GitHub stars
446

Install

/plugin install ghost@ghost-security

Run it inside Claude Code after adding the marketplace with /plugin marketplace add ghostsecurity/skills.

Contents

Discovered from source

Skills 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

CommandPurpose
reaper start --domains example.comStart proxy (foreground)
reaper start --domains example.com -dStart proxy (daemon)
reaper logsShow 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 stopStop 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.com matches example.com, api.example.com, sub.api.example.com
  • --hosts: Exact match. api.example.com matches only api.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):

  1. Start reaper scoped to the application domain
  2. Verify traffic is being captured by running reaper logs — at least one entry should appear after routing a test request through the proxy
  3. If no entries appear, verify proxy settings and domain scope match the target
  4. Authenticate (or ask the user to authenticate) as a normal user and exercise the vulnerable endpoint legitimately
  5. Search for the captured request to understand the expected request format
  6. Craft and send a malicious request that exercises the exploit described in the finding
  7. Inspect the response to determine if the exploit succeeded
  8. 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 entries
  • reaper.sock - Unix socket for CLI-to-daemon IPC
  • reaper.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

  1. Detect Projects — Read <skill_dir>/detector.md and follow its instructions against <repo_path>. Save the full detection output (project details needed for step 2). If detection finds no projects, write a minimal repo.md noting "No projects detected" and skip to step 4.

  2. 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.

  3. Write repo.md — Combine detection and summary results into <cache_dir>/repo.md using 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
  4. Validate — Read <cache_dir>/repo.md back 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.

  5. 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 scan
  • secrets/ — secrets and credentials scan
  • code/ — 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, or code)
  • 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 deps findings: status is confirmed-exploitable
  • For secrets findings: status is NOT clean and NOT rejected
  • For code findings: status is verified or unverified (NOT rejected)

Exclude any finding with status clean, rejected, or false-positive.

Sort the remaining findings:

  1. By severity: high first, then medium, then low
  2. 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

  1. Read <skill_dir>/report-template.md
  2. 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
  3. 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, or full — 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


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"
  1. Read $cache_dir/repo.md — if missing, run the repo-context skill first and then continue.
  2. Read criteria/index.yaml to get the valid agent→vector mappings per project type
  3. Set depth to quick if not provided
  4. If depth is full, warn the user that a full scan uses significantly more tokens and ask them to confirm before proceeding. If they decline, fall back to balanced.

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:

  1. List all finding files in $scan_dir/findings/
  2. Count verified vs rejected findings
  3. 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 to YYYYMMDD for non-git dirs)

$ARGUMENTS

Any values provided above override the defaults.


Execution

  1. Setup — compute paths and create output directories
  2. Initialize Wraith — install the wraith binary
  3. Discover Lockfiles — find all dependency lockfiles in the repo
  4. Scan for Vulnerabilities — run wraith against each lockfile
  5. Analyze Candidates — assess exploitability of each candidate
  6. 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 to YYYYMMDD for non-git dirs)

$ARGUMENTS

Any values provided above override the defaults.


Execution

  1. Setup — compute paths and create output directories
  2. Initialize Poltergeist — install the poltergeist binary
  3. Scan for Secrets — run poltergeist against the codebase
  4. Analyze Candidates — assess each candidate for confirmation
  5. 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

  1. Read the vulnerable file at the specified line number and all supporting files
  2. Trace the request flow from route registration through middleware to the handler
  3. Verify the specific claim — does the code actually lack the described check?
  4. Look for indirect protections (middleware, helpers, ORM constraints) the scanner may have missed
  5. 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:

  1. Start reaper proxy scoped to the target domain
  2. Authenticate (or have the user authenticate) as a legitimate user and capture a valid request to the vulnerable endpoint
  3. Replay or modify the request to attempt the exploit described in the finding
  4. Compare the response to expected behavior:
    • Does the unauthorized action succeed? (true positive)
    • Does the server reject it with 401/403/404? (false positive)
  5. 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:

  1. Determination: True Positive, False Positive, or Inconclusive
  2. Confidence: High, Medium, or Low
  3. Evidence Summary: Key findings from code review and/or live testing
  4. Code Analysis: Specific lines and logic that support the determination
  5. Live Test Results (if performed): Request/response pairs demonstrating the behavior
  6. 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

More from ghostsecurity/skills

All 2