blitzstrike 1.0.21 → 1.0.22

package/dist/index.js

@@ -30017,6 +30017,52 @@ function confidenceFactorsFor(_input) {
     negative_control: false
   };
 }
+function transition(finding, to) {
+  if (!canTransition(finding.status, to)) {
+    throw new Error(`illegal transition ${finding.status} -> ${to}`);
+  }
+  const updated = { ...finding, status: to, timestamps: { ...finding.timestamps, updated: new Date().toISOString() } };
+  return updated;
+}
+function confirmFinding(finding, opts) {
+  const evidence = opts.evidence.map((e) => makeEvidence(e));
+  const negativeControl = opts.negative_control ?? true;
+  const confidence = computeConfidence({
+    static_analysis: true,
+    data_flow: true,
+    reachability: true,
+    preconditions: true,
+    runtime_validation: true,
+    negative_control: negativeControl
+  });
+  const level = confidenceLevel(confidence);
+  const status = negativeControl ? "confirmed" : "hypothesis";
+  return {
+    ...finding,
+    status,
+    confidence,
+    confidence_level: level,
+    validation: {
+      performed: true,
+      status: negativeControl ? "confirmed" : "unconfirmed",
+      baseline: opts.baseline ?? true,
+      negative_control: negativeControl
+    },
+    evidence: [...finding.evidence, ...evidence],
+    timestamps: { ...finding.timestamps, updated: new Date().toISOString() }
+  };
+}
+function rejectFinding(finding, status, reason, evidence) {
+  const ev = evidence?.map((e) => makeEvidence(e)) ?? [];
+  const updated = transition(finding, status);
+  return {
+    ...updated,
+    validation: { ...updated.validation, performed: false },
+    remediation: { ...updated.remediation, note: reason },
+    evidence: [...updated.evidence, ...ev],
+    timestamps: { ...updated.timestamps, updated: new Date().toISOString() }
+  };
+}
 
 // src/orchestrator.ts
 var _chainsCache = null;
@@ -50184,13 +50230,150 @@ async function liveRecon(target, includeActive = false) {
   };
 }
 
+// src/strike.ts
+var TIMEOUT_MS3 = 15000;
+async function httpRequest(url, method, data, headers) {
+  const controller = new AbortController;
+  const t = setTimeout(() => controller.abort(), TIMEOUT_MS3);
+  try {
+    const res = await fetch(url, {
+      method,
+      body: method === "POST" ? data : undefined,
+      headers: { "User-Agent": "blitzstrike/1.0", ...headers ?? {} },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const body = await res.text();
+    const hdrs = {};
+    res.headers.forEach((v, k) => {
+      hdrs[k] = v;
+    });
+    return { status: res.status, body: body.slice(0, 20000), headers: hdrs };
+  } catch (e) {
+    return { status: 0, body: String(e), headers: {} };
+  } finally {
+    clearTimeout(t);
+  }
+}
+function defaultMarker() {
+  return `BS${Date.now().toString(36).toUpperCase()}${Math.random().toString(36).slice(2, 8).toUpperCase()}`;
+}
+function inject(target, value, param) {
+  const placeholder = "{{MARKER}}";
+  if (target.includes(placeholder))
+    return target.split(placeholder).join(value);
+  if (target.includes("?"))
+    return `${target}&${param}=${encodeURIComponent(value)}`;
+  return `${target}?${param}=${encodeURIComponent(value)}`;
+}
+async function strikeVerify(input) {
+  const method = input.method ?? "GET";
+  const param = input.param ?? "q";
+  const marker = input.marker ?? defaultMarker();
+  const control = input.control ?? defaultMarker();
+  const baseUrl = input.url;
+  const baselineTarget = inject(baseUrl, "", param).replace(/[?&]q=$/, "").replace(/[?&]$/, "");
+  const markerTarget = inject(baseUrl, marker, param);
+  const controlTarget = inject(baseUrl, control, param);
+  const baseline = await httpRequest(baselineTarget, method, input.data, input.headers);
+  const markerResp = await httpRequest(markerTarget, method, input.data, input.headers);
+  const controlResp = await httpRequest(controlTarget, method, input.data, input.headers);
+  if (baseline.status === 0 || markerResp.status === 0) {
+    return {
+      status: "blocked",
+      marker_reflected: false,
+      control_reflected: false,
+      baseline: { status: baseline.status, body_preview: redactSecrets(baseline.body.slice(0, 400)), body_hash: sha256(baseline.body) },
+      marker_response: { status: markerResp.status, body_preview: redactSecrets(markerResp.body.slice(0, 400)), body_hash: sha256(markerResp.body) },
+      control_response: { status: controlResp.status, body_preview: redactSecrets(controlResp.body.slice(0, 400)), body_hash: sha256(controlResp.body) },
+      reason: "request failed or target unreachable — cannot validate",
+      evidence: []
+    };
+  }
+  const markerReflected = markerResp.body.includes(marker);
+  const controlReflected = controlResp.body.includes(control);
+  let status;
+  let reason;
+  if (markerReflected && !controlReflected) {
+    status = "confirmed";
+    reason = "marker reflected; negative control did not — the sink reflects attacker-controlled input (real finding)";
+  } else if (markerReflected && controlReflected) {
+    status = "false_positive";
+    reason = "marker AND negative control both reflected — behaviour is indistinguishable from benign reflection (likely false positive)";
+  } else if (!markerReflected && !controlReflected) {
+    status = "unconfirmed";
+    reason = "marker not reflected — reachability/exploitability could not be demonstrated live";
+  } else {
+    status = "unconfirmed";
+    reason = "negative control reflected but marker did not — inconsistent, requires deeper analysis";
+  }
+  const evidence = [
+    {
+      type: "baseline_comparison",
+      description: `Baseline response (status ${baseline.status}) for ${redactSecrets(baselineTarget)}`,
+      artifacts: [{ name: "baseline", kind: "http_response", content: `${baseline.status}
+${baseline.body}` }]
+    },
+    {
+      type: "validation_result",
+      description: `Marker '${redactSecrets(marker)}' reflected=${markerReflected}; control reflected=${controlReflected}`,
+      artifacts: [{ name: "marker_response", kind: "http_response", content: `${markerResp.status}
+${markerResp.body}` }]
+    },
+    {
+      type: "negative_control",
+      description: `Negative control '${redactSecrets(control)}' reflected=${controlReflected}`,
+      artifacts: [{ name: "control_response", kind: "http_response", content: `${controlResp.status}
+${controlResp.body}` }]
+    }
+  ];
+  return {
+    status,
+    marker_reflected: markerReflected,
+    control_reflected: controlReflected,
+    baseline: { status: baseline.status, body_preview: redactSecrets(baseline.body.slice(0, 400)), body_hash: sha256(baseline.body) },
+    marker_response: { status: markerResp.status, body_preview: redactSecrets(markerResp.body.slice(0, 400)), body_hash: sha256(markerResp.body) },
+    control_response: { status: controlResp.status, body_preview: redactSecrets(controlResp.body.slice(0, 400)), body_hash: sha256(controlResp.body) },
+    reason,
+    evidence
+  };
+}
+function resolveFinding(finding, verdict) {
+  let f = finding;
+  if (f.status === "hypothesis") {
+    f = transition(f, "validating");
+  }
+  switch (verdict.status) {
+    case "confirmed":
+      return confirmFinding(f, {
+        evidence: verdict.evidence,
+        negative_control: true,
+        baseline: true
+      });
+    case "false_positive":
+      return rejectFinding(f, "false_positive", verdict.reason, verdict.evidence);
+    case "blocked":
+      return rejectFinding(f, "blocked", verdict.reason, verdict.evidence);
+    case "unconfirmed":
+    case "likely":
+    default: {
+      return {
+        ...f,
+        validation: { performed: true, status: verdict.status === "likely" ? "likely" : "unconfirmed", negative_control: verdict.control_reflected === false, baseline: true },
+        remediation: { ...f.remediation, note: verdict.reason },
+        timestamps: { ...f.timestamps, updated: new Date().toISOString() }
+      };
+    }
+  }
+}
+
 // src/server.ts
 function createServer() {
   const server = new McpServer({
     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).\\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; the finding is confirmed only when your marker reflects AND " + "   the negative control stays inert. 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: full one-call audit (scope gate -> triage -> chain enrichment " + "  -> findings with tool manuals attached).\\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: 85 playbooks (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" + "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).\\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: full one-call audit (scope gate -> triage -> chain enrichment " + "  -> findings with tool manuals attached).\\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: 85 playbooks (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",
@@ -50272,55 +50455,66 @@ function createServer() {
   });
   server.registerTool("strike_verify", {
     title: "STRIKE live verification",
-    description: "STRIKE: live HTTP verification with marker + negative control. A hit is a HYPOTHESIS until the marker reflects.",
+    description: "STRIKE: live HTTP verification with marker + negative control + baseline. Verdict: confirmed (marker reflected, control NOT) / false_positive (both reflected) / unconfirmed (marker not reflected) / blocked. Returns redacted SHA-256-tagged evidence. " + "USE WHEN: you have a hypothesis and need to prove (or refute) it live. " + "NEXT: feed the verdict to strike_resolve to advance the finding's lifecycle.",
     inputSchema: {
       url: string2().describe("Target URL"),
       method: _enum(["GET", "POST"]).optional().describe("HTTP method"),
-      data: string2().optional().describe("POST body (urlencoded)"),
+      data: string2().optional().describe("POST body template; a literal {{MARKER}} is replaced"),
       headers: string2().optional().describe("JSON object of extra headers"),
-      marker: string2().optional().describe("String that must appear in the response to confirm"),
+      marker: string2().optional().describe("Unique string the payload should reflect (defaults to a random token)"),
+      control: string2().optional().describe("Benign lookalike for the negative control (defaults to a random token)"),
+      param: string2().optional().describe("Query/body param name to inject into (default 'q')"),
       timeout: number2().int().optional().describe("Timeout seconds (default 15)")
     }
-  }, async ({ url, method, data, headers, marker, timeout }) => {
-    const controller = new AbortController;
-    const t = setTimeout(() => controller.abort(), (timeout ?? 15) * 1000);
+  }, async ({ url, method, data, headers, marker, control, param, timeout }) => {
     let hdrs = {};
     try {
       hdrs = headers ? JSON.parse(headers) : {};
     } catch {}
+    const verdict = await strikeVerify({
+      url,
+      method: method ?? "GET",
+      data,
+      headers: hdrs,
+      marker,
+      control,
+      param
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          ...verdict,
+          next_steps: [
+            `Verdict: ${verdict.status} — ${verdict.reason}`,
+            verdict.status === "confirmed" ? "Confirmed. Attach to the finding with strike_resolve, then record evidence (finding_create already carried SHA-256 artifacts)." : verdict.status === "false_positive" ? "False positive. Reject the finding via strike_resolve to close it out." : "Not confirmed. Refine the payload or trace reachability (taint_file / eagle_eye) before re-validating."
+          ]
+        })
+      }]
+    };
+  });
+  server.registerTool("strike_resolve", {
+    title: "Resolve a finding from a STRIKE verdict",
+    description: "STRIKE+FINDINGS: take a canonical Finding and a STRIKE verdict, and advance the lifecycle end-to-end — hypothesis->validating->confirmed (marker reflected, control inert) or ->false_positive/blocked/unconfirmed. Returns the updated finding with evidence + recomputed confidence.",
+    inputSchema: {
+      finding: string2().describe("JSON of the canonical Finding object (from finding_create)"),
+      verdict: string2().describe("JSON of the STRIKE verdict (from strike_verify)")
+    }
+  }, async ({ finding, verdict }) => {
+    let f;
+    let v;
     try {
-      const res = await fetch(url, {
-        method: method ?? "GET",
-        body: method === "POST" ? data : undefined,
-        headers: { "User-Agent": "blitzstrike/1.0", ...hdrs },
-        signal: controller.signal,
-        redirect: "follow"
-      });
-      const body = await res.text();
-      const reflected = marker ? body.includes(marker) : true;
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              url,
-              status: res.status,
-              marker,
-              marker_reflected: reflected,
-              body_preview: body.slice(0, 800)
-            })
-          }
-        ]
-      };
-    } catch (e) {
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ url, error: String(e) }) }
-        ]
-      };
-    } finally {
-      clearTimeout(t);
+      f = JSON.parse(finding);
+    } catch {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "invalid finding JSON" }) }] };
+    }
+    try {
+      v = JSON.parse(verdict);
+    } catch {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "invalid verdict JSON" }) }] };
     }
+    const updated = resolveFinding(f, v);
+    return { content: [{ type: "text", text: JSON.stringify(updated) }] };
   });
   server.registerTool("scope_check", {
     title: "STRIKE scope enforcement",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "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": {