blitzstrike 2.4.151 → 2.4.152

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.152] — 2026-10-11
+
+### Added — autonomous blind SQLi confirmation (blind_sqli_confirm)
+
+- New `blind_sqli_confirm` tool + `confirmBlindSqli()`: turns blind_oracle's
+  "SQL context" hint into "blind SQLi CONFIRMED" — sends the boolean oracle
+  (TRUE vs FALSE byte-count differential) and time oracle (TRUE-branch sleep vs
+  FALSE-branch instant) with payloads taken from the blind_sqli playbook (not
+  hand-written), and returns a deterministic verdict + evidence string.
+  166 tools, 548/548 tests.
+
 ## [2.4.151] — 2026-10-11
 
 ### Added — time-based blind SQLi (per-DBMS, detection + extraction)

package/dist/index.js

@@ -62443,6 +62443,46 @@ async function blindOracle(baseUrl, param, value, opts = {}) {
     interpretation: "A signal means the parameter reaches that sink (evidence: the differential). Verify live before reporting — the oracle is a detection hint, not proof."
   };
 }
+async function confirmBlindSqli(baseUrl, param, value, dbms = "mysql") {
+  const base = baseUrl.replace(/\/+$/, "");
+  const p = blindSqli(dbms);
+  if (!p)
+    return { error: `no blind-SQLi playbook for '${dbms}'`, known: ["mysql", "postgresql", "mssql", "oracle", "sqlite"] };
+  const headers = { "User-Agent": "Mozilla/5.0 (blitzstrike confirm)" };
+  const build = (payload) => `${base}?${encodeURIComponent(param)}=${encodeURIComponent(payload)}`;
+  const fetchSize = async (payload) => {
+    try {
+      const r = await fetch(build(payload), { headers, redirect: "manual", signal: AbortSignal.timeout(9000) });
+      const body = await r.text();
+      return { ok: true, status: r.status, size: body.length };
+    } catch (e) {
+      return { ok: false, status: 0, size: 0 };
+    }
+  };
+  const fetchTiming = async (payload) => {
+    const t0 = Date.now();
+    const r = await fetchSize(payload);
+    return { ok: r.ok, size: r.size, ms: Date.now() - t0 };
+  };
+  const bt = await fetchSize(`${value}${p.oracle.boolean_true}`);
+  const bf = await fetchSize(`${value}${p.oracle.boolean_false}`);
+  const boolDiff = bt.ok && bf.ok && bt.size !== bf.size;
+  const tt = await fetchTiming(`${value}${p.oracle.time_true}`);
+  const tf = await fetchTiming(`${value}${p.oracle.time_false}`);
+  const timeDiff = tt.ms > 2000 && tf.ms < 2000;
+  const confirmed = boolDiff || timeDiff;
+  const channel = boolDiff && timeDiff ? "both" : boolDiff ? "boolean" : timeDiff ? "time" : null;
+  return {
+    dbms,
+    param,
+    value,
+    boolean: { true_size: bt.size, false_size: bf.size, differential: boolDiff },
+    time: { true_ms: tt.ms, false_ms: tf.ms, differential: timeDiff },
+    confirmed,
+    channel,
+    evidence: confirmed ? `blind SQLi CONFIRMED via ${channel} differential — ` + (boolDiff ? `boolean TRUE=${bt.size}b vs FALSE=${bf.size}b` : "") + (boolDiff && timeDiff ? "; " : "") + (timeDiff ? `time TRUE≈${tt.ms}ms vs FALSE≈${tf.ms}ms` : "") + "." : "no clean boolean or time differential observed — not confirmed as blind SQLi (could be a WAF, a non-boolean sink, or a false arithmetic hint)."
+  };
+}
 
 // src/param-precedence.ts
 function generatePrecedenceVariants(param, a, b) {
@@ -65125,6 +65165,18 @@ ${statusLine}` : statusLine },
     }
     return { content: [{ type: "text", text: JSON.stringify(await blindOracle(base_url, param, value, { sinks: s, timeDbms: time_dbms })) }] };
   });
+  server.registerTool("blind_sqli_confirm", {
+    title: "Blind SQLi confirmation (autonomous boolean + time oracle)",
+    description: "CONFIRM: turn blindOracle's 'SQL context' HINT into 'blind SQLi CONFIRMED'. Sends the actual boolean oracle (TRUE vs FALSE byte-count differential) and time oracle (TRUE-branch sleep vs FALSE-branch instant) — payloads come from the blind_sqli playbook, NOT hand-written — and returns a deterministic verdict. confirmed=true only when a clean boolean or time differential is observed. Call AFTER blind_oracle flags SQL context.",
+    inputSchema: {
+      base_url: string2().describe("Target base URL"),
+      param: string2().describe("Parameter name to confirm (e.g. id)"),
+      value: string2().describe("Baseline value (e.g. 1)"),
+      dbms: string2().optional().describe("DBMS for the oracle payloads (mysql | postgresql | mssql | oracle | sqlite; default mysql)")
+    }
+  }, async ({ base_url, param, value, dbms }) => {
+    return { content: [{ type: "text", text: JSON.stringify(await confirmBlindSqli(base_url, param, value, dbms ?? "mysql")) }] };
+  });
   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.",

package/package.json

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