F --> G1[Passive scanners]
F --> G2[Active scanners]

I[template-tool] --> H[CVE templates]
H --> G2

G1 --> J[Findings]
G2 --> J
J --> K[Reporter]
K --> L[Auto Reports]
K --> M[CI/CD Controls]

## ¿Por qué ApiHunter?

### Ventajas principales

- **Arquitectura centrada en API**: Diseñado específicamente para APIs REST/GraphQL, no adaptado de escáneres de aplicaciones web
- **Reducción inteligente de falsos positivos**:
  - Detección catch-all de SPA con sondeos de prueba
  - Validación de secretos según contexto (frontend vs backend)
  - Validación de contenido del cuerpo y verificación de referer
  - Huella digital de respuestas para saltar hallazgos duplicados
- **Seguro para producción por diseño**:
  - Concurrencia adaptativa (AIMD) que reduce la velocidad en caso de errores
  - Límite de velocidad por host con retrasos configurables
  - Controles de cortesía (reintentos, tiempos de espera, evasión de WAF)
  - Modo de prueba para comprobaciones activas
- **Sigilo y evasión**:
  - Rotación de User-Agent en tiempo de ejecución desde un conjunto curado (assets/user_agents.txt)
  - Retrasos aleatorios en las solicitudes con jitter
  - Cumplimiento de retraso por host (evita patrones de ráfaga)
  - Lógica de reintento con retroceso exponencial
  - Inyección de encabezados personalizados para mezclarse con tráfico legítimo
  - Temporización adaptativa basada en respuestas del servidor
  - Sin huellas dactilares de escáner codificadas en modo predeterminado

### Inmersión profunda en técnicas de sigilo

ApiHunter utiliza varias técnicas de sigilo para evitar la detección por parte de WAF (Firewall de Aplicaciones Web) y sistemas de protección contra bots:

#### 1. Rotación de User-Agent
**Qué hace:** Cicla aleatoriamente entre más de 100 cadenas de User-Agent reales de navegador desde un archivo (`assets/user_agents.txt`)

**Por qué funciona:** Los bots suelen usar el mismo User-Agent (como `curl/7.68.0`). Al hacerse pasar por Chrome, Firefox, Safari, etc., te mezclas con el tráfico legítimo

**Analogía simple:** Como usar diferentes disfraces en lugar de usar siempre el mismo uniforme

#### 2. Temporización aleatoria y jitter
**Qué hace:** Agrega retrasos aleatorios entre solicitudes (controlado por `--delay-ms`) con jitter (pequeñas variaciones aleatorias)

**Por qué funciona:** Los bots envían solicitudes en intervalos perfectos (exactamente 100ms de diferencia). Los humanos son impredecibles. La temporización aleatoria hace que el tráfico parezca orgánico

**Analogía simple:** Caminar con pasos irregulares en lugar de marchar como un robot

#### 3. Cumplimiento de retraso por host
**Qué hace:** Rastrea el retraso por separado para cada dominio, no globalmente

**Por qué funciona:** Evita patrones de ráfaga donde golpeas un host 50 veces instantáneamente. Cada host ve solicitudes corteses y espaciadas

**Analogía simple:** Turnarse en diferentes conversaciones en lugar de gritarle a una persona repetidamente

#### 4. Concurrencia adaptativa (AIMD)
**Qué hace:** Reduce automáticamente la velocidad al recibir errores 429 (límite de velocidad) o 503 (servidor ocupado), acelera cuando tiene éxito

**Por qué funciona:** Retrocede cuando es detectado, imita cómo los navegadores reintentan. Los WAF ven "este cliente respeta nuestros límites"

**Analogía simple:** Reducir la velocidad cuando hay tráfico congestionado, acelerar en carreteras abiertas

#### 5. Reintento con retroceso exponencial
**Qué hace:** Cuando una solicitud falla, espera 1s, luego 2s, luego 4s antes de reintentar

**Por qué funciona:** Los clientes legítimos reintentan con cortesía. Los bots suelen golpear inmediatamente o rendirse

**Analogía simple:** Tocar una puerta, esperar más tiempo cada vez en lugar de golpear continuamente

#### 6. Sin huellas dactilares de escáner
**Qué hace:** No envía encabezados como `X-Scanner: ApiHunter` ni patrones predecibles

**Por qué funciona:** Muchas herramientas dejan firmas (plantillas de Nuclei, patrones de sqlmap). ApiHunter evita marcadores obvios

**Analogía simple:** No llevar una etiqueta con el nombre que diga "Probador de Seguridad"

#### 7. Reutilización y agrupación de conexiones
**Qué hace:** Utiliza grupos de clientes HTTP por host, mantiene las conexiones activas

**Por qué funciona:** Los navegadores reutilizan conexiones. Abrir/cerrar para cada solicitud parece sospechoso

**Analogía simple:** Mantener la puerta abierta en lugar de cerrarla de golpe y tocar el timbre de nuevo

#### 8. Inyección de encabezados personalizados
**Qué hace:** Puede agregar encabezados como `Referer`, `X-Forwarded-For`, cookies personalizadas

**Por qué funciona:** Hace que las solicitudes parezcan provenir de un flujo de aplicación legítimo (hicieron clic en un enlace, tienen cookies de sesión)

**Analogía simple:** Mostrar un comprobante de entrada al ingresar a un lugar en lugar de saltar la valla

#### Comparación de detección

| Técnica | Sin evasión | Con evasión |
|---------|-------------|-------------|
| **User-Agent** | `python-requests/2.28.0` (bot obvio) | `Mozilla/5.0 (Windows NT 10.0; Win64; x64)...` (parece Chrome) |
| **Temporización** | Intervalos perfectos de 100ms → WAF bloquea | 120ms, 95ms, 180ms → parece humano |
| **Reintentos** | Reintento instantáneo → baneo | Esperar 1s→2s→4s → "cliente paciente" |
| **Concurrencia** | 100 golpes paralelos → alarma | Adaptativo 5→10→3 según respuesta → "navegador educado" |

#### Cuándo usar `--waf-evasion`

- Probar APIs en producción con Cloudflare/Akamai/AWS WAF
- Evitar baneos de IP durante escaneos grandes
- Pruebas de penetración donde necesitas pasar desapercibido

- **CI/CD nativo**:
  - Diferenciación con línea base (solo reportar nuevos hallazgos)
  - Salida NDJSON en streaming para monitoreo en tiempo real
  - SARIF 2.1.0 para escaneo de código en GitHub/GitLab
  - Máscara de bits de código de salida para control de pipelines
  - Filtrado basado en severidad y umbrales de fallo
- **Rendimiento a escala**:
  - Tiempo de ejecución asíncrono en Rust (tokio) con abstracciones de costo cero
  - Escaneo concurrente con paralelismo limitado por semáforo
  - Grupos de clientes HTTP por host para evitar cuellos de botella de conexión
  - Uso eficiente de memoria (sin pausas de GC)
- **Soporte completo de autenticación**:
  - Flujos de autenticación basados en JSON con extracción de cookies/encabezados
  - Pruebas IDOR/BOLA con doble identidad
  - Importación de archivos de sesión (integración con Excalibur)
  - Autenticación Bearer, Basic y encabezados personalizados
  - Cliente no autenticado automático para comprobaciones de escalada de privilegios

## Módulos del escáner

ApiHunter incluye 13 módulos de escáner incorporados. Consulta [docs/scanners.md](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md) para conocer la lógica de detección detallada.

| Escáner | Tipo | Qué detecta |
|---------|------|-------------|
| **CORS** | Pasivo | Orígenes comodín, orígenes reflejados con credenciales, aceptación de origen nulo, vulnerabilidades de bypass de expresiones regulares (ataques de sufijo/prefijo), falta de Vary: Origin, métodos preflight no seguros |
| **CSP** | Pasivo | Falta de Content-Security-Policy, directivas unsafe-inline/unsafe-eval, orígenes comodín, hosts CDN eludibles (gadgets JSONP), falta de frame-ancestors |
| **GraphQL** | Pasivo | Introspección habilitada, campos sensibles de esquema (tipos de usuario/contraseña/token), sugerencias de campos (fuga de esquema), agrupación de consultas, amplificación de alias (DoS), exposición de GraphiQL/Playground |
| **JWT** | Pasivo | Tokens alg=none, secretos HS256 débiles (basado en lista de palabras), caducidad faltante/excesiva, claims sensibles en payload, vulnerabilidades de confusión de algoritmo |
| **OpenAPI** | Pasivo | Esquemas de seguridad faltantes, operaciones sin requisitos de autenticación, endpoints de subida de archivos, operaciones obsoletas aún presentes, endpoints sensibles no asegurados |
| **Versionado de API** | Pasivo | Divulgación de encabezado de versión, versiones concurrentes heredadas/nuevas de API, encabezados de obsolescencia y desviación de respuesta entre variantes benignas de consulta/versión (más modo profundo con `--response-diff-deep`) |
| **gRPC/Protobuf** | Pasivo + Activo | Señales de transporte/tipo de contenido gRPC, pistas de superficie protobuf, y señales opcionales de reflexión/sonda de estado |
| **Seguridad de API** | Pasivo + Activo | Falta de encabezados de seguridad (X-Content-Type-Options, X-Frame-Options), divulgación de versión del servidor, acceso no autenticado a rutas sensibles, enumeración de métodos HTTP, endpoints de depuración, patrones de exposición de secretos, comprobaciones activas de IDOR/BOLA (comparación de cuerpo + encabezados seleccionados), sondeos de callback SSRF ciego, y señales de sonda de bypass/puerta de enlace |
| **Asignación masiva** | Activo | Campos sensibles reflejados (is_admin, role, permissions), cambios de estado persistidos, escalada de privilegios mediante inyección de campos |
| **OAuth/OIDC** | Activo | Bypass de validación de URI de redirección, falta de parámetro state, problemas de soporte PKCE (falta de S256, plain permitido), flujo implícito habilitado, concesión de contraseña habilitada |
| **Límite de velocidad** | Activo | Falta de limitación de velocidad (sondas de ráfaga), falta de encabezados Retry-After, bypass de suplantación de encabezado IP (X-Forwarded-For) |
| **WebSocket** | Activo | Aceptación de actualización WebSocket en rutas comunes, falta de validación de origen, conexiones WebSocket no autenticadas |
| **Plantillas CVE** | Activo | Detección de CVE basada en plantillas desde `assets/cve_templates/*.toml` (actualmente 168 plantillas), coincidencia diferencial de línea base vs bypass |

**Los escáneres pasivos** se ejecutan por defecto y analizan las respuestas sin enviar solicitudes diseñadas.  
**Los escáneres/comprobaciones activos** requieren `--active-checks` y envían sondas potencialmente invasivas (IDOR/BOLA, mutación, pruebas de bypass).  
IDOR/BOLA se encuentra bajo el escáner `API Security` (no hay una bandera `--no-idor` específica; usa `--no-api-security` para deshabilitarlo).

### Notas de salida y señales del módulo

Estas notas resumen cómo se emiten los hallazgos y qué suele causar ruido:

| Módulo | Prefijo / Forma del hallazgo | Falsos positivos comunes | Falsos negativos comunes |
|---------|------------------------------|--------------------------|--------------------------|
| CORS | `cors/*` con campos de origen/evidencia | Reflexión en rutas no sensibles | Comprobaciones de origen aplicadas solo en rutas autenticadas |
| CSP | `csp/*` con evidencia de directiva | CSP heredado aplicado intencionalmente durante migración | CSP entregado solo en ruta de CDN de producción |
| GraphQL | `graphql/*` con endpoint + señal de capacidad | Playground público destinado a inquilinos internos/pruebas | Controles de esquema habilitados solo después de autenticación |
| JWT | `jwt/*` con evidencia de claim/encabezado de token | Tokens de prueba/demo en respuestas sintéticas | El token nunca aparece en las respuestas escaneadas |
| OpenAPI | `openapi/*` con contexto de operación/seguridad | Especificación incluye intencionalmente endpoints obsoletos pero bloqueados | Especificación no disponible o dividida en documentos privados |
| Versionado de API | `api_versioning/*` + `response_diff/*` | Múltiples versiones compatibles durante migraciones controladas | Rutas versionadas no descubribles desde el conjunto semilla actual |
| gRPC/Protobuf | `grpc_protobuf/*` con evidencia de transporte/reflexión | Metadatos similares a gRPC en proxies perimetrales sin superficie RPC expuesta | Endpoints gRPC detrás de host/ruta separados no alcanzados desde el conjunto semilla |
| Seguridad de API | `api_security/*` con evidencia de encabezado/ruta/método | Endpoints de depuración/prueba expuestos intencionalmente en no producción | Controles aplicados detrás de contexto de autenticación/sesión |
| Asignación masiva | `mass_assignment/*` con deltas reflejados/persistidos | Comportamiento de eco que no persiste estado en backend | Mutaciones rechazadas por reglas de validación ocultas |
| OAuth/OIDC | `oauth/*` con evidencia de redirección/metadatos | Configuración de IdP no productiva con políticas relajadas | Políticas dinámicas no visibles en metadatos |
| Límite de velocidad | `rate_limit/*` con comportamiento de ráfaga/429 | Modelado de tráfico global enmascara comportamiento del limitador a nivel de aplicación | Limitadores de ventana larga no activados por ventana de sonda corta |
| WebSocket | `websocket/*` con comprobaciones de actualización/origen | Endpoints WS públicos intencionalmente anónimos | Autenticación requerida mediante encabezados de handshake no proporcionados en la sonda |
| Plantillas CVE | `cve/<id>/<check>` con evidencia de plantilla | Colisión de huella digital en endpoints genéricos | Ruta/contexto vulnerable no alcanzado desde URLs semilla |

Para conocer los detalles comprobación por comprobación y las recomendaciones de remediación, consulta [docs/scanners.md](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md) y [docs/findings.md](https://github.com/teycir/apihunter/blob/HEAD/docs/findings.md).
Los documentos del escáner ahora incluyen un [Catálogo de comprobaciones del módulo](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md#module-check-catalog) alineado con la fuente y un [Modelo de expectativa de falsos positivos](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md#false-positive-expectation-model).

## Características

### Análisis de seguridad pasivo
- **Detección de configuración incorrecta de CORS**:
  - Generación dinámica de origen basada en el dominio objetivo
  - Pruebas de bypass de expresiones regulares (ataques de sufijo/prefijo)
  - Puntuación de severidad consciente de credenciales
  - Detección de origen comodín y nulo
- **Análisis de políticas CSP**:
  - Detección de política de seguridad de contenido faltante/débil
  - Directivas unsafe-inline/eval
  - Detección de fuentes comodín
  - Patrones de bypass de políticas
- **Seguridad GraphQL**:
  - Detección de consultas de introspección
  - Análisis de tipos/campos sensibles
  - Detección de soporte de agrupación de consultas
  - Sondeo de amplificación de alias (DoS)
  - Fuzzing activo de mutaciones (`--active-checks`, soporta `--dry-run`)
  - Exposición de GraphiQL/Playground
- **Análisis de tokens JWT**:
  - Confusión de algoritmo (alg=none, HS256→RS256)
  - Detección de secretos débiles (lista de palabras curada)
  - Detección de tokens de larga duración (exp faltante/excesivo)
  - Exposición de claims sensibles
  - Extracción de tokens de encabezados y cookies
- **Análisis de OpenAPI/Swagger**:
  - Validación de esquemas de seguridad
  - Detección de endpoints de subida de archivos
  - Marcado de operaciones obsoletas
  - Definiciones de seguridad faltantes
  - Caché de especificaciones para rendimiento
- **Cobertura de gRPC/Protobuf**:
  - Detección de metadatos/tipo de contenido de respuesta gRPC
  - Detección de pistas de superficie protobuf desde metadatos de endpoint/forma de ruta
  - Señales opcionales de sonda activa de reflexión/salud en rutas gRPC conocidas
- **Detección de exposición de secretos**:
  - Claves AWS (AKIA*, secret keys)
  - Claves de API de Google (AIza*)
  - Tokens de GitHub (ghp_*, github_pat_*)
  - Tokens de Slack (xox*)
  - Claves de Stripe (sk_live_*, pk_live_*)
  - URLs de base de datos, claves privadas, tokens Bearer
  - Validación consciente del contexto (reduce falsos positivos)
- **Comprobaciones de seguridad de API**:
  - Enumeración de métodos HTTP
  - Detección de endpoints de depuración
  - Exposición de listado de directorios
  - Presencia de security.txt
  - Análisis de encabezados de respuesta (HSTS, X-Frame-Options, etc.)
  - Divulgación de mensajes de error

### Pruebas de seguridad activas (--active-checks)
- **Comprobaciones IDOR/BOLA de seguridad de API** (enfoque de 3 niveles):
  - Prueba de acceso no autenticado
  - Comparación de respuestas mediante huellas dactilares del cuerpo más capturas de encabezados estables
  - Recorrido de enumeración de ID (±2 rango)
  - Bypass de autorización entre usuarios (doble identidad)
  - Sondeo de callback SSRF ciego mediante parámetros de consulta estilo callback (`APIHUNTER_OAST_BASE`, soporta `--dry-run`)
  - Huella dactilar de puerta de enlace y sondeo de bypass (`api_security/gateway-*`)
- **Vulnerabilidades de asignación masiva**:
  - Inyección de campos sensibles reflejados
  - Detección de cambio de estado persistido
  - Verificación Línea base→Mutación→Confirmación
  - Escalada de privilegios mediante inyección de campos
- **Seguridad OAuth/OIDC**:
  - Bypass de validación de URI de redirección
  - Manejo del parámetro state
  - Detección de soporte PKCE
  - Fortalecimiento de configuración de metadatos
  - Detección de flujo implícito y concesión de contraseña
- **Limitación de velocidad**:
  - Sondeo de solicitudes en ráfaga
  - Detección de falta de límite de velocidad
  - Validación del encabezado Retry-After
  - Pruebas de bypass de suplantación de encabezado IP
- **Seguridad WebSocket**:
  - Aceptación de actualización en rutas comunes
  - Pruebas de validación de origen
  - Comprobaciones de falta de autenticación
- **Motor de plantillas CVE**:
  - Catálogo de plantillas basado en TOML
  - Soporte de importación de YAML de Nuclei
  - Coincidencia diferencial de línea base vs bypass
  - Deduplicación de host+plantilla
  - Compuertas de calidad del cargador que saltan plantillas de solicitud no válidas/inseguras (por ejemplo, placeholders de solicitud no resueltos)
  - Coincidencia de contexto consciente de segmentos reduce la activación excesiva de subcadenas de ruta amplias
  - Catálogo local actual: 168 plantillas (incluye comprobaciones reforzadas curadas como CVE-2022-22947, CVE-2021-29442, CVE-2021-29441, CVE-2020-13945, CVE-2021-45232, CVE-2022-24288)

### Descubrimiento y enumeración
- **Descubrimiento de endpoints**:
  - Análisis de robots.txt
  - Análisis de sitemap.xml
  - Importación de especificación OpenAPI/Swagger
  - Importación de archivo HAR (integración con Excalibur)
  - Importación de colecciones de Postman/Insomnia (`--collection`)
  - Extracción de endpoints de JavaScript
  - Filtrado de mismo host
- **Prefiltrado de accesibilidad de URL**:
  - Comprobación rápida previa para saltar endpoints inactivos
  - Tiempo de espera configurable
  - Bypass opcional con --no-filter

### Rendimiento y fiabilidad
- **Concurrencia adaptativa (AIMD)**:
  - Ajuste automático de velocidad basado en errores
  - Aumento aditivo (cada 5s)
  - Disminución multiplicativa en 429/503/timeouts
- **Sigilo y evasión de WAF**:
  - Rotación de User-Agent desde grupo en tiempo de ejecución (assets/user_agents.txt con más de 100 UAs reales)
  - Fallback de UAs incrustados si el archivo no está disponible
  - Jitter de retraso aleatorio para evitar patrones de detección
  - Cumplimiento de temporización por host (no global)
  - Lógica de reintento con retroceso exponencial
  - Inyección de encabezados personalizados (X-Forwarded-For, Referer, etc.)
  - Temporización adaptativa basada en respuestas 429/503
  - Modo de cortesía para pruebas cooperativas
  - Sin huellas dactilares de escáner en User-Agent o encabezados por defecto
- **Gestión de recursos**:
  - Paralelismo limitado por semáforo
  - Grupos de clientes HTTP por host
  - Reutilización y agrupación de conexiones
  - Tiempos de espera y reintentos configurables
- **Manejo de errores**:
  - Recuperación de pánico mediante JoinSet
  - Errores capturados reportados por separado
  - Degradación gradual en fallos del escáner

### Salida e informes
- **Múltiples formatos de salida**:
  - JSON bonito (legible por humanos)
  - NDJSON (streaming, analizable)
  - SARIF 2.1.0 (Escaneo de código de GitHub/GitLab)
- **Diferenciación con línea base**:
  - Generar instantáneas de línea base
  - Comparar escaneos para reportar solo nuevos hallazgos
  - Perfecto para pruebas de regresión
- **Informes de guardado automático** (habilitado por defecto, deshabilitar con `--no-auto-report`):
  - Guardado en ~/Documents/ApiHunterReports/<timestamp>/
  - findings.json (hallazgos estructurados)
  - summary.md (informe en Markdown)
  - scan.log (registro de ejecución)
- **Streaming en tiempo real**:
  - Transmitir hallazgos a medida que se descubren
  - Formato NDJSON para análisis en vivo
  - Seguimiento de progreso
- **Filtrado por severidad**:
  - Filtrar por severidad mínima (info/baja/media/alta/crítica)
  - Umbral de fallo para CI/CD
  - Máscara de bits de código de salida (0x01 hallazgos, 0x02 errores)

### Integración y extensibilidad
- **Arquitectura de escáner conectable**:
  - Implementar el trait Scanner para agregar módulos
  - Diseño asíncrono primero
  - Ejecución independiente del escáner
  - Aislamiento de pánico por escáner
- **Extensibilidad basada en TOML**:
  - Catálogo de plantillas CVE en assets/cve_templates/*.toml
  - No se necesitan cambios de código para agregar nuevas comprobaciones
  - Detección de vulnerabilidades basada en plantillas
  - Formato de plantilla compartible por la comunidad
- **Importación de plantillas de Nuclei**:
  - Herramienta template-tool para conversión de YAML a TOML
  - Traducción automática de matchers (status, word, regex, dsl)
  - Extracción segura de cadena de solicitudes previas
  - Preserva la lógica de detección de las plantillas originales
- **Modelo de extensión dual**:
  - **Basado en código**: Escribir escáneres en Rust implementando el trait Scanner para lógica compleja
  - **Basado en plantillas**: Escribir plantillas TOML para comprobaciones basadas en firmas (CVEs, configuraciones incorrectas)
  - Lo mejor de ambos mundos: rendimiento + flexibilidad
- **Herramientas complementarias**:
  - Extensión de navegador Excalibur (captura HAR)
  - BurpAPIsecuritysuite (pruebas manuales)
  - Flujo de trabajo: Capturar → Automatizar → Prueba profunda

### Configuración y control
- **Entrada flexible**:
  - Listas de URLs basadas en archivos
  - stdin (pipe desde otras herramientas)
  - Importación de archivo HAR
  - Importación de colecciones de Postman/Insomnia
  - Importación de especificación OpenAPI
- **Control granular del escáner**:
  - Habilitar/deshabilitar escáneres individuales
  - Modo activo vs pasivo
  - Modo de prueba para comprobaciones activas
  - Configuración por escáner
- **Configuración de red**:
  - Soporte de proxy HTTP/HTTPS
  - Control de validación de certificado TLS
  - Encabezados y cookies personalizados
  - Tiempos de espera y reintentos configurables
- **Perfiles de escaneo**:
  - quickscan.sh (rápido, bajo impacto)
  - deepscan.sh (completo, comprobaciones activas)
  - inaccessiblescan.sh (revisar objetivos previamente inaccesibles con configuraciones más lentas)
  - baselinescan.sh (generar línea base)
  - diffscan.sh (comparar con línea base)
  - authscan.sh (escaneo autenticado)
  - sarifscan.sh (integración CI/CD)
  - scan-and-report.sh (ejecutar escaneo + imprimir ruta del informe más reciente)
  - split-by-host.sh (dividir objetivos por host y opcionalmente distribuir escaneos)

## Comparación con otras herramientas| Característica | ApiHunter | Nuclei | ZAP | Burp Suite | ffuf |
|---------|-----------|--------|-----|------------|------|
| **Lenguaje** | Rust | Go | Java | Java | Go |
| **Rendimiento** | ⚡⚡⚡ Asíncrono, concurrencia adaptativa | ⚡⚡ Rápido en paralelo | ⚡ Moderado | ⚡ Moderado | ⚡⚡⚡ Muy rápido |
| **Diseño Primero-API** | ✅ Construido para APIs | ❌ Web general | ⚠️ Híbrido | ⚠️ Híbrido | ❌ Enfoque en fuzzing |
| **Filtrado de Falsos Positivos** | ✅ Detección SPA, validación de cuerpo, comprobaciones de referer | ⚠️ Dependiente de plantillas | ⚠️ Muchos FP | ✅ Bueno | N/A |
| **Análisis CORS/CSP** | ✅ Análisis profundo de políticas | ⚠️ Plantillas básicas | ✅ Bueno | ✅ Bueno | ❌ |
| **Introspección GraphQL** | ✅ Exposición de esquema + comprobaciones de campos sensibles | ⚠️ Detección básica | ⚠️ Limitado | ✅ Mediante extensiones | ❌ |
| **OpenAPI/Swagger** | ✅ Análisis de esquemas de seguridad | ❌ | ✅ Solo importación | ✅ Importación + escaneo | ❌ |
| **Análisis JWT** | ✅ alg=none, secretos débiles, caducidad | ⚠️ Mediante plantillas | ⚠️ Limitado | ✅ Mediante extensiones | ❌ |
| **Detección IDOR/BOLA** | ✅ 3 niveles (sin autenticar/rango/entre usuarios) | ⚠️ Plantillas manuales | ⚠️ Limitado | ✅ Pruebas manuales | ❌ |
| **Detección de Secretos** | ✅ Consciente del contexto (frontend vs backend) | ⚠️ Basado en regex | ⚠️ Básico | ⚠️ Básico | ❌ |
| **Comprobaciones Activas** | ✅ Opt-in (IDOR, mass-assignment, OAuth/OIDC, websocket, límite de tasa, plantillas CVE) | ✅ Basado en plantillas | ✅ Escaneo activo | ✅ Escaneo activo | ✅ Fuzzing |
| **Evasión de WAF** | ✅ Rotación de UA, retardos, reintentos, temporización adaptativa | ⚠️ Básico | ⚠️ Limitado | ✅ Bueno | ⚠️ Básico |
| **Integración CI/CD** | ✅ NDJSON, SARIF, códigos de salida | ✅ JSON, SARIF | ⚠️ Informes XML | ⚠️ XML/JSON | ✅ JSON |
| **Diffing de Línea Base** | ✅ Integrado | ❌ Herramientas externas | ❌ | ❌ | ❌ |
| **Flujos de Autenticación** | ✅ Inicio de sesión pre-escaneo basado en JSON | ⚠️ Inyección de cabecera | ✅ Gestión de sesiones | ✅ Gestión de sesiones | ⚠️ Inyección de cabecera |
| **Salida en Streaming** | ✅ NDJSON en tiempo real | ❌ Solo por lotes | ❌ | ❌ | ✅ |
| **Uso de Recursos** | 🟢 Bajo (Rust) | 🟢 Bajo (Go) | 🟡 Alto (Java) | 🟡 Alto (Java) | 🟢 Bajo (Go) |
| **Curva de Aprendizaje** | 🟢 CLI sencillo | 🟢 Sintaxis de plantillas | 🟡 Complejidad de GUI | 🔴 Empinada | 🟢 Sencillo |
| **Extensibilidad** | ✅ Sistema de traits Rust | ✅ Plantillas YAML | ✅ Complementos | ✅ Extensiones | ⚠️ Limitada |
| **Licencia** | MIT (Gratuita) | MIT (Gratuita) | Apache 2.0 (Gratuita) | Comercial | MIT (Gratuita) |
| **Mejor para** | Seguridad de APIs en CI/CD, pruebas de regresión, análisis CORS/GraphQL/JWT | Escaneo de vulnerabilidades general, detección de CVEs | Pentesting completo de aplicaciones web | Pentesting manual, flujos de trabajo complejos | Fuzzing de directorios/parámetros |

### Diferenciadores Clave

**ApiHunter:** Diseño primero-API, detección SPA, diffing de línea base, IDOR/BOLA de 3 niveles, secretos conscientes del contexto, concurrencia AIMD, **evasión sigilosa/WAF (rotación de UA, jitter, temporización adaptativa)**, **extensibilidad dual (plantillas TOML + módulos Rust)**  
**Nuclei:** Cobertura CVE más amplia, solo plantillas YAML, evasión básica  
**ZAP/Burp:** Pruebas manuales, flujos de proxy, extensiones basadas en GUI, sigilo limitado  
**ffuf:** Fuzzing puro, descubrimiento de contenido, extensibilidad limitada, evasión básica

## Inicio Rápido```bash
cargo build --release

# Scan URLs from a file (newline-delimited)
./target/release/apihunter --urls ./targets/cve-regression-real-public.txt --format ndjson --output ./results.ndjson

# Or scan URLs from stdin
cat ./targets/cve-regression-real-public.txt | ./target/release/apihunter --stdin --min-severity medium

La entrada de escaneo de escritorio admite:
- Entrada manual de múltiples objetivos (una URL por línea o separada por comas)
- Importación CSV mediante `Load CSV` (máx. 307,200 bytes / 300 KiB)
- Presets de escaneo guiado: `Quick Passive` y `Deep Active`
- Límite estricto: hasta 3,000 objetivos por ejecución (deduplicados + validados como URLs absolutas `http/https`)
- Controles de alcance: descubrimiento activado/desactivado, filtro de accesibilidad + tiempo de espera, máximo de endpoints por sitio
- Controles de versionado de API: opción de sondeo profundo de diferencias en respuestas
- Controles avanzados: proxy, cabeceras, cookies, autenticación bearer/básica, opción de certificado TLS inválido
- Entrada de correlación de callback SSRF ciego (`OAST callback base`) para comprobaciones activas
- Controles de rendimiento: clientes por host, concurrencia adaptativa, evasión de WAF con pool de user-agent personalizado
- Cobertura completa de alternancia del escáner incluyendo `API Versioning` y `gRPC/Protobuf`
- Secciones de escaneo plegables con caret alineado a la derecha; `Safety and Scan Behavior`, `Runtime Limits` y `Scanner toggles` están plegadas por defecto
- Tarjetas de progreso de ejecución paralela con instantáneas de finalización y hallazgos por objetivo
- Panel de análisis de resultados: mapa de calor de gravedad, tarjeta del peor objetivo, eficiencia del escaneo, cobertura del escáner, rutas más vulnerables, desglose de gravedad de comprobaciones
- Persistencia de sesión: los últimos resultados de escaneo se restauran automáticamente en el próximo inicio
- Panel de modo de enriquecimiento: cargar hallazgos NDJSON, ejecutar enriquecimiento de inteligencia de amenazas, promover hosts con alta puntuación directamente a Escaneo Completo con el preset Deep Active
- UX de exportación: etiquetas de tamaño + `Save All Reports` + nombres de archivo con marca de tiempo por ejecución; las exportaciones incluyen paquetes JSON por objetivo, NDJSON, SARIF, colección de Insomnia y datos de Insomnia Runner

Consulte [HOWTO.md](https://github.com/teycir/apihunter/blob/HEAD/HOWTO.md) para uso detallado, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/HEAD/docs/lab-setup.md) para laboratorios de validación CVE basados en Vulhub, y [docs/](https://github.com/teycir/apihunter/blob/HEAD/docs/) para detalles internos.

Si desea un binario de escritorio de lanzamiento:```bash
cd apps/desktop
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Nota: el inicio del desarrollo de escritorio ahora usa los activos del frontend compilados directamente y no requiere un servidor `localhost:1420` separado.

Consulte [HOWTO.md](https://github.com/teycir/apihunter/blob/HEAD/HOWTO.md) para uso detallado, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/HEAD/docs/lab-setup.md) para laboratorios de validación de CVE basados en Vulhub y [docs/](https://github.com/teycir/apihunter/blob/HEAD/docs/) para detalles internos.

### Ejemplo de hallazgo NDJSON```json
{
  "url": "https://api.example.com/graphql",
  "check": "graphql/introspection-enabled",
  "title": "GraphQL introspection is enabled",
  "severity": "MEDIUM",
  "detail": "Introspection query returned schema metadata from a public endpoint.",
  "evidence": "POST /graphql -> HTTP 200 with __schema fields in response body",
  "scanner": "graphql",
  "timestamp": "2026-03-19T14:02:11.824Z"
}

**Flujo:** CLI args → Config → Runner orquestra Discovery + Scanners → HTTP Client (con Auth/WAF) → Reports

## Herramientas de Plantillas

ApiHunter soporta **doble extensibilidad**: agregue comprobaciones mediante **plantillas TOML** (sin código) o **módulos Rust** (control total).

### Formato de Plantilla TOML
Cree comprobaciones personalizadas en `assets/cve_templates/*.toml`:```toml
id = "custom-api-check"
name = "Custom API Vulnerability"
severity = "high"

[[requests]]
method = "GET"
path = "/api/vulnerable"

[[requests.matchers]]
type = "status"
values = [200]

[[requests.matchers]]
type = "word"
part = "body"
words = ["sensitive_data", "exposed"]

### Añadir escáneres Rust personalizados
Implementa el trait `Scanner` para lógica compleja:```rust
#[async_trait]
impl Scanner for MyCustomScanner {
    async fn scan(
        &self,
        url: &str,
        client: &HttpClient,
        config: &Config,
    ) -> (Vec<Finding>, Vec<CapturedError>) {
        // Your custom scanning logic
    }
}

Todos los scripts contenedores excepto `split-by-host.sh` soportan `--stdin` y los flags finales de ApiHunter.

## Estrategia de pruebas

Las pruebas de ApiHunter se dividen por intención:

- **Pruebas unitarias** (`tests/*_scanner.rs`, pruebas de parser/config): lógica del escáner y casos límite.
- **Pruebas de integración** (`tests/integration_runner.rs`, comportamiento de inicio/CLI): orquestación y cableado en tiempo de ejecución.
- **Pruebas de regresión con fixtures** (`tests/cve_templates_real_data.rs`, `tests/cve_templates_upstream_parity.rs`): reproducción de cargas útiles reales y comparación con plantillas fijadas ascendentes.
- **Pruebas con servidor simulado** (múltiples suites de escáner): comprobaciones de comportamiento determinista sin depender de destinos de Internet.
- **Comprobaciones de destino en vivo**: solo opcional/manual (no forman parte de `cargo test` por defecto).

Consulte la [Guía de pruebas](https://github.com/teycir/apihunter/blob/HEAD/docs/testing.md) dedicada para obtener la matriz de pruebas completa y el mapa de cobertura.

Ejecute conjuntos enfocados:```bash
cargo test --test cors_scanner
cargo test --test graphql_scanner
cargo test --test cve_templates_runtime_ext
cargo test --test integration_runner

Ejecutar la puerta de integración de datos reales (fixtures + suites ignoradas en vivo):```bash
# Fixture-backed real payload regression suites
cargo test --test cve_templates_real_data --test cve_templates_upstream_parity --test cve_templates_runtime_ext

# Manual live internet integration suites (ignored by default)
cargo test --test live_vulnerable_apis --test live_real_world_targets -- --ignored

### Artefactos de Versión Precompilados

Las versiones etiquetadas (`v*`) publican binarios precompilados de `apihunter` para:

- Linux (`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`)
- macOS (`x86_64-apple-darwin`)
- Windows (`x86_64-pc-windows-msvc`)

Cada versión también publica artefactos de la cadena de suministro:

- Archivos de suma de verificación SHA256 (`*.sha256`)
- Materiales de firma sin clave Sigstore (`*.sig`, `*.pem`, `*.sigstore.json`)
- SPDX JSON SBOM (`apihunter-release-assets-sbom.spdx.json`)
- Atestaciones de artefactos de GitHub (metadatos de atestación de procedencia y SBOM)

Descargar desde [GitHub Releases](https://github.com/Teycir/ApiHunter/releases).

### Instalación de Escritorio (Tauri + React)

El código fuente de la aplicación de escritorio se encuentra en `apps/desktop`.

Compila y ejecuta un binario de escritorio de producción:```bash
cd apps/desktop
npm install
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Instalar un icono de lanzador de Linux en el que se pueda hacer clic:```bash
cd apps/desktop
npm run desktop:install-icon

Ejecuta un escaneo desde archivos en tu directorio actual:```bash
docker run --rm -v "$PWD:/work" apihunter:local \
  --urls /work/targets/cve-regression-real-public.txt \
  --format ndjson \
  --output /work/results.ndjson

**P: ¿Diferenciación de línea base?**```bash
./target/release/apihunter --urls targets/cve-regression-real-public.txt --format ndjson --output baseline.ndjson
./target/release/apihunter --urls targets/cve-regression-real-public.txt --baseline baseline.ndjson --format ndjson