
Trailmark Finding Triage
FreeStreamline your security finding analysis with graph evidence.
Free · Opens the source repo
What Trailmark Finding Triage does
Trailmark Finding Triage is a specialized tool designed for security professionals who need to assess the reachability and exploitability of security findings. By leveraging graph-assisted analysis, this skill helps users determine whether a specific issue in the codebase is actionable. It works by normalizing the candidate finding, binding it to relevant graph nodes, and analyzing the evidence surrounding the issue, including entrypoint paths and taint analysis. This structured approach allows for a more informed decision-making process when prioritizing security findings.
The skill is particularly useful in scenarios where a developer or security analyst needs to triage a single static analysis result or a manual finding before investing time into proof of concept (PoC) work. It provides a clear verdict on whether the finding should be promoted, requires further manual review, or can be deprioritized based on the available evidence. This evidence packet not only aids in the prioritization of findings but also prepares the groundwork for further exploit validation.
However, this skill is not intended for use with multiple findings that may need to be analyzed as a chain, nor is it suitable for full audits or remediation verification. Users should ensure they have a concrete finding or suspicious sink before utilizing this skill, as it relies on specific code references to function effectively. By following a defined workflow, users can efficiently navigate through the complexities of security findings, making it an essential tool for those focused on application security and vulnerability management.
When to use it
Use this skill when you need to analyze a single security finding or static-analysis result to determine its reachability and potential impact before proceeding with exploit development.
When not to use it
Avoid using this skill for multiple findings, full audits, or when no concrete finding exists, as it is designed for focused analysis on individual issues.
What you can build with it
Triage a Static Analysis Result
Use this skill to assess a specific static analysis result before investing time in proof of concept work.
Evaluate a Manual Finding
Check if a suspicious function identified during a manual audit is reachable and requires further review.
Prepare Evidence for PoC Work
Build a concise evidence packet for a security finding to support your proof of concept development.
How to install Trailmark Finding Triage
View source1. Install with the skills CLI
npx skills add trailofbits/skills/trailmark-finding-triage --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by trailofbitsTrailmark Finding Triage
Build a concise graph evidence packet for one candidate finding. This skill answers whether the affected code is reachable, what graph evidence supports or weakens the claim, and what manual review is still required before calling the issue exploitable.
When to Use
- Triage one static-analysis result before spending PoC time
- Check whether a manual finding is entrypoint-reachable
- Build an evidence packet for PoC work
- Review a single suspicious function discovered during manual audit
- Decide whether one issue should be promoted, deprioritized, or treated as part of a broader chain analysis
When NOT to Use
- Multiple weak findings might compose into a stronger chain. Use a chain or composition workflow instead.
- The user wants a full audit. Use an audit or design-review workflow instead.
- The user wants remediation verification for a known finding. Use a remediation-review workflow instead.
- The target is a PR or branch diff. Use
graph-evolutionplus a differential review workflow. - No concrete finding, function, file/line, or suspicious sink exists yet. Use discovery skills first.
Rationalizations to Reject
| Rationalization | Why It Is Wrong | Required Action |
|---|---|---|
| "The scanner says high severity, so reachability is obvious" | Static findings need graph and code context before promotion | Bind the finding to a graph node and check entrypoint paths |
| "No entrypoint path means impossible" | It may mean parser, proxy, or dynamic dispatch limitations | Report the limitation separately from reachability |
| "An auth check appears on the path, so the issue is safe" | The check may enforce the wrong predicate or be bypassed by another path | Treat validation/auth as review targets, not proof |
| "One reachable path is enough for a PoC claim" | The path still needs attacker-controlled inputs and compatible preconditions | Separate graph reachability from exploitability |
| "This is probably a chain" | Single-finding triage stops at one candidate | Hand off related findings to a composition workflow |
Workflow
Finding Triage Progress:
- [ ] Step 1: Normalize the candidate
- [ ] Step 2: Build or reuse the Trailmark graph
- [ ] Step 3: Bind the candidate to graph node(s)
- [ ] Step 4: Analyze reachability, taint, boundaries, and blast radius
- [ ] Step 5: Decide and emit the evidence packet
Step 1: Normalize the Candidate
Accept file/line, function name, SARIF result, weAudit annotation, Markdown finding excerpt, or a manual claim. Normalize it to:
- title
- source type
- file path and line range if present
- function or node hint
- suspected source, sink, or asset
- claimed impact
If there is no concrete code anchor, stop and ask for one.
For input handling details, see references/input-normalization.md.
Step 2: Build Or Reuse The Graph
Use the public trailmark skill workflow. Prefer an existing fresh exported
graph or .trailmark/ artifact when present. Otherwise build a graph with
language="auto" or the target's explicit language list, then run
engine.preanalysis().
Record the Trailmark version or feature probes used. Feature-gate Trailmark
0.4-only APIs with hasattr() or CLI help checks.
Step 3: Bind The Candidate
Bind by file and line overlap first, then function name plus file. If several nodes match, list every candidate and select the narrowest enclosing node as primary. If no node matches, report a binding limitation instead of guessing.
SARIF and weAudit users should reuse the audit-augmentation workflow for
matching and then inspect the annotated node.
Step 4: Analyze Graph Evidence
Run the query recipe in references/query-recipes.md:
- entrypoint paths to the bound node
- trust level of each path when available
- membership in
tainted,privilege_boundary, andhigh_blast_radiussubgraphs - direct callers and callees
- high-impact downstream sinks
- sibling or nearby nodes worth manual review
Do not treat graph reachability as proof of exploitability.
Step 5: Decide And Handoff
Produce one verdict:
| Verdict | Meaning |
|---|---|
Promote | Graph evidence supports reachability and plausible impact |
Needs manual review | Evidence is suggestive but not decisive |
Deprioritize | No reachable path or only trusted/internal paths found |
Blocked | Binding or Trailmark analysis failed |
Write the evidence packet using references/output-format.md.
Hand off promoted PoC-worthy issues to the user's PoC workflow. Hand off
related findings to a composition workflow. Hand off repeatable root causes to
trailmark-variant-neighborhood, variant-analysis, or a custom Semgrep/CodeQL
rule workflow.
Example Prompts
- "Use Trailmark finding triage on
src/Vault.sol:148; I think withdraw can bypass the balance update." - "Triage this SARIF result before I spend PoC time:
semgrep:error unchecked-transferincontracts/Bridge.solline 91." - "This report excerpt claims
parse_packetis attacker reachable. Build the Trailmark evidence packet and tell me what is still missing."
Frequently asked questions about Trailmark Finding Triage
Similar skills
GitHub Actions Hardening
Enhance the security of your GitHub Actions workflows.
Sensitive Logging Audit
Audit and fix sensitive data exposure in Python logging.
Android App Static Analysis
Automate security assessments of Android apps with MobSF.
Integrating DAST with OWASP ZAP
Seamlessly integrate dynamic security testing into CI/CD pipelines.
Implementing Runtime Security with Tetragon
Enhance Kubernetes security with eBPF-based observability.
Implementing Mobile Application Management
Secure enterprise data on mobile devices with app-level controls.
