Ghidra contro le tecniche di evasione e mitigazione nei malware

Nel contesto del reverse engineering dei malware, uno degli aspetti più complessi e stimolanti che affrontiamo è l'identificazione delle tecniche di evasione e mitigazione. Questi tipi di malware sono progettati per eludere l'analisi e la rilevazione da parte degli analisti e degli strumenti di sicurezza. In questa lezione, capiremo come possiamo utilizzare Ghidra per identificare e comprendere queste tecniche, fornendo dettagli tecnici ed esempi pratici che ci aiuteranno a migliorare le nostre capacità di reverse engineering.

Introduzione alle tecniche di evasione e mitigazione con Ghidra

I malware moderni sono costruiti per evitare il rilevamento da parte di antivirus, sistemi di prevenzione delle intrusioni e, in alcuni casi, anche di strumenti di reverse engineering come Ghidra. Le tecniche di evasione possono includere:

Evasione del Debugger

Molti malware verificano la presenza di un debugger chiamando la funzione IsDebuggerPresent che fa parte della libreria kernel32.dll. Se il malware rileva un debugger, può terminare l'esecuzione o cambiare comportamento.

Ecco il codice Assembly estratto con Ghidra:

mov eax, fs:[30h]    ; Ottiene il PEB (Process Environment Block)
movzx eax, byte ptr [eax+2] ; Legge il campo BeingDebugged
test eax, eax
jnz detected_debugger ; Salta se il debugger è presente

Per aggirarlo possiamo forzare eax a 0 per ingannare il controllo. In Ghidra, cerchiamo il riferimento a IsDebuggerPresent e modifichiamo il codice o patchiamo il binario per far sempre restituire 0.

Evasione del Sandbox

Molte sandbox funzionano su macchine virtuali con una sola CPU. Il malware può controllare il numero di processori per rilevare una sandbox.

xor eax, eax
cpuid
shr ebx, 16
cmp ebx, 2    ; Controlla se ci sono almeno 2 core
jl sandbox_detected

Per aggirarlo dobbiamo modificare il valore di ebx in fase di esecuzione e patchare il codice in Ghidra per eliminare il confronto (cmp ebx, 2).

Criptazione del codice

Molti malware criptano il proprio payload per evitare che sia leggibile in fase di analisi. Il codice viene decriptato dinamicamente in memoria prima dell'esecuzione. Un metodo comune è l'uso dell'operatore XOR con una chiave statica.

mov ecx, length
mov esi, encrypted_data
mov edi, decrypted_data
xor_key db 0x55  ; Chiave di XOR
decrypt_loop:
    lodsb         ; Carica un byte cifrato
    xor al, xor_key  ; Decifra con XOR
    stosb         ; Memorizza il byte decriptato
    loop decrypt_loop

Per aggirarlo individuiamo il ciclo di decriptazione in Ghidra. Scriviamo quindi uno script Python per decriptare il payload:

data = bytearray(open("malware.bin", "rb").read())
key = 0x55
decrypted = bytes([b ^ key for b in data])
open("decrypted.bin", "wb").write(decrypted)

Anti-Static Analysis

Tecniche di offuscamento del codice, come l'utilizzo di istruzioni NOP, l'inserimento di codice inutilizzato, o la modifica dinamica del flusso di esecuzione per ostacolare l'analisi statica.

nop
nop
nop
nop
jmp real_code

Per aggirarlo, in Ghidra cerchiamo lunghe sequenze di NOP. Usiamo poi la funzione "Remove NOPs" per semplificare il codice.

Controllo della velocità dell'orologio

Alcuni malware usano RDTSC (Read Time-Stamp Counter) per misurare il tempo di esecuzione di un'istruzione. Se l'esecuzione è troppo lenta (tipico di un ambiente virtualizzato), il malware sospetta una sandbox.

rdtsc
mov ecx, eax  ; Salva il timestamp iniziale
; Esegue un ciclo vuoto
rdtsc
sub eax, ecx
cmp eax, 0x10000  ; Se il valore è troppo alto, rileva una VM
jg sandbox_detected

Per aggirarlo possiamo patchare il valore 0x10000 in 0x00000 per evitare il salto e intercettare l'istruzione rdtsc con un debugger.

Self-Modifying Code

Alcuni malware sovrascrivono il proprio codice in memoria per impedire l'analisi statica.

mov eax, offset self_mod_code
mov byte ptr [eax], 0x90  ; Sovrascrive con NOP
jmp self_mod_code

Per aggirarlo usiamo un debugger con cui eseguire il codice fino alla modifica. Dumpiamo poi la memoria per ottenere il codice deoffuscato.

Algoritmo di Decriptazione con RC4

Alcuni malware utilizzano RC4 per cifrare il proprio payload. RC4 (Rivest Cipher 4) è un algoritmo di cifratura a flusso (stream cipher) sviluppato da Ron Rivest nel 1987 per RSA Security. È noto per la sua velocità ed efficienza. Nel tempo sono state scoperte però diverse vulnerabilità che lo hanno reso insicuro per molti usi.

call rc4_init
call rc4_decrypt
jmp decrypted_code

Per aggirarlo individuiamo le chiamate alla funzione rc4_decrypt in Ghidra. Quindi, analizziamo il flusso del codice per estrarre la chiave.

Le tecniche di mitigazione, d'altra parte, sono usate dai malware per proteggersi dalle contromisure di sicurezza, come la protezione contro la reverse engineering. Esse includono il controllo dell'integrità del codice e la modifica dinamica delle funzioni in tempo di esecuzione per evitare che gli analisti comprendano il comportamento del malware.

Identificazione delle tecniche di mitigazione con Ghidra

Le tecniche di mitigazione sono utilizzate dai malware per difendersi dall'analisi e dalla reverse engineering. Una delle principali tecniche di mitigazione è la criptoanalisi dinamica, in cui il malware cripta il proprio codice per nascondere l'intento malizioso. Questa tecnica è difficile da affrontare ma Ghidra offre diversi strumenti per analizzare il codice criptato.

In molti casi, il malware criptografa il proprio codice al fine di nascondere la sua funzionalità principale. Per esempio, il codice eseguibile potrebbe essere criptato all'interno di una funzione di "loader" che esegue il decriptaggio al momento dell'esecuzione. In Ghidra, possiamo esaminare questa sequenza di operazioni, cercando funzioni di criptazione e decriptazione. Come quelle che utilizzano algoritmi di cifratura simmetrici.

Ecco un esempio di una funzione di decriptazione in Ghidra:

mov eax, [encrypted_data]
mov ebx, decryption_key
call decrypt_function

Se troviamo un blocco di dati criptati, possiamo cercare la funzione di decriptazione e analizzare il codice per cercare il punto in cui il malware esegue la decriptazione e capire come manipolare questi dati per eseguire l'analisi.

Conclusioni: reverse engineering dei malware con Ghidra

Identificare le tecniche di evasione e mitigazione è una parte fondamentale del processo di reverse engineering dei malware. Utilizzando Ghidra, possiamo esplorare in dettaglio le strutture e le funzioni del malware per scoprire come questi software maliziosi cercano di sfuggire all'analisi. Sia che stiamo cercando di aggirare l'evasione del debugger, rilevare l'esecuzione in una sandbox o decriptare codice criptato, Ghidra ci fornisce gli strumenti necessari per analizzare e comprendere queste tecniche avanzate. Con la pratica saremo in grado di riconoscere i segni di queste tecniche e di adattare le nostre strategie di analisi per superarle.