blitzstrike

BLITZ: scan a source tree for unauth entry points + dangerous sinks with file:line refs.

BLITZ: scan a single source file for entry points + sinks.

EAGLE-EYE: return a function's full body, sinks in scope, and auth gates in scope.

EAGLE-EYE: report a sink ONLY inside a function body, flagged guarded/un-guarded (anti-grep-monkey).

Scan a source tree AND match detected sinks to escalation chains (chains.json).

STRIKE+FINDINGS: take a canonical Finding and a STRIKE verdict, and advance the lifecycle end-to-end — hypothesis->validating->confirmed (marker reflected, control inert) or ->false_positive/blocked/unconfirmed. Returns the updated finding with evidence + recomputed confidence.

EAGLE-EYE: scan ARBITRARY leaked text (a 500 traceback, a debug page, a source dump, a config file, an error message, a credential dump) for dangerous sinks — eval/exec/os.system (RCE), render_template_string (SSTI), SQL string-building, requests.get (SSRF), file read (LFI), SECRET_KEY/API keys, har…

CREDENTIAL: when you dump password hashes, EXECUTE this instead of leaving 'crack the hashes' as a recommendation. Identifies the hash type (bcrypt/md5/sha1/sha256/sha512/ntlm) and immediately tries a built-in common-password list offline, then returns the exact hashcat/john command for the full cra…

STRIKE: classify a target against scope (intel for the report — not a gate). Exclusion-aware, mode-aware.

STRIKE: live black-box scan of a URL — fingerprint, WAF detection, tech correlation, endpoint discovery. No authorization gate (the repo disclaimer covers responsibility).

STRIKE: the DEFAULT first call when the user asks to test / scan / audit / engagement / pentest a URL or source path. Runs the whole audit in ONE call (no babysitting): source path -> triage -> chain enrichment -> findings -> inline report (markdown+JSON+SARIF); URL -> full autonomous live pipeline …

ORCHESTRATION: like run_engagement but the escalation path is pre-attached to every finding (chain name/severity/prerequisites + ordered next_steps with action + tool_hint + success_criteria + negative_control). Use when the user asks to test / scan / audit a target and you want the 'what to do next…

Format a terminal-friendly live progress snapshot of the running engagement — current stage (of the scope→recon→analyze→verify→review→report pipeline), finding counts, and task status. Call it to announce progress to the user as you drive the audit.

STRIKE: list all escalation chains in the data layer (chains.json).

STRIKE: search the FOFA asset index (needs FOFA_EMAIL + FOFA_KEY).

STRIKE: look up a CVE from NVD 2.0 (no key required).

Look up a tool in tools-catalog.json (command + flags + install + check).

List all tools in the catalog, grouped by category.

Search the skills/ knowledge base for a relevant playbook by topic.

List all skill playbooks in the knowledge base.

Read the full content of a skill playbook by name.

Check if a catalog tool is installed; if not, install it (auto-install).

Save a reusable insight to long-term memory (deduped). verified=true only if marker reflected + negative control inert.

Search memory by topic/tag/content, scored by relevance.

List all memory entries, grouped by type.

MEMORY: remove a memory entry by id (append-only store; 'forget' = tombstone).

Read the full deep reference manual for a security tool (317 manuals from kali-pentest, Apache-2.0).

List all tool manuals and playbooks available.

Read a full engagement playbook (web-app, api-security, active-directory, forensics-triage, etc.).

List all engagement playbooks available.

INTEL: detect a WAF from HTTP response headers/body (100+ signatures).

INTEL: given a technology, return known vulns + CVEs + paths.

INTEL: given a CVE, return product + affected targets + severity.

INTEL: given a port, return service + attack vectors (103 ports).

INTEL: fuzzing payload collections + vulnerable patterns + chain rules.

INTEL: counts of WAF sigs, tech/CVE/port correlations, fuzzer categories, and attack vectors.

BLITZ: list the full web attack-vector taxonomy (34 categories, 588 vectors) grouped by category, for attack-surface mapping.

BLITZ: return the full vector list for one attack category (e.g. 'ssrf', 'business logic', 'ai/llm') so a driving agent covers the whole attack surface.

DECISION: return the prioritized attack-vector plan for a target — the vectors to test (injection vectors always listed, then param/tech hints add + reprioritize), each with a reason and the specific tool. Call this AFTER run_engagement recon to decide what to test next with data instead of guessing…

INTEL: find a payload collection (66 categories from PayloadsAllTheThings).

INTEL: return bypass techniques for a defense that is blocking a probe. Pass a defense/context (waf, firewall, filter, sanitizer, blacklist, 403/401, auth, captcha, rate limit) and get concrete techniques (encoding, case, comment insertion, chunked, null byte, double-encoding, verb tampering, header…

INTEL: return how escalation chains compose — which chain naturally follows another (e.g. SSRF->cloud-metadata then default-creds->internal-pivot via stolen IAM). Use it after confirming a chain to see what a complex bug chains into next, instead of stopping at one chain.

INTEL: return structured recovery actions for a failure mode instead of giving up. Pass a signal (empty output, blocked, sanitized, subagent failed, model failed/rate-limit, unconfirmed, low severity) and get concrete next actions (reload-mcp, escalate detector, bypass_lookup, challenge sanitizer, r…

INTEL: return the orchestration framework — the engagement lifecycle (scope→recon→analyze→deep→verify→report, each with entry/exit criteria), the sub-agent team (roles + tools + returns), the handoff contract, and the termination criteria. Load this at engagement start; pass a phase/role id (scope, …

ORCHESTRATION: classify a model or sub-agent failure and decide the recovery. Pass the error text (rate limit / 429 / quota / context length / timeout / 500 / auth / connection / unavailable / aborted) and get the error class, whether it is retryable, whether to back off, the per-class action (retry…

ORCHESTRATION: return the interconnected doctrine map — each phase (scope→recon→analyze→deep→verify→report) with its skill, OWASP WSTG category, tools, and data; plus the cross-cutting moments (blocked→bypass_lookup, finding→list_chains/chain_links, probe→payload_lookup, failed→model_fallback/retry_…

INTEL: map an OWASP WSTG category (WSTG-INFO, WSTG-INPV, WSTG-BUSL, WSTG-CLNT, WSTG-APIT, ...) to the Blitz Strike skill, phase, tools, and data that covers it, including the high-value advanced tests where Blitz has a specific deterministic capability. Use to ground the engagement in the official f…

INTEL: return the DETAILED methodology + tricks for one vulnerability class (52 classes: ssrf, request smuggling, cache poisoning, race conditions, ssti, deserialization, prototype pollution, mass assignment, sql/nosql injection, xss, cors, csrf, jwt, oauth, host header, open redirect, subdomain tak…

INTEL: return framework-specific exploitation knowledge for a framework (Laravel, Django, Flask, Node/Express, Next.js, Vue, Angular, WordPress, Joomla, Spring, JSP, Python, Go, Ruby/Rails, Perl, GraphQL) — detection signals, known vulns/CVEs, and concrete attack tricks. Use after detect_framework t…

INTEL: return the FULL curated security resource index (78 entries, 44 domains — every entry from the community Awesome-Hacking meta-list: web, api, pentest, recon, payload, cve, privesc, source, fuzzing, llm, framework, osint, rev, cracking, forensics, malware, ir, intel, cicd, devsecops, defense, …

INTEL: return standard taxonomy for grounding + professional reporting. taxonomy(web) = OWASP Top 10 (2021); taxonomy(api) = OWASP API Security Top 10 (2023); taxonomy(cwe, query) = CWE ID for a technique class; taxonomy(asvs) = ASVS verification chapters. Each maps to Blitz Strike coverage. Use to …

ORCHESTRATION: open an engagement and track its state. Call at the start of a full audit so subsequent engagement_phase / engagement_track / engagement_status calls have a state to update. The LLM is the brain; this is the deterministic bookkeeping hand.

ORCHESTRATION: move the engagement to the next lifecycle phase (scope, recon, analyze, deep, verify, report). The phase tracks where the audit is; engagement_status uses it for the termination check.

ORCHESTRATION: record a hypothesis (a candidate finding keyed by its sink) with its status — pending, confirmed, or rejected. engagement_status derives the termination check from these; an untracked hypothesis is one the LLM has to remember, which is exactly what this avoids.

ORCHESTRATION: return the current engagement state — phase, hypotheses, counts — and a deterministic termination check (done or the exact unmet criteria). Call this instead of asking yourself 'am I done?'. Also drives blitz_status-style progress.

ORCHESTRATION: generate the deterministic engagement plan (phase order, tool per phase, evidence required, risk, permission) for a target + mode. This is the planning pass (like a planning sub-agent) — call ONCE at the start, then execute without re-planning.

ORCHESTRATION: decompose a workstream list into parallel-first dispatch batches (named dependencies only) + the retry pattern. Fire every batch in ONE message; sequential is the exception. Returns batches so the LLM dispatches without re-deriving the dependency graph.

ORCHESTRATION: register a delegated workstream with an ordered plan (steps). Every step records a checkpoint so a failed workstream can be RESUMED from its last completed step instead of restarting. On-disk, so checkpoints survive restarts.

ORCHESTRATION: record a checkpoint for a task step (in_progress / done / failed / blocked) with an optional note + output hash. Advancing 'done' moves current_step forward; a 'failed' checkpoint marks the task for resume.

ORCHESTRATION: read a task's current state — status, current step, progress (done/total), remaining steps, and full checkpoint history. The orchestrator's deterministic view of where each workstream is.

ORCHESTRATION: compute the resume instruction for a failed/blocked task — the last completed checkpoint, the current step, the remaining steps, and the exact re-dispatch prompt (resume from where it stopped, not a fresh start).

ORCHESTRATION: create/list/remove an isolated git worktree so parallel workstreams don't conflict on the same files. add: `git worktree add -b <branch> <path>`; list: enumerate existing; remove: clean up after a workstream.

ORCHESTRATION: detect a stalled phase — no progress (idle > 15 min, no hypotheses). Returns STALLED / PROGRESSING / IDLE plus the concrete intervention so the LLM unblocks instead of looping.

ORCHESTRATION: produce a compact summary (phase, confirmed/pending/rejected counts, top findings) so the LLM can DROP raw detail from its context and keep only this. The engagement tracker is the source of truth — re-read it instead of relying on memory.

INTEL: read the full payload collection for a category (or a specific file).

INTEL: find nuclei YAML templates matching a CVE/tech/topic (11.9k templates).

FINDINGS: create a canonical, evidence-first finding. Severity describes impact; confidence (deterministic) describes certainty. Default status=detected (hypothesis-pending).

FINDINGS: advance a finding through its strict lifecycle (detected->triaged->hypothesis->validating->confirmed). Rejects illegal transitions.

FINDINGS: compute a deterministic weighted confidence score (static/data-flow/reachability/preconditions/validation/negative-control). Never an AI opinion.

FINDINGS: inspect or override the deterministic confidence weights (configurable per the framework spec). Pass `set` (JSON object of weight overrides) to change them; omit to read the current weights.

FINDINGS: attach a redacted, SHA-256-tagged evidence record to an existing canonical finding (without advancing its lifecycle).

EVIDENCE: redact passwords/API keys/tokens/cookies/private keys from text before persisting evidence or reporting.

EAGLE-EYE: trace data flow in a file — classify sources, sinks, sanitizers, and authorization gates. Returns candidates (reachable+unsanitized), sanitized (not findings), and authorized (lower priority).

EAGLE-EYE: variant analysis — group data-flow candidates by root cause (sink category + source), deduplicating identical patterns across files.

EAGLE-EYE: real taint tracking — variable assignment, cross-function flow, and sanitizer awareness. Finds tainted data reaching sinks even across function boundaries.

EAGLE-EYE 2.0: whole-program data-flow on a PHP AST — call-graph-aware interprocedural taint with return propagation, by-reference alias tracking, ternary/conditional merge, context-sensitive sanitizers, and authorization-gate detection. Prefer this over taint_scan for accurate cross-function reacha…

Route confusion (separate class from source→sink taint): detect attacker-controlled dispatch (call_user_func/forward/dispatch), dynamic method calls ($obj->$m()), dynamic include (LFI), batch/proxy forwarding without per-route auth re-check, and route matching without path normalization.

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)…

PHASE 4: compare two versions of code (files or a git commit range) and surface only security-sensitive changes — new vulnerabilities, fixed vulnerabilities, new sinks/sources, removed sanitizers, and removed authorization gates.

EAGLE-EYE: analyze only the files changed between two git refs (default HEAD~1..HEAD) — the fast CI pass. Runs the taint + data-flow engine on just the changed source files and skips unchanged ones; the full-scan path (run_engagement / enrich_scan) remains authoritative.

PHASE 5: list the web frameworks Blitz Strike understands for framework-aware security analysis (Laravel, WordPress, Express, Next.js, Django, FastAPI, Spring).

PHASE 5: detect the web framework used by a source file (reads the file, then scores each framework's detection signals for the file's language).

PHASE 5: return a framework's security knowledge (sources, sinks, sanitizers, auth gates, routing, ORM, middleware) and optionally scan code with those patterns.

PHASE 6: validate a static-analysis HYPOTHESIS by driving a real headless Chromium. Checks: dom_xss, open_redirect, auth_bypass, csrf. Use only when necessary — to confirm a hypothesis with browser evidence, not as a first-pass scan. Requires playwright-core (optional peer dependency).

PHASE 12: drive a real headless-Chromium session. Ops: open, navigate, click, type, evaluate, screenshot, back, forward, get_cookie, set_cookie, plus detect_auth_form, diagnostics, close. Enables multi-step flows (login/MFA) and DOM issue detection. Requires playwright-core (optional peer dependency…

EAGLE-EYE: run inter-procedural taint analysis across an entire source tree.

CVSS: compute a deterministic CVSS v3.1 base score + vector + severity from metric values (AV/AC/PR/UI/S/C/I/A). Self-computed, not read from NVD.

FINDINGS: collapse a list of findings that share a root cause (sink type + source type + CWE) into one group per root cause.

REPORT: emit a deterministic markdown (or JSON) report from canonical Findings, with summary + integrity hash. Reproducible: same findings -> byte-identical output.

BENCHMARK: run the labelled corpus and report detection rate, false-positive rate, and precision. The quality metric, not the tool count.

BENCHMARK: enumerate language × sink-class coverage (which languages detect which sink types), plus the coverage ratio.

BENCHMARK: run the deterministic detectors (taint + route-confusion + complex-bugs) against realistic framework fixtures (Laravel/Express/Django/Spring + batch-route + complex-bugs) and report per-fixture recall.

UPDATE: query the npm registry for the latest blitzstrike version. Tells a driving agent whether the package or the data cache is stale.