Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconGain user thread execution on device
-
DeliveryConfirm CONFIG_USERSPACE build enabled
-
ExploitCraft forged k_poll_event[] array
-
InstallCall k_poll() to leak events_copy allocation
-
C2Spawn threads inheriting resource_pool
-
ExecuteRepeat leak across all spawned threads
-
ImpactExhaust kernel heap, causing system-wide DoS
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Resource cleanup, leak prevention
|
| Exploitation Conditions | Exploitation requires that the Zephyr system be compiled with CONFIG_USERSPACE enabled - without this build-time flag, z_vrfy_k_poll() is not present in the kernel binary and the vulnerability does not exist. The attacker must be executing as a low-privilege user thread (PR:L per CVSS) on the target device; remote network access alone is insufficient (AV:L). The attack additionally relies on the ability to spawn new threads within the process, since heap exhaustion is amplified by spawning threads that inherit the parent's resource_pool. Exploitation is limited to versions v1.12.0 through v4.4.1; v4.5.0 and later are not affected. No configuration of specific kernel objects beyond the default k_poll interface is required - any low-privilege user thread that can invoke k_poll() can trigger the leak. User interaction from other users or operators is not required (UI:N). |
| Impact | The CVSS 3.1 vector AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:N/A:H yields a 6.5 medium score that is directionally accurate but may understate practical severity in embedded contexts. The scope change (S:C) correctly captures that heap exhaustion radiates beyond the attacking thread to the entire shared kernel resource pool - impacting all threads and kernel subsystems drawing from it. The AC:L rating is defensible: once CONFIG_USERSPACE is enabled and a user thread is present, no special timing, race conditions, or environmental factors are needed. EPSS data was not present in the provided intelligence, so exploitation probability cannot be quantified from that signal. Neither a CISA KEV listing nor public POC code has been identified, meaning active exploitation is not confirmed. However, the attack mechanism is mechanically straightforward - any user thread can execute it without sophisticated tooling - and the amplification via inherited resource pools makes reliable heap exhaustion achievable. For safety-critical embedded and IoT deployments where Zephyr is commonly used, loss of kernel allocation capability can cascade into hard faults or watchdog resets, elevating the operational impact well above what a CVSS base score communicates in isolation. No conflicting signals between the CVSS vector and the description were identified; AV:L is appropriate since exploitation requires thread execution on the device itself. |
| Exploit ScenarioDerived | A low-privilege user thread running on a Zephyr device with CONFIG_USERSPACE enabled calls k_poll() in a tight loop, passing a k_poll_event[] array containing a forged or invalid kernel object handle. Each iteration causes z_vrfy_k_poll() to allocate events_copy via z_thread_malloc(), immediately kill the thread via K_OOPS without freeing the buffer, then resume - permanently leaking the allocation. The attacker spawns additional threads that inherit the parent's resource_pool, multiplying the leak rate across threads until the shared kernel heap is exhausted and legitimate kernel allocations for queues, message buffers, and future k_poll calls begin to fail system-wide, triggering denial of service. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 22, 2026
Kernel heap exhaustion in Zephyr RTOS affects all builds with CONFIG_USERSPACE enabled from v1.12.0 through v4.4.1, allowing any low-privilege user thread to permanently leak kernel memory by supplying a forged object handle to k_poll(). The z_vrfy_k_poll() syscall verifier allocates a kernel-side event copy but, prior to the fix, killed the calling thread via K_OOPS without freeing that buffer - a path any user thread can trigger repeatedly. By spawning additional threads that inherit the parent's resource_pool, an attacker can multiply the leak rate until the shared kernel heap is depleted, causing system-wide denial of service affecting queues, message buffers, and all future k_poll calls. No public exploit code or CISA KEV listing has been identified at time of analysis.
RemediationAI
The primary fix is to upgrade to Zephyr v4.5.0 or later, which incorporates the patch committed at https://github.com/zephyrproject-rtos/zephyr/commit/8dc7a37bc75402a0a3329397887f32f5fb4da3ad. Note that this is a GitHub commit reference rather than a tagged release artifact - the exact release version is confirmed as v4.5.0 by EUVD-2026-46446 (affected versions listed as less than 4.5.0). For deployments that cannot upgrade immediately, the most effective compensating control is to disable CONFIG_USERSPACE in the kernel build configuration if userspace thread isolation is not required; this removes z_vrfy_k_poll() entirely, eliminating the vulnerable code path at the cost of losing userspace privilege separation. If CONFIG_USERSPACE must remain enabled, restrict application design so that untrusted threads cannot call k_poll() or spawn arbitrary child threads - reducing the number of threads that can reach the vulnerable path limits leak rate and extends time-to-impact. Monitoring Zephyr's kernel memory pool statistics for anomalous heap depletion can serve as a detection signal. Full advisory details are at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-r3cc-8wcr-xfj9.
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 vulnerable function is z_vrfy_k_poll() in kernel/poll.c, the userspace syscall verifier activated only when Zephyr is built with CONFIG_USERSPACE. When a user thread calls k_poll(), the verifier allocates a kernel-side copy of the caller's k_poll_event[] array via z_thread_malloc() and then validates each event's object handle using K_SYSCALL_OBJ(). Pre-fix code wrapped these checks in K_OOPS() macros, which abort the calling thread immediately on a validation failure - before the loop can reach the cleanup path that would free events_copy. This is a textbook CWE-401 (Missing Release of Memory after Effective Lifetime): the buffer is acquired, an abnormal exit path bypasses the corresponding free, and the allocation is permanently orphaned. Because Zephyr threads inherit their parent's resource_pool (kernel/thread.c), each sacrificial thread spawned by an attacker draws from the same heap region, enabling leak amplification without requiring privileged operations. The CPE cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* covering v1.12.0 onward reflects that the k_poll userspace exposure has carried this defect since it was first introduced. The commit diff confirms five distinct K_OOPS call sites were replaced with conditional goto oops_free blocks, ensuring the buffer is freed before thread termination in all error cases.
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:L/PR:L/UI:N/S:C/C:N/I:N/A:H
AV:L because exploitation requires local thread execution on the device; PR:L for any valid user-mode thread; S:C because heap exhaustion impacts the entire shared kernel resource pool beyond the attacker's own thread.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The CONFIG_USERSPACE syscall verifier z_vrfy_k_poll() in kernel/poll.c allocates a kernel-side copy of the user-supplied k_poll_event[] via z_thread_malloc() and then validates each event's object handle. Before this fix, validation used K_OOPS(K_SYSCALL_OBJ(...)) inline inside the loop, which kills the calling thread without freeing events_copy.
A user thread can pass num_events >= 1 with a forged object handle to leak the allocation; because newly spawned user threads inherit the parent's resource_pool (kernel/thread.c), an attacker spawns sacrificial threads to repeat the leak until the shared kernel heap is exhausted. Once depleted, legitimate kernel allocations from that pool (k_queue alloc nodes, k_msgq buffers, future k_poll calls, etc.) fail, causing a system-level denial of service.
The fix replaces each inline K_OOPS with a conditional goto oops_free so the buffer is freed before the thread is killed. Affects Zephyr releases from v1.12.0 (when k_poll was first exposed to user mode) through v4.4.1.
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
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-46446
NVD
CVE.org
EPSS
GitHub
Exploit-DB