blitzstrike 2.4.32 → 2.4.33

package/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to Blitz Strike are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.4.33] — 2026-09-14
+
+### Added — Security-State Lattice (beyond binary taint)
+
+- New `src/security-state.ts`: models each value's SECURITY STATE
+  (clean < whitelisted < validated < sanitized(context) < tainted) instead of
+  binary tainted/not. A sink declares the minimum context it accepts.
+- `detectWrongSanitizer` (wired into `complex_scan`/`blitz_file`) finds the
+  complex bug class binary taint misses: a value sanitized for context X
+  reaching a sink that needs Y (e.g. `sanitize_text_field()` into a SQL query),
+  and pseudo-sanitizers (`base64_encode()`/`trim()` misused as escaping).
+- New `security_state` tool: deterministic verdict for a sanitizer flow.
+- Data-driven tables (sanitizers, pseudo-sanitizers, sink requirements) —
+  the lattice is data, not guesses.
+
 ## [2.4.32] — 2026-09-14
 
 ### Removed

package/bench/corpus/cb-wrongsanitizer-safe.md

@@ -0,0 +1,10 @@
+- id: cb-wrongsanitizer-safe
+- language: php
+- vulnerable: false
+- detector: complex_bugs
+
+```php
+<?php
+$name = esc_sql($_GET['name']);
+$wpdb->query("SELECT * FROM users WHERE name = '$name'");
+```

package/bench/corpus/cb-wrongsanitizer-vuln.md

@@ -0,0 +1,10 @@
+- id: cb-wrongsanitizer-vuln
+- language: php
+- vulnerable: true
+- detector: complex_bugs
+
+```php
+<?php
+$name = sanitize_text_field($_GET['name']);
+$wpdb->query("SELECT * FROM users WHERE name = '$name'");
+```

package/dist/index.js

@@ -56078,8 +56078,189 @@ function detectRouteConfusion(code, file) {
   return out;
 }
 
+// src/security-state.ts
+var SANITIZERS2 = {
+  esc_sql: { context: "sql", level: "sanitized" },
+  addslashes: { context: "sql", level: "sanitized" },
+  mysqli_real_escape_string: { context: "sql", level: "sanitized" },
+  mysql_real_escape_string: { context: "sql", level: "sanitized" },
+  pg_escape_string: { context: "sql", level: "sanitized" },
+  sanitize_text_field: { context: "html", level: "sanitized" },
+  sanitize_textarea_field: { context: "html", level: "sanitized" },
+  esc_html: { context: "html", level: "sanitized" },
+  esc_html__: { context: "html", level: "sanitized" },
+  htmlspecialchars: { context: "html", level: "sanitized" },
+  htmlentities: { context: "html", level: "sanitized" },
+  wp_kses: { context: "html", level: "sanitized" },
+  wp_kses_post: { context: "html", level: "sanitized" },
+  wp_kses_data: { context: "html", level: "sanitized" },
+  strip_tags: { context: "html", level: "sanitized" },
+  esc_attr: { context: "html_attr", level: "sanitized" },
+  esc_url: { context: "url", level: "sanitized" },
+  esc_url_raw: { context: "url", level: "sanitized" },
+  urlencode: { context: "url", level: "sanitized" },
+  rawurlencode: { context: "url", level: "sanitized" },
+  wp_json_encode: { context: "json", level: "sanitized" },
+  json_encode: { context: "json", level: "sanitized" },
+  absint: { context: "int", level: "validated" },
+  intval: { context: "int", level: "validated" },
+  sanitize_key: { context: "key", level: "validated" },
+  sanitize_email: { context: "email", level: "validated" },
+  sanitize_file_name: { context: "filename", level: "validated" },
+  filter_var: { context: "validated", level: "validated" }
+};
+var PSEUDO_SANITIZERS = new Set([
+  "trim",
+  "ltrim",
+  "rtrim",
+  "strtolower",
+  "strtoupper",
+  "ucfirst",
+  "ucwords",
+  "base64_encode",
+  "base64_decode",
+  "urldecode",
+  "rawurldecode",
+  "stripslashes",
+  "html_entity_decode",
+  "htmlspecialchars_decode",
+  "json_decode",
+  "unserialize",
+  "serialize",
+  "substr",
+  "mb_substr",
+  "explode",
+  "implode",
+  "str_replace",
+  "preg_replace",
+  "nl2br",
+  "strval",
+  "number_format",
+  "sprintf",
+  "md5",
+  "sha1",
+  "hash",
+  "crypt",
+  "chr",
+  "ord",
+  "strrev",
+  "str_repeat",
+  "str_pad"
+]);
+var SINK_REQUIREMENTS = {
+  sql_execution: ["sql", "sql_param", "int"],
+  code_execution: ["code"],
+  command_execution: ["code"],
+  deserialization: ["code"],
+  file_operations: ["filename"],
+  redirect: ["url"],
+  html_render: ["html"]
+};
+var SOURCE_TOKENS2 = /\$_(GET|POST|REQUEST|COOKIE|FILES|SERVER)\b|->(input|query|request)\(|\breq\.(query|body|params|headers|cookies)|\bgetParameter\(/;
+function analyzeSecurityState(input) {
+  let state = "tainted";
+  let context = null;
+  for (const fn of input.sanitizers) {
+    const s = SANITIZERS2[fn];
+    if (!s)
+      continue;
+    if (s.level === "validated") {
+      if (state === "tainted" || state === "sanitized") {
+        state = "validated";
+        context = s.context;
+      }
+    } else if (state === "tainted") {
+      state = "sanitized";
+      context = s.context;
+    }
+  }
+  const required = SINK_REQUIREMENTS[input.sinkType] ?? [];
+  if (required.length === 0) {
+    return { verdict: "unknown", state, context, required, reason: `sink type '${input.sinkType}' not in the requirements table` };
+  }
+  if (state === "tainted") {
+    return { verdict: "vulnerable", state, context, required, reason: `raw tainted input reaches a ${input.sinkType} sink with no sanitization` };
+  }
+  if (state === "validated") {
+    return { verdict: "safe", state, context, required, reason: `input validated (${context}) — safe for any sink` };
+  }
+  if (state === "sanitized") {
+    if (context && required.includes(context)) {
+      return { verdict: "safe", state, context, required, reason: `sanitized for '${context}' — matches sink requirement ${required.join("/")}` };
+    }
+    return { verdict: "vulnerable", state, context, required, reason: `sanitized for '${context}' but this sink requires ${required.join("/")} — WRONG sanitizer (context mismatch)` };
+  }
+  return { verdict: "unknown", state, context, required, reason: "unhandled state" };
+}
+function sinkTypeOf(line) {
+  if (/\$wpdb->(query|get_var|get_row|get_results|get_col)|mysqli_query\s*\(|mysql_query\s*\(|pg_query\s*\(|->query\s*\(/.test(line) && !/->prepare\s*\(/.test(line))
+    return "sql_execution";
+  if (/\b(eval|assert)\s*\(/.test(line))
+    return "code_execution";
+  if (/\b(system|exec|shell_exec|passthru|proc_open|popen)\s*\(/.test(line))
+    return "command_execution";
+  if (/\b(unserialize|maybe_unserialize)\s*\(/.test(line))
+    return "deserialization";
+  if (/\b(file_get_contents|file_put_contents|fopen|readfile|include|require|include_once|require_once)\s*\(/.test(line))
+    return "file_operations";
+  if (/header\s*\(\s*['"]Location/i.test(line))
+    return "redirect";
+  return null;
+}
+function detectWrongSanitizer(code, file) {
+  const out = [];
+  const ls = code.split(`
+`);
+  const varSanitizer = new Map;
+  for (const line of ls) {
+    const m = line.match(/\$(\w+)\s*=\s*([a-zA-Z0-9_]+)\s*\(\s*([^)]*)\s*\)\s*;?/);
+    if (!m)
+      continue;
+    const [, varName, fn, arg] = m;
+    if (!SOURCE_TOKENS2.test(arg))
+      continue;
+    if (SANITIZERS2[fn])
+      varSanitizer.set(varName, fn);
+    else if (PSEUDO_SANITIZERS.has(fn))
+      varSanitizer.set(varName, fn);
+  }
+  for (let i = 0;i < ls.length; i++) {
+    const line = ls[i];
+    const sinkType = sinkTypeOf(line);
+    if (!sinkType)
+      continue;
+    const required = SINK_REQUIREMENTS[sinkType] ?? [];
+    for (const [varName, fn] of varSanitizer) {
+      if (!new RegExp(`\\$${varName}\\b`).test(line))
+        continue;
+      const sanitizer = SANITIZERS2[fn];
+      const context = sanitizer?.context ?? null;
+      if (sanitizer && (sanitizer.level === "validated" || context && required.includes(context)))
+        continue;
+      const detail = sanitizer ? `$${varName} was sanitized for '${context}' (${fn}()) but this ${sinkType} sink requires ${required.join("/")} — WRONG sanitizer (context mismatch).` : `$${varName} passed through ${fn}() — a NON-sanitizing transformation — and still reaches this ${sinkType} sink as raw tainted input. ${fn}() does not neutralize ${required.join("/")} context.`;
+      out.push({
+        file,
+        line: i + 1,
+        type: "wrong_sanitizer",
+        category: "Wrong-context sanitization / pseudo-sanitizer",
+        severity: "high",
+        evidence: line.trim(),
+        detail
+      });
+    }
+  }
+  const seen = new Set;
+  return out.filter((f) => {
+    const key = `${f.type}:${f.line}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 // src/complex-bugs.ts
-var SOURCE_TOKENS2 = /\$_(GET|POST|REQUEST|COOKIE|FILES|SERVER)\b|\$request->|\$req->|request\.(get|input|query|post|data|body|headers|cookies|params)|getParameter\(|req\.(query|body|params|headers|cookies)/;
+var SOURCE_TOKENS3 = /\$_(GET|POST|REQUEST|COOKIE|FILES|SERVER)\b|\$request->|\$req->|request\.(get|input|query|post|data|body|headers|cookies|params)|getParameter\(|req\.(query|body|params|headers|cookies)/;
 function lines2(code) {
   return code.split(`
 `);
@@ -56103,7 +56284,7 @@ function detectDeserialization(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 4), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     out.push({
       file,
@@ -56125,7 +56306,7 @@ function detectTypeJuggling(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 4), ln).join(`
 `);
-    const hasSource = SOURCE_TOKENS2.test(l) || SOURCE_TOKENS2.test(scope);
+    const hasSource = SOURCE_TOKENS3.test(l) || SOURCE_TOKENS3.test(scope);
     const hasHash = /\b(md5|sha1|sha256|hash|crc32|crypt|password_verify|strcmp|hash_equals|secret|token|nonce)\s*\(?/i.test(l) || /\b(secret|token|nonce|hash)\b/i.test(l);
     if (!hasSource || !hasHash)
       continue;
@@ -56165,7 +56346,7 @@ function detectMassAssignment(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 3), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     out.push({
       file,
@@ -56189,6 +56370,7 @@ function detectComplexBugs(code, file) {
   detectSsrF(code, file, out);
   detectXxe(code, file, out);
   detectSsti(code, file, out);
+  out.push(...detectWrongSanitizer(code, file));
   const seen = new Set;
   return out.filter((f) => {
     const key = `${f.type}:${f.line}`;
@@ -56207,7 +56389,7 @@ function detectPrototypePollution(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 4), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     out.push({
       file,
@@ -56229,7 +56411,7 @@ function detectCrlfInjection(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 3), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     out.push({
       file,
@@ -56251,7 +56433,7 @@ function detectPathConfusion(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 3), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     if (/\b(basename|realpath|canonicalPath|getCanonicalPath|normalize|resolve|toRealPath)\s*\(/i.test(scope + `
 ` + l))
@@ -56282,7 +56464,7 @@ function detectSsrF(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 3), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     if (/(allowlist|whitelist|in_array|preg_match|parse_url|startsWith\(["']https?|endsWith\(["']|basename|realpath|normalize)/i.test(scope + `
 ` + l))
@@ -56310,7 +56492,7 @@ function detectXxe(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 4), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     if (/libxml_disable_entity_loader\s*\(\s*true|LIBXML_NONET/.test(scope + `
 ` + l))
@@ -56335,7 +56517,7 @@ function detectSsti(code, file, out) {
     const l = ls[ln - 1] ?? "";
     const scope = ls.slice(Math.max(0, ln - 3), ln).join(`
 `);
-    if (!SOURCE_TOKENS2.test(l) && !SOURCE_TOKENS2.test(scope))
+    if (!SOURCE_TOKENS3.test(l) && !SOURCE_TOKENS3.test(scope))
       continue;
     out.push({
       file,
@@ -57628,6 +57810,22 @@ ${statusLine}` : statusLine },
     }
     return { content: [{ type: "text", text: JSON.stringify(m) }] };
   });
+  server.registerTool("security_state", {
+    title: "Analyze a sanitizer flow (security-state lattice)",
+    description: "SECURITY-STATE: given a value's sanitizer/validator functions + the sink type it reaches, return the deterministic verdict — vulnerable (wrong-context sanitization / pseudo-sanitizer / raw taint) or safe (correct context / validated). This is the step beyond binary taint: it catches 'sanitized for X but used in a Y sink'. The lattice is data-driven, no guesses.",
+    inputSchema: {
+      sanitizers: string2().optional().describe('JSON array of sanitizer/validator function names applied to the value (e.g. ["sanitize_text_field"])'),
+      sink_type: string2().describe("Sink type: sql_execution, code_execution, command_execution, deserialization, file_operations, redirect, html_render")
+    }
+  }, async ({ sanitizers, sink_type }) => {
+    let arr = [];
+    try {
+      arr = sanitizers ? JSON.parse(sanitizers) : [];
+    } catch {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "invalid sanitizers JSON" }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(analyzeSecurityState({ sanitizers: arr, sinkType: sink_type })) }] };
+  });
   server.registerTool("payload_lookup", {
     title: "Look up exploit payloads",
     description: "INTEL: find a payload collection (66 categories from PayloadsAllTheThings).",
@@ -58176,8 +58374,8 @@ ${statusLine}` : statusLine },
     };
   });
   server.registerTool("complex_scan", {
-    title: "Complex-bug scan (deserialization / type juggling / mass assignment / prototype pollution / CRLF / path confusion / SSRF / XXE / SSTI)",
-    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), and SSTI (user input into a template render with no sandbox).",
+    title: "Complex-bug scan (deserialization / type juggling / mass assignment / prototype pollution / CRLF / path confusion / SSRF / XXE / SSTI / wrong-context sanitization)",
+    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), and wrong-context sanitization (a value sanitized for context X reaching a sink that needs Y — e.g. sanitize_text_field() into a SQL query).",
     inputSchema: { path: string2().describe("Source file path") }
   }, async ({ path }) => {
     const code = readFileSync21(path, "utf8");

package/package.json

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