
Due PoC Python per l'RCE tramite progress di upload delle sessioni PHP: esecuzione di codice tramite LFI sul file di sessione e object injection dal serializzatore php_binary a php, con script per l'allestimento del laboratorio.
https://github.com/user-attachments/assets/7d25d259-ec00-4e3a-810c-09098f0afb5f
https://github.com/user-attachments/assets/00a0d3e7-bd78-4bdb-992f-0110fc580746
Questo repository contiene due PoC da laboratorio per il progress di upload delle sessioni PHP. Il gestore del progress di upload scrive un campo controllato dall'attaccante nel file di sessione prima che venga eseguito il codice dell'applicazione:
poc.py): il gestore memorizza un nome file o un valore di progress
contenente codice PHP. Se una LFI autorizzata include il file di sessione,
quel codice viene eseguito.poc-php-binary.py): il record di progress viene scritto
con php_binary, poi l'applicazione passa al serializzatore php e
chiama session_start(). Il decoder php deserializza il valore di progress
dell'attaccante, dimostrando una primitiva di object-injection senza alcuna LFI.Usa questi strumenti solo contro sistemi di tua proprietà o per i quali sei esplicitamente autorizzato a eseguire test.
L'endpoint ?file= generato è intenzionalmente non sicuro e deve rimanere in un laboratorio.
| File | Scopo |
|---|---|
poc.py | PoC di upload multipart con injection --filename / --progress / --field-name e polling LFI opzionale |
poc-php-binary.py | PoC di serializzazione php_binary -> php senza LFI |
setup.sh | Distribuisce il laboratorio LFI sul file di sessione sulla porta 80 (installa Apache/PHP se mancanti) |
setup-php-binary.sh | Lo stesso script di setup.sh; differisce solo nel index.php distribuito e nell'ambito di session.serialize_handler=php_binary |
poc.mp4 | Demo: LFI sul file di sessione |
poc-php-binary.mp4 | Demo: cambio di serializzatore php_binary |
setup.sh rileva la distribuzione, installa i pacchetti del web server e di PHP
se mancanti, svuota /var/www/html, scrive solo index.php e
ricarica il web server. Eseguilo come utente con diritti sudo; lo script chiama
sudo da solo, quindi non è necessario anteporre nulla all'intera invocazione:
bash setup.sh
Al termine stampa [+] Deployed: /var/www/html/index.php e l'URL
da testare.
Installa httpd, php e php-fpm. Poiché mod_php non è più pacchettizzato
in questa distribuzione, lo script scrive anche /etc/httpd/conf.d/php.conf per instradare le richieste
.php al socket php-fpm, quindi avvia php-fpm e httpd. La pagina viene
servita sulla normale porta Apache:
http://<host>/index.php
Installa apache2, php e libapache2-mod-php (mod_php), e abilita
il modulo PHP se non è già caricato. La pagina viene servita sulla normale
porta Apache:
http://<host>/index.php
La configurazione non imposta i valori PHP INI relativi alla sessione. Utilizza la configurazione PHP di sistema.
La pagina generata:
<?php
declare(strict_types=1);
if (isset($_GET['file']) && $_GET['file'] !== '') {
header('Content-Type: text/plain; charset=utf-8');
include $_GET['file'];
} else {
echo "hello, world\n";
}
Controllalo:
curl http://192.168.122.170/index.php
# hello, world
setup.sh cancella /var/www/html; non eseguirlo su un host con un sito reale
in quella posizione.
poc.pyIl PoC chiede conferma prima dell'invio. --duration è il numero di
chunk di upload da un secondo; il valore predefinito è 45. Scegli esattamente una modalità
di injection:
--filename inserisce il payload PHP nel nome file multipart.--progress lo inserisce nel valore di PHP_SESSION_UPLOAD_PROGRESS (il payload
non può contenere |).--field-name lo inserisce nel nome del campo della parte file, che l'handler
memorizza così com'è in files[].field_name (ext/session/session.c:3321) senza
filtraggio dell'input. Il payload non può contenere ", [ o ] (il parser
multipart legge il nome del campo fino alla virgoletta di chiusura e rifiuta le
parentesi non bilanciate).--lfi richiede uno tra --fedora, --ubuntu o --tmp affinché il PoC interroghi
il file di sessione per la piattaforma corretta. Su Ubuntu:
python3 poc.py \
--remote 'http://192.168.122.170/index.php' \
--filename \
--lfi 'http://192.168.122.170/index.php?file={file}' \
--ubuntu
Su Fedora / RHEL:
python3 poc.py \
--remote 'http://192.168.122.170/index.php' \
--filename \
--lfi 'http://192.168.122.170/index.php?file={file}' \
--fedora
Il PoC attende otto secondi, poi interroga l'LFI una volta al secondo mentre
l'upload è ancora in corso. Si interrompe non appena vede l'output del payload eseguito
(RCE <version>), annulla l'upload rimanente ed esce con 0. Se l'upload termina
senza una corrispondenza esce con 1. Le durate inferiori a 20 secondi vengono portate a 20 quando
il polling è abilitato, perché PHP impiega circa dieci secondi per scrivere la
voce di avanzamento.
Senza --lfi, i flag della piattaforma sono opzionali; il PoC invia solo l'upload
e puoi ispezionare manualmente il file di sessione.
Il flag della piattaforma seleziona il file da monitorare:
--fedora /var/lib/php/session/sess_pwnd00000000000001
--ubuntu /var/lib/php/sessions/sess_pwnd00000000000001
--tmp /tmp/sess_pwnd00000000000001
php_binary a phpsetup-php-binary.sh è lo stesso script di setup.sh — i due file sono
identici byte per byte tranne che per un blocco lab-specific configuration (il index.php
che viene distribuito e il serializer con cui viene eseguito il lab). Installa i pacchetti
se necessario, cancella /var/www/html, scrive il proprio index.php e ricarica Apache,
e inoltre limita session.serialize_handler=php_binary al lab:
Fedora/RHEL usano un pool php-fpm dedicato collegato tramite /etc/httpd/conf.d/php.conf;
Ubuntu/Debian usano un php_value in uno snippet di configurazione Apache. Rieseguire setup.sh
rimuove tale limitazione e ripristina il lab LFI standard, così i due script fanno passare
avanti e indietro il lab condiviso /var/www/html.
bash setup-php-binary.sh
L'endpoint inizia con session.serialize_handler=php_binary, passa a
php in fase di esecuzione e chiama session_start():
<?php
declare(strict_types=1);
class Gadget {
public function __wakeup() { echo "SERIALIZED_WAKEUP\n"; }
public function __destruct() { echo "SERIALIZED_DESTRUCT\n"; }
}
ini_set('session.serialize_handler', 'php');
session_start();
echo "hello, world\n";
poc-php-binary.pypython3 poc-php-binary.py \
--remote 'http://192.168.122.170/index.php'
Lo script è solo di serializzazione; non esiste una modalità LFI. Invia il valore di progresso
x|O:6:"Gadget":0:{} (o la classe indicata da --gadget) più una normale parte
file. --duration è impostato per default a 45 e viene portato ad almeno 20. Dopo otto
secondi esegue il polling dello stesso URL con lo stesso PHPSESSID ogni secondo, stampa
ogni risposta ed esce con 0 non appena compare SERIALIZED_WAKEUP o
SERIALIZED_DESTRUCT. Se l'upload termina senza una corrispondenza esce con 1.
Il prefisso x| fornisce il delimitatore che php_binary non scrive, così il
decoder php vede l'oggetto serializzato come valore di progresso.