Connect Firebreak to Claude, Cursor, or any MCP-compatible client. Then just ask:
You: "Is my app secure?"
Claude: [calls firebreak tools] Found 6 vulnerabilities. 1 high (CORS misconfiguration),
5 medium (missing security headers). Security score: B. Want me to fix them?
No CLI to learn. No reports to read. The AI runs the scans, interprets the results, and walks you through the fixes.
Why Firebreak
AI-generated code ships with predictable vulnerabilities: inconsistent auth middleware, permissive RLS policies, IDOR on every endpoint, secrets in the JS bundle. Developers who use AI to build don't always know how to test what it builds.
Firebreak flips the problem. Instead of expecting developers to learn security tooling, it gives the AI the security tooling. The same AI that wrote the code can now test it, find the holes, and fix them.
What makes it different:
- MCP-native — not a CLI wrapper. Built from the ground up for AI tool calling.
- VCVD — 47 vulnerability patterns specific to AI-generated code that traditional scanners miss.
- Proof over theory — every finding includes the actual HTTP request/response that proves the vulnerability.
- Safe by design — rate limited, scope-locked, non-destructive. Can't accidentally DROP your database.
Quick Start
Option 1: Build from source
git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
cargo build --release
./target/release/firebreak
Option 2: Docker
git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
docker compose up -d
Either way, Firebreak starts on port 9090.
Connect to Claude Desktop
Add this to your claude_desktop_config.json:
{
"mcpServers": {
"firebreak": {
"url": "http://localhost:9090/mcp"
}
}
}
Restart Claude Desktop. You now have 20 security tools available.
Connect to Cursor / Windsurf / Any MCP Client
Point your client's MCP configuration to http://localhost:9090/mcp. The server speaks standard MCP (JSON-RPC 2.0 over HTTP).
Verify it works
Ask your AI: "What security tools do you have available?"
It should list the Firebreak tools. Then try: "Scan https://httpbin.org for security issues"
How It Works
The AI is the orchestrator. Firebreak doesn't decide what to test — it provides the tools. The AI picks the strategy based on what the user asks and what it finds along the way.
Typical flow
1. User: "Test my app at https://myapp.com"
2. AI calls firebreak_scan_quick({ target_url: "https://myapp.com" })
└── Firebreak probes headers, paths, CORS, TLS
└── Returns: 4 findings, score B
3. AI explains results in plain language
└── "Found a CORS misconfiguration and 3 missing headers..."
4. User: "Fix the CORS issue"
5. AI calls firebreak_finding_fix({ finding_id: "...", framework: "express" })
└── Returns: before/after code diff for Express
6. User applies fix
7. AI calls firebreak_replay({ finding_id: "..." })
└── Returns: "Fixed. Server no longer reflects arbitrary origins."
Tool Reference
Knowledge Tools
These don't hit any external service. They query Firebreak's built-in security knowledge base.
Scan Tools
These make HTTP requests to the target. Rate limited and scope-locked.
Analysis Tools
These work with stored scan results. No external requests.
Scan Checks — 32 Security Checks
Every scan runs a subset of these checks depending on the scan type (quick, full, targeted). Each check produces findings with full HTTP evidence.
Headers & TLS
Authentication & Session
Data & API
Content & Frontend
Recon & Discovery
VCVD — Vibe Coding Vulnerability Database
47 vulnerability patterns that AI-generated code gets wrong. Traditional scanners don't look for these because they're specific to how LLMs write code.
Auth & Identity
Data Access
Injection
Infrastructure
Frontend
Security Scoring
Every scan produces a letter grade based on what was found:
Safety Guardrails
Firebreak is designed for authorized testing only.
Configuration
Environment variables:
Copy .env.example to .env and edit as needed.
Project Structure
firebreak/
├── src/
│ ├── main.rs # Axum HTTP server, AppState, routing
│ ├── types.rs # Shared types: Scan, Finding, Evidence, ScanSummary
│ │
│ ├── mcp/ # MCP protocol implementation
│ │ ├── protocol.rs # JSON-RPC 2.0 types
│ │ └── handler.rs # Request dispatch (initialize, tools/list, tools/call)
│ │
│ ├── tools/ # MCP tool implementations
│ │ ├── knowledge/ # Knowledge tools (best practices, pattern check, OWASP)
│ │ ├── scan.rs # Scan tools (quick, full, targeted, status, stop)
│ │ └── analysis.rs # Analysis tools (results, fix, replay, compare, reports)
│ │
│ ├── engine/ # HTTP scanning engine
│ │ ├── mod.rs # Scan orchestration (quick/full/targeted/replay)
│ │ └── checks.rs # 32 security checks (headers, TLS, auth, CORS, cookies, IDOR...)
│ │
│ ├── vcvd/ # Vibe Coding Vulnerability Database
│ │ └── data.rs # 47 patterns with descriptions, detection, fixes
│ │
│ ├── store/ # SQLite persistence
│ │ └── mod.rs # CRUD for scans, findings, audit log
│ │
│ ├── safety/ # Safety guardrails
│ │ └── mod.rs # Rate limiter, scope lock, consent, audit trail
│ │
│ ├── rls/ # RLS policy analyzer
│ │ └── mod.rs # SQL parsing with sqlparser-rs
│ │
│ └── report/ # Report generation
│ └── mod.rs # JSON, Markdown, HTML, executive summary
│
├── knowledge/
│ └── best-practices/ # 100 security guides (JWT, RLS, CORS, uploads, CSP...)
│
├── frontend/ # React dashboard (Vite + TypeScript + Tailwind)
│
├── Dockerfile # Multi-stage build, non-root user
├── docker-compose.yml # Firebreak + headless Chromium
└── .github/workflows/ci.yml # Build, test, lint, artifacts
Tech Stack
The release binary is ~8 MB with no runtime dependencies.
Contributing
Contributions are welcome. Here's how to get involved:
Getting started
git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
cargo build
cargo test
The server runs on http://localhost:9090/mcp by default.
Areas where help is needed
New VCVD patterns — Found a vulnerability pattern that AI consistently generates? Add it to src/vcvd/data.rs. Each pattern needs an ID, description, severity, detection hint, and fix.
Scan engine checks — Add new vulnerability checks in src/engine/checks.rs. Each check function takes a reqwest client, target URL, and safety reference. Return a Vec<Finding>.
Best practice guides — Add markdown files to knowledge/best-practices/. Then register them in src/tools/knowledge/best_practices.rs.
Framework-specific fixes — The finding_fix tool generates fix code. Add framework support in src/tools/analysis.rs in the framework_fix_example function.
Dashboard — The React frontend lives in frontend/. Run npm run dev for the dev server.
Submitting changes
- Fork the repo
- Create a branch (
git checkout -b add-new-check) - Make your changes
- Run
cargo check && cargo clippy -- -D warnings - Open a pull request with a clear description of what you changed and why
Code style
- No unnecessary comments. If the code says what it does, don't add a comment.
- Guard clauses over nested if/else.
- Match the style of existing code.
- Every finding must have verifiable evidence — no "this might be vulnerable."
Reporting security issues
If you find a security vulnerability in Firebreak itself, please email [email protected] instead of opening a public issue. We'll respond within 48 hours.
Roadmap
Done
- MCP server with JSON-RPC 2.0 over HTTP
- 20 MCP tools (knowledge, scan, analysis, report)
- VCVD v1 — 47 vulnerability patterns
- HTTP scanning engine with 32 security checks
- SQLite persistence
- Safety guardrails
- Report generation (JSON, Markdown, HTML)
- RLS policy analyzer (sqlparser-rs)
- Docker support
- CI/CD pipeline
- Web crawler for endpoint discovery
- False positive elimination (content validation, baseline comparison)
- Technology fingerprinting
- Cookie/session security analysis
- Form CSRF detection
- Open redirect testing
- CSP quality analysis
- Rate limiting detection
Next
- Web dashboard (React)
- Gray-box scanning with authenticated sessions
- Headless browser for frontend-rendered apps
- Scheduled / recurring scans
- Webhook notifications (Slack, Discord)
- PDF report export
- Cloud-hosted option (managed VPS)
- Plugin system for custom checks
- VCVD community contributions via PR
FAQ
Do I need to be a security expert to use this? No. That's the point. The AI handles the security expertise. You just tell it what to test.
What MCP clients work with Firebreak? Any client that supports MCP over HTTP: Claude Desktop, Claude Code, Cursor, Windsurf, and others.
Is it safe to run against production? Firebreak is non-destructive (read-only probing), but you should always test against staging first. Rate limiting is on by default.
Can I add my own vulnerability checks?
Yes. Add check functions in src/engine/checks.rs and wire them into the scan methods in src/engine/mod.rs.
Why Rust? Single binary with no runtime dependencies. Fast. Memory safe. We ship one file and it works.
Why AGPL-3.0? If you run Firebreak as a service for others, you must share your modifications. If you use it internally or self-host for your own team, you don't need to do anything special.
License
If you build a commercial service on top of Firebreak, the AGPL requires you to open-source your modifications. For internal and self-hosted use, no restrictions beyond the standard AGPL terms.