GromHacks Labs -- Le liste di payload che non vogliono farti avere. 1.324 sonde di iniezione trasmesse dalla nave madre per rilevare cosa è iniettabile in 20 classi di vulnerabilità. Non sfruttiamo, bussiamo solo alla porta e vediamo chi risponde. Ogni payload testato su parser reali perché gli alieni esigono prove. Non fidarti di nessun input. Metti tutto in discussione!
Trovato un payload che non funziona? Per favore apri una segnalazione con il payload, il contesto di destinazione e cosa ti aspettavi accadesse. Le richieste pull con correzioni o nuovi payload sono sempre benvenute.
La ricerca è in corso. Questo progetto è in fase di sviluppo attivo e verrà aggiornato regolarmente con nuovi payload, classi di vulnerabilità e miglioramenti nella validazione.
Disclaimer: Questi payload sono forniti esclusivamente per test di sicurezza autorizzati, formazione e scopi di ricerca. Gli autori non si assumono alcuna responsabilità per eventuali usi impropri o effetti indiretti. Utilizzare interamente a proprio rischio. Utilizzando questo progetto accetti la piena responsabilità per le tue azioni.
Licenza: MIT - vedi LICENSE
1.353 payload di injection validati che coprono 20 classi di vulnerabilità, 31 framework di deserializzazione e 14 motori di template. Ogni payload produce un segnale rilevabile. Zero payload teorici.
Validazione: 1.353 testati / 1.353 attivi / 0 fallimenti / 0 saltati contro 35 stack di test Docker. La validazione rigorosa dimostra lo sfruttamento effettivo (calcolo lato server, errori reali del parser, ritardi di temporizzazione misurati, callback OOB dai container target) — non semplice corrispondenza di stringhe.
La maggior parte delle liste di payload disponibili pubblicamente sono organizzate per tipo di vulnerabilità: una lista per SQL injection, un'altra per XSS, un'altra per command injection, e così via. Un tester sceglie la lista che pensa corrisponda al target, la carica in uno strumento di intrusione e la esegue contro un parametro. Se sbaglia a indovinare la classe di vulnerabilità, l'intera scansione non produce nulla. Se il backend è un database insolito, un motore di template non standard o un linguaggio che la lista non ha considerato, i payload falliscono silenziosamente. Il tester passa oltre pensando che il parametro sia pulito.
Questo approccio ha due problemi fondamentali. In primo luogo, richiede che il tester sappia quale vulnerabilità esiste prima di averla trovata. In secondo luogo, la maggior parte dei payload in circolazione sono teorici — copiati tra progetti e articoli di blog senza mai essere testati contro un parser reale. Sembrano corretti. Potrebbero anche essere sintatticamente validi. Ma in realtà non innescano una risposta rilevabile dal target.
Questo progetto adotta un approccio diverso. L'unità di lavoro principale è il poliglotto — una singola stringa di payload progettata per essere valida (o significativamente invalida) in quanti più contesti di injection possibile simultaneamente. Un poliglotto esce da virgolette singole, virgolette doppie, parentesi, commenti a blocchi, attributi HTML, delimitatori di template e contesti di backtick tutti insieme. Invece di dover sapere qual è la vulnerabilità, il tester lancia poliglotti a ogni parametro e osserva i segnali.
Ogni payload in questa raccolta è costruito attorno a pilastri di rilevamento — risposte osservabili che confermano l'esistenza di una vulnerabilità senza richiedere accesso ai log del server, al codice sorgente o al filesystem:
7*191 che viene valutata come 1337. Se quel numero appare nella risposta e il payload ha inviato solo 7*191 (non il letterale 1337), il backend ha calcolato l'espressione — prova di esecuzione di codice.Se un payload non produce almeno uno di questi segnali quando testato contro il suo contesto target, non appartiene all'elenco. Ognuno dei 1.353 payload qui è stato validato contro banchi di prova Docker appositamente costruiti con prova rigorosa di sfruttamento. Zero sono teorici.
I payload OOB e di temporizzazione tradizionali si basano su comandi shell: curl, nslookup, ping, sleep. Questi si rompono continuamente. Dipendono dal sistema operativo target, dal PATH disponibile, da quale shell interpreta il comando e se il processo ha il permesso di generare sottoprocessi. Un payload OOB basato su curl che funziona su Ubuntu fallisce su Alpine (nessun curl), fallisce su Windows (nessun curl) e fallisce all'interno di un contenitore ristretto (nessuna esecuzione di processo in uscita).
Questo progetto sostituisce i comandi shell con funzioni native del linguaggio, ove possibile. I payload Python usano urllib.request.urlopen() e time.sleep(). I payload Java usano java.net.URL.openStream() e Thread.sleep(). Ruby usa Net::HTTP.get() e Kernel.sleep. PHP usa file_get_contents() e sleep(). Queste funzioni esistono in ogni installazione standard del rispettivo linguaggio — nessuna ricerca nel PATH, nessun sottoprocesso, nessuna dipendenza dal sistema operativo.
Laddove anche gli import della libreria standard potrebbero essere bloccati (eval in sandbox, exec ristretto), i payload ricorrono ad alternative senza import: cicli CPU per la temporizzazione (sum(range(500000000)) in Python, Atomics.wait() in Node) e connessioni socket grezze per OOB (__import__('socket').create_connection(), fsockopen(), TCPSocket.new()).
Non tutto può essere un poliglotto. I motori di template usano sintassi fondamentalmente incompatibili — {{}} in Jinja2 non significa nulla per <%= %> di ERB, e nessuno dei due viene analizzato come ${} di Freemarker). I formati di deserializzazione sono dati binari o strutturati specifici di un singolo framework. Per queste categorie, il progetto utilizza payload per motore specifico organizzati sotto lo stesso sistema di pilastri di rilevamento, coprendo 14 motori di template e 31 framework di deserializzazione in 7 linguaggi.
Il risultato è un unico corpus dove i poliglotti gestiscono i contesti che possono (SQLi, OS command injection, XSS, code injection) e payload specifici per motore creati appositamente gestiscono il resto, tutti validati, tutti che producono segnali rilevabili, tutti pronti per strumenti di injection riga per riga.
83 payload che coprono tutti i 35 stack di test, tutti i 55+ endpoint e tutti i 4 pilastri di rilevamento per categoria. Validati: 83 ATTIVI / 0 NON ATTIVI / 0 SALTATI.
Ogni categoria di injection riceve copertura di errore + matematica + temporizzazione + OOB dove architetturalmente possibile. I framework di deserializzazione che supportano l'esecuzione di codice (Pickle, PyYAML, jsonpickle, node-serialize, XMLDecoder, .NET Json.NET) ottengono copertura multi-pilastro completa. I framework limitati al probing (PHP unserialize, Ruby Marshal, SnakeYAML, ecc.) ricevono rilevamento basato su errore. Lancia questo contro ogni parametro prima di passare agli elenchi completi per categoria per approfondimento.
83 richieste invece di 1.353. Utilizza ready/minimal/payloads-only.txt per Burp Intruder.
Vedere HOWTOUSE.md per la guida completa all'operatore. Trasforma "Sto guardando un parametro, cosa ci lancio?" in un flusso di lavoro ripetibile:
7*7 che restituisce 49 come indizio di eval, {{name}} che viene renderizzato come "Alice" che conferma SSTI, output di ping che perde da un campo diagnostico, stringhe User-Agent nei log OOB che nominano la libreria fetcher), trappole ORM moderne (Prisma $queryRaw, Rails .order(), Hibernate JPQL concat, Mongoose findOne(req.body)), e sonde economiche per confermare il sospetto prima di bruciare l'intero elenco.rO0AB = Java, AAEAAAD///// = .NET BinaryFormatter, BAg = Ruby Marshal, gASV = Python pickle P4, / = PHP unserialize, ecc.) con una scheda di riferimento rapido di 16 voci ed euristiche di disambiguazione. Identifica il blob prima di lanciare, così carichi 5-15 payload corrispondenti invece di tutti e 232.Usa HOWTOUSE.md prima di eseguire payloadctl prepare. Prima fingerprint, poi elenco minimo, poi approfondimento per categoria — non una raffica di 1.353 payload a ogni parametro.
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com
Dopo aver eseguito `prepare`, i file pronti all'uso si trovano in `ready/full/` e `ready/minimal/` con la seguente struttura:
| File | Cosa | Conteggio |
|------|------|-------|
| `ready/minimal/payloads-only.txt` | **Minimale -- 83 richieste, tutti i pilastri** | 83 |
| `ready/full/payloads-only.txt` | Elenco completo, un payload per riga | 1,353 |
| `ready/full/by-category/sqli.txt` | Solo SQL injection | 211 |
| `ready/full/by-category/ssti.txt` | Solo template injection | 206 |
| `ready/full/by-category/deserialization.txt` | Solo deserializzazione | 232 |
| `ready/full/by-category/os-cmd-injection.txt` | Solo OS command injection | 120 |
| `ready/full/by-category/code-injection.txt` | Solo code injection | 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 NoSQL injection | 32 |
| `ready/full/by-category/format-string.txt` | Solo format string | 38 |
| `ready/full/by-category/el-injection.txt` | Solo expression language | 34 |
| `ready/full/by-category/header-crlf.txt` | Solo CRLF/header injection | 17 |
| `ready/full/by-category/prototype-pollution.txt` | Solo prototype pollution | 12 |
| `ready/full/by-category/xxe.txt` | Solo XXE | 11 |
| `ready/full/by-category/ldap-injection.txt` | Solo LDAP injection | 35 |
| `ready/full/by-category/xslt-injection.txt` | Solo XSLT injection | 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` | Polyglot cross-context | 246 |
| `ready/full/by-pillar/error-payloads-only.txt` | Payload basati su errori | 324 |
| `ready/full/by-pillar/timing-payloads-only.txt` | Basati sul tempo (blind) | 227 |
| `ready/full/by-pillar/oob-payloads-only.txt` | Callback out-of-band | 209 |
| `ready/full/by-pillar/math-payloads-only.txt` | Canary matematico (1337) | 182 |
| `ready/full/by-pillar/reflected-payloads-only.txt` | Riflessi/casi limite | 374 |
| `ready/full/encoded/url-encoded/payloads.txt` | Variante URL-encoded | 1,353 |
| `ready/full/encoded/base64/payloads.txt` | Variante Base64 | 1,353 |
| `ready/full/encoded/json-safe/payloads.txt` | Variante JSON-safe | 1,353 |
| `ready/full/encoded/double-url-encoded/payloads.txt` | Doppio URL-encoded | 1,353 |
| `ready/full/encoded/html-entity/payloads.txt` | Codifica entità HTML | 1,353 |
| `ready/full/encoded/hex-escaped/payloads.txt` | Variante hex-escaped | 1,353 |
| `ready/full/encoded/unicode-escaped/payloads.txt` | Variante Unicode-escaped | 1,353 |
La directory `ready/minimal/` rispecchia la stessa struttura (by-category, by-pillar, encoded) con il set di payload minimale.
Directory di output personalizzata:```bash
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com -o /path/to/engagement/payloads
I template grezzi con segnaposto {domain} (per sostituzione scriptata) si trovano in payloads/lists/full/ e payloads/lists/minimal/.
Ogni payload produce almeno uno di questi segnali. Cercali con grep nelle tue risposte:
Valori canarini: 1337 (primario, da 7*191) e 7331 (secondario). Il rilevamento è un semplice grep.
13 delle 20 categorie hanno tutti e 4 i pilastri. Le 7 che non li hanno (XSS, XSLT, Format String, Prototype Pollution, CRLF, XXE, CouchDB) hanno ragioni architetturali -- non puoi fare CRLF basato su timing o format string OOB. Dove il cross-pilastro È possibile, la sezione polyglot lo copre.
7 formati di codifica, ciascuno con tutti i 1.353 payload:
Payload minimi, massima copertura di contesto. Vedi SPEC.md per la specifica tecnica completa con tabelle dei pilastri per engine e sintassi esatta dei payload.
Polyglot prima di tutto. Un singolo payload esce da ', ", ), */, -->, backtick e delimitatori di template simultaneamente. Le sezioni polyglot conducono la lista principale.
Per engine dove i polyglot non possono arrivare. I delimitatori SSTI e i formati di deserializzazione sono fondamentalmente incompatibili tra engine.
Built-in meglio di shell. I payload OOB e timing usano librerie native del linguaggio:
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
### Flusso di lavoro di sviluppo tipico```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
---
## Aggiungere payload
### Aggiungere un payload a una categoria esistente
1. Modificare il file sorgente in `payloads/sources/`. Un payload per riga sotto una sezione `##Header##`.
2. Ogni payload deve produrre un segnale rilevabile (errore, math 1337, timing >4.5s, OOB, reflection).
3. Ricostruire e convalidare: ```bash
./tools/payloadctl build && ./tools/payloadctl dist
./tools/payloadctl validate # 0 NO-FIRE required
payloads/sources/<category>.txt con intestazioni ## per ogni pilastro (error, math, timing, OOB).tools/cmd_build.py SOURCE_FILES e tools/cmd_dist.py CATEGORY_SOURCES.testbed/stacks/<category>/ (Dockerfile + server che espone POST /<endpoint> con input=<payload> restituendo {"output": "...", "error": "...", "time_ms": N}).tools/cmd_validate.py (dizionario ENDPOINTS e funzione _get_endpoints()).tools/generate-deser-final.py - aggiungere una funzione che produce payload (error, math, timing, OOB)../tools/payloadctl generate deser && ./tools/payloadctl buildpayloads/sources/ssti.txt - aggiungere sezioni ##EngineName (Language) - Pillar##. Utilizzare built-in del linguaggio per timing/OOB.ssti-<language>.tools/cmd_validate.py ENGINE_MAP.\n letterale){domain} per URL di callback OOB1337 canary per tutti i payload math##Header## raggruppano per categoria e pilastroIl validatore testa ogni payload contro applicazioni vulnerabili reali:```bash
cd testbed ./testbed up sqli-sqlite ./testbed up ssti-python ./testbed up deserialization-java
cd .. ./tools/payloadctl validate
How it works:
1. Legge il file dei payload e indirizza ogni sezione `##` al/i testbed endpoint corrispondente/i
2. Invia POST `input=<payload>` agli endpoint, controlla la risposta per segnali
3. Un payload viene attivato se QUALSIASI endpoint restituisce: errore reale del parser/interprete, `1337` calcolato dal server (da `7*191`), ritardo >4,5s, callback OOB dal container di destinazione, contenuto di file letto (`root:x:0:0`), o input riflesso in un contesto valido (XSS, CRLF)
La validazione rigorosa (`tools/cmd_validate_strict.py`) verifica inoltre:
- I payload matematici dimostrano il calcolo lato server (il payload invia `7*191`, non il letterale `1337`)
- I callback OOB provengono dagli IP del container del testbed
- I messaggi di errore contengono firme reali del parser/interprete, non errori HTTP generici
- I ritardi temporali rientrano nell'intervallo previsto (~5 secondi)
### Stack dei testbed (35 totali)
| Stack | Porta | Linguaggio | Endpoint |
|-------|------|------------|----------|
| 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 sulla porta 9999 (HTTP + rilevamento LDAP/binario) e sulla 9998 (catch-all TCP raw), con DNS sulla 5353/UDP. Rileva callback HTTP, connessioni binarie LDAP/ASN.1 (JNDI), query DNS e connessioni TCP raw. Ogni endpoint accetta `POST /<sink>` con `input=<payload>` e restituisce `{"output": "...", "error": "...|null", "time_ms": N}`.
---
## Crediti
Payload studiati e sviluppati da [Grom Hacks](https://github.com/gromhacks). Basati sul lavoro della community di ricerca sulla sicurezza, inclusi PayloadsAllTheThings, HackTricks, PortSwigger Web Security Academy e ricercatori individuali. Tutti i payload sono stati validati su applicazioni vulnerabili reali.
| Payload | Categoria | Pilastri |
|---|
| 4 | SQLi | errore, matematica, temporizzazione, OOB (poliglotti cross-dialetto) |
| 4 | SSTI | errore, matematica, temporizzazione, OOB (poliglotti cross-motore) |
| 3 | OS Cmd | matematica, temporizzazione, OOB (poliglotti cross-shell) |
| 3 | Code Injection | matematica, temporizzazione, OOB (cross-linguaggio) |
| 2 | XSS | matematica, OOB |
| 2 | XXE | lettura-file, OOB |
| 2 | SSRF | errore, OOB |
| 1 | Path Traversal | lettura-file |
| 2 | NoSQL | matematica, errore |
| 1 | EL Injection | matematica |
| 1 | Prototype Pollution | matematica |
| 1 | CRLF/Header | matematica |
| 1 | Format String | errore |
| 1 | SSI | matematica |
| 2 | LDAP Injection | errore, matematica |
| 3 | XSLT Injection | errore, matematica, OOB |
| 2 | Elasticsearch | errore, matematica |
| 2 | Cypher/Neo4j | errore, temporizzazione |
| 1 | CouchDB | errore |
| 3 | Groovy | matematica, temporizzazione, OOB |
| 41 | Deserializzazione | multi-pilastro dove supportato, solo errore altrimenti |
TzoYToid=42 e JSESSIONID" a "prova by-category/sqli.txt + deserializzazione Java + EL injection, controlla il pilastro matematica" in una sola consultazione.| Pilastro | Payload | Cosa cercare | Quando usare |
|---|
| Error | 324 | Testo dell'eccezione, stack trace, errore del parser nella risposta | L'app riflette errori |
| Timing | 227 | La risposta richiede >4.5 secondi | Blind - nessun output, nessun errore |
| OOB | 209 | HTTP/DNS/LDAP/TCP in uscita verso il tuo server di callback | Blind + asincrono - timing inaffidabile |
| Math | 182 | Letterale 1337 nel corpo della risposta (server ha calcolato 7*191) | Output riflesso ma nessun errore |
| Reflected | 374 | Valore di input riprodotto nella risposta | Fuzzing per anomalie del parser |
| File-read | (sottoinsieme) | Contenuto di root: o [extensions] nella risposta | Path traversal, lettura file XXE |
| Categoria | Conteggio | Pilastri | Copertura |
|---|
| SQLi | 211 | error, math, timing, oob | MySQL, PostgreSQL, Oracle, MSSQL, SQLite, CockroachDB. UNION, error, timing, OOB. Breakout di contesto: ', ", ), )), */, numerico. |
| SSTI | 206 | error, math, timing, oob | Jinja2, Mako, Tornado, EJS, Nunjucks, Pug, Twig, Smarty, ERB, Slim, Haml, Thymeleaf, Pebble, Freemarker, Velocity, Razor, Go template, Mustache, Liquid. Tutti usano built-in del linguaggio. |
| Deserialization | 232 | error, math, timing, oob | 31 framework / 7 linguaggi. Tutti i payload nativi del linguaggio usano built-in (nessun comando 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). |
| OS Cmd Injection | 120 | error, math, timing, oob | Bash, CMD, PowerShell. Breakout: ;, |, ||, &&, $(), backtick. Bypass IFS, bypass glob, codifica hex. |
| Code Injection | 123 | error, math, timing, oob | Python, Node, PHP, Ruby, Perl, Lua, Java ScriptEngine, Groovy. CPU spin senza import, OOB a livello di socket. |
| SSRF | 156 | error, math, timing, oob | Metadati cloud (AWS/GCP/Azure), bypass IP, schemi di protocollo, DNS rebinding, sonde di servizi interni. |
| Path Traversal | 113 | error, math, timing, oob | Linux + Windows, bypass di codifica, null byte, wrapper PHP, UNC, ADS NTFS, nomi brevi 8.3. |
| XSS | 58 | error, math, oob | Polyglot cross-contesto (20+ contesti), gestori di eventi, elusione filtri, DOM clobbering, mutation XSS, SVG, OOB. |
| Format String | 38 | error, math | C/C++ (%s%n%x), Python ({0.__class__}), .NET ({0:X}). |
| NoSQL | 32 | error, math, timing, oob | Iniezione di operatori MongoDB, timing $where, OOB, comandi Redis. |
| EL Injection | 34 | error, math, timing, oob | SpEL, OGNL, MVEL, Unified EL. OOB via java.net.URL. |
| CRLF/Header | 17 | error, math, oob | Response splitting, iniezione di header, OOB via header Host. |
| Prototype Pollution | 12 | error, math | __proto__, constructor.prototype, varianti JSON e query string. |
| XXE | 11 | error, timing, oob, file-read | Entità esterne, XInclude, entità parametro, Billion Laughs DoS. |
| LDAP Injection | 35 | error, math, timing, oob | Iniezione di filtro, bypass autenticazione, timing wildcard, referral OOB. |
| Elasticsearch | 30 | error, math, timing, oob | Iniezione script Painless, query DSL, sintassi query_string. |
| Cypher/Neo4j | 27 | error, math, timing, oob | Iniezione query Cypher, APOC sleep, LOAD CSV OOB. |
| CouchDB | 5 | error, math | Iniezione query Mango, iniezione operatori, bypass autenticazione. |
| XSLT Injection | 30 | error, math, oob, file-read | Math XPath, document() SSRF, lettura file, info leak system-property(). |
| Polyglots/Edge Cases | 246 | error, math, timing, oob | Polyglot cross-contesto + buffer overflow, limite intero, type confusion, null byte. |
| Codifica | Caso d'uso |
|---|
| URL-encoded | Parametri standard di query/form |
| Double-URL-encoded | Bypass WAF, vulnerabilità double-decode |
| Base64 | Corpi API, JWT, parametri serializzati |
| JSON-safe | Corpi richiesta JSON (virgolette escaped) |
| HTML entity | Iniezione attributi HTML |
| Hex-escaped | Protocolli binari, iniezione a basso livello |
| Unicode-escaped | Bypass normalizzazione Unicode |
| Linguaggio | Built-in OOB | Built-in Timing |
|---|
| Python | urllib.request.urlopen() | time.sleep(5) |
| Java | java.net.URL.openStream() | Thread.sleep(5000) |
| Node | require('http').get() | Ciclo busy-wait con Date.now() |
| 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) |
I comandi shell (curl, nslookup) dipendono dal sistema operativo e dal PATH. I built-in funzionano ovunque.
Senza import dove possibile. Il timing CPU spin funziona anche quando gli import sono bloccati:
sum(range(500000000)) (~7s, nessun import)Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,5000) (preciso 5s)99999999.times{1+1}OOB a livello di socket come fallback. Quando le librerie HTTP sono bloccate: __import__('socket').create_connection(), fsockopen(), TCPSocket.new(), new java.net.Socket().
./tools/payloadctl validate