Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local access
-
DeliverySupply crafted/corrupt XFS image for mount
-
ExploitTrigger iunlink bucket log recovery
-
Executioninodegc flush fails, inode freed
-
PersistDereference dangling prev_ip (use-after-free)
-
ImpactCorrupt kernel memory / crash or escalate
Vulnerability Assessment
| Exploitation Conditions | Requires local access and the mounting/log-recovery of an XFS filesystem whose log contains unlinked-inode buckets. The use-after-free manifests specifically when the inodegc flush call inside the recovery loop fails, after which prev_ip is left pointing at released memory; the related cursor/pointer bugs also create self-referential (looping) unlinked lists. Limiting factors: the vector is purely local (AV:L) with no remote path, user interaction is required (UI:R) to mount/recover a crafted or corrupt XFS image, and only systems running XFS on affected kernels (6.0 up to the fixed 6.12.113 / 6.18.55 / 7.2.9 / 7.3-rc5 releases) are exposed. The exact conditions under which the inodegc flush fails are not detailed in the available sources, which limits how reliably an attacker can force the UAF versus a benign crash. |
| Impact | This is a local, non-remote memory-safety defect (use-after-free plus unlinked-list corruption) in the XFS log-recovery path of the Linux kernel. The vendor CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 7.8) describes high confidentiality, integrity and availability impact but an attack that is LOCAL and requires user interaction - not network-exploitable. The multi-source signals are consistent and point to a real-but-not-urgent issue: EPSS is only 0.17% (6th percentile), the CVE is NOT on CISA KEV, and the only references are the upstream fix commits on git.kernel.org - there is no public exploit identified and no SSVC/automatable evidence of mass exploitation. The vuln.today decision label is 'this_week', i.e. patch promptly but not an emergency. One tension worth flagging: CVSS sets PR:N (unauthenticated), yet the real trigger is processing/mounting an XFS filesystem and running log recovery, which in most deployments requires some privilege or automount of attacker-supplied media - the CVSS vector likely reflects automount/removable-media scenarios rather than true zero-privilege access, so treat PR:N with caution. The CWE is unspecified in the input, but the commit message confirms this is a use-after-free (CWE-416 class). |
| Exploit ScenarioDerived | A local attacker who can cause an XFS filesystem with a crafted or corrupt log to be mounted and recovered (for example via removable media/automount) triggers recovery of the unlinked-inode buckets; if the inodegc flush inside the recovery loop fails, a dangling pointer (prev_ip not nulled) is dereferenced, producing a use-after-free in kernel context that can corrupt kernel memory, crash the system, or potentially be leveraged toward privilege escalation. No public exploit code was identified - the only references are the upstream fix commits. Exploitation is local and requires user interaction (mount/recovery), consistent with AV:L/UI:R. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
A memory-safety defect in the Linux kernel's XFS log-recovery routine (xlog_recover_iunlink_bucket) can leave a released inode pointer (prev_ip) dangling and can construct self-referential unlinked-inode lists, producing use-after-free and list-corruption conditions. Only systems running XFS on affected kernels - 6.0 through the fixed versions 6.12.113, 6.18.55, 7.2.9 and 7.3-rc5 - are exposed, and exploitation requires local access plus the mounting or log recovery of an XFS filesystem whose journal contains unlinked-inode buckets. The use-after-free specifically manifests when the inodegc flush call inside the recovery loop fails; the conditions under which that flush fails are not detailed in the available sources, so triggering reliably is difficult, no public exploit has been identified, EPSS is 0.17% (6th percentile) and the issue is not in CISA KEV.
RemediationAI
Vendor-released patches address this in the stable trees at 6.12.113, 6.18.55, 7.2.9 and 7.3-rc5; upgrade to or beyond the fixed release for your branch, or apply the upstream stable commits 8c9d5b8a96d6b93eb24e07b4163c89341ba29bd1, 66a2179d02668f8df44b1a249899006f3ba38ea0, 961c717e6bf0e53c2c2b1fe4aef1add9390fedab or 65f39d09d73718611cee40399179323b5d4ead00 as appropriate (also referenced: https://git.kernel.org/stable/c/47a948ba653a463d429e02fda2f06a3d6b78666d) and consult https://nvd.nist.gov/vuln/detail/CVE-2026-98443. Patch availability is listed as vendor-provided, and this is a this_week priority rather than an act_now/emergency item; because the trigger requires local access plus mounting or log-recovering an XFS filesystem with unlinked-inode buckets, restricting the ability to mount untrusted or attacker-supplied XFS images to privileged, trusted operators limits exposure until the kernel is updated. The sources do not state any further workaround, and no public exploit code has been identified.
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
XFS is a high-performance journaling filesystem used widely on Linux servers and workstations. When replaying its journal, XFS reconstructs the on-disk unlinked-inode bucket lists via xlog_recover_iunlink_bucket, which walks linked inodes with prev_ip/prev_agino cursor state and periodically flushes each inode through inodegc. Four related defects were corrected: prev_ip was not nulled after being released, so a failing inodegc flush in the loop could leave a dangling pointer to freed memory (use-after-free); a failed flush also leaked the current inode reference; prev_agino was assigned after agino had already advanced, so inodes could end up with i_prev_unlinked pointing at themselves; and exiting the bottom of the loop with prev_ip set aliases prev_ip and ip, again producing a self-referential unlinked list. The latter two issues introduce loops into the unlinked list, which are latent because each unlinked inode is flushed immediately after loading. The root cause class is cursor/state handling during error-path recovery (use-after-free and improper list linkage); the CVE record carries no CWE mapping. The trigger requires a corrupt or crafted XFS journal containing unlinked-inode buckets and, for the UAF, a failing inodegc flush - the sources do not describe how that failure is induced. The assessed vector (CVSS:3.1/AV:L/AC:H/PR:L/UI:R) reflects a local, higher-complexity attack with low privileges and required user interaction (mounting/recovering the image), rated C:H/I:H/A:H.
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:N/UI:R/S:U/C:H/I:H/A:H
Local XFS mount/recovery path (AV:L) needing mount privilege (PR:L) and user interaction (UI:R); triggering depends on an inodegc flush failure during recovery, so AC:H; kernel UAF yields full C/I/A impact.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
xfs: fix cursor and pointer handling when recovering iunlink buckets
LOLLM pointed out a bug in xlog_recover_iunlink_bucket:
- We don't null out prev_ip after releasing it, which can lead to UAF
problems if the inodegc flush call in the loop fails.
at which point I noticed even more bugs:
- If the inodegc flush inside the loop fails, we also leak @ip.
- We set prev_agino to agino having already advanced agino, which
results in inodes with i_prev_unlinked set to itself.
- If we exit the bottom of the loop with prev_ip set, then prev_ip
aliases ip and we also set its i_prev_unlinked to itself.
Bugs 3 and 4 introduce loops into the unlinked list, though these loops don't surface because we immediately flush each unlinked inode after loading it.
Fix all of these issues.
Executive ViewAI
A high-severity memory-safety flaw in the Linux kernel's XFS filesystem affects systems running affected kernel versions (6.0 through the fixed releases). Because exploitation requires local access and specific journal-recovery conditions that are difficult to trigger, the immediate organizational exposure is limited, but any XFS-based production infrastructure-including storage, database, and virtualization hosts-should still be prioritized for patching given the kernel privileges involved and the potential for system crashes or corruption.
Apply vendor patch.
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-103683
GHSA-27hr-pwp4-53ph
NVD
CVE.org
EPSS
Exploit-DB