[!CAUTION] Ce dépôt n'est plus maintenu, visitez https://github.com/sadreck/Spartacus pour la dernière version.

Spartacus DLL/COM Hijacking Toolkit

Pourquoi « Spartacus » ?

Si vous avez vu le film Spartacus de 1960, vous vous souviendrez de la scène où les Romains demandent à Spartacus de se rendre. Au moment où le vrai Spartacus s'est levé, beaucoup d'autres se sont levés aussi et ont prétendu être lui en utilisant la phrase « JE SUIS SPARTACUS ».

Lorsqu'un processus vulnérable au détournement de DLL demande le chargement d'une DLL, c'est un peu comme s'il demandait « QUI EST VERSION.DLL ? » et des répertoires aléatoires commencent à clamer « JE SUIS VERSION.DLL » et « NON, JE SUIS VERSION.DLL ». Et donc, Spartacus.

En quoi cet outil diffère-t-il de tous les autres outils de détournement existants ?

• Spartacus automatise la plupart du processus. Il analyse les journaux bruts de Process Monitor de SysInternals, et vous pouvez laisser ProcMon tourner pendant des heures et découvrir des vulnérabilités de détournement DLL/COM de 2e et 3e niveau (c'est-à-dire une application qui charge une autre DLL qui en charge une autre lorsque vous utilisez une fonctionnalité spécifique de l'application parente).
• Génère automatiquement des solutions Visual Studio pour les DLL vulnérables.
• Capable de traiter de gros fichiers PML et de stocker tous les événements d'intérêt dans un fichier CSV. Benchmark local : a traité un fichier de 3 Go avec 8 millions d'événements en 45 secondes.
• Prend en charge la recherche de vulnérabilités de détournement DLL et COM.
• Prend en charge la génération de certificats auto-signés et la signature de fichiers DLL.
• En utilisant les fonctionnalités de Ghidra, extrait les signatures des fonctions exportées et exécute votre charge utile via des fonctions mandatées individuellement au lieu de tout exécuter depuis DllMain. Cette technique a été inspirée et implémentée à partir de l'explication sur https://www.redteam.cafe/red-team/dll-sideloading/dll-sideloading-not-by-dllmain, par Shantanu Khandelwal.
• [Défense] Mode de surveillance tentant d'identifier les applications en cours d'exécution qui mandatent des appels, comme dans « Détournement de DLL en cours ». Ce n'est que pour attraper les fruits tombés et ne doit pas être considéré comme fiable.

Table des matières

• Installation
• Fonctionnalités prises en charge
  • Détournement de DLL
    • Utilisation
  • Détournement COM
    • Utilisation
  • Génération de mandataire DLL
    • Utilisation
  • Signature de fichiers DLL
    • Utilisation
  • Détection de détournement de DLL
• Arguments de ligne de commande
• Contributions
• Crédits

Installation

Trouvez et téléchargez la dernière version de Spartacus sous Releases. Sinon, clonez simplement ce dépôt et compilez à partir des sources.

Fonctionnalités prises en charge

Voici une description de chacun des modes que Spartacus prend en charge.

Remarque : Les arguments de ligne de commande ont considérablement changé entre la v1 et la v2.

Détournement de DLL

La fonctionnalité originale de Spartacus consistait uniquement à trouver des vulnérabilités de détournement de DLL. Son fonctionnement est le suivant :

1. Générer un fichier de configuration ProcMon (PMC) à la volée, basé sur les arguments passés. Les filtres qui seront définis sont :
   • L'opération est CreateFile.
   • Le chemin se termine par .dll.
   • Le nom du processus n'est pas procmon.exe ou procmon64.exe.
   • Activer Drop Filtered Events pour garantir une taille minimale du fichier PML.
   • Désactiver Auto Scroll.
2. Exécuter Process Monitor et s'arrêter jusqu'à ce que l'utilisateur appuie sur ENTRÉE.
3. L'utilisateur exécute/termine des processus, ou le laisse tourner aussi longtemps que nécessaire.
4. Arrêter Process Monitor lorsque l'utilisateur appuie sur ENTRÉE.
5. Analyser le fichier journal d'événements (PML) de sortie.
   1. Créer un fichier CSV avec toutes les DLL en NAME_NOT_FOUND et PATH_NOT_FOUND.
   2. Comparer les DLL ci-dessus et tenter d'identifier les DLL qui ont été effectivement chargées.
   3. Pour chaque DLL « trouvée », générer une solution Visual Studio pour mandater toutes les fonctions d'exportation de la DLL identifiée.

Utilisation du détournement de DLL

Collectez tous les événements et enregistrez-les dans C:\Data\logs.pml. Toutes les DLL vulnérables seront sauvegardées sous C:\Data\VulnerableDLLFiles.csv et toutes les solutions de DLL mandataires dans C:\Data\Solutions.

--mode dll --procmon C:\SysInternals\Procmon.exe --pml C:\Data\logs.pml --csv C:\Data\VulnerableDLLFiles.csv --solution C:\Data\Solutions --verbose

Analyser un fichier journal PML existant, sauvegarder la sortie au format CSV et générer des solutions Visual Studio mandataires.

--mode dll --existing --pml C:\MyData\SomeBackup.pml --csv C:\Data\VulnerableDLLFiles.csv --solution C:\Data\Solutions --verbose

Captures d'écran

Détournement COM

Une nouvelle fonctionnalité de Spartacus est d'identifier les vulnérabilités de détournement COM local. Son fonctionnement est le suivant :

1. Générer un fichier de configuration ProcMon (PMC) à la volée, basé sur les arguments passés. Les filtres qui seront définis sont :
   • L'opération est RegOpenKey.
   • Le nom du processus n'est pas procmon.exe ou procmon64.exe.
   • Activer Drop Filtered Events pour garantir une taille minimale du fichier PML.
   • Désactiver Auto Scroll.
2. Exécuter Process Monitor et s'arrêter jusqu'à ce que l'utilisateur appuie sur ENTRÉE.
3. L'utilisateur exécute/termine des processus, ou le laisse tourner aussi longtemps que nécessaire.
4. Arrêter Process Monitor lorsque l'utilisateur appuie sur ENTRÉE.
5. Analyser le fichier journal d'événements (PML) de sortie.
   1. Identifier toutes les clés de registre manquantes qui se terminent par InprocServer32 et dont le résultat est NAME_NOT_FOUND.
   2. Si la clé identifiée se trouve sous HKEY_CURRENT_USER, rechercher son GUID sous HKEY_CLASSES_ROOT et inclure ses détails dans le fichier CSV d'exportation (si trouvé).

Pour le détournement COM, Spartacus prend également en charge l'analyse du système local pour les entrées COM mal configurées :

1. Énumérer toutes les clés HKEY_CLASSES_ROOT, HKEY_CURRENT_USER et HKEY_LOCAL_MACHINE.
2. Rechercher les clés de registre appelées InProcServer, InProcServer32, LocalServer ou LocalServer32.
3. Identifier tout emplacement manquant d'EXE/DLL, ainsi que toute mauvaise configuration des ACL telle que la capacité de modifier ou de supprimer le fichier par l'utilisateur actuel.

Utilisation du détournement COM

Collectez tous les événements et enregistrez-les dans C:\Data\logs.pml. Toutes les informations COM vulnérables seront sauvegardées sous C:\Data\VulnerableCOM.csv.

--mode com --procmon C:\SysInternals\Procmon.exe --pml C:\Data\logs.pml --csv C:\Data\VulnerableCOM.csv --verbose

Traiter un fichier PML existant pour identifier les entrées COM vulnérables.

--mode com --existing --pml C:\Data\logs.pml --csv C:\Data\VulnerableCOM.csv --verbose

Énumérer le registre du système local pour identifier les bibliothèques et exécutables COM manquants ou mal configurés.

--mode com --acl --csv C:\Data\VulnerableCOM.csv --verbose

Captures d'écran

Génération de mandataire DLL

Spartacus prend en charge la génération de solutions Visual Studio en créant des projets squelette que vous pouvez utiliser, basés sur la DLL que vous souhaitez exploiter.

• Rediriger tous les appels en exportant les fonctions vers la DLL légitime.
  • Cela signifie que vous devrez exécuter votre charge utile depuis la fonction DllMain.
• En utilisant Ghidra, extraire autant de signatures/définitions de fonctions que possible de la DLL cible, et créer des fonctions mandataires pour celles-ci.
  • Pour toute fonction dont l'extraction de la signature n'a pas été possible, elle sera directement redirigée vers la fonction/DLL légitime.
  • Cela signifie que vous pouvez exécuter votre charge utile depuis une fonction extérieure à DllMain.
  • Par exemple, si vous souhaitez exploiter version.dll, vous pourriez exécuter votre implant depuis GetFileVersionInfoExW si cette fonction est appelée par l'application vulnérable.

Utilisation de la génération de mandataire DLL

Générer une solution qui redirige toutes les exportations (sans mandataire de fonction).

--mode proxy --dll C:\Windows\System32\version.dll --solution "C:\data\tmp\refactor-version" --overwrite --verbose --external-resources

Il est possible d'entrer plusieurs DLL en une seule fois.

--mode proxy --dll C:\Windows\System32\version.dll --dll C:\Windows\System32\userenv.dll --solution "C:\data\tmp\dll-collection" --overwrite --verbose --external-resources

Créer des mandataires pour autant de fonctions que possible (basé sur la sortie de Ghidra).

--mode proxy --ghidra C:\ghidra\support\analyzeHeadless.bat --dll C:\Windows\System32\userenv.dll --solution C:\Projects\spartacus-userenv --overwrite --verbose

Identique au précédent, mais utiliser des fichiers de ressources externes pour générer la solution (si vous devez les modifier).

--mode proxy --ghidra C:\ghidra\support\analyzeHeadless.bat --dll C:\Windows\System32\userenv.dll --solution C:\Projects\spartacus-userenv --overwrite --verbose --external-resources

Utiliser des prototypes de fonctions pré-générés pour les fonctions pour lesquelles Ghidra n'a pas pu extraire les définitions de fonctions.

--mode proxy --ghidra C:\ghidra\support\analyzeHeadless.bat --dll C:\Windows\System32\userenv.dll --solution C:\Projects\spartacus-userenv --overwrite --verbose --external-resources --prototypes C:\data\prototypes.csv

Générer des mandataires uniquement pour les fonctions GetFileVersionInfoExW et GetFileVersionInfoExA.

--mode proxy --ghidra C:\ghidra\support\analyzeHeadless.bat --dll C:\Windows\System32\version.dll --solution C:\Projects\spartacus-version --verbose --overwrite --external-resources --only "GetFileVersionInfoExW, GetFileVersionInfoExA"

Générer une base de données de prototypes de fonctions à partir de fichiers *.h existants, en aidant à générer des fonctions mandataires pour celles dont Ghidra n'a pas pu extraire la définition de fonction.

--mode proxy --action prototypes --path "C:\Program Files (x86)\Windows Kits" --csv C:\data\prototypes.csv --verbose

Lister les exportations d'une DLL et vérifier si chaque fonction possède un prototype pré-généré.

--mode proxy --action exports --dll C:\Windows\System32\version.dll --dll C:\Windows\System32\amsi.dll --prototypes ./Assets/prototypes.csv

Signature de fichiers DLL

Spartacus prend désormais en charge la génération de certificats auto-signés (tout en copiant les attributs des fichiers existants) et la signature de fichiers DLL.

Utilisation pour la signature de fichiers DLL

Créer un certificat de signature, en utilisant les propriétés de C:\Windows\System32\version.dll (doit être une DLL signée).

--mode sign --action generate --pfx "C:\Output\certificate.pfx" --password "Welcome1" --not-before "2022-12-31 00:00:55" --not-after "2026-01-01 00:00:01" --copy-from C:\Windows\System32\version.dll --verbose

Signer une DLL en utilisant un certificat existant/généré.

--mode sign --action sign --pfx "C:\Output\certificate.pfx" --password "Welcome1" --path "C:\Input\MyFakeVersion.dll" --algorithm SHA256 --verbose

Détection de détournement de DLL

Spartacus a également un mode --detect, qui essaie d'identifier un mandat actif de DLL. La logique derrière cela est :

• Énumérer tous les processus.
• Pour chaque processus, charger les DLL (modules) qu'il a chargées en mémoire (en supposant que vous ayez les bonnes permissions pour le faire).
• Si vous trouvez une DLL avec le même nom :
  • Si les deux fichiers se trouvent dans un chemin système (par exemple Windows, System32, Program Files), ignorer.
  • Si un seul des fichiers se trouve dans un chemin système et l'autre dans un emplacement accessible en écriture par l'utilisateur, signaler le fichier.

Pour utiliser cette fonctionnalité, exécutez simplement Spartacus avec --detect.

Auto-signature d'exécutables/DLLs

Spartacus prend en charge le mode --sign qui vous permet à la fois de générer des certificats auto-signés, mais aussi de signer les DLL compilées avec ceux-ci.

Générer un certificat auto-signé, en copiant l'Émetteur/Sujet d'un fichier existant :

--mode sign --action generate --pfx "C:\Output\myCertificate.pfx" --password "Welcome1" --not-before "2023-01-01 00:00:04" --not-after "2025-01-01 00:00:42" --copy-from C:\Windows\System32\version.dll --verbose

Et utilisez ce certificat pour signer votre fichier compilé :

--mode sign --action sign --pfx "C:\Output\myCertificate.pfx" --password "Welcome1" --path "C:\Projects\Spartacus-AMSI\amsi.dll" --algorithm SHA256 --verbose

Arguments de ligne de commande

Pour vous faciliter la vie, utilisez le fichier CommandLineGenerator.html.

Contributions

Que ce soit une faute de frappe, un bug ou une nouvelle fonctionnalité, Spartacus est très ouvert aux contributions tant que nous sommes d'accord sur les points suivants :

• Vous acceptez la licence MIT de ce projet.
• Avant de créer une pull request, créez un problème (issue) afin qu'il puisse être discuté avant d'effectuer tout travail, car le développement interne n'est pas suivi via le dépôt GitHub public. Sinon, vous risquez de voir votre pull request rejetée si, par exemple, nous travaillons déjà sur la même fonctionnalité ou une fonctionnalité similaire, ou pour toute autre raison.

Crédits

• https://github.com/eronnen/procmon-parser/
• https://www.redteam.cafe/red-team/dll-sideloading/dll-sideloading-not-by-dllmain
• https://stmxcsr.com/persistence/com-hijacking.html
• L'icône de Spartacus provient de Helmet icons created by Darius Dan - Flaticon | https://dariusdan.com/
• https://github.com/Danielku15/SigningServer