trustcaptcha-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d78761eef52835f808e6d3ee33558c690a568aadb9ab1ec4c27620ba05d6a1c5
+  data.tar.gz: 183647f8234e6b834e5ac277ae580d487e353790f1d0cb84dd88abc65fc5a980
+SHA512:
+  metadata.gz: 5257883ec25f2fe55f521879a53a8beefb8d4628a70cf7bfde975bfb1f04e15e95f41cec4e2c6ad94a31eb000b49ebc826ec4943772c60a9b68867a0bf40b981
+  data.tar.gz: 0eca12736d3b9e5144600c52caaefd726590d544bcb4ed5615ceb9d48a6fc4108fdda7ebad7c7e4b68e37d0a3e876b24cceb57dfe5d9a7ec7d3444f6f0452155

data/lib/trustcaptcha/aes_encryption.rb

@@ -0,0 +1,26 @@
+require 'openssl'
+require 'base64'
+
+class AesEncryption
+  STANDARD_BLOCK_SIZE = 16
+
+  def self.to_aes_secret_key(key_string)
+    Base64.decode64(key_string)
+  end
+
+  def self.decrypt_to_string(key, encrypted_text)
+    decoded = Base64.decode64(encrypted_text)
+    decrypt(key, decoded)
+  end
+
+  def self.decrypt(key, encrypted_data)
+    iv = encrypted_data[0, STANDARD_BLOCK_SIZE]
+    cipher_text = encrypted_data[STANDARD_BLOCK_SIZE..-1]
+    decipher = OpenSSL::Cipher::AES256.new(:CBC)
+    decipher.decrypt
+    decipher.key = key
+    decipher.iv = iv
+    decrypted = decipher.update(cipher_text) + decipher.final
+    decrypted.force_encoding('UTF-8')
+  end
+end

data/lib/trustcaptcha/captcha_manager.rb

@@ -0,0 +1,51 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require_relative 'aes_encryption'
+require_relative 'model/verification_token'
+require_relative 'model/verification_result'
+
+class CaptchaManager
+  class SecretKeyInvalidException < StandardError; end
+  class TokenDecryptionFailedException < StandardError; end
+  class VerificationTokenInvalidException < StandardError; end
+  class VerificationNotFoundException < StandardError; end
+
+  def self.get_verification_result(base64_secret_key, base64_verification_token)
+    verification_token = get_verification_token(base64_verification_token)
+    secret_key = get_secret_key(base64_secret_key)
+    decrypted_access_token = decrypt_access_token(secret_key, verification_token)
+    fetch_verification_result(verification_token, decrypted_access_token)
+  end
+
+  private
+
+  def self.get_secret_key(base64_secret_key)
+    AesEncryption.to_aes_secret_key(base64_secret_key)
+  rescue StandardError => e
+    raise SecretKeyInvalidException, "Invalid secret key: #{e.message}"
+  end
+
+  def self.get_verification_token(verification_token)
+    VerificationToken.from_base64(verification_token)
+  rescue StandardError => e
+    raise VerificationTokenInvalidException, "Invalid verification token: #{e.message}"
+  end
+
+  def self.decrypt_access_token(secret_key, verification_token)
+    AesEncryption.decrypt_to_string(secret_key, verification_token.encrypted_access_token)
+  rescue StandardError => e
+    raise TokenDecryptionFailedException, "Failed to decrypt access token: #{e.message}"
+  end
+
+  def self.fetch_verification_result(verification_token, access_token)
+    url = URI("#{verification_token.api_endpoint}/verifications/#{verification_token.verification_id}/assessments?accessToken=#{access_token}")
+    response = Net::HTTP.get_response(url)
+    raise VerificationNotFoundException, "Verification not found" if response.code == '404'
+    raise "Failed to retrieve verification result: HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+    VerificationResult.from_json(response.body)
+  rescue StandardError => e
+    raise "Failed to retrieve verification result: #{e.message}"
+  end
+end

data/lib/trustcaptcha/model/verification_result.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+class VerificationResult
+  attr_reader :captcha_id, :verification_id, :score, :reason, :mode, :origin, :ip_address,
+              :device_family, :operating_system, :browser, :creation_timestamp,
+              :release_timestamp, :retrieval_timestamp, :verification_passed
+
+  def initialize(data)
+    @captcha_id = data['captchaId']
+    @verification_id = data['verificationId']
+    @score = data['score']
+    @reason = data['reason']
+    @mode = data['mode']
+    @origin = data['origin']
+    @ip_address = data['ipAddress']
+    @device_family = data['deviceFamily']
+    @operating_system = data['operatingSystem']
+    @browser = data['browser']
+    @creation_timestamp = data['creationTimestamp']
+    @release_timestamp = data['releaseTimestamp']
+    @retrieval_timestamp = data['retrievalTimestamp']
+    @verification_passed = data['verificationPassed']
+  end
+
+  def self.from_json(json_data)
+    data = JSON.parse(json_data)
+    new(data)
+  end
+
+  def to_json(*_args)
+    {
+      captchaId: @captcha_id,
+      verificationId: @verification_id,
+      score: @score,
+      reason: @reason,
+      mode: @mode,
+      origin: @origin,
+      ipAddress: @ip_address,
+      deviceFamily: @device_family,
+      operatingSystem: @operating_system,
+      browser: @browser,
+      creationTimestamp: @creation_timestamp,
+      releaseTimestamp: @release_timestamp,
+      retrievalTimestamp: @retrieval_timestamp,
+      verificationPassed: @verification_passed
+    }.to_json
+  end
+end

data/lib/trustcaptcha/model/verification_token.rb

@@ -0,0 +1,18 @@
+require 'json'
+require 'securerandom'
+
+class VerificationToken
+  attr_reader :api_endpoint, :verification_id, :encrypted_access_token
+
+  def initialize(api_endpoint, verification_id, encrypted_access_token)
+    @api_endpoint = api_endpoint
+    @verification_id = verification_id
+    @encrypted_access_token = encrypted_access_token
+  end
+
+  def self.from_base64(base64_string)
+    json_string = Base64.decode64(base64_string)
+    data = JSON.parse(json_string)
+    new(data['apiEndpoint'], data['verificationId'], data['encryptedAccessToken'])
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: trustcaptcha-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Trustcaptcha GmbH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides integration with Trustcaptcha for Ruby applications,
+  offering CAPTCHA verification with a focus on security and privacy.
+email:
+- mail@trustcaptcha.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/trustcaptcha/aes_encryption.rb
+- lib/trustcaptcha/captcha_manager.rb
+- lib/trustcaptcha/model/verification_result.rb
+- lib/trustcaptcha/model/verification_token.rb
+homepage: https://www.trustcaptcha.com
+licenses:
+- Apache-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+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: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Trustcaptcha library for Ruby
+test_files: []