Miasm - Folha de Dicas do Framework de Engenharia Reversa
Miasm é um framework Python gratuito e de código aberto para analisar, gerar e manipular binários. Pode desmontar em muitas arquiteturas (x86/x64, ARM, MIPS, PPC e mais), levantar código para sua própria representação intermediária (IR), emular execução com JIT e executar execução simbólica para deofuscação e resolução de restrições. É um toolkit programático — você o aciona do Python — que o torna poderoso para automatizar tarefas de engenharia reversa e desempacotamento que ferramentas GUI não conseguem escrever facilmente.
Instalação
| Método | Comando |
|---|
| pip | pip install miasm |
| A partir do código-fonte | git clone https://github.com/cea-sec/miasm && cd miasm && pip install -e . |
| JIT Opcional (LLVM) | pip install llvmlite (backend de emulação mais rápido) |
| Docker | docker build -t miasm . a partir do repositório |
| Verificar | python -c "import miasm; print('ok')" |
Módulos Principais
| Módulo | Propósito |
|---|
miasm.analysis.binary | Carregue um contêiner binário (ELF/PE/raw) |
miasm.analysis.machine | Abstração de arquitetura (Machine("x86_64")) |
miasm.core.locationdb | Rastreie endereços/rótulos em toda a análise |
miasm.ir | Representação intermediária de instruções |
miasm.analysis.dse | Motor de execução simbólica dinâmica |
miasm.jitter | Motor de emulação/JIT |
Desassembly
from miasm.analysis.binary import Container
from miasm.analysis.machine import Machine
from miasm.core.locationdb import LocationDB
loc_db = LocationDB()
cont = Container.from_stream(open("target.bin", "rb"), loc_db)
machine = Machine(cont.arch)
mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db)
asmcfg = mdis.dis_multiblock(cont.entry_point) # desassembly recursivo → CFG
for block in asmcfg.blocks:
print(block)
| Chamada | Descrição |
|---|
mdis.dis_block(addr) | Desmonte um único bloco básico |
mdis.dis_multiblock(addr) | Desmonte recursivamente em um CFG |
asmcfg.blocks | Itere blocos básicos |
asmcfg.dot() | Exporte o gráfico de fluxo de controle para Graphviz |
Representação Intermediária (IR)
lifter = machine.lifter_model_call(mdis.loc_db)
ircfg = lifter.new_ircfg_from_asmcfg(asmcfg)
for lbl, irblock in ircfg.blocks.items():
print(irblock)
A IR normaliza instruções específicas de arquitetura em uma pequena linguagem tipada, o que torna possível análise entre arquiteturas e raciocínio simbólico.
Emulação (Jitter)
from miasm.analysis.machine import Machine
jitter = Machine("x86_64").jitter("llvm") # ou "python", "gcc"
jitter.init_stack()
# mapeie código, defina registradores, depois:
jitter.run(0x401000)
| Backend | Trade-off |
|---|
python | Portável, mais lento |
gcc | Mais rápido, precisa de um compilador |
llvm | Mais rápido, precisa de llvmlite |
| Recurso | Use |
|---|
add_breakpoint(addr, cb) | Execute um callback Python em um endereço |
vm.set_mem(addr, data) | Escreva memória antes de executar |
| Syscalls/APIs personalizadas | Hook chamadas de biblioteca durante emulação |
Execução Simbólica
from miasm.ir.symbexec import SymbolicExecutionEngine
sb = SymbolicExecutionEngine(lifter)
symbolic_pc = sb.run_at(ircfg, 0x401000)
print(sb.symbols) # estado simbólico de registrador/memória
A execução simbólica é a base para deofuscação, resolução de entradas e simplificação de lixo/predicados opacos.
Fluxos de Trabalho Comuns
| Objetivo | Abordagem |
|---|
| Exporte um CFG para visualizar | asmcfg.dot() → renderize com Graphviz |
| Desempacotar/deofuscar | Emule com o jitter, despeje memória no OEP |
| Resolva para uma entrada | Execução simbólica + um solver SMT (z3) |
| Análise entre arquiteturas | Levante para IR, execute os mesmos passes independentemente de arquitetura |
Miasm vs Outros Frameworks de RE
| Aspecto | Miasm | angr | Ghidra |
|---|
| Linguagem | Python | Python | Java/GUI |
| IR | Próprio IR | VEX | P-code |
| Emulação | JIT integrado | Baseado em Unicorn | API do Emulador |
| Execução simbólica | Sim | Sim (força principal) | Limitado |
| Melhor para | Análise em scripts, deofuscação | Simbólico/CTF | RE interativo |
Recursos
