Merge branch 'master' into fernet

16 files changed, 341 insertions, 408 deletions

diff --git a/tests/conftest.py b/tests/conftest.py
index e059b630..0ddc3338 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -4,7 +4,7 @@ from cryptography.hazmat.backends.interfaces import (
     HMACBackend, CipherBackend, HashBackend
 )
 
-from .utils import check_for_iface
+from .utils import check_for_iface, check_backend_support
 
 
 def pytest_generate_tests(metafunc):
@@ -19,3 +19,4 @@ def pytest_runtest_setup(item):
     check_for_iface("hmac", HMACBackend, item)
     check_for_iface("cipher", CipherBackend, item)
     check_for_iface("hash", HashBackend, item)
+    check_backend_support(item)
diff --git a/tests/hazmat/primitives/test_3des.py b/tests/hazmat/primitives/test_3des.py
index 439ca258..581c47eb 100644
--- a/tests/hazmat/primitives/test_3des.py
+++ b/tests/hazmat/primitives/test_3des.py
@@ -28,6 +28,12 @@ from .utils import generate_encrypt_test
 from ...utils import load_nist_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
+    ),
+    skip_message="Does not support TripleDES CBC",
+)
 @pytest.mark.cipher
 class TestTripleDES_CBC(object):
     test_KAT = generate_encrypt_test(
@@ -42,10 +48,6 @@ class TestTripleDES_CBC(object):
         ],
         lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
         lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES CBC",
     )
 
     test_MMT = generate_encrypt_test(
@@ -60,13 +62,15 @@ class TestTripleDES_CBC(object):
             binascii.unhexlify(key1 + key2 + key3)
         ),
         lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.CBC("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES CBC",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
+    ),
+    skip_message="Does not support TripleDES OFB",
+)
 @pytest.mark.cipher
 class TestTripleDES_OFB(object):
     test_KAT = generate_encrypt_test(
@@ -81,10 +85,6 @@ class TestTripleDES_OFB(object):
         ],
         lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
         lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES OFB",
     )
 
     test_MMT = generate_encrypt_test(
@@ -99,13 +99,15 @@ class TestTripleDES_OFB(object):
             binascii.unhexlify(key1 + key2 + key3)
         ),
         lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.OFB("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES OFB",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
+    ),
+    skip_message="Does not support TripleDES CFB",
+)
 @pytest.mark.cipher
 class TestTripleDES_CFB(object):
     test_KAT = generate_encrypt_test(
@@ -120,10 +122,6 @@ class TestTripleDES_CFB(object):
         ],
         lambda keys, **kwargs: algorithms.TripleDES(binascii.unhexlify(keys)),
         lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES CFB",
     )
 
     test_MMT = generate_encrypt_test(
@@ -138,8 +136,4 @@ class TestTripleDES_CFB(object):
             binascii.unhexlify(key1 + key2 + key3)
         ),
         lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.TripleDES("\x00" * 8), modes.CFB("\x00" * 8)
-        ),
-        skip_message="Does not support TripleDES CFB",
     )
diff --git a/tests/hazmat/primitives/test_aes.py b/tests/hazmat/primitives/test_aes.py
index e9ef3853..8cba8c66 100644
--- a/tests/hazmat/primitives/test_aes.py
+++ b/tests/hazmat/primitives/test_aes.py
@@ -26,8 +26,14 @@ from ...utils import (
 )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.CBC("\x00" * 16)
+    ),
+    skip_message="Does not support AES CBC",
+)
 @pytest.mark.cipher
-class TestAES(object):
+class TestAES_CBC(object):
     test_CBC = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "AES", "CBC"),
@@ -50,12 +56,17 @@ class TestAES(object):
         ],
         lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.CBC("\x00" * 16)
-        ),
-        skip_message="Does not support AES CBC",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.ECB()
+    ),
+    skip_message="Does not support AES ECB",
+)
+@pytest.mark.cipher
+class TestAES_ECB(object):
     test_ECB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "AES", "ECB"),
@@ -78,12 +89,17 @@ class TestAES(object):
         ],
         lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
         lambda **kwargs: modes.ECB(),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.ECB()
-        ),
-        skip_message="Does not support AES ECB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.OFB("\x00" * 16)
+    ),
+    skip_message="Does not support AES OFB",
+)
+@pytest.mark.cipher
+class TestAES_OFB(object):
     test_OFB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "AES", "OFB"),
@@ -106,12 +122,17 @@ class TestAES(object):
         ],
         lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.OFB("\x00" * 16)
-        ),
-        skip_message="Does not support AES OFB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.CFB("\x00" * 16)
+    ),
+    skip_message="Does not support AES CFB",
+)
+@pytest.mark.cipher
+class TestAES_CFB(object):
     test_CFB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "AES", "CFB"),
@@ -134,24 +155,34 @@ class TestAES(object):
         ],
         lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.CFB("\x00" * 16)
-        ),
-        skip_message="Does not support AES CFB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.CTR("\x00" * 16)
+    ),
+    skip_message="Does not support AES CTR",
+)
+@pytest.mark.cipher
+class TestAES_CTR(object):
     test_CTR = generate_encrypt_test(
         load_openssl_vectors,
         os.path.join("ciphers", "AES", "CTR"),
         ["aes-128-ctr.txt", "aes-192-ctr.txt", "aes-256-ctr.txt"],
         lambda key, **kwargs: algorithms.AES(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CTR(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.CTR("\x00" * 16)
-        ),
-        skip_message="Does not support AES CTR",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
+    ),
+    skip_message="Does not support AES GCM",
+)
+@pytest.mark.cipher
+class TestAES_GCM(object):
     test_GCM = generate_aead_test(
         load_nist_vectors,
         os.path.join("ciphers", "AES", "GCM"),
@@ -165,8 +196,4 @@ class TestAES(object):
         ],
         lambda key: algorithms.AES(key),
         lambda iv, tag: modes.GCM(iv, tag),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
-        ),
-        skip_message="Does not support AES GCM",
     )
diff --git a/tests/hazmat/primitives/test_arc4.py b/tests/hazmat/primitives/test_arc4.py
index f2e2452c..33f7ff09 100644
--- a/tests/hazmat/primitives/test_arc4.py
+++ b/tests/hazmat/primitives/test_arc4.py
@@ -24,6 +24,12 @@ from .utils import generate_stream_encryption_test
 from ...utils import load_nist_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.ARC4("\x00" * 16), None
+    ),
+    skip_message="Does not support ARC4",
+)
 @pytest.mark.cipher
 class TestARC4(object):
     test_rfc = generate_stream_encryption_test(
@@ -39,8 +45,4 @@ class TestARC4(object):
             "rfc-6229-256.txt",
         ],
         lambda key, **kwargs: algorithms.ARC4(binascii.unhexlify(key)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.ARC4("\x00" * 16), None
-        ),
-        skip_message="Does not support ARC4",
     )
diff --git a/tests/hazmat/primitives/test_block.py b/tests/hazmat/primitives/test_block.py
index 22a7c02f..30cf1d60 100644
--- a/tests/hazmat/primitives/test_block.py
+++ b/tests/hazmat/primitives/test_block.py
@@ -136,21 +136,19 @@ class TestCipherContext(object):
             decryptor.finalize()
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
+    ),
+    skip_message="Does not support AES GCM",
+)
 @pytest.mark.cipher
 class TestAEADCipherContext(object):
     test_aead_exceptions = generate_aead_exception_test(
         algorithms.AES,
         modes.GCM,
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
-        ),
-        skip_message="Does not support AES GCM",
     )
     test_aead_tag_exceptions = generate_aead_tag_exception_test(
         algorithms.AES,
         modes.GCM,
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.AES("\x00" * 16), modes.GCM("\x00" * 12)
-        ),
-        skip_message="Does not support AES GCM",
     )
diff --git a/tests/hazmat/primitives/test_blowfish.py b/tests/hazmat/primitives/test_blowfish.py
index 79ceabe7..18512a6e 100644
--- a/tests/hazmat/primitives/test_blowfish.py
+++ b/tests/hazmat/primitives/test_blowfish.py
@@ -24,52 +24,69 @@ from .utils import generate_encrypt_test
 from ...utils import load_nist_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Blowfish("\x00" * 56), modes.ECB()
+    ),
+    skip_message="Does not support Blowfish ECB",
+)
 @pytest.mark.cipher
-class TestBlowfish(object):
+class TestBlowfish_ECB(object):
     test_ECB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "Blowfish"),
         ["bf-ecb.txt"],
         lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
         lambda **kwargs: modes.ECB(),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Blowfish("\x00" * 56), modes.ECB()
-        ),
-        skip_message="Does not support Blowfish ECB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Blowfish("\x00" * 56), modes.CBC("\x00" * 8)
+    ),
+    skip_message="Does not support Blowfish CBC",
+)
+@pytest.mark.cipher
+class TestBlowfish_CBC(object):
     test_CBC = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "Blowfish"),
         ["bf-cbc.txt"],
         lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Blowfish("\x00" * 56), modes.CBC("\x00" * 8)
-        ),
-        skip_message="Does not support Blowfish CBC",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Blowfish("\x00" * 56), modes.OFB("\x00" * 8)
+    ),
+    skip_message="Does not support Blowfish OFB",
+)
+@pytest.mark.cipher
+class TestBlowfish_OFB(object):
     test_OFB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "Blowfish"),
         ["bf-ofb.txt"],
         lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Blowfish("\x00" * 56), modes.OFB("\x00" * 8)
-        ),
-        skip_message="Does not support Blowfish OFB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Blowfish("\x00" * 56), modes.CFB("\x00" * 8)
+    ),
+    skip_message="Does not support Blowfish CFB",
+)
+@pytest.mark.cipher
+class TestBlowfish_CFB(object):
     test_CFB = generate_encrypt_test(
         load_nist_vectors,
         os.path.join("ciphers", "Blowfish"),
         ["bf-cfb.txt"],
         lambda key, **kwargs: algorithms.Blowfish(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Blowfish("\x00" * 56), modes.CFB("\x00" * 8)
-        ),
-        skip_message="Does not support Blowfish CFB",
     )
diff --git a/tests/hazmat/primitives/test_camellia.py b/tests/hazmat/primitives/test_camellia.py
index c376220e..7c56f6f9 100644
--- a/tests/hazmat/primitives/test_camellia.py
+++ b/tests/hazmat/primitives/test_camellia.py
@@ -26,8 +26,14 @@ from ...utils import (
 )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Camellia("\x00" * 16), modes.ECB()
+    ),
+    skip_message="Does not support Camellia ECB",
+)
 @pytest.mark.cipher
-class TestCamellia(object):
+class TestCamellia_ECB(object):
     test_ECB = generate_encrypt_test(
         load_cryptrec_vectors,
         os.path.join("ciphers", "Camellia"),
@@ -38,44 +44,55 @@ class TestCamellia(object):
         ],
         lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
         lambda **kwargs: modes.ECB(),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Camellia("\x00" * 16), modes.ECB()
-        ),
-        skip_message="Does not support Camellia ECB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Camellia("\x00" * 16), modes.CBC("\x00" * 16)
+    ),
+    skip_message="Does not support Camellia CBC",
+)
+@pytest.mark.cipher
+class TestCamellia_CBC(object):
     test_CBC = generate_encrypt_test(
         load_openssl_vectors,
         os.path.join("ciphers", "Camellia"),
         ["camellia-cbc.txt"],
         lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Camellia("\x00" * 16), modes.CBC("\x00" * 16)
-        ),
-        skip_message="Does not support Camellia CBC",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Camellia("\x00" * 16), modes.OFB("\x00" * 16)
+    ),
+    skip_message="Does not support Camellia OFB",
+)
+@pytest.mark.cipher
+class TestCamellia_OFB(object):
     test_OFB = generate_encrypt_test(
         load_openssl_vectors,
         os.path.join("ciphers", "Camellia"),
         ["camellia-ofb.txt"],
         lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Camellia("\x00" * 16), modes.OFB("\x00" * 16)
-        ),
-        skip_message="Does not support Camellia OFB",
     )
 
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.Camellia("\x00" * 16), modes.CFB("\x00" * 16)
+    ),
+    skip_message="Does not support Camellia CFB",
+)
+@pytest.mark.cipher
+class TestCamellia_CFB(object):
     test_CFB = generate_encrypt_test(
         load_openssl_vectors,
         os.path.join("ciphers", "Camellia"),
         ["camellia-cfb.txt"],
         lambda key, **kwargs: algorithms.Camellia(binascii.unhexlify(key)),
         lambda iv, **kwargs: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.Camellia("\x00" * 16), modes.CFB("\x00" * 16)
-        ),
-        skip_message="Does not support Camellia CFB",
     )
diff --git a/tests/hazmat/primitives/test_cast5.py b/tests/hazmat/primitives/test_cast5.py
index a4789c65..d65a86b2 100644
--- a/tests/hazmat/primitives/test_cast5.py
+++ b/tests/hazmat/primitives/test_cast5.py
@@ -24,6 +24,12 @@ from .utils import generate_encrypt_test
 from ...utils import load_nist_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.cipher_supported(
+        algorithms.CAST5("\x00" * 16), modes.ECB()
+    ),
+    skip_message="Does not support CAST5 ECB",
+)
 @pytest.mark.cipher
 class TestCAST5(object):
     test_ECB = generate_encrypt_test(
@@ -32,8 +38,4 @@ class TestCAST5(object):
         ["cast5-ecb.txt"],
         lambda key, **kwargs: algorithms.CAST5(binascii.unhexlify((key))),
         lambda **kwargs: modes.ECB(),
-        only_if=lambda backend: backend.cipher_supported(
-            algorithms.CAST5("\x00" * 16), modes.ECB()
-        ),
-        skip_message="Does not support CAST5 ECB",
     )
diff --git a/tests/hazmat/primitives/test_hash_vectors.py b/tests/hazmat/primitives/test_hash_vectors.py
index d9febea9..13ffc3fd 100644
--- a/tests/hazmat/primitives/test_hash_vectors.py
+++ b/tests/hazmat/primitives/test_hash_vectors.py
@@ -23,6 +23,10 @@ from .utils import generate_hash_test, generate_long_string_hash_test
 from ...utils import load_hash_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA1),
+    skip_message="Does not support SHA1",
+)
 @pytest.mark.hash
 class TestSHA1(object):
     test_SHA1 = generate_hash_test(
@@ -33,11 +37,13 @@ class TestSHA1(object):
             "SHA1ShortMsg.rsp",
         ],
         hashes.SHA1(),
-        only_if=lambda backend: backend.hash_supported(hashes.SHA1),
-        skip_message="Does not support SHA1",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA224),
+    skip_message="Does not support SHA224",
+)
 @pytest.mark.hash
 class TestSHA224(object):
     test_SHA224 = generate_hash_test(
@@ -48,11 +54,13 @@ class TestSHA224(object):
             "SHA224ShortMsg.rsp",
         ],
         hashes.SHA224(),
-        only_if=lambda backend: backend.hash_supported(hashes.SHA224),
-        skip_message="Does not support SHA224",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA256),
+    skip_message="Does not support SHA256",
+)
 @pytest.mark.hash
 class TestSHA256(object):
     test_SHA256 = generate_hash_test(
@@ -63,11 +71,13 @@ class TestSHA256(object):
             "SHA256ShortMsg.rsp",
         ],
         hashes.SHA256(),
-        only_if=lambda backend: backend.hash_supported(hashes.SHA256),
-        skip_message="Does not support SHA256",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA384),
+    skip_message="Does not support SHA384",
+)
 @pytest.mark.hash
 class TestSHA384(object):
     test_SHA384 = generate_hash_test(
@@ -78,11 +88,13 @@ class TestSHA384(object):
             "SHA384ShortMsg.rsp",
         ],
         hashes.SHA384(),
-        only_if=lambda backend: backend.hash_supported(hashes.SHA384),
-        skip_message="Does not support SHA384",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA512),
+    skip_message="Does not support SHA512",
+)
 @pytest.mark.hash
 class TestSHA512(object):
     test_SHA512 = generate_hash_test(
@@ -93,11 +105,13 @@ class TestSHA512(object):
             "SHA512ShortMsg.rsp",
         ],
         hashes.SHA512(),
-        only_if=lambda backend: backend.hash_supported(hashes.SHA512),
-        skip_message="Does not support SHA512",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
+    skip_message="Does not support RIPEMD160",
+)
 @pytest.mark.hash
 class TestRIPEMD160(object):
     test_RIPEMD160 = generate_hash_test(
@@ -107,18 +121,18 @@ class TestRIPEMD160(object):
             "ripevectors.txt",
         ],
         hashes.RIPEMD160(),
-        only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
-        skip_message="Does not support RIPEMD160",
     )
 
     test_RIPEMD160_long_string = generate_long_string_hash_test(
         hashes.RIPEMD160(),
         "52783243c1697bdbe16d37f97f68f08325dc1528",
-        only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
-        skip_message="Does not support RIPEMD160",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
+    skip_message="Does not support Whirlpool",
+)
 @pytest.mark.hash
 class TestWhirlpool(object):
     test_whirlpool = generate_hash_test(
@@ -128,8 +142,6 @@ class TestWhirlpool(object):
             "iso-test-vectors.txt",
         ],
         hashes.Whirlpool(),
-        only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
-        skip_message="Does not support Whirlpool",
     )
 
     test_whirlpool_long_string = generate_long_string_hash_test(
@@ -137,11 +149,13 @@ class TestWhirlpool(object):
         ("0c99005beb57eff50a7cf005560ddf5d29057fd86b2"
          "0bfd62deca0f1ccea4af51fc15490eddc47af32bb2b"
          "66c34ff9ad8c6008ad677f77126953b226e4ed8b01"),
-        only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
-        skip_message="Does not support Whirlpool",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.MD5),
+    skip_message="Does not support MD5",
+)
 @pytest.mark.hash
 class TestMD5(object):
     test_md5 = generate_hash_test(
@@ -151,6 +165,4 @@ class TestMD5(object):
             "rfc-1321.txt",
         ],
         hashes.MD5(),
-        only_if=lambda backend: backend.hash_supported(hashes.MD5),
-        skip_message="Does not support MD5",
     )
diff --git a/tests/hazmat/primitives/test_hashes.py b/tests/hazmat/primitives/test_hashes.py
index 45faaab2..c907ef61 100644
--- a/tests/hazmat/primitives/test_hashes.py
+++ b/tests/hazmat/primitives/test_hashes.py
@@ -69,89 +69,105 @@ class TestHashContext(object):
             hashes.Hash(UnsupportedDummyHash(), backend)
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA1),
+    skip_message="Does not support SHA1",
+)
 @pytest.mark.hash
 class TestSHA1(object):
     test_SHA1 = generate_base_hash_test(
         hashes.SHA1(),
         digest_size=20,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.SHA1),
-        skip_message="Does not support SHA1",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA224),
+    skip_message="Does not support SHA224",
+)
 @pytest.mark.hash
 class TestSHA224(object):
     test_SHA224 = generate_base_hash_test(
         hashes.SHA224(),
         digest_size=28,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.SHA224),
-        skip_message="Does not support SHA224",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA256),
+    skip_message="Does not support SHA256",
+)
 @pytest.mark.hash
 class TestSHA256(object):
     test_SHA256 = generate_base_hash_test(
         hashes.SHA256(),
         digest_size=32,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.SHA256),
-        skip_message="Does not support SHA256",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA384),
+    skip_message="Does not support SHA384",
+)
 @pytest.mark.hash
 class TestSHA384(object):
     test_SHA384 = generate_base_hash_test(
         hashes.SHA384(),
         digest_size=48,
         block_size=128,
-        only_if=lambda backend: backend.hash_supported(hashes.SHA384),
-        skip_message="Does not support SHA384",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA512),
+    skip_message="Does not support SHA512",
+)
 @pytest.mark.hash
 class TestSHA512(object):
     test_SHA512 = generate_base_hash_test(
         hashes.SHA512(),
         digest_size=64,
         block_size=128,
-        only_if=lambda backend: backend.hash_supported(hashes.SHA512),
-        skip_message="Does not support SHA512",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
+    skip_message="Does not support RIPEMD160",
+)
 @pytest.mark.hash
 class TestRIPEMD160(object):
     test_RIPEMD160 = generate_base_hash_test(
         hashes.RIPEMD160(),
         digest_size=20,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.RIPEMD160),
-        skip_message="Does not support RIPEMD160",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
+    skip_message="Does not support Whirlpool",
+)
 @pytest.mark.hash
 class TestWhirlpool(object):
     test_Whirlpool = generate_base_hash_test(
         hashes.Whirlpool(),
         digest_size=64,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.Whirlpool),
-        skip_message="Does not support Whirlpool",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.MD5),
+    skip_message="Does not support MD5",
+)
 @pytest.mark.hash
 class TestMD5(object):
     test_MD5 = generate_base_hash_test(
         hashes.MD5(),
         digest_size=16,
         block_size=64,
-        only_if=lambda backend: backend.hash_supported(hashes.MD5),
-        skip_message="Does not support MD5",
     )
diff --git a/tests/hazmat/primitives/test_hmac.py b/tests/hazmat/primitives/test_hmac.py
index 7acb78b7..04913af6 100644
--- a/tests/hazmat/primitives/test_hmac.py
+++ b/tests/hazmat/primitives/test_hmac.py
@@ -33,14 +33,19 @@ class UnsupportedDummyHash(object):
         name = "unsupported-dummy-hash"
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.MD5),
+    skip_message="Does not support MD5",
+)
 @pytest.mark.hmac
-class TestHMAC(object):
+class TestHMACCopy(object):
     test_copy = generate_base_hmac_test(
         hashes.MD5(),
-        only_if=lambda backend: backend.hmac_supported(hashes.MD5),
-        skip_message="Does not support MD5",
     )
 
+
+@pytest.mark.hmac
+class TestHMAC(object):
     def test_hmac_reject_unicode(self, backend):
         h = hmac.HMAC(b"mykey", hashes.SHA1(), backend=backend)
         with pytest.raises(TypeError):
diff --git a/tests/hazmat/primitives/test_hmac_vectors.py b/tests/hazmat/primitives/test_hmac_vectors.py
index 9bc06a2e..c5644459 100644
--- a/tests/hazmat/primitives/test_hmac_vectors.py
+++ b/tests/hazmat/primitives/test_hmac_vectors.py
@@ -21,6 +21,10 @@ from .utils import generate_hmac_test
 from ...utils import load_hash_vectors
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.MD5),
+    skip_message="Does not support MD5",
+)
 @pytest.mark.hmac
 class TestHMAC_MD5(object):
     test_hmac_md5 = generate_hmac_test(
@@ -30,11 +34,13 @@ class TestHMAC_MD5(object):
             "rfc-2202-md5.txt",
         ],
         hashes.MD5(),
-        only_if=lambda backend: backend.hmac_supported(hashes.MD5),
-        skip_message="Does not support MD5",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.SHA1),
+    skip_message="Does not support SHA1",
+)
 @pytest.mark.hmac
 class TestHMAC_SHA1(object):
     test_hmac_sha1 = generate_hmac_test(
@@ -44,11 +50,13 @@ class TestHMAC_SHA1(object):
             "rfc-2202-sha1.txt",
         ],
         hashes.SHA1(),
-        only_if=lambda backend: backend.hmac_supported(hashes.SHA1),
-        skip_message="Does not support SHA1",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.SHA224),
+    skip_message="Does not support SHA224",
+)
 @pytest.mark.hmac
 class TestHMAC_SHA224(object):
     test_hmac_sha224 = generate_hmac_test(
@@ -58,11 +66,13 @@ class TestHMAC_SHA224(object):
             "rfc-4231-sha224.txt",
         ],
         hashes.SHA224(),
-        only_if=lambda backend: backend.hmac_supported(hashes.SHA224),
-        skip_message="Does not support SHA224",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.SHA256),
+    skip_message="Does not support SHA256",
+)
 @pytest.mark.hmac
 class TestHMAC_SHA256(object):
     test_hmac_sha256 = generate_hmac_test(
@@ -72,11 +82,13 @@ class TestHMAC_SHA256(object):
             "rfc-4231-sha256.txt",
         ],
         hashes.SHA256(),
-        only_if=lambda backend: backend.hmac_supported(hashes.SHA256),
-        skip_message="Does not support SHA256",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.SHA384),
+    skip_message="Does not support SHA384",
+)
 @pytest.mark.hmac
 class TestHMAC_SHA384(object):
     test_hmac_sha384 = generate_hmac_test(
@@ -86,11 +98,13 @@ class TestHMAC_SHA384(object):
             "rfc-4231-sha384.txt",
         ],
         hashes.SHA384(),
-        only_if=lambda backend: backend.hmac_supported(hashes.SHA384),
-        skip_message="Does not support SHA384",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.SHA512),
+    skip_message="Does not support SHA512",
+)
 @pytest.mark.hmac
 class TestHMAC_SHA512(object):
     test_hmac_sha512 = generate_hmac_test(
@@ -100,11 +114,13 @@ class TestHMAC_SHA512(object):
             "rfc-4231-sha512.txt",
         ],
         hashes.SHA512(),
-        only_if=lambda backend: backend.hmac_supported(hashes.SHA512),
-        skip_message="Does not support SHA512",
     )
 
 
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hmac_supported(hashes.RIPEMD160),
+    skip_message="Does not support RIPEMD160",
+)
 @pytest.mark.hmac
 class TestHMAC_RIPEMD160(object):
     test_hmac_ripemd160 = generate_hmac_test(
@@ -114,6 +130,4 @@ class TestHMAC_RIPEMD160(object):
             "rfc-2286-ripemd160.txt",
         ],
         hashes.RIPEMD160(),
-        only_if=lambda backend: backend.hmac_supported(hashes.RIPEMD160),
-        skip_message="Does not support RIPEMD160",
     )
diff --git a/tests/hazmat/primitives/test_utils.py b/tests/hazmat/primitives/test_utils.py
deleted file mode 100644
index c39364c7..00000000
--- a/tests/hazmat/primitives/test_utils.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import pytest
-
-from .utils import (
-    base_hash_test, encrypt_test, hash_test, long_string_hash_test,
-    base_hmac_test, hmac_test, stream_encryption_test, aead_test,
-    aead_exception_test, aead_tag_exception_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 backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            aead_test(
-                None, None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADExceptionTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            aead_exception_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestAEADTagExceptionTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            aead_tag_exception_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestHashTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            hash_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestBaseHashTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            base_hash_test(
-                None, None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestLongHashTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            long_string_hash_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestHMACTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            hmac_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestBaseHMACTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            base_hmac_test(
-                None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
-
-
-class TestStreamEncryptionTest(object):
-    def test_skips_if_only_if_returns_false(self):
-        with pytest.raises(pytest.skip.Exception) as exc_info:
-            stream_encryption_test(
-                None, None, None,
-                only_if=lambda backend: False,
-                skip_message="message!"
-            )
-        assert exc_info.value.args[0] == "message!"
diff --git a/tests/hazmat/primitives/utils.py b/tests/hazmat/primitives/utils.py
index e0184777..cdcf84cb 100644
--- a/tests/hazmat/primitives/utils.py
+++ b/tests/hazmat/primitives/utils.py
@@ -22,27 +22,17 @@ def _load_all_params(path, file_names, param_loader):
 
 
 def generate_encrypt_test(param_loader, path, file_names, cipher_factory,
-                          mode_factory, only_if, skip_message=None):
+                          mode_factory):
     all_params = _load_all_params(path, file_names, param_loader)
 
     @pytest.mark.parametrize("params", all_params)
     def test_encryption(self, backend, params):
-        encrypt_test(
-            backend,
-            cipher_factory,
-            mode_factory,
-            params,
-            only_if,
-            skip_message
-        )
+        encrypt_test(backend, cipher_factory, mode_factory, params)
 
     return test_encryption
 
 
-def encrypt_test(backend, cipher_factory, mode_factory, params, only_if,
-                 skip_message):
-    if not only_if(backend):
-        pytest.skip(skip_message)
+def encrypt_test(backend, cipher_factory, mode_factory, params):
     plaintext = params["plaintext"]
     ciphertext = params["ciphertext"]
     cipher = Cipher(
@@ -61,27 +51,17 @@ def encrypt_test(backend, cipher_factory, mode_factory, params, only_if,
 
 
 def generate_aead_test(param_loader, path, file_names, cipher_factory,
-                       mode_factory, only_if, skip_message):
+                       mode_factory):
     all_params = _load_all_params(path, file_names, param_loader)
 
     @pytest.mark.parametrize("params", all_params)
     def test_aead(self, backend, params):
-        aead_test(
-            backend,
-            cipher_factory,
-            mode_factory,
-            params,
-            only_if,
-            skip_message
-        )
+        aead_test(backend, cipher_factory, mode_factory, params)
 
     return test_aead
 
 
-def aead_test(backend, cipher_factory, mode_factory, params, only_if,
-              skip_message):
-    if not only_if(backend):
-        pytest.skip(skip_message)
+def aead_test(backend, cipher_factory, mode_factory, params):
     if params.get("pt") is not None:
         plaintext = params["pt"]
     ciphertext = params["ct"]
@@ -124,26 +104,16 @@ def aead_test(backend, cipher_factory, mode_factory, params, only_if,
 
 
 def generate_stream_encryption_test(param_loader, path, file_names,
-                                    cipher_factory, only_if=None,
-                                    skip_message=None):
+                                    cipher_factory):
     all_params = _load_all_params(path, file_names, param_loader)
 
     @pytest.mark.parametrize("params", all_params)
     def test_stream_encryption(self, backend, params):
-        stream_encryption_test(
-            backend,
-            cipher_factory,
-            params,
-            only_if,
-            skip_message
-        )
+        stream_encryption_test(backend, cipher_factory, params)
     return test_stream_encryption
 
 
-def stream_encryption_test(backend, cipher_factory, params, only_if,
-                           skip_message):
-    if not only_if(backend):
-        pytest.skip(skip_message)
+def stream_encryption_test(backend, cipher_factory, params):
     plaintext = params["plaintext"]
     ciphertext = params["ciphertext"]
     offset = params["offset"]
@@ -161,25 +131,16 @@ def stream_encryption_test(backend, cipher_factory, params, only_if,
     assert actual_plaintext == binascii.unhexlify(plaintext)
 
 
-def generate_hash_test(param_loader, path, file_names, hash_cls,
-                       only_if=None, skip_message=None):
+def generate_hash_test(param_loader, path, file_names, hash_cls):
     all_params = _load_all_params(path, file_names, param_loader)
 
     @pytest.mark.parametrize("params", all_params)
     def test_hash(self, backend, params):
-        hash_test(
-            backend,
-            hash_cls,
-            params,
-            only_if,
-            skip_message
-        )
+        hash_test(backend, hash_cls, params)
     return test_hash
 
 
-def hash_test(backend, algorithm, params, only_if, skip_message):
-    if only_if is not None and not only_if(backend):
-        pytest.skip(skip_message)
+def hash_test(backend, algorithm, params):
     msg = params[0]
     md = params[1]
     m = hashes.Hash(algorithm, backend=backend)
@@ -188,25 +149,13 @@ def hash_test(backend, algorithm, params, only_if, skip_message):
     assert m.finalize() == binascii.unhexlify(expected_md)
 
 
-def generate_base_hash_test(algorithm, digest_size, block_size,
-                            only_if=None, skip_message=None):
+def generate_base_hash_test(algorithm, digest_size, block_size):
     def test_base_hash(self, backend):
-        base_hash_test(
-            backend,
-            algorithm,
-            digest_size,
-            block_size,
-            only_if,
-            skip_message,
-        )
+        base_hash_test(backend, algorithm, digest_size, block_size)
     return test_base_hash
 
 
-def base_hash_test(backend, algorithm, digest_size, block_size, only_if,
-                   skip_message):
-    if only_if is not None and not only_if(backend):
-        pytest.skip(skip_message)
-
+def base_hash_test(backend, algorithm, digest_size, block_size):
     m = hashes.Hash(algorithm, backend=backend)
     assert m.algorithm.digest_size == digest_size
     assert m.algorithm.block_size == block_size
@@ -221,46 +170,42 @@ def base_hash_test(backend, algorithm, digest_size, block_size, only_if,
     assert copy.finalize() == m.finalize()
 
 
-def generate_long_string_hash_test(hash_factory, md, only_if=None,
-                                   skip_message=None):
+def generate_long_string_hash_test(hash_factory, md):
     def test_long_string_hash(self, backend):
-        long_string_hash_test(
-            backend,
-            hash_factory,
-            md,
-            only_if,
-            skip_message
-        )
+        long_string_hash_test(backend, hash_factory, md)
     return test_long_string_hash
 
 
-def long_string_hash_test(backend, algorithm, md, only_if, skip_message):
-    if only_if is not None and not only_if(backend):
-        pytest.skip(skip_message)
+def long_string_hash_test(backend, algorithm, md):
     m = hashes.Hash(algorithm, backend=backend)
     m.update(b"a" * 1000000)
     assert m.finalize() == binascii.unhexlify(md.lower().encode("ascii"))
 
 
-def generate_hmac_test(param_loader, path, file_names, algorithm,
-                       only_if=None, skip_message=None):
+def generate_base_hmac_test(hash_cls):
+    def test_base_hmac(self, backend):
+        base_hmac_test(backend, hash_cls)
+    return test_base_hmac
+
+
+def base_hmac_test(backend, algorithm):
+    key = b"ab"
+    h = hmac.HMAC(binascii.unhexlify(key), algorithm, backend=backend)
+    h_copy = h.copy()
+    assert h != h_copy
+    assert h._ctx != h_copy._ctx
+
+
+def generate_hmac_test(param_loader, path, file_names, algorithm):
     all_params = _load_all_params(path, file_names, param_loader)
 
     @pytest.mark.parametrize("params", all_params)
     def test_hmac(self, backend, params):
-        hmac_test(
-            backend,
-            algorithm,
-            params,
-            only_if,
-            skip_message
-        )
+        hmac_test(backend, algorithm, params)
     return test_hmac
 
 
-def hmac_test(backend, algorithm, params, only_if, skip_message):
-    if only_if is not None and not only_if(backend):
-        pytest.skip(skip_message)
+def hmac_test(backend, algorithm, params):
     msg = params[0]
     md = params[1]
     key = params[2]
@@ -269,44 +214,13 @@ def hmac_test(backend, algorithm, params, only_if, skip_message):
     assert h.finalize() == binascii.unhexlify(md.encode("ascii"))
 
 
-def generate_base_hmac_test(hash_cls, only_if=None, skip_message=None):
-    def test_base_hmac(self, backend):
-        base_hmac_test(
-            backend,
-            hash_cls,
-            only_if,
-            skip_message,
-        )
-    return test_base_hmac
-
-
-def base_hmac_test(backend, algorithm, only_if, skip_message):
-    if only_if is not None and not only_if(backend):
-        pytest.skip(skip_message)
-    key = b"ab"
-    h = hmac.HMAC(binascii.unhexlify(key), algorithm, backend=backend)
-    h_copy = h.copy()
-    assert h != h_copy
-    assert h._ctx != h_copy._ctx
-
-
-def generate_aead_exception_test(cipher_factory, mode_factory,
-                                 only_if, skip_message):
+def generate_aead_exception_test(cipher_factory, mode_factory):
     def test_aead_exception(self, backend):
-        aead_exception_test(
-            backend,
-            cipher_factory,
-            mode_factory,
-            only_if,
-            skip_message
-        )
+        aead_exception_test(backend, cipher_factory, mode_factory)
     return test_aead_exception
 
 
-def aead_exception_test(backend, cipher_factory, mode_factory,
-                        only_if, skip_message):
-    if not only_if(backend):
-        pytest.skip(skip_message)
+def aead_exception_test(backend, cipher_factory, mode_factory):
     cipher = Cipher(
         cipher_factory(binascii.unhexlify(b"0" * 32)),
         mode_factory(binascii.unhexlify(b"0" * 24)),
@@ -336,23 +250,13 @@ def aead_exception_test(backend, cipher_factory, mode_factory,
         decryptor.tag
 
 
-def generate_aead_tag_exception_test(cipher_factory, mode_factory,
-                                     only_if, skip_message):
+def generate_aead_tag_exception_test(cipher_factory, mode_factory):
     def test_aead_tag_exception(self, backend):
-        aead_tag_exception_test(
-            backend,
-            cipher_factory,
-            mode_factory,
-            only_if,
-            skip_message
-        )
+        aead_tag_exception_test(backend, cipher_factory, mode_factory)
     return test_aead_tag_exception
 
 
-def aead_tag_exception_test(backend, cipher_factory, mode_factory,
-                            only_if, skip_message):
-    if not only_if(backend):
-        pytest.skip(skip_message)
+def aead_tag_exception_test(backend, cipher_factory, mode_factory):
     cipher = Cipher(
         cipher_factory(binascii.unhexlify(b"0" * 32)),
         mode_factory(binascii.unhexlify(b"0" * 24)),
diff --git a/tests/test_utils.py b/tests/test_utils.py
index a65091ff..c640367e 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -20,7 +20,8 @@ import pytest
 
 from .utils import (
     load_nist_vectors, load_vectors_from_file, load_cryptrec_vectors,
-    load_openssl_vectors, load_hash_vectors, check_for_iface
+    load_openssl_vectors, load_hash_vectors, check_for_iface,
+    check_backend_support
 )
 
 
@@ -41,6 +42,36 @@ def test_check_for_iface():
     check_for_iface("fake_name", FakeInterface, item)
 
 
+def test_check_backend_support_skip():
+    supported = pretend.stub(
+        kwargs={"only_if": lambda backend: False, "skip_message": "Nope"}
+    )
+    item = pretend.stub(keywords={"supported": supported},
+                        funcargs={"backend": True})
+    with pytest.raises(pytest.skip.Exception) as exc_info:
+        check_backend_support(item)
+    assert exc_info.value.args[0] == "Nope"
+
+
+def test_check_backend_support_no_skip():
+    supported = pretend.stub(
+        kwargs={"only_if": lambda backend: True, "skip_message": "Nope"}
+    )
+    item = pretend.stub(keywords={"supported": supported},
+                        funcargs={"backend": True})
+    assert check_backend_support(item) is None
+
+
+def test_check_backend_support_no_backend():
+    supported = pretend.stub(
+        kwargs={"only_if": "notalambda", "skip_message": "Nope"}
+    )
+    item = pretend.stub(keywords={"supported": supported},
+                        funcargs={})
+    with pytest.raises(ValueError):
+        check_backend_support(item)
+
+
 def test_load_nist_vectors():
     vector_data = textwrap.dedent("""
     # CAVS 11.1
diff --git a/tests/utils.py b/tests/utils.py
index 82021a5f..beb2ca5d 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -24,6 +24,16 @@ def check_for_iface(name, iface, item):
             ))
 
 
+def check_backend_support(item):
+    supported = item.keywords.get("supported")
+    if supported and "backend" in item.funcargs:
+        if not supported.kwargs["only_if"](item.funcargs["backend"]):
+            pytest.skip(supported.kwargs["skip_message"])
+    elif supported:
+        raise ValueError("This mark is only available on methods that take a "
+                         "backend")
+
+
 def load_vectors_from_file(filename, loader):
     base = os.path.join(
         os.path.dirname(__file__), "hazmat", "primitives", "vectors",