aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/bindings/test_openssl.py3
-rw-r--r--tests/conftest.py5
-rw-r--r--tests/primitives/test_block.py20
-rw-r--r--tests/primitives/test_ciphers.py17
-rw-r--r--tests/primitives/test_cryptrec.py42
-rw-r--r--tests/primitives/test_nist.py171
-rw-r--r--tests/primitives/test_openssl_vectors.py73
-rw-r--r--tests/primitives/test_utils.py14
-rw-r--r--tests/primitives/utils.py42
-rw-r--r--tests/primitives/vectors/OpenSSL/AES/aes-128-ctr.txt4
-rw-r--r--tests/primitives/vectors/OpenSSL/AES/aes-192-ctr.txt4
-rw-r--r--tests/primitives/vectors/OpenSSL/AES/aes-256-ctr.txt5
-rw-r--r--tests/test_utils.py364
-rw-r--r--tests/utils.py39
14 files changed, 470 insertions, 333 deletions
diff --git a/tests/bindings/test_openssl.py b/tests/bindings/test_openssl.py
index b23c4ccc..e5b78d18 100644
--- a/tests/bindings/test_openssl.py
+++ b/tests/bindings/test_openssl.py
@@ -28,3 +28,6 @@ class TestOpenSSL(object):
for every OpenSSL.
"""
assert api.openssl_version_text().startswith("OpenSSL")
+
+ def test_supports_cipher(self):
+ assert api.supports_cipher("not-a-real-cipher") is False
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 00000000..b526f2bf
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,5 @@
+def pytest_generate_tests(metafunc):
+ from cryptography.bindings import _ALL_APIS
+
+ if "api" in metafunc.fixturenames:
+ metafunc.parametrize("api", _ALL_APIS)
diff --git a/tests/primitives/test_block.py b/tests/primitives/test_block.py
index 774409ca..f4d3f467 100644
--- a/tests/primitives/test_block.py
+++ b/tests/primitives/test_block.py
@@ -23,17 +23,17 @@ from cryptography.primitives.block.base import _Operation
class TestBlockCipher(object):
- def test_cipher_name(self):
- cipher = BlockCipher(
+ def test_instantiate_without_api(self):
+ BlockCipher(
ciphers.AES(binascii.unhexlify(b"0" * 32)),
modes.CBC(binascii.unhexlify(b"0" * 32))
)
- assert cipher.name == "AES-128-CBC"
- def test_use_after_finalize(self):
+ def test_use_after_finalize(self, api):
cipher = BlockCipher(
ciphers.AES(binascii.unhexlify(b"0" * 32)),
- modes.CBC(binascii.unhexlify(b"0" * 32))
+ modes.CBC(binascii.unhexlify(b"0" * 32)),
+ api
)
cipher.encrypt(b"a" * 16)
cipher.finalize()
@@ -42,20 +42,22 @@ class TestBlockCipher(object):
with pytest.raises(ValueError):
cipher.finalize()
- def test_encrypt_with_invalid_operation(self):
+ def test_encrypt_with_invalid_operation(self, api):
cipher = BlockCipher(
ciphers.AES(binascii.unhexlify(b"0" * 32)),
- modes.CBC(binascii.unhexlify(b"0" * 32))
+ modes.CBC(binascii.unhexlify(b"0" * 32)),
+ api
)
cipher._operation = _Operation.decrypt
with pytest.raises(ValueError):
cipher.encrypt(b"b" * 16)
- def test_finalize_with_invalid_operation(self):
+ def test_finalize_with_invalid_operation(self, api):
cipher = BlockCipher(
ciphers.AES(binascii.unhexlify(b"0" * 32)),
- modes.CBC(binascii.unhexlify(b"0" * 32))
+ modes.CBC(binascii.unhexlify(b"0" * 32)),
+ api
)
cipher._operation = pretend.stub(name="wat")
diff --git a/tests/primitives/test_ciphers.py b/tests/primitives/test_ciphers.py
index 5ee9f223..27d35850 100644
--- a/tests/primitives/test_ciphers.py
+++ b/tests/primitives/test_ciphers.py
@@ -17,7 +17,7 @@ import binascii
import pytest
-from cryptography.primitives.block.ciphers import AES
+from cryptography.primitives.block.ciphers import AES, Camellia
class TestAES(object):
@@ -33,3 +33,18 @@ class TestAES(object):
def test_invalid_key_size(self):
with pytest.raises(ValueError):
AES(binascii.unhexlify(b"0" * 12))
+
+
+class TestCamellia(object):
+ @pytest.mark.parametrize(("key", "keysize"), [
+ (b"0" * 32, 128),
+ (b"0" * 48, 192),
+ (b"0" * 64, 256),
+ ])
+ def test_key_size(self, key, keysize):
+ cipher = Camellia(binascii.unhexlify(key))
+ assert cipher.key_size == keysize
+
+ def test_invalid_key_size(self):
+ with pytest.raises(ValueError):
+ Camellia(binascii.unhexlify(b"0" * 12))
diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py
new file mode 100644
index 00000000..edf97652
--- /dev/null
+++ b/tests/primitives/test_cryptrec.py
@@ -0,0 +1,42 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Tests using the CRYPTREC (Camellia) Test Vectors
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import binascii
+import os
+
+from cryptography.primitives.block import ciphers, modes
+
+from .utils import generate_encrypt_test
+from ..utils import load_cryptrec_vectors_from_file
+
+
+class TestCamelliaECB(object):
+ test_NTT = generate_encrypt_test(
+ load_cryptrec_vectors_from_file,
+ os.path.join("Camellia", "NTT"),
+ [
+ "camellia-128-ecb.txt",
+ "camellia-192-ecb.txt",
+ "camellia-256-ecb.txt"
+ ],
+ lambda key: ciphers.Camellia(binascii.unhexlify((key))),
+ lambda key: modes.ECB(),
+ only_if=lambda api: api.supports_cipher("camellia-128-ecb"),
+ skip_message="Does not support Camellia ECB",
+ )
diff --git a/tests/primitives/test_nist.py b/tests/primitives/test_nist.py
index 1e5d2396..d97b207b 100644
--- a/tests/primitives/test_nist.py
+++ b/tests/primitives/test_nist.py
@@ -18,33 +18,18 @@ Test using the NIST Test Vectors
from __future__ import absolute_import, division, print_function
import binascii
-import itertools
import os
-import pytest
-
-from cryptography.primitives.block import BlockCipher, ciphers, modes
+from cryptography.primitives.block import ciphers, modes
+from .utils import generate_encrypt_test
from ..utils import load_nist_vectors_from_file
-def parameterize_encrypt_test(cipher, vector_type, params, fnames):
- return pytest.mark.parametrize(params,
- list(itertools.chain.from_iterable(
- load_nist_vectors_from_file(
- os.path.join(cipher, vector_type, fname),
- "ENCRYPT",
- params
- )
- for fname in fnames
- ))
- )
-
-
class TestAES_CBC(object):
- @parameterize_encrypt_test(
- "AES", "KAT",
- ("key", "iv", "plaintext", "ciphertext"),
+ test_KAT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "KAT"),
[
"CBCGFSbox128.rsp",
"CBCGFSbox192.rsp",
@@ -58,40 +43,28 @@ class TestAES_CBC(object):
"CBCVarTxt128.rsp",
"CBCVarTxt192.rsp",
"CBCVarTxt256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
)
- def test_KAT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.CBC(binascii.unhexlify(iv)),
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
-
- @parameterize_encrypt_test(
- "AES", "MMT",
- ("key", "iv", "plaintext", "ciphertext"),
+
+ test_MMT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "MMT"),
[
"CBCMMT128.rsp",
"CBCMMT192.rsp",
"CBCMMT256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
)
- def test_MMT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.CBC(binascii.unhexlify(iv)),
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
class TestAES_ECB(object):
- @parameterize_encrypt_test(
- "AES", "KAT",
- ("key", "plaintext", "ciphertext"),
+ test_KAT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "KAT"),
[
"ECBGFSbox128.rsp",
"ECBGFSbox192.rsp",
@@ -105,40 +78,28 @@ class TestAES_ECB(object):
"ECBVarTxt128.rsp",
"ECBVarTxt192.rsp",
"ECBVarTxt256.rsp",
- ]
+ ],
+ lambda key: ciphers.AES(binascii.unhexlify(key)),
+ lambda key: modes.ECB(),
)
- def test_KAT(self, key, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.ECB()
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
-
- @parameterize_encrypt_test(
- "AES", "MMT",
- ("key", "plaintext", "ciphertext"),
+
+ test_MMT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "MMT"),
[
"ECBMMT128.rsp",
"ECBMMT192.rsp",
"ECBMMT256.rsp",
- ]
+ ],
+ lambda key: ciphers.AES(binascii.unhexlify(key)),
+ lambda key: modes.ECB(),
)
- def test_MMT(self, key, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.ECB()
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
class TestAES_OFB(object):
- @parameterize_encrypt_test(
- "AES", "KAT",
- ("key", "iv", "plaintext", "ciphertext"),
+ test_KAT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "KAT"),
[
"OFBGFSbox128.rsp",
"OFBGFSbox192.rsp",
@@ -152,40 +113,28 @@ class TestAES_OFB(object):
"OFBVarTxt128.rsp",
"OFBVarTxt192.rsp",
"OFBVarTxt256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
)
- def test_KAT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.OFB(binascii.unhexlify(iv))
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
-
- @parameterize_encrypt_test(
- "AES", "MMT",
- ("key", "iv", "plaintext", "ciphertext"),
+
+ test_MMT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "MMT"),
[
"OFBMMT128.rsp",
"OFBMMT192.rsp",
"OFBMMT256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
)
- def test_MMT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.OFB(binascii.unhexlify(iv))
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
class TestAES_CFB(object):
- @parameterize_encrypt_test(
- "AES", "KAT",
- ("key", "iv", "plaintext", "ciphertext"),
+ test_KAT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "KAT"),
[
"CFB128GFSbox128.rsp",
"CFB128GFSbox192.rsp",
@@ -199,31 +148,19 @@ class TestAES_CFB(object):
"CFB128VarTxt128.rsp",
"CFB128VarTxt192.rsp",
"CFB128VarTxt256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
)
- def test_KAT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.CFB(binascii.unhexlify(iv))
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
-
- @parameterize_encrypt_test(
- "AES", "MMT",
- ("key", "iv", "plaintext", "ciphertext"),
+
+ test_MMT = generate_encrypt_test(
+ lambda path: load_nist_vectors_from_file(path, "ENCRYPT"),
+ os.path.join("AES", "MMT"),
[
"CFB128MMT128.rsp",
"CFB128MMT192.rsp",
"CFB128MMT256.rsp",
- ]
+ ],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
)
- def test_MMT(self, key, iv, plaintext, ciphertext):
- cipher = BlockCipher(
- ciphers.AES(binascii.unhexlify(key)),
- modes.CFB(binascii.unhexlify(iv))
- )
- actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
- actual_ciphertext += cipher.finalize()
- assert binascii.hexlify(actual_ciphertext) == ciphertext
diff --git a/tests/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py
new file mode 100644
index 00000000..5b2be784
--- /dev/null
+++ b/tests/primitives/test_openssl_vectors.py
@@ -0,0 +1,73 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Test using the OpenSSL Test Vectors
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import binascii
+
+from cryptography.primitives.block import ciphers, modes
+
+from .utils import generate_encrypt_test
+from ..utils import load_openssl_vectors_from_file
+
+
+class TestCamelliaCBC(object):
+ test_OpenSSL = generate_encrypt_test(
+ load_openssl_vectors_from_file,
+ "Camellia",
+ ["camellia-cbc.txt"],
+ lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+ lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
+ only_if=lambda api: api.supports_cipher("camellia-128-cbc"),
+ skip_message="Does not support Camellia CBC",
+ )
+
+
+class TestCamelliaOFB(object):
+ test_OpenSSL = generate_encrypt_test(
+ load_openssl_vectors_from_file,
+ "Camellia",
+ ["camellia-ofb.txt"],
+ lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+ lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
+ only_if=lambda api: api.supports_cipher("camellia-128-ofb"),
+ skip_message="Does not support Camellia OFB",
+ )
+
+
+class TestCamelliaCFB(object):
+ test_OpenSSL = generate_encrypt_test(
+ load_openssl_vectors_from_file,
+ "Camellia",
+ ["camellia-cfb.txt"],
+ lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
+ lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
+ only_if=lambda api: api.supports_cipher("camellia-128-cfb"),
+ skip_message="Does not support Camellia CFB",
+ )
+
+
+class TestAESCTR(object):
+ test_OpenSSL = generate_encrypt_test(
+ load_openssl_vectors_from_file,
+ "AES",
+ ["aes-128-ctr.txt", "aes-192-ctr.txt", "aes-256-ctr.txt"],
+ lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
+ lambda key, iv: modes.CTR(binascii.unhexlify(iv)),
+ only_if=lambda api: api.supports_cipher("aes-128-ctr"),
+ skip_message="Does not support AES CTR",
+ )
diff --git a/tests/primitives/test_utils.py b/tests/primitives/test_utils.py
new file mode 100644
index 00000000..4666ece7
--- /dev/null
+++ b/tests/primitives/test_utils.py
@@ -0,0 +1,14 @@
+import pytest
+
+from .utils import encrypt_test
+
+
+class TestEncryptTest(object):
+ def test_skips_if_only_if_returns_false(self):
+ with pytest.raises(pytest.skip.Exception) as exc_info:
+ encrypt_test(
+ None, None, None, None,
+ only_if=lambda api: False,
+ skip_message="message!"
+ )
+ assert exc_info.value.args[0] == "message!"
diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py
new file mode 100644
index 00000000..3cf08c28
--- /dev/null
+++ b/tests/primitives/utils.py
@@ -0,0 +1,42 @@
+import binascii
+import os
+
+import pytest
+
+from cryptography.bindings import _ALL_APIS
+from cryptography.primitives.block import BlockCipher
+
+
+def generate_encrypt_test(param_loader, path, file_names, cipher_factory,
+ mode_factory, only_if=lambda api: True,
+ skip_message=None):
+ def test_encryption(self):
+ for api in _ALL_APIS:
+ for file_name in file_names:
+ for params in param_loader(os.path.join(path, file_name)):
+ yield (
+ encrypt_test,
+ api,
+ cipher_factory,
+ mode_factory,
+ params,
+ only_if,
+ skip_message
+ )
+ return test_encryption
+
+
+def encrypt_test(api, cipher_factory, mode_factory, params, only_if,
+ skip_message):
+ if not only_if(api):
+ pytest.skip(skip_message)
+ plaintext = params.pop("plaintext")
+ ciphertext = params.pop("ciphertext")
+ cipher = BlockCipher(
+ cipher_factory(**params),
+ mode_factory(**params),
+ api
+ )
+ actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
+ actual_ciphertext += cipher.finalize()
+ assert actual_ciphertext == binascii.unhexlify(ciphertext)
diff --git a/tests/primitives/vectors/OpenSSL/AES/aes-128-ctr.txt b/tests/primitives/vectors/OpenSSL/AES/aes-128-ctr.txt
new file mode 100644
index 00000000..f4ce15eb
--- /dev/null
+++ b/tests/primitives/vectors/OpenSSL/AES/aes-128-ctr.txt
@@ -0,0 +1,4 @@
+# AES Counter test vectors from RFC3686
+aes-128-ctr:AE6852F8121067CC4BF7A5765577F39E:00000030000000000000000000000001:53696E676C6520626C6F636B206D7367:E4095D4FB7A7B3792D6175A3261311B8:1
+aes-128-ctr:7E24067817FAE0D743D6CE1F32539163:006CB6DBC0543B59DA48D90B00000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F:5104A106168A72D9790D41EE8EDAD388EB2E1EFC46DA57C8FCE630DF9141BE28:1
+aes-128-ctr:7691BE035E5020A8AC6E618529F9A0DC:00E0017B27777F3F4A1786F000000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223:C1CF48A89F2FFDD9CF4652E9EFDB72D74540A42BDE6D7836D59A5CEAAEF3105325B2072F:1
diff --git a/tests/primitives/vectors/OpenSSL/AES/aes-192-ctr.txt b/tests/primitives/vectors/OpenSSL/AES/aes-192-ctr.txt
new file mode 100644
index 00000000..9e166fc4
--- /dev/null
+++ b/tests/primitives/vectors/OpenSSL/AES/aes-192-ctr.txt
@@ -0,0 +1,4 @@
+# AES Counter test vectors from RFC3686
+aes-192-ctr:16AF5B145FC9F579C175F93E3BFB0EED863D06CCFDB78515:0000004836733C147D6D93CB00000001:53696E676C6520626C6F636B206D7367:4B55384FE259C9C84E7935A003CBE928:1
+aes-192-ctr:7C5CB2401B3DC33C19E7340819E0F69C678C3DB8E6F6A91A:0096B03B020C6EADC2CB500D00000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F:453243FC609B23327EDFAAFA7131CD9F8490701C5AD4A79CFC1FE0FF42F4FB00:1
+aes-192-ctr:02BF391EE8ECB159B959617B0965279BF59B60A786D3E0FE:0007BDFD5CBD60278DCC091200000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223:96893FC55E5C722F540B7DD1DDF7E758D288BC95C69165884536C811662F2188ABEE0935:1
diff --git a/tests/primitives/vectors/OpenSSL/AES/aes-256-ctr.txt b/tests/primitives/vectors/OpenSSL/AES/aes-256-ctr.txt
new file mode 100644
index 00000000..d4998750
--- /dev/null
+++ b/tests/primitives/vectors/OpenSSL/AES/aes-256-ctr.txt
@@ -0,0 +1,5 @@
+# AES Counter test vectors from RFC3686
+aes-256-ctr:776BEFF2851DB06F4C8A0542C8696F6C6A81AF1EEC96B4D37FC1D689E6C1C104:00000060DB5672C97AA8F0B200000001:53696E676C6520626C6F636B206D7367:145AD01DBF824EC7560863DC71E3E0C0:1
+aes-256-ctr:F6D66D6BD52D59BB0796365879EFF886C66DD51A5B6A99744B50590C87A23884:00FAAC24C1585EF15A43D87500000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F:F05E231B3894612C49EE000B804EB2A9B8306B508F839D6A5530831D9344AF1C:1
+aes-256-ctr:FF7A617CE69148E4F1726E2F43581DE2AA62D9F805532EDFF1EED687FB54153D:001CC5B751A51D70A1C1114800000001:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223:EB6C52821D0BBBF7CE7594462ACA4FAAB407DF866569FD07F48CC0B583D6071F1EC0E6B8:1
+
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 73394a51..28e7407b 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -56,21 +56,19 @@ def test_load_nist_vectors_encrypt():
PLAINTEXT = 9798c4640bad75c7c3227db910174e72
""").splitlines()
- assert load_nist_vectors(vector_data, "ENCRYPT",
- ["key", "iv", "plaintext", "ciphertext"],
- ) == [
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"f34481ec3cc627bacd5dc3fb08f273e6",
- b"0336763e966d92595a567cc9ce537f5e",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"9798c4640bad75c7c3227db910174e72",
- b"a9a1631bf4996954ebc093957b234589",
- ),
+ assert load_nist_vectors(vector_data, "ENCRYPT") == [
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"f34481ec3cc627bacd5dc3fb08f273e6",
+ "ciphertext": b"0336763e966d92595a567cc9ce537f5e",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"9798c4640bad75c7c3227db910174e72",
+ "ciphertext": b"a9a1631bf4996954ebc093957b234589",
+ },
]
@@ -112,72 +110,69 @@ def test_load_nist_vectors_decrypt():
PLAINTEXT = 9798c4640bad75c7c3227db910174e72
""").splitlines()
- assert load_nist_vectors(vector_data, "DECRYPT",
- ["key", "iv", "ciphertext", "plaintext"],
- ) == [
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"0336763e966d92595a567cc9ce537f5e",
- b"f34481ec3cc627bacd5dc3fb08f273e6",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"a9a1631bf4996954ebc093957b234589",
- b"9798c4640bad75c7c3227db910174e72",
- ),
+ assert load_nist_vectors(vector_data, "DECRYPT") == [
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"f34481ec3cc627bacd5dc3fb08f273e6",
+ "ciphertext": b"0336763e966d92595a567cc9ce537f5e",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"9798c4640bad75c7c3227db910174e72",
+ "ciphertext": b"a9a1631bf4996954ebc093957b234589",
+ },
]
def test_load_nist_vectors_from_file_encrypt():
assert load_nist_vectors_from_file(
"AES/KAT/CBCGFSbox128.rsp",
- "ENCRYPT",
- ["key", "iv", "plaintext", "ciphertext"],
+ "ENCRYPT"
) == [
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"f34481ec3cc627bacd5dc3fb08f273e6",
- b"0336763e966d92595a567cc9ce537f5e",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"9798c4640bad75c7c3227db910174e72",
- b"a9a1631bf4996954ebc093957b234589",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"96ab5c2ff612d9dfaae8c31f30c42168",
- b"ff4f8391a6a40ca5b25d23bedd44a597",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"6a118a874519e64e9963798a503f1d35",
- b"dc43be40be0e53712f7e2bf5ca707209",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"cb9fceec81286ca3e989bd979b0cb284",
- b"92beedab1895a94faa69b632e5cc47ce",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"b26aeb1874e47ca8358ff22378f09144",
- b"459264f4798f6a78bacb89c15ed3d601",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"58c8e00b2631686d54eab84b91f0aca1",
- b"08a4e2efec8a8e3312ca7460b9040bbf",
- ),
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"f34481ec3cc627bacd5dc3fb08f273e6",
+ "ciphertext": b"0336763e966d92595a567cc9ce537f5e",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"9798c4640bad75c7c3227db910174e72",
+ "ciphertext": b"a9a1631bf4996954ebc093957b234589",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"96ab5c2ff612d9dfaae8c31f30c42168",
+ "ciphertext": b"ff4f8391a6a40ca5b25d23bedd44a597",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"6a118a874519e64e9963798a503f1d35",
+ "ciphertext": b"dc43be40be0e53712f7e2bf5ca707209",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"cb9fceec81286ca3e989bd979b0cb284",
+ "ciphertext": b"92beedab1895a94faa69b632e5cc47ce",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"b26aeb1874e47ca8358ff22378f09144",
+ "ciphertext": b"459264f4798f6a78bacb89c15ed3d601",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"58c8e00b2631686d54eab84b91f0aca1",
+ "ciphertext": b"08a4e2efec8a8e3312ca7460b9040bbf",
+ },
]
@@ -185,50 +180,49 @@ def test_load_nist_vectors_from_file_decrypt():
assert load_nist_vectors_from_file(
"AES/KAT/CBCGFSbox128.rsp",
"DECRYPT",
- ["key", "iv", "ciphertext", "plaintext"],
) == [
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"0336763e966d92595a567cc9ce537f5e",
- b"f34481ec3cc627bacd5dc3fb08f273e6",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"a9a1631bf4996954ebc093957b234589",
- b"9798c4640bad75c7c3227db910174e72",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"ff4f8391a6a40ca5b25d23bedd44a597",
- b"96ab5c2ff612d9dfaae8c31f30c42168",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"dc43be40be0e53712f7e2bf5ca707209",
- b"6a118a874519e64e9963798a503f1d35",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"92beedab1895a94faa69b632e5cc47ce",
- b"cb9fceec81286ca3e989bd979b0cb284",
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"459264f4798f6a78bacb89c15ed3d601",
- b"b26aeb1874e47ca8358ff22378f09144"
- ),
- (
- b"00000000000000000000000000000000",
- b"00000000000000000000000000000000",
- b"08a4e2efec8a8e3312ca7460b9040bbf",
- b"58c8e00b2631686d54eab84b91f0aca1"
- ),
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"f34481ec3cc627bacd5dc3fb08f273e6",
+ "ciphertext": b"0336763e966d92595a567cc9ce537f5e",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"9798c4640bad75c7c3227db910174e72",
+ "ciphertext": b"a9a1631bf4996954ebc093957b234589",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"96ab5c2ff612d9dfaae8c31f30c42168",
+ "ciphertext": b"ff4f8391a6a40ca5b25d23bedd44a597",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"6a118a874519e64e9963798a503f1d35",
+ "ciphertext": b"dc43be40be0e53712f7e2bf5ca707209",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"cb9fceec81286ca3e989bd979b0cb284",
+ "ciphertext": b"92beedab1895a94faa69b632e5cc47ce",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"b26aeb1874e47ca8358ff22378f09144",
+ "ciphertext": b"459264f4798f6a78bacb89c15ed3d601",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "iv": b"00000000000000000000000000000000",
+ "plaintext": b"58c8e00b2631686d54eab84b91f0aca1",
+ "ciphertext": b"08a4e2efec8a8e3312ca7460b9040bbf",
+ },
]
@@ -254,21 +248,21 @@ def test_load_cryptrec_vectors():
""").splitlines()
assert load_cryptrec_vectors(vector_data) == [
- (
- b"00000000000000000000000000000000",
- b"80000000000000000000000000000000",
- b"07923A39EB0A817D1C4D87BDB82D1F1C",
- ),
- (
- b"00000000000000000000000000000000",
- b"40000000000000000000000000000000",
- b"48CD6419809672D2349260D89A08D3D3",
- ),
- (
- b"10000000000000000000000000000000",
- b"80000000000000000000000000000000",
- b"07923A39EB0A817D1C4D87BDB82D1F1C",
- ),
+ {
+ "key": b"00000000000000000000000000000000",
+ "plaintext": b"80000000000000000000000000000000",
+ "ciphertext": b"07923A39EB0A817D1C4D87BDB82D1F1C",
+ },
+ {
+ "key": b"00000000000000000000000000000000",
+ "plaintext": b"40000000000000000000000000000000",
+ "ciphertext": b"48CD6419809672D2349260D89A08D3D3",
+ },
+ {
+ "key": b"10000000000000000000000000000000",
+ "plaintext": b"80000000000000000000000000000000",
+ "ciphertext": b"07923A39EB0A817D1C4D87BDB82D1F1C",
+ },
]
@@ -277,11 +271,11 @@ def test_load_cryptrec_vectors_from_file_encrypt():
"Camellia/NTT/camellia-128-ecb.txt"
)
assert test_set[0] == (
- (
- b"00000000000000000000000000000000",
- b"80000000000000000000000000000000",
- b"07923A39EB0A817D1C4D87BDB82D1F1C",
- )
+ {
+ "key": b"00000000000000000000000000000000",
+ "plaintext": b"80000000000000000000000000000000",
+ "ciphertext": b"07923A39EB0A817D1C4D87BDB82D1F1C",
+ }
)
assert len(test_set) == 1280
@@ -310,30 +304,30 @@ def test_load_openssl_vectors():
).splitlines()
assert load_openssl_vectors(vector_data) == [
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"000102030405060708090A0B0C0D0E0F",
- b"6BC1BEE22E409F96E93D7E117393172A",
- b"14F7646187817EB586599146B82BD719",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"14F7646187817EB586599146B82BD719",
- b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
- b"A53D28BB82DF741103EA4F921A44880B",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"000102030405060708090A0B0C0D0E0F",
- b"6BC1BEE22E409F96E93D7E117393172A",
- b"14F7646187817EB586599146B82BD719",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"14F7646187817EB586599146B82BD719",
- b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
- b"A53D28BB82DF741103EA4F921A44880B",
- ),
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"000102030405060708090A0B0C0D0E0F",
+ "plaintext": b"6BC1BEE22E409F96E93D7E117393172A",
+ "ciphertext": b"14F7646187817EB586599146B82BD719",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"14F7646187817EB586599146B82BD719",
+ "plaintext": b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
+ "ciphertext": b"A53D28BB82DF741103EA4F921A44880B",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"000102030405060708090A0B0C0D0E0F",
+ "plaintext": b"6BC1BEE22E409F96E93D7E117393172A",
+ "ciphertext": b"14F7646187817EB586599146B82BD719",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"14F7646187817EB586599146B82BD719",
+ "plaintext": b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
+ "ciphertext": b"A53D28BB82DF741103EA4F921A44880B",
+ },
]
@@ -341,28 +335,28 @@ def test_load_openssl_vectors_from_file():
test_list = load_openssl_vectors_from_file("Camellia/camellia-ofb.txt")
assert len(test_list) == 24
assert test_list[:4] == [
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"000102030405060708090A0B0C0D0E0F",
- b"6BC1BEE22E409F96E93D7E117393172A",
- b"14F7646187817EB586599146B82BD719",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"50FE67CC996D32B6DA0937E99BAFEC60",
- b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
- b"25623DB569CA51E01482649977E28D84",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"D9A4DADA0892239F6B8B3D7680E15674",
- b"30C81C46A35CE411E5FBC1191A0A52EF",
- b"C776634A60729DC657D12B9FCA801E98",
- ),
- (
- b"2B7E151628AED2A6ABF7158809CF4F3C",
- b"A78819583F0308E7A6BF36B1386ABF23",
- b"F69F2445DF4F9B17AD2B417BE66C3710",
- b"D776379BE0E50825E681DA1A4C980E8E",
- ),
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"000102030405060708090A0B0C0D0E0F",
+ "plaintext": b"6BC1BEE22E409F96E93D7E117393172A",
+ "ciphertext": b"14F7646187817EB586599146B82BD719",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"50FE67CC996D32B6DA0937E99BAFEC60",
+ "plaintext": b"AE2D8A571E03AC9C9EB76FAC45AF8E51",
+ "ciphertext": b"25623DB569CA51E01482649977E28D84",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"D9A4DADA0892239F6B8B3D7680E15674",
+ "plaintext": b"30C81C46A35CE411E5FBC1191A0A52EF",
+ "ciphertext": b"C776634A60729DC657D12B9FCA801E98",
+ },
+ {
+ "key": b"2B7E151628AED2A6ABF7158809CF4F3C",
+ "iv": b"A78819583F0308E7A6BF36B1386ABF23",
+ "plaintext": b"F69F2445DF4F9B17AD2B417BE66C3710",
+ "ciphertext": b"D776379BE0E50825E681DA1A4C980E8E",
+ },
]
diff --git a/tests/utils.py b/tests/utils.py
index d06c9e3b..6b1cfd79 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -14,7 +14,7 @@
import os.path
-def load_nist_vectors(vector_data, op, fields):
+def load_nist_vectors(vector_data, op):
section, count, data = None, None, {}
for line in vector_data:
@@ -44,21 +44,19 @@ def load_nist_vectors(vector_data, op, fields):
# For all other tokens we simply want the name, value stored in
# the dictionary
else:
- data[section][count][name.lower()] = value
+ data[section][count][name.lower()] = value.encode("ascii")
- # We want to test only for a particular operation
- return [
- tuple(vector[1][f].encode("ascii") for f in fields)
- for vector in sorted(data[op].items(), key=lambda v: v[0])
- ]
+ # We want to test only for a particular operation, we sort them for the
+ # benefit of the tests of this function.
+ return [v for k, v in sorted(data[op].items(), key=lambda kv: kv[0])]
-def load_nist_vectors_from_file(filename, op, fields):
+def load_nist_vectors_from_file(filename, op):
base = os.path.join(
os.path.dirname(__file__), "primitives", "vectors", "NIST",
)
with open(os.path.join(base, filename), "r") as vector_file:
- return load_nist_vectors(vector_file, op, fields)
+ return load_nist_vectors(vector_file, op)
def load_cryptrec_vectors_from_file(filename):
@@ -87,7 +85,11 @@ def load_cryptrec_vectors(vector_data):
ct = line.split(" : ")[1].replace(" ", "").encode("ascii")
# after a C is found the K+P+C tuple is complete
# there are many P+C pairs for each K
- cryptrec_list.append((key, pt, ct))
+ cryptrec_list.append({
+ "key": key,
+ "plaintext": pt,
+ "ciphertext": ct
+ })
return cryptrec_list
@@ -110,15 +112,10 @@ def load_openssl_vectors(vector_data):
continue
vector = line.split(":")
- params = (
- # key
- vector[1].encode("ascii"),
- # iv
- vector[2].encode("ascii"),
- # plaintext
- vector[3].encode("ascii"),
- # ciphertext
- vector[4].encode("ascii")
- )
- vectors.append(params)
+ vectors.append({
+ "key": vector[1].encode("ascii"),
+ "iv": vector[2].encode("ascii"),
+ "plaintext": vector[3].encode("ascii"),
+ "ciphertext": vector[4].encode("ascii"),
+ })
return vectors
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-25 04:37:08 +0000