CVE-2026-99601 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

udf: check the unallocated space table when it is loaded

udf_table_new_block() hands out the first block of the extent closest to its goal and trusts that the extent covers at least one whole block inside the partition. Nothing checks that. A zero-length extent makes it return the block the extent points at, which need not be free, and the subtraction of one block then underflows the length into the type bits, turning the entry into a bogus continuation. An extent running past the end of the partition makes it return blocks behind the partition.

Such tables are not only found on crafted images: until the previous commit, udf_table_new_block() itself left zero-length extents behind in tables written by mkudffs, and then converted them into extents running past the partition.

Check every extent once when the table is loaded, and refuse read-write access if one is empty, is not a whole number of blocks, or does not lie inside the partition, in the same way as for other allocation information the kernel cannot use. Check first that the table is an Unallocated Space Entry at all: the walk starts at the offset of the allocation descriptors in one, and for a file entry that offset lies before the inode's in-memory copy of the descriptors. Treat a chain of allocation extent descriptors that leads back to itself the same way: the walk would otherwise return the same extents forever, and the mount would never finish. Let a fatal signal interrupt the walk and fail the mount.

Refusing read-write access to an empty extent is deliberate. It shows that an old kernel took the last block but left the entry behind. If consumed again, the entry returns an in-use block and turns into a huge bogus extent. Refusing the table before that happens avoids this second allocation; the filesystem can still be mounted read-only. The check cannot detect every overlap that may already exist in a damaged table.

This patch should be backported together with the previous one: that patch stops creating new empty extents, and this one rejects existing ones before they are consumed again.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/21/2026

The Linux kernel's Universal Disk Format (UDF) filesystem implementation contained a critical logic flaw within the block allocation mechanism, specifically in the udf_table_new_block function. This vulnerability arises from an insufficient validation of extent descriptors during table loading and subsequent block assignment operations. The core technical failure lies in the assumption that every extent referenced by the Unallocated Space Table covers at least one complete block within the partition boundaries. When this assumption is violated due to malformed or corrupted data structures, the kernel proceeds with unsafe arithmetic operations that lead to memory corruption and potential denial of service conditions. Specifically, if an extent has a length of zero, the function returns the starting block address without verifying its availability. Subsequent logic subtracts one from the remaining length field; because this value is unsigned, it causes an integer underflow, wrapping around to a maximum positive value in the type bits. This transforms the entry into a bogus continuation descriptor that misrepresents the filesystem layout. Similarly, if an extent extends beyond the physical end of the partition, the function may return block addresses located outside valid storage regions, leading to out-of-bounds memory access or writes to incorrect disk sectors.

The operational impact of this vulnerability is severe, affecting both system stability and data integrity. An attacker who can craft a malicious UDF image containing these malformed extents can trigger integer underflows that corrupt kernel memory structures associated with filesystem metadata management. This corruption can lead to unpredictable behavior during file operations, including crashes, panics, or potential privilege escalation if the corrupted pointers are dereferenced in sensitive contexts. Furthermore, the vulnerability allows for denial of service by causing mount processes to hang indefinitely. If a chain of allocation extent descriptors forms a circular reference that leads back to itself, the traversal logic enters an infinite loop. Without proper interruption mechanisms, this results in a kernel deadlock where the filesystem cannot be mounted or accessed, effectively rendering storage media unusable until unmounted forcibly. The issue is not limited to externally crafted images; historical bugs within mkudffs and previous versions of udf_table_new_block could leave zero-length extents behind during normal operation, which then convert into out-of-bounds extents upon subsequent mounts, creating a persistent risk for systems using older kernel versions or improperly formatted media.

From a security standards perspective, this vulnerability maps directly to CWE-190 Integer Overflow or Wraparound and CWE-20 Improper Input Validation. The underflow resulting from subtracting one from an unsigned zero-length field is a classic integer wrap-around issue that compromises data integrity. Additionally, the failure to verify extent boundaries against partition limits constitutes improper input validation of filesystem metadata structures. In terms of attack vectors, this aligns with ATT&CK technique T1496 Resource Hijacking via Denial of Service, as maliciously crafted media can be used to exhaust system resources or halt operations through infinite loops and kernel panics. The vulnerability also touches upon CWE-787 Out-of-bounds Write if the returned block addresses are used for writing data outside allocated regions, potentially overwriting critical filesystem structures or adjacent memory buffers depending on how the blocks are utilized by higher-level drivers.

Mitigation strategies require both immediate patching and long-term defensive coding practices. The primary remediation is to apply the kernel update that introduces rigorous validation checks during table loading. This includes verifying that every extent in the Unallocated Space Table has a non-zero length, consists of a whole number of blocks, and lies entirely within the partition boundaries. If any such invalidity is detected, the filesystem should be mounted with read-only access to prevent further corruption while allowing data recovery operations. It is crucial to implement checks for circular references in extent descriptor chains to prevent infinite loops during traversal; this can be achieved by tracking visited nodes or limiting iteration depth and ensuring that fatal signals like SIGKILL can interrupt long-running mount processes. Developers should also ensure that all allocation tables are validated against physical partition limits before any block assignment occurs, rejecting entries that do not conform to expected structural constraints. Backporting both the fix for preventing new empty extents and the validation logic for existing ones is essential to fully mitigate this risk across supported kernel versions.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00209

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!