קרנף בתוך חתול - הפעל את הקושחה באמולטור Kopycat

במסגרת הפגישה 0x0A DC7831 DEF CON ניז'ני נובגורוד ב-16 בפברואר הצגנו דו"ח על העקרונות הבסיסיים של אמולציית קוד בינארי והפיתוח שלנו - אמולטור פלטפורמת חומרה עותק.

במאמר זה נתאר כיצד להפעיל את קושחת המכשיר באמולטור, להדגים אינטראקציה עם ה-debugger, ולבצע ניתוח דינמי קטן של הקושחה.

פרהיסטוריה

לפני הרבה זמן בגלקסיה רחוקה רחוקה

לפני כמה שנים במעבדה שלנו היה צורך לחקור את הקושחה של מכשיר. הקושחה נדחסה ופורקה עם טוען אתחול. הוא עשה זאת בצורה מאוד מסובכת, והעביר את הנתונים בזיכרון מספר פעמים. והקושחה עצמה עשתה אז אינטראקציה אקטיבית עם הציוד ההיקפי. וכל זה בליבת MIPS.

מסיבות אובייקטיביות, האמולטורים הזמינים לא התאימו לנו, אבל בכל זאת רצינו להפעיל את הקוד. ואז החלטנו ליצור אמולטור משלנו, שיעשה את המינימום ויאפשר לנו לפרק את הקושחה הראשית. ניסינו את זה וזה עבד. חשבנו, מה אם נוסיף ציוד היקפי כדי לבצע גם את הקושחה הראשית. זה לא כאב במיוחד - וגם זה הסתדר. חשבנו שוב והחלטנו לעשות אמולטור מן המניין.

התוצאה הייתה אמולטור מערכות מחשב עותק.

למה קופיקאט?

יש משחק מילים.

1. חקיין (אנגלית, שם עצם [ˈkɒpɪkæt]) - חקיין, חקיין
2. חתול (אנגלית, שם עצם [ˈkæt]) - חתול, חתול - החיה האהובה על אחד מיוצרי הפרויקט
3. האות "K" היא משפת התכנות Kotlin

עותק

בעת יצירת האמולטור, הוגדרו יעדים מאוד ספציפיים:

• היכולת ליצור במהירות ציוד היקפי, מודולים, ליבות מעבדים חדשים;
• היכולת להרכיב מכשיר וירטואלי ממודולים שונים;
• היכולת לטעון כל נתונים בינאריים (קושחה) לזיכרון של מכשיר וירטואלי;
• יכולת לעבוד עם תצלומי מצב (תצלומים של מצב המערכת);
• היכולת ליצור אינטראקציה עם האמולטור באמצעות מאתר הבאגים המובנה;
• שפה מודרנית נחמדה להתפתחות.

כתוצאה מכך, Kotlin נבחר ליישום, ארכיטקטורת האוטובוס (זה כאשר מודולים מתקשרים זה עם זה באמצעות אפיקי נתונים וירטואליים), JSON כפורמט תיאור המכשיר, ו-GDB RSP כפרוטוקול לאינטראקציה עם ה-debugger.

הפיתוח נמשך קצת יותר משנתיים ונמשך באופן פעיל. במהלך תקופה זו יושמו ליבות מעבד MIPS, x86, V850ES, ARM ו-PowerPC.

הפרויקט צומח והגיע הזמן להציג אותו לציבור הרחב. אנו נעשה תיאור מפורט של הפרויקט מאוחר יותר, אך לעת עתה נתמקד בשימוש בקופיקאט.

עבור חסרי הסבלנות ביותר, ניתן להוריד גרסת פרומו של האמולטור קשר.

קרנף באמולטור

הבה נזכיר כי מוקדם יותר עבור כנס SMARTRHINO-2018, נוצר מכשיר בדיקה "קרנף" להוראת מיומנויות הנדסה הפוכה. התהליך של ניתוח קושחה סטטי תואר ב מאמר זה.

כעת ננסה להוסיף "רמקולים" ולהפעיל את הקושחה באמולטור.

אנחנו צריכים:
1) Java 1.8
2) פייתון ומודול ג'פ להשתמש ב-Python בתוך האמולטור. אתה יכול לבנות את מודול WHL Jep עבור Windows הורד כאן.

עבור Windows:
1) com0com
2) מרק

עבור לינוקס:
1) socat

אתה יכול להשתמש ב-Eclipse, IDA Pro או radare2 כלקוח GDB.

איך זה עובד?

על מנת לבצע קושחה באמולטור, יש צורך "להרכיב" מכשיר וירטואלי, שהוא אנלוגי למכשיר אמיתי.

ניתן להציג את המכשיר האמיתי ("קרנף") בתרשים הבלוק:

לאמולטור מבנה מודולרי וניתן לתאר את המכשיר הוירטואלי הסופי בקובץ 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 הוא שם של קובץ שניתן לטעון למכשיר וירטואלי בתור קושחה.

ניתן לייצג את המכשיר הוירטואלי והאינטראקציה שלו עם מערכת ההפעלה הראשית באמצעות הדיאגרמה הבאה:

מופע הבדיקה הנוכחי של האמולטור כולל אינטראקציה עם יציאות ה-COM של מערכת ההפעלה הראשית (ניפוי באגים ב-UART ו-UART עבור מודול ה-Bluetooth). אלו יכולות להיות יציאות אמיתיות שאליהן מחוברים התקנים או יציאות COM וירטואליות (בשביל זה אתה רק צריך com0com/socat).

כדי ליצור אינטראקציה עם האמולטור מבחוץ, יש כרגע שתי דרכים עיקריות:

• פרוטוקול GDB RSP (בהתאם, הכלים התומכים בפרוטוקול זה הם Eclipse / IDA / radare2);
• שורת הפקודה הפנימית של אמולטור (Argparse או Python).

יציאות COM וירטואליות

על מנת ליצור אינטראקציה עם UART של מכשיר וירטואלי במחשב המקומי באמצעות מסוף, עליך ליצור זוג יציאות COM וירטואליות משויכות. במקרה שלנו, יציאה אחת משמשת את האמולטור, והשנייה על ידי תוכנית מסוף (PuTTY או מסך):

שימוש ב-com0com

יציאות COM וירטואליות מוגדרות באמצעות תוכנית השירות להגדרה מהערכת com0com (גרסת המסוף - C:Program Files (x86)com0comsetupс.exe, או גרסת GUI - C:Program Files (x86)com0comsetupg.exe):

סמן את התיבות אפשר הצפת מאגר עבור כל היציאות הוירטואליות שנוצרו, אחרת האמולטור ימתין לתגובה מיציאת ה-COM.

באמצעות socat

במערכות UNIX, יציאות COM וירטואליות נוצרות אוטומטית על ידי האמולטור באמצעות כלי השירות socat; לשם כך, פשוט ציין את הקידומת בשם היציאה בעת הפעלת האמולטור socat:.

ממשק שורת פקודה פנימי (Argparse או Python)

מכיוון שקופיקט הוא יישום מסוף, האמולטור מספק שתי אפשרויות ממשק שורת פקודה לאינטראקציה עם האובייקטים והמשתנים שלו: Argparse ו-Python.

Argparse הוא CLI מובנה בקופיקאט וזמין תמיד לכולם.

CLI חלופי הוא מתורגמן Python. כדי להשתמש בו, עליך להתקין את מודול Jep Python ולהגדיר את האמולטור לעבוד עם Python (ייעשה שימוש במתורגמן של Python המותקן במערכת הראשית של המשתמש).

התקנת מודול Python 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.

בקובץ האצווה של האמולטור עבור המערכת שלך (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).

פקודה להפעלה תחת Windows:

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).

חיבור ל-debugger לא אומר להפעיל את קוד הקושחה. עמדת הביצוע הנוכחית חייבת להיות הכתובת 0x08006A74 - תחילת הפונקציה Reset_Handler. אם תגלול למטה ברישום, תוכל לראות את שיחת הפונקציה ראשי. אתה יכול למקם את הסמן על שורה זו (כתובת 0x08006ABE) ולבצע את הפעולה הפעל עד הסמן (מקש F4).

לאחר מכן, תוכל ללחוץ על F7 כדי להיכנס לפונקציה ראשי.

אם תפעיל את הפקודה המשך בתהליך (מקש F9), ואז יופיע חלון "נא המתן" עם כפתור בודד להשעות:

כשאתה לוחץ להשעות ביצוע קוד הקושחה מושעה וניתן להמשיך אותה מאותה כתובת בקוד שבה הוא הופסק.

אם תמשיך בביצוע הקוד, תראה את השורות הבאות במסופים המחוברים ליציאות ה-COM הוירטואליות:

הנוכחות של קו "עקיפת המדינה" מצביעה על כך שמודול ה-Bluetooth הוירטואלי עבר למצב של קבלת נתונים מיציאת ה-COM של המשתמש.

כעת במסוף בלוטות' (COM29 בתמונה) ניתן להזין פקודות בהתאם לפרוטוקול Rhino. לדוגמה, הפקודה "MEOW" תחזיר את המחרוזת "mur-mur" למסוף ה-Bluetooth:

תחקו אותי לא לגמרי

בעת בניית אמולטור, ניתן לבחור את רמת הפירוט/הדמייה של מכשיר מסוים. לדוגמה, ניתן לחקות את מודול ה-Bluetooth בדרכים שונות:

• המכשיר מחולק במלואו עם קבוצה מלאה של פקודות;
• פקודות AT מחוקות, וזרם הנתונים מתקבל מיציאת ה-COM של המערכת הראשית;
• המכשיר הוירטואלי מספק הפניית נתונים מלאה למכשיר האמיתי;
• בתור בדל פשוט שתמיד מחזיר "בסדר".

הגרסה הנוכחית של האמולטור משתמשת בגישה השנייה - מודול ה-Bluetooth הוירטואלי מבצע תצורה, ולאחר מכן הוא עובר למצב של "פרוקסי" נתונים מיציאת ה-COM של המערכת הראשית ליציאת UART של האמולטור.

בואו נשקול את האפשרות של מכשור פשוט של הקוד במקרה שחלק מהפריפריה לא מיושם. לדוגמה, אם לא נוצר טיימר שאחראי על בקרת העברת הנתונים ל-DMA (הבדיקה מתבצעת בפונקציה ws2812b_waitממוקם ב 0x08006840), אז הקושחה תמיד תחכה לאיפוס הדגל עסוקממוקם ב 0x200004C4שמראה את התפוסה של קו הנתונים של DMA:

נוכל לעקוף את המצב הזה על ידי איפוס ידני של הדגל עסוק מיד לאחר התקנתו. ב-IDA Pro אפשר ליצור פונקציית Python ולקרוא לה ב-breakpoint, ולשים את ה-breakpoint עצמו בקוד לאחר כתיבת הערך 1 לדגל עסוק.

מטפל בנקודת שבירה

ראשית, בואו ניצור פונקציית Python ב-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.... כעת הקושחה לא תחכה לאיפוס הדגל עסוק.

אינטראקציה עם האמולטור

לא סביר שהאמולציה לשם חיקוי תגרום לעונג ושמחה. זה הרבה יותר מעניין אם האמולטור עוזר לחוקר לראות את הנתונים בזיכרון או לבסס את האינטראקציה של שרשורים.

אנו נראה לך כיצד ליצור אינטראקציה דינמית בין משימות RTOS. תחילה עליך להשהות את ביצוע הקוד אם הוא פועל. אם אתה הולך לפונקציה bluetooth_task_entry לענף העיבוד של פקודת "LED" (כתובת 0x080057B8), ואז תוכל לראות מה נוצר לראשונה ולאחר מכן נשלח לתור המערכת ledControlQueueHandle הודעה כלשהי.

עליך להגדיר נקודת עצירה כדי לגשת למשתנה ledControlQueueHandleממוקם ב 0x20000624 והמשך בביצוע הקוד:

כתוצאה מכך, העצירה תתרחש תחילה בכתובת 0x080057CA לפני הקריאה לפונקציה osMailAlloc, ואז בכתובת 0x08005806 לפני הקריאה לפונקציה osMailPut, ואז לאחר זמן מה - לכתובת 0x08005BD4 (לפני קריאת הפונקציה osMailGet), השייך לפונקציה leds_task_entry (משימת LED), כלומר, המשימות התחלפו, ועכשיו משימת 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. אתה יכול להוריד את מקורות הקושחה מכאן.

נשתמש ב-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 אתה צריך להוסיף תצורה חדשה, ולאחר מכן בכרטיסייה "ראשי" ציין את הפרויקט הנוכחי ואת היישום לאיתור באגים:

בכרטיסייה "Debugger" עליך לציין את פקודת GDB:
${openstm32_compiler_path}arm-none-eabi-gdb

וגם הזן את הפרמטרים לחיבור לשרת GDB (מארח ויציאה):

בכרטיסייה "אתחול", עליך לציין את הפרמטרים הבאים:

• תיבת סימון אפשר טען תמונה (כך שתמונת הקושחה המורכבת תיטען לאמולטור);
• תיבת סימון אפשר טען סמלים;
• הוסף פקודת הפעלה: set $pc = *0x08000004 (הגדר את אוגר המחשב לערך מהזיכרון בכתובת 0x08000004 - הכתובת מאוחסנת שם ResetHandler).

שים לב, אם אינך רוצה להוריד את קובץ הקושחה מאקליפס, אז האפשרויות טען תמונה и הפעל פקודות אין צורך לציין.

לאחר לחיצה על איתור באגים, תוכל לעבוד במצב ניפוי באגים:

• ביצוע קוד צעד אחר צעד
  
• אינטראקציה עם נקודות שבירה
  

שים לב. לליקוי יש, הממ... כמה מוזרויות... ואתה צריך לחיות איתם. לדוגמה, אם בעת הפעלת מאתר הבאגים מופיעה ההודעה "אין מקור זמין עבור "0x0", אז בצע את הפקודה Step (F5)

במקום מסקנה

אמולציה של קוד מקורי הוא דבר מאוד מעניין. זה הופך להיות אפשרי עבור מפתח מכשירים לנפות באגים בקושחה ללא מכשיר אמיתי. עבור חוקר, זו הזדמנות לבצע ניתוח קוד דינמי, מה שלא תמיד אפשרי אפילו עם מכשיר.

אנו רוצים לספק למומחים כלי נוח, פשוט במידה ולא לוקח הרבה מאמץ וזמן להתקין ולהפעיל.

כתוב בהערות על החוויה שלך בשימוש באמולטורים של חומרה. אנו מזמינים אתכם לדון ונשמח לענות על שאלות.

רק משתמשים רשומים יכולים להשתתף בסקר. להתחברבבקשה.

בשביל מה אתה משתמש באמולטור?

• אני מפתח (באגים) קושחה

• אני חוקר קושחה

• אני משיק משחקים (Dendi, Sega, PSP)

• משהו אחר (כתוב בתגובות)

7 משתמשים הצביעו. 2 משתמשים נמנעו.

באיזו תוכנה אתה משתמש כדי לחקות קוד מקורי?

• QEMU

• מנוע חד קרן

• פרוטאוס

• משהו אחר (כתוב בתגובות)

6 משתמשים הצביעו. 2 משתמשים נמנעו.

מה תרצה לשפר באמולטור שבו אתה משתמש?

• אני רוצה מהירות

• אני רוצה קלות התקנה/השקה

• אני רוצה אפשרויות נוספות לאינטראקציה עם האמולטור (API, hooks)

• אני מרוצה מהכל

• משהו אחר (כתוב בתגובות)

8 משתמשים הצביעו. משתמש אחד נמנע.

מקור: www.habr.com