blitzstrike 1.0.76 → 1.0.78

package/CHANGELOG.md

@@ -5,6 +5,27 @@ 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.0.78] — 2026-09-13
+
+### Added — automatic target routing (URL vs source)
+
+- `bs-orchestrate-engagement` now leads with a "Target routing" table: a URL
+  or bare hostname → live engagement (scope-gated); a filesystem path / code
+  extension → source audit — classified automatically, no need to ask.
+- MCP `instructions` gained a "0. ROUTE BY TARGET" step so a driving LLM
+  auto-classifies the target and routes to the live or source pipeline without
+  being told.
+
+## [1.0.77] — 2026-09-13
+
+### Fixed — explicit tool argument names in doctrine
+
+- `bs-source-audit` now documents the exact argument convention: all
+  source-analysis tools take `path` (file or directory); only `run_engagement`
+  takes `target` (path or URL). Workflow steps now show `{path}` explicitly.
+- `bs-orchestrate-engagement` tells sub-agents to load `source-audit` for the
+  argument names instead of guessing `target` vs `path`.
+
 ## [1.0.76] — 2026-09-13
 
 ### Changed — native plan + sub-agent orchestration doctrine

package/dist/index.js

@@ -53328,7 +53328,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" + "1. SCOPE FIRST. Call scope_check(target, scope, mode) before ANY active testing. " + "   Passive analysis (reading source, fingerprinting public pages) needs no gate; " + "   active probing (exploitation, fuzzing, path brute-force) is blocked until scope " + "   authorizes it.\\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 gated alternative. Both re-check 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) 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_languages / taint_file: multi-language taint (PHP, JS/TS, Python, Java).\\n" + "- list_chains: 57 escalation chains (source -> sink -> impact).\\n" + "- tool_lookup / ensure_tool / list_tools: 130-tool catalog, auto-install.\\n" + "- skill_lookup / read_skill / list_skills: 38 skills (WP/PHP 0-day, AD, " + "  malware, mobile, cloud, etc.).\\n" + "- read_playbook / read_tool_manual / list_manuals: 270 tool manuals + engagement " + "  playbooks.\\n" + "- detect_waf / tech_correlation / cve_correlation / port_correlation: signature " + "  + correlation intelligence.\\n" + "- nvd_lookup / fofa_search: CVE + asset reconnaissance (FOFA needs env creds).\\n" + "- remember / memory_lookup / memory_list: persist + recall verified knowledge.\\n\\n" + "IRON RULES:\\n" + "- Scope first; authorized targets only. Refuse out-of-scope or destructive/DoS work.\\n" + "- A hit is a hypothesis; a verified exploit (or proven data-flow) is the finding.\\n" + "- Prefer the one-call run_engagement path; fall back to granular tools when you " + "  need finer control."
+    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 the target automatically - no need to ask. A " + "   URL (http/https) or bare hostname = LIVE engagement (scope-gated, then " + "   live_recon + active_scan + strike_verify). A filesystem path (exists on " + "   disk, or ends in a code extension) = SOURCE audit (blitz_scan + eagle_eye2 " + "   + complex_scan/route_scan). run_engagement auto-detects both internally.\\n" + "1. SCOPE FIRST. Call scope_check(target, scope, mode) before ANY active testing. " + "   Passive analysis (reading source, fingerprinting public pages) needs no gate; " + "   active probing (exploitation, fuzzing, path brute-force) is blocked until scope " + "   authorizes it.\\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 gated alternative. Both re-check 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) 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_languages / taint_file: multi-language taint (PHP, JS/TS, Python, Java).\\n" + "- list_chains: 57 escalation chains (source -> sink -> impact).\\n" + "- tool_lookup / ensure_tool / list_tools: 130-tool catalog, auto-install.\\n" + "- skill_lookup / read_skill / list_skills: 38 skills (WP/PHP 0-day, AD, " + "  malware, mobile, cloud, etc.).\\n" + "- read_playbook / read_tool_manual / list_manuals: 270 tool manuals + engagement " + "  playbooks.\\n" + "- detect_waf / tech_correlation / cve_correlation / port_correlation: signature " + "  + correlation intelligence.\\n" + "- nvd_lookup / fofa_search: CVE + asset reconnaissance (FOFA needs env creds).\\n" + "- remember / memory_lookup / memory_list: persist + recall verified knowledge.\\n\\n" + "IRON RULES:\\n" + "- Scope first; authorized targets only. Refuse out-of-scope or destructive/DoS work.\\n" + "- A hit is a hypothesis; a verified exploit (or proven data-flow) is the finding.\\n" + "- Prefer the one-call run_engagement path; fall back to granular tools when you " + "  need finer control."
   });
   server.registerTool("blitz_scan", {
     title: "BLITZ scan",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "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-orchestrate-engagement.md

@@ -8,6 +8,21 @@ description: Use when the user asks for a full security engagement ("fullscan",
 You are the brain. Blitz Strike is the hands. Drive the full cycle with the
 deterministic MCP tools; never guess a finding — produce it from tool output.
 
+## Target routing (auto-detect first — no need to ask)
+
+Classify the target before any tool call. This is automatic, driven by the
+shape of what the user gave you:
+
+| Target shape | Flow |
+|---|---|
+| URL (`http://` / `https://`) | **Live** — `scope_check` (authorization) → `live_recon` → `active_scan` → `strike_verify` → report |
+| Filesystem path (exists on disk, or starts `/` `./` `../` `~`, or ends in a code extension `.php` `.py` `.js` `.ts` `.java` …) | **Source** — `blitz_scan` → `eagle_eye2` → `complex_scan`/`route_scan` → report |
+| Bare hostname (`example.com`, no scheme) | Treat as **live** — confirm scope before any request |
+
+`run_engagement` auto-detects both internally (path on disk → source pipeline;
+anything else → live, scope-gated). For the granular sub-agent flow, route the
+workstreams yourself: URL → live workstreams, path → source workstreams.
+
 ## The cycle
 
 1. **Scope gate (always first).** Call `scope_check` before any live action.
@@ -51,6 +66,10 @@ no-babysitting, not a single `run_engagement` call:
    - *Analyze* → `eagle_eye2` + `taint_scan` + `trace_data_flow` (source→sink).
    - *Deep classes* → `complex_scan` (POP/type-juggling/mass-assignment) +
      `route_scan` (route confusion).
+   Source-analysis tools take a `path` argument (file or directory); only
+   `run_engagement` takes `target` (path or URL). Point each sub-agent at the
+   `source-audit` skill so it knows the exact argument names — do not let it
+   guess `target` vs `path`.
    Each sub-agent returns deterministic findings — give it the target, the
    exact tools to call, and require evidence (file:line, sink, chain), never prose.
 3. **Collect + verify.** Merge sub-agent findings, `dedup_findings` by root

package/skills/bs-source-audit.md

@@ -8,27 +8,37 @@ description: Use when auditing source code (PHP/JS/Python/Java/etc.) for vulnera
 Drive Blitz Strike's static analyzers over a source tree and turn each hit into a
 hypothesis. Do not hand-guess; let the tools produce the source→sink evidence.
 
+## Tool argument convention (read this first)
+
+- **All source-analysis tools take `path`** (a file or directory):
+  `blitz_scan`, `eagle_eye2`, `taint_scan`, `taint_file`, `blitz_file`,
+  `trace_data_flow`, `eagle_grep`, `variant_analysis`, `enrich_scan`,
+  `route_scan`, `complex_scan`, `detect_framework`.
+  Example: `blitz_scan {path: "/repo/app"}`.
+- **Only `run_engagement` takes `target`** (accepts either a source path OR a
+  live URL). Do not pass `target` to the source-analysis tools — it is ignored.
+
 ## Workflow
 
-1. **Map the tree.** `blitz_scan <root>` — entry points (nopriv hooks, REST
-   routes, controllers) + sink inventory per file. `detect_framework` per file
-   to know what conventions apply.
+1. **Map the tree.** `blitz_scan {path}` — entry points (nopriv hooks, REST
+   routes, controllers) + sink inventory per file. `detect_framework {path}` per
+   file to know what conventions apply.
 
 2. **Trace data flow.** For each source→sink candidate:
-   - `taint_file` / `taint_scan` — variable-level taint tracking per file.
-   - `eagle_eye2` — whole-program interprocedural taint (PHP, method-call aware).
-   - `trace_data_flow` — classify sources vs sinks across a file.
+   - `taint_file {path}` / `taint_scan {path}` — variable-level taint tracking.
+   - `eagle_eye2 {path}` — whole-program interprocedural taint (PHP, method-aware).
+   - `trace_data_flow {path}` — classify sources vs sinks across a file.
    - `variant_analysis` — group data-flow candidates by shared root cause.
 
-3. **Escalate.** `enrich_scan` — match detected sinks to escalation chains
-   (SQLi → RCE, upload → shell, LFI → RCE). `list_chains` to see the full
+3. **Escalate.** `enrich_scan {path}` — match detected sinks to escalation
+   chains (SQLi → RCE, upload → shell, LFI → RCE). `list_chains` to see the full
    escalation taxonomy. `tech_correlation` for framework-specific weaknesses.
 
 4. **Deep/complex classes.** Beyond plain taint, drive the dedicated detectors:
-   - `route_scan <file>` — route confusion / dispatch abuse (`call_user_func`,
+   - `route_scan {path}` — route confusion / dispatch abuse (`call_user_func`,
      `$obj->$method()`, batch/proxy forwarding, dynamic include, route match
      without path normalization).
-   - `complex_scan <file>` — deserialization→POP chain (`unserialize` +
+   - `complex_scan {path}` — deserialization→POP chain (`unserialize` +
      `__destruct`/`__wakeup`/`__toString`), type juggling (loose `==`/`!=` vs
      hash/secret), mass assignment (`extract()`/`parse_str()` without a safe flag).