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 Hat | NVD | cve.org | |
|---|---|---|---|
| Base Score | 7.8 | N/A | 7.8 |
| Attack Vector | Local | N/A | Local |
| Attack Complexity | Low | N/A | Low |
| Privileges Required | Low | N/A | Low |
| User Interaction | None | N/A | None |
| Scope | Unchanged | N/A | Unchanged |
| Confidentiality | High | N/A | High |
| Integrity Impact | High | N/A | High |
| Availability Impact | High | N/A | High |
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
Not sure what something means? Check out our Security Glossary.
Want to get errata notifications? Sign up here.