🥇Rhinoceros inside a cat - abiarazi firmwarea Kopycat emulatzailean

0x0A DC7831 bileraren barruan DEF CON Nizhny Novgorod Otsailaren 16an, kode bitar emulazioaren oinarrizko printzipioei eta gure garapen propioari buruzko txostena aurkeztu genuen - hardware plataforma emuladorea. Kopurua.

Artikulu honetan gailuaren firmwarea emuladorean exekutatu, araztearekin elkarreragina erakutsi eta firmwarearen analisi dinamiko txiki bat nola egin deskribatuko dugu.

historiaurrea

Aspaldi urrutiko galaxia batean

Duela pare bat urte gure laborategian gailu baten firmwarea ikertu beharra zegoen. Firmwarea konprimitu eta deskonprimitu zen abio-kargagailu batekin. Modu oso konplikatuan egin zuen, memoriako datuak hainbat aldiz lekuz aldatuz. Eta firmwareak berak aktiboki elkarreragin zuen periferikoekin. Eta hori guztia MIPS nukleoan.

Arrazoi objektiboengatik, eskuragarri dauden emuladoreak ez zitzaizkigun egokitzen, baina hala ere kodea exekutatu nahi genuen. Orduan, gure emuladorea egitea erabaki genuen, gutxienekoa egingo lukeena eta firmware nagusia deskonprimitu ahal izateko. Probatu genuen eta funtzionatu zuen. Pentsatu genuen, zer gertatzen da periferikoak gehitzen baditugu firmware nagusia ere egiteko. Ez zuen minik handirik egin, eta funtzionatu ere egin zuen. Berriro pentsatu eta emuladore oso bat egitea erabaki genuen.

Emaitza sistema informatikoen emuladore bat izan zen Kopurua.

Zergatik Kopycat?

Hitz joko bat dago.

copycat (Ingelesa, noun [ˈkɒpɪkæt]) - imitator, imitator
cat (Ingelesa, izena [ˈkæt]) - cat, cat - proiektuaren sortzaileetako baten animalia gogokoena
"K" letra Kotlin programazio-lengoaiakoa da

Kopurua

Emuladorea sortzean, helburu oso zehatzak ezarri ziren:

periferiko, modulu, prozesadore nukleo berriak azkar sortzeko gaitasuna;
hainbat modulutako gailu birtual bat muntatzeko gaitasuna;
edozein datu bitar (firmware) gailu birtual baten memorian kargatzeko gaitasuna;
argazkiekin lan egiteko gaitasuna (sistemaren egoeraren argazkiak);
emuladorearekin elkarreragiteko gaitasuna integratutako araztearen bidez;
garapenerako hizkuntza moderno polita.

Ondorioz, Kotlin aukeratu zen inplementatzeko, bus-arkitektura (hau da moduluak elkarren artean komunikatzen direnean datu-bus birtualen bidez), JSON gailuaren deskribapen formatu gisa eta GDB RSP araztailearekin interakziorako protokolo gisa.

Garapena bi urte pasatxo darama eta aktiboki jarraitzen du. Denbora horretan, MIPS, x86, V850ES, ARM eta PowerPC prozesadore nukleoak ezarri ziren.

Proiektua hazten ari da eta publiko zabalari aurkezteko garaia da. Aurrerago egingo dugu proiektuaren deskribapen zehatza, baina oraingoz Kopycat erabiltzean zentratuko gara.

Pazientziarik ez dutenentzat, emuladorearen promo bertsioa deskargatu daiteke link.

Rhino emuladorean

Gogora dezagun lehenago SMARTRHINO-2018 konferentziarako "Rhinoceros" proba-gailu bat sortu zela alderantzizko ingeniaritza gaitasunak irakasteko. Firmware estatikoko azterketa prozesuan deskribatu zen Artikulu honetan.

Orain saia gaitezen "bozgorailuak" gehitzen eta exekutatu firmwarea emuladorean.

Beharko dugu:
1) Java 1.8
2) Python eta modulua jep emuladorearen barruan Python erabiltzeko. WHL Jep modulua eraiki dezakezu Windows-erako deskargatu hemen.

Windows-erako:
1) com0com
2) plastilina

Linuxerako:
1) sokat

Eclipse, IDA Pro edo radare2 GDB bezero gisa erabil ditzakezu.

Nola funtzionatzen du?

Emuladorean firmwarea egiteko, beharrezkoa da gailu birtual bat "muntatzea", hau da, benetako gailu baten analogoa dena.

Benetako gailua ("rhino") bloke-diagraman ikus daiteke:

Emuladoreak egitura modularra du eta azken gailu birtuala JSON fitxategi batean deskriba daiteke.

JSON 105 lerroak

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

Erreparatu parametroari Firmware Atal parametroak gailu birtualean firmware gisa kargatu daitekeen fitxategi baten izena da.

Gailu birtuala eta sistema eragile nagusiarekin duen interakzioa diagrama honen bidez irudika daitezke:

Emuladorearen egungo proba-instantziak OS nagusiaren COM portuekin elkarreragina dakar (araztu UART eta UART Bluetooth modulurako). Hauek gailuak konektatuta dauden benetako atakak edo COM portu birtualak izan daitezke (horretarako besterik ez duzu behar com0com/socat).

Gaur egun, emuladorearekin kanpotik elkarreragiteko bi modu nagusi daude:

GDB RSP protokoloa (beraz, protokolo hau onartzen duten tresnak Eclipse / IDA / radare2 dira);
barne emuladorearen komando-lerroa (Argparse edo Python).

COM ataka birtualak

Tokiko makinako gailu birtual baten UARTarekin terminal baten bidez elkarreragiteko, lotutako COM ataka birtual pare bat sortu behar duzu. Gure kasuan, ataka bat emuladoreak erabiltzen du, eta bigarrena terminaleko programa batek (PuTTY edo pantaila):

com0com erabiliz

COM ataka birtualak com0com kit-eko konfigurazio utilitatearen bidez konfiguratzen dira (kontsola bertsioa - C: Programa-fitxategiak (x86)com0comsetupс.exe, edo GUI bertsioa - C: Programa-fitxategiak (x86)com0comsetupg.exe):

Egiaztatu laukiak gaitu buffer gainditzea sortutako ataka birtual guztietarako, bestela emuladoreak COM atakaren erantzunaren zain egongo da.

Socat erabiliz

UNIX sistemetan, COM ataka birtualak automatikoki sortzen ditu emuladoreak socat utilitatea erabiliz; horretarako, zehaztu aurrizkia ataka-izenean emuladorea abiaraztean. socat:.

Barne komando-lerroko interfazea (Argparse edo Python)

Kopycat kontsola aplikazio bat denez, emuladoreak bi komando-lerroko interfaze aukera eskaintzen ditu bere objektu eta aldagaiekin elkarreragiteko: Argparse eta Python.

Argparse Kopycat-en eraikitako CLI bat da eta denon eskura dago beti.

CLI alternatibo bat Python interpretea da. Erabiltzeko, Jep Python modulua instalatu eta emuladorea konfiguratu behar duzu Pythonekin lan egiteko (erabiltzailearen sistema nagusian instalatutako Python interpretea erabiliko da).

Jep Python modulua instalatzen

Linux-en Jep pip bidez instalatu daiteke:

pip install jep

Jep Windows-en instalatzeko, lehenik Windows SDK eta dagokion Microsoft Visual Studio instalatu behar dituzu. Apur bat erraztu dizugu eta WHLk eraikitzen du JEP Python-en Windows-en uneko bertsioetarako, beraz, modulua fitxategitik instalatu daiteke:

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

Jep-en instalazioa egiaztatzeko, komando lerroan exekutatu behar duzu:

python -c "import jep"

Erantzun gisa honako mezu hau jaso behar da:

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

Zure sistemarako emulatzaile batch fitxategian (copycat.bat - Windows-erako, kopiatzailea - Linuxerako) parametroen zerrendara DEFAULT_JVM_OPTS gehitu parametro gehigarri bat Djava.library.path — instalatutako Jep modulurako bidea eduki behar du.

Windows-erako emaitzak honelako lerro bat izan beharko luke:

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

Kopycat abiarazten

Emuladorea kontsola JVM aplikazio bat da. Abiatzea sistema eragilearen komando lerroko script-aren bidez egiten da (sh/cmd).

Windows-en exekutatzeko komandoa:

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

Linux-en exekutatzeko komandoa socat utilitatea erabiliz:

./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 — GDB zerbitzarian sartzeko irekita egongo den TCP ataka;
-n rhino — sistema nagusiaren moduluaren izena (muntatutako gailua);
-l user — modulu nagusia bilatzeko liburutegiaren izena;
-y library — gailuan sartutako moduluak bilatzeko bidea;
firmwarerhino_pass.bin — firmware fitxategirako bidea;
COM26 eta COM28 COM ataka birtualak dira.

Ondorioz, gonbita bat bistaratuko da Python > (Edo 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 >

IDA Pro-rekin elkarrekintza

Probak errazteko, Rhino firmwarea erabiltzen dugu iturburu-fitxategi gisa IDAn analisirako formularioan ELF fitxategia (meta informazioa hor gordetzen da).

Firmware nagusia ere erabil dezakezu meta informaziorik gabe.

IDA Pro-n Kopycat abiarazi ondoren, Arazte-menuan joan elementura "Aldatu arazketa..."Eta aukeratu"Urruneko GDB arazketa". Ondoren, konfiguratu konexioa: menua Araztailea - Prozesu aukerak...

Ezarri balioak:

Aplikazioa - edozein balio
Ostalari-izena: 127.0.0.1 (edo Kopycat exekutatzen ari den urruneko makinaren IP helbidea)
Port: 23946

Orain arazketa botoia erabilgarri dago (F9 tekla):

Egin klik emuladoreko arazketa-modulura konektatzeko. IDA arazketa moduan sartzen da, leiho osagarriak eskuragarri egongo dira: erregistroei buruzko informazioa, pilari buruzkoa.

Orain araztearen ezaugarri estandar guztiak erabil ditzakegu:

argibideak urratsez urrats betetzea (Sartu и Pausoa eman — F7 eta F8 teklak, hurrenez hurren);
exekuzioa abiaraztea eta etetea;
eten-puntuak sortzea bai kodea eta bai datuetarako (F2 tekla).

Araztagailu batera konektatzeak ez du esan nahi firmware kodea exekutatzea. Uneko exekuzio-posizioak helbidea izan behar du 0x08006A74 - funtzioaren hasiera Berrezarri_Handler. Zerrendatik behera mugitzen baduzu, funtzio-deia ikus dezakezu nagusia. Kurtsorea lerro honetan jar dezakezu (helbidea 0x08006ABE) eta egin eragiketa Exekutatu kurtsorea arte (F4 tekla).

Ondoren, F7 sakatu dezakezu funtzioan sartzeko nagusia.

Komandoa exekutatzen baduzu Jarraitu prozesua (F9 tekla), orduan "Mesedez itxaron" leihoa agertuko da botoi bakar batekin Eseki:

Sakatzen duzunean Eseki firmware kodearen exekuzioa eten egiten da eta eten zen kodean helbide beretik jarraitu daiteke.

Kodea exekutatzen jarraitzen baduzu, lerro hauek ikusiko dituzu COM portu birtualei konektatutako terminaletan:

"Estatuko saihesbidea" lerroaren presentzia adierazten du Bluetooth modulu birtuala erabiltzailearen COM atakatik datuak jasotzeko modura aldatu dela.

Orain Bluetooth terminalean (COM29 irudian) Rhino protokoloaren araberako komandoak sar ditzakezu. Adibidez, "MEOW" komandoak "mur-mur" katea itzuliko du Bluetooth terminalera:

Ez nazazu guztiz imitatu

Emuladore bat eraikitzean, gailu jakin baten xehetasun/emulazio maila hauta dezakezu. Adibidez, Bluetooth modulua modu ezberdinetan emulatu daiteke:

gailua guztiz emulatzen da komando multzo oso batekin;
AT komandoak emulatzen dira, eta datu-korrontea sistema nagusiko COM atakatik jasotzen da;
gailu birtualak datuen birbideraketa osoa eskaintzen du benetako gailura;
beti "OK" itzultzen duen zirriborro soil gisa.

Emuladorearen egungo bertsioak bigarren ikuspegia erabiltzen du: Bluetooth modulu birtualak konfigurazioa egiten du, eta ondoren, sistema nagusiko COM atakatik emuladorearen UART atakara "proxiatzeko" modura aldatzen da.

Azter dezagun kodearen tresneria sinplea egiteko aukera, periferiaren zatiren bat inplementatzen ez bada. Adibidez, DMAra datuen transferentzia kontrolatzeko ardura duen tenporizadorerik sortu ez bada (egiaztapena funtzioan egiten da. ws2812b_itxaronhelbidean kokatua 0x08006840), orduan firmwareak bandera berrezarri arte itxarongo du beti okupatutahelbidean kokatua 0x200004C4DMA datu-lerroaren okupazioa erakusten duena:

Egoera hau konpon dezakegu bandera eskuz berrezarriz okupatuta instalatu eta berehala. IDA Pro-n, Python funtzio bat sor dezakezu eta eten puntu batean deitu, eta eten-puntua bera kodean jarri 1 balioa banderan idatzi ondoren. okupatuta.

Eten-puntuaren kudeatzailea

Lehenik eta behin, sor dezagun Python funtzio bat IDAn. Menua Fitxategia - Script komandoa...

Gehitu zati berri bat ezkerreko zerrendan, eman izena (adibidez, BPT),
Eskuineko testu-eremuan, idatzi funtzioaren kodea:

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

Horren ostean sakatzen dugu Korrika egin eta itxi script-leihoa.

Orain goazen kodean 0x0800688A, ezarri eten puntu bat (F2 tekla), editatu (testuinguruko menua Editatu eten-puntua...), ez ahaztu script mota Python-en ezartzea:

Uneko banderaren balioa bada okupatuta 1 berdina da, orduan funtzioa exekutatu beharko zenuke skip_dma gidoi lerroan:

Exekutatzeko firmwarea exekutatzen baduzu, eten-puntuaren kudeatzailearen kodea abiarazteko IDA leihoan ikus daiteke Output lerroka Skipping wait ws2812.... Orain firmwareak ez du itxarongo bandera berrezarri arte okupatuta.

Emuladorearekin interakzioa

Emulazioaren mesedetan emulatzeak nekez eragingo du poza eta poza. Askoz interesgarriagoa da emuladoreak ikertzaileari memorian dauden datuak ikusten edo harien interakzioa ezartzen laguntzen badio.

RTOS zereginen arteko elkarrekintza dinamikoki nola ezarri erakutsiko dizugu. Lehenik eta behin, kodearen exekuzioa eten behar duzu exekutatzen ari bada. Funtziora joaten bazara bluetooth_task_sarrera "LED" komandoaren prozesatzeko adarrera (helbidea 0x080057B8), orduan ikusi ahal izango duzu zer sortu den lehenik eta gero sistema ilarara bidaltzen dena ledControlQueueHandle mezuren bat.

Eten puntu bat ezarri beharko zenuke aldagaira sartzeko ledControlQueueHandlehelbidean kokatua 0x20000624 eta jarraitu kodea exekutatzen:

Ondorioz, geldialdia helbidean gertatuko da lehenik 0x080057CA funtzioari deitu aurretik osMailAlloc, gero helbidean 0x08005806 funtzioari deitu aurretik osMailPut, gero pixka bat igaro ondoren - helbidera 0x08005BD4 (funtzioa deitu aurretik osMailGet), funtzioari dagokiona leds_task_sarrera (LED-zereginak), hau da, zereginak aldatu ziren, eta orain LED-zereginak kontrola jaso zuen.

Modu erraz honetan RTOS zereginek elkarren artean nola elkarreragiten ezar dezakezu.

Jakina, errealitatean, zereginen elkarrekintza zailagoa izan daiteke, baina emuladore bat erabiliz, interakzio horren jarraipena ez da hain neketsua izaten.

Hemen Emuladorea IDA Pro-rekin abiarazten eta elkarreraginaren bideo labur bat ikus dezakezu.

Abiarazi Radare2-rekin

Ezin duzu Radare2 bezalako tresna unibertsala alde batera utzi.

r2 erabiliz emuladorera konektatzeko, komandoak honela izango luke:

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

Abiarazi orain eskuragarri (dc) eta eten exekuzioa (Ktrl+C).

Zoritxarrez, momentuz, r2-k arazoak ditu hardware gdb zerbitzariarekin eta memoria-diseinuarekin lan egitean; horregatik, eten puntuak eta Urratsak ez dute funtzionatzen (komandoa ds). Hau laster konponduko dela espero dugu.

Eclipse-rekin korrika

Emuladorea erabiltzeko aukeretako bat garatzen ari den gailuaren firmwarea araztea da. Argitasuna lortzeko, Rhino firmwarea ere erabiliko dugu. Firmware iturriak deskargatu ditzakezu beraz,.

Multzoko Eclipse IDE gisa erabiliko dugu Sistema Workbench STM32rako.

Emuladoreak Eclipse-n zuzenean konpilatutako firmwarea kargatzeko, parametroa gehitu behar duzu firmware=null emulatzailea abiarazteko komandora:

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

Arazketa-konfigurazioa konfiguratzen

Eclipse-n, hautatu menua Exekutatu - Araztu konfigurazioak... Irekitzen den leihoan, atalean GDB Hardwarearen arazketa konfigurazio berri bat gehitu behar duzu, ondoren "Nagusia" fitxan zehaztu uneko proiektua eta arazketarako aplikazioa:

"Araztatzailea" fitxan GDB komandoa zehaztu behar duzu:
${openstm32_compiler_path}arm-none-eabi-gdb

Eta sartu GDB zerbitzariarekin konektatzeko parametroak (ostalaria eta ataka):

"Abiarazte" fitxan, parametro hauek zehaztu behar dituzu:

gaitu kontrol-laukia Kargatu irudia (muntatutako firmwarearen irudia emuladorean kargatu dadin);
gaitu kontrol-laukia Kargatu sinboloak;
Gehitu abiarazteko komandoa: set $pc = *0x08000004 (ezarri ordenagailuko erregistroa helbidean dagoen memoriako balioarekin 0x08000004 - helbidea bertan gordetzen da Berrezarri kudeatzailea).

Arreta ezazu, Eclipse-tik firmware fitxategia deskargatu nahi ez baduzu, aukerak Kargatu irudia и Exekutatu komandoak ez dago adierazi beharrik.

Araztu klik egin ondoren, arazketa moduan lan egin dezakezu:

urratsez urrats kodearen exekuzioa
etenguneekin elkarreragin

Kontuan izan. Eclipse-k baditu, hmm... bitxikeria batzuk... eta haiekin bizi behar duzu. Adibidez, arazketa abiaraztean "Ez dago iturririk eskuragarri "0x0"" mezua agertzen bada, exekutatu Step komandoa (F5)

Horren ordez Ondorio baten

Kode natiboa emulatzea oso gauza interesgarria da. Gailu garatzaile batek firmwarea araztea posible da benetako gailurik gabe. Ikertzaile batentzat, kodeen analisi dinamikoa egiteko aukera da, eta hori ez da beti posible gailu batekin ere.

Espezialistei tresna erosoa, nahiko sinplea eta konfiguratzeko eta martxan jartzeko ahalegin eta denbora asko behar ez duen tresna bat eskaini nahi diegu.

Idatzi iruzkinetan hardware emuladoreak erabiliz zure esperientziari buruz. Eztabaidatzera gonbidatzen zaitugu eta pozik erantzungo ditugu galderak.

Erregistratutako erabiltzaileek soilik parte hartu dezakete inkestan. Hasi saioa, mesedez.

Zertarako erabiltzen duzu emuladorea?

Firmwarea garatzen dut (araztea).
Firmwarea ikertzen ari naiz
Jokoak abiarazten ditut (Dendi, Sega, PSP)
beste zerbait (idatzi iruzkinetan)

7 erabiltzailek eman dute botoa. 2 erabiltzaile abstenitu ziren.

Zein software erabiltzen duzu jatorrizko kodea emulatzeko?

Qemu
Unicorn motorra
Proteus
beste zerbait (idatzi iruzkinetan)

6 erabiltzailek eman dute botoa. 2 erabiltzaile abstenitu ziren.

Zer hobetu nahiko zenuke erabiltzen ari zaren emuladorean?

Abiadura nahi dut
Konfiguratzeko/abiarazteko erraztasuna nahi dut
Emuladorearekin elkarreragiteko aukera gehiago nahi ditut (APIa, kakoak)
Pozik nago denarekin
beste zerbait (idatzi iruzkinetan)

8 erabiltzailek eman dute botoa. Erabiltzaile 1 abstenitu egin zen.

Iturria: www.habr.com

Rhinoceros inside a cat - exekutatu firmwarea Kopycat emuladorean