Traditional SAST scanners dump CVE lists with 90%+ false positives. VulnHunter does the opposite: it reasons like an adversary, identifies which defects are actually exploitable, maps attack paths, writes proof-of-concept exploits, then generates targeted, test-driven fixes. Built as Claude Code skills. Open-sourced under Apache 2.0. 207+ GitHub stars and trending.
# Traditional Scanners Are Broken
Every security team knows the drill. Run the scanner. Get 400 findings. Spend weeks triaging. 90% are false positives. Traditional scanners produce 300-500 findings per scan. Teams spend 40+ hours triaging each batch. The real exploit sits on page 12 of a PDF nobody reads.
A REAL EXAMPLE - SPOT THE VULNERABILITY:
@app.route("/api/export", methods=["POST"]) def export_report(): data = request.get_json() target_url = data.get("target_url") # User-controlled! # Fetch the remote resource for PDF rendering response = httpx.get(target_url, # No validation headers={"Authorization": SERVICE_TOKEN}) return generate_pdf(response.content)
CWE-918: Server-Side Request Forgery Severity: Medium File: export_handler.py:7 Rule: http-request-user-input
- ✗ Pattern matching - no exploitability context
- ✗ 90%+ false positives - buried in 387 findings
- ✗ Generic fix - "update dependency" with no proof
CONFIRMED EXPLOITABLE: SSRF via /api/export
Attack: target_url accepts arbitrary URLs
Impact: attacker reads cloud metadata
at 169.254.169.254
PoC: Included (verified working)
Fix: URL allowlist + validation (attached)
Test: Regression test (attached) - ✓ Adversarial reasoning with attack path mapping
- ✓ PoC exploit that proves the bug is real
- ✓ Targeted fix with regression test attached
The difference is fundamental. One is a search engine for known patterns. The other thinks like a pentester and proves its findings before reporting them.
# The Three-Skill Architecture
VulnHunter is built as Claude Code skills - SKILL.md files that instruct the agent how to reason. Three skills form the core pipeline. Each one handles a distinct phase of the security analysis.
A SKILL.md file with phased reasoning instructions. The agent reads the entire codebase, identifies entry points (auth flows, file uploads, API endpoints, deserialization, SQL queries), then reasons about exploitability. It follows data flows across function boundaries - if a sanitizer exists upstream, the agent recognizes the bug is not reachable.
Companion skill backed by a Python helper package. Generates not just a code patch but a regression test that replays the original PoC to confirm the fix works. Every remediation is evidence-backed and targeted to the specific vulnerability, not a generic "add input validation" recommendation.
Re-runs the original PoC exploit against the patched code. If the exploit still works, the fix is rejected and the cycle restarts. This closes the loop - no fix ships without proof that the vulnerability is actually neutralized. The verification skill operates independently so it can be run separately from the fix generation step.
Config-driven headless runtime for automated security scanning on every push. Connects via direct Anthropic API, clones target repos, runs scans, and opens GitHub issues with full findings. Drop into your pipeline as a GitHub Action or standalone job.
# How It Actually Works
This is not "run regex, dump findings." VulnHunter's agent chains multi-step reasoning the same way a human pentester would approach a target. Here is a complete walkthrough using the SSRF vulnerability from above.
Scanning codebase for attack surface... Found 14 route handlers across 6 modules Analyzing /api/export (POST) - user-controlled: target_url Tracing: request.body.target_url -> httpx.get(target_url) No URL validation. No allowlist. No SSRF protection. Exploitability analysis: target_url accepts arbitrary URLs (no scheme filter) httpx.get() follows redirects, sends SERVICE_TOKEN header Service on AWS EC2 - metadata at 169.254.169.254 reachable VERDICT: EXPLOITABLE - CRITICAL Impact: Cloud metadata -> IAM creds -> account compromise
# VulnHunter-generated PoC exploit curl -X POST http://target-app:8080/api/export \ -H "Content-Type: application/json" \ -d '{ "target_url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/" }' # Response: IAM role name + temporary credentials # Attacker now has AWS access with the service's permissions
User Input (target_url) -> API Handler (/api/export) -> HTTP Client (+SERVICE_TOKEN) -> Internal Network (no egress filter) -> Cloud Metadata (169.254.169.254) -> IAM Credentials (full cloud account compromise)
from urllib.parse import urlparse ALLOWED_HOSTS = {"reports.internal.co", "cdn.company.com"} def validate_export_url(url: str) -> bool: parsed = urlparse(url) if parsed.scheme != "https": return False if parsed.hostname not in ALLOWED_HOSTS: return False return True @app.route("/api/export", methods=["POST"]) def export_report(): data = request.get_json() target_url = data.get("target_url") if not validate_export_url(target_url): abort(400, "URL not in allowlist") response = httpx.get(target_url, headers=...) return generate_pdf(response.content)
Re-running PoC exploit against patched code... POST /api/export with target_url=http://169.254.169.254/... Response: 400 Bad Request - "URL not in allowlist" RESULT: EXPLOIT BLOCKED test_ssrf_metadata_blocked PASSED test_valid_export_url_works PASSED VERIFICATION COMPLETE - Fix confirmed effective
Every finding comes with a working PoC exploit. If VulnHunter cannot prove it is exploitable, it does not report it.
Built and optimized for Claude Opus 4.8. Multi-step adversarial reasoning needs frontier-class models to work reliably.
# Why This Changes Security
Capital One did not build VulnHunter because existing tools were slightly inadequate. They built it because the entire paradigm of scanning was wrong. They needed something that thinks, not something that scans.
VulnHunter does offensive security reasoning - it thinks like an attacker. This may trigger AI safety guardrails. Anthropic's Cyber Verification Program enrollment is recommended. Without it, the agent may refuse to generate PoC exploits.
Built as Claude Code skills, VulnHunter integrates directly into the editor. Run /vulnhunt the same way you run a linter. Security becomes part of the development loop, not a separate team's quarterly audit.
Instead of triaging 400 findings, teams get 5-10 confirmed exploitable bugs with working PoCs and verified fixes. Traditional SAST takes days of triage. VulnHunter takes hours of automated reasoning.
# Try It
VulnHunter is Apache 2.0 licensed. Clone it, install the skills into Claude Code, point it at your repo.
- ● Claude Code with Anthropic API key + Claude Opus 4.8
- ● Cyber Verification Program enrollment (avoids safeguard blocks on offensive reasoning)
- ● Python 3.10+ for the vulnhunter-fix helper package
git clone https://github.com/capitalone/vulnhunter.git && cd vulnhunter # Copy skill files to your project's .claude/ directory # /vulnhunt /vulnhunter-fix /vulnhunt-fix-verify # Run a scan (in Claude Code): /vulnhunt scan the /src directory for exploitable vulnerabilities # Or headless via vulnhunter-agent/ for CI/CD automation
$ /vulnhunt scan ./src [Phase 1] Reading codebase... 23 entry points across 12 modules [Phase 2] Analyzing data flows... 7 candidates evaluated [Phase 3] Generating PoC exploits for confirmed findings... SCAN COMPLETE: 3 exploitable vulnerabilities found CRITICAL SSRF via /api/export (CWE-918) PoC: included | Fix: available | Test: included HIGH SQL Injection in /api/users/search (CWE-89) PoC: included | Fix: available | Test: included MEDIUM Path Traversal in /api/files/download (CWE-22) PoC: included | Fix: available | Test: included
The harness/ directory supports batch scanning multiple repos and benchmarking accuracy against known vulnerability datasets. Measure precision and recall before rolling VulnHunter into your CI pipeline.
- ● Frontier Opus-class models required - expensive. Budget higher API costs.
- ● Early stage - scanning quality depends on Claude Opus reasoning. Results may vary across languages and codebases.
- ● Early stage - 207 stars, 3 contributors. Not yet battle-tested at massive scale.
- ● Slower than SAST - adversarial reasoning takes minutes, not seconds.
SAST scanners are dead. They were built for a world where pattern matching was the best you could do. VulnHunter is what happens when you let an agent reason instead of regex-match. It thinks like an attacker, proves the bug is real, and hands you a verified fix. Capital One did not just open-source a tool. They open-sourced a new category.
Ring-Zero: Your Model Has Context Anxiety and Nobody Programmed It
Ant Group scaled Zero RL to 1 trillion parameters. Five cognitive behaviors emerged that nobody coded - including a model that panics about running out of tokens.
Enjoyed this?
New episodes Mon, Wed, Sat.