Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local unprivileged access
-
DeliveryOpen fsverity-enabled files across threads
-
ExploitRace rhashtable lookup against fsverity_info free
-
ExecutionDereference freed fsverity_info (UAF)
-
ImpactCorrupt kernel memory to escalate or crash
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires local access to a system where fsverity is in use, and specifically the ability to trigger concurrent __fsverity_get_info() lookups against DIFFERENT fsverity-enabled inodes - the UAF does not arise for a single inode (whose fsverity_info is only freed at eviction or on enable failure), only across the shared rhashtable where entries are followed under rcu_read_lock() without synchronizing against fsverity_remove_info(). Limiting factors: no remote vector (AV:L), the attacker must already have a local foothold, and because the flaw is a race the attacker must win a narrow timing window between the rhashtable lookup and the freeing of the struct - so reliable triggering is harder than the supplied AC:L implies. Filesystems/deployments that do not enable fsverity are not exposed. The complete fix is the upstream change that RCU-delays freeing of struct fsverity_info; update to a kernel containing the referenced fix commits. |
| Impact | This is a kernel use-after-free (functionally CWE-416, though the input lists CWE as N/A) in the fsverity subsystem, rated 7.8 (High) with vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. The exploitation signals are modest and internally consistent: EPSS is only 0.20% (9th percentile), there is no CISA KEV listing, and the only references are the two upstream fix commits on git.kernel.org plus an NVD pointer - so no public exploit identified at time of analysis. The vuln.today decision label is 'this_week', i.e. patch-management priority rather than emergency. The CVSS attack vector is Local (AV:L), which correctly contradicts any assumption of remote reach - an attacker needs an existing local foothold. One point of tension: the description explicitly frames the bug as a concurrency/RCU race ('concurrent __fsverity_get_info() for *different* inodes'), which argues for a higher attack complexity than the AC:L in the supplied vector; a race window makes reliable exploitation harder than AC:L suggests. Net: a real local privilege-escalation/DoS risk worth patching on a normal cadence, not a widely-exploited emergency. Confidentiality 'Information Disclosure' is the only tag, but the vector claims full C:H/I:H/A:H - the tag understates the impact. |
| Exploit ScenarioDerived | A local user with the ability to open files on an fsverity-enabled filesystem runs many threads that concurrently trigger fsverity_info lookups across different inodes. By racing a lookup against an inode eviction that frees a fsverity_info object before the RCU grace period, the attacker dereferences freed kernel memory, which can be groomed toward privilege escalation or a kernel crash. No public proof-of-concept is referenced, and winning the race reliably is non-trivial. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
A use-after-free in the Linux kernel's fsverity subsystem lets a local attacker who already holds low privileges on a fsverity-enabled system race concurrent __fsverity_get_info() lookups against different verity-protected inodes, potentially leading to memory corruption, information disclosure, or code execution in kernel context. Only kernels built and deployed with fsverity in active use are exposed, and because the flaw is a race the attacker must win a narrow timing window between the rhashtable lookup and the freeing of struct fsverity_info, which makes reliable triggering harder than a plain local-privilege-escalation bug. There is no CISA KEV listing and no confirmed public exploit code at time of analysis; EPSS is 0.20% (9th percentile), so mass exploitation is not expected, although the vendor-priority signal places remediation in the current week.
RemediationAI
Vendor-released patch: update to Linux 7.2.11 or 7.3, or to any kernel that contains fix commits e58c3805ed325fe2d4ae2dd467c0486cc860b733 / fa84f091a8e7fc46fd29834496fab9739dd4c8dc (referenced against base f77f281b61183a5c0b87e6a4d101c70bd32c1c79); the upstream commits are visible at https://git.kernel.org/stable/c/fa84f091a8e7fc46fd29834496fab9739dd4c8dc and https://git.kernel.org/stable/c/e58c3805ed325fe2d4ae2dd467c0486cc860b733, and the CVE record is at https://nvd.nist.gov/vuln/detail/CVE-2026-99051. Because the complete fix is the upstream RCU-delay change, the vendor guidance is that updating is the only complete remediation. Before patching, exposure can be reduced only by removing the prerequisite: this is a local race requiring a foothold on a host that actively uses fsverity, so restricting untrusted local users and reducing the number of concurrently active fsverity-protected inodes lowers the practical attack surface. Note that fsverity is generally built into the kernel (CONFIG_FS_VERITY), so it cannot simply be unloaded at runtime; disabling it is a build-time/configuration decision and would invalidate any integrity measurement or file-verification guarantees that depend on it. There is no KEV listing and no confirmed public exploit, but the vendor priority label calls for patching this week given the High severity (locally reachable memory corruption).
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
fsverity is the kernel's file-based integrity verification layer, and it tracks per-inode metadata in struct fsverity_info, keyed in an rhashtable by the inode. __fsverity_get_info() performs rhashtable_lookup_fast() under rcu_read_lock() only, and walks the bucket chain via fsverity_info::rhash_head while comparing keys using fsverity_info::inode. fsverity_remove_info() does not synchronize with those readers, so the struct can be freed while another CPU is still traversing the chain for a different inode. For a single inode the race is benign because the info is removed only at inode eviction or when verity enablement fails, after which that inode's info is no longer looked up; the dangerous case is cross-inode traversal of the shared table. The upstream fix addresses this by RCU-delaying the free of struct fsverity_info after removal from the rhashtable, so readers under rcu_read_lock() never observe reclaimed memory. The input lists the CWE as N/A, but the defect is functionally a use-after-free (CWE-416) in the kernel rhashtable/RCU concurrency pattern.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Local foothold needed (AV:L) and an unprivileged user suffices (PR:L); AC:H because the described RCU race requires winning a timing window; kernel UAF yields full C/I/A.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
3DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
fsverity: RCU-delay the freeing of struct fsverity_info
__fsverity_get_info() calls rhashtable_lookup_fast(), which just uses rcu_read_lock() and doesn't directly synchronize with fsverity_remove_info().
For the same inode this isn't a problem: its fsverity_info is removed only at inode eviction time or upon failure to enable verity, when the inode no longer needs its fsverity_info and it will no longer be accessed via that inode.
However, this is broken and can cause a use-after-free for concurrent __fsverity_get_info() for *different* inodes. Those rely on following fsverity_info::rhash_head in the rhashtable under rcu_read_lock() only. They also use fsverity_info::inode to do the key comparison.
Fix this by RCU-delaying the freeing of 'struct fsverity_info' after it's been removed from the rhashtable.
Executive ViewAI
CVE-2026-99051 is a high-severity memory-safety flaw in the Linux kernel's fsverity subsystem that affects only systems actively using fsverity. It requires an attacker to already hold low local privileges and win a narrow race condition, so exploitation is difficult and no public exploit has been identified; leadership should prioritize patching internet-facing and multi-tenant Linux hosts that use fsverity, as successful exploitation could grant kernel-level code execution.
No vendor-released patch identified at time of analysis; restrict local shell and interactive access to trusted users, disable fsverity on systems that do not require it, monitor for suspicious local privilege-escalation behavior, and apply kernel updates as soon as the vendor publishes them.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-108846
GHSA-7hq4-c7jg-2h9h
NVD
CVE.org
EPSS
Exploit-DB