Firebreak

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.

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.

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

1. Fork the repo
2. Create a branch (git checkout -b add-new-check)
3. Make your changes
4. Run cargo check && cargo clippy -- -D warnings
5. 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 security@firebreak.dev 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

License

AGPL-3.0

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.

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"

Configuration

Environment variables:

Copy .env.example to .env and edit as needed.

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.