Security
Shell, Buffer, Overflow, Exploit
Shell, חולשות Buffer Overflow, Exploit, Shellcode, Rootkit וכלים כמו Metasploit ו-Ghidra.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Shell, Buffer, Overflow, Exploit: עקרונות הגישה, הצפות זיכרון, ניצול והגנות
כדי להגן על מערכות בצורה אפקטיבית, עליכם להבין כיצד נראית תקיפה מהצד הטכני ומהי נקודת הכשל בכל שלב. מדריך זה מרכז שישה נושאי יסוד באבטחה התקפית מנקודת מבט הגנתית, בדגש על הבנת המנגנונים, זיהוי סימני אזהרה ובחירת הגנות מתאימות.
- Shell מרוחק: מהי גישה לשורת הפקודה, כיצד נקבעות ההרשאות של הפקודות, ומה מבדיל בין Reverse Shell, Bind Shell ו-Web Shell.
- Buffer Overflow: כיצד כתיבה מעבר לגבולות מאגר דורסת את כתובת החזרה במחסנית, אילו פונקציות בשפת C יוצרות את הסכנה, ואיך פועלות ההגנות Canary, ASLR ו-NX/DEP מול טכניקות עקיפה.
- Exploit וניצול פגיעויות: ההפרדה המדויקת בין פגיעות, קוד ניצול ו-Payload, ההבחנה בין Zero-day ל-N-day, ורצף שלבי התקיפה עד להעלאת הרשאות.
- Metasploit: מבנה המסגרת לבדיקות חדירה, משמעות הפרמטרים
RHOSTS,LHOSTו-LPORT, והתפקידים של Meterpreter ושלmulti/handler. - Rootkit: שימוש ב-Hooking להסתרת פעילות ברמת המשתמש או הליבה, וכיצד מאתרים ומטפלים במערכת שנפגעה.
- Reverse Engineering: ניתוח סטטי מול ניתוח דינמי של קובצי הרצה, כלים נפוצים, סביבה מבודדת, טכניקות הקשיה, Patch Diffing ו-Fuzzing.
לפני שמתחילים, שלושה רעיונות שכדאי להחזיק בראש, וכל אחד מהם מופיע בנושא מסוים:
- פורט רשת הוא מספר שמציין איזה שירות במחשב מקבל את התעבורה, והוא חוזר בנושאי ה-Shell וה-Metasploit.
- בשפת C רוב פקודות ההעתקה הוותיקות אינן בודקות כמה בתים נכתבים, וזו נקודת המוצא של Buffer Overflow.
- בכל קריאה לפונקציה המחסנית שומרת את המשתנים המקומיים ואת המקום שאליו יש לחזור בסיומה.
Shell: גישה לשורת הפקודה של היעד
מה זה Shell ובאילו הרשאות הוא רץ
נניח שתוקף מצא באג בשרת אינטרנט שרץ תחת החשבון www-data, וקיבל דרכו יכולת להקליד פקודות, כלומר Shell: מפרש פקודות של מערכת ההפעלה, תוכנה שמתרגמת שורות טקסט לפעולות שהמערכת מבצעת. דוגמאות: bash, sh ו-zsh בלינוקס, וכן cmd.exe ו-PowerShell ב-Windows.
התשובה לשאלה "מה מותר לתוקף לעשות?" היא: בדיוק מה ש-www-data מורשה. ה-Shell אינו מעניק כוח, הוא רק דרך להקליד פקודות בתוך התהליך שנפרץ, ולכן הפקודות נושאות את זהות התהליך וההרשאות שלו. מי יושב ליד המסוף המקומי ומה תפקידו של מנהל הרשת אינם משנים דבר.
מכאן שגם root או SYSTEM אינם מגיעים מעצמם. כדי לעבור מחשבון שירות מצומצם לשליטה מלאה נדרש צעד נפרד שבא אחר כך, והוא נקרא העלאת הרשאות (Privilege Escalation).
ומה לגבי מחיקת יומנים, החלפת סיסמאות או הצפנת קבצים? אלה פעולות שאפשר לבצע כשיש Shell, אבל הן לא מה שמגדיר אותו. במינוח של אבטחת מידע, "השגת Shell" פירושה היכולת להריץ פקודות ותוכנות במחשב מרוחק בלי לשבת מולו פיזית.
טעויות נפוצות
- Shell הוא קובץ נוזקה ייעודי שמושתל ברקע המחשב. מדובר במפרש פקודות לגיטימי של מערכת ההפעלה, ולא בקובץ זדוני בפני עצמו.
- Shell הוא פרוטוקול הצפנה שנועד להסתיר תעבורה ברשת. התפקיד שלו הוא הרצת פקודות מול מערכת ההפעלה, ללא קשר להצפנת תעבורה.
- ברגע שנפתח Shell מרוחק, הוא פועל מיד עם הרשאות מנהל מלאות. ההרשאות נגזרות אך ורק מהתהליך הפגיע שדרכו בוצעה החדירה, ושדרוגן מחייב שלב נוסף.
בדקו את עצמכם
שירות אפליקטיבי שרץ תחת חשבון app_svc נפרץ, והתקבל דרכו Shell מרוחק. אילו הרשאות יש לפקודות שירוצו בו?
הפקודות ירוצו בהרשאות app_svc בלבד, משום שה-Shell יורש את הקשר האבטחה של התהליך שנפרץ.
מהי התרומה המרכזית של קבלת Shell בהשוואה למחיקת קבצי לוג?
ה-Shell מספק גישה כללית להרצת פקודות ותוכנות על המערכת המרוחקת; מחיקת לוגים היא רק שימוש אפשרי אחד לאחר מכן.
Reverse Shell: חיבור יוצא מהקורבן
דמיינו שאתם מנהלי המערכת ורואים ב-netstat שתהליך של שרת האינטרנט מחזיק חיבור פתוח אל כתובת חיצונית שאינכם מכירים. זה יכול להיות Reverse Shell: המחשב שנפרץ הוא היוזם, והוא פונה החוצה אל מאזין (listener) שממתין אצל התוקף.
כשהערוץ נוצר, הפקודות עוברות דרכו פנימה והפלט חוזר החוצה. מה שזורם בו הוא רק הקלט והפלט של שורת הפקודה, ולא התעבורה הרגילה של הקורבן.
מדוע תוקפים אוהבים את השיטה? כי ארגונים נוהגים לחסום חיבורים שנפתחים מבחוץ פנימה, באמצעות חומת אש ו-NAT, ופחות מקפידים על מה שיוצא. חיבור יוצא לפורט 443 או 80 נראה כמו גלישה רגילה, ולכן הוא עובר בקלות.
שלוש אי-הבנות נפוצות לגבי הפורט הזה:
| טענה שגויה | מה נכון |
|---|---|
הפורט 443 מעניק ל-Shell הרשאות גבוהות | ההרשאות נקבעות לפי התהליך שנפרץ, לא לפי מספר הפורט |
| השרת הנפרץ פותח פורט האזנה חדש | השרת רק פונה החוצה, וההאזנה מתבצעת אצל התוקף |
| NAT מסנן חיבורים יוצאים לפי פורט | הסינון נובע מחוקי ה-Firewall, לא מ-NAT |
ההגנה העיקרית היא Egress Filtering: רשימה מוגדרת של יעדים ופורטים שהשרת רשאי לפנות אליהם ביוזמתו. שרת אינטרנט רגיל כמעט אינו צריך לפנות לכתובות אקראיות, ולכן חיבור יוצא חריג נחסם או מתריע. מומלץ להוסיף ניטור של תהליכי-בן חריגים, למשל שרת אינטרנט שמפעיל תהליך Shell, כדי לתפוס גם מה שעבר את הסינון.
תרחיש 1: שרת דואר עם כללי יציאה מצומצמים
שרת דואר מקבל חיבורים נכנסים בפורטים 25 ו-587 בלבד. חומת האש מתירה לו לפנות החוצה רק לפורט 443, לצורך עדכוני תוכנה, ולפורט 53.
נמצא בשרת באג שמאפשר להריץ פקודה. אם הפורץ ינסה גישת Bind Shell (הקורבן פותח בעצמו פורט האזנה חדש וממתין לחיבור נכנס, ויוסבר בהמשך), הכניסה לפורט החדש חסומה בחומת האש והניסיון ייכשל.
לעומת זאת, שרת שיפנה החוצה לפורט 443 של מאזין זר יוצר בדיוק את סוג החיבור שהחומה מתירה, ולכן Reverse Shell יצליח. הסימן הבולט הוא חיבור 443 מתהליך הדואר לכתובת שאינה שרת עדכונים מוכר. כאן מה שמכריע הוא כיוון החיבור והפורט המותר, ולא תוכן הפקודות.
טעויות נפוצות
- ב-Reverse Shell התוקף יוזם את החיבור אל פורט פתוח אצל הקורבן. היוזם הוא דווקא המחשב שנפרץ, שפונה החוצה אל המאזין של הצד השני.
- שימוש בפורט 443 מקנה לחיבור הרשאות גבוהות או עוקף חסימת NAT יוצאת. פורט אינו מעניק הרשאות, ו-NAT אינו חוסם תקשורת יוצאת לפי פורט; הבחירה נובעת מהיתרי Firewall.
- זיהוי Reverse Shell מתבצע בבדיקת חוקי כניסה של Firewall או לפי עומס מעבד גבוה. החיבור הוא יוצא ולא נכנס, ו-Shell שקט כמעט אינו צורך משאבי מעבד; האיתור נעשה בניטור חיבורים יוצאים.
בדקו את עצמכם
איזו בקרה רשתית מצמצמת משמעותית את היכולת להשתמש ב-Reverse Shell?
יישום Egress Filtering שחוסם חיבורים יוצאים משרתים לכתובות ופורטים שאינם מאושרים מראש.
כיצד תזהו בבדיקה על השרת עצמו שקיים Reverse Shell פעיל?
בבדיקת חיבורי רשת פעילים (למשל עם netstat או lsof) יופיע חיבור יוצא לכתובת זרה מתהליך לא שגרתי.
Bind Shell: הקורבן מאזין, התוקף מתחבר
נניח שחומת האש חוסמת כל חיבור נכנס חדש חוץ מכמה פורטים מוכרים. Bind Shell ייתקל שם בבעיה, משום שבגישה הזו הקורבן הוא זה שממתין: המערכת שנפרצה פותחת פורט האזנה חדש וקושרת אליו את מפרש הפקודות, והצד המרוחק הוא שיוזם את החיבור הנכנס.
לאחר שהחיבור נוצר הערוץ נשאר פתוח, ואפשר לשלוח פקודה אחר פקודה בלי להתחבר מחדש. אין צורך ב-VPN, אך הפורט חייב להיות נגיש ישירות מהרשת שממנה התוקף מתחבר.
לתוקף יש כאן שני חסרונות: חומות אש ונתבי NAT חוסמים בדרך כלל חיבורים נכנסים שלא אושרו, ופורט האזנה חדש ולא מוכר בולט בסריקת פורטים שגרתית.
כדי לא להתבלבל, שני דברים אינם Bind Shell: שירות SSH שצוות המערכת הגדיר ואישר מראש, ומפרש פקודות מקומי שאינו חשוף לרשת. Bind Shell דורש שני תנאים יחד: מפרש הפקודות נקשר לפורט שנפתח בעקבות פריצה, והפורט נגיש מרשת.
| שאלה | Reverse Shell | Bind Shell |
|---|---|---|
| מי שולח את בקשת ההתחברות הראשונה? | המחשב שנפרץ | הצד המרוחק |
| איפה ממתין המאזין? | בעמדה של התוקף | על המחשב שנפרץ, בפורט חדש |
| איזה כלל בחומת האש מפריע לו? | כמעט אין, כי תקשורת יוצאת מותרת בדרך כלל | חסימת חיבורים נכנסים |
| איך מגלים אותו? | בבדיקת החיבורים הפעילים של השרת | בפורט האזנה חדש בסריקה |
טעויות נפוצות
- חיבור SSH שמנהל מערכת הגדיר לגישה מרחוק הוא דוגמה ל-Bind Shell. SSH הוא כלי ניהול מורשה ומתוכנן מראש, ולא פתיחת האזנה זדונית של פורץ.
- Bind Shell מתנתק מיד לאחר כל פקודה בודדת. החיבור נשאר פתוח לאורך זמן ומאפשר רצף פקודות.
בדקו את עצמכם
מה קורה בצד המחשב הנתקף כאשר מופעל עליו Bind Shell?
תהליך במחשב הנתקף פותח פורט האזנה וממתין לחיבור נכנס מבחוץ.
Web Shell וזיהוי Shell נסתר
במקום ערוץ רשת ייעודי, Web Shell משתמש בשרת האינטרנט עצמו. התוקף שולח בקשת HTTP רגילה לקובץ סקריפט שהושתל בשרת, לדוגמה בשפת PHP או ASPX, והסקריפט מריץ את הפקודה שבבקשה ומחזיר את התוצאה בתשובה. אין כאן חיבור מתמשך אל מפרש פקודות, אלא סדרה של בקשות ותשובות.
הקובץ מגיע לשרת בדרך כלל דרך חולשה: מנגנון העלאת קבצים שאינו מוגבל כראוי, או פגיעות הכללת קבצים מרוחקת (RFI). כמו בשני הסוגים האחרים, הפקודות רצות בהרשאות של תהליך שרת האינטרנט.
בדקו את עצמכם
מה מבדיל Web Shell מ-Reverse Shell מבחינת אופן התקשורת?
Web Shell מקבל פקודות בתוך בקשות HTTP לשרת האינטרנט, ואילו Reverse Shell פותח חיבור רשת ישיר החוצה.
Buffer Overflow: הצפת מאגר בזיכרון
מה זה Buffer Overflow וכתובת החזרה
נתבונן בפונקציה read_name שמחזיקה משתנה מקומי char name[8], שמונה בתים לשם משתמש. מאגר (Buffer) הוא בדיוק זה: רצף תאי זיכרון בגודל קבוע שנועד להחזיק נתונים. כשנכתבים אליו תשעה בתים או יותר, בזמן ריצה, מתרחש Buffer Overflow: הכתיבה גולשת מעבר לקצה ודורסת את מה שנמצא ממש אחריו.
מה נמצא אחריו? במחסנית (Stack) כל קריאה לפונקציה מקבלת מקטע משלה: המשתנים המקומיים, ובסמוך אליהם כתובת החזרה (Return Address), המקום בקוד שאליו המעבד קופץ כשהפונקציה נגמרת. קלט ארוך מדי עובר את name, דורס משתנים סמוכים ובסוף מגיע גם לכתובת החזרה.
אם הערך החדש בכתובת החזרה נבחר בכוונה, בסיום הפונקציה המעבד יקפוץ אליו במקום לחזור לקורא, ובכך הבאג הופך מתקלה להשתלטות על זרימת הביצוע. הערך עשוי להצביע על Shellcode: הוראות מכונה קטנות שהניצול גורם לתהליך להריץ, ושתפקידן להתניע את מה שהתוקף רוצה, למשל פתיחת Shell.
שלושה דברים אינם נדרסים בתהליך הזה: קוד המקור, שלא נטען לזיכרון בכלל; מקטע ההוראות של התוכנית, שמוגן מפני שינוי; והערימה (Heap), שנועדה להקצאות דינמיות ואינה שומרת כתובות חזרה.
דריסה כזאת לא חייבת להסתיים בקריסה (מניעת שירות). היא יכולה לשבש משתנה סמוך בלבד, ויכולה גם להכווין את הביצוע. קיימת גם הצפה ב-Heap (Heap-based), שפוגעת בנתונים דינמיים ובמבני הניהול של מקצה הזיכרון.
הבעיה אופיינית ל-C ול-C++, שבהן אין אכיפת גבולות אוטומטית. שפות מנוהלות כמו Python, Java ו-C# בודקות חריגה מגבולות המערך.
שלוש בעיות אחרות מתבלבלות לעיתים עם הצפת זיכרון:
| מצב | איזו בעיה זו |
|---|---|
| שני תהליכים ניגשים לאותו משאב בו-זמנית | Race Condition |
| זיכרון שהוקצה ולא שוחרר | Memory Leak |
| סיסמאות שנשמרות כטקסט גלוי | ליקוי באחסון מידע, ולא בעיית גבולות |
טעויות נפוצות
- Buffer Overflow הוא באג שמתרחש בזמן הקומפילציה של התוכנית. הכתיבה העודפת קורית בזמן ריצה, כשמוזן לתוכנית קלט ארוך מכפי שהמאגר יכול להכיל.
- התוצאה האפשרית היחידה של הצפת מאגר היא קריסה מיידית של התהליך. קריסה היא אפשרות אחת, אך דריסה מכוונת של כתובת החזרה עלולה להעביר שליטה על זרימת הביצוע.
- כדי להסיט את הריצה בהצפת מחסנית, נדרס קוד המקור או כתובת ההתחלה של ה-Heap. הרכיב שנדרס במחסנית הוא כתובת החזרה השמורה סמוך למשתנים המקומיים.
בדקו את עצמכם
בפונקציה read_name קלט ארוך מדי גלש מעבר ל-name. איזה ערך נדרס בסופו של דבר, ושינה את יעד הקפיצה בסיום?
כתובת החזרה השמורה, שנמצאת בסמיכות למשתנים המקומיים.
במה שונה הצפה במחסנית מהצפה ב-Heap?
במחסנית נדרסים משתנים מקומיים סמוכים וכתובת חזרה, ואילו ב-Heap נפגעים נתונים שהוקצו דינמית ומבני הניהול של ההקצאה.
מהו Shellcode?
הוראות מכונה קטנות שניצול גורם לתהליך להריץ, כדי להתניע את מה שהתוקף מבקש.
פונקציות מסוכנות ובדיקת אורך קלט
שורש הבעיה אחד: מעתיקים נתונים למאגר בלי להשוות את אורכם לגודל שהוקצה. הפונקציות gets, strcpy, sprintf ו-scanf("%s") (ללא רוחב מוגבל) אינן מקבלות כלל את גודל היעד, ולכן כותבות עד סוף הקלט גם כשעברו את סוף המערך.
טעות נפוצה היא לחשוב ש-strcpy מסוכנת כי היא "שוכחת" תו סיום. בפועל היא כן מעתיקה את '\0' מהמקור, והבעיה היא היעדר גבול אורך. זה נכון גם כשהיעד הוקצה ב-malloc על ה-Heap.
הטיפול בשורש הבעיה דורש אימות אורך הקלט ומעבר לפונקציות תוחמות גודל:
- במקום
sprintfהשתמשו ב-snprintf(buf, n, ...): היא כותבת לכל היותרnבתים, כולל תו הסיום. - במקום
getsהשתמשו ב-fgets(buf, n, stdin): מעבירים כ-nאת גודל המאגר, והיא קוראת לכל היותרn-1תווים ומצרפת תו סיום. - היזהרו מ-
strncpy: היא מגבילה את מספר התווים המועתקים, אך כשהמקור באורך היעד או ארוך ממנו היא לא כותבת'\0', ויש להוסיף אותו ידנית.
התוכנית הבאה מעתיקה ארבעה שמות למשבצת של 8 בתים בשתי הפונקציות, ובודקת אם המשבצת הסתיימה בתו סיום. שימו לב למקרה של שם שאורכו 8 בדיוק.
#include <stdio.h>
#include <string.h>
/* Copies a name into an 8-byte slot with two functions and reports whether a terminator exists */
static void try_copy(const char *name) {
char slot[8];
memset(slot, 'x', sizeof slot); /* visible marker so garbage is not mistaken for '\0' */
strncpy(slot, name, sizeof slot);
printf("strncpy %-11s terminated: %s\n", name,
memchr(slot, '\0', sizeof slot) ? "yes" : "no");
memset(slot, 'x', sizeof slot);
snprintf(slot, sizeof slot, "%s", name);
printf("snprintf %-11s terminated: %s, kept %zu chars\n", name,
memchr(slot, '\0', sizeof slot) ? "yes" : "no", strlen(slot));
}
int main(void) {
const char *names[] = { "Dana", "Yonatan", "Benjamin", "Alexandria" };
for (size_t i = 0; i < sizeof names / sizeof names[0]; i++) {
try_copy(names[i]);
}
return 0;
}strncpy Dana terminated: yes
snprintf Dana terminated: yes, kept 4 chars
strncpy Yonatan terminated: yes
snprintf Yonatan terminated: yes, kept 7 chars
strncpy Benjamin terminated: no
snprintf Benjamin terminated: yes, kept 7 chars
strncpy Alexandria terminated: no
snprintf Alexandria terminated: yes, kept 7 charsבשמות הקצרים (4 ו-7 תווים) שתי הפונקציות מסיימות כראוי. ב-Benjamin ובשם הארוך ממנו strncpy ממלאת את כל 8 התאים ואינה משאירה מקום ל-'\0', ואילו snprintf מקצרת ל-7 תווים ושומרת מקום לתו הסיום.
לא כל צעד נראה כמו פתרון. הטבלה הבאה מסכמת מה לא עוצר הצפה:
| צעד | מדוע הוא לא מספיק |
|---|---|
| הגדלת המאגרים | קלט ארוך מספיק עדיין יגלוש |
| אנטי-וירוס או חומת אש | הם אינם מתקנים העתקה לא מבוקרת בקוד |
| הצפנת הקלט | היא אינה מקצרת את הנתונים שנכתבים |
| בדיקת סוג הנתונים, אימות הרשאות או הגבלת ניסיונות הזנה | אף אחד מהם לא עוצר מחרוזת ארוכה מדי |
טעויות נפוצות
- הסכנה ב-strcpy היא שהיא שוכחת להעתיק את תו הסיום '\0'. הפונקציה מעתיקה בעצמה את תו הסיום מהמקור, ואילו הכשל הוא שאין לה גבול אורך.
- הגדלת כל המערכים ל-1024 בתים או הצפנת הקלט מונעות Buffer Overflow. קלט ארוך מ-1024 בתים עדיין יגלוש, והצפנה אינה מונעת חריגה מגבולות המערך.
- הקצאה ב-malloc על ה-Heap חסינה מהצפה בהעתקה עם strcpy. היעדר בדיקת גבולות מסוכן באותה מידה גם במאגרים שהוקצו על ה-Heap.
בדקו את עצמכם
מדוע strncpy אינה נחשבת פתרון מושלם בפני עצמה?
כשהמקור ארוך מגודל היעד או שווה לו, היא אינה כותבת תו סיום '\0' בסוף המחרוזת.
מה מונעת בדיקת אורך הקלט לפני העתקתו?
היא מונעת כתיבה מעבר לגבולות הזיכרון שהוקצה למאגר, ובכך מטפלת בשורש של Buffer Overflow.
איזה ערך מעבירים ל-fgets כגבול הקריאה, וכמה תווים היא קוראת בפועל?
מעבירים את גודל המאגר כ-n, והיא קוראת לכל היותר n-1 תווים ומשאירה מקום לתו הסיום.
הגנות זיכרון: Canary, ASLR, NX/DEP
קוד בטוח הוא קו ההגנה הראשון, אך מערכות הפעלה ומהדרים מוסיפים שלוש שכבות שמקשות על ניצול של באג שכבר קיים. נעקוב אחרי ניסיון ניצול של הצפת מחסנית ונראה איזו הגנה מתערבת בכל שלב. זו רשימה של שכבות ולא ציר זמן מדויק, כי ASLR פועל כבר ברגע שבו התוקף בוחר לאן לקפוץ.
בשלב הראשון הקלט הארוך נכתב ודורס את כתובת החזרה. אף אחת מההגנות אינה עוצרת את הכתיבה עצמה, כי מבחינת התוכנית זו פעולה רגילה.
בשלב השני, לפני החזרה, נכנס לפעולה Stack Canary (מופעל ב-gcc -fstack-protector או ב-MSVC /GS). המהדר מניח במחסנית ערך אקראי בין המשתנים לכתובת החזרה, ודריסה רציפה שמגיעה אל כתובת החזרה חייבת לשנות אותו. הבדיקה בסוף הפונקציה חושפת את השינוי, והתהליך נעצר במקום לקפוץ.
בשלב השלישי הכתובת שנדרסה מצביעה אל קוד שהוזרק (Shellcode) בתוך המחסנית. כאן NX / DEP (ביט NX במעבד, או Data Execution Prevention ב-Windows) מסמן את אזורי הנתונים, מחסנית ו-Heap, כאסורים להרצה, והניסיון מסתיים בשגיאה: המעבד מדווח על הפרה, ומערכת ההפעלה עוצרת את התהליך. הכתיבה למחסנית עדיין מותרת, וההגנה אינה משנה כתובות ואינה מסננת תעבורת רשת.
בשלב הרביעי התוקף צריך לדעת לאן לקפוץ. ASLR (Address Space Layout Randomization) גורם לכך שבכל הפעלה המחסנית, ה-Heap והספריות המשותפות נטענים בכתובות אחרות, וגם התוכנית עצמה אם נבנתה כ-PIE (Position Independent Executable, קובץ שניתן לטעון בכל כתובת בסיס). הוא אינו מתקן את הבאג ואינו חוסם הרצה מאזור נתונים.
| הגנה | מה היא עושה | מה היא לא עושה |
|---|---|---|
| Stack Canary | בודקת, לפני החזרה מהפונקציה, שהערך האקראי שלפני כתובת החזרה נשאר שלם | לא עוצרת את הכתיבה ולא בודקת אורך קלט |
| ASLR | גורמת לכתובות הבסיס להשתנות בין הרצות | לא מתקנת את הבאג ולא מונעת הרצה מאזורי נתונים |
| NX / DEP | אוסרת הרצת הוראות מתוך אזורי נתונים | לא מונעת כתיבה עודפת ולא מערבלת כתובות |
טעויות נפוצות
- Stack Canary בולם את הכתיבה מעבר לגבולות המערך בזמן אמת. הוא אינו עוצר את הכתיבה, אלא בודק לפני פקודת החזרה אם הערך האקראי השתנה.
- DEP חוסם כל כתיבה למחסנית, ו-ASLR מסמן אזורים כלא ניתנים להרצה. המחסנית נשארת ניתנת לכתיבה; DEP חוסם הרצה מתוכה, ואילו ASLR רק מערבל כתובות.
בדקו את עצמכם
התהליך נעצר לפני שהפונקציה חזרה, אך הכתיבה העודפת כבר התבצעה. איזו הגנה פעלה, ובמה היא שונה מ-ASLR?
Stack Canary: היא מגלה שהערך השמור נדרס. ASLR לא בודק דריסה, אלא רק משנה כתובות בין הרצות.
מה קורה כש-DEP או NX פעיל וכתובת החזרה מצביעה על מאגר במחסנית?
המעבד מסרב להריץ הוראות מאזור נתונים, ולכן קוד שהוזרק לשם לא יפעל.
טכניקות עקיפה מתקדמות
כל הגנה קונה זמן ואינה חסינה. כדי ללמוד את טכניקות העקיפה כדאי לשאול על כל אחת: איזו הגנה היא מנסה להתגבר עליה, ומה המגן יכול לשנות כדי לעצור אותה.
מול ASLR התוקף לא מנסה לנחש כתובות אלא לגלות אחת מהן. באג נוסף שמדפיס כתובת מתוך ספרייה (דליפת מידע) מספיק, כי בתוך הספרייה המרחקים בין הפונקציות קבועים וניתן לחשב את שאר הכתובות.
במערכות של 32 ביט טווח האקראיות הצר מאפשר לפעמים גם ניחוש. הערבול מחושב מחדש בכל הרצה, ולכן הרצה חוזרת של התוכנית מניבה כתובות חדשות. ASLR פועל על כתובות הזיכרון של התהליך, ולכן אורך הקלט וכתובת ה-IP של הלקוח אינם משפיעים עליו.
מול NX/DEP, שאוסר הרצה מאזור נתונים, לא מזריקים קוד חדש אלא משתמשים בקוד קיים ולגיטימי:
- Return-to-libc: כתובת החזרה שנדרסה מצביעה על פונקציה שכבר קיימת בספרייה משותפת, כמו
systemשב-libc, והארגומנטים שלה מוכנים מראש במחסנית. - ROP (Return-Oriented Programming): מחברים כתובות חזרה לרצף של קטעי קוד קצרים מתוך הקוד הקיים (Gadgets), שכל אחד מהם מסתיים ב-
ret. כל הפעולה בנויה מקוד שהיה בזיכרון מראש.
לא כל טכניקה עוקפת את NX: NOP Sled (רצף של הוראות "אל תעשה דבר" שמונח לפני קוד שהוזרק כדי להקל על הנחיתה עליו) וניחוש כתובות אינם עוזרים, כי הרשאות הדף אוסרות הרצה מכל כתובת באזור נתונים.
מה כן בולם שרשרת ROP? CFI (Control Flow Integrity), שמשווה בזמן ריצה כל קפיצה וחזרה למפת היעדים המותרים של התוכנית. NX, חתימות אנטי-וירוס ו-Sandbox (סביבה מבודדת שמגבילה את הנזק לאחר חדירה) אינם עוצרים שרשור של קוד לגיטימי.
עוד כמה טכניקות מתקדמות, ברמת ההכרה בלבד, מקובצות לפי הבעיה שהן מנסות לפתור:
- Egg Hunter: משתמשים בו כשאין מספיק מקום במאגר לקוד המלא, או כשאי אפשר לדעת מראש באיזו כתובת בזיכרון הקוד הגדול נחת. במקום לקפוץ אליו ישירות, מכניסים קטע זעיר שסורק את הזיכרון בחיפוש אחר סימון ייחודי ("הביצה") וקופץ לקוד שמופיע אחריו. הקטע הזעיר רק מחפש, ואילו הדריסה של כתובת החזרה נעשית עדיין בידי ההצפה.
- Stack Pivoting: כשהמקום שנדרס במחסנית צר, קטע קוד קיים מעביר את מצביע המחסנית (Stack Pointer) לאזור זיכרון אחר שבשליטת התוקף, כמו ה-Heap, וכתובות החזרה נקראות מעתה מהאזור החדש. הוא אינו מגדיל את המחסנית, אלא מעביר אותה למקום אחר.
- SROP (Sigreturn Oriented Programming): הליבה משחזרת את כל האוגרים בקריאת המערכת
sigreturnלפי מסגרתsignalשבמחסנית, ומסגרת מזויפת קובעת את כולם בבת אחת באמצעות גאדג'ט יחיד. גם כאן הקוד קיים, ו-ASLR אינו מתבטל. - SEH Exploitation: ב-Windows של 32 ביט רשומות הטיפול בחריגות (Structured Exception Handling) יושבות במחסנית, וכל רשומה מחזיקה מצביע לפונקציית טיפול. החלפת המצביע הזה וגרימת חריגה מפעילות קוד לפני סוף הפונקציה, כלומר לפני בדיקת ה-Canary. ההגנות
SafeSEHו-SEHOPמצמצמות את הטכניקה, אך אינן עוצרות אותה לחלוטין. - Heap Spraying: בדפדפן, למשל דרך JavaScript, ממלאים את ה-Heap בעותקים רבים של נתונים, מבנים מזויפים או Shellcode. כך מצביע פגום שנוחת באזור כלשהו ב-Heap צפוי לפגוש בנתונים שהתוקף הכין.
- Pointer Subterfuge: ההצפה דורסת מצביע סמוך, שעשוי להצביע על פונקציה או על נתונים, בערך שהתוקף בחר, וכך התוכנה משתמשת אחר כך בכתובת או בערך שנקבעו על ידו. זה שונה מדריסה בערך סתמי שרק תקריס את התוכנית.
- Polymorphic Shellcode: מבנה הבייטים של ה-Shellcode משתנה בכל עותק, באמצעות הצפנה חלקית, שינוי סדר הוראות ומפענח (Decoder) שפועל בזמן ריצה, כדי לחמוק מחתימות סטטיות של אנטי-וירוס ו-IDS. ניטור התנהגותי (Anomaly) עשוי עדיין לזהות זאת.
תרחיש 2: מה עוצר מה: מנתח קובצי תמונה
מנתח קובצי תמונה רץ עם ASLR ו-NX. בסקירת קוד מתגלה שקובץ ארוך מהצפוי דורס כתובת חזרה.
הזרקת קוד למחסנית תיעצר ב-NX, וקפיצה לפונקציית ספרייה לפי כתובת קבועה לא תעבוד כי ASLR משנה אותה בכל הפעלה.
אבל אם התוכנה כותבת ליומן כתובת מתוך ספרייה משותפת, זו דליפה שמאפשרת לחשב את שאר הכתובות בה. שרשרת Gadgets מקוד קיים יכולה אז לעבוד מול שני המנגנונים, ורק CFI, או תיקון הבאג והדליפה, יעצרו אותה.
טעויות נפוצות
- Return-to-libc ו-ROP מזריקים קוד חדש או עובדים בדיוק באותה צורה. שניהם משתמשים בקוד קיים בלבד, אך ret2libc קופץ לפונקציה שלמה אחת ואילו ROP משרשר גאדג'טים קצרים.
- Stack Canary בולם ניצול SEH, והוספת NOP Sled עוקפת את NX. חריגת SEH קופצת לפני בדיקת ה-Canary בסוף הפונקציה, ופקודות NOP אינן משנות הרשאות אי-הרצה של NX.
- Egg Hunter דורס את כתובת החזרה, ו-Stack Pivoting מגדיל את שטח המחסנית. ההצפה היא שדורסת את כתובת החזרה, ו-Stack Pivoting מזיז את מצביע המחסנית לאזור אחר.
בדקו את עצמכם
המחסנית אינה ניתנת להרצה. איזו משפחת טכניקות עדיין אפשרית, ומדוע?
Return-to-libc או ROP, מפני שהן מפעילות קוד לגיטימי שכבר נמצא בזיכרון, ולא מזריקות קוד חדש לאזור נתונים.
איזה מנגנון עוצר שרשרת Gadgets ואיך?
CFI: הוא משווה כל קפיצה וחזרה למפת היעדים המותרת של התוכנית, וקפיצה לאמצע גאדג'ט נדחית.
האם SafeSEH ו-SEHOP מבטלים לגמרי את התקפת ה-SEH?
לא, הן מצמצמות אותה בלבד; למשל SafeSEH חלה רק על מודולים שנבנו איתה.
Exploit: ניצול פגיעות
פגיעות, Exploit ו-Payload
שלושה מונחים מתבלבלים לעיתים קרובות, ולכן כדאי לעקוב אחרי חולשה אחת לאורך שלושת השלבים שלה.
שרת קבצים מכיל קוד העתקה ללא בדיקת אורך: זו פגיעות (Vulnerability), פגם בתוכנה או בתצורה שקיים גם אם איש לא תקף אותו. מי שכותב קלט, קוד או שיטה שמתאימים לפגם וגורמים לתוכנית להתנהג שלא כמתוכנן יצר Exploit. ומה שרץ אחר כך על המכונה, למשל פתיחת Shell מרוחק, הוא ה-Payload.
גורם רביעי שונה לחלוטין הוא עדכון אבטחה (Patch): היצרן מפרסם אותו כדי לסגור את הפגם. Exploit הוא הניגוד שלו, כלי שעובד רק כל עוד הפגם לא נסגר, ואינו תיקון.
אפשר גם לסווג ניצולים לפי הגישה שהם דורשים. Remote Exploit מבוצע מעבר לרשת בלי אחיזה מוקדמת במערכת, ואילו Local Exploit דורש גישה קיימת למחשב ומשמש לרוב להעלאת הרשאות.
טעויות נפוצות
- Exploit הוא שם נרדף לפגיעות, או לעדכון שהיצרן משחרר. הפגיעות היא החולשה, העדכון סוגר אותה, וה-Exploit הוא הקוד שמנצל אותה.
- הרצת הפקודות במערכת לאחר הפריצה נקראת Exploit. מה שרץ לאחר הצלחת הניצול הוא ה-Payload.
בדקו את עצמכם
שרת אינטרנט נפרץ מרחוק ונפתח בו Reverse Shell. מהו ה-Exploit ומהו ה-Payload?
השיטה או הקוד שניצלו את הבאג בשרת הם ה-Exploit, ואילו קוד ה-Reverse Shell שרץ לאחר הכניסה הוא ה-Payload.
Zero-day מול N-day
נסתכל על ציר הזמן של חולשה: בשלב הראשון היצרן אינו יודע עליה, בשלב השני הוא מפרסם תיקון, ובשלב השלישי ארגונים מתקינים אותו, או לא.
בתקופה שלפני התיקון החולשה היא Zero-day: לצוותי ההגנה היו אפס ימים להיערך, וגם מערכת מעודכנת לגמרי חשופה. השם אינו קשור ליום התקנת המערכת בארגון, והחולשה נשארת Zero-day גם כשתוקפים כבר משתמשים בה, כל עוד אין עדכון רשמי.
אחרי פרסום התיקון החולשה הופכת N-day: חולשה ידועה ומתועדת, עם מזהה CVE, שהוא מזהה ציבורי לפגיעות ידועה. הסכנה כאן אינה מחסור בתיקון אלא מערכות שלא עודכנו, שמולן קוד ניצול ציבורי עובד בקלות.
ואם עדיין אין תיקון? אי אפשר לסגור את הפגם, אבל אפשר לצמצם את הנזק: פחות שירותים חשופים (הקטנת משטח התקיפה), הרשאות מינימליות, והגנות זיכרון כמו ASLR ו-DEP שמקשות על הניצול.
תרחיש 3: ציר הזמן של חולשה בשירות ההדפסה
חולשה בשירות ההדפסה של מערכת הפעלה מאפשרת למשתמש רגיל להגיע להרשאות מנהל. בחודש הראשון תוקפים כבר משתמשים בה, והיצרן אינו מכיר אותה.
באותו חודש היא Zero-day. הקוד שהתוקפים מפעילים הוא Local Exploit, כי הוא מחייב שהתוקף כבר יהיה מחובר למחשב עם חשבון משלו. אילו ניצל אותה מעבר לרשת, בלי חשבון קיים, היה זה Remote Exploit.
בחודש השני היצרן מפרסם תיקון ומקצה לחולשה CVE, והיא הופכת N-day. מעתה מחשב שלא הותקן בו התיקון נשאר פגיע, אך הסיבה היא עדכון חסר ולא היעדר תיקון.
טעויות נפוצות
- Zero-day הוא באג שמופיע ביום הראשון לאחר התקנת המערכת. השם מציין שלמגינים לא היה זמן היערכות כי טרם פורסם תיקון, ללא קשר למועד ההתקנה.
- פגיעות שיש לה תיקון אך הוא טרם הותקן נקראת Zero-day או Local Exploit. פגיעות עם תיקון זמין היא N-day; המונח Local Exploit מתאר צורך בגישה מקומית ואינו קשור לקיום תיקון.
בדקו את עצמכם
פורסם ברשת קוד שפוגע בתוכנה, אך היצרן עדיין אינו מודע לבעיה. איך מסווגים את החולשה?
Zero-day, כי טרם פורסם תיקון רשמי.
ארגון נפרץ דרך חולשה שיש לה CVE ותיקון שפורסם לפני חודשיים. איזה סוג חולשה זה ומה היה מונע את הפריצה?
N-day; התקנת התיקון בזמן.
שלבי התקיפה והעלאת הרשאות
נעקוב אחר חדירה אחת לשרת ארגוני, תחנה אחר תחנה:
- סיור (Reconnaissance): סריקות ואיסוף מידע על היעד, עוד לפני שידוע על פגיעות כלשהי.
- איתור פגיעות בתוכנה שנמצאה.
- הכנת Exploit מתאים.
- הפעלת ה-Payload לקבלת אחיזה, למשל Shell.
- Post-Exploitation: ביסוס הגישה, איסוף נתונים והרחבת השליטה.
והעלאת הרשאות? היא אינה חלק משלב הסיור, וגם אינה רק צעד סיום למחיקת עקבות. העלאת הרשאות (Privilege Escalation) באה רק אחרי שיש כניסה ראשונית: נניח שה-Shell רץ כמשתמש שירות מוגבל, התוקף מחפש חולשה מקומית או תצורה לקויה כדי להגיע לחשבון root או SYSTEM.
טעויות נפוצות
- סריקת פורטים היא חלק משלבי הניצול, והעלאת הרשאות נעשית בזמן איסוף המידע. סריקה שייכת לשלב הסיור המקדים, והעלאת הרשאות מתרחשת רק אחרי הכניסה הראשונית.
בדקו את עצמכם
תוקף סרק פורטים, השיג Shell ואז עבר מ-www-data ל-root. באיזה שלב בוצעה העלאת ההרשאות ומה קדם לה?
אחרי שהושגה כניסה ראשונית (ה-Shell); הסריקה שייכת לשלב הסיור שקדם לכך.
Metasploit: מסגרת לבדיקות חדירה
מה זה Metasploit ומה הוא איננו
נעבור על בדיקת חדירה מאושרת אחת ונראה היכן נכנס כל סוג של מודול ב-Metasploit Framework: פלטפורמה בקוד פתוח שמציעה מקום מרכזי אחד לניהול הבדיקה ולהרצת Exploits רבים, דרך הממשק msfconsole.
המסגרת נוצרה ב-2003 על ידי H. D. Moore, והיא בבעלות Rapid7 מאז 2009.
- באיסוף המידע משתמשים במודולי Auxiliary: סורקים ו-Fuzzers, ללא Payload.
- כדי לנצל חולשה שנמצאה, בוחרים מודול Exploit.
- אחריו בוחרים Payload, הקוד שירוץ ביעד לאחר שהניצול הצליח.
- כשנפתחת הפעלה (session), מריצים בתוכה מודולי Post-Exploitation לאיסוף מידע ובדיקת המערכת.
- לאורך הדרך, Encoders, NOPs ו-Evasion מתאימים וממירים את המטענים.
החלוקה בין Exploit ל-Payload מכוונת: בוחרים פעם אחת את דרך הכניסה, ואפשר לנסות מאחוריה מטענים שונים בלי לכתוב מחדש את הניצול. גם צוותי הגנה משתמשים בכלי, באישור בכתב: אחרי עדכון הם מריצים את אותו ניצול בסביבה מאושרת כדי לוודא שהוא כבר לא עובד.
כמה הנחות מוטעות נפוצות לגבי הכלי:
| מי שחושב ש-Metasploit הוא... | האמת |
|---|---|
| פגיעות | הוא כלי שמנצל פגיעויות |
| אנטי-וירוס או כלי הגנה | הוא מסגרת התקפית לבדיקות חדירה |
| כלי לפיצוח סיסמאות | זה לא תפקידו |
| כלי להנדסה לאחור | הוא אינו מבצע הנדסה לאחור |
| הפצת לינוקס | Kali היא ההפצה שבה הוא מותקן מראש כאחד הכלים |
השימוש בו מותר אך ורק בהרשאה כתובה.
טעויות נפוצות
- Metasploit הוא הפצת לינוקס או כלי לפיצוח סיסמאות ואנטי-וירוס. זו מסגרת לבדיקות חדירה המשלבת מודולי Exploit ו-Payload; Kali היא ההפצה שכוללת אותו.
בדקו את עצמכם
מה הערך המרכזי של Metasploit עבור בודק חדירות?
מקום מרכזי אחד לניהול הבדיקה ולהרצת Exploits רבים, ולא אנטי-וירוס, כלי לפיצוח סיסמאות או הפצת לינוקס.
בודק רוצה לנסות אותו ניצול מול כמה סוגי מטענים. מה מאפשר לו זאת ב-Metasploit?
ההפרדה המבנית בין מודולי ה-Exploit למודולי ה-Payload, שמאפשרת לצרף לאותו ניצול מטענים שונים.
מדוע מודולי Post-Exploitation אינם דורשים כלי נפרד?
הם רצים בתוך הפעלה (session) שכבר קיימת בעקבות הניצול.
הפרמטרים: RHOSTS, LHOST, LPORT
שם פרמטר במסגרת מתחיל ב-R כשהוא מתאר את הצד הרחוק (Remote), המערכת הנבדקת, וב-L כשהוא מתאר את הצד המקומי (Local), מכונת הבודק.
| פרמטר | על מה הוא מצביע |
|---|---|
RHOSTS / RPORT | המחשב הנבדק והפורט שעליו מופעל הניצול |
LHOST / LPORT | מכונת הבודק והפורט שבו היא ממתינה לקשר חוזר ממטען הפוך |
בדוגמה עם windows/meterpreter/reverse_tcp, הערך של RHOSTS הוא השרת הנבדק, ואילו LHOST ו-LPORT מציינים את עמדת הבודק שאליה המטען יפנה. LHOST הוא רק כתובת להתקשרות חזרה, ואין לו קשר לחלוקת קבצים או למאגר תוצאות הסריקה.
טעויות נפוצות
- הפרמטר LHOST מציין את כתובת השרת הנבדק או את בסיס הנתונים של התוצאות. היעד הנבדק מוגדר ב-RHOSTS, ואילו LHOST מציין את מכונת הבודק שמקבלת את החיבור החוזר.
בדקו את עצמכם
בהגדרת מטען reverse_tcp, על איזו מכונה מצביע LHOST?
על מכונת הבודק, שמאזינה לחיבור היוצא שמגיע מהמערכת הנבדקת.
Payload, Meterpreter ו-multi/handler
כדאי להפריד בין שני תפקידים: יצירת מטען, וקבלת הקשר ממנו. הכלי msfvenom יוצר קובצי Payload עצמאיים (קידוד שלהם אינו הצפנה ואינו מבטיח שאנטי-וירוס לא יזהה אותם), ואילו המודול exploit/multi/handler מקבל את הקשר.
ה-handler אינו מנצל שום פגיעות. הוא מאזין לחיבור שנכנס ממטען הפוך שהופעל בנפרד, ולכן צריך להפעיל אותו עם אותם LHOST ו-LPORT לפני הרצת הקובץ, או שהוא פונה אל מטען Bind שממתין. הוא מנהל את ה-Session, ואין לו חלק ביצירת קבצים, בסריקת פורטים או במחיקת יומנים.
ה-Payload עצמו רץ רק אחרי שהניצול הצליח, והוא אינו חולשה ואינו מודול סריקה. הדוגמה המוכרת היא Meterpreter: Payload מתקדם שרץ בזיכרון התהליך ואינו כותב קבצים לדיסק, ולכן קשה לגלות אותו בבדיקת דיסק רגילה. הוא מציע העברת קבצים, צילום מסך, הקלטת הקלדות והרצת פקודות.
את תצורת המטען אפשר לזהות בשם: לוכסן, כמו windows/meterpreter/reverse_tcp, מציין Staged, שבו רכיב פתיחה קטן מוריד את שאר הקוד. קו תחתון, כמו windows/meterpreter_reverse_tcp, מציין Stageless / Single, מטען שלם אחד.
תרחיש 4: מטען Bind וה-handler
בבדיקה מאושרת הופעל במכונה נבדקת מטען מסוג Bind, שפתח פורט האזנה וממתין. הבודק מגדיר ב-exploit/multi/handler את כתובת היעד ואת הפורט שהמטען פתח.
הפעם ה-handler הוא שיוזם את הפנייה והמטען ממתין, ולכן אין צורך ב-LHOST וב-LPORT של מאזין. ה-handler מנהל את ה-Session שנוצר, ואין כאן Exploit חדש.
טעויות נפוצות
- Meterpreter סורק פורטים ומנצל את החולשה הראשונית, ו-multi/handler יוצר קובצי הרצה. סריקה היא תפקיד Auxiliary, הניצול הוא תפקיד Exploit, ויצירת קובצי Payload נעשית ב-msfvenom.
- קידוד ב-msfvenom מצפין את המטען ומבטיח שהאנטי-וירוס לא יזהה אותו. קידוד משנה ייצוג של בתים ואינו מהווה הצפנה או ערובה להתחמקות מפתרונות אבטחה.
בדקו את עצמכם
איזה רכיב מייצר קובץ מטען, ואיזה ממתין לקשר ממנו?
msfvenom יוצר את הקובץ, ו-exploit/multi/handler ממתין לקשר וקולט אותו.
בדיקת דיסק ושרשרת קבצים לא מצאו כלום, אך יש חשד ל-Meterpreter. מה ההסבר?
הוא פועל מתוך הזיכרון בלבד ואינו כותב קבצים לדיסק.
Rootkit: הסתרת נוכחות זדונית
מהות ה-Rootkit, מטרתו ושכבות הפעולה שלו
דמיינו מנהל מערכת שפותח את רשימת התהליכים בשרת, בודק את חיבורי הרשת ועובר על הקבצים, ולא מוצא דבר חריג, בעוד שהתוקף שולט במכונה. כך נראית מערכת שהותקן בה Rootkit: רכיב או ערכת כלים שמסתירים נוכחות עוינת ובו בזמן מבטיחים לתוקף אחיזה קבועה בהרשאות גבוהות, כמו root או Administrator. מה שמוסתר כולל נוזקות נוספות, חיבורי רשת, תהליכים, ערכי Registry וקבצים.
כדי למקם את ה-Rootkit נכון, חשבו על ציר זמן. קודם התוקף נכנס, למשל בעזרת Exploit, ומשיג הרשאות, ורק אחר כך מתקין Rootkit כדי שהגישה לא תתגלה ותישאר זמינה גם בהמשך. לכן Rootkit אינו כלי פריצה: Exploit מנצל חולשה ברגע נקודתי, ואילו Rootkit שומר על מה שכבר הושג.
גם ההתקנה עצמה יכולה להתבצע בשכבות שונות של המערכת:
| שכבת הפעולה | אופן המימוש | משמעות אבטחתית |
|---|---|---|
| User-mode | החלפה או שינוי של תוכנות וספריות משותפות שרצות במרחב המשתמש | פחות עמיד: בבדיקת הליבה או הזיכרון מבחוץ אפשר לחשוף אותו, אף שמתוך המערכת עצמה הוא עדיין מטעה כלים הנשענים על הספריות שנפגעו |
| Kernel-mode | פועל בתוך הליבה כדרייבר או כמודול ליבה | המסוכן ביותר: יכול להטעות כל כלי שמקבל את המידע ממערכת ההפעלה |
| Bootkit | משתלט על רצף האתחול ועולה עוד לפני מערכת ההפעלה | שולט בסביבה לפני שהגנות המערכת נטענו |
| Firmware Rootkit | יושב בקושחת החומרה, למשל ב-UEFI | ממשיך להתקיים גם אחרי החלפת דיסק או התקנה חדשה של מערכת ההפעלה |
שלושה בלבולים נפוצים כדאי לפרק לפי מה שרואים בשטח:
- מחשבים ברשת שנדבקים זה אחרי זה בעותקים של אותה נוזקה: זו תולעת (Worm), שסימן ההיכר שלה הוא שכפול עצמי, ולא Rootkit.
- קובצי עבודה שנהפכו לבלתי קריאים ולצדם דרישה לתשלום: זו כופרה (Ransomware).
- מחשב איטי: זה אינו סימן אמין ל-Rootkit. מפני שהוא מנסה להישאר בלתי מורגש, הוא נמנע מעומס שעלול לעורר חשד.
טעויות נפוצות
- ה-Rootkit הוא הדרך שבה תוקף נכנס לראשונה למערכת. הוא מגיע אחרי הפריצה, כשכבר יש לתוקף הרשאות גבוהות, ותפקידו להחזיק אותן בסתר.
- Rootkit משכפל את עצמו למחשבים אחרים ברשת. שכפול עצמי הוא סימן ההיכר של Worm; Rootkit עוסק בהסתרה ובהישארות.
- מחשב שמגיב במהירות הרגילה כנראה נקי מ-Rootkit. הסתרה כוללת הימנעות מעומס בולט, ולכן היעדר האטה אינו מוכיח כלום.
- Rootkit נותן לתוקף גישה חד-פעמית. גישה נקודתית שייכת ל-Exploit; Rootkit נועד לשמר גישה חוזרת לאורך זמן.
בדקו את עצמכם
תוקף ניצל חולשה, השיג הרשאות root והתקין Rootkit. באיזה שלב ההתקנה מתבצעת, ומה מטרתה?
היא באה אחרי ההשתלטות, ומטרתה להסוות את הפעילות ולהשאיר גישה קבועה.
אתם צריכים להעריך סיכון: Rootkit ברמת משתמש מול מודול ליבה. איזה מהם מסוכן יותר, ולמה?
מודול הליבה, כי הוא רץ ברמת המערכת עצמה, ולכן כל כלי שמקבל נתונים ממערכת ההפעלה עלול לקבל תשובה כוזבת.
טכניקת Hooking: כיצד מתבצעת ההונאה
דמיינו פקיד בארכיון שמקבל בקשה לרשימת כל התיקים בארגז, ולפני שהוא מוסר אותה הוא מוחק ממנה כמה שורות. מי שביקש מקבל רשימה מסודרת ואינו יודע שמשהו חסר. זו תמצית ה-Hook (יירוט, ובשפת המבחנים גם “תפס”): השתלטות על נקודת המעבר של פונקציה או של קריאת מערכת, כך שהתשובה עוברת עיבוד לפני שהיא חוזרת למי ששאל.
בפועל כלי שמציג חיבורי רשת, כמו netstat, או כלי שמציג תוכן תיקייה, כמו ls, נטען ורץ כרגיל לגמרי. הוא רק מקבל תשובות שהרשומות העוינות כבר הוסרו מהן, והמשתמש רואה מערכת נקייה בזמן שהנוזקה ממשיכה לעבוד. הכלי עצמו אינו נחסם ואינו נכשל.
את היירוט אפשר לבצע בכמה נקודות מפתח:
- טבלת
syscall_tableבליבה: טבלה של מצביעים לקריאות המערכת. כשהמצביע של קריאה כמוopenאוexecveמוחלף בכתובת בקוד של ה-Rootkit, כל קריאה כזו עוברת קודם דרכו והפלט חוזר מסונן. - ספריית
libcבמרחב המשתמש: פונקציות ספרייה כמוreaddir,openו-socketמוחלפות בגרסאות מסננות. התוכניותlsו-psנשארות שלמות על הדיסק ורצות כרגיל, שמות הקבצים הזדוניים אינם משתנים, והרשימות שהפונקציות מחזירות הן שחסרות. - טבלת
IDT(Interrupt Descriptor Table): המעבד פונה אליה כדי לדעת איזו שגרה להפעיל כשמתרחשת פסיקה (Interrupt) או חריגה (Exception). אם מחליפים בה רשומה, קוד ה-Rootkit מקבל שליטה ראשון, ורק אחריו מגיעה השגרה המקורית של הליבה.
IDT; ותולעת (Worm) מתפשטת ואינה מסננת תשובות.טעויות נפוצות
- Hook ב-
libcפירושו שקובציlsו-psנכתבו מחדש בדיסק. הם נותרים כמות שהם; מה שנפגע הוא התשובה שפונקציות הספרייה מחזירות להם בזמן ריצה. - Hook מונע מ-
psלהיטען לזיכרון, ולכן הוא אינו יכול לרוץ.psנטען ורץ כרגיל; ה-Hook פועל על המידע שהוא מקבל, לא על עצם ההרצה. - כדי להסתיר קובץ, ה-Hook משנה את שמו למשהו שהסורק מדלג עליו. ההסתרה נעשית בסינון הפלט, והשם נשאר כמו שהוא.
- Hook ב-
IDTמפעיל את ה-Rootkit לפני העלאת מערכת ההפעלה.IDTפועלת כשהליבה כבר רצה; עלייה לפני המערכת מאפיינת Bootkit.
בדקו את עצמכם
ps על שרת נגוע רץ ללא תקלות ומציג רשימה נקייה, אך חיבור זדוני פעיל. מה קרה לקריאה שהוא ביצע?
הקריאה יורטה והתשובה סוננה לפני שחזרה אליו; התוכנית עצמה לא נפגעה.
מדוע Hook ב-libc מסוכן גם כשקובצי הכלים בדיסק זהים למקור?
כמעט כל תוכנית במרחב המשתמש קוראת לפונקציות הספרייה, ולכן כולן מקבלות אותה תמונה מסוננת, בלי קשר לשלמות הקבצים שלהן.
איתור חיצוני, מניעה וטיפול במערכת נגועה
הכלל הראשון: כל מה שנבדק מתוך מערכת חיה נגועה נשען על תשובות שהליבה עצמה מספקת, ולכן אי אפשר לסמוך עליו. יומני אירועים, ערך Hash שחושב בתוך המערכת, רשימת תהליכים ב-Task Manager וגם סריקת אנטי-וירוס שגרתית עלולים כולם לקבל נתונים מזויפים.
מכאן שבדיקה מהימנה צריכה להגיע מבחוץ, באחת הדרכים האלה:
- Cross-view Comparison: מציבים זה מול זה שני דיווחים על אותה מערכת, מה שמערכת ההפעלה מציגה ומה שנקרא ישירות מהדיסק או מהזיכרון. פער ביניהם, למשל תהליך שקיים בזיכרון אך חסר ברשימה, מסגיר הסתרה.
- Memory Forensics: לוקחים צילום זיכרון (Memory Dump) ובוחנים אותו מחוץ למערכת הנגועה, דרך קריאת מבני הנתונים הגולמיים. שם אפשר למצוא תהליכים, מודולים וחיבורים שהממשקים הרגילים העלימו.
- אתחול ממדיה חיצונית נקייה: מעלים את המחשב ממדיה מהימנה, רצוי לקריאה בלבד, וסורקים את הדיסק בשעה שה-Rootkit אינו טעון ולכן אינו יכול להסתיר.
- סורקים ייעודיים בלינוקס:
rkhunterו-chkrootkitמחפשים עקבות ודפוסים ידועים של Rootkits.
Rootkit ליבה מסתיר פריטים בתשובות, אך אינו חוסם את הגישה לדיסק עצמו, ולכן אפשר לקרוא את הדיסק ולסרוק אותו מבחוץ. הוא גם אינו מצפין קבצים ואינו מאט את המכונה; הוא פשוט משקר.
למניעת הטמעה של Rootkit משלבים עקרונות הקשחה בסיסיים: עבודה בהרשאות מינימליות, הפעלת Secure Boot, התקנת עדכוני אבטחה בזמן, ושימוש בחתימת קוד דיגיטלית (Code Signing). חתימת קוד מאמתת את זהות החותם ואת שלמות הקובץ (שהקוד לא שונה מאז שנחתם), ובכך מונעת טעינת דרייברים או מודולי ליבה שזויפו.
לאחר שזוהה Rootkit ברמת הליבה, הפעולה המקצועית היחידה המומלצת היא התקנה מחדש של מערכת ההפעלה מתמונה נקייה ומהימנה, ושחזור נתונים רק מגיבויים שנבדקו. אם נפגעה גם הקושחה, יש לבצע צריבה מחדש (Reflashing).
תרחיש 5: שרת אחסון עם סימנים חשודים
ביומני חומת האש של חברת אחסון מופיעה תעבורה יוצאת מתמשכת משרת מסד נתונים אל כתובת לא מוכרת, אך netstat על השרת אינו מציג חיבור כזה והסורק המקומי מדווח על מערכת נקייה. בדיקה מאתחול חיצוני מאשרת שיש Rootkit ברמת הליבה. הצוות מעלה ארבעה רעיונות:
- להקשיח את חומת האש, בין היתר בחסימת הכתובת החשודה, ולהמשיך לעבוד - לא מנטרל: כללי רשת אינם מסירים קוד שכבר רץ בשרת, והתוקף יכול לעבור לערוץ אחר.
- להחליף את כל הסיסמאות במערכת - לא פותר: ה-Rootkit אינו מסתמך על סיסמה גנובה אלא יושב בליבה עצמה. את הסיסמאות מחליפים, אך רק בסוף.
- למחוק את הקובץ החשוד שנמצא בסריקה החיצונית ולהחזיר את השרת לשירות - לא מספיק: הקובץ הוא עקבה אחת, המודול כבר נטען לליבה וייתכנו רכיבים נסתרים נוספים.
- להריץ שוב סריקה מלאה מתוך השרת הפועל ולסמוך על תוצאה נקייה - לא אמין: אותה ליבה נגועה יכולה להציג לסורק תשובות מזויפות.
המסקנה: מוציאים את השרת משירות, מתקינים אותו מחדש מתמונה נקייה ומהימנה, משחזרים נתונים רק מגיבוי שנבדק, ורק אחרי שהמערכת נבנתה מחדש מחליפים סיסמאות ומפתחות גישה.
טעויות נפוצות
- אם סריקת אנטי-וירוס מלאה או השוואת Hash בשרת החי יצאו נקיות, השרת בוודאות נקי. בליבה נגועה הנתונים שהסורק מקבל עלולים להיות מזויפים.
- חתימה דיגיטלית על דרייבר מוכיחה שאין בו קוד זדוני. היא מעידה על זהות החותם ועל כך שהקוד לא שונה, בלי לבחון מה הקוד עושה.
- מחיקת קובץ והחלפת סיסמאות מספיקות לניקוי שרת עם Rootkit ליבה. משנשלטה הליבה אי אפשר לבטוח בניקוי מקומי; צריך התקנה מחדש מתמונה אמינה.
- Rootkit ליבה חוסם את הגישה לדיסק, ולכן אי אפשר לסרוק אותו. הוא מסתיר פריטים בתשובות ואינו חוסם את הדיסק; סריקה ממדיה חיצונית עובדת.
בדקו את עצמכם
צוות אבטחה מקבל תוצאה נקייה מסריקה בתוך שרת חי, אך חומת האש מראה ממנו תעבורה חשודה. איזו שיטה תבחרו כדי לברר, ומדוע?
ניתוח צילום זיכרון מבחוץ (Memory Forensics) או הצלבה בין תצוגות, כי הם קוראים מבנים גולמיים ואינם תלויים בתשובות הכוזבות של הליבה.
אומת Rootkit ברמת Kernel בשרת. מה סדר הפעולות הנכון?
התקנה מחדש מתמונה נקייה, שחזור נתונים מגיבוי מאומת, ורק אז החלפת סיסמאות; אם נפגעה הקושחה, גם צריבה מחדש.
Reverse Engineering: הנדסה לאחור
ניתוח סטטי מול ניתוח דינמי
נניח שהגיע אליכם קובץ הרצה בלי קוד מקור, ועליכם לדעת מה הוא עושה. זו משימה של Reverse Engineering (הנדסה לאחור): בחינת תוכנה מקומפלת, רכיב חומרה או פרוטוקול תקשורת כדי להבין איך הם פועלים מבפנים. משתמשים בה כדי לחקור נוזקות, לחשוף חולשות, להבטיח תאימות בין מערכות ולאמת התנהגות של רכיבים.
שימו לב לתכלית: ההנדסה לאחור נועדה להבין ולנתח, לא לנצל. ניצול בפועל הוא עבודתו של Exploit, ו-RE רק מספק את התמונה של המבנה ושל הלוגיקה.
להבנה כזו יש שתי דרכים משלימות, והשאלה היחידה שמפרידה ביניהן היא האם הקובץ מורץ:
| מאפיין | ניתוח סטטי (Static Analysis) | ניתוח דינמי (Dynamic Analysis) |
|---|---|---|
| הרצת הקובץ | הקובץ נבחן במנוחה, בלי להריץ אותו כלל | הקובץ מופעל בפועל בסביבה מבוקרת |
| שיטות וכלים | קריאת מחרוזות (strings), רשימת פונקציות מיובאות (imports), פירוק לאסמבלי ושחזור קוד דמוי C | מכונה וירטואלית מבודדת (Sandbox) ודיבאגר (gdb, x64dbg) למעקב אחרי קבצים, Registry ורשת |
| יתרון בולט | מבט בטוח על מבנה הקוד הנראה בקובץ, בלי סיכון הפעלה | חשיפת קוד והתנהגות שמופיעים רק בריצה, למשל אחרי פריסת כיווץ או פענוח הצפנה |
שתי הדרכים פועלות על קוד שכבר קומפל, ובשתיהן יש מקום גם לכלים אוטומטיים וגם לשיקול דעת של חוקר. כששתיהן משולבות מתגלות התנהגויות סמויות שכל אחת לבדה עלולה לפספס.
טעויות נפוצות
- הניתוח הסטטי מקדים את בניית התוכנה והדינמי בא אחרי הבנייה. שתיהן בוחנות קובץ בינארי שכבר קומפל ואין לו קוד מקור.
- ניתוח דינמי שייך רק לשפות דינמיות כמו Python. המונח מתאר בדיקה בזמן ריצה ואינו קשור לסוג שפת התכנות.
- ניתוח סטטי הוא עבודה אנושית בלבד, ודינמי הוא עבודה של כלים בלבד. ההבדל הוא האם הקובץ רץ; בשתי הגישות משלבים כלים וחוקרים.
בדקו את עצמכם
אנליסט אחד קורא את רשימת הפונקציות שקובץ מייבא, ושני מפעיל אותו ומתעד פעילות רשת. איזה ניתוח עושה כל אחד, ומה ההבדל ביניהם?
הראשון עושה ניתוח סטטי והשני דינמי; ההבדל הוא האם הקובץ מורץ בפועל.
קובץ מכווץ מפרק את עצמו רק בזמן ריצה. מדוע ניתוח סטטי לבדו עלול לפספס, ומה משלים אותו?
הקוד האמיתי אינו גלוי בקובץ במנוחה; ניתוח דינמי חושף אותו אחרי הפריסה ומראה פעולות ממשיות מול קבצים, Registry ורשת.
כלי ניתוח: Ghidra, IDA Pro, Radare2 וקובצי Symbol
בבינארי נמצאים רק בתים של קוד מכונה, ובני אדם אינם קוראים אותם בקלות. כדי לגשר על הפער משתמשים בכלי ניתוח סטטי כמו Ghidra, IDA Pro ו-Radare2, שהאחרון בהם יודע גם לדבג בזמן הרצה. הם עובדים בשני שלבים:
- Disassembler: הופך את הבתים להוראות Assembly ומארגן אותן לפונקציות ולזרימת בקרה.
- Decompiler: מייצר מהאסמבלי קוד שדומה לשפת C, וגם תרשימי זרימה, כדי שיהיה קל לעקוב אחרי ההיגיון.
אבל מה ש-Decompiler מציג הוא קירוב בלבד, לא המקור. הערות המתכנת לא נכנסות כלל לקובץ המקומפל. בקוד native (שנכתב ב-C או ב-C++) שמות של משתנים מקומיים אינם נשמרים אלא אם צורף מידע דיבאג, ושמות של פונקציות נשארים בבינארי רגיל אך נעלמים או הופכים לשמות גנריים אחרי הסרת הסמלים (strip).
גם תפקיד הכלים צריך להיות ברור: כדי לקמפל קוד מקור צריך מהדר, כדי להחליף קושחה בשבב צריך כלי צריבה, וכדי להצפין קבצים צריך כלי הצפנה. Ghidra ו-IDA אינם עושים אף אחד מאלה, ואינם דוחסים קובצי הרצה; הם מפרקים בינארי קיים בלבד.
בשפות מנוהלות המצב שונה. ה-Bytecode של Java וה-IL של .NET נושאים איתם את שמות המחלקות והמתודות, ולכן JD-GUI (ל-Java) ו-dnSpy (ל-.NET) מחזירים קוד קרוב מאוד למקור. זה נכון כל עוד המפתח לא הפעיל Obfuscation, כלומר ערפול מכוון שנועד להפוך את הקוד לקשה לקריאה.
קובצי Symbol הם מעין מילון שמחזיר את השמות: הם מכילים שמות של פונקציות, משתנים ומבני נתונים שאבדו בקימפול, וכך מקצרים את הניתוח ומכוונים במהירות לפונקציות רגישות ולמוקדי חולשה. הם אינם מאמתים חתימה דיגיטלית ואינם מכילים קוד מקור מלא.
עוד אזהרה: קובץ Symbol שימושי רק כשהוא תואם בדיוק לבילד ולמהדר שיצרו את הבינארי, והוא אינו מבטיח שהקוד יישאר תואם לגרסה עדכנית של מהדר. סמלים שנוצרו בבילד אחד לא יתאימו בהכרח לקובץ שנבנה אחרת.
טעויות נפוצות
- Ghidra ו-Radare2 מחזירים את קוד המקור המקורי עם ההערות ושמות המשתנים. ההערות אינן בקובץ המקומפל, ובקוד native שמות מקומיים אובדים ללא מידע דיבאג; מתקבל קירוב דמוי C.
- קובצי Symbol מאמתים חתימה דיגיטלית, מכילים קוד מקור מלא או מבטיחים תאימות למהדר חדש. הם מכילים רק שמות ומבנים ומתאימים לבילד המדויק שיצר אותם; אין להם קשר לחתימות, לקוד מקור מלא או לתאימות למהדר.
- IDA Pro מקמפל קוד או דוחס קובצי הרצה. הוא עושה את ההפך ממהדר ומפרק בינארי קיים לצורכי ניתוח; דחיסה שייכת ל-Packers, הם דחיסה או הצפנה של קוד שנפתחים בזמן ריצה.
בדקו את עצמכם
בפלט של כלי ניתוח מופיעה פונקציה בשם גנרי וקוד דמוי C. איזה שלב יצר את הקוד הדמוי C, ומה הוא מייצג?
ה-Decompiler יצר אותו מתוך האסמבלי שהפיק ה-Disassembler; זה קירוב ולא המקור.
מה הערך של קובץ Symbol שנמצא ליד בינארי, ומה אין להניח עליו?
הוא מספק שמות של פונקציות, משתנים ומבנים ומאיץ את ההבנה; אין להניח שהוא מאמת חתימה, מכיל קוד מקור מלא או מבטיח תאימות למהדר.
סביבת Sandbox, טכניקות Anti-Debugging ו-Breakpoints
לפני שמריצים קובץ חשוד זכרו שהוא עלול למחוק מידע, להצפין אותו או להתפשט ברשת, בדיוק כמו ניסוי מעבדה בחומר מסוכן. לכן הרצה דינמית נעשית אך ורק בתוך מכונה וירטואלית מבודדת (Sandbox / סביבת מעבדה) שמנותקת מהרשת הארגונית, ולפני ההרצה נשמר לה Snapshot נקי שאפשר לחזור אליו.
שני דברים כדאי לזכור על הבידוד: הוא מגביל את הנזק ומגן על תחנת העבודה ועל הרשת, אך אינו הופך את הנוזקה לבטוחה. בנוסף, נוזקות מסוימות משתמשות ב-Anti-VM כדי לבדוק אם הן רצות בסביבה וירטואלית ולהתנהג אחרת.
טכניקה קרובה אך שונה היא Anti-Debugging: הנוזקה בודקת אם Debugger מחובר אליה, למשל לפי דגלים בתהליך או מדידת זמני ריצה, ועוצרת או מטעה אם כן. ההבדל מ-Anti-VM הוא מה נבדק: נוכחות של מנפה שגיאות, לא של המכונה. בניפוי מציבים נקודות עצירה (Breakpoints) משני סוגים:
| סוג Breakpoint | מנגנון הפעולה | יתרונות ומגבלות |
|---|---|---|
| Software Breakpoint | הבית הראשון של ההוראה בזיכרון מוחלף בבייט 0xCC (INT3) | אפשר להציב כמה שרוצים, אבל הזיכרון משתנה, ולכן נוזקה שבודקת את הקוד של עצמה עלולה להבחין |
| Hardware Breakpoint | נשען על רגיסטרים מיוחדים של המעבד לניפוי שגיאות (DR0 עד DR3 ב-x86) | עוצר בקריאה, בכתיבה או בהרצה של כתובת בלי לשנות את הקוד, אך מוגבל למספר הרגיסטרים. הוא אינו משחזר קוד מקור ואינו יוצר בידוד |
תרחיש 6: קובץ חשוד שהגיע בדוא״ל מחלקת החשבונות
מחלקת החשבונות מעבירה לצוות האבטחה קובץ בשם invoice_viewer.exe שנשלח מכתובת לא מוכרת. עובד מציע להריץ אותו מהר במחשב הבדיקות המחובר לרשת, כי מותקן בו אנטי-וירוס מעודכן. הצוות דוחה זאת, כי אנטי-וירוס אינו עוצר נזק מהרצת נוזקה, ופועל כך:
- מקים מכונה וירטואלית ללא חיבור לרשת הארגונית ושומר לה Snapshot נקי.
- לפני ההרצה בוחן את הקובץ סטטית ב-Radare2 או ב-IDA Pro: מחרוזות, פונקציות מיובאות ומבנה כללי, כדי לדעת למה לצפות.
- מריץ אותו במכונה ומנטר קבצים, Registry ותקשורת. אם הדגימה מסרבת לפעול בכלל, חושדים ב-Anti-VM; אם היא נעצרת רק תחת Debugger, זה Anti-Debugging.
- כשהדגימה בודקת שינויים בקוד של עצמה, עוברים מ-Software Breakpoints ל-Hardware Breakpoints, שאינם משנים את הזיכרון.
- בסיום משחזר את המכונה ל-Snapshot הנקי.
טעויות נפוצות
- Anti-Debugging בודק אם הקובץ רץ במכונה וירטואלית. זיהוי מכונה וירטואלית נקרא Anti-VM; Anti-Debugging מזהה הרצה תחת Debugger.
- Hardware Breakpoints משנים קוד באמצעות
INT3, משחזרים קוד מקור או יוצרים סביבה מבודדת.INT3(0xCC) שייך ל-Software Breakpoints; חומרה אינה משנה קוד, אינה משחזרת מקור ואינה מבודדת, ובידוד מספקת מכונה וירטואלית. - הרצה ב-Sandbox הופכת נוזקה לבלתי מזיקה. הנוזקה נשארת מסוכנת, והבידוד רק תוחם את הנזק למכונה הווירטואלית.
- מחשב העבודה או שרת בדיקות עם אנטי-וירוס מעודכן מתאימים להרצת קובץ חשוד. אנטי-וירוס אינו מבטיח עצירת נזק; צריך מכונה מבודדת עם Snapshot לשחזור.
בדקו את עצמכם
אנליסט מציע להריץ דגימה במכונה וירטואלית שמחוברת לרשת הארגונית וללא Snapshot. מה הבעיה?
אין בידוד, ולכן הנזק יכול להגיע לרשת, ואין דרך לחזור במהירות למצב נקי.
נוזקה בודקת אם הקוד שלה שונה בזיכרון. איזה סוג Breakpoint מתאים לכם, ולמה?
Hardware Breakpoint, כי הוא פועל דרך רגיסטרי המעבד בלי לשנות את הקוד, ולכן קשה יותר לנוזקה לגלות אותו.
מושגים משלימים: Obfuscation, Patch Diffing ו-Fuzzing
Code Obfuscation (ערפול קוד) הוא טשטוש מכוון של התוכנה: משנים שמות פנימיים, מסדרים מחדש את הפקודות ומוסיפים קוד מיותר. התוצאה מקשה על Disassemblers ו-Decompilers להציג זרימה ברורה, ומפחיתה זיהוי שמבוסס על חתימות סטטיות.
אל תייחסו לערפול כוחות שאין לו. הוא לא משפר ביצועים (בדרך כלל הקוד גדל ורץ לאט יותר), לא מעלה הרשאות, לא עוקף בדיקות הרשאה של מערכת ההפעלה ולא מעביר קוד לריצה ב-Kernel. לצידו עומדים Packers, שדוחסים או מצפינים את הקוד ופותחים אותו בזמן ריצה, ו-Anti-Debugging; שלושתם מכשולים שהחוקר צריך להתמודד איתם.
נניח שיצרן פרסם עדכון אבטחה לשירות דואר. חוקר שומר את הגרסה הישנה ואת החדשה, טוען את שתיהן ל-Ghidra או ל-IDA ומשווה פונקציה אחר פונקציה, ומגלה שבגרסה החדשה נוספה בדיקת אורך לפני פעולת ההעתקה. זה Patch Diffing: השוואה בינארית שחושפת בדיוק איזו חולשה תוקנה, ומסבירה למה מערכות שלא עודכנו נשארות חשופות.
השוואת Hash תאמר רק שהקובץ שונה, והערת יצרן מילולית תתאר את התיקון במילים בלבד. רק ההשוואה הבינארית מראה את השינוי עצמו.
Fuzzing שונה במהותו: במקום להשוות גרסאות, מזינים לתוכנה כמויות גדולות של קלטים אקראיים או מעוותים ומחפשים קריסות, שמסמנות באגים שעדיין לא ידועים.
נחבר הכול לחיפוש חולשת Buffer Overflow. השלב הסטטי סורק את הקוד אחר קריאות כמו sprintf או strcpy, שמעתיקות בלי להגביל אורך, ומסמן אותן כחשודות, אך אינו מוכיח שאפשר לנצל אותן. כדי לאשר, מריצים תחת Debugger קלט ארוך מהצפוי וצופים אם הזיכרון אכן נדרס.
טעויות נפוצות
- Code Obfuscation מאיץ את התוכנה ומעניק לה הרשאות מנהל. הערפול רק מסבך את הקריאה ואת הזיהוי הסטטי; לרוב הוא מאט את הקוד ואינו משפיע על הרשאות.
- Patch Diffing הוא בדיקת Hash של קובצי ההפצה. Hash מראה רק אם הקובץ השתנה; Patch Diffing משווה פונקציות בינאריות כדי לגלות מה תוקן.
- ניתוח סטטי לבדו מוכיח שפגיעות Buffer Overflow ניתנת לניצול. הוא מסמן מקומות חשודים; הוכחה בפועל דורשת הרצה בניתוח דינמי.
בדקו את עצמכם
יש בידיכם את הקובץ לפני עדכון ואחריו. מה תראו בהשוואת Hash, ומה בהשוואה בינארית?
Hash יראה רק שהקבצים שונים; ההשוואה הבינארית תראה אילו פונקציות ולוגיקה השתנו, ובכך תסביר איזו חולשה נסגרה.
כלי סטטי סימן שימוש ב-strcpy בפונקציה. האם זה מוכיח חולשה שניתנת לניצול, ומה השלב הבא?
לא; זה רק סימון חשד. השלב הבא הוא ניתוח דינמי: הרצה תחת Debugger עם קלט ארוך ובדיקה אם מתרחשת דריסה.
סיכום
סיימנו את ההיכרות עם ששת הצירים המרכזיים של הנושא מזווית המגן והמבחן:
- Shell: מפרש פקודות שרץ בהרשאות התהליך שנפרץ בלבד, לא
rootאוטומטית. ב-Reverse Shell הקורבן יוזם חיבור יוצא (לרוב בפורטים 80/443), ולכן הוא עוקף חסימות כניסה של פיירוול ושל NAT ומתגלה בניטור תעבורה יוצאת; ב-Bind Shell הקורבן מאזין, הוא נחסם לרוב בפיירוול נכנס או ב-NAT ומתגלה בסריקת פורטים; ב-Web Shell הפקודות מועברות בבקשות HTTP. - Buffer Overflow: כתיבה שחורגת מגבולות מאגר, ודורסת זיכרון סמוך או כתובת חזרה, מה שמוביל לקריסה או להרצת קוד. הסיבה היא פונקציות ללא בדיקת אורך (
gets,strcpy), והמניעה היא בדיקת גבולות ופונקציות בטוחות (fgets,snprintf, ובזכירה ש-strncpyעלולה להשמיט תו סיום). מוסיפים Stack Canary, ASLR (נעקף בדליפת כתובת) ו-NX/DEP (נעקף ב-ROP או ב-Return-to-libc, שעליהם מקשה CFI), ואף הגנה אחת אינה שלמה לבדה. טכניקות מתקדמות כוללות Egg Hunter, Stack Pivoting, SEH, Heap Spraying, Pointer Subterfuge, Polymorphic Shellcode ו-SROP. - Exploit ומחזור התקיפה: מבדילים בין הפגיעות (Vulnerability), דרך הניצול (Exploit) והקוד שרץ אחריה (Payload). סדר התקיפה הוא איסוף מידע, גילוי פגיעות, הרצת Exploit, Payload ופעולות אחרי ההשתלטות (Post Exploitation), ובהן העלאת הרשאות לאחר הכניסה הראשונית. פגיעות Zero-day חסרה תיקון רשמי, ואילו N-day היא פגיעות מוכרת עם CVE ותיקון שמערכות לא עדכנו.
- Metasploit: מסגרת לבדיקות חדירה מורשות המפרידה בין Exploit ל-Payload (כמו Meterpreter שרץ בזיכרון).
RHOSTSמסמן את היעד,LHOSTו-LPORTאת מכונת הבודק,multi/handlerמנהל את החיבור הנכנס, ו-msfvenomמייצר Payloads. - Rootkit: מותקן אחרי ההשתלטות כדי להסתיר נוכחות ולשמר גישה קבועה, באמצעות Hook ב-
syscall_table, ב-libcאו ב-IDT. איתור מהימן של Rootkit ליבה נעשה מבחוץ (אתחול ממדיה נקייה, Memory Forensics, Cross-view), והטיפול האמין היחיד הוא התקנה מחדש מתמונה נקייה. - Reverse Engineering: שילוב של ניתוח סטטי (ללא הרצה, בכלים כמו Ghidra, IDA ו-Radare2 שמפיקים קירוב בלבד, ובסיוע קובצי Symbol) וניתוח דינמי (הרצה ב-Sandbox מבודד עם Snapshot, התמודדות עם Anti-Debugging ושימוש ב-Hardware Breakpoints). מושגים נוספים: Obfuscation (ערפול שמקשה על קריאת הקוד), Patch Diffing (השוואת גרסאות בינאריות) ו-Fuzzing (איתור באגים חדשים בקלטים משובשים).