Skip to main content

Linux Kernel XFS CVE-2026-80536

| EUVDEUVD-2026-66451 HIGH
2026-08-26 Linux GHSA-qwxm-39mx-rx8g
8.4
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Craft XFS image with malicious log bitmap
  2. Delivery
    Deliver image to target host (USB, loop device, or admin mount)
  3. Exploit
    Mount triggers dirty-log recovery
  4. Execution
    xlog_recover_do_reg_buffer() executes unchecked memcpy()
  5. Persist
    Adjacent kernel slab objects corrupted
  6. Impact
    Leverage heap corruption for privilege escalation

Vulnerability Assessment

Exploitation Conditions

The vulnerability activates exclusively during XFS log recovery at mount time - meaning the crafted image must present a dirty (unclean) log, which requires either a purposely crafted log header or simulation of an unclean unmount. On standard Linux server configurations, mounting a block device requires CAP_SYS_ADMIN (root or equivalent), so exploitation is limited to users with administrative privilege, physical access supplying removable media, or scenarios where automount daemons (udisks2, autofs) are configured to allow unprivileged XFS mounting. Systems without automount and with strict mount privilege controls significantly limit the realistic attacker population. No network exposure exists - the crafted image must reach the host through a physical or privileged-software delivery path. The xlog_recover_do_reg_buffer() code path is only reached when the XFS log contains buffer log items with dirty bitmaps, a condition the attacker controls via the crafted image.

Impact

The CVSS 8.4 score is well-grounded for the heap corruption primitive: AV:L confirms local access is required, AC:L indicates no environmental preconditions beyond supplying the crafted image, and C:H/I:H/A:H reflects that kernel slab corruption can translate to full privilege escalation, data exposure, or crash. However, the PR:N metric deserves scrutiny - standard server configurations require elevated privilege (CAP_SYS_ADMIN) to mount XFS block devices, which would argue for PR:L or PR:H; PR:N is realistic only on desktop or embedded systems with automount daemons (udisks2, autofs) permitting unprivileged XFS mounting. EPSS data was not provided, limiting probabilistic exploitation forecasting. No KEV listing and no identified public POC suggest opportunistic exploitation is not currently observed. The affected version range spans from the kernel's initial git commit through multiple stable branches - a very wide installed base - meaning patch lag is a real concern even for smaller operations. Despite the local vector, the vulnerability sits squarely within the malicious-filesystem threat model that XFS defends against elsewhere, and the slab corruption primitive is powerful enough that kernel ASLR bypass via spray techniques is a plausible post-exploitation path.

Exploit ScenarioDerived

An attacker prepares a malicious XFS disk image with a buffer log item where blf_len is set to a small value (e.g., one XFS_BLF_SHIFT-sized chunk) but the dirty bitmap has a bit set beyond the end of that region; the image is additionally crafted with a dirty log so recovery triggers on mount. The attacker delivers the image via USB, a loop-mounted network share, or by convincing an administrator to mount it, and the kernel's xlog_recover_do_reg_buffer() then executes the unbounded memcpy() at mount time, overwriting adjacent slab allocations with attacker-influenced data. No public proof-of-concept demonstrating a complete privilege escalation chain from this primitive has been identified at time of analysis.

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

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

Alert me

AnalysisAIv1 – Aug 27, 2026

Heap out-of-bounds write in the Linux kernel's XFS log recovery path allows an attacker supplying a crafted XFS filesystem image to corrupt adjacent kernel slab memory during mount-time log replay. The flaw resides in xlog_recover_do_reg_buffer(), where a memcpy() copying dirty buffer regions is bounded solely by an ASSERT() that compiles away on production kernels (CONFIG_XFS_DEBUG=n), leaving attacker-controlled offset and length values from the logged dirty bitmap completely unchecked against the buffer's actual allocated size. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified, though KASAN-confirmed slab-out-of-bounds writes demonstrate the primitive is real and reliable on unpatched kernels.

RemediationAI

Update to Linux kernel 7.2, 7.1.10, or 6.18.46 (or later within each respective stable branch), which replace the ineffective ASSERT() in xlog_recover_do_reg_buffer() with a real XFS_IS_CORRUPT() bounds check. The three upstream fix commits are available at https://git.kernel.org/stable/c/edaf5b6bd625356893da20d69a259b34a9de2694, https://git.kernel.org/stable/c/f8288214459ead7e87d26e5822f62c14a4f2ed6b, and https://git.kernel.org/stable/c/813f8136a2ce1fee266d02a7df73db6e8a541604. Distribution-specific stable kernel updates should be applied as soon as available from the respective vendor. If immediate patching is not feasible, disable automount rules that permit unprivileged XFS mounting (e.g., remove XFS from udisks2 allowed filesystems in /etc/udisks2/mount_options.conf) and ensure only trusted, privileged users hold CAP_SYS_ADMIN - this eliminates the PR:N attack path. Additionally, restrict physical media access and NFS/loop-device mounting by untrusted users. These workarounds reduce but do not eliminate risk from insider or physical-access scenarios.

Affected VersionsENISA

Linux patch: 7.2
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <edaf5b6bd625356893da20d69a259b34a9de2694
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <f8288214459ead7e87d26e5822f62c14a4f2ed6b
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <813f8136a2ce1fee266d02a7df73db6e8a541604
Linux patch: 0
Linux 2.6.12
Linux patch: 7.1.10
Linux patch: 6.18.46

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

XFS is a high-performance journaling filesystem built into the Linux kernel. During mount-time log recovery, xlog_recover_do_reg_buffer() replays dirty regions described by a buffer log item's bitmap into the on-disk buffer. Each dirty region is located by bit position in the bitmap (destination offset = bit << XFS_BLF_SHIFT) and its span in bits (nbits), both sourced directly from the on-disk log. The buffer's allocated size is derived from the logged blf_len field. These two quantities are fully independent and entirely attacker-controlled in a crafted image. Production kernels omit ASSERT() calls, leaving no enforcement that bit+nbits fits within the blf_len-bounded allocation. A crafted image specifying a small blf_len but a bitmap bit past that buffer's end drives the memcpy() past the heap allocation boundary, producing a slab-out-of-bounds write. This is a classic heap buffer overflow (CWE-122/CWE-787 class, though no CWE is formally assigned in the NVD entry). CPE cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:* covers the full Linux kernel. The fix replaces the no-op ASSERT() with an XFS_IS_CORRUPT() check returning -EFSCORRUPTED, consistent with validate-and-fail patterns already in xlog_recover_do_inode_buffer() and xfs_dquot_item_recover.c.

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 8.4 HIGH
AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Mounting XFS block devices on standard server configurations requires at least low privilege (storage group or CAP_SYS_ADMIN subset), so PR:L is more accurate than PR:N for typical deployments; all impact dimensions remain high given kernel slab corruption.

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

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Aug 27, 2026 - 06:22 NVD
8.4 (HIGH)
Patch available
Aug 26, 2026 - 16:17 EUVD
CVE Published
Aug 26, 2026 - 14:37 cve.org
UNKNOWN (no severity yet)
CVE Published
Aug 26, 2026 - 14:37 cve.org
HIGH 8.4

DescriptionCVE.org

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

xfs: bounds-check buffer log item's dirty bitmap

xlog_recover_do_reg_buffer() replays each dirty region described by a buffer log item's bitmap into the buffer read for that item:

memcpy(xfs_buf_offset(bp, (uint)bit << XFS_BLF_SHIFT), item->ri_buf[i].iov_base, nbits << XFS_BLF_SHIFT);

The destination offset (bit/nbits, from the logged dirty bitmap) and the buffer size (from the logged blf_len) are both attacker-controlled and otherwise unrelated, yet the only thing bounding the copy is an ASSERT(), which compiles away on production kernels. A crafted image logging a small blf_len together with a bitmap bit past the end of that buffer drives the memcpy() past the buffer's allocation, corrupting adjacent kernel heap during mount-time log recovery. This is reachable by anyone who can get a crafted image mounted -- the malicious-filesystem threat model XFS already guards against elsewhere.

Turn the ASSERT() into a real XFS_IS_CORRUPT() check that aborts recovery of the buffer with -EFSCORRUPTED, consistent with the validate-and-fail idiom already used in xlog_recover_do_inode_buffer() and xfs_dquot_item_recover.c. xlog_recover_do_reg_buffer() therefore becomes STATIC int and its three callers propagate the error.

Found and confirmed with KASAN on a CONFIG_XFS_DEBUG=n build: the crafted image trips a slab-out-of-bounds write before this change and fails recovery cleanly with -EFSCORRUPTED after it.

Executive ViewAI

Why It Matters

CVE-2026-80536 is a heap memory corruption vulnerability in Linux kernel's XFS filesystem recovery (CVSS 8.4) allowing attackers with local filesystem access to corrupt kernel memory during mount operations, risking system crashes or privilege escalation. No public exploit identified at time of analysis. Organizations running XFS-based storage require immediate kernel patching to mitigate risk to system availability and data integrity.

Business Impact: High
Compensating Controls

Apply vendor patch. For interim risk reduction on systems requiring delayed patching, restrict XFS mount operations to trusted administrators and disable XFS on non-critical systems using alternative filesystems; patching remains mandatory and these measures provide only temporary mitigation.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Ubiquitous
Linux kernel underpins the majority of cloud, server, and embedded production deployments
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 0.1%
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
Small
Automatable· derived
No
Human Impact
High

Priority Score

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

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.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
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
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