Add unit tests to exercise new code paths

Author: aidangarske

src/wp_cmac.c

@@ -162,15 +162,13 @@ static wp_CmacCtx* wp_cmac_dup(wp_CmacCtx* src)
         dst = wp_cmac_new(NULL);
     }
     if (dst != NULL) {
+        /* Copy the entire context to preserve in-progress CMAC state. */
+        XMEMCPY(&dst->cmac, &src->cmac, sizeof(Cmac));
         dst->type = src->type;
         dst->size = src->size;
         dst->expKeySize = src->expKeySize;
-
-        if ((src->keyLen != 0) &&
-            (!wp_cmac_set_key(dst, src->key, src->keyLen, 1))) {
-            wp_cmac_free(dst);
-            dst = NULL;
-        }
+        XMEMCPY(dst->key, src->key, src->keyLen);
+        dst->keyLen = src->keyLen;
     }
 
     return dst;

src/wp_drbg.c

@@ -334,17 +334,41 @@ static int wp_drbg_reseed(wp_DrbgCtx* ctx, int predResist,
     const unsigned char* addIn, size_t addInLen)
 {
     int ok = 1;
-
     int rc;
+    unsigned char *seed = NULL;
+    size_t seedLen = 0;
 
     WOLFPROV_ENTER(WP_LOG_COMP_RNG, "wp_drbg_reseed");
 
-    rc = wc_RNG_DRBG_Reseed(ctx->rng, entropy, (word32)entropyLen);
-    if (rc != 0) {
-        WOLFPROV_MSG_DEBUG_RETCODE(WP_LOG_COMP_RNG, "wc_RNG_DRBG_Reseed", rc);
-        ok = 0;
+    /* If no entropy provided, get fresh entropy from the OS source. */
+    if (entropy == NULL || entropyLen == 0) {
+        seedLen = 48;
+        seed = OPENSSL_malloc(seedLen);
+        if (seed == NULL) {
+            ok = 0;
+        }
+        if (ok) {
+            OS_Seed osSeed;
+            rc = wc_GenerateSeed(&osSeed, seed, (word32)seedLen);
+            if (rc != 0) {
+                ok = 0;
+            }
+            else {
+                entropy = seed;
+                entropyLen = seedLen;
+            }
+        }
     }
-    if (ok && (addInLen > 0)) {
+
+    if (ok && entropy != NULL && entropyLen > 0) {
+        rc = wc_RNG_DRBG_Reseed(ctx->rng, entropy, (word32)entropyLen);
+        if (rc != 0) {
+            WOLFPROV_MSG_DEBUG_RETCODE(WP_LOG_COMP_RNG,
+                "wc_RNG_DRBG_Reseed", rc);
+            ok = 0;
+        }
+    }
+    if (ok && (addInLen > 0) && (addIn != NULL)) {
         rc = wc_RNG_DRBG_Reseed(ctx->rng, addIn, (word32)addInLen);
         if (rc != 0) {
             WOLFPROV_MSG_DEBUG_RETCODE(WP_LOG_COMP_RNG,
@@ -353,6 +377,11 @@ static int wp_drbg_reseed(wp_DrbgCtx* ctx, int predResist,
         }
     }
 
+    /* Clear seed from parent if we obtained one. */
+    if (seed != NULL && ctx->parentClearSeed != NULL) {
+        ctx->parentClearSeed(ctx->parent, seed, seedLen);
+    }
+
     (void)predResist;
 
     WOLFPROV_LEAVE(WP_LOG_COMP_RNG, __FILE__ ":" WOLFPROV_STRINGIZE(__LINE__), ok);

src/wp_ecx_kmgmt.c

@@ -365,50 +365,20 @@ static wp_Ecx* wp_ecx_dup(const wp_Ecx* src, int selection)
 
         dst->includePublic = src->includePublic;
 
-        /* Copy public key if available and requested. */
-        if (ok && src->hasPub &&
+        /* Copy the key union directly to preserve all internal state. */
+        XMEMCPY(&dst->key, &src->key, sizeof(src->key));
+
+        /* Copy public key flags if available and requested. */
+        if (src->hasPub &&
             ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)) {
-            byte buf[64];
-            word32 len = (word32)sizeof(buf);
-            int rc = (*src->data->exportPub)((void*)&src->key, buf, &len,
-                ECX_LITTLE_ENDIAN);
-            if (rc != 0) {
-                ok = 0;
-            }
-            if (ok) {
-                rc = (*dst->data->importPub)(buf, len, (void*)&dst->key,
-                    ECX_LITTLE_ENDIAN);
-                if (rc != 0) {
-                    ok = 0;
-                }
-            }
-            if (ok) {
-                dst->hasPub = 1;
-            }
+            dst->hasPub = 1;
         }
-        /* Copy private key if available and requested. */
-        if (ok && src->hasPriv &&
+        /* Copy private key flags if available and requested. */
+        if (src->hasPriv &&
             ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)) {
-            byte buf[64];
-            word32 len = (word32)sizeof(buf);
-            int rc = (*src->data->exportPriv)((void*)&src->key, buf, &len);
-            if (rc != 0) {
-                ok = 0;
-            }
-            if (ok) {
-                rc = (*dst->data->importPriv)(buf, len, (void*)&dst->key,
-                    ECX_LITTLE_ENDIAN);
-                if (rc != 0) {
-                    ok = 0;
-                }
-            }
-            if (ok) {
-                dst->hasPriv = 1;
-                dst->clamped = src->clamped;
-                XMEMCPY(dst->unclamped, src->unclamped,
-                    sizeof(src->unclamped));
-            }
-            wc_ForceZero(buf, len);
+            dst->hasPriv = 1;
+            dst->clamped = src->clamped;
+            XMEMCPY(dst->unclamped, src->unclamped, sizeof(src->unclamped));
         }
 
         if (!ok) {

src/wp_hmac.c

@@ -194,10 +194,10 @@ static wp_HmacCtx* wp_hmac_dup(wp_HmacCtx* src)
         dst->size = src->size;
         dst->provCtx = src->provCtx;
 
-        rc = wc_HmacCopy(&src->hmac, &dst->hmac);
-        if (rc != 0) {
-            ok = 0;
-        }
+        /* Copy the Hmac struct directly to preserve in-progress state.
+         * wc_HmacCopy is not available in all wolfSSL versions. */
+        XMEMCPY(&dst->hmac, &src->hmac, sizeof(Hmac));
+        (void)rc;
 
         if (ok && (src->key != NULL) &&
             (!wp_hmac_set_key(dst, src->key, src->keyLen, 0))) {

src/wp_mac_kmgmt.c

@@ -319,6 +319,10 @@ static int wp_mac_has(const wp_Mac* mac, int selection)
     if (mac == NULL) {
        ok = 0;
     }
+    if (ok && ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)) {
+        /* MAC keys do not have a public key component. */
+        ok = 0;
+    }
     if (ok && ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)) {
         ok &= mac->key != NULL;
     }
@@ -345,11 +349,13 @@ static int wp_mac_match(const wp_Mac* mac1, const wp_Mac* mac2, int selection)
     if (!wolfssl_prov_is_running()) {
         ok = 0;
     }
-    if (ok && ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) &&
-        (mac1->keyLen != MAX_SIZE_T) && ((mac1->keyLen != mac2->keyLen) ||
-        (CRYPTO_memcmp(mac1->key, mac2->key, mac1->keyLen) != 0) ||
-        (XMEMCMP(mac1->cipher, mac2->cipher, WP_MAX_CIPH_NAME_SIZE) != 0))) {
-        ok = 0;
+    if (ok && ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)) {
+        if ((mac1->keyLen == MAX_SIZE_T) || (mac2->keyLen == MAX_SIZE_T) ||
+            (mac1->keyLen != mac2->keyLen) ||
+            (CRYPTO_memcmp(mac1->key, mac2->key, mac1->keyLen) != 0) ||
+            (XMEMCMP(mac1->cipher, mac2->cipher, WP_MAX_CIPH_NAME_SIZE) != 0)) {
+            ok = 0;
+        }
     }
 
     WOLFPROV_LEAVE(WP_LOG_COMP_MAC, __FILE__ ":" WOLFPROV_STRINGIZE(__LINE__), ok);

src/wp_rsa_kmgmt.c

@@ -998,12 +998,34 @@ static int wp_rsa_get_params_pss(wp_RsaPssParams* pss,  OSSL_PARAM params[])
             ok = 0;
         }
     }
-    /* MGF is default so don't set. */
-    if (ok && (pss->mgf != WP_RSA_PSS_MGF_DEF)) {
+    /* Always export MGF1 digest when requested. Translate wolfSSL-style
+     * digest names to OpenSSL-style names for interoperability. */
+    if (ok) {
         p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_RSA_MGF1_DIGEST);
-        if ((p != NULL) &&
-                !OSSL_PARAM_set_utf8_string(p, pss->mgfMdName)) {
-            ok = 0;
+        if (p != NULL) {
+            const char* mgfName = NULL;
+            /* Convert mgf type to OpenSSL name via wp_digest_to_ossl_digest. */
+            if (pss->mgf != WP_RSA_PSS_MGF_DEF) {
+                enum wc_HashType mgfHash = WC_HASH_TYPE_NONE;
+                switch (pss->mgf) {
+                    case WC_MGF1SHA256: mgfHash = WC_HASH_TYPE_SHA256; break;
+                    case WC_MGF1SHA384: mgfHash = WC_HASH_TYPE_SHA384; break;
+                    case WC_MGF1SHA512: mgfHash = WC_HASH_TYPE_SHA512; break;
+                    default: break;
+                }
+                if (mgfHash != WC_HASH_TYPE_NONE) {
+                    wp_digest_to_ossl_digest(mgfHash, &mgfName);
+                }
+            }
+            /* Fall back to signing digest if MGF1 not explicitly set. */
+            if (mgfName == NULL) {
+                if (!wp_digest_to_ossl_digest(pss->hashType, &mgfName)) {
+                    mgfName = OSSL_DIGEST_NAME_SHA1;
+                }
+            }
+            if (!OSSL_PARAM_set_utf8_string(p, mgfName)) {
+                ok = 0;
+            }
         }
     }
     if (ok) {
@@ -1607,6 +1629,7 @@ static wp_Rsa* wp_rsa_gen(wp_RsaGenCtx* ctx, OSSL_CALLBACK* cb, void* cbArg)
                     rsa->hasPub    = 1;
                     rsa->hasPriv   = 1;
                     rsa->pssParams = ctx->pssParams;
+                    rsa->pssDefSet = ctx->pssDefSet;
                     break;
                 }
             }

test/test_cmac.c

@@ -257,5 +257,114 @@ int test_cmac_create(void *data)
     return ret;
 }
 
+int test_cmac_dup(void *data)
+{
+    int ret = 0;
+    EVP_MAC* emac = NULL;
+    EVP_MAC_CTX* src = NULL;
+    EVP_MAC_CTX* dup = NULL;
+    OSSL_PARAM params[3];
+    char cipher[] = "AES-256-CBC";
+    unsigned char key[] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
+    };
+    unsigned char prefix[] = "dup-prefix";
+    unsigned char tailA[] = "-tail-a";
+    unsigned char tailB[] = "-tail-b";
+    unsigned char msgA[sizeof(prefix) + sizeof(tailA)];
+    unsigned char msgB[sizeof(prefix) + sizeof(tailB)];
+    unsigned char macA[16];
+    unsigned char macB[16];
+    unsigned char expA[16];
+    unsigned char expB[16];
+    size_t macASz = sizeof(macA);
+    size_t macBSz = sizeof(macB);
+    int expASz = sizeof(expA);
+    int expBSz = sizeof(expB);
+
+    (void)data;
+
+    PRINT_MSG("Testing CMAC context dup");
+
+    /* Build full messages for one-shot expected MAC calculations. */
+    memcpy(msgA, prefix, sizeof(prefix));
+    memcpy(msgA + sizeof(prefix), tailA, sizeof(tailA));
+    memcpy(msgB, prefix, sizeof(prefix));
+    memcpy(msgB + sizeof(prefix), tailB, sizeof(tailB));
+
+    /* Compute expected MACs. */
+    ret = test_cmac_gen_mac(wpLibCtx, cipher, key, (int)sizeof(key),
+        msgA, (int)sizeof(msgA), expA, &expASz);
+    if (ret != 0) {
+        PRINT_MSG("Generate expected MAC A failed");
+    }
+    if (ret == 0) {
+        ret = test_cmac_gen_mac(wpLibCtx, cipher, key, (int)sizeof(key),
+            msgB, (int)sizeof(msgB), expB, &expBSz);
+        if (ret != 0) {
+            PRINT_MSG("Generate expected MAC B failed");
+        }
+    }
+
+    params[0] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
+        cipher, 0);
+    params[1] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
+        (void*)key, sizeof(key));
+    params[2] = OSSL_PARAM_construct_end();
+
+    if (ret == 0) {
+        ret = (emac = EVP_MAC_fetch(wpLibCtx, "CMAC", NULL)) == NULL;
+    }
+    if (ret == 0) {
+        ret = (src = EVP_MAC_CTX_new(emac)) == NULL;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_CTX_set_params(src, params) != 1;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_init(src, NULL, 0, NULL) != 1;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_update(src, prefix, sizeof(prefix)) != 1;
+    }
+    /* Duplicate after partial update. */
+    if (ret == 0) {
+        ret = (dup = EVP_MAC_CTX_dup(src)) == NULL;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_update(src, tailA, sizeof(tailA)) != 1;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_update(dup, tailB, sizeof(tailB)) != 1;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_final(src, macA, &macASz, sizeof(macA)) != 1;
+    }
+    if (ret == 0) {
+        ret = EVP_MAC_final(dup, macB, &macBSz, sizeof(macB)) != 1;
+    }
+    if (ret == 0) {
+        if ((macASz != (size_t)expASz) || (memcmp(macA, expA, macASz) != 0)) {
+            PRINT_MSG("Duplicated source context MAC mismatch");
+            ret = -1;
+        }
+    }
+    if (ret == 0) {
+        if ((macBSz != (size_t)expBSz) || (memcmp(macB, expB, macBSz) != 0)) {
+            PRINT_MSG("Duplicated destination context MAC mismatch");
+            ret = -1;
+        }
+    }
+
+    EVP_MAC_CTX_free(dup);
+    EVP_MAC_CTX_free(src);
+    EVP_MAC_free(emac);
+
+    return ret;
+}
+
 #endif /* WP_HAVE_CMAC */