Como resolver o CAPTCHA e o desafio da Amazon (AWS WAF) ao fazer raspagem na Web

O AWS WAF (um serviço da Amazon) fornece dois tipos principais de proteção para recursos da Web contra ações automatizadas indesejadas:

• CAPTCHA - exige que o usuário resolva tarefas como inserir texto em um campo específico, mover um controle deslizante, selecionar determinados objetos em uma imagem ou arrastar elementos para um local designado. Além disso, podem ser oferecidos CAPTCHAs de áudio, em que o usuário deve ouvir e reconhecer palavras faladas contra o ruído de fundo e inseri-las no campo apropriado.
• Challenge - Aqui, o usuário não precisa resolver nada para interagir com o site - a verificação ocorre em segundo plano, analisando os parâmetros da sessão e o comportamento da solicitação (como frequência de solicitação, uso de JavaScript, comportamento do mouse e presença ou ausência de cookies). Se a verificação for bem-sucedida, o usuário poderá continuar usando o site. Caso contrário, a solicitação poderá ser bloqueada ou um CAPTCHA poderá ser exibido para verificação adicional. Se o sistema detectar sinais de automação, ele poderá aumentar o nível de verificação para garantir a segurança e proteger o site contra acesso não autorizado.

O sistema de segurança da Amazon foi cuidadosamente projetado e oferece um alto nível de segurança; ele é constantemente atualizado para dificultar o acesso dos bots aos sites. No entanto, para fins de teste de site, análise segura e depuração, ele pode ser resolvido usando o serviço de nuvem CapMonster Cloud.

Encontrando dados de CAPTCHA

Para resolver esse tipo de CAPTCHA, você precisa visitar o site de destino com o CAPTCHA, abrir o Developer Tools e recuperar os dados de CAPTCHA necessários, como websiteKey, contexto, iv e challengeScript.

Aqui está um guia mais detalhado:

1. Carregue a página necessária, abra o Developer Tools, navegue até a guia Rede e localize a linha do documento com uma resposta 405.

2. selecione esse documento e vá para a guia Response:
3. localize o objeto window.gokuProps, onde você encontrará todos os parâmetros necessários.

Tabela com parâmetros obrigatórios e seus valores:

A tarefa é executada usando os servidores proxy do CapMonster Cloud.

Você também pode obter automaticamente os parâmetros para um CAPTCHA do AWS WAF usando o seguinte código JavaScript:

// Extrair parâmetros do CAPTCHA
var gokuProps = window.gokuProps;
var websiteKey = gokuProps ? gokuProps.key : "Não encontrado";
var context = gokuProps ? gokuProps.context : "Não encontrado";
var iv = gokuProps ? gokuProps.iv : "Não encontrado";
// Extrair URLs de script CAPTCHA
var scripts = Array.from(document.querySelectorAll('script'));
var challengeScriptUrl = scripts.find(script => script.src.includes('challenge.js'))?.src || "Não encontrado";
var captchaScriptUrl = scripts.find(script => script.src.includes('captcha.js'))?.src || "Não encontrado";
// Parâmetros de saída e URLs de script
console.log("Chave do site: " + websiteKey);
console.log("Contexto: " + contexto);
console.log("IV: " + iv);
console.log("URL do script de desafio: " + challengeScriptUrl);
console.log("URL do script do Captcha: " + captchaScriptUrl);

{
  "clientKey": "API_KEY",
  "task": {
    "type": "AmazonTaskProxyless",
    "websiteURL": "https://efw47fpad9.execute-api.us-east-1.amazonaws.com/latest",
    "challengeScript": "https://41bcdd4fb3cb.610cd090.us-east-1.token.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/challenge.js",
    "captchaScript": "https://41bcdd4fb3cb.610cd090.us-east-1.captcha.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/captcha.js",
    "websiteKey": "AQIDA....wZwdADFLWk7XOA==",
    "context" (contexto): "qoJYgnKsc...aormh/dYYYK+Y=",
    "iv": "CgAAXFFFFSAAABVk",
    "cookieSolution": true
  }
}

{
  "errorId": 0,
  "taskId": 407533072
}

{
  "errorId": 0,
  "status": "ready" (pronto),
  "solution" (solução): {
    "cookies": {
      "aws-waf-token": "10115f5b-ebd8-45c7-851e-cfd4f6a82e3e:EAoAua1QezAhAAAA:dp7sp2rXIRcnJcmpWOC1vIu+yq/A3EbR6b6K7c67P49usNF1f1bt/Af5pNcZ7TKZlW+jIZ7QfNs8zjjqiu8C9XQq50Pmv2DxUlyFtfPZkGwk0d27Ocznk18/IOOa49Rydx+/XkGA7xoGLNaUelzNX34PlyXjoOtL0rzYBxMAQy0D1tn+Q5u97kJBjs5Mytqu9tXPIPCTSn4dfXv5llSkv9pxBEnnhwz6HEdmdJMdfur+YRW1MgCX7i3L2Y0/CNL8kd8CEhTMzwyoXekrzBM="
    },
    "userAgent": "userAgentPlaceholder"
  }
}

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import os
import requests
import time

# API_KEY para o CapMonster Cloud
API_KEY = os.getenv('CAPMONSTER_API_KEY')
CREATE_TASK_URL = 'https://api.capmonster.cloud/createTask'
GET_TASK_RESULT_URL = 'https://api.capmonster.cloud/getTaskResult'

def create_task(website_key, context, iv, challenge_script_url, captcha_script_url):
    print("Creating task...")
    task_data = {
        "clientKey": API_KEY,
        "task": {
            "type": "AmazonTaskProxyless",
            "websiteURL": 'https://example.com', # Substitua pelo valor correto
            "challengeScript": challenge_script_url,
            "captchaScript": captcha_script_url,
            "websiteKey": website_key,
            "context": contexto,
            "iv": iv,
            "cookieSolution": False # Defina como True se os cookies "aws-waf-token" forem necessários
        }
    }
    response = requests.post(CREATE_TASK_URL, json=task_data)
    response_json = response.json()
    se response_json['errorId'] == 0:
        print(f "Tarefa criada com sucesso. ID da tarefa: {response_json['taskId']}")
        return response_json['taskId']
    else:
        print(f "Erro ao criar a tarefa: {response_json['errorCode']}")
        return None

def get_task_result(task_id):
    print("Obtendo o resultado da tarefa...")
    result_data = {"clientKey": API_KEY, "taskId": task_id}
    while True:
        response = requests.post(GET_TASK_RESULT_URL, json=result_data)
        response_json = response.json()
        se response_json['status'] == 'ready':
            print(f "Resultado da tarefa pronto: {response_json}")
            return response_json
        elif response_json['status'] == 'processing':
            print("A tarefa ainda está sendo processada...")
            time.sleep(5)
        else:
            print(f "Erro ao recuperar o resultado da tarefa: {response_json['errorCode']}")
            return response_json

# Iniciar o navegador
driver = webdriver.Chrome()

try:
    # Abrir a página principal
    print("Abrindo a página...")
    driver.get('https://example.com')
    
    # Digite a cidade para pesquisa
    search_box = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "header-location-search"))
    )
    search_box.send_keys("Moscow") # Substitua pela cidade desejada
    search_box.send_keys(Keys.RETURN)

    # Aguardar a exibição do iframe CAPTCHA
    print("Waiting for iframe...")
    iframe = WebDriverWait(driver, 20).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, 'iframe[src*="execute-api"]'))
    )
    driver.switch_to.frame(iframe)

    print("Esperando pelo CAPTCHA, extraindo parâmetros...")
    WebDriverWait(driver, 20).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, '#captcha-container'))
    )
    goku_props = driver.execute_script("return window.gokuProps;")
    
    website_key = goku_props["key"]
    context = goku_props["context"]
    iv = goku_props["iv"]
    
    challenge_script_url, captcha_script_url = [
        driver.execute_script(f "return document.querySelector('script[src*=\"{x}\"]').src;")
        for x in ("challenge.js", "captcha.js")
    ]

    # Criar e resolver a tarefa CAPTCHA
    task_id = create_task(website_key, context, iv, challenge_script_url, captcha_script_url)
    if task_id:
        result = get_task_result(task_id)
        # Use o resultado para enviar a solução CAPTCHA na página, se necessário

    # Continuar processando os resultados da pesquisa depois de resolver o CAPTCHA
    WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, 'div.locations-list'))  # Substituir pelo valor correto
    )

    first_result = driver.find_element(By.CSS_SELECTOR, 'div.locations-list a') # Substitua pelo valor correto
    primeiro_resultado.click()

    # Ações adicionais...

finalmente:
    print("Fechando o navegador...")
    driver.quit()

• Importações de bibliotecas adicionais:
  pedidos para enviar solicitações HTTP para interagir com a API do CapMonster Cloud e tempo para pausar a execução do código.
• Variáveis de chave de API e URL:
  Variáveis são adicionadas para armazenar a chave de API para autenticação e as URLs para criar tarefas e recuperar resultados do CapMonster Cloud.
• Função de criação de tarefa:
  Uma função que recebe vários parâmetros necessários para criar uma tarefa de resolução de CAPTCHA. Ela envia uma solicitação POST para o servidor do CapMonster Cloud com os dados da tarefa. Se a tarefa for criada com êxito, a função retornará o ID da tarefa.
• Função de resultado da tarefa:
  Uma função que envia uma solicitação POST para verificar o status da tarefa. Se o status da tarefa for "pronto", a função retornará o resultado; caso contrário, ela aguardará e verificará o status novamente.
• Inicialização do navegador e abertura da página de destino:
  Aguarde o campo de pesquisa aparecer, digite o nome da cidade e aguarde o iframe CAPTCHA aparecer.
• Extração de parâmetros do CAPTCHA:
  O código atualizado extrai os valores website_key, context e iv dos scripts do iframe e os utiliza para criar uma tarefa no servidor do CapMonster Cloud.
• Fluxo de trabalho de resolução do CAPTCHA:
  O código agora inclui a criação de uma tarefa e verificações periódicas para determinar se o CAPTCHA foi resolvido. Depois que o CAPTCHA é resolvido, ações adicionais são executadas.

O código fornecido acima é um exemplo que demonstra a lógica geral da execução de ações. Todas as ações e nomes de elementos dependem do site específico e de sua estrutura. Você precisará estudar o código HTML do site e familiarizar-se com a documentação das ferramentas que planeja usar para raspagem da Web. Cada site é único, e a raspagem bem-sucedida pode exigir a adaptação do código e das abordagens, dependendo das características do recurso de destino. Além disso, o trabalho com o Amazon CAPTCHA tem suas nuances que precisam ser consideradas.

Aqui estão algumas dicas gerais úteis para a raspagem bem-sucedida da Web e a solução do Amazon CAPTCHA (AWS WAF):

1. Programação assíncrona: em nosso exemplo simples de raspagem e solução de CAPTCHA, o método assíncrono não é usado. No entanto, se estiver trabalhando com uma grande quantidade de dados ou sites com tempos de resposta lentos, é melhor usar a programação assíncrona para a execução de tarefas paralelas e acelerar o processo.
2. Modo sem cabeça: Execute o navegador no modo headless para acelerar o trabalho e economizar recursos. Sem exibir a interface gráfica do navegador, o processo pode ser mais eficiente.
3. Navegador gráfico: se o site exigir interações complexas que são impossíveis no modo headless, use um navegador gráfico. Isso o ajudará a lidar com elementos da interface, testar melhor o código e evitar alguns erros e bloqueios de sites que podem restringir o acesso ao detectar navegadores sem interface.
4. Alteração do endereço IP e do agente do usuário: para evitar bloqueios e restrições do site, altere regularmente o endereço IP e o agente do usuário. Use servidores proxy de qualidade e altere o User-Agent nas solicitações para que o site não suspeite de comportamento automatizado.
5. Lidar com CAPTCHA dinâmico: A Amazon usa CAPTCHAs que podem mudar dependendo do tempo ou da atividade e atualiza constantemente seus métodos de proteção anti-bot. Certifique-se de que seu script se adapte a essas alterações e as manipule corretamente. Acompanhe as atualizações e as novidades dos serviços de solução de CAPTCHA.
6. Reduzir a frequência das solicitações: Evite fazer solicitações com muita frequência para não chamar a atenção dos sistemas anti-bot da Amazon, ou distribua-as em diferentes endereços IP.

Links úteis:

• AWS WAF Documentation
• Selenium WebDriver Documentation
• CapMonster Cloud API Documentation

A resolução do Amazon CAPTCHA (AWS WAF) pode representar desafios significativos na coleta de dados. No entanto, a compreensão dos princípios básicos de como esse sistema funciona e o uso das ferramentas certas podem ajudar a gerenciar essas tarefas de forma eficaz.

Abordamos os pontos principais, incluindo a descrição desse tipo de CAPTCHA e sua solução usando o CapMonster Cloud. Os estágios mais críticos são a extração precisa dos parâmetros CAPTCHA necessários, a criação e o envio da tarefa ao servidor e a obtenção e o uso da solução CAPTCHA. Também analisamos um exemplo de código Python que demonstra como integrar a solução de CAPTCHA ao processo de raspagem da Web. O sucesso nessa área depende não apenas das habilidades técnicas, mas também da capacidade de se adaptar rapidamente às mudanças e inovações nos métodos de proteção antibot.

Nota: Gostaríamos de lembrá-lo de que o produto é usado para automatizar testes em seus próprios sites e em sites aos quais você tem acesso legal.