Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAttain Layer-2 adjacency to target device
-
DeliveryIdentify Zephyr DHCPv4 client in DHCP exchange
-
ExploitCraft DHCP reply with MESSAGE TYPE option value 9-31
-
InstallTransmit spoofed reply to client
-
C2Bypass faulty sizeof bounds check in net_dhcpv4_msg_type_name()
-
ExecuteWild-pointer dereference via %s log handler
-
ImpactCrash DHCPv4 client or leak adjacent pointer value
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 two concurrent conditions: (1) the target Zephyr firmware must be compiled with CONFIG_NET_DHCPV4_LOG_LEVEL_DBG enabled, a non-default Kconfig setting that is absent in release and production builds; (2) the attacker must have Layer-2 adjacency to the target device, either as a legitimate participant on the same link or via a spoofed DHCP reply - DHCP is link-local (UDP broadcast), so the attacker cannot reach the client from a routed network without a relay. Exploitation is limited by the non-default debug configuration requirement: the vulnerable code path (NET_DBG log statement) is compiled out or skipped at non-debug log levels, making standard production firmware immune regardless of Zephyr version. No authentication by the attacker is required; no user interaction on the device is needed. The attack does not require knowledge of any secret, key, or internal state beyond the ability to send a UDP packet with a crafted DHCP option. |
| Impact | The NVD-assigned CVSS 3.1 score of 5.4 (AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L) reflects adjacent-network reachability and dual confidentiality/availability impact, but the AC:L rating overstates ease of exploitation because it does not capture the mandatory non-default build-time prerequisite (CONFIG_NET_DHCPV4_LOG_LEVEL_DBG). In practice, production Zephyr firmware is built with release-level logging; a device must be deliberately compiled with debug logging active for this code path to be reachable at runtime. An independent assessment of AC:H better represents the real exploitation bar. No EPSS data was provided. The CVE is not in the CISA KEV catalog and no POC has been identified, confirming this has not been exploited at scale. The primary real-world scenario is a development or test device with debug builds exposed on an untrusted network segment - a configuration edge case, not a mainstream deployment risk. The availability impact (crash of the DHCPv4 client, potentially the device) is the more likely outcome; information disclosure via log output of a garbage pointer value is a secondary concern requiring log capture by the attacker. |
| Exploit ScenarioDerived | An attacker already positioned on the same Layer-2 network segment as a Zephyr device running a debug build sends a crafted DHCP OFFER or ACK packet containing a MESSAGE TYPE option (option 53) with a value between 9 and 31 (on a 32-bit target). The faulty bounds check passes because sizeof of the pointer array returns 32, the value indexes past the 8-element name table, and the resulting garbage pointer is dereferenced by the debug log's %s handler, crashing the DHCPv4 client or printing adjacent memory content to the log. No authentication or special tooling is required beyond the ability to inject raw Ethernet frames on the target's link, achievable via ARP spoofing or a rogue DHCP server. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 01, 2026
Out-of-bounds read in Zephyr RTOS DHCPv4 client (versions 1.7.0 through 4.4.x) allows an adjacent-network attacker to crash the DHCP client or leak adjacent pointer contents by sending a crafted DHCP reply with a message-type value greater than 8. The defect is a classic sizeof-vs-ARRAY_SIZE confusion: the bounds guard compares a raw msg_type byte against the byte-size of a pointer array (32 or 64, depending on architecture) rather than its element count of 8, so values 9-31/63 bypass the check and cause a wild-pointer dereference inside a debug log call. Exploitation is gated on a non-default build configuration (CONFIG_NET_DHCPV4_LOG_LEVEL_DBG), substantially reducing the real-world attack surface. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.
RemediationAI
The primary fix is to upgrade to Zephyr 4.5.0 or later, which incorporates the corrective commit 73c8a7df4f00088fc04ee5ab71bcabf47fcd3db7 (https://github.com/zephyrproject-rtos/zephyr/commit/73c8a7df4f00088fc04ee5ab71bcabf47fcd3db7) replacing sizeof(name) with ARRAY_SIZE(name) in both net_dhcpv4_msg_type_name() and net_dhcpv4_state_name(), as well as the DHCPv6 equivalent. The upstream fix is available as a patch commit; a tagged 4.5.0 release version has not been independently verified at time of analysis. For projects that cannot immediately upgrade, the direct compensating control is to ensure CONFIG_NET_DHCPV4_LOG_LEVEL_DBG is not set in the build configuration - this removes the only code path that reaches the vulnerable lookup and eliminates the attack surface entirely at zero functional cost to production firmware. Disabling DHCPv4 altogether (if static IP assignment is viable) is an alternative but carries significant operational impact. Network-level mitigations such as 802.1X port authentication or DHCP snooping on managed switches can limit an attacker's ability to inject spoofed DHCP replies, but do not address the root cause.
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
Zephyr RTOS (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*) is a Linux Foundation RTOS targeting constrained IoT and embedded devices. The DHCPv4 client is implemented in subsys/net/lib/dhcpv4/dhcpv4.c. The function net_dhcpv4_msg_type_name() maps a numeric DHCP message type (RFC 2132 option 53) to a human-readable string via a static 8-element const char* array. The faulty guard (msg_type <= sizeof(name)) compares the byte against the byte-size of the pointer array - 32 bytes on a 32-bit target, 64 bytes on a 64-bit target - rather than the logical element count of 8 obtained by ARRAY_SIZE(). CWE-125 (Out-of-bounds Read) applies: a raw byte from the received packet (read via net_pkt_read_u8 with no range validation) can index past the end of the array. The out-of-range slot contains a garbage const char* value that is subsequently passed to a %s format specifier in NET_DBG/LOG_DBG, causing a wild-pointer dereference. The same sizeof bug also appeared in net_dhcpv4_state_name() and in the DHCPv6 counterpart (subsys/net/lib/dhcpv6/dhcpv6.c), both fixed in the same commit. The vulnerability is only reachable when the DHCPv4 log module is compiled at DEBUG verbosity, a non-default Kconfig option.
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:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L
AV:A for link-local DHCP; AC:H because exploitation requires the non-default CONFIG_NET_DHCPV4_LOG_LEVEL_DBG build condition; PR:N as no attacker authentication is needed.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The DHCPv4 client helper net_dhcpv4_msg_type_name() in subsys/net/lib/dhcpv4/dhcpv4.c indexes a static 8-element const char * name table after a faulty bounds check. The guard used msg_type <= sizeof(name) instead of msg_type <= ARRAY_SIZE(name); sizeof returns the byte size of the pointer array (32 on 32-bit, 64 on 64-bit targets) rather than the element count of 8, so message-type values from 9 up to that byte size pass the check and cause name[msg_type - 1] to read past the end of the array.
The msg_type value originates from the DHCP MESSAGE TYPE option, which is read as an unchecked raw byte from a received packet (net_pkt_read_u8) and passed unmodified into the lookup. A DHCP server, or any host able to inject a spoofed DHCP reply onto the client's link, can therefore drive the index out of bounds. The out-of-range slot yields a garbage const char * that is then dereferenced by a %s log conversion.
The lookup is reached only from a debug log statement (NET_DBG / LOG_DBG), so the out-of-bounds read is triggerable only when the DHCPv4 log module is built at DEBUG level (CONFIG_NET_DHCPV4_LOG_LEVEL_DBG), which is not the default configuration. When that condition holds, the result is an out-of-bounds read and a wild-pointer dereference: most likely a crash of the DHCP client (denial of service) and potentially disclosure of an adjacent pointer's contents through the log output. The fix replaces sizeof with ARRAY_SIZE, restoring the correct 1..8 acceptance window.
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.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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-51868
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB