diff --git a/cryptography/bindings/__init__.py b/cryptography/bindings/__init__.py
index 8b16500..215f17c 100644
--- a/cryptography/bindings/__init__.py
+++ b/cryptography/bindings/__init__.py
@@ -11,7 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cryptography.bindings.openssl import api
+from cryptography.bindings import openssl
 
 
-_default_api = api
+_default_api = openssl.api
+_ALL_APIS = [
+    openssl.api
+]
diff --git a/cryptography/bindings/openssl/api.py b/cryptography/bindings/openssl/api.py
index 02ba8fd..f1a2c08 100644
--- a/cryptography/bindings/openssl/api.py
+++ b/cryptography/bindings/openssl/api.py
@@ -26,17 +26,18 @@
     """
     _modules = [
         "bignum",
-        "conf",
         "bio",
+        "conf",
         "crypto",
         "dh",
         "dsa",
         "engine",
         "err",
         "evp",
+        "opensslv",
         "rand",
         "rsa",
-        "opensslv",
+        "ssl",
     ]
 
     def __init__(self):
@@ -71,7 +72,7 @@
         #   int foo(short);
         self.lib = self.ffi.verify(
             source="\n".join(includes + functions),
-            libraries=["crypto"],
+            libraries=["crypto", "ssl"],
         )
 
         self.lib.OpenSSL_add_all_algorithms()
diff --git a/cryptography/bindings/openssl/err.py b/cryptography/bindings/openssl/err.py
index ffb6096..76c34a0 100644
--- a/cryptography/bindings/openssl/err.py
+++ b/cryptography/bindings/openssl/err.py
@@ -24,7 +24,6 @@
 """
 
 FUNCTIONS = """
-void SSL_load_error_strings();
 void ERR_load_crypto_strings();
 void ERR_free_strings();
 char* ERR_error_string(unsigned long, char *);
diff --git a/cryptography/bindings/openssl/ssl.py b/cryptography/bindings/openssl/ssl.py
new file mode 100644
index 0000000..8aca86e
--- /dev/null
+++ b/cryptography/bindings/openssl/ssl.py
@@ -0,0 +1,26 @@
+# 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.
+
+INCLUDES = """
+#include <openssl/ssl.h>
+"""
+
+TYPES = """
+"""
+
+FUNCTIONS = """
+void SSL_load_error_strings();
+"""
+
+MACROS = """
+"""
diff --git a/tests/conftest.py b/tests/conftest.py
index d16be3b..b526f2b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,5 +1,5 @@
 def pytest_generate_tests(metafunc):
-    from cryptography.bindings.openssl import api
+    from cryptography.bindings import _ALL_APIS
 
     if "api" in metafunc.fixturenames:
-        metafunc.parametrize("api", [api])
+        metafunc.parametrize("api", _ALL_APIS)
diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py
index c30bda4..edf9765 100644
--- a/tests/primitives/test_cryptrec.py
+++ b/tests/primitives/test_cryptrec.py
@@ -12,51 +12,31 @@
 # 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"),
+    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-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",
     )
-    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..d97b207 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"),
+        os.path.join("AES", "KAT"),
         [
             "CBCGFSbox128.rsp",
             "CBCGFSbox192.rsp",
@@ -58,42 +43,28 @@
             "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"),
+        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, 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"),
+        os.path.join("AES", "KAT"),
         [
             "ECBGFSbox128.rsp",
             "ECBGFSbox192.rsp",
@@ -107,42 +78,28 @@
             "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"),
+        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, 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"),
+        os.path.join("AES", "KAT"),
         [
             "OFBGFSbox128.rsp",
             "OFBGFSbox192.rsp",
@@ -156,42 +113,28 @@
             "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"),
+        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, 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"),
+        os.path.join("AES", "KAT"),
         [
             "CFB128GFSbox128.rsp",
             "CFB128GFSbox192.rsp",
@@ -205,33 +148,19 @@
             "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"),
+        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, 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/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py
index d30efa5..6e32eca 100644
--- a/tests/primitives/test_openssl_vectors.py
+++ b/tests/primitives/test_openssl_vectors.py
@@ -18,83 +18,44 @@
 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_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"),
+        skip_message="Does not support Camellia 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"),
+        skip_message="Does not support Camellia 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"),
+        skip_message="Does not support Camellia 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/test_utils.py b/tests/primitives/test_utils.py
new file mode 100644
index 0000000..4666ece
--- /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 0000000..3cf08c2
--- /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/test_utils.py b/tests/test_utils.py
index 73394a5..28e7407 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
 
@@ -310,30 +304,30 @@
     ).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 @@
     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 d06c9e3..6b1cfd7 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
 
 
@@ -110,15 +112,10 @@
             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