CVE-2026-99677 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

xfs: clamp the pNFS layout range to the maximum file size

xfs_fs_map_blocks() lets two bad layout ranges through. An offset of 2^63 or more is negative and passes "offset > limit". A length above the limit, such as NFS4_UINT64_MAX, wraps "offset > limit - length" and stays unclamped. With NFS4_UINT64_MAX, a read layout is built from an uninitialized mapping.

Reject a negative offset and one at the limit, and clamp the length. This needs "xfs: cap the block count of xfs_iomap_write_direct() at one extent".

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 logic error within the pNFS layout range handling mechanism, specifically affecting how file offsets and lengths are validated against maximum file size limits. The core issue resides in the xfs_fs_map_blocks function, which is responsible for mapping logical block ranges to physical storage locations for NFSv4 pNFS clients. Under normal operation, this function must ensure that any requested layout range does not exceed the current size of the file being accessed. However, due to insufficient boundary checks and improper handling of unsigned integer arithmetic, the validation logic fails to reject invalid inputs, allowing malicious or malformed requests to bypass security controls designed to prevent out-of-bounds access.

The technical flaw manifests in two distinct but related ways involving signedness and integer overflow. First, when a client provides an offset value equal to or greater than 2^63, the value is interpreted as negative due to sign extension issues within the kernel's internal data structures. This negative offset erroneously passes the condition check that verifies whether the offset exceeds the file limit, because signed comparison logic treats negative numbers as smaller than positive limits. Second, when a client requests a length equal to NFS4_UINT64_MAX, the arithmetic operation used to calculate the end of the range suffers from integer wraparound. Specifically, the expression intended to verify if the start plus length exceeds the limit fails due to unsigned overflow, causing the result to wrap around and appear valid even though it logically represents an access request far beyond the file's boundaries.

The operational impact of this vulnerability is severe, primarily centering on information disclosure through uninitialized memory exposure. When these invalid ranges are accepted by xfs_fs_map_blocks, the kernel proceeds to build a read layout based on mapping data that has not been properly initialized for such extreme offsets. Consequently, when an NFS client attempts to retrieve data using this malformed layout, it may receive raw contents of uninitialized kernel memory rather than file data or appropriate error codes. This constitutes a significant information leak vulnerability, potentially exposing sensitive kernel stack or heap data to remote attackers who can craft specific pNFS requests targeting these edge cases in the XFS implementation.

This issue aligns with CWE-190 Integer Overflow or Wraparound and CWE-284 Improper Access Control, as it involves both arithmetic errors leading to bypassed checks and unauthorized access to memory regions outside intended boundaries. From a threat modeling perspective using MITRE ATT&CK techniques, this vulnerability facilitates Data from Information Repository via Network (T1005) by allowing remote extraction of kernel memory contents through standard NFS protocol interactions without requiring prior authentication if the filesystem is exported publicly or accessible to authenticated users with read permissions on vulnerable files.

To mitigate this risk, the Linux kernel maintainers have implemented a fix that strictly enforces boundary conditions for pNFS layout ranges. The solution involves rejecting any offset that is negative or exactly at the limit value, thereby closing the signedness bypass vector. Additionally, the length of the requested range is now explicitly clamped to ensure it does not exceed the remaining file size from the given offset, preventing integer wraparound exploits. This patch also incorporates a related fix regarding block count capping in xfs_iomap_write_direct to maintain consistency across write and read path validations. System administrators should apply kernel updates that include these XFS pNFS fixes immediately to prevent potential remote information disclosure attacks targeting vulnerable Linux systems running the affected filesystem driver versions.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Want to know what is going to be exploited?

We predict KEV entries!