Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessJoin target 6LoWPAN radio link/mesh
-
ExploitCraft undersized malformed fragment
-
ExecutionTrigger OOB read in gnrc_sixlowpan_frag_recv()
-
ImpactDisclose memory and crash network stack
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Target must run RIOT 2026.07 or earlier with the GNRC network stack and 6LoWPAN SFF fragment handling path active (sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c _receive() routing into gnrc_sixlowpan_frag_recv()), and must process inbound 6LoWPAN fragments. No authentication or user interaction is required (PR:N/UI:N), and the malformed undersized fragment triggers the flaw against default fragment-handling behavior. The principal limiting factor is delivery: because 6LoWPAN rides on IEEE 802.15.4 radio, the attacker must be within radio range of the node or able to inject/route fragments into its mesh - not reachable from an arbitrary remote host unless a border router forwards attacker-controlled fragments inward. |
| Impact | The reporter-supplied CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H, base 8.2) describes a low-complexity, unauthenticated flaw whose dominant impact is availability (A:H - crashing the GNRC network stack) with secondary limited memory disclosure (C:L), consistent with the CWE-125 out-of-bounds read. One key signal conflicts with the data: the vector claims AV:N (network), but 6LoWPAN is an IEEE 802.15.4 link-layer adaptation, so in practice an attacker must inject frames onto the target's low-power wireless link or routed mesh - closer to AV:A (adjacent) - which lowers real-world reachability from arbitrary Internet hosts; verify exposure against the specific deployment's border router/gateway configuration. No EPSS score, CISA KEV entry, POC, or SSVC decision data was provided, so there is no evidence of active or probable exploitation - this is a disclosed-but-not-yet-weaponized defect. Risk is elevated by the absence of a fixed repository release (only an unmerged/merged fix PR exists) and the ease of triggering a stack crash, but tempered by RIOT's niche embedded footprint and the link-local nature of 6LoWPAN. Net: a credible denial-of-service (and minor info-leak) priority for organizations actually running RIOT 6LoWPAN nodes, not a broad-impact emergency. |
| Exploit ScenarioDerived | An attacker within radio range of, or able to route 6LoWPAN frames to, a RIOT 2026.07-or-earlier IoT node sends a malformed, undersized 6LoWPAN fragment. The GNRC stack passes it into SFF fragment handling after only a minimal payload check and interprets it as a sixlowpan_frag_t header without confirming the snip holds the required bytes, causing gnrc_sixlowpan_frag_recv() to read beyond the packet buffer - leaking adjacent memory and crashing the network stack. No public exploit is identified, though the fix commit (0cae205) discloses the exact missing bounds check. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Malformed 6LoWPAN fragments can drive an out-of-bounds read in the GNRC network stack of RIOT OS 2026.07 and earlier, crashing the stack and potentially exposing adjacent memory. The flaw sits in _receive() in sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c, which forwards an undersized packet into SFF fragment handling after only a minimal payload check, so gnrc_sixlowpan_frag_recv() then interprets bytes as a sixlowpan_frag_t (or larger fragment header) that the packet snip does not actually contain. Exploitation requires no authentication or user interaction (PR:N/UI:N) and, per this assessment, is bounded by delivery: because 6LoWPAN rides on IEEE 802.15.4, the attacker must be within radio range of the node or able to inject fragments into its mesh (AV:A, assessed vector CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H; the reporter's AV:N/8.2 rating assumes arbitrary remote reachability that is not generally available unless a border router forwards attacker-controlled fragments inward). Availability is the dominant impact (A:H - crash of the GRNC network stack), with limited secondary memory disclosure (C:L); no public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
No vendor-tagged fixed release is available at time of analysis; the authoritative fix is the upstream change set published as PR https://github.com/RIOT-OS/RIOT/pull/22504 and commit https://github.com/RIOT-OS/RIOT/commit/0cae205cd1d110e0b8fce094714598322d56ce2d, which adds sixlowpan_frag_is_snip() to sys/include/net/gnrc/sixlowpan.h and switches the _receive() call site in sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c to it, enforcing snip->size >= sizeof(sixlowpan_frag_t) (and >= sizeof(sixlowpan_frag_n_t) for fragment-N headers) before any fragment header is dereferenced; apply this commit or cherry-pick its equivalent into any RIOT 2026.07-or-earlier tree, and track https://github.com/RIOT-OS/RIOT/security/advisories/GHSA-m8mc-q4p7-p8j3 for a tagged release. Where patching is not yet possible, the effective compensating control is to remove the exposure surface: disable 6LoWPAN selective fragment forwarding / the GNRC fragment-forwarding module in the build (for example by turning off the SFF/fragment-forwarding Kconfig option and its dependent modules) so that gnrc_sixlowpan_frag_recv() is no longer reachable from _receive(), at the cost of losing multi-hop fragment forwarding and reducing range for large datagrams; alternatively, filter undersized or malformed 6LoWPAN fragments at the mesh border router before they are forwarded inward, which requires border-router firmware changes and can drop legitimate fragments if the size threshold is set too aggressively. Because delivery is over IEEE 802.15.4, physically limiting radio range and avoiding untrusted mesh peers reduces the practical attack surface but does not substitute for patching, and RF shielding is impractical in most deployments.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
RIOT is an open-source operating system for microcontrollers and embedded IoT devices, and this defect lives in its GNRC IPv6/6LoWPAN network stack. CWE-125 (out-of-bounds read) is the root-cause class: the receive path in sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c calls sixlowpan_frag_is((sixlowpan_frag_t *)dispatch) on a packet whose buffered payload may be shorter than sizeof(sixlowpan_frag_t), because _receive() performs only a minimal payload-length check before routing the packet into Selective Fragment Forwarding (SFF) handling. gnrc_sixlowpan_frag_recv() subsequently dereferences the buffer as a sixlowpan_frag_t (or a larger sixlowpan_frag_n_t variant), reading beyond the allocated gnrc_pktsnip_t data region. The upstream fix introduces sixlowpan_frag_is_snip() in sys/include/net/gnrc/sixlowpan.h, which first rejects any snip whose size is below sizeof(sixlowpan_frag_t) and, when the dispatch byte identifies the fragment-N form, additionally requires snip->size >= sizeof(sixlowpan_frag_n_t) before interpreting it as a fragment header; the vulnerable call site is changed from checking the raw dispatch pointer to checking the sized snip. In practical deployments the affected code is exercised only on nodes that enable the GNRC 6LoWPAN SFF fragment-forwarding path and actually process inbound fragments; the CPE cpe:2.3:a:riot-os:riot:*:*:*:*:*:*:*:* matches all RIOT releases through 2026.07.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
6LoWPAN frames arrive over the 802.15.4 link so AV:A (not AV:N); unauthenticated malformed fragment (PR:N/UI:N/AC:L); over-read leaks limited memory (C:L) and crashes the stack (A:H), no integrity impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
RIOT is an open-source microcontroller operating system designed for Internet of Things devices and other embedded systems. In 2026.07 and earlier, _receive() in sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c can route an undersized packet into SFF fragment handling after only a minimal payload check. The code then interprets the packet as a sixlowpan_frag_t or larger fragment header without verifying that the packet snip contains the required bytes. A remote attacker can send a malformed 6LoWPAN fragment that causes gnrc_sixlowpan_frag_recv() to read beyond the packet buffer, potentially disclosing memory and crashing the network stack. No fixed repository release is available as of this review.
Technical POC Analysis
Evidence base: GitHub Security Advisory GHSA-m8mc-q4p7-p8j3 only.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
RIOT OS 2026.07 and earlier are affected by a high-severity, unauthenticated flaw in the GNRC 6LoWPAN stack that can crash affected nodes and potentially expose adjacent memory. An attacker within IEEE 802.15.4 radio range could disrupt mesh/IoT operations, and no vendor-released patch has been identified at time of analysis. Leadership should prioritize because these devices often support critical sensing and control networks, and mitigation depends on segmentation, radio-access restrictions, and border-router filtering until a fix is available.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict radio proximity to trusted devices, enforce IEEE 802.15.4 link-layer security, filter/drop malformed or undersized 6LoWPAN fragments at border routers, disable 6LoWPAN fragmentation if feasible, segment affected mesh/IoT networks, and monitor/restart nodes for crashes.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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)
EUVD-2026-95932
NVD
CVE.org
EPSS
GitHub
Exploit-DB