דלגו לתוכן הראשי
גאמא קוד

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מהדפדפן אל השרתהסשן של משתמש מחובר באתר היעד
חזרה לתוכן העניינים

עוגיות וסשן

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

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

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

דגלמה הוא קובעאיזו בעיה הוא פותר
HttpOnlyהעוגייה נסתרת מקוד JavaScript בדף, ו-document.cookie אינו מחזיר אותהסקריפט שהוזרק (XSS) אינו יכול להעתיק את מזהה הסשן
Secureהדפדפן שולח את העוגייה רק בערוץ HTTPSמי שמאזין לרשת אינו רואה אותה בטקסט גלוי
SameSiteהאם לצרף אותה כשהבקשה יוצאת מדף של אתר אחרזיוף בקשות בין אתרים (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. לכן בדיקות או סינון בצד השרת לא יראו אותו לעולם.

Text
// 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 כך שהדפדפן יציג אותם כטקסט.

Python
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 &lt;team&gt; &amp; &quot;lead&quot;

ההתאמה להקשר קריטית: כאשר קלט משובץ בתוך ערך של מאפיין (למשל 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, כל ערך בין גרשיים בודדים. הדוגמה הבאה בונה את טקסט השאילתה, קודם עם ערכים רגילים ואחר כך עם שם שמכיל גרש:

Python
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) שקולים לחלוטין למצייני מקום לפי מיקום (?).

Python
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 נוגע רק לתגובה לכישלון בטעינה (אזהרה מול עצירה) ולטעינה חוזרת של אותו קובץ; אף אחת מהן אינה בודקת את הנתיב.

Text
// 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) שממפה ערכים מותרים לקבצים קבועים מראש, ודוחה כל קלט אחר.

Python
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 הוא שולח בקשה שלא התכוון אליה. אף אחת מהן אינה עוסקת בשאילתות מסד או בהעלאת קבצים לשרת. עם זאת, המנגנון הפוך לחלוטין:

מאפייןXSSCSRF
מה מנוצלהסתמכות המשתמש על האתרהסתמכות האתר על הדפדפן של המשתמש
מה קורה בפועלקוד זדוני רץ בתוך דף האתרבקשה מזויפת נשלחת מדף אחר
איפה נמצאת החולשהבאתר הפגיע עצמו (קלט שמוצג בלי קידוד)באתר שאינו מוגן, והבקשה מגיעה מדף אחר
קריאת תגובהכן (רץ באותו Origin)לא (SOP חוסם קריאה)
השפעה על טוקן CSRFיכול לקרוא את הטוקן ולעקוף אותואינו יכול לקרוא את הטוקן
הגנה עיקריתקידוד פלט, textContent, CSPAnti-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.