Skip to main content

Linux Kernel CVE-2026-98995

| EUVDEUVD-2026-108789 HIGH
2026-10-23 Linux GHSA-h4q9-qcg7-rj48
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 unprivileged shell
  2. Delivery
    Obtain mount capability (e.g. user namespace)
  3. Exploit
    Build overmount + hold fd on unmounted mount
  4. Execution
    Trigger reparent() leaving dangling ->overmount
  5. Persist
    do_lock_mount() dereferences freed mount (UAF)
  6. Impact
    Corrupt kernel memory for privilege escalation

Vulnerability Assessment

Exploitation Conditions

Exploitation requires local access and the ability to perform mount operations - specifically the capability to create/move mounts and use the 'mount beneath'/overmount feature so that propagate_umount() and reparent() relocate a surviving overmount, combined with an open file descriptor that keeps the original unmounted mount alive to create the dangling ->overmount pointer. This typically means CAP_SYS_ADMIN in some (possibly unprivileged) user namespace where mounting is allowed. Limiting factors: no remote vector (AV:L), a privilege/mount-capability prerequisite (PR:L - not reachable by a completely unprivileged user on systems where unprivileged user namespaces or mounting are disabled), and the vulnerable code path exists only in kernels carrying the overmount/reparent logic (affected around 6.17, fixed in 6.18.57 and 7.2.11 per EUVD). Systems that disable unprivileged user namespaces materially reduce exposure.

Impact

This is a use-after-free in the Linux kernel mount namespace code (mnt_change_mountpoint() failing to reset a stale parent ->overmount pointer), and the signals are internally consistent but point to moderate, not urgent, real-world risk. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) correctly frames this as a local, low-complexity flaw requiring some privilege (an unprivileged local user able to perform mount operations) with full confidentiality, integrity and availability impact - the expected profile for a kernel UAF that can corrupt memory and enable local privilege escalation. The EPSS score is very low (0.21%, 10th percentile), and there is no CISA KEV listing and no public exploit reference (the only references are the three stable-tree fix commits), so there is no evidence of active exploitation or available weaponized code. The vuln.today Decision label is 'this_week', which is a moderate-priority patching cadence consistent with a locally-exploitable, non-public-exploit kernel memory-corruption bug rather than an act_now/emergency item. Note one tagging discrepancy: the input Tags label this 'Information Disclosure', but the CVSS C:H/I:H/A:H impact and the described dangling-pointer/UAF mechanism indicate memory corruption and likely local privilege escalation, which is broader than pure information disclosure - treat the 'Information Disclosure' tag as an undercharacterization, not a confirmed impact ceiling. Overall this is a legitimate issue to patch in the normal cycle but not a drop-everything emergency, given local-only access, a privilege prerequisite, low EPSS, and no observed exploitation.

Exploit ScenarioDerived

A local unprivileged user with the ability to perform mount operations (for example via a user namespace where mounting is permitted) sets up a mount configuration that forces propagate_umount()/reparent() to move a surviving overmount while holding a file descriptor that keeps the original, now-unmounted, mount alive. The stale ->overmount pointer then references freed memory, and a subsequent do_lock_mount()/topmost_overmount() walk dereferences and takes references on the freed mount, yielding a use-after-free that a skilled attacker could shape into local privilege escalation. No public exploit code is identified at time of analysis; only the kernel fix commits are referenced.

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 exists in the Linux kernel mount-namespace code path that relocates mounts, where mnt_change_mountpoint() fails to reset the old parent's ->overmount pointer the way __umount_mnt() does. A local attacker who can perform mount operations - including the 'mount beneath'/overmount feature - and who holds an open file descriptor keeping an unmounted mount alive can leave ->overmount pointing at a moved mount that is subsequently unmounted and freed; do_lock_mount() then walks that dangling pointer and takes references into freed memory, giving high confidentiality, integrity and availability impact to a local user with mount capability. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8), EPSS is 0.21% (10th percentile) and there is no KEV entry and no public exploit identified at time of analysis; the vulnerable overmount/reparent logic is present in kernels around 6.17, with fixes in 6.18.57 and 7.2.11.

RemediationAI

Update to a kernel carrying the upstream fix: Linux 6.18.57 or later on the 6.18 branch, Linux 7.2.11 or later on the 7.2 branch, or Linux 7.3, applying the stable commits referenced at https://git.kernel.org/stable/c/5e0a1f2c753a79749bc2ead3ae2f2ede3941daa5, https://git.kernel.org/stable/c/476ef286a7a5db8bda51325dc0c45887b4d99d9a and https://git.kernel.org/stable/c/08d575ee89393fd812dbdca7b5d7b4574cd5a564, or obtain the vendor's updated kernel package per its advisory (patch availability is reported as 'Available from vendor'). Because exploitation requires the ability to create and move mounts and to use mount-beneath, exposure is materially reduced on systems where unprivileged user namespaces are disabled (kernel.unprivileged_userns_clone=0 or the equivalent restriction) or where mount capability is not granted to untrusted users; note that this trades away container and sandbox functionality that relies on unprivileged user namespaces, and it does not protect users who already hold CAP_SYS_ADMIN in a namespace.

Affected VersionsENISA

Linux patch: 0
Linux ffdc52fbbd5835a936ad683c943d6d103a2d4514 <5e0a1f2c753a79749bc2ead3ae2f2ede3941daa5
Linux 6.17
Linux patch: 7.3
Linux ffdc52fbbd5835a936ad683c943d6d103a2d4514 <476ef286a7a5db8bda51325dc0c45887b4d99d9a
Linux patch: 6.18.57
Linux patch: 7.2.11
Linux ffdc52fbbd5835a936ad683c943d6d103a2d4514 <08d575ee89393fd812dbdca7b5d7b4574cd5a564

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 flaw is in the Linux kernel VFS mount-namespace implementation. A mount's ->overmount field records the mount stacked on top of it, and __umount_mnt() clears the parent's ->overmount when the overmounting mount is unmounted; mnt_change_mountpoint() moves a mount to a new parent without performing that same reset, leaving the old parent pointing at the moved mount. During attach_recursive_mnt() this is harmless because the new mount has already reset the old parent's ->overmount before the old top mount is moved onto it, but it matters for reparent(): propagate_umount() moves a surviving overmount onto the first ancestor that is not going to be unmounted, and the mount it was taken from is unmounted immediately afterwards. If a file descriptor keeps that unmounted mount alive, ->overmount points at the moved mount, which is itself unmounted and freed - a dangling pointer and use-after-free. do_lock_mount() follows ->overmount from the target path under mount_lock, so using a file descriptor on such a mount as the target of a mount beneath makes topmost_overmount() walk into freed memory and do_lock_mount() take references on whatever it finds there. The root-cause class is CWE-416 (use-after-free); the input did not supply a CWE mapping, and the exact trigger sequence requires the mount-beneath capability described above.

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.8 HIGH

Local-only kernel UAF reachable by a user with mount capability (AV:L, PR:L), deterministic trigger (AC:L), and memory corruption enabling full local compromise (C:H/I:H/A:H).

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/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:20 cve.org
HIGH 7.8
CVE Published
Oct 23, 2026 - 12:20 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

namespace: reset the old parent's ->overmount in mnt_change_mountpoint()

__umount_mnt() resets ->overmount of the parent when it unmounts the mount that overmounts it. mnt_change_mountpoint() doesn't. It moves the mount to its new parent and leaves the old one pointing at it.

For a mount that is moved beneath in attach_recursive_mnt() that doesn't matter. The new mount has already reset ->overmount of the old parent by the time the old top mount is moved onto it.

It matters for reparent() though. propagate_umount() moves a surviving overmount onto the first ancestor that isn't going to be unmounted. The mount it was taken from is unmounted immediately afterwards. If a file descriptor keeps that unmounted mount alive ->overmount points at the moved mount. That's a dangling pointer and UAF as the moved mount is unmounted and freed.

do_lock_mount() follows ->overmount from the target path under mount_lock. With a file descriptor on such a mount as the target of a mount beneath topmost_overmount() walks into the freed mount and do_lock_mount() takes references on whatever it finds there.

So reset ->overmount of the old parent in mnt_change_mountpoint() the same way __umount_mnt() does. A mount's ->overmount is then always a mount that is attached to it.

Executive ViewAI

Why It Matters

A high-severity use-after-free flaw in Linux kernel mount-namespace handling (CVE-2026-98995) can allow a local user with mount privileges to corrupt kernel memory, potentially leading to full loss of confidentiality, integrity, and availability on affected hosts. Leadership should care because any server, container host, or workstation running approximately kernel 6.17 with users or processes capable of mount operations is exposed, and successful abuse could let a local actor escalate to kernel-level compromise of that system.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
Ubiquitous
Linux kernel core code, though vulnerable overmount path only in recent 6.17+ branches
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