Degunradzis kaķī — palaidiet programmaparatūru Kopycat emulatorā

Sapulces ietvaros 0x0A DC7831 DEF CON Nizhny Novgorod 16. februārī prezentējām ziņojumu par binārā koda emulācijas pamatprincipiem un mūsu pašu izstrādi - aparatūras platformas emulatoru Copycat.

Šajā rakstā mēs aprakstīsim, kā emulatorā palaist ierīces programmaparatūru, demonstrēt mijiedarbību ar atkļūdotāju un veikt nelielu programmaparatūras dinamisku analīzi.

Aizvēsture

Sen tālu galaktikā

Pirms pāris gadiem mūsu laboratorijā radās nepieciešamība izpētīt kādas ierīces programmaparatūru. Programmaparatūra tika saspiesta un izpakota ar sāknēšanas ielādētāju. Viņš to izdarīja ļoti sarežģītā veidā, vairākas reizes pārvietojot datus atmiņā. Un pati programmaparatūra pēc tam aktīvi mijiedarbojās ar perifērijas ierīcēm. Un tas viss uz MIPS kodola.

Objektīvu iemeslu dēļ esošie emulatori mums nederēja, bet mēs joprojām gribējām palaist kodu. Tad mēs nolēmām izveidot savu emulatoru, kas darītu minimālu un ļautu mums izpakot galveno programmaparatūru. Mēs to izmēģinājām, un tas strādāja. Mēs domājām, kā būtu, ja pievienotu perifērijas ierīces, lai veiktu arī galveno programmaparatūru. Tas ļoti nesāpēja - un tas arī izdevās. Mēs vēlreiz pārdomājām un nolēmām izveidot pilnvērtīgu emulatoru.

Rezultāts bija datorsistēmu emulators Copycat.

Kāpēc Kopycat?

Notiek vārdu spēle.

1. atdarinājumu (angļu valodā, lietvārds [ˈkɒpɪkæt]) - atdarinātājs, atdarinātājs
2. kaķis (angļu valodā, lietvārds [ˈkæt]) - kaķis, kaķis - mīļākais dzīvnieks vienam no projekta veidotājiem
3. Burts “K” ir no Kotlin programmēšanas valodas

Copycat

Veidojot emulatoru, tika izvirzīti ļoti konkrēti mērķi:

• iespēja ātri izveidot jaunas perifērijas ierīces, moduļus, procesora kodolus;
• iespēja salikt virtuālo ierīci no dažādiem moduļiem;
• iespēja ielādēt jebkādus bināros datus (programmaparatūru) virtuālās ierīces atmiņā;
• prasme strādāt ar momentuzņēmumiem (sistēmas stāvokļa momentuzņēmumiem);
• spēja mijiedarboties ar emulatoru, izmantojot iebūvēto atkļūdotāju;
• jauka mūsdienu valoda attīstībai.

Rezultātā Kotlin tika izvēlēts ieviešanai, kopnes arhitektūra (tas ir, kad moduļi sazinās viens ar otru, izmantojot virtuālās datu kopnes), JSON kā ierīces apraksta formāts un GDB RSP kā protokols mijiedarbībai ar atkļūdotāju.

Attīstība notiek nedaudz vairāk kā divus gadus un aktīvi turpinās. Šajā laikā tika ieviesti MIPS, x86, V850ES, ARM un PowerPC procesoru kodoli.

Projekts aug un ir pienācis laiks ar to iepazīstināt plašāku sabiedrību. Detalizētu projekta aprakstu sniegsim vēlāk, bet pagaidām koncentrēsimies uz Kopycat lietošanu.

Nepacietīgākajiem emulatora reklāmas versiju var lejupielādēt no saite.

Rhino emulatorā

Atgādināsim, ka iepriekš konferencei SMARTRHINO-2018 tika izveidota testa iekārta “Degunradzis” reversās inženierijas prasmju mācīšanai. Statiskās programmaparatūras analīzes process tika aprakstīts Šis raksts.

Tagad mēģināsim pievienot “skaļruņus” un palaist programmaparatūru emulatorā.

Mums ir nepieciešams:
1) Java 1.8
2) Python un modulis Džep lai emulatorā izmantotu Python. Varat izveidot WHL moduli Jep operētājsistēmai Windows lejupielādēt šeit.

Operētājsistēmai Windows:
1) com0com
2) PuTTY

Operētājsistēmai Linux:
1) socat

Kā GDB klientu varat izmantot Eclipse, IDA Pro vai radare2.

Kā tas strādā?

Lai emulatorā veiktu programmaparatūru, ir nepieciešams “samontēt” virtuālo ierīci, kas ir reālas ierīces analogs.

Īsto ierīci ("rhino") var parādīt blokshēmā:

Emulatoram ir modulāra struktūra, un galīgo virtuālo ierīci var aprakstīt JSON failā.

JSON 105 rindas

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

Pievērsiet uzmanību parametram programmaparatūra daļa parametri ir faila nosaukums, ko var ielādēt virtuālajā ierīcē kā programmaparatūru.

Virtuālo ierīci un tās mijiedarbību ar galveno operētājsistēmu var attēlot ar šādu diagrammu:

Pašreizējais emulatora testa gadījums ietver mijiedarbību ar galvenās OS COM portiem (UART un UART atkļūdošana Bluetooth modulim). Tie var būt reāli porti, kuriem ir pievienotas ierīces, vai virtuālie COM porti (šim nolūkam jums vienkārši nepieciešams com0com/socat).

Pašlaik ir divi galvenie veidi, kā mijiedarboties ar emulatoru no ārpuses:

• GDB RSP protokols (attiecīgi rīki, kas atbalsta šo protokolu, ir Eclipse / IDA / radare2);
• iekšējā emulatora komandrinda (Argparse vai Python).

Virtuālie COM porti

Lai mijiedarbotos ar vietējās mašīnas virtuālās ierīces UART, izmantojot termināli, ir jāizveido pāris saistīto virtuālo COM portu. Mūsu gadījumā vienu portu izmanto emulators, bet otro izmanto termināļa programma (PuTTY vai ekrāns):

Izmantojot com0com

Virtuālie COM porti tiek konfigurēti, izmantojot iestatīšanas utilītu no com0com komplekta (konsoles versija - C:Program Files (x86)com0comsetupс.exe, vai GUI versija - C:Program Files (x86)com0comsetupg.exe):

Atzīmējiet izvēles rūtiņas iespējot bufera pārtēriņu visiem izveidotajiem virtuālajiem portiem, pretējā gadījumā emulators gaidīs atbildi no COM porta.

Izmantojot socat

UNIX sistēmās emulators automātiski izveido virtuālos COM portus, izmantojot utilītu socat; lai to izdarītu, vienkārši norādiet prefiksu porta nosaukumā, startējot emulatoru. socat:.

Iekšējais komandrindas interfeiss (Argparse vai Python)

Tā kā Kopycat ir konsoles lietojumprogramma, emulators nodrošina divas komandrindas saskarnes opcijas, lai mijiedarbotos ar tā objektiem un mainīgajiem: Argparse un Python.

Argparse ir CLI, kas iebūvēts Kopycat un vienmēr ir pieejams ikvienam.

Alternatīva CLI ir Python tulks. Lai to izmantotu, jāinstalē Jep Python modulis un jākonfigurē emulators darbam ar Python (tiks izmantots lietotāja galvenajā sistēmā instalētais Python tulks).

Python moduļa Jep instalēšana

Linux sistēmā Jep var instalēt, izmantojot pip:

pip install jep

Lai instalētu Jep operētājsistēmā Windows, vispirms jāinstalē Windows SDK un atbilstošā Microsoft Visual Studio. Mēs esam jums to padarījuši nedaudz vieglāk un WHL būvē JEP pašreizējām Python for Windows versijām, lai moduli varētu instalēt no faila:

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

Lai pārbaudītu Jep instalēšanu, jums ir jāpalaiž komandrindā:

python -c "import jep"

Atbildē ir jāsaņem šāds ziņojums:

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

Jūsu sistēmas emulatora sērijveida failā (copycat.bat - operētājsistēmai Windows, kopēt - Linux) uz parametru sarakstu DEFAULT_JVM_OPTS pievienojiet papildu parametru Djava.library.path — tajā jāietver ceļš uz instalēto Jep moduli.

Windows rezultātam jābūt šādai rindai:

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

Tiek palaists Kopycat

Emulators ir konsoles JVM lietojumprogramma. Palaišana tiek veikta, izmantojot operētājsistēmas komandrindas skriptu (sh/cmd).

Komanda, lai palaistu operētājsistēmā Windows:

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

Komanda, lai palaistu operētājsistēmā Linux, izmantojot socat utilītu:

./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 ports, kas būs atvērts piekļuvei GDB serverim;
• -n rhino — galvenā sistēmas moduļa (samontētās ierīces) nosaukums;
• -l user — bibliotēkas nosaukums, kurā meklēt galveno moduli;
• -y library — ceļš, lai meklētu ierīcē iekļautos moduļus;
• firmwarerhino_pass.bin — ceļš uz programmaparatūras failu;
• COM26 un COM28 ir virtuālie COM porti.

Tā rezultātā tiks parādīta uzvedne Python > (Vai 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 >

Mijiedarbība ar IDA Pro

Lai vienkāršotu testēšanu, mēs izmantojam Rhino programmaparatūru kā avota failu analīzei IDA veidlapā ELF fails (tur tiek glabāta meta informācija).

Varat arī izmantot galveno programmaparatūru bez metainformācijas.

Pēc Kopycat palaišanas programmā IDA Pro izvēlnē Atkļūdotājs dodieties uz vienumu “Pārslēgt atkļūdotāju…"un izvēlieties"Attālais GDB atkļūdotājs". Pēc tam iestatiet savienojumu: izvēlni Atkļūdotājs — procesa opcijas…

Iestatiet vērtības:

• Pielietojums - jebkura vērtība
• Resursdatora nosaukums: 127.0.0.1 (vai tās attālās iekārtas IP adrese, kurā darbojas Kopycat)
• Ports: 23946

Tagad ir pieejama atkļūdošanas poga (taustiņš F9):

Noklikšķiniet uz tā, lai izveidotu savienojumu ar atkļūdotāja moduli emulatorā. IDA pāriet atkļūdošanas režīmā, kļūst pieejami papildu logi: informācija par reģistriem, par steku.

Tagad mēs varam izmantot visas atkļūdotāja standarta funkcijas:

• soli pa solim instrukciju izpilde (Iekāp и Pārkāpt pāri — attiecīgi taustiņi F7 un F8);
• izpildes sākšana un apturēšana;
• izveidojot pārtraukuma punktus gan kodam, gan datiem (taustiņš F2).

Savienojuma izveide ar atkļūdotāju nenozīmē programmaparatūras koda palaišanu. Pašreizējai izpildes pozīcijai ir jābūt adresei 0x08006A74 — funkcijas sākums Reset_Handler. Ritinot sarakstu uz leju, varat redzēt funkcijas izsaukumu galvenais. Kursoru var novietot uz šīs rindas (adrese 0x08006ABE) un veikt operāciju Palaist līdz kursoram (taustiņš F4).

Pēc tam varat nospiest F7, lai ievadītu funkciju galvenais.

Ja palaižat komandu Turpināt procesu (taustiņš F9), tad ar vienu pogu parādīsies logs “Lūdzu, uzgaidiet”. Apturēt:

Nospiežot Apturēt programmaparatūras koda izpilde tiek apturēta, un to var turpināt no tās pašas adreses kodā, kurā tā tika pārtraukta.

Ja turpināsiet izpildīt kodu, termināļos, kas savienoti ar virtuālajiem COM portiem, redzēsit šādas rindas:

“Stāvokļa apiešanas” līnijas klātbūtne norāda, ka virtuālais Bluetooth modulis ir pārslēdzies uz datu saņemšanas režīmu no lietotāja COM porta.

Tagad Bluetooth terminālī (COM29 attēlā) varat ievadīt komandas saskaņā ar Rhino protokolu. Piemēram, komanda “MEOW” atgriezīs virkni “mur-mur” Bluetooth terminālī:

Atdarināt mani ne pilnībā

Veidojot emulatoru, var izvēlēties konkrētas ierīces detalizācijas/emulācijas līmeni. Piemēram, Bluetooth moduli var emulēt dažādos veidos:

• ierīce ir pilnībā emulēta ar pilnu komandu komplektu;
• AT komandas tiek emulētas, un datu plūsma tiek saņemta no galvenās sistēmas COM porta;
• virtuālā ierīce nodrošina pilnīgu datu novirzīšanu uz reālo ierīci;
• kā vienkāršs stubs, kas vienmēr atgriež "OK".

Pašreizējā emulatora versijā tiek izmantota otrā pieeja - virtuālais Bluetooth modulis veic konfigurāciju, pēc kura tas pārslēdzas uz datu “starpniekserverēšanas” režīmu no galvenās sistēmas COM porta uz emulatora UART portu.

Apsvērsim koda vienkāršas instrumentēšanas iespēju gadījumā, ja kāda perifērijas daļa netiek realizēta. Piemēram, ja nav izveidots taimeris, kas atbild par datu pārsūtīšanas kontroli uz DMA (pārbaude tiek veikta funkcijā ws2812b_waitAtrodas 0x08006840), programmaparatūra vienmēr gaidīs karoga atiestatīšanu aizņemtsAtrodas 0x200004C4kas parāda DMA datu līnijas noslogojumu:

Mēs varam apiet šo situāciju, manuāli atiestatot karogu aizņemts uzreiz pēc tā instalēšanas. Programmā IDA Pro varat izveidot Python funkciju un izsaukt to pārtraukuma punktā un ievietot pašu pārtraukuma punktu kodā pēc vērtības 1 ierakstīšanas karogā aizņemts.

Pārtraukuma punktu apstrādātājs

Vispirms izveidosim Python funkciju IDA. Izvēlne Fails — skripta komanda...

Kreisajā pusē esošajā sarakstā pievienojiet jaunu fragmentu, piešķiriet tam nosaukumu (piemēram, BPT),
Teksta laukā labajā pusē ievadiet funkcijas kodu:

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

Pēc tam nospiežam skrējiens un aizveriet skripta logu.

Tagad pāriesim pie koda plkst 0x0800688A, iestatiet pārtraukuma punktu (taustiņš F2), rediģējiet to (konteksta izvēlne Rediģēt pārtraukuma punktu...), neaizmirstiet iestatīt skripta veidu uz Python:

Ja pašreizējā karoga vērtība aizņemts ir vienāds ar 1, tad jums ir jāizpilda funkcija skip_dma skripta rindā:

Ja palaižat programmaparatūru izpildei, pārtraukuma punkta apdarinātāja koda aktivizēšanu var redzēt IDA logā izvade pēc līnijas Skipping wait ws2812.... Tagad programmaparatūra negaidīs karoga atiestatīšanu aizņemts.

Mijiedarbība ar emulatoru

Emulācija emulācijas labad, visticamāk, neradīs sajūsmu un prieku. Daudz interesantāk ir, ja emulators palīdz pētniekam redzēt atmiņā esošos datus vai izveidot pavedienu mijiedarbību.

Mēs parādīsim, kā dinamiski izveidot mijiedarbību starp RTOS uzdevumiem. Vispirms jums vajadzētu apturēt koda izpildi, ja tas darbojas. Ja dodaties uz funkciju bluetooth_task_entry uz komandas “LED” apstrādes filiāli (adrese 0x080057B8), tad varat redzēt, kas vispirms tiek izveidots un pēc tam nosūtīts uz sistēmas rindu ledControlQueueHandle kāda ziņa.

Lai piekļūtu mainīgajam, ir jāiestata pārtraukuma punkts ledControlQueueHandleAtrodas 0x20000624 un turpiniet izpildīt kodu:

Rezultātā apstāšanās vispirms notiks adresē 0x080057CA pirms funkcijas izsaukšanas osMailAlloc, pēc tam uz adresi 0x08005806 pirms funkcijas izsaukšanas osMailPut, tad pēc kāda laika - uz adresi 0x08005BD4 (pirms funkcijas izsaukšanas osMailGet), kas pieder funkcijai leds_task_entry (LED uzdevums), tas ir, uzdevumi tika pārslēgti, un tagad LED uzdevums saņēma kontroli.

Šādā vienkāršā veidā varat noteikt, kā RTOS uzdevumi mijiedarbojas viens ar otru.

Protams, patiesībā uzdevumu mijiedarbība var būt sarežģītāka, taču, izmantojot emulatoru, šīs mijiedarbības izsekošana kļūst mazāk darbietilpīga.

Šeit Varat noskatīties īsu video par emulatora palaišanu un mijiedarbību ar IDA Pro.

Palaidiet ar Radare2

Jūs nevarat ignorēt tik universālu rīku kā Radare2.

Lai izveidotu savienojumu ar emulatoru, izmantojot r2, komanda izskatīsies šādi:

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

Palaišana ir pieejama tagad (dc) un pauzējiet izpildi (Ctrl+C).

Diemžēl šobrīd r2 ir problēmas darbā ar aparatūras gdb serveri un atmiņas izkārtojumu, tāpēc pārtraukuma punkti un soļi nedarbojas (komanda ds). Mēs ceram, ka tas drīz tiks novērsts.

Skriešana ar Eclipse

Viena no emulatora izmantošanas iespējām ir izstrādātās ierīces programmaparatūras atkļūdošana. Skaidrības labad mēs izmantosim arī Rhino programmaparatūru. Varat lejupielādēt programmaparatūras avotus tātad.

Mēs izmantosim Eclipse no komplekta kā IDE Sistēmas darbgalds STM32.

Lai emulators varētu ielādēt programmaparatūru, kas tieši kompilēta Eclipse, jums jāpievieno parametrs firmware=null uz emulatora palaišanas komandu:

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

Atkļūdošanas konfigurācijas iestatīšana

Programmā Eclipse atlasiet izvēlni Palaist — atkļūdot konfigurācijas... Atvērtajā logā sadaļā GDB aparatūras atkļūdošana jums jāpievieno jauna konfigurācija, pēc tam cilnē “Galvenā” norādiet pašreizējo projektu un atkļūdošanas lietojumprogrammu:

Cilnē “Atkļūdotājs” jānorāda komanda GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

Un arī ievadiet parametrus savienojuma izveidei ar GDB serveri (resursdators un ports):

Cilnē “Startēšana” ir jānorāda šādi parametri:

• iespējot izvēles rūtiņu Ielādēt attēlu (lai samontētais programmaparatūras attēls tiktu ielādēts emulatorā);
• iespējot izvēles rūtiņu Ielādēt simbolus;
• pievienot palaišanas komandu: set $pc = *0x08000004 (iestatiet datora reģistrā vērtību no atmiņas adresē 0x08000004 - tur tiek saglabāta adrese ResetHandler).

Обратите внимание, ja nevēlaties lejupielādēt programmaparatūras failu no Eclipse, tad opcijas Ielādēt attēlu и Palaist komandas nav jānorāda.

Pēc noklikšķināšanas uz Atkļūdot varat strādāt atkļūdotāja režīmā:

• soli pa solim koda izpilde
  
• mijiedarbība ar pārtraukuma punktiem
  

Piezīme. Eclipse ir, hmm... daži dīvainības... un ar tām ir jāsadzīvo. Piemēram, ja, startējot atkļūdotāju, tiek parādīts ziņojums “Uz “0x0″ nav pieejams avots”, izpildiet komandu Step (F5).

Tā vietā, lai noslēgtu

Vietējā koda emulēšana ir ļoti interesanta lieta. Ierīces izstrādātājam kļūst iespējams atkļūdot programmaparatūru bez īstas ierīces. Pētniekam tā ir iespēja veikt dinamisku koda analīzi, kas ne vienmēr ir iespējama pat ar ierīci.

Mēs vēlamies nodrošināt speciālistus ar rīku, kas ir ērts, vidēji vienkāršs un neprasa daudz pūļu un laika, lai to iestatītu un palaistu.

Rakstiet komentāros par savu pieredzi, izmantojot aparatūras emulatorus. Aicinām diskutēt un labprāt atbildēsim uz jautājumiem.

Aptaujā var piedalīties tikai reģistrēti lietotāji. Ielogoties, lūdzu.

Kam jūs izmantojat emulatoru?

• Es izstrādāju (atkļūdoju) programmaparatūru

• Es pētīju programmaparatūru

• Es palaistu spēles (Dendi, Sega, PSP)

• kaut kas cits (raksti komentāros)

Nobalsoja 7 lietotāji. 2 lietotāji atturējās.

Kādu programmatūru jūs izmantojat, lai atdarinātu vietējo kodu?

• QEMU

• Unicorn dzinējs

• Proteus

• kaut kas cits (raksti komentāros)

Nobalsoja 6 lietotāji. 2 lietotāji atturējās.

Ko jūs vēlētos uzlabot izmantotajā emulatorā?

• Es gribu ātrumu

• Es vēlos vienkāršāku iestatīšanu/palaišanu

• Es vēlos vairāk iespēju mijiedarboties ar emulatoru (API, āķi)

• Esmu apmierināts ar visu

• kaut kas cits (raksti komentāros)

Nobalsoja 8 lietotāji. 1 lietotājs atturējās.

Avots: www.habr.com