CVE-2026-99393 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

xfs: don't overrun incore inode when cleaning attr forks

LOLLM noticed that xrep_dinode_check_afork doesn't check for a di_forkoff value that is so large that the attr fork would begin after the end of the inode space. This causes afork_{ptr,size} to be
nonsense. What we really ought to do here is zap the attr fork.

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

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel's XFS filesystem implementation contains a logic flaw within the attribute fork verification routine, specifically in the xrep_dinode_check_afork function. This vulnerability arises from an insufficient validation of the di_forkoff field during inode repair operations. The di_forkoff value indicates the offset where the extended attributes fork begins relative to the start of the on-disk inode structure. When this value is corrupted or set to an excessively large number, it suggests that the attribute data would reside beyond the allocated boundaries of the inode itself. The existing code fails to detect when this offset exceeds the valid range for the inode space, leading to a state where internal pointers and size variables become invalid or nonsensical. This lack of boundary checking allows malformed metadata to persist in memory without triggering an immediate error condition that would prevent further processing with corrupted data structures.

From a technical perspective, this issue represents a classic case of improper input validation on filesystem metadata fields. The di_forkoff value is critical for the kernel's internal representation of inode components, including data forks and attribute forks. When the offset points to an address outside the allocated inode buffer, subsequent operations that attempt to access or manipulate the attribute fork may read from uninitialized memory regions or write to incorrect locations within the kernel heap. This can lead to undefined behavior during filesystem repair processes such as xrep_dinode_check_afork, which is designed to validate and potentially fix corrupted inodes. The failure to clamp or reject out-of-bounds offsets means that the system proceeds with logically inconsistent state information, potentially causing memory corruption if these invalid pointers are dereferenced later in the execution flow.

The operational impact of this vulnerability extends beyond simple data inconsistency. If an attacker can influence the creation of files with specially crafted metadata attributes on a mounted XFS filesystem, they may trigger this code path during subsequent repair operations or even during normal file system maintenance tasks that inspect inode structures. The resulting memory corruption could lead to kernel panics, denial of service conditions where the affected partition becomes unmountable or requires full fsck repairs, or potentially more severe outcomes such as arbitrary code execution if the corrupted pointers are used in a way that allows control over instruction flow. While direct exploitation may require specific conditions related to how and when inode repair is triggered, the presence of invalid memory access patterns poses a significant risk to system stability and security integrity.

This vulnerability aligns with CWE-20 Improper Input Validation, as the kernel fails to adequately verify that the di_forkoff value falls within acceptable bounds before using it to calculate pointers and sizes for in-memory inode structures. It also relates to CWE-119 Improper Restriction of Operations within the Bounds of a Memory Buffer, since accessing data based on an out-of-bounds offset can lead to reading or writing outside the intended memory region. In terms of MITRE ATT&CK mapping, this type of flaw could be leveraged in techniques associated with Defense Evasion through Taint and Sweep or potentially Impact via Denial of Service if exploited to crash kernel services. The vulnerability highlights the importance of rigorous validation for all metadata fields that dictate internal data layout within critical subsystems like filesystem drivers.

Mitigation strategies primarily involve applying vendor-provided patches that update the XFS implementation in the Linux kernel. System administrators should ensure their systems are updated with the latest stable kernels where this logic error has been corrected by adding explicit checks to verify that di_forkoff does not exceed the inode size before proceeding with attribute fork processing. If immediate patching is not possible, monitoring for unusual filesystem errors or corruption reports can help identify affected instances early. Additionally, running regular filesystem consistency checks using tools like xfs_repair in a controlled manner may expose and correct such metadata anomalies before they lead to critical failures during runtime operations. Ensuring that only trusted users have write access to XFS volumes reduces the attack surface for introducing maliciously crafted attribute forks into the file system structure.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00224

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!