blitzstrike 2.4.81 → 2.4.83

package/CHANGELOG.md

@@ -5,6 +5,37 @@ 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.83] — 2026-09-17
+
+### Added — Web3 / Solidity audit (10 bug classes + Foundry PoC)
+
+- New `web3_audit(code|path)` — a deterministic, pattern-based Solidity auditor for
+  the 10 highest-value smart-contract bug classes: reentrancy, unchecked return
+  value, unchecked arithmetic, tx.origin auth, signature replay, unprotected
+  selfdestruct, delegatecall-to-user-input, missing access control, timestamp
+  dependence, spot-price oracle manipulation, and unbounded loops. Returns ranked
+  findings (class / CWE / severity / line / evidence).
+- New `foundry_poc(class, contract)` — generates an executable Foundry (forge) test
+  template that proves a finding class. A web3 hit is a HYPOTHESIS until the
+  Foundry PoC reproduces it.
+- `.sol` added to the scan extensions.
+
+Competitive analysis source: Awarexone/Agentic-Bug-Hunter (web3-audit + Foundry PoC).
+
+## [2.4.82] — 2026-09-17
+
+### Added — out-of-band (OOB) listener for blind vuln proof
+
+- New `oob_start` / `oob_poll` / `oob_stop` / `oob_list` tools give deterministic
+  proof for BLIND SSRF/XXE/SQLi/command-injection that never reflect in the HTTP
+  response. `oob_start` prefers the installed `interactsh-client` (unique *.oast.*
+  domain streaming DNS/HTTP interactions — the standard for public targets) and
+  falls back to a local HTTP listener for local labs. `oob_poll(id)` reports a hit
+  ONLY when an interaction for the session's unique id actually arrives. Handles
+  interactsh's ANSI-colored `[INF]` banner + JSONL interaction parsing.
+
+Competitive analysis source: Awarexone/Agentic-Bug-Hunter (interactsh OOB).
+
 ## [2.4.81] — 2026-09-17
 
 ### Added — impact-first prioritization via typical bounty payout

package/dist/index.js

@@ -7291,6 +7291,7 @@ var init_scanner = __esm(() => {
     ".hpp",
     ".sh",
     ".bash",
+    ".sol",
     ".conf",
     ".config",
     ".nginx",
@@ -17358,10 +17359,10 @@ var init_update = __esm(() => {
 });
 
 // src/release.ts
-import { readFileSync as readFileSync28, existsSync as existsSync14 } from "node:fs";
+import { readFileSync as readFileSync28, existsSync as existsSync15 } from "node:fs";
 import { join as join25 } from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
-import { execSync as execSync2 } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 function validateRelease() {
   const checks = [];
   checks.push({ name: "package.json version", ok: true, detail: VERSION });
@@ -17378,13 +17379,13 @@ function validateRelease() {
     checks.push({ name: "CHANGELOG version", ok: false, detail: "CHANGELOG.md not found" });
   }
   try {
-    const tag = execSync2("git describe --tags --abbrev=0", { cwd: ROOT8, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const tag = execSync3("git describe --tags --abbrev=0", { cwd: ROOT8, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     checks.push({ name: "Git tag", ok: tag === `v${VERSION}`, detail: tag, soft: true });
   } catch {
     checks.push({ name: "Git tag", ok: true, detail: "unavailable (no git/tags)", soft: true });
   }
   try {
-    const published = execSync2("npm view blitzstrike version", { encoding: "utf8", timeout: 8000, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const published = execSync3("npm view blitzstrike version", { encoding: "utf8", timeout: 8000, stdio: ["ignore", "pipe", "ignore"] }).trim();
     checks.push({ name: "npm registry version", ok: published === VERSION, detail: published, soft: true });
   } catch {
     checks.push({ name: "npm registry version", ok: true, detail: "unavailable (offline)", soft: true });
@@ -17398,7 +17399,7 @@ function validateRelease() {
   return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
 }
 function lockfilePresent() {
-  return existsSync14(join25(ROOT8, "package-lock.json")) || existsSync14(join25(ROOT8, "bun.lock")) || existsSync14(join25(ROOT8, "bun.lockb"));
+  return existsSync15(join25(ROOT8, "package-lock.json")) || existsSync15(join25(ROOT8, "bun.lock")) || existsSync15(join25(ROOT8, "bun.lockb"));
 }
 var ROOT8;
 var init_release = __esm(() => {
@@ -17440,7 +17441,7 @@ var init_dependency = __esm(() => {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync30, existsSync as existsSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
+import { readFileSync as readFileSync30, existsSync as existsSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
 import { join as join27, dirname as dirname6 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
@@ -17486,7 +17487,7 @@ async function runDoctor() {
     detail: h1 ? `X-HackerOne-Research: ${h1}` : "H1_USERNAME not set",
     fix: h1 ? undefined : "export H1_USERNAME=<your-hackerone-username> (adds X-HackerOne-Research to outbound requests)"
   });
-  const dataOk = existsSync15(join27(ROOT10, "chains.json")) && existsSync15(join27(ROOT10, "tools-catalog.json"));
+  const dataOk = existsSync16(join27(ROOT10, "chains.json")) && existsSync16(join27(ROOT10, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -17538,14 +17539,14 @@ function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
   const src = join27(ROOT10, "src", "index.ts");
-  if (which("bun") && existsSync15(src))
+  if (which("bun") && existsSync16(src))
     return { command: "bun", args: ["run", src, "serve", "--mcp"] };
   if (which("npx"))
     return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
   if (which("bunx"))
     return { command: "bunx", args: ["blitzstrike", "serve", "--mcp"] };
   const dist = join27(ROOT10, "dist", "index.js");
-  if (existsSync15(dist))
+  if (existsSync16(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
@@ -17559,7 +17560,7 @@ function readJson(p) {
 function jsonMcpServersWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcpServers = {
@@ -17572,7 +17573,7 @@ function jsonMcpServersWrite(p) {
 function opencodeWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcp = {
@@ -17586,14 +17587,14 @@ function opencodeWrite(p) {
 function copyOpenCodeAgents() {
   const srcDir = join27(ROOT10, "opencode-agents");
   const dstDir = join27(homedir11(), ".config", "opencode", "agents");
-  if (!existsSync15(srcDir))
+  if (!existsSync16(srcDir))
     return;
-  if (!existsSync15(dstDir))
+  if (!existsSync16(dstDir))
     mkdirSync10(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
     const src = join27(srcDir, f);
     const dst = join27(dstDir, f);
-    if (existsSync15(src)) {
+    if (existsSync16(src)) {
       writeFileSync9(dst, readFileSync30(src, "utf8"));
     }
   }
@@ -17601,9 +17602,9 @@ function copyOpenCodeAgents() {
 function codexWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync15(p) ? readFileSync30(p, "utf8") : "";
+    let existing = existsSync16(p) ? readFileSync30(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -17620,9 +17621,9 @@ args = ${JSON.stringify(args)}
 function hermesWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync15(p) ? readFileSync30(p, "utf8") : "";
+    let existing = existsSync16(p) ? readFileSync30(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -17653,70 +17654,70 @@ function detectAgents() {
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
-    installed: () => existsSync15(claudeJson) || which("claude"),
+    installed: () => existsSync16(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
   const claudeDesktop = join27(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
-    installed: () => existsSync15(claudeDesktop),
+    installed: () => existsSync16(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
   const cursor = join27(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync15(join27(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync16(join27(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
   const opencode = join27(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync15(join27(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync16(join27(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
   const codex = join27(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync15(join27(home, ".codex")) || which("codex"),
+    installed: () => existsSync16(join27(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
   const hermes = join27(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync15(join27(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync16(join27(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
   const gemini = join27(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync15(join27(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync16(join27(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
   const windsurf = join27(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync15(join27(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync16(join27(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
   const copilot = join27(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync15(join27(home, ".copilot")),
+    installed: () => existsSync16(join27(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
   const cline = join27(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync15(join27(home, ".cline")),
+    installed: () => existsSync16(join27(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -60177,8 +60178,476 @@ function analyzeJwt(token, opts = {}) {
   };
 }
 
+// src/oob.ts
+import { spawn as spawn3, execSync as execSync2 } from "node:child_process";
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { networkInterfaces } from "node:os";
+import { existsSync as existsSync13 } from "node:fs";
+var sessions = new Map;
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function findInteractsh() {
+  try {
+    const p = execSync2("which interactsh-client 2>/dev/null", { encoding: "utf8", timeout: 3000 }).trim();
+    if (p)
+      return p;
+  } catch {}
+  const home = process.env.HOME ?? "/root";
+  const candidates = [`${home}/go/bin/interactsh-client`, "/usr/local/bin/interactsh-client", "/usr/bin/interactsh-client"];
+  for (const c of candidates)
+    if (existsSync13(c))
+      return c;
+  return null;
+}
+function stripAnsi(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function extractDomain(buffer) {
+  const m = stripAnsi(buffer).match(/\[INF\]\s+([a-z0-9]{20,}\.[a-z0-9.-]+)/i);
+  return m ? m[1] : null;
+}
+function parseInteractions(buffer) {
+  const out = [];
+  for (const raw of stripAnsi(buffer).split(`
+`)) {
+    const line = raw.trim();
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const j = JSON.parse(line);
+      if (j && j.protocol && j.timestamp) {
+        const req = typeof j["raw-request"] === "string" ? j["raw-request"].split(/\r?\n/)[0] : null;
+        out.push({
+          protocol: j.protocol,
+          remote_address: j["remote-address"] ?? null,
+          request_line: req,
+          timestamp: j.timestamp,
+          unique_id: j["unique-id"] ?? null
+        });
+      }
+    } catch {}
+  }
+  return out;
+}
+function localIP() {
+  const ifaces = networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    for (const iface of ifaces[name] ?? []) {
+      if (iface.family === "IPv4" && !iface.internal)
+        return iface.address;
+    }
+  }
+  return "127.0.0.1";
+}
+function result(s, extra = {}) {
+  return {
+    id: s.id,
+    mode: s.mode,
+    domain: s.domain ?? null,
+    url: s.url ?? null,
+    payload_url: s.url ? `\${oob_url}` : null,
+    payload_dns: s.domain ? `\${oob_dns}` : null,
+    templates: s.domain ? {
+      dns: `\${oob_dns}`,
+      http: `http://\${oob_dns}`,
+      ssrf_xxe: `http://\${oob_dns}/<marker>`,
+      sql_blind: `http://\${oob_dns}/<marker>`
+    } : { http: `http://${s.url}/<marker>` },
+    ...extra
+  };
+}
+async function oobStart() {
+  const bin = findInteractsh();
+  if (bin) {
+    const id = randomUUID().slice(0, 8);
+    const session = { id, mode: "interactsh", buffer: "", hits: [], startedAt: Date.now() };
+    session.proc = spawn3(bin, ["-json"], { stdio: ["ignore", "pipe", "pipe"] });
+    session.proc.stdout?.on("data", (d) => session.buffer += d.toString());
+    session.proc.stderr?.on("data", (d) => session.buffer += d.toString());
+    sessions.set(id, session);
+    const deadline = Date.now() + 25000;
+    while (Date.now() < deadline) {
+      const domain = extractDomain(session.buffer);
+      if (domain) {
+        session.domain = domain;
+        session.url = `http://${domain}`;
+        return result(session, { status: "listening" });
+      }
+      await sleep(300);
+    }
+    return result(session, { status: "timeout", note: "interactsh-client did not register a domain within 15s — check network / oast server reachability" });
+  }
+  return startSelfHost();
+}
+function startSelfHost() {
+  const id = randomUUID().slice(0, 8);
+  const session = { id, mode: "selfhost", buffer: "", hits: [], startedAt: Date.now() };
+  const server = createServer((req, res) => {
+    let body = "";
+    req.on("data", (c) => body += c);
+    req.on("end", () => {
+      session.hits.push({
+        protocol: "http",
+        method: req.method,
+        path: req.url,
+        remote_address: req.socket.remoteAddress,
+        headers: req.headers,
+        body: body.slice(0, 2000),
+        timestamp: new Date().toISOString()
+      });
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("oob-ok");
+    });
+  });
+  server.listen(0, "0.0.0.0");
+  const port = server.address().port;
+  session.server = server;
+  session.port = port;
+  session.url = `http://${localIP()}:${port}`;
+  sessions.set(id, session);
+  return result(session, {
+    status: "listening",
+    note: "local listener (target must reach this host); for a remote target, expose it via a tunnel (e.g. pinggy) and re-point the payload"
+  });
+}
+function oobPoll(id) {
+  const s = sessions.get(id);
+  if (!s)
+    return { error: "unknown session id (was it stopped or did the server restart?)" };
+  if (s.mode === "selfhost") {
+    const fresh = s.hits.slice(0);
+    s.hits.length = 0;
+    return { id, mode: s.mode, url: s.url, found: fresh.length > 0, hits: fresh, total_hits_seen: fresh.length };
+  }
+  const interactions = parseInteractions(s.buffer);
+  const known = new Set(s.hits.map((h) => `${h.timestamp}|${h.protocol}|${h.request_line ?? ""}`));
+  const fresh = interactions.filter((i) => !known.has(`${i.timestamp}|${i.protocol}|${i.request_line ?? ""}`));
+  s.hits.push(...fresh);
+  return { id, mode: s.mode, domain: s.domain, url: s.url, found: fresh.length > 0, hits: fresh, total_hits_seen: s.hits.length };
+}
+function oobStop(id) {
+  const s = sessions.get(id);
+  if (!s)
+    return { error: "unknown session id" };
+  try {
+    s.proc?.kill("SIGTERM");
+  } catch {}
+  try {
+    s.server?.close();
+  } catch {}
+  sessions.delete(id);
+  return { id, stopped: true, total_hits_seen: s.hits.length };
+}
+function oobList() {
+  return { active: [...sessions.values()].map((s) => ({ id: s.id, mode: s.mode, domain: s.domain, url: s.url, age_sec: Math.round((Date.now() - s.startedAt) / 1000) })) };
+}
+
+// src/web3.ts
+var SEVERITY = {
+  reentrancy: { severity: "critical", cwe: "CWE-841", category: "Reentrancy (state change after external call)" },
+  unchecked_return: { severity: "high", cwe: "CWE-252", category: "Unchecked return value of low-level call" },
+  unchecked_arithmetic: { severity: "high", cwe: "CWE-190", category: "Unchecked arithmetic (overflow/underflow)" },
+  tx_origin_auth: { severity: "high", cwe: "CWE-284", category: "tx.origin authentication (phishing)" },
+  signature_replay: { severity: "high", cwe: "CWE-294", category: "Signature replay (no nonce/chainId/deadline)" },
+  unprotected_selfdestruct: { severity: "critical", cwe: "CWE-284", category: "Unprotected selfdestruct" },
+  delegatecall_user_input: { severity: "critical", cwe: "CWE-284", category: "delegatecall to user-controlled address" },
+  missing_access_control: { severity: "high", cwe: "CWE-284", category: "Privileged function missing access control" },
+  timestamp_dependence: { severity: "medium", cwe: "CWE-1164", category: "block.timestamp / block.number dependence" },
+  oracle_manipulation: { severity: "high", cwe: "CWE-1235", category: "Spot-price oracle (DEX pair) manipulation" },
+  unbounded_loop: { severity: "medium", cwe: "CWE-834", category: "Unbounded loop over user-controlled length" }
+};
+function lines3(code) {
+  return code.split(`
+`);
+}
+function lineNo4(code, idx) {
+  let n = 1;
+  for (let i = 0;i < idx; i++)
+    if (code.charCodeAt(i) === 10)
+      n++;
+  return n;
+}
+function stripComments2(code) {
+  let out = "";
+  let i = 0;
+  const n = code.length;
+  while (i < n) {
+    const c = code[i];
+    const nx = code[i + 1];
+    if (c === "/" && nx === "/") {
+      while (i < n && code[i] !== `
+`)
+        i++;
+      out += `
+`;
+    } else if (c === "/" && nx === "*") {
+      i += 2;
+      let closed = false;
+      while (i < n) {
+        if (code[i] === "*" && code[i + 1] === "/") {
+          i += 2;
+          closed = true;
+          break;
+        }
+        if (code[i] === `
+`)
+          out += `
+`;
+        i++;
+      }
+      if (!closed)
+        break;
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
+}
+function push(out, file, code, idx, cls, evidence, detail) {
+  const meta = SEVERITY[cls];
+  out.push({ file, line: lineNo4(code, idx), class_: cls, category: meta.category, severity: meta.severity, cwe: meta.cwe, evidence, detail });
+}
+function functionBody3(code, name) {
+  const re = new RegExp(`function\\s+${name}\\s*\\([^)]*\\)[^{]*\\{`);
+  const m = re.exec(code);
+  if (!m)
+    return null;
+  const open = code.indexOf("{", m.index);
+  let depth = 0;
+  for (let i = open;i < code.length; i++) {
+    if (code[i] === "{")
+      depth++;
+    else if (code[i] === "}") {
+      depth--;
+      if (depth === 0)
+        return code.slice(open, i + 1);
+    }
+  }
+  return code.slice(open);
+}
+function web3Audit(code, file) {
+  const out = [];
+  const clean = stripComments2(code);
+  const ls = lines3(code);
+  const callRe = /\.call\{value:|\.call\(|\.send\(|\.transfer\(/g;
+  let m;
+  while ((m = callRe.exec(clean)) !== null) {
+    const ln = lineNo4(code, m.index);
+    const bodyEnd = clean.indexOf(`
+    }`, m.index);
+    const tail = clean.slice(m.index, bodyEnd === -1 ? clean.length : bodyEnd);
+    if (/\b[a-z_][a-z0-9_]*\s*(\[[^\]]*\])?\s*[-+]?=/.test(tail.slice(tail.indexOf(")") + 1))) {
+      push(out, file, code, m.index, "reentrancy", (ls[ln - 1] ?? "").trim(), "An external call is followed by a state mutation in the same function — a classic reentrancy window (the callee can re-enter before state is settled). Apply the checks-effects-interactions pattern: update state FIRST, then make the external call; or use a reentrancy guard (OpenZeppelin ReentrancyGuard).");
+    }
+  }
+  const lowCallRe = /(?:\(bool\s+\w+\s*,\s*\)\s*=\s*)?([\w.\[\]()]+)\.(?:call|send)\s*(?:\{|\(|;)/g;
+  while ((m = lowCallRe.exec(clean)) !== null) {
+    const ln = lineNo4(code, m.index);
+    const line = ls[ln - 1] ?? "";
+    if (/\.call\{value:/.test(line))
+      continue;
+    if (/require\s*\(|if\s*\(/.test(line))
+      continue;
+    push(out, file, code, m.index, "unchecked_return", line.trim(), "A low-level `.call`/`.send` return value is not checked — the call can silently fail (e.g. out-of-gas) while execution continues. Check the boolean success and revert on failure.");
+  }
+  const uncheckedRe = /\bunchecked\s*\{/g;
+  while ((m = uncheckedRe.exec(clean)) !== null) {
+    push(out, file, code, m.index, "unchecked_arithmetic", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), "An `unchecked { }` block disables overflow/underflow checks (Solidity ≥0.8) — arithmetic inside can wrap. Verify each operation is provably safe, or remove the block.");
+  }
+  const txOriginRe = /\btx\.origin\b/g;
+  while ((m = txOriginRe.exec(clean)) !== null) {
+    push(out, file, code, m.index, "tx_origin_auth", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), "`tx.origin` is used for authorization — it can be a phishing victim's address when called through a malicious intermediary contract. Use `msg.sender` for auth.");
+  }
+  const ecRe = /\becrecover\s*\(/g;
+  while ((m = ecRe.exec(clean)) !== null) {
+    const ln = lineNo4(code, m.index);
+    const scope = clean.slice(Math.max(0, m.index - 600), m.index);
+    if (/\bnonce\b/i.test(scope) && (/\bchainId\b|\bblock\.chainid\b/i.test(scope) || /\bdeadline\b/i.test(scope)))
+      continue;
+    push(out, file, code, m.index, "signature_replay", (ls[ln - 1] ?? "").trim(), "`ecrecover` validates a signature without binding it to a nonce / chainId / deadline — the same signature can be replayed on another chain or re-submitted. Include a nonce, the chain id, and an expiry in the signed digest.");
+  }
+  const selfRe = /\bselfdestruct\s*\(/g;
+  while ((m = selfRe.exec(clean)) !== null) {
+    const ln = lineNo4(code, m.index);
+    const scope = clean.slice(Math.max(0, m.index - 800), m.index);
+    if (/onlyOwner|require\s*\(\s*msg\.sender|Ownable|onlyRole|_checkOwner/.test(scope))
+      continue;
+    push(out, file, code, m.index, "unprotected_selfdestruct", (ls[ln - 1] ?? "").trim(), "`selfdestruct` is reachable without an ownership/role check — an attacker can destroy the contract and force-send its balance. Gate it behind the owner and emit an event.");
+  }
+  const delRe = /\.delegatecall\s*\(/g;
+  while ((m = delRe.exec(clean)) !== null) {
+    push(out, file, code, m.index, "delegatecall_user_input", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), "`delegatecall` to a user-controlled address executes the target's code in the caller's storage context — arbitrary storage overwrite / selfdestruct. Never delegatecall to an address derived from user input.");
+  }
+  const fnRe = /function\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\([^)]*\)/g;
+  const privileged = /\b(mint|burn|setOwner|transferOwnership|setPrice|setFee|pause|unpause|upgrade|initialize|claim|withdrawAll|drain|rescue)\b/i;
+  while ((m = fnRe.exec(clean)) !== null) {
+    const name = m[1];
+    if (!privileged.test(name))
+      continue;
+    const body = functionBody3(code, name);
+    if (!body)
+      continue;
+    const authRe = /\bonlyOwner\b|\brequire\s*\(\s*msg\.sender|Ownable|onlyRole|_checkOwner|_onlyOwner|\bowner\b\s*==/.test(body) || /\bmodifier\b/.test(body);
+    if (authRe)
+      continue;
+    push(out, file, code, m.index, "missing_access_control", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), `Privileged function \`${name}()\` has no visible access control (onlyOwner / require(msg.sender==owner) / role check) — anyone can call it. Add an ownership/role modifier.`);
+  }
+  const tsRe = /\bblock\.(timestamp|number|hash|difficulty|coinbase)\b/g;
+  while ((m = tsRe.exec(clean)) !== null) {
+    push(out, file, code, m.index, "timestamp_dependence", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), "`block.timestamp`/`block.number` is used in critical logic — miners can manipulate it within a range, and it must never be a source of randomness or a payout/auction boundary. Use an oracle (Chainlink VRF) for randomness and tolerate timestamp skew.");
+  }
+  const oracleRe = /\bgetReserves\s*\(|\bspotPrice\b|\bgetAmountsOut\s*\(|\bgetAmountOut\s*\(/g;
+  while ((m = oracleRe.exec(clean)) !== null) {
+    push(out, file, code, m.index, "oracle_manipulation", (ls[lineNo4(code, m.index) - 1] ?? "").trim(), "A DEX pair's spot price (`getReserves`/`getAmountOut`) is used as a price oracle — it can be manipulated with a flash loan. Use a time-weighted average price (TWAP) or a Chainlink price feed.");
+  }
+  const loopRe = /for\s*\([^;]*;[^;]*;\s*[^)]*\)/g;
+  while ((m = loopRe.exec(clean)) !== null) {
+    const ln = lineNo4(code, m.index);
+    const line = ls[ln - 1] ?? "";
+    if (!/\.length\b/.test(line))
+      continue;
+    if (/require\s*\([^)]*\.length\s*[<]=?\s*\d+/.test(line))
+      continue;
+    push(out, file, code, m.index, "unbounded_loop", line.trim(), "A loop iterates over a user-controlled array length with no bound — an attacker can grow the array to force an out-of-gas DoS. Cap the iteration or use a pull-based pattern.");
+  }
+  const seen = new Set;
+  return out.filter((f) => {
+    const k = `${f.class_}:${f.line}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  });
+}
+function web3Rank(findings) {
+  const order = { critical: 0, high: 1, medium: 2 };
+  const agg = new Map;
+  for (const f of findings) {
+    const e = agg.get(f.class_) ?? { count: 0, severity: f.severity, cwe: f.cwe };
+    e.count++;
+    agg.set(f.class_, e);
+  }
+  return [...agg.entries()].map(([class_, v]) => ({ class_, ...v })).sort((a, b) => order[a.severity] - order[b.severity] || b.count - a.count);
+}
+function foundryPoc(cls, contractName = "Vulnerable") {
+  const base = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "forge-std/Test.sol";
+import "../src/${contractName}.sol";
+
+contract ${contractName}Poc is Test {
+    ${contractName} internal target;
+    address internal attacker = address(0xBEEF);
+    address internal victim = address(0xCAFE);
+
+    function setUp() public {
+        target = new ${contractName}();
+        // fund the target / victim as needed
+    }
+`;
+  const exploit = {
+    reentrancy: `    function testReentrancy() public {
+        // Attacker contract re-enters before state is settled
+        ReentrantAttacker a = new ReentrantAttacker(address(target));
+        a.attack{value: 1 ether}();
+        assertGt(address(a).balance, 1 ether, "attacker drained more than deposited");
+    }
+}
+
+contract ReentrantAttacker {
+    Vulnerable t;
+    constructor(address _t) { t = Vulnerable(_t); }
+    function attack() external payable {
+        t.deposit{value: msg.value}();
+        t.withdraw(msg.value);
+    }
+    receive() external payable {
+        if (address(t).balance > 0) t.withdraw(msg.value);
+    }
+}`,
+    unchecked_return: `    function testUncheckedReturn() public {
+        // force the low-level call to fail, observe the contract keeps going
+        (bool ok, ) = address(target).call{value: 0}(abi.encodeWithSignature("fail()"));
+        assertFalse(ok, "call should fail");
+    }`,
+    unchecked_arithmetic: `    function testUncheckedArithmetic() public {
+        // trigger the wrap that the unchecked block allowed
+        vm.expectRevert(); // replace with a concrete overflow/underflow assertion
+        target.triggerOverflow();
+    }`,
+    tx_origin_auth: `    function testTxOriginAuth() public {
+        // a malicious intermediary makes the victim (tx.origin) call the target
+        Phisher p = new Phisher(address(target));
+        vm.prank(victim, victim);
+        p.forward();
+    }
+}
+
+contract Phisher {
+    Vulnerable t;
+    constructor(address _t) { t = Vulnerable(_t); }
+    function forward() external { t.restricted(); }
+}`,
+    signature_replay: `    function testSignatureReplay() public {
+        // replay the same signature on a second chain / a second time
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(attackerPk, digest);
+        target.claim(attacker, 1 ether, deadline, v, r, s);
+        // replay it — should revert if nonce/chainId bound
+        vm.expectRevert();
+        target.claim(attacker, 1 ether, deadline, v, r, s);
+    }`,
+    unprotected_selfdestruct: `    function testUnprotectedSelfdestruct() public {
+        vm.prank(attacker);
+        target.kill(); // should revert — only owner may selfdestruct
+        assertEq(address(target).code.length, 0, "contract destroyed by non-owner");
+    }`,
+    delegatecall_user_input: `    function testDelegatecallUserInput() public {
+        // attacker supplies a malicious implementation that selfdestructs
+        Evil impl = new Evil();
+        vm.prank(attacker);
+        target.setImplementation(address(impl));
+        vm.expectRevert();
+        target.exec();
+    }
+}
+
+contract Evil {
+    function kill() external { selfdestruct(payable(tx.origin)); }
+}`,
+    missing_access_control: `    function testMissingAccessControl() public {
+        vm.prank(attacker);
+        target.mint(attacker, 1_000_000 ether); // should require owner
+        assertEq(target.balanceOf(attacker), 0, "attacker minted without auth");
+    }`,
+    timestamp_dependence: `    function testTimestampDependence() public {
+        // warp the timestamp to a favorable value and observe the payout/randomness
+        vm.warp(block.timestamp + 1000);
+        target.resolve();
+    }`,
+    oracle_manipulation: `    function testOracleManipulation() public {
+        // swap a large amount to move the spot price, then exploit the target
+        pool.swap(attacker, 1_000_000 ether); // move spot price
+        target.trade();
+        assertGt(target.balanceOf(attacker), 0, "spot-price oracle was manipulated");
+    }`,
+    unbounded_loop: `    function testUnboundedLoop() public {
+        // grow the array past the gas limit to force a DoS
+        for (uint i = 0; i < 100_000; i++) target.add(address(uint160(i)));
+        vm.expectRevert(); // or assert gas consumption
+        target.processAll();
+    }`
+  };
+  return base + (exploit[cls] ?? exploit.missing_access_control) + `
+}
+`;
+}
+
 // src/enterprise-benchmark.ts
-import { existsSync as existsSync13, readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
 import { join as join23, resolve } from "node:path";
 init_complex_bugs();
 var ROOT6 = resolve(process.cwd(), "bench", "enterprise");
@@ -60239,7 +60708,7 @@ function detectFixture(dir) {
 function runEnterpriseBenchmark() {
   const fixtures = [];
   for (const fx of ENTERPRISE_FIXTURES) {
-    if (!existsSync13(fx.dir)) {
+    if (!existsSync14(fx.dir)) {
       fixtures.push({ id: fx.id, available: false, detected: 0, expected: fx.expected_vulns, recall: 0 });
       continue;
     }
@@ -60421,7 +60890,7 @@ function coverageMatrix() {
 // src/server.ts
 init_update();
 init_version();
-function createServer() {
+function createServer2() {
   const server = new McpServer({
     name: "blitzstrike",
     version: VERSION
@@ -60434,7 +60903,7 @@ function createServer() {
 ` + `- A hard block (Cloudflare/WAF/IP-block/captcha) is NOT the end: mark the finding blocked + note the required vantage (residential / authorized / correct-SNI / --resolve direct-to-origin), then CONTINUE to the next lead (origin bypass, non-prod cluster, mobile APK, subdomain).
 ` + `- Keep trying every lead AND every chain step until each is verified/executed or blocked, THEN generate_report. Never deliver a bare surface map, and never stop at 'found X' when X enables more.
 
-` + "TWO PATHS:\\n" + "- Source path on disk -> blitz_scan / taint_file / eagle_eye2 (static).\\n" + "- Live URL -> live_recon / active_scan / strike_verify (web-hunting).\\n\\n" + "DEEPEN A FINDING: attack_plan(target, tech, params) to get the prioritized vector plan (decide what to test next with data); list_chains (escalation), chain_links (compose), technique_lookup(cls), payload_lookup, bypass_lookup (blocked). Ground any detector hit empirically with pattern_lookup(id) — it returns the class's CWE, real-world signature, escalation chains, citable references, per-class bypass techniques, and the high-value assets (crown jewels) that class hits, so a raw hit becomes a class-aware finding. Resolve free-form terminology first with synonym_lookup(term) (IDOR/BOLA/SQLi/prompt-injection → canonical id). For an llm_injection hit, its pattern carries a validation discipline — the RUN-TWICE RULE (reproduce token-for-token across two fresh sessions), NON-GUESSABLE ANCHOR (must leak a real key/URL, not a plausible guess), and OOB PROOF (a verifiable callback log) — apply all three before reporting. BEFORE generating a report, run submission_gate(...) and only ship a finding that passes all 7 questions (reproducible, in-scope, real-impact, no-privileged-assumption, verified-live, evidence-redacted, severity-derived); one false = kill it. Calibrate severity with severity_calibrate(type, cvss) to get a P1–P5 tier + VRT-style category. Start each engagement with engagement_scaffold(target, scope) for the folder + scope.md structure, and check data_refresh() to confirm the data layers are consistent. Phase doctrine: read_skill(bs-orchestrate-engagement | bs-web-hunting | bs-source-audit | bs-verify-finding). Campaign plan: read_playbook(target-type). On any failure call retry_guidance(signal) / model_fallback(signal) before giving up.\n" + "KNOWLEDGE BASE (discover, don't guess): skillLookup(topic) / listSkills for the 40 attack-path + hunting skills (ap-*, hp-*, bs-*); list_attack_vectors / attack_vectors(cat) for the 34-category vector taxonomy; taxonomy(kind) for OWASP/CWE/ASVS/API-top-10; read_playbook(type) for the 17 campaign playbooks; list_manuals / read_tool_manual for 317 tool references; list_tools / run_catalog_tool for the 141-tool catalog. Every tool, skill, and data layer is reachable from these. CROSS-TARGET INTELLIGENCE: strike_resolve auto-records confirmed/false_positive verdicts into the empirical ledger; query it with intelligence(action=hit_rates/top_vectors/recall) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). intelligence(action=recall, tech, target) is the per-engagement pattern recall — it returns which patterns historically CONFIRMED on that tech (prioritize them) versus which only ever produced false positives (avoid them), so a new engagement starts from the empirical playbook of past ones. LIVE PENTEST + TARGETING (black-box, WAF-safe): cache_gap(base_url, endpoint) fuzzes path-normalization + static-extension variants for cache deception/poisoning; blind_oracle(base_url, param, value) detects which SINK a param reaches (sql/ssti/xss) via benign arithmetic (id=1+0, test${7*7}) WITHOUT a malicious payload; param_precedence(base_url, param, A, B) maps duplicate-parameter precedence (first/last-wins) for WAF-bypass. SOURCE TARGETING: action_surface(code) maps every wp_ajax_* action to its vuln class + DERIVED priority (what to look for WHERE); security_state(sanitizers, sink) gives a wrong-context sanitization verdict; framework_knowledge(framework) returns auth/nonce primitives for 9 frameworks; variant_scan(root, signature) mass-sweeps an install base for ONE bug family; patch_analyze(old, new) REVERSES a security patch into the 0-day, and its mine_signature feeds variant_scan to sweep unpatched copies. All of these are DETECTION HINTS — verify each live (strike_verify / browser_validate) before it enters the report. NEWEST DETECTORS — understand AND try them: variant_scan also emits priv_esc (privilege escalation — a role/capability/user change fed by request input, traced cross-file via reverse call-graph, e.g. set_role($id, sanitize_key($_POST['um-role'])) or update_user_meta(...,'wp_capabilities', $_POST[...])) and flags uploadAllow=>array('all') unrestricted-upload configs as file_upload (the file-manager/connector shape). TO TRY a priv_esc hit: submit the role field with 'administrator' (or send wp_capabilities meta) and confirm the account actually gains admin. TO TRY an unrestricted-upload hit: POST a .php/.phtml and confirm it lands web-reachable + executes. variant_scan also emits hardcoded_secret (CWE-798) in three tiers: a secret field (api_key/db_password/access_token/aws_*) assigned a literal (HIGH), a known secret FORMAT (JWT eyJ…/AWS AKIA…/GitHub ghp_…/Slack xoxb-…/…) regardless of name (HIGH), or a high-entropy suspect token (MEDIUM — verify before reporting). Verify a frontend/JS secret live via drive_devtools (inspect the JS bundle / network response and confirm the key is actually exposed), and for a backend secret confirm it is reachable/valid. A static hit is a HYPOTHESIS until verified live — never report unverified. For a repo, also scan_git_history(root) — secrets DELETED from HEAD still live in .git history (the removed-later-is-not-fixed trap), and it feeds every recovered pre-deletion blob through the same secret detector. Once you recover a credential, prove it is still ACTIVE with validate_leaked_key(apiBase, endpoints, key|blobUrl) — a READ-ONLY differential test (401-without-key vs 200-with-key = auth bypass PROVEN). Two supply-chain detectors: dependency_confusion (a manifest/build file resolving a package from a public registry — pypi.org/npmjs.org --extra-index-url, or a scoped @company/pkg with no private registry) and ml_supply_chain (torch.load without weights_only=True / joblib.load / np.load(allow_pickle=True) / keras load_model on an untrusted model → pickle RCE). Rust is supported end-to-end: the taint engine (blitz_scan / taint_file) maps Rust sinks (std::process::Command, sqlx/diesel, reqwest/hyper, std::fs, serde/bincode) to the classic classes, plus two Rust-specific detectors — rust_unsafe (transmute / assume_init / from_raw_parts / ptr::* — memory-unsafety surface, CWE-119) and rust_format_string (println!/format! with a variable as the format string — CWE-134). The sqlx query! compile-time macro is treated as safe (suppressed). Two more web-class detectors: jwt_alg_confusion (a JWT verifier that dispatches on the token's alg header and accepts BOTH RS256 and HS256, with the HS256 HMAC secret derived from public/shared key material — CWE-347; the attacker sets alg=HS256 and signs with the public key to forge admin tokens) and cache_deception (a reverse proxy caching static-extension URLs with a cache key that omits the session cookie, over a session-authenticated backend — CWE-525; the victim's cached private response is re-fetched anonymously). TO TRY a jwt_alg_confusion hit: fetch the public key (/.well-known/jwks.json), forge an HS256 token signed with that public key, and confirm admin access. TO TRY a cache_deception hit: request an authenticated path with a static extension appended (.css/.js) and re-fetch it anonymously.\n" + `PRECISION ANALYSIS — chrome-devtools MCP is MANDATORY, not optional:
+` + "TWO PATHS:\\n" + "- Source path on disk -> blitz_scan / taint_file / eagle_eye2 (static).\\n" + "- Live URL -> live_recon / active_scan / strike_verify (web-hunting).\\n\\n" + "DEEPEN A FINDING: attack_plan(target, tech, params) to get the prioritized vector plan (decide what to test next with data); list_chains (escalation), chain_links (compose), technique_lookup(cls), payload_lookup, bypass_lookup (blocked). Ground any detector hit empirically with pattern_lookup(id) — it returns the class's CWE, real-world signature, escalation chains, citable references, per-class bypass techniques, and the high-value assets (crown jewels) that class hits, so a raw hit becomes a class-aware finding. Resolve free-form terminology first with synonym_lookup(term) (IDOR/BOLA/SQLi/prompt-injection → canonical id). For an llm_injection hit, its pattern carries a validation discipline — the RUN-TWICE RULE (reproduce token-for-token across two fresh sessions), NON-GUESSABLE ANCHOR (must leak a real key/URL, not a plausible guess), and OOB PROOF (a verifiable callback log) — apply all three before reporting. BEFORE generating a report, run submission_gate(...) and only ship a finding that passes all 7 questions (reproducible, in-scope, real-impact, no-privileged-assumption, verified-live, evidence-redacted, severity-derived); one false = kill it. Calibrate severity with severity_calibrate(type, cvss) to get a P1–P5 tier + VRT-style category. Start each engagement with engagement_scaffold(target, scope) for the folder + scope.md structure, and check data_refresh() to confirm the data layers are consistent. Phase doctrine: read_skill(bs-orchestrate-engagement | bs-web-hunting | bs-source-audit | bs-verify-finding). Campaign plan: read_playbook(target-type). On any failure call retry_guidance(signal) / model_fallback(signal) before giving up.\n" + "KNOWLEDGE BASE (discover, don't guess): skillLookup(topic) / listSkills for the 40 attack-path + hunting skills (ap-*, hp-*, bs-*); list_attack_vectors / attack_vectors(cat) for the 34-category vector taxonomy; taxonomy(kind) for OWASP/CWE/ASVS/API-top-10; read_playbook(type) for the 17 campaign playbooks; list_manuals / read_tool_manual for 317 tool references; list_tools / run_catalog_tool for the 141-tool catalog. Every tool, skill, and data layer is reachable from these. CROSS-TARGET INTELLIGENCE: strike_resolve auto-records confirmed/false_positive verdicts into the empirical ledger; query it with intelligence(action=hit_rates/top_vectors/recall) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). intelligence(action=recall, tech, target) is the per-engagement pattern recall — it returns which patterns historically CONFIRMED on that tech (prioritize them) versus which only ever produced false positives (avoid them), so a new engagement starts from the empirical playbook of past ones. LIVE PENTEST + TARGETING (black-box, WAF-safe): cache_gap(base_url, endpoint) fuzzes path-normalization + static-extension variants for cache deception/poisoning; blind_oracle(base_url, param, value) detects which SINK a param reaches (sql/ssti/xss) via benign arithmetic (id=1+0, test${7*7}) WITHOUT a malicious payload; param_precedence(base_url, param, A, B) maps duplicate-parameter precedence (first/last-wins) for WAF-bypass. OOB (out-of-band) PROOF for BLIND vulns: oob_start() spins an interactsh listener (unique *.oast.* domain, streams DNS/HTTP interactions — the standard for public targets) or a local HTTP listener for local labs; inject the canary, then oob_poll(id) until the hit arrives; oob_stop(id) to clean up. A blind SSRF/XXE/SQLi/command-injection is CONFIRMED only when the canary actually arrives — never from a guess. SOURCE TARGETING: action_surface(code) maps every wp_ajax_* action to its vuln class + DERIVED priority (what to look for WHERE); security_state(sanitizers, sink) gives a wrong-context sanitization verdict; framework_knowledge(framework) returns auth/nonce primitives for 9 frameworks; variant_scan(root, signature) mass-sweeps an install base for ONE bug family; patch_analyze(old, new) REVERSES a security patch into the 0-day, and its mine_signature feeds variant_scan to sweep unpatched copies. All of these are DETECTION HINTS — verify each live (strike_verify / browser_validate) before it enters the report. NEWEST DETECTORS — understand AND try them: variant_scan also emits priv_esc (privilege escalation — a role/capability/user change fed by request input, traced cross-file via reverse call-graph, e.g. set_role($id, sanitize_key($_POST['um-role'])) or update_user_meta(...,'wp_capabilities', $_POST[...])) and flags uploadAllow=>array('all') unrestricted-upload configs as file_upload (the file-manager/connector shape). TO TRY a priv_esc hit: submit the role field with 'administrator' (or send wp_capabilities meta) and confirm the account actually gains admin. TO TRY an unrestricted-upload hit: POST a .php/.phtml and confirm it lands web-reachable + executes. variant_scan also emits hardcoded_secret (CWE-798) in three tiers: a secret field (api_key/db_password/access_token/aws_*) assigned a literal (HIGH), a known secret FORMAT (JWT eyJ…/AWS AKIA…/GitHub ghp_…/Slack xoxb-…/…) regardless of name (HIGH), or a high-entropy suspect token (MEDIUM — verify before reporting). Verify a frontend/JS secret live via drive_devtools (inspect the JS bundle / network response and confirm the key is actually exposed), and for a backend secret confirm it is reachable/valid. A static hit is a HYPOTHESIS until verified live — never report unverified. For a repo, also scan_git_history(root) — secrets DELETED from HEAD still live in .git history (the removed-later-is-not-fixed trap), and it feeds every recovered pre-deletion blob through the same secret detector. Once you recover a credential, prove it is still ACTIVE with validate_leaked_key(apiBase, endpoints, key|blobUrl) — a READ-ONLY differential test (401-without-key vs 200-with-key = auth bypass PROVEN). Two supply-chain detectors: dependency_confusion (a manifest/build file resolving a package from a public registry — pypi.org/npmjs.org --extra-index-url, or a scoped @company/pkg with no private registry) and ml_supply_chain (torch.load without weights_only=True / joblib.load / np.load(allow_pickle=True) / keras load_model on an untrusted model → pickle RCE). Rust is supported end-to-end: the taint engine (blitz_scan / taint_file) maps Rust sinks (std::process::Command, sqlx/diesel, reqwest/hyper, std::fs, serde/bincode) to the classic classes, plus two Rust-specific detectors — rust_unsafe (transmute / assume_init / from_raw_parts / ptr::* — memory-unsafety surface, CWE-119) and rust_format_string (println!/format! with a variable as the format string — CWE-134). The sqlx query! compile-time macro is treated as safe (suppressed). Two more web-class detectors: jwt_alg_confusion (a JWT verifier that dispatches on the token's alg header and accepts BOTH RS256 and HS256, with the HS256 HMAC secret derived from public/shared key material — CWE-347; the attacker sets alg=HS256 and signs with the public key to forge admin tokens) and cache_deception (a reverse proxy caching static-extension URLs with a cache key that omits the session cookie, over a session-authenticated backend — CWE-525; the victim's cached private response is re-fetched anonymously). TO TRY a jwt_alg_confusion hit: fetch the public key (/.well-known/jwks.json), forge an HS256 token signed with that public key, and confirm admin access. TO TRY a cache_deception hit: request an authenticated path with a static extension appended (.css/.js) and re-fetch it anonymously. WEB3: for Solidity/EVM, call web3_audit(code|path) — a deterministic 10-class smart-contract audit (reentrancy, unchecked return, unchecked arithmetic, tx.origin auth, signature replay, unprotected selfdestruct, delegatecall-to-user-input, missing access control, timestamp dependence, spot-price oracle manipulation, unbounded loop) returning ranked findings (class/CWE/severity/line), then foundry_poc(class, contract) to generate an executable Foundry test that PROVES the bug. A web3 hit is a HYPOTHESIS until the Foundry PoC reproduces it.\n" + `PRECISION ANALYSIS — chrome-devtools MCP is MANDATORY, not optional:
 ` + `- When a lead needs DOM/JS precision — DOM-XSS sink execution, AJAX endpoint + payload interception, JS runtime errors, redirect chains, SSO/token flow, or anything a static HTML glance cannot prove — call drive_devtools(target). It spawns chrome-devtools-mcp and drives a REAL headless browser (navigate -> list_network_requests -> list_console_messages -> evaluate_script), giving reproducible evidence instead of a guess.
 ` + `- Before calling it, check_mcp() to confirm the browser MCP is available; if not, blitzstrike install-tools or npm i -g chrome-devtools-mcp. Never substitute eyeballing minified JS or a static sink guess when a live browser can PROVE it. This is the precision + consistency layer.
 ` + "EXTERNAL MCP SERVERS (verified, connect them — NOT one-shot CLIs): chrome-devtools-mcp (29 tools: list_network_requests/get_network_request for raw HTTP interception, list_console_messages for JS errors + DOM-XSS, evaluate_script to run JS, take_screenshot) -> stdio chrome-devtools-mcp --headless --chromeArg=--no-sandbox --chromeArg=--disable-gpu (as root/container this is MANDATORY or the browser crashes; add --proxyServer http://127.0.0.1:8080 to route through Burp, --acceptInsecureCerts for bad TLS). burp-suite-mcp (proxy history + active scan + repeater) -> NOT npm: build the JAR (git clone https://github.com/PortSwigger/mcp-server.git && cd mcp-server && ./gradlew embedProxyJar), load it in Burp Extensions, then connect the client to http://127.0.0.1:9876 (SSE) or the stdio proxy java -jar mcp-proxy-all.jar --sse-url http://127.0.0.1:9876."
@@ -61353,6 +61822,69 @@ ${statusLine}` : statusLine },
     }
     return { content: [{ type: "text", text: JSON.stringify(await blindOracle(base_url, param, value, { sinks: s })) }] };
   });
+  server.registerTool("oob_start", {
+    title: "Out-of-band callback listener (blind SSRF/XXE/SQLi/RCE proof)",
+    description: "Start a deterministic out-of-band (OOB) listener to PROVE a blind vuln (SSRF/XXE/SQLi/command injection) that does not reflect in the HTTP response. Uses interactsh-client when installed (unique *.oast.* domain, streams DNS/HTTP interactions) — the standard for public targets; falls back to a local HTTP listener for local labs. Returns the callback URL/domain + payload templates. Pair oob_start -> inject the canary -> oob_poll(id) until the hit arrives -> oob_stop(id). A hit is reported ONLY when an interaction actually arrives for the session's unique id — never a guess.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(await oobStart()) }] };
+  });
+  server.registerTool("oob_poll", {
+    title: "Poll an OOB listener for incoming interactions",
+    description: "Check a live OOB session (from oob_start) for incoming DNS/HTTP interactions. Returns found:true + the hits (protocol, remote address, request line, timestamp) when the canary was actually fetched. Poll repeatedly (e.g. every 2-3s) for up to ~60s after injecting the payload; a blind vuln is CONFIRMED only when your marker arrives.",
+    inputSchema: {
+      id: string2().describe("Session id returned by oob_start")
+    }
+  }, async ({ id }) => {
+    return { content: [{ type: "text", text: JSON.stringify(oobPoll(id)) }] };
+  });
+  server.registerTool("oob_stop", {
+    title: "Stop an OOB listener",
+    description: "Stop an OOB session and free its resources (kill the interactsh child / close the listener). Returns the total hits seen.",
+    inputSchema: {
+      id: string2().describe("Session id returned by oob_start")
+    }
+  }, async ({ id }) => {
+    return { content: [{ type: "text", text: JSON.stringify(oobStop(id)) }] };
+  });
+  server.registerTool("oob_list", {
+    title: "List active OOB listeners",
+    description: "List active OOB sessions (id, mode, domain/url, age) for introspection.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(oobList()) }] };
+  });
+  server.registerTool("web3_audit", {
+    title: "Solidity / smart-contract audit (10 bug classes + Foundry PoC)",
+    description: "WEB3: deterministic Solidity audit for the 10 highest-value smart-contract bug classes — reentrancy, unchecked return value, unchecked arithmetic, tx.origin auth, signature replay, unprotected selfdestruct, delegatecall-to-user-input, missing access control, timestamp dependence, spot-price oracle manipulation, and unbounded loops. Pass raw Solidity source (or a path) to get ranked findings (class, CWE, severity, line, evidence). Then call foundry_poc(class, contract) to generate an executable Foundry test template that proves the bug. A hit is a HYPOTHESIS until the Foundry PoC reproduces it.",
+    inputSchema: {
+      code: string2().optional().describe("Raw Solidity source"),
+      path: string2().optional().describe("Path to a .sol file")
+    }
+  }, async ({ code, path }) => {
+    let src = code;
+    if (!src && path) {
+      try {
+        src = readFileSync27(path, "utf8");
+      } catch {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "unreadable path" }) }] };
+      }
+    }
+    if (!src)
+      return { content: [{ type: "text", text: JSON.stringify({ error: "provide code or path" }) }] };
+    const findings = web3Audit(src, path ?? "contract.sol");
+    return { content: [{ type: "text", text: JSON.stringify({ file: path ?? "contract.sol", findings, ranked: web3Rank(findings) }) }] };
+  });
+  server.registerTool("foundry_poc", {
+    title: "Generate a Foundry PoC test for a Web3 finding",
+    description: "Generate an executable Foundry (forge) test template that proves a Web3 finding class (reentrancy / unchecked-return / signature-replay / missing-access-control / oracle-manipulation / …). Pass the class + the vulnerable contract name. Fill in the contract-specific details and run `forge test` to reproduce.",
+    inputSchema: {
+      class_: string2().describe("Web3 finding class (reentrancy, missing_access_control, signature_replay, …)"),
+      contract: string2().optional().describe("Vulnerable contract name (default 'Vulnerable')")
+    }
+  }, async ({ class_, contract }) => {
+    return { content: [{ type: "text", text: foundryPoc(class_, contract ?? "Vulnerable") }] };
+  });
   server.registerTool("param_precedence", {
     title: "Duplicate parameter precedence fuzzer (WAF-bypass oracle)",
     description: "LIVE (black-box): determine how the app resolves duplicate parameters + alternate delimiters (; , %26 %3b | [] %00 + #). Reveals the WAF-bypass vector — if the WAF validates one value and the app binds another, inject via the disagreement. Deterministic: baseline A/B + differential per variant.",
@@ -62275,21 +62807,21 @@ ${out}${gate}` }] };
   return server;
 }
 async function serve() {
-  const server = createServer();
+  const server = createServer2();
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
 
 // src/index.ts
 init_cli();
-import { readFileSync as readFileSync31, existsSync as existsSync16 } from "node:fs";
+import { readFileSync as readFileSync31, existsSync as existsSync17 } from "node:fs";
 import { join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 var ROOT11 = join28(fileURLToPath17(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
     const p = join28(ROOT11, "package.json");
-    if (existsSync16(p))
+    if (existsSync17(p))
       return JSON.parse(readFileSync31(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";

package/package.json

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