Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconGain adjacent LAN/link-local access
-
DeliverySend mDNS query for _http._tcp
-
ExploitSend two PTR responses with names in same length bucket
-
InstallTrigger stale-length bound check in _nx_mdns_packet_rr_add
-
C2Encoder writes name past nx_packet_data_end
-
ExecuteCorrupt neighbouring packet or pool free-list
-
ImpactDenial of service / stack instability
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 | Requires the device to be running the NetX Duo mDNS responder addon (addons/mdns/nxd_mdns.c) and answering |
| Impact | This is a genuine but bounded risk. The vendor CVSS 4.0 vector (AV:A/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H, base 7.1) is internally consistent with the description: exploitation requires only adjacent-network (LAN/link-local) reach, no authentication, no user interaction, and low complexity - any host on the local segment can send two crafted mDNS PTR responses. Impact is correctly scoped to availability-high plus low-integrity with NO confidentiality (this is a pure out-of-bounds WRITE of 1-3 attacker-influenced bytes, not a read), so this is not an information-disclosure bug despite the memory-corruption class. No EPSS score, no CISA KEV listing, and no public exploit are provided, so this is 'no public exploit identified at time of analysis'. The absence of KEV/EPSS is expected for a freshly-published vendor self-report and does not lower intrinsic risk, but it does mean there is no evidence of active or automated exploitation. The realistic ceiling is degraded: the overflow lands in the next packet within the same pool (no ASAN-style redzone in production), so the practical outcome is a corrupted neighbouring packet or corrupted pool free-list - denial of service / instability rather than a clean, reliable RCE primitive, which is why availability (VA:H) dominates and integrity is only Low. Net: a real MED-priority issue for exposed embedded/IoT devices running the mDNS responder, not an internet-wide critical. |
| Exploit ScenarioDerived | An attacker with a foothold on the same LAN segment as a NetX Duo device (e.g. a compromised IoT device or laptop on the corporate/home Wi-Fi) issues an mDNS query for |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
Heap out-of-bounds write in the mDNS responder of Eclipse ThreadX NetX Duo allows an unauthenticated attacker on the same local network segment to corrupt packet memory by sending two ordinary mDNS PTR records in response to a _http._tcp service query. The flaw arises from a string-table bucket collision: owner names of 12-15 characters round to the same slot size, causing the responder to reuse a shorter stored entry and write 1-3 bytes past the transmit packet's data end. With the mDNS addon active and adjacency to the target, the realistic impact is denial of service through corrupted neighboring packets or pool free lists, though code execution is not demonstrated; no public exploit code or active exploitation has been identified at time of analysis.
RemediationAI
Apply the vendor fix from the Eclipse ThreadX NetX Duo security advisory GHSA-2gf7-5224-5vrj; patch available per vendor advisory, but no exact patched version number is provided in the available data. The recommended code change is to compare the rounded slot size against the stored string length before declaring a name match, or to keep the true string length in the slot header so that _nx_mdns_packet_rr_add and _nx_mdns_name_string_encode agree on the bounds. If immediate patching is not possible, disable the mDNS responder addon if mDNS service discovery is not required (trade-off: breaks multicast DNS functionality), or restrict network access to trusted LAN segments and block UDP port 5353 at network boundaries to prevent adjacent attackers from reaching the responder (trade-off: mDNS is link-local and blocking it may disrupt legitimate discovery across subnets). Segmenting embedded devices onto isolated VLANs reduces exposure but requires network reconfiguration. No public exploit code or active exploitation has been identified, so prioritization should follow the adjacency requirement and the limited 1-3 byte overflow, which favors availability impact over code execution.
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
Eclipse ThreadX NetX Duo is an embedded TCP/IP stack, and this vulnerability resides in its mDNS responder addon (addons/mdns/nxd_mdns.c). The CPE cpe:2.3:a:eclipse_foundation:eclipse-threadx/netxduo:*:*:*:*:*:*:*:* indicates all versions of NetX Duo that include the vulnerable addon are potentially affected. The root cause is CWE-787 (out-of-bounds write) in the string table that caches mDNS names: names are stored in 4-byte-aligned slots, and the lookup routine compares the rounded slot size rather than the true string length, so distinct names that land in the same bucket (e.g., 12, 13, 14, or 15 characters) are treated as identical. When a second such name is answered, the reply reuses a pointer to the first, longer name, but the record-adding function _nx_mdns_packet_rr_add sizes its bounds check from the stale, shorter length while _nx_mdns_name_string_encode writes the actual string. This one- to three-byte overflow past nx_packet_data_end corrupts the next packet in the same pool or the pool free list rather than hitting a redzone. The upstream fix should compare the stored string length against the slot size or preserve the true length in the slot header.
Know when Eclipse Threadx Netxduo 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:A/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Adjacent LAN reach (AV:A), no auth or interaction (PR:N/UI:N), reliable low-complexity trigger (AC:L); write-only corruption gives no confidentiality (C:N), minor integrity (I:L), and dominant availability/DoS impact (A:H).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
Any host on the LAN can send two mDNS records and make the responder write past the end of its
transmit packet.
The string table stores each name in a slot rounded up to a multiple of four:
/* addons/mdns/nxd_mdns.c:11436, 11443, 11447 */
memory_len = ((memory_len & 0xFFFFFFFC) + 8) & 0xFFFFFFFF;
...
len = *((USHORT*)(p - 2)); /* slot size, not string length */
if ((len == memory_len) && ... _nx_mdns_name_match(start, memory_ptr, memory_size) ...)
The lookup that decides whether an incoming name is already stored compares the rounded slot size,
so names of 12, 13, 14 and 15 characters share one bucket. A second name in the bucket is answered
with the pointer to the first, and the record then carries a string up to three bytes longer than
the length the caller accounted for. _nx_mdns_packet_rr_add (nxd_mdns.c:8911) sizes its only
bound check from that stale length, and _nx_mdns_name_string_encode writes the real string.
Two PTR records are enough, both ordinary mDNS responses to a _http._tcp query, with owner names
whose lengths fall in the same bucket:
==87491==ERROR: AddressSanitizer: heap-buffer-overflow
WRITE of size 1 at 0x611000000124 thread T5
#0 _nx_mdns_name_string_encode addons/mdns/nxd_mdns.c:13096
#1 _nx_mdns_packet_rr_add addons/mdns/nxd_mdns.c:8911
0x611000000124 is 0 bytes to the right of 228-byte region
The overflow is one to three bytes of attacker-influenced name data past nx_packet_data_end. In a
normal pool that lands in the next packet in the same pool rather than in a redzone, so the visible
effect is a corrupted neighbouring packet or a corrupted pool free list rather than a clean crash.
Compare the slot size against the stored string length before declaring a match, or keep the
string length in the slot header and return it to the caller so the encoder and the bound check
agree.
Executive ViewAI
A memory-corruption flaw in the mDNS responder of Eclipse ThreadX NetX Duo - the networking stack embedded in many connected IoT, industrial, and consumer devices - allows any host on the same local network segment to destabilize or crash affected endpoints by sending ordinary mDNS service responses. No public exploit code and no evidence of active exploitation have been identified, but the vendor has not released a fix, so every product built on this stack and sharing a broadcast domain with untrusted or guest devices remains exposed. Leadership should care primarily as an availability and fleet-reliability risk to fielded devices rather than as a demonstrated remote code-execution threat.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the mDNS responder add-on where local service discovery is not required; keep mDNS traffic confined to trusted layer-2 segments and block multicast discovery across guest, corporate, and OT boundaries; filter or rate-limit inbound mDNS responses on adjacent untrusted segments; monitor for repeated or malformed PTR responses to _http._tcp queries and for unexpected device reboots or hangs indicative of pool corruption; maintain out-of-band recovery paths for affected fielded devices.
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 Netxduo
View allUnauthenticated remote clients can exhaust the packet pool of the Eclipse ThreadX NetX Duo RTSP server addon, causing a
An out-of-bounds heap read in the DHCP client addon of Eclipse ThreadX NetX Duo (nxd_dhcp_client.c) allows an attacker o
EUVD-2026-89178
GHSA-rp9p-ggxc-p9xm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB