Rhinoceros នៅខាងក្នុងឆ្មា - ដំណើរការកម្មវិធីបង្កប់នៅក្នុងកម្មវិធីត្រាប់តាម Kopycat

ជាផ្នែកមួយនៃការប្រជុំ 0x0A DC7831 DEF CON Nizhny Novgorod នៅថ្ងៃទី 16 ខែកុម្ភៈ យើងបានបង្ហាញរបាយការណ៍ស្តីពីគោលការណ៍ជាមូលដ្ឋាននៃការត្រាប់តាមប្រព័ន្ធគោលពីរ និងការអភិវឌ្ឍន៍ផ្ទាល់ខ្លួនរបស់យើង - កម្មវិធីត្រាប់តាមវេទិកាផ្នែករឹង ឆ្មាចម្លង.

នៅក្នុងអត្ថបទនេះ យើងនឹងរៀបរាប់អំពីរបៀបដំណើរការកម្មវិធីបង្កប់ឧបករណ៍នៅក្នុងកម្មវិធីត្រាប់តាម បង្ហាញអន្តរកម្មជាមួយឧបករណ៍បំបាត់កំហុស និងធ្វើការវិភាគថាមវន្តតូចមួយនៃកម្មវិធីបង្កប់។

សម័យបុរេប្រវត្តិសាស្ត្រ

កាលពីយូរយារណាស់មកហើយនៅក្នុងកាឡាក់ស៊ីឆ្ងាយ

ពីរបីឆ្នាំមុននៅក្នុងមន្ទីរពិសោធន៍របស់យើងមានតម្រូវការដើម្បីស៊ើបអង្កេតកម្មវិធីបង្កប់នៃឧបករណ៍មួយ។ កម្មវិធីបង្កប់ត្រូវបានបង្ហាប់ និងពន្លាជាមួយកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ។ គាត់​ធ្វើ​បែប​នេះ​ក្នុង​វិធី​ដ៏​ស្មុគស្មាញ ដោយ​ប្តូរ​ទិន្នន័យ​ក្នុង​អង្គចងចាំ​ច្រើន​ដង។ ហើយកម្មវិធីបង្កប់ខ្លួនវាបន្ទាប់មកមានអន្តរកម្មយ៉ាងសកម្មជាមួយគ្រឿងកុំព្យូទ័រ។ ហើយទាំងអស់នេះនៅលើស្នូល MIPS ។

សម្រាប់ហេតុផលគោលបំណង កម្មវិធីត្រាប់តាមដែលមានមិនសមនឹងយើងទេ ប៉ុន្តែយើងនៅតែចង់ដំណើរការកូដ។ បន្ទាប់មក យើងបានសម្រេចចិត្តបង្កើតកម្មវិធីត្រាប់តាមផ្ទាល់ខ្លួនរបស់យើង ដែលនឹងធ្វើអប្បបរមា និងអនុញ្ញាតឱ្យយើងពន្លាកម្មវិធីបង្កប់សំខាន់។ យើងបានសាកល្បងវាហើយវាដំណើរការ។ យើងបានគិតថាតើមានអ្វីកើតឡើងប្រសិនបើយើងបន្ថែមគ្រឿងកុំព្យូទ័រដើម្បីដំណើរការកម្មវិធីបង្កប់សំខាន់។ វាមិនឈឺចាប់ខ្លាំងទេ - ហើយវាក៏ដំណើរការផងដែរ។ យើងគិតម្តងទៀត ហើយសម្រេចចិត្តបង្កើតកម្មវិធីត្រាប់តាមពេញលក្ខណៈ។

លទ្ធផលគឺកម្មវិធីត្រាប់តាមប្រព័ន្ធកុំព្យូទ័រ ឆ្មាចម្លង.

ហេតុអ្វី Kopycat?

មានការលេងនៅលើពាក្យ។

1. copycat (ភាសាអង់គ្លេស noun [ˈkɒpɪkæt]) - អ្នកត្រាប់តាម, អ្នកត្រាប់តាម
2. ឆ្មា (ភាសាអង់គ្លេស noun [ˈkæt]) - cat, cat - សត្វសំណព្វរបស់អ្នកបង្កើតគម្រោង
3. អក្សរ "K" គឺមកពីភាសាសរសេរកម្មវិធី Kotlin

ឆ្មាចម្លង

នៅពេលបង្កើតកម្មវិធីត្រាប់តាម គោលដៅជាក់លាក់ត្រូវបានកំណត់៖

• សមត្ថភាពក្នុងការបង្កើតគ្រឿងកុំព្យូទ័រថ្មី ម៉ូឌុល ស្នូលខួរក្បាល
• សមត្ថភាពក្នុងការប្រមូលផ្តុំឧបករណ៍និម្មិតពីម៉ូឌុលផ្សេងៗ។
• សមត្ថភាពក្នុងការផ្ទុកទិន្នន័យគោលពីរ (កម្មវិធីបង្កប់) ទៅក្នុងអង្គចងចាំរបស់ឧបករណ៍និម្មិត។
• សមត្ថភាពក្នុងការធ្វើការជាមួយរូបថត (រូបថតនៃស្ថានភាពប្រព័ន្ធ);
• សមត្ថភាពក្នុងការធ្វើអន្តរកម្មជាមួយកម្មវិធីត្រាប់តាមតាមរយៈឧបករណ៍បំបាត់កំហុសដែលភ្ជាប់មកជាមួយ;
• ភាសាទំនើបល្អសម្រាប់ការអភិវឌ្ឍន៍។

ជាលទ្ធផល Kotlin ត្រូវបានជ្រើសរើសសម្រាប់ការអនុវត្ត ស្ថាបត្យកម្មឡានក្រុង (នេះគឺជាពេលដែលម៉ូឌុលទំនាក់ទំនងគ្នាទៅវិញទៅមកតាមរយៈឡានក្រុងទិន្នន័យនិម្មិត) JSON ជាទម្រង់ពិពណ៌នាឧបករណ៍ និង GDB RSP ជាពិធីការសម្រាប់អន្តរកម្មជាមួយឧបករណ៍បំបាត់កំហុស។

ការអភិវឌ្ឍន៍បានបន្តក្នុងរយៈពេលជាងពីរឆ្នាំ ហើយកំពុងដំណើរការយ៉ាងសកម្ម។ ក្នុងអំឡុងពេលនេះ ស្នូលដំណើរការ MIPS, x86, V850ES, ARM និង PowerPC ត្រូវបានអនុវត្ត។

គម្រោងនេះកំពុងរីកចម្រើន ហើយដល់ពេលត្រូវបង្ហាញវាដល់សាធារណជនកាន់តែទូលំទូលាយ។ យើងនឹងធ្វើការពិពណ៌នាលម្អិតអំពីគម្រោងនៅពេលក្រោយ ប៉ុន្តែសម្រាប់ពេលនេះ យើងនឹងផ្តោតលើការប្រើប្រាស់ Kopycat ។

សម្រាប់អ្នកដែលមិនចេះអត់ធ្មត់បំផុត កំណែផ្សព្វផ្សាយនៃកម្មវិធីត្រាប់តាមអាចទាញយកបានពី តំណភ្ជាប់.

Rhino នៅក្នុងកម្មវិធីត្រាប់តាម

ចូរយើងចាំថាមុននេះសម្រាប់សន្និសីទ SMARTRHINO-2018 ឧបករណ៍សាកល្បង "រមាស" ត្រូវបានបង្កើតឡើងសម្រាប់ការបង្រៀនជំនាញវិស្វកម្មបញ្ច្រាស។ ដំណើរការនៃការវិភាគកម្មវិធីបង្កប់ឋិតិវន្តត្រូវបានពិពណ៌នានៅក្នុង អត្ថបទនេះ.

ឥឡូវនេះសូមព្យាយាមបន្ថែម "វាគ្មិន" ហើយដំណើរការកម្មវិធីបង្កប់នៅក្នុងកម្មវិធីត្រាប់តាម។

យើងនឹងត្រូវការ:
1) Java 1.8
2) Python និងម៉ូឌុល ជ ដើម្បីប្រើ Python នៅខាងក្នុងកម្មវិធីត្រាប់តាម។ អ្នកអាចបង្កើតម៉ូឌុល WHL Jep សម្រាប់ Windows ទាញយកនៅទីនេះ.

សម្រាប់វីនដូ៖
1) com0com
2) PuTTY

សម្រាប់លីនុច៖
1) socat

អ្នកអាចប្រើ Eclipse, IDA Pro ឬ radare2 ជាម៉ាស៊ីនភ្ញៀវ GDB ។

តើវាដំណើរការយ៉ាងដូចម្តេច?

ដើម្បីអនុវត្តកម្មវិធីបង្កប់ក្នុងកម្មវិធីត្រាប់តាម វាចាំបាច់ក្នុងការ "ប្រមូលផ្តុំ" ឧបករណ៍និម្មិត ដែលជា analogue នៃឧបករណ៍ពិត។

ឧបករណ៍ពិត ("រមាស") អាចត្រូវបានបង្ហាញនៅក្នុងដ្យាក្រាមប្លុក៖

កម្មវិធីត្រាប់តាមមានរចនាសម្ព័ន្ធម៉ូឌុល ហើយឧបករណ៍និម្មិតចុងក្រោយអាចត្រូវបានពិពណ៌នានៅក្នុងឯកសារ 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 នៃ OS ចម្បង (បំបាត់កំហុស 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

នៅលើប្រព័ន្ធយូនីក ច្រក COM និម្មិតត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិដោយកម្មវិធីត្រាប់តាមដោយប្រើឧបករណ៍ប្រើប្រាស់ socat ដើម្បីធ្វើដូចនេះគ្រាន់តែបញ្ជាក់បុព្វបទនៅក្នុងឈ្មោះច្រកនៅពេលចាប់ផ្តើមកម្មវិធីត្រាប់តាម socat:.

ចំណុចប្រទាក់បន្ទាត់ពាក្យបញ្ជាខាងក្នុង (Argparse ឬ Python)

ដោយសារ Kopycat គឺជាកម្មវិធីកុងសូល កម្មវិធីត្រាប់តាមផ្តល់ជម្រើសចំណុចប្រទាក់បន្ទាត់ពាក្យបញ្ជាពីរសម្រាប់អន្តរកម្មជាមួយវត្ថុ និងអថេររបស់វា៖ Argparse និង Python ។

Argparse គឺជា CLI ដែលត្រូវបានបង្កើតឡើងនៅក្នុង Kopycat ហើយតែងតែមានសម្រាប់មនុស្សគ្រប់គ្នា។

CLI ជំនួសគឺអ្នកបកប្រែ Python ។ ដើម្បីប្រើវា អ្នកត្រូវដំឡើងម៉ូឌុល Jep Python ហើយកំណត់រចនាសម្ព័ន្ធកម្មវិធីត្រាប់តាមដើម្បីធ្វើការជាមួយ Python (អ្នកបកប្រែ Python ដែលបានដំឡើងនៅលើប្រព័ន្ធសំខាន់របស់អ្នកប្រើនឹងត្រូវបានប្រើ) ។

ការដំឡើង Python module Jep

នៅក្រោម Linux Jep អាចត្រូវបានដំឡើងតាមរយៈ pip:

pip install jep

ដើម្បីដំឡើង Jep នៅលើ Windows ដំបូងអ្នកត្រូវតែដំឡើង Windows SDK និង Microsoft Visual Studio ដែលត្រូវគ្នា។ យើងបានធ្វើឱ្យវាកាន់តែងាយស្រួលសម្រាប់អ្នក និង WHL បង្កើត JEP សម្រាប់កំណែបច្ចុប្បន្ននៃ Python សម្រាប់ Windows ដូច្នេះម៉ូឌុលអាចត្រូវបានដំឡើងពីឯកសារ៖

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.

នៅក្នុងឯកសារ emulator batch សម្រាប់ប្រព័ន្ធរបស់អ្នក (copycat.bat - សម្រាប់ Windows, ឆ្មាចម្លង - សម្រាប់លីនុច) ទៅបញ្ជីប៉ារ៉ាម៉ែត្រ DEFAULT_JVM_OPTS បន្ថែមប៉ារ៉ាម៉ែត្របន្ថែម Djava.library.path - វាត្រូវតែមានផ្លូវទៅកាន់ម៉ូឌុល Jep ដែលបានដំឡើង។

លទ្ធផលសម្រាប់ Windows គួរតែជាបន្ទាត់ដូចនេះ៖

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 Pro

ដើម្បីសម្រួលការសាកល្បង យើងប្រើកម្មវិធីបង្កប់ Rhino ជាឯកសារប្រភពសម្រាប់ការវិភាគក្នុង IDA ក្នុងទម្រង់ ឯកសារ ELF (ព័ត៌មានមេតាត្រូវបានរក្សាទុកនៅទីនោះ) ។

អ្នកក៏អាចប្រើកម្មវិធីបង្កប់ចម្បងដោយគ្មានព័ត៌មានមេតា។

បន្ទាប់ពីបើកដំណើរការ Kopycat នៅក្នុង IDA Pro នៅក្នុងម៉ឺនុយ Debugger សូមចូលទៅកាន់ធាតុ "ប្ដូរ​កម្មវិធី​បំបាត់​កំហុស..."ហើយជ្រើសរើស"ឧបករណ៍បំបាត់កំហុស GDB ពីចម្ងាយ"។ បន្ទាប់មកកំណត់ការតភ្ជាប់៖ ម៉ឺនុយ កម្មវិធីបំបាត់កំហុស - ជម្រើសដំណើរការ...

កំណត់តម្លៃ៖

• កម្មវិធី - តម្លៃណាមួយ។
• ឈ្មោះម៉ាស៊ីន៖ 127.0.0.1 (ឬអាសយដ្ឋាន IP របស់ម៉ាស៊ីនពីចម្ងាយ ដែល Kopycat កំពុងដំណើរការ)
• ច្រក: 23946

ឥឡូវនេះប៊ូតុងបំបាត់កំហុសអាចប្រើបាន (គ្រាប់ចុច F9)៖

ចុចវាដើម្បីភ្ជាប់ទៅម៉ូឌុលបំបាត់កំហុសនៅក្នុងកម្មវិធីត្រាប់តាម។ IDA ចូលទៅក្នុងរបៀបបំបាត់កំហុស បង្អួចបន្ថែមអាចរកបាន៖ ព័ត៌មានអំពីការចុះឈ្មោះ អំពីជង់។

ឥឡូវនេះ យើងអាចប្រើលក្ខណៈស្តង់ដារទាំងអស់នៃកម្មវិធីបំបាត់កំហុស៖

• ការអនុវត្តការណែនាំជាជំហាន ៗ (បោះ​ជំហាន​ចូល​ទៅ​ក្នុង и បោះជំហានទៅមុខ - គ្រាប់ចុច F7 និង F8 រៀងគ្នា);
• ចាប់ផ្តើមនិងផ្អាកការអនុវត្ត;
• បង្កើតចំណុចបំបែកសម្រាប់ទាំងកូដ និងទិន្នន័យ (គ្រាប់ចុច F2) ។

ការភ្ជាប់ទៅឧបករណ៍បំបាត់កំហុសមិនមានន័យថាដំណើរការកូដកម្មវិធីបង្កប់នោះទេ។ ទីតាំងប្រតិបត្តិបច្ចុប្បន្នត្រូវតែជាអាសយដ្ឋាន 0x08006A74 - ការចាប់ផ្តើមនៃមុខងារ Reset_Handler. ប្រសិនបើអ្នករមូរចុះក្រោមការចុះបញ្ជី អ្នកអាចឃើញការហៅមុខងារ សំខាន់. អ្នកអាចដាក់ទស្សន៍ទ្រនិចនៅលើបន្ទាត់នេះ (អាសយដ្ឋាន 0x08006ABE) និងអនុវត្តប្រតិបត្តិការ រត់រហូតដល់ទស្សន៍ទ្រនិច (គន្លឹះ F4) ។

បន្ទាប់មកអ្នកអាចចុច F7 ដើម្បីបញ្ចូលមុខងារ សំខាន់.

ពាក្យបញ្ជា Esli vypolnit បន្តដំណើរការ (គ្រាប់ចុច F9) បន្ទាប់មកបង្អួច "សូមរង់ចាំ" នឹងបង្ហាញដោយប៊ូតុងតែមួយ ផ្អាក:

នៅពេលអ្នកចុច ផ្អាក ការប្រតិបត្តិកូដកម្មវិធីបង្កប់ត្រូវបានផ្អាក ហើយអាចបន្តពីអាសយដ្ឋានដូចគ្នានៅក្នុងកូដដែលវាត្រូវបានរំខាន។

ប្រសិនបើអ្នកបន្តប្រតិបត្តិកូដ អ្នកនឹងឃើញបន្ទាត់ខាងក្រោមនៅក្នុងស្ថានីយដែលភ្ជាប់ទៅច្រក COM និម្មិត៖

វត្តមាននៃបន្ទាត់ "ផ្លូវវាងរដ្ឋ" បង្ហាញថាម៉ូឌុលប៊្លូធូសនិម្មិតបានប្តូរទៅរបៀបទទួលទិន្នន័យពីច្រក COM របស់អ្នកប្រើ។

ឥឡូវនេះនៅក្នុងស្ថានីយប៊្លូធូស (COM29 ក្នុងរូបភាព) អ្នកអាចបញ្ចូលពាក្យបញ្ជាដោយអនុលោមតាមពិធីការ Rhino ។ ឧទាហរណ៍ ពាក្យបញ្ជា "MEOW" នឹងត្រឡប់ខ្សែអក្សរ "mur-mur" ទៅស្ថានីយប៊្លូធូស៖

ធ្វើត្រាប់តាមខ្ញុំមិនទាំងស្រុងទេ។

នៅពេលបង្កើតកម្មវិធីត្រាប់តាម អ្នកអាចជ្រើសរើសកម្រិតលម្អិត/ការត្រាប់តាមឧបករណ៍ជាក់លាក់មួយ។ ឧទាហរណ៍ ម៉ូឌុលប៊្លូធូសអាចត្រូវបានត្រាប់តាមតាមវិធីផ្សេងៗគ្នា៖

• ឧបករណ៍នេះត្រូវបានត្រាប់តាមយ៉ាងពេញលេញជាមួយនឹងសំណុំពេញលេញនៃពាក្យបញ្ជា;
• ពាក្យបញ្ជា AT ត្រូវបានត្រាប់តាម ហើយស្ទ្រីមទិន្នន័យត្រូវបានទទួលពីច្រក COM នៃប្រព័ន្ធមេ។
• ឧបករណ៍និម្មិតផ្តល់នូវការបញ្ជូនទិន្នន័យពេញលេញទៅកាន់ឧបករណ៍ពិត។
• ជា​ដើម​ធម្មតា​ដែល​តែងតែ​ត្រឡប់ "យល់ព្រម"។

កំណែបច្ចុប្បន្ននៃកម្មវិធីត្រាប់តាមប្រើវិធីសាស្រ្តទីពីរ - ម៉ូឌុលប៊្លូធូសនិម្មិតអនុវត្តការកំណត់រចនាសម្ព័ន្ធ បន្ទាប់ពីនោះវាប្តូរទៅរបៀប "ប្រូកស៊ី" ទិន្នន័យពីច្រក COM នៃប្រព័ន្ធមេទៅច្រក UART នៃកម្មវិធីត្រាប់តាម។

ចូរយើងពិចារណាពីលទ្ធភាពនៃឧបករណ៍សាមញ្ញនៃកូដក្នុងករណីដែលផ្នែកខ្លះនៃបរិមាត្រមិនត្រូវបានអនុវត្ត។ ឧទាហរណ៍ ប្រសិនបើកម្មវិធីកំណត់ម៉ោងដែលទទួលខុសត្រូវក្នុងការគ្រប់គ្រងការផ្ទេរទិន្នន័យទៅ DMA មិនត្រូវបានបង្កើតទេ (ការត្រួតពិនិត្យត្រូវបានអនុវត្តនៅក្នុងមុខងារ ws2812b_រង់ចាំ, raspolojennoy po adresu 0x08006840) បន្ទាប់មកកម្មវិធីបង្កប់នឹងរង់ចាំជានិច្ចសម្រាប់ទង់ត្រូវបានកំណត់ឡើងវិញ រវល់មាន​ទី​តាំង​នៅ 0x200004C4ដែលបង្ហាញពីការកាន់កាប់នៃខ្សែទិន្នន័យ DMA៖

យើងអាចទទួលបានជុំវិញស្ថានភាពនេះដោយកំណត់ទង់ឡើងវិញដោយដៃ រវល់ ភ្លាមៗបន្ទាប់ពីដំឡើងវា។ នៅក្នុង IDA Pro អ្នកអាចបង្កើតមុខងារ Python ហើយហៅវានៅក្នុង breakpoint ហើយដាក់ breakpoint ខ្លួនវានៅក្នុង code បន្ទាប់ពីសរសេរតម្លៃ 1 ទៅកាន់ flag រវល់.

ឧបករណ៍ដោះស្រាយចំណុចបំបែក

ជាដំបូង ចូរយើងបង្កើតមុខងារ Python នៅក្នុង IDA។ ម៉ឺនុយ ឯកសារ - ពាក្យបញ្ជាស្គ្រីប...

បន្ថែម​អត្ថបទ​ខ្លី​ថ្មី​មួយ​ក្នុង​បញ្ជី​នៅ​ខាង​ឆ្វេង ផ្តល់​ឈ្មោះ​វា (ឧទាហរណ៍ ប៊ី។ ប៊ី។ ធី),
នៅក្នុងវាលអត្ថបទនៅខាងស្តាំ បញ្ចូលកូដមុខងារ៖

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

បន្ទាប់ពីនោះចុច រត់ ហើយបិទបង្អួចស្គ្រីប។

ឥឡូវ​យើង​ចូល​ទៅ​កាន់​លេខ​កូដ 0x0800688Aកំណត់ចំណុចឈប់ (គ្រាប់ចុច F2) កែសម្រួលវា (ម៉ឺនុយបរិបទ កែសម្រួលចំណុចឈប់...) កុំភ្លេចកំណត់ប្រភេទស្គ្រីបទៅ Python៖

ប្រសិនបើតម្លៃទង់បច្ចុប្បន្ន រវល់ ស្មើនឹង 1 បន្ទាប់មកអ្នកគួរតែប្រតិបត្តិមុខងារ រំលង_dma នៅក្នុងបន្ទាត់ស្គ្រីប៖

ប្រសិនបើអ្នកដំណើរការកម្មវិធីបង្កប់សម្រាប់ការប្រតិបត្តិ អ្នកអាចឃើញការកេះកូដកម្មវិធីគ្រប់គ្រងចំណុចឈប់នៅក្នុងបង្អួច IDA ទិន្នផល តាមបន្ទាត់ Skipping wait ws2812.... ឥឡូវនេះកម្មវិធីបង្កប់នឹងមិនរង់ចាំឱ្យទង់ត្រូវបានកំណត់ឡើងវិញទេ។ រវល់.

អន្តរកម្មជាមួយកម្មវិធីត្រាប់តាម

ការធ្វើត្រាប់តាមសម្រាប់ជាប្រយោជន៍នៃការធ្វើត្រាប់តាមទំនងជាមិនបង្កឱ្យមានភាពរីករាយ និងរីករាយនោះទេ។ វាគួរឱ្យចាប់អារម្មណ៍ជាងនេះទៅទៀត ប្រសិនបើកម្មវិធីត្រាប់តាមជួយឱ្យអ្នកស្រាវជ្រាវមើលឃើញទិន្នន័យនៅក្នុងសតិ ឬបង្កើតអន្តរកម្មនៃខ្សែស្រឡាយ។

យើងនឹងបង្ហាញអ្នកពីរបៀបបង្កើតអន្តរកម្មយ៉ាងសកម្មរវាងកិច្ចការ RTOS ។ ដំបូងអ្នកគួរតែផ្អាកការប្រតិបត្តិនៃកូដប្រសិនបើវាកំពុងដំណើរការ។ ប្រសិនបើអ្នកចូលទៅកាន់មុខងារ bluetooth_task_entry ទៅសាខាដំណើរការនៃពាក្យបញ្ជា "LED" (អាសយដ្ឋាន 0x080057B8) បន្ទាប់មកអ្នកអាចឃើញអ្វីដែលត្រូវបានបង្កើតដំបូងហើយបន្ទាប់មកផ្ញើទៅជួរប្រព័ន្ធ ledControlQueueHandle សារខ្លះ។

អ្នកគួរតែកំណត់ចំណុចឈប់ដើម្បីចូលប្រើអថេរ ledControlQueueHandle, raspolojennoy po adresu 0x20000624 ហើយបន្តដំណើរការកូដ៖

ជាលទ្ធផលការឈប់នឹងកើតឡើងដំបូងនៅអាសយដ្ឋាន 0x080057CA មុនពេលហៅមុខងារ osMailAllocបន្ទាប់មកនៅអាសយដ្ឋាន 0x08005806 មុនពេលហៅមុខងារ osMailPutបន្ទាប់មកមួយសន្ទុះ - ទៅអាសយដ្ឋាន 0x08005BD4 (មុនពេលហៅមុខងារ osMailGet) ដែលជាកម្មសិទ្ធិរបស់មុខងារ leds_task_entry (LED-task) នោះគឺ ភារកិច្ចបានប្តូរ ហើយឥឡូវនេះ LED-task បានទទួលការគ្រប់គ្រង។

តាមរបៀបសាមញ្ញនេះ អ្នកអាចបង្កើតរបៀបដែលកិច្ចការ RTOS ទាក់ទងគ្នាទៅវិញទៅមក។

ជាការពិតណាស់ អន្តរកម្មនៃកិច្ចការអាចមានភាពស្មុគស្មាញជាង ប៉ុន្តែការប្រើកម្មវិធីត្រាប់តាម ការតាមដានអន្តរកម្មនេះកាន់តែពិបាក។

នៅទីនេះ អ្នកអាចមើលវីដេអូខ្លីនៃការបើកដំណើរការកម្មវិធីត្រាប់តាម និងធ្វើអន្តរកម្មជាមួយ IDA Pro។

បើកដំណើរការជាមួយ Radare2

អ្នកមិនអាចព្រងើយកន្តើយចំពោះឧបករណ៍សកលដូចជា Radare2 នោះទេ។

ដើម្បីភ្ជាប់ទៅកម្មវិធីត្រាប់តាមដោយប្រើ r2 ពាក្យបញ្ជានឹងមើលទៅដូចនេះ៖

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

បើកដំណើរការឥឡូវនេះ (dc) និងផ្អាកការប្រតិបត្តិ (Ctrl+C)។

ជាអកុសល នៅពេលនេះ r2 មានបញ្ហានៅពេលធ្វើការជាមួយ hardware gdb server និង memory layout ដោយសារតែបញ្ហានេះ ចំនុចបំបែក និងជំហានមិនដំណើរការ (ពាក្យបញ្ជា ds) យើងសង្ឃឹមថាវានឹងត្រូវបានជួសជុលក្នុងពេលឆាប់ៗនេះ។

រត់ជាមួយ Eclipse

ជម្រើសមួយក្នុងចំណោមជម្រើសសម្រាប់ប្រើកម្មវិធីត្រាប់តាមគឺដើម្បីបំបាត់កំហុសកម្មវិធីបង្កប់របស់ឧបករណ៍ដែលកំពុងត្រូវបានបង្កើត។ សម្រាប់ភាពច្បាស់លាស់ យើងក៏នឹងប្រើកម្មវិធីបង្កប់ Rhino ផងដែរ។ អ្នកអាចទាញយកប្រភពកម្មវិធីបង្កប់ ពីទីនេះ.

យើងនឹងប្រើ Eclipse ពីសំណុំជា IDE ប្រព័ន្ធការងារសម្រាប់ STM32.

ដើម្បីឱ្យកម្មវិធីត្រាប់តាមអាចផ្ទុកកម្មវិធីបង្កប់ដែលចងក្រងដោយផ្ទាល់នៅក្នុង Eclipse អ្នកត្រូវបន្ថែមប៉ារ៉ាម៉ែត្រ 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 - អាសយដ្ឋានត្រូវបានរក្សាទុកនៅទីនោះ ResetHandler).

យកចិត្តទុកដាក់ប្រសិនបើអ្នកមិនចង់ទាញយកឯកសារកម្មវិធីបង្កប់ពី Eclipse នោះជម្រើស ផ្ទុករូបភាព и ដំណើរការពាក្យបញ្ជា មិនចាំបាច់ចង្អុលបង្ហាញទេ។

បន្ទាប់ពីចុច Debug អ្នកអាចធ្វើការក្នុងរបៀបបំបាត់កំហុស៖

• ការប្រតិបត្តិលេខកូដជាជំហាន ៗ
  
• អន្តរកម្មជាមួយចំណុចឈប់
  

ការកត់សម្គាល់. សូរ្យគ្រាសមាន ហ៊ឺម... ចម្លែកខ្លះ... ហើយអ្នកត្រូវតែរស់នៅជាមួយពួកគេ។ ឧទាហរណ៍ប្រសិនបើនៅពេលចាប់ផ្តើមកម្មវិធីបំបាត់កំហុសសារ "គ្មានប្រភពសម្រាប់ "0x0" លេចឡើងបន្ទាប់មកប្រតិបត្តិពាក្យបញ្ជាជំហាន (F5) ។

ជំនួសឱ្យការសន្និដ្ឋានមួយ

ការត្រាប់តាមកូដដើមគឺជារឿងគួរឱ្យចាប់អារម្មណ៍ណាស់។ សម្រាប់អ្នកអភិវឌ្ឍន៍ឧបករណ៍ វាអាចបំបាត់កំហុសកម្មវិធីបង្កប់ដោយគ្មានឧបករណ៍ពិត។ សម្រាប់អ្នកស្រាវជ្រាវ វាគឺជាឱកាសមួយដើម្បីធ្វើការវិភាគកូដថាមវន្ត ដែលមិនតែងតែអាចធ្វើទៅបានសូម្បីតែជាមួយឧបករណ៍ក៏ដោយ។

យើងចង់ផ្តល់ឱ្យអ្នកឯកទេសនូវឧបករណ៍ដែលងាយស្រួល សាមញ្ញល្មម និងមិនចំណាយពេលច្រើនក្នុងការរៀបចំ និងដំណើរការ។

សរសេរនៅក្នុងមតិយោបល់អំពីបទពិសោធន៍របស់អ្នកដោយប្រើឧបករណ៍ត្រាប់តាមផ្នែករឹង។ យើងសូមអញ្ជើញអ្នកឱ្យពិភាក្សា ហើយនឹងរីករាយក្នុងការឆ្លើយសំណួរ។

មានតែអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះប៉ុណ្ណោះដែលអាចចូលរួមក្នុងការស្ទង់មតិនេះ។ ចូលសូម។

តើអ្នកប្រើកម្មវិធីត្រាប់តាមដើម្បីអ្វី?

• ខ្ញុំបង្កើតកម្មវិធីបង្កប់ (បំបាត់កំហុស)

• ខ្ញុំកំពុងស្រាវជ្រាវកម្មវិធីបង្កប់

• ខ្ញុំបើកដំណើរការហ្គេម (Dendi, Sega, PSP)

• អ្វីផ្សេងទៀត (សរសេរនៅក្នុងមតិយោបល់)

អ្នកប្រើប្រាស់ 7 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ ៦៣ នាក់ត្រូវបានហាមឃាត់។

តើអ្នកប្រើកម្មវិធីអ្វីដើម្បីត្រាប់តាមកូដដើម?

• ខេមយូ

• ម៉ាស៊ីន Unicorn

• Proteus

• អ្វីផ្សេងទៀត (សរសេរនៅក្នុងមតិយោបល់)

អ្នកប្រើប្រាស់ 6 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ ៦៣ នាក់ត្រូវបានហាមឃាត់។

តើអ្នកចង់កែលម្អអ្វីនៅក្នុងកម្មវិធីត្រាប់តាមដែលអ្នកកំពុងប្រើ?

• ខ្ញុំចង់បានល្បឿន

• ខ្ញុំចង់បានភាពងាយស្រួលនៃការដំឡើង/បើកដំណើរការ

• ខ្ញុំចង់បានជម្រើសបន្ថែមទៀតសម្រាប់ការធ្វើអន្តរកម្មជាមួយកម្មវិធីត្រាប់តាម (API, hooks)

• ខ្ញុំសប្បាយចិត្តនឹងអ្វីៗទាំងអស់។

• អ្វីផ្សេងទៀត (សរសេរនៅក្នុងមតិយោបល់)

អ្នកប្រើប្រាស់ 8 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ 1 នាក់ត្រូវបានហាមឃាត់។

ប្រភព: www.habr.com