Como resolver o AWS Captcha / Desafio com PHP: Um Guia Completo

Resumo (Muito Longo; Não Li)

Este guia fornece um tutorial completo e passo a passo sobre como contornar o CAPTCHA e as páginas de desafio do AWS WAF usando PHP e a API CapSolver. Detalhamos a lógica para detectar tanto o CAPTCHA (HTTP 405) quanto o desafio (HTTP 202), extrair os parâmetros necessários e usar o cookie aws-waf-token resultante para acessar o recurso protegido.

Introdução

Bem-vindo a este guia abrangente, onde exploraremos o mundo do CAPTCHA do AWS e como implementar um solucionador PHP para ele. Para desenvolvedores e raspadores de web, encontrar um CAPTCHA pode ser uma barreira significativa, mas com as ferramentas certas, torna-se uma tarefa gerenciável.

O que é AWS WAF CAPTCHA e Desafio?

AWS WAF (Web Application Firewall) é um serviço de segurança que ajuda a proteger aplicações web contra explorações comuns. Ele oferece duas ações principais para verificar se uma solicitação vem de um usuário humano legítimo, em vez de um robô: CAPTCHA e Desafio.

Visão Geral das Ações do AWS WAF

Após resolver com sucesso o CAPTCHA ou o Desafio, o AWS WAF emite um token válido, que é retornado como o valor de um cookie chamado aws-waf-token. Este token deve ser incluído em solicitações subsequentes para contornar a proteção do WAF.

🔎 Resolvendo AWS Captcha / Desafio usando PHP e CapSolver

O CapSolver fornece uma solução robusta de API para lidar com o Desafio silencioso e o CAPTCHA visual apresentados pelo AWS WAF. Este guia se concentra no uso da biblioteca cURL do PHP para implementar a lógica necessária.

📕 Requisitos

• PHP (com a extensão cURL habilitada)
• cURL
• Chave da API do CapSolver (Você pode obter uma se inscrevendo no CapSolver)

🛠️ Etapa 1: Configurando o Ambiente e Funções Auxiliares

O núcleo da nossa solução envolve duas chamadas principais à API do CapSolver: createTask para enviar o CAPTCHA/Desafio e getTaskResult para recuperar a solução.

<?php

// --- Configuração ---
$PROXY = "http://username:password@host:port"; // OPCIONAL: Substitua pelas suas informações de proxy (ex.: para AntiAwsWafTask)
$PAGE_URL = "https://norway-meetup.aws.wslab.no/";  // Substitua pela URL alvo protegida pelo AWS WAF
$CLIENT_KEY = "YourPayPerUsage";  // Substitua pela sua chave da API CAPSOLVER

/**
 * Envia uma tarefa para a API CapSolver.
 * @param array $payload O payload da tarefa contendo tipo e parâmetros.
 * @return array A resposta da API, incluindo o taskId.
 */
function createTask($payload) {
    global $CLIENT_KEY;
    $ch = curl_init();
    echo("Criando tarefa...\n");
    curl_setopt($ch, CURLOPT_URL, 'https://api.capsolver.com/createTask');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['clientKey' => $CLIENT_KEY, 'task' => $payload]));
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

/**
 * Consulta a API CapSolver para obter o resultado da tarefa.
 * @param string $taskId O ID da tarefa a ser verificada.
 * @return array A resposta da API contendo a solução.
 */
function getTaskResult($taskId) {
    global $CLIENT_KEY;
    do {
        echo("Aguardando solução...\n");
        sleep(1);
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, 'https://api.capsolver.com/getTaskResult');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['clientKey' => $CLIENT_KEY, 'taskId' => $taskId]));
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
        $response = curl_exec($ch);
        curl_close($ch);
        $data = json_decode($response, true);
        
        if (isset($data['status']) && $data['status'] == "ready") {
            return $data;
        }
        
        // Tratamento de possíveis erros da getTaskResult
        if (isset($data['errorId']) && $data['errorId'] != 0) {
            echo("Erro ao recuperar o resultado da tarefa: " . $data['errorDescription'] . "\n");
            return null;
        }
        
    } while(true);
}

/**
 * Resolve o Desafio ou Captcha do AWS WAF usando o tipo de tarefa apropriado.
 * @param string $taskType O tipo de tarefa do CapSolver (AntiAwsWafTask ou AwsCaptchaTask).
 * @param array $params Os parâmetros necessários para a tarefa.
 * @return string|null O valor do cookie aws-waf-token ou null em caso de falha.
 */
function solveAwsWaf($taskType, $params) {
    global $PAGE_URL, $PROXY;
    
    $payload = [
        'type' => $taskType,
        'websiteURL' => $PAGE_URL,
        'proxy' => $PROXY,
    ];
    
    // Mescla os parâmetros específicos para a tarefa
    $payload = array_merge($payload, $params);
    
    // Limpa valores vazios para uma solicitação mais limpa
    $payload = array_filter($payload, function($value) {
        return $value !== "" && $value !== null;
    });

    $taskData = createTask($payload);
    
    if (isset($taskData['taskId'])) {
        $result = getTaskResult($taskData['taskId']);
        if ($result && isset($result['solution']['cookie'])) {
            return $result['solution']['cookie'];
        }
    }
    
    return null;
}

⚡ Etapa 2: Implementando a Lógica de Detecção e Resolução do WAF

A lógica principal envolve fazer uma solicitação inicial à página protegida e verificar o código de status HTTP para determinar se um Desafio (202) ou CAPTCHA (405) é necessário. Em seguida, usamos expressões regulares para extrair os parâmetros necessários do corpo da resposta HTML.

// --- Lógica de Execução Principal ---

// 1. Solicitação inicial à página protegida
$ch = curl_init($PAGE_URL);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$cookie = null;

echo("Código HTTP Inicial: " . $httpCode . "\n");

if ($httpCode == 202) {
    // --- Tratamento do Desafio (202) ---
    echo("Desafio detectado (HTTP 202). Extraindo parâmetros...\n");
    
    // Extrai a URL do challenge.js
    preg_match('/<script src="([^"]*token.awswaf.com[^"]*)"/', $response, $matches);
    $awsChallengeJS = $matches[1] ?? null;
    
    if ($awsChallengeJS) {
        $params = ['awsChallengeJS' => $awsChallengeJS];
        $cookie = solveAwsWaf("AntiAwsWafTask", $params);
    } else {
        echo("Erro: awsChallengeJS não encontrado para o Desafio.\n");
    }

} elseif ($httpCode == 405) {
    // --- Tratamento do CAPTCHA (405) ---
    echo("CAPTCHA detectado (HTTP 405). Extraindo parâmetros...\n");
    
    // Extrai parâmetros do conteúdo da página
    preg_match('/<script src="([^"]*token.awswaf.com[^"]*)"/', $response, $matches);
    $awsChallengeJS = $matches[1] ?? null;
    
    preg_match('/"key":"(.*?)"/', $response, $matches);
    $awsKey = $matches[1] ?? null;
    
    preg_match('/"iv":"(.*?)"/', $response, $matches);
    $awsIv = $matches[1] ?? null;
    
    preg_match('/"context":"(.*?)"/', $response, $matches);
    $awsContext = $matches[1] ?? null;
    
    if ($awsKey && $awsIv && $awsContext) {
        $params = [
            'awsKey' => $awsKey,
            'awsIv' => $awsIv,
            'awsContext' => $awsContext,
            'awsChallengeJS' => $awsChallengeJS // Opcional, mas recomendado
        ];
        // Observação: O tipo de tarefa para o CAPTCHA visual geralmente ainda é AntiAwsWafTask, 
        // mas os parâmetros passados determinam o tipo de solução no lado do CapSolver.
        $cookie = solveAwsWaf("AntiAwsWafTask", $params); 
    } else {
        echo("Erro: Parâmetros key, iv ou context não encontrados para o CAPTCHA.\n");
    }
}

// 3. Use o token para acessar o recurso protegido
if ($cookie) {
    echo("Obteve com sucesso o aws-waf-token. Fazendo a solicitação final...\n");
    
    $ch = curl_init($PAGE_URL);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    // Define o cookie aws-waf-token
    curl_setopt($ch, CURLOPT_COOKIE, "aws-waf-token=" . $cookie);
    
    $finalResponse = curl_exec($ch);
    curl_close($ch);
    
    echo "\n--- Conteúdo da Página Final ---\n";
    echo $finalResponse;
    echo "\n--------------------------\n";
} else {
    echo("Falha em resolver o desafio/captcha do AWS WAF.\n");
}

?>

Notas de Otimização do Código

O código original usava funções separadas (solveAwsChallenge, solveAwsCaptcha) e nomes de parâmetros ligeiramente inconsistentes (key, iv, context vs. awsKey, awsIv, awsContext). O código otimizado simplifica isso em uma única função solveAwsWaf, garantindo consistência com a documentação mais recente da API do CapSolver para resolver o AWS WAF. Essa abordagem é mais modular e fácil de manter.

Essa lógica é altamente eficaz para tarefas de raspagem e automação. Para aqueles que trabalham em outras linguagens, o CapSolver também fornece guias como "Como resolver AWS Captcha / Desafio com Python" [https://www.capsolver.com/blog/how-to-solve-aws-captcha-challenge-with-python] que seguem um padrão de API semelhante.

Conclusão

As mecanismos de Desafio e CAPTCHA do AWS WAF são medidas eficazes contra bots, mas não são insuperáveis. Ao implementar uma lógica de detecção e resolução robusta em PHP, aproveitando a força da API CapSolver, os desenvolvedores podem obter confiavelmente o aws-waf-token necessário para continuar suas tarefas de raspagem ou automação sem interrupções. A chave está em identificar corretamente a ação do WAF pelo código de status HTTP e extrair com precisão os parâmetros necessários da fonte da página.

Pontos Principais

• Ações do AWS WAF: O AWS WAF usa um Desafio silencioso (HTTP 202) ou um CAPTCHA visual (HTTP 405) para bloquear bots.
• Objetivo: O objetivo final é obter o valor do cookie aws-waf-token.
• API CapSolver: O tipo de tarefa AntiAwsWafTask lida com a resolução de Desafio e CAPTCHA, com os parâmetros necessários determinando a solução específica.
• Implementação em PHP: A biblioteca cURL do PHP é usada para solicitações, e preg_match é essencial para extrair parâmetros dinâmicos como awsChallengeJS, awsKey, awsIv e awsContext da fonte HTML.
• Confiabilidade: Para automação estável e de alto volume, integrar um solucionador especializado como o CapSolver é crucial, conforme detalhado em recursos como Solução de CAPTCHA do AWS WAF: Token e Solução de Imagem para Raspagem

Perguntas Frequentes: Perguntas Mais Comuns

Q1: Por que preciso verificar o código de status HTTP (202 ou 405)?

A: O código de status HTTP é o indicador mais confiável do tipo de ação do WAF necessária. Um código de status 202 Aceito indica que um Desafio silencioso está ativo, que requer poucos parâmetros. Um código de status 405 Método Não Permitido indica que um CAPTCHA visual está ativo, que requer parâmetros mais específicos (key, iv, context) para ser extraído das variáveis JavaScript da página.

Q2: Qual é a diferença entre AntiAwsWafTask e AntiAwsWafTaskProxyLess?

A: Ambos os tipos de tarefa são projetados para resolver os desafios do AWS WAF. A principal diferença é a exigência de proxy. AntiAwsWafTask requer que você forneça seu próprio proxy no payload da solicitação. AntiAwsWafTaskProxyLess não exige um proxy, pois o CapSolver lida com o uso de proxy internamente. Usar um proxy é frequentemente recomendado para raspagem em larga escala para manter anonimato e evitar banimentos de IP.

Q3: Meu script falha em encontrar os parâmetros key, iv ou context. O que devo fazer?

A: Esses parâmetros são gerados dinamicamente e embutidos na fonte HTML, geralmente dentro de uma tag <script> ou um campo de entrada oculto. Se o preg_match falhar, é provável devido a mudanças na implementação do WAF do site alvo. Você deve inspecionar a fonte HTML mais recente da página bloqueada para atualizar suas expressões regulares.

Q4: Posso resolver o AWS WAF sem usar um serviço de terceiros?

A: Resolver manualmente os desafios do AWS WAF é extremamente difícil e impraticável para automação. A ação de Desafio requer a execução de JavaScript complexo e obfuscado, e a ação de CAPTCHA requer resolver quebra-cabeças de reconhecimento de imagem. Serviços de terceiros como CapSolver usam inteligência artificial avançada e infraestrutura em larga escala para resolver esses desafios em tempo real, tornando a automação viável. Tentar construir um solucionador interno para cada tipo de CAPTCHA geralmente não é economicamente viável ou confiável.

Q5: Por quanto tempo o aws-waf-token é válido?

A: O período de validade do aws-waf-token é determinado pela configuração do AWS WAF do site protegido, mas geralmente é de cerca de 10 a 30 minutos. Após expirar o token, você precisará repetir o processo de resolução (solicitação inicial, detecção e submissão da tarefa) para obter um novo token.