Merge pull request #2370 from reaperhulk/asserts-begone-2

convert the rest of the openssl backend to using openssl_assert

1 files changed, 33 insertions, 29 deletions

diff --git a/src/cryptography/hazmat/backends/openssl/rsa.py b/src/cryptography/hazmat/backends/openssl/rsa.py
index 7da42292..664f6d35 100644
--- a/src/cryptography/hazmat/backends/openssl/rsa.py
+++ b/src/cryptography/hazmat/backends/openssl/rsa.py
@@ -89,15 +89,15 @@ def _enc_dec_rsa_pkey_ctx(backend, key, data, padding_enum):
     pkey_ctx = backend._lib.EVP_PKEY_CTX_new(
         key._evp_pkey, backend._ffi.NULL
     )
-    assert pkey_ctx != backend._ffi.NULL
+    backend.openssl_assert(pkey_ctx != backend._ffi.NULL)
     pkey_ctx = backend._ffi.gc(pkey_ctx, backend._lib.EVP_PKEY_CTX_free)
     res = init(pkey_ctx)
-    assert res == 1
+    backend.openssl_assert(res == 1)
     res = backend._lib.EVP_PKEY_CTX_set_rsa_padding(
         pkey_ctx, padding_enum)
-    assert res > 0
+    backend.openssl_assert(res > 0)
     buf_size = backend._lib.EVP_PKEY_size(key._evp_pkey)
-    assert buf_size > 0
+    backend.openssl_assert(buf_size > 0)
     outlen = backend._ffi.new("size_t *", buf_size)
     buf = backend._ffi.new("char[]", buf_size)
     res = crypt(pkey_ctx, buf, outlen, data, len(data))
@@ -114,7 +114,7 @@ def _enc_dec_rsa_098(backend, key, data, padding_enum):
         crypt = backend._lib.RSA_private_decrypt
 
     key_size = backend._lib.RSA_size(key._rsa_cdata)
-    assert key_size > 0
+    backend.openssl_assert(key_size > 0)
     buf = backend._ffi.new("unsigned char[]", key_size)
     res = crypt(len(data), data, buf, key._rsa_cdata, padding_enum)
     if res < 0:
@@ -158,6 +158,7 @@ class _RSASignatureContext(object):
         self._pkey_size = self._backend._lib.EVP_PKEY_size(
             self._private_key._evp_pkey
         )
+        self._backend.openssl_assert(self._pkey_size > 0)
 
         if isinstance(padding, PKCS1v15):
             if self._backend._lib.Cryptography_HAS_PKEY_CTX:
@@ -174,7 +175,6 @@ class _RSASignatureContext(object):
 
             # Size of key in bytes - 2 is the maximum
             # PSS signature length (salt length is checked later)
-            assert self._pkey_size > 0
             if self._pkey_size - algorithm.digest_size - 2 < 0:
                 raise ValueError("Digest too large for key size. Use a larger "
                                  "key.")
@@ -207,7 +207,7 @@ class _RSASignatureContext(object):
     def finalize(self):
         evp_md = self._backend._lib.EVP_get_digestbyname(
             self._algorithm.name.encode("ascii"))
-        assert evp_md != self._backend._ffi.NULL
+        self._backend.openssl_assert(evp_md != self._backend._ffi.NULL)
 
         return self._finalize_method(evp_md)
 
@@ -215,18 +215,18 @@ class _RSASignatureContext(object):
         pkey_ctx = self._backend._lib.EVP_PKEY_CTX_new(
             self._private_key._evp_pkey, self._backend._ffi.NULL
         )
-        assert pkey_ctx != self._backend._ffi.NULL
+        self._backend.openssl_assert(pkey_ctx != self._backend._ffi.NULL)
         pkey_ctx = self._backend._ffi.gc(pkey_ctx,
                                          self._backend._lib.EVP_PKEY_CTX_free)
         res = self._backend._lib.EVP_PKEY_sign_init(pkey_ctx)
-        assert res == 1
+        self._backend.openssl_assert(res == 1)
         res = self._backend._lib.EVP_PKEY_CTX_set_signature_md(
             pkey_ctx, evp_md)
-        assert res > 0
+        self._backend.openssl_assert(res > 0)
 
         res = self._backend._lib.EVP_PKEY_CTX_set_rsa_padding(
             pkey_ctx, self._padding_enum)
-        assert res > 0
+        self._backend.openssl_assert(res > 0)
         if isinstance(self._padding, PSS):
             res = self._backend._lib.EVP_PKEY_CTX_set_rsa_pss_saltlen(
                 pkey_ctx,
@@ -236,17 +236,19 @@ class _RSASignatureContext(object):
                     self._hash_ctx.algorithm.digest_size
                 )
             )
-            assert res > 0
+            self._backend.openssl_assert(res > 0)
 
             if self._backend._lib.Cryptography_HAS_MGF1_MD:
                 # MGF1 MD is configurable in OpenSSL 1.0.1+
                 mgf1_md = self._backend._lib.EVP_get_digestbyname(
                     self._padding._mgf._algorithm.name.encode("ascii"))
-                assert mgf1_md != self._backend._ffi.NULL
+                self._backend.openssl_assert(
+                    mgf1_md != self._backend._ffi.NULL
+                )
                 res = self._backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(
                     pkey_ctx, mgf1_md
                 )
-                assert res > 0
+                self._backend.openssl_assert(res > 0)
         data_to_sign = self._hash_ctx.finalize()
         buflen = self._backend._ffi.new("size_t *")
         res = self._backend._lib.EVP_PKEY_sign(
@@ -256,7 +258,7 @@ class _RSASignatureContext(object):
             data_to_sign,
             len(data_to_sign)
         )
-        assert res == 1
+        self._backend.openssl_assert(res == 1)
         buf = self._backend._ffi.new("unsigned char[]", buflen[0])
         res = self._backend._lib.EVP_PKEY_sign(
             pkey_ctx, buf, buflen, data_to_sign, len(data_to_sign))
@@ -330,7 +332,7 @@ class _RSASignatureContext(object):
             self._private_key._rsa_cdata,
             self._backend._lib.RSA_NO_PADDING
         )
-        assert sig_len != -1
+        self._backend.openssl_assert(sig_len != -1)
         return self._backend._ffi.buffer(sig_buf)[:sig_len]
 
 
@@ -347,6 +349,7 @@ class _RSAVerificationContext(object):
         self._pkey_size = self._backend._lib.EVP_PKEY_size(
             self._public_key._evp_pkey
         )
+        self._backend.openssl_assert(self._pkey_size > 0)
 
         if isinstance(padding, PKCS1v15):
             if self._backend._lib.Cryptography_HAS_PKEY_CTX:
@@ -363,7 +366,6 @@ class _RSAVerificationContext(object):
 
             # Size of key in bytes - 2 is the maximum
             # PSS signature length (salt length is checked later)
-            assert self._pkey_size > 0
             if self._pkey_size - algorithm.digest_size - 2 < 0:
                 raise ValueError(
                     "Digest too large for key size. Check that you have the "
@@ -398,7 +400,7 @@ class _RSAVerificationContext(object):
     def verify(self):
         evp_md = self._backend._lib.EVP_get_digestbyname(
             self._algorithm.name.encode("ascii"))
-        assert evp_md != self._backend._ffi.NULL
+        self._backend.openssl_assert(evp_md != self._backend._ffi.NULL)
 
         self._verify_method(evp_md)
 
@@ -406,18 +408,18 @@ class _RSAVerificationContext(object):
         pkey_ctx = self._backend._lib.EVP_PKEY_CTX_new(
             self._public_key._evp_pkey, self._backend._ffi.NULL
         )
-        assert pkey_ctx != self._backend._ffi.NULL
+        self._backend.openssl_assert(pkey_ctx != self._backend._ffi.NULL)
         pkey_ctx = self._backend._ffi.gc(pkey_ctx,
                                          self._backend._lib.EVP_PKEY_CTX_free)
         res = self._backend._lib.EVP_PKEY_verify_init(pkey_ctx)
-        assert res == 1
+        self._backend.openssl_assert(res == 1)
         res = self._backend._lib.EVP_PKEY_CTX_set_signature_md(
             pkey_ctx, evp_md)
-        assert res > 0
+        self._backend.openssl_assert(res > 0)
 
         res = self._backend._lib.EVP_PKEY_CTX_set_rsa_padding(
             pkey_ctx, self._padding_enum)
-        assert res > 0
+        self._backend.openssl_assert(res > 0)
         if isinstance(self._padding, PSS):
             res = self._backend._lib.EVP_PKEY_CTX_set_rsa_pss_saltlen(
                 pkey_ctx,
@@ -427,16 +429,18 @@ class _RSAVerificationContext(object):
                     self._hash_ctx.algorithm.digest_size
                 )
             )
-            assert res > 0
+            self._backend.openssl_assert(res > 0)
             if self._backend._lib.Cryptography_HAS_MGF1_MD:
                 # MGF1 MD is configurable in OpenSSL 1.0.1+
                 mgf1_md = self._backend._lib.EVP_get_digestbyname(
                     self._padding._mgf._algorithm.name.encode("ascii"))
-                assert mgf1_md != self._backend._ffi.NULL
+                self._backend.openssl_assert(
+                    mgf1_md != self._backend._ffi.NULL
+                )
                 res = self._backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(
                     pkey_ctx, mgf1_md
                 )
-                assert res > 0
+                self._backend.openssl_assert(res > 0)
 
         data_to_verify = self._hash_ctx.finalize()
         res = self._backend._lib.EVP_PKEY_verify(
@@ -449,7 +453,7 @@ class _RSAVerificationContext(object):
         # The previous call can return negative numbers in the event of an
         # error. This is not a signature failure but we need to fail if it
         # occurs.
-        assert res >= 0
+        self._backend.openssl_assert(res >= 0)
         if res == 0:
             errors = self._backend._consume_errors()
             assert errors
@@ -469,7 +473,7 @@ class _RSAVerificationContext(object):
         # The previous call can return negative numbers in the event of an
         # error. This is not a signature failure but we need to fail if it
         # occurs.
-        assert res >= 0
+        self._backend.openssl_assert(res >= 0)
         if res == 0:
             errors = self._backend._consume_errors()
             assert errors
@@ -530,12 +534,12 @@ class _RSAPrivateKey(object):
 
     def public_key(self):
         ctx = self._backend._lib.RSA_new()
-        assert ctx != self._backend._ffi.NULL
+        self._backend.openssl_assert(ctx != self._backend._ffi.NULL)
         ctx = self._backend._ffi.gc(ctx, self._backend._lib.RSA_free)
         ctx.e = self._backend._lib.BN_dup(self._rsa_cdata.e)
         ctx.n = self._backend._lib.BN_dup(self._rsa_cdata.n)
         res = self._backend._lib.RSA_blinding_on(ctx, self._backend._ffi.NULL)
-        assert res == 1
+        self._backend.openssl_assert(res == 1)
         evp_pkey = self._backend._rsa_cdata_to_evp_pkey(ctx)
         return _RSAPublicKey(self._backend, ctx, evp_pkey)