deathbycaptcha 5.0.2 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d578d0181a5e858098bc2329884daff5971f7bbd
-  data.tar.gz: b2681b030c07099cc78cb52dfc4382c6015d64b6
+SHA256:
+  metadata.gz: b7b0ae41ffa4cc961dc9600c23ec9f0e56bf09261fa4766ed2aa1cd686a2a09f
+  data.tar.gz: 87885c289fce41e9a34696514dc067b62b025a45e89f7728aaf28146beba4111
 SHA512:
-  metadata.gz: 1eaf72f64a8b7e83d4e7b6933d17d3d48ea14a890cae901c1aa1f3e9693f7bbdac4e85ad23ba075010714a166946668fb60cd8032aa4d3814a31cf228e80a66c
-  data.tar.gz: 2628bb9faeba7ee4e1438d307d3a20357bb69f3b2195afbf804add2c9d1979f48ddbc719c6f01d084e38572c76ec03b7d623f56d96733eec784d96a5e056a327
+  metadata.gz: 926bfd8b477e4d3888947bfca51521402c0f170c04fb70244b31fc9fa8aea47904f00587ea9f95fe9c9cb62c1c6780164aa59ef1bed19e0ac9e232adf01690a7
+  data.tar.gz: 72925f985964bf277675ebc86373871f0a3c865eb7996b0eb73bde1900d14d4d8e7b3765d1ced32979c0baae3bed7d762ca8d56de9273ed48e3d42e4452c5251

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Rafael Barbolo
+Copyright (c) 2015 Infosimples
 
 MIT License
 

data/README.md

@@ -1,6 +1,12 @@
 Developed by [Infosimples](https://infosimples.com), a brazilian company that
-offers [data extraction solutions](https://infosimples.com/en/data-engineering)
-and [Ruby on Rails development](https://infosimples.com/en/software-development).
+offers [data extraction solutions](https://infosimples.com/en/data-engineering).
+
+We suggest you to also check [2Captcha.com](http://2captcha.com/?from=1025109)
+for a cheaper service. You can find it's gem fully compatible with the
+deathbycaptcha gem at https://github.com/infosimples/two_captcha.
+
+[Contact us](https://infosimples.com/en) if you need enterprise services for
+CAPTCHAs solving or Internet automation.
 
 
 # DeathByCaptcha
@@ -24,14 +30,12 @@ Or install it yourself as:
 
     $ gem install deathbycaptcha
 
-
 ## Usage
 
 1. **Create a client**
 
   ```ruby
   # Create a client (:socket and :http clients are available)
-  #
   client = DeathByCaptcha.new('myusername', 'mypassword', :http)
   ```
 
@@ -44,7 +48,7 @@ Or install it yourself as:
   If the solution is not available, an empty captcha object will be returned.
 
   ```ruby
-  captcha = client.decode(url: 'http://bit.ly/1xXZcKo')
+  captcha = client.decode!(url: 'http://bit.ly/1xXZcKo')
   captcha.text        # Solution of the captcha
   captcha.id          # Numeric ID of the captcha solved by DeathByCaptcha
   captcha.is_correct  # true if the solution is correct
@@ -53,16 +57,17 @@ Or install it yourself as:
   You can also specify *path*, *file*, *raw* and *raw64* when decoding an image.
 
   ```ruby
-  client.decode(path: 'path/to/my/captcha/file')
+  client.decode!(path: 'path/to/my/captcha/file')
 
-  client.decode(file: File.open('path/to/my/captcha/file', 'rb'))
+  client.decode!(file: File.open('path/to/my/captcha/file', 'rb'))
 
-  client.decode(raw: File.open('path/to/my/captcha/file', 'rb').read)
+  client.decode!(raw: File.open('path/to/my/captcha/file', 'rb').read)
 
-  client.decode(raw64: Base64.encode64(File.open('path/to/my/captcha/file', 'rb').read))
+  client.decode!(raw64: Base64.encode64(File.open('path/to/my/captcha/file', 'rb').read))
   ```
 
-  > Internally, the gem will always convert the image to raw64 (binary base64 encoded).
+  > Internally, the gem will always convert any image to raw64 (binary base64
+  encoded).
 
 3. **Retrieve a previously solved captcha**
 
@@ -97,6 +102,135 @@ Or install it yourself as:
   status.is_service_overloaded  # true if DeathByCaptcha is overloaded/unresponsive
   ```
 
+## New reCAPTCHA
+
+> It's currently available only with the :http client.
+
+To solve captchas similar to
+[reCAPTCHA v2](https://support.google.com/recaptcha/?hl=en#6262736), you can use
+both the DeathByCaptcha's **Coordinates API** or **Image Group API**.
+
+Please, read the oficial documentation at
+http://www.deathbycaptcha.com/user/api/newrecaptcha.
+
+### Using the Coordinates API
+
+```ruby
+# Read above all the instructions on how to solve a captcha.
+captcha = client.decode!(type: 2, url: 'http://bit.ly/1VCUuzk')
+```
+
+You should specify arguments with *type = 2* and an image similar to a screenshot of
+the captcha. See an example:
+
+**Captcha (screenshot)**
+
+> the argument is passed as *url*, *path*, *file*, *raw* or *raw64*
+
+![Example of a captcha based on image clicks](captchas/2.jpg)
+
+The response will be an array containing coordinates (x, y) where the human
+clicked to solve the captcha. For the captcha above it should look something
+like:
+
+```ruby
+# captcha.text
+"[[30,143],[241,325]]"
+
+# captcha.coordinates
+[[30, 143], [241, 325]]
+```
+
+### Using the Image Group API
+
+```ruby
+# Read above all the instructions on how to solve a captcha.
+captcha = client.decode!(
+  type: 3,
+  url: 'http://bit.ly/1i1CIaB', # single image with the clickable grid
+  banner: { url: 'http://bit.ly/1JTG4T3' }, # the banner image
+  banner_text: 'Click all images with bananas' # the banner text
+)
+```
+
+You should specify arguments with *type = 3* and the decomposed captcha as seen in the
+example below:
+
+**Captcha: images grid**
+
+> the argument is passed as *url*, *path*, *file*, *raw* or *raw64*
+
+![Example of a grid of a captcha based on image clicks](captchas/3-grid.jpg)
+
+**Captcha: banner**
+
+![Example of a banner of a captcha based on image clicks](captchas/3-banner.jpg)
+
+**Captcha: banner text**
+
+> Click all images with bananas
+
+The response will be an array containing the indexes for each image that should
+be clicked counting from left to right. For the captcha above it should look
+something like:
+
+```ruby
+# captcha.text
+"[1,9]"
+
+# captcha.indexes
+[1, 9]
+```
+
+## New Recaptcha by Token API
+
+> It's currently available only with the :http client.
+
+To solve captchas similar to
+[reCAPTCHA v2](https://support.google.com/recaptcha/?hl=en#6262736), you can also use
+**Token API**
+
+Please, read the oficial documentation at
+http://deathbycaptcha.com/user/api/newtokenrecaptcha
+
+### Using the Token API
+
+```ruby
+# Read above all the instructions on how to solve a captcha.
+captcha = client.decode!(type: 4, token_params: {
+    # optional proxy if needed and server verifies
+    #proxy: "http://127.0.0.1:3128",
+    #proxytype: "HTTP",
+    googlekey: "6Ld2sf4SAAAAAKSgzs0Q13IZhY02Pyo31S2jgOB5",
+    pageurl: "https://patrickhlauke.github.io/recaptcha/"
+  })
+```
+
+You should specify arguments with *type = 4* and an all token params required by DBC API
+
+The response will be a text (token), which you can access with  **text** or **token** method.
+
+```ruby
+# captcha.text
+"03AOPBWq_RPO2vLzyk0h8gH0cA2X4v3tpYCPZR6Y4yxKy1s3Eo7CHZRQntxrd
+saD2H0e6S3547xi1FlqJB4rob46J0-wfZMj6YpyVa0WGCfpWzBWcLn7tO_EYs
+vEC_3kfLNINWa5LnKrnJTDXTOz-JuCKvEXx0EQqzb0OU4z2np4uyu79lc_Ndv
+L0IRFc3Cslu6UFV04CIfqXJBWCE5MY0Ag918r14b43ZdpwHSaVVrUqzCQMCyb
+cGq0yxLQf9eSexFiAWmcWLI5nVNA81meTXhQlyCn5bbbI2IMSEErDqceZjf1m
+X3M67BhIb4"
+
+# captcha.token
+"03AOPBWq_RPO2vLzyk0h8gH0cA2X4v3tpYCPZR6Y4yxKy1s3Eo7CHZRQntxrd
+saD2H0e6S3547xi1FlqJB4rob46J0-wfZMj6YpyVa0WGCfpWzBWcLn7tO_EYs
+vEC_3kfLNINWa5LnKrnJTDXTOz-JuCKvEXx0EQqzb0OU4z2np4uyu79lc_Ndv
+L0IRFc3Cslu6UFV04CIfqXJBWCE5MY0Ag918r14b43ZdpwHSaVVrUqzCQMCyb
+cGq0yxLQf9eSexFiAWmcWLI5nVNA81meTXhQlyCn5bbbI2IMSEErDqceZjf1m
+X3M67BhIb4"
+```
+
+> Those captchas sometimes took more than 60 seconds to solve
+> So consider increasing the client's *timeout*
+
 ## Notes
 
 #### Thread-safety
@@ -121,7 +255,7 @@ firewall.
 #### Ruby dependencies
 
 DeathByCaptcha >= 5.0.0 don't require specific dependencies. That saves you
-memmory and avoid conflicts with other gems.
+memory and avoid conflicts with other gems.
 
 #### Input image format
 
@@ -131,7 +265,7 @@ you already have this format available on your side, there's no need to do
 convertions before calling the API.
 
 > Our recomendation is to never convert your image format, unless needed. Let
-> the gem convert internally. It may save you resources (CPU, memmory and IO).
+> the gem convert internally. It may save you resources (CPU, memory and IO).
 
 #### Versioning
 
@@ -153,13 +287,6 @@ This gem has been tested on the following versions of Ruby:
 * MRI 2.0.0
 * MRI 1.9.3
 
-# Maintainers
-
-* [Débora Setton Fernandes](http://github.com/deborasetton)
-* [Rafael Barbolo](http://github.com/barbolo)
-* [Rafael Ivan Garcia](http://github.com/rafaelivan)
-
-
 ## Contributing
 
 1. Fork it ( https://github.com/infosimples/deathbycaptcha/fork )

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "deathbycaptcha"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/deathbycaptcha.gemspec

@@ -6,7 +6,7 @@ require 'deathbycaptcha/version'
 Gem::Specification.new do |spec|
   spec.name          = "deathbycaptcha"
   spec.version       = DeathByCaptcha::VERSION
-  spec.authors       = ["Débora Setton Fernandes, Rafael Barbolo, Rafael Ivan Garcia"]
+  spec.authors       = ["Rafael Barbolo, Rafael Ivan Garcia"]
   spec.email         = ["team@infosimples.com.br"]
   spec.summary       = %q{Ruby API for DeathByCaptcha (Captcha Solver as a Service)}
   spec.description   = %q{DeathByCaptcha allows you to solve captchas with manual labor}
@@ -14,7 +14,11 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  # Since our currently binstubs are used only during the gem's development, we
+  # are ignoring them in the gem specification.
+  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

data/lib/deathbycaptcha.rb

@@ -1,4 +1,5 @@
 require 'base64'
+require 'openssl'
 require 'json'
 require 'bigdecimal'
 require 'socket'

data/lib/deathbycaptcha/client.rb

@@ -12,7 +12,7 @@ module DeathByCaptcha
   #
   class Client
 
-    attr_accessor :username, :password, :timeout, :polling
+    attr_accessor :username, :password, :timeout, :polling, :hostname
 
     # Create a DeathByCaptcha API client
     #
@@ -43,6 +43,7 @@ module DeathByCaptcha
     # @param [Hash]   options  Options hash.
     # @option options [Integer] :timeout (60) Seconds before giving up.
     # @option options [Integer] :polling (5) Seconds for polling the solution.
+    # @option options [String]  :hostname ('api.dbcapi.me') Custom API hostname.
     #
     # @return [DeathByCaptcha::Client] A Client instance.
     #
@@ -51,6 +52,7 @@ module DeathByCaptcha
       self.password   = password
       self.timeout    = options[:timeout] || 60
       self.polling    = options[:polling] || 5
+      self.hostname   = options[:hostname] || 'api.dbcapi.me'
     end
 
     # Decode the text from an image (i.e. solve a captcha).
@@ -84,19 +86,24 @@ module DeathByCaptcha
     def decode!(options = {})
       started_at = Time.now
 
-      raw64 = load_captcha(options)
-      raise DeathByCaptcha::InvalidCaptcha if raw64.to_s.empty?
+      # don't load image data for Token API v2 & v3
+      raw64 = nil
+      unless [4, 5].include? options[:type]
+        raw64 = load_captcha(options)
+        raise DeathByCaptcha::InvalidCaptcha if raw64.to_s.empty?
+      end
+
+      decoded_captcha = self.upload(options.merge(raw64: raw64))
 
-      _captcha = self.upload(raw64)
-      while _captcha.text.to_s.empty?
+      while decoded_captcha.text.to_s.empty?
         sleep(self.polling)
-        _captcha = self.captcha(_captcha.id)
+        decoded_captcha = self.captcha(decoded_captcha.id)
         raise DeathByCaptcha::Timeout if (Time.now - started_at) > self.timeout
       end
 
-      raise DeathByCaptcha::IncorrectSolution if !_captcha.is_correct
+      raise DeathByCaptcha::IncorrectSolution if !decoded_captcha.is_correct
 
-      _captcha
+      decoded_captcha
     end
 
     # Retrieve information from an uploaded captcha.

data/lib/deathbycaptcha/client/http.rb

@@ -3,9 +3,6 @@ module DeathByCaptcha
   # HTTP client for DeathByCaptcha API.
   #
   class Client::HTTP < Client
-
-    BASE_URL = 'http://api.dbcapi.me/api'
-
     # Retrieve information from an uploaded captcha.
     #
     # @param [Integer] captcha_id Numeric ID of the captcha.
@@ -53,8 +50,26 @@ module DeathByCaptcha
     #
     # @return [DeathByCaptcha::Captcha] The captcha object (not solved yet).
     #
-    def upload(raw64)
-      response = perform('captcha', :post_multipart, captchafile: "base64:#{raw64}")
+    def upload(options = {})
+      payload = {}
+      payload[:captchafile] = "base64:#{options[:raw64]}"
+      payload[:type] = options[:type] if options[:type].to_i > 0
+
+      if options[:type].to_i == 3
+        banner64 = load_captcha(options[:banner])
+        raise DeathByCaptcha::InvalidCaptcha if banner64.to_s.empty?
+
+        payload[:banner] = "base64:#{banner64}"
+        payload[:banner_text] = options[:banner_text].to_s
+
+      elsif [4, 5].include? options[:type].to_i
+        payload = {
+          type: options[:type].to_i,
+          token_params: options[:token_params].to_json,
+        }
+      end
+
+      response = perform('captcha', :post_multipart, payload)
       DeathByCaptcha::Captcha.new(response)
     end
 
@@ -74,19 +89,18 @@ module DeathByCaptcha
       headers = { 'User-Agent' => DeathByCaptcha::API_VERSION }
 
       if method == :post
-        uri = URI("#{BASE_URL}/#{action}")
+        uri = URI("http://#{self.hostname}/api/#{action}")
         req = Net::HTTP::Post.new(uri.request_uri, headers)
         req.set_form_data(payload)
 
       elsif method == :post_multipart
-        uri = URI("#{BASE_URL}/#{action}")
+        uri = URI("http://#{self.hostname}/api/#{action}")
         req = Net::HTTP::Post.new(uri.request_uri, headers)
         boundary, body = prepare_multipart_data(payload)
         req.content_type = "multipart/form-data; boundary=#{boundary}"
         req.body = body
-
       else
-        uri = URI("#{BASE_URL}/#{action}?#{URI.encode_www_form(payload)}")
+        uri = URI("http://#{self.hostname}/api/#{action}?#{URI.encode_www_form(payload)}")
         req = Net::HTTP::Get.new(uri.request_uri, headers)
       end
 

data/lib/deathbycaptcha/client/socket.rb

@@ -4,7 +4,6 @@ module DeathByCaptcha
   #
   class Client::Socket < Client
 
-    HOST  = 'api.dbcapi.me'
     PORTS = (8123..8130).to_a
 
     # Retrieve information from an uploaded captcha.
@@ -54,8 +53,12 @@ module DeathByCaptcha
     #
     # @return [DeathByCaptcha::Captcha] The captcha object (not solved yet).
     #
-    def upload(raw64)
-      response = perform('upload', captcha: raw64)
+    def upload(options = {})
+      if options[:type] && options[:type].to_i != 1
+        # Socket client implementation currently supports only text captchas.
+        raise DeathByCaptcha::InvalidCaptcha
+      end
+      response = perform('upload', captcha: options[:raw64])
       DeathByCaptcha::Captcha.new(response)
     end
 
@@ -112,7 +115,7 @@ module DeathByCaptcha
     #
     def create_socket
       socket = ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0)
-      sockaddr = ::Socket.sockaddr_in(PORTS.sample, HOST)
+      sockaddr = ::Socket.sockaddr_in(PORTS.sample, self.hostname)
       begin # emulate blocking connect
         socket.connect_nonblock(sockaddr)
       rescue IO::WaitWritable

data/lib/deathbycaptcha/models/captcha.rb

@@ -16,5 +16,14 @@ module DeathByCaptcha
     def captcha=(value)
       @captcha = value.to_i
     end
+
+    def parsed_text
+      JSON.parse(text)
+    rescue
+      []
+    end
+    alias_method :coordinates, :parsed_text
+    alias_method :indexes, :parsed_text
+    alias_method :token, :text
   end
 end

data/lib/deathbycaptcha/version.rb

@@ -1,4 +1,4 @@
 module DeathByCaptcha
-  VERSION = "5.0.2"
+  VERSION = "5.2.0"
   API_VERSION = "DBC/Ruby v#{VERSION}"
 end

data/spec/lib/image_captcha_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+username      = CREDENTIALS['username']
+password      = CREDENTIALS['password']
+path2         = './captchas/2.jpg' # path of the captcha (Coordinates API)
+path3_grid    = './captchas/3-grid.jpg' # path of the grid (Image Group API)
+path3_banner  = './captchas/3-banner.jpg' # path of the grid (Image Group API)
+banner_text3  = 'Click all images with bananas'
+token_params = {
+  #proxy: "http://127.0.0.1:3128",
+  #proxytype: "HTTP",
+  googlekey: "6Ld2sf4SAAAAAKSgzs0Q13IZhY02Pyo31S2jgOB5",
+  pageurl: "https://patrickhlauke.github.io/recaptcha/"
+}
+
+describe 'Solving an image based captcha' do
+  before(:all) { @client = DeathByCaptcha.new(username, password, :http) }
+
+  context 'Coordinates API' do
+    describe '#decode!' do
+      before(:all) { @captcha = @client.decode!(type: 2, path: path2) }
+      it { expect(@captcha).to be_a(DeathByCaptcha::Captcha) }
+      it { expect(@captcha.text).to match(/\A\[\[.*\]\]\Z/) }
+      it { expect(@captcha.coordinates).to be_a(Array) }
+      it { expect(@captcha.coordinates.size).to be > 0 }
+      it 'expect coordinates to be valid' do
+        @captcha.coordinates.each do |coordinate|
+          expect(coordinate).to be_a(Array)
+          expect(coordinate.size).to eq(2)
+        end
+      end
+      it { expect(@captcha.is_correct).to be true }
+      it { expect(@captcha.id).to be > 0 }
+      it { expect(@captcha.id).to eq(@captcha.captcha) }
+    end
+  end
+
+  context 'Image Group API' do
+    describe '#decode!' do
+      before(:all) do
+        @captcha = @client.decode!(
+          type: 3,
+          path: path3_grid,
+          banner: { path: path3_banner },
+          banner_text: banner_text3
+        )
+      end
+      it { expect(@captcha).to be_a(DeathByCaptcha::Captcha) }
+      it { expect(@captcha.text).to match(/\A\[.*\]\Z/) }
+      it { expect(@captcha.indexes).to be_a(Array) }
+      it { expect(@captcha.indexes.size).to be > 0 }
+      it 'expect indexes to be valid' do
+        @captcha.indexes.each do |index|
+          expect(index).to be_a(Numeric)
+        end
+      end
+      it { expect(@captcha.is_correct).to be true }
+      it { expect(@captcha.id).to be > 0 }
+      it { expect(@captcha.id).to eq(@captcha.captcha) }
+    end
+  end
+
+  context 'Token API' do
+    describe '#decode!' do
+      before(:all) do
+        @captcha = @client.decode!(
+          type: 4,
+          token_params: token_params,
+        )
+      end
+      it { expect(@captcha).to be_a(DeathByCaptcha::Captcha) }
+      it { expect(@captcha.text).to eq(@captcha.token) }
+      it { expect(@captcha.token).to match(/\A"?\S+"?\Z/) }
+      it { expect(@captcha.token.size).to be > 30 }
+      it { expect(@captcha.is_correct).to be true }
+      it { expect(@captcha.id).to be > 0 }
+      it { expect(@captcha.id).to eq(@captcha.captcha) }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deathbycaptcha
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.2.0
 platform: ruby
 authors:
-- Débora Setton Fernandes, Rafael Barbolo, Rafael Ivan Garcia
-autorequire: 
+- Rafael Barbolo, Rafael Ivan Garcia
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-05-26 00:00:00.000000000 Z
+date: 2020-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,7 +65,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - captchas/1.png
+- captchas/2.jpg
+- captchas/3-banner.jpg
+- captchas/3-grid.jpg
 - deathbycaptcha.gemspec
 - lib/deathbycaptcha.rb
 - lib/deathbycaptcha/client.rb
@@ -80,12 +85,13 @@ files:
 - lib/deathbycaptcha/version.rb
 - spec/credentials.yml.example
 - spec/lib/client_spec.rb
+- spec/lib/image_captcha_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/infosimples/deathbycaptcha
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,12 +106,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Ruby API for DeathByCaptcha (Captcha Solver as a Service)
 test_files:
 - spec/credentials.yml.example
 - spec/lib/client_spec.rb
+- spec/lib/image_captcha_spec.rb
 - spec/spec_helper.rb