ביצוע בפועל של ההתקפה - buffer overflow
בשיעור זה, שיעור השיא של סדרת גלישת החוצץ, מוצג ברמה מושגית בלבד שיא התהליך: הרצת ההתקפה שנבנתה בשיעורים הקודמים על מחשב מעבדה, אימות בדיבאגר שהמעבר אל הקוד השתול מתבצע בדיוק כמתוכנן, טיפול בבעיית הקוד שדורס את עצמו באמצעות פקודות ריקות, והרצה סופית בלי דיבאגר שמדגימה את התוצאה הסופית של החולשה.
פרקי ההרצאה: ביצוע בפועל של ההתקפה - buffer overflow
תמלול ההרצאה: ביצוע בפועל של ההתקפה - buffer overflow
הטקסט המלא של הדקות הראשונות בהרצאה «ביצוע בפועל של ההתקפה - buffer overflow» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שלום לכולם, ברוכים הבאים להרצאה שבה אנחנו נפרוץ סוף סוף לשרת בלי לדעת שם וסיסמה, דרך שירות, דרך סרוויס, דרך תוכנה שרצה אצלו ברקע שנקראת סינק ברידס. אנחנו לא יודעים שם משתמש, אנחנו לא יודעים סיסמה, אנחנו רק נתחבר לתוכנה הזאת, נשלח לה קוד זדוני ונשתלט עליה.
בואו נפעיל את זה עכשיו באימיוניטי ונראה את כל זה קורה תכלס. מפעילים אימיוניטי עם הרשאות של אדמיניסטרטור כדי שנוכל לעשות את touch להתחבר לתהליך שרץ בזיכרון לסרוויס של סינגבריץ.
אנחנו מתחברים לתוכנה קיימת, אנחנו למעשה נהיים הדבאגר של התוכנה. ומה זה אומר שאנחנו הדבאגר שלה? זה אומר אחרי כל פקודה היא חוזרת אליי. היא עושה פקודה, חוזרת אליי.
אליי זה לדבאגר. כרגע הדבאגר איך שהוא התחבר אליי הוא העביר אותה לפאוז, עצר אותה, אז היא במצב של פאוז עכשיו, ואני יכול ללחוץ play, סימן של פליי למעלה ושהיא תמשיך לרוץ בואו נדלג לכתובת הזאת של dll שקבוע בזיכרון בלי הגנת aslr ובכתובת הזאת בתוך ה dll הזה יושבת
הפקודת jump esp שתחזיר אותי חזרה לסטאק לכתובת של הסטאק אומר jump לתוך הכתובת בזיכרון שיושבת בתוך מצביע esp יש רגיסטר יש אוגר esp שמצביע לראש המחסנית ואני אומר בוא תקפוץ חזרה למעשה אני מחזיר את השליטה אליי למה לא יכולתי לעשות את זה
ישר מסיבה מאוד פשוטה שאני לא יודע באיזה כתובת יהיה ESP הזה הפקודה הזאת Jump ESP בשפת אסמבלר בשפת מכונה זה FFE4 זה למעשה תקן של x86 זה התקן של שפת מכונה x86 שאומר FFE4 המשמעות של זה Jump ל-ESP עכשיו תשאלו למה ב-EIP לא שלטלת ישירות את הג'אמפ ASP בשביל מה לך לקפוץ ל-DLL ואז לחזור חזרה
כי בתוך ה-EIP אני שותל כתובת אני לא יכול לשתול פקודה אם EIP זה לא היה כתובת אלא היה ממש פקודה לביצוע אז הייתי שותל לו ג'אמפ ASP ונגמר הסיפור הקטע ש-EIP הוא מצביע למקום שיש בו את הפקודה אני לא יכול לשתול לו את הפקודה אז אני צריך לשתול ל-EIP כתובת ששם הכתובה הפקודה שאני רוצה שיבצע ואת זה עשינו בסרטים הקודמים מצאנו תובת בזיכרון שהיא גם הפקודת Jump ASP גם נמצאת ב-DLL שהוא ללא SLR וגם
בכתובת שלו למעלה שם בצד שמאל אין סימנים אסורים הוא לא מתחיל בכתובת במספרים שאסורים לשליחה ב-HTTP אז יופי למזלנו יש DLL כזה שהוא גם בלי SLR גם בלי מספרים אסורים וגם גם יושבת בו פקודת Jump ASP וגם אין לו את ההגנה ASLR מושלם שהתוכנה הזאת משתמשת ב-DLL שיש לו את כל הדברים האלו ואז אני דורס את ה-EIP, מכניס לו את הכתובת הזאת, הוא קופץ לשמה, מבצע את הפקודה שמה,
שמה היא עושה? מקפיצה אותו חזרה אליי ל-ESP והוא מבצע את הפקודות שאני דחפתי לו בתוך ה-Stack האמת שאם האקר היה רוצה לבנות מעבד לעצמו שיהיה לו ככה חיים טובים הוא היה בתוך eip לא שם כתובת שמצביעה לפקודה הבאה לביצוע אלא שם את הפקודה עצמה אז זה היה הרבה יותר קל לא משנה אנחנו נקפוץ
לשם ונחזור חזרה עכשיו אנחנו חייבים להבין לאן בדיוק פקודת jumpasp תיקח אותנו לאן היא תקפיץ אותנו בדיוק כי אנחנו צריכים לשתול שם את השל קוד אז אני לוחץ f2 אני שם breakpoint מה זה ה-breakpoint הזה זה אומר לתוכנה תרוצי מהר מהר תבצעי את כל הפקודות אל תחזירי אליי אחרי כל פקודת ערוץ לא לעצור עד שלא מגיעים לברקפוינט איך שהגענו לברקפוינט
עוצרים ואז אני מתחיל לעשות שורה אחרי שורה כי בא לי לראות מה קורה שמה בזיכרון למעשה הדבאגר הזה ברגע שהוא מתחבר לסרוויס אחרי כל פקודה התוכנה חוזרת לתוכנת הדבאגר מחזירה אליו את השליטה והדבאגר אם הוא נמצא במצב ראנינג הוא אומר לה תמשיכי תמשיכי תמשיכי עד שמגיעים לברקפוינט אחרי הברקפוינט תעצרי ברגע שעוצרים יש לי בחירה עוד פעם לרוץ מהר
או לעבור פקודה פקודה יש לי למעשה שליטה טובה על התוכנה ועל כל פקודה לביצוע אני כמו האימא והאבא של התוכנה שאחרי כל פקודה שהיא מבצעת היא חוזרת אליי אז לחצנו F2, שמנו ברק פוינט, יש לנו פה את כל הפקודות אנחנו רוצים לראות בדיוק לאן הוא יקפוץ אחרי
ג'אמפ ESP אנחנו עכשיו עברנו למצב ראנינג עם F9 אני רק רוצה להזכיר לכם מה יש לנו בתוך הסקריפט יש לנו בתוך הסקריפט את השל קוד, את הקוד הזדוני הזה, ה-CMD הזה שיפתח לו בזיכרון, ואליו אנחנו נשלח את הפקודות שלנו מהמקלדת.
זה השל קוד שיצרנו אותו בהרצאה הקודמת. למעשה אנחנו שולחים לו את הפילר, שזה 780 פעם אות A. למה? כדי למחוק מהזיכרון את כל המשתנים שהפונקציה הזאת שתלה בזמן הביצוע שלה.
אנחנו דורסים את כל המשתנים שהיא שתלה בזיכרון, אנחנו רוצים להגיע ל-EIP. זאת אומרת, אנחנו דרסנו את זה והמשכנו לדרוס עם EIP.
למעשה, אני מראה לכם את כל מה שעשינו בהרצאות קודמות. זה 780 פעם אות A, כי זה 780 בייט של המשתנים הלוקאליים.
אחרי זה מגיע EIP, שזה הדבר הכי חשוב. זה למעשה כתובת בזיכרון שבה מגובה הערך של EIP. בדיוק לשם יוקפץ המעבד בסיום הפונקציה, ואחרי זה יש לנו את ארבע הבתים שבהם יושבים הפרמטרים שאיתם הפעלנו את הפונקציה הזאת, גם אותם צריך לנקוט בסיום ביצוע של הפונקציה, זה למעשה הקוד שעדיין אני לא שולט עליו,
ואחרי זה ה-ESP, הסטק, יצביע על מה שהיה כביכול לפני ההפעלה של הפונקציה הזאת, ושם אני שתלתי את השל-קוד.
למעשה הראש של המחסנית יצביע בדיוק על השל-קוד שלי, ובמשתנה הזה של קוד יושב כל ה-CMD הזה. זה למעשה קוד שפותח לי את ה-CMD.
אני מצפה שבסיום ביצוע של הפונקציה הוא ישלוף את ה-EIP, ישלוף את ארבע פעמים C, את הכתובות האלו בזיכרון, ויחזיר את הראש של הסטייק לכתובת של השל קוד.
ואני שותל שמה את הקוד הזדוני שלי. הוא חושב שהוא חוזר למקום הרגיל, ולמעשה בתוך הסטייק כבר אין את המידע המקורי, יש את כל המידע שדרסתי, ואני מצאתי את המקום המדויק שלשם צריך להכניס את הקוד הזדוני שלי, את השל-קוד שלי, את ה-CMD שלי.
זאת הכתובת שלשם יצביע ראש המחסנית, ה-ESP, בסיום ביצוע של הפונקציה. זה נשמע מושלם, נכון? דרך אגב, אני מזכיר לכם שהשל-קוד הזה, אנחנו יצרנו אותו על ידי קידוד מיוחד, כמו זיפ כזה, שלא יכלול את הסימנים האסורים.
זאת אומרת, לקחנו את השל קוד הרגיל ואמרנו זה לא טוב לנו של קוד רגיל כי יש שם סימנים אסורים מה זה סימנים אסורים? סימנים שאם אני משדר אותם השרת חושב שהתקשורת נפסקה, סיום התקשורת זה סימן שאומר לו הסתיימה התקשורת, הסתיים הסטרינג, הסתיים האינפוט ולא נותן לי להמשיך אז אני רוצה לדלג על סימנים אסורים אז אני עושה לו כמו זיפ כזה שיודע לפתוח את עצמו
קידוד שיודע לעשות פתיחה עצמית של עצמו לקוד המקורי של של. זה למעשה של כמו מכווץ בזיכרון, רק עם סימנים שמותר. זה מעין התחכמות כזאת, כדי לא לגרום לשרת פתאום לעצור באמצע העברת הנתונים.
אוקיי, אז יש לנו של קוד בזיפ כזה שפותח את עצמו, יש לנו אות A780 פעם, יש לנו את ה-EIP, יש לנו את ה-C4, ויש לנו את השל קוד.
זה ביחד נקרא input buffer זה למעשה מה שאני שולח לו שולח לו תמחק קודם כל את כל המשתנים הלוקאליים אחרי זה תדרוס את הגיבוי לחזרה שיש תדרוס את ארבע הכתובות שלא מעניינות אותי שזה המשתנים המקוריים שאיתם הפעילו את הפונקציה האופסט ותכניס לראש של המחסנית שיהיה בסיום הפונקציה את השל קוד למעשה את הנתונים האלו שיהיו במקום הנתונים המקוריים שהיו שהם בכלל
כבר לא מעניינים אותי אני דורס אותם זה למעשה מה שאני שולח לו שישים בתוך הסטאק במקום היוזרניים במקור מה היה צריך להיות פה באינפוט באפר הזה מה היה צריך להיות שם אתם זוכרים היה צריך להיות שם יוזרניים אנחנו קלטנו שהמתכנת לא בודק את גודל הזיכרון בגודל האינפוט ואנחנו במקום יוזרניים של 5-7-20 אותיות שלחנו לו
יוזרניים את כל הדבר הזה וחרגנו מגבולות הזיכרון שהקצינו ודרסנו את הכל בואו נראה את כל זה קורה אז יש לנו ברק פוינט בכתובת של jump.asp אני רוצה לראות לאן בדיוק ה-asp הזה יקפוץ אנחנו במצב running עם breakpoint ואנחנו נשלח את הדבר הזה ואני רוצה לראות שהוא בדיוק קופץ
למקום הנכון אז בוא נפעיל אותו עם python singbridge 0.7 py יפה הפעלנו אותו והנה הוא במצב pause למה כי הוא מחכה לפקודה שלי הוא נעצר בפקודה הזאתי זה אומר שעד עכשיו זה הכל תקין הוא ב-breakpoint הוא נעצר ואני יכול ללחוץ לו f7 לעשות step אחד צעד אחד שהקפיץ אותי ל-ESP, למעשה לבצע את
הפקודה הזאת ואני רוצה לראות לאן אני קופץ ומה יש שם בתוך הזיכרון הזה אז למעשה שלחנו לו את הקוד הזדוני, דרסנו את הכל, הוא סיים את הפונקציה וקפץ לכתובת שלנו ואנחנו עכשיו קפצנו חזרה ל-ESP, הנה ESP 744C בואו נראה מה יש לנו שם בזיכרון, Follow
the Dump ומה אני רואה בתא זיכרון 744C, איפה שמצביע ה-ESP שלנו בתחילת הסטייק מה אני רואה בדיוק את השל קוד אני רואה שם db c2 be פקודות של השל קוד שאנחנו הכנסנו זאת אומרת שהכנסנו את הפקודות בדיוק למקום הנכון בזיכרון בדיוק למקום שאליו קפץ ה-eip כפקודה הבאה לביצוע חבר'ה הצלחנו להקפיץ אותו למקום הנכון
והכל נראה מעולה עכשיו הוא יתחיל עם f7 לעשות פקודה אחר פקודה אנחנו נלחץ F7 ונעשה את הפקודה הראשונה שימו לב מה יש לנו בפקודה 744C אנחנו יכולים לראות גם בחלק העליון וגם בדאמפ של הזיכרון למטה וגם בתוך הסטייק אנחנו רואים שבכל מקום כתוב dbc2 שזה בדיוק הפקודות של השל קוד זה אומר שקפצנו בדיוק למקום שרצינו הרי זאת
הפקודה הראשונה שרצינו שהוא יבצע לפני שאני אלחץ F7 בואו נראה שיש שם באמת את ה-AAA41 הזה שדחפנו אחרי זה יש לנו את הכתובת להקפצה 83.0C.0.9.10 זוכרים? זה הגיבוי של EIP שדרסנו אחרי זה יש לנו את ה-CCC עם 43 הזה ארבע פעמים, אתם רואים 43 ואחרי 43 ארבע פעמים יש לנו DBC2 זה בדיוק תמונת הזיכרון שעשינו לו
ולאן ה-ESP מצביע אחרי כל הקפיצות לשם לפה ה-ESP מצביע בדיוק להתחלה של השואל קוד 744C זאת הכתובת של ההתחלה של השואל קוד שגם ESP מצביע לשם וגם EIP מצביע לשם זה אומר אם EIP מצביע זה אומר שזאת הפקודה שתתבצע חברים ממש ממש הצלחנו ואני לוחץ F7 לראות שהפקודות של השואל קוד באמת באמת מתבצעות הנה לחצתי F7 והנה הגענו לפקודה הבאה בכתובת 744 eip התקדם והפקודה הבאה מתבצעת
באמת זאת הפקודה שיש לנו בתוך השל קוד שלנו הפצצה שלנו מתחילה לפעול ופה אנחנו מגיעים לפקודה בעייתית שימו לב לפקודה הזאת הפקודה הזאת אומרת תשמור 28 בייט של מידע לתוך esp-c זאת אומרת תשמור את זה לתוך כתובת בזיכרון של המחסנית פחות 12. C זה 12 באקסה.
אבל הוא לא מודע לזה שהוא בעצמו עובד ב-ESP. הוא בעצמו יושב בתוך הסטאק. עכשיו, הוא לא מודע לזה כי הוא חושב שהוא יושב באזור הקוד, הרי זה פקודות רגילות.
הפקודות הרגילות האלו שומרות את המידע בתוך הסטאק. אבל מה יקרה? מה זה ה-ESP הזה? מה זה ESP מינוס C? ESP מינוס 12 זה למעשה הוא יעלה טיפה למעלה, 12 בתים למעלה, יעלה 12 כתובות למעלה אבל הוא ישמור 28 כתובות מה זה אומר שהוא ידרוס את המקום הנוכחי שלו הוא למעשה לא מודע לזה שהוא בעצמו רץ בתוך
ה-ESP הוא חושב שהוא רץ באזור הקוד ושומר מידע ב-ESP מינוס C וכשאנחנו מבצעים את הפקודה הזאת עם F7 קורה דבר מדהים הוא דורס את ה-ESP והוא דורס את עצמו הוא דורס את הקוד שכרגע רץ הוא דורס את עצמו זה כמו נחש שאוכל את עצמו נראה לי שיש נחשים כאלו ואז כל הביצוע של הקוד שלנו מתפקשש כי הוא שמר מידע בתוך בעצם אזור הפקודות שהוא
בעצמו מבצע כפי שאתם רואים מה שקורה שהוא שומר מידע בתמימות שלו בתוך ה-ESP מינוס 12 שומר שם 28 בתים ולא מודע לזה שהוא זה שגם נמצא שם בעצמו, כי זה כביכול מצב לא תקין, והוא דורס את עצמו. ושימו לב מה קורה אחרי הפקודה הזאת.
קורה שכל הפקודות פתאום בזיכרון משתנות. הדבר היחיד שנשאר, אם