blitzstrike 2.4.70 → 2.4.72

package/dist/index.js

@@ -16265,6 +16265,8 @@ function detectComplexBugs(code, file) {
   detectGrpcReflection(code, file, out);
   detectDependencyConfusion(code, file, out);
   detectMlSupplyChain(code, file, out);
+  detectRustUnsafe(code, file, out);
+  detectRustFormatString(code, file, out);
   out.push(...detectWrongSanitizer(code, file));
   out.push(...detectMissingAuthz(code, file));
   const seen = new Set;
@@ -16753,6 +16755,46 @@ function detectMlSupplyChain(code, file, out) {
     }
   }
 }
+function detectRustUnsafe(code, file, out) {
+  if (!/\.rs$/i.test(file))
+    return;
+  const ls = lines2(code);
+  const clean = stripCommentsOnly(code);
+  const re = /std::mem::transmute|\btransmute\s*\(|\bassume_init\s*\(|from_raw_parts(?:_mut)?\s*\(|ptr::(copy|copy_nonoverlapping|read|write|swap)\s*\(|from_utf8_unchecked\s*\(|\bunreachable_unchecked\s*\(/g;
+  let m;
+  while ((m = re.exec(clean)) !== null) {
+    const ln = lineNo2(code, m.index);
+    out.push({
+      file,
+      line: ln,
+      type: "rust_unsafe",
+      category: "Rust unsafe / memory-unsafety surface",
+      severity: "medium",
+      evidence: (ls[ln - 1] ?? "").trim(),
+      detail: `\`${m[0]}\` bypasses the borrow checker's memory-safety guarantees — type confusion (transmute), uninitialized reads (assume_init), or unchecked pointer/slice construction (from_raw_parts / ptr::*) can lead to out-of-bounds access, use-after-free, or UB (CWE-119/787/416). Verify the input is bounds-checked and no attacker-controlled length/index reaches it.`
+    });
+  }
+}
+function detectRustFormatString(code, file, out) {
+  if (!/\.rs$/i.test(file))
+    return;
+  const ls = lines2(code);
+  const clean = stripCommentsOnly(code);
+  const re = /\b(format!|println!|print!|eprintln!|eprint!)\s*\(\s*([a-z_][a-z0-9_]*)\s*\)/g;
+  let m;
+  while ((m = re.exec(clean)) !== null) {
+    const ln = lineNo2(code, m.index);
+    out.push({
+      file,
+      line: ln,
+      type: "rust_format_string",
+      category: "Rust format string injection",
+      severity: "high",
+      evidence: (ls[ln - 1] ?? "").trim(),
+      detail: `\`${m[1]}\` passes a variable (\`${m[2]}\`) as the FORMAT string instead of a literal — if attacker-controlled, format specifiers (positional args, width, precision) can read or corrupt memory (CWE-134). Use \`${m[1]}!("{}", value)\` with the input as an argument, never as the format string.`
+    });
+  }
+}
 var SOURCE_TOKENS3, MAGIC_METHODS, SECRET_FIELD_RE, SECRET_PLACEHOLDER_RE, ENTROPY_EXCLUDE_VAR;
 var init_complex_bugs = __esm(() => {
   init_security_state();
@@ -16948,17 +16990,31 @@ $r = openai.chat.completions.create(['messages' => [['role' => 'user', 'content'
       file: "train.py",
       positive: `import torch\\nmodel = torch.load(downloaded_model)\\n`,
       negative: `import torch\\nmodel = torch.load("model.pt", weights_only=True)\\n`
+    },
+    {
+      id: "rust-unsafe",
+      detector: "rust_unsafe",
+      file: "lib.rs",
+      positive: `fn f() { let x: &[u8] = std::mem::transmute(user_data); }\\n`,
+      negative: `fn f() { let x: &[u8] = user_data.as_bytes(); }\\n`
+    },
+    {
+      id: "rust-format-string",
+      detector: "rust_format_string",
+      file: "main.rs",
+      positive: `fn f() { println!(user_input); }\\n`,
+      negative: `fn f() { println!("{}", user_input); }\\n`
     }
   ];
 });
 
 // src/variants.ts
-import { readFileSync as readFileSync19 } from "node:fs";
-import { join as join19, dirname as dirname4 } from "node:path";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { join as join20, dirname as dirname5 } from "node:path";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 function loadVariants() {
   try {
-    const doc = JSON.parse(readFileSync19(join19(__dirname4, "..", "intelligence", "variants.json"), "utf8"));
+    const doc = JSON.parse(readFileSync20(join20(__dirname5, "..", "intelligence", "variants.json"), "utf8"));
     return doc.variants ?? [];
   } catch {
     return [];
@@ -17009,18 +17065,18 @@ function variantCoverageText() {
   return lines.join(`
 `);
 }
-var __dirname4, CROSS_FILE_ONLY;
+var __dirname5, CROSS_FILE_ONLY;
 var init_variants = __esm(() => {
   init_complex_bugs();
-  __dirname4 = dirname4(fileURLToPath10(import.meta.url));
+  __dirname5 = dirname5(fileURLToPath11(import.meta.url));
   CROSS_FILE_ONLY = new Set(["priv_esc"]);
 });
 
 // src/sync.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync25, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
-import { join as join23 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync26, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
+import { join as join24 } from "node:path";
 import { homedir as homedir10 } from "node:os";
-import { fileURLToPath as fileURLToPath12 } from "node:url";
+import { fileURLToPath as fileURLToPath13 } from "node:url";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function dirExists(p) {
   try {
@@ -17035,7 +17091,7 @@ function countFiles(dir) {
     const walk = (d) => {
       for (const e of readdirSync7(d, { withFileTypes: true })) {
         if (e.isDirectory())
-          walk(join23(d, e.name));
+          walk(join24(d, e.name));
         else
           n++;
       }
@@ -17049,8 +17105,8 @@ function countFiles(dir) {
 function syncData() {
   if (!dirExists(DATA_ROOT2))
     mkdirSync9(DATA_ROOT2, { recursive: true });
-  const payloadsPath = join23(DATA_ROOT2, "payloads");
-  const templatesPath = join23(DATA_ROOT2, "templates");
+  const payloadsPath = join24(DATA_ROOT2, "payloads");
+  const templatesPath = join24(DATA_ROOT2, "templates");
   const hasPayloads = dirExists(payloadsPath) && countFiles(payloadsPath) > 0;
   const hasTemplates = dirExists(templatesPath) && countFiles(templatesPath) > 0;
   if (hasPayloads && hasTemplates) {
@@ -17060,8 +17116,8 @@ function syncData() {
       data_root: DATA_ROOT2
     };
   }
-  const localPayloads = join23(ROOT7, "payloads");
-  const localTemplates = join23(ROOT7, "templates");
+  const localPayloads = join24(ROOT7, "payloads");
+  const localTemplates = join24(ROOT7, "templates");
   let payloadsSynced = false;
   let templatesSynced = false;
   if (!hasPayloads && dirExists(localPayloads)) {
@@ -17074,7 +17130,7 @@ function syncData() {
   }
   const gitOk = spawnSync4("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
-    const tmp = join23(DATA_ROOT2, ".tmp-clone");
+    const tmp = join24(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync4(tmp, { recursive: true, force: true });
     const r = spawnSync4("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
@@ -17082,11 +17138,11 @@ function syncData() {
       const sparse = spawnSync4("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
       if (sparse.status === 0) {
         if (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0) {
-          copyDir(join23(tmp, "payloads"), payloadsPath);
+          copyDir(join24(tmp, "payloads"), payloadsPath);
           payloadsSynced = true;
         }
         if (!dirExists(templatesPath) || countFiles(templatesPath) === 0) {
-          copyDir(join23(tmp, "templates"), templatesPath);
+          copyDir(join24(tmp, "templates"), templatesPath);
           templatesSynced = true;
         }
       }
@@ -17108,18 +17164,18 @@ function copyDir(src, dst) {
 function manualCopy(src, dst) {
   mkdirSync9(dst, { recursive: true });
   for (const e of readdirSync7(src, { withFileTypes: true })) {
-    const s = join23(src, e.name);
-    const d = join23(dst, e.name);
+    const s = join24(src, e.name);
+    const d = join24(dst, e.name);
     if (e.isDirectory())
       manualCopy(s, d);
     else
-      writeFileSync8(d, readFileSync25(s));
+      writeFileSync8(d, readFileSync26(s));
   }
 }
 var ROOT7, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
 var init_sync = __esm(() => {
-  ROOT7 = join23(fileURLToPath12(new URL(".", import.meta.url)), "..");
-  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join23(homedir10(), ".blitzstrike", "data");
+  ROOT7 = join24(fileURLToPath13(new URL(".", import.meta.url)), "..");
+  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join24(homedir10(), ".blitzstrike", "data");
 });
 
 // src/update.ts
@@ -17164,15 +17220,15 @@ var init_update = __esm(() => {
 });
 
 // src/release.ts
-import { readFileSync as readFileSync27, existsSync as existsSync13 } from "node:fs";
-import { join as join24 } from "node:path";
-import { fileURLToPath as fileURLToPath13 } from "node:url";
+import { readFileSync as readFileSync28, existsSync as existsSync13 } 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";
 function validateRelease() {
   const checks = [];
   checks.push({ name: "package.json version", ok: true, detail: VERSION });
   try {
-    const changelog = readFileSync27(join24(ROOT8, "CHANGELOG.md"), "utf8");
+    const changelog = readFileSync28(join25(ROOT8, "CHANGELOG.md"), "utf8");
     const m = changelog.match(/^##\s+\[([0-9]+\.[0-9]+\.[0-9]+)\]/m);
     const changelogVersion = m?.[1] ?? null;
     checks.push({
@@ -17204,22 +17260,22 @@ function validateRelease() {
   return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
 }
 function lockfilePresent() {
-  return existsSync13(join24(ROOT8, "package-lock.json")) || existsSync13(join24(ROOT8, "bun.lock")) || existsSync13(join24(ROOT8, "bun.lockb"));
+  return existsSync13(join25(ROOT8, "package-lock.json")) || existsSync13(join25(ROOT8, "bun.lock")) || existsSync13(join25(ROOT8, "bun.lockb"));
 }
 var ROOT8;
 var init_release = __esm(() => {
   init_version();
-  ROOT8 = join24(fileURLToPath13(new URL(".", import.meta.url)), "..");
+  ROOT8 = join25(fileURLToPath14(new URL(".", import.meta.url)), "..");
 });
 
 // src/dependency.ts
-import { readFileSync as readFileSync28 } from "node:fs";
-import { join as join25 } from "node:path";
-import { fileURLToPath as fileURLToPath14 } from "node:url";
+import { readFileSync as readFileSync29 } from "node:fs";
+import { join as join26 } from "node:path";
+import { fileURLToPath as fileURLToPath15 } from "node:url";
 function checkDependencies() {
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync28(join25(ROOT9, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync29(join26(ROOT9, "package.json"), "utf8"));
   } catch {
     return { install_scripts: [], git_dependencies: [], total_dependencies: 0, safe: false };
   }
@@ -17242,14 +17298,14 @@ function checkDependencies() {
 }
 var ROOT9;
 var init_dependency = __esm(() => {
-  ROOT9 = join25(fileURLToPath14(new URL(".", import.meta.url)), "..");
+  ROOT9 = join26(fileURLToPath15(new URL(".", import.meta.url)), "..");
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync29, existsSync as existsSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join26, dirname as dirname5 } from "node:path";
+import { readFileSync as readFileSync30, existsSync as existsSync14, 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 fileURLToPath15 } from "node:url";
+import { fileURLToPath as fileURLToPath16 } from "node:url";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function which(cmd) {
   return spawnSync5("sh", ["-c", 'command -v "$1" >/dev/null 2>&1', "sh", cmd]).status === 0;
@@ -17292,7 +17348,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 = existsSync14(join26(ROOT10, "chains.json")) && existsSync14(join26(ROOT10, "tools-catalog.json"));
+  const dataOk = existsSync14(join27(ROOT10, "chains.json")) && existsSync14(join27(ROOT10, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -17343,28 +17399,28 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join26(ROOT10, "src", "index.ts");
+  const src = join27(ROOT10, "src", "index.ts");
   if (which("bun") && existsSync14(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 = join26(ROOT10, "dist", "index.js");
+  const dist = join27(ROOT10, "dist", "index.js");
   if (existsSync14(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync29(p, "utf8"));
+    return JSON.parse(readFileSync30(p, "utf8"));
   } catch {
     return null;
   }
 }
 function jsonMcpServersWrite(p) {
   return (command, args) => {
-    const dir = dirname5(p);
+    const dir = dirname6(p);
     if (!existsSync14(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
@@ -17377,7 +17433,7 @@ function jsonMcpServersWrite(p) {
 }
 function opencodeWrite(p) {
   return (command, args) => {
-    const dir = dirname5(p);
+    const dir = dirname6(p);
     if (!existsSync14(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
@@ -17390,26 +17446,26 @@ function opencodeWrite(p) {
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join26(ROOT10, "opencode-agents");
-  const dstDir = join26(homedir11(), ".config", "opencode", "agents");
+  const srcDir = join27(ROOT10, "opencode-agents");
+  const dstDir = join27(homedir11(), ".config", "opencode", "agents");
   if (!existsSync14(srcDir))
     return;
   if (!existsSync14(dstDir))
     mkdirSync10(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join26(srcDir, f);
-    const dst = join26(dstDir, f);
+    const src = join27(srcDir, f);
+    const dst = join27(dstDir, f);
     if (existsSync14(src)) {
-      writeFileSync9(dst, readFileSync29(src, "utf8"));
+      writeFileSync9(dst, readFileSync30(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
-    const dir = dirname5(p);
+    const dir = dirname6(p);
     if (!existsSync14(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync14(p) ? readFileSync29(p, "utf8") : "";
+    let existing = existsSync14(p) ? readFileSync30(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -17425,10 +17481,10 @@ args = ${JSON.stringify(args)}
 }
 function hermesWrite(p) {
   return (command, args) => {
-    const dir = dirname5(p);
+    const dir = dirname6(p);
     if (!existsSync14(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync14(p) ? readFileSync29(p, "utf8") : "";
+    let existing = existsSync14(p) ? readFileSync30(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -17455,74 +17511,74 @@ mcp_servers:
 function detectAgents() {
   const home = homedir11();
   const agents = [];
-  const claudeJson = join26(home, ".claude.json");
+  const claudeJson = join27(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
     installed: () => existsSync14(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join26(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join27(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
     installed: () => existsSync14(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join26(home, ".cursor", "mcp.json");
+  const cursor = join27(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync14(join26(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync14(join27(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join26(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join27(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync14(join26(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync14(join27(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join26(home, ".codex", "config.toml");
+  const codex = join27(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync14(join26(home, ".codex")) || which("codex"),
+    installed: () => existsSync14(join27(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join26(home, ".hermes", "config.yaml");
+  const hermes = join27(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync14(join26(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync14(join27(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join26(home, ".gemini", "settings.json");
+  const gemini = join27(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync14(join26(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync14(join27(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join26(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join27(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync14(join26(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync14(join27(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join26(home, ".copilot", "mcp.json");
+  const copilot = join27(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync14(join26(home, ".copilot")),
+    installed: () => existsSync14(join27(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join26(home, ".cline", "mcp_settings.json");
+  const cline = join27(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync14(join26(home, ".cline")),
+    installed: () => existsSync14(join27(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -17640,7 +17696,7 @@ var init_cli = __esm(() => {
   init_release();
   init_dependency();
   init_mcp_status();
-  ROOT10 = join26(fileURLToPath15(new URL(".", import.meta.url)), "..");
+  ROOT10 = join27(fileURLToPath16(new URL(".", import.meta.url)), "..");
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -32278,7 +32334,7 @@ class StdioServerTransport {
 
 // src/server.ts
 init_scanner();
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 
 // src/recon.ts
 var TIMEOUT_MS = 25000;
@@ -56680,10 +56736,97 @@ var javaAdapter = {
     return { sources, sinks, sanitizers, calls, assigns };
   }
 };
+var RUST_SOURCES = [
+  [/env::args\s*\(|args_os\s*\(/, "cli_argument"],
+  [/stdin\s*\(\s*\)|read_line\s*\(/, "raw_body"],
+  [/\b(?:Query|Form|Json|Path)\b|web::(?:Query|Json|Form|Path)|req\.(?:query|params|param|form|query_string)/, "http_parameter"],
+  [/env::var\s*\(|env::var_os\s*\(/, "env_variable"]
+];
+var RUST_SINKS = [
+  [/Command::new|process::Command/, "command_execution", "CWE-78"],
+  [/sqlx::query(?:_as)?\s*\(|sqlx::raw_sql|\.query\s*\(|\.execute\s*\(|rusqlite|diesel::/, "sql_execution", "CWE-89"],
+  [/reqwest::get|reqwest::Client|hyper::|\.get\s*\(|\.post\s*\(|\.put\s*\(|\.request\s*\(/, "http_request", "CWE-918"],
+  [/std::fs::(read_to_string|read|write|remove_file|copy|rename)|File::open\s*\(|fs::(read|write|remove_file|copy)\s*\(/, "path_traversal", "CWE-22"],
+  [/serde_json::from_(str|slice)|bincode::deserialize|serde_yaml::from_str|toml::from_str|\.deserialize\s*\(/, "deserialization", "CWE-502"]
+];
+var RUST_SANITIZERS = [
+  [/canonicalize\s*\(/, ["path_traversal"]],
+  [/query(_as)?!\s*\(/, ["sql_execution"]]
+];
+var rustAdapter = {
+  language: "rust",
+  extensions: [".rs"],
+  parse(code, _file) {
+    const sources = [];
+    const sinks = [];
+    const sanitizers = [];
+    const calls = [];
+    const assigns = [];
+    const assignRe = /let\s+(?:mut\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+?);/g;
+    let m;
+    while ((m = assignRe.exec(code)) !== null) {
+      const varName = m[1];
+      const rhs = m[2];
+      const line = code.slice(0, m.index).split(`
+`).length;
+      const src = RUST_SOURCES.find(([re]) => re.test(rhs));
+      if (src)
+        sources.push({ variable: varName, kind: src[1], line, attacker_controlled: src[1] !== "cli_argument" && src[1] !== "env_variable" });
+      const rhsVars = [];
+      const vre = /([a-z_][a-z0-9_]*)/g;
+      let vm;
+      while ((vm = vre.exec(rhs)) !== null) {
+        const v = vm[1];
+        if (!RUST_SOURCES.some(([re]) => re.test(v)))
+          rhsVars.push(v);
+      }
+      assigns.push({ target: varName, sources: rhsVars.slice(0, 8), line });
+    }
+    const extractorRe = /\b(?:Query|Form|Json|Path)\s*\(\s*([a-z_][a-z0-9_]*)\s*\)/g;
+    while ((m = extractorRe.exec(code)) !== null) {
+      const line = code.slice(0, m.index).split(`
+`).length;
+      sources.push({ variable: m[1], kind: "http_parameter", line, attacker_controlled: true });
+      assigns.push({ target: m[1], sources: [], line });
+    }
+    const lines = code.split(`
+`);
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      for (const [re, kind, cwe] of RUST_SINKS) {
+        if (!re.test(line))
+          continue;
+        if (kind === "sql_execution" && /query(_as)?!\s*\(/.test(line))
+          continue;
+        const argVars = [];
+        const vre = /([a-z_][a-z0-9_]*)/g;
+        let vm;
+        while ((vm = vre.exec(line)) !== null) {
+          const id = vm[1];
+          if (/^(new|let|mut|arg|args|command|process|std|sqlx|query|query_as|execute|reqwest|client|get|post|put|request|fs|file|open|read_to_string|read|write|remove_file|copy|rename|serde_json|from_str|from_slice|bincode|deserialize|toml|yaml|format|unwrap|expect|env|args|stdin|read_line)$/.test(id))
+            continue;
+          argVars.push(id);
+        }
+        for (const v of argVars.slice(0, 8))
+          sinks.push({ variable: v, kind, line: i + 1, cwe });
+      }
+      for (const [re, kinds] of RUST_SANITIZERS) {
+        if (re.test(line)) {
+          const vre = /([a-z_][a-z0-9_]*)/g;
+          let vm;
+          while ((vm = vre.exec(line)) !== null)
+            sanitizers.push({ variable: vm[1], neutralizes: kinds, line: i + 1 });
+        }
+      }
+    }
+    return { sources, sinks, sanitizers, calls, assigns };
+  }
+};
 registerLanguage(phpAdapter);
 registerLanguage(jsAdapter);
 registerLanguage(pythonAdapter);
 registerLanguage(javaAdapter);
+registerLanguage(rustAdapter);
 
 // src/incremental.ts
 var SOURCE_EXTS = [".php", ".phtml", ".js", ".mjs", ".ts", ".tsx", ".py", ".pyw", ".java"];
@@ -58011,7 +58154,14 @@ var ALIASES = {
   "ai supply chain": "ml_supply_chain",
   "model poisoning": "ml_supply_chain",
   "ml security": "ml_supply_chain",
-  "ai ml security": "ml_supply_chain"
+  "ai ml security": "ml_supply_chain",
+  "rust unsafe": "rust_unsafe",
+  "unsafe rust": "rust_unsafe",
+  "rust memory safety": "rust_unsafe",
+  transmute: "rust_unsafe",
+  "rust format string": "rust_format_string",
+  "format string": "rust_format_string",
+  "format string injection": "rust_format_string"
 };
 function normalize(term) {
   return term.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
@@ -58279,6 +58429,103 @@ async function validateLeakedKey(input) {
   };
 }
 
+// src/hackbot-arena.ts
+import { readFileSync as readFileSync18 } from "node:fs";
+import { join as join18, dirname as dirname3 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+var __dirname3 = dirname3(fileURLToPath9(import.meta.url));
+function load4() {
+  try {
+    return JSON.parse(readFileSync18(join18(__dirname3, "..", "intelligence", "hackbot-arena.json"), "utf8"));
+  } catch {
+    return { total: 0, flag_format: "FLAG{nusasec-<32 hex>}", labs: [] };
+  }
+}
+var VECTOR_MAP = [
+  { re: /jwt|algorithm confusion|rs256|hs256/i, vectors: ["jwt"], detectors: ["missing_authz"], chains: ["jwt"], tools: ["jwt_analyze", "live_recon"] },
+  { re: /ssrf|server-side request/i, vectors: ["ssrf"], detectors: ["ssrf"], chains: ["ssrf"], tools: ["live_recon", "blind_oracle", "active_scan"] },
+  { re: /sql injection|sqli|postgresql|sql/i, vectors: ["sql_injection"], detectors: ["sql_injection"], chains: ["sql_injection"], tools: ["live_recon", "blind_oracle", "active_scan"] },
+  { re: /ssti|template injection|liquid|jinja|twig/i, vectors: ["ssti"], detectors: ["ssti"], chains: ["ssti"], tools: ["live_recon", "blind_oracle"] },
+  { re: /command injection|os command|command execution/i, vectors: ["command_injection"], detectors: ["command_injection"], chains: ["command_injection"], tools: ["live_recon", "blind_oracle"] },
+  { re: /idor|bola|authorization|broken function|role|membership|ownership|entitlement|directory search|excessive data|data exposure|harvest/i, vectors: ["broken_object_level_authorization"], detectors: ["missing_authz"], chains: ["idor"], tools: ["live_recon", "active_scan", "param_precedence"] },
+  { re: /graphql/i, vectors: ["graphql_exposure"], detectors: ["graphql_exposure", "sql_injection"], chains: ["graphql"], tools: ["live_recon", "active_scan"] },
+  { re: /cache/i, vectors: ["web_cache_deception"], detectors: [], chains: ["cache_deception"], tools: ["cache_gap", "live_recon"] },
+  { re: /credential|key|token|bearer|secret|leak|websocket|rum|api key/i, vectors: ["hardcoded_secret"], detectors: ["hardcoded_secret"], chains: ["secret_leak"], tools: ["live_recon", "drive_devtools", "scan_git_history"] },
+  { re: /rate.limit|batching|otp/i, vectors: ["business_logic"], detectors: [], chains: ["rate_limit_bypass"], tools: ["race_test", "active_scan"] },
+  { re: /mass assignment|self.regist|admin account|user creation|scope/i, vectors: ["mass_assignment"], detectors: ["mass_assignment", "missing_authz"], chains: ["mass_assignment"], tools: ["live_recon", "active_scan"] },
+  { re: /deserialization|rce|workflow|execution/i, vectors: ["code_execution"], detectors: ["deserialization"], chains: ["deserialization"], tools: ["live_recon", "active_scan"] }
+];
+function mapLab(lab) {
+  const out = { vectors: [], detectors: [], chains: [], tools: [] };
+  for (const m of VECTOR_MAP) {
+    if (m.re.test(lab.vuln_class)) {
+      out.vectors.push(...m.vectors);
+      out.detectors.push(...m.detectors);
+      out.chains.push(...m.chains);
+      out.tools.push(...m.tools);
+    }
+  }
+  out.vectors = [...new Set(out.vectors)];
+  out.detectors = [...new Set(out.detectors)];
+  out.chains = [...new Set(out.chains)];
+  out.tools = [...new Set(out.tools)];
+  return out;
+}
+function findByLab(labId) {
+  const id = labId.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return load4().labs.find((l) => l.id.toLowerCase() === id || l.id.toLowerCase() === `labs${id}`) ?? null;
+}
+function hackbotArenaList() {
+  const doc = load4();
+  return {
+    arena: "Hackbot-Arena (NusaSec)",
+    total: doc.total,
+    flag_format: doc.flag_format,
+    note: "Port = 8080 + lab number (labs01 -> 8081 … labs30 -> 8110). Each lab has a solver/ reference exploit + judge.success_when solve criteria.",
+    labs: doc.labs.map((l) => ({ id: l.id, name: l.name, difficulty: l.difficulty, port: l.port, vuln_class: l.vuln_class, stack: l.stack }))
+  };
+}
+function hackbotArenaBrief(labId) {
+  const lab = findByLab(labId);
+  if (!lab)
+    return { error: `unknown lab '${labId}'`, hint: "use hackbot_arena_list() to see all 30 labs" };
+  const plan = mapLab(lab);
+  return {
+    id: lab.id,
+    name: lab.name,
+    difficulty: lab.difficulty,
+    target: `http://localhost:${lab.port}`,
+    vuln_class: lab.vuln_class,
+    stack: lab.stack,
+    flag_format: load4().flag_format,
+    attack_plan: {
+      vectors: plan.vectors,
+      detectors: plan.detectors,
+      chains: plan.chains,
+      tools: plan.tools
+    },
+    hint: `Start with live_recon(target) to fingerprint, then drive the ${plan.chains.join(" + ") || "detected"} chain. Verify every step live (strike_verify / browser_validate) and recover the flag. Flag format: ${load4().flag_format}.`
+  };
+}
+function hackbotArenaCoverage() {
+  const doc = load4();
+  const rows = doc.labs.map((l) => {
+    const plan = mapLab(l);
+    return { id: l.id, name: l.name, vuln_class: l.vuln_class, vectors: plan.vectors, detectors: plan.detectors, chains: plan.chains };
+  });
+  const withVector = rows.filter((r) => r.vectors.length > 0).length;
+  const withDetector = rows.filter((r) => r.detectors.length > 0).length;
+  return {
+    arena: "Hackbot-Arena (NusaSec)",
+    total_labs: doc.total,
+    labs_with_mapped_vector: withVector,
+    labs_with_detector_coverage: withDetector,
+    coverage_ratio: Number((withVector / doc.total).toFixed(2)),
+    note: "A mapped vector/detector means Blitz Strike has the deterministic tooling to drive that vuln class; the agent still has to execute the chain + recover the flag.",
+    rows
+  };
+}
+
 // src/severity.ts
 var VRT_MAP = {
   sql_injection: { vrt: "injection > sql_injection", priority: "P1", severity: "critical", rationale: "SQL injection reaches sensitive data or enables admin takeover." },
@@ -58302,7 +58549,9 @@ var VRT_MAP = {
   oauth_misconfig: { vrt: "authentication > oauth_misconfiguration", priority: "P2", severity: "high", rationale: "An OAuth/open-redirect misconfiguration can leak authorization codes → account takeover." },
   grpc_reflection: { vrt: "misconfiguration > debug_information_exposure", priority: "P5", severity: "low", rationale: "gRPC reflection exposes the API contract but is not directly exploitable." },
   dependency_confusion: { vrt: "insecure_design > dependency_confusion", priority: "P2", severity: "high", rationale: "An internal package resolves from a squattable public registry → attacker-controlled code in the build." },
-  ml_supply_chain: { vrt: "injection > insecure_deserialization", priority: "P1", severity: "critical", rationale: "Untrusted model loading via pickle (torch/joblib/numpy) → arbitrary code execution on load." }
+  ml_supply_chain: { vrt: "injection > insecure_deserialization", priority: "P1", severity: "critical", rationale: "Untrusted model loading via pickle (torch/joblib/numpy) → arbitrary code execution on load." },
+  rust_unsafe: { vrt: "insecure_design > unsafe_memory_operations", priority: "P3", severity: "medium", rationale: "transmute/from_raw_parts/assume_init bypass the borrow checker — a hint that needs bounds verification; memory corruption if attacker-controlled." },
+  rust_format_string: { vrt: "injection > format_string_injection", priority: "P2", severity: "high", rationale: "An attacker-controlled format string can read or corrupt memory via format specifiers." }
 };
 function severityCalibrate(input) {
   const type = input.type?.toLowerCase() ?? "";
@@ -58341,13 +58590,13 @@ function listSeverityMap() {
 }
 
 // src/datarefresh.ts
-import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join18, dirname as dirname3 } from "node:path";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
-var __dirname3 = dirname3(fileURLToPath9(import.meta.url));
+import { readFileSync as readFileSync19 } from "node:fs";
+import { join as join19, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
+var __dirname4 = dirname4(fileURLToPath10(import.meta.url));
 function loadJson2(rel) {
   try {
-    return JSON.parse(readFileSync18(join18(__dirname3, "..", rel), "utf8"));
+    return JSON.parse(readFileSync19(join19(__dirname4, "..", rel), "utf8"));
   } catch {
     return null;
   }
@@ -58382,18 +58631,18 @@ init_verify_harness();
 init_variants();
 
 // src/benchmark.ts
-import { readFileSync as readFileSync20, readdirSync as readdirSync5, writeFileSync as writeFileSync6, rmSync as rmSync3, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join20 } from "node:path";
-import { fileURLToPath as fileURLToPath11 } from "node:url";
+import { readFileSync as readFileSync21, readdirSync as readdirSync5, writeFileSync as writeFileSync6, rmSync as rmSync3, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join21 } from "node:path";
+import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { tmpdir as tmpdir3, homedir as homedir8 } from "node:os";
 init_complex_bugs();
-var ROOT5 = join20(fileURLToPath11(new URL(".", import.meta.url)), "..");
-var CORPUS = join20(ROOT5, "bench", "corpus");
-var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join20(homedir8(), ".blitzstrike", "corpus");
+var ROOT5 = join21(fileURLToPath12(new URL(".", import.meta.url)), "..");
+var CORPUS = join21(ROOT5, "bench", "corpus");
+var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join21(homedir8(), ".blitzstrike", "corpus");
 function parseCorpusFile(path) {
   let text;
   try {
-    text = readFileSync20(path, "utf8");
+    text = readFileSync21(path, "utf8");
   } catch {
     return null;
   }
@@ -58449,7 +58698,7 @@ function loadDir(dir) {
     for (const f of readdirSync5(dir)) {
       if (!f.endsWith(".md"))
         continue;
-      const e = parseCorpusFile(join20(dir, f));
+      const e = parseCorpusFile(join21(dir, f));
       if (e)
         entries.push(e);
     }
@@ -58476,7 +58725,7 @@ function captureFalsePositive(input) {
     input.code,
     "```"
   ].filter((l) => l !== null);
-  const path = join20(CAPTURED_CORPUS_DIR, `${id}.md`);
+  const path = join21(CAPTURED_CORPUS_DIR, `${id}.md`);
   writeFileSync6(path, lines.join(`
 `) + `
 `, "utf8");
@@ -58498,7 +58747,7 @@ function detect(entry) {
   }
   const lang = entry.language;
   if (lang === "php") {
-    const tmp = join20(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
+    const tmp = join21(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
     writeFileSync6(tmp, entry.code);
     const r = analyzeDataFlow2(tmp);
     rmSync3(tmp, { force: true });
@@ -58567,12 +58816,12 @@ function runBenchmark() {
 }
 
 // src/obligations.ts
-import { readFileSync as readFileSync21, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join21 } from "node:path";
+import { readFileSync as readFileSync22, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join22 } from "node:path";
 import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir9 } from "node:os";
-var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join21(homedir9(), ".blitzstrike");
-var OBLIGATION_PATH = join21(HOME_DIR4, "obligations.jsonl");
+var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join22(homedir9(), ".blitzstrike");
+var OBLIGATION_PATH = join22(HOME_DIR4, "obligations.jsonl");
 function ensureDir3() {
   if (!existsSync11(HOME_DIR4))
     mkdirSync8(HOME_DIR4, { recursive: true });
@@ -58585,7 +58834,7 @@ function loadObligations() {
     return [];
   try {
     const out = [];
-    for (const line of readFileSync21(OBLIGATION_PATH, "utf8").split(`
+    for (const line of readFileSync22(OBLIGATION_PATH, "utf8").split(`
 `)) {
       const t = line.trim();
       if (!t)
@@ -58689,11 +58938,11 @@ init_framework_security();
 // src/variant-scan.ts
 init_scanner();
 init_complex_bugs();
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 
 // src/cross-file.ts
 init_scanner();
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 var PUBLIC_HOOK_RE = /(?:wp_ajax_nopriv_\w+|admin_post_nopriv_\w+|init|template_redirect|wp_loaded|parse_request|user_register|um_user_register|register_new_user|authenticate)/;
 var PRIV_SINK_RE = /\b(set_role|add_role|remove_role|set_user_role|wp_set_current_user|wp_set_auth_cookie|wp_insert_user|wp_create_user|wp_update_user)\s*\(/;
 var ROLE_META_RE = /update_user_meta\s*\(\s*[^,]+,\s*['"](wp_capabilities|role|roles|capabilities|wp_user_level)['"]/;
@@ -58745,7 +58994,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync22(file, "utf8"));
+      code = stripComments(readFileSync23(file, "utf8"));
     } catch {
       continue;
     }
@@ -58786,7 +59035,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync22(file, "utf8"));
+      code = stripComments(readFileSync23(file, "utf8"));
     } catch {
       continue;
     }
@@ -58809,7 +59058,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync22(file, "utf8"));
+      code = stripComments(readFileSync23(file, "utf8"));
     } catch {
       continue;
     }
@@ -58924,7 +59173,7 @@ function variantScan(root, opts = {}) {
   for (const file of files) {
     let code;
     try {
-      code = readFileSync23(file, "utf8");
+      code = readFileSync24(file, "utf8");
     } catch {
       continue;
     }
@@ -59584,17 +59833,17 @@ function analyzeJwt(token, opts = {}) {
 }
 
 // src/enterprise-benchmark.ts
-import { existsSync as existsSync12, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import { join as join22, resolve } from "node:path";
+import { existsSync as existsSync12, 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");
 var ENTERPRISE_FIXTURES = [
-  { id: "php-laravel", dir: join22(ROOT6, "php-laravel"), expected_vulns: 4 },
-  { id: "js-express", dir: join22(ROOT6, "js-express"), expected_vulns: 2 },
-  { id: "py-django", dir: join22(ROOT6, "py-django"), expected_vulns: 2 },
-  { id: "java-spring", dir: join22(ROOT6, "java-spring"), expected_vulns: 2 },
-  { id: "wp-batch-route", dir: join22(ROOT6, "wp-batch-route"), expected_vulns: 3 },
-  { id: "php-complex", dir: join22(ROOT6, "php-complex"), expected_vulns: 4 }
+  { id: "php-laravel", dir: join23(ROOT6, "php-laravel"), expected_vulns: 4 },
+  { id: "js-express", dir: join23(ROOT6, "js-express"), expected_vulns: 2 },
+  { id: "py-django", dir: join23(ROOT6, "py-django"), expected_vulns: 2 },
+  { id: "java-spring", dir: join23(ROOT6, "java-spring"), expected_vulns: 2 },
+  { id: "wp-batch-route", dir: join23(ROOT6, "wp-batch-route"), expected_vulns: 3 },
+  { id: "php-complex", dir: join23(ROOT6, "php-complex"), expected_vulns: 4 }
 ];
 function sourceFiles(root) {
   const out = [];
@@ -59606,7 +59855,7 @@ function sourceFiles(root) {
       return;
     }
     for (const e of entries) {
-      const p = join22(dir, e);
+      const p = join23(dir, e);
       let st;
       try {
         st = statSync3(p);
@@ -59627,7 +59876,7 @@ function detectFixture(dir) {
   for (const f of sourceFiles(dir)) {
     let code;
     try {
-      code = readFileSync24(f, "utf8");
+      code = readFileSync25(f, "utf8");
     } catch {
       continue;
     }
@@ -59758,11 +60007,29 @@ var JAVA_SINKS2 = {
   xpath_injection: true,
   ldap_injection: true
 };
+var RUST_SINKS2 = {
+  sql_execution: true,
+  code_execution: false,
+  command_execution: true,
+  file_operations: true,
+  file_inclusion: false,
+  deserialization: true,
+  http_request: true,
+  redirect: true,
+  html_render: false,
+  xml_processing: false,
+  archive_extraction: false,
+  path_traversal: true,
+  template_injection: false,
+  xpath_injection: false,
+  ldap_injection: false
+};
 var SINK_BY_LANG = {
   php: PHP_SINKS2,
   javascript: JS_SINKS2,
   python: PY_SINKS2,
-  java: JAVA_SINKS2
+  java: JAVA_SINKS2,
+  rust: RUST_SINKS2
 };
 function coverageMatrix() {
   const langs = listLanguages();
@@ -59822,7 +60089,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).\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. 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).\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."
@@ -60292,6 +60559,29 @@ ${statusLine}` : statusLine },
   }, async (input) => {
     return { content: [{ type: "text", text: JSON.stringify(await validateLeakedKey(input)) }] };
   });
+  server.registerTool("hackbot_arena_list", {
+    title: "List Hackbot Arena benchmark labs",
+    description: "BENCHMARK: list the 30 Hackbot Arena (NusaSec) dockerized web-security labs — a local benchmark of realistic vulnerability chains with deterministic flags. Returns id/name/difficulty/port/vuln_class per lab (evaluator view; no flags or solutions).",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(hackbotArenaList()) }] };
+  });
+  server.registerTool("hackbot_arena_brief", {
+    title: "Attack-plan brief for one Hackbot Arena lab",
+    description: "BENCHMARK: given a lab id (e.g. labs03), return the target URL, vuln class, stack, flag format, and the DERIVED Blitz Strike attack plan (vectors/detectors/chains/tools) to solve it. This is the agent brief — it never contains the flag, judge criteria, or reference solution.",
+    inputSchema: {
+      labId: string2().describe("Lab id (e.g. labs03, labs20)")
+    }
+  }, async ({ labId }) => {
+    return { content: [{ type: "text", text: JSON.stringify(hackbotArenaBrief(labId)) }] };
+  });
+  server.registerTool("hackbot_arena_coverage", {
+    title: "Blitz Strike coverage vs Hackbot Arena",
+    description: "BENCHMARK: map all 30 Hackbot Arena labs against Blitz Strike's detector/vector coverage — which vuln classes Blitz Strike has deterministic tooling for, per lab, plus the derived chains.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(hackbotArenaCoverage()) }] };
+  });
   server.registerTool("fofa_search", {
     title: "FOFA asset search",
     description: "STRIKE: search the FOFA asset index (needs FOFA_EMAIL + FOFA_KEY).",
@@ -60677,7 +60967,7 @@ ${statusLine}` : statusLine },
     let src = code;
     if (!src && path) {
       try {
-        src = readFileSync26(path, "utf8");
+        src = readFileSync27(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: "unreadable path" }) }] };
       }
@@ -61295,7 +61585,7 @@ ${statusLine}` : statusLine },
     description: "Route confusion (separate class from source→sink taint): detect attacker-controlled dispatch (call_user_func/forward/dispatch), dynamic method calls ($obj->$m()), dynamic include (LFI), batch/proxy forwarding without per-route auth re-check, and route matching without path normalization.",
     inputSchema: { path: string2().describe("Source file path (PHP)") }
   }, async ({ path }) => {
-    const code = readFileSync26(path, "utf8");
+    const code = readFileSync27(path, "utf8");
     const findings = detectRouteConfusion(code, path);
     return {
       content: [{
@@ -61309,7 +61599,7 @@ ${statusLine}` : statusLine },
     description: "Complex-bug detection beyond taint: deserialization→POP gadget chain (unserialize + magic method), type juggling (loose ==/!= vs hash/secret), mass assignment (extract/parse_str without a safe flag), prototype pollution (unsafe merge of request data), CRLF/header injection (user input into a header), path confusion (user input into a file path without canonicalization), SSRF (user-controlled URL with no host allowlist), XXE (user XML parsed without disabling entities), SSTI (user input into a template render with no sandbox), wrong-context sanitization (sanitize_text_field() into a SQL query), and missing authorization/nonce on WordPress entry points (wp_ajax_* / admin_post_* / register_rest_route without current_user_can, nonce verification, or permission_callback).",
     inputSchema: { path: string2().describe("Source file path") }
   }, async ({ path }) => {
-    const code = readFileSync26(path, "utf8");
+    const code = readFileSync27(path, "utf8");
     const findings = detectComplexBugs(code, path);
     return {
       content: [{
@@ -61395,7 +61685,7 @@ ${statusLine}` : statusLine },
     let lang = language;
     if (path && !code) {
       try {
-        src = readFileSync26(path, "utf8");
+        src = readFileSync27(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: `cannot read ${path}` }) }] };
       }
@@ -61644,15 +61934,15 @@ async function serve() {
 
 // src/index.ts
 init_cli();
-import { readFileSync as readFileSync30, existsSync as existsSync15 } from "node:fs";
-import { join as join27 } from "node:path";
-import { fileURLToPath as fileURLToPath16 } from "node:url";
-var ROOT11 = join27(fileURLToPath16(new URL(".", import.meta.url)), "..");
+import { readFileSync as readFileSync31, existsSync as existsSync15 } 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 = join27(ROOT11, "package.json");
+    const p = join28(ROOT11, "package.json");
     if (existsSync15(p))
-      return JSON.parse(readFileSync30(p, "utf8")).version ?? "1.0.0";
+      return JSON.parse(readFileSync31(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }