blitzstrike 1.0.99 → 1.1.3

package/CHANGELOG.md

@@ -5,6 +5,62 @@ 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.3] — 2026-09-13
+
+### Added — standard taxonomy (OWASP API Top 10 + CWE)
+
+- New `taxonomy` MCP tool + `intelligence/api_top10.json` + `cwe_map.json`:
+  - `taxonomy(api)` → OWASP API Security Top 10 (2023) risks mapped to Blitz
+    coverage (BOLA, broken auth, BOPLA, resource consumption, BFLA, business
+    flows, SSRF, misconfiguration, inventory, unsafe consumption).
+  - `taxonomy(cwe, query)` → CWE ID + name for any technique class (52 mapped),
+    for grounding findings in standard IDs during reporting.
+- THIRD-PARTY-NOTICES: OWASP API Security (CC BY-SA 4.0) + MITRE CWE.
+
+## [1.1.2] — 2026-09-13
+
+### Added — curated security resource index
+
+- New `resource_lookup` MCP tool + `intelligence/resources.json`: 30 curated
+  domain-specific security resources (from the community Awesome-Hacking
+  meta-list, filtered to web/pentest relevance) — each tagged with use_when
+  (which phase/context it serves). Search by category (web, pentest, bug_bounty,
+  api, recon, payload, cve, privesc, source, fuzzing, llm, framework, osint,
+  rev, cracking, forensics, malware, ir, intel, cicd, knowledge, labs) or
+  keyword. Lets the LLM find the best domain-specific tools/knowledge when
+  Blitz Strike's own data doesn't cover a domain.
+
+## [1.1.1] — 2026-09-13
+
+### Added — HackTricks full enrichment (52 classes + 16 frameworks)
+
+- `techniques.json` expanded 25 → 52 vulnerability classes (added crlf, ldap,
+  xpath, xslt, ssi, xssi, email injection, formula/CSV injection, orm, rsql,
+  json/xml/yaml, unicode, dangling markup, account takeover, 2FA bypass,
+  rate-limit bypass, password reset, captcha bypass, registration, payment
+  bypass, timing attacks, uuid insecurities, reverse tabnabbing, iframe traps,
+  cookie hacking, postMessage vulnerabilities, methodology).
+- New `framework_tricks` MCP tool + `intelligence/framework_tricks.json`: 16
+  frameworks (Laravel, Django, Flask, Node/Express, Next.js, Vue, Angular,
+  WordPress, Joomla, Spring, JSP, Python, Go, Ruby/Rails, Perl, GraphQL) with
+  detection signals, known vulns/CVEs, and concrete attack tricks.
+- Synthesized in own words from public technique references (paraphrased, not
+  verbatim — HackTricks has no open license).
+
+## [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)

package/THIRD-PARTY-NOTICES.md

@@ -56,6 +56,19 @@ satisfies the attribution requirements of those licenses.
   (category identifiers WSTG-INFO/CONF/IDNT/ATHN/ATHZ/SESS/INPV/ERRH/CRYP/
   BUSL/CLNT/APIT and their test names).
 
+## OWASP API Security Top 10
+
+- **Source:** https://github.com/OWASP/API-Security
+- **License:** CC BY-SA 4.0
+- **Used for:** the 2023 risk taxonomy in `intelligence/api_top10.json`
+  (API1–API10 identifiers and risk names).
+
+## MITRE CWE (Common Weakness Enumeration)
+
+- **Source:** https://cwe.mitre.org
+- **Used for:** standard weakness identifiers + names in `intelligence/cwe_map.json`
+  (CWE IDs are MITRE's taxonomy; the technique→CWE mapping is our own).
+
 ---
 
 All other code, chains, and data in this project are written by shinthink

package/dist/index.js

@@ -31766,6 +31766,82 @@ function wstgMap(category) {
     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)) };
+}
+function frameworkTricks(framework) {
+  const data = loadJson("framework_tricks");
+  if (!data)
+    return { found: false, error: "framework_tricks.json not found" };
+  if (!framework) {
+    return { found: true, frameworks: data.frameworks.map((f) => ({ framework: f.framework })) };
+  }
+  const q = framework.toLowerCase();
+  const f = data.frameworks.find((x) => String(x.framework).toLowerCase().includes(q));
+  if (f)
+    return { found: true, ...f };
+  return { found: false, framework, suggestions: data.frameworks.map((x) => String(x.framework)) };
+}
+function resourceLookup(category) {
+  const data = loadJson("resources");
+  if (!data)
+    return { found: false, error: "resources.json not found" };
+  if (!category) {
+    return {
+      found: true,
+      resources: data.resources.map((r) => ({ id: r.id, name: r.name, category: r.category, use_when: r.use_when }))
+    };
+  }
+  const q = category.toLowerCase();
+  const matches = data.resources.filter((r) => String(r.category).toLowerCase() === q || String(r.id).toLowerCase().includes(q) || String(r.name).toLowerCase().includes(q) || String(r.use_when).toLowerCase().includes(q));
+  if (matches.length > 0)
+    return { found: true, matches };
+  return { found: false, category, suggestions: [...new Set(data.resources.map((r) => String(r.category)))] };
+}
+function taxonomy(kind, query) {
+  if (kind === "api" || kind === "api_top10" || kind === "owasp-api") {
+    const data = loadJson("api_top10");
+    if (!data)
+      return { found: false, error: "api_top10.json not found" };
+    if (!query)
+      return { found: true, risks: data.risks };
+    const q = query.toLowerCase();
+    const r = data.risks.find((x) => String(x.id).toLowerCase() === q || String(x.name).toLowerCase().includes(q));
+    if (r)
+      return { found: true, ...r };
+    return { found: false, query, suggestions: data.risks.map((x) => String(x.id)) };
+  }
+  if (kind === "cwe" || kind === "weakness") {
+    const data = loadJson("cwe_map");
+    if (!data)
+      return { found: false, error: "cwe_map.json not found" };
+    if (!query)
+      return { found: true, mapping: data.mapping };
+    const q = query.toLowerCase();
+    const m = data.mapping.filter((x) => String(x.id).toLowerCase().includes(q) || String(x.cwe).toLowerCase() === q || String(x.name).toLowerCase().includes(q));
+    if (m.length > 0)
+      return { found: true, matches: m };
+    return { found: false, query, suggestions: data.mapping.map((x) => String(x.id)) };
+  }
+  return {
+    found: false,
+    error: "unknown taxonomy kind",
+    usage: "taxonomy(kind='api'|'cwe', query?)"
+  };
+}
 
 // src/active.ts
 var TIMEOUT_MS2 = 20000;
@@ -53712,7 +53788,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", {
@@ -54259,6 +54335,43 @@ ${statusLine}` : statusLine },
   }, 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 (52 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, crlf, ldap, xpath, xslt, ssi, xssi, email, formula/CSV, orm, rsql, unicode, dangling markup, account takeover, 2fa bypass, rate-limit, password reset, captcha, registration, payment bypass, timing, uuid, reverse tabnabbing, iframe traps, cookies, postMessage, ...). 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("framework_tricks", {
+    title: "Framework-specific exploitation tricks",
+    description: "INTEL: return framework-specific exploitation knowledge for a framework (Laravel, Django, Flask, Node/Express, Next.js, Vue, Angular, WordPress, Joomla, Spring, JSP, Python, Go, Ruby/Rails, Perl, GraphQL) — detection signals, known vulns/CVEs, and concrete attack tricks. Use after detect_framework to hunt that framework's specific weaknesses.",
+    inputSchema: {
+      framework: string2().optional().describe("Optional framework name (e.g. 'laravel', 'django', 'wordpress').")
+    }
+  }, async ({ framework }) => {
+    return { content: [{ type: "text", text: JSON.stringify(frameworkTricks(framework)) }] };
+  });
+  server.registerTool("resource_lookup", {
+    title: "Curated security resource index",
+    description: "INTEL: return curated domain-specific security resources (the community Awesome-Hacking index, filtered to web/pentest relevance) — each with name, URL, description, and use_when (which phase/context it serves). Search by category (web, pentest, bug_bounty, api, recon, payload, cve, privesc, source, fuzzing, llm, framework, osint, rev, cracking, forensics, malware, ir, intel, cicd, knowledge, labs) or keyword. Use to find the best domain-specific tools/knowledge when Blitz Strike's own data doesn't cover it.",
+    inputSchema: {
+      category: string2().optional().describe("Optional category id or keyword (e.g. 'web', 'payload', 'recon', 'privesc').")
+    }
+  }, async ({ category }) => {
+    return { content: [{ type: "text", text: JSON.stringify(resourceLookup(category)) }] };
+  });
+  server.registerTool("taxonomy", {
+    title: "OWASP API Top 10 + CWE taxonomy",
+    description: "INTEL: return standard taxonomy for grounding + professional reporting. taxonomy(kind='api') returns the OWASP API Security Top 10 (2023) risks mapped to Blitz coverage; taxonomy(kind='cwe', query='ssrf') returns the CWE ID + name for a technique class (or a CWE id). Use to map findings to standard IDs (CWE-79, CWE-89, API1 BOLA, ...).",
+    inputSchema: {
+      kind: string2().optional().describe("'api' (OWASP API Top 10) or 'cwe' (CWE mapping)."),
+      query: string2().optional().describe("Optional query: a technique class id (for cwe) or an API risk id (for api).")
+    }
+  }, async ({ kind, query }) => {
+    return { content: [{ type: "text", text: JSON.stringify(taxonomy(kind, query)) }] };
+  });
   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/api_top10.json

@@ -0,0 +1,15 @@
+{
+  "_comment": "OWASP API Security Top 10 (2023) mapped to Blitz Strike coverage. Each risk has its id, name, and the Blitz technique/tool that hunts it.",
+  "risks": [
+    {"id": "API1", "name": "Broken Object Level Authorization (BOLA)", "cwe": ["CWE-639"], "desc": "Accessing another user's object by tampering the object id without an authorization check.", "blitz": "technique_lookup(idor) + active_scan", "data": []},
+    {"id": "API2", "name": "Broken Authentication", "cwe": ["CWE-287", "CWE-384"], "desc": "Weak or bypassable authentication (JWT, OAuth, token, credential flaws).", "blitz": "technique_lookup(jwt) + technique_lookup(oauth) + bypass_lookup(auth)", "data": []},
+    {"id": "API3", "name": "Broken Object Property Level Authorization (BOPLA)", "cwe": ["CWE-915", "CWE-639"], "desc": "Mass assignment / excessive data exposure of object properties.", "blitz": "technique_lookup(mass_assignment) + complex_scan", "data": []},
+    {"id": "API4", "name": "Unrestricted Resource Consumption", "cwe": ["CWE-400", "CWE-770"], "desc": "DoS via missing rate limits, deep recursion, or resource exhaustion.", "blitz": "technique_lookup(rate_limit_bypass) + technique_lookup(race_condition)", "data": []},
+    {"id": "API5", "name": "Broken Function Level Authorization (BFLA)", "cwe": ["CWE-862", "CWE-285"], "desc": "Invoking admin-only functions without the right role.", "blitz": "technique_lookup(idor) + route_scan", "data": []},
+    {"id": "API6", "name": "Unrestricted Access to Sensitive Business Flows", "cwe": ["CWE-841"], "desc": "Abusing a legitimate business flow (purchase, redeem) without authorization.", "blitz": "technique_lookup(bypass_payment) + hp-business-logic-fuzzing", "data": []},
+    {"id": "API7", "name": "Server Side Request Forgery", "cwe": ["CWE-918"], "desc": "The API fetches an attacker-influenced URL to reach internal services.", "blitz": "technique_lookup(ssrf) + ap-ssrf-cloud-metadata", "data": ["chains"]},
+    {"id": "API8", "name": "Security Misconfiguration", "cwe": ["CWE-16"], "desc": "Verbose errors, exposed debug/admin endpoints, missing headers, CORS misconfig.", "blitz": "technique_lookup(cors) + live_recon + web-hunting (exposed config)", "data": []},
+    {"id": "API9", "name": "Improper Inventory Management", "cwe": ["CWE-1057"], "desc": "Orphaned/legacy API versions or endpoints left undocumented and unprotected.", "blitz": "live_recon (versioned APIs) + web-hunting (recon)", "data": []},
+    {"id": "API10", "name": "Unsafe Consumption of APIs", "cwe": ["CWE-20", "CWE-502"], "desc": "Trusting third-party API responses that are then processed unsafely.", "blitz": "technique_lookup(deserialization) + technique_lookup(command_injection)", "data": []}
+  ]
+}

package/intelligence/cwe_map.json

@@ -0,0 +1,56 @@
+{
+  "_comment": "Technique class -> CWE mapping (standard weakness IDs, for grounding + professional reporting). Each entry maps a techniques.json class id to its CWE ID(s) and name.",
+  "mapping": [
+    {"id": "ssrf", "cwe": "CWE-918", "name": "Server-Side Request Forgery (SSRF)"},
+    {"id": "request_smuggling", "cwe": "CWE-444", "name": "Inconsistent Interpretation of HTTP Requests (Request Smuggling)"},
+    {"id": "cache_poisoning", "cwe": "CWE-524", "name": "Use of Cache Containing Sensitive Information"},
+    {"id": "race_condition", "cwe": "CWE-362", "name": "Concurrent Execution using Shared Resource (TOCTOU)"},
+    {"id": "ssti", "cwe": "CWE-1336", "name": "Improper Neutralization of Special Elements Used in a Template Engine (SSTI)"},
+    {"id": "deserialization", "cwe": "CWE-502", "name": "Deserialization of Untrusted Data"},
+    {"id": "prototype_pollution", "cwe": "CWE-1321", "name": "Improperly Controlled Modification of Object Prototype Attributes (Prototype Pollution)"},
+    {"id": "mass_assignment", "cwe": "CWE-915", "name": "Improperly Controlled Modification of Dynamically-Determined Object Attributes"},
+    {"id": "sql_injection", "cwe": "CWE-89", "name": "SQL Injection"},
+    {"id": "nosql_injection", "cwe": "CWE-943", "name": "Improper Neutralization of Special Elements in Data Query Logic (NoSQL Injection)"},
+    {"id": "xss", "cwe": "CWE-79", "name": "Cross-site Scripting"},
+    {"id": "cors", "cwe": "CWE-942", "name": "Permissive Cross-domain Policy with Untrusted Domains (CORS)"},
+    {"id": "csrf", "cwe": "CWE-352", "name": "Cross-Site Request Forgery"},
+    {"id": "jwt", "cwe": "CWE-347", "name": "Improper Verification of Cryptographic Signature"},
+    {"id": "oauth", "cwe": "CWE-287", "name": "Improper Authentication"},
+    {"id": "host_header", "cwe": "CWE-644", "name": "Improper Neutralization of HTTP Headers for Scripting Syntax (Host Header)"},
+    {"id": "open_redirect", "cwe": "CWE-601", "name": "URL Redirection to Untrusted Site (Open Redirect)"},
+    {"id": "subdomain_takeover", "cwe": "CWE-350", "name": "Reliance on Reverse DNS Resolution for a Security-Critical Action"},
+    {"id": "idor", "cwe": "CWE-639", "name": "Authorization Bypass Through User-Controlled Key (IDOR/BOLA)"},
+    {"id": "graphql", "cwe": "CWE-862", "name": "Missing Authorization"},
+    {"id": "websocket", "cwe": "CWE-345", "name": "Insufficient Verification of Data Authenticity (WebSocket Hijacking)"},
+    {"id": "file_upload", "cwe": "CWE-434", "name": "Unrestricted Upload of File with Dangerous Type"},
+    {"id": "path_traversal_lfi", "cwe": "CWE-22", "name": "Improper Limitation of a Pathname to a Restricted Directory (Path Traversal)"},
+    {"id": "command_injection", "cwe": "CWE-78", "name": "OS Command Injection"},
+    {"id": "xxe", "cwe": "CWE-611", "name": "Improper Restriction of XML External Entity Reference (XXE)"},
+    {"id": "crlf_injection", "cwe": "CWE-93", "name": "Improper Neutralization of CRLF Sequences (CRLF Injection)"},
+    {"id": "ldap_injection", "cwe": "CWE-90", "name": "Improper Neutralization of Special Elements in LDAP Queries"},
+    {"id": "xpath_injection", "cwe": "CWE-643", "name": "Improper Neutralization of Data within XPath Expressions"},
+    {"id": "xslt_injection", "cwe": "CWE-91", "name": "XML Injection (XSLT)"},
+    {"id": "ssi_injection", "cwe": "CWE-97", "name": "Improper Neutralization of Server-Side Includes (SSI)"},
+    {"id": "xssi", "cwe": "CWE-200", "name": "Exposure of Sensitive Information to an Unauthorized Actor (XSSI)"},
+    {"id": "email_injection", "cwe": "CWE-74", "name": "Improper Neutralization of Special Elements in Output (Email Header Injection)"},
+    {"id": "formula_csv_injection", "cwe": "CWE-1236", "name": "Improper Neutralization of Formula Elements in a CSV File"},
+    {"id": "orm_injection", "cwe": "CWE-89", "name": "SQL Injection (via ORM)"},
+    {"id": "rsql_injection", "cwe": "CWE-89", "name": "SQL Injection (RSQL/FIQL)"},
+    {"id": "unicode_injection", "cwe": "CWE-180", "name": "Incorrect Behavior Order: Validate Before Canonicalize"},
+    {"id": "dangling_markup", "cwe": "CWE-79", "name": "Cross-site Scripting (Dangling Markup)"},
+    {"id": "account_takeover", "cwe": "CWE-287", "name": "Improper Authentication (Account Takeover)"},
+    {"id": "two_fa_bypass", "cwe": "CWE-308", "name": "Use of Single-factor Authentication"},
+    {"id": "rate_limit_bypass", "cwe": "CWE-799", "name": "Improper Control of Interaction Frequency (Rate Limit)"},
+    {"id": "password_reset_bypass", "cwe": "CWE-640", "name": "Weak Password Recovery Mechanism for Forgotten Password"},
+    {"id": "captcha_bypass", "cwe": "CWE-804", "name": "Guessable CAPTCHA"},
+    {"id": "registration_vulnerabilities", "cwe": "CWE-799", "name": "Improper Control of Interaction Frequency"},
+    {"id": "payment_bypass", "cwe": "CWE-841", "name": "Improper Enforcement of Behavioral Workflow (Business Logic)"},
+    {"id": "timing_attacks", "cwe": "CWE-208", "name": "Observable Timing Discrepancy"},
+    {"id": "uuid_insecurities", "cwe": "CWE-330", "name": "Use of Insufficiently Random Values"},
+    {"id": "reverse_tab_nabbing", "cwe": "CWE-1022", "name": "Use of Web Link to Untrusted Target with window.opener Access (Reverse Tabnabbing)"},
+    {"id": "iframe_traps", "cwe": "CWE-1021", "name": "Improper Restriction of Rendered UI Layers or Frames (Clickjacking)"},
+    {"id": "cookie_hacking", "cwe": "CWE-565", "name": "Reliance on Cookies without Validation and Integrity Checking"},
+    {"id": "postmessage_vulnerabilities", "cwe": "CWE-345", "name": "Insufficient Verification of Data Authenticity (postMessage)"},
+    {"id": "web_vulnerabilities_methodology", "cwe": "CWE-1057", "name": "Improper Inventory / Methodology"}
+  ]
+}