blitzstrike 2.4.78 → 2.4.80

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.80] — 2026-09-17
+
+### Changed — LLM-facing wiring for the two new web-class detectors
+
+- The system prompt ("NEWEST DETECTORS" block) now documents `jwt_alg_confusion`
+  and `cache_deception` — what they detect, the CWE, and a concrete TO TRY recipe
+  for each — so the LLM knows these detectors exist and how to act on a hit.
+- `orchestrator.ts` escalation map now routes `jwt_alg_confusion` →
+  `jwt_alg_confusion_forgery` and `cache_deception` → `cache_deception` chains.
+- Added a dedicated `cache_deception` escalation chain (chains.json) — request an
+  authenticated path with a static extension, then re-fetch anonymously — and
+  pointed the cache_deception pattern's chain_templates at it.
+
+Full end-to-end ground: synonym_lookup → pattern_lookup (CWE + chains + bypass)
+→ severity_calibrate (P1/P2) → list_chains → coverage_matrix.
+
+## [2.4.79] — 2026-09-17
+
+### Changed — precision pass (FP reduction, benchmark-driven)
+
+- Removed the bare `exec(` sink (sqlite `db.exec(...)` / `stmt.exec(...)` was
+  flagged as command execution in Node apps). Command injection is still covered
+  by `child_process.exec/spawn`, `system`, `shell_exec`, `subprocess.*`,
+  `os.system`, `popen`.
+- `detectRouteAuthz`: added `requireAdmin`/`requireRole`/`requirePermission`/
+  `isAdmin`/`checkRole`/`bearer`/`apiAuth`/`getApiKeyFromRequest`/`verifyApiKey`
+  to the express auth model + widened the window to ±3, and added a public-path
+  SEGMENT matcher for multi-segment public routes (`/api/system/version`,
+  `/.well-known/jwks.json`, `/v1/metrics`).
+- `detectHardcodedSecret`: skip values that are function calls
+  (`getApiKeyFromRequest(req)`, `fs.readFileSync(...)`, `make_token(...)`) or DOM
+  reads (`document.getElementById(...).value`) — those are computed at runtime.
+
+FP labs on the 30-lab benchmark dropped 16 → 8 (TP 12 unchanged).
+
 ## [2.4.78] — 2026-09-17
 
 ### Fixed — taint-engine sanitizer name collision (whole-class FN)

package/chains.json

@@ -1,7 +1,7 @@
 {
   "$schema": "blitzstrike-chains-v1",
   "version": "1.0.0",
-  "_comment": "Escalation chains. Each chain links a confirmed primitive into a higher-impact outcome. BlitzStrike edge vs other catalogs: every step carries an invariant_check (what MUST hold) and a negative_control (how to refute). Never hardcode in Python \u2014 edit here.",
+  "_comment": "Escalation chains. Each chain links a confirmed primitive into a higher-impact outcome. BlitzStrike edge vs other catalogs: every step carries an invariant_check (what MUST hold) and a negative_control (how to refute). Never hardcode in Python — edit here.",
   "min_severity": "medium",
   "chains": [
     {
@@ -603,7 +603,7 @@
       "steps": [
         {
           "order": 1,
-          "action": "Test alg=none / RS256\u2192HS256 confusion",
+          "action": "Test alg=none / RS256→HS256 confusion",
           "tool_hint": "strike_verify",
           "success_criteria": "forged token accepted",
           "invariant_check": "server does not pin algorithm / reuses public key as HMAC secret",
@@ -1190,7 +1190,7 @@
         },
         {
           "order": 4,
-          "action": "Test RS256\u2192HS256: sign with public key as HMAC secret",
+          "action": "Test RS256→HS256: sign with public key as HMAC secret",
           "tool_hint": "jwt_tool",
           "success_criteria": "Server accepts HS256 token",
           "invariant_check": "",
@@ -2099,7 +2099,7 @@
       "steps": [
         {
           "order": 1,
-          "action": "Find dangling CNAME: shop.target.com \u2192 shops.myshopify.com (404)",
+          "action": "Find dangling CNAME: shop.target.com → shops.myshopify.com (404)",
           "tool_hint": "subzy",
           "success_criteria": "Claimable subdomain found",
           "invariant_check": "",
@@ -2585,7 +2585,7 @@
         },
         {
           "order": 4,
-          "action": "Blind extraction: {\"password\":{\"$regex\":\"^a\"}} \u2014 iterate chars",
+          "action": "Blind extraction: {\"password\":{\"$regex\":\"^a\"}} — iterate chars",
           "tool_hint": "nosqlmap",
           "success_criteria": "Full DB dumped",
           "invariant_check": "",
@@ -2621,7 +2621,7 @@
         },
         {
           "order": 2,
-          "action": "Enumerate users: admin*)(uid=*))(|(uid=*a*) \u2014 check response delta",
+          "action": "Enumerate users: admin*)(uid=*))(|(uid=*a*) — check response delta",
           "tool_hint": "manual",
           "success_criteria": "User list built",
           "invariant_check": "",
@@ -2754,6 +2754,42 @@
         "curl",
         "swaks"
       ]
+    },
+    {
+      "id": "cache_deception",
+      "name": "Web Cache Deception",
+      "triggers": [
+        "cache deception",
+        "cache key",
+        "static extension",
+        "cookie-less cache"
+      ],
+      "required_findings": [
+        "cache_deception"
+      ],
+      "severity": "high",
+      "steps": [
+        {
+          "order": 1,
+          "action": "Request an authenticated path with a static extension appended (.css/.js/.png)",
+          "tool_hint": "cache_gap / strike_verify",
+          "success_criteria": "the private response is cached under the static URL",
+          "invariant_check": "cache key omits the session cookie while the backend serves per-session data",
+          "negative_control": "cookie included in cache key = victim response not cached"
+        },
+        {
+          "order": 2,
+          "action": "Re-fetch the same URL anonymously and confirm the victim's private body is returned",
+          "tool_hint": "curl / strike_verify",
+          "success_criteria": "victim-session data disclosed to an anonymous caller",
+          "invariant_check": "cache serves the cached body regardless of the requester's session",
+          "negative_control": "cache bypassed or auth required on re-fetch = no disclosure"
+        }
+      ],
+      "tools": [
+        "curl",
+        "cache_gap"
+      ]
     }
   ]
 }

package/dist/index.js

@@ -7190,7 +7190,6 @@ var init_scanner = __esm(() => {
     "eval(": "RCE (code execution)",
     "assert(": "RCE (code execution, PHP <8)",
     "system(": "RCE (command execution)",
-    "exec(": "RCE (command execution)",
     "shell_exec(": "RCE (command execution)",
     "passthru(": "RCE (command execution)",
     "proc_open(": "RCE (command execution)",
@@ -15981,7 +15980,7 @@ function detectRouteAuthz(code, file, out) {
       const ln = lineNoOf(code, m.index);
       const window2 = ls.slice(Math.max(0, ln - d.window), Math.min(ls.length, ln + d.window + 1)).join(`
 `);
-      if (PUBLIC_ROUTE_RE.test(m[0] + " " + window2))
+      if (PUBLIC_ROUTE_RE.test(m[0] + " " + window2) || PUBLIC_SEGMENT_RE.test(m[0] + " " + window2))
         continue;
       if (d.auth.test(window2))
         continue;
@@ -16010,7 +16009,7 @@ function detectMissingAuthz(code, file) {
     return true;
   });
 }
-var FRAMEWORKS, INDIRECT_AUTH, AUTH_RE, NONCE_RE, DANGEROUS_OP_RE, ROUTE_DETECTORS, PUBLIC_ROUTE_RE;
+var FRAMEWORKS, INDIRECT_AUTH, AUTH_RE, NONCE_RE, DANGEROUS_OP_RE, ROUTE_DETECTORS, PUBLIC_ROUTE_RE, PUBLIC_SEGMENT_RE;
 var init_framework_security = __esm(() => {
   FRAMEWORKS = {
     wordpress: {
@@ -16092,13 +16091,14 @@ var init_framework_security = __esm(() => {
     { framework: "laravel", entry: /Route::(?:get|post|put|patch|delete|any|match|resource)\s*\(\s*['"][^'"]+['"]/g, auth: /->middleware\s*\(\s*['"]auth|middleware\s*\(\s*\[[^\]]*['"]auth|->can\s*\(|\$this->authorize|Gate::|authorize\s*\(|@can\b/, window: 2 },
     { framework: "django", entry: /@api_view\s*\(|def\s+\w+\s*\(\s*request\s*[,)]/g, auth: /login_required|permission_required|user_passes_test|LoginRequiredMixin|PermissionRequiredMixin|permission_classes|IsAuthenticated|has_permission/, window: 3 },
     { framework: "flask", entry: /@(?:app|bp|blueprint)\.(?:route|get|post|put|delete|patch|before_request)\s*\(/g, auth: /login_required|require_auth|auth_required|jwt_required|token_required|current_user|is_authenticated|before_request|verify_token|permission_required/, window: 3 },
-    { framework: "express", entry: /(?<!@)(?:app|router)\.(?:get|post|put|delete|patch|use)\s*\(\s*['"][^'"]+['"]/g, auth: /requireAuth|require_auth|authenticate|passport\.authenticate|req\.user|isAuthenticated|ensureAuthenticated|requireLogin|\.authorize|authMiddleware|verifyToken|verify_token|jwt\.verify/, window: 2 },
+    { framework: "express", entry: /(?<!@)(?:app|router)\.(?:get|post|put|delete|patch|use)\s*\(\s*['"][^'"]+['"]/g, auth: /requireAuth|require_auth|requireAdmin|requireRole|requirePermission|isAdmin|checkRole|getApiKeyFromRequest|verifyApiKey|checkApiKey|verifyInternalToken|authenticate|passport\.authenticate|req\.user|isAuthenticated|ensureAuthenticated|requireLogin|\.authorize|authMiddleware|verifyToken|verify_token|jwt\.verify|\bbearer\b|apiAuth/, window: 3 },
     { framework: "spring", entry: /@(?:Get|Post|Put|Delete|Patch|Request)Mapping\s*\(/g, auth: /@PreAuthorize|@Secured|@RolesAllowed|hasRole|hasAuthority|isAuthenticated|SecurityContextHolder/, window: 2 },
     { framework: "symfony", entry: /#\[(?:Route|Get|Post|Put|Delete|Patch)\b|@Route\s*\(/g, auth: /is_granted|denyAccessUnlessGranted|->isGranted\s*\(|IsGranted|Voter/, window: 2 },
     { framework: "aspnet", entry: /\[Http(?:Get|Post|Put|Delete|Patch)\b/g, auth: /\[Authorize|User\.Identity|IsInRole|AuthorizeAsync|\[AllowAnonymous|IAuthorizationService/, window: 2 },
     { framework: "rails", entry: /class\s+\w+\s*<\s*ApplicationController/g, auth: /before_action\s+:authenticate|before_action\s+:authorize|authenticate_user!|authorize\s+|current_user|authenticate/, window: 6 }
   ];
-  PUBLIC_ROUTE_RE = /['"`]\/?(?:(?:api|v1|v2|o|auth|adminapi)\/)?(?:register|login|logout|signup|signin|forgot-password|reset-password|health|healthz|ready|status|version|ping|static|public|assets|css|js|img|favicon|echo|config|docs|openapi|swagger|robots|sitemap|graphql|graphiql|query|upload|callback|webhook|home|index|root)[/'"?]|['"`]\/?['"`](?!["'`])/i;
+  PUBLIC_ROUTE_RE = /['"`]\/?(?:(?:api|v1|v2|o|auth|adminapi|system|internal)\/)?(?:register|login|logout|signup|signin|forgot-password|reset-password|health|healthz|ready|status|version|ping|static|public|assets|css|js|img|favicon|echo|config|docs|openapi|swagger|robots|sitemap|graphql|graphiql|query|upload|callback|webhook|home|index|root|jwks|well-known|openid-configuration|traces|logs|metrics)[/'"?]|['"`]\/?['"`](?!["'`])/i;
+  PUBLIC_SEGMENT_RE = /['"`][^'"`]*\/(?:version|health|healthz|ready|status|ping|jwks|openid-configuration|well-known|metrics|traces|logs|favicon|robots|sitemap)(?:[.\/'"?]|$)/i;
 });
 
 // src/complex-bugs.ts
@@ -16596,6 +16596,10 @@ function detectHardcodedSecret(code, file, out) {
       continue;
     if (qm && /^["'][^"']+["']\s*\+/.test(valueRaw))
       continue;
+    if (!qm && new RegExp(`${value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`).test(valueRaw))
+      continue;
+    if (!qm && /document\.|window\.|localStorage\.|sessionStorage\./.test(valueRaw))
+      continue;
     const ln = lineNo2(code, m.index);
     flaggedLines.add(ln);
     let sev = "high";
@@ -37015,6 +37019,9 @@ var CHAIN_ID_TO_ESCALATION = {
   xxe: "xxe_to_ssrf_and_file_read",
   deserialization: "deserialization_to_rce",
   jwt: "jwt_alg_confusion_forgery",
+  jwt_alg_confusion: "jwt_alg_confusion_forgery",
+  cache_deception: "cache_deception",
+  cache_poisoning: "cache_poisoning_xss",
   nosql_injection: "nosql_injection_to_data_theft",
   mass_assignment: "mass_assignment_to_admin_takeover",
   prototype_pollution: "prototype_pollution_to_rce",
@@ -60389,7 +60396,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). 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:
+` + "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). Two more web-class detectors: jwt_alg_confusion (a JWT verifier that dispatches on the token's alg header and accepts BOTH RS256 and HS256, with the HS256 HMAC secret derived from public/shared key material — CWE-347; the attacker sets alg=HS256 and signs with the public key to forge admin tokens) and cache_deception (a reverse proxy caching static-extension URLs with a cache key that omits the session cookie, over a session-authenticated backend — CWE-525; the victim's cached private response is re-fetched anonymously). TO TRY a jwt_alg_confusion hit: fetch the public key (/.well-known/jwks.json), forge an HS256 token signed with that public key, and confirm admin access. TO TRY a cache_deception hit: request an authenticated path with a static extension appended (.css/.js) and re-fetch it anonymously.\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."

package/intelligence/patterns.json

@@ -747,7 +747,7 @@
         "greedy backend route regex + static-extension passthrough"
       ],
       "chain_templates": [
-        "cache_poisoning_xss"
+        "cache_deception"
       ],
       "bypass_techniques": [
         "append a static extension to an authenticated path",

package/package.json

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