Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain on-link DHCPv6 server position
-
ExploitSend REPLY with undersized IA_PD option
-
ExecutionTrigger size_t underflow in _parse_ia_pd_option
-
ImpactOut-of-bounds heap read crashes device
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 | Requires that the RIOT firmware be built with MODULE_DHCPV6_CLIENT_IA_PD (DHCPv6 prefix delegation) enabled and that the device operate as a DHCPv6 client; the attacker must control, compromise, or spoof a DHCPv6 server reachable on the same local link, then send a REPLY whose IA_PD (or IA_NA) option length is smaller than sizeof(dhcpv6_opt_ia_pd_t)/dhcpv6_opt_ia_na_t, defeating the absent minimum-length check in _parse_reply(). Limiting factors: DHCPv6 is link-local (adjacent network, not arbitrary Internet remote despite AV:N); the IA_PD code path is a compile-time option not present in all builds; and exploitation presumes a rogue or hijacked DHCPv6 server on-link rather than a wholly unauthenticated Internet attacker. |
| Impact | The input assigns CVSS 3.1 9.8 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H), but several signals temper the real-world urgency. There is no EPSS score, no CISA KEV listing, and no public exploit in the provided data, so exploitation status is 'no public exploit identified at time of analysis.' Two factors conflict with the Critical rating: (1) DHCPv6 is a link-local multicast protocol, so the attacker must sit on the same L2 segment as the client or compromise its DHCPv6 server - this is adjacent-network reality despite the vector claiming AV:N, verify network exposure before treating this as remotely Internet-reachable; and (2) the root weakness is CWE-125 out-of-bounds READ, which primarily yields a crash (DoS) and possible memory disclosure, so the C:H/I:H combination in the input looks overstated - integrity impact in particular is speculative ('may ... corrupt memory'). Exploitation is further gated on MODULE_DHCPV6_CLIENT_IA_PD (prefix delegation) being compiled in, which is not a universal default. Net: a genuine, patch-worthy memory-safety bug for IoT fleets running RIOT with DHCPv6-PD on untrusted links, but the 9.8 overstates likely blast radius for most deployments. |
| Exploit ScenarioDerived | An attacker who controls or has compromised a DHCPv6 server on the local link (or who can race/spoof one) sends a crafted REPLY containing an IA_PD or IA_NA option whose declared length is smaller than the minimum structure. A RIOT device built with MODULE_DHCPV6_CLIENT_IA_PD parses the undersized option, underflows a size_t length, and performs unbounded out-of-bounds heap reads - crashing the device and potentially leaking adjacent heap memory. No public proof-of-concept is identified in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 16, 2026
Out-of-bounds heap reads in the RIOT OS DHCPv6 client (sys/net/application_layer/dhcpv6/client.c) let an attacker who controls, compromises, or spoofs a DHCPv6 server on the same local link crash an embedded device - and potentially expose or corrupt adjacent heap memory - by sending a REPLY whose IA_PD or IA_NA option body is shorter than the structure it is parsed as. Exploitation requires firmware built with MODULE_DHCPV6_CLIENT_IA_PD enabled and the device operating as a DHCPv6 client; no public exploit code was identified at time of analysis, and the issue is fixed in RIOT 2026.07. The upstream 9.8 score (AV:N/C:H/I:H/A:H) is tempered by DHCPv6's link-local scope and the compile-time gating of the vulnerable code path, consistent with the independent assessment of CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H.
RemediationAI
Vendor-released patch: 2026.07. Upgrade RIOT OS to release 2026.07 (https://github.com/RIOT-OS/RIOT/releases/tag/2026.07), or cherry-pick the upstream fix commit c9830dc5f2a9bf97418de4fc7d7167d00a45df17 from pull request https://github.com/RIOT-OS/RIOT/pull/22322, which adds _opt_len() minimum-size checks before the IA_PD and IA_NA sub-parsers are invoked; see advisory https://github.com/RIOT-OS/RIOT/security/advisories/GHSA-p3fx-9qcg-jmcf for the vendor statement. If an immediate firmware update is not possible, the most effective compensating control is to remove MODULE_DHCPV6_CLIENT_IA_PD (and, where not required, the DHCPv6 client IA_NA path) from the build configuration so the vulnerable parsing code is not compiled in - at the cost of losing DHCPv6 prefix delegation and dynamic IPv6 address assignment, which means affected devices must be given statically configured addresses or use SLAAC instead. Additional risk reduction comes from treating the access link as a trust boundary: enforce DHCPv6 snooping or port-level filtering on managed switches so only authorized DHCPv6 servers can answer clients on the segment, which blunts the spoofed-server prerequisite but does not help on unmanaged or physically exposed links, and does not fix devices already running a vulnerable build. Because the trigger is a malformed REPLY rather than random traffic, network monitoring that flags DHCPv6 options declaring lengths shorter than their fixed structures can serve as a detection backstop, and watchdog/reset logic on devices mitigates the availability impact of a crash without addressing the memory-disclosure possibility. Note that these controls are compensating measures only; RIOT 2026.07 is the definitive fix, and no vendor-released patch was identified for versions prior to 2026.07 other than that release.
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
DHCPv6 (RFC 8415) encodes every option as a TLV: a 2-byte option code, a 2-byte length, then the option body. The client in RIOT OS parses server REPLY messages in _parse_reply() in sys/net/application_layer/dhcpv6/client.c, dispatching IA_PD (identity association for prefix delegation) and IA_NA (identity association for non-temporary addresses) bodies to _parse_ia_pd_option() and _parse_ia_na_option(). Because _parse_reply() cast the raw option body to dhcpv6_opt_ia_pd_t / dhcpv6_opt_ia_na_t without first verifying that the declared option length was at least sizeof() the corresponding structure, a malicious server could declare a length smaller than the required structure and drive the sub-parsers past the end of the option body, producing a size_t underflow and unbounded out-of-bounds heap reads. This is a classic CWE-125 (out-of-bounds read) rooted in missing input-length validation on a link-local network protocol. The upstream fix (PR #22322, commit c9830dc5f2a9bf97418de4fc7d7167d00a45df17) inserts explicit _opt_len(opt) < sizeof(dhcpv6_opt_ia_pd_t) and _opt_len(opt) < sizeof(dhcpv6_opt_ia_na_t) checks in _parse_reply() that log a debug message and return false, rejecting the malformed REPLY before the sub-parsers run. The CPE cpe:2.3:a:riot-os:riot:*:*:*:*:*:*:*:* denotes all RIOT OS releases before 2026.07; the vulnerable code path is only compiled in when the DHCPv6 prefix-delegation/address client modules are enabled, so many sensor and actuator builds are unaffected.
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:H/I:H/A:H
DHCPv6 is link-local so AV:A not AV:N; no auth needed (PR:N); out-of-bounds read yields crash (A:H) and at most partial memory disclosure (C:L), with integrity unaffected (I:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
RIOT is an open-source microcontroller operating system designed for Internet of Things devices and other embedded systems. Prior to 2026.07, _parse_reply() in sys/net/application_layer/dhcpv6/client.c omits minimum-length validation before passing IA_PD and IA_NA option bodies to sub-option parsers. A malicious or compromised DHCPv6 server can send a REPLY with an option length smaller than the required structure while MODULE_DHCPV6_CLIENT_IA_PD is enabled, causing _parse_ia_pd_option to read past the option body, size_t underflow, and unbounded out-of-bounds heap reads that can crash the device and may expose or corrupt memory. This issue is fixed in version 2026.07.
Technical POC Analysis
CWE-125 Out-of-bounds Read, with a secondary CWE-191 Integer Underflow/Wraparound.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A memory-safety flaw in the DHCPv6 client of RIOT OS, an open-source operating system used across embedded and IoT device fleets, lets an attacker who controls, compromises, or spoofs a DHCPv6 server on the same local network segment crash affected devices and potentially expose or corrupt adjacent heap memory. The exposure is narrow but operationally sharp: it applies only to firmware built with the optional IA_PD client module and only from the local link, meaning a single rogue or compromised network gateway could cause simultaneous, repeatable outages across every qualifying device on that segment. Leadership should care because the flaw offers no public exploit path today, yet it carries a critical severity rating, an unauthenticated attack vector, and a high availability impact, and the fix is only present in the RIOT 2026.07 release, leaving currently deployed firmware lines exposed until an upgrade is planned and executed.
No vendor-released patch is available for currently deployed firmware; the fix is present only in the RIOT 2026.07 release, so interim mitigations are required until upgrade. Rebuild affected firmware with MODULE_DHCPV6_CLIENT_IA_PD disabled where IA_PD support is not operationally required. Where it is required, enforce link-layer controls on every affected segment - DHCPv6 snooping, 802.1X port authentication, MAC-based port security, and static IPv6 addressing or prefix delegation where feasible - to prevent a rogue, spoofed, or compromised DHCPv6 server from reaching clients. Segment affected embedded devices away from general user and guest networks, monitor for anomalous DHCPv6 REPLY traffic and unexpected device restarts, and plan migration to RIOT 2026.07 as the durable remediation.
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-102947
NVD
CVE.org
GitHub
Exploit-DB