מחשבון קרב - אסמבלי
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, שני סוגים של קפיצה ושל קריאה: מה כל אחד מהם משנה, ומה הוא שומר במחסנית.
| מושג | במשפט אחד |
|---|---|
| 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), ומשתמשים בשם. אם הקוד זז, השם זז איתו, כמו איש קשר בטלפון שנשאר אותו איש קשר גם כשהמספר שלו מתחלף.
מי מחליף את השם במספר? האסמבלר, הכלי שהופך את הטקסט לקוד מכונה. בהמשך החלק תראו בפירוק של קובץ אמיתי שבתוך הפקודות נשארת רק הכתובת.
חזרה לתוכן הענייניםכללי הכתיבה של תווית
הנה כמה צורות כתיבה חוקיות. בכולן התווית מוגדרת על ידי שם שנצמדים אליו נקודתיים:
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. הם סימן של הגדרה בלבד, ומי שמוסיף אותם בשימוש מקבל שגיאה:
section .text
jmp RETRY: ; colon in the jump
RETRY:
add edx, 2jmpcolon.asm:2: error: invalid combination of opcode and operandsולגבי השם עצמו: הבחירה הבטוחה היא אותיות באנגלית, ספרות וקו תחתון, כשהתו הראשון אינו ספרה (RETRY, STEP_2, _start). כלל עבודה נוסף הוא לא לקרוא לתווית בשם של אוגר או של פקודה.
מעניין לראות מה האסמבלר עצמו אוכף. בדקנו שני שמות כאלה, אחד של אוגר ואחד של פקודה, עם כל האזהרות של NASM פעילות:
section .text
ecx: ; a register name as a label
add edx, 2
push: ; an instruction name as a label
add edx, 3names.asm:2: error: label, instruction or prefix expected at start of line, found `ecx'רק השורה של ecx: נפסלה. את push: NASM קיבל בלי שום אזהרה, ובכל זאת נמנעים משם כזה: קוד שבו jmp push היא קפיצה ולא דחיפה הוא מלכודת לכל מי שיקרא אותו.
תווית לא מבצעת שום פעולה
נתחיל בניסוי. תרגמנו שתי פקודות פעם אחת כמו שהן, ופעם שנייה עם שורת MIDDLE: ביניהן (שני הקבצים מתחילים ב-bits 32, כדי שייבנו כקוד של 32 ביט), והשווינו את מה שיצא:
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.binidentical
00000000: ba09 0000 0083 ea02 ........שמונה בתים בסך הכול, וכולם של הפקודות: ba 09 00 00 00 הוא mov edx, 9, ו-83 ea 02 הוא sub edx, 2. התווית לא הוסיפה אף בית.
מהניסוי הזה נגזר כלל שהרבה שאלות בנויות עליו. מבחינת המעבד השורה MIDDLE: פשוט לא קיימת: אין בה מה לבצע, ולכן שום אוגר, תא זיכרון או דגל לא משתנים בגללה. ריצה שמגיעה אליה מלמעלה, בלי שמישהו קפץ לשם, ממשיכה ישר לפקודה שאחריה.
במעקב זה נראה כך:
mov edx, 9
MIDDLE: ; only a name for the next address
sub edx, 2| שורה | EDX אחריה | מה קרה |
|---|---|---|
mov edx, 9 | 9 | ערך התחלתי. |
MIDDLE: | 9 | הריצה חולפת על פני התווית, ושום דבר לא משתנה. |
sub edx, 2 | 7 | הפקודה הבאה ברצף. |
תווית כיעד של קפיצה
יש שתי דרכים שבהן הריצה מגיעה לשורה שמסומנת בתווית. בשתיהן הפקודה שמתחת לתווית רצה, וההבדל הוא רק במה שקרה לפני כן:
| איך הריצה מגיעה לתווית | מה קורה שם |
|---|---|
| מלמעלה, כי הפקודה הקודמת הסתיימה | התווית שקופה, וממשיכים ישר לפקודה שמתחתיה. |
| בקפיצה אליה, ב-jmp או ב-call | EIP מקבל את הכתובת שהתווית מייצגת, והפקודה שמתחתיה היא הבאה שתתבצע. |
במקרה השני, כל מה שכתוב בין הקפיצה לבין התווית לא מבוקר בסיבוב הזה. זה לא אומר שהשורות האלה מתות: אם קפיצה אחרת, ממקום אחר בקוד, תוביל אליהן, הן ירוצו כמו כל קוד.
ל-jmp עצמה מוקדש חלק משלה בהמשך הפרק.
חזרה לתוכן העניינים_start ותוכנית שלמה
התוכנית הבאה שלמה, כזו שאפשר לבנות ולהריץ. כמה מהשורות שלה שייכות למעטפת ולא לחישוב, וההערות מסבירות אותן:
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 פותחת את קטע הקוד, שבו כתובות הפקודות.
בנינו והרצנו את התוכנית בלינוקס, ואז ביקשנו מהמעטפת את קוד היציאה:
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:
objdump -d -M intel skelskel: 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 |
פקודה רגילה: EIP מתקדם מעצמו
הדרך הכי טובה להבין איך EIP זז היא להסתכל על קוד אמיתי בזיכרון. בנינו בלינוקס תוכנית של חמש פקודות ופירקנו את הקובץ:
global _start
section .text
_start:
mov ecx, 9
sub ecx, 2
dec ecx
cmp ecx, 6
push ecxobjdump -d -M intel stepssteps: 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, 9 | 0x8049000 | 5 בתים | 0x8049005 |
sub ecx, 2 | 0x8049005 | 3 בתים | 0x8049008 |
dec ecx | 0x8049008 | בית אחד | 0x8049009 |
cmp ecx, 6 | 0x8049009 | 3 בתים | 0x804900C |
push ecx | 0x804900C | בית אחד | 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 הוא אוגר, למה לא לכתוב אליו ישירות? כך נראה הניסיון:
section .text
mov eip, 5 ; try to write the instruction pointer
push eip ; try to save it on the stackeip.asm:2: error: symbol `eip' not defined
eip.asm:3: error: symbol `eip' not definedNASM לא מוצא בשם 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: קפיצה בלתי מותנית
התחביר ומה הפקודה עושה
jmp labelאפשר לקרוא את jmp כהשמה אחת: EIP מקבל את הכתובת של label. זה כל מה שהיא עושה, ולכן מה שירוץ אחריה הוא הפקודה שבתווית, לא השורה שכתובה מתחתיה.
אין לה תנאי. היא לא מסתכלת על דגלים או על אוגרים, ומתבצעת בכל פעם שהריצה מגיעה אליה, ומכאן השם: קפיצה בלתי מותנית (jump).
| מה בודקים | מה jmp עושה לו |
|---|---|
| האופרנד | תווית. בשאלות המבחן זה תמיד שם של תווית. |
| EIP | מקבל את הכתובת של התווית. |
| ESP והמחסנית | ללא שינוי. jmp לא משאירה כתובת חזרה, וזה בדיוק מה שמבדיל אותה מ-call. |
| אוגרי הנתונים | ללא שינוי. |
| הדגלים | ללא שינוי. |
| חזרה | אין. הריצה ממשיכה מהיעד, ואין דרך אוטומטית לחזור. |
קפיצה קדימה: דילוג על פקודות
זה המקרה הנפוץ ביותר בשאלות: היעד נמצא מתחת ל-jmp, ובאמצע יושבת פקודה שנראית חשובה.
mov dl, 0xC0
jmp DONE_ADD
add dl, 0x50 ; skipped
DONE_ADD:
add dl, 0x03| פקודה שהתבצעה | DL אחריה | הערה |
|---|---|---|
mov dl, 0xC0 | 0xC0 | ערך התחלתי. |
jmp DONE_ADD | 0xC0 | קפיצה. add dl, 0x50 לא מתבצעת. |
add dl, 0x03 | 0xC3 | ממשיכים מתחת ל-DONE_ADD. |
אילו החיבור המדולג היה רץ, DL היה גולש (0xC0 + 0x50 = 0x110, ונשאר 0x10) והתשובה הייתה אחרת לגמרי. אבל הוא לא רץ, ולכן אין לו שום חלק בתוצאה.
כדי לא ליפול במלכודות כאלה, עבדו בשיטה קבועה:
- עוברים על הקטע מלמעלה, שורה אחר שורה.
- בכל jmp מחפשים את התווית שלה וממשיכים משם. השורות שבדרך לא נכנסות לטבלה.
- בטבלת המעקב רושמים רק פקודות שהתבצעו, עם הערך אחרי כל אחת.
- לא עוצרים לפני השורה האחרונה של הקטע, גם כשהיא מתחת לתווית האחרונה.
כמה דילוגים ברצף
בקטע הבא יש שני דילוגים. אין להם השפעה זה על זה: מטפלים בראשון, ממשיכים, ומטפלים בשני כשמגיעים אליו.
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, 0x11 | 0x11 |
jmp P1 | 0x11 |
add bl, 0x22 | 0x33 |
jmp P2 | 0x33 |
sub bl, 0x10 | 0x23 |
התוצאה היא BL = 0x23. מי שמתעלם משתי הקפיצות ומריץ את כל השורות מקבל 0x27, ערך שנראה סביר ולכן מסוכן.
חזרה לתוכן הענייניםקפיצה אחורה: חזרה לקטע שדולג
בקטע הבא הבלוק FIRST מדולג בהתחלה, ובכל זאת רץ בסוף:
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, 5 | 5 | ערך התחלתי. |
jmp SECOND | 5 | מדלגים על FIRST ועל add cx, 100 שמתחתיה. |
add cx, 7 | 12 | הקטע של SECOND. |
jmp FIRST | 12 | קפיצה למעלה, בדיוק לקטע שדילגנו עליו. |
add cx, 100 | 112 | הקטע שדולג רץ עכשיו. |
jmp END | 112 | יציאה לסוף הקטע. |
מה שקרה כאן: 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, DH | 0x00 עד 0xFF | 0xFF + 1 = 0x00, וגם 0x00 - 1 = 0xFF |
| 16 ביט | AX, BX, CX, DX | 0x0000 עד 0xFFFF | 0xFFFF + 1 = 0x0000 |
| 32 ביט | EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI | 0x00000000 עד 0xFFFFFFFF | 0xFFFFFFFF + 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 ביטים אפשר לקרוא בכמה שמות, וכל שם רואה חלק אחר:
| שם | ביטים | מה הוא רואה |
|---|---|---|
| EBX | 0 עד 31 | 0x89ABCDEF |
| (בלי שם) | 16 עד 31 | 0x89AB. לחצי העליון אין שם נפרד |
| BX | 0 עד 15 | 0xCDEF |
| BH | 8 עד 15 | 0xCD |
| BL | 0 עד 7 | 0xEF |
החצי התחתון, BX, מתחלק לשני בתים: BH (מלשון high) ו-BL (מלשון low). אותו מבנה בדיוק יש ל-EAX, ל-ECX ול-EDX: AX עם AH ו-AL, CX עם CH ו-CL, DX עם DH ו-DL.
כשכותבים לאחד השמות, רק הביטים שלו מתחלפים:
| כותבים ל- | מה מתחלף | מה נשאר בדיוק כמו שהיה |
|---|---|---|
| BL | 8 הביטים התחתונים | BH, וגם 16 הביטים העליונים |
| BX | 16 הביטים התחתונים | 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: העתקת ערך
mov dest, srcאחרי mov ecx, edx יש ב-ECX עותק של EDX, ו-EDX עצמו לא השתנה. כך זה תמיד: הערך עובר מהמקור (src, מימין) אל היעד (dest, משמאל), ומה שהיה ביעד נדרס. מי שמתבלבל בכיוון יכול לחשוב על dest = src בשפה עילית.
| פקודה | לפני | אחרי |
|---|---|---|
mov edx, 42 | EDX=? | EDX=42 |
mov ecx, edx | EDX=42, ECX=0 | EDX=42, ECX=42 |
mov bh, bl | BX=0x0071 | BX=0x7171 |
mov ax, 0xBEEF | EAX=0x12340000 | EAX=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 אומר על שלושה מהם:
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 destinationmov.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: חיבור
add dest, src| פקודה | לפני | אחרי |
|---|---|---|
add edx, 8 | EDX=42 | EDX=50 |
add ecx, ecx | ECX=9 | ECX=18 |
add ax, 1 | AX=0xFFFF | AX=0x0000 (גלישה) |
add bl, 0x05 | BX=0x44FD | BX=0x4402 (BL גלש, BH נשאר 0x44) |
add esp, 12 | ESP=0x0FF4 | ESP=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: חיסור
sub dest, src| פקודה | לפני | אחרי |
|---|---|---|
sub edx, 8 | EDX=50 | EDX=42 |
sub cx, 20 | CX=25 | CX=5 |
sub bl, 1 | BL=0x00 | BL=0xFF (גלישה) |
sub esp, 8 | ESP=0x0FF8 | ESP=0x0FF0 |
הכיוון של sub הוא היעד פחות המקור, והתוצאה נכתבת ביעד: dest = dest - src. את sub ecx, [ebp+8] קוראים 'ECX פחות הזיכרון', אף פעם לא להפך. אופרנדים ורוחבים: בדיוק כמו ב-add.
הדוגמה עם ESP אינה מקרית. כדי לפנות במחסנית מקום למשתנה מקומי מחסרים מ-ESP, למשל sub esp, 4 למשתנה אחד, כי המחסנית גדלה לכיוון הכתובות הנמוכות.
inc ו-dec: צעד של 1
inc dest
dec destinc ו-dec הן הגרסה המקוצרת של חיבור 1 וחיסור 1: אופרנד אחד, צעד של אחד. הקיצור הוא גם פיזי, כי את dec ecx ראיתם בפירוק תופסת בית אחד בלבד. ההבדל השני הוא בדגלים: ZF מתעדכן כרגיל, אבל CF לא זז.
| פקודה | לפני | אחרי |
|---|---|---|
inc edx | EDX=41 | EDX=42 |
dec ax | AX=0x8000 | AX=0x7FFF |
dec bl | BL=0x00 | BL=0xFF |
inc ecx | ECX=0xFFFFFFFF | ECX=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: דחיפה
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 ecx | 0x0FFC | בכתובת 0x0FFC: 9 |
push 0x0C | 0x0FF8 | בכתובת 0x0FF8: 12, מעל ה-9 |
pop: שליפה
pop destpop היא push בסדר הפוך: קודם קוראים, ורק אז המחוג זז. הערך שב-[esp] מועתק ליעד, ואחר כך ESP עולה ב-4.
| אופרנד | מותר? | דוגמה |
|---|---|---|
| אוגר של 32 ביט | כן | pop edx |
| זיכרון עם רוחב | כן | pop dword [total] |
| מספר | לא, אין לאן לכתוב | pop 5 |
| אוגר של 8 ביט | לא | pop bl |
| EIP | לא (את זה עושה ret) | pop eip |
גם כאן NASM דוחה את הצירופים האסורים, יחד עם הדחיפה של אוגר בן 8 ביט:
section .text
push bl ; an 8-bit register
pop 5 ; pop into a number
pop eip ; pop into the instruction pointerstack.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.
דוגמה: הסדר מתהפך
mov ecx, 30
mov edx, 40
push ecx
push edx
pop eax
pop ebxESP מתחיל ב-0x1000:
| פקודה | ESP | תוכן המחסנית (הראש בסוף) | אוגרים |
|---|---|---|---|
mov ecx, 30 | 0x1000 | ריקה | ECX=30 |
mov edx, 40 | 0x1000 | ריקה | EDX=40 |
push ecx | 0x0FFC | 30 | ללא שינוי |
push edx | 0x0FF8 | 30, 40 | ללא שינוי |
pop eax | 0x0FFC | 30 | EAX=40 |
pop ebx | 0x1000 | ריקה | EBX=30 |
כך נראית המחסנית אחרי שתי הדחיפות, כשהכתובות הגבוהות למעלה:
| כתובת | תוכן | הערה |
|---|---|---|
| 0x1000 | (לא חלק מהמחסנית) | כאן ESP התחיל |
| 0x0FFC | 30 | נדחף ראשון |
| 0x0FF8 | 40 | נדחף אחרון: ראש המחסנית, 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 את הבית שבכתובת הנמוכה ביותר של התא, ויוצאת איתו כקוד יציאה:
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 0x80nasm -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:
| כתובת | 0x0FFC | 0x0FFD | 0x0FFE | 0x0FFF |
|---|---|---|---|---|
| בית | 34 | 12 | FE | CA |
בשאלות המעקב לא תצטרכו לפרק ערכים לבתים, כי 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: לקפוץ ולזכור לאן לחזור
call labelפונקציה באסמבלי היא לא יותר מתווית ומתחתיה קוד שמסתיים ב-ret. מה שהופך אותה לפונקציה הוא הדרך שבה מגיעים אליה: מכמה מקומות בתוכנית, וכל אחד מהם מקבל את הריצה בחזרה כשהיא נגמרת.
call דומה ל-jmp בדבר אחד ושונה בדבר אחד. גם היא שולחת את הריצה לתווית, אבל לפני כן היא משאירה פתק עם הכתובת שאליה צריך לחזור:
jmp label | call label | |
|---|---|---|
| מכניסה ל-EIP את כתובת התווית | כן | כן |
| משאירה כתובת חזרה במחסנית | לא | כן, את כתובת ההוראה שאחריה |
| השינוי ב-ESP | אין | יורד ב-4 |
| אפשר לחזור ממנה עם ret | לא | כן |
הפתק נכתב במחסנית, ואלה שני הצעדים לפי הסדר:
- דוחפת למחסנית את הכתובת של ההוראה שבאה מיד אחריה, כתובת החזרה: ESP יורד ב-4, והכתובת נכתבת ב-
[esp]. - מכניסה ל-EIP את הכתובת של התווית, כך שהריצה עוברת אליה.
אם תרצו נוסחה: call היא push של כתובת ההמשך ומיד אחריה jmp. היא מקבלת תווית, ולא נוגעת לא בדגלים ולא באוגרי הנתונים.
בדקנו בהרצה מה בדיוק יושב בראש המחסנית כשהפונקציה מתחילה. PEEK משווה את הערך העליון, כל 32 הביטים שלו, לכתובת של AFTER_CALL, ויוצאת עם 0 אם הם שווים ועם 1 אם לא:
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:
retnasm -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: לחזור לכתובת שבראש המחסנית
retבצד השני עומדת ret, בלי אופרנדים. אם call השאירה פתק, ret קוראת אותו: היא מעבירה את הערך שבראש המחסנית ל-EIP, ומעלה את ESP ב-4.
שימו לב מה חסר כאן: ret לא יודעת מי קרא לה. היא לא מחפשת את ה-call ולא זוכרת אותה, אלא פשוט סומכת על הערך העליון במחסנית.
מכאן הדרישה מכל פונקציה: כשהיא מגיעה ל-ret, ESP צריך להצביע על כתובת החזרה עצמה, לא על ערך שנדחף אחריה. ממש כמו call, גם ret לא משנה דגלים.
ואיך פונקציה מוסרת תוצאה? לפי מוסכמה, ב-EAX: הקוד שאחרי ה-call קורא משם את התשובה.
חזרה לתוכן הענייניםמעקב: קריאה אחת
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:
| פקודה שהתבצעה | EDX | ESP | המחסנית | הערה |
|---|---|---|---|---|
mov edx, 18 | 18 | 0x1000 | ריקה | ערך התחלתי. |
call ADD9 | 18 | 0x0FFC | RA | נדחפת הכתובת של sub edx, 2, ו-EIP עובר ל-ADD9. |
add edx, 9 | 27 | 0x0FFC | RA | בתוך הפונקציה. |
ret | 27 | 0x1000 | ריקה | EIP=RA. |
sub edx, 2 | 25 | 0x1000 | ריקה | ממשיכים מיד אחרי ה-call. |
jmp DONE | 25 | 0x1000 | ריקה | קפיצה מעל הפונקציה. בלעדיה הריצה הייתה נכנסת ל-ADD9 שוב (ראו נפילה לתוך פונקציה). |
אותה פונקציה, שתי קריאות
כל call כותבת פתק חדש, עם הכתובת שמתחתיה. לכן אותה פונקציה יכולה לחזור בכל פעם למקום אחר: ret קוראת את הפתק של הקריאה הנוכחית.
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, 3 | 3 | ערך התחלתי. |
call F | 3 | כתובת החזרה: ה-call השני. |
add ebx, ebx | 6 | F בפעם הראשונה: הכפלה. |
add ebx, 1 | 7 | ועוד 1. |
ret | 7 | חזרה ל-call השני. |
call F | 7 | כתובת החזרה הפעם: jmp END. |
add ebx, ebx | 14 | F בפעם השנייה: הכפלה. |
add ebx, 1 | 15 | ועוד 1. |
ret | 15 | חזרה ל-jmp END. |
jmp END | 15 | סוף. |
התוצאה היא 15. מי שמריץ את F פעם אחת בלבד עוצר ב-7.
חזרה לתוכן הענייניםפונקציה שקוראת לפונקציה
כאן OUTER קוראת בעצמה ל-INNER:
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).
| פקודה שהתבצעה | ECX | ESP | המחסנית (הראש בסוף) |
|---|---|---|---|
mov ecx, 2 | 2 | 0x1000 | ריקה |
call OUTER | 2 | 0x0FFC | RA1 |
add ecx, 3 | 5 | 0x0FFC | RA1 |
call INNER | 5 | 0x0FF8 | RA1, RA2 |
add ecx, 50 | 55 | 0x0FF8 | RA1, RA2 |
ret (מתוך INNER) | 55 | 0x0FFC | RA1. הריצה עוברת ל-RA2. |
add ecx, 7 | 62 | 0x0FFC | RA1 |
ret (מתוך OUTER) | 62 | 0x1000 | ריקה. הריצה עוברת ל-RA1. |
jmp END | 62 | 0x1000 | ריקה |
שימו לב לעמודת המחסנית: RA2 נכנסה אחרי RA1, ולכן יצאה לפניה. כך זה בכל קינון: ה-ret הראשונה שייכת תמיד לפונקציה הפנימית ביותר שעדיין רצה, והחיצונית חוזרת רק אחריה (LIFO).
חזרה לתוכן הענייניםנפילה לתוך פונקציה: למה שמים jmp לפני הפונקציות
לתווית שבראש פונקציה אין שום כוח לעצור ריצה שמגיעה אליה מלמעלה. ריצה כזו פשוט תבצע את הפונקציה, בלי call ובלי פתק במחסנית. זה התפקיד של jmp DONE או jmp END שמופיעות כמעט בכל שאלה לפני הפונקציות: הן מעבירות את הריצה מעליהן, כך שהפונקציות רצות רק כשקוראים להן.
בתוכנית הבאה ה-jmp הזו חסרה:
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, 2 | 2 | ערך התחלתי. |
call G | 2 | קריאה רגילה. כתובת החזרה: add edx, 30. |
add edx, 5 | 7 | G בפעם הראשונה. |
ret | 7 | חזרה ל-add edx, 30. |
add edx, 30 | 37 | ממשיכים בזרימה רגילה. |
add edx, 5 | 42 | נפלנו לתוך G: הפונקציה רצה שוב, בלי שום call. |
ret | 42 | בראש המחסנית אין כתובת חזרה אמיתית. |
בשאלת מבחן ה-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 ביט קובעת מי אחראי על מה. החלק של הקורא בנוי משלושה צעדים:
- דוחפים את הפרמטרים מימין לשמאל: הפרמטר האחרון ברשימה נכנס למחסנית ראשון, והפרמטר הראשון נכנס אחרון, ממש לפני ה-call.
- מבצעים
call, והיא מוסיפה למחסנית את כתובת החזרה. - כשהפונקציה חזרה, מרימים את ESP מעל הפרמטרים עם
add esp, N, כאשר N הוא 4 בתים כפול מספר הפרמטרים. לשני פרמטרים כותביםadd esp, 8, ולשלושהadd esp, 12.
למשל, קריאה בסגנון area(5, 9) הופכת ל-push 9, אחריה push 5, ואז call area. אחרי החזרה בא add esp, 8.
push 9. אחרי שתי הדחיפות וה-call הוא 0x08F4, ו-ret מעלה אותו רק ל-0x08F8, כי היא לוקחת את כתובת החזרה ותו לא. רק add esp, 8 מחזירה אותו ל-0x0900, ובלעדיה כל קריאה הייתה משאירה מאחור שמונה בתים.פתיחת המסגרת (prologue)
פונקציה שבונה מסגרת פותחת תמיד באותן שורות:
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 ebp | ESP יורד ב-4, ובראש המחסנית נשמר ה-EBP של הקורא | כדי שביציאה אפשר יהיה להחזיר לקורא את העוגן שלו |
mov ebp, esp | EBP מצביע עכשיו על ראש המחסנית, כלומר על הערך שנשמר הרגע | מכאן והלאה [ebp] הוא ה-EBP של הקורא, וכל השאר נמדד ממנו |
sub esp, N | ESP יורד עוד 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 בתים.
[ebp+4] כאילו היה פרמטר מקבל בעצם כתובת בקוד.איזה ערך נוחת באיזה היסט
נניח שהקורא כותב:
push 0x30
push 0x0C
call DIFFהערך 0x0C נכנס אחרון, ולכן מבין השניים הוא הקרוב ביותר ל-EBP ונמצא ב-[ebp+8]. הערך 0x30 נכנס קודם, ולכן מקומו ב-[ebp+12].
| מתי נדחף | ערך | היסט בתוך DIFF |
|---|---|---|
| בדחיפה הראשונה | 0x30 | [ebp+12] |
| בדחיפה השנייה, האחרונה לפני call | 0x0C | [ebp+8] |
הכלל נקבע רק לפי סדר הדחיפה. גודל הערכים לא משחק תפקיד: גם כשהערך שנדחף אחרון קטן מהראשון, הוא עדיין ב-[ebp+8].
הסדר הכי קריטי כשיש חיסור. בתוך DIFF, השורה mov eax, [ebp+12] ואחריה sub eax, [ebp+8] נותנות 0x30 פחות 0x0C, כלומר 0x24. מי שמחליף בין ההיסטים מחשב חיסור הפוך ומקבל תוצאה אחרת לגמרי.
סגירת המסגרת (epilogue)
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, ebp | ESP חוזר אל הכתובת שבה שמור ה-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.
sub esp צריכים pop או הוספה מתאימים לפני ret. כך, ברגע הקפיצה חזרה, ESP יושב על כתובת החזרה ולא על שום ערך אחר.מעקב מלא: פונקציה שמחסרת פרמטר מפרמטר
תרחיש 1: חיסור של שני פרמטרים בתוך מסגרת
התוכנית קוראת ל-MINUS כמו לקריאה minus(25, 6): הפרמטר הראשון 25 והשני 6. זו תוכנית שלמה ל-Linux ב-32 ביט, ובסוף היא מחזירה את EAX כקוד היציאה שלה.
MINUS משתמשת ב-EBX כאוגר עזר, ולכן היא שומרת אותו במחסנית מיד אחרי הפתיחה ומשחזרת אותו לפני הסגירה, כדי לא לפגוע בערך של הקורא. ה-push הנוסף מזיז את ESP, אבל ההיסטים מ-EBP נשארים כמו שהיו.
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 0x80nasm -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. הכתובות בטבלה הן מעקב ידני לפי הכללים, לא פלט של התוכנית.
| # | פקודה | EAX | ESP | EBP | מה קרה |
|---|---|---|---|---|---|
| 1 | push 6 | - | 0x07FC | 0x0A00 | בכתובת 0x07FC נכתב 6 |
| 2 | push 25 | - | 0x07F8 | 0x0A00 | בכתובת 0x07F8 נכתב 25 |
| 3 | call MINUS | - | 0x07F4 | 0x0A00 | בכתובת 0x07F4 נכתבה RA, ו-EIP עובר ל-MINUS |
| 4 | push ebp | - | 0x07F0 | 0x0A00 | בכתובת 0x07F0 נשמר 0x0A00, ה-EBP של הקורא |
| 5 | mov ebp, esp | - | 0x07F0 | 0x07F0 | העוגן של הקריאה הזו קובע |
| 6 | push ebx | - | 0x07EC | 0x07F0 | הערך הקודם של EBX נשמר ב-0x07EC. ESP זז, EBP לא |
| 7 | mov ebx, [ebp+12] | - | 0x07EC | 0x07F0 | EBX מקבל 6, שנקרא מ-0x07FC |
| 8 | mov eax, [ebp+8] | 25 | 0x07EC | 0x07F0 | הקריאה היא מ-0x07F8 |
| 9 | sub eax, ebx | 19 | 0x07EC | 0x07F0 | 25 פחות 6 |
| 10 | pop ebx | 19 | 0x07F0 | 0x07F0 | EBX חזר לערך שהיה לו לפני MINUS |
| 11 | pop ebp | 19 | 0x07F4 | 0x0A00 | ה-EBP של הקורא חזר |
| 12 | ret | 19 | 0x07F8 | 0x0A00 | EIP מקבל את RA |
| 13 | add esp, 8 | 19 | 0x0800 | 0x0A00 | שני הפרמטרים הוסרו, ESP כמו בהתחלה |
| 14 | jmp FIN | 19 | 0x0800 | 0x0A00 | מעבר לסוף התוכנית |
תמונת המחסנית אחרי שורה 6, כשהכתובות הגבוהות למעלה:
| כתובת | תוכן | היסט ותפקיד |
|---|---|---|
| 0x07FC | 6 | [ebp+12], פרמטר 2 |
| 0x07F8 | 25 | [ebp+8], פרמטר 1 |
| 0x07F4 | RA | [ebp+4], כתובת החזרה |
| 0x07F0 | 0x0A00 | [ebp], ה-EBP השמור. לכאן מצביע EBP |
| 0x07EC | EBX הקודם | [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 כשידוע כמה בתים הוקצו.
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 0x80nasm -f elf32 mix.asm -o mix.o
ld -m elf_i386 mix.o -o mix
./mix; echo $?14אותן הנחות כמו קודם: לפני הקוד ESP=0x0800 ו-EBP=0x0A00. גם כאן הכתובות הן מעקב ידני.
| # | פקודה | EAX | ESP | EBP | מה קרה |
|---|---|---|---|---|---|
| 1 | push 3 | - | 0x07FC | 0x0A00 | - |
| 2 | push 11 | - | 0x07F8 | 0x0A00 | - |
| 3 | call MIX | - | 0x07F4 | 0x0A00 | RA נדחפת |
| 4 | push ebp | - | 0x07F0 | 0x0A00 | - |
| 5 | mov ebp, esp | - | 0x07F0 | 0x07F0 | - |
| 6 | sub esp, 12 | - | 0x07E4 | 0x07F0 | נפתחו [ebp-4] (0x07EC), [ebp-8] (0x07E8) ו-[ebp-12] (0x07E4) |
| 7 | mov ecx, [ebp+8] | - | 0x07E4 | 0x07F0 | ECX מקבל 11, פרמטר 1 |
| 8 | add ecx, ecx | - | 0x07E4 | 0x07F0 | ECX = 11 ועוד 11 = 22 |
| 9 | mov [ebp-4], ecx | - | 0x07E4 | 0x07F0 | המשתנה המקומי הראשון מקבל 22 |
| 10 | mov edx, [ebp+12] | - | 0x07E4 | 0x07F0 | EDX מקבל 3, פרמטר 2 |
| 11 | mov [ebp-8], edx | - | 0x07E4 | 0x07F0 | המשתנה המקומי השני מקבל 3 |
| 12 | mov ecx, 0 | - | 0x07E4 | 0x07F0 | ECX מתאפס, כדי שהערך הבא יגיע רק מהזיכרון |
| 13 | mov eax, [ebp-8] | 3 | 0x07E4 | 0x07F0 | EAX נטען מהמשתנה המקומי השני |
| 14 | mov ecx, [ebp-4] | 3 | 0x07E4 | 0x07F0 | ECX נטען שוב, 22, מהמשתנה המקומי הראשון |
| 15 | add eax, ecx | 25 | 0x07E4 | 0x07F0 | 3 ועוד 22 |
| 16 | sub eax, [ebp+8] | 14 | 0x07E4 | 0x07F0 | 25 פחות 11 |
| 17 | mov [ebp-12], eax | 14 | 0x07E4 | 0x07F0 | המשתנה המקומי השלישי שומר את התוצאה |
| 18 | add esp, 12 | 14 | 0x07F0 | 0x07F0 | שלוש המשבצות המקומיות שוחררו |
| 19 | pop ebp | 14 | 0x07F4 | 0x0A00 | - |
| 20 | ret | 14 | 0x07F8 | 0x0A00 | EIP מקבל את RA |
| 21 | add esp, 8 | 14 | 0x0800 | 0x0A00 | הקורא הסיר את הפרמטרים, והמחסנית מאוזנת |
תמונת המחסנית אחרי שורה 17:
| כתובת | תוכן | היסט ותפקיד |
|---|---|---|
| 0x07FC | 3 | [ebp+12], פרמטר 2 |
| 0x07F8 | 11 | [ebp+8], פרמטר 1 |
| 0x07F4 | RA | [ebp+4], כתובת החזרה |
| 0x07F0 | 0x0A00 | [ebp], ה-EBP השמור. לכאן מצביע EBP |
| 0x07EC | 22 | [ebp-4], משתנה מקומי 1 |
| 0x07E8 | 3 | [ebp-8], משתנה מקומי 2 |
| 0x07E4 | 14 | [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 | מה משתנה | מה עובר דרך המחסנית |
|---|---|---|
jmp | EIP מקבל את כתובת היעד | כלום |
call | EIP מקבל את כתובת היעד | נכנס ערך אחד, כתובת החזרה, ו-ESP יורד ב-4 |
ret | EIP מקבל את הערך שבראש המחסנית | יוצא ערך אחד, ו-ESP עולה ב-4 |
jmp וכל call שם הם near.far: מעבר ל-code segment אחר
עכשיו main קוראת לשגרה שגרה בבניין אחר. החלפת דירה כבר לא מספיקה, וההוראה טוענת ל-CS מספר בניין חדש יחד עם ההיסט שהיא כותבת ל-EIP.
| פקודת far | מה משתנה | מה עובר דרך המחסנית |
|---|---|---|
| far jmp | CS ו-EIP יחד | כלום |
| far call | CS ו-EIP יחד, אחרי השמירה | נכנסים שני ערכים: קודם CS, ומעליו EIP. ב-32 ביט ESP יורד ב-8 ולא ב-4 |
retf (return far) | EIP ואחריו CS, מתוך המחסנית | יוצאים שני הערכים, EIP ראשון ו-CS שני |
למה לשמור גם את CS? בסוף הפונקציה המעבד צריך לחזור לבניין הנכון, לא רק לדירה הנכונה. בלי שחזור של CS הוא היה לוקח הוראות מההיסט הנכון אבל בתוך הקטע של הפונקציה, כלומר קוד אחר לגמרי.
| מאפיין | near | far |
|---|---|---|
| איפה היעד | באותו code segment | ב-code segment אחר |
מה jmp משנה | EIP בלבד | CS וגם EIP |
מה call דוחפת | EIP בלבד | CS, ואחריו EIP |
ESP אחרי call (נובע ממה שנדחף) | יורד בערך אחד | יורד בשני ערכים, כלומר יותר |
| פקודת החזרה | ret | retf |
כך נראה ראש המחסנית מיד אחרי far call:
| כתובת | תוכן | הסבר |
|---|---|---|
| ESP+4 | CS | נדחף ראשון, ולכן יושב גבוה יותר |
| ESP | EIP, כלומר כתובת החזרה | נדחף אחרון ונמצא בראש המחסנית |
מה מסוגל לשנות את CS
את CS אי אפשר לטעון עם mov. הוא משתנה רק דרך פקודות זרימה שמביאות איתן קטע חדש:
- far jmp.
- far call.
retf, שמחזירה ל-CS את הערך ששמר ה-far call.- פסיקה:
int nדוחפת למחסנית שלושה ערכים, הדגלים, CS ו-EIP, ושגרת הפסיקה חוזרת עםiret.
ב-far call היעד כולל את שני החלקים, ואפשר לראות זאת בקידוד של הפקודה. הקטע הבא (16 ביט) עובר הרכבה ב-nasm ופירוק ב-ndisasm:
bits 16
call 0x4800:0x0010 ; far call: target segment 0x4800, offset 0x0010
retf ; far return: pops IP, then CSnasm -f bin far.asm -o far.bin
ndisasm -b 16 far.bin00000000 9A10000048 call word 0x4800:word 0x10
00000005 CB retfבבתים של ה-call מופיעים גם ההיסט 0x0010 וגם הקטע 0x4800. את הקוד הזה לא מריצים כאן, כי הוא דורש מעבד ב-real mode.
דוגמה מספרית ב-real mode, שבו כתובת פיזית מחושבת כ-segment כפול 16 ועוד offset:
| מצב | CS | IP | כתובת פיזית |
|---|---|---|---|
| לפני הקפיצה | 0x3000 | 0x0100 | 0x30000 + 0x0100 = 0x30100 |
| אחרי far jmp אל 0x4800:0x0010 | 0x4800 | 0x0010 | 0x48000 + 0x0010 = 0x48010 |
| אילו הייתה near jmp אל IP=0x0500 | 0x3000 | 0x0500 | 0x30000 + 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: שני דילוגים וחיסור שעובר מתחת לאפס
mov dl, 0x15
jmp P1
add dl, 0x70
P1:
add dl, 0x08
jmp P2
sub dl, 0x01
P2:
sub dl, 0x20| # | מה התבצע | DL אחרי | הערה |
|---|---|---|---|
| 1 | mov dl, 0x15 | 0x15 | - |
| 2 | jmp P1 | 0x15 | add dl, 0x70 לא מתבצעת |
| 3 | add dl, 0x08 | 0x1D | 0x15 ועוד 0x08 |
| 4 | jmp P2 | 0x1D | sub dl, 0x01 לא מתבצעת |
| 5 | sub dl, 0x20 | 0xFD | 0x1D פחות 0x20 הוא מינוס 3, וב-8 ביט מינוס 3 נשמר כ-0xFD |
בסוף DL=0xFD. שתי השורות המדולגות לא משאירות שום עקבה בתוצאה.
מעקב: AH ו-AL כשני אוגרים נפרדים
תרחיש 4: גלישה ב-AL שלא עוברת ל-AH
mov ax, 0x4CE0
jmp A1
sub ah, 0x02
A1:
add al, 0x35
jmp A2
add ah, 0x10
A2:
sub ah, 0x01| # | מה התבצע | AH | AL | AX | הערה |
|---|---|---|---|---|---|
| 1 | mov ax, 0x4CE0 | 0x4C | 0xE0 | 0x4CE0 | - |
| 2 | jmp A1 | 0x4C | 0xE0 | 0x4CE0 | sub ah, 0x02 לא מתבצעת |
| 3 | add al, 0x35 | 0x4C | 0x15 | 0x4C15 | 0xE0 ועוד 0x35 הם 0x115. ב-AL נשאר 0x15, ו-AH לא זז |
| 4 | jmp A2 | 0x4C | 0x15 | 0x4C15 | add ah, 0x10 לא מתבצעת |
| 5 | sub ah, 0x01 | 0x4B | 0x15 | 0x4B15 | AL לא מושפע |
בסוף AX=0x4B15. היחידה העודפת מהחיבור ב-AL פשוט נעלמת ולא מתווספת ל-AH. מי שמעביר אותה ל-AH מקבל 0x4C15, וזו טעות.
מעקב: אותה פונקציה פעמיים, וגלישה בפעם השנייה
תרחיש 5: שתי קריאות ל-BUMP
mov dh, 0xFD
call BUMP
call BUMP
jmp AFTER
BUMP:
add dh, 0x02
ret
AFTER:
add dh, 0x10נקרא RA1 לכתובת של ה-call השני, ו-RA2 לכתובת של jmp AFTER.
| # | מה התבצע | DH | במחסנית | הערה |
|---|---|---|---|---|
| 1 | mov dh, 0xFD | 0xFD | ריקה | - |
| 2 | call BUMP | 0xFD | RA1 | הקריאה הראשונה |
| 3 | add dh, 0x02 | 0xFF | RA1 | עדיין אין גלישה |
| 4 | ret | 0xFF | ריקה | חזרה אל ה-call השני |
| 5 | call BUMP | 0xFF | RA2 | הקריאה השנייה |
| 6 | add dh, 0x02 | 0x01 | RA2 | 0xFF ועוד 2 הם 0x101, וב-8 ביט נשאר 0x01 |
| 7 | ret | 0x01 | ריקה | חזרה אל jmp AFTER |
| 8 | jmp AFTER | 0x01 | ריקה | קפיצה מעל הגוף של BUMP, כדי שלא ירוץ פעם שלישית |
| 9 | add dh, 0x10 | 0x11 | ריקה | - |
בסוף DH=0x11. כל ret חזרה בדיוק לשורה שאחרי ה-call שהפעיל אותה.
מעקב: קפיצה אחורה באוגר של 16 ביט
תרחיש 6: קטע שדולג ואז רץ
mov dx, 0x0030
jmp R2
R1:
sub dx, 0x0004
jmp R3
R2:
add dx, 0x000C
jmp R1
R3:
add dx, 0x0001| # | מה התבצע | DX אחרי | הערה |
|---|---|---|---|
| 1 | mov dx, 0x0030 | 0x0030 | - |
| 2 | jmp R2 | 0x0030 | קפיצה מעל הקטע R1 |
| 3 | add dx, 0x000C | 0x003C | בתוך R2 |
| 4 | jmp R1 | 0x003C | קפיצה אחורה, אל הקטע שדולג |
| 5 | sub dx, 0x0004 | 0x0038 | עכשיו R1 רץ |
| 6 | jmp R3 | 0x0038 | קפיצה קדימה |
| 7 | add dx, 0x0001 | 0x0039 | - |
בסוף DX=0x0039. סדר הביצוע שונה מסדר הכתיבה: הקטע R1, שכתוב ראשון, רץ רק אחרי R2.
מעקב: גלישה באוגר של 16 ביט
תרחיש 7: חיבור שעובר את 0xFFFF
mov cx, 0xFFFA
jmp W
inc cx
W:
add cx, 0x0009| # | מה התבצע | CX אחרי | הערה |
|---|---|---|---|
| 1 | mov cx, 0xFFFA | 0xFFFA | - |
| 2 | jmp W | 0xFFFA | inc cx לא מתבצעת |
| 3 | add cx, 0x0009 | 0x0003 | 0xFFFA ועוד 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, src | dest מקבל dest + src | אין, אלא אם היעד הוא ESP עצמו | מתקדם להוראה הבאה |
sub dest, src | dest מקבל 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 |
; 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.