What is VulnHunter?
VulnHunter is a ground-truth-blind repository vulnerability scanner that combines four analysis layers into a single pipeline:
-
Deterministic AST rules — 30+ pattern-based detectors (VH100–VH128) covering SQL injection, command injection, XSS, SSRF, path traversal, weak cryptography, insecure randomness, timing attacks, CSRF, CORS misconfiguration, JWT bypass, NoSQL injection, unrestricted file uploads, and more.
-
Interprocedural taint analysis — 17+ native flow rules (VHNF100–VHNF117) that track data from sources (HTTP parameters, request bodies, file uploads) through function calls, assignments, and returns to security-sensitive sinks (SQL queries, shell commands, file paths, email headers).
-
Supply-chain analysis (SCA) — Integration with ca9, the supply-chain engine behind Skylos, to detect dependency confusion, untrusted registries, known malware, provenance regression, and suspicious releases in your dependency tree.
-
LLM-assisted investigation — A Hunter loop that uses large language models for deeper investigation beyond what static rules can find, with multi-model verification for higher confidence.
VulnHunter never executes target repository code. All analysis is static.
Detection Architecture
AST Rule Engine
The Python rule engine parses every Python file in the repository using tree-sitter, builds a cross-file import graph, and dispatches each function through 30+ detection methods. Import alias resolution means VulnHunter catches vulnerabilities regardless of how libraries are imported:
# All of these are caught as VH100 (command injection):
import os; os.system(user_input)
from os import system; system(user_input)
from os import system as run; run(user_input)
Rules include fast-path filters that skip functions whose source text cannot contain a match, keeping scan times practical on large repositories.
Interprocedural Taint Analysis
The native flow engine lowers Python, JavaScript, TypeScript, and Go source into an intermediate representation (IR) and runs bounded taint propagation from attacker-controlled sources to security-sensitive sinks. This catches vulnerabilities that span multiple files and function calls — the category most often missed by pattern-matching tools.
Supported sink categories include command execution, SQL queries, code evaluation, file system operations, HTML responses, HTTP redirects, LDAP filters, XPath expressions, deserialization, HTTP headers, log injection, regex injection, and email header injection.
Supply-Chain Analysis
Through ca9 integration, VulnHunter checks your declared dependencies against:
- Dependency confusion — internal package names resolvable on public registries
- Known malware — packages matching the ca9 malware feed
- Provenance regression — versions missing attestation that earlier versions had
- Untrusted registries — dependencies installed from non-standard indexes
- New package versions — recently published releases that may not yet be vetted
- Suspicious releases — versions flagged by automated sentinel analysis
Multi-Model Architecture
VulnHunter supports multiple LLM providers for its investigation and verification pipeline:
| Role | Default (xAI) | Default (Anthropic) |
|---|---|---|
| Controller/Investigator | Grok grok-4.7 | Claude Opus 4.6 |
| Worker | Grok grok-4.7 | Claude Opus 5.5 |
| Verifier | Grok grok-4.7 | Claude Mythos 5.1 |
When using Anthropic models, VulnHunter automatically assigns different models to different pipeline roles. The verifier uses a distinct model (Mythos 5.1) from the investigator, providing independent cross-model verification that reduces false positives without reducing recall.
Model selection follows a clear priority chain: explicit CLI argument → environment variable → role-based defaults → base model.
Benchmark Results
On a synthetic benchmark suite with 63+ planted vulnerabilities across injection, cryptography, authentication, file handling, DoS, and logic categories:
| Scanner | Detection Rate |
|---|---|
| VulnHunter | 95.2% |
| Semgrep | 58.7% |
| Bandit | 50.8% |
VulnHunter's advantage comes from interprocedural analysis and rules that cover vulnerability classes other scanners lack entirely, such as timing attacks, CORS misconfiguration, CSRF bypass, weak credential detection, and stack trace exposure.
Blind CVE Validation
To validate real-world effectiveness, VulnHunter was tested blind against pyLoad at a commit known to contain CVE-2025-55156 (SQL injection), without any hints about the vulnerability type or location. VulnHunter identified the SQL injection at file_database.py:271 with HIGH confidence as one of 99 findings across the 559-file repository.
Getting Started
pip install vulnhunter
# Quick static scan (no LLM required)
vulnhunter scan /path/to/repo --mode quick
# Deep scan with LLM investigation (requires XAI_API_KEY or ANTHROPIC_API_KEY)
vulnhunter scan /path/to/repo
# Disable SCA if ca9 is not needed
vulnhunter scan /path/to/repo --mode quick --no-sca
# Review only changed files between commits
vulnhunter review /path/to/repo --base main --mode quick
Output formats include human-readable text, JSON, and SARIF for integration with CI/CD pipelines and code review tools.
What VulnHunter Does Not Do
VulnHunter is a static scanner. It does not:
- Execute target repository code
- Perform dynamic analysis or fuzzing
- Generate exploit payloads
- Modify the scanned repository
Every finding includes evidence (source locations, taint paths, rule references) so that developers can verify and remediate without guesswork.