BlackPill

BlackPill è un rootkit Linux furtivo realizzato in Rust.

Caratteristiche

Il rootkit è composto da più moduli (parlando di moduli Rust, non moduli del kernel):

• evasione della difesa: nascondere file, processi, connessioni di rete, ecc.
• hooking: intercettare syscall e IDT
• hypervisor: creare una macchina virtuale per eseguire codice malevolo
• persistenza: rendere il rootkit persistente dopo il riavvio e resiliente alla soppressione
• utilità: varie utilità

L'architettura appare come segue:

Ed ecco come il codice malevolo viene eseguito dal C2 all'ospite VM:

Il C2 invia mnemonici x86_64 assemblati al rootkit, che poi li invia all'ospite VM per eseguirli. L'ospite VM è isolato dall'host e può essere utilizzato per eseguire codice malevolo.

Il kernel non vede i pacchetti malevoli in arrivo poiché vengono filtrati dal programma eBPF XDP e inviati al modulo LKM, mentre i pacchetti in uscita vengono modificati dal programma eBPF TC.

[!IMPORTANTE]
Questo progetto è ancora in fase di sviluppo. Non tutte le funzionalità sono funzionanti!
Sentiti libero di segnalare problemi o inviare richieste pull.

Hooking

L'hooking è una capacità fondamentale del rootkit, implementata utilizzando kprobes nel kernel Linux. Questa tecnica intercetta e reindirizza l'esecuzione delle funzioni di sistema per monitorare o modificare il loro comportamento. Nel contesto di questo rootkit, kprobes fornisce un potente meccanismo per interagire con le funzioni del kernel senza alterare direttamente il codice sorgente.

Evasione della difesa

Per garantire la furtività, il rootkit impiega due meccanismi primari anti-rilevamento:

1. Rimozione del Modulo dalla Lista dei Moduli del Kernel
   Quando un modulo del kernel viene caricato, viene aggiunto alla lista dei moduli del kernel, visibile tramite strumenti come lsmod o /proc/modules. Per prevenire il rilevamento:

   • Il rootkit si rimuove manualmente da questa lista.
   • Nonostante la rimozione dalla lista, il modulo rimane operativo, consentendo la continua esecuzione delle sue funzionalità.

2. Hooking della funzione filldir64 per Nascondere una Directory Specifica
   Per nascondere i file utilizzati dal rootkit, viene implementato un hook sulla funzione filldir64. Questa funzione viene invocata quando un processo legge il contenuto di una directory (ad es. tramite le syscall getdents o readdir).

   • Processo di Hooking:
     • Il rootkit intercetta la funzione filldir64 utilizzando kprobes.
     • Durante l'esecuzione, il gestore ispeziona le voci della directory restituite all'utente.
     • Se una voce corrisponde alla directory /BLACKPILL-BLACKPILL (utilizzata per memorizzare file critici del rootkit), viene filtrata e non restituita all'utente.
     • Tutte le altre voci della directory vengono restituite normalmente, garantendo trasparenza per gli strumenti in spazio utente.

3. Utilizzo di programmi eBPF XDP e TC per Modificare il Traffico di Rete In entrata e In uscita
   Per normalizzare le nostre comunicazioni di rete malevole, utilizziamo programmi eBPF XDP (eXpress Data Path) e TC (Traffic Control). In questo modo, possiamo:

   • Intercettare pacchetti specifici in entrata (ingress) con il programma XDP al livello di rete più basso, abbinando la firma del payload TCP costruita dal nostro C2, che poi reindirizziamo a una mappa BPF personalizzata per l'elaborazione VM/LKM.
   • Intercettare pacchetti specifici in uscita (egress) con il programma TC, abbinando i pacchetti TCP generati dalla VM/LKM, che poi modifichiamo sovrascrivendo il loro payload con i dati di risposta del nostro C2. I pacchetti originali vengono automaticamente ritrasmessi da TCP, mantenendo l'aspetto di traffico legittimo.

Hypervisor

Il nostro semplice hypervisor è stato implementato seguendo questi passaggi:

1. Configurazione iniziale del sistema

   • Abilitare le estensioni di virtualizzazione hardware (Intel VT-x o AMD-V) nel BIOS/UEFI (il rootkit non lo fa, deve essere abilitato prima).
   • Configurare i registri di controllo (CR0, CR4 e IA32_EFER) per passare alla modalità VMX (Virtual Machine Extensions (Intel)) o SVM (Secure Virtual Machine (AMD)).

2. Entrata in modalità VMX o SVM

   • Inizializzare le strutture dati specifiche per la virtualizzazione (VMCS per Intel o VMCB per AMD).
   • Programmare le caratteristiche del processore, come le uscite VM, per gestire le interazioni tra ospite e host.

3. Gestione delle transizioni tra Host e Ospite

   • Configurare i punti di ingresso e uscita per le macchine virtuali (VM entry/exit).
   • Implementare la logica per intercettare le chiamate di sistema sensibili effettuate dall'ospite e analizzarne gli effetti.

4. Creazione del Sistema Ospite

   • Allocare memoria per l'ospite e inizializzare le sue risorse (registri, stack, ecc.).

5. Comunicazione

   • Utilizzare canali di comunicazione tra il rootkit e l'hypervisor per trasmettere comandi o dati.

Persistenza

La persistenza è una capacità critica di qualsiasi rootkit, che gli consente di mantenere il controllo sul sistema di destinazione anche dopo un riavvio.
Nella sua implementazione attuale, il meccanismo di persistenza dimostra la sua funzionalità creando un file di prova nel filesystem utilizzando il comando /bin/touch. Questa azione placeholder mostra la capacità del rootkit di eseguire operazioni privilegiate e può essere estesa per implementare strategie di persistenza più avanzate.

Ora è inutile poiché non è la nostra priorità creare un rootkit di livello APT, ma piuttosto fare più ricerca su concetti meno visti.

Configurazione dell'ambiente di sviluppo

Prima di compilare il nostro rootkit sono necessari diversi passaggi. L'ambiente di sviluppo è composto da:

• un'immagine Alpine Linux che fornisce strumenti essenziali
• un kernel compilato personalizzato con Rust attivato
• una macchina virtuale QEMU accelerata da KVM

Inizia clonando il repository e i suoi sottomoduli shallow:

git clone [email protected]:DualHorizon/blackpill.git --recursive --depth 1

Dipendenze importanti

Su una distribuzione basata su Arch:

sudo pacman -S qemu-base qemu-desktop docker grub

Kernel Linux

Su una distribuzione Linux basata su Arch, installa Rust e altre dipendenze:

sudo pacman -S rust rust-src rust-bindgen
sudo pacman -S clang lld llvm

Poi avremo bisogno dei sorgenti Rust e di bindgen:

rustup component add rust-src clippy rustfmt
cargo install --locked bindgen-cli

Assicurati di poter iniziare a compilare il tuo kernel con Rust eseguendo nella cartella linux/:

$ cd blackpill
$ pushd linux
$ make LLVM=1 rustavailable
Rust is available!
$ popd

Avvia l'attività di configurazione iniziale che configura e compila il kernel:

make first-time-setup

[!IMPORTANTE]
Se ti vengono chieste opzioni personalizzate, premi Invio ogni volta.

Rootkit

Puoi compilare il modulo del kernel Rust (out-of-tree) con:

make