Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition within sub-GHz radio range
-
DeliveryTransmit frame with length byte >127
-
ExploitDriver skips bound check, reads unclamped pkt_len
-
ExecutionSPI burst overflows rx_bufs fragment
-
ImpactNet_buf pool corruption and device crash
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 that the target build enables CONFIG_IEEE802154_CC1200 with a physically attached CC1200 sub-GHz radio configured for variable packet length (PKT_LEN=0xFF), which is the driver's default and makes the length byte an over-the-air 0-255 value. The attacker must be within sub-GHz radio range (Adjacent) and must craft a frame whose first-byte length exceeds 127 while keeping the 128-byte RX FIFO from overflowing so the RX_FIFO_ERROR pre-check stays clear. Limiting factors that reduce real-world risk: High attack complexity from RF framing/timing dependence (the RX thread samples the FIFO off PKT_SYNC_RXTX and may read before a packet completes), reliance on the default net_buf configuration (CONFIG_NET_BUF_FIXED_DATA_SIZE with CONFIG_NET_BUF_DATA_SIZE=128), and the fact that the overflow writes FIFO-underflow bytes rather than attacker-chosen data - so impact is corruption/crash, not controlled code execution. No pairing, authentication, or user interaction is required. |
| Impact | This is a genuine but constrained memory-safety flaw (CWE-787 out-of-bounds write) rather than a top-tier emergency. The CVSS 3.1 vector (AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H, base 6.8 Medium) is internally consistent with the description: exploitation requires only radio range (Adjacent, no authentication, no user interaction) but carries High attack complexity because reaching the vulnerable state depends on RF framing and timing - the RX thread samples the FIFO off the PKT_SYNC_RXTX signal and the attacker must present a length byte above 127 while the 128-byte FIFO has not overflowed so the RX_FIFO_ERROR pre-check does not fire. No EPSS score, KEV entry, or POC was provided in the input, so exploitation likelihood signals are absent: no public exploit identified at time of analysis, and the flaw is not on CISA KEV. The practical impact is also self-limiting - the overflowing bytes are FIFO-underflow output, not attacker-chosen data, so the realistic outcome is net_buf pool corruption and device crashes (denial of service) rather than controlled code execution. The C:N/I:H/A:H impact split arguably overstates integrity, since the write content is uncontrolled; the dominant real-world effect is availability loss. Net: a real priority only for the narrow population running Zephyr with CONFIG_IEEE802154_CC1200 and an attached CC1200 radio in RF-reachable deployments; patch-when-able rather than drop-everything for most fleets. |
| Exploit ScenarioDerived | An unauthenticated attacker within sub-GHz radio range of a Zephyr device using the CC1200 802.15.4 driver transmits a crafted PHY frame whose first byte declares a length greater than the 802.15.4 maximum of 127 (up to 255) while keeping the chip's 128-byte RX FIFO from overflowing. The unclamped length drives net_pkt_rx_alloc_with_buffer() and a single SPI burst read that writes up to 127 bytes past the end of a fragment in the rx_bufs pool, corrupting the network-buffer pool and crashing the device. No public exploit is identified at time of analysis; success depends on RF framing and timing because the RX thread may sample the FIFO before a packet is complete. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Out-of-bounds write in the Zephyr CC1200 sub-GHz IEEE 802.15.4 driver lets an unauthenticated attacker within radio range transmit a frame whose first byte declares a PHY length above the IEEE 802.15.4 maximum of 127, driving an oversized net_buf allocation and a single SPI burst that can write up to 127 bytes past the end of the first 128-byte buffer fragment. The flaw affects builds that enable CONFIG_IEEE802154_CC1200 with a physically attached CC1200 radio in the driver's default variable-length mode (PKT_LEN = 0xFF), and exploitation is constrained by RF framing/timing requirements (CVSS 3.1 AV:A/AC:H/PR:N/UI:N, CWE-787), with the resulting overflow containing FIFO-underflow bytes so the realistic outcome is network-buffer-pool corruption and crashes rather than a controlled write. An upstream fix is available as a commit to verify_rxfifo_validity(), but no public exploit code or confirmed active exploitation was identified at time of analysis, and no independently confirmed tagged release containing the fix is documented here.
RemediationAI
The vendor fix is the upstream commit https://github.com/zephyrproject-rtos/zephyr/commit/26a8b8294bf28523c7aa2f15cf728517980ee593, which replaces the lower-bound-only check in verify_rxfifo_validity() with IN_RANGE(pkt_len, 3, IEEE802154_MAX_PHY_PACKET_SIZE), bounding the radio-supplied length to the IEEE 802.15.4 maximum and preventing the oversized allocation and SPI burst; patch status is 'upstream fix available (PR/commit); released patched version not independently confirmed', so consult the advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-pgg5-wwxw-vmj8 and your Zephyr vendor/BSP for the specific release or backport carrying this commit. If the fix cannot be applied immediately, the most direct compensating control is to disable CONFIG_IEEE802154_CC1200 when the CC1200 sub-GHz interface is not required, which removes the vulnerable receive path entirely but eliminates that radio capability; alternatively, do not deploy CC1200-equipped nodes in variable-packet-length mode (PKT_LEN = 0xFF) until patched, accepting that this may break interoperability with variable-length 802.15.4 traffic and is not the driver default. Because the attacker only needs to be within sub-GHz radio range, there is no practical network-side filtering or authentication workaround, and operators should treat physical RF isolation or the patched build as the only reliable mitigations; monitoring for repeated node resets, faults, or net_buf pool exhaustion near CC1200 nodes can provide detection but is not prevention.
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 affected component is the CC1200 sub-GHz IEEE 802.15.4 driver (drivers/ieee802154/ieee802154_cc1200.c) in the Zephyr RTOS, tracked as CPE cpe:2.3:a:zephyrproject:zephyr. In the driver's receive path, get_packet_length() reads the PHY packet length from the first byte of the radio's RX FIFO, and verify_rxfifo_validity() was intended to sanity-check it. The original validation only enforced a lower bound (pkt_len < 3) and a second clause that rejects a FIFO holding more bytes than declared, which never bounds large values upwards. Because the driver configures the CC1200 for variable packet length with PKT_LEN = 0xFF, that length byte is an over-the-air value in the range 0-255 rather than a negotiated limit, and it flows unclamped into net_pkt_rx_alloc_with_buffer() and then into read_rxfifo_content(). With the default CONFIG_NET_BUF_FIXED_DATA_SIZE and CONFIG_NET_BUF_DATA_SIZE=128, an allocation larger than one fragment is satisfied by a chain of fragments, but read_rxfifo_content() performs a single SPI burst of pkt_len bytes into the first fragment's buf->data and then calls net_buf_add() with that same length; a length above 128 therefore writes past the end of a contiguous fragment in the rx_bufs pool and leaves a net_buf whose len exceeds its capacity. This is CWE-787 (out-of-bounds write) rooted in missing upper-bound validation of an attacker-influenced length field, and the attacker can reach it without pairing, authentication, or user interaction because the RX thread is driven off the PKT_SYNC_RXTX signal and may sample the FIFO before a packet is complete - the RX_FIFO_ERROR pre-check only fires on an actual FIFO overflow, so a frame declaring more than 127 bytes while the 128-byte FIFO has not yet overflowed slips through. The overflowing bytes are FIFO-underflow output rather than attacker-chosen content, which is why the integrity impact is limited and the practical result is memory corruption/crash, consistent with the assessed CVSS:3.1/AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H.
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:H/A:H
Adjacent radio reach and no auth/UI, but AC:H for the RF framing/timing window; A:H for crashes and C:N, with I:L because overflow bytes are uncontrolled FIFO data, not attacker-chosen.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The CC1200 sub-GHz IEEE 802.15.4 driver takes the PHY packet length from the first byte of the radio's RX FIFO in get_packet_length() and validates it in verify_rxfifo_validity() (drivers/ieee802154/ieee802154_cc1200.c). That validation only enforced a lower bound (pkt_len < 3); its second clause rejects a FIFO that holds more bytes than declared and therefore never bounds large values. Because the driver configures the radio for variable packet length with PKT_LEN = 0xFF, the length byte is an over-the-air value of 0-255 that reached net_pkt_rx_alloc_with_buffer() and the subsequent SPI burst read unclamped.
An unauthenticated attacker within radio range can transmit a frame that presents a length byte above the IEEE 802.15.4 maximum of 127 while the chip's 128-byte RX FIFO has not overflowed, so the driver's RX_FIFO_ERROR pre-check does not fire. Reaching this state depends on RF framing and timing, since the RX thread is driven off the PKT_SYNC_RXTX signal and may sample the FIFO before a packet is complete; no pairing, authentication, or user interaction is required.
With the default CONFIG_NET_BUF_FIXED_DATA_SIZE and CONFIG_NET_BUF_DATA_SIZE=128, an allocation larger than one fragment is satisfied by a chain of fragments, but read_rxfifo_content() performs a single SPI burst of pkt_len bytes into the first fragment's buf->data and then calls net_buf_add() with the same length. A length above 128 therefore writes up to 127 bytes past the end of a fragment in the contiguous rx_bufs pool and leaves a net_buf whose len exceeds its capacity. The overflowing bytes are FIFO-underflow output rather than attacker-chosen data, so the practical impact is network-buffer-pool corruption and crashes rather than a controlled write. Only builds that enable CONFIG_IEEE802154_CC1200 with an attached CC1200 radio are affected.
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-101341
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB