blitzstrike 1.0.46 → 1.0.47

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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/).
 
+## [1.0.47] — 2026-09-13
+
+### Added — Autonomous Security Engine (phase 7: adaptive planner)
+
+- **Adaptive Attack Planner** (`src/mission/planner.ts`, §11):
+  - `ATTACK_BRANCHES` — data-driven technique library across SSRF / LFI / SQLi /
+    RCE / XSS / IDOR / XXE / traversal (each with rationale, expected value,
+    risk, evidence requirements, and tool).
+  - `planNextActions()` — generates ranked next actions from unresolved
+    hypotheses (confidence × expected-value − risk), evidence-driven branching.
+  - `classifyType()` — maps hypothesis type strings to a technique class.
+- **Escalation Graph** (`buildEscalationGraph`, §12) — integrates the 57
+  escalation chains into the Security Graph (`vuln` → `enables` → `attack_chain`),
+  seeded into every mission's world model.
+- `@commander` now emits ranked `next_actions` from the adaptive planner.
+
 ## [1.0.46] — 2026-09-13
 
 ### Fixed (autonomous-engine milestone review)

package/dist/index.js

@@ -18139,6 +18139,124 @@ function mergeGraphs(a, b) {
   return out;
 }
 
+// src/mission/planner.ts
+function classifyType(type) {
+  const t = type.toLowerCase();
+  if (/ssrf|server-side request|url fetch/.test(t))
+    return "ssrf";
+  if (/lfi|include|local file/.test(t))
+    return "lfi";
+  if (/sql|query injection/.test(t))
+    return "sqli";
+  if (/command|exec|rce|deserializ|template|ssti/.test(t))
+    return "rce";
+  if (/xss|cross-site|reflected|stored|dom/.test(t))
+    return "xss";
+  if (/idor|authorization|object access|missing_authorization/.test(t))
+    return "idor";
+  if (/xxe|xml/.test(t))
+    return "xxe";
+  if (/traversal|path|directory/.test(t))
+    return "traversal";
+  return "xss";
+}
+function planNextActions(hypotheses, _mission) {
+  const actions = [];
+  for (const h of hypotheses) {
+    if (h.status !== "pending")
+      continue;
+    const cls = classifyType(h.type);
+    const branches = ATTACK_BRANCHES[cls] ?? [];
+    for (const b of branches) {
+      const score = h.confidence * 0.5 + VALUE_RANK[b.expected_value] * 0.3 - RISK_PENALTY[b.risk];
+      actions.push({
+        hypothesis_id: h.id,
+        hypothesis_type: h.type,
+        technique: b.technique,
+        rationale: b.rationale,
+        expected_value: b.expected_value,
+        risk: b.risk,
+        evidence_required: b.evidence_required,
+        tool: b.tool,
+        score: Number(score.toFixed(3))
+      });
+    }
+  }
+  return actions.sort((a, b) => b.score - a.score);
+}
+function buildEscalationGraph(chains, graph) {
+  let out = graph;
+  for (const chain of chains) {
+    const chainId = `chain:${chain.id}`;
+    out = upsertNode(out, chainId, "attack_chain", {
+      name: chain.name,
+      severity: chain.severity,
+      prerequisites: chain.required_findings ?? [],
+      steps: chain.steps.length,
+      tools: chain.tools ?? []
+    });
+    for (const rf of chain.required_findings ?? []) {
+      const prereqId = `vuln:${rf}`;
+      out = upsertNode(out, prereqId, "vulnerability", { class: rf });
+      out = addEdge2(out, prereqId, chainId, "enables");
+    }
+  }
+  return out;
+}
+function loadEscalationGraph(graph) {
+  return buildEscalationGraph(loadChains(), graph);
+}
+var ATTACK_BRANCHES, VALUE_RANK, RISK_PENALTY;
+var init_planner = __esm(() => {
+  init_orchestrator();
+  ATTACK_BRANCHES = {
+    ssrf: [
+      { technique: "probe localhost (127.0.0.1 / ::1)", rationale: "confirm server-side fetch of loopback", expected_value: "high", risk: "low", evidence_required: ["server-side fetch"], tool: "strike_verify" },
+      { technique: "probe internal services (10.0.0.0/8, 172.16/12, 192.168/16)", rationale: "map internal reachability", expected_value: "medium", risk: "low", evidence_required: ["server-side fetch"], tool: "strike_verify" },
+      { technique: "probe cloud metadata (169.254.169.254)", rationale: "exfiltrate IAM creds on cloud hosts", expected_value: "high", risk: "medium", evidence_required: ["cloud-hosted target"], tool: "strike_verify" },
+      { technique: "test redirect behavior (open redirect → SSRF)", rationale: "bypass URL allowlist via redirect", expected_value: "medium", risk: "low", evidence_required: ["redirect endpoint"], tool: "strike_verify" },
+      { technique: "test alternate protocol (gopher:// file:// dict://)", rationale: "escalate SSRF to file read / RCE", expected_value: "high", risk: "high", evidence_required: ["raw socket support"], tool: "strike_verify" }
+    ],
+    lfi: [
+      { technique: "read /etc/passwd", rationale: "confirm file read primitive", expected_value: "high", risk: "low", evidence_required: ["file include sink"], tool: "strike_verify" },
+      { technique: "read application logs", rationale: "harvest secrets/session data", expected_value: "medium", risk: "low", evidence_required: ["file include sink"], tool: "strike_verify" },
+      { technique: "read session files", rationale: "session hijack", expected_value: "high", risk: "medium", evidence_required: ["session path known"], tool: "strike_verify" },
+      { technique: "read upload locations", rationale: "chain to RCE via uploaded file", expected_value: "high", risk: "medium", evidence_required: ["upload path"], tool: "strike_verify" },
+      { technique: "test log poisoning / wrapper execution", rationale: "escalate LFI to RCE", expected_value: "high", risk: "high", evidence_required: ["writable log"], tool: "strike_verify" }
+    ],
+    sqli: [
+      { technique: "error-based extraction", rationale: "confirm SQLi via error leakage", expected_value: "high", risk: "low", evidence_required: ["query sink"], tool: "strike_verify" },
+      { technique: "UNION-based extraction", rationale: "dump columns/tables", expected_value: "high", risk: "medium", evidence_required: ["query sink"], tool: "strike_verify" },
+      { technique: "blind boolean extraction", rationale: "infer data without errors", expected_value: "medium", risk: "medium", evidence_required: ["query sink"], tool: "strike_verify" },
+      { technique: "time-based blind extraction", rationale: "infer data via timing", expected_value: "medium", risk: "medium", evidence_required: ["query sink"], tool: "strike_verify" }
+    ],
+    rce: [
+      { technique: "command injection (separators)", rationale: "chain to OS command execution", expected_value: "high", risk: "high", evidence_required: ["command sink"], tool: "strike_verify" },
+      { technique: "deserialization gadget chain", rationale: "POP chain to code execution", expected_value: "high", risk: "high", evidence_required: ["unserialize sink"], tool: "strike_verify" },
+      { technique: "template injection", rationale: "SSTI to code execution", expected_value: "high", risk: "high", evidence_required: ["template render sink"], tool: "strike_verify" }
+    ],
+    xss: [
+      { technique: "reflected XSS (marker reflection)", rationale: "confirm reflected script execution", expected_value: "high", risk: "low", evidence_required: ["reflection"], tool: "strike_verify" },
+      { technique: "stored XSS (persistence)", rationale: "confirm stored script execution", expected_value: "high", risk: "medium", evidence_required: ["persistence"], tool: "browser_validate" },
+      { technique: "DOM XSS (sink execution)", rationale: "confirm client-side sink", expected_value: "high", risk: "low", evidence_required: ["DOM sink"], tool: "browser_validate" }
+    ],
+    idor: [
+      { technique: "enumerate sequential object ids", rationale: "find adjacent objects", expected_value: "high", risk: "low", evidence_required: ["object id"], tool: "strike_verify" },
+      { technique: "cross-tenant object access", rationale: "break authorization boundary", expected_value: "high", risk: "medium", evidence_required: ["multi-tenant"], tool: "strike_verify" }
+    ],
+    xxe: [
+      { technique: "internal entity (file read)", rationale: "read local files via XXE", expected_value: "high", risk: "medium", evidence_required: ["XML parse sink"], tool: "strike_verify" },
+      { technique: "external entity (SSRF via XXE)", rationale: "chain XXE to SSRF", expected_value: "medium", risk: "medium", evidence_required: ["XML parse sink"], tool: "strike_verify" }
+    ],
+    traversal: [
+      { technique: "dot-dot-slash traversal", rationale: "escape web root", expected_value: "high", risk: "low", evidence_required: ["file path sink"], tool: "strike_verify" },
+      { technique: "encoded traversal (%2e%2e%2f)", rationale: "bypass naive filters", expected_value: "medium", risk: "low", evidence_required: ["file path sink"], tool: "strike_verify" }
+    ]
+  };
+  VALUE_RANK = { low: 0.3, medium: 0.6, high: 1 };
+  RISK_PENALTY = { low: 0, medium: 0.1, high: 0.2 };
+});
+
 // src/agents.ts
 import { readFileSync as readFileSync18 } from "node:fs";
 function emptyGraph() {
@@ -18156,6 +18274,7 @@ function agentFor(type) {
 }
 var reconAgent, webAgent, sourceAgent, analysisAgent, authAgent, validatorAgent, reviewerAgent, reporterAgent, mobileAgent, cloudAgent, commanderAgent, apiAgent, AGENTS;
 var init_agents = __esm(() => {
+  init_planner();
   init_orchestrator();
   init_scanner();
   init_eagle2();
@@ -18433,7 +18552,8 @@ ${m.hypotheses.map((h) => `- [${h.status}] ${h.type} @ ${h.target} (confidence $
       const prioritized = [...hypotheses].sort((a, b) => b.confidence - a.confidence).slice(0, 10).map((h) => h.id);
       const sinks = nodesOfType(ctx.mission.graph, "sink").length;
       const exposed = outgoing(ctx.mission.graph, `target:${ctx.mission.target}`).length;
-      return { ok: true, output: { prioritized, pending: hypotheses.length, sinks, exposed_edges: exposed }, hypotheses: [], graph: emptyGraph() };
+      const nextActions = planNextActions(ctx.mission.hypotheses, ctx.mission).slice(0, 10).map((a) => ({ technique: a.technique, type: a.hypothesis_type, tool: a.tool, score: a.score }));
+      return { ok: true, output: { prioritized, pending: hypotheses.length, sinks, exposed_edges: exposed, next_actions: nextActions }, hypotheses: [], graph: emptyGraph() };
     }
   };
   apiAgent = {
@@ -18535,6 +18655,7 @@ async function runMission(mission) {
   }
   let m = { ...mission, status: "running" };
   m.tasks = buildInitialTasks(m);
+  m.graph = loadEscalationGraph(m.graph);
   m = saveMission(m);
   const scope = m.scope.join(",");
   let iterations = 0;
@@ -18616,6 +18737,7 @@ var MODE_PROFILES;
 var init_control = __esm(() => {
   init_state();
   init_agents();
+  init_planner();
   MODE_PROFILES = {
     web: { agents: ["recon", "web", "api", "auth", "validator", "reviewer", "reporter"], verify: true, risk: "medium" },
     api: { agents: ["recon", "api", "auth", "validator", "reviewer", "reporter"], verify: true, risk: "medium" },

package/package.json

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