Skip to main content

Linux Kernel CVE-2026-98982

| EUVDEUVD-2026-108776 HIGH
2026-10-23 Linux GHSA-2rh7-4ph4-xmm5
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Gain local low-priv shell with bpffs access
  2. Delivery
    Create bpf token and place it on caller's bpffs mount
  3. Exploit
    Bind-mount /proc/self/fd/token and clone the mount
  4. Execution
    Race RCU path walk against final mntput/dput
  5. Impact
    Trigger kernel use-after-free and escalate

Vulnerability Assessment

Exploitation Conditions

Requires LOCAL access and the ability to reach bpf_token_create() and place the token file on a bpffs mount that resides in the caller's own mount namespace - unlike other alloc_file_pseudo() callers whose files sit on kernel-internal mounts that may_copy_tree() refuses to clone. The attacker must then bind-mount /proc/self/fd/<token> and clone it (OPEN_TREE_CLONE + move_mount) so the DCACHE_NORCU dentry becomes a mount root. Limiting factors: no remote vector (local only); it depends on a configuration where a bpffs mount with BPF token delegation is usable by the attacker (not a default general-purpose setup); and successful exploitation hinges on winning the race in __follow_mount_rcu between the lockless walk and the final dput, which narrows the practical window. The complete fix is the kernel patch, which refuses to clone a mount whose root dentry is DCACHE_NORCU.

Impact

This is a Linux kernel use-after-free in mount/namespace handling (a pseudo dentry carrying DCACHE_NORCU becoming the root of a cloned mount via a bpf token bind-mount). The supplied CVSS is 7.8 with vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, i.e. local, low-privilege, full CIA impact. Counter-signals are strongly deflationary: EPSS is only 0.21% (11th percentile), the CVE is not listed in CISA KEV, and no public exploit or PoC reference is present in the input - only upstream stable git commits (the fix). The vuln.today priority is 'this_week' (not act_now/emergency), consistent with a locally-exploitable memory-corruption bug that is patched but not under active exploitation. One internal tension: the input vector states AC:L, but the description explicitly frames the bug as a race between the RCU path walk (__follow_mount_rcu reading d_seq/d_flags) and the final dput()/free, which is the kind of narrow timing window that normally argues for AC:H - treat the 'low complexity' label with caution. Bottom line: a genuine local privilege-escalation/memory-corruption risk worth patching promptly, but the real-world priority is bounded by local access plus an unusual precondition (a usable bpffs mount and bpf token creation in the caller's namespace), so it is not a mass-exploitation threat.

Exploit ScenarioDerived

A local, low-privileged user with access to a bpffs mount in its own mount namespace creates a BPF token file, then bind-mounts /proc/self/fd/<token> and clones that mount (open_tree with OPEN_TREE_CLONE + move_mount) so the DCACHE_NORCU pseudo dentry becomes a mount root. The attacker then races a lockless RCU path walk against the final mntput/dput so a walker dereferences the dentry after it has been freed, yielding kernel use-after-free and potential privilege escalation. No public exploit identified at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 24, 2026

A use-after-free in Linux kernel mount and namespace handling can be reached when a BPF token file - created via bpf_token_create() and placed on a bpffs mount inside the caller's own mount namespace - is bind-mounted through /proc/self/fd/<token> and then cloned with open_tree(OPEN_TREE_CLONE) plus move_mount(). This turns a d_alloc_pseudo() dentry that carries DCACHE_NORCU into the root of a mount, and because such dentries are freed immediately by dentry_free(), the lockless path walk in __follow_mount_rcu() can read ->mnt_root, d_seq and d_flags of a dentry that has already been released. A local attacker who can reach bpf_token_create() with a delegated bpffs mount can therefore trigger a use-after-free that corrupts kernel memory, giving a path to confidentiality, integrity and availability impact; the assessed vector is AV:L/AC:H/PR:L/UI:N (a local, low-privileged attacker), reflecting that bpf token delegation and a suitable bpffs mount are not a default general-purpose configuration and that the flaw requires winning a race in __follow_mount_rcu against the final dput(). No public exploit code has been confirmed and the issue is not in CISA KEV; EPSS is 0.21% (11th percentile) and the vendor has released fixes.

RemediationAI

Vendor-released patch: update to Linux 6.12.113, 6.18.57, 7.2.11 or 7.3 as listed in the EUVD affected-version data, or cherry-pick the stable fixes a256e31e0c54c4c37d2523aa52faabdcdd2ebc07, 7e1c466011ba9e64d43075396badc03191bcee44, b138e16fb1e81376cea89f727dda7bfccd140de4 or 00287afa7cd989efdbf5822b7efac33cce7d489a from https://git.kernel.org/stable/c/a256e31e0c54c4c37d2523aa52faabdcdd2ebc07 into any kernel between the vulnerable base and those releases. Because the patch makes clone_mount refuse a mount whose root dentry is DCACHE_NORCU, no feature toggle in the fixed code is needed; on kernels that cannot be updated immediately, the exposure is limited by removing the preconditions rather than by generic hardening: do not grant BPF token delegation to unprivileged or untrusted workloads and do not expose bpffs mounts that carry token files into mount namespaces those workloads control, accepting that this removes BPF token functionality (and any tooling relying on delegated tokens) for those callers; also restrict the ability of untrusted users to perform bind mounts and open_tree/move_mount operations in their own namespaces, which similarly depends on the deployment and likewise reduces legitimate container or sandbox flexibility. Kernels with BPF token support disabled entirely are not reachable through this path. The vendor advisories to track are https://nvd.nist.gov/vuln/detail/CVE-2026-98982 and EUVD-2026-108776.

Affected VersionsENISA

Linux patch: 6.12.113
Linux 6.9
Linux 35f96de04127d332a5c5e8a155d31f452f88c76d <a256e31e0c54c4c37d2523aa52faabdcdd2ebc07
Linux 35f96de04127d332a5c5e8a155d31f452f88c76d <7e1c466011ba9e64d43075396badc03191bcee44
Linux patch: 7.3
Linux patch: 0
Linux patch: 6.18.57
Linux 35f96de04127d332a5c5e8a155d31f452f88c76d <b138e16fb1e81376cea89f727dda7bfccd140de4
Linux patch: 7.2.11
Linux 35f96de04127d332a5c5e8a155d31f452f88c76d <00287afa7cd989efdbf5822b7efac33cce7d489a

Affected Packages

euvd linux no fix

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

The bug lives in the VFS mount/dentry layer rather than in BPF itself. d_alloc_pseudo() produces dentries for pipes, sockets and similar anonymous files that are never anyone's child or parent; they are marked DCACHE_NORCU and dentry_free() releases them immediately because no lockless path walk is expected ever to reach them. That invariant breaks if such a dentry becomes the root of a mount. Most alloc_file_pseudo() callers place their files on kernel-internal mounts which may_copy_tree() refuses to clone, but bpf_token_create() puts the token file on the bpffs mount supplied by the caller, and that mount sits in the caller's mount namespace, so the clone succeeds via mount --bind /proc/self/fd/<token> <file> followed by open_tree(tokfd, "", AT_EMPTY_PATH | OPEN_TREE_CLONE) and move_mount(). Once the pseudo dentry is a mount root, __follow_mount_rcu() loads ->mnt_root and reads d_seq and d_flags before it checks mount_lock, so the dentry can already be gone; the final mntput() of an unmounted parent detaches a child under mount_lock alone, and if the child's holder performs the final put right afterwards the root is dput() and freed while a walker that found the mount still hashed dereferences it. The upstream fix simply refuses to clone a mount whose root dentry is DCACHE_NORCU, on the reasoning that there is no sensible use for a bind mount of a BPF token.

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

Vendor (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

Local only (AV:L); the changelog describes a free/walk race so AC:H; requires a low-priv caller able to create a bpf token on its bpffs mount (PR:L); kernel UAF gives full C/I/A.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Oct 24, 2026 - 14:22 NVD
7.8 (HIGH)
Patch available
Oct 23, 2026 - 13:17 EUVD
CVE Published
Oct 23, 2026 - 12:19 cve.org
HIGH 7.8
CVE Published
Oct 23, 2026 - 12:19 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

namespace: don't let a pseudo dentry become the root of a mount

d_alloc_pseudo() hands out dentries for pipes, sockets and other files that are never anyone's child or parent. They carry DCACHE_NORCU and dentry_free() frees them right away because no lockless path walk can ever reach them. That holds as long as such a dentry isn't the root of a mount. But bind mounting /proc/self/fd/<fd> of such a file does exactly that.

Most callers of alloc_file_pseudo() put their files on kernel-internal mounts and may_copy_tree() refuses those. bpf_token_create() doesn't. It places the token file on the bpffs mount the caller handed it and that mount is in the caller's mount namespace so the clone goes through:

mount --bind /proc/self/fd/<token> <file> open_tree(tokfd, "", AT_EMPTY_PATH | OPEN_TREE_CLONE) + move_mount()

__follow_mount_rcu() then loads ->mnt_root of that mount, reads d_seq and d_flags of the dentry and only then checks mount_lock. The dentry can be gone by then. The final mntput() of an unmounted parent unhooks a child that stayed attached to it under mount_lock alone. When the child's holder does the final put right after that the root is dput() and freed immediately while a walker that found the mount hashed still looks at it.

Refuse to clone a mount with a DCACHE_NORCU dentry as its root. Nothing sensible can be done with a bind mount of a bpf token anyway.

Executive ViewAI

Why It Matters

A high-severity vulnerability in the Linux kernel allows a local, low-privileged user to corrupt kernel memory, potentially leading to full system compromise. This requires a specific configuration involving BPF token delegation and a private mount namespace, but once exploited, could impact confidentiality, integrity, and availability of affected systems. Leadership should prioritize patching because insider threats or compromised accounts could escalate privileges and disrupt critical services.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Ubiquitous
Linux kernel; runs across the vast majority of server and device environments
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy