Pentest Tools

---
name: pentest-tools
description: |
  Active penetration testing toolchain. Covers reconnaissance, port scanning, vulnerability scanning, web pentest, SQL injection, directory brute-force, password cracking.
  Exposes 20+ security tools to the AI agent via MCP server (pentestMCP / mcp-security-hub).
  Trigger keywords: pentest, port scan, Nmap, vuln scan, Nuclei, SQL injection, SQLMap, directory brute, FFUF, password crack, Hashcat, recon, subdomain, web pentest, ZAP, Burp.
---


## ACTION REQUIRED (execute immediately after reading)

1. `NOW`: Read accessный local precedent only if it exists; do not treat a missing path as proof of authorization. Every active scan, exploit, credential test, external request, MCP call, bootstrap/install, or target interaction requires explicit written scope and authorization; otherwise remain read-only and record `unverified`.
3. `NOW`: confirm the current task falls within this skill's scope
5. `NEXT`: if a tool is missing, report the exact missing capability; bootstrap/install is a mutation and requires explicit authorization. Do not guess paths or install automatically.
6. `ACT`: Recon phase prioritizes `references/recon-pipeline.md` (CF browser headers / Windows nmap / curl `--globoff`); append each batch result to `timeline.md`; write candidates to Evidence via `../scripts/append-evidence.ps1` (hit ≠ verified)
7. `ACT`: Modern web/lab client-side (DOM XSS / prototype pollution / agent-browser) → `references/client-side-lab-playbook.md`; write observed Evidence + failure gate even if not exploited

# Pentest Tools

## Scope

Use this skill when the task involves:

- Target reconnaissance (port scanning, subdomain enumeration, service identification)
- Vulnerability scanning (web vulns, CVE detection, misconfig)
- Web pentest (SQL injection, XSS, SSRF, directory brute-force)
- Password cracking (hash cracking, dictionary attacks)
- Network penetration (service exploitation, lateral movement assistance)

### Division of labor with other skills

| Scenario | Use which skill |
|------|--------|
| Active scanning/attacking (Nmap/Nuclei/SQLMap) | **This skill** |
| Reverse engineering binaries | `ida-reverse/` or `radare2/` |
| Frontend JS signature reversing | `js-reverse/` |
| Browser/desktop automation | `browser-automation/` |
| CTF competition (comprehensive) | `CTF-Sandbox-Orchestrator/` |

Simple heuristic:
- Need to "scan target, find vulns, exploit" → this skill
- Need to "analyze program internal logic" → RE-type skill
- Need to "operate browser/desktop" → browser-automation

---

## Tool matrix

### Reconnaissance

| Tool | Purpose | Typical command |
|------|------|---------|
| **Nmap** | Port scan, service ID, OS detection | `nmap -sV -sC -O target` |
| **Masscan** | Large-scale fast port scanning | `masscan -p1-65535 target --rate=1000` |
| **Subfinder** | Subdomain enumeration | `subfinder -d target.com` |
| **httpx** | HTTP probing, liveness check | `httpx -l urls.txt -status-code` |

### Vulnerability scanning

| Tool | Purpose | Typical command |
|------|------|---------|
| **Nuclei** | Template-based vuln scan (CVE/config/exposure) | `nuclei -u target -t cves/` |
| **ZAP** | Web app security scanning | via API or MCP call |
| **Nikto** | Web server vulnerability scanning | `nikto -h target` |

### Web pentest

| Tool | Purpose | Typical command |
|------|------|---------|
| **SQLMap** | SQL injection automation | `sqlmap -u "url?id=1" --batch --dbs` |
| **FFUF** | Directory/parameter brute-force | `ffuf -u target/FUZZ -w wordlist.txt` |
| **Gobuster** | Directory/subdomain brute-force | `gobuster dir -u target -w wordlist` |
| **XSStrike** | XSS detection | `xsstrike -u "url?param=test"` |

### Password cracking

| Tool | Purpose | Typical command |
|------|------|---------|
| **Hashcat** | GPU hash cracking | `hashcat -m 0 hash.txt wordlist.txt` |
| **John the Ripper** | CPU hash cracking | `john --wordlist=rockyou.txt hash.txt` |
| **Hydra** | Online brute-force | `hydra -l admin -P pass.txt target ssh` |

### Exploitation frameworks

| Tool | Purpose | Note |
|------|------|------|
| **Metasploit** | Exploitation framework | Requires separate install, large |
| **Impacket** | Windows protocol exploitation (SMB/WMI/Kerberos) | `pip install impacket` |

---

## MCP backend selection

This skill supports two MCP backends; choose one:

### Option A: pentestMCP (recommended, Docker one-shot)

- **Project**: https://github.com/ramkansal/pentestmcp
- **Features**: 20+ tools packaged in a single Docker container, MCP server directly exposed
- **Tools**: Nmap, Nuclei, ZAP, SQLMap, FFUF, Nikto, Gobuster, Subfinder, httpx, etc.
- **Install**:

```bash
# Pull and run
docker pull ramkansal/pentestmcp
docker run -d -p 8080:8080 ramkansal/pentestmcp

# Or build locally
git clone https://github.com/ramkansal/pentestmcp.git
cd pentestmcp
docker build -t pentestmcp .
docker run -d -p 8080:8080 pentestmcp
```

- **MCP registration**:

```json
{
  "mcpServers": {
    "pentest": {
      "url": "http://localhost:8080/mcp"
    }
  }
}
```

### Option B: mcp-security-hub (modular)

- **Project**: https://github.com/FuzzingLabs/mcp-security-hub
- **Features**: Each tool is a separate MCP server, enable as needed
- **Tools**: Nmap, Ghidra, Nuclei, SQLMap, Hashcat
- **Install**: follow each submodule's README

### Option C: Single-tool MCP (lightest)

If you only need one tool:

| Tool | MCP project | Install |
|------|---------|------|
| Nmap | [nmap-mcp-server](https://github.com/PhialsBasement/nmap-mcp-server) | npm |
| Nuclei | [nuclei-mcp](https://github.com/addcontent/nuclei-mcp) | npm |
| SQLMap | mcp-security-hub submodule | pip |

---

## Workflow

### Standard pentest flow

> **Important**: When executing pentest, follow the autonomous loop framework in `references/pentest-loop.md`.
> This framework defines complete risk gating, logging standards, context compression, and completion checks.

```text
1. Reconnaissance
   - Nmap port scan → confirm open services
   - Subfinder subdomain enumeration → expand attack surface
   - httpx liveness check → filter valid targets

2. Vulnerability scanning
   - Nuclei template scan → quickly find known vulns
   - ZAP/Nikto → deep web app scanning

3. Vulnerability exploitation
   - SQLMap → SQL injection
   - FFUF → discover hidden paths/parameters
   - Manual verification → confirm exploitability

4. Post-exploitation (if within authorized scope)
   - Privilege escalation
   - Lateral movement
   - Data extraction

5. Report
   - Call docs-generator skill to generate pentest report
```

### Quick scan flow (results in 5 minutes)

```text
1. nmap -sV -sC target → ports+services
2. nuclei -u target -severity critical,high → critical/high vulns
3. If web service → ffuf -u target/FUZZ -w common.txt → directories
4. Aggregate findings → decide next step
```

---

## Notes

- **Must have authorization** — all scanning/attacking operations must be within authorized scope
- **Control scan rate** — avoid triggering WAF/IDS or crashing the target
- **Passive before active** — recon first, then vuln scanning, then exploitation
- **Log everything** — record every command and result for the report
- **Don't blindly automate** — AI should wait for confirmation at each critical step

---

## On-Demand Bootstrap

### Automation capability boundary

The install commands below are reference material only. They must not run automatically during review; package/bootstrap changes require explicit authorization, an isolated target, and a rollback path.

| Tool | Auto-installable | Install method | Note |
|------|-----------|---------|------|
| Nmap | ✓ | winget (`Insecure.Nmap`) | Windows version |
| Nuclei | ✓ | `go install` or GitHub Release | Requires Go or download binary |
| SQLMap | ✓ | `pip install sqlmap` or git clone | Python |
| FFUF | ✓ | GitHub Release | Go binary |
| SecLists | ✓ | GitHub Release ZIP | Wordlist collection (required for FFUF/Gobuster) |
| Hashcat | ✗ | Manual download | Requires GPU driver |
| Metasploit | ✗ | Manual install | Large, recommend Kali |
| pentestMCP (Docker) | ✗ | Requires Docker | `docker run ramkansal/pentestmcp` |
| Impacket | ✓ | `pip install impacket` | Python |
| ProxyCat | ✓ | `pip install proxycat` | Proxy pool middleware (anti-ban for batch scanning) |
| BurpSuite MCP | ✗ | BurpSuite extension marketplace | Requires BurpSuite Pro/Community |

### Bootstrap strategy

1. If user has Docker → recommend pentestMCP (one-shot all-in-one)
2. If no Docker → install tools individually as needed
3. Prioritize Nmap + Nuclei + SQLMap (covers 80% of scenarios)

### Manual install guidance

```markdown
⚠️ **Pentest tools not installed**

**Recommended (requires Docker)**:
docker pull ramkansal/pentestmcp
docker run -d -p 8080:8080 ramkansal/pentestmcp

**Lightweight (install individually)**:
- Nmap: winget install Insecure.Nmap
- Nuclei: go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
- SQLMap: pip install sqlmap
- FFUF: Download from https://github.com/ffuf/ffuf/releases

**After installation, let me know and I'll continue the task.**
```

---

## Reference resources

- [awesome-pentest](https://github.com/enaqx/awesome-pentest) — 25k+ stars pentest tool collection
- [SecLists](https://github.com/danielmiessler/SecLists) — Wordlist/payload collection (required for FFUF/Gobuster)
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings) — Various vulnerability payloads
- [HackTricks](https://book.hacktricks.wiki/) — Pentest techniques encyclopedia
- [pentest-ai-agents](https://github.com/0xSteph/pentest-ai-agents) — 35 Claude Code pentest sub-agents (reference their prompt patterns)
- [Pentest Swarm AI](https://github.com/Armur-Ai/Pentest-Swarm-AI) — Swarm intelligence autonomous pentest framework (multi-agent, supports MCP server)
- [ProxyCat](https://github.com/honmashironeko/ProxyCat) — Proxy pool middleware (anti-IP-ban for batch scanning)
- [planning-with-files](https://github.com/othmanadi/planning-with-files) — Planning task skill (for loop testing)

### Internal reference documents

- `references/pentest-loop.md` — **Core loop framework** (risk gating + logging + context compression)
- `references/recon-pipeline.md` — **Authorized recon pipeline** (CF headers / nmap / Evidence)
- `references/client-side-lab-playbook.md` — **DOM XSS / prototype pollution / agent-browser** (lab client-side)
- `references/burpsuite-mcp-guide.md` — **BurpSuite MCP complete guide** (63 tools + 7 scenarios + AI prompt templates)
- `references/automation-loop-pattern.md` — Automated loop testing pattern (lightweight)
- `references/awesome-pentest-digest.md` — Pentest tools digest quick reference
- `references/pentest-ai-agents-matrix.md` — 35-agent coverage matrix
- `payloads/` — Custom payload directory (AI uses first)
- `templates/` — Pentest required file templates (scope/rules/plan/findings/progress)

## Routing context

**Upstream entry**: `skills/SKILL.md` (master), `routing.md`
**Trigger condition**: Need to actively scan/attack target (port scan, vuln detection, injection testing, etc.)
**Downstream exit**:
- Found web vuln needing further analysis → `js-reverse/`
- Found binary vuln needing reversing → `ida-reverse/` or `radare2/`
- Need to operate browser to verify vuln → `browser-automation/`
- Generate report after completion → `docs-generator/`

**Sibling modules**: `CTF-Sandbox-Orchestrator/` (Web/Pwn challenges in CTF use these tools)


## Task completion checklist (MUST pass before claiming completion)

- [ ] Was the workflow authorized for the named target and scope?
- [ ] Were all external scans, exploit attempts, credential tests, and installs explicitly authorized?
- [ ] Was the read-only fallback used when authorization or tool evidence was missing?
- [ ] Did I execute every workflow step (not just read)?
- [ ] Did I use real tool paths based on `tool-index`?
- [ ] Did I produce reproducible evidence (commands/scripts/screenshots/report)?
- [ ] Did I complete and write back the RULES-required Checklist items?