From 9b457dea21096ac3f170c6c49e5acda2ccbf8293 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Wed, 30 Oct 2013 09:12:56 -0500 Subject: move around the tests to organize by cipher --- tests/hazmat/primitives/test_3des.py | 116 +++++++++++ tests/hazmat/primitives/test_aes.py | 182 +++++++++++++++++ tests/hazmat/primitives/test_camellia.py | 88 ++++++++ tests/hazmat/primitives/test_cryptrec.py | 44 ---- tests/hazmat/primitives/test_nist.py | 256 ------------------------ tests/hazmat/primitives/test_openssl_vectors.py | 83 -------- 6 files changed, 386 insertions(+), 383 deletions(-) create mode 100644 tests/hazmat/primitives/test_3des.py create mode 100644 tests/hazmat/primitives/test_aes.py create mode 100644 tests/hazmat/primitives/test_camellia.py delete mode 100644 tests/hazmat/primitives/test_cryptrec.py delete mode 100644 tests/hazmat/primitives/test_nist.py delete mode 100644 tests/hazmat/primitives/test_openssl_vectors.py (limited to 'tests') diff --git a/tests/hazmat/primitives/test_3des.py b/tests/hazmat/primitives/test_3des.py new file mode 100644 index 00000000..d5188ff6 --- /dev/null +++ b/tests/hazmat/primitives/test_3des.py @@ -0,0 +1,116 @@ +# 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 NIST Test Vectors +""" + +from __future__ import absolute_import, division, print_function + +import binascii +import os + +from cryptography.hazmat.primitives.block import ciphers, modes + +from .utils import generate_encrypt_test +from ...utils import load_nist_vectors_from_file + + +class TestTripleDES_CBC(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "KAT"), + [ + "TCBCinvperm.rsp", + "TCBCpermop.rsp", + "TCBCsubtab.rsp", + "TCBCvarkey.rsp", + "TCBCvartext.rsp", + ], + lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), + lambda keys, iv: modes.CBC(binascii.unhexlify(iv)), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "MMT"), + [ + "TCBCMMT1.rsp", + "TCBCMMT2.rsp", + "TCBCMMT3.rsp", + ], + lambda key1, key2, key3, iv: ( + ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) + ), + lambda key1, key2, key3, iv: modes.CBC(binascii.unhexlify(iv)), + ) + + +class TestTripleDES_OFB(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "KAT"), + [ + "TOFBpermop.rsp", + "TOFBsubtab.rsp", + "TOFBvarkey.rsp", + "TOFBvartext.rsp", + "TOFBinvperm.rsp", + ], + lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), + lambda keys, iv: modes.OFB(binascii.unhexlify(iv)), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "MMT"), + [ + "TOFBMMT1.rsp", + "TOFBMMT2.rsp", + "TOFBMMT3.rsp", + ], + lambda key1, key2, key3, iv: ( + ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) + ), + lambda key1, key2, key3, iv: modes.OFB(binascii.unhexlify(iv)), + ) + + +class TestTripleDES_CFB(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "KAT"), + [ + "TCFB64invperm.rsp", + "TCFB64permop.rsp", + "TCFB64subtab.rsp", + "TCFB64varkey.rsp", + "TCFB64vartext.rsp", + ], + lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), + lambda keys, iv: modes.CFB(binascii.unhexlify(iv)), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "3DES", "MMT"), + [ + "TCFB64MMT1.rsp", + "TCFB64MMT2.rsp", + "TCFB64MMT3.rsp", + ], + lambda key1, key2, key3, iv: ( + ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) + ), + lambda key1, key2, key3, iv: modes.CFB(binascii.unhexlify(iv)), + ) diff --git a/tests/hazmat/primitives/test_aes.py b/tests/hazmat/primitives/test_aes.py new file mode 100644 index 00000000..e853a0b8 --- /dev/null +++ b/tests/hazmat/primitives/test_aes.py @@ -0,0 +1,182 @@ +# 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 NIST Test Vectors +""" + +from __future__ import absolute_import, division, print_function + +import binascii +import os + +from cryptography.hazmat.primitives.block import ciphers, modes + +from .utils import generate_encrypt_test +from ...utils import ( + load_nist_vectors_from_file, load_openssl_vectors_from_file +) + + +class TestAES_CBC(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "KAT"), + [ + "CBCGFSbox128.rsp", + "CBCGFSbox192.rsp", + "CBCGFSbox256.rsp", + "CBCKeySbox128.rsp", + "CBCKeySbox192.rsp", + "CBCKeySbox256.rsp", + "CBCVarKey128.rsp", + "CBCVarKey192.rsp", + "CBCVarKey256.rsp", + "CBCVarTxt128.rsp", + "CBCVarTxt192.rsp", + "CBCVarTxt256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + lambda key, iv: modes.CBC(binascii.unhexlify(iv)), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "MMT"), + [ + "CBCMMT128.rsp", + "CBCMMT192.rsp", + "CBCMMT256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + lambda key, iv: modes.CBC(binascii.unhexlify(iv)), + ) + + +class TestAES_ECB(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "KAT"), + [ + "ECBGFSbox128.rsp", + "ECBGFSbox192.rsp", + "ECBGFSbox256.rsp", + "ECBKeySbox128.rsp", + "ECBKeySbox192.rsp", + "ECBKeySbox256.rsp", + "ECBVarKey128.rsp", + "ECBVarKey192.rsp", + "ECBVarKey256.rsp", + "ECBVarTxt128.rsp", + "ECBVarTxt192.rsp", + "ECBVarTxt256.rsp", + ], + lambda key: ciphers.AES(binascii.unhexlify(key)), + lambda key: modes.ECB(), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "MMT"), + [ + "ECBMMT128.rsp", + "ECBMMT192.rsp", + "ECBMMT256.rsp", + ], + lambda key: ciphers.AES(binascii.unhexlify(key)), + lambda key: modes.ECB(), + ) + + +class TestAES_OFB(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "KAT"), + [ + "OFBGFSbox128.rsp", + "OFBGFSbox192.rsp", + "OFBGFSbox256.rsp", + "OFBKeySbox128.rsp", + "OFBKeySbox192.rsp", + "OFBKeySbox256.rsp", + "OFBVarKey128.rsp", + "OFBVarKey192.rsp", + "OFBVarKey256.rsp", + "OFBVarTxt128.rsp", + "OFBVarTxt192.rsp", + "OFBVarTxt256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + lambda key, iv: modes.OFB(binascii.unhexlify(iv)), + ) + + test_MMT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "MMT"), + [ + "OFBMMT128.rsp", + "OFBMMT192.rsp", + "OFBMMT256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + lambda key, iv: modes.OFB(binascii.unhexlify(iv)), + ) + + +class TestAES_CFB(object): + test_KAT = generate_encrypt_test( + lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), + os.path.join("ciphers", "AES", "KAT"), + [ + "CFB128GFSbox128.rsp", + "CFB128GFSbox192.rsp", + "CFB128GFSbox256.rsp", + "CFB128KeySbox128.rsp", + "CFB128KeySbox192.rsp", + "CFB128KeySbox256.rsp", + "CFB128VarKey128.rsp", + "CFB128VarKey192.rsp", + "CFB128VarKey256.rsp", + "CFB128VarTxt128.rsp", + "CFB128VarTxt192.rsp", + "CFB128VarTxt256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + 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("ciphers", "AES", "MMT"), + [ + "CFB128MMT128.rsp", + "CFB128MMT192.rsp", + "CFB128MMT256.rsp", + ], + lambda key, iv: ciphers.AES(binascii.unhexlify(key)), + lambda key, iv: modes.CFB(binascii.unhexlify(iv)), + ) + + +class TestAES_CTR(object): + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, + os.path.join("ciphers", "AES", "CTR"), + ["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 backend: backend.ciphers.supported( + ciphers.AES("\x00" * 16), modes.CTR("\x00" * 16) + ), + skip_message="Does not support AES CTR", + ) diff --git a/tests/hazmat/primitives/test_camellia.py b/tests/hazmat/primitives/test_camellia.py new file mode 100644 index 00000000..ab321a42 --- /dev/null +++ b/tests/hazmat/primitives/test_camellia.py @@ -0,0 +1,88 @@ +# 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.hazmat.primitives.block import ciphers, modes + +from .utils import generate_encrypt_test +from ...utils import ( + load_cryptrec_vectors_from_file, load_openssl_vectors_from_file +) + + +class TestCamelliaECB(object): + test_NTT = generate_encrypt_test( + load_cryptrec_vectors_from_file, + os.path.join("ciphers", "Camellia"), + [ + "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 backend: backend.ciphers.supported( + ciphers.Camellia("\x00" * 16), modes.ECB() + ), + skip_message="Does not support Camellia ECB", + ) + + +class TestCamelliaCBC(object): + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, + os.path.join("ciphers", "Camellia"), + ["camellia-cbc.txt"], + lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), + lambda key, iv: modes.CBC(binascii.unhexlify(iv)), + only_if=lambda backend: backend.ciphers.supported( + ciphers.Camellia("\x00" * 16), modes.CBC("\x00" * 16) + ), + skip_message="Does not support Camellia CBC", + ) + + +class TestCamelliaOFB(object): + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, + os.path.join("ciphers", "Camellia"), + ["camellia-ofb.txt"], + lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), + lambda key, iv: modes.OFB(binascii.unhexlify(iv)), + only_if=lambda backend: backend.ciphers.supported( + ciphers.Camellia("\x00" * 16), modes.OFB("\x00" * 16) + ), + skip_message="Does not support Camellia OFB", + ) + + +class TestCamelliaCFB(object): + test_OpenSSL = generate_encrypt_test( + load_openssl_vectors_from_file, + os.path.join("ciphers", "Camellia"), + ["camellia-cfb.txt"], + lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), + lambda key, iv: modes.CFB(binascii.unhexlify(iv)), + only_if=lambda backend: backend.ciphers.supported( + ciphers.Camellia("\x00" * 16), modes.CFB("\x00" * 16) + ), + skip_message="Does not support Camellia CFB", + ) diff --git a/tests/hazmat/primitives/test_cryptrec.py b/tests/hazmat/primitives/test_cryptrec.py deleted file mode 100644 index c882e475..00000000 --- a/tests/hazmat/primitives/test_cryptrec.py +++ /dev/null @@ -1,44 +0,0 @@ -# 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.hazmat.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("ciphers", "Camellia"), - [ - "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 backend: backend.ciphers.supported( - ciphers.Camellia("\x00" * 16), modes.ECB() - ), - skip_message="Does not support Camellia ECB", - ) diff --git a/tests/hazmat/primitives/test_nist.py b/tests/hazmat/primitives/test_nist.py deleted file mode 100644 index b8b7e9f2..00000000 --- a/tests/hazmat/primitives/test_nist.py +++ /dev/null @@ -1,256 +0,0 @@ -# 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 NIST Test Vectors -""" - -from __future__ import absolute_import, division, print_function - -import binascii -import os - -from cryptography.hazmat.primitives.block import ciphers, modes - -from .utils import generate_encrypt_test -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"), - os.path.join("ciphers", "AES", "KAT"), - [ - "CBCGFSbox128.rsp", - "CBCGFSbox192.rsp", - "CBCGFSbox256.rsp", - "CBCKeySbox128.rsp", - "CBCKeySbox192.rsp", - "CBCKeySbox256.rsp", - "CBCVarKey128.rsp", - "CBCVarKey192.rsp", - "CBCVarKey256.rsp", - "CBCVarTxt128.rsp", - "CBCVarTxt192.rsp", - "CBCVarTxt256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - lambda key, iv: modes.CBC(binascii.unhexlify(iv)), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "MMT"), - [ - "CBCMMT128.rsp", - "CBCMMT192.rsp", - "CBCMMT256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - lambda key, iv: modes.CBC(binascii.unhexlify(iv)), - ) - - -class TestAES_ECB(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "KAT"), - [ - "ECBGFSbox128.rsp", - "ECBGFSbox192.rsp", - "ECBGFSbox256.rsp", - "ECBKeySbox128.rsp", - "ECBKeySbox192.rsp", - "ECBKeySbox256.rsp", - "ECBVarKey128.rsp", - "ECBVarKey192.rsp", - "ECBVarKey256.rsp", - "ECBVarTxt128.rsp", - "ECBVarTxt192.rsp", - "ECBVarTxt256.rsp", - ], - lambda key: ciphers.AES(binascii.unhexlify(key)), - lambda key: modes.ECB(), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "MMT"), - [ - "ECBMMT128.rsp", - "ECBMMT192.rsp", - "ECBMMT256.rsp", - ], - lambda key: ciphers.AES(binascii.unhexlify(key)), - lambda key: modes.ECB(), - ) - - -class TestAES_OFB(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "KAT"), - [ - "OFBGFSbox128.rsp", - "OFBGFSbox192.rsp", - "OFBGFSbox256.rsp", - "OFBKeySbox128.rsp", - "OFBKeySbox192.rsp", - "OFBKeySbox256.rsp", - "OFBVarKey128.rsp", - "OFBVarKey192.rsp", - "OFBVarKey256.rsp", - "OFBVarTxt128.rsp", - "OFBVarTxt192.rsp", - "OFBVarTxt256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - lambda key, iv: modes.OFB(binascii.unhexlify(iv)), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "MMT"), - [ - "OFBMMT128.rsp", - "OFBMMT192.rsp", - "OFBMMT256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - lambda key, iv: modes.OFB(binascii.unhexlify(iv)), - ) - - -class TestAES_CFB(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "AES", "KAT"), - [ - "CFB128GFSbox128.rsp", - "CFB128GFSbox192.rsp", - "CFB128GFSbox256.rsp", - "CFB128KeySbox128.rsp", - "CFB128KeySbox192.rsp", - "CFB128KeySbox256.rsp", - "CFB128VarKey128.rsp", - "CFB128VarKey192.rsp", - "CFB128VarKey256.rsp", - "CFB128VarTxt128.rsp", - "CFB128VarTxt192.rsp", - "CFB128VarTxt256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - 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("ciphers", "AES", "MMT"), - [ - "CFB128MMT128.rsp", - "CFB128MMT192.rsp", - "CFB128MMT256.rsp", - ], - lambda key, iv: ciphers.AES(binascii.unhexlify(key)), - lambda key, iv: modes.CFB(binascii.unhexlify(iv)), - ) - - -class TestTripleDES_CBC(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "KAT"), - [ - "TCBCinvperm.rsp", - "TCBCpermop.rsp", - "TCBCsubtab.rsp", - "TCBCvarkey.rsp", - "TCBCvartext.rsp", - ], - lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), - lambda keys, iv: modes.CBC(binascii.unhexlify(iv)), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "MMT"), - [ - "TCBCMMT1.rsp", - "TCBCMMT2.rsp", - "TCBCMMT3.rsp", - ], - lambda key1, key2, key3, iv: ( - ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) - ), - lambda key1, key2, key3, iv: modes.CBC(binascii.unhexlify(iv)), - ) - - -class TestTripleDES_OFB(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "KAT"), - [ - "TOFBpermop.rsp", - "TOFBsubtab.rsp", - "TOFBvarkey.rsp", - "TOFBvartext.rsp", - "TOFBinvperm.rsp", - ], - lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), - lambda keys, iv: modes.OFB(binascii.unhexlify(iv)), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "MMT"), - [ - "TOFBMMT1.rsp", - "TOFBMMT2.rsp", - "TOFBMMT3.rsp", - ], - lambda key1, key2, key3, iv: ( - ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) - ), - lambda key1, key2, key3, iv: modes.OFB(binascii.unhexlify(iv)), - ) - - -class TestTripleDES_CFB(object): - test_KAT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "KAT"), - [ - "TCFB64invperm.rsp", - "TCFB64permop.rsp", - "TCFB64subtab.rsp", - "TCFB64varkey.rsp", - "TCFB64vartext.rsp", - ], - lambda keys, iv: ciphers.TripleDES(binascii.unhexlify(keys)), - lambda keys, iv: modes.CFB(binascii.unhexlify(iv)), - ) - - test_MMT = generate_encrypt_test( - lambda path: load_nist_vectors_from_file(path, "ENCRYPT"), - os.path.join("ciphers", "3DES", "MMT"), - [ - "TCFB64MMT1.rsp", - "TCFB64MMT2.rsp", - "TCFB64MMT3.rsp", - ], - lambda key1, key2, key3, iv: ( - ciphers.TripleDES(binascii.unhexlify(key1 + key2 + key3)) - ), - lambda key1, key2, key3, iv: modes.CFB(binascii.unhexlify(iv)), - ) diff --git a/tests/hazmat/primitives/test_openssl_vectors.py b/tests/hazmat/primitives/test_openssl_vectors.py deleted file mode 100644 index 2a3e44f3..00000000 --- a/tests/hazmat/primitives/test_openssl_vectors.py +++ /dev/null @@ -1,83 +0,0 @@ -# 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 - -import os - -from cryptography.hazmat.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, - os.path.join("ciphers", "Camellia"), - ["camellia-cbc.txt"], - lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), - lambda key, iv: modes.CBC(binascii.unhexlify(iv)), - only_if=lambda backend: backend.ciphers.supported( - ciphers.Camellia("\x00" * 16), modes.CBC("\x00" * 16) - ), - skip_message="Does not support Camellia CBC", - ) - - -class TestCamelliaOFB(object): - test_OpenSSL = generate_encrypt_test( - load_openssl_vectors_from_file, - os.path.join("ciphers", "Camellia"), - ["camellia-ofb.txt"], - lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), - lambda key, iv: modes.OFB(binascii.unhexlify(iv)), - only_if=lambda backend: backend.ciphers.supported( - ciphers.Camellia("\x00" * 16), modes.OFB("\x00" * 16) - ), - skip_message="Does not support Camellia OFB", - ) - - -class TestCamelliaCFB(object): - test_OpenSSL = generate_encrypt_test( - load_openssl_vectors_from_file, - os.path.join("ciphers", "Camellia"), - ["camellia-cfb.txt"], - lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)), - lambda key, iv: modes.CFB(binascii.unhexlify(iv)), - only_if=lambda backend: backend.ciphers.supported( - ciphers.Camellia("\x00" * 16), modes.CFB("\x00" * 16) - ), - skip_message="Does not support Camellia CFB", - ) - - -class TestAESCTR(object): - test_OpenSSL = generate_encrypt_test( - load_openssl_vectors_from_file, - os.path.join("ciphers", "AES", "CTR"), - ["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 backend: backend.ciphers.supported( - ciphers.AES("\x00" * 16), modes.CTR("\x00" * 16) - ), - skip_message="Does not support AES CTR", - ) -- cgit v1.2.3