Comment gérer Cloudflare en mode attaque

Le « I'm Under Attack Mode » (IUAM) de Cloudflare est une défense DDoS qui oblige chaque visiteur à relever un défi JavaScript de 5 secondes avant d'accéder au site. Il s'agit du mode de protection Cloudflare le plus agressif, déclenché manuellement par les opérateurs de sites lors d'attaques ou activé en permanence sur les sites à haut risque. Pour un accès automatisé, IUAM crée un défi JavaScript obligatoire que les clients HTTP traditionnels ne peuvent pas réussir.

Ce que fait l'IUAM

Lorsqu'un opérateur de site active « Je suis en mode attaque » dans le tableau de bord Cloudflare :

Every request → Cloudflare edge
    ↓
JavaScript challenge page served (HTTP 503)
    ↓
Browser executes JavaScript challenge (~5 seconds)
    ↓
Challenge answer submitted automatically
    ↓
cf_clearance cookie set
    ↓
Original page loaded with cf_clearance cookie

La page du défi IUAM

La page de défi renvoie HTTP 503 et contient :

Caractéristiques clés

• Code d'état HTTP 503 (PAS 403)
• 5 secondes d'attente obligatoire avant de soumettre le défi
• Exécution JavaScript requise — les clients HTTP simples échouent
• cookie cf_clearance — valide pendant environ 30 minutes, permet les demandes ultérieures
• À l'échelle du domaine : chaque page du domaine montre le défi

Identifier IUAM par rapport aux autres protections Cloudflare

import requests

def identify_cloudflare_protection(url):
    """Distinguish IUAM from other Cloudflare protections."""
    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, allow_redirects=False)
    html = response.text
    status = response.status_code

    if status == 503 and "jschl" in html:
        return "IUAM (I'm Under Attack Mode)"

    if status == 503 and "challenge-platform" in html:
        return "Managed Challenge"

    if status == 403 and "cf-ray" in str(response.headers):
        return "Blocked by WAF/Bot Management"

    if "cf-turnstile" in html:
        return "Turnstile widget"

    if "challenges.cloudflare.com" in html:
        return "Cloudflare challenge (generic)"

    if status == 200:
        return "No challenge (passed)"

    return f"Unknown (status: {status})"

Tableau de détection

Comment fonctionne le défi JavaScript

Le challenge JavaScript de l'IUAM a pour but de vérifier que le visiteur dispose d'un vrai navigateur :

Flux de défi

1. Cloudflare propose une page de défi avec du JavaScript obscurci
2. JavaScript effectue des calculs : - Opérations mathématiques sur les chaînes de la page - Mesures DOM - Application du timing (minimum 4-5 secondes)
3. Réponse calculée — une valeur numérique basée sur le défi
4. Formulaire soumis automatiquement à Cloudflare avec jschl_vc, pass et jschl_answer
5. Cloudflare valide la réponse et le timing
6. Cookie cf_clearance renvoyé — autorise l'accès pendant environ 30 minutes

Pourquoi les clients HTTP échouent

# This will ALWAYS get the challenge page:
import requests
response = requests.get("https://iuam-protected-site.com")
# response.status_code == 503
# response.text contains "Checking your browser..."

# Plain HTTP clients cannot:
# - Execute JavaScript
# - Compute the challenge answer
# - Meet the timing requirement
# - Generate the required cookies

Résoudre IUAM avec CaptchaAI

Méthode 1 : solveur Cloudflare Challenge (recommandé)

La méthode cloudflare_challenge de CaptchaAI gère directement les défis IUAM :

import requests
import time

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://iuam-protected-site.com/data"

# Step 1: Submit challenge to CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "cloudflare_challenge",
    "sitekey": "managed",
    "pageurl": TARGET_URL,
    "json": 1,
})

task_id = submit.json()["request"]
print(f"Task submitted: {task_id}")

# Step 2: Poll for result
for attempt 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:
        token = result["request"]
        print(f"Challenge solved! Token: {token[:50]}...")
        break
    elif result.get("request") == "ERROR_CAPTCHA_UNSOLVABLE":
        print("Challenge could not be solved")
        break
else:
    print("Timed out waiting for solution")

# Step 3: Use cf_clearance cookie or token
# The response contains the clearance data needed to access the site

Méthode 2 : automatisation du navigateur avec CaptchaAI

Pour les sessions persistantes, combinez un navigateur sans tête avec CaptchaAI :

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import requests
import time

API_KEY = "YOUR_API_KEY"

# Launch browser
options = webdriver.ChromeOptions()
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)

# Navigate to IUAM page
driver.get("https://iuam-protected-site.com")

# Wait for challenge page to load
time.sleep(3)

# Check if IUAM challenge is present
if "Checking your browser" in driver.page_source or driver.title == "Just a moment...":
    print("IUAM challenge detected")

    # Option A: Wait for browser to solve natively (if not headless)
    try:
        WebDriverWait(driver, 15).until(
            lambda d: "Checking your browser" not in d.page_source
        )
        print("Challenge passed natively")
    except:
        print("Native solve failed — using CaptchaAI")
        # Submit to CaptchaAI for solving
        # Token submission via JavaScript injection

# After challenge is passed, extract cookies for API use
cookies = driver.get_cookies()
cf_clearance = next(
    (c["value"] for c in cookies if c["name"] == "cf_clearance"), None
)

if cf_clearance:
    print(f"cf_clearance obtained: {cf_clearance[:30]}...")

    # Use cookie with requests library
    session = requests.Session()
    for cookie in cookies:
        session.cookies.set(cookie["name"], cookie["value"])
    session.headers.update({
        "User-Agent": driver.execute_script("return navigator.userAgent"),
    })

    # Now make requests with the clearance cookie
    response = session.get("https://iuam-protected-site.com/api/data")
    print(f"Status: {response.status_code}")

driver.quit()

Noeud.js

const axios = require("axios");

const API_KEY = "YOUR_API_KEY";
const TARGET_URL = "https://iuam-protected-site.com/data";

async function solveIUAM() {
  // Submit challenge
  const submit = await axios.post("https://ocr.captchaai.com/in.php", null, {
    params: {
      key: API_KEY,
      method: "cloudflare_challenge",
      sitekey: "managed",
      pageurl: TARGET_URL,
      json: 1,
    },
  });

  const taskId = submit.data.request;
  console.log(`Task submitted: ${taskId}`);

  // Poll for result
  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) {
      console.log("IUAM challenge solved!");
      return result.data.request;
    }
  }

  throw new Error("Timed out");
}

solveIUAM().then((token) => console.log("Token:", token.substring(0, 50)));

Gestion des cookies cf_clearance

Le cookie cf_clearance est le résultat clé de la résolution d'un défi IUAM :

Stratégie de gestion des cookies

import requests
import time

class IUAMSessionManager:
    """Manage cf_clearance cookies for IUAM-protected sites."""

    def __init__(self, api_key, target_url, user_agent=None):
        self.api_key = api_key
        self.target_url = target_url
        self.user_agent = user_agent or (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/120.0.0.0"
        )
        self.session = requests.Session()
        self.session.headers["User-Agent"] = self.user_agent
        self.clearance_time = 0
        self.clearance_lifetime = 1800  # 30 minutes default

    def needs_refresh(self):
        """Check if clearance cookie needs refreshing."""
        return time.time() - self.clearance_time > self.clearance_lifetime - 60

    def solve_challenge(self):
        """Solve IUAM challenge and update session cookies."""
        submit = requests.post("https://ocr.captchaai.com/in.php", data={
            "key": self.api_key,
            "method": "cloudflare_challenge",
            "sitekey": "managed",
            "pageurl": self.target_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": self.api_key,
                "action": "get",
                "id": task_id,
                "json": 1,
            }).json()

            if result.get("status") == 1:
                # Apply clearance to session
                self.clearance_time = time.time()
                return result["request"]

        raise TimeoutError("IUAM solve timed out")

    def get(self, url, **kwargs):
        """Make a GET request, solving IUAM if needed."""
        if self.needs_refresh():
            self.solve_challenge()
        return self.session.get(url, **kwargs)

Dépannage

Questions fréquemment posées

Combien de temps dure cf_clearance ?

La valeur par défaut est de 30 minutes, mais les opérateurs de sites peuvent la configurer de 15 minutes à 24 heures. La plupart des sites utilisent la valeur par défaut de 30 minutes. Prévoyez de rafraîchir avant l'expiration.

Puis-je partager cf_clearance entre les demandes ?

Oui, mais uniquement à partir de la même adresse IP et avec la même chaîne User-Agent. Changer l’un ou l’autre invalidera le cookie.

Le mode Under Attack est-il toujours activé ?

Non. Les opérateurs du site l'activent manuellement lors d'attaques. Certains sites le laissent activé en permanence comme couche de sécurité supplémentaire. Il n'y a aucun moyen de prédire si un site aura IUAM actif.

Quelle est la différence entre IUAM et un défi géré ?

L’IUAM interpelle chaque visiteur sans condition. Les défis gérés utilisent l'évaluation des robots de Cloudflare pour contester de manière sélective le trafic suspect. IUAM renvoie toujours 503 avec un défi JS. Les défis gérés peuvent renvoyer 503 avec un widget Tourniquet à la place.

IUAM affecte-t-il les points de terminaison de l'API ?

Oui. IUAM s'applique à chaque requête sur le domaine, y compris les points de terminaison de l'API. C'est pourquoi les requêtes API provenant de clients non-navigateurs échouent : ils ne peuvent pas exécuter le défi JavaScript.

Résumé

Le mode Under Attack de Cloudflare crée un défi JavaScript obligatoire pour tous les visiteurs, renvoyant HTTP 503 avec une exigence de calcul de 5 secondes. Résolvez les défis de l'IUAM avecSolveur Cloudflare Challenge de CaptchaAI, puis utilisez le cookie cf_clearance pour les demandes ultérieures dans la fenêtre de 30 minutes. Faites toujours correspondre l’adresse IP et l’agent utilisateur entre la résolution et l’utilisation.

Articles connexes

• Cloudflare Challenge vs détection de tourniquet
• Comment fonctionne Cloudflare Challenge
• Procédure pas à pas du flux de session Cloudflare Challenge