🥇Renoster binne 'n kat - begin die firmware in die Kopycat-emulator

As deel van die vergadering 0x0A DC7831 DEF CON Nizhny Novgorod Op 16 Februarie het ons 'n verslag aangebied oor die basiese beginsels van binêre kode-emulasie en ons eie ontwikkeling - 'n hardeware-platform-emulator Copycat.

In hierdie artikel sal ons beskryf hoe om die toestel se firmware in die emulator te laat loop, interaksie met die ontfouter te demonstreer en 'n klein dinamiese analise van die firmware uit te voer.

voorgeskiedenis

Lank gelede in 'n sterrestelsel ver ver weg

'n Paar jaar gelede in ons laboratorium was daar 'n behoefte om die firmware van 'n toestel te ondersoek. Die firmware is saamgepers en uitgepak met 'n selflaaiprogram. Hy het dit op 'n baie ingewikkelde manier gedoen en die data verskeie kere in die geheue verskuif. En die firmware self het toe aktief met die randapparatuur in wisselwerking gegaan. En dit alles op die MIPS-kern.

Om objektiewe redes het die beskikbare emulators ons nie gepas nie, maar ons wou steeds die kode laat loop. Toe het ons besluit om ons eie emulator te maak, wat die minimum sal doen en ons toelaat om die hooffirmware uit te pak. Ons het dit probeer en dit het gewerk. Ons het gedink, wat as ons randapparatuur byvoeg om ook die hooffirmware uit te voer. Dit het nie baie seergemaak nie - en dit het ook uitgewerk. Ons het weer gedink en besluit om 'n volwaardige emulator te maak.

Die resultaat was 'n rekenaarstelsel-emulator Copycat.

Hoekom Kopycat?

Daar is 'n woordspeling.

Covers (Engels, selfstandige naamwoord [ˈkɒpɪkæt]) - nabootser, nabootser
kat (Engels, selfstandige naamwoord [ˈkæt]) - kat, kat - die gunsteling dier van een van die skeppers van die projek
Die letter "K" is van die Kotlin-programmeertaal

Copycat

Met die skep van die emulator is baie spesifieke doelwitte gestel:

die vermoë om vinnig nuwe randapparatuur, modules, verwerkerkerne te skep;
die vermoë om 'n virtuele toestel uit verskeie modules saam te stel;
die vermoë om enige binêre data (firmware) in die geheue van 'n virtuele toestel te laai;
vermoë om met kiekies te werk (kiekies van die stelseltoestand);
die vermoë om met die emulator te kommunikeer deur die ingeboude ontfouter;
lekker moderne taal vir ontwikkeling.

As gevolg hiervan is Kotlin gekies vir implementering, die busargitektuur (dit is wanneer modules met mekaar kommunikeer via virtuele databusse), JSON as die toestelbeskrywingsformaat en GDB RSP as die protokol vir interaksie met die ontfouter.

Ontwikkeling is aan die gang vir 'n bietjie meer as twee jaar en is aktief aan die gang. Gedurende hierdie tyd is MIPS-, x86-, V850ES-, ARM- en PowerPC-verwerkerkerne geïmplementeer.

Die projek groei en dit is tyd om dit aan die breër publiek voor te stel. Ons sal later 'n gedetailleerde beskrywing van die projek doen, maar vir nou sal ons fokus op die gebruik van Kopycat.

Vir die mees ongeduldige, kan 'n promo weergawe van die emulator afgelaai word vanaf skakel.

Renoster in die emulator

Laat ons onthou dat vroeër vir die SMARTRHINO-2018-konferensie 'n toetstoestel "Rhinoceros" geskep is vir die onderrig van omgekeerde ingenieursvaardighede. Die proses van statiese firmware-analise is beskryf in Hierdie artikel.

Kom ons probeer nou "luidsprekers" byvoeg en die firmware in die emulator laat loop.

Ons benodig:
1) Java 1.8
2) Python en module jep om Python binne die emulator te gebruik. Jy kan die WHL-module Jep vir Windows bou laai hier af.

Vir Windows:
1) com0com
2) PuTTY

Vir Linux:
1) sokat

Jy kan Eclipse, IDA Pro of radare2 as 'n GDB-kliënt gebruik.

Hoe werk dit?

Om firmware in die emulator uit te voer, is dit nodig om 'n virtuele toestel te "saamstel", wat 'n analoog van 'n regte toestel is.

Die werklike toestel ("renoster") kan in die blokdiagram getoon word:

Die emulator het 'n modulêre struktuur en die finale virtuele toestel kan in 'n JSON-lêer beskryf word.

JSON 105 reëls

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

Gee aandag aan die parameter Firmware artikel params is die naam van 'n lêer wat as firmware in 'n virtuele toestel gelaai kan word.

Die virtuele toestel en sy interaksie met die hoofbedryfstelsel kan deur die volgende diagram voorgestel word:

Die huidige toetsinstansie van die emulator behels interaksie met die COM-poorte van die hoofbedryfstelsel (ontfout UART en UART vir die Bluetooth-module). Dit kan regte poorte wees waaraan toestelle gekoppel is of virtuele COM-poorte (hiervoor benodig jy net com0com/socat).

Daar is tans twee hoof maniere om van buite af met die emulator te kommunikeer:

GDB RSP-protokol (gevolglik is die instrumente wat hierdie protokol ondersteun, Eclipse / IDA / radare2);
interne emulator-opdragreël (Argparse of Python).

Virtuele COM-poorte

Om met die UART van 'n virtuele toestel op die plaaslike masjien via 'n terminaal te kommunikeer, moet jy 'n paar geassosieerde virtuele COM-poorte skep. In ons geval word een poort deur die emulator gebruik, en die tweede deur 'n terminale program (PuTTY of skerm):

Gebruik com0com

Virtuele COM-poorte word gekonfigureer met behulp van die opstelprogram vanaf die com0com-stel (konsoleweergawe - C:Program Files (x86)com0comsetupс.exe, of GUI weergawe - C:Program Files (x86)com0comsetupg.exe):

Merk die blokkies aktiveer bufferoorskryding vir alle geskepde virtuele poorte, anders sal die emulator wag vir 'n reaksie van die COM-poort.

Gebruik socat

Op UNIX-stelsels word virtuele COM-poorte outomaties geskep deur die emulator met behulp van die socat-nutsding om dit te doen, spesifiseer net die voorvoegsel in die poortnaam wanneer die emulator begin word socat:.

Interne opdragreël-koppelvlak (Argparse of Python)

Aangesien Kopycat 'n konsoletoepassing is, bied die emulator twee opdragreël-koppelvlakopsies vir interaksie met sy voorwerpe en veranderlikes: Argparse en Python.

Argparse is 'n CLI wat in Kopycat ingebou is en is altyd beskikbaar vir almal.

'n Alternatiewe CLI is die Python-tolk. Om dit te gebruik, moet jy die Jep Python-module installeer en die emulator instel om met Python te werk (die Python-tolk wat op die gebruiker se hoofstelsel geïnstalleer is, sal gebruik word).

Installeer die Python-module Jep

Onder Linux kan Jep via pip geïnstalleer word:

pip install jep

Om Jep op Windows te installeer, moet jy eers die Windows SDK en die ooreenstemmende Microsoft Visual Studio installeer. Ons het dit vir jou 'n bietjie makliker gemaak en WHL bou JEP vir huidige weergawes van Python vir Windows, sodat die module vanaf die lêer geïnstalleer kan word:

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

Om die installasie van Jep na te gaan, moet jy op die opdragreël hardloop:

python -c "import jep"

Die volgende boodskap moet in reaksie ontvang word:

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

In die emulator bondellêer vir jou stelsel (copycat.bat - vir Windows, kopieer - vir Linux) na die lys van parameters DEFAULT_JVM_OPTS voeg 'n bykomende parameter by Djava.library.path — dit moet die pad na die geïnstalleerde Jep-module bevat.

Die resultaat vir Windows moet 'n reël soos hierdie wees:

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

Begin Kopycat

Die emulator is 'n konsole JVM-toepassing. Die bekendstelling word uitgevoer deur die opdragreëlskrif van die bedryfstelsel (sh/cmd).

Opdrag om onder Windows uit te voer:

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

Opdrag om onder Linux uit te voer met die socat-hulpprogram:

./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-poort wat oop sal wees vir toegang tot die GDB-bediener;
-n rhino — naam van die hoofstelselmodule (saamgestelde toestel);
-l user — naam van die biblioteek om na die hoofmodule te soek;
-y library — pad om te soek na modules wat by die toestel ingesluit is;
firmwarerhino_pass.bin - pad na die firmware-lêer;
COM26 en COM28 is virtuele COM-poorte.

As gevolg hiervan sal 'n prompt vertoon word Python > (Of 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 >

Interaksie met IDA Pro

Om toetsing te vereenvoudig, gebruik ons die Rhino-firmware as die bronlêer vir ontleding in IDA in die vorm ELF lêer (meta-inligting word daar gestoor).

U kan ook die hooffirmware sonder meta-inligting gebruik.

Nadat u Kopycat in IDA Pro geloods het, gaan in die Debugger-kieslys na die item "Skakel ontfouter …"en kies"Afgeleë GDB-ontfouter". Stel dan die verbinding:-kieslys op Ontfouter - Proses opsies...

Stel die waardes:

Toepassing - enige waarde
Gasheernaam: 127.0.0.1 (of die IP-adres van die afgeleë masjien waar Kopycat loop)
Port: 23946

Nou word die ontfoutingsknoppie beskikbaar (F9-sleutel):

Klik daarop om aan die ontfoutermodule in die emulator te koppel. IDA gaan in ontfoutingsmodus, bykomende vensters word beskikbaar: inligting oor registers, oor die stapel.

Nou kan ons al die standaardkenmerke van die ontfouter gebruik:

stap-vir-stap uitvoering van instruksies (Instap и Klim oor — sleutels F7 en F8, onderskeidelik);
begin en onderbreek uitvoering;
skep breekpunte vir beide kode en data (F2 sleutel).

Om aan 'n ontfouter te koppel, beteken nie dat die firmwarekode uitgevoer word nie. Die huidige uitvoeringsposisie moet die adres wees 0x08006A74 — begin van funksie Reset_Handler. As jy die lys afrol, kan jy die funksie-oproep sien hoof. Jy kan die wyser op hierdie lyn plaas (adres 0x08006ABE) en voer die operasie uit Hardloop tot wyser (sleutel F4).

Vervolgens kan jy F7 druk om die funksie in te voer hoof.

As jy die opdrag uitvoer Gaan voort met proses (F9 sleutel), dan sal die "Wag asseblief" venster verskyn met 'n enkele knoppie Hang:

As jy druk Hang Die uitvoering van die firmwarekode word opgeskort en kan voortgesit word vanaf dieselfde adres in die kode waar dit onderbreek is.

As jy aanhou om die kode uit te voer, sal jy die volgende reëls sien in die terminale wat aan die virtuele COM-poorte gekoppel is:

Die teenwoordigheid van die "staatsomleiding"-lyn dui aan dat die virtuele Bluetooth-module oorgeskakel het na die modus om data vanaf die gebruiker se COM-poort te ontvang.

Nou in die Bluetooth-terminaal (COM29 in die prentjie) kan jy opdragte in voer in ooreenstemming met die Rhino-protokol. Byvoorbeeld, die "MEOW"-opdrag sal die string "mur-mur" na die Bluetooth-terminaal terugstuur:

Emuleer my nie heeltemal nie

Wanneer u 'n emulator bou, kan u die vlak van detail/emulasie van 'n spesifieke toestel kies. Byvoorbeeld, die Bluetooth-module kan op verskillende maniere nageboots word:

die toestel word ten volle nageboots met 'n volledige stel opdragte;
AT-opdragte word nageboots, en die datastroom word vanaf die COM-poort van die hoofstelsel ontvang;
die virtuele toestel verskaf volledige dataherleiding na die regte toestel;
as 'n eenvoudige stomp wat altyd "OK" gee.

Die huidige weergawe van die emulator gebruik die tweede benadering - die virtuele Bluetooth-module voer konfigurasie uit, waarna dit oorskakel na die modus van "proxying" data vanaf die COM-poort van die hoofstelsel na die UART-poort van die emulator.

Kom ons kyk na die moontlikheid van eenvoudige instrumentasie van die kode ingeval 'n deel van die periferie nie geïmplementeer word nie. Byvoorbeeld, as 'n timer verantwoordelik vir die beheer van data-oordrag na DMA nie geskep is nie (die kontrole word in die funksie uitgevoer ws2812b_wag, raspolojennoy po adresu 0x08006840), dan sal die firmware altyd wag vir die vlag om teruggestel te word besiggeleë by 0x200004C4wat die besetting van die DMA-datalyn toon:

Ons kan hierdie situasie omseil deur die vlag handmatig terug te stel besig onmiddellik nadat dit geïnstalleer is. In IDA Pro kan jy 'n Python-funksie skep en dit in 'n breekpunt noem, en die breekpunt self in die kode plaas nadat jy die waarde 1 in die vlag geskryf het besig.

Breekpunt hanteerder

Kom ons skep eers 'n Python-funksie in IDA. Spyskaart Lêer - Skripopdrag...

Voeg 'n nuwe brokkie in die lys aan die linkerkant by, gee dit 'n naam (byvoorbeeld, BPT),
In die teksveld aan die regterkant, voer die funksiekode in:

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

Daarna, klik Run en maak die skrifvenster toe.

Kom ons gaan nou na die kode by 0x0800688A, stel 'n breekpunt (F2-sleutel), wysig dit (kontekskieslys Wysig breekpunt...), moenie vergeet om die skriptipe op Python te stel nie:

As die huidige vlagwaarde besig gelyk is aan 1, dan moet jy die funksie uitvoer skip_dma in die skrifreël:

As jy die firmware vir uitvoering laat loop, kan die aktiveer van die breekpunt hanteerder-kode in die IDA-venster gesien word Uitgawe per lyn Skipping wait ws2812.... Nou sal die firmware nie wag vir die vlag om teruggestel te word nie besig.

Interaksie met die emulator

Emulasie ter wille van navolging sal waarskynlik nie genot en vreugde veroorsaak nie. Dit is baie interessanter as die emulator die navorser help om die data in die geheue te sien of die interaksie van drade vas te stel.

Ons sal jou wys hoe om interaksie tussen RTOS-take dinamies te vestig. U moet eers die uitvoering van die kode onderbreek as dit loop. As jy na die funksie gaan bluetooth_taak_inskrywing na die verwerkingstak van die "LED"-opdrag (adres 0x080057B8), dan kan jy sien wat eers geskep word en dan na die stelselry gestuur word ledControlQueueHandle een of ander boodskap.

Jy moet 'n breekpunt stel om toegang tot die veranderlike te verkry ledControlQueueHandle, raspolojennoy po adresu 0x20000624 en gaan voort om die kode uit te voer:

Gevolglik sal die stop eers by adres plaasvind 0x080057CA voordat u die funksie oproep osMailAlloc, dan by die adres 0x08005806 voordat u die funksie oproep osMailPut, dan na 'n rukkie - na die adres 0x08005BD4 (voordat die funksie gebel word osMailGet), wat tot die funksie behoort leds_taak-inskrywing (LED-taak), dit wil sê die take het omgeskakel, en nou het die LED-taak beheer ontvang.

Op hierdie eenvoudige manier kan jy vasstel hoe RTOS-take met mekaar in wisselwerking is.

Natuurlik, in werklikheid kan die interaksie van take meer ingewikkeld wees, maar die gebruik van 'n emulator word minder moeisaam om hierdie interaksie op te spoor.

Hier Jy kan 'n kort video kyk van die emulator wat begin en met IDA Pro kommunikeer.

Begin met Radare2

Jy kan nie so 'n universele instrument soos Radare2 ignoreer nie.

Om met r2 aan die emulator te koppel, sal die opdrag soos volg lyk:

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

Bekendstelling nou beskikbaar (dc) en onderbreek uitvoering (Ctrl+C).

Ongelukkig het r2 op die oomblik probleme wanneer daar met die hardeware gdb-bediener en geheue-uitleg gewerk word, as gevolg hiervan, werk breekpunte en stappe nie (opdrag ds). Ons hoop dit sal binnekort reggestel word.

Hardloop met Eclipse

Een van die opsies vir die gebruik van die emulator is om die firmware van die toestel wat ontwikkel word, te ontfout. Vir duidelikheid sal ons ook die Rhino-firmware gebruik. Jy kan die firmware-bronne aflaai vandaar.

Ons sal Eclipse vanaf die stel as 'n IDE gebruik Stelselwerkbank vir STM32.

Om die emulator firmware direk saamgestel in Eclipse te laai, moet u die parameter byvoeg firmware=null na die emulator launch opdrag:

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

Stel ontfoutopstelling op

In Eclipse, kies die spyskaart Hardloop - Ontfout konfigurasies... In die venster wat oopmaak, in die afdeling GDB Hardeware Ontfouting jy moet 'n nuwe konfigurasie byvoeg, en dan op die "Hoof"-oortjie spesifiseer die huidige projek en toepassing vir ontfouting:

Op die "Debugger"-oortjie moet jy die GDB-opdrag spesifiseer:
${openstm32_compiler_path}arm-none-eabi-gdb

En voer ook die parameters in om aan die GDB-bediener (gasheer en poort) te koppel:

Op die "Opstart"-oortjie moet u die volgende parameters spesifiseer:

aktiveer merkblokkie Laai prent (sodat die saamgestelde firmware-beeld in die emulator gelaai word);
aktiveer merkblokkie Laai simbole;
voeg bekendstelling opdrag by: set $pc = *0x08000004 (stel die rekenaarregister op die waarde uit die geheue by adres 0x08000004 - die adres word daar gestoor HerstelHandler).

Let wel, as jy nie die firmware-lêer van Eclipse wil aflaai nie, dan is die opsies Laai prent и Voer opdragte uit nie nodig om aan te dui nie.

Nadat u op Ontfout geklik het, kan u in ontfoutingsmodus werk:

stap vir stap kode uitvoering
interaksie met breekpunte

Let daarop. Eclipse het, hmm ... 'n paar eienaardighede ... en jy moet daarmee saamleef. Byvoorbeeld, as wanneer die ontfouter begin word die boodskap "Geen bron beskikbaar vir "0x0″" verskyn nie, voer dan die Stap-opdrag (F5) uit.

In plaas daarvan om 'n gevolgtrekking

Om inheemse kode te emuleer is 'n baie interessante ding. Vir 'n toestelontwikkelaar word dit moontlik om die firmware sonder 'n regte toestel te ontfout. Vir 'n navorser is dit 'n geleentheid om dinamiese kode-analise uit te voer, wat selfs met 'n toestel nie altyd moontlik is nie.

Ons wil spesialiste voorsien van 'n hulpmiddel wat gerieflik, matig eenvoudig is en nie baie moeite en tyd verg om op te stel en te laat loop nie.

Skryf in die kommentaar oor jou ervaring met hardeware-emulators. Ons nooi jou uit om te bespreek en sal graag vrae beantwoord.

Slegs geregistreerde gebruikers kan aan die opname deelneem. Meld aan, asseblief.

Waarvoor gebruik jy die emulator?

Ek ontwikkel (debug) firmware
Ek doen navorsing oor firmware
Ek begin speletjies (Dendi, Sega, PSP)
iets anders (skryf in die kommentaar)

7 gebruikers het gestem. 2 gebruikers het buite stemming gebly.

Watter sagteware gebruik jy om inheemse kode na te boots?

QEMU
Eenhoorn-enjin
Proteus
iets anders (skryf in die kommentaar)

6 gebruikers het gestem. 2 gebruikers het buite stemming gebly.

Wat wil jy verbeter in die emulator wat jy gebruik?

Ek wil spoed hê
Ek wil maklik opstel/bekendstelling hê
Ek wil meer opsies hê vir interaksie met die emulator (API, hake)
Ek is gelukkig met alles
iets anders (skryf in die kommentaar)

8 gebruikers het gestem. 1 gebruiker het buite stemming gebly.

Bron: will.com

Renoster binne 'n kat - hardloop die firmware in die Kopycat-emulator