Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain user-mode thread granted entropy device
-
DeliveryInvoke entropy_get_entropy syscall, length 1, chosen address
-
ExploitTrigger dataSize underflow in TRNG SDK
-
ExecutionKernel writes ~127 uncontrolled bytes past buffer
-
ImpactCorrupt adjacent kernel state, escalate or crash
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 all of: (1) an affected NXP SoC where the MCUX SDK compiles TRNG_SW_HEALTH_TESTS - MIMXRT595S, MIMXRT555S, MIMXRT533S, MIMXRT685S, or MIMXRT633S - with the TRNG as the zephyr,entropy chosen node; other SoCs take the clamping SDK path and are unaffected. (2) A request whose length is not a multiple of 4 bytes (e.g. 1), which is what causes the SDK's dataSize to underflow. For the syscall-driven privilege-boundary case: CONFIG_USERSPACE must be enabled and the unprivileged thread must have been granted the entropy device, after which it controls both destination address and length. The kernel-mode path (getentropy(), and sys_rand8_get()/sys_rand16_get() where sys_csrand_get()/sys_rand_get() resolve to the hardware generator) is reachable by any caller requesting a non-word-multiple length even without userspace. Limiting factors: local access only (no remote vector), the bug is absent on non-affected SoCs, and the overflow content is uncontrolled random data rather than attacker-chosen bytes. |
| Impact | The input CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) describes a locally-reachable, low-complexity flaw requiring low privileges, which matches the description: an unprivileged user-mode thread (PR:L) that has merely been granted the entropy device can trigger a deterministic out-of-bounds write of up to 127 bytes. Exploitation status is 'no public exploit identified at time of analysis' - there is no EPSS score, no CISA KEV listing, and no POC indicated in the input, only a vendor patch and GHSA advisory; absence of these signals means this is a disclosed-and-patched issue rather than one under active exploitation. The high CVSS is driven by the escalation potential on MMU-less Cortex-M33 targets where user and kernel share one SRAM, so this is a genuine priority for anyone shipping the affected NXP parts with CONFIG_USERSPACE, but not an emergency 'patch-tonight' scenario in the absence of exploitation evidence. One signal to weigh independently: the input marks C:H (confidentiality High), yet the described primitive writes uncontrolled TRNG output and does not directly disclose data - confidentiality impact is at most opportunistic (secondary to a successful privilege escalation), so the real-world impact is weighted toward integrity and availability (corruption, crashes). No SSVC decision data was provided in the input to cross-reference. |
| Exploit ScenarioDerived | On an affected NXP i.MX RT MCU running Zephyr with CONFIG_USERSPACE, an unprivileged application thread that has been granted access to the entropy device calls the entropy_get_entropy() syscall requesting a non-word-multiple length (e.g. 1 byte) at an attacker-chosen destination. The SDK's dataSize == 0 guard underflows and the generator writes up to 127 bytes of random data past the validated region into adjacent kernel SRAM, corrupting kernel bookkeeping such as object permission bitmaps and opening a path from crash to opportunistic privilege escalation. No public exploit code is identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 11, 2026
An out-of-bounds write of up to 127 bytes in the Zephyr RTOS NXP MCUX TRNG entropy driver (drivers/entropy/entropy_mcux_trng.c) allows a locally-present attacker to corrupt memory immediately following a caller-supplied buffer on affected NXP i.MX RT5xx/RT6xx SoCs. Because entropy_get_entropy() is a syscall whose verifier (K_SYSCALL_MEMORY_WRITE) checks only the requested length, an unprivileged user-mode thread that has merely been granted the entropy device can supply a length such as 1 and an arbitrary destination, causing the kernel to write 128 bytes where 1 was proven to be owned; on these Cortex-M33 parts there is no MMU, so the overflow can land in adjacent kernel state. The same defect is reachable from kernel mode via getentropy() or sys_rand8_get()/sys_rand16_get() where those resolve to the hardware generator. No public exploit code was identified at time of analysis and the flaw is not confirmed as actively exploited (no CISA KEV listing), but exploitation is local, deterministic in offset, and low complexity, which the assessed vector captures as AV:L/AC:L/PR:L with changed scope and high integrity impact.
RemediationAI
Apply the upstream fix at commit 2c132efaf03a5d45aeaf7b0531c1107db7a36a3d (advisory GHSA-3f6q-3949-rqph), which makes entropy_mcux_trng_get_entropy() copy any unaligned prefix and any sub-word tail through a local bounce word and passes the SDK only word-multiple lengths; because this is a commit rather than a tagged release, upstream fix available (PR/commit); released patched version not independently confirmed, so downstream integrators should cherry-pick the commit or rebase onto a revision that contains it and re-verify their NXP SDK blob. Where the patch cannot be applied immediately: remove CONFIG_USERSPACE on affected i.MX RT5xx/RT6xx boards (trade-off: loses memory-domain isolation for all user threads, a broad regression in defence in depth), or revoke the entropy device grant from unprivileged threads (trade-off: legitimate user-mode crypto/RNG consumers break) while keeping the syscall available; and avoid driving the MCUX TRNG with non-word-multiple lengths by wrapping entropy_get_entropy() callers in a helper that rounds lengths up to a multiple of four and supplies a buffer at least 127 bytes larger than requested (trade-off: wastes SRAM and requires auditing every getentropy(), sys_rand8_get() and sys_rand16_get() path). Because the written content is uncontrolled TRNG output rather than attacker-chosen bytes, the practical outcomes range from crashes to corrupted kernel state; treat any device that ran an unpatched build with CONFIG_USERSPACE as potentially integrity-compromised, and note this is a local-only issue with no remote attack vector.
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 driver is a thin Zephyr shim over the NXP MCUXpresso SDK routine TRNG_GetRandomData(), which generates entropy at 32-bit word granularity. On the SoCs where the SDK compiles its TRNG_SW_HEALTH_TESTS variant, that routine always copies whole words and rounds the extraction up to a multiple of 128 bytes; its internal 'caller buffer is full' guard tests dataSize == 0, so any request whose length is not a multiple of four underflows dataSize past zero and the SDK continues writing words for the remainder of the extraction. The Zephyr wrapper passed the caller's byte count straight through with no alignment or rounding, so a 1-byte request produces a 128-byte write and any non-word-multiple length overruns by up to 127 bytes. Root cause is CWE-787 (out-of-bounds write) arising from a granularity/size mismatch at a library boundary rather than from a malformed input parser. The privilege boundary is crossed because entropy_get_entropy() is a syscall: with CONFIG_USERSPACE enabled, the syscall verifier in drivers/entropy/entropy_handlers.c validates only the declared length through K_SYSCALL_MEMORY_WRITE(), never accounting for the SDK's word-rounded copy size, so a user thread granted the entropy device controls both destination address and length. Affected Cortex-M33 targets lack an MMU, meaning user partitions and kernel data share one SRAM and the overrun can overwrite kernel bookkeeping such as object permission bitmaps. The upstream fix (commit 2c132efaf03a5d45aeaf7b0531c1107db7a36a3d) routes any unaligned prefix and any sub-word tail through a local bounce word and hands the SDK only word-multiple sizes, eliminating the underflow.
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 syscall needing an entropy-device grant (PR:L, AV:L, AC:L); the write crosses from an unprivileged partition into kernel state on an MMU-less target (S:C); impact is corruption not disclosure, so I:H/A:H and only C:L.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The NXP MCUX TRNG entropy driver in drivers/entropy/entropy_mcux_trng.c passed the caller's byte count straight to the vendor SDK routine TRNG_GetRandomData(). On i.MX RT5xx and RT6xx parts the SDK compiles its TRNG_SW_HEALTH_TESTS variant, which always copies whole 32-bit words and draws entropy rounded up to a multiple of 128 bytes. Its "caller buffer is full" guard tests dataSize == 0, so a request whose length is not a multiple of four makes dataSize underflow past zero and the SDK keeps writing into the caller's buffer for the entire extraction: a 1-byte request results in 128 bytes written, and any non-word-multiple length overflows by up to 127 bytes.
entropy_get_entropy() is a syscall, and its verifier in drivers/entropy/entropy_handlers.c validates only the requested length via K_SYSCALL_MEMORY_WRITE(). With CONFIG_USERSPACE enabled, an unprivileged user-mode thread that has merely been granted the entropy device can therefore choose both the destination address and a length such as 1, and cause the kernel to write up to 127 bytes beyond the region it proved it owns. On these Cortex-M33 targets there is no MMU, so user partitions and kernel data share one SRAM and the overflow can land in adjacent kernel state. The same defect is reached from kernel mode by any caller requesting a non-word-multiple length, including getentropy() and, in builds where sys_csrand_get()/sys_rand_get() resolve to the hardware generator, sys_rand8_get() and sys_rand16_get().
Impact is memory corruption of up to 127 bytes immediately following the supplied buffer - typically the caller's stack in kernel-mode use, or memory outside the caller's partition when driven through the syscall. The overflow offset is fully determined by the requested length and is therefore deterministic, while the written content is uncontrolled TRNG output; the practical consequences range from crashes and unpredictable state corruption to opportunistic escalation when kernel bookkeeping such as object permission bitmaps is overwritten. The affected devices are those where the MCUX SDK enables TRNG_SW_HEALTH_TESTS (MIMXRT595S, MIMXRT555S, MIMXRT533S, MIMXRT685S, MIMXRT633S), on which the TRNG is the zephyr,entropy chosen node; other SoCs using this driver take the SDK path that clamps the copy size and are unaffected.
The fix routes any unaligned prefix and any sub-word tail through a local bounce word and hands the SDK only word-multiple sizes, so the SDK's word-granular writes can no longer pass the end of the caller's buffer.
Technical POC Analysis
CWE-787 (Out-of-bounds Write) in entropymcuxtrnggetentropy() in drivers/entropy/entropymcuxtrng.c.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Zephyr RTOS-based devices built on NXP i.MX RT5xx and RT6xx SoCs are affected by a high-severity memory corruption flaw in the NXP MCUX TRNG entropy driver. A local attacker with access to the entropy device could corrupt kernel memory, potentially leading to device instability, unauthorized code execution, or a complete loss of trust in the affected product. Security leadership should prioritize patching because these embedded systems often underpin critical operational, industrial, or consumer functions where availability and integrity are paramount.
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-97115
NVD
CVE.org
EPSS
GitHub
Exploit-DB