Skip to main content

Zephyr RTOS EUVDEUVD-2026-95530

| CVE-2026-19575 HIGH
Access of Resource Using Incompatible Type (Type Confusion) (CWE-843)
2026-10-09 zephyr
7.8
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Access
    Gain unprivileged user-mode thread execution
  2. Delivery
    Allocate user-writable thread stack object
  3. Exploit
    Forge fake struct device with malicious ops.deinit
  4. Execution
    Invoke device_deinit() syscall on it
  5. Impact
    Supervisor-mode arbitrary call escapes userspace isolation

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Type safety enforcement
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a build compiled with BOTH CONFIG_USERSPACE and CONFIG_DEVICE_DEINIT_SUPPORT enabled; with deinit support off, z_impl_device_deinit() returns -ENOTSUP before dereferencing the pointer, eliminating the bug. The attacker must already be an unprivileged user-mode thread that holds permission on a kernel object whose backing memory is user-writable (most practically a k_thread_stack_alloc() stack object or a granted static K_THREAD_STACK used to spawn child user threads). Version exposure: v4.2.x and v4.3.x shipped CONFIG_DEVICE_DEINIT_SUPPORT=y by default, so every CONFIG_USERSPACE build of those lines is affected unless explicitly disabled; from v4.4.0 the option is opt-in and not selected by any in-tree subsystem, so v4.4.x is affected only if explicitly enabled. v4.2 is end-of-life and receives no backport. Limiting factors: local access only, attacker must already run inside the userspace sandbox, and the vulnerable config combination must be present.

Impact

This is a genuine high-priority local privilege-escalation flaw, not a high-CVSS-but-low-impact case, though its reach is gated by build configuration. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N) is consistent with the description: a local, already-running unprivileged user-mode thread with no user interaction and low complexity can reliably trigger a type-confusion (CWE-843) that yields an arbitrary indirect supervisor-mode call plus arbitrary kernel read and a single-byte kernel write - full defeat of the CONFIG_USERSPACE isolation boundary. The C:H/I:H/A:H impact is well-justified; the vendor rated scope unchanged (S:U), but exploitation crosses the user/supervisor security authority, which is arguably a scope change (see assessed vector). No EPSS score, CISA KEV entry, or public PoC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active or widespread exploitation. The dominant limiting factor is not CVSS complexity but configuration: the defect is only reachable when both CONFIG_USERSPACE and CONFIG_DEVICE_DEINIT_SUPPORT are enabled, so raw CVSS overstates the fleet-wide exposure. Priority is high for Zephyr builds that use userspace isolation as a security control on v4.2.x/v4.3.x (where the deinit option defaulted on), and lower for v4.4.x where the option is opt-in.

Exploit ScenarioDerived

A low-privileged user-mode thread on a Zephyr device allocates a thread-stack kernel object (via k_thread_stack_alloc() or a granted static K_THREAD_STACK), writes a fake struct device into that user-writable memory, then calls the device_deinit() syscall passing the stack object; because the handler only checked K_OBJ_ANY, the kernel dereferences the attacker-controlled state and ops.deinit pointers and performs an indirect call in supervisor mode. This requires local code execution already inside the userspace sandbox and no user interaction. No public exploit code was identified at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 – Oct 09, 2026

Local privilege escalation in Zephyr RTOS allows an unprivileged user-mode thread, in builds that enable both CONFIG_USERSPACE and CONFIG_DEVICE_DEINIT_SUPPORT, to pass a user-writable kernel object - most practically a thread stack from k_thread_stack_alloc() or a granted static K_THREAD_STACK - to the device_deinit() syscall and achieve supervisor-mode code execution. The flaw is a type-confusion issue in z_vrfy_device_deinit(): validation with K_OBJ_ANY skips the object type comparison, so z_impl_device_deinit() treats attacker-written bytes as a struct device and follows attacker-controlled state and ops.deinit pointers. The upstream fix is available via commit 1036694889ab33996db41b4141ddf66aa786d267, no public exploit code was identified at time of analysis, and impact is gated by the required build configuration; v4.2.x and v4.3.x defaulted the vulnerable option to y, while v4.4.x is exposed only if explicitly enabled.

RemediationAI

Apply the upstream fix commit 1036694889ab33996db41b4141ddf66aa786d267 or update to a vendor release that contains it; upstream fix available (PR/commit); released patched version not independently confirmed. If immediate patching is not possible, disable CONFIG_DEVICE_DEINIT_SUPPORT in the build - this eliminates the vulnerable code path because z_impl_device_deinit() returns -ENOTSUP before dereferencing the pointer, at the cost of losing device de-initialization functionality. For v4.2.x and v4.3.x this means explicitly setting the option to n; for v4.4.x ensure it is not explicitly enabled. Disabling CONFIG_USERSPACE also removes the syscall verification path but eliminates user-mode isolation entirely and is not recommended as a primary workaround. Since v4.2 is end-of-life, upgrade to a supported line or apply the commit backport if accepted. Review the vendor advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-j9m4-fr5f-49wm for additional guidance.

Affected VersionsENISA

Zephyr 4.2.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

Zephyr RTOS uses user-mode syscall verification handlers to enforce the CONFIG_USERSPACE isolation boundary. In kernel/device.c, z_vrfy_device_deinit() validated its dev argument with K_SYSCALL_OBJ_INIT(dev, K_OBJ_ANY); because k_object_validate() short-circuits type comparison when the requested type is K_OBJ_ANY, the check only confirmed that the pointer was the base address of some kernel object the calling thread had been granted, without comparing the object's actual type, and K_SYSCALL_OBJ_INIT also skipped the initialization-state check. This is CWE-843 type confusion. The sibling handlers z_vrfy_device_init() and z_vrfy_device_is_ready() already used K_OBJ_DRIVER_ANY and were unaffected. The fix changes the check to K_OBJ_DRIVER_ANY, constraining the argument to the build-generated driver object type range K_OBJ_DRIVER_FIRST..K_OBJ_DRIVER_LAST - the real struct device instances placed by the linker - so state and ops.deinit fields are once again kernel-controlled. The defect is reachable only when CONFIG_USERSPACE and CONFIG_DEVICE_DEINIT_SUPPORT are both enabled; with deinit support off, z_impl_device_deinit() returns -ENOTSUP before dereferencing the pointer. The independent assessment rates this as a genuine high-priority local privilege-escalation flaw with local access, low privileges, and changed scope because the userspace-to-kernel boundary is defeated; the CPE entry cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* uses a wildcard, so exposure depends on build configuration.

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 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

Local already-running user thread (AV:L, PR:L, AC:L); exploitation crosses the userspace/kernel security boundary yielding supervisor code execution, so S:C with full C/I/A impact.

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

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

DescriptionCVE.org

The user-mode verification handler for the device_deinit() system call, z_vrfy_device_deinit() in kernel/device.c, validated its dev argument with K_SYSCALL_OBJ_INIT(dev, K_OBJ_ANY). k_object_validate() short-circuits its type comparison when the requested type is K_OBJ_ANY, so the check reduced to "this pointer is the base address of some kernel object the calling thread has been granted" - the object's actual type was never compared, and K_SYSCALL_OBJ_INIT also skips the initialization-state check. The sibling handlers z_vrfy_device_init() and z_vrfy_device_is_ready() already used K_OBJ_DRIVER_ANY and were unaffected.

A thread running in user mode can therefore pass any kernel object it holds permission on - most usefully a thread stack object obtained from the k_thread_stack_alloc() syscall or a statically defined K_THREAD_STACK it was granted in order to spawn a child user thread - whose backing memory is writable from user mode. z_impl_device_deinit() then interprets those attacker-written bytes as a struct device: it dereferences the state pointer read out of the object, calls the function pointer read out of ops.deinit, and on success writes through state again. The result is an indirect call to an arbitrary address executed in supervisor mode, plus an arbitrary kernel read and a single-byte kernel write.

Exploitation gives a local unprivileged thread full kernel code execution, defeating the CONFIG_USERSPACE isolation boundary entirely; a less precise attempt yields a supervisor-mode fault and a system crash. The defect is only reachable in builds that enable both CONFIG_USERSPACE and CONFIG_DEVICE_DEINIT_SUPPORT - with de-initialization support disabled, z_impl_device_deinit() returns -ENOTSUP without ever dereferencing the pointer. In v4.2.x and v4.3.x, CONFIG_DEVICE_DEINIT_SUPPORT defaulted to y, so every CONFIG_USERSPACE build of those releases is exposed unless the option was explicitly turned off. From v4.4.0 the option is opt-in (no default, and not selected by any in-tree subsystem), so a v4.4.x build is exposed only if it enables the option explicitly. The v4.2 line is no longer maintained and receives no backport.

The fix changes the object check to K_OBJ_DRIVER_ANY, which constrains the argument to the build-generated driver object type range (K_OBJ_DRIVER_FIRST..K_OBJ_DRIVER_LAST) - the real struct device instances placed by the linker - so the state and ops.deinit fields are once again kernel-controlled.

Technical POC Analysis

Note on evidence: no public PoC code was identified in the supplied material.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Zephyr RTOS, a widely embedded real-time operating system used across connected device product lines, contains a local privilege escalation flaw in builds that enable both user-mode threads and device-deinitialization support - configurations that were on by default in the v4.2.x and v4.3.x release lines. An attacker with the ability to run code inside an affected device can escalate from an unprivileged user thread to full supervisor-mode control of the device, potentially compromising code execution, data integrity, and the trust anchor of any product built on these configurations. Leadership should care because remediation requires engineering effort to recompile and re-release firmware across the entire affected device fleet, not a simple infrastructure patch.

Business Impact: High
Compensating Controls

Apply vendor patch. Where patching cannot be completed immediately, disable CONFIG_DEVICE_DEINIT_SUPPORT, restrict the ability to execute untrusted code on affected devices, and monitor for anomalous supervisor-level behavior.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Medium
widely used embedded/IoT RTOS, but exposure limited to userspace-enabled builds
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

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.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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