CVE-2026-45329: 
Espressif ESP-IDF Tools vulnerability analysis and mitigation

CVE-2026-45329 is an out-of-bounds read vulnerability in the ESP-IDF (Espressif IoT Development Framework) ESP-TEE secure-service wrappers that allows a low-privileged local attacker to read sensitive data from Trusted Execution Environment (TEE)-exclusive memory. It affects ESP-IDF versions 5.5.4 and 6.0, specifically on Espressif SoCs with ESP-TEE support (ESP32-C5, ESP32-C6, ESP32-C61, ESP32-H2). The vulnerability was published on June 10, 2026, and patched in versions 5.5.5 and 6.0.1. It carries a CVSS v3.1 base score of 6.5 (Medium) per NVD, and 7.1 (High) per the GitHub Security Advisory (GitHub Advisory, Feedly).

The root cause is improper input validation (CWE-20) in multiple ESP-TEE secure-service wrapper functions within esp_secure_services.c and esp_secure_services_iram.c. These wrappers validated only some caller-supplied pointer arguments (e.g., output pointers) while leaving input pointer arguments unchecked, constituting an out-of-bounds read (CWE-125) and sensitive information exposure (CWE-200). Because the underlying TEE-protected hardware peripherals — including ECC, SHA, AES, SPI, HMAC, and Digital Signature accelerators — operate in RISC-V machine mode (M-mode) with full address-space access, a caller in the Rich Execution Environment (REE) could supply pointers targeting TEE-exclusive memory regions as inputs. The fix replaces the incomplete esp_tee_ptr_in_ree() single-pointer checks with the overflow-safe esp_tee_buf_in_ree() range-checking helper and adds ESP_FAULT_ASSERT() enforcement across all affected wrappers (GitHub Advisory, Patch Commit).

Successful exploitation allows an unprivileged REE application to read TEE-resident sensitive data across the REE/TEE isolation boundary, including cryptographic keys, application secrets, code and data addresses, and internal pointers. Depending on the specific wrapper targeted, an attacker can retrieve raw bytes from TEE memory directly, recover TEE memory contents through computed cryptographic functions via repeated calls, or use a single-bit oracle to incrementally disclose TEE secrets. This effectively defeats the exploit mitigations protecting the TEE and makes subsequent memory-corruption attacks significantly more reliable, though no integrity or availability impact is associated with this vulnerability itself (GitHub Advisory, Feedly).

There is no public proof-of-concept exploit code known at this time, and no evidence of in-the-wild exploitation has been observed (Feedly). The vulnerability requires only local code execution in the REE — no TEE privileges are needed — making it accessible to any unprivileged application running on the affected SoC. The EPSS score is approximately 0.018% (0.000180), reflecting low current exploitation probability. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. The vulnerability was responsibly disclosed by researcher Eun0us / Espilon Worker (GitHub Advisory).

1. Identify target: Confirm the target device is an Espressif SoC with ESP-TEE support (ESP32-C5, ESP32-C6, ESP32-C61, or ESP32-H2) running ESP-IDF version 5.5.4 or 6.0 with the ESP-TEE component enabled.
2. Gain REE code execution: Obtain local code execution in the Rich Execution Environment (REE) on the target device — no elevated privileges are required.
3. Identify vulnerable secure-service wrapper: Select a target ESP-TEE secure-service wrapper that accepts input pointer arguments without validation, such as _ss_esp_sha, _ss_esp_ecc_point_multiply, _ss_esp_hmac_calculate, or _ss_esp_ds_sign.
4. Craft malicious pointer: Construct a call to the chosen wrapper supplying a pointer that references a TEE-exclusive memory address (e.g., a TEE code or data region) as an input argument instead of a legitimate REE buffer.
5. Trigger hardware peripheral read: Invoke the secure-service wrapper; the underlying hardware peripheral (e.g., SHA, ECC, HMAC accelerator) operating in M-mode reads from the TEE-supplied address and processes the TEE memory contents.
6. Extract TEE data: Retrieve the result returned to the REE — this may be raw TEE memory bytes, a cryptographic function of TEE memory, or a single bit usable as an oracle. Repeat calls iteratively to incrementally reconstruct TEE-resident secrets such as cryptographic keys (GitHub Advisory, Patch Commit).

• Process/Application Behavior: Unusual or repeated calls to ESP-TEE secure-service wrappers (e.g., SHA, ECC, HMAC, DS functions) from REE applications with atypical input pointer values pointing outside normal REE memory ranges.
• Logs: Unexpected or high-frequency invocations of TEE secure-service APIs logged by the application or TEE monitor; absence of expected ESP_FAULT_ASSERT abort behavior on unpatched firmware when invalid pointers are supplied.
• Firmware: Presence of ESP-IDF version 5.5.4 or 6.0 identifiable via firmware version strings or build metadata on ESP32-C5, ESP32-C6, ESP32-C61, or ESP32-H2 devices.
• Network: Unusual outbound data exfiltration from IoT devices that may indicate extracted cryptographic material being transmitted to an attacker-controlled endpoint.

Espressif has released patched versions 5.5.5 and 6.0.1 that add comprehensive input pointer validation using the overflow-safe esp_tee_buf_in_ree() helper with ESP_FAULT_ASSERT() enforcement across all affected secure-service wrappers. Users should upgrade ESP-IDF to version 5.5.5 or 6.0.1 immediately, or cherry-pick the relevant fix commits onto downstream branches (commits 145ba4c, 7867f4a, eebabaf for master, release/v6.0, and release/v5.5 respectively). There is no runtime workaround available; as an interim measure, restrict access to applications invoking ESP-TEE secure-service functions to trusted code only until patching is feasible (GitHub Advisory, Patch Commit).

The vulnerability was responsibly disclosed by researcher Eun0us / Espilon Worker and acknowledged by Espressif in their official GitHub Security Advisory. The CISA Vulnerability Bulletin (SB26-166) referenced the CVE, indicating it was included in routine government vulnerability tracking. No significant broader media coverage or notable community commentary beyond standard vulnerability database aggregation has been observed at this time (GitHub Advisory, CISA Bulletin).