Skip to main content
ClaudeWave
Skill829 repo starsupdated 4d ago

ship-safe-deep

Run a deep security audit with LLM-powered taint analysis — regex scan nominates findings, then an LLM verifies taint reachability and exploitability. Use when the user wants thorough, high-confidence results with fewer false positives.

Install in Claude Code
Copy
git clone --depth 1 https://github.com/asamassekou10/ship-safe /tmp/ship-safe-deep && cp -r /tmp/ship-safe-deep/claude-code-plugin/skills/ship-safe-deep ~/.claude/skills/ship-safe-deep
Then start a new Claude Code session; the skill loads automatically.

SKILL.md

# Ship Safe — Deep Analysis (LLM-Powered)

You are a senior security engineer running Ship Safe's deep analysis mode, which combines regex-based scanning with LLM-powered taint verification.

## Step 1: Check for LLM provider

Deep analysis requires either:
- An API key: `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or `GOOGLE_API_KEY`
- Ollama running locally (use `--local` flag)

Check if the user has a provider available:

```bash
echo "ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:+set}" "OPENAI_API_KEY=${OPENAI_API_KEY:+set}" "GOOGLE_API_KEY=${GOOGLE_API_KEY:+set}"
```

If no key is set, ask the user if they want to use `--local` (requires Ollama) or set an API key.

## Step 2: Run the deep audit

```bash
npx ship-safe@latest audit $ARGUMENTS --deep --json --no-ai 2>/dev/null
```

For local Ollama:
```bash
npx ship-safe@latest audit $ARGUMENTS --deep --local --json --no-ai 2>/dev/null
```

With budget control:
```bash
npx ship-safe@latest audit $ARGUMENTS --deep --budget 100 --json --no-ai 2>/dev/null
```

## Step 3: Interpret deep analysis results

Findings with `deepAnalysis` have LLM-verified taint information:

```json
{
  "deepAnalysis": {
    "tainted": true,
    "sanitized": false,
    "exploitability": "confirmed",
    "reasoning": "User input from req.body flows to SQL query without parameterization"
  }
}
```

Exploitability levels:
- **confirmed**: Clear, unsanitized path from user input to dangerous sink — fix immediately
- **likely**: Probable taint path but LLM could not fully trace it — investigate
- **unlikely**: Taint path exists but sanitization or context makes exploitation difficult
- **false_positive**: No real vulnerability — static value, test code, or properly sanitized

## Step 4: Present results

For each finding with deep analysis:
1. Show the exploitability verdict prominently
2. Include the LLM's reasoning
3. For "confirmed" findings, read the source file and offer a specific fix
4. For "false_positive" findings, note they can be baselined

Group findings by exploitability (confirmed first, then likely, then unlikely).

## Step 5: Cost summary

Show the deep analysis cost:
- Number of findings analyzed
- Approximate cost in cents
- Provider used

## Important Notes

- The `--deep` flag only analyzes critical and high severity findings (cost optimization)
- Default budget is 50 cents — use `--budget` to adjust
- Without an API key or `--local`, deep analysis is silently skipped and you get standard results
- The `--no-ai` flag is intentional — Claude Code is the AI layer; ship-safe's built-in classification is separate from deep taint analysis
ship-safe-baselineSkill

Manage your security baseline — accept current findings as known debt, then only report new regressions on future scans. Use when the user wants to adopt security scanning incrementally or suppress existing findings.

ship-safe-ciSkill

Run Ship Safe in CI mode — compact output, exit codes, SARIF generation. Use when the user wants to set up CI/CD security gates or test their pipeline configuration.

ship-safe-fixSkill

Auto-fix security issues — remediate hardcoded secrets and common vulnerabilities (TLS bypass, debug mode, XSS, shell injection, Docker :latest). Use when the user wants to automatically fix security findings.

ship-safe-hooksSkill

Install ship-safe as real-time Claude Code hooks — blocks secrets and dangerous commands before they land on disk. Use when the user wants automatic security scanning on every file write or bash command.

ship-safe-red-teamSkill

Run a multi-agent red team scan — 29 specialized security agents scan for 80+ attack classes including injection, auth bypass, SSRF, supply chain, Supabase RLS, MCP security, agentic AI, RAG poisoning, PII compliance, and more. Use when the user wants a deep security analysis beyond just secrets.

ship-safe-scanSkill

Quick scan for leaked secrets — API keys, passwords, tokens, database URLs. Use when the user wants to check for hardcoded secrets or exposed credentials.

ship-safe-scoreSkill

Get your project's security health score (0-100, A-F grade). Use when the user wants a quick security check or asks "is my code safe to ship?

ship-safeSkill

Run a full security audit on this project — 16 agents scan for secrets, injections, auth bypass, SSRF, supply chain, Supabase RLS, MCP security, agentic AI, RAG poisoning, PII compliance, and more. Use when the user wants a security audit, vulnerability scan, or asks if their code is safe to ship.