Skip to main content

NetX Duo CVE-2026-103416

| EUVDEUVD-2026-94228 CRITICAL
Out-of-bounds Write (CWE-787)
2026-10-07 eclipse
9.3
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Lure client to malicious TLS server
  2. Delivery
    Client begins TLS 1.3 handshake
  3. Exploit
    Send oversized handshake message pre-auth
  4. Execution
    Overflow cache into session control block
  5. Persist
    Corrupt control-block pointers
  6. Impact
    Achieve 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Eclipse ThreadX - NetX Duo 0 ≤6.5.1.202602

Affected Packages

euvd eclipse_threadx_netx_duo no fix

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

Vendor (eclipse) PRIMARY 9.3 CRITICAL
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
vuln.today AI 9.8 CRITICAL

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).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.2%
Top 90% exploitable
Prevalence
Medium
widely-used embedded/IoT RTOS networking stack, but not in every environment
Social Media
2
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy