Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to malicious TLS server
-
DeliveryClient begins TLS 1.3 handshake
-
ExploitSend oversized handshake message pre-auth
-
ExecutionOverflow cache into session control block
-
PersistCorrupt control-block pointers
-
ImpactAchieve code execution on client
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation 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 affected device run the NetX Duo TLS 1.3 CLIENT and be induced to initiate a TLS 1.3 handshake to an attacker-controlled or compromised server; the oversized handshake message is delivered during that handshake and the out-of-bounds write is reached BEFORE server certificate authentication, so a valid server certificate is NOT required and certificate pinning/validation does not block it. Limiting factors that reduce real-world exposure: the flaw is client-side (the victim, not the attacker, initiates the connection), it is specific to the TLS 1.3 handshake path in NetX Duo version 6.5.1.202602, and it does not apply to deployments that do not use the NetX Duo TLS client or TLS 1.3. There is no unauthenticated remote server-side listener attack here - the attacker must control the server endpoint the client reaches. |
| Impact | This is a genuine high-priority vulnerability, not a CVSS-inflated paper risk. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N with VC:H/VI:H/VA:H, score 9.3) indicates a network-reachable, low-complexity, unauthenticated flaw with full confidentiality, integrity and availability impact - consistent with the description of an out-of-bounds write (CWE-787) that corrupts pointer-bearing fields of the TLS session control block, a classic path to memory corruption and likely remote code execution on the embedded client. The most important signal is that the write is reachable BEFORE certificate authentication completes, so the normal trust anchor (server certificate validation) does not mitigate it; any malicious or compromised server a client is induced to connect to can trigger it. Signals that TEMPER urgency: EPSS is not provided in the input, the CVE is NOT on CISA KEV, and no public proof-of-concept is referenced - so there is no public exploit identified at time of analysis and no evidence of active exploitation. One nuance to verify: this is a CLIENT-side vulnerability requiring the victim to initiate a TLS 1.3 connection to an attacker-controlled or compromised server, which is a meaningful real-world precondition even though CVSS encodes it as AV:N/UI:N. Net: treat as a serious patch-soon issue for any deployment running the NetX Duo TLS 1.3 client, while recognizing exploitation is currently theoretical pending a POC. |
| Exploit ScenarioDerived | An attacker stands up (or compromises) a TLS server and lures or redirects a NetX Duo TLS 1.3 client - e.g. an IoT/embedded device performing an outbound TLS connection - to connect to it. During the handshake, before any certificate is validated, the server sends a handshake message larger than the client's handshake message cache, causing an out-of-bounds write that overruns the cache into adjacent pointer fields of the session control block, enabling memory corruption and potential remote code execution on the device. No public exploit identified at time of analysis, so this is currently a theoretical chain. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
Out-of-bounds write in the TLS 1.3 client of Eclipse ThreadX NetX Duo 6.5.1.202602 allows a malicious or compromised server to corrupt memory in the session control block by sending an oversized handshake message before certificate authentication completes, potentially achieving code execution or causing denial of service. The flaw is client-side and unauthenticated from the network perspective, requiring the victim device to initiate a TLS 1.3 handshake to an attacker-controlled server; no valid server certificate is needed and certificate pinning does not prevent exploitation. No public exploit code was identified at time of analysis, but the CVSS 9.3 base score and the pre-authentication nature make this a high-priority memory-corruption issue for affected embedded deployments.
RemediationAI
No vendor-released patch was identified in the provided data at time of analysis. Track the Eclipse ThreadX NetX Duo advisory at https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-4x76-j955-qhq2 and the GitLab CVE assignment work item at https://gitlab.eclipse.org/security/cve-assignment/-/work_items/356 for an official fix; apply the patched release as soon as it becomes available. In the interim, actionable compensating controls include disabling TLS 1.3 in the NetX Duo client and falling back to TLS 1.2 if the application can tolerate the loss of TLS 1.3 features (trade-off: potential feature regression and a reduced security posture if TLS 1.2 is configured with weaker cipher suites). Because exploitation requires the device to initiate a TLS 1.3 handshake to a malicious or compromised server, restrict client connections to a tightly controlled allowlist of trusted server endpoints and avoid initiating TLS sessions to untrusted hosts (trade-off: operational overhead and reduced flexibility for dynamic environments). Enabling memory protection hardware, such as an MPU, can help contain the impact of the out-of-bounds write if exploitation occurs, but it does not prevent the memory corruption itself. Certificate pinning or validation will not block this attack because the overflow is reached before server certificate authentication completes.
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 an embedded TCP/IP stack from Eclipse ThreadX (formerly Azure RTOS) used in resource-constrained devices. The vulnerability resides in the TLS 1.3 handshake message cache, a fixed-size buffer that stores handshake messages for later processing and transcript hashing. Because the code does not properly validate the length of an incoming handshake message before copying it into the cache, a message larger than the cache writes past its bounds and into the adjacent session control block, which contains pointers. This is a classic CWE-787 out-of-bounds write. The affected product is identified by the CPE cpe:2.3:a:eclipse_foundation:eclipse_threadx_-_netx_duo:*:*:*:*:*:*:*:* (wildcard version), with the described flaw specific to version 6.5.1.202602. Exploitation occurs during the TLS 1.3 handshake, specifically before the server certificate is authenticated, so an attacker-controlled or compromised server can trigger the overflow without presenting a valid certificate. The independent assessment confirms a remote unauthenticated attack vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) but notes that the victim must initiate a connection to the attacker-controlled endpoint, making this a client-side rather than server-side listener issue.
Know when Eclipse 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:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Unauthenticated network-reachable client flaw triggered automatically during the handshake (PR:N/UI:N/AC:L); out-of-bounds pointer corruption yields full RCE-level C/I/A, same-component scope (S:U).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
Out-of-bounds write via the TLS 1.3 handshake message cache in NetX Duo in Eclipse ThreadX NetX Duo 6.5.1.202602 allows a handshake message larger than the cache writes past it and on into the rest of the session control block, which holds pointers. A malicious or compromised server can make a TLS 1.3 client produce such a message before certificate authentication completes, so no server certificate is needed to reach it.
Technical POC Analysis
CWE-787 out-of-bounds write in nxsecuretlssendhandshakerecord in NetX Secure, part of Eclipse ThreadX NetX Duo.
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.5.1.202602, a TLS stack widely embedded in connected devices, contains a critical memory-corruption flaw that is triggered before the server's certificate is validated. Any affected device that initiates a TLS 1.3 connection to an attacker-controlled server can have its memory corrupted, potentially leading to code execution or device failure, and no vendor patch is currently available. Because these devices are often deployed in medical, industrial, and consumer environments where field updates are slow, leadership should treat this as a fleet-wide exposure requiring immediate network and configuration containment rather than waiting on a fix.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the TLS 1.3 client and force TLS 1.2 where the stack is configurable; enforce egress filtering, DNS allowlisting, and network segmentation so affected devices only connect to trusted servers; monitor for oversized or malformed TLS handshake traffic; restrict device deployments to controlled network environments until a patch is available. Note that certificate pinning does not prevent exploitation, and no public exploit was 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
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.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
EUVD-2026-94228
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB