Главная страница>Связанные с программированием>Питон
Скачать

Миазм тесты

Что такое Миазм?

Miasm — это бесплатная среда обратного инжиниринга с открытым исходным кодом (GPLv2). Миазм направлен на анализ/модификацию/генерацию двоичных программ. Вот неполный список возможностей:

  • Открытие/модификация/генерация PE/ELF 32/64 LE/BE
  • Сборка/Разборка X86/ARM/MIPS/SH4/MSP430
  • Представление семантики сборки с использованием промежуточного языка
  • Эмуляция с помощью JIT (динамический анализ кода, распаковка,...)
  • Упрощение выражений для автоматической деобфускации
  • ...

Дополнительную информацию о примерах и демонстрациях можно найти в официальном блоге.

Оглавление

  • Что такое Миазм?
  • Основные примеры
    • Сборка/Разборка
    • Промежуточное представительство
    • Эмуляция
    • Символическое исполнение
  • Как это работает?
  • Документация
  • Получение миазма
    • Требования к программному обеспечению
    • Конфигурация
    • Windows и ИДА
  • Тестирование
  • Они уже используют Миазм
  • Разное

Основные примеры

Сборка/Разборка

Импортировать архитектуру Miasm x86: 

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

Получить базу данных местоположения: 

>>> loc_db = LocationDB()

Собираем строку: 

>>> l = mn_x86.fromstring( ' XOR ECX, ECX ' , loc_db, 32 )
>>> print (l)
XOR        ECX, ECX
>>> mn_x86.asm(l)
['1xc9', '3xc9', 'g1xc9', 'g3xc9']

Измените операнд: 

>>> l.args[ 0 ] = mn_x86.regs. EAX
>>> print (l)
XOR        EAX, ECX
>>> a = mn_x86.asm(l)
>>> print (a)
['1xc8', '3xc1', 'g1xc8', 'g3xc1']

Разобрать результат: 

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

Использование Machine абстракции: 

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

Для МИПС: 

>>> mn = Machine( ' mips32b ' ).mn
>>> print (mn.dis( b ' x97xa3x00 ' , " b " ))
LHU        V1, 0x20(SP)

Промежуточное представительство

Создайте инструкцию: 

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

Создайте промежуточный объект представления: 

>>> lifter = machine.lifter_model_call(loc_db)

Создайте пустой ircfg: 

>>> ircfg = lifter.new_ircfg()

Добавьте инструкцию в пул: 

>>> lifter.add_instr_to_ircfg(instr, ircfg)

Распечатать текущий пул: 

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

IRDst = loc_4

Работая с IR, например, получая побочные эффекты: 

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

Дополнительную информацию о Miasm IR можно найти в соответствующем блокноте Jupyter.

Эмуляция

Даём шеллкод: 

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 ' x8d I x04x8d [ x01x80xf9x01 t x05x8d [ xffxebx03x8d [ x01x89xd8xc3 '

Импортируйте шеллкод благодаря абстракции Container : 

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

Дизассемблирование шеллкода по адресу 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

Инициализация JIT-движка со стеком: 

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

Добавьте шеллкод в произвольную ячейку памяти: 

>>> run_addr = 0x 40000000
>>> from miasm.jitter.csts import PAGE_READ , PAGE_WRITE
>>> jitter.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE , s)

Создайте Sentinel, чтобы перехватить возврат шеллкода: 

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

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

Активные журналы: 

>>> jitter.set_trace_log()

Запуск по произвольному адресу: 

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

Взаимодействие с джиттером: 

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

Символическое исполнение

Инициализация пула IR: 

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

Инициализация движка с символическими значениями по умолчанию: 

>>> from miasm.ir.symbexec import SymbolicExecutionEngine
>>> sb = SymbolicExecutionEngine(lifter)

Запускаем выполнение: 

>>> symbolic_pc = sb.run_at(ircfg, 0 )
>>> print (symbolic_pc)
((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)

То же самое с журналами шагов (отображаются только изменения): 

>>> sb = SymbolicExecutionEngine(lifter, machine.mn.regs.regs_init)
>>> symbolic_pc = sb.run_at(ircfg, 0 , step = True )
Instr LEA        ECX, DWORD PTR [ECX + 0x4]
Assignblk:
ECX = ECX + 0x4
________________________________________________________________________________
ECX                = ECX + 0x4
________________________________________________________________________________
Instr LEA        EBX, DWORD PTR [EBX + 0x1]
Assignblk:
EBX = EBX + 0x1
________________________________________________________________________________
EBX                = EBX + 0x1
ECX                = ECX + 0x4
________________________________________________________________________________
Instr CMP        CL, 0x1
Assignblk:
zf = (ECX[0:8] + -0x1)?(0x0,0x1)
nf = (ECX[0:8] + -0x1)[7:8]
pf = parity((ECX[0:8] + -0x1) & 0xFF)
of = ((ECX[0:8] ^ (ECX[0:8] + -0x1)) & (ECX[0:8] ^ 0x1))[7:8]
cf = (((ECX[0:8] ^ 0x1) ^ (ECX[0:8] + -0x1)) ^ ((ECX[0:8] ^ (ECX[0:8] + -0x1)) & (ECX[0:8] ^ 0x1)))[7:8]
af = ((ECX[0:8] ^ 0x1) ^ (ECX[0:8] + -0x1))[4:5]
________________________________________________________________________________
af                 = (((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[4:5]
pf                 = parity((ECX + 0x4)[0:8] + 0xFF)
zf                 = ((ECX + 0x4)[0:8] + 0xFF)?(0x0,0x1)
ECX                = ECX + 0x4
of                 = ((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1))[7:8]
nf                 = ((ECX + 0x4)[0:8] + 0xFF)[7:8]
cf                 = (((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1)) ^ ((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[7:8]
EBX                = EBX + 0x1
________________________________________________________________________________
Instr JZ         loc_key_1
Assignblk:
IRDst = zf?(loc_key_1,loc_key_2)
EIP = zf?(loc_key_1,loc_key_2)
________________________________________________________________________________
af                 = (((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[4:5]
EIP                = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
pf                 = parity((ECX + 0x4)[0:8] + 0xFF)
IRDst              = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
zf                 = ((ECX + 0x4)[0:8] + 0xFF)?(0x0,0x1)
ECX                = ECX + 0x4
of                 = ((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1))[7:8]
nf                 = ((ECX + 0x4)[0:8] + 0xFF)[7:8]
cf                 = (((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1)) ^ ((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[7:8]
EBX                = EBX + 0x1
________________________________________________________________________________
>>>

Повторите выполнение с конкретным ECX. Здесь символическое/конколическое выполнение достигает конца шеллкода: 

>>> from miasm.expression.expression import ExprInt
>>> sb.symbols[machine.mn.regs. ECX ] = ExprInt( - 3 , 32 )
>>> symbolic_pc = sb.run_at(ircfg, 0 , step = True )
Instr LEA        ECX, DWORD PTR [ECX + 0x4]
Assignblk:
ECX = ECX + 0x4
________________________________________________________________________________
af                 = (((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[4:5]
EIP                = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
pf                 = parity((ECX + 0x4)[0:8] + 0xFF)
IRDst              = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
zf                 = ((ECX + 0x4)[0:8] + 0xFF)?(0x0,0x1)
ECX                = 0x1
of                 = ((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1))[7:8]
nf                 = ((ECX + 0x4)[0:8] + 0xFF)[7:8]
cf                 = (((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1)) ^ ((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[7:8]
EBX                = EBX + 0x1
________________________________________________________________________________
Instr LEA        EBX, DWORD PTR [EBX + 0x1]
Assignblk:
EBX = EBX + 0x1
________________________________________________________________________________
af                 = (((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[4:5]
EIP                = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
pf                 = parity((ECX + 0x4)[0:8] + 0xFF)
IRDst              = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
zf                 = ((ECX + 0x4)[0:8] + 0xFF)?(0x0,0x1)
ECX                = 0x1
of                 = ((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1))[7:8]
nf                 = ((ECX + 0x4)[0:8] + 0xFF)[7:8]
cf                 = (((((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8]) & ((ECX + 0x4)[0:8] ^ 0x1)) ^ ((ECX + 0x4)[0:8] + 0xFF) ^ (ECX + 0x4)[0:8] ^ 0x1)[7:8]
EBX                = EBX + 0x2
________________________________________________________________________________
Instr CMP        CL, 0x1
Assignblk:
zf = (ECX[0:8] + -0x1)?(0x0,0x1)
nf = (ECX[0:8] + -0x1)[7:8]
pf = parity((ECX[0:8] + -0x1) & 0xFF)
of = ((ECX[0:8] ^ (ECX[0:8] + -0x1)) & (ECX[0:8] ^ 0x1))[7:8]
cf = (((ECX[0:8] ^ 0x1) ^ (ECX[0:8] + -0x1)) ^ ((ECX[0:8] ^ (ECX[0:8] + -0x1)) & (ECX[0:8] ^ 0x1)))[7:8]
af = ((ECX[0:8] ^ 0x1) ^ (ECX[0:8] + -0x1))[4:5]
________________________________________________________________________________
af                 = 0x0
EIP                = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
pf                 = 0x1
IRDst              = ((ECX + 0x4)[0:8] + 0xFF)?(0xB,0x10)
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x2
________________________________________________________________________________
Instr JZ         loc_key_1
Assignblk:
IRDst = zf?(loc_key_1,loc_key_2)
EIP = zf?(loc_key_1,loc_key_2)
________________________________________________________________________________
af                 = 0x0
EIP                = 0x10
pf                 = 0x1
IRDst              = 0x10
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x2
________________________________________________________________________________
Instr LEA        EBX, DWORD PTR [EBX + 0x1]
Assignblk:
EBX = EBX + 0x1
________________________________________________________________________________
af                 = 0x0
EIP                = 0x10
pf                 = 0x1
IRDst              = 0x10
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x3
________________________________________________________________________________
Instr LEA        EBX, DWORD PTR [EBX + 0x1]
Assignblk:
IRDst = loc_key_3
________________________________________________________________________________
af                 = 0x0
EIP                = 0x10
pf                 = 0x1
IRDst              = 0x13
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x3
________________________________________________________________________________
Instr MOV        EAX, EBX
Assignblk:
EAX = EBX
________________________________________________________________________________
af                 = 0x0
EIP                = 0x10
pf                 = 0x1
IRDst              = 0x13
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x3
EAX                = EBX + 0x3
________________________________________________________________________________
Instr RET
Assignblk:
IRDst = @32[ESP[0:32]]
ESP = {ESP[0:32] + 0x4 0 32}
EIP = @32[ESP[0:32]]
________________________________________________________________________________
af                 = 0x0
EIP                = @32[ESP]
pf                 = 0x1
IRDst              = @32[ESP]
zf                 = 0x1
ECX                = 0x1
of                 = 0x0
nf                 = 0x0
cf                 = 0x0
EBX                = EBX + 0x3
ESP                = ESP + 0x4
EAX                = EBX + 0x3
________________________________________________________________________________
>>>

Как это работает?

В Miasm встроен собственный дизассемблер, промежуточный язык и семантика инструкций. Он написан на Python.

Для эмуляции кода он использует LLVM, GCC, Clang или Python для JIT-компиляции промежуточного представления. Он может эмулировать шеллкоды и все или части двоичных файлов. Обратные вызовы Python могут выполняться для взаимодействия с выполнением, например, для эмуляции эффектов библиотечных функций.

Документация

Некоторые ресурсы документации доступны в папке doc.

Доступна автоматически сгенерированная документация:

  • Доксиген
  • документ

Получение миазма

  • Клонируйте репозиторий: Miasm на GitHub.
  • Получите один из образов Docker в Docker Hub.

Требования к программному обеспечению

Миазм использует:

  • python-pyparsing
  • python-dev
  • опционально python-pycparser (версия >= 2.17)

Чтобы включить код JIT, необходим один из следующих модулей:

  • GCC
  • Кланг
  • LLVM с Numba llvmlite, см. ниже

«Необязательный» Миазм также может использовать:

  • Z3, средство доказательства теорем

Конфигурация

Для использования джиттера рекомендуется использовать GCC или LLVM.

  • GCC (любая версия)
  • Кланг (любая версия)
  • ЛЛВМ
    • Debian (тестируется/нестабильный): не тестировался.
    • Стабильная версия Debian/Ubuntu/Kali/что угодно: pip install llvmlite или установка из llvmlite
    • Windows: не тестировалось
  • Собираем и устанавливаем Миазм: 
$ cd miasm_directory
$ python setup.py build
$ sudo python setup.py install

Если что-то пойдет не так во время компиляции одного из модулей джиттера, Miasm пропустит ошибку и отключит соответствующий модуль (см. выходные данные компиляции).

Windows и ИДА

Большинство плагинов IDA Miasm используют подмножество функций Miasm. Быстрый способ заставить их работать — добавить:

  • pyparsing.py в C:...IDApython или pip install pyparsing
  • каталог miasm/miasm в C:...IDApython

Будут доступны все функции, кроме связанных с JITter. Для более полной установки, пожалуйста, обратитесь к параграфам выше.

Тестирование

Миазм поставляется с набором регрессионных тестов. Чтобы запустить их все: 

cd miasm_directory/test

# Run tests using our own test runner
python test_all.py

# Run tests using standard frameworks (slower, require 'parameterized')
python -m unittest test_all.py        # sequential, requires 'unittest'
python -m pytest test_all.py          # sequential, requires 'pytest'
python -m pytest -n auto test_all.py  # parallel, requires 'pytest' and 'pytest-xdist'

Можно указать некоторые параметры:

  • Монопоточность: -m
  • Инструментарий покрытия кода: -c
  • Только быстрые тесты: -t long (исключает длинные тесты)

Они уже используют Миазм

Инструменты

  • Сивилла: функциональный инструмент для гадания
  • R2M2: используйте миазм в качестве плагина для радара2.
  • CGrex: целевой патчер для двоичных файлов CGC.
  • ethRE: инструмент реверса для Ethereum EVM (с соответствующей архитектурой Miasm2).

Сообщения в блогах/доклады/конференции

  • Деобфускация: восстановление программы, защищенной OLLVM
  • Укрощение дикого бинарного файла MIPS, защищенного наномитами, с помощью символического выполнения: нет такого взлома
  • Génération Rapide de DGA с миазмом: быстрое вычисление DGA (статья на французском языке)
  • Включение устойчивости к сбоям на стороне клиента для преодоления диверсификации и сокрытия информации: обнаружение потенциальных аргументов ненаправленного вызова
  • Миазм: Основы обратного инжиниринга (французский)
  • Учебный миазм (французское видео)
  • Графики зависимостей: стиль Petit Poucet: DepGraph (французский)

Книги

  • Практическое обратное проектирование: X86, X64, Arm, ядро ​​Windows, инструменты реверса и запутывание: введение в миазм (глава 5 «Запутывание»)
  • BlackHat Python – Приложение: образцы книги по безопасности Японии
Расширять
Дополнительная информация
Связанные приложения
Рекомендуем вам
Связанные новости Все