Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local low-privilege access
-
DeliveryMonitor target directory for FIFO creation
-
ExploitWin TOCTOU race: unlink FIFO and create symlink to privileged file
-
ExecutionChmod follows symlink, exposing target file
-
PersistModify exposed file for privilege escalation
-
ImpactExecute arbitrary code as root
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture TOCTOU prevention
|
| Exploitation Conditions | Exploitation requires mkfifo utility executed with elevated privileges (root or SUID context) on filesystem paths where the attacker has write access to the parent directory. Attacker must possess low-privilege local user account (PR:L) and ability to monitor filesystem events or repeatedly attempt race condition timing. Target directory must allow the attacker to perform unlink and symlink operations between FIFO creation and chmod execution - typically /tmp, /var/tmp, or user-writable shared directories. High attack complexity (AC:H) stems from TOCTOU race timing: attacker must detect FIFO creation and perform symlink swap within microseconds-to-milliseconds window before chmod executes. Exploitation limited to systems using uutils coreutils implementation rather than GNU coreutils. No user interaction required (UI:N). Most impactful when automated privileged processes invoke mkfifo on predictable paths in attacker-writable locations; minimal impact when users run mkfifo only within their own private directories with their own privilege level. |
| Impact | Real-world risk is moderate to high depending on deployment context. CVSS 7.0 (AV:L/AC:H/PR:L) indicates local-only exploitation with high attack complexity due to race condition timing requirements. SSVC assessment confirms proof-of-concept availability and total technical impact (privilege escalation to full system control), but marks exploitation as not automatable due to timing dependencies. The attack requires: (1) local user access with write permissions to the directory where mkfifo is invoked, (2) ability to win a race condition, and (3) the utility running with elevated privileges for meaningful impact. Risk is elevated in scenarios where system scripts or privileged processes invoke mkfifo on user-writable paths (temp directories, user home directories). Conversely, risk is minimal if mkfifo is only used by unprivileged users in their own contexts. Not listed in CISA KEV, suggesting no widespread active exploitation. The high attack complexity (AC:H) and requirement for precise timing make this difficult to exploit reliably in practice, though proof-of-concept existence lowers the barrier. Primary risk is to systems using uutils coreutils in privileged automation rather than individual user contexts. |
| Exploit ScenarioDerived | A local attacker with low-privilege shell access identifies an automated system maintenance script running as root that uses uutils mkfifo to create a FIFO in /tmp for inter-process communication. The attacker writes a monitoring program that watches /tmp for new FIFO creation using inotify. When the script creates /tmp/process.fifo, the attacker's program immediately unlinks it and creates a symbolic link at /tmp/process.fifo pointing to /etc/shadow. The script's subsequent chmod 0666 /tmp/process.fifo follows the symlink, making /etc/shadow world-writable. The attacker then modifies /etc/shadow to add a passwordless root account or crack existing password hashes offline, achieving full system compromise. Success depends on winning the race between FIFO creation and chmod execution, typically requiring multiple attempts or system load conditions that widen the timing window. Proof-of-concept code exists per SSVC data, lowering technical barriers for skilled attackers. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 23, 2026
Privilege escalation in uutils coreutils mkfifo utility allows local attackers with low privileges to manipulate file permissions on arbitrary system files. A TOCTOU race condition between FIFO creation and permission setting enables symlink swapping attacks, redirecting chmod operations to unintended targets. SSVC framework indicates proof-of-concept exists with total technical impact. While CVSS rates this 7.0 (High), exploitation requires high attack complexity (race condition timing), low privileges, and write access to the parent directory where mkfifo is executed - most impactful when the utility runs with elevated privileges in automated scripts or system processes. No active exploitation confirmed (not in CISA KEV); EPSS data not available.
RemediationAI
Upstream fix available through GitHub issue tracking (https://github.com/uutils/coreutils/issues/10020), but released patched version number not independently confirmed from available data - monitor the GitHub repository for tagged release incorporating the fix. Once released, upgrade uutils coreutils to the patched version immediately if deployed in privileged contexts. Interim compensating controls: (1) Avoid running mkfifo with elevated privileges in automated scripts; if necessary, use unprivileged processes and employ capability-based security to limit damage scope. (2) Ensure mkfifo operations occur only in directories with restricted write permissions (not world-writable or user-writable temp directories); use private temporary directories with mode 0700 owned by the executing process. (3) If feasible, switch to GNU coreutils mkfifo implementation which may use file descriptor-based chmod (fchmod) avoiding the TOCTOU condition, though verify your distribution's implementation. (4) Implement filesystem monitoring (inotify/fanotify) to detect rapid unlink/create sequences in critical directories where mkfifo executes, though this adds performance overhead. Note that restricting directory permissions is the most practical mitigation but may break existing workflows where users legitimately need to create FIFOs in shared spaces.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
This vulnerability affects the mkfifo utility in uutils coreutils, a cross-platform Rust reimplementation of GNU coreutils. The flaw is a classic Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367), where a non-atomic sequence of file operations creates an exploitable window. The vulnerable code path performs: (1) FIFO creation at a specified path, then (2) a separate path-based chmod syscall to set permissions. Between these operations, the filesystem entry can be replaced. When an attacker with write access to the parent directory detects the FIFO creation, they can atomically unlink it and create a symbolic link with the same name pointing to a privileged file (e.g., /etc/passwd, /etc/shadow, or SUID binaries). The subsequent chmod then follows the symlink, inadvertently modifying permissions on the attacker-controlled target. This is particularly dangerous in environments where mkfifo runs as root or within privileged automation contexts.
Know when Coreutils gets its next vulnerability
- 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:H/PR:L/UI:N/S:U/C:H/I:H/A:H
Primary rating from Vendor (canonical) · only source for this CVE.
CVSS VectorVendor: canonical
DescriptionCVE.org
A Time-of-Check to Time-of-Use (TOCTOU) race condition exists in the mkfifo utility of uutils coreutils. The utility creates a FIFO and then performs a path-based chmod to set permissions. A local attacker with write access to the parent directory can swap the newly created FIFO for a symbolic link between these two operations. This redirects the chmod call to an arbitrary file, potentially enabling privilege escalation if the utility is run with elevated privileges.
Executive ViewAI
CVE-2026-35352 is a privilege escalation vulnerability in uutils coreutils mkfifo that allows local attackers to manipulate file permissions on arbitrary system files through a race condition exploit. Organizations using uutils coreutils in automated scripts or system processes risk unauthorized permission changes to critical files, potentially compromising system integrity and access controls. The threat is elevated in environments where mkfifo runs with elevated privileges or in shared multi-user systems.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Remove write permissions on parent directories where mkfifo executes where operationally feasible; (2) Restrict mkfifo to non-root execution contexts and eliminate elevated privilege runs; (3) Replace uutils coreutils with GNU coreutils if compatible with deployment; (4) Audit and remove unnecessary mkfifo invocations from automated processes and scripts; (5) Monitor file permission changes on critical system files via HIDS or filesystem auditing.
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
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
Affected Products (CPE)CVE.org
The parse_datetime function in GNU coreutils allows remote attackers to cause a denial of service (crash) or possibly ex
Recursive chmod operations can bypass --preserve-root protection in uutils coreutils versions prior to 0.6.0, allowing l
Local privilege escalation in uutils coreutils mkfifo allows authenticated users to downgrade permissions on arbitrary f
The ln utility in uutils coreutils fails to process source paths containing non-UTF-8 filename bytes when using target-d
The chmod utility in uutils coreutils versions prior to 0.6.0 incorrectly reports success (exit code 0) when recursively
The mknod utility in uutils coreutils creates device nodes before atomically applying SELinux security labels, and fails
The printenv utility in uutils coreutils versions before 0.6.0 silently omits environment variables containing invalid U
Privilege escalation to root in uutils coreutils chroot utility allows low-privileged local attackers with write access
Bypass of --preserve-root protection in uutils coreutils rm utility allows local users to recursively delete the root fi
Local privilege escalation in uutils coreutils before 0.10.0: the `install` utility applies a requested setuid/setgid mo
Logic error in uutils coreutils cut utility causes incorrect behavior when combining the -s (only-delimited), -z (null-t
The id utility in uutils coreutils displays incorrect effective user information in its pretty-print output when real an
EUVD-2026-24986
GHSA-9gh9-hwpr-rvqq
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB