Se Linux è il tuo ambiente di lavoro principale, allora potresti avere familiarità con Executable and Linkable Format (ELF), il formato di file principale utilizzato per eseguibili, librerie, core-dump e altro su Linux. Ho scritto articoli riguardanti gli strumenti nativi di Linux per comprendere i binari ELF, iniziando da come vengono costruiti i binari ELF, seguiti da alcuni suggerimenti generali su come analizzare i binari ELF. Se non hai familiarità con ELF e gli eseguibili in generale, ti suggerisco di leggere prima questi articoli.
Vi presentiamo Capa
Capa è un progetto open source di Mandiant (una società di sicurezza informatica). Nelle stesse parole del progetto, capa rileva le capacità nei file eseguibili . Sebbene l'obiettivo principale di Capa siano eseguibili sconosciuti e possibilmente dannosi, gli esempi in questo articolo eseguono Capa sulle utilità Linux quotidiane per vedere come funziona lo strumento.
Dato che la maggior parte dei malware è basata su Windows, le versioni precedenti di Capa supportavano solo il formato di file PE, un formato eseguibile di Windows dominante. Tuttavia, a partire dalla v3.0.0, è stato aggiunto il supporto per i file ELF (grazie a Intezer).
Più risorse Linux
- Comandi Linux cheat sheet
- Cheat sheet sui comandi avanzati di Linux
- Corso online gratuito:Panoramica tecnica RHEL
- Cheat sheet della rete Linux
- Cheat sheet di SELinux
- Cheat sheet dei comandi comuni di Linux
- Cosa sono i container Linux?
- I nostri ultimi articoli su Linux
Cosa sono le capacità?
Che cosa significa il concetto di capacità in realtà significa, soprattutto nel contesto dei file eseguibili? Programmi o software soddisfano determinate esigenze di elaborazione o risolvono un problema. Per semplificare le cose, i nostri requisiti possono variare dalla ricerca di un file, alla lettura/scrittura di un file, all'esecuzione di un programma, alla registrazione di alcuni dati in un file di registro, all'apertura di una connessione di rete, ecc. Utilizziamo quindi un linguaggio di programmazione a nostra scelta con istruzioni specifiche per svolgere questi compiti e compilare il programma. Il file binario o eseguibile risultante esegue quindi queste attività per conto dell'utente, quindi l'eseguibile risultante è capace di svolgere i compiti di cui sopra.
Osservando il codice sorgente, è facile identificare cosa fa un programma o qual è il suo intento. Tuttavia, una volta che il programma è stato compilato come eseguibile, il codice sorgente viene convertito in linguaggio macchina e non fa più parte dell'eseguibile risultante (a meno che non venga compilato con le informazioni di debug). Possiamo ancora dargli un senso guardando le istruzioni di assemblaggio equivalenti supportate da una certa conoscenza dell'API Linux (glibc/chiamate di sistema), tuttavia, è difficile. Esistono strumenti come i decompilatori che tentano di convertire l'assembly in uno pseudo-codice di quello che potrebbe essere stato il codice sorgente originale. Tuttavia, non è una partita uno a uno ed è solo un tentativo di massimo sforzo.
Perché un altro strumento?
Se abbiamo più strumenti Linux nativi per analizzare i binari, perché ne abbiamo bisogno di un altro? Gli strumenti esistenti aiutano gli sviluppatori nella risoluzione dei problemi e nel debug dei problemi che potrebbero sorgere durante lo sviluppo. Spesso sono il primo passo per l'analisi iniziale su binari sconosciuti, tuttavia non sono sufficienti.
A volte ciò che è necessario non è un lungo disassemblaggio o un lungo pseudo-codice, ma solo un rapido riepilogo delle funzionalità visualizzate nel file binario in base all'utilizzo dell'API. Spesso, i file binari e il malware dannosi utilizzano alcune tecniche anti-analisi o anti-inversione che rendono indifesi tali strumenti nativi.
Il pubblico principale di Capa è costituito da malware o ricercatori di sicurezza che spesso si imbattono in file binari sconosciuti per i quali il codice sorgente non è disponibile. Devono identificare se si tratta di malware o di un eseguibile benigno. Un primo passo iniziale è scoprire cosa può fare l'eseguibile prima di passare all'analisi dinamica. Questo può essere fatto con alcuni set di regole predefiniti abbinati a un framework popolare (che esploreremo di seguito). Gli strumenti nativi di Linux non sono stati progettati per tali usi.
Ottenere Capa
Scarica un programma Capa Linux pre-costruito da qui. È necessario utilizzare la v3.0.0 o una versione successiva. Capa è programmato in Python, tuttavia il programma scaricato non è un .py file che l'interprete Python può eseguire. È invece un eseguibile ELF che viene eseguito direttamente dalla riga di comando di Linux.
$ pwd
/root/CAPA
$
$ wget -q https://github.com/mandiant/capa/releases/download/v3.0.2/capa-v3.0.2-linux.zip
$
$ file capa-v3.0.2-linux.zip
capa-v3.0.2-linux.zip: Zip archive data, at least v2.0 to extract
$
$ unzip capa-v3.0.2-linux.zip
Archive: capa-v3.0.2-linux.zip
inflating: capa
$
$ ls -l capa
-rwxr-xr-x. 1 root root 41282976 Sep 28 18:29 capa
$
$ file capa
capa: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=1da3a1d77c7109ce6444919f4a15e7e6c63d02fa, stripped
Opzioni della riga di comando
Capa viene fornito con una varietà di opzioni della riga di comando. Questo articolo ne visita alcuni, a cominciare dal contenuto della guida:
$ ./capa -h
usage: capa [-h] [--version] [-v] [-vv] [-d] [-q] [--color {auto,always,never}] [-f {auto,pe,elf,sc32,sc64,freeze}]
[-b {vivisect,smda}] [-r RULES] [-s SIGNATURES] [-t TAG] [-j]
sample
The FLARE team's open-source tool to identify capabilities in executable files.
<< snip >>
$
Utilizzare questo comando per verificare se la versione richiesta di Capa (v3 e successive) è in esecuzione:
$ ./capa --version
capa v3.0.2-0-gead8a83
Output Capa e framework MITRE ATT&CK
L'output di Capa può essere un po' opprimente, quindi eseguilo prima su una semplice utility, come pwd . Il pwd command su Linux stampa la directory di lavoro corrente ed è un comando comune. Tieni presente che pwd potrebbe essere una shell integrata per te (nessun eseguibile separato) a seconda della distribuzione che stai utilizzando. Identifica il suo percorso usando il which prima il comando e poi fornire il percorso completo a Capa. Ecco un esempio:
$ which pwd
/usr/bin/pwd
$
$ file /usr/bin/pwd
/usr/bin/pwd: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ec306ddd72ce7be19dfc1e62328bb89b6b3a6df5, for GNU/Linux 3.2.0, stripped
$
$ ./capa -f elf /usr/bin/pwd
loading : 100%| 633/633 [00:00<00:00, 2409.72 rules/s]
matching: 100%| 76/76 [00:01<00:00, 38.87 functions/s, skipped 0 library functions]
+------------------------+------------------------------------------------------------------------------------+
| md5 | 8d50bbd7fea04735a70f21cca5063efe |
| sha1 | 7d9df581bc3d34c9fb93058be2cdb9a8c04ec061 |
| sha256 | 53205e6ef4e1e7e80745adc09c00f946ae98ccf6f8eb9c4535bd29188f7f1d91 |
| os | linux |
| format | elf |
| arch | amd64 |
| path | /usr/bin/pwd |
+------------------------+------------------------------------------------------------------------------------+
+------------------------+------------------------------------------------------------------------------------+
| ATT&CK Tactic | ATT&CK Technique |
|------------------------+------------------------------------------------------------------------------------|
| DISCOVERY | File and Directory Discovery:: T1083 |
+------------------------+------------------------------------------------------------------------------------+
+-----------------------------+-------------------------------------------------------------------------------+
| MBC Objective | MBC Behavior |
|-----------------------------+-------------------------------------------------------------------------------|
| FILE SYSTEM | Writes File:: [C0052] |
+-----------------------------+-------------------------------------------------------------------------------+
+------------------------------------------------------+------------------------------------------------------+
| CAPABILITY | NAMESPACE |
|------------------------------------------------------+------------------------------------------------------|
| enumerate files on Linux (2 matches) | host-interaction/file-system/files/list |
| write file on Linux | host-interaction/file-system/write |
+------------------------------------------------------+------------------------------------------------------+
Esegui Capa con -f elf argomento per dirgli che l'eseguibile da analizzare è nel formato di file ELF. Questa opzione potrebbe essere richiesta per binari sconosciuti; tuttavia, Capa è perfettamente in grado di rilevare il formato da solo ed eseguire l'analisi, quindi puoi saltare questa opzione se necessario. All'inizio, vedrai un messaggio di caricamento/corrispondenza mentre Capa carica le sue regole dal back-end e quindi analizza l'eseguibile e confronta quelle regole con esso. Salta la visualizzazione aggiungendo il -q opzione a tutti i comandi.
L'output di Capa è suddiviso in varie sezioni. La prima sezione identifica in modo univoco il file binario utilizzando il relativo hash md5, sha1 o sha256 seguito dal sistema operativo, dal formato del file e dalle informazioni sull'architettura. Queste informazioni sono spesso critiche quando si tratta di eseguibili. Nelle sezioni seguenti, Capa utilizza la tattica e la tecnica ATT&CK per abbinare le capacità.
MITRE ATT&CK è meglio descritto nelle stesse parole del progetto:
MITRE ATT&CK® è una base di conoscenza accessibile a livello globale di tattiche e tecniche avversarie basate su osservazioni del mondo reale.
Se desideri saperne di più su ATT&CK, fai riferimento a MITRE ATT&CK Framework qui.
È possibile abbinare l'output di Capa nelle due sezioni seguenti con quello del framework MITRE ATT&CK. Salterò questa parte in questo articolo.
Infine, nella sezione Capacità, puoi vedere due funzionalità specifiche elencate:
enumerate files on Linux
write file on Linux
Confronta questo con la natura del pwd programma, che deve mostrare la directory corrente. Qui corrisponde alla prima capacità (ricorda che il concetto di tutto è un file in Linux). Che dire della seconda parte, che dice scrittura file ? Di certo non abbiamo scritto pwd output su qualsiasi file. Tuttavia, ricorda pwd deve scrivere la posizione della directory corrente sul terminale; in che altro modo verrà stampato l'output? Se non sei ancora sicuro di come funzioni, esegui il comando seguente e abbina l'output. Se non hai familiarità con strace o cosa fa, ho un articolo che lo copre qui. Concentrati sulla scrittura chiamata di sistema verso la fine dell'articolo in cui il pwd eseguibile deve scrivere il percorso della directory (stringa) su 1 , che sta per standard out. Nel nostro caso, quello è il terminale.
$ strace -f /usr/bin/pwd
execve("/usr/bin/pwd", ["/usr/bin/pwd"], 0x7ffd7983a238 /* 49 vars */) = 0
brk(NULL)
<< snip >>
write(1, "/root/CAPA\n", 11/root/CAPA
) = 11
close(1) = 0
close(2) = 0
exit_group(0) = ?
+++ exited with 0 +++
Eseguire Capa su diverse utilità Linux
Ora che sai come eseguire Capa, ti consiglio vivamente di provarlo su varie utility Linux quotidiane. Quando scegli i servizi di pubblica utilità, cerca di essere il più diversificato possibile. Ad esempio, seleziona utilità che funzionano con file system o comandi di archiviazione, come ls , mount , cat , echo , ecc. Successivamente, passa alle utilità di rete, come netstat , ss , telnet , ecc., dove troverai le capacità di rete di un eseguibile. Estendilo a daemon di programmi più estesi come sshd per vedere le funzionalità relative alle criptovalute, seguite da systemd , bash , ecc.
Un avvertimento, non spaventarti troppo se vedi regole che corrispondono al malware per queste utilità native. Ad esempio, durante l'analisi di systemd, Capa ha mostrato corrispondenze per COMANDO E CONTROLLO in base alla capacità di ricevere dati da una rete. Questa funzionalità potrebbe essere utilizzata da programmi originali per casi legittimi, mentre il malware potrebbe utilizzarla per scopi dannosi.
Esecuzione in modalità debug
Se desideri vedere come Capa trova tutte queste funzionalità in un eseguibile, fornisci il -d flag, che mostra informazioni aggiuntive sullo schermo che potrebbero aiutare a comprenderne il funzionamento interno. Usa questi dati e cerca indizi nel codice sorgente su GitHub.
$ ./capa -q /usr/sbin/sshd -dLa prima cosa da notare è che Capa salva le regole in una directory temporanea e le legge da lì:
DEBUG:capa:reading rules from directory /tmp/_MEIKUG6Oj/rulesL'output di debug mostra che ha caricato varie regole da questa directory. Ad esempio, guarda come ha cercato di identificare il nome host di una macchina:
DEBUG:capa:loaded rule: 'get hostname' with scope: function
Con queste informazioni, è facile cercare la regola. Vai semplicemente alle rules directory e grep per il nome della regola specifica come nell'esempio seguente. La regola è indicata in un file .yml.
$ grep -irn "name: get hostname" *
rules/host-interaction/os/hostname/get-hostname.yml:3: name: get hostname
Verifica la -api sezioni in cui sono elencate varie API. Capa cerca il gethostname Utilizzo dell'API (su Linux) e puoi vedere anche l'equivalente di Windows elencato lì.
$ cat _MEIKUG6Oj/rules/host-interaction/os/hostname/get-hostname.yml
rule:
meta:
name: get hostname
namespace: host-interaction/os/hostname
<< snip >>
features:
- or:
- api: kernel32.GetComputerName
- api: kernel32.GetComputerNameEx
- api: GetComputerObjectName
- api: ws2_32.gethostname
- api: gethostname
Puoi trovare maggiori informazioni su questa specifica chiamata di sistema su Linux usando la pagina man.
$ man 2 gethostname
GETHOSTNAME(2) Linux Programmer's Manual GETHOSTNAME(2)
NAME
gethostname, sethostname - get/set hostname
<< snip >>
Utilizzo dettagliato
Un altro buon modo per identificare quale API sta cercando Capa è usare la modalità dettagliata, come mostrato di seguito. Questo semplice esempio mostra l'uso di opendir , readdir e fwrite API:
$ ./capa -q /usr/bin/pwd -vv
enumerate files on Linux (2 matches)
<< snip >>
api: opendir @ 0x20052E8
api: readdir @ 0x2005369, 0x200548A
write file on Linux
<< snip >>
os: linux
or:
api: fwrite @ 0x2002CB5
Regole personalizzate
Come con altri buoni strumenti, Capa ti consente di estenderlo aggiungendo le tue regole. Questo suggerimento è stato fornito anche nell'output di debug, se l'hai notato.
$ capa --signature ./path/to/signatures/ /path/to/executableSolo regole specifiche
Puoi anche cercare regole specifiche invece di avere Capa che cerca di soddisfare ogni regola. Fallo aggiungendo il -t flag seguito dal nome esatto della regola:
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j
Visualizza il nome della regola dai file .yml all'interno delle rules directory. Ad esempio:
$ grep name rules/host-interaction/process/create/create-process-on-linux.yml
name: create process on Linux
Formato di output
Infine, Capa consente l'output in formato JSON utilizzando il -j bandiera. Questo flag aiuta a consumare rapidamente le informazioni e aiuta l'automazione. Questo comando di esempio richiede che sia installato il comando jq:
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j | jq .Concludi
Capa è una degna aggiunta agli strumenti tanto necessari per gli eseguibili ELF. Dico molto necessario perché ora vediamo regolarmente casi di malware Linux. Gli strumenti su Linux devono recuperare il ritardo per affrontare queste minacce. Puoi giocare con Capa e provarlo su vari eseguibili, e anche scrivere le tue regole e aggiungerle a monte a beneficio della comunità.