Firebreak

Servidor MCP de segurança que transforma sua IA em um testador de penetração.

Documentação

O servidor MCP de segurança que transforma sua IA em um testador de penetração.

Início Rápido · Como Funciona · Referência de Ferramentas · Contribuindo · Licença

Conecte o Firebreak ao Claude, Cursor ou qualquer cliente compatível com MCP. Depois é só perguntar:

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?

Sem CLI para aprender. Sem relatórios para ler. A IA executa os scans, interpreta os resultados e te guia pelas correções.

Por que Firebreak

Código gerado por IA vem com vulnerabilidades previsíveis: middleware de autenticação inconsistente, políticas RLS permissivas, IDOR em cada endpoint, segredos no bundle JS. Desenvolvedores que usam IA para construir nem sempre sabem como testar o que ela constrói.

O Firebreak inverte o problema. Em vez de esperar que os desenvolvedores aprendam ferramentas de segurança, ele dá à IA as ferramentas de segurança. A mesma IA que escreveu o código agora pode testá-lo, encontrar as falhas e corrigi-las.

O que o torna diferente:

Nativo MCP — não é um wrapper de CLI. Construído do zero para chamadas de ferramentas de IA.
VCVD — 47 padrões de vulnerabilidade específicos para código gerado por IA que scanners tradicionais não detectam.
Prova em vez de teoria — cada achado inclui a requisição/resposta HTTP real que comprova a vulnerabilidade.
Seguro por design — com limite de taxa, escopo bloqueado, não destrutivo. Não pode acidentalmente DROPAR seu banco de dados.

Início Rápido

Opção 1: Compilar a partir do código-fonte

git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
cargo build --release
./target/release/firebreak

Opção 2: Docker

git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
docker compose up -d

De qualquer forma, o Firebreak inicia na porta 9090.

Conectar ao Claude Desktop

Adicione isso ao seu claude_desktop_config.json:

{
  "mcpServers": {
    "firebreak": {
      "url": "http://localhost:9090/mcp"
    }
  }
}

Reinicie o Claude Desktop. Agora você tem 20 ferramentas de segurança disponíveis.

Conectar ao Cursor / Windsurf / Qualquer Cliente MCP

Aponte a configuração MCP do seu cliente para http://localhost:9090/mcp. O servidor fala MCP padrão (JSON-RPC 2.0 sobre HTTP).

Verifique se funciona

Pergunte à sua IA: "Quais ferramentas de segurança você tem disponíveis?"

Ela deve listar as ferramentas do Firebreak. Depois tente: "Escanear https://httpbin.org em busca de problemas de segurança"

Como Funciona

How Firebreak Works

A IA é a orquestradora. O Firebreak não decide o que testar — ele fornece as ferramentas. A IA escolhe a estratégia com base no que o usuário pede e no que encontra pelo caminho.

Fluxo típico

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."

Referência de Ferramentas

Ferramentas de Conhecimento

Elas não acessam nenhum serviço externo. Consultam a base de conhecimento de segurança integrada do Firebreak.

Ferramenta	Descrição	Exemplo
`firebreak_best_practice`	Melhores práticas de segurança para um tópico	`{ topic: "jwt-auth" }`
`firebreak_check_pattern`	Escanear código em busca de padrões inseguros	`{ code: "...", language: "javascript" }`
`firebreak_explain_vuln`	Explicar um tipo de vulnerabilidade	`{ vuln_id: "IDOR" }`
`firebreak_security_checklist`	Gerar uma lista de verificação de segurança	`{ stack: ["nextjs", "supabase"] }`
`firebreak_owasp_check`	Mapear um achado para o OWASP Top 10	`{ description: "SQL injection in login" }`
`firebreak_analyze_rls`	Analisar SQL para problemas de política RLS	`{ sql: "CREATE POLICY..." }`

Ferramentas de Escaneamento

Elas fazem requisições HTTP ao alvo. Com limite de taxa e escopo bloqueado.

Ferramenta	Descrição	Exemplo
`firebreak_scan_quick`	Escaneamento rápido, apenas crítico+alto (2-3 min)	`{ target_url: "https://myapp.com" }`
`firebreak_scan_full`	Teste de penetração completo (caixa preta/cinza/branca)	`{ target_url: "...", mode: "gray", credentials: [...] }`
`firebreak_scan_target`	Escaneamento focado em uma área	`{ target_url: "...", focus: "auth" }`
`firebreak_scan_status`	Verificar o progresso de um escaneamento em andamento	`{ scan_id: "..." }`
`firebreak_scan_stop`	Parar um escaneamento, manter resultados parciais	`{ scan_id: "..." }`

Ferramentas de Análise

Elas trabalham com resultados de escaneamento armazenados. Sem requisições externas.

Ferramenta	Descrição
`firebreak_results`	Resumo do escaneamento com pontuação de segurança (A-F)
`firebreak_finding_detail`	Evidência completa para um achado específico
`firebreak_finding_fix`	Gerar código de correção para um achado
`firebreak_replay`	Re-testar um achado para verificar se foi corrigido
`firebreak_compare`	Comparar dois escaneamentos (corrigido / novo / inalterado)
`firebreak_scan_history`	Listar escaneamentos anteriores para um alvo
`firebreak_attack_chain`	Cadeias de ataque em várias etapas
`firebreak_report_generate`	Exportar relatório (JSON, Markdown, HTML)
`firebreak_report_executive`	Resumo executivo não técnico

Verificações de Escaneamento — 32 Verificações de Segurança

Cada escaneamento executa um subconjunto dessas verificações dependendo do tipo de escaneamento (rápido, completo, direcionado). Cada verificação produz achados com evidência HTTP completa.

Cabeçalhos e TLS

Verificação	O que testa
Cabeçalhos de segurança	Presença de HSTS, X-Content-Type-Options, X-Frame-Options, CSP
Análise de qualidade CSP	unsafe-inline, unsafe-eval, fontes curinga
Permissions-Policy	Presença e configuração do cabeçalho de política de recursos
Divulgação de versão do servidor	Cabeçalhos Server, X-Powered-By, X-AspNet-Version
Vazamentos de cabeçalhos de informação	X-Debug-Token, X-Backend-Server, Via, X-Request-ID
Aplicação de HTTPS	Análise da cadeia de redirecionamento HTTP para HTTPS
Qualidade do HSTS	Valor de max-age, includeSubDomains, diretivas de preload
Cabeçalhos avançados	Cross-Origin-Opener-Policy, Cross-Origin-Resource-Policy, Cross-Origin-Embedder-Policy

Autenticação e Sessão

Verificação	O que testa
Segurança de cookies	Flags HttpOnly, Secure, SameSite em cookies de sessão
Autenticação ausente em endpoints de API	Acesso não autenticado a rotas protegidas
Detecção de limite de taxa	Limitação de login e endpoints de API
Enumeração de métodos HTTP	TRACE, PUT, DELETE habilitados em endpoints que não deveriam permiti-los
Injeção de cabeçalho Host	Cabeçalho Host manipulado refletido em respostas ou redirecionamentos

Dados e API

Verificação	O que testa
Descoberta de API não autenticada	Caminhos comuns de API acessíveis sem credenciais
Detecção de ID sequencial	Risco de IDOR a partir de identificadores de recursos previsíveis
Configuração incorreta de CORS	Reflexão de origem, aceitação de origem nula, curinga com credenciais
Teste de redirecionamento aberto	Parâmetros de redirecionamento não validados em URLs

Conteúdo e Frontend

Verificação	O que testa
Identificação de tecnologia	Detecção de CMS, identificação de framework, software de servidor
Bibliotecas JS vulneráveis	jQuery, Angular, Bootstrap, Lodash com CVEs conhecidos
Exposição de source maps	Arquivos .map acessíveis em produção
Segredos em bundles JS	Chaves de API, tokens, credenciais em JavaScript do lado do cliente
Detecção de conteúdo misto	Recursos HTTP carregados em páginas HTTPS
Análise de CSRF em formulários	Formulários sem tokens CSRF ou usando GET para mudanças de estado

Reconhecimento e Descoberta

Verificação	O que testa
Rastreador web	Links HTML, endpoints JS, sitemap, robots.txt (profundidade recursiva 3)
Sondagem de caminhos sensíveis	Painéis de administração, arquivos de configuração, backups (com validação de conteúdo para eliminar falsos positivos)
robots.txt / sitemap.xml	Análise de caminhos desautorizados e endpoints de sitemap
security.txt	Conformidade com RFC 9116 e informações de contato
Divulgação de página de erro	Stack traces, informações de depuração, caminhos internos em respostas de erro
Descoberta de referências a subdomínios	Subdomínios referenciados em HTML, JS e cabeçalhos
Segurança de cabeçalhos de cache	Cache-Control, Pragma, Expires em respostas sensíveis

VCVD — Banco de Dados de Vulnerabilidades de Vibe Coding

47 padrões de vulnerabilidade que o código gerado por IA erra. Scanners tradicionais não procuram por eles porque são específicos de como LLMs escrevem código.

Autenticação e Identidade

ID	Padrão	Severidade
VC-AUTH-001	Middleware de autenticação inconsistente — IA aplica autenticação a algumas rotas, mas não a outras	CRÍTICO
VC-AUTH-002	Validação apenas no cliente — verificações de papel existem no React, mas não na API	CRÍTICO
VC-AUTH-003	JWT decodificado sem verificação — `jwt.decode()` em vez de `jwt.verify()`	CRÍTICO
VC-AUTH-004	Chave de serviço no código do cliente — chave `service_role` do Supabase no bundle JS	CRÍTICO
VC-AUTH-005	Expiração de token >30 dias — "por conveniência"	ALTO
VC-AUTH-006	OAuth sem parâmetro de estado	ALTO
VC-AUTH-007	Senha na string de consulta da URL	ALTO
VC-AUTH-008	Sessão não regenerada após login	MÉDIO

Acesso a Dados

ID	Padrão	Severidade
VC-DATA-001	IDOR — IDs sequenciais sem verificação de propriedade	CRÍTICO
VC-DATA-002	`USING (true)` em RLS — política "temporária" da IA que vai para produção	CRÍTICO
VC-DATA-003	Tabela criada sem habilitar RLS	CRÍTICO
VC-DATA-004	`SELECT *` expondo hashes de senha e PII	ALTO
VC-DATA-005	`...req.body` espalhado em inserção de banco sem lista branca de campos	ALTO
VC-DATA-006	Introspecção GraphQL habilitada em produção	MÉDIO
VC-DATA-007	Consultas N+1 sem limite como vetor de DoS	MÉDIO
VC-DATA-008	Consultas multi-tenant sem filtro `tenant_id`	CRÍTICO

Injeção

ID	Padrão	Severidade
VC-INJ-001	Template literals em consultas SQL	CRÍTICO
VC-INJ-002	`innerHTML` com entrada do usuário	ALTO
VC-INJ-003	Conteúdo do usuário armazenado e renderizado sem sanitização	CRÍTICO
VC-INJ-004	Entrada do usuário em `exec()` / `spawn()`	CRÍTICO
VC-INJ-005	Caminhos de arquivo construídos a partir de entrada do usuário	ALTO
VC-INJ-006	Fetch no servidor com URL fornecida pelo usuário (SSRF)	ALTO
VC-INJ-007	Entrada do usuário passada como fonte de template	ALTO
VC-INJ-008	Operadores MongoDB em entrada JSON	ALTO

Infraestrutura

ID	Padrão	Severidade
VC-INFRA-001	Modo de depuração / stack traces em produção	ALTO
VC-INFRA-002	`Access-Control-Allow-Origin: *` com credenciais	ALTO
VC-INFRA-003	Ausência de HSTS, X-Frame-Options, CSP	MÉDIO
VC-INFRA-004	Portas Docker desnecessárias expostas	MÉDIO
VC-INFRA-005	Uploads de usuários armazenados sem criptografia	MÉDIO
VC-INFRA-006	TLS 1.0/1.1 ainda habilitado	MÉDIO
VC-INFRA-007	Painel de administração acessível pela internet pública	ALTO
VC-INFRA-008	Credenciais padrão inalteradas	CRÍTICO

Frontend

ID	Padrão	Severidade
VC-FE-001	Chaves de API no bundle JavaScript	CRÍTICO
VC-FE-002	Guarda de autenticação apenas no React Router, não na API	ALTO
VC-FE-003	JWT armazenado em `localStorage`	MÉDIO
VC-FE-004	Formulários sem proteção CSRF	ALTO
VC-FE-005	URL de redirecionamento de parâmetro de consulta sem validação	MÉDIO
VC-FE-006	Handler `postMessage` sem verificação de origem	MÉDIO
VC-FE-007	Source maps acessíveis em produção	BAIXO
VC-FE-008	Campos sensíveis sem `autocomplete="off"`	BAIXO

Pontuação de Segurança

Cada escaneamento produz uma nota com base no que foi encontrado:

Nota	Critérios	Interpretação
A	Zero crítico ou alto. Máximo 2 médios.	Pode lançar.
B	Zero crítico. Alguns altos ou médios.	Corrija os altos em breve.
C	Múltiplos problemas de alta gravidade.	Precisa de trabalho antes da produção.
D	1-2 críticos ou >5 altos.	Risco significativo. Priorize correções.
F	3+ críticos ou uma cadeia completa de comprometimento.	Não faça deploy.

Salvaguardas de Segurança

O Firebreak é projetado apenas para testes autorizados.

Salvaguarda	Como funciona
Limitação de taxa	10 requisições/segundo ao alvo (configurável). Janela deslizante.
Bloqueio de escopo	Ataca apenas a URL alvo especificada. Sem movimento lateral, sem enumeração de subdomínios.
Não destrutivo	Sem requisições DELETE, DROP, UPDATE ou POST que modifiquem dados. Apenas sondagem.
Consentimento	A IA pede confirmação antes da primeira varredura.
Trilha de auditoria	Cada requisição HTTP é registrada com timestamp, alvo e motivo.

Configuração

Variáveis de ambiente:

Variável	Padrão	Descrição
`FIREBREAK_HOST`	`0.0.0.0`	Endereço de bind
`FIREBREAK_PORT`	`9090`	Porta
`RUST_LOG`	`firebreak=info`	Nível de log

Copie .env.example para .env e edite conforme necessário.

Estrutura do Projeto

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

Pilha Tecnológica

Componente	Tecnologia	Porquê
Linguagem	Rust	Binário único, sem runtime, seguro em memória, rápido
Servidor HTTP	Axum	Assíncrono, ecossistema de middleware tower
Cliente HTTP	reqwest	Maduro, suporte a TLS, controle de redirecionamento
Banco de dados	SQLite (rusqlite)	Zero configuração, embutido, suficiente para varreduras locais
Parser SQL	sqlparser-rs	Análise de políticas RLS sem banco de dados em execução
Runtime assíncrono	tokio	Padrão da indústria
Serialização	serde + serde_json	Rápido, macros derivadas
Dashboard	React + TypeScript + Vite + Tailwind	Moderno, servidor de desenvolvimento rápido, CSS utilitário

O binário de release tem ~8 MB sem dependências de runtime.

Contribuindo

Contribuições são bem-vindas. Veja como participar:

Começando

git clone https://github.com/protonese3/Firebreak.git
cd Firebreak
cargo build
cargo test

O servidor roda em http://localhost:9090/mcp por padrão.

Áreas onde ajuda é necessária

Novos padrões VCVD — Encontrou um padrão de vulnerabilidade que a IA gera consistentemente? Adicione-o em src/vcvd/data.rs. Cada padrão precisa de um ID, descrição, severidade, dica de detecção e correção.

Verificações do mecanismo de varredura — Adicione novas verificações de vulnerabilidade em src/engine/checks.rs. Cada função de verificação recebe um cliente reqwest, URL alvo e referência de segurança. Retorne um Vec<Finding>.

Guias de melhores práticas — Adicione arquivos markdown em knowledge/best-practices/. Depois registre-os em src/tools/knowledge/best_practices.rs.

Correções específicas de framework — A ferramenta finding_fix gera código de correção. Adicione suporte a frameworks em src/tools/analysis.rs na função framework_fix_example.

Dashboard — O frontend React fica em frontend/. Execute npm run dev para o servidor de desenvolvimento.

Enviando alterações

Faça um fork do repositório
Crie uma branch (git checkout -b add-new-check)
Faça suas alterações
Execute cargo check && cargo clippy -- -D warnings
Abra um pull request com uma descrição clara do que você mudou e porquê

Estilo de código

Sem comentários desnecessários. Se o código diz o que faz, não adicione um comentário.
Cláusulas de guarda em vez de if/else aninhados.
Siga o estilo do código existente.
Cada achado deve ter evidência verificável — nada de "isso pode ser vulnerável."

Reportando problemas de segurança

Se você encontrar uma vulnerabilidade de segurança no próprio Firebreak, envie um e-mail para security@firebreak.dev em vez de abrir um issue público. Responderemos em até 48 horas.

Roadmap

Concluído

Próximos

Dashboard web (React)
Varredura gray-box com sessões autenticadas
Navegador headless para aplicações renderizadas no frontend
Varreduras agendadas / recorrentes
Notificações via webhook (Slack, Discord)
Exportação de relatórios em PDF
Opção hospedada em nuvem (VPS gerenciado)
Sistema de plugins para verificações personalizadas
Contribuições da comunidade VCVD via PR

FAQ

Preciso ser especialista em segurança para usar isso? Não. Esse é o ponto. A IA cuida da expertise em segurança. Você só diz o que testar.

Quais clientes MCP funcionam com o Firebreak? Qualquer cliente que suporte MCP sobre HTTP: Claude Desktop, Claude Code, Cursor, Windsurf e outros.

É seguro executar contra produção? O Firebreak é não destrutivo (sondagem somente leitura), mas você deve sempre testar primeiro em staging. A limitação de taxa está ativada por padrão.

Posso adicionar minhas próprias verificações de vulnerabilidade? Sim. Adicione funções de verificação em src/engine/checks.rs e conecte-as aos métodos de varredura em src/engine/mod.rs.

Por que Rust? Binário único sem dependências de runtime. Rápido. Seguro em memória. Entregamos um arquivo e ele funciona.

Por que AGPL-3.0? Se você executar o Firebreak como um serviço para outros, deve compartilhar suas modificações. Se você usar internamente ou auto-hospedar para sua própria equipe, não precisa fazer nada de especial.

Licença

AGPL-3.0

Se você construir um serviço comercial em cima do Firebreak, a AGPL exige que você abra o código-fonte de suas modificações. Para uso interno e auto-hospedado, sem restrições além dos termos padrão da AGPL.

20 Ferramentas de Segurança · 100 Guias de Melhores Práticas · 47 Padrões de Vulnerabilidade · 32 Verificações de Varredura

FIREBREAK — Porque se você não testar, outra pessoa vai.