બિલાડીની અંદર ગેંડા - કોપીકેટ ઇમ્યુલેટરમાં ફર્મવેર ચલાવો

મીટિંગના ભાગ રૂપે 0x0A DC7831 DEF CON નિઝની નોવગોરોડ 16 ફેબ્રુઆરીના રોજ, અમે બાઈનરી કોડ ઇમ્યુલેશનના મૂળભૂત સિદ્ધાંતો અને અમારા પોતાના વિકાસ - હાર્ડવેર પ્લેટફોર્મ ઇમ્યુલેટર પર એક અહેવાલ રજૂ કર્યો કોપીકેટ.

આ લેખમાં અમે વર્ણન કરીશું કે ઇમ્યુલેટરમાં ઉપકરણ ફર્મવેર કેવી રીતે ચલાવવું, ડીબગર સાથે ક્રિયાપ્રતિક્રિયા દર્શાવવી અને ફર્મવેરનું નાનું ગતિશીલ વિશ્લેષણ કેવી રીતે કરવું.

પ્રાગૈતિહાસિક

લાંબા સમય પહેલા દૂર એક આકાશગંગામાં

થોડા વર્ષો પહેલા અમારી પ્રયોગશાળામાં ઉપકરણના ફર્મવેરની તપાસ કરવાની જરૂર હતી. ફર્મવેર બુટલોડર સાથે સંકુચિત અને અનપેક કરવામાં આવ્યું હતું. તેણે આ ખૂબ જ જટિલ રીતે કર્યું, મેમરીમાં ડેટાને ઘણી વખત ખસેડ્યો. અને ફર્મવેર પોતે પછી પેરિફેરલ્સ સાથે સક્રિય રીતે ક્રિયાપ્રતિક્રિયા કરે છે. અને આ બધું MIPS કોર પર.

ઉદ્દેશ્ય કારણોસર, ઉપલબ્ધ ઇમ્યુલેટર્સ અમને અનુકૂળ ન હતા, પરંતુ અમે હજી પણ કોડ ચલાવવા માંગીએ છીએ. પછી અમે અમારું પોતાનું ઇમ્યુલેટર બનાવવાનું નક્કી કર્યું, જે ન્યૂનતમ કરશે અને અમને મુખ્ય ફર્મવેરને અનપૅક કરવાની મંજૂરી આપશે. અમે તેનો પ્રયાસ કર્યો અને તે કામ કર્યું. અમે વિચાર્યું કે, જો આપણે મુખ્ય ફર્મવેર કરવા માટે પેરિફેરલ્સ ઉમેરીએ તો શું થશે. તે ખૂબ જ નુકસાન પહોંચાડ્યું નથી - અને તે પણ કામ કર્યું. અમે ફરીથી વિચાર્યું અને સંપૂર્ણ સુવિધાયુક્ત ઇમ્યુલેટર બનાવવાનું નક્કી કર્યું.

પરિણામ કમ્પ્યુટર સિસ્ટમ્સ ઇમ્યુલેટર હતું કોપીકેટ.

શા માટે કોપીકેટ?

શબ્દો પર નાટક છે.

1. copycat (અંગ્રેજી, સંજ્ઞા [ˈkɒpɪkæt]) - અનુકરણ કરનાર, અનુકરણ કરનાર
2. બિલાડી (અંગ્રેજી, સંજ્ઞા [ˈkæt]) - બિલાડી, બિલાડી - પ્રોજેક્ટના નિર્માતાઓમાંના એકનું પ્રિય પ્રાણી
3. "K" અક્ષર કોટલિન પ્રોગ્રામિંગ ભાષામાંથી છે

કોપીકેટ

ઇમ્યુલેટર બનાવતી વખતે, ખૂબ ચોક્કસ લક્ષ્યો સેટ કરવામાં આવ્યા હતા:

• ઝડપથી નવા પેરિફેરલ્સ, મોડ્યુલો, પ્રોસેસર કોરો બનાવવાની ક્ષમતા;
• વિવિધ મોડ્યુલોમાંથી વર્ચ્યુઅલ ઉપકરણને એસેમ્બલ કરવાની ક્ષમતા;
• વર્ચ્યુઅલ ઉપકરણની મેમરીમાં કોઈપણ બાઈનરી ડેટા (ફર્મવેર) લોડ કરવાની ક્ષમતા;
• સ્નેપશોટ સાથે કામ કરવાની ક્ષમતા (સિસ્ટમ સ્ટેટના સ્નેપશોટ);
• બિલ્ટ-ઇન ડીબગર દ્વારા ઇમ્યુલેટર સાથે ક્રિયાપ્રતિક્રિયા કરવાની ક્ષમતા;
• વિકાસ માટે સરસ આધુનિક ભાષા.

પરિણામે, અમલીકરણ માટે કોટલિન પસંદ કરવામાં આવ્યું હતું, બસ આર્કિટેક્ચર (આ ત્યારે છે જ્યારે મોડ્યુલો વર્ચ્યુઅલ ડેટા બસ દ્વારા એકબીજા સાથે વાતચીત કરે છે), ઉપકરણ વર્ણન ફોર્મેટ તરીકે JSON અને ડીબગર સાથે ક્રિયાપ્રતિક્રિયા માટે પ્રોટોકોલ તરીકે GDB RSP.

વિકાસ બે વર્ષથી થોડો સમય ચાલી રહ્યો છે અને સક્રિયપણે ચાલુ છે. આ સમય દરમિયાન, MIPS, x86, V850ES, ARM અને PowerPC પ્રોસેસર કોરો લાગુ કરવામાં આવ્યા હતા.

પ્રોજેક્ટ વધી રહ્યો છે અને તેને વ્યાપક લોકો સમક્ષ રજૂ કરવાનો સમય આવી ગયો છે. અમે પ્રોજેક્ટનું વિગતવાર વર્ણન પછીથી કરીશું, પરંતુ હમણાં માટે અમે કોપીકેટનો ઉપયોગ કરવા પર ધ્યાન કેન્દ્રિત કરીશું.

સૌથી વધુ અધીરા માટે, ઇમ્યુલેટરનું પ્રોમો વર્ઝન ડાઉનલોડ કરી શકાય છે કડી.

ઇમ્યુલેટરમાં ગેંડો

ચાલો યાદ કરીએ કે અગાઉ SMARTRHINO-2018 કોન્ફરન્સ માટે, રિવર્સ એન્જિનિયરિંગ કૌશલ્ય શીખવવા માટે એક પરીક્ષણ ઉપકરણ "ગેંડા" બનાવવામાં આવ્યું હતું. સ્ટેટિક ફર્મવેર વિશ્લેષણની પ્રક્રિયામાં વર્ણવવામાં આવી હતી આ લેખ.

હવે ચાલો "સ્પીકર્સ" ઉમેરવાનો પ્રયાસ કરીએ અને ઇમ્યુલેટરમાં ફર્મવેર ચલાવીએ.

અમને જરૂર પડશે:
1) જાવા 1.8
2) પાયથોન અને મોડ્યુલ જીપ ઇમ્યુલેટરની અંદર પાયથોનનો ઉપયોગ કરવા માટે. તમે Windows માટે WHL મોડ્યુલ Jep બનાવી શકો છો અહીં ડાઉનલોડ કરો.

વિન્ડોઝ માટે:
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 (બ્લૂટૂથ મોડ્યુલ માટે ડીબગ UART અને UART) ના COM પોર્ટ્સ સાથે ક્રિયાપ્રતિક્રિયાનો સમાવેશ થાય છે. આ વાસ્તવિક બંદરો હોઈ શકે છે જેની સાથે ઉપકરણો જોડાયેલા છે અથવા વર્ચ્યુઅલ 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:.

આંતરિક કમાન્ડ લાઇન ઇન્ટરફેસ (આર્ગપાર્સ અથવા પાયથોન)

કોપીકેટ એ કન્સોલ એપ્લિકેશન હોવાથી, ઇમ્યુલેટર તેના ઑબ્જેક્ટ્સ અને ચલો સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે બે કમાન્ડ લાઇન ઇન્ટરફેસ વિકલ્પો પૂરા પાડે છે: Argparse અને Python.

અર્ગપાર્સ એ કોપીકેટમાં બનેલ CLI છે અને તે હંમેશા દરેક માટે ઉપલબ્ધ છે.

વૈકલ્પિક CLI એ Python દુભાષિયા છે. તેનો ઉપયોગ કરવા માટે, તમારે Jep Python મોડ્યુલ ઇન્સ્ટોલ કરવાની અને Python સાથે કામ કરવા માટે ઇમ્યુલેટરને ગોઠવવાની જરૂર છે (વપરાશકર્તાની મુખ્ય સિસ્ટમ પર ઇન્સ્ટોલ કરેલ Python ઇન્ટરપ્રીટરનો ઉપયોગ કરવામાં આવશે).

પાયથોન મોડ્યુલ Jep ઇન્સ્ટોલ કરી રહ્યું છે

Linux Jep હેઠળ પાઇપ દ્વારા ઇન્સ્ટોલ કરી શકાય છે:

pip install jep

Windows પર Jep ઇન્સ્ટોલ કરવા માટે, તમારે પહેલા Windows SDK અને અનુરૂપ Microsoft Visual Studio ઇન્સ્ટોલ કરવું પડશે. અમે તમારા માટે તેને થોડું સરળ બનાવ્યું છે અને WHL બનાવે છે વિન્ડોઝ માટે Python ના વર્તમાન સંસ્કરણો માટે 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.

તમારી સિસ્ટમ માટે ઇમ્યુલેટર બેચ ફાઇલમાં (copycat.bat - વિન્ડોઝ માટે, નકલ - Linux માટે) પરિમાણોની સૂચિમાં 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"

કોપીકેટ લોન્ચ કરી રહ્યું છે

ઇમ્યુલેટર એ કન્સોલ JVM એપ્લિકેશન છે. લોન્ચ ઓપરેટિંગ સિસ્ટમ કમાન્ડ લાઇન સ્ક્રિપ્ટ (sh/cmd) દ્વારા હાથ ધરવામાં આવે છે.

વિન્ડોઝ હેઠળ ચલાવવા માટે આદેશ:

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

સોકેટ યુટિલિટીનો ઉપયોગ કરીને 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 માં કોપીકેટ લોન્ચ કર્યા પછી, ડીબગર મેનૂમાં આઇટમ પર જાઓ “ડીબગર સ્વિચ કરો..."અને પસંદ કરો"રીમોટ GDB ડીબગર" આગળ, કનેક્શન સેટ કરો: મેનુ ડીબગર - પ્રક્રિયા વિકલ્પો...

મૂલ્યો સેટ કરો:

• એપ્લિકેશન - કોઈપણ મૂલ્ય
• હોસ્ટનામ: 127.0.0.1 (અથવા રિમોટ મશીનનું IP સરનામું જ્યાં કોપીકેટ ચાલી રહ્યું છે)
• પોર્ટ: 23946

હવે ડીબગીંગ બટન ઉપલબ્ધ થશે (F9 કી):

ઇમ્યુલેટરમાં ડીબગર મોડ્યુલ સાથે જોડાવા માટે તેને ક્લિક કરો. IDA ડિબગીંગ મોડમાં જાય છે, વધારાની વિન્ડો ઉપલબ્ધ થાય છે: રજીસ્ટર વિશેની માહિતી, સ્ટેક વિશે.

હવે આપણે ડીબગરની તમામ પ્રમાણભૂત સુવિધાઓનો ઉપયોગ કરી શકીએ છીએ:

• સૂચનાઓનું પગલું-દર-પગલાં અમલ (માં પગલું и આગળ વધો — અનુક્રમે F7 અને F8 કીઓ);
• અમલ શરૂ કરવું અને થોભાવવું;
• કોડ અને ડેટા (F2 કી) બંને માટે બ્રેકપોઇન્ટ બનાવવું.

ડીબગર સાથે કનેક્ટ કરવાનો અર્થ એ નથી કે ફર્મવેર કોડ ચલાવવો. વર્તમાન એક્ઝેક્યુશન પોઝિશન સરનામું હોવું આવશ્યક છે 0x08006A74 - કાર્યની શરૂઆત રીસેટ_હેન્ડલર. જો તમે સૂચિને નીચે સ્ક્રોલ કરો છો, તો તમે ફંક્શન કૉલ જોઈ શકો છો મુખ્ય. તમે આ લાઇન પર કર્સર મૂકી શકો છો (સરનામું 0x08006ABE) અને ઓપરેશન કરો કર્સર સુધી ચલાવો (કી F4).

આગળ, તમે ફંક્શન દાખલ કરવા માટે F7 દબાવી શકો છો મુખ્ય.

જો તમે આદેશ ચલાવો છો પ્રક્રિયા ચાલુ રાખો (F9 કી), પછી "કૃપા કરીને રાહ જુઓ" વિન્ડો એક બટન સાથે દેખાશે સસ્પેન્ડ કરો:

જ્યારે તમે દબાવો સસ્પેન્ડ કરો ફર્મવેર કોડનો અમલ સસ્પેન્ડ કરવામાં આવ્યો છે અને કોડમાં તે જ સરનામાંથી ચાલુ રાખી શકાય છે જ્યાં તે વિક્ષેપિત થયો હતો.

જો તમે કોડ ચલાવવાનું ચાલુ રાખશો, તો તમે વર્ચ્યુઅલ COM પોર્ટ્સ સાથે જોડાયેલા ટર્મિનલ્સમાં નીચેની લીટીઓ જોશો:

"સ્ટેટ બાયપાસ" લાઇનની હાજરી સૂચવે છે કે વર્ચ્યુઅલ બ્લૂટૂથ મોડ્યુલ વપરાશકર્તાના COM પોર્ટમાંથી ડેટા પ્રાપ્ત કરવાના મોડ પર સ્વિચ થઈ ગયું છે.

હવે બ્લૂટૂથ ટર્મિનલમાં (ચિત્રમાં COM29) તમે રાઇનો પ્રોટોકોલ અનુસાર આદેશો દાખલ કરી શકો છો. ઉદાહરણ તરીકે, “MEOW” આદેશ બ્લૂટૂથ ટર્મિનલ પર “mur-mur” શબ્દમાળા પરત કરશે:

મને સંપૂર્ણપણે અનુકરણ કરો નહીં

ઇમ્યુલેટર બનાવતી વખતે, તમે ચોક્કસ ઉપકરણની વિગતો/ઇમ્યુલેશનનું સ્તર પસંદ કરી શકો છો. ઉદાહરણ તરીકે, બ્લૂટૂથ મોડ્યુલને અલગ અલગ રીતે અનુકરણ કરી શકાય છે:

• ઉપકરણને આદેશોના સંપૂર્ણ સેટ સાથે સંપૂર્ણપણે અનુકરણ કરવામાં આવે છે;
• AT આદેશોનું અનુકરણ કરવામાં આવે છે, અને ડેટા સ્ટ્રીમ મુખ્ય સિસ્ટમના COM પોર્ટમાંથી પ્રાપ્ત થાય છે;
• વર્ચ્યુઅલ ઉપકરણ વાસ્તવિક ઉપકરણ પર સંપૂર્ણ ડેટા રીડાયરેક્શન પૂરું પાડે છે;
• એક સરળ સ્ટબ તરીકે જે હંમેશા "ઓકે" પરત કરે છે.

ઇમ્યુલેટરનું વર્તમાન સંસ્કરણ બીજા અભિગમનો ઉપયોગ કરે છે - વર્ચ્યુઅલ બ્લૂટૂથ મોડ્યુલ રૂપરેખાંકન કરે છે, ત્યારબાદ તે મુખ્ય સિસ્ટમના COM પોર્ટમાંથી ઇમ્યુલેટરના UART પોર્ટ પર ડેટા "પ્રોક્સીંગ" મોડ પર સ્વિચ કરે છે.

જો પરિઘનો અમુક ભાગ અમલમાં ન આવે તો કોડના સરળ સાધનની શક્યતાને ધ્યાનમાં લઈએ. ઉદાહરણ તરીકે, જો DMA માં ડેટા ટ્રાન્સફરને નિયંત્રિત કરવા માટે જવાબદાર ટાઈમર બનાવવામાં આવ્યું નથી (તપાસ કાર્યમાં કરવામાં આવે છે ws2812b_પ્રતીક્ષા કરોપર સ્થિત 0x08006840), પછી ફર્મવેર હંમેશા ફ્લેગ રીસેટ થવાની રાહ જોશે વ્યસ્તપર સ્થિત 0x200004C4જે DMA ડેટા લાઇનનો કબજો દર્શાવે છે:

ધ્વજને મેન્યુઅલી રીસેટ કરીને અમે આ પરિસ્થિતિમાંથી બહાર નીકળી શકીએ છીએ વ્યસ્ત તેને ઇન્સ્ટોલ કર્યા પછી તરત જ. IDA Pro માં, તમે Python ફંક્શન બનાવી શકો છો અને તેને બ્રેકપોઇન્ટમાં કૉલ કરી શકો છો, અને ફ્લેગ પર મૂલ્ય 1 લખ્યા પછી કોડમાં બ્રેકપોઇન્ટને જ મૂકી શકો છો. વ્યસ્ત.

બ્રેકપોઇન્ટ હેન્ડલર

પ્રથમ, ચાલો IDA માં Python ફંક્શન બનાવીએ. મેનુ ફાઇલ - સ્ક્રિપ્ટ આદેશ...

ડાબી બાજુની સૂચિમાં એક નવું સ્નિપેટ ઉમેરો, તેને એક નામ આપો (ઉદાહરણ તરીકે, બી.પી.ટી.),
જમણી બાજુના ટેક્સ્ટ ફીલ્ડમાં, ફંક્શન કોડ દાખલ કરો:

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.... હવે ફર્મવેર ફ્લેગ રીસેટ થવાની રાહ જોશે નહીં વ્યસ્ત.

ઇમ્યુલેટર સાથે ક્રિયાપ્રતિક્રિયા

અનુકરણ ખાતર અનુકરણ આનંદ અને આનંદનું કારણ બને તેવી શક્યતા નથી. જો ઇમ્યુલેટર સંશોધકને મેમરીમાં ડેટા જોવા અથવા થ્રેડોની ક્રિયાપ્રતિક્રિયા સ્થાપિત કરવામાં મદદ કરે તો તે વધુ રસપ્રદ છે.

અમે તમને બતાવીશું કે 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). અમને આશા છે કે આ ટૂંક સમયમાં ઠીક થઈ જશે.

ગ્રહણ સાથે ચાલી રહ્યું છે

ઇમ્યુલેટરનો ઉપયોગ કરવા માટેના વિકલ્પોમાંનો એક એ છે કે વિકસિત થઈ રહેલા ઉપકરણના ફર્મવેરને ડીબગ કરવું. સ્પષ્ટતા માટે, અમે રાઇનો ફર્મવેરનો પણ ઉપયોગ કરીશું. તમે ફર્મવેર સ્ત્રોતો ડાઉનલોડ કરી શકો છો અહીંથી.

અમે IDE તરીકે સેટમાંથી Eclipse નો ઉપયોગ કરીશું 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

• યુનિકોર્ન એન્જિન

• Proteus

• બીજું કંઈક (કોમેન્ટમાં લખો)

6 વપરાશકર્તાઓએ મત ​​આપ્યો. 2 વપરાશકર્તાઓ દૂર રહ્યા.

તમે જે ઇમ્યુલેટરનો ઉપયોગ કરી રહ્યાં છો તેમાં તમે શું સુધારવા માંગો છો?

• મને ઝડપ જોઈએ છે

• મને સેટઅપ/લૉન્ચની સરળતા જોઈએ છે

• મને એમ્યુલેટર (API, હુક્સ) સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે વધુ વિકલ્પો જોઈએ છે

• હું દરેક વસ્તુથી ખુશ છું

• બીજું કંઈક (કોમેન્ટમાં લખો)

8 વપરાશકર્તાઓએ મત ​​આપ્યો. 1 વપરાશકર્તા દૂર રહ્યો.

સોર્સ: www.habr.com