blitzstrike 2.4.5 → 2.4.7

package/CHANGELOG.md

@@ -5,6 +5,30 @@ 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/).
 
+## [2.4.7] — 2026-09-14
+
+### Added — deterministic arbitrary-file-read verification (no bare hypotheses)
+
+- New `verifyFileRead` (STRIKE): verifies a CWE-22 / path-traversal / LFI
+  hypothesis by reading a marker file (`/etc/passwd`) vs a non-existent
+  negative-control path, then comparing. Confirmed only when the marker returns
+  file content and the control does not — never from reasoning alone.
+- Supports raw POST body (`bodyRaw`) and named query/body param injection.
+- New MCP tool `verify_file_read` + chain hints `verify_file_read` /
+  `path_traversal` / `lfi` / `file_read` route to it; `strike_verify` now
+  auto-routes file-read findings to the file-read verifier.
+- A gated endpoint (e.g. identical 500 auth wall) now returns an explicit
+  `unconfirmed` verdict with reason instead of leaving a bare hypothesis.
+
+## [2.4.6] — 2026-09-14
+
+### Added — chrome-devtools-mcp auto-install (npx zero-install fallback)
+
+- `drive_devtools` / `browser_devtools` now auto-fetch chrome-devtools-mcp via
+  `npx -y chrome-devtools-mcp@latest` when no global binary is present — no
+  manual `npm i -g` required. (burp-suite-mcp still can't be auto-installed:
+  it's a Java/GUI app that must be built + run manually.)
+
 ## [2.4.5] — 2026-09-14
 
 ### Added — responsible-disclosure header (X-HackerOne-Research)

package/dist/index.js

@@ -15300,7 +15300,7 @@ import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync6, readFileSync
 import { join as join16 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 function dirExists(p) {
   try {
     return statSync4(p).isDirectory();
@@ -15351,14 +15351,14 @@ function syncData() {
     copyDir(localTemplates, templatesPath);
     templatesSynced = true;
   }
-  const gitOk = spawnSync2("git", ["--version"]).status === 0;
+  const gitOk = spawnSync3("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
     const tmp = join16(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync4(tmp, { recursive: true, force: true });
-    const r = spawnSync2("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
+    const r = spawnSync3("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
     if (r.status === 0) {
-      const sparse = spawnSync2("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
+      const sparse = spawnSync3("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
       if (sparse.status === 0) {
         if (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0) {
           copyDir(join16(tmp, "payloads"), payloadsPath);
@@ -15379,7 +15379,7 @@ function syncData() {
   };
 }
 function copyDir(src, dst) {
-  const r = spawnSync2("cp", ["-r", src, dst], { timeout: 120000 });
+  const r = spawnSync3("cp", ["-r", src, dst], { timeout: 120000 });
   if (r.status !== 0) {
     manualCopy(src, dst);
   }
@@ -15529,9 +15529,9 @@ import { readFileSync as readFileSync22, existsSync as existsSync10, writeFileSy
 import { join as join19, dirname as dirname2 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 function which(cmd) {
-  return spawnSync3(`command -v ${cmd}`, { shell: true }).status === 0;
+  return spawnSync4(`command -v ${cmd}`, { shell: true }).status === 0;
 }
 function installedCount() {
   const tools = loadTools();
@@ -31291,6 +31291,53 @@ ${controlResp.body}` }]
     evidence
   };
 }
+function buildFileReadRequest(url, path, param, bodyRaw) {
+  if (bodyRaw)
+    return { url, data: path };
+  return { url: inject(url, path, param ?? "path") };
+}
+async function verifyFileRead(input) {
+  const method = input.method ?? "POST";
+  const markerPath = input.markerPath ?? "/etc/passwd";
+  const controlPath = `/bs-nonexistent-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+  const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const markerReq = buildFileReadRequest(input.url, markerPath, input.param, input.bodyRaw);
+  const controlReq = buildFileReadRequest(input.url, controlPath, input.param, input.bodyRaw);
+  const markerResp = await httpRequest(markerReq.url, method, markerReq.data, input.headers, timeoutMs);
+  const controlResp = await httpRequest(controlReq.url, method, controlReq.data, input.headers, timeoutMs);
+  const passwdRe = /(^|\n)root:[x*!][^:]*:0:0:/m;
+  const markerFile = passwdRe.test(markerResp.body);
+  const controlFile = passwdRe.test(controlResp.body);
+  let status;
+  let reason;
+  if (markerResp.status === 0 && controlResp.status === 0) {
+    status = "blocked";
+    reason = "both marker and control requests failed — target unreachable";
+  } else if (markerFile && !controlFile) {
+    status = "confirmed";
+    reason = "marker file (/etc/passwd) content returned while the non-existent negative control did not — arbitrary file read confirmed";
+  } else if (markerFile && controlFile) {
+    status = "unconfirmed";
+    reason = "marker and negative control both returned passwd-like content — indistinguishable from a fixed response";
+  } else if (markerResp.status === controlResp.status && markerResp.body === controlResp.body) {
+    status = "unconfirmed";
+    reason = `marker and control returned identical responses (HTTP ${markerResp.status}) — likely an auth/session gate; file read not reachable without credentials`;
+  } else {
+    status = "unconfirmed";
+    reason = "marker file content not returned — arbitrary file read could not be demonstrated live";
+  }
+  return {
+    status,
+    file_read: markerFile && !controlFile,
+    marker_file_content: markerFile,
+    control_file_content: controlFile,
+    marker_status: markerResp.status,
+    control_status: controlResp.status,
+    marker_preview: redactSecrets(markerResp.body.slice(0, 300)),
+    control_preview: redactSecrets(controlResp.body.slice(0, 300)),
+    reason
+  };
+}
 function resolveFinding(finding, verdict) {
   let f = finding;
   if (f.status === "hypothesis") {
@@ -31587,7 +31634,7 @@ async function browserValidate(check, target, payload) {
 }
 
 // src/devtools.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
 import { join as join7 } from "node:path";
 import { homedir as homedir3 } from "node:os";
@@ -31678,11 +31725,14 @@ function findChromium() {
   }
   return null;
 }
-function chromeDevtoolsBin() {
+function chromeDevtoolsCommand() {
   for (const c of ["/usr/bin/chrome-devtools-mcp", "/usr/local/bin/chrome-devtools-mcp"]) {
     if (existsSync4(c))
       return { command: c, args: [] };
   }
+  const npx = spawnSync2("npx", ["--version"], { timeout: 8000 });
+  if (npx.error === undefined)
+    return { command: "npx", args: ["-y", "chrome-devtools-mcp@latest"] };
   return null;
 }
 function parsePageId(text) {
@@ -31690,17 +31740,12 @@ function parsePageId(text) {
   return m ? parseInt(m[1], 10) : 1;
 }
 async function driveChromeDevtools(target, timeoutMs = 25000) {
-  const bin = chromeDevtoolsBin();
+  const bin = chromeDevtoolsCommand();
   if (!bin) {
-    return { ok: false, error: "chrome-devtools-mcp not installed — run: npm install -g chrome-devtools-mcp (or npx chrome-devtools-mcp@latest)" };
+    return { ok: false, error: "chrome-devtools-mcp not available (no global binary and no npx) — install Node/npm first" };
   }
   const chrome = findChromium();
-  const args = [
-    "--headless",
-    "--isolated",
-    "--chromeArg=--no-sandbox",
-    "--chromeArg=--disable-gpu"
-  ];
+  const args = [...bin.args, "--headless", "--isolated", "--chromeArg=--no-sandbox", "--chromeArg=--disable-gpu"];
   if (chrome)
     args.push(`--executablePath=${chrome}`);
   const client = mcpClient(bin.command, args);
@@ -31828,6 +31873,10 @@ async function driveBurpMCP(baseUrl = DEFAULT_BURP_URL, timeoutMs = 1e4) {
 // src/chain-executor.ts
 var BLITZ_FINDING_TOOLS = {
   strike_verify: verifyFinding,
+  verify_file_read: fileReadFinding,
+  path_traversal: fileReadFinding,
+  lfi: fileReadFinding,
+  file_read: fileReadFinding,
   crack_hash: crackFinding,
   hashcat: crackFinding,
   hashid: crackFinding,
@@ -31861,9 +31910,15 @@ function findingText(f) {
 function findingUrl(f) {
   return (f.target?.host ?? "") + (f.target?.endpoint ?? "");
 }
+function isFileReadFinding(f) {
+  const text = `${f.classification?.cwe ?? ""} ${f.classification?.cwe_name ?? ""} ${f.sink?.type ?? ""} ${f.chain?.id ?? ""} ${f.chain?.name ?? ""} ${f.title ?? ""}`.toLowerCase();
+  return /(cwe-?22|path.?traversal|arbitrary.?file|file.?read|directory.?traversal|lfi|\btraversal\b)/.test(text);
+}
 async function verifyFinding(f) {
   const url = findingUrl(f);
   const param = f.source?.name ?? "q";
+  if (isFileReadFinding(f))
+    return fileReadFinding(f);
   const v = await strikeVerify({ url, method: "GET", param });
   return {
     status: v.status,
@@ -31873,6 +31928,16 @@ async function verifyFinding(f) {
     leaked_sinks: v.leaked_sinks ?? []
   };
 }
+async function fileReadFinding(f) {
+  const url = findingUrl(f);
+  if (!url)
+    return { executed: false, note: "no target URL on finding" };
+  const srcType = (f.source?.type ?? "").toLowerCase();
+  const bodyRaw = /(body|post|raw)/.test(srcType);
+  const method = bodyRaw ? "POST" : "GET";
+  const verdict = await verifyFileRead({ url, method, bodyRaw, param: f.source?.name });
+  return { verify_kind: "file_read", ...verdict };
+}
 async function crackFinding(f) {
   const text = findingText(f);
   const hashRe = /(\$2[aby]\$\d+\$[./A-Za-z0-9]{53}|[a-f0-9]{32}|[a-f0-9]{40}|[a-f0-9]{64})/g;
@@ -56281,6 +56346,45 @@ function createServer() {
       }]
     };
   });
+  server.registerTool("verify_file_read", {
+    title: "Verify arbitrary file read / path traversal (marker file vs negative control)",
+    description: "STRIKE: deterministic verification of an arbitrary-file-read / path-traversal hypothesis (CWE-22). Reads a marker file (/etc/passwd) vs a non-existent negative-control path and compares: confirmed (marker returns file content, control does not) / unconfirmed (indistinguishable or gated by auth) / blocked (unreachable). Supports raw POST body (bodyRaw=true) or a named query/body param. Never leaves a bare hypothesis — always returns a verdict + reason.",
+    inputSchema: {
+      url: string2().describe("Target URL (e.g. the file-read endpoint)"),
+      method: _enum(["GET", "POST"]).optional().describe("HTTP method (default POST)"),
+      param: string2().optional().describe("Query/body param name that carries the path (default 'path')"),
+      bodyRaw: boolean2().optional().describe("Treat the raw POST body as the filesystem path (default false)"),
+      headers: string2().optional().describe("JSON object of extra headers"),
+      markerPath: string2().optional().describe("Marker file to read (default /etc/passwd)"),
+      timeout: number2().int().optional().describe("Timeout seconds (default 15)")
+    }
+  }, async ({ url, method, param, bodyRaw, headers, markerPath, timeout }) => {
+    let hdrs = {};
+    try {
+      hdrs = headers ? JSON.parse(headers) : {};
+    } catch {}
+    const verdict = await verifyFileRead({
+      url,
+      method: method ?? "POST",
+      param,
+      bodyRaw: bodyRaw ?? false,
+      headers: hdrs,
+      markerPath,
+      timeoutMs: timeout ? timeout * 1000 : undefined
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          ...verdict,
+          next_steps: [
+            `Verdict: ${verdict.status} — ${verdict.reason}`,
+            verdict.status === "confirmed" ? "Confirmed arbitrary file read. Record with finding_create + attach the marker/control evidence." : verdict.status === "blocked" ? "Blocked. Target unreachable — retry or re-check scope." : "Unconfirmed. The response is gated (auth/session) or the file is not read — obtain a low-priv session and re-run with a valid session, or mark the finding unconfirmed with this evidence."
+          ]
+        })
+      }]
+    };
+  });
   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.",

package/package.json

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