🥇Носорог в котка - стартирайте фърмуера в емулатора на Kopycat

Като част от срещата 0x0A DC7831 DEF CON Нижни Новгород На 16 февруари представихме доклад за основните принципи на емулация на двоичен код и нашата собствена разработка - емулатор на хардуерна платформа Копие.

В тази статия ще опишем как да стартираме фърмуера на устройството в емулатора, ще демонстрираме взаимодействие с дебъгера и ще извършим малък динамичен анализ на фърмуера.

праистория

Преди много време в една далечна галактика

Преди няколко години в нашата лаборатория имаше нужда да се изследва фърмуера на устройство. Фърмуерът беше компресиран и разопакован с буутлоудър. Той направи това по много сложен начин, премествайки данните в паметта няколко пъти. И самият фърмуер след това активно взаимодейства с периферните устройства. И всичко това на MIPS ядрото.

По обективни причини наличните емулатори не ни устройваха, но все пак искахме да стартираме кода. Тогава решихме да направим наш собствен емулатор, който да направи минимума и да ни позволи да разопаковаме основния фърмуер. Опитахме го и се получи. Помислихме, какво ще стане, ако добавим периферни устройства, които също да изпълняват основния фърмуер. Не болеше много - и също се получи. Помислихме отново и решихме да направим пълноценен емулатор.

Резултатът беше емулатор на компютърни системи Копие.

Защо Kopycat?

Има игра на думи.

Copycat (английски, съществително [ˈkɒpɪkæt]) - имитатор, имитатор
котка (Английски, съществително [ˈkæt]) - котка, котка - любимото животно на един от създателите на проекта
Буквата “K” е от езика за програмиране Kotlin

Копие

При създаването на емулатора бяха поставени много конкретни цели:

възможност за бързо създаване на нови периферни устройства, модули, процесорни ядра;
възможност за сглобяване на виртуално устройство от различни модули;
възможност за зареждане на всякакви двоични данни (фърмуер) в паметта на виртуално устройство;
умение за работа със snapshots (моментни снимки на състоянието на системата);
възможността за взаимодействие с емулатора чрез вградения дебъгер;
хубав модерен език за развитие.

В резултат на това беше избран Kotlin за внедряване, архитектурата на шината (това е, когато модулите комуникират помежду си чрез виртуални шини за данни), JSON като формат за описание на устройството и GDB RSP като протокол за взаимодействие с дебъгера.

Разработката продължава малко повече от две години и продължава активно. През това време бяха внедрени процесорни ядра MIPS, x86, V850ES, ARM и PowerPC.

Проектът се разраства и е време да го представим на широката публика. Ще направим подробно описание на проекта по-късно, но засега ще се съсредоточим върху използването на Kopycat.

За най-нетърпеливите може да изтеглите промо версия на емулатора от връзка.

Rhino в емулатора

Нека припомним, че по-рано за конференцията SMARTRHINO-2018 беше създадено тестово устройство „Rhinoceros“ за обучение на умения за обратно инженерство. Процесът на статичен анализ на фърмуера е описан в тази статия.

Сега нека се опитаме да добавим „високоговорители“ и да стартираме фърмуера в емулатора.

Имаме нужда от:
1) Java 1.8
2) Python и модул Джеп да използвате Python вътре в емулатора. Можете да изградите WHL модул Jep за Windows изтеглете тук.

За Windows:
1) com0com
2) PuTTY

За Linux:
1) соц

Можете да използвате Eclipse, IDA Pro или radare2 като GDB клиент.

Как действа тя?

За да се извърши фърмуер в емулатора, е необходимо да се „сглоби“ виртуално устройство, което е аналог на реално устройство.

Истинското устройство ("носорог") може да бъде показано на блоковата диаграма:

Емулаторът има модулна структура и крайното виртуално устройство може да бъде описано в JSON файл.

JSON 105 реда

{
  "top": true,

  // Plugin name should be the same as file name (or full path from library start)
  "plugin": "rhino",

  // Directory where plugin places
  "library": "user",

  // Plugin parameters (constructor parameters if jar-plugin version)
  "params": [
    { "name": "tty_dbg", "type": "String"},
    { "name": "tty_bt", "type": "String"},
    { "name": "firmware", "type": "String", "default": "NUL"}
  ],

  // Plugin outer ports
  "ports": [  ],

  // Plugin internal buses
  "buses": [
    { "name": "mem", "size": "BUS30" },
    { "name": "nand", "size": "4" },
    { "name": "gpio", "size": "BUS32" }
  ],

  // Plugin internal components
  "modules": [
    {
      "name": "u1_stm32",
      "plugin": "STM32F042",
      "library": "mcu",
      "params": {
        "firmware:String": "params.firmware"
      }
    },
    {
      "name": "usart_debug",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_dbg"
      }
    },
    {
      "name": "term_bt",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_bt"
      }
    },
    {
      "name": "bluetooth",
      "plugin": "BT",
      "library": "mcu"
    },

    { "name": "led_0",  "plugin": "LED", "library": "mcu" },
    { "name": "led_1",  "plugin": "LED", "library": "mcu" },
    { "name": "led_2",  "plugin": "LED", "library": "mcu" },
    { "name": "led_3",  "plugin": "LED", "library": "mcu" },
    { "name": "led_4",  "plugin": "LED", "library": "mcu" },
    { "name": "led_5",  "plugin": "LED", "library": "mcu" },
    { "name": "led_6",  "plugin": "LED", "library": "mcu" },
    { "name": "led_7",  "plugin": "LED", "library": "mcu" },
    { "name": "led_8",  "plugin": "LED", "library": "mcu" },
    { "name": "led_9",  "plugin": "LED", "library": "mcu" },
    { "name": "led_10", "plugin": "LED", "library": "mcu" },
    { "name": "led_11", "plugin": "LED", "library": "mcu" },
    { "name": "led_12", "plugin": "LED", "library": "mcu" },
    { "name": "led_13", "plugin": "LED", "library": "mcu" },
    { "name": "led_14", "plugin": "LED", "library": "mcu" },
    { "name": "led_15", "plugin": "LED", "library": "mcu" }
  ],

  // Plugin connection between components
  "connections": [
    [ "u1_stm32.ports.usart1_m", "usart_debug.ports.term_s"],
    [ "u1_stm32.ports.usart1_s", "usart_debug.ports.term_m"],

    [ "u1_stm32.ports.usart2_m", "bluetooth.ports.usart_m"],
    [ "u1_stm32.ports.usart2_s", "bluetooth.ports.usart_s"],

    [ "bluetooth.ports.bt_s", "term_bt.ports.term_m"],
    [ "bluetooth.ports.bt_m", "term_bt.ports.term_s"],

    [ "led_0.ports.pin",  "u1_stm32.buses.pin_output_a", "0x00"],
    [ "led_1.ports.pin",  "u1_stm32.buses.pin_output_a", "0x01"],
    [ "led_2.ports.pin",  "u1_stm32.buses.pin_output_a", "0x02"],
    [ "led_3.ports.pin",  "u1_stm32.buses.pin_output_a", "0x03"],
    [ "led_4.ports.pin",  "u1_stm32.buses.pin_output_a", "0x04"],
    [ "led_5.ports.pin",  "u1_stm32.buses.pin_output_a", "0x05"],
    [ "led_6.ports.pin",  "u1_stm32.buses.pin_output_a", "0x06"],
    [ "led_7.ports.pin",  "u1_stm32.buses.pin_output_a", "0x07"],
    [ "led_8.ports.pin",  "u1_stm32.buses.pin_output_a", "0x08"],
    [ "led_9.ports.pin",  "u1_stm32.buses.pin_output_a", "0x09"],
    [ "led_10.ports.pin", "u1_stm32.buses.pin_output_a", "0x0A"],
    [ "led_11.ports.pin", "u1_stm32.buses.pin_output_a", "0x0B"],
    [ "led_12.ports.pin", "u1_stm32.buses.pin_output_a", "0x0C"],
    [ "led_13.ports.pin", "u1_stm32.buses.pin_output_a", "0x0D"],
    [ "led_14.ports.pin", "u1_stm32.buses.pin_output_a", "0x0E"],
    [ "led_15.ports.pin", "u1_stm32.buses.pin_output_a", "0x0F"]
  ]
}

Обърнете внимание на параметъра фърмуер раздел params е името на файл, който може да бъде зареден във виртуално устройство като фърмуер.

Виртуалното устройство и неговото взаимодействие с основната операционна система могат да бъдат представени чрез следната диаграма:

Текущият тестов екземпляр на емулатора включва взаимодействие с COM портовете на основната операционна система (отстраняване на грешки UART и UART за Bluetooth модула). Това могат да бъдат реални портове, към които са свързани устройства или виртуални COM портове (за това просто ви трябва com0com/socat).

В момента има два основни начина за взаимодействие с емулатора отвън:

GDB RSP протокол (съответно инструментите, които поддържат този протокол са Eclipse / IDA / radare2);
вътрешен команден ред на емулатора (Argparse или Python).

Виртуални COM портове

За да взаимодействате с UART на виртуално устройство на локалната машина чрез терминал, трябва да създадете двойка свързани виртуални COM портове. В нашия случай един порт се използва от емулатора, а вторият се използва от терминална програма (PuTTY или екран):

Използване на com0com

Виртуалните COM портове се конфигурират с помощта на помощната програма за настройка от комплекта com0com (конзолна версия - C:Програмни файлове (x86)com0comsetupс.exe, или GUI версия - C:Програмни файлове (x86)com0comsetupg.exe):

Поставете отметки в квадратчетата активирайте препълване на буфера за всички създадени виртуални портове, в противен случай емулаторът ще изчака отговор от COM порта.

Използвайки socat

В UNIX системи виртуалните COM портове се създават автоматично от емулатора с помощта на помощната програма socat; за да направите това, просто посочете префикса в името на порта, когато стартирате емулатора socat:.

Вътрешен интерфейс на командния ред (Argparse или Python)

Тъй като Kopycat е конзолно приложение, емулаторът предоставя две опции за интерфейс на командния ред за взаимодействие с неговите обекти и променливи: Argparse и Python.

Argparse е CLI, вграден в Kopycat и винаги е достъпен за всички.

Алтернативен CLI е интерпретаторът на Python. За да го използвате, трябва да инсталирате модула Jep Python и да конфигурирате емулатора да работи с Python (ще се използва интерпретаторът на Python, инсталиран на основната система на потребителя).

Инсталиране на Python модул Jep

Под Linux Jep може да се инсталира чрез pip:

pip install jep

За да инсталирате Jep на Windows, първо трябва да инсталирате Windows SDK и съответното Microsoft Visual Studio. Направихме го малко по-лесно за вас и WHL изгражда JEP за текущите версии на Python за Windows, така че модулът може да бъде инсталиран от файла:

pip install jep-3.8.2-cp27-cp27m-win_amd64.whl

За да проверите инсталирането на Jep, трябва да стартирате от командния ред:

python -c "import jep"

Следното съобщение трябва да бъде получено в отговор:

ImportError: Jep is not supported in standalone Python, it must be embedded in Java.

В пакетния файл на емулатора за вашата система (copycat.bat - за Windows, имитатор - за Linux) към списъка с параметри DEFAULT_JVM_OPTS добавете допълнителен параметър Djava.library.path — трябва да съдържа пътя до инсталирания Jep модул.

Резултатът за Windows трябва да бъде ред като този:

set DEFAULT_JVM_OPTS="-XX:MaxMetaspaceSize=256m" "-XX:+UseParallelGC" "-XX:SurvivorRatio=6" "-XX:-UseGCOverheadLimit" "-Djava.library.path=C:/Python27/Lib/site-packages/jep"

Стартиране на Kopycat

Емулаторът е конзолно JVM приложение. Стартирането се извършва чрез скрипта на командния ред на операционната система (sh/cmd).

Команда за изпълнение под Windows:

binkopycat -g 23946 -n rhino -l user -y library -p firmware=firmwarerhino_pass.bin,tty_dbg=COM26,tty_bt=COM28

Команда за изпълнение под Linux с помощната програма socat:

./bin/kopycat -g 23946 -n rhino -l user -y library -p firmware=./firmware/rhino_pass.bin, tty_dbg=socat:./COM26,tty_bt=socat:./COM28

-g 23646 — TCP порт, който ще бъде отворен за достъп до GDB сървъра;
-n rhino — име на основния системен модул (сглобено устройство);
-l user — име на библиотеката за търсене на основния модул;
-y library — път за търсене на модули, включени в устройството;
firmwarerhino_pass.bin — път до файла на фърмуера;
COM26 и COM28 са виртуални COM портове.

В резултат на това ще се покаже подкана Python > (Or Argparse >):

18:07:59 INFO [eFactoryBuilder.create ]: Module top successfully created as top
18:07:59 INFO [ Module.initializeAndRes]: Setup core to top.u1_stm32.cortexm0.arm for top
18:07:59 INFO [ Module.initializeAndRes]: Setup debugger to top.u1_stm32.dbg for top
18:07:59 WARN [ Module.initializeAndRes]: Tracer wasn't found in top...
18:07:59 INFO [ Module.initializeAndRes]: Initializing ports and buses...
18:07:59 WARN [ Module.initializePortsA]: ATTENTION: Some ports has warning use printModulesPortsWarnings to see it...
18:07:59 FINE [ ARMv6CPU.reset ]: Set entry point address to 08006A75
18:07:59 INFO [ Module.initializeAndRes]: Module top is successfully initialized and reset as a top cell!
18:07:59 INFO [ Kopycat.open ]: Starting virtualization of board top[rhino] with arm[ARMv6Core]
18:07:59 INFO [ GDBServer.debuggerModule ]: Set new debugger module top.u1_stm32.dbg for GDB_SERVER(port=23946,alive=true)
Python >

Взаимодействие с IDA Pro

За да опростим тестването, ние използваме фърмуера на Rhino като изходен файл за анализ в IDA във формата ELF файл (мета информацията се съхранява там).

Можете също да използвате основния фърмуер без мета информация.

След като стартирате Kopycat в IDA Pro, в менюто Debugger отидете на елемента „Превключване на програмата за отстраняване на грешки..." и изберете "Отдалечен GDB дебъгер". След това настройте връзката: меню Дебъгер - Опции на процеса...

Задайте стойностите:

Приложение - произволна стойност
Име на хост: 127.0.0.1 (или IP адреса на отдалечената машина, на която работи Kopycat)
Port: 23946

Сега бутонът за отстраняване на грешки става достъпен (клавиш F9):

Щракнете върху него, за да се свържете с модула за отстраняване на грешки в емулатора. IDA преминава в режим на отстраняване на грешки, стават достъпни допълнителни прозорци: информация за регистрите, за стека.

Сега можем да използваме всички стандартни функции на дебъгера:

стъпка по стъпка изпълнение на инструкции (Влезте и Прекрача — клавиши F7 и F8, съответно);
стартиране и пауза на изпълнение;
създаване на точки на прекъсване както за код, така и за данни (клавиш F2).

Свързването към дебъгер не означава стартиране на кода на фърмуера. Текущата позиция за изпълнение трябва да бъде адресът 0x08006A74 — начало на функцията Reset_Handler. Ако превъртите надолу списъка, можете да видите извикването на функцията основен. Можете да поставите курсора на този ред (адрес 0x08006ABE) и извършете операцията Пуснете до курсора (клавиш F4).

След това можете да натиснете F7, за да влезете във функцията основен.

Ако изпълните командата Продължете процеса (клавиш F9), тогава ще се появи прозорецът „Моля, изчакайте“ с един бутон Задържане:

Когато натиснете Задържане Изпълнението на кода на фърмуера е спряно и може да бъде продължено от същия адрес в кода, където е било прекъснато.

Ако продължите да изпълнявате кода, ще видите следните редове в терминалите, свързани към виртуалните COM портове:

Наличието на линията „байпас на състоянието“ показва, че виртуалният Bluetooth модул е преминал в режим на получаване на данни от COM порта на потребителя.

Сега в Bluetooth терминала (COM29 на снимката) можете да въвеждате команди в съответствие с протокола Rhino. Например командата “MEOW” ще върне низа “mur-mur” на Bluetooth терминала:

Подражавай на мен не напълно

Когато създавате емулатор, можете да изберете нивото на детайлност/емулация на конкретно устройство. Например Bluetooth модулът може да бъде емулиран по различни начини:

устройството е напълно емулирано с пълен набор от команди;
AT командите се емулират и потокът от данни се получава от COM порта на основната система;
виртуалното устройство осигурява пълно пренасочване на данните към реалното устройство;
като обикновен мъниче, който винаги връща „ОК“.

Текущата версия на емулатора използва втория подход - виртуалният Bluetooth модул извършва конфигурация, след което преминава в режим на „проксииране“ на данни от COM порта на основната система към UART порта на емулатора.

Нека разгледаме възможността за просто инструментиране на кода, в случай че част от периферията не е внедрена. Например, ако не е създаден таймер, отговорен за контролиране на трансфера на данни към DMA (проверката се извършва във функцията ws2812b_чакайтенамира се в 0x08006840), тогава фърмуерът винаги ще чака флагът да бъде нулиран заетнамира се в 0x200004C4което показва заетостта на DMA линията за данни:

Можем да заобиколим тази ситуация, като ръчно нулираме флага зает веднага след инсталирането му. В IDA Pro можете да създадете функция на Python и да я извикате в точка на прекъсване и да поставите самата точка на прекъсване в кода, след като напишете стойността 1 на флага зает.

Манипулатор на точка на прекъсване

Първо, нека създадем функция на Python в IDA. Меню Файл - Скрипт команда...

Добавете нов фрагмент в списъка отляво, дайте му име (например BPT),
В текстовото поле вдясно въведете кода на функцията:

def skip_dma():
    print "Skipping wait ws2812..."
    value = Byte(0x200004C4)
    if value == 1:
        PatchDbgByte(0x200004C4, 0)
return False

След това натискаме бягане и затворете прозореца на скрипта.

Сега да преминем към кода на 0x0800688A, задайте точка на прекъсване (клавиш F2), редактирайте я (контекстно меню Редактиране на точката на прекъсване...), не забравяйте да зададете типа скрипт на Python:

Ако текущата стойност на флага зает е равно на 1, тогава трябва да изпълните функцията skip_dma в реда на скрипта:

Ако стартирате фърмуера за изпълнение, можете да видите задействането на кода за обработка на точката на прекъсване в прозореца на IDA Продукция по линия Skipping wait ws2812.... Сега фърмуерът няма да чака флагът да бъде нулиран зает.

Взаимодействие с емулатора

Емулация в името на емулация е малко вероятно да предизвика наслада и радост. Много по-интересно е, ако емулаторът помага на изследователя да види данните в паметта или да установи взаимодействието на нишките.

Ще ви покажем как динамично да установявате взаимодействие между RTOS задачи. Първо трябва да поставите на пауза изпълнението на кода, ако той се изпълнява. Ако отидете на функцията bluetooth_task_entry към клона за обработка на командата „LED“ (адрес 0x080057B8), тогава можете да видите какво първо е създадено и след това изпратено в системната опашка ledControlQueueHandle някакво съобщение.

Трябва да зададете точка на прекъсване за достъп до променливата ledControlQueueHandleнамира се в 0x20000624 и продължете да изпълнявате кода:

В резултат на това спирането първо ще се случи на адрес 0x080057CA преди да извикате функцията osMailAlloc, след което на адрес 0x08005806 преди да извикате функцията osMailPut, след което след малко - на адрес 0x08005BD4 (преди да извикате функцията osMailGet), който принадлежи на функцията leds_task_entry (LED-задача), т.е. задачите се превключиха и сега LED-задачата получи контрол.

По този прост начин можете да установите как RTOS задачите взаимодействат една с друга.

Разбира се, в действителност взаимодействието на задачите може да бъде по-сложно, но с помощта на емулатор проследяването на това взаимодействие става по-малко трудоемко.

Тук Можете да гледате кратко видео на емулатора, който стартира и взаимодейства с IDA Pro.

Стартирайте с Radare2

Не можете да пренебрегнете такъв универсален инструмент като Radare2.

За да се свържете с емулатора с помощта на r2, командата ще изглежда така:

radare2 -A -a arm -b 16 -d gdb://localhost:23946 rhino_fw42k6.elf

Стартирането е налично сега (dc) и пауза на изпълнението (Ctrl+C).

За съжаление, в момента r2 има проблеми при работа с хардуерния gdb сървър и оформлението на паметта; поради това точките на прекъсване и стъпките не работят (команда ds). Надяваме се, че това скоро ще бъде поправено.

Работи с Eclipse

Една от възможностите за използване на емулатора е отстраняване на грешки във фърмуера на разработваното устройство. За по-голяма яснота ще използваме и фърмуера на Rhino. Можете да изтеглите източниците на фърмуера следователно.

Ще използваме Eclipse от комплекта като IDE System Workbench за STM32.

За да може емулаторът да зареди фърмуер, директно компилиран в Eclipse, трябва да добавите параметъра firmware=null към командата за стартиране на емулатора:

binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28

Настройване на конфигурация за отстраняване на грешки

В Eclipse изберете менюто Изпълнение - Отстраняване на грешки в конфигурациите... В прозореца, който се отваря, в секцията GDB хардуерно отстраняване на грешки трябва да добавите нова конфигурация, след което в раздела „Основни“ посочете текущия проект и приложение за отстраняване на грешки:

В раздела „Debugger“ трябва да посочите командата GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

И също така въведете параметрите за свързване към GDB сървъра (хост и порт):

В раздела „Стартиране“ трябва да посочите следните параметри:

активирайте квадратчето за отметка Зареждане на изображението (така че сглобеното изображение на фърмуера да се зареди в емулатора);
активирайте квадратчето за отметка Заредете символи;
добавете команда за стартиране: set $pc = *0x08000004 (задайте компютърния регистър на стойността от паметта на адрес 0x08000004 - адресът се съхранява там ResetHandler).

Моля, обърнете внимание, ако не искате да изтеглите файла на фърмуера от Eclipse, тогава опциите Зареждане на изображението и Изпълнение на команди няма нужда да се посочва.

След като щракнете върху Отстраняване на грешки, можете да работите в режим на отстраняване на грешки:

стъпка по стъпка изпълнение на код
взаимодействие с точки на прекъсване

Внимание. Eclipse има, хм... някои странности... и трябва да живеете с тях. Например, ако при стартиране на дебъгера се появи съобщението „Няма наличен източник за „0x0″“, тогава изпълнете командата Step (F5)

Вместо заключение

Емулирането на естествен код е много интересно нещо. Става възможно разработчик на устройство да отстранява грешки във фърмуера без реално устройство. За един изследовател това е възможност за провеждане на динамичен анализ на кода, което не винаги е възможно дори с устройство.

Искаме да предоставим на специалистите инструмент, който е удобен, умерено прост и не отнема много усилия и време за настройка и работа.

Напишете в коментарите за вашия опит с използването на хардуерни емулатори. Каним ви да обсъдим и ще се радваме да отговорим на въпроси.

В анкетата могат да участват само регистрирани потребители. Впиши се, Моля те.

За какво използвате емулатора?

Разработвам (дебъгвам) фърмуер
Проучвам фърмуера
Пускам игри (Dendi, Sega, PSP)
нещо друго (пишете в коментарите)

7 потребители гласуваха. 2 потребители се въздържаха.

Какъв софтуер използвате за емулиране на естествен код?

QEMU
Еднорог двигател
Proteus
нещо друго (пишете в коментарите)

6 потребители гласуваха. 2 потребители се въздържаха.

Какво бихте искали да подобрите в емулатора, който използвате?

Искам скорост
Искам лесна настройка/стартиране
Искам повече опции за взаимодействие с емулатора (API, куки)
Доволна съм от всичко
нещо друго (пишете в коментарите)

8 потребители гласуваха. 1 потребител се въздържа.

Източник: www.habr.com

Носорог в котка - стартирайте фърмуера в емулатора на Kopycat