RIOT OS
CVE-2025-66647
LOW
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach IPv6 stack of RIOT device
-
DeliverySend short offset=0 priming fragment
-
ExploitSend oversized offset=0 fragment
-
ExecutionOverflow reassembly buffer, corrupt adjacent buffers
-
ImpactCrash device or potential code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer copy size validation
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the firmware be built with the gnrc_ipv6_ext_frag module included (IPv6 extension-header fragment reassembly) - this is a non-default, build-time condition that significantly limits the exposed population. The attacker must be able to send arbitrary IPv6 packets to the victim (no authentication, per PR:N) and must perform a two-step sequence: first send a shorter fragment with offset=0 to force creation of an undersized reassembly buffer, then send a larger offset=0 fragment whose copy is not size-checked, overflowing the buffer. Affected version is RIOT v2025.07 (and 2025.10 release candidates rc1/rc2/rc3); the stable 2025.10 release is fixed. The required priming step is the attack requirement reflected as AT:P in the official vector. |
| Impact | Signals here point mostly in the low-to-moderate direction, with one internal conflict worth flagging. The official CVSS 4.0 vector scores only 1.7 (Low), modeling the impact as availability-only (VA:L) with no confidentiality or integrity effect and an attack requirement present (AT:P) - yet the description explicitly claims the buffer overflow 'corrupts the state of other packet buffers' and could be leveraged for 'further memory corruption (potentially resulting in remote code execution).' This is a direct conflict: the assigned score treats the flaw as a minor availability issue while the narrative describes a classic heap/buffer-corruption primitive with RCE potential - the RCE outcome is speculative ('might be able to', 'potentially') and not demonstrated, so it should not be treated as confirmed. EPSS is low at 0.97% (61st percentile), indicating no strong real-world exploitation pressure, and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation. Public exploit material is referenced via the GitHub Security Advisory (GHSA-wh3v-q6vr-j79r). Exposure is further gated: the vulnerable gnrc_ipv6_ext_frag module must be compiled into the firmware (not universal), and the attack requires a priming step (sending a short offset=0 fragment first). Net: this is a credible unauthenticated remote memory-corruption bug in affected RIOT builds, but given low EPSS, no KEV, a niche embedded OS, and a required non-default module, it is a moderate patch priority for RIOT operators rather than a broad emergency - reconcile the Low official score against the RCE claim with the vendor advisory before deprioritizing. |
| Exploit ScenarioDerived | An attacker with IPv6 reachability to a RIOT device running the gnrc_ipv6_ext_frag module first sends a short fragment with offset=0 to force allocation of an undersized reassembly buffer, then sends a larger offset=0 fragment whose contents are copied in without a size check, overflowing the buffer and corrupting adjacent packet buffers. Publicly available exploit material is referenced in the GitHub Security Advisory; exploitation is remote and unauthenticated but carries an attack requirement (AT:P) due to the required priming sequence. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Buffer overflow in RIOT OS's IPv6 fragment reassembly allows remote attackers to corrupt packet buffer state and potentially achieve further memory corruption. Affected versions include RIOT 2025.07 and 2025.10 release candidates rc1, rc2, and rc3; the stable 2025.10 release fixes the issue. Exploitation requires the non-default gnrc_ipv6_ext_frag module to be built into the firmware and the attacker to send arbitrary IPv6 packets in a two-step sequence - first a short offset=0 fragment to force an undersized reassembly buffer, then a larger offset=0 fragment whose copy is not size-checked. Publicly available exploit code exists, but EPSS is only 0.97% (61st percentile), and the build-time condition limits the exposed population; the independent assessment rates availability impact as high while noting no confirmed code execution.
RemediationAI
Upgrade to RIOT OS 2025.10 (stable), which contains the fix (release notes: https://github.com/RIOT-OS/RIOT/releases/tag/2025.10). Vendor-released patch: 2025.10. If upgrading is not immediately possible, the most direct compensating control is to rebuild firmware without the gnrc_ipv6_ext_frag module if IPv6 fragment reassembly is not a required feature - the trade-off is that the device will no longer reassemble fragmented IPv6 packets, which may break legitimate IPv6 traffic that relies on fragmentation. Blocking or filtering IPv6 fragments at the network boundary can reduce exposure but may be impractical in environments where fragmentation is normal and can be bypassed if the attacker has direct IPv6 reachability to the device. Restricting arbitrary IPv6 access to the affected device (for example, firewall rules permitting only trusted hosts) limits the attack surface. Consult the GitHub security advisory GHSA-wh3v-q6vr-j79r for vendor guidance.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is in RIOT's GNRC network stack, specifically the IPv6 extension-header fragmentation reassembly module gnrc_ipv6_ext_frag. Under CWE-120 (Buffer Copy without Checking Size of Input), when the first fragment (offset=0) is copied into the reassembly buffer, the code at gnrc_ipv6_ext_frag.c lines 411, 481, 532, and 544 fails to validate that the fragment length fits the buffer. An attacker can prime the reassembly state by sending a shorter offset=0 fragment, causing a smaller buffer to be allocated, and then send a larger offset=0 fragment that overflows it. The CPE data identifies RIOT OS 2025.07 and the 2025.10 release candidates (rc1, rc2, rc3) as affected; the module is not enabled by default in all builds, so only firmware configurations that include gnrc_ipv6_ext_frag are exposed. The crafted packets are unauthenticated IPv6 traffic (PR:N), and the required priming step corresponds to the attack requirement AT:P in the official CVSS 4.0 vector.
Know when Riot gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:U
Remote unauthenticated (AV:N/PR:N); AC:H because exploitation needs a priming short fragment to size the buffer; reliably achievable impact is memory-corruption-induced crash (A:H), while claimed RCE (C/I) is unproven so left N.
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
RIOT is an open-source microcontroller operating system, designed to match the requirements of Internet of Things (IoT) devices and other embedded devices. A vulnerability was discovered in the IPv6 fragmentation reassembly implementation of RIOT OS v2025.07. When copying the contents of the first fragment (offset=0) into the reassembly buffer, no size check is performed. It is possible to force the creation of a small reassembly buffer by first sending a shorter fragment (also with offset=0). Overflowing the reassembly buffer corrupts the state of other packet buffers which an attacker might be able to used to achieve further memory corruption (potentially resulting in remote code execution). To trigger the vulnerability, the gnrc_ipv6_ext_frag module must be included and the attacker must be able to send arbitrary IPv6 packets to the victim. Version 2025.10 fixes the issue.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)CVE.org
RIOT-OS, an operating system for Internet of Things (IoT) devices, contains a network stack with the ability to process
RIOT RIOT-OS version after commit 7af03ab624db0412c727eed9ab7630a5282e2fd3 contains a Buffer Overflow vulnerability in s
RIOT IoT operating system has an out-of-bounds read vulnerability (CVSS 9.1) that could lead to information disclosure o
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is an operating system for internet of things (IoT) devices. Rated high severity (CVSS 7.5), this vulnerability is
RIOT-OS, an operating system that supports Internet of Things devices, contains a network stack with the ability to proc
RIOT 2019.07 contains a NULL pointer dereference in the MQTT-SN implementation (asymcute), potentially allowing an attac
In the TCP implementation (gnrc_tcp) in RIOT through 2019.07, the parser for TCP options does not terminate on all input
RIOT through 2019.07 contains a memory leak in the TCP implementation (gnrc_tcp), allowing an attacker to consume all me
RIOT is an open-source microcontroller operating system, designed to match the requirements of Internet of Things (IoT)
NVD
CVE.org
EPSS
GitHub
Exploit-DB