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

fzf: Arbitrary command execution via bash arithmetic expansion on unvalidated layout size in fzf-tmux (-l/-u attached value)GHSA-w6x2-f5m4-xw82

HIGHFix: junegunn/fzf@f126ff2

GHSA-w6x2-f5m4-xw82 is a high-severity (CVSS 7) OS Command Injection vulnerability in github.com/junegunn/fzf. A fix is available for github.com/junegunn/fzf — see the affected versions and patch details below.

Also known asCVE-2026-121716
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

No confirmed exploitation observed yet

  • A successful exploit gives an attacker total control of the affected component, not partial access.
  • CISA’s own triage has not observed active exploitation or public proof-of-concept code for this CVE as of its last assessment.

Exploitation and automatability from CISA’s SSVC triage for GHSA-w6x2-f5m4-xw82.

EPSS Exploitation Probability

via FIRST.org ↗
0.2%probability of exploitation in next 30 days
Lower Risk0.00%
Lower risk than most CVEs10th percentile — riskier than 10% 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

bin/fzf-tmux fails to validate layout size values given in the attached form (e.g. -l50). For -l/-u these values reach bash arithmetic expansion ($(( max - size ))), where an operand like a[$(cmd)] executes cmd as the invoking user during option parsing — before any tmux interaction and even outside tmux. A second sink embeds unvalidated popup geometry (-x/-y/-w/-h/-p) into an unquoted tmux popup ... $opt ... invocation, allowing injection of tmux flags such as -e BASH_ENV=<path> (command execution via non-interactive bash sourcing $BASH_ENV).

Reporter / Credits:

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

Details

In bin/fzf-tmux (tag 0.74.4, commit a140afeb), the option parser validates size values with a regex (^[0-9%,]+$ / ^[A-Z]$) only for the separate-argument form (line 82). The attached form is captured unvalidated at line 80:

if [[ ${#arg} -gt 2 ]]; then
  size="${arg:2}"                       # no validation
else
  if [[ $1 =~ ^[0-9%,]+$ ]] || [[ $1 =~ ^[A-Z]$ ]]; then   # only separate form validated

For -l and -u, swap is non-empty (lines 68/75), so size reaches arithmetic evaluation:

  • line 120: size=$((max - size)) (non-percent values)
  • line 102: opt="$opt -l $((100 - size))%" (percent, tmux >= 3.2)
  • line 108: opt="$opt -p $((100 - size))" (percent, tmux < 3.2)

Bash arithmetic expands array subscripts, so a[$(command)] runs command. Verified end-to-end against the unmodified script (see PoC).

Second sink (same root cause): opt is used unquoted at line 236 (tmux popup -d "$PWD" $opt "bash $argsf") and line 249, so a geometry value containing spaces injects extra tmux flags, e.g. -e BASH_ENV=/path/to/script.

PoC

Verified on 0.74.4 (no tmux or fzf binary needed — a stub fzf on PATH suffices because the sink fires during bash argument parsing):

$ bash bin/fzf-tmux '-l a[$(id > /tmp/pwn1)]'      # line 120 sink (non-percent)
$ bash bin/fzf-tmux '-u a[$(id > /tmp/pwn2)]%'     # line 102/108 sink (percent)

$ cat /tmp/pwn1 /tmp/pwn2
uid=1001(sb) gid=1001(sb) groups=...
uid=1001(sb) gid=1001(sb) groups=...

A self-contained reproducer was provided by email (poc-t03-arithmetic.sh). Popup flag-injection variant (tmux >= 3.2): bash bin/fzf-tmux -p '-x0 -e BASH_ENV=/path/to/evil.sh'.

Impact

Local command injection (CWE-78). fzf-tmux argv is commonly assembled by third-party scripts and editor plugins (e.g. fzf-tmux -l "${height}%"); any layout value influenced by less-trusted data (project-local config, wrapper scripts) yields arbitrary command execution as the invoking user. Suggested fixes: apply the regex validation to the attached form, constrain size to [0-9]+ before any $((...)), and build the tmux invocation as an array ("${opt_parts[@]}") instead of unquoted $opt.

Reported privately to the maintainer by email; fixes prepared for the next release.

Exploitability in practice

Impact is high (command execution as the invoking user), but a real attack requires attacker-controlled data to reach the fzf-tmux layout arguments (-l/-u). In normal use these values are set by the user or by trusted, hardcoded configuration, so a vulnerable data flow is uncommon. The issue is local-only, requires the victim to run fzf-tmux with the poisoned value, and bin/fzf-tmux has been superseded by the built-in --tmux/--popup option since 0.53.0.

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 GHSA-w6x2-f5m4-xw82 is resolved across your whole dependency graph.

  3. Workarounds

    Stop passing untrusted input into the interpreter or shell: call the affected binary with an argument array rather than a composed command string, reject anything outside a strict allowlist of expected values, and run the component under an account that cannot reach beyond the work it legitimately does.

Frequently Asked Questions

### Summary `bin/fzf-tmux` fails to validate layout size values given in the *attached* form (e.g. `-l50`). For `-l`/`-u` these values reach bash arithmetic expansion (`$(( max - size ))`), where an operand like `a[$(cmd)]` executes `cmd` as the invoking user during option parsing — before any tmux interaction and even outside tmux. A second sink embeds unvalidated popup geometry (`-x/-y/-w/-h/-p`) into an unquoted `tmux popup ... $opt ...` invocation, allowing injection of tmux flags such as `-e BASH_ENV=<path>` (command execution via non-interactive bash sourcing `$BASH_ENV`). ### Reporter
O3 Security · Impact-Aware SCA

Is GHSA-w6x2-f5m4-xw82 in your dependencies?

Find it across Go, including transitive dependencies.

fzf: Arbitrary command execution via bash arithmetic…