CVE-2026-42926 Laboratório de Injeção de Quadros HTTP/2 NGINX

Um laboratório de cibersegurança controlado para validar e comparar comportamentos relacionados a CVE-2026-42926, um problema de injeção de quadros HTTP/2 que afeta versões específicas do NGINX quando uma configuração de proxy vulnerável é usada.

Este repositório é destinado apenas para pesquisa defensiva, validação de patches, auditoria de configuração e reprodução controlada em laboratório.

Classificação: Injeção de quadros HTTP/2 Versões afetadas: NGINX 1.29.4 até 1.30.0 Versões corrigidas: NGINX 1.30.1+ / 1.31.0+

Aviso de Segurança

Use este projeto apenas em um ambiente de laboratório isolado que você possua ou tenha autorização explícita para testar.

Não execute isto contra sistemas de terceiros, infraestrutura pública, ambientes compartilhados ou serviços de produção sem autorização por escrito.

Isolamento recomendado:

• VM local
• Container descartável
• Host de teste privado
• Rede de laboratório não roteável

O Que Este Laboratório Faz

O laboratório verifica se um binário NGINX alvo e sua configuração correspondem às condições necessárias para reproduzir o problema, envia uma requisição maliciosa para o local de teste e inspeciona um logger upstream controlado em busca de evidências de que bytes injetados semelhantes a quadros HTTP/2 alcançaram o lado upstream.

O padrão de validação normal é:

1. Executar a mesma configuração de proxy vulnerável com uma compilação NGINX vulnerável.
2. Executar a mesma configuração de proxy vulnerável com uma compilação NGINX corrigida.
3. Comparar as evidências upstream e os veredictos dos scripts.

Resultado esperado:

• Compilação vulnerável: evidência de injeção pode ser observada.
• Compilação corrigida: nenhuma evidência de injeção deve ser observada.

Conteúdo do Repositório

Requisitos

• Ambiente de shell Linux ou macOS
• bash
• python3
• php
• Extensão PHP cURL
• Binários NGINX de teste para as versões que você deseja comparar
• Permissão para vincular a porta de escuta NGINX configurada

Para o fluxo de trabalho conteinerizado:

• Docker
• Docker Compose v2

A configuração de exemplo escuta na porta 80, que geralmente requer privilégios de root. Para um laboratório local sem privilégios, altere listen 80; em nginx_vulnerable.conf para uma porta alta disponível, como 8080, e use a URL alvo correspondente no comando PHP.

Configuração

Torne os scripts shell executáveis:

chmod +x nginx_config_verify.sh run_lab_comparison.sh

Confirme que o PHP tem suporte a cURL:

php -m | grep -i curl

Confirme que cada binário NGINX pode imprimir sua versão:

/path/to/nginx -V

Configuração do Laboratório

O arquivo nginx_vulnerable.conf fornecido contém o padrão de teste necessário:

location /exploit {
    proxy_pass http://127.0.0.1:8081;
    proxy_http_version 2;
    proxy_set_body $request_body;
    proxy_set_header Host $host;
    proxy_set_header Content-Length $content_length;
}

Detalhes importantes:

• proxy_http_version 2 habilita o proxy HTTP/2 para o logger upstream.
• proxy_set_body $request_body usa um corpo de requisição controlado pelo cliente.
• client_max_body_size 20m permite o corpo de requisição malicioso de 16 MiB usado pelo script de validação.
• O logger upstream escuta em 127.0.0.1:8081 por padrão.

A configuração específica do Docker em docker/nginx_vulnerable.docker.conf mantém o mesmo padrão de proxy vulnerável, mas escuta na porta 8080 do container e faz proxy para o nome do serviço Compose upstream:8081.

Início Rápido com Docker: Laboratório NGINX 1.29.4

O Dockerfile compila o NGINX 1.29.4 a partir do código fonte e instala as ferramentas PHP/Python necessárias para o laboratório. O Compose então executa três serviços a partir da mesma imagem:

• upstream: logger bruto de quadros HTTP/2
• nginx: NGINX vulnerável 1.29.4 usando docker/nginx_vulnerable.docker.conf
• runner: comando de validação PHP de execução única

Construa a imagem do laboratório:

docker compose build

Inicie o logger upstream e o NGINX vulnerável:

docker compose up -d upstream nginx

Confirme a versão do NGINX incluído:

docker compose exec nginx nginx -V

Execute o script de validação dentro da rede do Compose:

docker compose --profile run run --rm runner

O runner usa estes argumentos dentro do container:

php /lab/cve_2026_42926_lab.php \
  http://nginx:8080/exploit \
  /lab/upstream_logs \
  /lab/nginx_config_verify.sh \
  /usr/local/nginx/sbin/nginx \
  /lab/docker/nginx_vulnerable.docker.conf \
  /exploit

Os logs upstream gerados são escritos no diretório do host:

./upstream_logs/

O serviço NGINX também é exposto ao host em:

http://localhost:8080/version

Pare e remova os containers do laboratório:

docker compose down

Início Rápido: Execução de Validação Única

Inicie o logger upstream controlado:

python3 upstream_frame_logger.py 8081 ./upstream_logs

Em outro terminal, inicie o NGINX com a configuração de exemplo:

/path/to/nginx -c "$PWD/nginx_vulnerable.conf"

Execute o script de validação:

php cve_2026_42926_lab.php \
  http://localhost/exploit \
  ./upstream_logs \
  ./nginx_config_verify.sh \
  /path/to/nginx \
  "$PWD/nginx_vulnerable.conf" \
  /exploit

Pare o NGINX após a execução:

/path/to/nginx -s stop

Se você alterou o NGINX para escutar em outra porta, atualize o primeiro argumento. Por exemplo:

php cve_2026_42926_lab.php http://localhost:8080/exploit ./upstream_logs ./nginx_config_verify.sh /path/to/nginx "$PWD/nginx_vulnerable.conf" /exploit

Início Rápido: Comparação entre Versão Vulnerável e Corrigida

Defina os caminhos para os dois binários NGINX e execute o harness de comparação:

VULNERABLE_NGINX=/usr/local/nginx_1.29.4/sbin/nginx \
PATCHED_NGINX=/usr/local/nginx_1.30.1/sbin/nginx \
bash run_lab_comparison.sh

Substituições de configuração opcionais:

VULNERABLE_NGINX=/path/to/vulnerable/nginx \
PATCHED_NGINX=/path/to/patched/nginx \
VULNERABLE_CONFIG="$PWD/nginx_vulnerable.conf" \
PATCHED_CONFIG="$PWD/nginx_vulnerable.conf" \
bash run_lab_comparison.sh

O script de comparação escreve:

• vulnerable_result.txt
• patched_result.txt
• upstream_logs_vulnerable/
• upstream_logs_patched/

Verificação Manual de Configuração

Use nginx_config_verify.sh diretamente quando quiser apenas inspecionar se uma configuração contém o padrão vulnerável:

./nginx_config_verify.sh /path/to/nginx "$PWD/nginx_vulnerable.conf" /exploit

O auxiliar verifica:

• proxy_http_version 2
• proxy_set_body com uma variável
• client_max_body_size de pelo menos 16 MiB

Argumentos do Script

cve_2026_42926_lab.php aceita argumentos posicionais:

php cve_2026_42926_lab.php <target_url> <upstream_log_dir> <config_script> <nginx_binary> <nginx_config> <location> [version_url]

Padrões:

Veredictos e Códigos de Saída

cve_2026_42926_lab.php retorna um de três veredictos:

Evidência positiva exige que o script correlacione o marcador de execução, o cabeçalho de quadro upstream observado, a flag de quadro injetado e a versão NGINX afetada.

Artefatos de Saída

O logger upstream escreve arquivos JSON nomeados como:

frames_<timestamp>.json

Cada log contém metadados de quadros HTTP/2 analisados, excertos de payload, deslocamentos de bytes, flags de detecção de injeção e campos de correlação de execução.

O harness de comparação armazena diretórios de log separados para execuções vulneráveis e corrigidas, para que as evidências das duas execuções não se misturem.

Solução de Problemas

Se o script PHP relatar que o auxiliar de configuração não é executável, execute:

chmod +x nginx_config_verify.sh

Se a requisição retornar 413 Request Entity Too Large, aumente client_max_body_size para pelo menos 16m; a configuração de exemplo usa 20m.

Se nenhum log upstream for criado, verifique se:

• upstream_frame_logger.py está em execução.
• O NGINX está fazendo proxy para 127.0.0.1:8081.
• A URL alvo aponta para o listener NGINX configurado.
• A requisição alcançou o local /exploit.

Se o NGINX falhar ao vincular à porta 80, execute-o com privilégios apropriados em um ambiente de laboratório ou altere a configuração para uma porta alta como 8080.

Se o resultado da comparação for inconclusivo, inspecione vulnerable_result.txt, patched_result.txt e os diretórios de log upstream correspondentes para a pré-condição que falhou.

Licença

Este projeto é licenciado sob a Licença MIT. Consulte LICENSE para obter detalhes.