No Detectes Herramientas - Detecta Técnicas

La razón detrás de publicar este software se describió en una publicación de blog adjunta:

ProtectMyTooling - No detectes herramientas, detecta técnicas

Introducción

Script que envuelve una multitud de empaquetadores, protectores, ofuscadores, cargadores de shellcode, codificadores, generadores para producir complejos implantes protegidos de Red Team. Tu compañero perfecto en el pipeline de CI/CD de Desarrollo de Malware, ayudando a marcar tus artefactos, recolectar IOCs, backdoor y más.

ProtectMyToolingGUI.py

Con ProtectMyTooling puedes ofuscar rápidamente tus binarios sin tener que preocuparte por hacer clic a través de todos los diálogos, interfaces, menús, crear proyectos para ofuscar un solo binario, hacer clic en todas las opciones disponibles y perder el tiempo con todas esas tonterías. Te lleva directamente al punto - ofuscar tu herramienta.

El objetivo es ofrecer la interfaz más conveniente posible y permitir aprovechar una cadena en serie de múltiples empaquetadores combinados en un solo binario.

Así es - podemos lanzar ProtectMyTooling con varios empaquetadores a la vez:``` C:> py ProtectMyTooling.py hyperion,upx mimikatz.exe mimikatz-obf.exe

## Configuración Para conectar los ofuscadores compatibles, cambiar las opciones predeterminadas o apuntar **ProtectMyTooling** a la ruta de su ejecutable de ofuscación, deberá ajustar el archivo de configuración `config\ProtectMyTooling.yaml`. También existe el archivo `config\sample-full-config.yaml` que contiene todas las opciones disponibles para todos los empaquetadores compatibles, sirviendo como punto de referencia. ## Recordatorio amigable - Si su binario producido se bloquea o no se ejecuta como se espera, intente usar una cadena de empaquetadores diferente. - Los empaquetadores no garantizan la estabilidad de los binarios producidos, por lo tanto, ProtectMyTooling tampoco puede hacerlo. - Al encadenar, combine cuidadosamente los formatos de carga útil de salida->entrada según lo que espera el empaquetador consecutivo. --- ## Uso Antes del primer uso de `ProtectMyTooling`, es esencial ajustar el archivo de configuración YAML del programa `ProtectMyTooling.yaml`. El orden de procesamiento de parámetros es el siguiente: - Primero se utilizan los parámetros predeterminados - Luego son sobrescritos por los valores provenientes del YAML - Finalmente, lo que se proporcione en la línea de comandos sobrescribirá los valores correspondientes Allí, se deben establecer las rutas y opciones de los empaquetadores compatibles para habilitarlos. ### Escenario 1: Ofuscación simple con ConfuserEx El uso es muy simple, todo lo que se necesita es pasar el nombre del ofuscador a elegir, la ruta del archivo de entrada y de salida:``` 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%

Actualmente solo se admite la marca de agua de archivos PE, pero en el futuro se agregarán documentos de Office y otros formatos también. ### Recopilación de IOCs Los IOCs pueden recopilarse simplemente usando la opción `-i` en la ejecución de `ProtectMyTooling`. Se recopilan en las siguientes fases: - en el archivo de entrada - después de cada ronda de ofuscación en un archivo intermedio - en el archivo de salida final Contendrán los siguientes campos guardados en forma de archivo CSV: - `timestamp` - `filename` - `author` - formado como `username@hostname` - `context` - indica si un registro apunta a un archivo de entrada, salida o intermedio - `comment` - valor ajustado por el usuario mediante la opción `-I value` - `md5` - `sha1` - `sha256` - `imphash` - Hash de importaciones PE, si está disponible - (TODO) `typeref_hash` - Hash de TypeRef de .NET, si está disponible El resultado será un archivo CSV llamado `outfile-ioc.csv` almacenado junto al artefacto de salida generado. Ese archivo se escribe en modo APPEND, lo que significa que recibirá todos los IOCs posteriores. # RedBackdoorer - Backdooring de PE integrado `ProtectMyTooling` utiliza mi propio script `RedBackdoorer.py` que proporciona algunos métodos para realizar backdooring en ejecutables PE. El soporte viene como un packer dedicado llamado `backdoor`. Ejemplo de uso: **Toma shellcode de Cobalt Strike como entrada y lo codifica con SGN (Shikata Ga-Nai), luego backdoora SysInternals DbgView64.exe y produce un cargador reflectivo 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]>

# Integración con Cobalt Strike También hay un script que integra `ProtectMyTooling.py` usado como wrapper alrededor de Packer/Protectores de PE/.NET configurados para transformar fácilmente ejecutables de entrada en sus formas de salida protegidas y comprimidas, y luego cargarlos o usarlos desde CobaltStrike. La idea es tener un proceso automatizado de protección de todos los binarios cargados o ensamblados .NET utilizados por execute-assembly y olvidarse de protegerlos u ofuscarlos manualmente antes de cada uso. El beneficio adicional de un enfoque automatizado para transformar ejecutables es la capacidad de tener el mismo ejecutable protegido cada vez que se usa, resultando en muestras únicas lanzadas en las máquinas objetivo. Eso debería engañar adecuadamente a los barridos de IOC a nivel empresarial de EDR/AV mientras buscan el mismo artefacto en diferentes máquinas. Adicionalmente, el comando protected-execute-assembly tiene la capacidad de buscar ensamblados de los cuales solo se dio el nombre en un directorio de ensamblados preconfigurado (establecido en la configuración dotnet_assemblies_directory). Para usarlo: 1. Cargue `CobaltStrike/ProtectMyTooling.cna` en su Cobalt Strike. 2. Vaya al menú y configure todas las opciones. ![options](https://assets.kitploit.com/production/public/readmes/5634/45a8a4f1c128ccf0c0712410e5972c0197b5089b228eaaed38b5a23fa46ca5fd.png) 3. Luego, en la consola de su Beacon tendrá los siguientes comandos disponibles: * `protected-execute-assembly` - Ejecuta un programa .NET local, previamente protegido y comprimido, en memoria en el objetivo. * `protected-upload` - Toma un archivo de entrada, lo protege si es un ejecutable PE y luego carga ese archivo a una ubicación remota especificada. * `bofnet_load_protected` - Toma un archivo de ensamblado .NET de entrada, lo pasa a través de la cadena de packers .NET configurada, carga la salida generada con `bofnet_load`. [BOFNET](https://github.com/CCob/BOF.NET/) necesita cargarse por separado para que esto funcione. Básicamente, estos comandos abrirán archivos de entrada, los pasarán primero al script `CobaltStrike/cobaltProtectMyTooling.py`, que a su vez llama a `ProtectMyTooling.py`. Tan pronto como el binario se ofusque, se pasará a su beacon para su ejecución/carga. ## Opciones relacionadas con Cobalt Strike Aquí hay una lista de opciones requeridas por el integrador de Cobalt Strike: * `python3_interpreter_path` - Especifique una ruta al intérprete ejecutable de Python3 * `protect_my_tooling_dir` - Especifique una ruta al directorio principal de ProtectMyTooling * `protect_my_tooling_config` - Especifique una ruta al archivo de configuración de ProtectMyTooling con varias opciones de packers * `dotnet_assemblies_directory` - Especifique la ruta local donde se deben buscar los ensamblados .NET si no se encuentran mediante execute-assembly * `cache_protected_executables` - Habilite para almacenar en caché los ejecutables ya protegidos y reutilizarlos cuando sea necesario * `protected_executables_cache_dir` - Especifique una ruta a un directorio que debe almacenar los ejecutables protegidos en caché * `default_exe_x86_packers_chain` - Cadena de protectores/packers para ejecutables EXE nativos x86 * `default_exe_x64_packers_chain` - Cadena de protectores/packers para ejecutables EXE nativos x64 * `default_dll_x86_packers_chain` - Cadena de protectores/packers para ejecutables DLL nativos x86 * `default_dll_x64_packers_chain` - Cadena de protectores/packers para ejecutables DLL nativos x64 * `default_dotnet_packers_chain` - Cadena de protectores/packers para ejecutables .NET --- ## Problemas conocidos - `ScareCrow` es muy complicado de ejecutar desde Windows. Lo que funcionó para mí es lo siguiente: 1. Ejecutar en Windows 10 y tener WSL instalado (comando `bash.exe` disponible en Windows) 2. Tener `golang` instalado en WSL en la versión `1.16+` (probado en `1.18`) 3. Asegurarse de tener configurado `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True` --- ## Créditos y tecnología utilizada - Todos los créditos de packers, ofuscadores, conversores y loaders pertenecen a sus autores. ¡Esta herramienta es simplemente un wrapper alrededor de su tecnología! - Espero que a ninguno de ellos le moleste que agregue estos wrappers. Si hay inquietudes, comuníquese conmigo. - _ProtectMyTooling_ también utiliza [`denim.exe`](https://github.com/moloch--/denim) de **moloch--** para algunos packers basados en Nim. --- ## TODO - Escribir un inyector PE personalizado y ofrecerlo como "protector" - Agregar marcas de agua a otros formatos de archivo como documentos de Office, scripts WSH (VBS, JS, HTA) y contenedores - Agregar soporte para algunos otros Packer/Loaders/Generadores en un 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) - dos variantes: una para shellcode de entrada, la otra para ejecutable --- ## Descargo de responsabilidad El uso de esta herramienta, así como de cualquier otro proyecto del que soy autor, con fines ilegales, hacking no solicitado, ciberespionaje está estrictamente prohibido. Esta y otras herramientas que distribuyo ayudan a profesionales de Pruebas de Penetración, Consultores de Seguridad, Ingenieros de Seguridad y otro personal de seguridad a mejorar las capacidades de ciberdefensa de las redes de sus clientes. En ningún caso los autores o titulares de derechos de autor serán responsables por reclamos, daños u otra responsabilidad derivada del uso ilegal de este software. Si hay inquietudes, problemas de derechos de autor, amenazas que plantea este software u otras consultas, estoy abierto a colaborar para abordarlas de manera responsable. La herramienta expone una interfaz útil para usar software de packers/protectores/ofuscadores mayormente de código abierto o disponibles comercialmente, por lo tanto, no introduce ninguna amenaza inmediatamente nueva al panorama de la ciberseguridad tal como está. --- ### ☕ Muestra tu apoyo ☕ Este y otros proyectos son el resultado de noches sin dormir y **mucho trabajo duro**. Si te gusta lo que hago y aprecias que siempre devuelvo algo a la comunidad, [Considera invitarme un café](https://github.com/sponsors/mgeeky) _(o mejor una cerveza)_ solo para darte las gracias! 💪 --- ## Autor``` Mariusz Banach / mgeeky, '20-'22 <mb [at] binary-offensive.com> (https://github.com/mgeeky)

ProtectMyTooling

Más Populares

Acerca de

Trucos

Escenario 2: Ofuscación simple con ConfuserEx seguida de prueba de artefacto

RedWatermarker - Marcado de agua de artefactos integrado

Marcado de agua de artefactos y recopilación de IOC

Marcado de agua de artefactos