Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition radio within 802.15.4 range
-
DeliveryFlood frames with PHY length byte of one
-
ExploitUnderflow pkt_len to 255 in uint8_t
-
ExecutionOverrun 128-byte net_buf RX fragment
-
ImpactCrash or corrupt adjacent packet buffers
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer underflow checks
|
| Exploitation Conditions | Exploitation requires a Zephyr target that (1) uses the NXP KW41Z IEEE 802.15.4 radio driver (drivers/ieee802154/ieee802154_kw41z.c) and (2) runs the default fixed-size buffer pool configuration (CONFIG_NET_BUF_FIXED_DATA_SIZE with CONFIG_NET_BUF_DATA_SIZE=128), which allows the 255-byte request to allocate a two-fragment chain while the copy loop writes only the first 128-byte fragment. The attacker must be within 802.15.4 radio range (AV:A) and transmits unauthenticated frames with a PHY-header length byte of 1. Limiting factors: RF proximity is mandatory; there is no network-facing remote path; and success depends on a timing race (AC:H) because the length is latched at PHY-header time before frame filtering but sampled after the interrupt is cleared, so the attacker must flood length-one frames to drive the underflow. The affected code is also present in the CONFIG_NET_L2_OPENTHREAD size-computation variant. |
| Impact | This is a genuine but modest-priority memory-corruption flaw (CWE-191 integer underflow), not a high-severity emergency. The input CVSS of 5.9 (CVSS:3.1/AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H) is internally consistent with the description: AV:A reflects that the triggering frame must be sent from within 802.15.4 radio range, AC:H reflects the race window (the length byte is latched at PHY-header time before frame filtering, then sampled after the interrupt is cleared, requiring the attacker to flood length-one frames to win the timing), and PR:N/UI:N correctly reflect that the malformed frame is unauthenticated and needs no user interaction. C:N is appropriate because the over-read exposes radio register contents to buffer memory rather than to the attacker, and the description explicitly notes the overflowing bytes are radio register contents rather than attacker-authored data, which bounds integrity to I:L; A:H reflects the realistic crash/pool-corruption outcome. No EPSS score, KEV listing, POC, or SSVC decision data was provided, so exploitation-probability and automatability signals cannot be weighed - but the combination of adjacent-only vector, high attack complexity, and the fact that an attacker cannot control the corrupting bytes makes weaponization into reliable code execution unlikely; a denial-of-service crash is the most plausible real-world impact. Net: real and worth patching on affected KW41Z deployments, but not a drop-everything issue absent any exploitation evidence. |
| Exploit ScenarioDerived | An attacker with an 802.15.4 radio positioned within RF range of a Zephyr device using the NXP KW41Z driver floods the air with frames whose PHY-header length byte is set to 1. When the driver samples that length, the uint8_t subtraction underflows to 255 and the receive path writes 255 bytes into a 128-byte net_buf fragment, overrunning the shared RX buffer pool from interrupt context. No public exploit identified at time of analysis; the attack requires winning a timing race (AC:H) and yields corruption/crash rather than attacker-controlled code execution. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Integer underflow in the NXP KW41Z IEEE 802.15.4 receive path of Zephyr RTOS lets an attacker within radio range corrupt memory in the shared network-buffer pool from interrupt context. The driver samples the over-the-air PHY-header length byte from the ZLL IRQSTS register and subtracts the FCS length in a uint8_t, so a crafted frame advertising a length of one wraps to 255 bytes, which is copied into a single 128-byte net_buf fragment and overruns it by up to 127 bytes while also reading past the end of the radio's RX register array. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited; exploiting it requires RF proximity plus a timing race that the attacker must win by flooding length-one frames.
RemediationAI
Apply the upstream fix commit 51d71864578c08eb1a1201f87b46ec81c8609d62 (referenced as the vendor patch) or upgrade to a Zephyr release that contains it; the advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-2pwx-gg6f-535f and ENISA EUVD-2026-101339 bracket the affected range as 1.8.0 through versions before 4.5.0. The patch rejects any frame length below KW41Z_FCS_LENGTH before the subtraction and additionally checks net_buf_tailroom() on the first fragment before the copy loops, which also covers the CONFIG_NET_L2_OPENTHREAD variant. If patching is not immediately possible, compensating controls are limited and all carry trade-offs: making CONFIG_NET_BUF_DATA_SIZE large enough that the first fragment can never be shorter than the maximum advertised payload removes the single-fragment write assumption but increases RAM consumption across the whole buffer pool and only mitigates the write overrun, not the out-of-bounds read of PKT_BUFFER_RX; disabling the KW41Z IEEE 802.15.4 driver or the 802.15.4/OpenThread L2 entirely eliminates exposure at the cost of the radio functionality; and physically limiting 802.15.4 RF proximity (shielded enclosures, RF-quiet deployment zones, transmit-power and site surveys) reduces the AV:A attack surface but is not a reliable barrier against a determined nearby attacker and does not address the underlying integer underflow.
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
The vulnerability is CWE-191 (integer underflow) in drivers/ieee802154/ieee802154_kw41z.c, specifically the kw41z_rx() helper invoked from the kw41z_isr() interrupt handler. The frame length originates from the RX_FRAME_LENGTH field of the KW41Z ZLL IRQSTS register, a hardware copy of the PHY header length byte of any frame received over the air; the handler only rejects zero, so len == 1 makes the uint8_t expression pkt_len = len - KW41Z_FCS_LENGTH wrap to 255. Because the packet is allocated with NET_AF_UNSPEC on a non-Ethernet L2, net_pkt_rx_alloc_with_buffer() does not clamp the request to the interface MTU, and with the default fixed-size buffer pool (CONFIG_NET_BUF_FIXED_DATA_SIZE, CONFIG_NET_BUF_DATA_SIZE=128) the oversized request is satisfied as a two-fragment chain. The register-to-buffer copy loops write only into the first fragment, so 255 bytes land in a 128-byte net_buf data block, overrunning into adjacent pool memory, while up to 128 bytes are read past the end of the PKT_BUFFER_RX register array. The length is latched at PHY-header time, before frame filtering completes, but is sampled by the handler after the interrupt status is cleared, adding a timing-race element. The same size computation exists in the CONFIG_NET_L2_OPENTHREAD configuration variant. The CPE cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* identifies the affected product family, and ENISA EUVD entry EUVD-2026-101339 records the affected range as Zephyr 1.8.0 through versions prior to 4.5.0.
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:H/PR:N/UI:N/S:U/C:N/I:L/A:H
Adjacent radio-range frame (AV:A), unauthenticated with no interaction (PR:N/UI:N), a PHY-header timing race makes it AC:H; over-read is register data not disclosed to attacker so C:N, corruption bounded to I:L, crash gives A:H.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The receive path of the NXP KW41Z IEEE 802.15.4 driver, kw41z_rx() in drivers/ieee802154/ieee802154_kw41z.c, computed the payload size as pkt_len = len - KW41Z_FCS_LENGTH in a uint8_t, where len is the frame length reported by the radio. The interrupt handler kw41z_isr() obtained that length from the RX_FRAME_LENGTH field of the ZLL IRQSTS register - a copy of the PHY header length byte of the frame received over the air - and only rejected the value zero. A reported length of one therefore underflowed to pkt_len == 255.
Because the packet is allocated with NET_AF_UNSPEC on a non-Ethernet L2, net_pkt_rx_alloc_with_buffer() does not clamp the request to the interface MTU; with the default fixed-size buffer pool (CONFIG_NET_BUF_FIXED_DATA_SIZE, CONFIG_NET_BUF_DATA_SIZE=128) the allocation succeeded as a chain of two fragments. The subsequent register-to-buffer copy loops write into the first fragment only, so 255 bytes were written into a 128-byte net_buf data block, overrunning it by up to 127 bytes into adjacent network-buffer-pool memory, and reading up to 128 bytes past the end of the radio's PKT_BUFFER_RX register array.
The length field originates from an unauthenticated frame transmitted by any device within 802.15.4 radio range, and is captured by the hardware at PHY-header time - before frame filtering has completed - while the handler samples it after clearing the interrupt status, so an attacker flooding frames with a length byte of one can drive the underflow. The impact is memory corruption in the shared receive buffer pool from interrupt context, most plausibly a crash or corruption of other packets' data; the overflowing bytes are radio register contents rather than attacker-authored data, which bounds the integrity impact.
The fix rejects any length below KW41Z_FCS_LENGTH and additionally verifies net_buf_tailroom() of the first fragment before the copy loops, which also covers the CONFIG_NET_L2_OPENTHREAD variant of the size computation.
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.
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
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-101339
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB