enzoic 1.1.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 193cc6ee5e5585ea3a76add970ce69feb44c2383
-  data.tar.gz: a77cdcf48592e05a9f06ef1ad486467002f2df30
+SHA256:
+  metadata.gz: a9299615755ffc582bb35414b6851ba06c11f236565542ef1d7b5d8b681ec776
+  data.tar.gz: 12e91e3208c526598672ecbf066af5734237345954e76320ae7163691d4f25e7
 SHA512:
-  metadata.gz: 641ca919dd26147fe4e06550923f380f2b54eb0959372171f57a4f17ff2bcd5f98adcd446d3d39e9f0205910671307c7e78b6954ffa77e0ad58513f25ca31084
-  data.tar.gz: 9acf2c9d120dc0292f136b7583ba0d36f2aacd4c7e9fe52de19ec2c6468f7f42738e939250893345fe1fdc6e5d77b44e203db2558b34b0a541303365515b393d
+  metadata.gz: 888318919c30799a05c6cb91ddf0d986a5b86ac9d0a4ca0db76ed725fac7f4e91dd2d8a9a9353af0bd375b9c3e4284a979a3391d1649292521a145b04f9e577f
+  data.tar.gz: dad8311f61c0bdadd39436e53db8ec02e0f61313233aba3f0337c7cf403ec3cbe0b04d2b97a16194c3c4d1c2e578cdf0233bfea560046208f0c692e08a73497b

data/README.md

@@ -35,6 +35,7 @@ require 'enzoic'
 enzoic = Enzoic::Enzoic.new(apiKey: YOUR_API_KEY, secret: YOUR_API_SECRET)
 
 # Check whether a password has been compromised
+# see https://www.enzoic.com/docs-passwords-api/ for more information
 if enzoic.check_password("password-to-test")
     puts("Password is compromised")
 else
@@ -42,6 +43,7 @@ else
 end
 
 # Check whether a specific set of credentials are compromised
+# see https://www.enzoic.com/docs-credentials-api/ for more information
 if enzoic.check_credentials("test@enzoic.com", "password-to-test")
     puts("Credentials are compromised")
 else
@@ -53,7 +55,7 @@ end
 # lastCheckDate is the timestamp for the last check you performed for this user.
 # If the DateTime you provide for the last check is greater than the timestamp Enzoic has 
 # for the last breach affecting this user, the check will not be performed.  
-# This can be used to substantially increase performance. 
+# This can be used to substantially increase performance.
 if enzoic.check_credentials("test@enzoic.com", "password-to-test", DateTime.parse("2019-07-15T19:57:43.000Z"))
     puts("Credentials are compromised")
 else
@@ -61,12 +63,20 @@ else
 end
 
 # get all exposures for a given user
+# see https://www.enzoic.com/docs-exposures-api/#get-exposures for more information
 exposures = enzoic.get_exposures_for_user("test@enzoic.com")
 puts(exposures.count.to_s + " exposures found for test@enzoic.com")
 
 # now get the full details for the first exposure found
+# see https://www.enzoic.com/docs-exposures-api/#get-exposure-details for more information
 details = enzoic.get_exposure_details(exposures.exposures[0])
 puts("First exposure for test@enzoic.com was " + details.title)
+
+# get all passwords for a given user - requires special approval, contact Enzoic sales
+# see https://www.enzoic.com/docs-raw-passwords-api/ for more information
+user_passwords = enzoic.get_passwords_for_user("eicar_0@enzoic.com")
+puts("First password for eicar_0@enzoic.com was " + user_passwords.passwords[0].password)
+
 ```
 
 More information in reference format can be found below.

data/Rakefile

@@ -20,9 +20,9 @@ Rake::ExtensionTask.new('whirlpool', gemspec) do |ext|
   ext.lib_dir = 'lib/digest'
 end
 
-# Rake::ExtensionTask.new('argon2-wrapper', gemspec) do |ext|
-#   ext.ext_dir = 'ext/argon2-wrapper'
-#   ext.lib_dir = 'lib/enzoic'
-# end
+Rake::ExtensionTask.new('argon2-wrapper', gemspec) do |ext|
+  ext.ext_dir = 'ext/argon2-wrapper'
+  ext.lib_dir = 'lib/enzoic'
+end
 
 task :default => :test

data/enzoic.gemspec

@@ -20,14 +20,14 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.add_dependency 'ffi', '~> 1.11.1'
+  spec.add_dependency 'ffi', '~> 1.15.5'
   spec.add_dependency 'ffi-compiler', '~> 1.0.1'
   spec.add_dependency 'rest-client', '~> 2.0', '>= 2.0.2'
   spec.add_dependency 'bcrypt', '~> 3.1', '>= 3.1.11'
   spec.add_dependency 'unix-crypt', '~> 1.3'
   spec.add_dependency 'base64url', '~> 1.0', '>= 1.0.1'
 
-  spec.add_development_dependency "bundler", '~> 2.0.2', '>= 2.0.2'
+  spec.add_development_dependency "bundler", '~> 2.2.11', '>= 2.2.11'
   spec.add_development_dependency "rake", '~> 10.4', '>= 10.4.2'
   spec.add_development_dependency "test-unit", '~> 3.2', '>= 3.2.4'
   spec.add_development_dependency "rake-compiler", '~> 1.0', '>= 1.0.4'

data/lib/enzoic/hashing.rb

@@ -3,7 +3,8 @@ require 'digest'
 require 'bcrypt'
 require 'unix_crypt'
 require 'zlib'
-require 'digest/whirlpool'
+require 'digest/whirlpool.bundle'
+#require 'open_ssl'
 require 'base64url'
 
 module Enzoic
@@ -24,6 +25,14 @@ module Enzoic
       return Digest::SHA1.hexdigest to_hash
     end
 
+    def self.sha1_binary(to_hash)
+      return Digest::SHA1.digest(to_hash).bytes
+    end
+
+    def self.sha1_binary_array(to_hash_bytes)
+      return Digest::SHA1.digest(to_hash_bytes.pack('c*')).bytes
+    end
+
     def self.sha256(to_hash)
       return Digest::SHA256.hexdigest to_hash
     end
@@ -91,7 +100,7 @@ module Enzoic
 
       itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
       to_hash_bytes = to_hash.bytes
-      count = 2**itoa64.index(salt[3])
+      count = 2 ** itoa64.index(salt[3])
       justsalt = salt[4..12]
 
       hash = self.md5_binary(justsalt + to_hash)
@@ -148,13 +157,169 @@ module Enzoic
     end
 
     def self.md5crypt(to_hash, salt)
-      return UnixCrypt::MD5.build(to_hash, salt.start_with?("$1$") ? salt[3..salt.length] : salt);
+      return UnixCrypt::MD5.build(to_hash, salt.start_with?("$1$") ? salt[3..salt.length] : salt)
     end
 
     def self.custom_algorithm4(to_hash, salt)
       return self.bcrypt(self.md5(to_hash), salt)
     end
 
+    def self.custom_algorithm5(to_hash, salt)
+      return self.sha256(self.md5(to_hash + salt))
+    end
+
+    def self.osCommerce_AEF(to_hash, salt)
+      return self.md5(salt + to_hash)
+    end
+
+    def self.desCrypt(to_hash, salt)
+      return UnixCrypt::DES.build(to_hash, salt)
+    end
+
+    def self.convertToUnsigned(val)
+      return [val].pack('L').unpack('L').first
+    end
+
+    def self.mySQLPre4_1(to_hash)
+      nr = 1345345333
+      add = 7
+      nr2 = 0x12345671
+
+      for i in 0..to_hash.length - 1 do
+        c = to_hash[i]
+
+        if c == " " || c == "\t"
+          next
+        end
+
+        tmp = c.ord
+        nr = nr ^ ((((nr & 63) + add) * tmp) + (self.convertToUnsigned(nr << 8)))
+        nr2 += (self.convertToUnsigned(nr2 << 8)) ^ nr
+        add += tmp
+      end
+
+      result1 = nr & ((self.convertToUnsigned(1 << 31)) - 1)
+      result2 = nr2 & ((self.convertToUnsigned(1 << 31)) - 1)
+
+      return result1.to_s(16) + result2.to_s(16)
+    end
+
+    def self.mySQLPost4_1(to_hash)
+      return "*" + self.bytes_to_hex(self.sha1_binary_array(self.sha1_binary(to_hash)));
+    end
+
+    def self.punBB(to_hash, salt)
+      return self.sha1(salt + self.sha1(to_hash))
+    end
+
+    def self.custom_algorithm6(to_hash, salt)
+      return self.sha1(to_hash + salt)
+    end
+
+    def self.partial_md5_20(to_hash)
+      return self.md5(to_hash)[0..19]
+    end
+
+    def self.partial_md5_29(to_hash)
+      return self.md5(to_hash)[0..28]
+    end
+
+    def self.ave_datalife_diferior(to_hash)
+      return self.md5(self.md5(to_hash))
+    end
+
+    def self.django_md5(to_hash, salt)
+      return "md5$" + salt + "$" + self.md5(salt + to_hash)
+    end
+
+    def self.django_sha1(to_hash, salt)
+      return "sha1$" + salt + "$" + self.sha1(salt + to_hash)
+    end
+
+    def self.pligg_cms(to_hash, salt)
+      return salt + self.sha1(salt + to_hash)
+    end
+
+    def self.runcms_smf1_1(to_hash, salt)
+      return self.sha1(salt + to_hash)
+    end
+
+    def self.ntlm(to_hash)
+      pwd = to_hash.dup
+      pwd = pwd.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8')
+      OpenSSL::Digest::MD4.hexdigest pwd
+    end
+
+    def self.sha1dash(to_hash, salt)
+      return self.sha1("--" + salt + "--" + to_hash + "--")
+    end
+
+    def self.sha384(to_hash)
+      return Digest::SHA384.hexdigest to_hash
+    end
+
+    def self.custom_algorithm7(to_hash, salt)
+      derived_salt = self.sha1(salt)
+      return OpenSSL::HMAC.hexdigest("SHA256",
+                                     "d2e1a4c569e7018cc142e9cce755a964bd9b193d2d31f02d80bb589c959afd7e",
+                                     derived_salt + to_hash)
+    end
+
+    def self.custom_algorithm9(to_hash, salt)
+      result = self.sha512(to_hash + salt)
+      for i in 0..10 do
+        result = self.sha512(result)
+      end
+      return result
+    end
+
+    def self.sha256crypt(to_hash, salt)
+      return self.sha_crypt("5", UnixCrypt::SHA256, to_hash, salt)
+    end
+
+    def self.sha512crypt(to_hash, salt)
+      return self.sha_crypt("6", UnixCrypt::SHA512, to_hash, salt)
+    end
+
+    def self.sha_crypt(crypt_version, crypter, to_hash, salt)
+      # special handling if the salt contains an embedded rounds specifier
+      if salt.start_with?("$" + crypt_version + "$") && salt.include?("$rounds=")
+        # extract rounds
+        rounds_starting_idx = salt.index("$rounds=") + 8
+        rounds = salt[rounds_starting_idx..salt.length]
+        salt_portion = rounds[rounds.index("$") + 1..rounds.length]
+
+        begin
+          rounds = Integer(rounds[0..rounds.index("$") - 1])
+        rescue ArgumentError
+          rounds = 5000
+        end
+
+        result = crypter.build(to_hash, salt_portion, rounds)
+
+        # if the default rounds of 5000 was used, add this back in to the resultant hash as this library, unlike most,
+        # will strip it out.
+        if rounds == 5000
+          result = result[0..2] + "rounds=5000$" + result[3..result.length]
+        end
+
+        return result
+      end
+      return crypter.build(to_hash, salt.start_with?("$" + crypt_version + "$") ? salt[3..salt.length] : salt)
+    end
+
+    def self.custom_algorithm10(to_hash, salt)
+      return self.sha512(to_hash + ":" + salt)
+    end
+
+    def self.hmac_sha1_salt_as_hash(to_hash, salt)
+      return OpenSSL::HMAC.hexdigest("sha1", salt, to_hash)
+    end
+
+    def self.authMeSHA256(to_hash, salt)
+      return "$SHA$" + salt + "$" + self.sha256(self.sha256(to_hash) + salt);
+    end
+
     def self.argon2_raw(to_hash, salt)
       time_cost = 3
       mem_cost = 10
@@ -238,13 +403,13 @@ module Enzoic
     end
 
     def self.xor(byte_array1, byte_array2)
-        result = Array.new(byte_array1.length);
+      result = Array.new(byte_array1.length);
 
-        for i in 0..byte_array1.length - 1 do
-            result[i] = byte_array1[i] ^ byte_array2[i];
-        end
+      for i in 0..byte_array1.length - 1 do
+        result[i] = byte_array1[i] ^ byte_array2[i];
+      end
 
-        return result;
+      return result;
     end
 
     def self.bytes_to_hex(bytes)

data/lib/enzoic/password_type.rb

@@ -18,6 +18,33 @@ module Enzoic
     SHA512 = 14
     MD5Crypt = 16
     CustomAlgorithm4 = 17
+    CustomAlgorithm5 = 18
+    OsCommerce_AEF = 19
+    DESCrypt = 20
+    MySQLPre4_1 = 21
+    MySQLPost4_1 = 22
+    PeopleSoft = 23
+    PunBB = 24
+    CustomAlgorithm6 = 25
+    PartialMD5_20 = 26
+    AVE_DataLife_Diferior = 27
+    DjangoMD5 = 28
+    DjangoSHA1 = 29
+    PartialMD5_29 = 30
+    PliggCMS = 31
+    RunCMS_SMF1_1 = 32
+    NTLM = 33
+    SHA1Dash = 34
+    SHA384 = 35
+    CustomAlgorithm7 = 36
+    CustomAlgorithm8 = 37
+    CustomAlgorithm9 = 38
+    SHA512Crypt = 39
+    CustomAlgorithm10 = 40
+    HMACSHA1_SaltAsHash = 41
+    AuthMeSHA256 = 42
+    SHA256Crypt = 43
+
     Unknown = 97
     UnusablePassword = 98
     None = 99

data/lib/enzoic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 # Standard Gem version constant.
 module Enzoic
-  VERSION = "1.1.3".freeze
+  VERSION = "1.3.0".freeze
 end

data/lib/enzoic.rb

@@ -15,61 +15,72 @@ module Enzoic
   # to access the Enzoic API.
   class Enzoic
     def initialize(options = {})
-      @apiKey = options[:apiKey] || '';
+      @apiKey = options[:apiKey] || ''
       raise EnzoicFail, "No API key provided" if @apiKey == ''
-      @secret = options[:secret] || '';
+      @secret = options[:secret] || ''
       raise EnzoicFail, "No Secret provided" if @secret == ''
       @baseURL = options[:baseURL] || "https://api.enzoic.com/v1"
       @authString = calc_auth_string(@apiKey, @secret)
     end
 
-    def check_credentials(username, password, lastCheckTimestamp = Date.new(1980, 1, 1))
+    def check_credentials(username, password, last_check_timestamp = Date.new(1980, 1, 1))
       raise EnzoicFail, "API key/Secret not set" if !@authString || @authString == ''
 
-      response = make_rest_call(@baseURL + Constants::ACCOUNTS_API_PATH + "?username=" + Hashing.sha256(username), "GET", nil)
+      response = make_rest_call(@baseURL + Constants::ACCOUNTS_API_PATH +
+                                  "?username=" + Hashing.sha256(username.downcase),
+                                "GET", nil)
 
-      if (response == "404")
+      if response == "404"
         return false
       end
 
       account_response = JSON.parse(response)
 
       # if lastCheckTimestamp was provided, see if we need to go any further
-      if (Date.parse(account_response["lastBreachDate"]) > lastCheckTimestamp)
+      if Date.parse(account_response["lastBreachDate"]) > last_check_timestamp
         hashes_required = account_response["passwordHashesRequired"]
 
         bcrypt_count = 0
         query_string = ""
+        credential_hashes = []
 
-        for i in 0..hashes_required.length - 1 do
-          hash_spec = hashes_required[i]
-
+        hashes_required.each do |hash_spec|
           # bcrypt gets far too expensive for good response time if there are many of them to calculate.
           # some mostly garbage accounts have accumulated a number of them in our DB and if we happen to hit one it
           # kills performance, so short circuit out after at most 2 BCrypt hashes
-          if (hash_spec["hashType"] != PasswordType::BCrypt || bcrypt_count <= 2)
-            if (hash_spec["hashType"] == PasswordType::BCrypt)
+          if hash_spec["hashType"] != PasswordType::BCrypt || bcrypt_count <= 2
+            if hash_spec["hashType"] == PasswordType::BCrypt
               bcrypt_count = bcrypt_count + 1
             end
 
-            if (hash_spec["hashType"] != nil)
-              credential_hash = calc_credential_hash(username, password, account_response["salt"], hash_spec);
+            if hash_spec["hashType"] != nil
+              credential_hash = calc_credential_hash(username.downcase, password, account_response["salt"], hash_spec)
+
+              if credential_hash != nil
+                credential_hashes << credential_hash
 
-              if (credential_hash != nil)
-                if (query_string.length == 0)
-                  query_string = query_string + "?hashes=" + CGI.escape(credential_hash);
+                if query_string.length == 0
+                  query_string = query_string + "?partialHashes=" + CGI.escape(credential_hash[0..6])
                 else
-                  query_string = query_string + "&hashes=" + CGI.escape(credential_hash);
+                  query_string = query_string + "&partialHashes=" + CGI.escape(credential_hash[0..6])
                 end
               end
             end
           end
         end
 
-        if (query_string.length > 0)
+        if query_string.length > 0
           creds_response = make_rest_call(
-                  @baseURL + Constants::CREDENTIALS_API_PATH + query_string, "GET", nil)
-          return creds_response != "404"
+            @baseURL + Constants::CREDENTIALS_API_PATH + query_string, "GET", nil)
+
+          if creds_response != "404"
+            creds_result = JSON.parse(creds_response, object_class: OpenStruct)
+            creds_result.candidateHashes.each do |candidateHash|
+              if credential_hashes.include? candidateHash
+                return true
+              end
+            end
+          end
         end
       end
 
@@ -77,21 +88,36 @@ module Enzoic
     end
 
     def check_password(password)
+      md5 = Hashing.md5(password)
+      sha1 = Hashing.sha1(password)
+      sha256 = Hashing.sha256(password)
+
       response = make_rest_call(
-              @baseURL + Constants::PASSWORDS_API_PATH +
-                  "?md5=" + Hashing.md5(password) +
-                  "&sha1=" + Hashing.sha1(password) +
-                  "&sha256=" + Hashing.sha256(password),
-              "GET", nil)
+        @baseURL + Constants::PASSWORDS_API_PATH, "POST",
+        '{' +
+          '"partialMD5":"' + md5[0..6] + '",' +
+          '"partialSHA1":"' + sha1[0..6] + '",' +
+          '"partialSHA256":"' + sha256[0..6] + '"' +
+          '}')
 
-      return response != "404"
+      if response != "404"
+        result = JSON.parse(response, object_class: OpenStruct)
+
+        result.candidates.each do |candidate|
+          if candidate.md5 == md5 || candidate.sha1 == sha1 || candidate.sha256 == sha256
+            return true
+          end
+        end
+      end
+
+      return false
     end
 
     def get_exposures_for_user(username)
-      response = make_rest_call(@baseURL + Constants::EXPOSURES_API_PATH + "?username=" + Hashing.sha256(username),
-        "GET", nil)
+      response = make_rest_call(@baseURL + Constants::EXPOSURES_API_PATH + "?username=" + Hashing.sha256(username.downcase),
+                                "GET", nil)
 
-      if (response == "404")
+      if response == "404"
         # don't have this email in the DB - return empty response
         return JSON.parse('{ "count": 0, "exposures": [] }', object_class: OpenStruct)
       else
@@ -102,9 +128,9 @@ module Enzoic
 
     def get_exposure_details(exposure_id)
       response = make_rest_call(@baseURL + Constants::EXPOSURES_API_PATH + "?id=" + CGI.escape(exposure_id),
-        "GET", nil)
+                                "GET", nil)
 
-      if (response != "404")
+      if response != "404"
         # deserialize response
         return JSON.parse(response, object_class: OpenStruct)
       else
@@ -112,82 +138,180 @@ module Enzoic
       end
     end
 
-    private
-      def make_rest_call(rest_url, method, body)
-        begin
-          response = RestClient::Request.execute(method: method, url: rest_url,
-            headers: { content_type: :json, accept: :json, authorization: @authString })
-          return response.body
-        rescue RestClient::NotFound
-          return "404"
-        end
+    def get_passwords_for_user(username)
+      response = make_rest_call(@baseURL + Constants::ACCOUNTS_API_PATH + "?username=" +
+                                  Hashing.sha256(username.downcase) + "&includePasswords=1",
+                                "GET", nil)
+
+      if response == "404"
+        # don't have this email in the DB - return empty response
+        return JSON.parse('{ "lastBreachDate": null, "passwords": [] }', object_class: OpenStruct)
+      else
+        # deserialize response
+        return JSON.parse(response, object_class: OpenStruct)
       end
+    end
 
-      def calc_credential_hash(username, password, salt, hash_spec)
-        password_hash = calc_password_hash(hash_spec["hashType"], password, hash_spec["salt"])
+    private
 
-        if (password_hash != nil)
-          return Hashing.argon2_raw(username + "$" + password_hash, salt)
-        else
-          return nil
-        end
+    def make_rest_call(rest_url, method, body)
+      begin
+        response = RestClient::Request.execute(method: method, url: rest_url,
+                                               payload: body,
+                                               headers: { content_type: :json, accept: :json, authorization: @authString })
+        return response.body
+      rescue RestClient::NotFound
+        return "404"
       end
+    end
 
-      def calc_password_hash(password_type, password, salt)
-        case password_type
-        when PasswordType::MD5
-          return Hashing.md5(password)
-        when PasswordType::SHA1
-          return Hashing.sha1(password)
-        when PasswordType::SHA256
-          return Hashing.sha256(password)
-        when PasswordType::SHA512
-          return Hashing.sha512(password)
-        when PasswordType::IPBoard_MyBB
-          if (salt != nil && salt.length > 0)
-            return Hashing.mybb(password, salt)
-          end
-        when PasswordType::VBulletinPre3_8_5
-          if (salt != nil && salt.length > 0)
-            return Hashing.vbulletin(password, salt)
-          end
-        when PasswordType::VBulletinPost3_8_5
-          if (salt != nil && salt.length > 0)
-            return Hashing.vbulletin(password, salt)
-          end
-        when PasswordType::BCrypt
-          if (salt != nil && salt.length > 0)
-            return Hashing.bcrypt(password, salt)
-          end
-        when PasswordType::CRC32
-          return Hashing.crc32(password)
-        when PasswordType::PHPBB3
-          if (salt != nil && salt.length > 0)
-            return Hashing.phpbb3(password, salt)
-          end
-        when PasswordType::CustomAlgorithm1
-          if (salt != nil && salt.length > 0)
-            return Hashing.custom_algorithm1(password, salt)
-          end
-        when PasswordType::CustomAlgorithm2
-          if (salt != nil && salt.length > 0)
-            return Hashing.custom_algorithm2(password, salt)
-          end
-        when PasswordType::MD5Crypt
-          if (salt != nil && salt.length > 0)
-            return Hashing.md5crypt(password, salt)
-          end
-        when PasswordType::CustomAlgorithm4
-          if (salt != nil && salt.length > 0)
-            return Hashing.custom_algorithm4(password, salt)
-          end
-        end
+    def calc_credential_hash(username, password, salt, hash_spec)
+      password_hash = calc_password_hash(hash_spec["hashType"], password, hash_spec["salt"])
 
+      if password_hash != nil
+        return Hashing.argon2_raw(username.downcase + "$" + password_hash, salt)
+      else
         return nil
       end
+    end
 
-      def calc_auth_string(apiKey, secret)
-        return "basic " + Base64.strict_encode64(apiKey + ":" + secret);
+    def calc_password_hash(password_type, password, salt)
+      case password_type
+      when PasswordType::MD5
+        return Hashing.md5(password)
+      when PasswordType::SHA1
+        return Hashing.sha1(password)
+      when PasswordType::SHA256
+        return Hashing.sha256(password)
+      when PasswordType::SHA512
+        return Hashing.sha512(password)
+      when PasswordType::IPBoard_MyBB
+        if salt != nil && salt.length > 0
+          return Hashing.mybb(password, salt)
+        end
+      when PasswordType::VBulletinPre3_8_5
+        if salt != nil && salt.length > 0
+          return Hashing.vbulletin(password, salt)
+        end
+      when PasswordType::VBulletinPost3_8_5
+        if salt != nil && salt.length > 0
+          return Hashing.vbulletin(password, salt)
+        end
+      when PasswordType::BCrypt
+        if salt != nil && salt.length > 0
+          return Hashing.bcrypt(password, salt)
+        end
+      when PasswordType::CRC32
+        return Hashing.crc32(password)
+      when PasswordType::PHPBB3
+        if salt != nil && salt.length > 0
+          return Hashing.phpbb3(password, salt)
+        end
+      when PasswordType::CustomAlgorithm1
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm1(password, salt)
+        end
+      when PasswordType::CustomAlgorithm2
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm2(password, salt)
+        end
+      when PasswordType::MD5Crypt
+        if salt != nil && salt.length > 0
+          return Hashing.md5crypt(password, salt)
+        end
+      when PasswordType::CustomAlgorithm4
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm4(password, salt)
+        end
+      when PasswordType::CustomAlgorithm5
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm5(password, salt)
+        end
+      when PasswordType::OsCommerce_AEF
+        if salt != nil && salt.length > 0
+          return Hashing.osCommerce_AEF(password, salt)
+        end
+      when PasswordType::DESCrypt
+        if salt != nil && salt.length > 0
+          return Hashing.desCrypt(password, salt)
+        end
+      when PasswordType::MySQLPre4_1
+        return Hashing.mySQLPre4_1(password)
+      when PasswordType::MySQLPost4_1
+        return Hashing.mySQLPost4_1(password)
+      when PasswordType::PunBB
+        if salt != nil && salt.length > 0
+          return Hashing.punBB(password, salt)
+        end
+      when PasswordType::CustomAlgorithm6
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm6(password, salt)
+        end
+      when PasswordType::PartialMD5_20
+        return Hashing.partial_md5_20(password)
+      when PasswordType::AVE_DataLife_Diferior
+        return Hashing.ave_datalife_diferior(password)
+      when PasswordType::DjangoMD5
+        if salt != nil && salt.length > 0
+          return Hashing.django_md5(password, salt)
+        end
+      when PasswordType::DjangoSHA1
+        if salt != nil && salt.length > 0
+          return Hashing.django_sha1(password, salt)
+        end
+      when PasswordType::PartialMD5_29
+        return Hashing.partial_md5_29(password)
+      when PasswordType::PliggCMS
+        if salt != nil && salt.length > 0
+          return Hashing.pligg_cms(password, salt)
+        end
+      when PasswordType::RunCMS_SMF1_1
+        if salt != nil && salt.length > 0
+          return Hashing.runcms_smf1_1(password, salt)
+        end
+      when PasswordType::NTLM
+        return Hashing.ntlm(password)
+      when PasswordType::SHA1Dash
+        if salt != nil && salt.length > 0
+          return Hashing.sha1dash(password, salt)
+        end
+      when PasswordType::SHA384
+        return Hashing.sha384(password)
+      when PasswordType::CustomAlgorithm7
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm7(password, salt)
+        end
+      when PasswordType::CustomAlgorithm9
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm9(password, salt)
+        end
+      when PasswordType::SHA512Crypt
+        if salt != nil && salt.length > 0
+          return Hashing.sha512crypt(password, salt)
+        end
+      when PasswordType::CustomAlgorithm10
+        if salt != nil && salt.length > 0
+          return Hashing.custom_algorithm10(password, salt)
+        end
+      when PasswordType::SHA256Crypt
+        if salt != nil && salt.length > 0
+          return Hashing.sha256crypt(password, salt)
+        end
+      when PasswordType::AuthMeSHA256
+        if salt != nil && salt.length > 0
+          return Hashing.authMeSHA256(password, salt)
+        end
+      when PasswordType::HMACSHA1_SaltAsHash
+        if salt != nil && salt.length > 0
+          return Hashing.hmac_sha1_salt_as_hash(password, salt)
+        end
+      else
+        return nil
       end
+    end
+
+    def calc_auth_string(api_key, secret)
+      return "basic " + Base64.strict_encode64(api_key + ":" + secret)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enzoic
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Enzoic
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2023-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.1
+        version: 1.15.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.1
+        version: 1.15.5
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -118,20 +118,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -307,8 +307,8 @@ files:
 - ext/phc-winner-argon2/src/genkat.c
 - ext/phc-winner-argon2/src/genkat.h
 - ext/phc-winner-argon2/src/opt.c
-- ext/phc-winner-argon2/src/opt.o
 - ext/phc-winner-argon2/src/ref.c
+- ext/phc-winner-argon2/src/ref.o
 - ext/phc-winner-argon2/src/run.c
 - ext/phc-winner-argon2/src/test.c
 - ext/phc-winner-argon2/src/thread.c
@@ -361,8 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Ruby library for Enzoic API