grap: definire e abbinare pattern di grafi all'interno dei binari

https://github.com/QuoSecGmbH/grap

grap prende pattern e file binari, utilizza un disassembler basato su Casptone per ottenere i grafi di flusso di controllo dai binari, quindi abbina i pattern a essi.

I pattern sono grafi definiti dall'utente con condizioni di istruzioni ("opcode è xor e arg1 è eax") e condizioni di ripetizione (3 istruzioni identiche, blocchi di base...).

grap è disponibile come strumento standalone con un disassembler e binding Python, e come plugin IDA che sfrutta il disassemblaggio effettuato da IDA e dal reverser.

Supporto:

• File: disassemblaggio di PE, ELF e binari raw, ulteriori file dovrebbero funzionare all'interno di IDA
• Architettura: x86 e x86_64

Abbinamento rapido del pattern:

Abbinamento completo del pattern:

Abbinamento su più file:

Creare pattern interattivamente da IDA:

Installazione

Questo documento descrive come compilare e installare grap su una distribuzione Linux.

Puoi anche leggere:

• WINDOWS.md: installare grap su Windows
• IDA.md: istruzioni di installazione e uso del plugin IDA

Requisiti

Oltre ai compilatori (build-essential), devono essere installate le seguenti dipendenze:

• cmake
• bison
• flex
• libboost-regex-dev
• libboost-system-dev
• libboost-filesystem-dev
• libseccomp-dev
• python3-dev
• python3-pefile
• python3-pyelftools
• python3-capstone
• swig (la versione 3 o successiva è obbligatoria)

Quindi su Ubuntu / Debian, dovrebbe funzionare:

sudo apt-get install build-essential cmake bison flex libboost-regex-dev libboost-system-dev libboost-filesystem-dev libseccomp-dev python3-dev python3-pefile python3-pyelftools python3-capstone swig

Si noti che questi sono stati testati per l'ultima Ubuntu LTS (18.04.3). I pacchetti possono differire a seconda della distribuzione.

Compilazione e installazione

I seguenti comandi compileranno e installeranno il progetto:

• mkdir build; cd build/ come consigliato, compilare il progetto in una directory dedicata
• cmake ../src/; make compilerà con cmake e make
• sudo make install installerà grap in /usr/local/bin/

SWIG potrebbe non trovare python3 se la versione predefinita è python2, ciò può essere risolto impostando python3 come predefinito. Ad esempio su Ubuntu:

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10

Utilizzo

Lo strumento può essere avviato utilizzando il seguente comando:

$ grap [options] pattern test_paths

Di seguito alcuni esempi di opzioni supportate:

• grap -h: descrive le opzioni supportate

Si può far inferire a grap un pattern da una stringa. Solo poche opzioni sono supportate, ma è utile per la prototipazione:

• grap "opcode is xor and arg1 contains '['" (test.exe): cerca uno xor con una scrittura in memoria
• grap -v "sub->xor->sub" (test.exe): -v mostrerà il percorso del pattern inferito

Scegli come vengono disassemblati i binari:

• grap -od (pattern.grapp) samples/*: disassembla file nella cartella samples/ senza tentare l'abbinamento
• grap -f (pattern.grapp) (test.exe): forza il ri-disassemblaggio del binario, quindi lo abbina a pattern.grapp
• grap --raw (pattern.grapp) (test.bin): disassembla file raw (usa --raw-64 per binari a 64 bit)

Controlla la verbosità dell'output:

• grap -q -sa (pattern.grapp) (samples/*.grapcfg): abbina file disassemblati, mostra file corrispondenti e non, uno per riga
• grap -m (pattern.grapp) (test.grapcfg): mostra tutti i nodi corrispondenti

Scegli dove vengono scritti i file disassemblati (.grapcfg); abbina più file a più pattern:

• grap patterns/basic_block_loop.grapp -o ls.grapcfg /bin/ls: disassembla ls in ls.grapp e cerca loop di blocchi di base
• grap (pattern1.grapp) -p (pattern2.grapp) (test.exe): abbina contro più file di pattern
• grap -r -q patterns/ /bin/ -o /tmp/: disassembla tutti i file da /bin/ in /tmp/ e li abbina a tutti i pattern .grapp da patterns/ (l'opzione ricorsiva -r si applica a /bin/, non a patterns/)

Esempi di pattern

Il seguente pattern rileva un loop di decifratura composto da uno xor seguito da sub trovato in un campione di Backspace:

digraph decryption_md5_4ee00c46da143ba70f7e6270960823be {
A [cond=true, repeat=3]
B [cond="opcode is xor and arg2 is 0x11"]
C [cond="opcode is sub and arg2 is 0x25"]
D [cond=true, repeat=3]
E [cond="opcode beginswith j and nchildren == 2"]

A -> B
B -> C
C -> D
D -> E
E -> A [childnumber=2]
}

Nota che i file di pattern possono contenere più grafi di pattern.

Puoi trovare ulteriori esempi di pattern in due directory:

• patterns/ contiene alcuni pattern che possono essere utili su qualsiasi binario, come un pattern per rilevare loop brevi o per rilevare un loop su blocchi di base,
• examples/ contiene pattern usati contro il malware Backspace (vedi examples/backspace_samples.md per ottenere i campioni binari).

Tutorial e ulteriori esempi

Su campioni di malware:

• Navigare campioni di malware con grap (CLI, IDA): https://yaps8.github.io/blog/grap_qakbot_navigation
• Automatizzare parsing e decifratura di funzioni (binding Python): https://yaps8.github.io/blog/grap_qakbot_strings

Utilizzo dei binding Python:

• File Python che dimostra come usare i binding per analizzare campioni Backspace: examples/analyze_backspace.py
• Esempi di scripting IDApython sono integrati nel plugin IDA, puoi vederli qui: https://yaps8.github.io/grap/html/scripting_css.html

Documentazione

Troverai ulteriore documentazione nella cartella doc/:

• doc/COMPILE_OPTIONS.md
• doc/DEBUG.md
• doc/TESTS.md
• doc/syntax_highlighting.md

La sintassi dei pattern e dei grafi di test è dettagliata nel file grap_graphs.pdf nella sezione release.

Licenza

grap è concesso in licenza sotto la licenza MIT. Il testo completo della licenza si trova in LICENSE.