דלגו לתוכן הראשי
גאמא קוד

מחשבון קרב - אסמבלי

labels

קפיצות ללא תנאי עם jmp ו-labels, וקריאות call, ומעקב אחרי הערך הסופי באוגר.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

labels: תוויות, קפיצות, קריאות לפונקציות והמחסנית ב-x86

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

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

  • שאלות ידע בלי קוד: מה עובר על EIP אחרי פקודה רגילה, אילו פקודות משנות אותו, מה call משאירה במחסנית, ובמה far שונה מ-near.
  • קטע עם jmp אחת או יותר שמדלגות קדימה, ולפעמים גם קפיצה חזרה למעלה.
  • קטע עם call ו-ret, שבו לפעמים אותה פונקציה מופעלת פעמיים.
  • פונקציה שפותחת מסגרת מחסנית וקוראת את הפרמטרים שלה מ-[ebp+8] ומ-[ebp+12], ולפעמים שומרת משתנה מקומי ב-[ebp-4].

אוצר המילים של הקטעים מצומצם: mov, add, sub, inc, push, pop, jmp, call ו-ret, תשע פקודות ולא יותר. כל אחת מקבלת כאן הסבר משלה: אילו אופרנדים היא מקבלת, אילו היא דוחה, ומה היא משנה באוגרים.

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

  • jmp, call ו-ret: הפקודות שכותבות ל-EIP כתובת אחרת, וכך מעבירות את הריצה.
  • Label (תווית): השם שנותנים לכתובת היעד, כדי שלא תצטרכו לדעת אותה כמספר.
  • המחסנית (stack): זיכרון עבודה שבו call רושמת לאן לחזור, ושבו פונקציה מחזיקה את הפרמטרים ואת המשתנים המקומיים שלה.

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

לגבי מבחן מחשבון הקרב: שם הקוד כתוב בשפה מומצאת של מעבד אחר, ולא ב-x86. מי ששינן רק תחביר ייתקע, ומי שהבין מה עושות תווית, קפיצה, קריאה וחזרה יזהה אותן בכל תחפושת.
מושגבמשפט אחד
EIPהאוגר שבו כתובה הכתובת של ההוראה הבאה לביצוע.
ESPמצביע על ראש המחסנית, כלומר על הערך האחרון שנדחף.
EBPנקודת עיגון קבועה שממנה פונקציה מגיעה לפרמטרים ולמשתנים המקומיים שלה.
CSאוגר ה-segment של הקוד: מסמן מאיזה code segment המעבד מביא הוראות.
Labelשם שניתן לכתובת בקוד. בשורה שמגדירה אותו באים אחריו נקודתיים.
Stackאזור זיכרון שבו מה שנכנס אחרון יוצא ראשון.
Stack frameהפרוסה של המחסנית ששייכת לקריאה אחת של פונקציה.
call / retהפעלה של פונקציה, והחזרה ממנה אל מי שהפעיל אותה.
near / farקפיצה או קריאה שנשארת באותו code segment, לעומת כזו שעוברת ל-segment אחר.

על המעקבים שבטבלאות: עשינו אותם ביד, שורה אחר שורה, ואחר כך הרצנו את אותו קוד על מעבד x86 אמיתי (32 ביט, לינוקס) כדי לוודא את התוצאות. כשמתחת לקוד מופיע פלט, זה הפלט שהתקבל בפועל.

Label (תווית): שם לכתובת בקוד

למה נותנים שם לכתובת

נניח שכתבתם jmp 0x804900f כדי לקפוץ לפקודה מסוימת, ואחר כך הוספתם שורה אחת מעליה. מעכשיו הפקודה יושבת בכתובת אחרת, וה-jmp שולחת את הריצה למקום הלא נכון.

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

מי מחליף את השם במספר? האסמבלר, הכלי שהופך את הטקסט לקוד מכונה. בהמשך החלק תראו בפירוק של קובץ אמיתי שבתוך הפקודות נשארת רק הכתובת.

חזרה לתוכן העניינים

כללי הכתיבה של תווית

הנה כמה צורות כתיבה חוקיות. בכולן התווית מוגדרת על ידי שם שנצמדים אליו נקודתיים:

Assembly
RETRY:
  add edx, 2

CHECK: dec ecx          ; label and instruction on one line

FIRST:
SECOND:
  sub eax, 1            ; FIRST and SECOND name the same address

מה רואים בקטע: FIRST ו-SECOND כתובות זו מעל זו בלי פקודה ביניהן, ולכן שתיהן שמות של אותה כתובת, זו של sub eax, 1. CHECK חולקת שורה עם הפקודה שלה, ו-RETRY עומדת לבדה ומסמנת את הפקודה שמתחתיה, ושתי הצורות שקולות.

בשורת הקפיצה הנקודתיים נעלמים, וכותבים jmp RETRY. הם סימן של הגדרה בלבד, ומי שמוסיף אותם בשימוש מקבל שגיאה:

Assembly
section .text
  jmp RETRY:            ; colon in the jump
RETRY:
  add edx, 2
פלט
jmpcolon.asm:2: error: invalid combination of opcode and operands

ולגבי השם עצמו: הבחירה הבטוחה היא אותיות באנגלית, ספרות וקו תחתון, כשהתו הראשון אינו ספרה (RETRY, STEP_2, _start). כלל עבודה נוסף הוא לא לקרוא לתווית בשם של אוגר או של פקודה.

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

Assembly
section .text
ecx:                    ; a register name as a label
  add edx, 2
push:                   ; an instruction name as a label
  add edx, 3
פלט
names.asm:2: error: label, instruction or prefix expected at start of line, found `ecx'

רק השורה של ecx: נפסלה. את push: NASM קיבל בלי שום אזהרה, ובכל זאת נמנעים משם כזה: קוד שבו jmp push היא קפיצה ולא דחיפה הוא מלכודת לכל מי שיקרא אותו.

חזרה לתוכן העניינים

תווית לא מבצעת שום פעולה

נתחיל בניסוי. תרגמנו שתי פקודות פעם אחת כמו שהן, ופעם שנייה עם שורת MIDDLE: ביניהן (שני הקבצים מתחילים ב-bits 32, כדי שייבנו כקוד של 32 ביט), והשווינו את מה שיצא:

Bash
nasm -f bin plain.asm -o plain.bin        # mov and sub, no label
nasm -f bin labeled.asm -o labeled.bin    # the same lines with MIDDLE: between them
cmp plain.bin labeled.bin && echo identical
xxd labeled.bin
פלט
identical
00000000: ba09 0000 0083 ea02                      ........

שמונה בתים בסך הכול, וכולם של הפקודות: ba 09 00 00 00 הוא mov edx, 9, ו-83 ea 02 הוא sub edx, 2. התווית לא הוסיפה אף בית.

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

במעקב זה נראה כך:

Assembly
mov edx, 9
MIDDLE:          ; only a name for the next address
sub edx, 2
שורהEDX אחריהמה קרה
mov edx, 99ערך התחלתי.
MIDDLE:9הריצה חולפת על פני התווית, ושום דבר לא משתנה.
sub edx, 27הפקודה הבאה ברצף.
חזרה לתוכן העניינים

תווית כיעד של קפיצה

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

איך הריצה מגיעה לתוויתמה קורה שם
מלמעלה, כי הפקודה הקודמת הסתיימההתווית שקופה, וממשיכים ישר לפקודה שמתחתיה.
בקפיצה אליה, ב-jmp או ב-callEIP מקבל את הכתובת שהתווית מייצגת, והפקודה שמתחתיה היא הבאה שתתבצע.

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

ל-jmp עצמה מוקדש חלק משלה בהמשך הפרק.

חזרה לתוכן העניינים

_start ותוכנית שלמה

התוכנית הבאה שלמה, כזו שאפשר לבנות ולהריץ. כמה מהשורות שלה שייכות למעטפת ולא לחישוב, וההערות מסבירות אותן:

Assembly
global _start          ; make _start visible to the linker

section .text          ; code lives in the text section
_start:                ; the program starts running here
  mov ebx, 12
  sub ebx, 5
  jmp FINISH           ; skip the next line
  mov ebx, 99          ; never runs
FINISH:
  mov eax, 1           ; Linux system call 1 = exit
  int 0x80             ; the exit code is the value in EBX

_start היא התווית שבה הריצה מתחילה, השם המקובל לנקודת הכניסה. global _start חושפת אותה ללינקר, הכלי שמרכיב את קובץ ההרצה ומחפש בו את נקודת הכניסה. section .text פותחת את קטע הקוד, שבו כתובות הפקודות.

בנינו והרצנו את התוכנית בלינוקס, ואז ביקשנו מהמעטפת את קוד היציאה:

Bash
nasm -f elf32 skel.asm -o skel.o
ld -m elf_i386 skel.o -o skel
./skel
echo $?
פלט
7

שתי השורות האחרונות בתוכנית מבקשות ממערכת ההפעלה לסיים אותה, וקוד היציאה נלקח מ-EBX. לכן echo $? מציגה את הערך הסופי, 7 (כלומר 12 פחות 5), והשורה עם 99, שדולגה, לא השאירה סימן.

ומה נשאר מהתוויות אחרי התרגום? זה הפירוק של אותה תוכנית בכלי objdump:

Bash
objdump -d -M intel skel
פלט
skel:     file format elf32-i386


Disassembly of section .text:

08049000 <_start>:
 8049000:	bb 0c 00 00 00       	mov    ebx,0xc
 8049005:	83 eb 05             	sub    ebx,0x5
 8049008:	eb 05                	jmp    804900f <FINISH>
 804900a:	bb 63 00 00 00       	mov    ebx,0x63

0804900f <FINISH>:
 804900f:	b8 01 00 00 00       	mov    eax,0x1
 8049014:	cd 80                	int    0x80

בתוך פקודת ה-jmp, FINISH היא כבר רק מספר: 804900f, הכתובת של mov eax, 1. את השם objdump לוקח מטבלת הסמלים (symbol table) שהלינקר משאיר בקובץ, בנפרד מהקוד, ולא מהפקודות עצמן.

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

ומה עם ret בשורה האחרונה, כשאף call לא הפעיל את הקטע? היא לא מחזירה לשום מקום, אלא פשוט מסמנת שהקטע נגמר.

חזרה לתוכן העניינים

טעויות ובדיקה עצמית: תוויות

טעויות נפוצות
  • jmp RETRY: ו-jmp RETRY הן שתי דרכים לכתוב את אותה קפיצה. רק השנייה נבנית. הנקודתיים שייכים לשורה שמגדירה את התווית, והאסמבלר דוחה אותם בשורת הקפיצה.
  • תווית היא סוג של מחסום: הריצה נעצרת עליה, או שהקוד שמתחתיה ממתין שמישהו יקפוץ אליו. לתווית אין בתים בקוד המכונה ואין לה שום פעולה. ריצה שמגיעה אליה מלמעלה ממשיכה הלאה, והפקודות שמתחתיה מתבצעות.
  • כש-jmp RETRY מתבצעת, משהו נטען לאוגר נתונים, כי לתווית יש ערך. השם מייצג כתובת בקוד, והיחיד שמקבל אותה הוא EIP. אף אוגר נתונים לא משתנה.
  • קוד שיושב בין jmp לבין התווית שלה הוא קוד מת. הוא מדולג רק במעבר הזה. קפיצה ממקום אחר יכולה להוביל אליו, ואז הוא רץ.
  • NASM פוסל כל תווית שהשם שלה הוא מילה שמורה. הוא פוסל שמות של אוגרים כמו ecx:, אבל מקבל שם של פקודה כמו push:. גם אם הוא מקבל, לא משתמשים בשם כזה.
בדקו את עצמכם
אילו מהשורות הבאות האסמבלר ידחה: STEP_2:, edx:, jmp STEP_2, jmp STEP_2:?

את edx:, כי זה שם של אוגר, ואת jmp STEP_2:, כי בשורת קפיצה לא כותבים נקודתיים. שתי האחרות תקינות.

מוסיפים לתוכנית עשר תוויות חדשות, בלי לגעת באף פקודה. בכמה בתים יגדל קוד המכונה?

באפס. תוויות לא מתורגמות לבתים, הן רק שמות לכתובות שכבר קיימות.

חבר טוען שבקטע mov ebx, 3, TOP:, add ebx, 4 החיבור ירוץ רק אם מישהו יקפוץ ל-TOP, ולכן EBX יישאר 3. מה התשובה הנכונה?

7. הריצה מגיעה ל-TOP מלמעלה, עוברת עליה בלי שום פעולה, ומבצעת את החיבור.

objdump מציג בפירוק שמות של תוויות. האם זה אומר שהשמות נמצאים בתוך הפקודות?

לא. בתוך הפקודות יש רק כתובות. את השמות objdump קורא מטבלת הסמלים, שנשמרת בקובץ בנפרד מהקוד.

חזרה לתוכן העניינים

Instruction pointer (מצביע ההוראה): האוגר EIP

EIP: הכתובת של ההוראה הבאה

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

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

השם של האוגר תלוי ברוחב המעבד:

רוחבשם האוגר
16 ביטIP
32 ביט (המצב שבו עוסק הפרק)EIP
64 ביטRIP
הצצה קדימה, לחלק על call: ב-x86 כתובת החזרה מפונקציה נשמרת במחסנית. במעבדי ARM היא נכנסת לאוגר LR (שהוא R14), ואת תפקיד מצביע ההוראה ממלא שם האוגר PC (מונה התוכנית, R15).
חזרה לתוכן העניינים

פקודה רגילה: EIP מתקדם מעצמו

הדרך הכי טובה להבין איך EIP זז היא להסתכל על קוד אמיתי בזיכרון. בנינו בלינוקס תוכנית של חמש פקודות ופירקנו את הקובץ:

Assembly
global _start
section .text
_start:
  mov ecx, 9
  sub ecx, 2
  dec ecx
  cmp ecx, 6
  push ecx
Bash
objdump -d -M intel steps
פלט
steps:     file format elf32-i386


Disassembly of section .text:

08049000 <_start>:
 8049000:	b9 09 00 00 00       	mov    ecx,0x9
 8049005:	83 e9 02             	sub    ecx,0x2
 8049008:	49                   	dec    ecx
 8049009:	83 f9 06             	cmp    ecx,0x6
 804900c:	51                   	push   ecx

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

פקודהמתחילה בכתובתאורךEIP אחרי הביצוע
mov ecx, 90x80490005 בתים0x8049005
sub ecx, 20x80490053 בתים0x8049008
dec ecx0x8049008בית אחד0x8049009
cmp ecx, 60x80490093 בתים0x804900C
push ecx0x804900Cבית אחד0x804900D

זה כל הכלל: כשמסתיימת פקודה שלא נועדה לשנות את סדר הריצה, EIP גדל באורך שלה ומגיע לפקודה הבאה ברצף. ב-x86 אורך פקודה נע בין בית אחד ל-15 בתים, ולכן אין צעד קבוע של 1 או של 4.

במבחן לא יבקשו מכם אורכי קידוד. שאלות על EIP בודקות שאתם יודעים שהוא נע קדימה אל הפקודה הבאה, ולכן תשובות כמו 'מתאפס', 'נשאר קבוע' או 'מקבל את הערך של EAX' שגויות.

חזרה לתוכן העניינים

פקודות זרימה: רק הן שולחות את EIP למקום אחר

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

פקודהמה היא משנהEIP
movאת היעד בלבדמתקדם באורך הפקודה
add, subאת היעד ואת הדגליםמתקדם באורך הפקודה
inc, decאת היעד ואת הדגלים, חוץ מ-CFמתקדם באורך הפקודה
cmp a, bאת הדגלים בלבד: מחשבת a - b ומשליכה את התוצאהמתקדם באורך הפקודה
push, popאת ESP ואת המחסנית, ו-pop גם את היעדמתקדם באורך הפקודה

את cmp תפגשו בפרק הזה רק בתור דוגמה נגדית: פקודה שבודקת משהו, ובכל זאת לא מסיטה את הריצה.

פקודות הזרימה הן סיפור אחר: התפקיד שלהן הוא לכתוב ל-EIP כתובת שאינה של הפקודה הבאה. כך עושה כל אחת מהן:

פקודההערך החדש של EIP
jmp labelהכתובת של label, בכל מצב.
jne, jc, jnc (קפיצות מותנות)הכתובת של label כשהתנאי שלהן מתקיים. אחרת, התקדמות רגילה.
loop labelמקטינה את ECX ב-1, וקופצת ל-label כל עוד ECX לא הגיע ל-0.
call labelהכתובת של label, אחרי שכתובת ההוראה הבאה נדחפה למחסנית.
retהכתובת שנשלפת מראש המחסנית.
int nהכתובת של שגרת הטיפול בפסיקה. לפני כן נשמרים במחסנית הדגלים, CS ו-EIP.
חזרה לתוכן העניינים

אין כתיבה ישירה ל-EIP

אם EIP הוא אוגר, למה לא לכתוב אליו ישירות? כך נראה הניסיון:

Assembly
section .text
  mov eip, 5            ; try to write the instruction pointer
  push eip              ; try to save it on the stack
פלט
eip.asm:2: error: symbol `eip' not defined
eip.asm:3: error: symbol `eip' not defined

NASM לא מוצא בשם eip אוגר שמותר לכתוב בפקודה, ולכן הוא מניח שמדובר בתווית שלא הוגדרה. בניגוד ל-EAX, את EIP אי אפשר לציין כאופרנד: לא ב-mov, לא ב-push ולא ב-pop. רק פקודות זרימה משנות אותו.

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

חזרה לתוכן העניינים

טעויות ובדיקה עצמית: EIP

טעויות נפוצות
  • call דוחפת את הכתובת שבה ה-call עצמה יושבת. כשה-call מתבצעת, EIP כבר מצביע על הפקודה שאחריה, ואת הערך הזה היא דוחפת.
  • cmp ו-add הן פקודות של החלטה, ולכן הן יכולות להעביר את הריצה. cmp רק מעדכנת דגלים, ו-add משנה את היעד ואת הדגלים. להעביר את הריצה יכולות רק פקודות זרימה.
  • כשאין קפיצה, EIP מתאפס או נשאר במקום. אחרי כל פקודה רגילה הוא גדל באורך שלה, אל הפקודה הבאה.
  • EIP ו-EAX קשורים: אחרי פקודה רגילה EIP מקבל את מה שיש ב-EAX. EAX מחזיק נתונים, ו-EIP מחזיק כתובת של קוד. אין ביניהם שום מעבר אוטומטי.
  • mov יכולה לכתוב ל-EIP כמו לכל אוגר אחר. האסמבלר לא מקבל את EIP כאופרנד בכלל. היעד של mov הוא נתון, לא כתובת הריצה.
בדקו את עצמכם
לפי הפירוק של steps, הפקודה cmp ecx, 6 יושבת ב-0x8049009. מה יהיה ב-EIP אחרי שהיא תתבצע, ולמה?

0x804900C. cmp היא פקודה רגילה באורך 3 בתים, ולכן EIP פשוט עובר לפקודה שאחריה, push ecx.

מיינו לשתי קבוצות: sub, loop, push, ret, cmp, int. אילו מהן פקודות זרימה?

loop, ret ו-int. שלוש האחרות רגילות, והן רק מקדמות את EIP.

פקודה אחת באורך 2 בתים, ואחרת באורך 6 בתים. בכמה יתקדם EIP אחרי כל אחת?

ב-2 וב-6, בהתאמה. הצעד שווה תמיד לאורך הפקודה שבוצעה.

ב-ARM, איפה נשמרת כתובת החזרה מפונקציה, ואיזה אוגר משמש מונה תוכנית?

כתובת החזרה נשמרת באוגר LR (R14), ומונה התוכנית הוא PC (R15). ב-x86 לעומת זאת call דוחפת את כתובת החזרה למחסנית.

חזרה לתוכן העניינים

הפקודה jmp: קפיצה בלתי מותנית

התחביר ומה הפקודה עושה

Assembly
jmp label

אפשר לקרוא את jmp כהשמה אחת: EIP מקבל את הכתובת של label. זה כל מה שהיא עושה, ולכן מה שירוץ אחריה הוא הפקודה שבתווית, לא השורה שכתובה מתחתיה.

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

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

קפיצה קדימה: דילוג על פקודות

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

Assembly
mov dl, 0xC0
jmp DONE_ADD
add dl, 0x50      ; skipped
DONE_ADD:
add dl, 0x03
פקודה שהתבצעהDL אחריההערה
mov dl, 0xC00xC0ערך התחלתי.
jmp DONE_ADD0xC0קפיצה. add dl, 0x50 לא מתבצעת.
add dl, 0x030xC3ממשיכים מתחת ל-DONE_ADD.

אילו החיבור המדולג היה רץ, DL היה גולש (0xC0 + 0x50 = 0x110, ונשאר 0x10) והתשובה הייתה אחרת לגמרי. אבל הוא לא רץ, ולכן אין לו שום חלק בתוצאה.

כדי לא ליפול במלכודות כאלה, עבדו בשיטה קבועה:

  1. עוברים על הקטע מלמעלה, שורה אחר שורה.
  2. בכל jmp מחפשים את התווית שלה וממשיכים משם. השורות שבדרך לא נכנסות לטבלה.
  3. בטבלת המעקב רושמים רק פקודות שהתבצעו, עם הערך אחרי כל אחת.
  4. לא עוצרים לפני השורה האחרונה של הקטע, גם כשהיא מתחת לתווית האחרונה.
חזרה לתוכן העניינים

כמה דילוגים ברצף

בקטע הבא יש שני דילוגים. אין להם השפעה זה על זה: מטפלים בראשון, ממשיכים, ומטפלים בשני כשמגיעים אליו.

Assembly
mov bl, 0x11
jmp P1
sub bl, 0x01      ; skipped
P1:
add bl, 0x22
jmp P2
add bl, 0x05      ; skipped
P2:
sub bl, 0x10
פקודה שהתבצעהBL אחריה
mov bl, 0x110x11
jmp P10x11
add bl, 0x220x33
jmp P20x33
sub bl, 0x100x23

התוצאה היא BL = 0x23. מי שמתעלם משתי הקפיצות ומריץ את כל השורות מקבל 0x27, ערך שנראה סביר ולכן מסוכן.

חזרה לתוכן העניינים

קפיצה אחורה: חזרה לקטע שדולג

בקטע הבא הבלוק FIRST מדולג בהתחלה, ובכל זאת רץ בסוף:

Assembly
mov cx, 5
jmp SECOND        ; jump over the FIRST block
FIRST:
add cx, 100
jmp END
SECOND:
add cx, 7
jmp FIRST         ; back up to the block that was skipped
END:
פקודה שהתבצעהCX אחריההערה
mov cx, 55ערך התחלתי.
jmp SECOND5מדלגים על FIRST ועל add cx, 100 שמתחתיה.
add cx, 712הקטע של SECOND.
jmp FIRST12קפיצה למעלה, בדיוק לקטע שדילגנו עליו.
add cx, 100112הקטע שדולג רץ עכשיו.
jmp END112יציאה לסוף הקטע.

מה שקרה כאן: FIRST כתובה מעל ה-jmp שקופצת אליה, ולכן הקפיצה הובילה אחורה. הדילוג הראשון לא 'סגר' את התווית, והיא נשארה יעד חוקי לכל קפיצה, בכל שלב. באותה דרך, קפיצה אחורה יכולה גם להריץ שוב קוד שכבר רץ.

נסו למחוק בראש את jmp END מהקטע FIRST. אחרי add cx, 100 הריצה תמשיך ל-SECOND, jmp FIRST תחזיר אותה למעלה, וחוזר חלילה: CX ימשיך להשתנות בלי סוף, וזו לולאה אינסופית. קפיצה לאחור בטוחה רק כשבקוד שאליו חוזרים יש דרך החוצה.
חזרה לתוכן העניינים

טעויות ובדיקה עצמית: jmp

טעויות נפוצות
  • גם התווית שאליה קופצים נבלעת בדילוג, יחד עם השורות שמעליה. הדילוג נגמר בדיוק בתווית. הפקודה שמתחתיה היא הראשונה שרצה.
  • פקודה מדולגת משפיעה בכל זאת: או שמריצים אותה ליתר ביטחון, או שמבטלים את הערך שלה בסימן הפוך. היא לא רצה, ולכן לא משתתפת בחישוב בשום צורה.
  • התשובה היא מה שהתווסף אחרי התווית. התשובה היא הערך ההתחלתי ועוד כל השינויים שקרו בפועל. מי שזוכר רק חלק מהם מקבל אחת התשובות החלקיות.
  • כשיש כמה jmp, הראשונה קובעת הכול, ואחרי התווית האחרונה אפשר לעצור. כל jmp מדלגת על הקטע שלה בנפרד, ואחרי האחרונה ממשיכים עד השורה האחרונה של הקטע.
  • תווית שדילגו עליה פעם אחת כבר לא שמישה. קפיצה אחורה אליה מריצה את מה שמתחתיה כרגיל.
  • jmp משאירה במחסנית כתובת, כמו call, ולכן אפשר לחזור ממנה עם ret. jmp לא נוגעת במחסנית ולא ב-ESP, ואין ממנה חזרה.
בדקו את עצמכם
רשמו לפי הסדר את הפקודות שרצות, ומצאו את SI בסוף: mov si, 1, jmp B, A:, inc si, jmp C, B:, add si, 2, jmp A, C:.

רצות: mov si, 1, jmp B, add si, 2, jmp A, inc si, jmp C. SI = 1 + 2 + 1 = 4.

לפני jmp X היה ESP = 0x2000. מה יהיה בו אחריה?

0x2000. jmp לא נוגעת ב-ESP.

בקטע mov dh, 6, jmp ON, sub dh, 6, ON:, inc dh תלמיד ענה 1. מה הטעות שלו?

הוא הריץ את החיסור המדולג. החיסור לא מתבצע, DH נשאר 6, ו-inc מעלה אותו ל-7.

מה צריך שיהיה בקוד שאליו קופצים אחורה, כדי שלא תיווצר לולאה אינסופית?

דרך לצאת, למשל jmp קדימה אל סוף הקטע, כמו jmp END בדוגמה.

חזרה לתוכן העניינים

פקודות החישוב בשאלות: mov, add, sub, inc, dec

בסיסי ספירה וגלישה

מה יהיה ב-AL אחרי mov al, 0xFF ואחריה add al, 1? לא 0x100, אלא 0x00. חישובים קטנים כאלה מסתתרים בין ה-jmp וה-call שבקטעים, ולכן החלק הזה עוסק בקריאת מספרים, בגלישה, ובחלקים הקטנים של האוגרים, כמו AX ו-AL.

מה ההבדל בין add al, 10 לבין add al, 0x10? הראשונה מוסיפה עשר, והשנייה שש עשרה. הקידומת 0x מסמנת בסיס 16 (הקסדצימלי), ובלעדיה המספר עשרוני.

בבסיס 16 הספרות שאחרי 9 הן אותיות: A עד F מייצגות 10 עד 15 (A=10, B=11 וכן הלאה עד F=15). אפסים מובילים לא משנים ערך, כך ש-0x0007, 0x07 ו-7 שווים.

הטבלה מראה את הטווח של כל רוחב, ומה קורה כשחוצים אותו:

רוחבאוגריםטווחדוגמה לגלישה
8 ביטAL, AH, BL, BH, CL, CH, DL, DH0x00 עד 0xFF0xFF + 1 = 0x00, וגם 0x00 - 1 = 0xFF
16 ביטAX, BX, CX, DX0x0000 עד 0xFFFF0xFFFF + 1 = 0x0000
32 ביטEAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI0x00000000 עד 0xFFFFFFFF0xFFFFFFFF + 1 = 0x00000000

שלוש דוגמאות באוגרים של 8 ביט:

  • 0xC8 + 0x50 = 0x118, ובאוגר נשאר 0x18.
  • 0x03 - 0x07 = -4, ו-256 - 4 = 252, כלומר 0xFC.
  • 0x3F + 0x01 = 0x40: ספרת ה-F הופכת ל-0 ומעבירה 1 לספרה שמשמאלה, בדיוק כמו 39 + 1 בעשרוני.

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

את שלוש הדוגמאות הרצנו על המעבד, ב-AL, ב-BL וב-CL, והתקבלו 0x18, 0xFC ו-0x40.

חזרה לתוכן העניינים

החלקים של אוגר: EBX, BX, BH, BL

קחו את EBX כשהוא מחזיק 0x89ABCDEF. אותם 32 ביטים אפשר לקרוא בכמה שמות, וכל שם רואה חלק אחר:

שםביטיםמה הוא רואה
EBX0 עד 310x89ABCDEF
(בלי שם)16 עד 310x89AB. לחצי העליון אין שם נפרד
BX0 עד 150xCDEF
BH8 עד 150xCD
BL0 עד 70xEF

החצי התחתון, BX, מתחלק לשני בתים: BH (מלשון high) ו-BL (מלשון low). אותו מבנה בדיוק יש ל-EAX, ל-ECX ול-EDX: AX עם AH ו-AL, CX עם CH ו-CL, DX עם DH ו-DL.

כשכותבים לאחד השמות, רק הביטים שלו מתחלפים:

כותבים ל-מה מתחלףמה נשאר בדיוק כמו שהיה
BL8 הביטים התחתוניםBH, וגם 16 הביטים העליונים
BX16 הביטים התחתונים16 הביטים העליונים של EBX
EBXכל 32 הביטיםשום דבר

גם גלישה מכבדת את הגבולות האלה. אם BL = 0xFF ומבצעים add bl, 1, BL הופך ל-0x00, ושום נשיאה לא עוברת ל-BH.

עוד שתי עובדות. ל-ESI, ל-EDI, ל-EBP ול-ESP יש רק חצי של 16 ביט (SI, DI, BP, SP), בלי בתים בעלי שם. ובכל פקודה עם שני אופרנדים הרוחבים חייבים להיות שווים: mov bl, ch עוברת, ו-mov bx, cl נדחית.

חזרה לתוכן העניינים

mov: העתקת ערך

Assembly
mov dest, src

אחרי mov ecx, edx יש ב-ECX עותק של EDX, ו-EDX עצמו לא השתנה. כך זה תמיד: הערך עובר מהמקור (src, מימין) אל היעד (dest, משמאל), ומה שהיה ביעד נדרס. מי שמתבלבל בכיוון יכול לחשוב על dest = src בשפה עילית.

פקודהלפניאחרי
mov edx, 42EDX=?EDX=42
mov ecx, edxEDX=42, ECX=0EDX=42, ECX=42
mov bh, blBX=0x0071BX=0x7171
mov ax, 0xBEEFEAX=0x12340000EAX=0x1234BEEF

השורה האחרונה בטבלה ממחישה שוב את החלקים: כתיבה ל-AX החליפה רק את 16 הביטים התחתונים. ועוד דבר: mov לא נוגעת בדגלים, כך ש-CF, ZF וכל השאר נשארים כמו לפניה.

אילו צירופים של יעד ומקור האסמבלר מקבל:

יעד, מקורמותר?דוגמה
אוגר, מספרכןmov edx, 42
אוגר, אוגרכן, כששניהם באותו רוחבmov ecx, edx
אוגר, זיכרוןכןmov eax, [ebp+12]
זיכרון, אוגרכןmov [ebp-8], ecx
זיכרון, מספרכן, כשמציינים את הרוחבmov dword [ebp-8], 1
זיכרון, זיכרוןלאmov [total], [price]
מספר כיעדלאmov 5, eax
רוחבים שוניםלאmov ax, bl
EIP כיעדלאmov eip, 5

את הצירופים האסורים אפשר לבדוק מול האסמבלר. זה מה ש-NASM אומר על שלושה מהם:

Assembly
section .data
price dd 30
total dd 0
section .text
  mov ax, bl            ; 16-bit destination, 8-bit source
  mov [total], [price]  ; memory to memory
  mov 5, eax            ; a number as the destination
פלט
mov.asm:5: error: invalid combination of opcode and operands
mov.asm:6: error: invalid combination of opcode and operands
mov.asm:7: error: invalid combination of opcode and operands

הנוסח 'invalid combination of opcode and operands' פירושו: הפקודה קיימת, אבל אין לה גרסה שמקבלת את צירוף האופרנדים הזה.

חזרה לתוכן העניינים

add: חיבור

Assembly
add dest, src
פקודהלפניאחרי
add edx, 8EDX=42EDX=50
add ecx, ecxECX=9ECX=18
add ax, 1AX=0xFFFFAX=0x0000 (גלישה)
add bl, 0x05BX=0x44FDBX=0x4402 (BL גלש, BH נשאר 0x44)
add esp, 12ESP=0x0FF4ESP=0x1000

מה שמשותף לכל השורות: היעד מקבל את הסכום של עצמו ושל המקור, dest = dest + src, והמקור יוצא בלי שינוי.

מבחינת אופרנדים, add מקבלת כל מה ש-mov מקבלת חוץ מזיכרון מול זיכרון, עם אותה דרישה לרוחבים שווים. אחד האופרנדים יכול לשבת בזיכרון: ב-x86 add ecx, [ebp+8] מחברת ישר מהזיכרון, בלי לטעון קודם לאוגר.

הבדל חשוב מ-mov: add מעדכנת דגלים. תוצאה 0 מדליקה את ZF, ונשיאה מהביט העליון מדליקה את CF, כמו add dl, 1 כש-DL=0xFF. הפרק לא שואל על דגלים, אבל טוב לדעת מי נוגע בהם.

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

חזרה לתוכן העניינים

sub: חיסור

Assembly
sub dest, src
פקודהלפניאחרי
sub edx, 8EDX=50EDX=42
sub cx, 20CX=25CX=5
sub bl, 1BL=0x00BL=0xFF (גלישה)
sub esp, 8ESP=0x0FF8ESP=0x0FF0

הכיוון של sub הוא היעד פחות המקור, והתוצאה נכתבת ביעד: dest = dest - src. את sub ecx, [ebp+8] קוראים 'ECX פחות הזיכרון', אף פעם לא להפך. אופרנדים ורוחבים: בדיוק כמו ב-add.

הדוגמה עם ESP אינה מקרית. כדי לפנות במחסנית מקום למשתנה מקומי מחסרים מ-ESP, למשל sub esp, 4 למשתנה אחד, כי המחסנית גדלה לכיוון הכתובות הנמוכות.

חזרה לתוכן העניינים

inc ו-dec: צעד של 1

Assembly
inc dest
dec dest

inc ו-dec הן הגרסה המקוצרת של חיבור 1 וחיסור 1: אופרנד אחד, צעד של אחד. הקיצור הוא גם פיזי, כי את dec ecx ראיתם בפירוק תופסת בית אחד בלבד. ההבדל השני הוא בדגלים: ZF מתעדכן כרגיל, אבל CF לא זז.

פקודהלפניאחרי
inc edxEDX=41EDX=42
dec axAX=0x8000AX=0x7FFF
dec blBL=0x00BL=0xFF
inc ecxECX=0xFFFFFFFFECX=0 (ו-ZF=1)

בדקנו בהרצה גם את עניין הדגלים: אחרי inc ecx שגלשה מ-0xFFFFFFFF ל-0, ZF היה 1, ו-CF נשאר בדיוק כמו שהיה לפני הפקודה.

חזרה לתוכן העניינים

סוגריים מרובעים: גישה לזיכרון

השוו שתי שורות: mov ecx, ebp ו-mov ecx, [ebp]. בראשונה ECX מקבל את המספר ש-EBP מחזיק. בשנייה המספר הזה משמש כתובת, ו-ECX מקבל את מה שכתוב בזיכרון שם.

הסוגריים הם כל ההבדל: הם אומרים 'לכו לכתובת וקחו את התוכן'. [ebp+12] מוסיפה עוד צעד: קודם מחשבים את EBP ועוד 12, ורק אז ניגשים.

כתיבהמשמעות
[ebp+12]הזיכרון בכתובת EBP+12. כמה בתים נקראים נקבע לפי האוגר שבפקודה (עם ECX: ארבעה).
[ebp-8]הזיכרון בכתובת EBP-8.
[esp]הזיכרון בכתובת ש-ESP מצביע עליה, כלומר ראש המחסנית.
mov ecx, [ebp+12]קריאה: ארבעה בתים מהזיכרון נכנסים ל-ECX.
mov [ebp-8], ecxכתיבה: הערך של ECX נכתב לזיכרון.
mov ecx, ebpבלי סוגריים: ECX מקבל את הערך של EBP עצמו, כלומר כתובת, ולא את מה ששמור בה.

כמה בתים נקראים או נכתבים? אם יש בפקודה אוגר, הוא מכתיב את הרוחב, ולכן mov [ebp-8], ecx כותבת ארבעה. אם אין, כמו בהשמה של מספר לזיכרון, מוסיפים מילת רוחב: byte (1), word (2) או dword (4), למשל mov dword [ebp-8], 1.

חזרה לתוכן העניינים

טעויות ובדיקה עצמית: פקודות החישוב

טעויות נפוצות
  • [ebp+12] היא רק דרך אחרת לכתוב את החשבון EBP ועוד 12. בלי סוגריים זו כתובת. עם סוגריים זה מה ששמור בכתובת הזו.
  • באוגר של 8 ביט הסכום 0xFE + 3 הוא 0x101, או לפחות הנשיאה עוברת ל-BH. נשארים רק 8 ביטים, כלומר 0x01, והנשיאה לא עוברת לחצי השני. BH ו-BL נפרדים לגמרי.
  • mov bx, cl ו-mov [total], [price] חוקיות, כי כל אופרנד לבדו חוקי. הצירוף הוא שקובע: רוחבים שונים נדחים, וכך גם שני אופרנדים בזיכרון. העתקה מזיכרון לזיכרון עוברת דרך אוגר.
  • את mov ecx, edx ואת sub ecx, [ebp+8] אפשר לקרוא בשני הכיוונים. היעד תמיד משמאל: הראשונה מעתיקה את EDX ל-ECX, והשנייה מחסירה את הזיכרון מ-ECX.
  • add edx, 3 משנה גם את האוגר שמופיע בשורה שלפניה. פקודה משנה רק את היעד שלה (ואת הדגלים). כל אוגר אחר נשאר כמו שהיה.
בדקו את עצמכם
AX=0x2AFF. מבצעים add al, 1 ואחריה inc ah. מה יהיה AX?

0x2B00. AL גולש מ-0xFF ל-0x00 בלי להעביר נשיאה, ו-inc מעלה את AH מ-0x2A ל-0x2B.

אילו מהשורות האסמבלר יקבל: mov bl, ch, add [x], [y], sub cx, 0x10, mov 7, ebx?

רק mov bl, ch ו-sub cx, 0x10. add [x], [y] משלבת שני אופרנדים בזיכרון, ו-mov 7, ebx מנסה לכתוב לתוך מספר.

אחרי dec ecx יצא ECX=0. איזה דגל בטוח דלק, ואיזה לא זז בגללה?

ZF דלק כי התוצאה 0. CF לא זז, כי dec לא נוגעת בו.

CL=0x05. מה יהיה ב-CL אחרי sub cl, 0x09?

0x05 - 0x09 = -4, ומוסיפים 256: 252, כלומר 0xFC.

חזרה לתוכן העניינים

המחסנית: ESP, push ו-pop

מהי המחסנית

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

מהתמונה הזו נובעות התכונות של המחסנית. היא מתמלאת לכיוון הכתובות הנמוכות, ומה שנכנס אחרון יוצא ראשון. לכן קוראים לה LIFO (Last In, First Out), כמו ערימת ספרים שמורידים ממנה תמיד את העליון.

  • ESP (Stack Pointer) הוא המחוג: הוא מחזיק את הכתובת של הערך שנדחף אחרון, ראש המחסנית.
  • גודל כל תא הוא 4 בתים, 32 ביט. כשמדברים על הכתובת של תא, הכוונה לבית הנמוך שבו.
  • המחסנית שוכנת בקטע הזיכרון SS (ה-segment של המחסנית), והצירוף של SS ו-ESP הוא שמזהה את ראש המחסנית.

כדי שהחשבון יהיה נקי, בכל הדוגמאות כאן ESP מתחיל ב-0x1000. בהרצות האמיתיות שלנו בלינוקס הוא התחיל בכתובת גבוהה בהרבה, אבל זה לא משנה דבר: 4 פחות בכל push, ו-4 יותר בכל pop.

חזרה לתוכן העניינים

push: דחיפה

Assembly
push src

הסדר בתוך push חשוב: המחוג זז קודם, ורק אחר כך כותבים. ESP יורד ב-4, והערך של המקור נכתב ב-[esp], כלומר בתא החדש שנפתח.

המקור הוא האופרנד היחיד, ובפרק הזה הוא תמיד ערך של 32 ביט. מה מותר לדחוף:

אופרנדמותר?דוגמה
אוגר של 32 ביטכןpush ecx
מספר, עשרוני או הקסדצימליכןpush 12, push 0x0C
זיכרון עם רוחבכןpush dword [ebp+12]
אוגר של 8 ביטלאpush bl
EIPלאpush eip

שימו לב לשורת המספרים: push 12 לא כותבת בית אחד. כל דחיפה ממלאת תא שלם, ולכן 12 נשמר כ-0x0000000C. האוגר שנדחף לא מתרוקן, הוא רק מוסר עותק, וגם הדגלים לא משתנים.

דוגמה, כש-ESP=0x1000 ו-ECX=9:

פקודהESP אחריהמה נכתב
push ecx0x0FFCבכתובת 0x0FFC: 9
push 0x0C0x0FF8בכתובת 0x0FF8: 12, מעל ה-9
חזרה לתוכן העניינים

pop: שליפה

Assembly
pop dest

pop היא push בסדר הפוך: קודם קוראים, ורק אז המחוג זז. הערך שב-[esp] מועתק ליעד, ואחר כך ESP עולה ב-4.

אופרנדמותר?דוגמה
אוגר של 32 ביטכןpop edx
זיכרון עם רוחבכןpop dword [total]
מספרלא, אין לאן לכתובpop 5
אוגר של 8 ביטלאpop bl
EIPלא (את זה עושה ret)pop eip

גם כאן NASM דוחה את הצירופים האסורים, יחד עם הדחיפה של אוגר בן 8 ביט:

Assembly
section .text
  push bl               ; an 8-bit register
  pop 5                 ; pop into a number
  pop eip               ; pop into the instruction pointer
פלט
stack.asm:2: error: invalid combination of opcode and operands
stack.asm:3: error: invalid combination of opcode and operands
stack.asm:4: error: symbol `eip' not defined
  • בגלל שהקריאה באה לפני התזוזה, pop מחזירה תמיד את מה שנדחף אחרון.
  • pop לא נוגעת בדגלים.
  • הבתים של הערך שנשלף לא נמחקים. הם נשארים בזיכרון מתחת ל-ESP, מחוץ למחסנית, עד שהדחיפה הבאה תדרוס אותם. בהרצה שלנו, אחרי שלוש דחיפות ושלוש שליפות, הערך האחרון עדיין ישב 12 בתים מתחת ל-ESP.
חזרה לתוכן העניינים

דוגמה: הסדר מתהפך

Assembly
mov ecx, 30
mov edx, 40
push ecx
push edx
pop eax
pop ebx

ESP מתחיל ב-0x1000:

פקודהESPתוכן המחסנית (הראש בסוף)אוגרים
mov ecx, 300x1000ריקהECX=30
mov edx, 400x1000ריקהEDX=40
push ecx0x0FFC30ללא שינוי
push edx0x0FF830, 40ללא שינוי
pop eax0x0FFC30EAX=40
pop ebx0x1000ריקהEBX=30

כך נראית המחסנית אחרי שתי הדחיפות, כשהכתובות הגבוהות למעלה:

כתובתתוכןהערה
0x1000(לא חלק מהמחסנית)כאן ESP התחיל
0x0FFC30נדחף ראשון
0x0FF840נדחף אחרון: ראש המחסנית, ESP מצביע לכאן

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

עוד אחת: push 7, push 8, push 9, ואחריהן pop ecx ו-pop edx. ב-ECX יהיה 9, ב-EDX יהיה 8, ובמחסנית יישאר רק 7.

חזרה לתוכן העניינים

סדר הבתים בתוך תא (little-endian)

מה יושב בבית הראשון של תא שדחפנו לתוכו 0xCAFE1234? התוכנית הבאה מעתיקה ל-BL את הבית שבכתובת הנמוכה ביותר של התא, ויוצאת איתו כקוד יציאה:

Assembly
global _start
section .text
_start:
  push 0xCAFE1234
  mov ebx, 0
  mov bl, [esp]          ; the byte at the lowest address of the cell
  mov eax, 1
  int 0x80
Bash
nasm -f elf32 lend.asm -o lend.o
ld -m elf_i386 lend.o -o lend
./lend
echo $?
פלט
52

יצא 52, כלומר 0x34: הבית הכי פחות משמעותי של הערך, ולא 0xCA שכתוב ראשון משמאל. זו השיטה של x86, little-endian, ולפיה התא כולו נראה כך כש-ESP=0x0FFC:

כתובת0x0FFC0x0FFD0x0FFE0x0FFF
בית3412FECA

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

חזרה לתוכן העניינים

איזון: דחיפות מול שליפות

קחו רצף של ארבע דחיפות ושליפה אחת. בלי לעקוב אחרי כל שורה אפשר לדעת איפה ESP ייגמר: כל push מורידה 4 וכל pop מחזירה 4, ונשארות שלוש דחיפות עודפות, כלומר 12 בתים מתחת לנקודת ההתחלה (גם את זה מדדנו בהרצה).

אותו חשבון חל על כל פקודה שמזיזה את ESP:

פעולהמה קורה ל-ESP
push אחתיורד ב-4
pop אחתעולה ב-4
sub esp, 4יורד ב-4: מקום שמור, בלי לכתוב בו ערך
add esp, 8עולה ב-8: שני ערכים נזרקים בלי שקוראים אותם

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

חזרה לתוכן העניינים

טעויות ובדיקה עצמית: המחסנית

טעויות נפוצות
  • pop מוחקת את מה שהיא שולפת, ולכן הזיכרון שמתחת ל-ESP נקי. pop רק מזיזה את ESP. הבתים נשארים עד שדחיפה אחרת תכתוב עליהם.
  • המחסנית היא תור: מה שנדחף ראשון יוצא ראשון. היא LIFO. pop מחזירה את הערך האחרון שנדחף.
  • push מגדילה את ESP, ובכמה בדיוק תלוי בגודל הערך, בית או שניים. push מקטינה את ESP, ובפרק הזה תמיד ב-4, כי כל תא הוא 32 ביט.
  • פונקציה יכולה להגיע ל-ret עם push שלא נשלפה, ו-ret תסתדר. ret תשלוף את הערך העודף ותקפוץ אליו כאילו הוא כתובת החזרה.
  • push bl ו-pop 5 הן קיצורים חוקיים. שתיהן נדחות: לא דוחפים אוגר של 8 ביט, ולא שולפים לתוך מספר.
בדקו את עצמכם
ESP=0x1000, ואחרי רצף כלשהו של push ו-pop הוא 0x0FF0. כמה ערכים יותר נדחפו משנשלפו?

ארבעה: ההפרש הוא 16 בתים, וכל ערך תופס 4.

רוצים להחליף בין הערכים של ESI ו-EDI בעזרת המחסנית בלבד. באיזה סדר כותבים את הפקודות?

push esi, push edi, pop esi, pop edi. EDI נדחף אחרון ולכן יוצא ראשון, אל ESI.

אחרי push 0x0A0B0C0D, איזה בית יושב בכתובת ESP+3?

0x0A, הבית המשמעותי ביותר, כי ב-little-endian הוא יושב בכתובת הגבוהה של התא.

ESP=0x0FF4 ויש במחסנית שלושה ערכים מיותרים. איזו פקודה אחת מחזירה את ESP ל-0x1000?

add esp, 12: היא מעלה את ESP ב-12 בלי לקרוא את הערכים.

חזרה לתוכן העניינים

call ו-ret: קריאה לפונקציה וחזרה ממנה

call: לקפוץ ולזכור לאן לחזור

Assembly
call label

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

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

jmp labelcall label
מכניסה ל-EIP את כתובת התוויתכןכן
משאירה כתובת חזרה במחסניתלאכן, את כתובת ההוראה שאחריה
השינוי ב-ESPאיןיורד ב-4
אפשר לחזור ממנה עם retלאכן

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

  1. דוחפת למחסנית את הכתובת של ההוראה שבאה מיד אחריה, כתובת החזרה: ESP יורד ב-4, והכתובת נכתבת ב-[esp].
  2. מכניסה ל-EIP את הכתובת של התווית, כך שהריצה עוברת אליה.

אם תרצו נוסחה: call היא push של כתובת ההמשך ומיד אחריה jmp. היא מקבלת תווית, ולא נוגעת לא בדגלים ולא באוגרי הנתונים.

בדקנו בהרצה מה בדיוק יושב בראש המחסנית כשהפונקציה מתחילה. PEEK משווה את הערך העליון, כל 32 הביטים שלו, לכתובת של AFTER_CALL, ויוצאת עם 0 אם הם שווים ועם 1 אם לא:

Assembly
global _start
section .text
_start:
  call PEEK
AFTER_CALL:
  mov eax, 1                    ; exit, code = EBX
  int 0x80
PEEK:
  mov ebx, 1                    ; 1 = the top of the stack is something else
  cmp dword [esp], AFTER_CALL   ; compare the full 32-bit value on top
  jne NOT_SAME
  mov ebx, 0                    ; 0 = exactly the address after the call
NOT_SAME:
  ret
Bash
nasm -f elf32 peek.asm -o peek.o
ld -m elf_i386 peek.o -o peek
./peek
echo $?
פלט
0

יצא 0: בראש המחסנית יושבת בדיוק הכתובת של AFTER_CALL, הפקודה שאחרי ה-call, ולא הכתובת של ה-call ולא של PEEK. ה-ret שבסוף PEEK מחזירה את הריצה לשם, ושתי השורות שמתחת ל-AFTER_CALL מסיימות את התוכנית (cmp ו-jne משמשות כאן רק כדי להפוך את ההשוואה לקוד יציאה).

חזרה לתוכן העניינים

ret: לחזור לכתובת שבראש המחסנית

Assembly
ret

בצד השני עומדת ret, בלי אופרנדים. אם call השאירה פתק, ret קוראת אותו: היא מעבירה את הערך שבראש המחסנית ל-EIP, ומעלה את ESP ב-4.

שימו לב מה חסר כאן: ret לא יודעת מי קרא לה. היא לא מחפשת את ה-call ולא זוכרת אותה, אלא פשוט סומכת על הערך העליון במחסנית.

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

ואיך פונקציה מוסרת תוצאה? לפי מוסכמה, ב-EAX: הקוד שאחרי ה-call קורא משם את התשובה.

חזרה לתוכן העניינים

מעקב: קריאה אחת

Assembly
mov edx, 18
call ADD9
sub edx, 2        ; the return address points here
jmp DONE
ADD9:
add edx, 9
ret
DONE:

נניח ESP=0x1000, ונסמן RA את כתובת החזרה, הכתובת של sub edx, 2:

פקודה שהתבצעהEDXESPהמחסניתהערה
mov edx, 18180x1000ריקהערך התחלתי.
call ADD9180x0FFCRAנדחפת הכתובת של sub edx, 2, ו-EIP עובר ל-ADD9.
add edx, 9270x0FFCRAבתוך הפונקציה.
ret270x1000ריקהEIP=RA.
sub edx, 2250x1000ריקהממשיכים מיד אחרי ה-call.
jmp DONE250x1000ריקהקפיצה מעל הפונקציה. בלעדיה הריצה הייתה נכנסת ל-ADD9 שוב (ראו נפילה לתוך פונקציה).
חזרה לתוכן העניינים

אותה פונקציה, שתי קריאות

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

Assembly
mov ebx, 3
call F            ; first call
call F            ; second call
jmp END
F:
add ebx, ebx
add ebx, 1
ret
END:
פקודה שהתבצעהEBXהערה
mov ebx, 33ערך התחלתי.
call F3כתובת החזרה: ה-call השני.
add ebx, ebx6F בפעם הראשונה: הכפלה.
add ebx, 17ועוד 1.
ret7חזרה ל-call השני.
call F7כתובת החזרה הפעם: jmp END.
add ebx, ebx14F בפעם השנייה: הכפלה.
add ebx, 115ועוד 1.
ret15חזרה ל-jmp END.
jmp END15סוף.

התוצאה היא 15. מי שמריץ את F פעם אחת בלבד עוצר ב-7.

חזרה לתוכן העניינים

פונקציה שקוראת לפונקציה

כאן OUTER קוראת בעצמה ל-INNER:

Assembly
mov ecx, 2
call OUTER
jmp END
OUTER:
add ecx, 3
call INNER
add ecx, 7        ; return address of call INNER
ret
INNER:
add ecx, 50
ret
END:

נניח ESP=0x1000. RA1 היא הכתובת של jmp END (החזרה מ-OUTER), ו-RA2 היא הכתובת של add ecx, 7 (החזרה מ-INNER).

פקודה שהתבצעהECXESPהמחסנית (הראש בסוף)
mov ecx, 220x1000ריקה
call OUTER20x0FFCRA1
add ecx, 350x0FFCRA1
call INNER50x0FF8RA1, RA2
add ecx, 50550x0FF8RA1, RA2
ret (מתוך INNER)550x0FFCRA1. הריצה עוברת ל-RA2.
add ecx, 7620x0FFCRA1
ret (מתוך OUTER)620x1000ריקה. הריצה עוברת ל-RA1.
jmp END620x1000ריקה

שימו לב לעמודת המחסנית: RA2 נכנסה אחרי RA1, ולכן יצאה לפניה. כך זה בכל קינון: ה-ret הראשונה שייכת תמיד לפונקציה הפנימית ביותר שעדיין רצה, והחיצונית חוזרת רק אחריה (LIFO).

חזרה לתוכן העניינים

נפילה לתוך פונקציה: למה שמים jmp לפני הפונקציות

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

בתוכנית הבאה ה-jmp הזו חסרה:

Assembly
global _start
section .text
_start:
  mov edx, 2
  call G
  add edx, 30
G:                     ; no jmp before it: execution falls in
  add edx, 5
  ret                  ; second time here: no return address on the stack
פקודה שהתבצעהEDXהערה
mov edx, 22ערך התחלתי.
call G2קריאה רגילה. כתובת החזרה: add edx, 30.
add edx, 57G בפעם הראשונה.
ret7חזרה ל-add edx, 30.
add edx, 3037ממשיכים בזרימה רגילה.
add edx, 542נפלנו לתוך G: הפונקציה רצה שוב, בלי שום call.
ret42בראש המחסנית אין כתובת חזרה אמיתית.

בשאלת מבחן ה-ret האחרונה היא פשוט סוף הקטע, והתשובה היא 42. בתוכנית אמיתית זו תקלה: כשהרצנו את הקוד הזה בלינוקס, ה-ret השנייה שלפה ערך שאינו כתובת קוד, והתוכנית קרסה עם Segmentation fault (קוד יציאה 139).

חזרה לתוכן העניינים

טעויות ובדיקה עצמית: call ו-ret

טעויות נפוצות
  • ret חוזרת לתחילת התוכנית, או למקום ש-call רשמה אצלה. ret לא זוכרת דבר. היא קופצת לכתובת שבראש המחסנית, ורק לשם.
  • הכתובת ש-call דוחפת היא של ה-call עצמה, של התווית, או של תחילת התוכנית. זו הכתובת של הפקודה שמיד אחרי ה-call, כפי שראינו גם בהרצה של PEEK.
  • במעקב אפשר לדלג על call, או לפחות לעצור כשהפונקציה מסתיימת. הפונקציה רצה במלואה, ואחרי ret ממשיכים מהפקודה שאחרי ה-call עד סוף הקטע.
  • פונקציה רצה פעם אחת, כי היא כתובה בקוד פעם אחת. היא רצה פעם לכל call. שתי קריאות, שתי ריצות.
  • כל פונקציה רצה גם בזרימה רגילה, ולכן קריאה אחת מריצה אותה פעמיים. זה קורה רק כשאין jmp שעוקפת אותה. עם ה-jmp היא רצה רק כשקוראים לה.
  • אפשר לוותר על ה-jmp שמעל הפונקציות. בלעדיה הריצה נופלת לתוכן, ובסוף ret שולפת ערך שאינו כתובת חזרה, כמו בתוכנית שקרסה.
בדקו את עצמכם
תלמיד ענה 10 על הקטע mov ecx, 4, call ADD6, call ADD6, jmp END, ADD6:, add ecx, 6, ret, END:. מה הוא שכח, ומה התשובה?

הוא הריץ את הפונקציה פעם אחת. כל call מריצה אותה מחדש, ולכן ECX = 4 + 6 + 6 = 16.

ESP=0x2000 לפני call. מה יהיו ESP והערך שב-[esp] בפקודה הראשונה של הפונקציה, ומה יהיה ESP אחרי ה-ret?

ESP=0x1FFC, וב-[esp] הכתובת של הפקודה שאחרי ה-call. אחרי ה-ret ESP חוזר ל-0x2000.

בפונקציה הייתה push ebx בלי pop לפני ה-ret. לאן ret תקפוץ?

לערך של EBX, כי הוא יושב בראש המחסנית, מעל כתובת החזרה. זו כמעט תמיד כתובת שגויה.

OUTER קוראת ל-INNER. כמה כתובות חזרה יש במחסנית בזמן ש-INNER רצה, ואיזו מהן תשמש ראשונה?

שתיים. הראשונה שתשמש היא זו של INNER, שנדחפה אחרונה.

חזרה לתוכן העניינים

Stack frame: המסגרת של קריאה אחת במחסנית

למה פונקציה צריכה מסגרת משלה

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

כל קריאה לפונקציה מקבלת במחסנית רצועה משלה, והרצועה הזו נקראת מסגרת מחסנית (stack frame). כשהקריאה מסתיימת, הרצועה משתחררת.

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

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

  • מעל הסיכה, בהיסטים חיוביים כמו [ebp+8] ו-[ebp+12], יושבים הפרמטרים. אותם דחף הקורא לפני הקריאה.
  • מתחת לסיכה, בהיסטים שליליים כמו [ebp-4] ו-[ebp-8], יושבים המשתנים המקומיים. אותם מקצה הפונקציה עצמה.
חזרה לתוכן העניינים

תפקיד הקורא לפי cdecl: דחיפה, call וניקוי

מוסכמת הקריאה cdecl ב-32 ביט קובעת מי אחראי על מה. החלק של הקורא בנוי משלושה צעדים:

  1. דוחפים את הפרמטרים מימין לשמאל: הפרמטר האחרון ברשימה נכנס למחסנית ראשון, והפרמטר הראשון נכנס אחרון, ממש לפני ה-call.
  2. מבצעים call, והיא מוסיפה למחסנית את כתובת החזרה.
  3. כשהפונקציה חזרה, מרימים את ESP מעל הפרמטרים עם add esp, N, כאשר N הוא 4 בתים כפול מספר הפרמטרים. לשני פרמטרים כותבים add esp, 8, ולשלושה add esp, 12.

למשל, קריאה בסגנון area(5, 9) הופכת ל-push 9, אחריה push 5, ואז call area. אחרי החזרה בא add esp, 8.

נניח ש-ESP היה 0x0900 לפני push 9. אחרי שתי הדחיפות וה-call הוא 0x08F4, ו-ret מעלה אותו רק ל-0x08F8, כי היא לוקחת את כתובת החזרה ותו לא. רק add esp, 8 מחזירה אותו ל-0x0900, ובלעדיה כל קריאה הייתה משאירה מאחור שמונה בתים.
חזרה לתוכן העניינים

פתיחת המסגרת (prologue)

פונקציה שבונה מסגרת פותחת תמיד באותן שורות:

Assembly
push ebp          ; keep the caller's base pointer
mov ebp, esp      ; pin the anchor of this call
sub esp, 8        ; optional: two local slots, [ebp-4] and [ebp-8]
שורהמה היא משנהבשביל מה
push ebpESP יורד ב-4, ובראש המחסנית נשמר ה-EBP של הקוראכדי שביציאה אפשר יהיה להחזיר לקורא את העוגן שלו
mov ebp, espEBP מצביע עכשיו על ראש המחסנית, כלומר על הערך שנשמר הרגעמכאן והלאה [ebp] הוא ה-EBP של הקורא, וכל השאר נמדד ממנו
sub esp, NESP יורד עוד N בתים, בכפולות של 4פינוי מקום למשתנים מקומיים. פונקציה בלי משתנים כאלה מוותרת על השורה
חזרה לתוכן העניינים

מפת המסגרת: מה יושב בכל היסט

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

היסט מ-EBPתוכןמי הניח אותו שם
[ebp+12]פרמטר 2הקורא, בדחיפה הראשונה
[ebp+8]פרמטר 1הקורא, בדחיפה האחרונה
[ebp+4]כתובת החזרההפקודה call
[ebp]ה-EBP של הקוראהשורה push ebp בפתיחה
[ebp-4]משתנה מקומי 1הפונקציה, אחרי sub esp
[ebp-8]משתנה מקומי 2, אם יש כזההפונקציה, אחרי sub esp

הסדר בטבלה הפוך לסדר הכניסה. כל ערך שנכנס למחסנית נוחת 4 בתים מתחת לקודם, ולכן פרמטר 2, הראשון שנכנס, תפס את השורה העליונה.

עם שלושה פרמטרים, למשל בקריאה box(4, 7, 2), הקורא דוחף 2, אחריו 7 ואחריו 4. בתוך הפונקציה 4 נמצא ב-[ebp+8], 7 ב-[ebp+12] ו-2 ב-[ebp+16]: כל פרמטר נוסף מתרחק מ-EBP עוד 4 בתים.

את ה-8 של הפרמטר הראשון אפשר לחשב במקום לשנן. סופרים מ-EBP כלפי מעלה: בהיסט 0 ה-EBP השמור, בהיסט 4 כתובת החזרה, ורק בהיסט 8 מגיעים לנתון שהקורא שלח. מי שקורא את [ebp+4] כאילו היה פרמטר מקבל בעצם כתובת בקוד.
חזרה לתוכן העניינים

איזה ערך נוחת באיזה היסט

נניח שהקורא כותב:

Assembly
push 0x30
push 0x0C
call DIFF

הערך 0x0C נכנס אחרון, ולכן מבין השניים הוא הקרוב ביותר ל-EBP ונמצא ב-[ebp+8]. הערך 0x30 נכנס קודם, ולכן מקומו ב-[ebp+12].

מתי נדחףערךהיסט בתוך DIFF
בדחיפה הראשונה0x30[ebp+12]
בדחיפה השנייה, האחרונה לפני call0x0C[ebp+8]

הכלל נקבע רק לפי סדר הדחיפה. גודל הערכים לא משחק תפקיד: גם כשהערך שנדחף אחרון קטן מהראשון, הוא עדיין ב-[ebp+8].

הסדר הכי קריטי כשיש חיסור. בתוך DIFF, השורה mov eax, [ebp+12] ואחריה sub eax, [ebp+8] נותנות 0x30 פחות 0x0C, כלומר 0x24. מי שמחליף בין ההיסטים מחשב חיסור הפוך ומקבל תוצאה אחרת לגמרי.

חזרה לתוכן העניינים

סגירת המסגרת (epilogue)

Assembly
mov esp, ebp      ; drop the locals: ESP back on the saved EBP
pop ebp           ; give the caller its base pointer back
ret               ; continue at the return address
שורהמה קורה
mov esp, ebpESP חוזר אל הכתובת שבה שמור ה-EBP של הקורא. המשתנים המקומיים לא נמחקים פיזית, אבל הם כבר מתחת לראש המחסנית ונחשבים משוחררים.
pop ebpהערך השמור חוזר ל-EBP, ו-ESP עולה ב-4.
retכתובת החזרה נטענת ל-EIP, ו-ESP עולה ב-4 נוספים.

האם השורה הראשונה תמיד נחוצה? זה תלוי בשאלה אם הפונקציה הזיזה את ESP. אם לא היה sub esp ולא נשאר push בלי pop, ESP ו-EBP כבר מצביעים על אותה משבצת, ו-pop ebp ואחריה ret עושות את כל העבודה.

עכשיו דמיינו פונקציה שפתחה ב-sub esp, 8 ושכחה את השחזור. pop ebp תיקח את מה שבראש, כלומר את [ebp-8], ו-ret תקפוץ לכתובת שנלקחה מ-[ebp-4]. את זה מונעים בהחזרת ESP למקומו, עם mov esp, ebp או עם add esp, 8.

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

מעקב מלא: פונקציה שמחסרת פרמטר מפרמטר

תרחיש 1: חיסור של שני פרמטרים בתוך מסגרת

התוכנית קוראת ל-MINUS כמו לקריאה minus(25, 6): הפרמטר הראשון 25 והשני 6. זו תוכנית שלמה ל-Linux ב-32 ביט, ובסוף היא מחזירה את EAX כקוד היציאה שלה.

MINUS משתמשת ב-EBX כאוגר עזר, ולכן היא שומרת אותו במחסנית מיד אחרי הפתיחה ומשחזרת אותו לפני הסגירה, כדי לא לפגוע בערך של הקורא. ה-push הנוסף מזיז את ESP, אבל ההיסטים מ-EBP נשארים כמו שהיו.

Assembly
section .text
global _start
_start:
    push 6
    push 25
    call MINUS
    add esp, 8
    jmp FIN
MINUS:
    push ebp
    mov ebp, esp
    push ebx
    mov ebx, [ebp+12]
    mov eax, [ebp+8]
    sub eax, ebx
    pop ebx
    pop ebp
    ret
FIN:
    mov ebx, eax      ; the result becomes the exit status
    mov eax, 1        ; Linux sys_exit
    int 0x80
Bash
nasm -f elf32 minus.asm -o minus.o
ld -m elf_i386 minus.o -o minus
./minus; echo $?
פלט
19

עכשיו המעקב עצמו. נניח שלפני הקוד ESP=0x0800 ו-EBP=0x0A00, ונקרא RA לכתובת החזרה, כלומר לכתובת של add esp, 8. הכתובות בטבלה הן מעקב ידני לפי הכללים, לא פלט של התוכנית.

#פקודהEAXESPEBPמה קרה
1push 6-0x07FC0x0A00בכתובת 0x07FC נכתב 6
2push 25-0x07F80x0A00בכתובת 0x07F8 נכתב 25
3call MINUS-0x07F40x0A00בכתובת 0x07F4 נכתבה RA, ו-EIP עובר ל-MINUS
4push ebp-0x07F00x0A00בכתובת 0x07F0 נשמר 0x0A00, ה-EBP של הקורא
5mov ebp, esp-0x07F00x07F0העוגן של הקריאה הזו קובע
6push ebx-0x07EC0x07F0הערך הקודם של EBX נשמר ב-0x07EC. ESP זז, EBP לא
7mov ebx, [ebp+12]-0x07EC0x07F0EBX מקבל 6, שנקרא מ-0x07FC
8mov eax, [ebp+8]250x07EC0x07F0הקריאה היא מ-0x07F8
9sub eax, ebx190x07EC0x07F025 פחות 6
10pop ebx190x07F00x07F0EBX חזר לערך שהיה לו לפני MINUS
11pop ebp190x07F40x0A00ה-EBP של הקורא חזר
12ret190x07F80x0A00EIP מקבל את RA
13add esp, 8190x08000x0A00שני הפרמטרים הוסרו, ESP כמו בהתחלה
14jmp FIN190x08000x0A00מעבר לסוף התוכנית

תמונת המחסנית אחרי שורה 6, כשהכתובות הגבוהות למעלה:

כתובתתוכןהיסט ותפקיד
0x07FC6[ebp+12], פרמטר 2
0x07F825[ebp+8], פרמטר 1
0x07F4RA[ebp+4], כתובת החזרה
0x07F00x0A00[ebp], ה-EBP השמור. לכאן מצביע EBP
0x07ECEBX הקודם[ebp-4], שמור עד pop ebx. לכאן מצביע ESP

בסוף EAX=19, בדיוק קוד היציאה שהתוכנית האמיתית החזירה, ו-ESP חזר לערך שלפני הקריאה.

חזרה לתוכן העניינים

מעקב מלא: פונקציה עם משתנים מקומיים

תרחיש 2: משתנים מקומיים לצד שני פרמטרים

הפעם הפונקציה MIX שומרת ב-[ebp-4] את הפרמטר הראשון כפול שניים. הקורא דוחף 3 ואחריו 11, ולכן בתוך MIX הערך ב-[ebp+8] הוא 11 והערך ב-[ebp+12] הוא 3.

MIX מקצה שלוש משבצות מקומיות: [ebp-4] מקבלת את הפרמטר הראשון כפול שניים, [ebp-8] עותק של הפרמטר השני, ו-[ebp-12] את התוצאה. בסוף היא משחררת אותן עם add esp, 12, החלופה ל-mov esp, ebp כשידוע כמה בתים הוקצו.

Assembly
section .text
global _start
_start:
    push 3
    push 11
    call MIX
    add esp, 8
    jmp FIN
MIX:
    push ebp
    mov ebp, esp
    sub esp, 12
    mov ecx, [ebp+8]
    add ecx, ecx
    mov [ebp-4], ecx
    mov edx, [ebp+12]
    mov [ebp-8], edx
    mov ecx, 0
    mov eax, [ebp-8]
    mov ecx, [ebp-4]
    add eax, ecx
    sub eax, [ebp+8]
    mov [ebp-12], eax
    add esp, 12
    pop ebp
    ret
FIN:
    mov ebx, eax      ; exit status = EAX
    mov eax, 1
    int 0x80
Bash
nasm -f elf32 mix.asm -o mix.o
ld -m elf_i386 mix.o -o mix
./mix; echo $?
פלט
14

אותן הנחות כמו קודם: לפני הקוד ESP=0x0800 ו-EBP=0x0A00. גם כאן הכתובות הן מעקב ידני.

#פקודהEAXESPEBPמה קרה
1push 3-0x07FC0x0A00-
2push 11-0x07F80x0A00-
3call MIX-0x07F40x0A00RA נדחפת
4push ebp-0x07F00x0A00-
5mov ebp, esp-0x07F00x07F0-
6sub esp, 12-0x07E40x07F0נפתחו [ebp-4] (0x07EC), [ebp-8] (0x07E8) ו-[ebp-12] (0x07E4)
7mov ecx, [ebp+8]-0x07E40x07F0ECX מקבל 11, פרמטר 1
8add ecx, ecx-0x07E40x07F0ECX = 11 ועוד 11 = 22
9mov [ebp-4], ecx-0x07E40x07F0המשתנה המקומי הראשון מקבל 22
10mov edx, [ebp+12]-0x07E40x07F0EDX מקבל 3, פרמטר 2
11mov [ebp-8], edx-0x07E40x07F0המשתנה המקומי השני מקבל 3
12mov ecx, 0-0x07E40x07F0ECX מתאפס, כדי שהערך הבא יגיע רק מהזיכרון
13mov eax, [ebp-8]30x07E40x07F0EAX נטען מהמשתנה המקומי השני
14mov ecx, [ebp-4]30x07E40x07F0ECX נטען שוב, 22, מהמשתנה המקומי הראשון
15add eax, ecx250x07E40x07F03 ועוד 22
16sub eax, [ebp+8]140x07E40x07F025 פחות 11
17mov [ebp-12], eax140x07E40x07F0המשתנה המקומי השלישי שומר את התוצאה
18add esp, 12140x07F00x07F0שלוש המשבצות המקומיות שוחררו
19pop ebp140x07F40x0A00-
20ret140x07F80x0A00EIP מקבל את RA
21add esp, 8140x08000x0A00הקורא הסיר את הפרמטרים, והמחסנית מאוזנת

תמונת המחסנית אחרי שורה 17:

כתובתתוכןהיסט ותפקיד
0x07FC3[ebp+12], פרמטר 2
0x07F811[ebp+8], פרמטר 1
0x07F4RA[ebp+4], כתובת החזרה
0x07F00x0A00[ebp], ה-EBP השמור. לכאן מצביע EBP
0x07EC22[ebp-4], משתנה מקומי 1
0x07E83[ebp-8], משתנה מקומי 2
0x07E414[ebp-12], משתנה מקומי 3. לכאן מצביע ESP

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

טעויות נפוצות
  • [ebp+4] הוא הפרמטר הראשון. ב-[ebp+4] יושבת כתובת החזרה ש-call דחפה. הפרמטר הראשון מתחיל ב-[ebp+8].
  • הערך שנדחף ראשון נמצא ב-[ebp+8]. ההפך: הדחיפה האחרונה, זו שממש לפני call, נוחתת ב-[ebp+8], והדחיפה שלפניה ב-[ebp+12].
  • מספיק לקרוא את [ebp+8], או לחבר אותו לעצמו, כשהשורה מבקשת את שני הפרמטרים. שורה שקוראת גם את [ebp+12] מכניסה לחישוב ערך שני ושונה. מי שמשתמש רק באחד, או סופר את הראשון פעמיים, יוצא עם תוצאה שגויה.
  • אפשר לנחש אם מחברים או מחסרים לפי האופי של הפונקציה. מה שקובע הוא הפקודה בכל שורה: add מחברת ו-sub מחסרת. קוראים כל שורה בדיוק כפי שהיא כתובה.
  • כשיש חיסור בפונקציה, מה שמחסרים הוא תמיד הפרמטר השני. בודקים איזה אופרנד כתוב. sub eax, [ebp-4] מחסרת את המשתנה המקומי ו-sub eax, [ebp+12] את הפרמטר השני, ומי שמחליף ביניהם מקבל ערך אחר.
  • אפשר לעצור את המעקב כשהערך כבר נראה סופי. פקודת החישוב האחרונה לפני הסגירה עדיין משנה את EAX. ממשיכים עד ה-ret ואחריה.
  • אחרי ret המחסנית חוזרת לבד למצב שלפני הקריאה. ret מסירה רק את כתובת החזרה. בלי add esp, 8 שני הפרמטרים נשארים, ו-ESP לא מאוזן.
  • כל push בתוך הפונקציה מזיז גם את EBP. push ו-pop משנים רק את ESP. EBP נקבע פעם אחת בפתיחה, ולכן ההיסטים ממנו נשארים נכונים לאורך כל הפונקציה.
  • אפשר לסיים פונקציה עם מסגרת ב-ret בלי pop ebp. אז ESP מצביע על ה-EBP השמור, ו-ret טוענת אותו ל-EIP כאילו היה כתובת החזרה. הריצה ממשיכה במקום שגוי.
בדקו את עצמכם
קורא מבצע push 0x40, אחר כך push 0x09, ואז call P. אחרי הפתיחה של P, מה יש ב-[ebp+8] ומה ב-[ebp+12]?

ב-[ebp+8] יושב 0x09, שנדחף אחרון, וב-[ebp+12] יושב 0x40.

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

add esp, 16, כי ארבעה פרמטרים של 4 בתים תופסים 16 בתים.

איפה תמצאו את המשתנה המקומי השני, ואיפה את ה-EBP של הקורא?

המשתנה המקומי השני ב-[ebp-8], וה-EBP של הקורא ב-[ebp] עצמו.

הקורא מבצע push 20, push 6, call H. הפונקציה H פותחת מסגרת רגילה, טוענת ל-EAX את [ebp+12], מחסרת ממנו את [ebp+8], סוגרת את המסגרת וחוזרת. מה ערך EAX כש-H חוזרת?

ב-[ebp+12] יושב 20, שנדחף ראשון, וב-[ebp+8] יושב 6. לכן EAX = 20 - 6 = 14.

בפונקציה עם sub esp, 8 שכחו את mov esp, ebp לפני pop ebp. מה תקבל pop ebp, ולאן תקפוץ ret?

ESP מצביע על [ebp-8], ולכן pop ebp מקבלת את המשתנה המקומי השני. אחריה ret לוקחת את [ebp-4] ומשתמשת בו ככתובת חזרה, וזו כתובת שגויה.

חזרה לתוכן העניינים

far ו-near: קפיצה בתוך הקטע או אל קטע אחר

קטעי זיכרון, קטע הקוד והאוגר CS

כתובת של הוראה במעבד x86 דומה לכתובת בעיר שיש בה מספר בניין ומספר דירה. הבניין הוא קטע זיכרון (segment), והדירה היא ההיסט בתוכו.

הבניין שבו גרות ההוראות של התוכנית נקרא code segment, ובקובץ המקור זה האזור section .text. את מספר הבניין הנוכחי מחזיק האוגר CS ואת מספר הדירה EIP, ולכן כל הוראה מגיעה מ-CS:EIP (בקוד 16 ביט מ-CS:IP).

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

חזרה לתוכן העניינים

near: נשארים באותו code segment

נניח ש-main קוראת ל-sum, ושתיהן גרות באותו בניין, כלומר באותו code segment. CS כבר נכון, ולכן מה שההוראה צריכה לספק הוא רק דירה חדשה, ערך חדש ל-EIP.

פקודת nearמה משתנהמה עובר דרך המחסנית
jmpEIP מקבל את כתובת היעדכלום
callEIP מקבל את כתובת היעדנכנס ערך אחד, כתובת החזרה, ו-ESP יורד ב-4
retEIP מקבל את הערך שבראש המחסניתיוצא ערך אחד, ו-ESP עולה ב-4
בשאלות המעקב של הנושא הזה אין far בכלל: כל jmp וכל call שם הם near.
חזרה לתוכן העניינים

far: מעבר ל-code segment אחר

עכשיו main קוראת לשגרה שגרה בבניין אחר. החלפת דירה כבר לא מספיקה, וההוראה טוענת ל-CS מספר בניין חדש יחד עם ההיסט שהיא כותבת ל-EIP.

פקודת farמה משתנהמה עובר דרך המחסנית
far jmpCS ו-EIP יחדכלום
far callCS ו-EIP יחד, אחרי השמירהנכנסים שני ערכים: קודם CS, ומעליו EIP. ב-32 ביט ESP יורד ב-8 ולא ב-4
retf (return far)EIP ואחריו CS, מתוך המחסניתיוצאים שני הערכים, EIP ראשון ו-CS שני

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

מאפייןnearfar
איפה היעדבאותו code segmentב-code segment אחר
מה jmp משנהEIP בלבדCS וגם EIP
מה call דוחפתEIP בלבדCS, ואחריו EIP
ESP אחרי call (נובע ממה שנדחף)יורד בערך אחדיורד בשני ערכים, כלומר יותר
פקודת החזרהretretf

כך נראה ראש המחסנית מיד אחרי far call:

כתובתתוכןהסבר
ESP+4CSנדחף ראשון, ולכן יושב גבוה יותר
ESPEIP, כלומר כתובת החזרהנדחף אחרון ונמצא בראש המחסנית
חזרה לתוכן העניינים

מה מסוגל לשנות את CS

את CS אי אפשר לטעון עם mov. הוא משתנה רק דרך פקודות זרימה שמביאות איתן קטע חדש:

  • far jmp.
  • far call.
  • retf, שמחזירה ל-CS את הערך ששמר ה-far call.
  • פסיקה: int n דוחפת למחסנית שלושה ערכים, הדגלים, CS ו-EIP, ושגרת הפסיקה חוזרת עם iret.

ב-far call היעד כולל את שני החלקים, ואפשר לראות זאת בקידוד של הפקודה. הקטע הבא (16 ביט) עובר הרכבה ב-nasm ופירוק ב-ndisasm:

Assembly
bits 16
call 0x4800:0x0010   ; far call: target segment 0x4800, offset 0x0010
retf                 ; far return: pops IP, then CS
Bash
nasm -f bin far.asm -o far.bin
ndisasm -b 16 far.bin
פלט
00000000  9A10000048        call word 0x4800:word 0x10
00000005  CB                retf

בבתים של ה-call מופיעים גם ההיסט 0x0010 וגם הקטע 0x4800. את הקוד הזה לא מריצים כאן, כי הוא דורש מעבד ב-real mode.

דוגמה מספרית ב-real mode, שבו כתובת פיזית מחושבת כ-segment כפול 16 ועוד offset:

מצבCSIPכתובת פיזית
לפני הקפיצה0x30000x01000x30000 + 0x0100 = 0x30100
אחרי far jmp אל 0x4800:0x00100x48000x00100x48000 + 0x0010 = 0x48010
אילו הייתה near jmp אל IP=0x05000x30000x05000x30000 + 0x0500 = 0x30500, עדיין בקטע המקורי

קפיצת near יכולה לשנות רק את IP, ולכן היא לא יוצאת מהקטע שבו הריצה נמצאת.

חזרה לתוכן העניינים

המודל השטוח (flat): near כמעט תמיד

קחו תוכנית 32 ביט רגילה שהקוד שלה מפוזר בכמה קבצי מקור. הלינקר מאחד את כולם, ובמודל הזיכרון השטוח (flat) שבו עובדות מערכות 32 ביט מודרניות כל הקוד הזה גר בבניין אחד. לכן קריאה מ-main אל parse שבקובץ אחר היא near, בדיוק כמו קפיצה בתוך אותה פונקציה.

בתוכנית כזו near היא המקרה הרגיל כמעט תמיד. far שמורה למקרים הנדירים שבהם באמת עוברים לקטע אחר.

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

טעויות נפוצות
  • near מחליפה את CS, ו-far נוגעת רק ב-EIP. בדיוק הפוך: near מעדכנת EIP בלבד, ו-far מעדכנת גם את CS.
  • near ו-far משנות אוגרים באותה דרך, או שאינן משנות אוגרים בכלל. שתיהן משנות את EIP, כי זה כל הטעם בקפיצה. רק far משנה בנוסף את CS.
  • far call דוחפת רק את CS, או דוחפת את EBP. היא דוחפת שני ערכים: CS ואחריו EIP. EBP לא נדחף על ידי שום call.
  • call שומרת את EBP באופן אוטומטי. שמירת EBP היא עבודה של הפונקציה עצמה, בשורה push ebp שבפתיחת המסגרת.
  • במודל השטוח רוב הקריאות הן far. במודל השטוח יש קטע קוד אחד, ולכן הרוב המוחלט של הקפיצות והקריאות הן near.
  • אפשר לחזור מ-far call עם ret. ret שולפת רק את EIP, ו-CS השמור נשאר תקוע במחסנית. החזרה הנכונה היא retf.
בדקו את עצמכם
באיזה סדר retf מוציאה ערכים מהמחסנית?

קודם EIP, שנמצא בראש, ואחריו CS. זה הסדר ההפוך לדחיפה של far call.

ב-32 ביט, בכמה בתים ESP יורד ב-near call, ובכמה ב-far call?

ב-4 בתים ב-near call, וב-8 בתים ב-far call, כי שם נדחפים שני ערכים.

תוכנית 32 ביט במודל שטוח: הפונקציה main קוראת לפונקציה parse שכתובה בקובץ מקור אחר. האם זו קריאת near או far?

near. שני הקבצים מקושרים לאותו code segment, ולכן CS לא משתנה.

רוצים לטעון ל-CS ערך חדש. האם אפשר לעשות זאת עם mov?

לא. הדרכים לשנות את CS הן far jmp, far call, retf או פסיקה (int, והחזרה ממנה ב-iret).

חזרה לתוכן העניינים

מעקבים נוספים, צעד אחר צעד

לפני המעקבים: איך לעבוד איתם

החלק הזה הוא מגרש אימון: חמישה קטעי קוד קצרים, ובכל אחד שילוב של דילוגי jmp, גלישה באוגר קטן או קריאות call. מעקבים שמערבים את המחסנית ואת המסגרת כבר עברתם בחלקים של call ו-ret ושל מסגרת המחסנית.

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

חזרה לתוכן העניינים

מעקב: דילוגים בשרשרת באוגר של 8 ביט

תרחיש 3: שני דילוגים וחיסור שעובר מתחת לאפס
Assembly
mov dl, 0x15
jmp P1
add dl, 0x70
P1:
add dl, 0x08
jmp P2
sub dl, 0x01
P2:
sub dl, 0x20
#מה התבצעDL אחריהערה
1mov dl, 0x150x15-
2jmp P10x15add dl, 0x70 לא מתבצעת
3add dl, 0x080x1D0x15 ועוד 0x08
4jmp P20x1Dsub dl, 0x01 לא מתבצעת
5sub dl, 0x200xFD0x1D פחות 0x20 הוא מינוס 3, וב-8 ביט מינוס 3 נשמר כ-0xFD

בסוף DL=0xFD. שתי השורות המדולגות לא משאירות שום עקבה בתוצאה.

חזרה לתוכן העניינים

מעקב: AH ו-AL כשני אוגרים נפרדים

תרחיש 4: גלישה ב-AL שלא עוברת ל-AH
Assembly
mov ax, 0x4CE0
jmp A1
sub ah, 0x02
A1:
add al, 0x35
jmp A2
add ah, 0x10
A2:
sub ah, 0x01
#מה התבצעAHALAXהערה
1mov ax, 0x4CE00x4C0xE00x4CE0-
2jmp A10x4C0xE00x4CE0sub ah, 0x02 לא מתבצעת
3add al, 0x350x4C0x150x4C150xE0 ועוד 0x35 הם 0x115. ב-AL נשאר 0x15, ו-AH לא זז
4jmp A20x4C0x150x4C15add ah, 0x10 לא מתבצעת
5sub ah, 0x010x4B0x150x4B15AL לא מושפע

בסוף AX=0x4B15. היחידה העודפת מהחיבור ב-AL פשוט נעלמת ולא מתווספת ל-AH. מי שמעביר אותה ל-AH מקבל 0x4C15, וזו טעות.

חזרה לתוכן העניינים

מעקב: אותה פונקציה פעמיים, וגלישה בפעם השנייה

תרחיש 5: שתי קריאות ל-BUMP
Assembly
mov dh, 0xFD
call BUMP
call BUMP
jmp AFTER
BUMP:
add dh, 0x02
ret
AFTER:
add dh, 0x10

נקרא RA1 לכתובת של ה-call השני, ו-RA2 לכתובת של jmp AFTER.

#מה התבצעDHבמחסניתהערה
1mov dh, 0xFD0xFDריקה-
2call BUMP0xFDRA1הקריאה הראשונה
3add dh, 0x020xFFRA1עדיין אין גלישה
4ret0xFFריקהחזרה אל ה-call השני
5call BUMP0xFFRA2הקריאה השנייה
6add dh, 0x020x01RA20xFF ועוד 2 הם 0x101, וב-8 ביט נשאר 0x01
7ret0x01ריקהחזרה אל jmp AFTER
8jmp AFTER0x01ריקהקפיצה מעל הגוף של BUMP, כדי שלא ירוץ פעם שלישית
9add dh, 0x100x11ריקה-

בסוף DH=0x11. כל ret חזרה בדיוק לשורה שאחרי ה-call שהפעיל אותה.

חזרה לתוכן העניינים

מעקב: קפיצה אחורה באוגר של 16 ביט

תרחיש 6: קטע שדולג ואז רץ
Assembly
mov dx, 0x0030
jmp R2
R1:
sub dx, 0x0004
jmp R3
R2:
add dx, 0x000C
jmp R1
R3:
add dx, 0x0001
#מה התבצעDX אחריהערה
1mov dx, 0x00300x0030-
2jmp R20x0030קפיצה מעל הקטע R1
3add dx, 0x000C0x003Cבתוך R2
4jmp R10x003Cקפיצה אחורה, אל הקטע שדולג
5sub dx, 0x00040x0038עכשיו R1 רץ
6jmp R30x0038קפיצה קדימה
7add dx, 0x00010x0039-

בסוף DX=0x0039. סדר הביצוע שונה מסדר הכתיבה: הקטע R1, שכתוב ראשון, רץ רק אחרי R2.

חזרה לתוכן העניינים

מעקב: גלישה באוגר של 16 ביט

תרחיש 7: חיבור שעובר את 0xFFFF
Assembly
mov cx, 0xFFFA
jmp W
inc cx
W:
add cx, 0x0009
#מה התבצעCX אחריהערה
1mov cx, 0xFFFA0xFFFA-
2jmp W0xFFFAinc cx לא מתבצעת
3add cx, 0x00090x00030xFFFA ועוד 9 הם 0x10003, ו-16 ביט שומרים רק 0x0003

בסוף CX=0x0003.

טעויות נפוצות
  • בטבלת המעקב רושמים את כל השורות לפי הסדר שבו הן כתובות. רושמים רק שורות שבאמת רצו, בסדר שבו רצו. שורה מדולגת לא מקבלת שורה בטבלה.
  • התוצאה של חיבור או חיסור נשארת בדיוק כמו בחשבון. האוגר מחזיק רק 8, 16 או 32 ביט. מה שעובר את הגבול נחתך, ומעבר מתחת לאפס מתגלגל לערך גבוה.
  • חישוב על AL משפיע גם על AH, ולהפך. אלה שני חצאים נפרדים של AX. גלישה באחד מהם לא נוגעת בשני.
  • המעקב נגמר כשמגיעים לתווית האחרונה. תווית לא מבצעת כלום. הפקודה שאחריה רצה ונכנסת לחישוב.
בדקו את עצמכם
מה הערך של BL בסוף? הקוד: mov bl, 0xE8, jmp G, sub bl, 0x01, ואז התווית G: ואחריה add bl, 0x30.

sub bl, 0x01 מדולגת. 0xE8 ועוד 0x30 הם 0x118, ובאוגר של 8 ביט נשאר 0x18.

רשמו את סדר הביצוע במעקב הקפיצה אחורה של DX.

mov dx, 0x0030, jmp R2, add dx, 0x000C, jmp R1, sub dx, 0x0004, jmp R3, add dx, 0x0001.

במעקב של AH ו-AL, מה היה הערך הסופי של AX אילו השורה jmp A2 הייתה נמחקת?

אז גם add ah, 0x10 הייתה רצה: AH עובר מ-0x4C ל-0x5C, ואחרי sub ah, 0x01 הוא 0x5B. AL נשאר 0x15, ולכן AX=0x5B15.

חזרה לתוכן העניינים

סיכום

הנושא כולו בדף אחד: תוויות, EIP, jmp, פקודות החישוב, המחסנית, call ו-ret, מסגרת המחסנית, far ו-near.

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

כשפוגשיםמה עושים
את הקוד בפעם הראשונהמקיפים כל תווית, כדי לדעת מראש לאן כל קפיצה מובילה
פקודת חישובמעדכנים את הערך ברשימה וחותכים אותו לרוחב האוגר: 8, 16 או 32 ביט
jmpממשיכים מהתווית שהיא מציינת. מה שבין הקפיצה ליעד לא נכנס לחשבון
callמניחים בראש ערימת פתקים את השורה שמתחת ל-call, ואז עוברים לתווית
retמרימים את הפתק העליון בערימה, חוזרים לשורה שכתובה עליו וזורקים אותו: אחרון נכנס, ראשון יוצא
פונקציה עם מסגרתמשרטטים את המחסנית ורושמים ליד [ebp+8], [ebp+12] ו-[ebp-4] את הערכים שלהם
סוף הקודבודקים שהשורה האחרונה, גם כשהיא אחרי התווית האחרונה, נכנסה לחשבון
פקודהמה היא עושההשפעה על ESPהשפעה על EIP
mov dest, srcמעתיקה ערך. אין העתקה ישירה מזיכרון לזיכרון, והדגלים לא משתניםאיןמתקדם להוראה הבאה
add dest, srcdest מקבל dest + srcאין, אלא אם היעד הוא ESP עצמומתקדם להוראה הבאה
sub dest, srcdest מקבל dest - srcאין, אלא אם היעד הוא ESP עצמומתקדם להוראה הבאה
inc destמוסיפה 1, בלי לגעת ב-CFאיןמתקדם להוראה הבאה
dec destמחסירה 1, בלי לגעת ב-CFאיןמתקדם להוראה הבאה
cmp a, bמחשבת a - b בלי לשמור את התוצאה, ומעדכנת רק דגליםאיןמתקדם להוראה הבאה
jmp labelעוברת לתווית בלי לשמור כתובת חזרהאיןמקבל את כתובת התווית
push srcמורידה את ESP ב-4 וכותבת את src בראש המחסניתיורד ב-4מתקדם להוראה הבאה
pop destקוראת את ראש המחסנית ל-dest ומעלה את ESP ב-4עולה ב-4מתקדם להוראה הבאה
call labelדוחפת את כתובת ההוראה שאחריה ועוברת לתוויתיורד ב-4מקבל את כתובת התווית
retשולפת כתובת מראש המחסניתעולה ב-4מקבל את הכתובת שנשלפה
far callדוחפת CS ואחריו EIPיורד יותר מאשר ב-near, כי נדחפים שני ערכיםמקבל את היעד, ו-CS מתחלף
retfשולפת EIP ואחריו CSעולה יותר מאשר ב-ret, כי נשלפים שני ערכיםמקבל את הכתובת שנשלפה
jmp, call, ret, push, pop ו-mov לא משנות דגלים. פקודות החשבון add, sub, inc ו-dec מעדכנות דגלים, אבל inc ו-dec משאירות את CF כפי שהיה.
היסטמה יושב שם
[ebp+12]פרמטר 2, שנדחף ראשון
[ebp+8]פרמטר 1, שנדחף אחרון
[ebp+4]כתובת החזרה
[ebp]ה-EBP של הקורא
[ebp-4]משתנה מקומי 1
[ebp-8]משתנה מקומי 2
Assembly
; caller side
push arg2            ; the last argument goes in first
push arg1
call WORK
add esp, 8           ; the caller removes both arguments

; callee side
WORK:
push ebp
mov ebp, esp
sub esp, N           ; room for locals, only when needed
; the function body goes here
mov esp, ebp
pop ebp
ret

ולסיום, מה כדאי לזכור לפי סוג השאלה:

  • שאלות דילוג: תווית רק נותנת שם למקום בקוד ואינה פקודה, כך שריצה שמגיעה אליה ברצף עוברת הלאה. jmp label שולחת את הריצה לאותו מקום, וכל מה שבאמצע נשאר בלי ביצוע.
  • שאלות call ו-ret: הכתובת שנשמרת שייכת לשורה שמתחת ל-call, ו-ret מחזירה אותה ל-EIP. את התוצאה של פונקציה מחפשים, לפי המוסכמה, ב-EAX.
  • שאלות מחסנית: כל push מוריד את ESP ב-4 וכל pop מעלה אותו ב-4, כי המחסנית גדלה לעבר כתובות נמוכות. מה שנכנס אחרון יוצא ראשון.
  • שאלות מסגרת: הפתיחה היא push ebp ו-mov ebp, esp, והסגירה mov esp, ebp, pop ebp ו-ret. ב-EBP עצמו יושב ה-EBP הישן, מעליו 4 לכתובת החזרה ו-8 ו-12 לשני הפרמטרים, ומתחתיו [ebp-4] למשתנה המקומי הראשון.
  • שאלות cdecl: הארגומנט הימני נכנס למחסנית ראשון, ואחרי החזרה הקורא עצמו מפנה את המקום, למשל add esp, 8 לשני ארגומנטים.
  • שאלות near ו-far: near נוגעת רק ב-EIP ושומרת רק אותו. far מחליפה גם את CS, שומרת CS ואז EIP, וחוזרת ב-retf; בתוכניות 32 ביט במודל השטוח נתקלים כמעט רק ב-near.
  • שאלות על EIP: חשבו עליו כעל סימנייה שמונחת תמיד על ההוראה שתורה הבא. הוראה רגילה מקדמת את הסימנייה במספר הבתים שהיא תופסת, רק jmp, call, ret ושאר הוראות הזרימה מניחות אותה במקום אחר, ואין mov שהיעד שלה הוא EIP.
  • שאלות ARM: את כתובת החזרה מחזיק LR, הוא R14, ואת התפקיד של EIP ממלא PC, הוא R15.