cea-sec/miasmReverse-Engineering-Framework in Python
Miasm ist ein kostenloses und quelloffenes (GPLv2) Reverse-Engineering-Framework. Miasm zielt darauf ab, Binärprogramme zu analysieren / zu modifizieren / zu generieren. Hier ist eine unvollständige Liste der Funktionen:
Siehe den offiziellen Blog für weitere Beispiele und Demos.
Importiere die Miasm x86-Architektur:```pycon
from miasm.arch.x86.arch import mn_x86 from miasm.core.locationdb import LocationDB
Standort-Datenbank abrufen:```pycon
>>> loc_db = LocationDB()
Stelle eine Zeile zusammen:```pycon
l = mn_x86.fromstring('XOR ECX, ECX', loc_db, 32) print(l) XOR ECX, ECX mn_x86.asm(l) ['1\xc9', '3\xc9', 'g1\xc9', 'g3\xc9']
Operand ändern:```pycon
>>> l.args[0] = mn_x86.regs.EAX
>>> print(l)
XOR EAX, ECX
>>> a = mn_x86.asm(l)
>>> print(a)
['1\xc8', '3\xc1', 'g1\xc8', 'g3\xc1']
Disassemblieren Sie das Ergebnis:```pycon
print(mn_x86.dis(a[0], 32)) XOR EAX, ECX
Verwendung der `Machine`-Abstraktion:```pycon
>>> from miasm.analysis.machine import Machine
>>> mn = Machine('x86_32').mn
>>> print(mn.dis('\x33\x30', 32))
XOR ESI, DWORD PTR [EAX]
Für MIPS:```pycon
mn = Machine('mips32b').mn print(mn.dis(b'\x97\xa3\x00 ', "b")) LHU V1, 0x20(SP)
Zwischendarstellung
---------------------------
Erstelle eine Anweisung:```pycon
>>> machine = Machine('arml')
>>> instr = machine.mn.dis('\x00 \x88\xe0', 'l')
>>> print(instr)
ADD R2, R8, R0
Erstellen Sie ein Objekt der Zwischendarstellung:```pycon
lifter = machine.lifter_model_call(loc_db)
Erstelle eine leere ircfg:```pycon
>>> ircfg = lifter.new_ircfg()
Anweisung zum Pool hinzufügen:```pycon
lifter.add_instr_to_ircfg(instr, ircfg)
Aktuellen Pool ausgeben:```pycon
>>> for lbl, irblock in ircfg.blocks.items():
... print(irblock)
loc_0:
R2 = R8 + R0
IRDst = loc_4
Arbeiten mit IR, zum Beispiel durch das Erhalten von Nebeneffekten:```pycon
for lbl, irblock in ircfg.blocks.items(): ... for assignblk in irblock: ... rw = assignblk.get_rw() ... for dst, reads in rw.items(): ... print('read: ', [str(x) for x in reads]) ... print('written:', dst) ... print() ... read: ['R8', 'R0'] written: R2
read: [] written: IRDst
Weitere Informationen zur Miasm IR finden Sie im [zugehörigen Jupyter Notebook](https://github.com/cea-sec/miasm/blob/master/doc/expression/expression.ipynb).
Emulation
---------
Angenommen, ein Shellcode:```pycon
00000000 8d4904 lea ecx, [ecx+0x4]
00000003 8d5b01 lea ebx, [ebx+0x1]
00000006 80f901 cmp cl, 0x1
00000009 7405 jz 0x10
0000000b 8d5bff lea ebx, [ebx-1]
0000000e eb03 jmp 0x13
00000010 8d5b01 lea ebx, [ebx+0x1]
00000013 89d8 mov eax, ebx
00000015 c3 ret
>>> s = b'\x8dI\x04\x8d[\x01\x80\xf9\x01t\x05\x8d[\xff\xeb\x03\x8d[\x01\x89\xd8\xc3'
Importiere den Shellcode dank der Container-Abstraktion:```pycon
from miasm.analysis.binary import Container c = Container.from_string(s, loc_db) c <miasm.analysis.binary.ContainerUnknown object at 0x7f34cefe6090>
Disassemblieren des Shellcodes an Adresse `0`:```pycon
>>> from miasm.analysis.machine import Machine
>>> machine = Machine('x86_32')
>>> mdis = machine.dis_engine(c.bin_stream, loc_db=loc_db)
>>> asmcfg = mdis.dis_multiblock(0)
>>> for block in asmcfg.blocks:
... print(block)
...
loc_0
LEA ECX, DWORD PTR [ECX + 0x4]
LEA EBX, DWORD PTR [EBX + 0x1]
CMP CL, 0x1
JZ loc_10
-> c_next:loc_b c_to:loc_10
loc_10
LEA EBX, DWORD PTR [EBX + 0x1]
-> c_next:loc_13
loc_b
LEA EBX, DWORD PTR [EBX + 0xFFFFFFFF]
JMP loc_13
-> c_to:loc_13
loc_13
MOV EAX, EBX
RET
Initialisieren der JIT-Engine mit einem Stack:```pycon
jitter = machine.jitter(loc_db, jit_type='python') jitter.init_stack()
Fügen Sie den Shellcode an einer beliebigen Speicherstelle hinzu:```pycon
>>> run_addr = 0x40000000
>>> from miasm.jitter.csts import PAGE_READ, PAGE_WRITE
>>> jitter.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, s)
Erstellen Sie einen Wächter, um die Rückkehr des Shellcodes abzufangen:```Python def code_sentinelle(jitter): jitter.running = False jitter.pc = 0 return True