Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRun unprivileged user-mode thread on Xtensa device
-
DeliveryCraft (addr, size) forcing ROUND_UP address wrap
-
ExploitCall syscall using k_usermode copy/string helper
-
ExecutionValidation skips MPU loop, returns permitted
-
PersistKernel reads or writes attacker-chosen memory
-
ImpactEscalate privileges or corrupt kernel state
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
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 | Requires the target device to be an Xtensa SoC built with BOTH CONFIG_XTENSA_MPU and CONFIG_USERSPACE, and the attacker must already be executing as an unprivileged user-mode thread on that device (PR:L, AV:L - local, authenticated at user level). The concrete trigger is passing a crafted (addr, size) to any syscall using k_usermode_from_copy/to_copy or k_usermode_string_copy such that size + alignment offset is near SIZE_MAX or ROUND_UP(size + offset) overflows the 32-bit address to 0, causing the MPU probe loop to run zero iterations. Limiting factors that reduce real-world exposure: it does not apply to non-Xtensa builds or Xtensa builds without MPU userspace, no remote vector exists (local thread execution is a prerequisite), and it depends on the specific compile-time configuration rather than a default. The string path (arch_user_string_nlen) is notably easier to reach because it has no syscall-layer overflow guard at all. |
| Impact | The CVSS 3.1 vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8 High) is internally consistent with the description: this requires local code execution as an unprivileged user-mode thread (AV:L, PR:L) with low complexity and no user interaction, and yields full confidentiality, integrity, and availability impact through arbitrary kernel memory read/write. There is no EPSS score, KEV entry, or POC in the provided data, so exploitation is theoretical-but-credible rather than demonstrated - no public exploit identified at time of analysis. The realistic priority is moderated by a narrow precondition: it only affects Xtensa SoCs specifically compiled with both CONFIG_XTENSA_MPU and CONFIG_USERSPACE, a niche embedded configuration, so the population of exposed devices is far smaller than Zephyr's overall footprint. For teams actually running that configuration, however, this is a genuine userspace-isolation bypass that defeats the primary security boundary and should be patched promptly; for everyone else it is not applicable. No signals conflict here - the vector, description, and patch all agree. |
| Exploit ScenarioDerived | An attacker who can run an unprivileged user-mode thread on an affected Xtensa device - for example via a compromised or malicious application partition - invokes any syscall that copies a user buffer (k_usermode_from_copy/to_copy or a string syscall) with a crafted (addr, size) pair whose rounded extent overflows the 32-bit address space to zero. Validation returns 'permitted' without probing any MPU region, so the kernel then reads attacker-chosen kernel memory (information disclosure) or, with write=1, overwrites kernel or other-partition memory (corruption), which can be leveraged into privilege escalation or denial of service. No public POC is available, but exploitation is low-complexity given local code execution. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 14, 2026
Local privilege escalation and kernel memory corruption in Zephyr RTOS on Xtensa SoCs (v3.7.0 through v4.4.0) built with CONFIG_XTENSA_MPU and CONFIG_USERSPACE, where arch_buffer_validate() fails open on an integer-overflow edge case, letting an unprivileged user thread trick the kernel into reading or writing arbitrary kernel/partition memory on its behalf. The flaw stems from a default-permit return value combined with a ROUND_UP address-space wrap that skips the MPU probe loop entirely, and it is not caught by the existing syscall-layer overflow guards. Vendor patch is available; no public exploit identified at time of analysis, and this is not in CISA KEV.
RemediationAI
Patch available per vendor advisory: upgrade to the Zephyr release containing fix commit 3b1bdaf5482188ca110ef9a411aaa8c7d3db3b16 (https://github.com/zephyrproject-rtos/zephyr/commit/3b1bdaf5482188ca110ef9a411aaa8c7d3db3b16), which makes arch_buffer_validate() deny-by-default, adds a size_add_overflow() guard, and only permits access after full-range validation; consult GHSA-4r4p-gh69-v6w4 for the exact tagged release. Because Zephyr is compiled into device firmware, remediation means rebuilding and reflashing affected images rather than a runtime update. If immediate patching is not feasible, the most effective compensating control is to disable CONFIG_USERSPACE (or CONFIG_XTENSA_MPU) for the Xtensa build, which removes the vulnerable path entirely at the cost of losing user/kernel isolation - acceptable only if the application does not rely on untrusted user threads. Alternatively, cherry-pick the upstream fix onto your maintained branch and reflash, and audit any custom syscalls that copy user buffers.
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 affected component is Zephyr's Xtensa architecture memory-protection hook, arch/xtensa/core/mpu.c, which enforces user/kernel isolation via the Xtensa MPU when CONFIG_USERSPACE is enabled. arch_buffer_validate() is called from the syscall boundary (via k_usermode_from_copy/to_copy and k_usermode_string_copy) to confirm a user-supplied buffer is legitimately accessible to the calling thread before the kernel dereferences it. The root cause is CWE-787 (Out-of-bounds Write, alongside out-of-bounds read): the function initialized ret=0 (permit) and only set a denial inside a per-MPU-region probe loop, so any code path that skips the loop returns 'permitted.' Rounding the buffer extent with ROUND_UP(size + alignment offset) can overflow the 32-bit address space to 0, producing zero loop iterations. The upstream fix (commit 3b1bdaf5) inverts the default to -EINVAL (deny-by-default), adds a size_add_overflow() check via math_extras.h, and only sets ret=0 after the entire range validates - the classic fail-closed correction for a permission gate.
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 unprivileged user thread required (AV:L, PR:L), trivially triggered overflow (AC:L), yielding arbitrary kernel read/write for full C/I/A impact within the same protection scope.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
On Xtensa SoCs built with CONFIG_XTENSA_MPU and CONFIG_USERSPACE, arch_buffer_validate() in arch/xtensa/core/mpu.c - the architecture hook that verifies a user-mode-supplied buffer is accessible to the calling user thread with the requested permission - defaulted its return value to 0 (access permitted) and only set a denial result inside its per-MPU-region probe loop. When the rounded extent of the buffer wraps the 32-bit address space (size + alignment offset near SIZE_MAX, or ROUND_UP(size + offset) overflowing to 0), the loop executes zero iterations and the function returns 0 = permitted without probing any MPU region.
The syscall-layer pre-checks (K_SYSCALL_MEMORY_SIZE_CHECK / Z_DETECT_POINTER_OVERFLOW) only catch a raw addr+size wrap and do not cover the ROUND_UP-induced wrap, and the string path (arch_user_string_nlen -> arch_buffer_validate) has no syscall-layer guard at all.
An unprivileged user-mode thread can therefore pass a crafted (addr, size) to any syscall that validates user buffers via k_usermode_from_copy/to_copy or k_usermode_string_copy and have validation succeed for memory it must not access; the kernel then reads from (disclosure) or, with write=1, writes to (corruption) attacker-chosen kernel or other-partition memory on the thread's behalf, enabling information disclosure, memory corruption, privilege escalation, and denial of service.
Affected from v3.7.0 (when Xtensa MPU userspace support was added) through v4.4.0. The fix changes the default to -EINVAL (deny by default), adds an explicit size_add_overflow check, and sets the success value only after the full range has been validated.
Executive ViewAI
Zephyr RTOS versions 3.7.0-4.4.0 with Xtensa memory protection enabled contain a privilege escalation flaw allowing unprivileged applications to achieve kernel-level access and corrupt memory, with no public exploit identified at time of analysis. Organizations using affected versions in embedded and IoT systems face significant risk of system compromise and data integrity violation.
Apply vendor patch.
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
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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-43696
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB