Skip to main content

Zephyr RTOS CVE-2026-18413

| EUVDEUVD-2026-88471 HIGH
Out-of-bounds Write (CWE-787)
2026-09-28 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
    Obtain unprivileged user-mode thread with LPADC device access
  2. Delivery
    Craft adc_sequence: many channels, tiny buffer, large extra_samplings
  3. Exploit
    Invoke adc_read()/adc_read_async() syscall
  4. Execution
    Driver writes samples unbounded in kernel ISR/DMA context
  5. Persist
    Linear out-of-bounds write into kernel data and stacks
  6. Impact
    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 as a privilege-escalation/DoS primitive requires ALL of: (1) a Zephyr build compiled with CONFIG_USERSPACE so adc_read()/adc_read_async() are system calls; (2) use of the NXP MCUX LPADC driver (adc_mcux_lpadc.c) in interrupt-driven mode, or DMA-driven mode on releases that include the DMA path; and (3) an attacker-controlled unprivileged user-mode thread that has been granted access to the LPADC device object, giving it control over channels, buffer, buffer_size and options->extra_samplings. The attacker crafts a sequence requesting far more samples than the buffer holds (up to channels × 65536 into a two-byte buffer). Limiting factors: local access only (no remote vector), the thread must already hold the device-object grant, and builds WITHOUT CONFIG_USERSPACE are affected only as a caller-side robustness defect because the application itself supplies the buffer.

Impact

This is a genuine local privilege-escalation and denial-of-service primitive, not an inflated high-CVSS score. The vendor CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 7.8) is internally consistent with the description: an unprivileged user-mode thread (PR:L) that has been granted access to an LPADC device object can trigger kernel-mode out-of-bounds writes of attacker-chosen length and offset with no user interaction and low complexity. The high C/I/A ratings are justified because the writes occur in kernel context (ISR or DMA callback) where the MPU does not enforce the thread's memory domain, so corruption reaches other partitions, kernel data and thread stacks. Signals are LIMITED on the exploitation side: no EPSS score, no CISA KEV listing, and no public POC were provided, so real-world exploitation is unproven - appropriate given this is a local-only bug in an embedded RTOS driver rather than a network-facing service. The one caveat is scope: the vendor marks S:U, but a user-to-kernel memory corruption arguably crosses a security boundary (S:C); this does not change the local, authenticated-context nature of the flaw. Overall a real but conditionally-triggered priority - meaningful for security-critical Zephyr deployments using the NXP LPADC with CONFIG_USERSPACE, low practical risk elsewhere.

Exploit ScenarioDerived

On a Zephyr build with CONFIG_USERSPACE enabled, a low-privileged user-mode thread that has been granted access to an NXP MCUX LPADC device object calls adc_read()/adc_read_async() with a small buffer (e.g. two bytes) but selects multiple channels and a large options->extra_samplings count. Because mcux_lpadc_start_read() performs no buffer-size validation, the driver writes up to channels × 65536 16-bit samples via an unbounded *data->buffer++ in kernel-mode ISR/DMA context, walking out of the user partition into kernel data and thread stacks. No public exploit code was identified at time of analysis; the fix and advisory ship a validation helper rather than a weaponized POC.

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 – Sep 28, 2026

An out-of-bounds kernel-mode write in Zephyr RTOS's NXP MCUX LPADC driver (drivers/adc/adc_mcux_lpadc.c) lets an unprivileged user-mode thread corrupt memory outside its own partition, providing a genuine local privilege-escalation and denial-of-service primitive rather than an inflated high-severity score. The bug affects builds compiled with CONFIG_USERSPACE that use the MCUX LPADC driver in interrupt-driven mode (or DMA-driven mode on releases carrying the DMA path), where adc_read()/adc_read_async() are system calls: a thread already granted access to the LPADC device object controls channels, buffer, buffer_size and options->extra_samplings, and can demand up to channels × 65536 samples into a tiny buffer, causing the driver's ISR or DMA callback to walk past the buffer while running in kernel mode where the MPU does not confine it. No public exploit code or confirmed active exploitation has been identified at time of analysis, but the CVSS vector (7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects high confidentiality and integrity impact from an authenticated local attacker, and upstream fixes are available.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - apply the upstream commits 9338c518bf2b6a396f166d4dbe9985ce7e44379c and 3bda971a52ddbbec28f6fcfe3b006d34e8b9e5a9, which introduce the shared helper adc_sequence_validate_buffer() in drivers/adc/adc_common.c (computing active_channels * sizeof(uint16_t) * (1 + extra_samplings) and returning -ENOMEM before any sampling starts) and call it from mcux_lpadc_start_read(). See the vendor advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-7jqq-2g5q-hcrp for coordinated guidance. Where the patched code cannot be deployed immediately, the most effective compensating control is to avoid granting the LPADC device object to user-mode threads (remove it from the thread's memory-domain/device-access configuration) so no unprivileged thread can reach adc_read()/adc_read_async() with attacker-controlled sequence parameters; the trade-off is that those threads lose all ADC functionality. If the ADC must remain reachable from userspace and the build uses the MCUX LPADC driver, consider switching to a different Zephyr ADC driver implementation that already validates buffer_size, or, as a last resort, building without CONFIG_USERSPACE - noting that this removes the syscall boundary and reverts the issue to a caller-side robustness defect while degrading the overall userspace isolation posture of the device. Note that builds without CONFIG_USERSPACE require only caller-side buffer-size discipline and are not exposed to the privilege-escalation primitive.

Affected VersionsENISA

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

Zephyr's ADC API contract, documented in include/zephyr/drivers/adc.h for struct adc_sequence, requires each driver to refuse a sequence whose destination buffer is too small and to return an error instead of writing beyond buffer_size. The NXP MCUX LPADC driver violated that contract: mcux_lpadc_start_read() unconditionally assigned data->buffer = sequence->buffer with no size validation, and every completed conversion then performed an unbounded store through *data->buffer++ in mcux_lpadc_isr() (interrupt builds) or mcux_lpadc_dma_callback() (DMA builds), writing one 16-bit sample per enabled channel per sampling round. The root cause class is CWE-787, an out-of-bounds write stemming from missing length validation before pointer consumption. The severity is amplified by Zephyr's userspace syscall layer: with CONFIG_USERSPACE, adc_read() and adc_read_async() are system calls whose handler in drivers/adc/adc_handlers.c copies the sequence from user memory, checks only that [buffer, buffer + buffer_size) lies within the calling thread's writable memory, and explicitly rejects a user-supplied options->callback - deliberately delegating size arithmetic to the driver. Because the sample pointer is rewound only on a repeat sampling and never across extra samplings, a two-channel sequence with a two-byte buffer writes the second and all subsequent samples past the end. Critically, the offending stores execute in kernel mode, either in the ADC interrupt handler or the DMA completion callback, where the MPU does not enforce the originating thread's memory domain, so the write marches linearly out of the user partition into adjacent partitions, kernel data structures, or thread stacks - yielding corruption of attacker-chosen length at an attacker-chosen offset. On builds without CONFIG_USERSPACE the flaw degrades to a caller-side robustness defect, since the application itself supplies the buffer.

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 7.8 HIGH

Local user-mode thread with a device grant (PR:L) triggers kernel out-of-bounds writes at will (AC:L, UI:N); attacker-chosen kernel corruption yields full C/I/A; S:U kept per vendor though user→kernel crossing arguably S:C.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/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:N/SI:N/SA:N

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 ADC API requires each driver to reject a sampling sequence whose destination buffer is too small: the buffer_size field of struct adc_sequence in include/zephyr/drivers/adc.h documents that "the driver must ensure that samples are not written beyond the limit and it must return an error if the buffer turns out to be not large enough". The NXP MCUX LPADC driver did not honour that contract. mcux_lpadc_start_read() in drivers/adc/adc_mcux_lpadc.c performed no buffer-size check at all before assigning data->buffer = sequence->buffer. Each completed conversion then stores one 16-bit sample per enabled channel per sampling round through an unbounded *data->buffer++: in mcux_lpadc_isr() for interrupt-driven builds, and in mcux_lpadc_dma_callback() for DMA-driven builds on releases that have the DMA path. A sequence selecting two channels with a two-byte buffer, for example, has its second sample written past the end of the buffer.

On a build with CONFIG_USERSPACE, adc_read() and adc_read_async() are system calls. The handler in drivers/adc/adc_handlers.c copies the sequence in from user memory, verifies only that [buffer, buffer + buffer_size) is writable by the calling thread, and rejects a user-supplied options->callback; it deliberately leaves the size arithmetic to the driver. A user-mode thread that has been granted access to an LPADC device object therefore fully controls channels, buffer, buffer_size and options->extra_samplings, and can request far more samples than its buffer can hold: up to channels * 65536 samples into a two-byte buffer, since the sample pointer is only rewound on a repeat sampling, never on the extra samplings of a sequence.

The resulting stores are performed by the driver in kernel mode (in the ADC interrupt handler or the DMA completion callback), where the MPU does not restrict the thread's memory domain, so the write walks linearly out of the user partition and into adjacent memory such as other partitions, kernel data or thread stacks. The impact is kernel-memory corruption of attacker-chosen length at an attacker-chosen offset, a plausible privilege-escalation and denial-of-service primitive from an unprivileged user-mode thread. Builds without CONFIG_USERSPACE are affected only as a caller-side robustness defect, since the application itself supplies the buffer.

The fix calls the new shared helper adc_sequence_validate_buffer() in drivers/adc/adc_common.c from mcux_lpadc_start_read(). The helper computes active_channels sizeof(uint16_t) (1 + extra_samplings) and returns -ENOMEM before any sampling is started.

Technical POC Analysis

CWE-787 (out-of-bounds write).

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

A memory-corruption flaw in the NXP MCUX LPADC driver shipped with Zephyr RTOS allows an already-authenticated local user-mode thread on affected CONFIG_USERSPACE builds to write outside its memory partition and escalate to kernel-level privileges or crash the device. Because Zephyr is widely embedded in NXP-based IoT and industrial products, a successful attack could let a low-privileged process on a compromised device take full control of the platform, bypass MPU isolation, and cause persistent denial of service. Leadership should care because this undermines the core isolation guarantee organizations rely on when deploying these devices in the field, and remediation requires coordination with downstream product and firmware teams rather than a single IT patch cycle.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Medium
Zephyr is a popular RTOS, but flaw is confined to NXP LPADC-based boards
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
Defer
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

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