gromhacks/payload-and-polyglot-listsGromHacks Labs -- Die Payload-Listen, die sie dir nicht geben wollen. 1.324 Injektionssonden, die vom Mutterschiff herabgestrahlt werden, um zu erkennen, was über 20 Schwachstellenklassen hinweg injizierbar ist. Wir nutzen nichts aus, wir klopfen nur an die Tür und schauen, wer antwortet. Jede Payload wird an echten Parsern getestet, weil die Aliens Beweise fordern. Vertraue keiner Eingabe. Stelle alles in Frage!
Haben Sie einen Payload gefunden, der nicht funktioniert? Bitte eröffnen Sie ein Issue mit dem Payload, dem Zielkontext und dem erwarteten Verhalten. Pull-Requests mit Korrekturen oder neuen Payloads sind immer willkommen.
Die Forschung läuft weiter. Dieses Projekt befindet sich in aktiver Entwicklung und wird regelmäßig mit neuen Payloads, Schwachstellenklassen und Validierungsverbesserungen aktualisiert.
Haftungsausschluss: Diese Payloads sind ausschließlich für autorisierte Sicherheitstests, Schulungen und Forschungszwecke vorgesehen. Die Autoren übernehmen keinerlei Verantwortung oder Haftung für Missbrauch oder daraus resultierende Folgen. Die Nutzung erfolgt vollständig auf eigenes Risiko. Mit der Nutzung dieses Projekts übernehmen Sie die volle Verantwortung für Ihr Handeln.
Lizenz: MIT – siehe LICENSE
1.353 validierte Injektions-Payloads, die 20 Schwachstellenklassen, 31 Deserialisierungs-Frameworks und 14 Template-Engines abdecken. Jeder Payload erzeugt ein detektierbares Signal. Null theoretische Payloads.
Validierung: 1.353 getestet / 1.353 feuern / 0 Fehlschläge / 0 übersprungen gegen 35 Docker-Testumgebungen. Strikte Validierung beweist tatsächliche Ausnutzung (serverseitige Berechnung, echte Parserfehler, gemessene Zeitverzögerungen, OOB-Callbacks von Zielcontainern) – kein Zeichenkettenabgleich.
Die meisten öffentlich verfügbaren Payload-Listen sind nach Schwachstellentyp organisiert: eine Liste für SQL-Injektion, eine andere für XSS, eine weitere für Befehlsinjektion und so weiter. Ein Tester wählt die Liste aus, von der er glaubt, dass sie zum Ziel passt, lädt sie in ein Intruder-Tool und führt sie gegen einen Parameter aus. Wenn er sich bei der Schwachstellenklasse irrt, liefert der gesamte Scan nichts. Wenn das Backend eine ungewöhnliche Datenbank, eine nicht standardmäßige Template-Engine oder eine Sprache ist, die in der Liste nicht berücksichtigt wurde, schlagen die Payloads stillschweigend fehl. Der Tester geht weiter und hält den Parameter für sauber.
Dieser Ansatz hat zwei grundlegende Probleme. Erstens erfordert er, dass der Tester weiß, welche Schwachstelle existiert, bevor er sie gefunden hat. Zweitens sind die meisten in Umlauf befindlichen Payloads theoretisch – sie werden zwischen Projekten und Blogbeiträgen kopiert, ohne jemals gegen einen echten Parser getestet zu werden. Sie sehen richtig aus. Sie könnten sogar syntaktisch gültig sein. Aber sie lösen tatsächlich keine detektierbare Antwort des Ziels aus.
Dieses Projekt verfolgt einen anderen Ansatz. Die primäre Arbeitseinheit ist der Polyglot – eine einzelne Payload-Zeichenfolge, die so konstruiert ist, dass sie in möglichst vielen Injektionskontexten gleichzeitig gültig (oder bedeutungsvoll ungültig) ist. Ein einziger Polyglot bricht aus einfachen Anführungszeichen, doppelten Anführungszeichen, Klammern, Blockkommentaren, HTML-Attributen, Template-Begrenzern und Backtick-Kontexten gleichzeitig aus. Anstatt zu wissen, was die Schwachstelle ist, schießt der Tester Polyglots auf jeden Parameter und beobachtet die Signale.
Jeder Payload in dieser Sammlung basiert auf Erkennungssäulen – beobachtbaren Antworten, die bestätigen, dass eine Schwachstelle existiert, ohne dass Zugriff auf Serverlogs, Quellcode oder das Dateisystem erforderlich ist:
7*191, der zu 1337 ausgewertet wird. Wenn diese Zahl in der Antwort erscheint und der Payload nur 7*191 (nicht den Literal 1337) gesendet hat, hat das Backend den Ausdruck berechnet – ein Beweis für Codeausführung.Wenn ein Payload mindestens eines dieser Signale im Test gegen seinen Zielkontext nicht erzeugt, gehört er nicht in die Liste. Jeder der 1.353 Payloads hier wurde gegen eigens erstellte Docker-Testumgebungen mit strengem Nachweis der Ausnutzung validiert. Keiner ist theoretisch.
Traditionelle OOB- und Timing-Payloads verlassen sich auf Shell-Befehle: curl, nslookup, ping, sleep. Diese versagen ständig. Sie hängen vom Zielbetriebssystem, dem verfügbaren PATH, der Shell, die den Befehl interpretiert, und davon ab, ob der Prozess die Berechtigung zum Erstellen von Unterprozessen hat. Ein curl-basierter OOB-Payload, der auf Ubuntu funktioniert, schlägt auf Alpine (kein curl), auf Windows (kein curl) und innerhalb eines eingeschränkten Containers (keine ausgehende Prozessausführung) fehl.
Dieses Projekt ersetzt Shell-Befehle nach Möglichkeit durch sprachspezifische Built-ins. Python-Payloads verwenden urllib.request.urlopen() und time.sleep(). Java-Payloads verwenden java.net.URL.openStream() und Thread.sleep(). Ruby verwendet Net::HTTP.get() und Kernel.sleep. PHP verwendet file_get_contents() und sleep(). Diese Funktionen sind in jeder Standardinstallation ihrer jeweiligen Sprache vorhanden – kein PATH-Lookup, kein Unterprozess, keine Betriebssystemabhängigkeit.
Wo selbst Standardbibliotheksimporte blockiert sein könnten (Sandbox-Eval, eingeschränktes Exec), greifen die Payloads auf import-freie Alternativen zurück: CPU-Spin-Loops für Timing (sum(range(500000000)) in Python, Atomics.wait() in Node) und direkte Socket-Verbindungen für OOB (__import__('socket').create_connection(), fsockopen(), TCPSocket.new()).
Nicht alles kann ein Polyglot sein. Template-Engines verwenden grundlegend inkompatible Syntax – {{}} in Jinja2 bedeutet nichts für ERBs <%= %>, und beides wird nicht als Freemarker-${} geparst). Deserialisierungsformate sind binär oder strukturierte Daten, die für ein bestimmtes Framework spezifisch sind. Für diese Kategorien verwendet das Projekt pro-Engine-Payloads, die unter demselben Erkennungssäulen-System organisiert sind und 14 Template-Engines und 31 Deserialisierungs-Frameworks in 7 Sprachen abdecken.
Das Ergebnis ist ein einzelnes Korpus, in dem Polyglots die Kontexte abdecken, die sie können (SQLi, OS-Befehlsinjektion, XSS, Code-Injektion), und speziell entwickelte pro-Engine-Payloads den Rest, alle validiert, alle erzeugen detektierbare Signale, alle bereit für zeilenweise Injektionswerkzeuge.
83 Payloads decken alle 35 Testumgebungen, alle 55+ Endpunkte und alle 4 Erkennungssäulen pro Kategorie ab. Validierung: 83 FEUERN / 0 NICHT-FEUERN / 0 ÜBERSPRUNGEN.
Jede Injektionskategorie erhält, wo architektonisch möglich, Fehler- + Mathe- + Timing- + OOB-Abdeckung. Deserialisierungs-Frameworks, die Codeausführung unterstützen (Pickle, PyYAML, jsonpickle, node-serialize, XMLDecoder, .NET Json.NET), erhalten vollständige Multi-Säulen-Abdeckung. Frameworks, die auf Sondierung beschränkt sind (PHP unserialize, Ruby Marshal, SnakeYAML usw.), erhalten fehlerbasierte Erkennung. Feuern Sie diese Liste auf jeden Parameter, bevor Sie für die Tiefe zu den vollständigen Kategorielisten übergehen.
83 Anfragen statt 1.353. Verwenden Sie ready/minimal/payloads-only.txt für Burp Intruder.
Siehe HOWTOUSE.md für die vollständige Bedienungsanleitung. Sie verwandelt „Ich schaue mir einen Parameter an, was werfe ich darauf?“ in einen wiederholbaren Arbeitsablauf:
7*7 gibt 49 als Eval-Hinweis zurück, {{name}} rendert als „Alice“ bestätigt SSTI, Ping-Ausgabe aus einem Diagnosefeld, User-Agent-Strings in OOB-Logs nennen die Abrufbibliothek), moderne-Stack-ORM-Fallstricke (Prisma $queryRaw, Rails .order(), Hibernate JPQL Concat, Mongoose findOne(req.body)) und günstige Sonden, um den Verdacht zu bestätigen, bevor Sie die vollständige Liste abfeuern.rO0AB = Java, AAEAAAD///// = .NET BinaryFormatter, BAg = Ruby Marshal, gASV = Python pickle P4, / = PHP unserialize usw.) mit einer 16-Einträge-Spickzettel-Cheat-Karte und Disambiguierungsheuristiken. Fingerprinten Sie den Blob, bevor Sie feuern, sodass Sie 5-15 passende Payloads laden statt aller 232.Verwenden Sie HOWTOUSE.md, bevor Sie payloadctl prepare ausführen. Zuerst Fingerabdruck, dann Minimal-Liste, dann Kategorie-Tiefenbohrung – keine Schrotflinte mit 1.353 Payloads auf jeden Parameter.
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com
Nach Ausführung von `prepare` befinden sich Ihre einsatzbereiten Dateien in `ready/full/` und `ready/minimal/` mit folgender Struktur:
| Datei | Beschreibung | Anzahl |
|------|------|-------|
| `ready/minimal/payloads-only.txt` | **Minimal – 83 Anfragen, alle Säulen** | 83 |
| `ready/full/payloads-only.txt` | Vollständige Liste, ein Payload pro Zeile | 1,353 |
| `ready/full/by-category/sqli.txt` | Nur SQL-Injection | 211 |
| `ready/full/by-category/ssti.txt` | Nur Template-Injection | 206 |
| `ready/full/by-category/deserialization.txt` | Nur Deserialisierung | 232 |
| `ready/full/by-category/os-cmd-injection.txt` | Nur OS-Befehlsinjektion | 120 |
| `ready/full/by-category/code-injection.txt` | Nur Code-Injection | 123 |
| `ready/full/by-category/ssrf.txt` | Nur SSRF | 156 |
| `ready/full/by-category/path-traversal.txt` | Nur Path Traversal | 113 |
| `ready/full/by-category/xss.txt` | Nur XSS | 58 |
| `ready/full/by-category/nosql.txt` | Nur NoSQL-Injection | 32 |
| `ready/full/by-category/format-string.txt` | Nur Format String | 38 |
| `ready/full/by-category/el-injection.txt` | Nur Expression Language | 34 |
| `ready/full/by-category/header-crlf.txt` | Nur CRLF/Header-Injection | 17 |
| `ready/full/by-category/prototype-pollution.txt` | Nur Prototype Pollution | 12 |
| `ready/full/by-category/xxe.txt` | Nur XXE | 11 |
| `ready/full/by-category/ldap-injection.txt` | Nur LDAP-Injection | 35 |
| `ready/full/by-category/xslt-injection.txt` | Nur XSLT-Injection | 30 |
| `ready/full/by-category/elasticsearch-injection.txt` | Nur Elasticsearch | 30 |
| `ready/full/by-category/cypher-injection.txt` | Nur Neo4j/Cypher | 27 |
| `ready/full/by-category/couchdb-injection.txt` | Nur CouchDB | 5 |
| `ready/full/by-category/polyglots.txt` | Kontextübergreifende Polyglots | 246 |
| `ready/full/by-pillar/error-payloads-only.txt` | Fehlerbasierte Payloads | 324 |
| `ready/full/by-pillar/timing-payloads-only.txt` | Zeitbasierte (Blind) | 227 |
| `ready/full/by-pillar/oob-payloads-only.txt` | Out-of-Band Callback | 209 |
| `ready/full/by-pillar/math-payloads-only.txt` | Mathematische Canary (1337) | 182 |
| `ready/full/by-pillar/reflected-payloads-only.txt` | Reflektierte/Grenzfälle | 374 |
| `ready/full/encoded/url-encoded/payloads.txt` | URL-kodierte Variante | 1,353 |
| `ready/full/encoded/base64/payloads.txt` | Base64-Variante | 1,353 |
| `ready/full/encoded/json-safe/payloads.txt` | JSON-sichere Variante | 1,353 |
| `ready/full/encoded/double-url-encoded/payloads.txt` | Doppelt URL-kodiert | 1,353 |
| `ready/full/encoded/html-entity/payloads.txt` | HTML-Entity-kodiert | 1,353 |
| `ready/full/encoded/hex-escaped/payloads.txt` | Hex-escaped Variante | 1,353 |
| `ready/full/encoded/unicode-escaped/payloads.txt` | Unicode-escaped Variante | 1,353 |
Das Verzeichnis `ready/minimal/` spiegelt die gleiche Struktur (by-category, by-pillar, encoded) mit dem minimalen Payload-Satz wider.
Benutzerdefiniertes Ausgabeverzeichnis:```bash
./tools/payloadctl prepare YOUR_CALLBACK.oastify.com -o /path/to/engagement/payloads
Raw templates with {domain} placeholder (for scripted substitution) are in payloads/lists/full/ and payloads/lists/minimal/.
Jeder Payload erzeugt mindestens eines dieser Signale. Suchen Sie mit grep in Ihren Antworten danach:
Canary-Werte: 1337 (primär, aus 7*191) und 7331 (sekundär). Erkennung ist ein einfaches grep.
13 von 20 Kategorien haben alle 4 Säulen. Die 7, die das nicht haben (XSS, XSLT, Format String, Prototype Pollution, CRLF, XXE, CouchDB), haben architektonische Gründe – Sie können kein Timing-basiertes CRLF oder OOB-Format-Strings durchführen. Wo säulenübergreifende Erkennung möglich ist, wird sie im Polyglots-Abschnitt abgedeckt.
Minimale Payloads, maximale Kontextabdeckung. Siehe SPEC.md für die vollständige technische Spezifikation mit enginespezifischen Säulentabellen und genauer Payload-Syntax.
Polyglots zuerst. Ein einziger Payload bricht gleichzeitig aus ', ", ), */, -->, Backticks und Template-Trennzeichen aus. Polyglot-Abschnitte führen die Masterliste an.
Pro Engine, wo Polyglots nicht hinreichen. SSTI-Trennzeichen und Deserialisierungsformate sind grundsätzlich enginespezifisch inkompatibel.
Built-in vor Shell. OOB- und Timing-Payloads verwenden spracheigene Bibliotheken:
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
### Typischer Entwicklungsablauf```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
---
## Hinzufügen von Payloads
### Hinzufügen einer Payload zu einer bestehenden Kategorie
1. Bearbeiten Sie die Quelldatei in `payloads/sources/`. Eine Payload pro Zeile unter einem `##Header##`-Abschnitt.
2. Jede Payload muss ein nachweisbares Signal erzeugen (Fehler, math 1337, Zeit >4.5s, OOB, Reflexion).
3. Neu erstellen und validieren: ```bash
./tools/payloadctl build && ./tools/payloadctl dist
./tools/payloadctl validate # 0 NO-FIRE required
payloads/sources/<category>.txt mit ##-Überschriften für jeden Pfeiler (error, math, timing, OOB).tools/cmd_build.py SOURCE_FILES und tools/cmd_dist.py CATEGORY_SOURCES hinzu.testbed/stacks/<category>/ (Dockerfile + Server, der POST /<endpoint> mit input=<payload> bereitstellt und {"output": "...", "error": "...", "time_ms": N} zurückgibt).tools/cmd_validate.py hinzu (ENDPOINTS-Dict und _get_endpoints()-Funktion).tools/generate-deser-final.py – füge eine Funktion hinzu, die Payloads (error, math, timing, OOB) ausgibt../tools/payloadctl generate deser && ./tools/payloadctl build auspayloads/sources/ssti.txt – füge ##EngineName (Sprache) - Pillar##-Abschnitte hinzu. Verwende sprachinterne Funktionen für timing/OOB.ssti-<Sprache>-Stack hinzu.tools/cmd_validate.py ENGINE_MAP hinzu.\n){domain}-Platzhalter für OOB-Callback-URLs1337-Canary für alle Math-Payloads##Header##-Abschnitte gruppieren nach Kategorie und PfeilerDer Validator testet jeden Payload gegen echte anfällige Anwendungen:```bash
cd testbed ./testbed up sqli-sqlite ./testbed up ssti-python ./testbed up deserialization-java
cd .. ./tools/payloadctl validate
So funktioniert es:
1. Liest die Payload-Datei ein und leitet jede `##`-Sektion an passende Testbed-Endpunkte weiter
2. Sendet `input=<payload>` per POST an die Endpunkte und prüft die Antwort auf Signale
3. Ein Payload feuert, wenn IRGENDEIN Endpunkt zurückgibt: echten Parser/Interpreter-Fehler, server-seitig berechnetes `1337` (aus `7*191`), >4.5s Verzögerung, OOB-Callback vom Zielcontainer, Datei-Lese-Inhalt (`root:x:0:0`) oder reflektierte Eingabe in einem gültigen Kontext (XSS, CRLF)
Strenge Validierung (`tools/cmd_validate_strict.py`) überprüft zusätzlich:
- Mathe-Payloads beweisen serverseitige Berechnung (Payload sendet `7*191`, nicht literal `1337`)
- OOB-Callbacks stammen von den IPs der Testbed-Container
- Fehlermeldungen enthalten echte Parser/Interpreter-Signaturen, keine generischen HTTP-Fehler
- Zeitverzögerungen liegen im erwarteten Bereich (~5 Sekunden)
### Testbed-Stacks (insgesamt 35)
| Stack | Port | Sprache | Endpunkte |
|-------|------|----------|-----------|
| 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` |
OOB-Catcher auf Port 9999 (HTTP + LDAP/Binary-Erkennung) und 9998 (roher TCP-Catch-All), mit DNS auf 5353/UDP. Erkennt HTTP-Callbacks, LDAP/ASN.1-Binärverbindungen (JNDI), DNS-Abfragen und rohe TCP-Verbindungen. Jeder Endpunkt akzeptiert `POST /<sink>` mit `input=<payload>` und gibt `{"output": "...", "error": "...|null", "time_ms": N}` zurück.
---
## Danksagungen
Payloads erforscht und entwickelt von [Grom Hacks](https://github.com/gromhacks). Basiert auf Arbeiten der Sicherheitsforschungsgemeinschaft, einschließlich PayloadsAllTheThings, HackTricks, PortSwigger Web Security Academy und einzelner Forscher. Alle Payloads wurden gegen reale anfällige Anwendungen validiert.
| Payloads | Kategorie | Säulen |
|---|
| 4 | SQLi | Fehler, Mathe, Timing, OOB (dialektübergreifende Polyglots) |
| 4 | SSTI | Fehler, Mathe, Timing, OOB (engineübergreifende Polyglots) |
| 3 | OS-Befehl | Mathe, Timing, OOB (shellübergreifende Polyglots) |
| 3 | Code-Injektion | Mathe, Timing, OOB (sprachübergreifend) |
| 2 | XSS | Mathe, OOB |
| 2 | XXE | Datei-Lesen, OOB |
| 2 | SSRF | Fehler, OOB |
| 1 | Path Traversal | Datei-Lesen |
| 2 | NoSQL | Mathe, Fehler |
| 1 | EL-Injektion | Mathe |
| 1 | Prototype Pollution | Mathe |
| 1 | CRLF/Header | Mathe |
| 1 | Format String | Fehler |
| 1 | SSI | Mathe |
| 2 | LDAP-Injektion | Fehler, Mathe |
| 3 | XSLT-Injektion | Fehler, Mathe, OOB |
| 2 | Elasticsearch | Fehler, Mathe |
| 2 | Cypher/Neo4j | Fehler, Timing |
| 1 | CouchDB | Fehler |
| 3 | Groovy | Mathe, Timing, OOB |
| 41 | Deserialisierung | Multi-Säule wo unterstützt, sonst nur Fehler |
TzoYToid=42 und JSESSIONID“ zu „versuchen Sie by-category/sqli.txt + Java-Deserialisierung + EL-Injektion, achten Sie auf Mathe-Säule“ in einer Suche.| Säule | Payloads | Worauf achten | Verwenden, wenn |
|---|
| Fehler | 324 | Ausnahmetext, Stacktrace, Parserfehler in der Antwort | App gibt Fehler zurück |
| Timing | 227 | Antwort dauert >4,5 Sekunden | Blind – keine Ausgabe, keine Fehler |
| OOB | 209 | Ausgehendes HTTP/DNS/LDAP/TCP zu Ihrem Callback-Server | Blind + asynchron – Timing unzuverlässig |
| Mathe | 182 | 1337 wörtlich im Antworttext (Server berechnete 7*191) | Ausgabe wird reflektiert, aber keine Fehler |
| Reflektiert | 374 | Eingabewert wird in der Antwort zurückgegeben | Fuzzing auf Parser-Anomalien |
| Datei-Lesen | (Teilmenge) | root: oder [extensions]-Inhalt in der Antwort | Path Traversal, XXE Datei-Lesen |
| Kategorie | Anzahl | Säulen | Abdeckung |
|---|
| SQLi | 211 | error, math, timing, oob | MySQL, PostgreSQL, Oracle, MSSQL, SQLite, CockroachDB. UNION, error, timing, OOB. Kontextausbrüche: ', ", ), )), */, numerisch. |
| 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. Alle verwenden Sprach-Built-ins. |
| Deserialisierung | 232 | error, math, timing, oob | 31 Frameworks / 7 Sprachen. Alle spracheigenen Payloads verwenden Built-ins (keine Shell-Befehle). 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-Befehlseinschleusung | 120 | error, math, timing, oob | Bash, CMD, PowerShell. Ausbrüche: ;, |, ||, &&, $(), Backticks. IFS-Bypass, Glob-Bypass, Hex-Kodierung. |
| Code-Injection | 123 | error, math, timing, oob | Python, Node, PHP, Ruby, Perl, Lua, Java ScriptEngine, Groovy. Import-freie CPU-Spin, Socket-Level-OOB. |
| SSRF | 156 | error, math, timing, oob | Cloud-Metadaten (AWS/GCP/Azure), IP-Bypass, Protokoll-Schemata, DNS-Rebinding, interne Service-Probes. |
| Path Traversal | 113 | error, math, timing, oob | Linux + Windows, Kodierungs-Bypass, Nullbyte, PHP-Wrapper, UNC, NTFS ADS, 8.3-Kurznamen. |
| XSS | 58 | error, math, oob | Kontextübergreifende Polyglots (20+ Kontexte), Event-Handler, Filterumgehung, DOM-Clobbering, Mutations-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 | MongoDB-Operator-Injection, $where-Timing, OOB, Redis-Befehle. |
| 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, Header-Injection, OOB via Host-Header. |
| Prototype Pollution | 12 | error, math | __proto__, constructor.prototype, JSON- und Query-String-Varianten. |
| XXE | 11 | error, timing, oob, file-read | Externe Entitäten, XInclude, Parameter-Entitäten, Billion Laughs DoS. |
| LDAP-Injection | 35 | error, math, timing, oob | Filter-Injection, Auth-Bypass, Wildcard-Timing, Referral-OOB. |
| Elasticsearch | 30 | error, math, timing, oob | Painless-Script-Injection, Query-DSL, query_string-Syntax. |
| Cypher/Neo4j | 27 | error, math, timing, oob | Cypher-Query-Injection, APOC-Sleep, LOAD CSV OOB. |
| CouchDB | 5 | error, math | Mango-Query-Injection, Operator-Injection, Auth-Bypass. |
| XSLT-Injection | 30 | error, math, oob, file-read | XPath-Mathe, document()-SSRF, Datei-Lesen, system-property()-Info-Leak. |
| Polyglots/Grenzfälle | 246 | error, math, timing, oob | Kontextübergreifende Polyglots + Pufferüberlauf, Integer-Grenze, Typkonfusion, Nullbyte. |
| Kodierung | Anwendungsfall |
|---|
| URL-kodiert | Standard-Query-/Formularparameter |
| Doppelt URL-kodiert | WAF-Bypass, Double-Decode-Schwachstellen |
| Base64 | API-Bodies, JWT, serialisierte Parameter |
| JSON-sicher | JSON-Anfragekörper (escaped Anführungszeichen) |
| HTML-Entität | HTML-Attribut-Injection |
| Hex-escaped | Binärprotokolle, Low-Level-Injection |
| Unicode-escaped | Unicode-Normalisierungs-Bypass |
| Sprache | OOB-Built-in | Timing-Built-in |
|---|
| Python | urllib.request.urlopen() | time.sleep(5) |
| Java | java.net.URL.openStream() | Thread.sleep(5000) |
| Node | require('http').get() | Date.now()-Busy-Wait-Schleife |
| 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) |
Shell-Befehle (curl, nslookup) sind abhängig vom Betriebssystem und PATH. Built-ins funktionieren überall.
Import-frei wo möglich. CPU-Spin-Timing funktioniert auch, wenn Imports blockiert sind:
sum(range(500000000)) (~7s, no imports)Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0,5000) (precise 5s)99999999.times{1+1}Socket-Level-OOB als Fallback. Wenn HTTP-Bibliotheken blockiert sind: __import__('socket').create_connection(), fsockopen(), TCPSocket.new(), new java.net.Socket().
./tools/payloadctl validate