Firebreak

Servidor MCP de seguridad que convierte tu IA en un probador de penetración.

Documentación

El servidor MCP de seguridad que convierte tu IA en un probador de penetración.

Inicio Rápido · Cómo Funciona · Referencia de Herramientas · Contribuciones · Licencia

Conecta Firebreak a Claude, Cursor o cualquier cliente compatible con MCP. Luego solo pregunta:

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?

Sin CLI que aprender. Sin informes que leer. La IA ejecuta los escaneos, interpreta los resultados y te guía en las correcciones.

Por qué Firebreak

El código generado por IA viene con vulnerabilidades predecibles: middleware de autenticación inconsistente, políticas RLS permisivas, IDOR en cada endpoint, secretos en el bundle de JavaScript. Los desarrolladores que usan IA para construir no siempre saben cómo probar lo que construye.

Firebreak invierte el problema. En lugar de esperar que los desarrolladores aprendan herramientas de seguridad, le da a la IA las herramientas de seguridad. La misma IA que escribió el código ahora puede probarlo, encontrar los agujeros y corregirlos.

Qué lo hace diferente:

Nativo de MCP — no es un envoltorio de CLI. Construido desde cero para la llamada de herramientas de IA.
VCVD — 47 patrones de vulnerabilidad específicos del código generado por IA que los escáneres tradicionales pasan por alto.
Prueba sobre teoría — cada hallazgo incluye la solicitud/respuesta HTTP real que demuestra la vulnerabilidad.
Seguro por diseño — con límite de velocidad, bloqueo de alcance y no destructivo. No puede eliminar tu base de datos por accidente.

Inicio Rápido

Opción 1: Compilar desde el código fuente

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

Opción 2: Docker

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

De cualquier manera, Firebreak se inicia en el puerto 9090.

Conectar a Claude Desktop

Agrega esto a tu claude_desktop_config.json:

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

Reinicia Claude Desktop. Ahora tienes 20 herramientas de seguridad disponibles.

Conectar a Cursor / Windsurf / Cualquier Cliente MCP

Apunta la configuración MCP de tu cliente a http://localhost:9090/mcp. El servidor habla MCP estándar (JSON-RPC 2.0 sobre HTTP).

Verificar que funciona

Pregunta a tu IA: "¿Qué herramientas de seguridad tienes disponibles?"

Debería listar las herramientas de Firebreak. Luego intenta: "Escanea https://httpbin.org en busca de problemas de seguridad"

Cómo Funciona

How Firebreak Works

La IA es la orquestadora. Firebreak no decide qué probar — proporciona las herramientas. La IA elige la estrategia según lo que el usuario pide y lo que encuentra en el camino.

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

Referencia de Herramientas

Herramientas de Conocimiento

Estas no acceden a ningún servicio externo. Consultan la base de conocimiento de seguridad integrada de Firebreak.

Herramienta	Descripción	Ejemplo
`firebreak_best_practice`	Mejores prácticas de seguridad para un tema	`{ topic: "jwt-auth" }`
`firebreak_check_pattern`	Escanear código en busca de patrones inseguros	`{ code: "...", language: "javascript" }`
`firebreak_explain_vuln`	Explicar un tipo de vulnerabilidad	`{ vuln_id: "IDOR" }`
`firebreak_security_checklist`	Generar una lista de verificación de seguridad	`{ stack: ["nextjs", "supabase"] }`
`firebreak_owasp_check`	Mapear un hallazgo al OWASP Top 10	`{ description: "SQL injection in login" }`
`firebreak_analyze_rls`	Analizar SQL para problemas de políticas RLS	`{ sql: "CREATE POLICY..." }`

Herramientas de Escaneo

Estas hacen solicitudes HTTP al objetivo. Con límite de velocidad y bloqueo de alcance.

Herramienta	Descripción	Ejemplo
`firebreak_scan_quick`	Escaneo rápido, solo crítico+alto (2-3 min)	`{ target_url: "https://myapp.com" }`
`firebreak_scan_full`	Prueba de penetración completa (caja negra/gris/blanca)	`{ target_url: "...", mode: "gray", credentials: [...] }`
`firebreak_scan_target`	Escaneo enfocado en un área	`{ target_url: "...", focus: "auth" }`
`firebreak_scan_status`	Verificar el progreso de un escaneo en ejecución	`{ scan_id: "..." }`
`firebreak_scan_stop`	Detener un escaneo, conservar resultados parciales	`{ scan_id: "..." }`

Herramientas de Análisis

Estas trabajan con resultados de escaneo almacenados. Sin solicitudes externas.

Herramienta	Descripción
`firebreak_results`	Resumen del escaneo con puntuación de seguridad (A-F)
`firebreak_finding_detail`	Evidencia completa para un hallazgo específico
`firebreak_finding_fix`	Generar código de corrección para un hallazgo
`firebreak_replay`	Re-probar un hallazgo para verificar que está corregido
`firebreak_compare`	Comparar dos escaneos (corregido / nuevo / sin cambios)
`firebreak_scan_history`	Listar escaneos anteriores para un objetivo
`firebreak_attack_chain`	Cadenas de ataque de múltiples pasos
`firebreak_report_generate`	Exportar informe (JSON, Markdown, HTML)
`firebreak_report_executive`	Resumen ejecutivo no técnico

Verificaciones de Escaneo — 32 Verificaciones de Seguridad

Cada escaneo ejecuta un subconjunto de estas verificaciones según el tipo de escaneo (rápido, completo, dirigido). Cada verificación produce hallazgos con evidencia HTTP completa.

Encabezados y TLS

Verificación	Qué prueba
Encabezados de seguridad	HSTS, X-Content-Type-Options, X-Frame-Options, presencia de CSP
Análisis de calidad de CSP	unsafe-inline, unsafe-eval, fuentes comodín
Permissions-Policy	Presencia y configuración del encabezado de política de características
Divulgación de versión del servidor	Encabezados Server, X-Powered-By, X-AspNet-Version
Fugas de información en encabezados	X-Debug-Token, X-Backend-Server, Via, X-Request-ID
Aplicación de HTTPS	Análisis de la cadena de redirección HTTP a HTTPS
Calidad de HSTS	Valor de max-age, includeSubDomains, directivas de precarga
Encabezados avanzados	Cross-Origin-Opener-Policy, Cross-Origin-Resource-Policy, Cross-Origin-Embedder-Policy

Autenticación y Sesión

Verificación	Qué prueba
Seguridad de cookies	Banderas HttpOnly, Secure, SameSite en cookies de sesión
Autenticación faltante en endpoints de API	Acceso no autenticado a rutas protegidas
Detección de límite de velocidad	Limitación de inicio de sesión y endpoints de API
Enumeración de métodos HTTP	TRACE, PUT, DELETE habilitados en endpoints que no deberían permitirlos
Inyección de encabezado Host	Encabezado Host manipulado reflejado en respuestas o redirecciones

Datos y API

Verificación	Qué prueba
Descubrimiento de API no autenticada	Rutas de API comunes accesibles sin credenciales
Detección de ID secuencial	Riesgo de IDOR por identificadores de recursos predecibles
Configuración incorrecta de CORS	Reflexión de origen, aceptación de origen nulo, comodín con credenciales
Prueba de redirección abierta	Parámetros de redirección no validados en URLs

Contenido y Frontend

Verificación	Qué prueba
Huella de tecnología	Detección de CMS, identificación de frameworks, software de servidor
Bibliotecas JS vulnerables	jQuery, Angular, Bootstrap, Lodash con CVEs conocidos
Exposición de mapas de origen	Archivos .map accesibles en producción
Secretos en bundles JS	Claves de API, tokens, credenciales en JavaScript del lado del cliente
Detección de contenido mixto	Recursos HTTP cargados en páginas HTTPS
Análisis de CSRF en formularios	Formularios sin tokens CSRF o que usan GET para cambios de estado

Reconocimiento y Descubrimiento

Verificación	Qué prueba
Rastreador web	Enlaces HTML, endpoints JS, sitemap, robots.txt (profundidad recursiva 3)
Sondeo de rutas sensibles	Paneles de administración, archivos de configuración, copias de seguridad (con validación de contenido para eliminar falsos positivos)
robots.txt / sitemap.xml	Análisis de rutas prohibidas y endpoints del sitemap
security.txt	Cumplimiento de RFC 9116 e información de contacto
Divulgación en páginas de error	Trazas de pila, información de depuración, rutas internas en respuestas de error
Descubrimiento de referencias a subdominios	Subdominios referenciados en HTML, JS y encabezados
Seguridad de encabezados de caché	Cache-Control, Pragma, Expires en respuestas sensibles

VCVD — Base de Datos de Vulnerabilidades de Vibe Coding

47 patrones de vulnerabilidad que el código generado por IA falla. Los escáneres tradicionales no buscan estos porque son específicos de cómo los LLM escriben código.

Autenticación e Identidad

ID	Patrón	Severidad
VC-AUTH-001	Middleware de autenticación inconsistente — la IA aplica autenticación a algunas rutas pero no a otras	CRÍTICO
VC-AUTH-002	Validación solo en el cliente — las verificaciones de roles existen en React pero no en la API	CRÍTICO
VC-AUTH-003	JWT decodificado sin verificación — `jwt.decode()` en lugar de `jwt.verify()`	CRÍTICO
VC-AUTH-004	Clave de servicio en código de cliente — clave `service_role` de Supabase en el bundle JS	CRÍTICO
VC-AUTH-005	Expiración de token >30 días — "por conveniencia"	ALTO
VC-AUTH-006	OAuth sin parámetro de estado	ALTO
VC-AUTH-007	Contraseña en la cadena de consulta de la URL	ALTO
VC-AUTH-008	Sesión no regenerada después del inicio de sesión	MEDIO

Acceso a Datos

ID	Patrón	Severidad
VC-DATA-001	IDOR — IDs secuenciales sin verificación de propiedad	CRÍTICO
VC-DATA-002	`USING (true)` en RLS — la política "temporal" de la IA que llega a producción	CRÍTICO
VC-DATA-003	Tabla creada sin habilitar RLS	CRÍTICO
VC-DATA-004	`SELECT *` exponiendo hashes de contraseñas y PII	ALTO
VC-DATA-005	`...req.body` extendido en inserción de base de datos sin lista blanca de campos	ALTO
VC-DATA-006	Introspección de GraphQL habilitada en producción	MEDIO
VC-DATA-007	Consultas N+1 sin límite como vector de DoS	MEDIO
VC-DATA-008	Consultas multi-tenant sin filtro de `tenant_id`	CRÍTICO

Inyección

ID	Patrón	Severidad
VC-INJ-001	Literales de plantilla en consultas SQL	CRÍTICO
VC-INJ-002	`innerHTML` con entrada de usuario	ALTO
VC-INJ-003	Contenido de usuario almacenado y renderizado sin sanitización	CRÍTICO
VC-INJ-004	Entrada de usuario en `exec()` / `spawn()`	CRÍTICO
VC-INJ-005	Rutas de archivo construidas desde entrada de usuario	ALTO
VC-INJ-006	Fetch del lado del servidor con URL proporcionada por el usuario (SSRF)	ALTO
VC-INJ-007	Entrada de usuario pasada como fuente de plantilla	ALTO
VC-INJ-008	Operadores de MongoDB en entrada JSON	ALTO

Infraestructura

ID	Patrón	Severidad
VC-INFRA-001	Modo de depuración / trazas de pila en producción	ALTO
VC-INFRA-002	`Access-Control-Allow-Origin: *` con credenciales	ALTO
VC-INFRA-003	Falta de HSTS, X-Frame-Options, CSP	MEDIO
VC-INFRA-004	Puertos Docker innecesarios expuestos	MEDIO
VC-INFRA-005	Cargas de usuario almacenadas sin cifrado	MEDIO
VC-INFRA-006	TLS 1.0/1.1 aún habilitado	MEDIO
VC-INFRA-007	Panel de administración accesible desde internet público	ALTO
VC-INFRA-008	Credenciales predeterminadas sin cambiar	CRÍTICO

Frontend

ID	Patrón	Severidad
VC-FE-001	Claves de API en el bundle de JavaScript	CRÍTICO
VC-FE-002	Guardia de autenticación solo en React Router, no en la API	ALTO
VC-FE-003	JWT almacenado en `localStorage`	MEDIO
VC-FE-004	Formularios sin protección CSRF	ALTO
VC-FE-005	URL de redirección desde parámetro de consulta sin validación	MEDIO
VC-FE-006	Manejador de `postMessage` sin verificación de origen	MEDIO
VC-FE-007	Mapas de origen accesibles en producción	BAJO
VC-FE-008	Campos sensibles sin `autocomplete="off"`	BAJO

Puntuación de Seguridad

Cada escaneo produce una calificación con letras según lo encontrado:

Calificación	Criterio	Interpretación
A	Cero críticos o altos. Máximo 2 medios.	Despliégalo.
B	Cero críticos. Algunos altos o medios.	Corrige los altos pronto.
C	Múltiples problemas de alta severidad.	Necesita trabajo antes de producción.
D	1-2 críticos o >5 altos.	Riesgo significativo. Prioriza las correcciones.
F	3+ críticos o una cadena de compromiso completa.	No lo despliegues.

Salvaguardas de Seguridad

Firebreak está diseñado solo para pruebas autorizadas.

Guardrail	Cómo funciona
Límite de tasa	10 solicitudes/segundo al objetivo (configurable). Ventana deslizante.
Bloqueo de alcance	Solo ataca la URL objetivo especificada. Sin movimiento lateral, sin enumeración de subdominios.
No destructivo	Sin solicitudes DELETE, DROP, UPDATE o POST que modifiquen datos. Solo sondeos.
Consentimiento	La IA pide confirmación antes del primer escaneo.
Registro de auditoría	Cada solicitud HTTP se registra con marca de tiempo, objetivo y motivo.

Configuración

Variables de entorno:

Variable	Predeterminado	Descripción
`FIREBREAK_HOST`	`0.0.0.0`	Dirección de enlace
`FIREBREAK_PORT`	`9090`	Puerto
`RUST_LOG`	`firebreak=info`	Nivel de registro

Copia .env.example a .env y edítalo según sea necesario.

Estructura del Proyecto

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

Stack Tecnológico

Componente	Tecnología	Por qué
Lenguaje	Rust	Binario único, sin runtime, seguro en memoria, rápido
Servidor HTTP	Axum	Async, ecosistema de middleware tower
Cliente HTTP	reqwest	Maduro, soporte TLS, control de redirecciones
Base de datos	SQLite (rusqlite)	Cero configuración, embebido, suficiente para escaneos locales
Analizador SQL	sqlparser-rs	Análisis de políticas RLS sin base de datos en ejecución
Runtime asíncrono	tokio	Estándar de la industria
Serialización	serde + serde_json	Rápido, macros derivadas
Panel de control	React + TypeScript + Vite + Tailwind	Moderno, servidor de desarrollo rápido, CSS utilitario

El binario de lanzamiento es de ~8 MB sin dependencias de runtime.

Contribuciones

Las contribuciones son bienvenidas. Así es como puedes participar:

Para empezar

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

El servidor se ejecuta en http://localhost:9090/mcp por defecto.

Áreas donde se necesita ayuda

Nuevos patrones VCVD — ¿Encontraste un patrón de vulnerabilidad que la IA genera consistentemente? Añádelo a src/vcvd/data.rs. Cada patrón necesita un ID, descripción, severidad, pista de detección y corrección.

Comprobaciones del motor de escaneo — Añade nuevas comprobaciones de vulnerabilidad en src/engine/checks.rs. Cada función de comprobación toma un cliente reqwest, URL objetivo y referencia de seguridad. Devuelve un Vec<Finding>.

Guías de mejores prácticas — Añade archivos markdown a knowledge/best-practices/. Luego regístralos en src/tools/knowledge/best_practices.rs.

Correcciones específicas de frameworks — La herramienta finding_fix genera código de corrección. Añade soporte para frameworks en src/tools/analysis.rs dentro de la función framework_fix_example.

Panel de control — El frontend de React vive en frontend/. Ejecuta npm run dev para el servidor de desarrollo.

Envío de cambios

Haz un fork del repositorio
Crea una rama (git checkout -b add-new-check)
Haz tus cambios
Ejecuta cargo check && cargo clippy -- -D warnings
Abre un pull request con una descripción clara de lo que cambiaste y por qué

Estilo de código

Sin comentarios innecesarios. Si el código dice lo que hace, no añadas un comentario.
Cláusulas de guarda en lugar de if/else anidados.
Sigue el estilo del código existente.
Cada hallazgo debe tener evidencia verificable — nada de "esto podría ser vulnerable".

Reportar problemas de seguridad

Si encuentras una vulnerabilidad de seguridad en Firebreak, envía un correo a security@firebreak.dev en lugar de abrir un issue público. Responderemos dentro de 48 horas.

Hoja de ruta

Hecho

Panel de control web (React)
Escaneo de caja gris con sesiones autenticadas
Navegador sin cabeza para aplicaciones renderizadas en frontend
Escaneos programados / recurrentes
Notificaciones webhook (Slack, Discord)
Exportación de informes PDF
Opción alojada en la nube (VPS gestionado)
Sistema de plugins para comprobaciones personalizadas
Contribuciones de la comunidad VCVD vía PR

Preguntas frecuentes

¿Necesito ser un experto en seguridad para usar esto? No. Ese es el punto. La IA maneja la experiencia en seguridad. Solo le dices qué probar.

¿Qué clientes MCP funcionan con Firebreak? Cualquier cliente que soporte MCP sobre HTTP: Claude Desktop, Claude Code, Cursor, Windsurf y otros.

¿Es seguro ejecutarlo contra producción? Firebreak es no destructivo (solo sondeos de lectura), pero siempre deberías probar primero en staging. El límite de tasa está activado por defecto.

¿Puedo añadir mis propias comprobaciones de vulnerabilidad? Sí. Añade funciones de comprobación en src/engine/checks.rs y conéctalas a los métodos de escaneo en src/engine/mod.rs.

¿Por qué Rust? Binario único sin dependencias de runtime. Rápido. Seguro en memoria. Enviamos un archivo y funciona.

¿Por qué AGPL-3.0? Si ejecutas Firebreak como un servicio para otros, debes compartir tus modificaciones. Si lo usas internamente o lo autoalojas para tu propio equipo, no necesitas hacer nada especial.

Licencia

AGPL-3.0

Si construyes un servicio comercial sobre Firebreak, la AGPL requiere que publiques tus modificaciones como código abierto. Para uso interno y autoalojado, no hay restricciones más allá de los términos estándar de AGPL.

20 Herramientas de Seguridad · 100 Guías de Mejores Prácticas · 47 Patrones de Vulnerabilidad · 32 Comprobaciones de Escaneo

FIREBREAK — Porque si no lo pruebas, alguien más lo hará.