python-haystack analisi forense della memoria ################################

Avvio rapido:

Guida rapida all'uso <docs/Haystack_basic_usage.ipynb>_ nella cartella docs/.

Haystack-reverse CLI <docs/Haystack_reverse_CLI.ipynb>_ nella cartella docs/.

Ulteriore documentazione <http://python-haystack.readthedocs.io/en/latest/>_

Introduzione:

python-haystack è un framework di analisi dell'heap, focalizzato sulla ricerca e sul reverse engineering delle strutture C nella memoria allocata.

La prima funzione/API è la funzione SEARCH. Fornisce la capacità di cercare tipi di record noti in un dump di memoria di un processo o nella memoria di un processo in esecuzione.

La seconda funzione/API è la funzione REVERSE nell'estensione python-haystack-reverse <https://github.com/trolldbois/python-haystack-reverse>_ Ha lo scopo di aiutare un analista nel reverse engineering dei tipi di record di memoria presenti nell'heap di un processo. Si concentra sulla ricostruzione e classificazione delle strutture C classiche dalla memoria. Tenta di ricreare le definizioni dei tipi.

Script e formato del gestore della memoria:

Esistono alcuni punti di ingresso per gestire il formato del tuo dump di memoria.

Cartella del dump di memoria prodotta da `haystack-live-dump`

haystack-find-heap permette di mostrare i dettagli sull'HEAP di Windows.
haystack-search CLI di ricerca
haystack-show CLI di visualizzazione per un tipo di record specifico a un indirizzo specifico

Puoi utilizzare i seguenti URL per designare il tuo gestore/dump di memoria:

dir:///path/to/my/haystack/fump/folder per utilizzare il formato dump haystack
dmp:///path/to/my/minidump/file per utilizzare il formato minidump (microsoft?)
frida://name_or_pid_of_process_to_attach_to per utilizzare frida per accedere alla memoria di un processo in esecuzione
live://name_or_pid_of_process_to_attach_to per eseguire ptrace di un processo in esecuzione
rekall:// per caricare un'immagine rekall
volatility:// per caricare un'immagine volatility
cuckoo:// per caricare un dump di memoria prodotto da Cuckoo (beta potrebbe richiedere patch)

Come ottenere un dump di memoria:

Su Windows, il metodo più diretto è ottenere un Minidump. La suite Microsoft Sysinternals fornisce sia un CLI (procdump.exe) che una GUI (Process explorer). Utilizzando uno di questi (con l'opzione di dump completo della memoria) otterrai un file che può essere utilizzato con l'elenco dei punti di ingresso haystack-minidump-xxx.

Sebbene tecnicamente potresti utilizzare molti strumenti di terze parti, haystack ha effettivamente bisogno delle informazioni di mappatura della memoria per funzionare. Quindi è incluso uno strumento di dump haystack-live-dump:

.. code-block:: bash

# haystack-live-dump <pid> myproc.dump

Per processi in esecuzione

haystack-live-dump cattura un dump di memoria di un processo in una cartella (formato haystack)

Per un dump di memoria Rekall

haystack-rekall-dump scarica un processo specifico in un dump di processo haystack

Per un dump di memoria Volatility

haystack-volatility-dump scarica un processo specifico in un dump di processo haystack

È possibile riprodurre facilmente il formato del dump: si tratta di una cartella/archivio contenente ciascuna mappa di memoria in un file separato:

contenuto della memoria in un file denominato in base agli indirizzi di inizio/fine ( 0x000700000-0x000800000 )
file 'mappings' contenente i metadati delle mappe di memoria. ( mappings )

Oppure puoi codificare un'implementazione haystack.abc.IMemoryMapping per il tuo formato preferito.

Altrimenti, se hai già un dump di memoria di sistema da Volatility o Rekall, puoi utilizzare le famiglie di punti di ingresso haystack-rekall-xxx o haystack-volatility-xxx per estrarre la memoria di un processo specifico in un file.

Verifica degli attributi dell'heap di Windows:

Il punto di ingresso haystack-find-heap permette di mostrare i dettagli sull'HEAP di Windows. Dovrebbe supportare:

Windows XP 32 bit
Windows XP 64 bit
Windows 7 32 bit
Windows 7 64 bit

e mostrare i dettagli della Look Aside List (LAL) e dell'Low Fragmentation Heap (LFH) frontend.

Potresti essere sorpreso di vedere che, a volte, un singolo processo può mescolare i due tipi di HEAP (32 e 64).

Ricerca di strutture note:

Per cercare un record specifico, devi prima definire quel tipo di record. Una [guida rapida all'uso](docs/Haystack basic usage.ipynb) è disponibile per seguire i passaggi di base per passare da un file C Header a una definizione Python ctypes. Oppure puoi farlo da solo, con i tradizionali record Python ctypes.

L'API di ricerca è disponibile attraverso la famiglia di script haystack-xxx-search ma anche in una API in modo da poter incorporare questa ricerca nel tuo codice.

In breve, la ricerca haystack itererà su ogni offset della memoria del programma per cercare di trovare offset 'validi' per quel tipo di record specifico.

La validità del record è determinata dai vincoli del tipo come:

i campi puntatore dovrebbero avere valori di spazio degli indirizzi validi
vincoli di tipo definiti dall'utente (vedere la sezione 'File dei vincoli' di seguito)
ecc..

.. code-block:: bash

$ python haystack/cli.py dir:///home/user/project/python-haystack/test/src/test-ctypes6.32.dump ctypes6_gen32.struct_usual

File dei vincoli:

Sono supportati i seguenti vincoli:

IgnoreMember: Il valore di questo campo verrà ignorato. Utile per ignorare i campi puntatore.
NotNull: Il valore di questo campo non deve essere 0.
RangeValue(x,y): il campo deve avere un valore compreso tra x e y.
PerfectMatch('hello world'): il campo (una stringa) deve corrispondere a 'hello world'
[1,2,3]: Un elenco di valori che i campi dovrebbero avere
[1, RangeValue(12,16), 42]: Il valore del campo dovrebbe essere 1, 12-16 o 42.

Esempio:

.. code-block:: python

[struct_name]
myfield: [1,0xff]
ptr_field: NotNull

Puoi dare un'occhiata a haystack/allocators/win32/winxpheap32.constraints, dove sono definiti i vincoli di un HEAP x32 di Windows XP.

Ovviamente, più vincoli ci sono, migliori saranno i risultati.

Definizione di vincoli dinamici:

Puoi anche creare vincoli più complessi utilizzando codice Python implementando una classe haystack.abc.interface.IRecordTypeDynamicConstraintsValidator e fornendola a ModuleConstraints.set_dynamic_constraints

Esempio da riga di comando:

Il repository sslsnoop necessita di un aggiornamento per essere compatibile con le versioni > v0.30 - in sospeso

Ad esempio, questo dumpa le strutture session_state + le strutture figlie puntate come un oggetto Python con cui possiamo giocare. Supponiamo di avere un client o server ssh con pid 4042:

.. code-block:: bash

$ sudo haystack-live-search --pickled 4042 sslsnoop.ctypes_openssh.session_state search > instance.pickled
$ sudo haystack-live-search --pickled 4042 sslsnoop.ctypes_openssh.session_state refresh 0xb8b70d18 > instance.pickled
$ sudo haystack-live-search --pickled <pid> <your ctypes Structure> search

Interfaccia grafica:

Al momento non funziona

Esiste anche un tentativo di interfaccia grafica python-haystack-gui <https://github.com/trolldbois/python-haystack-gui>_

Esempio di API Python:

Vedi la guida rapida all'uso <docs/Haystack_basic_usage.ipynb>_

Come definire le proprie strutture:

Il modo più semplice è utilizzare ctypeslib per generare record ctypes da file C Header.

Oppure definisci manualmente i tuoi record Python ctypes.

Esempi di estensioni:

@ vedi sslsnoop nel repository Pypi. Le strutture openssl e nss vengono generate.

@ vedi ctypes-kernel sul mio github. Le strutture del kernel Linux vengono generate da un albero del kernel compilato. (VMM è una scocciatura)

Domande non così frequenti:

Cosa fa?:

La funzionalità di base è cercare nella memoria di un processo un record C specifico.

La funzionalità estesa di reverse engineering mira a ricostruire le strutture dall'analisi della memoria/dell'heap.

Come fa a sapere che la struttura è valida?:

Aggiungi alcuni vincoli sui valori attesi dei campi del record. I puntatori sono sempre vincolati a spazio di memoria valido.

Da dove viene l'idea?:

passe-partout <http://www.hsc.fr/ressources/breves/passe-partout.html.fr>_ originariamente. Da quando ho iniziato a marzo 2011, ho scoperto diversi altri lavori correlati precedenti.

La maggior parte si trovano nella cartella docs/.

Altri lavori correlati sono mona.py di Immunity, alcune cose di Mandiant...

In poche parole, probabilmente non è un'idea originale. Ma tuttavia, non ho trovato una libreria standalone operativa per l'estrazione di memoria in tempo reale per il mio PoC sslsnoop, quindi...

Lavori correlati <https://github.com/trolldbois/python-haystack/wiki/State-of-art-reference>_