Narkootikum kassipoja sees — käivitame püsivara emulaatoris Kopycat

Kohtumise raames 0x0A DC7831 DEF CON Nizhni Novgorod 16. veebruaril esitlesime ettekannet binaarkoodi emulatsiooni põhialustest ja meie arengust - riistvaraplatvormide emulaatorist. Kopycat.

Artiklis kirjeldame seadme püsivara käivitamist emulaatoris, demonstreerime suhtlemist siluri ja teeme väikese dünaamilise analüüsi püsivara üle.

Eellugu

Kaua aega tagasi kaugel-galaktikas

Mõni aasta tagasi oli meie laboris vajadus uurida seadme püsivara. Püsivara oli tihendatud, lahti pakitud bootloader'iga. Ta tegi seda üsna keerulisel moel, paar korda andmeid mälus ümber paigutades. Ja ise püsivara suhtles aktiivselt perifeeriaga. Ja kõik see MIPSi tuumal.

Käesolevad emulaatorid ei rahuldanud meid objektiivsetel põhjustel, kuid soovisime ikkagi koodi käivitada. Siis otsustasime teha oma emulaatori, mis teeks minimaalselt ja võimaldaks põhivara lahti pakkida. Proovisime - see töötas. Mõtlesime, mis siis, kui lisada perifeeria, et ka põhivara töötlema hakata. See ei olnud eriti keeruline - ja ka see töötas. Taaskord mõtlesime ja otsustasime teha täisfunktsionaalse emulaatori.

Tulemusena saime arvutisüsteemide emulaatori Kopycat.

Miks Kopycat?

See on sõnamäng.

1. copycat (inglise, subst. [ˈkɒpɪkæt]) - imiteerija, jäljendaja
2. cat (inglise, subst. [ˈkæt]) - kass, kiisu - üks projekti looja lemmiklooma nimi
3. Täht „K“ on saadud programmeerimiskeelest Kotlin

Kopycat

Emulaatori loomisel seati täiesti konkreetsed eesmärgid:

• võimalus üsna kiiresti luua uus perifeeria, moodul, protsessorituum;
• võimalus kokku panna virtuaalne seade erinevatest moodulitest;
• võimalus laadida virtuaalse seadme mällu kõiki binaarseid andmeid (püsivara);
• võimalus töötada snapshootidega (süsteemi olekute pildid);
• võimalus suhelda emulaatoriga läbi sisseehitatud siluri;
• mugav ja kaasaegne programmeerimiskeel arendamiseks.

Lõpuks valiti elluviimiseks Kotlin, bussiarhitektuur (see tähendab, et moodulid ühendatakse omavahel virtuaalsete andmebusside kaudu), JSON - seadme kirjeldamise formaadina, ja GDB RSP - siluri suhtlusprotokollina.

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

Projekt kasvab ja on aeg tutvustada seda laiemale publikule. Projekti üksikasjalik kirjeldus tuleb hiljem, aga praegu keskendume Kopycat'i kasutamisele.

Kõige kannatamatutele — emulaatori promoversioon on saadaval allalaadimiseks lingil.

Ninasarvik emulaatoris

Kasutame meelde tuletamiseks, et varem loodi konverentsiks SMARTRHINO-2018 testseade "Ninasarvik" reversseerituse oskuste õppimiseks. Juhendi staatilise analüüsi jaoks kirjeldati. selles artiklis.

Käesolevaga proovime aga lisada "dünaamikat" ja käivitame püsivara emulaatoris.

Meile on vajalikud:
1) Java 1.8
2) Python ja moodul Jep Python'i kasutamiseks emulaatoris. WHL-ehitatud Jep mooduli versioon Windowsile on saadaval. 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?

Püsivara emulaatoris täitmiseks on vajalik "kokku panna" virtuaalne seade, mis esindab reaalset seadet.

Reaalset seadet ("ninasarvik") saab näidata struktuuriskeemis:

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

JSON 105 real

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

Pange tähele parameetrit firmware jaotises params — see on faili nimi, mille saab laadida virtuaalsesse seadmesse püsivara vormis.

Virtuaalne seade ja selle koostoime põhiosakonnaga on esitatud järgmisel skeemil:

Praegune emulaatori testimise eksemplar eeldab koostoimet põhiosakonna COM-portidega (silumis UART ja UART Bluetooth-mooduli jaoks). Need võivad olla reaalsed portid, kuhu seadmed on ühendatud, või siis virtuaalsed COM-portid (just selleks on vajalik com0com / socat).

Praegu on emulaatoriga välise koostoime jaoks kaks peamist viisi:

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

Virtuaalsed COM-portid

Kuna virtuaalse seadme UART-iga koostoime loomiseks kohaliku masina terminaliga on vajalik luua seotud virtuaalsete COM-portide paar. Meie juhul kasutab ühte porti emulaator ja teist — terminali programm (PuTTY või screen):

com0com kasutamine

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

Tuleb märkida linnukesed enable buffer overrun kõikide loodud virtuaalsete portide jaoks, vastasel juhul ootab emulaator vastust COM-portidelt.

socat kasutamine

UNIX-süsteemides luuakse virtuaalsed COM-portid emulaatori poolt automaatselt socat utiliidi abil, selleks piisab emulaatori käivitamisel portide nimes prefiksi määramisest socat:.

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

Kuna Kopycat on konsooli rakendus, pakub emulaator oma objektide ja muutujatega koostoime loomiseks kahte käsurea liidese võimalust: Argparse ja Python.

Argparse on Kopycati sisse ehitatud CLI, mis on alati ja kõigile kergesti ligipääsetav.

Alternatiivne CLI on Python'i tõlk. Selle kasutamiseks tuleb installida Python'i moodul Jep ja seadistada emulaator töötama Pythoniga (kasutatakse kasutaja põhiosakonnas installitud Python'i tõlget).

Python'i mooduli Jep installimine

Linuxis saab Jep'i installida pip'i kaudu:

pip install jep

Jepi installimiseks Windowsis tuleb eelnevalt installida Windows SDK ja vastav Microsoft Visual Studio. Oleme teie ülesande pisut lihtsustanud ja teinud WHL-pakkumised JEP aktuaalsete Python versioonide jaoks Windowsis, seega saab mooduli installida failist:

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

Jep'i installatsiooni kontrollimiseks peate käivitama käsureal:

python -c "import jep"

Vastuseks peaks tulema sõnum:

ImportError: Jep ei ole iseseisvas Python'is toetatud, see peab olema Java'sse sisse embeditud.

Teie süsteemi emulaatori käsklusfailis (kopycat.bat — Windowsi jaoks, kopycat — Linuxi jaoks) lisage parameetrite loendisse DEFAULT_JVM_OPTS lisaks veel üks parameeter Djava.library.path — see peab sisaldama teed installitud mooduli Jep'i juurde.

Seega peaks Windowsi jaoks saama 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 konsoolipõhine JVM rakendus. Käivitamine toimub operatsioonisüsteemi käsurea skripti kaudu (sh/cmd).

Käivitamis käsk Windowsis:

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

Käivitamis käsk Linuxis, 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-serveri juurde pääsemiseks;
• -n rhino — põhikomplekti seadme nimi;
• -l user — põhikomplekti otsingu raamatukogu nimi;
• -y library — seadme moodulite otsingu tee;
• firmwarerhino_pass.bin — muudete faili tee;
• COM26 ja COM28 — virtuaalsed COM-pordid.

Tulemuseks on väljund: Python > (või Argparse >):

18:07:59 INFO [eFactoryBuilder.create]: Moodul top loodi edukalt kui top
18:07:59 INFO [Module.initializeAndRes]: Seadistatakse core 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]: Tracerit ei leitud top'i...
18:07:59 INFO [Module.initializeAndRes]: Portide ja busside algatamine...
18:07:59 WARN [Module.initializePortsA]: TÄHELEPANU: Mõnedel portidel on hoiatuseid, kasutage printModulesPortsWarnings neid näha...
18:07:59 FINE [ARMv6CPU.reset]: Sisendpunkti aadress on seatud 08006A75
18:07:59 INFO [Module.initializeAndRes]: Moodul top on edukalt algatatud ja lähtestatud kui top rakk!
18:07:59 INFO [Kopycat.open]: Alustatakse plaadi top[rhino] virtualiseerimist arm[ARMv6Core]
18:07:59 INFO [GDBServer.debuggerModule]: Uus debugeerija moodul top.u1_stm32.dbg on seadistatud GDB_SERVER(port=23946,alive=true)
Python >

Koostoime IDA Pro-ga

Analüüsi lähtefailina IDAs kasutame testimise lihtsustamiseks «Rhinole» mõeldud firmware'i ELF-failina (seal on salvestatud metaainfo).

Samuti võite kasutada põhifirmware'i ilma metaandmeteta.

Pärast Kopycat'i käivitamist IDA Pro's liigume Debugger menüüs punkti «Switch debugger…» ja valime «Kaug-GDB debugger«. Jätkame ühenduse seadistamist: menüü Debugeerija — Protsessi valikud…

Seame väärtused:

• Rakendus — ükskõik milline väärtus
• Hostname: 127.0.0.1 (või kaugmasina IP-aadress, kus Kopycat on käimas)
• Port: 23946

Nüüd on käivitamise nupp (klahv F9) saadaval:

Klikkame sellele — ühendame debugeerimise mooduliga emulaatoris. IDA läheb debugeerimise režiimi, avanevad lisakraanid: registerteave, stek.

Nüüd saame kasutada kõiki standardseid debugeerimisvõimalusi:

• juhuslikult teostada juhiseid (Step into ja Step over — klahvid F7 ja F8, vastavalt);
• käivitamine ja täitmise peatamine;
• looge peatuspunkte nii koodi kui ka andmete jaoks (klahv F2).

Debugeerijaga ühendamine ei tähenda, et koodiraamat käivitub. Täitmiseks peab hetke aadress olema 0x08006A74 — funktsiooni algus Reset_Handler. Kui kerida loetelu alla, siis on näha funktsiooni kutset main. Kursor võib sellel real seista (aadress 0x08006ABE) ja teostada toimingu Run until cursor (klahv F4).

Jätkamiseks võib vajutada F7, et siseneda funktsiooni main.

Kui täita käsk Continue process (klahv F9), siis ilmub aken "Palun oota" ainulaadse nupuga Suspend:

Kuna vajutatakse, Suspend koodi täitmine peatub ja seda saab jätkata samalt aadressilt koodis, kus see katkestati.

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

Rida "state bypass" näitab, et virtuaalne Bluetooth-moodul on läinud kasutaja COM-portide andmete vastuvõtmise režiimi.

Nüüd saab Bluetooth-terminalis (pildil — COM29) sisestada käske vastavalt "Norsupätsi" protokollile. Näiteks käsule "MEOW" tagastatakse Bluetooth-terminalis rida "mur-mur":

Emuleeri mind mitte täielikult

Emulaatori loomisel saab valida seadme detailituse/emuletuse taset. Näiteks Bluetooth-moodulit saab emuleerida erinevalt:

• emuleeritakse seadet täielikult koos täieliku käsu kogumiga;
• emuleeritakse AT-käske, samas kui andmevoog võetakse peamise süsteemi COM-portist;
• virtuaalne seade tagab täieliku andmete edastamise reaalsele seadmele;
• lihtsa stubina, mis alati tagastab "OK".

Käesolevas emulaatori versioonis kasutatakse teist lähenemist — virtuaalne Bluetooth-modul konfigureerib, seejärel läheb andmete "proximeerimise" režiimi COM-pordist põh süsteemist emulaatori UART-porda.

Vaatame võimalust lihtsaks koodi instrumenteerimiseks, juhul kui mõni perifeeria osa ei ole teostatud. Näiteks, kui taimerit, mis vastutab andmete edastamise üle DMA, ei ole loodud (kontrollimine toimub funktsioonis ws2812b_wait, mis asub aadressil 0x08006840), siis jääb firmware alati ootama lipu lähtestamist busy, mis asub aadressil 0x200004C4, mis näitab DMA andmeliini hõivatust:

Saame selle olukorra vältida, "manuaalselt" lipu lähtestamisega busy koheselt pärast selle seadistamist. IDA Pro-s saab luua Python-funktsiooni ja seda kutsuda breakpoint'is, samas kui breakpoint tuleb paigutada koodi pärast väärtuse 1 kirjutamist lipule busy.

Breakpoint'i töötleja

Esiteks loome Python-funktsiooni IDA-s. Menüü File — Script command…

Lisame uue lõigu vasakpoolse nimekirja, anname sellele nime (näiteks, BPT),
ja parempoolsesse tekstiväljadese 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 Käita ja sulgeme skripti akna.

Nüüd liikume aadressile 0x0800688A, paigaldame breakpoint'i (klahv F2), redigeerime seda (konteksimenüü Edit breakpoint…), ärge unustage seada skripti tüüpi – Python:

Kui lipu praegune väärtus busy on 1, siis tuleb kutsuda funktsioon skip_dma skripti ridas:

Kui käivitada firmware'i täitmine, siis saab breakpoint'i töötleja koodi aktiveerimist näha IDA-s aknas Väljund rea järgi Skipping wait ws2812.... Nüüd ei ootata lipu lähtestamist busy.

Suhtlemine emulaatoriga

Emuleerimine emuleerimise nimel tõenäoliselt ei tekita rõõmu. Tunduvalt huvitavam on, kui emulaator aitab uurijal vaadata mälu andmeid või luua voogude vahel suhtlemist.

Kätkeme, kuidas dünaamiliselt seada RTOS-i ülesannete vahelisi suhteid. Eelnevalt tuleks koodi täitmine peatada, kui see on käivitunud. Kui minna funktsiooni bluetooth_task_entry LED käsitlemisvõsasse (aadress 0x080057B8), siis võib näha, et esmalt luuakse ja seejärel saadetakse süsteemi järjekorda ledControlQueueHandle mingi sõnum.

Tuleb paigaldada breakpoint muutuja seuradele ja jätkata koodi täitmist: ledControlQueueHandle, mis asub aadressil 0x20000624 ja jätkata koodi täitmist:

Seega toimub esmalt peatamine aadressil 0x080057CA enne funktsiooni kutsumist osMailAlloc, seejärel aadressil 0x08005806 enne funktsiooni kutsumist osMailPut, hiljem mõne aja pärast aadressil 0x08005BD4 (enne funktsiooni kutsumist osMailGet), mis kuulub funktsioonile leds_task_entry (LED-ülesanne), st toimus ülesannete vahetus ja nüüd sai juhtimise LED-ülesanne.

Nii lihtsal viisil saab määrata, kuidas RTOS-i ülesanded üksteisega suhtlevad.

Tõenäoliselt on ülesannete vaheline suhtlemine keerulisem, kuid simulaatori abil on selle jälgimine vähem koormav.

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

Käivitamine Radare2 abil

Ei saa üle vaadata sellist universaalset tööriista nagu Radare2.

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

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

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

Kahjuks on r2-ga hetkel probleeme, kui töötada riistvara gdb-serveriga ja mälu kaardistamisega, seetõttu ei tööta peatumise punktid ja Step'id (käsk ds). Loodame, et see parandatakse lähitulevikus.

Käivitamine Eclipse'iga

Üks võimalus simulaatori kasutamiseks on arendatava seadme püsivara silumine. Selguse huvides kasutame ka püsivara 'Norsut'. Püsivara lähtekoodi saab alla laadida siit.

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

Kuna käivitamiseks peab simulaatorisse laadima Eclipse'is otse kompileeritud püsivara, on vajalik lisada parameeter firmware=null simulaatori käivitamiskäsule:

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

Silumisprotsessi seadistamine

Eclipse'is valime menüüst Run — Debug Configurations… Avanevas aknas jaotises GDB Hardware Debugging on vajalik lisada uus konfigureerimine, mille järel vahekaardil 'Main' tuleb määrata praegune projekt ja silumisrakendus:

Vahekaardil 'Debugger' on vajalik määrata GDB-käsk:
${openstm32_compiler_path}arm-none-eabi-gdb

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

Vahekaardil 'Startup' on vajalik määrata järgmised parameetrid:

• märkida linnuke Load image (et simulaatorisse laaditaks kokku pandud püsivara kuva);
• märkida linnuke Load symbols;
• lisada käivitamiskäsk: set $pc = *0x08000004 (määrata PC registrisse väärtus mälust aadressilt 0x08000004 — seal on salvestatud aadress ResetHandler’i).

Pange tähele, kui te ei soovi laadida püsivara faili Eclipse’ist, siis parameetreid Load image ja Käivita käsud märkida ei ole vaja.

Pärast Debug nuppu vajutamist saab töötada silumine režiimis:

• koodi samm-sammuline täitmine
  
• koostöö peatuspunktega
  

Märkus. Eclipse’is on, hmm… mõned eripärad… ning nendega tuleb ellu jääda. Näiteks, kui silumi käivitamisel ilmub sõnum „No source available for „0x0″”, siis täitke käsk Step (F5)

Lõpetuseks

Natiivse koodi emuleerimine on väga huvitav asi. Seadmete arendajale annab see võimaluse siluda püsivara ilma reaalse seadmeta. Uurijale — võimalus läbi viia koodi dünaamiline analüüs, mis ei ole alati võimalik isegi seadmega.

Me tahame pakkuda spetsialistidele tööriista, mis oleks mugav, piisavalt lihtne ja ei nõuaks palju jõudu ja aega seadistamiseks ja käivitamiseks.

Kirjutage kommentaarides oma kogemustest riistvara emulaatorite kasutamisel. Ootame arutelu ja vastame rõõmuga küsimustele.

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

Milleks kasutate emulaatorit?

• arendan (silun) püsivara

• uurin püsivara

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

• midagi muud (kirjutage kommentaaridesse)

Hääletas 7 kasutajat. 2 kasutajat jäid erapooletuks.

Millist tarkvara kasutate natiivse koodi emuleerimiseks?

• QEMU

• Unicorn engine

• Proteus

• midagi muud (kirjutage kommentaaridesse)

Hääletanud 6 kasutajat. 2 kasutajat hoidusid.

Mida sooviksite parandada kasutatavas emulaatoris?

• soovin kiirus

• soovin seadistamise/käivitamise mugavust

• soovin rohkem võimalusi emulaatoriga suhtlemiseks (API, hookid)

• olen rahul kõigega

• midagi muud (kirjutage kommentaaridesse)

Hääletas 8 kasutajat. 1 kasutaja jäi erapooletuks.

Allikas: habr.com