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

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

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

प्रागितिहास

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

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

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

परिणाम कंप्यूटिंग सिस्टम Kopycat का एक एमुलेटर था।

Kopycat

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

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

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

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

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

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

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

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

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

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

विंडोज के लिए:
1) com0com
2) PuTTY

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

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

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

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

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

एमुलेटर में एक मॉड्यूलर संरचना होती है और अंतिम वर्चुअल डिवाइस को JSON फ़ाइल में वर्णित किया जा सकता है।

{ "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 सिर्फ इसके लिए हैं ) ।

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

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

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

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

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

वर्चुअल COM पोर्ट्स को com0com किट (कंसोल संस्करण C: \ Program Files (x86) \ com0com \ setup.exe, या GUI संस्करण C: \ Program Files (x86) \ com0com \ setupg.exe से सेटअप उपयोगिता के साथ कॉन्फ़िगर किया गया है। :

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

समाज का उपयोग करना

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

आंतरिक कमांड लाइन इंटरफ़ेस (आर्गपर्स या पायथन)

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

आर्गपर्स सीएलआई है जो कोपीकैट में बनाया गया है, यह हमेशा सभी के लिए उपलब्ध है।

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

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

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

 pip install jep 

विंडोज के तहत जेप को स्थापित करने के लिए, आपको सबसे पहले विंडोज एसडीके और संबंधित माइक्रोसॉफ्ट विजुअल स्टूडियो को स्थापित करना होगा। हमने आपके कार्य को थोड़ा सरल किया और विंडोज के लिए पायथन के वर्तमान संस्करणों के लिए 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. 

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

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

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

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

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

विंडोज के तहत चलने के लिए कमांड:

 bin\kopycat -g 23946 -n rhino -l user -y library -p firmware=firmware\rhino_pass.bin,tty_dbg=COM26,tty_bt=COM28 

लिनक्स पर चलने के लिए समादेश उपयोगिता का उपयोग:

 ./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 - डिवाइस में शामिल मॉड्यूल की खोज करने का मार्ग;
• firmware\rhino_pass.bin - फर्मवेयर फ़ाइल का पथ;
• COM26 और COM28 वर्चुअल COM पोर्ट हैं।

इसका परिणाम Python > (या Argparse > ) 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 होना चाहिए - Reset_Handler फ़ंक्शन की शुरुआत। यदि आप नीचे दी गई सूची को स्क्रॉल करते हैं, तो आप मुख्य फ़ंक्शन को कॉल देख सकते हैं। आप इस लाइन पर कर्सर रख सकते हैं (पता 0x08006ABE ) और कर्सर ऑपरेशन (F4 कुंजी) तक रन करें ।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

उसके बाद, Run पर क्लिक करें और स्क्रिप्ट विंडो को बंद करें।

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

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

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

एमुलेटर इंटरैक्शन

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

हम दिखाते हैं कि RTOS कार्यों की बातचीत को गतिशील रूप से कैसे स्थापित किया जाए। यदि यह चल रहा है तो सबसे पहले, कोड निष्पादन को रोकें। यदि आप "LED" कमांड प्रोसेसिंग ब्रांच में bluetooth_task_entry फंक्शन पर स्विच करते हैं (एड्रेस 0x080057B8 ), तो आप देख सकते हैं कि सबसे पहले क्या बनाया गया है, और फिर ledControlQueueandandle सिस्टम कतार को एक संदेश भेजा जाता है।

आप 0x20000624 पर स्थित ledControlQueueHandle चर का उपयोग करने के लिए ब्रेकपॉइंट सेट करें और कोड निष्पादित करना जारी रखें:

नतीजतन, पहले यह osMailAlloc फ़ंक्शन को कॉल करने से पहले 0x080057CA पते पर 0x080057CA , फिर osMailPut फ़ंक्शन को कॉल करने से पहले 0x08005806 पर, फिर थोड़ी देर के बाद 0x08005BD4 ( osMailGet फ़ंक्शन को कॉल करने से पहले), जो leds_task_entask_ फ़ंक्शन को कॉल करता है। एक कार्य स्विच था, और अब नियंत्रण को एलईडी कार्य मिला है।

ऐसे सरल तरीके से, आप यह स्थापित कर सकते हैं कि RTOS कार्य एक दूसरे के साथ कैसे बातचीत करते हैं।

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

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

Radare2 के साथ लॉन्च

आप इस तरह के एक सार्वभौमिक उपकरण को Radare2 के रूप में अनदेखा नहीं कर सकते।

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

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

अब प्रारंभ ( dc ) और ठहराव निष्पादन (Ctrl + C) उपलब्ध हैं।

दुर्भाग्य से, इस समय r2 में हार्डवेयर gdb सर्वर और मेमोरी मार्कअप के साथ काम करते समय समस्याएं आती हैं, इस वजह से, ब्रेकपॉइंट्स और स्टेप्स ( ds कमांड) काम नहीं करते हैं। हमें उम्मीद है कि यह निकट भविष्य में तय हो जाएगा।

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

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

हम IDE के रूप में STM32 सूट के लिए सिस्टम वर्कबेंच से ग्रहण का उपयोग करेंगे।

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

 bin\kopycat -g 23946 -n rhino -l user -y library -p firmware=null,tty_dbg=COM26,tty_bt=COM28 

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

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

डीबगर टैब पर, आपको GDB कमांड निर्दिष्ट करना होगा:
${openstm32_compiler_path}\arm-none-eabi-gdb

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

"स्टार्टअप" टैब पर निम्नलिखित पैरामीटर निर्दिष्ट किए जाने चाहिए:

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

कृपया ध्यान दें कि यदि आप फर्मवेयर फ़ाइल को ग्रहण से डाउनलोड नहीं करना चाहते हैं, तो आपको लोड छवि और रन कमांड पैरामीटर निर्दिष्ट करने की आवश्यकता नहीं है।

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

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

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

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

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

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

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