Qu'est-ce que Miasm ?

Miasm est un framework de rétro-ingénierie gratuit et open source (GPLv2). Miasm a pour but d'analyser / modifier / générer des programmes binaires. Voici une liste non exhaustive de fonctionnalités :

Ouvrir / modifier / générer des PE / ELF 32 / 64 LE / BE
Assembler / Désassembler X86 / ARM / MIPS / SH4 / MSP430
Représenter la sémantique d'assemblage à l'aide d'un langage intermédiaire
Émuler via JIT (analyse de code dynamique, dépaquetage, ...)
Simplification d'expressions pour la désobfuscation automatique
...

Consultez le blog officiel pour plus d'exemples et de démos.

Table des matières

Qu'est-ce que Miasm ?
Exemples de base
Comment ça marche ?
Documentation
Obtenir Miasm
Tests
Ils utilisent déjà Miasm
Divers

Exemples de base

Assembler / Désassembler

Importer l'architecture x86 de Miasm :```pycon

from miasm.arch.x86.arch import mn_x86 from miasm.core.locationdb import LocationDB

Obtenez un db de localisation :```pycon
>>> loc_db = LocationDB()

Assembler une ligne :```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']

Modifier un opérande :```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']

Désassemblez le résultat :```pycon

print(mn_x86.dis(a[0], 32)) XOR EAX, ECX

En utilisant l'abstraction `Machine`:```pycon
>>> from miasm.analysis.machine import Machine
>>> mn = Machine('x86_32').mn
>>> print(mn.dis('\x33\x30', 32))
XOR        ESI, DWORD PTR [EAX]

Pour MIPS:```pycon

mn = Machine('mips32b').mn print(mn.dis(b'\x97\xa3\x00 ', "b")) LHU V1, 0x20(SP)

Représentation intermédiaire
---------------------------

Créer une instruction :```pycon
>>> machine = Machine('arml')
>>> instr = machine.mn.dis('\x00 \x88\xe0', 'l')
>>> print(instr)
ADD        R2, R8, R0

Créer un objet de représentation intermédiaire :```pycon

lifter = machine.lifter_model_call(loc_db)

Créer un ircfg vide :```pycon
>>> ircfg = lifter.new_ircfg()

Ajouter une instruction au pool:```pycon

lifter.add_instr_to_ircfg(instr, ircfg)

Afficher le pool actuel :```pycon
>>> for lbl, irblock in ircfg.blocks.items():
...     print(irblock)
loc_0:
R2 = R8 + R0

IRDst = loc_4

Travailler avec IR, par exemple en obtenant des effets secondaires :```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

Plus d'informations sur l'IR de Miasm sont dans le [Jupyter Notebook correspondant](https://github.com/cea-sec/miasm/blob/master/doc/expression/expression.ipynb).

Émulation
---------```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'

Importez le shellcode grâce à l'abstraction Container:```pycon

from miasm.analysis.binary import Container c = Container.from_string(s, loc_db) c <miasm.analysis.binary.ContainerUnknown object at 0x7f34cefe6090>

Désassemblage du shellcode à l'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

Initialisation du moteur JIT avec une pile :```pycon

jitter = machine.jitter(loc_db, jit_type='python') jitter.init_stack()

Ajoutez le shellcode dans un emplacement mémoire arbitraire :```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)

Créez une sentinelle pour intercepter le retour du shellcode :```Python def code_sentinelle(jitter): jitter.running = False jitter.pc = 0 return True

jitter.add_breakpoint(0x1337beef, code_sentinelle) jitter.push_uint32_t(0x1337beef)

Logs actifs:```pycon
>>> jitter.set_trace_log()

Exécuter à une adresse arbitraire :```pycon

jitter.init_run(run_addr) jitter.continue_run() RAX 0000000000000000 RBX 0000000000000000 RCX 0000000000000000 RDX 0000000000000000 RSI 0000000000000000 RDI 0000000000000000 RSP 000000000123FFF8 RBP 0000000000000000 zf 0000000000000000 nf 0000000000000000 of 0000000000000000 cf 0000000000000000 RIP 0000000040000000 40000000 LEA ECX, DWORD PTR [ECX+0x4] RAX 0000000000000000 RBX 0000000000000000 RCX 0000000000000004 RDX 0000000000000000 RSI 0000000000000000 RDI 0000000000000000 RSP 000000000123FFF8 RBP 0000000000000000 zf 0000000000000000 nf 0000000000000000 of 0000000000000000 cf 0000000000000000 .... 4000000e JMP loc_0000000040000013:0x40000013 RAX 0000000000000000 RBX 0000000000000000 RCX 0000000000000004 RDX 0000000000000000 RSI 0000000000000000 RDI 0000000000000000 RSP 000000000123FFF8 RBP 0000000000000000 zf 0000000000000000 nf 0000000000000000 of 0000000000000000 cf 0000000000000000 RIP 0000000040000013 40000013 MOV EAX, EBX RAX 0000000000000000 RBX 0000000000000000 RCX 0000000000000004 RDX 0000000000000000 RSI 0000000000000000 RDI 0000000000000000 RSP 000000000123FFF8 RBP 0000000000000000 zf 0000000000000000 nf 0000000000000000 of 0000000000000000 cf 0000000000000000 RIP 0000000040000013 40000015 RET

miasm

Populaires

Qu'est-ce que Miasm ?

Table des matières

Exemples de base

Assembler / Désassembler