geetest_ruby_sdk 4.0.3

data/lib/geetest/v4/account.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Geetest
+  module V4
+    class Account
+      DEFAULT_API_SERVER = 'http://gcaptcha4.geetest.com'
+      DIGEST_MOD = 'hmac_sha256'
+
+      attr_accessor :captcha_id, :captcha_key, :api_server
+
+      def initialize(captcha_id, captcha_key, **options)
+        @captcha_id = captcha_id
+        @captcha_key = captcha_key
+        @api_server = URI.parse options.fetch(:api_server, DEFAULT_API_SERVER)
+      end
+
+      def validate?(lot_number: nil, captcha_output: nil, pass_token: nil, gen_time: nil, **options)
+        return false unless lot_number && captcha_output && pass_token && gen_time
+
+        payload = {
+          lot_number: lot_number,
+          captcha_output: captcha_output,
+          pass_token: pass_token,
+          gen_time: gen_time,
+          sign_token: Encryptor.encrypt(lot_number).with(captcha_key).by(DIGEST_MOD).to_s
+        }
+        response = request! payload, options
+        Geetest.logger.debug "Geetest validate failed, reason: #{response['reason']}" if response['result'] != 'success'
+        response['result'] == 'success'
+      rescue *Geetest.exceptions_to_degraded_mode => e
+        Geetest.logger.info "Geetest validate request failed for #{e.message}, fall back to degraded mode"
+        true
+      end
+
+      private
+
+      def request!(payload, options = {})
+        response = RestClient.post "#{api_server}/validate?captcha_id=#{captcha_id}", options.merge(payload)
+        JSON.parse response.body
+      end
+    end
+  end
+end

data/lib/geetest.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'rest-client'
+
+require 'geetest/encryptor'
+
+require 'geetest/v3/concerns/degraded_mode'
+require 'geetest/v3/account'
+require 'geetest/v3/register'
+require 'geetest/v3/validator'
+
+require 'geetest/v4/account'
+
+module Geetest
+  class << self
+    attr_writer :logger
+
+    # Set up a geetest account and keep it in +Geetest.channels+
+    # @param [String, Symbol, Hash] channel_or_config
+    #
+    # @option opts [String] id Geetest CaptchaId
+    # @option opts [String] key Geetest CaptchaKey
+    # @option opts [String, Symbol] channel (:default) Which channel to store the instance
+    # @option opts [String, Symbol] :version (:V3) Which Captcha version to use
+    #
+    # other available opts depend on which Captcha version used
+    #   eg. digest_mod, api_server
+    #
+    # Set up by a hash config:
+    #   Geetest.setup(id: 'geetest_id', key: 'geetest_key')
+    #   Geetest.channel
+    #
+    # Set up by a hash config with channel name:
+    #   Geetest.setup(id: 'geetest_id', key: 'geetest_key', channel: 'login')
+    #   Geetest.channel(:login)
+    #
+    # Set up a channel by another way:
+    #   Geetest.setup('login').with(id: 'geetest_id', key: 'geetest_key')
+    #   Geetest.channel(:login)
+    #
+    def setup(channel_or_config)
+      if channel_or_config.is_a? Hash
+        build_channel(channel_or_config)
+      else
+        Object.new.tap do |unready_channel|
+          unready_channel.define_singleton_method(:with) { |opts| Geetest.setup opts.merge(channel: channel_or_config) }
+        end
+      end
+    end
+
+    def build_channel(config)
+      config = config.transform_keys(&:to_sym)
+      channel_name = config.delete(:channel) || :default
+      captcha_version = config.delete(:version) || :V3
+      captcha_id = config.delete(:id)
+      captcha_key = config.delete(:key)
+      account_klass = Geetest.const_get("#{captcha_version.upcase}::Account", false)
+      channels[channel_name.to_sym] = account_klass.new(captcha_id, captcha_key, **config)
+    end
+
+    def channel(channel_name = :default)
+      channels[channel_name.to_sym]
+    end
+
+    def channels
+      @channels ||= {}
+    end
+
+    def exceptions_to_degraded_mode
+      @exceptions_to_degraded_mode ||= [
+        ::SystemCallError, # includes ::Errno::EINVAL, ::Errno::ECONNRESET, ::Errno::ECONNREFUSED, ::Errno::ETIMEDOUT, and more
+        JSON::ParserError,
+        RestClient::InternalServerError,
+        RestClient::NotFound,
+        RestClient::RequestTimeout
+      ]
+    end
+
+    def logger
+      @logger ||= Logger.new(STDERR)
+    end
+  end
+end

data/lib/geetest_ruby_sdk/version.rb

@@ -0,0 +1,3 @@
+module GeetestRubySdk
+  VERSION = '4.0.3'
+end

data/lib/geetest_ruby_sdk.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'geetest'
+
+module GeetestRubySdk
+  extend SingleForwardable
+
+  delegate [:logger, :logger=, :exceptions_to_degraded_mode] => Geetest
+
+  # @deprecated Use +Geetest#setup+ instead.
+  def self.setup(geetest_id, geetest_key)
+    Geetest.setup id: geetest_id, key: geetest_key
+  end
+
+  if defined?(::Rails)
+    class Engine < ::Rails::Engine
+      # Rails -> use app/assets directory.
+
+      config.to_prepare do
+        Geetest.logger = ::Rails.logger
+      end
+    end
+  end
+end

data/vendor/assets/javascripts/gt.js

@@ -0,0 +1,353 @@
+"v0.4.8 Geetest Inc.";
+
+(function (window) {
+    "use strict";
+    if (typeof window === 'undefined') {
+        throw new Error('Geetest requires browser environment');
+    }
+
+    var document = window.document;
+    var Math = window.Math;
+    var head = document.getElementsByTagName("head")[0];
+
+    function _Object(obj) {
+        this._obj = obj;
+    }
+
+    _Object.prototype = {
+        _each: function (process) {
+            var _obj = this._obj;
+            for (var k in _obj) {
+                if (_obj.hasOwnProperty(k)) {
+                    process(k, _obj[k]);
+                }
+            }
+            return this;
+        }
+    };
+
+    function Config(config) {
+        var self = this;
+        new _Object(config)._each(function (key, value) {
+            self[key] = value;
+        });
+    }
+
+    Config.prototype = {
+        api_server: 'api.geetest.com',
+        protocol: 'http://',
+        typePath: '/gettype.php',
+        fallback_config: {
+            slide: {
+                static_servers: ["static.geetest.com", "dn-staticdown.qbox.me"],
+                type: 'slide',
+                slide: '/static/js/geetest.0.0.0.js'
+            },
+            fullpage: {
+                static_servers: ["static.geetest.com", "dn-staticdown.qbox.me"],
+                type: 'fullpage',
+                fullpage: '/static/js/fullpage.0.0.0.js'
+            }
+        },
+        _get_fallback_config: function () {
+            var self = this;
+            if (isString(self.type)) {
+                return self.fallback_config[self.type];
+            } else if (self.new_captcha) {
+                return self.fallback_config.fullpage;
+            } else {
+                return self.fallback_config.slide;
+            }
+        },
+        _extend: function (obj) {
+            var self = this;
+            new _Object(obj)._each(function (key, value) {
+                self[key] = value;
+            })
+        }
+    };
+    var isNumber = function (value) {
+        return (typeof value === 'number');
+    };
+    var isString = function (value) {
+        return (typeof value === 'string');
+    };
+    var isBoolean = function (value) {
+        return (typeof value === 'boolean');
+    };
+    var isObject = function (value) {
+        return (typeof value === 'object' && value !== null);
+    };
+    var isFunction = function (value) {
+        return (typeof value === 'function');
+    };
+    var MOBILE = /Mobi/i.test(navigator.userAgent);
+    var pt = MOBILE ? 3 : 0;
+
+    var callbacks = {};
+    var status = {};
+
+    var nowDate = function () {
+        var date = new Date();
+        var year = date.getFullYear();
+        var month = date.getMonth() + 1;
+        var day = date.getDate();
+        var hours = date.getHours();
+        var minutes = date.getMinutes();
+        var seconds = date.getSeconds();
+
+        if (month >= 1 && month <= 9) {
+            month = '0' + month;
+        }
+        if (day >= 0 && day <= 9) {
+            day = '0' + day;
+        }
+        if (hours >= 0 && hours <= 9) {
+            hours = '0' + hours;
+        }
+        if (minutes >= 0 && minutes <= 9) {
+            minutes = '0' + minutes;
+        }
+        if (seconds >= 0 && seconds <= 9) {
+            seconds = '0' + seconds;
+        }
+        var currentdate = year + '-' + month + '-' + day + " " + hours + ":" + minutes + ":" + seconds;
+        return currentdate;
+    }
+
+    var random = function () {
+        return parseInt(Math.random() * 10000) + (new Date()).valueOf();
+    };
+
+    var loadScript = function (url, cb) {
+        var script = document.createElement("script");
+        script.charset = "UTF-8";
+        script.async = true;
+
+        // 对geetest的静态资源添加 crossOrigin
+        if ( /static\.geetest\.com/g.test(url)) {
+            script.crossOrigin = "anonymous";
+        }
+
+        script.onerror = function () {
+            cb(true);
+        };
+        var loaded = false;
+        script.onload = script.onreadystatechange = function () {
+            if (!loaded &&
+                (!script.readyState ||
+                "loaded" === script.readyState ||
+                "complete" === script.readyState)) {
+
+                loaded = true;
+                setTimeout(function () {
+                    cb(false);
+                }, 0);
+            }
+        };
+        script.src = url;
+        head.appendChild(script);
+    };
+
+    var normalizeDomain = function (domain) {
+        // special domain: uems.sysu.edu.cn/jwxt/geetest/
+        // return domain.replace(/^https?:\/\/|\/.*$/g, ''); uems.sysu.edu.cn
+        return domain.replace(/^https?:\/\/|\/$/g, ''); // uems.sysu.edu.cn/jwxt/geetest
+    };
+    var normalizePath = function (path) {
+        path = path.replace(/\/+/g, '/');
+        if (path.indexOf('/') !== 0) {
+            path = '/' + path;
+        }
+        return path;
+    };
+    var normalizeQuery = function (query) {
+        if (!query) {
+            return '';
+        }
+        var q = '?';
+        new _Object(query)._each(function (key, value) {
+            if (isString(value) || isNumber(value) || isBoolean(value)) {
+                q = q + encodeURIComponent(key) + '=' + encodeURIComponent(value) + '&';
+            }
+        });
+        if (q === '?') {
+            q = '';
+        }
+        return q.replace(/&$/, '');
+    };
+    var makeURL = function (protocol, domain, path, query) {
+        domain = normalizeDomain(domain);
+
+        var url = normalizePath(path) + normalizeQuery(query);
+        if (domain) {
+            url = protocol + domain + url;
+        }
+
+        return url;
+    };
+
+    var load = function (config, send, protocol, domains, path, query, cb) {
+        var tryRequest = function (at) {
+
+            var url = makeURL(protocol, domains[at], path, query);
+            loadScript(url, function (err) {
+                if (err) {
+                    if (at >= domains.length - 1) {
+                        cb(true);
+                        // report gettype error
+                        if (send) {
+                            config.error_code = 508;
+                            var url = protocol + domains[at] + path;
+                            reportError(config, url);
+                        }
+                    } else {
+                        tryRequest(at + 1);
+                    }
+                } else {
+                    cb(false);
+                }
+            });
+        };
+        tryRequest(0);
+    };
+
+
+    var jsonp = function (domains, path, config, callback) {
+        if (isObject(config.getLib)) {
+            config._extend(config.getLib);
+            callback(config);
+            return;
+        }
+        if (config.offline) {
+            callback(config._get_fallback_config());
+            return;
+        }
+
+        var cb = "geetest_" + random();
+        window[cb] = function (data) {
+            if (data.status == 'success') {
+                callback(data.data);
+            } else if (!data.status) {
+                callback(data);
+            } else {
+                callback(config._get_fallback_config());
+            }
+            window[cb] = undefined;
+            try {
+                delete window[cb];
+            } catch (e) {
+            }
+        };
+        load(config, true, config.protocol, domains, path, {
+            gt: config.gt,
+            callback: cb
+        }, function (err) {
+            if (err) {
+                callback(config._get_fallback_config());
+            }
+        });
+    };
+
+    var reportError = function (config, url) {
+        load(config, false, config.protocol, ['monitor.geetest.com'], '/monitor/send', {
+            time: nowDate(),
+            captcha_id: config.gt,
+            challenge: config.challenge,
+            pt: pt,
+            exception_url: url,
+            error_code: config.error_code
+        }, function (err) {})
+    }
+
+    var throwError = function (errorType, config) {
+        var errors = {
+            networkError: '网络错误',
+            gtTypeError: 'gt字段不是字符串类型'
+        };
+        if (typeof config.onError === 'function') {
+            config.onError(errors[errorType]);
+        } else {
+            throw new Error(errors[errorType]);
+        }
+    };
+
+    var detect = function () {
+        return window.Geetest || document.getElementById("gt_lib");
+    };
+
+    if (detect()) {
+        status.slide = "loaded";
+    }
+
+    window.initGeetest = function (userConfig, callback) {
+
+        var config = new Config(userConfig);
+
+        if (userConfig.https) {
+            config.protocol = 'https://';
+        } else if (!userConfig.protocol) {
+            config.protocol = window.location.protocol + '//';
+        }
+
+        // for KFC
+        if (userConfig.gt === '050cffef4ae57b5d5e529fea9540b0d1' ||
+            userConfig.gt === '3bd38408ae4af923ed36e13819b14d42') {
+            config.apiserver = 'yumchina.geetest.com/'; // for old js
+            config.api_server = 'yumchina.geetest.com';
+        }
+
+        if(userConfig.gt){
+            window.GeeGT = userConfig.gt
+        }
+
+        if(userConfig.challenge){
+            window.GeeChallenge = userConfig.challenge
+        }
+
+        if (isObject(userConfig.getType)) {
+            config._extend(userConfig.getType);
+        }
+        jsonp([config.api_server || config.apiserver], config.typePath, config, function (newConfig) {
+            var type = newConfig.type;
+            var init = function () {
+                config._extend(newConfig);
+                callback(new window.Geetest(config));
+            };
+
+            callbacks[type] = callbacks[type] || [];
+            var s = status[type] || 'init';
+            if (s === 'init') {
+                status[type] = 'loading';
+
+                callbacks[type].push(init);
+
+                load(config, true, config.protocol, newConfig.static_servers || newConfig.domains, newConfig[type] || newConfig.path, null, function (err) {
+                    if (err) {
+                        status[type] = 'fail';
+                        throwError('networkError', config);
+                    } else {
+                        status[type] = 'loaded';
+                        var cbs = callbacks[type];
+                        for (var i = 0, len = cbs.length; i < len; i = i + 1) {
+                            var cb = cbs[i];
+                            if (isFunction(cb)) {
+                                cb();
+                            }
+                        }
+                        callbacks[type] = [];
+                    }
+                });
+            } else if (s === "loaded") {
+                init();
+            } else if (s === "fail") {
+                throwError('networkError', config);
+            } else if (s === "loading") {
+                callbacks[type].push(init);
+            }
+        });
+
+    };
+
+
+})(window);