mrexodia/dumpulatorUna biblioteca fácil de usar para emular volcados de memoria. Útil para análisis de malware (extracción de configuraciones, desempaquetado) y análisis dinámico en general (sandboxing).
Nota: Este es un prototipo en desarrollo, trátelo como tal. ¡Se aceptan pull requests! Puede comenzar con buenos primeros issues
Una biblioteca fácil de usar para emular código en archivos minidump. Aquí hay algunos enlaces a publicaciones/videos que usan dumpulator:
¡No dudes en enviar un pull request para agregar tu artículo aquí!
El siguiente ejemplo abre StringEncryptionFun_x64.dmp (descarga una copia aquí), asigna algo de memoria y llama a la función de descifrado en 0x140001000 para descifrar la cadena en 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}'")
El StringEncryptionFun_x64.dmp se recopila en el punto de entrada del ejemplo tests/StringEncryptionFun. Puedes obtener los binarios compilados para StringEncryptionFun aquí
from dumpulator import Dumpulator
dp = Dumpulator("StringEncryptionFun_x64.dmp", trace=True)
dp.start(dp.regs.rip)
Esto creará StringEncryptionFun_x64.dmp.trace con una lista de instrucciones ejecutadas y algunas indicaciones útiles al cambiar de módulos, etc. Ten en cuenta que el seguimiento ralentiza significativamente la emulación y está pensado principalmente para depuración.
from dumpulator import Dumpulator
dp = Dumpulator("my.dmp")
buf = dp.call(0x140001000)
dp.read_str(buf, encoding='utf-16')
Supón que tienes la siguiente función:
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]
Solo quieres ejecutar el prólogo y configurar algunos registros:
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)}")
La bandera quiet suprime los registros sobre DLLs cargadas y regiones de memoria configuradas (para usar en scripts donde se desea reducir el ruido de registros).
Puedes (re)implementar syscalls usando el decorador @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
Todos los prototipos de funciones syscall se pueden encontrar en ntsyscalls.py. También hay muchos ejemplos allí sobre cómo usar la API.
Para enganchar una implementación de syscall existente, puedes hacer lo siguiente:
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
)
Desde v0.2.0 hay soporte para declarar fácilmente tus propias estructuras:
from dumpulator.native import *
class PROCESS_BASIC_INFORMATION(Struct):
ExitStatus: ULONG
PebBaseAddress: PVOID
AffinityMask: KAFFINITY
BasePriority: KPRIORITY
UniqueProcessId: ULONG_PTR
InheritedFromUniqueProcessId: ULONG_PTR
Para instanciar estas estructuras debes usar una instancia 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 pasas un valor de puntero como segundo argumento, la estructura se leerá de la memoria. Puedes declarar punteros con myptr: P[MY_STRUCT] y desreferenciarlos con myptr[0].
Hay un complemento simple de x64dbg disponible llamado MiniDumpPlugin El comando minidump se ha integrado en x64dbg desde 2022-10-10. Para crear un volcado, pausa la ejecución y ejecuta el comando MiniDump my.dmp.
python -m pip install dumpulator
Para instalar desde el código fuente:
python setup.py install
Instalar para un entorno de desarrollo:
python setup.py develop
Lo que distingue a dumpulator de sandboxes como speakeasy y qiling es que la memoria completa del proceso está disponible. Esto mejora el rendimiento porque puedes emular grandes partes de malware sin salir nunca de unicorn. Además, solo es necesario emular syscalls para proporcionar un entorno Windows realista (ya que todo en realidad es un entorno de proceso legítimo).