Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add trailofbits/skills-curated
/plugin install ffuf-web-fuzzing@skills-curated
Open on GitHub

What 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-curated

This 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-code

3Manually: put the files in place

~/.claude/skills/ffuf-web-fuzzing/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ffuf-web-fuzzing/

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.

ffuf-web-fuzzing jthack The ffuf-web-fuzzing skill guides ffuf scans for directories, parameters, and subdomains. It also covers fuzzing requests that carry authentication. CX Codex +1 ★ 216repo stars security-fuzzing Eyadkelleh security-fuzzing provides curated SecLists fuzzing payloads for injection testing and input validation. Essential for authorized code audits, bug bounties, and CTFs. CX Codex +1 662installs api-fuzzing-bug-bounty zebbern api-fuzzing-bug-bounty is a Claude Code skill for assessing API security and locating vulnerabilities. It activates for requests about fuzzing, IDOR checks, or REST and GraphQL testing. CX Codex +1 139installs fuzzing-obstacles trailofbits fuzzing-obstacles patches anti-fuzzing patterns like checksums and time-seeded PRNGs in C, C++, and Rust. Useful when fuzzers get stuck on early validation checks. CX Codex +1 5,900installs fuzzing-dictionary trailofbits fuzzing-dictionary is a Claude Code skill that builds token dictionaries for libFuzzer and AFL++ to move past initial parser and protocol checks. CX Codex +1 5,800installs web-hunter 0xSteph web-hunter — a Claude Code subagent for active web application security testing. It discovers hidden paths and parameters, then checks injection points inside an authorized scope. CX Codex ★ 2,482repo stars fuzzing mohitmishra786 fuzzing guides agents in writing fuzz targets for C and C++, configuring libFuzzer or AFL++, and wiring coverage-guided tests into CI pipelines. CX Codex +1 722installs

From the same set51

The whole set →
openai-gh-fix-ci openai-gh-fix-ci reads the failing GitHub Actions checks on a pull request, pulls the logs, names the cause and drafts a fix. Edits land only after you approve the plan. CX Codex +1 ★ 540repo stars openai-jupyter-notebook openai-jupyter-notebook is a Claude Code skill that generates, structures, and edits clean Jupyter notebooks (.ipynb) for analytical experiments and step-by-step guides. CX Codex +1 ★ 540repo stars security-awareness The security-awareness skill guides an agent through phishing checks, domain verification, and safer handling of credentials. Use it when an agent works with email, links, or sensitive data. CX Codex +1 ★ 540repo stars openai-netlify-deploy openai-netlify-deploy — a Claude skill that runs a Netlify deploy end to end: sign-in check, site linking or creation, dependency install, then a preview or production release. CX Codex +1 ★ 540repo stars openai-cloudflare-deploy openai-cloudflare-deploy is a Claude Code skill that automates deploying apps and infrastructure to Cloudflare. It activates for requests to deploy, host, publish, or set up a Cloudflare project. CX Codex +1 ★ 540repo stars scv-scan scv-scan is a Claude Code skill that scans Solidity projects for contract vulnerabilities. It runs for pre-release security checks or reviews after code changes. CX Codex +1 ★ 540repo stars review-plugin review-plugin audits a plugin directory for script flaws and project standard violations, automatically fixing detected issues. CX Codex +1 ★ 540repo stars x-research The x-research skill for Claude Code searches recent X discussions, opens threads, and gathers sources to check developer reactions to a release or API change. CX Codex +1 ★ 540repo stars

Project sponsors

Companies that keep this analytics open