blitzstrike 1.0.46 → 1.0.48

package/CHANGELOG.md

@@ -5,6 +5,40 @@ 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.48] — 2026-09-13
+
+### Added — Autonomous Security Engine (phase 8: coverage-driven scheduler)
+
+- **Coverage-driven Scheduler** (`src/mission/coverage.ts`, §13):
+  - `computeCoverage()` — 10 dimensions (attack surface, endpoints, technologies,
+    source files, sink classes, auth/authorization boundaries, vulnerability
+    classes, attack vectors, escalation chains).
+  - `coverageGaps()` — dimensions below a threshold.
+  - `scheduleCoverageTasks()` — auto-generates tasks for under-covered
+    dimensions, skipping already-attempted agents and mode-inappropriate ones
+    (e.g. no `@web` for source audits; endpoints/technologies resolve locally).
+  - `gapAgent()` — mode-aware dimension→agent mapping.
+- Mission Control's `replan` now runs the coverage scheduler and persists
+  per-dimension coverage into `mission.coverage.dimensions`.
+- `@recon` now links discovered endpoints into the Security Graph (so coverage
+  reflects real endpoint exploration).
+
+## [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();
@@ -18182,11 +18301,18 @@ var init_agents = __esm(() => {
         };
       }
       const r = enrichScan(ctx.mission.target, 500);
+      let graph = { nodes: [], edges: [] };
+      const tid = `target:${ctx.mission.target}`;
+      for (const ep of r.hits.filter((h) => h.type === "endpoint").slice(0, 50)) {
+        const epId = `endpoint:${ep.file}:${ep.line}`;
+        graph = upsertNode(graph, epId, "endpoint", { file: ep.file, line: ep.line, hook: ep.detail });
+        graph = addEdge2(graph, tid, epId, "exposes");
+      }
       return {
         ok: true,
         output: { files_scanned: r.files_scanned, hits: r.hits.length, sink_signals: r.sink_signals, endpoints: r.hits.filter((h) => h.type === "endpoint").length },
         hypotheses: [],
-        graph: emptyGraph()
+        graph
       };
     }
   };
@@ -18433,7 +18559,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 = {
@@ -18462,6 +18589,71 @@ ${m.hypotheses.map((h) => `- [${h.status}] ${h.type} @ ${h.target} (confidence $
   };
 });
 
+// src/mission/coverage.ts
+function clamp012(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function computeCoverage(mission) {
+  const byType = graphStats(mission.graph).by_type;
+  const hyps = mission.hypotheses;
+  const sinkCategories = new Set(mission.graph.nodes.filter((n) => n.type === "sink").map((n) => String(n.properties.category ?? n.properties.sink ?? "unknown")));
+  const hypTypes = new Set(hyps.map((h) => h.type));
+  return {
+    attack_surface: clamp012(mission.graph.nodes.length / 25),
+    endpoints: clamp012((byType.endpoint ?? 0) / 10),
+    technologies: clamp012(mission.technologies.length / 6),
+    source_files: clamp012((byType.sink ?? 0) / 15),
+    sink_classes: clamp012(sinkCategories.size / 10),
+    auth_boundaries: hyps.length ? clamp012(hyps.filter((h) => /auth/i.test(h.evidence)).length / hyps.length) : 0,
+    authorization_boundaries: hyps.length ? clamp012(hyps.filter((h) => /missing_authorization/i.test(h.type)).length / hyps.length) : 0,
+    vulnerability_classes: clamp012(hypTypes.size / 10),
+    attack_vectors: clamp012(planNextActions(hyps, mission).length / 20),
+    escalation_chains: clamp012((byType.attack_chain ?? 0) / 57)
+  };
+}
+function coverageGaps(coverage, threshold = 0.5) {
+  return Object.entries(coverage).filter(([, v]) => v < threshold).map(([k]) => k);
+}
+function gapAgent(dimension, isUrl) {
+  if (dimension === "endpoints" && !isUrl)
+    return "recon";
+  if (dimension === "technologies" && !isUrl)
+    return "source";
+  return GAP_AGENT[dimension] ?? "analysis";
+}
+function scheduleCoverageTasks(mission, threshold = 0.5) {
+  const coverage = computeCoverage(mission);
+  const gaps = coverageGaps(coverage, threshold);
+  const attempted = new Set(mission.tasks.map((t) => t.agent_type));
+  const isUrl = /^https?:\/\//i.test(mission.target);
+  const tasks = [];
+  for (const gap of gaps) {
+    const agent = gapAgent(gap, isUrl);
+    if (attempted.has(agent))
+      continue;
+    if (!isUrl && agent === "web")
+      continue;
+    tasks.push(createTask({ objective: `close coverage gap: ${gap} (${coverage[gap].toFixed(2)})`, agent_type: agent, priority: 8 }));
+  }
+  return tasks;
+}
+var GAP_AGENT;
+var init_coverage = __esm(() => {
+  init_planner();
+  GAP_AGENT = {
+    attack_surface: "recon",
+    endpoints: "api",
+    technologies: "web",
+    source_files: "source",
+    sink_classes: "source",
+    auth_boundaries: "auth",
+    authorization_boundaries: "auth",
+    vulnerability_classes: "analysis",
+    attack_vectors: "analysis",
+    escalation_chains: "commander"
+  };
+});
+
 // src/mission/control.ts
 import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
 function scopeAllowed(mission) {
@@ -18514,7 +18706,12 @@ function replan(mission) {
       tasks = [...tasks, createTask({ objective: "generate the final report", agent_type: "reporter", risk: "low" })];
     }
   }
-  return { ...mission, tasks };
+  const coverage = computeCoverage(mission);
+  const coverageTasks = scheduleCoverageTasks(mission);
+  if (coverageTasks.length > 0) {
+    tasks = [...tasks, ...coverageTasks];
+  }
+  return { ...mission, tasks, coverage: { dimensions: { ...mission.coverage.dimensions, ...coverage } } };
 }
 async function executeTask(task, mission, scope) {
   const agent = agentFor(task.agent_type);
@@ -18535,6 +18732,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 +18814,8 @@ var MODE_PROFILES;
 var init_control = __esm(() => {
   init_state();
   init_agents();
+  init_planner();
+  init_coverage();
   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.48",
   "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": {