python-haystack Speicherforensik ################################

Schnellstart:

Schnellstart-Anleitung <docs/Haystack_basic_usage.ipynb>_ im docs/-Ordner.

Haystack-reverse CLI <docs/Haystack_reverse_CLI.ipynb>_ im docs/-Ordner.

Weitere Dokumentation <http://python-haystack.readthedocs.io/en/latest/>_

Einführung:

python-haystack ist ein Heap-Analyse-Framework, das sich auf die Suche und das Reverse Engineering von C-Strukturen im allozierten Speicher konzentriert.

Die erste Funktion/API ist die SEARCH-Funktion. Sie ermöglicht die Suche nach bekannten Record-Typen in einem Prozess-Speicherabbild oder dem Speicher eines laufenden Prozesses.

Die zweite Funktion/API ist die REVERSE-Funktion in der Erweiterung python-haystack-reverse <https://github.com/trolldbois/python-haystack-reverse>_ Sie zielt darauf ab, einen Analysten beim Reverse Engineering der im Prozess-Heap vorhandenen Speicher-Record-Typen zu unterstützen. Der Fokus liegt auf der Rekonstruktion und Klassifizierung klassischer C-Strukturen aus dem Speicher. Es wird versucht, Typdefinitionen zu rekonstruieren.

Skripte & Memory-Handler-Format:

Es gibt einige Einstiegspunkte, um das Format Ihres Speicherabbilds zu verarbeiten.

Speicherabbild-Ordner, erstellt von `haystack-live-dump`

haystack-find-heap erlaubt die Anzeige von Details zu Windows HEAP.
haystack-search Such-CLI
haystack-show Anzeige-CLI für einen bestimmten Record-Typ an einer bestimmten Adresse

Sie können die folgende URL verwenden, um Ihren Memory-Handler/Ihr Speicherabbild zu bezeichnen:

dir:///path/to/my/haystack/fump/folder zur Verwendung des haystack-Abbildformats
dmp:///path/to/my/minidump/file verwendet das Minidump-Format (microsoft?)
frida://name_or_pid_of_process_to_attach_to verwendet frida, um auf den Speicher eines laufenden Prozesses zuzugreifen
live://name_or_pid_of_process_to_attach_to ptrace eines laufenden Prozesses
rekall:// lädt ein Rekall-Image
volatility:// lädt ein Volatility-Image
cuckoo:// lädt ein von Cuckoo erstelltes Speicherabbild (Beta, möglicherweise Patch erforderlich)

So erhalten Sie ein Speicherabbild:

Unter Windows ist der einfachste Weg, ein Minidump zu erhalten. Die Microsoft Sysinternals-Toolsuite bietet entweder eine CLI (procdump.exe) oder eine GUI (Process Explorer). Mit einem dieser Tools (mit der Option für vollständiges Speicherabbild) erzeugen Sie eine Datei, die mit der Liste der Einstiegspunkte haystack-minidump-xxx verwendet werden kann.

Obwohl Sie technisch gesehen viele Drittanbieter-Tools verwenden könnten, benötigt haystack tatsächlich Memory-Mapping-Informationen, um zu funktionieren. Daher ist ein Dumping-Tool enthalten: haystack-live-dump:

.. code-block:: bash

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

Für laufende Prozesse

haystack-live-dump erfasst ein Prozess-Speicherabbild in einem Ordner (haystack-Format)

Für ein Rekall-Speicherabbild

haystack-rekall-dump dumpst einen bestimmten Prozess in ein haystack-Prozessabbild

Für ein Volatility-Speicherabbild

haystack-volatility-dump dumpst einen bestimmten Prozess in ein haystack-Prozessabbild

Sie können das Format des Abbilds leicht reproduzieren: Es ist ein Ordner/Archiv, das jede Speicherzuordnung in einer separaten Datei enthält:

Speicherinhalt in einer Datei, benannt nach ihrer Start-/Endadresse (0x000700000-0x000800000)
'mappings'-Datei enthält Metadaten der Speicherzuordnungen. ( mappings )

Oder Sie können eine haystack.abc.IMemoryMapping-Implementierung für Ihr bevorzugtes Format programmieren.

Andernfalls, wenn Sie bereits ein System-Speicherabbild von Volatility oder Rekall haben, können Sie die Familien der Einstiegspunkte haystack-rekall-xxx oder haystack-volatility-xxx verwenden, um den Speicher eines bestimmten Prozesses in eine Datei zu extrahieren.

Überprüfen von Windows-Heap-Attributen:

Der Einstiegspunkt haystack-find-heap ermöglicht die Anzeige von Details zu Windows HEAP. Es sollte unterstützen:

Windows XP 32 bits
Windows XP 64 bits
Windows 7 32 bits
Windows 7 64 bits

und Details des Look-Aside-List (LAL) und Low-Fragmentation-Heap (LFH)-Frontends anzeigen.

Sie werden vielleicht überrascht sein, dass ein einzelner Prozess manchmal die beiden Heap-Typen (32 & 64) mischen kann.

Suche nach bekannten Strukturen:

Um nach einem bestimmten Record zu suchen, müssen Sie zunächst diesen Record-Typ definieren. Eine [Schnellstart-Anleitung](docs/Haystack basic usage.ipynb) ist verfügbar, um die grundlegenden Schritte von einer C-Header-Datei zu einer Python-ctypes-Definition durchzugehen. Oder Sie können es selbst mit traditionellen Python-ctypes-Records machen.

Die Such-API ist über die Familie der Skripte haystack-xxx-search verfügbar, aber auch als API, sodass Sie diese Suche in Ihren eigenen Code einbetten können.

Kurz gesagt, die haystack-Suche iteriert über jeden Offset des Programmspeichers, um einen 'gültigen' Offset für diesen bestimmten Record-Typ zu finden.

Die Gültigkeit des Records wird durch Typ-Einschränkungen bestimmt, wie:

Zeigerfelder sollten gültige Adressraumwerte haben
benutzerdefinierte Typ-Einschränkungen (siehe Abschnitt 'Constraints-Datei' unten)
usw.

.. code-block:: bash

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

Constraints-Datei:

Die folgenden Einschränkungen werden unterstützt:

IgnoreMember: Der Wert dieses Feldes wird ignoriert. Nützlich, um Zeigerfelder zu ignorieren.
NotNull: Der Wert dieses Feldes darf nicht 0 sein.
RangeValue(x,y): Das Feld muss einen Wert zwischen x und y haben.
PerfectMatch('hello world'): Das Feld (ein String) muss mit 'hello world' übereinstimmen
[1,2,3]: Eine Liste von Werten, die das Feld haben sollte
[1, RangeValue(12,16), 42]: Der Feldwert sollte 1, 12-16 oder 42 sein.

Beispiel:

.. code-block:: python

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

Sie können einen Blick auf haystack/allocators/win32/winxpheap32.constraints werfen, wo die Einschränkungen eines Windows XP HEAP x32 definiert sind.

Je mehr Einschränkungen, desto besser werden die Ergebnisse sein.

Dynamische Einschränkungsdefinition:

Sie können auch komplexere Einschränkungen mit Python-Code erstellen, indem Sie eine Klasse haystack.abc.interface.IRecordTypeDynamicConstraintsValidator implementieren und sie an die ModuleConstraints.set_dynamic_constraints übergeben.

Kommandozeilenbeispiel:

sslsnoop-Repository benötigt ein Update, um mit Versionen > v0.30 kompatibel zu sein – ausstehend

Zum Beispiel werden hiermit die session_state-Strukturen + die referenzierten Kindstrukturen als Python-Objekt ausgegeben, mit dem wir spielen können. Nehmen wir an, wir haben einen SSH-Client oder -Server mit der 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

Grafische Benutzeroberfläche:

Dies funktioniert derzeit nicht

Es gibt auch einen Versuch einer grafischen Benutzeroberfläche: python-haystack-gui <https://github.com/trolldbois/python-haystack-gui>_

Python-API-Beispiel:

Siehe die Schnellstart-Anleitung <docs/Haystack_basic_usage.ipynb>_

So definieren Sie Ihre eigenen Strukturen:

Der einfachste Weg ist die Verwendung von ctypeslib, um ctypes-Records aus C-Headern zu generieren.

Oder definieren Sie Ihre Python-ctypes-Records von Hand.

Erweiterungsbeispiele:

@ siehe sslsnoop im PyPI-Repository. OpenSSL- und NSS-Strukturen werden generiert.

@ siehe ctypes-kernel auf meinem GitHub. Linux-Kernel-Strukturen werden aus einem gebauten Kernel-Baum generiert. (VMM ist die Hölle)

Nicht so FAQ:

Was macht es?:

Die grundlegende Funktionalität besteht darin, im Speicher eines Prozesses nach einem bestimmten C-Record zu suchen.

Die erweiterte Reverse-Engineering-Funktionalität zielt darauf ab, Strukturen aus der Speicher-/Heap-Analyse zu rekonstruieren.

Woher weiß es, dass die Strukturen gültig sind?:

Sie fügen einige Einschränkungen zu den erwarteten Werten der Record-Felder hinzu. Zeiger werden immer auf gültigen Speicherplatz eingeschränkt.

Woher kommt die Idee?:

Ursprünglich von passe-partout <http://www.hsc.fr/ressources/breves/passe-partout.html.fr>_. Seit ich im März 2011 begonnen habe, habe ich mehrere andere verwandte frühere Arbeiten entdeckt.

Die meisten davon befinden sich im docs/-Ordner.

Weitere verwandte Arbeiten sind mona.py von Immunity, einige andere Sachen von Mandiant...

Im Grunde ist dies wahrscheinlich keine originelle Idee. Aber dennoch konnte ich keine betriebsbereite eigenständige Bibliothek für die Live-Speicherextraktion für meinen sslsnoop-PoC finden, also....

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