FERRAMENTAS LINUX: Kubernetes 1.23 no openSUSE: Guia completo para corrigir ataques de exaustão de memória via SPDY e HTTP/2

Guia prático para corrigir ataques de DoS via SPDY (CVE-2026-35469) e HTTP/2 (CVE-2026-33814) no Kubernetes 1.23 em openSUSE. Scripts e mitigação real.

Em meados de 2026, foram descobertas duas falhas críticas no Kubernetes 1.23 em distribuições SUSE/openSUSE. Uma delas permite que um único pacote SPDY malicioso aloque gigabytes de memória no processo da API, derrubando seu cluster por esgotamento de memória (OOM).

A outra trava o servidor em um loop infinito de frames HTTP/2, travando o nó e causando paradas generalizadas.

Este artigo não é apenas sobre a data desse aviso. É sobre como você identifica e resolve esse tipo de ameaça para sempre, hoje e nos próximos anos.

Qual é o problema real e por que ele volta a aparecer?

Ambas as falhas estão em componentes de rede do Kubernetes usados por quase todo mundo:

CVE-2026-35469 – moby/spdystream versões ≤ 0.5.0. O parser de frames SPDY/3 não valida tamanhos antes de alocar memória. Um invasor remoto pode enviar um frame controlado que explode o consumo de memória do processo, causando um out‑of‑memory crash em segundos. Pontuação CVSS: 7.1 a 8.7, dependendo da métrica.

CVE-2026-33814 – golang.org/x/net/http2. Ao receber SETTINGS_MAX_FRAME_SIZE com valor 0, o transporte HTTP/2 entra em um loop infinito escrevendo CONTINUATION frames, tornando o servidor inoperante. Pontuação CVSS: 7.5 (alta).

Esse tipo de vulnerabilidade não é raro: parsers de protocolo com alocação sem validação aparecem com frequência. Dominar a correção hoje te prepara para proteger seus clusters contra ameaças similares no futuro.

Como verificar se você está vulnerável

Antes de correr para aplicar patches, confirme a situação exata do seu ambiente.

1. Verifique a versão do Kubernetes instalada

Execute no master ou control plane (qualquer nó com kubectl e acesso ao cluster):

# Ver cliente e servidor
kubectl version --short

# Alternativa sem --short (se disponível)
kubectl version -o yaml

Saída esperada:

Client Version: v1.23.x
Server Version: v1.23.x

Se a versão for anterior à 1.23.17‑150500.3.6.1 (openSUSE Leap 15.5), você está sujeito às falhas

2. Veja o pacote instalado via RPM

No cada nó do cluster (worker e master), verifique qual versão do kubernetes1.23-kubelet está rodando:

rpm -q kubernetes1.23-kubelet

Se o comando não retornar nada, verifique pacotes do cliente:

rpm -qa | grep kubernetes

3. Teste específico de conectividade (opcional, para validação interna)

Para testar ativamente a vulnerabilidade CVE-2026-35469, um script de prova de conceito (PoC) envia um frame SPDY malicioso ao API server:

# (Execute apenas em ambiente de teste - usar sem permissão é crime)
for i in {1..10000}; do curl -k -X POST -H "Content-Type: application/spdy" \
  --data-binary @<(python3 -c 'print("A"*1000000)') \
  https://SEU_API_SERVER:6443/api/v1/namespaces/default/pods >/dev/null & done

Em versões vulneráveis, isso consome memória rapidamente. Se o processo kube-apiserver for reiniciado pelo OOM killer, seu cluster está vulnerável.

Script de automação para aplicar a correção

Este script Bash unificado faz tudo: verifica a versão atual, aplica o patch SUSE, remove pacotes conflitantes e reinicia os serviços. Execute em cada nó do cluster como root.

#!/bin/bash
# Kubernetes Security Patch Automation for openSUSE/SLE
# Fixes CVE-2026-33814 (HTTP/2 loop) and CVE-2026-35469 (SPDY memory amplification)
# Compatible with SUSE Linux Enterprise 15 SP4, openSUSE Leap 15.3/15.4/15.5

set -euo pipefail

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"; }

log "Starting Kubernetes security patch for CVE-2026-33814 and CVE-2026-35469"

# Check current version before patch
if command -v kubectl &>/dev/null; then
    log "Current kubectl client version: $(kubectl version --client -o json 2>/dev/null | jq -r '.clientVersion.gitVersion' 2>/dev/null || kubectl version --client --short 2>/dev/null | cut -d' ' -f3)"
fi
if command -v kubelet &>/dev/null; then
    log "Current kubelet version: $(kubelet --version 2>/dev/null || echo 'unknown')"
fi

# Apply the SUSE security patch
log "Applying SUSE security patch SUSE-2026-2315..."
zypper --non-interactive patch --cve=CVE-2026-33814 --cve=CVE-2026-35469 || \
zypper --non-interactive in -t patch SUSE-2026-2315=1

# Verify patch was applied
log "Verifying patch installation..."
zypper patches | grep -E "CVE-2026-33814|CVE-2026-35469" && log "Patches confirmed installed."

# Restart Kubernetes components if they were updated
log "Restarting Kubernetes services..."
systemctl daemon-reload
systemctl restart kubelet kube-apiserver kube-scheduler kube-controller-manager 2>/dev/null || \
log "Some services not found; restart only those present."

# Final verification
log "✅ Patch process completed."
log "Verify versions: kubectl version"

Como usar:

1. Salve como kubernetes-patch.sh.

2. Dê permissão: chmod +x kubernetes-patch.sh.

3. Copie para todos os nós (master e workers).

4. Execute como root: sudo ./kubernetes-patch.sh.

5. Teste com kubectl get nodes e kubectl version.

Mitigação alternativa caso não possa atualizar agora

Se você não pode atualizar imediatamente (cluster crítico, janela de manutenção longe ou versão EOL sem patch oficial), estas medidas reduzem o risco a níveis aceitáveis.

Opção 1 – Bloquear SPDY e HTTP/2 maliciosos com iptables

Cada API server e kubelet recebe requisições HTTP/2 e SPDY. Bloqueie os padrões de ataque antes que cheguem ao parser vulnerável:

# Criar chain específica
iptables -N K8S_ATTACK_MITIGATION

# Bloquear frame SPDY com payload suspeito (>50KB em POST)
iptables -A K8S_ATTACK_MITIGATION -p tcp --dport 6443 -m string --algo bm --string "Content-Type: application/spdy" -m connbytes --connbytes 50000: --connbytes-dir original --connbytes-mode bytes -j DROP

# Limitar taxa de conexões HTTP/2
iptables -A K8S_ATTACK_MITIGATION -p tcp --dport 6443 -m recent --name http2_attack --update --seconds 60 --hitcount 10 -j DROP
iptables -A K8S_ATTACK_MITIGATION -p tcp --dport 6443 -m recent --name http2_attack --set -j ACCEPT

# Aplicar ao tráfego da API
iptables -I INPUT -p tcp --dport 6443 -j K8S_ATTACK_MITIGATION

# Salvar regras
iptables-save > /etc/iptables.rules

Opção 2 – Restringir SPDY via AppArmor

Crie um perfil AppArmor que impeça o processo do API server de alocar memória excessiva:

cat << 'EOF' > /etc/apparmor.d/k8s-apiserver-mitigation
#include <tunables/global>

profile k8s-apiserver-mitigation /usr/bin/kube-apiserver {
  #include <abstractions/base>

  # Limitar memória via rlimit
  set rlimit memlock <= 4G,
  set rlimit as <= 6G,

  # Impedir socket de rede perigoso (opcional)
  deny network raw,

  # Permitir apenas comunicações essenciais
  /usr/bin/kube-apiserver mr,
  /etc/kubernetes/** r,
  /var/lib/kubelet/** rw,
  /proc/*/mem w,
}
EOF

apparmor_parser -r /etc/apparmor.d/k8s-apiserver-mitigation

Aplique o perfil editando o manifesto do pod do API server (se for estático) ou via anotação em deployments gerenciados.

Opção 3 – Proxy reverso com validação

Coloque um nginx/haproxy na frente do API server para validar requisições SPDY:

# /etc/nginx/nginx.conf - proxy que bloqueia SPDY malicioso
location / {
    # Recusar frames SPDY com tamanho anormal
    if ($http_content_type = "application/spdy") {
        set $spdy_size $http_content_length;
        if ($spdy_size ~* "^[0-9]{6,}$") {
            return 400;
        }
    }
    proxy_pass https://api-server-interno:6443;
}

Conclusão

Falhas em protocolos de rede (SPDY, HTTP/2) são recorrentes no ecossistema Kubernetes. A abordagem apresentada aqui não serve apenas para CVE-2026-33814 e CVE-2026-35469; é um framework reutilizável: