GromHacks Labs — As listas de payloads que eles não querem que você tenha. 1.324 sondas de injeção enviadas da nave-mãe para detectar o que é injetável em 20 classes de vulnerabilidade. Nós não exploramos, apenas batemos na porta e vemos quem atende. Cada payload testado contra parsers reais porque os alienígenas exigem provas. Não confie em nenhuma entrada. Questione tudo!
Encontrou um payload que não funciona? Por favor abra um issue com o payload, contexto do alvo e o que você esperava que acontecesse. Pull requests com correções ou novos payloads são sempre bem-vindos.
A pesquisa está em andamento. Este projeto está em desenvolvimento ativo e será atualizado regularmente com novos payloads, classes de vulnerabilidade e melhorias de validação.
Aviso Legal: Estes payloads são fornecidos apenas para testes de segurança autorizados, educação e fins de pesquisa. Os autores não assumem qualquer responsabilidade por uso indevido ou efeitos indiretos. Use totalmente por sua conta e risco. Ao usar este projeto, você aceita total responsabilidade por suas ações.
Licença: MIT - veja LICENSE
1,353 payloads de injeção validados cobrindo 20 classes de vulnerabilidade, 31 frameworks de desserialização e 14 mecanismos de template. Cada payload produz um sinal detectável. Zero payloads teóricos.
Validação: 1,353 testados / 1,353 acionam / 0 falhas / 0 ignorados contra 35 ambientes de teste Docker. A validação rigorosa comprova exploração real (computação no lado do servidor, erros reais de parser, atrasos de temporização medidos, callbacks OOB de contêineres alvo) -- não correspondência de strings.
A maioria das listas de payloads disponíveis publicamente são organizadas por tipo de vulnerabilidade: uma lista para injeção SQL, outra para XSS, outra para injeção de comandos, e assim por diante. Um testador escolhe a lista que acha que corresponde ao alvo, carrega-a em uma ferramenta de intrusão e a executa contra um parâmetro. Se ele errar sobre a classe de vulnerabilidade, toda a varredura não produz nada. Se o backend for um banco de dados incomum, um mecanismo de template não padrão, ou uma linguagem que a lista não considerou, os payloads falham silenciosamente. O testador segue em frente pensando que o parâmetro está limpo.
Essa abordagem tem dois problemas fundamentais. Primeiro, exige que o testador saiba qual vulnerabilidade existe antes de encontrá-la. Segundo, a maioria dos payloads em circulação são teóricos -- copiados entre projetos e postagens de blog sem nunca serem testados contra um parser real. Eles parecem corretos. Eles podem até ser sintaticamente válidos. Mas eles não provocam uma resposta detectável do alvo.
Este projeto adota uma abordagem diferente. A unidade principal de trabalho é o poliglota -- uma única string de payload projetada para ser válida (ou significativamente inválida) em tantos contextos de injeção quanto possível simultaneamente. Um poliglota escapa de aspas simples, aspas duplas, parênteses, comentários de bloco, atributos HTML, delimitadores de template e contextos de crase de uma só vez. Em vez de precisar saber qual é a vulnerabilidade, o testador dispara poliglotas em cada parâmetro e observa os sinais.
Cada payload nesta coleção é construído em torno de pilares de detecção -- respostas observáveis que confirmam a existência de uma vulnerabilidade sem exigir acesso a logs do servidor, código fonte ou sistema de arquivos:
7*191 que resulta em 1337. Se esse número aparecer na resposta e o payload enviou apenas 7*191 (não o literal 1337), o backend computou a expressão -- prova de execução de código.Se um payload não produzir pelo menos um desses sinais quando testado contra seu contexto alvo, ele não pertence à lista. Cada um dos 1,353 payloads aqui foi validado contra ambientes de teste Docker construídos para o propósito, com prova rigorosa de exploração. Zero são teóricos.
Payloads tradicionais de OOB e temporização dependem de comandos shell: curl, nslookup, ping, sleep. Estes quebram constantemente. Eles dependem do SO alvo, do PATH disponível, de qual shell interpreta o comando e se o processo tem permissão para gerar subprocessos. Um payload OOB baseado em curl que funciona no Ubuntu falha no Alpine (sem curl), falha no Windows (sem curl) e falha dentro de um contêiner restrito (sem execução de processo de saída).
Este projeto substitui comandos shell por funções nativas da linguagem sempre que possível. Payloads Python usam urllib.request.urlopen() e time.sleep(). Payloads Java usam java.net.URL.openStream() e Thread.sleep(). Ruby usa Net::HTTP.get() e Kernel.sleep. PHP usa file_get_contents() e sleep(). Essas funções existem em toda instalação padrão de suas respectivas linguagens -- sem busca de PATH, sem subprocesso, sem dependência de SO.
Onde até mesmo importações da biblioteca padrão podem ser bloqueadas (eval em sandbox, exec restrito), os payloads recorrem a alternativas sem importação: loops de CPU para temporização (sum(range(500000000)) em Python, Atomics.wait() em Node) e conexões socket brutas para OOB (__import__('socket').create_connection(), fsockopen(), TCPSocket.new()).
Nem tudo pode ser um poliglota. Mecanismos de template usam sintaxe fundamentalmente incompatível -- {{}} no Jinja2 não significa nada para o <%= %> do ERB, e nenhum deles é analisado como ${} do Freemarker). Formatos de desserialização são binários ou dados estruturados específicos de um framework. Para essas categorias, o projeto usa payloads por mecanismo organizados sob o mesmo sistema de pilares de detecção, cobrindo 14 mecanismos de template e 31 frameworks de desserialização em 7 linguagens.
O resultado é um único corpus onde os poliglotas lidam com os contextos que podem (SQLi, injeção de comando no SO, XSS, injeção de código) e payloads por mecanismo construídos para o propósito lidam com o restante, todos validados, todos produzindo sinais detectáveis, todos prontos para ferramentas de injeção linha por linha.
83 payloads cobrindo todas as 35 pilhas de teste, todos os 55+ endpoints e todos os 4 pilares de detecção por categoria. Validado: 83 ACIONAM / 0 NÃO ACIONAM / 0 IGNORADOS.
Toda categoria de injeção recebe cobertura de erro + matemática + temporização + OOB onde arquiteturalmente possível. Frameworks de desserialização que suportam execução de código (Pickle, PyYAML, jsonpickle, node-serialize, XMLDecoder, .NET Json.NET) recebem cobertura completa de múltiplos pilares. Frameworks limitados a sondagem (PHP unserialize, Ruby Marshal, SnakeYAML, etc.) recebem detecção baseada em erro. Dispare isso em cada parâmetro antes de mudar para listas de categoria completa para profundidade.
83 requisições em vez de 1,353. Use ready/minimal/payloads-only.txt para o Burp Intruder.
Consulte HOWTOUSE.md para o guia completo do operador. Ele transforma "Estou olhando para um parâmetro, o que eu jogo nele?" em um fluxo de trabalho repetível:
7*7 retornando 49 como a dica de eval, {{name}} renderizando como "Alice" confirmando SSTI, saída de ping vazando de um campo de diagnóstico, strings User-Agent em logs OOB nomeando a biblioteca extratora), armadilhas ORM de pilha moderna (Prisma $queryRaw, Rails .order(), Hibernate JPQL concat, Mongoose findOne(req.body)), e sondagens baratas para confirmar suspeita antes de queimar a lista completa.rO0AB = Java, AAEAAAD///// = .NET BinaryFormatter, BAg = Ruby Marshal, gASV = Python pickle P4, / = PHP unserialize, etc.) com um cartão de referência rápida de 16 entradas e heurísticas de desambiguação. Identifique o blob antes de disparar para carregar de 5 a 15 payloads correspondentes em vez de todos os 232.Use HOWTOUSE.md antes de executar payloadctl prepare. Identificação primeiro, lista mínima segundo, aprofundamento por categoria terceiro - não uma saraivada de 1,353 payloads em cada parâmetro.
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com
After executar `prepare`, seus arquivos prontos para uso estão em `ready/full/` e `ready/minimal/` com a estrutura correspondente:
| Arquivo | O quê | Contagem |
|------|------|-------|
| `ready/minimal/payloads-only.txt` | **Mínimo -- 83 requisições, todos os pilares** | 83 |
| `ready/full/payloads-only.txt` | Lista completa, um payload por linha | 1.353 |
| `ready/full/by-category/sqli.txt` | Apenas SQL injection | 211 |
| `ready/full/by-category/ssti.txt` | Apenas injeção de template | 206 |
| `ready/full/by-category/deserialization.txt` | Apenas desserialização | 232 |
| `ready/full/by-category/os-cmd-injection.txt` | Apenas injeção de comando no SO | 120 |
| `ready/full/by-category/code-injection.txt` | Apenas injeção de código | 123 |
| `ready/full/by-category/ssrf.txt` | Apenas SSRF | 156 |
| `ready/full/by-category/path-traversal.txt` | Apenas path traversal | 113 |
| `ready/full/by-category/xss.txt` | Apenas XSS | 58 |
| `ready/full/by-category/nosql.txt` | Apenas injeção NoSQL | 32 |
| `ready/full/by-category/format-string.txt` | Apenas string de formato | 38 |
| `ready/full/by-category/el-injection.txt` | Apenas linguagem de expressão | 34 |
| `ready/full/by-category/header-crlf.txt` | Apenas injeção de CRLF/cabeçalho | 17 |
| `ready/full/by-category/prototype-pollution.txt` | Apenas poluição de protótipo | 12 |
| `ready/full/by-category/xxe.txt` | Apenas XXE | 11 |
| `ready/full/by-category/ldap-injection.txt` | Apenas injeção LDAP | 35 |
| `ready/full/by-category/xslt-injection.txt` | Apenas injeção XSLT | 30 |
| `ready/full/by-category/elasticsearch-injection.txt` | Apenas Elasticsearch | 30 |
| `ready/full/by-category/cypher-injection.txt` | Apenas Neo4j/Cypher | 27 |
| `ready/full/by-category/couchdb-injection.txt` | Apenas CouchDB | 5 |
| `ready/full/by-category/polyglots.txt` | Poliglotas cross-contexto | 246 |
| `ready/full/by-pillar/error-payloads-only.txt` | Payloads baseados em erro | 324 |
| `ready/full/by-pillar/timing-payloads-only.txt` | Baseados em temporização (cego) | 227 |
| `ready/full/by-pillar/oob-payloads-only.txt` | Callback fora de banda | 209 |
| `ready/full/by-pillar/math-payloads-only.txt` | Canário matemático (1337) | 182 |
| `ready/full/by-pillar/reflected-payloads-only.txt` | Refletidos/caso de borda | 374 |
| `ready/full/encoded/url-encoded/payloads.txt` | Variante codificada em URL | 1.353 |
| `ready/full/encoded/base64/payloads.txt` | Variante Base64 | 1.353 |
| `ready/full/encoded/json-safe/payloads.txt` | Variante segura para JSON | 1.353 |
| `ready/full/encoded/double-url-encoded/payloads.txt` | Duplamente codificado em URL | 1.353 |
| `ready/full/encoded/html-entity/payloads.txt` | Codificado como entidade HTML | 1.353 |
| `ready/full/encoded/hex-escaped/payloads.txt` | Variante com escape hexadecimal | 1.353 |
| `ready/full/encoded/unicode-escaped/payloads.txt` | Variante com escape Unicode | 1.353 |
O diretório `ready/minimal/` espelha a mesma estrutura (por categoria, por pilar, codificado) com o conjunto mínimo de payloads.
Diretório de saída personalizado:```bash
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com -o /path/to/engagement/payloads
Modelos brutos com o placeholder {domain} (para substituição por script) estão em payloads/lists/full/ e payloads/lists/minimal/.
Cada payload produz pelo menos um desses sinais. Use grep para localizá-los nas suas respostas:
Valores canários: 1337 (primário, de 7*191) e 7331 (secundário). A detecção é um simples grep.
13 de 20 categorias têm todos os 4 pilares. As 7 que não têm (XSS, XSLT, Format String, Poluição de Protótipo, CRLF, XXE, CouchDB) têm razões arquiteturais — não é possível fazer CRLF baseado em tempo ou format strings OOB. Onde é possível ter pilares cruzados, a seção de poliglotas cobre.
7 formatos de codificação, cada um com todos os 1.353 payloads:
Mínimo de payloads, máxima cobertura de contexto. Veja SPEC.md para a especificação técnica completa com tabelas de pilares por motor e sintaxe exata dos payloads.
Poliglotas primeiro. Um único payload sai de ', ", ), */, -->, crases e delimitadores de template simultaneamente. As seções de poliglotas lideram a lista principal.
Por motor onde poliglotas não alcançam. Delimitadores SSTI e formatos de desserialização são fundamentalmente incompatíveis entre motores.
Recursos internos em vez de shell. Payloads OOB e de tempo usam bibliotecas nativas da linguagem:
payloadctl)```bash./tools/payloadctl prepare abc123.oastify.com # output -> ready/ ./tools/payloadctl prepare abc123.oastify.com -o /tmp/payloads # custom dir
./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
### Fluxo de Desenvolvimento 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
. ├── 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
---
## Adicionando Payloads
### Adicionar um payload a uma categoria existente
1. Edite o arquivo fonte em `payloads/sources/`. Um payload por linha sob a seção `##Header##`.
2. Cada payload deve produzir um sinal detectável (error, math 1337, timing >4.5s, OOB, reflection).
3. Reconstrua e valide: ```bash
./tools/payloadctl build && ./tools/payloadctl dist
./tools/payloadctl validate # 0 NO-FIRE required
payloads/sources/<category>.txt com cabeçalhos ## para cada pilar (error, math, timing, OOB).tools/cmd_build.py SOURCE_FILES e tools/cmd_dist.py CATEGORY_SOURCES.testbed/stacks/<category>/ (Dockerfile + servidor expondo POST /<endpoint> com input=<payload> retornando {"output": "...", "error": "...", "time_ms": N}).tools/cmd_validate.py (ENDPOINTS dict e função _get_endpoints()).tools/generate-deser-final.py - adicione uma função que gera payloads (error, math, timing, OOB)../tools/payloadctl generate deser && ./tools/payloadctl buildpayloads/sources/ssti.txt - adicione seções ##EngineName (Language) - Pillar##. Use funções nativas da linguagem para timing/OOB.ssti-<language> correspondente.tools/cmd_validate.py ENGINE_MAP.\n literal){domain} para URLs de callback OOB1337 canário para todos os payloads de math##Header## agrupam por categoria e pilarO validador testa cada payload contra aplicações vulneráveis reais:```bash
cd testbed ./testbed up sqli-sqlite ./testbed up ssti-python ./testbed up deserialization-java
cd .. ./tools/payloadctl validate
Como funciona:
1. Lê o ficheiro de payloads e encaminha cada secção `##` para o(s) endpoint(s) correspondente(s)
2. Faz POST de `input=<payload>` para o(s) endpoint(s), verifica a resposta por sinais
3. Um payload é acionado se QUALQUER endpoint retornar: erro real de parser/intérprete, `1337` (de `7*191`) calculado pelo servidor, atraso >4,5s, callback OOB do contentor alvo, conteúdo de leitura de ficheiro (`root:x:0:0`), ou input refletido num contexto válido (XSS, CRLF)
Validação rigorosa (`tools/cmd_validate_strict.py`) adicionalmente verifica:
- Payloads matemáticos comprovam cálculos do lado do servidor (o payload envia `7*191`, não `1337` literal)
- Callbacks OOB originam-se de IPs do contentor da bancada de teste
- Mensagens de erro contêm assinaturas reais de parser/intérprete, não erros HTTP genéricos
- Atrasos de temporização enquadram-se no intervalo esperado (~5 segundos)
### Stacks de bancada de teste (35 no total)
| Stack | Porta | Linguagem | 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 na porta 9999 (HTTP + deteção LDAP/binária) e 9998 (catch-all TCP bruto), com DNS em 5353/UDP. Detecta callbacks HTTP, conexões binárias LDAP/ASN.1 (JNDI), consultas DNS e conexões TCP brutas. Cada endpoint aceita `POST /<sink>` com `input=<payload>` e retorna `{"output": "...", "error": "...|null", "time_ms": N}`.
---
## Créditos
Payloads pesquisados e desenvolvidos por [Grom Hacks](https://github.com/gromhacks). Construído com base no trabalho da comunidade de pesquisa em segurança, incluindo PayloadsAllTheThings, HackTricks, PortSwigger Web Security Academy e investigadores individuais. Todos os payloads validados contra aplicações vulneráveis reais.
| Payloads | Categoria | Pilares |
|---|
| 4 | SQLi | erro, matemática, temporização, OOB (poliglotas entre dialetos) |
| 4 | SSTI | erro, matemática, temporização, OOB (poliglotas entre mecanismos) |
| 3 | Comando SO | matemática, temporização, OOB (poliglotas entre shells) |
| 3 | Injeção de Código | matemática, temporização, OOB (entre linguagens) |
| 2 | XSS | matemática, OOB |
| 2 | XXE | leitura de arquivo, OOB |
| 2 | SSRF | erro, OOB |
| 1 | Path Traversal | leitura de arquivo |
| 2 | NoSQL | matemática, erro |
| 1 | Injeção EL | matemática |
| 1 | Poluição de Protótipo | matemática |
| 1 | CRLF/Cabeçalho | matemática |
| 1 | String de Formato | erro |
| 1 | SSI | matemática |
| 2 | Injeção LDAP | erro, matemática |
| 3 | Injeção XSLT | erro, matemática, OOB |
| 2 | Elasticsearch | erro, matemática |
| 2 | Cypher/Neo4j | erro, temporização |
| 1 | CouchDB | erro |
| 3 | Groovy | matemática, temporização, OOB |
| 41 | Desserialização | múltiplos pilares onde suportado, apenas erro caso contrário |
TzoYToid=42 e JSESSIONID" para "tente by-category/sqli.txt + desserialização Java + injeção EL, observe o pilar matemática" em uma consulta.| Pilar | Payloads | O que procurar | Usar quando |
|---|
| Erro | 324 | Texto de exceção, stack trace, erro de parser na resposta | A aplicação reflete erros |
| Tempo | 227 | Resposta leva >4,5 segundos | Blind - sem saída, sem erros |
| OOB | 209 | HTTP/DNS/LDAP/TCP de saída para seu servidor de callback | Blind + assíncrono - tempo não confiável |
| Matemática | 182 | Literal 1337 no corpo da resposta (servidor computou 7*191) | Saída refletida mas sem erros |
| Refletido | 374 | Valor de entrada ecoado de volta na resposta | Fuzzing para anomalias de parser |
| Leitura de arquivo | (subconjunto) | Conteúdo root: ou [extensions] na resposta | Path traversal, XXE leitura de arquivo |
| Categoria | Contagem | Pilares | Cobertura |
|---|
| SQLi | 211 | erro, matemática, tempo, oob | MySQL, PostgreSQL, Oracle, MSSQL, SQLite, CockroachDB. UNION, erro, tempo, OOB. Quebras de contexto: ', ", ), )), */, numérico. |
| SSTI | 206 | erro, matemática, tempo, oob | Jinja2, Mako, Tornado, EJS, Nunjucks, Pug, Twig, Smarty, ERB, Slim, Haml, Thymeleaf, Pebble, Freemarker, Velocity, Razor, Go template, Mustache, Liquid. Todos usam recursos nativos da linguagem. |
| Desserialização | 232 | erro, matemática, tempo, oob | 31 frameworks / 7 linguagens. Todos os payloads nativos da linguagem usam recursos internos (sem comandos shell). Python (pickle P0/P2/P4 via time.sleep/builtins.eval/urllib, YAML via time.sleep/builtins.eval, jsonpickle), PHP (unserialize), Node (node-serialize via 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). |
| Injeção de Comando OS | 120 | erro, matemática, tempo, oob | Bash, CMD, PowerShell. Quebras: ;, |, ||, &&, $(), crases. Bypass IFS, bypass glob, codificação hex. |
| Injeção de Código | 123 | erro, matemática, tempo, oob | Python, Node, PHP, Ruby, Perl, Lua, Java ScriptEngine, Groovy. CPU spin sem imports, OOB em nível de soquete. |
| SSRF | 156 | erro, matemática, tempo, oob | Metadados de nuvem (AWS/GCP/Azure), bypass de IP, esquemas de protocolo, DNS rebinding, sondagem de serviços internos. |
| Path Traversal | 113 | erro, matemática, tempo, oob | Linux + Windows, bypass de codificação, byte nulo, wrappers PHP, UNC, NTFS ADS, nomes curtos 8.3. |
| XSS | 58 | erro, matemática, oob | Poliglotas entre contextos (20+ contextos), manipuladores de eventos, evasão de filtros, DOM clobbering, mutation XSS, SVG, OOB. |
| Format String | 38 | erro, matemática | C/C++ (%s%n%x), Python ({0.__class__}), .NET ({0:X}). |
| NoSQL | 32 | erro, matemática, tempo, oob | Injeção de operadores MongoDB, tempo $where, OOB, comandos Redis. |
| Injeção EL | 34 | erro, matemática, tempo, oob | SpEL, OGNL, MVEL, Unified EL. OOB via java.net.URL. |
| CRLF/Cabeçalho | 17 | erro, matemática, oob | Response splitting, injeção de cabeçalho, OOB via cabeçalho Host. |
| Poluição de Protótipo | 12 | erro, matemática | __proto__, constructor.prototype, variantes JSON e query string. |
| XXE | 11 | erro, tempo, oob, leitura de arquivo | Entidades externas, XInclude, entidades de parâmetro, Billion Laughs DoS. |
| Injeção LDAP | 35 | erro, matemática, tempo, oob | Injeção de filtro, bypass de autenticação, tempo com curinga, OOB referral. |
| Elasticsearch | 30 | erro, matemática, tempo, oob | Injeção de script Painless, query DSL, sintaxe query_string. |
| Cypher/Neo4j | 27 | erro, matemática, tempo, oob | Injeção de consulta Cypher, APOC sleep, LOAD CSV OOB. |
| CouchDB | 5 | erro, matemática | Injeção de consulta Mango, injeção de operadores, bypass de autenticação. |
| Injeção XSLT | 30 | erro, matemática, oob, leitura de arquivo | Matemática XPath, document() SSRF, leitura de arquivo, vazamento de informações system-property(). |
| Poliglotas/Casos Extremos | 246 | erro, matemática, tempo, oob | Poliglotas entre contextos + buffer overflow, limite de inteiros, type confusion, byte nulo. |
| Codificação | Caso de uso |
|---|
| URL-encoded | Parâmetros padrão de query/formulário |
| Double-URL-encoded | Bypass de WAF, vulnerabilidades de dupla decodificação |
| Base64 | Corpos de API, JWT, parâmetros serializados |
| JSON-safe | Corpos de requisição JSON (aspas escapadas) |
| HTML entity | Injeção em atributos HTML |
| Hex-escaped | Protocolos binários, injeção de baixo nível |
| Unicode-escaped | Bypass de normalização Unicode |
| Linguagem | Recurso Interno OOB | Recurso Interno de Tempo |
|---|
| 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) |
Comandos shell (curl, nslookup) dependem do SO e PATH. Recursos internos funcionam em qualquer lugar.
Sem imports sempre que possível. O CPU spin timing funciona mesmo quando imports são bloqueados:
sum(range(500000000)) (~7s, sem imports)Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,5000) (5s precisos)99999999.times{1+1}OOB em nível de soquete como fallback. Quando bibliotecas HTTP estão bloqueadas: __import__('socket').create_connection(), fsockopen(), TCPSocket.new(), new java.net.Socket().
./tools/payloadctl validate