scrypt 3.0.6 → 3.1.0

data/lib/scrypt/password.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module SCrypt
+  # A password management class which allows you to safely store users' passwords and compare them.
+  #
+  # Example usage:
+  #
+  #   include "scrypt"
+  #
+  #   # hash a user's password
+  #   @password = Password.create("my grand secret")
+  #   @password #=> "2000$8$1$f5f2fa5fe5484a7091f1299768fbe92b5a7fbc77$6a385f22c54d92c314b71a4fd5ef33967c93d679"
+  #
+  #   # store it safely
+  #   @user.update_attribute(:password, @password)
+  #
+  #   # read it back
+  #   @user.reload!
+  #   @db_password = Password.new(@user.password)
+  #
+  #   # compare it after retrieval
+  #   @db_password == "my grand secret" #=> true
+  #   @db_password == "a paltry guess"  #=> false
+  #
+  class Password < String
+    # Key length constraints
+    MIN_KEY_LENGTH = 16
+    MAX_KEY_LENGTH = 512
+    # Salt size constraints
+    MIN_SALT_SIZE = 8
+    MAX_SALT_SIZE = 32
+
+    # The hash portion of the stored password hash.
+    attr_reader :digest
+    # The salt of the store password hash
+    attr_reader :salt
+    # The cost factor used to create the hash.
+    attr_reader :cost
+
+    class << self
+      # Hashes a secret, returning a SCrypt::Password instance.
+      # Takes five options (optional), which will determine the salt/key's length and
+      # the cost limits of the computation.
+      # <tt>:key_len</tt> specifies the length in bytes of the key you want to generate.
+      # The default is 32 bytes (256 bits). Minimum is 16 bytes (128 bits). Maximum is 512 bytes (4096 bits).
+      # <tt>:salt_size</tt> specifies the size in bytes of the random salt you want to generate.
+      # The default and minimum is 8 bytes (64 bits). Maximum is 32 bytes (256 bits).
+      # <tt>:max_time</tt> specifies the maximum number of seconds the computation should take.
+      # <tt>:max_mem</tt> specifies the maximum number of bytes the computation should take.
+      # A value of 0 specifies no upper limit. The minimum is always 1 MB.
+      # <tt>:max_memfrac</tt> specifies the maximum memory in a fraction of available resources to use.
+      # Any value equal to 0 or greater than 0.5 will result in 0.5 being used.
+      # The scrypt key derivation function is designed to be far more secure against hardware
+      # brute-force attacks than alternative functions such as PBKDF2 or bcrypt.
+      # The designers of scrypt estimate that on modern (2009) hardware, if 5 seconds are spent
+      # computing a derived key, the cost of a hardware brute-force attack against scrypt is roughly
+      # 4000 times greater than the cost of a similar attack against bcrypt (to find the same password),
+      # and 20000 times greater than a similar attack against PBKDF2.
+      # Default options will result in calculation time of approx. 200 ms with 1 MB memory use.
+      #
+      # Example:
+      #   @password = SCrypt::Password.create("my secret", :max_time => 0.25)
+      #
+      def create(secret, options = {})
+        options = SCrypt::Engine::DEFAULTS.merge(options)
+
+        options[:key_len] = clamp_key_length(options[:key_len])
+        options[:salt_size] = clamp_salt_size(options[:salt_size])
+
+        salt = SCrypt::Engine.generate_salt(options)
+        hash = SCrypt::Engine.hash_secret(secret, salt, options[:key_len])
+
+        Password.new(hash)
+      end
+
+      private
+
+      # Clamps key length to valid range
+      def clamp_key_length(key_len)
+        return MIN_KEY_LENGTH if key_len < MIN_KEY_LENGTH
+        return MAX_KEY_LENGTH if key_len > MAX_KEY_LENGTH
+
+        key_len
+      end
+
+      # Clamps salt size to valid range
+      def clamp_salt_size(salt_size)
+        return MIN_SALT_SIZE if salt_size < MIN_SALT_SIZE
+        return MAX_SALT_SIZE if salt_size > MAX_SALT_SIZE
+
+        salt_size
+      end
+    end
+
+    # Initializes a SCrypt::Password instance with the data from a stored hash.
+    def initialize(raw_hash)
+      raise Errors::InvalidHash, 'invalid hash' unless valid_hash?(raw_hash)
+
+      replace(raw_hash)
+
+      @cost, @salt, @digest = split_hash(to_s)
+    end
+
+    # Compares a potential secret against the hash. Returns true if the secret is the original secret, false otherwise.
+    def ==(other)
+      SecurityUtils.secure_compare(self, SCrypt::Engine.hash_secret(other, @cost + @salt, digest.length / 2))
+    end
+    alias is_password? ==
+
+    private
+
+    # Returns true if +h+ is a valid hash.
+    def valid_hash?(h)
+      !SCrypt::Engine::HASH_PATTERN.match(h).nil?
+    end
+
+    # call-seq:
+    #   split_hash(raw_hash) -> cost, salt, hash
+    #
+    # Splits +h+ into cost, salt, and hash and returns them in that order.
+    def split_hash(hash_string)
+      cpu_cost, version, memory_cost, salt, hash = hash_string.split('$')
+      cost_string = "#{[cpu_cost, version, memory_cost].join('$')}$"
+      [cost_string, salt, hash]
+    end
+  end
+end

data/lib/scrypt/scrypt_ext.rb

@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
 require 'ffi'
 require 'ffi-compiler/loader'
 
 module SCrypt
   module Ext
     extend FFI::Library
-    ffi_lib FFI::Compiler::Loader.find('scrypt_ext')
+
+    begin
+      ffi_lib FFI::Compiler::Loader.find('scrypt_ext')
+    rescue LoadError => e
+      raise LoadError, "Failed to load scrypt extension library: #{e.message}"
+    end
   end
 end

data/lib/scrypt/security_utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # NOTE:: a verbatim copy of https://github.com/rails/rails/blob/c8c660002f4b0e9606de96325f20b95248b6ff2d/activesupport/lib/active_support/security_utils.rb
 # Please see the Rails license: https://github.com/rails/rails/blob/master/activesupport/MIT-LICENSE
 
@@ -9,15 +11,14 @@ module SCrypt
     # that have already been processed by HMAC. This should not be used
     # on variable length plaintext strings because it could leak length info
     # via timing attacks.
-    def secure_compare(a, b)
+    def self.secure_compare(a, b)
       return false unless a.bytesize == b.bytesize
 
       l = a.unpack "C#{a.bytesize}"
 
       res = 0
       b.each_byte { |byte| res |= byte ^ l.shift }
-      res == 0
+      res.zero?
     end
-    module_function :secure_compare
   end
 end

data/lib/scrypt/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SCrypt
-  VERSION = "3.0.6"
+  VERSION = '3.1.0'
 end

data/lib/scrypt.rb

@@ -1,269 +1,10 @@
-# A wrapper for the scrypt algorithm.
-
-require "scrypt/scrypt_ext"
-require "scrypt/security_utils"
-require "openssl"
-require "scanf"
-require "ffi"
-
-
-module SCrypt
-
-  module Ext
-    # Bind the external functions
-    attach_function :sc_calibrate, [:size_t, :double, :double, :pointer], :int, :blocking => true
-    attach_function :crypto_scrypt, [:pointer, :size_t, :pointer, :size_t, :uint64, :uint32, :uint32, :pointer, :size_t], :int, :blocking => true # todo
-  end
-
-  module Errors
-    class InvalidSalt   < StandardError; end  # The salt parameter provided is invalid.
-    class InvalidHash   < StandardError; end  # The hash parameter provided is invalid.
-    class InvalidSecret < StandardError; end  # The secret parameter provided is invalid.
-  end
-
-  class Engine
-    DEFAULTS = {
-      :key_len     => 32,
-      :salt_size   => 32,
-      :max_mem     => 16 * 1024 * 1024,
-      :max_memfrac => 0.5,
-      :max_time    => 0.2,
-      :cost        => nil
-    }
-
-    def self.scrypt(secret, salt, *args)
-      if args.length == 2
-        # args is [cost_string, key_len]
-        n, r, p = args[0].split('$').map{ |x| x.to_i(16) }
-        key_len = args[1]
-        __sc_crypt(secret, salt, n, r, p, key_len)
-      elsif args.length == 4
-        # args is [n, r, p, key_len]
-        n, r, p = args[0, 3]
-        key_len = args[3]
-        __sc_crypt(secret, salt, n, r, p, key_len)
-      else
-        raise ArgumentError.new("invalid number of arguments (4 or 6)")
-      end
-    end
-
-    # Given a secret and a valid salt (see SCrypt::Engine.generate_salt) calculates an scrypt password hash.
-    def self.hash_secret(secret, salt, key_len = DEFAULTS[:key_len])
-      if valid_secret?(secret)
-        if valid_salt?(salt)
-          cost = autodetect_cost(salt)
-          salt_only = salt[/\$([A-Za-z0-9]{16,64})$/, 1]
-          if salt_only.length == 40
-            # Old-style hash with 40-character salt
-            salt + "$" + Digest::SHA1.hexdigest(scrypt(secret.to_s, salt, cost, 256))
-          else
-            # New-style hash
-            salt_only = [salt_only.sub(/^(00)+/, '')].pack('H*')
-            salt + "$" + scrypt(secret.to_s, salt_only, cost, key_len).unpack('H*').first.rjust(key_len * 2, '0')
-          end
-        else
-          raise Errors::InvalidSalt.new("invalid salt")
-        end
-      else
-        raise Errors::InvalidSecret.new("invalid secret")
-      end
-    end
-
-    # Generates a random salt with a given computational cost.  Uses a saved
-    # cost if SCrypt::Engine.calibrate! has been called.
-    #
-    # Options:
-    # <tt>:cost</tt> is a cost string returned by SCrypt::Engine.calibrate
-    def self.generate_salt(options = {})
-      options = DEFAULTS.merge(options)
-      cost = options[:cost] || calibrate(options)
-      salt = OpenSSL::Random.random_bytes(options[:salt_size]).unpack('H*').first.rjust(16,'0')
-      if salt.length == 40
-        #If salt is 40 characters, the regexp will think that it is an old-style hash, so add a '0'.
-        salt = '0' + salt
-      end
-      cost + salt
-    end
-
-    # Returns true if +cost+ is a valid cost, false if not.
-    def self.valid_cost?(cost)
-      cost.match(/^[0-9a-z]+\$[0-9a-z]+\$[0-9a-z]+\$$/) != nil
-    end
-
-    # Returns true if +salt+ is a valid salt, false if not.
-    def self.valid_salt?(salt)
-      salt.match(/^[0-9a-z]+\$[0-9a-z]+\$[0-9a-z]+\$[A-Za-z0-9]{16,64}$/) != nil
-    end
-
-    # Returns true if +secret+ is a valid secret, false if not.
-    def self.valid_secret?(secret)
-      secret.respond_to?(:to_s)
-    end
-
-    # Returns the cost value which will result in computation limits less than the given options.
-    #
-    # Options:
-    # <tt>:max_time</tt> specifies the maximum number of seconds the computation should take.
-    # <tt>:max_mem</tt> specifies the maximum number of bytes the computation should take. A value of 0 specifies no upper limit. The minimum is always 1 MB.
-    # <tt>:max_memfrac</tt> specifies the maximum memory in a fraction of available resources to use. Any value equal to 0 or greater than 0.5 will result in 0.5 being used.
-    #
-    # Example:
-    #
-    #   # should take less than 200ms
-    #   SCrypt::Engine.calibrate(:max_time => 0.2)
-    #
-    def self.calibrate(options = {})
-      options = DEFAULTS.merge(options)
-      "%x$%x$%x$" % __sc_calibrate(options[:max_mem], options[:max_memfrac], options[:max_time])
-    end
-    
-    # Calls SCrypt::Engine.calibrate and saves the cost string for future calls to
-    # SCrypt::Engine.generate_salt.
-    def self.calibrate!(options = {})
-      DEFAULTS[:cost] = calibrate(options)
-    end
-
-    # Computes the memory use of the given +cost+
-    def self.memory_use(cost)
-      n, r, p = cost.scanf("%x$%x$%x$")
-      (128 * r * p) + (256 * r) + (128 * r * n);
-    end
+# frozen_string_literal: true
 
-    # Autodetects the cost from the salt string.
-    def self.autodetect_cost(salt)
-      salt[/^[0-9a-z]+\$[0-9a-z]+\$[0-9a-z]+\$/]
-    end
-
-    private
-
-    class Calibration < FFI::Struct
-      layout  :n, :uint64,
-              :r, :uint32,
-              :p, :uint32
-    end
-
-    def self.__sc_calibrate(max_mem, max_memfrac, max_time)
-      result = nil
-
-      calibration = Calibration.new
-      retval = SCrypt::Ext.sc_calibrate(max_mem, max_memfrac, max_time, calibration)
-
-      if retval == 0
-        result = [calibration[:n], calibration[:r], calibration[:p]]
-      else
-        raise "calibration error #{result}"
-      end
-
-      result
-    end
-
-    def self.__sc_crypt(secret, salt, n, r, p, key_len)
-      result = nil
-
-      FFI::MemoryPointer.new(:char, key_len) do |buffer|
-        retval = SCrypt::Ext.crypto_scrypt(
-          secret, secret.bytesize, salt, salt.bytesize,
-          n, r, p,
-          buffer, key_len
-        )
-        if retval == 0
-          result = buffer.read_string(key_len)
-        else
-          raise "scrypt error #{retval}"
-        end
-      end
-
-      result
-    end
-  end
-
-  # A password management class which allows you to safely store users' passwords and compare them.
-  #
-  # Example usage:
-  #
-  #   include "scrypt"
-  #
-  #   # hash a user's password
-  #   @password = Password.create("my grand secret")
-  #   @password #=> "2000$8$1$f5f2fa5fe5484a7091f1299768fbe92b5a7fbc77$6a385f22c54d92c314b71a4fd5ef33967c93d679"
-  #
-  #   # store it safely
-  #   @user.update_attribute(:password, @password)
-  #
-  #   # read it back
-  #   @user.reload!
-  #   @db_password = Password.new(@user.password)
-  #
-  #   # compare it after retrieval
-  #   @db_password == "my grand secret" #=> true
-  #   @db_password == "a paltry guess"  #=> false
-  #
-  class Password < String
-    # The hash portion of the stored password hash.
-    attr_reader :digest
-    # The salt of the store password hash
-    attr_reader :salt
-    # The cost factor used to create the hash.
-    attr_reader :cost
-
-    class << self
-      # Hashes a secret, returning a SCrypt::Password instance.
-      # Takes five options (optional), which will determine the salt/key's length and the cost limits of the computation.
-      # <tt>:key_len</tt> specifies the length in bytes of the key you want to generate. The default is 32 bytes (256 bits). Minimum is 16 bytes (128 bits). Maximum is 512 bytes (4096 bits).
-      # <tt>:salt_size</tt> specifies the size in bytes of the random salt you want to generate. The default and minimum is 8 bytes (64 bits). Maximum is 32 bytes (256 bits).
-      # <tt>:max_time</tt> specifies the maximum number of seconds the computation should take.
-      # <tt>:max_mem</tt> specifies the maximum number of bytes the computation should take. A value of 0 specifies no upper limit. The minimum is always 1 MB.
-      # <tt>:max_memfrac</tt> specifies the maximum memory in a fraction of available resources to use. Any value equal to 0 or greater than 0.5 will result in 0.5 being used.
-      # The scrypt key derivation function is designed to be far more secure against hardware brute-force attacks than alternative functions such as PBKDF2 or bcrypt.
-      # The designers of scrypt estimate that on modern (2009) hardware, if 5 seconds are spent computing a derived key, the cost of a hardware brute-force attack against scrypt is roughly 4000 times greater than the cost of a similar attack against bcrypt (to find the same password), and 20000 times greater than a similar attack against PBKDF2.
-      # Default options will result in calculation time of approx. 200 ms with 1 MB memory use.
-      #
-      # Example:
-      #   @password = SCrypt::Password.create("my secret", :max_time => 0.25)
-      #
-      def create(secret, options = {})
-        options = SCrypt::Engine::DEFAULTS.merge(options)
-        #Clamp minimum/maximum keylen
-        options[:key_len] = 16 if options[:key_len] < 16
-        options[:key_len] = 512 if options[:key_len] > 512
-        #Clamp minimum/maximum salt_size
-        options[:salt_size] = 8 if options[:salt_size] < 8
-        options[:salt_size] = 32 if options[:salt_size] > 32
-        salt = SCrypt::Engine.generate_salt(options)
-        hash = SCrypt::Engine.hash_secret(secret, salt, options[:key_len])
-        Password.new(hash)
-      end
-    end
-
-    # Initializes a SCrypt::Password instance with the data from a stored hash.
-    def initialize(raw_hash)
-      if valid_hash?(raw_hash)
-        self.replace(raw_hash)
-        @cost, @salt, @digest = split_hash(self.to_s)
-      else
-        raise Errors::InvalidHash.new("invalid hash")
-      end
-    end
-
-    # Compares a potential secret against the hash. Returns true if the secret is the original secret, false otherwise.
-    def ==(secret)
-      SecurityUtils.secure_compare(self, SCrypt::Engine.hash_secret(secret, @cost + @salt, self.digest.length / 2))
-    end
-    alias_method :is_password?, :==
+# A wrapper for the scrypt algorithm.
 
-  private
-    # Returns true if +h+ is a valid hash.
-    def valid_hash?(h)
-      h.match(/^[0-9a-z]+\$[0-9a-z]+\$[0-9a-z]+\$[A-Za-z0-9]{16,64}\$[A-Za-z0-9]{32,1024}$/) != nil
-    end
+require 'scrypt/errors'
+require 'scrypt/scrypt_ext'
+require 'scrypt/security_utils'
 
-    # call-seq:
-    #   split_hash(raw_hash) -> cost, salt, hash
-    #
-    # Splits +h+ into cost, salt, and hash and returns them in that order.
-    def split_hash(h)
-      n, v, r, salt, hash = h.split('$')
-      return [n, v, r].join('$') + "$", salt, hash
-    end
-  end
-end
+require 'scrypt/engine'
+require 'scrypt/password'

data/scrypt.gemspec

@@ -1,37 +1,42 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "scrypt/version"
+# frozen_string_literal: true
+
+$:.push File.expand_path('lib', __dir__)
+require 'scrypt/version'
 
 Gem::Specification.new do |s|
-  s.name        = "scrypt"
+  s.name        = 'scrypt'
   s.version     = SCrypt::VERSION
-  s.authors     = ["Patrick Hogan", "Stephen von Takach", "Rene van Paassen" ]
-  s.email       = ["pbhogan@gmail.com", "steve@advancedcontrol.com.au",
-                   "rene.vanpaassen@gmail.com" ]
+  s.authors     = ['Patrick Hogan',
+                   'Stephen von Takach',
+                   'Rene van Paassen',
+                   'Johanns Gregorian']
+  s.email       = ['pbhogan@gmail.com',
+                   'steve@advancedcontrol.com.au',
+                   'rene.vanpaassen@gmail.com',
+                   'io+scrypt@jsg.io']
   s.cert_chain  = ['certs/pbhogan.pem']
   s.license     = 'BSD-3-Clause'
-  s.signing_key = File.expand_path("~/.ssh/gem-private_key.pem") if $0 =~ /gem\z/
-  s.homepage    = "https://github.com/pbhogan/scrypt"
-  s.summary     = "scrypt password hashing algorithm."
-  s.description = <<-EOF
+
+  s.signing_key = File.expand_path('~/.ssh/gem-private_key.pem') if $0 =~ /gem\z/
+  s.metadata['rubygems_mfa_required'] = 'true'
+
+  s.homepage    = 'https://github.com/pbhogan/scrypt'
+  s.summary     = 'scrypt password hashing algorithm.'
+
+  s.description = <<-DESC
     The scrypt key derivation function is designed to be far
     more secure against hardware brute-force attacks than
     alternative functions such as PBKDF2 or bcrypt.
-  EOF
+  DESC
 
-  s.add_dependency 'ffi-compiler', '>= 1.0', '< 2.0'
-  s.add_development_dependency 'rake', '>= 9', '< 13'
-  s.add_development_dependency 'rspec', '>= 3', '< 4'
-  s.add_development_dependency 'rdoc', '>= 4', '< 5'
-  s.add_development_dependency 'awesome_print', '>= 1', '< 2'
+  s.required_ruby_version = '>= 2.3.0'
 
-  s.rubyforge_project = "scrypt"
+  s.add_dependency 'ffi-compiler', '>= 1.0', '< 2.0'
+  s.add_dependency 'rake', '~> 13'
 
-  s.extensions = ["ext/scrypt/Rakefile"]
+  s.extensions = ['ext/scrypt/Rakefile']
 
-  s.files = %w(Rakefile scrypt.gemspec README.md COPYING) + Dir.glob("{lib,spec,autotest}/**/*")
-  s.files += Dir.glob("ext/scrypt/*")
-  s.test_files = Dir.glob("spec/**/*")
-  s.require_paths = ["lib"]
+  s.files = %w[Rakefile scrypt.gemspec README.md COPYING] + Dir.glob('{lib,spec}/**/*')
+  s.files += Dir.glob('ext/scrypt/*')
+  s.require_paths = ['lib']
 end
-

data/spec/fixtures/test_vectors.yml

@@ -0,0 +1,67 @@
+# SCrypt Test Vectors
+# These are the official test vectors from the scrypt specification
+# Used to verify our implementation matches the reference
+
+scrypt_vectors:
+  - description: "Empty string test"
+    password: ""
+    salt: ""
+    n: 16
+    r: 1
+    p: 1
+    key_len: 64
+    expected: "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906"
+
+  - description: "Standard test vector"
+    password: "password"
+    salt: "NaCl"
+    n: 1024
+    r: 8
+    p: 16
+    key_len: 64
+    expected: "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640"
+
+  - description: "High memory test vector"
+    password: "pleaseletmein"
+    salt: "SodiumChloride"
+    n: 16384
+    r: 8
+    p: 1
+    key_len: 64
+    expected: "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887"
+
+  - description: "Very high memory test (disabled on memory-constrained systems)"
+    password: "pleaseletmein"
+    salt: "SodiumChloride"
+    n: 1048576
+    r: 8
+    p: 1
+    key_len: 64
+    expected: "2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4"
+    skip_reason: "Memory limited systems (like Raspberry Pi) may fail this test"
+
+hash_secret_vectors:
+  - description: "Empty string via hash_secret"
+    password: ""
+    salt: "10$1$1$0000000000000000"
+    key_len: 64
+    expected_pattern: "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906"
+
+  - description: "Standard test via hash_secret"
+    password: "password"
+    salt: "400$8$10$000000004e61436c"
+    key_len: 64
+    expected_pattern: "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640"
+
+  - description: "High memory test via hash_secret"
+    password: "pleaseletmein"
+    salt: "4000$8$1$536f6469756d43686c6f72696465"
+    key_len: 64
+    expected_pattern: "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887"
+
+  - description: "Very high memory test via hash_secret (disabled)"
+    password: "pleaseletmein"
+    salt: "100000$8$1$536f6469756d43686c6f72696465"
+    key_len: 64
+    expected_pattern: "2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4"
+    skip_reason: "Memory limited systems may fail this test"