Skip to main content

Eclipse NetX Duo EUVDEUVD-2026-89178

| CVE-2026-102715 HIGH
Out-of-bounds Write (CWE-787)
2026-09-29 eclipse GHSA-rp9p-ggxc-p9xm
7.1
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Recon
    Gain adjacent LAN/link-local access
  2. Delivery
    Send mDNS query for _http._tcp
  3. Exploit
    Send two PTR responses with names in same length bucket
  4. Install
    Trigger stale-length bound check in _nx_mdns_packet_rr_add
  5. C2
    Encoder writes name past nx_packet_data_end
  6. Execute
    Corrupt neighbouring packet or pool free-list
  7. Impact
    Denial 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 _http._tcp service queries. The attacker must be on the same LAN / link-local segment (adjacent network, AV:A - not routable across the internet) and sends two ordinary mDNS PTR responses whose owner-name lengths both fall within one rounded string-table bucket (e.g. 12, 13, 14 or 15 characters, which round to the same 4-byte-aligned slot). No authentication and no user interaction are needed (PR:N/UI:N). Limiting factors: adjacency requirement confines the attack to the local segment; the mDNS addon must be compiled in and active; and the overflow is bounded to 1-3 bytes, so in a normal packet pool the realistic effect is packet/pool corruption and DoS rather than a controllable code-execution primitive.

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 _http._tcp and then sends two crafted PTR responses whose owner-name lengths both fall in the same rounded 12-15 character bucket. The responder reuses the first name's stored pointer for the second record and writes 1-3 bytes past nx_packet_data_end, corrupting the adjacent packet or the pool free list and typically destabilizing or crashing the networking stack. No authentication or user interaction is required, but no public exploit code exists at time of analysis.

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

eclipse-threadx/netxduo 0 ≤6.5.1

Affected Packages

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

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

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

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

3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H
4.0 AV:A/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Adjacent
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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:

c



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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.2%
Top 96% exploitable
Prevalence
High
Eclipse ThreadX NetX Duo is a widely-deployed embedded RTOS TCP/IP stack; mDNS addon is an enabled subset.
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.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
Controlled
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

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

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.

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