Dos PoC en Python para RCE mediante el progreso de carga de sesiones de PHP: ejecución de código mediante LFI de archivos de sesión e inyección de objetos del serializador php_binary a php, con scripts de configuración del laboratorio.
https://github.com/user-attachments/assets/7d25d259-ec00-4e3a-810c-09098f0afb5f
https://github.com/user-attachments/assets/00a0d3e7-bd78-4bdb-992f-0110fc580746
Este repositorio contiene dos PoC de laboratorio para el progreso de carga de sesión de PHP. El manejador de progreso de carga escribe un campo controlado por el atacante en el archivo de sesión antes de que se ejecute el código de la aplicación:
poc.py): el manejador almacena un nombre de archivo o un valor de progreso
que contiene código PHP. Si un LFI autorizado incluye el archivo de sesión,
ese código se ejecuta.poc-php-binary.py): el registro de progreso se escribe
con php_binary, luego la aplicación cambia al serializador php y
llama a session_start(). El decodificador php deserializa el valor de progreso
del atacante, demostrando una primitiva de inyección de objetos sin ningún LFI.Utilícelos únicamente contra sistemas de su propiedad o para los que tenga autorización explícita para probar.
El endpoint ?file= generado es intencionalmente inseguro y debe permanecer en un laboratorio.
| Archivo | Propósito |
|---|---|
poc.py | PoC de carga multipart con inyección --filename / --progress / --field-name y sondeo LFI opcional |
poc-php-binary.py | PoC de serialización php_binary -> php sin LFI |
setup.sh | Despliega el laboratorio de LFI de archivo de sesión en el puerto 80 (instala Apache/PHP si faltan) |
setup-php-binary.sh | El mismo script que setup.sh; solo difiere en el index.php desplegado y en el alcance de session.serialize_handler=php_binary |
poc.mp4 | Demostración: LFI de archivo de sesión |
poc-php-binary.mp4 | Demostración: cambio de serializador php_binary |
setup.sh detecta la distribución, instala el servidor web y los paquetes de PHP
si faltan, limpia /var/www/html, escribe solo index.php y
recarga el servidor web. Ejecútelo como un usuario con permisos de sudo; el script llama
a sudo por sí mismo, por lo que no es necesario prefijar toda la invocación:
bash setup.sh
Cuando termina, imprime [+] Deployed: /var/www/html/index.php y la URL
para probar.
Instala httpd, php y php-fpm. Debido a que mod_php ya no está empaquetado
allí, el script también escribe /etc/httpd/conf.d/php.conf para enrutar las solicitudes
.php al socket de php-fpm, y luego inicia php-fpm y httpd. La página se
sirve en el puerto normal de Apache:
http://<host>/index.php
Instala apache2, php y libapache2-mod-php (mod_php), y habilita
el módulo PHP si aún no está cargado. La página se sirve en el puerto
normal de Apache:
http://<host>/index.php
La configuración no establece valores PHP INI relacionados con la sesión. Utiliza la configuración PHP del sistema.
La página generada:
<?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";
}
Compruébalo:
curl http://192.168.122.170/index.php
# hello, world
setup.sh borra /var/www/html; no lo ejecutes en un host con un sitio real
allí.
poc.pyEl PoC solicita confirmación antes de enviar. --duration es el número de
fragmentos de carga de un segundo; el valor predeterminado es 45. Elige exactamente un modo
de inyección:
--filename coloca el payload PHP en el nombre de archivo multipart.--progress lo coloca en el valor de PHP_SESSION_UPLOAD_PROGRESS (el payload
no puede contener |).--field-name lo coloca en el nombre de campo de la parte del archivo, que el handler
almacena sin procesar en files[].field_name (ext/session/session.c:3321) sin
filtrado de entrada. El payload no puede contener ", [ ni ] (el analizador
multipart lee el nombre de campo hasta la comilla de cierre y rechaza los corchetes
desbalanceados).--lfi requiere uno de --fedora, --ubuntu o --tmp para que el PoC consulte
el archivo de sesión de la plataforma correcta. En Ubuntu:
python3 poc.py \
--remote 'http://192.168.122.170/index.php' \
--filename \
--lfi 'http://192.168.122.170/index.php?file={file}' \
--ubuntu
En 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
El PoC espera ocho segundos y luego consulta el LFI una vez por segundo mientras la
carga sigue en ejecución. Se detiene en cuanto ve la salida del payload ejecutado
(RCE <version>), aborta la carga restante y sale con 0. Si la carga termina
sin coincidencia, sale con 1. Las duraciones inferiores a 20 segundos se elevan a 20 cuando
la consulta periódica está habilitada, porque PHP necesita aproximadamente diez segundos para escribir la
entrada de progreso.
Sin --lfi, los flags de plataforma son opcionales; el PoC solo envía la carga
y puedes inspeccionar el archivo de sesión manualmente.
El flag de plataforma selecciona el archivo a vigilar:
--fedora /var/lib/php/session/sess_pwnd00000000000001
--ubuntu /var/lib/php/sessions/sess_pwnd00000000000001
--tmp /tmp/sess_pwnd00000000000001
php_binary -> phpsetup-php-binary.sh es el mismo script que setup.sh — los dos archivos son
idénticos byte a byte excepto por un bloque lab-specific configuration (el index.php
que se despliega y el serializador bajo el que se ejecuta el laboratorio). Instala paquetes
si es necesario, limpia /var/www/html, escribe su index.php y recarga Apache,
y además limita session.serialize_handler=php_binary al laboratorio:
Fedora/RHEL usan un pool de php-fpm dedicado conectado mediante /etc/httpd/conf.d/php.conf;
Ubuntu/Debian usan un php_value en un fragmento de configuración de Apache. Volver a ejecutar setup.sh
elimina esa limitación y restaura el laboratorio LFI original, de modo que los dos scripts alternan
el laboratorio compartido /var/www/html de un lado a otro.
bash setup-php-binary.sh
El endpoint comienza con session.serialize_handler=php_binary, cambia a
php en tiempo de ejecución y llama a 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'
El script es solo de serialización; no hay modo LFI. Envía el valor de progreso
x|O:6:"Gadget":0:{} (o la clase nombrada por --gadget) más una parte de archivo
normal. --duration es 45 por defecto y se eleva a al menos 20. Tras ocho
segundos consulta la misma URL con el mismo PHPSESSID cada segundo, imprime
cada respuesta y sale con 0 en cuanto aparece SERIALIZED_WAKEUP o
SERIALIZED_DESTRUCT. Si la subida termina sin coincidencia, sale con 1.
El prefijo x| proporciona el delimitador que php_binary no escribe, de modo que el
decodificador php ve el objeto serializado como el valor de progreso.