Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain unprivileged user-mode thread execution
-
DeliveryAllocate user-writable thread stack object
-
ExploitForge fake struct device with malicious ops.deinit
-
ExecutionInvoke device_deinit() syscall on it
-
ImpactSupervisor-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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
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.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
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
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.
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
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
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.
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-95530
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB