FERRAMENTAS LINUX: Fedora Kubernetes: Entendendo e Mitigando a Vulnerabilidade DoS no SPDY

A vulnerabilidade CVE-2026-35469 afeta o Kubernetes no Fedora através de um ataque DoS via SPDY. Aprenda a verificar se seu cluster está vulnerável, aplique a correção com um script automatizado e implemente mitigações alternativas enquanto não pode atualizar. Guia completo para administradores de sistemas Linux.

O Que Está em Jogo?

Em meados de 2026, foi identificada uma vulnerabilidade de negação de serviço (Denial of Service – DoS) nos componentes , e do Kubernetes.

A falha, registrada como , reside na implementação do protocolo utilizada para streaming de dados entre os componentes do cluster.

A vulnerabilidade permite que um atacante com permissões específicas no cluster — como aquelas que possibilitam port forwarding, execução remota de comandos ou attachment a pods — envie frames SPDY malformados que causam amplificação de memória no processo de parsing.

O resultado? Um único frame malicioso pode esgotar a memória do processo e provocar um crash por out-of-memory (OOM).

O contexto histórico: Esta falha foi corrigida no Fedora através da atualização do pacote kubernetes1.33 para a versão 1.33.13-1.fc43. Mas vulnerabilidades como esta não são novas — e não serão as últimas.

O que importa não é a data, mas como você se prepara para lidar com elas de forma sistemática e repetível.

Como Verificar se Você Está Vulnerável

Antes de aplicar qualquer correção, você precisa saber se seu sistema está exposto. Aqui estão os comandos práticos para verificar a situação no Fedora Linux:

1. Verifique a versão do Kubernetes instalada
bash
# Verifica a versão do pacote Kubernetes instalado dnf list installed kubernetes1.33 # Ou, para uma visão mais detalhada: rpm -q kubernetes1.33

Se a versão exibida for anterior a 1.33.13-1.fc43, seu sistema está vulnerável.

2. Verifique a versão do spdystream (dependência Go)

A vulnerabilidade está na biblioteca github.com/moby/spdystream. Versões anteriores à 0.5.1 são afetadas. Para verificar:

# Se você tem acesso ao código-fonte ou às dependências do cluster
go list -m github.com/moby/spdystream

# Ou, em sistemas com CRI-O:
crio --version
# A versão do CRI-O deve estar usando spdystream >= 0.5.1

3. Verifique se há atualizações disponíveis

# Verifica se a atualização de segurança está disponível
dnf check-update --advisory FEDORA-2026-c2a89ccca5

# Ou verifique todas as atualizações disponíveis
dnf check-update | grep kubernetes

4. Verificação rápida do status do cluster

# Verifica a versão do kubectl (se instalado)
kubectl version --short 2>/dev/null || echo "kubectl não instalado"

# Verifica a versão do kubelet (em cada node)
kubelet --version 2>/dev/null || echo "kubelet não instalado"

Script de Automação para Aplicar a Correção

Abaixo, um script Bash compatível com Fedora Linux que automatiza todo o processo de verificação e aplicação da correção:

#!/bin/bash
# Script: fix-k8s-spdy-dos.sh
# Descrição: Verifica e aplica a correção para CVE-2026-35469 no Fedora
# Compatível com: Fedora 43 e versões posteriores

set -euo pipefail

# Cores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== Verificação e Correção CVE-2026-35469 (SPDY DoS) ===${NC}"

# 1. Verifica se está rodando como root
if [[ $EUID -ne 0 ]]; then
   echo -e "${RED}Este script precisa ser executado como root. Use sudo.${NC}"
   exit 1
fi

# 2. Verifica a versão atual do Kubernetes
echo -e "${YELLOW}Verificando versão atual do kubernetes1.33...${NC}"
CURRENT_VERSION=$(rpm -q kubernetes1.33 2>/dev/null || echo "não instalado")
echo "Versão atual: $CURRENT_VERSION"

if [[ "$CURRENT_VERSION" == *"1.33.13-1.fc43"* ]]; then
    echo -e "${GREEN}✓ Sistema já está atualizado com a versão corrigida.${NC}"
    exit 0
fi

# 3. Verifica se a atualização está disponível
echo -e "${YELLOW}Verificando disponibilidade da atualização...${NC}"
if dnf check-update --advisory FEDORA-2026-c2a89ccca5 &>/dev/null; then
    echo -e "${GREEN}✓ Atualização disponível.${NC}"
else
    echo -e "${RED}✗ Atualização não encontrada. Verifique se os repositórios estão configurados.${NC}"
    exit 1
fi

# 4. Faz backup da configuração atual (se existir)
if [ -d /etc/kubernetes ]; then
    echo -e "${YELLOW}Criando backup da configuração do Kubernetes...${NC}"
    BACKUP_DIR="/root/k8s-backup-$(date +%Y%m%d-%H%M%S)"
    cp -r /etc/kubernetes "$BACKUP_DIR"
    echo -e "${GREEN}✓ Backup criado em $BACKUP_DIR${NC}"
fi

# 5. Aplica a atualização
echo -e "${YELLOW}Aplicando atualização...${NC}"
dnf upgrade --advisory FEDORA-2026-c2a89ccca5 -y

# 6. Verifica se a atualização foi bem-sucedida
NEW_VERSION=$(rpm -q kubernetes1.33 2>/dev/null || echo "falha")
if [[ "$NEW_VERSION" == *"1.33.13-1.fc43"* ]]; then
    echo -e "${GREEN}✓ Atualização aplicada com sucesso!${NC}"
    echo "Nova versão: $NEW_VERSION"
else
    echo -e "${RED}✗ Falha ao aplicar a atualização.${NC}"
    exit 1
fi

# 7. Reinicia os serviços afetados (se estiverem em execução)
echo -e "${YELLOW}Reiniciando serviços do Kubernetes...${NC}"
systemctl restart kubelet 2>/dev/null && echo -e "${GREEN}✓ kubelet reiniciado${NC}" || echo -e "${YELLOW}! kubelet não encontrado ou não está em execução${NC}"
systemctl restart crio 2>/dev/null && echo -e "${GREEN}✓ crio reiniciado${NC}" || echo -e "${YELLOW}! crio não encontrado ou não está em execução${NC}"

echo -e "${GREEN}=== Processo concluído! ===${NC}"
echo "Seu cluster Kubernetes agora está protegido contra CVE-2026-35469."

Como usar:

chmod +x fix-k8s-spdy-dos.sh
sudo ./fix-k8s-spdy-dos.sh

📗 Recomendação de Leitura

Segurança em servidores Linux: Ataque e Defesa (anúncio) -> https://link.amazon/B0hlDkNqk

Se você prefere estudar em português e quer aprender a "pensar como um hacker" para se antecipar a invasões, essa é a pedida! O livro ensina a usar as ferramentas prediletas dos invasores (como Nmap e Netcat) a seu favor, blindando seus sistemas.

Eu ganho uma comissão quando você faz uma compra.

Mitigação Alternativa (Caso Não Possa Atualizar Agora)

Se você não pode aplicar a atualização imediatamente — seja por políticas de change management, dependências de compatibilidade ou ambientes de produção críticos — existem medidas paliativas que reduzem significativamente o risco:

1. Restrição de Acesso via iptables

A vulnerabilidade é explorada através de conexões SPDY nas portas dos componentes. Restringir o acesso a essas portas apenas para IPs confiáveis reduz a superfície de ataque:

# Exemplo: Restringir acesso à porta do kube-apiserver (geralmente 6443)
# para apenas uma sub-rede confiável

# Porta padrão do kube-apiserver
API_PORT=6443

# Substitua pela sua sub-rede confiável
TRUSTED_SUBNET="192.168.0.0/16"

# Permite acesso apenas da sub-rede confiável
iptables -I INPUT -p tcp --dport $API_PORT -s $TRUSTED_SUBNET -j ACCEPT
iptables -I INPUT -p tcp --dport $API_PORT -j DROP

# Para CRI-O (porta 10010 por padrão)
CRIO_PORT=10010
iptables -I INPUT -p tcp --dport $CRIO_PORT -s $TRUSTED_SUBNET -j ACCEPT
iptables -I INPUT -p tcp --dport $CRIO_PORT -j DROP

# Salva as regras (persistente)
iptables-save > /etc/sysconfig/iptables

2. Configuração de Proxy Reverso com Rate Limiting

Utilize um proxy reverso (como NGINX ou HAProxy) na frente do kube-apiserver para limitar a taxa de requisições e filtrar frames malformados:

# /etc/nginx/nginx.conf - Exemplo de rate limiting
http {
    limit_req_zone $binary_remote_addr zone=k8s_api:10m rate=10r/s;
    
    server {
        listen 6443;
        location / {
            limit_req zone=k8s_api burst=20 nodelay;
            proxy_pass https://localhost:6444;  # API rodando em porta alternativa
            proxy_read_timeout 60s;
        }
    }
}

3. AppArmor/SELinux para Restringir o Processo

No Fedora, o SELinux já está ativo por padrão. Você pode criar políticas mais restritivas para o kubelet e CRI-O:

# Verifica o status do SELinux
getenforce

# Aplica políticas mais restritivas (modo enforcing)
setenforce 1

# Verifica logs de negação do SELinux relacionados ao Kubernetes
ausearch -m avc -ts recent | grep -E "kubelet|crio"

4. Monitoramento Intensivo

Enquanto a atualização não é aplicada, monitore ativamente o uso de memória dos processos:

# Script simples de monitoramento
while true; do
    echo "$(date): $(ps aux | grep -E 'kubelet|crio|kube-apiserver' | grep -v grep | awk '{print $2, $4, $11}')"
    sleep 60
done >> /var/log/k8s-memory-monitor.log

Conclusão

A CVE-2026-35469 é mais do que uma simples notícia de segurança — é um estudo de caso sobre como vulnerabilidades em dependências de baixo nível (como o spdystream) podem afetar todo um ecossistema.

A lição aqui não é sobre uma data específica, mas sobre a importância de: