Skip to main content

Zephyr CC1200 Driver EUVDEUVD-2026-101341

| CVE-2026-75084 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-14 zephyr
6.8
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Position within sub-GHz radio range
  2. Delivery
    Transmit frame with length byte >127
  3. Exploit
    Driver skips bound check, reads unclamped pkt_len
  4. Execution
    SPI burst overflows rx_bufs fragment
  5. Impact
    Net_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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Zephyr 1.11.0 ≤4.4.2

Affected Packages

euvd zephyr no fix

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

Vendor (zephyr) PRIMARY 6.8 MEDIUM
AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H
vuln.today AI 5.9 MEDIUM

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.

3.1 AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H
4.0 AV:A/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

Attack Vector
Adjacent
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
High

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

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Low
Zephyr is common in IoT, but only CC1200-radio 802.15.4 builds are affected
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Controlled
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Zephyr

View all
CVE-2023-4260 CRITICAL POC
10.0 Sep 27

Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),

CVE-2026-1678 CRITICAL POC
9.8 Mar 05

An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on

CVE-2023-5055 CRITICAL POC
9.8 Nov 21

Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2023-4257 CRITICAL POC
9.8 Oct 13

Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS

CVE-2023-3725 CRITICAL POC
9.8 Oct 06

Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner

CVE-2021-3323 CRITICAL POC
9.8 Oct 12

Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability

CVE-2021-3625 CRITICAL POC
9.8 Oct 05

Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable

CVE-2021-3319 CRITICAL POC
9.8 Oct 05

DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul

CVE-2018-1000800 CRITICAL POC
9.8 Sep 06

zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(

CVE-2023-4264 CRITICAL POC
9.6 Sep 27

Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul

CVE-2024-1638 CRITICAL POC
9.1 Feb 19

The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte

CVE-2023-5753 HIGH POC
8.8 Oct 25

Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy