
ghost
- GitHub stars
- 446
Install
/plugin install ghost@ghost-securityRun it inside Claude Code after adding the marketplace with /plugin marketplace add ghostsecurity/skills.
Contents
Discovered from sourceSkills 7
Reaper MITM Proxy
Reaper is a CLI-based MITM HTTPS proxy for application security testing. It intercepts, logs, and allows inspection of HTTP/HTTPS traffic flowing through it. Use it to capture live request/response pairs for security validation.
Prerequisites
Before using any reaper command, make sure the latest version of the binary is installed:
curl -sfL https://raw.githubusercontent.com/ghostsecurity/reaper/main/scripts/install.sh | bash
All reaper commands in this document should be invoked as ~/.ghost/bin/reaper unless ~/.ghost/bin is on PATH.
Quick Reference
| Command | Purpose |
|---|---|
reaper start --domains example.com | Start proxy (foreground) |
reaper start --domains example.com -d | Start proxy (daemon) |
reaper logs | Show recent captured entries |
reaper search --method POST --path /api/* | Search captured traffic |
reaper get <id> | Show full request + response |
reaper req <id> | Show raw HTTP request only |
reaper res <id> | Show raw HTTP response only |
reaper stop | Stop the daemon |
Starting the Proxy
Start reaper scoped to the target domain(s). At least one --domains or --hosts flag is required.
# Intercept all traffic to example.com and its subdomains
reaper start --domains example.com
# Multiple domains
reaper start --domains example.com,api.internal.co
# Exact hostname matching
reaper start --hosts api.example.com
# Both domain suffix and exact host matching
reaper start --domains example.com --hosts special.internal.co
# Custom port (default: 8443)
reaper start --domains example.com --port 9090
# Run as background daemon
reaper start --domains example.com -d
Scope behavior:
--domains: Suffix match.example.commatchesexample.com,api.example.com,sub.api.example.com--hosts: Exact match.api.example.commatches onlyapi.example.com- Traffic outside scope passes through transparently without logging
Routing Traffic Through the Proxy
Configure the HTTP client to use the proxy. The default listen address is localhost:8443.
# curl
curl -x http://localhost:8443 -k https://api.example.com/endpoint
# Environment variables (works with many tools)
export http_proxy=http://localhost:8443
export https_proxy=http://localhost:8443
# Python requests
import requests
requests.get("https://api.example.com/endpoint",
proxies={"http": "http://localhost:8443", "https": "http://localhost:8443"},
verify=False)
The -k / verify=False flag is needed because reaper generates its own CA certificate at startup for MITM TLS interception.
Viewing Captured Traffic
Recent Entries
# Show last 50 entries (default)
reaper logs
# Show last 200 entries
reaper logs -n 200
Output columns: ID, METHOD, HOST, PATH, STATUS, MS, REQ (request body size), RES (response body size).
Searching
# By HTTP method
reaper search --method POST
# By host (supports * wildcard)
reaper search --host *.api.example.com
# By domain suffix
reaper search --domains example.com
# By path prefix (supports * wildcard)
reaper search --path /api/v3/transfer
# By status code
reaper search --status 200
# Combined filters
reaper search --method POST --path /api/v3/* --status 200 -n 50
Inspecting Individual Entries
# Full request and response (raw HTTP)
reaper get 42
# Request only
reaper req 42
# Response only
reaper res 42
Output is raw HTTP/1.1 format including headers and body, suitable for analysis or replay.
Stopping the Proxy
reaper stop
Common Workflows
Validate a Security Finding
When used with the validate skill (may need to collaborate with the user to setup the test environment):
- Start reaper scoped to the application domain
- Verify traffic is being captured by running
reaper logs— at least one entry should appear after routing a test request through the proxy - If no entries appear, verify proxy settings and domain scope match the target
- Authenticate (or ask the user to authenticate) as a normal user and exercise the vulnerable endpoint legitimately
- Search for the captured request to understand the expected request format
- Craft and send a malicious request that exercises the exploit described in the finding
- Inspect the response to determine if the exploit succeeded
- Use
reaper get <id>to capture the full request/response as evidence
Data Storage
All data is stored in ~/.ghost/reaper/:
reaper.db- SQLite database with captured entriesreaper.sock- Unix socket for CLI-to-daemon IPCreaper.pid- Daemon process ID
The CA certificate is generated fresh in memory on each start and is not persisted.
Repository Context Builder
You gather repository context by detecting projects, summarizing their architecture, and writing the results to repo.md. Do all work yourself — do not spawn subagents or delegate.
Inputs
Parse these from $ARGUMENTS (key=value pairs):
- repo_path: path to the repository root
- cache_dir: path to the cache directory (defaults to
~/.ghost/repos/<repo_id>/cache)
$ARGUMENTS
If cache_dir is not provided, compute it:
repo_name=$(basename "$(pwd)") && remote_url=$(git remote get-url origin 2>/dev/null || pwd) && short_hash=$(printf '%s' "$remote_url" | git hash-object --stdin | cut -c1-8) && repo_id="${repo_name}-${short_hash}" && cache_dir="$HOME/.ghost/repos/${repo_id}/cache" && echo "cache_dir=$cache_dir"
Tool Restrictions
Do NOT use WebFetch or WebSearch. All work must use only local files in the repository.
Setup
Discover this skill's own directory so you can reference agent files:
skill_dir=$(find . -path '*/skills/repo-context/SKILL.md' 2>/dev/null | head -1 | xargs dirname)
echo "skill_dir=$skill_dir"
Check Cache First
Check if <cache_dir>/repo.md already exists. If it does, skip everything and return:
Repository context is at: <cache_dir>/repo.md
If it does not exist, run mkdir -p <cache_dir> and continue.
Workflow
-
Detect Projects — Read
<skill_dir>/detector.mdand follow its instructions against<repo_path>. Save the full detection output (project details needed for step 2). If detection finds no projects, write a minimalrepo.mdnoting "No projects detected" and skip to step 4. -
Summarize Each Project — Read
<skill_dir>/summarizer.md. For EACH project detected in step 1, follow the summarizer instructions using that project's details (id, type, base_path, languages, frameworks, dependency_files, extensions, evidence). Collect the summary for each project. If summarization fails for a project, note it as "summary unavailable" and continue with remaining projects. -
Write repo.md — Combine detection and summary results into
<cache_dir>/repo.mdusing the format in<skill_dir>/template-repo.md. For each project include:- Detection: ID, Type, Base Path, Languages, Frameworks, Dependency Files, Extensions, Evidence
- Summary: Architectural summary, Sensitive Data Types, Business Criticality, Component Map, Evidence
-
Validate — Read
<cache_dir>/repo.mdback and verify it contains the expected sections from<skill_dir>/template-repo.md(e.g., project entries with Detection and Summary fields). If the file is missing or malformed, retry the write once before reporting an error. -
Output — Return:
Repository context is at: <cache_dir>/repo.md
Combined Security Report
You aggregate findings from all scan skills (scan-deps, scan-secrets, scan-code) into a single prioritized report. Do all work yourself — do not spawn subagents or delegate.
$ARGUMENTS
Step 0: Setup
Run this Bash command to compute paths:
repo_name=$(basename "$(pwd)") && remote_url=$(git remote get-url origin 2>/dev/null || pwd) && short_hash=$(printf '%s' "$remote_url" | git hash-object --stdin | cut -c1-8) && repo_id="${repo_name}-${short_hash}" && short_sha=$(git rev-parse --short HEAD 2>/dev/null || date +%Y%m%d) && ghost_repo_dir="$HOME/.ghost/repos/${repo_id}" && scans_dir="${ghost_repo_dir}/scans/${short_sha}" && cache_dir="${ghost_repo_dir}/cache" && skill_dir=$(find . -path '*/skills/report/SKILL.md' 2>/dev/null | head -1 | xargs dirname) && echo "scans_dir=$scans_dir cache_dir=$cache_dir skill_dir=$skill_dir"
Store scans_dir (commit-level scan directory), cache_dir, and skill_dir.
Cache Check
If <scans_dir>/report.md already exists, show:
Combined security report is at: <scans_dir>/report.md
And stop. Do not regenerate it.
Step 1: Read Repo Context
Read <cache_dir>/repo.md if it exists. Extract:
- Business criticality
- Sensitive data types
- Component map
If it does not exist, continue without it — this is not an error.
Step 2: Discover Scan Results
List the contents of <scans_dir> to see which scan-type directories exist. Recognized types:
deps/— SCA / dependency vulnerability scansecrets/— secrets and credentials scancode/— code security scan (SAST)
If none of these directories exist, report an error:
No scan results found in <scans_dir>. Run one or more scan skills first:
/ghost-scan-deps
/ghost-scan-secrets
/ghost-scan-code
And stop.
Step 3: Collect Findings
For each scan type that exists, glob <scans_dir>/<type>/findings/*.md and read each finding file in full. Retain the complete markdown body of every finding — the report will inline this content directly so readers never need to open individual finding files.
From each finding, also extract these metadata fields for filtering and sorting:
- ID — from
## Metadata→ID - Type — the scan type (
deps,secrets, orcode) - Severity — from
## Metadata→Severity(high, medium, low) - Status — from
## Metadata→Status(e.g., confirmed-exploitable, unverified, verified, rejected, clean)
Step 4: Filter and Sort
Filter: Keep only high-confidence findings:
- For
depsfindings: status isconfirmed-exploitable - For
secretsfindings: status is NOTcleanand NOTrejected - For
codefindings: status isverifiedorunverified(NOTrejected)
Exclude any finding with status clean, rejected, or false-positive.
Sort the remaining findings:
- By severity: high first, then medium, then low
- Within same severity: deps before secrets before code
Step 5: Read Per-Scan Reports
For deps and secrets scan types, read <scans_dir>/<type>/report.md if present. Extract:
- Statistics (candidates scanned, confirmed findings, false positives filtered)
- Executive summary highlights
Note: code does not produce a report.md. For code scan coverage, count the finding files in <scans_dir>/code/findings/ directly. The "Candidates Scanned" count is the total number of finding files (all statuses). "Confirmed Findings" is the count with status verified, confirmed, or unverified. "False Positives Filtered" is the count with status rejected. Do NOT count clean file analyses from the nomination/analysis funnel — those never became findings.
If a per-scan report does not exist for deps or secrets, note it as unavailable.
Step 6: Generate Report
- Read
<skill_dir>/report-template.md - Populate the template with collected data:
- Fill Scan Information with repository name, commit SHA, date, and which scans ran
- Write Executive Summary using repo context and aggregated findings
- For all writing elements in this security-focused, objective and fact based report, use a neutral, human tone that balances expertise with ease of reading. Do not use emojis, em-dashes, etc.
- For Critical & High findings (severity = high): inline the substantive content from each finding file directly into the report — include code snippets, assessment tables, remediation commands, and all relevant detail so the report is fully self-contained
- For Medium findings: write a full subsection per finding with description, location, code context, and remediation (not a condensed table)
- Omit low-severity findings (they remain in per-scan finding files only)
- Fill Scan Coverage table from per-scan report statistics (for code, use finding file counts from Step 5)
- Add a brief methodology note per scan type that ran (1-2 sentences drawn from per-scan reports)
- Do NOT include links to per-scan reports or individual finding files — all content is inlined
- Write the report to
<scans_dir>/report.md
Step 7: Show Output
Combined security report is at: <scans_dir>/report.md
Find Issues
You find security issues in a repository. This skill plans which vulnerability vectors to scan, then executes those scans against each project.
Inputs
- depth:
quick(default),balanced, orfull— override via$ARGUMENTS
$ARGUMENTS
Note: Arguments passed can be used to customize the scan workflow if provided. For example, if the user specifies a specific set of vectors, count of vectors, specific candidate files, areas to focus on, count of candidate files, etc., ensure the relevant details are passed to the relevant steps in the skill.
Supporting files
- Loop script: scripts/loop.sh
- Scan criteria: criteria/index.yaml
Step 1: Setup
Compute the repo-specific output directory:
repo_name=$(basename "$(pwd)") && remote_url=$(git remote get-url origin 2>/dev/null || pwd) && short_hash=$(printf '%s' "$remote_url" | git hash-object --stdin | cut -c1-8) && repo_id="${repo_name}-${short_hash}" && short_sha=$(git rev-parse --short HEAD 2>/dev/null || date +%Y%m%d) && ghost_repo_dir="$HOME/.ghost/repos/${repo_id}" && scan_dir="${ghost_repo_dir}/scans/${short_sha}/code" && cache_dir="${ghost_repo_dir}/cache" && mkdir -p "$scan_dir" && echo "scan_dir=$scan_dir cache_dir=$cache_dir"
- Read
$cache_dir/repo.md— if missing, run the repo-context skill first and then continue. - Read criteria/index.yaml to get the valid agent→vector mappings per project type
- Set
depthtoquickif not provided - If
depthisfull, warn the user that a full scan uses significantly more tokens and ask them to confirm before proceeding. If they decline, fall back tobalanced.
Step 2: Plan Scans
If $scan_dir/plan.md already exists, skip to the next step.
Otherwise, run the planner using scripts/loop.sh:
bash <path-to-loop.sh> $scan_dir planner.md "- depth: <depth>
- arguments: <relevant argument overrides if any, otherwise omit>" 1 $cache_dir
Use a 10-minute timeout. If the command times out, re-run it — the script resumes from where it left off. If it fails 3 times consecutively with the same error, stop and report the failure.
Verify: $scan_dir/plan.md exists and contains at least one ## Project: section before proceeding.
Step 3: Nominate Files
If $scan_dir/nominations.md does not exist, generate it by reading $scan_dir/plan.md and for each project section (## Project: <base_path> (<type>)), parse the Recommended Scans table. For each row, extract the Agent and Vector columns. Write $scan_dir/nominations.md - one line per (project, agent, vector) combination. Skip projects with empty scan tables.
# Nominations
- [ ] <base_path> (<type>) | <agent> | <vector>
- [ ] <base_path> (<type>) | <agent> | <vector>
...
If $scan_dir/nominations.md already exists, change every top level task - [x] to - [ ]. Keep all indented lines/subtasks beneath each item unchanged.
Run nomination script
Using scripts/loop.sh:
bash <path-to-loop.sh> $scan_dir nominator.md "- depth: <depth>
- arguments: <relevant argument overrides if any, otherwise omit>" 5 $cache_dir
Use a 10-minute timeout. If the command times out, re-run it — the script resumes from where it left off. If it fails 3 times consecutively with the same error, stop and report the failure.
Verify: $scan_dir/nominations.md contains at least one - [x] line before proceeding.
Step 4: Analyze Nominated Files
Read $scan_dir/nominations.md. For each candidate file under a checked - [x] line, append to $scan_dir/analyses.md (skip candidates already listed in analyses.md).
- [ ] <base_path> (<type>) | <agent> | <vector> | <candidate_file>
Create the findings directory:
mkdir -p $scan_dir/findings
Run analysis script
Using scripts/loop.sh:
bash <path-to-loop.sh> $scan_dir analyzer.md "" 5 $cache_dir
Use a 10-minute timeout. If the command times out, re-run it — the script resumes from where it left off. If it fails 3 times consecutively with the same error, stop and report the failure.
Verify: $scan_dir/analyses.md contains at least one - [x] line before proceeding.
Step 5: Verify Findings
List all .md files in $scan_dir/findings/. If none exist, write a no-findings.md summary and stop.
Using scripts/loop.sh:
bash <path-to-loop.sh> $scan_dir verifier.md "" 5 $cache_dir
Use a 10-minute timeout. If the command times out, re-run it — the script resumes from where it left off. If it fails 3 times consecutively with the same error, stop and report the failure.
Completion
After all steps complete, report the scan results:
- List all finding files in
$scan_dir/findings/ - Count verified vs rejected findings
- Present a summary to the user
Ghost Security SCA Scanner — Orchestrator
You are the top-level orchestrator for Software Composition Analysis (SCA) scanning. Your ONLY job is to call the Task tool to spawn subagents to do the actual work. Each step below gives you the exact Task tool parameters to use. Do not do the work yourself.
Defaults
- repo_path: the current working directory
- scan_dir:
~/.ghost/repos/<repo_id>/scans/<short_sha>/deps - short_sha:
git rev-parse --short HEAD(falls back toYYYYMMDDfor non-git dirs)
$ARGUMENTS
Any values provided above override the defaults.
Execution
- Setup — compute paths and create output directories
- Initialize Wraith — install the wraith binary
- Discover Lockfiles — find all dependency lockfiles in the repo
- Scan for Vulnerabilities — run wraith against each lockfile
- Analyze Candidates — assess exploitability of each candidate
- Summarize Results — generate the final scan report
Step 0: Setup
Run this Bash command to compute the repo-specific output directory, create it, and locate the skill files:
repo_name=$(basename "$(pwd)") && remote_url=$(git remote get-url origin 2>/dev/null || pwd) && short_hash=$(printf '%s' "$remote_url" | git hash-object --stdin | cut -c1-8) && repo_id="${repo_name}-${short_hash}" && short_sha=$(git rev-parse --short HEAD 2>/dev/null || date +%Y%m%d) && ghost_repo_dir="$HOME/.ghost/repos/${repo_id}" && scan_dir="${ghost_repo_dir}/scans/${short_sha}/deps" && cache_dir="${ghost_repo_dir}/cache" && mkdir -p "$scan_dir/findings" && skill_dir=$(find . -path '*skills/scan-deps/SKILL.md' 2>/dev/null | head -1 | xargs dirname) && echo "scan_dir=$scan_dir cache_dir=$cache_dir skill_dir=$skill_dir"
Store scan_dir (the absolute path under ~/.ghost/repos/), cache_dir (the repo-level cache directory), and skill_dir (the absolute path to the skill directory containing agents/, scripts/, etc.).
After this step, your only remaining tool is Task. Do not use Bash, Read, Grep, Glob, or any other tool for Steps 1–5.
Step 1: Initialize Wraith
Call the Task tool to initialize the wraith binary:
{
"description": "Initialize wraith binary",
"subagent_type": "general-purpose",
"prompt": "You are the init agent. Read and follow the instructions in <skill_dir>/agents/init/agent.md.\n\n## Inputs\n- skill_dir: <skill_dir>"
}
The init agent installs wraith to ~/.ghost/bin/wraith (or wraith.exe on Windows).
Step 2: Discover Lockfiles
Call the Task tool to discover lockfiles in the repository:
{
"description": "Discover lockfiles",
"subagent_type": "general-purpose",
"prompt": "You are the discover agent. Read and follow the instructions in <skill_dir>/agents/discover/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>"
}
The discover agent finds all lockfiles (go.mod, package-lock.json, etc.) and writes <scan_dir>/lockfiles.json.
If lockfile count is 0: Skip to Step 5 (Summarize) with no lockfiles found.
Step 3: Scan for Vulnerabilities
Call the Task tool to run the wraith scanner:
{
"description": "Scan for vulnerabilities",
"subagent_type": "general-purpose",
"prompt": "You are the scan agent. Read and follow the instructions in <skill_dir>/agents/scan/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>"
}
The scan agent executes wraith for each lockfile and writes <scan_dir>/candidates.json.
If candidate count is 0: Skip to Step 5 (Summarize) with no vulnerabilities found.
Step 4: Analyze Candidates
Call the Task tool to analyze the vulnerability candidates:
{
"description": "Analyze vulnerability candidates",
"subagent_type": "general-purpose",
"prompt": "You are the analysis agent. Read and follow the instructions in <skill_dir>/agents/analyze/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>\n- skill_dir: <skill_dir>\n- cache_dir: <cache_dir>"
}
The analysis agent spawns parallel analyzers for each candidate to assess exploitability and writes finding files to <scan_dir>/findings/.
Step 5: Summarize Results
Call the Task tool to summarize the findings:
{
"description": "Summarize scan results",
"subagent_type": "general-purpose",
"prompt": "You are the summarize agent. Read and follow the instructions in <skill_dir>/agents/summarize/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>\n- skill_dir: <skill_dir>\n- cache_dir: <cache_dir>"
}
After executing all the tasks, report the scan results to the user.
Error Handling
If any Task call fails, retry it once. If it fails again, stop and report the failure.
Ghost Security Secrets Scanner — Orchestrator
You are the top-level orchestrator for secrets scanning. Your ONLY job is to call the Task tool to spawn subagents to do the actual work. Each step below gives you the exact Task tool parameters to use. Do not do the work yourself.
Defaults
- repo_path: the current working directory
- scan_dir:
~/.ghost/repos/<repo_id>/scans/<short_sha>/secrets - short_sha:
git rev-parse --short HEAD(falls back toYYYYMMDDfor non-git dirs)
$ARGUMENTS
Any values provided above override the defaults.
Execution
- Setup — compute paths and create output directories
- Initialize Poltergeist — install the poltergeist binary
- Scan for Secrets — run poltergeist against the codebase
- Analyze Candidates — assess each candidate for confirmation
- Summarize Results — generate the final scan report
Step 0: Setup
Run this Bash command to compute the repo-specific output directory, create it, and locate the skill files:
repo_name=$(basename "$(pwd)") && remote_url=$(git remote get-url origin 2>/dev/null || pwd) && short_hash=$(printf '%s' "$remote_url" | git hash-object --stdin | cut -c1-8) && repo_id="${repo_name}-${short_hash}" && short_sha=$(git rev-parse --short HEAD 2>/dev/null || date +%Y%m%d) && ghost_repo_dir="$HOME/.ghost/repos/${repo_id}" && scan_dir="${ghost_repo_dir}/scans/${short_sha}/secrets" && cache_dir="${ghost_repo_dir}/cache" && mkdir -p "$scan_dir/findings" && skill_dir=$(find . -path '*skills/scan-secrets/SKILL.md' 2>/dev/null | head -1 | xargs dirname) && echo "scan_dir=$scan_dir cache_dir=$cache_dir skill_dir=$skill_dir"
Store scan_dir (the absolute path under ~/.ghost/repos/), cache_dir (the repo-level cache directory), and skill_dir (the absolute path to the skill directory containing agents/, scripts/, etc.).
After this step, your only remaining tool is Task. Do not use Bash, Read, Grep, Glob, or any other tool for Steps 1–4.
Step 1: Initialize Poltergeist
Call the Task tool to initialize the poltergeist binary:
{
"description": "Initialize poltergeist binary",
"subagent_type": "general-purpose",
"prompt": "You are the init agent. Read and follow the instructions in <skill_dir>/agents/init/agent.md.\n\n## Inputs\n- skill_dir: <skill_dir>"
}
The init agent installs poltergeist to ~/.ghost/bin/poltergeist (or poltergeist.exe on Windows).
Step 2: Scan for Secrets
Call the Task tool to run the poltergeist scanner:
{
"description": "Scan for secret candidates",
"subagent_type": "general-purpose",
"prompt": "You are the scan agent. Read and follow the instructions in <skill_dir>/agents/scan/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>"
}
The scan agent returns the candidate count and writes <scan_dir>/candidates.json.
If candidate count is 0: Skip to Step 4 (Summarize) with no findings.
Step 3: Analyze Candidates
Call the Task tool to analyze the candidates:
{
"description": "Analyze secret candidates",
"subagent_type": "general-purpose",
"prompt": "You are the analysis agent. Read and follow the instructions in <skill_dir>/agents/analyze/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>\n- skill_dir: <skill_dir>\n- cache_dir: <cache_dir>"
}
The analysis agent spawns parallel analyzers for each candidate and writes finding files to <scan_dir>/findings/.
Step 4: Summarize Results
Call the Task tool to summarize the findings:
{
"description": "Summarize scan results",
"subagent_type": "general-purpose",
"prompt": "You are the summarize agent. Read and follow the instructions in <skill_dir>/agents/summarize/agent.md.\n\n## Inputs\n- repo_path: <repo_path>\n- scan_dir: <scan_dir>\n- skill_dir: <skill_dir>\n- cache_dir: <cache_dir>"
}
After executing all the tasks, report the scan results to the user.
Error Handling
If any Task call fails, retry it once. If it fails again, stop and report the failure.
Security Finding Validation
Determine whether a security finding is a true positive or false positive. Produce a determination with supporting evidence.
Input
The user provides a finding as a file path or pasted text. If neither is provided, ask for one.
Extract: vulnerability class, specific claim, affected endpoint, code location, and any existing validation evidence.
Validation Workflow
Step 1: Understand the Finding
Identify:
- The vulnerability class (BFLA, BOLA, XSS, SQLi, SSRF, etc.)
- The specific claim being made (what authorization check is missing, what input is unsanitized, etc.)
- The affected endpoint and HTTP method
- The code location
Step 2: Analyze the Source Code
- Read the vulnerable file at the specified line number and all supporting files
- Trace the request flow from route registration through middleware to the handler
- Verify the specific claim — does the code actually lack the described check?
- Look for indirect protections (middleware, helpers, ORM constraints) the scanner may have missed
- Confirm the vulnerable code path is reachable under the described conditions
Step 3: Live Validation (When Available)
If a live instance of the application is accessible and the vulnerability can be confirmed through live interaction, use the proxy skill to confirm exploitability:
- Start reaper proxy scoped to the target domain
- Authenticate (or have the user authenticate) as a legitimate user and capture a valid request to the vulnerable endpoint
- Replay or modify the request to attempt the exploit described in the finding
- Compare the response to expected behavior:
- Does the unauthorized action succeed? (true positive)
- Does the server reject it with 401/403/404? (false positive)
- Capture the request/response pair as evidence using
reaper get <id>
Step 4: Make Determination
Classify the finding as one of:
- True Positive: The vulnerability exists and is exploitable. The code lacks the described protection and the endpoint is reachable.
- True Positive (Confirmed): Same as above, plus live testing demonstrated successful exploitation.
- False Positive: The vulnerability does not exist. Provide the specific reason (indirect protection found, code path unreachable, etc.).
- Inconclusive: Cannot determine without additional information. Specify what is needed.
Step 5: Report
Output a summary in the following format:
- Determination: True Positive, False Positive, or Inconclusive
- Confidence: High, Medium, or Low
- Evidence Summary: Key findings from code review and/or live testing
- Code Analysis: Specific lines and logic that support the determination
- Live Test Results (if performed): Request/response pairs demonstrating the behavior
- Recommendation: Fix if true positive, close if false positive, gather more info if inconclusive
Example:
## Validation Result
- **Determination**: True Positive
- **Confidence**: High
- **Evidence**: Handler at routes/transfers.go:142 queries transfers by ID without checking ownership. No middleware or ORM-level constraint enforces user scoping.
- **Recommendation**: Add ownership check — include user_id in the WHERE clause.
Step 6: Persist Results
If the finding was provided as a file path, ask the user if they would like to append the validation details to the original finding file. If they agree, append a ## Validation section to the file containing the determination, confidence, evidence summary, and recommendation.
Vulnerability Class Reference
See VULNERABILITY_PATTERNS.md in this skill directory for patterns to look for when validating authorization flaws (BFLA/BOLA/IDOR), injection (SQLi/XSS), and authentication flaws.
Sponsors
Details
- Marketplace
- ghostsecurity/skills
- Source
- plugins/ghost
- Category
- Community