CVE-2026-43472
Received Received - Intake
Linux Kernel Unshare Filesystem Handling Vulnerability

Publication date: 2026-05-08

Last updated on: 2026-05-08

Assigner: kernel.org

Description
In the Linux kernel, the following vulnerability has been resolved: unshare: fix unshare_fs() handling There's an unpleasant corner case in unshare(2), when we have a CLONE_NEWNS in flags and current->fs hadn't been shared at all; in that case copy_mnt_ns() gets passed current->fs instead of a private copy, which causes interesting warts in proof of correctness] > I guess if private means fs->users == 1, the condition could still be true. Unfortunately, it's worse than just a convoluted proof of correctness. Consider the case when we have CLONE_NEWCGROUP in addition to CLONE_NEWNS (and current->fs->users == 1). We pass current->fs to copy_mnt_ns(), all right. Suppose it succeeds and flips current->fs->{pwd,root} to corresponding locations in the new namespace. Now we proceed to copy_cgroup_ns(), which fails (e.g. with -ENOMEM). We call put_mnt_ns() on the namespace created by copy_mnt_ns(), it's destroyed and its mount tree is dissolved, but... current->fs->root and current->fs->pwd are both left pointing to now detached mounts. They are pinning those, so it's not a UAF, but it leaves the calling process with unshare(2) failing with -ENOMEM _and_ leaving it with pwd and root on detached isolated mounts. The last part is clearly a bug. There is other fun related to that mess (races with pivot_root(), including the one between pivot_root() and fork(), of all things), but this one is easy to isolate and fix - treat CLONE_NEWNS as "allocate a new fs_struct even if it hadn't been shared in the first place". Sure, we could go for something like "if both CLONE_NEWNS *and* one of the things that might end up failing after copy_mnt_ns() call in create_new_namespaces() are set, force allocation of new fs_struct", but let's keep it simple - the cost of copy_fs_struct() is trivial. Another benefit is that copy_mnt_ns() with CLONE_NEWNS *always* gets a freshly allocated fs_struct, yet to be attached to anything. That seriously simplifies the analysis... FWIW, that bug had been there since the introduction of unshare(2) ;-/
CVSS Scores
EPSS Scores
Probability:
Percentile:
Meta Information
Published
2026-05-08
Last Modified
2026-05-08
Generated
2026-05-09
AI Q&A
2026-05-08
EPSS Evaluated
N/A
NVD
CVE-2026-43472
EUVD
EUVD-2026-28778
Affected Vendors & Products
Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel *
Helpful Resources
Exploitability
CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN
Attack-Flow Graph
AI Powered Q&A
Can you explain this vulnerability to me?

This vulnerability exists in the Linux kernel's unshare(2) system call, specifically in the handling of the unshare_fs() function. When certain flags like CLONE_NEWNS and CLONE_NEWCGROUP are used together, and the current process's filesystem structure (fs) hasn't been shared, the kernel incorrectly passes the original fs structure instead of a private copy to copy_mnt_ns().

If copy_mnt_ns() succeeds but a subsequent call to copy_cgroup_ns() fails (for example, due to memory exhaustion), the kernel destroys the newly created mount namespace but leaves the process's current fs pointers (root and pwd) pointing to now detached mounts. This results in the unshare(2) call failing with an error (-ENOMEM) while leaving the process in an inconsistent state with references to invalid mount points.

The fix involves always allocating a new fs_struct when CLONE_NEWNS is used, even if the fs_struct wasn't previously shared, preventing the process from ending up with dangling pointers after failure.


How can this vulnerability impact me? :

This vulnerability can cause the unshare(2) system call to fail with an error while leaving the calling process in an inconsistent state where its current working directory (pwd) and root directory pointers reference detached and invalid mount points.

Although this does not lead to use-after-free (UAF) conditions, it can cause unexpected behavior or instability in processes relying on unshare(2), potentially leading to application errors or system misbehavior.


What immediate steps should I take to mitigate this vulnerability?

The vulnerability is related to the Linux kernel's unshare(2) system call handling, specifically with CLONE_NEWNS and CLONE_NEWCGROUP flags causing issues with mount namespaces and fs_struct allocation.

To mitigate this vulnerability, update your Linux kernel to a version where this issue has been fixed. The fix involves ensuring that a new fs_struct is allocated when CLONE_NEWNS is used, preventing the bug from occurring.


Ask Our AI Assistant
Need more information? Ask your question to get an AI reply (Powered by our expertise)
0/70
EPSS Chart