| \ / / | | | _ __ | || _ \ ___ _ __ _ | | | | \ / | | | | | | ' | | | | |/ _ | ' | | | | | | | / \ || || |__| | | | || || | () | | | | || | | |_____//__|||| ||_|____/ _/|| ||_,|__| par @JoeLeonJr (@FortyNorthSec)

EXCELntDonut est un générateur de macros XLM (Excel 4.0). Commencez avec du code source C# (EXE) et obtenez une macro XLM (Excel 4.0) qui exécutera votre code en mémoire. Les macros XLM (Excel 4.0) peuvent être enregistrées dans des fichiers .XLS.

Installation

chmod +x install.sh
./install.sh

Qu'est-ce qui est installé ?

pip3
mono-complete (à la fois mcs et toutes les bibliothèques possibles que vous référenceriez dans vos fichiers sources)
EXCELntDonut en tant qu'interface en ligne de commande

Si vous préférez exécuter EXCELntDonut simplement comme un script Python, vous devrez configurer un environnement virtuel avec deux packages "pandas" et "donut-shellcode". De plus, vous devrez installer mono-complete via apt-get et appeler le script drive.py avec python3. Nous recommandons d'utiliser simplement le script bash ./install.sh, mais libre à vous.

Utilisation

Usage:
	$ EXCELntDonut -f exe_source.cs -r System.Windows.Forms.dll --sandbox --obfuscate

Flags:
	(obligatoire)
	-f chemin vers le fichier contenant votre code source C# (exe uniquement)

	-r Références nécessaires pour compiler votre code C# (les mêmes que celles utilisées avec mcs pour compiler sous Linux)
	(ex: -r 'System.Management')

	(optionnel)
	-o nom du fichier de sortie
	--sandbox 
		Effectue des vérifications basiques de sandbox. Cette fonction sera mise à jour au fur et à mesure de la découverte de nouvelles approches.
	--obfuscate 
		Effectue une obfuscation basique de la macro.

Comment ça fonctionne

Vous fournissez un fichier C# contenant votre charge utile (comme un EXE avec une méthode main qui exécute une charge utile Cobalt Strike Beacon). Ce fichier C# est compilé avec MCS en deux assemblies .NET : x86 et x64. Après compilation, les excellents outils Donut (pour x86) et CLRvoyance (pour x64) convertissent chaque assembly en shellcode indépendant de la position. Ensuite, tous les octets nuls sont supprimés, car les macros XLM (Excel 4.0) ne gèrent pas bien les octets nuls, et la charge utile est découpée en lignes ne dépassant pas 255 caractères (pour x86) ou 10 caractères (pour x64).

Une fois le shellcode préparé, il est combiné avec des fonctions d'injection de processus de base (VirtualAlloc, WriteProcessMemory et CreateThread) ainsi qu'une fonction de vérification d'architecture pour déterminer quelle charge utile (x86 ou x64) exécuter sur le système cible. Si vous choisissez d'effectuer des vérifications de sandbox ou une obfuscation basique, ces fonctions mettront à jour votre macro. Enfin, la sortie est placée dans un fichier CSV (enregistré sous .txt).

Comment créer une macro XLM (Excel 4.0)

Une fois que vous avez le fichier de sortie d'EXCELntDonut, ouvrez le fichier de sortie dans un éditeur de texte et copiez son contenu intégralement (Ctrl-A, Ctrl-S). Ouvrez Excel sur une VM Windows, faites un clic droit sur "Feuil1" et sélectionnez "Insérer". Choisissez "Macro MS Excel 4.0". Allez dans la cellule A1 et collez la sortie d'EXCELntDonut. Toutes les données seront probablement collées dans une seule colonne. Les données sont séparées par des points-virgules ";". Allez dans l'onglet "Données" puis cliquez sur "Convertir". Sélectionnez "Délimité" et sur l'écran suivant, choisissez "Point-virgule" puis cliquez sur "Terminer". La macro se répartira sur les colonnes et lignes appropriées.

(Note : si vous avez sélectionné le drapeau "--obfuscate", vous devrez faire défiler horizontalement pas mal pour trouver votre code réel, car une partie de la logique d'obfuscation déplace la macro dans une section aléatoire de la feuille de calcul).

Nous recommandons deux choses à ce stade :

Trouvez la cellule de départ (ce sera la cellule en haut à gauche de votre code de macro, probablement A1). Faites un clic droit et sélectionnez "Exécuter". Testez votre macro pour vous assurer qu'elle fonctionne.
Une fois que vous avez vérifié que la macro fonctionne, sélectionnez à nouveau cette même cellule en haut à gauche. Sur le côté gauche de l'écran, il devrait y avoir une liste déroulante indiquant la cellule dans laquelle vous vous trouvez (probablement "A1"). Cliquez dans la liste déroulante et changez la valeur textuelle en "Auto_open". Cela produira la même fonctionnalité d'exécution automatique que celle à laquelle vous êtes habitué avec les macros VBA.

Enregistrez le fichier (.xls) et essayez de l'ouvrir. Il devrait exécuter automatiquement votre charge utile.

Vérifications de sandbox

Ces vérifications sont basées sur ce que les acteurs malveillants réels utilisent dans leurs logiciels malveillants.

Y a-t-il une souris active ?
La taille de l'écran est-elle supérieure à 770 de largeur et 381 de hauteur ?
L'hôte peut-il jouer des sons ?
S'agit-il d'une machine Windows ?

Obfuscation

Pour les instructions d'injection de processus (VirtualAlloc, WriteProcessMemory, CreateThread) et les vérifications de sandbox, toutes les fonctions de macro deviendront la structure suivante :

=FORMULE(D3&D23&D54&D23&D44;E45)

La fonction FORMULE nous permet de placer une formule, qui peut ensuite être exécutée, dans une autre cellule. Ainsi, dans ce cas, nous plaçons les instructions d'injection de processus, puis utilisons la fonction FORMULE pour placer la fonction réelle dans une autre cellule à exécuter. Cela évite que les défenseurs effectuant une analyse statique voient des choses comme "VirtualAlloc".

La macro entière décalera une certaine valeur vers la droite, de sorte que lorsque vous ouvrez initialement la feuille avec les macros, elle semble vide.

Choses à savoir

Les charges utiles moins sophistiquées utilisent simplement la commande =EXEC() pour exécuter des commandes. Certaines utilisent aussi URLMON pour télécharger des fichiers. D'autres fichiers incluent même le mot "SHELL". Tout cela nous a semblé être une mauvaise idée. Cet outil n'inclut rien de tout cela. Il injecte plutôt votre code source C# dans le processus Excel (32 bits ou 64 bits) et l'exécute. Ensuite, c'est à votre charge utile de décider quoi faire ensuite.

Conseils

Votre code source C# peut faire tout ce que vous voulez. Nous recommandons que votre code source brise la relation Parent > Enfant entre Excel et tout ce que vous lancez.
Il existe de nombreux bons articles de blog sur les feuilles Excel "Très masquées". Envisagez de les utiliser.
N'oubliez pas de rendre votre fichier Excel réaliste.

Dépannage

"Le type ou l'espace de noms ... n'existe pas ..."

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    par @JoeLeonJr (@FortyNorthSec)                
[i] Génération de votre assembly .NET x86.
warning CS8001: Le chemin SDK n'a pas pu être résolu
test.cs(2,14): erreur CS0234: Le type ou le nom d'espace de noms « Management » n'existe pas dans l'espace de noms « System ». Référence d'assembly manquante ?

Cette erreur signifie très probablement qu'il manque un assembly de référence lors de la compilation avec mono. Pour la corriger, il suffit de passer l'espace de noms mentionné dans le drapeau -r. Dans ce cas, nous ajouterions -r 'System.Management' à la ligne de commande. La nouvelle commande serait :

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs -r 'System.Management'

"Le fichier de métadonnées ... est introuvable"

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs -r System.Management
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    par @JoeLeonJr (@FortyNorthSec)                
[i] Génération de votre assembly .NET x86.
warning CS8001: Le chemin SDK n'a pas pu être résolu
erreur CS0006: Le fichier de métadonnées « System.Management » est introuvable

[x] Erreur lors de la génération de l'assembly .NET x86 avec MCS. Voir le message d'erreur ci-dessus.

Cette erreur ne devrait pas apparaître sauf si vous exécutez EXCELntDonut sans utiliser le script bash install.sh. Dans ce cas, vous devrez installer manuellement mono-complete. Cela téléchargera les dépendances pertinentes. Vous pouvez l'installer avec apt comme ceci :

apt-get install mono-complete

"Le programme ... ne contient pas de méthode 'Main' statique ..."

root@kali:~/Desktop# EXCELntDonut -f test.cs
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    par @JoeLeonJr (@FortyNorthSec)                
[i] Génération de votre assembly .NET x86.
erreur CS5001: Le programme « _excelntdonut_GJAoNuVPMcX.exe » ne contient pas de méthode « Main » statique appropriée pour un point d'entrée

[x] Erreur lors de la génération de l'assembly .NET x86 avec MCS. Voir le message d'erreur ci-dessus.

Pour le moment, EXCELntDonut n'accepte que les fichiers C# avec des charges utiles dans la fonction Main.

Conseils généraux de dépannage

Tout d'abord, compilez votre code source C# avec csc sur Windows et exécutez-le pour vérifier que la charge utile fonctionne. Testez cela en compilant des charges utiles x86 et x64, car vous ne saurez probablement pas si votre environnement cible utilise Excel 32 bits ou 64 bits.
Vous devriez pouvoir exécuter votre charge utile plusieurs fois dans le même processus, mais si vous obtenez des erreurs étranges, quittez Excel, rouvrez-le et réessayez.
En cas de doute, fermez Excel et créez un nouveau fichier pour tester.

Détection

Voici quelques règles Yara pour commencer par @InQuest :

Recherchez une feuille très masquée

https://github.com/InQuest/yara-rules/blob/master/Excel_Hidden_Macro_Sheet.rule

Recherchez la chaîne Auto_Open

https://github.com/Neo23x0/signature-base/blob/master/yara/general_officemacros.yar

Il existe de nombreux articles sur l'utilisation d'OLEDUMP.py pour examiner les fichiers XLM. Considérez celui-ci :

https://clickallthethings.wordpress.com/2020/04/06/covid-19-excel-4-0-macros-and-sandbox-detection/

Défense

Activez le blocage GPO de l'exécution des macros pour les fichiers téléchargés depuis Internet. Voir - https://www.microsoft.com/security/blog/2016/03/22/new-feature-in-office-2016-can-block-macros-and-help-prevent-infection/
AMSI n'aide malheureusement pas ici.
Règles ASR... nous ne sommes pas sûrs.
La plupart des utilisateurs envoient des fichiers .xlsx de nos jours. Peut-être bloquer les fichiers .xls pour qu'ils ne soient pas envoyés dans les boîtes de réception de vos employés. Il ne serait pas scandaleux de demander à quelqu'un de renvoyer un fichier enregistré sous .xlsx.
La version la plus récente de Defender ATP a détecté la version non obfusquée de ce fichier lorsqu'elle était déposée sur le disque.

Remerciements

Ce projet n'aurait même pas été sur notre radar sans le travail fantastique des gens d'Outflank (@outflanknl). Un remerciement spécial à @StanHacked pour ses idées pendant ce projet. De plus, ce projet ne serait pas possible sans Donut (par @TheWover et @odzhan) et la bibliothèque python associée (par @byt3bl33d3r). Par ailleurs, l'équipe d'Accenture a créé CLRvoyance, ce qui a résolu certains problèmes x64 que nous n'arrivions pas à résoudre avec Donut + les macros XLM 4.0. Enfin, merci à Philip Tsukerman de Cybereason pour la recherche géniale sur la compatibilité des macros XLM avec les versions 64 bits d'Excel.

Avertissement

Nous ne sommes pas responsables d'une mauvaise utilisation de cet outil. Cet outil a été généré à des fins éducatives et de tests autorisés pour démontrer comment un code source C# peut être injecté en mémoire à l'aide d'une macro XLM (Excel 4.0). Le but ultime de ce projet est (1) de fournir aux équipes rouges une autre option de charge utile pour l'hameçonnage afin d'émuler ce que les adversaires réels utilisent actuellement, et (2) de fournir aux défenseurs un cadre de référence pour construire des analyses et des mesures d'atténuation. Sans un outil pour générer rapidement ce type de charge utile, nous pensons que les défenseurs ne seront pas correctement préparés pour ce qui les attend réellement. Veuillez agir de manière responsable.

Licence

Veuillez consulter le fichier de licence dans ce dossier. Veuillez noter que cet outil intègre deux autres outils open source, notamment Donut et CLRvoyance.

EXCELntDonut

Populaires