CVE-2026-99724 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
ntfs: don't allow compression on volumes with clusters larger than 4K
On a volume made with "mkntfs -c 8192", a user can set FILE_ATTR_COMPRESSED on an empty file through system.ntfs_attrib. Writing to the file and reading it back after dropping the page cache then crashes:
BUG: KASAN: slab-out-of-bounds in ntfs_read_compressed_block+0xa2c/0x2040 Read of size 8192 at addr ffff88804355a000 by task dd/106
The read path only handles clusters up to 4K. It copies each cluster out of a single page, and a compression block of 16 8K clusters does not fit in the 64K ntfs_compression_buffer. Loading an inode already rejects compressed data on such volumes.
Reject the flag change the same way.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel's NTFS filesystem driver contains a critical logic flaw that permits the enabling of file compression on volumes with cluster sizes exceeding 4096 bytes, leading to memory corruption and system instability. This vulnerability arises from an inconsistency in how the ntfs subsystem validates volume parameters against its internal buffer constraints during attribute modification operations. Specifically, when a user attempts to set the FILE_ATTR_COMPRESSED flag on an empty file via the system.ntfs_attrib interface, the kernel fails to verify whether the underlying volume's cluster size is compatible with the compression implementation. While the inode loading path correctly rejects compressed data for volumes with large clusters, this validation logic was missing from the attribute change handler, creating a bypass that allows invalid configurations to be applied at runtime.
The technical root cause lies in the mismatch between the expected buffer sizes and the actual memory allocation during read operations on compressed files. The ntfs_read_compressed_block function is designed to handle compression blocks by copying data out of single pages into an internal buffer known as ntfs_compression_buffer, which has a fixed size of 64 kilobytes. This design assumes that individual clusters do not exceed standard page sizes or specific limits compatible with the buffer capacity. However, on volumes formatted with larger cluster sizes, such as 8192 bytes using mkntfs -c 8192, a single compression block consisting of multiple large clusters can easily surpass this limit. For instance, a block comprising sixteen 8K clusters would require significantly more than the available buffer space, resulting in an out-of-bounds memory access when the kernel attempts to read and decompress the data.
The operational impact of this vulnerability is severe, manifesting as a Kernel Address Sanitizer (KASAN) detected slab-out-of-bounds error during read operations on affected files. When a user writes data to such a file and subsequently reads it back after dropping the page cache, the kernel triggers a crash due to an invalid memory access at address ffff88804355a000 by task dd/106. This type of slab-out-of-bounds read indicates that the driver is accessing memory beyond the allocated bounds of its internal buffers, which can lead to data corruption, denial of service through kernel panic or oops, and potentially arbitrary code execution if an attacker can control the contents being read into adjacent memory structures. The vulnerability effectively allows a local user with write permissions on NTFS volumes to destabilize the entire system by exploiting this buffer overflow condition in the decompression logic.
This issue is categorized under CWE-120 Buffer Copy without Checking Size of Input, as the code performs a copy operation that exceeds the allocated destination buffer size due to insufficient input validation regarding cluster sizes. From an ATT&CK perspective, this vulnerability aligns with techniques related to privilege escalation and defense evasion through exploitation of software vulnerabilities, specifically targeting kernel-level components to achieve system compromise or disruption. The lack of proper boundary checks during attribute modification represents a classic logic error where security controls are applied inconsistently across different code paths within the same subsystem.
To mitigate this risk, the Linux kernel developers have implemented a fix that explicitly rejects attempts to change file attributes to include compression on volumes with cluster sizes larger than 4096 bytes. This validation is now performed consistently in both the inode loading path and the attribute modification handler, ensuring that no invalid configuration can be applied at runtime. System administrators should ensure their kernels are updated to versions containing this patch. Additionally, users formatting NTFS partitions for use within Linux environments should adhere to standard cluster sizes or verify compatibility with kernel limitations before enabling compression features. Regular security audits of filesystem drivers and adherence to strict input validation practices in kernel development remain essential to preventing similar logic flaws that could lead to memory corruption vulnerabilities.