CVE-2026-98980·Kernel vulnerability
In the Linux kernel, the following vulnerability has been resolved: namei: don't reveal overmounted entries in refwalk In rcuwalk the dentry is validated before it is accepted. step_into() step_into() rechecks d_seq and __follow_mount_rcu() rechecks mount_lock. An entry that gets unlinked in between causes the lookup to retry and miss. A refwalk doesn't do this. lookup_fast() takes a reference on the hashed dentry and simply accepts it. So an unlink that happens after the reference was taken isn't seen by refwalk. That's fine for a simple file. We just happened to open it before it was unlinked, no problem. For a mountpoint and specifically a locked mountpoint it very much isn't. The unlink detaches all mounts and then removes the name. Any refwalk that hasn't traversed the mounts yet simply reveals the underlying entry. It's a very narrow window but it can be hit: reads of a covered file in 60 s, 3 walkers, ~15000 unlinks no widening 27 that step + 200 us 3741 See the appended patch for a more reliable reproducer. So check the entry after step_into(). unlink(), rmdir() and rename() mark the dentry with dont_mount() before they detach the mounts and remove the dentry. So a dentry that is marked with DCACHE_CANT_MOUNT and is unhashed by the time its mounts were looked at is a name that was unlinked under the refwalk. DCACHE_CANT_MOUNT is read after the mounts were looked up and it is set before they are detached by detach_mounts(). A refwalk that missed the mounts will see DCACHE_CANT_MOUNT. Plain d_unlinked() is fine. A rename takes the dentry off its hash chain but ___d_drop() leaves d_hash.pprev set. So only __d_drop() and a rename over the dentry unhash it. The only move that flips IS_ROOT splices in a disconnected alias. That doesn't have DCACHE_CANT_MOUNT set. Add the to step_into_slowpath(). ".." and LOOKUP_DOWN may legitimately land on an unhashed directory. A refwalk that crossed onto a mount has path.mnt different from nd->path.mnt. A dentry that a filesystem dropped on its own (d_invalidate(), d_drop()) doesn't have the flag set and is treated as before. // SPDX-License-Identifier: GPL-2.0 /* * unlink_covered: unlink a file that is a mountpoint in a detached copy of * its mount, against walkers that open it through that copy. * * A is a tmpfs with the file f1 (content SECRET_F) and the plain file * MARK_A. A' is an open_tree(OPEN_TREE_CLONE) copy of A with MARK_A bound * on A'/f1, held through an O_PATH fd on its root once the tree fd is * closed. Walkers open f1 through that fd while the driver unlinks A/f1, * where nothing is mounted on it. A walker may read MARK_A or get ENOENT. * A read of SECRET_F is a hit: the name was found after its mount was * gone. The lockless walks use openat2(RESOLVE_CACHED). * * usage: unlink_covered [-t seconds] [-w walkers] */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include <errno.h> #include <fcntl.h> #include <pthread.h> #include <stdatomic.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/mount.h> #include <sys/stat.h> #include <sys/syscall.h> #include <linux/openat2.h> #ifndef __NR_open_tree #define __NR_open_tree 428 #endif #ifndef __NR_move_mount #define __NR_move_mount 429 #endif #ifndef __NR_openat2 #define __NR_openat2 437 #endif #ifndef OPEN_TREE_CLONE #define OPEN_TREE_CLONE 1 #endif #ifndef OPEN_TREE_CLOEXEC #define OPEN_TREE_CLOEXEC O_CLOEXEC #endif #ifndef MOVE_MOUNT_F_EMPTY_PATH #define MOVE_MOUNT_F_EMPTY_PATH 0x00000004 #endif #define WORK "/tmp/uc" #define ADIR WORK "/A" static int duration = 60, nwalkers = 3; static atomic_int stop, writer_waiting; static pthread_rwlock_t cur_lock = PTHREAD_RWLOCK_INITIALIZER; static int cur_fd = -1; /* the root of A', -1 while there is none */ static atomic_long n_unlink, n_walk, n_mark, n_enoent, n_othe ---truncated---
- Severity
- high
- Software
- Kernel
- Fixed in
- 6.12.113, 6.18.57, 7.2.11, 7.3
- Published
How likely is exploitation
FIRST's Exploit Prediction Scoring System puts the probability of this CVE being exploited in the next 30 days at 0.18% — higher than 7% of all published CVEs. EPSS is an independent forecast of exploitation, not a severity rating: it says nothing about how much damage a successful attack does, which is what a CVSS score measures.
Read the two together. CVE-2026-98980 scores 8.8 on CVSS, so a successful attack would be serious — but at 0.18%, almost nobody is currently attempting it. That is a different situation from a flaw under mass exploitation, and it is usually the difference between patching on your next maintenance window and patching tonight.
How to fix this CVE
Update your Linux kernel to a patched version to prevent unauthorized access to files that should be hidden by mount points. Apply the stable kernel update for your branch: 6.12.113, 6.18.57, 7.2.11, or mainline 7.3+. Most users should use their distribution's kernel package rather than compiling from source to ensure proper integration and support.
sudo dnf update kernel kernel-develDefensia detects this vulnerability
How to check if you are affected
- Step 1: Check your current kernel version with `uname -r` and compare against the fixed versions (6.12.113, 6.18.57, 7.2.11, 7.3+)
- Step 2: Verify if your kernel is vulnerable by checking if the version is older than the patched release in your stable branch
- Step 3: Search system logs for ENOENT or permission denied errors when accessing files that should be mount points with `grep -i 'permission denied\|enoent' /var/log/kern.log | head -20`
- Step 4: After patching, reboot the system and confirm the new kernel is active with `uname -r`, then verify the DCACHE_CANT_MOUNT flag behavior is enforced
FAQ
What is CVE-2026-98980?
This is a kernel vulnerability in the namei (name lookup) subsystem that allows unprivileged attackers to bypass mount point protections during reference walk operations. An attacker can race with file unlinking to reveal the underlying filesystem beneath a mount point, potentially exposing sensitive data.
Is CVE-2026-98980 being actively exploited?
No, CVE-2026-98980 is not listed in the CISA KEV catalog and no public exploits are known. However, it is a high-severity vulnerability (CVSS 8.8) that requires a narrow race condition to trigger.
What versions of Kernel are affected by CVE-2026-98980?
All kernel versions before the fix are potentially affected. Patched versions are: 6.12.113 and later (6.12 branch), 6.18.57 and later (6.18 branch), 7.2.11 and later (7.2 branch), and 7.3+ (mainline). Users should upgrade within their current stable branch rather than jumping to a new major version.
How do I check if my server is vulnerable to CVE-2026-98980?
Run `uname -r` to get your kernel version. If your version is older than 6.12.113, 6.18.57, 7.2.11, or 7.3 (depending on your branch), you are vulnerable.
Does Defensia detect CVE-2026-98980?
Yes — Defensia's CVE advisory scanner compares installed package versions against the NVD database. If the Linux kernel is installed on a monitored server, CVE-2026-98980 will appear in your dashboard with remediation steps and the specific patched version available for your branch.
Related Kernel CVEs
References
Track CVEs across your fleet automatically
Defensia scans your Linux servers and tells you exactly which ones are running vulnerable versions — including CVE-2026-98980. Free for 1 server.
Get started free