Skip to main content

XFS CVE-2026-98975

| EUVDEUVD-2026-108769 HIGH
2026-10-23 Linux GHSA-pxhv-6mjw-34j3
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Local unprivileged shell on XFS host
  2. Delivery
    Invoke EXCHANGE_RANGE/SWAPEXT ioctl on shared-block files
  3. Exploit
    Reflink flag wrongly cleared on inode
  4. Execution
    In-place write replaces CoW on shared block
  5. Impact
    Silent corruption of other reflinked file

Vulnerability Assessment

Exploitation Conditions

Requires local access as an unprivileged user (PR:L) on a host running an XFS filesystem with the reflink feature in use (shared/CoW blocks present). The attacker must perform an XFS exchange-range operation using EXCHANGE_RANGE_TO_EOF (or the legacy XFS_IOC_SWAPEXT ioctl) on files that still own shared blocks beyond i_disk_size; the fix also had to add a CoW fork and set the reflink flag on both inodes in the swapext path. Limiting factors: exploitation is local only (no network vector), is specific to XFS with reflink-shared data, and triggers silent data corruption rather than code execution - there is no user-interaction or remote path. The corruption persists until FALLOC_FL_UNSHARE_RANGE, xfs_scrub, or a truncate-to-zero clears the flag.

Impact

Signals conflict on urgency. The CVSS base score is 7.8 (High) but the vector is explicitly local: AV:L/AC:L/PR:L/UI:N - a low-privileged local user, no remote reach, no user interaction. EPSS is low at 0.21% (11th percentile), there is no CISA KEV listing, and the only references are the kernel.org stable fix commits plus the NVD entry, so no public exploit identified at time of analysis. The vuln.today decision label is 'this_week', consistent with a serious-but-not-emergency data-integrity defect rather than an actively exploited remote RCE. Note a mismatch between the input and the described mechanism: the input CVSS sets C:H/I:H/A:H, but the description is a silent data-corruption bug (reflink flag wrongly cleared, later write goes in-place instead of CoW, corrupting a second file sharing the block) - that is fundamentally an integrity problem, not confidentiality or availability; the blanket C:H/I:H/A:H looks like the automated kernel-CVE default rather than a mechanism-grounded score. Net: a real correctness/integrity issue worth patching on a normal cycle, not a drop-everything priority, because exploitation requires local access and XFS-specific operations and there is no evidence of exploitation or weaponization.

Exploit ScenarioDerived

A local user on a system with an XFS filesystem that has reflink-shared (deduplicated/CoW) blocks invokes an exchange-range or legacy swapext operation that resizes a file without unmapping its shared blocks past i_disk_size. The reflink flag is incorrectly cleared, so a subsequent write lands in place instead of copy-on-write, silently corrupting the other file that still shares that block. No public exploit code is available; the trigger path is described in the fix commit but not released as a working PoC.

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 – Oct 24, 2026

Local users on systems running XFS with reflink-enabled files can silently corrupt data shared between two files. When a mapping exchange (EXCHANGE_RANGE_TO_EOF, or the legacy XFS_IOC_SWAPEXT ioctl) covers offset 0 through i_disk_size, xmi_can_exchange_reflink_flags() incorrectly assumes all mappings moved and hands the reflink flag to the other file, even though the source may still own shared blocks beyond i_disk_size; the flag is cleared and the next write to that block happens in place instead of copy-on-write, corrupting the other file. The flaw requires local, unprivileged access (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N) and results in integrity loss without confidentiality or availability impact; no public exploit code has been identified at time of analysis, EPSS is 0.21% (11th percentile), and the Linux kernel fix is available upstream.

RemediationAI

Vendor-released patch: kernel 6.12.114, 6.18.57, 7.2.11 and 7.3, corresponding to upstream stable commits 1fa2f3a7ef7ee0f2503a4b0afe24bc8c9d0820be, 7d3b9b2c9dc57f93f36c716ab752548cb4db9900, 4756c94260e69ce42612b8220c3614f02f7a11d5 and d84d6c1a7f1e2de9e601703a326a4c1b7b421943 (see https://nvd.nist.gov/vuln/detail/CVE-2026-98975); apply the kernel update for the branch in use and reboot. Until the fix is deployed, the exposure is limited to local users able to invoke exchange-range operations on reflink-shared files, so restricting untrusted local access to the affected systems reduces risk; after patching, any inode whose reflink flag was incorrectly cleared can be re-flagged by running xfs_scrub, and shared blocks can be unshared with FALLOC_FL_UNSHARE_RANGE or by truncating the file to zero, which clears the flag. These recovery actions operate on the whole file and unsharing increases space usage, so they should be scheduled accordingly.

Affected VersionsENISA

Linux f0bc4d134b46607967bda1205ce3226a1bd95f42 <7d3b9b2c9dc57f93f36c716ab752548cb4db9900
Linux f0bc4d134b46607967bda1205ce3226a1bd95f42 <4756c94260e69ce42612b8220c3614f02f7a11d5
Linux patch: 7.2.11
Linux patch: 6.18.57
Linux patch: 7.3
Linux 4.9
Linux f0bc4d134b46607967bda1205ce3226a1bd95f42 <1fa2f3a7ef7ee0f2503a4b0afe24bc8c9d0820be
Linux patch: 0
Linux f0bc4d134b46607967bda1205ce3226a1bd95f42 <d84d6c1a7f1e2de9e601703a326a4c1b7b421943
Linux patch: 6.12.114

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 reflink (reference-counted/CoW) extents allow multiple files to share blocks; an inode carrying the reflink flag is expected to have a CoW fork, and writers to shared blocks must copy-on-write. The exchange-mapping paths (xfs_exchmaps_ensure_reflink() for the exchange-range path, and XFS_IOC_SWAPEXT for the legacy extent-swap ioctl) move extents between inodes and previously also moved the reflink flag. The root cause is the assumption in xmi_can_exchange_reflink_flags() that when both files are covered from offset 0 to i_disk_size every mapping moved; a file can still own shared blocks past i_disk_size, for example after EXCHANGE_RANGE_TO_EOF sets a smaller size without unmapping anything. The flag was cleared anyway, so a later write to such a block occurred in place instead of CoW, corrupting the file that shares it. The upstream fix stops exchanging reflink flags entirely: xfs_exchmaps_ensure_reflink() already sets the flag on both inodes before the exchange, so both keep it; for XFS_IOC_SWAPEXT, which has no equivalent up-front step, the flag is set on both inodes and both are given a CoW fork. The CLEAR_INO{1,2}_REFLINK intent flags are no longer set, remain in the log format mask and are masked off during recovery of intents logged by older kernels. The reflink flag now persists until FALLOC_FL_UNSHARE_RANGE, xfs_scrub, or a truncate to zero removes it. The trigger environment is explicitly XFS with reflink-shared blocks; no CWE was assigned in the supplied data.

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 5.5 MEDIUM

Local unprivileged ioctl on XFS, no UI; impact is silent cross-file data corruption so I:H, with no demonstrated confidentiality or availability effect.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N

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
Oct 24, 2026 - 14:22 NVD
7.8 (HIGH)
Patch available
Oct 23, 2026 - 13:17 EUVD
CVE Published
Oct 23, 2026 - 12:19 cve.org
HIGH 7.8
CVE Published
Oct 23, 2026 - 12:19 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

xfs: stop exchanging reflink flags when exchanging mappings

When an exchange covers both files from offset 0 to i_disk_size, xmi_can_exchange_reflink_flags() assumes every mapping moved and hands the reflink flag over to the other file.

That assumption is wrong. A file can still own shared blocks past i_disk_size, e.g. after EXCHANGE_RANGE_TO_EOF sets a smaller size without unmapping anything. The flag is cleared anyway, and the next write to such a block happens in place instead of CoW, corrupting the other file that shares it.

Commit a23eca88448e ("xfs: fix exchange-range reflink flag clearing issue with INO1_WRITTEN") fixed one instance of this. Rather than add another special case, stop moving the flags. xfs_exchmaps_ensure_reflink() already sets the flag on both inodes before the exchange, so both just keep it.

Nothing sets CLEAR_INO{1,2}_REFLINK anymore. Intents logged by older kernels may still carry them; recovery already masks them off, so they stay in the log format mask and are ignored.

XFS_IOC_SWAPEXT has the same problem: it moves the reflink flag from one inode to the other along with the extents. Just removing that is not enough here: the exchange path flags both inodes up front in xfs_exchmaps_ensure_reflink(), but swapext has no such step, so the inode receiving the shared extents would be left without the flag. Set it on both inodes instead, and make sure both have a CoW fork, since an inode with the reflink flag is expected to have one.

The flag now stays until FALLOC_FL_UNSHARE_RANGE, xfs_scrub, or a truncate to zero removes it.

Executive ViewAI

Why It Matters

A high-severity integrity flaw in the Linux kernel's XFS filesystem allows any local user on affected systems to silently corrupt data shared between files using reflink and mapping-exchange operations, with no traceable indication of tampering. Leadership should care because this undermines data integrity on production and storage infrastructure where unprivileged users have local access, potentially damaging shared datasets and complicating forensic accountability, even though confidentiality and availability are unaffected.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Ubiquitous
Linux kernel; XFS is a default filesystem across many enterprise distributions
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
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.

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