Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain UDP reachability to device
-
DeliveryLearn fixed resolver source port (observe or ICMP-scan)
-
ExploitFlood forged answers across 16-bit transaction-ID space
-
ExecutionWin race against legitimate DNS server
-
ImpactApplication resolves attacker-chosen address (cached for attacker TTL)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Cryptographic random values
|
| Exploitation Conditions | Requires a Zephyr build using the DNS stub resolver (CONFIG_DNS_RESOLVER) and an attacker with UDP reachability to the device's resolver socket (same LAN/Wi-Fi/mesh segment or a globally routable device address). The attacker must identify the static source port (trivially from any observed query, or by probing for the single ephemeral UDP port that stays silent instead of returning ICMP port-unreachable) and then, during an active query window, correctly match the 16-bit transaction identifier plus the CRC-16 of the queried name while winning the race against the legitimate server's reply. Limiting factors: exploitation needs a query actually in flight for a predictable name, success is probabilistic (race must be won), and applications that validate TLS certificates for the resolved endpoint are largely protected; persistence of the forged record requires CONFIG_DNS_RESOLVER_CACHE to be enabled. Multicast DNS and LLMNR are out of scope because their ports are protocol-fixed. Affected versions are >= 1.8.0 through <= 4.4.2. |
| Impact | This is a CWE-330 insufficient-randomness weakness (static UDP source port in the Zephyr DNS stub resolver) that lowers off-path DNS answer-spoofing cost from ~31 bits to ~16 bits. The input CVSS is 6.5 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N): network-reachable and unauthenticated (PR:N), but AC:H because the attacker must win a race against the legitimate server during a live query window while flooding the 16-bit transaction-identifier space, and I:H reflects that a win makes the application resolve an attacker-chosen address (cache-poisoned for an attacker-chosen TTL when CONFIG_DNS_RESOLVER_CACHE is on). No EPSS score, no SSVC decision vector, and no KEV entry are provided, so there is no public active-exploitation signal; exploitation status is 'no public exploit identified at time of analysis' (the only references are the vendor patch commit and the GHSA advisory, not a PoC). The vuln.today priority is 'this_month', not act_now/emergency, which is consistent with a medium-severity hardening fix rather than an under-attack flaw. Real-world risk is moderate and conditional: it is a genuine defense-in-depth gap on IoT/embedded devices with UDP reachability, but AC:H plus the advisory's own note that TLS-certificate-validating applications are largely protected pulls realistic impact below the raw network-vector reading. Treat as a planned-patch item, not a fire drill, unless a device relies on unauthenticated DNS results for security decisions. |
| Exploit ScenarioDerived | An off-path attacker with UDP reachability to a Zephyr device (same LAN/Wi-Fi/mesh segment, or a globally routable device address) learns the resolver's fixed source port - from any single observed query, or by scanning the ephemeral range for the one UDP port that does not answer with ICMP port-unreachable. During a window in which the device issues a predictable query name, the attacker floods forged answers across the 16-bit transaction-identifier space (the reply's source address is never checked), racing the real server to make the application resolve an attacker-chosen address. No public exploit code is identified; the attack requires winning the race, and endpoints that validate TLS certificates are largely protected. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Off-path DNS answer spoofing against the Zephyr DNS stub resolver (subsys/net/lib/dns, builds with CONFIG_DNS_RESOLVER) is made practical by a single static UDP source port that is bound once at resolver initialisation and reused for every query, so only the 16-bit transaction identifier varies - contrary to RFC 5452 section 9.2, which requires both to change. A remote attacker with UDP reachability to the device (same LAN, Wi-Fi or mesh segment, or a globally routable address) can learn that port from any observed query or by scanning for the one ephemeral port that stays silent instead of returning ICMP port-unreachable, then flood forged answers across the identifier space during a query window and race the legitimate server; a win makes the application resolve an attacker-chosen address, and with CONFIG_DNS_RESOLVER_CACHE enabled the forged record persists for its attacker-chosen TTL. Affected versions are >= 1.8.0 through <= 4.4.2; no public exploit code or active exploitation is confirmed, exploitation is probabilistic (the race must be won, and a predictable name must be in flight), and endpoints whose TLS certificates are validated are largely protected. The assessed vector is AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N (6.5), and vendor fixes are merged on main and the v4.4, v4.3 and v3.7 branches with a projected release in 4.5.0.
RemediationAI
Vendor-released patch: not yet in a tagged release - the fix is merged on main as commit 289c14b9103b44cf05b3ecf20eaec6153b7dc3ef (PR #116963) with backports merged to v4.4-branch (PR #117533), v4.3-branch (PR #117535) and v3.7-branch (PR #117536), and the projected fixed version is 4.5.0 (forecast to be confirmed against the actual release). Until a release containing the change is available, apply the upstream commit or backport to your tree and verify that CONFIG_DNS_RESOLVER_RANDOMIZE_SOURCE_PORT is enabled (default y) for non-mDNS/non-LLMNR servers, since that option is what closes and reopens the socket to obtain a fresh source port before each query to an idle server; disabling it - offered in the Kconfig help for builds where per-query socket close/reopen, dispatcher re-registration and descriptor churn matter more than the hardening - reintroduces the static-port weakness. Complementary hardening consistent with the advisory's own analysis of impact: leave CONFIG_DNS_RESOLVER_CACHE disabled where caching is not required so a successful forged answer is not retained for an attacker-chosen TTL, and restrict UDP reachability to the resolver socket (segment isolation, ACLs on globally routable devices) because the attack requires network access to that port; applications that validate TLS certificates for the resolved endpoint are largely protected regardless. Advisory: https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-vwgx-h8w3-xwj7 and https://github.com/zephyrproject-rtos/zephyr/commit/289c14b9103b44cf05b3ecf20eaec6153b7dc3ef.
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
CWE-330 (use of insufficiently random values) in Zephyr's DNS stub resolver: dns_resolve_init_locked() registers a dispatcher per configured server, dns_dispatcher_register() calls zsock_bind() with sin_port/sin6_port of 0, and zsock_getsockname() records the ephemeral port the stack picked - once, for the lifetime of the resolver context. dns_write() thereafter sends every query from that same socket without re-binding, while only ctx->queries[i].id (sys_rand16_get()) is redrawn per query. Reply acceptance in get_slot_by_id() is based solely on the transaction identifier plus a CRC-16 of the queried name; dispatcher_cb() performs ARG_UNUSED(addr)/ARG_UNUSED(addrlen), so the reply's source address is never validated and a forged answer need not be spoofed to look like the configured server - it only has to arrive on the resolver's port. Port discovery is cheap because subsys/net/ip/connection.c answers unmatched unicast UDP with an ICMP port-unreachable, making the resolver's socket the single silent port in the ephemeral range; note also that find_available_port() in net_context.c derives local ports from sys_rand16_get() | 0x8000 (~15 bits), so port selection itself is not strong. The merged fix adds dns_randomize_source_port(), which - for servers that are not mDNS or LLMNR and that have no query outstanding - unregisters the dispatcher, closes the socket, reopens it, and re-registers it bound to port 0 so a new port is selected, restoring roughly 31 bits of guessing space. It is gated by the new Kconfig option CONFIG_DNS_RESOLVER_RANDOMIZE_SOURCE_PORT (default y, depends on DNS_RESOLVER); multicast DNS and LLMNR are explicitly excluded because those protocols fix their ports. The trigger for the underlying weakness is the initialisation-time bind path described above; the attacker-side mechanics beyond port learning and answer flooding are as stated in the vendor advisory.
Know when Zephyr 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
AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N
Off-path and unauthenticated (AV:N/PR:N/UI:N) but AC:H for the id-guessing race against a live query; I:H for attacker-chosen resolution, C:L minor, A:N.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The DNS stub resolver in subsys/net/lib/dns/resolve.c binds one UDP socket per configured server when the resolver context is initialised (dns_resolve_init_locked() -> register_dispatcher() -> dns_dispatcher_register()), with the local port left at 0 so the stack picks an ephemeral port exactly once. dns_write() then sends every subsequent query from that same socket without re-binding, so the source port is constant for the lifetime of the resolver context while only the 16-bit transaction identifier (ctx->queries[i].id, drawn with sys_rand16_get()) varies per query. RFC 5452 section 9.2 requires both to vary; with a fixed port, an off-path attacker has to guess only the identifier.
The stable port is cheap to learn. Any single observed query reveals it permanently, and it can also be found by probing the ephemeral UDP range: subsys/net/ip/connection.c answers unmatched unicast UDP with an ICMP port-unreachable, so the resolver's socket is the one port in that range that stays silent. Acceptance of a reply is decided solely by get_slot_by_id() matching the transaction identifier and a CRC-16 of the queried name - the reply's source address is never checked (dispatcher_cb() does ARG_UNUSED(addr)), so forged answers need not even be spoofed to appear to come from the configured server; they only need to reach the resolver's port.
An attacker with UDP reachability to the device (same LAN, Wi-Fi or mesh segment, or a globally routable device address) can therefore flood answers for a predictable query name across the 16-bit identifier space during a query window and race the legitimate server. A win makes the application resolve an attacker-chosen address, and with CONFIG_DNS_RESOLVER_CACHE enabled the forged record is retained for its attacker-chosen TTL. The attack still requires winning that race, and applications that validate TLS certificates for the resolved endpoint are largely protected.
The fix draws a fresh local port before each query to a server that has nothing outstanding: dns_randomize_source_port() unregisters the dispatcher, closes and reopens the socket, and re-registers it bound to port 0 so the system selects a new port, raising the per-query guessing space from roughly 16 to roughly 31 bits. Multicast DNS and LLMNR are excluded because their ports are protocol-fixed. The behaviour is controlled by CONFIG_DNS_RESOLVER_RANDOMIZE_SOURCE_PORT (default y).
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),
An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on
Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit
Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS
Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner
Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability
Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable
DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul
zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(
Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul
The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte
Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c
EUVD-2026-109144
NVD
CVE.org
EPSS
GitHub
Exploit-DB