diff --git a/tests/test_crypto.py b/tests/test_crypto.py
index c441e15..a44ac14 100644
--- a/tests/test_crypto.py
+++ b/tests/test_crypto.py
@@ -15,7 +15,7 @@
 
 import pytest
 
-from six import u, b, binary_type
+from six import binary_type
 
 from cryptography.hazmat.backends.openssl.backend import backend
 from cryptography.hazmat.primitives import serialization
@@ -60,7 +60,7 @@
 GOOD_DIGEST = "SHA1"
 BAD_DIGEST = "monkeys"
 
-root_cert_pem = b("""-----BEGIN CERTIFICATE-----
+root_cert_pem = b"""-----BEGIN CERTIFICATE-----
 MIIC7TCCAlagAwIBAgIIPQzE4MbeufQwDQYJKoZIhvcNAQEFBQAwWDELMAkGA1UE
 BhMCVVMxCzAJBgNVBAgTAklMMRAwDgYDVQQHEwdDaGljYWdvMRAwDgYDVQQKEwdU
 ZXN0aW5nMRgwFgYDVQQDEw9UZXN0aW5nIFJvb3QgQ0EwIhgPMjAwOTAzMjUxMjM2
@@ -78,9 +78,9 @@
 hkgaZnzoIq/Uamidegk4hirsCT/R+6vsKAAxNTcBjUeZjlykCJWy5ojShGftXIKY
 w/njVbKMXrvc83qmTdGl3TAM0fxQIpqgcglFLveEBgzn
 -----END CERTIFICATE-----
-""")
+"""
 
-root_key_pem = b("""-----BEGIN RSA PRIVATE KEY-----
+root_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
 MIICXQIBAAKBgQD5mkLpi7q6ROdu7khB3S9aanA0Zls7vvfGOmB80/yeylhGpsjA
 jWen0VtSQke/NlEPGtO38tsV7CsuFnSmschvAnGrcJl76b0UOOHUgDTIoRxC6QDU
 3claegwsrBA+sJEBbqx5RdXbIRGicPG/8qQ4Zm1SKOgotcbwiaor2yxZ2wIDAQAB
@@ -95,9 +95,9 @@
 6AWSeGAdtRFHVzR7oHjVAkB4hutvxiOeiIVQNBhM6RSI9aBPMI21DoX2JRoxvNW2
 cbvAhow217X9V0dVerEOKxnNYspXRrh36h7k4mQA+sDq
 -----END RSA PRIVATE KEY-----
-""")
+"""
 
-intermediate_cert_pem = b("""-----BEGIN CERTIFICATE-----
+intermediate_cert_pem = b"""-----BEGIN CERTIFICATE-----
 MIICVzCCAcCgAwIBAgIRAMPzhm6//0Y/g2pmnHR2C4cwDQYJKoZIhvcNAQENBQAw
 WDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAklMMRAwDgYDVQQHEwdDaGljYWdvMRAw
 DgYDVQQKEwdUZXN0aW5nMRgwFgYDVQQDEw9UZXN0aW5nIFJvb3QgQ0EwHhcNMTQw
@@ -112,9 +112,9 @@
 9n5zXb1ZwhW/sTWgUvmOceJ4/XVs9FkdWOOn1J0XBch9ZIiFe/s5ASIgG7fUdcUF
 9mAWS6FK2ca3xIh5kIupCXOFa0dPvlw/YUFT
 -----END CERTIFICATE-----
-""")
+"""
 
-intermediate_key_pem = b("""-----BEGIN RSA PRIVATE KEY-----
+intermediate_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
 MIICWwIBAAKBgQDYcEQw5lfbEQRjr5Yy4yxAHGV0b9Al+Lmu7wLHMkZ/ZMmKFGIb
 ljbviiD1Nz97Oh2cpB91YwOXOTN2vXHq26S+A5xe8z/QJbBsyghMur88CjdT21H2
 qwMa+r5dCQwEhuGIiZ3KbzB/n4DTMYI5zy4IYPv0pjxShZn4aZTCCK2IUwIDAQAB
@@ -129,9 +129,9 @@
 /qUot9YUBF8m6BuGsQJATHHmdFy/fG1VLkyBp49CAa8tN3Z5r/CgTznI4DfMTf4C
 NbRHn2UmYlwQBa+L5lg9phewNe8aEwpPyPLoV85U8Q==
 -----END RSA PRIVATE KEY-----
-""")
+"""
 
-server_cert_pem = b("""-----BEGIN CERTIFICATE-----
+server_cert_pem = b"""-----BEGIN CERTIFICATE-----
 MIICKDCCAZGgAwIBAgIJAJn/HpR21r/8MA0GCSqGSIb3DQEBBQUAMFgxCzAJBgNV
 BAYTAlVTMQswCQYDVQQIEwJJTDEQMA4GA1UEBxMHQ2hpY2FnbzEQMA4GA1UEChMH
 VGVzdGluZzEYMBYGA1UEAxMPVGVzdGluZyBSb290IENBMCIYDzIwMDkwMzI1MTIz
@@ -145,9 +145,9 @@
 2mgpFQ6FHpoIENGvJhdEKpptQ5i7KaGhnDNTfdy3x1+h852G99f1iyj0RmbuFcM8
 uzujnS8YXWvM7DM1Ilozk4MzPug8jzFp5uhKCQ==
 -----END CERTIFICATE-----
-""")
+"""
 
-server_key_pem = normalize_privatekey_pem(b("""-----BEGIN RSA PRIVATE KEY-----
+server_key_pem = normalize_privatekey_pem(b"""-----BEGIN RSA PRIVATE KEY-----
 MIICWwIBAAKBgQC+pvhuud1dLaQQvzipdtlcTotgr5SuE2LvSx0gz/bg1U3u1eQ+
 U5eqsxaEUceaX5p5Kk+QflvW8qdjVNxQuYS5uc0gK2+OZnlIYxCf4n5GYGzVIx3Q
 SBj/TAEFB2WuVinZBiCbxgL7PFM1Kpa+EwVkCAduPpSflJJPwkYGrK2MHQIDAQAB
@@ -162,9 +162,9 @@
 NaeNCFfH3aeTrX0LyQJAMBWjWmeKM2G2sCExheeQK0ROnaBC8itCECD4Jsve4nqf
 r50+LF74iLXFwqysVCebPKMOpDWp/qQ1BbJQIPs7/A==
 -----END RSA PRIVATE KEY-----
-"""))
+""")
 
-intermediate_server_cert_pem = b("""-----BEGIN CERTIFICATE-----
+intermediate_server_cert_pem = b"""-----BEGIN CERTIFICATE-----
 MIICWDCCAcGgAwIBAgIRAPQFY9jfskSihdiNSNdt6GswDQYJKoZIhvcNAQENBQAw
 ZjEVMBMGA1UEAxMMaW50ZXJtZWRpYXRlMQwwCgYDVQQKEwNvcmcxETAPBgNVBAsT
 CG9yZy11bml0MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEjAQBgNVBAcTCVNh
@@ -179,9 +179,9 @@
 3bfAtV7eSAqBsfxYXyof7G1ALANQERkq3+oyLP1iVt08W1WOUlIMPhdCF/QuCwy6
 x9MJLhUCGLJPM+O2rAPWVD9wCmvq10ALsiH3yA==
 -----END CERTIFICATE-----
-""")
+"""
 
-intermediate_server_key_pem = b("""-----BEGIN RSA PRIVATE KEY-----
+intermediate_server_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
 MIICXAIBAAKBgQCqklnKB37DV9os6vWI4CZsGHHlJlZxMJn9mMdBMkzsa49PrbhC
 SqyLEWCFEp0NE7CnCcA/uAxG6QuqLLj6RG4ZPk5/IaCAv3mLbGoD7N6GOPTyVJOW
 8Yel48mALJNq8jLn4uOyPgMqcrK6HGZuJdNGsfzc0OCLFWQ5tMSaH85UrQIDAQAB
@@ -196,9 +196,9 @@
 ipWJWe0aAlP18ZcEQQJBAL+5lekZ/GUdQoZ4HAsN5a9syrzavJ9VvU1KOOPorPZK
 nMRZbbQgP+aSB7yl6K0gaLaZ8XaK0pjxNBh6ASqg9f4=
 -----END RSA PRIVATE KEY-----
-""")
+"""
 
-client_cert_pem = b("""-----BEGIN CERTIFICATE-----
+client_cert_pem = b"""-----BEGIN CERTIFICATE-----
 MIICJjCCAY+gAwIBAgIJAKxpFI5lODkjMA0GCSqGSIb3DQEBBQUAMFgxCzAJBgNV
 BAYTAlVTMQswCQYDVQQIEwJJTDEQMA4GA1UEBxMHQ2hpY2FnbzEQMA4GA1UEChMH
 VGVzdGluZzEYMBYGA1UEAxMPVGVzdGluZyBSb290IENBMCIYDzIwMDkwMzI1MTIz
@@ -212,9 +212,9 @@
 9Zdr0U4UDCU9SmmGYh4o7R4TZ5pGFvBYvjhHbkSFYFQXZxKUi+WUxplP6I0wr2KJ
 PSTJCjJOn3xo2NTKRgV1gaoTf2EhL+RG8TQ=
 -----END CERTIFICATE-----
-""")
+"""
 
-client_key_pem = normalize_privatekey_pem(b("""-----BEGIN RSA PRIVATE KEY-----
+client_key_pem = normalize_privatekey_pem(b"""-----BEGIN RSA PRIVATE KEY-----
 MIICXgIBAAKBgQDAZh/SRtNm5ntMT4qb6YzEpTroMlq2rn+GrRHRiZ+xkCw/CGNh
 btPir7/QxaUj26BSmQrHw1bGKEbPsWiW7bdXSespl+xKiku4G/KvnnmWdeJHqsiX
 eUZtqurMELcPQAw9xPHEuhqqUJvvEoMTsnCEqGM+7DtboCRajYyHfluARQIDAQAB
@@ -229,9 +229,9 @@
 JJEQjOMCVsEJlRk54WWjAkEAzoZNH6UhDdBK5F38rVt/y4SEHgbSfJHIAmPS32Kq
 f6GGcfNpip0Uk7q7udTKuX7Q/buZi/C4YW7u3VKAquv9NA==
 -----END RSA PRIVATE KEY-----
-"""))
+""")
 
-cleartextCertificatePEM = b("""-----BEGIN CERTIFICATE-----
+cleartextCertificatePEM = b"""-----BEGIN CERTIFICATE-----
 MIIC7TCCAlagAwIBAgIIPQzE4MbeufQwDQYJKoZIhvcNAQEFBQAwWDELMAkGA1UE
 BhMCVVMxCzAJBgNVBAgTAklMMRAwDgYDVQQHEwdDaGljYWdvMRAwDgYDVQQKEwdU
 ZXN0aW5nMRgwFgYDVQQDEw9UZXN0aW5nIFJvb3QgQ0EwIhgPMjAwOTAzMjUxMjM2
@@ -249,9 +249,9 @@
 hkgaZnzoIq/Uamidegk4hirsCT/R+6vsKAAxNTcBjUeZjlykCJWy5ojShGftXIKY
 w/njVbKMXrvc83qmTdGl3TAM0fxQIpqgcglFLveEBgzn
 -----END CERTIFICATE-----
-""")
+"""
 
-cleartextPrivateKeyPEM = normalize_privatekey_pem(b("""\
+cleartextPrivateKeyPEM = normalize_privatekey_pem(b"""\
 -----BEGIN RSA PRIVATE KEY-----
 MIICXQIBAAKBgQD5mkLpi7q6ROdu7khB3S9aanA0Zls7vvfGOmB80/yeylhGpsjA
 jWen0VtSQke/NlEPGtO38tsV7CsuFnSmschvAnGrcJl76b0UOOHUgDTIoRxC6QDU
@@ -267,9 +267,9 @@
 6AWSeGAdtRFHVzR7oHjVAkB4hutvxiOeiIVQNBhM6RSI9aBPMI21DoX2JRoxvNW2
 cbvAhow217X9V0dVerEOKxnNYspXRrh36h7k4mQA+sDq
 -----END RSA PRIVATE KEY-----
-"""))
+""")
 
-cleartextCertificateRequestPEM = b("""-----BEGIN CERTIFICATE REQUEST-----
+cleartextCertificateRequestPEM = b"""-----BEGIN CERTIFICATE REQUEST-----
 MIIBnjCCAQcCAQAwXjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAklMMRAwDgYDVQQH
 EwdDaGljYWdvMRcwFQYDVQQKEw5NeSBDb21wYW55IEx0ZDEXMBUGA1UEAxMORnJl
 ZGVyaWNrIERlYW4wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANp6Y17WzKSw
@@ -280,9 +280,9 @@
 Vrb3HUNqOkiwsJf6kCtq5oPn3QVYzTa76Dt2y3Rtzv6boRSlmlfrgS92GNma8JfR
 oICQk3nAudi6zl1Dix3BCv1pUp5KMtGn3MeDEi6QFGy2rA==
 -----END CERTIFICATE REQUEST-----
-""")
+"""
 
-encryptedPrivateKeyPEM = b("""-----BEGIN RSA PRIVATE KEY-----
+encryptedPrivateKeyPEM = b"""-----BEGIN RSA PRIVATE KEY-----
 Proc-Type: 4,ENCRYPTED
 DEK-Info: DES-EDE3-CBC,9573604A18579E9E
 
@@ -300,12 +300,12 @@
 MbzjS007Oe4qqBnCWaFPSnJX6uLApeTbqAxAeyCql56ULW5x6vDMNC3dwjvS/CEh
 11n8RkgFIQA0AhuKSIg3CbuartRsJnWOLwgLTzsrKYL4yRog1RJrtw==
 -----END RSA PRIVATE KEY-----
-""")
+"""
 
-encryptedPrivateKeyPEMPassphrase = b("foobar")
+encryptedPrivateKeyPEMPassphrase = b"foobar"
 
 
-cleartextPublicKeyPEM = b("""-----BEGIN PUBLIC KEY-----
+cleartextPublicKeyPEM = b"""-----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxszlc+b71LvlLS0ypt/l
 gT/JzSVJtnEqw9WUNGeiChywX2mmQLHEt7KP0JikqUFZOtPclNY823Q4pErMTSWC
 90qlUxI47vNJbXGRfmO2q6Zfw6SE+E9iUb74xezbOJLjBuUIkQzEKEFV+8taiRV+
@@ -314,14 +314,14 @@
 8Xk5iKICEXwnZreIt3jyygqoOKsKZMK/Zl2VhMGhJR6HXRpQCyASzEG7bgtROLhL
 ywIDAQAB
 -----END PUBLIC KEY-----
-""")
+"""
 
 # Some PKCS#7 stuff.  Generated with the openssl command line:
 #
 #    openssl crl2pkcs7 -inform pem -outform pem -certfile s.pem -nocrl
 #
 # with a certificate and key (but the key should be irrelevant) in s.pem
-pkcs7Data = b("""\
+pkcs7Data = b"""\
 -----BEGIN PKCS7-----
 MIIDNwYJKoZIhvcNAQcCoIIDKDCCAyQCAQExADALBgkqhkiG9w0BBwGgggMKMIID
 BjCCAm+gAwIBAgIBATANBgkqhkiG9w0BAQQFADB7MQswCQYDVQQGEwJTRzERMA8G
@@ -342,7 +342,7 @@
 /g5NDjxFZNDJP1dGiLAxPW6JXwov4v0FmdzfLOZ01jDcgQQZqEpYlgpuI5JEWUQ9
 Ho4EzbYCOaEAMQA=
 -----END PKCS7-----
-""")
+"""
 
 pkcs7DataASN1 = base64.b64decode(b"""
 MIIDNwYJKoZIhvcNAQcCoIIDKDCCAyQCAQExADALBgkqhkiG9w0BBwGgggMKMIID
@@ -365,7 +365,7 @@
 Ho4EzbYCOaEAMQA=
 """)
 
-crlData = b("""\
+crlData = b"""\
 -----BEGIN X509 CRL-----
 MIIBWzCBxTANBgkqhkiG9w0BAQQFADBYMQswCQYDVQQGEwJVUzELMAkGA1UECBMC
 SUwxEDAOBgNVBAcTB0NoaWNhZ28xEDAOBgNVBAoTB1Rlc3RpbmcxGDAWBgNVBAMT
@@ -376,9 +376,9 @@
 0yp4HXRFFoRhhSE/hP+eteaPXRgrsNRLHe9ZDd69wmh7J1wMDb0m81RG7kqcbsid
 vrzEeLDRiiPl92dyyWmu
 -----END X509 CRL-----
-""")
+"""
 
-crlDataUnsupportedExtension = b("""\
+crlDataUnsupportedExtension = b"""\
 -----BEGIN X509 CRL-----
 MIIGRzCCBS8CAQIwDQYJKoZIhvcNAQELBQAwJzELMAkGA1UEBhMCVVMxGDAWBgNV
 BAMMD2NyeXB0b2dyYXBoeS5pbxgPMjAxNTAxMDEwMDAwMDBaGA8yMDE2MDEwMTAw
@@ -415,12 +415,12 @@
 SdEILd164bfBeLuplVI+xpmTEMVNpXBlSXl7+xIw9Vk7p7Q1Pa3k/SvhOldYCm6y
 C1xAg/AAq6w78yzYt18j5Mj0s6eeHi1YpHKw
 -----END X509 CRL-----
-""")
+"""
 
 
 # A broken RSA private key which can be used to test the error path through
 # PKey.check.
-inconsistentPrivateKeyPEM = b("""-----BEGIN RSA PRIVATE KEY-----
+inconsistentPrivateKeyPEM = b"""-----BEGIN RSA PRIVATE KEY-----
 MIIBPAIBAAJBAKy+e3dulvXzV7zoTZWc5TzgApr8DmeQHTYC8ydfzH7EECe4R1Xh
 5kwIzOuuFfn178FBiS84gngaNcrFi0Z5fAkCAwEaAQJBAIqm/bz4NA1H++Vx5Ewx
 OcKp3w19QSaZAwlGRtsUxrP7436QjnREM3Bm8ygU11BjkPVmtrKm6AayQfCHqJoT
@@ -429,11 +429,11 @@
 HjubeEgjpj32AQIhAJqMGTaZVOwevTXvvHwNeH+vRWsAYU/gbx+OQB+7VOcBAiEA
 oolb6NMg/R3enNPvS1O4UU1H8wpaF77L4yiSWlE0p4w=
 -----END RSA PRIVATE KEY-----
-""")
+"""
 
 # certificate with NULL bytes in subjectAltName and common name
 
-nulbyteSubjectAltNamePEM = b("""-----BEGIN CERTIFICATE-----
+nulbyteSubjectAltNamePEM = b"""-----BEGIN CERTIFICATE-----
 MIIE2DCCA8CgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBxTELMAkGA1UEBhMCVVMx
 DzANBgNVBAgMBk9yZWdvbjESMBAGA1UEBwwJQmVhdmVydG9uMSMwIQYDVQQKDBpQ
 eXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEgMB4GA1UECwwXUHl0aG9uIENvcmUg
@@ -460,9 +460,9 @@
 kX4LxlEx5RAvpGB2zZVRGr6LobD9rVK91xuHYNIxxxfEGE8tCCWjp0+3ksri9SXx
 VHWBnbM9YaL32u3hxm8sYB/Yb8WSBavJCWJJqRStVRHM1koZlJmXNx2BX4vPo6iW
 RFEIPQsFZRLrtnCAiEhyT8bC2s/Njlu6ly9gtJZWSV46Q3ZjBL4q9sHKqZQ=
------END CERTIFICATE-----""")
+-----END CERTIFICATE-----"""
 
-large_key_pem = b("""-----BEGIN RSA PRIVATE KEY-----
+large_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
 MIIJYgIBAAKCAg4AtRua8eIeevRfsj+fkcHr1vmse7Kgb+oX1ssJAvCb1R7JQMnH
 hNDjDP6b3vEkZuPUzlDHymP+cNkXvvi4wJ4miVbO3+SeU4Sh+jmsHeHzGIXat9xW
 9PFtuPM5FQq8zvkY8aDeRYmYwN9JKu4/neMBCBqostYlTEWg+bSytO/qWnyHTHKh
@@ -514,7 +514,7 @@
 le7YjqHugezmjMGlA0sDw5aCXjfbl74vowRFYMO6e3ItApfSRgNV86CDoX74WI/5
 AYU/QVM4wGt8XGT2KwDFJaxYGKsGDMWmXY04dS+WPuetCbouWUusyFwRb9SzFave
 vYeU7Ab/
------END RSA PRIVATE KEY-----""")
+-----END RSA PRIVATE KEY-----"""
 
 ec_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
 MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgYirTZSx+5O8Y6tlG
@@ -568,7 +568,7 @@
         # This isn't necessarily the best string representation.  Perhaps it
         # will be changed/improved in the future.
         self.assertEquals(
-            str(X509Extension(b('basicConstraints'), True, b('CA:false'))),
+            str(X509Extension(b'basicConstraints', True, b'CA:false')),
             'CA:FALSE')
 
     def test_type(self):
@@ -579,7 +579,7 @@
         self.assertIdentical(X509Extension, X509ExtensionType)
         self.assertConsistentType(
             X509Extension,
-            'X509Extension', b('basicConstraints'), True, b('CA:true'))
+            'X509Extension', b'basicConstraints', True, b'CA:true')
 
     def test_construction(self):
         """
@@ -587,14 +587,14 @@
         flag, and an extension value and returns an
         :py:class:`X509ExtensionType` instance.
         """
-        basic = X509Extension(b('basicConstraints'), True, b('CA:true'))
+        basic = X509Extension(b'basicConstraints', True, b'CA:true')
         self.assertTrue(
             isinstance(basic, X509ExtensionType),
             "%r is of type %r, should be %r" % (
                 basic, type(basic), X509ExtensionType))
 
         comment = X509Extension(
-            b('nsComment'), False, b('pyOpenSSL unit test'))
+            b'nsComment', False, b'pyOpenSSL unit test')
         self.assertTrue(
             isinstance(comment, X509ExtensionType),
             "%r is of type %r, should be %r" % (
@@ -606,26 +606,26 @@
         extension name or value.
         """
         self.assertRaises(
-            Error, X509Extension, b('thisIsMadeUp'), False, b('hi'))
+            Error, X509Extension, b'thisIsMadeUp', False, b'hi')
         self.assertRaises(
-            Error, X509Extension, b('basicConstraints'), False, b('blah blah'))
+            Error, X509Extension, b'basicConstraints', False, b'blah blah')
 
         # Exercise a weird one (an extension which uses the r2i method).  This
         # exercises the codepath that requires a non-NULL ctx to be passed to
         # X509V3_EXT_nconf.  It can't work now because we provide no
         # configuration database.  It might be made to work in the future.
         self.assertRaises(
-            Error, X509Extension, b('proxyCertInfo'), True,
-            b('language:id-ppl-anyLanguage,pathlen:1,policy:text:AB'))
+            Error, X509Extension, b'proxyCertInfo', True,
+            b'language:id-ppl-anyLanguage,pathlen:1,policy:text:AB')
 
     def test_get_critical(self):
         """
         :py:meth:`X509ExtensionType.get_critical` returns the value of the
         extension's critical flag.
         """
-        ext = X509Extension(b('basicConstraints'), True, b('CA:true'))
+        ext = X509Extension(b'basicConstraints', True, b'CA:true')
         self.assertTrue(ext.get_critical())
-        ext = X509Extension(b('basicConstraints'), False, b('CA:true'))
+        ext = X509Extension(b'basicConstraints', False, b'CA:true')
         self.assertFalse(ext.get_critical())
 
     def test_get_short_name(self):
@@ -633,26 +633,26 @@
         :py:meth:`X509ExtensionType.get_short_name` returns a string giving the
         short type name of the extension.
         """
-        ext = X509Extension(b('basicConstraints'), True, b('CA:true'))
-        self.assertEqual(ext.get_short_name(), b('basicConstraints'))
-        ext = X509Extension(b('nsComment'), True, b('foo bar'))
-        self.assertEqual(ext.get_short_name(), b('nsComment'))
+        ext = X509Extension(b'basicConstraints', True, b'CA:true')
+        self.assertEqual(ext.get_short_name(), b'basicConstraints')
+        ext = X509Extension(b'nsComment', True, b'foo bar')
+        self.assertEqual(ext.get_short_name(), b'nsComment')
 
     def test_get_data(self):
         """
         :py:meth:`X509Extension.get_data` returns a string giving the data of
         the extension.
         """
-        ext = X509Extension(b('basicConstraints'), True, b('CA:true'))
+        ext = X509Extension(b'basicConstraints', True, b'CA:true')
         # Expect to get back the DER encoded form of CA:true.
-        self.assertEqual(ext.get_data(), b('0\x03\x01\x01\xff'))
+        self.assertEqual(ext.get_data(), b'0\x03\x01\x01\xff')
 
     def test_get_data_wrong_args(self):
         """
         :py:meth:`X509Extension.get_data` raises :py:exc:`TypeError` if passed
         any arguments.
         """
-        ext = X509Extension(b('basicConstraints'), True, b('CA:true'))
+        ext = X509Extension(b'basicConstraints', True, b'CA:true')
         self.assertRaises(TypeError, ext.get_data, None)
         self.assertRaises(TypeError, ext.get_data, "foo")
         self.assertRaises(TypeError, ext.get_data, 7)
@@ -664,13 +664,13 @@
         case.
         """
         ext1 = X509Extension(
-            b('basicConstraints'), False, b('CA:TRUE'), subject=self.x509)
+            b'basicConstraints', False, b'CA:TRUE', subject=self.x509)
         self.x509.add_extensions([ext1])
         self.x509.sign(self.pkey, 'sha1')
         # This is a little lame.  Can we think of a better way?
         text = dump_certificate(FILETYPE_TEXT, self.x509)
-        self.assertTrue(b('X509v3 Basic Constraints:') in text)
-        self.assertTrue(b('CA:TRUE') in text)
+        self.assertTrue(b'X509v3 Basic Constraints:' in text)
+        self.assertTrue(b'CA:TRUE' in text)
 
     def test_subject(self):
         """
@@ -678,11 +678,11 @@
         :py:class:`X509Extension` provides its value.
         """
         ext3 = X509Extension(
-            b('subjectKeyIdentifier'), False, b('hash'), subject=self.x509)
+            b'subjectKeyIdentifier', False, b'hash', subject=self.x509)
         self.x509.add_extensions([ext3])
         self.x509.sign(self.pkey, 'sha1')
         text = dump_certificate(FILETYPE_TEXT, self.x509)
-        self.assertTrue(b('X509v3 Subject Key Identifier:') in text)
+        self.assertTrue(b'X509v3 Subject Key Identifier:' in text)
 
     def test_missing_subject(self):
         """
@@ -690,7 +690,7 @@
         is given no value, something happens.
         """
         self.assertRaises(
-            Error, X509Extension, b('subjectKeyIdentifier'), False, b('hash'))
+            Error, X509Extension, b'subjectKeyIdentifier', False, b'hash')
 
     def test_invalid_subject(self):
         """
@@ -710,12 +710,12 @@
         case.
         """
         ext1 = X509Extension(
-            b('basicConstraints'), False, b('CA:TRUE'), issuer=self.x509)
+            b'basicConstraints', False, b'CA:TRUE', issuer=self.x509)
         self.x509.add_extensions([ext1])
         self.x509.sign(self.pkey, 'sha1')
         text = dump_certificate(FILETYPE_TEXT, self.x509)
-        self.assertTrue(b('X509v3 Basic Constraints:') in text)
-        self.assertTrue(b('CA:TRUE') in text)
+        self.assertTrue(b'X509v3 Basic Constraints:' in text)
+        self.assertTrue(b'CA:TRUE' in text)
 
     def test_issuer(self):
         """
@@ -723,13 +723,13 @@
         :py:class:`X509Extension` provides its value.
         """
         ext2 = X509Extension(
-            b('authorityKeyIdentifier'), False, b('issuer:always'),
+            b'authorityKeyIdentifier', False, b'issuer:always',
             issuer=self.x509)
         self.x509.add_extensions([ext2])
         self.x509.sign(self.pkey, 'sha1')
         text = dump_certificate(FILETYPE_TEXT, self.x509)
-        self.assertTrue(b('X509v3 Authority Key Identifier:') in text)
-        self.assertTrue(b('DirName:/CN=Yoda root CA') in text)
+        self.assertTrue(b'X509v3 Authority Key Identifier:' in text)
+        self.assertTrue(b'DirName:/CN=Yoda root CA' in text)
 
     def test_missing_issuer(self):
         """
@@ -739,8 +739,8 @@
         self.assertRaises(
             Error,
             X509Extension,
-            b('authorityKeyIdentifier'), False,
-            b('keyid:always,issuer:always'))
+            b'authorityKeyIdentifier', False,
+            b'keyid:always,issuer:always')
 
     def test_invalid_issuer(self):
         """
@@ -1174,8 +1174,8 @@
         a = self._x509name(CN="foo", C="US")
         self.assertEqual(
             a.der(),
-            b('0\x1b1\x0b0\t\x06\x03U\x04\x06\x13\x02US'
-              '1\x0c0\n\x06\x03U\x04\x03\x0c\x03foo'))
+            b'0\x1b1\x0b0\t\x06\x03U\x04\x06\x13\x02US'
+            b'1\x0c0\n\x06\x03U\x04\x03\x0c\x03foo')
 
     def test_get_components(self):
         """
@@ -1186,11 +1186,11 @@
         a = self._x509name()
         self.assertEqual(a.get_components(), [])
         a.CN = "foo"
-        self.assertEqual(a.get_components(), [(b("CN"), b("foo"))])
+        self.assertEqual(a.get_components(), [(b"CN", b"foo")])
         a.organizationalUnitName = "bar"
         self.assertEqual(
             a.get_components(),
-            [(b("CN"), b("foo")), (b("OU"), b("bar"))])
+            [(b"CN", b"foo"), (b"OU", b"bar")])
 
     def test_load_nul_byte_attribute(self):
         """
@@ -1361,12 +1361,12 @@
         """
         request = X509Req()
         request.add_extensions([
-            X509Extension(b('basicConstraints'), True, b('CA:false'))])
+            X509Extension(b'basicConstraints', True, b'CA:false')])
         exts = request.get_extensions()
         self.assertEqual(len(exts), 1)
-        self.assertEqual(exts[0].get_short_name(), b('basicConstraints'))
+        self.assertEqual(exts[0].get_short_name(), b'basicConstraints')
         self.assertEqual(exts[0].get_critical(), 1)
-        self.assertEqual(exts[0].get_data(), b('0\x00'))
+        self.assertEqual(exts[0].get_data(), b'0\x00')
 
     def test_get_extensions(self):
         """
@@ -1377,16 +1377,16 @@
         exts = request.get_extensions()
         self.assertEqual(exts, [])
         request.add_extensions([
-            X509Extension(b('basicConstraints'), True, b('CA:true')),
-            X509Extension(b('keyUsage'), False, b('digitalSignature'))])
+            X509Extension(b'basicConstraints', True, b'CA:true'),
+            X509Extension(b'keyUsage', False, b'digitalSignature')])
         exts = request.get_extensions()
         self.assertEqual(len(exts), 2)
-        self.assertEqual(exts[0].get_short_name(), b('basicConstraints'))
+        self.assertEqual(exts[0].get_short_name(), b'basicConstraints')
         self.assertEqual(exts[0].get_critical(), 1)
-        self.assertEqual(exts[0].get_data(), b('0\x03\x01\x01\xff'))
-        self.assertEqual(exts[1].get_short_name(), b('keyUsage'))
+        self.assertEqual(exts[0].get_data(), b'0\x03\x01\x01\xff')
+        self.assertEqual(exts[1].get_short_name(), b'keyUsage')
         self.assertEqual(exts[1].get_critical(), 0)
-        self.assertEqual(exts[1].get_data(), b('\x03\x02\x07\x80'))
+        self.assertEqual(exts[1].get_data(), b'\x03\x02\x07\x80')
 
     def test_add_extensions_wrong_args(self):
         """
@@ -1572,28 +1572,28 @@
         self.assertEqual(get(), None)
 
         # GMT (Or is it UTC?) -exarkun
-        when = b("20040203040506Z")
+        when = b"20040203040506Z"
         set(when)
         self.assertEqual(get(), when)
 
         # A plus two hours and thirty minutes offset
-        when = b("20040203040506+0530")
+        when = b"20040203040506+0530"
         set(when)
         self.assertEqual(get(), when)
 
         # A minus one hour fifteen minutes offset
-        when = b("20040203040506-0115")
+        when = b"20040203040506-0115"
         set(when)
         self.assertEqual(get(), when)
 
         # An invalid string results in a ValueError
-        self.assertRaises(ValueError, set, b("foo bar"))
+        self.assertRaises(ValueError, set, b"foo bar")
 
         # The wrong number of arguments results in a TypeError.
         self.assertRaises(TypeError, set)
         with pytest.raises(TypeError):
             set(b"20040203040506Z", b"20040203040506Z")
-        self.assertRaises(TypeError, get, b("foo bar"))
+        self.assertRaises(TypeError, get, b"foo bar")
 
     # XXX ASN1_TIME (not GENERALIZEDTIME)
 
@@ -1620,7 +1620,7 @@
         internally.
         """
         cert = load_certificate(FILETYPE_PEM, self.pemData)
-        self.assertEqual(cert.get_notBefore(), b("20090325123658Z"))
+        self.assertEqual(cert.get_notBefore(), b"20090325123658Z")
 
     def test_get_notAfter(self):
         """
@@ -1629,7 +1629,7 @@
         internally.
         """
         cert = load_certificate(FILETYPE_PEM, self.pemData)
-        self.assertEqual(cert.get_notAfter(), b("20170611123658Z"))
+        self.assertEqual(cert.get_notAfter(), b"20170611123658Z")
 
     def test_gmtime_adj_notBefore_wrong_args(self):
         """
@@ -1732,14 +1732,14 @@
             # Digest verified with the command:
             # openssl x509 -in root_cert.pem -noout -fingerprint -md5
             cert.digest("MD5"),
-            b("19:B3:05:26:2B:F8:F2:FF:0B:8F:21:07:A8:28:B8:75"))
+            b"19:B3:05:26:2B:F8:F2:FF:0B:8F:21:07:A8:28:B8:75")
 
     def _extcert(self, pkey, extensions):
         cert = X509()
         cert.set_pubkey(pkey)
         cert.get_subject().commonName = "Unit Tests"
         cert.get_issuer().commonName = "Unit Tests"
-        when = b(datetime.now().strftime("%Y%m%d%H%M%SZ"))
+        when = datetime.now().strftime("%Y%m%d%H%M%SZ").encode("ascii")
         cert.set_notBefore(when)
         cert.set_notAfter(when)
 
@@ -1754,10 +1754,10 @@
         that are present in the certificate.
         """
         pkey = load_privatekey(FILETYPE_PEM, client_key_pem)
-        ca = X509Extension(b('basicConstraints'), True, b('CA:FALSE'))
-        key = X509Extension(b('keyUsage'), True, b('digitalSignature'))
+        ca = X509Extension(b'basicConstraints', True, b'CA:FALSE')
+        key = X509Extension(b'keyUsage', True, b'digitalSignature')
         subjectAltName = X509Extension(
-            b('subjectAltName'), True, b('DNS:example.com'))
+            b'subjectAltName', True, b'DNS:example.com')
 
         # Try a certificate with no extensions at all.
         c = self._extcert(pkey, [])
@@ -1777,27 +1777,27 @@
         :py:obj:`X509Extension` corresponding to the extension at that index.
         """
         pkey = load_privatekey(FILETYPE_PEM, client_key_pem)
-        ca = X509Extension(b('basicConstraints'), True, b('CA:FALSE'))
-        key = X509Extension(b('keyUsage'), True, b('digitalSignature'))
+        ca = X509Extension(b'basicConstraints', True, b'CA:FALSE')
+        key = X509Extension(b'keyUsage', True, b'digitalSignature')
         subjectAltName = X509Extension(
-            b('subjectAltName'), False, b('DNS:example.com'))
+            b'subjectAltName', False, b'DNS:example.com')
 
         cert = self._extcert(pkey, [ca, key, subjectAltName])
 
         ext = cert.get_extension(0)
         self.assertTrue(isinstance(ext, X509Extension))
         self.assertTrue(ext.get_critical())
-        self.assertEqual(ext.get_short_name(), b('basicConstraints'))
+        self.assertEqual(ext.get_short_name(), b'basicConstraints')
 
         ext = cert.get_extension(1)
         self.assertTrue(isinstance(ext, X509Extension))
         self.assertTrue(ext.get_critical())
-        self.assertEqual(ext.get_short_name(), b('keyUsage'))
+        self.assertEqual(ext.get_short_name(), b'keyUsage')
 
         ext = cert.get_extension(2)
         self.assertTrue(isinstance(ext, X509Extension))
         self.assertFalse(ext.get_critical())
-        self.assertEqual(ext.get_short_name(), b('subjectAltName'))
+        self.assertEqual(ext.get_short_name(), b'subjectAltName')
 
         self.assertRaises(IndexError, cert.get_extension, -1)
         self.assertRaises(IndexError, cert.get_extension, 4)
@@ -1812,13 +1812,13 @@
         cert = load_certificate(FILETYPE_PEM, nulbyteSubjectAltNamePEM)
 
         ext = cert.get_extension(3)
-        self.assertEqual(ext.get_short_name(), b('subjectAltName'))
+        self.assertEqual(ext.get_short_name(), b'subjectAltName')
         self.assertEqual(
-            b("DNS:altnull.python.org\x00example.com, "
-              "email:null@python.org\x00user@example.org, "
-              "URI:http://null.python.org\x00http://example.org, "
-              "IP Address:192.0.2.1, IP Address:2001:DB8:0:0:0:0:0:1\n"),
-            b(str(ext)))
+            b"DNS:altnull.python.org\x00example.com, "
+            b"email:null@python.org\x00user@example.org, "
+            b"URI:http://null.python.org\x00http://example.org, "
+            b"IP Address:192.0.2.1, IP Address:2001:DB8:0:0:0:0:0:1\n",
+            str(ext).encode("ascii"))
 
     def test_invalid_digest_algorithm(self):
         """
@@ -1845,8 +1845,8 @@
         self.assertTrue(isinstance(subj, X509Name))
         self.assertEquals(
             subj.get_components(),
-            [(b('C'), b('US')), (b('ST'), b('IL')), (b('L'), b('Chicago')),
-             (b('O'), b('Testing')), (b('CN'), b('Testing Root CA'))])
+            [(b'C', b'US'), (b'ST', b'IL'), (b'L', b'Chicago'),
+             (b'O', b'Testing'), (b'CN', b'Testing Root CA')])
 
     def test_set_subject_wrong_args(self):
         """
@@ -1872,7 +1872,7 @@
         cert.set_subject(name)
         self.assertEquals(
             cert.get_subject().get_components(),
-            [(b('C'), b('AU')), (b('O'), b('Unit Tests'))])
+            [(b'C', b'AU'), (b'O', b'Unit Tests')])
 
     def test_get_issuer_wrong_args(self):
         """
@@ -1892,8 +1892,8 @@
         comp = subj.get_components()
         self.assertEquals(
             comp,
-            [(b('C'), b('US')), (b('ST'), b('IL')), (b('L'), b('Chicago')),
-             (b('O'), b('Testing')), (b('CN'), b('Testing Root CA'))])
+            [(b'C', b'US'), (b'ST', b'IL'), (b'L', b'Chicago'),
+             (b'O', b'Testing'), (b'CN', b'Testing Root CA')])
 
     def test_set_issuer_wrong_args(self):
         """
@@ -1918,7 +1918,7 @@
         cert.set_issuer(name)
         self.assertEquals(
             cert.get_issuer().get_components(),
-            [(b('C'), b('AU')), (b('O'), b('Unit Tests'))])
+            [(b'C', b'AU'), (b'O', b'Unit Tests')])
 
     def test_get_pubkey_uninitialized(self):
         """
@@ -1964,7 +1964,7 @@
         """
         cert = load_certificate(FILETYPE_PEM, self.pemData)
         self.assertEqual(
-            b("sha1WithRSAEncryption"), cert.get_signature_algorithm())
+            b"sha1WithRSAEncryption", cert.get_signature_algorithm())
 
     def test_get_undefined_signature_algorithm(self):
         """
@@ -1973,7 +1973,7 @@
         """
         # This certificate has been modified to indicate a bogus OID in the
         # signature algorithm field so that OpenSSL does not recognize it.
-        certPEM = b("""\
+        certPEM = b"""\
 -----BEGIN CERTIFICATE-----
 MIIC/zCCAmigAwIBAgIBATAGBgJ8BQUAMHsxCzAJBgNVBAYTAlNHMREwDwYDVQQK
 EwhNMkNyeXB0bzEUMBIGA1UECxMLTTJDcnlwdG8gQ0ExJDAiBgNVBAMTG00yQ3J5
@@ -1993,7 +1993,7 @@
 PEVk0Mk/V0aIsDE9bolfCi/i/QWZ3N8s5nTWMNyBBBmoSliWCm4jkkRZRD0ejgTN
 tgI5
 -----END CERTIFICATE-----
-""")
+"""
         cert = load_certificate(FILETYPE_PEM, certPEM)
         self.assertRaises(ValueError, cert.get_signature_algorithm)
 
@@ -2347,7 +2347,7 @@
         """
         passwd = b'Dogmeat[]{}!@#$%^&*()~`?/.,<>-_+=";:'
         p12 = self.gen_pkcs12(server_cert_pem, server_key_pem, root_cert_pem)
-        for friendly_name in [b('Serverlicious'), None, b('###')]:
+        for friendly_name in [b'Serverlicious', None, b'###']:
             p12.set_friendlyname(friendly_name)
             self.assertEqual(p12.get_friendlyname(), friendly_name)
             dumped_p12 = p12.export(passphrase=passwd, iter=2, maciter=3)
@@ -2609,7 +2609,7 @@
         """
         self.assertRaises(
             Error,
-            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, b("quack"))
+            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, b"quack")
 
     def test_load_privatekey_passphraseWrongType(self):
         """
@@ -2653,7 +2653,7 @@
 
         def cb(*a):
             called.append(None)
-            return b("quack")
+            return b"quack"
         self.assertRaises(
             Error,
             load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, cb)
@@ -2742,7 +2742,7 @@
         :py:obj:`dump_privatekey` writes an encrypted PEM when given a
         passphrase.
         """
-        passphrase = b("foo")
+        passphrase = b"foo"
         key = load_privatekey(FILETYPE_PEM, cleartextPrivateKeyPEM)
         pem = dump_privatekey(FILETYPE_PEM, key, GOOD_CIPHER, passphrase)
         self.assertTrue(isinstance(pem, binary_type))
@@ -2876,7 +2876,7 @@
         :py:obj:`dump_privatekey` writes an encrypted PEM when given a callback
         which returns the correct passphrase.
         """
-        passphrase = b("foo")
+        passphrase = b"foo"
         called = []
 
         def cb(writing):
@@ -3068,7 +3068,7 @@
         type name.
         """
         pkcs7 = load_pkcs7_data(FILETYPE_PEM, pkcs7Data)
-        self.assertEquals(pkcs7.get_type_name(), b('pkcs7-signedData'))
+        self.assertEquals(pkcs7.get_type_name(), b'pkcs7-signedData')
 
     def test_attribute(self):
         """
@@ -3163,7 +3163,7 @@
         revoked = Revoked()
         self.assertTrue(isinstance(revoked, Revoked))
         self.assertEquals(type(revoked), Revoked)
-        self.assertEquals(revoked.get_serial(), b('00'))
+        self.assertEquals(revoked.get_serial(), b'00')
         self.assertEquals(revoked.get_rev_date(), None)
         self.assertEquals(revoked.get_reason(), None)
 
@@ -3183,16 +3183,16 @@
         with grace.
         """
         revoked = Revoked()
-        ret = revoked.set_serial(b('10b'))
+        ret = revoked.set_serial(b'10b')
         self.assertEquals(ret, None)
         ser = revoked.get_serial()
-        self.assertEquals(ser, b('010B'))
+        self.assertEquals(ser, b'010B')
 
-        revoked.set_serial(b('31ppp'))  # a type error would be nice
+        revoked.set_serial(b'31ppp')  # a type error would be nice
         ser = revoked.get_serial()
-        self.assertEquals(ser, b('31'))
+        self.assertEquals(ser, b'31')
 
-        self.assertRaises(ValueError, revoked.set_serial, b('pqrst'))
+        self.assertRaises(ValueError, revoked.set_serial, b'pqrst')
         self.assertRaises(TypeError, revoked.set_serial, 100)
         self.assertRaises(TypeError, revoked.get_serial, 1)
         self.assertRaises(TypeError, revoked.get_serial, None)
@@ -3208,7 +3208,7 @@
         date = revoked.get_rev_date()
         self.assertEquals(date, None)
 
-        now = b(datetime.now().strftime("%Y%m%d%H%M%SZ"))
+        now = datetime.now().strftime("%Y%m%d%H%M%SZ").encode("ascii")
         ret = revoked.set_rev_date(now)
         self.assertEqual(ret, None)
         date = revoked.get_rev_date()
@@ -3227,8 +3227,8 @@
                 self.assertEquals(ret, None)
                 reason = revoked.get_reason()
                 self.assertEquals(
-                    reason.lower().replace(b(' '), b('')),
-                    r.lower().replace(b(' '), b('')))
+                    reason.lower().replace(b' ', b''),
+                    r.lower().replace(b' ', b''))
                 r = reason  # again with the resp of get
 
         revoked.set_reason(None)
@@ -3242,7 +3242,7 @@
         """
         revoked = Revoked()
         self.assertRaises(TypeError, revoked.set_reason, 100)
-        self.assertRaises(ValueError, revoked.set_reason, b('blue'))
+        self.assertRaises(ValueError, revoked.set_reason, b'blue')
 
     def test_get_reason_wrong_arguments(self):
         """
@@ -3295,10 +3295,10 @@
         """
         crl = CRL()
         revoked = Revoked()
-        now = b(datetime.now().strftime("%Y%m%d%H%M%SZ"))
+        now = datetime.now().strftime("%Y%m%d%H%M%SZ").encode("ascii")
         revoked.set_rev_date(now)
-        revoked.set_serial(b('3ab'))
-        revoked.set_reason(b('sUpErSeDEd'))
+        revoked.set_serial(b'3ab')
+        revoked.set_reason(b'sUpErSeDEd')
         crl.add_revoked(revoked)
         return crl
 
@@ -3315,10 +3315,10 @@
 
         # These magic values are based on the way the CRL above was constructed
         # and with what certificate it was exported.
-        text.index(b('Serial Number: 03AB'))
-        text.index(b('Superseded'))
+        text.index(b'Serial Number: 03AB')
+        text.index(b'Superseded')
         text.index(
-            b('Issuer: /C=US/ST=IL/L=Chicago/O=Testing/CN=Testing Root CA')
+            b'Issuer: /C=US/ST=IL/L=Chicago/O=Testing/CN=Testing Root CA'
         )
 
     def test_export_der(self):
@@ -3334,10 +3334,10 @@
         text = _runopenssl(
             dumped_crl, b"crl", b"-noout", b"-text", b"-inform", b"DER"
         )
-        text.index(b('Serial Number: 03AB'))
-        text.index(b('Superseded'))
+        text.index(b'Serial Number: 03AB')
+        text.index(b'Superseded')
         text.index(
-            b('Issuer: /C=US/ST=IL/L=Chicago/O=Testing/CN=Testing Root CA')
+            b'Issuer: /C=US/ST=IL/L=Chicago/O=Testing/CN=Testing Root CA'
         )
 
     def test_export_text(self):
@@ -3365,7 +3365,7 @@
         crl = self._get_crl()
         dumped_crl = crl.export(self.cert, self.pkey, digest=b"sha1")
         text = _runopenssl(dumped_crl, b"crl", b"-noout", b"-text")
-        text.index(b('Signature Algorithm: sha1'))
+        text.index(b'Signature Algorithm: sha1')
 
     def test_export_md5_digest(self):
         """
@@ -3378,7 +3378,7 @@
             self.assertEqual(0, len(catcher))
         dumped_crl = crl.export(self.cert, self.pkey, digest=b"md5")
         text = _runopenssl(dumped_crl, b"crl", b"-noout", b"-text")
-        text.index(b('Signature Algorithm: md5'))
+        text.index(b'Signature Algorithm: md5')
 
     def test_export_default_digest(self):
         """
@@ -3395,7 +3395,7 @@
                 str(catcher[0].message),
             )
         text = _runopenssl(dumped_crl, b"crl", b"-noout", b"-text")
-        text.index(b('Signature Algorithm: md5'))
+        text.index(b'Signature Algorithm: md5')
 
     def test_export_invalid(self):
         """
@@ -3468,20 +3468,20 @@
         crl = CRL()
 
         revoked = Revoked()
-        now = b(datetime.now().strftime("%Y%m%d%H%M%SZ"))
+        now = datetime.now().strftime("%Y%m%d%H%M%SZ").encode("ascii")
         revoked.set_rev_date(now)
-        revoked.set_serial(b('3ab'))
+        revoked.set_serial(b'3ab')
         crl.add_revoked(revoked)
-        revoked.set_serial(b('100'))
-        revoked.set_reason(b('sUpErSeDEd'))
+        revoked.set_serial(b'100')
+        revoked.set_reason(b'sUpErSeDEd')
         crl.add_revoked(revoked)
 
         revs = crl.get_revoked()
         self.assertEqual(len(revs), 2)
         self.assertEqual(type(revs[0]), Revoked)
         self.assertEqual(type(revs[1]), Revoked)
-        self.assertEqual(revs[0].get_serial(), b('03AB'))
-        self.assertEqual(revs[1].get_serial(), b('0100'))
+        self.assertEqual(revs[0].get_serial(), b'03AB')
+        self.assertEqual(revs[1].get_serial(), b'0100')
         self.assertEqual(revs[0].get_rev_date(), now)
         self.assertEqual(revs[1].get_rev_date(), now)
 
@@ -3514,19 +3514,19 @@
         crl = load_crl(FILETYPE_PEM, crlData)
         revs = crl.get_revoked()
         self.assertEqual(len(revs), 2)
-        self.assertEqual(revs[0].get_serial(), b('03AB'))
+        self.assertEqual(revs[0].get_serial(), b'03AB')
         self.assertEqual(revs[0].get_reason(), None)
-        self.assertEqual(revs[1].get_serial(), b('0100'))
-        self.assertEqual(revs[1].get_reason(), b('Superseded'))
+        self.assertEqual(revs[1].get_serial(), b'0100')
+        self.assertEqual(revs[1].get_reason(), b'Superseded')
 
         der = _runopenssl(crlData, b"crl", b"-outform", b"DER")
         crl = load_crl(FILETYPE_ASN1, der)
         revs = crl.get_revoked()
         self.assertEqual(len(revs), 2)
-        self.assertEqual(revs[0].get_serial(), b('03AB'))
+        self.assertEqual(revs[0].get_serial(), b'03AB')
         self.assertEqual(revs[0].get_reason(), None)
-        self.assertEqual(revs[1].get_serial(), b('0100'))
-        self.assertEqual(revs[1].get_reason(), b('Superseded'))
+        self.assertEqual(revs[1].get_serial(), b'0100')
+        self.assertEqual(revs[1].get_reason(), b'Superseded')
 
     def test_load_crl_wrong_args(self):
         """
@@ -3752,12 +3752,12 @@
         :py:obj:`sign` generates a cryptographic signature which
         :py:obj:`verify` can check.
         """
-        content = b(
-            "It was a bright cold day in April, and the clocks were striking "
-            "thirteen. Winston Smith, his chin nuzzled into his breast in an "
-            "effort to escape the vile wind, slipped quickly through the "
-            "glass doors of Victory Mansions, though not quickly enough to "
-            "prevent a swirl of gritty dust from entering along with him.")
+        content = (
+            b"It was a bright cold day in April, and the clocks were striking "
+            b"thirteen. Winston Smith, his chin nuzzled into his breast in an "
+            b"effort to escape the vile wind, slipped quickly through the "
+            b"glass doors of Victory Mansions, though not quickly enough to "
+            b"prevent a swirl of gritty dust from entering along with him.")
 
         # sign the content with this private key
         priv_key = load_privatekey(FILETYPE_PEM, root_key_pem)
@@ -3781,7 +3781,7 @@
             # signing it.
             self.assertRaises(
                 Error, verify,
-                good_cert, sig, content + b("tainted"), digest)
+                good_cert, sig, content + b"tainted", digest)
 
         # test that unknown digest types fail
         self.assertRaises(
@@ -3834,7 +3834,7 @@
         """
         :py:obj:`sign` produces a signature for a string with embedded nulls.
         """
-        content = b("Watch out!  \0  Did you see it?")
+        content = b"Watch out!  \0  Did you see it?"
         priv_key = load_privatekey(FILETYPE_PEM, root_key_pem)
         good_cert = load_certificate(FILETYPE_PEM, root_cert_pem)
         sig = sign(priv_key, content, "sha1")
@@ -3844,12 +3844,12 @@
         """
         :py:obj:`sign` produces a signature for a string when using a long key.
         """
-        content = b(
-            "It was a bright cold day in April, and the clocks were striking "
-            "thirteen. Winston Smith, his chin nuzzled into his breast in an "
-            "effort to escape the vile wind, slipped quickly through the "
-            "glass doors of Victory Mansions, though not quickly enough to "
-            "prevent a swirl of gritty dust from entering along with him.")
+        content = (
+            b"It was a bright cold day in April, and the clocks were striking "
+            b"thirteen. Winston Smith, his chin nuzzled into his breast in an "
+            b"effort to escape the vile wind, slipped quickly through the "
+            b"glass doors of Victory Mansions, though not quickly enough to "
+            b"prevent a swirl of gritty dust from entering along with him.")
 
         priv_key = load_privatekey(FILETYPE_PEM, large_key_pem)
         sign(priv_key, content, "sha1")
@@ -3892,7 +3892,7 @@
             curve = next(iter(curves))
             self.assertEqual(curve.name, get_elliptic_curve(curve.name).name)
         else:
-            self.assertRaises(ValueError, get_elliptic_curve, u("prime256v1"))
+            self.assertRaises(ValueError, get_elliptic_curve, u"prime256v1")
 
     def test_not_a_curve(self):
         """
@@ -3900,7 +3900,7 @@
         with a name which does not identify a supported curve.
         """
         self.assertRaises(
-            ValueError, get_elliptic_curve, u("this curve was just invented"))
+            ValueError, get_elliptic_curve, u"this curve was just invented")
 
     def test_repr(self):
         """
diff --git a/tests/test_rand.py b/tests/test_rand.py
index ece0935..0350e9e 100644
--- a/tests/test_rand.py
+++ b/tests/test_rand.py
@@ -13,7 +13,7 @@
 
 from OpenSSL import rand
 
-from .util import NON_ASCII, TestCase, b
+from .util import NON_ASCII, TestCase
 
 
 class RandTests(TestCase):
@@ -55,15 +55,15 @@
         raises :py:obj:`TypeError`.
         """
         self.assertRaises(TypeError, rand.add)
-        self.assertRaises(TypeError, rand.add, b("foo"), None)
+        self.assertRaises(TypeError, rand.add, b"foo", None)
         self.assertRaises(TypeError, rand.add, None, 3)
-        self.assertRaises(TypeError, rand.add, b("foo"), 3, None)
+        self.assertRaises(TypeError, rand.add, b"foo", 3, None)
 
     def test_add(self):
         """
         :py:obj:`OpenSSL.rand.add` adds entropy to the PRNG.
         """
-        rand.add(b('hamburger'), 3)
+        rand.add(b'hamburger', 3)
 
     def test_seed_wrong_args(self):
         """
@@ -73,13 +73,13 @@
         """
         self.assertRaises(TypeError, rand.seed)
         self.assertRaises(TypeError, rand.seed, None)
-        self.assertRaises(TypeError, rand.seed, b("foo"), None)
+        self.assertRaises(TypeError, rand.seed, b"foo", None)
 
     def test_seed(self):
         """
         :py:obj:`OpenSSL.rand.seed` adds entropy to the PRNG.
         """
-        rand.seed(b('milk shake'))
+        rand.seed(b'milk shake')
 
     def test_status_wrong_args(self):
         """
diff --git a/tests/test_ssl.py b/tests/test_ssl.py
index ac57280..a2aad55 100644
--- a/tests/test_ssl.py
+++ b/tests/test_ssl.py
@@ -75,7 +75,7 @@
     SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP, SSL_CB_CONNECT_EXIT,
     SSL_CB_HANDSHAKE_START, SSL_CB_HANDSHAKE_DONE)
 
-from .util import WARNING_TYPE_EXPECTED, NON_ASCII, TestCase, b
+from .util import WARNING_TYPE_EXPECTED, NON_ASCII, TestCase
 from .test_crypto import (
     cleartextCertificatePEM, cleartextPrivateKeyPEM,
     client_cert_pem, client_key_pem, server_cert_pem, server_key_pem,
@@ -138,10 +138,10 @@
     # Let's pass some unencrypted data to make sure our socket connection is
     # fine.  Just one byte, so we don't have to worry about buffers getting
     # filled up or fragmentation.
-    server.send(b("x"))
-    assert client.recv(1024) == b("x")
-    client.send(b("y"))
-    assert server.recv(1024) == b("y")
+    server.send(b"x")
+    assert client.recv(1024) == b"x"
+    client.send(b"y")
+    assert server.recv(1024) == b"y"
 
     # Most of our callers want non-blocking sockets, make it easy for them.
     server.setblocking(False)
@@ -170,7 +170,7 @@
         2. A new intermediate certificate signed by cacert (icert)
         3. A new server certificate signed by icert (scert)
     """
-    caext = X509Extension(b('basicConstraints'), False, b('CA:true'))
+    caext = X509Extension(b'basicConstraints', False, b'CA:true')
 
     # Step 1
     cakey = PKey()
@@ -179,8 +179,8 @@
     cacert.get_subject().commonName = "Authority Certificate"
     cacert.set_issuer(cacert.get_subject())
     cacert.set_pubkey(cakey)
-    cacert.set_notBefore(b("20000101000000Z"))
-    cacert.set_notAfter(b("20200101000000Z"))
+    cacert.set_notBefore(b"20000101000000Z")
+    cacert.set_notAfter(b"20200101000000Z")
     cacert.add_extensions([caext])
     cacert.set_serial_number(0)
     cacert.sign(cakey, "sha1")
@@ -192,8 +192,8 @@
     icert.get_subject().commonName = "Intermediate Certificate"
     icert.set_issuer(cacert.get_subject())
     icert.set_pubkey(ikey)
-    icert.set_notBefore(b("20000101000000Z"))
-    icert.set_notAfter(b("20200101000000Z"))
+    icert.set_notBefore(b"20000101000000Z")
+    icert.set_notAfter(b"20200101000000Z")
     icert.add_extensions([caext])
     icert.set_serial_number(0)
     icert.sign(cakey, "sha1")
@@ -205,10 +205,10 @@
     scert.get_subject().commonName = "Server Certificate"
     scert.set_issuer(icert.get_subject())
     scert.set_pubkey(skey)
-    scert.set_notBefore(b("20000101000000Z"))
-    scert.set_notAfter(b("20200101000000Z"))
+    scert.set_notBefore(b"20000101000000Z")
+    scert.set_notAfter(b"20200101000000Z")
     scert.add_extensions([
-        X509Extension(b('basicConstraints'), True, b('CA:false'))])
+        X509Extension(b'basicConstraints', True, b'CA:false')])
     scert.set_serial_number(0)
     scert.sign(ikey, "sha1")
 
@@ -925,7 +925,7 @@
         :py:obj:`Context.set_passwd_cb` accepts a callable which will be
         invoked when a private key is loaded from an encrypted PEM.
         """
-        passphrase = b("foobar")
+        passphrase = b"foobar"
         pemFile = self._write_encrypted_pem(passphrase)
         calledWith = []
 
@@ -945,7 +945,7 @@
         :py:obj:`Context.use_privatekey_file` propagates any exception raised
         by the passphrase callback.
         """
-        pemFile = self._write_encrypted_pem(b("monkeys are nice"))
+        pemFile = self._write_encrypted_pem(b"monkeys are nice")
 
         def passphraseCallback(maxlen, verify, extra):
             raise RuntimeError("Sorry, I am a fail.")
@@ -960,7 +960,7 @@
         :py:obj:`OpenSSL.SSL.Error` if the passphrase callback returns a false
         value.
         """
-        pemFile = self._write_encrypted_pem(b("monkeys are nice"))
+        pemFile = self._write_encrypted_pem(b"monkeys are nice")
 
         def passphraseCallback(maxlen, verify, extra):
             return b""
@@ -975,7 +975,7 @@
         :py:obj:`OpenSSL.SSL.Error` if the passphrase callback returns a true
         non-string value.
         """
-        pemFile = self._write_encrypted_pem(b("monkeys are nice"))
+        pemFile = self._write_encrypted_pem(b"monkeys are nice")
 
         def passphraseCallback(maxlen, verify, extra):
             return 10
@@ -990,12 +990,12 @@
         longer than the indicated maximum length, it is truncated.
         """
         # A priori knowledge!
-        passphrase = b("x") * 1024
+        passphrase = b"x" * 1024
         pemFile = self._write_encrypted_pem(passphrase)
 
         def passphraseCallback(maxlen, verify, extra):
             assert maxlen == 1024
-            return passphrase + b("y")
+            return passphrase + b"y"
 
         context = Context(TLSv1_METHOD)
         context.set_passwd_cb(passphraseCallback)
@@ -1680,11 +1680,11 @@
 
         client = Connection(Context(TLSv1_METHOD), None)
         client.set_connect_state()
-        client.set_tlsext_host_name(b("foo1.example.com"))
+        client.set_tlsext_host_name(b"foo1.example.com")
 
         self._interactInMemory(server, client)
 
-        self.assertEqual([(server, b("foo1.example.com"))], args)
+        self.assertEqual([(server, b"foo1.example.com")], args)
 
 
 class NextProtoNegotiationTests(TestCase, _LoopbackMixin):
@@ -2194,13 +2194,13 @@
         self.assertRaises(TypeError, conn.set_tlsext_host_name, object())
         self.assertRaises(TypeError, conn.set_tlsext_host_name, 123, 456)
         self.assertRaises(
-            TypeError, conn.set_tlsext_host_name, b("with\0null"))
+            TypeError, conn.set_tlsext_host_name, b"with\0null")
 
         if PY3:
             # On Python 3.x, don't accidentally implicitly convert from text.
             self.assertRaises(
                 TypeError,
-                conn.set_tlsext_host_name, b("example.com").decode("ascii"))
+                conn.set_tlsext_host_name, b"example.com".decode("ascii"))
 
     def test_get_servername_wrong_args(self):
         """
@@ -2234,10 +2234,10 @@
         :py:obj:`socket.MSG_PEEK` is passed.
         """
         server, client = self._loopback()
-        server.send(b('xy'))
-        self.assertEqual(client.recv(2, MSG_PEEK), b('xy'))
-        self.assertEqual(client.recv(2, MSG_PEEK), b('xy'))
-        self.assertEqual(client.recv(2), b('xy'))
+        server.send(b'xy')
+        self.assertEqual(client.recv(2, MSG_PEEK), b'xy')
+        self.assertEqual(client.recv(2, MSG_PEEK), b'xy')
+        self.assertEqual(client.recv(2), b'xy')
 
     def test_connect_wrong_args(self):
         """
@@ -2892,9 +2892,9 @@
         all of it and returns the number of bytes sent.
         """
         server, client = self._loopback()
-        count = server.send(b('xy'))
+        count = server.send(b'xy')
         self.assertEquals(count, 2)
-        self.assertEquals(client.recv(2), b('xy'))
+        self.assertEquals(client.recv(2), b'xy')
 
     def test_text(self):
         """
@@ -2923,9 +2923,9 @@
         of bytes sent.
         """
         server, client = self._loopback()
-        count = server.send(memoryview(b('xy')))
+        count = server.send(memoryview(b'xy'))
         self.assertEquals(count, 2)
-        self.assertEquals(client.recv(2), b('xy'))
+        self.assertEquals(client.recv(2), b'xy')
 
     @skip_if_py3
     def test_short_buffer(self):
@@ -2935,9 +2935,9 @@
         of bytes sent.
         """
         server, client = self._loopback()
-        count = server.send(buffer(b('xy')))
+        count = server.send(buffer(b'xy'))
         self.assertEquals(count, 2)
-        self.assertEquals(client.recv(2), b('xy'))
+        self.assertEquals(client.recv(2), b'xy')
 
 
 def _make_memoryview(size):
@@ -2961,10 +2961,10 @@
         output_buffer = factory(5)
 
         server, client = self._loopback()
-        server.send(b('xy'))
+        server.send(b'xy')
 
         self.assertEqual(client.recv_into(output_buffer), 2)
-        self.assertEqual(output_buffer, bytearray(b('xy\x00\x00\x00')))
+        self.assertEqual(output_buffer, bytearray(b'xy\x00\x00\x00'))
 
     def test_bytearray_no_length(self):
         """
@@ -2982,11 +2982,11 @@
         output_buffer = factory(10)
 
         server, client = self._loopback()
-        server.send(b('abcdefghij'))
+        server.send(b'abcdefghij')
 
         self.assertEqual(client.recv_into(output_buffer, 5), 5)
         self.assertEqual(
-            output_buffer, bytearray(b('abcde\x00\x00\x00\x00\x00'))
+            output_buffer, bytearray(b'abcde\x00\x00\x00\x00\x00')
         )
 
     def test_bytearray_respects_length(self):
@@ -3007,12 +3007,12 @@
         output_buffer = factory(5)
 
         server, client = self._loopback()
-        server.send(b('abcdefghij'))
+        server.send(b'abcdefghij')
 
         self.assertEqual(client.recv_into(output_buffer), 5)
-        self.assertEqual(output_buffer, bytearray(b('abcde')))
+        self.assertEqual(output_buffer, bytearray(b'abcde'))
         rest = client.recv(5)
-        self.assertEqual(b('fghij'), rest)
+        self.assertEqual(b'fghij', rest)
 
     def test_bytearray_doesnt_overfill(self):
         """
@@ -3034,13 +3034,13 @@
     def test_peek(self):
 
         server, client = self._loopback()
-        server.send(b('xy'))
+        server.send(b'xy')
 
         for _ in range(2):
             output_buffer = bytearray(5)
             self.assertEqual(
                 client.recv_into(output_buffer, flags=MSG_PEEK), 2)
-            self.assertEqual(output_buffer, bytearray(b('xy\x00\x00\x00')))
+            self.assertEqual(output_buffer, bytearray(b'xy\x00\x00\x00'))
 
     @skip_if_py26
     def test_memoryview_no_length(self):
@@ -3101,8 +3101,8 @@
         passed to it.
         """
         server, client = self._loopback()
-        server.sendall(b('x'))
-        self.assertEquals(client.recv(1), b('x'))
+        server.sendall(b'x')
+        self.assertEquals(client.recv(1), b'x')
 
     def test_text(self):
         """
@@ -3129,8 +3129,8 @@
         :py:obj:`Connection.sendall` transmits all of them.
         """
         server, client = self._loopback()
-        server.sendall(memoryview(b('x')))
-        self.assertEquals(client.recv(1), b('x'))
+        server.sendall(memoryview(b'x'))
+        self.assertEquals(client.recv(1), b'x')
 
     @skip_if_py3
     def test_short_buffers(self):
@@ -3139,8 +3139,8 @@
         :py:obj:`Connection.sendall` transmits all of them.
         """
         server, client = self._loopback()
-        server.sendall(buffer(b('x')))
-        self.assertEquals(client.recv(1), b('x'))
+        server.sendall(buffer(b'x'))
+        self.assertEquals(client.recv(1), b'x')
 
     def test_long(self):
         """
@@ -3152,7 +3152,7 @@
         # Should be enough, underlying SSL_write should only do 16k at a time.
         # On Windows, after 32k of bytes the write will block (forever
         # - because no one is yet reading).
-        message = b('x') * (1024 * 32 - 1) + b('y')
+        message = b'x' * (1024 * 32 - 1) + b'y'
         server.sendall(message)
         accum = []
         received = 0
@@ -3160,7 +3160,7 @@
             data = client.recv(1024)
             accum.append(data)
             received += len(data)
-        self.assertEquals(message, b('').join(accum))
+        self.assertEquals(message, b''.join(accum))
 
     def test_closed(self):
         """
@@ -3449,7 +3449,7 @@
             client_conn.client_random(), client_conn.server_random())
 
         # Here are the bytes we'll try to send.
-        important_message = b('One if by land, two if by sea.')
+        important_message = b'One if by land, two if by sea.'
 
         server_conn.write(important_message)
         self.assertEquals(
@@ -3473,7 +3473,7 @@
         """
         server_conn, client_conn = self._loopback()
 
-        important_message = b("Help me Obi Wan Kenobi, you're my only hope.")
+        important_message = b"Help me Obi Wan Kenobi, you're my only hope."
         client_conn.send(important_message)
         msg = server_conn.recv(1024)
         self.assertEqual(msg, important_message)
diff --git a/tests/util.py b/tests/util.py
index 56d7154..2cab91f 100644
--- a/tests/util.py
+++ b/tests/util.py
@@ -24,11 +24,11 @@
 
 from . import memdbg
 
-from OpenSSL._util import ffi, lib, byte_string as b
+from OpenSSL._util import ffi, lib
 
 
 # This is the UTF-8 encoding of the SNOWMAN unicode code point.
-NON_ASCII = b("\xe2\x98\x83").decode("utf-8")
+NON_ASCII = b"\xe2\x98\x83".decode("utf-8")
 
 
 class TestCase(TestCase):