CVE-2026-99476 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

fsverity: Set S_VERITY only after rollback is no longer possible

Commit f77f281b6118 ("fsverity: use a hashtable to find the fsverity_info") changed the implementation of FS_IOC_ENABLE_VERITY to make concurrent reads start going through fsverity verification slightly earlier than they did before.

Instead of it happening when enable_verity() calls fsverity_set_info(), it now happens when ->end_enable_verity() sets S_VERITY.

However, ext4 and btrfs can roll back verity after they set S_VERITY, causing a use-after-free.

Fix that by making ext4 and btrfs set S_VERITY only after rollback is no longer possible. On failure, don't roll back S_VERITY, but do roll back the filesystem-specific verity flag.

Also update enable_verity() to handle any future instances of this bug more safely by warning and *not* freeing the fsverity_info.

Finally, tweak some comments. Clarify one, and move information from another to its proper place in the comment for ->end_enable_verity().

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel vulnerability identified involves a critical race condition within the filesystem verification subsystem, specifically affecting ext4 and btrfs implementations of fsverity. The root cause stems from an optimization introduced in commit f77f281b6118, which aimed to improve performance by allowing concurrent reads to begin verifying file integrity earlier in the enablement process. Previously, this verification logic was triggered when the internal function fsverity_set_info() executed. However, the updated implementation shifted the activation point of the S_VERITY inode flag to occur during the ->end_enable_verity() callback phase. This change inadvertently created a window where the filesystem-specific verity state could be marked as active via the generic kernel flag before all underlying data structures were fully committed and immutable.

The technical flaw arises because both ext4 and btrfs retain the ability to roll back their internal verity configuration even after S_VERITY has been set on the inode. When a rollback occurs in this specific window, the filesystem attempts to clean up resources associated with the now-active verity state. However, since the generic kernel layer believes verification is already enabled based on the presence of the S_VERITY flag, it may proceed to access or free memory structures that are concurrently being dismantled by the rolling-back filesystem driver. This sequence results in a use-after-free condition, where pointers to freed memory are dereferenced during subsequent read operations or cleanup routines. Such memory corruption can lead to kernel panics, denial of service, or potentially arbitrary code execution if an attacker can manipulate the timing and state transitions involved in enabling verity on sensitive files.

From a security architecture perspective, this vulnerability aligns with CWE-416: Use After Free, as it involves accessing memory after it has been freed due to improper lifecycle management of kernel objects. In terms of adversarial tactics, while not directly an exploitation vector for remote code execution without additional conditions, the underlying mechanism resembles aspects of ATT&CK technique T1059: Command and Scripting Interpreter if leveraged in conjunction with other vulnerabilities to gain initial access, or more accurately reflects internal state manipulation issues often seen in privilege escalation paths. The core issue is a failure in atomicity guarantees during feature enablement, where the global system state (S_VERITY) was synchronized before local filesystem consistency was guaranteed.

The operational impact of this vulnerability includes potential instability for systems relying on fsverity for integrity verification, particularly those using ext4 or btrfs file systems with files undergoing verity enablement under concurrent load. An attacker who can trigger rapid creation and modification of files while enabling verity might induce the race condition, causing kernel crashes that disrupt service availability. Furthermore, if the use-after-free allows memory corruption to persist without immediate crash, it could theoretically be exploited to bypass integrity checks or escalate privileges by corrupting adjacent kernel structures.

To mitigate this risk, the fix involves restructuring the order of operations in ext4 and btrfs drivers so that S_VERITY is set only after all rollback possibilities have been eliminated. This ensures that once the generic kernel layer marks verity as active, no subsequent filesystem-specific cleanup can invalidate or free associated resources prematurely. Additionally, the enable_verity() function was updated to handle potential future instances of this bug more safely by issuing warnings and refraining from freeing fsverity_info if an error state is detected during the finalization phase. This defensive programming approach prevents memory leaks or corruption even in edge cases where rollback logic might be triggered unexpectedly. Administrators should apply kernel updates that include these patches immediately to restore the integrity guarantees provided by filesystem verity features.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00156

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!