Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach internet-facing DTLS server
-
DeliveryCraft ClientHello with one cookie byte
-
ExploitBypass HelloVerifyRequest cookie check
-
ExecutionComplete handshake on spoofed source
-
ImpactExhaust server resources / reflect traffic
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A07:2025 - Authentication Failures
ASVS 5.0
V6 - Authentication Anti-spoofing controls
MITRE ATT&CK
1 technique across 1 tactic: Defense Evasion 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 be running NetX Secure in DTLS server mode performing the HelloVerifyRequest cookie exchange - i.e. a reachable DTLS listener - and succeeds against default configurations because the cookie-validation defect is in the standard handshake path, needing no authentication (PR:N) and no user interaction (UI:N). The practical limiting factors are network reachability of the DTLS server endpoint and that the realized harm is anti-spoofing/availability abuse (forged-source handshakes, amplification, resource exhaustion) rather than data compromise; devices not exposing a DTLS server, or fronted by stateful filtering that enforces return-routability, are not exploitable. |
| Impact | This is a genuine integrity/availability concern in the DTLS handshake rather than a code-execution flaw, and the supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms remote, unauthenticated, low-complexity reachability with no user interaction, scoring 8.7 (High). Impact is isolated to availability - VA:H (vulnerable system) and SA:L (subsequent system) with VC/VI/VA integrity and confidentiality set to N - consistent with the root cause: the server never validates the returned DTLS cookie, defeating the return-routability check that normally prevents spoofed-source handshakes and amplification/reflection abuse. No EPSS score, CISA KEV listing, or public POC is present in the provided data, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the real-world urgency therefore rests on exposure (internet-facing DTLS servers) rather than on observed in-the-wild activity. The CVSS network vector is consistent with the description, so no attack-vector conflict exists; the main caveat is that this is a defense-in-depth/anti-spoofing control failure whose practical harm (DoS amplification, resource exhaustion from forged clients) depends on deployment, not a direct compromise of the device's data. |
| Exploit ScenarioDerived | An attacker on the network sends a DTLS ClientHello to an exposed NetX Secure DTLS server with any single arbitrary byte placed in the cookie field of the first ClientHello. Because the server judges verification solely from the cookie length and never checks the value it issued, it skips the HelloVerifyRequest return-routability exchange and completes handshakes for forged (spoofed) source addresses, enabling spoofed-source handshakes and amplification/reflection toward third parties. No public exploit is identified at time of analysis, but the condition is trivial to trigger given the network/low-complexity vector. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Eclipse NetX Duo's NetX Secure DTLS server can be driven into completing handshakes with forged source addresses because the cookie it issues in a HelloVerifyRequest is never actually validated: the ClientHello parser copies the client-supplied cookie bytes over the value the server generated, and the server then treats the peer as verified based on the cookie's length alone, so a single arbitrary cookie byte in the first ClientHello skips the return-routability exchange entirely. The defect is remotely reachable with no authentication and no user interaction (CVSS 4.0 base 8.7, High; the independent assessment confirms AV:N/AC:L/PR:N/UI:N with an availability-only impact), and the practical harm is anti-spoofing and availability abuse - spoofed-source handshakes, amplification potential, and handshake state/resource exhaustion - not data compromise or code execution. No public exploit code has been identified at time of analysis, and CVE-2026-106465 is not listed in CISA KEV.
RemediationAI
No vendor-released patch version is identified in the available data, so the first step is to consult the Eclipse ThreadX NetX Duo advisory at https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-7c5f-gmpm-f655 (and the assignment record at https://gitlab.eclipse.org/security/cve-assignment/-/work_items/379) and apply the fixed NetX Duo/NetX Secure release named there as soon as it is published; until then treat the DTLS server as untrusted. If DTLS server functionality is not required, disable or exclude the NetX Secure DTLS server from the build - this removes the attack surface completely but breaks any legitimate DTLS clients. Where the DTLS listener must stay up, enforce return-routability at the network boundary: only permit inbound UDP to the DTLS port from sources that can be validated (unicast reverse-path forwarding/uRPF or a stateful firewall that drops unsolicited datagrams), accepting that legitimate clients behind NAT or on asymmetric paths may be blocked and should be allow-listed explicitly. Additionally, rate-limit new handshakes and cap half-open handshake state at the application or gateway layer so spoofed-source floods cannot exhaust memory - a mitigation that trades some legitimate connection throughput for resilience - and monitor egress traffic for amplification patterns toward spoofed victims, since the realized impact is denial of service rather than data compromise.
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
DTLS carries TLS over UDP and therefore cannot rely on TCP's three-way handshake for return-routability, so the protocol specifies a stateless cookie exchange (HelloVerifyRequest followed by a retried ClientHello carrying the echoed cookie) to prove a client actually receives traffic at its claimed address before the server allocates handshake state. This flaw is CWE-290 (Authentication Bypass by Spoofing): the server's verification decision is not cryptographically or even logically bound to the cookie it generated, since the parser overwrites the stored server-side cookie with attacker-controlled bytes and the check degrades to a length comparison. The affected component is NetX Secure, the TLS/DTLS implementation bundled with Eclipse Foundation's NetX Duo embedded TCP/IP stack, tracked by the CPE cpe:2.3:a:eclipse_foundation:netx_duo:*:*:*:*:*:*:*:* and typically deployed on microcontroller and RTOS platforms. Scope is limited to DTLS server mode that performs the HelloVerifyRequest cookie exchange - the vulnerable code path is in the standard handshake, so default configurations are affected once a DTLS listener is reachable, while devices that never expose a DTLS server endpoint are not exploitable.
Know when 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:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:L
Remote unauthenticated trigger in the default DTLS handshake (AV:N/AC:L/PR:N/UI:N); impact is loss of return-routability enabling spoofed handshakes and resource/amplification abuse, so A:H with C:N/I:N.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
The NetX Secure DTLS server sends a HelloVerifyRequest carrying a freshly generated cookie, but never checks the cookie a client returns. The ClientHello parser copies the client's cookie bytes over the value the server issued, and the server then decides whether the client has been verified from the cookie's length alone. A peer that puts any single cookie byte in its first ClientHello skips the verification exchange entirely, so the server has no return-routability check and completes handshakes for forged source addresses.
Technical POC Analysis
CWE-290 (Authentication Bypass by Spoofing), with CWE-406 as a secondary consequence.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Eclipse NetX Duo deployments that expose the NetX Secure DTLS server are affected by CVE-2026-106465, a high-severity remote availability flaw that can let unauthenticated actors consume handshake resources and disrupt DTLS-dependent services. Organizations using affected embedded, IoT, industrial, or networking products should treat this as an operational resilience issue because no vendor-released patch is identified and the vulnerability is reachable over the network; no public exploit identified at time of analysis. Leadership should prioritize exposure reduction and vendor coordination to prevent service degradation or outages in devices and upstream services that rely on DTLS.
Disable NetX Secure DTLS server where not required; restrict DTLS/UDP to trusted networks; enforce anti-spoofing (uRPF/BCP38); rate-limit DTLS handshakes and cap handshake state; monitor for handshake floods; segment affected devices; use VPN/IPsec or alternate DTLS termination. No vendor-released patch identified at time of analysis.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Out-of-bounds write in the Eclipse NetX Duo TLS 1.3 client lets a malicious or compromised server corrupt memory past th
An out-of-bounds write in Eclipse NetX Duo's WebSocket client allows unauthenticated remote attackers to corrupt NX_PACK
Memory disclosure and denial of service in the Eclipse NetX Duo TFTP server addon (nxd_tftp_server) are reachable by an
Unauthenticated remote attackers can exploit an out-of-bounds read in Eclipse NetX Duo's DTLS ClientHello parser to disc
Out-of-bounds read in Eclipse NetX Duo's X.509 certificate parser (routine `_nx_secure_x509_parse_signature_data`) lets
The SNMP agent addon in Eclipse ThreadX NetX Duo can be driven into an out-of-bounds read by a single unauthenticated re
Memory corruption in the Eclipse ThreadX NetX Duo NetX Secure TLS stack can overrun the packet pool and crash a device,
Malformed MQTT PUBLISH frames leak packet buffers in the Eclipse ThreadX NetX Duo MQTT client, letting a peer that can d
An out-of-bounds read in Eclipse ThreadX NetX Duo's MQTT-over-WebSocket transport (the setter path) lets a malicious or
Out-of-bounds reads in the client-side TLS and DTLS handshake parsers of Eclipse ThreadX NetX Duo (NetX Secure) through
NetX Duo (NetX Secure) through 6.5.1.202602 performs a one-byte out-of-bounds read inside the ASN.1 TLV parsing primitiv
Malformed ICMPv6 Neighbor Discovery option parsing in Eclipse NetX Duo can stall the IP thread or read past packet buffe
EUVD-2026-101504
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB