Run any Skill in Manus with one click

chain

Stars0

Forks0

UpdatedMay 29, 2026 at 02:51

Proactive attack-path engine. The chain-finder agent SEARCHES for ordered entry→…→asset attack paths where each step is enabled by a finding — composing even sub-threshold (candidate/lead) primitives into a critical chain — using the threat-model assets, attacker-reachable entry points, and the reachability graph. Records each path (ordered narrative + member fingerprints) in .kuzushi/chains.json and attaches a `chains` ref onto each member (status unchanged). Needs ≥2 live findings.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

allsmog

allsmog/kuzushi-security-plugin

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Information Security AnalystsComputer and Mathematical Occupations·SOC 15-1212

SKILL.md

readonly

name	chain
description	Proactive attack-path engine. The chain-finder agent SEARCHES for ordered entry→…→asset attack paths where each step is enabled by a finding — composing even sub-threshold (candidate/lead) primitives into a critical chain — using the threat-model assets, attacker-reachable entry points, and the reachability graph. Records each path (ordered narrative + member fingerprints) in .kuzushi/chains.json and attaches a `chains` ref onto each member (status unchanged). Needs ≥2 live findings.
context	fork
agent	chain-finder
user-invocable	false

Attack-path chaining

Findings are triaged independently; the highest-impact issues are often a path assembled from individually-unremarkable bugs (a low info-leak + a medium auth gap + a candidate SSRF ⇒ critical RCE). This searches for those paths — it doesn't just restate confirmed findings. Requires ≥2 live findings in .kuzushi/findings.json (run the hunts first); richer with a threat model + code-graph built (they supply the assets + reachability the search keys off).

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/chain-prepare.mjs" --target "<repo root>". If there are fewer than 2 live findings, tell the user to run more hunts and stop. Read prepPath — it carries the findings (incl. sub-threshold leads), the crown-jewel context.assets, the attacker-reachable context.entryPoints, and a context.reachability summary.
Search entry→asset paths (forward from entry points, backward from assets, meet in the middle) where each step is enabled by a finding; compose sub-threshold primitives where the composition is what makes it critical. Order members, name the data/control link between steps, and use each fingerprint verbatim. Write { chains: [...] } (with kind/entryPoint/asset) to draftPath. If nothing genuinely composes, write { "chains": [] } — don't force a chain.
Run the assembleCommand (finalize). It validates each chain (≥2 real members, ordered narrative ≥120 chars), escalates severity to at least the max member's (composed impact is never under-reported), writes .kuzushi/chains.json, and attaches a chains ref onto each member (status unchanged). Report the paths highest-impact first; /report renders them.

When NOT to use

Before ≥2 live findings exist — run /sweep / /threat-hunt / /taint-analysis first.
To discover new bugs — chaining only connects existing findings; name missing links as gaps.

Rationalizations to Reject

"All low/candidate — not worth chaining." → Composing sub-threshold primitives into a critical is the whole point; severity-gating the links misses the chains that matter most.
"Same bug class, so they chain." → A link needs one finding's effect to satisfy the next's precondition — name that edge or drop it. Co-occurrence ≠ composition.

More from this repository

same repository

deep-hunt

allsmog/kuzushi-security-plugin

Interprocedural, hypothesis-driven hunt — finds the multi-file source→sink bugs that pattern-gating and same-file taint miss. Ranks trace anchors (entry points + dangerous sinks), then the deep-hunter agent walks each flow ACROSS files (forward/backward call-graph CLIs) over multiple rounds, confirming propagation and defeating guards, and promotes confirmed cross-file flows into findings.json with the path stored as evidenceGraph. Token-expensive, budget-bounded. Part of the HUNT phase (run via /sweep --deep, or ask for it); leads flow to /verify (panel).

2026-06-110

deep-scan

allsmog/kuzushi-security-plugin

Whole-file deep reader — finds bugs by READING risk-ranked files in full and reasoning from first principles, not by grepping for known patterns. Catches the long tail (project-specific wrappers, business logic, cross-function flaws) that pattern-gated producers structurally miss. Token-expensive; budget-bounded and risk-ranked. Promotes leads into .kuzushi/findings.json (source "deep-scan").

2026-06-110

taint-analysis

allsmog/kuzushi-security-plugin

IRIS-style source→sink taint hunt. Ranks a typed CWE catalog for the repo, then drives subagents to label dangerous sinks, label sources of user input, run Joern/CodeQL dataflow queries (or same-file linking) to connect them, and triage each flow as finding/candidate/rejected. Promotes verdicts into .kuzushi/findings.json. Benefits from a prebuilt CodeQL DB / Joern CPG but degrades gracefully.

2026-06-110

threat-hunt

allsmog/kuzushi-security-plugin

Adversarial per-threat review (Carlini doctrine). For each threat in .kuzushi/threat-model.json, state attacker capabilities, walk source→sink, attempt to bypass every guard, and assign a verdict with evidence. Promotes findings into .kuzushi/findings.json. Requires /threat-model first.

2026-06-110

partition

allsmog/kuzushi-security-plugin

Split the attack surface into parallel-discovery partitions so fan-out hunters explore different subsystems instead of converging on the same shallow bug. Deterministic grouping of /x-ray entry points by component → .kuzushi/partitions.json, which a hunt coordinator hands to one subagent per partition. Run /x-ray first.

2026-06-100

poc

allsmog/kuzushi-security-plugin

Empirical proof-of-concept for the PoC-ready findings. For each finding /verify marked confirmed-exploitable or inconclusive, synthesize a minimal harness that triggers the bug; a host script then runs it in a sandbox (Docker --network none when present, else a gated local run) and classifies the crash into a proof verdict. Attaches a poc block onto each finding. Requires /verify first.

2026-06-100

name	chain
description	Proactive attack-path engine. The chain-finder agent SEARCHES for ordered entry→…→asset attack paths where each step is enabled by a finding — composing even sub-threshold (candidate/lead) primitives into a critical chain — using the threat-model assets, attacker-reachable entry points, and the reachability graph. Records each path (ordered narrative + member fingerprints) in .kuzushi/chains.json and attaches a `chains` ref onto each member (status unchanged). Needs ≥2 live findings.
context	fork
agent	chain-finder
user-invocable	false

Attack-path chaining

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/chain-prepare.mjs" --target "<repo root>". If there are fewer than 2 live findings, tell the user to run more hunts and stop. Read prepPath — it carries the findings (incl. sub-threshold leads), the crown-jewel context.assets, the attacker-reachable context.entryPoints, and a context.reachability summary.
Search entry→asset paths (forward from entry points, backward from assets, meet in the middle) where each step is enabled by a finding; compose sub-threshold primitives where the composition is what makes it critical. Order members, name the data/control link between steps, and use each fingerprint verbatim. Write { chains: [...] } (with kind/entryPoint/asset) to draftPath. If nothing genuinely composes, write { "chains": [] } — don't force a chain.
Run the assembleCommand (finalize). It validates each chain (≥2 real members, ordered narrative ≥120 chars), escalates severity to at least the max member's (composed impact is never under-reported), writes .kuzushi/chains.json, and attaches a chains ref onto each member (status unchanged). Report the paths highest-impact first; /report renders them.

When NOT to use

Before ≥2 live findings exist — run /sweep / /threat-hunt / /taint-analysis first.
To discover new bugs — chaining only connects existing findings; name missing links as gaps.

Rationalizations to Reject

"All low/candidate — not worth chaining." → Composing sub-threshold primitives into a critical is the whole point; severity-gating the links misses the chains that matter most.
"Same bug class, so they chain." → A link needs one finding's effect to satisfy the next's precondition — name that edge or drop it. Co-occurrence ≠ composition.