Développement pratique de malwares

Exercice 1 - Configuration de l'environnement

1. Configurez une machine virtuelle Windows dans un hyperviseur. a. Assurez-vous de prendre un instantané de votre installation de base.
2. Téléchargez et installez Visual Studio 2022 - https://visualstudio.microsoft.com/vs/ a. Sélectionnez la charge de travail Desktop development with C++ lors de l'installation
3. Téléchargez et installez :
   • DebugView++ - https://github.com/CobaltFusion/DebugViewPP
   • PE Bear - https://github.com/hasherezade/pe-bear
   • ProcMon - https://learn.microsoft.com/en-us/sysinternals/downloads/procmon
   • Ghidra - https://www.ghidra-sre.org/
   • Everything - https://www.voidtools.com/

De plus (optionnel), pour une expérience de rétro-ingénierie plus complète, configurez les symboles :

setx _NT_SYMBOL_PATH c:\Symbols;srv*c:\Symbols*https://msdl.microsoft.com/download/symbols

mkdir \symbols

4. Ouvrez PMD.sln dans Visual Studio.

5. Sélectionnez le projet setup et assurez-vous de pouvoir :

   a. Compiler le projet

   b. Voir l'instruction de débogage dans DebugView++.

Exercice 2 - Comprendre les propriétés PE

1. Mettez à jour les options du compilateur et de l'éditeur de liens du projet template pour manipuler les entrées de l'IAT et d'autres propriétés PE.

   a. Familiarisez-vous avec la résolution dynamique d'API et la documentation MSDN.

   b. Y a-t-il d'autres propriétés qui ressortent ? Si vous exécutez Strings.exe sur le binaire, des chaînes ressortent-elles ?

   c. Pouvez-vous les supprimer/mettre à jour ?

Utilisez l'outil de votre choix pour réaliser l'exercice (par exemple dumpbin/PE Bear). Un wrapper autour de pefile est fourni dans scripts\props.py (assurez-vous d'installer les dépendances).

2. Téléchargez quelques échantillons de malwares depuis VXUG

   a. Quelles sont les principales différences entre les exécutables bénins et malveillants ?

   b. Quelles sont les principales différences entre notre binaire et les exécutables bénins ?

Ressources supplémentaires

• https://learn.microsoft.com/en-us/cpp/build/reference/dumpbin-reference?view=msvc-170
• https://learn.microsoft.com/en-us/windows/win32/debug/pe-format
• https://learn.microsoft.com/en-us/previous-versions/ms809762(v=msdn.10)
• https://cloud.google.com/blog/topics/threat-intelligence/tracking-malware-import-hashing/
• https://github.com/rad9800/misc/blob/main/generic/fix-entropy.cpp
• https://github.com/rad9800/misc/blob/main/generic/stack-strings.cpp

Exercice 3 - Hachage d'API à la compilation

L'algorithme de hachage d'API actuellement utilisé est fnv1a.

1. Ouvrez le projet solution et appelez MessageBoxA en utilisant le framework de hachage d'API.
2. Utilisez un algorithme de hachage différent et assurez-vous de pouvoir toujours appeler MessageBoxA.

Ressources supplémentaires

• https://github.com/vxunderground/VX-API/tree/main/VX-API
• https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messageboxa

Exercice 4 - Trouver et exploiter le détournement de DLL

1. Téléchargez Cisco Webex (https://www.webex.com/downloads.html)

2. Trouvez CiscoCollabHost et voyez quelles DLL sont chargées

   • Utilisez Procmon/PE Bear/Ghidra ou ce que vous voulez !

3. Ouvrez CiscoCollabHost dans Ghidra et identifiez différentes façons d'obtenir l'exécution de code via le sideloading

4. Modifiez le dll_template pour effectuer un sideload de votre binaire cible. Vérifiez que vous pouvez voir la chaîne de débogage dans DebugView++.

5. Mettez à jour les LastWriteTime et CreationTime de dll_template.dll pour correspondre à la DLL cible.

Ressources supplémentaires

• https://hijacklibs.net/
• https://github.com/sadreck/Spartacus

Exercice 5 - Exécution de shellcode

1. Compilez et exécutez le projet utilitaire.

   a. En outre, envisagez de l'exécuter sur votre système hôte.

2. Copiez la DLL identifiée dans le répertoire x64/{Debug,Release} et mettez à jour le code du chargeur.

3. Mettez à jour execute_sc pour exécuter votre shellcode avec une fonction différente via le framework de hachage d'API.

Ressources supplémentaires

• https://github.com/Wra7h/FlavorTown

Exercice 6 - Tout assembler

1. Créez un nouveau projet DLL et assemblez : a. Sideloading de DLL b. Exécution de shellcode à partir du sideload
2. Vérifiez que vos propriétés PE sont comme prévu.
3. Compilez votre payload en mode Release et empaquetez-le dans un format adapté à la livraison.

Exercice 7 - Hébergement du payload

1. Inscrivez-vous auprès d'un fournisseur de stockage cloud (par exemple AWS/CloudFlare)

2. Empaquetez votre payload et téléversez-le

   a. En outre, étudiez les moyens de limiter/auditer l'accès au téléchargement

3. Prenez un instantané de votre VM

4. Revenez à la VM de base et rejouez votre scénario de "livraison" complet

   • par exemple, amener un utilisateur sur l'URL et lui faire télécharger le fichier. Assurez-vous que cela fonctionne.

Exercice 8 - Construire des payloads avec Github Actions

1. Créez un dépôt Git avec le contenu de ce projet
2. Validez que vous pouvez exécuter l'Action et que les artefacts fonctionnent
3. Mettez à jour .github\workflows\build.yml pour effectuer des traitements pré/post supplémentaires de votre choix afin de gagner du temps. Voici quelques idées :
   • Exécutez props.py et validez/incluez la sortie
   • Automatisez l'empaquetage du payload en Python
   • Automatisez la mise à jour de LastWriteTime et CreationTime pour correspondre à une cible