Como Resolver CAPTCHA com Selenium em Ruby

CAPTCHAs, ou testes públicos totalmente automatizados de Turing para diferenciar computadores de humanos, são projetados para proteger sites de bots automatizados. Embora desempenhem um papel crucial na segurança de plataformas online, eles podem ser um obstáculo significativo ao automatizar tarefas com ferramentas como Selenium. Se você está trabalhando com Selenium em Ruby e precisa resolver CAPTCHAs, este guia fornecerá uma abordagem passo a passo para lidar com eles de forma eficaz.

O que são Selenium e Ruby?

Antes de mergulharmos na resolução de CAPTCHAs, é essencial entender as ferramentas com as quais você trabalhará: Selenium e Ruby.

• Selenium é uma ferramenta poderosa de código aberto usada para automatizar navegadores da web. Ele permite que os desenvolvedores escrevam scripts em várias linguagens de programação para simular interações do usuário com páginas da web, tornando-se uma escolha popular para testes e web scraping.
• Ruby é uma linguagem de programação dinâmica e orientada a objetos conhecida por sua simplicidade e produtividade. É frequentemente usado no desenvolvimento web e, quando combinado com Selenium, oferece uma estrutura robusta para automatizar tarefas do navegador.

Entendendo CAPTCHAs e seus tipos

Antes de mergulhar na solução, é importante entender os diferentes tipos de CAPTCHAs que você pode encontrar:

• CAPTCHA ImageToText: Esses exigem que o usuário digite caracteres exibidos em uma imagem distorcida. Você pode encontrar alguns casos comuns aqui
• CAPTCHA com base em imagem: Os usuários precisam selecionar imagens que correspondem a um determinado critério (por exemplo, selecione todas as imagens com semáforos). Principalmente do reCAPTCHA
• reCAPTCHA: Sistema CAPTCHA avançado do Google que geralmente requer o reconhecimento de objetos em imagens ou simplesmente clicar em uma caixa de seleção para provar que você não é um bot.

• captcha: Semelhante ao reCAPTCHA, mas frequentemente utilizado por sites que visam soluções mais focadas na privacidade.

Reivindique seu Código de Bônus para as melhores soluções de captcha; CapSolver: WEBS. Após resgatá-lo, você receberá um bônus extra de 5% após cada recarga, Ilimitado

O Selenium Ruby Pode Resolver CAPTCHAs?

Uma das perguntas mais comuns entre desenvolvedores é se o Selenium com Ruby pode resolver CAPTCHAs. A resposta curta é: não diretamente. O Selenium sozinho não possui recursos integrados para resolver CAPTCHAs porque eles são projetados especificamente para diferenciar usuários humanos de bots.
No entanto, existem várias abordagens para lidar com CAPTCHAs no Selenium Ruby:

1. Intervenção Manual: Em alguns casos, os desenvolvedores resolvem manualmente o CAPTCHA durante o processo de automação. No entanto, isso elimina o objetivo da automação completa.
2. Resolvers de CAPTCHA de Terceiros: O método mais eficaz é integrar serviços de terceiros como CapSolver que são especializados em resolver CAPTCHAs usando algoritmos avançados e inteligência humana.
3. Resolvendo CAPTCHAs Simples: Para CAPTCHAs de texto muito básicos, os desenvolvedores podem escrever scripts personalizados para reconhecer padrões, embora essa abordagem seja limitada e frequentemente não confiável.

Embora o Selenium Ruby não possa resolver CAPTCHAs por conta própria, com as ferramentas e serviços certos, é totalmente possível automatizar o processo de contornar CAPTCHAs, o que exploraremos neste guia.

Configurando o Selenium em Ruby

Preparação

• Google Chrome: Instale a versão mais recente do navegador Chrome, pois usaremos código para interagir com o Chrome.
• Ruby: Certifique-se de que o Ruby está instalado em seu computador.
• Selenium-webdriver: A biblioteca Ruby para a ferramenta de automação Selenium.
• CapSolver: A documentação oficial do CapSolver ajudará você a resolver CAPTCHAs.

Depois que o Ruby estiver instalado em seu computador, você pode instalar a biblioteca Selenium WebDriver executando o comando gem install selenium-webdriver. Verifique sua versão do Chrome e, com base nela, faça o download do driver chromedriver.exe correspondente. Você pode encontrar os links para download nos seguintes locais:

• Link para download 1: Fornece as versões Estável, Beta, Dev e Canary mais recentes do driver.
• Link para download 2: Fornece todos os drivers da versão 113 em diante.
• Link para download 3: Fornece todos os drivers para versões anteriores à 113.

Analisando o Site Alvo

Usaremos o site https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php como exemplo para resolver o reCAPTCHA usando Ruby Selenium.

Antes de começar, precisamos entender os conceitos básicos do envio de formulários HTML. Ao observar esta página e abrir as ferramentas de desenvolvedor, podemos resolver manualmente o reCAPTCHA e, em seguida, clicar no botão enviar. Essa ação envia uma solicitação POST, enviando três campos: ex-a, ex-b e g-recaptcha-response, como mostrado abaixo:

Esses três campos correspondem a dois elementos de entrada e um elemento de área de texto sob o formulário no código-fonte HTML inicial, como mostrado abaixo:

Automatizando o Processo com Ruby Selenium

Como podemos automatizar todo o processo usando Ruby Selenium? Os passos são os seguintes:

1. Ruby direciona o Selenium para visitar o site-alvo.
2. Ruby chama a API CapSolver para resolver o reCAPTCHA e obter um token.
3. Altera o estilo CSS do elemento textarea de display: none para display: block para torná-lo interativo com o Selenium.
4. Simula a inserção do token retornado pelo CapSolver no elemento textarea.
5. Simula o clique no botão de envio para enviar o formulário e concluir a verificação.

Visitando o Site-Alvo com Ruby Selenium

Certifique-se de substituir o driver_path no código abaixo pelo caminho real para chromedriver em seu computador.

require 'selenium-webdriver'

# Inicializa as opções do navegador Chrome e acessa o site-alvo
driver_path = "path/to/chromedriver.exe"
options = Selenium::WebDriver::Chrome::Options.new
service = Selenium::WebDriver::Service.chrome(path: driver_path)
driver = Selenium::WebDriver.for :chrome, options: options, service: service
url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
driver.navigate.to url

Obtendo o Token

Para usar a API CapSolver, precisamos fornecer o websiteKey, que pode ser encontrado pesquisando pela palavra-chave data-sitekey na fonte da página:

Agora, vamos escrever o código Ruby para usar a API CapSolver para resolver o reCAPTCHA automaticamente:

require 'net/http'
require 'json'
require 'time'

def cap_solver(api_key, public_key, page_url)
  payload = {
    "clientKey" => api_key,
    "task" => {
      "type" => 'ReCaptchaV2TaskProxyLess',
      "websiteKey" => public_key,
      "websiteURL" => page_url,
    }
  }

  # Envia uma solicitação de criação de tarefa

require 'selenium-webdriver'
require 'net/http'
require 'json'
require 'time'

def cap_solver(api_key, website_key, page_url)
  payload = {
    "clientKey" => api_key,
    "task" => {
      "type" => 'ReCaptchaV2TaskProxyLess',
      "websiteKey" => website_key,
      "websiteURL" => page_url,
    }
  }

  # Envia uma solicitação de criação de tarefa
  uri = URI("https://api.capsolver.com/createTask")
  res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
  resp = JSON.parse(res.body)
  task_id = resp["taskId"]

  unless task_id
    puts "Falha ao criar a tarefa: #{res.body}"
    return
  end

  puts "Obteve taskId: #{task_id}"

  # Loop aguardando para obter os resultados da tarefa
  loop do
    sleep(1)
    payload = { "clientKey" => api_key, "taskId" => task_id }
    uri = URI("https://api.capsolver.com/getTaskResult")
    res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
    resp = JSON.parse(res.body)
    status = resp["status"]
    if status == "ready"
      token = resp.dig("solution", "gRecaptchaResponse")
      puts "Solução bem-sucedida, token: #{token}"
      return token
    elsif status == "processing"
      puts "Solução em andamento..."
    elsif status == "failed"
      puts "Solução falhou! resposta: #{res.body}"
      return
    end
  end
end

# Configura o driver do Selenium
driver = Selenium::WebDriver.for :chrome

# Define as credenciais CapSolver
cap_solver_api_key = 'YOUR_API_KEY'

# Define o URL da página que deseja automatizar
page_url = 'https://www.google.com/recaptcha/api2/demo'

# Define a chave do site do reCAPTCHA
website_key = '6LeIxAcTAAAAAJcOh9v-2s7srZN59R-w46x8-z5'

# Resolve o reCAPTCHA
token = cap_solver(cap_solver_api_key, website_key, page_url)

# Visita a página e completa o reCAPTCHA
driver.get(page_url)

# Encontra o elemento reCAPTCHA
recaptcha_frame = driver.find_element(:tag_name, 'iframe')

# Muda o contexto para o frame reCAPTCHA
driver.switch_to.frame(recaptcha_frame)

# Encontra o elemento de entrada do token
token_input = driver.find_element(:id, 'g-recaptcha-response')

# Define o token resolvido
token_input.send_keys(token)

# Muda o contexto para o frame principal
driver.switch_to.default_content

# Clique no botão "Enviar" (ajustar o seletor conforme necessário)
driver.find_element(:id, 'recaptcha-demo-submit').click

# Aguarde o carregamento da página
sleep(5)

# Imprima o conteúdo da página
puts driver.page_source

# Feche o driver do Selenium
driver.quit

  sleep(1)
  payload = { "clientKey" => api_key, "taskId" => task_id }
  uri = URI("https://api.capsolver.com/getTaskResult")
  res = Net::HTTP.post(uri, payload.to_json, { "Content-Type" => "application/json" })
  resp = JSON.parse(res.body)
  status = resp["status"]
  if status == "ready"
    token = resp.dig("solution", "gRecaptchaResponse")
    puts "Solução bem-sucedida, token: #{token}"
    return token
  elsif status == "processing"
    puts "Solução em andamento..."
  elsif status == "failed"
    puts "Solução falhou! resposta: #{res.body}"
    return
  end
end

# Inicializa as opções do navegador Chrome e acessa o site de destino
driver_path = "path/to/chromedriver.exe"
options = Selenium::WebDriver::Chrome::Options.new
service = Selenium::WebDriver::Service.chrome(path: driver_path)
driver = Selenium::WebDriver.for :chrome, options: options, service: service
url = "https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php"
driver.navigate.to url

# Chamada da API CapSolver para resolver o ReCaptcha
cap_solver_api_key = 'YOUR_API_KEY'
website_key = '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9'
token = cap_solver(cap_solver_api_key, website_key, url)
if token.nil? || token.empty?
  puts "Falha ao resolver o captcha, pressione qualquer tecla para sair."
  STDIN.gets
  driver.quit
  return
end

# Altera a propriedade de estilo de exibição da área de texto para bloco para torná-la visível
driver.execute_script("document.getElementById('g-recaptcha-response').style.display = 'block';")
# Simula a entrada do token na área de texto
textarea = driver.find_element(id: 'g-recaptcha-response')
textarea.send_keys(token)
# Simula o clique e o envio de um formulário
submit_btn = driver.find_element(css: "button[type='submit']")
submit_btn.click

puts "Pressione qualquer tecla para sair."
STDIN.gets
driver.quit

Mais Informações

CapSolver usa tecnologia de desbloqueio web automática baseada em IA para ajudá-lo a resolver CAPTCHAs em segundos. Ele pode resolver não apenas o reCAPTCHA, mas também o captcha, captcha, Cloudflare Turnstile, captcha, captcha WAF e muito mais. O CapSolver também fornece SDKs em várias linguagens, bem como extensões de navegador. Você pode consultar a documentação do CapSolver para obter mais informações.