Skip to main content

Zephyr RTOS CVE-2026-10677

| EUVDEUVD-2026-46446 MEDIUM
Memory Leak (CWE-401)
2026-07-21 zephyr
6.5
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Recon
    Gain user thread execution on device
  2. Delivery
    Confirm CONFIG_USERSPACE build enabled
  3. Exploit
    Craft forged k_poll_event[] array
  4. Install
    Call k_poll() to leak events_copy allocation
  5. C2
    Spawn threads inheriting resource_pool
  6. Execute
    Repeat leak across all spawned threads
  7. Impact
    Exhaust 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.

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

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

Alert me

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

Zephyr 1.12.0 <4.5.0

Affected Packages

euvd zephyr fix: 4.5.0

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

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

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.

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
None
Integrity
None
Availability
High

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

EPSS Score
0.1%
Top 99% exploitable
Prevalence
Low
niche embedded RTOS, primarily IoT and edge devices
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.1%
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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