Qué probamos
Cada escaneo ejecuta primero el mismo motor determinista: sin aleatoriedad, sin adivinanzas. Baseline (8 pruebas) da feedback rápido en cada push; Deep (430+ comprobaciones) ejecuta el paquete completo con calendario o antes del release. Además: triaje asistido por IA, hacker mode autónomo y un cuestionario de código (ask mode, SaaS+) para lo que ningún escáner puede ver desde fuera.
430+ comprobaciones en total: 149 pruebas de escaneo automatizadas + 280+ preguntas de revisión de hardening.
Baseline: 8 pruebas en cada ejecución
Autenticación rota
Comprueba si un endpoint que requiere autenticación funciona sin token o con un token basura.
Cómo: Repite la petición sin cabecera Authorization y con un token aleatorio; un 2xx significa que la comprobación de autenticación falta o está rota.
Ejemplo: GET /users/me devuelve 200 sin ningún token → cualquiera puede leer el perfil.
BOLA / IDOR
Comprueba si cambiar el ID de un recurso da acceso a los datos de otra persona (autorización rota a nivel de objeto).
Cómo: Aplica heurísticas sobre parámetros tipo ID: prueba otros identificadores típicos y compara respuestas para detectar fuga de datos.
Ejemplo: GET /orders/124 devuelve el pedido de otro cliente → fuga de datos crítico.
Mass assignment
Comprueba si el servidor acepta en silencio campos extra que nunca se documentaron.
Cómo: Añade campos extra al payload y busca su eco o persistencia en la respuesta.
Ejemplo: POST /users acepta {"is_admin": true} → escalada de privilegios.
Inyección (SQL / NoSQL / JSON)
Sondea parámetros de consulta y campos del cuerpo en busca de fallos de inyección.
Cómo: Envía payloads clásicos SQL/NoSQL/JSON y compara firmas de error y anomalías de tiempo en las respuestas.
Ejemplo: ' OR '1'='1 en ?search= provoca un error SQL → parámetro inyectable.
Rate limiting
Comprueba si la API limita las peticiones repetidas.
Cómo: Dispara una ráfaga de peticiones idénticas a un endpoint; si no hay 429, la fuerza bruta y el scraping quedan abiertos.
Ejemplo: 12 POST /login rápidos sin 429 → posible credential stuffing.
Mala configuración de CORS
Comprueba si la API refleja Origins arbitrarios permitiendo credenciales.
Cómo: Envía cabeceras Origin maliciosas e inspecciona Access-Control-Allow-Origin / Allow-Credentials.
Ejemplo: Origin: https://evil.example reflejado con credenciales → robo de sesión desde el navegador.
Cabeceras de seguridad
Comprueba si faltan cabeceras HTTP de seguridad básicas.
Cómo: Lee las cabeceras de respuesta (nosniff, frame options, HSTS, CSP, referrer policy) en cada objetivo.
Ejemplo: Faltan X-Content-Type-Options y protecciones de frame → riesgo de clickjacking / MIME-sniffing.
Parámetros sensibles
Encuentra secretos, tokens y contraseñas enviados en la query string de la URL.
Cómo: Analiza los nombres de parámetros en busca de claves tipo secreto (token, key, password, secret) que acaban en logs e historial del navegador.
Ejemplo: GET /reset?token=abc123 en la URL → el secreto acaba en los logs del proxy.
Deep: 141 pruebas más para escaneos programados y de release
Descubrimiento de shadow APIs
Encuentra endpoints no documentados que responden a tus espaldas (admin, debug, versiones antiguas, backups).
Cómo: Sondea variantes comunes de rutas documentadas y rutas globales (/health, /swagger.json, /actuator); un 2xx/3xx en una ruta no documentada es un hallazgo.
Ejemplo: /admin/users responde 200 pero no aparece en la spec → superficie de ataque oculta.
Debilidades JWT
Ataca el token en sí: alg=none, firma no verificada, secreto HMAC débil, falta de expiración, key-confusion.
Cómo: Primero el baseline (un token válido funciona y uno basura se rechaza; si no, es autenticación rota); después reenvía tokens mutados solo a endpoints protegidos.
Ejemplo: Token con alg=none aceptado → cualquiera puede falsificar sesiones.
Manipulación de métodos HTTP
Comprueba si el control de acceso solo está aplicado al método documentado.
Cómo: Prueba la misma ruta con otros verbos (GET→POST/PUT/DELETE); un 2xx con contenido en un método no declarado es un bypass.
Ejemplo: GET /admin → 403, pero POST /admin → 200 → bypass de autorización.
Fingerprint de tecnología + actualidad de versión
Identifica el stack del servidor a partir de cabeceras y páginas de error y marca software al final de su vida útil.
Cómo: Recoge cabeceras Server / X-Powered-By de GET / y de un 404 deliberado, comparándolas con una tabla de versiones integrada; EOL es gravedad alta.
Ejemplo: Server: PHP/7.4 (fin de vida) → probables CVEs sin parchear.
Mass assignment v2 (escalada de solo lectura)
Va un paso más allá de v1: demuestra escalada de privilegios mediante campos de solo lectura.
Cómo: Envía sondas canary, ignora los campos declarados en el schema y exige un eco exacto del valor; solo los campos clasificados por permisos (role, is_admin) elevan a alto.
Ejemplo: {"role":"admin"} echoed back exactly → confirmed escalation.
Checklist de revelación de información
Barre rutas sensibles conocidas (.git, .env, consolas de debug, actuators, métricas).
Cómo: Cuenta contenido, no estado: un hallazgo necesita un marcador real en el cuerpo; cuerpos vacíos y páginas de login no cuentan. Además, detección de stack traces en una ruta inexistente.
Ejemplo: /.git/config leaks repository internals → high.
Rate-limit v2 (diferencial + bypass)
Plantea las preguntas más incómodas: ¿el login está limitado cuando el resto también? ¿Se puede saltar el límite con una cabecera IP falsificada?
Cómo: Compara un endpoint de autenticación con uno neutro y luego repite con rotación de X-Forwarded-For en condiciones controladas.
Ejemplo: Login ilimitado junto a una API limitada → credential stuffing; rotación XFF esquiva el 429 → alto.
Versiones antiguas de API
Comprueba si los endpoints retirados /v1/ siguen vivos con protección más débil.
Cómo: Para rutas /vN/ documentadas prueba /v(N-1)/ y /v1/ sin autenticación; un 2xx antiguo frente a 401/403 nuevo es un bypass, y un 2xx antiguo frente a 404 nuevo es un endpoint zombi.
Ejemplo: /v1/orders returns 200 while /v2/orders demands auth → old version bypasses access control.
Sondeo GraphQL
Detecta endpoints GraphQL, introspección activa en producción y falta de límites de coste de consultas.
Cómo: Prueba rutas típicas /graphql, envía una consulta de introspección (volcado del schema = medio) y luego una consulta anidada costosa (éxito = sin límites de coste).
Ejemplo: La introspección devuelve el schema completo en prod → el atacante obtiene todo el mapa gratis.
Comprobación de redirect OAuth2 / OIDC
Prueba el login OAuth del cliente en busca de open-redirect en redirect_uri (robo de códigos/tokens).
Cómo: Lee /.well-known/openid-configuration y sondea authorize con un redirect_uri malicioso sin seguir redirecciones; un 302 a un host externo es alto. Nunca se atacan proveedores de identidad externos.
Ejemplo: authorize?redirect_uri=https://evil.example → 302 allí → robo de código.
Cadena CORS + CSRF
Ataca la lógica de la allowlist, no solo el reflejo simple.
Cómo: Sondea Origin: null, dominios parecidos ({host}.evil.example) y preflight en métodos de escritura con credenciales.
Ejemplo: Origin null de confianza con credenciales → robo de sesión desde iframe en sandbox.
Canary SSRF
Comprueba si la API obtiene URLs proporcionadas por el atacante (SSRF), de forma segura y contra nuestro propio listener.
Cómo: Coloca nuestra URL canary en campos con forma de URL (webhook, avatar, import); un callback a nuestra infraestructura demuestra SSRF. Nunca se ataca a terceros.
Ejemplo: POST /webhooks con nuestra URL → el servidor llama de vuelta → SSRF confirmado.
Flags de cookie de sesión
Comprueba que las cookies de sesión en endpoints de login llevan Secure, HttpOnly y una política SameSite estricta.
Cómo: Lee Set-Cookie en respuestas de login; un hallazgo por flag ausente. Solo cuentan respuestas con Set-Cookie: sin cookie no hay hallazgo.
Ejemplo: POST /login crea la sesión sin HttpOnly → robable vía XSS.
Enumeración de IDs predecibles
Comprueba si los IDs secuenciales de recursos se pueden extraer uno a uno (enumeración de usuarios).
Cómo: Solicita IDs 1/2/3 en rutas con plantilla; tres conjuntos de datos distintos indican IDs enumerables. Los 404 uniformes no cuentan. Se ejecuta una vez por escaneo.
Ejemplo: /users/1, /users/2, /users/3 devuelven perfiles → base de usuarios cosechable.
Oráculo de tiempo de respuesta
Comprueba si el tiempo de respuesta del login depende del secreto (canal lateral temporal).
Cómo: Alterna contraseñas cortas y largas (4 rondas); bandas de tiempo no solapadas con más de 200 ms de diferencia generan un hallazgo de gravedad baja. Se ejecuta una vez por escaneo.
Ejemplo: Las contraseñas largas tardan sistemáticamente 300 ms más → oráculo temporal que conviene corregir.
Path traversal / LFI
Comprueba si los parámetros de archivo llegan al sistema de archivos del servidor (inclusión local de archivos).
Cómo: Envía ../ y variantes codificadas; el marcador /etc/passwd en el cuerpo es un hallazgo alto. Máximo 2 sondas por objetivo.
Ejemplo: ?file=../../../../etc/passwd devuelve root:x:0: → archivos del servidor legibles.
Redirección abierta
Comprueba parámetros de redirección en busca de open-redirect a hosts del atacante (phishing / robo de tokens).
Cómo: Coloca https://evil.example en parámetros tipo next/url/redirect sin seguir redirecciones; un 3xx con Location allí es alto.
Ejemplo: /goto?next=https://evil.example → 302 there → login-code theft.
HTTP TRACE / TRACK
Comprueba si los métodos peligrosos TRACE/TRACK están activos (cross-site tracing).
Cómo: Envía OPTIONS una vez por escaneo; una cabecera Allow con TRACE/TRACK genera un hallazgo bajo.
Ejemplo: Allow: GET, POST, TRACE, TRACK → cookies legibles vía XST.
Archivos backup / editor
Comprueba si copias de backup (.bak, ~) de rutas documentadas se sirven con código fuente.
Cómo: Prueba sufijos .bak y ~; un 200 con marcadores de código fuente es un hallazgo bajo. Limitado a 8 peticiones por escaneo.
Ejemplo: /config.js.bak sirve el código fuente del servidor → secretos y lógica filtrados.
Credenciales por defecto
Comprueba si los logins de fábrica (admin:admin, admin:password) siguen funcionando.
Cómo: Prueba dos pares por defecto solo en el endpoint de login, una vez por escaneo; un login que concede token es alto. Nunca toca cuentas reales de usuario.
Ejemplo: POST /session admin:admin → token de sesión → toma de control total.
Trucos null-byte / unicode
Comprueba si codificaciones null-byte y unicode sobredimensionado saltan los filtros de entrada.
Cómo: Compara una sonda baseline con payloads %00 y %c0%ae; marcadores de sistema de archivos o un cambio 404→200 generan un hallazgo.
Ejemplo: ..%c0%ae/etc/passwd devuelve root:x:0: → bypass de filtro.
Reutilización de código OAuth
Comprueba si un código de autorización se puede canjear dos veces (debe ser de un solo uso).
Cómo: Envía el mismo código de sonda dos veces al endpoint de token; dos concesiones de token significan códigos reutilizables.
Ejemplo: Mismo código → dos access tokens → el código interceptado nunca muere.
Reutilización de OTP
Comprueba si un código de un solo uso sobrevive a su primera verificación (debe quemarse al usarse).
Cómo: Envía el mismo código dos veces a endpoints verify/OTP; dos éxitos significan OTP reutilizable. Los códigos ya quemados no cuentan.
Ejemplo: El mismo 000000 verifica dos veces → código SMS interceptado reutilizable.
Falsificación de cookie firmada
Comprueba si la cookie de sesión es dato controlado por el cliente que puede reescribirse a admin.
Cómo: Inicia sesión, decodifica una cookie base64/JSON, falsifica role→admin y la reenvía a rutas protegidas; marcadores de admin solo con la cookie falsificada indican confianza sin firma. Los tokens opacos no cuentan. Se ejecuta una vez por escaneo.
Ejemplo: Cookie de sesión falsificada → /profile devuelve admin:true → toma de control total.
Deserialización insegura
Comprueba si los datos de la petición llegan a un deserializador del servidor (pickle / Java / PHP).
Cómo: Envía magic bytes (pickle, Java STREAM_MAGIC, PHP serializado) en campos del cuerpo; los marcadores de error de deserializador son altos. Los 400 limpios no cuentan.
Ejemplo: Magic bytes → pickle.UnpicklingError → ruta de ejecución remota de código.
Inyección SQL ciega (basada en tiempo)
Detecta inyección SQL por diferencia de tiempo de respuesta, no solo por marcadores de error.
Cómo: Compara un GET baseline con un payload SLEEP(2) en el mismo parámetro; un Δt superior a 1,5 s sin error indica inyección ciega. Una ejecución, 2 peticiones.
Ejemplo: q=1' AND SLEEP(2)-- - → +2,0 s de retraso → alto.
Marcadores de comando OS / LDAP
Comprueba si la entrada llega a un shell o servidor de directorio (`;id`, `|whoami`, filtros LDAP).
Cómo: Envía separadores de comando y un filtro LDAP en parámetros de consulta; una salida uid=/gid= o excepciones LDAP (sin mero reflejo) indican ejecución. Los ecos limpios no cuentan.
Ejemplo: host=|whoami → uid=0(root) en el cuerpo → alto.
Bypass de HTTP method-override
Comprueba si X-HTTP-Method-Override redirige la petición saltándose las comprobaciones de verbo.
Cómo: Envía un POST baseline y luego repite con X-HTTP-Method-Override: DELETE; un cambio de error→éxito con cuerpo distinto indica que se respeta el override.
Ejemplo: POST → 405, mismo POST + override → 200 deleted:true → medio.
Mass assignment anidado
Prueba binders de objetos profundos con payloads {"user":{"role":"admin"}}.
Cómo: Envía un baseline y un cuerpo anidado con role=admin; marcadores de admin solo en la respuesta anidada indican que el binder no tiene allowlist recursiva.
Ejemplo: role=admin anidado → "role":"admin" reflejado → medio.
Valores secretos en actuator
Lee /actuator/env, /actuator/configprops y /metrics en busca de valores secretos expuestos.
Cómo: Obtiene cada ruta una vez por escaneo; una palabra clave de secreto junto a un valor entre comillas (no solo un 200) indica que el actuator filtra credenciales.
Ejemplo: /actuator/env → "db.password" con valor → alto.
PII en páginas de error
Comprueba si los cuerpos 4xx devuelven datos personales (emails, IBAN, PESEL con contexto).
Cómo: Solicita una ruta inexistente por escaneo y aplica regex al cuerpo de error; se excluyen extensiones de imagen/estáticos. Los errores genéricos no cuentan.
Ejemplo: 404 Traceback → [email protected] → medio (GDPR).
Secretos en sourcemaps
Rastrea bundles públicos *.map en busca de API keys y tokens embebidos.
Cómo: Obtiene rutas de map comunes una vez por escaneo y aplica el índice de patrones de secretos sobre sourcesContent; los mapas sin coincidencias no cuentan.
Ejemplo: main.js.map → AKIA… → high source leak.
Cadena de toma de control auth-to-RCE
Repite la kill-chain oracle-forge-escalate-deserialize de principio a fin: oracle → forge → escalate → deserialize en una sola ejecución.
Cómo: Inicia sesión, falsifica la cookie de sesión a admin, confirma que el panel de admin confía en ella y envía magic bytes pickle al import de admin como admin; cada eslabón debe confirmarse o no hay hallazgo. 3 peticiones, una ejecución.
Ejemplo: Cookie falsificada → /admin confía → /admin/import deserializa → toma de control total de cadena completa crítica.
Versión del servidor → búsqueda de CVE
Asocia la versión de servidor identificada con CVEs conocidos de una caché local de NVD (actualizada cada noche).
Cómo: Lee Server / X-Powered-By una vez por escaneo y compara las líneas de release con el índice offline; la gravedad sigue la puntuación CVSS. Los stacks desconocidos no cuentan.
Ejemplo: Server: nginx/1.18.0 → CVE-2021-23017 (CVSS 7.7, alto).
SCA de librerías incluidas
Encuentra librerías JavaScript desactualizadas en tus bundles y las asocia a CVEs (avisos OSV).
Cómo: Recoge scripts del mismo origen (máximo 4 peticiones por escaneo), extrae versiones (jQuery, lodash, React, Vue…) y las busca en el índice offline. Las librerías modernas no cuentan.
Ejemplo: jQuery 3.4.1 en el bundle → CVE-2020-11022/11023 (XSS).
IDOR por lotes
Comprueba si los endpoints masivos devuelven objetos de otras personas sin autorización por registro.
Cómo: Envía ids [1,2,3] a campos de lote y compara claves de propietario (user_id, email…); objetos de 2+ propietarios en una respuesta son un hallazgo. Los lotes de un solo propietario no cuentan.
Ejemplo: POST /batch/orders → alice, bob y carol en una llamada → falta autorización por registro.
Protección contra fraude SMS
Comprueba si los endpoints de mensajería aceptan números no enrutables (falta protección de rangos premium).
Cómo: Envía un número ficticio +1555 que nunca puede enrutarse ni generar coste; un veredicto «sent/queued» indica que no hay protección contra toll-fraud. Los números rechazados no cuentan.
Ejemplo: +15550001111 reportado como enviado → probablemente los números premium también se facturan.
Secretos en respuestas
Analiza cuerpos de respuesta en busca de claves, tokens y números de tarjeta filtrados (AWS, GitHub, Stripe, Slack, PEM, PAN).
Cómo: Patrones deterministas sobre hasta 5 respuestas por escaneo; los números de tarjeta requieren validación Luhn y contexto cercano, y las muestras se enmascaran a los últimos 4 caracteres. Las páginas limpias no cuentan.
Ejemplo: token ghp_… en /page → alto; rota y purga.
Política de divulgación security.txt
Comprueba si el sitio publica un contacto security.txt para investigadores.
Cómo: Lee /.well-known/security.txt (fallback /security.txt), máximo 2 peticiones por escaneo; un archivo sin Contact cuenta como ausente. Los archivos publicados no cuentan.
Ejemplo: Ambas rutas 404 → bajo; añade Contact + política de divulgación.
Aplicación de DMARC
Comprueba si el dominio aplica DMARC (anti-spoofing para phishing de remitente exacto).
Cómo: Consulta pasiva de DNS TXT para _dmarc (cero peticiones HTTP); registro ausente es medio, una política sin reject es bajo, p=reject no cuenta.
Ejemplo: Sin registro _dmarc → los atacantes pueden suplantar tu dominio.
Reconocimiento por Certificate Transparency
Enumera subdominios expuestos en logs públicos de Certificate Transparency.
Cómo: Una petición a crt.sh por escaneo; los nombres descubiertos (dev, staging…) se reportan como inventario de superficie de ataque. Offline o vacío no cuenta.
Ejemplo: dev.example.com en el log CT → revísalo o retíralo.
Enumeración de subdominios comunes
Comprueba si nombres adivinables (www, api, dev, staging, admin…) resuelven públicamente.
Cómo: Solo consultas DNS A (cero peticiones HTTP, wordlist de 10 nombres); los nombres que resuelven se reportan como inventario. Si no resuelve nada, no cuenta.
Ejemplo: staging.example.com resuelve → ¿está protegido?
Fingerprint de WAF/CDN
Identifica el stack de edge (Cloudflare, CloudFront, Akamai…) a partir de marcadores pasivos.
Cómo: Un GET / por escaneo, solo marcadores de cabecera y cookie (cf-ray, x-amz-cf-id…); informativo, alimenta la pregunta de reglas WAF en ask mode.
Ejemplo: Edge: Cloudflare → confirma reglas SSRF en WAF.
Cabeceras de ciclo de vida de API (Sunset)
Comprueba si los endpoints versionados (/v1/…) anuncian deprecación.
Cómo: Solo se sondean rutas GET versionadas; la ausencia de cabeceras Sunset/Deprecation es informativa. Los ciclos de vida anunciados no cuentan.
Ejemplo: /v1/orders without Sunset → stale version risk.
Secretos en ejemplos OpenAPI
Analiza especificaciones OpenAPI/Swagger publicadas en busca de secretos con aspecto real en valores de ejemplo.
Cómo: Lee openapi.json / swagger.json / api-docs (máximo 3 peticiones) y compara patrones de claves/tokens; las especificaciones limpias no cuentan.
Ejemplo: "example": "ghp_…" en la spec → medio; los desarrolladores lo copian.
Confusión de algoritmos JWT
Comprueba si el verificador fija un solo algoritmo (confusión RS→HS, alg=none con firma, falta de aud).
Cómo: En endpoints con un JWT Bearer válido: reenvía la firma RS/EC con cabecera HS256, un token alg=none con bytes de firma y marca la falta de claim aud. Los verificadores limpios solo reciben la nota baja de aud.
Ejemplo: Firma RS256 aceptada como HS256 → falsifica tokens con la clave pública.
Fijación de sesión
Comprueba si el ID de sesión se rota al iniciar sesión.
Cómo: Toma una cookie sid previa al login, inicia sesión con ella y compara: el mismo sid tras el login es medio. Los logins rotados o rechazados no cuentan. Máximo 2 peticiones por escaneo.
Ejemplo: sid=abc antes y después de /login → las sesiones plantadas por el atacante sobreviven.
Validación de refresh token
Comprueba si el endpoint de refresh emite tokens para entradas basura.
Cómo: Envía un refresh_token inválido a endpoints de refresh; un access_token en una respuesta 200 es alto. La reutilización de un token válido necesita un token real → fallback a ask.
Ejemplo: Refresh basura → 200 con access_token → validación rota.
Degradación de PKCE
Comprueba si el endpoint authorize emite códigos sin PKCE.
Cómo: Lee openid-configuration y solicita authorize sin code_challenge (sin seguir redirecciones); un código en Location es medio. Si no hay discovery, no cuenta.
Ejemplo: 302 con ?code= y sin challenge → riesgo de interceptación para clientes públicos.
Repetición de logout
Comprueba si POST /logout invalida realmente el token.
Cómo: Hace baseline de un token válido en /me, llama a logout y lo reenvía: seguir devolviendo 200 es medio. Solo funciona con el token proporcionado por el escaneo (el tuyo). Máximo 3 peticiones.
Ejemplo: Token vivo tras logout → los tokens robados siguen siendo utilizables.
Envenenamiento de Host header
Comprueba si los enlaces de reset/verify se construyen con el Host proporcionado por el atacante.
Cómo: Envía Host: evil.com y X-Forwarded-Host a endpoints de login/reset; el host malicioso dentro de un enlace reset/verify/token es alto. Máximo 2 peticiones por escaneo.
Ejemplo: El email de reset enlaza a evil.com → toma de control de cuenta.
Bypass de auth con cabeceras mágicas
Comprueba si las cabeceras de confianza del proxy (X-Forwarded-For, X-Original-URL…) saltan la autorización.
Cómo: Hace baseline de un token válido frente a un 401 anónimo y luego repite anónimamente con 4 cabeceras mágicas; un 200 es alto. Los endpoints públicos no cuentan. Máximo 6 peticiones.
Ejemplo: X-Original-URL como anónimo → 200 → bug de confianza en el gateway.
Evasiones de validación de redirect
Comprueba la validación de redirect frente a trucos con barra invertida y espacios.
Cómo: Reenvía 5 payloads codificados (/\, %5c, tab…) a parámetros de redirect sin seguir redirecciones; un host malicioso en Location es alto. Amplía la prueba simple de open-redirect.
Ejemplo: ?next=%5cevil.com → 302 allí → validador ingenuo.
Mass assignment por query string
Comprueba si ?role=admin en la consulta se fusiona con campos privilegiados.
Cómo: Envía el mismo cuerpo dos veces (limpio vs ?role=admin&isAdmin=true) y compara: nuevos marcadores de admin solo en la variante con query son altos. 2 peticiones por objetivo.
Ejemplo: POST /users?role=admin → "role":"admin" en la respuesta.
Oráculo de errores (403 vs 404)
Comprueba si los códigos de error revelan qué objetos existen.
Cómo: Compara IDs con la misma forma (1 vs 999999999) con token: una división 403/404 es informativa. Las respuestas uniformes no cuentan.
Ejemplo: 403 en /orders/1, 404 en /orders/9… → enumeración de IDs.
Inyección en sort/filter
Comprueba si los parámetros sort/filter llegan al motor de consultas.
Cómo: Sondea ?sort=password y filter[$ne]; un 500 con marcadores de base de datos es medio. Los 200 limpios no cuentan. Máximo 3 peticiones por objetivo.
Ejemplo: ?sort=password → psycopg SyntaxError → superficie de inyección.
Secreto en query de URL
Marca endpoints GET que llevan secretos en la query string.
Cómo: Análisis pasivo de la spec (cero peticiones): token/reset_token/session en parámetros de consulta es medio. Los secretos van en cabeceras o cuerpo.
Ejemplo: GET /reset?reset_token=… → medio; fuga vía Referer/logs.
Bypass del flag MFA
Comprueba si el endpoint de step-up confía en un flag MFA proporcionado por el cliente.
Cómo: Envía flags mfa_passed/mfa_verified a endpoints de verificación (máximo 3 peticiones); un veredicto de token/éxito es crítico.
Ejemplo: {"mfa_passed":true} → 200 con token → 2FA decorativo.
Auditoría de scopes/grants OAuth
Audita los scopes anunciados y el endpoint de token en busca de emisión abierta.
Cómo: Lee openid-configuration (scopes tipo admin → info) y prueba client_credentials con secreto incorrecto + scope=admin; un token es crítico. Máximo 2 peticiones.
Ejemplo: Secreto basura → access_token → falta comprobación de credenciales.
Protección contra fuerza bruta OTP
Comprueba si los endpoints de verificación limitan los intentos.
Cómo: Envía 5 códigos erróneos; cualquier veredicto de 429/bloqueo/enfriamiento no cuenta, cinco rechazos simples son medios. Máximo 5 peticiones por escaneo.
Ejemplo: 5 códigos erróneos sin 429 → espacio de 6 dígitos enumerable.
Protección contra fatiga de push MFA
Comprueba si los desafíos push tienen enfriamiento.
Cómo: Envía 3 peticiones push seguidas; un enfriamiento/429 no cuenta, 3 aceptaciones son medias. Máximo 3 peticiones.
Ejemplo: 3 pushes aceptados al instante → riesgo de fatiga/phishing.
Señal de step-up en acciones sensibles
Marca acciones sensibles (transfer, payout, admin) aceptadas con tokens sin amr/acr.
Cómo: Comprobación pasiva de claims JWT en rutas POST sensibles (cero peticiones); los tokens con amr/acr no cuentan. Señal informativa de hardening.
Ejemplo: POST /transfer sin amr/acr → verifica step-up en el servidor.
Sonda SSTI
Comprueba si las expresiones de plantilla se evalúan en el servidor.
Cómo: Envía {{7*7}} y ${7*7} en campos de texto; un 49 desnudo sin eco es alto. Máximo ~6 peticiones por escaneo.
Ejemplo: {{7*7}} → 49 → RCE-adjacent template injection.
Fingerprint de motor SSTI
Identifica el motor de plantillas detrás de un SSTI con sintaxis específica de cada motor.
Cómo: Prueba marcadores ERB/Ruby/Smarty/Twig una vez cada uno; la evaluación es alta con el motor nombrado en la evidencia.
Ejemplo: <%= 7*7 %> → 49 → ERB fingerprint.
Sonda XXE
Comprueba si la entrada XML resuelve entidades externas.
Cómo: Envía un DOCTYPE con una entidad interna canary como application/xml; la expansión es alta y la revelación de errores del parser es media. Máximo 2 peticiones.
Ejemplo: &xxe; → XXE_PROBE en la respuesta → riesgo de archivo/SSRF.
Inyección CRLF/header
Comprueba si un CRLF en parámetros se convierte en cabecera de respuesta.
Cómo: Inyecta payloads %0d%0a en parámetros de consulta; una cabecera de respuesta X-Scan-Probe es alto. Máximo 3 peticiones.
Ejemplo: CRLF inyectado → cabecera de respuesta → riesgo de splitting.
Prototype pollution
Comprueba si las claves __proto__/constructor persisten en el servidor.
Cómo: Envía claves contaminadas y luego lee el objeto de vuelta; el marcador en la lectura es alto. 2 peticiones.
Ejemplo: __proto__ survives into GET → object pollution.
Contaminación de parámetros HTTP
Comprueba cómo resuelve el servidor parámetros de consulta duplicados.
Cómo: Compara respuestas con parámetro único vs duplicado (?id=1&id=2); un error del parser por el duplicado es bajo y marca revisión manual de rutas de auth.
Ejemplo: Duplicado → 500 con error de BD → confusión del parser.
Fingerprint de dialecto SQL
Identifica el motor de base de datos a partir del texto de error.
Cómo: Envía una comilla simple una vez por escaneo; un marcador de dialecto (psycopg, mysql, sqlite, mssql, oracle, mongodb) es informativo y orienta payloads posteriores.
Ejemplo: ' → psycopg2.SyntaxError → PostgreSQL.
Inyección de segundo orden
Planta un marcador almacenado y comprueba si vuelve sin escapar.
Cómo: Escribe un canary con comillas/corchetes y luego lo lee; caracteres especiales en crudo son medios. 2 peticiones. La salida escapada en HTML no cuenta.
Ejemplo: La nota almacenada devuelve comillas en crudo → riesgo en export/admin sinks.
Login con type-juggling
Prueba contraseñas que no son strings (true, array, $gt, 0) en el login.
Cómo: Hace baseline con contraseña incorrecta (debe ser 4xx) y envía 4 sondas tipadas; cualquier login aceptado es alto. Máximo 5 peticiones.
Ejemplo: password=true → token → bug de comparación laxa en auth.
Atomicidad de lotes
Comprueba si un lote con una operación inválida se rechaza o se traga.
Cómo: Envía [válido, inválido] en un lote (1 petición); la aceptación completa sin error por elemento es media.
Ejemplo: Operación inválida absorbida en silencio → ejecución parcial.
Protección contra replay
Comprueba si se respeta Idempotency-Key en endpoints que mueven dinero.
Cómo: Envía dos POST con la misma clave (2 peticiones); dos IDs de recurso distintos son altos, el mismo ID no cuenta.
Ejemplo: Misma clave, dos IDs de pedido → doble cobro.
Manipulación de carrito/precio
Comprueba si se confía en campos de dinero del lado del cliente.
Cómo: Muta price/amount/total/qty (máximo 3 peticiones); un precio 0.01 aceptado o un mutante cercano a qty -1 es alto.
Ejemplo: price=0.01 aceptado → los totales no se recalculan.
Adivinación de cupones
Comprueba si una cadena de cupón a la primera concede descuento.
Cómo: Envía coupon=SCAN10 una vez; los marcadores de descuento en la respuesta son bajos.
Ejemplo: Código adivinado → descuento → hay códigos de prueba activos.
Importe por debajo del céntimo
Comprueba si el dinero fraccionario se normaliza.
Cómo: Envía 0.9999999 una vez; la aceptación sin error es baja (superficie de deriva de redondeo).
Ejemplo: 0.9999999 aceptado → usa céntimos enteros.
Duplicados concurrentes
Envía dos mutaciones idénticas en paralelo en flujos de un solo uso.
Cómo: Dos POST paralelos (2 peticiones); que ambos tengan éxito es bajo y marca revisión TOCTOU (locks/idempotencia).
Ejemplo: Doble canje aceptado → revisión de atomicidad.
Dinero negativo
Comprueba si se rechazan qty/amount negativos.
Cómo: Envía -1 y -5 (máximo 2 peticiones); la aceptación es alta (vector de reembolso/crédito).
Ejemplo: qty=-1 aceptado → manipulación de crédito.
Cambio de moneda
Comprueba si se acepta un código de moneda falso tal cual.
Cómo: Envía currency=XXX/xxx (máximo 2 peticiones); la aceptación es media.
Ejemplo: XXX aceptado → allowlist ISO-4217.
Manipulación de envío
Comprueba si un método elegido por el cliente pone a cero el coste de envío.
Cómo: Envía shipping_method=pickup una vez; una tarifa cero en la respuesta es baja.
Ejemplo: Método del cliente → envío 0 → tablas de precios en servidor.
Fórmula CSV en export
Comprueba endpoints de export en busca de celdas con fórmulas sin escapar.
Cómo: Solicita CSV una vez; celdas que empiezan por =/+/-/@ son medias (inyección de hoja de cálculo en el sink).
Ejemplo: =1+1 en export → sanea los sinks.
Límite de enteros
Sondea campos numéricos con valores límite de 32 bits.
Cómo: Envía 2^31 y -(2^31)-1 (máximo 2 peticiones); un 500 o una aceptación silenciosa es bajo.
Ejemplo: 2^31 → 500 → superficie de overflow.
Tolerancia a campos desconocidos
Comprueba si las rutas de escritura rechazan campos desconocidos.
Cómo: Añade un campo extra (1 petición); la aceptación es informativa (superficie de deriva/mass assignment).
Ejemplo: Campo extra 2xx → ¿schemas estrictos?
Versión legacy accesible
Comprueba si /v{n-1} responde junto a /v{n}.
Cómo: Solicita la ruta legacy una vez; un 2xx es bajo (huecos de auth/validación legacy).
Ejemplo: /v1 vivo junto a /v2 → retíralo o haz backport.
Salto de estado de workflow
Intenta fijar directamente un estado terminal del workflow.
Cómo: Envía status=completed/approved (máximo 2 peticiones); la aceptación es media: las transiciones deben dirigirlas el servidor.
Ejemplo: status=completed aceptado → protege las transiciones.
IDOR con UUID + predictibilidad
Cambia un UUID de la ruta por un UUID nulo y compara objetos.
Cómo: Baseline 200 y luego un UUID alternativo (máximo 3 peticiones); un objeto distinto con 200 es alto: los UUID son identificadores, no capacidades.
Ejemplo: UUID ajeno → 200 con datos → falta authz.
Forma de request smuggling
Comprueba si se procesa un cuerpo a pesar de Content-Length: 0.
Cómo: Envía un cuerpo con CL:0 una vez; el procesamiento con eco es medio y marca confirmación con socket crudo (desync CL/TE).
Ejemplo: Cuerpo procesado con CL:0 → superficie de desync.
Fingerprint de subdomain takeover
Comprueba la respuesta raíz en busca de huellas de hosts colgantes.
Cómo: Un GET / por escaneo; un 404/410 con marcadores de GitHub-Pages/S3/Heroku es alto: audita el CNAME.
Ejemplo: Marcadores de CNAME colgante → recupera el DNS.
Postura TLS (HSTS + caducidad)
Comprueba HSTS en HTTPS y la caducidad del certificado.
Cómo: La falta de HSTS es baja; un certificado que caduca en 30 días es medio (comprobación de socket best-effort, segura offline).
Ejemplo: Sin HSTS → superficie de SSL-stripping.
Confusión de rutas
Prueba variantes /../, //, mayúsculas, barra final y punto y coma de rutas protegidas.
Cómo: Hace baseline de una ruta 401/403/404 y luego 6 variantes; cualquier 200 es alto (división de normalización en gateway/auth).
Ejemplo: //ADMIN → 200 → canonicalize before auth.
Bypass por doble codificación
Prueba rutas %252e, %c0%ae y con barra unicode.
Cómo: Tres sondas codificadas por escaneo; un 200 es alto: la autorización se ejecuta sobre la forma cruda.
Ejemplo: %252e%252e → 200 → decode-then-authorize.
Bypass de representación WAF
Repite un ataque bloqueado por WAF con un ajuste de representación.
Cómo: Hace baseline de un 403 con marcadores WAF y luego variantes percent/case (máximo 3 peticiones); un 200 es alto.
Ejemplo: El mismo payload pasa codificado → normaliza en el WAF.
Auth en handshake WebSocket
Comprueba si los endpoints WS se actualizan sin credenciales.
Cómo: Envía un handshake WS a rutas hint más /ws y /socket (máximo 2 alcanzadas); un 101 es medio: verifica Origin + auth.
Ejemplo: 101 sin token → revisión de auth en handshake.
Superficie gRPC + errores verbosos
Sondea framing gRPC y errores con forma de reflexión.
Cómo: Envía un frame con forma de reflexión como application/grpc (máximo 2 peticiones); grpc-status es info, la revelación de stack/SQL es media.
Ejemplo: grpc-status + traceback → mensajes genéricos.
Sobrecarga de alias GraphQL
Comprueba si se responden inline 200 campos con alias.
Cómo: Una consulta __typename con alias; 100+ respuestas inline son medias (CPU/DoS, independiente de los límites de profundidad).
Ejemplo: 200 alias inline → limita el número de campos.
Envenenamiento de caché (entrada sin clave)
Comprueba si cabeceras sin clave acaban en respuestas cacheadas.
Cómo: Envía un canary X-Forwarded-Host/UA y luego una petición limpia (máximo 3); un HIT con reflejo es alto y la persistencia al segundo cliente es media.
Ejemplo: Host malicioso cacheado → las claves cachean de forma segura.
Política Private-Network-Access
Comprueba si Allow-Private-Network se concede de forma amplia.
Cómo: Un preflight con origen público; una concesión true es informativa: limita a una allowlist.
Ejemplo: PNA true para cualquier origen → añádelo a allowlist.
Alcance del Domain de cookie
Marca Domains de cookie con punto inicial o sufijo amplio.
Cómo: Una inspección pasiva de Set-Cookie por escaneo; un alcance amplio es bajo: fija al host exacto.
Ejemplo: Domain=.example.com → compartición entre subdominios.
Upload polyglot / zip traversal
Sube sondas de doble extensión, SVG ejecutable y zip con traversal.
Cómo: Tres subidas inertes (shell.php.jpg, SVG con onload, zip con entrada ../../); la aceptación sin rechazo es media (baja para el zip, ya que no se confirma la extracción). Máximo 3 peticiones.
Ejemplo: shell.php.jpg stored → sniff types + sandbox.
XSS almacenado vía API
Planta marcado ejecutable y comprueba la lectura posterior.
Cómo: Escribe un canary SVG-onload y luego hace GET del objeto (2 peticiones); el retorno en crudo es alto, la salida escapada no cuenta.
Ejemplo: <svg onload> en crudo en GET → codifica sinks + CSP.
Confusión de Content-Type
Reenvía un cuerpo JSON como form y XML al mismo endpoint.
Cómo: Dos peticiones con Content-Type alternativo por escaneo; un veredicto de éxito es medio (división parser/validación).
Ejemplo: Cuerpo form 2xx en endpoint JSON → un solo parser.
Subida EICAR (comprobación AV)
Sube la firma de prueba inerte EICAR a endpoints de archivos.
Cómo: Una subida por escaneo; un veredicto de malware/cuarentena no cuenta (bien), el almacenamiento sin veredicto es bajo.
Ejemplo: EICAR almacenado en silencio → escanea las subidas.
PII en ruta de URL / redirect
Marca emails, formas de PESEL y secretos en rutas y Locations.
Cómo: Comprobación pasiva de rutas más una inspección de redirect (follow_redirects=False); una coincidencia es media: mueve identificadores a cabeceras/cuerpo.
Ejemplo: /users/[email protected] → opaque IDs instead.
Relay de open-proxy
Comprueba si los parámetros ?url=/redirect sirven hosts externos.
Cómo: Apunta parámetros de relay a un host malicioso no enrutable (máximo 2 peticiones); un redirect allí es medio, una petición del lado del servidor es alta.
Ejemplo: ?url=evil → 302 allí → forma de relay C2.
SSRF vía funcionalidad (oráculo de errores)
Comprueba si las funciones webhook/import obtienen URLs arbitrarias.
Cómo: Envía una URL de host caído (máximo 2 peticiones); un error de intento de fetch (texto DNS/socket) es medio: no hace falta listener.
Ejemplo: getaddrinfo canary → salida confirmada.
Validación de canal de callback
Comprueba si se aceptan dominios de callback externos.
Cómo: Registra un callback canary una vez por escaneo; la aceptación es baja y marca confirmación con listener en hacker mode (N2/S9).
Ejemplo: Callback malicioso almacenado → forma de exfiltración DNS.
TTL y alcance de URL prefirmada
Marca URLs firmadas eternas o con alcance wildcard.
Cómo: Análisis pasivo de la spec (cero peticiones): caducidad superior a 7 días o alcance wildcard es medio.
Ejemplo: se=+30d → acorta el TTL por enlace.
Export sin límites
Marca respuestas de list/export enormes y sin paginación.
Cómo: Un GET por candidato; cuerpos de más de 500 KB sin marcadores de paginación (inicio y final) son bajos: pagina y limita.
Ejemplo: Lista plana de 546 KB → forma de exfiltración masiva.
Lectura de archivos en endpoint LOL
Comprueba si las funciones export/preview leen fuera de su directorio.
Cómo: Envía sondas de traversal y file:// a parámetros de funcionalidad (máximo 2 peticiones); los marcadores /etc/passwd son altos.
Ejemplo: /preview?path=…/passwd → root:x: → LFI.
Dead-drop anónimo
Comprueba si las escrituras anónimas se leen de forma anónima.
Cómo: Escribe un canary de forma anónima y lo lee de forma anónima (2 peticiones); una coincidencia es media.
Ejemplo: Nota anónima legible → dead-drop del atacante.
Confused deputy en webhook
Comprueba si se aceptan URLs de webhook de intranet al registrar.
Cómo: Registra URLs loopback y de host caído (máximo 2 peticiones); la aceptación es media: allowlist en el registro.
Ejemplo: http://127.0.0.1:9 stored → deputy SSRF.
Traversal de JWT kid / fetch jku
Sondea path-traversal en kid y fetch jku mediante oráculo de errores.
Cómo: Envía tokens alg=none con kid ../../ y jku de host caído en login (máximo 2 peticiones); los errores de sistema/red son medios.
Ejemplo: ENOENT en kid → sink confirmado.
Cache deception (auth vs anon)
Compara una respuesta autenticada con una anónima para ver si es cacheable.
Cómo: Obtiene la misma URL con y sin credenciales (2 peticiones); cuerpos PII idénticos más un marcador HIT son altos. Necesita contexto de auth; si no, se omite.
Ejemplo: Anon recibe /me cacheado → datos de usuario públicos.
Confusión de cache-key (Host)
Comprueba si un Host falsificado acaba en la caché compartida.
Cómo: Envía Host/X-Forwarded-Host malicioso y luego una petición limpia (máximo 3); el reflejo en un HIT es alto, la persistencia al cliente limpio es media.
Ejemplo: Host malicioso cacheado → envenena a otros.
Envenenamiento de caché CORS
Comprueba si un Origin atacante reflejado se cachea.
Cómo: Envía Origin malicioso y luego una petición limpia (máximo 3); ACAO reflejado en un HIT es alto, la persistencia media.
Ejemplo: ACAO malicioso cacheado → envenenamiento CORS de la víctima.
Señal de throttling en par rápido
Comprueba si peticiones rápidas muestran alguna señal de throttling.
Cómo: Dos GET rápidos por escaneo; un 429 no cuenta (bien), sin contador ni 429 es bajo y marca revisión de ráfaga en el límite.
Ejemplo: Sin 429 ni contadores → verifica los límites.
Combo redirect + CORS
Comprueba si un redirect externo también lleva una concesión CORS de confianza.
Cómo: Apunta un parámetro de relay a un host malicioso con Origin malicioso (máximo 2 peticiones); un 302 allí más ACAO reflejado es medio.
Ejemplo: 302 evil + ACAO evil → combo de phishing.
Flujo de dispositivo OAuth
Comprueba si el polling de device-code emite tokens sin aprobación.
Cómo: Lee discovery (endpoint anunciado → info) y luego hace polling con un código fabricado (máximo 2 peticiones); un token es alto.
Ejemplo: device_code falso → token → vincula la aprobación.
OAuth requiere state/nonce
Comprueba si authorize emite códigos sin state.
Cómo: Llama a authorize sin state/nonce (máximo 2 peticiones); un código sin state reflejado es medio.
Ejemplo: Código sin state → superficie de login-CSRF.
Confianza en JWT x5c
Comprueba si se confía en un certificado x5c proporcionado por el cliente.
Cómo: Envía un token de login con x5c del atacante (1 petición); la aceptación es alta: fija las claves en el servidor.
Ejemplo: Certificado propio aceptado → confusión de claves.
Confusión JWE/plaintext
Comprueba si se acepta una forma de token plaintext sin firmar.
Cómo: Envía un token con forma plaintext alg:dir en login (1 petición); la aceptación es alta.
Ejemplo: Forma sin firmar pasa → un solo tipo de token.
Degradación DPoP
Comprueba si las rutas con hint DPoP aceptan un bearer simple.
Cómo: Solicita una ruta dpop sin prueba DPoP (1 petición); un 200 es medio.
Ejemplo: Sin prueba, 200 → aplica el binding.
Cookie de sesión eterna
Marca cookies de sesión/auth válidas durante meses.
Cómo: Una inspección pasiva de Set-Cookie por escaneo; Max-Age superior a 90 días es bajo: acórtalo con re-auth step-up.
Ejemplo: Max-Age 10a → rota sesiones.
Reutilización de método en URL prefirmada
Comprueba si una firma funciona con otro método HTTP.
Cómo: Reenvía una URL firmada con el método opuesto (máximo 2 peticiones); el éxito es alto: vincula método+ruta+caducidad.
Ejemplo: Firma GET funciona como POST → vincúlala.
Anidamiento JSON profundo
Envía un cuerpo JSON anidado 100 niveles una vez por escaneo.
Cómo: Un 500 es medio, un 2xx lento (>5 s) bajo; los rechazos rápidos no cuentan. Cuerpo pequeño, forma grande.
Ejemplo: Anidamiento → 500 → limita la profundidad.
Fuzz de schema/límites
Muta un campo de texto con cambios de tipo y valores límite.
Cómo: Cinco sondas (2^63, bool, null, string de 10k, array de 5k); un 500 con interioridades o la aceptación silenciosa de un tipo incorrecto es bajo.
Ejemplo: bool para string 2xx → tipos estrictos.
Fuga de sugerencias GraphQL
Comprueba si una errata provoca sugerencias de campos.
Cómo: Una consulta mal escrita; didYouMean/pistas de password son informativas: desactiva sugerencias en prod.
Ejemplo: Typo → ¿quisiste decir password?.
Bypass de auth con persisted query
Comprueba si un hash de consulta almacenada responde de forma anónima.
Cómo: Envía un hash APQ sha256 sin credenciales (máximo 2 peticiones); datos sin error es medio.
Ejemplo: Hash → datos sin auth → protege los hashes.
Evasifón WAF (3 representaciones)
Reenvía un payload XSS bloqueado con doble codificación y mutación de mayúsculas.
Cómo: Hace baseline de un 403 con marcadores WAF y luego dos repeticiones mutadas (máximo 4 peticiones); un 200 con eco es alto.
Ejemplo: El mismo payload pasa codificado → canonicaliza.
Mass assignment por framework
Prueba formas de binder de Rails/Laravel/Django (corchetes, _method, __dict__).
Cómo: Tres mutantes por escaneo; los marcadores de privilegio en la respuesta son medios.
Ejemplo: user[admin] → admin:true → bloquea binders.
Manipulación de cursor
Comprueba si un cursor ajeno/negativo devuelve datos.
Cómo: Compara una página baseline con cursor=-1 (2 peticiones); datos distintos es bajo: firma y limita el alcance de los cursores.
Ejemplo: cursor=-1 → otras filas → cursores opacos.
Control del destinatario de correo
Comprueba si el destinatario del correo viene de la entrada.
Cómo: Inyecta una dirección maliciosa (máximo 2 peticiones); un eco o envío ciego es medio, un destinatario fijo no cuenta.
Ejemplo: To: desde entrada → allowlist.
Token en URL externa / error
Marca tokens embebidos en enlaces externos o páginas de error.
Cómo: Inspecciona una página normal más un 404 con sonda de token (máximo 2 peticiones); hrefs con token son medios, los ecos en errores bajos.
Ejemplo: href con ?token= → fuga por Referer.
Enumeración de códigos de invitación
Prueba códigos de invitación/referido a la primera.
Cómo: Envía 000000/123456/invite-1/test (máximo 4 peticiones); un veredicto de validación es medio.
Ejemplo: 000000 válido → entropía + caducidad.
Bucket de almacenamiento abierto
Comprueba si las URLs de bucket en cuerpos de API listan de forma anónima.
Cómo: Extrae URLs S3/GCS/Azure de una página y obtiene una de forma anónima (máximo 2 peticiones); un listado es medio.
Ejemplo: URL S3 → ListBucketResult → ciérralo.
Señal de password spraying
Comprueba si la adivinación entre cuentas es observable.
Cómo: Prueba una contraseña en tres usuarios (3 peticiones); rechazos simples sin 429/CAPTCHA son bajos.
Ejemplo: Sin señal de spray → controles de velocidad.
Negociación de versión
Comprueba si versiones legacy responden mediante cabeceras.
Cómo: Compara un baseline con una petición X-API-Version:1 (2 peticiones); un 200 distinto es bajo.
Ejemplo: v1 vía cabecera → retírala.
Forma de cookie tossing
Marca cookies de sesión sin prefijo __Host-.
Cómo: Una inspección pasiva de Set-Cookie por escaneo; una cookie de sesión sin prefijo es baja: los subdominios podrían plantarla.
Ejemplo: sess sin __Host- → añade el prefijo.
Repetición de cabecera de tenant
Comprueba si las cabeceras de tenant del cliente dirigen el acceso a datos.
Cómo: Reenvía una petición con X-Tenant-ID/X-Org-ID intercambiados (máximo 2 peticiones); datos distintos con el mismo token es medio: la repetición completa entre tokens es una misión hacker.
Ejemplo: La cabecera other9 filtra filas ajenas → deriva el tenant en servidor.
Higiene de claims del token
Marca tokens de escaneo sin caducidad ni audiencia.
Cómo: Cero peticiones: decodifica el JWT Bearer del escaneo; falta de exp es medio, falta de aud bajo: la repetición entre APIs necesita una segunda API (hacker).
Ejemplo: Sin exp/aud → TTL corto + audiencia fijada.
Encadenamiento de rutas de ataque
Encadena hallazgos entre etapas de la kill-chain en el informe.
Cómo: Cero peticiones: el motor agrupa hallazgos (auth-bypass → acceso a datos → exfiltración) y emite una cadena informativa: entrada para el grafo TTP.
Ejemplo: juggling → export → corrige la cabeza.
Hacker mode (AI): pentest autónomo al estilo humano
Prueba destructiva autorizada: solo dev/staging, nunca producción. Requiere dominio verificado (localhost e IPs privadas exentos).
Planifica y revisa: el LLM mantiene un plan de ataque explícito (IDOR → escalada → secretos → inyecciones) y lo revisa mientras aprende: ves el plan y cada revisión en el informe de escaneo.
Sondea y adapta: el agente envía peticiones, lee fragmentos de respuesta redactados y se corrige tras bloqueos (401/404/429), incluso escribiendo y ejecutando su propio código de exploit en un sandbox restringido (timeout de 15 s, 30 peticiones, sin acceso al sistema).
Encadena playbooks: apúntalo a cookies, sesiones u oráculos y ejecuta la cadena oracle → forge → escalate (timing-oracle → decodificar cookie de sesión → falsificar role→admin → confirmar en endpoints protegidos), con deserialización confirmada solo por marcadores de error, nunca con payloads RCE. Las misiones de lógica de negocio funcionan igual: abuso de precio/cupón/cantidad, race/double-spend, toll-fraud (solo números ficticios), canaries de prompt-injection indirecta, bucles de valor almacenado y fidelidad de extracción de modelos, cada una con reglas de seguridad integradas en el plan.
Objetivos guiados: apúntalo a «comprueba /users en busca de IDOR» o «intenta escalar a admin»; con credenciales guardadas prueba el control de acceso autenticado (tus datos vs los de otro usuario).
Privacidad por diseño: el modelo solo ve rutas relativas anonimizadas, estados y fragmentos; nunca tus URLs o credenciales. Las peticiones se ejecutan en el servidor con la autenticación fuera del contexto del modelo.
Veredicto: la sesión termina con una evaluación de IA (nivel de riesgo, narración de cómo se ejecutó la prueba, recomendaciones) y cada paso guardado en el informe de escaneo.
Capa de IA: payloads, triaje, interpretación
Payloads inteligentes
Antes del escaneo, el LLM lee las formas de tu OpenAPI y genera payloads adaptados por endpoint (IDs, campos extra, inyecciones); después los dispara el motor determinista. ¿Sin clave o con una caída? El motor vuelve a los valores integrados.
Triaje y veredictos
Cada hallazgo recibe una segunda opinión de IA (sugerencia de gravedad, marca de falso positivo, prioridad). Los resultados se cachean por firma de hallazgo y se limitan con un presupuesto de tokens por escaneo; el núcleo determinista siempre funciona sin IA.
Descubrimiento con agente
Un agente de navegador impulsado por LLM (Playwright) recorre el sitio como un humano, sugiere rutas de sonda adicionales y alimenta el escaneo con los endpoints descubiertos, incluso sin OpenAPI.
Ask mode: 320 preguntas de seguridad sobre tu código (SaaS+)
El escáner nunca ve tu código, así que ask mode te pregunta a ti (o a tu asistente de código): 270 preguntas verificables sobre autenticación, autorización, validación de entrada, protección de datos, lógica de negocio, aislamiento de tenants, sesiones, diseño de API, logging, cadena de suministro y SDLC, cada una con gravedad (crítica → baja) y una nota de corrección con cómo verificarla. La IA añade preguntas de seguimiento adaptadas a tus endpoints y profundiza en las respuestas fallidas durante varias rondas. Responde pass / fail / n/a con evidencia de archivo y función, bloquea CI según el resultado y exporta un informe Markdown.
Ejecútalo desde la CLI (liveapisec ask) o el cuestionario del panel: el código fuente nunca sale de tu máquina.
Todo lo demás alrededor de las pruebas
Descubrimiento y deriva
Descubrimiento automático de endpoints (detección automática de OpenAPI, bundles JS, sitemaps, rutas de sonda de IA) más detección de deriva entre escaneos (regresiones, corregidos, nuevos altos/críticos, cambios de fingerprint de configuración) y un endpoint de veredicto de CI que falla solo por hallazgos nuevos frente al baseline.
Priorización basada en riesgo (KEV + EPSS)
Cada hallazgo incluye IDs CVE, una marca CISA Known-Exploited (gravedad autoescalada, solo en el panel, nunca en la Trust Page pública), la puntuación de explotabilidad EPSS y una puntuación de riesgo (0,55·gravedad + 0,30·CVSS + 0,15·EPSS·10). La API de hallazgos admite ?sort=risk para que aparezcan primero los problemas más explotables. Los feeds se actualizan cada noche; los escaneos siempre leen la caché local, así que nunca esperan a la red.
Herramientas externas y cumplimiento
Las integraciones opcionales con ZAP y Nuclei añaden hallazgos adicionales al mismo informe; cada hallazgo abierto se mapea a requisitos PCI DSS 4.0, SOC 2, ISO 27001, GDPR y NIS2 en la vista de cumplimiento.