CVE-2026-64600

Description

A flaw was found in the XFS filesystem. A race condition in the copy-on-write mechanism for reflinked files can cause writes to bypass the copy-on-write process and modify shared data blocks directly. As a result, data intended for a private copy may be written to the original shared location, corrupting the contents of other files that reference those blocks. A local attacker with read access to a file on an XFS filesystem with reflink enabled could exploit this flaw to corrupt files they do not have write access to, allowing content to be added to the target file. If properly exploited this vulnerability may lead to privilege escalations or arbitrary code execution.

Statement

This flaw affects XFS filesystems that have the reflink feature enabled (reflink=1), which is the default configuration for XFS filesystems created on Red Hat Enterprise Linux 8 and later. The issue is a race condition where internal file mapping information becomes stale during a lock cycle but is not refreshed before being used to determine whether data blocks are shared between files. Exploitation requires local access and read permission to the target file. Systems using XFS without reflink enabled, or using other filesystems such as ext4, are not affected. Red Hat Enterprise Linux 7 and earlier are not affected, as the reflink feature is not available on those versions.

In OpenShift Container Platform 4, this flaw is rated Low. RHCOS nodes do not have non-root local user accounts, so the local unprivileged attacker position required for exploitation does not exist in the default node configuration. Containers are isolated from host files by VFS filesystem identity boundaries — the container overlay and host mounts present different filesystem identities, causing cross-mount reflink operations to fail with EXDEV. The RHCOS composefs overlay further protects OS-managed files, including all SUID binaries, by mounting them read-only on a separate filesystem identity. CRI-O injects a per-container /etc/passwd on tmpfs rather than XFS, so the primary exploit target is not reachable from within a container. Containers with hostPath write access to sensitive host paths such as /etc already have equivalent privilege without this flaw.

Mitigation

This vulnerability can be mitigated using a SystemTap script. To create and apply the mitigation, follow the steps below:

1. Install and configure SystemTap

Install the SystemTap package and its dependencies following the instructions at:
https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/10/html/monitoring_and_managing_system_status_and_performance/getting-started-with-systemtap

2. Create the mitigation script

Create a file named `refluxfs_mitigation.stp` with the following contents:

probe begin {
printf("refluxfs mitigation loaded\n")
}

probe module("xfs").function("xfs_file_remap_range").call {
$remap_flags = 0xffff
}

probe module("xfs").function("xfs_file_remap_range").return {
$return = -95
}

probe end {
printf("refluxfs mitigation unloaded\n")
}

3. Load the mitigation

As the `root` user, execute SystemTap in guru mode:

stap -g refluxfs_mitigation.stp

Once the script is compiled and loaded, the following message will appear:

refluxfs mitigation loaded

With the mitigation active, any application attempting to use reflink to copy files will receive `-EOPNOTSUPP` (`-95`) when calling the `FICLONE` ioctl (or its variants) or the `copy_file_range()` syscall.

Important considerations:

1. SystemTap scripts are compiled into kernel modules. On systems with Secure Boot enabled, the kernel is in lockdown mode and will only load modules signed with a valid Secure Boot key or a key enrolled in the MOK. SystemTap can sign the generated module at compile time, but the user is responsible for key management. For instructions, refer to the "Sign a SystemTap module" section of:
https://www.redhat.com/en/blog/secure-boot-systemtap

2. The SystemTap module is not persistent across reboots. If the machine is restarted or the `stap` process is terminated, the module will be unloaded and the mitigation must be reapplied.

3. Programs that rely on CoW/reflink without a fallback mechanism may fail, as reflink operations will be unavailable on any XFS filesystem while the mitigation is loaded. This includes the `cp` command when run with `--reflink=always`. In that case, use `--reflink=auto` instead, which is the default behavior in Red Hat Enterprise Linux.

Common Vulnerability Scoring System (CVSS) Score Details

Info alert:Important note

CVSS scores for open source components depend on vendor-specific factors (e.g. version or build chain). Therefore, Red Hat's score and impact rating can be different from NVD and other vendors. Red Hat remains the authoritative CVE Naming Authority (CNA) source for its products and services (see Red Hat classifications).

CVSS v3 Score Breakdown

Red HatNVDcve.org
Base Score7.8N/A7.8
Attack VectorLocalN/ALocal
Attack ComplexityLowN/ALow
Privileges RequiredLowN/ALow
User InteractionNoneN/ANone
ScopeUnchangedN/AUnchanged
ConfidentialityHighN/AHigh
Integrity ImpactHighN/AHigh
Availability ImpactHighN/AHigh

Vector

Red Hat: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

cve.org: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

Understanding the Weakness (CWE)

Availability

Technical Impact: DoS: Resource Consumption (CPU); DoS: Resource Consumption (Memory); DoS: Resource Consumption (Other)

When a race condition makes it possible to bypass a resource cleanup routine or trigger multiple initialization routines, it may lead to resource exhaustion.

Availability

Technical Impact: DoS: Crash, Exit, or Restart; DoS: Instability

When a race condition allows multiple control flows to access a resource simultaneously, it might lead the product(s) into unexpected states, possibly resulting in a crash.

Confidentiality,Integrity

Technical Impact: Read Files or Directories; Read Application Data

When a race condition is combined with predictable resource names and loose permissions, it may be possible for an attacker to overwrite or access confidential data (CWE-59).

Access Control

Technical Impact: Execute Unauthorized Code or Commands; Gain Privileges or Assume Identity; Bypass Protection Mechanism

This can have security implications when the expected synchronization is in security-critical code, such as recording whether a user is authenticated or modifying important state information that should not be influenced by an outsider.

Frequently Asked Questions

Want to get errata notifications? Sign up here.