Start of the great refactoring
diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py
index c30bda4..c8e0af0 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 ciphers, modes
-from cryptography.primitives.block import BlockCipher, 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 261bbd1..0c9569f 100644
--- a/tests/primitives/test_nist.py
+++ b/tests/primitives/test_nist.py
@@ -18,33 +18,18 @@
from __future__ import absolute_import, division, print_function
import binascii
-import itertools
-import os
-import pytest
+from cryptography.primitives.block import ciphers, modes
-from cryptography.primitives.block import BlockCipher, 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 @@
"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 @@
"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 @@
"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 @@
"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
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 73394a5..8141faf 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -56,21 +56,19 @@
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 @@
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 @@
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 @@
""").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 @@
"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
diff --git a/tests/utils.py b/tests/utils.py
index d06c9e3..2220822 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 @@
# 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 @@
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