mrexodia/dumpulatorUne bibliothèque facile à utiliser pour émuler des dumps mémoire. Utile pour l'analyse de malwares (extraction de configuration, dépaquetage) et l'analyse dynamique en général (sandboxing).
Remarque : Ceci est un prototype en cours de développement, veuillez le considérer comme tel. Les pull requests sont les bienvenues ! Vous pouvez vous familiariser avec les bonnes premières issues
Une bibliothèque facile à utiliser pour émuler du code dans des fichiers minidump. Voici quelques liens vers des articles/vidéos utilisant dumpulator :
N'hésitez pas à envoyer une pull request pour ajouter votre article ici !
L'exemple ci-dessous ouvre StringEncryptionFun_x64.dmp (téléchargez une copie ici), alloue de la mémoire et appelle la fonction de déchiffrement à 0x140001000 pour déchiffrer la chaîne à 0x140017000 :
from dumpulator import Dumpulator
dp = Dumpulator("StringEncryptionFun_x64.dmp")
temp_addr = dp.allocate(256)
dp.call(0x140001000, [temp_addr, 0x140017000])
decrypted = dp.read_str(temp_addr)
print(f"decrypted: '{decrypted}'")
Le fichier StringEncryptionFun_x64.dmp est collecté au point d'entrée de l'exemple tests/StringEncryptionFun. Vous pouvez obtenir les binaires compilés pour StringEncryptionFun ici
from dumpulator import Dumpulator
dp = Dumpulator("StringEncryptionFun_x64.dmp", trace=True)
dp.start(dp.regs.rip)
Cela créera un fichier StringEncryptionFun_x64.dmp.trace avec une liste des instructions exécutées et quelques indications utiles lors du changement de modules, etc. Notez que le traçage ralentit considérablement l'émulation et est principalement destiné au débogage.
from dumpulator import Dumpulator
dp = Dumpulator("my.dmp")
buf = dp.call(0x140001000)
dp.read_str(buf, encoding='utf-16')
Supposons que vous ayez la fonction suivante :
00007FFFC81C06C0 | mov qword ptr [rsp+0x10],rbx ; prolog_start
00007FFFC81C06C5 | mov qword ptr [rsp+0x18],rsi
00007FFFC81C06CA | push rbp
00007FFFC81C06CB | push rdi
00007FFFC81C06CC | push r14
00007FFFC81C06CE | lea rbp,qword ptr [rsp-0x100]
00007FFFC81C06D6 | sub rsp,0x200 ; prolog_end
00007FFFC81C06DD | mov rax,qword ptr [0x7FFFC8272510]
Vous souhaitez seulement exécuter le prologue et configurer certains registres :
from dumpulator import Dumpulator
prolog_start = 0x00007FFFC81C06C0
# we want to stop the instruction after the prolog
prolog_end = 0x00007FFFC81C06D6 + 7
dp = Dumpulator("my.dmp", quiet=True)
dp.regs.rcx = 0x1337
dp.start(begin=prolog_start, end=prolog_end)
print(f"rsp: {hex(dp.regs.rsp)}")
Le flag quiet supprime les logs concernant les DLL chargées et les régions mémoire configurées (à utiliser dans les scripts où vous souhaitez réduire le bruit des logs).
Vous pouvez (ré)implémenter des syscalls en utilisant le décorateur @syscall :
from dumpulator import *
from dumpulator.native import *
from dumpulator.handles import *
from dumpulator.memory import *
@syscall
def ZwQueryVolumeInformationFile(dp: Dumpulator,
FileHandle: HANDLE,
IoStatusBlock: P[IO_STATUS_BLOCK],
FsInformation: PVOID,
Length: ULONG,
FsInformationClass: FSINFOCLASS
):
return STATUS_NOT_IMPLEMENTED
Tous les prototypes de fonctions syscall peuvent être trouvés dans ntsyscalls.py. Il y a aussi beaucoup d'exemples sur la façon d'utiliser l'API.
Pour accrocher une implémentation syscall existante, vous pouvez faire ce qui suit :
import dumpulator.ntsyscalls as ntsyscalls
@syscall
def ZwOpenProcess(dp: Dumpulator,
ProcessHandle: Annotated[P[HANDLE], SAL("_Out_")],
DesiredAccess: Annotated[ACCESS_MASK, SAL("_In_")],
ObjectAttributes: Annotated[P[OBJECT_ATTRIBUTES], SAL("_In_")],
ClientId: Annotated[P[CLIENT_ID], SAL("_In_opt_")]
):
process_id = ClientId.read_ptr()
assert process_id == dp.parent_process_id
ProcessHandle.write_ptr(0x1337)
return STATUS_SUCCESS
@syscall
def ZwQueryInformationProcess(dp: Dumpulator,
ProcessHandle: Annotated[HANDLE, SAL("_In_")],
ProcessInformationClass: Annotated[PROCESSINFOCLASS, SAL("_In_")],
ProcessInformation: Annotated[PVOID, SAL("_Out_writes_bytes_(ProcessInformationLength)")],
ProcessInformationLength: Annotated[ULONG, SAL("_In_")],
ReturnLength: Annotated[P[ULONG], SAL("_Out_opt_")]
):
if ProcessInformationClass == PROCESSINFOCLASS.ProcessImageFileNameWin32:
if ProcessHandle == dp.NtCurrentProcess():
main_module = dp.modules[dp.modules.main]
image_path = main_module.path
elif ProcessHandle == 0x1337:
image_path = R"C:\Windows\explorer.exe"
else:
raise NotImplementedError()
buffer = UNICODE_STRING.create_buffer(image_path, ProcessInformation)
assert ProcessInformationLength >= len(buffer)
if ReturnLength.ptr:
dp.write_ulong(ReturnLength.ptr, len(buffer))
ProcessInformation.write(buffer)
return STATUS_SUCCESS
return ntsyscalls.ZwQueryInformationProcess(dp,
ProcessHandle,
ProcessInformationClass,
ProcessInformation,
ProcessInformationLength,
ReturnLength
)
Depuis v0.2.0, il est possible de déclarer facilement vos propres structures :
from dumpulator.native import *
class PROCESS_BASIC_INFORMATION(Struct):
ExitStatus: ULONG
PebBaseAddress: PVOID
AffinityMask: KAFFINITY
BasePriority: KPRIORITY
UniqueProcessId: ULONG_PTR
InheritedFromUniqueProcessId: ULONG_PTR
Pour instancier ces structures, vous devez utiliser une instance de Dumpulator :
pbi = PROCESS_BASIC_INFORMATION(dp)
assert ProcessInformationLength == Struct.sizeof(pbi)
pbi.ExitStatus = 259 # STILL_ACTIVE
pbi.PebBaseAddress = dp.peb
pbi.AffinityMask = 0xFFFF
pbi.BasePriority = 8
pbi.UniqueProcessId = dp.process_id
pbi.InheritedFromUniqueProcessId = dp.parent_process_id
ProcessInformation.write(bytes(pbi))
if ReturnLength.ptr:
dp.write_ulong(ReturnLength.ptr, Struct.sizeof(pbi))
return STATUS_SUCCESS
Si vous passez une valeur de pointeur comme second argument, la structure sera lue depuis la mémoire. Vous pouvez déclarer des pointeurs avec myptr: P[MY_STRUCT] et les déréférencer avec myptr[0].
Un plugin simple x64dbg est disponible appelé MiniDumpPlugin La commande minidump a été intégrée dans x64dbg depuis le 2022-10-10. Pour créer un dump, mettez l'exécution en pause et exécutez la commande MiniDump my.dmp.
Depuis PyPI (dernière version) :
python -m pip install dumpulator
Pour installer depuis les sources :
python setup.py install
Installer pour un environnement de développement :
python setup.py develop
Ce qui distingue dumpulator des bacs à sable comme speakeasy et qiling est que la mémoire complète du processus est disponible. Cela améliore les performances car vous pouvez émuler de grandes parties de logiciels malveillants sans jamais quitter unicorn. De plus, seuls les syscalls doivent être émulés pour fournir un environnement Windows réaliste (puisque tout est en réalité un environnement de processus légitime).