Rhinoceros bannent enger Kaz - lafen d'Firmware am Kopycat Emulator

Am Kader vun der Versammlung 0x0A DC7831 DEF CON Nizhny Novgorod De 16. Februar hu mir e Bericht iwwer d'Basisprinzipien vun der binärer Code-Emulatioun an eiser eegener Entwécklung presentéiert - e Hardware Plattform Emulator Copycat.

An dësem Artikel wäerte mir beschreiwen wéi d'Apparat Firmware am Emulator lafen, Interaktioun mam Debugger demonstréieren an eng kleng dynamesch Analyse vun der Firmware maachen.

Virgeschicht

Viru laanger Zäit an enger Galaxis wäit wäit ewech

Virun e puer Joer an eisem Labo war et néideg d'Firmware vun engem Apparat z'ënnersichen. D'Firmware gouf kompriméiert an ausgepackt mat engem Bootloader. Hien huet dat op eng ganz komplizéiert Manéier gemaach, d'Donnéeën an der Erënnerung e puer Mol verréckelt. An d'Firmware selwer huet dunn aktiv mat de Peripherieger interagéiert. An dat alles um MIPS Kär.

Aus objektive Grënn hunn déi verfügbar Emulatoren eis net gepasst, awer mir wollten nach ëmmer de Code lafen. Duerno hu mir décidéiert eisen eegene Emulator ze maachen, deen de Minimum géif maachen an eis erlaabt d'Haaptfirmware auszepaken. Mir hunn et probéiert an et huet geschafft. Mir hu geduecht, wat wa mir Peripherieger addéieren fir och d'Haaptfirmware auszeféieren. Et huet net vill schueden - an et huet och geklappt. Mir hunn nach eng Kéier geduecht an decidéiert e vollwäertege Emulator ze maachen.

D'Resultat war e Computersystememulator Copycat.

Firwat Kopycat?

Et gëtt e Wierderspill.

1. Kopie (Englesch, Substantiv [ˈkɒpɪkæt]) - imitator, imitator
2. cat (Englesch, Substantiv [ˈkæt]) - Kaz, Kaz - dat Liiblingsdéier vun engem vun de Créateure vum Projet
3. De Bréif "K" ass aus der Kotlin Programmiersprache

Copycat

Wann Dir den Emulator erstellt, goufen ganz spezifesch Ziler gesat:

• d'Fäegkeet fir séier nei Peripherieger, Moduler, Prozessorkären ze kreéieren;
• d'Fäegkeet fir e virtuellen Apparat aus verschiddene Moduler ze sammelen;
• d'Fäegkeet fir binär Daten (Firmware) an d'Erënnerung vun engem virtuellen Apparat ze lueden;
• Fäegkeet fir mat Snapshots ze schaffen (Snapshots vum Systemzoustand);
• d'Fäegkeet fir mam Emulator duerch den agebaute Debugger ze interagéieren;
• flott modern Sprooch fir Entwécklung.

Als Resultat gouf Kotlin fir d'Ëmsetzung gewielt, d'Busarchitektur (dëst ass wann Moduler mateneen iwwer virtuell Datebussen kommunizéieren), JSON als Apparatbeschreiwungsformat, an GDB RSP als Protokoll fir Interaktioun mam Debugger.

Entwécklung ass fir e bësse méi wéi zwee Joer lass an ass aktiv weider. Wärend dëser Zäit goufen MIPS, x86, V850ES, ARM, a PowerPC Prozessor Cores implementéiert.

De Projet wiisst an et ass Zäit en dem grousse Public ze presentéieren. Mir wäerte spéider eng detailléiert Beschreiwung vum Projet maachen, awer fir de Moment konzentréiere mir eis op d'Benotzung vun Kopycat.

Fir déi ongedëllegst, kann eng Promo Versioun vum Emulator erofgeluede ginn Link.

Rhino am Emulator

Loosst eis drun erënneren datt virdru fir d'SMARTRHINO-2018 Konferenz en Testapparat "Rhinoceros" erstallt gouf fir Reverse Engineering Kompetenzen ze léieren. De Prozess vun der statesch Firmware Analyse gouf beschriwwen an dësen Artikel.

Loosst eis elo probéieren "Spriecher" ze addéieren an d'Firmware am Emulator auszeféieren.

Mir brauchen:
1) Java 1.8
2) Python a Modul jep fir Python am Emulator ze benotzen. Dir kënnt de WHL Modul Jep fir Windows bauen download hei.

Fir Windows:
1) com0com
2) putty

Fir Linux:
1) souz

Dir kënnt Eclipse, IDA Pro oder radare2 als GDB Client benotzen.

Wéi heescht et schaffen?

Fir Firmware am Emulator auszeféieren, ass et néideg e virtuellen Apparat ze "sammelen", deen en Analog vun engem richtegen Apparat ass.

De richtegen Apparat ("Rhino") kann am Blockdiagramm ugewise ginn:

Den Emulator huet eng modulär Struktur an de finalen virtuellen Apparat kann an enger JSON Datei beschriwwe ginn.

JSON 105 Linnen

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

Opgepasst op de Parameter Firmware Sektioun params ass den Numm vun enger Datei déi als Firmware an e virtuellen Apparat gelueden ka ginn.

De virtuellen Apparat a seng Interaktioun mam Haaptbetribssystem kann duerch folgend Diagramm vertruede ginn:

Déi aktuell Testinstanz vum Emulator beinhalt d'Interaktioun mat den COM Ports vum Haapt OS (debug UART an UART fir de Bluetooth Modul). Dëst kënne real Ports sinn, mat deenen Apparater verbonne sinn oder virtuell COM Ports (fir dëst braucht Dir just com0com/socat).

Et ginn de Moment zwee Haapt Weeër fir mam Emulator vu baussen ze interagéieren:

• GDB RSP Protokoll (deemno, d'Tools déi dëse Protokoll ënnerstëtzen sinn Eclipse / IDA / radare2);
• intern Emulator Kommandozeil (Argparse oder Python).

Virtuell COM Häfen

Fir mat der UART vun engem virtuellen Apparat op der lokaler Maschinn iwwer e Terminal ze interagéieren, musst Dir e Paar assoziéiert virtuell COM Ports erstellen. An eisem Fall gëtt een Hafen vum Emulator benotzt, an deen zweeten vun engem Terminalprogramm (PuTTY oder Écran):

Benotzt com0com

Virtuell COM Ports gi konfiguréiert mat dem Setup Utility vum com0com Kit (Konsol Versioun - C:Programmdateien (x86)com0comsetupс.exe, oder GUI Versioun - C:Programmdateien (x86)com0comsetupg.exe):

Kontrolléiert d'Këschten aktivéiert Puffer Iwwerlaf fir all erstallt virtuell Häfen, soss wäert d'Emulator op eng Äntwert vum COM Hafen waarden.

Socat benotzt

Op UNIX Systemer ginn virtuell COM Ports automatesch vum Emulator erstallt mat dem socat Utility fir dëst ze maachen, gitt just de Präfix am Hafennumm beim Start vum Emulator socat:.

Intern Kommandozeil Interface (Argparse oder Python)

Zënter Kopycat ass eng Konsolapplikatioun, bitt den Emulator zwee Kommandozeil-Interface-Optiounen fir mat sengen Objeten a Variablen ze interagéieren: Argparse a Python.

Argparse ass e CLI a Kopycat gebaut an ass ëmmer fir jiddereen verfügbar.

Eng alternativ CLI ass de Python Dolmetscher. Fir et ze benotzen, musst Dir de Jep Python Modul installéieren an den Emulator konfiguréieren fir mat Python ze schaffen (de Python Dolmetscher, deen um Haaptsystem vum Benotzer installéiert ass, gëtt benotzt).

Installatioun vum Python Modul Jep

Ënner Linux kann Jep iwwer Pip installéiert ginn:

pip install jep

Fir Jep op Windows z'installéieren, musst Dir als éischt d'Windows SDK an den entspriechende Microsoft Visual Studio installéieren. Mir hunn et e bësse méi einfach fir Iech gemaach an WHL baut JEP fir aktuell Versioune vu Python fir Windows, sou datt de Modul aus der Datei installéiert ka ginn:

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

Fir d'Installatioun vu Jep z'iwwerpréiwen, musst Dir op der Kommandozeil lafen:

python -c "import jep"

De folgende Message soll als Äntwert kritt ginn:

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

An der Emulator Batchdatei fir Äre System (copycat.bat - fir Windows, copycat - fir Linux) op d'Lëscht vun de Parameteren DEFAULT_JVM_OPTS addéiere en zousätzleche Parameter Djava.library.path - et muss de Wee zum installéierten Jep Modul enthalen.

D'Resultat fir Windows soll eng Linn wéi dës sinn:

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

Start Kopycat

Den Emulator ass eng Konsol JVM Applikatioun. De Start gëtt duerch de Betribssystem Kommandozeil Skript (sh/cmd) duerchgefouert.

Kommando fir ënner Windows ze lafen:

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

Kommando fir ënner Linux ze lafen mam 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 Hafen dee fir Zougang zum GDB Server op ass;
• -n rhino - Numm vum Haaptsystem Modul (gesammelt Apparat);
• -l user - Numm vun der Bibliothéik fir den Haaptmodul ze sichen;
• -y library - Wee fir no Moduler ze sichen déi am Apparat abegraff sinn;
• firmwarerhino_pass.bin - Wee fir d'Firmware Datei;
• COM26 an COM28 sinn virtuell COM Häfen.

Als Resultat gëtt eng Prompt ugewisen Python > (oder 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 >

Interaktioun mat IDA Pro

Fir Testen ze vereinfachen, benotze mir d'Rhino Firmware als Quelldatei fir Analyse an IDA an der Form ELF Datei (Meta Informatioun gëtt do gespäichert).

Dir kënnt och d'Haaptfirmware ouni Meta Informatioun benotzen.

Nodeems Dir Kopycat an IDA Pro lancéiert hutt, gitt am Debugger Menu op den Artikel "Debugger wiesselen…"a wielt"Remote GDB Debugger". Als nächst setzt d'Verbindung op: Menü Debugger - Prozessoptiounen ...

Setzt d'Wäerter:

• Applikatioun - all Wäert
• Hostnumm: 127.0.0.1 (oder d'IP Adress vun der Fernmaschinn wou Kopycat leeft)
• Port: 23946

Elo gëtt den Debugging Knäppchen verfügbar (F9 Schlëssel):

Klickt et fir mam Debuggermodul am Emulator ze verbannen. IDA geet an Debugging Modus, zousätzlech Fënstere ginn verfügbar: Informatioun iwwer Registere, iwwer de Stack.

Elo kënne mir all Standardfeatures vum Debugger benotzen:

• Schrëtt fir Schrëtt Ausféierung vun Instruktiounen (Stuf an и Schrëtt iwwer - Schlësselen F7 an F8, respektiv);
• Start an Paus vun der Ausféierung;
• Schafen breakpoints fir souwuel Code an Donnéeën (F2 Schlëssel).

Verbindung mat engem Debugger heescht net de Firmware Code lafen. Déi aktuell Ausféierungspositioun muss d'Adress sinn 0x08006A74 - Start vun der Funktioun Reset_Handler. Wann Dir d'Lëscht erof scrollt, kënnt Dir de Funktiounsruff gesinn Haaptstrooss. Dir kënnt de Cursor op dëser Linn setzen (Adress 0x08006ABE) an d'Operatioun ausféieren Run bis Cursor (Schlëssel F4).

Als nächst kënnt Dir op F7 drécken fir d'Funktioun anzeginn Haaptstrooss.

Wann Dir de Kommando leeft Prozess weider (F9 Schlëssel), da erschéngt d'"W.e.g. waart" Fënster mat engem eenzege Knäppchen Suspend:

Wann Dir dréckt Suspend D'Ausféierung vum Firmwarecode gëtt suspendéiert a kann vun der selwechter Adress am Code weidergefouert ginn, wou se ënnerbrach gouf.

Wann Dir weider de Code ausféiert, gesitt Dir déi folgend Zeilen an den Terminals verbonne mat de virtuelle COM Ports:

D'Präsenz vun der Linn "Staat Contournement" weist datt de virtuelle Bluetooth Modul op de Modus gewiesselt ass fir Daten aus dem COM Hafen vum Benotzer ze kréien.

Elo am Bluetooth-Terminal (COM29 am Bild) kënnt Dir Kommandoen am Aklang mat dem Rhino-Protokoll aginn. Zum Beispill gëtt de Kommando "MEOW" d'String "mur-mur" op de Bluetooth-Terminal zréck:

Emuléiert mech net ganz

Wann Dir en Emulator baut, kënnt Dir den Niveau vum Detail / Emulatioun vun engem bestëmmten Apparat wielen. Zum Beispill kann de Bluetooth Modul op verschidde Weeër emuléiert ginn:

• den Apparat gëtt voll emuléiert mat engem komplette Set vu Kommandoen;
• AT Kommandoen ginn emuléiert, an den Datestroum gëtt vum COM Hafen vum Haaptsystem kritt;
• de virtuelle Gerät liwwert eng komplett Dateviruleedung zum realen Apparat;
• als einfache Stéck deen ëmmer "OK" zréckkënnt.

Déi aktuell Versioun vum Emulator benotzt déi zweet Approche - de virtuelle Bluetooth Modul mécht d'Konfiguratioun aus, duerno wiesselt et op de Modus vun "Proxying" Daten vum COM Hafen vum Haaptsystem an den UART Hafen vum Emulator.

Loosst eis d'Méiglechkeet vun der einfacher Instrumentatioun vum Code betruechten am Fall wou en Deel vun der Peripherie net ëmgesat gëtt. Zum Beispill, wann en Timer verantwortlech fir d'Kontroll vun den Datenübertragung op DMA net erstallt gouf (de Scheck gëtt an der Funktioun duerchgefouert ws2812b_waitläit um 0x08006840), da wäert d'Firmware ëmmer waarden bis de Fändel zréckgesat gëtt beschäftegtläit um 0x200004C4déi d'Besetzung vun der DMA Datenlinn weist:

Mir kënnen dës Situatioun ëmgoen andeems mir de Fändel manuell zrécksetzen beschäftegt direkt no der Installatioun. An IDA Pro kënnt Dir eng Python Funktioun erstellen an et an engem Breakpoint nennen, an den Breakpoint selwer an de Code setzen nodeems Dir de Wäert 1 op de Fändel schreift beschäftegt.

Breakpoint Handler

Als éischt, loosst eis eng Python Funktioun an IDA erstellen. Menu Datei - Skript Kommando ...

Füügt en neien Ausschnëtt an der Lëscht lénks, gitt et en Numm (zum Beispill, CPM),
Am Textfeld op der rietser Säit gitt de Funktiounscode:

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

Duerno klickt op Run an d'Skriptfenster zoumaachen.

Loosst eis elo op de Code goen 0x0800688A, Setzt en Breakpunkt (F2 Schlëssel), editéiert et (Kontextmenü Breakpunkt änneren...), Vergiesst net de Skripttyp op Python ze setzen:

Wann déi aktuell Fändel Wäert beschäftegt entsprécht 1, da sollt Dir d'Funktioun ausféieren skip_dma an der Skript Linn:

Wann Dir d'Firmware fir d'Ausféierung leeft, kënnt Dir d'Ausléisung vum Breakpoint Handler Code an der IDA Fënster gesinn Däischterheet duerch Linn Skipping wait ws2812.... Elo wäert d'Firmware net waarden bis de Fändel zréckgesat gëtt beschäftegt.

Interaktioun mam Emulator

Emulatioun fir d'Emuléierung ass onwahrscheinlech fir Freed a Freed ze verursaachen. Et ass vill méi interessant wann den Emulator de Fuerscher hëlleft d'Donnéeën an der Erënnerung ze gesinn oder d'Interaktioun vu Threads z'etabléieren.

Mir weisen Iech wéi Dir dynamesch Interaktioun tëscht RTOS Aufgaben etabléiert. Dir sollt als éischt d'Ausféierung vum Code pausen wann et leeft. Wann Dir op d'Funktioun gitt bluetooth_task_entry an d'Veraarbechtungszweige vum Kommando "LED" (Adress 0x080057B8), da kënnt Dir gesinn wat als éischt erstallt gëtt an dann an d'Systemschlaang geschéckt gëtt ledControlQueueHandle puer Message.

Dir sollt e Breakpoint setzen fir op d'Variabel ze kommen ledControlQueueHandleläit um 0x20000624 a weider de Code ausféieren:

Als Resultat gëtt de Stop fir d'éischt op Adress geschéien 0x080057CA ier Dir d'Funktioun rufft osMailAlloc, dann op der Adress 0x08005806 ier Dir d'Funktioun rufft osMailPut, dann no enger Zäit - op d'Adress 0x08005BD4 (ier Dir d'Funktioun urufft osMailGet), déi zu der Funktioun gehéiert leds_task_entry (LED-Aufgab), dat heescht, d'Aufgaben gewiesselt, an elo krut d'LED-Aufgab Kontroll.

Op dës einfach Manéier kënnt Dir feststellen wéi RTOS Aufgaben matenee interagéieren.

Natierlech, a Wierklechkeet, kann d'Interaktioun vun Aufgaben méi komplizéiert sinn, awer mat engem Emulator, d'Verfollegung vun dëser Interaktioun gëtt manner ustrengend.

hei Dir kënnt e kuerze Video kucken wéi den Emulator lancéiert an interagéiert mat IDA Pro.

Start mat Radare2

Dir kënnt net sou en universellt Tool wéi Radare2 ignoréieren.

Fir mam Emulator mat r2 ze verbannen, gesäit de Kommando esou aus:

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

Start elo verfügbar (dc) an d'Ausféierung pausen (Ctrl+C).

Leider, am Moment, huet r2 Problemer wann Dir mat der Hardware gdb Server an Erënnerung Layout schafft wéinst dësem, breakpoints a Schrëtt net schaffen (Command ds). Mir hoffen dat wäert geschwënn fix ginn.

Lafen mat Eclipse

Eng vun den Optiounen fir den Emulator ze benotzen ass d'Firmware vum Apparat ze debuggen, deen entwéckelt gëtt. Fir Kloerheet wäerte mir och d'Rhino Firmware benotzen. Dir kënnt d'Firmware Quellen eroflueden vun hei.

Mir benotzen Eclipse aus dem Set als IDE System Workbench fir STM32.

Fir datt den Emulator Firmware direkt an Eclipse kompiléiert gëtt, musst Dir de Parameter derbäisetzen firmware=null op den Emulator Start Kommando:

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

Debug Konfiguratioun opsetzen

An Eclipse, wielt de Menü Run - Debug Konfiguratiounen ... An der Fënster déi opmaacht, an der Rubrik GDB Hardware Debugging Dir musst eng nei Konfiguratioun derbäisetzen, dann op der "Main" Reiter spezifizéiert den aktuelle Projet an Uwendung fir Debugging:

Op der Tab "Debugger" musst Dir de GDB Kommando spezifizéieren:
${openstm32_compiler_path}arm-none-eabi-gdb

A gitt och d'Parameteren fir d'Verbindung mam GDB Server (Host an Hafen):

Op der Tab "Startup" musst Dir déi folgend Parameteren uginn:

• aktivéiert Checkbox Lued Bild (sou datt dat gesammelt Firmwarebild an den Emulator gelueden gëtt);
• aktivéiert Checkbox Lued Symboler;
• Füügt Start Kommando: set $pc = *0x08000004 (setzen de PC Register op de Wäert aus der Erënnerung op der Adress 0x08000004 - d'Adress ass do gespäichert ResetHandler).

Opgepasst, Wann Dir d'Firmware-Datei net vun Eclipse eroflueden wëllt, dann d'Optiounen Lued Bild и Kommandoen lafen net néideg ze uginn.

Nodeems Dir op Debug geklickt hutt, kënnt Dir am Debuggermodus schaffen:

• Schrëtt fir Schrëtt Code Ausféierung
  
• interagéieren mat Breakpunkten
  

Remarque. Eclipse huet, hmm ... e puer Quirks ... an Dir musst mat hinnen liewen. Zum Beispill, wann Dir den Debugger starten, de Message "Keng Quell verfügbar fir "0x0"" erschéngt, da fuert de Step Kommando (F5) aus.

Amplaz vun enger Konklusioun

Emuléieren gebierteg Code ass eng ganz interessant Saach. Fir en Apparat Entwéckler gëtt et méiglech d'Firmware ouni e richtegen Apparat ze debuggen. Fir e Fuerscher ass et eng Geleeënheet dynamesch Code Analyse ze maachen, wat net ëmmer méiglech ass och mat engem Apparat.

Mir wëllen Spezialisten e Tool ubidden dat bequem ass, mëttelméisseg einfach ass an net vill Effort an Zäit brauch fir opzemaachen an ze lafen.

Schreift an de Kommentaren iwwer Är Erfahrung mat Hardware-Emulatoren. Mir invitéieren Iech ze diskutéieren a wäerte frou Froen ze beäntweren.

Nëmme registréiert Benotzer kënnen un der Ëmfro deelhuelen. Umellen, wann ech glift.

Fir wat benotzt Dir den Emulator?

• Ech entwéckelen (Debug) Firmware

• Ech recherchéieren Firmware

• Ech starten Spiller (Dendi, Sega, PSP)

• soss eppes (schreiwen an de Kommentaren)

7 Benotzer hunn gestëmmt. 2 Benotzer hu sech enthalen.

Wéi eng Software benotzt Dir fir gebierteg Code ze emuléieren?

• QEMU

• Unicorn Motor

• Proteus

• soss eppes (schreiwen an de Kommentaren)

6 Benotzer hunn gestëmmt. 2 Benotzer hu sech enthalen.

Wat wëllt Dir am Emulator verbesseren deen Dir benotzt?

• Ech wëll Vitesse

• Ech wëll Einfachheet vum Setup / Start

• Ech wëll méi Optiounen fir mam Emulator ze interagéieren (API, Haken)

• Ech si frou mat allem

• soss eppes (schreiwen an de Kommentaren)

8 Benotzer hunn gestëmmt. 1 Benotzer huet sech enthalen.

Source: will.com