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 é:

Executar a mesma configuração de proxy vulnerável com uma compilação NGINX vulnerável.
Executar a mesma configuração de proxy vulnerável com uma compilação NGINX corrigida.
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

Arquivo	Descrição
`README.md`	Documentação do projeto.
`LICENSE`	Licença MIT.
`Dockerfile`	Cria uma imagem de laboratório autossuficiente com NGINX `1.29.4`, PHP CLI/cURL, Python e os scripts do projeto.
`docker-compose.yml`	Inicia o serviço NGINX vulnerável, o logger de quadros upstream e um executor de validação opcional.
`cve_2026_42926_lab.php`	Script principal de validação do laboratório. Ele verifica pré-condições de versão/configuração, envia a requisição maliciosa, inspeciona logs upstream e retorna um veredicto.
`nginx_vulnerable.conf`	Configuração NGINX de exemplo contendo o padrão de proxy vulnerável usado para execuções de comparação vulnerável e corrigida.
`docker/nginx_vulnerable.docker.conf`	Configuração NGINX específica para Docker usando o mesmo padrão vulnerável e descoberta de serviço do Compose.
`nginx_config_verify.sh`	Auxiliar que verifica se uma configuração NGINX alvo contém o padrão de proxy vulnerável necessário.
`upstream_frame_logger.py`	Logger upstream HTTP/2 bruto controlado usado para capturar e inspecionar quadros recebidos do NGINX.
`run_lab_comparison.sh`	Orquestra execuções de comparação entre versão vulnerável e corrigida.
`.dockerignore`	Mantém logs gerados e metadados de IDE fora do contexto de build do Docker.

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:

CVE2026-42926

Mais Populares