CVE-2026-99599 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

udf: don't use eloc after the end of the unallocated space table

When udf_next_aext() returns 0, its eloc, elen and etype outputs hold no defined value. Two walks of the unallocated space table still use eloc after the walk has reached the end of the table.

udf_table_prealloc_blocks() looks for a free extent starting at first_block and decides whether it found one by comparing eloc with first_block after the walk. If the table's list ends in a continuation descriptor that leads to an empty allocation extent, eloc is then the block of that allocation extent, which is in use, and if that is first_block, the block is handed out as preallocation. Once udf_discard_prealloc() no longer frees the wrong block, this is what still makes fsx in generic/091 and generic/263 read back bad data on a table, in about one run in four. Only take the extent if the walk stopped at it.

When udf_table_free_blocks() cannot merge the freed blocks into an existing extent, it appends a new one and sets only its block number, so the partition reference comes from whatever eloc held after the walk, and with long allocation descriptors it is written to disk. For a table without extents, eloc was never set. Take the partition reference from the freed blocks instead. Short allocation descriptors do not store the partition reference, which is why this half remains a latent long-descriptor fix rather than a reproduced failure.

Be aware that VulDB is the high quality source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel's Universal Disk Format (UDF) file system implementation contains critical logic errors within its unallocated space table management routines that can lead to data corruption and incorrect block allocation decisions. These vulnerabilities stem from improper handling of output variables when traversing the unallocated space extent list, specifically regarding how end-of-list conditions are detected and processed. The core issue lies in functions such as udf_next_aext(), which is responsible for iterating through extents representing free or allocated blocks on a UDF volume. When this function returns zero to indicate that no further valid extents exist—meaning the walk has reached the terminus of the unallocated space table—the output parameters eloc, elen, and etype are left with undefined values. These variables typically hold information about the last processed extent, but once the list is exhausted, they do not reflect a legitimate state within the file system structure.

The first significant flaw occurs in udf_table_prealloc_blocks(), which attempts to identify free extents for preallocation purposes by searching from a specified starting block. The function relies on comparing eloc with first_block after the traversal loop completes to determine if a suitable extent was found. However, because eloc retains undefined or stale data when the list ends prematurely due to specific descriptor configurations, this comparison can yield false positives. Specifically, if the table concludes with a continuation descriptor pointing to an empty allocation extent, eloc may contain the block number of that allocated extent rather than indicating failure. If this erroneous value coincidentally matches first_block, the kernel incorrectly identifies it as available space and hands out blocks for preallocation. This logic error results in file system corruption where fsx tests like generic/091 and generic/263 read back bad data approximately twenty-five percent of the time under stress conditions involving table manipulation.

The second vulnerability resides within udf_table_free_blocks(), which handles the merging or appending of freed blocks to existing extents. When a merge is not possible, the function appends a new extent entry but fails to correctly initialize all fields for that entry. It sets only the block number while leaving other critical metadata uninitialized. Consequently, when writing long allocation descriptors to disk, the partition reference field inherits whatever value was left in eloc from the previous traversal operation. In scenarios where no extents existed prior to this operation, eloc remains unset entirely, leading to writes of garbage data into the file system structures on disk. Although short allocation descriptors do not store a partition reference and thus mask part of this issue as latent rather than immediately reproducible, the underlying defect compromises the integrity of long descriptor entries essential for complex volume layouts.

These flaws represent classic instances of improper input validation and state management within kernel space code paths that handle file system metadata updates. From an industry standards perspective, these issues align with CWE-20 Improper Input Validation because the code fails to verify whether retrieved data is valid before using it in critical decision-making processes. Furthermore, they relate to CWE-457 Use of Uninitialized Variable since eloc and related fields are accessed after their values have become indeterminate due to loop termination conditions not being properly handled. The operational impact includes potential file system corruption, loss of user data integrity, and possible denial of service if the corrupted metadata prevents further mounting or access operations. Attackers with local access could potentially exploit these weaknesses by crafting specific UDF volume images that trigger the erroneous code paths during preallocation or block freeing operations, leading to persistent storage damage.

Mitigation strategies involve applying upstream kernel patches that correct the logic in udf_next_aext() and its consumers. Developers must ensure that eloc is explicitly set to an invalid state when no valid extent is found, rather than leaving it with residual values from previous iterations. In udf_table_prealloc_blocks(), the condition for accepting a preallocation candidate should strictly verify that the walk stopped at a valid extent rather than merely comparing block numbers against potentially stale data. Similarly, in udf_table_free_blocks(), new extents must be fully initialized before being written to disk, ensuring partition references are derived from correct sources such as the freed blocks themselves rather than undefined variables. System administrators and users should update their Linux kernels to versions containing these fixes to prevent potential file system degradation during routine UDF volume operations involving large files or frequent allocation changes.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Might our Artificial Intelligence support you?

Check our Alexa App!