ffuf-web-fuzzing · trailofbits — Claude Code skill: what it does, how to install
ffuf-web-fuzzing guides Claude Code through web fuzzing using ffuf during authorized penetration testing engagements.
MIT ★ 540 updated 2026-07-14
/plugin marketplace add trailofbits/skills-curated
/plugin install ffuf-web-fuzzing@skills-curatedWhat ffuf-web-fuzzing does
The skill provides workflow rules for running ffuf against web applications. It sets up command arguments for directory discovery, subdomain enumeration, parameter testing, and authenticated requests. To prevent noisy outputs, it enforces auto-calibration via -ac and demands output logging directly into -o results.json.
For authenticated endpoints, the agent converts browser DevTools curl commands into raw req.txt request files instead of stringing multiple -H parameters. It also specifies rate-limiting tiers, such as -rate 2 -t 10 for sensitive targets and -t 100 for local labs, helping testers stay clear of WAF triggers.
The standalone ffuf binary must already exist on your system via Homebrew or Go. Without it, the assistant cannot execute tests or analyze responses.
What it helps with
- Construct targeted directory and subdomain discovery commands with auto-calibration
- Convert DevTools curl commands into raw HTTP requests for authenticated fuzzing
- Configure rate limits and thread counts to avoid triggering WAF defenses
- Inspect ffuf JSON output to spot status code and response size anomalies
Example prompts for the agent
- Build an ffuf command to discover API endpoints using a bearer token
- Convert this curl snippet to a req.txt file and set up an IDOR check
- Analyze results.json to highlight anomalous response sizes and HTTP statuses
How to install ffuf-web-fuzzing
1Plugin marketplace
/plugin marketplace add trailofbits/skills-curated/plugin install ffuf-web-fuzzing@skills-curatedThis installs the whole ffuf-web-fuzzing plugin with all its skills
2Skills CLI (Vercel)
npx skills add trailofbits/skills-curated --skill ffuf-web-fuzzing -a claude-code3Manually: put the files in place
~/.claude/skills/ffuf-web-fuzzing/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/ffuf-web-fuzzing/
1Skills CLI (Vercel)
npx skills add trailofbits/skills-curated --skill ffuf-web-fuzzing -a codex2Manually: put the files in place
.agents/skills/ffuf-web-fuzzing/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add trailofbits/skills-curated --skill ffuf-web-fuzzing -a cursor2Manually: put the files in place
.cursor/skills/ffuf-web-fuzzing/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install trailofbits/skills-curated plugins/ffuf-web-fuzzing/skills/ffuf-web-fuzzing2Manually: put the files in place
.github/skills/ffuf-web-fuzzing/SKILL.md1Skills CLI (Vercel)
npx skills add trailofbits/skills-curated --skill ffuf-web-fuzzing -a gemini-cli2Platform CLI
gemini skills install https://github.com/trailofbits/skills-curated --path plugins/ffuf-web-fuzzing/skills/ffuf-web-fuzzingManually: put the files in place
.devin/skills/ffuf-web-fuzzing/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about ffuf-web-fuzzing
How to install ffuf-web-fuzzing in Claude Code?
Run /plugin marketplace add trailofbits/skills-curated in Claude Code, then execute /plugin install ffuf-web-fuzzing@skills-curated.
What does the ffuf-web-fuzzing skill do?
It guides the agent in orchestrating ffuf runs, choosing dictionaries, setting up auto-calibration, and parsing output during security assessments.
What dependencies are required beforehand?
The ffuf CLI tool must be installed on your machine using brew install ffuf or go install github.com/ffuf/ffuf/v2@latest.
Source text
SKILL.md · MIT
---
name: ffuf-web-fuzzing
description: >-
Expert guidance for ffuf web fuzzing during authorized penetration testing.
Covers directory discovery, subdomain enumeration, parameter fuzzing,
authenticated fuzzing with raw requests, auto-calibration, and result
analysis. Use when running ffuf scans, analyzing ffuf output, or building
fuzzing strategies for web targets.
allowed-tools:
- Bash
- Read
- Write
- Edit
- Grep
- Glob
---
# FFUF Web Fuzzing
Guidance for using ffuf (Fuzz Faster U Fool) effectively during authorized penetration testing.
## Prerequisites
ffuf must be installed: `brew install ffuf` (macOS) or `go install github.com/ffuf/ffuf/v2@latest`
## When to Use
- Running directory, file, or subdomain discovery against web targets
- Fuzzing API endpoints, parameters, or POST data
- Authenticated fuzzing with raw HTTP requests
- Analyzing ffuf JSON output for anomalies and interesting findings
- Building fuzzing strategies (wordlist selection, filtering, rate limiting)
- IDOR testing with authenticated sessions
## When NOT to Use
- Target system is not in scope or authorization is unclear
- Passive reconnaissance is more appropriate (use OSINT tools instead)
- The target is a production system and rate limiting hasn't been configured
- You need a full vulnerability scanner (use Burp Suite, Nuclei, etc.)
- Testing for logic flaws that require multi-step interaction
## Rationalizations to Reject
- "Auto-calibration is optional" -- `-ac` is mandatory. Without it, results are buried in false positives and analysis is wasted effort.
- "More threads = faster results" -- Hammering a target with `-t 200` triggers WAFs, gets you blocked, and may crash staging environments. Start with `-t 10 -rate 2` for production targets.
- "I'll filter later" -- Set up filtering before the scan. Running a 220k wordlist without filters and then trying to grep through the noise is backwards.
- "The default wordlist is fine" -- Wordlist selection is the most important decision. A generic wordlist misses technology-specific paths. See [references/wordlists.md](references/wordlists.md).
- "Raw requests are too much work" -- For authenticated fuzzing, `--request req.txt` is simpler and more reliable than chaining `-H` and `-b` flags. Capture once, fuzz many times.
## Critical Rules
1. **Always use `-ac`** (auto-calibration) unless you have a specific, documented reason not to
2. **Always save output** with `-o results.json` for later analysis
3. **Rate limit production targets** with `-rate` and `-t` flags
4. **Use `--request` for auth** -- raw request files beat command-line header chains
5. **Confirm authorization first** -- before running any scan, verify the user has written permission for the target. Ask if unclear.
## Core Concepts
### The FUZZ Keyword
```bash
# In URL path
ffuf -w wordlist.txt -u https://target.com/FUZZ -ac
# In headers
ffuf -w wordlist.txt -u https://target.com -H "Host: FUZZ.target.com" -ac
# In POST body
ffuf -w wordlist.txt -X POST -d "user=admin&pass=FUZZ" -u https://target.com/login -ac
# Multiple positions with custom keywords
ffuf -w endpoints.txt:EP -w ids.txt:ID -u https://target.com/EP/ID -mode pitchfork -ac
```
### Auto-Calibration
`-ac` automatically detects and filters repetitive false-positive responses. It adapts to the target's specific behavior and removes noise from dynamic content.
```bash
ffuf -w wordlist.txt -u https://target.com/FUZZ -ac # Standard
ffuf -w wordlist.txt -u https://target.com/FUZZ -ach # Per-host (multi-host scans)
ffuf -w wordlist.txt -u https://target.com/FUZZ -acc "404" # Custom calibration string
```
## Common Patterns
### Directory Discovery
```bash
ffuf -w /opt/SecLists/Discovery/Web-Content/raft-large-directories.txt \
-u https://target.com/FUZZ -e .php,.html,.txt,.bak \
-ac -c -v -o results.json
```
### Subdomain Enumeration
```bash
ffuf -w /opt/SecLists/Discovery/DNS/subdomains-top1million-5000.txt \
-u https://FUZZ.target.com -ac -c -v -o results.json
```
### API Endpoint Discovery
```bash
ffuf -w /opt/SecLists/Discovery/Web-Content/api/api-endpoints.txt \
-u https://api.target.com/v1/FUZZ \
-H "Authorization: Bearer YOUR_TOKEN_HERE" -mc 200,201 -ac -c
```
### Authenticated Fuzzing with Raw Requests
Capture a full authenticated request, save to `req.txt`, insert `FUZZ`:
```http
POST /api/v1/users/FUZZ HTTP/1.1
Host: target.com
Authorization: Bearer YOUR_TOKEN_HERE
Cookie: session=YOUR_SESSION_ID
Content-Type: application/json
{"action":"view","id":"1"}
```
```bash
ffuf --request req.txt -w wordlist.txt -ac -o results.json
```
See [references/request-templates.md](references/request-templates.md) for pre-built templates covering bearer tokens, session cookies, API keys, and GraphQL.
### Authenticated Fuzzing: Agent Workflow
Authenticated fuzzing requires real credentials that the agent cannot obtain independently. When the user asks for authenticated fuzzing:
1. Ask the user to provide ONE of:
- A raw HTTP request file (`req.txt`) with auth headers already included
- A curl command from browser DevTools (convert it to `req.txt` format)
- Individual credentials (Bearer token, session cookie, API key)
2. If given a curl command, convert it to raw HTTP request format and write to `req.txt`
3. If given individual credentials, use a template from [references/request-templates.md](references/request-templates.md) and substitute real values
4. Never fabricate or guess authentication tokens
### IDOR Testing
```bash
ffuf --request req.txt -w <(seq 1 10000) -ac -mc 200 -o idor_results.json
```
## Rate Limiting
| Environment | Flags | Notes |
|-------------|-------|-------|
| Production (stealth) | `-rate 2 -t 10` | Avoid WAF triggers |
| Production (normal) | `-rate 10 -t 20` | Balanced |
| Staging/Dev | `-rate 50 -t 40` | Faster |
| Local/Lab | No limit, `-t 100` | Maximum speed |
## Analyzing Results
Save output as JSON (`-o results.json`), then read the file and focus on:
- **Anomalous status codes** -- anything other than the baseline 404/403
- **Size outliers** -- responses significantly larger or smaller than average
- **Interesting keywords** in URLs -- admin, api, backup, config, .git, .env
- **Timing anomalies** -- slow responses may indicate SQL injection or heavy processing
- **Follow-up targets** -- interesting findings warrant deeper fuzzing
Use `-fs` to filter by response size and `-fc` to filter by status code when auto-calibration isn't sufficient. Run `ffuf -h` for the full list of match/filter flags.
## References
- [Wordlist selection guide](references/wordlists.md) -- recommended SecLists by scenario
- [Authenticated request templates](references/request-templates.md) -- pre-built req.txt for bearer tokens, cookies, API keys
- [ffuf official docs](https://github.com/ffuf/ffuf/wiki)
- [SecLists](https://github.com/danielmiessler/SecLists)
© jthack · MIT · trailofbits/skills-curated
Similar skills
All skills for Security →ffuf-web-fuzzing by other authors comes first.