Cloudflare WAF-Regeln, die CAPTCHA-Herausforderungen auslösen

Mit der Web Application Firewall (WAF) von Cloudflare können Website-Betreiber Regeln erstellen, die CAPTCHA-Herausforderungen basierend auf bestimmten Anforderungsattributen auslösen – IP-Adresse, Land, URL-Pfad, Bot-Score, Header oder eine beliebige Kombination. Wenn Sie verstehen, welche Regeln Herausforderungen auslösen, können Sie besser diagnostizieren, warum Sie ein CAPTCHA sehen, und den richtigen Ansatz für den Umgang damit wählen.

WAF-Regelaktionen, die CAPTCHAs erzeugen

Cloudflare WAF-Regeln unterstützen mehrere Aktionen. Drei davon stellen lösbare Herausforderungen dar:

Managed Challenge (am häufigsten)

Managed Challenge ist die von Cloudflare empfohlene Aktion. Es entscheidet adaptiv über die Art der Herausforderung pro Besucher:

WAF rule matches → Managed Challenge triggered
    ↓
Cloudflare evaluates visitor:
  ├─ Low risk → Invisible pass (no visible challenge)
  ├─ Medium risk → Turnstile widget (click to verify)
  └─ High risk → JavaScript challenge page
    ↓
Successful → cf_clearance cookie issued

Gängige WAF-Regelmuster

Site-Betreiber erstellen WAF-Regeln mithilfe der Ausdruckssprache von Cloudflare. Dies sind die Muster, die am wahrscheinlichsten CAPTCHAs für automatisierten Datenverkehr auslösen:

Bot-Score-Regeln

# Challenge traffic with low bot scores
(cf.bot_management.score lt 30)
→ Action: Managed Challenge

# Challenge non-verified bots
(cf.bot_management.score lt 50 and not cf.bot_management.verified_bot)
→ Action: JS Challenge

Bot-Score-Regeln sind der häufigste Auslöser für Automatisierungstools. Die API-Solver von CaptchaAI erhalten Bewertungen auf menschlicher Ebene, da sie echte Browser verwenden.

Länderspezifische Regeln

# Challenge traffic from specific countries
(ip.geoip.country in {"CN" "RU" "VN" "IN"})
→ Action: Managed Challenge

# Block specific regions entirely
(ip.geoip.country eq "XX")
→ Action: Block

Pfadbasierte Regeln

# Challenge login page access
(http.request.uri.path eq "/login" or http.request.uri.path eq "/signup")
→ Action: Managed Challenge

# Challenge API endpoints
(http.request.uri.path contains "/api/")
→ Action: JS Challenge

Tarifbasierte Regeln

# Challenge after high request rate
(cf.threat_score gt 10 and http.request.uri.path contains "/search")
→ Action: Managed Challenge

Headerbasierte Regeln

# Challenge requests with no Accept-Language header
(not http.request.headers["accept-language"])
→ Action: JS Challenge

# Challenge requests with suspicious UA
(http.user_agent contains "python" or http.user_agent contains "curl")
→ Action: Managed Challenge

Zusammengesetzte Regeln

# Multiple conditions
(cf.bot_management.score lt 30
 and http.request.uri.path contains "/api/"
 and ip.geoip.country ne "US")
→ Action: JS Challenge

Identifizieren, welche Regel ausgelöst wurde

Wenn eine CAPTCHA-Aufforderung erscheint, können Sie die auslösende Regel anhand der Antwort identifizieren:

Aus HTTP-Headern

import requests

def check_cloudflare_rule_info(url):
    """Extract WAF rule information from Cloudflare challenge response."""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 Chrome/120.0.0.0",
        "Accept": "text/html,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
    }

    response = requests.get(url, headers=headers, timeout=15, allow_redirects=False)

    info = {
        "status": response.status_code,
        "cf_ray": response.headers.get("cf-ray", ""),
        "cf_cache_status": response.headers.get("cf-cache-status", ""),
        "server": response.headers.get("server", ""),
    }

    # Challenge-specific info
    html = response.text

    if response.status_code == 503:
        if "jschl" in html:
            info["challenge_type"] = "JS Challenge (IUAM or WAF rule)"
        elif "challenge-platform" in html:
            info["challenge_type"] = "Managed Challenge"
        elif "cf-turnstile" in html:
            info["challenge_type"] = "Turnstile (Managed Challenge)"

    elif response.status_code == 403:
        if "cf-ray" in str(response.headers):
            info["challenge_type"] = "WAF Block (no challenge)"
        else:
            info["challenge_type"] = "Origin 403 (not Cloudflare)"

    return info

Von der Cloudflare Ray ID

Jede Cloudflare-Antwort enthält einen cf-ray-Header. Site-Betreiber können diese Ray-ID im Cloudflare-Dashboard (Sicherheit > Ereignisse) verwenden, um genau zu sehen, welche Regel ausgelöst wurde und welche Maßnahmen ergriffen wurden.

Durch WAF ausgelöste Herausforderungen lösen

Strategie basierend auf der Art der Herausforderung

import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_cloudflare_challenge(url, challenge_type):
    """Solve Cloudflare challenge based on WAF rule action."""

    if challenge_type == "managed_challenge":
        # Managed Challenge typically renders as Turnstile
        method = "turnstile"
        sitekey = extract_turnstile_sitekey(url)
    elif challenge_type == "js_challenge":
        # JavaScript Challenge page
        method = "cloudflare_challenge"
        sitekey = "managed"
    else:
        raise ValueError(f"Unknown challenge type: {challenge_type}")

    submit = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": method,
        "sitekey": sitekey,
        "pageurl": url,
        "json": 1,
    })

    task_id = submit.json()["request"]

    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        }).json()

        if result.get("status") == 1:
            return result["request"]

    raise TimeoutError("Challenge solve timed out")


def extract_turnstile_sitekey(url):
    """Fetch page and extract Turnstile sitekey."""
    import re
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 Chrome/120.0.0.0",
    }
    response = requests.get(url, headers=headers, timeout=15)
    match = re.search(r'data-sitekey=["\']([0-9x][A-Za-z0-9_-]+)["\']', response.text)
    return match.group(1) if match else None

Node.js

const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solveWAFChallenge(url, challengeType) {
  const method =
    challengeType === "js_challenge" ? "cloudflare_challenge" : "turnstile";
  const sitekey =
    challengeType === "js_challenge" ? "managed" : await extractSitekey(url);

  const submit = await axios.post("https://ocr.captchaai.com/in.php", null, {
    params: {
      key: API_KEY,
      method,
      sitekey,
      pageurl: url,
      json: 1,
    },
  });

  const taskId = submit.data.request;

  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));

    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: taskId, json: 1 },
    });

    if (result.data.status === 1) {
      return result.data.request;
    }
  }

  throw new Error("Challenge solve timed out");
}

async function extractSitekey(url) {
  const response = await axios.get(url, {
    headers: {
      "User-Agent": "Mozilla/5.0 Chrome/120.0.0.0",
    },
  });
  const match = response.data.match(/data-sitekey=["']([0-9x][A-Za-z0-9_-]+)["']/);
  return match ? match[1] : null;
}

WAF-Regeländerungen und ihre Auswirkungen

Seitenbetreiber passen WAF-Regeln häufig an. Diese Änderungen wirken sich auf die Automatisierung aus:

Überwachungsstrategie

import requests
import time

def monitor_cloudflare_protection(urls, interval=3600):
    """Monitor protection changes across URLs."""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 Chrome/120.0.0.0",
        "Accept": "text/html,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
    }

    last_status = {}

    while True:
        for url in urls:
            try:
                response = requests.get(
                    url, headers=headers, timeout=15, allow_redirects=False
                )
                status = response.status_code
                has_challenge = status == 503 or "cf-turnstile" in response.text

                current = {"status": status, "challenge": has_challenge}
                previous = last_status.get(url)

                if previous and current != previous:
                    print(f"[CHANGE] {url}")
                    print(f"  Before: {previous}")
                    print(f"  After:  {current}")

                last_status[url] = current

            except requests.RequestException as e:
                print(f"[ERROR] {url}: {e}")

        time.sleep(interval)

Fehlerbehebung

Häufig gestellte Fragen

Kann ich sehen, welche WAF-Regeln eine Site verwendet?

Nein. WAF-Regeln sind privat für den Website-Betreiber. Sie können Regeln nur aus dem Verhalten ableiten – welche Pfade Herausforderungen auslösen, von welchen IPs und welcher Herausforderungstyp auftritt.

Gelten die WAF-Regeln für alle Cloudflare-Pläne?

Benutzerdefinierte WAF-Regeln sind für alle kostenpflichtigen Pläne (Pro, Business, Enterprise) verfügbar. Für kostenlose Pläne gelten begrenzte WAF-Regeln. Managed Challenge ist jedoch für alle Pläne verfügbar, auch für Free.

Können WAF-Regeln unterschiedliche Herausforderungen für unterschiedliche Pfade auslösen?

Ja. Jede WAF-Regel kann eine andere Aktion haben und unterschiedliche Pfade abgleichen. Eine Site könnte Managed Challenge für /login- und JS Challenge für /api/-Endpunkte verwenden.

Wie oft ändern Websites ihre WAF-Regeln?

Es variiert. E-Commerce-Websites passen die Regeln häufig während Verkaufsveranstaltungen an. Auf sicherheitsbewussten Websites können die Regeln wöchentlich aktualisiert werden. Die meisten Websites ändern die Regeln nach der Ersteinrichtung selten.

Hat die Lösung einer WAF-Herausforderung Auswirkungen auf zukünftige Anfragen?

Ja. Nach der Lösung lässt das cf_clearance-Cookie nachfolgende Anfragen ca. 30 Minuten lang ohne Herausforderung durch. Das Cookie ist an Ihre IP und Ihren User-Agent gebunden.

Zusammenfassung

Cloudflare WAF-Regeln lösen CAPTCHA-Herausforderungen basierend auf konfigurierbaren Bedingungen aus: Bot-Score, Land, Pfad, Header oder Rate. Die häufigste Aktion ist die verwaltete Herausforderung, die Cloudflare adaptiv als unsichtbare, Turnstile- oder JS-Herausforderung darstellt. Lösen Sie diese mit CaptchaAI – verwenden Sie die Methode turnstile oder cloudflare_challenge, je nachdem, was gerendert wird. Harte Blöcke (403) aus WAF-Regeln sind nicht lösbar – ändern Sie stattdessen Ihr Anfragemuster oder Ihre IP.

Verwandte Artikel

• Cloudflare Challenge: Wie es funktioniert
• Cloudflare Browser Integrity Check vs. CAPTCHA-Challenge
• Cloudflare Under Attack Mode behandeln