anticaptchaofficial 1.0.1

data/lib/anticaptcha/client.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Anticaptcha
+  # Talks to the Anti-Captcha API.
+  #
+  #   client = Anticaptcha::Client.new("API_KEY_HERE")
+  #   solution = client.solve_recaptcha_v2(
+  #     website_url: "https://www.website.com/",
+  #     website_key: "SITE_KEY"
+  #   )
+  #   puts solution.g_recaptcha_response
+  class Client
+    API_HOST = "https://api.anti-captcha.com/"
+
+    # Your key from https://anti-captcha.com/clients/settings/apisetup
+    attr_accessor :api_key
+
+    # Specify a soft id to earn 10% commission with your app.
+    # Get yours at https://anti-captcha.com/clients/tools/devcenter
+    attr_accessor :soft_id
+
+    # Debug output goes to stderr. On by default.
+    attr_accessor :verbose
+
+    # Timeout of a single HTTP call to the API, in seconds.
+    attr_accessor :connection_timeout
+
+    # Seconds to wait before the first status request.
+    attr_accessor :first_attempt_waiting_interval
+
+    # Seconds to wait between the following status requests.
+    attr_accessor :normal_waiting_interval
+
+    # Seconds to keep polling before giving up.
+    attr_accessor :max_waiting_time
+
+    # Full getTaskResult response of the last solved task.
+    attr_reader :last_task_info
+
+    def initialize(api_key = nil, soft_id: 0, verbose: true)
+      @api_key = api_key
+      @soft_id = soft_id
+      @verbose = verbose
+      @connection_timeout = 30
+      @first_attempt_waiting_interval = 5
+      @normal_waiting_interval = 5
+      @max_waiting_time = 300
+      @last_task_info = nil
+    end
+
+    # Account balance in US dollars.
+    def balance
+      json_request("getBalance")["balance"]
+    end
+    alias get_balance balance
+
+    # Number of prepaid captcha credits on the account.
+    def credits_balance
+      json_request("getBalance")["captchaCredits"] || 0
+    end
+    alias get_credits_balance credits_balance
+
+    # Calls any API method with your own payload. The client key is added for you.
+    def json_request(method, payload = {})
+      raise InvalidTaskError, "API key is not set" if api_key.to_s.empty?
+
+      url = URI.join(API_HOST, method)
+      log "POST #{url}"
+
+      body = post_json(url, payload.merge("clientKey" => api_key))
+      response = parse_json(body)
+      error_id = response["errorId"]
+
+      unless error_id.is_a?(Integer)
+        raise BadResponseError.new("the API response carries no errorId", shorten(body))
+      end
+
+      return response if error_id.zero?
+
+      raise ApiError.new(error_id, response["errorCode"].to_s,
+                         response["errorDescription"] || "(no error description)")
+    end
+
+    # Submits a task and returns its id.
+    def create_task(task)
+      log "Creating task: #{JSON.generate(task)}"
+
+      response = json_request("createTask", "task" => task, "softId" => soft_id)
+      task_id = response["taskId"]
+
+      unless task_id.is_a?(Integer)
+        raise BadResponseError.new("API did not return a task id", shorten(JSON.generate(response)))
+      end
+
+      log "Task id: #{task_id}"
+
+      task_id
+    end
+
+    # Polls until the task is solved or the waiting limit runs out.
+    def wait_for_result(task_id)
+      deadline = monotonic_now + max_waiting_time
+      interval = first_attempt_waiting_interval
+
+      loop do
+        log "Waiting #{interval} seconds..."
+        sleep interval
+        interval = normal_waiting_interval
+
+        response = json_request("getTaskResult", "taskId" => task_id)
+
+        case response["status"]
+        when "ready"
+          @last_task_info = response
+          solution = Solution.new(response["solution"], task_id: task_id, cost: response["cost"].to_f)
+
+          if solution.empty?
+            raise BadResponseError.new("the task is ready but carries no solution",
+                                       shorten(JSON.generate(response)))
+          end
+
+          log "The task is complete"
+
+          return solution
+        when "processing"
+          if monotonic_now >= deadline
+            raise TimeoutError,
+                  "the task was not solved in #{max_waiting_time} seconds"
+          end
+
+          log "The task is still processing..."
+        else
+          raise BadResponseError.new(
+            "unknown task status #{response["status"].inspect}, please update the library",
+            shorten(JSON.generate(response))
+          )
+        end
+      end
+    end
+
+    # Sends a task type this library does not wrap yet, and waits for the result.
+    # See https://anti-captcha.com/apidoc/task-types for the "task" object shape.
+    def solve_task(task)
+      wait_for_result(create_task(task))
+    end
+
+    # ------------------------------------------------------------------ tasks
+
+    def solve_image(**options)
+      solve_task(Tasks.image(**options))
+    end
+
+    def solve_image_file(path, **options)
+      solve_image(body: self.class.file_to_base64(path), **options)
+    end
+
+    def solve_image_to_coordinates(**options)
+      solve_task(Tasks.image_to_coordinates(**options))
+    end
+
+    def solve_image_to_coordinates_file(path, **options)
+      solve_image_to_coordinates(body: self.class.file_to_base64(path), **options)
+    end
+
+    def solve_recaptcha_v2(**options)
+      solve_task(Tasks.recaptcha_v2(**proxyless(options)))
+    end
+
+    def solve_recaptcha_v2_proxy_on(proxy:, **options)
+      solve_task(Tasks.recaptcha_v2(proxy: proxy, **options))
+    end
+
+    def solve_recaptcha_v3(**options)
+      solve_task(Tasks.recaptcha_v3(**options))
+    end
+
+    def solve_hcaptcha(**options)
+      solve_task(Tasks.hcaptcha(**proxyless(options)))
+    end
+
+    def solve_hcaptcha_proxy_on(proxy:, **options)
+      solve_task(Tasks.hcaptcha(proxy: proxy, **options))
+    end
+
+    def solve_funcaptcha(**options)
+      solve_task(Tasks.funcaptcha(**proxyless(options)))
+    end
+
+    def solve_funcaptcha_proxy_on(proxy:, **options)
+      solve_task(Tasks.funcaptcha(proxy: proxy, **options))
+    end
+
+    def solve_geetest(**options)
+      solve_task(Tasks.geetest(**proxyless(options)))
+    end
+
+    def solve_geetest_proxy_on(proxy:, **options)
+      solve_task(Tasks.geetest(proxy: proxy, **options))
+    end
+
+    def solve_turnstile(**options)
+      solve_task(Tasks.turnstile(**proxyless(options)))
+    end
+
+    def solve_turnstile_proxy_on(proxy:, **options)
+      solve_task(Tasks.turnstile(proxy: proxy, **options))
+    end
+
+    def solve_prosopo(**options)
+      solve_task(Tasks.prosopo(**proxyless(options)))
+    end
+
+    def solve_prosopo_proxy_on(proxy:, **options)
+      solve_task(Tasks.prosopo(proxy: proxy, **options))
+    end
+
+    def solve_friendly_captcha(**options)
+      solve_task(Tasks.friendly_captcha(**proxyless(options)))
+    end
+
+    def solve_friendly_captcha_proxy_on(proxy:, **options)
+      solve_task(Tasks.friendly_captcha(proxy: proxy, **options))
+    end
+
+    def solve_altcha(**options)
+      solve_task(Tasks.altcha(**proxyless(options)))
+    end
+
+    def solve_altcha_proxy_on(proxy:, **options)
+      solve_task(Tasks.altcha(proxy: proxy, **options))
+    end
+
+    def solve_amazon(**options)
+      solve_task(Tasks.amazon(**proxyless(options)))
+    end
+
+    def solve_amazon_proxy_on(proxy:, **options)
+      solve_task(Tasks.amazon(proxy: proxy, **options))
+    end
+
+    def solve_antigate(**options)
+      solve_task(Tasks.antigate(**options))
+    end
+
+    def solve_antibot_cookie(**options)
+      solve_task(Tasks.antibot_cookie(**options))
+    end
+
+    # ---------------------------------------------------------------- reports
+
+    def report_incorrect_image_captcha(task_id)
+      json_request("reportIncorrectImageCaptcha", "taskId" => task_id)
+
+      nil
+    end
+
+    def report_incorrect_recaptcha(task_id)
+      json_request("reportIncorrectRecaptcha", "taskId" => task_id)
+
+      nil
+    end
+
+    def report_correct_recaptcha(task_id)
+      json_request("reportCorrectRecaptcha", "taskId" => task_id)
+
+      nil
+    end
+
+    def report_incorrect_hcaptcha(task_id)
+      json_request("reportIncorrectHcaptcha", "taskId" => task_id)
+
+      nil
+    end
+
+    # ---------------------------------------------------------------- helpers
+
+    # Reads a file and encodes it in base64.
+    def self.file_to_base64(path)
+      to_base64(File.binread(path))
+    rescue SystemCallError, IOError => e
+      raise InvalidTaskError, "could not read #{path}: #{e.message}"
+    end
+
+    # Encodes bytes in base64.
+    def self.to_base64(bytes)
+      [bytes].pack("m0")
+    end
+
+    private
+
+    def proxyless(options)
+      raise InvalidTaskError, "pass the proxy to the *_proxy_on method instead" if options.key?(:proxy)
+
+      options
+    end
+
+    def post_json(url, payload)
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.open_timeout = connection_timeout
+      http.read_timeout = connection_timeout
+
+      request = Net::HTTP::Post.new(url.request_uri,
+                                    "Content-Type" => "application/json",
+                                    "Accept" => "application/json",
+                                    "User-Agent" => "anticaptcha-ruby/#{Anticaptcha::VERSION}")
+      request.body = JSON.generate(payload)
+
+      response = http.request(request)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise BadResponseError.new("API answered with HTTP #{response.code}", shorten(response.body))
+      end
+
+      response.body
+    rescue Timeout::Error => e
+      raise NetworkError, "request to #{url} timed out after #{connection_timeout} seconds: #{e.message}"
+    rescue SystemCallError, SocketError, IOError, OpenSSL::SSL::SSLError => e
+      raise NetworkError, "request to #{url} failed: #{e.message}"
+    end
+
+    def parse_json(body)
+      parsed = JSON.parse(body.to_s)
+
+      unless parsed.is_a?(Hash)
+        raise BadResponseError.new("the API response is not a JSON object",
+                                   shorten(body))
+      end
+
+      parsed
+    rescue JSON::ParserError => e
+      raise BadResponseError.new("could not parse the API response as JSON: #{e.message}", shorten(body))
+    end
+
+    def shorten(text)
+      text.to_s[0, 500]
+    end
+
+    def log(message)
+      warn "[anticaptcha] #{message}" if verbose
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/anticaptcha/errors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Anticaptcha
+  # Base class of every error this library raises.
+  class Error < StandardError; end
+
+  # A task is missing a required parameter, or a value is out of range.
+  # Nothing was sent to the API.
+  class InvalidTaskError < Error; end
+
+  # The API could not be reached.
+  class NetworkError < Error; end
+
+  # The API answered with something that is not the JSON we expect.
+  class BadResponseError < Error
+    # First 500 characters of what the API actually sent.
+    attr_reader :raw
+
+    def initialize(message, raw = nil)
+      @raw = raw
+      super(raw ? "#{message}; raw response: #{raw}" : message)
+    end
+  end
+
+  # The API answered with a non-zero errorId.
+  # See https://anti-captcha.com/apidoc/errors for the list of codes.
+  class ApiError < Error
+    attr_reader :error_id, :error_code, :description
+
+    # Codes worth retrying the very same task on.
+    RETRYABLE = %w[
+      ERROR_NO_SLOT_AVAILABLE
+      ERROR_SERVICE_OVERLOAD
+      ERROR_RATE_LIMIT
+      ERROR_CAPTCHA_UNSOLVABLE
+    ].freeze
+
+    def initialize(error_id, error_code, description)
+      @error_id = error_id
+      @error_code = error_code
+      @description = description
+      super("API error #{error_id} #{error_code}: #{description}")
+    end
+
+    def retryable?
+      RETRYABLE.include?(error_code)
+    end
+  end
+
+  # The task was still unsolved when the waiting limit ran out.
+  class TimeoutError < Error; end
+end

data/lib/anticaptcha/solution.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Anticaptcha
+  # The "solution" object of a completed task.
+  #
+  # Which readers return something depends on the task type; see
+  # https://anti-captcha.com/apidoc for the per-type description. Readers for
+  # fields a task type does not fill return nil, so nothing blows up.
+  class Solution
+    # The whole "solution" object, for fields this class does not expose yet.
+    attr_reader :raw
+
+    # Id of the task that produced this solution, for the report_* methods.
+    attr_reader :task_id
+
+    # What the task cost, in US dollars.
+    attr_reader :cost
+
+    def initialize(raw, task_id: nil, cost: nil)
+      @raw = raw || {}
+      @task_id = task_id
+      @cost = cost
+    end
+
+    # Any field by its API name.
+    def [](field)
+      raw[field.to_s]
+    end
+
+    # Image captchas.
+    def text
+      self["text"]
+    end
+
+    # FunCaptcha, Turnstile, Prosopo, Friendly Captcha, Altcha, Amazon WAF.
+    def token
+      self["token"]
+    end
+
+    # Recaptcha and hCaptcha.
+    def g_recaptcha_response
+      self["gRecaptchaResponse"]
+    end
+
+    # Recaptcha with isExtended.
+    def g_recaptcha_response_md5
+      self["gRecaptchaResponseMd5"]
+    end
+
+    # hCaptcha.
+    def resp_key
+      self["respKey"]
+    end
+
+    # User-agent of the worker who solved the captcha. Submit the form with it.
+    def user_agent
+      self["userAgent"]
+    end
+
+    # AntiGate and AntiBotCookie tasks.
+    def url
+      self["url"]
+    end
+
+    # Amazon WAF: the domain the aws-waf-token cookie belongs to.
+    def domain
+      self["domain"]
+    end
+
+    # GeeTest v3.
+    def challenge
+      self["challenge"]
+    end
+
+    # GeeTest v3.
+    def seccode
+      self["seccode"]
+    end
+
+    # GeeTest v3.
+    def validate
+      self["validate"]
+    end
+
+    # GeeTest v4.
+    def captcha_id
+      self["captcha_id"]
+    end
+
+    # GeeTest v4.
+    def lot_number
+      self["lot_number"]
+    end
+
+    # GeeTest v4.
+    def pass_token
+      self["pass_token"]
+    end
+
+    # GeeTest v4.
+    def gen_time
+      self["gen_time"]
+    end
+
+    # GeeTest v4.
+    def captcha_output
+      self["captcha_output"]
+    end
+
+    # AntiGate and AntiBotCookie tasks.
+    def cookies
+      self["cookies"]
+    end
+
+    # AntiGate and AntiBotCookie tasks.
+    def local_storage
+      self["localStorage"]
+    end
+
+    # AntiGate and AntiBotCookie tasks.
+    def fingerprint
+      self["fingerprint"]
+    end
+
+    # AntiBotCookie tasks: the headers the worker's browser sent last.
+    def last_request_headers
+      self["lastRequestHeaders"]
+    end
+
+    # ImageToCoordinates tasks: [x, y] points or [x1, y1, x2, y2] boxes.
+    def coordinates
+      self["coordinates"]
+    end
+
+    # The cookies formatted as a "name1=value1; name2=value2" header value.
+    def cookie_header
+      jar = cookies
+
+      return "" unless jar.is_a?(Hash)
+
+      jar.map { |name, value| "#{name}=#{value}" }.join("; ")
+    end
+
+    # The worker's browser user-agent, taken from the AntiBotCookie fingerprint.
+    def fingerprint_user_agent
+      fingerprint.is_a?(Hash) ? fingerprint["self.navigator.userAgent"] : nil
+    end
+
+    # True when the API returned a "solution" object without any usable field.
+    def empty?
+      raw.empty?
+    end
+
+    def to_h
+      raw
+    end
+
+    def inspect
+      "#<Anticaptcha::Solution task_id=#{task_id.inspect} fields=#{raw.keys.inspect}>"
+    end
+  end
+end