Security
Web, XSS, LFI RFI, CSRF, SQL
התקפות על אתרים והגנה מפניהן: XSS, LFI ו-RFI, CSRF ו-SQL Injection.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Web, XSS, LFI RFI, CSRF, SQL: חולשות ווב מרכזיות ומנגנוני הגנה
בפרק זה תכירו ארבע משפחות תקיפה מרכזיות בעולם הווב: הזרקת סקריפט (XSS), הזרקת שאילתות (SQL Injection), הכללת קבצים (LFI ו-RFI) וזיוף בקשות (CSRF), לצד הצבת Web Shell בשרת כתוצאה טיפוסית של ניצול מוצלח.
לכל פגיעות נבין מהו שורש הבעיה בקוד, באיזה צד של התקשורת היא פועלת, מה התוקף מסוגל להשיג באמצעותה ומה חורג מיכולתה, ואיזו שכבת הגנה עוצרת אותה באמת. לאורך הפרק נשווה שוב ושוב בין ארבע המתקפות (היכן כל אחת רצה, מה היא מגיעה אליו ומה לא), כי היכולת להבדיל ביניהן היא המיומנות שנבחנת הכי הרבה.
- תשתיות ווב: איך עובדות בקשות
GETו-POST, למה עוגיות מצורפות אוטומטית, ומה מדיניות המקור הזהה (SOP) חוסמת ומה לא. - XSS: ההבדל בין
Stored,Reflected,DOM-Basedו-Blind, מגבלותHttpOnly, וחשיבות קידוד הפלט ו-CSP. - SQL Injection: עקיפת אימות,
UNION SELECT, הזרקה עיוורת, מיפוי סכימה,Second-Order, ושאילתות פרמטריות מול רשימה מותרת. - LFI / RFI ו-Web Shell: מעבר תיקיות (
Path Traversal), הרעלת לוגים,php://filter, התנאי ההכרחי ל-RFI, והגנה בעזרת רשימה סגורה. - CSRF: ניצול הסשן הפעיל בדפדפן, טוקן אקראי, התנהגות
SameSiteוההבדל החד מולXSS.
רקע: איך עובד ווב
בקשה ותגובה, לקוח ושרת
כשאתם פותחים עמוד או שולחים טופס, הדפדפן (הלקוח, שמריץ HTML ו-JavaScript) פונה אל שרת מרוחק שמחזיק את קוד האתר, את קבציו ואת מסד הנתונים. הפנייה היא בקשת HTTP, והתשובה, שמכילה את הדף, היא תגובת HTTP.
בבקשת GET הפרמטרים נראים בשורת הכתובת אחרי הסימן ? (כמו חיפוש בחנות), ולכן אפשר לשמור אותה כקישור ולשלוח אותה הלאה. בבקשת POST הנתונים יושבים בגוף הבקשה ולא בכתובת, והיא נבחרת בדרך כלל לפעולה שמשנה מצב, כמו שליחת הזמנה.
הדפדפן מייצג את הדף בזיכרון כמבנה עץ חי הנקרא DOM (Document Object Model), שדרכו קוד JavaScript קורא אלמנטים ומשנה אותם. כל הפגיעויות בפרק מנצלות בקשות HTTP שגרתיות, אך כל אחת מתממשת בשכבה אחרת:
| חולשה | שכבת ההרצה | הרכיב הנפגע |
|---|---|---|
XSS | צד הלקוח | הדפדפן של הקורבן וה-DOM של הדף |
SQL Injection | צד השרת | מנוע מסד הנתונים והשאילתות |
LFI ו-RFI | צד השרת | מנגנון טעינת והכללת הקבצים |
CSRF | מהדפדפן אל השרת | הסשן של משתמש מחובר באתר היעד |
מדיניות המקור הזהה
דמיינו שאתם מחוברים לאתר הבנק בלשונית אחת, ובלשונית אחרת נפתח דף של אתר זר שמבקש מהדפדפן לפנות אל הבנק. הדפדפן אכן שולח את הפנייה, והעוגייה של הבנק יוצאת איתה (כל עוד SameSite אינו מגביל זאת, כפי שיפורט בהמשך). אבל הסקריפט של הדף הזר אינו מקבל לידיו את התשובה.
הכלל שמסביר זאת הוא מדיניות המקור הזהה (Same Origin Policy, או SOP). מקור (Origin) הוא שלשה של פרוטוקול, שם דומיין ופורט, וסקריפט ממקור אחד אינו קורא תגובות שחוזרות ממקור אחר, ולכן אתר זר אינו רואה לא נתונים פרטיים ולא את הטוקן שבדף הבנק (ערך סודי שאתרים מטמיעים בטפסיהם, וההמשך בפרק על CSRF).
הלקח לבחינה: הכלל נוגע לקריאה בלבד, ולא לשליחה. שתי תופעות נשענות על הפער הזה: CSRF שולח בקשה בלי לראות את התשובה, והגנת הטוקן עובדת משום שהתוקף אינו יכול לקרוא את הטוקן.
טעויות נפוצות
- מדיניות
SOPמונעת מהדפדפן לשלוח בקשה לדומיין אחר. הבקשה נשלחת והעוגיות מצורפות כרגיל;SOPרק מונעת מהדף השולח לקרוא את התשובה. - עוגייה נשלחת רק כשהמשתמש גולש ישירות בלשונית של האתר. כל בקשה אל הדומיין של האתר נושאת את העוגייה שלו, גם כשהיוזם הוא קישור או טופס באתר זר (בכפוף ל-
SameSite). - הדגל
HttpOnlyזהה בתפקידו למאפייןSameSite.HttpOnlyשומר את העוגייה מקודJavaScript, ואילוSameSiteמחליט אם לשלוח אותה בבקשה שיצאה מאתר אחר.
בדקו את עצמכם
משתמש מחובר לחשבון מייל ומבקר באתר חיצוני ששולח בקשה לשרת המייל. האם העוגייה תישלח והאם האתר החיצוני יקרא את המיילים?
העוגייה תישלח אוטומטית עם הבקשה, אך האתר החיצוני לא יוכל לקרוא את התגובה בגלל מדיניות המקור הזהה (SOP).
XSS: הזרקת סקריפט
מה זה XSS ולמה השם הזה
ראשי התיבות XSS מייצגים Cross-Site Scripting: חולשה שבה קלט שמגיע ממשתמש משולב בדף ווב ומורץ בדפדפן של גולשים אחרים כקוד JavaScript לגיטימי.
השם ההיסטורי מתאר קוד שמקורו בצד שלישי אך רץ בתוך ההקשר המאובטח של האתר הפגיע. מאחר שהסקריפט רץ תחת אותו Origin, הדפדפן מעניק לו גישה מלאה למבנה הדף.
הרצת קוד בדפדפן אינה תלויה רק בתגית script. גם מאפייני אירוע (event handlers) בתגיות רגילות, כמו onerror על תגית תמונה או onmouseover על שדה קלט, מריצים JavaScript בלי להזדקק לתגית script כלל.
טעויות נפוצות
- הקיצור
XSSמתייחס לשפת העיצובCascading Style Sheets. שפת העיצוב היאCSS; הסימןXב-XSSהוחלף במקוםCכדי למנוע בלבול. - סינון שמסיר את המילה
scriptפותר לחלוטין את בעיית ה-XSS. ניתן להפעיל קוד דרך מאפייני אירועים כמוonerrorאוonloadבתגיות אחרות לחלוטין.
Stored XSS
ב-Stored XSS (המכונה גם Persistent XSS), הקלט המסוכן נשמר בצד השרת, למשל בטבלת תגובות, בפרופיל משתמש או בהודעה במערכת.
בכל פעם שמשתמש אחר טוען את הדף, השרת (או בקשת Ajax, כלומר בקשה ש-JavaScript שולח לשרת כדי להביא נתונים בלי לרענן את הדף) מגיש את התוכן השמור ללא קידוד, והדפדפן מריץ את הסקריפט.
זה הסוג המסוכן ביותר מכמה סיבות. התוקף לא צריך לשכנע אף אחד ללחוץ על משהו, וגם לא הרשאות מנהל, כי מספיק שדה ציבורי שכל אחד רשאי לכתוב בו. SOP אינה מפריעה, כי הקוד מגיע מהאתר עצמו.
תרחיש 1: תגובה שמורה בלוח מודעות
משתמש מפרסם תגובה שמכילה תגית תמונה עם כתובת שבורה ומאפיין onerror. האתר שומר את המחרוזת במסד ומציג אותה לכל מבקר בדיון בלי המרה לישויות HTML.
בדפדפן של כל קורא, טעינת התמונה נכשלת ומטפל ה-onerror מופעל מיד. הארכת או קיצור התגובה, או שימוש ב-HTTPS, אינם מונעים זאת; התיקון המרכזי והנכון הוא קידוד הפלט בעת ההצגה.
בדקו את עצמכם
קורא נכנס לדיון רגיל ולא לוחץ על שום דבר חשוד, ובכל זאת הסקריפט רץ אצלו. מה מסביר זאת?
הקוד כבר יושב בתוכן ששמור באתר, ולכן הוא חלק מהדף שהשרת מגיש לקורא. מבחינת הדפדפן זה קוד רגיל של האתר, ומספיק שהצופה גולש כרגיל.
Reflected XSS
בסוג זה המתקפה מתבצעת בבקשה בודדת: הקורבן נדרש ליזום את הבקשה בעצמו, לרוב על ידי פתיחת קישור שהכין התוקף ומכיל קלט זדוני בתוך פרמטר בכתובת. השרת משקף את הערך מיד בתוך תגובת ה-HTTP ללא קידוד, בלי לשמור אותו במסד הנתונים או בקובץ.
מאחר שאין שמירה מתמשכת בצד השרת, הפגיעה מוגבלת רק למי שלחץ על הקישור או שלח את הבקשה המותאמת. מצד שני, התוקף אינו זקוק לגישה לשרת, לשינוי קוד האפליקציה, להרשאות ניהול או ליכולת כתיבה למסד.
תרחיש 2: הודעת שגיאה המשקפת פרמטר מהכתובת
קורא מקבל בהודעה קישור לדף תמיכה ופותח אותו. בראש הדף מופיעה הודעת שגיאה שנבנית מהפרמטר err שבכתובת, והכתובת נוסחה מראש בידי תוקף, כך שהשרת מדפיס את הערך כמות שהוא.
כך הקוד שבפרמטר נטען כחלק מהדף ורץ בהרשאות של האתר, אבל רק אצל מי שפתח את הקישור הזה. התוקף לא נגע בשרת או בקוד האפליקציה, וגולשים אחרים אינם מושפעים כלל.
טעויות נפוצות
Reflected XSSנשמר בשרת ונמחק אחרי שהמשתמש סוגר את הדף. הוא אינו נשמר בשרת כלל, אלא משוקף באופן מיידי באותה תגובה בודדת.
DOM-Based XSS
ב-DOM-Based XSS, השרת כלל אינו מחזיר את הקוד הזדוני בתגובת ה-HTTP. התקלה נמצאת בקוד ה-JavaScript שכבר רץ בדפדפן.
הסקריפט קורא נתון שהתוקף שולט בו, כגון location.search או location.hash (החלק שאחרי #), וכותב אותו לדף דרך פונקציות שמפרשות HTML כמו innerHTML, outerHTML או document.write.
פרט קריטי למבחן: החלק שאחרי התו # (location.hash) אינו נשלח לשרת בבקשת ה-HTTP. לכן בדיקות או סינון בצד השרת לא יראו אותו לעולם.
// Vulnerable: interprets input as HTML
document.getElementById('greeting').innerHTML = location.hash.substring(1);
// Safe: treats input strictly as plain text
document.getElementById('greeting').textContent = location.hash.substring(1);| סוג XSS | היכן נשמר או נכנס | מעורבות השרת | מי נפגע |
|---|---|---|---|
Stored | נשמר בשרת (מסד נתונים / קובץ) | שומר ומגיש לכולם | כל גולש שצופה בדף |
Reflected | בבקשה, מוחזר מיד בתגובה | מחזיר בתגובה מיידית | רק מי שפותח את הקישור |
DOM-Based | נכתב לדף על ידי JS בדפדפן | ללא מעורבות בהזרקה | רק מי שפותח את הקישור |
טעויות נפוצות
- החלפת
innerHTMLב-outerHTMLפותרתDOM-Based XSS. גםouterHTMLוגםdocument.writeמפרשים מחרוזות כ-HTML; יש להשתמש ב-textContent. - בדיקת ערך ה-
location.hashבצד השרת חוסמתDOM-Based XSS. הדפדפן אינו שולח לשרת את מקטע ה-#, ולכן השרת אינו חשוף אליו כלל.
Blind XSS
Blind XSS הוא מקרה פרטי של Stored XSS שבו התוקף אינו רואה מיד את פלט ההזרקה בדף שלו.
התוקף משתיל את הקלט בשדה שמוצג רק בצד הניהול, כמו הערת הזמנה, נושא פנייה או רשומת יומן של כניסה כושלת, וממתין שגורם פנימי כמו אדמין יפתח את המסך שמציג אותו.
ההשתלה נעשית בטופס ציבורי והביצוע במסך ניהול פנימי, בדפדפן של אחר ובשעה אחרת. לכן התוקף אינו חווה את התוצאה בעצמו, ומכאן הכינוי "עיוור".
בדקו את עצמכם
מה מבדיל בין Blind XSS לבין Reflected XSS מבחינת בדיקת ההצלחה?
ב-Reflected המטען חוזר מיד באותה תגובה, ואילו ב-Blind התוקף מזין מראש לשדה פנימי ואינו רואה את הריצה המתרחשת מאוחר יותר אצל מנהל או תומך.
מה תוקף משיג ומה לא
מאחר שהסקריפט רץ בדפדפן של הקורבן בהקשר האתר, התוקף מסוגל לשנות את תצוגת הדף, להאזין להקשות מקלדת, לקרוא מידע רגיש מהדף, ולגנוב עוגיות סשן אם אין להן דגל HttpOnly.
בנוסף, הסקריפט יכול לשלוח בקשות HTTP בשם המשתמש המחובר. גם כשהעוגייה מסומנת HttpOnly, הדפדפן מצרף אותה אוטומטית לבקשות שיוצאות מהסקריפט, ולכן HttpOnly מצמצם גניבת עוגייה אך אינו מונע פעולות בשם המשתמש.
הגבול ברור: הסקריפט פועל בתוך הדפדפן של הקורבן ובשם האתר בלבד, ומשם אין דרך ישירה אל המכונה שמריצה את האתר. לכן XSS לבדו אינו נותן הרצת פקודות בשרת (RCE), אינו קורא את טבלאות המסד (זה ייעודה של SQL Injection) ואינו משנה את הגדרות האבטחה של השרת.
הגנה: קידוד פלט, CSP, HttpOnly
קו ההגנה המרכזי מפני XSS הוא קידוד פלט לפי ההקשר (Context-Aware Output Encoding): לפני הצגת קלט בדף, ממירים תווים מיוחדים (<, >, ", ', &) לישויות HTML כך שהדפדפן יציג אותם כטקסט.
import html
user_input = 'Maya <team> & "lead"'
encoded = html.escape(user_input, quote=True)
print("Raw input:", user_input)
print("Encoded: ", encoded)Raw input: Maya <team> & "lead"
Encoded: Maya <team> & "lead"ההתאמה להקשר קריטית: כאשר קלט משובץ בתוך ערך של מאפיין (למשל value של שדה קלט), סינון של < ו-> בלבד אינו מספיק. תוקף יכול לסגור את הערך בעזרת מרכאה ולהוסיף מאפיין אירוע כמו onmouseover בלי להשתמש בסוגריים זוויתיים כלל.
- צד לקוח בטוח: העדפת
textContentעל פניinnerHTML,outerHTMLו-document.write. Content Security Policy(CSP): כותרת תגובה שבה השרת מורה לדפדפן מאילו מקורות הוא מוכן להריץ סקריפטים בדף. היא פועלת בדפדפן ומגבילה הרצה; היא אינה מסנן קלט בשרת, ואינהCORS, שמסדיר אילו אתרים רשאים לקרוא ממנו נתונים.HttpOnlyעל עוגיית הסשן: מונע גישה מ-document.cookie, מקטין נזק אך אינו מונעXSS.iframeעםsandboxבליallow-same-origin: התוכן שבתוכו נחשב למקור נפרד, ולכן אינו נוגע בעץ ה-DOMובחלון של הדף המארח. זהו צמצום נזק ולא תיקון של החולשה.- אימות קלט ותבניות עם קידוד אוטומטי: בדיקת תקינות הקלט בכניסה ושימוש במסגרות פיתוח הממירות פלט לישויות בטוחות כברירת מחדל.
טעויות נפוצות
- שמירת הקלט בקידוד
Base64או הגבלת אורכו מונעותXSS.Base64מפוענח חזרה בעת ההצגה, והגבלת אורך אינה עוצרת מטענים קצרים המבוססים על מטפלי אירועים. CSPמסנן תווים מסוכנים לפני שמירתם במסד הנתונים.CSPפועל בדפדפן ומגביל מקורות סקריפט מאושרים; הוא אינו מסנן קלט בשרת.
בדקו את עצמכם
רכיב בדף כותב שם של גולש מתשובת JSON אל innerHTML. איזה שינוי קוד מתקן את החולשה?
לעבור משימוש ב-innerHTML ל-textContent כדי שהדפדפן יציג טקסט גולמי ולא יפענח תגיות.
SQL Injection
מה זה ומה הסיכון
SQL היא שפת השאילתות לתקשורת מול מסדי נתונים (למשל פקודת SELECT לשליפת רשומות לפי תנאי WHERE). פגיעות SQL Injection מתרחשת כשהאפליקציה בונה שאילתה על ידי שרשור ישיר של קלט המשתמש לתוך פקודת ה-SQL.
במצב זה מסד הנתונים אינו מפריד בין הפקודה לנתונים, והקלט עלול לשנות את מבנה השאילתה. התוקף עלול לקרוא מידע רגיש, לשנות רשומות או למחוק טבלאות בהתאם להרשאות חשבון המסד, ולעיתים אף להריץ פקודות על שרת המסד.
חשוב למקם את הנזק בשכבה הנכונה: הזרקת SQL פוגעת במנוע מסד הנתונים שבשרת, ואינה מתקפת דפדפן. אין בה זיוף בקשה בשם הגולש (CSRF) או חטיפת עוגיות (XSS), והיא אינה מוחקת קבצים במחשבו. גם שכבת התעבורה אינה נפגעת: תעודת ה-HTTPS וכתובת ה-IP של השרת נשארות כפי שהיו.
עקיפת התחברות
בטופס כניסה פשוט, קוד השרת מדביק את שם המשתמש ואת הסיסמה לתוך תבנית של שאילתת SELECT, כל ערך בין גרשיים בודדים. הדוגמה הבאה בונה את טקסט השאילתה, קודם עם ערכים רגילים ואחר כך עם שם שמכיל גרש:
def build_login_query(username, password):
# Vulnerable: both values are glued straight into the SQL text
return "SELECT id FROM users WHERE name = '" + username + "' AND pass = '" + password + "'"
print(build_login_query("dana", "blue42"))
print(build_login_query("o'neil", "blue42"))SELECT id FROM users WHERE name = 'dana' AND pass = 'blue42'
SELECT id FROM users WHERE name = 'o'neil' AND pass = 'blue42'בשורה השנייה הגרש חותך את המחרוזת באמצע והטקסט אינו תקין, וזה מראה שהקלט שולט בצורת השאילתה. תוקף מנוסה אינו שובר את המבנה אלא משלים אותו: הוא סוגר את המחרוזת, מוסיף תנאי שמתקיים תמיד ופותח הערה, והערה זו בולעת את שארית השורה, כולל בדיקת הסיסמה והגרש הסוגר המקורי.
מה שנשאר הוא שאילתה תקינה לגמרי שבה הסיסמה אינה חלק מהתנאי. המנוע מריץ אותה כרגיל ומחזיר שורה, כי מבחינתו אין הבדל בין טקסט שהמתכנת כתב לטקסט שהגיע מהמשתמש.
סימן ההערה נכתב אחרת בכל מנוע: ב-MySQL צריך רווח אחרי -- (או להשתמש ב-#), ואילו ב-SQL Server וב-PostgreSQL הרווח אינו נדרש.
תרחיש 3: כניסה כמשתמש ספציפי ללא סיסמה
תוקף מזין בשדה שם המשתמש את שם המשתמש המבוקש, אחריו מרכאה סוגרת וסימן הערה תקף למסד, ובשדה הסיסמה ערך אקראי.
בשאילתת שרשור מחרוזות, התנאי על הסיסמה מתבטל בתוך ההערה והשאילתה מחפשת רק לפי השם. רק שאילתה פרמטרית מתייחסת לכל הקלט כמחרוזת שם אחת ומכשילה את הכניסה.
טעויות נפוצות
- אם הכניסה הצליחה בלי הסיסמה הנכונה, השאילתה בטח נכשלה בשגיאת תחביר והמסד זיהה ניסיון תקיפה. ההערה מאזנת את מבנה השאילתה, ולכן אין שגיאה. המסד אינו בוחן כוונות: כל טקסט תקין מבחינת התחביר מורץ.
UNION SELECT
הטכניקה UNION SELECT מאפשרת להדביק שאילתת SELECT משנית אל השאילתה הקיימת, במטרה להציג באותו פלט גם רשומות מטבלאות אחרות (למשל פרטי חשבונות).
כדי שמנוע ה-SQL ימזג את פלט שתי השאילתות לטבלה מאוחדת אחת, כל עמודה בשאילתה המצורפת חייבת להתאים בעמדתה ובטיפוסה לעמודות השאילתה המקורית, ובאותה כמות בדיוק.
מיקום הקלט מסביר את המגבלות. בשאילתה כמו SELECT title, cost FROM items WHERE kind = '...' שם הטבלה כבר נקבע לפני שהקלט מגיע, כי הקלט יושב בתנאי ה-WHERE; לכן הטבלה המקורית נשארת, והערה לבדה רק קוצצת את שארית השאילתה בלי להוסיף טבלה. וכל זה מתרחש בשרת: JavaScript שבדפדפן אינו פונה למסד ישירות.
בדקו את עצמכם
מדוע שאילתת UNION SELECT תיכשל אם ננסה לשלוף בה עמודה בודדת מתוך טבלה, כשהשאילתה המקורית מחזירה שלוש עמודות?
משום שמנוע המסד דורש שטבלאות התוצאה הממוזגות יכילו כמות זהה של עמודות וטיפוסים תואמים בכל עמודה.
הזרקה עיוורת
בהזרקה עיוורת (Blind SQL Injection), האתר אינו מחזיר פלט ישיר מהשאילתה ואינו מציג הודעות שגיאה של המסד.
התוקף מסיק מידע בעקיפין בשתי שיטות: הזרקה בוליאנית (בדיקת הבדל בתגובת הדף בין תנאי אמת לתנאי שקר) או הזרקה מבוססת זמן (מדידת השהיה מכוונת בתגובת השרת). כבר הבדל יציב בין שני המצבים מוכיח שהקלט משתתף בשאילתה, וממנו אפשר לדלות מידע בהדרגה.
שתי הבהרות מונעות בלבול. זו אינה התקפת עומס (Denial of Service), כי המטרה היא מידע ולא השבתה, וזו גם אינה הזרקה מבוססת שגיאות (Error-based), שבה המידע נקרא מהודעות השגיאה שמופיעות בפלט. והסתרת הודעות שגיאה, חשובה ככל שתהיה נגד דליפה, אינה מתקנת את ההזרקה העיוורת.
מיפוי הסכימה
תוקף שהגיע לשדה פגיע מול טבלה שאת העמודות שלה אינו מכיר ניצב בפני בעיה: אי אפשר לבקש נתונים מטבלה בלי לנקוב בשמה ובשמות העמודות הרצויות. לכן הצעד הראשון הוא מיפוי סכימה (Schema Enumeration): שאילתה, בדרך כלל, על טבלת המערכת information_schema.columns (במנועים רבים), שמפרטת את העמודות של כל הטבלאות במסד.
אין צורך בפרטי כניסה נפרדים למסד, כי השאילתות רצות בחיבור שהאפליקציה עצמה כבר פתחה. גם שני דברים אחרים אינם הכרחיים: אפשר לבקש רק חלק מעמודות הטבלה, וגרסת המסד רק עוזרת לבחור תחביר מתאים בלי לגלות היכן המידע נמצא.
בדקו את עצמכם
תוקף יודע שהמסד הוא MySQL בגרסה מסוימת. מדוע זה עדיין לא מספיק כדי לשלוף נתונים מטבלת לקוחות?
הגרסה קובעת רק איך לכתוב את התחביר. כדי לשלוף צריך את שם הטבלה ואת שמות העמודות, ואותם מגלים בשאילתה על הסכימה.
Second-Order
דמיינו אתר עם הרשמה. נרשם משתמש ששמו מכיל תו מיוחד של SQL. שאילתת ההכנסה פרמטרית, ולכן השם נשמר כמות שהוא ושום דבר אינו קורה: בשלב הזה הוא נתון תקין לכאורה בטבלה.
מאוחר יותר המשתמש מבקש להחליף סיסמה. הקוד שולף את שמו מהטבלה ומשרשר אותו לשאילתת עדכון, מתוך הנחה שמה שבא מהמסד נקי. רק כאן התו משנה את מבנה השאילתה, וזו ההזרקה עצמה.
המסקנה: הגנה על שאילתת ההכנסה אינה מספיקה. כל שאילתה שמקבלת ערך, גם ערך שנשלף מהמסד עצמו, צריכה לקבל אותו כפרמטר. כדי לא לבלבל בין הסוגים, כדאי להשוות אותם לפי השאלה מתי ואיפה הנזק מתרחש:
| סוג | מתי הנזק מתרחש | איפה | מה מאפיין אותו |
|---|---|---|---|
| הזרקה רגילה | מיד עם שליחת הקלט | שאילתה במסד | התגובה משתנה מיד |
Blind | מיד עם שליחת הקלט | שאילתה במסד | אין תוצאה על המסך, ולכן לומדים מהבדלי תגובה או מהשהיה |
Second-Order | רק בשימוש מאוחר בנתון השמור | שאילתה אחרת במסד | הקלט נשמר תחילה כרגיל |
Stored XSS | כשצופה פותח את הדף | דפדפן של צופה אחר, לא המסד | התוכן השמור רץ כסקריפט |
טעויות נפוצות
- אם טופס ההרשמה משתמש בשאילתה פרמטרית, הנתון שנשמר במסד בטוח לשרשור עתידי. התו השמור עלול לשבור שאילתה עתידית אם היא תבנה אותו בשרשור מחרוזות (
Second-Order).
הגנה: שאילתות פרמטריות ורשימה מותרת
ההגנה היעילה ביותר היא שאילתות פרמטריות (Prepared Statements / Parameterized Queries). תבנית השאילתה נקבעת מראש עם מצייני מקום (? או :name), והערכים נקשרים בנפרד ונשארים תמיד בגדר נתונים. עיקרון זה תקף לכל סוגי השאילתות, כולל SELECT, ומצייני מקום בשם (כגון :city) שקולים לחלוטין למצייני מקום לפי מיקום (?).
import sqlite3
conn = sqlite3.connect(":memory:")
cur = conn.cursor()
cur.execute("CREATE TABLE accounts (id INTEGER PRIMARY KEY, username TEXT, role TEXT)")
cur.execute("INSERT INTO accounts (username, role) VALUES (?, ?)", ("dana", "member"))
cur.execute("INSERT INTO accounts (username, role) VALUES (?, ?)", ("o'connor", "guest"))
# Input with an apostrophe is treated strictly as data
search_name = "o'connor"
cur.execute("SELECT id, username, role FROM accounts WHERE username = ?", (search_name,))
print("Parameterized result:", cur.fetchall())
# Allow-list for ORDER BY column name
allowed_columns = {"id": "id", "name": "username"}
requested_sort = "name"
safe_column = allowed_columns.get(requested_sort, "id")
cur.execute(f"SELECT id, username FROM accounts ORDER BY {safe_column}")
print("Sorted rows:", cur.fetchall())Parameterized result: [(2, "o'connor", 'guest')]
Sorted rows: [(1, 'dana'), (2, "o'connor")]מגבלה קריטית של מצייני מקום: הם קושרים ערכים בלבד, ולא שמות של עמודות, טבלאות או כיוון מיון (ORDER BY). במקומות כאלה יש להשתמש ברשימה מותרת (allow-list) קבועה מראש, כמו בדוגמה למעלה.
| הגנה | מה היא מצמצמת או עוצרת | מה היא אינה עוצרת |
|---|---|---|
Stored Procedure (נוהל ששמור במסד ונקרא בשמו) | הזרקה, כשהקלט עובר אליו כפרמטר | הזרקה, כשהנוהל מרכיב בתוכו טקסט שאילתה מהקלט |
| הרשאות מינימליות לחשבון המסד | היקף הנזק אחרי שהזרקה כבר הצליחה | עצם ההזרקה |
| הסתרת הודעות שגיאה | דליפת פרטי מבנה מהודעות המסד | ההזרקה עצמה, שגם הגרסה העיוורת שלה ממשיכה לעבוד |
WAF (חומת אש ליישומי ווב, שיושבת לפני האתר) | בקשות שתוכנן תואם תבניות הזרקה מוכרות, והיא מתריעה או חוסמת | שאילתה שצורתה שונה אך משמעותה זהה, למשל בעזרת הערות או רווחים; היא שכבה משלימה ואינה מתקנת את הקוד |
שימו לב: העברת הקלט ב-GET במקום ב-POST, או החלפת כתובת IP וכותרת User-Agent, אינה משנה את תוכן השאילתה, ולכן אינה מסייעת לעקוף בדיקת תוכן.
טעויות נפוצות
- פונקציות escaping כמו
mysql_real_escape_stringאוaddslashesמחליפות שאילתות פרמטריות. פונקציות כאלה רק מוסיפות לוכסן לפני תווים מיוחדים (גרשיים, לוכסנים הפוכים ועוד) בתוך מחרוזת, כלומר הן מנטרלות תווים ולא מפרידות בין פקודה לנתונים. כשערך נכנס לשאילתה כמספר, בלי גרשיים, התוקף אינו צריך תו מיוחד כדי לשבש אותה, ולכן ה-escaping חלש משאילתה פרמטרית. - בקשות בפורמט
JSON, רשימה שחורה של מילים, בדיקתJSבצד הלקוח,HTTPSאו הצפנת דיסק מונעיםSQLi.JSONהוא אריזה בלבד, ובשרת הוא נפרש לטקסט רגיל. רשימה שחורה ובדיקת לקוח נעקפות בקלות,HTTPSשומר על הדרך ולא על תוכן השאילתה, והצפנת דיסק אינה מבחינה בין שאילתה לגיטימית לשאילתה שהאפליקציה עצמה הרכיבה בצורה פגיעה.
LFI / RFI: הכללת קבצים
מהי הכללת קובץ
יישומי ווב (כגון ב-PHP) משתמשים בפונקציות כמו include או require_once כדי לטעון קובצי תבנית וקוד ולהריץ אותם כחלק מהדף.
הפגיעות נוצרת כשהנתיב נקבע ישירות מפרמטר שהמשתמש שולט בו, כמו page בכתובת. ההבדל בין include ל-require_once נוגע רק לתגובה לכישלון בטעינה (אזהרה מול עצירה) ולטעינה חוזרת של אותו קובץ; אף אחת מהן אינה בודקת את הנתיב.
// Vulnerable: user input directly sets the included file path
include($_GET['page']);מכאן מתפצלות שתי חולשות: הכללת קובץ מקומי שכבר נמצא בשרת (LFI), או הכללת קובץ מכתובת URL מרוחקת שבשליטת התוקף (RFI).
LFI ו-path traversal
ב-LFI (Local File Inclusion), התוקף גורם לשרת לקרוא או להריץ קובץ מקומי רגיש שכבר קיים על גבי השרת.
המנגנון הנפוץ הוא מעבר תיקיות (Path Traversal). נניח שהסקריפט רץ מהתיקייה /var/www/html/app: כל ../ מעלה תיקייה אחת, כך שאחרי אחד מגיעים ל-/var/www/html, אחרי שניים ל-/var/www, ואחרי עוד כמה לשורש /, ומשם אפשר לרדת לכל קובץ במערכת.
- הרצף אינו נוגע בסיומת של שם הקובץ.
- הוא אינו מתחיל נתיב מהשורש: זה תפקידו של לוכסן שעומד בראש הנתיב.
- הוא אינו מפנה לשרת אחר: לשם כך נדרשת כתובת
URLמלאה.
הקובץ /etc/passwd מפרט משתמשים והגדרותיהם אך לא את הסיסמאות (הן ב-/etc/shadow). ברשימת שמות כזו התוקף מקבל יעדים לניחוש סיסמאות, אך הקריאה נשארת קריאה בלבד: אין כתיבה ואין קריסה של השרת. חמורה יותר חשיפה של קובצי תצורה שמכילים את סיסמת מסד הנתונים.
הבעיה נובעת מקוד האפליקציה ולא ממערכת ההפעלה, ולכן היא קיימת גם בשרתי Windows.
LFI להרצת קוד
לעיתים ניתן למנף LFI מעבר לחשיפת קבצים להרצת קוד בשרת, באמצעות הרעלת לוגים (Log Poisoning): התוקף שולח קוד PHP בכותרת בקשה כמו User-Agent שנשמרת בלוג השרת, ולאחר מכן מכליל את קובץ הלוג המקומי דרך ה-LFI.
כלי נוסף ב-PHP הוא מעטפת הזרם php://filter עם קידוד Base64. הכללה רגילה של קובץ כמו config.php הייתה מריצה את הקוד שבו ומסתירה את קוד המקור, אך העברתו דרך מסנן Base64 הופכת אותו לטקסט מקודד שאינו מורץ ומאפשרת לקרוא את הסיסמאות שבתוכו.
טעויות נפוצות
- הרעלת לוגים היא סוג של
RFIודורשת הכללה מרחוק. קובץ הלוג כבר קיים מקומית על השרת, ולכן מדובר בניצול שלLFI. - המעטפת
php://filterמריצה אתconfig.phpומדפיסה את פלט הריצה. היא מחזירה את תוכן קוד המקור מקודד ב-Base64כטקסט, בלי להריץ אותו. - דרך אותו פרמטר של
LFIאפשר לשלוף נתונים מהמסד באמצעות הזרקתSQL. הזרקתSQLהיא פגיעות נפרדת בשכבת מסד הנתונים ואינה חלק מטכניקות הכללת הקבצים.
RFI
ב-RFI (Remote File Inclusion), התוקף מספק בפרמטר כתובת URL של קובץ הנמצא על שרת שבשליטתו. השרת מושך את המשאב החיצוני ומבצע את פקודות ה-PHP הכלולות בו כחלק מהאפליקציה (לרוב ליצירת Web Shell).
RFI חמור מ-LFI כי התוקף אינו מסתפק בקריאת קבצים קיימים אלא מריץ קוד משלו. כמה פרטים שכדאי לזכור:
- אין צורך בהרשאת כתיבה לתיקיית האתר, כי הקוד נשאר בשרת המרוחק, וסיומת הקובץ אינה מגבילה.
- הקוד רץ בחשבון המשתמש של שרת הווב (כגון
www-data) ולא כ-root, והקובץ המקורי בשרת אינו משתנה. - ב-
PHPנדרש ש-allow_url_includeיהיה פעיל ב-php.ini: זה מה שמתיר ל-includeלקבל כתובת. מגרסה 5.2 הוא כבוי כברירת מחדל. - נדרש גם ש-
allow_url_fopenיהיה מאופשר, כי טעינה מכתובת נשענת עליו.
הגנה
כדי לעצור הן LFI והן RFI בצורה אמינה, יש להשתמש ברשימה מותרת סגורה (allow-list) שממפה ערכים מותרים לקבצים קבועים מראש, ודוחה כל קלט אחר.
ALLOWED_PAGES = {
"home": "pages/home.php",
"about": "pages/about.php",
"contact": "pages/contact.php",
}
def resolve_page(param: str) -> str:
if param in ALLOWED_PAGES:
return f"Loading: {ALLOWED_PAGES[param]}"
return "Error: page not allowed"
print(resolve_page("about"))
print(resolve_page("../config"))Loading: pages/about.php
Error: page not allowed- נגד
RFIב-php.ini: כיבויallow_url_includeו-allow_url_fopen. (הגדרות כמוmod_rewrite,HSTSאוupload_max_filesizeאינן קשורות להכללת קבצים). - שכבות משלימות: דחיית
../ונתיבים מוחלטים,open_basedir(הגדרתPHPשמצמצמת את התיקיות שהסקריפט רשאי לפתוח), והרצת השרת בהרשאות מינימליות.
טעויות נפוצות
- חיפוש והסרה חד-פעמית של
../, חסימת המילהpasswdאו הוספת סיומת.phpמגינים מ-LFI. הסרה חד-פעמית נעקפת ברצפים שמרכיבים את../מחדש אחרי ההסרה, ובקידודURLהמסנן רואה טקסט גולמי בעוד השרת מפענח אותו אחר כך. חסימת מילה אחת משאירה את שאר הקבצים, ותוספת.phpעדיין מאפשרת טעינה של כל קובץPHPאחר באתר (ובגרסאות ישנות אפשר היה לחתוך אותה בעזרת תו null). - דרישת התחברות לאתר מונעת ניצול של
LFI. משתמש רשום שולח את אותו פרמטר. וכיבויallow_url_includeחוסם רק אתRFI, ואילוLFIנשאר פתוח.
CSRF: זיוף בקשות
מה זה ואיך זה עובד
CSRF (Cross-Site Request Forgery) היא מתקפה המנצלת דף זדוני כדי להפעיל פעולה משנת מצב (כמו העברה בנקאית או החלפת סיסמה) מתוך הדפדפן של גולש שכבר מחובר לאתר היעד.
הסיבה שהמתקפה עובדת היא שהדפדפן מצרף אוטומטית את עוגיות הסשן לכל בקשה לאתר היעד, גם כשמקור הבקשה הוא קישור, תגית תמונה או טופס POST שנשלח אוטומטית מדף אחר. לכן מעבר מ-GET ל-POST או שימוש ב-HTTPS אינם מונעים CSRF. הנימוק הזה מניח שהעוגייה נשלחת גם בבקשות חוצות אתרים, כלומר בלי הגבלת SameSite או עם SameSite=None; על ברירות המחדל המודרניות נדבר בחלק על SameSite.
תנאי הכרחי: הקורבן חייב להיות מחובר באותו זמן לאתר היעד כדי שעוגיית הסשן תישלח (אחרת הבקשה נדחית או מופנית לדף ההתחברות). התוקף אינו רואה את התגובה (בגלל SOP) ואינו גונב את העוגייה, הדפדפן אינו מציג אזהרה, והאתר אינו מנתק את המשתמש אוטומטית.
טוקן אנטי-CSRF
כדי להבין מה הטוקן עושה, נשווה שני טפסים של בנק. בטופס הראשון השדה הנסתר מכיל את מספר החשבון כמות שהוא; בטופס השני הוא מכיל מחרוזת אקראית שהשרת יצר עבור הסשן הזה ושמר אצלו. השרת דורש שבכל בקשה שמשנה מצב הערך יתאים לזה ששמור, וזהו Anti-CSRF Token.
בטופס הראשון כל תוקף יודע את הערך או מנחש אותו, ולכן יכול לשים אותו בבקשה מזויפת. בטופס השני הוא חסר אותו: הערך נמצא בדף של הבנק, ו-SOP אוסרת על דף זר לקרוא אותו. הבקשה המזויפת מגיעה, והעוגייה נשלחת, אך בלי הטוקן הנכון, ולכן נדחית.
מכאן הדרישה שהטוקן יהיה אקראי, או HMAC (גיבוב שנעשה עם מפתח סודי שרק השרת מחזיק). גיבוב פשוט של ערך ידוע, כמו מספר החשבון, הוא דטרמיניסטי ואינו הצפנה, ולכן תוקף יחשב אותו בעצמו.
שכבה משלימה היא בדיקת הכותרת Origin או Referer: השרת משווה את הדומיין שבה לדומיין של האתר עצמו, והשוואה חייבת להיות מדויקת. בדיקה שהכותרת קיימת בלבד אינה שווה דבר.
טעויות נפוצות
- הטוקן מגן מפני
CSRFכי השדה שלו מוגדר כ-hidden. שדהhiddenנסתר רק מהעין, וכל גולש רואה אותו בקוד המקור. מה שחוסם את התוקף הוא שהערך אקראי ואינו בידיו. - הטוקן מגן כי הוא מצפין את שדות הטופס, מגביל שליחות חוזרות או מסנן קבצים. אלה אינם תפקידיו. הוא סוד שהתוקף חסר, ורק זה מה שחשוב; הוא גם נשאר קבוע לאורך הסשן, ואינו מוחלף בכל בקשה.
עוגיות SameSite
המאפיין SameSite של העוגייה קובע מתי הדפדפן יצרף אותה בבקשות שמקורן באתר אחר:
| ערך | מתי העוגייה נשלחת מאתר אחר | רמת הגנה מ-CSRF |
|---|---|---|
Strict | לעולם לא נשלחת בבקשות חוצות אתרים | חזקה |
Lax | נשלחת רק בניווט GET ברמה העליונה (לחיצה על קישור), נחסמת ב-POST אוטומטי | חלקית (חושפת שינוי מצב ב-GET) |
None | נשלחת תמיד, גם בבקשות חוצות אתרים | אין הגנה (מבטל את ההגנה) |
שימו לב למלכודת הנפוצה: SameSite=Lax (ברירת המחדל בדפדפנים מבוססי Chromium כמו Chrome ו-Edge כאשר המאפיין לא הוגדר) אינה מגינה על פעולה שמשנה מצב בבקשת GET, כי לחיצה על קישור בדף זדוני נחשבת ניווט GET ברמה העליונה והעוגייה עדיין מצורפת. כדי לתקן זאת, אל תשנו מצב בבקשות GET, הטמיעו טוקן אנטי-CSRF, ושקלו להגדיר SameSite=Strict.
אימות חוזר
לפני פעולות רגישות במיוחד נהוג לדרוש אימות חוזר, כמו הזנת הסיסמה הנוכחית או קוד חד-פעמי (OTP). הוא מצטרף לטוקן ולעוגיות SameSite כהגנה נוספת, ואינו מחליף אותם.
העוגייה עדיין נשלחת בבקשה המזויפת, אך הבקשה נכשלת כי הדף החיצוני אינו יכול לספק את הסוד הנוסף שרק המשתמש מכיר.
חזרה לתוכן הענייניםCSRF לעומת XSS
בשתי המתקפות הדפדפן של הקורבן פועל בשמו בלי שידע: ב-XSS הוא מריץ קוד זר, וב-CSRF הוא שולח בקשה שלא התכוון אליה. אף אחת מהן אינה עוסקת בשאילתות מסד או בהעלאת קבצים לשרת. עם זאת, המנגנון הפוך לחלוטין:
| מאפיין | XSS | CSRF |
|---|---|---|
| מה מנוצל | הסתמכות המשתמש על האתר | הסתמכות האתר על הדפדפן של המשתמש |
| מה קורה בפועל | קוד זדוני רץ בתוך דף האתר | בקשה מזויפת נשלחת מדף אחר |
| איפה נמצאת החולשה | באתר הפגיע עצמו (קלט שמוצג בלי קידוד) | באתר שאינו מוגן, והבקשה מגיעה מדף אחר |
| קריאת תגובה | כן (רץ באותו Origin) | לא (SOP חוסם קריאה) |
השפעה על טוקן CSRF | יכול לקרוא את הטוקן ולעקוף אותו | אינו יכול לקרוא את הטוקן |
| הגנה עיקרית | קידוד פלט, textContent, CSP | Anti-CSRF Token, SameSite |
בגלל שהסקריפט ב-Stored XSS רץ בתוך ההקשר של האתר, הוא יכול לבצע בקשות אוטומטיות בשם המשתמש ואף לקרוא מתוך הדף את ה-CSRF Token ולעקוף הגנת CSRF.
Web Shell: שליטה בשרת
איך Web Shell עובד ומהן ההגנות
נניח שתוקף ניצל RFI או העלאת קבצים לא מאובטחת והצליח להניח בשרת קובץ PHP קטן. מכאן הוא אינו זקוק לפרצה המקורית: הקובץ עצמו הוא דלת קבועה, וזהו Web Shell.
התוקף שולח אל כתובת הקובץ בקשות HTTP רגילות שנושאות את מה שהוא רוצה להריץ. הסקריפט מפעיל זאת במערכת ההפעלה ומחזיר את התוצאה בתגובה, ולכן מבחוץ זה נראה כמו גלישה רגילה באתר.
ההרשאות הן של חשבון השירות של שרת הווב (למשל www-data) ולא של root. גם זה מספיק כדי לקרוא ולשנות את קובצי האתר ולנסות להרחיב את האחיזה.
- חסימת הרצה בתיקיות העלאה: אם השרת אינו מריץ סקריפטים מהתיקייה שאליה מעלים קבצים, קובץ שהועלה נשאר טקסט בלבד.
- הרשאות מינימליות לשירותי השרת: ככל שחשבון השירות מוגבל יותר, כך הקוד שהוצב מגיע לפחות דברים.
- סינון תעבורה יוצאת (
egress filtering): שרת שנפרץ אינו יכול לפנות החוצה, כך שהתוקף מתקשה להוריד אליו כלים או להוציא ממנו מידע.
טעויות נפוצות
Web Shellהוא כלי הגנה או הגדרה של השרת, כמו אנטי-וירוס אוallow_url_include. זהו קוד של התוקף שהוצב בשרת.allow_url_includeהיא רק הגדרה שמאפשרתRFI, שדרכו אפשר להציב אותו, ואנטי-וירוס נועד דווקא לעצור כאלה.Web Shellרץ בדפדפן של הגולשים, כמו טופס פישינג, או מצפין את קובצי האתר. הוא רץ בשרת ולא בדפדפן, מבצע פקודות, ואינו טופס מזויף שאוסף סיסמאות ואינו מצפין קבצים.
סיכום
לפניכם ריכוז ההבדלים וההגנות המרכזיות של ארבע מתקפות הווב המרכזיות (לצד Web Shell כתוצאה אפשרית):
| מתקפה | מקום הריצה | מהות הניצול | הגנה מרכזית |
|---|---|---|---|
XSS | דפדפן הקורבן | הרצת סקריפט בהקשר האתר | קידוד פלט לפי הקשר, textContent, CSP |
SQL Injection | מסד הנתונים בשרת | שינוי מבנה השאילתה מקלט לא מופרד | שאילתות פרמטריות, allow-list לשמות עמודות |
LFI | שרת (הכללת קבצים) | טעינת קובץ מקומי בשרת (לעיתים גם הרצתו) | רשימה סגורה (allow-list) של דפים מותרים |
RFI | שרת (הכללת קבצים) | הרצת קובץ מכתובת מרוחקת | כיבוי allow_url_include, רשימה סגורה |
CSRF | דפדפן הקורבן אל השרת | שליחת בקשה משנת מצב עם העוגייה האוטומטית | Anti-CSRF Token, SameSite, אימות חוזר |
- זכרו את הגבולות:
SOPחוסמת קריאת תגובה, לא שליחת בקשה;HttpOnlyמגן מקריאת עוגייה ב-JSאך אינו עוצרXSS;SameSite=Laxעדיין שולח עוגייה בניווטGET, ו-SameSite=Noneמבטל את ההגנה. - סוגי
XSS:Storedנשמר ומוגש לכולם,Reflectedמוחזר מיידית בקישור, ו-DOM-Basedמתרחש כולו בצד הלקוח (והחלק שאחרי#כלל לא מגיע לשרת). - שאילתות פרמטריות וסוגי הזרקת
SQL: מצייני מקום מגינים על ערכים (כולל ב-Second-Order, שבו ההשפעה מתממשת רק בשימוש מאוחר בנתון השמור), בעוד הזרקה עיוורת מסיקה מידע מהבדלי תגובה או זמן, ושמות עמודות ב-ORDER BYמחייבים רשימה מותרת. Web Shell: רץ על השרת בהרשאות תהליך השרת (לאroot), ומגיע לרוב לאחרRFIאו העלאת קובץ לא מאובטחת.LFIמולRFI:LFIקורא (ולעיתים גם מריץ) קובץ שכבר נמצא בשרת, ואילוRFIמושך ומריץ קובץ מכתובת מרוחקת ודורש ש-allow_url_includeיהיה פעיל. כל מתקפה רצה במקום אחר:XSSבדפדפן,SQL Injectionבמסד הנתונים, והכללת הקבצים בשרת, ואף אחת מהן אינהCSRF.