dumpulator

Nota: Questo è un prototipo in fase di sviluppo, trattatelo come tale. Le pull request sono benvenute! Potete iniziare con buone prime issue

Una libreria facile da usare per emulare codice in file minidump. Ecco alcuni link a post/video che utilizzano dumpulator:

• Video introduttivo con OALabs: Dumpulator - Using Binary Emulation To Automate Reverse Engineering
• Emulating malware with Dumpulator
• Emotet x64 Stack Strings Config Emulation | OALabs Research
• Native function and Assembly Code Invocation
• Guloader string decryption (VEH)
• Rhadamanthys | OALabs Research
• [Case study] Decrypt strings using Dumpulator

_{Sentitevi liberi di inviare una pull request per aggiungere il vostro articolo qui!}

Esempi

Chiamare una funzione

L'esempio seguente apre StringEncryptionFun_x64.dmp (scaricarne una copia qui), alloca della memoria e chiama la funzione di decifratura all'indirizzo 0x140001000 per decifrare la stringa all'indirizzo 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}'")

Il file StringEncryptionFun_x64.dmp viene raccolto al punto di ingresso dell'esempio tests/StringEncryptionFun. Potete ottenere i binari compilati per StringEncryptionFun qui

Tracciamento dell'esecuzione

from dumpulator import Dumpulator

dp = Dumpulator("StringEncryptionFun_x64.dmp", trace=True)
dp.start(dp.regs.rip)

Questo creerà StringEncryptionFun_x64.dmp.trace con un elenco di istruzioni eseguite e alcune indicazioni utili quando si cambia modulo, ecc. Nota che il tracciamento rallenta significativamente l'emulazione ed è principalmente pensato per il debugging.

Lettura di stringhe utf-16

from dumpulator import Dumpulator

dp = Dumpulator("my.dmp")
buf = dp.call(0x140001000)
dp.read_str(buf, encoding='utf-16')

Esecuzione di un frammento di codice

Supponiamo di avere la seguente funzione:

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]

Vogliamo eseguire solo il prologo e impostare alcuni registri:

from dumpulator import Dumpulator

prolog_start = 0x00007FFFC81C06C0
# vogliamo fermarci all'istruzione dopo il prologo
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)}")

Il flag quiet sopprime i log relativi ai DLL caricati e alle regioni di memoria impostate (utile per script in cui si vuole ridurre la quantità di log).

Implementazione personalizzata delle syscall

Potete (re)implementare le syscall usando il decoratore @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

Tutti i prototipi delle funzioni syscall si trovano in ntsyscalls.py. Ci sono anche molti esempi su come utilizzare l'API.

Per agganciare una syscall già implementata, si può fare quanto segue:

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
                                                )

Strutture personalizzate

Dalla v0.2.0 è disponibile il supporto per dichiarare facilmente le proprie strutture:

from dumpulator.native import *

class PROCESS_BASIC_INFORMATION(Struct):
    ExitStatus: ULONG
    PebBaseAddress: PVOID
    AffinityMask: KAFFINITY
    BasePriority: KPRIORITY
    UniqueProcessId: ULONG_PTR
    InheritedFromUniqueProcessId: ULONG_PTR

Per istanziare queste strutture è necessario utilizzare un'istanza di Dumpulator: