🥇 बिरालो भित्र गैंडा - कोपीक्याट इमुलेटरमा फर्मवेयर सुरु गर्नुहोस्

बैठक 0x0A DC7831 को भाग को रूप मा DEF CON निजनी नोभगोरोड फेब्रुअरी 16 मा, हामीले बाइनरी कोड इमुलेशनको आधारभूत सिद्धान्तहरू र हाम्रो आफ्नै विकासको बारेमा एउटा रिपोर्ट प्रस्तुत गर्‍यौं - एक हार्डवेयर प्लेटफर्म इमुलेटर नक्कल.

यस लेखमा हामी इमुलेटरमा यन्त्र फर्मवेयर कसरी चलाउने, डिबगरसँग अन्तरक्रिया प्रदर्शन गर्ने र फर्मवेयरको सानो गतिशील विश्लेषण गर्ने भनेर वर्णन गर्नेछौं।

प्रागितिहास

धेरै पहिले एक आकाशगंगा मा धेरै टाढा

केही वर्ष पहिले हाम्रो प्रयोगशालामा यन्त्रको फर्मवेयरको अनुसन्धान गर्न आवश्यक थियो। फर्मवेयर कम्प्रेस गरिएको थियो र बुटलोडरसँग अनप्याक गरिएको थियो। उसले यो धेरै जटिल तरिकामा गर्यो, मेमोरीमा डाटा धेरै पटक सार्न। र फर्मवेयर आफैले सक्रिय रूपमा बाह्य उपकरणहरूसँग अन्तरक्रिया गर्यो। र यो सबै MIPS कोरमा।

वस्तुगत कारणहरूका लागि, उपलब्ध इमुलेटरहरूले हामीलाई अनुरूप गरेनन्, तर हामी अझै पनि कोड चलाउन चाहन्थ्यौं। त्यसपछि हामीले हाम्रो आफ्नै इमुलेटर बनाउने निर्णय गर्यौं, जसले न्यूनतम गर्छ र हामीलाई मुख्य फर्मवेयर अनप्याक गर्न अनुमति दिन्छ। हामीले यसलाई प्रयास गर्यौं र यसले काम गर्‍यो। हामीले सोच्यौं, यदि हामीले मुख्य फर्मवेयर प्रदर्शन गर्न बाह्य उपकरणहरू थप्यौं भने। यसले धेरै चोट पुर्याएन - र यसले पनि काम गर्यो। हामीले फेरि सोच्यौं र पूर्ण इमुलेटर बनाउने निर्णय गर्यौं।

नतिजा कम्प्युटर प्रणाली इमुलेटर थियो नक्कल.

किन कोपीक्याट?

शब्दहरूमा नाटक छ।

copycat (अंग्रेजी, संज्ञा [ˈkɒpɪkæt]) - अनुकरण गर्ने, अनुकरण गर्ने
बिरालो (अंग्रेजी, संज्ञा [ˈkæt]) - बिरालो, बिरालो - परियोजनाको सिर्जनाकर्ता मध्ये एक को मनपर्ने जनावर
अक्षर "K" कोटलिन प्रोग्रामिङ भाषाबाट आएको हो

नक्कल

इमुलेटर सिर्जना गर्दा, धेरै विशिष्ट लक्ष्यहरू सेट गरिएको थियो:

द्रुत रूपमा नयाँ बाह्य उपकरणहरू, मोड्युलहरू, प्रोसेसर कोरहरू सिर्जना गर्ने क्षमता;
विभिन्न मोड्युलहरूबाट भर्चुअल उपकरणहरू भेला गर्ने क्षमता;
भर्चुअल उपकरणको मेमोरीमा कुनै पनि बाइनरी डाटा (फर्मवेयर) लोड गर्ने क्षमता;
स्न्यापशटहरूसँग काम गर्ने क्षमता (प्रणाली अवस्थाको स्न्यापसटहरू);
बिल्ट-इन डिबगर मार्फत इमुलेटरसँग अन्तरक्रिया गर्ने क्षमता;
विकासको लागि राम्रो आधुनिक भाषा।

नतिजाको रूपमा, कोटलिनलाई कार्यान्वयनको लागि छनोट गरिएको थियो, बस संरचना (यो मोड्युलहरूले भर्चुअल डाटा बसहरू मार्फत एकअर्कासँग कुराकानी गर्दा), यन्त्र विवरण ढाँचाको रूपमा JSON, र डिबगरसँग अन्तरक्रियाको लागि प्रोटोकलको रूपमा GDB RSP।

दुई वर्षभन्दा कम समयदेखि विकास भइरहेको र सक्रिय रूपमा चलिरहेको छ। यस समयमा, MIPS, x86, V850ES, ARM, र PowerPC प्रोसेसर कोरहरू लागू गरियो।

परियोजना बढ्दै छ र यसलाई व्यापक जनतामा प्रस्तुत गर्ने समय हो। हामी परियोजनाको विस्तृत विवरण पछि गर्नेछौं, तर अहिलेको लागि हामी कोपीक्याट प्रयोग गर्नमा ध्यान केन्द्रित गर्नेछौं।

सबैभन्दा अधीरका लागि, इमुलेटरको प्रोमो संस्करण डाउनलोड गर्न सकिन्छ लिङ्क.

इमुलेटरमा राइनो

याद गरौं कि यसअघि SMARTRHINO-2018 सम्मेलनका लागि रिभर्स इन्जिनियरिङ सीपहरू सिकाउन परीक्षण यन्त्र “गैंडा” बनाइएको थियो। स्थिर फर्मवेयर विश्लेषण को प्रक्रिया मा वर्णन गरिएको थियो यो लेख.

अब "स्पिकरहरू" थप्ने प्रयास गरौं र इमुलेटरमा फर्मवेयर चलाउनुहोस्।

हामी आवश्यक पर्नेछौं:
१) जाभा १.८
2) पाइथन र मोड्युल जीप इमुलेटर भित्र पाइथन प्रयोग गर्न। तपाइँ Windows को लागी WHL मोड्युल Jep निर्माण गर्न सक्नुहुन्छ यहाँ डाउनलोड गर्नुहोस्.

विन्डोज को लागी:
1) com0com
2) पुटी

लिनक्सका लागि:
1) socat

तपाईंले GDB ग्राहकको रूपमा Eclipse, IDA Pro वा radare2 प्रयोग गर्न सक्नुहुन्छ।

यसले कसरी काम गर्छ?

इमुलेटरमा फर्मवेयर प्रदर्शन गर्न, यो एक भर्चुअल उपकरण "एकत्र" गर्न आवश्यक छ, जुन वास्तविक उपकरणको एनालॉग हो।

वास्तविक उपकरण ("गैंडा") ब्लक रेखाचित्रमा देखाउन सकिन्छ:

इमुलेटरको मोड्युलर संरचना छ र अन्तिम भर्चुअल उपकरणलाई JSON फाइलमा वर्णन गर्न सकिन्छ।

JSON 105 लाइनहरू

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

प्यारामिटरमा ध्यान दिनुहोस् फर्मवेयर खण्ड प्यारा फर्मवेयरको रूपमा भर्चुअल उपकरणमा लोड गर्न सकिने फाइलको नाम हो।

भर्चुअल उपकरण र मुख्य अपरेटिङ सिस्टम संग यसको अन्तरक्रिया निम्न रेखाचित्र द्वारा प्रतिनिधित्व गर्न सकिन्छ:

इमुलेटरको हालको परीक्षण उदाहरणमा मुख्य OS को COM पोर्टहरूसँग अन्तरक्रिया समावेश छ (ब्लुटुथ मोड्युलको लागि UART र UART डिबग गर्नुहोस्)। यी वास्तविक पोर्टहरू हुन सक्छन् जसमा उपकरणहरू जडान भएका छन् वा भर्चुअल COM पोर्टहरू (यसका लागि तपाईलाई आवश्यक छ com0com/socat).

बाहिरबाट इमुलेटरसँग अन्तर्क्रिया गर्ने दुई मुख्य तरिकाहरू छन्:

GDB RSP प्रोटोकल (तदनुसार, यस प्रोटोकललाई समर्थन गर्ने उपकरणहरू Eclipse / IDA / radare2 हुन्);
आन्तरिक इमुलेटर आदेश रेखा (Argparse वा Python)।

भर्चुअल COM पोर्टहरू

टर्मिनल मार्फत स्थानीय मेसिनमा भर्चुअल उपकरणको UART सँग अन्तर्क्रिया गर्नको लागि, तपाईंले सम्बद्ध भर्चुअल COM पोर्टहरूको जोडी सिर्जना गर्न आवश्यक छ। हाम्रो अवस्थामा, एउटा पोर्ट इमुलेटरद्वारा प्रयोग गरिन्छ, र दोस्रो टर्मिनल प्रोग्राम (PuTTY वा स्क्रिन) द्वारा प्रयोग गरिन्छ:

com0com प्रयोग गर्दै

भर्चुअल COM पोर्टहरू com0com किटबाट सेटअप उपयोगिता प्रयोग गरेर कन्फिगर गरिएको छ (कन्सोल संस्करण - C: कार्यक्रम फाइलहरू (x86) com0comsetupс.exe, वा GUI संस्करण - C: कार्यक्रम फाइलहरू (x86) com0comsetupg.exe):

बक्सहरू जाँच गर्नुहोस् बफर ओभररन सक्षम गर्नुहोस् सबै सिर्जना गरिएका भर्चुअल पोर्टहरूको लागि, अन्यथा इमुलेटरले COM पोर्टबाट प्रतिक्रियाको लागि पर्खनेछ।

Socat प्रयोग गर्दै

UNIX प्रणालीहरूमा, भर्चुअल COM पोर्टहरू socat उपयोगिता प्रयोग गरेर इमुलेटरद्वारा स्वचालित रूपमा सिर्जना हुन्छन्; यो गर्नका लागि, इमुलेटर सुरु गर्दा पोर्ट नाममा उपसर्ग निर्दिष्ट गर्नुहोस्। socat:.

आन्तरिक कमाण्ड लाइन इन्टरफेस (Argparse वा Python)

कोपीक्याट कन्सोल एप्लिकेसन भएको हुनाले, इमुलेटरले यसको वस्तु र चरहरूसँग अन्तर्क्रिया गर्नका लागि दुईवटा कमाण्ड लाइन इन्टरफेस विकल्पहरू प्रदान गर्दछ: Argparse र Python।

Argparse Kopycat मा निर्मित CLI हो र सधैं सबैको लागि उपलब्ध छ।

एक वैकल्पिक CLI पाइथन अनुवादक हो। यसलाई प्रयोग गर्नको लागि, तपाईंले Jep पाइथन मोड्युल स्थापना गर्न र पाइथनसँग काम गर्न इमुलेटर कन्फिगर गर्न आवश्यक छ (प्रयोगकर्ताको मुख्य प्रणालीमा स्थापित पाइथन अनुवादक प्रयोग गरिनेछ)।

पाइथन मोड्युल Jep स्थापना गर्दै

लिनक्स जेप अन्तर्गत पाइप मार्फत स्थापना गर्न सकिन्छ:

pip install jep

Windows मा Jep स्थापना गर्न, तपाईंले पहिले Windows SDK र सम्बन्धित Microsoft Visual Studio स्थापना गर्नुपर्छ। हामीले यसलाई तपाइँको लागि अलि सजिलो बनाएका छौं र WHL बनाउँछ विन्डोजको लागि पाइथनको हालको संस्करणहरूको लागि JEP, त्यसैले मोड्युल फाइलबाट स्थापना गर्न सकिन्छ:

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

Jep को स्थापना जाँच गर्न, तपाईंले आदेश लाइनमा चलाउन आवश्यक छ:

python -c "import jep"

निम्न सन्देश प्रतिक्रियामा प्राप्त हुनुपर्छ:

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

तपाईको प्रणालीको लागि इमुलेटर ब्याच फाइलमा (copycat.bat - विन्डोज को लागी, प्रतिलिपि क्याट - लिनक्सको लागि) प्यारामिटरहरूको सूचीमा DEFAULT_JVM_OPTS अतिरिक्त प्यारामिटर थप्नुहोस् Djava.library.path - यसले स्थापित Jep मोड्युलको मार्ग समावेश गर्नुपर्छ।

विन्डोजको लागि नतिजा यो जस्तै लाइन हुनुपर्छ:

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

Kopycat सुरु गर्दै

इमुलेटर एक कन्सोल JVM अनुप्रयोग हो। प्रक्षेपण अपरेटिङ सिस्टम कमाण्ड लाइन स्क्रिप्ट (sh/cmd) मार्फत गरिन्छ।

विन्डोज अन्तर्गत चलाउन आदेश:

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

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 पोर्ट जुन GDB सर्भरमा पहुँचको लागि खुला हुनेछ;
-n rhino - मुख्य प्रणाली मोड्युलको नाम (एकत्रित उपकरण);
-l user — मुख्य मोड्युल खोज्नको लागि पुस्तकालयको नाम;
-y library - उपकरणमा समावेश मोड्युलहरू खोज्नको लागि मार्ग;
firmwarerhino_pass.bin - फर्मवेयर फाइलमा मार्ग;
COM26 र COM28 भर्चुअल COM पोर्टहरू हुन्।

नतिजाको रूपमा, एक प्रम्प्ट प्रदर्शित हुनेछ Python > (वा 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 प्रो संग अन्तरक्रिया

परीक्षणलाई सरल बनाउन, हामी IDA मा विश्लेषणको लागि स्रोत फाइलको रूपमा राइनो फर्मवेयर प्रयोग गर्छौं। ELF फाइल (मेटा जानकारी त्यहाँ भण्डारण गरिएको छ)।

तपाईं मेटा जानकारी बिना मुख्य फर्मवेयर पनि प्रयोग गर्न सक्नुहुन्छ।

IDA Pro मा Kopycat सुरु गरेपछि, डिबगर मेनुमा वस्तुमा जानुहोस् "डिबगर स्विच गर्नुहोस्..."र चयन गर्नुहोस्"रिमोट GDB डिबगर"। अर्को, जडान सेट अप गर्नुहोस्: मेनु डिबगर - प्रक्रिया विकल्पहरू...

मानहरू सेट गर्नुहोस्:

आवेदन - कुनै पनि मूल्य
होस्टनाम: 127.0.0.1 (वा रिमोट मेसिनको IP ठेगाना जहाँ Kopycat चलिरहेको छ)
पोर्ट: 23946

अब डिबगिङ बटन उपलब्ध हुन्छ (F9 कुञ्जी):

इमुलेटरमा डिबगर मोड्युलमा जडान गर्न यसलाई क्लिक गर्नुहोस्। IDA डिबगिङ मोडमा जान्छ, थप सञ्झ्यालहरू उपलब्ध हुन्छन्: दर्ताहरू बारे जानकारी, स्ट्याकको बारेमा।

अब हामी डिबगरका सबै मानक सुविधाहरू प्रयोग गर्न सक्छौं:

निर्देशनहरूको चरण-दर-चरण कार्यान्वयन (मा कदम и स्टेप ओभर - क्रमशः F7 र F8 कुञ्जीहरू;
कार्यान्वयन सुरु र पज गर्दै;
दुबै कोड र डाटा (F2 कुञ्जी) को लागि ब्रेकपोइन्टहरू सिर्जना गर्दै।

डिबगरमा जडान गर्नु भनेको फर्मवेयर कोड चलाउनु होइन। हालको कार्यान्वयन स्थिति ठेगाना हुनुपर्छ 0x08006A74 - कार्यको सुरुवात रिसेट_ह्यान्डलर। यदि तपाइँ सूची तल स्क्रोल गर्नुहुन्छ भने, तपाइँ प्रकार्य कल देख्न सक्नुहुन्छ मुख्य। तपाइँ यो रेखामा कर्सर राख्न सक्नुहुन्छ (ठेगाना 0x08006ABE) र सञ्चालन गर्नुहोस् कर्सर सम्म चलाउनुहोस् (कुञ्जी F4)।

अर्को, तपाइँ प्रकार्य प्रविष्ट गर्न F7 थिच्न सक्नुहुन्छ मुख्य.

यदि तपाइँ आदेश चलाउनुहुन्छ प्रक्रिया जारी राख्नुहोस् (F9 कुञ्जी), त्यसपछि "कृपया प्रतीक्षा गर्नुहोस्" विन्डो एकल बटनको साथ देखा पर्नेछ निलम्बन गर्नुहोस्:

जब तपाइँ थिच्नुहोस् निलम्बन गर्नुहोस् फर्मवेयर कोडको कार्यान्वयन निलम्बन गरिएको छ र कोडको उही ठेगानाबाट जारी राख्न सकिन्छ जहाँ यो अवरोध गरिएको थियो।

यदि तपाइँ कोड कार्यान्वयन गर्न जारी राख्नुहुन्छ भने, तपाइँ भर्चुअल COM पोर्टहरूमा जडान भएको टर्मिनलहरूमा निम्न रेखाहरू देख्नुहुनेछ:

"स्टेट बाइपास" लाइनको उपस्थितिले भर्चुअल ब्लुटुथ मोड्युलले प्रयोगकर्ताको COM पोर्टबाट डाटा प्राप्त गर्ने मोडमा स्विच गरेको संकेत गर्छ।

अब ब्लुटुथ टर्मिनलमा (तस्विरमा COM29) तपाइँ राइनो प्रोटोकल अनुसार आदेशहरू प्रविष्ट गर्न सक्नुहुन्छ। उदाहरणका लागि, "MEOW" आदेशले "mur-mur" लाई ब्लुटुथ टर्मिनलमा फर्काउनेछ:

मलाई पूर्ण रूपमा नक्कल गर्नुहोस्

एक इमुलेटर निर्माण गर्दा, तपाइँ एक विशेष यन्त्रको विवरण/इमुलेशन स्तर छनौट गर्न सक्नुहुन्छ। उदाहरणका लागि, ब्लुटुथ मोड्युल विभिन्न तरिकामा अनुकरण गर्न सकिन्छ:

यन्त्र पूर्ण रूपमा आदेशहरूको पूर्ण सेटको साथ अनुकरण गरिएको छ;
AT आदेशहरू अनुकरण गरिन्छ, र डाटा स्ट्रिम मुख्य प्रणालीको COM पोर्टबाट प्राप्त हुन्छ;
भर्चुअल उपकरणले वास्तविक यन्त्रमा पूर्ण डेटा रिडिरेक्शन प्रदान गर्दछ;
एक साधारण स्टबको रूपमा जुन सधैं "ठीक" फर्काउँछ।

इमुलेटरको हालको संस्करणले दोस्रो दृष्टिकोण प्रयोग गर्दछ - भर्चुअल ब्लुटुथ मोड्युलले कन्फिगरेसन गर्दछ, जस पछि यसले मुख्य प्रणालीको COM पोर्टबाट इम्युलेटरको UART पोर्टमा "प्रोक्सी" डाटाको मोडमा स्विच गर्दछ।

परिधिको केही अंश लागू नभएको अवस्थामा कोडको सरल उपकरणको सम्भावनालाई विचार गरौं। उदाहरणका लागि, यदि DMA मा डाटा स्थानान्तरण नियन्त्रण गर्न जिम्मेवार टाइमर सिर्जना गरिएको छैन (चेक कार्यमा प्रदर्शन गरिन्छ। ws2812b_waitमा स्थित छ 0x08006840), त्यसपछि फर्मवेयरले सधैँ झण्डा रिसेट हुनको लागि पर्खनेछ व्यस्तमा स्थित छ 0x200004C4जसले DMA डाटा लाइनको कब्जा देखाउँछ:

हामी म्यानुअल रूपमा झण्डा रिसेट गरेर यस अवस्थाको वरिपरि जान सक्छौं व्यस्त यसलाई स्थापना पछि तुरुन्तै। IDA Pro मा, तपाईंले पाइथन प्रकार्य सिर्जना गर्न सक्नुहुन्छ र यसलाई ब्रेकपोइन्टमा कल गर्न सक्नुहुन्छ, र फ्ल्यागमा मान 1 लेखेपछि ब्रेकपोइन्टलाई कोडमा राख्न सक्नुहुन्छ। व्यस्त.

ब्रेकपोइन्ट ह्यान्डलर

पहिले, IDA मा पाइथन प्रकार्य सिर्जना गरौं। मेनु फाइल - स्क्रिप्ट आदेश...

बायाँको सूचीमा नयाँ स्निपेट थप्नुहोस्, यसलाई नाम दिनुहोस् (उदाहरणका लागि, बीपीटी),
दायाँको पाठ फिल्डमा, प्रकार्य कोड प्रविष्ट गर्नुहोस्:

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

त्यस पछि हामी थिच्छौं चलाउनुहोस् र स्क्रिप्ट विन्डो बन्द गर्नुहोस्।

अब कोड मा जाऔं 0x0800688A, ब्रेकपोइन्ट सेट गर्नुहोस् (F2 कुञ्जी), यसलाई सम्पादन गर्नुहोस् (सन्दर्भ मेनु ब्रेकपोइन्ट सम्पादन गर्नुहोस्...) पाइथनमा लिपि प्रकार सेट गर्न नबिर्सनुहोस्:

यदि हालको झण्डा मान व्यस्त 1 बराबर हुन्छ, त्यसपछि तपाईंले प्रकार्य कार्यान्वयन गर्नुपर्छ skip_dma स्क्रिप्ट लाइन मा:

यदि तपाइँ कार्यान्वयनको लागि फर्मवेयर चलाउनुहुन्छ भने, ब्रेकपोइन्ट ह्यान्डलर कोडको ट्रिगर IDA विन्डोमा देख्न सकिन्छ। उत्पादन लाइन द्वारा Skipping wait ws2812...। अब फर्मवेयरले झण्डा रिसेट हुनको लागि पर्खने छैन व्यस्त.

इमुलेटरसँग अन्तरक्रिया

इम्युलेसनको खातिर इम्युलेसनले रमाईलो र आनन्द ल्याउने सम्भावना छैन। यो धेरै रोचक छ यदि इमुलेटरले अनुसन्धानकर्तालाई मेमोरीमा डेटा हेर्न वा थ्रेडहरूको अन्तरक्रिया स्थापित गर्न मद्दत गर्दछ।

हामी तपाईंलाई RTOS कार्यहरू बीचको अन्तरक्रिया कसरी गतिशील रूपमा स्थापित गर्ने भनेर देखाउनेछौं। यदि यो चलिरहेको छ भने तपाईले पहिले कोडको कार्यान्वयन रोक्नु पर्छ। यदि तपाइँ समारोहमा जानुहुन्छ भने bluetooth_task_entry "LED" आदेशको प्रशोधन शाखामा (ठेगाना 0x080057B8), त्यसपछि तपाइँ पहिले के सिर्जना गरिएको छ र त्यसपछि प्रणाली लाममा पठाइएको देख्न सक्नुहुन्छ ledControlQueueHandle केही सन्देश।

तपाईंले चर पहुँच गर्न ब्रेकपोइन्ट सेट गर्नुपर्छ ledControlQueueHandleमा स्थित छ 0x20000624 र कोड कार्यान्वयन गर्न जारी राख्नुहोस्:

नतिजाको रूपमा, स्टप पहिले ठेगानामा हुनेछ 0x080057CA समारोह कल गर्नु अघि osMailAlloc, त्यसपछि ठेगानामा 0x08005806 समारोह कल गर्नु अघि osMailPut, त्यसपछि केहि समय पछि - ठेगानामा 0x08005BD4 (कार्यक्रमलाई कल गर्नु अघि osMailGet), जुन प्रकार्यसँग सम्बन्धित छ leds_task_entry (LED-कार्य), त्यो हो, कार्यहरू स्विच गरियो, र अब LED-कार्यले नियन्त्रण प्राप्त गर्यो।

यस सरल तरिकामा तपाइँ कसरी RTOS कार्यहरू एकअर्कासँग अन्तरक्रिया गर्दछ स्थापना गर्न सक्नुहुन्छ।

निस्सन्देह, वास्तविकतामा, कार्यहरूको अन्तरक्रिया अधिक जटिल हुन सक्छ, तर इमुलेटर प्रयोग गरेर, यो अन्तरक्रिया ट्र्याक गर्न कम श्रमसाध्य हुन्छ।

यहाँ तपाईंले इमुलेटर सुरु गर्ने र IDA प्रोसँग अन्तरक्रिया गर्ने छोटो भिडियो हेर्न सक्नुहुन्छ।

Radare2 को साथ सुरू गर्नुहोस्

तपाईंले Radare2 को रूपमा यस्तो विश्वव्यापी उपकरणलाई बेवास्ता गर्न सक्नुहुन्न।

r2 प्रयोग गरेर इमुलेटरमा जडान गर्न, आदेश यस्तो देखिन्छ:

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

अब उपलब्ध लन्च (dc) र पज कार्यान्वयन (Ctrl+C)।

दुर्भाग्यवश, यस समयमा, हार्डवेयर gdb सर्भर र मेमोरी लेआउटसँग काम गर्दा r2 मा समस्याहरू छन्; यस कारणले, ब्रेकपोइन्ट र चरणहरू काम गर्दैनन् (आदेश ds)। हामी आशा गर्दछौं कि यो छिट्टै ठीक हुनेछ।

ग्रहण संग चलिरहेको

इमुलेटर प्रयोग गर्नका लागि विकल्पहरू मध्ये एक उपकरणको फर्मवेयर डिबग गर्न हो। स्पष्टताको लागि, हामी राइनो फर्मवेयर पनि प्रयोग गर्नेछौं। तपाईं फर्मवेयर स्रोतहरू डाउनलोड गर्न सक्नुहुन्छ यहाँ देखि.

हामी सेटबाट ग्रहणलाई IDE को रूपमा प्रयोग गर्नेछौं STM32 को लागि प्रणाली वर्कबेन्च.

इम्युलेटरले ग्रहणमा सिधै कम्पाइल गरिएको फर्मवेयर लोड गर्नको लागि, तपाईंले प्यारामिटर थप्नु पर्छ। firmware=null इमुलेटर सुरुवात आदेशमा:

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

डिबग कन्फिगरेसन सेटअप गर्दै

Eclipse मा, मेनु चयन गर्नुहोस् चलाउनुहोस् - डिबग कन्फिगरेसनहरू... खुल्ने विन्डोमा, खण्डमा GDB हार्डवेयर डिबगिङ तपाईंले नयाँ कन्फिगरेसन थप्न आवश्यक छ, त्यसपछि "मुख्य" ट्याबमा हालको परियोजना र डिबगिङको लागि अनुप्रयोग निर्दिष्ट गर्नुहोस्:

"डिबगर" ट्याबमा तपाईंले GDB आदेश निर्दिष्ट गर्न आवश्यक छ:
${openstm32_compiler_path}arm-none-eabi-gdb

र GDB सर्भर (होस्ट र पोर्ट) मा जडान गर्न प्यारामिटरहरू पनि प्रविष्ट गर्नुहोस्:

"स्टार्टअप" ट्याबमा, तपाईंले निम्न प्यारामिटरहरू निर्दिष्ट गर्नुपर्छ:

चेकबक्स सक्षम गर्नुहोस् छवि लोड गर्नुहोस् (त्यसैले भेला गरिएको फर्मवेयर छवि इमुलेटरमा लोड हुन्छ);
चेकबक्स सक्षम गर्नुहोस् प्रतीकहरू लोड गर्नुहोस्;
प्रक्षेपण आदेश थप्नुहोस्: set $pc = *0x08000004 (ठेगानामा मेमोरीबाट मानमा पीसी रेजिस्टर सेट गर्नुहोस् 0x08000004 - ठेगाना त्यहाँ भण्डारण गरिएको छ रिसेट ह्यान्डलर).

ध्यान दिनुहोस्, यदि तपाइँ Eclipse बाट फर्मवेयर फाइल डाउनलोड गर्न चाहनुहुन्न भने, विकल्पहरू छवि लोड गर्नुहोस् и आदेशहरू चलाउनुहोस् संकेत गर्न आवश्यक छैन।

डिबग क्लिक गरेपछि, तपाइँ डिबगर मोडमा काम गर्न सक्नुहुन्छ:

चरणबद्ध कोड कार्यान्वयन
ब्रेकपोइन्टहरूसँग अन्तरक्रिया गर्दै

भन्नु. ग्रहणमा, हम्म... केही क्वर्कहरू छन्... र तपाईंले तिनीहरूसँग बाँच्नु पर्छ। उदाहरण को लागी, यदि डिबगर सुरु गर्दा सन्देश "0x0" को लागी कुनै स्रोत उपलब्ध छैन" देखा पर्दछ, त्यसपछि चरण आदेश (F5) कार्यान्वयन गर्नुहोस्।

बरु एक निष्कर्षमा को

मूल कोड अनुकरण एक धेरै रोचक कुरा हो। यन्त्र विकासकर्ताको लागि वास्तविक उपकरण बिना फर्मवेयर डिबग गर्न सम्भव हुन्छ। एक शोधकर्ताको लागि, यो गतिशील कोड विश्लेषण सञ्चालन गर्ने अवसर हो, जुन एक उपकरणको साथ पनि सधैं सम्भव छैन।

हामी विशेषज्ञहरूलाई एक उपकरण प्रदान गर्न चाहन्छौं जुन सुविधाजनक, मध्यम रूपमा सरल छ र सेटअप गर्न र चलाउन धेरै प्रयास र समय लाग्दैन।

हार्डवेयर इमुलेटरहरू प्रयोग गरेर तपाईंको अनुभवको बारेमा टिप्पणीहरूमा लेख्नुहोस्। हामी तपाईंलाई छलफल गर्न आमन्त्रित गर्छौं र प्रश्नहरूको जवाफ दिन खुसी हुनेछौं।

दर्ता भएका प्रयोगकर्ताहरूले मात्र सर्वेक्षणमा भाग लिन सक्छन्। साइन इन गर्नुहोस्कृपया

तपाईं इमुलेटर के को लागी प्रयोग गर्दै हुनुहुन्छ?

म (डिबग) फर्मवेयर विकास गर्छु
म फर्मवेयर अनुसन्धान गर्दैछु
म खेल सुरु गर्छु (Dendi, Sega, PSP)
अरू केही (कमेन्टमा लेख्नुहोस्)

7 प्रयोगकर्ताहरूले मतदान गरे। २ प्रयोगकर्ताहरू रोकिए।

तपाईले नेटिभ कोड अनुकरण गर्न कुन सफ्टवेयर प्रयोग गर्नुहुन्छ?

QEMU
युनिकोर्न इन्जिन
प्रोटेटस
अरू केही (कमेन्टमा लेख्नुहोस्)

6 प्रयोगकर्ताहरूले मतदान गरे। २ प्रयोगकर्ताहरू रोकिए।

तपाईंले प्रयोग गरिरहनुभएको इमुलेटरमा के सुधार गर्न चाहनुहुन्छ?

म गति चाहन्छु
म सेटअप/लन्चको सहजता चाहन्छु
म इमुलेटर (एपीआई, हुक) सँग अन्तरक्रियाका लागि थप विकल्पहरू चाहन्छु।
म सबै कुरामा खुसी छु
अरू केही (कमेन्टमा लेख्नुहोस्)

8 प्रयोगकर्ताहरूले मतदान गरे। १ प्रयोगकर्ता रोकिए।

स्रोत: www.habr.com

बिरालो भित्र गैंडा - कोपीक्याट इमुलेटरमा फर्मवेयर चलाउनुहोस्