blitzstrike 2.4.32 → 2.4.34

package/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.34] — 2026-09-14
+
+### Added — Framework Security Knowledge Graph (WordPress authz/nonce)
+
+- New `src/framework-security.ts`: WordPress security primitives encoded as DATA
+  (auth, nonce, entry-point hooks, sanitizers), exposed via `framework_knowledge`.
+- `detectMissingAuthz` (wired into `complex_scan`) finds missing capability /
+  nonce checks on WP entry points — `wp_ajax_*` / `wp_ajax_nopriv_*` /
+  `admin_post_*` / `register_rest_route` without `current_user_can`,
+  `wp_verify_nonce`, or `permission_callback` (auth bypass + CSRF + privesc,
+  the class that dominates real WordPress CVE reports).
+
+## [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-authz-safe.md

@@ -0,0 +1,15 @@
+- id: cb-authz-safe
+- language: php
+- vulnerable: false
+- detector: complex_bugs
+
+```php
+<?php
+add_action('wp_ajax_delete_user', 'safe_handler');
+function safe_handler() {
+    check_ajax_referer('nonce');
+    if (!current_user_can('manage_options')) { wp_die('no'); }
+    $id = intval($_POST['id']);
+    $wpdb->query($wpdb->prepare("DELETE FROM users WHERE id=%d", $id));
+}
+```

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

@@ -0,0 +1,13 @@
+- id: cb-authz-vuln
+- language: php
+- vulnerable: true
+- detector: complex_bugs
+
+```php
+<?php
+add_action('wp_ajax_nopriv_delete_user', 'delete_user_handler');
+function delete_user_handler() {
+    $id = $_POST['id'];
+    $wpdb->query("DELETE FROM users WHERE id=$id");
+}
+```

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,360 @@ 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/framework-security.ts
+var WP_PRIMITIVES = {
+  framework: "wordpress",
+  auth_primitives: [
+    "current_user_can",
+    "current_user_can_edit_post",
+    "current_user_can_for_blog",
+    "current_user_can_edit_others_posts",
+    "is_user_logged_in",
+    "authorize"
+  ],
+  nonce_primitives: [
+    "wp_verify_nonce",
+    "check_ajax_referer",
+    "check_admin_referer",
+    "verify_nonce"
+  ],
+  entry_point_hooks: [
+    "wp_ajax_",
+    "wp_ajax_nopriv_",
+    "admin_post_",
+    "admin_post_nopriv_",
+    "register_rest_route",
+    "add_shortcode",
+    "init",
+    "rest_api_init"
+  ],
+  sanitizers: [
+    "sanitize_text_field",
+    "esc_sql",
+    "esc_html",
+    "esc_attr",
+    "esc_url",
+    "wp_kses",
+    "wp_kses_post",
+    "absint",
+    "sanitize_email",
+    "sanitize_file_name"
+  ]
+};
+var FRAMEWORKS = {
+  wordpress: WP_PRIMITIVES,
+  wp: WP_PRIMITIVES
+};
+function frameworkKnowledge(framework = "wordpress") {
+  return FRAMEWORKS[framework.toLowerCase()] ?? null;
+}
+function functionBody(code, name) {
+  const idx = code.search(new RegExp(`function\\s+${name}\\s*\\(`));
+  if (idx === -1)
+    return null;
+  const open = code.indexOf("{", idx);
+  if (open === -1)
+    return null;
+  let depth = 0;
+  for (let i = open;i < code.length; i++) {
+    if (code[i] === "{")
+      depth++;
+    else if (code[i] === "}") {
+      depth--;
+      if (depth === 0)
+        return code.slice(open, i + 1);
+    }
+  }
+  return code.slice(open);
+}
+function lineNoOf(code, pos) {
+  let n = 1;
+  for (let i = 0;i < pos; i++)
+    if (code.charCodeAt(i) === 10)
+      n++;
+  return n;
+}
+var INDIRECT_AUTH = /\b[a-zA-Z0-9_]*(auth|permission|cap|nonce|can_|check|verify|allow)[a-zA-Z0-9_]*\s*\(/;
+function detectMissingAuthz(code, file) {
+  const out = [];
+  const ajaxRe = /add_action\s*\(\s*['"](wp_ajax(?:_nopriv)?_\w+)['"]\s*,\s*['"](\w+)['"]/g;
+  let m;
+  while ((m = ajaxRe.exec(code)) !== null) {
+    const hook = m[1];
+    const handler = m[2];
+    const nopriv = hook.startsWith("wp_ajax_nopriv_");
+    const body = functionBody(code, handler);
+    if (!body)
+      continue;
+    const hasCap = /current_user_can|is_user_logged_in|authorize/.test(body) || INDIRECT_AUTH.test(body);
+    const hasNonce = /wp_verify_nonce|check_ajax_referer|check_admin_referer|verify_nonce/.test(body);
+    const line = lineNoOf(code, m.index);
+    if (nopriv && !hasCap) {
+      out.push({
+        file,
+        line,
+        type: "missing_authz",
+        category: "Missing capability check (unauthenticated AJAX handler)",
+        severity: "high",
+        evidence: `add_action('${hook}', '${handler}')`,
+        detail: `Unauthenticated AJAX handler '${handler}()' performs no current_user_can()/authorization check — any unauthenticated visitor can trigger it (auth bypass / privilege escalation).`
+      });
+    }
+    if (!hasNonce) {
+      out.push({
+        file,
+        line,
+        type: "missing_nonce",
+        category: "Missing nonce verification",
+        severity: "medium",
+        evidence: `add_action('${hook}', '${handler}')`,
+        detail: `AJAX handler '${handler}()' does not verify a nonce (wp_verify_nonce / check_ajax_referer) — CSRF: an attacker can force an authenticated admin to trigger it.`
+      });
+    }
+  }
+  const adminRe = /add_action\s*\(\s*['"](admin_post(?:_nopriv)?_\w+)['"]\s*,\s*['"](\w+)['"]/g;
+  while ((m = adminRe.exec(code)) !== null) {
+    const hook = m[1];
+    const handler = m[2];
+    const nopriv = hook.startsWith("admin_post_nopriv_");
+    const body = functionBody(code, handler);
+    if (!body)
+      continue;
+    const hasCap = /current_user_can|is_user_logged_in|authorize/.test(body) || INDIRECT_AUTH.test(body);
+    const hasNonce = /wp_verify_nonce|check_admin_referer|verify_nonce/.test(body);
+    const line = lineNoOf(code, m.index);
+    if (nopriv && !hasCap) {
+      out.push({
+        file,
+        line,
+        type: "missing_authz",
+        category: "Missing capability check (unauthenticated admin-post handler)",
+        severity: "high",
+        evidence: `add_action('${hook}', '${handler}')`,
+        detail: `Unauthenticated admin-post handler '${handler}()' has no authorization check — auth bypass / privilege escalation.`
+      });
+    }
+    if (!hasNonce) {
+      out.push({
+        file,
+        line,
+        type: "missing_nonce",
+        category: "Missing nonce verification",
+        severity: "medium",
+        evidence: `add_action('${hook}', '${handler}')`,
+        detail: `admin-post handler '${handler}()' does not verify a nonce — CSRF.`
+      });
+    }
+  }
+  const restRe = /register_rest_route\s*\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/g;
+  while ((m = restRe.exec(code)) !== null) {
+    const line = lineNoOf(code, m.index);
+    const window2 = code.slice(m.index, m.index + 800);
+    if (/permission_callback/.test(window2))
+      continue;
+    out.push({
+      file,
+      line,
+      type: "missing_authz",
+      category: "REST route missing permission_callback",
+      severity: "high",
+      evidence: `register_rest_route('${m[1]}', '${m[2]}')`,
+      detail: `REST route '${m[1]}${m[2]}' has no permission_callback — the endpoint defaults to public (auth bypass / unauthenticated data access or mutation).`
+    });
+  }
+  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 +56455,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 +56477,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 +56517,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 +56541,8 @@ function detectComplexBugs(code, file) {
   detectSsrF(code, file, out);
   detectXxe(code, file, out);
   detectSsti(code, file, out);
+  out.push(...detectWrongSanitizer(code, file));
+  out.push(...detectMissingAuthz(code, file));
   const seen = new Set;
   return out.filter((f) => {
     const key = `${f.type}:${f.line}`;
@@ -56207,7 +56561,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 +56583,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 +56605,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 +56636,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 +56664,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 +56689,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 +57982,32 @@ ${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("framework_knowledge", {
+    title: "Framework security knowledge graph",
+    description: "FRAMEWORK-KNOWLEDGE: return a framework's security primitives as data — authorization primitives (current_user_can, is_user_logged_in), nonce/CSRF primitives (wp_verify_nonce, check_ajax_referer), entry-point hooks (wp_ajax_*, admin_post_*, register_rest_route), and sanitizers. Powers the missing-authz/nonce detector. Extensible to other frameworks.",
+    inputSchema: {
+      framework: string2().optional().describe("Framework id (default 'wordpress')")
+    }
+  }, async ({ framework }) => {
+    const k = frameworkKnowledge(framework ?? "wordpress");
+    return { content: [{ type: "text", text: JSON.stringify(k ?? { error: "framework not in the knowledge graph", framework }) }] };
+  });
   server.registerTool("payload_lookup", {
     title: "Look up exploit payloads",
     description: "INTEL: find a payload collection (66 categories from PayloadsAllTheThings).",
@@ -58176,8 +58556,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 / missing authz+nonce)",
+    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 = readFileSync21(path, "utf8");

package/package.json

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