CVE-2026-99574 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
f2fs: bound the SIT/NAT bitmaps by the checkpoint pack
sit_ver_bitmap_bytesize and nat_ver_bitmap_bytesize are used as memcpy lengths into and out of sbi->ckpt, which is sized from cp_payload alone, and nothing compares either length against that allocation.
sanity_check_ckpt() has checked these two fields since c77ec61ca0a4, which added them after a crafted image overran build_sit_info(). That check ties each length to a segment count; it never compares either against the allocation, which is the half this adds.
Mounting over-reads in build_sit_info() and build_node_manager(), and the first checkpoint writes the same lengths back through the same pointers, so the over-read's contents reach the on-disk checkpoint. An unmount is enough; the filesystem does not have to be used.
Bound both ends the way __bitmap_ptr() lays them out. The three branches differ, so a single sum of the two lengths would still admit a small overflow when cp_payload is non-zero.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel's F2FS file system contains a critical memory safety vulnerability related to improper bounds checking during checkpoint operations. This flaw specifically affects the handling of Segment Information Table and Node Address Table bitmaps, which are essential components for maintaining filesystem consistency and metadata integrity. The core issue arises from a mismatch between the lengths specified in these bitmap structures and the actual allocated size of the superblock's checkpoint payload area. Specifically, the variables sit_ver_bitmap_bytesize and nat_ver_version_bitmap_bytesize dictate the number of bytes to be copied into or out of sbi->ckpt via memcpy operations. However, prior to this fix, there was no validation ensuring that these lengths did not exceed the size of cp_payload, which determines the allocation boundary for the checkpoint structure. This oversight allows an attacker with access to a crafted F2FS image file to trigger buffer over-reads during the mounting process.
The technical mechanism of exploitation involves the build_sit_info and build_node_manager functions within the kernel source code. When a maliciously constructed filesystem image is mounted, these functions attempt to copy data using lengths derived from untrusted on-disk metadata without verifying against the allocated memory size. This results in reading beyond the bounds of the sbi->ckpt buffer into adjacent kernel memory spaces. The consequences are severe because this operation occurs during the initial mount phase, meaning no subsequent filesystem usage is required for exploitation. Furthermore, the vulnerability has a persistent impact on disk integrity; the first checkpoint write operation copies these same unchecked lengths back through the affected pointers, effectively writing the contents of the over-read buffer to the physical storage medium. This means that an unmount event alone can propagate corrupted data or potentially leak sensitive kernel memory information onto the disk, creating a vector for further attacks or system instability upon subsequent mounts.
From a classification perspective, this vulnerability aligns with CWE-125, Out-of-bounds Read, as it involves accessing memory locations beyond the intended buffer boundary. Additionally, because the flaw allows an attacker to read arbitrary kernel memory contents through a crafted filesystem image, it relates to CWE-200, Exposure of Sensitive Information to an Unauthorized Actor. In terms of attack vectors and tactics, this scenario is consistent with ATT&CK technique T1557, Adversary-in-the-Middle, if the over-read data includes cryptographic keys or session tokens found in adjacent memory, though more broadly it represents a local privilege escalation path via information disclosure that could lead to further exploitation. The vulnerability highlights the critical importance of validating all metadata-driven buffer sizes against actual allocations before performing memory copy operations, especially when dealing with untrusted external inputs like filesystem images from removable media or network shares.
Mitigation for this issue requires applying the kernel patch that bounds both ends of the bitmap handling logic in accordance with how __bitmap_ptr lays them out. The fix ensures that sit_ver_bitmap_bytesize and nat_version_bitmap_bytesize are strictly compared against the available cp_payload size before any memcpy operation is executed. It is important to note that a simple sum check of the two lengths would still admit small overflows when cp_payload is non-zero, so individual bounds checking for each bitmap type is necessary. System administrators should update their Linux kernels to versions where this patch has been integrated. For environments running older kernel versions that cannot be immediately updated, restricting access to untrusted filesystem images and disabling auto-mounting of removable media can reduce the attack surface. Regular auditing of mounted filesystems and monitoring for unusual memory allocation patterns may also help in detecting potential exploitation attempts before significant damage occurs.