Skip to main content

Linux Kernel CVE-2025-68336

HIGH
2025-12-22 416baaa9-dc9f-4396-8d5f-8c081fb06d67
High
Disputed · 7.5 Vendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Local execution on debug-enabled kernel
  2. Delivery
    Concurrent write-lock acquisition on two CPUs
  3. Exploit
    Unmarked read/write races in debug_write_lock_before
  4. Execution
    Inconsistent lock-debug state / KCSAN report
  5. Impact
    Transient availability or debug disruption

Vulnerability Assessment

Exploitation Conditions

Requires a Linux kernel compiled with spinlock lock-debugging enabled (CONFIG_DEBUG_SPINLOCK-class options); the affected debug_write_lock_before() path does not exist in kernels built without lock debugging. Exploitation further requires concurrent local execution of raw write-lock acquisition across CPUs (observed on the do_exit / call_usermodehelper_exec_async kworker path), i.e., local, timing-dependent conditions - not remote or unauthenticated access. Limiting factors: standard production/defconfig kernels usually omit lock debugging and are therefore not affected, the race is non-deterministic and timing-sensitive, and the practical impact is confined to lock-debug state rather than user-facing data.

Impact

The published CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, score 7.5) is inconsistent with the technical reality and appears to be an automated worst-case Linux-kernel CNA scoring. The vulnerability is a data-race inside optional lock-debugging code reached via kernel-internal task-exit paths - it is not a network-reachable, unauthenticated condition, so AV:N/PR:N materially overstates real risk. Confirming signals of low priority: EPSS is 0.17% (7th percentile), there is no CISA KEV listing, and no public exploit is identified. The realistic worst case is a debug-kernel availability blip or false KCSAN report, not a remotely triggerable DoS. CONFLICT TO NOTE: CVSS indicates a remote network vector with high availability impact, but the description and code path imply a local, debug-config-only race with negligible impact - treat the 7.5 as inflated and verify against the actual kernel config in use. Production kernels without lock debugging enabled are not affected at all.

Exploit ScenarioDerived

On a kernel built with spinlock lock-debugging enabled, two tasks concurrently exiting (e.g., via call_usermodehelper_exec_async / do_exit on separate CPUs) race on the same raw write-lock state word, producing a KCSAN-detected data-race and potentially inconsistent lock-debug state or a transient availability issue. No public POC exists, and triggering it requires the debug configuration plus precise timing, so this is realistically a correctness/sanitizer finding rather than a practical attack.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 30, 2026

Denial-of-service potential in the Linux kernel's spinlock debugging instrumentation (do_raw_write_lock) stems from an unmarked read/write in debug_write_lock_before(), producing a data-race flagged by the Kernel Concurrency Sanitizer (KCSAN). Only kernels built with lock debugging enabled are affected, and the fix completes prior race-hardening work (commit 1a365e822372) by converting the remaining access to WRITE_ONCE(). No public exploit identified at time of analysis, and EPSS is low (0.17%, 7th percentile).

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - apply the kernel update from your distribution that incorporates the stable-tree fix commits listed at git.kernel.org (e.g., https://git.kernel.org/stable/c/16b3590c0e1e615757dade098c8fbc0d4f040c76, https://git.kernel.org/stable/c/396a9270a7b90886be501611b13aa636f2e8c703, and the six additional referenced commits), which mark the remaining access in debug_write_lock_before() with WRITE_ONCE(). As a compensating control if patching must be deferred, disable kernel lock debugging (build/boot a kernel without CONFIG_DEBUG_SPINLOCK / lock-debug options), which removes the affected instrumentation entirely - the trade-off is losing spinlock sanity checking useful for kernel development, though production defconfig kernels typically ship without it and are unaffected. No firewall or network control is relevant here since the flaw is not network-reachable.

Affected ProductsAI

The Linux kernel is affected specifically in the spinlock debug instrumentation (do_raw_write_lock via debug_write_lock_before). The reporting reproduction was on kernel 6.1.111 (Comm: kworker/u4:1), and the eight stable-tree git.kernel.org commit references indicate the fix was backported across multiple stable branches, implying a range of long-lived stable and mainline versions prior to those fix commits are affected. No specific vendor CPE list or fixed tagged release version was provided in the input; affected versions are those built with spinlock lock-debugging enabled up to the referenced stable fix commits (e.g., https://git.kernel.org/stable/c/16b3590c0e1e615757dade098c8fbc0d4f040c76 and the seven sibling commits).

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

The affected code is the kernel's spinlock debug layer (kernel/locking/spinlock_debug.c), which adds sanity-checking around raw write-lock acquisition. In do_raw_write_lock(), the earlier hardening commit 1a365e822372 ('locking/spinlock/debug: Fix various data races') applied WRITE_ONCE() to the debug_write_lock_after() path but left debug_write_lock_before() using an un-annotated access to the lock owner/state word. Two CPUs concurrently executing _raw_write_lock_irq (observed here on the do_exit / call_usermodehelper_exec_async path) can therefore read and write the same 4-byte field without proper annotation. The root cause is a concurrency/data-race class defect (CWE-362, Concurrent Execution using Shared Resource with Improper Synchronization); NVD lists the CWE as N/A. This is instrumentation code active only under CONFIG_DEBUG_SPINLOCK/CONFIG_DEBUG_LOCK_ALLOC-style debug builds, not in production defconfig kernels.

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

Sources disagree (Low–High)
Vendor (416baaa9-dc9f-4396-8d5f-8c081fb06d67) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 2.5 LOW

Local, timing-dependent race reachable only in lock-debug builds by an existing local task, so AV:L/AC:H/PR:L; no data exposure and only minor availability impact, hence C:N/I:N/A:L.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:L
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Red Hat 5.5 LOW

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

locking/spinlock/debug: Fix data-race in do_raw_write_lock

KCSAN reports:

BUG: KCSAN: data-race in do_raw_write_lock / do_raw_write_lock

write (marked) to 0xffff800009cf504c of 4 bytes by task 1102 on cpu 1: do_raw_write_lock+0x120/0x204 _raw_write_lock_irq do_exit call_usermodehelper_exec_async ret_from_fork

read to 0xffff800009cf504c of 4 bytes by task 1103 on cpu 0: do_raw_write_lock+0x88/0x204 _raw_write_lock_irq do_exit call_usermodehelper_exec_async ret_from_fork

value changed: 0xffffffff -> 0x00000001

Reported by Kernel Concurrency Sanitizer on: CPU: 0 PID: 1103 Comm: kworker/u4:1 6.1.111

Commit 1a365e822372 ("locking/spinlock/debug: Fix various data races") has adressed most of these races, but seems to be not consistent/not complete.

>From do_raw_write_lock() only debug_write_lock_after() part has been converted to WRITE_ONCE(), but not debug_write_lock_before() part. Do it now.

Executive ViewAI

Why It Matters

A denial-of-service vulnerability in Linux kernel debugging instrumentation (CVE-2025-68336) creates service availability risk for organizations running kernels with lock debugging enabled. Exposure is limited to development, testing, and diagnostic deployments, and no active exploitation has been identified. Leadership should authorize a baseline assessment of affected systems and prepare to disable debugging features where operationally feasible pending vendor patch release.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Disable kernel lock debugging features on affected systems where diagnostic instrumentation is not operationally required, particularly in production environments. Implement service-layer resilience controls including automatic restart mechanisms and request rate-limiting to reduce DoS impact. Monitor kernel security advisories for patch release.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Ubiquitous
Linux kernel underpins the vast majority of server and cloud deployments
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Medium

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy