Ne détectez pas les outils - Détectez les techniques

La justification de la publication de ce logiciel a été présentée dans un article de blog d'accompagnement :

• ProtectMyTooling - Ne détectez pas les outils, détectez les techniques

Introduction

Script qui englobe une multitude de packers, protecteurs, obfuscateurs, chargeurs de shellcode, encodeurs, générateurs pour produire des implants Red Team protégés complexes. Votre compagnon idéal dans le pipeline CI/CD de développement de malwares, aidant à watermarker vos artefacts, collecter des IOCs, backdoor et plus.

ProtectMyToolingGUI.py

Avec ProtectMyTooling vous pouvez rapidement obscurcir vos binaires sans avoir à vous soucier de cliquer à travers toutes les boîtes de dialogue, interfaces, menus, créer des projets pour obscurcir un seul binaire, cliquer à travers toutes les options disponibles et perdre du temps avec toutes ces bêtises. Cela vous mène directement au point - obscurcir votre outil.

L'objectif est d'offrir l'interface la plus pratique possible et de permettre de tirer parti d' une chaîne de plusieurs packers combinée sur un seul binaire.

C'est exact - nous pouvons lancer ProtectMyTooling avec plusieurs packers à la fois :``` C:> py ProtectMyTooling.py hyperion,upx mimikatz.exe mimikatz-obf.exe

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

3. L'installation réelle est simple :

Windows``` PS C:\ProtectMyTooling> .\install.ps1

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

Gimmicks

Pour que le packer ScareCrow fonctionne sur Windows 10, il faut que WSL soit installé et que bash.exe soit disponible (dans %PATH%). Ensuite, dans WSL, il faut avoir golang installé dans une version au moins 1.16 :``` cmd> bash bash$ sudo apt update ; sudo apt upgrade -y ; sudo apt install golang=2:1.18~3 -y

## 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 2 : Obfuscation simple avec ConfuserEx suivie d'un test d'artefact

On peut également obscurcir le fichier et tenter immédiatement de le lancer (avec également des paramètres optionnels fournis) pour s'assurer qu'il fonctionne correctement avec les options -r --cmdline CMDLINE :``` C:> py ProtectMyTooling.py confuserex Rubeus.exe Rubeus-obf.exe -r --cmdline "hash /password:foobar"

[...]

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

[+] SUCCEEDED. Original file size: 417280 bytes, new file size ConfuserEx(): 758272, ratio: 181.72%

Running application to test it...

---

(_____ \ | | ) ) | | _____ _ _ ___ | __ /| | | | _ | ___ | | | |/) | | \ | || | |) ) | || | | || ||/|/|_____)__/(_/

v2.0.0

[*] Action: Calculate Password Hash(es)

[] Input password : foobar [] rc4_hmac : BAAC3929FABC9E6DCD32421BA94A84D4

[!] /user:X and /domain:Y need to be supplied to calculate AES and DES hash types!

### 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`.