Como lidar com Cloudflare sob modo de ataque

O “Modo Estou Sob Ataque” (IUAM) da Cloudflare é uma defesa DDoS que força cada visitante a passar por um desafio JavaScript de 5 segundos antes de acessar o site. É o modo de proteção mais agressivo da Cloudflare, acionado manualmente pelos operadores do site durante ataques ou ativado permanentemente em sites de alto risco. Para acesso automatizado, o IUAM cria um desafio JavaScript obrigatório que os clientes HTTP tradicionais não conseguem superar.

O que a IUAM faz

Quando um operador de site ativa o "Modo Estou Sob Ataque" no painel da Cloudflare:

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

A página do desafio IUAM

A página de desafio retorna HTTP 503 e contém:

Características principais

• HTTP 503 código de status (NÃO 403)
• Espera obrigatória de 5 segundos antes do envio do desafio
• É necessária execução de JavaScript — falha em clientes HTTP simples
• cookie_qa_validacao cookie – válido por aproximadamente 30 minutos, permite solicitações subsequentes
• Em todo o domínio — cada página do domínio mostra o desafio

Identificando IUAM versus outras proteções da 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 Turnstile em staging (generic)"

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

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

Tabela de detecção

Como funciona o desafio JavaScript

O desafio JavaScript da IUAM foi projetado para verificar se o visitante possui um navegador real:

Fluxo do desafio

1. Cloudflare disponibiliza página de desafio com JavaScript ofuscado
2. JavaScript realiza cálculos: - Operações matemáticas em strings da página - Medições DOM - Aplicação de tempo (mínimo 4-5 segundos)
3. Resposta calculada — um valor numérico baseado no desafio
4. Formulário enviado automaticamente para Cloudflare com jschl_vc, pass e jschl_answer
5. Cloudflare valida resposta e tempo
6. Cookie cookie_qa_validacao retornado — permite acesso por aproximadamente 30 minutos

Por que os clientes HTTP falham

# 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

Resolvendo IUAM com CaptchaAI

Método 1: solucionador Cloudflare Turnstile em staging (recomendado)

O método turnstile_staging do CaptchaAI lida diretamente com os desafios do 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": "turnstile_staging",
    "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 cookie_qa_validacao cookie or token
# The response contains the clearance data needed to access the site

Método 2: automação do navegador com CaptchaAI

Para sessões persistentes, combine um navegador headless com 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()
cookie_qa_validacao = next(
    (c["value"] for c in cookies if c["name"] == "cookie_qa_validacao"), None
)

if cookie_qa_validacao:
    print(f"cookie_qa_validacao obtained: {cookie_qa_validacao[: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()

Node.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: "turnstile_staging",
      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)));

Gerenciando cookies cookie_qa_validacao

O cookie cookie_qa_validacao é o principal resultado para resolver um desafio IUAM:

Estratégia de gerenciamento de cookies

import requests
import time

class IUAMSessionManager:
    """Manage cookie_qa_validacao 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": "turnstile_staging",
            "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)

Solução de problemas

Perguntas frequentes

Quanto tempo dura cookie_qa_validacao?

O padrão é 30 minutos, mas os operadores do site podem configurá-lo de 15 minutos a 24 horas. A maioria dos sites usa o padrão de 30 minutos. Planeje atualizar antes de expirar.

Posso compartilhar cookie_qa_validacao entre solicitações?

Sim, mas apenas do mesmo endereço IP e com a mesma string User-Agent. Alterar qualquer um deles invalidará o cookie.

O modo Under Attack está sempre ativado?

Não. Os operadores do site alternam-no manualmente durante os ataques. Alguns sites o deixam permanentemente ativado como uma camada extra de segurança. Não há como prever se um local terá o IUAM ativo.

Qual é a diferença entre IUAM e um Desafio Gerenciado?

A IUAM desafia cada visitante incondicionalmente. Os Desafios Gerenciados usam a avaliação de bot da Cloudflare para desafiar seletivamente o tráfego suspeito. IUAM sempre retorna 503 com um desafio JS. Os Desafios Gerenciados podem retornar 503 com um widget Cloudflare Turnstile.

O IUAM afeta os endpoints da API?

Sim. O IUAM se aplica a todas as solicitações no domínio, incluindo endpoints de API. É por isso que as solicitações de API de clientes que não são navegadores falham: eles não conseguem executar o desafio JavaScript.

Resumo

O modo Under Attack da Cloudflare cria um desafio JavaScript obrigatório para todos os visitantes, retornando HTTP 503 com um requisito de computação de 5 segundos. Resolva os desafios da IUAM comSolucionador Cloudflare Turnstile em staging de CaptchaAIe use o cookie cookie_qa_validacao para solicitações subsequentes dentro do período de 30 minutos. Sempre combine o endereço IP e o User-Agent entre a solução e o uso.

Artigos relacionados

• Cloudflare Turnstile em staging vs detecção de catraca
• Como funciona o Cloudflare Turnstile em staging
• Passo a passo do fluxo da sessão Cloudflare Turnstile em staging