Raccolta Automatica: Automated Collection (T1119)

Per comprendere appieno le capacità di questa tecnica, iniziamo con uno script PowerShell che automatizza la ricerca e raccolta di documenti Office:

Get-ChildItem -Path C:\ -Include *.docx,*.xlsx,*.pdf -Recurse -ErrorAction SilentlyContinue | 
Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-30)} | 
Copy-Item -Destination C:\temp\collection

Su sistemi Linux, un approccio simile utilizza find combinato con archivi compressi:

find /home -type f \( -name "*.pdf" -o -name "*.docx" -o -name "*.xlsx" \) -mtime -30 -exec cp {} /tmp/staging/ \;
tar czf /tmp/exfil_$(date +%Y%m%d).tar.gz /tmp/staging/

Per simulare la tecnica del gruppo Ke3chang, che esegue collezioni schedulate, possiamo implementare un job cron che opera durante orari di bassa attività. Il seguente script bash cerca file contenenti parole chiave sensibili:

#!/bin/bash
keywords=("password" "confidential" "secret" "api_key")
for keyword in "${keywords[@]}"; do
    grep -r -l "$keyword" /home/*/Documents/ 2>/dev/null >> /tmp/interesting_files.txt
done

Negli ambienti cloud, la raccolta automatica sfrutta le API native. Con AWS CLI, possiamo enumerare e scaricare oggetti S3:

aws s3 ls s3://target-bucket --recursive | awk '{print $4}' | 
while read file; do aws s3 cp "s3://target-bucket/$file" ./collection/; done

Il gruppo APT28 ha dimostrato l'uso di tool pubblici per compressione automatica. Simuliamo questa tecnica con 7zip su Windows:

for /f "delims=" %%i in ('dir /s /b C:\Users\*.pst') do 7z a -pinfected archive.7z "%%i"

Per macOS, Gamaredon Group utilizza script che scandiscono automaticamente documenti interessanti. Replichiamo con Swift:

mdfind -onlyin ~ 'kMDItemKind == "Microsoft Word Document" && kMDItemContentModificationDate >= $time.now(-2419200)'

La detection efficace richiede un approccio multilivello che identifichi pattern comportamentali anomali piuttosto che singoli eventi. Iniziamo configurando il monitoraggio per processi che generano liste di file in modo ricorsivo.

Su Windows con Sysmon, catturiamo l'esecuzione di comandi di discovery seguiti da operazioni di copia massiva:

<RuleGroup name="AutomatedCollection" groupRelation="and">
  <ProcessCreate onmatch="include">
    <CommandLine condition="contains any">dir /s;Get-ChildItem -Recurse;tree /f</CommandLine>
  </ProcessCreate>
  <FileCreate onmatch="include">
    <TargetFilename condition="contains">\temp\</TargetFilename>
    <Rule groupRelation="or">
      <TargetFilename condition="end with">.zip</TargetFilename>
      <TargetFilename condition="end with">.7z</TargetFilename>
    </Rule>
  </FileCreate>
</RuleGroup>

Per Linux, monitoriamo con auditd le operazioni di lettura massiva su directory sensibili. La regola seguente genera alert quando un processo accede a più di 50 file in 5 minuti:

-a always,exit -F dir=/home -F perm=r -F key=bulk_file_access
-a always,exit -S open -F success=1 -F key=file_collection

L'analisi comportamentale deve considerare la baseline normale dell'ambiente. Uno script Python per correlare eventi può identificare burst di attività anomala:

def detect_collection_burst(events, threshold=100, window_minutes=10):
    file_access_count = defaultdict(int)
    for event in events:
        if event.type == "FILE_ACCESS":
            process_id = event.process_id
            timestamp = event.timestamp
            file_access_count[(process_id, timestamp//window_minutes)] += 1
    
    alerts = []
    for (pid, window), count in file_access_count.items():
        if count > threshold:
            alerts.append(f"Process {pid} accessed {count} files in window")
    return alerts

Per ambienti cloud, monitoriamo le API di accesso ai dati. In Azure, una query KQL identifica download massicci:

StorageBlobLogs
| where OperationName == "GetBlob"
| summarize FileCount = count(), TotalSize = sum(ResponseBodySize) 
    by CallerIpAddress, UserAgent, bin(TimeGenerated, 5m)
| where FileCount > 100 or TotalSize > 1073741824  // 1GB

L'integrazione con MISP permette di correlare indicatori con campagne note. Quando FIN6 utilizza script per iterare su sistemi PoS, cerchiamo pattern specifici:

# Splunk search per FIN6-style collection
index=endpoint sourcetype=sysmon EventCode=1 
| regex CommandLine="for.*in.*do.*copy|while.*read.*cp"
| stats count by ComputerName, User, CommandLine
| where count > 10

La gestione dei falsi positivi richiede whitelisting intelligente. Processi legittimi come backup schedulati devono essere esclusi attraverso hash verificati e percorsi di esecuzione autorizzati. Manteniamo una baseline aggiornata delle attività di raccolta legittime per ridurre il rumore.

La ricostruzione forense di attività di raccolta automatica richiede l'analisi di molteplici artefatti che testimoniano le operazioni eseguite. Su Windows, il Prefetch conserva tracce preziose di tool di compressione utilizzati.

Esaminiamo i file Prefetch per 7-Zip o WinRAR:

Get-ChildItem C:\Windows\Prefetch\7Z*.pf | ForEach-Object {
    $prefetch = [System.IO.File]::ReadAllBytes($_.FullName)
    # Analizza timestamp di esecuzione e file acceduti
    $executionTime = [BitConverter]::ToInt64($prefetch, 0x80)
    $accessedFiles = Extract-StringsFromBinary($prefetch) | Where {$_ -match "\.docx|\.pdf"}
}

L'analisi della ShellBag rivela le directory navigate durante la fase di ricognizione. Mustang Panda tipicamente esplora sistematicamente le cartelle utente prima di eseguire la raccolta batch:

import winreg

def parse_shellbags():
    key_path = r"Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\BagMRU"
    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path) as key:
        # Estrai timestamp e percorsi navigati
        for i in range(winreg.QueryInfoKey(key)[0]):
            subkey_name = winreg.EnumKey(key, i)
            # Decodifica struttura shellbag per timeline

Su sistemi Linux, il file .bash_history spesso contiene comandi di ricerca e archiviazione. Correliamo con i log di auditd per una timeline completa:

# Estrai comandi di collezione dalla history
grep -E "(find.*-exec|tar.*cf|zip.*-r)" /home/*/.bash_history

# Correla con auditd per timestamp precisi
ausearch -k file_collection --format csv | 
awk -F',' '{print $1","$3","$11}' | sort

I Volume Shadow Copy su Windows possono contenere versioni precedenti di script di collezione. HAFNIUM è noto per utilizzare script PowerShell temporanei:

vssadmin list shadows
# Per ogni shadow copy
$shadow = "\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1"
Get-ChildItem "$shadow\Users\*\AppData\Local\Temp\*.ps1"

L'analisi della memoria può rivelare script in esecuzione. Con Volatility, identifichiamo processi con handle aperti su molteplici file:

volatility -f memory.dmp --profile=Win10x64 handles -t File | 
awk '{print $3}' | sort | uniq -c | sort -rn | head -20

Per macOS, analizziamo i log unificati che registrano l'accesso massivo ai file. Sidewinder utilizza tool per enumerare automaticamente configurazioni di sistema:

log show --predicate 'process == "mdfind" OR process == "find"' --last 48h |
grep -E "Documents|Downloads" | 
awk '{print $1, $2, $3, $(NF)}' > timeline_collection.txt

La correlazione temporale è cruciale. Mappiamo l'attività di discovery (T1083) che precede la raccolta automatica, seguita dal lateral movement (T1570) per trasferire i dati raccolti. Questa sequenza è caratteristica di APT1.

L'analisi delle tattiche di raccolta automatica rivela pattern distintivi che permettono l'attribuzione e la predizione comportamentale. Ke3chang implementa una metodologia particolarmente sofisticata con collezioni schedulate che si attivano durante specifici orari operativi della vittima.

Il gruppo utilizza DLL personalizzate per monitoraggio continuo della memoria, estraendo dati da applicazioni in esecuzione. La loro infrastruttura C2 riceve aggiornamenti incrementali ogni 4 ore, suggerendo un approccio paziente e persistente. Le vittime nel settore energetico e diplomatico in Asia mostrano pattern di esfiltrazione che coincidono con i cicli di reporting trimestrali.

Threat Group-3390 adotta un approccio più aggressivo, compilando archivi RAR di tipi di file specifici entro 48 ore dalla compromissione iniziale. La loro preferenza per documenti CAD e proprietà intellettuale manifatturiera indica targeting industriale mirato. I loro tool generano archivi con convenzioni di denominazione prevedibili: [YYYYMMDD]_[hostname]_docs.rar.

APT28 dimostra capacità adattive uniche, modificando i criteri di raccolta basandosi sul profilo della vittima. Contro obiettivi governativi, prioritizzano file *.pdf e *.doc modificati negli ultimi 7 giorni. Contro obiettivi militari, espandono la ricerca a include database e file di configurazione.

L'overlap negli strumenti utilizzati fornisce indicazioni preziose. BADNEWS malware, condiviso tra Patchwork e altri attori dell'Asia meridionale, monitora dispositivi USB per raccolta opportunistica. Quando osserviamo questo comportamento, possiamo anticipare:

• Movimento laterale verso workstation con maggiore attività USB
• Deployment di keylogger per catturare password di archivi crittografati
• Escalation verso server di file sharing entro 72 ore

I pattern geografici sono illuminanti. Gruppi cinesi come Mustang Panda tendono a operare durante l'orario lavorativo di Pechino (UTC+8), con picchi di attività di raccolta tra le 14:00-17:00 ora locale del target. Questa prevedibilità permette di rafforzare il monitoraggio durante finestre ad alto rischio.

Le analisi e raccomandazioni presentate si basano sul framework MITRE ATT&CK per la tecnica T1119, integrato con intelligence sulle campagne Operation Wocao, Frankenstein e ArcaneDoor. I pattern comportamentali dei gruppi APT derivano da ricerca open source e report di sicurezza pubblicati tra il 2019 e il 2024.