Skip to main content

Eclipse NetX Duo CVE-2026-106464

| EUVDEUVD-2026-101502 HIGH
Out-of-bounds Read (CWE-125)
2026-10-14 eclipse
8.7
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Initiate or accept TLS handshake with target
  2. Delivery
    Deliver crafted peer certificate (empty BIT STRING signature)
  3. Exploit
    Parser computes length as 0xFFFFFFFF
  4. Execution
    Out-of-bounds read on signature data
  5. Impact
    Crash / 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
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 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

NetX Duo 0 ≤6.5.2.202603

Affected Packages

euvd 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

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

Vendor (eclipse) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/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
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Medium
embedded RTOS TCP/IP+TLS stack; broad device base but TLS-reachable subset is narrower
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

CVE-2026-103415 CRITICAL
9.3 Oct 14

Out-of-bounds write in the Eclipse NetX Duo TLS 1.3 client lets a malicious or compromised server corrupt memory past th

CVE-2026-102761 CRITICAL
9.3 Sep 29

An out-of-bounds write in Eclipse NetX Duo's WebSocket client allows unauthenticated remote attackers to corrupt NX_PACK

CVE-2026-102713 HIGH
8.8 Sep 29

Memory disclosure and denial of service in the Eclipse NetX Duo TFTP server addon (nxd_tftp_server) are reachable by an

CVE-2026-102712 HIGH
8.8 Sep 29

Unauthenticated remote attackers can exploit an out-of-bounds read in Eclipse NetX Duo's DTLS ClientHello parser to disc

CVE-2026-106465 HIGH
8.7 Oct 14

Eclipse NetX Duo's NetX Secure DTLS server can be driven into completing handshakes with forged source addresses because

CVE-2026-102718 HIGH
8.7 Sep 29

The SNMP agent addon in Eclipse ThreadX NetX Duo can be driven into an out-of-bounds read by a single unauthenticated re

CVE-2026-102760 HIGH
8.3 Sep 29

Memory corruption in the Eclipse ThreadX NetX Duo NetX Secure TLS stack can overrun the packet pool and crash a device,

CVE-2026-102762 HIGH
8.2 Sep 29

Malformed MQTT PUBLISH frames leak packet buffers in the Eclipse ThreadX NetX Duo MQTT client, letting a peer that can d

CVE-2026-102717 HIGH
7.5 Sep 30

An out-of-bounds read in Eclipse ThreadX NetX Duo's MQTT-over-WebSocket transport (the setter path) lets a malicious or

CVE-2026-102728 HIGH
7.5 Sep 29

Out-of-bounds reads in the client-side TLS and DTLS handshake parsers of Eclipse ThreadX NetX Duo (NetX Secure) through

CVE-2026-102758 HIGH
7.5 Sep 29

NetX Duo (NetX Secure) through 6.5.1.202602 performs a one-byte out-of-bounds read inside the ASN.1 TLV parsing primitiv

CVE-2026-102714 HIGH
7.1 Sep 29

Malformed ICMPv6 Neighbor Discovery option parsing in Eclipse NetX Duo can stall the IP thread or read past packet buffe

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