Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local shell with mount capability
-
DeliveryBind-mount nsfs/pidfs file and hold it open
-
ExploitLazy-unmount then re-copy via /proc/self/fd
-
ExecutionClone inherits stale MNT_UMOUNT flag
-
PersistTrigger use-after-free on freed mnt_namespace
-
ImpactCorrupt 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
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).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.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
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.
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
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-108787
GHSA-53w5-4v27-r5f4
NVD
CVE.org
EPSS
Exploit-DB