Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInitiate or accept TLS handshake with target
-
DeliveryDeliver crafted peer certificate (empty BIT STRING signature)
-
ExploitParser computes length as 0xFFFFFFFF
-
ExecutionOut-of-bounds read on signature data
-
ImpactCrash / denial of service on device
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 | The target must participate in a TLS handshake using NetX Duo's X.509 parser and receive a certificate from the attacker - this occurs whenever the device acts as a TLS client (connecting to an attacker-controlled server) or as a TLS server configured to request/accept client certificates. The malicious input is a certificate whose signature field is an empty ASN.1 BIT STRING (tlv_length == 0). No authentication, user interaction, or non-default setting is required because certificate parsing happens before handshake authentication completes (AV:N/AC:L/PR:N/UI:N). The principal LIMITING factor is reachability: only devices that establish TLS connections with untrusted/attacker-controllable peers are exposed, and the realistic impact is a crash/DoS rather than confidentiality or integrity loss. |
| Impact | The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a remote, low-complexity, unauthenticated flaw with no special attack requirements, which is consistent with the description: malicious certificates are parsed directly from the peer during the TLS handshake, before any authentication completes. The impact is scoped as availability-only (VA:H, with VC:N/VI:N) yielding a base score of 8.7 (High). This maps cleanly to an out-of-bounds read (CWE-125) whose primary consequence is a crash/denial of service on the embedded TLS endpoint rather than data theft or code execution. Signal alignment is strong on exploitability but the input provides NO EPSS score and NO SSVC decision data, so exploitation probability cannot be quantified. KEV status is not listed (treated as NO) and no POC is referenced, so this is currently a theoretical-but-credible remote DoS, not confirmed in-the-wild activity. NOTE A CONFLICT: the input Tags include 'Information Disclosure' and 'Buffer Overflow', yet the authoritative CVSS sets VC:N (no confidentiality impact) and the root cause is an over-read (length 0xFFFFFFFF, pointer past buffer), not a write/overflow - the realistic outcome is a crash from dereferencing the out-of-bounds signature, so the 'Buffer Overflow' and 'Information Disclosure' tags overstate the demonstrated impact versus the vendor CVSS. Priority is genuine for anyone terminating or initiating TLS with NetX Duo on reachable embedded devices, but it is a reachability/availability risk, not a confidentiality or RCE emergency based on available data. |
| Exploit ScenarioDerived | An attacker positioned as a TLS peer (e.g., a malicious server the device connects to, or a client connecting to a device acting as a TLS server) presents an X.509 certificate whose signature is an empty ASN.1 BIT STRING. During the unauthenticated handshake, NetX Duo parses the certificate, computes the signature length as tlv_length - 1 = 0xFFFFFFFF, and stores a pointer one byte past the buffer; subsequent use of that signature triggers a massive out-of-bounds read and likely crashes the device. No public exploit identified at time of analysis, but the condition is trivially reproducible from the description. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Out-of-bounds read in Eclipse NetX Duo's X.509 certificate parser (routine _nx_secure_x509_parse_signature_data) lets a peer that supplies a certificate with an empty ASN.1 BIT STRING signature corrupt the parser's internal signature length to 0xFFFFFFFF and drive a signature pointer one byte past the end of the buffer, producing a crash or destabilization of the device. Because certificates are parsed from the remote peer during the TLS handshake, the issue is network-reachable and unauthenticated - affected devices are those acting as a TLS client toward an attacker-influenced server, or as a TLS server that requests client certificates; the independent assessment rates it AV:N/AC:L/PR:N/UI:N with availability-only impact (A:H). Neither CISA KEV active exploitation nor public exploit code is associated with this CVE at time of analysis, and the principal limiting factor is reachability: only systems that negotiate TLS with untrusted peers are exposed.
RemediationAI
Treat the vendor advisory as the authoritative fix source: apply the patched NetX Duo release announced in GHSA-ww3q-3444-q488 (Eclipse ThreadX GitHub security advisory) or the corresponding Eclipse security work item 368, and verify that the release notes explicitly cover the zero-length ASN.1 BIT STRING case in _nx_secure_x509_parse_signature_data; no exact fixed version number is provided in the available input data, so confirm the version string from the advisory rather than assuming one. If immediate upgrade is not possible, the most effective compensating control is reducing reachability: stop affected devices from initiating TLS connections to untrusted or attacker-influenceable endpoints, and, where the application does not require mutual TLS, disable server-side client-certificate requests/verification so that arbitrary peer certificates are not parsed - the trade-off is loss of peer identity assurance and mutual authentication, which may violate compliance requirements. Additional options include fronting the device with a hardened TLS terminator or proxy that validates and normalizes certificates before they reach NetX Duo (adds latency and hardware cost), and restricting/pinning the set of servers the device will connect to (reduces but does not eliminate exposure, since a compromised pinned peer still triggers the parser). Because the flaw is an out-of-bounds read driven by a length underflow, input sanitization at the TLS boundary and fuzz-regression testing of certificate parsing are recommended hardening measures alongside the patch.
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 vulnerability lives in NetX Duo's NetX Secure TLS stack, an embedded TLS/X.509 implementation used by Eclipse ThreadX (formerly Azure RTOS) on resource-constrained IoT and RTOS devices, identified here by the CPE cpe:2.3:a:eclipse_foundation:netx_duo:*:*:*:*:*:*:*:*. During handshake certificate parsing, _nx_secure_x509_parse_signature_data decodes the DER/BER-encoded ASN.1 signature field as a TLV and computes the signature payload length as tlv_length - 1, assuming a non-empty BIT STRING (the -1 accounts for the mandatory unused-bits octet). When a peer sends a certificate whose signature is an empty ASN.1 BIT STRING (tlv_length == 0), the subtraction underflows to 0xFFFFFFFF on the unsigned length field; the certificate is still accepted as parsed, and the signature pointer is advanced one byte past the end of the input buffer while the recorded length claims ~4 GB of data. Subsequent read of that signature material therefore walks out of bounds, which is the classic CWE-125 out-of-bounds read root-cause class - here originating from a missing input-validity check rather than a bounds check on the pointer. Reachability is high in the embedded use case because certificate parsing happens before handshake authentication completes, meaning the malicious certificate does not need to chain to a trusted root for the buggy code path to execute.
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:N
Peer certificate is parsed remotely before authentication (AV:N/AC:L/PR:N/UI:N); out-of-bounds read causes a crash so A:H with C:N/I:N and no scope change.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
_nx_secure_x509_parse_signature_data computes the certificate signature's length as tlv_length - 1 without first checking that tlv_length is non-zero. A certificate whose signature is an empty ASN.1 BIT STRING therefore parses successfully and leaves the certificate holding a signature length of 0xFFFFFFFF and a signature pointer one byte past the end of the buffer. Certificates are parsed from the peer during the TLS handshake, so the input is remote and unauthenticated.
Technical POC Analysis
No runnable PoC is present in the evidence.
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's X.509 certificate parser contains a high-severity out-of-bounds read that can crash or destabilize devices during TLS handshakes with untrusted peers. Because the flaw is unauthenticated and network-reachable, organizations using NetX Duo as a TLS client to external servers or as a TLS server requesting client certificates may face device availability outages with operational impact. No public exploit or active exploitation has been identified at time of analysis, but no vendor patch is available, making interim network controls critical.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict TLS reachability to trusted peers, disable client certificate authentication where not required, terminate TLS at a hardened gateway or proxy, segment affected devices, monitor for crashes/reboots, and apply vendor workarounds when available.
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.
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
Eclipse NetX Duo's NetX Secure DTLS server can be driven into completing handshakes with forged source addresses because
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-101502
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB