Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach target over network
-
DeliveryFlood ICMPv6 Packet Too Big to distinct destinations
-
ExploitFill IPv6 destination table
-
ExecutionApplication sends raw IPv6 (HDRINCL) to new off-link destination
-
PersistNULL pointer dereference in _nxd_bsd_ipv6_packet_send
-
ImpactSending thread crashes (denial of service)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Return value checking
|
| Exploitation Conditions | Requires a build with NX_BSD_ENABLE, NX_BSD_RAW_SUPPORT and FEATURE_NX_IPV6, where the application sends on an AF_INET6 raw socket with IP_RAW_IPV6_HDRINCL set. The destination must be off the link and not yet in the destination table, the default router's neighbour cache entry must be unknown (e.g. a router added via nxd_ipv6_default_router_add that never sent a Neighbor Advertisement, or whose cache entry was deleted), and the destination table must be full (or the neighbour cache unable to take the next hop). A remote sender can fill the table with ICMPv6 Packet Too Big messages only when NX_ENABLE_IPV6_PATH_MTU_DISCOVERY is enabled; otherwise the table fills from the device's own traffic to distinct off-link destinations. Limiting factors: exploitation is gated on the application's own non-default raw-socket sending behaviour and on an unresolved default router - conditions the remote attacker does not control (hence AT:P) - so this is not reliably triggerable against an arbitrary default configuration. |
| Impact | Signals point to a real but bounded denial-of-service issue, not a top-tier emergency. The vendor CVSS 4.0 base score is 8.2 (High), but the impact metrics are strictly availability (VA:H with VC:N/VI:N) - there is no confidentiality or integrity exposure and no code execution; the worst outcome is a crash of the thread sending on the raw socket. The vector carries AT:P (attack requirements present), and the advisory explains why: the crash also needs the application itself to send a raw IPv6 packet with its own header to a new off-link destination while the default router is unresolved, and the remote sender controls none of that - so a lone attacker cannot deterministically trigger it without favourable local conditions. No EPSS score is provided in the input and the CVE is not in CISA KEV, so there is no evidence of active exploitation; the vuln.today decision label is 'this_week', consistent with scheduled remediation rather than act_now/emergency. There is no standalone public exploit in the input, though the Eclipse advisory describes a working regression-test reproducer in the dev branch. Net: a genuine fixable DoS worth patching on a normal priority cycle, materially de-rated from its headline 8.2 by the DoS-only impact and the attacker-uncontrolled trigger conditions. |
| Exploit ScenarioDerived | On a NetX Duo device built with BSD raw-socket and IPv6 support and running an application that sends raw IPv6 packets (IP_RAW_IPV6_HDRINCL) to off-link destinations through a default router that has not been resolved, a remote sender floods the device with ICMPv6 Packet Too Big messages quoting distinct destinations (requires NX_ENABLE_IPV6_PATH_MTU_DISCOVERY) to fill the IPv6 destination table. The next time the application sends a raw IPv6 packet to a new off-link destination, the send path dereferences a NULL destination-table entry and the sending thread crashes (observed as SIGSEGV on the ThreadX Linux port). The Eclipse advisory includes a regression test that reproduces the SIGSEGV 5 of 5 times without the fix; no separate weaponized public exploit is indicated in the input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Denial of service in Eclipse ThreadX NetX Duo 6.0 through 6.5.2.202603a: the BSD raw IPv6 send path adds a destination-table entry and then reads that entry without first checking whether the add succeeded, so when the table is full and an off-link destination is reached through a default router whose neighbour cache entry is unknown, a NULL entry is dereferenced and the sending thread crashes. The defect is only reachable in builds that enable NX_BSD_ENABLE, NX_BSD_RAW_SUPPORT and FEATURE_NX_IPV6 where the application itself sends on an AF_INET6 raw socket with IP_RAW_IPV6_HDRINCL set, and only while the default router is unresolved - preconditions a remote sender does not control. A remote party can fill the destination table only if NX_ENABLE_IPV6_PATH_MTU_DISCOVERY is compiled in (32 crafted ICMPv6 Packet Too Big messages quoting distinct destinations were measured to do it); otherwise the table fills from the device's own outbound traffic to distinct off-link destinations. Unauthenticated (PR:N in both the vendor CVSS 4.0 vector and the assessed 3.1 vector) with high attack complexity and present attack requirements; no public exploit code was identified at time of analysis.
RemediationAI
Vendor-released patch: NetX Duo 6.5.2.202603b. The fix tests the status before using the entry (if((status == NX_SUCCESS) && (!NDCacheEntry)) ...), so a failed add falls through to the existing status check, which releases the packet; there are no public API changes and applications require no source change, so upgrading the stack is the complete fix. Where upgrading immediately is not possible, the vendor-documented workarounds are: stop sending raw IPv6 packets with IP_RAW_IPV6_HDRINCL to off-link destinations (application behaviour change, removes the affected code path but may break designs relying on header-included raw sends); build the stack without NX_BSD_RAW_SUPPORT (eliminates the vulnerable function entirely, at the cost of losing BSD raw socket support including any legitimate raw-socket use); and increasing NX_IPV6_DESTINATION_TABLE_SIZE, which only raises the number of destinations an attacker or the device's own traffic must reach and does not remove the defect - it also consumes additional static memory on a constrained embedded target. Note that under NX_ENABLE_IPV6_PATH_MTU_DISCOVERY a remote sender on the router's link-local segment can fill the table with ICMPv6 Packet Too Big messages quoting distinct destinations, so the table-size workaround is weak in that configuration. The advisory is at https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-9w9h-x3fh-m3fp.
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
NetX Duo is Eclipse ThreadX's embedded IPv6/IPv4 TCP/IP stack. Its IPv6 transmit path keeps a destination table (sized by NX_IPV6_DESTINATION_TABLE_SIZE) mapping next-hop destinations to neighbour cache entries, populated by _nx_icmpv6_dest_table_add, which returns NX_NOT_SUCCESSFUL and sets the returned entry pointer to NX_NULL when the table has no free slot or when no neighbour cache entry can be created for the next hop. In _nxd_bsd_ipv6_packet_send - the path used when an application writes a complete IPv6 packet, header included, to a BSD raw socket - the code calls _nx_icmpv6_dest_table_add, then, if the router lookup produced no neighbour cache entry, immediately reads dest_entry_ptr->nx_ipv6_destination_entry_nd_entry before testing the returned status, which is only checked four lines later. The root cause class is CWE-252 (unchecked return value), which manifests as CWE-476 (NULL pointer dereference). The equivalent block in the core IPv6 send path _nx_ipv6_packet_send, and the on-link branch of this same function, both test the status first, so this is an ordering defect specific to the raw-socket off-link branch. Reaching it requires the destination to be off-link and absent from the table, the default router's neighbour cache entry to be NULL (typically a router installed via nxd_ipv6_default_router_add that has never sent a Neighbor Advertisement, or whose entry the neighbour cache deleted), and the table add to fail. Consequence on the ThreadX Linux port is SIGSEGV in the sending thread; on other targets the effect depends on what is mapped at the offset of nx_ipv6_destination_entry_nd_entry from address 0, and where that memory is readable the value read there is then used as the neighbour cache entry for the send. The supplied CPE cpe:2.3:a:eclipse_foundation:eclipse_threadx:*:*:*:*:*:*:*:* carries a wildcard version, so the authoritative affected range comes from the GitHub advisory: 6.0 through 6.5.2.202603a.
Know when Eclipse Threadx 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:H/SC:N/SI:N/SA:N
Remote sender fills the table (AV:N) but the crash also needs attacker-uncontrolled app sending and an unresolved router, so AC:H; no auth (PR:N), DoS-only availability impact (A:H), no scope change.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse ThreadX NetX Duo versions 6.0 through 6.5.2.202603a, built with BSD raw socket and IPv6 support, the IPv6 raw send path uses the destination-table entry it adds without checking that the add succeeded. When the destination table is full and an off-link destination is reached through a default router whose neighbour cache entry is unknown, sending on an IPv6 raw socket with header inclusion dereferences a NULL pointer; a remote sender can fill the table, for example with ICMPv6 Packet Too Big messages, and crash the sending thread.
Technical POC Analysis
CWE-252 (Unchecked Return Value), with the resulting fault classified as CWE-476 (NULL Pointer Dereference).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Eclipse ThreadX NetX Duo 6.0 through 6.5.2.202603a contains a high-severity denial-of-service flaw in its IPv6 raw socket send path that can crash the sending thread under specific build configurations and conditions. This vulnerability matters to leadership because affected devices-typically embedded and IoT products-could experience unexpected outages, leading to operational disruption and potential customer impact if an attacker triggers the crash. However, exploitation requires multiple preconditions and is not straightforward, making the immediate organizational risk targeted rather than widespread.
Apply vendor patch.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Eclipse Threadx
View allDenial of service in the Eclipse ThreadX NetX Duo NetX Secure DTLS server (versions 6.0 through 6.5.2.202603a) lets remo
A NULL pointer dereference in the Eclipse ThreadX NetX Duo IPv6 stack lets an unauthenticated sender on the network cras
Privilege escalation in the Eclipse ThreadX Module Manager (versions 6.0.1 through 6.5.2.202603) lets a user-mode, memor
Eclipse ThreadX's Cortex-A7 MMU module port accepts a caller-supplied buffer range after validating only its first byte,
Eclipse ThreadX firmware built with Module Manager and loadable modules enabled contains a use-after-free in txm_module_
Use-after-free in Eclipse ThreadX Modules (6.0.1 through 6.5.2.202603) leaves a user-mode module's trace-buffer-full cal
Out-of-bounds write in the Cortex-M module ports of Eclipse ThreadX 6.0.1 through 6.5.2.202603 lets a user-mode, memory-
Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corr
The Eclipse ThreadX Module Manager fails to enforce thread ownership in its thread-control dispatchers, so a loaded user
A crafted ThreadX module can permanently hang the entire kernel by abusing the Module Manager's object-lookup path: the
Eclipse ThreadX deployments that use the Module Manager to load untrusted or mixed-trust modules let a module destroy ke
Eclipse ThreadX 6.0.1 through 6.5.2.202603 can be left with its Module Manager permanently deadlocked: when a module pre
EUVD-2026-115644
NVD
CVE.org
EPSS
GitHub
Exploit-DB