Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure/redirect victim to malicious TLS server
-
DeliverySend crafted Certificate message in TLS 1.3 handshake
-
ExploitTrigger unsigned-integer underflow in parser
-
ExecutionCause heap out-of-bounds read
-
ImpactCrash or destabilize NetX Secure peer
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection 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 victim device to act as a TLS 1.3 client/peer using NetX Secure and to process a Certificate message from an attacker-controlled or MITM'd TLS 1.3 server; the specific trigger is a malformed Certificate message that causes an unsigned-integer underflow in the Certificate-message parser. It is reachable pre-authentication and before certificate verification completes, so no credentials or prior trust are needed. The principal LIMITING factor is attacker positioning: the attacker must operate or intercept the TLS server the victim connects to - this is not a flaw an attacker can trigger against an unsolicited listening service. Impact per the vendor vector is availability (crash/DoS); confidentiality impact is rated none despite the 'Information Disclosure' tag. |
| Impact | The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) with a base score of 8.7 indicates a network-reachable, low-complexity, pre-authentication flaw, and the impact is scoped purely to availability (VA:H) with no confidentiality or integrity impact (VC:N/VI:N). This is consistent with CWE-125 (out-of-bounds read) manifesting as a crash/denial-of-service rather than data theft. A key nuance the raw score hides: this is a CLIENT-side vulnerability triggered by a MALICIOUS TLS 1.3 SERVER, so real-world exploitation requires the victim peer to initiate (or be redirected into) a handshake with an attacker-controlled endpoint - the 'network/no-privileges/no-UI' metrics are technically accurate but understate the need for attacker positioning. No EPSS score, KEV listing, or POC was provided in the input; therefore exploitation probability cannot be quantified and there is no public exploit identified at time of analysis. Note a signal conflict: the input Tags list 'Information Disclosure' and the description says 'out-of-bounds read,' which could imply memory leakage, yet the authoritative CVSS rates confidentiality at VC:N and availability at VA:H - treat this as an availability/DoS issue unless the vendor advisory confirms readable memory is returned to the attacker. Overall this is a credible, genuinely pre-auth remote DoS against embedded TLS peers, but it is not in the same tier as a wormable RCE and current evidence points to no active exploitation. |
| Exploit ScenarioDerived | A device running Eclipse ThreadX NetX Duo (NetX Secure) acting as a TLS 1.3 client connects to a server the attacker controls or has hijacked via MITM. During the normal handshake, before certificate verification completes, the malicious server returns a crafted Certificate message that triggers an unsigned-integer underflow and a heap out-of-bounds read, crashing or destabilizing the embedded peer. No public exploit code was provided in the input, and low attack complexity (AC:L) with no required privileges or user interaction makes the trigger straightforward once the victim initiates the connection. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Heap out-of-bounds read in the NetX Secure TLS 1.3 Certificate-message parser of Eclipse ThreadX NetX Duo can be triggered by a malicious or man-in-the-middle TLS 1.3 server, crashing the connecting peer. The flaw is unauthenticated (CVSS PR:N) and reachable during the normal handshake, before certificate verification completes, but requires the victim device to act as a TLS client and connect to an attacker-controlled endpoint - an attacker cannot trigger it against an unsolicited listening service. Vendor/independent assessment rates impact as availability-only (CVSS 4.0 base 8.7; CVSS 3.1 AV:N/AC:L/PR:N/UI:N/A:H), and no public exploit code or CISA KEV active-exploitation entry was identified at time of analysis.
RemediationAI
No vendor-released patch version was identifiable from the provided data; consult the Eclipse ThreadX NetX Duo advisory GHSA-4m85-f9qh-q3jv (https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-4m85-f9qh-q3jv) for the fixed release and apply it as soon as it is published - patch status should be treated as 'Patch available per vendor advisory' pending an exact version number. Until a fix is integrated, the highest-value control is reducing attacker positioning: constrain device egress with firewall/allow-list rules so NetX Secure clients only connect to known, trusted TLS servers, which removes the malicious-server and MITM trigger paths at the cost of blocking legitimate connections to unlisted endpoints. Where the application controls the trust model, pin the expected server certificate/identity before the handshake completes and abort on mismatch, closing the window in which the malformed Certificate message is parsed. As a stopgap, disable the TLS 1.3 profile in the NetX Secure configuration and negotiate TLS 1.2 only - this sidesteps the vulnerable Certificate-message parser but sacrifices TLS 1.3's reduced handshake round trips and forward-secrecy properties. Because the assessed impact is availability-only, enable a hardware watchdog and fast restart path on affected devices to bound downtime from a parser fault (trade-off: it does not prevent the crash, only shortens the outage), and if the platform offers an MPU/MMU, place NetX Secure buffers in a guarded region so an out-of-bounds read faults deterministically rather than corrupting adjacent heap. Note that network-level filtering does not mitigate a MITM positioned between device and a legitimate server, so egress restriction should be paired with certificate pinning where feasible.
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 IPv4/IPv6 TCP/IP stack, and NetX Secure is its bundled TLS/DTLS implementation (the CPE confirms the affected component as eclipse_foundation:eclipse_threadx_-_netx_duo). In TLS 1.3 (RFC 8446), the server sends an encrypted Certificate message carrying a certificate_request_context, a certificate_list with per-entry extensions, and length-prefixed DER blobs that the peer must parse incrementally as bytes arrive off the wire. The parser performs pointer/length arithmetic derived from those attacker-controlled length fields; a missing bounds check on a length field allows an unsigned-integer underflow (length wraps to a very large value) when the declared length exceeds the remaining buffer, after which a subsequent read walks past the end of the heap allocation. The root-cause class is CWE-125 (Out-of-bounds Read); the practical outcome is a fault/crash or watchdog reset of the embedded target, and the tag 'Information Disclosure' attached by the reporter is not supported by the assessed vector, which scores confidentiality and integrity impact as none (VC:N/VI:N). Because parsing happens during the handshake and before certificate validation, no credentials, prior trust, or client authentication are needed - only the ability to serve (or intercept) the TLS endpoint the device dials.
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:N/VI:N/VA:H/SC:N/SI:N/SA:N
Pre-auth and triggered automatically during the handshake so PR:N/UI:N/AC:L; out-of-bounds read causes a crash so A:H with C:N/I:N per the vendor-rated impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
A missing bounds check in the TLS 1.3 Certificate-message parser of NetX Secure lets a malicious TLS 1.3 server trigger an unsigned-integer underflow and a subsequent heap out-of-bounds read in any peer that processes a remote Certificate message. It is reachable pre-authentication, during the normal handshake, before certificate verification completes.
Technical POC Analysis
CWE-125 (out-of-bounds read), driven by an unsigned-integer underflow (CWE-191 pattern) in nxsecuretlsprocessremotecertificate in Eclipse ThreadX NetX Duo's NetX Secure TLS stack.
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 devices that act as TLS 1.3 clients are exposed to a high-severity availability flaw in the NetX Secure certificate parser, which can crash the device during the normal handshake before certificate validation completes. The issue is unauthenticated but requires the victim device to initiate a connection to an attacker-controlled or man-in-the-middle TLS 1.3 server, so organizational exposure is concentrated in outbound client scenarios rather than internet-facing listening services. No vendor-released patch identified at time of analysis and no public exploit identified at time of analysis; leadership should care because affected embedded and IoT devices may experience service disruption and require interim network controls until a fix is released.
No vendor-released patch identified at time of analysis; restrict outbound TLS 1.3 client connections to trusted allowlisted endpoints, disable TLS 1.3 client functionality in NetX Secure where operationally feasible, enforce network egress filtering, and monitor device crash and reboot telemetry.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Eclipse Threadx Netx Duo
View allOut-of-bounds write in the TLS 1.3 client of Eclipse ThreadX NetX Duo 6.5.1.202602 allows a malicious or compromised ser
Out-of-bounds write in Eclipse NetX Duo's X.509 certificate-chain verification lets unauthenticated remote attackers cor
Denial of service in the Eclipse ThreadX NetX Duo Web add-on's HTTP server, which mishandles a `Content-Length` underflo
A four-byte malformed TLS 1.3 Certificate handshake header can drive the NetX Secure certificate parser in Eclipse Threa
Denial of service in Eclipse ThreadX NetX Duo HTTP server arises from a flawed remediation of CVE-2025-0728, where the r
HTTP request smuggling in Eclipse ThreadX NetX Duo's optional Web add-on allows unauthenticated remote clients to influe
EUVD-2026-105140
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB