Dez falhas no nginx, uma atualização que nunca chegou e notas de versão erradas

O Golem noticia uma falha crítica no nginx e eu penso: “O dnf-automatic roda toda noite mesmo.” Uma olhada no servidor mostra: meu nginx não era atualizado havia semanas, e não era o único serviço.

Quadrinho: no corredor de um data center, um simpático robô de manutenção só coloca na sua esteira os pacotes com o carimbo vermelho “SECURITY”; um pacote verde brilhante sem carimbo fica esquecido no chão, com um coelhinho ao lado; o homem segura horrorizado um jornal com pontos de exclamação e aponta para ele

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski

Em resumo: Em 18 de novembro o nginx fechou dez vulnerabilidades, entre elas uma corrupção de memória no HTTP/2 e um bug no HTTP/3. Meu blog ainda rodava na versão vulnerável 1.31.8, embora o dnf-automatic instale atualizações de segurança toda noite. O motivo: aqui o dnf-automatic só instala o que um repositório marca explicitamente como atualização de segurança, e o repositório do nginx não marca nada. O mesmo valia para o Grafana, para um pacote do Rancher e para o MariaDB. Agora uma pequena tarefa noturna busca todas as atualizações exatamente desses repos de fabricantes. Nos Nextclouds desliguei o HTTP/2 por meio dia e esperei por um ingress controller corrigido, que na verdade já existia fazia tempo. Por que eu não percebi, conto mais abaixo.

Índice

📰 O gatilho: uma manchete

Na sexta de manhã o Golem (matéria só em alemão) publicou: milhões de servidores web em risco, falha no nginx permite execução de código sem autenticação. Minha primeira reação foi tranquila. Meu blog roda em nginx, mas o servidor instala toda noite as atualizações de segurança com o dnf-automatic. O que poderia acontecer?

Aí fui conferir. No nginx.org havia dez novos avisos de segurança, todos com o mesmo limite: vulnerável até 1.31.8, corrigido em 1.31.9 (mainline) e 1.30.7 (stable). Três deles atingiam exatamente o que meu blog usa:

FalhaGravidademe afeta porque…
Corrupção de memória no controle de fluxo do HTTP/2altao blog fala HTTP/2
Use-after-free no HTTP/3médiao blog fala HTTP/3
Loop infinito ao ler via TLS 1.3altatoda conexão usa TLS 1.3

O pacote estava no repositório havia dois dias. Instalado, não estava.

🔍 A causa: “só atualizações de segurança” significa “só atualizações de segurança marcadas”

Aqui o dnf-automatic roda com upgrade_type = security. Parece razoável: à noite só o que fecha brechas, todo o resto eu faço conscientemente. Mas como o dnf sabe o que é uma atualização de segurança?

Pelos metadados do repositório. Os repos do AlmaLinux trazem um arquivo chamado updateinfo, no qual cada atualização é classificada como security, bugfix ou enhancement. O dnf-automatic lê esse arquivo e instala só o que consta ali como security.

O repositório do nginx.org não tem esse arquivo. Conferi: nos metadados só estão as listas de pacotes, nenhum updateinfo. Para o dnf, portanto, nenhuma atualização do nginx é uma atualização de segurança, nem mesmo a que fecha dez falhas. Ela simplesmente espera até alguém rodar dnf upgrade à mão.

Na minha própria documentação estava escrito: “nginx, Grafana e todos os outros pacotes do sistema vêm dos seus repositórios e são atualizados pelo dnf-automatic.” Bem-intencionado e errado.

🧹 Não só o nginx

Quando a causa ficou clara, verifiquei todos os repositórios nos meus servidores que não vêm do próprio AlmaLinux:

RepositórioServidorupdateinfo
nginx.org (mainline)Blogausente
GrafanaBlog e Nextcloudsausente
Rancher (k3s-selinux)Nextcloudsausente
MariaDB CommunityNextcloudsausente

Quatro repos de fabricantes, nenhum com marcação de segurança. Todos esses pacotes só teriam sido atualizados na próxima atualização manual, inclusive o banco de dados.

🛠️ A solução: uma tarefa só para repos de fabricantes

Primeiro o urgente: subi o nginx do blog para 1.31.9 via Ansible, reiniciei, conferi. Como o HTTP/3 já tinha travado aqui uma vez depois de um restart, fiz em seguida 60 requisições via HTTP/3: 60 de 60 bem-sucedidas.

Depois a solução permanente. Os fabricantes publicam suas correções de segurança como versões novas comuns. Então um pequeno script, update-vendor-repos, pega toda noite todas as atualizações exatamente desses repositórios, e de nenhum outro:

dnf -y -q --disablerepo='*' --enablerepo="nginx-mainline,grafana" \
    --setopt=install_weak_deps=False upgrade

Quais repos são fica numa variável do Ansible por servidor. A tarefa roda às 02:15, ou seja, depois da janela noturna do dnf-automatic e antes de duas coisas que já existiam: às 03:45 um script reinicia todos os serviços que ainda têm código antigo na memória, e às 04:00 o AIDE incorpora os arquivos alterados à sua referência. Só chega um e-mail se algo foi atualizado ou se houve erro, e um heartbeat avisa se a tarefa parar.

Com o MariaDB hesitei um pouco: uma atualização automática do banco significa um restart noturno do banco. O repositório fixa a série (10.11), então só chegam versões de patch. E às quinze para as quatro da madrugada ninguém usa os Nextclouds das associações. Então o MariaDB entrou também.

A outra solução óbvia seria configurar o dnf-automatic com upgrade_type = default: aí chega toda noite qualquer atualização, não importa como esteja marcada. Tecnicamente é uma linha só, e as reinicializações das 03:30 e 03:45 já existem. Mesmo assim decidi não fazer isso. Também chegariam de madrugada, sem pedir, simples correções de bugs e funções novas, e o salto para uma nova versão menor do AlmaLinux significa centenas de pacotes de uma vez. Nos Nextclouds, o kernel, o container-selinux ou pacotes de rede podem desestabilizar o K3s – e se isso acontecer, acontece às três e meia, quando ninguém está olhando, e não no dia de atualizações, quando estou do lado. Some-se a isso os pacotes cuja versão o Ansible fixa de propósito e que simplesmente avançariam durante a noite. O job direcionado aos repositórios dos fabricantes fecha a brecha sem me trazer esses efeitos colaterais.

🧩 E os Nextclouds?

Os Nextclouds rodam em Kubernetes, e ali o nginx fica em contêineres em dois lugares:

  • O ingress controller, que aceita as conexões vindas da internet. Ele traz seu próprio nginx, e no momento da falha o fabricante ainda não tinha publicado nenhuma versão com nginx 1.31.9: até a edição mais nova, do mesmo dia, ainda trazia 1.31.8. Pelo menos era o que eu achava. Como solução temporária desliguei o HTTP/2 no ingress: assim a mais grave das dez falhas, a corrupção de memória no controle de fluxo do HTTP/2, deixa de ser alcançável de fora. Navegadores e clientes de sincronização mal percebem; eles voltam silenciosamente para o HTTP/1.1. O HTTP/3 ali já estava desligado de qualquer forma. Um pequeno script deveria perguntar ao GitHub a cada duas horas se o fabricante tinha se atualizado. À noite o controller 5.8.0 com nginx 1.31.9 já rodava nos dois Nextclouds, e o HTTP/2 estava ligado de novo; já explico.
  • O nginx dentro do pod do Nextcloud. Ele só é acessível por dentro, via HTTP simples: os bugs de HTTP/2, HTTP/3 e TLS nem chegam lá. Mesmo assim atualizei, de 1.30.6 para 1.30.7.

O script vigia roda no meu servidor de casa, não nos próprios Nextclouds. Ele lê no GitHub as release notes das últimas dez versões do controller e procura nelas a versão do nginx incluída. O núcleo são poucas linhas de Python, só com a biblioteca padrão:

FIXED = ((1, 31, 9), (1, 30, 7))      # primeira mainline / stable corrigida

def fixed(v):
    v = tuple(int(x) for x in v.split("."))
    return v >= FIXED[0] or (v[:2] == FIXED[1][:2] and v >= FIXED[1])

rels = json.loads(get("https://api.github.com/repos/nginx/kubernetes-ingress/releases?per_page=10"))
for r in rels:
    if r.get("draft") or r.get("prerelease"):
        continue
    vers = re.findall(r"NGINX (?:OSS )?(?:to )?(1\.3[0-9]\.[0-9]+)", r.get("body") or "", re.I)
    if any(fixed(v) for v in vers):
        print(f"CORRIGIDO: o controller {r['tag_name']} traz o nginx {vers[0]}")
        sys.exit(0)
sys.exit(1)                            # ainda não

Um pequeno script de shell em volta manda exatamente um e-mail no primeiro acerto e anota isso num arquivo, para que a mesma mensagem não chegue a cada duas horas. O endereço do destinatário fica só na entrada do crontab, não no script:

# crontab -e  (como usuário normal, sem root)
7 */2 * * * WATCH_MAIL_TO=du@example.org $HOME/nginx-ingress-watch/run.sh

Vigias desse tipo são, para mim, ferramentas descartáveis de propósito, para uma única pergunta. Este aqui, porém, nunca teria disparado. O script não está mal programado: ele faz a pergunta errada.

⏱️ Efeito colateral: quanto custa voltar para o HTTP/1.1?

Como um teste end-to-end faz a cada hora uma visita real aos dois Nextclouds (login, abrir um documento do Word no Collabora, logout), pude medir o que desligar o HTTP/2 significa no dia a dia. Com HTTP/1.1 o navegador precisa buscar os muitos arquivos pequenos da interface por várias conexões, em vez de recebê-los agrupados por uma só.

O HTTP/2 ficou desligado em 20 de novembro mais ou menos das 14:55 às 20:40. O teste mede a duração da rodada inteira e, como valor mais importante, o tempo até o Collabora mostrar o documento:

com HTTP/2 (antes)só HTTP/1.1 (7 rodadas)Avaliação
sofie, rodada completa10,2–11,0 s10,8–11,5 scerca de +0,5 s, uns 5 %
sofie, documento carregado2,9–3,2 s3,0–3,4 squase imperceptível
cvjm, rodada completa12,9–25,2 s18,1–44,5 svaria muito
cvjm, documento carregado3,7–6,5 s4,0–13,2 svaria muito

No sofie, onde quase ninguém trabalha, a diferença é pequena: pouco mais de cinco por cento na rodada completa, e no documento em si quase nada. No cvjm os números não dá para atribuir de forma limpa. Já a última rodada com HTTP/2 de manhã levou 25 segundos, e o pico de 44 segundos à tarde cai no horário em que os membros da associação trabalham ali. A rodada das 20h, ainda com HTTP/1.1, voltou a ser tão rápida quanto antes, com 4 segundos para o documento. Por algumas horas, então, o HTTP/1.1 foi um preço aceitável; a longo prazo, mesmo assim, eu não teria querido deixar desse jeito.

🤦 Meu erro de raciocínio: release notes não são um inventário

À noite pensei mais uma vez em compilar o controller eu mesmo, com nginx 1.31.9. O código-fonte é aberto, então baixei no estado da versão 5.8.0. Na primeira linha do Dockerfile estava:

ARG NGINX_OSS_VERSION=1.31.9

Não 1.31.8, como nas release notes. Então baixei a imagem oficial pronta e olhei dentro:

podman run --rm --entrypoint nginx docker.io/nginx/nginx-ingress:5.8.0 -v
# nginx version: nginx/1.31.9

O controller corrigido estava, portanto, publicado desde 18 de novembro, como imagem de contêiner e como Helm chart 2.9.0. Nas release notes consta a linha “Update NGINX to 1.31.8”: era um pull request anterior. A subida para 1.31.9 só veio pouco antes da publicação, num commit coletivo chamado “security hardening and minor bug fixes”. Esse também aparece nas notas, mas sem uma palavra sobre atualizar o nginx.

Meu erro foi tomar as release notes como prova. Elas são um resumo que alguém mantém à mão, não um inventário da imagem. A pergunta “Qual versão do nginx está no controller?” eu deveria ter feito à imagem, não ao texto sobre ela. Meu script vigia tem o mesmo erro, só que automatizado: ele vasculha as release notes e teria esperado até a próxima versão, talvez por semanas.

No fim a solução foi uma única linha: subir o Helm chart de 2.8.0 para 2.9.0 e religar o HTTP/2. Primeiro o sofie, depois o cvjm, e em seguida em cada um um teste end-to-end real com login e documento do Word no Collabora. Os dois funcionaram, e os dois Nextclouds voltaram a falar HTTP/2.

Depois reconstruí o script vigia. A segunda versão não pergunta mais às notas de versão, e sim à receita de build da imagem: cada tag de release contém um Dockerfile, e uma linha diz qual versão do nginx vai para a imagem. Nem é preciso baixar a imagem:

RAW = "https://raw.githubusercontent.com/nginx/kubernetes-ingress/{tag}/build/Dockerfile"

m = re.search(r"^ARG NGINX_OSS_VERSION=(\S+)", get(RAW.format(tag=tag)), re.M)
built = m.group(1)
if fixed(built):
    sys.exit(0)

A saída mostra preto no branco a contradição que eu não tinha visto:

v5.8.0   2026-11-18  image: nginx 1.31.9   (release notes: 1.31.8)
v5.7.1   2026-11-05  image: nginx 1.31.8   (release notes: 1.31.8)
v5.7.0   2026-10-14  image: nginx 1.31.7   (release notes: -)

🎯 Conclusão: confiar é bom, conferir é melhor

  • “Atualizações de segurança automáticas” só valem para repos que também marcam as atualizações de segurança. Para cada repo de terceiros vale a pena olhar os metadados: se falta o updateinfo, nada chega por ali à noite.
  • As falhas mais perigosas muitas vezes estão justamente nos repos de terceiros. nginx, banco de dados, monitoramento: são os serviços que a gente busca de propósito em repos de fabricantes, porque devem estar mais atualizados.
  • Uma manchete é um bom motivo para revisar as próprias suposições. Sem o artigo do Golem, a falha só teria aparecido na próxima atualização manual.
  • Release notes não são um inventário. Se uma falha está fechada numa imagem, só a própria imagem diz: nginx -v no contêiner leva dez segundos.
  • A documentação pode estar errada, inclusive a sua. A frase “é atualizado pelo dnf-automatic” ficou meses na minha documentação de operação e passava uma ótima sensação.

📚 Posts relacionados:

Alguns textos e imagens deste site foram criados com a ajuda de IA ou gerados por IA. Detalhes