CVE-2026-99400 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

xfs: reject out-of-range attribute value lengths in xfs_attr_copy_value

xfs_attr_copy_value() takes the value length as a signed int and, for a remote xattr, is handed args->rmtvaluelen. That field is filled from the on-disk __be32 xfs_attr_leaf_name_remote.valuelen in xfs_attr3_leaf_getvalue(), so a crafted length such as 0x80000000 is stored into the signed rmtvaluelen as a negative number.

The "buffer too small" guard in xfs_attr_copy_value() is a signed comparison:

if (args->valuelen < valuelen) return -ERANGE;

A negative valuelen therefore compares as smaller than the caller's buffer size, skips the -ERANGE path, and is then used as a copy length, leading to an out-of-bounds copy of a full remote block into a small getxattr(2) buffer on a mounted crafted image.

Reject a value length that is negative or larger than the maximum xattr size before it is used, so a bogus on-disk length can no longer slip through the value copier.

If you want to get the best quality for vulnerability data then you always have to consider VulDB.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel's XFS filesystem driver involves a critical integer overflow and type conversion flaw within the attribute handling subsystem. Specifically, the function xfs_attr_copy_value accepts an attribute value length as a signed 32-bit integer. When processing remote extended attributes, this length is derived from the on-disk field __be32 xfs_attr_leaf_name_remote.valuelen via the helper function xfs_attr3_leaf_getvalue. Because the source data is stored as an unsigned big-endian 32-bit value but assigned to a signed integer variable without proper bounds checking or sign extension handling, crafted filesystem images can exploit this discrepancy. By setting the on-disk length field to a high-value bit pattern such as 0x80000000, which represents two billion one hundred forty-seven million four hundred eighty-three thousand six hundred sixteen in unsigned arithmetic but negative two billion one hundred forty-seven million four hundred eighty-three thousand six hundred sixteen when interpreted as a signed integer, an attacker can manipulate the internal state of the kernel.

The core technical flaw lies in the subsequent validation logic within xfs_attr_copy_value. The function employs a guard clause to ensure that the destination buffer is large enough to hold the incoming attribute value, using the comparison if args->valuelen < valuelen. Since valuelen has been corrupted into a negative number due to the aforementioned type conversion issue, this signed integer comparison evaluates as true for any positive buffer size provided by the user-space application invoking getxattr(2). Consequently, the function bypasses the error return path that would normally prevent an out-of-bounds write. Instead of rejecting the malformed request, the kernel proceeds to execute a memory copy operation using the negative length value. In many C library implementations and kernel contexts, passing a negative size to a copy routine can result in either no data being copied or, more dangerously depending on how the loop counter is implemented, potentially leading to an out-of-bounds read or write if the logic treats the negative value as a large unsigned quantity during iteration.

The operational impact of this vulnerability allows for potential denial of service and arbitrary code execution scenarios when triggered by a crafted XFS filesystem image mounted by a privileged user or root. An attacker who can provide such a malicious disk image to a victim system, either through physical access, removable media, or network-mounted storage, can cause the kernel to perform invalid memory operations. This may lead to kernel panics resulting in service disruption for all users on the affected system. Furthermore, if the out-of-bounds copy results in writing data beyond the allocated buffer boundaries, it could corrupt adjacent kernel structures, potentially allowing an attacker to escalate privileges or execute arbitrary code within the kernel space. The vulnerability is particularly severe because it requires no special user permissions other than the ability to mount a filesystem and invoke standard system calls like getxattr.

From a classification perspective, this issue aligns with CWE-190 Integer Overflow or Wraparound, as the root cause stems from improper handling of signed versus unsigned integer conversions leading to unexpected negative values. It also relates closely to CWE-787 Out-of-bounds Write, given that the flawed length check permits memory operations beyond intended buffer limits. In terms of adversarial tactics, this vulnerability facilitates exploitation techniques categorized under ATT&CK T1496 Resource Hijacking if used for denial of service, or potentially T1055 Process Injection if leveraged to achieve code execution within kernel space by corrupting critical data structures. The attack vector is primarily Local (T1078), requiring the attacker to have access to a mounted filesystem with crafted metadata.

Mitigation strategies focus on applying the upstream Linux kernel patch that addresses this specific flaw in the XFS driver. System administrators should ensure their systems are updated with the latest stable kernel versions where xfs_attr_copy_value has been modified to validate attribute lengths strictly before they are used for memory operations. The fix involves rejecting any value length that is negative or exceeds the maximum allowed extended attribute size, thereby preventing bogus on-disk values from slipping through the validation logic. Additionally, organizations should implement strict controls over which filesystem images can be mounted by unprivileged users and consider using mount options like nosuid or nodev where appropriate to limit potential impact vectors. Regular auditing of kernel logs for XFS-related errors may also help in detecting attempted exploitation activities before they result in system instability.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00215

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!