🥇बिल्ली के अंदर गैंडा - कोपीकैट एमुलेटर में फर्मवेयर लॉन्च करें

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

इस लेख में हम वर्णन करेंगे कि एमुलेटर में डिवाइस फ़र्मवेयर को कैसे चलाया जाए, डिबगर के साथ इंटरैक्शन प्रदर्शित किया जाए और फ़र्मवेयर का एक छोटा गतिशील विश्लेषण किया जाए।

पृष्ठभूमि

बहुत समय पहले बहुत दूर एक आकाशगंगा में

कुछ साल पहले हमारी प्रयोगशाला में एक उपकरण के फर्मवेयर की जांच करने की आवश्यकता थी। फ़र्मवेयर को बूटलोडर के साथ संपीड़ित और अनपैक किया गया था। उन्होंने इसे बहुत जटिल तरीके से किया, मेमोरी में डेटा को कई बार स्थानांतरित किया। और फ़र्मवेयर ने तब सक्रिय रूप से बाह्य उपकरणों के साथ बातचीत की। और यह सब MIPS कोर पर।

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

परिणाम एक कंप्यूटर सिस्टम एमुलेटर था नकल.

कोपीकैट क्यों?

शब्दों का खेल है.

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

नकल

एमुलेटर बनाते समय, बहुत विशिष्ट लक्ष्य निर्धारित किए गए थे:

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

परिणामस्वरूप, कार्यान्वयन के लिए कोटलिन को चुना गया, बस आर्किटेक्चर (यह तब होता है जब मॉड्यूल वर्चुअल डेटा बसों के माध्यम से एक दूसरे के साथ संचार करते हैं), डिवाइस विवरण प्रारूप के रूप में JSON, और डिबगर के साथ बातचीत के लिए प्रोटोकॉल के रूप में GDB RSP।

विकास दो साल से कुछ अधिक समय से चल रहा है और सक्रिय रूप से जारी है। इस समय के दौरान, MIPS, x86, V850ES, ARM और PowerPC प्रोसेसर कोर लागू किए गए।

परियोजना बढ़ रही है और इसे व्यापक जनता के सामने प्रस्तुत करने का समय आ गया है। हम परियोजना का विस्तृत विवरण बाद में देंगे, लेकिन अभी हम कोपीकैट के उपयोग पर ध्यान केंद्रित करेंगे।

सबसे अधीर लोगों के लिए, एमुलेटर का प्रोमो संस्करण यहां से डाउनलोड किया जा सकता है लिंक.

एम्यूलेटर में राइनो

बता दें कि इससे पहले SMARTRHINO-2018 सम्मेलन के लिए, रिवर्स इंजीनियरिंग कौशल सिखाने के लिए एक परीक्षण उपकरण "गैंडा" बनाया गया था। स्थैतिक फर्मवेयर विश्लेषण की प्रक्रिया का वर्णन किया गया था यह लेख.

अब आइए "स्पीकर" जोड़ने और फर्मवेयर को एमुलेटर में चलाने का प्रयास करें।

हमें इसकी आवश्यकता होगी:
1) जावा 1.8
2) पायथन और मॉड्यूल जप एम्यूलेटर के अंदर पायथन का उपयोग करने के लिए। आप विंडोज़ के लिए WHL मॉड्यूल Jep बना सकते हैं यहाँ डाउनलोड करें.

विंडोज के लिए:
1) com0com
2) पुट्टी

लिनक्स के लिए:
1) समाज

आप जीडीबी क्लाइंट के रूप में एक्लिप्स, आईडीए प्रो या राडार2 का उपयोग कर सकते हैं।

यह कैसे काम करता है?

एमुलेटर में फर्मवेयर करने के लिए, एक वर्चुअल डिवाइस को "असेंबल" करना आवश्यक है, जो एक वास्तविक डिवाइस का एक एनालॉग है।

वास्तविक उपकरण ("राइनो") को ब्लॉक आरेख में दिखाया जा सकता है:

एमुलेटर में एक मॉड्यूलर संरचना होती है और अंतिम वर्चुअल डिवाइस को 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"]
  ]
}

पैरामीटर पर ध्यान दें फर्मवेयर अनुभाग पैरामीटर एक फ़ाइल का नाम है जिसे फ़र्मवेयर के रूप में वर्चुअल डिवाइस में लोड किया जा सकता है।

वर्चुअल डिवाइस और मुख्य ऑपरेटिंग सिस्टम के साथ इसके इंटरेक्शन को निम्नलिखित चित्र द्वारा दर्शाया जा सकता है:

एमुलेटर के वर्तमान परीक्षण उदाहरण में मुख्य ओएस के COM पोर्ट (ब्लूटूथ मॉड्यूल के लिए डीबग यूएआरटी और यूएआरटी) के साथ इंटरैक्शन शामिल है। ये वास्तविक पोर्ट हो सकते हैं जिनसे डिवाइस जुड़े हुए हैं या वर्चुअल COM पोर्ट हो सकते हैं (इसके लिए आपको बस इसकी आवश्यकता है com0com/socat).

वर्तमान में एम्यूलेटर के साथ बाहर से इंटरैक्ट करने के दो मुख्य तरीके हैं:

जीडीबी आरएसपी प्रोटोकॉल (तदनुसार, इस प्रोटोकॉल का समर्थन करने वाले उपकरण एक्लिप्स / आईडीए / रडार 2 हैं);
आंतरिक एमुलेटर कमांड लाइन (आर्गपर्स या पायथन)।

वर्चुअल COM पोर्ट

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

com0com का उपयोग करना

वर्चुअल COM पोर्ट को com0com किट (कंसोल संस्करण -) से सेटअप उपयोगिता का उपयोग करके कॉन्फ़िगर किया गया है C:प्रोग्राम फ़ाइलें (x86)com0comsetupс.exe, या जीयूआई संस्करण - C:प्रोग्राम फ़ाइलें (x86)com0comsetupg.exe):

बक्सों की जाँच करें बफ़र ओवररन सक्षम करें सभी निर्मित वर्चुअल पोर्ट के लिए, अन्यथा एमुलेटर COM पोर्ट से प्रतिक्रिया की प्रतीक्षा करेगा।

सोकाट का उपयोग करना

UNIX सिस्टम पर, वर्चुअल COM पोर्ट स्वचालित रूप से socat उपयोगिता का उपयोग करके एमुलेटर द्वारा बनाए जाते हैं; ऐसा करने के लिए, बस एमुलेटर शुरू करते समय पोर्ट नाम में उपसर्ग निर्दिष्ट करें socat:.

आंतरिक कमांड लाइन इंटरफ़ेस (Argparse या Python)

चूँकि Kopycat एक कंसोल एप्लिकेशन है, एमुलेटर अपने ऑब्जेक्ट और वेरिएबल्स के साथ इंटरैक्ट करने के लिए दो कमांड लाइन इंटरफ़ेस विकल्प प्रदान करता है: Argparse और Python।

Argparse Kopycat में निर्मित एक CLI है और यह हमेशा सभी के लिए उपलब्ध है।

एक वैकल्पिक सीएलआई पायथन दुभाषिया है। इसका उपयोग करने के लिए, आपको जेप पायथन मॉड्यूल को स्थापित करना होगा और पायथन के साथ काम करने के लिए एमुलेटर को कॉन्फ़िगर करना होगा (उपयोगकर्ता के मुख्य सिस्टम पर स्थापित पायथन दुभाषिया का उपयोग किया जाएगा)।

पायथन मॉड्यूल जेप स्थापित करना

लिनक्स के तहत जेप को पाइप के माध्यम से स्थापित किया जा सकता है:

pip install jep

विंडोज़ पर जेप स्थापित करने के लिए, आपको पहले विंडोज़ एसडीके और संबंधित माइक्रोसॉफ्ट विज़ुअल स्टूडियो इंस्टॉल करना होगा। हमने आपके लिए इसे थोड़ा आसान बना दिया है WHL बनाता है विंडोज़ के लिए पायथन के वर्तमान संस्करणों के लिए JEP, ताकि मॉड्यूल को फ़ाइल से स्थापित किया जा सके:

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

जेप की स्थापना की जांच करने के लिए, आपको कमांड लाइन पर चलना होगा:

python -c "import jep"

प्रत्युत्तर में निम्नलिखित संदेश प्राप्त होना चाहिए:

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

आपके सिस्टम के लिए एम्यूलेटर बैच फ़ाइल में (नकलची.बैट - विंडोज के लिए, नकल - लिनक्स के लिए) पैरामीटर की सूची में DEFAULT_JVM_OPTS एक अतिरिक्त पैरामीटर जोड़ें Djava.library.path - इसमें स्थापित जेप मॉड्यूल का पथ होना चाहिए।

विंडोज़ के लिए परिणाम इस प्रकार एक पंक्ति होना चाहिए:

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

कोपीकैट लॉन्च करना

एम्यूलेटर एक कंसोल JVM एप्लिकेशन है। लॉन्चिंग ऑपरेटिंग सिस्टम कमांड लाइन स्क्रिप्ट (sh/cmd) के माध्यम से की जाती है।

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

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

Socat उपयोगिता का उपयोग करके Linux के अंतर्गत चलाने का आदेश:

./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 - टीसीपी पोर्ट जो जीडीबी सर्वर तक पहुंच के लिए खुला रहेगा;
-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 >

आईडीए प्रो के साथ बातचीत

परीक्षण को सरल बनाने के लिए, हम फॉर्म में आईडीए में विश्लेषण के लिए स्रोत फ़ाइल के रूप में राइनो फर्मवेयर का उपयोग करते हैं ईएलएफ फ़ाइल (मेटा जानकारी वहां संग्रहीत है)।

आप मेटा जानकारी के बिना भी मुख्य फ़र्मवेयर का उपयोग कर सकते हैं।

आईडीए प्रो में कोपीकैट लॉन्च करने के बाद, डिबगर मेनू में आइटम पर जाएं "डिबगर स्विच करें..."और चुनें"रिमोट जीडीबी डिबगर". अगला, कनेक्शन सेट करें: मेनू डिबगर - प्रक्रिया विकल्प…

मान सेट करें:

अनुप्रयोग - कोई भी मूल्य
होस्टनाम: 127.0.0.1 (या रिमोट मशीन का आईपी पता जहां कोपीकैट चल रहा है)
पोर्ट: 23946

अब डिबगिंग बटन उपलब्ध हो जाता है (F9 कुंजी):

एम्यूलेटर में डिबगर मॉड्यूल से कनेक्ट करने के लिए इसे क्लिक करें। आईडीए डिबगिंग मोड में चला जाता है, अतिरिक्त विंडो उपलब्ध हो जाती है: रजिस्टरों के बारे में जानकारी, स्टैक के बारे में।

अब हम डिबगर की सभी मानक सुविधाओं का उपयोग कर सकते हैं:

निर्देशों का चरण-दर-चरण निष्पादन (में कदम и चहलकदमी - कुंजी F7 और F8, क्रमशः);
निष्पादन शुरू करना और रोकना;
कोड और डेटा (F2 कुंजी) दोनों के लिए ब्रेकप्वाइंट बनाना।

डिबगर से कनेक्ट करने का मतलब फ़र्मवेयर कोड चलाना नहीं है। वर्तमान निष्पादन स्थिति का पता होना चाहिए 0x08006A74 - समारोह की शुरुआत रीसेट_हैंडलर. यदि आप सूची को नीचे स्क्रॉल करते हैं, तो आप फ़ंक्शन कॉल देख सकते हैं मुख्य. आप कर्सर को इस लाइन (पते) पर रख सकते हैं 0x08006ABE) और ऑपरेशन करें कर्सर तक चलाएँ (कुंजी F4).

इसके बाद, आप फ़ंक्शन में प्रवेश करने के लिए F7 दबा सकते हैं मुख्य.

यदि आप कमांड चलाते हैं प्रक्रिया जारी रखें (F9 कुंजी), फिर "कृपया प्रतीक्षा करें" विंडो एक बटन के साथ दिखाई देगी निलंबित:

जब आप दबाते हैं निलंबित फ़र्मवेयर कोड का निष्पादन निलंबित कर दिया गया है और इसे कोड में उसी पते से जारी रखा जा सकता है जहां यह बाधित हुआ था।

यदि आप कोड निष्पादित करना जारी रखते हैं, तो आपको वर्चुअल COM पोर्ट से जुड़े टर्मिनलों में निम्नलिखित पंक्तियाँ दिखाई देंगी:

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

अब ब्लूटूथ टर्मिनल (चित्र में COM29) में आप राइनो प्रोटोकॉल के अनुसार कमांड दर्ज कर सकते हैं। उदाहरण के लिए, "MEOW" कमांड स्ट्रिंग "mur-mur" को ब्लूटूथ टर्मिनल पर लौटा देगा:

मेरा अनुकरण पूरी तरह से नहीं

एमुलेटर बनाते समय, आप किसी विशेष डिवाइस के विवरण/अनुकरण का स्तर चुन सकते हैं। उदाहरण के लिए, ब्लूटूथ मॉड्यूल का अनुकरण विभिन्न तरीकों से किया जा सकता है:

डिवाइस पूरी तरह से कमांड के पूरे सेट का अनुकरण करता है;
एटी कमांड का अनुकरण किया जाता है, और डेटा स्ट्रीम मुख्य सिस्टम के COM पोर्ट से प्राप्त की जाती है;
वर्चुअल डिवाइस वास्तविक डिवाइस पर संपूर्ण डेटा पुनर्निर्देशन प्रदान करता है;
एक साधारण स्टब के रूप में जो हमेशा "ओके" लौटाता है।

एमुलेटर का वर्तमान संस्करण दूसरे दृष्टिकोण का उपयोग करता है - वर्चुअल ब्लूटूथ मॉड्यूल कॉन्फ़िगरेशन करता है, जिसके बाद यह मुख्य सिस्टम के COM पोर्ट से एमुलेटर के यूएआरटी पोर्ट पर "प्रॉक्सी" डेटा के मोड पर स्विच करता है।

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

हम ध्वज को मैन्युअल रूप से रीसेट करके इस स्थिति से निपट सकते हैं व्यस्त इसे इंस्टॉल करने के तुरंत बाद. आईडीए प्रो में, आप एक पायथन फ़ंक्शन बना सकते हैं और इसे ब्रेकपॉइंट में कॉल कर सकते हैं, और ध्वज में मान 1 लिखने के बाद ब्रेकपॉइंट को कोड में डाल सकते हैं व्यस्त.

ब्रेकप्वाइंट हैंडलर

सबसे पहले, आइए आईडीए में एक पायथन फ़ंक्शन बनाएं। मेन्यू फ़ाइल - स्क्रिप्ट कमांड...

बाईं ओर की सूची में एक नया स्निपेट जोड़ें, इसे एक नाम दें (उदाहरण के लिए, बीपीटी),
दाईं ओर टेक्स्ट फ़ील्ड में, फ़ंक्शन कोड दर्ज करें:

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

उसके बाद हम दबाते हैं रन और स्क्रिप्ट विंडो बंद करें.

अब आइए कोड पर चलते हैं 0x0800688A, एक ब्रेकप्वाइंट (F2 कुंजी) सेट करें, इसे संपादित करें (संदर्भ मेनू)। ब्रेकप्वाइंट संपादित करें...), स्क्रिप्ट प्रकार को पायथन पर सेट करना न भूलें:

यदि वर्तमान ध्वज मान व्यस्त 1 के बराबर है, तो आपको फ़ंक्शन निष्पादित करना चाहिए स्किप_डीएमए स्क्रिप्ट लाइन में:

यदि आप निष्पादन के लिए फर्मवेयर चलाते हैं, तो ब्रेकपॉइंट हैंडलर कोड की ट्रिगरिंग को आईडीए विंडो में देखा जा सकता है उत्पादन रेखा से Skipping wait ws2812.... अब फ़र्मवेयर फ़्लैग के रीसेट होने का इंतज़ार नहीं करेगा व्यस्त.

एम्यूलेटर के साथ इंटरेक्शन

अनुकरण के लिए अनुकरण से ख़ुशी और खुशी मिलने की संभावना नहीं है। यह अधिक दिलचस्प है यदि एम्यूलेटर शोधकर्ता को मेमोरी में डेटा देखने या थ्रेड्स की इंटरैक्शन स्थापित करने में मदद करता है।

हम आपको दिखाएंगे कि आरटीओएस कार्यों के बीच गतिशील रूप से इंटरैक्शन कैसे स्थापित करें। यदि कोड चल रहा है तो आपको सबसे पहले उसके निष्पादन को रोकना चाहिए। अगर आप किसी समारोह में जाते हैं ब्लूटूथ_टास्क_एंट्री "एलईडी" कमांड की प्रोसेसिंग शाखा में (पता 0x080057B8), फिर आप देख सकते हैं कि पहले क्या बनाया गया और फिर सिस्टम कतार में भेजा गया LEDControlQueueHandle कुछ संदेश.

आपको वेरिएबल तक पहुंचने के लिए एक ब्रेकप्वाइंट सेट करना चाहिए LEDControlQueueHandleपर स्थित 0x20000624 और कोड निष्पादित करना जारी रखें:

परिणामस्वरूप, स्टॉप सबसे पहले पते पर होगा 0x080057CA फ़ंक्शन को कॉल करने से पहले osMailAlloc, फिर पते पर 0x08005806 फ़ंक्शन को कॉल करने से पहले ओसमेलपुट, फिर थोड़ी देर बाद - पते पर 0x08005BD4 (फ़ंक्शन को कॉल करने से पहले ओसमेलगेट), जो फ़ंक्शन से संबंधित है LEDs_task_entry (एलईडी-कार्य), यानी, कार्य स्विच किए गए, और अब एलईडी-कार्य को नियंत्रण प्राप्त हुआ।

इस सरल तरीके से आप यह स्थापित कर सकते हैं कि आरटीओएस कार्य एक-दूसरे के साथ कैसे इंटरैक्ट करते हैं।

बेशक, वास्तव में, कार्यों की बातचीत अधिक जटिल हो सकती है, लेकिन एक एमुलेटर का उपयोग करके, इस बातचीत को ट्रैक करना कम श्रमसाध्य हो जाता है।

यहां आप एमुलेटर के लॉन्च और आईडीए प्रो के साथ बातचीत का एक छोटा वीडियो देख सकते हैं।

Radare2 के साथ लॉन्च करें

आप Radare2 जैसे सार्वभौमिक उपकरण को नज़रअंदाज नहीं कर सकते।

R2 का उपयोग करके एमुलेटर से कनेक्ट करने के लिए, कमांड इस तरह दिखेगा:

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

लॉन्च अभी उपलब्ध है (dc) और निष्पादन रोकें (Ctrl+C)।

दुर्भाग्यवश, फिलहाल, हार्डवेयर जीडीबी सर्वर और मेमोरी लेआउट के साथ काम करते समय आर2 में समस्याएं हैं; इस वजह से, ब्रेकप्वाइंट और स्टेप्स काम नहीं करते हैं (कमांड ds). हमें उम्मीद है कि इसे जल्द ही ठीक कर लिया जाएगा.

ग्रहण के साथ चल रहा है

एमुलेटर का उपयोग करने के विकल्पों में से एक विकसित किए जा रहे डिवाइस के फर्मवेयर को डीबग करना है। स्पष्टता के लिए, हम राइनो फर्मवेयर का भी उपयोग करेंगे। आप फ़र्मवेयर स्रोत डाउनलोड कर सकते हैं अत:.

हम सेट से एक्लिप्स को एक आईडीई के रूप में उपयोग करेंगे STM32 के लिए सिस्टम कार्यक्षेत्र.

एमुलेटर के लिए सीधे एक्लिप्स में संकलित फर्मवेयर को लोड करने के लिए, आपको पैरामीटर जोड़ने की आवश्यकता है firmware=null एम्यूलेटर लॉन्च कमांड के लिए:

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

डिबग कॉन्फ़िगरेशन सेट करना

ग्रहण में, मेनू का चयन करें चलाएँ - डिबग कॉन्फ़िगरेशन... खुलने वाली विंडो में, अनुभाग में जीडीबी हार्डवेयर डिबगिंग आपको एक नया कॉन्फ़िगरेशन जोड़ने की आवश्यकता है, फिर "मुख्य" टैब पर डिबगिंग के लिए वर्तमान प्रोजेक्ट और एप्लिकेशन निर्दिष्ट करें:

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

और GDB सर्वर (होस्ट और पोर्ट) से कनेक्ट करने के लिए पैरामीटर भी दर्ज करें:

"स्टार्टअप" टैब पर, आपको निम्नलिखित पैरामीटर निर्दिष्ट करने होंगे:

चेकबॉक्स सक्षम करें छवि लोड करें (ताकि असेंबल की गई फ़र्मवेयर छवि एमुलेटर में लोड हो जाए);
चेकबॉक्स सक्षम करें प्रतीक लोड करें;
लॉन्च कमांड जोड़ें: set $pc = *0x08000004 (पीसी रजिस्टर को पते पर मेमोरी से मूल्य पर सेट करें 0x08000004 - पता वहां संग्रहीत है रीसेटहैंडलर).

ध्यान दें, यदि आप एक्लिप्स से फर्मवेयर फ़ाइल डाउनलोड नहीं करना चाहते हैं, तो विकल्प छवि लोड करें и आदेश चलाएँ इंगित करने की कोई आवश्यकता नहीं है.

डीबग पर क्लिक करने के बाद, आप डीबगर मोड में काम कर सकते हैं:

चरण दर चरण कोड निष्पादन
ब्रेकप्वाइंट के साथ इंटरैक्ट करना

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

इसके बजाय एक निष्कर्ष की

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

हम विशेषज्ञों को एक ऐसा उपकरण प्रदान करना चाहते हैं जो सुविधाजनक, मध्यम सरल हो और जिसे स्थापित करने और चलाने में बहुत अधिक प्रयास और समय न लगे।

हार्डवेयर एमुलेटर का उपयोग करने के अपने अनुभव के बारे में टिप्पणियों में लिखें। हम आपको चर्चा के लिए आमंत्रित करते हैं और प्रश्नों का उत्तर देने में हमें खुशी होगी।

केवल पंजीकृत उपयोगकर्ता ही सर्वेक्षण में भाग ले सकते हैं। साइन इन करेंकृपया।

आप एम्यूलेटर का उपयोग किस लिए कर रहे हैं?

मैं फर्मवेयर (डीबग) विकसित करता हूं
मैं फर्मवेयर पर शोध कर रहा हूं
मैं गेम लॉन्च करता हूं (डेन्डी, सेगा, पीएसपी)
कुछ और (टिप्पणियों में लिखें)

7 उपयोगकर्ताओं ने मतदान किया। 2 उपयोगकर्ता अनुपस्थित रहे।

मूल कोड का अनुकरण करने के लिए आप किस सॉफ़्टवेयर का उपयोग करते हैं?

QEMU
यूनिकॉर्न इंजन
रूप बदलनेवाला प्राणी
कुछ और (टिप्पणियों में लिखें)

6 उपयोगकर्ताओं ने मतदान किया। 2 उपयोगकर्ता अनुपस्थित रहे।

आप जिस एमुलेटर का उपयोग कर रहे हैं उसमें आप क्या सुधार करना चाहेंगे?

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

8 उपयोगकर्ताओं ने मतदान किया. 1 उपयोगकर्ता अनुपस्थित रहा.

स्रोत: www.habr.com

एक बिल्ली के अंदर गैंडा - कोपीकैट एमुलेटर में फर्मवेयर चलाएं