Eclipse NetXDuo CVE-2025-55086
MEDIUMAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain adjacent/on-link network position
-
DeliveryAwait or trigger device DHCPv6 solicit
-
ExploitSend crafted DHCPv6 reply with malformed server DUID
-
ExecutionTrigger out-of-bounds read in DUID parsing
-
ImpactFault or crash NetXDuo 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 | Exploitation requires that the NetXDuo application has the DHCPv6 client enabled and in use, and that the attacker can deliver a crafted DHCPv6 server reply - i.e., operate as a rogue DHCPv6 server or man-in-the-middle on the same local link, since DHCPv6 is link-local (multicast ff02::1:2). The specific trigger is the unchecked index used when extracting the server DUID from the server's reply packet. Limiting factors: the device must be actively soliciting/processing DHCPv6 replies (CVSS AT:P reflects this state requirement), the attacker needs on-link or on-path positioning rather than arbitrary Internet reachability, and impact is bounded to a memory over-read (crash/fault) with no confidentiality impact per the vendor vector. Devices not using the DHCPv6 client are unaffected. |
| Impact | This is a medium-severity (CVSS 6.3) out-of-bounds read (CWE-125) in the NetXDuo DHCPv6 client, and the signals converge on real-but-moderate risk rather than an urgent priority. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) rates it unauthenticated with low complexity but notes Attack Requirements Present (AT:P), reflecting that the attacker must act as the DHCPv6 responder to a soliciting client - a meaningful constraint. Impact is capped at low integrity and low availability (VI:L/VA:L) with explicitly no confidentiality impact (VC:N), so the vendor scoped this as a crash/memory-fault condition rather than data exfiltration. The EPSS score is low (0.41%, 34th percentile), there is no CISA KEV listing, and no public exploit code was identified, so exploitation is neither confirmed nor imminent. CONFLICT TO NOTE: the input Tags include 'Information Disclosure' and the CWE is an OOB read, yet the vendor CVSS sets confidentiality to N - treat the information-disclosure framing as unverified against the vendor's own impact scoring. Additionally, the vendor set AV:N, but DHCPv6 is inherently a link-local protocol, so a network-wide (Internet-facing) attack is unlikely without an on-path or on-link position - verify the realistic attack surface against your deployment topology. |
| Exploit ScenarioDerived | An attacker on the same local link (or a rogue/MITM DHCPv6 server) waits for or induces a NetXDuo device to solicit a DHCPv6 lease, then returns a crafted reply whose server DUID field drives an unchecked index, triggering an out-of-bounds memory read. The result is most likely a device crash or fault in the embedded TCP/IP stack. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 08, 2026
An out-of-bounds read (CWE-125) in the DHCPv6 client of Eclipse NetXDuo before 6.4.4 is triggered when the client parses the server DUID from a reply packet using an unchecked index, allowing a crafted DHCPv6 server response to force an out-of-memory read that can fault or crash the device. Affected deployments are those running NetXDuo with the DHCPv6 client enabled and actively soliciting or processing DHCPv6 replies; because DHCPv6 is link-local, an attacker must operate as a rogue DHCPv6 server or man-in-the-middle on the same local segment rather than reach the target over the open Internet. This is rated medium severity (CVSS 6.3, and an independent assessment of CVSS 3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L), EPSS is low at 0.41% (34th percentile), no CISA KEV listing exists, and no public exploit code has been identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade Eclipse NetXDuo to version 6.4.4 or later, which is the first release containing the bounds check for the server DUID index in the DHCPv6 client; the fix and affected-range details are documented in advisory GHSA-99pw-cp79-2j5j (https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-99pw-cp79-2j5j). If NetXDuo is vendored inside a SoC or RTOS vendor SDK, do not assume the upstream fix propagates automatically - request a patched SDK/firmware from the silicon or OEM vendor, or backport the DUID length check manually and rebuild the firmware. If an immediate upgrade is not possible, the highest-value compensating control is to disable the DHCPv6 client and use SLAAC/stateless address autoconfiguration instead, at the cost of losing DHCPv6-provided options such as DNS servers and prefix delegation, so this only works where those options are not required. Network-side, DHCPv6 has no built-in authentication, so deploy DHCPv6-Shield (RFC 7610) or equivalent Layer-2 port ACLs that permit DHCPv6 server traffic only from authorized server ports; this blocks the rogue-server and on-link MITM positions the exploit requires, but it must be configured on every access switch and does nothing against an attacker already inside an authorized server segment. Because the trigger is a memory over-read that typically ends in a fault/reset, enabling watchdog-based automatic recovery is a useful containment measure but does not remove the underlying bug.
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
NetXDuo is the IPv4/IPv6 networking stack shipped as part of the Eclipse ThreadX (formerly Azure RTOS) family of embedded real-time operating systems, and the vulnerable component is its DHCPv6 client, which obtains IPv6 addressing from a DHCPv6 server via multicast on ff02::1:2. As part of processing a server reply, the client extracts the server's DUID (the DHCP Unique Identifier used to distinguish servers) using an index value taken from the incoming packet without bounds checking; because the index is not validated against the actual length of the reply buffer, an attacker-supplied packet can drive the read past the end of the allocated buffer. This is the classic CWE-125 out-of-bounds read class: the immediate consequence is reading adjacent memory, which on a memory-protected or MPU-guarded embedded target typically manifests as a fault/reset (availability impact, A:L in the assessed vector) rather than a controllable disclosure, and the vendor-supplied CVSS 4.0 vector (VC:N/VI:L/VA:L with AT:P) and the independent 3.1 assessment (C:N/I:N/A:L) both bound the realistic impact to denial of service with no confirmed confidentiality loss. The CPE entry cpe:2.3:a:eclipse:threadx_netx_duo:*:*:*:*:*:*:*:* does not constrain a version, meaning every shipping release prior to the 6.4.4 fix is potentially affected, which is significant because NetXDuo is commonly vendored into SoC vendor SDKs and may be many revisions behind upstream. The 'Buffer Overflow' and 'Information Disclosure' tags attached to this CVE reflect the read-primitive nature of the bug, but the authoritative impact remains bounded to availability/crash as described above.
Know when Threadx Netx Duo 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:L/VA:L/SC:N/SI:N/SA:N
DHCPv6 is link-local so AV:A not AV:N; AC:L as crafting the reply is trivial; PR:N since no auth; OOB read yields a crash (A:L) with no confidentiality or integrity change.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In NetXDuo version before 6.4.4, a networking support module for Eclipse Foundation ThreadX, in the DHCPV6 client there was an unchecked index extracting the server DUID from the server reply. With a crafted packet, an attacker could cause an out of memory read.
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.
Affected Products (CPE)CVE.org
More in Threadx Netx Duo
View allOut-of-bounds reads in the Eclipse ThreadX NetX Duo HTTP client module (all versions before 6.4.4) let a malicious, comp
In Eclipse ThreadX NetX Duo before 6.4.0, if an attacker can control parameters of __portable_aligned_alloc() could caus
A denial-of-service vulnerability exists in the NetX IPv6 component functionality of Eclipse ThreadX NetX Duo. A special
In NetX HTTP server functionality of Eclipse ThreadX NetX Duo before version 6.4.3, an attacker can cause a denial of se
In NetX HTTP server functionality of Eclipse ThreadX NetX Duo before version 6.4.2, an attacker can cause a denial of se
An out-of-bounds read (CWE-125) in Eclipse ThreadX NetX Duo before 6.4.4 allows remote, unauthenticated attackers to rea
An out-of-bounds read in Eclipse ThreadX NetX Duo (all versions before 6.4.4) is triggered in the _nx_ip_packet_receive(
An out-of-bounds read in Eclipse NetX Duo's IPv4 receive path (_nx_ipv4_packet_receive()) can be triggered by delivering
Out-of-bounds read in Eclipse ThreadX NetX Duo before 6.4.4 allows unauthenticated remote attackers to trigger a limited
An out-of-bounds read in Eclipse NetX Duo before 6.4.4 allows remote, unauthenticated attackers to disclose small amount
An out-of-bounds memory read exists in Eclipse ThreadX NetX Duo's secure TLS module (all versions before 6.4.4) due to a
Out-of-bounds read in Eclipse ThreadX NetX Duo (all versions before 6.4.4) lets an attacker who can deliver DHCP traffic
NVD
CVE.org
EPSS
GitHub
Exploit-DB