Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
miasm — Framework de rétro-ingénierie en Python | Kitploit
Outils/GitHubGitHub/cea-sec/miasm
Analyse StatiqueAnalyse Dynamique (Sandboxing)Rétro-ingénierieDébogueursFuzzingAnalyse de Binaires
GitHubcea-sec/miasm

miasm

Framework de rétro-ingénierie en Python

Voir le dépôt
3.9k48954il y a 14 joursVérifié par Kitploit
Site web
Partager

Miasm tests

Qu'est-ce que Miasm ?

Miasm est un framework de rétro-ingénierie libre et open source (GPLv2). Miasm vise à 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 de l'assembleur à l'aide d'un langage intermédiaire
  • Émuler à l'aide de JIT (analyse dynamique de code, dépaquetage, ...)
  • Simplification d'expressions pour la désobfuscation automatique
  • ...

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

Table des matières

  • Qu'est-ce que Miasm ?
  • Exemples de base
    • Assemblage / Désassemblage
    • Représentation intermédiaire
    • Émulation
    • Exécution symbolique
  • Comment ça fonctionne ?
  • Documentation
  • Obtenir Miasm
    • Prérequis logiciels
    • Configuration
    • Windows & IDA
  • Tests
  • Ils utilisent déjà Miasm
  • Divers

Exemples de base

Assemblage / Désassemblage

Importer l'architecture x86 de Miasm :

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

Obtenir une base de données de localisation :

>>> loc_db = LocationDB()

Assemblez une ligne :

>>> 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 :

>>> 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ésassembler le résultat :

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

En utilisant l'abstraction Machine :

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

Pour MIPS :

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

Représentation intermédiaire

Créer une instruction :

>>> machine = Machine('arml')
>>> instr = machine.mn.dis('\x00 \x88\xe0', 'l')
>>> print(instr)
ADD        R2, R8, R0

Créez un objet de représentation intermédiaire :

>>> lifter = machine.lifter_model_call(loc_db)

Créez un ircfg vide :

>>> ircfg = lifter.new_ircfg()

Ajouter une instruction au pool :

>>> lifter.add_instr_to_ircfg(instr, ircfg)

Afficher le pool actuel :

>>> for lbl, irblock in ircfg.blocks.items():
...     print(irblock)
loc_0:
R2 = R8 + R0

IRDst = loc_4

Travailler avec l'IR, par exemple en obtenant des effets secondaires :

>>> 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 Miasm IR sont disponibles dans le Jupyter Notebook correspondant.

Émulation

En fournissant un shellcode :

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 :

>>> 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 :

>>> 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 :

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

Ajoutez le shellcode à un emplacement mémoire arbitraire :

>>> 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 :

def code_sentinelle(jitter):
    jitter.running = False
    jitter.pc = 0
    return True

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

Journaux actifs :

>>> jitter.set_trace_log()

Exécuter à une adresse arbitraire :

>>> 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
>>>

Interagir avec le jitter :

>>> jitter.vm
ad 1230000 size 10000 RW_ hpad 0x2854b40
ad 40000000 size 16 RW_ hpad 0x25e0ed0

>>> hex(jitter.cpu.EAX)
'0x0L'
>>> jitter.cpu.ESI = 12

Exécution symbolique

Initialisation du pool IR :

>>> lifter = machine.lifter_model_call(loc_db)
>>> ircfg = lifter.new_ircfg_from_asmcfg(asmcfg)

Initialisation du moteur avec les valeurs symboliques par défaut :

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Pas encore de données de popularité.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →