גלישת חוצץ

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

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

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

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

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

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

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

[עריכה] מדוע מבצעים גלישת חוצץ זדונית?

משתמשים זדוניים עלולים לנסות לנצל את גלישת החוצץ לקבלת הרשאות גבוהות יותר מאלו שהוקצו להם (למשל הרשאות משתמש על או אדמיניסטרטור).

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

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

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

השפות 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;
}