NetX Duo CVE-2025-55085
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessControl or MITM target device's HTTP server
-
ExploitReturn crafted HTTP response headers
-
ExecutionTrigger out-of-bounds read in header parser
-
ImpactLeak adjacent memory or crash 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 | Exploitation requires the target device to use the NetX Duo HTTP CLIENT module and to initiate an HTTP connection to a server the attacker controls, has compromised, or can MITM - the malformed data arrives in the server's HTTP response headers, so a purely inbound/listening attacker cannot trigger it. Limiting factors: the device must act as an HTTP client reaching an attacker-influenced endpoint; devices that only talk to fixed, authenticated, TLS-pinned servers are far harder to attack. No authentication is required of the attacker (PR:N) and no human interaction is needed (automated client requests), but the dependency on an attacker-positioned server is the key constraint reducing realistic exposure below what the 8.8 base score implies. Affected: Eclipse ThreadX NetX Duo before 6.4.4. |
| Impact | This is a genuine but situationally-gated risk rather than a drop-everything priority. The provided CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, base 8.8) describes a network, low-complexity, unauthenticated flaw, but the description makes clear this is a CLIENT-side vulnerability: the affected NetX Duo HTTP client must parse a crafted response from a server, so an attacker must control, compromise, or MITM the server the embedded device talks to - this precondition is not reflected in the base score and materially raises real-world difficulty. EPSS is 0.61% (47th percentile), which is low-to-moderate and signals no evidence of broad, automated exploitation. Publicly available exploit/POC material exists (the Eclipse GHSA advisory is flagged as exploit), but there is NO CISA KEV listing, so POC availability must not be read as active exploitation - these are distinct signals. There is also an internal impact conflict worth flagging: CWE-125 (out-of-bounds READ) and the 'Information Disclosure' tag imply confidentiality impact, yet the input vector sets VC:N while asserting VI:H/VA:H - integrity-high is hard to justify for a pure read, so the impact profile should be verified against the vendor advisory. Net: moderate priority - patch embedded devices that act as HTTP clients, prioritizing those that connect to untrusted or internet-facing endpoints. |
| Exploit ScenarioDerived | An embedded device running NetX Duo's HTTP client (e.g. for firmware updates or REST API calls) connects to a server the attacker controls or has interposed on via MITM. The malicious server returns an HTTP response with crafted/oversized header fields that bypass the missing bounds check, triggering an out-of-bounds read and undefined behavior that can leak adjacent memory or crash the device. Publicly available exploit code is referenced in the Eclipse security advisory, lowering the barrier to reproduction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Out-of-bounds reads in the Eclipse ThreadX NetX Duo HTTP client module (all versions before 6.4.4) let a malicious, compromised, or man-in-the-middle-positioned server trigger undefined behavior - most plausibly a denial-of-service crash, with limited memory-disclosure potential - by returning crafted HTTP response headers. The flaw is unauthenticated (PR:N) and requires no user interaction, but it only affects devices that act as HTTP clients and connect to an attacker-influenced endpoint, so real-world exposure is situationally gated despite the 8.8 base score; publicly available exploit code exists, while EPSS remains low at 0.61% (47th percentile).
RemediationAI
Vendor-released patch: 6.4.4 - upgrade Eclipse ThreadX NetX Duo to 6.4.4 or later as described in the GitHub security advisory GHSA-9c77-rgp9-c2g2 (https://github.com/eclipse-threadx/netxduo/security/advisories/GHSA-9c77-rgp9-c2g2); because NetX Duo is normally vendored into firmware, the stack update must be pulled into each affected product and the device reflashed, which can be slow for already-fielded hardware. Where upgrading immediately is not feasible, shrink the attack surface: restrict the device's HTTP client to a fixed allowlist of trusted servers, enforce TLS with certificate pinning so a man-in-the-middle or impersonated server cannot deliver the malformed headers, and avoid pointing the client at untrusted or user-configurable URLs - these controls reduce but do not eliminate the risk and TLS pinning adds certificate lifecycle overhead. If the device does not need HTTP client functionality, compile the module out of the build entirely to remove the vulnerable code path.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
NetX Duo is the Eclipse Foundation's dual IPv4/IPv6 embedded TCP/IP stack built for the ThreadX real-time operating system and widely embedded in IoT, industrial, and consumer devices; the CPE cpe:2.3:a:eclipse:threadx_netx_duo:*:*:*:*:*:*:*:* confirms the stack itself is the affected component. The defect is confined to the HTTP CLIENT module's header parsing path, not the HTTP server side. The root cause class is CWE-125 (Out-of-Bounds Read): the network support code parses HTTP response header fields without verifying that each read remains within the bounds of the received buffer, so an over-long or malformed header can push the parser past the end of the buffer and produce undefined behavior (crash, and potentially unintended memory exposure). Our independent assessment (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:H) rates confidentiality impact low and availability impact high - a device crash/DoS is the realistic outcome rather than meaningful data theft - and AC:H reflects that the attacker must control, compromise, or MITM the HTTP server the embedded device contacts, a precondition that materially narrows exposure versus the published 8.8 base score.
Know when 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:H/VA:H/SC:N/SI:N/SA:N
Client must connect to an attacker-controlled/MITM'd server (AC:H); out-of-bounds read discloses limited memory (C:L) and causes undefined behavior/crash (A:H); a read does not modify data (I:N).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In NextX Duo before 6.4.4, in the HTTP client module, the network support code for Eclipse Foundation ThreadX, the parsing of HTTP header fields was missing bounds verification. A crafted server response could cause undefined behavior.
Executive ViewAI
Eclipse ThreadX NetX Duo, an embedded networking stack used across connected devices and industrial/IoT products, contains an unauthenticated out-of-bounds read in its HTTP client module (all versions before 6.4.4) that a malicious or man-in-the-middle server can trigger through crafted response headers. Because the flaw is exploitable only by devices acting as HTTP clients against an attacker-influenced endpoint, exposure is limited to product lines and field deployments that initiate outbound HTTP to untrusted or third-party hosts. Impact is primarily device availability through crashes, with a secondary, limited risk of memory disclosure, and no vendor patch is available at this time, so leadership should treat remediation as a firmware-integration and exposure-reduction program rather than a simple update cycle.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict outbound HTTP/HTTPS from affected devices to allowlisted, trusted servers via network ACLs and egress filtering; enforce strict TLS certificate validation and pinning so a man-in-the-middle cannot present crafted responses; disable or remove unused HTTP client functionality in firmware where the feature is not required; isolate affected devices on segmented networks with no direct internet reachability or user-configurable endpoints; deploy IDS/IPS signatures and monitoring for malformed HTTP response headers, device crashes, and unexpected reboots; and pursue vendor engagement for the fixed NetX Duo release (6.4.4 is the version boundary cited as unaffected, pending vendor confirmation).
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.
Affected Products (CPE)CVE.org
More in Threadx Netx Duo
View allIn Eclipse ThreadX NetX Duo before 6.4.0, if an attacker can control parameters of __portable_aligned_alloc() could caus
A denial-of-service vulnerability exists in the NetX IPv6 component functionality of Eclipse ThreadX NetX Duo. A special
In NetX HTTP server functionality of Eclipse ThreadX NetX Duo before version 6.4.3, an attacker can cause a denial of se
In NetX HTTP server functionality of Eclipse ThreadX NetX Duo before version 6.4.2, an attacker can cause a denial of se
An out-of-bounds read (CWE-125) in Eclipse ThreadX NetX Duo before 6.4.4 allows remote, unauthenticated attackers to rea
An out-of-bounds read in Eclipse ThreadX NetX Duo (all versions before 6.4.4) is triggered in the _nx_ip_packet_receive(
An out-of-bounds read in Eclipse NetX Duo's IPv4 receive path (_nx_ipv4_packet_receive()) can be triggered by delivering
Out-of-bounds read in Eclipse ThreadX NetX Duo before 6.4.4 allows unauthenticated remote attackers to trigger a limited
An out-of-bounds read in Eclipse NetX Duo before 6.4.4 allows remote, unauthenticated attackers to disclose small amount
An out-of-bounds memory read exists in Eclipse ThreadX NetX Duo's secure TLS module (all versions before 6.4.4) due to a
Out-of-bounds read in Eclipse ThreadX NetX Duo (all versions before 6.4.4) lets an attacker who can deliver DHCP traffic
Two-byte out-of-bounds read in Eclipse ThreadX NetX Duo before 6.4.4 allows a remote unauthenticated attacker to send a
NVD
CVE.org
EPSS
GitHub
Exploit-DB