Skip to main content

RIOT OS CVE-2026-107837

| EUVDEUVD-2026-95932 HIGH
Out-of-bounds Read (CWE-125)
2026-10-09 GitHub_M
8.2
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Join target 6LoWPAN radio link/mesh
  2. Exploit
    Craft undersized malformed fragment
  3. Execution
    Trigger OOB read in gnrc_sixlowpan_frag_recv()
  4. Impact
    Disclose 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

RIOT ≤ 2026.07

Affected Packages

euvd riot no fix

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

Vendor (GitHub_M) PRIMARY 8.2 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
vuln.today AI 7.1 HIGH

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.

3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
4.0 AV:A/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
High

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Low
niche open-source IoT/embedded OS, limited production footprint
Social Media
2
Sightings
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

41
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Riot

View all
CVE-2023-33975 CRITICAL POC
9.8 May 30

RIOT-OS, an operating system for Internet of Things (IoT) devices, contains a network stack with the ability to process

CVE-2019-1000006 CRITICAL POC
9.8 Feb 04

RIOT RIOT-OS version after commit 7af03ab624db0412c727eed9ab7630a5282e2fd3 contains a Buffer Overflow vulnerability in s

CVE-2026-25139 CRITICAL POC
9.1 Feb 04

RIOT IoT operating system has an out-of-bounds read vulnerability (CVSS 9.1) that could lead to information disclosure o

CVE-2024-32018 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-32017 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-31225 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-52802 HIGH POC
7.5 Nov 22

RIOT is an operating system for internet of things (IoT) devices. Rated high severity (CVSS 7.5), this vulnerability is

CVE-2023-24818 HIGH POC
7.5 Apr 24

RIOT-OS, an operating system that supports Internet of Things devices, contains a network stack with the ability to proc

CVE-2019-16754 HIGH POC
7.5 Sep 24

RIOT 2019.07 contains a NULL pointer dereference in the MQTT-SN implementation (asymcute), potentially allowing an attac

CVE-2019-15702 HIGH POC
7.5 Aug 27

In the TCP implementation (gnrc_tcp) in RIOT through 2019.07, the parser for TCP options does not terminate on all input

CVE-2019-15134 HIGH POC
7.5 Aug 17

RIOT through 2019.07 contains a memory leak in the TCP implementation (gnrc_tcp), allowing an attacker to consume all me

CVE-2024-53980 MEDIUM POC
6.9 Nov 29

RIOT is an open-source microcontroller operating system, designed to match the requirements of Internet of Things (IoT)

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy