RCE no Nginx HTTP/2: complexidade é a superfície de ataque
As falhas de RCE no HTTP/2 do Nginx mostram onde se escondem os bugs críticos: parsers de protocolos com estado. Veja por quê e o que auditar na sua stack.

O código mais perigoso da internet não é a sua aplicação. É o parser de protocolo com estado, escrito em C, que fica na frente dela e que todo mundo presume estar blindado por anos de batalha. As novas vulnerabilidades de RCE no HTTP/2 do Nginx — CVE-2026-123633 e CVE-2026-123007, ambas não autenticadas e ambas com nota 9.2 — são a prova mais limpa dessa tese que tivemos em anos. Uma delas permitiu que pesquisadores abrissem um shell em um Nginx padrão que servia apenas arquivos estáticos. Sem backend de aplicação, sem módulos de terceiros, sem bug de aplicação. Só Nginx, HTTP/2 e um integer underflow que estava no código desde a versão 1.9.5, lançada em 2015.
Essa é a parte contraintuitiva: gastamos um esforço enorme auditando o nosso próprio código e quase nenhum pensando na porta da frente. Só que é justamente na porta da frente que um bug de corrupção de memória com uma década de idade pode entregar execução de código a um estranho não autenticado, na máquina que termina o seu TLS e enxerga tudo.
Por que o HTTP/2 no Nginx sempre foi uma aposta arriscada
HTTP/1.1 é um protocolo de texto. É simples, verboso, e o modelo de parsing dele se encaixa bem em 'ler bytes até o delimitador, validar, despachar'. Já houve bugs em parsers de HTTP/1 — request smuggling é todo um gênero — mas a máquina de estados é pequena o suficiente para que um engenheiro cuidadoso consiga mantê-la na cabeça.
HTTP/2 é outro bicho. Ele é binário, com frames, multiplexado e tem estado de formas que atravessam toda a conexão. Uma única conexão TCP carrega dezenas de streams concorrentes. O controle de fluxo é rastreado por stream e por conexão, com janelas deslizantes de crédito. Streams podem ser abertos, meio-fechados, resetados e repriorizados em qualquer ordem que o cliente quiser. A compressão de cabeçalhos via HPACK faz o parser manter uma tabela dinâmica compartilhada que muda a cada frame recebido. Cada um desses recursos é um pedaço de estado mutável que precisa continuar consistente diante de entradas adversariais — e o cliente controla essa entrada por completo.
O Nginx herdou toda essa maquinaria de estado quando adicionou seu módulo HTTP/2, e fez isso em C, numa arquitetura orientada a eventos, em que conexões e streams são objetos no heap cujo tempo de vida é gerenciado manualmente. Essa combinação — estado rico e transversal somado a gerenciamento manual de memória — é exatamente onde nascem bugs de use-after-free e de integer underflow. As duas CVEs aqui são quase caricaturas do gênero: uma é um objeto de conexão mantido numa lista de 'seguro para fechar' enquanto uma requisição ainda o está usando; a outra é uma contabilidade de controle de fluxo que dá a volta abaixo de zero e produz uma cópia de memória inválida.
Já argumentei antes, no contexto de a lacuna entre especificação e implementação, que os bugs se concentram onde os invariantes implícitos de uma especificação encontram código que não os impõe. HTTP/2 é um estudo de caso. A RFC 7540 (e agora a 9113) especifica como os fluxos devem ser quando estão bem formados. O espaço perigoso é tudo o que a especificação não proíbe, mas que a implementação nunca testou — frames parciais, transições de estado em ordens esquisitas, janelas manipuladas em valores-limite.
O use-after-free: reutilizável enquanto ocupado
A CVE-2026-123633 é a mais elegante das duas e recompensa uma leitura atenta. O Nginx mantém uma lista de conexões que considera 'reutilizáveis' — seguras para fechar quando precisa de slots para novas conexões. Uma conexão HTTP/2 entra nessa lista quando não tem nenhum stream de requisição ativo. Até aqui, tudo sensato.
A falha está em como a conexão sai da lista — ou melhor, em como ela não sai. Envie apenas parte de um frame HEADERS. O Nginx vê um frame incompleto, marca a conexão como reutilizável e espera. Agora envie o restante do frame. O handler cria um novo stream de requisição e incrementa o contador de processamento da conexão, mas nunca a remove da lista de reutilizáveis. Agora você tem uma conexão que processa simultaneamente uma requisição viva e está marcada como descartável. Se os slots de conexão ficarem escassos, o Nginx vai até essa lista, libera a conexão, e a requisição em andamento passa a apontar para memória já liberada. Use-after-free clássico, alcançável por qualquer cliente não autenticado que consiga falar HTTP/2 com um reverse proxy.
Repare no que é preciso para encontrar isso lendo código: você tem que acompanhar a pertinência de um objeto em uma estrutura de dados através de duas transições de estado diferentes, disparadas por entrada de rede dividida em vários pacotes. Não é um bug que um linter pega. Nem é um bug que a maioria dos fuzzers acha com facilidade, porque exige uma interação específica em duas etapas — frame parcial, espera, frame completo — somada a pressão de memória para disparar o fechamento. É o tipo de coisa que ficou escondida por quase seis anos, apesar de o Nginx ser um dos códigos mais lidos do planeta.
O integer underflow: uma década à vista
A CVE-2026-123007 é mais antiga e, de certa forma, pior. O controle de fluxo do HTTP/2 funciona concedendo a cada stream e a cada conexão uma janela de envio — um saldo de crédito que o remetente decrementa conforme transmite e que o destinatário reabastece com frames WINDOW_UPDATE. Se a contabilidade dessa janela der errado, você pode acabar calculando um tamanho de cópia a partir de um valor que deu a volta, e de repente está fazendo memcpy de ou para memória que não deveria tocar.
Os pesquisadores demonstraram execução remota de código a partir dessa primitiva numa configuração quase padrão — Nginx servindo arquivos estáticos via HTTPS num sistema 64 bits. O ASLR não salvou ninguém, porque as duas vulnerabilidades funcionam também como primitivas de leitura de memória antes de você escalar para execução de código. Você vaza ponteiros, derrota a randomização e então escreve. Isso é artesanato de exploit moderno padrão, mas vale internalizar: mitigações como o ASLR elevam o custo da exploração, não a impedem, e qualquer bug que dê leitura somada a corrupção é, na prática, game over.
O underflow foi lançado no Nginx 1.9.5, em 2015. Onze anos. Nesse período, o código foi revisado por milhares de engenheiros, implantado por milhões de operadores, varrido por todos os analisadores estáticos comerciais do mercado e fuzzado — o Nginx é fuzzado, sim. Sobreviveu a tudo isso. Se isso não recalibra a sua fé em 'open source maduro é seguro porque tem muitos olhos', nada vai recalibrar.

O desconfortável: a IA encontrou o que o fuzzing não encontrou
Aqui está o detalhe que deveria tirar o sono das equipes de segurança. A Wiz encontrou as duas falhas com um arcabouço de varredura de código assistido por IA e depois usou modelos de fronteira para validar a explorabilidade. E eles não estavam sozinhos — a Ikotas Labs, a Metnir, a Rapid7 e a Xint reportaram independentemente as mesmas falhas para a F5 dentro da mesma janela de divulgação. Cinco equipes, dois bugs com uma década de idade, convergindo no mesmo momento.
Isso não é coincidência. É uma mudança de fase. A barreira prática que antes protegia bugs antigos de segurança de memória não era que eles fossem impossíveis de encontrar em princípio — era que rastrear estado por dezenas de caminhos de código custava caro em atenção humana. Modelos agora são bons o bastante exatamente nesse tipo de raciocínio multi-salto, e o custo despencou. Vimos o mesmo padrão recentemente com o Java4Shell, em que 65 bytes viraram RCE — outra falha antiga revelada por ferramentas que seguem interações sutis melhor do que humanos cansados.
Duas implicações decorrem disso, e vou ser direto sobre ambas. Primeiro, toda equipe defensiva agora tem acesso à mesma capacidade de descoberta, então rode isso na sua stack antes que outra pessoa rode. Segundo — e é aqui que eu admito os limites da minha tese inicial — os atacantes também têm essa capacidade, e a janela entre 'o bug se torna encontrável' e 'o bug é explorado' está encolhendo. A discussão no Hacker News trouxe um detalhe incômodo: a correção de uma das CVEs ficou no repositório público por uma semana antes da divulgação, com uma mensagem de commit citando a empresa de segurança que a reportou. Quem analisa commits em busca de correções de segurança — uma técnica conhecida de black hat — largou na frente. Os processos de divulgação coordenada foram projetados para um mundo em que descobertas eram raras. Esse mundo acabou.
Lições para fazer fuzzing de parsers de protocolo
Se você mantém qualquer parser exposto à rede — e muitos de nós mantemos, em proxies, API gateways, service meshes e protocolos customizados — esses bugs funcionam como uma checklist de onde os seus testes provavelmente são fracos.
- Faça fuzzing de sequências, não só de mensagens. As duas CVEs exigem interações em múltiplas etapas: frames parciais, conexões pausadas, atualizações de janela em valores-limite. Um fuzzer que muta frames isolados nunca vai achar um bug que precisa de frame A, uma espera e depois frame B. Use fuzzing com estado ou ciente de gramática, que modele o ciclo de vida da conexão.
- Teste o tempo de vida dos objetos sob pressão de recursos. O UAF só dispara quando o Nginx precisa recuperar slots de conexão. Seus testes devem rodar com limites de recursos artificialmente baixos para que os caminhos de eviction sejam executados.
- Afirme invariantes em cada transição de estado. 'Se o processamento é > 0, a conexão não pode estar na lista de reutilizáveis' é verificável com uma única asserção. Invariantes baratos pegam os bugs que a revisão de código deixa passar.
- Dispare erro em overflow de inteiros em builds de debug. Wrapping com sinal e sem sinal aritmética de controle de fluxo é exatamente o que produziu a CVE-2026-123007. Sanitizers (UBSan) combinados com fuzzing teriam gritado sobre isso anos atrás.
- Compare os commits do seu upstream em busca de correções de segurança silenciosas. Defensores podem jogar o mesmo jogo que os atacantes. Vigiar commits com cara de correção compra dias de vantagem.
E uma observação de processo, aprendida cobrindo divulgação após divulgação: os prazos de divulgação cada vez menores existem porque a lacuna entre o patch e o exploit não para de encolher. Seu processo de resposta — inventário, priorização, rollout em etapas — importa mais do que qualquer correção isolada.
O que fazer com seus deployments de Nginx agora mesmo
A remediação é entediante, e isso é uma boa notícia. Atualize o Nginx OSS para a 1.30.7 stable ou a 1.31.9 mainline; clientes do Nginx Plus precisam das versões corrigidas R33/R37. Se você não puder atualizar nesta semana, desative o HTTP/2 — nas versões 1.25.1 e posteriores, isso é http2 off; nos server blocks afetados, e nas versões antigas você remove o parâmetro http2 das diretivas listen — depois recarregue e confirme que os workers antigos já saíram. É uma mitigação bruta: você perde multiplexação e compressão de cabeçalhos, e apps sensíveis à latência vão sentir. Mas ela fecha completamente as duas falhas, e é uma mudança de configuração, não de código.
Para detecção, a resposta honesta é que isso é difícil de notar nos logs — a exploração parece sequências estranhas de frames HTTP/2 e, eventualmente, crashes inesperados de workers ou o worker do Nginx criando processos que nunca deveria criar. Workers em crash loop num Nginx exposto à internet com HTTP/2 habilitado merecem investigação, não apenas um restart do supervisor.
Uma observação de escopo: o HTTP/2 não vem habilitado por padrão no Nginx, e levantamentos colocam o uso em cerca de 12% dos servidores. Em escala de internet, isso ainda são milhões de instâncias, mas confira antes de entrar em pânico — e verifique também seus load balancers e origens de CDN, porque o Nginx que você esqueceu atrás do ingress gerenciado é o que acaba invadido.
Complexidade nunca foi uma fronteira de segurança. Era só uma fila — e a fila está andando mais rápido agora.
A lição maior para a infraestrutura crítica
Dando um passo para trás, o padrão é claro: os bugs que mais importam hoje vivem em implementações de protocolo com estado e inseguras em termos de memória, em infraestrutura que todo mundo compartilha. Só essa divulgação trouxe dez CVEs do Nginx — UAFs no HTTP/2, um UAF no HTTP/3, um UAF no resolver de DNS, um UAF no proxy de e-mail. O ponto em comum não é descuido; o código do Nginx é disciplinado para padrões de C. O ponto em comum é que o gerenciamento manual de tempo de vida através de máquinas de estado assíncronas e controladas por atacantes excede o que qualquer equipe consegue verificar a olho nu.
Então, o que fazer? Não 'reescreva tudo em Rust', por mais tentador que esse refrão seja — ainda que reescritas com segurança de memória dos parsers de maior exposição sejam uma ideia realmente boa, e a indústria esteja fazendo isso aos poucos. No imediato: trate seus proxies de borda como o alvo de auditoria de maior valor da sua stack, exija fuzzing com estado e sanitizers dos projetos dos quais você depende, e desenvolva a musculatura operacional para aplicar patch ou mitigar em dias. A era em que um bug de onze anos podia esperar tranquilamente até um humano notá-lo acabou. Agora as máquinas estão lendo a fila, dos dois lados.



