hunting-bug-variants

Solid

Given one confirmed vulnerability, systematically find its siblings: the same defect shape repeated elsewhere in the codebase, and the parts of it the fix left uncovered. Use right after you confirm or read about a bug (your own finding, a CVE, a patch, a writeup) and want the other instances instead of stopping at one. Turns a single seed into a structural signature and sweeps the whole tree for same-shape code, copy-paste clones, sibling handlers, and incomplete fixes. Covers signature extraction, the variant sweep, and adjudicating each candidate.

AI & Automation 4 stars 1 forks Updated yesterday MIT

Install

View on GitHub

Quality Score: 80/100

Stars 20%
23
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# Hunting bug variants: one seed, every sibling One bug is almost never alone. The same mistake gets copy-pasted, re-implemented by a second author, or left uncovered by a fix that only patched the reported call site. Variant hunting takes a *single confirmed defect* and turns it into a signature you can sweep the whole codebase with, so you find the three other copies before an attacker does. ## When to use - You just confirmed a bug and want its siblings, not a victory lap. - A CVE, advisory, or writeup describes a bug in code you can read. - A fix landed and you want to know whether it covered every instance. - Someone says "we already patched that" and you want to verify it is really gone. ## Scope check Authorized source only (your own, OSS, CTF, in-scope engagement). If you can't name the authorization, stop. ## The loop 1. **Anchor the seed.** State the confirmed defect precisely: the exact sink, the exact missing or wrong step (no bounds check, no authz check, unnormalized path, unescaped context), and the untrusted input that drives it. A vague seed ("there was an injection somewhere") produces a useless sweep. 2. **Extract the shape, not the string.** Abstract the seed into a structural signature that survives renaming and reformatting. Usually one of: *this sink called without that guard*; *this unsafe idiom* (raw concat into a query, `base / user_name` without resolve-and-contain); *this type of value reaching this argument*. Grepping ...

Details

Author
UnboundCompute
Repository
UnboundCompute/security-agent-skills
Created
5 days ago
Last Updated
yesterday
Language
N/A
License
MIT

Similar Skills

Semantically similar based on skill content — not just same category

Code & Development Listed

variant-hunt

After any vulnerability or bug is found, hunt the entire codebase for every other instance of the same pattern — because one bug is almost never alone. Turns a single finding into a systematic sweep using ripgrep and custom Semgrep rules, so the whole class gets fixed, not just the reported case. Use this skill right after finding or fixing a security issue, when reviewing whether a fix is complete, or when a past incident's pattern must be proven eradicated. Defensive only: it finds and eradicates weaknesses, it does not exploit them.

0 Updated 2 weeks ago
AL-JANEF
AI & Automation Solid

hunting-bugs-with-a-code-graph

Hunt security bugs across a whole codebase by reasoning over its structure (call graph and dataflow) instead of grepping for keywords. Use when you have source access to an authorized target (your own code, an OSS project, or an in-scope engagement) and want systematic coverage of a bug taxonomy rather than a single hunch; when the question is "who calls this, what reaches this sink, which peer function is unguarded." Orients on an unfamiliar codebase, enumerates the full bug taxonomy before drilling in, and turns structural leads into decided findings.

4 Updated yesterday
UnboundCompute
AI & Automation Listed

hunt-defect

Run a bug to ground — reproduce it, state a falsifiable hypothesis before touching code, isolate the cause, fix the cause, and leave a test that fails without the fix.

0 Updated 3 weeks ago
kerilpatel