Introduction to malware analysis & reverse engineering

1. Malware Analysis and Reverse
Engineering

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

31. ‫המשתנה‬ ‫בדוגמא‬ ‫לראות‬ ‫שניתן‬ ‫כפי‬“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

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

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

34. ‫נקראים‬ ‫האוגר‬ ‫של‬ ‫השמאלי‬ ‫בחלק‬ ‫הנמצאים‬ ‫הביטים‬
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

35. 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‫מערכת‬ ‫דגלי‬,
‫התוכנה‬ ‫של‬ ‫הריצה‬ ‫המשך‬ ‫את‬ ‫לקבוע‬ ‫כדי‬ ‫המעבד‬ ‫ידי‬ ‫על‬ ‫האלו‬ ‫בערכים‬ ‫תדיר‬ ‫שימוש‬ ‫נעשה‬ ‫ככלל‬,‫ועוד‬ ‫תנאים‬ ‫בדיקת‬.

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

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

38. ‫באסמבלי‬ ‫מתמטיות‬ ‫פעולות‬
‫מתקדם‬ ‫סטטי‬ ‫ניתוח‬
‫מראש‬ ‫מוגדרים‬ ‫אוגרים‬ ‫על‬ ‫מתבצעות‬ ‫שהפעולות‬ ‫כיוון‬ ‫שליטה‬ ‫פחות‬ ‫אפילו‬ ‫יש‬ ‫חילוק‬ ‫או‬ ‫כפל‬ ‫של‬ ‫במקרה‬
‫כללים‬ ‫הינם‬ ‫שהאוגרים‬ ‫למרות‬ ‫מקודם‬ ‫שצויין‬ ‫כמו‬,‫מסויימות‬ ‫פונקציות‬ ‫כלפי‬ ‫מיוחדת‬ ‫אחריות‬ ‫גם‬ ‫יש‬ ‫לחלקם‬.
‫הפעולה‬ ‫לפני‬ ‫מוגדרים‬ ‫האוגרים‬ ‫כיצד‬ ‫לבדוק‬ ‫יש‬ ‫כזה‬ ‫למצב‬ ‫מגיעים‬ ‫אנחנו‬ ‫אם‬ ‫כן‬ ‫על‬
‫תאור‬ ‫פעולה‬
‫הפעולה‬‫את‬ ‫תכפיל‬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‫הבא‬ ‫באופן‬ ‫תשמר‬

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

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

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

42. ‫שהכתובת‬ ‫אחרי‬ ‫נוצרים‬ ‫הפונקציה‬ ‫של‬ ‫המשתנים‬
‫וה‬ ‫לחזרה‬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

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

44. ‫תנאי‬ ‫סוגי‬
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‫הוא‬
1‫המוגדר‬ ‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫אם‬
js loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬SF‫הוא‬
1‫המוגדר‬ ‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫אם‬
jecxz loc
‫ב‬ ‫הערך‬ ‫האם‬ ‫נבדק‬ ‫זה‬ ‫במקרה‬ECX
‫הוא‬0‫למקום‬ ‫מעבר‬ ‫יתבצע‬ ‫כן‬ ‫אם‬
‫המוגדר‬

45. ‫ביטים‬ ‫של‬ ‫מניפולציה‬
‫מתקדם‬ ‫סטטי‬ ‫ניתוח‬
‫הצפנות‬ ‫או‬ ‫חישובים‬ ‫בינהם‬ ‫שונים‬ ‫לצרכים‬ ‫ביטים‬ ‫של‬ ‫מניפולציה‬ ‫לנצל‬ ‫יכולות‬ ‫תוכנות‬ ‫מעט‬ ‫לא‬,‫משפחות‬ ‫בשתי‬ ‫שימוש‬ ‫יהיה‬ ‫זה‬ ‫במקרה‬
‫פקודות‬ ‫של‬(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

46. ‫הפונקציה‬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‫פרמטרים‬
‫הערה‬:‫פרמטרים‬ ‫לקבל‬ ‫צריכה‬ ‫היא‬ ‫תרוץ‬ ‫שתוכנה‬ ‫מנת‬ ‫על‬ ‫לפעמים‬,‫יכול‬ ‫פונקציות‬ ‫של‬ ‫טוב‬ ‫חקר‬
‫אותה‬ ‫לחקור‬ ‫בשביל‬ ‫שצריך‬ ‫כמו‬ ‫התוכנה‬ ‫את‬ ‫להריץ‬ ‫איך‬ ‫להבין‬ ‫לעזור‬

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

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

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

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

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

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

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

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

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

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

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

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

59. 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‫מוקדמת‬ ‫הכנה‬ ‫דורשת‬,‫גם‬ ‫לב‬ ‫לשים‬ ‫יש‬
‫קורה‬ ‫מה‬ ‫להבין‬ ‫בשביל‬ ‫לפניה‬ ‫לפקודות‬
‫ב‬ ‫הקוד‬IDA

60. 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”
‫ב‬ ‫הקוד‬IDA

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

62. 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
‫ב‬ ‫הקוד‬IDA

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

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

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