Skip to main content

Zephyr RTOS CVE-2026-12235

| EUVDEUVD-2026-57070 MEDIUM
Out-of-bounds Write (CWE-787)
2026-08-12 zephyr
6.3
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Access
    Obtain low-privilege write access to extension storage
  2. Delivery
    Craft relocatable ELF with RELA entry where r_offset exceeds target section size
  3. Exploit
    Submit ELF to application that calls llext_load()
  4. Execution
    llext_link_plt() computes out-of-bounds patch address using unvalidated r_offset
  5. Persist
    Supervisor-context write corrupts memory beyond extension text buffer
  6. Impact
    Leverage corrupted kernel structure for privilege escalation or denial of service

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

Exploitation requires all of the following to be true simultaneously: (1) the Zephyr device runs on Xtensa architecture - the vulnerable code path (tgt != NULL branch in llext_link_plt()) is specific to Xtensa relocatable ELF processing and is not triggered on other Zephyr-supported architectures; (2) the llext subsystem is compiled in (CONFIG_LLEXT=y in Kconfig); (3) the attacker can write a crafted ELF file to storage locations accessible to the llext loader - llext documentation states it is designed to accept extensions of untrusted origin, so this may be an intended workflow; (4) the application invokes llext_load() on attacker-influenced input at runtime. The CVSS PR:L metric confirms low-privilege access is sufficient. Exploitation is further limited by the fact that the write value is not fully arbitrary - it is the resolved symbol address - making reliable memory corruption into useful code execution non-trivial. The vulnerability is completely absent on non-Xtensa builds and in builds where CONFIG_LLEXT=n.

Impact

The vendor-supplied CVSS 3.1 vector (AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:H, score 6.3) accurately captures the constrained attack surface: local access to writable extension storage is prerequisite, complexity is high because the write value is constrained to a resolved symbol address rather than a fully arbitrary value, and no confidentiality loss occurs. However, the S:U (Unchanged scope) rating warrants scrutiny - the description explicitly states 'sandbox-boundary escape for user-mode extensions' as an impact, which implies the user-mode extension sandbox boundary is crossed to affect supervisor context, a potential scope-change scenario. This analysis independently assesses scope as Changed (S:C), which would raise the effective severity. No EPSS score was included in the provided intelligence data, making probabilistic exploitation forecasting unavailable. The CVE is not listed in CISA KEV, and no POC or active exploitation has been identified. Real-world prioritization should weight architecture specificity (Xtensa-only), feature dependency (CONFIG_LLEXT=y required), and the non-trivial conversion of the OOB write into a reliable primitive - making this a meaningful but not urgent finding for most Zephyr deployments.

Exploit ScenarioDerived

An attacker with low-privilege access to a Zephyr-based Xtensa device crafts a relocatable ELF extension containing a RELA entry with an r_offset value larger than the target section size, then writes it to extension storage accessible to the llext loader. When the Zephyr application calls llext_load() on the crafted extension, llext_link_plt() processes the malicious relocation entry and performs a supervisor-context out-of-bounds write before any extension code executes - potentially overwriting kernel data structures, function pointers, or security-critical metadata. Converting this write (constrained to a resolved symbol address value) into a reliable privilege escalation or persistent code execution primitive requires additional attacker effort and knowledge of the target memory layout, but the supervisor-context write location is attacker-influenced via r_offset.

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

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

Alert me

AnalysisAIv1 – Aug 12, 2026

Out-of-bounds write in Zephyr RTOS's llext subsystem allows a local attacker with low privileges to corrupt supervisor-context memory by loading a crafted relocatable ELF extension on Xtensa targets. The vulnerability in llext_link_plt() (subsys/llext/llext_link.c) occurs before any extension code executes - at link time - meaning sandbox protections are bypassed entirely. Exploitation complexity is high (CVSS AC:H) due to constraints on the write value, no public exploit code or CISA KEV listing exists at time of analysis, and impact is confined to deployments using llext on Xtensa architecture.

RemediationAI

The primary remediation is to integrate upstream commit 106540afbd22087ad40b90f53fb22657754a719e from the Zephyr repository, which adds the bounds check (if rela.r_offset >= tgt->sh_size, skip the entry) to llext_link_plt(). Refer to the vendor advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-xv9q-6mrf-8j49 and confirm the fix is included in the Zephyr SDK version used by the project. A specific patched release version was not confirmed in the available data - verify with upstream release notes before closing the finding. Where immediate patching is not feasible, the most effective compensating control is disabling llext entirely via CONFIG_LLEXT=n in the Kconfig build configuration, which eliminates the attack surface at the cost of losing dynamic extension loading capability. Alternatively, restrict extension loading to cryptographically signed, trusted-source ELFs and enforce that restriction in the application layer - this reduces attacker ability to supply crafted input, though it does not fix the underlying code defect. Restricting write access to extension storage paths to privileged processes only (AV:L, PR:L mitigation) reduces the attacker population but does not eliminate the vulnerability for privileged users.

Affected VersionsENISA

Zephyr 3.7.0 <4.4.2

Affected Packages

euvd zephyr fix: 4.4.2

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 Linkable Loadable Extensions (llext) subsystem in Zephyr RTOS enables dynamic loading of compiled ELF modules at runtime. Zephyr explicitly documents llext as capable of accepting extensions of untrusted origin. The vulnerable function, llext_link_plt() in subsys/llext/llext_link.c, processes PLT/RELA relocation entries during the Xtensa-specific relocatable (partially-linked) ELF path (the tgt != NULL branch). The patch address is calculated as ext->mem[LLEXT_MEM_TEXT] - text.sh_offset + rela.r_offset + tgt->sh_offset, and the relocation write is performed at that address without first validating that rela.r_offset falls within the target section's bounds. The sibling shared/dynamic branch already performed equivalent validation via llext_file_offset(), creating an asymmetric validation gap. CWE-787 (Out-of-bounds Write) is the root cause: rela.r_offset is attacker-controlled input read directly from the ELF RELA table, allowing a crafted entry to cause the write to land arbitrarily beyond the extension's text buffer in supervisor memory. All Zephyr versions are affected per CPE cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* prior to the upstream commit fix. The fix mirrors the existing validation: a guard rejecting any RELA entry where rela.r_offset >= tgt->sh_size was added to the Xtensa relocatable branch.

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

AV:L and PR:L per storage write requirement; AC:H for non-trivial primitive conversion; S:C because supervisor sandbox boundary is explicitly crossed from user-mode extension context.

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

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

DescriptionCVE.org

The Linkable Loadable Extensions (llext) subsystem mis-handles PLT/RELA relocation entries when linking a relocatable (partially-linked) ELF extension. In llext_link_plt() (subsys/llext/llext_link.c), the relocatable branch (tgt != NULL, the path used for Xtensa relocatable objects) computed the patch address as ext->mem[LLEXT_MEM_TEXT] - text.sh_offset + rela.r_offset + tgt->sh_offset and then performed the relocation write there without validating rela.r_offset. Its sibling shared/dynamic branch already rejected out-of-range offsets via llext_file_offset().

rela.r_offset is read directly from the ELF's RELA table, so a crafted entry with an offset larger than the target section makes the write land arbitrarily far outside the extension's text buffer. The result is an attacker-influenced out-of-bounds write (the location via r_offset, the written value being the resolved symbol address) performed in supervisor context at link time, before any extension code runs.

The path is reached from llext_load() whenever an application loads an attacker-influenced ELF extension on Xtensa with writable storage; llext is documented to accept extensions of untrusted origin. Impact is supervisor-context memory corruption (integrity and availability loss, and a sandbox-boundary escape for user-mode extensions). Exploitation is gated by the Xtensa relocatable PLT path and writable storage, and turning the out-of-range write into a useful primitive is non-trivial.

The fix adds a bound check rejecting any RELA entry whose r_offset >= tgt->sh_size, mirroring the existing validation in the shared branch.

Threat Intelligence Overview

EPSS Score
10.0%
Prevalence
Medium
popular open-source RTOS for IoT and embedded devices
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 10.0%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

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.

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