2 files changed, 134 insertions, 1 deletions
diff --git a/tests/hazmat/backends/test_multibackend.py b/tests/hazmat/backends/test_multibackend.py
index bf54d5ce..1cd87336 100644
--- a/tests/hazmat/backends/test_multibackend.py
+++ b/tests/hazmat/backends/test_multibackend.py
@@ -13,7 +13,7 @@ from cryptography.exceptions import (
 from cryptography.hazmat.backends.interfaces import (
     CMACBackend, CipherBackend, DERSerializationBackend, DSABackend,
     EllipticCurveBackend, HMACBackend, HashBackend, PBKDF2HMACBackend,
-    PEMSerializationBackend, RSABackend, X509Backend
+    PEMSerializationBackend, RSABackend, ScryptBackend, X509Backend
 )
 from cryptography.hazmat.backends.multibackend import MultiBackend
 from cryptography.hazmat.primitives import cmac, hashes, hmac
@@ -231,6 +231,12 @@ class DummyX509Backend(object):
         pass
 
 
+@utils.register_interface(ScryptBackend)
+class DummyScryptBackend(object):
+    def derive_scrypt(self, key_material, salt, length, n, r, p):
+        pass
+
+
 class TestMultiBackend(object):
     def test_raises_error_with_empty_list(self):
         with pytest.raises(ValueError):
@@ -558,3 +564,11 @@ class TestMultiBackend(object):
             )
         with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
             backend.create_x509_revoked_certificate(object())
+
+    def test_scrypt(self):
+        backend = MultiBackend([DummyScryptBackend()])
+        backend.derive_scrypt(b"key", b"salt", 1, 1, 1, 1)
+
+        backend = MultiBackend([DummyBackend])
+        with pytest.raises(UnsupportedAlgorithm):
+            backend.derive_scrypt(b"key", b"salt", 1, 1, 1, 1)
diff --git a/tests/hazmat/primitives/test_scrypt.py b/tests/hazmat/primitives/test_scrypt.py
new file mode 100644
index 00000000..de4100e3
--- /dev/null
+++ b/tests/hazmat/primitives/test_scrypt.py
@@ -0,0 +1,119 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import absolute_import, division, print_function
+
+import binascii
+
+import os
+
+import pytest
+
+from cryptography.exceptions import (
+    AlreadyFinalized, InvalidKey, UnsupportedAlgorithm
+)
+from cryptography.hazmat.backends.interfaces import ScryptBackend
+from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
+
+from tests.utils import load_nist_vectors, load_vectors_from_file
+
+vectors = load_vectors_from_file(
+    os.path.join("KDF", "scrypt.txt"), load_nist_vectors)
+
+
+@pytest.mark.requires_backend_interface(interface=ScryptBackend)
+class TestScrypt(object):
+    @pytest.mark.parametrize("params", vectors)
+    def test_derive(self, backend, params):
+        password = params["password"]
+        work_factor = int(params["n"])
+        block_size = int(params["r"])
+        parallelization_factor = int(params["p"])
+        length = int(params["length"])
+        salt = params["salt"]
+        derived_key = params["derived_key"]
+
+        scrypt = Scrypt(salt, length, work_factor, block_size,
+                        parallelization_factor, backend)
+        assert binascii.hexlify(scrypt.derive(password)) == derived_key
+
+    def test_unsupported_backend(self):
+        work_factor = 1024
+        block_size = 8
+        parallelization_factor = 16
+        length = 64
+        salt = b"NaCl"
+        backend = object()
+
+        with pytest.raises(UnsupportedAlgorithm):
+            Scrypt(salt, length, work_factor, block_size,
+                   parallelization_factor, backend)
+
+    def test_salt_not_bytes(self, backend):
+        work_factor = 1024
+        block_size = 8
+        parallelization_factor = 16
+        length = 64
+        salt = 1
+
+        with pytest.raises(TypeError):
+            Scrypt(salt, length, work_factor, block_size,
+                   parallelization_factor, backend)
+
+    def test_password_not_bytes(self, backend):
+        password = 1
+        work_factor = 1024
+        block_size = 8
+        parallelization_factor = 16
+        length = 64
+        salt = b"NaCl"
+
+        scrypt = Scrypt(salt, length, work_factor, block_size,
+                        parallelization_factor, backend)
+
+        with pytest.raises(TypeError):
+            scrypt.derive(password)
+
+    @pytest.mark.parametrize("params", vectors)
+    def test_verify(self, backend, params):
+        password = params["password"]
+        work_factor = int(params["n"])
+        block_size = int(params["r"])
+        parallelization_factor = int(params["p"])
+        length = int(params["length"])
+        salt = params["salt"]
+        derived_key = params["derived_key"]
+
+        scrypt = Scrypt(salt, length, work_factor, block_size,
+                        parallelization_factor, backend)
+        assert scrypt.verify(password, binascii.unhexlify(derived_key)) is None
+
+    def test_invalid_verify(self, backend):
+        password = b"password"
+        work_factor = 1024
+        block_size = 8
+        parallelization_factor = 16
+        length = 64
+        salt = b"NaCl"
+        derived_key = b"fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e773"
+
+        scrypt = Scrypt(salt, length, work_factor, block_size,
+                        parallelization_factor, backend)
+
+        with pytest.raises(InvalidKey):
+            scrypt.verify(password, binascii.unhexlify(derived_key))
+
+    def test_already_finalized(self, backend):
+        password = b"password"
+        work_factor = 1024
+        block_size = 8
+        parallelization_factor = 16
+        length = 64
+        salt = b"NaCl"
+
+        scrypt = Scrypt(salt, length, work_factor, block_size,
+                        parallelization_factor, backend)
+        scrypt.derive(password)
+        with pytest.raises(AlreadyFinalized):
+            scrypt.derive(password)