Exécutez n'importe quel Skill dans Manus
en un clic

Exécutez n'importe quel Skill dans Manus en un clic

rule-synth

Étoiles0

Forks0

Mis à jour29 mai 2026 à 02:51

Synthesize CodeQL queries / Joern scripts from confirmed findings — the heavy semantic engines /semgrep-rule (Semgrep-only) doesn't cover. The rule-synthesist agent writes a tight rule per seed; the host runs a native compile → fire-on-seed → repo-run → precision gate and persists only validated rules into a digest-attested pack under .kuzushi/rules/{codeql,joern}/, promoting new matches as candidate leads. Needs a confirmed finding + a built CodeQL DB / Joern CPG.

Installation

Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.

Exécuter dans Manus

Source

allsmog

allsmog/kuzushi-security-plugin

Ouvrir le dépôt GitHub Voir les dépôts du créateur

Téléchargement

Exécuter dans Manus

Métiers associésSOC

Basé sur la classification professionnelle SOC

Développeurs de logicielsProfessions informatiques et mathématiques·SOC 15-1252

SKILL.md

readonly

name	rule-synth
description	Synthesize CodeQL queries / Joern scripts from confirmed findings — the heavy semantic engines /semgrep-rule (Semgrep-only) doesn't cover. The rule-synthesist agent writes a tight rule per seed; the host runs a native compile → fire-on-seed → repo-run → precision gate and persists only validated rules into a digest-attested pack under .kuzushi/rules/{codeql,joern}/, promoting new matches as candidate leads. Needs a confirmed finding + a built CodeQL DB / Joern CPG.
context	fork
agent	rule-synthesist
user-invocable	false

Rule synthesis (CodeQL / Joern)

Lift a confirmed finding into a validated, reusable semantic detection rule for CodeQL/Joern — complementary to /semgrep-rule (which covers Semgrep). Accepted rules land in a digest-attested pack (.kuzushi/rules/{codeql,joern}/ + pack.json); the codeql/joern MCP servers refuse to run a pack query whose bytes don't match the manifest, so generated queries are validated before they execute.

Requires: a confirmed/proven/exploitable finding in findings.json, and a built CodeQL DB or Joern CPG (/build-databases). For Semgrep, use /semgrep-rule instead.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/rule-synth-prepare.mjs" --target "<repo root>". If status is no-seeds (run /verify or /threat-hunt first) or no-engine (run /build-databases, or /semgrep-rule for Semgrep), report that and stop. Read prepPath.
For each seed, write a tight CodeQL .ql / Joern .sc for the recommendedEngine into the run dir, using the seed's seedFingerprint as seedRef. Joern scripts must open the CPG from KUZUSHI_CPG and print matches as KUZUSHI_MATCH\t<file>\t<line>. Write the { rules: [...] } bundle to the prep's draftPath.
Run the assembleCommand (finalize). It compiles each rule, checks it fires on the seed line, runs it across the repo, and caps it for precision — accepting only those that pass into the pack and promoting new matches as candidate findings. Report accepted/rejected per seed.

Plus depuis ce dépôt

même dépôt

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	rule-synth
description	Synthesize CodeQL queries / Joern scripts from confirmed findings — the heavy semantic engines /semgrep-rule (Semgrep-only) doesn't cover. The rule-synthesist agent writes a tight rule per seed; the host runs a native compile → fire-on-seed → repo-run → precision gate and persists only validated rules into a digest-attested pack under .kuzushi/rules/{codeql,joern}/, promoting new matches as candidate leads. Needs a confirmed finding + a built CodeQL DB / Joern CPG.
context	fork
agent	rule-synthesist
user-invocable	false

Rule synthesis (CodeQL / Joern)

Requires: a confirmed/proven/exploitable finding in findings.json, and a built CodeQL DB or Joern CPG (/build-databases). For Semgrep, use /semgrep-rule instead.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/rule-synth-prepare.mjs" --target "<repo root>". If status is no-seeds (run /verify or /threat-hunt first) or no-engine (run /build-databases, or /semgrep-rule for Semgrep), report that and stop. Read prepPath.
For each seed, write a tight CodeQL .ql / Joern .sc for the recommendedEngine into the run dir, using the seed's seedFingerprint as seedRef. Joern scripts must open the CPG from KUZUSHI_CPG and print matches as KUZUSHI_MATCH\t<file>\t<line>. Write the { rules: [...] } bundle to the prep's draftPath.
Run the assembleCommand (finalize). It compiles each rule, checks it fires on the seed line, runs it across the repo, and caps it for precision — accepting only those that pass into the pack and promoting new matches as candidate findings. Report accepted/rejected per seed.