zero_captcha 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e8f70c4d1910b8d269b4f6ab284dac6b97c0ac7b
+  data.tar.gz: 515a4fcf417ad0b0f6dbf8463147d7aa2df71352
+SHA512:
+  metadata.gz: 87822e89be4d7b0875be5f3ef09f8d44aa4751888ffce5bc65edbe69f794ef1cf4c2a24d9bb78d6275e6f934ad5c8612982ef5e6f77e1e4c8cf7b731d5f8c4f5
+  data.tar.gz: 8d2b43bb65f869c31ccb93d4f93a34c0cdb06f391fa9386022dfefcdc825aaffb872cfcd039d677e9112ebba9bc55e42a81e0247df506108da6e74c590ec3a48

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.ruby-version
+/.ruby-gemset
+/spec/credentials.yml

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--order rand

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+### Comming next
+
+* ?
+
+### 1.0.0 - 2015-06-08
+
+Initial version of ZeroCaptcha, a captcha solver service that is 100% software
+powered and accessible through a private API (zerocaptcha at infosimples.com).

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zero_captcha.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Infosimples
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,140 @@
+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).
+
+
+# ZeroCaptcha
+
+ZeroCaptcha is a Ruby API for an enterprise captcha solving service developed by
+Infosimples that is 100% powered by artificial intelligence software.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zero_captcha', '~> 1.0.0'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zero_captcha
+
+
+## Usage
+
+1. **Create a client**
+
+  ```ruby
+  # Create a client
+  #
+  client = ZeroCaptcha.new('mytoken')
+  ```
+
+2. **Solve a captcha**
+
+  There are two methods available: **decode** and **decode!**
+    * **decode** doesn't raise exceptions.
+    * **decode!** may raise a *ZeroCaptcha::Error* if something goes wrong.
+
+  If the solution is not available, an empty captcha object will be returned.
+
+  ```ruby
+  captcha = client.decode(url: 'http://bit.ly/1xXZcKo', solver: 'captcha-type-1')
+  captcha.text        # Solution of the captcha
+  captcha.id          # Numeric ID of the captcha solved by ZeroCaptcha
+  captcha.correct?    # true if the solution is correct
+  captcha.duration    # How long it took to solve the captcha in milliseconds.
+  ```
+
+  You can also specify *path*, *file*, *raw* and *raw64* when decoding an image.
+
+  ```ruby
+  client.decode(path: 'path/to/my/captcha/file', solver: 'captcha-type-1')
+
+  client.decode(file: File.open('path/to/my/captcha/file', 'rb'), solver: 'captcha-type-1')
+
+  client.decode(raw: File.open('path/to/my/captcha/file', 'rb').read, solver: 'captcha-type-1')
+
+  client.decode(raw64: Base64.encode64(File.open('path/to/my/captcha/file', 'rb').read), solver: 'captcha-type-1')
+  ```
+
+  > Internally, the gem will always convert the image to raw64 (binary base64 encoded).
+
+3. **Report incorrectly solved captcha for refund**
+
+  ```ruby
+  captcha = client.report_incorrect(130920620) # with 130920620 as the captcha id
+  ```
+
+  > ***Warning:*** *do not abuse on this method, otherwise you may get banned*
+
+4. **Report correctly solved captcha for statistics**
+
+  ```ruby
+  captcha = client.report_correct(130920620) # with 130920620 as the captcha id
+  ```
+
+## Notes
+
+#### Thread-safety
+
+The API is thread-safe, which means it is perfectly fine to share a client
+instance between multiple threads.
+
+#### Ruby dependencies
+
+ZeroCaptcha don't require specific dependencies. That saves you memory and
+avoid conflicts with other gems.
+
+#### Input image format
+
+Any format you use in the decode method (url, file, path, raw, raw64) will
+always be converted to a raw64, which is a binary base64 encoded string. So, if
+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, memory and IO).
+
+#### Versioning
+
+ZeroCaptcha gem uses [Semantic Versioning](http://semver.org/).
+
+#### Ruby versions
+
+This gem has been tested with the following versions of Ruby:
+
+* MRI 2.2.2
+* MRI 2.2.0
+* MRI 2.1.5
+* MRI 2.0.0
+* MRI 1.9.3
+
+# Maintainers
+
+* [Rafael Barbolo](http://github.com/barbolo)
+
+
+## Contributing
+
+1. Fork it ( https://github.com/infosimples/zero_captcha/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. **Run/add tests (RSpec)**
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+7. Yay. Thanks for contributing :)
+
+All contributors:
+https://github.com/infosimples/zero_captcha/graphs/contributors
+
+
+# License
+
+MIT License. Copyright (C) 2011-2015 Infosimples. https://infosimples.com/

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zero_captcha"
+
+# 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/lib/zero_captcha.rb

@@ -0,0 +1,32 @@
+require 'base64'
+require 'json'
+require 'net/http'
+
+# The module ZeroCaptcha contains all the code for the zero_captcha gem.
+# It acts as a safely namespace that isolates logic from ZeroCaptcha from any
+# project that uses it.
+#
+module ZeroCaptcha
+  # Create a ZeroCaptcha API client. This is a shortcut to
+  # ZeroCaptcha::Client.new.
+  #
+  def self.new(*args)
+    ZeroCaptcha::Client.new(*args)
+  end
+
+  # Base class of a model object returned by ZeroCaptcha API.
+  #
+  class Model
+    def initialize(values = {})
+      values.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+  end
+end
+
+require 'zero_captcha/client'
+require 'zero_captcha/errors'
+require 'zero_captcha/http'
+require 'zero_captcha/models/captcha'
+require 'zero_captcha/version'

data/lib/zero_captcha/client.rb

@@ -0,0 +1,142 @@
+module ZeroCaptcha
+  # ZeroCaptcha::Client is a client that communicates with the ZeroCaptcha API:
+  # https://zerocaptcha.infosimples.com/.
+  #
+  class Client
+    BASE_URL = 'https://zerocaptcha.infosimples.com/api/v1/captcha/:action.json'
+
+    attr_accessor :token, :timeout
+
+    # Create a ZeroCaptcha API client.
+    #
+    # @param [String] token Token of the ZeroCaptcha account.
+    # @param [Hash]   options  Options hash.
+    # @option options [Integer] :timeout (60) Seconds before giving up of a
+    #                                         captcha being solved.
+    #
+    # @return [ZeroCaptcha::Client] A Client instance.
+    #
+    def initialize(token, options = {})
+      self.token      = token
+      self.timeout    = options[:timeout] || 60
+    end
+
+    # Decode the text from an image (i.e. solve a captcha).
+    #
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url   URL of the image to be decoded.
+    # @option options [String]  :path  File path of the image to be decoded.
+    # @option options [File]    :file  File instance with image to be decoded.
+    # @option options [String]  :raw   Binary content of the image to be
+    #                                  decoded.
+    # @option options [String]  :raw64 Binary content encoded in base64 of the
+    #                                  image to be decoded.
+    #
+    # @return [ZeroCaptcha::Captcha] The captcha (with solution) or an empty
+    #                                hash if something goes wrong.
+    #
+    def decode(options = {})
+      decode!(options)
+    rescue ZeroCaptcha::Error
+      ZeroCaptcha::Captcha.new
+    end
+
+    # Decode the text from an image (i.e. solve a captcha).
+    #
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url   URL of the image to be decoded.
+    # @option options [String]  :path  File path of the image to be decoded.
+    # @option options [File]    :file  File instance with image to be decoded.
+    # @option options [String]  :raw   Binary content of the image to be
+    #                                  decoded.
+    # @option options [String]  :raw64 Binary content encoded in base64 of the
+    #                                  image to be decoded.
+    #
+    # @return [ZeroCaptcha::Captcha] The captcha (with solution) if an error
+    #                                is not raised.
+    #
+    def decode!(options = {})
+      raw64   = load_captcha(options)
+      solver  = options[:solver]
+
+      response = request(solver, :multipart, image64: raw64)
+      captcha = ZeroCaptcha::Captcha.new(response)
+
+      fail(ZeroCaptcha::IncorrectSolution) unless captcha.correct?
+
+      captcha
+    end
+
+    # Report incorrectly solved captcha for refund.
+    #
+    # @param [Integer] id Numeric ID of the captcha.
+    #
+    # @return [ZeroCaptcha::Captcha] The captcha with current "correct" value.
+    #
+    def report_incorrect(id)
+      response = request('report_incorrect', :post, id: id)
+      ZeroCaptcha::Captcha.new(response)
+    end
+
+    # Report correctly solved captcha for statistics.
+    #
+    # @param [Integer] id Numeric ID of the captcha.
+    #
+    # @return [ZeroCaptcha::Captcha] The captcha with current "correct" value.
+    #
+    def report_correct(id)
+      response = request('report_correct', :post, id: id)
+      ZeroCaptcha::Captcha.new(response)
+    end
+
+    private
+
+    # Load a captcha raw content encoded in base64 from options.
+    #
+    # @param [Hash] options Options hash.
+    # @option options [String]  :url   URL of the image to be decoded.
+    # @option options [String]  :path  File path of the image to be decoded.
+    # @option options [File]    :file  File instance with image to be decoded.
+    # @option options [String]  :raw   Binary content of the image to bedecoded.
+    # @option options [String]  :raw64 Binary content encoded in base64 of the
+    #                                  image to be decoded.
+    #
+    # @return [String] The binary image base64 encoded.
+    #
+    def load_captcha(options)
+      if options[:raw64]
+        options[:raw64]
+      elsif options[:raw]
+        Base64.encode64(options[:raw])
+      elsif options[:file]
+        Base64.encode64(options[:file].read)
+      elsif options[:path]
+        Base64.encode64(File.open(options[:path], 'rb').read)
+      elsif options[:url]
+        Base64.encode64(ZeroCaptcha::HTTP.open_url(options[:url]))
+      else
+        fail ZeroCaptcha::ArgumentError, 'Illegal image format'
+      end
+    rescue
+      raise ZeroCaptcha::InvalidCaptcha
+    end
+
+    # Perform an HTTP request to the ZeroCaptcha API.
+    #
+    # @param [String] action  API method name.
+    # @param [Symbol] method  HTTP method (:get, :post, :multipart).
+    # @param [Hash]   payload Data to be sent through the HTTP request.
+    #
+    # @return [Hash] Response from the ZeroCaptcha API.
+    #
+    def request(action, method = :get, payload = {})
+      res = ZeroCaptcha::HTTP.request(
+        url: BASE_URL.gsub(':action', action),
+        timeout: timeout,
+        method: method,
+        payload: payload.merge(token: token)
+      )
+      JSON.parse(res)
+    end
+  end
+end

data/lib/zero_captcha/errors.rb

@@ -0,0 +1,52 @@
+module ZeroCaptcha
+  # This is the base DeathByCaptcha exception class. Rescue it if you want to
+  # catch any exception that might be raised.
+  #
+  class Error < Exception
+  end
+
+  class ArgumentError < Error
+  end
+
+  class InvalidCaptcha < Error
+    def initialize
+      super('The captcha is empty or invalid')
+    end
+  end
+
+  class InvalidCaptchaType < Error
+    def initialize
+      super('Captcha type is invalid or cannot be solved by ZeroCaptcha')
+    end
+  end
+
+  class Timeout < Error
+    def initialize
+      super('The captcha was not solved in the expected time')
+    end
+  end
+
+  class IncorrectSolution < Error
+    def initialize
+      super('The captcha could not be solved correctly')
+    end
+  end
+
+  class APIForbidden < Error
+    def initialize
+      super('Access denied, please check your credentials and/or balance')
+    end
+  end
+
+  class APIBadRequest < Error
+    def initialize
+      super('The Captcha was rejected, check if it\'s a valid image')
+    end
+  end
+
+  class APIResponseError < Error
+    def initialize(info)
+      super("Invalid API response: #{info}")
+    end
+  end
+end

data/lib/zero_captcha/http.rb

@@ -0,0 +1,119 @@
+module ZeroCaptcha
+  # ZeroCaptcha::HTTP exposes common HTTP routines that can be used by the
+  # ZeroCaptcha API client.
+  #
+  class HTTP
+    # Retrieve the contents of a captcha URL supporting HTTPS and redirects.
+    #
+    # @param [String] url The captcha URL.
+    #
+    # @return [String] The contents of the captcha URL.
+    #
+    def self.open_url(url)
+      uri = URI(url)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      res = http.get(uri.request_uri)
+
+      if (redirect = res.header['location'])
+        open_url(redirect)
+      else
+        res.body
+      end
+    end
+
+    # Perform an HTTP request with support to multipart requests.
+    #
+    # @param [Hash] options Options hash.
+    # @param options [String] url      URL to be requested.
+    # @param options [Symbol] method   HTTP method (:get, :post, :multipart).
+    # @param options [Hash]   payload  Data to be sent through the HTTP request.
+    # @param options [Integer] timeout HTTP open/read timeout in seconds.
+    #
+    # @return [String] Response body of the HTTP request.
+    #
+    def self.request(options = {})
+      uri     = URI(options[:url])
+      method  = options[:method] || :get
+      payload = options[:payload] || {}
+      timeout = options[:timeout] || 60
+      headers = { 'User-Agent' => ZeroCaptcha::USER_AGENT }
+
+      case method
+      when :get
+        uri.query = URI.encode_www_form(payload)
+        req = Net::HTTP::Get.new(uri.request_uri, headers)
+
+      when :post
+        req = Net::HTTP::Post.new(uri.request_uri, headers)
+        req.set_form_data(payload)
+
+      when :multipart
+        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
+        fail ZeroCaptcha::ArgumentError, "Illegal HTTP method (#{method})"
+      end
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = true if (uri.scheme == 'https')
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      res = http.request(req)
+
+      case res
+      when Net::HTTPSuccess
+        res.body
+
+      when Net::HTTPBadRequest
+        fail ZeroCaptcha::APIBadRequest
+
+      when Net::HTTPUnauthorized, Net::HTTPForbidden
+        fail ZeroCaptcha::APIForbidden
+
+      when Net::HTTPNotFound
+        fail ZeroCaptcha::InvalidCaptchaType
+
+      when Net::HTTPGatewayTimeOut
+        fail ZeroCaptcha::Timeout
+
+      else
+        fail ZeroCaptcha::APIResponseError, res.body
+      end
+
+    rescue Net::OpenTimeout, Net::ReadTimeout
+      raise ZeroCaptcha::Timeout
+    end
+
+    # Prepare the multipart data to be sent via a :multipart request.
+    #
+    # @param [Hash] payload Data to be prepared via a multipart post.
+    #
+    # @return [String, String] Boundary and body for the multipart post.
+    #
+    def self.prepare_multipart_data(payload)
+      boundary = 'infosimples' + rand(1_000_000).to_s # a random unique string
+
+      content = []
+      payload.each do |param, value|
+        content << '--' + boundary
+        content << "Content-Disposition: form-data; name=\"#{param}\""
+        content << ''
+        content << value
+      end
+      content << '--' + boundary + '--'
+      content << ''
+
+      [boundary, content.join("\r\n")]
+    end
+  end
+end

data/lib/zero_captcha/models/captcha.rb

@@ -0,0 +1,18 @@
+module ZeroCaptcha
+  # Model of a Captcha returned by ZeroCaptcha API.
+  #
+  class Captcha < ZeroCaptcha::Model
+    attr_accessor :id, :text, :code, :correct, :duration_in_milliseconds,
+                  :created_at, :created_at_not_parsed
+
+    alias_method :correct?, :correct
+    alias_method :duration, :duration_in_milliseconds
+
+    def created_at=(datetime)
+      self.created_at_not_parsed = datetime
+      @created_at = Time.parse(datetime)
+    rescue
+      datetime
+    end
+  end
+end

data/lib/zero_captcha/version.rb

@@ -0,0 +1,5 @@
+# Specify zero_captcha's gem version.
+module ZeroCaptcha
+  VERSION = '1.0.0'
+  USER_AGENT = "ZeroCaptcha/Ruby v#{VERSION}"
+end

data/zero_captcha.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zero_captcha/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'zero_captcha'
+  spec.version       = ZeroCaptcha::VERSION
+  spec.authors       = ['Rafael Barbolo', 'Rafael Ivan Garcia']
+  spec.email         = ["zerocaptcha@infosimples.com"]
+
+  spec.summary       = %q{Ruby API for ZeroCaptcha (Captcha Solver as a Service for the Enterprise)}
+  spec.description   = %q{ZeroCaptcha allows companies to solve captchas with artificial intelligence software, which is faster than humans and very accurate}
+  spec.homepage      = "https://github.com/infosimples/zero_captcha"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: zero_captcha
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Rafael Barbolo
+- Rafael Ivan Garcia
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: ZeroCaptcha allows companies to solve captchas with artificial intelligence
+  software, which is faster than humans and very accurate
+email:
+- zerocaptcha@infosimples.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/zero_captcha.rb
+- lib/zero_captcha/client.rb
+- lib/zero_captcha/errors.rb
+- lib/zero_captcha/http.rb
+- lib/zero_captcha/models/captcha.rb
+- lib/zero_captcha/version.rb
+- zero_captcha.gemspec
+homepage: https://github.com/infosimples/zero_captcha
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby API for ZeroCaptcha (Captcha Solver as a Service for the Enterprise)
+test_files: []