ModuleShifting

Cet outil a été présenté lors de la conférence 2023 x33fcon : "Améliorer la furtivité des techniques d'injection mémoire" [Vidéo] [Article de blog]

Qu'est-ce que c'est

ModuleShifting est une variante plus furtive des techniques d'injection Module Stomping et Module Overloading. Elle est implémentée en Python ctypes afin de pouvoir être exécutée entièrement en mémoire via un interpréteur Python et Pyramid, évitant ainsi l'utilisation de chargeurs compilés.

La technique peut être utilisée avec des charges utiles PE ou shellcode ; cependant, la variante la plus furtive est destinée à être utilisée avec des charges utiles shellcode qui doivent être fonctionnellement indépendantes de la charge utile finale que le shellcode charge.

ModuleShifting, lorsqu'il est utilisé avec une charge utile shellcode, effectue les opérations suivantes :

1. La dll hôte légitime est chargée via LoadLibrary
2. Modifier les permissions mémoire d'une section spécifiée en RW
3. Écraser le shellcode sur la section cible
4. Ajouter un remplissage optionnel pour mieux se fondre dans les comportements de faux positifs (plus d'informations ici)
5. Modifier les permissions en RX
6. Exécuter le shellcode via un pointeur de fonction - méthodes d'exécution supplémentaires : fonction de rappel ou API CreateThread
7. Écrire le contenu original de la dll sur le shellcode exécuté - cette étape évite de laisser un artefact mémoire malveillant dans l'espace mémoire image de la dll hôte. Le shellcode doit être fonctionnellement indépendant des étapes ultérieures, sinon l'exécution échouera.

Lors de l'utilisation d'une charge utile PE, ModuleShifting effectue les opérations suivantes :

1. La dll hôte légitime est chargée via LoadLibrary
2. Modifier les permissions mémoire d'une section spécifiée en RW
3. Copier le PE sur le point cible spécifié section par section
4. Ajouter un remplissage optionnel pour mieux se fondre dans les comportements de faux positifs
5. Effectuer le relogement de base
6. Résoudre les imports
7. Finaliser la section en attribuant les permissions à leurs valeurs natives (évite la création d'une région mémoire RWX)
8. Exécution des callbacks TLS
9. Exécution du point d'entrée du PE

Pourquoi c'est utile

ModuleShifting peut être utilisé pour injecter une charge utile sans allouer dynamiquement de mémoire (c'est-à-dire VirtualAlloc) et, comparé à Module Stomping et Module Overloading, il est plus furtif car il réduit le nombre d'IoC générés par la technique d'injection elle-même.

Il existe 3 différences principales entre Module Shifting et certaines implémentations publiques de Module Stomping (une de Bobby Cooke et WithSecure)

1. Remplissage : lors de l'écriture du shellcode ou du PE, vous pouvez utiliser un remplissage pour mieux vous fondre dans les comportements courants de faux positifs (comme des applications tierces ou des dll .NET écrivant x octets sur leur section .text).
2. Exécution du shellcode à l'aide d'un pointeur de fonction. Cela aide à éviter la création d'un nouveau thread ou l'appel de callbacks de fonctions inhabituelles.
3. Restauration du contenu original de la dll sur le shellcode exécuté. C'est une différence clé.

Les différences entre Module Shifting et Module Overloading sont les suivantes :

1. Le PE peut être écrit à partir d'une section spécifiée au lieu de partir du PE de la dll hôte. Une fois la section cible soigneusement choisie, cela peut réduire le nombre d'IoC générés (par exemple, l'en-tête PE de la dll hôte n'est pas écrasé, ou moins d'octets sont écrasés sur la section .text, etc.)
2. Remplissage qui peut être ajouté à la charge utile PE elle-même pour mieux se fondre dans les faux positifs.

En utilisant une charge utile shellcode fonctionnellement indépendante, telle qu'une charge utile shellcode AceLdr Beacon Stageless, ModuleShifting est capable d'injecter localement sans allouer dynamiquement de mémoire et, actuellement, en générant zéro IoC lors d'un scan Moneta et PE-Sieve. Je suis conscient que les charges utiles endormies d'AceLdr peuvent être détectées avec d'autres excellents outils tels que Hunt-Sleeping-Beacon, mais l'accent est ici mis sur la technique d'injection elle-même, pas sur la charge utile. Dans notre cas, ce qui permet une plus grande furtivité dans l'injection est l'indépendance fonctionnelle du shellcode, de sorte que les octets malveillants écrits peuvent être restaurés à leur contenu original, effaçant ainsi les traces de l'injection.

Avertissement

Toutes les informations et tout le contenu sont fournis à des fins éducatives uniquement. Suivez les instructions à vos propres risques. Ni l'auteur ni son employeur ne sont responsables des dommages directs ou indirects ou des pertes résultant de toute personne ou organisation.

Crédits

Ce travail a été rendu possible grâce aux connaissances et aux outils partagés par des personnes incroyables comme Aleksandra Doniec @hasherezade, Forest Orr et Kyle Avery. J'ai massivement utilisé Moneta, PeSieve, PE-Bear et AceLdr tout au long de mon processus d'apprentissage et ils ont été essentiels à ma compréhension de ce sujet.

Utilisation

ModuleShifting peut être utilisé avec Pyramid et un interpréteur Python pour exécuter l'injection de processus local entièrement en mémoire, évitant ainsi les chargeurs compilés.

1. Clonez le dépôt Pyramid :

git clone https://github.com/naksyn/Pyramid

2. Générez une charge utile shellcode avec votre C2 préféré et déposez-la dans le dossier Delivery_files de Pyramid. Voir la section Mises en garde pour les exigences relatives à la charge utile.
3. Modifiez les paramètres du script moduleshifting.py dans le dossier Modules de Pyramid.
4. Démarrez le serveur Pyramid : python3 pyramid.py -u testuser -pass testpass -p 443 -enc chacha20 -passenc superpass -generate -server 192.168.1.2 -setcradle moduleshifting.py
5. Exécutez le code cradle généré sur un interpréteur Python.

Démo

https://github.com/naksyn/ModuleShifting/assets/59816245/67fcf888-3385-47da-b828-8a2dafeeb1e2

Mises en garde

Pour exécuter avec succès cette technique, vous devez utiliser une charge utile shellcode capable de charger une charge utile supplémentaire autonome dans une autre zone mémoire. ModuleShifting a été testé avec la charge utile AceLdr, qui est capable de charger une copie entière de Beacon sur le tas, brisant ainsi la dépendance fonctionnelle avec le shellcode initial. Cette technique fonctionnerait avec toute charge utile shellcode ayant des capacités similaires. Ainsi, le shellcode initial devient inutile une fois exécuté et il n'y a aucune raison de le conserver en mémoire comme un IoC.

Une dll hôte avec suffisamment d'espace pour le shellcode sur la section ciblée doit également être choisie, sinon la technique échouera.

Opportunités de détection

Module Stomping et Module Shifting doivent écrire le shellcode sur l'espace mémoire d'une dll légitime. ModuleShifting éliminera cet IoC après la phase de nettoyage, mais des indicateurs pourraient être repérés par des scanners dotés de capacités d'inspection en temps réel.