Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain serial line access to target device
-
DeliveryConfirm CONFIG_UART_MCHP_ASYNC firmware build
-
ExploitSend byte during uart_rx_enable with 1-byte buffer
-
ExecutionISR triggers DMA with pending DATA register byte
-
PersistDMA writes one byte past buffer end
-
ImpactAdjacent memory corruption causes crash or DoS
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 | Four specific conditions must all be satisfied simultaneously: (1) firmware must be compiled with CONFIG_UART_MCHP_ASYNC=y - this is explicitly not the default for in-tree PIC32CM-JH board configurations; (2) the application layer must call uart_rx_enable() with a receive buffer of exactly one byte (len == 1); (3) the attacker must have physical or logical serial line access to the target device's UART peripheral - network-remote exploitation is not possible; (4) a received byte must be pending in the SERCOM DATA register at the precise moment the RX-complete ISR fires, introducing a timing dependency that raises practical exploitation difficulty. What limits exploitation: non-default Kconfig requirement, narrow application coding pattern, physical/adjacent access requirement, single-byte fixed-location overwrite only (no control over write offset or size), and no confidentiality impact. Exploitation against default Zephyr PIC32CM-JH configurations is not possible. |
| Impact | The CVSS 3.1 score of 4.2 (Medium) with vector AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L accurately reflects the constrained real-world risk profile. The adjacent attack vector (AV:A) requires the attacker to be physically or logically connected to the target UART serial interface - eliminating remote internet-scale exploitation entirely. High attack complexity (AC:H) captures two compounding prerequisites: a non-default Kconfig option (CONFIG_UART_MCHP_ASYNC) and a specific application-level call pattern (1-byte receive buffer), plus timing dependency for the pre-buffered byte. Impact is bounded to a single fixed-location, fixed-size (one byte) write, with no confidentiality exposure. No EPSS data was provided in the intelligence feed; the vulnerability is absent from CISA KEV and no POC exists. For the vast majority of Zephyr deployments, this is a non-issue; risk is only relevant to firmware teams explicitly building PIC32CM-JH targets with async UART enabled and 1-byte buffer consumers. |
| Exploit ScenarioDerived | An attacker with a serial connection to a PIC32CM-JH device running Zephyr firmware compiled with CONFIG_UART_MCHP_ASYNC enabled transmits a byte at the moment the firmware's RX path calls uart_rx_enable() with a 1-byte buffer, ensuring a byte is pending in the SERCOM DATA register when the RX-complete ISR fires. The DMA transfer then writes the attacker-supplied byte value to the memory location immediately following the receive buffer, corrupting adjacent memory. Depending on the firmware's memory layout, this could overwrite a stack variable, heap metadata, or a function pointer, most likely resulting in a crash, but potentially enabling further exploitation in specific memory arrangements. No public POC exists for this scenario. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 28, 2026
Out-of-bounds write in Zephyr RTOS's Microchip SERCOM-G1 UART driver (introduced in v4.4.0) allows an adjacent attacker who can send serial data to corrupt one byte of memory immediately beyond the caller-supplied RX buffer, potentially causing a crash or denial of service. The flaw exists only when CONFIG_UART_MCHP_ASYNC is enabled (non-default on in-tree PIC32CM-JH board configs) and the consuming application calls uart_rx_enable() with a one-byte buffer - a narrow but real embedded firmware scenario. No exploit code is publicly available and this vulnerability is not listed in CISA KEV; the upstream fix has been committed but a tagged patched release version has not been independently confirmed.
RemediationAI
Apply the upstream fix from commit 5251d2bc0070be801769fb7ce7b9066fef5d9f81 (https://github.com/zephyrproject-rtos/zephyr/commit/5251d2bc0070be801769fb7ce7b9066fef5d9f81), which restructures the async RX ISR to read the first incoming byte directly via CPU and bypasses DMA entirely for 1-byte buffers; a specific patched tagged release version was not confirmed in the available data, so monitor the Zephyr project release page for a version incorporating this commit. As the most effective compensating control, disable CONFIG_UART_MCHP_ASYNC in the project Kconfig if asynchronous UART is not operationally required - this eliminates the vulnerable code path entirely with no functional impact on synchronous UART use. If async mode is required, ensure all callers of uart_rx_enable() use receive buffers of at least two bytes; this prevents the overflow, though enforcing this at the application layer across a firmware codebase is fragile and should not substitute for the upstream patch.
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 vulnerability resides in drivers/serial/uart_mchp_sercom_g1.c within the Zephyr RTOS project (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*), targeting PIC32CM-JH SoC family hardware built around Microchip's SERCOM peripheral. The root cause (CWE-787: Out-of-Bounds Write) is a sequencing defect in the async DMA receive path: when uart_rx_enable() is called with len1 and CONFIG_UART_MCHP_ASYNC is active, the RX-complete ISR fires and initiates a single-beat DMA transfer configured for the full one-byte length. However, a received byte is already pending in the hardware SERCOM DATA register at this point. The peripheral-triggered DMA start then deposits the incoming byte at rx_buf[1] - one position past the end of the one-element buffer - because the ISR failed to consume the pre-buffered byte via CPU read before sizing the DMA. The fix restructures the ISR to read the first byte directly from the DATA register via CPU on initial receive, skipping DMA entirely for len1 buffers and reloading DMA for only the remaining len-1 bytes in larger buffers.
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:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
Adjacent vector and AC:H confirmed by serial-line access requirement plus non-default async config and timing dependency; no confidentiality impact from write-only single-byte corruption.
Primary rating from Vendor (zephyr).
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
The Microchip SERCOM-G1 UART driver (drivers/serial/uart_mchp_sercom_g1.c), used by the PIC32CM-JH SoC family, contains an out-of-bounds write in its asynchronous (DMA) receive path. When uart_rx_enable() is invoked with a one-byte receive buffer (len == 1) and CONFIG_UART_MCHP_ASYNC is enabled, the RX-complete ISR starts a single-beat DMA transfer while a received byte is already pending in the SERCOM DATA register. On this SoC the peripheral-triggered DMA start sequencing then writes one byte past the end of the caller-supplied buffer (CWE-787). The overflowed byte's value is the UART RX data supplied by the connected serial peer (adjacent attacker), while its size and location are fixed at one byte immediately after the buffer. Exploitation requires the async UART config (not enabled by default on the in-tree PIC32CM-JH boards) and a consumer that enables RX with a one-byte buffer; impact is limited single-byte memory corruption adjacent to the RX buffer (possible crash / denial of service). The defect shipped in v4.4.0. The fix reads the first byte with the CPU and, for one-byte buffers, performs no DMA at all; for larger buffers it sizes the DMA for the remaining len-1 bytes.
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.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Related Vulnerabilities in Zephyr RTOS Memory Safety and Audio Flaws
View all 3Potential 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-39979
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB