Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain low-privilege write access to extension storage
-
DeliveryCraft relocatable ELF with RELA entry where r_offset exceeds target section size
-
ExploitSubmit ELF to application that calls llext_load()
-
Executionllext_link_plt() computes out-of-bounds patch address using unvalidated r_offset
-
PersistSupervisor-context write corrupts memory beyond extension text buffer
-
ImpactLeverage 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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 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
AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:H
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.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
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
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
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.
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-57070
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB