Ninasarv sees kassi sees — käivitame püsivara emulaatoris Kopycat

Kohtumisel 0x0A DC7831 DEF CON Nizhni Novgorod 16. veebruaril esitlesime ettekannet binaarkoodi emuleerimise põhialustest ja meie enda arendusest — riistvaraplatvormide emulaatorist Kopycat.

Artiklis anname ülevaate seadme püsivara käivitamisest emulaatoris, näitame suhtlemist siluriga ja teeme väikese dünaamilise analüüsi püsivaramudelist.

Eelalugu

A long time ago in a galaxy far far away

Mõned aastad tagasi tekkis meie laboris vajadus uurida seadme püsivara. Püsivara oli kompressitud, lahti pakkimise tegi bootloader. See toimus üsna keerulisel viisil, mitu korda andmeid mällu paigutades. Ning ise püsivara suhtles aktiivselt perifeeriaga. Ja kõik see MIPS-i tuumal.

Oleme põhjusel, et olemasolevad emulaatorid meid ei rahuldanud, otsustanud luua oma emulaatori, mis teeks miinimumi ja võimaldaks põhifirmavara avada. Proovisime — ja see õnnestus. Mõtlesime, et mis siis, kui lisame perifeeria, et põhifirmavara veel käitada. See ei olnud liiga valus — ja jälle õnnestus. Jõudsime järeldusele, et peaksime tegema täieliku emulaatori.

Lõpuks saime emulaatori arvutus süsteemide jaoks. Kopycat.

Miks Kopycat?

Siin on sõnamäng.

1. copycat (ingl., nim. [ˈkɒpɪkæt]) — jäljendaja, imiteerija
2. cat (ingl., nim. [ˈkæt]) — kass, kassipoeg — üks projekti looja lemmikloomadest
3. Täht «K» — programmeerimiskeel Kotlin'i järgi

Kopycat

Emulaatori loomisel seati täielikult kindlad eesmärgid:

• võimalus kiiresti luua uus perifeeria, moodul, protsessorituum;
• võimalus kokku panna virtuaalne seade erinevatest moodulitest;
• võimalus laadida virtuaalse seadme mällu mis tahes binaardata (firmavara);
• võimalus töötada hetkepiltidega (süsteemi seisundi pildistamine);
• võimalus suhelda emulaatoriga sisseehitatud veaparandaja kaudu;
• mugav ja kaasaegne arenduskeel.

Lõpuks valiti teostuseks Kotlin, bussiarhitektuur (see on, kui moodulid ühendatakse omavahel läbi virtuaalsete andmebusside), JSON seadme kirjeldusvorminguks ning GDB RSP protokolliks suhtlemiseks debuggeriga.

Arendus on kestnud juba üle kahe aasta ja jätkub aktiivselt. Selle aja jooksul on teostatud MIPS, x86, V850ES, ARM ja PowerPC protsessorituumad.

Projekt kasvab ning on aeg esitleda seda laiemale publikule. Projekti üksikasjaliku kirjelduse anname hiljem, praegu keskendume Kopycati kasutamisele.

Kõige kannatamatumatele — emulaatori promoversiooni saab alla laadida lingi kaudu.

Norsule emulaatoris

Kä remindersime, et varem loodi konverentsile SMARTRHINO-2018 testseade nimega „Norsu“ tagasiregistreerimise oskuste õppimiseks. Firmware'i staatilist analüüsi on kirjeldatud selles artiklis.

Nüüd proovime lisada "dünaamikat" ja käivitame firmware emulaatoris.

Meil on vaja:
1) Java 1.8
2) Python ja moodul Jep Python'i kasutamiseks emulaatori sees. Windowsi jaoks saab WHL paketti Jep moodulist siit alla laadida.

Windowsi jaoks:
1) com0com
2) PuTTY

Linuxi jaoks:
1) socat

GDB-klientina saab kasutada Eclipse'i, IDA Pro'd või radare2.

Kuidas see töötab?

Emulaatori vahetamiseks tuleb luua virtuaalne seade, mis esindab reaalset seadet.

Reaalset seadet („ninasarvik“) saab näidata struktuuri scheemina:

Emulaatoril on modulaarsestruktuur ning lõplikku virtuaalset seadet saab kirjeldada JSON-failis.

JSON 105 rida

{
  "top": true,

  // Plugina nime peaks olema sama, mis faili nimi (või täispikk tee raamatukogust)
  "plugin": "rhino",

  // Kaust, kuhu plugin salvestatakse
  "library": "user",

  // Plugina parameetrid (konstruktoriparameetrid, kui jar-plugin versioon)
  "params": [
    { "name": "tty_dbg", "type": "String"},
    { "name": "tty_bt", "type": "String"},
    { "name": "firmware", "type": "String", "default": "NUL"}
  ],

  // Plugina välist sadamat
  "ports": [  ],

  // Plugina sisebussid
  "buses": [
    { "name": "mem", "size": "BUS30" },
    { "name": "nand", "size": "4" },
    { "name": "gpio", "size": "BUS32" }
  ],

  // Plugina sisekomponendid
  "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" }
  ],

  // Plugina ühendused komponentide vahel
  "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"]
  ]
}

Pöörake tähelepanu parameetrile firmware jaotises params — see on faili nimi, mida saab laadida virtuaalsesse seadmesse tarkvara värskendamiseks.

Virtuaalset seadet ja selle suhtlemist peamise operatsioonisüsteemiga saab kujutada järgmise skeemi abil:

Praegune emulaatori testimise näidis hõlmab suhtlemist põhiosa COM-portidega (debug UART ja Bluetooth-mooduli UART). Need võivad olla reaalsed portid, kuhu on ühendatud seadmed, või virtuaalsed COM-portid (selleks on vajalik com0com / socat).

Emulaatoriga väljastpoolt suhtlemiseks on praegu kaks peamist meetodit:

• GDB RSP protokoll (vastavad tööriistad — Eclipse / IDA / radare2);
• emulaatori sisemine käsurea liides (Argparse või Python).

Virtuaalsed COM-portid

Kuna virtuaalse seadme UART-iga suhtlemiseks kohaliku masina terminalist on vaja luua paar omavahel seotud virtuaalseid COM-porte. Meie juhul kasutab üks port emulaatorit ja teine — terminaliprogramm (PuTTY või screen):

com0com kasutamine

Virtuaalsed COM-portid seadistatakse komplekti com0com setup-utility abil (konsooliversioon — C:Program Files (x86)com0comsetupс.exe, või GUI-versioon — C:Program Files (x86)com0comsetupg.exe):

Samuti tuleb märkida ruudud enable buffer overrun kõigi loodud virtuaalsete portide jaoks, vastasel juhul ootab emulaator COM-porti vastust.

socat'i kasutamine

UNIX-süsteemides luuakse virtuaalsed COM-portid automaatselt emulaatori abil kasutades utiliiti socat, selleks piisab, kui emulaatori käivitamisel portide nimedes kasutada prefiksit socat:.

Sisemine käsurea liides (Argparse või Python)

Kuna Kopycat on konsoolirakendus, pakub emulaator oma objektidega ja muutujatega suhtlemiseks kahte käsurea liidest: Argparse ja Python.

Argparse — see on Kopycati sisseehitatud CLI, mis on alati ja kõigile saadaval.

Alternatiivne CLI — Python'i tõlgendaja. Selle kasutamiseks tuleb installida Python'i moodul Jep ja seadistada emulaator töötama Python'iga (kasutatakse kasutaja põhissüsteemis installitud Python'i tõlgendajat).

Python'i mooduli Jep installimine

Linuxis saab Jep'i installida läbi pip:

pip install jep

Jep-i installimiseks Windowsi all on vajalik eelnevalt paigaldada Windows SDK ja sobiv Microsoft Visual Studio. Oleme teie ülesannet veidi lihtsustanud ja teinud WHL-paketid JEP viimaste Python versioonide jaoks Windowsis, mistõttu saab mooduli paigaldada failist:

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

Jep-i paigaldamise kontrollimiseks tuleb käivitada järgnev käsk käsureas:

python -c "import jep"

Vastuseks peaks saama sõnum:

ImportError: Jep ei ole iseseisvas Pythoni versioonis toetatud, see peab olema Java-sse sisse ehitatud.

Teie süsteemi emulatori käskfailis (kopycat.bat – Windowsi jaoks, kopycat – Linuxi jaoks) lisage parameetrite nimekirja DEFAULT_JVM_OPTS täiendav parameeter Djava.library.path – see peaks sisaldama teed paigaldatud Jep moodulini.

Seega peaks Windowsi jaoks moodustuma järgmine rida:

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

Kopycat-i käivitamine

Emulaator on konsooli JVM-rakendus. Käivitamine toimub operatsioonisüsteemi käsureas (sh/cmd).

Käsk Windowsi all käivitamiseks:

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

Käsk Linuxis käivitamiseks kasutades utiliiti socat:

./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-port, mis avatakse GDB-serverile juurdepääsuks;
• -n rhino — süsteemi põhikomponendi nimi (seade koosseisus);
• -l user — põhikomponendi otsimiseks kasutatav teek;
• -y library — tee, kust otsitakse seadmes olevaid komponente;
• firmwarerhino_pass.bin — lähtefaili tee;
• COM26 ja COM28 — virtuaalsed COM-portid.

Tulemuseks kuvatakse käskluste täitmine Python > (või Argparse >):

18:07:59 INFO [eFactoryBuilder.create ]: Moodul top on edukalt loodud
18:07:59 INFO [ Module.initializeAndRes]: Seadistatakse tuum top.u1_stm32.cortexm0.arm jaoks
18:07:59 INFO [ Module.initializeAndRes]: Seadistatakse debugeerija top.u1_stm32.dbg jaoks
18:07:59 WARN [ Module.initializeAndRes]: Jälgijat ei leitud...
18:07:59 INFO [ Module.initializeAndRes]: Portide ja busside initsialiseerimine...
18:07:59 WARN [ Module.initializePortsA]: TÄHELEPANU: Mõne porti puhul on hoiatus, kasuta printModulesPortsWarnings, et näha...
18:07:59 FINE [ ARMv6CPU.reset ]: Määratud sisenemispunkt 08006A75
18:07:59 INFO [ Module.initializeAndRes]: Moodul top on edukalt initsialiseeritud ja lähtestatud!
18:07:59 INFO [ Kopycat.open ]: Alustatakse alusena top[rhino] virtuaalsust arm[ARMv6Core] jaoks
18:07:59 INFO [ GDBServer.debuggerModule ]: Seadistatud uus debugeerija moodul top.u1_stm32.dbg GDB_SERVER jaoks (port=23946,alive=true)
Python >

Koostoime IDA Pro-ga

Analüüsimiseks kasutame IDA-s lihtsustatud testimiseks "Norsukaru" tarkvara ELF-failina (seal on meta information).

Saate kasutada ka põhifirmavara ilma metaandmeteta.

Pärast Kopycat käivitamist IDA Pro-s läheme Debugger menüüs punkti «Switch debugger…» ja valime «Remote GDB debugger«. Edasi seadistame ühenduse: menüüst Debugger — Process options…

Seame väärtused:

• Application — mis tahes väärtus
• Hostname: 127.0.0.1 (või IP-aadress kaugtöötlusmasinast, kus Kopycat töötab)
• Port: 23946

Nüüd on juurdepääs silumise käivitamise nupule (klahv F9):

Vajutame sellele — toimub ühendamine debuggermooduli ja emulaatoriga. IDA läheb silumisse ja muutuvad kergesti kättesaadavaks lisakujud: registrite teave, virna teave.

Nüüd saame kasutada kõiki standardseid silumise võimalusi:

• juhendi läbi viimist (Step into ja Step over — klahvid F7 ja F8, vastavalt);
• käivitus ja tõkestamine;
• murdpunktide loomine nii koodile kui andmetele (klahv F2).

Ühendamine debugeerijaga ei tähenda, et firmavara kood käivitatakse. Käivituskoht peab olema aadressil 0x08006A74 — funktsiooni algus Reset_Handler. Kui kerite loendi alla, siis näete funktsiooni kutset main. Kursorit saab sellel real (aadress) 0x08006ABE) ja teostada toiming Käita kuni kursori (klahv F4).

Seejärel saab vajutada F7, et siseneda funktsiooni main.

Kui käivitada käsk Jätka protsessi (klahv F9), siis kuvatakse aken „Palun oota” ainsa nupuga Peata:

Nupu vajutamisel Peata koodide täitmine peatub ja seda saab jätkata samalt aadressilt koodis, kus see katkestati.

Kui koodi täitmist jätkata, siis virtuaalsete COM-portidega ühendatud terminalides võib näha järgmisi ridu:

Rida „state bypass” näitab, et virtuaalne Bluetooth-modul on läinud andmete vastuvõtu režiimi kasutaja COM-portidelt.

Nüüd saab Bluetooth-terminalis (pildil – COM29) sisestada käske vastavalt „Norsukaru” protokollile. Näiteks käsule „MEOW” tagastatakse Bluetooth-terminalis rida „mur-mur”:

Emuleeri mind mitte täielikult

Emulaatori ehitamisel saab valida, kui detailne/üle kantud on see või see seade. Näiteks Bluetooth-modulit saab emuleerida erinevalt:

• emuleeritakse täielikult seade koos kõigi käskudega;
• AT-käsud emuleeritakse ja andmevoog võetakse peamise süsteemi COM-portist;
• virtuaalne seade tagab täieliku andmete suunamise reaalsele seadmele;
• lihtsa pistikuga, mis alati tagastab "OK".

Praeguses emulaatori versioonis kasutatakse teist lähenemist — virtuaalne Bluetooth-moodul konfigureerib, seejärel lülitub "proksimise" režiimi, edastades andmeid peamise süsteemi COM-portist emulaatori UART-porti.

Vaatame koodi lihtsat instrumenteerimist, juhul kui mõni periferiaseade ei ole rakendatud. Näiteks, kui ajastit, mis kontrollib andmete edastamist DMA-s, ei ole loodud (kontroll teostatakse funktsioonis ws2812b_wait, mis asub aadressil 0x08006840), siis tarkvara ootab alati, kuni lipp "busy" , mis asub aadressil0x200004C4 , näitab DMA andmejoone hõivamist:Sellisest olukorrast saame mööda hiilida "manuaalse" lipu resettimisega

vahetult pärast selle seadmist. IDA Pro-s on võimalik luua Python-funktsioon ja kutsuda see esile hetkel, kui breakpoint on seadistatud, paigaldades selle koodi pärast väärtuse 1 kirjutamist lipule , mis asub aadressil Breakpoint-i töötleja , mis asub aadressil.

Esmalt loome IDA-s Python-funktsiooni. Menüüs

Alustame Python-funktsiooni loomisega IDA-s. Menüüs Fail — Skripti käsk…

Lisame uue snipeti vasakpoolsesse nimekirja, anname selle nime (näiteks, BPT),
parempoolsesse teksti väljasse sisestame funktsiooni koodi:

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

Pärast seda vajutame Run ja sulgeme skripti akna.

Nüüd liigume koodi aadressile 0x0800688A, seadistame breakpoint (klahv F2), toimetame seda (kontekstimenüü Muuda breakpointi…), ärge unustage määrata skripti tüüpi – Python:

Kui praegune lipu väärtus , mis asub aadressil on 1, siis tuleks käivitada funktsioon skip_dma skripti rida:

Kui laadida ülekande käivitamiseks, siis breakpointi töötleja koodi aktiveerumist saab näha IDAs aknas Väljund rea järgi Skipping wait ws2812.... Nüüd ei ootata lipu lähtestamist. , mis asub aadressil.

Koostoime emulaatoriga

Emuleerimine emuleerimise nimel ei kutsu tõenäoliselt esile rõõmu ja elevust. Palju huvitavam on, kui emulaator aitab teadlasel näha mälus andmeid või luua voogude koostoimeid.

Näitame, kuidas dünaamiliselt luua RTOS-ülesannete koostoime. Eelnevalt tuleks peatada koodi täitmine, kui see on käivitatud. Kui minna funktsiooni bluetooth_task_entry LED käskluse töötlemise haru (aadress 0x080057B8), siis võib näha, et esmalt luuakse ja seejärel saadetakse süsteemi järjekorda ledControlQueueHandle mingi sõnum.

Peaksite seadma katkestuse, kui juurdepääsete muutuja ledControlQueueHandle, mis asub aadressil 0x20000624 ja jätkama koodi täitmisega:

Tulemusena peatub esmalt aadressil 0x080057CA enne funktsiooni väljakutset osMailAlloc, edasi — aadressil 0x08005806 enne funktsiooni väljakutset osMailPut, seejärel mõne aja pärast — aadressil 0x08005BD4 (enne funktsiooni väljakutset osMailGet), mis kuulub funktsioonile leds_task_entry (LED-ülesanne), st toimus ülesannete vahetus, ja nüüd on juhtimine saanud LED-ülesanne.

Nii lihtsa meetodi abil saab paika panna, kuidas RTOS-ülesanded omavahel suhtlevad.

Muidugi võib ülesannete vaheline suhtlemine reaalsuses olla keerulisem, kuid emulatori kasutamine muudab selle jälgimise vähem vaevarikkaks.

Siin võite vaadata väikest videot emulatori käivitamisest ja suhtlemisest IDA Pro-ga.

Käivitamine Radare2-ga

Ei saa mööda minna sellisest universaalsest tööriistast nagu Radare2.

Emulaatoriga ühendamiseks r2 abil näeb käsk välja selline:

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

Praegu on saadaval käivitamine (dc) ja täitmise peatamine (Ctrl+C).

Kahjuks on r2-l hetkel probleeme riistvaralise gdb-serveri ja mälu kaardistamisega, mistõttu ei tööta murdepunkid ja sammud (käsk ds). Loodame, et see probleem lahendatakse lähitulevikus.

Käivitamine Eclipse'ist

Üks viis emulaatori kasutamiseks on arendatava seadme tarkvara silumine. Näitlikkuse huvides kasutame ka «Nohik» tarkvara. Tarkvara allikakoodid on saadaval siit.

IDE-na kasutame Eclipse'i komplektist System Workbench for STM32.

Et emulaatorisse laadida Eclipse'is koostatud tarkvara, tuleb lisada parameeter firmware=null emulaatori käivituskäskemesse:

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

Debug-konfiguratsiooni seadistamine

Eclipse'is valige menüü Run — Debug Configurations… Avanevas aknas tuleb jaotises GDB Hardware Debugging lisada uus konfiguratsioon, seejärel tuleb vahekaardil «Main» määrata praegune projekt ja silumisprogramm:

Vahekaardil «Debugger» tuleb märkida GDB-käsk:
${openstm32_compiler_path}arm-none-eabi-gdb

Ja ka sisestada ühenduse parameetrid GDB-serveriga (host ja port):

Vahe „Startup“ all tuleb märkida järgmised sätted:

• määrake linnuke Laadi pilt (et laadimine toimuks emulaatorisse kokku pandud pildifailist);
• määrake linnuke Laadi sümbolid;
• lisage käivitamiskäsk: set $pc = *0x08000004 (määrake registri PC väärtuseks mälu aadressilt 0x08000004 — seal hoitakse aadressi ResetHandler’ile).

Pange tähele, kui te ei soovi Eclipse’ist pildifaili laadida, siis sätteid Laadi pilt ja Käivita käsk ei pea määrama.

Pärast nupu Debug vajutamist saab töötada silumise režiimis:

• koodi samm-sammuline täitmine
  
• kohtumistega suhtlemine
  

Märkus. Eclipse’is on, hmm… mõned eripärad… ja nendega tuleb elada. Näiteks, kui silumisse sisenemisel kuvatakse teade „No source available for „0x0““, siis täitke käsk Step (F5)

Kokkuvõtte asemel

Kohaliku koodi emuleerimine on väga huvitav tegevus. Seadmese arendajale avaneb võimalus siluda saadetisi ilma reaalse seadmeta. Uurijale - võimalus teha dünaamilist koodianalüüsi, mis ei ole alati võimalik isegi seadme olemasolul.

Soovime pakkuda spetsialistidele tööriista, mis oleks mugav, suhteliselt lihtne ja ei nõuaks palju aega ja vaeva seadistamiseks ja käivitamiseks.

Jagage oma kogemustest riistvaraemulaatorite kasutamisel kommentaarides. Ootame arutelu ja vastame hea meelega küsimustele.

Ainult registreeritud kasutajad saavad küsitluses osaleda. Logige sisse, palun.

Miks te kasutate emulaatorit?

• arendan (teisendan) püsivara

• uurin püsivara

• käitan mänge (Dendi, Sega, PSP)

• midagi muud (kirjutage kommentaaridesse)

Hääletas 7 kasutajat. 2 kasutajat ei hääletanud.

Millist tarkvara te kasutate natiivkoodi emuleerimiseks?

• QEMU

• Unicorn engine

• Proteus

• midagi muud (kirjutage kommentaaridesse)

Hääletas 6 kasutajat. 2 kasutajat jätsid hääletamata.

Mida sooviksite emulaatoris parandada?

• sooviksin kiirus

• sooviksin mugavust seadistamisel/käivitamisel

• sooviksin rohkem interaktsiooni võimalusi emulaatoriga (API, hook'id)

• olen rahul kõigega

• midagi muud (kirjutage kommentaaridesse)

Olenenud 8 kasutajalt. 1 kasutaja hoidub.

Allikas: habr.com