2 files changed, 391 insertions, 0 deletions
diff --git a/spec/ruby/library/openssl/kdf/pbkdf2_hmac_spec.rb b/spec/ruby/library/openssl/kdf/pbkdf2_hmac_spec.rb
new file mode 100644
index 0000000000..ebf71482de
--- /dev/null
+++ b/spec/ruby/library/openssl/kdf/pbkdf2_hmac_spec.rb
@@ -0,0 +1,184 @@
+require_relative '../../../spec_helper'
+require 'openssl'
+
+describe "OpenSSL::KDF.pbkdf2_hmac" do
+  before :each do
+    @defaults = {
+      salt: "\x00".b * 16,
+      iterations: 20_000,
+      length: 16,
+      hash: "sha1"
+    }
+  end
+
+  it "creates the same value with the same input" do
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "supports nullbytes embedded in the password" do
+    key = OpenSSL::KDF.pbkdf2_hmac("sec\x00ret".b, **@defaults)
+    key.should == "\xB9\x7F\xB0\xC2\th\xC8<\x86\xF3\x94Ij7\xEF\xF1".b
+  end
+
+  it "coerces the password into a String using #to_str" do
+    pass = mock("pass")
+    pass.should_receive(:to_str).and_return("secret")
+    key = OpenSSL::KDF.pbkdf2_hmac(pass, **@defaults)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "coerces the salt into a String using #to_str" do
+    salt = mock("salt")
+    salt.should_receive(:to_str).and_return("\x00".b * 16)
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, salt: salt)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "coerces the iterations into an Integer using #to_int" do
+    iterations = mock("iterations")
+    iterations.should_receive(:to_int).and_return(20_000)
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: iterations)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "coerces the length into an Integer using #to_int" do
+    length = mock("length")
+    length.should_receive(:to_int).and_return(16)
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, length: length)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "accepts a OpenSSL::Digest object as hash" do
+    hash = OpenSSL::Digest.new("sha1")
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, hash: hash)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0".b
+  end
+
+  it "accepts an empty password" do
+    key = OpenSSL::KDF.pbkdf2_hmac("", **@defaults)
+    key.should == "k\x9F-\xB1\xF7\x9A\v\xA1(C\xF9\x85!P\xEF\x8C".b
+  end
+
+  it "accepts an empty salt" do
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, salt: "")
+    key.should == "\xD5f\xE5\xEA\xF91\x1D\xD3evD\xED\xDB\xE80\x80".b
+  end
+
+  it "accepts an empty length" do
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, length: 0)
+    key.should.empty?
+  end
+
+  it "accepts an arbitrary length" do
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, length: 19)
+    key.should == "!\x99+\xF0^\xD0\x8BM\x158\xC4\xAC\x9C\xF1\xF0\xE0\xCF\xBB\x7F".b
+  end
+
+  it "accepts any hash function known to OpenSSL" do
+    key = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, hash: "sha512")
+    key.should == "N\x12}D\xCE\x99\xDBC\x8E\xEC\xAAr\xEA1\xDF\xFF".b
+  end
+
+  it "raises a TypeError when password is not a String and does not respond to #to_str" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac(Object.new, **@defaults)
+    }.should raise_error(TypeError, "no implicit conversion of Object into String")
+  end
+
+  it "raises a TypeError when salt is not a String and does not respond to #to_str" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, salt: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into String")
+  end
+
+  it "raises a TypeError when iterations is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "raises a TypeError when length is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, length: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "raises a TypeError when hash is neither a String nor an OpenSSL::Digest" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, hash: Object.new)
+    }.should raise_error(TypeError, "wrong argument type Object (expected OpenSSL/Digest)")
+  end
+
+  it "raises a TypeError when hash is neither a String nor an OpenSSL::Digest, it does not try to call #to_str" do
+    hash = mock("hash")
+    hash.should_not_receive(:to_str)
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, hash: hash)
+    }.should raise_error(TypeError, "wrong argument type MockObject (expected OpenSSL/Digest)")
+  end
+
+  it "raises a RuntimeError for unknown digest algorithms" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, hash: "wd40")
+    }.should raise_error(RuntimeError, /Unsupported digest algorithm \(wd40\)/)
+  end
+
+  it "treats salt as a required keyword" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults.except(:salt))
+    }.should raise_error(ArgumentError, 'missing keyword: :salt')
+  end
+
+  it "treats iterations as a required keyword" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults.except(:iterations))
+    }.should raise_error(ArgumentError, 'missing keyword: :iterations')
+  end
+
+  it "treats length as a required keyword" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults.except(:length))
+    }.should raise_error(ArgumentError, 'missing keyword: :length')
+  end
+
+  it "treats hash as a required keyword" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults.except(:hash))
+    }.should raise_error(ArgumentError, 'missing keyword: :hash')
+  end
+
+  it "treats all keywords as required" do
+    -> {
+      OpenSSL::KDF.pbkdf2_hmac("secret")
+    }.should raise_error(ArgumentError, 'missing keywords: :salt, :iterations, :length, :hash')
+  end
+
+
+  guard -> { OpenSSL::OPENSSL_VERSION_NUMBER < 0x30000000 } do
+    it "treats 0 or less iterations as a single iteration" do
+      salt = "\x00".b * 16
+      length = 16
+      hash = "sha1"
+
+      # "Any iter less than 1 is treated as a single iteration."
+      key0 = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: 0)
+      key_negative = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: -1)
+      key1 = OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: 1)
+      key0.should == key1
+      key_negative.should == key1
+    end
+  end
+
+  guard -> { OpenSSL::OPENSSL_VERSION_NUMBER >= 0x30000000 } do
+    it "raises an OpenSSL::KDF::KDFError for 0 or less iterations" do
+      -> {
+        OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: 0)
+      }.should raise_error(OpenSSL::KDF::KDFError, "PKCS5_PBKDF2_HMAC: invalid iteration count")
+
+      -> {
+        OpenSSL::KDF.pbkdf2_hmac("secret", **@defaults, iterations: -1)
+      }.should raise_error(OpenSSL::KDF::KDFError, /PKCS5_PBKDF2_HMAC/)
+    end
+  end
+end
diff --git a/spec/ruby/library/openssl/kdf/scrypt_spec.rb b/spec/ruby/library/openssl/kdf/scrypt_spec.rb
new file mode 100644
index 0000000000..d9b83eaa55
--- /dev/null
+++ b/spec/ruby/library/openssl/kdf/scrypt_spec.rb
@@ -0,0 +1,207 @@
+require_relative '../../../spec_helper'
+require 'openssl'
+
+describe "OpenSSL::KDF.scrypt" do
+  before :each do
+    @defaults = {
+      salt: "\x00".b * 16,
+      N: 2**14,
+      r: 8,
+      p: 1,
+      length: 32
+    }
+  end
+
+  it "creates the same value with the same input" do
+    key = OpenSSL::KDF.scrypt("secret", **@defaults)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "supports nullbytes embedded into the password" do
+    key = OpenSSL::KDF.scrypt("sec\x00ret".b, **@defaults)
+    key.should == "\xF9\xA4\xA0\xF1p\xF4\xF0\xCAT\xB4v\xEB\r7\x88N\xF7\x15]Ns\xFCwt4a\xC9\xC6\xA7\x13\x81&".b
+  end
+
+  it "coerces the password into a String using #to_str" do
+    pass = mock("pass")
+    pass.should_receive(:to_str).and_return("secret")
+    key = OpenSSL::KDF.scrypt(pass, **@defaults)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "coerces the salt into a String using #to_str" do
+    salt = mock("salt")
+    salt.should_receive(:to_str).and_return("\x00".b * 16)
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, salt: salt)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "coerces the N into an Integer using #to_int" do
+    n = mock("N")
+    n.should_receive(:to_int).and_return(2**14)
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, N: n)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "coerces the r into an Integer using #to_int" do
+    r = mock("r")
+    r.should_receive(:to_int).and_return(8)
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, r: r)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "coerces the p into an Integer using #to_int" do
+    p = mock("p")
+    p.should_receive(:to_int).and_return(1)
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, p: p)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "coerces the length into an Integer using #to_int" do
+    length = mock("length")
+    length.should_receive(:to_int).and_return(32)
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, length: length)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D\x17}\xF2\x84T\xD4)\xC2>\xFE\x93\xE3\xF4".b
+  end
+
+  it "accepts an empty password" do
+    key = OpenSSL::KDF.scrypt("", **@defaults)
+    key.should == "\xAA\xFC\xF5^E\x94v\xFFk\xE6\xF0vR\xE7\x13\xA7\xF5\x15'\x9A\xE4C\x9Dn\x18F_E\xD2\v\e\xB3".b
+  end
+
+  it "accepts an empty salt" do
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, salt: "")
+    key.should == "\x96\xACDl\xCB3/aN\xB0F\x8A#\xD7\x92\xD2O\x1E\v\xBB\xCE\xC0\xAA\xB9\x0F]\xB09\xEA8\xDD\e".b
+  end
+
+  it "accepts a zero length" do
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, length: 0)
+    key.should.empty?
+  end
+
+  it "accepts an arbitrary length" do
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, length: 19)
+    key.should == "h\xB2k\xDF]\xDA\xE1.-(\xCF\xAC\x91D\x8F\xC2a\x9C\x9D".b
+  end
+
+  it "raises a TypeError when password is not a String and does not respond to #to_str" do
+    -> {
+      OpenSSL::KDF.scrypt(Object.new, **@defaults)
+    }.should raise_error(TypeError, "no implicit conversion of Object into String")
+  end
+
+  it "raises a TypeError when salt is not a String and does not respond to #to_str" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, salt: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into String")
+  end
+
+  it "raises a TypeError when N is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, N: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "raises a TypeError when r is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, r: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "raises a TypeError when p is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, p: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "raises a TypeError when length is not an Integer and does not respond to #to_int" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, length: Object.new)
+    }.should raise_error(TypeError, "no implicit conversion of Object into Integer")
+  end
+
+  it "treats salt as a required keyword" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults.except(:salt))
+    }.should raise_error(ArgumentError, 'missing keyword: :salt')
+  end
+
+  it "treats N as a required keyword" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults.except(:N))
+    }.should raise_error(ArgumentError, 'missing keyword: :N')
+  end
+
+  it "treats r as a required keyword" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults.except(:r))
+    }.should raise_error(ArgumentError, 'missing keyword: :r')
+  end
+
+  it "treats p as a required keyword" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults.except(:p))
+    }.should raise_error(ArgumentError, 'missing keyword: :p')
+  end
+
+  it "treats length as a required keyword" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults.except(:length))
+    }.should raise_error(ArgumentError, 'missing keyword: :length')
+  end
+
+  it "treats all keywords as required" do
+    -> {
+      OpenSSL::KDF.scrypt("secret")
+    }.should raise_error(ArgumentError, 'missing keywords: :salt, :N, :r, :p, :length')
+  end
+
+  it "requires N to be a power of 2" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, N: 2**14 - 1)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+  end
+
+  it "requires N to be at least 2" do
+    key = OpenSSL::KDF.scrypt("secret", **@defaults, N: 2)
+    key.should == "\x06A$a\xA9!\xBE\x01\x85\xA7\x18\xBCEa\x82\xC5\xFEl\x93\xAB\xBD\xF7\x8B\x84\v\xFC\eN\xEBQ\xE6\xD2".b
+
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, N: 1)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, N: 0)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, N: -1)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+  end
+
+  it "requires r to be positive" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, r: 0)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, r: -1)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+  end
+
+  it "requires p to be positive" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, p: 0)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, p: -1)
+    }.should raise_error(OpenSSL::KDF::KDFError, /EVP_PBE_scrypt/)
+  end
+
+  it "requires length to be not negative" do
+    -> {
+      OpenSSL::KDF.scrypt("secret", **@defaults, length: -1)
+    }.should raise_error(ArgumentError, "negative string size (or size too big)")
+  end
+end