blitzstrike 2.4.40 → 2.4.42

package/CHANGELOG.md

@@ -5,6 +5,31 @@ 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.42] — 2026-09-14
+
+### Added — Duplicate Parameter Precedence Fuzzer (WAF-bypass oracle)
+
+- New `src/param-precedence.ts`: determine how the app resolves duplicate
+  parameters + alternate delimiters (`;` `,` `%26` `%3b` `|` `[]` `%00` `+`),
+  and classify first-wins / last-wins / mixed precedence.
+- New `param_precedence` tool: baseline A/B + differential per variant, with a
+  DERIVED waf_bypass_hint (inject via the WAF/app disagreement).
+- System prompt: added a "LIVE PENTEST + TARGETING" directive wiring the new
+  black-box tools (cache_gap / blind_oracle / param_precedence) and source
+  targeting tools (action_surface / security_state / framework_knowledge /
+  variant_scan / patch_analyze) into a coherent, evidence-first workflow.
+
+## [2.4.41] — 2026-09-14
+
+### Added — Blind Differential Oracle (calibration-based sink detection)
+
+- New `src/blind-oracle.ts`: detect which sink a request parameter reaches
+  WITHOUT a malicious payload — calibration + differential. Arithmetic
+  identities (`id=1` vs `id=1+0`/`id=2-1`) reveal SQL/expression context; SSTI
+  arithmetic (`test${7*7}`) reveals template engines; a unique marker reveals
+  XSS reflection. Benign probes (numbers + operators), deterministic inference.
+- New `blind_oracle` tool: WAF-safe blind detection for sql/ssti/xss.
+
 ## [2.4.40] — 2026-09-14
 
 ### Added — Web Cache Key Normalization Gap Fuzzer (live, black-box)

package/dist/index.js

@@ -57506,6 +57506,209 @@ async function cacheGapScan(baseUrl, endpoint, opts = {}) {
   };
 }
 
+// src/blind-oracle.ts
+function arithmeticProbes(value) {
+  const n = Number(value);
+  if (Number.isNaN(n) || value.trim() === "")
+    return [];
+  return [
+    { sink: "sql_arithmetic", name: "plus_zero", payload: `${n}+0` },
+    { sink: "sql_arithmetic", name: "minus_zero", payload: `${n}-0` },
+    { sink: "sql_arithmetic", name: "times_one", payload: `${n}*1` },
+    { sink: "sql_coercion", name: "leading_zero", payload: `0${value}` },
+    { sink: "sql_coercion", name: "float_form", payload: `${n}.0` }
+  ];
+}
+function sstiProbes(value) {
+  return [
+    { sink: "ssti", name: "dollar_math", payload: `${value}\${7*7}` },
+    { sink: "ssti", name: "hash_math", payload: `${value}#{7*7}` },
+    { sink: "ssti", name: "mustache_math", payload: `${value}{{7*7}}` }
+  ];
+}
+function xssProbe(value, marker) {
+  return { sink: "xss", name: "marker", payload: `${value}${marker}` };
+}
+function classifyBlindProbe(input) {
+  const same = input.bodyHash === input.baselineHash;
+  let signal = false;
+  let reason = "";
+  if (input.sink === "sql_arithmetic" && same) {
+    signal = true;
+    reason = "arithmetic identity returned the SAME result as the bare value — the parameter is evaluated arithmetically (SQL/expression context).";
+  } else if (input.sink === "sql_coercion" && same) {
+    signal = true;
+    reason = "type-coerced variant returned the SAME result — the parameter is normalized numerically (SQL typed column).";
+  } else if (input.sink === "ssti" && !same && /49/.test(input.body)) {
+    signal = true;
+    reason = "the SSTI arithmetic (7*7) rendered as 49 in the response — the parameter reaches a template engine (SSTI).";
+  } else if (input.sink === "xss" && input.marker && input.body.includes(input.marker)) {
+    signal = true;
+    reason = "the unique marker was reflected in the response — the parameter reaches HTML output (reflected).";
+  }
+  return { same_as_baseline: same, signal, reason };
+}
+async function blindOracle(baseUrl, param, value, opts = {}) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const sinks = opts.sinks ?? ["sql", "ssti", "xss"];
+  const marker = `zz${Math.random().toString(36).slice(2, 10)}zz`;
+  const headers = { "User-Agent": "Mozilla/5.0 (blitzstrike oracle probe)" };
+  const timeoutMs = opts.timeoutMs ?? 8000;
+  const build = (payload) => `${base}?${encodeURIComponent(param)}=${encodeURIComponent(payload)}`;
+  let baselineHash = "";
+  let baselineSize = 0;
+  let baselineStatus = 0;
+  try {
+    const r = await fetch(build(value), { headers, redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+    baselineStatus = r.status;
+    const body = await r.text();
+    baselineHash = sha256(body);
+    baselineSize = body.length;
+  } catch (e) {
+    return { error: "baseline fetch failed", base_url: base, param, detail: String(e) };
+  }
+  const probes = [];
+  if (sinks.includes("sql"))
+    probes.push(...arithmeticProbes(value));
+  if (sinks.includes("ssti"))
+    probes.push(...sstiProbes(value));
+  if (sinks.includes("xss"))
+    probes.push(xssProbe(value, marker));
+  const results = [];
+  for (const p of probes) {
+    const t0 = Date.now();
+    try {
+      const r = await fetch(build(p.payload), { headers, redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+      const timing = Date.now() - t0;
+      const status = r.status;
+      const body = await r.text();
+      const bodyHash = sha256(body);
+      const cls = classifyBlindProbe({
+        baselineHash,
+        baselineSize,
+        bodyHash,
+        size: body.length,
+        sink: p.sink,
+        name: p.name,
+        body,
+        marker
+      });
+      results.push({
+        sink: p.sink,
+        name: p.name,
+        payload: p.payload,
+        status,
+        size: body.length,
+        timing_ms: timing,
+        body_hash: bodyHash.slice(0, 12),
+        same_as_baseline: cls.same_as_baseline,
+        signal: cls.signal,
+        reason: cls.reason
+      });
+    } catch {
+      results.push({ sink: p.sink, name: p.name, payload: p.payload, status: 0, size: 0, timing_ms: 0, body_hash: "", same_as_baseline: false, signal: false, reason: "fetch error/timeout" });
+    }
+  }
+  const signals = results.filter((r) => r.signal === true);
+  return {
+    base_url: base,
+    param,
+    value,
+    baseline: { status: baselineStatus, size: baselineSize, body_hash: baselineHash.slice(0, 16) },
+    probes_tested: results.length,
+    signals_found: signals.length,
+    signals,
+    all: results,
+    interpretation: "A signal means the parameter reaches that sink (evidence: the differential). Verify live before reporting — the oracle is a detection hint, not proof."
+  };
+}
+
+// src/param-precedence.ts
+function generatePrecedenceVariants(param, a, b) {
+  const enc = encodeURIComponent;
+  const variants = [
+    { name: "duplicate_amp", qs: `${enc(param)}=${enc(a)}&${enc(param)}=${enc(b)}` },
+    { name: "semicolon", qs: `${enc(param)}=${enc(a)};${enc(param)}=${enc(b)}` },
+    { name: "comma", qs: `${enc(param)}=${enc(a)},${enc(param)}=${enc(b)}` },
+    { name: "encoded_amp", qs: `${enc(param)}=${enc(a)}%26${enc(param)}=${enc(b)}` },
+    { name: "encoded_semicolon", qs: `${enc(param)}=${enc(a)}%3b${enc(param)}=${enc(b)}` },
+    { name: "pipe", qs: `${enc(param)}=${enc(a)}|${enc(param)}=${enc(b)}` },
+    { name: "array", qs: `${enc(param)}[]=${enc(a)}&${enc(param)}[]=${enc(b)}` },
+    { name: "null_byte", qs: `${enc(param)}=${enc(a)}%00${enc(b)}` },
+    { name: "space", qs: `${enc(param)}=${enc(a)}+${enc(b)}` }
+  ];
+  return variants;
+}
+function classifyPrecedence(input) {
+  const h = input.bodyHash;
+  if (h === input.hashA) {
+    return { winner: "A", split: true, detail: "value A won (the first/leftmost value) — first-wins precedence for this delimiter." };
+  }
+  if (h === input.hashB) {
+    return { winner: "B", split: true, detail: "value B won (the last/rightmost value) — last-wins precedence for this delimiter." };
+  }
+  return { winner: "neither", split: false, detail: "neither A nor B matched — the delimiter may be literal (not a parameter separator) or the values were joined." };
+}
+async function paramPrecedenceScan(baseUrl, param, valueA, valueB, opts = {}) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const headers = { "User-Agent": "Mozilla/5.0 (blitzstrike precedence probe)" };
+  const timeoutMs = opts.timeoutMs ?? 8000;
+  const enc = encodeURIComponent;
+  const fetchHash = async (qs) => {
+    try {
+      const r = await fetch(`${base}?${qs}`, { headers, redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+      const body = await r.text();
+      return { status: r.status, hash: sha256(body) };
+    } catch (e) {
+      return { status: 0, hash: "", error: String(e) };
+    }
+  };
+  const baseA = await fetchHash(`${enc(param)}=${enc(valueA)}`);
+  const baseB = await fetchHash(`${enc(param)}=${enc(valueB)}`);
+  if (baseA.error || baseB.error) {
+    return { error: "baseline fetch failed", base_url: base, param, detail: baseA.error ?? baseB.error };
+  }
+  if (baseA.hash === baseB.hash) {
+    return { error: "baseline A and B produce identical responses — pick two values with a distinguishable effect", base_url: base, param };
+  }
+  const variants = generatePrecedenceVariants(param, valueA, valueB);
+  const results = [];
+  let firstWins = 0;
+  let lastWins = 0;
+  for (const v of variants) {
+    const r = await fetchHash(v.qs);
+    if (r.error) {
+      results.push({ name: v.name, qs: v.qs, status: 0, body_hash: "", winner: "neither", split: false, detail: "fetch error/timeout" });
+      continue;
+    }
+    const cls = classifyPrecedence({ hashA: baseA.hash, hashB: baseB.hash, bodyHash: r.hash, name: v.name });
+    if (cls.winner === "A")
+      firstWins++;
+    else if (cls.winner === "B")
+      lastWins++;
+    results.push({ name: v.name, qs: v.qs, status: r.status, body_hash: r.hash.slice(0, 12), winner: cls.winner, split: cls.split, detail: cls.detail });
+  }
+  let precedence = "ambiguous";
+  if (firstWins > 0 && lastWins === 0)
+    precedence = "first_wins";
+  else if (lastWins > 0 && firstWins === 0)
+    precedence = "last_wins";
+  else if (firstWins > 0 && lastWins > 0)
+    precedence = "mixed_by_delimiter";
+  return {
+    base_url: base,
+    param,
+    value_a: valueA,
+    value_b: valueB,
+    precedence,
+    first_wins_count: firstWins,
+    last_wins_count: lastWins,
+    variants_tested: results.length,
+    results,
+    waf_bypass_hint: precedence === "first_wins" ? "the app uses the FIRST duplicate value — a WAF that inspects the LAST value is bypassed with ?param=benign&param=payload." : precedence === "last_wins" ? "the app uses the LAST duplicate value — a WAF that inspects the FIRST value is bypassed with ?param=payload&param=benign." : "precedence is mixed by delimiter — map which delimiter the WAF validates vs which the app binds, then inject via the disagreement."
+  };
+}
+
 // src/enterprise-benchmark.ts
 import { existsSync as existsSync11, readFileSync as readFileSync20, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
 import { join as join18, resolve } from "node:path";
@@ -57745,8 +57948,7 @@ function createServer() {
 ` + `- 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). 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.
-` + `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) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability).
-` + `PRECISION ANALYSIS — chrome-devtools MCP is MANDATORY, not optional:
+` + "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) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). 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.\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."
@@ -58505,6 +58707,36 @@ ${statusLine}` : statusLine },
   }, async ({ base_url, endpoint, max_variants }) => {
     return { content: [{ type: "text", text: JSON.stringify(await cacheGapScan(base_url, endpoint, { maxVariants: max_variants })) }] };
   });
+  server.registerTool("blind_oracle", {
+    title: "Blind differential oracle (calibration-based sink detection)",
+    description: "LIVE (black-box, WAF-safe): detect which sink a request parameter reaches WITHOUT a malicious payload — calibration + differential. Arithmetic identities (id=1 vs id=1+0 / id=2-1) reveal SQL/expression context; SSTI arithmetic (test${7*7}) reveals template engines; a unique marker reveals XSS reflection. Benign probes (numbers + operators, no quotes/commands), deterministic byte-level inference.",
+    inputSchema: {
+      base_url: string2().describe("Target base URL"),
+      param: string2().describe("Parameter name to probe (e.g. id)"),
+      value: string2().describe("Baseline value for the parameter (e.g. 1)"),
+      sinks: string2().optional().describe("JSON array of sinks to probe (default ['sql','ssti','xss'])")
+    }
+  }, async ({ base_url, param, value, sinks }) => {
+    let s;
+    try {
+      s = sinks ? JSON.parse(sinks) : undefined;
+    } catch {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "invalid sinks JSON" }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(await blindOracle(base_url, param, value, { sinks: s })) }] };
+  });
+  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.",
+    inputSchema: {
+      base_url: string2().describe("Target base URL"),
+      param: string2().describe("Parameter name (e.g. id)"),
+      value_a: string2().describe("First value (e.g. 1)"),
+      value_b: string2().describe("Second value (e.g. 2)")
+    }
+  }, async ({ base_url, param, value_a, value_b }) => {
+    return { content: [{ type: "text", text: JSON.stringify(await paramPrecedenceScan(base_url, param, value_a, value_b)) }] };
+  });
   server.registerTool("payload_lookup", {
     title: "Look up exploit payloads",
     description: "INTEL: find a payload collection (66 categories from PayloadsAllTheThings).",

package/package.json

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