nginx2root: novas falhas críticas de segurança dão acesso de root ao seu site!
Se tu roda nginx em produção, para tudo um minutinho. Sério.
Ontem, 18 de novembro de 2026, saiu a correção de uma série de cinco vulnerabilidades críticas no nginx que a Xint (da Theori) batizou de nginx2root. Todas permitem execução remota de código sem autenticação, e a pesquisa mostra que, encadeadas com um bug no kernel Linux que ainda não tem correção, elas levam a root no host. Inclusive escapando de container Docker nos testes da Xint.
Neste artigo eu vou te mostrar primeiro o que fazer, em que ordem e em que prazo. Depois a gente conversa sobre o que essa série significa e sobre quem achou esses bugs (spoiler: boa parte foi uma IA, sozinha). Tudo aqui vem das fontes listadas nas referências, no fim do post. Eu não vou mostrar nada de exploração, só defesa.
TL;DR
- Hoje: descubra onde tu roda nginx, atualize pra 1.30.7 (stable) ou 1.31.9 (mainline), ou pro pacote corrigido da sua distro, e reinicie o nginx. Reload NÃO basta.
- NGINX Plus: vá pra 37.0.8.1 ou 37.3.0.1. R33 a R36 não vão receber patch.
- Não dá pra atualizar hoje? Aplique as mitigações: desligar HTTP/2 cobre dois dos cinco CVEs, mas não os outros três. Tem que olhar mirror/resolver, HTTP/3 e mail proxy também.
- Esta semana: bloqueie o carregamento do módulo SCTP no kernel, confirme que o ASLR está ativo e procure sinais de ataque.
- Depois: quando sair o patch do kernel, aplique e reinicie a máquina. Aí sim reveja as mitigações temporárias.
- Usa o ingress-nginx comunitário no Kubernetes? Ele foi aposentado e NÃO vai receber correção. Desligue o HTTP/2 nele hoje e planeje a migração.
- Usa Ubuntu ou Debian? O
nginx -vvai continuar mostrando versão antiga mesmo corrigido. Confira a versão do pacote contra o advisory da distro.
Conteúdos deste artigo
- O que é o nginx2root?
- Os cinco CVEs, um por um
- Hoje: inventário, atualização e restart
- Não dá pra atualizar hoje? Mitigações
- Esta semana: kernel, ASLR e detecção
- Depois: o patch do kernel
- O que essa série de CVEs significa?
- Quem achou isso tudo (e por quê)?
- O que estão falando por aí
- E agora?
- Referências
O que é o nginx2root?
Ultra simplificando: são cinco CVEs no nginx mais um bug no kernel Linux (no envio de pacotes SCTP). Cada CVE do nginx, sozinho, dá execução de código remota com o privilégio do processo worker do nginx. Aí entra o bug do kernel, que permite sair desse usuário limitado e virar root na máquina.
Importante: o nome "nginx2root" foi dado pela Xint. A F5 e o nginx.org não usam esse nome nos advisories, então se tu for procurar lá, procure pelos números dos CVEs.
Os cinco CVEs têm nota 9.2 no CVSS 4.0, ou seja, críticos. E nenhum deles exige login, credencial ou qualquer coisa do tipo. Basta a pessoa atacante conseguir falar com o seu nginx.
Segundo a Xint, é um problema só de data plane ("data plane issue only"): o ataque vem pelo tráfego que o nginx atende, não por alguma interface de controle exposta. O que, na prática, quer dizer que basta o seu nginx estar recebendo requisição.
Os cinco CVEs, um por um
A imagem abaixo resume o que tu precisa saber pra decidir se está exposto. Repare no selo no pé de cada cartão: ele é a pegadinha deste post inteiro 👇
Pois é, tu leu certo: o CVE do mail proxy está lá desde a 0.5.15. E o detalhe de disparar mesmo com o auth recusando todo mundo é o tipo de coisa que derruba a frase "ah, mas ninguém consegue logar no meu servidor de e-mail" 😅
No mesmo release, a F5 também corrigiu outros CVEs menos graves: CVE-2026-118899 (8.7), CVE-2026-120993, CVE-2026-125283, CVE-2026-123640 (6.9) e CVE-2026-120967 (6.3). Mais um motivo pra atualizar em vez de só mitigar.
Hoje: inventário, atualização e restart
Vamos por partes. A ordem importa.
Passo 1 – Descubra onde tu roda nginx
Parece óbvio, mas não é. Pensa em tudo: servidor de borda, ingress do Kubernetes (inclusive o de staging), imagem Docker com nginx servindo front-end, aquele servidor de e-mail antigo que ninguém lembra, a VM de homologação exposta na internet. Se tem nginx e alguém de fora consegue falar com ele, entra na lista.
Em cada máquina, comece pela versão e pelos módulos compilados:
$ nginx -V
O -V (maiúsculo) mostra a versão e também os argumentos de compilação. Procure por --with-http_v2_module, --with-http_v3_module e --with-mail. Dá pra filtrar direto:
$ nginx -V 2>&1 | grep -oE 'nginx/[0-9.]+|with-http_v[23]_module|with-mail'
O 2>&1 está aí porque o nginx -V escreve na saída de erro, não na saída padrão.
Passo 2 – Veja quais recursos a sua configuração usa
Ter o módulo compilado não significa que ele está ligado. Pra saber o que está ativo de verdade, use o nginx -T, que testa a configuração e imprime ela inteira, já com todos os include resolvidos:
$ nginx -T 2>/dev/null | grep -nE 'http2|http3|quic|mirror|resolver|proxy_pass|auth_http|^\s*mail|ssi on'
O que procurar no resultado:
http2nolistenouhttp2 on;: tu está exposto ao 123007 e possivelmente ao 123633.quicnolistenouhttp3 on;, junto deproxy_pass: 121810.resolver+proxy_passcom variável (tipoproxy_pass http://$host;) +mirror: 123634. Fique de olho emssi ontambém.- Bloco
mail { ... }comauth_http: 113425.
Uma pegadinha aqui: o http2 no listen vale por socket. Um único listen [::]:443 ssl http2; esquecido no bloco de IPv6 mantém o HTTP/2 ligado na porta, mesmo que tu tenha tirado do listen 443 de IPv4. Por isso o nginx -T é melhor que abrir o arquivo que tu "acha" que é o certo: ele mostra a configuração efetiva.
E não confie só na configuração. Teste de fora se o HTTP/2 está sendo negociado:
$ openssl s_client -alpn h2 -connect codamos.com.br:443 </dev/null 2>/dev/null | grep -i alpn
O -alpn h2 oferece HTTP/2 durante o handshake TLS e o -connect diz pra onde ir. Se a saída tiver ALPN protocol: h2, o HTTP/2 está ligado. Se tu está atrás de uma CDN, faça esse teste também direto no IP da origem: a CDN pode estar falando HTTP/2 com o mundo e o seu nginx de origem pode estar exposto do mesmo jeito pra quem descobrir o endereço dele.
Lembre-se: a atualização corrige TUDO isso de uma vez. Esse grep serve pra tu priorizar quais máquinas atualizar primeiro e pra saber quais mitigações aplicar enquanto a atualização não chega.
Passo 3 – Atualize
As versões corrigidas são:
- nginx open source: 1.30.7 (stable) e 1.31.9 (mainline).
- NGINX Plus: 37.0.8.1 e 37.3.0.1. Se tu está em R33, R34, R35 ou R36, não vai ter patch: tem que ir pra 37.x.
Agora, se liga nessa pegadinha. Se tu instala o nginx pelo pacote da distro, ela faz backport da correção pra versão que ela já distribui. Ou seja, o nginx -v continua mostrando a versão antiga mesmo depois de corrigido. No Ubuntu 24.04 ele mostra 1.24.0, no Ubuntu 22.04 mostra 1.18.0 e no Debian 12 mostra 1.22.1.
E tem mais: no dia seguinte à divulgação, segundo a Aviatrix, Ubuntu e Debian ainda não tinham publicado pacotes corrigidos. Isso muda rápido, então confira o advisory de segurança da sua distro. Se a correção ainda não saiu, vá direto pras mitigações e volte aqui quando o pacote chegar.
Então NÃO use o nginx -v pra decidir se está corrigido. Use a versão completa do pacote:
$ sudo apt update
$ sudo apt install --only-upgrade nginx
$ dpkg -l 'nginx*'
$ apt changelog nginx | head -n 30
O dpkg -l mostra a versão completa de cada pacote do nginx instalado (o 'nginx*' pega também nginx-common, nginx-core e afins). O apt changelog mostra as últimas entradas do changelog do pacote: procure ali os números dos CVEs. Depois compare a versão do pacote com a que aparece no advisory de segurança da sua distro. Se as duas batem (ou a sua é mais nova), beleza.
Se o seu nginx roda em container, atualizar o host não muda nada dentro da imagem. Tu precisa buildar de novo a imagem em cima de uma base corrigida e fazer deploy dela. E aqui vale conferir duas coisas. A sua imagem usa uma tag fixa antiga? Então ela não vai se corrigir sozinha. Usa uma tag flutuante (tipo nginx:stable)? Ela pode demorar pra apontar pra versão nova em algumas arquiteturas. O caminho mais seguro é fixar a tag na versão corrigida explicitamente e conferir dentro do container depois do deploy.
Passo 4 – Reinicie de verdade
Essa é a parte que mais vai pegar gente desprevenida. Depois de atualizar o pacote:
$ sudo systemctl restart nginx
Motivo: o nginx -s reload (e o systemctl reload nginx, que faz a mesma coisa) relê a configuração, mas não troca o executável que está rodando. Além disso, no reload os workers velhos continuam vivos atendendo as conexões que já estavam abertas. Ou seja: tu atualizou o pacote, deu reload, e o binário vulnerável continua lá, feliz da vida.
Se tu não pode ter nem um segundo de restart, o nginx tem um mecanismo de upgrade de binário ao vivo suportado oficialmente. Só faça isso se tu já conhece o processo; não é o dia de aprender.
Pra confirmar que o processo rodando é o novo, dá pra olhar há quanto tempo o master está de pé:
$ ps -o pid,lstart,cmd -C nginx
Se o horário de início é de antes da atualização, o restart não aconteceu.
Outra checagem simples: veja pra qual executável o processo master aponta.
$ ls -l /proc/$(pgrep -o nginx)/exe
O pgrep -o pega o processo nginx mais antigo (o master) e o /proc/<pid>/exe é um link pro binário que ele está executando. Se aparecer (deleted) no fim, o processo ainda está rodando o binário velho, que o gerenciador de pacotes já substituiu no disco. Tem relato de quem atualizou pra 1.31.9, deu reload, viu o nginx -v dizendo 1.31.9 e o 1.31.8 continuava atendendo. Faz isso não 😉
Não dá pra atualizar hoje? Mitigações
Sei que tem empresa onde atualizar pacote em produção exige janela, ticket e três aprovações. Se esse é o seu caso, mitigue hoje e atualize assim que der. Mas lembre: mitigação é curativo, não cura. Cada uma delas tem custo.
HTTP/2 (CVE-2026-123007 e CVE-2026-123633)
No nginx 1.25.1 ou mais novo, desligue com a diretiva http2:
server {
listen 443 ssl;
http2 off;
# ...
}
Entre a 1.9.5 e a 1.25.0, o HTTP/2 é ligado no próprio listen. Basta tirar o http2 de lá:
# Antes
listen 443 ssl http2;
# Depois
listen 443 ssl;
Que problemas isso cria? Os navegadores voltam pra HTTP/1.1 sem drama, mas clientes gRPC quebram, porque gRPC depende de HTTP/2. Se tu tem gRPC passando por esse nginx, essa mitigação não serve: atualizar é o único caminho.
Depois de aplicar, rode de novo o teste do openssl s_client -alpn h2 lá do Passo 2, de fora e direto na origem, pra confirmar que o h2 sumiu de verdade.
ingress-nginx no Kubernetes
Se tu usa o ingress-nginx, o controller comunitário do Kubernetes, presta atenção: ele foi aposentado em março de 2026 e NÃO vai receber correção. E lá o HTTP/2 vem ligado por padrão (use-http2: "true" no ConfigMap).
O paliativo é desligar no ConfigMap do controller:
apiVersion: v1
kind: ConfigMap
metadata:
name: ingress-nginx-controller
namespace: ingress-nginx
data:
use-http2: "false"
O nome e o namespace dependem de como tu instalou o controller, então confira no seu cluster. Mas isso é só paliativo: o caminho real é migrar de controller. Não confunda com o NGINX Ingress Controller comercial da F5, que é outro produto e continua mantido.
Resolver/mirror (CVE-2026-123634)
Desligar HTTP/2 não ajuda aqui. E trocar pra mirror_request_body on, sozinho, também não resolve. O que a gente quer é evitar resolução de DNS em tempo de requisição e desligar o mirror onde ele não é necessário. Algo assim:
# Antes: destino calculado a partir da requisição, resolvido em tempo de execução
resolver 1.1.1.1;
location /api/ {
mirror /espelho;
mirror_request_body off;
proxy_pass http://$http_x_backend;
}
# Depois: upstream fixo e mirror desligado onde não precisa
upstream api_backend {
server api.interno.codamos.com.br:8080;
}
location /api/ {
mirror off;
proxy_pass http://api_backend;
}
Repare que o upstream com nome fixo é resolvido quando o nginx carrega a configuração, não a cada requisição. O custo: se o IP do backend muda, tu precisa dar reload pra pegar o novo endereço. Se tu usa SSI ou outro recurso que cria subrequests, revise também, porque eles podem alcançar o mesmo bug.
HTTP/3 (CVE-2026-121810)
Aqui o caminho é tirar o QUIC de cena:
server {
listen 443 ssl;
# listen 443 quic reuseport; # remova os listeners QUIC
http3 off;
# Avisa os navegadores pra esquecerem o HTTP/3 anunciado antes
add_header Alt-Svc 'clear' always;
# ...
}
O Alt-Svc 'clear' é importante porque navegador que já viu o anúncio de HTTP/3 tenta voltar nele. Se quiser ir além, bloqueie UDP na porta 443 no firewall. Custo: clientes voltam pra HTTP/2 ou HTTP/1.1 sobre TCP. Se tu também desligou o HTTP/2, eles caem pro HTTP/1.1, e tudo bem por alguns dias.
Mail proxy (CVE-2026-113425)
Se tu usa o nginx como proxy de IMAP/POP3/SMTP, faça o bind em loopback ou libere no firewall só os IPs confiáveis:
mail {
auth_http 127.0.0.1:9000/auth;
server {
listen 127.0.0.1:143;
protocol imap;
proxy on;
}
}
Na real, se tem um proxy de e-mail aberto pra internet inteira e ninguém no time sabe por quê, essa é uma ótima hora pra descobrir.
Esta semana: kernel, ASLR e detecção
Bloqueie o módulo SCTP
O bug do kernel é um use-after-free/double free no envio SCTP. Ele existe desde o Linux 4.15 (2018), não tem CVE e, até hoje (19/11/2026), não tem correção. Segundo a Xint, ele permite vazar memória do kernel (o que derrota o KASLR) e chamar funções arbitrárias dentro do kernel. É a ponte entre "o atacante virou o usuário do nginx" e "o atacante virou root". A Xint segurou os detalhes técnicos, e ainda bem.
Primeiro, veja se o módulo está carregado:
$ lsmod | grep sctp
Se tu não usa SCTP (e eu suspeito que a maioria dos servidores web não usa, mas confira antes), bloqueie o carregamento:
$ echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/bloqueia-sctp.conf
Essa linha diz pro modprobe: "quando alguém pedir pra carregar o sctp, rode /bin/false no lugar". Atenção pra duas limitações:
- Ela não descarrega um módulo que já está carregado. Se o
lsmodmostrou osctp, tu vai precisar descarregar (se nada estiver usando) ou reiniciar a máquina. - Ela não adianta nada se o SCTP estiver compilado direto no kernel, em vez de módulo.
E aqui vai um ponto que muita gente esquece: container compartilha o kernel do host. Então esse bloqueio tem que ser feito no host, não na imagem.
Confirme que o ASLR está ativo
$ cat /proc/sys/kernel/randomize_va_space
2
O valor 2 é a randomização completa, que é o padrão na maioria das distros. Se aparecer 0, alguém desligou, e tu precisa descobrir o porquê. Isso importa porque o PoC público do CVE-2026-123007 precisa derrotar o ASLR pra funcionar.
Procure sinais de ataque
A evidência pode ser fraca, porque o ataque usa frames de controle do HTTP/2 que não viram linha no access log. Então olhe por outros ângulos:
- Conexões estranhas. Liste as conexões estabelecidas na 443 com detalhes de TCP:
$ ss -tinp state established '( sport = :443 )'O
-tfiltra TCP, o-imostra informações internas da conexão (incluindobytes_receivedebytes_sent), o-nnão resolve nomes e o-pmostra o processo. Procure conexões longas combytes_receivedcrescendo rápido ebytes_sentpequeno. Faz sentido: segundo a Rapid7, o PoC público precisa de uns 128 GB de tráfego HTTP/2. - Shell aberto pelo nginx. Configure o auditd pra registrar
execvefeito pelo UID do worker do nginx. Worker de nginx abrindo shell é sinal forte de que algo deu muito errado. - Workers morrendo. Procure no log de erro por "worker process exited", "signal 11" e segfaults. Um worker que cai de vez em quando pode ser tentativa de exploração que não deu certo.
$ grep -nE 'worker process [0-9]+ exited|signal 11' /var/log/nginx/error.log
$ journalctl -k | grep -i segfault | grep -i nginx
Depois: o patch do kernel
Quando sair a correção do bug de SCTP no kernel da sua distro, aplique e reinicie a máquina (kernel novo só entra em vigor no boot, a menos que tu use live patching).
Só depois disso eu reveria as mitigações temporárias. E reveja MESMO: é muito comum desligar o HTTP/2 como paliativo e esquecer de religar, deixando o site mais lento por meses sem ninguém perceber. Abra um ticket hoje mesmo pra isso, com data. Com o nginx atualizado, tu pode religar HTTP/2, HTTP/3 e o mirror, mas faça isso com calma, um de cada vez, e de preferência atrás de algo que permita voltar rápido. O bloqueio do SCTP eu deixaria lá se tu não usa o protocolo: superfície de ataque que tu não usa é superfície que tu não precisa.
O que essa série de CVEs significa?
A superfície é gigante
Em 10/11/2026, o Shodan mostrava 56,7 milhões de hosts com product:nginx. Desses, 11,94 milhões (21,1%) expõem a versão, e 98,9% desses estavam entre a 1.9.5 e a 1.31.8.
A Censys, por meio do Zakir Durumeric, estima algo perto de 10 milhões de serviços na internet com versões vulneráveis. São metodologias diferentes, então os números não batem exatamente, mas apontam pra mesma direção.
Calma lá: isso não prova que 98,9% estão vulneráveis. Tem backport de distro (lembra do nginx -v mentindo?), tem servidor sem HTTP/2 ligado e por aí vai. Mas dá uma ideia do tamanho do problema: o nginx está em todo canto.
Um bug de 2015 no HTTP/2
O CVE-2026-123007 está no nginx desde o primeiro release com suporte a HTTP/2, a 1.9.5, de 2015. Foram onze anos com um integer overflow no controle de fluxo de um dos softwares mais usados e mais olhados da internet.
E não é só configuração exótica que está em risco. Segundo o The Hacker News, a Wiz demonstrou execução de código num nginx servindo só arquivos estáticos, sem backend e sem módulo de terceiros. Aquele nginx "simplão" que só serve o build do front-end também entra na conta.
Isso não é pra zoar ninguém do time do nginx. É um lembrete de que "é open source, muita gente olha" não significa "alguém olhou ESSA parte com ESSE olhar". E de que parser de protocolo binário escrito em C é terreno fértil pra esse tipo de bug.
De worker a root
Muita gente (eu incluso, por muito tempo) se acalma pensando "o worker do nginx roda como www-data, então o estrago é limitado". O nginx2root mostra o problema desse raciocínio: o atacante não precisa de um bug que dê root direto, ele precisa de dois bugs encadeados. E o segundo estava no kernel desde 2018.
O mesmo vale pra container. A Xint escapou de container Docker nos testes. Container é ótimo pra empacotar e isolar recurso, mas ele não é fronteira de segurança forte quando o bug está no kernel compartilhado.
A explosão de CVEs no nginx em 2026
Os advisories de segurança do nginx listaram 2 vulnerabilidades novas em 2025. Em 2026, até 17/11, já eram 26, sem contar o nginx2root.
Eu não sei afirmar a causa com certeza. Eu suspeito que tem relação direta com o próximo ponto: ferramentas automatizadas, com IA, procurando bug em escala. Se for isso mesmo, 2026 não é exceção, é o novo normal. E o nosso processo de atualização precisa estar pronto pra isso: inventário atualizado, deploy de pacote sem drama e restart sem medo.
Status da exploração
Até 18/19 de novembro, não havia exploração em massa confirmada e os CVEs não estavam no catálogo KEV da CISA. MAS, e é um mas grande, existe PoC público pro CVE-2026-123007, publicado no GitHub no próprio dia da divulgação por Stephen Fewer, da Rapid7, com RCE completo demonstrado contra o nginx 1.31.8 em Docker.
A Rapid7 diz que o PoC é restrito, e o The Hacker News reforça que ele roda num cenário Docker local controlado, não é um exploit universal: só x86-64, precisa de uns 128 GB de tráfego HTTP/2 e tem que derrotar o ASLR. A Wiz diz ter exploits funcionais, mas não publicou. Ou seja: hoje é difícil. Mas "difícil" costuma ficar fácil rápido depois que tem código público por aí. Não conte com isso como janela.
Quem achou isso tudo (e por quê)?
Aqui fica curioso. O time de pesquisa da Xint (Theori) aparece como responsável, com os reporters imssm99, cdor1, tjbecker e yves.
O CVE-2026-123007, o bug de 2015, foi achado por um pesquisador da Xint enquanto se preparava pro ZeroDay Cloud 2026, a competição de hacking em nuvem da Wiz. Faz sentido: na edição de 2025, em Londres, na Black Hat Europe, o nginx estava entre os alvos, com prêmio de até US$ 300 mil, e o time Xint Code foi o campeão geral. Quem treina pra campeonato vai atrás dos alvos que valem ponto 😉
Agora a parte que me chamou mais atenção: segundo a Xint, os outros quatro CVEs foram achados por um "scan totalmente automatizado da Xint, sem orientação humana". A Xint se descreve como uma plataforma de pentest autônomo e diz ser membro do Cyber Verification Program da Anthropic e do Daybreak da OpenAI.
E não foi só a Xint. Segundo a watchTowr, Wiz Research, Ikotas Labs, Metnir, Rapid7 e Xint acharam e reportaram esses bugs de forma independente. A Wiz, por exemplo, reportou o CVE-2026-123633 em 21/10, e a F5 respondeu que outro time já tinha reportado. Quando vários grupos acham o mesmo bug ao mesmo tempo, é sinal de que as ferramentas mudaram, não de que todo mundo teve a mesma ideia por coincidência.
A linha do tempo da Xint (em UTC) também é um bom exemplo de divulgação coordenada:
Pouco mais de um mês da descoberta à correção. Pra cinco CVEs críticos num projeto desse tamanho, é rápido.
O que estão falando por aí
Dei uma olhadinha no que saiu sobre o assunto nas últimas 24 horas. Alguns pontos que valem a leitura.
A IA é a manchete
O Security Affairs deu ênfase total à parte da IA, com várias citações da Xint. Algumas delas:
- "Pre-auth RCE in nginx almost never happens. The best known one is from 2013." Ou seja, RCE sem autenticação no nginx quase nunca acontece, e o mais conhecido até então era de 2013.
- "This year every AI lab pointed models at it. Everyone figured the easy bugs were long gone." Todo laboratório de IA apontou modelos pro nginx este ano, e todo mundo achava que os bugs fáceis já tinham acabado.
- "He picked the target; Xint did the rest." Sobre o pesquisador: ele escolheu o alvo, e a ferramenta fez o resto.
O relato da Xint é que o pesquisador escolheu uma fatia de uns 50 mil linhas do código do nginx, a IA apontou problemas graves em cerca de 90 minutos e um exploit funcional saiu em menos de 10 minutos. Atenção: isso é alegação da própria Xint, que vende essa plataforma, e até agora não há verificação independente desses números. Pode ser verdade, mas trate como material de divulgação até alguém reproduzir.
O bug de dez anos
O The Hacker News focou no "10-year-old flaw": a 1.9.5, primeira versão com o bug, saiu em 22/09/2015. É de lá também a demonstração da Wiz contra um nginx servindo só arquivo estático, que eu comentei lá em cima.
Relato de quem aplicou o patch
Na minha opinião, o texto mais útil da semana até agora é o relato de uma pessoa que aplicou o patch em uns 140 hosts. Boa parte das dicas práticas que eu espalhei no plano de ação veio de lá: o binário (deleted) que continua servindo depois do reload, o listen de IPv6 esquecido com http2, a tag Docker flutuante atrasada, o HTTP/2 que ninguém religa e um ingress-nginx esquecido em staging.
Duas frases dele resumem bem: "Floating tags and nginx -v both lie, in different ways." (tags flutuantes e o nginx -v mentem, cada um do seu jeito) e "the gap between a fix shipping and a working exploit existing was zero days this time." (o intervalo entre a correção sair e existir um exploit funcional foi de zero dias). Por isso ele está encurtando os SLAs de patch dos componentes de borda. Eu faria o mesmo.
Cuidado com página de fornecedor
Como em todo CVE grande, já tem fornecedor usando o caso pra vender produto. Algumas dessas páginas, como a da Aviatrix, trazem informação útil, mas também tem inconsistência: CVSS 8.1 num lugar e 9.2 no outro, por exemplo.
Dica de ouro: em incidente de segurança, leia a fonte primária. Aqui ela é o advisory da F5 (K000163926) e a página de advisories do nginx.org, mais o advisory da sua distro. Reportagem e post de blog (inclusive este aqui 😅) servem pra te dar contexto e um plano, mas a versão corrigida, a lista de CVEs e a nota oficial vêm de lá.
E agora?
Recapitulando: hoje tu atualiza e reinicia (reload não conta), confere se o processo não está rodando binário (deleted) e não esquece do ingress-nginx. Se não der, mitiga lembrando que desligar HTTP/2 cobre só dois dos cinco CVEs. Esta semana tu bloqueia o SCTP no host, confere o ASLR e procura sinais de ataque. Quando o kernel for corrigido, aplica e reinicia a máquina.
E pra depois da poeira baixar, fica a lição que eu acho mais importante: se IA está achando bug crítico sozinha em software que a gente usa há uma década, a quantidade de CVEs só tende a subir. A pergunta pro seu time não é "como a gente corrige o nginx2root?", é "quanto tempo a gente leva pra corrigir QUALQUER coisa em produção?". Se a resposta for "semanas", esse é o problema de verdade.
Não esquece de compartilhar com a galera do seu time, principalmente com quem cuida de infraestrutura. E se tu achou algum erro aqui ou tem uma dica de mitigação que eu não cobri, me dá um toque lá no LinkedIn.
Até a próxima! 👋
Referências
- Xint: nginx2root, Remote Code Execution
- Tenable: nginx2root (CVE-2026-123007), perguntas frequentes sobre cinco vulnerabilidades críticas no nginx
- watchTowr: nginx2root (CVE-2026-123633) FAQ
- The Hacker News: 10-year-old nginx HTTP/2 flaw
- Kubernetes Blog: aposentadoria do ingress-nginx
- Rorix Tech: nginx2root, o que corrigimos esta semana, o que checamos primeiro e o que eu faria diferente
- nginx.org: security advisories (e o advisory da F5, K000163926)
- Security Affairs: nginx2root, AI discovers five critical nginx flaws and a path to root
Comentários