Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend forwardable IP/multicast traffic to device
-
DeliveryPacket re-targeted to Ethernet TX with zero reserved headroom
-
Exploitnet_buf_push underflows fragment data pointer
-
Execution14/18-byte header written out of bounds over adjacent buffer or heap metadata
-
ImpactMemory corruption causes crash or heap inconsistency (DoS)
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 | Exploitation requires the Zephyr device (4.1.0-4.4.2) to be built and deployed as a packet forwarder or tunnel endpoint: specifically with CONFIG_NET_IPV4_FORWARDING/CONFIG_NET_IPV6_FORWARDING enabled forwarding from a non-Ethernet L2 (802.15.4/OpenThread or PPP) out to Ethernet/Wi-Fi, OR IPv6 multicast forwarding of RX-slab clones, OR the IPIP tunnel sending an outer-IP packet over an attached Ethernet interface. The in-place header path must also be enabled via CONFIG_NET_L2_ETHERNET_RESERVE_HEADER, which ships default-y on nRF54L Wi-Fi zero-copy TX (NRF_WIFI_ZERO_COPY_TX) and on NXP Wi-Fi. The out-of-bounds write only actually occurs in production builds compiled WITHOUT CONFIG_ASSERT and WITHOUT CONFIG_NET_BUF_HARDENING (otherwise the push is asserted or returns NULL). Key limiting factors: plain Ethernet-to-Ethernet forwarding is NOT affected because ethernet_recv() pulls the header and leaves headroom; the attacker controls neither the written bytes nor the offset; and the whole vulnerable path depends on a non-default forwarding/tunnel configuration on specific platforms. |
| Impact | Signals are mostly consistent toward a moderate, availability-focused issue rather than an emergency. The CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H, base 6.5) describes an unauthenticated, network-reachable but high-complexity flaw whose dominant impact is availability (crash/DoS) with only limited integrity impact and no confidentiality loss - matching the advisory's own statement that the attacker controls neither the written bytes nor the offset, so the outcome is memory corruption/crash/heap inconsistency, not controlled code execution. The vuln.today Decision label is this_month, not act_now or emergency. No EPSS score is provided, there is no CISA KEV listing (not actively exploited), and no public exploit identified at time of analysis - the only references are the vendor patch commit and the GHSA advisory, not PoC exploit code. The one notable conflict is the input 'RCE' tag, which is directly contradicted by the vendor's own impact analysis (uncontrolled write, no code execution); treat RCE as a mislabel, not a confirmed capability. AC:H is well justified here not by any race or timing but by the configuration dependency: the device must be acting as a forwarder/tunnel endpoint and be built without assertions. Net: a real but conditional issue best handled on a normal monthly patch cadence, not an actively-exploited priority. |
| Exploit ScenarioDerived | A Zephyr device configured to forward or tunnel traffic (e.g. IPv4/IPv6 forwarding from an 802.15.4/OpenThread/PPP interface out to Ethernet/Wi-Fi, IPv6 multicast forwarding, or an IPIP tunnel over Ethernet) receives attacker traffic from a remote or adjacent source. When the forwarded packet - allocated by a non-Ethernet L2 and therefore lacking reserved Ethernet headroom - is handed to Ethernet TX, net_buf_push writes 14 bytes (18 with VLAN) before the fragment's data block, corrupting a neighbouring buffer or allocator metadata. No public exploit is identified at time of analysis; the realistic result is a crash or heap inconsistency (DoS), not reliable code execution. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Out-of-bounds write in Zephyr's Ethernet L2 layer (subsys/net/l2/ethernet/ethernet.c) lets a remotely sent packet that the device forwards from a non-Ethernet interface to Ethernet corrupt memory preceding the packet buffer, causing crashes, packet corruption or heap inconsistency (CWE-787, CVSS 6.5, availability-weighted). Affected releases are Zephyr 4.1.0 through 4.4.2 built with CONFIG_NET_L2_ETHERNET_RESERVE_HEADER (default-y on nRF54L and NXP Wi-Fi zero-copy TX configurations) plus a forwarding or tunnelling path such as CONFIG_NET_IPV4_FORWARDING/CONFIG_NET_IPV6_FORWARDING from 802.15.4/OpenThread or PPP to Ethernet/Wi-Fi, IPv6 multicast forwarding, or the IPIP tunnel - plain Ethernet-to-Ethernet forwarding is not affected. The write only materialises in production builds compiled without CONFIG_ASSERT and without CONFIG_NET_BUF_HARDENING; the attacker controls neither the bytes written nor the offset, and no public exploit has been identified at time of analysis (not in CISA KEV).
RemediationAI
The upstream fix is merged: commit b39f86ea61d0 on main (PR #117462) plus backports on v4.4-branch (PR #117875) and v4.3-branch (PR #117873); the project's projected fixed release is Zephyr 4.5.0, and users on 4.1.0-4.4.2 should track or cherry-pick those branch commits until 4.5.0 ships (advisory: https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-56gp-jq94-c9hh). Where the fix is not yet applied, the documented evidence points to two compensating build-time controls: enabling CONFIG_ASSERT or CONFIG_NET_BUF_HARDENING so that net_buf_simple_push() asserts or returns NULL on headroom underflow instead of writing out of bounds - the trade-off is that the packet send fails or the system halts rather than silently corrupting memory, plus assert/hardening code size and runtime cost in production. Disabling CONFIG_NET_L2_ETHERNET_RESERVE_HEADER removes the in-place path for deployments that do not need embedded VLAN link-layer headers, at the cost of an extra buffer fragment allocation per transmitted packet. Deployments that do not forward or tunnel traffic from a non-Ethernet L2 (802.15.4/OpenThread, PPP) into Ethernet/Wi-Fi, and that do not use IPv6 multicast forwarding or IPIP tunnelling, do not exercise the vulnerable path.
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's network stack hands packets between layers using net_buf fragments with reserved 'headroom' before the payload. ethernet_fill_header() can prepend the 14-byte Ethernet header (18 bytes with VLAN) in place by pushing it into the first fragment's headroom rather than allocating a separate header fragment. That in-place path was originally gated only on the build-time constant CONFIG_NET_L2_ETHERNET_RESERVE_HEADER, with no runtime verification that the packet actually carries the reserve, and then called net_buf_push(pkt->buffer, hdr_len). The headroom is only ever produced by ethernet_l2_alloc(), which net_pkt_alloc_buffer() invokes solely when is_pkt_tx() is true and the packet's interface is the Ethernet interface. Packets allocated by a different L2 and then handed to Ethernet therefore have little or no headroom: net_route_packet_if() re-targets a received packet to another interface, net_route_ipv6_mcast_forward_packet() forwards an RX-slab clone with no reserve, and the IPIP tunnel's interface_send() prepends an outer IP header allocated on the virtual interface (whose alloc hook exists only under VLAN). Because net_buf_simple_push() only asserts on the headroom bound, a build without CONFIG_ASSERT and without CONFIG_NET_BUF_HARDENING moves the fragment data pointer below its data block: with fixed-size pools this overwrites the tail of the neighbouring buffer's payload or memory preceding the pool array, and with variable-size pools it overwrites the buffer reference count and heap chunk header. The commit b39f86ea61d0 adds the guard (reserve_ll_header <= net_buf_headroom(pkt->buffer)) and otherwise falls back to a separate header fragment. Note that ethernet_recv() pulls the header, restoring 14/18 bytes of headroom, which is why Ethernet-to-Ethernet forwarding escapes the bug.
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:N/I:L/A:H
Unauthenticated forwarded traffic reaches the sink (PR:N/AV:N), but the non-default forwarding/tunnel config and no-assert build make it AC:H; impact is mainly crash (A:H) with incidental corruption (I:L), no disclosure (C:N).
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
ethernet_fill_header() in subsys/net/l2/ethernet/ethernet.c can prepend the Ethernet header in place, by pushing it into the headroom of the packet's first fragment, instead of allocating a separate header fragment. Before this fix the in-place path was selected purely from the build-time value of CONFIG_NET_L2_ETHERNET_RESERVE_HEADER, with no check that the packet actually has that headroom, and then called net_buf_push(pkt->buffer, hdr_len). Only Ethernet TX allocations reserve that space: net_pkt_alloc_buffer() invokes the L2 alloc hook (ethernet_l2_alloc()) only when is_pkt_tx() is true and the packet's interface is the Ethernet interface.
A packet that was allocated by a different L2 and then handed to Ethernet for transmission therefore has too little (usually zero) headroom. Such packets are produced by ordinary routing and tunnelling paths: net_route_packet_if() re-targets a received packet to another interface when CONFIG_NET_IPV4_FORWARDING / CONFIG_NET_IPV6_FORWARDING are enabled (for example an 802.15.4/OpenThread or PPP interface forwarding to Wi-Fi/Ethernet), net_route_ipv6_mcast_forward_packet() forwards an RX-slab clone that carries no reserve, and the IPIP tunnel interface_send() prepends an outer IP header allocated on the virtual interface. In these configurations a remote or adjacent attacker triggers the condition simply by sending traffic that the device forwards.
Because net_buf_simple_push() only asserts on the headroom bound, a build without CONFIG_ASSERT (and without the newer CONFIG_NET_BUF_HARDENING) moves the fragment data pointer below the start of its data block and writes 14 bytes - 18 with VLAN - of Ethernet header out of bounds. With the default fixed-size buffer pools this overwrites the tail of the neighbouring buffer's payload or memory preceding the pool array; with variable-size pools it overwrites the buffer reference count and the heap chunk header. The attacker controls neither the written bytes nor the offset, so the practical impact is memory corruption leading to a crash, packet corruption, or heap inconsistency rather than controlled code execution. The fix takes the in-place path only when net_buf_headroom(pkt->buffer) is large enough and otherwise falls back to a separate header fragment.
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.
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-112266
NVD
CVE.org
GitHub
Exploit-DB