[openssl] master update

Dr. Paul Dale pauli at openssl.org
Thu Mar 25 22:48:15 UTC 2021


The branch master has been updated
       via  8c63532002fdab11b437bc8d68012c2b05cf00ea (commit)
       via  8eca93f8fbd568df3431c449e2b53d4a3aa5bae4 (commit)
       via  27f37279df67abc2ed8239435042de86ae3c74ca (commit)
       via  40d6e05cf8075e1f37aeb5ea1b49f47896f951fa (commit)
       via  8cdcb63fc02239e92fc4bdcc5b97d38cc726c439 (commit)
       via  3352a4f6fade5da0d0dfa9e7c9c9c261598c4bac (commit)
       via  f47865156a7b26c3ee4b6479f821588eaa53fddf (commit)
       via  b8cb90cdb68d81770e21417ca554954c92603675 (commit)
       via  0d2b8bd261bbebc8a1834d85ede0a2bd22c71851 (commit)
       via  a02d70dd510e66eb2f916a723e30fd7e75b33eef (commit)
       via  6a6844a219769aa9f58782fda2960c0ab5a4022b (commit)
      from  3c4c8dd84ac18345a44120bb28f7fc85e33da093 (commit)


- Log -----------------------------------------------------------------
commit 8c63532002fdab11b437bc8d68012c2b05cf00ea
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:46:03 2021 +1000

    test: fix coverity 1473609 & 1473610: unchecked return values
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 8eca93f8fbd568df3431c449e2b53d4a3aa5bae4
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:43:24 2021 +1000

    evp: fix coverity 1473378: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 27f37279df67abc2ed8239435042de86ae3c74ca
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:41:34 2021 +1000

    params: fix coverity 1473069: unchecked return values
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 40d6e05cf8075e1f37aeb5ea1b49f47896f951fa
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:40:05 2021 +1000

    evp: fix coverity 1467500 & 1467502: unchecked return values
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 8cdcb63fc02239e92fc4bdcc5b97d38cc726c439
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:35:05 2021 +1000

    apps: fix coverity 1455340: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 3352a4f6fade5da0d0dfa9e7c9c9c261598c4bac
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:30:07 2021 +1000

    test: fix coverity 1451550: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit f47865156a7b26c3ee4b6479f821588eaa53fddf
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:22:50 2021 +1000

    test: fix coverity 1429210: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit b8cb90cdb68d81770e21417ca554954c92603675
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:19:08 2021 +1000

    test: fix coverity 1416888: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 0d2b8bd261bbebc8a1834d85ede0a2bd22c71851
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:14:40 2021 +1000

    test: fix coverity 1414451: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit a02d70dd510e66eb2f916a723e30fd7e75b33eef
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 09:11:02 2021 +1000

    apps: fix coverity 1358776, 1451513, 1451519, 1451531 & 1473387: unchecked return values
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

commit 6a6844a219769aa9f58782fda2960c0ab5a4022b
Author: Pauli <ppzgs1 at gmail.com>
Date:   Fri Mar 19 08:44:09 2021 +1000

    test: fix coverity 1338157: unchecked return value
    
    Reviewed-by: Tomas Mraz <tomas at openssl.org>
    (Merged from https://github.com/openssl/openssl/pull/14615)

-----------------------------------------------------------------------

Summary of changes:
 apps/lib/s_cb.c                     |  8 ++++---
 apps/speed.c                        | 45 +++++++++++++++++++++++--------------
 crypto/evp/p_legacy.c               | 16 +++++++------
 crypto/evp/p_lib.c                  |  5 +++--
 crypto/params_from_text.c           |  7 +++---
 test/bad_dtls_test.c                | 44 +++++++++++++++++++++---------------
 test/exptest.c                      | 21 ++++++++++++-----
 test/gmdifftest.c                   |  4 ++--
 test/modes_internal_test.c          |  3 ++-
 test/ssl_cert_table_internal_test.c | 33 ++++++++++-----------------
 test/threadstest.c                  |  8 +++----
 11 files changed, 110 insertions(+), 84 deletions(-)

diff --git a/apps/lib/s_cb.c b/apps/lib/s_cb.c
index 4c209e76df..6824567c70 100644
--- a/apps/lib/s_cb.c
+++ b/apps/lib/s_cb.c
@@ -1276,12 +1276,14 @@ int config_ctx(SSL_CONF_CTX *cctx, STACK_OF(OPENSSL_STRING) *str,
 static int add_crls_store(X509_STORE *st, STACK_OF(X509_CRL) *crls)
 {
     X509_CRL *crl;
-    int i;
+    int i, ret = 1;
+
     for (i = 0; i < sk_X509_CRL_num(crls); i++) {
         crl = sk_X509_CRL_value(crls, i);
-        X509_STORE_add_crl(st, crl);
+        if (!X509_STORE_add_crl(st, crl))
+            ret = 0;
     }
-    return 1;
+    return ret;
 }
 
 int ssl_ctx_add_crls(SSL_CTX *ctx, STACK_OF(X509_CRL) *crls, int crl_download)
diff --git a/apps/speed.c b/apps/speed.c
index 30e703632f..0bd566e846 100644
--- a/apps/speed.c
+++ b/apps/speed.c
@@ -729,7 +729,11 @@ static EVP_CIPHER_CTX *init_evp_cipher_ctx(const char *ciphername,
         goto end;
     }
 
-    EVP_CIPHER_CTX_set_key_length(ctx, keylen);
+    if (!EVP_CIPHER_CTX_set_key_length(ctx, keylen)) {
+        EVP_CIPHER_CTX_free(ctx);
+        ctx = NULL;
+        goto end;
+    }
 
     if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, 1)) {
         EVP_CIPHER_CTX_free(ctx);
@@ -838,19 +842,19 @@ static int EVP_Update_loop_aead(void *args)
 
     if (decrypt) {
         for (count = 0; COND(c[D_EVP][testnum]); count++) {
-            EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
-            EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
-                                sizeof(faketag), faketag);
-            EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
-            EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
-            EVP_DecryptFinal_ex(ctx, buf + outl, &outl);
+            (void)EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
+            (void)EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
+                                      sizeof(faketag), faketag);
+            (void)EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
+            (void)EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
+            (void)EVP_DecryptFinal_ex(ctx, buf + outl, &outl);
         }
     } else {
         for (count = 0; COND(c[D_EVP][testnum]); count++) {
-            EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
-            EVP_EncryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
-            EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
-            EVP_EncryptFinal_ex(ctx, buf + outl, &outl);
+            (void)EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
+            (void)EVP_EncryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
+            (void)EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
+            (void)EVP_EncryptFinal_ex(ctx, buf + outl, &outl);
         }
     }
     return count;
@@ -3610,20 +3614,27 @@ static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
 
     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
-    ctx = EVP_CIPHER_CTX_new();
-    EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
+    if ((ctx = EVP_CIPHER_CTX_new()) == NULL)
+        app_bail_out("failed to allocate cipher context\n");
+    if (!EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv))
+        app_bail_out("failed to initialise cipher context\n");
 
     if ((keylen = EVP_CIPHER_CTX_key_length(ctx)) < 0) {
         BIO_printf(bio_err, "Impossible negative key length: %d\n", keylen);
         return;
     }
     key = app_malloc(keylen, "evp_cipher key");
-    EVP_CIPHER_CTX_rand_key(ctx, key);
-    EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
+    if (!EVP_CIPHER_CTX_rand_key(ctx, key))
+        app_bail_out("failed to generate random cipher key\n");
+    if (!EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL))
+        app_bail_out("failed to set cipher key\n");
     OPENSSL_clear_free(key, keylen);
 
-    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
-    alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
+    if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY,
+                             sizeof(no_key), no_key))
+        app_bail_out("failed to set AEAD key\n");
+    if ((alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher))) == NULL)
+        app_bail_out("failed to get cipher name\n");
 
     for (j = 0; j < num; j++) {
         print_message(alg_name, 0, mblengths[j], seconds->sym);
diff --git a/crypto/evp/p_legacy.c b/crypto/evp/p_legacy.c
index af93288dcb..c1d813f047 100644
--- a/crypto/evp/p_legacy.c
+++ b/crypto/evp/p_legacy.c
@@ -57,11 +57,13 @@ RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
 #ifndef OPENSSL_NO_EC
 int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
 {
-    int ret = EVP_PKEY_assign_EC_KEY(pkey, key);
-
-    if (ret)
-        EC_KEY_up_ref(key);
-    return ret;
+    if (!EC_KEY_up_ref(key))
+        return 0;
+    if (!EVP_PKEY_assign_EC_KEY(pkey, key)) {
+        EC_KEY_free(key);
+        return 0;
+    }
+    return 1;
 }
 
 EC_KEY *evp_pkey_get0_EC_KEY_int(const EVP_PKEY *pkey)
@@ -82,8 +84,8 @@ EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
 {
     EC_KEY *ret = evp_pkey_get0_EC_KEY_int(pkey);
 
-    if (ret != NULL)
-        EC_KEY_up_ref(ret);
+    if (ret != NULL && !EC_KEY_up_ref(ret))
+        ret = NULL;
     return ret;
 }
 #endif /* OPENSSL_NO_EC */
diff --git a/crypto/evp/p_lib.c b/crypto/evp/p_lib.c
index 4abecdf30c..94a83c4804 100644
--- a/crypto/evp/p_lib.c
+++ b/crypto/evp/p_lib.c
@@ -846,8 +846,9 @@ static const ECX_KEY *evp_pkey_get0_ECX_KEY(const EVP_PKEY *pkey, int type)
 static ECX_KEY *evp_pkey_get1_ECX_KEY(EVP_PKEY *pkey, int type)
 {
     ECX_KEY *ret = (ECX_KEY *)evp_pkey_get0_ECX_KEY(pkey, type);
-    if (ret != NULL)
-        ossl_ecx_key_up_ref(ret);
+
+    if (ret != NULL && !ossl_ecx_key_up_ref(ret))
+        ret = NULL;
     return ret;
 }
 
diff --git a/crypto/params_from_text.c b/crypto/params_from_text.c
index bf3ca61641..50f48fdb7e 100644
--- a/crypto/params_from_text.c
+++ b/crypto/params_from_text.c
@@ -29,6 +29,7 @@ static int prepare_from_text(const OSSL_PARAM *paramdefs, const char *key,
 {
     const OSSL_PARAM *p;
     size_t buf_bits;
+    int r;
 
     /*
      * ishex is used to translate legacy style string controls in hex format
@@ -49,11 +50,11 @@ static int prepare_from_text(const OSSL_PARAM *paramdefs, const char *key,
     case OSSL_PARAM_INTEGER:
     case OSSL_PARAM_UNSIGNED_INTEGER:
         if (*ishex)
-            BN_hex2bn(tmpbn, value);
+            r = BN_hex2bn(tmpbn, value);
         else
-            BN_asc2bn(tmpbn, value);
+            r = BN_asc2bn(tmpbn, value);
 
-        if (*tmpbn == NULL)
+        if (r == 0 || *tmpbn == NULL)
             return 0;
 
         /*
diff --git a/test/bad_dtls_test.c b/test/bad_dtls_test.c
index 52333e860c..d60daa447f 100644
--- a/test/bad_dtls_test.c
+++ b/test/bad_dtls_test.c
@@ -283,11 +283,12 @@ static int send_record(BIO *rbio, unsigned char type, uint64_t seqnr,
     unsigned char lenbytes[2];
     EVP_MAC *hmac;
     EVP_MAC_CTX *ctx;
-    EVP_CIPHER_CTX *enc_ctx;
+    EVP_CIPHER_CTX *enc_ctx = NULL;
     unsigned char iv[16];
     unsigned char pad;
     unsigned char *enc;
     OSSL_PARAM params[2];
+    int ret = 0;
 
     seq[0] = (seqnr >> 40) & 0xff;
     seq[1] = (seqnr >> 32) & 0xff;
@@ -305,23 +306,26 @@ static int send_record(BIO *rbio, unsigned char type, uint64_t seqnr,
     memcpy(enc, msg, len);
 
     /* Append HMAC to data */
-    hmac = EVP_MAC_fetch(NULL, "HMAC", NULL);
+    if ((hmac = EVP_MAC_fetch(NULL, "HMAC", NULL)) == NULL)
+        return 0;
     ctx = EVP_MAC_CTX_new(hmac);
     EVP_MAC_free(hmac);
+    if (ctx == NULL)
+        return 0;
     params[0] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
                                                  "SHA1", 0);
     params[1] = OSSL_PARAM_construct_end();
-    EVP_MAC_init(ctx, mac_key, 20, params);
-    EVP_MAC_update(ctx, epoch, 2);
-    EVP_MAC_update(ctx, seq, 6);
-    EVP_MAC_update(ctx, &type, 1);
-    EVP_MAC_update(ctx, ver, 2); /* Version */
     lenbytes[0] = (unsigned char)(len >> 8);
     lenbytes[1] = (unsigned char)(len);
-    EVP_MAC_update(ctx, lenbytes, 2); /* Length */
-    EVP_MAC_update(ctx, enc, len); /* Finally the data itself */
-    EVP_MAC_final(ctx, enc + len, NULL, SHA_DIGEST_LENGTH);
-    EVP_MAC_CTX_free(ctx);
+    if (!EVP_MAC_init(ctx, mac_key, 20, params)
+            || !EVP_MAC_update(ctx, epoch, 2)
+            || !EVP_MAC_update(ctx, seq, 6)
+            || !EVP_MAC_update(ctx, &type, 1)
+            || !EVP_MAC_update(ctx, ver, 2)      /* Version */
+            || !EVP_MAC_update(ctx, lenbytes, 2) /* Length */
+            || !EVP_MAC_update(ctx, enc, len)    /* Finally the data itself */
+            || !EVP_MAC_final(ctx, enc + len, NULL, SHA_DIGEST_LENGTH))
+        goto end;
 
     /* Append padding bytes */
     len += SHA_DIGEST_LENGTH;
@@ -330,11 +334,12 @@ static int send_record(BIO *rbio, unsigned char type, uint64_t seqnr,
     } while (len % 16);
 
     /* Generate IV, and encrypt */
-    RAND_bytes(iv, sizeof(iv));
-    enc_ctx = EVP_CIPHER_CTX_new();
-    EVP_CipherInit_ex(enc_ctx, EVP_aes_128_cbc(), NULL, enc_key, iv, 1);
-    EVP_Cipher(enc_ctx, enc, enc, len);
-    EVP_CIPHER_CTX_free(enc_ctx);
+    if (!TEST_true(RAND_bytes(iv, sizeof(iv)))
+            || !TEST_ptr(enc_ctx = EVP_CIPHER_CTX_new())
+            || !TEST_true(EVP_CipherInit_ex(enc_ctx, EVP_aes_128_cbc(), NULL,
+                                            enc_key, iv, 1))
+            || !TEST_int_ge(EVP_Cipher(enc_ctx, enc, enc, len), 0))
+        goto end;
 
     /* Finally write header (from fragmented variables), IV and encrypted record */
     BIO_write(rbio, &type, 1);
@@ -347,9 +352,12 @@ static int send_record(BIO *rbio, unsigned char type, uint64_t seqnr,
 
     BIO_write(rbio, iv, sizeof(iv));
     BIO_write(rbio, enc, len);
-
+    ret = 1;
+ end:
+    EVP_MAC_CTX_free(ctx);
+    EVP_CIPHER_CTX_free(enc_ctx);
     OPENSSL_free(enc);
-    return 1;
+    return ret;
 }
 
 static int send_finished(SSL *s, BIO *rbio)
diff --git a/test/exptest.c b/test/exptest.c
index a1ac44e909..9474f21f3b 100644
--- a/test/exptest.c
+++ b/test/exptest.c
@@ -144,17 +144,26 @@ static int test_mod_exp(int round)
         || !TEST_ptr(m = BN_new()))
         goto err;
 
-    RAND_bytes(&c, 1);
+    if (!TEST_true(RAND_bytes(&c, 1)))
+        goto err;
     c = (c % BN_BITS) - BN_BITS2;
-    BN_rand(a, NUM_BITS + c, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY);
+    if (!TEST_true(BN_rand(a, NUM_BITS + c, BN_RAND_TOP_ONE,
+                           BN_RAND_BOTTOM_ANY)))
+        goto err;
 
-    RAND_bytes(&c, 1);
+    if (!TEST_true(RAND_bytes(&c, 1)))
+        goto err;
     c = (c % BN_BITS) - BN_BITS2;
-    BN_rand(b, NUM_BITS + c, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY);
+    if (!TEST_true(BN_rand(b, NUM_BITS + c, BN_RAND_TOP_ONE,
+                           BN_RAND_BOTTOM_ANY)))
+        goto err;
 
-    RAND_bytes(&c, 1);
+    if (!TEST_true(RAND_bytes(&c, 1)))
+        goto err;
     c = (c % BN_BITS) - BN_BITS2;
-    BN_rand(m, NUM_BITS + c, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ODD);
+    if (!TEST_true(BN_rand(m, NUM_BITS + c, BN_RAND_TOP_ONE,
+                           BN_RAND_BOTTOM_ODD)))
+        goto err;
 
     if (!TEST_true(BN_mod(a, a, m, ctx))
         || !TEST_true(BN_mod(b, b, m, ctx))
diff --git a/test/gmdifftest.c b/test/gmdifftest.c
index b0fc5c637f..b1720ccf48 100644
--- a/test/gmdifftest.c
+++ b/test/gmdifftest.c
@@ -32,8 +32,8 @@ static int check_time(long offset)
     OPENSSL_gmtime(&t2, &tm2);
     OPENSSL_gmtime(&t1, &tm1);
     o1 = tm1;
-    OPENSSL_gmtime_adj(&tm1, 0, offset);
-    if (!TEST_int_eq(tm1.tm_year, tm2.tm_year)
+    if (!TEST_true(OPENSSL_gmtime_adj(&tm1, 0, offset))
+        || !TEST_int_eq(tm1.tm_year, tm2.tm_year)
         || !TEST_int_eq(tm1.tm_mon, tm2.tm_mon)
         || !TEST_int_eq(tm1.tm_mday, tm2.tm_mday)
         || !TEST_int_eq(tm1.tm_hour, tm2.tm_hour)
diff --git a/test/modes_internal_test.c b/test/modes_internal_test.c
index dd0a35956f..7701ff6dce 100644
--- a/test/modes_internal_test.c
+++ b/test/modes_internal_test.c
@@ -869,7 +869,8 @@ static int test_gcm128(int idx)
     if (A.data != NULL)
         CRYPTO_gcm128_aad(&ctx, A.data, A.size);
     if (P.data != NULL)
-        CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);
+        if (!TEST_int_ge(CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size), 0))
+            return 0;
     if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
             || (C.data != NULL
                     && !TEST_mem_eq(out, P.size, C.data, P.size)))
diff --git a/test/ssl_cert_table_internal_test.c b/test/ssl_cert_table_internal_test.c
index d6e93af5b6..fbf70e7405 100644
--- a/test/ssl_cert_table_internal_test.c
+++ b/test/ssl_cert_table_internal_test.c
@@ -43,27 +43,18 @@ static int do_test_cert_table(int nid, uint32_t amask, size_t idx,
 
 static int test_ssl_cert_table(void)
 {
-    TEST_size_t_eq(OSSL_NELEM(ssl_cert_info), SSL_PKEY_NUM);
-    if (!test_cert_table(EVP_PKEY_RSA, SSL_aRSA, SSL_PKEY_RSA))
-        return 0;
-    if (!test_cert_table(EVP_PKEY_DSA, SSL_aDSS, SSL_PKEY_DSA_SIGN))
-        return 0;
-    if (!test_cert_table(EVP_PKEY_EC, SSL_aECDSA, SSL_PKEY_ECC))
-        return 0;
-    if (!test_cert_table(NID_id_GostR3410_2001, SSL_aGOST01, SSL_PKEY_GOST01))
-        return 0;
-    if (!test_cert_table(NID_id_GostR3410_2012_256, SSL_aGOST12,
-                         SSL_PKEY_GOST12_256))
-        return 0;
-    if (!test_cert_table(NID_id_GostR3410_2012_512, SSL_aGOST12,
-                         SSL_PKEY_GOST12_512))
-        return 0;
-    if (!test_cert_table(EVP_PKEY_ED25519, SSL_aECDSA, SSL_PKEY_ED25519))
-        return 0;
-    if (!test_cert_table(EVP_PKEY_ED448, SSL_aECDSA, SSL_PKEY_ED448))
-        return 0;
-
-    return 1;
+    return TEST_size_t_eq(OSSL_NELEM(ssl_cert_info), SSL_PKEY_NUM)
+           && test_cert_table(EVP_PKEY_RSA, SSL_aRSA, SSL_PKEY_RSA)
+           && test_cert_table(EVP_PKEY_DSA, SSL_aDSS, SSL_PKEY_DSA_SIGN)
+           && test_cert_table(EVP_PKEY_EC, SSL_aECDSA, SSL_PKEY_ECC)
+           && test_cert_table(NID_id_GostR3410_2001, SSL_aGOST01,
+                              SSL_PKEY_GOST01)
+           && test_cert_table(NID_id_GostR3410_2012_256, SSL_aGOST12,
+                              SSL_PKEY_GOST12_256)
+           && test_cert_table(NID_id_GostR3410_2012_512, SSL_aGOST12,
+                              SSL_PKEY_GOST12_512)
+           && test_cert_table(EVP_PKEY_ED25519, SSL_aECDSA, SSL_PKEY_ED25519)
+           && test_cert_table(EVP_PKEY_ED448, SSL_aECDSA, SSL_PKEY_ED448);
 }
 
 int setup_tests(void)
diff --git a/test/threadstest.c b/test/threadstest.c
index ed46234fc1..17b348b80c 100644
--- a/test/threadstest.c
+++ b/test/threadstest.c
@@ -514,8 +514,8 @@ static void test_multi_load_worker(void)
 {
     OSSL_PROVIDER *prov;
 
-    TEST_ptr(prov = OSSL_PROVIDER_load(NULL, "default"));
-    TEST_true(OSSL_PROVIDER_unload(prov));
+    (void)TEST_ptr(prov = OSSL_PROVIDER_load(NULL, "default"));
+    (void)TEST_true(OSSL_PROVIDER_unload(prov));
 }
 
 static int test_multi_load(void)
@@ -524,10 +524,10 @@ static int test_multi_load(void)
     int i;
 
     for (i = 0; i < MULTI_LOAD_THREADS; i++)
-        TEST_true(run_thread(&threads[i], test_multi_load_worker));
+        (void)TEST_true(run_thread(&threads[i], test_multi_load_worker));
 
     for (i = 0; i < MULTI_LOAD_THREADS; i++)
-        TEST_true(wait_for_thread(threads[i]));
+        (void)TEST_true(wait_for_thread(threads[i]));
 
     return 1;
 }


More information about the openssl-commits mailing list