/

CVE-2026-10651

Severity:

HIGH RISK

(7.1)

Bluetooth SDP Parsing (CWE-20) Assertion Panic in Zephyr

CVE-2026-10651

Modified

Vulnerability type

Category:

Input Validation Error

CWE:

CWE-20, CWE-617

Impact:

Denial of Service and Potential Memory Safety Issues

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A malformed Bluetooth Classic SDP attribute can cause Zephyr's SDP parser to read beyond the available buffer length, leading to a reachable assertion and potential kernel panic.

When crafted SDP data is processed, truncated attributes may trigger denial of service on assert-enabled builds or undefined behavior due to out-of-bounds reads on other builds.

Affected context

This vulnerability occurs within Zephyr's Bluetooth Classic SDP parsing logic, specifically in the host subsystem responsible for handling incoming SDP attributes.

It is relevant in scenarios where a device or host parses SDP data received over a Bluetooth Classic connection and trusts that attribute fields are well-formed.

The issue manifests when malformed or truncated attribute data is accepted as complete and processed without adequate bounds checking on subsequent reads.

Exploit preconditions

  • Attack surface: Bluetooth Classic SDP interface exposed by a Zephyr-based device.
  • Required access: Ability to initiate or influence an SDP transaction and send crafted SDP attributes to the Zephyr host (typically within wireless range and protocol constraints).
  • Trigger point: Parsing of a truncated or malformed SDP attribute in bt_sdp_parse_attribute() after the attribute type and ID have been accepted.
  • Why exploitation is possible: The parser assumes a value type byte is present and unconditionally pulls it from the buffer, leading to assertion failure or out-of-bounds reads when the buffer length is insufficient.

Why this happens

The bug stems from insufficient input validation and defensive bounds checking in the SDP attribute parsing routine.

After reading the attribute type and ID, the code assumes that the subsequent value type byte exists and calls net_buf_simple_pull() without validating the remaining buffer length.

This behavior maps to CWE-20: Improper Input Validation, where the parser fails to verify that incoming data meets structural and length expectations, and to CWE-617: Reachable Assertion, where an assertion intended for debugging can be triggered by crafted external input.

Potential impact

  • Denial of service through kernel panic on builds where assertions are enabled.
  • Out-of-bounds read of memory in assertion-disabled builds, which may lead to undefined behavior.
  • Potential compromise of system stability, including crashes or hangs during Bluetooth SDP interactions.
  • Possible information leakage or further memory corruption depending on surrounding implementation details and platform behavior.

General mitigation guidance

Mitigation strategies center on robust input validation and defensive parsing patterns for protocol data.

Common approaches include:

  • Verifying buffer lengths before every pull or read operation, especially for multi-field protocol structures.
  • Treating all data from external interfaces (such as Bluetooth SDP) as untrusted and validating structural integrity before processing.
  • Constraining parser behavior so that malformed or truncated attributes are gracefully rejected rather than passed deeper into the stack.
  • Using assertions only as development aids and ensuring that production error handling paths fail safely without exposing memory safety risks.

Adopting these patterns helps prevent similar assertion-triggered failures and out-of-bounds accesses in protocol parsers.

How teams detect issues like this

Effective detection of this class of issue typically combines:

  • Static analysis checks for buffer pull/read operations that do not compare requested lengths against available data.
  • Code review practices focused on protocol parsers, ensuring that every field read is preceded by length and structural validation.
  • Fuzz testing of Bluetooth SDP and related protocol handlers to discover edge cases involving truncated or malformed inputs.
  • Runtime diagnostics and logging around assertion failures and parser errors to identify potentially exploitable input-driven crashes.

Automated tooling that flags reachable assertions and unchecked buffer operations can assist in surfacing similar vulnerabilities early.

Sources

SourceLink
github.comgithub.com/zephyrproject-rtos/zephyr/commit/dfac5224ab65fc7b81be2926386173c169318335
github.comgithub.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-p93g-3r68-cj53

Frequently asked

questions

Yes, in the sense that an attacker within Bluetooth range who can interact with the SDP service can send crafted SDP attributes to trigger the parser behavior, without needing local code execution on the device.

The attacker needs the ability to perform or influence a Bluetooth Classic SDP exchange with the Zephyr-based device. This typically requires proximity sufficient for a Bluetooth connection but does not require traditional authentication beyond what is needed to complete the SDP interaction.

The most robust fix pattern is to enforce strict bounds checking on all protocol field reads: confirm the remaining buffer length before each pull, gracefully reject malformed or truncated attributes, and ensure that assertions cannot be triggered solely by external input.

Future prevention relies on designing protocol parsers with defensive programming principles, comprehensive input validation, systematic use of length checks, and integrating static analysis, fuzzing, and security-focused code review into the development lifecycle for all external-facing parsers.

Find out what's already
exploitable in your codebase.