Hunt: Core
Current emphasis (update on wiki harvest): clean-session re-verification and proven-observable channels for negative results over response-body inference
- models over-index on over-represented old methods; the newest harvested technique leads the checklist until superseded.
The discipline every hunt-* skill assumes. Class-specific technique lives in the hunt skills and
the wiki; this file holds what is true regardless of which bug class you are chasing.
Owned here, never repeated in a hunt skill: the scope gate, two-account setup, confirmation gate, enumeration limits, stop conditions, marker discipline, wiki query/self-heal protocol, FIND output, Deadends, and distillation. A hunt skill that restates any of these will drift from this one; reference it instead.
Scope gate
Hunting means reading other people's data, escalating privileges, and creating accounts. Outside an authorized engagement all of it is a crime. Before any request leaves the machine:
- Authorization - a program with the target in scope, a signed agreement, your own lab, or a CTF. "Probably fine" is not authorization.
- Scope - exact hosts.
*.target.comdoes not covertargetapp.io, an acquisition, ortarget.com.cdn.net. Readtargets/<eng>/scope.md. An in-scope entry may carry a trailing comment restricting it to a PATH (e.g.events.example.com # IN for the hub endpoint only) - match the annotation, not just the host: a bare host-match against a path-restricted entry is out-of-scope traffic even though the shim passes it. - Exclusions and forbidden techniques - check
no_bruteforce, scanning caps, DoS, social engineering, and any per-program rule before the technique that would violate it. - Two accounts, both yours - see below. Required for any authorization-class bug.
- Deadends - read
targets/<eng>/Deadends.mdand skip what is already exhausted.
Unconfirmed on any of these: ask. Do not infer scope from the fact that a host resolved. Discovery
is not authorization. The scope-guard hook enforces the host check on Bash commands; it is a
backstop, not the gate.
Tool row: before Step 1 of any class hunt, read your class row in
scripts/playbook.json classes - it names the primary tools and the
payload page. Use those tools unless the target shape forbids it; note a
deviation in the run notes with one line of why.
Two-account rule
Authorization findings are "account A reached account B's object." Without B you have two bad options: test against a real user, or report a guess. Both are worse than not reporting.
- User A - resource owner. User B - attacker. Separate browser profiles so cookies never cross.
- Record both internal IDs in
targets/<eng>/identities.mdas you discover them. - Cross-tenant work needs two tenants, not two users in one. Many apps isolate tenants correctly and users not at all.
Confirmation gate
Nothing becomes a FIND on the strength of a response body. The gate is per class; the hunt skill owns the specific "NOT confirmation / IS confirmation" list. Universal rules:
- Re-verify in a clean session. Fresh token, new profile, no cached state. If the effect vanishes, you changed your own screen.
- Exercise the capability. Not "the server accepted it" but perform the action only the new state permits.
- Rule out legitimate access. Before claiming cross-account access, confirm A is not supposed to see it: shared teams, sharing links, public objects, org-wide visibility. The most common false positive in authorization testing.
- Blind classes need an OOB HIT. No inference-only findings. The
oob.mdrow must flip to HIT before a FIND is scaffolded. - Reproduce from scratch against your own written steps.
- A negative result needs a proven-observable channel. "No callback / no hits" only means something if the channel itself is proven to work: a listener that file-logs AND you have actually read, or a self-test hit on the same path. An unobservable channel (a tmux pane that captures empty, a log you never opened) produces false negatives that fossilize into dead-ends and "it was patched" verdicts.
Failed 1-3 is a Deadend, not a "probably real but hard to prove."
[[wiki/techniques/methodology/safe-probing-and-controls]] carries the other half of this gate: how to probe destructive or sensitive surface without touching a real record (use an identifier proven not to exist), and how to fire a control so a NEGATIVE result means something instead of being assumed.
When the hunt spans many hosts, sessions, or parallel agents, the coordination layer adds failure modes this gate does not cover: claims nobody re-checked, requests nobody counted, the same finding filed twice, and severity drifting upward as work is summarised. See [[wiki/techniques/methodology/multi-agent-campaign-orchestration]].
Request history discipline
(NOTE: hunt-core itself keeps NO request ledger or run checklist BY DESIGN - it is the always-loaded discipline hub, not a dispatched lane; the ledger contract below binds the hunt-* skills it loads.)
Lane contract (G9): a lane that recorded 2+ findings runs the triage skill's Cross-tool correlation pass over nuclei + burp/caido + manual records before it closes; an uncorrelated close is an UNCHECKED step, same standing as an unchecked request-ledger row.
$ENG_DIR/_requests.md is the shared append-only HTTP history (doctrine-2026 G3);
$ENG_DIR/identities.md ## Auth profiles holds the named auth postures its rows
reference (G4). ($ENG_DIR = the engagement tree in VMshare, double-nested
/; hunt skills append there - the repo tree targets/ is
admin/ingest only.) Two hard rules in the lane contract:
- Check the table before endpoint testing. Before a lane (or the brain dispatching
one) probes an endpoint, grep
requests.mdfor the host/path prefix; a prior row - including a negative one - is a skip-or-differentiate decision, not a re-test. Cite the prior row in the lane brief. - Append rows before lane close. One row per (lane, host, method, path) test, with
auth-profile-refnaming a profile from identities.md (-if unauthenticated). A lane that closes without its rows appended has an UNCHECKED request ledger - same standing as an unchecked completion-gate step.
The table is the index; raw evidence stays in ingest/ and lane capture dirs.
Enumeration limits
Prove the boundary is missing, not how much is behind it.
The server does not check any object. Demonstrating that takes two or three identifiers. A thousand-ID sweep does not raise severity; it collects real users' data and converts a critical finding into an incident report naming you.
- Default: 5 identifiers. Enough to show a sequential pattern and a missing check.
- Ceiling without explicit operator approval: 20.
- Beyond that, and for any range sweep: stop and ask. State why the extra volume changes the finding. Usually it does not.
no_bruteforcein scope means range 0. No sweep, no ffuf over an ID list, no exception.- Never enumerate writes. Read at volume is a rate problem; write at volume is destruction.
For scale evidence, cite a total field, a pagination header, or a result count. "The response
reports 41,180 records; none beyond my two test accounts were retrieved" proves scale without
retrieving anything.
Scope of these limits. They govern OBJECT and RECORD enumeration (guessing identifiers to pull
other users' data). They do NOT cap legitimate service discovery: an SSRF internal port sweep or a
network map is bounded by the engagement RoE (no_dos, scan-rate caps), not by the 5-to-20 object
ceiling. Thread it and honor the cap; do not clamp a port sweep to 20.
Stop conditions
Stop and report rather than continuing when:
- You received real user data. An ID you guessed belonged to someone real, a cache served another session, a beacon fired in a live employee context. Do not re-request to confirm, do not save it, do not use anything in it. Report immediately, state what you received and that you destroyed it, and note it in the FIND rather than hiding it.
- The next step is destructive or persistent - deleting objects, modifying another tenant's config, planting content that outlives the session.
- You have a traffic-affecting primitive - desync, cache poisoning, connection-pool effects. The mechanism is the finding.
- The last step needs volume beyond the limits above.
- You already have the severity ceiling. More escalation, more risk, no more payout. Post-ex serves one of two purposes, proving impact or feeding the next hop; if it is impact, the minimum that demonstrates it is the ceiling.
- You left scope. Even one hop. Especially one hop.
Stopping is not failure. "Confirmed and did not exploit" is worth more than a forfeited payout.
Blocked-handling ladder (403/429/WAF/timeout). Climb in order, one rung per attempt:
change UA -> reader proxy -> page cache -> archive (web.archive.org) -> alt engine ->
SOCKS5 (if provisioned). Retrying the same conditions twice unchanged is the named
violation gave-up-by-repetition. Exhausted after the full ladder: write the negative
fact (state.md ## Facts, negative/ key) plus one Deadends.md row carrying
ladder: <steps executed> (e.g. ladder: UA,proxy,archive), then switch domain - a
Deadends row without the ladder field reads as an early give and the close-out
drift-count separates them.
Violation vocabulary (drift taxonomy, used by the Stop-hook close-out count and
log.md skip-reason lines): hallucination (claim with no test), gave-up (blocked and
not switched), omission (creds in hand, not sprayed/reused).
Published chains: exact-first
When a writeup / published chain exists for the box or the vuln class, fire its EXACT form first: same payload, same framing, same delivery channel (chat UI vs raw API, browser vs curl). An adaptation is a one-variable experiment that needs a known-good baseline; adapt before the baseline exists and every failure is unattributable (payload? delivery? box version?). Transcribe EVERY writeup artifact, not just prose (screenshots carry source-IP / UA / Origin ground truth about where execution happens), and re-test a published chain verbatim on each new instance before believing it was patched. Method: [[wiki/techniques/methodology/writeup-reproduction]].
Wrong-vector tells (switch the vector, do not tune the tooling). A vector is exhausted the moment it starts fighting you; grinding harder is the sunk-cost trap. Two mechanical signals mean the current vector is the wrong door, not that your tooling needs another pass:
- The target starves under your own exploit loop (repeated
000/ connection-timeout / empty-reply while you hammer one endpoint). A vector that DoSes a lab box is almost never the intended one. Stop, let it drain, and enumerate a DIFFERENT class (source-read: LFI / alias-traversal /.git/ backup; a second service or vhost's own app; OOB creds) before returning. - Two verified hashes in a row fail the primary wordlist. The passwords are not wordlist material - they are delivered out-of-band (an email/note/KeePass, a config, a second service). Stop cracking and re-enumerate for where the creds are HANDED OUT; do not extract a third hash. (Engineering around a hostile channel - per-char verify-fix, min-of-2 sampling, gentler pacing - is the tell you are on the wrong vector, not a reason to keep going.)
Both signals fire MECHANICALLY: count them yourself from this session's own captured output (last 6+ curl failures against one host -> starvation verdict; 2+ hashcat runs Exhausted with nothing cracked -> stop-cracking verdict). The count surfacing in front of you is this section firing - act on it, do not re-run the tool.
When a wrong-vector tell fires and the next door is not obvious, call Skill(redteamlead) before
grinding further - it reads the engagement state + evidence + wiki and returns ranked directions with
an explicit STOP. That is exactly what it is for ("I'm stuck / which vector / should I keep hammering
this"); one RTL call at the first sign a vector is fighting back beats hours of sunk-cost grind.
Marker discipline
Any class where you inject a value and look for it later (xss, ssti, sqli error strings, crlf, log
injection, open redirect): use a unique 8+ char alphanumeric canary (e.g. x4hd2k9pq), never
test/marker/evil/payload. Check the baseline response for the canary BEFORE claiming
reflection; a value already present is not proof you put it there.
Small tells (battery before the big read)
Before reading a big source file / JS bundle / saved response tree end to end, run the
curated tell battery over it: python3 scripts/tells.py <path> prints path:line [class] snippet -> Skill(x) for every small indicator it knows (raw-HTML sinks, command-exec
sinks, string-built SQL, deser calls, keys/JWTs, comment hints, version banners). Read
the hit blocks FIRST, then the full read where the read-first mandate applies
(post-foothold source review). The pattern table is scripts/tells.json - the single
machine-readable source; learned a new tell (an indicator that would have saved you
time)? Add a row there. High precision only: a noisy tell trains the eye to ignore the
battery. This locates, it never replaces the read.
Wiki lookup (reference-map first, qmd on a hint)
mcp__wiki-search__query is powerful but ~15-30s per call, so it is a TARGETED deepen, not a pre-attack ritual.
Three tiers, in order:
- Reference map FIRST (instant
Read). Your hunt skill's## Wikisection names the class's domain MOC + primary page + a few anchors.Readthose directly, and one-hop from the MOC for a sibling technique. This answers the anticipated case with zero qmd latency. mcp__wiki-search__queryONLY on a concrete hint the map does not cover - a specific sink/function (an SSRF-reachingrequests.get(user_input)), an observed escape (a<script>context that could be XSS), a fingerprinted version/CVE, or a service the MOC does not list:mcp__wiki-search__query (lex) "<the specific thing>" via wiki-search MCP. It auto-surfaces pages added since the skill was written. Do NOT blanket-qmd every action (too slow); do NOT hand-roll from memory when a targeted qmd would answer (that is the opposite failure). Fire it when you have the hint, then act.- Self-heal only if neither the map nor a targeted qmd has it: stub
wiki/techniques/<area>/<slug>.md(frontmatter +## Observed during <engagement>) so the gap fills.
Payload arsenals live in wiki/payloads/. If the MCP is down, bash scripts/wiki-query.sh "<terms>"
wraps the same qmd index (-k for an exact CVE/string).
Volume reconciliation: this tiered lookup IS the wiki-first rule below - the reference-map read
(or one targeted qmd) per new attack-path lane satisfies it; qmd is a targeted deepen, not a
pre-attack ritual, and never a per-action step.
Hunt approaches (which skill for the signal)
Usage order: load this index first, load the per-surface skill on demand, keep three permanent rules always on:
- wiki-first - consult the class page/MOC before dispatching a new attack-path lane.
- OOB gate - blind claims (SSRF/SSTI/SQLi-blind/deser) need an out-of-band callback, never inference.
- verification before status change - a status only advances with the evidence the ladder demands (see FIND output + find-lint).
hunt-core is the hub: route from the observed signal to the class skill, load it, then use that
skill's ## Wiki map. The recon-capture fingerprint router auto-suggests many of these from tool
output; this table is the manual reference when it does not fire or you are reasoning about approach.
| Signal / surface | Skill |
|---|---|
reflected/stored input, <script> / onerror / javascript: / a DOM sink |
Skill(hunt-xss) |
| a stored field rendered in an admin/moderation/approval panel; a reviewer bot | Skill(hunt-xss-blind) |
| a param/body reaching a DB; an error / boolean / time oracle | Skill(hunt-sqli) |
a URL/host param, a fetch/preview/import sink, ?url= |
Skill(hunt-ssrf) |
an object id, /users/{id}, two-account cross-access |
Skill(hunt-idor) |
template {{ }} render, XXE (SVG/DOCX/SAML), GraphQL |
Skill(hunt-injection) |
| a command sink, template-injection-to-exec, a version+CVE | Skill(hunt-rce) |
a serialized blob (rO0 / AAEAAAD / O:), viewstate, a signed cookie |
Skill(hunt-deserialization) |
| login / reset / session / JWT, a legacy-protocol endpoint | Skill(hunt-auth) |
| OAuth / SAML redirect_uri or assertion | Skill(hunt-federation) |
| file upload / avatar / document import | Skill(hunt-upload) |
| REST/GraphQL/gRPC, BOLA / BFLA / mass-assignment | Skill(hunt-api) |
| checkout / price / coupon / workflow logic, a race | Skill(hunt-bizlogic) |
| CL.TE / TE.CL / HTTP-2 downgrade desync | Skill(hunt-smuggling) |
| an unkeyed header/param reaching a cache | Skill(hunt-cache) |
exposed .git / .env / keys, secrets in a JS bundle |
Skill(hunt-secrets) |
| LLM prompt-injection / excessive agency | Skill(hunt-llm) |
| MCP tool-poisoning / indirect injection | Skill(hunt-mcp) |
| a handed-out binary / a socket service that crashes on crafted input (stack-heap corruption, format string, ROP, seccomp jail) | Skill(hunt-pwn) |
| AD: kerberoast / AS-REP / ADCS / DCSync / delegation (dotted-FQDN domain / a DC) | Skill(hunt-ad) |
| AD expert depth: certificate templates / ESC1-16 | Skill(hunt-ad-adcs) |
| AD expert depth: roasting, delegation, tickets | Skill(hunt-ad-kerberos) |
| AD expert depth: ACL edges, GPO, ADIDNS | Skill(hunt-ad-acl) |
| Windows LOCAL privesc: service misconfig / autologon reg / SeImpersonate-Potato / scheduled-task / DLL hijack (standalone/workgroup box, or a local shell on a member) | Skill(hunt-windows) |
| AWS/Azure/GCP metadata or IAM | Skill(hunt-cloud) |
| Microsoft 365 / Entra tenant | Skill(hunt-m365) |
| CI/CD pipeline (Actions / runners / OIDC) | Skill(hunt-cicd) |
| macOS TCC / SIP / keychain / XPC | Skill(hunt-macos) |
| SSL-VPN appliance (Fortinet/Citrix/Ivanti/Cisco/PAN) | Skill(hunt-vpn) |
| Modbus / S7 / EtherNet-IP / PLC / HMI | Skill(hunt-ics) |
Process skills (not vuln classes): Skill(ctf-box) boot-to-root, Skill(wiki-recon) external recon,
Skill(wiki-arsenal) tool+payload lookup, Skill(triage) -> Skill(evidence)
finding validation, Skill(hunt-burp) drive Burp. Coverage gaps and move ranking come from the
driver itself (scripts/offensive.py coverage / offensive.py next).
- At board time, list the attacks the scope implies that no board row exercises, cross-checked against the Approach.md 4a coverage table; a gap gets a row or a Ruling for why not.
- Dynamic threat modeling (cloudflare adopt 2026-11-12): the static class table is
the floor, not the ceiling. After the surface map, derive 1-3 TARGET-SPECIFIC
attack classes the generic table has no row for (a site with a file-conversion
pipeline gets a "conversion-worker abuse" class; a staging host with a debug
panel gets its own row) and add them as normal 4a board rows with skill
hunt-core+ a one-line method note. Do not force-fit a target-specific vector into a generic class name that will never route to it again. - Cross-model second look (cloudflare adopt 2026-11-12): a single pass by one model finds roughly half of what repeated passes find, skewed to the simpler bugs. Before declaring a HIGH-value surface exhausted, re-hunt it ONCE from a different tier than the lanes that covered it (flash-covered surface gets a glm-5.3 lane; glm-5.3-covered gets opus on exploit-shaped surfaces) - different weights see different vectors. One bounded re-hunt lane per surface, not a fleet sweep; skip on LOW-value surfaces where the tier cost is not worth it.
Routing table (machine-readable)
The fingerprint -> {class, skill, wiki, arsenal} parse contract offensive.py index reads
lives in scripts/routing.json - edit the JSON, not this file. Key order is load-bearing
(the first key per class wins); extend it there (not playbook.json) when a driver-side
signal is added, then recompile: python3 scripts/offensive.py --eng <eng> index - the G1
lint refuses a malformed row by name. An empty skill value is a legal G2-skipping state
(vector-baseline rows with no doctrine match).
FIND output
On confirmation:
Create Vulns/Research/FIND-XXX-SEVERITY-<class>-<host>[-<resource>].md
Add row to Vuln-index.md
Severity is rated on demonstrated impact, not theoretical maximum. Preconditions lower it (victim interaction, an unguessable identifier you cannot show leaking, a race you win one time in twenty). Scale raises it, when you can show the identifier is enumerable without enumerating. State impact in the program's terms (customer data, account security, financial exposure), not in vulnerability classes.
Escalating a rating is a capture task, not an argument. When a finding looks like it could rate higher: name the ONE artifact that would prove the upgrade (an event payload carrying PII, a cross-account write, a state change on an unowned object), dispatch lanes for exactly that artifact, and if they return empty, the rating stands on an evidence-complete negative - record what was probed, the negative, and the concrete re-test triggers in the index row. Never write up the theoretical chain as the finding while the missing link is uncaptured; a chain argument without the captured link reads as speculation to a triager and buries the real finding.
Each card ends with a ## Recommended next line (template field): one line naming the
next class/skill plus the evidence input it needs. The triage skill reads it as a
ranking hint; find-lint does not gate on it.
On exhaustion:
Append to Deadends.md table: | <host> | <class> | <what was tried> | <typed fail-class>: <why ruled out + the named control> | <date> | <reopen-if> |
The reason matters more than the entry. technical: 403 on cross-account, authorization enforced stops you
retesting; a bare entry does not. (Table rows only - the audit parses the table; stray - [ ] bullet blocks
above/below it are unparseable and get flagged.)
Machine-quality contract for Deadends rows (the close-out audit checks this; a row that fails it gets re-served as unverified):
- One row per asset x class pair - never two. When a second row lands for the same pair, fold its evidence into the richer row and drop the other; parallel rows for the same class drift apart and one always rots.
- The
why exhaustedcell is one sentence carrying a TYPED fail-class from the fixed vocabularytechnical | environmental | conceptual | external- e.g.technical: no URL-fetch sink exists (op map carries zero url= params). A bareexhaustedplaceholder is an unverified claim. - A "secure/safe/hardened" claim must NAME the control that proved it (rotation enforced, single-use replay rejected, captcha fires before the email check) - a safety verdict without its control is unfalsifiable and reads as not-tested.
- Before recording a dead-end on a masked-error gateway (uniform ISE/PQNF), retry the exact request once - probabilistic defenses intermittently reject valid requests, and a single-shot negative fossilizes into a wrong dead-end row.
Before recording a class exhausted app-wide, diff the endpoints you actually probed against the app's full route/parameter inventory; the verdict covers only the endpoints in it, and the one route never touched (a pre-auth register/dup-check path is the classic) is usually where the class was actually live.
Run completion gate
A dispatched run is COMPLETE only when its checklist says so - never on the
lane's narrative. Author a run ledger at dispatch
(python3 scripts/completion-gate.py init <lane-dir> --title "<vector>",
steps from the hunt skill's checklist, artifacts declared inline after @),
and on return verify mechanically
(python3 scripts/completion-gate.py check <lane-dir> --capture <dir>):
UNCHECKED / MISSING / EMPTY verdicts mean the run is not done; re-dispatch
with the printed generic nudge rather than a re-written brief. An empty
capture dir is a failed lane, not a quiet success.
Distillation
When a confirmed finding is a reusable technique rather than a target quirk, stage it:
python3 scripts/wiki-stage.py --kind technique --slug <slug> --target-page <area>/<page>.md
GENERIC only - no client host, no real identifier, no customer data. Promote later via
scripts/wiki-promote.py. Run scripts/check-leaks.sh before any push. Engagement data lives
under targets/ and is git-ignored. Technique know-how that is NOT finding-derived (a mailbox
relay recipe, a seat-bridge quirk proven across engagements) stages the same way the iteration
it is learned - do not stockpile staging for close-out.
Validation
- Meta-contract for every class: a CONFIRMED names its proof artifact AND the negative control that failed; the FIND carries counterevidence / confidence / severity_change_conditions (find-lint enforces non-empty on CONFIRMED+).
- Re-derive one claimed negative before it reaches Deadends.md; a subagent's negative is a hypothesis until the brain re-verifies it.
False Positives
- The five cross-class false-positive families:
- encoded reflection read as XSS (
<script>in the body); - empty 200 read as access (no other-account content);
- self-effect read as cross-user (no second session);
- an error page read as a vuln (it is the control doing its job);
- the SPA fallback shell read as a routed API hit - a JSON API probe answered
by
200 text/html(the app shell) means the gateway never routed the request, not that the endpoint accepted it. Distinguish by content-type + the app's JSON error envelope; before declaring a route 404, vary the shape the router keys on: sendAccept: application/json(gateways route on it), and check the id segment type (numeric ids often route while UUIDs fall through) and for missing path segments between the base and the leaf (/v1/access/{id}/x, not/v1/{id}/x).
- encoded reflection read as XSS (
- The single control that kills all four: re-send the request WITHOUT the attack input and diff; identical response = no finding.
Cross-routing
- The 'Hunt approaches' table below is the router; when a signal names two candidate skills, run the cheap distinguishing probe and negative-route the loser in one line.
- Load the paired skill when a confirmed finding changes class (SSRF hits metadata -> hunt-cloud; SSTI executes -> hunt-rce).
Depth walk (mandatory)
Walk EVERY applicable row of the payload arsenal page cited above.
Record each row in $RUN/coverage-depth.md as a table
| row | state | evidence | where state is probed, blocked, or
N/A, and evidence is a probe-pair path or a Deadends.md line. A bare
probed with no evidence reference fails the completion gate
(NEEDS-REVIEW). N/A rows cite why (surface shape forbids it).
Blocked implies research: before any Deadend is claimable on a blocked
row, (a) walk the arsenal page's bypass-ladder rows for that control
class, and (b) run one wiki query AND one mcp__wigolo__search for the
specific tech-plus-control bypass. Results, or a genuine null, land in
coverage-depth.md. "No research tried" is not a claimable state.