Skip to main content
VulnerabilityPublished Updated

CVE-2026-43472: Linux kernel · unshare: fix unshare_fs() handling

Affects Linux kernelSource CVE Database V5

0
Compare

Not known to be exploited · fixed in d7963d6997fea86a6def242ac36198b86655f912 : update Linux kernel when convenient.

Data as of 6 Nov 2026, 15:49 UTC

Severity
Unrated

Rated by Threat Radar · No CVSS score from NVD or the CNA

Thin evidence

One scorer or none
CISA SSVC
Exploitation
No evidence of active exploitation and no public proof of concept
Automatable
Attackers cannot reliably automate steps 1–4 of the kill chain
Technical impact
Limited control over the software or limited information exposure

CISA SSVC assessment, 2026-11-06.

Patch
Available – fixed in d7963d6997fea86a6def242ac36198b86655f912, d3ffc8f13034af895531a02c30b1fe3a34b46432, d0d99f60538ddb4a62ccaac2168d8f448965f083 +5

Exploitation evidence

  1. Disclosed: evidence found.

    CVE published 8 May 2026

  2. Detectable: no evidence on record.

    No public nuclei template indexed

  3. Weaponized: no evidence on record.

    No public exploit code indexed in Metasploit or Exploit-DB

  4. Exploited in the wild: no evidence on record.

    Not in CISA KEV and no source reports exploitation

  5. Observed by OffSeq Mirage: no evidence on record.

    No attack traffic recorded by OffSeq Mirage sensors

A missing step is not evidence of safety. Sources: cve.org (opens in a new tab), the Metasploit, Exploit-DB and nuclei-templates index as of 6 Nov 2026.

What to do

Upgrade to a fixed release listed under Affected software.

Affected software

ProductAffectedFixed in
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < d7963d6997fea86a6def242ac36198b86655f912
Fixed in
  • d7963d6997fea86a6def242ac36198b86655f912
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < d3ffc8f13034af895531a02c30b1fe3a34b46432
Fixed in
  • d3ffc8f13034af895531a02c30b1fe3a34b46432
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < d0d99f60538ddb4a62ccaac2168d8f448965f083
Fixed in
  • d0d99f60538ddb4a62ccaac2168d8f448965f083
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < af8f4be3b68ac8caa41c8e5ead0eeaf5e85e42d0
Fixed in
  • af8f4be3b68ac8caa41c8e5ead0eeaf5e85e42d0
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < aa9ebc084505fb26dd90f4d7a249045aad152043
Fixed in
  • aa9ebc084505fb26dd90f4d7a249045aad152043
LinuxLinuxAffected
  • ≥ 741a295130606143edbf9fc740f633dbc1e6225f, < 845bf3c6963a52096d0d3866e4a92db77a0c03d8
Fixed in
  • 845bf3c6963a52096d0d3866e4a92db77a0c03d8

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) ;-/

References

Community reviews

Loading reviews…