trustcaptcha-ruby 1.0.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d42810d7f13e991b814a40eafda026452831869ad378a79aeccd44acf7a61709
-  data.tar.gz: 13c38027c3d9f886c4757a11cc00962de9e150e4e1d6673db94f75c6e1667799
+  metadata.gz: 85d74bf1f0b4aaac1ed7e612cdedb7fec49237b52bea370675215ef99b39cf24
+  data.tar.gz: 3a66c366c2060cb68160c0d3080ab2591ff5ec575bfbd56958b3c2ba486870ef
 SHA512:
-  metadata.gz: ec5b0433bf795d9c69d23eb8252b200864211b5068b92a92268732994c0bc208a19dcca76e657ba5885726cee06ca5c9a0f91b554a1404d7d32bae7fea83ce12
-  data.tar.gz: 8510735aa4e9efbca1cd97bcbb1607359c73648e5d8505398e03ed5cb364af001c836ab1d62ccaa2e6b9133edd36978f19640208b768d1d0f44c3ed913ec25b8
+  metadata.gz: cfdc5945cc4e4fdbcac701cc0b547c426cc7f730112da689b934a5026361984dc018daa28db14cb4c5f89fcddad5ede818639b22445028306e6039ed6b18a60b
+  data.tar.gz: 855add25e32b315804a55aaa74bb8d7383a8ed33f2629eaabbdda27d377bc3af65068d43cf7250f0f3fb5df337af44a257f1d82ab5f883bf12367c97fb45f171

data/lib/trustcaptcha/captcha_manager.rb

@@ -1,51 +1,49 @@
 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
+  class VerificationNotFinishedException < StandardError; end
 
-  def self.get_verification_result(base64_secret_key, base64_verification_token)
+  def self.get_verification_result(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)
+    fetch_verification_result(verification_token, secret_key)
   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)
+  def self.get_verification_token(base64_verification_token)
+    VerificationToken.from_base64(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}&pl=rb")
-    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)
+    url = URI("#{verification_token.api_endpoint}/verifications/#{verification_token.verification_id}/assessments")
+    headers = {
+      "tc-authorization" => access_token,
+      "tc-library-language" => "ruby",
+      "tc-library-version" => "1.2"
+    }
+    response = Net::HTTP.get_response(url, headers)
+
+    case response.code.to_i
+    when 403
+      raise SecretKeyInvalidException, "Secret key is invalid"
+    when 404
+      raise VerificationNotFoundException, "Verification not found"
+    when 423
+      raise VerificationNotFinishedException, "Verification not finished"
+    else
+      raise "Failed to retrieve verification result: HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+    end
 
     VerificationResult.from_json(response.body)
-  rescue StandardError => e
-    raise "Failed to retrieve verification result: #{e.message}"
   end
 end

data/lib/trustcaptcha/model/verification_token.rb

@@ -1,18 +1,18 @@
 require 'json'
 require 'securerandom'
+require 'base64'
 
 class VerificationToken
-  attr_reader :api_endpoint, :verification_id, :encrypted_access_token
+  attr_reader :api_endpoint, :verification_id
 
-  def initialize(api_endpoint, verification_id, encrypted_access_token)
+  def initialize(api_endpoint, verification_id)
     @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'])
+    new(data['apiEndpoint'], data['verificationId'])
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trustcaptcha-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Trustcaptcha GmbH
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2024-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -46,7 +46,6 @@ 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

data/lib/trustcaptcha/aes_encryption.rb

@@ -1,26 +0,0 @@
-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