ഒരു പൂച്ചയ്ക്കുള്ളിൽ കാണ്ടാമൃഗം - കോപ്പികാറ്റ് എമുലേറ്ററിൽ ഫേംവെയർ പ്രവർത്തിപ്പിക്കുക

മീറ്റിംഗിന്റെ ഭാഗമായി 0x0A DC7831 DEF CON നിസ്നി നോവ്ഗൊറോഡ് ഫെബ്രുവരി 16 ന്, ബൈനറി കോഡ് എമുലേഷന്റെ അടിസ്ഥാന തത്വങ്ങളെയും ഞങ്ങളുടെ സ്വന്തം വികസനത്തെയും കുറിച്ചുള്ള ഒരു റിപ്പോർട്ട് ഞങ്ങൾ അവതരിപ്പിച്ചു - ഒരു ഹാർഡ്‌വെയർ പ്ലാറ്റ്ഫോം എമുലേറ്റർ കോപ്പികാറ്റ്.

ഈ ലേഖനത്തിൽ, എമുലേറ്ററിൽ ഉപകരണ ഫേംവെയർ എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്നും, ഡീബഗ്ഗറുമായുള്ള ആശയവിനിമയം എങ്ങനെ നടത്താമെന്നും, ഫേംവെയറിന്റെ ഒരു ചെറിയ ചലനാത്മക വിശകലനം നടത്താമെന്നും ഞങ്ങൾ വിവരിക്കും.

ചരിത്രാതീതകാലം

വളരെ ദൂരെയുള്ള ഒരു ഗാലക്സിയിൽ വളരെക്കാലം മുമ്പ്

കുറച്ച് വർഷങ്ങൾക്ക് മുമ്പ്, ഞങ്ങളുടെ ലബോറട്ടറിയിൽ ഒരു ഉപകരണത്തിന്റെ ഫേംവെയർ പരിശോധിക്കേണ്ടതിന്റെ ആവശ്യകത ഉണ്ടായിരുന്നു. ഫേംവെയർ ഒരു ബൂട്ട്ലോഡർ ഉപയോഗിച്ച് കംപ്രസ് ചെയ്യുകയും അൺപാക്ക് ചെയ്യുകയും ചെയ്തു. വളരെ സങ്കീര് ണമായ രീതിയിലാണ് അദ്ദേഹം ഇത് ചെയ്തത്, മെമ്മറിയിലെ ഡാറ്റ പലതവണ മാറ്റി. ഫേംവെയർ തന്നെ പിന്നീട് പെരിഫറലുകളുമായി സജീവമായി സംവദിച്ചു. MIPS കോറിൽ ഇതെല്ലാം.

വസ്തുനിഷ്ഠമായ കാരണങ്ങളാൽ, ലഭ്യമായ എമുലേറ്ററുകൾ ഞങ്ങൾക്ക് അനുയോജ്യമല്ല, പക്ഷേ ഞങ്ങൾ ഇപ്പോഴും കോഡ് പ്രവർത്തിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു. തുടർന്ന് ഞങ്ങൾ സ്വന്തമായി എമുലേറ്റർ നിർമ്മിക്കാൻ തീരുമാനിച്ചു, അത് ഏറ്റവും കുറഞ്ഞത് ചെയ്യുകയും പ്രധാന ഫേംവെയർ അൺപാക്ക് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുകയും ചെയ്യും. ഞങ്ങൾ അത് പരീക്ഷിച്ചു, അത് പ്രവർത്തിച്ചു. പ്രധാന ഫേംവെയർ നിർവഹിക്കുന്നതിന് പെരിഫറലുകൾ ചേർത്താലോ എന്ന് ഞങ്ങൾ ചിന്തിച്ചു. ഇത് വളരെയധികം വേദനിപ്പിച്ചില്ല - അതും പ്രവർത്തിച്ചു. ഞങ്ങൾ വീണ്ടും ആലോചിച്ച് ഒരു പൂർണ്ണ എമുലേറ്റർ നിർമ്മിക്കാൻ തീരുമാനിച്ചു.

ഒരു കമ്പ്യൂട്ടർ സിസ്റ്റം എമുലേറ്ററായിരുന്നു ഫലം കോപ്പികാറ്റ്.

എന്തുകൊണ്ട് കോപ്പികാറ്റ്?

വാക്കുകളിൽ ഒരു കളിയുണ്ട്.

1. copycat (ഇംഗ്ലീഷ്, നാമം [ˈkɒpɪkæt]) - അനുകരണം, അനുകരണം
2. പൂച്ച (ഇംഗ്ലീഷ്, നാമം [ˈkæt]) - പൂച്ച, പൂച്ച - പദ്ധതിയുടെ സ്രഷ്‌ടാക്കളിൽ ഒരാളുടെ പ്രിയപ്പെട്ട മൃഗം
3. "കെ" എന്ന അക്ഷരം കോട്ലിൻ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ നിന്നാണ്

കോപ്പികാറ്റ്

എമുലേറ്റർ സൃഷ്ടിക്കുമ്പോൾ, വളരെ നിർദ്ദിഷ്ട ലക്ഷ്യങ്ങൾ സജ്ജമാക്കി:

• പുതിയ പെരിഫറലുകൾ, മൊഡ്യൂളുകൾ, പ്രോസസർ കോറുകൾ എന്നിവ വേഗത്തിൽ സൃഷ്ടിക്കാനുള്ള കഴിവ്;
• വിവിധ മൊഡ്യൂളുകളിൽ നിന്ന് ഒരു വെർച്വൽ ഉപകരണം കൂട്ടിച്ചേർക്കാനുള്ള കഴിവ്;
• ഒരു വെർച്വൽ ഉപകരണത്തിന്റെ മെമ്മറിയിലേക്ക് ഏതെങ്കിലും ബൈനറി ഡാറ്റ (ഫേംവെയർ) ലോഡ് ചെയ്യാനുള്ള കഴിവ്;
• സ്നാപ്പ്ഷോട്ടുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനുള്ള കഴിവ് (സിസ്റ്റം അവസ്ഥയുടെ സ്നാപ്പ്ഷോട്ടുകൾ);
• ബിൽറ്റ്-ഇൻ ഡീബഗ്ഗർ വഴി എമുലേറ്ററുമായി സംവദിക്കാനുള്ള കഴിവ്;
• വികസനത്തിന് നല്ല ആധുനിക ഭാഷ.

തൽഫലമായി, നടപ്പിലാക്കുന്നതിനായി കോട്‌ലിൻ തിരഞ്ഞെടുത്തു, ഒരു ബസ് ആർക്കിടെക്ചർ (മൊഡ്യൂളുകൾ വെർച്വൽ ഡാറ്റ ബസുകൾ വഴി പരസ്പരം ആശയവിനിമയം നടത്തുമ്പോഴാണ്), ഒരു ഉപകരണ വിവരണ ഫോർമാറ്റായി JSON, ഡീബഗ്ഗറുമായുള്ള ആശയവിനിമയത്തിനുള്ള പ്രോട്ടോക്കോൾ ആയി GDB RSP.

രണ്ട് വർഷത്തിലേറെയായി വികസനം നടക്കുന്നു, സജീവമായി തുടരുന്നു. ഈ സമയത്ത്, MIPS, x86, V850ES, ARM, PowerPC പ്രോസസർ കോറുകൾ എന്നിവ നടപ്പിലാക്കി.

പദ്ധതി വികസിച്ചുകൊണ്ടിരിക്കുന്നു, ഇത് പൊതുജനങ്ങൾക്ക് മുന്നിൽ അവതരിപ്പിക്കാനുള്ള സമയമായി. പ്രോജക്റ്റിന്റെ വിശദമായ വിവരണം ഞങ്ങൾ പിന്നീട് ചെയ്യും, എന്നാൽ ഇപ്പോൾ ഞങ്ങൾ കോപ്പികാറ്റ് ഉപയോഗിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

ഏറ്റവും അക്ഷമരായവർക്ക്, എമുലേറ്ററിന്റെ ഒരു പ്രൊമോ പതിപ്പ് ഡൗൺലോഡ് ചെയ്യാവുന്നതാണ് ലിങ്ക്.

എമുലേറ്ററിൽ റിനോ

നേരത്തെ, SMARTRHINO-2018 കോൺഫറൻസിനായി, റിവേഴ്സ് എഞ്ചിനീയറിംഗ് കഴിവുകൾ പഠിപ്പിക്കുന്നതിനായി ഒരു പരീക്ഷണ ഉപകരണം "കാണ്ടാമൃഗം" സൃഷ്ടിച്ചത് നമുക്ക് ഓർക്കാം. സ്റ്റാറ്റിക് ഫേംവെയർ വിശകലനത്തിന്റെ പ്രക്രിയ വിവരിച്ചിരിക്കുന്നു ഈ ലേഖനം.

ഇപ്പോൾ നമുക്ക് "സ്പീക്കറുകൾ" ചേർക്കാനും എമുലേറ്ററിൽ ഫേംവെയർ പ്രവർത്തിപ്പിക്കാനും ശ്രമിക്കാം.

ഞങ്ങൾക്ക് വേണ്ടത്:
1) ജാവ 1.8
2) പൈത്തണും മൊഡ്യൂളും ജെപ്പ് എമുലേറ്ററിനുള്ളിൽ പൈത്തൺ ഉപയോഗിക്കുന്നതിന്. നിങ്ങൾക്ക് വിൻഡോസിനായി WHL മൊഡ്യൂൾ ജെപ്പ് നിർമ്മിക്കാൻ കഴിയും ഇവിടെ ഡൗൺലോഡ് ചെയ്യുക.

വിൻഡോസിനായി:
1) com0com
2) പുട്ടി

Linux-ന്:
1) സോക്കറ്റ്

നിങ്ങൾക്ക് ഒരു 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);
• ആന്തരിക എമുലേറ്റർ കമാൻഡ് ലൈൻ (ആർഗ്പാർസ് അല്ലെങ്കിൽ പൈത്തൺ).

വെർച്വൽ COM പോർട്ടുകൾ

ഒരു ടെർമിനൽ വഴി ലോക്കൽ മെഷീനിലെ ഒരു വെർച്വൽ ഉപകരണത്തിന്റെ UART-മായി സംവദിക്കുന്നതിന്, നിങ്ങൾ ഒരു ജോടി അനുബന്ധ വെർച്വൽ COM പോർട്ടുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ കാര്യത്തിൽ, ഒരു പോർട്ട് എമുലേറ്റർ ഉപയോഗിക്കുന്നു, രണ്ടാമത്തേത് ടെർമിനൽ പ്രോഗ്രാം (PuTTY അല്ലെങ്കിൽ സ്ക്രീൻ) ഉപയോഗിക്കുന്നു:

com0com ഉപയോഗിക്കുന്നു

com0com കിറ്റിൽ നിന്നുള്ള സജ്ജീകരണ യൂട്ടിലിറ്റി ഉപയോഗിച്ചാണ് വെർച്വൽ COM പോർട്ടുകൾ ക്രമീകരിച്ചിരിക്കുന്നത് (കൺസോൾ പതിപ്പ് - സി:പ്രോഗ്രാം ഫയലുകൾ (x86)com0comsetupс.exe, അല്ലെങ്കിൽ GUI പതിപ്പ് - സി:പ്രോഗ്രാം ഫയലുകൾ (x86)com0comsetupg.exe):

ബോക്സുകൾ പരിശോധിക്കുക ബഫർ ഓവർറൺ പ്രവർത്തനക്ഷമമാക്കുക സൃഷ്ടിച്ച എല്ലാ വെർച്വൽ പോർട്ടുകൾക്കും, അല്ലെങ്കിൽ COM പോർട്ടിൽ നിന്നുള്ള പ്രതികരണത്തിനായി എമുലേറ്റർ കാത്തിരിക്കും.

സോകാറ്റ് ഉപയോഗിക്കുന്നു

UNIX സിസ്റ്റങ്ങളിൽ, സോകാറ്റ് യൂട്ടിലിറ്റി ഉപയോഗിച്ച് എമുലേറ്റർ സ്വയമേവ വെർച്വൽ COM പോർട്ടുകൾ സൃഷ്ടിക്കുന്നു; ഇത് ചെയ്യുന്നതിന്, എമുലേറ്റർ ആരംഭിക്കുമ്പോൾ പോർട്ട് നാമത്തിൽ പ്രിഫിക്സ് വ്യക്തമാക്കുക. socat:.

ആന്തരിക കമാൻഡ് ലൈൻ ഇന്റർഫേസ് (Argparse അല്ലെങ്കിൽ Python)

കോപ്പികാറ്റ് ഒരു കൺസോൾ ആപ്ലിക്കേഷനായതിനാൽ, എമുലേറ്റർ അതിന്റെ ഒബ്ജക്റ്റുകളുമായും വേരിയബിളുകളുമായും സംവദിക്കുന്നതിന് രണ്ട് കമാൻഡ് ലൈൻ ഇന്റർഫേസ് ഓപ്ഷനുകൾ നൽകുന്നു: ആർഗ്പാർസ്, പൈത്തൺ.

ആർഗ്പാർസ് കോപ്പികാറ്റിൽ നിർമ്മിച്ച ഒരു CLI ആണ്, അത് എല്ലാവർക്കുമായി എപ്പോഴും ലഭ്യമാണ്.

ഒരു ബദൽ CLI ആണ് പൈത്തൺ ഇന്റർപ്രെറ്റർ. ഇത് ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ജെപ്പ് പൈത്തൺ മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്യുകയും പൈത്തണുമായി പ്രവർത്തിക്കാൻ എമുലേറ്റർ ക്രമീകരിക്കുകയും വേണം (ഉപയോക്താവിന്റെ പ്രധാന സിസ്റ്റത്തിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള പൈത്തൺ ഇന്റർപ്രെറ്റർ ഉപയോഗിക്കും).

പൈത്തൺ മൊഡ്യൂൾ ജെപ്പ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു

Linux ജെപ്പിന് കീഴിൽ പൈപ്പ് വഴി ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും:

pip install jep

വിൻഡോസിൽ ജെപ്പ് ഇൻസ്റ്റാൾ ചെയ്യാൻ, നിങ്ങൾ ആദ്യം വിൻഡോസ് എസ്ഡികെയും അനുബന്ധ മൈക്രോസോഫ്റ്റ് വിഷ്വൽ സ്റ്റുഡിയോയും ഇൻസ്റ്റാൾ ചെയ്യണം. ഞങ്ങൾ ഇത് നിങ്ങൾക്ക് കുറച്ച് എളുപ്പമാക്കിയിരിക്കുന്നു WHL നിർമ്മിക്കുന്നു വിൻഡോസിനായുള്ള പൈത്തണിന്റെ നിലവിലെ പതിപ്പുകൾക്കുള്ള ജെഇപി, അതിനാൽ ഫയലിൽ നിന്ന് മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും:

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.

നിങ്ങളുടെ സിസ്റ്റത്തിനായുള്ള എമുലേറ്റർ ബാച്ച് ഫയലിൽ (copycat.bat - വിൻഡോസിനായി, കോപ്പിയടി - ലിനക്സിനായി) പരാമീറ്ററുകളുടെ പട്ടികയിലേക്ക് 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 — GDB സെർവറിലേക്കുള്ള പ്രവേശനത്തിനായി തുറന്നിരിക്കുന്ന TCP പോർട്ട്;
• -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 പ്രോയുമായുള്ള ഇടപെടൽ

പരിശോധന ലളിതമാക്കാൻ, ഫോമിലെ ഐഡിഎയിൽ വിശകലനം ചെയ്യുന്നതിനുള്ള ഉറവിട ഫയലായി ഞങ്ങൾ റിനോ ഫേംവെയർ ഉപയോഗിക്കുന്നു ELF ഫയൽ (മെറ്റാ വിവരങ്ങൾ അവിടെ സൂക്ഷിച്ചിരിക്കുന്നു).

മെറ്റാ വിവരങ്ങളില്ലാതെ നിങ്ങൾക്ക് പ്രധാന ഫേംവെയർ ഉപയോഗിക്കാനും കഴിയും.

ഐഡിഎ പ്രോയിൽ കോപ്പികാറ്റ് സമാരംഭിച്ചതിന് ശേഷം, ഡീബഗ്ഗർ മെനുവിലെ ഇനത്തിലേക്ക് പോകുക "ഡീബഗ്ഗർ മാറുക..."ഒപ്പം തിരഞ്ഞെടുക്കുക"വിദൂര GDB ഡീബഗ്ഗർ". അടുത്തതായി, കണക്ഷൻ സജ്ജമാക്കുക: മെനു ഡീബഗ്ഗർ - പ്രോസസ്സ് ഓപ്ഷനുകൾ...

മൂല്യങ്ങൾ സജ്ജമാക്കുക:

• ആപ്ലിക്കേഷൻ - ഏതെങ്കിലും മൂല്യം
• ഹോസ്റ്റിന്റെ പേര്: 127.0.0.1 (അല്ലെങ്കിൽ കോപ്പികാറ്റ് പ്രവർത്തിക്കുന്ന റിമോട്ട് മെഷീന്റെ IP വിലാസം)
• പോർട്ട്: 23946

ഇപ്പോൾ ഡീബഗ്ഗിംഗ് ബട്ടൺ ലഭ്യമാകുന്നു (F9 കീ):

എമുലേറ്ററിലെ ഡീബഗ്ഗർ മൊഡ്യൂളിലേക്ക് കണക്റ്റുചെയ്യാൻ അതിൽ ക്ലിക്ക് ചെയ്യുക. IDA ഡീബഗ്ഗിംഗ് മോഡിലേക്ക് പോകുന്നു, അധിക വിൻഡോകൾ ലഭ്യമാകുന്നു: രജിസ്റ്ററുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ, സ്റ്റാക്കിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

ഇപ്പോൾ നമുക്ക് ഡീബഗ്ഗറിന്റെ എല്ലാ സ്റ്റാൻഡേർഡ് സവിശേഷതകളും ഉപയോഗിക്കാം:

• നിർദ്ദേശങ്ങളുടെ ഘട്ടം ഘട്ടമായുള്ള നിർവ്വഹണം (ഇതിലേക്ക് കടക്കുക и ചുവടുവെക്കുക - കീകൾ യഥാക്രമം F7, F8);
• എക്സിക്യൂഷൻ ആരംഭിക്കുന്നതും താൽക്കാലികമായി നിർത്തുന്നതും;
• കോഡിനും ഡാറ്റയ്ക്കുമായി ബ്രേക്ക്‌പോയിന്റുകൾ സൃഷ്ടിക്കുന്നു (F2 കീ).

ഒരു ഡീബഗ്ഗറിലേക്ക് കണക്റ്റുചെയ്യുന്നത് ഫേംവെയർ കോഡ് പ്രവർത്തിപ്പിക്കുക എന്നല്ല. നിലവിലെ നിർവ്വഹണ സ്ഥാനം വിലാസമായിരിക്കണം 0x08006A74 - പ്രവർത്തനത്തിന്റെ തുടക്കം Reset_Handler. നിങ്ങൾ ലിസ്റ്റിംഗ് താഴേക്ക് സ്ക്രോൾ ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഫംഗ്ഷൻ കോൾ കാണാം പ്രധാന. നിങ്ങൾക്ക് ഈ വരിയിൽ കഴ്സർ സ്ഥാപിക്കാം (വിലാസം 0x08006ABE) കൂടാതെ ഓപ്പറേഷൻ നടത്തുക കഴ്സർ വരെ പ്രവർത്തിപ്പിക്കുക (കീ F4).

അടുത്തതായി, ഫംഗ്ഷനിൽ പ്രവേശിക്കാൻ നിങ്ങൾക്ക് F7 അമർത്താം പ്രധാന.

നിങ്ങൾ കമാൻഡ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ പ്രക്രിയ തുടരുക (F9 കീ), തുടർന്ന് "ദയവായി കാത്തിരിക്കുക" വിൻഡോ ഒരൊറ്റ ബട്ടണിൽ ദൃശ്യമാകും താൽക്കാലികമായി നിർത്തിവയ്ക്കുക:

നിങ്ങൾ അമർത്തുമ്പോൾ താൽക്കാലികമായി നിർത്തിവയ്ക്കുക ഫേംവെയർ കോഡിന്റെ നിർവ്വഹണം താൽക്കാലികമായി നിർത്തി, അത് തടസ്സപ്പെട്ട കോഡിലെ അതേ വിലാസത്തിൽ നിന്ന് തുടരാം.

നിങ്ങൾ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് തുടരുകയാണെങ്കിൽ, വെർച്വൽ COM പോർട്ടുകളുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള ടെർമിനലുകളിൽ ഇനിപ്പറയുന്ന വരികൾ നിങ്ങൾ കാണും:

"സ്റ്റേറ്റ് ബൈപാസ്" ലൈനിന്റെ സാന്നിധ്യം വെർച്വൽ ബ്ലൂടൂത്ത് മൊഡ്യൂൾ ഉപയോക്താവിന്റെ COM പോർട്ടിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്ന മോഡിലേക്ക് മാറിയതായി സൂചിപ്പിക്കുന്നു.

ഇപ്പോൾ ബ്ലൂടൂത്ത് ടെർമിനലിൽ (ചിത്രത്തിൽ COM29) നിങ്ങൾക്ക് റിനോ പ്രോട്ടോക്കോൾ അനുസരിച്ച് കമാൻഡുകൾ നൽകാം. ഉദാഹരണത്തിന്, "MEOW" കമാൻഡ് ബ്ലൂടൂത്ത് ടെർമിനലിലേക്ക് "mur-mur" എന്ന സ്ട്രിംഗ് തിരികെ നൽകും:

എന്നെ പൂർണ്ണമായും അനുകരിക്കരുത്

ഒരു എമുലേറ്റർ നിർമ്മിക്കുമ്പോൾ, ഒരു പ്രത്യേക ഉപകരണത്തിന്റെ വിശദാംശം/എമുലേഷൻ ലെവൽ നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം. ഉദാഹരണത്തിന്, ബ്ലൂടൂത്ത് മൊഡ്യൂൾ വ്യത്യസ്ത രീതികളിൽ അനുകരിക്കാം:

• പൂർണ്ണമായ ഒരു കൂട്ടം കമാൻഡുകൾ ഉപയോഗിച്ച് ഉപകരണം പൂർണ്ണമായും അനുകരിക്കപ്പെടുന്നു;
• AT കമാൻഡുകൾ അനുകരിക്കപ്പെടുന്നു, കൂടാതെ പ്രധാന സിസ്റ്റത്തിന്റെ COM പോർട്ടിൽ നിന്ന് ഡാറ്റ സ്ട്രീം സ്വീകരിക്കുന്നു;
• വെർച്വൽ ഉപകരണം യഥാർത്ഥ ഉപകരണത്തിലേക്ക് പൂർണ്ണമായ ഡാറ്റ റീഡയറക്ഷൻ നൽകുന്നു;
• എല്ലായ്‌പ്പോഴും "ശരി" എന്ന് നൽകുന്ന ഒരു ലളിതമായ അപൂർണ്ണം.

എമുലേറ്ററിന്റെ നിലവിലെ പതിപ്പ് രണ്ടാമത്തെ സമീപനം ഉപയോഗിക്കുന്നു - വെർച്വൽ ബ്ലൂടൂത്ത് മൊഡ്യൂൾ കോൺഫിഗറേഷൻ നടത്തുന്നു, അതിനുശേഷം ഇത് പ്രധാന സിസ്റ്റത്തിന്റെ COM പോർട്ടിൽ നിന്ന് എമുലേറ്ററിന്റെ UART പോർട്ടിലേക്ക് “പ്രോക്സിയിംഗ്” ഡാറ്റയുടെ മോഡിലേക്ക് മാറുന്നു.

ചുറ്റളവിന്റെ ചില ഭാഗങ്ങൾ നടപ്പിലാക്കിയില്ലെങ്കിൽ കോഡിന്റെ ലളിതമായ ഇൻസ്ട്രുമെന്റേഷൻ സാധ്യത പരിഗണിക്കാം. ഉദാഹരണത്തിന്, DMA-യിലേക്കുള്ള ഡാറ്റ കൈമാറ്റം നിയന്ത്രിക്കുന്നതിന് ഉത്തരവാദിത്തമുള്ള ഒരു ടൈമർ സൃഷ്ടിച്ചിട്ടില്ലെങ്കിൽ (ചെക്ക് ഫംഗ്ഷനിൽ നടത്തുന്നു ws2812b_waitസ്ഥിതി ചെയ്യുന്നത് 0x08006840), തുടർന്ന് ഫ്ലാഗ് പുനഃസജ്ജമാക്കുന്നതിനായി ഫേംവെയർ എപ്പോഴും കാത്തിരിക്കും തിരക്ക്സ്ഥിതി ചെയ്യുന്നത് 0x200004C4ഇത് ഡിഎംഎ ഡാറ്റാ ലൈനിന്റെ ഒക്യുപെൻസി കാണിക്കുന്നു:

ഫ്ലാഗ് സ്വമേധയാ പുനഃസജ്ജമാക്കുന്നതിലൂടെ നമുക്ക് ഈ സാഹചര്യത്തെ മറികടക്കാൻ കഴിയും തിരക്ക് ഇൻസ്റ്റാൾ ചെയ്ത ഉടനെ. ഐ‌ഡി‌എ പ്രോയിൽ, നിങ്ങൾക്ക് ഒരു പൈത്തൺ ഫംഗ്‌ഷൻ സൃഷ്‌ടിച്ച് അതിനെ ബ്രേക്ക്‌പോയിന്റിൽ വിളിക്കാം, ഫ്ലാഗിൽ മൂല്യം 1 എഴുതിയതിന് ശേഷം ബ്രേക്ക്‌പോയിന്റ് തന്നെ കോഡിൽ ഇടുക. തിരക്ക്.

ബ്രേക്ക്‌പോയിന്റ് ഹാൻഡ്‌ലർ

ആദ്യം, നമുക്ക് IDA-യിൽ ഒരു പൈത്തൺ ഫംഗ്‌ഷൻ ഉണ്ടാക്കാം. മെനു ഫയൽ - സ്ക്രിപ്റ്റ് കമാൻഡ്...

ഇടതുവശത്തുള്ള പട്ടികയിൽ ഒരു പുതിയ സ്‌നിപ്പെറ്റ് ചേർക്കുക, അതിന് ഒരു പേര് നൽകുക (ഉദാഹരണത്തിന്, BPT),
വലതുവശത്തുള്ള ടെക്സ്റ്റ് ഫീൽഡിൽ, ഫംഗ്ഷൻ കോഡ് നൽകുക:

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.... ഫ്ലാഗ് പുനഃസജ്ജമാക്കുന്നതിനായി ഇപ്പോൾ ഫേംവെയർ കാത്തിരിക്കില്ല തിരക്ക്.

എമുലേറ്ററുമായുള്ള ഇടപെടൽ

അനുകരണത്തിനുവേണ്ടിയുള്ള അനുകരണം സന്തോഷവും സന്തോഷവും ഉണ്ടാക്കാൻ സാധ്യതയില്ല. മെമ്മറിയിലെ ഡാറ്റ കാണാനോ ത്രെഡുകളുടെ ഇടപെടൽ സ്ഥാപിക്കാനോ എമുലേറ്റർ ഗവേഷകനെ സഹായിക്കുന്നുവെങ്കിൽ അത് കൂടുതൽ രസകരമാണ്.

ആർ‌ടി‌ഒ‌എസ് ടാസ്‌ക്കുകൾ തമ്മിലുള്ള ആശയവിനിമയം എങ്ങനെ ചലനാത്മകമായി സ്ഥാപിക്കാമെന്ന് ഞങ്ങൾ നിങ്ങളെ കാണിക്കും. കോഡ് പ്രവർത്തിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ആദ്യം അതിന്റെ നിർവ്വഹണം താൽക്കാലികമായി നിർത്തണം. ചടങ്ങിനു പോയാലോ 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

ഡീബഗ് കോൺഫിഗറേഷൻ സജ്ജീകരിക്കുന്നു

എക്ലിപ്സിൽ, മെനു തിരഞ്ഞെടുക്കുക റൺ - ഡീബഗ് കോൺഫിഗറേഷനുകൾ... തുറക്കുന്ന വിൻഡോയിൽ, വിഭാഗത്തിൽ GDB ഹാർഡ്‌വെയർ ഡീബഗ്ഗിംഗ് നിങ്ങൾ ഒരു പുതിയ കോൺഫിഗറേഷൻ ചേർക്കേണ്ടതുണ്ട്, തുടർന്ന് "മെയിൻ" ടാബിൽ നിലവിലെ പ്രോജക്റ്റും ഡീബഗ്ഗിംഗിനുള്ള ആപ്ലിക്കേഷനും വ്യക്തമാക്കുക:

"ഡീബഗ്ഗർ" ടാബിൽ നിങ്ങൾ GDB കമാൻഡ് വ്യക്തമാക്കേണ്ടതുണ്ട്:
${openstm32_compiler_path}arm-none-eabi-gdb

കൂടാതെ GDB സെർവറിലേക്ക് (ഹോസ്റ്റും പോർട്ടും) ബന്ധിപ്പിക്കുന്നതിനുള്ള പാരാമീറ്ററുകളും നൽകുക:

"സ്റ്റാർട്ടപ്പ്" ടാബിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ വ്യക്തമാക്കണം:

• ചെക്ക്ബോക്സ് പ്രവർത്തനക്ഷമമാക്കുക ചിത്രം ലോഡ് ചെയ്യുക (അങ്ങനെ അസംബിൾ ചെയ്ത ഫേംവെയർ ഇമേജ് എമുലേറ്ററിലേക്ക് ലോഡ് ചെയ്യുന്നു);
• ചെക്ക്ബോക്സ് പ്രവർത്തനക്ഷമമാക്കുക ചിഹ്നങ്ങൾ ലോഡ് ചെയ്യുക;
• ലോഞ്ച് കമാൻഡ് ചേർക്കുക: set $pc = *0x08000004 (വിലാസത്തിൽ മെമ്മറിയിൽ നിന്നുള്ള മൂല്യത്തിലേക്ക് പിസി രജിസ്റ്റർ സജ്ജമാക്കുക 0x08000004 - വിലാസം അവിടെ സൂക്ഷിച്ചിരിക്കുന്നു ResetHandler).

ശ്രദ്ധിക്കുക, നിങ്ങൾക്ക് എക്ലിപ്സിൽ നിന്ന് ഫേംവെയർ ഫയൽ ഡൗൺലോഡ് ചെയ്യാൻ താൽപ്പര്യമില്ലെങ്കിൽ, ഓപ്ഷനുകൾ ചിത്രം ലോഡ് ചെയ്യുക и കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക സൂചിപ്പിക്കേണ്ട ആവശ്യമില്ല.

ഡീബഗ് ക്ലിക്ക് ചെയ്ത ശേഷം, നിങ്ങൾക്ക് ഡീബഗ്ഗർ മോഡിൽ പ്രവർത്തിക്കാം:

• ഘട്ടം ഘട്ടമായുള്ള കോഡ് നിർവ്വഹണം
  
• ബ്രേക്ക് പോയിന്റുകളുമായി സംവദിക്കുന്നു
  

അഭിപായപ്പെടുക. ഗ്രഹണത്തിന് ചില വൈചിത്ര്യങ്ങളുണ്ട്... നിങ്ങൾ അവയ്‌ക്കൊപ്പം ജീവിക്കണം. ഉദാഹരണത്തിന്, ഡീബഗ്ഗർ ആരംഭിക്കുമ്പോൾ "0x0″ എന്നതിന് ഉറവിടമൊന്നും ലഭ്യമല്ല" എന്ന സന്ദേശം ദൃശ്യമാകുകയാണെങ്കിൽ, സ്റ്റെപ്പ് കമാൻഡ് (F5) എക്സിക്യൂട്ട് ചെയ്യുക.

പകരം ഒരു നിഗമനത്തിൽ എന്ന

നേറ്റീവ് കോഡ് അനുകരിക്കുന്നത് വളരെ രസകരമായ ഒരു കാര്യമാണ്. ഒരു യഥാർത്ഥ ഉപകരണമില്ലാതെ ഫേംവെയർ ഡീബഗ് ചെയ്യാൻ ഒരു ഉപകരണ ഡെവലപ്പർക്ക് സാധ്യമാകും. ഒരു ഗവേഷകനെ സംബന്ധിച്ചിടത്തോളം, ഡൈനാമിക് കോഡ് വിശകലനം നടത്താനുള്ള അവസരമാണിത്, ഒരു ഉപകരണത്തിൽ പോലും ഇത് എല്ലായ്പ്പോഴും സാധ്യമല്ല.

സ്പെഷ്യലിസ്റ്റുകൾക്ക് സൗകര്യപ്രദവും മിതമായ ലളിതവും സജ്ജീകരിക്കാനും പ്രവർത്തിപ്പിക്കാനും വളരെയധികം പരിശ്രമവും സമയവും എടുക്കാത്തതുമായ ഒരു ഉപകരണം നൽകാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

ഹാർഡ്‌വെയർ എമുലേറ്ററുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ അനുഭവത്തെക്കുറിച്ച് അഭിപ്രായങ്ങളിൽ എഴുതുക. ചർച്ച ചെയ്യാൻ ഞങ്ങൾ നിങ്ങളെ ക്ഷണിക്കുകയും ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നതിൽ സന്തോഷിക്കുകയും ചെയ്യും.

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

നിങ്ങൾ എന്തിനാണ് എമുലേറ്റർ ഉപയോഗിക്കുന്നത്?

• ഞാൻ (ഡീബഗ്) ഫേംവെയർ വികസിപ്പിക്കുന്നു

• ഞാൻ ഫേംവെയറിനെക്കുറിച്ച് അന്വേഷിക്കുകയാണ്

• ഞാൻ ഗെയിമുകൾ സമാരംഭിക്കുന്നു (ഡെണ്ടി, സെഗ, PSP)

• മറ്റെന്തെങ്കിലും (അഭിപ്രായങ്ങളിൽ എഴുതുക)

7 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 2 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

നേറ്റീവ് കോഡ് അനുകരിക്കാൻ നിങ്ങൾ ഏത് സോഫ്റ്റ്‌വെയർ ഉപയോഗിക്കുന്നു?

• ക്യുഇഎംയു

• യൂണികോൺ എഞ്ചിൻ

• Proteus

• മറ്റെന്തെങ്കിലും (അഭിപ്രായങ്ങളിൽ എഴുതുക)

6 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 2 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

നിങ്ങൾ ഉപയോഗിക്കുന്ന എമുലേറ്ററിൽ എന്താണ് മെച്ചപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നത്?

• എനിക്ക് വേഗത വേണം

• എനിക്ക് സജ്ജീകരണം/ലോഞ്ച് എളുപ്പം വേണം

• എമുലേറ്ററുമായി സംവദിക്കുന്നതിന് എനിക്ക് കൂടുതൽ ഓപ്ഷനുകൾ വേണം (API, ഹുക്കുകൾ)

• എല്ലാത്തിലും ഞാൻ സന്തുഷ്ടനാണ്

• മറ്റെന്തെങ്കിലും (അഭിപ്രായങ്ങളിൽ എഴുതുക)

8 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 1 ഉപയോക്താവ് വിട്ടുനിന്നു.

അവലംബം: www.habr.com