Skip to content

A Claude Code skill bundle for bug hunting and external red-team work - 82 skills, 15 slash commands, 681 disclosed-report patterns curated across 24 core vulnerability classes, plus enterprise identity + infrastructure attack matrices.

feat: add hunt-fintech-graphql skill + doc-count CI, refresh counts (#61)

prithvee07f6944d673dbf
diff --git a/.github/workflows/doc-count-check.yml b/.github/workflows/doc-count-check.yml
new file mode 100644
index 0000000..41d91c1
--- /dev/null
+++ b/.github/workflows/doc-count-check.yml
@@ -0,0 +1,44 @@
+name: doc-count-check
+
+# Keeps skill/command counts in docs honest against what's actually on disk.
+# Catches stale numbers (e.g. "71 SKILL.md files" after the bundle grew to 82)
+# before they merge. No external dependencies — stdlib Python only.
+
+on:
+ pull_request:
+ paths:
+ - "skills/**"
+ - "commands/**"
+ - "README.md"
+ - "SECURITY.md"
+ - "USAGE.md"
+ - "INSTALL.md"
+ - "docs/skills.md"
+ - "docs/credits.md"
+ - "docs/architecture.md"
+ - "scripts/check_doc_counts.py"
+ - ".github/workflows/doc-count-check.yml"
+ push:
+ branches: [main]
+ paths:
+ - "skills/**"
+ - "commands/**"
+ - "scripts/check_doc_counts.py"
+ workflow_dispatch:
+
+permissions:
+ contents: read
+
+jobs:
+ check:
+ name: Check doc counts
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - uses: actions/setup-python@v5
+ with:
+ python-version: "3.12"
+
+ - name: Verify skill/command counts in docs match disk
+ run: python3 scripts/check_doc_counts.py
diff --git a/INSTALL.md b/INSTALL.md
index 50b0a70..bdb8af5 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -58,7 +58,7 @@ pwsh ./scripts/install.ps1
> script aborts with a `syntax error` and cannot fix itself.
This copies:
-- All 82 skills → `~/.claude/skills/` (macOS/Linux) or `%USERPROFILE%\.claude\skills\` (Windows)
+- All 83 skills → `~/.claude/skills/` (macOS/Linux) or `%USERPROFILE%\.claude\skills\` (Windows)
- All 15 slash commands → `~/.claude/commands/`
- The `hunt` scaffolder → `~/.claude/scripts/hunt.sh` (sourced from your `.zshrc`/`.bashrc`) on macOS/Linux, or `~\.claude\scripts\hunt.ps1` (dot-sourced from your PowerShell `$PROFILE`) on Windows
diff --git a/README.md b/README.md
index d8f8cda..d21dd41 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
# claude-bughunter
-> A self-contained Claude skill bundle for bug hunting and external red-team work · **82 skills** · 15 slash commands · **681 disclosed-report patterns** across 24 core vulnerability classes · enterprise identity + infrastructure attack matrices · engagement-folder scaffolding · Burp MCP integration · battle-tested across authorized red-team and bug-hunting engagements, plus public training platforms (DVWA, OWASP Juice Shop, Hacker101, testphp.vulnweb.com).
+> A self-contained Claude skill bundle for bug hunting and external red-team work · **83 skills** · 15 slash commands · **681 disclosed-report patterns** across 24 core vulnerability classes · enterprise identity + infrastructure attack matrices · engagement-folder scaffolding · Burp MCP integration · battle-tested across authorized red-team and bug-hunting engagements, plus public training platforms (DVWA, OWASP Juice Shop, Hacker101, testphp.vulnweb.com).
Built by **[Sachin Sharma](https://www.linkedin.com/in/sachinsharma8080/)** — Bug Hunting & GenAI Security Research.
@@ -26,7 +26,7 @@ Built by **[Sachin Sharma](https://www.linkedin.com/in/sachinsharma8080/)** —
Four layers stack:
- **Think** — `bb-methodology` + `redteam-mindset`: the 5-phase non-linear workflow, critical-thinking framework, and red-team operator discipline.
-- **Hunt webapps** — 48 `hunt-*` skills curated from 681 disclosed HackerOne reports: per-class detection patterns, payloads, bypass tables, and chain templates.
+- **Hunt webapps** — 58 `hunt-*` skills curated from 681 disclosed HackerOne reports: per-class detection patterns, payloads, bypass tables, and chain templates.
- **Hit the perimeter** — enterprise platform chains (M365/Entra, Okta, vCenter, SSL-VPN appliances, SharePoint, cloud IAM): current 2024–2026 CVE chains + post-credential escalation.
- **Ship it** — `triage-validation` + reporting + `evidence-hygiene`: the 7-Question Gate, VRT-aware severity, OOS rebuttals, PII redaction, and red-team deliverables.
@@ -43,7 +43,7 @@ All triggered automatically by topic — describe what you're testing in plain E
/plugin install claude-bughunter@elementalsouls
```
-All 82 skills + 15 commands load namespaced under `claude-bughunter:` and update when you bump the plugin version — no files copied into `~/.claude/`.
+All 83 skills + 15 commands load namespaced under `claude-bughunter:` and update when you bump the plugin version — no files copied into `~/.claude/`.
**Option B — copy install (no plugin system / pin to a clone):**
@@ -64,7 +64,7 @@ Both copy the skills + commands into `~/.claude/` (macOS/Linux) or `%USERPROFILE
**What each install path gives you:**
-| Path | 82 skills + 15 slash commands | `cbh` CLI | `hunt` scaffolder |
+| Path | 83 skills + 15 slash commands | `cbh` CLI | `hunt` scaffolder |
|---|---|---|---|
| **A — plugin** | ✅ namespaced under `claude-bughunter:` | ➕ separate `pipx install` | ❌ clone-only |
| **B — copy install** | ✅ copied into `~/.claude/` | ✅ from the clone | ✅ from the clone |
@@ -158,20 +158,15 @@ If you're running an internal red team that includes domain-takeover chains via
## What's inside
-**82 skills**, auto-loaded by topic — no invocation by name. Coverage across the external attack surface:
+**83 skills**, auto-loaded by topic — no invocation by name. Coverage across the external attack surface:
| Category | # | Examples |
|---|---|---|
-| Web application hunting | 13 | XSS, SQLi, SSRF, IDOR, LFI, SSTI, XXE, CSRF, CORS, open-redirect |
-| Authentication & identity | 7 | auth-bypass, session, OAuth, SAML, MFA-bypass, ATO |
-| API & infrastructure | 15 | GraphQL, gRPC, WebSocket, API-misconfig, host-header, RCE |
-| Advanced & concurrency | 6 | race-condition, HTTP smuggling, deserialization, cache-poison |
-| Framework-specific | 4 | Next.js, Node.js, Laravel, Spring Boot |
-| Enterprise identity & cloud ★ | 3 | M365/Entra, Okta, cloud-IAM-deep |
-| Infrastructure & appliance ★ | 4 | VMware vCenter, enterprise VPN, SharePoint, ASP.NET/NTLM |
-| Red-team tradecraft ★ | 4 | redteam-mindset, APK pipeline, supply-chain recon, mid-engagement IR |
-| Recon & OSINT | 4 | web2-recon, offensive-osint, subdomain |
-| Workflow, reporting & specialized | 11 | methodology, triage-validation, evidence-hygiene, VRT-aware reporting |
+| Hunt — web app vuln classes | 58 | XSS, SQLi, SSRF, IDOR, LFI, SSTI, XXE, CSRF, CORS, open-redirect, SharePoint, ASP.NET/NTLM |
+| Enterprise platform attack ★ | 10 | M365/Entra, Okta, cloud-IAM-deep, vCenter, enterprise VPN, APK/iOS red-team pipelines, supply-chain recon |
+| Reporting & validation | 6 | triage-validation, evidence-hygiene, report-writing, bugcrowd-reporting |
+| Recon & OSINT | 5 | web2-recon, offensive-osint, osint-methodology, recon-scope-triage |
+| Methodology & mindset | 4 | bb-methodology, bug-bounty, redteam-mindset, bb-local-toolkit |
Full searchable catalog → **[docs/skills.md](docs/skills.md)**. Also ships **15 slash commands** (`/hunt`, `/recon`, `/report`, …) and a deterministic **engagement engine** (`engine/`) that maps a target's attack surface and routes each finding to the skill that handles it.
@@ -266,7 +261,7 @@ The per-class `hunt-*` skills address gap-zero (*"what should I look for in weba
- [ ] HackerOne MCP integration (currently only Burp MCP wired in)
- [ ] Per-engagement memory layer — pattern recall across targets
-- [ ] Industry-specific hunt skills — `hunt-fintech-graphql`, `hunt-healthcare-fhir`, `hunt-gov-compliance`
+- [x] Industry-specific hunt skills — `hunt-fintech-graphql` shipped; `hunt-healthcare-fhir`, `hunt-gov-compliance` still open
- [ ] Program-rules-parser skill — auto-generate structured `scope.md` from program text
- [ ] Refresh `hunt-*` skills with newer disclosed reports (re-run `public-skills-builder`)
- [ ] Additional enterprise-platform skills — `citrix-netscaler-deep`, `f5-bigip-attack`, `ad-cs-attack` (AD Certificate Services)
@@ -300,7 +295,7 @@ Operational tradecraft accumulated across bug-bounty engagements and authorized
**Sister project:** [Claude-OSINT](https://github.com/elementalsouls/Claude-OSINT) — paired skills for the recon phase that this bundle picks up after. Its two recon skills (`offensive-osint`, `osint-methodology`) are **canonically maintained here** and re-exported there, so the two are byte-identical. **Installing both is safe:** each bundle's installer (`install.sh` on macOS/Linux, `install.ps1` on Windows) records a manifest, the script skips re-copying an identical skill, and `--uninstall` keeps any skill the other bundle still owns — uninstalling one never breaks the other.
-**Vendored foundation:** [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) — methodology, validation, reporting, payload library (8 of 82 skills + 15 slash commands)
+**Vendored foundation:** [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) — methodology, validation, reporting, payload library (8 of 83 skills + 15 slash commands)
**Generator tool used (not vendored):** [shuvonsec/public-skills-builder](https://github.com/shuvonsec/public-skills-builder) — used to scaffold per-class skills from H1 disclosed reports
diff --git a/SECURITY.md b/SECURITY.md
index 1b69302..295e1ff 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -50,7 +50,7 @@ If you reach domain-admin-class objectives during an engagement, the bundle's ex
## Verifying what you install (supply-chain trust)
-You are installing 71 `SKILL.md` files plus shell and Python helpers into your AI agent's context. Agent Skills are third-party code — treat them like any dependency you run. Independent research (Snyk "ToxicSkills", 2026) found prompt injection in a meaningful fraction of public skills, so verification matters.
+You are installing 83 `SKILL.md` files plus shell and Python helpers into your AI agent's context. Agent Skills are third-party code — treat them like any dependency you run. Independent research (Snyk "ToxicSkills", 2026) found prompt injection in a meaningful fraction of public skills, so verification matters.
**What we do on our side:**
diff --git a/USAGE.md b/USAGE.md
index e0d81c3..d58af4b 100644
--- a/USAGE.md
+++ b/USAGE.md
@@ -1,6 +1,6 @@
# Claude-BugHunter — Usage Guide
-A practical guide to using the 82-skill Claude-BugHunter bundle for bug hunting (bounty programs, authorized pentesting, CTFs, vuln research) **and external red-team engagements** against enterprise targets. This document covers what's in the bundle, how it composes, and how to use it on a real engagement from intake through paid bounty (or final client deliverable).
+A practical guide to using the 83-skill Claude-BugHunter bundle for bug hunting (bounty programs, authorized pentesting, CTFs, vuln research) **and external red-team engagements** against enterprise targets. This document covers what's in the bundle, how it composes, and how to use it on a real engagement from intake through paid bounty (or final client deliverable).
> Built and validated through authorized red-team and bug-bounty engagements — exposed four bug-bounty capability gaps and five additional gaps around platform attack chains, mid-engagement IR detection, and client-facing reporting. The final stack documented here addresses both modes.
@@ -12,7 +12,7 @@ This section is for people who have **never used the bundle before, never used C
### What is this bundle, in plain English?
-It's a collection of 82 markdown files (called **skills**) that turn Claude Code into a methodical bug-hunting assistant.
+It's a collection of 83 markdown files (called **skills**) that turn Claude Code into a methodical bug-hunting assistant.
Without the bundle, asking Claude *"is this XSS?"* gets you a generic answer. With the bundle installed, the same question loads the `hunt-xss` skill — which contains specific detection patterns from 681+ disclosed reports, the exact payloads that have worked, and a validation gate that prevents you from filing a false-positive bug report.
@@ -31,7 +31,7 @@ You don't "learn" the bundle. You install it once, then describe what you're tes
- ❌ You don't need to know how to write exploits. The skills include working payloads.
- ❌ You don't need to know Burp Suite. It's optional. Skills work with curl + browser.
- ❌ You don't need a bug bounty account yet. You can practice on OWASP Juice Shop first.
-- ❌ You don't need to read all 82 skills. They auto-load when relevant.
+- ❌ You don't need to read all 83 skills. They auto-load when relevant.
- ❌ You don't need Python beyond `python --version` working (run `python3 --version` on macOS/Linux).
### Your first 30 minutes
@@ -45,7 +45,7 @@ mkdir -p ~/security-research && cd ~/security-research
git clone https://github.com/elementalsouls/Claude-BugHunter.git
cd Claude-BugHunter
-# 2. Install (copies 82 skills + 15 commands into Claude Code)
+# 2. Install (copies 83 skills + 15 commands into Claude Code)
bash scripts/install.sh
# 3. Reload your shell so the 'hunt' command becomes available
@@ -63,7 +63,7 @@ cd "$HOME\security-research"
git clone https://github.com/elementalsouls/Claude-BugHunter.git
cd Claude-BugHunter
-# 2. Install (copies 82 skills + 15 commands into Claude Code)
+# 2. Install (copies 83 skills + 15 commands into Claude Code)
pwsh ./scripts/install.ps1
# 3. Reload your profile so the 'hunt' command becomes available
@@ -159,7 +159,7 @@ The stack maps to a 6-phase bug-bounty workflow. Each phase has its own skill se
|---|---|---|
| **1. Scope** | Reading program rules, deciding what's in/out, scaffolding the engagement folder | `bug-bounty`, `bb-methodology`, `osint-methodology` + `hunt <target>` shell command |
| **2. Recon** | Asset discovery, subdomain enum, endpoint mapping, secret hunting | `offensive-osint`, `web2-recon`, `bb-local-toolkit` |
-| **3. Hunt** | Active testing for bugs in specific vuln classes | 24 `hunt-*` skills + 7 enterprise-platform skills (M365/Okta/cloud-IAM/vCenter/VPN/SharePoint/APK) + `security-arsenal` |
+| **3. Hunt** | Active testing for bugs in specific vuln classes | 58 `hunt-*` skills + 7 enterprise-platform skills (M365/Okta/cloud-IAM/vCenter/VPN/SharePoint/APK) + `security-arsenal` |
| **4. Validate** | Decide whether a lead is actually a reportable bug | `triage-validation` (7-Question Gate) via `/triage` or `/validate` |
| **5. Capture** | PoC screenshots, HAR files, evidence redaction | `evidence-hygiene` |
| **6. Report** | Draft and submit | `report-writing`, `bugcrowd-reporting` |
@@ -168,7 +168,7 @@ See [docs/architecture.md](docs/architecture.md) for a more detailed breakdown.
---
-## 2. Skill inventory (82 skills total)
+## 2. Skill inventory (83 skills total)
### Workflow skills — the spine of any engagement
@@ -186,7 +186,7 @@ See [docs/architecture.md](docs/architecture.md) for a more detailed breakdown.
| `web2-recon` | Subdomain enumeration, host discovery, URL crawling | "find all subdomains of X" |
| `bb-local-toolkit` | Router for local cloned bug-bounty repos | "which tool for X", refers to local stack |
-### Hunt — 57 per-class web skills
+### Hunt — 58 per-class web skills
Each focuses on one vulnerability class with detection patterns, payloads, bypass tables, and chain opportunities drawn from disclosed bug-bounty reports.
@@ -219,6 +219,7 @@ Each focuses on one vulnerability class with detection patterns, payloads, bypas
| `hunt-sharepoint` | SharePoint on-prem (ToolShell chain, anon SOAP, SafeControl enum, FormDigest) |
| `hunt-ntlm-info` | NTLM Type-2 anonymous AD topology disclosure |
| `hunt-misc` | Catch-all for less-common classes |
+| `hunt-fintech-graphql` | Money-movement GraphQL mutations, ledger IDOR, decimal-precision abuse, idempotency-key bypass |
Plus `hunt-dispatch` — the meta-router that the `/hunt` slash command uses to pick Red Team vs WAPT mode and load the right skill set.
@@ -397,7 +398,7 @@ Cross-reference this UUID in any chained submissions you file later.
If another pentester wants to replicate this stack, the install steps are in [INSTALL.md](INSTALL.md). The short version:
1. Clone this repo
-2. Run the installer — `bash scripts/install.sh` (macOS/Linux) or `pwsh ./scripts/install.ps1` (Windows) — installs all 82 skills, 15 commands, and the `hunt` scaffold in one step
+2. Run the installer — `bash scripts/install.sh` (macOS/Linux) or `pwsh ./scripts/install.ps1` (Windows) — installs all 83 skills, 15 commands, and the `hunt` scaffold in one step
3. Set up Burp MCP (BApp Store extension + `claude mcp add burp ...`)
4. (Optional) Refresh upstream snapshots via `./scripts/install-community-skills.sh` (macOS/Linux) or `pwsh ./scripts/install-community-skills.ps1` (Windows)
5. (Optional) Set up the skill regenerator with Anthropic + H1 API keys
diff --git a/docs/architecture.md b/docs/architecture.md
index 6234ad2..19cc82b 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -4,15 +4,15 @@ The Claude-BugHunter bundle maps to a 6-phase workflow that supports both bug hu
## Primary view — phase-by-phase architecture
-82 skills mapped to 6 phases, with a 57-skill `hunt-*` sub-stack, an 8-skill enterprise-platform attack layer, integration layer, and usage decision tree. This is the main reference for "which skill do I use when?".
+83 skills mapped to 6 phases, with a 58-skill `hunt-*` sub-stack, an 8-skill enterprise-platform attack layer, integration layer, and usage decision tree. This is the main reference for "which skill do I use when?".
![architecture overview](assets/architecture-overview.svg)
-The "Source" column in the per-phase tables below tags each skill: **`original`** = author's work in this repo, `community` = community-contributed (v3), `vendored` = from [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) (MIT). Of 82 skills: 54 original, 20 community (v3), 8 vendored.
+The "Source" column in the per-phase tables below tags each skill: **`original`** = author's work in this repo, `community` = community-contributed (v3), `vendored` = from [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) (MIT). Of 83 skills: 55 original, 20 community (v3), 8 vendored.
## Alternate view — 3-layer capability stack
-The same 82 skills, regrouped by **role in an engagement** rather than by phase. Methodology + Recon (bottom) feeds the Hunt Arsenal (middle), which produces findings that flow up through Ship It (top) to a paid submission or client deliverable.
+The same 83 skills, regrouped by **role in an engagement** rather than by phase. Methodology + Recon (bottom) feeds the Hunt Arsenal (middle), which produces findings that flow up through Ship It (top) to a paid submission or client deliverable.
![capability map](assets/capability-map.svg)
@@ -55,12 +55,12 @@ The 6-phase workflow expanded into a pipeline showing per-phase active skills, t
| Skill | Source | Purpose |
|---|---|---|
-| **57 `hunt-*` skills** | original + community | Per vuln class / framework, curated from disclosed H1 reports + v3 community expansion — auto-trigger by topic |
+| **58 `hunt-*` skills** | original + community | Per vuln class / framework, curated from disclosed H1 reports + v3 community expansion — auto-trigger by topic |
| `security-arsenal` | vendored | Payload library (XSS / SSRF / SQLi / SSTI / etc.) |
| `web3-audit` | vendored | Smart-contract audit (10 bug classes, Foundry PoC) |
| `meme-coin-audit` | vendored | Token rug-pull detection |
-### Per-class hunt skills (57)
+### Per-class hunt skills (58)
```
hunt-api-misconfig hunt-mfa-bypass
@@ -93,7 +93,7 @@ hunt-jwt-crypto hunt-forgot-password
hunt-shadow-api hunt-exceptional-conditions
hunt-spa-api hunt-captcha-bypass
hunt-rag-vector hunt-clickjacking
-hunt-html-injection
+hunt-html-injection hunt-fintech-graphql
```
Plus alternates: `hunt-cache-poison`, `hunt-race-condition`, `hunt-subdomain`. Plus the meta-router `hunt-dispatch` (used internally by the `/hunt` slash command — not user-invoked).
diff --git a/docs/credits.md b/docs/credits.md
index 8c6b874..2192175 100644
--- a/docs/credits.md
+++ b/docs/credits.md
@@ -10,11 +10,11 @@ This is a **bundle**: skills and commands are vendored directly into `skills/` a
| Category | Count | Source |
|---|---|---|
-| **Original / personally-curated skills** | 54 | This repo |
+| **Original / personally-curated skills** | 55 | This repo |
| Community-contributed skills (v3) | 20 | community PRs (e.g. #7) |
| Vendored foundation skills | 8 | shuvonsec/claude-bug-bounty (MIT) |
| Vendored slash commands | 12 | shuvonsec/claude-bug-bounty (MIT) |
-| **Total** | 82 skills + 15 commands | |
+| **Total** | 83 skills + 15 commands | |
---
@@ -79,7 +79,7 @@ Built from authorized red-team engagements (enterprise targets including on-prem
### Tooling and docs
- **`hunt <target>` command** — Engagement-folder scaffolding: creates `~/Targets/<name>/` with `CLAUDE.md`, `scope.md`, `findings/`, `evidence/`, `submissions.txt`, `notes.md`, and a sensible `.gitignore` for engagement artifacts. Ships as `scripts/hunt.sh` (bash) and `scripts/hunt.ps1` (PowerShell).
-- **Bundle packaging** — Single-step installer that copies all 82 skills, 15 commands, and the hunt scaffold into `~/.claude/`: `scripts/install.sh` (macOS/Linux) and `scripts/install.ps1` (Windows/PowerShell).
+- **Bundle packaging** — Single-step installer that copies all 83 skills, 15 commands, and the hunt scaffold into `~/.claude/`: `scripts/install.sh` (macOS/Linux) and `scripts/install.ps1` (Windows/PowerShell).
- **Autopilot ledger (`engine/memory.py`) + the `/remember`, `/memory-gc`, `/pickup` commands** — Original design and implementation (cross-engagement capture + skip-decision for the engine hunt loop). Not derived from any external memory implementation.
- **`assets/banner-v2.svg`** — Hand-coded SVG banner.
- **Documentation** — `README.md`, `INSTALL.md`, `USAGE.md`, `CONTRIBUTING.md`, `docs/architecture.md`, this credits file.
diff --git a/docs/index.md b/docs/index.md
index 8867eff..a3b760c 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -22,7 +22,7 @@ platform CVE chains, and the hygiene, and it stays in scope.
## What you get
-- **82 skills** across recon, 57 web-app vuln-class + framework skills, enterprise
+- **83 skills** across recon, 58 web-app vuln-class + framework skills, enterprise
platform attack, red-team tradecraft, and reporting — all **auto-loading by topic**,
no invocation by name.
- **681 disclosed-report patterns** curated from public HackerOne reports.
diff --git a/docs/multi-harness.md b/docs/multi-harness.md
index b9839c4..939f145 100644
--- a/docs/multi-harness.md
+++ b/docs/multi-harness.md
@@ -6,9 +6,9 @@ description: Run the Claude-BugHunter skills on OpenCode, Codex, and Hermes Agen
# Multi-harness install
-The 82 skills are plain **Agent Skills** (`SKILL.md` = `name` + `description` frontmatter + Markdown). That format is an open standard, so the *knowledge* runs on more than Claude Code. This page shows how to install it on **OpenCode**, **OpenAI Codex CLI**, and **Hermes Agent**.
+The 83 skills are plain **Agent Skills** (`SKILL.md` = `name` + `description` frontmatter + Markdown). That format is an open standard, so the *knowledge* runs on more than Claude Code. This page shows how to install it on **OpenCode**, **OpenAI Codex CLI**, and **Hermes Agent**.
-> **What ports and what doesn't.** The **82 skills** (payloads, methodology, bypass tables, disclosed-report patterns) port to every harness below. The **`/hunt` slash commands, the plugin marketplace, and the `hunt-dispatch` subagent routing are Claude-Code-specific** and do **not** port — other harnesses get the knowledge, not the orchestration engine. **Burp MCP** ports to all of them (it's just an MCP server).
+> **What ports and what doesn't.** The **83 skills** (payloads, methodology, bypass tables, disclosed-report patterns) port to every harness below. The **`/hunt` slash commands, the plugin marketplace, and the `hunt-dispatch` subagent routing are Claude-Code-specific** and do **not** port — other harnesses get the knowledge, not the orchestration engine. **Burp MCP** ports to all of them (it's just an MCP server).
## Compatibility matrix (verified mid-2026)
@@ -56,7 +56,7 @@ pwsh ./scripts/install.ps1 -Hermes # + Hermes Agent (~/.hermes/skills)
```
- **OpenCode** already reads `~/.claude/skills/`, so the plain installer (no flags) is enough for OpenCode — you don't need `--agents`/`-Agents` for it. That flag exists mainly for **Codex** (which reads only `~/.agents/skills/`).
- - *Caveat (verified):* OpenCode reads **both** `~/.claude/skills/` and `~/.agents/skills/`. If both are populated (e.g. you ran `--all`/`-All` for Codex too), OpenCode logs harmless `duplicate skill name` warnings and loads one copy — all 82 skills still work. Only populate `~/.agents/skills/` if you actually use Codex.
+ - *Caveat (verified):* OpenCode reads **both** `~/.claude/skills/` and `~/.agents/skills/`. If both are populated (e.g. you ran `--all`/`-All` for Codex too), OpenCode logs harmless `duplicate skill name` warnings and loads one copy — all 83 skills still work. Only populate `~/.agents/skills/` if you actually use Codex.
- **Codex is the strict parser** (verified by testing): it hard-rejects descriptions > 1024 chars and invalid YAML, where Claude/OpenCode/Hermes are lenient. So the installer **auto-truncates** any description > 1024 to ≤1024 **only in the `~/.agents/skills` (Codex) copy** — your `~/.claude` and `~/.hermes` copies keep the full descriptions (incl. non-English trigger words). The install logs which were truncated (today: the 3 aggregator router skills). `--normalize-frontmatter` (`-NormalizeFrontmatter`) additionally strips the non-standard `sources:`/`report_count:` keys (optional — Codex tolerates them).
## Burp MCP on other harnesses
diff --git a/docs/skills.md b/docs/skills.md
index c1306a3..61a0dc9 100644
--- a/docs/skills.md
+++ b/docs/skills.md
@@ -6,11 +6,11 @@ description: Searchable index of every skill in the bundle.
# Skill catalog
-All **82 skills** in the bundle, grouped by domain. Each auto-loads when your prompt matches its trigger keywords — no need to invoke by name. Use your browser's find (⌘/Ctrl-F) or the docs search box.
+All **83 skills** in the bundle, grouped by domain. Each auto-loads when your prompt matches its trigger keywords — no need to invoke by name. Use your browser's find (⌘/Ctrl-F) or the docs search box.
> Generated by `scripts/gen_skill_catalog.py` — do not edit by hand.
-## Hunt — web app vuln classes (57)
+## Hunt — web app vuln classes (58)
| Skill | What it does | Reports |
|---|---|---|
@@ -32,6 +32,7 @@ All **82 skills** in the bundle, grouped by domain. Each auto-loads when your pr
| `hunt-dom` | Hunt client-side DOM vulnerabilities — DOM Clobbering (overwrite JS globals via HTML injection), PostMessage hijacking (missing origin check), Service Worker abuse (intercept requests from same-origin script), CSS Injection/Exfiltration… | 17 |
| `hunt-exceptional-conditions` | Hunt mishandling of exceptional conditions — feed an endpoint malformed/unexpected input (wrong type, broken JSON, oversized field, null byte) and make it fail OPEN or leak internals: a verbose stack-trace / framework error page that… | — |
| `hunt-file-upload` | Hunt file upload bugs — RCE via webshell, XSS via SVG/HTML, SSRF via XXE in DOCX, path traversal via filename. | — |
+| `hunt-fintech-graphql` | Hunt fintech-specific GraphQL vulnerabilities: money-movement mutations (transfers, redemptions, withdrawals, card top-ups), ledger/balance/portfolio query IDOR, decimal-precision and rounding abuse, idempotency-key bypass enabling… | 0 |
| `hunt-forgot-password` | Hunt Forgot Password / Account Recovery Authentication Flaws — 5 distinct patterns: (1) username enumeration via different responses for valid vs invalid email, (2) reset token exposed directly in the API response body, (3) reset token not… | — |
| `hunt-graphql` | Hunting skill for graphql vulnerabilities. | 12 |
| `hunt-grpc` | Hunt gRPC vulnerabilities — server reflection enabled (enumerate all services/methods), missing authentication / metadata-stripping on internal endpoints, plaintext gRPC over HTTP/2, internal endpoint disclosure, proto file leakage,… | 6 |
diff --git a/scripts/check_doc_counts.py b/scripts/check_doc_counts.py
new file mode 100644
index 0000000..c1c606c
--- /dev/null
+++ b/scripts/check_doc_counts.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+check_doc_counts.py — verify skill/command counts in docs match what's on disk.
+
+The bundle's skill/command counts have grown several times (skills: 51 -> 71 ->
+82; hunt-* skills: 24 -> 48 -> 57) and each time, at least one doc's hardcoded
+number didn't get updated along with the rest (see the 71/48/24 stale-count
+fixes). This script computes the real counts from skills/ and commands/ on
+disk, then checks every doc location that asserts one of those numbers in
+prose, plus two places where a count is derived by summing a table/section
+breakdown.
+
+It deliberately does NOT try to reconcile every document's bespoke
+sub-categorization (e.g. docs/architecture.md's narrower "enterprise-platform"
+grouping vs. docs/skills.md's generated one) — only the three ground-truth
+totals: all skills, hunt-* skills, and slash commands.
+
+If a doc's wording changes, update CHECKS to match — a "pattern not found"
+error is a prompt to update this script, not necessarily a doc bug.
+
+Exit code 0 = all counts match, 1 = at least one mismatch.
+Stdlib only — no pip install needed in CI.
+
+Usage:
+ python3 scripts/check_doc_counts.py
+"""
+import os
+import re
+import sys
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SKILLS_DIR = os.path.join(REPO, "skills")
+COMMANDS_DIR = os.path.join(REPO, "commands")
+
+
+def count_skills():
+ total = 0
+ hunt = 0
+ for d in sorted(os.listdir(SKILLS_DIR)):
+ if os.path.isfile(os.path.join(SKILLS_DIR, d, "SKILL.md")):
+ total += 1
+ if d.startswith("hunt-"):
+ hunt += 1
+ return total, hunt
+
+
+def count_commands():
+ return len([f for f in os.listdir(COMMANDS_DIR) if f.endswith(".md")])
+
+
+def read(path):
+ with open(os.path.join(REPO, path), encoding="utf-8") as fh:
+ return fh.read()
+
+
+# (file, regex with one capture group per checked number, key or tuple of keys
+# into the `actual` dict, human label for error messages)
+CHECKS = [
+ ("README.md", r"\*\*(\d+) skills\*\* · 15 slash commands", "total", "hero line skill count"),
+ ("README.md", r"skills\*\* · (\d+) slash commands ·", "commands", "hero line command count"),
+ ("README.md", r"\| (\d+) skills \+ (\d+) slash commands \|", ("total", "commands"), "install-path comparison table"),
+ ("README.md", r"\*\*(\d+) skills\*\*, auto-loaded", "total", "'What's inside' intro"),
+ ("README.md", r"(\d+) `hunt-\*` skills curated from", "hunt", "'Hunt webapps' bullet"),
+ ("README.md", r"Also ships \*\*(\d+) slash commands\*\*", "commands", "documentation table footer"),
+ ("README.md", r"\(8 of (\d+) skills \+ (\d+) slash commands\)", ("total", "commands"), "vendored-foundation credit"),
+ ("SECURITY.md", r"installing (\d+) `SKILL\.md` files", "total", "supply-chain-trust intro"),
+ ("USAGE.md", r"the (\d+)-skill Claude-BugHunter bundle", "total", "doc intro"),
+ ("USAGE.md", r"copies (\d+) skills \+ (\d+) commands into Claude Code", ("total", "commands"), "quickstart code block"),
+ ("USAGE.md", r"(\d+) `hunt-\*` skills \+ \d+ enterprise-platform skills", "hunt", "phase-3 architecture table row"),
+ ("USAGE.md", r"### Hunt — (\d+) per-class web skills", "hunt", "skill-inventory section header"),
+ ("USAGE.md", r"installs all (\d+) skills, (\d+) commands", ("total", "commands"), "setup-for-someone-new summary"),
+ ("INSTALL.md", r"All (\d+) skills →", "total", "what-gets-installed list"),
+ ("docs/skills.md", r"All \*\*(\d+) skills\*\* in the bundle", "total", "catalog intro"),
+ ("docs/skills.md", r"## Hunt — web app vuln classes \((\d+)\)", "hunt", "catalog Hunt section header"),
+ ("docs/credits.md", r"\| \*\*Total\*\* \| (\d+) skills \+ (\d+) commands \|", ("total", "commands"), "credits breakdown total row"),
+ ("docs/architecture.md", r"(\d+) skills mapped to 6 phases", "total", "doc intro"),
+ ("docs/architecture.md", r"a (\d+)-skill `hunt-\*` sub-stack", "hunt", "doc intro"),
+ ("docs/architecture.md", r"Of (\d+) skills: \d+ original", "total", "source-breakdown sentence"),
+ ("docs/architecture.md", r"\*\*(\d+) `hunt-\*` skills\*\* \| original \+ community", "hunt", "phase-3 detail table"),
+]
+
+
+def check_assertions(actual):
+ errors = []
+ for file, pattern, key, label in CHECKS:
+ text = read(file)
+ m = re.search(pattern, text)
+ if not m:
+ errors.append(
+ f"{file}: pattern not found for '{label}' ({pattern}) — "
+ f"doc wording changed, update scripts/check_doc_counts.py"
+ )
+ continue
+ keys = key if isinstance(key, tuple) else (key,)
+ for i, k in enumerate(keys):
+ got = int(m.group(i + 1))
+ want = actual[k]
+ if got != want:
+ errors.append(f"{file}: '{label}' says {got} but actual {k} count is {want}")
+ return errors
+
+
+def check_readme_table_sum(errors, actual):
+ """README's 'What's inside' category table must sum to the total skill count."""
+ text = read("README.md")
+ m = re.search(r"\| Category \| # \| Examples \|\n\|[-| ]+\n((?:\|.*\n)+)", text)
+ if not m:
+ errors.append("README.md: could not locate 'What's inside' category table to sum")
+ return
+ total = 0
+ for row in m.group(1).strip("\n").split("\n"):
+ cells = [c.strip() for c in row.strip("|").split("|")]
+ if len(cells) >= 2 and cells[1].isdigit():
+ total += int(cells[1])
+ if total != actual["total"]:
+ errors.append(f"README.md: 'What's inside' category table sums to {total}, actual total is {actual['total']}")
+
+
+def check_catalog_section_sum(errors, actual):
+ """docs/skills.md's generated section headers ('## Name (N)') must sum to the total."""
+ text = read("docs/skills.md")
+ counts = [int(n) for n in re.findall(r"^## .+\((\d+)\)\s*$", text, re.MULTILINE)]
+ total = sum(counts)
+ if total != actual["total"]:
+ errors.append(f"docs/skills.md: section headers sum to {total}, actual total is {actual['total']}")
+
+
+def main():
+ total, hunt = count_skills()
+ commands = count_commands()
+ actual = {"total": total, "hunt": hunt, "commands": commands}
+
+ errors = check_assertions(actual)
+ check_readme_table_sum(errors, actual)
+ check_catalog_section_sum(errors, actual)
+
+ for e in errors:
+ print(f"::error:: {e}" if os.environ.get("GITHUB_ACTIONS") else f"ERROR {e}")
+
+ print(f"\nGround truth: {total} skills ({hunt} hunt-*), {commands} slash commands.")
+ print(f"Checked {len(CHECKS)} doc assertions + 2 structural sums: {len(errors)} error(s).")
+ return 1 if errors else 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/skills/hunt-fintech-graphql/SKILL.md b/skills/hunt-fintech-graphql/SKILL.md
new file mode 100644
index 0000000..23a1cbc
--- /dev/null
+++ b/skills/hunt-fintech-graphql/SKILL.md
@@ -0,0 +1,245 @@
+---
+name: hunt-fintech-graphql
+description: "Hunt fintech-specific GraphQL vulnerabilities: money-movement mutations (transfers, redemptions, withdrawals, card top-ups), ledger/balance/portfolio query IDOR, decimal-precision and rounding abuse, idempotency-key bypass enabling double-spend, KYC/PII field-level authorization gaps, and admin-override mutations reachable via mass assignment. Distinct from hunt-graphql, which owns generic GraphQL discovery and IDOR/mutation methodology — this skill owns the delta introduced when a GraphQL layer sits in front of a ledger, wallet, payments, banking, brokerage, or lending backend, where a resolver bug moves real money instead of just leaking data. Use when hunting a fintech, banking, payments, wallet, neobank, brokerage, or lending target that exposes a GraphQL API, or when a schema/response includes balance, transfer, ledger, redeem, quote, KYC, or account-linking fields."
+sources: owasp_api_top10_2023, public_research
+report_count: 0
+---
+
+## Why Fintech GraphQL Is a Different Risk Class
+
+Generic GraphQL bugs (IDOR, mass assignment, introspection, batching abuse — see `hunt-graphql`)
+still apply here, but the blast radius changes completely: a resolver bug in a SaaS app leaks
+data, the same class of bug in a ledger mutation **moves money**. Three properties make fintech
+GraphQL backends a distinct hunting surface:
+
+- **Money-movement mutations are almost always resolvers over a double-entry ledger.** A single
+ GraphQL mutation (`transferFunds`, `redeemRewards`, `withdrawToBank`) can trigger multiple
+ ledger writes (debit + credit + fee) that must be atomic. GraphQL's flexible input shape and
+ alias batching make it easy to desynchronize those writes.
+- **Decimals are attacker-controlled input, not display formatting.** Amounts, exchange rates,
+ interest, and rewards points are usually passed as GraphQL scalars (`Float`, `String`, custom
+ `Decimal`/`Money` scalar). How the resolver parses and rounds that value is exploitable surface
+ in its own right — this barely exists in non-financial GraphQL APIs.
+- **KYC/PII fields sit next to routine account fields in the same type.** `User` or `Account`
+ types commonly expose `ssnLast4`, `routingNumber`, `kycStatus`, `governmentIdUrl`, or
+ `linkedBankAccount` alongside `displayName` and `email` — one missing field-level authorization
+ check on a type used everywhere in the schema fans out to every query that touches it.
+
+---
+
+## Attack Surface Signals
+
+**URL / schema naming patterns (in addition to `hunt-graphql`'s generic `/graphql` list):**
+```
+/graphql/ledger
+/graphql/payments
+/api/wallet/graphql
+/internal/ledger-graphql
+/banking/graphql
+```
+
+**Field/type names worth grepping schema introspection or JS bundles for:**
+```
+balance, availableBalance, pendingBalance, ledgerEntry, ledgerEntries
+transferFunds, withdraw, redeem, topUp, reverseTransaction, adjustBalance
+kycStatus, ssnLast4, routingNumber, accountNumber, governmentIdUrl
+quoteExchangeRate, interestAccrued, rewardsPoints, portfolioValue
+idempotencyKey, clientMutationId
+```
+
+**Tech-stack tells specific to this vertical:**
+- Plaid/Stripe/Dwolla/Marqeta wrapped behind an internal GraphQL gateway (`bankLink`, `plaidLinkToken` mutations)
+- Apollo Federation with a dedicated `ledger` or `payments` subgraph — check for the subgraph's own introspection being reachable directly, bypassing the gateway's stitched-down schema
+- Custom `Money`/`Decimal`/`BigDecimal` GraphQL scalar in the schema (`scalar Money`) — the parser for this scalar is worth fuzzing directly
+
+Run `hunt-graphql`'s discovery + introspection methodology first to get the schema; everything
+below assumes you already have (or have partially enumerated) a schema with money-movement types.
+
+---
+
+## Step-by-Step Hunting Methodology
+
+1. **Map every mutation that touches balance, whether directly or as a side effect.** Not just
+ `transfer*`/`withdraw*` — also `redeemRewards`, `applyCoupon`, `upgradeTier`,
+ `closeAccount` (often refunds a balance), `disputeTransaction` (often provisionally credits).
+
+2. **For each money-movement mutation, identify the ledger write shape.** Does one mutation call
+ produce one ledger entry or several (debit sender, credit receiver, fee entry)? Multi-entry
+ writes are the ones worth racing — see Stage 4.
+
+3. **Test idempotency-key handling.** Send the identical mutation (same `idempotencyKey` /
+ `clientMutationId`) twice, back-to-back and with a delay. A ledger write on the second call
+ means idempotency isn't enforced server-side — replay = double-execute.
+
+4. **Test decimal/precision edge cases** on every amount-accepting argument — see Payload section.
+ Confirm server-side rounding matches client-displayed rounding; a mismatch is directly
+ monetizable.
+
+5. **Probe cross-account IDOR on account/portfolio node IDs**, same as `hunt-idor`/`hunt-graphql`,
+ but specifically test whether a `transferFunds`-style mutation validates that the
+ **source account belongs to the authenticated caller** — not just that *some* account with
+ that ID exists. This is the fintech-specific IDOR: authz on the *source* of a debit is easy to
+ forget when authz on the *destination* of a credit was correctly implemented (crediting an
+ arbitrary account "looks safe" to a developer; debiting one clearly isn't, so it gets checked
+ — but sometimes only one direction does).
+
+6. **Check field-level authorization on KYC/PII fields** by querying the shared `User`/`Account`
+ type from every context that returns it — not just the profile screen. A `transaction` type
+ that embeds `counterparty { ssnLast4 }` is a common place for the check to be missing, because
+ the developer authorized the top-level `transaction` query but didn't re-check field access on
+ the nested `counterparty`.
+
+7. **Look for admin-tier mutations reachable via mass assignment**, not just a missing auth
+ check — e.g. an input object with a client-settable `status` or `override` field that a normal
+ user's mutation shouldn't expose but that the resolver accepts anyway
+ (`updateTransaction(input: {id, status: "COMPLETED", amount: "..."})`).
+
+8. **Test currency-argument consistency.** Send a transfer/quote mutation with mismatched
+ `sourceCurrency`/`targetCurrency` combinations the UI never generates (e.g. self-transfer with
+ a currency conversion) and check whether the resolver's FX-rate lookup and the ledger write use
+ the same rate — a TOCTOU window here is a direct arbitrage bug.
+
+9. **Combine alias batching with money-movement mutations** to test for double-spend — see
+ `hunt-race-condition` for the parallel-HTTP escalation once alias batching alone confirms the
+ resolver isn't serializing writes per-account.
+
+---
+
+## Payload & Detection Patterns
+
+**Idempotency-key replay test:**
+```graphql
+mutation {
+ transferFunds(input: {
+ idempotencyKey: "test-key-001"
+ sourceAccountId: "acc_1"
+ destAccountId: "acc_2"
+ amount: "10.00"
+ }) { transactionId status }
+}
+```
+Send twice with the identical `idempotencyKey`. Two successful, distinct `transactionId` values
+= idempotency not enforced.
+
+**Decimal-precision / rounding probes:**
+```graphql
+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "0.001"}) { transactionId } }
+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "9999999999999999.99"}) { transactionId } }
+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "1e2"}) { transactionId } }
+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "-50.00"}) { transactionId } }
+```
+Sub-cent amounts test truncate-vs-round handling (repeat N times to accumulate a rounding-error
+balance drift); scientific notation and oversized values test whether the `Money`/`Decimal`
+scalar parser falls back to a native float/int with overflow or precision-loss behavior; negative
+amounts test whether the resolver assumes sign server-side or trusts the client's.
+
+**Alias-batched double-spend probe (confirm before escalating to parallel HTTP):**
+```graphql
+mutation {
+ r1: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }
+ r2: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }
+ r3: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }
+}
+```
+If more than one alias succeeds against a single-use reward/coupon, the resolver doesn't
+serialize per-account/per-resource writes within a batched request — see `hunt-race-condition`
+for combining this with parallel HTTP POSTs to confirm real double-spend impact.
+
+**Source-account authorization probe (asymmetric IDOR check):**
+```graphql
+mutation {
+ transferFunds(input: {
+ sourceAccountId: "VICTIM_ACCOUNT_ID"
+ destAccountId: "ATTACKER_CONTROLLED_ACCOUNT_ID"
+ amount: "1.00"
+ }) { transactionId status }
+}
+```
+Run as the attacker's own session/token. Success = the resolver validated the destination is
+attacker-controlled (obviously required) but never validated that the source belongs to the
+caller.
+
+**Nested field-level PII probe:**
+```graphql
+query {
+ transaction(id: "txn_123") {
+ amount
+ counterparty { displayName ssnLast4 routingNumber kycStatus }
+ }
+}
+```
+Query as a user with no relationship to the counterparty beyond a shared transaction; success on
+the nested PII fields is the finding even if the top-level `transaction` query correctly scoped
+the transaction itself.
+
+**Mass-assignment probe on admin-shaped input fields:**
+```graphql
+mutation {
+ updateTransaction(input: {id: "txn_123", status: "COMPLETED", amount: "0.01"}) { id status }
+}
+```
+Send as a non-admin user against a mutation the client UI never exposes these fields for; a
+schema that accepts them anyway is mass assignment onto ledger state.
+
+---
+
+## Common Root Causes
+
+1. **Client-side amount/fee validation only.** The UI computes and displays the correct amount;
+ the resolver trusts whatever the GraphQL client actually sends, because "the app always sends
+ the right value."
+2. **Non-atomic multi-entry ledger writes.** Debit, credit, and fee entries are written as
+ separate sequential statements instead of inside a single transaction/lock — the race window
+ this creates is exactly what alias batching + parallel HTTP exploits.
+3. **`Money`/`Decimal` scalar falls back to native float parsing** under edge-case input
+ (scientific notation, oversized strings), reintroducing floating-point rounding error into a
+ system that was supposed to guarantee fixed-point precision.
+4. **Idempotency keys are stored but never checked before executing the write** — the key is
+ logged for support/debugging purposes, not used as a dedup gate.
+5. **Field-level authorization implemented per top-level query, not per type.** A `User`/`Account`
+ type's sensitive fields are protected when queried directly (`me { ssnLast4 }`) but not when
+ the same type is returned nested inside an unrelated query (`transaction { counterparty {...} }`).
+6. **Source-account ownership check missing while destination-account existence check is
+ present** — see methodology step 5. Debiting looks dangerous so it gets reviewed; the "does
+ this account belong to the caller" check quietly only gets applied to the credited side.
+7. **Admin/internal mutations reuse the same input type as the public mutation**, just with extra
+ optional fields — nothing at the resolver layer strips those fields for non-admin callers.
+
+---
+
+## Gate 0 Validation
+
+Money-movement findings need a stricter bar than a typical GraphQL IDOR — "the query returns
+someone else's balance" is real impact; "I sent a malformed amount and got a 400" is not.
+
+1. **Did an actual ledger write occur, and can you show it?** Query the account balance before
+ and after — a state change (not just a `200`/success response body) is the proof.
+2. **Is the win deterministic, not a timing fluke?** For race/double-spend findings, reproduce
+ twice from a clean state. If it only works under specific load conditions, document the window
+ honestly rather than claiming guaranteed exploitability.
+3. **Does the finding move value the attacker didn't have, or reveal data they shouldn't see** —
+ not just "the mutation accepted an unexpected input type and the API returned an error
+ message." A verbose GraphQL error leaking a stack trace on a malformed `Money` scalar is a
+ `hunt-source-leak`-class finding, not a fintech-logic one — don't conflate the two in a report.
+
+---
+
+## Related Skills & Chains
+
+- **`hunt-graphql`** — parent skill for generic GraphQL discovery, introspection bypass, node-ID
+ IDOR, and alias-batching mechanics. Load this skill first; `hunt-fintech-graphql` assumes that
+ methodology and only adds the money-movement-specific delta.
+- **`hunt-business-logic`** — coupon/reward double-redemption and other logic-flaw patterns
+ generalize directly to `redeemRewards`/`applyCoupon`-style mutations here.
+- **`hunt-race-condition`** — the escalation path once alias batching alone confirms a
+ money-movement mutation doesn't serialize writes: combine with parallel-HTTP / single-packet
+ attack for a deterministic double-spend PoC.
+- **`hunt-api-misconfig`** — mass assignment and JWT-claim tampering patterns apply directly to
+ admin-shaped GraphQL input objects reachable by normal users.
+- **`hunt-idor`** — the source-account-vs-destination-account asymmetric authz pattern (step 5) is
+ a fintech-specific instance of the general IDOR-on-mutation-argument class.
+- **`evidence-hygiene`** — balance screenshots and ledger-entry PoCs need the same cookie/PII
+ redaction discipline as any other capture, plus care that a real account number/balance from a
+ live financial account is never included verbatim.
+- **`triage-validation`** — apply Gate 0 above before drafting; a fintech program's triage team
+ will kill anything without a demonstrated ledger state change immediately.