🥇Faru ndani ya paka - zindua programu dhibiti katika kiigaji cha Kopycat

Kama sehemu ya mkutano 0x0A DC7831 DEF CON Nizhny Novgorod Mnamo Februari 16, tuliwasilisha ripoti juu ya kanuni za msingi za uigaji wa msimbo wa binary na maendeleo yetu wenyewe - kiigaji cha jukwaa la maunzi. Copycat.

Katika makala hii tutaelezea jinsi ya kuendesha firmware ya kifaa katika emulator, kuonyesha mwingiliano na debugger, na kufanya uchambuzi mfupi wa nguvu wa firmware.

kabla ya historia

muda mrefu uliopita katika galaxy mbali mbali

Miaka michache iliyopita katika maabara yetu kulikuwa na haja ya kuchunguza firmware ya kifaa. Firmware ilibanwa na kupakuliwa na bootloader. Alifanya hivyo kwa njia ngumu sana, akibadilisha data kwenye kumbukumbu mara kadhaa. Na firmware yenyewe basi iliingiliana kikamilifu na vifaa vya pembeni. Na haya yote kwenye msingi wa MIPS.

Kwa sababu za kusudi, emulators zilizopo hazikufaa, lakini bado tulitaka kutekeleza nambari. Kisha tuliamua kufanya emulator yetu wenyewe, ambayo ingefanya kiwango cha chini na kuruhusu sisi kufuta firmware kuu. Tulijaribu na ilifanya kazi. Tulifikiria, vipi ikiwa tutaongeza vifaa vya pembeni ili kutekeleza firmware kuu. Haikuumiza sana - na ilifanya kazi pia. Tulifikiria tena na tukaamua kutengeneza emulator kamili.

Matokeo yake yalikuwa emulator ya mifumo ya kompyuta Copycat.

Kwa nini Kopycat?

Kuna mchezo wa maneno.

copycat (Kiingereza, nomino [ˈkɒpɪkæt]) - mwigaji, mwigaji
paka (Kiingereza, nomino [ˈkæt]) - paka, paka - mnyama anayependwa na mmoja wa waundaji wa mradi
Herufi "K" inatoka kwa lugha ya programu ya Kotlin

Copycat

Wakati wa kuunda emulator, malengo maalum yaliwekwa:

uwezo wa kuunda haraka pembeni mpya, moduli, cores za processor;
uwezo wa kukusanya kifaa cha kawaida kutoka kwa moduli mbalimbali;
uwezo wa kupakia data yoyote ya binary (firmware) kwenye kumbukumbu ya kifaa cha kawaida;
uwezo wa kufanya kazi na snapshots (snapshots ya hali ya mfumo);
uwezo wa kuingiliana na emulator kupitia debugger iliyojengwa;
lugha nzuri ya kisasa kwa maendeleo.

Kwa hivyo, Kotlin ilichaguliwa kwa utekelezaji, usanifu wa basi (hapa ndipo moduli zinapowasiliana kupitia mabasi pepe ya data), JSON kama umbizo la maelezo ya kifaa, na GDB RSP kama itifaki ya kuingiliana na kitatuzi.

Maendeleo yamekuwa yakiendelea kwa zaidi ya miaka miwili na yanaendelea kikamilifu. Wakati huu, cores za MIPS, x86, V850ES, ARM, na PowerPC zilitekelezwa.

Mradi unakua na ni wakati wa kuuwasilisha kwa umma mpana. Tutafanya maelezo ya kina ya mradi baadaye, lakini kwa sasa tutazingatia kutumia Kopycat.

Kwa wasio na subira zaidi, toleo la ofa la kiigaji linaweza kupakuliwa kutoka kiungo.

Rhino katika emulator

Hebu tukumbuke kwamba mapema kwa mkutano wa SMARTRHINO-2018, kifaa cha mtihani "Rhinoceros" kiliundwa kwa ajili ya kufundisha ujuzi wa uhandisi wa reverse. Mchakato wa uchambuzi wa firmware tuli ulielezewa katika Makala hii.

Sasa hebu jaribu kuongeza "wasemaji" na kukimbia firmware katika emulator.

Tutahitaji:
1) Java 1.8
2) Chatu na moduli jep kutumia Python ndani ya emulator. Unaweza kuunda moduli ya WHL Jep kwa Windows pakua hapa.

Kwa Windows:
1) com0com
2) PuTTY

Kwa Linux:
1) soketi

Unaweza kutumia Eclipse, IDA Pro au radare2 kama mteja wa GDB.

Jinsi gani kazi?

Ili kutekeleza firmware katika emulator, ni muhimu "kukusanya" kifaa cha kawaida, ambacho ni analog ya kifaa halisi.

Kifaa halisi ("kifaru") kinaweza kuonyeshwa kwenye mchoro wa block:

Kiigaji kina muundo wa kawaida na kifaa cha mwisho pepe kinaweza kuelezewa katika faili ya JSON.

JSON 105 mistari

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

Makini na parameter firmware sehemu viunga ni jina la faili inayoweza kupakiwa kwenye kifaa pepe kama programu dhibiti.

Kifaa halisi na mwingiliano wake na mfumo mkuu wa uendeshaji unaweza kuwakilishwa na mchoro ufuatao:

Mfano wa sasa wa majaribio wa emulator unahusisha mwingiliano na milango ya COM ya OS kuu (tatua UART na UART kwa moduli ya Bluetooth). Hizi zinaweza kuwa bandari halisi ambazo vifaa vimeunganishwa au bandari za COM za kawaida (kwa hili unahitaji tu com0com/socat).

Hivi sasa kuna njia mbili kuu za kuingiliana na emulator kutoka nje:

Itifaki ya GDB RSP (kwa hivyo, zana zinazounga mkono itifaki hii ni Eclipse / IDA / radare2);
mstari wa amri ya emulator ya ndani (Argparse au Python).

Bandari za COM za kweli

Ili kuingiliana na UART ya kifaa pepe kwenye mashine ya ndani kupitia terminal, unahitaji kuunda jozi ya bandari za mtandaoni za COM zinazohusiana. Kwa upande wetu, bandari moja hutumiwa na emulator, na ya pili hutumiwa na programu ya terminal (PuTTY au skrini):

Kwa kutumia com0com

Bandari za Virtual COM zimesanidiwa kwa kutumia matumizi ya usanidi kutoka kwa com0com kit (toleo la koni - C: Faili za Programu (x86) com0comsetupс.exe, au toleo la GUI - C:Faili za Programu (x86)com0comsetupg.exe):

Angalia masanduku wezesha kuzidisha kwa bafa kwa bandari zote za mtandaoni zilizoundwa, vinginevyo emulator itasubiri jibu kutoka kwa bandari ya COM.

Kwa kutumia socat

Kwenye mifumo ya UNIX, bandari dhahania za COM huundwa kiotomatiki na emulator kwa kutumia matumizi ya socat; ili kufanya hivyo, taja kiambishi awali katika jina la bandari wakati wa kuanzisha emulator. socat:.

Kiolesura cha mstari wa amri ya ndani (Argparse au Python)

Kwa kuwa Kopycat ni programu ya console, emulator hutoa chaguzi mbili za interface ya mstari wa amri kwa kuingiliana na vitu na vigezo vyake: Argparse na Python.

Argparse ni CLI iliyojengwa ndani ya Kopycat na inapatikana kwa kila mtu kila wakati.

CLI mbadala ni mkalimani wa Python. Ili kuitumia, unahitaji kusakinisha moduli ya Jep Python na usanidi emulator kufanya kazi na Python (mkalimani wa Python aliyesakinishwa kwenye mfumo mkuu wa mtumiaji atatumika).

Kufunga moduli ya Python Jep

Chini ya Linux Jep inaweza kusanikishwa kupitia bomba:

pip install jep

Ili kusakinisha Jep kwenye Windows, lazima kwanza usakinishe Windows SDK na Microsoft Visual Studio inayolingana. Tumekurahisishia kidogo na WHL inajenga JEP kwa matoleo ya sasa ya Python kwa Windows, kwa hivyo moduli inaweza kusanikishwa kutoka kwa faili:

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

Kuangalia usakinishaji wa Jep, unahitaji kukimbia kwenye mstari wa amri:

python -c "import jep"

Ujumbe ufuatao unapaswa kupokelewa kwa kujibu:

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

Katika faili ya kundi la emulator ya mfumo wako (copycat.bat - kwa Windows, nakala - kwa Linux) kwa orodha ya vigezo DEFAULT_JVM_OPTS ongeza parameter ya ziada Djava.library.path - lazima iwe na njia ya moduli ya Jep iliyosakinishwa.

Matokeo ya Windows inapaswa kuwa mstari kama huu:

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

Inazindua Kopycat

Emulator ni programu ya JVM ya console. Uzinduzi unafanywa kupitia hati ya mstari wa amri ya mfumo wa uendeshaji (sh/cmd).

Amri ya kukimbia chini ya Windows:

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

Amri ya kukimbia chini ya Linux kwa kutumia matumizi ya 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 - bandari ya TCP ambayo itakuwa wazi kwa ufikiaji wa seva ya GDB;
-n rhino - jina la moduli kuu ya mfumo (kifaa kilichokusanyika);
-l user - jina la maktaba ya kutafuta moduli kuu;
-y library - njia ya kutafuta moduli zilizojumuishwa kwenye kifaa;
firmwarerhino_pass.bin - njia ya faili ya firmware;
COM26 na COM28 ni bandari za COM pepe.

Kama matokeo, kidokezo kitaonyeshwa Python > (Au 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 >

Mwingiliano na IDA Pro

Ili kurahisisha majaribio, tunatumia programu dhibiti ya Rhino kama faili chanzo cha uchanganuzi katika IDA katika fomu Faili ya ELF (habari ya meta imehifadhiwa hapo).

Unaweza pia kutumia firmware kuu bila maelezo ya meta.

Baada ya kuzindua Kopycat katika IDA Pro, kwenye menyu ya Debugger nenda kwa kipengee "Badili kitatuzi..."na chagua"Kitatuzi cha mbali cha GDB". Ifuatayo, weka unganisho: menyu Kitatuzi - Chaguzi za kuchakata...

Weka maadili:

Maombi - thamani yoyote
Jina la mpangishi: 127.0.0.1 (au anwani ya IP ya mashine ya mbali ambapo Kopycat inafanya kazi)
Port: 23946

Sasa kitufe cha utatuzi kinapatikana (ufunguo wa F9):

Bofya ili kuunganisha kwenye moduli ya kitatuzi katika kiigaji. IDA inaingia kwenye hali ya kurekebisha, madirisha ya ziada yanapatikana: habari kuhusu rejista, kuhusu stack.

Sasa tunaweza kutumia vipengele vyote vya kawaida vya debugger:

utekelezaji wa hatua kwa hatua wa maagizo (Ingia и Hatua juu - funguo F7 na F8, kwa mtiririko huo);
kuanza na kusitisha utekelezaji;
kuunda sehemu za kuvunja kwa nambari na data zote (ufunguo F2).

Kuunganisha kwa kitatuzi haimaanishi kuendesha msimbo wa programu dhibiti. Nafasi ya sasa ya utekelezaji lazima iwe anwani 0x08006A74 - kuanza kwa kazi Weka Upya_Kishughulikiaji. Ukisogeza chini tangazo, unaweza kuona simu ya kukokotoa kuu. Unaweza kuweka mshale kwenye mstari huu (anwani 0x08006ABE) na kufanya operesheni Endesha hadi kielekezi (ufunguo F4).

Ifuatayo, unaweza kubonyeza F7 ili kuingiza kitendakazi kuu.

Ikiwa unaendesha amri Endelea mchakato (Funguo la F9), kisha dirisha la "Tafadhali subiri" litaonekana na kifungo kimoja kuahirisha:

Unapobonyeza kuahirisha Utekelezaji wa msimbo wa firmware umesimamishwa na unaweza kuendelea kutoka kwa anwani sawa katika msimbo ambapo uliingiliwa.

Ukiendelea kutekeleza msimbo, utaona mistari ifuatayo kwenye vituo vilivyounganishwa kwenye bandari pepe za COM:

Uwepo wa mstari wa "hali ya kupita" unaonyesha kuwa moduli ya Bluetooth ya kawaida imebadilika kwa hali ya kupokea data kutoka kwa bandari ya COM ya mtumiaji.

Sasa katika terminal ya Bluetooth (COM29 kwenye picha) unaweza kuingiza amri kwa mujibu wa itifaki ya Rhino. Kwa mfano, amri ya "MEOW" itarudisha kamba "mur-mur" kwenye terminal ya Bluetooth:

Niige si kabisa

Wakati wa kujenga emulator, unaweza kuchagua kiwango cha maelezo / uigaji wa kifaa fulani. Kwa mfano, moduli ya Bluetooth inaweza kuigwa kwa njia tofauti:

kifaa kinaigwa kikamilifu na seti kamili ya amri;
Amri za AT zinaigwa, na mkondo wa data unapokelewa kutoka kwa bandari ya COM ya mfumo mkuu;
kifaa cha kawaida hutoa uelekezaji kamili wa data kwa kifaa halisi;
kama mbegu rahisi ambayo inarudi kila wakati "Sawa".

Toleo la sasa la emulator hutumia mbinu ya pili - moduli ya Bluetooth ya kawaida hufanya usanidi, baada ya hapo inabadilika kwa hali ya data ya "proxying" kutoka kwa bandari ya COM ya mfumo mkuu hadi bandari ya UART ya emulator.

Wacha tuzingatie uwezekano wa utumiaji rahisi wa nambari ikiwa sehemu fulani ya pembezoni haitatekelezwa. Kwa mfano, ikiwa kipima saa kinachohusika na kudhibiti uhamishaji data kwa DMA hakijaundwa (angalia ukaguzi unafanywa katika kitendakazi. ws2812b_subiriiko katika 0x08006840), basi firmware itasubiri kila wakati bendera kuwekwa upya busyiko katika 0x200004C4ambayo inaonyesha ukaaji wa laini ya data ya DMA:

Tunaweza kukabiliana na hali hii kwa kuweka upya bendera sisi wenyewe busy mara baada ya kuiweka. Katika IDA Pro, unaweza kuunda kazi ya Python na kuiita katika eneo la mapumziko, na kuweka sehemu ya mapumziko yenyewe kwenye nambari baada ya kuandika dhamana 1 kwenye bendera. busy.

Kidhibiti cha mapumziko

Kwanza, wacha tuunde kazi ya Python katika IDA. Menyu Faili - Amri ya Hati...

Ongeza kijisehemu kipya kwenye orodha iliyo upande wa kushoto, ipe jina (kwa mfano, BPT),
Katika sehemu ya maandishi upande wa kulia, ingiza msimbo wa kazi:

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

Baada ya hapo, bofya Kukimbia na funga dirisha la maandishi.

Sasa hebu tuende kwenye kanuni 0x0800688A, weka sehemu ya kuvunja (ufunguo wa F2), uhariri (menyu ya muktadha Hariri sehemu ya kuvunja...), usisahau kuweka aina ya hati kwa Python:

Ikiwa thamani ya bendera ya sasa busy sawa na 1, basi unapaswa kutekeleza chaguo la kukokotoa ruka_dma katika mstari wa maandishi:

Ikiwa utaendesha firmware kwa utekelezaji, basi uanzishaji wa nambari ya kidhibiti cha sehemu ya kuvunja inaweza kuonekana kwenye dirisha la IDA. pato kwa mstari Skipping wait ws2812.... Sasa firmware haitasubiri bendera kuwekwa upya busy.

Mwingiliano na emulator

Uigaji kwa ajili ya kuigwa hauwezekani kuleta furaha na furaha. Inafurahisha zaidi ikiwa emulator husaidia mtafiti kuona data kwenye kumbukumbu au kuanzisha mwingiliano wa nyuzi.

Tutakuonyesha jinsi ya kuanzisha mwingiliano kati ya kazi za RTOS. Unapaswa kwanza kusitisha utekelezaji wa nambari ikiwa inaendeshwa. Ukienda kwenye shughuli bluetooth_task_entry kwa tawi la usindikaji la amri ya "LED" (anwani 0x080057B8), basi unaweza kuona kile kilichoundwa kwanza na kisha kutumwa kwenye foleni ya mfumo ledControlQueueHandle ujumbe fulani.

Unapaswa kuweka sehemu ya kuvunja ili kufikia utofauti ledControlQueueHandleiko katika 0x20000624 na uendelee kutekeleza nambari:

Matokeo yake, kuacha kutatokea kwanza kwenye anwani 0x080057CA kabla ya kupiga kazi osMailAlloc, kisha kwa anwani 0x08005806 kabla ya kupiga kazi osMailPut, kisha baada ya muda - kwa anwani 0x08005BD4 (kabla ya kupiga simu osMailGet), ambayo ni ya kazi leds_task_entry (LED-kazi), yaani, kazi zilibadilishwa, na sasa kazi ya LED ilipokea udhibiti.

Kwa njia hii rahisi unaweza kuanzisha jinsi kazi za RTOS zinavyoingiliana.

Kwa kweli, kwa kweli, mwingiliano wa kazi unaweza kuwa ngumu zaidi, lakini kwa kutumia emulator, kufuatilia mwingiliano huu inakuwa ngumu kidogo.

Hapa Unaweza kutazama video fupi ya emulator ikizindua na kuingiliana na IDA Pro.

Zindua na Radare2

Hauwezi kupuuza zana ya ulimwengu wote kama Radare2.

Ili kuunganishwa na emulator kwa kutumia r2, amri ingeonekana kama hii:

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

Uzinduzi unapatikana sasa (dc) na sitisha utekelezaji (Ctrl+C).

Kwa bahati mbaya, kwa sasa, r2 ina shida wakati wa kufanya kazi na seva ya gdb ya vifaa na mpangilio wa kumbukumbu; kwa sababu ya hii, sehemu za mapumziko na Hatua hazifanyi kazi (amri). ds) Tunatumahi hili litarekebishwa hivi karibuni.

Kukimbia na Eclipse

Moja ya chaguzi za kutumia emulator ni kurekebisha firmware ya kifaa kinachotengenezwa. Kwa uwazi, tutatumia pia firmware ya Rhino. Unaweza kupakua vyanzo vya firmware hivyo.

Tutatumia Eclipse kutoka kwa seti kama IDE Mfumo wa Workbench kwa STM32.

Ili emulator kupakia firmware iliyokusanywa moja kwa moja katika Eclipse, unahitaji kuongeza parameter firmware=null kwa amri ya uzinduzi wa emulator:

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

Kuweka usanidi wa utatuzi

Katika Eclipse, chagua menyu Endesha - Mipangilio ya Utatuzi... Katika dirisha linalofungua, katika sehemu Utatuzi wa maunzi ya GDB unahitaji kuongeza usanidi mpya, kisha kwenye kichupo cha "Kuu" taja mradi wa sasa na programu ya utatuzi:

Kwenye kichupo cha "Debugger" unahitaji kutaja amri ya GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

Na pia ingiza vigezo vya kuunganisha kwenye seva ya GDB (mwenyeji na bandari):

Kwenye kichupo cha "Anza", lazima ueleze vigezo vifuatavyo:

wezesha kisanduku cha kuteua Pakia picha (hivyo kwamba picha ya firmware iliyokusanyika imewekwa kwenye emulator);
wezesha kisanduku cha kuteua Alama za mzigo;
ongeza amri ya uzinduzi: set $pc = *0x08000004 (weka rejista ya PC kwa thamani kutoka kwa kumbukumbu kwenye anwani 0x08000004 - anwani imehifadhiwa hapo ResetHandler).

Makini, ikiwa hutaki kupakua faili ya firmware kutoka Eclipse, basi chaguzi Pakia picha и Endesha amri hakuna haja ya kuashiria.

Baada ya kubofya Debug, unaweza kufanya kazi katika hali ya utatuzi:

utekelezaji wa hatua kwa hatua wa nambari
kuingiliana na sehemu za kuvunja

Kumbuka. Eclipse ina, mh... baadhi ya mambo ya ajabu... na inabidi uishi nayo. Kwa mfano, ikiwa unapoanzisha kitatuzi ujumbe "Hakuna chanzo kinachopatikana cha "0x0"" kinaonekana, kisha tekeleza amri ya Hatua (F5)

Badala ya hitimisho

Kuiga msimbo asilia ni jambo la kufurahisha sana. Inakuwa inawezekana kwa msanidi wa kifaa kurekebisha firmware bila kifaa halisi. Kwa mtafiti, ni fursa ya kufanya uchambuzi wa kanuni za nguvu, ambazo haziwezekani kila wakati hata kwa kifaa.

Tunataka kuwapa wataalamu zana ambayo ni rahisi, rahisi kiasi na haichukui juhudi nyingi na wakati wa kusanidi na kuendesha.

Andika kwenye maoni kuhusu uzoefu wako kwa kutumia emulators za maunzi. Tunakualika kujadili na tutafurahi kujibu maswali.

Watumiaji waliojiandikisha pekee ndio wanaweza kushiriki katika utafiti. Weka sahihitafadhali.

Unatumia emulator kwa nini?

Ninakuza (debug) firmware
Ninatafiti firmware
Ninazindua michezo (Dendi, Sega, PSP)
kitu kingine (andika kwenye maoni)

Watumiaji 7 walipiga kura. Watumiaji 2 walijizuia.

Je, unatumia programu gani kuiga msimbo asilia?

QEMU
Injini ya nyati
Proteus
kitu kingine (andika kwenye maoni)

Watumiaji 6 walipiga kura. Watumiaji 2 walijizuia.

Je, ungependa kuboresha nini katika kiigaji unachotumia?

Nataka kasi
Ninataka urahisi wa kusanidi / kuzindua
Ninataka chaguzi zaidi za kuingiliana na emulator (API, ndoano)
Nina furaha na kila kitu
kitu kingine (andika kwenye maoni)

Watumiaji 8 walipiga kura. Mtumiaji 1 alijizuia.

Chanzo: mapenzi.com

Kifaru ndani ya paka - endesha firmware katika emulator ya Kopycat