🥇Rhinoceros sa loob ng pusa - ilunsad ang firmware sa Kopycat emulator

Bilang bahagi ng pulong 0x0A DC7831 DEF CON Nizhny Novgorod Noong Pebrero 16, ipinakita namin ang isang ulat sa mga pangunahing prinsipyo ng binary code emulation at ang aming sariling pag-unlad - isang hardware platform emulator copycat.

Sa artikulong ito, ilalarawan namin kung paano patakbuhin ang firmware ng device sa emulator, ipakita ang pakikipag-ugnayan sa debugger, at magsagawa ng maliit na dynamic na pagsusuri ng firmware.

prehistory

Isang mahabang panahon ang nakalipas sa isang kalawakan na malayo

Ilang taon na ang nakalilipas, sa aming laboratoryo ay may pangangailangan na siyasatin ang firmware ng isang device. Ang firmware ay na-compress at na-unpack gamit ang isang bootloader. Ginawa niya ito sa isang napaka-komplikadong paraan, paglilipat ng data sa memorya ng maraming beses. At ang firmware mismo pagkatapos ay aktibong nakipag-ugnayan sa mga peripheral. At lahat ng ito sa MIPS core.

Para sa mga layuning dahilan, hindi nababagay sa amin ang mga available na emulator, ngunit gusto pa rin naming patakbuhin ang code. Pagkatapos ay nagpasya kaming gumawa ng sarili naming emulator, na gagawin ang pinakamababa at pahihintulutan kaming i-unpack ang pangunahing firmware. Sinubukan namin ito at ito ay gumana. Naisip namin, paano kung magdagdag kami ng mga peripheral upang maisagawa din ang pangunahing firmware. Hindi ito masyadong masakit - at naging maayos din. Muli kaming nag-isip at nagpasyang gumawa ng ganap na emulator.

Ang resulta ay isang computer system emulator copycat.

Bakit Kopycat?

May laro sa mga salita.

copycat (Ingles, pangngalan [ˈkɒpɪkæt]) - tagagaya, tagagaya
pusa (Ingles, pangngalan [ˈkæt]) - pusa, pusa - ang paboritong hayop ng isa sa mga lumikha ng proyekto
Ang titik na "K" ay mula sa Kotlin programming language

copycat

Kapag lumilikha ng emulator, itinakda ang mga napakatukoy na layunin:

ang kakayahang mabilis na lumikha ng mga bagong peripheral, module, mga core ng processor;
ang kakayahang mag-ipon ng isang virtual na aparato mula sa iba't ibang mga module;
ang kakayahang mag-load ng anumang binary data (firmware) sa memorya ng isang virtual device;
kakayahang magtrabaho kasama ang mga snapshot (mga snapshot ng estado ng system);
ang kakayahang makipag-ugnayan sa emulator sa pamamagitan ng built-in na debugger;
magandang modernong wika para sa pag-unlad.

Bilang resulta, napili ang Kotlin para sa pagpapatupad, ang arkitektura ng bus (ito ay kapag ang mga module ay nakikipag-ugnayan sa isa't isa sa pamamagitan ng mga virtual data bus), JSON bilang format ng paglalarawan ng device, at GDB RSP bilang protocol para sa pakikipag-ugnayan sa debugger.

Ang pag-unlad ay nangyayari sa loob ng mahigit dalawang taon at aktibong nagpapatuloy. Sa panahong ito, ipinatupad ang mga core ng processor ng MIPS, x86, V850ES, ARM, at PowerPC.

Ang proyekto ay lumalaki at oras na upang ipakita ito sa mas malawak na publiko. Gagawa kami ng isang detalyadong paglalarawan ng proyekto sa ibang pagkakataon, ngunit sa ngayon ay tututukan namin ang paggamit ng Kopycat.

Para sa pinaka naiinip, isang promo na bersyon ng emulator ang maaaring ma-download mula sa link.

Rhino sa emulator

Alalahanin natin na kanina para sa kumperensya ng SMARTHINO-2018, isang pansubok na device na "Rhinoceros" ang nilikha para sa pagtuturo ng mga kasanayan sa reverse engineering. Ang proseso ng static firmware analysis ay inilarawan sa artikulong ito.

Ngayon subukan nating magdagdag ng "mga nagsasalita" at patakbuhin ang firmware sa emulator.

Kailangan namin:
1) Java 1.8
2) Python at module Si Jep upang gamitin ang Python sa loob ng emulator. Maaari kang bumuo ng WHL module na Jep para sa Windows download dito.

Para sa Windows:
1) com0com
2) PuTTY

Para sa Linux:
1) socat

Maaari mong gamitin ang Eclipse, IDA Pro o radare2 bilang GDB client.

Paano ito gumagana?

Upang maisagawa ang firmware sa emulator, kinakailangan na "magtipon" ng isang virtual na aparato, na isang analogue ng isang tunay na aparato.

Ang tunay na device (“rhino”) ay maaaring ipakita sa block diagram:

Ang emulator ay may modular na istraktura at ang panghuling virtual device ay maaaring ilarawan sa isang JSON file.

JSON 105 na linya

{
  "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"]
  ]
}

Bigyang-pansin ang parameter firmware seksyon param ay ang pangalan ng isang file na maaaring i-load sa isang virtual device bilang firmware.

Ang virtual na aparato at ang pakikipag-ugnayan nito sa pangunahing operating system ay maaaring katawanin ng sumusunod na diagram:

Ang kasalukuyang pagsubok na instance ng emulator ay nagsasangkot ng pakikipag-ugnayan sa mga COM port ng pangunahing OS (debug UART at UART para sa Bluetooth module). Ang mga ito ay maaaring tunay na mga port kung saan nakakonekta ang mga device o mga virtual na COM port (para dito kailangan mo lang com0com/socat).

Upang makipag-ugnayan sa emulator mula sa labas, kasalukuyang may dalawang pangunahing paraan:

GDB RSP protocol (ayon dito, ang mga tool na sumusuporta sa protocol na ito ay Eclipse / IDA / radare2);
panloob na linya ng utos ng emulator (Argparse o Python).

Mga virtual COM port

Upang makipag-ugnayan sa UART ng isang virtual device sa lokal na makina sa pamamagitan ng isang terminal, kailangan mong lumikha ng isang pares ng nauugnay na mga virtual COM port. Sa aming kaso, ang isang port ay ginagamit ng emulator, at ang pangalawa ay ginagamit ng isang terminal program (PuTTY o screen):

Gamit ang com0com

Ang mga virtual COM port ay na-configure gamit ang setup utility mula sa com0com kit (console version - C:Program Files (x86)com0comsetupс.exe, o bersyon ng GUI - C:Program Files (x86)com0comsetupg.exe):

Lagyan ng tsek ang mga kahon paganahin ang buffer overrun para sa lahat ng nilikhang virtual port, kung hindi, ang emulator ay maghihintay ng tugon mula sa COM port.

Gamit ang socat

Sa mga sistema ng UNIX, ang mga virtual COM port ay awtomatikong nilikha ng emulator gamit ang socat utility; upang gawin ito, tukuyin lamang ang prefix sa pangalan ng port kapag sinimulan ang emulator socat:.

Interface ng panloob na command line (Argparse o Python)

Dahil ang Kopycat ay isang console application, ang emulator ay nagbibigay ng dalawang command line interface na opsyon para sa pakikipag-ugnayan sa mga object at variable nito: Argparse at Python.

Ang Argparse ay isang CLI na binuo sa Kopycat at palaging magagamit sa lahat.

Ang isang alternatibong CLI ay ang Python interpreter. Upang magamit ito, kailangan mong i-install ang Jep Python module at i-configure ang emulator upang gumana sa Python (ang Python interpreter na naka-install sa pangunahing system ng user ay gagamitin).

Pag-install ng Python module na Jep

Sa ilalim ng Linux Jep ay maaaring mai-install sa pamamagitan ng pip:

pip install jep

Upang i-install ang Jep sa Windows, kailangan mo munang i-install ang Windows SDK at ang kaukulang Microsoft Visual Studio. Medyo pinadali namin ito para sa iyo at Bumubuo ang WHL JEP para sa kasalukuyang mga bersyon ng Python para sa Windows, upang mai-install ang module mula sa file:

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

Upang suriin ang pag-install ng Jep, kailangan mong tumakbo sa command line:

python -c "import jep"

Ang sumusunod na mensahe ay dapat matanggap bilang tugon:

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

Sa emulator batch file para sa iyong system (copycat.bat - para sa Windows, copycat - para sa Linux) sa listahan ng mga parameter DEFAULT_JVM_OPTS magdagdag ng karagdagang parameter Djava.library.path — dapat itong maglaman ng landas patungo sa naka-install na Jep module.

Ang resulta para sa Windows ay dapat na isang linya tulad nito:

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

Inilunsad ang Kopycat

Ang emulator ay isang console JVM application. Ang paglunsad ay isinasagawa sa pamamagitan ng script ng command line ng operating system (sh/cmd).

Command na tumakbo sa ilalim ng Windows:

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

Command na tumakbo sa ilalim ng Linux gamit ang socat utility:

./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 port na magbubukas para sa pag-access sa GDB server;
-n rhino — pangalan ng pangunahing module ng system (naka-assemble na aparato);
-l user — pangalan ng aklatan upang maghanap para sa pangunahing module;
-y library — landas para maghanap ng mga module na kasama sa device;
firmwarerhino_pass.bin — landas sa firmware file;
Ang COM26 at COM28 ay mga virtual na COM port.

Bilang resulta, isang prompt ang ipapakita Python > (O 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 >

Pakikipag-ugnayan sa IDA Pro

Upang gawing simple ang pagsubok, ginagamit namin ang Rhino firmware bilang source file para sa pagsusuri sa IDA sa form ELF file (naka-imbak doon ang impormasyon ng meta).

Maaari mo ring gamitin ang pangunahing firmware nang walang impormasyon sa meta.

Pagkatapos ilunsad ang Kopycat sa IDA Pro, sa Debugger menu pumunta sa item na "Lumipat ng debugger..."at piliin"Remote GDB debugger". Susunod, i-set up ang koneksyon: menu Debugger - Mga opsyon sa proseso...

Itakda ang mga halaga:

Application - anumang halaga
Hostname: 127.0.0.1 (o ang IP address ng remote machine kung saan tumatakbo ang Kopycat)
Port: 23946

Ngayon ay magagamit na ang pindutan ng pag-debug (F9 key):

I-click ito para kumonekta sa debugger module sa emulator. Ang IDA ay napupunta sa debugging mode, ang mga karagdagang window ay magagamit: impormasyon tungkol sa mga rehistro, tungkol sa stack.

Ngayon ay magagamit na natin ang lahat ng karaniwang feature ng debugger:

hakbang-hakbang na pagpapatupad ng mga tagubilin (Hakbang sa и Tumabi ka — mga key F7 at F8, ayon sa pagkakabanggit);
pagsisimula at paghinto ng pagpapatupad;
paggawa ng mga breakpoint para sa parehong code at data (F2 key).

Ang pagkonekta sa isang debugger ay hindi nangangahulugan ng pagpapatakbo ng firmware code. Ang kasalukuyang posisyon ng pagpapatupad ay dapat ang address 0x08006A74 - simula ng pag-andar I-reset ang_Handler. Kung mag-scroll ka pababa sa listahan, makikita mo ang function na tawag pangunahin. Maaari mong ilagay ang cursor sa linyang ito (address 0x08006ABE) at gawin ang operasyon Patakbuhin hanggang sa cursor (key F4).

Susunod, maaari mong pindutin ang F7 upang ipasok ang function pangunahin.

Kung patakbuhin mo ang utos Ipagpatuloy ang proseso (F9 key), pagkatapos ay lilitaw ang window na "Mangyaring maghintay" na may isang pindutan suspindihin:

Kapag pinindot mo suspindihin Ang pagpapatupad ng firmware code ay nasuspinde at maaaring ipagpatuloy mula sa parehong address sa code kung saan ito naantala.

Kung patuloy mong ipapatupad ang code, makikita mo ang mga sumusunod na linya sa mga terminal na konektado sa mga virtual COM port:

Ang pagkakaroon ng linya ng "state bypass" ay nagpapahiwatig na ang virtual na Bluetooth module ay lumipat sa mode ng pagtanggap ng data mula sa COM port ng user.

Ngayon sa Bluetooth terminal (COM29 sa larawan) maaari kang magpasok ng mga command alinsunod sa Rhino protocol. Halimbawa, ibabalik ng command na "MEOW" ang string na "mur-mur" sa Bluetooth terminal:

Tularan mo ako hindi lubusan

Kapag gumagawa ng emulator, maaari mong piliin ang antas ng detalye/emulasyon ng isang partikular na device. Halimbawa, ang Bluetooth module ay maaaring tularan sa iba't ibang paraan:

ang aparato ay ganap na ginagaya sa isang buong hanay ng mga utos;
Ang mga utos ng AT ay ginagaya, at ang data stream ay natanggap mula sa COM port ng pangunahing sistema;
ang virtual na aparato ay nagbibigay ng kumpletong pag-redirect ng data sa tunay na aparato;
bilang isang simpleng stub na palaging nagbabalik ng "OK".

Ang kasalukuyang bersyon ng emulator ay gumagamit ng pangalawang diskarte - ang virtual na Bluetooth module ay nagsasagawa ng pagsasaayos, pagkatapos nito ay lumipat sa mode ng "proxying" na data mula sa COM port ng pangunahing system hanggang sa UART port ng emulator.

Isaalang-alang natin ang posibilidad ng simpleng instrumentation ng code kung sakaling hindi maipatupad ang ilang bahagi ng periphery. Halimbawa, kung ang isang timer na responsable para sa pagkontrol sa paglipat ng data sa DMA ay hindi pa nagagawa (ang pagsusuri ay isinasagawa sa function ws2812b_waitmatatagpuan sa 0x08006840), pagkatapos ay palaging maghihintay ang firmware para sa pag-reset ng flag abalamatatagpuan sa 0x200004C4na nagpapakita ng occupancy ng DMA data line:

Malalampasan natin ang sitwasyong ito sa pamamagitan ng manu-manong pag-reset ng bandila abala kaagad pagkatapos i-install ito. Sa IDA Pro, maaari kang lumikha ng Python function at tawagan ito sa isang breakpoint, at ilagay ang breakpoint mismo sa code pagkatapos isulat ang value 1 sa flag abala.

Handler ng breakpoint

Una, gumawa tayo ng Python function sa IDA. Menu File - Script command...

Magdagdag ng bagong snippet sa listahan sa kaliwa, bigyan ito ng pangalan (halimbawa, BPT),
Sa field ng text sa kanan, ilagay ang function code:

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

After that we press Tumakbo at isara ang script window.

Ngayon, pumunta tayo sa code sa 0x0800688A, magtakda ng breakpoint (F2 key), i-edit ito (context menu I-edit ang breakpoint...), huwag kalimutang itakda ang uri ng script sa Python:

Kung ang kasalukuyang halaga ng bandila abala katumbas ng 1, pagkatapos ay dapat mong isagawa ang function skip_dma sa linya ng script:

Kung pinapatakbo mo ang firmware para sa pagpapatupad, ang pag-trigger ng breakpoint handler code ay makikita sa IDA window Pagbubuhos sa pamamagitan ng linya Skipping wait ws2812.... Ngayon ang firmware ay hindi maghihintay para sa pag-reset ng bandila abala.

Pakikipag-ugnayan sa emulator

Ang pagtulad para sa kapakanan ng pagtulad ay malamang na hindi magdulot ng kasiyahan at kagalakan. Mas kawili-wili kung tinutulungan ng emulator ang mananaliksik na makita ang data sa memorya o maitatag ang pakikipag-ugnayan ng mga thread.

Ipapakita namin sa iyo kung paano dynamic na magtatag ng pakikipag-ugnayan sa pagitan ng mga gawain sa RTOS. Dapat mo munang i-pause ang execution ng code kung ito ay tumatakbo. Kung pupunta ka sa function bluetooth_task_entry sa processing branch ng "LED" command (address 0x080057B8), pagkatapos ay makikita mo kung ano ang unang nilikha at pagkatapos ay ipinadala sa queue ng system ledControlQueueHandle ilang mensahe.

Dapat kang magtakda ng breakpoint para ma-access ang variable ledControlQueueHandlematatagpuan sa 0x20000624 at ipagpatuloy ang pagpapatupad ng code:

Bilang resulta, ang paghinto ay unang magaganap sa address 0x080057CA bago tawagan ang function osMailAlloc, pagkatapos ay sa address 0x08005806 bago tawagan ang function osMailPut, pagkatapos ng ilang sandali - sa address 0x08005BD4 (bago tawagan ang function osMailGet), na kabilang sa function leds_task_entry (LED-task), iyon ay, ang mga gawain ay lumipat, at ngayon ang LED-task ay nakatanggap ng kontrol.

Sa simpleng paraan na ito, maitatag mo kung paano nakikipag-ugnayan ang mga gawain sa RTOS sa isa't isa.

Siyempre, sa katotohanan, ang pakikipag-ugnayan ng mga gawain ay maaaring maging mas kumplikado, ngunit gamit ang isang emulator, ang pagsubaybay sa pakikipag-ugnayan na ito ay nagiging hindi gaanong matrabaho.

Dito Maaari kang manood ng maikling video ng paglulunsad at pakikipag-ugnayan ng emulator sa IDA Pro.

Ilunsad sa Radare2

Hindi mo maaaring balewalain ang isang unibersal na tool tulad ng Radare2.

Upang kumonekta sa emulator gamit ang r2, ang utos ay magiging ganito:

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

Available na ang paglulunsad (dc) at i-pause ang pagpapatupad (Ctrl+C).

Sa kasamaang palad, sa ngayon, ang r2 ay may mga problema kapag nagtatrabaho sa hardware gdb server at memory layout; dahil dito, ang mga breakpoint at Steps ay hindi gumagana (utos ds). Umaasa kami na ito ay maayos sa lalong madaling panahon.

Tumatakbo kasama ang Eclipse

Ang isa sa mga opsyon para sa paggamit ng emulator ay ang pag-debug ng firmware ng device na binuo. Para sa kalinawan, gagamitin din namin ang Rhino firmware. Maaari mong i-download ang mga mapagkukunan ng firmware kaya.

Gagamitin namin ang Eclipse mula sa set bilang isang IDE System Workbench para sa STM32.

Upang mai-load ng emulator ang firmware na direktang pinagsama sa Eclipse, kailangan mong idagdag ang parameter firmware=null sa emulator launch command:

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

Pagse-set up ng configuration ng debug

Sa Eclipse, piliin ang menu Run - Mga Configuration ng Debug... Sa window na bubukas, sa seksyon GDB Hardware Debugging kailangan mong magdagdag ng bagong configuration, pagkatapos ay sa tab na "Main" tukuyin ang kasalukuyang proyekto at application para sa pag-debug:

Sa tab na "Debugger" kailangan mong tukuyin ang utos ng GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

At ipasok din ang mga parameter para sa pagkonekta sa GDB server (host at port):

Sa tab na "Startup", dapat mong tukuyin ang mga sumusunod na parameter:

paganahin ang checkbox Mag-load ng larawan (upang ang naka-assemble na imahe ng firmware ay na-load sa emulator);
paganahin ang checkbox Mag-load ng mga simbolo;
magdagdag ng utos ng paglunsad: set $pc = *0x08000004 (itakda ang rehistro ng PC sa halaga mula sa memorya sa address 0x08000004 - ang address ay naka-imbak doon I-reset angHandler).

Magbayad ng pansin, kung ayaw mong i-download ang firmware file mula sa Eclipse, pagkatapos ay ang mga opsyon Mag-load ng larawan и Patakbuhin ang mga utos hindi na kailangang ipahiwatig.

Pagkatapos i-click ang Debug, maaari kang magtrabaho sa debugger mode:

hakbang-hakbang na pagpapatupad ng code
nakikipag-ugnayan sa mga breakpoint

Nota. Ang Eclipse ay may, hmm... ilang quirks... at kailangan mong mamuhay kasama sila. Halimbawa, kung kapag sinimulan ang debugger ang mensaheng "Walang available na mapagkukunan para sa "0x0″" ay lilitaw, pagkatapos ay isagawa ang Step command (F5)

Sa halip ng isang konklusyon

Ang pagtulad sa katutubong code ay isang napaka-kagiliw-giliw na bagay. Nagiging posible para sa isang developer ng device na i-debug ang firmware nang walang tunay na device. Para sa isang mananaliksik, ito ay isang pagkakataon upang magsagawa ng dynamic na pagsusuri ng code, na hindi palaging posible kahit na may isang aparato.

Gusto naming magbigay sa mga espesyalista ng isang tool na maginhawa, katamtamang simple at hindi nangangailangan ng maraming pagsisikap at oras upang mag-set up at tumakbo.

Sumulat sa mga komento tungkol sa iyong karanasan sa paggamit ng mga emulator ng hardware. Inaanyayahan ka naming talakayin at ikalulugod naming sagutin ang mga tanong.

Ang mga rehistradong user lamang ang maaaring lumahok sa survey. Mag-sign in, pakiusap

Para saan mo ginagamit ang emulator?

Bumubuo ako ng (debug) firmware
Nagre-research ako ng firmware
Naglulunsad ako ng mga laro (Dendi, Sega, PSP)
iba pa (sumulat sa mga komento)

7 mga gumagamit ang bumoto. 2 user ang umiwas.

Anong software ang ginagamit mo para tularan ang native code?

QEMU
Unicorn engine
Proteyus
iba pa (sumulat sa mga komento)

6 mga gumagamit ang bumoto. 2 user ang umiwas.

Ano ang gusto mong pagbutihin sa emulator na iyong ginagamit?

Gusto ko ng bilis
Gusto ko ng kadalian ng pag-setup/paglunsad
Gusto ko ng higit pang mga opsyon para sa pakikipag-ugnayan sa emulator (API, mga kawit)
Masaya ako sa lahat
iba pa (sumulat sa mga komento)

8 na user ang bumoto. 1 user ang umiwas.

Pinagmulan: www.habr.com

Rhinoceros sa loob ng pusa - patakbuhin ang firmware sa Kopycat emulator