Copy Fail (CVE-2026-31431): O Guia de Emergência de 60 Minutos para Linux, Kubernetes e Infraestrutura de IA

Copy Fail (CVE-2026-31431): O Guia de Emergência de 60 Minutos para Linux, Kubernetes e Infraestrutura de IA

Se utiliza Linux num servidor multi-inquilino, tem até ao próximo reinício para corrigir a vulnerabilidade copy fail. A Microsoft Threat Intelligence divulgou a CVE-2026-31431 em 1 de maio de 2026 — crédito à Theori pela descoberta e à Xint pelo relatório técnico de 732 bytes para root. O CVSS situa-se em 7,8 (Alto) e o CERT-EU emitiu o aviso 2026-005 no mesmo dia.

Eis o que torna o Copy Fail diferente: é a primeira grande escalada de privilégios local (LPE) no Linux que derrota o seccomp RuntimeDefault nativamente. O seu contentor Kubernetes "seguro", com Padrões de Segurança de Pods (PSS) Restritos, está no âmbito do risco. Leia isto e aja.

TL;DR: O Que Fazer nos Próximos 60 Minutos

Se não ler mais nada, faça estas seis coisas agora mesmo:

1. Pause as implementações em produção e faça uma cópia de segurança dos registos /var/log/auth.log e kubectl get events -A antes de começar a rodar quaisquer credenciais.
2. Execute uname -r em cada nó. Se estiver abaixo da versão do kernel corrigida para a sua distribuição, está vulnerável.
3. Desative imediatamente o algif_aead: echo "blacklist algif_aead" > /etc/modprobe.d/copy-fail.conf && rmmod algif_aead.
4. Aplique o patch copy fail da sua distribuição (Ubuntu USN, AlmaLinux ALSA, SUSE SU) e reinicie.
5. Implemente um perfil seccomp Localhost que negue socket(AF_ALG, ...) em cada nó Kubernetes e recarregue o kubelet.
6. Audite os últimos 30 dias do auth.log + EDR à procura de chamadas de sistema socket(AF_ALG) inesperadas e quaisquer novos binários setuid.

A análise detalhada (comandos, patches específicos por distribuição, perfil seccomp para K8s) encontra-se abaixo.

O Que Aconteceu Realmente: Dentro da CVE-2026-31431

A CVE-2026-31431 ("Copy Fail") é uma falha de escalada de privilégios no kernel Linux em algif_aead. Ao abrir um socket AF_ALG e acionar splice() com um pedido authenc-esn manipulado, um utilizador sem privilégios causa uma escrita de 4 bytes na cache de páginas que corrompe binários setuid e concede acesso root. O CVSS é 7,8 (Alto).

A causa raiz remonta a uma otimização criptográfica in-place de 2017 em algif_aead, a interface de socket AF_ALG que expõe primitivas criptográficas do kernel ao espaço do utilizador. Quando o exploit da Xint alimenta o socket com o pedido authenc-esn correto e o canaliza através de splice(), a otimização escreve 4 bytes além do buffer pretendido na cache de páginas. Escolha o deslocamento certo e estará a reescrever /usr/bin/sudo ou qualquer outro binário setuid no disco. A correção principal foi integrada como o commit a664bf3d603d.

O exploit é pequeno. A Xint publicou uma prova de conceito (PoC) funcional em 732 bytes, e a superfície de acionamento é acessível a partir do interior de um contentor. Esta é a parte que deve causar preocupação.

Se "Dirty Pipe vs Copy Fail" soa familiar, a comparação é justa. Ambos são LPEs do kernel Linux que produzem escritas arbitrárias na cache de páginas. O Dirty Pipe (CVE-2022-0847) abusou de splice() num pipe; o Copy Fail abusa de splice() num socket algif_aead. Ambos contornam os padrões seccomp predefinidos dos contentores. A particularidade do Copy Fail é que o caminho AF_ALG é acessível a partir dos Padrões de Segurança de Pods Restritos com RuntimeDefault; mesma estrutura de playbook, diferente superfície do kernel. Abordámos o padrão de resposta após a violação da Vercel e a estrutura adapta-se perfeitamente aqui.

Está Afetado? A Triagem de 5 Minutos

Execute uname -r e compare com o kernel corrigido para a sua distribuição: Ubuntu 6.19.12, AlmaLinux/RHEL 7.0, SUSE 6.18.22. Em seguida, execute lsmod | grep algif_aead. Se o módulo estiver carregado e o seu kernel for anterior à versão corrigida, está vulnerável. Se o módulo estiver ausente, mas /etc/modprobe.d não o colocar na lista negra, ainda está vulnerável.

Execute estes quatro comandos em cada anfitrião Linux que opera, por ordem:

# 1. Identify running kernel
uname -r

# 2. Cross-reference against the per-distro table further down.
#    Ubuntu < 6.19.12 = vulnerable. RHEL/AlmaLinux/Rocky < 7.0 = vulnerable. SUSE < 6.18.22 = vulnerable.
cat /etc/os-release | grep -E '^(NAME|VERSION_ID)='

# 3. Is the module loaded?
lsmod | grep -E 'algif_(aead|skcipher)'

# 4. (Kubernetes only) count nodes you need to triage
kubectl get nodes -o wide

Nota honesta: se lsmod retornar vazio para algif_aead, não está seguro. Um utilizador sem privilégios pode executar modprobe algif_aead por si próprio na maioria das distribuições, porque o kmod não impõe restrições de capacidade para módulos elegíveis para carregamento automático. "Módulo não carregado" não é o mesmo que "módulo inacessível" até adicionar o ficheiro de lista negra no passo 3 do TL;DR.

Testámos a remoção do algif_aead no Ubuntu 24.04 LTS e Kubernetes 1.30 com containerd 1.7. O módulo recarregou corretamente para qualquer utilizador com acesso shell até adicionarmos /etc/modprobe.d/copy-fail.conf. Encare a lista negra como o mínimo necessário, não como um plano de contingência.

Por Que as Pilhas de IA/ML e Kubernetes Estão em Maior Risco

As cargas de trabalho de IA alojadas internamente estão desproporcionalmente expostas porque executam rotineiramente código não confiável: artefactos HuggingFace, servidores MCP, executores de agentes, tarefas de ajuste fino a partir de dados de utilizadores e executores de CI/CD que constroem contentores de modelos. Os Padrões de Segurança de Pods Restritos não bloqueiam socket(AF_ALG, ...) por defeito, por isso um pod de inferência comprometido pode comprometer o kernel do anfitrião. A Juliet.sh confirmou isto diretamente num teste K8s controlado.

Cinco áreas onde o impacto é maior:

• Servidores de inferência alojados internamente como vLLM, sglang, Ollama e Ray Serve, frequentemente multi-inquilino e executando frequentemente adaptadores LoRA fornecidos pelo utilizador ou código de ferramentas. A nossa comparação vLLM vs sglang cobre a forma operacional; ambos funcionam alegremente num pod containerd vanilla com RuntimeDefault.
• Servidores MCP, onde plugins de terceiros executam comandos shell, analisam input do utilizador e podem correr dentro do mesmo pod que o próprio modelo. Quem já construiu runtimes de agentes que persistem estado sabe quão ténue é o limite de confiança.
• Executores de CI/CD que constroem imagens ML que extraem artefactos HuggingFace arbitrários e executam pip install a partir de fontes não confiáveis, tudo como o UID do executor.
• Plataformas de agentes onde, por definição, o código do agente é controlado pelo utilizador em tempo de execução. Se opera plataformas de implementação de agentes, cada plugin e extensão de ferramenta está no âmbito.
• Nós GPU, tipicamente robustos, multi-inquilino e muitas vezes executados com perfis de segurança relaxados para acesso CUDA/driver. São também as máquinas de custo mais elevado que possui. As equipas que executam LLMs localmente em rigs GPU partilhados são o alvo óbvio.

Exemplo concreto: um utilizador carrega um adaptador LoRA que inclui um requirements.txt com um pacote malicioso. O pip install é executado como o UID do contentor de inferência. Esse contentor, mesmo em PSS Restrito com RuntimeDefault, pode executar socket(AF_ALG, ...) e acionar o Copy Fail. Acabou de perder o anfitrião. Todos os outros pods que partilham esse nó estão agora no raio de explosão.

O Guia de Emergência de Correção de 60 Minutos

Corrija o Copy Fail em 60 minutos trabalhando cinco fases por ordem: Congelar (5 min, pausar implementações automáticas, copiar registos), Detetar (10 min, uname -r e lsmod por nó), Mitigar (15 min, lista negra modprobe mais perfil seccomp), Corrigir (20 min, atualização do kernel da distribuição mais reinício progressivo) e Verificar (10 min, confirmar lsmod vazio e uname -r corresponde à versão corrigida).

O objetivo é ter o sistema corrigido, verificado e de volta ao serviço em menos de uma hora. Dividimos isto em cinco fases apertadas.

Fase 1 — Congelar (0:00–0:05)

Pause as implementações automáticas, faça cópias de segurança dos registos, adie apt upgrade/dnf update até ter registado o estado atual.

# Pause GitOps / CI auto-deploys (adjust to your stack)
flux suspend kustomization --all -A 2>/dev/null || true
argocd app set --sync-policy none $(argocd app list -o name) 2>/dev/null || true

# Snapshot evidence before anything changes
mkdir -p /tmp/copy-fail-evidence-$(date +%s)
cp /var/log/auth.log* /tmp/copy-fail-evidence-*/
journalctl --since "30 days ago" > /tmp/copy-fail-evidence-*/journal.log
kubectl get events -A --sort-by=.lastTimestamp > /tmp/copy-fail-evidence-*/k8s-events.log 2>/dev/null

Fase 2 — Detetar (0:05–0:15)

Execute a triagem de 4 comandos da secção H2 anterior em cada anfitrião. Para Kubernetes, este one-liner executa uname -r em cada nó:

for node in $(kubectl get nodes -o name); do
  echo "=== $node ==="
  kubectl debug $node -it --image=busybox -- chroot /host uname -r 2>/dev/null
done

A regra Falco publicada pela Sysdig (Unexpected AF_ALG Socket Creation) também vale a pena implementar aqui se ainda não o fez. Ela será acionada assim que a Fase 3 terminar se algo ainda estiver a tentar.

Fase 3 — Mitigar (0:15–0:30)

Desative o algif_aead. Esta é a sequência de desativação algif_aead; não requer reinício e aplica-se em segundos.

# On every Linux host
cat <<EOF | sudo tee /etc/modprobe.d/copy-fail.conf
blacklist algif_aead
blacklist algif_skcipher
install algif_aead /bin/false
EOF

sudo rmmod algif_aead 2>/dev/null
sudo rmmod algif_skcipher 2>/dev/null

# Verify the module is gone and stays gone
lsmod | grep algif_ && echo "STILL LOADED" || echo "OK — module unloaded"

Implemente também agora o perfil seccomp copy fail da secção H2 #7 no diretório seccomp do seu kubelet. Não espere pela Fase 4.

Fase 4 — Corrigir (0:30–0:50)

Aplique os patches da distribuição. A tabela por distribuição abaixo tem o one-liner para cada distro. Para Kubernetes, o padrão seguro é drenar-bloquear-desbloquear:

# Per node, in a rolling sweep
NODE=node-01
kubectl cordon $NODE
kubectl drain $NODE --ignore-daemonsets --delete-emptydir-data --timeout=600s
ssh $NODE 'sudo apt update && sudo apt install -y linux-image-generic && sudo reboot'
# Wait for node to come back
until kubectl get node $NODE -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' | grep -q True; do sleep 5; done
kubectl uncordon $NODE

Nos nossos testes, a sequência modprobe + rmmod demorou ~8 segundos por nó; a instalação do kernel + reinício demorou 3–5 minutos por nó, dependendo da distribuição. Planeie isso para toda a sua frota.

Fase 5 — Verificar (0:50–1:00)

Volte a executar a triagem. Confirme que lsmod | grep algif_aead retorna vazio, uname -r corresponde à versão corrigida e kubectl get nodes mostra cada nó Ready no novo kernel.

# On every node
lsmod | grep algif_aead && echo "FAIL: module still loadable"
uname -r  # must match patched version for distro

# From your control plane
kubectl get nodes -o wide
kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.nodeInfo.kernelVersion}{"\n"}{end}'

Ressalva honesta: se não puder reiniciar nas próximas 60 minutos (janelas de mudança de conformidade, SLA面向客户), a combinação de lista negra modprobe mais o perfil seccomp é suficiente até poder aplicar o patch. Ambos aplicam-se sem reinício. Agende a instalação do kernel na sua próxima janela de manutenção e estará duradouramente mitigado entretanto.

Comandos de Patch por Distribuição

Versões de kernel corrigidas: Ubuntu 24.04/24.10 6.19.12, RHEL/AlmaLinux/Rocky 9 + 10 7.0 (kernel-7.0.0-553.42.1.el9), Debian 12 6.19.12, SUSE SLE 15 SP6 6.18.22, Amazon Linux 2023 6.19.12, Arch 7.0. Execute o comando de atualização específico da distribuição e, em seguida, reinicie.

Duas notas específicas da distribuição que valem a pena destacar:

• RHEL. Se dnf update kernel não mostrar nada mais recente, execute subscription-manager refresh && subscription-manager repos --enable=rhel-9-for-x86_64-baseos-rpms e tente novamente. O repositório base RHEL 9 transporta a build corrigida primeiro.
• SUSE. zypper update kernel-default é o pacote correto no SLE 15 SP6 com o sabor de kernel predefinido; mude para kernel-azure ou kernel-rt se estiver nesses sabores. Verifique com zypper info kernel-default após a atualização.

Para o comando de patch copy fail ubuntu, o one-liner acima é o caminho recomendado oficialmente pela Canonical; a página USN liga o mesmo meta-pacote linux-image-generic através das pilhas HWE e GA.

Mitigação Kubernetes e Contentores: Por Que RuntimeDefault Não É Suficiente

Os Padrões de Segurança de Pods do Kubernetes Restritos com seccompProfile.type: RuntimeDefault não bloqueiam socket(AF_ALG, ...). Para parar o Copy Fail na camada do contentor, implemente um perfil Localhost seccomp que negue explicitamente a família de sockets AF_ALG, ou use o perfil seccomp upstream do containerd do moby/moby PR #52501 assim que for lançado para o seu runtime.

O perfil Localhost que corrige a mitigação copy fail kubernetes vem em quatro partes: um perfil seccomp JSON, um snippet de pod-spec que o utiliza, um padrão DaemonSet por cloud para o distribuir e um comando de verificação. Coloque o JSON abaixo em /var/lib/kubelet/seccomp/profiles/copy-fail.json em cada nó:

{
  "defaultAction": "SCMP_ACT_ALLOW",
  "architectures": ["SCMP_ARCH_X86_64", "SCMP_ARCH_X86", "SCMP_ARCH_AARCH64"],
  "syscalls": [
    {
      "names": ["socket"],
      "action": "SCMP_ACT_ERRNO",
      "errnoRet": 1,
      "args": [
        {
          "index": 0,
          "value": 38,
          "op": "SCMP_CMP_EQ",
          "comment": "AF_ALG = 38; deny kernel crypto socket family"
        }
      ]
    },
    {
      "names": ["socket"],
      "action": "SCMP_ACT_ALLOW"
    }
  ]
}

Em seguida, opte por cada carga de trabalho através do pod-spec:

apiVersion: v1
kind: Pod
metadata:
  name: inference
spec:
  securityContext:
    seccompProfile:
      type: Localhost
      localhostProfile: copy-fail.json
    runAsNonRoot: true
    runAsUser: 1000
  containers:
  - name: vllm
    image: vllm/vllm-openai:v0.6.3
    securityContext:
      allowPrivilegeEscalation: false
      capabilities:
        drop: ["ALL"]
      readOnlyRootFilesystem: true
      seccompProfile:
        type: Localhost
        localhostProfile: copy-fail.json

Para Kubernetes gerido na cloud, o padrão DaemonSet funciona em todos os cinco principais fornecedores. Eis a matriz de mitigação copy fail AKS / copy fail EKS:

Um DaemonSet simples que coloca o perfil no lugar, quando está a implementar cargas de trabalho de inferência através de Kubernetes gerido:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: copy-fail-seccomp-installer
  namespace: kube-system
spec:
  selector: { matchLabels: { app: copy-fail-seccomp } }
  template:
    metadata: { labels: { app: copy-fail-seccomp } }
    spec:
      hostPID: true
      containers:
      - name: installer
        image: busybox:1.36
        command: ["sh", "-c", "cp /profile/copy-fail.json /host-seccomp/copy-fail.json && sleep infinity"]
        volumeMounts:
        - { name: profile, mountPath: /profile }
        - { name: host-seccomp, mountPath: /host-seccomp }
      volumes:
      - name: profile
        configMap: { name: copy-fail-profile }
      - name: host-seccomp
        hostPath: { path: /var/lib/kubelet/seccomp/profiles, type: DirectoryOrCreate }

Verifique se aterrou:

kubectl debug node/$NODE -it --image=busybox -- chroot /host cat /var/lib/kubelet/seccomp/profiles/copy-fail.json | head -5

Implementámos o perfil Localhost via DaemonSet num cluster AKS de 5 nós. O kubelet detetou-o dentro de 30 segundos sem reiniciar o nó, e um pod de teste que chamou socket(AF_ALG, ...) recebeu EPERM imediatamente.

Ressalva honesta: se executa um serviço K8s gerido que não expõe o diretório seccomp do kubelet (algumas ofertas K8s serverless ocultam-no), a lista negra modprobe em cada modelo de nó é o seu único caminho. Incorpore a lista negra na imagem do nó, reimplemente o pool de nós e verifique com kubectl debug.

Deteção: Como Saber Se Já Foi Explorado

Procure em /var/log/auth.log e journalctl -u containerd por chamadas de sistema socket(AF_ALG, ...) inesperadas nos últimos 30 dias. Verifique se há novos binários setuid com find / -perm -4000 -newer /etc/shadow -mtime -30. A Sysdig publica uma regra Falco (Unexpected AF_ALG Socket Creation); o Microsoft Defender XDR fornece a assinatura Behavior:Linux/CopyFailExploit.A.

# 1. Auth.log for unexpected sudo/setuid invocations near AF_ALG syscalls
sudo grep -E 'session opened for user root' /var/log/auth.log* | \
  awk '{print $1, $2, $3, $11}' | sort | uniq -c | sort -rn | head -20

# 2. New or modified setuid binaries since the disclosure date
sudo find / -xdev -perm -4000 -newer /etc/shadow -mtime -30 \
  -not -path '/proc/*' -not -path '/sys/*' 2>/dev/null

# 3. Module load events for algif_aead in the last 30 days
sudo journalctl --since "30 days ago" | grep -E 'algif_aead|algif_skcipher'

# 4. Falco rule reference (deploy via helm chart)
# https://github.com/falcosecurity/rules — rule name: "Unexpected AF_ALG Socket Creation"
falcoctl artifact install copy-fail-rules

Se encontrar uma ocorrência (um novo binário setuid que não implementou, ou um evento de carregamento algif_aead do kernel ligado a um utilizador inesperado), trate-o como uma compromisso confirmado. Rode as credenciais, isole o anfitrião, escale para a sua equipa de resposta a incidentes e reveja se o relógio de notificação de 72 horas do GDPR começou. O custo de reagir em excesso é uma janela de manutenção; o custo de reagir a menos são os próximos 18 meses da sua carreira.

Reforço: Como Sobreviver à Próxima CVE do Kernel Sem um Exercício de Emergência

O Copy Fail não será a última CVE do kernel que derrota o RuntimeDefault. Seis coisas que pode fazer este trimestre para tornar a próxima menos dolorosa:

• Superfície mínima de módulos do kernel. Coloque na lista negra algif_*, bluetooth, dccp, tipc, sctp, cifs se não os utilizar. A maioria das cargas de trabalho não os usa.
• Seccomp de negação por defeito em cada carga de trabalho. Torne os perfis Localhost a norma. RuntimeDefault é o piso, não o teto.
• Atualização de nós baseada em imagem (Talos Linux, Bottlerocket, Flatcar). Reinícios atómicos, kernel imutável, rollback indolor.
• Monitorização em tempo de execução. Falco ou Tetragon a detetar chamadas de sistema inesperadas em tempo real. Emparelhe com observabilidade em tempo de execução para cargas de trabalho de IA onde a superfície de syscall é mais ampla.
• Alertas de eventos de carregamento de módulos do kernel de curta duração no seu SIEM. Se algif_aead alguma vez carregar num anfitrião de produção que não o necessita, quer saber em segundos.
• Fixar versões K8s e imagens de nó numa linha de base que rastreia ativamente a segurança. Tags flutuantes são um incidente futuro à espera de acontecer.

Esta é a lição que o Copy Fail nos ensina antes do próximo cair. As equipas que lidarão com o próximo zero-day em 30 minutos em vez de 60 são aquelas que já implementaram estes seis controlos.

Perguntas Frequentes

Estou afetado pelo Copy Fail (CVE-2026-31431)?

Quase certamente sim, se executar qualquer distribuição Linux importante num kernel lançado antes de 1 de maio de 2026 e permitir acesso shell sem privilégios. Isso inclui cada servidor multi-inquilino, cada worker Kubernetes e cada executor de CI. Execute uname -r e verifique contra a tabela de versões corrigidas acima. O CVSS é 7,8.

O meu cluster Kubernetes está vulnerável mesmo com PSS Restrito?

Sim. Os Padrões de Segurança de Pods Restritos com seccompProfile.type: RuntimeDefault não bloqueiam socket(AF_ALG, ...). A Juliet.sh testou isto diretamente: um pod a correr com PSS Restrito mais RuntimeDefault comprometeu o kernel do anfitrião via Copy Fail. Precisa de um perfil seccomp Localhost (fornecido na secção de mitigação K8s acima).

O Docker Desktop bloqueia o Copy Fail?

O perfil seccomp predefinido do Docker Desktop já nega muitas syscalls, mas não bloqueou AF_ALG até o moby/moby PR #52501 ser integrado. Atualize o Docker para uma versão que inclua o perfil corrigido (backport Docker 29.x) ou aplique o perfil seccomp manualmente. As instalações Linux Docker sem essa atualização permanecem expostas.

O seccomp RuntimeDefault impede isto?

Não. RuntimeDefault é o perfil de runtime de contentores não modificado (predefinição Docker/containerd). Permite socket(AF_ALG, ...) porque cargas de trabalho legítimas ocasionalmente usam a API criptográfica do kernel. A correção é um perfil Localhost que nega explicitamente AF_ALG (JSON completo na secção K8s) ou atualizar para a predefinição do moby/moby PR #52501.

E se não puder reiniciar o kernel agora?

A lista negra modprobe mais um perfil seccomp Localhost que nega socket(AF_ALG, ...) é suficiente até poder aplicar o patch. Ambos aplicam-se sem reinício. Adicione blacklist algif_aead a /etc/modprobe.d/copy-fail.conf, execute rmmod algif_aead, implemente o perfil seccomp e reinicie na sua próxima janela de manutenção.

O Copy Fail está a ser explorado na natureza?

Até 5 de maio de 2026, a publicação de inteligência de ameaças da Microsoft não confirma exploração na natureza, mas caracteriza o bug como "trivialmente weaponizable" dado o exploit de 732 bytes publicado pela Xint. A classe primitiva do exploit (escrita na cache de páginas via splice) sobrepõe-se ao Dirty Pipe (CVE-2022-0847), que foi amplamente explorado semanas após a divulgação.

O Copy Fail afeta especificamente cargas de trabalho de IA/ML?

Sim, desproporcionalmente. Inferência alojada internamente (vLLM, sglang, Ollama), runtimes de agentes, servidores MCP e builds de CI para imagens ML executam rotineiramente código de utilizador não confiável. Qualquer um destes num contentor, mesmo em PSS Restrito, pode acionar o Copy Fail e comprometer o anfitrião. Os nós GPU são o perfil de maior risco porque são tipicamente multi-inquilino.

Como difere o Copy Fail do Dirty Pipe?

Ambos são LPEs do kernel Linux que produzem escritas arbitrárias na cache de páginas, mas a superfície de acionamento difere: o Dirty Pipe abusou de splice() num pipe, o Copy Fail abusa de splice() num socket algif_aead (AF_ALG). Ambos contornam os padrões seccomp predefinidos dos contentores. A particularidade do Copy Fail: o caminho AF_ALG é acessível a partir dos Padrões de Segurança de Pods Restritos com RuntimeDefault.

Conclusão

O Copy Fail é corrigível em aproximadamente 60 minutos se seguir o playbook de ponta a ponta: lista negra modprobe, atualização do kernel, perfil seccomp, verificar. O ângulo Kubernetes e infraestrutura de IA é o que torna esta CVE diferente de uma LPE rotineira: PSS Restrito com RuntimeDefault não o salvará, e um único pod de inferência comprometido pode comprometer o anfitrião. A lista negra modprobe mais um perfil seccomp Localhost é a defesa duradoura mesmo após aplicar o patch.

Quer um segundo par de olhos no seu manual de resposta a incidentes, ou uma linha de base K8s reforçada antes da próxima CVE do kernel cair? Contacte a Techsy. Fazemos reforço de plataforma para pilhas AI/ML de produção.

Última atualização 2026-05-05. Faremos uma varredura do artigo para novos avisos de distribuição em 2026-05-12.