Analisi forense digitale

Livello: Intermedio → Avanzato
Obiettivo: Acquisire prove digitali in modo forense-corretto, analizzare disco e memoria, ricostruire timeline di un incidente.

---

1. Principi Fondamentali della Forensics

1.1 Chain of Custody (Catena di Custodia)

Ogni prova digitale deve essere gestita in modo da garantirne l'integrità e la tracciabilità. Qualsiasi errore invalida la prova in sede legale.

Regola d'oro: Non modificare MAI il sistema originale. Lavora sempre su copie.

Documenta:

• Chi ha acquisito la prova, quando e dove
• Hash dell'immagine acquisita (SHA-256)
• Tool e versioni usati
• Ogni accesso alle prove

1.2 Ordine di volatilità

I dati si perdono con velocità diversa. Acquisire prima quelli più volatili:

1. Registri CPU e cache                  (nanosecondi)
2. Memoria RAM                           (perduta all'avvio)
3. Traffico di rete attivo               (secondi)
4. Processi e connessioni in corso       (minuti)
5. Disco (non volatile)                  (persistente)
6. Log remoti, backup                    (molto persistente)

1.3 Hashing per integrità

# SHA-256 del file/immagine acquisita
sha256sum /path/to/evidence.img

# MD5 (meno sicuro ma ancora usato)
md5sum evidence.img

# Verifica dopo il trasporto
sha256sum --check checksums.txt

# Creare file di hash per più file
sha256sum * > SHA256SUMS
sha256sum -c SHA256SUMS  # verifica tutto

---

2. Acquisizione Forense del Disco

2.1 Acquisizione con dd

# Identificare i dischi
lsblk
fdisk -l
# Supponiamo: disco target = /dev/sdb

# IMPORTANTE: montare in sola lettura prima di tutto
sudo mount -o ro /dev/sdb /mnt/evidence

# Acquisizione bit-per-bit con dd
sudo dd if=/dev/sdb of=/mnt/usb_esterno/evidence.img bs=4096 conv=noerror,sync status=progress

# dd con hash contestuale
sudo dd if=/dev/sdb bs=4096 conv=noerror,sync | tee evidence.img | sha256sum > evidence.sha256

# Verificare
sha256sum evidence.img
cat evidence.sha256

2.2 Acquisizione con dcfldd (versione forense di dd)

sudo apt install dcfldd

sudo dcfldd if=/dev/sdb of=evidence.img \
  hash=sha256 \
  hashlog=evidence.sha256 \
  bs=4096 \
  conv=noerror,sync \
  hashwindow=1G  # hash ogni GB

2.3 Acquisizione con ewfacquire (formato E01 — standard forense)

sudo apt install libewf-dev ewf-tools

sudo ewfacquire /dev/sdb
# Chiede: caso, investigatore, note, formato compressione
# Output: evidence.E01, evidence.E02, ... (suddiviso automaticamente)

# Montare immagine E01 in lettura
ewfmount evidence.E01 /mnt/ewf/
sudo mount -o ro,noatime /mnt/ewf/ewf1 /mnt/evidence

2.4 Write Blocker

In ambiente fisico si usa un write blocker hardware tra il disco e il computer. Su Linux si può simulare via software:

# Blocco scrittura su dispositivo
sudo hdparm -r1 /dev/sdb    # imposta read-only
sudo blockdev --setro /dev/sdb

# Verifica
sudo blockdev --getro /dev/sdb   # ritorna 1 se read-only

---

3. Analisi del Filesystem

3.1 Sleuth Kit (TSK) — Suite CLI forense

# Informazioni sull'immagine
mmls evidence.img         # layout partizioni
fsstat -o 2048 evidence.img   # info filesystem (offset dalla partizione)

# Listare file e directory (inclusi cancellati)
fls -r -o 2048 evidence.img          # ricorsivo, tutte le partizioni
fls -r -d -o 2048 evidence.img       # solo file cancellati
fls -r -o 2048 evidence.img | grep "\.doc"  # cerca .doc

# Estrarre un file tramite inode
icat -o 2048 evidence.img 12345 > recovered_file.doc

# Timeline di tutte le attività del filesystem
fls -r -m "/" -o 2048 evidence.img > bodyfile.txt
mactime -b bodyfile.txt -d > timeline.csv   # formato CSV
mactime -b bodyfile.txt -d "2024-01-01" "2024-01-31" > january.csv

3.2 Autopsy — GUI forense

Autopsy è l'interfaccia grafica di Sleuth Kit, usata professionalmente:

sudo apt install autopsy
autopsy  # avvia su http://localhost:9999

Workflow in Autopsy:

1. New Case → inserisci nome, numero caso, investigatore
2. Add Data Source → seleziona immagine disco
3. Ingest Modules → seleziona analisi da eseguire:
   • Hash Lookup (confronta con database NSRL)
   • Keyword Search
   • Recent Activity (browser history, installed programs)
   • Email Parser
   • Embedded File Extractor
4. Analisi risultati per categoria

3.3 Recupero file cancellati

# PhotoRec — recupero file da partizioni
sudo apt install testdisk
photorec evidence.img    # GUI testuale interattiva

# Foremost — recupero basato su file signature (magic bytes)
sudo foremost -i evidence.img -o /tmp/recovered/
# Cerca per tipo: -t jpeg,pdf,doc,zip

# Scalpel
sudo apt install scalpel
sudo scalpel evidence.img -o /tmp/scalpel_out/

# Analisi manuale con strings
strings evidence.img | grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]" > emails.txt
strings evidence.img | grep "http://" > urls.txt
strings evidence.img | grep -i "password" > passwords.txt

---

4. Memory Forensics

L'analisi della RAM è fondamentale: processi, connessioni, chiavi di cifratura, malware in memoria.

4.1 Acquisizione della RAM

# Linux — LiME (Linux Memory Extractor)
sudo apt install build-essential linux-headers-$(uname -r)
git clone https://github.com/504ensicsLabs/LiME
cd LiME/src
make
sudo insmod lime-$(uname -r).ko "path=/mnt/usb/memory.lime format=lime"

# Alternativa su Linux
sudo dd if=/proc/mem of=memory.dump
sudo cp /dev/mem memory.dump  # limitato su sistemi moderni

# Windows (con tool esterno — usare FTK Imager, WinPmem, Magnet RAM Capture)
# winpmem_mini.exe memory.dmp

4.2 Volatility 3 — Analisi memoria

Volatility è lo strumento standard per memory forensics:

sudo apt install python3-pip
pip3 install volatility3

# Info di sistema (identifica OS e profilo)
python3 vol.py -f memory.lime banners.Banners
python3 vol.py -f memory.lime windows.info  # Windows

# Processi in esecuzione
python3 vol.py -f memory.lime linux.pslist
python3 vol.py -f memory.lime linux.pstree    # albero gerarchico
python3 vol.py -f memory.lime linux.cmdline   # linee di comando

# Processi nascosti (rootkit detection)
python3 vol.py -f memory.lime linux.pslist > ps1.txt
python3 vol.py -f memory.lime linux.psscan > ps2.txt
diff ps1.txt ps2.txt   # processi in psscan ma non pslist → sospetti

# Connessioni di rete al momento del dump
python3 vol.py -f memory.lime linux.netstat

# Moduli kernel caricati
python3 vol.py -f memory.lime linux.lsmod

# Dump di un processo
python3 vol.py -f memory.lime linux.memmap --pid 1234 --dump

# Hash delle password (Windows)
python3 vol.py -f memory.dmp windows.hashdump

# Registry in memoria (Windows)
python3 vol.py -f memory.dmp windows.registry.hivelist
python3 vol.py -f memory.dmp windows.registry.printkey --key "SOFTWARE\Microsoft\Windows\CurrentVersion\Run"

# Cercare stringhe in memoria
python3 vol.py -f memory.lime linux.strings --pid 1234 | grep password
strings memory.lime | grep -i "password\|passwd\|credential"

4.3 Analisi malware in memoria

# Trovare DLL iniettate (Windows)
python3 vol.py -f memory.dmp windows.dlllist --pid 1234

# Rilevare processi con codice iniettato
python3 vol.py -f memory.dmp windows.malfind

# Dump del codice sospetto per analisi
python3 vol.py -f memory.dmp windows.malfind --dump

# Verificare hash dei dump con VirusTotal
sha256sum pid.1234.0x400000.dmp
# → cerca l'hash su virustotal.com

---

5. Analisi dei Log

5.1 Log Linux

# Log di sistema
journalctl -xe                  # log systemd
journalctl -u sshd              # log servizio specifico
journalctl --since "2024-01-01" --until "2024-01-31"

# Auth log
cat /var/log/auth.log | grep "Failed password"
cat /var/log/auth.log | grep "Accepted password"

# Tentativi di accesso SSH da IP specifico
grep "192.168.1.50" /var/log/auth.log

# Estrazione di tutti gli IP che hanno tentato login
grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -rn

# Comandi eseguiti
cat /home/user/.bash_history
cat /root/.bash_history

# Modifiche recenti ai file
find / -newer /tmp/marker -type f 2>/dev/null
# Crea marker: touch -t 202401010000 /tmp/marker

# File modificati nell'ultima ora
find / -mmin -60 -type f 2>/dev/null

5.2 Log Windows

# Event Log via PowerShell
Get-EventLog -LogName Security -Newest 100
Get-EventLog -LogName System -EntryType Error -Newest 50

# Filtro per Event ID
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624}   # Login riuscito
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625}   # Login fallito
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4648}   # Credenziali esplicite
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4720}   # Account creato
Get-WinEvent -FilterHashtable @{LogName='System'; Id=7045}     # Servizio installato

# Event ID importanti per forensics:
# 4624 - Logon riuscito
# 4625 - Logon fallito
# 4634 - Logoff
# 4648 - Logon con credenziali esplicite
# 4688 - Processo creato
# 4698 - Task schedulato creato
# 4720 - Account utente creato
# 7034 - Servizio crash
# 7045 - Servizio installato

# Su Kali, analisi file .evtx Windows
sudo apt install libevtx-utils
evtxexport C_Security.evtx > security_log.txt

# Tool alternativo: python-evtx
pip3 install python-evtx
python3 -m evtx.dump Security.evtx > security.txt

5.3 Browser Forensics

# Chrome/Chromium — SQLite databases
# Profilo in: ~/.config/google-chrome/Default/

# History
sqlite3 ~/.config/google-chrome/Default/History \
  "SELECT datetime(last_visit_time/1000000-11644473600, 'unixepoch'), url, title FROM urls ORDER BY last_visit_time DESC LIMIT 50;"

# Download
sqlite3 ~/.config/google-chrome/Default/History \
  "SELECT tab_url, target_path, datetime(start_time/1000000-11644473600, 'unixepoch') FROM downloads;"

# Cookie
sqlite3 ~/.config/google-chrome/Default/Cookies \
  "SELECT host_key, name, value, datetime(creation_utc/1000000-11644473600, 'unixepoch') FROM cookies;"

# Firefox — places.sqlite
sqlite3 ~/.mozilla/firefox/*.default/places.sqlite \
  "SELECT datetime(visit_date/1000000, 'unixepoch'), url, title FROM moz_places JOIN moz_historyvisits ON moz_places.id = moz_historyvisits.place_id ORDER BY visit_date DESC LIMIT 50;"

---

6. Timeline Reconstruction

# Creare supertimeline con plaso (log2timeline)
sudo apt install plaso-tools

# Parsing di un'immagine disco
log2timeline.py --storage-file evidence.plaso evidence.img

# Filtrare e esportare
psort.py -o l2tcsv -w timeline.csv evidence.plaso "date > '2024-01-01' AND date < '2024-02-01'"

# Analisi con Timesketch (web UI)
sudo apt install timesketch
# Importa il CSV per visualizzazione timeline interattiva

# Approccio manuale — unifica log diversi
cat /var/log/auth.log | awk '{print $1,$2,$3,"[AUTH]",$0}' >> supertimeline.txt
cat /var/log/syslog | awk '{print $1,$2,$3,"[SYSLOG]",$0}' >> supertimeline.txt
sort supertimeline.txt > supertimeline_sorted.txt

---

7. Network Forensics

# Analisi pcap con Wireshark
# Filtri forensi utili:
# http.request.method == "POST" && http contains "password"
# ftp.request.command == "PASS"
# smtp.auth.password
# dns.qry.name contains "malicious"

# Ricostruzione stream TCP
# Wireshark: click destro → Follow TCP Stream

# Estrazione file da pcap
sudo apt install tcpextract
tcpflow -r capture.pcap -o extracted/

# Networkminer (su Windows/Mono)
# Estrae automaticamente file, credenziali, immagini dai pcap

# Analisi con tshark
# Tutte le conversazioni HTTP
tshark -r capture.pcap -q -z http,tree

# Estrazione file HTTP
tshark -r capture.pcap --export-objects http,/tmp/http_objects/

---

8. Lab Pratico — Risposta a un Incidente

Scenario: Sospetti che un server Linux sia stato compromesso. Esegui triage forense.

# 1. Acquisizione dati volatili (PRIMA di tutto)
date >> incident.log
uname -a >> incident.log
uptime >> incident.log
w >> incident.log            # utenti connessi
last -25 >> incident.log     # ultimi login
ps auxf >> incident.log      # processi
netstat -antup >> incident.log  # connessioni
iptables -L -n >> incident.log  # regole firewall

# 2. Ricerca presenza attaccante
# Connessioni attive sospette
netstat -antup | grep ESTABLISHED | grep -v "127.0.0.1"

# Processi che ascoltano su porte inattese
ss -tlnp | grep -v ":22\|:80\|:443"

# Crontab di tutti gli utenti
for user in $(cut -f1 -d: /etc/passwd); do
  echo "=== $user ==="; crontab -u $user -l 2>/dev/null
done

# File modificati recentemente (ultime 24h)
find / -mtime -1 -type f 2>/dev/null | grep -v proc | grep -v sys

# File SUID modificati di recente
find / -perm -4000 -mtime -7 2>/dev/null

# 3. Analisi log
grep "Failed password" /var/log/auth.log | tail -50
grep "Accepted password\|Accepted publickey" /var/log/auth.log | tail -20

# 4. Acquisizione RAM
sudo insmod lime.ko "path=/tmp/memory.lime format=lime"

# 5. Acquisizione disco (su sistema live)
sudo dd if=/dev/sda of=/mnt/backup/disk.img bs=4096 conv=noerror,sync status=progress

# 6. Hash per chain of custody
sha256sum /mnt/backup/disk.img > /mnt/backup/disk.sha256
sha256sum /tmp/memory.lime > /tmp/memory.sha256

---

Quiz di autoverifica

1. Perché è fondamentale calcolare l'hash SHA-256 di un'immagine forense prima e dopo l'acquisizione?
2. Qual è la differenza tra fls e icat in Sleuth Kit?
3. Cosa può rivelare il comando malfind di Volatility?
4. Perché si acquisisce prima la RAM e poi il disco?
5. Cosa indica la presenza di un processo nel psscan ma non nel pslist di Volatility?

---

Precedente: 03 — Penetration Testing
Prossimo: 05 — Malware & Reverse Engineering