მარტორქა კატის შიგნით - გაუშვით პროგრამული უზრუნველყოფა Kopycat-ის ემულატორში

შეხვედრის ფარგლებში 0x0A DC7831 DEF CON ნიჟნი ნოვგოროდი 16 თებერვალს ჩვენ წარმოვადგინეთ ანგარიში ბინარული კოდის ემულაციის ძირითადი პრინციპებისა და ჩვენი საკუთარი განვითარების შესახებ - ტექნიკის პლატფორმის ემულატორი. ასლი.

ამ სტატიაში ჩვენ აღვწერთ, თუ როგორ უნდა გაუშვათ მოწყობილობის პროგრამული უზრუნველყოფა ემულატორში, ვაჩვენოთ ურთიერთქმედება დებუგერთან და შევასრულოთ პროგრამული უზრუნველყოფის მცირე დინამიური ანალიზი.

წინაისტორია

დიდი ხნის წინ შორეულ გალაქტიკაში

რამდენიმე წლის წინ ჩვენს ლაბორატორიაში საჭირო გახდა მოწყობილობის პროგრამული უზრუნველყოფის გამოკვლევა. firmware იყო შეკუმშული და გახსნილი ჩამტვირთველით. მან ეს გააკეთა ძალიან რთული გზით, რამდენჯერმე გადაიტანა მონაცემები მეხსიერებაში. და თავად firmware შემდეგ აქტიურად ურთიერთობდა პერიფერიულ მოწყობილობებთან. და ეს ყველაფერი MIPS ბირთვზე.

ობიექტური მიზეზების გამო, ხელმისაწვდომი ემულატორები არ გვერგებოდა, მაგრამ მაინც გვინდოდა კოდის გაშვება. შემდეგ ჩვენ გადავწყვიტეთ გაგვეკეთებინა საკუთარი ემულატორი, რომელიც მინიმუმს შეასრულებდა და საშუალებას მოგვცემდა ამოვაწყოთ მთავარი პროგრამული უზრუნველყოფა. ჩვენ ვცადეთ და იმუშავა. ჩვენ ვიფიქრეთ, რა მოხდება, თუ დავამატებთ პერიფერიულ მოწყობილობებს, რომ ასევე შეასრულოს ძირითადი firmware. ძალიან არ მტკივა - და ისიც გამოუვიდა. ჩვენ კიდევ ერთხელ დავფიქრდით და გადავწყვიტეთ შეგვექმნა სრულფასოვანი ემულატორი.

შედეგი იყო კომპიუტერული სისტემების ემულატორი ასლი.

რატომ Kopycat?

არის სიტყვების თამაში.

1. copycat (ინგლისური, არსებითი სახელი [ˈkɒpɪkæt]) - იმიტატორი, იმიტატორი
2. კატა (ინგლისური, არსებითი სახელი [ˈkæt]) - კატა, კატა - პროექტის ერთ-ერთი შემქმნელის საყვარელი ცხოველი
3. ასო "K" არის კოტლინის პროგრამირების ენიდან

ასლი

ემულატორის შექმნისას დასახული იყო ძალიან კონკრეტული მიზნები:

• ახალი პერიფერიული მოწყობილობების, მოდულების, პროცესორის ბირთვების სწრაფად შექმნის შესაძლებლობა;
• ვირტუალური მოწყობილობის აწყობის შესაძლებლობა სხვადასხვა მოდულიდან;
• ვირტუალური მოწყობილობის მეხსიერებაში ნებისმიერი ორობითი მონაცემების (firmware) ჩატვირთვის შესაძლებლობა;
• სნეპშოტებთან მუშაობის უნარი (სისტემის მდგომარეობის სნეპშოტები);
• ემულატორთან ურთიერთქმედების შესაძლებლობა ჩაშენებული გამართვის საშუალებით;
• ლამაზი თანამედროვე ენა განვითარებისთვის.

შედეგად, კოტლინი არჩეულ იქნა იმპლემენტაციისთვის, ავტობუსის არქიტექტურა (ეს არის მაშინ, როდესაც მოდულები ერთმანეთთან ურთიერთობენ მონაცემთა ვირტუალური ავტობუსების საშუალებით), JSON, როგორც მოწყობილობის აღწერილობის ფორმატი და GDB RSP, როგორც პროტოკოლი დებუგერთან ურთიერთქმედებისთვის.

განვითარება ორ წელზე ცოტა მეტია მიმდინარეობს და აქტიურად მიმდინარეობს. ამ დროის განმავლობაში განხორციელდა MIPS, x86, V850ES, ARM და PowerPC პროცესორის ბირთვები.

პროექტი იზრდება და დროა მისი ფართო საზოგადოების წინაშე წარდგენა. პროექტის დეტალურ აღწერას მოგვიანებით გავაკეთებთ, მაგრამ ახლა ყურადღებას გავამახვილებთ Kopycat-ის გამოყენებაზე.

ყველაზე მოუთმენლებისთვის, ემულატორის პრომო ვერსიის ჩამოტვირთვა შესაძლებელია ლინკები.

მარტორქა ემულატორში

შეგახსენებთ, რომ ადრე SMARTRHINO-2018-ის კონფერენციაზე შეიქმნა სატესტო მოწყობილობა "Rhinoceros" საპირისპირო ინჟინერიის უნარების სასწავლებლად. სტატიკური პროგრამული უზრუნველყოფის ანალიზის პროცესი აღწერილი იყო ეს მუხლი.

ახლა შევეცადოთ დავამატოთ "დინამიკები" და გავუშვათ firmware ემულატორში.

ჩვენ გვჭირდება:
1) Java 1.8
2) პითონი და მოდული ჯიპი პითონის გამოყენება ემულატორის შიგნით. თქვენ შეგიძლიათ შექმნათ WHL მოდული Jep Windows-ისთვის ჩამოტვირთეთ აქ.

Windows- ისთვის:
1) com0com
2) ჭუჭყიანი

Linux-ისთვის:
1) სოკატ

GDB კლიენტად შეგიძლიათ გამოიყენოთ Eclipse, IDA Pro ან radare2.

როგორ მუშაობს იგი?

ემულატორში firmware-ის შესასრულებლად აუცილებელია ვირტუალური მოწყობილობის „აწყობა“, რომელიც რეალური მოწყობილობის ანალოგია.

რეალური მოწყობილობა ("მარტორქო") შეიძლება ნაჩვენები იყოს ბლოკ-სქემაზე:

ემულატორს აქვს მოდულური სტრუქტურა და საბოლოო ვირტუალური მოწყობილობა შეიძლება აღწერილი იყოს 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"]
  ]
}

ყურადღება მიაქციეთ პარამეტრს firmware სექციაში პარამი არის ფაილის სახელი, რომელიც შეიძლება ჩაიტვირთოს ვირტუალურ მოწყობილობაში, როგორც firmware.

ვირტუალური მოწყობილობა და მისი ურთიერთქმედება მთავარ ოპერაციულ სისტემასთან შეიძლება წარმოდგენილი იყოს შემდეგი დიაგრამით:

ემულატორის ამჟამინდელი ტესტის მაგალითი მოიცავს ურთიერთქმედებას ძირითადი OS-ის COM პორტებთან (UART და UART გამართვა Bluetooth მოდულისთვის). ეს შეიძლება იყოს რეალური პორტები, რომლებთანაც დაკავშირებულია მოწყობილობები ან ვირტუალური 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 პორტიდან.

სოკატის გამოყენებით

UNIX სისტემებზე ვირტუალური COM პორტები ავტომატურად იქმნება ემულატორის მიერ ამისთვის socat უტილიტის გამოყენებით, უბრალოდ მიუთითეთ პორტის სახელში პრეფიქსი ემულატორის გაშვებისას socat:.

შიდა ბრძანების ხაზის ინტერფეისი (Argparse ან Python)

ვინაიდან Kopycat არის კონსოლის აპლიკაცია, ემულატორი უზრუნველყოფს ბრძანების ხაზის ინტერფეისის ორ ვარიანტს მის ობიექტებთან და ცვლადებთან ურთიერთობისთვის: Argparse და Python.

Argparse არის CLI ჩაშენებული Kopycat-ში და ყოველთვის ხელმისაწვდომია ყველასთვის.

ალტერნატიული CLI არის Python თარჯიმანი. მის გამოსაყენებლად თქვენ უნდა დააინსტალიროთ Jep Python მოდული და დააკონფიგურიროთ ემულატორი პითონთან მუშაობისთვის (გამოიყენება მომხმარებლის მთავარ სისტემაზე დაინსტალირებული Python თარჯიმანი).

პითონის მოდულის ინსტალაცია Jep

Linux-ის ქვეშ Jep შეიძლება დაინსტალირდეს პიპის საშუალებით:

pip install jep

Windows-ზე Jep-ის დასაყენებლად, ჯერ უნდა დააინსტალიროთ Windows SDK და შესაბამისი Microsoft Visual Studio. ჩვენ ცოტათი გაგიადვილეთ და WHL აშენებს JEP პითონის მიმდინარე ვერსიებისთვის 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.

თქვენი სისტემის ემულატორის სერიულ ფაილში (კოპირება.ღამურა - Windows-ისთვის, კოპირება — для Linux) к списку параметров 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).

Windows-ზე გასაშვები ბრძანება:

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

Linux-ის ქვეშ მუშაობის ბრძანება 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 - ბილიკი firmware ფაილისკენ;
• 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 firmware, როგორც წყარო ფაილი ანალიზისთვის IDA-ში ფორმაში ELF ფაილი (მეტა ინფორმაცია იქ ინახება).

თქვენ ასევე შეგიძლიათ გამოიყენოთ ძირითადი პროგრამული უზრუნველყოფა მეტა ინფორმაციის გარეშე.

IDA Pro-ში Kopycat-ის გაშვების შემდეგ, Debugger მენიუში გადადით პუნქტზე “გამართვის ჩართვა…"და აირჩიეთ"დისტანციური GDB გამართვა". შემდეგი, დააყენეთ კავშირი: მენიუ Debugger - დამუშავების პარამეტრები…

დააყენეთ მნიშვნელობები:

• აპლიკაცია - ნებისმიერი მნიშვნელობა
• ჰოსტის სახელი: 127.0.0.1 (ან დისტანციური აპარატის IP მისამართი, სადაც მუშაობს Kopycat)
• პორტი: 23946

ახლა გამართვის ღილაკი ხელმისაწვდომი ხდება (F9 გასაღები):

დააწკაპუნეთ მასზე, რათა დაუკავშირდეთ გამართვის მოდულს ემულატორში. IDA გადადის გამართვის რეჟიმში, ხელმისაწვდომი ხდება დამატებითი ფანჯრები: ინფორმაცია რეგისტრების შესახებ, სტეკის შესახებ.

ახლა ჩვენ შეგვიძლია გამოვიყენოთ გამართვის ყველა სტანდარტული ფუნქცია:

• ინსტრუქციების ეტაპობრივი შესრულება (Შეაბიჯე и გადააბიჯე — კლავიშები F7 და F8, შესაბამისად);
• შესრულების დაწყება და შეჩერება;
• შეწყვეტის წერტილების შექმნა როგორც კოდისთვის, ასევე მონაცემებისთვის (F2 გასაღები).

გამართავთან დაკავშირება არ ნიშნავს firmware კოდის გაშვებას. მიმდინარე შესრულების პოზიცია უნდა იყოს მისამართი 0x08006A74 - ფუნქციის დაწყება Reset_Handler. თუ ჩამონათვალს ქვემოთ გადახვევთ, შეგიძლიათ იხილოთ ფუნქციის გამოძახება მთავარი. თქვენ შეგიძლიათ მოათავსოთ კურსორი ამ ხაზზე (მისამართი 0x08006ABE) და შეასრულეთ ოპერაცია გაუშვით კურსორამდე (გასაღები F4).

შემდეგი, შეგიძლიათ დააჭიროთ F7 ფუნქციის შესაყვანად მთავარი.

ესლი ვიპოლნიტ ბრძანება პროცესის გაგრძელება (F9 ღილაკი), შემდეგ გამოჩნდება ფანჯარა „გთხოვთ დაელოდოთ“ ერთი ღილაკით შეაჩეროს:

როდესაც დააჭერთ შეაჩეროს firmware კოდის შესრულება შეჩერებულია და შეიძლება გაგრძელდეს იმავე მისამართიდან იმ კოდიდან, სადაც ის შეწყდა.

თუ გააგრძელებთ კოდის შესრულებას, ვირტუალურ COM პორტებთან დაკავშირებულ ტერმინალებში ნახავთ შემდეგ ხაზებს:

"სახელმწიფო შემოვლითი" ხაზის არსებობა მიუთითებს იმაზე, რომ ვირტუალური Bluetooth მოდული გადავიდა მომხმარებლის COM პორტიდან მონაცემების მიღების რეჟიმში.

ახლა Bluetooth ტერმინალში (სურათზე COM29) შეგიძლიათ შეიყვანოთ ბრძანებები Rhino პროტოკოლის შესაბამისად. მაგალითად, "MEOW" ბრძანება დააბრუნებს სტრიქონს "mur-mur" Bluetooth ტერმინალში:

მიბაძა სრულებით არა

ემულატორის შექმნისას შეგიძლიათ აირჩიოთ კონკრეტული მოწყობილობის დეტალების/ემულაციის დონე. მაგალითად, Bluetooth მოდულის ემულაცია შესაძლებელია სხვადასხვა გზით:

• მოწყობილობა სრულად არის ემულირებული ბრძანებების სრული კომპლექტით;
• AT ბრძანებები ემულირებულია და მონაცემთა ნაკადი მიიღება ძირითადი სისტემის COM პორტიდან;
• ვირტუალური მოწყობილობა უზრუნველყოფს მონაცემთა სრულ გადამისამართებას რეალურ მოწყობილობაზე;
• როგორც უბრალო ნაკერი, რომელიც ყოველთვის აბრუნებს "OK".

ემულატორის ამჟამინდელი ვერსია იყენებს მეორე მიდგომას - ვირტუალური Bluetooth მოდული ასრულებს კონფიგურაციას, რის შემდეგაც იგი გადადის მონაცემთა "პროქსის" რეჟიმში ძირითადი სისტემის COM პორტიდან ემულატორის UART პორტში.

განვიხილოთ კოდის მარტივი ინსტრუმენტაციის შესაძლებლობა იმ შემთხვევაში, თუ პერიფერიის ზოგიერთი ნაწილი არ არის დანერგილი. მაგალითად, თუ DMA-ზე მონაცემთა გადაცემის კონტროლზე პასუხისმგებელი ტაიმერი არ არის შექმნილი (შემოწმება ხორციელდება ფუნქციაში ws2812b_waitმდებარეობს 0x08006840), მაშინ firmware ყოველთვის დაელოდება დროშის გადატვირთვას დაკავებულიამდებარეობს 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 სცენარის ხაზში:

თუ თქვენ აწარმოებთ firmware-ს შესასრულებლად, წყვეტის წერტილის დამმუშავებლის კოდის ამოქმედება შეგიძლიათ იხილოთ IDA ფანჯარაში. გამოყვანის ხაზით Skipping wait ws2812.... ახლა firmware არ დაელოდება დროშის გადატვირთვას დაკავებულია.

ურთიერთქმედება ემულატორთან

ემულაცია ემულაციის გულისთვის ნაკლებად სავარაუდოა, რომ გამოიწვიოს სიამოვნება და სიხარული. გაცილებით საინტერესოა, თუ ემულატორი ეხმარება მკვლევარს მეხსიერებაში მონაცემების დანახვაში ან ძაფების ურთიერთქმედების დადგენაში.

ჩვენ გაჩვენებთ, თუ როგორ უნდა დაამყაროთ დინამიურად ურთიერთქმედება RTOS ამოცანებს შორის. თქვენ ჯერ უნდა შეაჩეროთ კოდის შესრულება, თუ ის გაშვებულია. თუ მიდიხარ ფუნქციაზე bluetooth_task_entry "LED" ბრძანების დამუშავების ფილიალში (მისამართი 0x080057B8), შემდეგ შეგიძლიათ ნახოთ, რა არის ჯერ შექმნილი და შემდეგ იგზავნება სისტემის რიგში ledControlQueueHandle რაღაც მესიჯი.

თქვენ უნდა დააყენოთ წყვეტის წერტილი ცვლადზე წვდომისთვის ledControlQueueHandleმდებარეობს 0x20000624 და გააგრძელეთ კოდის შესრულება:

შედეგად, გაჩერება პირველად მოხდება მისამართზე 0x080057CA ფუნქციის გამოძახებამდე osMailAlloc, შემდეგ მისამართზე 0x08005806 ფუნქციის გამოძახებამდე osMailPut, შემდეგ ცოტა ხნის შემდეგ - მისამართზე 0x08005BD4 (ფუნქციის გამოძახებამდე osMailGet), რომელიც ეკუთვნის ფუნქციას leds_task_entry (LED-task), ანუ ამოცანები შეიცვალა და ახლა LED-ამოცანა მიიღო კონტროლი.

ამ მარტივი გზით შეგიძლიათ დაადგინოთ, თუ როგორ ურთიერთობენ RTOS ამოცანები ერთმანეთთან.

რა თქმა უნდა, სინამდვილეში, დავალებების ურთიერთქმედება შეიძლება უფრო რთული იყოს, მაგრამ ემულატორის გამოყენებით, ამ ურთიერთქმედების თვალყურის დევნება ნაკლებად შრომატევადი ხდება.

აქ შეგიძლიათ ნახოთ მოკლე ვიდეო ემულატორის გაშვებისა და IDA Pro-სთან ურთიერთობის შესახებ.

Запуск с Radare2

თქვენ არ შეგიძლიათ უგულებელყოთ ისეთი უნივერსალური ინსტრუმენტი, როგორიცაა Radare2.

ემულატორთან დასაკავშირებლად r2-ის გამოყენებით, ბრძანება ასე გამოიყურება:

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

გაშვება ხელმისაწვდომია ახლა (dc) და შეაჩერე შესრულება (Ctrl+C).

სამწუხაროდ, ამ დროისთვის, r2-ს აქვს პრობლემები ტექნიკის gdb სერვერთან მუშაობისას და მეხსიერების განლაგება ამის გამო, წყვეტის წერტილები და ნაბიჯები არ მუშაობს (ბრძანება ds). ვიმედოვნებთ, რომ ეს მალე გამოსწორდება.

სირბილი Eclipse-ით

ემულატორის გამოყენების ერთ-ერთი ვარიანტია შემუშავებული მოწყობილობის პროგრამული უზრუნველყოფის გამართვა. სიცხადისთვის, ჩვენ ასევე გამოვიყენებთ Rhino firmware-ს. შეგიძლიათ ჩამოტვირთოთ firmware წყაროები აქედან გამომდინარე,.

ჩვენ გამოვიყენებთ Eclipse-ს ნაკრებიდან, როგორც IDE სისტემის სამუშაო მაგიდა STM32-ისთვის.

იმისათვის, რომ ემულატორმა ჩატვირთოს Eclipse-ში პირდაპირ შედგენილი firmware, თქვენ უნდა დაამატოთ პარამეტრი firmware=null ემულატორის გაშვების ბრძანებაზე:

binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28

გამართვის კონფიგურაციის დაყენება

Eclipse-ში აირჩიეთ მენიუ გაშვება - კონფიგურაციების გამართვა... ფანჯარაში, რომელიც იხსნება, განყოფილებაში GDB აპარატურის გამართვა თქვენ უნდა დაამატოთ ახალი კონფიგურაცია, შემდეგ "მთავარი" ჩანართზე მიუთითეთ მიმდინარე პროექტი და პროგრამა გამართვისთვის:

"Debugger" ჩანართზე თქვენ უნდა მიუთითოთ GDB ბრძანება:
${openstm32_compiler_path}arm-none-eabi-gdb

ასევე შეიყვანეთ GDB სერვერთან დაკავშირების პარამეტრები (ჰოსტი და პორტი):

"გაშვების" ჩანართზე უნდა მიუთითოთ შემდეგი პარამეტრები:

• ჩამრთველის ჩართვა სურათის ჩატვირთვა (ისე, რომ აწყობილი პროგრამული უზრუნველყოფის სურათი ჩაიტვირთება ემულატორში);
• ჩამრთველის ჩართვა სიმბოლოების ჩატვირთვა;
• დაამატეთ გაშვების ბრძანება: set $pc = *0x08000004 (დააყენეთ კომპიუტერის რეგისტრი მნიშვნელობა მეხსიერებიდან მისამართზე 0x08000004 - მისამართი ინახება იქ ResetHandler).

შენიშვნათუ არ გსურთ firmware ფაილის ჩამოტვირთვა Eclipse-დან, მაშინ ოფციები სურათის ჩატვირთვა и გაუშვით ბრძანებები არ არის საჭირო მითითება.

გამართვის დაწკაპუნების შემდეგ, შეგიძლიათ იმუშაოთ გამართვის რეჟიმში:

• пошаговое выполнение кода
  
• ინტერაქცია წყვეტის წერტილებთან
  

შენიშვნა. Eclipse-ს აქვს, ჰმ... რაღაც უცნაურობები... და თქვენ უნდა იცხოვროთ მათთან ერთად. მაგალითად, თუ გამართვის გაშვებისას გამოჩნდება შეტყობინება „არ არის ხელმისაწვდომი წყარო „0x0″-სთვის“, მაშინ შეასრულეთ ნაბიჯი ბრძანება (F5)

იმის ნაცვლად, რომ დასკვნა

მშობლიური კოდის ემულაცია ძალიან საინტერესო რამ არის. მოწყობილობის დეველოპერისთვის შესაძლებელი ხდება firmware-ის გამართვა რეალური მოწყობილობის გარეშე. მკვლევარისთვის ეს არის კოდის დინამიური ანალიზის ჩატარების შესაძლებლობა, რაც ყოველთვის არ არის შესაძლებელი მოწყობილობითაც კი.

ჩვენ გვსურს მივაწოდოთ სპეციალისტებს ხელსაწყო, რომელიც არის მოსახერხებელი, ზომიერად მარტივი და არ მოითხოვს დიდ ძალისხმევასა და დროს დაყენებასა და გაშვებას.

დაწერეთ კომენტარებში თქვენი გამოცდილების შესახებ ტექნიკის ემულატორების გამოყენებით. გეპატიჟებით განხილვაზე და სიამოვნებით გიპასუხებთ კითხვებზე.

გამოკითხვაში მონაწილეობა შეუძლიათ მხოლოდ დარეგისტრირებულ მომხმარებლებს. Შებრძანდითგთხოვთ

რისთვის იყენებთ ემულატორს?

• ვამუშავებ (გამართვა) firmware

• მე ვსწავლობ firmware-ს

• ვიწყებ თამაშებს (დენდი, სეგა, PSP)

• სხვა რამე (დაწერეთ კომენტარებში)

მისცა ხმა 7 მომხმარებელმა. 2 მომხმარებელმა თავი შეიკავა.

რა პროგრამულ უზრუნველყოფას იყენებთ მშობლიური კოდის ემულაციისთვის?

• QEMU

• Unicorn ძრავა

• Proteus

• სხვა რამე (დაწერეთ კომენტარებში)

მისცა ხმა 6 მომხმარებელმა. 2 მომხმარებელმა თავი შეიკავა.

რის გაუმჯობესებას ისურვებდით ემულატორში, რომელსაც იყენებთ?

• სიჩქარე მინდა

• დაყენების/გაშვების სიმარტივე მინდა

• მე მინდა მეტი ვარიანტი ემულატორთან ურთიერთობისთვის (API, კაკვები)

• ყველაფრით კმაყოფილი ვარ

• სხვა რამე (დაწერეთ კომენტარებში)

მისცა ხმა 8 მომხმარებელმა. 1 მომხმარებელმა თავი შეიკავა.

წყარო: www.habr.com