גלישת חוצץ

מתוך ויקיפדיה, האנציקלופדיה החופשית

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

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

[עריכה] תיאור

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

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

[עריכה] הסכנות שבגלישת חוצץ

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

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

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

[עריכה] מניעת גלישות חוצץ

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

השפות C ו ++C, למשל, נותנות למתכנת יד חופשית בניהול הזיכרון, ולכן הסיכוי לגלישת חוצץ בתוכניות שנכתבות באמצעותן גדול יותר. Java ו־Lisp, לעומתן, מנהלות את הזיכרון אוטומטית ולכן הסיכוי לבאג כזה הוא אפסי. Perl לעומת זאת משנה אוטומטית גדלים של מערכים בהתאם לחוצץ בשימוש. עם זאת גם שימוש בשפות אלו איננו בהכרח מגן באופן מלא בפני התופעה (למשל ראו כאן) בשל השימוש בשירותים הכתובים בשפות בלתי מוגנות.

[עריכה] תיאור טכני

להלן תיאור גלישת חוצץ החל ברמת שפת הסף. מחסנית (stack) הפקודות מתמלאת בשיטת ראשון נכנס אחרון יוצא (FILO), בצורה הבא:

(NEWDATA)(DATA)(DATA)(...)

כאשר תוכנית (למשל C) מריצה פונקציה היא דוחפת (push) קודם כל את הכתובת (ADDR) ורק לאחר מכן את שאר המידע על מנת שהמחשב ידע לאן עליו לחזור בסיום הפונקציה (למעשה באסמבלר הכתובת היא ה IP: instruction pointer):

(ADDR)(DATA)(DATA)(...)

אם התוכנית הכריזה על מערך בגודל מסוים, למשל על ידי '[char a[10' הוא ידחף אחרי הכתובת חזרה:

(.a.........)(ADDR)(DATA)(DATA)(...)

או בצורה מדויקת יותר:

bottom of                                                            top of
memory                                                               memory
           buffer2       buffer1   sfp   ret   a     b     c
<------   [            ][        ][    ][    ][    ][    ][    ]
           
top of                                                            bottom of
stack                                                                 stack

כשהפונקציה תסתיים כל מה שנדחף יצא (pop) והכתובת חזרה תקרא על ידי RET להחזרת התוכנית למקום שממנה היא יצאה. עכשיו נניח שהוכנסו לאותו משתנה 14 ספרות במקום 10 שהוקצו לו. אם התוכנית לא תבדוק שכמות הספרות תואמת את המערך, ארבעת הספרות האחרות ידרסו את מה שבא אחרי המערך – כתובת החזרה.

במקרה והטעות תמימה כנראה שהמידע הנוסף יהיה רנדומאלי ויפגע בכתובת חזרה כך שהיא תצביע על כתובת שלא נמצאת תחת השליטה של התוכנית שרצה כרגע, דבר שיגרום לטעות כאשר התוכנית תנסה לחזור לשם (ב jump) – שגיאת קומפילציה שנקראת segmentation fault.

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

[עריכה] דוגמה בשפת C לתוכנית המבצעת גלישת חוצץ

void function(char *str) {
   char buffer[16];

   strcpy(buffer,str); // Str, 256 - Buffer, 16 = Crash
}

int main() {
  char large_string[256];
  int i;

  for( i = 0; i < 255; i++)
    large_string[i] = 'A';

  function(large_string);

  
  return 1;
}