דיבאג של קובץ so עם IDA ופריצה לתוך UnCrackable-Level2

בלי כתוביותעם כתוביות

מילון מושגים:

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

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

Java - שפת תכנות עילית ומונחית עצמים, הרצה על מכונה וירטואלית (JVM) ומשמשת לפיתוח מגוון יישומים.

אימות - תהליך שמוודא שהמשתמש או המערכת הם מי שהם טוענים שהם, בדרך כלל באמצעות סיסמה, קוד או תעודה.

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

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

הקסדצימלי - שיטת ספירה בבסיס 16, המשתמשת בספרות 0-9 ובאותיות A-F, ונפוצה לייצוג ערכים בינאריים בקצרה.

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

דיבאג של קובץ so עם IDA ופריצה לתוך UnCrackable-Level2

בשיעור זה נגלה את הקוד הסודי של UnCrackable Level 2 בעזרת חיבור הדבאגר של IDA אל האפליקציה הרצה בטלפון. סוכן סמוי רץ בתוך הטלפון וממתין לחיבור הדיבאגינג שלנו, נעצור את הקוד בזמן אמת, נציץ בזיכרון ובמחסנית, ונגלה את הסיסמה הסודית שמושוות בתוך הספרייה.

נושאי הסיכום המוצגים בשיעור:

1. ההכנה: ב IDA Pro פותחים ניתוח חדש על קובץ הספרייה libfoo.so של אנדרואיד, ומציבים נקודת עצירה בתוך פונקציית bar, הפונקציה שאליה Java שולחת את הקלט לבדיקה, כפי שראינו ב JADX, ובדיוק בתחילתה.

2. חיבור הדבאגר אל הטלפון: בתפריט הדבאגר פותחים את אפשרויות התהליך ומזינים את הכתובת של הטלפון. מומלץ תמיד לבדוק לפני כן בעזרת פינג שיש תקשורת, כי הטלפון מוגדר במצב גשר. אחר כך נכנסים אל touch to process, מאתרים בתוך הטלפון את התהליך של UnCrackable 2 ומתחברים אליו עם הדבאגר. הוא שואל אם מה שרץ בטלפון ומה שיש על המסך הם אותו דבר, עונים שכן, והוא מחבר, ואז לוחצים הרצה.

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

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

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

6. הפיכת שפת המכונה ל C: עוברים שורה שורה בשפת המכונה אך זה אינו עוזר הרבה, כי קשה להבין שם. לוחצים F5, שמנסה להפוך את הפונקציה חזרה לשפת C, ומופיע קוד בשפת C שהרבה יותר קריא. בקוד הזה רואים שהפונקציה מחזירה בסופה משתנה result שמתחיל מאפס והופך לאחד אם מתקיים תנאי, ואותו תנאי צריך להבין ולפענח.

7. התנאי שנראה מבולבל: התנאי מורכב מכמה חלקים, חלק שמשווה משהו אל המספר 23, וחלק שהוא קריאת השוואת מחרוזות, strcmp, שבה כנראה יושבת התשובה. הסיבה לבלבול היא ש IDA לא פירש נכון את הסיפור.

8. הסוד של הפרמטר הראשון ב JNI: המשתנה הראשון בכל פונקציית JNI הוא תמיד משתנה שמצביע אל כתובת בזיכרון שבה יושבת סביבת ה JNI. מסמנים את הפרמטר ולוחצים Y, ואומרים לכלי שזה אינו מספר סתם אלא מצביע, כוכבית, אל JNIEnv. ברגע שעשינו זאת השורה נהיית ברורה לגמרי, הכלי מבין שזאת קריאה לפונקציה בשם get array length שבודקת את אורך הקלט, והקלט צריך להיות 23, ורק אז מתבצעת השוואת המחרוזות. מקווים שבגרסאות הבאות הכלי יידע לפענח זאת מעצמו.

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

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

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

12. התנאי הראשון, אורך הקלט: בהגעה אל ההשוואה הראשונה רואים השוואה בין הערך שברגיסטר לבין המספר 17 בבסיס הקסדצימלי, ואחריה פקודת קפיצה אם אינם שווים. כשמקלידים באפליקציה מספרים שונים רואים שהערך ברגיסטר הוא אורך הקלט שלנו, ומחשבון מתברר ש 17 בבסיס הקסדצימלי הוא 23 בדיוק. כלומר הקלט צריך להיות 23 תווים בדיוק, ורק אז מגיעים אל אזור של קריאת השוואת המחרוזות. גם בשפת C רואים זאת, האורך חייב להיות 23, ושני התנאים חייבים להתקיים יחד מפני שביניהם סימן ו, ואם התנאי הראשון אינו מתקיים אין טעם לבדוק את השני והקוד לא מגיע אל ההשוואה שרצינו.

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

14. מעקב אחרי הכתובות ב dump: בלחיצה ימנית על הכתובת שנדחפה בוחרים מעקב בתוך dump, והחלון של hex view, שהוא dump גולמי של הזיכרון, עוקב אחרי הכתובת הזאת. בכתובת הראשונה יושבים המספרים 31, 32, 33, 34, שלפי תקן ASCII הם המחרוזת 1234, כלומר זהו הקלט שהמשתמש הקיש. אם זה הקלט, בטח שהסיסמה הסודית היא בכתובת השנייה.

15. גילוי הסיסמה: מעקב אחרי הכתובת השנייה מגלה בתוכה מספרים שלפי ASCII הם המשפט thanks all for the fish, וכנראה שזו הסיסמה הסודית. מעתיקים אותה, מזינים אותה באפליקציה, שוב מטפלים בהודעות השגיאה שאין לעצור ולהעביר חזרה אל האפליקציה, מבצעים אימות, ובנקודת העצירה רואים שנדחפו האורך 17 ושתי הכתובות, ושתיהן מכילות כעת את אותו משפט, כלומר השוואת המחרוזות תחזיר אמת והפונקציה תחזיר אמת. לוחצים הרצה, ומופיע Success, הצלחנו לעלות על הסיסמה.

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

בשיעור זה חיברנו את הדבאגר של IDA אל האפליקציה הרצה בטלפון דרך הסוכן הסמוי, טיפלנו בהודעות האותות שלא יעצרו את הריצה, הפכנו את הפונקציה לקוד C בעזרת F5, תיקנו את פרשנות הפרמטר הראשון של JNI כמצביע אל סביבת ה JNI, גילינו שהקלט חייב 23 תווים בדיוק, עקבנו אחרי הפרמטרים שנדחפו למחסנית לפני קריאת השוואת המחרוזות, וגילינו בתוכם את הסיסמה הסודית שהוזנה בהצלחה. בשיעור הבא נעסוק בנושא התקנת ממשק גרפי לפרידה.

פרקי ההרצאה: דיבאג של קובץ so עם IDA ופריצה לתוך UnCrackable-Level2

תמלול ההרצאה: דיבאג של קובץ so עם IDA ופריצה לתוך UnCrackable-Level2

הטקסט המלא של הדקות הראשונות בהרצאה «דיבאג של קובץ so עם IDA ופריצה לתוך UnCrackable-Level2» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

00:02
שלום לכולם, ברוכים הבאים להרצאה שבה נגלה את הקוד הסודי שלנו על ידי זה שנתחבר עם הדבאגר לתוך האפליקציה הזאת. אז ככה, קודם כל, יש לנו פה סוכן סמוי שרץ בתוך הטלפון ומחכה לחיבור הדבאגינג שלנו.
00:17
אנחנו מפעילים עאידה פרו, עושים לה new שתדבג את ה-DLL הזה של אנדרואיד, ליפטפון.so. דיברנו על זה בהרצאות קודמות, אז אני לא חוזר.
00:30
אנחנו רוצים לשים breakpoint בתוך פונקציה של בר, זאת הפונקציה שהג'אווה שולחת לבדיקה, ראינו את זה בג'אדקס ואנחנו רוצים לעצור כאן בתחילת הפונקציה ואנחנו רואים שאנחנו פה. עכשיו, איך אנחנו נגלה את הסיסמה?
00:47
קודם כל בוא נראה שזה באמת עובד, שאנחנו מצליחים באמת להגיע לכאן ולהציץ לפקודות האלו, שזה לא ניתוח סטטי, שזה ניתוח דינמי של זיכרון. אנחנו עושים debugger process options, מכניסים פה את ה-IP של הטלפון שלנו.
01:02
אפשר לעשות פינג אליו, לבדוק שהוא באמת עובד. ככה אני מציע לכולם תמיד לבדוק, לעשות פינגים בלראות שזה באמת יש תקשורת, כי הטלפון נמצא בברידג' בהגדרות, ואני עושה את touch to process, מחפש את התהליך בתוך הטלפון, את השם של התוכנה, Uncrackable 2, ומתחבר עם הדבאגר לתוך הטלפון לתוכנה הזאת.
01:26
הוא שואל אותי האם מה שרץ בטלפון ומה שיש לך על המסך זה אותו דבר, אני אומר לו אותו דבר והוא חיבר אותי ואני עושה לו פליי יופי עכשיו אני אחשון פה סיסמה 12345 נעשה verify והנה הוא עוצר לנו בתוך הזה זה נהיה פחות אדום ואני יכול לעבור עם F7 שורה שורה עכשיו תשאלו אותי טוב מה זה עוזר לך שאתה בשפת מכונה איך אתה מבין פה משהו אז אני פה עובר שורה שורה וזה לא אומר לי
01:53
הרבה בוא ננסה לנתח את הקוד הזה ניתן לו לרוץ מהר ואנחנו רואים שהסיסמה לא נכונה טוב אז קודם כל הצלחנו עם הדבאגר להיכנס לו לזיכרון ולהציץ לו מה קורה.
02:06
איפה אני מציץ? במשתנים פה. זה המשתנים של המעבד, אני יכול להציץ פה. אני יכול להציץ לכל כתובת בזיכרון שאני ארצה.
02:16
יש כתובות רגילות, סתם דאמפ, ויש כתובות שמנוהלות בצורה חכמה שנקראת סטאק. אוקיי, אז אני יכול עוד פעם לעשות פה נניח 1, 2, 3, 4, 5, 6, וריפאי, ולעבור פקודה-פקודה ולראות פה דברים משתנים.
02:31
אתם רואים פה כל מיני פקודות רצות, תאי זיכרון פה משתנים, הסטאק פה משתנה, זה פקודות בשפת מכונה. רק מה הבעיה? שזה לא באמת עוזר לי. רגע, יש לי פה הודעת שגיאה.
02:43
הוא קיבל איזשהו סיגנל 33. אני עושה לו פה תמתין. אני עושה לו אוקיי, תריץ קדימה, לא מעניין אותי הסיגנל הזה. Change exception definition, מה לעשות עם הטעויות?
02:55
אני אומר לו, כשמגיעה טעות 21, אל תעצור את התוכנה, ניתן לאפליקציה לטפל בבעיות של עצמה וזהו. כן, אל תעשה לי סאספנד, אוקיי, אוקיי. הוא אומר לי יש גם בעיה 35, אני עושה לו פליי, תמשיך הלאה.
03:11
מה קורה עם בעיה הזאת? אל תעצור לי את התוכנה, פסט טו דה אפליקיישן, תודה רבה. עוד אחד, אוקיי, פסט דה אפליקיישן וזהו.
03:21
אוקיי, בואו נראה שזה עובד. 1, 2, 3, 4, 5, הנה אנחנו עוצרים בפקודה הראשונה בבר, יכולים לעבור שפת מכונה, לעשות פליי, הוא כותב לי שהקוד לא נכון טוב איך ממשיכים קודם כל הצלחנו עם הדבאגר להתחבר פנימה ולהציץ שזה נהדר מבחינתי רק שזה לא באמת עוזר לי כי אני לא מבין בזה כלום אז אני לוחץ כפתור
03:43
F5 שמנסה להפוך את הפונקציה הזאת של בר חזרה לשפת C אולי בשפת C זה יהיה לי יותר ברור כי בכל מקרה השפה הזאת הרבה יותר ברורה מאשר שפת מכונה אני לוחץ F5 ומופיע לי פה קוד בשפת C שזה קוד הרבה הרבה הרבה יותר קריא בוא ננסה לקרוא אותו ולהבין לראות מה אנחנו מבינים ממנו אולי זה יעזור לנו אוקיי אז אני רואה פה שיש לי
04:11
פה דברים לא כאלו ברורים למה זה לא כזה ברור לי טוב בוא נתחיל לפענח קודם כל ככה אנחנו רואים שהפונקציה מחזירה פה ברטורן בסוף הפונקציה הזאת מחזירה משתנה ריזולט המשתנה ריזולט מתחיל מאפס ואם מתקיים איזשהו תנאי הוא הופך לאחד יופי אז אני צריך את התנאי הזה אני צריך להבין את האיף הזה ולפענח אותו
04:33
עכשיו, האיף הזה נראה לי ממש לא ברור. ולמה הוא כזה לא ברור? קודם כל, כי יש פה בעיה. עאידה לא פירש נכון את הסיפור הזה. יש פה ככה, האיף הזה מורכב מכמה חלקים.
04:46
יש פה חלק שמאלי שמושווה ל-23, וחלק ימני שמשווה סטרינג קומפר, שני סטרינגים מושווים. כנראה שפה יושבת התשובה. כי הוא משווה פה את הסטרינג, אבל בשביל שזה יהיה, צריך שיהיה משהו 23.
05:00
עכשיו, הדבר הזה לא ברור לי בכלל. וזה למה? כי עאידה פישל. עאידה לא הבין שהמשתנה הראשון ב-GNI זה תמיד משתנה שמצביע לכתובת בזיכרון ששם יושב ה-GNI.
05:14
אז אני בא לכאן, מסמן את זה ולוחץ Y, ואומר לו, תקשיב, ה-A1 זה לא סתם מספר שאתה לא יודע מה זה, זה מצביע, כוכבית זה אומר שזה מצביע, למשהו שזה נקרא GNI Environment, למשתנה סביבה של GNI זה מצביע לשם.
05:32
למעשה שם יושבת כתובת שמצביעה על GNI. מקווה שבגרסאות הבאות הם ידעו לפענח את זה, בינתיים הם לא יודעים אז אני צריך להגיד לא ידענית, ותראו מה יקרה לשורה הזאת פה למטה.
05:44
ברגע שאני עושה את זה, הופה, פתאום היא נהיית ממש ברורה, אתם רואים? דברים פתאום נהיים ברורים.
05:51
מה אנחנו מבינים פתאום? פתאום הוא כבר מבין שזאת פונקציה, ולא איזה משהו לא ברור שהיה לפני כן, פונקציה בשם get array length. זה אומר שהוא בודק אורך של input וה input הזה צריך להיות 23, אם input הזה get array length צריך להיות 23 רק אז מתקיימת פקודת string compare אוקיי זה ה-string compare שמעניין אותי מה אני עושה קודם כל זה נהיה הרבה יותר
06:18
מובן והמטרה הסופית שלי זה להגיע ל-result שווה 1 כי זה אומר שהצלחתי ואז תצא להודעה נכונה וכדי להגיע לשם אני צריך לעבור דרך string compare הזה אוקיי אז מה אנחנו עושים קודם כל אני רוצה לסנכרן את החלון הזה של c++ עם שפת מכונה אני עושה פה רייט קליק סינכרונאיז וויד פסאודו קוד אתם רואים פה מעל כל חלון כתוב השם שלו אז יש לו פסאודו קוד a זה כאילו קוד כי הוא לא רוצה להתחייב
06:48
שזה קוד אמיתי אז הוא עושה פסאודו קוד a אוקיי יופי כשאני לוחץ על כאן הוא ישר מקפיץ אותי לסטרין קומפר הזה שימו לב עוד פעם כשאני אלחץ כאן נניח הוא יקפיץ אותי לפה הם מסונכנים עכשיו אני רוצה את הסטרין קומפר הזה נכון כי סטרין קומפר הזה משווה את הסטרינגים
07:07
ואחד מאלו זה הקוד האמיתי אחד מאלו זה מה שהיוזר הכניס השני זה מה שהוא חילץ לא יודע מאיפה הוא הביא אותו אז פה אחד זה שלי אחד זה מה שהקוד הסודי האמיתי הוא משווה ביניהם ואם הכל תקין הוא נכנס לתוך הif ואומר ריזולט אחד שזה בדיוק מה שהייתי רוצה נכון ריזולט אחד ואנחנו רואים פה שזה זז פחות או יותר לפי מה שאנחנו לוחצים לו אוקיי
07:33
בקיצור מעניין אותי הסטרינג קומפר כאן הנה זאת הפקודה של סטרינג קומפר כאן, אני לוחץ עליה אדום. אז הפסבדו קוד הזה עזר לי להבין בכלל מה קורה בתוכנית ולמצוא את הסטרינג קומפר הזה שנורא רציתי.
07:47
עזרתי לעאידה לפרש את הפונקציות וזה מתחיל להתבאר. טוב, בואו ננסה עכשיו להגיע. זאת אומרת, שמתי פה נקודת עצירה. אני מזכיר לכם, יש לי נקודת עצירה אחת פה בסטרינג קומפר הזה ואני רוצה לגלות בדיוק מה הוא משווה.
08:04
ויש לי פה למעלה, בהתחלה של כל הסיפור, נקודת עצירה בואו נראה שזה עובד לנו עושים verify הנה הגענו לשורה ראשונה ואנחנו יכולים לעשות F7 ולעבור שורה שורה ולראות שדברים בזיכרון זזים אנחנו יכולים לראות תאריכים שלהם אני עושה F7 זז תסתכלו איזה יופי אני זז כאן בתוך הקוד אני רואה גם פה שזה זז תסתכלו תסתכלו גם פה
08:29
שורות זזות זאת אומרת אני עובר פקודה פקודה בשפת מכונה וזה גם זז לי בתוך השפת C++ בשפת C אני לוחץ על F8, מי שרוצה לדעת על מה אני לוחץ, אני לוחץ על F8 כדי שלא ייכנס לי לתוך פונקציות עזר. אם אני אעשה F7, אם יש לו איזה פונקציית עזר הוא ייכנס לתוכה ויעבור לי שורה שורה,
08:50
זה לא מעניין אותי. אני רוצה שפונקציות עזר הוא יריס מהר, אז אני לוחץ לו F8. אז אני לוחץ לו כל הזמן F8. והנה הגענו למה שרציתי. שימו לב איפה אנחנו.
09:02
הגענו לאזור שלנו, הנה זה נהיה חם, חם מאוד. הנה ה-Stream Compare שלנו, אנחנו צריכים להגיע אליו ואנחנו פה בשורה הזאת. אוקיי בוא נתחיל לראות F7 מה קרה פה אין לי