🥇 मांजरीच्या आत गेंडा - कोपीकॅट एमुलेटरमध्ये फर्मवेअर लाँच करा

मीटिंगचा भाग म्हणून 0x0A DC7831 DEF CON निझनी नोव्हगोरोड 16 फेब्रुवारी रोजी, आम्ही बायनरी कोड इम्युलेशनची मूलभूत तत्त्वे आणि आमच्या स्वतःच्या विकासावर एक अहवाल सादर केला - हार्डवेअर प्लॅटफॉर्म एमुलेटर नक्कल करणारा.

या लेखात आम्ही एमुलेटरमध्ये डिव्हाइस फर्मवेअर कसे चालवायचे, डीबगरसह परस्परसंवादाचे प्रदर्शन कसे करावे आणि फर्मवेअरचे लहान डायनॅमिक विश्लेषण कसे करावे याचे वर्णन करू.

prehistory

बर्याच काळापूर्वी दूरच्या आकाशगंगेत

काही वर्षांपूर्वी आमच्या प्रयोगशाळेत उपकरणाच्या फर्मवेअरची तपासणी करण्याची गरज होती. फर्मवेअर संकुचित आणि बूटलोडरसह अनपॅक केलेले होते. त्याने हे अत्यंत क्लिष्ट पद्धतीने केले, मेमरीमधील डेटा अनेक वेळा हलवला. आणि फर्मवेअर स्वतः नंतर सक्रियपणे परिधीयांशी संवाद साधला. आणि हे सर्व MIPS कोअरवर.

वस्तुनिष्ठ कारणास्तव, उपलब्ध अनुकरणकर्ते आम्हाला अनुकूल नव्हते, परंतु तरीही आम्हाला कोड चालवायचा होता. मग आम्ही आमचे स्वतःचे एमुलेटर बनवण्याचा निर्णय घेतला, जो किमान करेल आणि आम्हाला मुख्य फर्मवेअर अनपॅक करण्यास अनुमती देईल. आम्ही प्रयत्न केला आणि ते काम केले. आम्ही विचार केला की, मुख्य फर्मवेअर करण्यासाठी पेरिफेरल्स जोडले तर काय होईल. हे फारसे दुखापत झाले नाही - आणि ते देखील कार्य केले. आम्ही पुन्हा विचार केला आणि पूर्ण एमुलेटर बनवण्याचा निर्णय घेतला.

परिणाम म्हणजे संगणक प्रणाली एमुलेटर नक्कल करणारा.

कॉपीकॅट का?

शब्दांवर नाटक आहे.

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

नक्कल करणारा

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

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

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

दोन वर्षांपासून विकास चालू आहे आणि सक्रियपणे चालू आहे. या वेळी, MIPS, x86, V850ES, ARM, आणि PowerPC प्रोसेसर कोर लागू केले गेले.

प्रकल्प वाढत आहे आणि तो व्यापक लोकांसमोर सादर करण्याची वेळ आली आहे. आम्ही नंतर प्रकल्पाचे तपशीलवार वर्णन करू, परंतु सध्या आम्ही कोपीकॅट वापरण्यावर लक्ष केंद्रित करू.

सर्वात अधीरांसाठी, एमुलेटरची प्रोमो आवृत्ती येथून डाउनलोड केली जाऊ शकते दुवा.

एमुलेटर मध्ये गेंडा

याआधी SMARTRHINO-2018 परिषदेसाठी रिव्हर्स इंजिनीअरिंग कौशल्ये शिकवण्यासाठी “गेंडा” हे चाचणी उपकरण तयार करण्यात आले होते. स्थिर फर्मवेअर विश्लेषण प्रक्रियेचे वर्णन केले आहे हा लेख.

आता "स्पीकर" जोडण्याचा प्रयत्न करू आणि एमुलेटरमध्ये फर्मवेअर चालवू.

आम्हाला आवश्यक असेलः
1) Java 1.8
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"]
  ]
}

पॅरामीटरकडे लक्ष द्या फर्मवेअर विभाग params हे एका फाईलचे नाव आहे जे फर्मवेअर म्हणून आभासी उपकरणात लोड केले जाऊ शकते.

व्हर्च्युअल डिव्हाइस आणि मुख्य ऑपरेटिंग सिस्टमसह त्याचा परस्परसंवाद खालील आकृतीद्वारे दर्शविला जाऊ शकतो:

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

बाहेरून एमुलेटरशी संवाद साधण्याचे सध्या दोन मुख्य मार्ग आहेत:

GDB RSP प्रोटोकॉल (त्यानुसार, या प्रोटोकॉलला समर्थन देणारी साधने Eclipse/IDA/radare2 आहेत);
अंतर्गत एमुलेटर कमांड लाइन (आर्गपार्स किंवा पायथन).

आभासी COM पोर्ट

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

com0com वापरणे

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

बॉक्स तपासा बफर ओव्हररन सक्षम करा सर्व तयार केलेल्या व्हर्च्युअल पोर्टसाठी, अन्यथा एमुलेटर COM पोर्टच्या प्रतिसादाची प्रतीक्षा करेल.

socat वापरणे

UNIX सिस्टीमवर, socat युटिलिटी वापरून एमुलेटरद्वारे व्हर्च्युअल COM पोर्ट आपोआप तयार केले जातात; हे करण्यासाठी, एमुलेटर सुरू करताना फक्त पोर्ट नावामध्ये उपसर्ग निर्दिष्ट करा. socat:.

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

कॉपीकॅट हे कन्सोल अॅप्लिकेशन असल्याने, एमुलेटर त्याच्या ऑब्जेक्ट्स आणि व्हेरिएबल्सशी संवाद साधण्यासाठी दोन कमांड लाइन इंटरफेस पर्याय पुरवतो: Argparse आणि Python.

Argparse कॉपीकॅटमध्ये तयार केलेला CLI आहे आणि तो नेहमी प्रत्येकासाठी उपलब्ध आहे.

पर्यायी CLI म्हणजे पायथन इंटरप्रिटर. ते वापरण्यासाठी, तुम्हाला जेप पायथन मॉड्यूल स्थापित करणे आणि पायथनसह कार्य करण्यासाठी एमुलेटर कॉन्फिगर करणे आवश्यक आहे (वापरकर्त्याच्या मुख्य प्रणालीवर स्थापित केलेला पायथन इंटरप्रिटर वापरला जाईल).

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

Linux Jep अंतर्गत pip द्वारे स्थापित केले जाऊ शकते:

pip install jep

Windows वर Jep स्थापित करण्यासाठी, आपण प्रथम Windows SDK आणि संबंधित Microsoft Visual Studio स्थापित करणे आवश्यक आहे. आम्ही तुमच्यासाठी हे थोडे सोपे केले आहे आणि WHL तयार करतो विंडोजसाठी पायथनच्या वर्तमान आवृत्त्यांसाठी जेईपी, त्यामुळे फाइलमधून मॉड्यूल स्थापित केले जाऊ शकते:

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 युटिलिटी वापरून 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 — 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 Pro सह संवाद

चाचणी सुलभ करण्यासाठी, आम्ही IDA मधील विश्लेषणासाठी स्त्रोत फाइल म्हणून Rhino फर्मवेअरचा वापर करतो 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) तुम्ही Rhino प्रोटोकॉलनुसार कमांड टाकू शकता. उदाहरणार्थ, “MEOW” कमांड ब्लूटूथ टर्मिनलवर “mur-mur” स्ट्रिंग परत करेल:

माझे अनुकरण पूर्णपणे नाही

एमुलेटर बनवताना, तुम्ही विशिष्ट उपकरणाच्या तपशील/इम्युलेशनची पातळी निवडू शकता. उदाहरणार्थ, ब्लूटूथ मॉड्यूल वेगवेगळ्या प्रकारे अनुकरण केले जाऊ शकते:

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

एमुलेटरची वर्तमान आवृत्ती दुसरा दृष्टिकोन वापरते - व्हर्च्युअल ब्लूटूथ मॉड्यूल कॉन्फिगरेशन करते, त्यानंतर ते मुख्य सिस्टमच्या COM पोर्टवरून एमुलेटरच्या UART पोर्टवर डेटा “प्रॉक्सी” मोडवर स्विच करते.

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

ध्वज स्वहस्ते रीसेट करून आम्ही या परिस्थितीतून बाहेर पडू शकतो व्यस्त ते स्थापित केल्यानंतर लगेच. IDA Pro मध्ये, तुम्ही पायथन फंक्शन तयार करू शकता आणि त्याला ब्रेकपॉईंटमध्ये कॉल करू शकता आणि फ्लॅगवर व्हॅल्यू 1 लिहिल्यानंतर ब्रेकपॉइंट स्वतः कोडमध्ये ठेवू शकता. व्यस्त.

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

प्रथम, IDA मध्ये पायथन फंक्शन तयार करू. मेनू फाइल - स्क्रिप्ट कमांड...

डावीकडील सूचीमध्ये एक नवीन स्निपेट जोडा, त्याला एक नाव द्या (उदाहरणार्थ, BPT),
उजवीकडील मजकूर फील्डमध्ये, फंक्शन कोड प्रविष्ट करा:

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

त्यानंतर आम्ही दाबतो चालवा आणि स्क्रिप्ट विंडो बंद करा.

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

जर वर्तमान ध्वज मूल्य व्यस्त 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 (एलईडी-टास्क), म्हणजे, कार्ये स्विच केली गेली आणि आता एलईडी-टास्कवर नियंत्रण प्राप्त झाले.

या सोप्या पद्धतीने तुम्ही RTOS कार्ये एकमेकांशी कसा संवाद साधतात हे स्थापित करू शकता.

अर्थात, प्रत्यक्षात, कार्यांचा परस्परसंवाद अधिक क्लिष्ट असू शकतो, परंतु एमुलेटर वापरून, या परस्परसंवादाचा मागोवा घेणे कमी कष्टदायक होते.

येथे तुम्‍ही IDA Pro लाँच करण्‍याचा आणि संवाद साधण्‍याचा एक छोटा व्हिडिओ पाहू शकता.

Radare2 सह लाँच करा

आपण Radare2 सारख्या सार्वत्रिक साधनाकडे दुर्लक्ष करू शकत नाही.

r2 वापरून इम्युलेटरशी कनेक्ट करण्यासाठी, कमांड असे दिसेल:

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

आता उपलब्ध लाँच (dc) आणि अंमलबजावणीला विराम द्या (Ctrl+C).

दुर्दैवाने, याक्षणी, हार्डवेअर gdb सर्व्हर आणि मेमरी लेआउटसह कार्य करताना r2 ला समस्या आहेत; यामुळे, ब्रेकपॉइंट्स आणि स्टेप्स कार्य करत नाहीत (आदेश ds). आम्हाला आशा आहे की हे लवकरच निश्चित केले जाईल.

ग्रहण सह धावणे

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

आम्ही संचातून ग्रहण 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)

त्याऐवजी एक निष्कर्ष

मूळ कोडचे अनुकरण करणे ही एक अतिशय मनोरंजक गोष्ट आहे. डिव्हाइस डेव्हलपरला वास्तविक डिव्हाइसशिवाय फर्मवेअर डीबग करणे शक्य होते. संशोधकासाठी, डायनॅमिक कोडचे विश्लेषण करण्याची ही एक संधी आहे, जी एखाद्या उपकरणासह देखील शक्य नसते.

आम्‍हाला तज्ञांना असे साधन प्रदान करायचे आहे जे सोयीचे, माफक प्रमाणात सोपे आहे आणि सेट अप आणि चालवण्‍यासाठी खूप मेहनत आणि वेळ लागत नाही.

हार्डवेअर एमुलेटर वापरून तुमच्या अनुभवाबद्दल टिप्पण्यांमध्ये लिहा. आम्ही तुम्हाला चर्चा करण्यासाठी आमंत्रित करतो आणि प्रश्नांची उत्तरे देण्यात आनंद होईल.

केवळ नोंदणीकृत वापरकर्तेच सर्वेक्षणात भाग घेऊ शकतात. साइन इन करा, आपले स्वागत आहे.

तुम्ही एमुलेटर कशासाठी वापरत आहात?

मी फर्मवेअर (डीबग) विकसित करतो
मी फर्मवेअरवर संशोधन करत आहे
मी खेळ लाँच करतो (डेंडी, सेगा, पीएसपी)
दुसरे काहीतरी (टिप्पण्यांमध्ये लिहा)

7 वापरकर्त्यांनी मतदान केले. 2 वापरकर्ते दूर राहिले.

मूळ कोडचे अनुकरण करण्यासाठी तुम्ही कोणते सॉफ्टवेअर वापरता?

QEMU
युनिकॉर्न इंजिन
इच्छेनुसार स्वतःचे स्वरुप
दुसरे काहीतरी (टिप्पण्यांमध्ये लिहा)

6 वापरकर्त्यांनी मतदान केले. 2 वापरकर्ते दूर राहिले.

तुम्ही वापरत असलेल्या एमुलेटरमध्ये तुम्हाला काय सुधारायचे आहे?

मला वेग हवा आहे
मला सेटअप/लाँचची सुलभता हवी आहे
मला एमुलेटर (API, हुक) सह संवाद साधण्यासाठी अधिक पर्याय हवे आहेत
मी प्रत्येक गोष्टीत आनंदी आहे
दुसरे काहीतरी (टिप्पण्यांमध्ये लिहा)

8 वापरकर्त्यांनी मतदान केले. 1 वापरकर्ता दूर राहिला.

स्त्रोत: www.habr.com

मांजरीच्या आत गेंडा - कोपीकॅट एमुलेटरमध्ये फर्मवेअर चालवा