int main()
{
char buff[200];
fgets(buff,200,stdin);
printf(buff);
return 0;
}

כיצד ננצל קוד זה בשביל להשתלט על המחשב?

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

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

לאחר חידות אלו נעשה סיכון לנקודות, ונתן WINNER בהתאם.

ע"י Debugger, ניתן לבדוק, כנראה, היכן מתחילה המחסנית, והיכן היא מסתיימת...כמו כן, ניתן לראות את המבנה שלה (מקום שמור ל-buff, לערך המוחזר, לכתובת החזרה וכו'...).

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

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

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

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

למשל הקוד לעיל על המחסנית יראה כך:
Return address: 1000
Base Pointer, BP: 998
Buffer: 798-997

המספר 1000 נבחר שרירותית. (יש לשים לב שהמחסנית צומחת למטה
במעבדי אינטל.)
אם המשתמש ניגש לתא הראשון בBUFFER הוא ניגש לכתובת 798 אם הוא ניגש
לערך האחרון, הוא יגש לכתובת 997, אבל עם אני נותן לו אינדקס גדול יותר
201 או 202 אני אחרוג מהמקום שהוקצה לBUFFER בזכרון ואכתוב על המקום
של הBP, שזה וודאי לא יעזור לתוכנית לרוץ נכון, אבל לא זה העניין שלנו,
כאשר נמשיך לגשת לאינדקסים גבוהים מידי, 203,204 אנו נכתוב מידע
מעל כתובת החזרה. במקומות אלו בBUFFER שלנו אנו נכתוב את הכתובת של
הBUFFER שלנו בזכרון על המחסנית 997, ואז כאשר נחזור מהפונקציה
המעבד יקפוץ לכתובת 997 שזה איפה אנחנו שמנו את הקוד הזדוני שלנו.

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

השיטה לפריצה אליה אתה מכוון נקראת Injection כלומר "הזרקה"

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

השיטה נפוצה מאוד בעבודה עם בסיסי נתונים כאשר השאילתה נבנית בתוך התוכנית וע"י Injections מסויימים ניתן ממש להכניס שאילתות שלמות. למשל למחיקת נתונים שינויט נתונים וכדומה.

הפרמטר n% אומר ל printf לא להדפיס כלום וארגומנט הוא מצביע לכתובת בה מאוחסנים מספר התווים שהודפסו עד כה.

אם נכניס כקלט משהו כמו 666,"n%" נוכל לגרום לפונקציה להגיע לכתובת אשר לא שייכת לתוכנית.

שוב המטרה היא לתת לprintf איזה שהוא format string שיגרום לתוכנית
להריץ קוד כרצוני!

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

(המרצה, שחר שמש, נתן לי כתרגיל למחשבה את הבעיה עם הprintf,
ואני דיי משוכנע שיש לי פתרון מלא ונכון)

האם כל הקומפיילרים של C עובדים באותה שיטה בדיוק?

האם זה נכון גם לשפות אחרות או בכל שפה מבנה הזכרון אחר?
האם יש לך אתרים בנושא מבנה הזכרון של תוכנית בשפת C?

אני מנסה בינתיים לפתור את שאלתך.

2. מה מציין הביטוי %$10n.

3. איזה מחרוזת תשמש (בעזרת %n) אותנו כדי לכתוב ביטוי מסויים, למשל 0xBF, לכתובת מסויימת בזיכרון, למשל 0xB1D873FF.

4. איפה (באיזה כתובת בזיכרון) בדיוק ה%n שם את הערך שנתת לו ?
כתבת שזה לכתובת חזרה של הפונקצייה שקראה ל-printf. למה שזה יכתוב את זה שם ? איך אני מוצא (ב-Debbug) את הכתובת חזרה של פונקצייה מסויימת ?