Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify shared k_queue on SMP or preemptive Zephyr build
-
DeliverySpawn concurrent peek and get threads on same queue
-
ExploitWin race: node freed between pointer load and dereference
-
ExecutionPeek returns dangling alloc_node pointer
-
PersistCaller dereferences stale pointer as live buffer
-
ImpactKernel crash or stale heap data leak
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
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 local access with at least low privileges (PR:L per CVSS vector) and the ability to operate on a shared k_queue concurrently with another thread or CPU executing k_queue_get - making SMP builds or builds with preemption or ISR concurrency the primary risk surface. CONFIG_USERSPACE must be enabled for the userspace system-call attack path; without it, only kernel-internal callers can trigger the race. A narrow timing window (AC:H) must be won between the peek's pointer load and its dereference. Single-CPU builds without preemption cannot trigger this race at all, as the sequence cannot be interleaved. The vulnerability does not apply when peek and get operations on the same queue are inherently serialized by application design. No remote or network-accessible attack vector exists. |
| Impact | CVSS 3.6 (AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:L) accurately reflects a low-severity finding: exploitation is confined to local access, requires winning a narrow race window (AC:H), and yields only a stale one-pointer heap leak or system crash rather than privilege escalation or remote code execution. No EPSS score was provided in source data; the AC:H and local-only vector strongly imply very low exploitation probability in practice. The vulnerability is absent from the CISA KEV catalog and no public exploit code has been identified, corroborating the low-risk assessment. The most realistic real-world impact is a denial-of-service crash in embedded networking or Bluetooth stacks that dereference the dangling pointer as a live buffer. The wildcard CPE with no version bounds means the full scope of affected releases is unconfirmed. On single-CPU non-preemptive builds the race cannot materialize at all, further constraining the practical attack surface to a subset of Zephyr deployments. |
| Exploit ScenarioDerived | On a Zephyr SMP or preemptive build with CONFIG_USERSPACE enabled, a local userspace process spawns two threads sharing a k_queue populated with alloc-enqueued items - one repeatedly calling k_queue_peek_head and the other calling k_queue_get. When the race is won, peek returns a dangling pointer to a freed alloc_node; downstream networking or Bluetooth subsystem code that treats this as a live net_buf then dereferences invalid memory, crashing the kernel or exposing the freed allocation's stale contents. No public exploit code has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 07, 2026
Use-after-free in Zephyr RTOS kernel queue peek operations (z_impl_k_queue_peek_head and z_impl_k_queue_peek_tail in kernel/queue.c) allows a local low-privileged thread to obtain a dangling pointer to freed heap memory by winning a race against a concurrent k_queue_get call on a shared queue. Successful exploitation - requiring SMP or preemptive concurrency - can leak a stale heap pointer or crash the system when the returned dangling pointer is subsequently consumed as a live buffer in the net_buf, Bluetooth, USB, or networking subsystems. No public exploit exists and no active exploitation is confirmed; CVSS scores this at 3.6 (Low), accurately reflecting the narrow race window and local-only attack surface.
RemediationAI
Apply upstream commit a6b6149a50cb0f64061869f7536acbf80ccc5e0c (https://github.com/zephyrproject-rtos/zephyr/commit/a6b6149a50cb0f64061869f7536acbf80ccc5e0c), which wraps both z_impl_k_queue_peek_head() and z_impl_k_queue_peek_tail() with k_spin_lock/k_spin_unlock on the queue lock, making the read-and-dereference atomic with respect to concurrent unlink-and-free. A tagged patched release version is not independently confirmed at time of analysis - only the upstream commit is available; consult the GitHub advisory GHSA-8xm3-4w69-29mm for official release guidance. As a compensating control where patching is not immediately feasible, restructure application logic to serialize k_queue_peek_head/tail and k_queue_get calls on the same shared queue via an application-level mutex or by restricting peek calls to a single execution context, eliminating the race without kernel changes; note that this workaround adds scheduling overhead and may affect latency in time-sensitive Bluetooth or networking paths.
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 resides in kernel/queue.c of the Zephyr RTOS kernel (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*), an open-source RTOS widely used in embedded and IoT devices. The k_queue primitive underlies k_fifo and k_lifo wrappers and is consumed throughout the net_buf, Bluetooth, USB, and networking subsystems. Items enqueued via k_queue_alloc_append/alloc_prepend are backed by a heap-allocated alloc_node struct; k_queue_get() unlinks and frees this struct while holding the queue's spinlock. CWE-416 (Use After Free) applies because the helper z_queue_node_peek() reads the node's flag byte and data pointer without first acquiring that same spinlock, so a concurrent k_queue_get() on another CPU or after a preemption can free the alloc_node between the peek's pointer load and its dereference, yielding a read from freed - and potentially re-allocated - heap memory. The peek operations are additionally exposed as system calls reachable from CONFIG_USERSPACE threads, widening the attack surface on userspace-enabled builds.
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:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:L
Local-only race condition requires concurrent queue access on SMP or preemptive build; PR:L for userspace thread path; AC:H for narrow race window; no integrity impact from read-only UAF path.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The kernel queue helper z_queue_node_peek() in kernel/queue.c dereferences a node taken from a queue's data_q list, reading the node's flag byte and, for items enqueued via k_queue_alloc_append/alloc_prepend, the data pointer of an internally allocated alloc_node struct. The implementations of z_impl_k_queue_peek_head() and z_impl_k_queue_peek_tail() performed this read-and-dereference without holding the queue's spinlock, while every other accessor of the same list - including k_queue_get(), which unlinks a node and k_free()s its backing alloc_node - operates under that lock.
Because peek was unsynchronized, a concurrent k_queue_get() on the same queue (on an SMP build, or under preemption/ISR concurrency) can free the node between the moment peek obtains the node pointer and the moment it dereferences it. The peek then reads flag bits and a data pointer out of freed, potentially re-allocated heap memory and returns a stale or dangling pointer to its caller. k_fifo and k_lifo are thin wrappers over k_queue, so this affects buffer queues used throughout the net_buf, Bluetooth, USB, and networking subsystems; the peek operations are also system calls reachable from CONFIG_USERSPACE threads.
The consequences are a use-after-free read that can leak stale heap contents (one pointer word) and, when the returned dangling pointer is subsequently consumed as a live buffer, a dereference that can crash the system or corrupt memory. Exploitation requires winning a small race window with local access (e.g. a userspace process racing k_queue_peek_* against k_queue_get on a shared queue, or two CPUs), so practical impact is bounded and of low severity.
The fix wraps both peek implementations with k_spin_lock/k_spin_unlock on the queue lock, making the read-and-dereference atomic with respect to the concurrent unlink-and-free and bringing peek into line with the rest of the queue's locking discipline.
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
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
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.
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-54681
NVD
CVE.org
EPSS
GitHub
Exploit-DB