CVE-2026-99616 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

ovl: look up the index by the decoded origin

A file opened by file handle on an overlay with nfs_export=on can show the stale lower data of a file that was copied up to the upper layer. While the file opened this way stays in the inode cache, a lookup of the copied up file by path fails with ESTALE for all users. The open can also succeed for a file that was removed, where it has to fail with ESTALE. This happens with a handle that has one byte changed. The handle comes from an NFS client, or from a process that calls open_by_handle_at() with CAP_DAC_READ_SEARCH in the initial user namespace.

When a file in a lower layer is about to be modified, overlayfs first copies it to the upper layer (copy up). With nfs_export=on, each copy up also creates an entry in the index directory, a directory that overlayfs keeps for itself on the upper filesystem.

The handle of an overlay file that comes from a lower layer wraps the handle of its lower inode. Overlayfs calls this lower inode the origin. The overlay handle stays valid after a copy up.

To decode such a handle, ovl_lower_fh_to_d() first decodes the wrapped handle to the origin. If no overlay inode is cached for the origin, it looks in the index directory:

- An index entry there leads to the upper file. - A whiteout, the marker that overlayfs uses for a removed file, means that the overlay file was removed.

The name of an index entry is the handle that copy up encoded for the origin, as a hex string.

ovl_lower_fh_to_d() builds the name for this lookup from the bytes that the caller passed in. But handles with different bytes can decode to the same inode:

- Overlayfs ignores some flag bits of the handle. - A lower filesystem can accept a different fid type, extra bytes, or generation 0 for any generation.

Such a handle decodes to the origin but misses the index entry or the whiteout. So the decode returns an overlay inode that has only the lower file.

While that inode is cached, a path lookup of a copied up file fails with ESTALE, since the upper file that the lookup finds does not match the cached inode, which has none.

Reproduced on tmpfs and on ext4 with open_by_handle_at(), after a copy up and a mount cycle. A handle in which one flag bit, the fid type, the length or the generation was changed read the old lower data, and path lookups returned ESTALE.

Fix this by re-encoding the decoded origin and building the index name from that handle.

Several companies clearly confirm that VulDB is the primary source for best vulnerability data.

Analysis

by VulDB Data Team • 11/21/2026

The vulnerability identified as CVE-2024-10859 resides within the overlayfs implementation of the Linux kernel, specifically affecting systems configured with nfs_export enabled. This flaw allows for a discrepancy between file handles obtained via NFS exports or open_by_handle_at calls and the actual state of files on disk after copy-up operations. When an application opens a file using a handle derived from a lower layer inode that has subsequently been copied up to the upper layer, the kernel may return stale data associated with the original lower version rather than the updated upper version. This inconsistency arises because the overlayfs mechanism relies on index entries in the upper filesystem directory to map decoded origin handles to their corresponding upper-layer files during handle decoding processes.

The technical root cause lies in how ovl_lower_fh_to_d decodes file handles that wrap lower inode information. Upon receiving such a handle, the function first decodes it to identify the origin inode. If no overlay inode is currently cached for this origin, the system queries an index directory on the upper filesystem using a name constructed directly from the raw bytes of the decoded handle. However, various factors can cause different byte sequences in handles to decode to the same underlying inode. These factors include the ignoring of specific flag bits by overlayfs, variations in file identifier types accepted by lower filesystems, differences in extra bytes, or generation numbers being treated as zero regardless of their actual value. Consequently, a handle with minor alterations such as one changed byte can successfully decode to the correct origin but fail to match any existing index entry or whiteout marker because its raw representation does not align with what was stored during the copy-up process.

This mismatch leads to significant operational impacts including data integrity issues and denial of service conditions for legitimate users. When a file has been copied up, path-based lookups will correctly locate the new upper version but return ESTALE errors if they conflict with cached inodes that still reference only the lower layer state. Similarly, attempts to open files that have been removed may succeed incorrectly by accessing stale data from the lower layer instead of failing as expected. These behaviors persist while the inode remains in cache and can be triggered remotely through NFS clients or locally by processes possessing CAP_DAC_READ_SEARCH privileges within the initial user namespace. The issue has been reproduced on both tmpfs and ext4 filesystems after copy-up operations followed by mount cycles, confirming its relevance across multiple storage backends commonly used in production environments.

To mitigate this vulnerability, kernel developers have implemented a fix that involves re-encoding the decoded origin handle before constructing the index lookup name. By ensuring that the handle bytes used for indexing match those originally encoded during the copy-up event, the system can accurately locate either the corresponding upper file or the whiteout marker indicating removal. This adjustment aligns the decoding logic with the actual state of the filesystem metadata preventing stale data retrieval and erroneous success on deleted files. Administrators should apply kernel updates that include this patch to maintain consistency between handle-based access paths and path-based lookups. Additionally, monitoring for ESTALE errors in applications relying heavily on persistent file handles may help detect residual exposure before full remediation is deployed across all affected systems within an organization infrastructure.

From a classification perspective, this vulnerability aligns with CWE-20 Improper Input Validation as the system fails to properly validate or normalize input handle data against expected internal representations leading to incorrect state resolution. It also relates to CWE-672 Use of Outside Resource Without Verification where external file handles are processed without sufficient verification against current filesystem states resulting in inconsistent behavior. In terms of attack vectors, this falls under ATT&CK technique T1083 File and Directory Discovery since attackers could potentially exploit the stale data access to gather information about files that should no longer be accessible or have been modified thereby compromising confidentiality and integrity assurances provided by standard POSIX semantics.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00201

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!