Skip to main content

Zephyr RTOS CVE-2026-10684

| EUVDEUVD-2026-50445 LOW
Out-of-bounds Read (CWE-125)
2026-07-29 zephyr
3.0
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain privileged local shell access on Zephyr device
  2. Delivery
    Overwrite coredump storage backend with crafted header containing tgt_code >= 7
  3. Exploit
    Execute 'coredump print' shell command
  4. Execution
    print_coredump_hdr() uses tgt_code as unbounded array index
  5. Persist
    Out-of-bounds char* read from memory past coredump_target_code2str[]
  6. Impact
    shell_print() dereferences pointer and leaks adjacent device memory to shell output

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires two concurrent prerequisites. First, the attacker must hold high-privilege local shell access on the Zephyr device - the vulnerability is only reachable via the 'coredump print' shell command, which requires both the Zephyr shell subsystem (CONFIG_SHELL) and the coredump shell extension (CONFIG_DEBUG_COREDUMP_SHELL) to be compiled into the firmware; these are debug/development features not typically enabled in production builds. Second, the attacker must be able to stage or corrupt the stored coredump in the flash or in-memory backend with a tgt_code field value >= 7; normal device crash handling always produces in-range tgt_code values, so triggering the flaw requires deliberate manipulation of coredump storage rather than simply inducing a crash. Exploitation is additionally bounded by the fact that the information disclosed (arbitrary char* dereferenced as a string) is visible only to the privileged shell user who is already trusted to view coredump data. These conditions collectively limit realistic exploitation to insider-threat or supply-chain scenarios involving devices with debug firmware.

Impact

The CVSS 3.1 base score of 3.0 (AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L) correctly characterises the constrained attack surface. Local access vector (AV:L) confines exploitation to the device itself; high privilege requirement (PR:H) means an attacker must already hold privileged shell credentials; and high attack complexity (AC:H) reflects that triggering the flaw requires deliberate staging or corruption of the coredump storage backend with a crafted tgt_code - a normal device crash produces only in-range values and will never trigger this path. No CISA KEV listing exists, no public POC has been identified, and no EPSS score was provided in the source data. The vulnerability lives in a debug/diagnostic subsystem (CONFIG_DEBUG_COREDUMP_SHELL) that is typically disabled in production firmware builds, further reducing exposure. Impact is limited to partial confidentiality loss (C:L) - leaking a string of device memory to a shell already controlled by the privileged attacker - or a local crash (A:L). For the vast majority of Zephyr deployments this is a low-priority informational finding; it warrants attention only in development or field-debug firmware images where privileged shell access is granted to potentially untrusted operators.

Exploit ScenarioDerived

A privileged developer or operator with local Zephyr shell access on an affected device (v4.2.0-v4.4.0) writes a crafted coredump blob containing a tgt_code value such as 0x0200 (512) directly to the device's coredump flash backend using available debug tooling, then issues the 'coredump print' shell command. The print_coredump_hdr() function uses 512 as an unchecked array index into the 7-element coredump_target_code2str[], reads a char* value from 505 entries past the array end, and shell_print() walks that pointer as a C string - potentially printing several bytes of adjacent rodata, stack, or heap content to the shell terminal.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.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 – Jul 29, 2026

Out-of-bounds read in Zephyr RTOS 4.2.0 through 4.4.0 allows a high-privileged local shell user to disclose device memory contents or crash the system via the coredump print shell command. The 16-bit tgt_code field from a stored coredump header is used as an unbounded index into a static 7-element string pointer array in print_coredump_hdr(), enabling reads up to ~64K entries past the array boundary that are then dereferenced and printed as a C string. No public exploit has been identified and no CISA KEV listing exists; the CVSS 3.0 base score accurately reflects that exploitation is constrained by local high-privilege access and deliberate coredump storage manipulation.

RemediationAI

Apply the upstream fix available at https://github.com/zephyrproject-rtos/zephyr/commit/a9226324e8bd1f8adecafb1b6e0603f781dc750c, which adds a bounds check that clamps any tgt_code value >= ARRAY_SIZE(coredump_target_code2str) to index 0 (the 'unknown' entry) before using it as an array subscript. The patch is confirmed by the Zephyr security advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-9fw2-4429-49q8; however, a specific tagged release version incorporating this fix was not independently confirmed from the provided data - consult Zephyr project release notes to identify the first tagged release containing commit a9226324e8bd. As an immediate compensating control, disable the coredump shell command subsystem at build time via CONFIG_DEBUG_COREDUMP_SHELL=n in the project's Kconfig; this removes the entire vulnerable code path with the trade-off of losing runtime coredump introspection capability. Alternatively, restrict Zephyr shell access (CONFIG_SHELL) to eliminate the privilege path entirely, accepting the loss of all shell-based diagnostics.

Affected VersionsENISA

Zephyr 4.4.0 ≤4.4.1
Zephyr 4.2.0 <4.3.1

Affected Packages

euvd zephyr fix: 4.3.1

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 defect resides in subsys/debug/coredump/coredump_shell.c within the Zephyr real-time operating system's debug subsystem, specifically in print_coredump_hdr(), which is invoked through the call chain cmd_coredump_print_stored_dump -> pretty_print_coredump -> parse_and_print_coredump -> print_coredump_hdr. The function maps a uint16_t tgt_code field from a stored coredump header to a human-readable architecture name via coredump_target_code2str[], a static array of exactly 7 char* pointers. Because tgt_code (range 0-65535) is passed directly as an array index without a bounds check, any value >= 7 constitutes a CWE-125 (Out-of-Bounds Read): the read char* is then passed to shell_print() as a %s argument, causing the shell to dereference and walk whatever pointer value resides in memory past the array end. The result is either leakage of adjacent memory regions (if the pointer happens to be mapped and readable) or a fault/crash (if the pointer is unmapped). The affected CPE is cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* for versions 4.2.0 through 4.4.0, with the defect introduced by commit 13abd7fe730.

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 3.0 LOW
AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L
vuln.today AI 3.0 LOW

Local-only vector, high privilege required to reach coredump shell, high complexity to stage malformed storage; impact limited to partial memory read or local crash.

3.1 AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L
4.0 AV:L/AC:H/AT:P/PR:H/UI:N/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

Attack Vector
Local
Attack Complexity
High
Privileges Required
High
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
Low

DescriptionCVE.org

In subsys/debug/coredump/coredump_shell.c, print_coredump_hdr() used the 16-bit tgt_code field of a stored Zephyr coredump header directly as an index into coredump_target_code2str[], a fixed 7-element array of string pointers, with no bounds check.

A stored coredump whose tgt_code is >= 7 causes an out-of-bounds read of a char* up to ~64K entries past the array; that value is passed as the %s argument to shell_print, which dereferences and walks it as a string. The result is either disclosure of device memory contents to the shell user or a crash when the out-of-bounds pointer is unmapped.

The defect is reached via the coredump print shell command (cmd_coredump_print_stored_dump -> pretty_print_coredump -> parse_and_print_coredump -> print_coredump_hdr). The tgt_code field is device-generated and in-range during normal crash handling, so triggering requires local shell access plus the ability to stage or corrupt the stored coredump in the flash/in-memory backend.

Introduced in v4.2.0 (commit 13abd7fe730) and present through v4.4.0; fixed by clamping out-of-range codes to the 'unknown' (index 0) entry.

Threat Intelligence Overview

EPSS Score
0.1%
Top 99% exploitable
Prevalence
Low
niche embedded RTOS targeting IoT and microcontroller deployments
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

15
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +15
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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