blitzstrike 2.4.6 → 2.4.7

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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)

package/dist/index.js

@@ -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") {
@@ -31826,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,
@@ -31859,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,
@@ -31871,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;
@@ -56279,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.6",
+  "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": {