Skip to content
Back to search

blitzstrike

Blitz Strike — a universal MCP security-audit toolbelt. Reconnaissance at speed. Analysis in depth. Validation before report.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/shinthink--blitzstrike/badge.svg)](/listings/shinthink--blitzstrike)

HTML

<a href="/listings/shinthink--blitzstrike"><img src="/api/listings/shinthink--blitzstrike/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# Zero-install — works from any MCP client, no clone, no build
npx -y blitzstrike doctor        # verify the environment
npx -y blitzstrike install       # auto-register with every detected agent CLI

`npx blitzstrike install` detects every installed agent CLI (Claude Code, Cursor, OpenCode, Codex, Hermes, Gemini, Windsurf, Copilot, Cline) and writes the correct MCP config to each one in its native format. Restart your agent and call `run_engagement`.

From source:

git clone https://github.com/shinthink/blitzstrike.git
cd blitzstrike
bun install
bun run src/index.ts serve --mcp

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 444 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <a href="https://github.com/shinthink/blitzstrike"><img src="./.github/assets/banner.webp" alt="Blitz Strike" width="100%" /></a>
  3. [![GitHub Release](https://img.shields.io/github/v/release/shinthink/blitzstrike?color=369eff&labelColor=black&logo=github&style=flat-square)](https://github.com/shinthink/blitzstrike/releases)
  4. [![GitHub Stars](https://img.shields.io/github/stars/shinthink/blitzstrike?color=ffcb47&labelColor=black&style=flat-square)](https://github.com/shinthink/blitzstrike/stargazers)
  5. [![License](https://img.shields.io/badge/license-MIT-97CA00?labelColor=black&style=flat-square)](LICENSE)
  6. [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6?labelColor=black&logo=typescript&logoColor=white&style=flat-square)](https://www.typescriptlang.org/)
  7. [![Bun](https://img.shields.io/badge/Bun-1.4+-000000?labelColor=black&logo=bun&logoColor=white&style=flat-square)](https://bun.sh)
  8. [![MCP](https://img.shields.io/badge/MCP-SDK-6366f1?labelColor=black&style=flat-square)](https://modelcontextprotocol.io)
  9. </div>
  10. # Blitz Strike
  11. **Reconnaissance at speed. Analysis in depth. Validation before report.**
  12. Blitz Strike is a structured penetration-testing methodology — reconnaissance,
  13. source analysis, and validation — delivered as a universal MCP server. It
  14. enumerates the attack surface (BLITZ), traces source-to-sink reachability
  15. (EAGLE-EYE), and verifies each finding live before it is reported (STRIKE).
  16. One server, every agent: scope enforcement to submission-ready findings in a
  17. single `run_engagement` call, with the relevant exploit-tool manual attached to
  18. every result.
  19. > A scan hit is a **hypothesis**. A live test is the **verdict**.
  20. >
  21. > Blitz Strike exists to eliminate the two most common failure modes in
  22. > automated security assessment: false positives from surface-level pattern
  23. > matching, and unverified findings reported without live confirmation.
  24. ---
  25. ## What it does
  26. Blitz Strike is a Model Context Protocol (MCP) server (TypeScript / Bun) that
  27. packages a 3-tier security-audit methodology as callable tools — and runs the
  28. whole engagement **server-side**, so a single `run_engagement` call works from
  29. Claude Code, Cursor, Hermes, OpenCode, Claude Desktop, Gemini, or any MCP client.
  30. ### The three tiers
  31. Blitz Strike maps a structured penetration-testing methodology — reconnaissance,
  32. source analysis, and validation — into three tool tiers executed server-side.
  33. | Tier | Name | Phase | What it does |
  34. |---|---|---|---|
  35. | 1 | **BLITZ** | Reconnaissance & attack-surface mapping | Enumerates the exposed attack surface at scale: unauthenticated entry points, dangerous sinks, and authentication boundaries. |
  36. | 2 | **EAGLE-EYE** | Static analysis & data-flow tracing | Traces source-to-sink reachability and enriches findings against the escalation-chain graph. Confirms a sink is *reachable*, *unauthenticated*, and *exploitable* — not merely present. |
  37. | 3 | **STRIKE** | Validation & exploitation | Performs live verification (marker reflection + negative control), scope enforcement, and orchestration so a finding is confirmed before it is ever reported. |
  38. Reconnaissance → analysis → validation. Nothing is reported until STRIKE
  39. confirms it.
  40. Beyond the three tiers, Blitz Strike also ships **Web3 audit** (deterministic
  41. Solidity + executable Foundry proof), a **live logic-bug prober** (sibling
  42. enumeration + differential IDOR), **hunting intel** (CWE/CVE watchlist + DNS
  43. sinkhole detection), and **out-of-band proof** — so IDOR/auth logic bugs, blind
  44. injection, and smart-contract findings are all caught and proven, not just
  45. pattern-matched.
  46. ---
  47. ## Autonomous, LLM-driven
  48. Blitz Strike is driven by the LLM — Claude, Hermes, OpenCode, Codex, or any
  49. MCP client. **The LLM is the brain** (plans, routes, delegates, judges); **Blitz
  50. Strike is the deterministic hands + knowledge + guardrails**.
  51. A full engagement is one call, or a granular agent-orchestrated cycle:
  52. ```bash
  53. npx blitzstrike serve --mcp # connect your agent, then ask it to
  54. # "audit ./src" (source) or "audit https://example.com" (live)
  55. ```
  56. The LLM classifies the target automatically (URL → live pipeline, filesystem
  57. path → source pipeline), then drives recon → analyze → verify → review →
  58. report — guided by the bundled doctrine (`instructions` + skills + per-step
  59. `next_steps`) and fanned out across the platform's native sub-agents.
  60. → [Autonomy & doctrine](docs/AUTONOMY.md) — how the LLM is steered.
  61. ## Why TypeScript / Bun
  62. - **Single static binary** via `bun build --compile` — ship one executable per platform.
  63. - **Zero-install distribution** via `bunx blitzstrike` / `npx blitzstrike`.
  64. - **MCP TypeScript SDK** first-class (`@modelcontextprotocol/sdk`).
  65. - **One toolchain** for dev + test + build + compile.
  66. ---
  67. ## Quickstart (30 seconds)
  68. ```bash
  69. # Zero-install — works from any MCP client, no clone, no build
  70. npx -y blitzstrike doctor # verify the environment
  71. npx -y blitzstrike install # auto-register with every detected agent CLI
  72. ```
  73. `npx blitzstrike install` detects every installed agent CLI (Claude Code,
  74. Cursor, OpenCode, Codex, Hermes, Gemini, Windsurf, Copilot, Cline) and writes
  75. the correct MCP config to each one in its native format. Restart your agent and
  76. call `run_engagement`.
  77. From source:
  78. ```bash
  79. git clone https://github.com/shinthink/blitzstrike.git
  80. cd blitzstrike
  81. bun install
  82. bun run src/index.ts serve --mcp
  83. ```
  84. ---
  85. ## Client Configuration (works in any MCP client)
  86. ```json
  87. {
  88. "mcpServers": {
  89. "blitzstrike": {
  90. "command": "blitzstrike",
  91. "args": ["serve", "--mcp"]
  92. }
  93. }
  94. }
  95. ```
  96. - **Claude Code / Desktop**: `claude_desktop_config.json` or `.mcp.json`
  97. - **Cursor**: `.cursor/mcp.json`
  98. - **OpenCode**: `.mcp.json`
  99. - **Hermes**: `mcp_servers:` in `config.yaml`
  100. - **Gemini / Copilot**: native MCP config
  101. Run `blitzstrike install` to print the exact snippet.
  102. ---
  103. ## CLI
  104. ```bash
  105. blitzstrike serve --mcp # start MCP server over stdio (default)
  106. blitzstrike doctor # health check: runtime + 130-tool catalog + creds
  107. blitzstrike install # write MCP config to detected clients (Claude/Cursor/OpenCode)
  108. blitzstrike install --dry-run # preview the config without writing
  109. blitzstrike sync-data # fetch heavy datasets (payloads + templates) on-demand
  110. blitzstrike update # check for a newer version + refresh the data cache
  111. blitzstrike version # print version
  112. ```
  113. ### What doctor checks
  114. | Check | Status you'll see |
  115. |---|---|
  116. | Runtime (bun/node) | OK / FAIL + fix |
  117. | Security tools catalog | 63/130 installed, 67 on-demand |
  118. | FOFA credentials | OK / WARN + fix |
  119. | Data layers (chains + tools-catalog) | present / missing |
  120. Each issue carries a `fix:` line — no guessing.
  121. ### What install does
  122. `blitzstrike install` detects which MCP client config files already exist
  123. (Claude `~/.claude.json`, Cursor `~/.cursor/mcp.json`, project `.mcp.json`) and
  124. **merges** the Blitz Strike server entry in — it never overwrites your existing
  125. MCP servers. With no client detected, it prints the snippet for manual paste.
  126. ---
  127. ## Tools
  128. ### BLITZ — attack-surface triage
  129. | Tool | Purpose |
  130. |---|---|
  131. | `blitz_scan(path, max_files)` | Scan a source tree: enumerate unauth entry points + dangerous sinks with file:line refs. |
  132. | `blitz_file(path)` | Same scan, single file. |
  133. ### EAGLE-EYE — deep trace
  134. | Tool | Purpose |
  135. |---|---|
  136. | `eagle_eye(path, symbol)` | Return a function's full body, sinks in scope, and auth gates in scope. |
  137. | `eagle_grep(path, sink, max_hits)` | Precision sink grep — report a hit ONLY inside a function body, flagged guarded/un-guarded. |
  138. | `enrich_scan(path, max_files)` | Scan + match detected sinks to escalation chains (chains.json). |
  139. ### STRIKE — verify + recon + orchestrate
  140. | Tool | Purpose |
  141. |---|---|
  142. | `strike_verify(url, method, data, headers, marker, timeout)` | Live HTTP verification with marker + negative control + baseline. |
  143. | `strike_resolve(finding, verdict)` | Attach a live STRIKE verdict to a finding and advance its lifecycle. |
  144. | `scope_check(target, scope, mode)` | Enforce scope before active testing (no-DoS, exclusion-aware, mode-gated). |
  145. | `run_engagement(target, scope, mode, max_files)` | Full 3-tier audit in ONE call — scope gate → triage → chain enrichment → findings. |
  146. | `list_chains()` | List all escalation chains in the data layer. |
  147. | `fofa_search(query, size, fields)` | FOFA asset index search (needs `FOFA_EMAIL` + `FOFA_KEY`). |
  148. | `nvd_lookup(cve_id)` | CVE lookup from NVD 2.0 (no key required). |
  149. | `live_recon(url)` | Modular passive-first recon: fingerprint, WAF/tech/version, crawler, params, subdomains, Wayback, API discovery, port scan. |
  150. ### CATALOG — breadth layer (tools + skills knowledge base)
  151. | Tool | Purpose |
  152. |---|---|
  153. | `tool_lookup(name)` | Look up a tool's command + flags + install + check. |
  154. | `list_tools()` | List all catalog tools, grouped by category. |
  155. | `skill_lookup(topic)` | Search the skills/ playbook knowledge base by topic. |
  156. | `list_skills()` | List all skill playbooks. |
  157. | `read_skill(name)` | Read the full content of a playbook. |
  158. | `ensure_tool(name)` | Check if a tool is installed; if not, auto-install it. |
  159. ### MANUALS — deep tool reference + playbooks (wired into flow)
  160. | Tool | Purpose |
  161. |---|---|
  162. | `read_tool_manual(name)` | Read a full deep manual for a tool (317+ manuals). |
  163. | `list_manuals()` | List all manuals + playbooks. |
  164. | `read_playbook(name)` | Read an engagement playbook (web-app, api-security, AD, etc.). |
  165. | `list_playbooks()` | List all 17 engagement playbooks. |
  166. ### PHASE 4 — verification, measurement, reporting
  167. | Tool | Purpose |
  168. |---|---|
  169. | `cvss_score(AV, AC, PR, UI, S, C, I, A)` | Compute a deterministic CVSS v3.1 base score + vector + severity (self-computed, not read from NVD). |
  170. | `dedup_findings(findings)` | Collapse findings that share a root cause (sink × source × CWE) into one group per root cause. |
  171. | `generate_report(findings, format)` | Emit a reproducible markdown/JSON report with summary + SHA-256 integrity hash. |
  172. | `run_enterprise_benchmark()` | Run the labelled enterprise corpus and report detection rate, false-positive rate, and precision. |
  173. | `coverage_matrix()` | Enumerate language × sink-class coverage (5 languages) + coverage ratio. |
  174. ### EAGLE-EYE — taint + data-flow
  175. | Tool | Purpose |
  176. |---|---|
  177. | `taint_file(path)` | Inter-procedural taint analysis (PHP) — reachable, sanitized, authorized sinks. |
  178. | `taint_scan(code, language)` | Universal taint analysis (PHP/JS/TS/Python/Java) with source→sink tracing. |
  179. | `taint_tree(path)` | Taint propagation tree — how a source flows to a sink. |
  180. | `trace_data_flow(path)` | Window-based data-flow trace with sanitizer + auth-gate awareness. |
  181. | `variant_analysis(path)` | Group reachable sinks into variant families. |
  182. | `list_languages()` | List supported analysis languages + extensions. |
  183. ### INTELLIGENCE — data layer (WAF + correlations + fuzzer)
  184. | Tool | Purpose |
  185. |---|---|
  186. | `detect_waf(headers, body)` | Detect a WAF from response headers/body (139 signatures). |
  187. | `tech_correlation(tech)` | Correlate tech to known vulns + CVEs (89 technologies). |
  188. | `cve_correlation(cve)` | Correlate CVE to product + targets + severity (53 CVEs). |
  189. | `port_correlation(port)` | Correlate port to service + attack vectors (103 ports). |
  190. | `fuzzer_payloads(category)` | Fuzzing payloads + vulnerable patterns + chain rules. |
  191. | `intel_summary()` | Counts of every intelligence dataset. |
  192. | `payload_lookup(topic)` | Find exploit payloads (66 categories from PayloadsAllTheThings). |
  193. | `read_payload(category)` | Read a full payload collection. |
  194. | `template_lookup(topic)` | Find nuclei detection templates (11.9k YAML signatures). |
  195. | `list_attack_vectors()` | List the full web attack-vector taxonomy (34 categories, 588 vectors). |
  196. | `attack_vectors(category)` | Enumerate the vector list for one category (e.g. ssrf, business logic, ai/llm). |
  197. | `check_update()` | Query the npm registry for the latest blitzstrike version. |
  198. The intelligence layer (WAF signatures, tech/CVE/port correlations, fuzzer
  199. data, vuln ontology, exploit payloads, nuclei detection templates) is sourced
  200. from MIT-licensed public datasets, PayloadsAllTheThings (MIT), and nuclei-templates (MIT) —
  201. loaded at runtime and wired into the tool surface above. The attack-vector
  202. taxonomy (`intelligence/attack_vectors.json`) is first-party.
  203. 317 indexed tool manuals + 17 playbooks from kali-pentest (Apache-2.0) — 334
  204. manual files, 100% of the 130-tool catalog documented. These are NOT
  205. decoration — they are wired into the flow:
  206. - `tool_lookup(name)` auto-attaches the tool's full manual.
  207. - `run_engagement()` attaches the relevant manual per matched chain's `tools` field.
  208. ### WEB3 — smart-contract audit + proof
  209. | Tool | Purpose |
  210. |---|---|
  211. | `web3_audit(code, path)` | Deterministic Solidity audit — 13 bug classes (reentrancy incl. ERC721/ERC1155 callbacks, unchecked return/arithmetic, tx.origin auth, signature replay, selfdestruct, delegatecall, missing access control, timestamp dependence, spot-price oracle, unbounded loop, encodePacked collision, missing address(0) check) with CWE + severity + line refs. |
  212. | `foundry_poc(class, contract)` | Generate an executable Foundry test that PROVES a Web3 finding. |
  213. | `foundry_run(contract_code, poc_code, class_)` | Actually run the Foundry PoC (`forge test`) — a PASSING test = exploit reproduced (deterministic: forge's own verdict). |
  214. ### HUNTING — doctrine + live logic-bug prober + intel
  215. | Tool | Purpose |
  216. |---|---|
  217. | `hunting_doctrine()` | High-ROI heuristics — sibling rule, A→B signal, two-account IDOR, PoC escalation, follow-the-money + the always-rejected kill-list. |
  218. | `kill_list(type)` | Deterministic always-rejected check — missing headers, self-XSS, open-redirect-alone, SSRF-DNS-only, GraphQL-introspection-alone are N/A standalone. |
  219. | `sibling_scan(base_url, endpoint, token_a, token_b)` | Deterministic LIVE logic-bug prober — sibling enumeration + differential IDOR + auth matrix + mass assignment + rate limit (closes the static-analysis gap on IDOR/auth logic bugs). |
  220. | `auto_poc(type, base_url, endpoint, param)` | Turn a finding into a copy-paste-ready reproduction recipe (marker + negative control + expected differential + Patchstack-style title). |
  221. | `watchlist()` | Ranked CWE frequency + high-value CVE watchlist with payout + saturated flag — "what to hunt next". |
  222. | `resolve_check(host)` | Detect an ISP/country DNS sinkhole (blocking page) before auditing a sensitive-niche domain. |
  223. | `oob_start()` / `oob_poll(id)` / `oob_stop(id)` | Out-of-band proof — interactsh listener for blind SSRF/XXE/SQLi/command-injection (the canary must actually arrive). |
  224. ### MEMORY — long-term knowledge (self-growing)
  225. | Tool | Purpose |
  226. |---|---|
  227. | `remember(topic, content, type, tags, verified)` | Save a reusable insight (deduped). verified=true only if marker reflected + negative control inert. |
  228. | `memory_lookup(query)` | Search memory by topic/tag/content, scored. |
  229. | `memory_list()` | List all memory entries, grouped by type. |
  230. | `memory_forget(id)` | Remove a memory entry (append-only tombstone). |
  231. | `confidence_weights(...)` | Get or set the confidence-scoring weight factors. |
  232. | `finding_attach_evidence(finding, type, description, content)` | Attach a redacted + hashed evidence record to a finding. |
  233. Memory is append-only JSONL at `~/.blitzstrike/memory.jsonl` (override with
  234. `BLITZSTRIKE_HOME`). `run_engagement` auto-captures matched escalation chains
  235. as `pattern` entries (deduped by chain id), so the knowledge base grows with
  236. every engagement — no duplicate spam, and only `verified=true` entries are
  237. authoritative.
  238. ---
  239. ## Tools Catalog (tools-catalog.json)
  240. 130 self-written security tools (not copied from any project), each with command
  241. base, key flags, install command per platform, check_installed probe, phase,
  242. tags, alternatives, requires_root, pipes, and homepage.
  243. | Category | Count | Examples |
  244. |---|---|---|
  245. | recon | 23 | subfinder, amass, httpx, naabu, katana, trufflehog |
  246. | exploitation | 13 | sqlmap, commix, dalfox, hydra, hashcat, phpggc |
  247. | blue-team (defensive) | 13 | suricata, zeek, osquery, wazuh, sigma, yara, trivy |
  248. | reverse-engineering | 12 | ghidra, radare2, gdb, pwndbg, angr, binwalk |
  249. | enumeration | 11 | nuclei, ffuf, gobuster, arjun, wafw00f |
  250. | forensics | 10 | volatility3, autopsy, tshark, foremost, steghide |
  251. | active-directory | 8 | netexec, impacket, bloodhound, certipy, kerbrute |
  252. | mobile | 7 | frida, objection, mobsf, apktool, jadx |
  253. | post-exploitation | 6 | linpeas, pspy, chisel, ligolo-ng, pwncat |
  254. | red-team | 6 | sliver, havoc, metasploit, evilginx3, gophish |
  255. | utility | 6 | curl, jq, anew, notify |
  256. | web | 4 | wpscan, joomscan, droopescan, cmseek |
  257. | wireless | 4 | aircrack-ng, wifite, bettercap |
  258. | cloud | 4 | pacu, prowler, scoutsuite, cloudfox |
  259. | crypto | 3 | hashid, ciphey, rsactftool |
  260. ## Skills Knowledge Base (skills/)
  261. 32 skill playbooks (markdown) — universal, license-safe hidden gems from the
  262. internet (MIT). Our personal attack-tree playbooks were removed (they were
  263. private methodology, not universal exploit scripts).
  264. - **adversary-playbook (14, MIT)** — `ap-*` prefix. Rare offensive playbooks:
  265. cross-forest-trust-abuse, gitea-ci-injection, kerberos-trust-abuse,
  266. multi-domain-ad-attacks, client-side-crypto-forgery.
  267. - **hack.proof (18, MIT)** — `hp-*` prefix. End-to-end audit playbooks:
  268. full-security-audit, smart-contract-audit, api-security-test, sast-code-review,
  269. container-image-scan, iac-cloud-posture.
  270. See `ATTRIBUTION.md` for full license/copyright notices.
  271. ---
  272. ## Escalation Chains (chains.json)
  273. 58 data-driven escalation chains, each with ordered steps carrying:
  274. - `tool_hint` — which Blitz Strike tool to use
  275. - `success_criteria` — binary observable for the step
  276. - `invariant_check` — the assumption that MUST hold for exploitation
  277. - `negative_control` — how to refute the finding
  278. Examples: `ssrf_cloud_metadata`, `lfi_log_poison_rce`, `appkey_leak_deserialization_rce`,
  279. `hmac_empty_key_forgery`, `intval_form_id_bypass`, `extract_variable_injection_lfi`,
  280. `split_controller_upload_bypass`, `race_condition_double_spend`, `ssti_template_injection_rce`,
  281. `jwt_alg_confusion_forgery`, `cache_poisoning_xss`, `subdomain_takeover`, and more.
  282. Edit `chains.json` to add knowledge — never hardcode in source.
  283. ---
  284. ## Environment Variables
  285. | Variable | Required | Purpose |
  286. |---|---|---|
  287. | `FOFA_EMAIL` | For `fofa_search` | FOFA account email |
  288. | `FOFA_KEY` | For `fofa_search` | FOFA API key |
  289. | `H1_USERNAME` | Optional | Your HackerOne username. When set, every outbound security-testing request carries `X-HackerOne-Research: <username>` so targets/triagers can identify you (responsible-disclosure convention). |
  290. | `BLITZSTRIKE_HOME` | Optional | Override the home directory (default `~/.blitzstrike`). |
  291. | `BLITZSTRIKE_DATA` | Optional | Override the data-cache directory (default `~/.blitzstrike/data`). |
  292. All other tools need no credentials.
  293. ---
  294. ## Build
  295. ```bash
  296. bun install # deps
  297. bun run typecheck # tsc --noEmit
  298. bun run build # ESM bundle → dist/index.js
  299. bun run test # regression + benchmark suite (453 checks)
  300. bun run compile # single static binary → dist/blitzstrike
  301. ```
  302. ---
  303. ## Quality (measured, not claimed)
  304. Blitz Strike carries a benchmark suite and a coverage matrix so quality is a
  305. number you can re-run, not a claim.
  306. - **Benchmark** (`run_enterprise_benchmark`) — a labelled corpus of vulnerable +
  307. safe fixtures across PHP, JavaScript, Python, and Java. Current result:
  308. detection rate **1.0**, false-positive rate **0**, precision **1.0**.
  309. - **Coverage matrix** (`coverage_matrix`) — 5 languages × sink classes = 84%
  310. coverage (php, javascript, python, java, rust). Uncovered pairs are
  311. legitimately absent from the language (e.g. Java has no `eval`, Python/Java no
  312. PHP-style file inclusion, JS no deserialization sink).
  313. - **Attack-vector taxonomy** (`list_attack_vectors` / `attack_vectors`) — a
  314. master reference of 34 attack-vector categories (588 vectors) so a driving
  315. agent can map the *entire* attack surface, not just the obvious sinks.
  316. - **Regression suite** — `bun run test` runs 453 checks covering finding
  317. lifecycle, evidence integrity, CVSS math, taint tracing, dedup, report
  318. integrity, and benchmark invariants. CI runs it on every push.
  319. ---
  320. ## Methodology Notes
  321. - **Sink ≠ vuln.** A dangerous function in the same *file* as an unauth handler does not mean the handler calls it. Use `eagle_eye` to confirm scope.
  322. - **File write ≠ RCE (CF-003).** A writable file must be *loaded by the runtime* to be execution.
  323. - **Default server config only.** Default Apache `FilesMatch .+\.ph(ar|p|tml)$` has a `$` anchor — `.php.jpg` does not execute.
  324. - **Every finding is a HYPOTHESIS** until `strike_verify` reflects your marker AND the chain's `negative_control` stays inert.
  325. ---
  326. ## Disclaimer
  327. This tool is provided for educational and authorized security research only.
  328. Do not use against systems without explicit permission from the owner.
  329. ---
  330. ## Further Reading
  331. - [Installation](docs/installation.md) — prerequisites, install, client registration.
  332. - [Usage](docs/usage.md) — one-call engagement, granular path, modes, memory.
  333. - [Autonomy & doctrine](docs/AUTONOMY.md) — LLM-driven autonomy, resource map, guardrails.
  334. - [Manifesto](docs/manifesto.md) — the invariants that drive the methodology.
  335. - [Contributing](CONTRIBUTING.md) — how to add chains, tools, and data.
  336. - [Changelog](CHANGELOG.md) — version history.
  337. - [Roadmap](ROADMAP.md) — where this is headed.
  338. - [Security](SECURITY.md) — responsible disclosure + authorized use.
  339. - [Third-Party Notices](THIRD-PARTY-NOTICES.md) — vendored data licenses.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.