Skip to main content

Linux Kernel CVE-2026-98993

| EUVDEUVD-2026-108787 HIGH
2026-10-23 Linux GHSA-53w5-4v27-r5f4
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 shell with mount capability
  2. Delivery
    Bind-mount nsfs/pidfs file and hold it open
  3. Exploit
    Lazy-unmount then re-copy via /proc/self/fd
  4. Execution
    Clone inherits stale MNT_UMOUNT flag
  5. Persist
    Trigger use-after-free on freed mnt_namespace
  6. Impact
    Corrupt kernel mount state for escalation/DoS

Vulnerability Assessment

Exploitation Conditions

Requires local code execution plus the ability to create mounts and mount namespaces (CAP_SYS_ADMIN), which unprivileged users can obtain on systems where unprivileged user namespaces are enabled. The concrete trigger is stated in the sources: bind-mount an nsfs or pidfs pseudo-file (e.g. /proc/self/ns/net), hold it open on a file descriptor, lazily unmount it (umount -l), then re-bind it through /proc/self/fd/N - may_copy_tree() accepts the nsfs/pidfs source before checking whether it is still mounted, so the copy carries MNT_UMOUNT. Limiting factors: no network vector (AV:L) and no user interaction, but exploitation is gated on mount privileges - on hosts where unprivileged user namespaces are disabled, a genuine CAP_SYS_ADMIN context is needed, substantially reducing real-world reach.

Impact

Signals point to a real but non-urgent, locally-scoped kernel memory-safety bug rather than a widespread remote threat. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N, C:H/I:H/A:H, 7.8 HIGH) is consistent with the description: this is a local, low-privilege use-after-free in the mount-namespace code, not a network-reachable issue. EPSS is low at 0.21% (10th percentile) and the CVE is NOT on CISA KEV (status: no), so there is no evidence of active exploitation; exploitation status is 'no public exploit identified at time of analysis' - the only references are the kernel.org stable fix commits and the NVD entry, with no PoC or exploit reference supplied. The vendor priority label is 'this_week', which is consistent with a patchable local-privilege/memory-corruption kernel flaw that should be rolled into normal fast patch cycles but is not an emergency. No SSVC decision fields (automatable, technical impact, exploitation) were supplied, so that framework cannot be applied. One contradiction to note: the input Tags label this 'Information Disclosure', but the CVSS impact is C:H/I:H/A:H and the description is a use-after-free / namespace-confusion bug that corrupts freed kernel objects - the impact profile is broader than pure information disclosure, so the tag likely understates the technical impact. CWE is N/A in the input; the UAF/confusion classification is inferred from the description text, not vendor-assigned.

Exploit ScenarioDerived

A local user who can create mount namespaces bind-mounts an nsfs/pidfs pseudo-file (e.g. /proc/self/ns/net), holds it open on a file descriptor, lazily unmounts it, then re-binds it via /proc/self/fd/N; the resulting mount is attached to the namespace with MNT_UMOUNT already set and every clone inherits it, corrupting kernel mount bookkeeping and leaving a dangling pointer to a freed struct mnt_namespace that is later read. No public exploit code is identified at time of analysis. Exploitation is local-only with low complexity, but requires mount privileges (CAP_SYS_ADMIN), which unprivileged users can obtain where unprivileged user namespaces are enabled.

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

The Linux kernel's mount-namespace code copies the internal MNT_UMOUNT flag when clone_mnt() duplicates a mount, so a lazily unmounted mount that is still pinned by a file descriptor on an nsfs or pidfs node can be re-bound into a namespace already carrying that stale flag. Because MNT_UMOUNT is never cleared and is treated by propagation, detach and locked-mount logic as proof that a mount is already going away, holders of mount privileges can corrupt mount-tree bookkeeping, strand a mount in a namespace with one reference too few and make it its own parent, and later read a freed struct mnt_namespace through may_change_propagation()/anon_ns_root() - a use-after-free that can escalate to kernel code execution in the local privilege-escalation sense. Exploitation is local and requires the ability to create mounts and mount namespaces (CAP_SYS_ADMIN, obtainable by unprivileged users where unprivileged user namespaces are enabled), with no user interaction; the vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8). A vendor patch is available (fixed in the 6.6.160, 6.12.114, 6.18.57, 7.2.11 and 7.3 branches per the EUVD data), EPSS is low at 0.21% (10th percentile), there is no CISA KEV listing and no public exploit identified at time of analysis.

RemediationAI

Apply the vendor-released kernel patch: the fixes are in the 6.6.160, 6.12.114, 6.18.57, 7.2.11 and 7.3 branches, with the upstream stable commits at https://git.kernel.org/stable/c/99698cfa34e493fc091219056aae446fe9442a96, https://git.kernel.org/stable/c/c26c1a91ad2881a194f7af543e0b57f0870006b2, https://git.kernel.org/stable/c/eecc9cd0fc07dba3f7fb0b2f844b4029435a2f7b, https://git.kernel.org/stable/c/5077b52e9e4d72da53c50251296b99cd416765a1 and https://git.kernel.org/stable/c/e2c6d326216642011da318b9edfd5d57ebd5a56f, and consult https://nvd.nist.gov/vuln/detail/CVE-2026-98993 for the current record; because this is a mainline kernel fix, wait for or install the equivalent backport from your distribution's kernel package rather than assuming a version string alone is patched. Until then the effective compensating control is to deny the mount privileges the trigger needs: disable unprivileged user namespaces (kernel.unprivileged_userns_clone=0 on Debian-derived kernels, or user.max_user_namespaces=0) so that non-root users cannot obtain CAP_SYS_ADMIN in a new namespace - this breaks unprivileged container runtimes, browser and application sandboxes, and rootless build tools, so scope it to multi-tenant or high-value hosts; alternatively restrict CAP_SYS_ADMIN to a small set of trusted binaries via capabilities or seccomp profiles, accepting that any process legitimately allowed to bind-mount /proc/self/ns/* retains the ability to trigger the bug. Note that the vulnerable sequence requires a file descriptor kept open across a lazy unmount followed by a re-bind through /proc/self/fd/N, so auditing for that pattern provides detection value but is not a preventive fix; updating the kernel is the complete remediation.

Affected VersionsENISA

Linux 590ce4bcbfb4e0462a720a4ad901e84416080bba <5077b52e9e4d72da53c50251296b99cd416765a1
Linux 590ce4bcbfb4e0462a720a4ad901e84416080bba <99698cfa34e493fc091219056aae446fe9442a96
Linux patch: 6.18.57
Linux 7052e71b2d085f76800115d4a212dcaf82b86262
Linux patch: 0
Linux patch: 7.2.11
Linux patch: 7.3
Linux patch: 6.12.114
Linux patch: 6.6.160
Linux 590ce4bcbfb4e0462a720a4ad901e84416080bba <e2c6d326216642011da318b9edfd5d57ebd5a56f
Linux 590ce4bcbfb4e0462a720a4ad901e84416080bba <c26c1a91ad2881a194f7af543e0b57f0870006b2
Linux 4.0.2 <4.1
Linux 590ce4bcbfb4e0462a720a4ad901e84416080bba <eecc9cd0fc07dba3f7fb0b2f844b4029435a2f7b
Linux 4.1

Affected Packages

euvd linux fix: 4.1

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 lives in the VFS mount-namespace machinery (fs/namespace.c and fs/pnode.c). MNT_UMOUNT is an internal flag raised by umount_tree()/umount_one() on a mount that has been taken out of its namespace and is never cleared; __detach_mounts() uses it to unhook rather than unmount a mount, disconnect_mount() uses it to decide whether an unmounted child may stay attached to its parent, and propagate_umount() treats it as the signal that a mount is about to be unmounted when computing peer-group and locked-mount cutoffs. clone_mnt() copies the source mount's flags but masks only MNT_INTERNAL_FLAGS, which does not include MNT_UMOUNT, and may_copy_tree() accepts nsfs/pidfs roots before it checks whether the source is actually mounted. The documented trigger is: bind-mount /proc/self/ns/net to /tmp/x, hold it open (exec 3</tmp/x), lazily unmount it (umount -l /tmp/x), then bind-mount /proc/self/fd/3 to /tmp/y - the new mount enters the caller's namespace with MNT_UMOUNT already set, and every clone of it inherits the flag. The consequences described are: a mount unlinked from a namespace it does not belong to, left with one reference too few and as its own parent, leaked at namespace teardown while still pointing at a freed struct mnt_namespace that may_change_propagation() and anon_ns_root() dereference on the next propagation change or mount_setattr() via the file descriptor; peer-group corruption where a propagated umount strips the flag from peers; and gather_candidates() marking a mount T_UMOUNT_CANDIDATE without ever enqueueing it, so the mark is never cleared, handle_locked() commits a locked child that should have stayed mounted, disconnect_mount() leaves that child attached to an unmounted parent, and umount_tree()/reparent() revisit or loop on the corrupted chain. The root-cause class is improper state-flag inheritance across a copy operation leading to reference-count and lifetime errors (use-after-free), and the fix adds MNT_UMOUNT to MNT_INTERNAL_FLAGS and warns when umount_tree() reaches a mount that already has it set.

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 attacker needing mount privileges obtainable via unprivileged user namespaces (PR:L, AV:L); deterministic reproducer gives AC:L; UAF on freed mnt_namespace yields full C/I/A impact within the kernel (S:U).

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: don't inherit MNT_UMOUNT in clone_mnt()

MNT_UMOUNT gets raised on a mount that umount_tree() or umount_one() has taken out of its namespace. It's never cleared. __detach_mounts() unhooks a mount that carries it instead of unmounting it.

disconnect_mount() lets an unmounted child stay attached only if its parent carries it. propagate_umount() takes it as the sign that a mount is going to be unmounted when it decides what else can be unmounted, where a chain of locked mounts ends and where a for reparenting an overmount.

clone_mnt() copies the flags of the source and only masks MNT_INTERNAL_FLAGS which doesn't include MNT_UMOUNT. A mount that was lazily unmounted but is kept alive by a file descriptor can still be copied when its root is an nsfs or pidfs file because may_copy_tree() accepts those before checking whether the source is mounted at all:

mount --bind /proc/self/ns/net /tmp/x exec 3< /tmp/x umount -l /tmp/x mount --bind /proc/self/fd/3 /tmp/y

The mount on /tmp/y is attached to the caller's namespace with MNT_UMOUNT already set and every copy of it inherits the flag again.

That causes a number of bugs:

  • Unlink its mountpoint from a mount namespace where it isn't one.

__detach_mounts() takes it for a mount that was unmounted earlier, unhooks it from its parent and drops the reference the namespace holds on it. It stays in the namespace with one reference too few and as its own parent, so it can't be unmounted through the file descriptor anymore and the namespace never finds it again. When the namespace goes away it's leaked and points to a freed struct mnt_namespace that may_change_propagation() and anon_ns_root() read on the next propagation change or mount_setattr() through the file descriptor.

  • Make it shared and unmount a peer. trace_transfers() follows the

flag from the peer into it and strips it from its peer group.

  • Let a propagated umount reach it. gather_candidates() marks it with

T_UMOUNT_CANDIDATE but never puts it on the candidate list, so the mark is never cleared and every later propagated umount skips it. If it's the parent of a locked mount handle_locked() takes it as the cutoff and commits the locked child that should have stayed and disconnect_mount() leaves that child attached to it, unmounted under a mounted parent, which is what disconnect_mount() exists to prevent. When the namespace goes away umount_tree() visits the child a second time. And once __detach_mounts() has made it its own parent reparent() never finds the end of the chain of unmounted parents.

A clone is a new mount that has never been unmounted. Add MNT_UMOUNT to MNT_INTERNAL_FLAGS so clone_mnt() never copies it. And warn when umount_tree() reaches a mount that already has it set.

Executive ViewAI

Why It Matters

CVE-2026-98993 is a high-severity Linux kernel vulnerability affecting systems that permit unprivileged user namespaces, enabling local users to escalate privileges to kernel-level code execution. This puts any organization relying on such configurations at risk of full system compromise by an insider or compromised account, undermining the integrity of critical workloads and data.

Business Impact: High
Compensating Controls

Apply vendor patch. If patching is delayed, disable unprivileged user namespaces (sysctl kernel.unprivileged_userns_clone=0 and user.max_user_namespaces=0) where feasible. Additionally, restrict CAP_SYS_ADMIN to trusted processes and monitor for suspicious mount-namespace activity.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
Ubiquitous
Linux kernel, present in essentially every Linux deployment
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