Analisi forense della RAM con Volatility
Importante: conservare sempre un’immagine della memoria originale e verificare l’integrità dell’immagine prima di ogni analisi.
Introduzione
Una parte importante dell’analisi malware è l’analisi della memoria ad accesso casuale (RAM). L’analisi della RAM aiuta a identificare processi in esecuzione, attività di rete, connessioni aperte e artefatti non persistenti che potrebbero non comparire sul disco. Questo articolo descrive l’uso dello strumento open source Volatility per l’analisi della memoria volatile.
Volatility supporta analisi di sistemi a 32/64 bit e analizza immagini di Windows, Linux, macOS e Android. Il framework è implementato in Python e può essere eseguito su Linux e Windows. Può analizzare crash dump, raw dumps e snapshot di macchine virtuali (VMware, VirtualBox). Le tecniche di estrazione sono indipendenti dal sistema investigato e forniscono visibilità completa sullo stato runtime della macchina.
Definizione veloce: Volatility è un toolkit per estrarre artefatti da dump di memoria per scopi di risposta agli incidenti e analisi forense.
Cosa vedremo in questa guida
- Come identificare il profilo della memoria (imageinfo)
- Come enumerare processi (pslist, pstree)
- Come trovare e dumpare codice sospetto (malfind)
- Come ricostruire connessioni di rete (netscan)
- Come leggere la cronologia dei comandi (cmdscan)
- Validazione dei campioni con servizi online e scanner AV locali
- Metodologia, checklist e criteri di accettazione per un’indagine ripetibile
Supporto dei formati di memoria
Le seguenti tipologie di immagine sono supportate dall’ultima release di Volatility:
- Raw/Padded Physical Memory
- Firewire (IEEE 1394)
- Expert Witness (EWF)
- Crash Dump di Windows a 32 e 64 bit
- Ibernazione di Windows a 32 e 64 bit
- File MachO a 32 e 64 bit
- Core dump di VirtualBox
- VMware Saved State (.vmss) e Snapshot (.vmsn)
- Formato HPAK (FastDump)
- Dump di memoria QEMU
Installazione
Volatility è disponibile per Windows, Linux e macOS. Per Windows e macOS sono disponibili eseguibili standalone; su Ubuntu 16.04 LTS si può installare con il comando seguente:
apt-get install volatility
Verifica di integrità dell’immagine
Prima di ogni analisi bisogna calcolare e registrare l’hash dell’immagine acquisita per garantire che l’immagine non venga alterata. Nell’esempio qui sotto è mostrato l’MD5 calcolato per la memoria estratta dal sistema compromesso:
MD5: ee043142485a83f4d49a3a7899408500Annotare hash MD5/SHA1/SHA256 nei metadati del caso.
Analisi della memoria con Volatility
In questo tutorial si esegue l’analisi di un dump di memoria raw acquisito da una macchina Windows. L’obiettivo è identificare processi malevoli residenti in memoria e raccogliere artefatti utili per la risposta all’incidente.
Identificare i profili suggeriti (imageinfo)
Per prima cosa si determina quali profili Volatility suggerisce per l’immagine:
"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" imageinfo -f memdump3.raw
Nell’esempio i profili suggeriti sono:
Win7SP0x86 , Win7SP1x86Scegliere il profilo corretto può richiedere tentativi; usare il profilo che produce più risultati coerenti (ad es. PSList con campi corretti).
Elencare i processi in esecuzione (pslist)
Una volta noto il profilo, si elenca la lista dei processi:
"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 pslist -f memdump3.raw
part-1
part-2
Il plugin pslist mostra i processi trovati nella memoria. Nell’esempio emergono processi con nomi sospetti come “0KqEC12.exe” e più istanze di “iexplore.exe”. Anche “rdpclip.exe” potrebbe essere anomalo se non atteso nel contesto.
Struttura padre/figlio dei processi (pstree)
Per ricostruire le relazioni di parentela tra processi:
"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 pstree -f memdump3.raw
part-1
part-2
L’output mostra PID e PPID: in molti casi il malware inietta codice in processi legittimi (es. explorer.exe) per persistere e confondere l’analisi. Identificare il processo genitore aiuta a capire il vettore di esecuzione.
Ricerca e dump di codice sospetto (malfind)
Il plugin malfind individua regioni di memoria sospette che potrebbero contenere codice iniettato o DLL non legittime. Per dumpare il contenuto di un processo si usa:
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-1120 -p 1120 -f memdump3.rawProcess ID: 1120 (svchost.exe) — in questo caso malfind non ha trovato DLL sospette.
Process ID: 1788 (rdpclip.exe) — anche qui malfind non ha estratto nulla di sospetto.
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-1788 -p 1788 -f memdump3.raw
Process ID: 2104 (explorer.exe) — in questo caso malfind ha estratto sezioni interessanti dalla memoria del processo.
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2104 -p 2104 -f memdump3.raw
Output: dump delle DLL/segmenti estratti dalla memoria del processo.
Process ID: 2240 (0kqEC12.exe) — processo con nome non standard per Windows, soggetto ad ulteriore analisi:
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2240 -p 2240 -f memdump3.raw
Processi con nome simile a “iexplore.exe” (ma non sempre legittimi) sono stati analizzati con malfind per estrarre i payload presenti in memoria:
Esempi di comandi per PID 2840, 2364, 3728 (stesse opzioni, differente -p):
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 malfind -D E:\output/pid-2840 -p 2840 -f memdump3.raw
Scansione dei dump estratti con motori AV e servizi online
Dopo aver estratto i binari/segmenti dalla memoria, è buona pratica verificarli con scanner locali e servizi online (VirusTotal, Payload Security, Hybrid Analysis) per ottenere indicazioni sul tipo di minaccia.
Windows Defender
Lo scanning dei dump con Windows Defender ha identificato il campione come “Trojan:Win32/EyeStye.N” e “Trojan:Win32/EyeStye.plugin”.
Descrizione delle famiglie: questi trojan registrano sequenze di tasti, monitorano attività Internet, rubano credenziali e possono spedire dati a un attaccante remoto. Possono effettuare code injection e utilizzare rootkit per nascondersi. EyeStye può iniettare codice in processi come cmd.exe ed explorer.exe.
L’analisi mostra che codice malevolo è stato iniettato in explorer.exe, che risulta essere il genitore di alcune istanze sospette di iexplore.exe.
Malwarebytes
Malwarebytes ha identificato i dump estratti come “Trojan.Grabber”.
Questi riscontri confermano l’ipotesi di compromissione in memoria.
Cronologia dei comandi (cmdscan)
Il plugin cmdscan consente di leggere la cronologia dei comandi presenti nella memoria della shell:
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 cmdscan -f memdump3.raw
L’output mostra che l’attaccante ha eseguito comandi che hanno lanciato eseguibili come “iexplorer.exe” e “ieplore.exe” (varianti con typo spesso usate per confondere). Un’altra stringa sospetta trovata è “_lt112.spn”.
Ricerche online sul file _lt112.spn
La stringa “_lt112.spn” è stata cercata su servizi di malware analysis online e corrisponde a campioni analizzati su malwr/hybrid-analysis, indicando che quel nome è associato a campioni malevoli:
Questi riferimenti corroborano l’analisi locale.
Connessioni di rete (netscan)
Le connessioni di rete residue in memoria possono essere ricostruite con netscan:
E:\>"E:\volatility_2.4.win.standalone\volatility-2.4.standalone.exe" --profile=Win7SP0x86 netscan -f memdump3.raw
Part-1
Part-2
L’output mostra che processi denominati “iexplore” avevano connessioni attive, inclusi flussi verso porta 80 (HTTP). Questo può indicare comunicazione con server di comando e controllo o esfiltrazione di dati.
Conclusioni dell’analisi tecnica
L’analisi dettagliata della memoria indica una compromissione: codice malevolo è iniettato in explorer.exe e più processi con nomi simili a processi di sistema (iexplore/iexplorer/ieplore) sono attivi e con connessioni di rete. I dump estratti sono stati identificati come trojan (famiglie EyeStye / Grabber) da scanner AV e servizi online.
Metodologia forense consigliata (mini-methodology)
- Acquisizione: creare dump di memoria con strumenti appropriati (DumpIt, FTK Imager, WinPMEM) e calcolare hash (MD5/SHA1/SHA256).
- Conservazione: conservare l’originale read-only e lavorare su copie.
- Profilazione: eseguire imageinfo per suggerimenti profilo.
- Enumerazione processi: pslist, pstree.
- Ricerca codice: malfind, dlllist, apihooks.
- Rete: netscan, connscan.
- Cronologia e artefatti: cmdscan, consoles, memdump di processi sospetti.
- Verifica: analizzare i dump con servizi online e scanner locali.
- Documentazione: salvare prove, timestamp e log delle attività analitiche.
- Contenimento e hardening: isolare host, aggiornare policy, rimuovere persistenza.
Checklist operativa per ruolo
Investigatore forense:
- Verificare hash immagine e catena di custodia
- Determinare profilo adatto
- Eseguire pslist/pstree
- Eseguire malfind su processi sospetti
- Archiviare dump estratti con metadati
Analista malware:
- Eseguire analisi statica sui dump estratti
- Sottoporre campioni a VirusTotal/Hybrid Analysis
- Identificare tecniche di evasione (code injection, rootkit)
- Valutare persistenza e meccanismi di comando e controllo
Responder / Team operativo:
- Isolare l’host dalla rete se attivo
- Valutare necessità di ripristino/rollback
- Cambiare credenziali potenzialmente esfiltrate
Quando l’approccio potrebbe fallire (controesempi)
- Dump incompleto o corrotto: molte tecniche falliscono se l’immagine è parziale.
- Tecniche avanzate di offuscamento in memoria: alcuni malware cifrano o comprimono payload in memoria rendendo malfind meno efficace.
- Profilo sbagliato: usare un profilo errato può nascondere strutture di processo e portare a falsi negativi.
- Processi ephemeral: processi lanciati e terminati velocemente potrebbero non essere presenti nel dump.
Alternative e strumenti complementari
- Rekall: fork/alternativa a Volatility con focus su scalabilità e plugin moderni.
- WinPMEM / DumpIt: strumenti per acquisire dump di memoria su Windows.
- Magnet RAM Capture: strumento gratuito per acquisizione RAM.
- LiME: acquisizione della memoria per Linux/Android.
- Bulk extractor, strings, YARA: strumenti per analisi secondaria sui dump estratti.
Criteri di accettazione
Per considerare valida l’analisi del caso:
- Immagine acquisita e hash registrati.
- Profilo scelto e comandi eseguiti documentati.
- Dump estratti per ogni processo sospetto archiviati con metadati.
- Risultati di scansioni AV e riferimenti a servizi online salvati.
- Report che descrive persistenza, vettore e raccomandazioni per mitigazione.
Test cases / casi di verifica suggeriti
- Caso 1: immagine con processo iniettato in explorer.exe; malfind deve produrre dump.
- Caso 2: immagine con exploit temporaneo; pslist non mostra sempre la presenza — verificare con timeline.
- Caso 3: immagine Linux con processo nascosto; usare plugin specifici per Linux.
Decision tree per risposta rapida (Mermaid)
flowchart TD
A[Acquisizione immagine] --> B{Immagine valida?}
B -- No --> C[Ripetere acquisizione / controllare strumenti]
B -- Sì --> D[imageinfo]
D --> E{Profilo coerente?}
E -- No --> F[Provare profili alternativi]
E -- Sì --> G[pslist + pstree]
G --> H{Processi sospetti?}
H -- No --> I[Analisi artefatti di rete e file]
H -- Sì --> J[malfind su PID sospetti]
J --> K{Dump estratti?}
K -- Sì --> L[Scanner AV / servizi online]
K -- No --> M[Ulteriori plugin: apihooks, dlllist]
L --> N[Documentare e isolare host]
N --> O[Cleanup / ripristino / monitoraggio]Maturità dell’approccio (heuristica)
- Livello 1 (Base): esecuzione di pslist e netscan per evidenze veloci.
- Livello 2 (Intermedio): uso esteso di malfind, cmdscan e verifica con scanner AV.
- Livello 3 (Avanzato): analisi manuale dei dump con disassemblatori, ricostruzione timeline e correlazione con log di rete.
Sicurezza e privacy
Note sulla privacy: durante l’analisi si possono estrarre dati sensibili (password, token, PII). Trattare tali informazioni conformemente a policy interne e normative locali (es. GDPR) limitando l’accesso e cifrando gli artefatti conservati.
Hardening e mitigazioni consigliate
- Aggiornare sistema e software all’ultima versione disponibile.
- Configurare EDR/AV con telemetria completa e regole per individuare process injection.
- Disabilitare o limitare l’uso di macro e software non necessari.
- Implementare whitelisting dove possibile.
- Monitorare traffico su porte comuni e DNS per comunicazioni sospette.
Sommario
- Volatility è uno strumento fondamentale per l’analisi della memoria volatile.
- Plugin chiave: imageinfo, pslist, pstree, malfind, cmdscan, netscan.
- Estrarre e analizzare dump da processi sospetti è essenziale per confermare compromissioni in memoria.
- Integrare i risultati con servizi online e scanner AV per migliorare le evidenze.
Note finali: mantenere procedure ripetibili e documentare ogni passo per preservare la catena di custodia e la riproducibilità dell’analisi.
Riferimenti
- http://www.volatilityfoundation.org/24
- https://www.microsoft.com/security/portal/threat/encyclopedia/entry.aspx?Name=Trojan:Win32/EyeStye.N
Fatto chiave: Volatility supporta analisi di immagini raw, EWF, crash dump Windows, VMware/VirtualBox e QEMU.
Glossario (1 riga ciascuno):
- Dump di memoria: file che rappresenta lo stato della RAM in un dato istante.
- Profile (Volatility): configurazione che descrive la struttura delle tabelle di sistema per una certa versione OS/architettura.
- Malfind: plugin Volatility che cerca regioni di memoria sospette.
Sommario punti chiave:
- Conservare l’immagine originale e gli hash.
- Usare plugin Volatility per trovare e dumpare codice iniettato.
- Verificare i campioni estratti con servizi esterni e scanner locali.
