Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain unprivileged user-mode thread with LPADC device access
-
DeliveryCraft adc_sequence: many channels, tiny buffer, large extra_samplings
-
ExploitInvoke adc_read()/adc_read_async() syscall
-
ExecutionDriver writes samples unbounded in kernel ISR/DMA context
-
PersistLinear out-of-bounds write into kernel data and stacks
-
ImpactPrivilege 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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'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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
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.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
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
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.
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
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-88471
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB