Jeden Skill in Manus ausführen
mit einem Klick

Jeden Skill in Manus mit einem Klick ausführen

path-solve

Sterne0

Forks0

Aktualisiert29. Mai 2026 um 02:51

Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.

Installation

Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.

In Manus ausführen

Quelle

allsmog

allsmog/kuzushi-security-plugin

GitHub-Repository öffnen Creator-Repositorys ansehen

Download

In Manus ausführen

Verwandte BerufeSOC

Basierend auf der SOC-Berufsklassifikation

SoftwareentwicklerInformatik- und Mathematikberufe·SOC 15-1252

SKILL.md

readonly

name	path-solve
description	Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.
context	fork
agent	path-solver
user-invocable	false

Path solve

Get past the guards that left a sink unreachable.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/path-solve-prepare.mjs" --target "<repo root>" (optionally --input '{"fingerprints":["<fp>"]}' to target specific findings). If it reports no-candidates, tell the user to run /verify first (it surfaces the inconclusive findings worth solving) and stop.
Read the prep's prepPath. For each candidate, extract the path predicate between the source and sink (tree_sitter:node_at parent chain + tree_sitter:query for branch conditions across the functions on the path, using graphContext), then solve it: concolic:z3_solve for numeric/string predicates, concolic:crosshair for Python, else reason the input out (LLM). Decide reachable + a concrete solvedInput, or list the blocking guard in unsolvedGuards.
Write the { candidates: [...] } bundle to the prep's draftPath, then run the assembleCommand — it validates and attaches a pathSolution block onto each finding (no verdict change).
Report, per finding: guards extracted, backend used, reachable?, the solved input (or blocking guard). Note /verify can turn a reachable solution into a confirmed trigger and /fuzz can seed the corpus from it.

When NOT to use

Before /verify has produced inconclusive / needs-trace findings (nothing hard-to-reach) — unless you pass explicit fingerprints.
To render the exploitability verdict — that's /verify; this produces reach evidence.
For reachability that needs real symbolic execution of allocator/heap state — out of scope; this solves input predicates only.

Rationalizations to Reject

"An input was found, so it's exploitable." → That's reachable evidence at the stated confidence, not a proof; /verify + /poc adjudicate. Don't inflate confidence.
"That guard looks hard — unreachable." → Try Z3/CrossHair and a concrete assignment first; only reachable:false when a guard is genuinely unsatisfiable, and name it.
"Skip the predicate, just guess a payload." → The path predicate is the deliverable; a bare guess is what /verify already couldn't produce.

Mehr aus diesem Repository

gleiches 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	path-solve
description	Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.
context	fork
agent	path-solver
user-invocable	false

Path solve

Get past the guards that left a sink unreachable.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/path-solve-prepare.mjs" --target "<repo root>" (optionally --input '{"fingerprints":["<fp>"]}' to target specific findings). If it reports no-candidates, tell the user to run /verify first (it surfaces the inconclusive findings worth solving) and stop.
Read the prep's prepPath. For each candidate, extract the path predicate between the source and sink (tree_sitter:node_at parent chain + tree_sitter:query for branch conditions across the functions on the path, using graphContext), then solve it: concolic:z3_solve for numeric/string predicates, concolic:crosshair for Python, else reason the input out (LLM). Decide reachable + a concrete solvedInput, or list the blocking guard in unsolvedGuards.
Write the { candidates: [...] } bundle to the prep's draftPath, then run the assembleCommand — it validates and attaches a pathSolution block onto each finding (no verdict change).
Report, per finding: guards extracted, backend used, reachable?, the solved input (or blocking guard). Note /verify can turn a reachable solution into a confirmed trigger and /fuzz can seed the corpus from it.

When NOT to use

Before /verify has produced inconclusive / needs-trace findings (nothing hard-to-reach) — unless you pass explicit fingerprints.
To render the exploitability verdict — that's /verify; this produces reach evidence.
For reachability that needs real symbolic execution of allocator/heap state — out of scope; this solves input predicates only.

Rationalizations to Reject

"An input was found, so it's exploitable." → That's reachable evidence at the stated confidence, not a proof; /verify + /poc adjudicate. Don't inflate confidence.
"That guard looks hard — unreachable." → Try Z3/CrossHair and a concrete assignment first; only reachable:false when a guard is genuinely unsatisfiable, and name it.
"Skip the predicate, just guess a payload." → The path predicate is the deliverable; a bare guess is what /verify already couldn't produce.