Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect as protocol peer to ESP32 app
-
DeliveryInduce second AES session with attacker-known key
-
ExploitRace victim's begin/op window
-
ExecutionVictim operation runs under resident attacker key
-
ImpactRecover plaintext or invert encrypt/decrypt direction
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Concurrency control, locking
MITRE ATT&CK
1 technique across 1 tactic: 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 a Zephyr application on ESP32 that holds two or more concurrent cipher sessions with different keys against this hardware AES driver (CONFIG_ESP32_CRYPTO_AES_SESSIONS_MAX, default 4) using ECB, CBC or CTR mode. No stock Zephyr subsystem meets this: the 802.15.4 security layer opens two sessions but uses CCM mode, which this driver rejects, so only custom application code using the documented multi-session API is exposed. The attacker must be able to induce session creation - e.g. a protocol peer whose connection installs a session key - and, for the threaded race variant, land a second cipher_begin_session() between the victim's begin and its operation. Limiting factors: ESP32 hardware only, affected driver versions 4.3.0-4.4.2, non-default multi-session usage pattern required, and the attacker must know or supply the key that ends up resident for plaintext to be recoverable. |
| Impact | This is a genuinely low-priority issue whose signals are internally consistent rather than conflicting. The NVD CVSS of 3.7 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N) reflects a high-complexity attack with only limited confidentiality impact, and the vuln.today decision label is 'monitor' - the weakest urgency tier. No EPSS score, no CISA KEV listing, and no exploit-code reference were provided (only vendor patch commit and the GHSA advisory, which are remediation artifacts, not exploit code), so exploitation status is 'no public exploit identified at time of analysis.' The dominant limiter is not the CVSS complexity metric itself but the deployment precondition the advisory states explicitly: exploitation requires application code that holds two or more concurrent sessions with different keys against this driver, and the advisory confirms NO in-tree Zephyr subsystem does so today (the 802.15.4 layer that opens two sessions uses CCM, which this driver rejects). Therefore the real-world attack surface is effectively zero for stock Zephyr and non-zero only for bespoke applications using the multi-session AES API on ESP32. The AV:N rating is defensible because an attacker influences which key is resident by inducing session creation over a protocol connection, but the AC:H and the application-dependency together make this a correctly-scored low-risk cryptographic correctness bug, not an under-rated threat. One nuance worth verifying: NVD sets I:N, yet the described direction inversion (encrypt vs. decrypt) and wrong-key encryption are arguably integrity-affecting, so the true impact may be slightly broader than the vendor vector shows. |
| Exploit ScenarioDerived | An ESP32-based Zephyr application uses the documented multi-session AES API, keeping one session for its own protected data and installing a second session key when a network/protocol peer connects. An attacker whose connection causes that second session to be created - with a key the attacker knows or supplied - makes the chip-global key registers hold the attacker's key when the victim's next ECB/CBC/CTR operation runs, so the victim's data is transformed under the attacker's key and its plaintext becomes recoverable. No public exploit code was identified; exploitation also hinges on winning the race between the victim's begin and its operation, consistent with the AC:H rating. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Cross-session AES key confusion in the Zephyr RTOS Espressif ESP32 hardware crypto driver (drivers/crypto/crypto_esp32_aes.c, shipped in Zephyr 4.3.0 through 4.4.2) causes cipher operations to run under another session's key and direction instead of the key the caller installed. The driver advertises up to four independent cipher sessions, but the ESP32 AES peripheral has a single chip-global key/mode register set that aes_begin_session() programmed once, outside the aes_lock mutex, so a second session opened with a different key silently redirects every subsequent ECB, CBC or CTR operation from the first session, and the threaded pattern of begin-then-operate on separate sessions also races. Impact is cryptographic rather than memory corruption: plaintext the application believed protected under its own key may be encrypted or decrypted under a key the attacker knows or supplied, and encrypt/decrypt direction can be inverted; unauthenticated remote exploitation is constrained to custom applications on ESP32 hardware that hold two or more concurrent sessions with different keys, no stock Zephyr subsystem does so, and no public exploit has been identified at time of analysis (vendor fix merged, projected release 4.5.0).
RemediationAI
Update to Zephyr 4.5.0, the projected fixed release, once it ships; the fix is already merged on main as commit cb4168ab3f6bd1bfc26060fd33cfcd00e8e641f1 (PR #116964) and backported to the v4.4-branch (PR #117880) and v4.3-branch (PR #117879), so patched branch builds can be taken from those branches in the interim and the 4.5.0 forecast should be confirmed against the actual release. Updating is the complete fix because it moves key and direction programming inside aes_lock at the top of every ECB, CBC and CTR operation so the chip-global registers can no longer be observed stale by another session. Applications that cannot update immediately can reduce exposure by not holding two or more concurrent cipher sessions with different keys against this driver - serializing sessions or performing begin/op/free as a single-threaded sequence removes the cross-session overwrite precondition - at the cost of giving up concurrent hardware AES throughput; note that no stock Zephyr subsystem meets the multi-session precondition today (the 802.15.4 security layer uses CCM, which this driver rejects), so the practical exposure is limited to custom application code using the documented multi-session API. Details are in the vendor advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-rvww-w3mx-r99q.
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
CWE-362 (concurrent execution using shared resource with improper synchronization) here maps onto a hardware-state isolation failure. The Espressif ESP32 AES block has no per-session hardware context: aes_hal_setkey() in the HAL writes the chip-global mode and key registers via aes_ll_set_mode() and aes_ll_write_key(). The Zephyr driver nevertheless exposes a multi-session API, keeping per-session key[32]/key_len/dir entries in struct esp_aes_ctx in a pool sized by CONFIG_ESP32_CRYPTO_AES_SESSIONS_MAX (default 4), and serializes transforms with the aes_lock mutex. The bug is that aes_begin_session() called aes_setkey_dir() during session setup, before and outside aes_lock, so the per-operation handlers aes_ecb_op(), aes_cbc_op() and aes_ctr_op() executed aes_hal_transform_block() against whatever key and direction another session had most recently left resident, with no error returned. The CTR handler additionally saved and restored direction conditionally with a restore_dir flag, writing the key only when ctx->dir != ESP_AES_ENCRYPT. The trigger requires two or more concurrent sessions with different keys against this driver; a second session creation landing between a victim's begin and its operation is sufficient, and a protocol peer that induces session creation can influence which key is resident. No in-tree consumer is exposed: the 802.15.4 security layer opens two sessions but in CCM mode, which the driver rejects, and the OSDP code performs begin/op/free sequentially from a single thread. The fix commit cb4168ab3f6b removes all hardware access from aes_begin_session() and reprograms the key and direction as the first statement inside k_mutex_lock(&data->aes_lock) in each of the ECB, CBC and CTR handlers, with an unlock on the error path, and drops the CTR save/restore logic. Exploitation is limited to ESP32 hardware running the affected driver and to application code using the documented multi-session API.
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:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
Attacker needs no auth (PR:N) but must win a race and the app must use the multi-session API (AC:H); key confusion yields plaintext recovery (C:L) and direction inversion harms integrity (I:L).
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The Espressif AES driver drivers/crypto/crypto_esp32_aes.c advertises a multi-session cipher API - it hands out up to CONFIG_ESP32_CRYPTO_AES_SESSIONS_MAX (default 4) independent sessions, each carrying its own key and direction. The AES peripheral, however, has a single chip-global set of key and mode registers, and aes_begin_session() programmed them exactly once, at session start, outside the aes_lock mutex that serialises the transforms. The per-operation handlers aes_ecb_op(), aes_cbc_op() and aes_ctr_op() then ran aes_hal_transform_block() against whatever key and direction the registers happened to hold.
As a result, once a second session is opened with a different key, every subsequent operation on the first session silently uses the second session's key and direction, and no error is reported. Because the key programming happened outside the lock, the correct usage pattern of "each thread does begin, then op, then free on its own session" also races: a second thread's cipher_begin_session() landing between the first thread's begin and its operation makes that operation run under the second thread's key. An attacker who can induce session creation on the device - for example a protocol peer whose connection causes a session key to be installed - can influence which key is resident when a victim operation runs.
The impact is a cryptographic failure rather than memory corruption: data the application believed it was protecting under one key is encrypted or decrypted under another. Where the resident key is one the attacker knows or supplied, the affected plaintext becomes recoverable by that attacker, and the operation's direction (encrypt versus decrypt) can likewise be inverted. Exposure requires an application that holds two or more concurrent sessions with different keys against this driver; no in-tree Zephyr subsystem does so today (the 802.15.4 security layer, which does open two sessions, uses CCM mode, which this driver rejects), so the risk falls on application code that uses the documented multi-session API.
The fix removes all hardware access from aes_begin_session() and reprograms the key and direction at the top of every operation, inside aes_lock, so the chip-global registers can no longer be observed stale by another session.
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
Race conditions occur when multiple concurrent requests exploit the brief time gap between checking a condition and acting upon it (TOCTOU - Time of Check, Time of Use).
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-109976
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB