Unduh dumpulator - Unduh Kode Sumber dumpulator

Dumpulator

Catatan: Ini adalah prototipe yang sedang dalam proses, tolong perlakukan seperti itu. Permintaan tarik dipersilakan! Anda bisa membuat kaki Anda basah dengan masalah pertama yang bagus

Perpustakaan yang mudah digunakan untuk meniru kode dalam file Minidump. Berikut adalah beberapa tautan ke posting/video menggunakan dumpulator:

PENDAHULUAN Video dengan oalab: Dumpulator - Menggunakan emulasi biner untuk mengotomatiskan rekayasa terbalik
Meniru malware dengan dumpulator
Emosi X64 Stack Strings Config Emulasi | Penelitian Oalab
Doa Fungsi Asli dan Kode Perakitan
Guloader String Decryption (Veh)
Rhadamanthys | Penelitian Oalab
[Studi Kasus] Dekripsi string menggunakan dumpulator

_{Jangan ragu untuk mengirim permintaan tarik untuk menambahkan artikel Anda di sini!}

Contoh

Memanggil fungsi

Contoh di bawah ini membuka StringEncryptionFun_x64.dmp (unduh salinan di sini), mengalokasikan beberapa memori dan memanggil fungsi dekripsi di 0x140001000 untuk mendekripsi string di 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 } '" )

StringEncryptionFun_x64.dmp dikumpulkan pada titik masuk contoh tests/StringEncryptionFun . Anda bisa mendapatkan binari yang dikompilasi untuk StringEncryptionFun di sini

Melacak eksekusi

 from dumpulator import Dumpulator

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

Ini akan membuat StringEncryptionFun_x64.dmp.trace dengan daftar instruksi yang dieksekusi dan beberapa indikasi yang bermanfaat saat beralih modul dll. Perhatikan bahwa penelusuran secara signifikan memperlambat emulasi dan sebagian besar dimaksudkan untuk debugging.

Membaca string UTF-16

 from dumpulator import Dumpulator

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

Menjalankan Cuplikan Kode

Katakanlah Anda memiliki fungsi berikut:

 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]

Anda hanya ingin menjalankan prolog dan mengatur beberapa register:

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

Bendera quiet menekan log tentang DLL yang dimuat dan daerah memori diatur (untuk digunakan dalam skrip di mana Anda ingin mengurangi spam log).

Implementasi Syscall Kustom

Anda dapat mengimplementasikan syscall dengan menggunakan dekorator @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

Semua prototipe fungsi syscall dapat ditemukan di ntsyscalls.py. Ada juga banyak contoh di sana tentang cara menggunakan API.

Untuk mengaitkan implementasi syscall yang ada, Anda dapat melakukan hal berikut:

 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:Windowsexplorer.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
                                                )

Struktur khusus

Karena v0.2.0 Ada dukungan untuk dengan mudah mendeklarasikan struktur Anda sendiri:

 from dumpulator . native import *

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

Untuk membuat instantiate struktur ini, Anda harus menggunakan instance 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

Jika Anda memberikan nilai pointer sebagai argumen kedua, struktur akan dibaca dari memori. Anda dapat mendeklarasikan pointer dengan myptr: P[MY_STRUCT] dan dereference mereka dengan myptr[0] .

Mengumpulkan tempat pembuangan

~~Ada plugin X64DBG sederhana yang tersedia bernama Minidumpplugin~~ Perintah Minidump telah diintegrasikan ke dalam X64DBG sejak 2022-10-10. Untuk membuat dump, jeda eksekusi dan jalankan perintah MiniDump my.dmp .

Instalasi

Dari PYPI (rilis terbaru):

 python -m pip install dumpulator

Untuk menginstal dari sumber:

 python setup.py install

Instal untuk lingkungan pengembangan:

 python setup.py develop

Pekerjaan terkait

Dumpulator-ID: Proyek ini adalah plugin POC kecil untuk meluncurkan emulasi dumpulator di dalam IDA, menyampaikan alamatnya dari tampilan IDA Anda menggunakan menu konteks.
WTF: Fuzzer berbasis snapshot yang terdistribusi, cross-coverage, cross-platform yang dirancang untuk menyerang pengguna dan / atau target mode kernel yang berjalan di Microsoft Windows
Speakeasy: Windows Sandbox di atas unicorn.
Qiling: Kerangka kerja emulasi biner di atas unicorn.
Simpleator: Emulator Aplikasi Mode Pengguna Berdasarkan API Platform Hyper-V.

Apa yang membuat dumpulator terpisah dari kotak pasir seperti speakeasy dan qiling adalah bahwa memori proses penuh tersedia. Ini meningkatkan kinerja karena Anda dapat meniru sebagian besar malware tanpa pernah meninggalkan unicorn. Selain itu hanya syscall yang harus ditiru untuk menyediakan lingkungan Windows yang realistis (karena semuanya sebenarnya merupakan lingkungan proses yang sah).