Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInitiate TLS/DTLS handshake with target
-
DeliveryPresent chain with oversized RSA intermediate
-
ExploitOverflow fixed 4096-bit modulus buffer
-
ExecutionOut-of-bounds write past static
-
ImpactCorrupt memory / achieve code execution
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 target use NetX Secure's X.509 certificate-chain verification over TLS or DTLS and that the attacker-supplied intermediate carry an RSA modulus larger than NX_CRYPTO_MAX_RSA_MODULUS_SIZE (default 4096 bits). Two concrete trigger paths exist: a TLS/DTLS CLIENT verifying a malicious server's chain (no special configuration - ordinary server-certificate validation), and a SERVER that has client-certificate authentication (mutual TLS) enabled, which is the limiting factor for the server-side path since mutual TLS is not a default in most deployments. No authentication is needed because the malicious issuer is resolved from the remote peer-supplied store before the trusted store, so the attacker's oversized key is used in the crypto operation without chaining to a trusted root. The main limiting factor is simply that the target must initiate or accept certificate verification against the attacker - trivially satisfied for the client path, configuration-gated for the server path. |
| Impact | All available signals point to a genuine high-priority issue rather than a CVSS-inflated low-risk one. The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H, 9.3) is internally consistent with the description: an out-of-bounds write (CWE-787) reachable pre-authentication over the network with low complexity and no user interaction, because the attacker simply presents an oversized RSA modulus as an intermediate in a certificate chain the target verifies. The description's claim that the malicious issuer is resolved from the peer-supplied store BEFORE the trusted store is the key enabler - it removes any need for the attacker's cert to actually chain to a trusted root, so PR:N is credible rather than optimistic. Signals are NOT fully corroborated across sources: there is no EPSS score, no CISA KEV listing, and no indication of public exploit code in the provided intelligence, so this is 'no public exploit identified at time of analysis' and must not be described as actively exploited. The combination of pre-auth network reach, a memory-corruption primitive in a TLS/DTLS stack, and both client-side and server-side (mutual-TLS) trigger paths makes this a strong patch priority despite the absence of exploitation telemetry; the missing EPSS/KEV data reflects the vulnerability's recency, not low severity. |
| Exploit ScenarioDerived | An attacker stands up a malicious TLS/DTLS server (or connects as a malicious client to a mutual-TLS server) and presents a certificate chain containing an intermediate whose RSA public key modulus exceeds 4096 bits. When the NetX Secure X.509 verifier performs ordinary chain verification, the oversized key is decrypted into a fixed-size buffer, causing an out-of-bounds write past a file-scope static before any authentication completes. No public exploit code is identified in the available data, but the low attack complexity and lack of required privileges or user interaction make reliable triggering straightforward. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Out-of-bounds write in Eclipse NetX Duo's X.509 certificate-chain verification lets unauthenticated remote attackers corrupt static memory by presenting a certificate with an RSA modulus larger than the 4096-bit NX_CRYPTO_MAX_RSA_MODULUS_SIZE buffer dimension. The flaw is reachable pre-authentication on TLS/DTLS clients validating a malicious server chain and on servers configured for client-certificate authentication, because the peer-supplied issuer is resolved before the trusted store. No public exploit was identified at time of analysis, but the issue is rated critical (CVSS 4.0 9.3; independently assessed CVSS 3.1 9.8).
RemediationAI
Patch available per vendor advisory: apply the fix referenced by the NetX Duo security advisory GHSA-rcv5-vfff-25gh, and confirm the exact fixed NetX Duo release in that advisory before upgrading because the provided intelligence does not specify a patched version number. Until patched, add a pre-verification length check that rejects any certificate or intermediate whose RSA modulus exceeds NX_CRYPTO_MAX_RSA_MODULUS_SIZE or the buffer size actually compiled in; this compensating control will also reject legitimate certificates using larger keys. On servers, disable client-certificate authentication (mutual TLS) where it is not required to remove the server-side trigger path; this does not mitigate the client-side path where a NetX Duo client validates a malicious server chain. Review build-time configuration of NX_CRYPTO_MAX_RSA_MODULUS_SIZE and ensure buffers and acceptance limits are consistent, but enlarging the macro alone is not a substitute for enforcing an explicit maximum. See https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-rcv5-vfff-25gh for vendor guidance.
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 Secure is the TLS/DTLS and cryptography component of Eclipse ThreadX NetX Duo. Its X.509 parser accepts an RSA public key of arbitrary size, while signature-verification paths decrypt into fixed-size buffers sized by the NX_CRYPTO_MAX_RSA_MODULUS_SIZE default of 4096 bits. A certificate carrying a larger modulus therefore causes a CWE-787 out-of-bounds write past a file-scope static during ordinary certificate-chain verification. The crypto operation looks up the issuer in the remote, peer-supplied store before the trusted store, so the attacker can supply the oversized key as an intermediate in the presented chain and reach the vulnerable path without a trusted-root relationship. CPE data identifies the affected product as Eclipse Foundation Eclipse ThreadX - NetX Duo.
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:H/VI:H/VA:H/SC:N/SI:N/SA:N
Pre-auth network reach with attacker-controlled chain gives AV:N/AC:L/PR:N/UI:N; an out-of-bounds write enabling potential code execution justifies C:H/I:H/A:H, scope unchanged within the stack.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
The X.509 parser in NetX Secure accepts an RSA public key of any size, but every signature-verification path decrypts into fixed-size buffers dimensioned for the NX_CRYPTO_MAX_RSA_MODULUS_SIZE default of 4096 bits. A certificate carrying a larger modulus drives an out-of-bounds write past a file-scope static during ordinary certificate-chain verification.
It is reachable pre-authentication. The issuer used for the crypto operation is looked up in the remote, peer-supplied store before the trusted store, so the attacker supplies the oversized key themselves as an intermediate in the chain they present. It triggers on a TLS or DTLS client verifying a malicious server's chain, and on a server performing client-certificate authentication.
Technical POC Analysis
CWE-787 out-of-bounds write, with CWE-1284 improper validation of a quantity supplied in input.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical memory-safety flaw in Eclipse NetX Duo’s X.509 certificate-chain verification can let a malicious TLS/DTLS peer corrupt static memory by presenting a crafted certificate chain, affecting organizations that ship or operate NetX Duo-based clients or servers performing certificate validation. No vendor-released patch identified at time of analysis and no public exploit identified at time of analysis, but the broad exposure of secured device communications warrants leadership attention and near-term mitigation planning.
No vendor-released patch identified at time of analysis. Interim controls: limit TLS/DTLS endpoints to trusted networks, disable client-certificate authentication where operationally feasible, enforce maximum RSA modulus/key size limits at gateways or proxies, restrict trust to known CAs, segment affected devices, and monitor for crafted or anomalous peer certificate chains; apply the Eclipse NetX Duo vendor fix once released.
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.
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.
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
Denial of service in the Eclipse ThreadX NetX Duo Web add-on's HTTP server, which mishandles a `Content-Length` underflo
Heap out-of-bounds read in the NetX Secure TLS 1.3 Certificate-message parser of Eclipse ThreadX NetX Duo can be trigger
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-105129
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB