DirtyClone
DirtyClone è uno strumento diagnostico proof-of-concept per l'elevazione locale dei privilegi, scritto in C. Prende di mira un percorso di sfruttamento correlato a kernel/XFRM descritto nel sorgente come CVE-2026-43503 ed è destinato esclusivamente a ricerche di sicurezza autorizzate in ambienti controllati.
Panoramica
Questa repository contiene:
L'implementazione attuale esegue i seguenti passaggi di alto livello:
- crea namespace utente e di rete isolati,
- configura il networking di loopback e lo stato/le policy XFRM/IPsec,
- costruisce un payload ESP utilizzando la crittografia AES-CBC,
- tenta la consegna tramite un percorso UDP basato su TEE e un fallback IP grezzo,
- attende che la cache delle pagine del binario SUID di destinazione venga modificata,
- esegue il binario di destinazione se la cache delle pagine è stata modificata.
Avviso importante
Questo strumento è destinato esclusivamente a test di sicurezza autorizzati. Eseguirlo su sistemi senza autorizzazione esplicita può essere illegale e può compromettere l'integrità del sistema.
Compilazione
Installare prima il pacchetto di sviluppo OpenSSL richiesto:
# Debian/Ubuntu
sudo apt-get install libssl-dev
# Fedora
sudo dnf install openssl-devel
# Arch Linux
sudo pacman -S openssl
Quindi compilare il binario:
gcc -o dirtyclone dirtyclone.c -lcrypto -Wall -O2
Utilizzo
Eseguire il programma con:
Argomenti opzionali:
./dirtyclone -q # quiet mode
./dirtyclone -v # verbose mode (default)
./dirtyclone -h # show help
Cosa fa il programma
In fase di esecuzione il programma:
- stampa un banner e verifica se è già in esecuzione come root;
- verifica i dettagli di kernel e architettura e segnala se il sistema sembra rientrare nell'intervallo vulnerabile;
- configura namespace e networking di loopback;
- configura stato/policy XFRM e tenta di aggiungere una regola netfilter TEE;
- mappa il binario SUID di destinazione in memoria e stampa un riepilogo PoC dei byte originali rispetto a quelli attesi;
- invia un pacchetto ESP utilizzando UDP+TEE o un fallback IP grezzo;
- attende che la cache delle pagine rifletta i byte iniettati e quindi tenta di eseguire il binario di destinazione.
Come funziona DirtyClone
L'exploit si basa su un'idea semplice: il programma prepara un payload ESP/XFRM appositamente costruito che induce il kernel a decrittare i dati in una regione di memoria basata sulla cache delle pagine, quindi verifica se i byte del binario SUID di destinazione sono cambiati.
In termini pratici, il programma esegue le seguenti azioni:
- identifica un file di destinazione,
/usr/bin/su, e lo mappa in memoria;
- prepara un piccolo payload contenente byte di shellcode e i metadati ESP necessari;
- crittografa il payload con AES-CBC per poterlo inoltrare nel percorso XFRM/ESP;
- invia il pacchetto attraverso lo stack di rete locale utilizzando UDP assistito da TEE o un fallback IP grezzo;
- monitora la regione mappata per verificare la comparsa dei byte attesi;
- se i byte compaiono, presuppone che il percorso di sfruttamento abbia alterato la cache delle pagine ed esegue il percorso del file di destinazione modificato.
Questo è un flusso proof-of-concept, non un framework generico di elevazione dei privilegi. È pensato per dimostrare il meccanismo dell'exploit e per aiutare a verificare se un kernel di destinazione espone ancora il comportamento vulnerabile.
Esempio di implementazione fittizia
Il seguente esempio semplificato mostra lo stesso concetto ad alto livello:
#include <stdio.h>
#include <string.h>
static int dummy_exploit(unsigned char *target_bytes) {
unsigned char expected[] = {0x31, 0x0f, 0x05};
memcpy(target_bytes, expected, sizeof(expected));
return 0;
}
int main(void) {
unsigned char target[16] = {0};
dummy_exploit(target);
printf("Patched bytes: %02x %02x %02x\n", target[0], target[1], target[2]);
return 0;
}
Il progetto reale usa lo stesso principio, ma confeziona il payload come un pacchetto in stile ESP/XFRM e guida il percorso del kernel attraverso lo stack di rete invece di una semplice copia in memoria.
Procedura dettagliata di sfruttamento
-
Fase di setup
- il programma crea namespace per isolare l'ambiente del processo;
- configura il networking di loopback affinché i pacchetti rimangano locali.
-
Preparazione XFRM
- l'exploit aggiunge stati e policy XFRM che indicano al kernel come elaborare il traffico ESP;
- tenta inoltre di installare una regola TEE affinché il traffico possa essere reindirizzato attraverso il percorso pianificato.
-
Costruzione del payload
- il codice costruisce un piccolo payload in chiaro contenente byte in stile shellcode;
- il payload viene crittografato con AES-CBC utilizzando una chiave di test statica.
-
Fase di consegna
- il programma invia il pacchetto ESP appositamente costruito tramite UDP o IP grezzo;
- il kernel elabora il pacchetto e, su un sistema vulnerabile, scrive i dati decrittati nella regione della cache delle pagine del binario di destinazione.
-
Verifica ed esecuzione
- il codice osserva i byte del file di destinazione e verifica se corrispondono ai byte di shellcode attesi;
- in caso affermativo, tenta di eseguire il binario di destinazione e passare il controllo al percorso del payload iniettato.
Dettagli tecnici
L'implementazione include:
- logica di retry adattiva durante l'attesa di modifiche alla cache delle pagine,
- routine di pulizia registrate tramite
atexit e gestori di segnali,
- esecuzione sicura dei comandi basata su
fork/execvp,
- crittografia AES-CBC tramite le API OpenSSL EVP,
- shellcode adattato all'architettura per x86_64 e AArch64,
- logica duale di consegna sia per il trasporto UDP assistito da TEE sia per l'IP grezzo.
Prerequisiti
Il sorgente richiede un ambiente Linux con:
- GCC o Clang,
- header e librerie di sviluppo OpenSSL,
ip, iptables e modprobe disponibili sul sistema,
- un binario di destinazione in
/usr/bin/su,
- un kernel che possa essere vulnerabile al percorso di sfruttamento descritto.
Comportamento previsto
Il programma è pensato per mostrare un riepilogo PoC diagnostico e quindi:
- modificare con successo la cache delle pagine ed eseguire il binario di destinazione, oppure
- fallire in modo pulito se il kernel è patchato o il percorso di sfruttamento non è disponibile.
Se l'exploit non si attiva, il programma stampa un messaggio chiaro che suggerisce che il kernel è probabilmente patchato.
Sicurezza ed etica
Utilizza questo progetto solo quando:
- possiedi il sistema di destinazione,
- hai esplicita autorizzazione a testarlo,
- operi in un laboratorio o in un ambiente isolato.
Non eseguire mai questo codice su sistemi di produzione o su sistemi che non sei autorizzato a valutare.
Licenza e paternità
L'header del sorgente identifica l'autore come MrAashish0x1 (gl1tch0x1). La repository non include un file di licenza separato, quindi il codice deve essere trattato come materiale di ricerca piuttosto che come software di produzione.