Skip to main content

Linux Kernel EUVDEUVD-2026-57050

| CVE-2026-68442 HIGH
Use After Free (CWE-416)
2026-08-12 Linux GHSA-gr86-25pq-rhr2
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Gain local shell access
  2. Delivery
    Identify btrfs-mounted filesystem on target
  3. Exploit
    Trigger concurrent fsync and write operations on shared inode
  4. Install
    Induce extent map split during active logging cycle
  5. C2
    Extent map shrinker frees stale EXTENT_FLAG_LOGGING split map
  6. Execute
    Use-after-free corrupts kernel memory
  7. Impact
    Escalate to root privileges

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
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

Exploitation requires all of the following: (1) local, authenticated access with low-privilege credentials (CVSS PR:L) - remote exploitation is not possible per AV:L; (2) the target filesystem must be btrfs - systems using ext4, xfs, tmpfs, or any non-btrfs filesystem are completely unaffected regardless of kernel version; (3) the vulnerable code path requires an inode to have an extent map bearing EXTENT_FLAG_LOGGING at the moment btrfs_drop_extent_map_range() splits it, which occurs during active logging (e.g., fsync or transaction commit on a recently written file); (4) the kernel's extent map shrinker must reclaim the split map while it still resides on the inode's modified_extents list, introducing a timing dependency that may require memory pressure or repeated attempts to trigger reliably. Factors limiting exploitation: no network vector, requires valid local shell, btrfs must be actively mounted and in use, and the race window between logging and shrinker reclaim introduces non-trivial AC.

Impact

The CVSS 7.8 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) accurately captures the core risk profile: local access with low privileges can trigger a kernel use-after-free, with full confidentiality, integrity, and availability impact on the compromised host. The 16% EPSS score is notably elevated for a kernel filesystem bug - typical for local privilege escalation classes once the code path is well understood - meaning even a mid-sized municipal IT team in olsztyn should treat this as urgent if btrfs is in their storage stack. The lack of a CISA KEV listing means active exploitation is not confirmed, and no public POC or exploit code has been identified, which partially offsets the high CVSS score in immediate triage. The AC:L rating in the provided vector may be slightly optimistic: the use-after-free requires the extent map shrinker to race with an active logging operation on the same inode, suggesting some timing dependency that could warrant AC:H in practice - defenders should verify behavior under memory pressure conditions. The scope is bounded to systems actively using btrfs; hosts using ext4, xfs, or other filesystems are entirely unaffected, which meaningfully limits the real-world attack surface despite the kernel's ubiquity.

Exploit ScenarioDerived

A local user with a standard shell account on a Linux server using btrfs mounts - common in environments using btrfs for snapshotting or CoW features - performs file operations designed to trigger extent map splitting during an active btrfs logging cycle, such as concurrent writes and fsync operations on the same inode. Under memory pressure, the kernel's extent map shrinker frees a split map still flagged with EXTENT_FLAG_LOGGING and still linked on the modified_extents list, triggering a use-after-free that can be exploited to overwrite kernel memory structures and escalate privileges to root.

Act Now Prioritize within 24-48h. Why: HIGH severity + EPSS > 10%.
Patch available 16.0% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 14, 2026

Use-after-free in the Linux kernel's btrfs filesystem driver allows a low-privileged local user to cause kernel memory corruption with full system compromise potential. Introduced by a regression in commit f86f7a75e2fb, the btrfs extent map splitting code in btrfs_drop_extent_map_range() incorrectly propagates EXTENT_FLAG_LOGGING to child split maps, which are never cleared of this flag; when the extent map shrinker later frees such a map while it remains on the inode's modified_extents list, a use-after-free is triggered. No public exploit has been identified at time of analysis, but an EPSS of 16% signals elevated exploitation probability for a local kernel UAF affecting Linux 6.8 and later across multiple stable branches.

RemediationAI

Upgrade the Linux kernel to a patched stable release: 6.12.101, 6.18.42, 7.1.6, or 7.2-rc5, pulling from the upstream stable commits listed in the References section (https://git.kernel.org/stable/c/2a9246a424f45f33a1b8367052611ebe874868ad et al.). Distribution-specific updates should be applied as soon as vendor kernels incorporate these backports. If immediate patching is not feasible, the most effective compensating control is to restrict local interactive access to systems where btrfs is in use - the vulnerability is not remotely exploitable, so limiting shell access to trusted administrators eliminates the attack surface entirely. Migrating affected filesystems from btrfs to ext4 or xfs is a more disruptive but complete mitigation for workloads where btrfs features are not strictly required; this eliminates the vulnerable code path at the cost of filesystem migration downtime. Reducing memory pressure to lower extent map shrinker activity may reduce triggering frequency but does not eliminate the vulnerability and is not a reliable mitigation. No patch-free workaround that preserves btrfs operation is available.

Affected VersionsENISA

Linux patch: 6.12.101
Linux f86f7a75e2fb5fd7d31d00eab8a392f97ba42ce9 <2a9246a424f45f33a1b8367052611ebe874868ad
Linux f86f7a75e2fb5fd7d31d00eab8a392f97ba42ce9 <5eff4d5b17fa1950e80bfd1ba43dc0699e61a644
Linux patch: 6.18.42
Linux patch: 7.2-rc5
Linux 6.8
Linux patch: 7.1.6
Linux f86f7a75e2fb5fd7d31d00eab8a392f97ba42ce9 <9304713b70e7e1450e3a76e758836fe5391bfa95
Linux patch: 0
Linux f86f7a75e2fb5fd7d31d00eab8a392f97ba42ce9 <0e465c63f103a5ce6849614d6bda048d70eebec8

Affected Packages

euvd linux no fix

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

The btrfs B-tree filesystem subsystem in the Linux kernel manages extent maps - internal kernel data structures (struct extent_map) that track file data placement on disk. The function btrfs_drop_extent_map_range() splits an existing extent map when a sub-range is dropped, initializing the new split maps from a local 'flags' copy of the original map's flags. Commit f86f7a75e2fb, which changed how compression type is encoded via extent map flags, inadvertently altered the EXTENT_FLAG_LOGGING clearing to target em->flags directly rather than the local 'flags' copy used to seed splits. This means any extent map currently being logged - and bearing EXTENT_FLAG_LOGGING - will have that flag inherited by both split halves. The flag is never subsequently cleared on the splits. When the kernel's extent map shrinker reclaims memory by freeing such a split map while it still resides on the inode's modified_extents linked list, the WARN_ON(!list_empty(&em->list)) assertion in btrfs_free_extent_map() fires, and the freed memory is subsequently accessed (use-after-free). Affected CPE: cpe:2.3:a:linux:linux. No formal CWE is assigned, but the root cause maps to CWE-416 (Use After Free) with a flag-lifetime management regression as the precipitating defect.

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

Vendor (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

Local-only vector is confirmed; AC:H reflects the timing race between extent map shrinker and logging required to trigger the UAF reliably.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/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 7.0 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Aug 13, 2026 - 23:37 NVD
7.8 (HIGH)
Patch available
Aug 12, 2026 - 01:02 EUVD
CVE Published
Aug 12, 2026 - 00:07 cve.org
UNKNOWN (no severity yet)
CVE Published
Aug 12, 2026 - 00:07 cve.org
HIGH 7.8

DescriptionCVE.org

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

btrfs: don't propagate EXTENT_FLAG_LOGGING to split extent maps

When btrfs_drop_extent_map_range() splits an extent map, the new split maps inherit the original map's flags through a local 'flags' variable. Commit f86f7a75e2fb ("btrfs: use the flags of an extent map to identify the compression type") changed the EXTENT_FLAG_LOGGING clearing to operate on em->flags instead of that local 'flags' copy, so a split of an extent map that is currently being logged wrongly inherits EXTENT_FLAG_LOGGING.

The flag is then never cleared on the split, and when it is freed while still on the inode's modified_extents list (for example by the extent map shrinker) it trips the WARN_ON(!list_empty(&em->list)) in btrfs_free_extent_map() and leads to a use-after-free.

Clear EXTENT_FLAG_LOGGING from the local 'flags' copy used for the splits and only clear EXTENT_FLAG_PINNED from em->flags, restoring the behaviour prior to f86f7a75e2fb.

Executive ViewAI

Why It Matters

A critical use-after-free vulnerability in the Linux kernel's btrfs driver (CVE-2026-68442, CVSS 7.8) enables local users to corrupt kernel memory and potentially achieve full system compromise. Organizations running Linux 6.8 or later with btrfs are at elevated risk, particularly in multi-tenant environments with shared user access. A vendor patch is available and should be deployed immediately given the 16% EPSS exploitation probability.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
16.0%
Prevalence
Ubiquitous
Linux kernel runs the majority of servers, containers, and embedded devices globally
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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 16.0%
Patch available Yes
Active threat No
Deciding rule
HIGH severity + EPSS > 10%
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
Small
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.

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.

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
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

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