Listas de Payloads y Políglotas

¿Encontraste un payload que no funciona? Por favor abre un issue con el payload, el contexto objetivo y lo que esperabas que sucediera. Las solicitudes de extracción con correcciones o nuevos payloads siempre son bienvenidas.

La investigación está en curso. Este proyecto está en desarrollo activo y se actualizará regularmente con nuevos payloads, clases de vulnerabilidad y mejoras en la validación.

Aviso legal: Estos payloads se proporcionan únicamente para pruebas de seguridad autorizadas, educación e investigación. Los autores no asumen ninguna responsabilidad por el mal uso o efectos derivados. Úselo completamente bajo su propio riesgo. Al utilizar este proyecto, acepta toda la responsabilidad de sus acciones.

Licencia: MIT - consulta LICENSE

1,353 payloads de inyección validados que cubren 20 clases de vulnerabilidad, 31 frameworks de deserialización y 14 motores de plantillas. Cada payload produce una señal detectable. Cero payloads teóricos.

Validación: 1,353 probados / 1,353 disparan / 0 fallos / 0 omitidos contra 35 stacks de pruebas Docker. La validación estricta demuestra explotación real (cómputo del lado del servidor, errores reales del analizador, retrasos de tiempo medidos, callbacks OOB desde contenedores objetivo), no coincidencia de cadenas.

Concepto

El problema con las listas de payloads tradicionales

La mayoría de las listas de payloads disponibles públicamente están organizadas por tipo de vulnerabilidad: una lista para inyección SQL, otra para XSS, otra para inyección de comandos, etc. Un probador elige la lista que cree que coincide con el objetivo, la carga en una herramienta de intrusión y la ejecuta contra un parámetro. Si adivina mal la clase de vulnerabilidad, todo el escaneo no produce nada. Si el backend es una base de datos poco común, un motor de plantillas no estándar o un lenguaje que la lista no contempló, los payloads fallan silenciosamente. El probador continúa pensando que el parámetro está limpio.

Este enfoque tiene dos problemas fundamentales. Primero, requiere que el probador sepa qué vulnerabilidad existe antes de haberla encontrado. Segundo, la mayoría de los payloads en circulación son teóricos, copiados entre proyectos y publicaciones de blog sin haber sido probados contra un analizador real. Se ven bien. Incluso pueden ser sintácticamente válidos. Pero en realidad no desencadenan una respuesta detectable del objetivo.

Políglota primero, señal garantizada

Este proyecto adopta un enfoque diferente. La unidad principal de trabajo es el políglota (polyglot): una sola cadena de payload diseñada para ser válida (o significativamente inválida) en tantos contextos de inyección como sea posible simultáneamente. Un políglota escapa de comillas simples, comillas dobles, paréntesis, comentarios de bloque, atributos HTML, delimitadores de plantillas y contextos de comillas invertidas a la vez. En lugar de necesitar saber cuál es la vulnerabilidad, el probador dispara políglotas a cada parámetro y observa las señales.

Cada payload en esta colección se basa en pilares de detección: respuestas observables que confirman que existe una vulnerabilidad sin requerir acceso a registros del servidor, código fuente o sistema de archivos:

Error: el payload provoca que el backend lance una excepción, un error del analizador o un stack trace visible en la respuesta.
Math: el payload incluye una expresión aritmética como 7*191 que se evalúa como 1337. Si ese número aparece en la respuesta y el payload solo envió 7*191 (no el literal 1337), el backend calculó la expresión: prueba de ejecución de código.
Timing: el payload fuerza un retraso (5+ segundos). Si la respuesta es lenta, el backend ejecutó una operación de sleep o intensiva en CPU.
OOB (Out-of-Band): el payload fuerza al backend a realizar una conexión saliente HTTP, DNS, LDAP o TCP a un servidor de callback que el probador controla. Confirma la ejecución incluso cuando la respuesta es completamente opaca.

Si un payload no produce al menos una de estas señales cuando se prueba contra su contexto objetivo, no pertenece a la lista. Cada uno de los 1,353 payloads aquí ha sido validado contra entornos de prueba Docker construidos específicamente con pruebas estrictas de explotación. Cero son teóricos.

Funciones integradas en lugar de comandos de shell

Los payloads tradicionales de OOB y timing dependen de comandos de shell: curl, nslookup, ping, sleep. Estos fallan constantemente. Dependen del sistema operativo objetivo, el PATH disponible, qué shell interpreta el comando y si el proceso tiene permiso para crear subprocesos. Un payload OOB basado en curl que funciona en Ubuntu falla en Alpine (sin curl), falla en Windows (sin curl) y falla dentro de un contenedor restringido (sin ejecución de procesos salientes).

Este proyecto reemplaza los comandos de shell con funciones integradas nativas del lenguaje siempre que sea posible. Los payloads de Python usan urllib.request.urlopen() y time.sleep(). Los payloads de Java usan java.net.URL.openStream() y Thread.sleep(). Ruby usa Net::HTTP.get() y Kernel.sleep. PHP usa file_get_contents() y sleep(). Estas funciones existen en cada instalación estándar de su respectivo lenguaje: sin búsqueda de PATH, sin subproceso, sin dependencia del SO.

Donde incluso las importaciones de la biblioteca estándar podrían estar bloqueadas (eval en sandbox, exec restringido), los payloads recurren a alternativas sin importaciones: bucles de CPU para timing (sum(range(500000000)) en Python, Atomics.wait() en Node) y conexiones de socket sin procesar para OOB (__import__('socket').create_connection(), fsockopen(), TCPSocket.new()).

Donde los políglotas no llegan

No todo puede ser un políglota. Los motores de plantillas usan sintaxis fundamentalmente incompatible: {{}} en Jinja2 no significa nada para <%= %> de ERB, y ninguno se analiza como ${} de Freemarker. Los formatos de deserialización son datos binarios o estructurados específicos de un framework. Para estas categorías, el proyecto utiliza payloads por motor organizados bajo el mismo sistema de pilares de detección, cubriendo 14 motores de plantillas y 31 frameworks de deserialización en 7 lenguajes.

El resultado es un solo corpus donde los políglotas manejan los contextos que pueden (SQLi, inyección de comandos del SO, XSS, inyección de código) y los payloads por motor diseñados específicamente manejan el resto, todos validados, todos produciendo señales detectables, todos listos para herramientas de inyección línea por línea.

Lista Mínima (82 Payloads)

83 payloads cubriendo todos los 35 stacks de pruebas, todos los 55+ endpoints y los 4 pilares de detección por categoría. Validado: 83 FIRE / 0 NO-FIRE / 0 SKIPPED.

Cada categoría de inyección obtiene cobertura de error + math + timing + OOB donde sea arquitectónicamente posible. Los frameworks de deserialización que admiten ejecución de código (Pickle, PyYAML, jsonpickle, node-serialize, XMLDecoder, .NET Json.NET) obtienen cobertura completa de múltiples pilares. Los frameworks limitados a sondeo (PHP unserialize, Ruby Marshal, SnakeYAML, etc.) obtienen detección basada en error. Dispare esto en cada parámetro antes de cambiar a listas de categoría completas para profundidad.

83 solicitudes en lugar de 1,353. Use ready/minimal/payloads-only.txt para Burp Intruder.

Elegir el payload correcto para un objetivo

Consulte HOWTOUSE.md para la guía completa del operador. Convierte 'Estoy viendo un parámetro, ¿qué le lanzo?' en un flujo de trabajo repetible:

Perfilado de parámetros y contexto - 5 preguntas (forma del valor, huella del stack, visibilidad de respuesta, disponibilidad de OOB, WAF) que podan categorías antes de disparar un solo payload.
Por categoría: 'cuándo sospecharlo' - pistas exhaustivas centradas en producción para las 20 categorías. Cada categoría enumera tipos de funciones SaaS reales (plataformas low-code, BI/informes, monitorización, automatización de flujos de trabajo, SSO, buscadores SSRF, sinks de eval, constructores de plantillas de correo electrónico, etc.), señales visuales y de comportamiento (7*7 devolviendo 49 como indicio de eval, {{name}} renderizando como 'Alice' confirmando SSTI, salida de ping filtrándose desde un campo de diagnóstico, cadenas User-Agent en logs OOB que nombran la biblioteca del buscador), footguns de ORM en stacks modernos (Prisma $queryRaw, Rails .order(), Hibernate JPQL concat, Mongoose findOne(req.body)) y sondas baratas para confirmar sospechas antes de quemar la lista completa.
Huellas dactilares de bytes de serialización peligrosas - bytes mágicos sin procesar y prefijos base64 para 31 frameworks en Python, PHP, Java, .NET, Node, Ruby y Perl (rO0AB = Java, AAEAAAD///// = .NET BinaryFormatter, BAg = Ruby Marshal, gASV = Python pickle P4, / = PHP unserialize, etc.) con una tarjeta de referencia rápida de 16 entradas y heurísticas de desambiguación. Huella del blob antes de disparar para cargar 5-15 payloads coincidentes en lugar de los 232.

Use HOWTOUSE.md antes de ejecutar payloadctl prepare. Huella primero, lista mínima segundo, profundización por categoría tercero: no una escopeta de 1,353 payloads en cada parámetro.

Inicio rápido```bash

1. Prepare payloads with your callback domain

Replaces {domain} placeholder in all OOB payloads with your server

./tools/payloadctl prepare YOUR_CALLBACK.oastify.com

2. Load into Burp Intruder, ffuf, or any line-by-line injection tool

All output goes to ready/ (gitignored, contains your domain)

Después de ejecutar `prepare`, tus archivos listos para usar están en `ready/full/` y `ready/minimal/` con la siguiente estructura:

| Archivo | Descripción | Cantidad |
|------|------|-------|
| `ready/minimal/payloads-only.txt` | **Mínimo -- 83 solicitudes, todos los pilares** | 83 |
| `ready/full/payloads-only.txt` | Lista completa, un payload por línea | 1,353 |
| `ready/full/by-category/sqli.txt` | Solo inyección SQL | 211 |
| `ready/full/by-category/ssti.txt` | Solo inyección de plantillas | 206 |
| `ready/full/by-category/deserialization.txt` | Solo deserialización | 232 |
| `ready/full/by-category/os-cmd-injection.txt` | Solo inyección de comandos del sistema | 120 |
| `ready/full/by-category/code-injection.txt` | Solo inyección de código | 123 |
| `ready/full/by-category/ssrf.txt` | Solo SSRF | 156 |
| `ready/full/by-category/path-traversal.txt` | Solo path traversal | 113 |
| `ready/full/by-category/xss.txt` | Solo XSS | 58 |
| `ready/full/by-category/nosql.txt` | Solo inyección NoSQL | 32 |
| `ready/full/by-category/format-string.txt` | Solo format string | 38 |
| `ready/full/by-category/el-injection.txt` | Solo lenguaje de expresiones | 34 |
| `ready/full/by-category/header-crlf.txt` | Solo inyección CRLF/encabezado | 17 |
| `ready/full/by-category/prototype-pollution.txt` | Solo contaminación de prototipos | 12 |
| `ready/full/by-category/xxe.txt` | Solo XXE | 11 |
| `ready/full/by-category/ldap-injection.txt` | Solo inyección LDAP | 35 |
| `ready/full/by-category/xslt-injection.txt` | Solo inyección XSLT | 30 |
| `ready/full/by-category/elasticsearch-injection.txt` | Solo Elasticsearch | 30 |
| `ready/full/by-category/cypher-injection.txt` | Solo Neo4j/Cypher | 27 |
| `ready/full/by-category/couchdb-injection.txt` | Solo CouchDB | 5 |
| `ready/full/by-category/polyglots.txt` | Políglotas de contexto cruzado | 246 |
| `ready/full/by-pillar/error-payloads-only.txt` | Payloads basados en errores | 324 |
| `ready/full/by-pillar/timing-payloads-only.txt` | Basados en tiempo (ciego) | 227 |
| `ready/full/by-pillar/oob-payloads-only.txt` | Callback fuera de banda | 209 |
| `ready/full/by-pillar/math-payloads-only.txt` | Canario matemático (1337) | 182 |
| `ready/full/by-pillar/reflected-payloads-only.txt` | Reflejados/casos límite | 374 |
| `ready/full/encoded/url-encoded/payloads.txt` | Variante codificada en URL | 1,353 |
| `ready/full/encoded/base64/payloads.txt` | Variante Base64 | 1,353 |
| `ready/full/encoded/json-safe/payloads.txt` | Variante JSON segura | 1,353 |
| `ready/full/encoded/double-url-encoded/payloads.txt` | Doble URL codificada | 1,353 |
| `ready/full/encoded/html-entity/payloads.txt` | Codificada en entidades HTML | 1,353 |
| `ready/full/encoded/hex-escaped/payloads.txt` | Variante escapada en hexadecimal | 1,353 |
| `ready/full/encoded/unicode-escaped/payloads.txt` | Variante escapada en Unicode | 1,353 |

El directorio `ready/minimal/` refleja la misma estructura (por-categoría, por-pilar, codificado) con el conjunto mínimo de payloads.

Directorio de salida personalizado:```bash
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com -o /path/to/engagement/payloads

Las plantillas sin procesar con el marcador de posición {domain} (para sustitución mediante script) están en payloads/lists/full/ y payloads/lists/minimal/.

Pilares de detección

Cada payload produce al menos una de estas señales. Busca estas con grep en tus respuestas:

Valores canarios: 1337 (principal, de 7*191) y 7331 (secundario). La detección es un simple grep.

Cobertura de Payloads

Por Clase de Vulnerabilidad

13 de 20 categorías tienen los 4 pilares. Las 7 que no (XSS, XSLT, Cadena de Formato, Contaminación de Prototipo, CRLF, XXE, CouchDB) tienen razones arquitectónicas -- no se puede hacer CRLF basado en tiempo ni cadenas de formato OOB. Donde es posible cruzar pilares, la sección de políglotas lo cubre.

Variantes Codificadas

7 formatos de codificación, cada uno con los 1,353 payloads:

Principios de Diseño

Mínimos payloads, máxima cobertura de contexto. Consulta SPEC.md para la especificación técnica completa con tablas de pilares por motor y sintaxis exacta de payloads.

Políglotas primero. Un solo payload escapa de ', ", ), */, -->, comillas invertidas y delimitadores de plantilla simultáneamente. Las secciones políglotas encabezan la lista maestra.
Por motor donde los políglotas no llegan. Los delimitadores de SSTI y los formatos de deserialización son fundamentalmente incompatibles entre motores.
Funciones integradas sobre shell. Los payloads OOB y de tiempo usan bibliotecas nativas del lenguaje:

Herramienta CLI (`payloadctl`)```bash

USAGE: prepare payloads for an engagement

./tools/payloadctl prepare abc123.oastify.com # output -> ready/ ./tools/payloadctl prepare abc123.oastify.com -o /tmp/payloads # custom dir

DEVELOPMENT: build, distribute, validate, generate

./tools/payloadctl build # sources/ -> payloads/full.txt ./tools/payloadctl dist # full.txt + minimum.txt -> payloads/lists/full/ + lists/minimal/ ./tools/payloadctl validate # test all 1,353 payloads against 35 testbed stacks ./tools/payloadctl validate # test a specific wordlist (e.g. lists/minimal/master.txt) ./tools/payloadctl generate # regenerate computed payloads (deser, ssti, sqli, misc) ./tools/payloadctl generate deser # deserialization only ./tools/payloadctl generate ssti # SSTI only

### Flujo de desarrollo típico```bash
# 1. Edit source files
vim payloads/sources/sqli.txt

# 2. Rebuild
./tools/payloadctl build       # rebuild full.txt from sources
./tools/payloadctl dist        # regenerate lists/full/ + lists/minimal/

# 3. Validate (requires Docker testbeds running)
cd testbed && ./testbed up sqli-sqlite && cd ..
./tools/payloadctl validate    # expect: N FIRE / 0 NO-FIRE / 0 SKIPPED

# 4. Prepare for use
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com

Estructura del Repositorio```

. ├── README.md # This file ├── HOWTOUSE.md # Operator guide: context profiling + category selection matrix ├── SPEC.md # Technical spec - per-engine pillars, payload syntax, coverage │ ├── tools/ # CLI and generators │ ├── payloadctl # CLI entry point │ ├── cmd_build.py # Build full.txt from source files │ ├── cmd_dist.py # Generate lists/ directory │ ├── cmd_validate.py # Validate payloads against testbeds │ ├── cmd_validate_strict.py # Strict validation (proves actual exploitation) │ ├── cmd_generate.py # Run payload generators │ ├── cmd_prepare.py # Prepare payloads with callback domain │ ├── generate-deser-final.py # Deserialization generator (31 frameworks) │ ├── generate-ssti-missing.py # SSTI generator (14 engines) │ ├── generate-sqli-code-missing.py # SQLi and code injection generator │ └── generate-misc-missing.py # XXE, XSS, SSRF, path traversal generator │ ├── payloads/ │ ├── full.txt # Master list (1,353 payloads, with ## headers) │ ├── sources/ # Source files (edit these, all validated) │ │ ├── minimum.txt # 83-payload minimal list (validated, all pillars) │ │ ├── polyglots-condensed.txt # Cross-context polyglots (first in master) │ │ ├── sqli.txt # SQL injection (204) │ │ ├── ssti.txt # Template injection (168) │ │ ├── deserialization.txt # Deserialization (116, 31 frameworks) │ │ ├── os-cmd-injection.txt # OS command injection (116) │ │ ├── code-injection.txt # Code injection (112, includes Groovy) │ │ ├── ssrf.txt # SSRF (117) │ │ ├── path-traversal.txt # Path traversal (98) │ │ ├── xss.txt # XSS (49) │ │ ├── format-string.txt # Format string (33) │ │ ├── nosql.txt # NoSQL (26) │ │ ├── el-injection.txt # Expression language (26, includes MVEL) │ │ ├── header-crlf.txt # CRLF/header (14) │ │ ├── prototype-pollution.txt # Prototype pollution (10) │ │ ├── xxe.txt # XXE (8) │ │ ├── ldap-injection.txt # LDAP injection (30) │ │ ├── xslt-injection.txt # XSLT injection (25) │ │ ├── elasticsearch-injection.txt # Elasticsearch (25) │ │ ├── cypher-injection.txt # Neo4j/Cypher (22) │ │ └── couchdb-injection.txt # CouchDB (4) │ └── lists/ # Generated (don't edit, use payloadctl dist) │ ├── full/ # Full payload set │ │ ├── master.txt # 1,353 payloads with ## headers │ │ ├── payloads-only.txt # Raw lines for Burp Intruder │ │ ├── by-category/ # 20 category files │ │ ├── by-pillar/ # 5 pillar files (with -payloads-only variants) │ │ └── encoded/ # 7 encoding variants │ └── minimal/ # Minimal payload set (same structure) │ ├── master.txt # 83 payloads with ## headers │ ├── payloads-only.txt # Raw lines for Burp Intruder │ ├── by-category/ # 20 category files │ ├── by-pillar/ # 5 pillar files (with -payloads-only variants) │ └── encoded/ # 7 encoding variants │ ├── ready/ # Output from payloadctl prepare (gitignored) │ └── testbed/ # Docker validation infrastructure ├── testbed # CLI: ./testbed up ├── docker-compose.oob.yml # OOB callback catcher (HTTP 9999, TCP 9998, DNS 5353) ├── shared/oob-catcher/ # HTTP + LDAP/binary + raw TCP + DNS callback server └── stacks/ # 35 vulnerable application stacks

---

## Agregando Payloads

### Agregar un payload a una categoría existente

1. Edita el archivo fuente en `payloads/sources/`. Un payload por línea bajo una sección `##Header##`.
2. Cada payload debe producir una señal detectable (error, math 1337, timing >4.5s, OOB, reflexión).
3. Reconstruye y valida:   ```bash
   ./tools/payloadctl build && ./tools/payloadctl dist
   ./tools/payloadctl validate    # 0 NO-FIRE required

Agregar una nueva categoría de vulnerabilidad

Crear payloads/sources/<category>.txt con encabezados ## para cada pilar (error, math, timing, OOB).
Agregar el archivo a tools/cmd_build.py SOURCE_FILES y tools/cmd_dist.py CATEGORY_SOURCES.
Crear un stack de testbed en testbed/stacks/<category>/ (Dockerfile + servidor exponiendo POST /<endpoint> con input=<payload> devolviendo {"output": "...", "error": "...", "time_ms": N}).
Agregar enrutamiento de endpoints en tools/cmd_validate.py (diccionario ENDPOINTS y función _get_endpoints()).

Agregar un nuevo framework de deserialización

Editar tools/generate-deser-final.py - agregar una función que genere payloads (error, math, timing, OOB).
Ejecutar ./tools/payloadctl generate deser && ./tools/payloadctl build
Agregar endpoint de testbed y enrutamiento si es necesario.

Agregar un nuevo motor SSTI

Editar payloads/sources/ssti.txt - agregar secciones ##EngineName (Language) - Pillar##. Usar funciones integradas del lenguaje para timing/OOB.
Agregar endpoint de testbed en el stack ssti-<language> correspondiente.
Agregar enrutamiento en tools/cmd_validate.py ENGINE_MAP.

Reglas de formato de payloads

Un payload por línea (YAML multilínea usa \n literal)
Placeholder {domain} para URLs de callback OOB
Canario 1337 para todos los payloads de math
Las secciones ##Header## agrupan por categoría y pilar
Sin duplicados (el paso de build deduplica automáticamente)

Validación

El validador prueba cada payload contra aplicaciones vulnerables reales:```bash

Start testbeds (Docker required)

cd testbed ./testbed up sqli-sqlite ./testbed up ssti-python ./testbed up deserialization-java

... (35 stacks total)

Run validation

cd .. ./tools/payloadctl validate

Output: 1,353 FIRE / 0 NO-FIRE / 0 SKIPPED / 1,353 TOTAL

Cómo funciona:
1. Lee el archivo de payloads y enruta cada sección `##` al (a los) endpoint(s) de prueba correspondiente(s)
2. Hace POST de `input=<payload>` a los endpoint(s), verifica la respuesta en busca de señales
3. Un payload se activa si ALGÚN endpoint devuelve: error real del parser/intérprete, `1337` calculado por el servidor (de `7*191`), demora >4.5 s, callback OOB desde el contenedor objetivo, contenido de archivo leído (`root:x:0:0`), o entrada reflejada en un contexto válido (XSS, CRLF)

La validación estricta (`tools/cmd_validate_strict.py`) adicionalmente verifica:
- Los payloads matemáticos demuestran cómputo del lado del servidor (el payload envía `7*191`, no el literal `1337`)
- Los callbacks OOB se originan desde las IPs de los contenedores de prueba
- Los mensajes de error contienen firmas reales del parser/intérprete, no errores HTTP genéricos
- Las demoras de tiempo caen dentro del rango esperado (~5 segundos)

### Pilas de pruebas (35 en total)

| Pila | Puerto | Lenguaje | Endpoints |
|------|--------|----------|-----------|
| sqli-sqlite | 8001 | Python | `/sqli`, `/sqli-numeric` |
| sqli-postgres | 8030 | Python | `/sqli` |
| ssti-python | 8003 | Python | `/jinja2`, `/mako`, `/tornado` |
| ssti-node | 8011 | Node | `/ejs`, `/nunjucks`, `/pug` |
| ssti-php | 8020 | PHP | `/twig`, `/smarty` |
| ssti-ruby | 8025 | Ruby | `/erb`, `/slim`, `/haml` |
| ssti-java | 8040 | Java | `/freemarker`, `/velocity`, `/pebble`, `/thymeleaf` |
| os-cmd-injection | 8002 | Python | `/system`, `/popen` |
| code-injection-python | 8004 | Python | `/eval` |
| code-injection-node | 8012 | Node | `/eval` |
| code-injection-php | 8021 | PHP | `/eval` |
| code-injection-ruby | 8026 | Ruby | `/eval`, `/yaml`, `/marshal`, `/oj` |
| code-injection-perl | 8031 | Perl | `/eval`, `/storable`, `/yaml` |
| xss | 8010 | Node | `/reflected` |
| xxe | 8008 | Python | `/parse`, `/xinclude` |
| ssrf | 8007 | Python | `/fetch` |
| path-traversal | 8006 | Python | `/read` |
| nosql-redis | 8015 | Node | `/eval` |
| el-injection-java | 8041 | Java | `/spel`, `/ognl` |
| prototype-pollution | 8013 | Node | `/merge` |
| deserialization-python | 8005 | Python | `/pickle`, `/yaml`, `/jsonpickle` |
| deserialization-node | 8014 | Node | `/unserialize`, `/yaml`, `/funcster` |
| deserialization-php | 8022 | PHP | `/unserialize`, `/unserialize-b64`, `/phar` |
| deserialization-java | 8042 | Java | `/deserialize`, `/yaml`, `/jackson`, `/fastjson`, `/xstream`, `/xmldecoder`, `/hessian` |
| deserialization-dotnet | 8045 | .NET | `/jsonnet`, `/binaryformatter`, `/xmlserializer`, `/losformatter`, `/javascriptserializer` |
| log4j-jndi | 8046 | Java | `/log` |
| sqli-mysql | 8050 | Python | `/sqli`, `/sqli-numeric` |
| nosql-mongo | 8051 | Node | `/find`, `/where`, `/aggregate` |
| ssi-esi | 8035 | Python | `/ssi` |
| ldap-injection | 8055 | Python + OpenLDAP | `/search`, `/auth` |
| xslt-injection | 8056 | Python | `/transform`, `/xpath` |
| elasticsearch | 8057 | Python + ES 7.17 | `/search`, `/script` |
| cypher-injection | 8058 | Python + Neo4j 5 | `/query`, `/search` |
| couchdb-injection | 8059 | Python + CouchDB 3 | `/find` |
| groovy-injection | 8060 | Groovy/JDK 21 | `/eval` |

Catcher OOB en el puerto 9999 (HTTP + detección LDAP/binaria) y 9998 (catch-all TCP bruto), con DNS en 5353/UDP. Detecta callbacks HTTP, conexiones binarias LDAP/ASN.1 (JNDI), consultas DNS y conexiones TCP brutas. Cada endpoint acepta `POST /<sink>` con `input=<payload>` y devuelve `{"output": "...", "error": "...|null", "time_ms": N}`.

---

## Créditos

Payloads investigados y desarrollados por [Grom Hacks](https://github.com/gromhacks). Construido sobre el trabajo de la comunidad de investigación en seguridad, incluyendo PayloadsAllTheThings, HackTricks, PortSwigger Web Security Academy e investigadores individuales. Todos los payloads validados contra aplicaciones vulnerables reales.

4	SQLi	error, math, timing, OOB (políglotas entre dialectos)
4	SSTI	error, math, timing, OOB (políglotas entre motores)
3	OS Cmd	math, timing, OOB (políglotas entre shells)
3	Code Injection	math, timing, OOB (entre lenguajes)
2	XSS	math, OOB
2	XXE	lectura de archivo, OOB
2	SSRF	error, OOB
1	Path Traversal	lectura de archivo
2	NoSQL	math, error
1	EL Injection	math
1	Prototype Pollution	math
1	CRLF/Header	math
1	Format String	error
1	SSI	math
2	LDAP Injection	error, math
3	XSLT Injection	error, math, OOB
2	Elasticsearch	error, math
2	Cypher/Neo4j	error, timing
1	CouchDB	error
3	Groovy	math, timing, OOB
41	Deserialization	multi-pilar cuando es compatible, solo error en otro caso

Error	324	Texto de excepción, traza de pila, error de analizador en la respuesta	La app refleja errores
Tiempo	227	La respuesta tarda >4.5 segundos	Blind - sin salida, sin errores
OOB	209	HTTP/DNS/LDAP/TCP saliente a tu servidor de callback	Blind + asíncrono - tiempo impredecible
Matemática	182	Literal `1337` en el cuerpo de la respuesta (servidor computó `7*191`)	Salida reflejada pero sin errores
Reflejado	374	Valor de entrada repetido en la respuesta	Fuzzing para anomalías en el analizador
Lectura de archivo	(subconjunto)	Contenido `root:` o `[extensions]` en la respuesta	Path traversal, lectura de archivos XXE

SQLi	211	error, matemática, tiempo, oob	MySQL, PostgreSQL, Oracle, MSSQL, SQLite, CockroachDB. UNION, error, tiempo, OOB. Escapes de contexto: `'`, `"`, `)`, `))`, `*/`, numérico.
SSTI	206	error, matemática, tiempo, oob	Jinja2, Mako, Tornado, EJS, Nunjucks, Pug, Twig, Smarty, ERB, Slim, Haml, Thymeleaf, Pebble, Freemarker, Velocity, Razor, Go template, Mustache, Liquid. Todos usan funciones integradas del lenguaje.
Deserialización	232	error, matemática, tiempo, oob	31 frameworks / 7 lenguajes. Todos los payloads nativos del lenguaje usan funciones integradas (sin comandos de shell). Python (pickle P0/P2/P4 mediante `time.sleep`/`builtins.eval`/`urllib`, YAML mediante `time.sleep`/`builtins.eval`, jsonpickle), PHP (unserialize), Node (node-serialize mediante JS busy-wait/`http.get`, js-yaml, funcster, cryo), Ruby (YAML, Marshal, Oj), Java (Jackson, Fastjson, XStream, SnakeYAML, XMLDecoder, Hessian, JNDI/Log4Shell, ObjectInputStream, ysoserial URLDNS), .NET (Json.NET, BinaryFormatter, SoapFormatter, XmlSerializer, JavaScriptSerializer, LosFormatter, ViewState, ObjectStateFormatter), Perl (Storable, YAML).
Inyección de Comandos del SO	120	error, matemática, tiempo, oob	Bash, CMD, PowerShell. Escapes: `;`, `\|`, `\|\|`, `&&`, `$()`, comillas invertidas. Bypass de IFS, bypass de glob, codificación hexadecimal.
Inyección de Código	123	error, matemática, tiempo, oob	Python, Node, PHP, Ruby, Perl, Lua, Java ScriptEngine, Groovy. Bucle de CPU sin imports, OOB a nivel de socket.
SSRF	156	error, matemática, tiempo, oob	Metadatos de nube (AWS/GCP/Azure), bypass de IP, esquemas de protocolo, reenlace de DNS, sondeos de servicios internos.
Path Traversal	113	error, matemática, tiempo, oob	Linux + Windows, bypass de codificación, byte nulo, wrappers PHP, UNC, NTFS ADS, nombres cortos 8.3.
XSS	58	error, matemática, oob	Políglotas cross-context (20+ contextos), manejadores de eventos, evasión de filtros, DOM clobbering, mutation XSS, SVG, OOB.
Cadena de Formato	38	error, matemática	C/C++ (`%s%n%x`), Python (`{0.__class__}`), .NET (`{0:X}`).
NoSQL	32	error, matemática, tiempo, oob	Inyección de operadores MongoDB, timing `$where`, OOB, comandos Redis.
Inyección EL	34	error, matemática, tiempo, oob	SpEL, OGNL, MVEL, Unified EL. OOB mediante `java.net.URL`.
CRLF/Cabecera	17	error, matemática, oob	División de respuesta, inyección de cabecera, OOB mediante cabecera Host.
Contaminación de Prototipo	12	error, matemática	`__proto__`, `constructor.prototype`, variantes JSON y query string.
XXE	11	error, tiempo, oob, file-read	Entidades externas, XInclude, entidades paramétricas, Billion Laughs DoS.
Inyección LDAP	35	error, matemática, tiempo, oob	Inyección de filtro, bypass de autenticación, timing con comodín, OOB de referencia.
Elasticsearch	30	error, matemática, tiempo, oob	Inyección de script Painless, DSL de consulta, sintaxis query_string.
Cypher/Neo4j	27	error, matemática, tiempo, oob	Inyección de consulta Cypher, sleep APOC, LOAD CSV OOB.
CouchDB	5	error, matemática	Inyección de consulta Mango, inyección de operador, bypass de autenticación.
Inyección XSLT	30	error, matemática, oob, archivo-lectura	Matemática XPath, document() SSRF, lectura de archivo, fuga de información system-property().
Políglotas/Casos Límite	246	error, matemática, tiempo, oob	Políglotas cross-context + desbordamiento de búfer, límite de enteros, confusión de tipos, byte nulo.

Codificado URL	Parámetros estándar de consulta/formulario
Codificado URL doble	Bypass de WAF, vulnerabilidades de doble decodificación
Base64	Cuerpos de API, JWT, parámetros serializados
Seguro para JSON	Cuerpos de solicitud JSON (comillas escapadas)
Entidad HTML	Inyección de atributo HTML
Escapado hexadecimal	Protocolos binarios, inyección de bajo nivel
Escapado Unicode	Bypass de normalización Unicode

Python	`urllib.request.urlopen()`	`time.sleep(5)`
Java	`java.net.URL.openStream()`	`Thread.sleep(5000)`
Node	`require('http').get()`	`Date.now()` busy-wait loop
PHP	`file_get_contents()`, `fsockopen()`	`sleep(5)`
Ruby	`Net::HTTP.get()`, `TCPSocket.new()`	`sleep(5)`
Perl	`IO::Socket::INET`	`select(undef,undef,undef,5)`
.NET	`System.Net.WebClient`	`Thread.Sleep(5000)`

Más Populares

Acerca de

Payload-and-Polyglot-Lists