Em 18 de novembro de 2026, a F5, empresa que mantém o NGINX, publicou as versões 1.31.9 (mainline) e 1.30.7 (stable) com a correção de dez falhas de segurança. A mais grave é a CVE-2026-123007, uma corrupção de memória no controle de fluxo do HTTP/2 que permite a um atacante sem login derrubar os processos do servidor e, em alguns cenários, executar código nele. A nota é 9.2 no CVSS v4.0 (8.1 no CVSS v3.1), e o próprio nginx.org classifica a falha como "major".

O defeito está no código desde o NGINX 1.9.5, de 2015, e funciona mesmo em servidores que só entregam arquivos estáticos, sem nenhum backend por trás. No mesmo dia da divulgação, a Rapid7 publicou no GitHub uma prova de conceito que demonstra execução remota de código. Os pesquisadores apelidaram o conjunto de falhas de NGINX2Root e Nginx2Shell.

Resumo para quem tem pressa

  • Atualize o NGINX para 1.31.9 (mainline) ou 1.30.7 (stable). No NGINX Plus, as versões corrigidas são 37.0.8.1 e 37.3.0.1.
  • Está exposto quem tem HTTP/2 ligado, que é o padrão em boa parte das configurações com HTTPS (listen 443 ssl http2 ou http2 on).
  • Depois de atualizar, reinicie o NGINX em vez de só recarregar: um reload mantém processos antigos atendendo as conexões abertas.
  • Não dá para atualizar agora? Desligue o HTTP/2. O site continua funcionando em HTTP/1.1, só um pouco menos eficiente.
  • Até 18 de novembro não havia exploração confirmada, mas a prova de conceito já é pública.

O que é a falha

No HTTP/2, várias requisições trafegam ao mesmo tempo na mesma conexão, cada uma num "stream". Para que um lado não afogue o outro, existe o controle de fluxo: cada lado diz quantos bytes aceita receber (a "janela"), e vai liberando mais espaço com quadros chamados WINDOW_UPDATE. O protocolo define um limite para essa janela: 2.147.483.647 bytes.

O NGINX guarda a janela de envio da conexão num contador. Quando o cliente cancela um stream, o NGINX devolve a esse contador o espaço que não chegou a usar, sem conferir se o total passou do limite. Repetindo isso, o atacante empurra o contador para além do máximo. A partir daí, a conta que deveria barrar novos WINDOW_UPDATE dá a volta (um integer underflow) e deixa de funcionar, e o valor gigante vira um tamanho negativo quando o NGINX monta os dados de resposta. A camada de TLS então copia memória fora dos limites do buffer: dá para vazar dados da memória e corromper o heap do processo.

Na prática, o resultado mais comum é o processo de trabalho (worker) do NGINX cair. Com o vazamento de memória, porém, o atacante consegue descobrir onde as coisas estão na memória e contornar o ASLR, e a partir daí sobrescrever um ponteiro de função para rodar um comando. O código roda com o usuário do worker (normalmente nginx ou www-data), não como root.

Quem está exposto

  • NGINX Open Source de 1.9.5 até 1.31.8 com HTTP/2 ligado sobre HTTPS, em servidores de 64 bits. Não importa se ele serve arquivos estáticos, faz proxy reverso ou roda PHP-FPM.
  • NGINX Plus R33 e as versões 37.x anteriores a 37.0.8.1 e 37.3.0.1.
  • Imagens Docker baseadas no nginx oficial que não foram reconstruídas depois de 18 de novembro. As tags mainline, stable e latest já foram atualizadas, mas a sua imagem só muda quando você gera um build novo.
  • Pacotes das distribuições: em 18 de novembro, o Alpine 3.24 já tinha o nginx 1.30.7, mas Debian e Ubuntu ainda não tinham publicado a correção. Quem usa o pacote da distribuição precisa acompanhar o aviso de segurança dela ou trocar para o repositório oficial do nginx.org.
  • Produtos que embutem o NGINX, como o OpenResty (a 1.31.8.1 ainda traz o NGINX vulnerável) e o ingress-nginx do Kubernetes, que foi aposentado em março de 2026 e não vai receber correção. Ele usa HTTP/2 por padrão.

Quem fica de fora: servidores com HTTP/2 desligado e NGINX em 32 bits. Se uma CDN ou um balanceador (Cloudflare, AWS ALB, Azure Front Door) recebe o HTTP/2 do visitante e fala com o seu NGINX em HTTP/1.1, boa parte do ataque é barrada, desde que o servidor de origem não esteja acessível diretamente pela internet.

Quão fácil é explorar

Derrubar o NGINX é a parte simples. Já a execução de código tem barreiras práticas, segundo a análise da Rapid7: o ataque precisa enviar cerca de 128 GB de dados HTTP/2 pela conexão, então links abaixo de uns 300 Mbit/s não conseguem concluí-lo; um proxy na frente do NGINX tende a quebrar o ataque; e o exploit publicado depende de uma rotina de cópia de memória da glibc usada em processadores x86-64 com AVX-512, comum em servidores de nuvem. A Wiz, que também reportou a falha, demonstrou execução de código nos builds oficiais 1.31.7 e 1.31.8 servindo só arquivos estáticos e não publicou o seu exploit.

O apelido NGINX2Root vem da Xint, que diz ter encadeado estas falhas com uma falha no kernel do Linux para virar root na máquina. Os detalhes dessa cadeia ainda não foram publicados.

Ou seja: não é algo que qualquer um explora da própria casa, mas um servidor de nuvem com boa banda é exatamente o ambiente que um atacante usaria. Com o exploit público, a janela para atualizar é curta.

As outras falhas corrigidas no mesmo pacote

As versões 1.31.9 e 1.30.7 corrigem mais nove falhas. As que mais pesam:

  • CVE-2026-123633: use-after-free no HTTP/2 quando o NGINX faz proxy para um backend e está com poucas conexões livres. Também pode levar a execução de código. Afeta da 1.19.7 à 1.31.8.
  • CVE-2026-121810: use-after-free no HTTP/3 em configurações de proxy (1.25.0 a 1.31.8).
  • CVE-2026-123634: use-after-free no resolver, quando o destino do proxy_pass vem da requisição.
  • CVE-2026-113425: use-after-free no proxy de e-mail com auth_http.
  • CVE-2026-118899: laço infinito ao ler o corpo da requisição em TLS 1.3, que trava o worker (negação de serviço).

Todas somem com a mesma atualização, então não vale a pena tratar uma por uma.

Passo 1: confira a versão e a configuração

No servidor ou dentro do container:

# versão do nginx
nginx -v

# o HTTP/2 está ligado? (qualquer linha na saída = sim)
nginx -T 2>/dev/null | grep -nE '^\s*(http2\s+on\b|listen\b[^#]*\bhttp2\b)'

# o nginx repassa requisições para um backend? (CVE-2026-123633)
nginx -T 2>/dev/null | grep -nE '\b(proxy|fastcgi|uwsgi|scgi|grpc)_pass\b'

Se a versão for anterior a 1.31.9 (ou 1.30.7 na linha stable) e o segundo comando mostrar alguma linha, o servidor está exposto à CVE-2026-123007. Se o terceiro também mostrar algo, está exposto à CVE-2026-123633. Atenção: pacotes de distribuição às vezes trazem a correção com o número de versão antigo, então compare a versão completa do pacote (dpkg -l nginx, rpm -q nginx ou apk info nginx) com o aviso de segurança da sua distribuição.

Passo 2: atualize

  • Repositório oficial do nginx.org: rode a atualização normal do sistema (apt upgrade nginx, dnf upgrade nginx) para receber a 1.31.9 ou a 1.30.7.
  • Debian e Ubuntu com o pacote da distribuição: acompanhe o aviso de segurança e atualize assim que sair. Se o servidor está exposto e a correção demora, desligue o HTTP/2 (passo 3) ou mude para o repositório do nginx.org.
  • Docker: atualize a tag no Dockerfile (por exemplo nginx:1.31.9 ou nginx:1.30.7-alpine), gere um build novo e faça o deploy. Não basta reiniciar o container com a imagem antiga.
  • NGINX Plus: vá para a 37.0.8.1 ou a 37.3.0.1.
  • OpenResty e ingress-nginx: enquanto não houver versão corrigida, desligue o HTTP/2. No caso do ingress-nginx, vale planejar a troca por outro controlador, já que ele não recebe mais atualizações.

Depois, teste a configuração com nginx -t e reinicie o serviço (systemctl restart nginx). Confira com ps aux | grep nginx que não sobrou nenhum worker antigo.

Passo 3: se não der para atualizar agora, desligue o HTTP/2

É a única mitigação que fecha a CVE-2026-123007 sem atualizar. Em cada bloco server com HTTPS:

server {
    # tire o "http2" do listen
    listen 443 ssl;
    http2 off;   # no NGINX 1.25.1 ou mais novo
    ...
}

Rode nginx -t, recarregue e confirme que os workers antigos saíram. O site continua no ar em HTTP/1.1. O que deixa de funcionar é o que exige HTTP/2, como serviços gRPC expostos pelo NGINX. Lembre-se de religar o HTTP/2 depois de atualizar.

No ingress-nginx, a opção equivalente é use-http2: "false" no ConfigMap do controlador. Se você usa HTTP/3, desligue também enquanto não atualiza (http3 off;, sem os listen ... quic e sem o cabeçalho Alt-Svc), por causa da CVE-2026-121810.

Passo 4: procure sinais de ataque

  • Workers caindo no log de erros: linhas como worker process 1234 exited on signal 11. Procure com grep "exited on signal" /var/log/nginx/error.log (ou docker logs <container> 2>&1 | grep "exited on signal").
  • Conexões HTTP/2 longas que transferem uma quantidade anormal de dados, de um mesmo IP. Lembre que o ataque envia dezenas de gigabytes.
  • Processos filhos do worker do NGINX, como sh, bash, curl, wget ou nc. Um worker do NGINX não deveria abrir shell nunca.
  • Arquivos novos em /tmp, /var/tmp ou /dev/shm pertencentes ao usuário do NGINX.
  • Conexões de saída estranhas a partir do servidor, principalmente para o endereço de metadados da nuvem (169.254.169.254).

Se encontrar algo além de quedas isoladas, isole o servidor, guarde os logs, suba uma máquina ou imagem nova já atualizada e troque os certificados TLS e os segredos que o NGINX conseguia ler, já que a falha permite vazar memória do processo.

Checklist

  • Inventário de todos os servidores, containers e ingress com NGINX, OpenResty ou NGINX Plus
  • NGINX em 1.31.9 ou 1.30.7 (ou NGINX Plus em 37.0.8.1 ou 37.3.0.1)
  • Serviço reiniciado, sem workers antigos rodando
  • Imagens Docker reconstruídas e publicadas, inclusive as de homologação
  • HTTP/2 desligado onde ainda não foi possível atualizar (OpenResty, ingress-nginx, pacotes de distribuição sem correção)
  • Servidores de origem atrás de CDN sem acesso direto pela internet
  • Logs revisados em busca de workers caindo e processos estranhos

Fontes

Precisa de ajuda?

Não sabe quantos servidores e containers rodam NGINX, se o pacote da sua distribuição já veio corrigido ou se dá para desligar o HTTP/2 sem quebrar nada? Fale com a gente: fazemos o inventário, atualizamos e reiniciamos sem derrubar o site e revisamos os logs em busca de sinais de ataque.