enzoic 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f384606d64ea5eac9f13b2467ab4e494d7043312
-  data.tar.gz: 7f3d428ada763102e27d26aba7ee5172169e5bee
+SHA256:
+  metadata.gz: 2af7917c4ee90414cdffeda3948ce2a0642f523f6c44fe07db64deab4f5b6e25
+  data.tar.gz: 4cdfeb61e75c47f95132e9a0c644f89a987597a48685038ac7308dba66e008ee
 SHA512:
-  metadata.gz: 7a6da77a5e86c97d835e50378c67423c6197f771d5647216d9c7613d7cf402ff6705dbf9e20fce28796bf8957741a3d7459c6dbec0aead19f0ff9e3a7bc4b09e
-  data.tar.gz: 20356c44bacd22fa24ea58ee85515acecb44326b4fc5b46ee233ad0b132727b8b61594053e2c91df1a4c5300277f0bcda1c7691acf14ed5b126e59bc265e55b1
+  metadata.gz: 557fadc6dab20d5d76d2098466c31728ecba0a1fcd16ce9cd13a798817239bb791012691b37130b7e64dd7275728d83c9f89bdfeda10dbde0b369faf705f8ecf
+  data.tar.gz: 420af16ed93a7696969a74fbfcd13e491e23f934a9f15712fe42fc3eb777e6cdcf51751ac4ebc2bfa28b250fc7d17c3107f10989a524c4f1779811254423cc50

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,19 +43,40 @@ 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
     puts("Credentials are not compromised")
 end
 
+# Check whether a specific set of credentials are compromised, using the optional 
+# lastCheckData parameter.
+# 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.
+if enzoic.check_credentials("test@enzoic.com", "password-to-test", DateTime.parse("2019-07-15T19:57:43.000Z"))
+    puts("Credentials are compromised")
+else
+    puts("Credentials are not compromised")
+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/enzoic.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   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/ext/phc-winner-argon2/argon2.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.argon2</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/ext/phc-winner-argon2/libargon2.0.dylib.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.libargon2.0.dylib</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/lib/enzoic/hashing.rb

@@ -24,6 +24,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 +99,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 +156,146 @@ 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.sha512crypt(to_hash, salt)
+      return UnixCrypt::SHA512.build(to_hash, salt.start_with?("$6$") ? salt[3..salt.length] : salt)
+    end
+
+    def self.custom_algorithm10(to_hash, salt)
+      return self.sha512(to_hash + ":" + salt)
+    end
+
+    def self.sha256crypt(to_hash, salt)
+      salt_to_use = salt
+      if salt_to_use.start_with?("$5$")
+        salt_to_use = salt_to_use[3..salt.length];
+      end
+      if salt_to_use.start_with?("rounds=")
+        salt_to_use = salt_to_use[salt_to_use.index("$") + 1..salt_to_use.length]
+      end
+
+      return UnixCrypt::SHA256.build(to_hash, salt_to_use)
+    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 +379,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,32 @@ 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
+    SHA256Crypt = 41
+    AuthMeSHA256 = 42
+
     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.0.3".freeze
+  VERSION = "1.2.0".freeze
 end

data/lib/enzoic.rb

@@ -15,79 +15,109 @@ 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)
+    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)
-      hashes_required = account_response["passwordHashesRequired"]
 
-      bcrypt_count = 0
-      query_string = ""
+      # if lastCheckTimestamp was provided, see if we need to go any further
+      if Date.parse(account_response["lastBreachDate"]) > last_check_timestamp
+        hashes_required = account_response["passwordHashesRequired"]
 
-      for i in 0..hashes_required.length - 1 do
-        hash_spec = hashes_required[i]
+        bcrypt_count = 0
+        query_string = ""
+        credential_hashes = []
 
-        # 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)
-            bcrypt_count = bcrypt_count + 1
-          end
+        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
+              bcrypt_count = bcrypt_count + 1
+            end
+
+            if hash_spec["hashType"] != nil
+              credential_hash = calc_credential_hash(username.downcase, password, account_response["salt"], hash_spec)
 
-          if (hash_spec["hashType"] != nil)
-            credential_hash = calc_credential_hash(username, 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);
-              else
-                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 + "&partialHashes=" + CGI.escape(credential_hash[0..6])
+                end
               end
             end
           end
         end
-      end
 
-      if (query_string.length > 0)
-        creds_response = make_rest_call(
-                @baseURL + Constants::CREDENTIALS_API_PATH + query_string, "GET", nil)
-        return creds_response != "404"
+        if query_string.length > 0
+          creds_response = make_rest_call(
+            @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
 
       return false
     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] + '"' +
+          '}')
+
+      if response != "404"
+        result = JSON.parse(response, object_class: OpenStruct)
 
-      return response != "404"
+        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
@@ -98,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
@@ -108,82 +138,176 @@ 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
+      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.0.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Enzoic
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-02 00:00:00.000000000 Z
+date: 2022-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -116,22 +116,22 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.0.2
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.0.2
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.2.11
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.11
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -230,9 +230,11 @@ files:
 - Rakefile
 - enzoic.gemspec
 - ext/.DS_Store
+- ext/argon2-wrapper/.DS_Store
 - ext/argon2-wrapper/Makefile
 - ext/argon2-wrapper/argon2-wrapper.c
 - ext/argon2-wrapper/extconf.rb
+- ext/argon2-wrapper/libargon2-wrapper.bundle
 - ext/argon2_import/.DS_Store
 - ext/digest/whirlpool/extconf.rb
 - ext/digest/whirlpool/whirlpool-algorithm.c
@@ -251,7 +253,10 @@ files:
 - ext/phc-winner-argon2/Makefile
 - ext/phc-winner-argon2/README.md
 - ext/phc-winner-argon2/appveyor.yml
+- ext/phc-winner-argon2/argon2
 - ext/phc-winner-argon2/argon2-specs.pdf
+- ext/phc-winner-argon2/argon2.dSYM/Contents/Info.plist
+- ext/phc-winner-argon2/argon2.dSYM/Contents/Resources/DWARF/argon2
 - ext/phc-winner-argon2/export.sh
 - ext/phc-winner-argon2/include/argon2.h
 - ext/phc-winner-argon2/kats/argon2d
@@ -278,27 +283,37 @@ files:
 - ext/phc-winner-argon2/latex/pics/generic.pdf
 - ext/phc-winner-argon2/latex/pics/power-distribution.jpg
 - ext/phc-winner-argon2/latex/tradeoff.bib
+- ext/phc-winner-argon2/libargon2.0.dylib
+- ext/phc-winner-argon2/libargon2.0.dylib.dSYM/Contents/Info.plist
+- ext/phc-winner-argon2/libargon2.0.dylib.dSYM/Contents/Resources/DWARF/libargon2.0.dylib
+- ext/phc-winner-argon2/libargon2.a
 - ext/phc-winner-argon2/libargon2.pc
 - ext/phc-winner-argon2/man/argon2.1
 - ext/phc-winner-argon2/src/argon2.c
+- ext/phc-winner-argon2/src/argon2.o
 - ext/phc-winner-argon2/src/bench.c
 - ext/phc-winner-argon2/src/blake2/blake2-impl.h
 - ext/phc-winner-argon2/src/blake2/blake2.h
 - ext/phc-winner-argon2/src/blake2/blake2b.c
+- ext/phc-winner-argon2/src/blake2/blake2b.o
 - ext/phc-winner-argon2/src/blake2/blamka-round-opt.h
 - ext/phc-winner-argon2/src/blake2/blamka-round-ref.h
 - ext/phc-winner-argon2/src/core.c
 - ext/phc-winner-argon2/src/core.h
+- ext/phc-winner-argon2/src/core.o
 - ext/phc-winner-argon2/src/encoding.c
 - ext/phc-winner-argon2/src/encoding.h
+- ext/phc-winner-argon2/src/encoding.o
 - 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/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
 - ext/phc-winner-argon2/src/thread.h
+- ext/phc-winner-argon2/src/thread.o
 - ext/phc-winner-argon2/vs2015/Argon2Opt/Argon2Opt.vcxproj
 - ext/phc-winner-argon2/vs2015/Argon2Opt/Argon2Opt.vcxproj.filters
 - ext/phc-winner-argon2/vs2015/Argon2OptBench/Argon2OptBench.vcxproj
@@ -346,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.0.3.1
 signing_key: 
 specification_version: 4
 summary: Ruby library for Enzoic API