feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

refactor wolfcrypt constructors:

Browse Source 
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.
This commit is contained in:
Daniel Pouzzner
2024-10-17 18:48:07 -05:00
parent 61b726fae7
commit 984d16b727
12 changed files with 284 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
wolfcrypt/src/aes.c
View File

@ -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)

22
wolfcrypt/src/curve25519.c
View File

@ -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 */

25
wolfcrypt/src/ed25519.c
View File

@ -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;
}
}

41
wolfcrypt/src/hash.c
View File

@ -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;
}

22
wolfcrypt/src/rsa.c
View File

@ -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;
}

322
wolfcrypt/test/test.c
View File

@ -937,8 +937,8 @@ static void myFipsCb(int ok, int err, const char* hash)
#if defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
#ifndef NO_AES
static struct Aes *wc_AesNew(void *heap, int thisDevId) {
#if !defined(NO_AES) && !defined(WC_NO_CONSTRUCTORS)
static WC_MAYBE_UNUSED struct Aes *wc_AesNew(void *heap, int thisDevId) {
Aes* aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_AES);
if (aes != NULL) {
if (wc_AesInit(aes, heap, thisDevId) != 0) {
@ -948,10 +948,19 @@ static struct Aes *wc_AesNew(void *heap, int thisDevId) {
}
return aes;
}
#endif
static WC_MAYBE_UNUSED 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 /* !NO_AES && !WC_NO_CONSTRUCTORS */
#ifndef NO_RSA
static RsaKey* wc_NewRsaKey(void* heap, int thisDevId)
#if !defined(NO_RSA) && !defined(WC_NO_CONSTRUCTORS)
static WC_MAYBE_UNUSED RsaKey* wc_NewRsaKey(void* heap, int thisDevId)
{
RsaKey* key = (RsaKey*)XMALLOC(sizeof(RsaKey), heap, DYNAMIC_TYPE_RSA);
if (key != NULL) {
@ -962,11 +971,19 @@ static RsaKey* wc_NewRsaKey(void* heap, int thisDevId)
}
return key;
}
#endif
static WC_MAYBE_UNUSED 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 /* !NO_RSA && !WC_NO_CONSTRUCTORS */
#endif /* FIPS_VERSION3_LT(6,0,0) */
#ifdef WOLFSSL_STATIC_MEMORY
#if defined(WOLFSSL_STATIC_MEMORY_TEST_SZ)
static byte gTestMemory[WOLFSSL_STATIC_MEMORY_TEST_SZ];
@ -6039,7 +6056,6 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void)
ret = MEMORY_E;
return WC_TEST_RET_ENC_EC(ret);
}
hash->isAllocated = 0; /* free manually */
#else
XMEMSET(hash, 0, sizeof(wc_HashAlg));
#endif
@ -6320,10 +6336,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void)
#endif
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
if (hash != NULL) {
hash->isAllocated = 1; /* free manually */
(void)wc_HashFree(hash, hash->type);
}
(void)wc_HashDelete(&hash);
#endif
return 0;
@ -9545,16 +9558,18 @@ EVP_TEST_END:
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
#endif
#endif /* WOLFSSL_AES_256 */
@ -9873,14 +9888,16 @@ EVP_TEST_END:
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
@ -10133,14 +10150,16 @@ EVP_TEST_END:
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
@ -10343,14 +10362,16 @@ EVP_TEST_END:
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
@ -10486,9 +10507,10 @@ static wc_test_ret_t aes_key_size_test(void)
ret = 0; /* success */
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&aes);
#else
wc_AesFree(aes);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(aes, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -13526,14 +13548,16 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes_ctr_test(void)
#endif /* DEBUG_VECTOR_REGISTER_ACCESS && WC_C_DYNAMIC_FALLBACK */
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
return ret;
@ -14100,14 +14124,16 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes_cbc_test(void)
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
@ -14176,13 +14202,12 @@ static wc_test_ret_t aes_ecb_direct_test(void)
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
wc_AesDelete(&dec);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -14374,14 +14399,16 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes192_test(void)
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
#endif /* HAVE_AES_CBC */
@ -14579,14 +14606,16 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes256_test(void)
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#ifdef HAVE_AES_DECRYPT
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&dec);
#else
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#endif
#endif /* HAVE_AES_CBC */
@ -14714,13 +14743,12 @@ static wc_test_ret_t aesgcm_default_test_helper(byte* key, int keySz, byte* iv,
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
wc_AesDelete(&dec);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -15652,13 +15680,12 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
XFREE(large_outdec, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
#endif
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
wc_AesDelete(&dec);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
wc_AesFree(dec);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(dec, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -15877,9 +15904,10 @@ static wc_test_ret_t aesccm_256_test(void)
}
#endif
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&aes);
#else
wc_AesFree(aes);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(aes, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -16044,19 +16072,9 @@ static wc_test_ret_t aesccm_128_test(void)
XMEMSET(iv2, 0, sizeof(iv2));
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
enc = wc_AesNew(HEAP_HINT, devId);
if (enc == NULL)
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), out);
#else
XMEMSET(enc, 0, sizeof(Aes));
ret = wc_AesInit(enc, HEAP_HINT, devId);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
#endif
#ifndef HAVE_SELFTEST
/* selftest build does not have wc_AesCcmSetNonce() or
@ -16179,9 +16197,10 @@ static wc_test_ret_t aesccm_128_test(void)
out:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_AesDelete(&enc);
#else
wc_AesFree(enc);
#if defined(WOLFSSL_SMALL_STACK) && defined(HAVE_FIPS) && FIPS_VERSION3_LT(6,0,0)
XFREE(enc, HEAP_HINT, DYNAMIC_TYPE_AES);
#endif
return ret;
@ -21553,7 +21572,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), exit_rsa);
#endif
XMEMCPY(in, inStr, inLen);
@ -21561,25 +21580,32 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
key = wc_NewRsaKey(HEAP_HINT, devId);
if (key == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), exit_rsa);
#if defined(WOLFSSL_CERT_EXT) || defined(WOLFSSL_CERT_GEN)
keypub = wc_NewRsaKey(HEAP_HINT, devId);
if (keypub == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), exit_rsa);
#endif
#ifdef WOLFSSL_TEST_CERT
if (cert == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), exit_rsa);
#endif
#endif /* WOLFSSL_SMALL_STACK && !WOLFSSL_NO_MALLOC */
#else /* ! (WOLFSSL_SMALL_STACK && !WOLFSSL_NO_MALLOC) */
ret = wc_InitRsaKey_ex(key, HEAP_HINT, devId);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
#if defined(WOLFSSL_CERT_EXT) || defined(WOLFSSL_CERT_GEN)
ret = wc_InitRsaKey_ex(keypub, HEAP_HINT, devId);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
#endif
#endif /* ! (WOLFSSL_SMALL_STACK && !WOLFSSL_NO_MALLOC) */
/* initialize stack structures */
XMEMSET(&rng, 0, sizeof(rng));
/* memset also clears isAllocated bit, so free must be called manually */
XMEMSET(key, 0, sizeof(RsaKey));
#if defined(WOLFSSL_CERT_EXT) || defined(WOLFSSL_CERT_GEN)
XMEMSET(keypub, 0, sizeof(RsaKey));
#endif
#if !defined(NO_ASN)
ret = rsa_decode_test(key);
@ -21850,7 +21876,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
&& !defined(WOLF_CRYPTO_CB_ONLY_RSA)
ret = rsa_oaep_padding_test(key, &rng);
if (ret != 0)
return ret;
goto exit_rsa;
#endif /* !HAVE_FIPS */
#endif /* WC_NO_RSA_OAEP && !WC_NO_RNG */
@ -21860,14 +21886,14 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
&& !defined(WOLFSSL_RSA_VERIFY_ONLY)
ret = rsa_export_key_test(key);
if (ret != 0)
return ret;
goto exit_rsa;
#endif
#if !defined(NO_ASN) && !defined(WOLFSSL_RSA_PUBLIC_ONLY) && \
!defined(WOLFSSL_RSA_VERIFY_ONLY)
ret = rsa_flatten_test(key);
if (ret != 0)
return ret;
goto exit_rsa;
#endif
#if !defined(NO_FILESYSTEM) && !defined(NO_RSA) && !defined(NO_ASN) && \
@ -22130,16 +22156,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
exit_rsa:
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
if (key != NULL) {
wc_FreeRsaKey(key);
XFREE(key, HEAP_HINT, DYNAMIC_TYPE_RSA);
}
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_DeleteRsaKey(&key);
#if defined(WOLFSSL_CERT_EXT) || defined(WOLFSSL_CERT_GEN)
if (keypub != NULL) {
wc_FreeRsaKey(keypub);
XFREE(keypub, HEAP_HINT, DYNAMIC_TYPE_RSA);
}
wc_DeleteRsaKey(&keypub);
#endif
#ifdef WOLFSSL_TEST_CERT
XFREE(cert, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
@ -35059,21 +35079,12 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t curve25519_test(void)
(void)x;
WOLFSSL_ENTER("curve25519_test");
#ifndef HAVE_FIPS
ret = wc_InitRng_ex(&rng, HEAP_HINT, devId);
#else
ret = wc_InitRng(&rng);
#endif
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
userA = wc_curve25519_new(HEAP_HINT, devId);
userB = wc_curve25519_new(HEAP_HINT, devId);
pubKey = wc_curve25519_new(HEAP_HINT, devId);
if (userA == NULL || userB == NULL || pubKey == NULL) {
ret = MEMORY_E;
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(MEMORY_E), cleanup);
}
#else
wc_curve25519_init_ex(userA, HEAP_HINT, devId);
@ -35081,35 +35092,43 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t curve25519_test(void)
wc_curve25519_init_ex(pubKey, HEAP_HINT, devId);
#endif
#ifndef HAVE_FIPS
ret = wc_InitRng_ex(&rng, HEAP_HINT, devId);
#else
ret = wc_InitRng(&rng);
#endif
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
/* make curve25519 keys */
ret = wc_curve25519_make_key(&rng, 32, userA);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
ret = wc_curve25519_make_key(&rng, 32, userB);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
#ifdef HAVE_CURVE25519_SHARED_SECRET
/* find shared secret key */
x = sizeof(sharedA);
if ((ret = wc_curve25519_shared_secret(userA, userB, sharedA, &x)) != 0) {
printf("wc_curve25519_shared_secret 1 failed\n");
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
}
y = sizeof(sharedB);
if ((ret = wc_curve25519_shared_secret(userB, userA, sharedB, &y)) != 0) {
printf("wc_curve25519_shared_secret 2 failed\n");
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
}
/* compare shared secret keys to test they are the same */
if (y != x)
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
if (XMEMCMP(sharedA, sharedB, x))
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
#endif
#ifdef HAVE_CURVE25519_KEY_EXPORT
@ -35117,12 +35136,12 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t curve25519_test(void)
x = sizeof(exportBuf);
ret = wc_curve25519_export_public(userA, exportBuf, &x);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
#ifdef HAVE_CURVE25519_KEY_IMPORT
ret = wc_curve25519_import_public(exportBuf, x, pubKey);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
#endif
#endif
@ -35132,104 +35151,104 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t curve25519_test(void)
XMEMSET(sharedB, 0, sizeof(sharedB));
y = sizeof(sharedB);
if (wc_curve25519_shared_secret(userB, pubKey, sharedB, &y) != 0) {
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
}
if (XMEMCMP(sharedA, sharedB, y))
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
/* import RFC test vectors and compare shared key */
ret = wc_curve25519_import_private_raw(sa, sizeof(sa), pa, sizeof(pa),
userA);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
ret = wc_curve25519_import_private_raw(sb, sizeof(sb), pb, sizeof(pb),
userB);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
/* test against known test vector */
XMEMSET(sharedB, 0, sizeof(sharedB));
y = sizeof(sharedB);
ret = wc_curve25519_shared_secret(userA, userB, sharedB, &y);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
if (XMEMCMP(ss, sharedB, y))
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
/* test swapping roles of keys and generating same shared key */
XMEMSET(sharedB, 0, sizeof(sharedB));
y = sizeof(sharedB);
ret = wc_curve25519_shared_secret(userB, userA, sharedB, &y);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
if (XMEMCMP(ss, sharedB, y))
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
/* test with 1 generated key and 1 from known test vector */
ret = wc_curve25519_import_private_raw(sa, sizeof(sa), pa, sizeof(pa),
userA);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
wc_curve25519_free(userB);
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
userB = wc_curve25519_new(HEAP_HINT, devId);
if (userB == NULL) {
ret = MEMORY_E;
return WC_TEST_RET_ENC_EC(ret);
}
#else
wc_curve25519_init_ex(userB, HEAP_HINT, devId);
#endif
ret = wc_curve25519_make_key(&rng, 32, userB);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
x = sizeof(sharedA);
ret = wc_curve25519_shared_secret(userA, userB, sharedA, &x);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
y = sizeof(sharedB);
ret = wc_curve25519_shared_secret(userB, userA, sharedB, &y);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), cleanup);
/* compare shared secret keys to test they are the same */
if (y != x)
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
if (XMEMCMP(sharedA, sharedB, x))
return WC_TEST_RET_ENC_NC;
ERROR_OUT(WC_TEST_RET_ENC_NC, cleanup);
ret = curve25519_overflow_test();
if (ret != 0)
return ret;
goto cleanup;
ret = curve25519_check_public_test();
if (ret != 0)
return ret;
goto cleanup;
#endif /* HAVE_CURVE25519_SHARED_SECRET && HAVE_CURVE25519_KEY_IMPORT */
#if !defined(NO_ASN) && defined(HAVE_CURVE25519_KEY_EXPORT) && \
defined(HAVE_CURVE25519_KEY_IMPORT)
ret = curve255519_der_test();
if (ret != 0)
return ret;
goto cleanup;
#endif
cleanup:
/* clean up keys when done */
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_curve25519_delete(&pubKey);
wc_curve25519_delete(&userB);
wc_curve25519_delete(&userA);
#else
wc_curve25519_free(pubKey);
wc_curve25519_free(userB);
wc_curve25519_free(userA);
#endif
wc_FreeRng(&rng);
return 0;
return ret;
}
#endif /* HAVE_CURVE25519 */
@ -36387,15 +36406,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
#endif /* HAVE_ED25519_VERIFY */
wc_ed25519_free(key3);
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
key3 = wc_ed25519_new(HEAP_HINT, devId);
if (key3 == NULL) {
ret = MEMORY_E;
return WC_TEST_RET_ENC_EC(ret);
}
#else
wc_ed25519_init_ex(key3, HEAP_HINT, devId);
#endif
idx = 0;
ret = wc_Ed25519PrivateKeyDecode(privPubEd25519, &idx, key3,
@ -36410,13 +36421,22 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
if (XMEMCMP(out, sigs[0], 64))
return WC_TEST_RET_ENC_NC;
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_ed25519_delete(&key3);
#else
wc_ed25519_free(key3);
#endif
#endif /* NO_ASN */
#endif /* HAVE_ED25519_SIGN && HAVE_ED25519_KEY_EXPORT && HAVE_ED25519_KEY_IMPORT */
/* clean up keys when done */
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
wc_ed25519_delete(&key);
wc_ed25519_delete(&key2);
#else
wc_ed25519_free(key);
wc_ed25519_free(key2);
#endif
#if defined(HAVE_HASHDRBG) || defined(NO_RC4)
wc_FreeRng(&rng);

5
wolfssl/wolfcrypt/aes.h
View File

@ -726,8 +726,11 @@ WOLFSSL_API int wc_AesInit_Id(Aes* aes, unsigned char* id, int len, void* heap,
WOLFSSL_API int wc_AesInit_Label(Aes* aes, const char* label, void* heap,
int devId);
#endif
WOLFSSL_API Aes* wc_AesNew(void* heap, int devId);
WOLFSSL_API void wc_AesFree(Aes* aes);
#ifndef WC_NO_CONSTRUCTORS
WOLFSSL_API Aes* wc_AesNew(void* heap, int devId);
WOLFSSL_API int wc_AesDelete(Aes** aes);
#endif
#ifdef WOLFSSL_AES_SIV
typedef struct AesSivAssoc {

12
wolfssl/wolfcrypt/curve25519.h
View File

@ -99,7 +99,9 @@ struct curve25519_key {
/* bit fields */
WC_BITFIELD pubSet:1;
WC_BITFIELD privSet:1;
WC_BITFIELD isAllocated:1; /* flag indicates if structure was allocated */
#ifndef WC_NO_CONSTRUCTORS
WC_BITFIELD isAllocated:1;
#endif
};
enum {
@ -132,8 +134,6 @@ int wc_curve25519_shared_secret_ex(curve25519_key* private_key,
curve25519_key* public_key,
byte* out, word32* outlen, int endian);
WOLFSSL_API
curve25519_key* wc_curve25519_new(void* heap, int devId);
WOLFSSL_API
int wc_curve25519_init(curve25519_key* key);
WOLFSSL_API
@ -142,6 +142,12 @@ int wc_curve25519_init_ex(curve25519_key* key, void* heap, int devId);
WOLFSSL_API
void wc_curve25519_free(curve25519_key* key);
#ifndef WC_NO_CONSTRUCTORS
WOLFSSL_API
curve25519_key* wc_curve25519_new(void* heap, int devId);
WOLFSSL_API
int wc_curve25519_delete(curve25519_key** key);
#endif
/* raw key helpers */
WOLFSSL_API

12
wolfssl/wolfcrypt/ed25519.h
View File

@ -97,8 +97,9 @@ struct ed25519_key {
WC_BITFIELD privKeySet:1;
WC_BITFIELD pubKeySet:1;
WC_BITFIELD sha_clean_flag:1; /* only used if WOLFSSL_ED25519_PERSISTENT_SHA */
/* flag indicates if structure was allocated */
#ifndef WC_NO_CONSTRUCTORS
WC_BITFIELD isAllocated:1;
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV asyncDev;
#endif
@ -177,14 +178,19 @@ int wc_ed25519_verify_msg_final(const byte* sig, word32 sigLen, int* res,
#endif /* WOLFSSL_ED25519_STREAMING_VERIFY */
#endif /* HAVE_ED25519_VERIFY */
WOLFSSL_API
ed25519_key* wc_ed25519_new(void* heap, int devId);
WOLFSSL_API
int wc_ed25519_init(ed25519_key* key);
WOLFSSL_API
int wc_ed25519_init_ex(ed25519_key* key, void* heap, int devId);
WOLFSSL_API
void wc_ed25519_free(ed25519_key* key);
#ifndef WC_NO_CONSTRUCTORS
WOLFSSL_API
ed25519_key* wc_ed25519_new(void* heap, int devId);
WOLFSSL_API
int wc_ed25519_delete(ed25519_key** key);
#endif
#ifdef HAVE_ED25519_KEY_IMPORT
WOLFSSL_API
int wc_ed25519_import_public(const byte* in, word32 inLen, ed25519_key* key);

12
wolfssl/wolfcrypt/hash.h
View File

@ -125,7 +125,10 @@ typedef union {
typedef struct {
wc_Hashes alg;
enum wc_HashType type; /* sanity check */
WC_BITFIELD isAllocated:1; /* flag indicates if structure was allocated */
#ifndef WC_NO_CONSTRUCTORS
void *heap;
WC_BITFIELD isAllocated:1;
#endif
} wc_HashAlg;
#endif /* !NO_HASH_WRAPPER */
@ -182,8 +185,6 @@ WOLFSSL_API int wc_Hash_ex(enum wc_HashType hash_type,
byte* hash, word32 hash_len, void* heap, int devId);
/* generic hash operation wrappers */
WOLFSSL_API wc_HashAlg* wc_HashNew(enum wc_HashType type, void* heap,
int devId);
WOLFSSL_API int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type,
void* heap, int devId);
WOLFSSL_API int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type);
@ -192,6 +193,11 @@ WOLFSSL_API int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type,
WOLFSSL_API int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type,
byte* out);
WOLFSSL_API int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type);
#ifndef WC_NO_CONSTRUCTORS
WOLFSSL_API wc_HashAlg* wc_HashNew(enum wc_HashType type, void* heap,
int devId);
WOLFSSL_API int wc_HashDelete(wc_HashAlg **hash);
#endif
#ifdef WOLFSSL_HASH_FLAGS
WOLFSSL_API int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type,

10
wolfssl/wolfcrypt/rsa.h
View File

@ -269,7 +269,9 @@ struct RsaKey {
#if defined(WOLFSSL_RENESAS_FSPSM)
FSPSM_RSA_CTX ctx;
#endif
WC_BITFIELD isAllocated:1; /* flag indicates if structure was allocated */
#ifndef WC_NO_CONSTRUCTORS
WC_BITFIELD isAllocated:1;
#endif
};
#ifndef WC_RSAKEY_TYPE_DEFINED
@ -293,10 +295,14 @@ struct RsaPadding {
typedef struct RsaPadding RsaPadding;
#endif
WOLFSSL_API RsaKey* wc_NewRsaKey(void* heap, int devId);
WOLFSSL_API int wc_InitRsaKey(RsaKey* key, void* heap);
WOLFSSL_API int wc_InitRsaKey_ex(RsaKey* key, void* heap, int devId);
WOLFSSL_API int wc_FreeRsaKey(RsaKey* key);
#ifndef WC_NO_CONSTRUCTORS
WOLFSSL_API RsaKey* wc_NewRsaKey(void* heap, int devId);
WOLFSSL_API int wc_DeleteRsaKey(RsaKey** key);
#endif
#ifdef WOLF_PRIVATE_KEY_ID
WOLFSSL_API int wc_InitRsaKey_Id(RsaKey* key, unsigned char* id, int len,
void* heap, int devId);

6
wolfssl/wolfcrypt/types.h
View File

@ -522,6 +522,12 @@ typedef struct w64wrapper {
#elif defined(NO_WOLFSSL_MEMORY)
#ifdef WOLFSSL_NO_MALLOC
/* this platform does not support heap use */
#ifdef WOLFSSL_SMALL_STACK
#error WOLFSSL_SMALL_STACK requires a heap implementation.
#endif
#ifndef WC_NO_CONSTRUCTORS
#define WC_NO_CONSTRUCTORS
#endif
#ifdef WOLFSSL_MALLOC_CHECK
#ifndef NO_STDIO_FILESYSTEM
#include <stdio.h>