Skip to main content

Eclipse NetX Duo EUVDEUVD-2026-105140

| CVE-2026-92843 HIGH
Out-of-bounds Read (CWE-125)
2026-10-20 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
    Lure/redirect victim to malicious TLS server
  2. Delivery
    Send crafted Certificate message in TLS 1.3 handshake
  3. Exploit
    Trigger unsigned-integer underflow in parser
  4. Execution
    Cause heap out-of-bounds read
  5. Impact
    Crash 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

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

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

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

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.

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

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.3%
Top 79% exploitable
Prevalence
High
RTOS TCP/IP stack embedded in very large numbers of IoT/embedded devices
Data Quality
5 sources
Confidence: Medium

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.3%
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
Medium
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.

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