Introduction to malware analysis & reverse engineering

Malware Analysis and Reverse
Engineering

‫ה‬ ‫נושאי‬ ‫להבנת‬ ‫עזר‬ ‫חומר‬ ‫להוות‬ ‫נועדה‬ ‫זו‬ ‫מצגת‬-Malware Analysis
‫וה‬-Reverse Engineering.‫לחומר‬ ‫תחליף‬ ‫מהווה‬ ‫אינו‬ ‫במצגת‬ ‫החומר‬
‫פרקים‬ ‫כראשי‬ ‫הנושאים‬ ‫לכלל‬ ‫מתייחס‬ ‫והינו‬ ‫בשיעורים‬ ‫הנלמד‬
‫כנקודות‬ ‫במצגת‬ ‫המוצג‬ ‫לחומר‬ ‫להתייחס‬ ‫ניתן‬ ‫לעיל‬ ‫מהאמור‬ ‫לגרוע‬ ‫מבלי‬
‫בתחום‬ ‫הרבים‬ ‫הנושאים‬ ‫להבנת‬ ‫מפתח‬
‫לתלמיד‬ ‫עזר‬ ‫חומר‬
Malware Analysis and Reverse
Engineering
‫הקדמה‬
© 2018 Ilan Mindel- HackerU

Backdoor
‫לתוקף‬ ‫לספק‬ ‫מטרתה‬ ‫אשר‬ ‫נוזקה‬
‫פקודות‬ ‫לשלוח‬ ‫ויכולת‬ ‫מרוחקת‬ ‫גישה‬
‫למערכת‬
Information-Stealing
‫סיסמאות‬ ‫כגון‬ ‫מידע‬ ‫אוסף‬ ‫אשר‬ ‫נוזקה‬
‫אותו‬ ‫ושולחת‬ ‫הנתקף‬ ‫של‬ ‫מהמחשב‬
‫לתוקף‬
Scareware
‫את‬ ‫להפחיד‬ ‫מנסה‬ ‫אשר‬ ‫נוזקה‬
‫מוצר‬ ‫לקנות‬ ‫לו‬ ‫ולגרום‬ ‫המשתמש‬
‫כלשהו‬
Botnet
‫ל‬ ‫הדומה‬ ‫נוזקה‬backdoor‫במקרה‬ ‫אך‬
‫את‬ ‫מקבלות‬ ‫הנגועות‬ ‫התחנות‬ ‫כל‬ ‫זה‬
‫בודד‬ ‫בקרה‬ ‫ממרכז‬ ‫פקודה‬ ‫אותה‬
Launcher
‫נוזקה‬ ‫להריץ‬ ‫מטרתה‬ ‫אשר‬ ‫נוזקה‬
‫בד‬ ‫במערכת‬ ‫אחרת‬"‫יותר‬ ‫בצורה‬ ‫כ‬
"‫שקטה‬"
Span-Sending
‫של‬ ‫המחשב‬ ‫את‬ ‫מנצלת‬ ‫זאת‬ ‫נוזקנה‬
‫ולשלוח‬ ‫ספאם‬ ‫לייצר‬ ‫מנת‬ ‫על‬ ‫הנתקף‬
‫הקורבן‬ ‫של‬ ‫בשמו‬ ‫אותו‬
Downloader
‫היא‬ ‫היחידה‬ ‫מטרתה‬ ‫אשר‬ ‫נוזקה‬
‫הנגועה‬ ‫לתחנה‬ ‫אחר‬ ‫זדוני‬ ‫קוד‬ ‫להוריד‬
Rootkit
‫של‬ ‫קיומה‬ ‫את‬ ‫מסתירה‬ ‫אשר‬ ‫נוזקה‬
‫מבלי‬ ‫לרוץ‬ ‫לה‬ ‫ומאפשרת‬ ‫אחרת‬ ‫נוזקה‬
‫להתגלות‬
Worm / Virus
‫ויכולה‬ ‫עצמה‬ ‫את‬ ‫מעתיקה‬ ‫אשר‬ ‫נוזקה‬
‫נוספות‬ ‫תחנות‬ ‫להדביק‬
‫מבוא‬
‫נוזקות‬ ‫סוגי‬

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

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

‫ההפעלה‬ ‫במערכת‬ ‫המובנה‬ ‫כלי‬windows‫אשר‬
‫חתימות‬ ‫מספר‬ ‫לייצר‬ ‫מאפשר‬hash‫הרצת‬ ‫ידי‬ ‫על‬
‫הפקודה‬:certUtil -hashfile [path] [algorithm]
‫הם‬ ‫הנתמכים‬ ‫הפורמטים‬:MD2 MD4 MD5 SHA1
SHA256 SHA384 SHA512
‫כמו‬ ‫בשירות‬ ‫אותו‬ ‫ולבדוק‬ ‫הקובץ‬ ‫של‬ ‫חתימה‬ ‫לבצע‬ ‫היא‬ ‫נוספת‬ ‫אופציה‬Virus Total‫אחד‬ ‫נתונים‬ ‫ממסד‬ ‫יותר‬ ‫מול‬ ‫החתימה‬ ‫את‬ ‫משווה‬ ‫אשר‬.
‫מהרשת‬ ‫להורדה‬ ‫הניתנים‬ ‫יעודיים‬ ‫כלים‬ ‫ידי‬ ‫על‬ ‫או‬ ‫השונות‬ ‫ההפעלה‬ ‫במערכות‬ ‫הקיימים‬ ‫כלים‬ ‫ידי‬ ‫על‬ ‫לקבצים‬ ‫שונות‬ ‫חתימות‬ ‫לבצע‬ ‫ניתן‬.
‫עצמו‬ ‫הקובץ‬ ‫את‬ ‫ולא‬ ‫הקובץ‬ ‫של‬ ‫החתימה‬ ‫את‬ ‫להעלות‬ ‫מומלץ‬,‫התגלתה‬ ‫התוכנה‬ ‫האם‬ ‫מעקב‬ ‫מבצע‬ ‫והתוקף‬ ‫למקרה‬.
certUtil
‫להראות‬ ‫גם‬ ‫יכול‬ ‫אשר‬ ‫ויזואלי‬ ‫משתמש‬ ‫ממשק‬ ‫עם‬ ‫כלי‬
‫חתימות‬hash‫זמנית‬ ‫בו‬ ‫קבצים‬ ‫למספר‬.‫ניתן‬ ‫הכלי‬
‫מ‬ ‫להורדה‬http://www.winmd5.com/‫כמובן‬ ‫אך‬
‫נוספים‬ ‫כלים‬ ‫שיש‬.
WinMD5
‫קבצים‬ ‫של‬ ‫חתימה‬

Strings‫הלינוקס‬ ‫מערכות‬ ‫ברוב‬ ‫המובנה‬ ‫כלי‬ ‫היא‬
‫ה‬ ‫בחבילת‬ ‫ווינדוס‬ ‫ובמערכות‬Sysinternals‫של‬
‫מ‬ ‫להורדה‬ ‫וניתנת‬ ‫מיקרוסופט‬‫כאן‬.‫בכלי‬ ‫השימוש‬
‫למדי‬ ‫פשוט‬ ‫והינו‬ ‫הפקודה‬ ‫שורת‬ ‫דרך‬ ‫מתבצע‬.
‫בתוכנה‬ ‫להמצא‬ ‫יכולים‬ ‫אשר‬ ‫תווים‬ ‫של‬ ‫רצף‬ ‫היא‬ ‫מילה‬,‫מריצה‬ ‫שהתוכנה‬ ‫הודעות‬ ‫להיות‬ ‫יכולות‬ ‫אלו‬ ‫מילים‬,
‫אליהם‬ ‫לגשת‬ ‫מנסה‬ ‫שהיא‬ ‫דומיינים‬,‫ליבא‬ ‫תנסה‬ ‫שהיא‬ ‫קוד‬ ‫ספריות‬ ‫או‬ ‫אליהם‬ ‫לגשת‬ ‫תנסה‬ ‫שהיא‬ ‫קבצים‬ ‫של‬ ‫שמות‬.
‫לבצע‬ ‫תנסה‬ ‫היא‬ ‫אשר‬ ‫ולדברים‬ ‫פעילותה‬ ‫לאופן‬ ‫חזק‬ ‫רמז‬ ‫להוות‬ ‫יכול‬ ‫בתוכנה‬ ‫מילים‬ ‫אחר‬ ‫חיפוש‬.
Strings
‫מסתיים‬ ‫אשר‬ ‫אותיות‬ ‫של‬ ‫רצף‬ ‫היא‬ ‫מילה‬ ‫שלנו‬ ‫במקרה‬
‫ב‬null-byte‫של‬ ‫מינמאלי‬ ‫באורך‬ ‫מיקרוסופט‬ ‫של‬ ‫ובכלי‬
3‫תווים‬.‫על‬-‫לא‬ ‫תווים‬ ‫רצפי‬ ‫גם‬ ‫יופיעו‬ ‫כלל‬ ‫בדרך‬ ‫כן‬
‫בתוצאות‬ ‫הגיוניים‬.‫תהיה‬ ‫מילה‬ ‫כל‬ ‫שלא‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫חשובה‬,‫בסיסיות‬ ‫ספריות‬ ‫של‬ ‫שמות‬ ‫להיות‬ ‫גם‬ ‫יכולים‬
‫לחלוטין‬ ‫לגיטימיות‬.
‫מילה‬ ‫בעצם‬ ‫מהיא‬?
‫מילים‬ ‫חיפוש‬

PEiD‫מ‬ ‫להורדה‬ ‫הניתנת‬ ‫תוכנה‬ ‫היא‬‫כאן‬‫יודעת‬ ‫אשר‬
‫פונקציית‬ ‫מה‬ ‫משוער‬ ‫באופן‬ ‫ולזהות‬ ‫קובץ‬ ‫לנתח‬
‫עליו‬ ‫שהופעלה‬ ‫הדחיסה‬.‫להתקל‬ ‫ניתן‬ ‫אשר‬ ‫דחיסות‬
‫הן‬ ‫בהן‬UPX‫או‬FSG,‫ש‬ ‫כיוון‬ ‫להיזהר‬ ‫יש‬PEiD
‫בטעות‬ ‫הקובץ‬ ‫את‬ ‫להריץ‬ ‫עלולה‬.
‫טובה‬ ‫יותר‬ ‫בצורה‬ ‫שלהם‬ ‫הקוד‬ ‫את‬ ‫להסתיר‬ ‫מנת‬ ‫על‬ ‫שונות‬ ‫דחיסה‬ ‫בשיטות‬ ‫להשתמש‬ ‫יכולות‬ ‫שונות‬ ‫תוכנות‬,
‫התוכנה‬ ‫את‬ ‫לנתח‬ ‫קשה‬ ‫יותר‬ ‫ויהיה‬ ‫מילים‬ ‫לזהות‬ ‫ניתן‬ ‫יהיה‬ ‫לא‬ ‫זה‬ ‫במקרה‬.
‫קוד‬ ‫קטע‬ ‫קודם‬ ‫ירוץ‬ ‫כלל‬ ‫בדרך‬ ‫דחוסות‬ ‫תוכנות‬ ‫של‬ ‫הרצה‬ ‫בעת‬
PEiD
UPX‫קלה‬ ‫ונורא‬ ‫פופולארית‬ ‫די‬ ‫דחיסה‬ ‫שיטת‬ ‫היא‬
‫לפתיחה‬(‫ל‬ ‫בניגוד‬FSG),‫הכלי‬ ‫את‬ ‫להוריד‬ ‫ניתן‬UPX
‫מ‬‫כאן‬‫הפקודה‬ ‫את‬ ‫ולהריץ‬upx –d [path]
UPX
Packing(‫דחיסה‬)

Dotfuscator‫מגיע‬ ‫אשר‬ ‫אבפוסקציה‬ ‫לכלי‬ ‫דוגמא‬ ‫הינו‬
‫מיקרוסופט‬ ‫של‬ ‫הפיתוח‬ ‫סביבת‬ ‫עם‬Visual Studio
‫קוד‬ ‫של‬ ‫אובפוסקציה‬ ‫מבצע‬ ‫אשר‬ ‫חינמי‬ ‫כלי‬ ‫והינו‬
‫ושיטות‬ ‫דרכים‬ ‫של‬ ‫שונה‬ ‫במספר‬.
‫אדם‬ ‫בני‬ ‫ידי‬ ‫על‬ ‫קריא‬ ‫יהיה‬ ‫לא‬ ‫שבו‬ ‫למצב‬ ‫מכוונת‬ ‫בצורה‬ ‫קוד‬ ‫של‬ ‫שינוי‬ ‫שמשמעותו‬ ‫תכנותי‬ ‫מושג‬ ‫הינו‬ ‫קוד‬ ‫של‬ ‫ערפול‬.
‫לרצפים‬ ‫המשתנים‬ ‫שמות‬ ‫שינוי‬ ‫כוללים‬ ‫אלו‬ ‫שינויים‬‫ראנדומאלים‬,‫שכפול‬ ‫או‬ ‫הערות‬ ‫כמו‬ ‫יראה‬ ‫לגיטימי‬ ‫שקוד‬ ‫כך‬ ‫הקוד‬ ‫שינוי‬
‫המסך‬ ‫גבי‬ ‫על‬ ‫שונות‬ ‫גאומטריות‬ ‫צורות‬ ‫שיצור‬ ‫כך‬ ‫קוד‬ ‫של‬.
Dotfuscator
‫להשתמש‬ ‫צורך‬ ‫יש‬ ‫מעורפל‬ ‫קוד‬ ‫לנתח‬ ‫מנת‬ ‫על‬
‫בסיסי‬ ‫סטטי‬ ‫ניתוח‬ ‫מאשר‬ ‫מתקדמות‬ ‫יותר‬ ‫בשיטות‬
‫מעורפל‬ ‫קוד‬
Obfuscation(‫ערפול‬)

Dependency Walker‫להורדה‬ ‫הניתנת‬ ‫תוכנה‬ ‫הינה‬
‫מ‬‫כאן‬.‫כל‬ ‫את‬ ‫לראות‬ ‫לנו‬ ‫מאפשרת‬ ‫זאת‬ ‫תוכנה‬
‫הקובץ‬ ‫הרצת‬ ‫בזמן‬ ‫מיובאות‬ ‫אשר‬ ‫הספריות‬.
•‫מס‬ ‫בחלון‬'1‫ה‬ ‫של‬ ‫השמות‬ ‫את‬ ‫לראות‬ ‫ניתן‬DLL
‫ליבא‬ ‫מנסה‬ ‫החשוד‬ ‫הקובץ‬ ‫אשר‬.
•‫מס‬ ‫בחלון‬'2‫הפונקציות‬ ‫כל‬ ‫של‬ ‫רשימה‬ ‫תופיעה‬
‫מה‬ ‫מיובאות‬ ‫אשר‬DLL‫הנבחר‬.
•‫מס‬ ‫בחלון‬'3‫הפונקציות‬ ‫כל‬ ‫של‬ ‫רשימה‬ ‫תופיע‬
‫ב‬ ‫הקימות‬DLL‫לטעון‬ ‫שניתן‬ ‫כיוון‬ ‫הסידורי‬ ‫והמספר‬
‫מס‬ ‫דרך‬ ‫גם‬ ‫פונקציה‬"‫שם‬ ‫ולא‬ ‫ד‬.
‫שלה‬ ‫המיובאות‬ ‫הפונקציות‬ ‫את‬ ‫לבחון‬ ‫היא‬ ‫עושה‬ ‫תוכנה‬ ‫מה‬ ‫להבין‬ ‫הטובות‬ ‫הדרכים‬ ‫אחת‬,‫אשר‬ ‫קוד‬ ‫קטעי‬ ‫הן‬ ‫מיובאות‬ ‫פונקציות‬
‫בספריות‬ ‫או‬ ‫אחרות‬ ‫בתוכנות‬ ‫להמצא‬ ‫יכולים‬DLL‫טוענת‬ ‫התוכנה‬ ‫אשר‬.‫לרמוז‬ ‫יכול‬ ‫המיובאות‬ ‫הפונקציות‬ ‫של‬ ‫זיהוי‬
‫להפעיל‬ ‫תנסה‬ ‫שהיא‬ ‫קוד‬ ‫או‬ ‫לבצע‬ ‫תנסה‬ ‫שהתוכנה‬ ‫פעולות‬ ‫על‬.
Dependency Walker
‫מיובאות‬ ‫פונקציות‬

‫פונקציות‬ ‫ליבא‬ ‫דרכים‬
•‫חיצוניים‬ ‫ממקורות‬ ‫פונקציות‬ ‫ליבא‬ ‫דרכים‬ ‫מספר‬ ‫קימות‬
‫סטטי‬ ‫יבוא‬
‫פונקציות‬ ‫של‬ ‫לקישור‬ ‫נפוצה‬ ‫פחות‬ ‫והכי‬ ‫נוחה‬ ‫פחות‬ ‫הכי‬ ‫הדרך‬,‫לתוך‬ ‫מעותקות‬ ‫הפונקציות‬ ‫סטטי‬ ‫קישור‬ ‫של‬ ‫במקרה‬
‫ההרצה‬ ‫קובץ‬,‫היא‬ ‫אשר‬ ‫הפונקציות‬ ‫לבין‬ ‫עצמה‬ ‫התוכנה‬ ‫של‬ ‫הקוד‬ ‫בין‬ ‫להבדיל‬ ‫קושי‬ ‫ונוצר‬ ‫גדל‬ ‫הקובץ‬ ‫מכך‬ ‫כתוצאה‬
‫מיבאת‬.
01
‫ריצה‬ ‫בזמן‬ ‫יבוא‬
‫זדוניות‬ ‫תוכנות‬ ‫של‬ ‫במקרה‬ ‫שכיח‬ ‫כן‬ ‫אך‬ ‫לגיטימיות‬ ‫תוכנות‬ ‫בקרב‬ ‫נפוץ‬ ‫אינו‬ ‫ריצה‬ ‫בזמן‬ ‫יבוא‬.‫יבוא‬ ‫מתבצע‬ ‫כאשר‬
‫ההרצה‬ ‫בתחילת‬ ‫ולא‬ ‫נדרשות‬ ‫הן‬ ‫כאשר‬ ‫ורק‬ ‫אך‬ ‫הרצויות‬ ‫הפונקציות‬ ‫את‬ ‫תייבא‬ ‫התוכנה‬ ‫ריצה‬ ‫בזמן‬.
‫דינאמי‬ ‫יבוא‬
‫נפוץ‬ ‫הכי‬ ‫היבוא‬ ‫סוג‬ ‫הוא‬ ‫דינאמי‬ ‫יבוא‬,‫את‬ ‫ההפעלה‬ ‫מערכת‬ ‫תחפש‬ ‫התוכנה‬ ‫של‬ ‫ההרצה‬ ‫תחילת‬ ‫עם‬ ‫זה‬ ‫במקרה‬
‫ה‬ ‫וספריות‬ ‫הפונקציות‬DLL‫המקושרות‬,‫שנקרא‬ ‫באזור‬ ‫ישמר‬ ‫המידע‬ ‫כלל‬header‫ההרצה‬ ‫בקובץ‬
02
03

‫עיקריות‬ ‫ספריות‬
Kernel32.dll
‫בסיסיות‬ ‫פונקציות‬ ‫שמכילה‬ ‫ספרייה‬
‫לקבצים‬ ‫וגישה‬ ‫זיכרון‬ ‫לתפעול‬
Advapi32.dll
‫בסיסיות‬ ‫פונקציות‬ ‫שמכילה‬ ‫ספרייה‬
‫שירותים‬ ‫ניהול‬ ‫כמו‬ ‫יותר‬ ‫מתקדמות‬
‫ל‬ ‫וגישה‬registry
User32.dll
‫האחראיות‬ ‫פונקציות‬ ‫שמכילה‬ ‫ספרייה‬
‫כפתורים‬ ‫כגון‬ ‫משתמש‬ ‫ממשק‬ ‫לתפעול‬
Gdi32.dll
‫על‬ ‫האחראיות‬ ‫פונקציות‬ ‫המכילה‬ ‫ספרייה‬
‫וגרפיקה‬ ‫תצוגה‬
Ntdll.32
‫ל‬ ‫חלון‬ ‫המהווה‬ ‫ספרייה‬kernel‫של‬
‫ההפעלה‬ ‫מערכת‬,‫ספרייה‬ ‫כלל‬ ‫בדרך‬
‫ישיר‬ ‫באופן‬ ‫מיובאת‬ ‫לא‬ ‫זאת‬
WSock32.dll
‫אשר‬ ‫פונקציות‬ ‫המכילה‬ ‫ספרייה‬
‫לייצר‬ ‫תפקידן‬,‫מידע‬ ‫ולקבל‬ ‫לשלוח‬
‫הרשת‬ ‫גבי‬ ‫על‬ ‫מועבר‬ ‫אשר‬
Ws2_32.dll
‫תפקידן‬ ‫אשר‬ ‫פונקציות‬ ‫המכילה‬ ‫ספרייה‬
‫לייצר‬,‫מועבר‬ ‫אשר‬ ‫מידע‬ ‫ולקבל‬ ‫לשלוח‬
‫הרשת‬ ‫גבי‬ ‫על‬
Wininet.dll
‫ממשות‬ ‫אשר‬ ‫פונקציות‬ ‫המכילה‬ ‫ספרייה‬
‫כגון‬ ‫פרוטוקולים‬HTP‫ו‬FTP

‫קובץ‬ ‫של‬ ‫מבנה‬PE
•‫של‬ ‫מבנה‬PE(portable executable)‫קבצי‬ ‫לרוב‬ ‫המשותף‬ ‫מבנה‬ ‫הוא‬
‫עיקריים‬ ‫חלקים‬ ‫מספר‬ ‫ומכיל‬ ‫ההרצה‬
.rsrc
‫אייקונים‬ ‫או‬ ‫תמונות‬ ‫כגון‬ ‫מהתוכנה‬ ‫חלק‬ ‫מוגדרים‬ ‫לא‬ ‫אשר‬ ‫משאבים‬ ‫ישמרו‬ ‫זה‬ ‫באזור‬
01
02
03
.rdata
‫המוגדר‬ ‫מידע‬ ‫יופיע‬ ‫זה‬ ‫באזור‬"‫בלבד‬ ‫לקריאה‬"‫והמיוצאות‬ ‫המיובאות‬ ‫הפונקציות‬ ‫של‬ ‫רשימה‬ ‫כגון‬(‫של‬ ‫במקרה‬DLL)
.data
‫התוכנה‬ ‫של‬ ‫אזור‬ ‫בכל‬ ‫הזמין‬ ‫גלובאלי‬ ‫מידע‬ ‫ישמר‬ ‫זה‬ ‫באזור‬
.text
‫להרצה‬ ‫המעבד‬ ‫של‬ ‫הפקודות‬ ‫נמצאות‬ ‫בו‬ ‫האזור‬ ‫זהו‬,‫בלבד‬ ‫מידע‬ ‫יכילו‬ ‫האזורים‬ ‫שאר‬.
04

Peview‫מ‬ ‫להורדה‬ ‫הניתנת‬ ‫תוכנה‬ ‫הינה‬‫כאן‬.‫תוכנה‬
‫הרצה‬ ‫בקובץ‬ ‫המוגדרים‬ ‫האזורים‬ ‫כל‬ ‫את‬ ‫מציגה‬ ‫זאת‬,
‫כגון‬ ‫נוסף‬ ‫שימושי‬ ‫מידע‬ ‫לראות‬ ‫ניתן‬ ‫בנוסף‬:
•‫בקובץ‬ ‫הקוד‬ ‫גודל‬
•‫יבקש‬ ‫הוא‬ ‫אותו‬ ‫בזיכרון‬ ‫המקום‬ ‫גודל‬
•‫הקובץ‬ ‫יצור‬ ‫תאריך‬
•‫מיובאות‬ ‫פונקציות‬
•‫מיוצאות‬ ‫פונקציות‬
•‫ה‬ ‫גדלי‬Stack‫וה‬heap
‫ב‬ ‫להשתמש‬ ‫תוכנה‬ ‫עשוייה‬ ‫מסויימים‬ ‫במקרים‬DLL‫ניתוח‬ ‫בעת‬ ‫מסויימת‬ ‫פעולה‬ ‫לבצעה‬ ‫מנת‬ ‫על‬ ‫חיצוני‬DLL.
‫שה‬ ‫כיוון‬ ‫המיובאות‬ ‫הפונקציות‬ ‫את‬ ‫לבדוק‬ ‫אותנו‬ ‫יעניין‬ ‫לא‬DLL‫פונקציות‬ ‫איזה‬ ‫לראות‬ ‫כי‬ ‫אם‬ ‫עצמו‬ ‫בפני‬ ‫להרצה‬ ‫ניתן‬ ‫לא‬
‫שימושי‬ ‫להיות‬ ‫כן‬ ‫יכול‬ ‫מיצא‬ ‫הוא‬
PEview
‫מיוצאות‬ ‫פונקציות‬

Resource Hacker‫להורדה‬ ‫הניתנת‬ ‫תוכנה‬ ‫הינה‬
‫מ‬‫כאן‬.‫איקונים‬ ‫רק‬ ‫זה‬ ‫באזור‬ ‫נראה‬ ‫הסטנדרטי‬ ‫במקרה‬
‫מכילה‬ ‫אכן‬ ‫והתוכנה‬ ‫במידה‬ ‫אך‬ ‫חשוב‬ ‫לא‬ ‫ומידע‬
‫ולראות‬ ‫אותם‬ ‫לפתוח‬ ‫ניתן‬ ‫יהיה‬ ‫מוטמעים‬ ‫קבצים‬
‫בתצוגת‬Hex‫מס‬ ‫בחלון‬'2.
‫תנסה‬ ‫היא‬ ‫אותם‬ ‫קבצים‬ ‫המשאבים‬ ‫באזור‬ ‫להכיל‬ ‫יכולה‬ ‫תוכנה‬ ‫ולתמונות‬ ‫לאייקונים‬ ‫בנוסף‬
‫בהם‬ ‫ולהשתמש‬ ‫הריצה‬ ‫בזמן‬ ‫לפרוק‬
Resource Hacker
‫משאבים‬

PEBrowse Professional‫אשר‬ ‫מורכבת‬ ‫תוכנה‬ ‫הינו‬
‫בינהם‬ ‫ואפרויות‬ ‫כלים‬ ‫מספר‬ ‫בתוכה‬ ‫מכילה‬:
•‫אזורי‬ ‫זיהוי‬PE
•‫מילים‬ ‫זיהוי‬
•‫ואפילו‬debugger
‫אדם‬ ‫בני‬ ‫ידי‬ ‫על‬ ‫קריא‬ ‫יהיה‬ ‫לא‬ ‫שבוא‬ ‫למצב‬ ‫מכוונת‬ ‫בצורה‬ ‫קוד‬ ‫של‬ ‫שינוי‬ ‫שמשמעותו‬ ‫תכנותי‬ ‫מושג‬ ‫הינו‬ ‫קוד‬ ‫של‬ ‫ערפול‬
‫שכפול‬ ‫או‬ ‫הערות‬ ‫כמו‬ ‫יראה‬ ‫לגיטימי‬ ‫שקוד‬ ‫כך‬ ‫הקוד‬ ‫שינוי‬ ‫ראנדומאלים‬ ‫לרצפים‬ ‫משתנים‬ ‫שמות‬ ‫השינוי‬ ‫כוללים‬ ‫אלו‬ ‫שינויים‬
‫המסך‬ ‫גבי‬ ‫על‬ ‫שונות‬ ‫גאומטריות‬ ‫צורות‬ ‫שיצור‬ ‫כך‬ ‫קוד‬ ‫של‬.
PEBrowse Professional
PE Explorer‫נוספת‬ ‫תוכנה‬ ‫הינה‬(‫בתשלום‬)‫אשר‬
‫קבצים‬ ‫של‬ ‫סטטי‬ ‫לניתוח‬ ‫כלים‬ ‫של‬ ‫רחב‬ ‫סט‬ ‫מכילה‬
PE Explorer
‫נוספות‬ ‫תוכנות‬

‫על‬‫מנת‬‫כן‬‫לנסות‬‫לדמות‬
‫חיבור‬‫לשרת‬‫אינטרנט‬‫כלשהו‬
‫נרצה‬‫להרים‬‫מכונה‬‫וירטואלית‬
‫נוספת‬‫אשר‬‫תהווה‬‫שרת‬
‫פיקטיבי‬‫לתעבורת‬‫רשת‬.‫ניתן‬
‫להריץ‬‫מכונה‬‫ווירטואלית‬‫מסוג‬
windows‫אך‬‫לצורך‬‫זה‬‫עדיף‬
linux‫עקב‬‫זמינות‬‫של‬‫כלים‬
‫שונים‬‫כגון‬nc
‫מכונת‬"‫שרת‬"
‫אומנם‬‫לא‬‫מעט‬‫תוכנות‬
‫מסתמכות‬‫על‬‫רשת‬‫האינטרנט‬
‫בשביל‬‫לבצע‬‫פעולה‬‫זו‬‫או‬
‫אחרת‬,‫הסיכון‬‫שהן‬‫יתפשטו‬
‫ברשת‬‫מצריך‬‫מאיתנו‬‫לנתק‬‫את‬
‫המכונה‬‫מכל‬‫רשת‬‫שהיא‬.‫ישנן‬
‫דרכים‬‫אחרות‬‫שניתן‬‫ל‬"‫עבוד‬"
‫בהן‬‫על‬‫התוכנה‬‫ולגרום‬‫לה‬
‫לחשוב‬‫שאכן‬‫קיים‬‫חיבור‬‫זמין‬.
‫כן‬‫רצוי‬‫ליצור‬‫רשת‬‫פנימית‬‫בין‬
‫כמה‬‫מכונות‬‫וירטואליות‬
‫כיוון‬‫שניתוח‬‫דינאמי‬‫כרוך‬
‫בהרצה‬‫של‬‫תוכנה‬‫על‬‫גבי‬
‫המחשב‬,‫לא‬‫נרצה‬‫לעשות‬
‫זאת‬‫על‬‫המחשב‬‫שלנו‬.‫נרצה‬
‫לעשות‬‫זאת‬‫בסביבה‬‫מבוקרת‬.
‫לצרוך‬‫זאת‬‫באפשרותנו‬‫להרים‬
‫מכונה‬‫ווירטואלית‬‫להתקין‬‫בה‬
‫את‬‫כל‬‫הכלים‬‫הנדרשים‬.
‫מהרשת‬ ‫ניתוק‬ ‫תחנה‬"‫נפגעת‬"
‫דינאמי‬ ‫לניתוח‬ ‫הכנות‬
‫אחד‬‫הדברים‬‫החשובים‬‫ביותר‬
‫בעת‬‫ניתוח‬‫דינאמי‬‫במכונה‬
‫ווירטואלית‬‫הוא‬‫תיעוד‬‫של‬
‫מצבי‬‫המכונה‬,‫על‬‫ידי‬‫שימוש‬‫ב‬
snapshots‫שיאפשרו‬‫לנו‬
‫לחזור‬‫למצב‬‫קודם‬‫במקרה‬
‫ומשהו‬‫משתבש‬‫בזמן‬‫ריצה‬.
‫כלי‬‫נוסף‬‫היכול‬‫להיות‬‫שימושי‬
‫הוא‬‫ה‬record/replay‫של‬
vmware‫אשר‬‫מתעד‬‫כל‬
‫פעולה‬‫שבוצע‬‫במכונה‬
‫ומאפשר‬"‫צפייה‬‫חוזרת‬"‫בשלב‬
‫מאוחר‬‫יותר‬
‫ושמירה‬ ‫תיעוד‬
‫בסיסי‬ ‫דינאמי‬ ‫ניתוח‬

‫ווירטואלית‬ ‫רשת‬ ‫מבנה‬
Analysis
Virtual
Machine
Services
Virtual
Machine
Virtual
Network
Host
Physical Machine
External
Network

Cuckoo Sandbox‫חזקה‬ ‫פתוח‬ ‫קוד‬ ‫תוכנת‬ ‫הינה‬
‫ניתוח‬ ‫כגון‬ ‫שירותים‬ ‫של‬ ‫רחב‬ ‫מבחר‬ ‫המאפשרת‬ ‫מאוד‬
‫זיכרון‬,‫פונקציות‬ ‫יבוא‬ ‫אחרי‬ ‫מעקב‬,‫אחרי‬ ‫מעקב‬
‫תקשורת‬(‫מוצפנת‬ ‫גם‬)‫במספר‬ ‫דוחות‬ ‫יצירת‬ ‫כן‬ ‫וכמו‬
‫פורמטים‬.
‫הפרוייקט‬ ‫בדף‬ ‫לצפות‬ ‫ניתן‬‫כאן‬
Sandboxes‫בדר‬ ‫ממומשים‬ ‫אשר‬ ‫שירותים‬ ‫הם‬"‫גדולות‬ ‫חברות‬ ‫ידי‬ ‫על‬ ‫כ‬.‫הפרטי‬ ‫לשימוש‬ ‫זה‬ ‫מסוג‬ ‫כלים‬ ‫גם‬ ‫ישנם‬ ‫אמנם‬.
Sandboxes‫מסוג‬ ‫כלים‬ ‫הם‬All-in-one‫רשת‬ ‫שירותי‬ ‫לספק‬ ‫יכולה‬ ‫אשר‬ ‫ווירטואלית‬ ‫בסביבה‬ ‫אמינה‬ ‫לא‬ ‫תוכנה‬ ‫להריץ‬ ‫היא‬ ‫מטרתם‬ ‫אשר‬‫פיקטיבים‬.
‫שנוצרו‬ ‫קבצים‬ ‫של‬ ‫מפורט‬ ‫דוח‬ ‫ההרצה‬ ‫בסוף‬ ‫יפיקו‬ ‫גם‬ ‫זה‬ ‫מסוג‬ ‫התוכנות‬ ‫רוב‬,‫ועוד‬ ‫ששונו‬ ‫ערכים‬...
Cuckoo Sandbox
‫ווירטואלית‬ ‫בסביבה‬ ‫מתוחכמת‬ ‫תוכנה‬ ‫של‬ ‫הרצה‬ ‫בעת‬
‫בתוכנה‬ ‫להטמיע‬ ‫יכל‬ ‫שהמתכנת‬ ‫בחשבון‬ ‫לקחת‬ ‫יש‬
‫ווירטואלית‬ ‫סביבה‬ ‫לזיהוי‬ ‫פונקציות‬.‫אם‬ ‫זה‬ ‫במקרה‬
‫אופן‬ ‫את‬ ‫תשנה‬ ‫היא‬ ‫ווירטואלית‬ ‫סביבה‬ ‫מזהה‬ ‫התוכנה‬
‫פעילותה‬.
‫ווירטואלית‬ ‫בסביבה‬ ‫הרצה‬
Sandboxes

Rundll32‫ב‬ ‫המובנת‬ ‫פונקציה‬ ‫הינה‬windows
‫מתוך‬ ‫פונקציות‬ ‫של‬ ‫הרצה‬ ‫המאפשרת‬DLL‫ידי‬ ‫על‬
‫הבאה‬ ‫בפקודה‬ ‫שימוש‬:
rundll32 [dll], [function] [parameters]
‫הם‬ ‫ננתח‬ ‫שאנחנו‬ ‫שקבצים‬ ‫מקרים‬ ‫ישנם‬ ‫להרצה‬ ‫קשות‬ ‫אינן‬ ‫התוכנות‬ ‫שרוב‬ ‫בעוד‬DLL‫ידני‬ ‫באופן‬ ‫אותם‬ ‫להפעיל‬ ‫נצטרך‬ ‫זה‬ ‫ובמקרה‬
rundll32
‫וה‬ ‫במידה‬DLL‫כלשהו‬ ‫שירות‬ ‫להתקנת‬ ‫אחראי‬,‫על‬
‫בפקודה‬ ‫להשתמש‬ ‫נרצה‬ ‫אותו‬ ‫להריץ‬ ‫מנת‬
net start [service]
Net start
‫תוכנה‬ ‫של‬ ‫הרצה‬

‫ב‬ ‫הפילטור‬ ‫תפריט‬procmon‫של‬ ‫רב‬ ‫מספר‬ ‫מאפשר‬
‫פילטור‬ ‫אופציות‬,‫קריאות‬ ‫של‬ ‫סוגים‬ ‫אחרי‬ ‫מעקב‬ ‫בינהן‬
(CreateFile,RegSetValue)‫תנאים‬ ‫של‬ ‫ויצירה‬
‫התפריט‬ ‫דרך‬ ‫אישית‬ ‫מותאמים‬.
‫הפילטרים‬ ‫בסרגל‬ ‫אוטומטים‬ ‫פילטרים‬ ‫מספר‬ ‫גם‬ ‫ישנם‬
‫על‬ ‫סינונים‬ ‫מאפשרים‬ ‫אשר‬-‫רשומה‬ ‫סוג‬ ‫פי‬:‫תהליכים‬,
‫קבצים‬,‫ברשת‬ ‫תקשורת‬
Process Motinor‫ב‬ ‫הנמצא‬ ‫נוסף‬ ‫כלי‬ ‫הינו‬Sysinternals‫מיקרוסופט‬ ‫של‬.‫אשר‬ ‫המערכת‬ ‫קריאות‬ ‫כל‬ ‫של‬ ‫תפיסה‬ ‫מאפשר‬ ‫זה‬ ‫כלי‬
‫במחשב‬ ‫מתבצעות‬,‫כ‬ ‫להיות‬ ‫יכולות‬ ‫כי‬ ‫לב‬ ‫לשים‬ ‫יש‬50,000‫המערכת‬ ‫של‬ ‫לגיטימיות‬ ‫קריאות‬ ‫רובן‬ ‫בדקה‬ ‫קריאות‬,procmon‫המידע‬ ‫כל‬ ‫את‬ ‫שומר‬
‫הקיימות‬ ‫הפילטור‬ ‫באופציות‬ ‫ולהשתמש‬ ‫מוגבלים‬ ‫זמן‬ ‫לפרקי‬ ‫רק‬ ‫אותו‬ ‫להריץ‬ ‫עדיף‬ ‫ולכן‬ ‫בראם‬
Filter
‫ל‬ ‫שיש‬ ‫נוספת‬ ‫פונקציה‬Procmon‫האפשרות‬ ‫היא‬
‫מערכת‬ ‫עם‬ ‫שעולה‬ ‫כדרייבר‬ ‫עצמו‬ ‫את‬ ‫להתקין‬
‫בזמן‬ ‫שמופעלים‬ ‫תהליכים‬ ‫גם‬ ‫לתפוס‬ ‫ובכך‬ ‫ההפעלה‬
‫ריצה‬
Boot
Procmon

‫שונים‬ ‫תהליכים‬ ‫על‬ ‫מידע‬ ‫להצגת‬ ‫האופציות‬ ‫מלבד‬
‫מערכת‬ ‫קבצי‬ ‫של‬ ‫חתימות‬ ‫לוודא‬ ‫האופציה‬ ‫גם‬ ‫קיימת‬
‫על‬ ‫ימנית‬ ‫על‬ ‫לחיצה‬ ‫ידי‬ ‫על‬ ‫למיקרוסופט‬ ‫השייכים‬
‫ו‬ ‫תהליך‬properties > verify
Proccess Explorer‫ב‬ ‫הנמצא‬ ‫נוסף‬ ‫שימושי‬ ‫כלי‬ ‫הינו‬Sysinternals‫מיקרוסופט‬ ‫של‬.‫הרצים‬ ‫התהליכים‬ ‫כל‬ ‫על‬ ‫מידע‬ ‫להציג‬ ‫היא‬ ‫מטרתו‬
‫המחשב‬ ‫על‬ ‫אמת‬ ‫בזמן‬,‫תהליכים‬ ‫פירוטי‬ ‫לראות‬ ‫בשביל‬ ‫בו‬ ‫להשתמש‬ ‫ניתן‬,‫אב‬ ‫וקישורי‬ ‫רצות‬ ‫תוכנות‬ ‫על‬ ‫מידע‬-‫שונים‬ ‫תהליכים‬ ‫בין‬ ‫בן‬
Verify
‫ב‬Process Explorer‫שימושיות‬ ‫אופציות‬ ‫קיימות‬
‫הריצה‬ ‫בזמן‬ ‫מחרוזות‬ ‫בין‬ ‫להשוות‬ ‫המאפשרות‬ ‫נוספות‬
‫ריצה‬ ‫לפני‬ ‫המצב‬ ‫לבין‬ ‫התוכנה‬ ‫של‬.
‫ב‬ ‫להשתמש‬ ‫ניתן‬ ‫כן‬ ‫כמו‬Process Explorer‫כדי‬
‫נגועים‬ ‫מסמכים‬ ‫לזהות‬-‫תהליך‬ ‫יוצר‬ ‫כלשהו‬ ‫מסמך‬ ‫אם‬
‫הרצה‬ ‫בזמן‬,‫זדוני‬ ‫קוד‬ ‫מכיל‬ ‫שהוא‬ ‫כנראה‬.
‫נוספות‬ ‫פונקציות‬
Process Explorer

Regshot‫מ‬ ‫להורדה‬ ‫הניתן‬ ‫פשוט‬ ‫כלי‬ ‫הינו‬‫כאן‬,‫הוא‬
‫ה‬ ‫של‬ ‫תיעוד‬ ‫מאפשר‬registry‫של‬ ‫הרצה‬ ‫ואחרי‬ ‫לפני‬
‫השינויים‬ ‫כל‬ ‫את‬ ‫המפרט‬ ‫קובץ‬ ‫יצא‬ ‫מכן‬ ‫ולאחר‬ ‫תוכנה‬
‫קיימות‬ ‫הגדרות‬ ‫ושינוי‬ ‫הגדרות‬ ‫יצירת‬ ‫כולל‬ ‫שבוצעו‬
‫ב‬ ‫מבצעת‬ ‫היא‬ ‫שינויים‬ ‫אילו‬ ‫זה‬ ‫תוכנה‬ ‫של‬ ‫ניתוח‬ ‫בעת‬ ‫אליהם‬ ‫לב‬ ‫לשים‬ ‫שכדאי‬ ‫הדברים‬ ‫אחד‬Regisrty,
‫ה‬Regisrty‫במערכת‬ ‫יותר‬ ‫טובה‬ ‫אחיזה‬ ‫לקבל‬ ‫ידי‬ ‫על‬ ‫שינויים‬ ‫בו‬ ‫יבצעו‬ ‫תוכנות‬ ‫והרבה‬ ‫ההפעלה‬ ‫מערכת‬ ‫של‬ ‫ההגדרות‬ ‫כל‬ ‫את‬ ‫מכיל‬
‫כלשהן‬ ‫פעולות‬ ‫ביצוע‬ ‫לצורך‬ ‫הגדרות‬ ‫לזייף‬ ‫מנת‬ ‫על‬ ‫או‬
Regshot
Regshot

ApateDNS‫להורדה‬ ‫הניתנת‬ ‫חינמית‬ ‫תוכנה‬ ‫הינה‬
‫מ‬‫כאן‬.‫לפורט‬ ‫האזנה‬ ‫מבצעת‬ ‫זו‬ ‫תוכנה‬53‫באופן‬
‫המתקבלות‬ ‫לכתובות‬ ‫הבקשות‬ ‫כל‬ ‫את‬ ‫ומנווטת‬ ‫לוקאלי‬
‫מהמשתמש‬,‫של‬ ‫בקשה‬ ‫כל‬ ‫לנווט‬ ‫בקלות‬ ‫ניתן‬ ‫כך‬
‫לכתובת‬ ‫לפנות‬ ‫התוכנה‬dns‫פקטיבי‬ ‫לשרת‬ ‫כלשהיא‬
‫אחר‬ ‫פיתרון‬ ‫למצוא‬ ‫נצטרך‬ ‫לאינטרנט‬ ‫חיבור‬ ‫ללא‬ ‫מאובטחת‬ ‫עבודה‬ ‫סביבת‬ ‫על‬ ‫לשמור‬ ‫נרצה‬ ‫מסויימת‬ ‫תוכנה‬ ‫של‬ ‫ניתוח‬ ‫שבעת‬ ‫כיוון‬
‫גישה‬ ‫לה‬ ‫יש‬ ‫שאכן‬ ‫לחשוב‬ ‫לתוכנה‬ ‫לגרום‬ ‫מנת‬ ‫על‬,‫לבצע‬ ‫נוכל‬ ‫אנחנו‬ ‫צריכה‬ ‫שהיא‬ ‫המשאבים‬ ‫את‬ ‫להשיג‬ ‫תוכל‬ ‫באמת‬ ‫היא‬ ‫אם‬ ‫אפילו‬
‫פיקטיבית‬ ‫בצורה‬ ‫אותן‬ ‫לספק‬ ‫אף‬ ‫הצורך‬ ‫ובמידת‬ ‫שולחת‬ ‫שהיא‬ ‫הבקשות‬ ‫אחרי‬ ‫מעקב‬
ApateDNS
‫רשת‬ ‫זיוף‬
INetSim‫אשר‬ ‫לינוקס‬ ‫למערכות‬ ‫המיודעת‬ ‫תוכנה‬ ‫היא‬
‫שירותים‬ ‫של‬ ‫רב‬ ‫מספר‬ ‫של‬ ‫אימולציה‬ ‫מאפשרת‬
‫פיקטיבים‬.‫לרישום‬ ‫אפשרויות‬ ‫הכלי‬ ‫מספק‬ ‫בנוסף‬
‫תשובות‬ ‫ומתן‬ ‫התעבורה‬"‫לגיטימיות‬"‫אשר‬ ‫לבקשות‬
‫מקבל‬ ‫הוא‬
INetSim

‫רשת‬ ‫לסריקת‬ ‫פופולארים‬ ‫הכי‬ ‫הכלים‬ ‫אחד‬,‫גם‬ ‫הקיים‬
‫לינוקס‬ ‫וגם‬ ‫ווינדוס‬ ‫למערכות‬,‫הכלי‬ ‫את‬ ‫להפעיל‬ ‫נרצה‬
‫את‬ ‫ולהפסיק‬ ‫חוקרים‬ ‫אנו‬ ‫אותה‬ ‫התוכנה‬ ‫הרצת‬ ‫טרם‬
‫ההרצה‬ ‫בתום‬ ‫מיד‬ ‫הסריקה‬.‫את‬ ‫לנתח‬ ‫ניתן‬ ‫מכן‬ ‫לאר‬
‫מסודרת‬ ‫בצורה‬ ‫התוצאות‬
‫פיקטיבית‬ ‫רשת‬ ‫להרים‬ ‫רק‬ ‫מספיק‬ ‫שלא‬ ‫כמובן‬,‫מ‬ ‫לקבל‬ ‫ניתן‬ ‫אשר‬ ‫ללוגים‬ ‫מעבר‬ ‫אותה‬ ‫לתעד‬ ‫לנסות‬ ‫גם‬ ‫חובה‬INetSim
‫מפורט‬ ‫שיותר‬ ‫וכמה‬,‫טוב‬ ‫יותר‬.
WireShark
‫הרשת‬ ‫תידוע‬
NC‫וניתן‬ ‫בלינוקס‬ ‫מובנה‬ ‫הקיים‬ ‫נוסף‬ ‫כלי‬ ‫הינו‬
‫אופציות‬ ‫מאפשר‬ ‫אשר‬ ‫ווינדוס‬ ‫למערכות‬ ‫להורדה‬
‫רשת‬ ‫לתעבורת‬ ‫הקשורות‬ ‫מרובות‬,‫לא‬ ‫הכלי‬ ‫אמנם‬
‫ביותר‬ ‫שימושי‬ ‫להיות‬ ‫יכול‬ ‫הוא‬ ‫אך‬ ‫רחב‬ ‫לתיעוד‬ ‫נועד‬
‫אמת‬ ‫בזמן‬ ‫תעבורה‬ ‫לבדיקת‬.
NC

‫סטטי‬ ‫לניתוח‬ ‫מבוא‬
‫מתקדם‬
•‫המעבד‬ ‫עובד‬ ‫כיצד‬
•‫הזיכרון‬ ‫עובד‬ ‫כיצד‬
•‫במחשב‬ ‫פונקציות‬ ‫ממומשות‬ ‫איך‬
•‫הנמוכות‬ ‫בשכבות‬ ‫ההפעלה‬ ‫מערכת‬ ‫עובדת‬ ‫איך‬
•‫ועוד‬...‫חזק‬ ‫תחזיקו‬ ‫אז‬
‫מתקדם‬ ‫סטטי‬ ‫ניתוח‬ ‫על‬ ‫לעבוד‬ ‫להתחיל‬ ‫שניתן‬ ‫לפני‬,
reversing‫ו‬disassembly‫מספר‬ ‫להבין‬ ‫צריך‬ ‫תחילה‬
‫דברים‬:

‫לחקור‬ ‫שננסה‬ ‫התוכנה‬ ‫נכתבה‬ ‫כנראה‬ ‫שבה‬ ‫השפה‬.
‫ומובנות‬ ‫נוחות‬ ‫פונקציות‬ ‫עם‬ ‫שפה‬ ‫הינה‬ ‫עילית‬ ‫שפה‬
‫במערכת‬ ‫קורה‬ ‫מה‬ ‫מדי‬ ‫יותר‬ ‫מפרטות‬ ‫לא‬ ‫כלל‬ ‫שבדרך‬
‫עצמה‬
‫הקוד‬ ‫את‬ ‫לנתח‬ ‫ניתן‬ ‫שבהן‬ ‫רמות‬ ‫מספר‬ ‫שיש‬ ‫להבין‬ ‫צריכים‬ ‫אנחנו‬ ‫כלשהו‬ ‫קוד‬ ‫מנתחים‬ ‫אנחנו‬ ‫כאשר‬,
‫אחרת‬ ‫בדרך‬ ‫אותו‬ ‫להוציא‬ ‫לנסות‬ ‫נצטרך‬ ‫לנו‬ ‫זמין‬ ‫יהיה‬ ‫לא‬ ‫כלל‬ ‫בדרך‬ ‫המקור‬ ‫שקוד‬ ‫כיוון‬,‫להוציא‬ ‫לנסות‬ ‫בזמן‬ ‫בו‬ ‫אך‬
‫לחקירה‬ ‫וניתן‬ ‫מסויימת‬ ‫במידה‬ ‫קריא‬ ‫שיהיה‬ ‫משהו‬.
‫עילית‬ ‫שפה‬
‫בהן‬ ‫לרוץ‬ ‫יכול‬ ‫שהקוד‬ ‫נמוכות‬ ‫הכי‬ ‫מהרמות‬ ‫אחת‬.
‫ערכים‬ ‫יהיו‬ ‫הפקודות‬ ‫מכונה‬ ‫בשפת‬‫הקסהדצימאלים‬
‫אדם‬ ‫לבני‬ ‫רגיל‬ ‫באופן‬ ‫קריאים‬ ‫ולא‬ ‫למעבד‬ ‫מובנים‬ ‫אשר‬
‫מכונה‬ ‫שפת‬
‫לאסמבלי‬ ‫מבוא‬
‫לבני‬ ‫קריאה‬ ‫שכן‬ ‫מכונה‬ ‫לשפת‬ ‫קרובה‬ ‫הכי‬ ‫הרמה‬
‫אדם‬,‫אסמבלי‬‫במחשב‬ ‫המתרחש‬ ‫של‬ ‫הבנה‬ ‫תספק‬
‫מעבד‬ ‫לפקודות‬ ‫הדומה‬ ‫בכתיבה‬ ‫הנמוכות‬ ‫ברמות‬
‫אסמבלי‬ ‫שפת‬
•Int a;
printf(“hello”);
Return 0;
HL
•55
8B EC
8B EC 40
MC •push ebp
move ebs esp
sub esp 0x40
AS

‫אסמבלי‬‫מאפשרת‬‫לנו‬‫לראות‬
‫בצורה‬‫ברורה‬‫את‬‫הפקודות‬
‫שהמעבד‬‫אמור‬‫לבצע‬,‫אלוקציה‬
‫של‬‫זיכרון‬,‫קריאות‬‫של‬‫פונקציות‬
‫וטעינות‬‫של‬‫ספריות‬,‫דבר‬‫זה‬
‫מאפשר‬‫לנו‬‫לרדת‬‫לפרטי‬‫פרטים‬
‫בניתוח‬‫ולהבין‬‫איזה‬‫דברים‬‫קורים‬
‫במחשב‬‫בעת‬‫הרצת‬‫קובץ‬‫ברמות‬
‫הכי‬‫נמוכות‬‫שיש‬.
‫מורכבות‬ ‫ניתוח‬ ‫יכולות‬
‫אסמבלי‬‫היא‬‫בעצם‬‫משפחה‬‫של‬
‫שפות‬‫תכנות‬"‫נמוכות‬"‫כאשר‬‫כל‬
‫דיאלקט‬‫מכוון‬‫לעבוד‬‫עם‬‫משפחה‬
‫שונה‬‫של‬‫מעבדים‬.‫רוב‬‫מחשבי‬32
‫ביט‬‫הם‬‫ממשפחת‬x86‫אך‬‫גם‬
‫מחשבים‬‫חדשים‬‫יותר‬‫עם‬‫מערכות‬
64‫ביט‬‫מגיעים‬‫עם‬‫תאימות‬
‫למשפחת‬‫ה‬x86,‫מסיבה‬‫זאת‬
‫מספר‬‫רב‬‫של‬‫תוכנות‬‫נכתבות‬
‫למערכות‬32‫ביט‬‫לצורכי‬‫תאימות‬
‫בדרך‬‫כלל‬‫לאחר‬‫שתוכנה‬‫נכתבה‬
‫וקומפלה‬‫למצב‬‫אשר‬‫בו‬‫היא‬‫ניתנת‬
‫להרצה‬‫היא‬‫תשמר‬‫על‬‫המחשב‬
‫בצורה‬‫בינארית‬.‫כיוון‬‫שבמצב‬‫זה‬
‫היא‬‫לא‬‫ניתנת‬‫לקריאה‬‫נצטרך‬‫לנתח‬
‫אותה‬‫ולפרק‬‫אותה‬‫לקוד‬‫קריא‬,‫היות‬
‫ובני‬‫אדם‬‫לא‬‫מבינים‬‫שפת‬‫מחשב‬
‫הדבר‬‫הכי‬‫קרוב‬‫למקור‬‫יהיה‬
‫אסמבלי‬
‫במעבד‬ ‫הריצה‬ ‫לאופן‬ ‫דומה‬ ‫מכונה‬ ‫לשפת‬ ‫קרוב‬ ‫הכי‬
‫אסמבלי‬ ‫למה‬?)!(

‫אוגרים‬(registers)‫יכולים‬ ‫אשר‬ ‫זיכרון‬ ‫רכיבי‬ ‫הינם‬
‫חישוב‬ ‫לצורכי‬ ‫בהם‬ ‫משתמש‬ ‫שהמעבד‬ ‫משתנים‬ ‫להכיל‬
‫לביצוע‬ ‫פעולות‬ ‫נשמרות‬ ‫בהן‬ ‫זיכרון‬ ‫כתובות‬ ‫או‬
‫ארכיטקטורת‬x86‫ניומן‬ ‫וון‬ ‫מודל‬ ‫על‬ ‫מבוסת‬,‫המעבד‬ ‫הם‬ ‫במחשב‬ ‫העיקריים‬ ‫החומרה‬ ‫רכיבי‬ ‫זה‬ ‫מודל‬ ‫פי‬ ‫על‬,‫הקלט‬ ‫ממשקי‬‫פלט‬
‫פנימיים‬ ‫חלקים‬ ‫מכמה‬ ‫מורכב‬ ‫המעבד‬ ‫כאשר‬ ‫והזיכרון‬
‫אוגרים‬
‫ונתונים‬ ‫פקודות‬ ‫של‬ ‫ושמירה‬ ‫ליבוא‬ ‫אחראי‬ ‫אשר‬ ‫הרכיב‬
‫הראם‬ ‫בזיכרון‬
Control unit
‫ארכיטקטורת‬x86
‫פעולות‬ ‫לביצוע‬ ‫אחראי‬ ‫אשר‬ ‫הרכיב‬‫אריתמתיות‬
‫מהראם‬ ‫פרודות‬ ‫של‬ ‫והרצה‬ ‫במחשב‬
ALU
CPU
RAM
Input / Output
registers
ALU
Control
Unit

‫נקבל‬ ‫אנחנו‬ ‫אותן‬ ‫הפקודות‬ ‫את‬ ‫יכיל‬ ‫זה‬ ‫אזור‬
‫מה‬disassembler.‫באזור‬ ‫להיטען‬ ‫לבקש‬ ‫יכולה‬ ‫תוכנה‬
‫פנוי‬ ‫זיכרון‬ ‫סמך‬ ‫על‬ ‫מקום‬ ‫לבקש‬ ‫או‬ ‫מסויים‬ ‫קוד‬
‫שונים‬ ‫תפקידים‬ ‫עם‬ ‫חלקים‬ ‫למספר‬ ‫מחולק‬ ‫הראם‬ ‫זיכרון‬,‫תוכנה‬ ‫של‬ ‫הרצה‬ ‫בזמן‬,‫לזיכרון‬ ‫ישמר‬ ‫התוכנה‬ ‫של‬ ‫עצמו‬ ‫הקוד‬,
‫אליהם‬ ‫גישה‬ ‫יש‬ ‫בתוכנה‬ ‫הפונקציות‬ ‫לכל‬ ‫אשר‬ ‫הגלובאלים‬ ‫המשתנים‬ ‫יטענו‬ ‫אחריו‬,‫ב‬ ‫ימצאו‬ ‫המשנים‬ ‫ושאר‬Stack‫ב‬ ‫או‬Heap
Code
‫ריצה‬ ‫בזמן‬ ‫שמוגדרים‬ ‫המשתנים‬ ‫את‬ ‫יכיל‬ ‫זה‬ ‫אזור‬
‫בה‬ ‫שמשתמשות‬ ‫לפונקציות‬ ‫לוקאלית‬
stack
‫הזיכרון‬ ‫מבנה‬
‫ה‬ ‫האזור‬"‫דינאמי‬"‫הזיכרון‬ ‫של‬,‫יבוצעו‬ ‫זה‬ ‫באזור‬
‫תוך‬ ‫לבצע‬ ‫מנסה‬ ‫התוכנה‬ ‫אשר‬ ‫זיכרון‬ ‫של‬ ‫אלוקציות‬
‫ריצה‬ ‫זמן‬ ‫כדי‬
Heap
RAM
Global Data
Code
Heap
Stack

‫המשתנה‬ ‫בדוגמא‬ ‫לראות‬ ‫שניתן‬ ‫כפי‬“bol”‫שהינו‬
‫נפנה‬ ‫אליו‬ ‫לפנות‬ ‫נרצה‬ ‫ואם‬ ‫אחד‬ ‫בייט‬ ‫תופס‬ ‫בוליאני‬
‫לכתובת‬8x401D00‫המשתנה‬ ‫ואילו‬“num”‫תופס‬4
‫בייטים‬,‫לכתובת‬ ‫נפנה‬ ‫אליו‬ ‫לפנות‬ ‫נרצה‬ ‫ואם‬
0x401D0C.
‫זיכרון‬ ‫אלוקציות‬ ‫בעניין‬ ‫לעומק‬ ‫מדי‬ ‫יותר‬ ‫לרדת‬ ‫מבלי‬,‫כתובת‬ ‫יש‬ ‫בייט‬ ‫לכל‬ ‫כאשר‬ ‫בייטים‬ ‫של‬ ‫ארוכה‬ ‫רשימה‬ ‫הוא‬ ‫שהזיכרון‬ ‫להגיד‬ ‫ניתן‬.
‫בד‬"‫של‬ ‫בקפיצות‬ ‫ישמרו‬ ‫שונים‬ ‫משתנים‬ ‫כ‬4‫בייטים‬,‫למשתנה‬ ‫הכתובת‬ ‫היה‬ ‫הראשון‬ ‫הבייט‬ ‫אחד‬ ‫מבייט‬ ‫יותר‬ ‫תופס‬ ‫מסויים‬ ‫משתנה‬ ‫וכאשר‬.
‫כתובות‬
‫לכתובות‬ ‫בפנייה‬ ‫מתמטים‬ ‫חישובים‬ ‫לעשות‬ ‫ניתן‬,‫כך‬
‫לכתובת‬ ‫להגיע‬ ‫ניתן‬ ‫לדוגמא‬0x401D10‫ידי‬ ‫על‬
‫החישוב‬0x401D08+8.
‫הקסהדצימאלים‬ ‫הם‬ ‫החישובים‬ ‫כי‬ ‫לב‬ ‫לשים‬ ‫יש‬
4 * 3 ≠ 1612 + 8 ≠ 20
4 * 3 = 0C12 + 8 = 1A
‫בכתובות‬ ‫אריטמטיקה‬
‫הזיכרון‬ ‫כתובות‬
RAM
Boolean: bol
Int32: num
0x401D08
0x401D09
0x401D0A
0x401D0B
0x401D0C
0x401D0D
0x401D0E
0x401D0F
0x401D10

‫את‬ ‫להפעיל‬ ‫למעבד‬ ‫ונאמר‬ ‫שבמידה‬ ‫לראות‬ ‫ניתן‬ ‫זו‬ ‫בדוגמא‬
‫ב‬ ‫הנמצאת‬ ‫הפקודה‬0x401D08‫תופעל‬ ‫שבאמת‬ ‫הפקודה‬
‫ב‬ ‫הפקודה‬ ‫היא‬0x401D10.‫בדר‬ ‫מנוצלת‬ ‫זו‬ ‫פקודה‬"‫על‬ ‫כ‬
‫לא‬ ‫היא‬ ‫אליהם‬ ‫בזיכרון‬ ‫למקומות‬ ‫להגיע‬ ‫תוכנה‬ ‫לנתב‬ ‫מנת‬
‫המקורי‬ ‫התכנון‬ ‫לפי‬ ‫להגיע‬ ‫אמורה‬
‫ה‬ ‫פקודת‬ ‫היא‬ ‫זה‬ ‫בשלב‬ ‫כבר‬ ‫להכיר‬ ‫שכדאי‬ ‫מעבד‬ ‫פקודת‬No Operation‫הוא‬ ‫מכונה‬ ‫בשפת‬ ‫שלה‬ ‫הקוד‬ ‫אשר‬0x90
‫בזיכרון‬ ‫זה‬ ‫בקוד‬ ‫נתקל‬ ‫המעבד‬ ‫כאשר‬,‫הבאה‬ ‫לפקודה‬ ‫ממשיך‬ ‫ופשוט‬ ‫כלום‬ ‫מבצע‬ ‫לא‬ ‫הוא‬.‫זיכרון‬ ‫לכתובת‬ ‫מופנה‬ ‫והמעבד‬ ‫נניח‬
‫הפקודה‬ ‫בה‬ ‫נמצאת‬ ‫אשר‬0x90‫ערך‬ ‫עם‬ ‫לתא‬ ‫שיגיע‬ ‫עד‬ ‫לחפש‬ ‫ימשיך‬ ‫הוא‬,‫ב‬ ‫שימושי‬ ‫זה‬ ‫דבר‬OverFlow‫למיניהם‬.
‫דוגמא‬
NOP0x90
0x401D08
0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x8B 0xEC
0x401D10

‫אוגרים‬ ‫סוגי‬
‫באופן‬ ‫למעבד‬ ‫זמינים‬ ‫שהיו‬ ‫כך‬ ‫מידע‬ ‫של‬ ‫שמירה‬ ‫ומאפשרים‬ ‫מהירה‬ ‫יותר‬ ‫אליהם‬ ‫הגישה‬ ‫אשר‬ ‫זיכרון‬ ‫רכיבי‬ ‫הם‬ ‫אוגרים‬
‫יותר‬ ‫יעיל‬,‫של‬ ‫באוגרים‬ ‫אלא‬ ‫שונים‬ ‫בגדלים‬ ‫באוגרים‬ ‫מדובר‬ ‫לא‬32‫המעבד‬ ‫לצורכי‬ ‫פנימית‬ ‫חלוקה‬ ‫עם‬ ‫ביט‬,
‫באמת‬ ‫לא‬ ‫והם‬ ‫מיוחדים‬ ‫תפקידים‬ ‫יש‬ ‫לחלקם‬ ‫אך‬ ‫זיכרון‬ ‫כתובות‬ ‫או‬ ‫משתנים‬ ‫להכיל‬ ‫ויכולים‬ ‫כללי‬ ‫לשימוש‬ ‫נועדו‬ ‫האוגרים‬"‫כלליים‬"
32‫ביט‬16‫ביט‬8‫ביט‬L.O8‫ביט‬H.O
EAXAXALAH
EBXBXBLBH
ECXCXCLCH
EDXDXDLDH
EBPBP
ESPSP
ESISI

‫נקראים‬ ‫האוגר‬ ‫של‬ ‫השמאלי‬ ‫בחלק‬ ‫הנמצאים‬ ‫הביטים‬
High Order bits,‫לדוגמא‬AH‫ה‬ ‫שני‬ ‫הם‬High
Order Bits‫של‬AX
H.O
‫אוגר‬ ‫של‬ ‫מבנה‬
0001 1000 1100 1001 1010 0101 1101 1111
1 8 C 9 A 5 D F
1010 0101 1101 1111
A 5 D F
1010 0101
A 5
1101 1111
D F
EAX
AX
ALAH‫נקראים‬ ‫האוגר‬ ‫של‬ ‫הימני‬ ‫בחלק‬ ‫הנמצאים‬ ‫הביטים‬
Low Order bits,‫לדוגמא‬AX‫ה‬ ‫ארבעת‬ ‫הם‬Low
Order Bits‫של‬EAX
L.O

EFLAGS
ZF
zero flag,‫כלשהיא‬ ‫פעולה‬ ‫כאשר‬
‫של‬ ‫ערכו‬ ‫לאפס‬ ‫השווה‬ ‫ערך‬ ‫מחזירה‬
‫נקבע‬ ‫הדגל‬(1)‫מאופס‬ ‫ערכו‬ ‫אחרת‬(0)
CF
carry flag,‫פעולה‬ ‫של‬ ‫תוצאה‬ ‫כאשר‬
‫בו‬ ‫האוגר‬ ‫מגודל‬ ‫קטנה‬ ‫או‬ ‫גדולה‬ ‫כלשהיא‬
‫נקבע‬ ‫הדגל‬ ‫של‬ ‫ערכו‬ ‫נשמר‬ ‫הערך‬(1)
SF
sign flag,‫פעולה‬ ‫של‬ ‫תוצאותה‬ ‫אם‬
‫של‬ ‫ערכו‬ ‫אז‬ ‫חיובית‬ ‫היא‬ ‫מסויימת‬
‫נקבע‬ ‫הדגל‬(1)‫מאופס‬ ‫הוא‬ ‫אחרת‬(0)
TF
trap flag‫נקבע‬ ‫זה‬ ‫דגל‬ ‫של‬ ‫ערכו‬ ‫אם‬(1)
‫פעם‬ ‫בכל‬ ‫אחת‬ ‫פעולה‬ ‫רק‬ ‫יבצע‬ ‫המעבד‬
IF
interrupt flag,‫זה‬ ‫דגל‬ ‫של‬ ‫ערכו‬ ‫אם‬
‫נקבע‬(1)‫באותות‬ ‫תטפל‬ ‫המערכת‬
interrupt‫מהחומרה‬ ‫להתקבל‬ ‫העלולים‬
OF
overflow flag,‫זה‬ ‫דגל‬ ‫של‬ ‫ערכו‬
‫נקבע‬(1)‫חריגה‬ ‫התרחשה‬ ‫אם‬
‫אריתמטית‬ ‫פעולה‬ ‫בביצוע‬ ‫מתמטית‬
‫מכיל‬ ‫מכיל‬ ‫אשר‬ ‫חשוב‬ ‫אחד‬ ‫אוגר‬ ‫עוד‬ ‫קיים‬ ‫קודם‬ ‫שהוזכרו‬ ‫לאוגרים‬ ‫בנוסף‬9‫ו‬ ‫בוליאנים‬ ‫ערכים‬7‫מערכת‬ ‫דגלי‬,
‫התוכנה‬ ‫של‬ ‫הריצה‬ ‫המשך‬ ‫את‬ ‫לקבוע‬ ‫כדי‬ ‫המעבד‬ ‫ידי‬ ‫על‬ ‫האלו‬ ‫בערכים‬ ‫תדיר‬ ‫שימוש‬ ‫נעשה‬ ‫ככלל‬,‫ועוד‬ ‫תנאים‬ ‫בדיקת‬.

‫פקודה‬ ‫של‬ ‫מבנה‬
mov eax, ebx
‫באוגר‬ ‫הערך‬ ‫את‬ ‫מעתיקה‬ ‫זו‬ ‫פעולה‬ebx
‫לאוגר‬ ‫אותו‬ ‫ומכניסה‬eax
mov eax, [0x4057C1]
‫בביטים‬ ‫הערך‬ ‫את‬ ‫מעתיקה‬ ‫זו‬ ‫פעולה‬
‫בכתובת‬ ‫נמצאים‬ ‫אשר‬0x4057c1‫לתוך‬
‫האוגר‬eax
mov eax, [ebx+esi*8]
‫בכתובת‬ ‫הערך‬ ‫את‬ ‫מעתיקה‬ ‫זו‬ ‫פעולה‬
‫מהחישוב‬ ‫כתוצאה‬ ‫שמתקבלת‬‫לתוך‬
‫האוגר‬eax
‫מ‬ ‫מורכבת‬ ‫הינה‬ ‫אשר‬ ‫פקודה‬ ‫יכילו‬ ‫באסמבלי‬ ‫הפקודות‬ ‫רוב‬3(‫יותר‬ ‫לעיתים‬ ‫או‬)‫פרמטרים‬ ‫שני‬ ‫או‬ ‫ואחד‬ ‫אותיות‬.
‫זיכרון‬ ‫כתובות‬ ‫להיות‬ ‫יכולים‬ ‫הללו‬ ‫הפרמטרים‬,‫זיכרון‬ ‫כתובות‬ ‫על‬ ‫אריתמטיות‬ ‫פעולות‬ ‫או‬ ‫הקסדצימלים‬ ‫ערכים‬ ‫אוגרים‬.
‫מרובעים‬ ‫בסוגריים‬ ‫אותו‬ ‫לשים‬ ‫יש‬ ‫כתובת‬ ‫הוא‬ ‫כלשהו‬ ‫שערך‬ ‫למעבד‬ ‫לציין‬ ‫מנת‬ ‫על‬ ‫כי‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫כללי‬ ‫מבנה‬:command destination, source
‫הערה‬:‫באסמבלי‬ ‫לפקודה‬ ‫פרמטרים‬ ‫כשני‬ ‫כתובות‬ ‫שתי‬ ‫להעביר‬ ‫ניתן‬ ‫לא‬

‫באסמבלי‬ ‫מתמטיות‬ ‫פעולות‬
‫בסימנים‬ ‫שימוש‬ ‫ידי‬ ‫על‬ ‫רגילים‬ ‫אנחנו‬ ‫לו‬ ‫באופן‬ ‫משתנים‬ ‫על‬ ‫ארתמטיות‬ ‫פעולות‬ ‫לבצע‬ ‫ניתן‬ ‫לא‬ ‫שבאסמבלי‬ ‫לב‬ ‫לשים‬ ‫יש‬
+-=/%‫ואחרים‬,‫לאן‬ ‫נכנס‬ ‫משתנה‬ ‫איזה‬ ‫לזכור‬ ‫ולהקפיד‬ ‫בפקודות‬ ‫להשתמש‬ ‫מחוייבים‬ ‫נהיה‬ ‫פעולה‬ ‫כל‬ ‫לבצע‬ ‫מנת‬ ‫על‬
‫לאיבוד‬ ‫בקלות‬ ‫ללכת‬ ‫ניתן‬ ‫אחרת‬
‫לב‬ ‫שימו‬:‫התוצאה‬ ‫תשמר‬ ‫איפה‬ ‫שליטה‬ ‫לנו‬ ‫אין‬
‫תאור‬ ‫פעולה‬
‫הפעולה‬‫תחסיר‬0x10(16)‫מהאוגר‬eax‫ב‬ ‫התוצאה‬ ‫את‬ ‫ותשמור‬eax sub eax, 0x10
‫הפעולה‬‫ב‬ ‫הערך‬ ‫את‬ ‫תוסיף‬ebx‫לאוגר‬eax‫ב‬ ‫התוצאה‬ ‫את‬ ‫ותשמור‬eax add eax, ebx
‫הפעולה‬‫תוסיף‬1‫לאוגר‬edx‫ב‬ ‫התוצאה‬ ‫את‬ ‫ותשמור‬edx inc edx
‫הפעולה‬‫תחסיר‬1‫מהאוגר‬ecx‫ב‬ ‫התוצאה‬ ‫את‬ ‫ותשמור‬ecx dec ecx

‫באסמבלי‬ ‫מתמטיות‬ ‫פעולות‬
‫מראש‬ ‫מוגדרים‬ ‫אוגרים‬ ‫על‬ ‫מתבצעות‬ ‫שהפעולות‬ ‫כיוון‬ ‫שליטה‬ ‫פחות‬ ‫אפילו‬ ‫יש‬ ‫חילוק‬ ‫או‬ ‫כפל‬ ‫של‬ ‫במקרה‬.
‫כלליים‬ ‫הינם‬ ‫שהאוגרים‬ ‫למרות‬ ‫מקודם‬ ‫שצויין‬ ‫כמו‬,‫מסויימות‬ ‫פונקציות‬ ‫כלפי‬ ‫מיוחדת‬ ‫אחריות‬ ‫גם‬ ‫יש‬ ‫לחלקם‬.
‫הפעולה‬ ‫לפני‬ ‫מוגדרים‬ ‫האוגרים‬ ‫כיצד‬ ‫לבדוק‬ ‫יש‬ ‫כזה‬ ‫למצב‬ ‫מגיעים‬ ‫אנחנו‬ ‫אם‬ ‫כן‬ ‫על‬
‫הפעולה‬‫את‬ ‫תכפיל‬eax‫ב‬0x04(4)‫האוגרים‬ ‫בין‬ ‫תתפצל‬ ‫והתוצאה‬eax‫ו‬edx
‫כאשר‬edx‫ה‬ ‫את‬ ‫מכיל‬H.O bits‫התוצאה‬ ‫של‬
mul 0x04
‫הפעולה‬‫האוגרים‬ ‫בין‬ ‫השמור‬ ‫הערך‬ ‫את‬ ‫תחלק‬eax‫ו‬edx‫המוזכרת‬ ‫בצורה‬
‫ב‬ ‫למעלה‬0x04(4),‫ב‬ ‫ישמר‬ ‫התוצאה‬ ‫של‬ ‫השלם‬ ‫החלק‬eax‫השארית‬ ‫ואילו‬
‫ב‬ ‫תשמר‬edx
div 0x04
0010 1001 0001 0001 0000 1001 1010 0110
2 9 1 1 0 9 A 6
EAX
0000 0000 0000 0000 0000 0000 0001 1010
0 0 0 0 0 0 1 A
EDX ‫התוצאה‬112358132134‫הבא‬ ‫באופן‬ ‫תשמר‬

‫לוגיות‬ ‫פעולות‬
‫כגון‬ ‫לוגיות‬ ‫בפעולות‬ ‫נרחב‬ ‫שימוש‬ ‫קיים‬ ‫באסמבלי‬or,and,not‫ובמיוחד‬xor‫דרך‬ ‫כקיצור‬ ‫למשל‬ ‫או‬ ‫הצפנה‬ ‫לצורכי‬ ‫כלל‬ ‫בדרך‬
xor eax, eax‫של‬ ‫ערכו‬ ‫את‬ ‫לקבוע‬ ‫מהירה‬ ‫דרך‬ ‫היא‬eax‫ל‬0.‫ויעד‬ ‫מקור‬ ‫יקבלו‬ ‫הלוגיות‬ ‫הפעולות‬ ‫קודם‬ ‫שראינו‬ ‫לפעולות‬ ‫זהה‬ ‫באופן‬,
‫ביעד‬ ‫התוצאה‬ ‫את‬ ‫וישמרו‬ ‫הפעולה‬ ‫את‬ ‫יבצעו‬.‫הבינארית‬ ‫ברמה‬ ‫מבוצאות‬ ‫שהפעולות‬ ‫לב‬ ‫לשים‬ ‫יש‬
AX‫הפעולה‬ ‫לאחר‬BXAX‫פעולה‬
00 A900 AB00 B9or ax, bx
0000 0000 1010 10010000 0000 1010 10110000 0000 1011 1001and ax, bx
00 56-00 A9not ax
0000 0000 0110 01010000 0000 0011 11000000 0000 0101 1001xor ax, bx
0000 0001 1001 1000-0000 0000 0110 0110rol ax, 2
0101 0000 0000 10100000 0000 1010 0101-ror bx, 4

EBP‫מתחיל‬ ‫בה‬ ‫הכתובת‬ ‫את‬ ‫שמחיל‬ ‫האוגר‬ ‫הוא‬
‫ה‬Stack,‫הפונקציה‬ ‫ריצת‬ ‫כל‬ ‫לארוך‬ ‫קבוע‬ ‫ישאר‬ ‫הוא‬
‫פעולות‬ ‫ידי‬ ‫על‬ ‫משתנים‬ ‫למציאת‬ ‫ישמש‬ ‫כלל‬ ‫ובדרך‬
‫כגון‬ ‫בזיכרון‬ ‫אריטמטיות‬[ebp+4]
‫פועלת‬ ‫הפונקציה‬ ‫עוד‬ ‫כל‬ ‫יתקיימו‬ ‫אשר‬ ‫מסויימת‬ ‫לפונקציה‬ ‫לוקאלים‬ ‫משתנים‬ ‫להגדיר‬ ‫תוכנה‬ ‫יכולה‬ ‫ריצה‬ ‫בזמן‬ ‫כידוע‬,
‫הנקרא‬ ‫באזור‬ ‫יוגדרו‬ ‫אלו‬ ‫משתנים‬Stack‫קודם‬ ‫שהוזכר‬,‫ה‬ ‫אחר‬ ‫רציף‬ ‫מעקב‬ ‫לצורך‬Stack‫בו‬ ‫השמורים‬ ‫המשתנים‬ ‫ומיפוי‬
‫באסמבלי‬ ‫קיימים‬2‫יעודיים‬ ‫אוגרים‬EBP‫ו‬ESP
EBP
‫ה‬ ‫אחרי‬ ‫מעקב‬Stack
ESP‫ראש‬ ‫לציון‬ ‫האחראי‬ ‫האוגר‬ ‫הוא‬‫ה‬ ‫סוף‬Stack.
‫שה‬ ‫כיוון‬Stack‫עיקרון‬ ‫על‬ ‫עובד‬"‫הוא‬ ‫שנכנס‬ ‫אחרון‬
‫שיוצא‬ ‫ראשון‬"‫בהשוואה‬ ‫פונקציה‬ ‫תסתיים‬ ‫כלל‬ ‫בדרך‬
‫של‬ESP‫ל‬EBP
ESP
Stack
Data
Data
Data
Data
EBP
ESP
0x401D08
0x401D18

‫לפונקציות‬ ‫קריאה‬
‫הפקודה‬ ‫עם‬ ‫תתבצע‬ ‫כלל‬ ‫בדרך‬ ‫לפונקציה‬ ‫קריאה‬call‫נמצאת‬ ‫הפונקציה‬ ‫בו‬ ‫בזיכרון‬ ‫ומקום‬,‫לפונקציה‬ ‫להעביר‬ ‫ניתן‬ ‫שלא‬ ‫כיוון‬
‫ה‬ ‫לזיכרון‬ ‫יטענו‬ ‫כלל‬ ‫בדרך‬ ‫המשתנים‬ ‫ישיר‬ ‫באופן‬ ‫משתנים‬Stack‫הפוך‬ ‫בסדר‬,‫הפונקציה‬ ‫מתוך‬ ‫יקראו‬ ‫מכן‬ ‫ולאחר‬,
‫הספציפית‬ ‫הפונקציה‬ ‫של‬ ‫הדוקומנטציה‬ ‫את‬ ‫לקרוא‬ ‫צריך‬ ‫לקבל‬ ‫אמורה‬ ‫הפונקציה‬ ‫משתנים‬ ‫איזה‬ ‫לדעת‬ ‫כדי‬
‫לב‬ ‫שימו‬:‫ההרצה‬ ‫בתחילת‬ ‫לרוץ‬ ‫מסיימת‬ ‫שהפונקציה‬ ‫אחרי‬ ‫לחזור‬ ‫מקום‬ ‫לאיזה‬ ‫לזכור‬ ‫בשביל‬
‫ל‬ ‫הפונקציה‬ ‫נקראה‬ ‫ממנו‬ ‫הנוכחי‬ ‫המיקום‬ ‫ישמר‬Stack‫לאוגר‬ ‫יכונס‬ ‫מכן‬ ‫ולאחר‬EIP‫שתפקידו‬
‫לרוץ‬ ‫שצריך‬ ‫בזיכרון‬ ‫הבא‬ ‫למיקום‬ ‫להפנות‬.
‫הפעולה‬‫של‬ ‫התוכן‬ ‫את‬ ‫תוסיף‬eax‫ה‬ ‫לראש‬Stack push eax
‫הפעולה‬‫ה‬ ‫מראש‬ ‫התוכן‬ ‫את‬ ‫תעביר‬Stack‫האוגר‬ ‫לתוך‬eax pop eax
‫הפעולה‬‫בכתובת‬ ‫שיושבת‬ ‫לפונקציה‬ ‫תקרא‬0xdeadbeef call 0xdeadbeef
‫למקום‬ ‫תחזור‬ ‫הפעולה‬‫הפונקציה‬ ‫הופעלה‬ ‫בו‬ ‫בזיכרון‬ ret
‫תיצור‬ ‫הפעולה‬Stack frame enter
‫תמחק‬ ‫הפעולה‬‫ה‬ ‫את‬Stack frame‫האחרון‬ leave

‫שהכתובת‬ ‫אחרי‬ ‫נוצרים‬ ‫הפונקציה‬ ‫של‬ ‫המשתנים‬
‫וה‬ ‫לחזרה‬EBP‫תהיה‬ ‫אליהם‬ ‫הגישה‬ ‫ולכן‬ ‫מוגדרים‬
‫מ‬ ‫יותר‬ ‫הגבוהות‬ ‫כתובות‬ ‫באמצאות‬EBP
‫המחשב‬ ‫אחרת‬ ‫לפונקציה‬ ‫בטעות‬ ‫יגיעו‬ ‫לא‬ ‫אחת‬ ‫לפונקציה‬ ‫ששיכים‬ ‫ומשתנים‬ ‫משלה‬ ‫זיכרון‬ ‫אזור‬ ‫להיות‬ ‫צריך‬ ‫פונקציה‬ ‫שלכל‬ ‫כיוון‬
‫אזור‬ ‫פונקציה‬ ‫לכל‬ ‫מחלק‬Stack‫ה‬ ‫בתוך‬ ‫דברים‬ ‫נשמרים‬ ‫שבו‬ ‫לאופן‬ ‫דומה‬ ‫באופן‬ ‫שנשמר‬ ‫משלו‬Stack‫בעצמו‬
Variables
Stack frames
‫לפני‬ ‫מועברים‬ ‫לפונקציה‬ ‫שמועברים‬ ‫הפרמטרים‬
‫ו‬ ‫לחזרה‬ ‫הכתובת‬ ‫הגדרת‬EBP‫אליהם‬ ‫הגישה‬ ‫לכן‬
‫מ‬ ‫יותר‬ ‫נמוכות‬ ‫כתובות‬ ‫בעזרת‬ ‫תתבצע‬EBP
Arguemets
Memory
Caller’s caller frame
Caller’s frame
Current frame
Stack
Argument
Argument
Return Address
Old EBP
Variable
Pushad‫אסמבלי‬ ‫פקודת‬ ‫עוד‬ ‫היא‬,‫זה‬ ‫במקרה‬
‫ל‬ ‫יוסיף‬ ‫המחשב‬Stack‫הבא‬ ‫בסדר‬ ‫האוגרים‬ ‫את‬:
eax,ecx,edx,ebx,esp,ebp,esi,esi
‫האוגרים‬ ‫של‬ ‫גיבוי‬ ‫ביצוע‬ ‫לצורך‬
pushad

‫השוואה‬ ‫פעולות‬
‫תנאים‬ ‫ידי‬ ‫על‬ ‫היא‬ ‫באסמבלי‬ ‫הקוד‬ ‫מהלך‬ ‫את‬ ‫לקבוע‬ ‫אחת‬ ‫דרך‬,‫הקוד‬ ‫מהלך‬ ‫אחרות‬ ‫תכנות‬ ‫לשפות‬ ‫בניגוד‬
‫ההשוואה‬ ‫פעולת‬ ‫בעקבות‬ ‫שהשתנו‬ ‫מהדגלים‬ ‫כתוצאה‬ ‫אלה‬ ‫עצמה‬ ‫ההשוואה‬ ‫בפעולת‬ ‫נקבע‬ ‫לא‬ ‫באסמבלי‬.
‫של‬ ‫ערכו‬ ‫יקבע‬ ‫שווים‬ ‫ערכים‬ ‫שני‬ ‫אם‬ ‫לדוגמא‬ZF,‫ל‬ ‫בהתאם‬ ‫מכן‬ ‫ולאחר‬ZF‫התוכנה‬ ‫של‬ ‫הפעולה‬ ‫המשך‬ ‫יקבע‬
ZF CF ‫תנאי‬
1 0 dest = src
0 1 dest < src
0 0 dest > src
‫הפקודה‬ ‫באמצעות‬ ‫מתבצעת‬ ‫באסמבלי‬ ‫ההשוואה‬ ‫פעולת‬
cmp destination, source

‫תנאי‬ ‫סוגי‬
jmp loc
‫למקום‬ ‫לקפוץ‬ ‫למעבד‬ ‫מורה‬ ‫זו‬ ‫פקודה‬
‫תנאי‬ ‫ללא‬ ‫מסויים‬
jz loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬ZF‫הוא‬
1‫המוגדר‬ ‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫ואם‬
jnz loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬ZF
‫הוא‬0‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫ואם‬
‫המוגדר‬
je/jne loc
‫כמו‬ ‫הדבר‬ ‫אותו‬ ‫עובד‬jz/jnz‫בדרך‬ ‫אבל‬
‫פעולת‬ ‫אחרי‬ ‫ישר‬ ‫יופיע‬ ‫כלל‬cmp
Jg/jnl loc
‫פעולת‬ ‫אחרי‬ ‫תתבצע‬ ‫קפיצה‬cmp‫אם‬
dest‫מ‬ ‫גדול‬ ‫יותר‬src‫ההשוואה‬ ‫בפעולת‬
jng/jl loc
‫פעולת‬ ‫אחרי‬ ‫תתבצע‬ ‫קפיצה‬cmp‫אם‬
dest‫לא‬‫מ‬ ‫גדול‬ ‫יותר‬src‫בפעולת‬
‫ההשוואה‬
‫בינהם‬ ‫ההשוואה‬ ‫ואופן‬ ‫הדגלים‬ ‫על‬ ‫שמבוססים‬ ‫תנאי‬ ‫סוגי‬ ‫של‬ ‫רב‬ ‫מספר‬ ‫קיימים‬ ‫באסמבלי‬
‫יותר‬ ‫יעילה‬ ‫בצורה‬ ‫התוכנה‬ ‫מהלך‬ ‫את‬ ‫לנתח‬ ‫בשביל‬ ‫בינהם‬ ‫ההבדלים‬ ‫את‬ ‫לדעת‬ ‫עדיף‬ ‫זאת‬ ‫בכל‬ ‫אך‬ ‫דומים‬ ‫די‬ ‫אומנם‬ ‫רובם‬
‫הבאות‬ ‫בדוגמאות‬loc‫בזיכרון‬ ‫כלשהיא‬ ‫כתובת‬ ‫הינו‬.
jo loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬OF‫הוא‬
js loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬SF‫הוא‬
jecxz loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬ECX
‫הוא‬0‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫ואם‬
‫המוגדר‬

‫ביטים‬ ‫של‬ ‫מניפולציה‬
‫הצפנות‬ ‫או‬ ‫חישובים‬ ‫בינהם‬ ‫שונים‬ ‫לצרכים‬ ‫ביטים‬ ‫של‬ ‫מניפולציה‬ ‫לנצל‬ ‫יכולות‬ ‫תוכנות‬ ‫מעט‬ ‫לא‬,‫משפחות‬ ‫בשתי‬ ‫שימוש‬ ‫יהיה‬ ‫זה‬ ‫במקרה‬
‫פקודות‬ ‫של‬(repreperepne)‫והפקודות‬ ‫מסויימת‬ ‫פעולה‬ ‫על‬ ‫לחזור‬ ‫למעבד‬ ‫שאומרות‬(cmpsbscasbmovsb)
‫לעשות‬ ‫מה‬ ‫שקובעות‬,‫באוגרים‬ ‫שימוש‬ ‫יבוצע‬ ‫בנוסף‬ESI,EDI,ECX‫מראש‬ ‫מוגדרים‬ ‫להיות‬ ‫שצריכים‬
‫לב‬ ‫שימו‬:‫האלו‬ ‫הפעולות‬ ‫בכל‬ECX‫של‬ ‫סוג‬ ‫הוא‬counter‫עד‬ ‫כלשהו‬ ‫ממספר‬ ‫שרץ‬0,ESI‫זיכרון‬ ‫כתובת‬ ‫הוא‬
‫כ‬ ‫שמשמשת‬source‫ו‬EDI‫כ‬ ‫שמשמשת‬ ‫זיכרון‬ ‫כתובת‬ ‫הוא‬destination
‫בד‬ ‫ישנה‬ ‫כן‬ ‫כמו‬"‫האות‬ ‫מופיע‬ ‫אם‬ ‫באסמבלי‬ ‫הפקודות‬ ‫של‬ ‫בשמות‬ ‫חוקיות‬ ‫כ‬‘n’‫ל‬ ‫היא‬ ‫שהכוונה‬ ‫כנראה‬‘not’‫ואם‬
‫מופיע‬‘e’‫ל‬ ‫הכוונה‬ ‫כנראה‬ ‫אז‬‘equal’‫מופיע‬ ‫ואם‬‘z’‫שה‬ ‫להניח‬ ‫סביר‬ZF‫הפעולה‬ ‫בביצוע‬ ‫נבדק‬.
‫הפעולה‬‫באוגר‬ ‫הנקבעת‬ ‫בייטים‬ ‫כמות‬ ‫את‬ ‫תשווה‬ECX‫הכתובות‬ ‫בין‬ESI‫ו‬EDI
‫ותחסיר‬1‫מ‬ECX‫ש‬ ‫עד‬ ‫סיבוב‬ ‫בכל‬ECX=0‫יהיו‬ ‫לא‬ ‫שנבדקים‬ ‫שהבייטים‬ ‫או‬
‫שווים‬.
repe cmpb
‫תעתיק‬ ‫הפעולה‬‫ב‬ ‫הנקבעת‬ ‫הבייטים‬ ‫כמות‬ ‫את‬ECX‫מהכתובת‬ESI‫לכתובת‬EDI
‫ותחסיר‬1‫מ‬ECX‫ל‬ ‫שווה‬ ‫יהיה‬ ‫שהוא‬ ‫עד‬0
rep movsb
‫הפועולה‬‫ב‬ ‫המוגדר‬ ‫הבייט‬ ‫את‬ ‫תחפש‬AL‫ב‬ ‫המתחילה‬ ‫בכתובת‬EDI‫את‬ ‫ותבדוק‬
‫ב‬ ‫המוגדרת‬ ‫הבייטים‬ ‫כמות‬ECX‫ש‬ ‫עד‬ECX=0‫ימצא‬ ‫שהבייט‬ ‫או‬
repne scasb

‫הפונקציה‬Main
argv[0]
‫הוא‬ ‫מריצים‬ ‫שאנחנו‬ ‫התוכנה‬ ‫של‬ ‫השם‬
‫שמועברים‬ ‫המשנתים‬ ‫אחד‬ ‫גם‬,‫במקרה‬
‫זה‬ ‫הדוגמא‬ ‫של‬example.exe
argv[1]
‫שמועבר‬ ‫הראשון‬ ‫הפרמטר‬"-i"‫בדרך‬
‫כנגד‬ ‫השוואה‬ ‫תתבצע‬ ‫התוכנה‬ ‫בתוך‬ ‫כלל‬
‫צפויה‬ ‫שהתוכנה‬ ‫קלטים‬ ‫של‬ ‫רשימה‬
‫פונקציות‬ ‫יופעלו‬ ‫ובהתאם‬ ‫לקבל‬
‫מסויימות‬
argv[2]
‫הפרמטר‬ ‫שלנו‬ ‫הדוגמא‬ ‫של‬ ‫במקרה‬
‫הוא‬ ‫השני‬“/path/to/file”‫גם‬ ‫יכול‬ ‫והוא‬
‫מוגדרות‬ ‫קלט‬ ‫אופציות‬ ‫כנגד‬ ‫להבדק‬ ‫כן‬
‫משתמש‬ ‫קלט‬ ‫להיות‬ ‫אפילו‬ ‫או‬ ‫מראש‬
‫פונקציה‬ ‫לצורך‬
‫ה‬ ‫התוכנות‬ ‫רוב‬"‫חכמות‬"‫וה‬"‫מורכבות‬"‫וטובה‬ ‫נכונה‬ ‫בצורה‬ ‫המערכת‬ ‫של‬ ‫המשאבים‬ ‫את‬ ‫לנצל‬ ‫שתדע‬ ‫שפה‬ ‫דורשות‬,
‫היא‬ ‫האלו‬ ‫השפות‬ ‫אחת‬C‫פונקציית‬ ‫של‬ ‫העיקרון‬ ‫את‬ ‫שממשות‬ ‫נוספות‬ ‫שפות‬ ‫פותחו‬ ‫שממנה‬main‫פרמטרים‬ ‫שני‬ ‫שמקבלת‬
argc‫ו‬ ‫לרוץ‬ ‫כדי‬ ‫דורשת‬ ‫שהתוכנה‬ ‫הפרמטרים‬ ‫כמות‬ ‫את‬ ‫שמכיל‬argv‫עצמם‬ ‫לפרמטרים‬ ‫הפניה‬ ‫שהוא‬
‫כללי‬ ‫מבנה‬:int main(int argc, char** argv)
‫הרצת‬ ‫של‬ ‫במקרה‬example.exe -i /path/to/file‫מועברים‬3‫פרמטרים‬
‫הערה‬:‫פרמטרים‬ ‫לקבל‬ ‫צריכה‬ ‫היא‬ ‫תרוץ‬ ‫שתוכנה‬ ‫מנת‬ ‫על‬ ‫לפעמים‬,‫יכול‬ ‫פונקציות‬ ‫של‬ ‫טוב‬ ‫חקר‬
‫אותה‬ ‫לחקור‬ ‫בשביל‬ ‫שצריך‬ ‫כמו‬ ‫התוכנה‬ ‫את‬ ‫להריץ‬ ‫איך‬ ‫להבין‬ ‫לעזור‬

IDA‫את‬ ‫לפתוח‬ ‫איך‬ ‫אוטומטית‬ ‫תזהה‬ ‫כלל‬ ‫בדרך‬
‫בתצורה‬ ‫אותו‬ ‫לפתוח‬ ‫וברצונכם‬ ‫במקרה‬ ‫אך‬ ‫הקובץ‬
‫מס‬ ‫בשדה‬ ‫זאת‬ ‫לבחור‬ ‫ניתן‬ ‫אחרת‬'1
Interctive Disassember Professional‫רבה‬ ‫פונקציונליות‬ ‫עם‬ ‫עוצמתי‬ ‫דיסאסמבלר‬ ‫הוא‬,‫התוכנה‬ ‫של‬ ‫הרבים‬ ‫היתרונות‬ ‫בין‬
‫הרצה‬ ‫פורמטי‬ ‫במגוון‬ ‫התמיכה‬ ‫הם‬,‫ספריות‬ ‫לזהות‬ ‫ויכולת‬ ‫שונים‬ ‫מעבדים‬ ‫בסוגי‬ ‫תמיכה‬,‫משתנים‬,‫שמות‬ ‫להם‬ ‫ולתת‬ ‫פרמטרים‬.
‫ניתוח‬ ‫עבודת‬ ‫כל‬ ‫על‬ ‫מאוד‬ ‫מקל‬ ‫זה‬ ‫דבר‬.‫ב‬ ‫קיימת‬ ‫בנוסף‬IDA‫של‬ ‫סקריפטים‬ ‫להרצת‬ ‫אופצייה‬python‫מקסימאלית‬ ‫עבודה‬ ‫נוחות‬ ‫לקבלת‬.
Load as
‫הבסיסים‬ ‫הניתוחים‬ ‫רוב‬ ‫עבור‬IDA‫אוטומטית‬ ‫תבחר‬
‫זאת‬ ‫לקבוע‬ ‫ניתן‬ ‫כן‬ ‫גם‬ ‫אך‬ ‫ופרמטרים‬ ‫המעבד‬ ‫סוג‬ ‫את‬
‫ידני‬ ‫באופן‬‫מס‬ ‫בשדה‬'2
Processor type
IDA Pro
‫ספציפי‬ ‫במקום‬ ‫להטען‬ ‫לתוכנה‬ ‫לגרום‬ ‫נרצה‬ ‫לפעמים‬
‫בזיכרון‬(‫דינאמי‬ ‫ניתוח‬ ‫עם‬ ‫להשוות‬ ‫בשביל‬ ‫למשל‬
‫מתקדם‬)‫נסמן‬ ‫זה‬ ‫במקרה‬Manual load‫ונבחר‬
‫מס‬ ‫בשדות‬ ‫התוכנה‬ ‫את‬ ‫לטעון‬ ‫נרצה‬ ‫כתובת‬ ‫באיזה‬'3
Manual load

‫זה‬ ‫באזור‬IDA‫מזהה‬ ‫שהיא‬ ‫הפונקציות‬ ‫כל‬ ‫את‬ ‫ממפה‬
‫בתוכנה‬,‫אם‬IDA‫פונקציית‬ ‫מזהה‬main‫בסוף‬ ‫מייד‬
‫ב‬disassembly‫הזאת‬ ‫לפונקציה‬ ‫הפוקוס‬ ‫יעבור‬
‫ל‬IDA‫העבודה‬ ‫שרוב‬ ‫למרות‬ ‫פעולות‬ ‫לביצוע‬ ‫עבודה‬ ‫סרגלי‬ ‫מספר‬ ‫כן‬ ‫וכמו‬ ‫נוחה‬ ‫בצורה‬ ‫המסודרים‬ ‫ומידע‬ ‫עבודה‬ ‫אזורי‬ ‫מספר‬
‫ב‬IDA‫במקלדת‬ ‫המקשים‬ ‫עם‬ ‫דרך‬ ‫בקיצורי‬ ‫שימוש‬ ‫בעזרת‬ ‫להתבצע‬ ‫יכולה‬
‫אזור‬1
‫העבודה‬ ‫רוב‬ ‫תתבצע‬ ‫זה‬ ‫באזור‬,‫את‬ ‫לראות‬ ‫ניתן‬ ‫כאן‬
‫התוכנה‬ ‫של‬ ‫שונים‬ ‫פרטים‬ ‫או‬ ‫שונות‬ ‫בתצורות‬ ‫הקוד‬
‫אזור‬2
‫ראשית‬ ‫תצוגה‬
‫האם‬ ‫להראות‬ ‫שתפקידו‬ ‫צבעוני‬ ‫סרגל‬ ‫מופיע‬ ‫זה‬ ‫באזור‬
‫ידנית‬ ‫שנכתב‬ ‫קוד‬ ‫הוא‬ ‫בודקים‬ ‫שאנחנו‬ ‫האזור‬(‫כחול‬)
‫המערכת‬ ‫של‬ ‫מובנות‬ ‫ספריות‬ ‫או‬(‫שאר‬)
‫אזור‬3

‫לעומק‬ ‫יותר‬ ‫הקוד‬ ‫את‬ ‫לחקור‬ ‫מאפשר‬ ‫זו‬ ‫תצוגה‬
‫שמאל‬ ‫בצד‬ ‫הכתובות‬ ‫מיפוי‬ ‫את‬ ‫ולראות‬
‫ל‬IDA‫עיקריים‬ ‫קוד‬ ‫תצוגת‬ ‫מצבי‬ ‫שתי‬,‫ויזואלית‬ ‫תצוגה‬(1)‫קוד‬ ‫ותצוגת‬(2)‫ה‬ ‫מקש‬ ‫על‬ ‫לחיצה‬ ‫ידי‬ ‫על‬ ‫בקלות‬ ‫בינהם‬ ‫להליף‬ ‫ניתן‬Space
‫קוד‬ ‫תצוגת‬
‫שמקושרות‬ ‫למסגרות‬ ‫מחולק‬ ‫הקוד‬ ‫זו‬ ‫בתצוגה‬
‫בקפיצות‬,‫הקוד‬ ‫אחרי‬ ‫במעקב‬ ‫להיות‬ ‫נוח‬ ‫זה‬ ‫באופן‬
‫הקפיצה‬ ‫תנאי‬ ‫את‬ ‫ולראות‬
‫ויזואלית‬ ‫תצוגה‬

‫כלשהו‬ ‫ותנאי‬ ‫במידה‬ ‫הקוד‬ ‫הלך‬ ‫את‬ ‫יסמנו‬ ‫אלו‬ ‫חצים‬
‫מתקיים‬,‫את‬ ‫לקרוא‬ ‫יש‬ ‫התנאי‬ ‫מה‬ ‫לבדוק‬ ‫מנת‬ ‫על‬
‫החץ‬ ‫יוצא‬ ‫ממנה‬ ‫בקוביה‬ ‫הקוד‬
‫של‬ ‫הצבעונית‬ ‫החלוקה‬IDA‫הקוד‬ ‫לעומק‬ ‫שיורדים‬ ‫לפני‬ ‫עוד‬ ‫פרטים‬ ‫להרבה‬ ‫לב‬ ‫לשים‬ ‫מאפשרת‬:
‫ורוד‬ ‫בצבע‬ ‫יטענו‬ ‫כלל‬ ‫בדרך‬ ‫מערכת‬ ‫מספריות‬ ‫פונקציות‬,‫כהה‬ ‫בכחול‬ ‫אסמבלי‬ ‫קוד‬,‫בהיר‬ ‫בכחול‬ ‫והערות‬ ‫בירוק‬ ‫ערכים‬,‫בנוסף‬
‫התוכנה‬ ‫של‬ ‫הקוד‬ ‫הלך‬ ‫על‬ ‫המורים‬ ‫חצים‬ ‫ישנם‬,‫בלולאה‬ ‫ומדובר‬ ‫כנראה‬ ‫מעלה‬ ‫העולה‬ ‫חץ‬ ‫ויש‬ ‫במידה‬
‫ירוקים‬ ‫חצים‬
‫כלשהו‬ ‫ותנאי‬ ‫במידה‬ ‫הקוד‬ ‫הלך‬ ‫את‬ ‫יסמנו‬ ‫אלו‬ ‫חצים‬
‫מתקיים‬ ‫לא‬,‫את‬ ‫לקרוא‬ ‫יש‬ ‫התנאי‬ ‫מה‬ ‫לבדוק‬ ‫מנת‬ ‫על‬
‫החץ‬ ‫יוצא‬ ‫ממנה‬ ‫בקוביה‬ ‫הקוד‬
‫אדומים‬ ‫חצים‬
‫ויזואלית‬ ‫תצוגה‬
‫תנאי‬ ‫ללא‬ ‫קפיצה‬ ‫יסמנו‬ ‫אלו‬ ‫חצים‬(jmp)
‫כחולים‬ ‫חצים‬

‫בזיכרון‬ ‫כלשהו‬ ‫למיקום‬ ‫הפניה‬ ‫יש‬ ‫כאשר‬IDA‫תתן‬‫לו‬
‫שם‬Loc_X‫ו‬ ‫ניתן‬ ‫אשר‬XREF‫כלשהו‬(‫ירוק‬ ‫בצבע‬)
‫מיקום‬ ‫לאותו‬ ‫אלטרנטיבי‬ ‫שם‬ ‫שהוא‬
‫המסך‬ ‫של‬ ‫שמאל‬ ‫בצד‬ ‫מנחים‬ ‫חצים‬ ‫לראות‬ ‫ניתן‬ ‫עדיין‬ ‫זאת‬ ‫עם‬ ‫אך‬ ‫עצמו‬ ‫בקוד‬ ‫מתמקדת‬ ‫הקוד‬ ‫תצוגת‬.
‫תנאי‬ ‫ללא‬ ‫קפיצה‬ ‫מסמלים‬ ‫רציפים‬ ‫חצים‬,‫הפונים‬ ‫וחצים‬ ‫מתבצע‬ ‫כלשהו‬ ‫ותנאי‬ ‫במידה‬ ‫הקוד‬ ‫הלך‬ ‫את‬ ‫מקווקוים‬ ‫חצים‬
‫לולאות‬ ‫מסמנים‬ ‫מעלה‬ ‫כלפי‬
Loc
IDA‫של‬ ‫לזיהוי‬ ‫בניסיון‬ ‫מאוד‬ ‫טובה‬ ‫עבודה‬ ‫עושה‬
‫מילים‬ ‫רצפי‬ ‫או‬ ‫משתנים‬ ‫שמות‬,‫זה‬ ‫מצליח‬ ‫והוא‬ ‫במידה‬
‫אחרי‬ ‫לפקודה‬ ‫מימין‬ ‫בשם‬ ‫יופיע‬;‫כהערה‬
‫הערות‬
‫ל‬ ‫פרט‬main,IDA‫שהן‬ ‫נוספות‬ ‫פונקציות‬ ‫גם‬ ‫מזהה‬
‫מהתוכנה‬ ‫חלק‬,‫הכותרת‬ ‫עם‬ ‫יופרדו‬ ‫האלו‬ ‫הפונקציות‬
=========subroutine=========
subroutines

‫נוספים‬ ‫חלונות‬
Hex View
‫אותה‬ ‫התוכנה‬ ‫של‬ ‫הקסהדצימאלית‬ ‫תצוגה‬ ‫מכילה‬
‫מריצים‬ ‫אנו‬,‫אם‬ ‫רואים‬ ‫שהיינו‬ ‫למה‬ ‫זהה‬ ‫התצוגה‬
‫קוראת‬ ‫בתוכנה‬ ‫הקובץ‬ ‫את‬ ‫פותחים‬ ‫היינו‬hex
Structures
‫ש‬ ‫הנתונים‬ ‫מבני‬ ‫את‬ ‫תכיל‬ ‫זו‬ ‫תצוגה‬IDA‫מזהה‬
‫מנצלת‬ ‫בודקים‬ ‫שאנו‬ ‫שהתוכנה‬
Imports
‫מנסה‬ ‫הנבדקת‬ ‫התוכנה‬ ‫אותן‬ ‫הפונקציות‬
‫חיצוניות‬ ‫מספריות‬ ‫ליבא‬
Exports
‫מיצאת‬ ‫התוכנה‬ ‫אותן‬ ‫הפונקציות‬–‫יותר‬
‫או‬ ‫קוד‬ ‫ספריות‬ ‫בניתוח‬ ‫רלוונטי‬DLL

‫ב‬ ‫נתקלים‬ ‫כאשר‬call‫מסויימת‬ ‫לפונקציה‬‫קפיצה‬ ‫או‬
‫ל‬loc‫המיקום‬ ‫על‬ ‫כפולה‬ ‫לחיצה‬ ‫ללחוץ‬ ‫ניתן‬ ‫מסויים‬
‫למסך‬ ‫יטען‬ ‫מיד‬ ‫והוא‬
‫ב‬IDA‫שונים‬ ‫קוד‬ ‫קטעי‬ ‫בין‬ ‫לעבור‬ ‫דרכים‬ ‫מספר‬ ‫קיימות‬,‫בזיכרון‬ ‫נשמרים‬ ‫המקומות‬ ‫כל‬
‫שמאל‬ ‫בצד‬ ‫העליון‬ ‫הכלים‬ ‫בסרגל‬ ‫החצים‬ ‫בעזרת‬ ‫אחורה‬ ‫או‬ ‫קדימה‬ ‫ולנווט‬ ‫כך‬ ‫אחר‬ ‫אליהם‬ ‫לחזור‬ ‫וניתן‬
‫כפולה‬ ‫לחיצה‬
‫ה‬ ‫מקש‬ ‫על‬ ‫לחיצה‬G‫להקליט‬ ‫המאפשר‬ ‫חלון‬ ‫פותחת‬
‫אליה‬ ‫לקפוץ‬ ‫ומיד‬ ‫כלשהי‬ ‫זיכרון‬ ‫כתובת‬
G
‫בקוד‬ ‫ניווט‬
‫חיפוש‬ ‫אופציות‬ ‫מספר‬ ‫קימות‬ ‫העליון‬ ‫הכלים‬ ‫בסרגל‬
‫פקודות‬ ‫לחפש‬ ‫המאפשרות‬,‫טקסט‬,‫בייטים‬ ‫של‬ ‫רצפים‬
‫בקוד‬ ‫לנווט‬ ‫דרך‬ ‫עוד‬ ‫ומאפשרות‬ ‫ועוד‬
search

‫שבהם‬ ‫בקוד‬ ‫המקומות‬ ‫כל‬ ‫את‬ ‫תציג‬ ‫הזאת‬ ‫האופציה‬
‫הנבחר‬ ‫למקום‬ ‫קריאה‬ ‫מתבצעת‬,‫ניתן‬ ‫מכן‬ ‫לאחר‬
‫זה‬ ‫למקום‬ ‫ולקפוץ‬ ‫האפשרויות‬ ‫באחרת‬ ‫לבחור‬
‫ב‬ ‫לנווט‬ ‫נוספת‬ ‫דרך‬IDA‫ב‬ ‫שימוש‬ ‫היא‬XREFs‫לכתובות‬ ‫איזכורים‬ ‫בעצם‬ ‫שהם‬‫מסויימות‬.
‫באופציה‬ ‫ולבחור‬ ‫הכתובת‬ ‫על‬ ‫ימנית‬ ‫לחיצה‬ ‫לבצע‬ ‫ניתן‬list cross reference to
Cross reference to
‫כלשהיא‬ ‫פונקציה‬ ‫ליד‬ ‫רואים‬ ‫אנחנו‬ ‫כאשר‬
code xref: _main+3p
‫מתוך‬ ‫לפונקציה‬ ‫קריאה‬ ‫שיש‬ ‫לדעת‬ ‫יכולים‬ ‫אנחנו‬main
‫ב‬offset‫של‬3
Code XREF
XREF
‫לפעמים‬IDA‫יש‬ ‫מיקום‬ ‫באיזה‬ ‫לדעת‬ ‫גם‬ ‫לנו‬ ‫תאפשר‬
‫באופן‬ ‫בזיכרון‬ ‫נמצאים‬ ‫אשר‬ ‫מסויימים‬ ‫למשתנים‬ ‫פניה‬
‫ל‬ ‫דומה‬code xref
Data XREF

‫ואת‬ ‫בתוכנה‬ ‫הפונקציות‬ ‫כל‬ ‫את‬ ‫תציג‬ ‫זו‬ ‫אופציה‬
‫בינהם‬ ‫הקישורים‬
‫ב‬IDA‫תחת‬ ‫תצוגה‬ ‫אפשרות‬ ‫עוד‬View‫שנקראת‬Graph,‫העליון‬ ‫הכלים‬ ‫מסרגל‬ ‫זו‬ ‫אופציה‬ ‫לבחור‬ ‫ניתן‬
‫לתהליך‬ ‫מתהליך‬ ‫שונות‬ ‫קריאות‬ ‫בין‬ ‫הקישורים‬ ‫את‬ ‫וויזואלית‬ ‫בצורה‬ ‫לראות‬ ‫שיאפשרו‬ ‫שונים‬ ‫גרפים‬ ‫וליצור‬
Function calls
‫לפונקציה‬ ‫המובילות‬ ‫הפונקציות‬ ‫כל‬ ‫של‬ ‫הגרף‬ ‫את‬ ‫תציג‬
‫הנוכחית‬
xrefs to
Graph View
‫מהפונקציה‬ ‫הנקראות‬ ‫הפונקציות‬ ‫כל‬ ‫של‬ ‫גרף‬ ‫תציג‬
xrefs from
‫להריץ‬ ‫היכול‬ ‫את‬ ‫למשתמש‬ ‫מעניקה‬ ‫זו‬ ‫אפשרות‬
‫שאילתת‬xref‫לרדת‬ ‫רמות‬ ‫כמה‬ ‫ולבחור‬ ‫יותר‬ ‫פרטנית‬
‫התוצאות‬ ‫כל‬ ‫את‬ ‫ותציג‬ ‫רקורסיבי‬ ‫חיפוש‬ ‫לבצע‬ ‫האם‬ ‫או‬
‫בגרף‬
User xrefs

‫אותה‬ ‫לאפיין‬ ‫והצלחנו‬ ‫פונקציה‬ ‫בתוכנה‬ ‫זיהינו‬ ‫אם‬
‫ולבחור‬ ‫הימני‬ ‫המקש‬ ‫עם‬ ‫עליה‬ ‫ללחוץ‬ ‫אפשר‬ ‫בהצלחה‬
‫באופציה‬rename,‫בכל‬ ‫יתעדכן‬ ‫שנבחר‬ ‫החדש‬ ‫השם‬
‫בהם‬ ‫הופיע‬ ‫הקודם‬ ‫שהשם‬ ‫המקומות‬
‫ש‬ ‫למרות‬IDA‫הניתוח‬ ‫במהלך‬ ‫ולפעמים‬ ‫הכל‬ ‫תזהה‬ ‫לא‬ ‫היא‬ ‫משתנים‬ ‫בזיהוי‬ ‫טובה‬ ‫עבודה‬ ‫עושה‬
‫בקלות‬ ‫יותר‬ ‫בקוד‬ ‫אותה‬ ‫לזהות‬ ‫בשביל‬ ‫שם‬ ‫שאפיינו‬ ‫לפונקציה‬ ‫לתת‬ ‫נרצה‬
‫ש‬ ‫למשתנה‬ ‫קריא‬ ‫שם‬ ‫לתת‬ ‫או‬IDA‫בתור‬ ‫מציגה‬EBP+ESI*4+8‫שב‬ ‫לב‬ ‫לשים‬ ‫יש‬ ‫אבל‬IDA‫אוצפיית‬ ‫אין‬"‫בטל‬"
Renaming Functions
‫שמות‬ ‫שינוי‬
‫כשאר‬ ‫כלל‬ ‫בדרך‬IDA‫תציג‬ ‫היא‬ ‫ערך‬ ‫איזשהו‬ ‫מזהה‬
‫המקש‬ ‫עם‬ ‫בלחיצה‬ ‫אבל‬ ‫הקסהדצימאלית‬ ‫בצורה‬ ‫אותו‬
‫למספר‬ ‫אותו‬ ‫להפוך‬ ‫בקלות‬ ‫אפשר‬ ‫הערך‬ ‫על‬ ‫הימני‬
‫דצימאלי‬,‫בינארית‬ ‫או‬ ‫טקסט‬...‫בצורך‬ ‫תלוי‬
Converting Values

IDC‫ב‬ ‫לניתוחים‬ ‫מובנות‬ ‫פונקציות‬ ‫מספר‬ ‫מכילה‬IDA
‫שתפקידם‬ ‫באינטרנט‬ ‫רבים‬ ‫סקריפטים‬ ‫למצוא‬ ‫וניתן‬
‫המנתח‬ ‫עבודת‬ ‫על‬ ‫להקל‬
‫את‬ ‫להרחיב‬ ‫ניתן‬IDA‫זיכרון‬ ‫מבני‬ ‫לנתח‬ ‫מנת‬ ‫על‬ ‫שונים‬ ‫סקריפטים‬ ‫לה‬ ‫ולהוסיף‬
‫נתונים‬ ‫של‬ ‫יעילה‬ ‫סריקה‬ ‫לבצע‬ ‫או‬.‫ב‬IDA‫שנקראת‬ ‫מובנת‬ ‫סקריפטים‬ ‫שפת‬ ‫יש‬IDC
‫סקריפטי‬ ‫בהרצת‬ ‫תומכת‬ ‫גם‬ ‫היא‬ ‫אך‬python
IDC
‫סקריפטים‬
IDAPyhton‫של‬ ‫אינטגרציה‬ ‫מביאה‬python‫לתוך‬
IDA‫בעזרת‬ ‫פעולות‬ ‫של‬ ‫רב‬ ‫מספר‬ ‫לעשות‬ ‫ומאפשר‬
‫ה‬api‫והספריות‬ ‫שלה‬idautils,idc,idaapi
IDAPython

int globalX = 1;
int globalY = 2;
int main(){
int localZ;
localZ = globalX + globalY;
printf("total = %dn", localZ);
return 0;}
‫עצמו‬ ‫הקוד‬
‫משתנים‬ ‫זיהוי‬
dword_41A000–‫הגלובאלי‬ ‫המשתנה‬globalX
dword_41A004–‫הגלובאלי‬ ‫המשתנה‬globalY
var_8–‫הלוקאלי‬ ‫המשתנה‬localY
sub_411334–‫הפונקציה‬printf
‫לב‬ ‫שימו‬:‫ה‬ ‫קריאות‬ ‫שני‬push‫לפני‬printf‫את‬ ‫טענות‬eax‫את‬ ‫שמכיל‬
‫להדפסה‬ ‫והטקסט‬ ‫התוצאה‬
‫ב‬ ‫הקוד‬IDA

int main(){
int apples = 5;
int bananas = 3;
int fruit;
apples = apples * 2;
bananas = bananas - 1;
fruit = apples + bananas;
bananas = fruit % 5;
return 0;}
‫ארטמטיות‬ ‫פעולות‬ ‫זיהוי‬
mov–‫ערכים‬ ‫של‬ ‫השמה‬ ‫מבצע‬
shl–‫עושים‬ ‫כאשר‬ ‫בבינארית‬shl‫ב‬ ‫ללהכפיל‬ ‫זהה‬ ‫זה‬ ‫אחת‬ ‫פעם‬2
sub–‫חיסור‬ ‫מבצע‬
idiv–‫של‬ ‫השמה‬ ‫יש‬ ‫מכן‬ ‫ולאחר‬ ‫חילוק‬ ‫מבצעת‬edx‫שמתקבלת‬ ‫היכן‬
‫השארית‬
‫לב‬ ‫שימו‬:‫כמו‬ ‫שפועלה‬ ‫כיוון‬idiv‫מוקדמת‬ ‫הכנה‬ ‫דורשת‬,‫גם‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫קורה‬ ‫מה‬ ‫להבין‬ ‫בשביל‬ ‫לפניה‬ ‫לפקודות‬

int main(){
char Name[5] = "leon";
if (Name == "lion") {
printf("cool");
}
else {printf("seat");}
return 0;}
‫התניות‬ ‫זיהוי‬If
dword_416094–‫הערך‬ ‫את‬ ‫מכיל‬"leon"
lea–‫הכתובת‬ ‫את‬ ‫מעבירה‬ebp+Name‫לתוך‬eax
cmp–‫בין‬ ‫השוואה‬ ‫מבצעת‬eax‫ל‬“lion”
jnz–‫ל‬ ‫קפיצה‬ ‫מתבצעת‬ ‫שווים‬ ‫לא‬ ‫והם‬ ‫במידה‬loc_413812
‫ל‬ ‫מגיע‬ ‫הקוד‬ ‫בסוף‬ ‫מתקיים‬ ‫התנאי‬ ‫האם‬ ‫משנה‬ ‫לא‬loc_41381f
‫לב‬ ‫שימו‬:IDA‫את‬ ‫אוטומטית‬ ‫זיהה‬ ‫לא‬printf,Name,‫ו‬length
‫האופציה‬ ‫בעזרת‬ ‫שונו‬ ‫שמות‬"rename”

int main(){
int age = 16;
if (age > 6) {
if (age > 18) {
printf("Mann");
}
else {printf("Jungen");}
}
else {printf("Kinder");}}
‫מקונן‬ ‫תנאי‬ ‫זיהוי‬
jle–‫הנבדק‬ ‫מהמספר‬ ‫קטן‬ ‫המשתנה‬ ‫עם‬ ‫קפיצה‬ ‫מבצע‬
‫בתצוגה‬ ‫צפייה‬ ‫ידי‬ ‫על‬ ‫מקונן‬ ‫לתנאי‬ ‫לב‬ ‫לשים‬ ‫מאוד‬ ‫קל‬ ‫זה‬ ‫במקרה‬
‫של‬ ‫הוויזואלית‬IDA

int main(){
for (int i = 0; i < 1000; i++) {
printf("Beep Boop");
}
int j =0;
}
‫לולאות‬ ‫זיהוי‬
‫של‬ ‫השמה‬ ‫מתבצעת‬ ‫ללולאה‬ ‫הכניסה‬ ‫לפני‬0‫לתוך‬var_8,‫מכן‬ ‫לאחר‬
‫עם‬ ‫השוואה‬ ‫מתבצעת‬3E8H(1000‫בהקסהדצימאלית‬.)‫עוד‬ ‫כל‬
‫לרוץ‬ ‫תמשיך‬ ‫הלולאה‬ ‫מתקיים‬ ‫לא‬ ‫התנאי‬.
loc_411810‫אחרי‬ ‫מיד‬ ‫נמצא‬loc_411807‫קפיצה‬ ‫נדרשת‬ ‫לא‬ ‫לכן‬
‫מס‬ ‫מקטע‬'1‫מס‬ ‫לקטע‬'2

‫דינאמי‬ ‫לניתוח‬ ‫מבוא‬
‫מתקדם‬
•Source level debugging
•Assembly level debugging
•Kernel level debugging
•Single stepping
•Break points
‫צריך‬ ‫מתקדם‬ ‫דינאמי‬ ‫ניתוח‬ ‫עובד‬ ‫איך‬ ‫להבין‬ ‫בשביל‬
‫מושגים‬ ‫מספר‬ ‫להכיר‬

Debugging‫את‬ ‫לנו‬ ‫יש‬ ‫כאשר‬ ‫מתאפשר‬ ‫הקוד‬ ‫ברמת‬
‫ל‬ ‫אותו‬ ‫לטעון‬ ‫ניתן‬ ‫ואז‬ ‫התוכנה‬ ‫של‬ ‫מקור‬ ‫הקוד‬IDE
‫ה‬ ‫בפונקציות‬ ‫ולהשתמש‬ ‫כלשהו‬debugging‫בשביל‬
‫אותו‬ ‫לנתח‬
Debugging‫פקודה‬ ‫הקוד‬ ‫על‬ ‫ולעבור‬ ‫בקוד‬ ‫שגיאות‬ ‫לאתר‬ ‫למפתחים‬ ‫לעזור‬ ‫שנועד‬ ‫תהליך‬ ‫הוא‬ ‫ככלל‬-‫פקודה‬.
‫דרך‬ ‫מורצת‬ ‫כלשהיא‬ ‫תוכנה‬ ‫כאשר‬debugger‫המשתנים‬ ‫של‬ ‫המצב‬ ‫את‬ ‫ולבחון‬ ‫שנרצה‬ ‫שלב‬ ‫בכל‬ ‫התוכנה‬ ‫את‬ ‫לעצור‬ ‫ניתן‬,‫זיכרון‬
‫אותנו‬ ‫שמעניין‬ ‫אחר‬ ‫פרמטר‬ ‫כל‬ ‫או‬.‫של‬ ‫חסותו‬ ‫תחת‬ ‫אבל‬ ‫שלנו‬ ‫המחשב‬ ‫על‬ ‫רצה‬ ‫התוכנה‬ ‫פעולת‬debugger
Source level
debugging
Debugging‫במקרה‬ ‫נפוץ‬ ‫יותר‬ ‫הוא‬ ‫האסמבלי‬ ‫ברמת‬
‫של‬reversing‫מקור‬ ‫הקוד‬ ‫את‬ ‫אין‬ ‫כלל‬ ‫שבדרך‬ ‫כיוון‬
‫זמין‬,‫של‬ ‫אסמבלי‬ ‫הקוד‬ ‫על‬ ‫תתבצע‬ ‫הריצה‬ ‫זה‬ ‫במקרה‬
‫במקביל‬ ‫פתוח‬ ‫גם‬ ‫שיהיה‬ ‫מומלץ‬ ‫ולכן‬ ‫התוכנה‬
‫ב‬disassembler‫לעקוב‬ ‫קל‬ ‫יותר‬ ‫שיהיה‬ ‫מנת‬ ‫על‬.
Assembly level

‫במצב‬‫שבו‬‫נתקל‬‫בפונקצית‬
‫מערכת‬‫שאנחנו‬‫לא‬‫צריכים‬‫לנתח‬
‫לעומק‬‫ניתן‬‫לדלג‬‫מעליה‬‫ולהמשיך‬
‫לפקודה‬‫הבאה‬‫אחרי‬‫שהפונקציה‬
‫חוזרת‬.‫יש‬‫להזהר‬‫הרי‬‫יכול‬‫להיות‬
‫שהפונקציה‬‫לעולם‬‫לא‬‫תחזור‬
‫ונצטרך‬‫להתחיל‬‫את‬‫הריצה‬
‫מתחלה‬.
‫הערה‬:‫עם‬‫פונקציית‬‫ה‬record/
replay‫של‬vmware‫ניתן‬‫לחזור‬
‫אם‬‫בטעות‬‫ביצענו‬step-over‫על‬
‫פונקציה‬‫שלא‬‫חוזרת‬.
Step-over
‫כאשר‬‫מתבצע‬Single stepping
‫והתוכנה‬‫מגיעה‬‫לקריאה‬‫של‬
‫פונקציה‬‫ניתן‬‫לבחור‬‫האם‬‫להמשיך‬
‫לתוך‬‫הפונקציה‬‫ולבצע‬single
stepping‫בתוכה‬‫או‬‫לדלג‬‫מעליה‬
‫ולהמשיך‬‫ישר‬‫לשלב‬‫שבו‬
‫הפונקציה‬‫מסתיימת‬‫והקוד‬‫ממשיך‬
‫מנקודת‬‫הקריאה‬.‫נרצה‬‫להכנס‬
‫לפונקציות‬‫שאנחנו‬‫חושדים‬‫שיש‬
‫להן‬‫חשיבות‬‫על‬‫מנת‬‫להבין‬‫מה‬
‫קורה‬‫בהן‬
Single stepping‫הוא‬‫הרצה‬‫של‬
‫התוכנה‬‫באופן‬‫שהריצה‬‫עוצרת‬
‫אחרי‬‫כל‬‫פקודה‬‫ומאפשר‬‫לנו‬‫לבחון‬
‫מה‬‫השתנה‬.‫האופציה‬‫הזאת‬‫יעילה‬
‫אך‬‫יש‬‫להיזהר‬‫שלא‬‫לרוץ‬‫על‬‫כל‬
‫הקוד‬‫אלא‬‫להתמקד‬‫בנקודות‬‫עניין‬
‫חשובות‬.
Step-in Single stepping
stepping
Debugger‫לראות‬ ‫מנת‬ ‫על‬ ‫פקודה‬ ‫אחרי‬ ‫פקודה‬ ‫של‬ ‫במצב‬ ‫תוכנה‬ ‫להריץ‬ ‫לנו‬ ‫מאפשר‬
‫בתוכנה‬ ‫שלב‬ ‫כל‬ ‫ביצוע‬ ‫אחרי‬ ‫קורה‬ ‫מה‬,‫מהן‬ ‫אחת‬ ‫כל‬ ‫לבדוק‬ ‫ואם‬ ‫מערכת‬ ‫פונקציות‬ ‫כולל‬ ‫זה‬ ‫דבר‬ ‫אבל‬
‫יקר‬ ‫זמן‬ ‫לבזבז‬ ‫יכול‬ ‫הדבר‬

Breakpoints‫מסוג‬‫זה‬‫הן‬‫ניצול‬
‫של‬software-breakpoints‫עם‬
‫תנאי‬.‫לדוגמא‬,‫ניתן‬‫להגיד‬
‫ל‬debugger‫לעצור‬‫כל‬‫פעם‬
‫שנקראת‬‫הפונקציה‬‫מסויימת‬‫אבל‬
‫רק‬‫עם‬‫פרמטר‬‫מסויים‬,‫כאשר‬
‫ה‬debugger‫יגיע‬‫לפונקציה‬‫הוא‬
‫יבדוק‬‫האם‬‫התנאי‬‫מתקיים‬,‫ורק‬
‫במידה‬‫וכן‬‫תתבצע‬‫עצירה‬.
Conditional-breakpoints
‫בסוג‬‫זה‬‫של‬breakpoint‫המחשב‬
‫משתמש‬‫באוגרים‬‫מיוחדים‬‫בשביל‬
‫לדעת‬‫מתי‬‫לבצע‬‫עצירה‬,‫בכל‬
‫הרצת‬‫פקודה‬‫יש‬‫רכיב‬‫שבודק‬
‫האם‬‫הכתובת‬‫של‬‫הפקודה‬‫זהה‬
‫לכתובת‬‫שהוא‬‫אמור‬‫לעצור‬‫בה‬‫לא‬
‫משנה‬‫מה‬‫הפקודה‬.Breakpoints
‫אלו‬‫יכולות‬‫לעזור‬‫מאוד‬‫בניתוח‬
‫קוד‬‫שמשכתב‬‫את‬‫עצמו‬,‫עם‬‫זאת‬
‫ישנם‬‫שני‬‫חסרונות‬:‫ניתן‬‫לקבוע‬‫רק‬
4hardware breakpoints
‫ובנוסף‬‫תוכנה‬‫יכולה‬‫לשנות‬‫את‬
‫הערך‬‫באוגרים‬‫ובכך‬‫להפריע‬
‫לניתוח‬
Breakpoints‫מהסוג‬‫הזה‬‫הן‬
‫הנפוצות‬‫ביותר‬,‫ה‬debugger
‫מאפשר‬‫עצירה‬‫של‬‫התוכנה‬‫על‬‫ידי‬
‫החלפת‬‫הבייט‬‫הראשון‬‫של‬‫הפקודה‬
‫ל‬0xCC‫דבר‬‫המקפיץ‬‫שגיאה‬
‫שמעבירה‬‫את‬‫השליטה‬‫על‬‫התוכנה‬
‫ל‬debugger‫וכאשר‬‫הוא‬‫ממשיך‬
‫הוא‬‫פשוט‬‫מתקן‬‫את‬‫הבייט‬
‫שהוחלף‬.‫ניתן‬‫לקבוע‬software
breakpoints‫ללא‬‫הגבלה‬‫בניתוח‬
‫תוכנה‬‫ב‬User-mode‫אך‬‫ב‬kernel-
mode‫מספר‬‫ה‬breakpoints‫יהיה‬
‫מוגבל‬
Hardware breakpoints Software breakpoints
Break points
Breakpoints‫הן‬"‫עצירה‬ ‫תחנות‬"‫לתוכנה‬ ‫להגדיר‬ ‫שאפשר‬,‫לבצע‬ ‫במקום‬single-stepping‫ל‬ ‫להגיד‬ ‫ניתן‬ ‫הקוד‬ ‫כל‬ ‫על‬debugger
‫שלנו‬"‫עד‬ ‫התוכנה‬ ‫את‬ ‫תריץ‬"...‫אלינו‬ ‫תחזור‬ ‫השליטה‬ ‫יתקיים‬ ‫הזה‬ ‫התנאי‬ ‫וכאשר‬.‫ל‬ ‫המשמשות‬ ‫התוכנות‬ ‫רוב‬debugging‫ישימו‬breakpoint
‫המשתמש‬ ‫באחריות‬ ‫הן‬ ‫העצירה‬ ‫נקודות‬ ‫שאר‬ ‫אך‬ ‫הריצה‬ ‫בתחילת‬ ‫אוטומטי‬.

‫שגיאה‬ ‫על‬ ‫להודיע‬ ‫יכולה‬ ‫התוכנה‬ ‫אלו‬ ‫בשגיאות‬
‫שנוצרת‬ ‫השגיאה‬ ‫של‬ ‫במקרה‬ ‫למשל‬ ‫או‬ ‫לרוץ‬ ‫ולהמשיך‬
‫מהפקודה‬0xCC‫ה‬debugger‫על‬ ‫שליטה‬ ‫לקחת‬ ‫ידע‬
‫ולעצור‬ ‫התוכנה‬ ‫של‬ ‫הריצה‬
Exceptions‫ריצה‬ ‫בזמן‬ ‫לקרות‬ ‫שיכול‬ ‫דבר‬ ‫הן‬ ‫ריצה‬ ‫שגיאות‬ ‫או‬(‫מבוסס‬ ‫גם‬ ‫ועליהם‬debugging.)‫שגיאות‬ ‫של‬ ‫סוגים‬ ‫שני‬ ‫ישנם‬-
‫ב‬ ‫חילוק‬ ‫כמו‬ ‫בהן‬ ‫לטפל‬ ‫יכולה‬ ‫התוכנה‬ ‫כלל‬ ‫שבדרך‬ ‫ראשונה‬ ‫ממעלה‬ ‫שגיאות‬0,‫שניה‬ ‫ממעלה‬ ‫שגיאות‬ ‫ויש‬-‫מצורף‬ ‫לא‬ ‫אם‬ ‫זה‬ ‫במקרה‬
debugger‫לחלוטין‬ ‫תקרוס‬ ‫התוכנה‬
First-chance exception
exceptions
‫כנראה‬ ‫אשר‬ ‫יותר‬ ‫רציניות‬ ‫שגיאות‬ ‫הן‬ ‫אלו‬ ‫שגיאות‬
‫שיש‬ ‫בקוד‬ ‫תקלות‬ ‫על‬ ‫מעידות‬ ‫באמת‬‫לפתור‬,‫לפעמים‬
‫בסביבה‬ ‫עבודה‬ ‫עקב‬ ‫לקפוץ‬ ‫יכולות‬ ‫זה‬ ‫מסוג‬ ‫שגיאות‬
‫טובה‬ ‫לא‬.
Second-chance exception

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

‫ב‬ ‫תוכנה‬ ‫להריץ‬ ‫פשוטה‬ ‫הכי‬ ‫הדרך‬OllyDbg‫פשוט‬ ‫היא‬
‫בשורת‬ ‫וצריך‬ ‫במידה‬ ‫פרמטרים‬ ‫ולהכניס‬ ‫אותה‬ ‫לפתוח‬
‫ה‬arguments.OllyDbg‫עצירה‬ ‫נקודות‬ ‫ישים‬
‫לתוכנה‬ ‫הכניסה‬ ‫בנקודות‬ ‫אוטומטית‬.
Ollydbg‫הוא‬debugger‫חינמי‬ ‫היותו‬ ‫עקב‬ ‫פופולרי‬,‫אוסף‬ ‫ובעל‬ ‫ונפוץ‬ ‫נוח‬Plug-ins‫שלו‬ ‫לפונקציאונליות‬ ‫הרבה‬ ‫שמוסיף‬.
‫של‬ ‫הקוד‬Ollydbg‫בגרסה‬1.1‫לחברת‬ ‫נמכר‬immunity security‫השם‬ ‫תחת‬ ‫להתפתח‬ ‫המשיך‬ ‫הוא‬ ‫שם‬ImmDbg
‫מסויימים‬ ‫במובנים‬ImmDbg‫דומה‬ ‫באופן‬ ‫עובדות‬ ‫התוכנות‬ ‫שתי‬ ‫כי‬ ‫אם‬ ‫נוח‬ ‫יותר‬ ‫להיות‬ ‫עשוי‬.
‫קובץ‬ ‫טעינת‬
OllyDbg
‫בגרסה‬2‫ל‬ ‫נוספו‬OllyDbg‫נוספות‬ ‫תמיכה‬ ‫אפשרויות‬
‫ב‬Breakpoints‫לנתח‬ ‫לעזור‬ ‫יכולים‬ ‫אשר‬ ‫שונים‬
‫ה‬ ‫הכניסה‬ ‫לפני‬ ‫לרוץ‬ ‫שיכולות‬ ‫פונקציות‬"‫רשמית‬"
‫לתוכנה‬.
OllyDbg 2.0

‫באופציית‬ ‫לבחור‬ ‫יש‬ ‫שרץ‬ ‫תהליך‬ ‫להוסיף‬ ‫מנת‬ ‫על‬
attach‫הראשי‬ ‫מהתפריט‬,‫תהליכים‬ ‫כמה‬ ‫ויש‬ ‫במידה‬
‫ב‬ ‫להשתמש‬ ‫יש‬ ‫השם‬ ‫אותו‬ ‫עם‬PID
‫לתוך‬ ‫תהליך‬ ‫לטעינת‬ ‫נוספת‬ ‫אופצייה‬OllyDbg‫המחשב‬ ‫על‬ ‫רץ‬ ‫שכבר‬ ‫קיים‬ ‫תהליך‬ ‫הוספת‬ ‫ידי‬ ‫על‬ ‫היא‬,‫הנוכחי‬ ‫התהליך‬
‫לשליטתינו‬ ‫יעבור‬ ‫שלו‬ ‫הריצה‬ ‫והמשך‬ ‫המסך‬ ‫על‬ ‫ויופיע‬ ‫יעצור‬.
Attach
‫קיים‬ ‫לתהליך‬ ‫צירוף‬
‫ש‬ ‫כיוון‬OllyBbg‫התוכנה‬ ‫של‬ ‫הנוכחי‬ ‫במיקום‬ ‫עוצר‬
‫הרצה‬,‫סיפרייה‬ ‫בתוך‬ ‫גם‬ ‫להיות‬ ‫יכול‬ ‫הזה‬ ‫המיקום‬
‫חיצונית‬,‫לקבוע‬ ‫ניתן‬breakpoint‫ה‬ ‫בפונקציה‬main
‫תחזור‬ ‫שהתוכנה‬ ‫עד‬ ‫לרוץ‬ ‫ולהמשיך‬
Breakpoints

‫אך‬ ‫הרצה‬ ‫התוכנה‬ ‫של‬ ‫האסמבלי‬ ‫קוד‬ ‫יוצג‬ ‫זה‬ ‫בחלון‬
‫ש‬ ‫והשמות‬ ‫ההערות‬ ‫ללא‬IDA‫להחליף‬ ‫יודעת‬
‫ל‬OllyDbg‫ל‬ ‫מחולקת‬ ‫אשר‬ ‫ראשית‬ ‫תצוגה‬4‫הריצה‬ ‫אופציות‬ ‫את‬ ‫מכיל‬ ‫אשר‬ ‫עליון‬ ‫כלים‬ ‫וסרגל‬ ‫שונים‬ ‫תוכן‬ ‫אזורי‬
‫אזור‬1
‫שלהם‬ ‫והתוכן‬ ‫המעבד‬ ‫של‬ ‫האוגרים‬ ‫יוצגו‬ ‫זה‬ ‫בחלון‬
‫אזור‬2
‫ה‬ ‫יוצג‬ ‫זה‬ ‫בחלון‬Stack‫הנוכחי‬ ‫התהליך‬ ‫של‬
‫אזור‬4
‫יוצג‬ ‫זה‬ ‫בחלון‬dump‫בתצוגת‬ ‫הזיכרון‬ ‫של‬hex‫ו‬ascii
‫אזור‬3

‫ב‬ ‫לבחור‬ ‫ניתן‬ ‫הזיכרון‬ ‫או‬ ‫הקוד‬ ‫בעריכת‬Edit Binary
‫הבינארי‬ ‫הקוד‬ ‫את‬ ‫ולעדכן‬,‫האופציה‬ ‫עם‬keep size
‫הקודם‬ ‫התוכן‬ ‫שתפס‬ ‫המקום‬ ‫של‬ ‫בגודל‬ ‫מקום‬ ‫ישמר‬
‫של‬ ‫השדות‬ ‫בכל‬ ‫המידע‬ ‫את‬ ‫לערוך‬ ‫ניתן‬OllyDbg‫דרכים‬ ‫במספר‬.‫בזהירות‬ ‫הדברים‬ ‫את‬ ‫שעורכים‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫לקרוס‬ ‫יכולה‬ ‫התוכנה‬ ‫אחרת‬.
Edit binary
‫ולבחור‬ ‫הימני‬ ‫המקש‬ ‫עם‬ ‫ללחוץ‬ ‫ניתן‬ ‫אוגרים‬ ‫בעריכת‬
modify‫חדש‬ ‫ערך‬ ‫ולהכניס‬
modify
‫מידע‬ ‫עריכת‬

‫ה‬ ‫באזור‬ ‫נטענה‬ ‫התוכנה‬0x0C0000‫בזיכרון‬,‫כיוון‬
‫ה‬ ‫שאזור‬0x400000‫תפוס‬ ‫כנראה‬ ‫היה‬
‫בין‬ ‫שהטעינה‬ ‫לב‬ ‫לשים‬ ‫יש‬disassembler‫ל‬debugger‫שונה‬ ‫היא‬,‫אליו‬ ‫להיטען‬ ‫תעדיף‬ ‫שהיא‬ ‫בזיכרון‬ ‫מקום‬ ‫יש‬ ‫תוכנה‬ ‫לכל‬
‫ו‬disassembler‫בד‬"‫ש‬ ‫בעוד‬ ‫המועדף‬ ‫למקום‬ ‫טעינה‬ ‫ידמה‬ ‫כ‬debugger‫לקרות‬ ‫ויכול‬ ‫לזיכרון‬ ‫בפועל‬ ‫התוכנה‬ ‫את‬ ‫יטען‬
‫אחר‬ ‫במקום‬ ‫תטען‬ ‫והתוכנה‬ ‫זמין‬ ‫יהיה‬ ‫לא‬ ‫המועדף‬ ‫שהמקום‬
OllyDbg
‫ה‬ ‫באזור‬ ‫נטענה‬ ‫התוכנה‬0x400000‫בזיכרון‬,‫ניתן‬ ‫אך‬
‫של‬ ‫האופציה‬ ‫באמצעות‬ ‫זאת‬ ‫לשנות‬manual load
IDA
‫לזיכרון‬ ‫טעינה‬

‫ל‬ ‫עד‬ ‫התוכנה‬ ‫את‬ ‫תריץ‬ ‫הזאת‬ ‫הפקודה‬breakpoint
‫הבא‬,‫הפסקה‬ ‫ללא‬ ‫תרוץ‬ ‫התוכנה‬ ‫אחד‬ ‫קיים‬ ‫לא‬ ‫אם‬
‫מקשים‬ ‫קיצורי‬ ‫בעזרת‬ ‫לעשות‬ ‫אפשר‬ ‫בתוכנה‬ ‫הקפיצות‬ ‫רוב‬ ‫את‬.‫לא‬ ‫למקומות‬ ‫לקפוץ‬ ‫שלא‬ ‫לב‬ ‫לשים‬ ‫יש‬ ‫זאת‬ ‫עם‬
‫הניתוח‬ ‫את‬ ‫לסבך‬ ‫יכול‬ ‫זה‬ ‫שדבר‬ ‫כיוון‬ ‫חשובה‬ ‫פונקציה‬ ‫לפספס‬ ‫או‬ ‫רצויים‬
run
‫חזרה‬ ‫לפני‬ ‫האחרונה‬ ‫הפקודה‬ ‫עד‬ ‫תרוץ‬ ‫התוכנה‬
‫הנוכחית‬ ‫מהפונקציה‬
Execute till return
‫בתוכנה‬ ‫זרימה‬
‫של‬ ‫הפונקציונליות‬trace‫הריצה‬ ‫את‬ ‫להקליט‬ ‫מאפשרת‬
‫שוב‬ ‫אותה‬ ‫לבחון‬ ‫מנת‬ ‫על‬ ‫אחורה‬ ‫ולחזור‬ ‫הפונקציה‬ ‫על‬,
‫אחרת‬ ‫בדרך‬ ‫וללכת‬ ‫לחזור‬ ‫ניתן‬ ‫שלא‬ ‫לב‬ ‫לשים‬ ‫יש‬
Trace into/over
‫משתמש‬ ‫לקוד‬ ‫לחזרה‬ ‫עד‬ ‫תרוץ‬ ‫התוכנה‬(‫ספריות‬ ‫לא‬
‫מערכת‬)
Execute till user code

‫מחדל‬ ‫כברירת‬OllyDbg‫להשתמש‬ ‫תעדיף‬
‫ב‬software breakpoint‫דרך‬ ‫זאת‬ ‫לשנות‬ ‫ניתן‬
‫תהיה‬ ‫המחדל‬ ‫שברירת‬ ‫כך‬ ‫ההגדרות‬hardware
breakpoint‫משיטות‬ ‫להתחמק‬ ‫לעזור‬ ‫היכול‬ ‫דבר‬
anti-debugging
‫ב‬OllyDbg‫לקבוע‬ ‫ניתן‬breakpoints‫דרכים‬ ‫במספר‬,‫המקשים‬ ‫קיצור‬ ‫דרך‬ ‫או‬F2‫ל‬breakpoint‫ו‬ ‫רגיל‬Shift+F2‫ל‬conditional breakpoint
‫ה‬ ‫מתפריט‬ ‫ולבחור‬ ‫בזיכרון‬ ‫אזור‬ ‫או‬ ‫קוד‬ ‫קטע‬ ‫על‬ ‫הימני‬ ‫המקש‬ ‫עם‬ ‫ללחוץ‬ ‫ניתן‬ ‫בנוסף‬breakpoints‫יותר‬ ‫מתקדמות‬ ‫באפשרויות‬
‫המחדל‬ ‫ברירת‬
‫הוספת‬Breakpoints
Breakpoints‫בתנאים‬ ‫שיפעלו‬ ‫לקבוע‬ ‫ניתן‬ ‫זה‬ ‫מסוג‬
‫למשל‬ ‫מסויימים‬on-access, on-read, on-write,
on-execute‫אנחנו‬ ‫כאשר‬ ‫שימושי‬ ‫להיות‬ ‫היכול‬ ‫דבר‬
‫בכמות‬ ‫לצמצם‬ ‫ורוצים‬ ‫ספציפית‬ ‫פעולה‬ ‫מחפשים‬
‫העצירות‬
Memory/Hardware breakpoint

‫ב‬ ‫נוחה‬ ‫אפשרות‬OllyDbg‫פרמטרים‬ ‫לטעון‬ ‫היא‬
‫ל‬ ‫הקריאה‬ ‫לפני‬ ‫לזיכרון‬DLL‫איתחול‬ ‫לבצע‬ ‫כן‬ ‫וכמו‬
‫אמיתית‬ ‫ריצה‬ ‫לדמות‬ ‫בכדי‬ ‫השונים‬ ‫לאוגרים‬
‫ב‬OllyDbg‫קבצי‬ ‫של‬ ‫מתקדם‬ ‫ניתוח‬ ‫לבצע‬ ‫האפשרות‬ ‫קיימת‬DLL,‫דרך‬ ‫להפעיל‬ ‫ניתן‬ ‫עצמאית‬ ‫להרצה‬ ‫נועדו‬ ‫לא‬ ‫אלו‬ ‫שקבצים‬ ‫כיוון‬
‫התפריט‬debug > call dll export‫אחריהן‬ ‫מעקב‬ ‫לבצע‬ ‫מנת‬ ‫על‬ ‫ספציפיות‬ ‫לפונקציות‬ ‫ולקרוא‬
arguments
‫ניתוח‬DLL
‫ב‬ ‫להרצה‬ ‫בנוסף‬debugger,OllyDbg‫לראות‬ ‫מאפשר‬
‫בתוך‬ ‫הפונקציות‬ ‫של‬ ‫הקוד‬ ‫את‬disassembler‫עם‬ ‫אך‬
‫ב‬ ‫במקביל‬ ‫הקוד‬ ‫את‬ ‫לנתח‬ ‫עדיף‬ ‫זאת‬IDA‫בגלל‬
‫שלה‬ ‫המתקדמות‬ ‫הקוד‬ ‫זיהוי‬ ‫אופציות‬
Follow in disassembler

Back trace‫אחורה‬ ‫או‬ ‫קדימה‬ ‫לנווט‬ ‫האפשרות‬ ‫היא‬
‫המקשים‬ ‫בעזרת‬ ‫בפקודות‬+-‫רק‬ ‫לנווט‬ ‫ניתן‬ ‫אך‬
‫בהם‬ ‫היינו‬ ‫שכבר‬ ‫לפקודות‬
Tracing‫שמספקת‬ ‫חשובה‬ ‫אופציה‬ ‫היא‬OllyDbg‫בשנית‬ ‫עליהם‬ ‫לעבור‬ ‫ואז‬ ‫הניתוח‬ ‫של‬ ‫חלקים‬ ‫להקליט‬ ‫מאפשרת‬ ‫אשר‬.
‫ל‬ ‫הוגדר‬ ‫לא‬ ‫שאם‬ ‫לב‬ ‫לשים‬ ‫חשוב‬OllyDbg‫ברור‬ ‫באופן‬,‫יוקלטו‬ ‫לא‬ ‫באוגרים‬ ‫הערכים‬
Back trace
Tracing
‫ה‬ ‫תפריט‬ ‫דרך‬view‫של‬ ‫הרצף‬ ‫את‬ ‫לראות‬ ‫ניתן‬
‫לנקודה‬ ‫להגיע‬ ‫מנת‬ ‫על‬ ‫שבוצעו‬ ‫לפונקציות‬ ‫הקריאות‬
Call trace
‫קוד‬ ‫אזור‬ ‫של‬ ‫בחירה‬ ‫דרך‬ ‫זו‬ ‫אופציה‬ ‫להפעיל‬ ‫ניתן‬
‫ובחירת‬Run trace‫הימני‬ ‫המקש‬ ‫על‬ ‫בלחיצה‬,
‫הקוד‬ ‫עבור‬ ‫הערכים‬ ‫שינויי‬ ‫יוקלטו‬ ‫כן‬ ‫זה‬ ‫במקרה‬
‫הנבחר‬
Run trace

OllyDump‫אשר‬ ‫הנפוצים‬ ‫התוספים‬ ‫אחד‬ ‫הוא‬
‫נפרד‬ ‫הרצה‬ ‫כקובץ‬ ‫מסוים‬ ‫תהליך‬ ‫לשמור‬ ‫מאפשר‬,
‫ל‬ ‫הוא‬ ‫זה‬ ‫בתוסף‬ ‫העיקרי‬ ‫השימוש‬unpacking
‫ל‬OllyDbg‫מהאינטרנט‬ ‫להורדה‬ ‫הניתנים‬ ‫נוספים‬ ‫תוספים‬ ‫של‬ ‫רחב‬ ‫ומגוון‬ ‫סטאנדארטים‬ ‫תוספים‬ ‫מספר‬.
‫קבצי‬ ‫של‬ ‫בתצורה‬ ‫מגיעים‬ ‫התוספים‬DLL‫של‬ ‫הראשית‬ ‫בתיקייה‬ ‫לשים‬ ‫שניתן‬OllyDbg
OllyDump
Plugins
Hide Debugger‫שיטות‬ ‫כמה‬ ‫שמנצל‬ ‫תוסף‬ ‫הוא‬
‫מפונקציות‬ ‫למנוע‬ ‫היא‬ ‫שמטרתן‬Anti debugging
‫את‬ ‫לזהות‬OllyDbg
Hide Debugger
Command line‫הפונקציונליות‬ ‫את‬ ‫להפעיל‬ ‫מאפשר‬
‫של‬OllyDbg‫הדומה‬ ‫בצורה‬ ‫פקודות‬ ‫חלון‬ ‫דרך‬
‫ל‬WinDbg
Command line

‫ש‬ ‫כיוון‬ImmDbg‫של‬ ‫מהקוד‬ ‫שנולד‬ ‫פיתוח‬ ‫הוא‬
OllyDbg‫שניהם‬ ‫על‬ ‫להרצה‬ ‫ניתנים‬ ‫מהתוספים‬ ‫רבים‬
‫תיקונים‬ ‫מספר‬ ‫ידרשו‬ ‫חלק‬ ‫כי‬ ‫אם‬
ImmDbg‫הוא‬rebranding‫של‬ ‫לקוד‬ ‫שנעשה‬OllyDbg‫בגרסה‬1.1‫חברת‬ ‫ידי‬ ‫על‬ ‫שנקנה‬ ‫לאחר‬Immunity
‫ב‬ ‫היתרון‬ ‫עם‬ ‫זהה‬ ‫כמעט‬ ‫התוכנות‬ ‫בין‬ ‫הפונקציונליות‬ImmDgb‫פייתון‬ ‫ממשק‬ ‫של‬ ‫באינטגרציה‬
plugins
ImmDbg
ImmDbg‫באופן‬ ‫פייטון‬ ‫סקריפטי‬ ‫של‬ ‫הרצה‬ ‫מאפשר‬
‫ו‬ ‫נוח‬api‫שמאפשר‬ ‫מסודר‬scriptable debugging
‫ב‬ ‫אפשרית‬ ‫אשר‬ ‫אופציה‬OllyDbg‫תוספים‬ ‫דרך‬
Python
‫שמאפשר‬ ‫נוסף‬ ‫שימוש‬ImmDbg‫הוא‬ ‫בפייתון‬
‫של‬ ‫לאלו‬ ‫הדומים‬ ‫גרפים‬ ‫ליצור‬ ‫האפשרות‬IDA‫מנת‬ ‫על‬
‫מסודרת‬ ‫בצורה‬ ‫הקוד‬ ‫את‬ ‫לראות‬
Python graphing

‫עם‬ ‫תוכנה‬ ‫לטעון‬ ‫מנת‬ ‫על‬GDB‫מתבצעת‬ ‫הפעולה‬
‫בפקודה‬ ‫שימוש‬ ‫ידי‬ ‫על‬ ‫בקלות‬gdb name‫מכן‬ ‫ולאחר‬
‫התוכנה‬ ‫ריצת‬ ‫על‬ ‫לשליטה‬ ‫פקודות‬ ‫הכנסת‬
‫ה‬GNU Project Debugger‫ה‬ ‫הוא‬debugger‫פלטפורמות‬ ‫על‬ ‫לשימוש‬ ‫ביותר‬ ‫הפופולארי‬‫הלינוקס‬,
‫ב‬ ‫וגם‬ ‫רבות‬ ‫תכנות‬ ‫בשפות‬ ‫גם‬ ‫רבה‬ ‫תמיכה‬ ‫בתוכו‬ ‫מכיל‬ ‫הוא‬kernel debugging‫מתבצע‬ ‫בו‬ ‫השימוש‬ ‫כלל‬
‫של‬ ‫הפקודות‬ ‫ממשק‬ ‫מתוך‬‫הלינוקס‬.
‫תוכנה‬ ‫הרצת‬
GDB
GDB‫ביצוע‬ ‫מאפשר‬debugging‫כאשר‬ ‫מערכת‬ ‫על‬
‫ה‬GDB‫אחרת‬ ‫מערכת‬ ‫על‬ ‫רץ‬ ‫עצמו‬.‫יעיל‬ ‫זה‬ ‫דבר‬
‫מוטמעות‬ ‫מערכות‬ ‫לניתוח‬ ‫במיוחד‬
Remote debugging
‫ל‬GDB‫תוכנות‬ ‫קיימות‬ ‫וכתחליף‬ ‫כלל‬ ‫גרפי‬ ‫ממשק‬ ‫אין‬
debugger‫כגון‬ ‫נוספות‬DDD‫או‬ultraGDB‫שנועדו‬
‫לה‬ ‫הזקוקים‬ ‫לאלו‬ ‫הגרפיקה‬ ‫את‬ ‫לספק‬
DDD

‫הפקודה‬info‫בצרוף‬breakpoints, registers, args,
threads‫המתבקש‬ ‫הנושא‬ ‫אודות‬ ‫המידע‬ ‫את‬ ‫תציג‬,
‫לדוגמא‬breakpoints‫ה‬ ‫כל‬ ‫את‬ ‫תציג‬breakpoints
‫אחת‬ ‫בכל‬ ‫בוצעו‬ ‫עצירות‬ ‫וכמה‬ ‫שהוגדרו‬
‫ב‬GDB‫מידע‬ ‫להצגת‬ ‫פקודות‬ ‫ביניהם‬ ‫קטגוריות‬ ‫לכמה‬ ‫המתחלקות‬ ‫פקודות‬ ‫מספר‬,‫קביעת‬breakpoints
‫ועוד‬ ‫לזיכרון‬ ‫גישה‬
info
Basic commands
Single stepping‫הפקודה‬ ‫באמצעות‬ ‫יתבצע‬s‫או‬si
‫באמצאות‬ ‫פונקציה‬ ‫לתוך‬ ‫וכניסה‬n‫או‬ni.‫את‬ ‫לראות‬ ‫ניתן‬
‫פקודות‬‫האסמבלי‬‫הפקודה‬ ‫ידי‬ ‫על‬ ‫הבאות‬x/10i‫כאשר‬
10‫הפקודות‬ ‫כמות‬ ‫היא‬‫לצפיה‬
stepping
‫כגון‬ ‫אופציות‬ ‫ולכבות‬ ‫להדליק‬ ‫מאפשרת‬logging
‫הקוד‬ ‫של‬ ‫הדפסה‬ ‫פורמט‬,‫האפשרויות‬ ‫על‬ ‫ללמוד‬ ‫ניתן‬
‫ה‬ ‫תפריט‬ ‫דרך‬help
set

‫בפונקציה‬ ‫או‬ ‫בכתובת‬ ‫בתוכנה‬ ‫עצירה‬ ‫נקודת‬ ‫תיצור‬
‫כפרמטר‬ ‫שמועברת‬,‫הוספת‬ ‫אם‬if‫הפרמטר‬ ‫אחרי‬
‫הראשון‬.‫ל‬ ‫העצירה‬ ‫את‬ ‫להפוך‬ ‫ובכך‬ ‫תנאי‬ ‫להוסיף‬ ‫ניתן‬
conditional breakpoint
‫ב‬GDB‫ה‬ ‫על‬ ‫השליטה‬breakpoints‫ה‬ ‫פקודת‬ ‫באמצאות‬ ‫מתבצעת‬ ‫בתוכנה‬break‫יכולה‬ ‫אשר‬
‫תנאים‬ ‫או‬ ‫זיכרון‬ ‫כתובות‬ ‫כגון‬ ‫לעצירה‬ ‫שונים‬ ‫תנאים‬ ‫כפרמטר‬ ‫לקבל‬,‫של‬ ‫מיוחדת‬ ‫אופציה‬ ‫עם‬break main
‫לתוכנה‬ ‫בכניסה‬ ‫עצירה‬ ‫נקודת‬ ‫שתשים‬
break
breakpoints
‫הפקודה‬clear‫למחוק‬ ‫מאפשרת‬breakpoint‫על‬ ‫ספציפי‬
‫לה‬ ‫שמועברים‬ ‫הפרמטרים‬ ‫פי‬,‫מעוניינים‬ ‫ואנחנו‬ ‫במידה‬
‫ה‬ ‫כל‬ ‫את‬ ‫למחוק‬breakpoints‫ב‬ ‫להשתמש‬ ‫ניתן‬delete
clear
‫ניתן‬ ‫הראשונה‬ ‫בפעם‬ ‫התוכנה‬ ‫את‬ ‫להריץ‬ ‫מנת‬ ‫על‬
‫בפקודה‬ ‫להשתמש‬r‫ב‬ ‫עצירה‬ ‫ולאחר‬breakpoint
‫כלשהו‬.‫ה‬ ‫עד‬ ‫לרוץ‬ ‫מנת‬ ‫על‬breakpoint‫יש‬ ‫הבא‬
‫בפקודה‬ ‫להשתמש‬c
continue

x/30hw addr‫את‬ ‫תציג‬‫את‬30‫החל‬ ‫הכתובות‬
‫מ‬addr‫בפורמט‬‫הקסהדצימאלי‬‫המידה‬ ‫יחידת‬ ‫כאשר‬
‫היא‬word.‫הכתיבה‬ ‫האפשרויות‬ ‫כל‬ ‫על‬ ‫לקרוא‬ ‫ניתן‬
‫שונות‬‫כאן‬.
‫ב‬ ‫הזיכרון‬ ‫ובתוכן‬ ‫במשתנים‬ ‫צפייה‬GDB‫עיקריות‬ ‫פקודות‬ ‫שתי‬ ‫בעזרת‬ ‫מתבצעת‬x/‫ו‬p/
‫ה‬ ‫לאחר‬ ‫כאשר‬-/‫פרמטרים‬ ‫מספר‬ ‫יהיו‬.p‫שונות‬ ‫בתצורות‬ ‫והדפסתם‬ ‫שונים‬ ‫משתנים‬ ‫של‬ ‫לבדיקה‬ ‫תשמש‬
‫ואילו‬e‫הזיכרון‬ ‫כתובות‬ ‫להצגת‬ ‫תשמש‬
x/parms
‫בזיכרון‬ ‫צפייה‬
P‫המועברת‬ ‫בתצורה‬ ‫ספציפי‬ ‫משתנה‬ ‫תדפיס‬
‫כפרמטר‬p/x‫בצורה‬ ‫הפרמטר‬ ‫את‬ ‫תדפיס‬‫הקסה‬
‫דצימאלית‬,‫בעוד‬p/d‫כמספר‬ ‫אותו‬ ‫תדפיס‬,‫על‬
‫של‬ ‫בדוקומנטציה‬ ‫לקרוא‬ ‫ניתן‬ ‫הבאות‬ ‫האפשרויות‬
GDB
p/parms

Rootkits‫נוזקות‬ ‫להסתיר‬ ‫הוא‬ ‫תפקידן‬ ‫אשר‬ ‫נוזקות‬ ‫הן‬
‫אחרות‬,‫רצות‬ ‫הן‬ ‫מוצלחת‬ ‫בצורה‬ ‫זאת‬ ‫לעשות‬ ‫מנת‬ ‫על‬
‫ב‬kernel‫ב‬ ‫ולא‬user-space
‫ה‬ ‫תהליך‬ ‫את‬ ‫לקחת‬ ‫נצטרך‬ ‫לפעמים‬debugging‫קדימה‬ ‫אחד‬ ‫שלב‬,‫המחשב‬ ‫של‬ ‫יותר‬ ‫הנמוכות‬ ‫לרמות‬ ‫ולרדת‬.
‫ה‬ ‫ברמת‬ ‫רצים‬ ‫אשר‬ ‫תהליכים‬ ‫לחקור‬ ‫נצטרך‬ ‫מסויימים‬ ‫במקרים‬kernel‫עצמו‬ ‫בפני‬ ‫אתגר‬ ‫מהווה‬ ‫זה‬ ‫ודבר‬ ‫המשתמש‬ ‫ברמת‬ ‫ולא‬,
‫נשים‬ ‫אם‬ ‫הרי‬breakpoint‫ב‬kernel‫ב‬ ‫להמשיך‬ ‫נוכל‬ ‫ולא‬ ‫מלעבוד‬ ‫תחדל‬ ‫המערכת‬ ‫כל‬debugging
rootkits
Kernel debugging
‫ידי‬ ‫על‬ ‫להתבצע‬ ‫תצטרך‬ ‫דרייברים‬ ‫של‬ ‫חקירה‬ ‫גם‬
debugging‫ב‬kernel‫רצים‬ ‫הדרייברים‬ ‫שם‬ ‫שהרי‬
‫דרייברים‬
‫ה‬ ‫לבעיית‬ ‫הפיתרון‬debugging‫את‬ ‫להריץ‬ ‫הוא‬
‫סיריאלי‬ ‫בפורט‬ ‫מחוברת‬ ‫היא‬ ‫כאשר‬ ‫הנבדקת‬ ‫המכונה‬
(‫קיים‬ ‫עדיין‬ ‫זה‬)‫ה‬ ‫רץ‬ ‫עליו‬ ‫אחר‬ ‫למחשב‬debugger
‫הפיתרון‬

‫הקובץ‬ ‫את‬ ‫לערוך‬ ‫יש‬ ‫ווינדוס‬ ‫במערכות‬boot.ini
‫ל‬ ‫ולהוסיף‬bootmenu‫עם‬ ‫הדלקה‬ ‫אופציית‬
‫הפרמטרים‬/debug‫שמאפשר‬debugging,
/debugport=COM1‫שנגדיר‬ ‫הסריאלי‬ ‫הפורט‬ ‫שהוא‬
/baudrate=115200‫נתונים‬ ‫יעברו‬ ‫שבו‬ ‫הקצב‬ ‫שהוא‬
‫ל‬ ‫סביבה‬ ‫לארגן‬ ‫ביותר‬ ‫הנוחה‬ ‫הדרך‬kernel debugging‫ווירטואליות‬ ‫מכונות‬ ‫באמצאות‬ ‫היא‬,‫יהיה‬ ‫זה‬ ‫דבר‬
‫שלבים‬ ‫בשני‬ ‫כרוך‬,‫המכונה‬ ‫את‬ ‫להגדיר‬ ‫השני‬ ‫והשלב‬ ‫סיריאלי‬ ‫פורט‬ ‫הווירטואלית‬ ‫למכונה‬ ‫להגדיר‬ ‫הוא‬ ‫הראשון‬ ‫השלב‬
‫שתאפשר‬ ‫כך‬ ‫הווירטואלית‬kernel debugging
windows
‫מוקדמות‬ ‫הכנות‬
‫ב‬ ‫קיימת‬ ‫לינוקס‬ ‫במערכות‬kernel‫פונקציונליות‬
‫שנקראת‬KASLR‫אך‬ ‫מהתקפות‬ ‫להגן‬ ‫נועדה‬ ‫אשר‬
‫ל‬ ‫מפריע‬debugging.‫מחדש‬ ‫ולקמפל‬ ‫אותה‬ ‫לבטל‬ ‫יש‬
‫הבוט‬ ‫קבצי‬ ‫את‬,‫של‬ ‫במקרה‬grub‫מתבצעת‬ ‫הפעולה‬
‫הוספת‬ ‫ידי‬ ‫על‬nokaslr‫ב‬
GRUB_CMDLINE_LINUX_DEFAULT="splash
quiet nokaslr"
linux

‫של‬ ‫בהגדרות‬ ‫נוסיף‬ ‫ווינדוס‬ ‫מערכת‬ ‫לנתח‬ ‫מנת‬ ‫על‬
‫הווירטואלית‬ ‫המכונה‬searial port‫ל‬ ‫אותו‬ ‫וננתב‬pipe
‫בשם‬.pipecom_1‫ונגדיר‬yield cpu on pool
‫כפעיל‬
‫ה‬ ‫את‬ ‫לחקור‬ ‫מנת‬ ‫על‬kernel‫משלנו‬ ‫הגדרות‬ ‫מספר‬ ‫ולהוסיף‬ ‫ווירטואלית‬ ‫כמכונה‬ ‫אותו‬ ‫להרים‬ ‫נרצה‬ ‫מסויים‬ ‫מחשב‬ ‫של‬
pipe
‫ווירטואלית‬ ‫סביבה‬ ‫הכנת‬
‫ב‬VMware‫להגדיר‬ ‫ניתן‬stub‫לא‬ ‫שהוא‬debugger
‫הווירטואלית‬ ‫למכונה‬ ‫שמאפשר‬ ‫פרוטוקול‬ ‫אלא‬ ‫שלם‬
‫דיבגר‬ ‫עם‬ ‫לדבר‬,‫בקובץ‬ ‫ידנית‬ ‫זו‬ ‫אופציה‬ ‫לערוך‬ ‫צריך‬
‫ה‬vmx‫השורה‬ ‫הוספת‬ ‫ידי‬ ‫על‬
debugStub.listen.guest64 = 1
stub
‫לחקור‬ ‫רוצים‬ ‫אנו‬ ‫אותו‬ ‫פיזי‬ ‫במחשב‬ ‫ומדובר‬ ‫במידה‬
‫בכלי‬ ‫ולהשתמש‬ ‫שלו‬ ‫הכונן‬ ‫את‬ ‫לשכפל‬ ‫ניתן‬qemu-
img‫ווירטואלית‬ ‫למכונה‬ ‫אותו‬ ‫להפוך‬ ‫מנת‬ ‫על‬
Qemu-img

‫ה‬ ‫לקבצי‬ ‫והסבר‬ ‫קישור‬ ‫למצוא‬ ‫ניתן‬symbols‫של‬
‫מיקרוסופט‬‫כאן‬,‫באמצעות‬ ‫הקבצים‬ ‫את‬ ‫לקשר‬ ‫ניתן‬
‫והשימוש‬ ‫הורדתם‬ ‫ידי‬ ‫על‬ ‫או‬ ‫מיקרוסופט‬ ‫לאתר‬ ‫פניה‬
‫לוקאלי‬ ‫באופן‬ ‫בהם‬
‫לבצע‬ ‫מנת‬ ‫על‬kernel debugging‫שנקראים‬ ‫קבצים‬ ‫להוריד‬ ‫יש‬ ‫ביעילות‬symbols‫ההפעלה‬ ‫מערכת‬ ‫לגרסת‬ ‫המתאימים‬
‫מנתחים‬ ‫אנחנו‬ ‫אותה‬,‫פונקציות‬ ‫של‬ ‫שמות‬ ‫מספקים‬ ‫אלו‬ ‫קבצים‬,‫ה‬ ‫של‬ ‫המקור‬ ‫בקוד‬ ‫ומיקומים‬ ‫משתנים‬ ‫שמות‬kernel.
‫ה‬ ‫בלי‬symbols‫כשורה‬ ‫יתבצע‬ ‫לא‬ ‫המקור‬ ‫וקוד‬ ‫המכונה‬ ‫של‬ ‫ההתנהגות‬ ‫בין‬ ‫הקישור‬
windows
Symbols
‫ההפעלה‬ ‫מערכת‬ ‫של‬ ‫במקרה‬ubuntu‫את‬ ‫למצוא‬ ‫ניתן‬
‫הרלוונטי‬ ‫המידע‬‫כאן‬‫אחרות‬ ‫לינוקס‬ ‫מערכות‬ ‫ובעבור‬
‫באינטרנט‬ ‫המידע‬ ‫את‬ ‫לחפש‬ ‫יש‬.
linux

‫ב‬ ‫הרצים‬ ‫קבצים‬ ‫ולנתח‬ ‫לפתוח‬ ‫מאפשר‬user-space
‫לתוכנות‬ ‫זהה‬ ‫הניתוח‬ ‫אופן‬debugging‫כי‬ ‫אם‬ ‫אחרות‬
‫ב‬WinDgb‫הפקודה‬ ‫שורת‬ ‫דרך‬ ‫מתבצעות‬ ‫הפעולות‬
‫להפעיל‬ ‫ויש‬ ‫אוטומטית‬ ‫נטענות‬ ‫לא‬ ‫השונות‬ ‫והתצוגות‬
‫דרך‬ ‫אותן‬view
WinDbg‫מאפשר‬ ‫אשר‬ ‫מיקרוסופט‬ ‫מבית‬ ‫חינמי‬ ‫כלי‬ ‫הוא‬debugging‫פקודה‬ ‫שורת‬ ‫באמצאות‬.‫אינו‬ ‫אומנם‬ ‫הוא‬
‫כמו‬ ‫פופולארי‬OllyDbg‫או‬ImmDbg‫בניתוח‬ ‫מדובר‬ ‫כאשר‬User-space‫מאפשר‬ ‫שהוא‬ ‫בכך‬ ‫מובהקים‬ ‫יתרונות‬ ‫לו‬ ‫יש‬ ‫אך‬
kernel debugging‫ווינדוס‬ ‫של‬ ‫בפונקציאונליות‬ ‫מורחבת‬ ‫תמיכה‬ ‫לו‬ ‫ויש‬
Open executable
WinDbg
‫ה‬ ‫את‬ ‫לנתח‬ ‫מנת‬ ‫על‬kernel‫כל‬ ‫שאכן‬ ‫לוודא‬ ‫יש‬
‫יש‬ ‫מכן‬ ‫ולאחר‬ ‫שצריך‬ ‫כמו‬ ‫מראש‬ ‫בוצעו‬ ‫ההכנות‬
‫אותו‬ ‫שהגדרנו‬ ‫כמו‬ ‫החיבור‬ ‫אופן‬ ‫את‬ ‫את‬ ‫לבחור‬
‫הווירטואלית‬ ‫במכונה‬,‫שהליך‬ ‫בחשבון‬ ‫לקחת‬ ‫יש‬
‫שניות‬ ‫מספר‬ ‫ימשך‬ ‫החיבור‬
Kernel debugging

‫מעין‬ ‫היא‬ ‫הראשית‬ ‫התצוגה‬cli‫הרצת‬ ‫מאפשר‬ ‫אשר‬
‫שלהן‬ ‫הפלט‬ ‫את‬ ‫ומציג‬ ‫שונות‬ ‫פקודות‬
‫ב‬WinDbg‫הניתוח‬ ‫תהליך‬ ‫עודות‬ ‫שונה‬ ‫מידע‬ ‫לנו‬ ‫המספקים‬ ‫שונים‬ ‫חלונות‬ ‫מספר‬,‫מחדל‬ ‫כברירת‬ ‫פתוחים‬ ‫לא‬ ‫החלונות‬ ‫רוב‬.
‫הרלוונטי‬ ‫המידע‬ ‫את‬ ‫יראו‬ ‫הם‬ ‫אותם‬ ‫נפתח‬ ‫כאשר‬ ‫זאת‬ ‫עם‬
‫העבודה‬ ‫סביבת‬
‫שהוא‬ ‫כפי‬ ‫התוכנה‬ ‫של‬ ‫הקוד‬ ‫את‬ ‫לנו‬ ‫מציג‬ ‫זה‬ ‫חלון‬
‫ה‬ ‫ידי‬ ‫על‬ ‫נקרא‬assembler
Disassembly
‫נתון‬ ‫ברגע‬ ‫האוגרים‬ ‫את‬ ‫המציג‬ ‫חלון‬
Registers
‫המציג‬ ‫חלון‬dump‫בתצוגה‬ ‫נתון‬ ‫ברגע‬ ‫הזיכרון‬ ‫של‬
‫הקסהדצימאלית‬
Memory

‫הפקודות‬ ‫באמצאות‬ ‫תתבצע‬ ‫מהזיכרון‬ ‫כתובת‬ ‫הצגת‬
da, du, dd‫המבוקשת‬ ‫הכתובת‬ ‫הינו‬ ‫אשר‬ ‫ופרמטר‬
‫בתצורת‬ ‫הכתובת‬ ‫של‬ ‫התוכן‬ ‫את‬ ‫יציגו‬ ‫אשר‬ascii,
unicode, dword‫בהתאמה‬.
‫של‬ ‫הפקודות‬ ‫בממשק‬ ‫מהאפשרויות‬ ‫אחת‬WinDbg‫הערכים‬ ‫את‬ ‫ולקרוא‬ ‫מסוימת‬ ‫זיכרון‬ ‫לכתובת‬ ‫ישירות‬ ‫לגשת‬ ‫היא‬
‫שם‬ ‫הנמצאים‬.‫על‬ ‫אריתמטיות‬ ‫פעולות‬ ‫לבצע‬ ‫והיכולת‬ ‫מסוימת‬ ‫בכתובת‬ ‫הערכים‬ ‫את‬ ‫לשנות‬ ‫האפשרויות‬ ‫גם‬ ‫קיימות‬ ‫זאת‬ ‫עם‬ ‫יחד‬
‫הזיכרון‬ ‫כתובות‬
‫כתובת‬ ‫הצגת‬
‫לזיכרון‬ ‫גישה‬
‫הפקודות‬ ‫באמצעות‬ ‫יתבצע‬ ‫בזיכרון‬ ‫ערך‬ ‫שינוי‬ea, eu,
ed‫שלאחר‬ ‫ההבדל‬ ‫עם‬ ‫הכתובת‬ ‫הצגת‬ ‫כמו‬ ‫אופן‬ ‫באותו‬
‫יהיו‬ ‫הפקודה‬2‫פרמטרים‬,‫והערך‬ ‫המבוקשת‬ ‫הכתובת‬
‫לכתיבה‬
‫ערך‬ ‫שינוי‬
‫הסימנים‬ ‫עם‬ ‫אריתמטיות‬ ‫פעולות‬ ‫לבצע‬ ‫ניתן‬+-/ *‫על‬
‫שונים‬ ‫זיכרון‬ ‫מיקומי‬,‫בפקודה‬ ‫להשתמש‬ ‫ניתן‬ ‫בנוסף‬
dwo‫לבצע‬ ‫בשביל‬dereference‫מסוימת‬ ‫לכתובת‬
‫אריתמטיות‬ ‫פעולות‬

bp NtCreateProcessEx‫פעם‬ ‫בכל‬ ‫עצירה‬ ‫תבצע‬
‫הנ‬ ‫שהפונקציה‬"‫למשתמש‬ ‫תעבור‬ ‫והשליטה‬ ‫תקרא‬ ‫ל‬
‫יצירת‬breakpoint‫ב‬WinDbg‫הפקודה‬ ‫ידי‬ ‫על‬ ‫מתבצעת‬bp‫יוצרת‬ ‫אשר‬breakpoints.
‫הפקודה‬bp‫בעת‬ ‫שיקרו‬ ‫אוטומטיות‬ ‫פעולות‬ ‫לקבוע‬ ‫ואפילו‬ ‫פרמטרים‬ ‫של‬ ‫שונים‬ ‫סוגים‬ ‫לקבל‬ ‫יכולה‬
‫ב‬ ‫נחיתה‬breakpoint‫אחר‬ ‫או‬ ‫כזה‬
‫לפונקציה‬ ‫קריאה‬
Setting breakpoints
bp NtCreateProcessEx “da dwo(esp+4); g”
‫שנקרא‬ ‫להרצה‬ ‫המודול‬ ‫שם‬ ‫את‬ ‫תדפיס‬ ‫זאת‬ ‫פקודה‬
‫הנ‬ ‫הפונקציה‬ ‫של‬ ‫הפעלה‬ ‫בכל‬"‫תמשיך‬ ‫מכן‬ ‫ולאחר‬ ‫ל‬
‫בפקודה‬ ‫בזכות‬ ‫אוטומטית‬"g"
‫אוטומציה‬
‫עם‬ ‫בזיכרון‬ ‫הטעונים‬ ‫המודולים‬ ‫את‬ ‫לראות‬ ‫ניתן‬
‫הפקודה‬lm,‫ה‬ ‫גם‬ ‫תדפיס‬ ‫הפקודה‬dll‫או‬ ‫הטעונים‬
‫ב‬ ‫רצה‬ ‫התוכנה‬ ‫אם‬ ‫הדרייברים‬user space‫ב‬ ‫או‬
kernel‫בהתאמה‬
‫בזיכרון‬ ‫פונקציות‬ ‫איתור‬

‫ל‬ ‫פנייה‬Symbol‫הבא‬ ‫בפורמט‬ ‫מתבצעת‬:
moduleName!symbolName‫כי‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫המודול‬ntoskrnl.exe‫יקרא‬nt‫ולא‬ntoskrnl
WinDbg‫לקבוע‬ ‫מאפשר‬breakpoints‫ב‬ ‫מוצא‬ ‫הוא‬ ‫אשר‬ ‫פונקציות‬ ‫על‬symbols,‫ה‬breakpoint
‫לזיכרון‬ ‫יטען‬ ‫המודול‬ ‫כאשר‬ ‫בפועל‬ ‫יקבע‬.‫לקבוע‬ ‫ניתן‬ ‫בנוסף‬breakpoint‫מסוים‬ ‫למודול‬ ‫הכניסה‬ ‫בנקודות‬
‫בפקודה‬ ‫שימוש‬ ‫ידי‬ ‫על‬$iment(name)
‫ל‬ ‫פניה‬symbol
Deferred breakpoints
du nt!ZwCreateProcess‫תקבע‬breakpoint
‫כאשר‬ZwCreateProcess‫לזיכרון‬ ‫תטען‬
Deferred breakpoints
‫באמצאות‬ ‫ופנימיות‬ ‫מיוצאות‬ ‫פונקציות‬ ‫לחפש‬ ‫ניתן‬
‫במסכות‬ ‫שימוש‬*‫הפקודה‬ ‫באמצעות‬x‫הבא‬ ‫באופן‬:
x nt!*CreateProcess*
‫פונקציות‬ ‫חיפוש‬

‫עם‬ ‫שתעבוד‬ ‫הווירטואלית‬ ‫המכונה‬ ‫את‬ ‫שהגדרנו‬ ‫לאחר‬
GDB‫ה‬ ‫את‬ ‫להריץ‬ ‫יש‬debugger‫ולהגדיר‬ ‫עצמו‬
‫ארכיטקטורה‬‫איתה‬‫ולקבוע‬ ‫נעבוד‬breakpoints
‫הרצויים‬ ‫במקומות‬.‫למכונה‬ ‫להתחבר‬ ‫ניתן‬ ‫מכן‬ ‫לאחר‬
‫הפקודה‬ ‫באמצעות‬target remote ip:port
GDB‫מאפשר‬Debugging‫שיטות‬ ‫מספר‬ ‫ידי‬ ‫על‬ ‫מרחוק‬,‫ווירטואלית‬ ‫למכונה‬ ‫התחברות‬ ‫היא‬ ‫אחת‬ ‫שיטה‬
‫דרך‬stub‫ל‬ ‫לשמש‬ ‫יכול‬ ‫אשר‬kerneldebugging.‫ב‬ ‫שימוש‬ ‫היא‬ ‫נוספת‬ ‫אפשרות‬GDB server‫על‬
‫ידי‬ ‫על‬ ‫מרחוק‬ ‫והתחברות‬ ‫הנבדקת‬ ‫המכונה‬GDB‫נוספת‬ ‫ממכונה‬
Remote stub
GDB remote debugging
‫תהליכים‬ ‫שני‬ ‫בהרצת‬ ‫כרוכה‬ ‫זאת‬ ‫שיטה‬,gdbserver
‫הם‬ ‫המועברים‬ ‫הפרמטרים‬ ‫כאשר‬ ‫הנבחנת‬ ‫המכונה‬ ‫על‬
‫לבחינה‬ ‫התוכנה‬ ‫ושם‬ ‫הניתוח‬ ‫לתעבורת‬ ‫הפורט‬.
‫להריץ‬ ‫יש‬ ‫הבודקת‬ ‫התחנה‬ ‫על‬ ‫במקביל‬GDB‫ושוב‬
‫באמצעות‬ ‫הרצויה‬ ‫למכונה‬ ‫להפנות‬target remote
GDB server

‫מתבצע‬ ‫כאשר‬packing‫בד‬ ‫לתוכנה‬"‫ה‬ ‫כל‬ ‫כ‬imports
‫וה‬exports‫יוסתרו‬ ‫שלה‬‫וה‬packer‫ישתמש‬
‫בפונקציות‬LoadLibrary‫ו‬GetProcAddress
‫לאחר‬ ‫עצמאי‬ ‫באופן‬ ‫הטעינות‬ ‫את‬ ‫לעשות‬ ‫בשביל‬
‫התוכנה‬ ‫של‬ ‫הפריקה‬
Packing‫שיטת‬ ‫היא‬anti-debugging‫שונים‬ ‫אלגוריתמים‬ ‫בעזרת‬ ‫נדחסת‬ ‫התוכנה‬ ‫בה‬ ‫נפוצה‬,‫ומוצפנת‬ ‫נדחסת‬.
‫אותו‬ ‫מריץ‬ ‫ואז‬ ‫המקורי‬ ‫הקוד‬ ‫את‬ ‫פורק‬ ‫אשר‬ ‫קוד‬ ‫קטע‬ ‫לתוכנה‬ ‫מתווסף‬ ‫מכן‬ ‫לאחר‬,‫דחוסה‬ ‫המקורית‬ ‫שהתוכנה‬ ‫כיוון‬
‫רגיל‬ ‫באופן‬ ‫סטטי‬ ‫ניתוח‬ ‫עליה‬ ‫לבצע‬ ‫ניתן‬ ‫לא‬
Imports & Exports
Packing
‫המושג‬tail jump‫הכניסה‬ ‫נקודת‬ ‫בין‬ ‫למעבר‬ ‫מתייחס‬
‫ה‬ ‫של‬packer‫הקוד‬ ‫של‬ ‫הכניסה‬ ‫לנקודות‬‫האמיתי‬
‫שעברו‬ ‫תוכנות‬ ‫של‬ ‫בפריקה‬ ‫מאתגר‬ ‫הכי‬ ‫החלק‬
packing‫לקוד‬ ‫והמעבר‬ ‫הפריקה‬ ‫סיום‬ ‫של‬ ‫איתור‬ ‫הוא‬
‫האמיתי‬
Tail jump
Other sections
.data section
.text section
exports
Packed
program
imports
header
header
unpacking
stub
packed
original code
Unpacked program
Entry Point

‫ה‬ ‫משיטות‬ ‫חלק‬packing‫סטטית‬ ‫פריקה‬ ‫מאפשרות‬
‫אותה‬ ‫פורקת‬ ‫ורק‬ ‫התוכנה‬ ‫את‬ ‫מריצה‬ ‫לא‬ ‫אשר‬.‫מספר‬
‫ל‬ ‫זמינים‬ ‫זאת‬ ‫פריקה‬ ‫העושים‬ ‫תוספים‬ ‫של‬ ‫רב‬PE
Explorer
‫שעברו‬ ‫תוכנות‬ ‫של‬ ‫ניתוח‬ ‫בעת‬packing‫לביצוע‬ ‫ייעודיות‬ ‫תוכנות‬ ‫או‬ ‫בתוספים‬ ‫להשתמש‬ ‫ניתן‬ ‫יהיה‬ ‫לפעמים‬
unpacking‫אוטומטי‬.‫עצמאית‬ ‫פריקה‬ ‫לבצע‬ ‫ונצטרך‬ ‫שצריך‬ ‫כמו‬ ‫יעבדו‬ ‫לא‬ ‫זה‬ ‫מסוג‬ ‫תוכנות‬ ‫קרובות‬ ‫לעיתים‬ ‫זאת‬ ‫עם‬
‫התוכנה‬ ‫של‬
Automated static unpacking
Unpacking
‫אוטומטי‬ ‫באופן‬ ‫לאתר‬ ‫תנסה‬ ‫הפורקת‬ ‫התוכנה‬ ‫זו‬ ‫בפריקה‬
‫לשמור‬ ‫ואז‬ ‫המקורי‬ ‫הקוד‬ ‫של‬ ‫הפריקה‬ ‫תהליך‬ ‫סוף‬ ‫את‬
‫אותו‬,‫להריץ‬ ‫מסוכן‬ ‫ולכן‬ ‫יצליחו‬ ‫האלו‬ ‫התוכנות‬ ‫תמיד‬ ‫לא‬
‫בטוחה‬ ‫לא‬ ‫בסביבה‬ ‫זו‬ ‫שיטה‬.
Automated dynamic unpacking
‫התוכנה‬ ‫את‬ ‫להריץ‬ ‫מהמנתח‬ ‫מצריכה‬ ‫זו‬ ‫שיטה‬
‫ב‬debugger,‫שהתוכנה‬ ‫מזהה‬ ‫שהוא‬ ‫לאחר‬ ‫לעצור‬
‫ה‬ ‫את‬ ‫ידני‬ ‫באופן‬ ‫לתקן‬ ‫ולבסוף‬ ‫נפרקה‬header,
‫ה‬imports‫ו‬exports
Manual unpacking

Introduction to malware analysis & reverse engineering

More Related Content

Similar to Introduction to malware analysis & reverse engineering (20)

More from yarden hanan (15)