ESP-IDF
CVE-2025-68473
NONE
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessApproach target within Bluetooth range
-
DeliveryAdvertise more than 32 SDP service records
-
ExploitTrigger SDP discovery on victim device
-
ExecutionOverflow fixed uuid_list stack array
-
ImpactCorrupt stack memory causing crash or code execution
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 the target to run the ESP-IDF BlueDroid host stack (not NimBLE) with Bluetooth Classic SDP, and to perform service discovery against an attacker-controlled Bluetooth device that advertises more than 32 service UUIDs; the overflow triggers in bta_dm_sdp_result() only once that 32-entry limit is exceeded. Exploitation is limited by physical proximity (Bluetooth radio range, not internet-routable), the need for the victim device to initiate or complete an SDP discovery against the malicious peer, and the use of the BlueDroid dual-mode stack with Classic SDP enabled rather than the BLE-only NimBLE stack. |
| Impact | This is CWE-787 out-of-bounds write in the ESP-IDF BlueDroid host stack: bta_dm_sdp_result() stores discovered SDP service UUIDs in a fixed uuid_list[32][MAX_UUID_SIZE] stack array and, prior to the fix, failed to bound-check num_uuids, so a peer advertising more than 32 services overflows the array. The input CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, all impacts VC:N/VI:N/VA:N) is internally contradictory and almost certainly wrong - it is network-attack-vector with zero impact, yet SDP is a Bluetooth proximity protocol and an out-of-bounds stack write cannot have null integrity/availability impact; this vector should not be used for prioritization. Realistically the attack vector is Adjacent (Bluetooth radio range), not Network, and the primary impact is memory corruption leading to denial of service (device crash/reboot) with possible code execution on the embedded target. No EPSS score, KEV listing, or POC was provided: there is no public exploit identified at time of analysis and no evidence of active exploitation. Net assessment: a credible, patch-confirmed memory-safety bug that matters most for IoT devices performing Bluetooth Classic service discovery, but it is proximity-gated and not a remote-internet mass-exploitation priority - treat as a firmware-update item rather than an emergency. |
| Exploit ScenarioDerived | An attacker within Bluetooth radio range of an ESP32-class device running BlueDroid stands up a malicious Bluetooth device whose SDP server advertises more than 32 service records. When the victim device performs SDP service discovery against it, bta_dm_sdp_result() writes past the end of the fixed 32-entry uuid_list array, corrupting adjacent stack memory and causing a crash or potentially influencing control flow. No public exploit code is identified at time of analysis; the vulnerability is demonstrated only by the vendor patch commits. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 05, 2026
Out-of-bounds write in the BlueDroid Bluetooth host stack shipped with Espressif ESP-IDF 5.5.1, 5.4.3, 5.3.4, 5.2.6, 5.1.6 and earlier allows a nearby attacker-controlled Bluetooth Classic device to corrupt memory on a target during SDP service discovery. The flaw is unauthenticated and requires only Bluetooth radio proximity (assessed CVSS:3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H), because a peer advertising more than 32 service UUIDs overflows the fixed-size uuid_list[32][MAX_UUID_SIZE] buffer in bta_dm_sdp_result(). No public exploit has been identified at time of analysis; upstream fixes are already committed and documented in GitHub advisory GHSA-hmjj-rjvv-w8pq.
RemediationAI
Apply the upstream Espressif fix, which is delivered through the vendor's Bluetooth host commits referenced in advisory GHSA-hmjj-rjvv-w8pq (https://github.com/espressif/esp-idf/security/advisories/GHSA-hmjj-rjvv-w8pq); patch references include commit 3286e45349b0b5c2b1422ef7e8d088b95eef895d (which adds MAX_UUID_NUM and the num_uuids bounds check in bta_dm_sdp_result) plus the companion commits 4d928f2265c394d2abc85024228e920a5b26bcab, 5b3185168dae83d42aa0852689422fffd931f16c, 6453f57a954458ad8ffd6e4bf2d9e76b73fac0f1, 6ca6f422dafaffcb88fa56cc458ce92d96be3b2e, 9889edd799cf369e082df9d01adba961d64693ed and ecb86d353640cf1375bf97db32e702ba59c551b7. Because the fixes are upstream commits rather than independently confirmed tagged releases, treat this as an upstream fix available via PR/commit and consult the advisory to identify and deploy the exact patched release for each maintained branch (5.5.x, 5.4.x, 5.3.x, 5.2.x, 5.1.x). If immediate patching is not possible, reduce exposure by rebuilding without the BlueDroid Classic host: switch to the BLE-only NimBLE stack, at the cost of losing BR/EDR profiles and Classic SDP functionality; otherwise keep Bluetooth Classic SDP disabled or pairing/discovery restricted to trusted peers only in physically controlled environments, since exploitation requires an attacker device within radio range that the target discovers as an SDP peer. Backporting the two-line bounds check and MAX_UUID_NUM macro locally is a low-risk stopgap that simply truncates UUID processing after 32 records, though it diverges from the vendor-maintained tree.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
ESP-IDF is Espressif's IoT development framework for ESP32-series SoCs and offers two Bluetooth host stacks: NimBLE (BLE-only) and BlueDroid (dual-mode BR/EDR plus BLE). The vulnerable code lives in BlueDroid's Device Manager action layer, components/bt/host/bluedroid/bta/dm/bta_dm_act.c, in the function bta_dm_sdp_result(), which consumes the results of an SDP (Service Discovery Protocol) transaction over Bluetooth Classic. Discovered service records were converted to 128-bit UUIDs and stored into a stack array declared as UINT8 uuid_list[32][MAX_UUID_SIZE] with a companion counter num_uuids that was never validated against the 32-entry capacity. Because CWE-787 (out-of-bounds write) is the root cause, any peer that returns more than 32 services causes writes past the end of the stack buffer, producing memory corruption that can crash the host stack or, depending on stack layout, corrupt adjacent variables with attacker-influenced UUID bytes. The upstream fix introduces a MAX_UUID_NUM macro (32) in components/bt/common/include/bt_common.h, sizes the array from that macro, and adds a bounds check around both the sdpu_uuid16_to_uuid128() and memcpy() write paths, emitting APPL_TRACE_WARNING("only process the first %d records") and breaking out of the record loop once the limit is reached. Only devices using BlueDroid with Classic SDP are exposed; the NimBLE stack does not contain this code path.
Know when Bluetooth 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:N/SC:N/SI:N/SA:N
Bluetooth proximity gives AV:A, a malicious peer needs no authentication (PR:N), and the stack out-of-bounds write primarily crashes the device (A:H) with limited integrity (I:L) and no data disclosure (C:N).
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
ESF-IDF is the Espressif Internet of Things (IOT) Development Framework. In versions 5.5.1, 5.4.3, 5.3.4, 5.2.6, 5.1.6, and earlier, in the ESP-IDF Bluetooth host stack (BlueDroid), the function bta_dm_sdp_result() used a fixed-size array uuid_list[32][MAX_UUID_SIZE] to store discovered service UUIDs during the SDP (Service Discovery Protocol) process. On modern Bluetooth devices, it is possible for the number of available services to exceed this fixed limit (32). In such cases, if more than 32 services are discovered, subsequent writes to uuid_list could exceed the bounds of the array, resulting in a potential out-of-bounds write condition.
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
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.
Affected Products (CPE)CVE.org
Unauthenticated Bluetooth Low Energy OTA firmware upgrade in the Meatmeet Pro WiFi & Bluetooth Meat Thermometer firmware
CVE-2025-32879 is a security vulnerability (CVSS 8.8) that allows an attacker. Risk factors: public PoC available.
Zephyr's Bluetooth Low Energy connection-response handler fails to verify that a connection request was actually initiat
Heap OOB write in Android Bluetooth driver via incorrect bounds check.
A use-after-free in the Android Bluetooth stack (bluetooth_ccc.cc, function BluetoothCccHandlerCallbackImpl) lets an att
Legacy pairing and secure-connections pairing authentication in Bluetooth BR/EDR Core Specification v5.2 and earlier may
Memory corruption in the Zephyr RTOS LE Audio Broadcast Sink (subsys/bluetooth/audio/bap_broadcast_sink.c) lets an attac
A memory leak combined with a use-after-free in the Linux kernel's Bluetooth HCI connection-setup path can crash the ker
A race condition in the Linux kernel's Bluetooth L2CAP subsystem allows a use-after-free of the hci_conn::l2cap_data poi
Bluetooth authentication bypass in SwitchBot Door Lock Series allows an attacker within BLE range to manipulate the lock
Out-of-bounds read in the Linux kernel Bluetooth subsystem's eir_get_service_data() leaks kernel heap memory into usersp
Use-after-free in the Linux kernel Bluetooth L2CAP stack lets a Bluetooth-adjacent attacker corrupt kernel memory by rac
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB