refactor wolfcrypt constructors:

add delete APIs, matching recently added wc_AesNew, wc_curve25519_new, wc_ed25519_new, wc_HashNew, and wc_NewRsaKey:
* wc_AesDelete()
* wc_HashDelete()
* wc_DeleteRsaKey()
* wc_curve25519_delete()
* wc_ed25519_delete()

* remove handling in corresponding preexisting free APIs for recently added .isAllocated member -- this restores preexisting semantics;

* add WC_NO_CONSTRUCTORS gate, and auto-activate it when NO_WOLFSSL_MEMORY && WOLFSSL_NO_MALLOC (unless preempted by XMALLOC_USER or XMALLOC_OVERRIDE);

* exclude recently added .isAllocated members from wolfcrypt structs when defined(WC_NO_CONSTRUCTORS);

* adjust wolfcrypt/test/test.c for consistency with the above, and fix cleanup codes/dynamics in several tests.

Author: douzzer

wolfcrypt/src/aes.c

@@ -11299,6 +11299,7 @@ int wc_AesCcmEncrypt_ex(Aes* aes, byte* out, const byte* in, word32 sz,
 
 #endif /* HAVE_AESCCM */
 
+#ifndef WC_NO_CONSTRUCTORS
 Aes* wc_AesNew(void* heap, int devId)
 {
     Aes* aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES);
@@ -11314,6 +11315,17 @@ Aes* wc_AesNew(void* heap, int devId)
     return aes;
 }
 
+int wc_AesDelete(Aes** aes)
+{
+    if ((aes == NULL) || (*aes == NULL))
+        return BAD_FUNC_ARG;
+    wc_AesFree(*aes);
+    XFREE(*aes, (*aes)->heap, DYNAMIC_TYPE_AES);
+    *aes = NULL;
+    return 0;
+}
+#endif /* !WC_NO_CONSTRUCTORS */
+
 /* Initialize Aes for use with async hardware */
 int wc_AesInit(Aes* aes, void* heap, int devId)
 {
@@ -11448,18 +11460,12 @@ int wc_AesInit_Label(Aes* aes, const char* label, void* heap, int devId)
 /* Free Aes from use with async hardware */
 void wc_AesFree(Aes* aes)
 {
-    void* heap;
-    byte isAllocated;
-
     if (aes == NULL) {
         return;
     }
 
-    heap = aes->heap;
-    isAllocated = aes->isAllocated;
-
 #ifdef WC_DEBUG_CIPHER_LIFECYCLE
-    (void)wc_debug_CipherLifecycleFree(&aes->CipherLifecycleTag, heap, 1);
+    (void)wc_debug_CipherLifecycleFree(&aes->CipherLifecycleTag, aes->heap, 1);
 #endif
 
 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_AES)
@@ -11497,7 +11503,7 @@ void wc_AesFree(Aes* aes)
 #endif
 #if defined(WOLFSSL_AESGCM_STREAM) && defined(WOLFSSL_SMALL_STACK) && \
     !defined(WOLFSSL_AESNI)
-    XFREE(aes->streamData, heap, DYNAMIC_TYPE_AES);
+    XFREE(aes->streamData, aes->heap, DYNAMIC_TYPE_AES);
     aes->streamData = NULL;
 #endif
 
@@ -11524,11 +11530,6 @@ void wc_AesFree(Aes* aes)
 #ifdef WOLFSSL_CHECK_MEM_ZERO
     wc_MemZero_Check(aes, sizeof(Aes));
 #endif
-
-    if (isAllocated) {
-        XFREE(aes, heap, DYNAMIC_TYPE_AES);
-    }
-
 }
 
 int wc_AesGetKeySize(Aes* aes, word32* keySize)

wolfcrypt/src/curve25519.c

@@ -655,6 +655,7 @@ int wc_curve25519_import_private_ex(const byte* priv, word32 privSz,
 
 #endif /* HAVE_CURVE25519_KEY_IMPORT */
 
+#ifndef WC_NO_CONSTRUCTORS
 curve25519_key* wc_curve25519_new(void* heap, int devId)
 {
     curve25519_key* key = (curve25519_key*)XMALLOC(sizeof(curve25519_key), heap,
@@ -671,6 +672,16 @@ curve25519_key* wc_curve25519_new(void* heap, int devId)
     return key;
 }
 
+int wc_curve25519_delete(curve25519_key** key) {
+    if ((key == NULL) || (*key == NULL))
+        return BAD_FUNC_ARG;
+    wc_curve25519_free(*key);
+    XFREE(*key, (*key)->heap, DYNAMIC_TYPE_CURVE25519);
+    *key = NULL;
+    return 0;
+}
+#endif /* !WC_NO_CONSTRUCTORS */
+
 int wc_curve25519_init_ex(curve25519_key* key, void* heap, int devId)
 {
     if (key == NULL)
@@ -707,15 +718,9 @@ int wc_curve25519_init(curve25519_key* key)
 /* Clean the memory of a key */
 void wc_curve25519_free(curve25519_key* key)
 {
-    void* heap;
-    byte isAllocated = 0;
-
     if (key == NULL)
        return;
 
-    heap = key->heap;
-    isAllocated = key->isAllocated;
-
 #ifdef WOLFSSL_SE050
     se050_curve25519_free_key(key);
 #endif
@@ -729,11 +734,6 @@ void wc_curve25519_free(curve25519_key* key)
 #ifdef WOLFSSL_CHECK_MEM_ZERO
     wc_MemZero_Check(key, sizeof(curve25519_key));
 #endif
-
-    if (isAllocated) {
-        XFREE(key, heap, DYNAMIC_TYPE_CURVE25519);
-        (void)heap;
-    }
 }
 
 /* get key size */

wolfcrypt/src/ed25519.c

@@ -968,7 +968,7 @@ int wc_ed25519ph_verify_msg(const byte* sig, word32 sigLen, const byte* msg,
 }
 #endif /* HAVE_ED25519_VERIFY */
 
-#ifndef WOLFSSL_NO_MALLOC
+#ifndef WC_NO_CONSTRUCTORS
 ed25519_key* wc_ed25519_new(void* heap, int devId)
 {
     ed25519_key* key = (ed25519_key*)XMALLOC(sizeof(ed25519_key), heap,
@@ -984,7 +984,16 @@ ed25519_key* wc_ed25519_new(void* heap, int devId)
     }
     return key;
 }
-#endif
+
+int wc_ed25519_delete(ed25519_key** key) {
+    if ((key == NULL) || (*key == NULL))
+        return BAD_FUNC_ARG;
+    wc_ed25519_free(*key);
+    XFREE(*key, (*key)->heap, DYNAMIC_TYPE_ED25519);
+    *key = NULL;
+    return 0;
+}
+#endif /* !WC_NO_CONSTRUCTORS */
 
 /* initialize information and memory for key */
 int wc_ed25519_init_ex(ed25519_key* key, void* heap, int devId)
@@ -1025,15 +1034,9 @@ int wc_ed25519_init(ed25519_key* key)
 /* clear memory of key */
 void wc_ed25519_free(ed25519_key* key)
 {
-    void* heap;
-    byte isAllocated = 0;
-
     if (key == NULL)
         return;
 
-    heap = key->heap;
-    isAllocated = key->isAllocated;
-
 #ifdef WOLFSSL_ED25519_PERSISTENT_SHA
     ed25519_hash_free(key, &key->sha);
 #endif
@@ -1046,12 +1049,6 @@ void wc_ed25519_free(ed25519_key* key)
 #ifdef WOLFSSL_CHECK_MEM_ZERO
     wc_MemZero_Check(key, sizeof(ed25519_key));
 #endif
-
-    if (isAllocated) {
-        XFREE(key, heap, DYNAMIC_TYPE_ED25519);
-        (void)heap;
-    }
-
 }
 
 

wolfcrypt/src/hash.c

@@ -686,7 +686,7 @@ int wc_Hash(enum wc_HashType hash_type, const byte* data,
         NULL, INVALID_DEVID);
 }
 
-#ifndef WOLFSSL_NO_MALLOC
+#ifndef WC_NO_CONSTRUCTORS
 wc_HashAlg* wc_HashNew(enum wc_HashType type, void* heap, int devId)
 {
     wc_HashAlg* hash = (wc_HashAlg*)XMALLOC(sizeof(wc_HashAlg), heap,
@@ -702,7 +702,19 @@ wc_HashAlg* wc_HashNew(enum wc_HashType type, void* heap, int devId)
     }
     return hash;
 }
-#endif
+
+int wc_HashDelete(wc_HashAlg **hash) {
+    int ret;
+    if ((hash == NULL) || (*hash == NULL))
+        return BAD_FUNC_ARG;
+    ret = wc_HashFree(*hash, (*hash)->type);
+    if (ret < 0)
+        return ret;
+    XFREE(*hash, (*hash)->heap, DYNAMIC_TYPE_HASHES);
+    *hash = NULL;
+    return 0;
+}
+#endif /* !WC_NO_CONSTRUCTORS */
 
 int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap,
     int devId)
@@ -712,9 +724,14 @@ int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap,
     if (hash == NULL)
         return BAD_FUNC_ARG;
 
-    hash->isAllocated = 0;
     hash->type = type;
 
+#ifdef WC_NO_CONSTRUCTORS
+    (void)heap;
+#else
+    hash->heap = heap;
+#endif
+
     switch (type) {
         case WC_HASH_TYPE_MD5:
 #ifndef NO_MD5
@@ -808,7 +825,6 @@ int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap,
             ret = BAD_FUNC_ARG;
     };
 
-    (void)heap;
     (void)devId;
 
     return ret;
@@ -1043,8 +1059,6 @@ int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
 int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
 {
     int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */
-    void* heap = NULL;
-    byte isAllocated = 0;
 
     if (hash == NULL)
         return BAD_FUNC_ARG;
@@ -1056,47 +1070,39 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
     }
 #endif
 
-    isAllocated = hash->isAllocated;
-
     switch (type) {
         case WC_HASH_TYPE_MD5:
 #ifndef NO_MD5
-            heap = hash->alg.md5.heap;
             wc_Md5Free(&hash->alg.md5);
             ret = 0;
 #endif
             break;
         case WC_HASH_TYPE_SHA:
 #ifndef NO_SHA
-            heap = hash->alg.sha.heap;
             wc_ShaFree(&hash->alg.sha);
             ret = 0;
 #endif
             break;
         case WC_HASH_TYPE_SHA224:
 #ifdef WOLFSSL_SHA224
-            heap = hash->alg.sha224.heap;
             wc_Sha224Free(&hash->alg.sha224);
             ret = 0;
 #endif
             break;
         case WC_HASH_TYPE_SHA256:
 #ifndef NO_SHA256
-            heap = hash->alg.sha256.heap;
             wc_Sha256Free(&hash->alg.sha256);
             ret = 0;
 #endif
             break;
         case WC_HASH_TYPE_SHA384:
 #ifdef WOLFSSL_SHA384
-            heap = hash->alg.sha384.heap;
             wc_Sha384Free(&hash->alg.sha384);
             ret = 0;
 #endif
             break;
         case WC_HASH_TYPE_SHA512:
 #ifdef WOLFSSL_SHA512
-            heap = hash->alg.sha512.heap;
             wc_Sha512Free(&hash->alg.sha512);
             ret = 0;
 #endif
@@ -1123,7 +1129,6 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
     #endif
         case WC_HASH_TYPE_SHA3_224:
 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
-            heap = hash->alg.sha3.heap;
             wc_Sha3_224_Free(&hash->alg.sha3);
             ret = 0;
 #endif
@@ -1149,7 +1154,6 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
 
     #ifdef WOLFSSL_SM3
         case WC_HASH_TYPE_SM3:
-            heap = hash->alg.sm3.heap;
             wc_Sm3Free(&hash->alg.sm3);
             ret = 0;
             break;
@@ -1172,11 +1176,6 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
             ret = BAD_FUNC_ARG;
     };
 
-    if (isAllocated) {
-        XFREE(hash, heap, DYNAMIC_TYPE_HASHES);
-        (void)heap;
-    }
-
     return ret;
 }
 

wolfcrypt/src/rsa.c

@@ -154,6 +154,7 @@ static void wc_RsaCleanup(RsaKey* key)
 #endif
 }
 
+#ifndef WC_NO_CONSTRUCTORS
 RsaKey* wc_NewRsaKey(void* heap, int devId)
 {
     RsaKey* key = (RsaKey*)XMALLOC(sizeof(RsaKey), heap, DYNAMIC_TYPE_RSA);
@@ -169,6 +170,17 @@ RsaKey* wc_NewRsaKey(void* heap, int devId)
     return key;
 }
 
+int wc_DeleteRsaKey(RsaKey** key)
+{
+    if ((key == NULL) || (*key == NULL))
+        return BAD_FUNC_ARG;
+    wc_FreeRsaKey(*key);
+    XFREE(*key, (*key)->heap, DYNAMIC_TYPE_RSA);
+    *key = NULL;
+    return 0;
+}
+#endif /* !WC_NO_CONSTRUCTORS */
+
 int wc_InitRsaKey_ex(RsaKey* key, void* heap, int devId)
 {
     int ret = 0;
@@ -542,16 +554,11 @@ int wc_RsaGetKeyId(RsaKey* key, word32* keyId)
 int wc_FreeRsaKey(RsaKey* key)
 {
     int ret = 0;
-    void* heap;
-    byte isAllocated = 0;
 
     if (key == NULL) {
         return BAD_FUNC_ARG;
     }
 
-    heap = key->heap;
-    isAllocated = key->isAllocated;
-
     wc_RsaCleanup(key);
 
 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_RSA)
@@ -615,11 +622,6 @@ int wc_FreeRsaKey(RsaKey* key)
     wc_fspsm_RsaKeyFree(key);
 #endif
 
-    if (isAllocated) {
-        XFREE(key, heap, DYNAMIC_TYPE_RSA);
-        (void)heap;
-    }
-
     return ret;
 }