Offensive Waf Bypass

SKILL: WAF Bypass Techniques

Metadata

• Skill Name: waf-bypass
• Folder: offensive-waf-bypass
• Source: https://github.com/SnailSploit/offensive-checklist/blob/main/waf-bypass.md

Description

WAF bypass techniques checklist: encoding bypass (URL/HTML/Unicode/double encoding), case variation, comment injection, HTTP header manipulation, chunked encoding, IP rotation, timing attacks, and payload obfuscation per WAF vendor. Use when WAF is blocking payloads during web app tests.

Trigger Phrases

Use this skill when the conversation involves any of: WAF bypass, web application firewall bypass, URL encoding, double encoding, Unicode bypass, comment injection, HTTP header bypass, chunked encoding, IP rotation, payload obfuscation, WAF evasion

Instructions for Claude

When this skill is active:

1. Load and apply the full methodology below as your operational checklist
2. Follow steps in order unless the user specifies otherwise
3. For each technique, consider applicability to the current target/context
4. Track which checklist items have been completed
5. Suggest next steps based on findings

---

Full Methodology

WAF Bypass Techniques

A Web Application Firewall (WAF) is a security tool that protects web applications from various attacks by analyzing HTTP requests and applying rules to identify and block suspicious traffic. This document outlines effective techniques to bypass WAF protections during security assessments.

graph TD
    A[Client] -->|HTTP Request| B[WAF]
    B -->|Filtered Request| C[Web Application]
    C -->|Response| D[WAF]
    D -->|Filtered Response| A

    E[Attacker] -->|Malicious Request| B
    B -->|Blocked| E

    F[Attacker withBypass Techniques] -->|ObfuscatedMalicious Request| B
    B -->|Request Appears Legitimate| C

    style B fill:#f9a,stroke:#333,color:#333
    style E fill:#f66,stroke:#333,color:#333
    style F fill:#f66,stroke:#333,color:#333

WAF Overview

WAFs operate in two primary models:

• Negative Model (Blacklist-based): Uses pre-set signatures to block known malicious requests, effective against common vulnerabilities
• Positive Model (Whitelist-based): Only allows requests that match specific patterns, blocking everything else by default

Popular WAFs

• Cloudflare - Identified by __cf_bm, cf_clearance, cf_chl_* cookies and "/cdn-cgi/" routes (cookies rotate roughly every 30 min)
• Akamai
• Imperva/Incapsula - Look for "X-CDN: Incapsula" headers
• AWS WAF - Commonly sets AWSALB or AWSALBCORS cookies
• Sucuri - Check for "X-Sucuri-ID" headers
• DataDome
• F5 Networks
• Barracuda
• Fortinet
• ModSecurity - Open-source WAF, commonly used with Apache
• NAXSI - Open-source WAF for NGINX
• Azure Front Door
• Fastly Next-Gen WAF
• Cloudflare AI WAF
• Radware
• Coraza - Modern open‑source WAF written in Go

Detection Methods

flowchart LR
    A[WAF Detection Methods] --> B[Control Page Analysis]
    A --> C[HTTP Header Inspection]
    A --> D[Cookie Analysis]
    A --> E[Route Examination]
    A --> F[JavaScript Object Analysis]

    B --> B1[Block Pages]
    B --> B2[Challenge Pages]
    B --> B3[CAPTCHA Systems]

    C --> C1[Custom Security Headers]
    C --> C2[Server Headers]
    C --> C3[CDN Markers]

    D --> D1[WAF-specific Cookies]
    D --> D2[Challenge Cookies]

    E --> E1[CDN Paths]
    E --> E2[WAF Asset Routes]

    F --> F1[Protection Objects]
    F --> F2[Challenge Scripts]

    style A fill:#f96,stroke:#333,stroke-width:2px,color:#333

1. Inspect Control Pages - Many WAFs display specific pages when blocking access
2. Analyze HTTP Headers - Check response headers for WAF-specific indicators
3. Examine Cookies - WAFs often set specific cookies (e.g., cf_clearance for Cloudflare)
4. Look for Specific Routes - e.g., /cdn-cgi/ for Cloudflare
5. Check JavaScript Objects - WAFs inject specific JS objects (e.g., \_cf_chl_opt)
6. JA3/JA4/TLS Fingerprints - Compare your client’s TLS fingerprint with common browser fingerprints; mismatches are often blocked.
7. HTTP/2/3 Support - Identify protocol negotiation; some WAF policies differ by protocol.

Fingerprinting WAFs

Some specific fingerprints of common WAFs:

• Apache Generic: Writing method type in lowercase (e.g., get instead of GET)
• IIS Generic: Using tabs before method (e.g., GET /login.php HTTP/1.1)
• Cloudflare: Challenge pages with JavaScript verification
• ModSecurity: Specific error messages and block pages
• AWS WAF: AWSELB cookies and specific headers
• Fastly Next‑Gen WAF: fastly-debug-* headers (when enabled), service IDs in responses
• Cloudflare Bot Fight Mode/AI WAF: presence of Turnstile, managed challenge flows, Bot Management headers

Bypass Techniques

1. Use Residential IPs

• Data center IPs are easily detected by WAFs
• Residential IPs appear legitimate as they come from ISPs
• Mobile IPs are useful for websites showing different content for mobile users
• Use proxy rotation services to avoid IP-based rate limiting

2. Fortify Headless Browsers

Headless browsers often set special headers or variables that help WAFs recognize them as automation tools. Use the following libraries to make headless browsers appear more human-like:

• undetected_chromedriver for Selenium
• puppeteer-extra-plugin-stealth for Puppeteer/Playwright
• playwright-extra with playwright-extra-plugin-stealth for Playwright

3. Use Web Scraping APIs

Services like ZenRows implement sophisticated anti-bot techniques including:

• Premium proxies
• JS rendering
• WAF bypassing capabilities
• CAPTCHA solving
• Protocol emulation (HTTP/2 push/HTTP/3), humanization features

4. Call the Origin Server Directly

• Use services like Shodan or tools like CloudFlair to find the origin server IP
• Forge requests to make them appear as coming from a valid domain
• Bypass the WAF layer completely by contacting the server directly
• Check historical DNS records (e.g., with securitytrails API) – 2024 research found ~40 % of Fortune‑100 origins exposed via stale A records
• Check Alt-Svc leakage for HTTP/3, misconfigured Workers/Edge redirects exposing bucket hostnames

sequenceDiagram
    participant Attacker
    participant WAF
    participant Origin as Origin Server

    Note over Attacker,Origin: Normal Route (Blocked)
    Attacker->>WAF: Malicious Request
    WAF->>Attacker: Request Blocked

    Note over Attacker,Origin: Origin Bypass
    Attacker->>Attacker: Find Origin IP (Shodan, etc.)
    Attacker->>Origin: Direct Request with Host Header
    Origin->>Attacker: Response (WAF Bypassed)

5. Utilize WAF Solvers

• BypassWAF - Overcomes firewalls by looking for old DNS A records
• Cfscrape - Python module to bypass Cloudflare protection
• Cloudscraper - Python library to avoid Cloudflare waiting room

6. Reverse Engineer JavaScript Challenges

• Analyze injected JavaScript snippets used by WAFs
• Understand how the challenge works
• Create custom solutions that satisfy the challenge requirements

7. CAPTCHA Bypass Techniques

• Cloudflare Turnstile – low‑friction CAPTCHA replacement; see cloudflare_turnstile_bypass PoC (GUI‑driven, YMMV)
• Use CAPTCHA solving services - Though often expensive and not always reliable
• Utilize automated CAPTCHA solvers - Various libraries exist for different CAPTCHA types
• Implement prevention measures - Use techniques that prevent CAPTCHAs from appearing

Cloudflare Turnstile Bypass

// Visibility bypass: Complete Turnstile in hidden iframe
const iframe = document.createElement("iframe");
iframe.style.display = "none";
iframe.src = "https://challenges.cloudflare.com/...";
document.body.appendChild(iframe);

// Token reuse test: Check if cf_clearance tokens are single-use
// Save token from successful solve, attempt reuse across sessions

// Timing attack: Solve challenge, delay submission to test token expiry
setTimeout(() => submitWithToken(token), 60000);

Tools:

• cf-clearance-scraper (2024 fork with Turnstile support)
• cloudflare-turnstile-solver - Automated solving with browser automation
• turnstile-bypass - Research tool for testing Turnstile implementations

8. Avoid Honeypot Traps

• Don't interact with invisible elements (display: none)
• Skip elements with zero opacity or positioned off-screen
• Analyze HTML structure to identify potential honeypots
• Avoid filling hidden form fields

9. Defeat Browser Fingerprinting

• Randomize or spoof canvas fingerprinting results
• Use plugins that add noise to fingerprint data
• Modify user agent and other HTTP headers periodically
• Spoof hardware and software features to appear as different devices

10. TLS Fingerprinting Evasion

• Modify TLS parameters during handshake
• Use libraries that allow customization of SSL/TLS configuration
• Match TLS fingerprints of legitimate browsers
• Randomise both JA3 and JA4 fingerprints using libraries such as noble-tls or ja4py
• Consider using the abuse-ssl-bypass-waf tool to find supported SSL/TLS ciphers
• Align cipher suites, ALPN order, and signature algorithms with target browser versions.

11. Simulate Human Behavior

• Add random delays between requests
• Follow logical navigation patterns
• Implement mouse movements and scrolling behavior
• Interact with page elements naturally
• Vary request patterns and timing
• Use browser engines (Playwright/Selenium) with stealth plugins to match DOM APIs and canvas behavior.

mindmap
  root((WAF Bypass Techniques))
    Network Level
      Residential IPs
      Origin Server Direct
      IP Rotation
      Distributed Requests
    Browser Emulation
      Headless Browser Fortification
      TLS Fingerprint Evasion
      JS Challenge Solving
      Human Behavior Simulation
    Request Manipulation
      Header Manipulation
      Parameter Pollution
      HTTP Protocol Tricks
      Encoding Variations
    Attack Specific
      SQLi Bypasses
      XSS Obfuscation
      JSON-Based Injection
      Protocol Level Bypass
    Tools & Services
      WAF Solvers
      CAPTCHA Services
      Proxy Rotators
      Web Scraping APIs

12. SQL Injection Specific WAF Bypasses

• Case variation: SeLeCt, UnIoN instead of SELECT, UNION
• Comment injection: UN/**/ION SE/**/LECT to break up keywords
• Alternate encodings:
• URL encoding: UNION → %55%4E%49%4F%4E
• Hex encoding: SELECT → 0x53454C454354
• Unicode encoding
• Whitespace manipulation: UNION/**/SELECT or using tabs/newlines/carriage returns
• Numeric representations:
• 1 → 1-0, 1+0, CHAR(49)
• String concatenation:
• MySQL: CONCAT('a','b')
• Oracle: 'a'||'b'
• MSSQL: 'a'+'b'
• Null byte injection:

`` %00' UNION SELECT password FROM Users WHERE username='xyz'-- ``

• Double encoding:

`` First pass: / → %2f Second pass: %2f → %252f ``

• SQLMAP tamper scripts:
• Use Atlas tool for suggesting tamper scripts
• Try multiple tamper scripts in combination
• Customize tamper scripts for specific WAFs
• JSON-Based SQL Injection (CVE-2023-50969):
• Many WAFs (AWS, Cloudflare, F5, Imperva) don't properly support JSON syntax in SQL
• Example: {"id": {"$gt": "' OR 1=1--"}}
• Use SQLMap with JSON parameter support for exploitation
• Leverage mixed encodings (half‑width Unicode, overlong UTF‑8), embedded comments, and case folding differences.

graph TD
    A[SQL Injection WAF Bypass] --> B[Syntax Manipulation]
    A --> C[Character Encodings]
    A --> D[Alternative Representations]
    A --> E[SQLMap Tamper Scripts]

    B --> B1[Case VariationSeLeCt]
    B --> B2[Comment InsertionUN/**/ION]
    B --> B3[Whitespace ManipulationUNION++++SELECT]

    C --> C1[URL Encoding%55%4E%49%4F%4E]
    C --> C2[Hex Encoding0x53454C454354]
    C --> C3[Double Encoding%252f]
    C --> C4[Unicode Encoding]

    D --> D1[String Alternatives]
    D --> D2[Numeric Alternatives]
    D --> D3[JSON-Based Injection]

    E --> E1[Multiple Script Chaining]
    E --> E2[WAF-Specific Scripts]

    style A fill:#f96,stroke:#333,stroke-width:2px,color:#333
    style B,C,D,E fill:#bbf,stroke:#333,color:#333

13. XSS-Specific WAF Bypasses

• Context-Aware Payloads: Craft payloads based on where they will be inserted:

``` # HTML Context

# HTML Attribute Context " onmouseover="alert(1)

# JavaScript Context ';alert(1);// ```

• Mutation XSS (mXSS): Use HTML parsing quirks to bypass sanitizers:

`` "> ``

• Alternative Tag Usage:

```

```

• JavaScript Obfuscation:

``` eval(atob('YWxlcnQoMSk='))

```

• Avoiding Blacklisted Words:

``` al\u0065rt(1)

```

• Protocol Obfuscation:

`` Click Me Click Me ``

• CSS-Based Attacks:

``` @keyframes x{}

```

• CSP Bypass Techniques:
• JSONP endpoint abuse: ``
• DOM clobbering: ` then self.location`
• Using allowed domains: Find script sources whitelisted in CSP that can be abused
• Abuse JSONP, postMessage, or gadget endpoints on allowed origins; check Trusted Types gaps.

• Polyglot XSS: Payloads that work in multiple contexts:

`` jaVasCript:/*-/*/*\/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//\x3csVg/\x3e ``

14. HTTP Protocol Level Bypasses

• HTTP Method Obfuscation:
• Using uncommon HTTP methods
• Modifying case of HTTP methods (e.g., gEt instead of GET)
• Adding tabs or spaces before HTTP methods

• Request Header Manipulation:
• Adding excessive headers to confuse WAF processing
• Using duplicate headers with different values
• Adding headers that make the request appear to come from internal networks or spoof identity. Many applications, especially behind misconfigured reverse proxies, trust headers like X-Forwarded-For or X-Forwarded-Host to determine the client's IP or the requested host. Manipulating these can lead to various vulnerabilities:
• Password Reset Poisoning: Injecting headers like X-Forwarded-Host: attacker.com can cause the application to generate password reset links pointing to the attacker's domain.
• Bypassing IP Restrictions: Using X-Forwarded-For: or similar headers can bypass IP-based access controls if the server trusts the header.
• Open Redirects: Manipulating host-related headers (X-Forwarded-Host, Referer) can redirect users to malicious sites.
• SSRF: Headers like X-Forwarded-For or X-Real-IP can be manipulated to target internal IPs (e.g., 169.254.169.254 for AWS metadata service).
• Common Headers for Spoofing/Bypass: Attackers may use a variety of headers to manipulate server behavior or bypass WAF rules. Some common examples include:

`` X-Forwarded-Host: attacker.com X-Forwarded-For: 127.0.0.1 X-Client-IP: 127.0.0.1 Client-IP: 127.0.0.1 X-Real-IP: 127.0.0.1 X-Originating-IP: 127.0.0.1 X-Remote-IP: 127.0.0.1 X-Remote-Addr: 127.0.0.1 Forwarded: for=127.0.0.1;host=attacker.com Referer: attacker.com Origin: null / attacker.com # And many variations like X-Forwarded, X-Forwarded-By, etc. ``

• HTTP Parameter Pollution:
• Using multiple parameters with the same name

`` ?id=safe&id=malicious ``

• Mix sources (query, body, headers, cookies) to exploit precedence ambiguities across proxies/gateways.

• HTTP RFC Inconsistencies:
• Exploiting differences in how servers handle HTTP specification
• Using newline variations (CR, LF, CRLF)
• Adding unexpected line breaks in headers

• Host Header Spoofing:
• The Host header specifies the hostname the client wants to connect to, crucial for virtual hosting and reverse proxies.
• If a WAF/proxy relies solel

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: SnailSploit
• Source: SnailSploit/Claude-Red
• License: MIT

Install and usage instructions live in the source repository linked above.