As ûnderdiel fan 'e gearkomste 0x0A DC7831 Op 16 febrewaris hawwe wy in rapport presintearre oer de basisprinsipes fan binêre koade-emulaasje en ús eigen ûntwikkeling - in hardware-platfoarmemulator .
Yn dit artikel sille wy beskriuwe hoe't jo de apparaatfirmware yn 'e emulator útfiere, ynteraksje mei de debugger demonstrearje en in lytse dynamyske analyze fan' e firmware útfiere.
prehistoarje
In lange tiid lyn yn in galaxy fier fier fuort
In pear jier lyn yn ús laboratoarium wie d'r needsaak om de firmware fan in apparaat te ûndersykjen. De firmware waard komprimearre en útpakt mei in bootloader. Hy die dit op in heul yngewikkelde manier, troch ferskate kearen de gegevens yn it ûnthâld te ferskowen. En de firmware sels hat doe aktyf ynteraksje mei de perifeare apparaten. En dit alles op 'e MIPS-kearn.
Om objektive redenen pasten de beskikbere emulators ús net, mar wy woene noch de koade útfiere. Doe besleaten wy ús eigen emulator te meitsjen, dy't it minimum soe dwaan en ús de haadfirmware útpakke kinne. Wy hawwe it besocht en it wurke. Wy tochten, wat as wy perifeare apparaten tafoegje om ek de wichtichste firmware út te fieren. It die net folle sear - en it slagge ek. Wy tochten nochris en besletten om in folweardige emulator te meitsjen.
It resultaat wie in emulator foar kompjûtersystemen .
Wêrom Kopycat?
Der wurdt boartsje mei wurden.
- copycat (Ingelsk, haadwurd [ˈkɒpɪkæt]) - imitator, imitator
- kat (Ingelsk, haadwurd [ˈkæt]) - kat, kat - it favorite bist fan ien fan 'e makkers fan it projekt
- De letter "K" is fan 'e Kotlin-programmearringstaal
Copycat
By it meitsjen fan de emulator waarden heul spesifike doelen ynsteld:
- de mooglikheid om fluch meitsje nije perifeare apparaten, modules, prosessor kearnen;
- de mooglikheid om in firtuele apparaat út ferskate modules te sammeljen;
- de mooglikheid om alle binêre gegevens (firmware) te laden yn it ûnthâld fan in firtuele apparaat;
- mooglikheid om te wurkjen mei snapshots (snapshots fan it systeem steat);
- de mooglikheid om ynteraksje mei de emulator fia de ynboude debugger;
- moaie moderne taal foar ûntwikkeling.
As resultaat waard Kotlin keazen foar ymplemintaasje, de busarsjitektuer (dit is as modules mei-inoar kommunisearje fia firtuele gegevensbussen), JSON as it apparaatbeskriuwingsformaat, en GDB RSP as it protokol foar ynteraksje mei de debugger.
De ûntwikkeling is al in bytsje mear as twa jier oan de gong en giet aktyf troch. Yn dizze tiid waarden MIPS, x86, V850ES, ARM, en PowerPC prosessor kearnen ymplementearre.
It projekt groeit en it is tiid om it oan it bredere publyk te presintearjen. Wy sille letter in detaillearre beskriuwing fan it projekt dwaan, mar foar no sille wy rjochtsje op it brûken fan Kopycat.
Foar de meast ûngeduldich, in promo ferzje fan de emulator kin wurde ynladen fan .
Rhino yn 'e emulator
Lit ús ûnthâlde dat earder foar de SMARTRHINO-2018-konferinsje, in testapparaat "Rhinoceros" waard makke foar it learen fan reverse engineeringfeardigens. It proses fan statyske firmware-analyze waard beskreaun yn .
Litte wy no besykje "sprekkers" ta te foegjen en de firmware yn 'e emulator út te fieren.
Wy sille nedich wêze:
1) Java 1.8
2) Python en module om Python yn 'e emulator te brûken. Jo kinne bouwe de WHL module Jep foar Windows .
Foar Windows:
1)
2)
Foar Linux:
1) sok
Jo kinne Eclipse, IDA Pro of radare2 brûke as in GDB-kliïnt.
Hoe wurket it?
Om de firmware yn 'e emulator út te fieren, is it nedich om in firtuele apparaat te "assemble", dat is in analoog fan in echte apparaat.
It echte apparaat ("rhino") kin werjûn wurde yn it blokdiagram:
De emulator hat in modulêre struktuer en it definitive firtuele apparaat kin beskreaun wurde yn in JSON-bestân.
JSON 105 rigels
{
"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"]
]
}Soarch omtinken foar de parameter Firmware section params is de namme fan in bestân dat kin wurde laden yn in firtuele apparaat as firmware.
It firtuele apparaat en syn ynteraksje mei it haadbestjoeringssysteem kinne wurde fertsjintwurdige troch it folgjende diagram:
De hjoeddeistige testeksimplaar fan 'e emulator omfettet ynteraksje mei de COM-poarten fan it haad OS (debug UART en UART foar de Bluetooth-module). Dit kinne echte havens wêze wêrmei apparaten binne ferbûn as firtuele COM-poarten (dêrfoar hawwe jo gewoan nedich com0com/socat).
D'r binne op it stuit twa wichtige manieren om fan bûten mei de emulator te ynteraksje:
- GDB RSP-protokol (neffens binne de ark dy't dit protokol stypje Eclipse / IDA / radare2);
- ynterne emulator kommandorigel (Argparse of Python).
Firtuele COM havens
Om ynteraksje mei de UART fan in firtuele apparaat op 'e lokale masine fia in terminal, moatte jo in pear assosjearre firtuele COM-ports oanmeitsje. Yn ús gefal wurdt ien poarte brûkt troch de emulator, en de twadde wurdt brûkt troch in terminalprogramma (PuTTY of skerm):
Mei help fan com0com
Firtuele COM-poarten wurde konfigureare mei it opsetprogramma fan 'e com0com-kit (konsoleferzje - C:Program Files (x86)com0comsetupс.exe, of GUI ferzje - C:Program Files (x86)com0comsetupg.exe):
Kontrolearje de fakjes ynskeakelje buffer oerrin foar alle makke firtuele havens, oars sil de emulator wachtsje op in antwurd fan de COM-poarte.
Socat brûke
Op UNIX-systemen wurde firtuele COM-poarten automatysk makke troch de emulator mei it socat-hulpprogramma; om dit te dwaan, spesifisearje gewoan it foarheaksel yn 'e poartenamme by it starten fan' e emulator socat:.
Ynterne kommandorigelynterface (Argparse of Python)
Sûnt Kopycat is in konsole-applikaasje, biedt de emulator twa kommandorigel-ynterface-opsjes foar ynteraksje mei har objekten en fariabelen: Argparse en Python.
Argparse is in CLI ynboud yn Kopycat en is altyd beskikber foar elkenien.
In alternative CLI is de Python-tolk. Om it te brûken, moatte jo de module Jep Python ynstallearje en de emulator ynstelle om te wurkjen mei Python (de Python-tolk ynstalleare op it haadsysteem fan 'e brûker sil brûkt wurde).
It ynstallearjen fan de Python module Jep
Under Linux kin Jep ynstalleare wurde fia pip:
pip install jepOm Jep op Windows te ynstallearjen, moatte jo earst de Windows SDK en de oerienkommende Microsoft Visual Studio ynstallearje. Wy hawwe makke it in bytsje makliker foar jo en JEP foar aktuele ferzjes fan Python foar Windows, sadat de module kin wurde ynstalleare út it bestân:
pip install jep-3.8.2-cp27-cp27m-win_amd64.whlOm de ynstallaasje fan Jep te kontrolearjen, moatte jo op 'e kommandorigel útfiere:
python -c "import jep"It folgjende berjocht moat wurde ûntfongen as antwurd:
ImportError: Jep is not supported in standalone Python, it must be embedded in Java.Yn it emulatorbatchbestân foar jo systeem (copycat.bat - foar Windows, copycat - foar Linux) nei de list mei parameters DEFAULT_JVM_OPTS add in ekstra parameter Djava.library.path - it moat befetsje it paad nei de ynstallearre Jep module.
It resultaat foar Windows moat in rigel wêze as dit:
set DEFAULT_JVM_OPTS="-XX:MaxMetaspaceSize=256m" "-XX:+UseParallelGC" "-XX:SurvivorRatio=6" "-XX:-UseGCOverheadLimit" "-Djava.library.path=C:/Python27/Lib/site-packages/jep"Kopycat opstarten
De emulator is in konsole JVM-applikaasje. De lansearring wurdt útfierd fia it kommandorigelskript fan it bestjoeringssysteem (sh/cmd).
Kommando om ûnder Windows út te fieren:
binkopycat -g 23946 -n rhino -l user -y library -p firmware=firmwarerhino_pass.bin,tty_dbg=COM26,tty_bt=COM28Kommando om ûnder Linux te rinnen mei it socat-hulpprogramma:
./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-poarte dy't iepen sil wêze foar tagong ta de GDB-tsjinner;-n rhino- namme fan 'e haadsysteemmodule (monteare apparaat);-l user- namme fan 'e bibleteek om te sykjen nei de haadmodule;-y library- paad om te sykjen nei modules opnommen yn it apparaat;firmwarerhino_pass.bin- paad nei it firmwarebestân;- COM26 en COM28 binne firtuele COM-poarten.
As resultaat sil in prompt wurde werjûn 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 >Ynteraksje mei IDA Pro
Om testen te ferienfâldigjen, brûke wy de Rhino-firmware as it boarnebestân foar analyse yn IDA yn 'e foarm (meta-ynformaasje wurdt dêr opslein).
Jo kinne ek de wichtichste firmware brûke sûnder meta-ynformaasje.
Nei it starten fan Kopycat yn IDA Pro, gean yn it Debugger-menu nei it item "Skeakelje debugger..."En kieze"GDB-debugger op ôfstân". Stel dan it ferbining yn: menu Debugger - Prosesopsjes ...
Stel de wearden yn:
- Applikaasje - elke wearde
- Hostnamme: 127.0.0.1 (as it IP-adres fan 'e masine op ôfstân wêr't Kopycat rint)
- Haven: 23946
No wurdt de debuggen knop beskikber (F9-kaai):
Klikje derop om te ferbinen mei de debuggermodule yn 'e emulator. IDA giet yn debuggen modus, ekstra finsters wurde beskikber: ynformaasje oer registers, oer de stack.
No kinne wy alle standertfunksjes fan 'e debugger brûke:
- stap foar stap útfiering fan ynstruksjes (Stap yn и Oerstappe - toetsen F7 en F8, respektivelik);
- útfiering begjinne en pauze;
- brekpunten meitsje foar sawol koade as gegevens (F2-kaai).
Ferbine mei in debugger betsjut net dat de firmwarekoade útfiert. De hjoeddeistige útfieringsposysje moat it adres wêze 0x08006A74 - begjin fan funksje Reset_Handler. As jo de list nei ûnderen rôlje, kinne jo de funksjeoprop sjen main. Jo kinne de rinnerke op dizze rigel pleatse (adres 0x08006ABE) en útfiere de operaasje Rinne oant rinnerke (toets F4).
Dêrnei kinne jo op F7 drukke om de funksje yn te gean main.
As jo it kommando útfiere Trochgean proses (F9-kaai), dan sil it finster "Wachtsje asjebleaft" ferskine mei ien knop Útstelle:
As jo drukke Útstelle útfiering fan de firmware koade wurdt ophâlden en kin wurde fuortset fan itselde adres yn de koade dêr't it waard ûnderbrutsen.
As jo trochgean mei it útfieren fan de koade, sille jo de folgjende rigels sjen yn 'e terminals ferbûn mei de firtuele COM-poarten:
De oanwêzigens fan 'e rigel "state bypass" jout oan dat de firtuele Bluetooth-module oerstapt is nei de modus foar it ûntfangen fan gegevens fan 'e COM-poarte fan 'e brûker.
No kinne jo yn 'e Bluetooth-terminal (COM29 op' e foto) kommando's ynfiere yn oerienstimming mei it Rhino-protokol. Bygelyks, it kommando "MEOW" sil de tekenrige "mur-mur" werombringe nei de Bluetooth-terminal:
Emulearje my net folslein
By it bouwen fan in emulator, kinne jo kieze it nivo fan detail / emulaasje fan in bepaald apparaat. Bygelyks, de Bluetooth-module kin op ferskate manieren wurde emulearre:
- it apparaat wurdt folslein emulearre mei in folsleine set fan kommando's;
- AT-kommando's wurde emulearre, en de gegevensstream wurdt ûntfongen fan 'e COM-poarte fan it haadsysteem;
- it firtuele apparaat jout folsleine gegevens trochferwizing nei it echte apparaat;
- as in ienfâldige stub dy't altyd "OK" jout.
De hjoeddeistige ferzje fan 'e emulator brûkt de twadde oanpak - de firtuele Bluetooth-module fiert konfiguraasje, wêrnei't it oerstapt nei de modus fan "proxying" gegevens fan 'e COM-poarte fan it haadsysteem nei de UART-poarte fan' e emulator.
Lit ús beskôgje de mooglikheid fan ienfâldige ynstrumintaasje fan de koade yn gefal in part fan 'e perifery wurdt net útfierd. Bygelyks, as in timer ferantwurdlik foar it kontrolearjen fan gegevensoerdracht nei DMA net is makke (de kontrôle wurdt útfierd yn 'e funksje ws2812b_wachtsjeleit oan 0x08006840), dan sil de firmware altyd wachtsje oant de flagge weromset wurdt drokleit oan 0x200004C4dy't de besetting fan 'e DMA-gegevensline toant:
Wy kinne dizze situaasje omgean troch de flagge manuell werom te setten drok direkt nei it ynstallearjen. Yn IDA Pro kinne jo in Python-funksje oanmeitsje en it yn in brekpunt neame, en it brekpunt sels yn 'e koade sette nei it skriuwen fan de wearde 1 nei de flagge drok.
Breakpoint handler
Lit ús earst in Python-funksje oanmeitsje yn IDA. Menu Triem - Skript kommando...
Foegje in nij snippet ta yn de list oan de linkerkant, jou it in namme (bygelyks, CPM),
Fier yn it tekstfjild rjochts de funksjekoade yn:
def skip_dma():
print "Skipping wait ws2812..."
value = Byte(0x200004C4)
if value == 1:
PatchDbgByte(0x200004C4, 0)
return False
Dêrnei drukke wy op run en slute it skriptfinster.
No litte wy nei de koade by 0x0800688A, set in brekpunt (F2-kaai), bewurkje it (kontekstmenu Brekpunt bewurkje...), ferjit net it skripttype yn te stellen op Python:
As de hjoeddeiske flagge wearde drok is lyk oan 1, dan moatte jo de funksje útfiere skip_dma yn 'e skriptline:
As jo de firmware útfiere foar útfiering, kin de triggering fan 'e breakpoint handlerkoade yn it IDA-finster sjoen wurde útfier by line Skipping wait ws2812.... No sil de firmware net wachtsje oant de flagge weromset wurdt drok.
Ynteraksje mei de emulator
Emulaasje om 'e wille fan' e emulaasje sil wierskynlik nocht en freugde feroarsaakje. It is folle nijsgjirriger as de emulator de ûndersiker helpt om de gegevens yn it ûnthâld te sjen of de ynteraksje fan threaden te fêstigjen.
Wy sille jo sjen litte hoe't jo ynteraksje dynamysk kinne fêstigje tusken RTOS-taken. Jo moatte earst de útfiering fan 'e koade pauze as it rint. As jo geane nei de funksje bluetooth_task_entry nei de ferwurkingstûke fan it kommando "LED" (adres 0x080057B8), dan kinne jo sjen wat earst makke is en dan nei de systeemwachtrige stjoerd wurdt ledControlQueueHandle wat berjocht.
Jo moatte in brekpunt ynstelle om tagong te krijen ta de fariabele ledControlQueueHandleleit oan 0x20000624 en trochgean mei it útfieren fan de koade:
Dêrtroch komt de halte earst op adres 0x080057CA foardat jo de funksje neame osMailAlloc, dan op it adres 0x08005806 foardat jo de funksje neame osMailPut, dan nei in skoftke - nei it adres 0x08005BD4 (foardat jo de funksje oproppe osMailGet), dy't heart by de funksje leds_task_entry (LED-taak), dat is, de taken skeakele, en no krige de LED-taak kontrôle.
Op dizze ienfâldige manier kinne jo fêststelle hoe't RTOS-taken mei-inoar ynteraksje.
Fansels kin yn 'e realiteit de ynteraksje fan taken yngewikkelder wêze, mar it brûken fan in emulator wurdt it folgjen fan dizze ynteraksje minder omslachtich.
Jo kinne in koarte fideo besjen fan 'e emulator dy't lanseart en ynteraksje mei IDA Pro.
Starte mei Radare2
Jo kinne sa'n universele ark as Radare2 net negearje.
Om te ferbinen mei de emulator mei r2, soe it kommando der sa útsjen:
radare2 -A -a arm -b 16 -d gdb://localhost:23946 rhino_fw42k6.elfLaunch no beskikber (dc) en de útfiering pauze (Ctrl+C).
Spitigernôch hat r2 op it stuit problemen by it wurkjen mei de hardware gdb-tsjinner en ûnthâldopmaak; hjirtroch wurkje brekpunten en stappen net (kommando ds). Wy hoopje dat dit gau fêststeld wurdt.
Rinne mei Eclipse
Ien fan 'e opsjes foar it brûken fan' e emulator is om de firmware fan it apparaat dat ûntwikkele wurdt te debuggen. Foar dúdlikens sille wy ek de Rhino-firmware brûke. Jo kinne download de firmware boarnen .
Wy sille Eclipse fan 'e set brûke as in IDE .
Om de emulator firmware direkt kompilearre yn Eclipse te laden, moatte jo de parameter tafoegje firmware=null nei it emulator-startkommando:
binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28It ynstellen fan debug-konfiguraasje
Yn Eclipse, selektearje it menu Run - Debug konfiguraasjes... Yn it finster dat iepent, yn 'e seksje GDB Hardware Debuggen jo moatte in nije konfiguraasje taheakje, dan op 'e ljepper "Main" spesifisearje it aktuele projekt en de applikaasje foar debuggen:
Op it ljepblêd "Debugger" moatte jo it GDB-kommando opjaan:
${openstm32_compiler_path}arm-none-eabi-gdb
En fier ek de parameters yn foar ferbining mei de GDB-tsjinner (host en poarte):
Op it ljepblêd "Opstarten" moatte jo de folgjende parameters opjaan:
- ynskeakelje karfakje Laad ôfbylding (sadat de gearstalde firmwareôfbylding wurdt laden yn 'e emulator);
- ynskeakelje karfakje Laden symboalen;
- start kommando taheakje:
set $pc = *0x08000004(set it PC-register yn op de wearde fan it ûnthâld op adres0x08000004- it adres wurdt dêr bewarre ResetHandler).
Wês oandacht, as jo it firmware-bestân net fan Eclipse downloade wolle, dan de opsjes Laad ôfbylding и Kommando's útfiere net nedich om oan te jaan.
Nei it klikken op Debug, kinne jo wurkje yn debuggermodus:
- stap foar stap koade útfiering
- ynteraksje mei brekpunten
remark. Eclipse hat, hmm ... guon eigenaardichheden ... en jo moatte libje mei harren. Bygelyks, as by it starten fan de debugger it berjocht "Gjin boarne beskikber foar "0x0″" ferskynt, fier dan it Step kommando (F5) út.
Yn stee fan in konklúzje
Emulearjen fan lânseigen koade is in heul ynteressant ding. It wurdt mooglik foar in apparaatûntwikkelder om de firmware te debuggen sûnder in echt apparaat. Foar in ûndersiker is it in kâns om dynamyske koade-analyze út te fieren, wat sels mei in apparaat net altyd mooglik is.
Wy wolle spesjalisten in ark leverje dat handich is, matig ienfâldich en net in protte muoite en tiid nimt om op te setten en te rinnen.
Skriuw yn 'e opmerkingen oer jo ûnderfining mei it brûken fan hardware-emulators. Wy noegje jo út om te besprekken en sille graach fragen beantwurdzje.
Allinnich registrearre brûkers kinne meidwaan oan 'e enkête. , asjebleaft.
Wêr brûke jo de emulator foar?
-
Ik ûntwikkelje (debuggen) firmware
-
Ik ûndersykje firmware
-
Ik lansearje spultsjes (Dendi, Sega, PSP)
-
wat oars (skriuw yn 'e kommentaren)
7 brûkers stimden. 2 brûkers ûntholden har.
Hokker software brûke jo om native koade te emulearjen?
-
QEMU
-
Unicorn motor
-
Proteus
-
wat oars (skriuw yn 'e kommentaren)
6 brûkers stimden. 2 brûkers ûntholden har.
Wat wolle jo ferbetterje yn 'e emulator dy't jo brûke?
-
Ik wol snelheid
-
Ik wol gemak fan opset / lansearring
-
Ik wol mear opsjes foar ynteraksje mei de emulator (API, haken)
-
Ik bin bliid mei alles
-
wat oars (skriuw yn 'e kommentaren)
8 brûkers stimden. 1 brûker ûnthâlde him.
Boarne: www.habr.com