Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local code execution as unprivileged user
-
DeliveryOpen L2CAP sockets and start connect()
-
ExploitRace bind() to flip chan->state to BT_BOUND
-
ExecutionTrigger second __l2cap_chan_add
-
PersistCorrupt channel/conn link state
-
ImpactEscalate privileges via kernel memory corruption
Vulnerability Assessment
| Exploitation Conditions | Requires a local, authenticated (PR:L) process on a host where the Linux Bluetooth stack and L2CAP socket support are present and reachable by the attacker (CONFIG_BT with L2CAP; access to AF_BLUETOOTH sockets). The concrete prerequisite stated in the description is a TOCTOU race: the attacker must interleave l2cap_chan_connect (which sets chan->state=BT_CONNECT) with l2cap_sock_bind (which sets chan->state=BT_BOUND) and then l2cap_sock_connect - which does not re-check sk->sk_state - so that __l2cap_chan_add is invoked a second time on a channel already linked to a conn. Limiting factors: exploitation is local only (AV:L, no network reach), needs the Bluetooth subsystem enabled and accessible, and depends on winning a narrow timing window between two tasks; there is no remote or unauthenticated path. |
| Impact | The input CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) describes a locally-exploitable, low-privilege flaw with full confidentiality, integrity and availability impact - the classic profile of a Linux-kernel memory-safety bug leading to local privilege escalation rather than a remote compromise. No EPSS score, KEV entry, SSVC exploitation field or POC indicator is present in the supplied data; the only references are eight git.kernel.org stable-tree fix commits, which are patch artifacts, not exploit code. The vuln.today decision label is 'this_week', i.e. a near-term but non-emergency priority, which is consistent with a local-only kernel race that has no evidence of active exploitation. One tension to flag: the supplied vector uses AC:L, yet the description explicitly characterizes the bug as a TOCTOU race between l2cap_chan_connect/l2cap_sock_bind/l2cap_sock_connect, and winning a race typically raises real-world attack complexity - my independent assessment therefore diverges on that metric (see assessed_cvss_vector). Net: a genuine local-EoL-class kernel issue worth patching within the vendor's normal stable cadence, not a drop-everything remote emergency; it is a high-CVSS issue whose real-world urgency is moderated by the local attack vector and race requirement. |
| Exploit ScenarioDerived | A local unprivileged user running on a Linux host with the Bluetooth stack present creates L2CAP sockets and concurrently races bind() against connect() on the same channel, violating the 'one l2cap_chan linked to one l2cap_conn' invariant so that __l2cap_chan_add runs twice. The resulting corrupted channel/connection state (mishandled in cleanup paths such as l2cap_chan_del) can be driven toward memory corruption and local privilege escalation. No public exploit is identified in the provided data; the only references are kernel fix commits, and the trigger beyond the described TOCTOU race is not detailed in the available sources. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Local privilege escalation in the Linux kernel Bluetooth L2CAP subsystem: a race between l2cap_sock_bind() and l2cap_chan_connect() lets an L2CAP channel be linked to an l2cap_conn twice, breaking the one-connection-per-channel invariant that l2cap_chan_del() cleanup relies on and exposing memory-corruption paths with high confidentiality, integrity and availability impact. Only local, authenticated processes (PR:L) with access to AF_BLUETOOTH sockets on a kernel built with Bluetooth/L2CAP support can reach the flaw, and exploitation requires winning a narrow timing window (AC:H); there is no remote or unauthenticated path. No public exploit code has been identified at time of analysis, and the issue is prioritized for remediation this week per the assigned decision label.
RemediationAI
Apply the upstream stable-tree fix commits for this issue - 85cc289eb08afa975375f838187369e68b429ee0, 820579652b24ce277e0097cd65b42bd9b7b8bf07, e618d928ec7f88cbeadfa3542adcac40f474e629, fabaff1c59ff2cc89cb7e5bd0186a5e15f0c73b2, 52fe88e4ef87311eee32b45c65603e7c69e75e7d, 10c705dd706aa93164ba41f2566f15206d6c178e, 73820561d8cbfd3364a29b8fa77f1707f26029da and d3afd7803f9bc2a8c4270199497b60158b2fc647 - selecting the commit that belongs to the stable branch in use (upstream fix available via commit; the input does not provide the resulting released kernel version numbers, so the exact patched release must be confirmed against the stable branch containing the corresponding commit). The fix itself adds a WARN_ON_ONCE invariant check in __l2cap_chan_add(), a pre-check in l2cap_chan_connect() and l2cap_lock_chan() guarding the chan->state write in l2cap_sock_bind(); no vendor workaround or compensating control is described in the supplied references, and the flaw is only reachable by local processes that can open AF_BLUETOOTH sockets on a kernel with Bluetooth L2CAP enabled.
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
L2CAP is the Bluetooth Logical Link Control and Adaptation Protocol layer, reached from user space through AF_BLUETOOTH sockets. The core data structure is struct l2cap_chan, which may be attached to an struct l2cap_conn at most once; several code paths, notably l2cap_chan_del() cleanup, assume this invariant holds. The described TOCTOU arises because chan->state is written without consistent locking: Task 1 executing l2cap_chan_connect() sets chan->state = BT_CONNECT, while Task 2 executing l2cap_sock_bind() observes sk->sk_state == BT_OPEN, sets chan->state = BT_BOUND and sk->sk_state = BT_BOUND; when the connect path then sets sk->sk_state = BT_CONNECT, a subsequent l2cap_sock_connect() - which does not re-check sk->sk_state - reaches __l2cap_chan_add() a second time and adds the already-linked channel to another connection. The upstream fix documents and enforces the invariant in __l2cap_chan_add() with WARN_ON_ONCE, adds an explicit pre-check in l2cap_chan_connect() so the code does not rely on chan->state, and takes l2cap_lock_chan in l2cap_sock_bind() to guard the chan->state write; the commit message notes that chan->state reads and writes are not properly guarded and that further TOCTOU problems may exist. No CWE identifier was assigned in the supplied data, and the CPE entries are the generic linux:linux product strings rather than branch-specific version ranges.
Know when the next one hits your stack
- 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:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Local Bluetooth-socket access gives AV:L/PR:L; the description explicitly requires winning a TOCTOU race, so AC:H; duplicate channel-add corrupts kernel state, so C/I/A:H.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
2DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
Bluetooth: L2CAP: refuse __l2cap_chan_add if chan already has conn
l2cap_chan may be linked to l2cap_conn at most once. This is assumed in several places, eg l2cap_chan_del cleanup.
There is a TOCTOU race where the invariant is violated:
[Task 1] [Task 2] l2cap_chan_connect l2cap_sock_bind l2cap_chan_lock lock_sock l2cap_state_change if (sk->sk_state != BT_OPEN) chan->state = BT_CONNECT l2cap_sock_state_change_cb chan->state = BT_BOUND sk->sk_state = BT_BOUND lock_sock <------------------ release_sock sk->sk_state = BT_CONNECT
l2cap_sock_connect() does not check sk->sk_state, so since chan->state is now BT_BOUND, subsequent connect() ends up with second __l2cap_chan_add.
Explicitly document and check the invariant in __l2cap_chan_add with WARN_ON_ONCE. The only callsite where it could be hit is l2cap_chan_connect, so add pre-check there to avoid relying on chan->state. chan->state read/write is not properly guarded currently so there can be other TOCTOUC problems.
Add l2cap_lock_chan in l2cap_sock_bind() to guard chan->state write.
Articles & Coverage 1
Executive ViewAI
CVE-2026-99239 is a local privilege escalation flaw in the Linux kernel's Bluetooth L2CAP subsystem, affecting systems with Bluetooth support enabled. A local authenticated user could exploit a race condition to corrupt kernel memory, potentially gaining elevated privileges, which threatens the confidentiality, integrity, and availability of affected devices across the organization.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict AF_BLUETOOTH socket permissions to trusted users/groups, disable Bluetooth kernel modules (e.g., via modprobe blacklist) on systems not requiring Bluetooth, enforce least-privilege access to reduce local authenticated attack surface, and monitor for anomalous privilege escalation attempts.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-115281
GHSA-367g-m7cr-7mf6
NVD
CVE.org
VulDB
Exploit-DB