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).
# dumpulator
**Nota: Este es un prototipo en desarrollo, trátelo como tal. ¡Se aceptan pull requests! Puede comenzar con [buenos primeros issues](https://github.com/mrexodia/dumpulator/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)**
Una biblioteca fácil de usar para emular código en archivos minidump. Aquí hay algunos enlaces a publicaciones/videos que usan dumpulator:
- Video de introducción con [OALabs](https://oalabs.openanalysis.net): [Dumpulator - Usando emulación binaria para automatizar ingeniería inversa](https://youtu.be/4Pfu98Xx9Yo)
- [Emulando malware con Dumpulator](https://rioasmara.com/2022/07/23/emulating-malware-with-dumpulator/)
- [Emotet x64 Stack Strings Config Emulation | OALabs Research](https://research.openanalysis.net/emotet/emulation/config/dumpulator/malware/2022/05/19/emotet_x64_emulation.html)
- [Invocación de funciones nativas y código ensamblador](https://research.checkpoint.com/2022/native-function-and-assembly-code-invocation/)
- [Descifrado de cadenas Guloader (VEH)](https://research.openanalysis.net/guloader/emulation/dumpulator/veh/exceptions/2023/01/15/dumpulator-veh.html)
- [Rhadamanthys | OALabs Research](https://research.openanalysis.net/rhadamanthys/config/ida/shifted%20pointers/peb/_list_entry/_ldr_data_table_entry/2023/01/19/rhadamanthys.html)
- [\[Caso de estudio\] Descifrar cadenas usando Dumpulator](https://kienmanowar.wordpress.com/2023/05/22/case-study-decrypt-strings-using-dumpulator/)
<sub>¡No dudes en enviar un pull request para agregar tu artículo aquí!</sub>
## Ejemplos
### Llamar a una función
El siguiente ejemplo abre `StringEncryptionFun_x64.dmp` (descarga una copia [aquí](https://github.com/mrexodia/dumpulator/releases/download/v0.0.1/StringEncryptionFun_x64.dmp)), asigna algo de memoria y llama a la función de descifrado en `0x140001000` para descifrar la cadena en `0x140017000`:
```python
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í](https://github.com/mrexodia/dumpulator/releases/download/v0.0.1/StringEncryptionFun.7z)
### Seguimiento de ejecución
```python
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.
### Leer cadenas utf-16
```python
from dumpulator import Dumpulator
dp = Dumpulator("my.dmp")
buf = dp.call(0x140001000)
dp.read_str(buf, encoding='utf-16')
```
### Ejecutar un fragmento de código
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:
```python
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).
### Implementación personalizada de syscalls
Puedes (re)implementar syscalls usando el decorador `@syscall`:
```python
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](https://github.com/mrexodia/dumpulator/blob/main/src/dumpulator/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:
```python
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
)
```
### Estructuras personalizadas
Desde `v0.2.0` hay soporte para declarar fácilmente tus propias estructuras:
```python
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`:
```python
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]`.
## Recolectar el volcado
~~Hay un complemento simple de [x64dbg](https://github.com/x64dbg/x64dbg) disponible llamado [MiniDumpPlugin](https://github.com/mrexodia/MiniDumpPlugin/releases)~~ El comando [minidump](https://help.x64dbg.com/en/latest/commands/memory-operations/minidump.html) se ha integrado en x64dbg desde 2022-10-10. Para crear un volcado, pausa la ejecución y ejecuta el comando `MiniDump my.dmp`.
## Instalación
Desde [PyPI](https://pypi.org/project/dumpulator) (última [versión](https://github.com/mrexodia/dumpulator/releases)):
```
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
```
## Trabajo relacionado
- [Dumpulator-IDA](https://github.com/michaeljgoodman/Dumpulator-IDA): Este proyecto es un pequeño complemento POC para iniciar la emulación de dumpulator dentro de IDA, pasándole direcciones desde la vista de IDA usando el menú contextual.
- [wtf](https://github.com/0vercl0k/wtf): Fuzzer distribuido, guiado por cobertura de código, personalizable, multiplataforma basado en instantáneas, diseñado para atacar objetivos en modo usuario y/o kernel que se ejecutan en Microsoft Windows.
- [speakeasy](https://github.com/mandiant/speakeasy): Sandbox de Windows sobre unicorn.
- [qiling](https://github.com/qilingframework/qiling): Marco de emulación binaria sobre unicorn.
- [Simpleator](https://github.com/ionescu007/Simpleator): Emulador de aplicaciones en modo usuario basado en la API Hyper-V Platform.
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).
## Créditos
- [herrcore](https://twitter.com/herrcore) por inspirarme a hacer esto
- [secret club](https://secret.club)
- [JetBrains](https://www.jetbrains.com/opensource/) por la licencia gratuita de PyCharm
- [Imagen de GraphiqaStock](https://www.freepik.com/free-vector/virus-internet_1040653.htm) en Freepik