dumpulator

Hinweis: Dies ist ein in Arbeit befindlicher Prototyp, bitte behandeln Sie ihn als solchen. Pull-Requests sind willkommen! Sie können sich mit guten ersten Aufgaben vertraut machen.

Eine einfach zu verwendende Bibliothek zum Emulieren von Code in Minidump-Dateien. Hier sind einige Links zu Beiträgen/Videos, die dumpulator verwenden:

• Einführungsvideo mit OALabs: Dumpulator - Verwendung von Binäremulation zur Automatisierung von Reverse Engineering
• Emulieren von Malware mit Dumpulator
• Emotet x64 Stack Strings Konfigurationsemulation | OALabs Research
• Native Function und Assembly Code Aufruf
• Guloader String-Entschlüsselung (VEH)
• Rhadamanthys | OALabs Research
• [Fallstudie] Entschlüsseln von Strings mit Dumpulator

_{Sie können gerne einen Pull-Request senden, um Ihren Artikel hier hinzuzufügen!}

Beispiele

Aufrufen einer Funktion

Das folgende Beispiel öffnet StringEncryptionFun_x64.dmp (laden Sie eine Kopie hier herunter), weist etwas Speicher zu und ruft die Entschlüsselungsfunktion bei 0x140001000 auf, um den String bei 0x140017000 zu entschlüsseln:

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}'")

Das StringEncryptionFun_x64.dmp wird am Einstiegspunkt des tests/StringEncryptionFun-Beispiels gesammelt. Sie können die kompilierten Binärdateien für StringEncryptionFun hier herunterladen.

Ablaufverfolgung

from dumpulator import Dumpulator

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

Dies erstellt StringEncryptionFun_x64.dmp.trace mit einer Liste ausgeführter Anweisungen und einigen hilfreichen Hinweisen beim Wechseln von Modulen usw. Beachten Sie, dass die Ablaufverfolgung die Emulation erheblich verlangsamt und hauptsächlich für das Debugging gedacht ist.

Lesen von UTF-16-Strings

from dumpulator import Dumpulator

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

Ausführen eines Codeausschnitts

Angenommen, Sie haben die folgende Funktion:

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]

Sie möchten nur den Prolog ausführen und einige Register einrichten:

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)}")

Das quiet-Flag unterdrückt die Protokolle über geladene DLLs und eingerichtete Speicherbereiche (zur Verwendung in Skripten, in denen Sie Protokollüberflutung reduzieren möchten).

Benutzerdefinierte Syscall-Implementierung

Sie können Syscalls mit dem @syscall-Dekorator (neu) implementieren:

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

Alle Syscall-Funktionsprototypen finden Sie in ntsyscalls.py. Es gibt dort auch viele Beispiele zur Nutzung der API.

Um eine vorhandene Syscall-Implementierung zu hooken, können Sie Folgendes tun:

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
                                                )

Benutzerdefinierte Strukturen

Seit v0.2.0 gibt es Unterstützung für das einfache Deklarieren eigener Strukturen:

from dumpulator.native import *

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

Um diese Strukturen zu instanziieren, müssen Sie eine Dumpulator-Instanz verwenden: