Shopping cart

Subtotal $0.00

View cartCheckout

Building better devs

TnewsTnews
Segurança

Nginx2Root: 2 Falhas Críticas Dão RCE no Seu Servidor

Email : 11

Seu Nginx está exposto há 10 anos (e você nem desconfiava)

No dia 18 de novembro de 2026, cinco equipes de segurança diferentes publicaram, ao mesmo tempo, duas vulnerabilidades críticas no Nginx que permitem execução remota de código sem autenticação. Leu certo: qualquer pessoa na internet pode rodar código no seu servidor Nginx, sem precisar de login, sem precisar de credencial. Basta uma conexão HTTP/2.

O nome que a comunidade deu ao ataque? Nginx2Root. E o pior: uma das falhas existe desde 2015.

Eu trabalho com infraestrutura há anos e posso dizer com tranquilidade que essa é uma das piores vulnerabilidades que já vi em software de proxy reverso. O Nginx está em todo lugar: CDNs, load balancers, API gateways, Kubernetes ingress controllers. Se você tem um servidor web, a chance de estar rodando Nginx é altíssima.

Vamos direto ao ponto técnico.

As duas CVEs que quebraram a internet

São duas vulnerabilidades distintas, mas ambas exploram o módulo HTTP/2 do Nginx:

CVE Tipo CVSS 4.0 Versões afetadas Desde quando
—– —— ———– ——————- ————–
CVE-2026-123633 Use-After-Free 9.2 Nginx OSS 1.19.7+ e Nginx Plus R33, 37.0.0+ 2021
CVE-2026-123007 Integer Underflow 9.2 Nginx OSS 1.9.5+ e Nginx Plus R33, 37.0.0+ 2015

As duas receberam nota 9.2 no CVSS 4.0. Para contextualizar, o Log4Shell (aquele que derrubou meio mundo em 2021) tinha nota 10.0. Estamos falando de quase o mesmo nível de severidade.

A CVE-2026-123007 é a mais assustadora. Qualquer release oficial do Nginx desde a versão 1.9.5 (lançada em 2015) com HTTP/2 habilitado está vulnerável. São mais de dez anos de exposição silenciosa.

Quem descobriu (e por que ao mesmo tempo)

Aqui tem um detalhe curioso. Cinco equipes independentes descobriram essas falhas quase simultaneamente: Wiz Research, Ikotas Labs, Metnir, Rapid7 e Xint. Nenhuma sabia da outra.

O que explica essa coincidência? Ferramentas de IA. Os pesquisadores usaram Gemini 4 Carbon e ChatGPT 5.6 Sol para análise automatizada de código. Basicamente, a mesma geração de modelos de linguagem encontrou o mesmo bug no mesmo código ao mesmo tempo, em laboratórios diferentes ao redor do mundo.

Isso levanta uma pergunta incômoda: se pesquisadores de segurança estão usando IA para achar vulnerabilidades, atacantes também estão. A corrida agora é quem encontra primeiro.

CVE-2026-123007: o Integer Underflow que dá RCE

Essa é a falha principal, então vou explicar com calma como ela funciona. Precisa entender um pouco de HTTP/2 flow control.

Como funciona o controle de fluxo no HTTP/2

O HTTP/2 usa um sistema de créditos para controlar quantos dados o servidor pode enviar ao cliente. Funciona com dois contadores:

  • Connection-level credit: total de bytes que o servidor pode enviar na conexão inteira
  • Stream-level credit: limite por stream individual

O protocolo define um teto máximo de 2^31 – 1 bytes (cerca de 2 GB) para esses contadores. O problema é que o Nginx armazena o contador de conexão como size_t (unsigned 64-bit), que pode ultrapassar esse limite sem que ninguém perceba.

A cadeia de exploração em 4 estágios

Estágio 1: Acumular crédito em excesso

O atacante abre uma conexão HTTP/2, faz requisições que geram respostas grandes e reduz a velocidade de leitura para manter os frames DATA enfileirados. Depois envia um WINDOW_UPDATE elevando o crédito da conexão ao máximo. Quando o stream fecha e a limpeza acontece, o Nginx restaura o crédito sem validação:


h2c->send_window += window; // Sem validação contra o máximo

Resultado: o crédito interno ultrapassa o limite do protocolo.

Estágio 2: Forçar fechamento de stream via SETTINGS

O atacante envia um frame SETTINGS_INITIAL_WINDOW_SIZE que aumentaria o crédito do stream além do máximo permitido. O Nginx encerra o stream, mas (contrariando a RFC 9113) mantém a conexão HTTP/2 ativa, em vez de emitir um erro de conexão.

Estágio 3: O underflow propriamente dito

Quando um novo WINDOW_UPDATE chega, a validação de limite faz uma subtração com unsigned integer:


if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) // Underflow aqui

Como h2c->send_window já está acima do máximo, a subtração de um unsigned resulta em wraparound para 2^64 – R (um número gigantesco). A validação passa, e o crédito fica essencialmente sem limite.

Estágio 4: Conversão de tipo e corrupção de memória

O contador absurdamente grande é convertido para off_t (signed):


limit = h2c->send_window; // Unsigned enorme vira negativo em signed

Isso produz um buffer inválido onde o ponteiro last fica antes de pos. Quando o memcpy subsequente tenta copiar dados usando esse tamanho, o resultado é acesso fora dos limites do buffer. O heap é corrompido, e daqui para frente é engenharia de exploit clássica: sobrescrever ponteiros de função e redirecionar a execução.

Quanto tráfego precisa para explorar?

Aqui vem a parte que pode dar uma falsa sensação de segurança. O exploit do Rapid7 precisa de aproximadamente 128 GB de dados HTTP/2 para acionar o RCE. No setup de teste deles, isso levou cerca de dois minutos e meio.

Parece muito? Não quando você lembra que a conexão HTTP/2 padrão no Nginx tem timeout de uma hora. Em uma rede de 300 Mbit/s ou mais (qualquer datacenter moderno), o ataque é perfeitamente viável.

Outro detalhe técnico importante: o caminho de RCE confirmado depende de uma implementação específica do memcpy na glibc para x86-64 que usa instruções AVX-512. Isso significa que o exploit funciona em servidores modernos com processadores Intel ou AMD recentes, que é exatamente onde o Nginx roda em produção.

CVE-2026-123633: Use-After-Free no ciclo de vida da conexão

A segunda CVE é um clássico use-after-free. O bug está no gerenciamento do ciclo de vida das conexões HTTP/2.

O Nginx mantém uma lista de conexões “reutilizáveis” (conexões ociosas que podem ser fechadas se o worker precisar de slots). Quando uma conexão HTTP/2 não tem requisições ativas, ela entra nessa lista. Quando uma nova requisição chega, ela deveria sair.

O problema: a função ngx_http_v2_create_stream() cria o stream de requisição mas esquece de remover a conexão da lista de reutilizáveis. Isso significa que o Nginx pode decidir fechar essa conexão (porque acha que está ociosa) enquanto ela ainda está processando uma requisição.

A memória da conexão é liberada, mas o código do stream continua referenciando ela. Use-after-free clássico. Se um atacante conseguir que o Nginx aloque outro objeto naquele mesmo espaço de memória, ele controla a execução.

Essa falha é mais fácil de acionar quando o Nginx está operando como proxy reverso e o worker está com poucos slots de conexão disponíveis, o que é exatamente o cenário de produção sob carga.

Proof of Concept público: o relógio está correndo

Stephen Fewer, pesquisador da Rapid7, publicou no GitHub um crash trigger e uma cadeia completa de RCE. O exploit demonstra execução de código arbitrário em um container Docker com Nginx 1.31.8, TLS e HTTP/2 habilitados.

Ponto importante: o código roda com as permissões do worker process do Nginx, não do master. Em muitas configurações, o worker roda como www-data ou nginx, que não é root. Mas se o seu Nginx está mal configurado (rodando como root, ou com capabilities demais), o impacto é total.

E mesmo sem root, um atacante no worker process consegue:

  • Ler arquivos de configuração (incluindo certificados TLS e chaves privadas)
  • Interceptar todo o tráfego que passa pelo proxy
  • Pivotar para a rede interna
  • Exfiltrar dados sensíveis

Quem está vulnerável?

A pergunta mais curta: quem não está vulnerável?

Se você tem Nginx com HTTP/2 habilitado (e quem não tem em 2026?), você está vulnerável. Isso inclui:

  • Servidores web diretos com http2 on; ou listen 443 ssl http2;
  • Kubernetes Ingress Controllers baseados em Nginx (o ingress-nginx é um dos mais populares)
  • Load balancers e reverse proxies em frente a aplicações
  • CDNs e WAFs que usam Nginx internamente
  • Containers Docker com imagens oficiais do Nginx

Para verificar se o seu Nginx está vulnerável, rode:


nginx -v
# Se a versão for menor que 1.30.7 (stable) ou 1.31.9 (mainline), está vulnerável

# Verifique se HTTP/2 está habilitado
grep -r "http2" /etc/nginx/
# Procure por "http2 on;" ou "listen ... http2"

Como corrigir agora

Opção 1: Atualizar (recomendado)

Atualize para as versões corrigidas:

Produto Versão corrigida
——— —————–
Nginx OSS (stable) 1.30.7
Nginx OSS (mainline) 1.31.9
Nginx Plus 37.0.7.1 ou 37.2.0.1

No Ubuntu/Debian:


sudo apt update && sudo apt upgrade nginx
nginx -v  # Confirme a versão
sudo systemctl reload nginx

No Alpine (containers Docker):


FROM nginx:1.31.9-alpine
# Rebuilde seus containers com a imagem atualizada

Opção 2: Desabilitar HTTP/2 (mitigação imediata)

Se você não pode atualizar agora, desabilite o HTTP/2 imediatamente:


server {
    listen 443 ssl;
    # Remova "http2" da diretiva listen
    # Ou adicione explicitamente:
    http2 off;

    # ... resto da configuração
}

Depois recarregue:


sudo nginx -t && sudo nginx -s reload

Sim, você perde HTTP/2 (multiplexing, server push, header compression). Mas entre perder performance e perder o servidor, a escolha é óbvia.

Opção 3: Verificar Kubernetes Ingress

Se você usa ingress-nginx no Kubernetes, verifique a versão da imagem:


kubectl get deployment -n ingress-nginx ingress-nginx-controller \
  -o jsonpath='{.spec.template.spec.containers[0].image}'

Atualize o Helm chart ou a imagem do container para uma versão que inclua o Nginx corrigido.

O que a comunidade está dizendo

A reação no Hacker News foi previsível: pânico controlado. Com 669 pontos e subindo, é uma das stories mais comentadas do mês.

Alguns pontos que surgiram na discussão:

  1. “Por que o Nginx usa unsigned para um valor que tem máximo signed?” A resposta é dívida técnica. O código HTTP/2 do Nginx foi escrito quando o protocolo ainda estava sendo finalizado, e ninguém revisou as suposições de tipo.
  1. “IA achando bugs em paralelo é o novo normal.” Cinco equipes usando IA encontraram o mesmo bug. A barreira de entrada para pesquisa de vulnerabilidades caiu drasticamente.
  1. “128 GB de tráfego não é prático.” Isso é ingenuidade. Em um datacenter com link de 10 Gbps, são 100 segundos. E o timeout padrão do Nginx é de uma hora.

Timeline completa

Data Evento
—— ——–
21 de outubro de 2026 Wiz reporta CVE-2026-123633 para a F5
10 de novembro de 2026 F5 disponibiliza patch
16 de novembro de 2026 Segunda vulnerabilidade (CVE-2026-123007) reportada
18 de novembro de 2026 Disclosure coordenado e release de segurança da F5
18 de novembro de 2026 Rapid7 publica PoC no GitHub

A F5 respondeu em tempo razoável, menos de um mês entre o report e o patch para a primeira CVE. Mas a janela entre o patch estar disponível e as pessoas aplicarem é onde mora o perigo.

Como detectar se você já foi comprometido

Antes de só atualizar e seguir a vida, vale checar se alguém já explorou essa falha no seu ambiente. Algumas coisas para investigar:


# Procure por crashes recentes do worker (sinal de tentativa de exploit)
grep -i "worker process" /var/log/nginx/error.log | grep -i "signal\|exit\|abort"

# Verifique conexões HTTP/2 com volume anormal de dados
# (o exploit precisa de ~128 GB, isso aparece nos access logs)
awk '$10 > 1000000000' /var/log/nginx/access.log

# Procure processos estranhos rodando como usuário nginx/www-data
ps aux | grep -E "^(nginx|www-data)" | grep -v "nginx:"

Se você encontrar crashes frequentes do worker process sem explicação óbvia, especialmente em servidores com HTTP/2 habilitado, trate como potencial comprometimento. Faça análise forense antes de simplesmente reiniciar.

Outro indicador: conexões HTTP/2 de longa duração vindas de IPs suspeitos. O exploit precisa manter a conexão aberta por alguns minutos, então conexões de 2 a 5 minutos com alto volume de dados transferidos merecem investigação.

Lições que ninguém quer ouvir

Primeira: HTTP/2 adicionou complexidade absurda ao stack web. O HTTP/1.1 tinha vulnerabilidades, claro, mas o modelo de flow control do HTTP/2 com seus múltiplos contadores, frames de controle e interações entre streams criou uma superfície de ataque que a maioria dos desenvolvedores nem entende.

Segunda: código C de dez anos precisa de auditoria contínua. O Nginx é um dos projetos open source mais usados do mundo, e esse bug ficou escondido por uma década. Quantos outros estão esperando para serem encontrados?

Terceira: a corrida entre atacantes e defensores agora é automatizada. Se IA encontra bugs em código fonte público em horas, o tempo entre disclosure e exploração in the wild vai encolher cada vez mais. Atualizar “na próxima sprint” não é mais aceitável.

Se você ainda não atualizou seu Nginx, pare de ler e vá fazer isso agora. Sério.


Fonte de inspiração: Unauthenticated Remote Code Execution in NGINX (Wiz Research)

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts