From 1fe70b12b24f1180b2c4fde1764e309bc0cb338d Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 11:59:17 -0700 Subject: Start of the great refactoring --- tests/primitives/test_cryptrec.py | 47 +++------- tests/primitives/test_nist.py | 189 +++++++++++++------------------------- 2 files changed, 74 insertions(+), 162 deletions(-) (limited to 'tests/primitives') diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py index c30bda48..c8e0af0f 100644 --- a/tests/primitives/test_cryptrec.py +++ b/tests/primitives/test_cryptrec.py @@ -12,51 +12,26 @@ # limitations under the License. """ -Test using the CRYPTREC (Camellia) Test Vectors +Tests using the CRYPTREC (Camellia) 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_cryptrec_vectors_from_file -def parameterize_encrypt_test(cipher, vector_type, params, fnames): - return pytest.mark.parametrize(params, - list(itertools.chain.from_iterable( - load_cryptrec_vectors_from_file( - os.path.join(cipher, vector_type, fname), - ) - for fname in fnames - )) - ) - - class TestCamelliaECB(object): - @parameterize_encrypt_test( - "Camellia", "NTT", - ("key", "plaintext", "ciphertext"), - [ - "camellia-128-ecb.txt", - "camellia-192-ecb.txt", - "camellia-256-ecb.txt", - ] + test_NTT = generate_encrypt_test( + load_cryptrec_vectors_from_file, + "Camellia", + "NTT", + ["camellia-128-ecb", "camellia-192-ecb", "camellia-256"], + lambda key: ciphers.Camellia(binascii.unhexlify((key))), + lambda key: modes.EBC(), + only_if=lambda api: api.supports_cipher("camellia-128-ecb") ) - def test_NTT(self, key, plaintext, ciphertext, api): - if not api.supports_cipher("camellia-128-ecb"): - pytest.skip("Does not support Camellia ECB") # pragma: no cover - cipher = BlockCipher( - ciphers.Camellia(binascii.unhexlify(key)), - modes.ECB(), - api - ) - actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) - actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext).upper() == ciphertext diff --git a/tests/primitives/test_nist.py b/tests/primitives/test_nist.py index 261bbd1d..0c9569f1 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"), + "AES", + "KAT", [ "CBCGFSbox128.rsp", "CBCGFSbox192.rsp", @@ -58,42 +43,30 @@ 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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.CBC(binascii.unhexlify(iv)), - api - ) - 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"), + "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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.CBC(binascii.unhexlify(iv)), - api - ) - 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"), + "AES", + "KAT", [ "ECBGFSbox128.rsp", "ECBGFSbox192.rsp", @@ -107,42 +80,30 @@ 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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.ECB(), - api - ) - 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"), + "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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.ECB(), - api - ) - 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"), + "AES", + "KAT", [ "OFBGFSbox128.rsp", "OFBGFSbox192.rsp", @@ -156,42 +117,30 @@ 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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.OFB(binascii.unhexlify(iv)), - api - ) - 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"), + "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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.OFB(binascii.unhexlify(iv)), - api - ) - 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"), + "AES", + "KAT", [ "CFB128GFSbox128.rsp", "CFB128GFSbox192.rsp", @@ -205,33 +154,21 @@ 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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.CFB(binascii.unhexlify(iv)), - api - ) - 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"), + "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, api): - cipher = BlockCipher( - ciphers.AES(binascii.unhexlify(key)), - modes.CFB(binascii.unhexlify(iv)), - api - ) - actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) - actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext) == ciphertext -- cgit v1.2.3 From bd458ae1e3bdd48f74437216ac467ab2e4d68b13 Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 11:59:30 -0700 Subject: Missed file --- tests/primitives/utils.py | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 tests/primitives/utils.py (limited to 'tests/primitives') diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py new file mode 100644 index 00000000..e35c915a --- /dev/null +++ b/tests/primitives/utils.py @@ -0,0 +1,40 @@ +import binascii +import os + +import pytest + +from cryptography.bindings import openssl +from cryptography.primitives.block import BlockCipher + + +def generate_encrypt_test(param_loader, cipher_name, vector_type, file_names, + cipher_factory, mode_factory, + only_if=lambda api: True): + def test_encryption(self): + for api in [openssl.api]: + if not only_if(api): + yield encrypt_skipped + else: + for file_name in file_names: + for params in param_loader( + os.path.join(cipher_name, vector_type, file_name) + ): + yield encrypt_test, api, cipher_factory, mode_factory, params + return test_encryption + + +def encrypt_test(api, cipher_factory, mode_factory, params): + 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 binascii.hexlify(actual_ciphertext) == ciphertext + + +def encrypt_skipped(): + pytest.skip("because reasons") -- cgit v1.2.3 From 016eed1cc1cc26ff404ac31ed3858de362ca37f2 Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:16:04 -0700 Subject: Ported openssl vector tests --- tests/primitives/test_cryptrec.py | 4 +- tests/primitives/test_nist.py | 25 ++++------ tests/primitives/test_openssl_vectors.py | 78 ++++++++------------------------ tests/primitives/utils.py | 9 ++-- 4 files changed, 34 insertions(+), 82 deletions(-) (limited to 'tests/primitives') diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py index c8e0af0f..59d8b24b 100644 --- a/tests/primitives/test_cryptrec.py +++ b/tests/primitives/test_cryptrec.py @@ -18,6 +18,7 @@ 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 @@ -28,8 +29,7 @@ from ..utils import load_cryptrec_vectors_from_file class TestCamelliaECB(object): test_NTT = generate_encrypt_test( load_cryptrec_vectors_from_file, - "Camellia", - "NTT", + os.path.join("Camellia", "NTT"), ["camellia-128-ecb", "camellia-192-ecb", "camellia-256"], lambda key: ciphers.Camellia(binascii.unhexlify((key))), lambda key: modes.EBC(), diff --git a/tests/primitives/test_nist.py b/tests/primitives/test_nist.py index 0c9569f1..e7778f1f 100644 --- a/tests/primitives/test_nist.py +++ b/tests/primitives/test_nist.py @@ -18,6 +18,7 @@ Test using the NIST Test Vectors from __future__ import absolute_import, division, print_function import binascii +import os from cryptography.primitives.block import ciphers, modes @@ -28,8 +29,7 @@ from ..utils import load_nist_vectors_from_file class TestAES_CBC(object): test_KAT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "KAT", + os.path.join("AES", "KAT"), [ "CBCGFSbox128.rsp", "CBCGFSbox192.rsp", @@ -50,8 +50,7 @@ class TestAES_CBC(object): test_MMT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "MMT", + os.path.join("AES", "MMT"), [ "CBCMMT128.rsp", "CBCMMT192.rsp", @@ -65,8 +64,7 @@ class TestAES_CBC(object): class TestAES_ECB(object): test_KAT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "KAT", + os.path.join("AES", "KAT"), [ "ECBGFSbox128.rsp", "ECBGFSbox192.rsp", @@ -87,8 +85,7 @@ class TestAES_ECB(object): test_MMT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "MMT", + os.path.join("AES", "MMT"), [ "ECBMMT128.rsp", "ECBMMT192.rsp", @@ -102,8 +99,7 @@ class TestAES_ECB(object): class TestAES_OFB(object): test_KAT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "KAT", + os.path.join("AES", "KAT"), [ "OFBGFSbox128.rsp", "OFBGFSbox192.rsp", @@ -124,8 +120,7 @@ class TestAES_OFB(object): test_MMT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "MMT", + os.path.join("AES", "MMT"), [ "OFBMMT128.rsp", "OFBMMT192.rsp", @@ -139,8 +134,7 @@ class TestAES_OFB(object): class TestAES_CFB(object): test_KAT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "KAT", + os.path.join("AES", "KAT"), [ "CFB128GFSbox128.rsp", "CFB128GFSbox192.rsp", @@ -162,8 +156,7 @@ class TestAES_CFB(object): test_MMT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - "AES", - "MMT", + os.path.join("AES", "MMT"), [ "CFB128MMT128.rsp", "CFB128MMT192.rsp", diff --git a/tests/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py index d30efa5c..f9c4e1fa 100644 --- a/tests/primitives/test_openssl_vectors.py +++ b/tests/primitives/test_openssl_vectors.py @@ -23,78 +23,40 @@ 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_openssl_vectors_from_file -def parameterize_encrypt_test(cipher, params, fnames): - return pytest.mark.parametrize(params, - list(itertools.chain.from_iterable( - load_openssl_vectors_from_file(os.path.join(cipher, fname)) - for fname in fnames - )) - ) - - class TestCamelliaCBC(object): - - @parameterize_encrypt_test( + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, "Camellia", - ("key", "iv", "plaintext", "ciphertext"), - [ - "camellia-cbc.txt", - ] + ["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") ) - def test_OpenSSL(self, key, iv, plaintext, ciphertext, api): - if not api.supports_cipher("camellia-128-cbc"): - pytest.skip("Does not support Camellia CBC") # pragma: no cover - cipher = BlockCipher( - ciphers.Camellia(binascii.unhexlify(key)), - modes.CBC(binascii.unhexlify(iv)), - ) - actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) - actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext).upper() == ciphertext class TestCamelliaOFB(object): - - @parameterize_encrypt_test( + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, "Camellia", - ("key", "iv", "plaintext", "ciphertext"), - [ - "camellia-ofb.txt", - ] + ["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") ) - def test_OpenSSL(self, key, iv, plaintext, ciphertext, api): - if not api.supports_cipher("camellia-128-ofb"): - pytest.skip("Does not support Camellia OFB") # pragma: no cover - cipher = BlockCipher( - ciphers.Camellia(binascii.unhexlify(key)), - modes.OFB(binascii.unhexlify(iv)), - ) - actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) - actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext).upper() == ciphertext class TestCamelliaCFB(object): - - @parameterize_encrypt_test( + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, "Camellia", - ("key", "iv", "plaintext", "ciphertext"), - [ - "camellia-cfb.txt", - ] + ["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") ) - def test_OpenSSL(self, key, iv, plaintext, ciphertext, api): - if not api.supports_cipher("camellia-128-cfb"): - pytest.skip("Does not support Camellia CFB") # pragma: no cover - cipher = BlockCipher( - ciphers.Camellia(binascii.unhexlify(key)), - modes.CFB(binascii.unhexlify(iv)), - ) - actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) - actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext).upper() == ciphertext diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py index e35c915a..13bf0d89 100644 --- a/tests/primitives/utils.py +++ b/tests/primitives/utils.py @@ -7,18 +7,15 @@ from cryptography.bindings import openssl from cryptography.primitives.block import BlockCipher -def generate_encrypt_test(param_loader, cipher_name, vector_type, file_names, - cipher_factory, mode_factory, - only_if=lambda api: True): +def generate_encrypt_test(param_loader, path, file_names, cipher_factory, + mode_factory, only_if=lambda api: True): def test_encryption(self): for api in [openssl.api]: if not only_if(api): yield encrypt_skipped else: for file_name in file_names: - for params in param_loader( - os.path.join(cipher_name, vector_type, file_name) - ): + for params in param_loader(os.path.join(path, file_name)): yield encrypt_test, api, cipher_factory, mode_factory, params return test_encryption -- cgit v1.2.3 From a20631d332d47903a85b61c4b68c5398125a3ebe Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:17:36 -0700 Subject: Consolidate this list --- tests/primitives/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'tests/primitives') diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py index 13bf0d89..addd7123 100644 --- a/tests/primitives/utils.py +++ b/tests/primitives/utils.py @@ -3,14 +3,14 @@ import os import pytest -from cryptography.bindings import openssl +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): def test_encryption(self): - for api in [openssl.api]: + for api in _ALL_APIS: if not only_if(api): yield encrypt_skipped else: -- cgit v1.2.3 From 512dd6925202c5dc6680dd7157a132a9ffc4855f Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:27:52 -0700 Subject: Move around the skip logic --- tests/primitives/test_cryptrec.py | 5 +++-- tests/primitives/test_openssl_vectors.py | 13 ++++++------- tests/primitives/utils.py | 29 +++++++++++++++++------------ 3 files changed, 26 insertions(+), 21 deletions(-) (limited to 'tests/primitives') diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py index 59d8b24b..4d16ce03 100644 --- a/tests/primitives/test_cryptrec.py +++ b/tests/primitives/test_cryptrec.py @@ -30,8 +30,9 @@ class TestCamelliaECB(object): test_NTT = generate_encrypt_test( load_cryptrec_vectors_from_file, os.path.join("Camellia", "NTT"), - ["camellia-128-ecb", "camellia-192-ecb", "camellia-256"], + ["camellia-128-ecb.txt", "camellia-192-ecb.txt", "camellia-256-ecb.txt"], lambda key: ciphers.Camellia(binascii.unhexlify((key))), lambda key: modes.EBC(), - only_if=lambda api: api.supports_cipher("camellia-128-ecb") + only_if=lambda api: api.supports_cipher("camellia-128-ecb"), + skip_message="Does not support Camellia ECB", ) diff --git a/tests/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py index f9c4e1fa..6e32eca6 100644 --- a/tests/primitives/test_openssl_vectors.py +++ b/tests/primitives/test_openssl_vectors.py @@ -18,10 +18,6 @@ Test using the OpenSSL Test Vectors from __future__ import absolute_import, division, print_function import binascii -import itertools -import os - -import pytest from cryptography.primitives.block import ciphers, modes @@ -36,7 +32,8 @@ class TestCamelliaCBC(object): ["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") + only_if=lambda api: api.supports_cipher("camellia-128-cbc"), + skip_message="Does not support Camellia CBC", ) @@ -47,7 +44,8 @@ class TestCamelliaOFB(object): ["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") + only_if=lambda api: api.supports_cipher("camellia-128-ofb"), + skip_message="Does not support Camellia OFB", ) @@ -58,5 +56,6 @@ class TestCamelliaCFB(object): ["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") + only_if=lambda api: api.supports_cipher("camellia-128-cfb"), + skip_message="Does not support Camellia CFB", ) diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py index addd7123..e4cb8da7 100644 --- a/tests/primitives/utils.py +++ b/tests/primitives/utils.py @@ -8,19 +8,28 @@ from cryptography.primitives.block import BlockCipher def generate_encrypt_test(param_loader, path, file_names, cipher_factory, - mode_factory, only_if=lambda api: True): + mode_factory, only_if=lambda api: True, + skip_message=None): def test_encryption(self): for api in _ALL_APIS: - if not only_if(api): - yield encrypt_skipped - else: - 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 + 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): +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( @@ -31,7 +40,3 @@ def encrypt_test(api, cipher_factory, mode_factory, params): actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) actual_ciphertext += cipher.finalize() assert binascii.hexlify(actual_ciphertext) == ciphertext - - -def encrypt_skipped(): - pytest.skip("because reasons") -- cgit v1.2.3 From fb39b3ffc6fcd3df0f89cd3978796a4377335075 Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:30:59 -0700 Subject: Rewrite to avoid capitalization issues --- tests/primitives/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests/primitives') diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py index e4cb8da7..3cf08c28 100644 --- a/tests/primitives/utils.py +++ b/tests/primitives/utils.py @@ -39,4 +39,4 @@ def encrypt_test(api, cipher_factory, mode_factory, params, only_if, ) actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext)) actual_ciphertext += cipher.finalize() - assert binascii.hexlify(actual_ciphertext) == ciphertext + assert actual_ciphertext == binascii.unhexlify(ciphertext) -- cgit v1.2.3 From f55da9d05e01bb95811da925f3142b08998540ed Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:33:19 -0700 Subject: Yolo --- tests/primitives/test_cryptrec.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests/primitives') diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py index 4d16ce03..13ae771d 100644 --- a/tests/primitives/test_cryptrec.py +++ b/tests/primitives/test_cryptrec.py @@ -32,7 +32,7 @@ class TestCamelliaECB(object): 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.EBC(), + lambda key: modes.ECB(), only_if=lambda api: api.supports_cipher("camellia-128-ecb"), skip_message="Does not support Camellia ECB", ) -- cgit v1.2.3 From 0d381b70c15952f222736d0ef875912649e7013e Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:39:34 -0700 Subject: Unit test the test harness --- tests/primitives/test_utils.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 tests/primitives/test_utils.py (limited to 'tests/primitives') 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!" -- cgit v1.2.3 From 745c95c75cc6588ecd9b927e5974bf00426125a2 Mon Sep 17 00:00:00 2001 From: Alex Gaynor Date: Wed, 16 Oct 2013 14:41:35 -0700 Subject: flake8 fixes --- tests/primitives/test_cryptrec.py | 6 +++++- tests/primitives/test_nist.py | 1 - 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'tests/primitives') diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py index 13ae771d..edf97652 100644 --- a/tests/primitives/test_cryptrec.py +++ b/tests/primitives/test_cryptrec.py @@ -30,7 +30,11 @@ 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"], + [ + "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"), diff --git a/tests/primitives/test_nist.py b/tests/primitives/test_nist.py index e7778f1f..d97b207b 100644 --- a/tests/primitives/test_nist.py +++ b/tests/primitives/test_nist.py @@ -153,7 +153,6 @@ class TestAES_CFB(object): lambda key, iv: modes.CFB(binascii.unhexlify(iv)), ) - test_MMT = generate_encrypt_test( lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), os.path.join("AES", "MMT"), -- cgit v1.2.3