python-haystack analyse forensique de la mémoire

################################

Démarrage rapide :

Guide d'utilisation rapide <docs/Haystack_basic_usage.ipynb>_ dans le dossier docs/.

Haystack-reverse CLI <docs/Haystack_reverse_CLI.ipynb>_ dans le dossier docs/.

Plus de documentation <http://python-haystack.readthedocs.io/en/latest/>_

Introduction :

python-haystack est un framework d'analyse du tas (heap), axé sur la recherche et le rétro-ingénierie de structures C dans la mémoire allouée.

La première fonction/API est la fonction SEARCH. Elle permet de rechercher des types d'enregistrements connus dans un vidage mémoire d'un processus ou dans la mémoire d'un processus en direct.

La deuxième fonction/API est la fonction REVERSE dans l'extension python-haystack-reverse <https://github.com/trolldbois/python-haystack-reverse>_ Elle vise à aider un analyste à rétro-ingénier les types d'enregistrements mémoire présents dans le tas d'un processus. Elle se concentre sur la reconstruction et la classification des structures C classiques à partir de la mémoire. Elle tente de recréer les définitions de types.

Scripts et format du gestionnaire de mémoire :

Quelques points d'entrée existent pour gérer le format de votre vidage mémoire.

Dossier de vidage mémoire produit par `haystack-live-dump`

haystack-find-heap permet d'afficher les détails sur le tas Windows.
haystack-search interface CLI de recherche
haystack-show interface CLI d'affichage pour un type d'enregistrement spécifique à une adresse donnée

Vous pouvez utiliser les URL suivantes pour désigner votre gestionnaire/ vidage mémoire :

dir:///chemin/vers/mon/dossier/de/vidage/haystack pour utiliser le format de vidage haystack
dmp:///chemin/vers/mon/fichier/minidump pour utiliser le format minidump (Microsoft ?)
frida://nom_ou_pid_du_processus_à_attacher pour utiliser frida afin d'accéder à la mémoire d'un processus en direct
live://nom_ou_pid_du_processus_à_attacher pour tracer (ptrace) un processus en direct
rekall:// pour charger une image rekall
volatility:// pour charger une image volatility
cuckoo:// pour charger un vidage mémoire produit par Cuckoo (bêta, peut nécessiter un correctif)

Comment obtenir un vidage mémoire ?

Sous Windows, le plus simple est d'obtenir un Minidump. La suite d'outils Microsoft Sysinternals fournit soit un CLI (procdump.exe) soit une interface graphique (Process Explorer). En utilisant l'un de ces outils (avec l'option de vidage mémoire complet), vous produirez un fichier qui peut être utilisé avec la liste de points d'entrée haystack-minidump-xxx.

Bien que techniquement vous puissiez utiliser de nombreux outils tiers, haystack a en réalité besoin des informations de mappage mémoire pour fonctionner. C'est pourquoi un outil de vidage est inclus : haystack-live-dump :

.. code-block:: bash

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

Pour les processus en direct

haystack-live-dump capture un vidage mémoire d'un processus vers un dossier (format haystack)

Pour un vidage mémoire Rekall

haystack-rekall-dump vide un processus spécifique vers un vidage de processus haystack

Pour un vidage mémoire Volatility

haystack-volatility-dump vide un processus spécifique vers un vidage de processus haystack

Vous pouvez facilement reproduire le format du vidage : il s'agit d'un dossier/archive contenant chaque carte mémoire dans un fichier séparé :

contenu mémoire dans un fichier nommé d'après ses adresses de début/fin ( 0x000700000-0x000800000 )
fichier 'mappings' contenant les métadonnées des mappages mémoire. ( mappings )

Ou vous pouvez coder une implémentation de haystack.abc.IMemoryMapping pour votre format préféré.

Sinon, si vous avez déjà un vidage mémoire système provenant de Volatility ou Rekall, vous pouvez utiliser les familles de points d'entrée haystack-rekall-xxx ou haystack-volatility-xxx pour extraire la mémoire d'un processus spécifique dans un fichier.

Vérification des attributs du tas Windows :

Le point d'entrée haystack-find-heap permet d'afficher les détails sur le tas Windows. Il devrait prendre en charge :

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

et afficher les détails de la liste de côté (LAL) et du tas à faible fragmentation (LFH) frontal (frontend).

Vous pourriez être surpris de constater que parfois, un seul processus peut mélanger les deux types de TAS (32 et 64).

Recherche de structures connues :

Pour rechercher un enregistrement spécifique, vous devez d'abord définir ce type d'enregistrement. Un [guide d'utilisation rapide](docs/Haystack basic usage.ipynb) est disponible pour parcourir les étapes de base allant d'un fichier d'en-tête C à une définition Python ctypes. Ou vous pouvez le faire vous-même, avec des enregistrements Python ctypes traditionnels.

L'API de recherche est disponible via la famille de scripts haystack-xxx-search mais aussi via une API afin que vous puissiez intégrer cette recherche dans votre propre code.

En résumé, la recherche haystack parcourra chaque décalage (offset) de la mémoire du programme pour tenter de trouver un décalage 'valide' pour ce type d'enregistrement spécifique.

La validité de l'enregistrement est déterminée par des contraintes de type telles que :

les champs pointeurs doivent avoir des valeurs d'espace d'adressage valides
des contraintes de type définies par l'utilisateur (voir la section 'Fichier de contraintes' ci-dessous)
etc...

.. code-block:: bash

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

Fichier de contraintes :

Les contraintes suivantes sont prises en charge :

IgnoreMember : La valeur de ce champ sera ignorée. Utile pour ignorer les champs pointeurs.
NotNull : La valeur de ce champ ne doit pas être 0.
RangeValue(x,y) : le champ doit avoir une valeur entre x et y.
PerfectMatch('hello world') : le champ (une chaîne) doit correspondre à 'hello world'
[1,2,3] : une liste de valeurs que le champ doit avoir
[1, RangeValue(12,16), 42] : la valeur du champ doit être 1, 12-16 ou 42.

Exemple :

.. code-block:: python

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

Vous pouvez consulter haystack/allocators/win32/winxpheap32.constraints, où les contraintes d'un TAS Windows XP x32 sont définies.

Évidemment, plus il y a de contraintes, meilleurs seront les résultats.

Définition dynamique de contraintes :

Vous pouvez également créer des contraintes plus complexes en utilisant du code Python en implémentant une classe haystack.abc.interface.IRecordTypeDynamicConstraintsValidator et en la transmettant à ModuleConstraints.set_dynamic_constraints

Exemple en ligne de commande :

Le dépôt sslsnoop nécessite une mise à jour pour être compatible avec les versions > v0.30 - en attente

Par exemple, cela videra les structures session_state ainsi que les structures enfants pointées sous forme d'un objet Python avec lequel nous pouvons jouer. Supposons que nous ayons un client ou serveur ssh avec le 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

Interface graphique :

Cela ne fonctionne pas pour le moment

Il existe également une tentative d'interface graphique python-haystack-gui <https://github.com/trolldbois/python-haystack-gui>_

Exemple d'API python :

Voir le guide d'utilisation rapide <docs/Haystack_basic_usage.ipynb>_

Comment définir vos propres structures :

La façon la plus simple est d'utiliser ctypeslib pour générer des enregistrements ctypes à partir d'en-têtes C.

Ou définissez vos enregistrements Python ctypes manuellement.

Exemples d'extension :

@ voir sslsnoop dans le dépôt Pypi. Les structures openssl et nss sont générées.

@ voir ctypes-kernel sur mon github. Les structures du noyau Linux sont générées à partir d'une arborescence de noyau compilée. (VMM est une garce)

FAQ pas si courante :

Que fait-il ? :

La fonctionnalité de base est de rechercher dans la mémoire d'un processus un enregistrement C spécifique.

La fonctionnalité étendue de rétro-ingénierie vise à inverser (reverse) des structures à partir de l'analyse de la mémoire/du tas.

Comment sait-il que les structures sont valides ? :

Vous ajoutez des contraintes sur les valeurs attendues des champs de l'enregistrement. Les pointeurs sont toujours contraints à un espace mémoire valide.

D'où vient l'idée ? :

À l'origine de passe-partout <http://www.hsc.fr/ressources/breves/passe-partout.html.fr>_. Depuis que j'ai commencé en mars 2011, j'ai découvert plusieurs autres travaux antérieurs connexes.

La plupart d'entre eux se trouvent dans le dossier docs/.

D'autres travaux connexes sont mona.py d'Immunity, certains trucs de Mandiant...

En résumé, ce n'est probablement pas une idée originale. Mais pourtant, je n'ai pas trouvé de bibliothèque autonome opérationnelle pour l'extraction de mémoire en direct pour mon PoC sslsnoop, donc...

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

Quelles sont les dépendances ? :

python-ptrace sur linux
winappdbg sur win32 (pas sûr que cela fonctionne, les retours sont les bienvenus)
python-numpy
python-networkx
python-levenshtein
plusieurs autres...