Capitolo 5 — Analisi Malware: Windows e Android

§ 5.1

Metodologia di Analisi Malware

L'analisi malware segue un processo strutturato che bilancia sicurezza dell'analista e profondità dell'analisi. Esistono due approcci principali: analisi statica (esame del codice senza esecuzione) e analisi dinamica (esecuzione controllata in sandbox per osservare il comportamento). Nella pratica professionale si usano entrambi in combinazione.

L'ambiente di analisi deve essere isolato e reversibile: VM con snapshot, rete isolata (host-only o simulata con INetSim), strumenti di monitoring pre-configurati (Process Monitor, Wireshark, Regshot). Mai analizzare malware su sistemi di produzione o connessi a reti aziendali reali.

1

Preparazione ambiente sicuro

VM Windows isolata (snapshot pulito), rete host-only, INetSim per simulare servizi di rete, strumenti di monitoring installati.

2

Analisi iniziale (triage)

Hash del campione, ricerca su VirusTotal, identificazione tipo file (PE32, ELF, APK, script). Estrazione stringhe con strings/FLOSS.

3

Analisi statica

Disassembly e decompilazione con Ghidra/IDA Pro, analisi import/export, identificazione di codice packed o offuscato.

4

Analisi dinamica

Esecuzione in sandbox: monitoraggio filesystem, registry, rete, processi. Tool: Process Monitor, Regshot, ANY.RUN, Cuckoo Sandbox.

5

Correlazione e reporting

IoC extraction (IP, domini, hash, mutex, registry keys), MITRE ATT&CK mapping, report per il team SOC/IR.

🔬

FLOSS

FireEye Labs Obfuscated String Solver: recupera stringhe offuscate dai binari

📊

Detect-It-Easy (DIE)

Identifica packer, compilatori, tipo di file: PE, ELF, .NET, Go binaries

🦠

VirusTotal

Multi-AV scan cloud + sandbox sandbox + behavioral analysis + IoC relations

📸

Regshot

Snapshot registro Windows: diff prima/dopo esecuzione per IoC registry

§ 5.2

Analisi Statica con Ghidra e IDA Pro

Ghidra è il tool di reverse engineering sviluppato dalla NSA e rilasciato open source nel 2019. Supporta decine di architetture (x86, ARM, MIPS, PowerPC, RISC-V, Dalvik) e fornisce decompilatore integrato che trasforma l'Assembly in pseudo-C leggibile. È diventato lo standard de facto per la community grazie alla sua gratuità e all'ecosistema di plugin.

IDA Pro è lo standard industriale a pagamento: disassembler più maturo, supporto superiore per codice offuscato e packed, IDA Python per automazione, Hex-Rays Decompiler (F5) per x86/x64/ARM. Molti analisti usano entrambi in parallelo, sfruttando i punti di forza di ciascuno.

# Ghidra: analisi da CLI (headless)
./analyzeHeadless /tmp/project MalwareProject \
    -import malware.exe \
    -postScript PrintASMScript.java \
    -scriptPath /home/user/scripts

# Estrazione stringhe
strings -a malware.exe | grep -E "(http|cmd|powershell|reg)" | sort -u

# Estrazione import/export (PE)
objdump -x malware.exe | grep -A 20 "IMPORT"
rabin2 -i malware.exe   # radare2
pe-sieve.exe /pid 1234  # process hollowing detection

# FLOSS: stringhe offuscate
floss malware.exe --no-static-strings -o floss_output.txt

💡 Workflow Ghidra per malware PE

1. Importa il binario → analisi automatica (attendere completamento) → 2. Vai a entry point (symbol tree → entry) → 3. Usa F per decompilare ogni funzione → 4. Rinomina variabili e funzioni man mano che ne comprendi il ruolo → 5. Cerca WinAPI sospette: CreateRemoteThread, VirtualAllocEx, WriteProcessMemory (injection), RegSetValue (persistence), InternetOpen (C2).

Le principali aree da analizzare in un malware PE Windows:

💉

Process Injection

VirtualAllocEx + WriteProcessMemory + CreateRemoteThread — pattern classico per DLL injection e shellcode injection

🔁

Persistence

HKCU\Run, Scheduled Tasks, DLL hijacking, COM hijacking, WMI subscriptions

📡

C2 Communication

WinHTTP/WinInet API, raw socket, DNS tunneling, HTTPS beacon con JA3 fingerprint

🔐

Encryption/Obfuscation

XOR rolling key, RC4, AES custom implementation, base64 variante, string decryption routine

§ 5.3

Analisi Dinamica con ANY.RUN

ANY.RUN è una sandbox interattiva cloud-based che permette di eseguire malware in un ambiente Windows virtuale e osservare in tempo reale le sue azioni: processi creati, file modificati, connessioni di rete, chiavi registry modificate. A differenza delle sandbox automatizzate (Cuckoo), ANY.RUN è interattiva: l'analista può cliccare, inserire input e guidare l'esecuzione.

Il report ANY.RUN include: behavior graph (albero dei processi), network indicators (IP, domini, HTTP requests), file IoC (file creati/modificati/eliminati), registry IoC, MITRE ATT&CK matrix con tecniche rilevate, e Suricata/Snort alerts sul traffico di rete.

🏃

ANY.RUN

Sandbox interattiva cloud: report comportamentale completo con MITRE mapping

🐔

Cuckoo Sandbox

Sandbox self-hosted open source: analisi automatizzata con report JSON/HTML

🔍

Process Monitor

Sysinternals: monitoraggio real-time filesystem, registry, network, processi

🌐

INetSim

Simula servizi internet (HTTP, DNS, SMTP) per catturare traffico C2 in lab

# Cuckoo: analisi locale
cuckoo submit --timeout 120 malware.exe
cuckoo submit --package doc /tmp/malicious.docm

# Process Monitor filtri utili (ProcMon)
# Operation is: RegSetValue → persistence registry
# Operation is: WriteFile + Path contains: Startup → persistence file
# Operation is: TCP Connect → C2 beaconing

# INetSim setup
echo "start_service dns" >> /etc/inetsim/inetsim.conf
echo "start_service http" >> /etc/inetsim/inetsim.conf
inetsim

# Wireshark capture durante esecuzione
tshark -i eth0 -w malware_traffic.pcap
# Analisi post-esecuzione
tshark -r malware_traffic.pcap -Y "http || dns || tls"

§ 5.4

Reverse Engineering di APK Android

Un file APK è essenzialmente un archivio ZIP contenente: classes.dex (bytecode Dalvik/ART), AndroidManifest.xml (permessi, componenti, intent filters), resources.arsc (risorse), e librerie native .so (ARM/x86). L'analisi di malware Android inizia sempre dal manifest per capire i permessi richiesti e i componenti esposti.

I malware Android comuni includono: banking trojan (overlay attack, accessibility abuse), spyware (SMS exfil, GPS tracking, audio recording), RAT (Remote Access Trojan), adware aggressivo, e ransomware che cifra i file dell'utente.

# Estrazione e analisi APK
cp malware.apk malware.zip && unzip malware.zip -d apk_contents/
ls apk_contents/

# Decode AndroidManifest.xml (binario → testo)
apktool d malware.apk -o apk_decoded/
cat apk_decoded/AndroidManifest.xml

# Permessi sospetti da cercare nel manifest
grep -E "(READ_SMS|SEND_SMS|RECORD_AUDIO|ACCESS_FINE_LOCATION|READ_CONTACTS|BIND_ACCESSIBILITY_SERVICE)" \
    apk_decoded/AndroidManifest.xml

# Decompilazione DEX → Java con jadx
jadx -d output_src/ malware.apk
jadx-gui malware.apk   # interfaccia grafica

# Strings nel DEX
strings classes.dex | grep -E "(http|/data/|AES|Base64|password|C2)"

⚠ Indicatori malware Android

Red flag nel manifest: BIND_ACCESSIBILITY_SERVICE (keylogging/overlay fraud), BIND_NOTIFICATION_LISTENER_SERVICE (intercettazione OTP), BIND_DEVICE_ADMIN (ransomware, blocco schermo), receiver per BOOT_COMPLETED (persistence al riavvio), permessi READ_SMS + SEND_SMS (banking trojan, intercettazione OTP).

§ 5.5

JADX e MobSF: Workflow Completo

JADX (Java Decompiler for Android) converte il bytecode DEX in codice Java leggibile. Il suo punto di forza è la qualità della decompilazione anche in presenza di offuscamento ProGuard. La GUI JADX permette di navigare il codice, cercare stringhe, cross-reference su metodi e field.

MobSF (Mobile Security Framework) è una piattaforma open source per l'analisi automatizzata di applicazioni mobile: statica (APK, IPA, APPX) e dinamica (richiede emulatore/device). Il report MobSF include: security score, liste di permessi, hardcoded secrets, API insicure, CVE nelle librerie incluse, e tracce di traffico di rete durante l'analisi dinamica.

# MobSF: installazione e avvio
git clone https://github.com/MobSF/Mobile-Security-Framework-MobSF
cd Mobile-Security-Framework-MobSF
./setup.sh  # Linux/Mac
python manage.py runserver

# Upload APK via API MobSF
curl -F 'file=@malware.apk' http://localhost:8000/api/v1/upload \
    -H "Authorization: TOKEN" | jq '.'

# JADX: ricerca pattern sospetti nel sorgente decompilato
grep -r "Runtime.exec\|ProcessBuilder\|getRuntime\|exec(" output_src/ --include="*.java"
grep -r "Cipher.getInstance\|SecretKeySpec\|AESutils" output_src/ --include="*.java"
grep -r "http://\|https://" output_src/ --include="*.java" | grep -v "schemas.android"

# Ricerca hardcoded secrets
grep -rE "(api_key|apikey|secret|password|token|private_key)" output_src/ --include="*.java" -i

1

Upload APK su MobSF

Drag & drop nella web UI o via API REST. MobSF esegue analisi statica automatica in ~2 minuti.

2

Review Security Score e Findings

MobSF assegna un punteggio A-F. Review di: permessi pericolosi, code issues (SQLi, path traversal, crypto weak), manifest anomalie.

3

Analisi approfondita con JADX

Importa in JADX-GUI per analisi manuale: cerca classi con nomi offuscati (a.b.c), traccia il flusso da onCreate() o da receiver onReceive().

4

Analisi dinamica (opzionale)

MobSF con AVD (emulatore): installa APK, intercetta traffico HTTPS con Frida/MobSF proxy, monitora comportamento runtime.

§ 5.6

Analisi del Codice Assembly

La comprensione dell'Assembly x86/x64 è fondamentale per l'analisi di malware Windows in quanto i decompilatori (Ghidra, Hex-Rays) producono pseudo-C non sempre accurato, specialmente in presenza di offuscamento, code virtualization (VMProtect, Themida) o handcrafted assembly.

Le strutture ricorrenti da riconoscere in Assembly includono: prologhi/epiloghi di funzione, chiamate a funzione, loop (jmp/jne patterns), confronti condizionali (cmp + jz/jnz/jl/jg), e le calling convention (cdecl, stdcall, fastcall, System V AMD64 ABI).

; Esempio: routine di decryption XOR (pattern comune nei malware)
; Decompilato da Ghidra/IDA: void decrypt_payload(char* buf, int len, char key)

decrypt_payload:
    push    rbp
    mov     rbp, rsp
    mov     [rbp-0x8],  rdi    ; buf
    mov     [rbp-0xc],  esi    ; len
    mov     [rbp-0x10], edx    ; key (byte)
    mov     DWORD PTR [rbp-0x4], 0  ; i = 0

.loop:
    mov     eax, [rbp-0x4]
    cmp     eax, [rbp-0xc]   ; i < len?
    jge     .end              ; no → exit loop

    mov     rax, [rbp-0x8]   ; buf
    mov     ecx, [rbp-0x4]   ; i
    movsx   edx, BYTE PTR [rax+rcx]  ; buf[i]
    mov     eax, [rbp-0x10]  ; key
    xor     eax, edx          ; buf[i] ^ key
    mov     rdx, [rbp-0x8]
    mov     ecx, [rbp-0x4]
    mov     BYTE PTR [rdx+rcx], al   ; buf[i] = result

    add     DWORD PTR [rbp-0x4], 1   ; i++
    jmp     .loop

.end:
    pop     rbp
    ret

Registri x86-64 fondamentali da memorizzare per l'analisi Assembly:

📦

RAX / EAX / AX / AL

Accumulatore: valore di ritorno da funzione, operazioni aritmetiche

📦

RCX / RDX / R8 / R9

Argomenti 1-4 in Windows fastcall x64 (System V: RDI, RSI, RDX, RCX, R8, R9)

📦

RSP

Stack Pointer: punta alla cima dello stack (cresce verso il basso)

📦

RBP

Base Pointer: frame corrente, usato per accedere a variabili locali e parametri

📦

RIP

Instruction Pointer: indirizzo dell'istruzione corrente (non modificabile direttamente)

🚩

RFLAGS (ZF, CF, SF, OF)

Flag risultato operazioni: usati dai salti condizionali (JZ, JNZ, JC, JO...)

; Pattern: process injection (CreateRemoteThread)
; In IDA/Ghidra vedremo queste WinAPI call in sequenza:

; 1. OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid)
mov     ecx, PROCESS_ALL_ACCESS  ; 0x1F0FFF
xor     edx, edx
mov     r8d, [target_pid]
call    cs:OpenProcess

; 2. VirtualAllocEx(hProcess, NULL, shellcode_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE)
mov     rcx, rax        ; hProcess
xor     rdx, rdx        ; lpAddress = NULL
mov     r8d, shellcode_len
mov     r9d, 0x3000     ; MEM_COMMIT|MEM_RESERVE
push    0x40            ; PAGE_EXECUTE_READWRITE
call    cs:VirtualAllocEx

; 3. WriteProcessMemory(hProcess, remote_addr, shellcode, size, NULL)
; 4. CreateRemoteThread(hProcess, NULL, 0, remote_addr, NULL, 0, NULL)

📌 Risorse per imparare Assembly

Strumenti consigliati per praticare l'analisi Assembly: GDB + pwndbg/peda (debug interattivo Linux), x64dbg / OllyDbg (debug Windows con GUI), Ghidra (disassembly + decompilazione), Cutter (frontend gratuito per radare2), piattaforme CTF come pwn.college e HackTheBox per esercitarsi su binari reali.