Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSpoof many source address/port tuples
-
DeliverySend one short non-alert datagram per source
-
ExploitServer allocates pool session before cookie exchange
-
ExecutionStalled handshakes never released
-
PersistFixed session pool exhausted
-
ImpactLegitimate DTLS clients denied service
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the target to run the NetX Secure DTLS *server* role on an affected build (NetX Duo 6.0 through 6.5.2.202603a); DTLS clients are not affected, and the vulnerable allocation is in the common DTLS receive path with no build option gating it. Per PR:N/UI:N the attack is unauthenticated and needs no user interaction, and the attacker need not receive any reply, so source-address spoofing works directly. Effectiveness scales with the application-configured nx_dtls_server_sessions_count, which is fixed and typically small on embedded targets, so only a few forged datagrams are needed. Limiting factors: the server must expose the DTLS service to the attacker's network path; applications that reset or end stalled handshakes via nx_secure_dtls_session_reset()/nx_secure_dtls_session_end() within a chosen timeout bound the exposure (though not a mid-burst flood); and upstream ingress filtering against source-address forgery reduces reach. Impact is availability-only - confidentiality and integrity are unaffected. |
| Impact | This is a genuine but bounded availability risk, not an overhyped high-CVSS finding. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms a network-reachable, low-complexity, unauthenticated flaw requiring no user interaction and no attack-requirement preconditions - all signals that favor easy exploitation - while impact is strictly availability (VC:N/VI:N/VA:H, no confidentiality or integrity effect), consistent with a resource-exhaustion DoS (CWE-770/CWE-772). The vuln.today decision label is 'this_week' rather than act_now/emergency, which aligns with a service-denial impact on a specific embedded feature rather than code execution or data compromise. No EPSS score and no KEV listing are present in the input, and there is no confirmed public exploit code - the issue was found internally by an Eclipse researcher (Frédéric Desbiens) while reviewing a prior fix, and the only public artifacts are vendor advisories, not weaponized PoC. The low-friction exploitation path (one spoofed datagram per source, no reply needed) is partly offset by the fact that it only affects deployments that actually enable the NetX Secure DTLS server and that recovery is possible via application-level session reset. Net: real and worth patching promptly for anyone running the DTLS server, but it is a denial-of-service against an optional RTOS networking component, not a widespread critical-impact emergency. |
| Exploit ScenarioDerived | A remote, unauthenticated attacker sends a single UDP/DTLS datagram (at least a record header long, non-alert) from each of many forged source address/port tuples to a device running the NetX Secure DTLS server. Each unrecognized source causes the server to allocate a session from its small fixed pool before any cookie verification, and stalled handshakes are never reclaimed by the library, so a handful of spoofed packets exhausts the pool and locks out legitimate clients. No public exploit code is identified at time of analysis, though the low complexity (AC:L) and absence of required reply traffic make the attack trivial to script. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Denial of service in the Eclipse ThreadX NetX Duo NetX Secure DTLS server (versions 6.0 through 6.5.2.202603a) lets remote, unauthenticated attackers exhaust the application-configured session pool by sending one spoofed datagram per forged source address or port, locking legitimate DTLS clients out of service. Sessions are allocated before the HelloVerifyRequest cookie exchange and are never reclaimed by the library when a handshake stalls or times out, so the denial persists until the application resets the affected sessions and can last indefinitely if it never does. Confidentiality and integrity are unaffected; no public exploit code was identified at time of analysis, though the low session counts typical of embedded targets mean only a handful of forged datagrams are needed.
RemediationAI
Vendor-released patch: upgrade NetX Duo to 6.5.2.202603b, which answers an initial ClientHello from an unknown source with a stateless HelloVerifyRequest without allocating a session and only allocates (and calls connect_notify) once a valid cookie returns; applications can supply the cookie key via the new nx_secure_dtls_server_cookie_secret_set service, otherwise it is drawn from NX_RAND. If upgrading immediately is not possible, the vendor's documented workaround is to have the application bound exposure by resetting or ending any session whose handshake has not completed within an application-chosen timeout using nx_secure_dtls_session_reset() or nx_secure_dtls_session_end() - this releases slots held by forged sources but does not stop a burst of forged datagrams from filling the pool in the meantime, and aggressive timeouts may cut off legitimately slow or lossy handshakes. Ingress filtering against source-address forgery upstream of the device reduces reach but does not help once traffic is on the local network path. Details are in the advisory at https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-3p2g-x7hh-3w4c.
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
The flaw is a combination of CWE-770 (allocation of resources without limits or throttling) and CWE-772 (missing release of resource after effective lifetime) in the common NetX Secure DTLS receive path. _nx_secure_dtls_receive_callback() looks up the sender with nx_secure_dtls_session_cache_find() and, on a miss, calls nx_secure_dtls_session_cache_get_new() for any non-alert datagram at least a record header long, marking the slot in use and invoking the application's connect notify without verifying anything about the datagram first. The HelloVerifyRequest cookie that should provide that verification is per-session state stored in the slot just allocated, so the current design cannot check it pre-allocation; cookie comparison, including the hardening added in 6.5.2.202603a, only decides whether a handshake proceeds inside an already-existing session. A slot is freed only by _nx_secure_dtls_session_reset(), driven by the application ending, deleting or resetting a session or stopping the server, while _nx_secure_dtls_session_start() returns on handshake timeout or retry exhaustion without resetting. When the pool is full, new peers get an internal_error alert and nx_secure_dtls_server_session_start() reports NX_SECURE_TLS_NO_FREE_DTLS_SESSIONS. The allocation sits in the shared DTLS receive path with no build option gating it, so any build offering a DTLS server is exposed; DTLS clients are not. The fix in 6.5.2.202603b replaces the pre-allocation with a stateless HMAC cookie over the client address, ports and ClientHello, keyed by a periodically rotated server secret, and drops non-ClientHello datagrams from unknown sources.
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:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated single-datagram trigger with no user interaction gives AV:N/AC:L/PR:N/UI:N; impact is pure pool-exhaustion DoS so C:N/I:N/A:H, scope unchanged.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse ThreadX NetX Duo versions 6.0 through 6.5.2.202603a, the NetX Secure DTLS server allocates a session from its fixed session pool for the first datagram from any unrecognised address and port, before the cookie exchange, and never releases a session whose handshake stalls. A remote, unauthenticated attacker can exhaust the pool with one spoofed datagram per source and deny DTLS service to legitimate clients until the application resets the sessions.
Technical POC Analysis
CWE-770 (allocation of a resource without limits or throttling), with CWE-772 (missing release after effective lifetime) as the second weakness.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
The Eclipse ThreadX NetX Duo NetX Secure DTLS server, versions 6.0 through 6.5.2.202603a, contains a high-severity denial-of-service vulnerability that allows unauthenticated remote attackers to exhaust the session pool with a few forged datagrams, blocking legitimate DTLS clients from connecting. This affects any organization using the affected component in embedded or IoT products, where low session limits mean even a small attack can cause persistent service outages. Leadership should care because a successful attack can indefinitely disrupt secure communications and require manual intervention to restore service.
No vendor-released patch identified at time of analysis. Interim mitigations include configuring session pool limits and timeouts to automatically reclaim stalled sessions, implementing network-level rate limiting or filtering to reduce spoofed datagrams, and monitoring for anomalous session exhaustion to trigger manual resets.
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 allA 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_
Denial of service in Eclipse ThreadX NetX Duo 6.0 through 6.5.2.202603a: the BSD raw IPv6 send path adds a destination-t
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-115638
NVD
CVE.org
EPSS
GitHub
Exploit-DB