wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-07-30 02:37:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add WC_ namespace to variable handling defines

Browse Source
This commit is contained in:
Juliusz Sosinowicz
2021-12-17 17:54:28 +01:00
parent bd515cd3a6
commit 8435eb4644
7 changed files with 182 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/tls.c
View File

@ -195,7 +195,7 @@ int BuildTlsFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
const byte* side;
word32 hashSz = HSHASH_SZ;
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
DECLARE_VAR(handshake_hash, byte, HSHASH_SZ, ssl->heap);
WC_DECLARE_VAR(handshake_hash, byte, HSHASH_SZ, ssl->heap);
if (handshake_hash == NULL)
return MEMORY_E;
#else
@ -245,7 +245,7 @@ int BuildTlsFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
}
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(handshake_hash, ssl->heap);
WC_FREE_VAR(handshake_hash, ssl->heap);
#endif
return ret;
@ -324,7 +324,7 @@ static int _DeriveTlsKeys(byte* key_dig, word32 key_dig_len,
{
int ret;
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
DECLARE_VAR(seed, byte, SEED_LEN, heap);
WC_DECLARE_VAR(seed, byte, SEED_LEN, heap);
if (seed == NULL)
return MEMORY_E;
#else
@ -360,7 +360,7 @@ static int _DeriveTlsKeys(byte* key_dig, word32 key_dig_len,
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(seed, heap);
WC_FREE_VAR(seed, heap);
#endif
return ret;
@ -436,7 +436,7 @@ static int _MakeTlsMasterSecret(byte* ms, word32 msLen,
{
int ret;
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
DECLARE_VAR(seed, byte, SEED_LEN, heap);
WC_DECLARE_VAR(seed, byte, SEED_LEN, heap);
if (seed == NULL)
return MEMORY_E;
#else
@ -467,7 +467,7 @@ static int _MakeTlsMasterSecret(byte* ms, word32 msLen,
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(seed, heap);
WC_FREE_VAR(seed, heap);
#endif
return ret;

42
tests/api.c
View File

@ -19259,11 +19259,11 @@ static int test_wc_RsaPublicEncryptDecrypt (void)
const word32 cipherLen = TEST_RSA_BYTES;
word32 cipherLenResult = cipherLen;
DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || plain == NULL || cipher == NULL) {
printf("test_wc_RsaPublicEncryptDecrypt malloc failed\n");
return MEMORY_E;
@ -19316,9 +19316,9 @@ static int test_wc_RsaPublicEncryptDecrypt (void)
/* Pass in bad args. */
/* Tests RsaPrivateDecryptEx() which, is tested by another fn. No need dup.*/
FREE_VAR(in, NULL);
FREE_VAR(plain, NULL);
FREE_VAR(cipher, NULL);
WC_FREE_VAR(in, NULL);
WC_FREE_VAR(plain, NULL);
WC_FREE_VAR(cipher, NULL);
if (wc_FreeRsaKey(&key) || ret != 0) {
ret = WOLFSSL_FATAL_ERROR;
}
@ -19352,11 +19352,11 @@ static int test_wc_RsaPublicEncryptDecrypt_ex (void)
int bits = TEST_RSA_BITS;
const word32 cipherSz = TEST_RSA_BYTES;
DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || plain == NULL || cipher == NULL) {
printf("test_wc_RsaPublicEncryptDecrypt_exmalloc failed\n");
return MEMORY_E;
@ -19439,9 +19439,9 @@ static int test_wc_RsaPublicEncryptDecrypt_ex (void)
}
#endif
FREE_VAR(in, NULL);
FREE_VAR(plain, NULL);
FREE_VAR(cipher, NULL);
WC_FREE_VAR(in, NULL);
WC_FREE_VAR(plain, NULL);
WC_FREE_VAR(cipher, NULL);
if (wc_FreeRsaKey(&key) || ret != 0) {
ret = WOLFSSL_FATAL_ERROR;
}
@ -19472,11 +19472,11 @@ static int test_wc_RsaSSL_SignVerify (void)
int bits = TEST_RSA_BITS;
const word32 outSz = TEST_RSA_BYTES;
DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
DECLARE_VAR(out, byte, TEST_RSA_BYTES, NULL);
DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(out, byte, TEST_RSA_BYTES, NULL);
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL) {
printf("test_wc_RsaSSL_SignVerify failed\n");
return MEMORY_E;
@ -19600,9 +19600,9 @@ static int test_wc_RsaSSL_SignVerify (void)
}
#endif
FREE_VAR(in, NULL);
FREE_VAR(out, NULL);
FREE_VAR(plain, NULL);
WC_FREE_VAR(in, NULL);
WC_FREE_VAR(out, NULL);
WC_FREE_VAR(plain, NULL);
if (wc_FreeRsaKey(&key) || ret != 0) {
ret = WOLFSSL_FATAL_ERROR;
}

116
wolfcrypt/benchmark/benchmark.c
View File

@ -2610,9 +2610,9 @@ static void bench_aesgcm_internal(int doAsync, const byte* key, word32 keySz,
#endif
double start;
DECLARE_VAR(bench_additional, byte, AES_AUTH_ADD_SZ, HEAP_HINT);
DECLARE_VAR(bench_tag, byte, AES_AUTH_TAG_SZ, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
WC_DECLARE_VAR(bench_additional, byte, AES_AUTH_ADD_SZ, HEAP_HINT);
WC_DECLARE_VAR(bench_tag, byte, AES_AUTH_TAG_SZ, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (bench_additional == NULL || bench_tag == NULL) {
printf("bench_aesgcm_internal malloc failed\n");
goto exit;
@ -2754,8 +2754,8 @@ exit:
wc_AesFree(&enc[i]);
}
FREE_VAR(bench_additional, HEAP_HINT);
FREE_VAR(bench_tag, HEAP_HINT);
WC_FREE_VAR(bench_additional, HEAP_HINT);
WC_FREE_VAR(bench_tag, HEAP_HINT);
}
void bench_aesgcm(int doAsync)
@ -3122,10 +3122,10 @@ void bench_aesccm(void)
double start;
int ret, i, count;
DECLARE_VAR(bench_additional, byte, AES_AUTH_ADD_SZ, HEAP_HINT);
DECLARE_VAR(bench_tag, byte, AES_AUTH_TAG_SZ, HEAP_HINT);
WC_DECLARE_VAR(bench_additional, byte, AES_AUTH_ADD_SZ, HEAP_HINT);
WC_DECLARE_VAR(bench_tag, byte, AES_AUTH_TAG_SZ, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (bench_additional == NULL || bench_tag == NULL) {
printf("bench_aesccm malloc failed\n");
goto exit;
@ -3164,8 +3164,8 @@ void bench_aesccm(void)
exit:
FREE_VAR(bench_additional, HEAP_HINT);
FREE_VAR(bench_tag, HEAP_HINT);
WC_FREE_VAR(bench_additional, HEAP_HINT);
WC_FREE_VAR(bench_tag, HEAP_HINT);
}
#endif /* HAVE_AESCCM */
#endif /* !NO_AES */
@ -3485,7 +3485,7 @@ void bench_md5(int doAsync)
wc_Md5 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_MD5_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_MD5_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3561,7 +3561,7 @@ exit:
}
#endif
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* !NO_MD5 */
@ -3572,7 +3572,7 @@ void bench_sha(int doAsync)
wc_Sha hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3646,7 +3646,7 @@ exit:
wc_ShaFree(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* NO_SHA */
@ -3657,7 +3657,7 @@ void bench_sha224(int doAsync)
wc_Sha224 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA224_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA224_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3727,7 +3727,7 @@ exit:
wc_Sha224Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif
@ -3737,7 +3737,7 @@ void bench_sha256(int doAsync)
wc_Sha256 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA256_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA256_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3810,7 +3810,7 @@ exit:
wc_Sha256Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif
@ -3820,7 +3820,7 @@ void bench_sha384(int doAsync)
wc_Sha384 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA384_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA384_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3890,7 +3890,7 @@ exit:
wc_Sha384Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif
@ -3900,7 +3900,7 @@ void bench_sha512(int doAsync)
wc_Sha512 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA512_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA512_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -3970,7 +3970,7 @@ exit:
wc_Sha512Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif
@ -3982,7 +3982,7 @@ void bench_sha3_224(int doAsync)
wc_Sha3 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_224_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_224_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -4052,7 +4052,7 @@ exit:
wc_Sha3_224_Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* WOLFSSL_NOSHA3_224 */
@ -4062,7 +4062,7 @@ void bench_sha3_256(int doAsync)
wc_Sha3 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_256_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_256_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -4132,7 +4132,7 @@ exit:
wc_Sha3_256_Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* WOLFSSL_NOSHA3_256 */
@ -4142,7 +4142,7 @@ void bench_sha3_384(int doAsync)
wc_Sha3 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_384_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_384_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -4212,7 +4212,7 @@ exit:
wc_Sha3_384_Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* WOLFSSL_NOSHA3_384 */
@ -4222,7 +4222,7 @@ void bench_sha3_512(int doAsync)
wc_Sha3 hash[BENCH_MAX_PENDING];
double start;
int ret = 0, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_512_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA3_512_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -4292,7 +4292,7 @@ exit:
wc_Sha3_512_Free(&hash[i]);
}
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* WOLFSSL_NOSHA3_512 */
#endif
@ -4557,7 +4557,7 @@ static void bench_hmac(int doAsync, int type, int digestSz,
double start;
int ret = 0, i, count = 0, times, pending = 0;
#ifdef WOLFSSL_ASYNC_CRYPT
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_MAX_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_MAX_DIGEST_SIZE, HEAP_HINT);
#else
byte digest[BENCH_MAX_PENDING][WC_MAX_DIGEST_SIZE];
#endif
@ -4628,7 +4628,7 @@ exit:
}
#ifdef WOLFSSL_ASYNC_CRYPT
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
#endif
}
@ -4938,18 +4938,18 @@ static void bench_rsa_helper(int doAsync, RsaKey rsaKey[BENCH_MAX_PENDING],
double start = 0.0f;
const char**desc = bench_desc_words[lng_index];
#ifndef WOLFSSL_RSA_VERIFY_ONLY
DECLARE_VAR(message, byte, TEST_STRING_SZ, HEAP_HINT);
WC_DECLARE_VAR(message, byte, TEST_STRING_SZ, HEAP_HINT);
#endif
#if !defined(WOLFSSL_MDK5_COMPLv5) && !defined(_WIN32_WCE)
/* MDK5 compiler regard this as a executable statement, and does not allow declarations after the line. */
DECLARE_ARRAY_DYNAMIC_DEC(enc, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
WC_DECLARE_ARRAY_DYNAMIC_DEC(enc, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
#else
byte* enc[BENCH_MAX_PENDING];
#endif
#if !defined(WOLFSSL_RSA_VERIFY_INLINE) && !defined(WOLFSSL_RSA_PUBLIC_ONLY)
#if !defined(WOLFSSL_MDK5_COMPLv5) && !defined(_WIN32_WCE)
/* MDK5 compiler regard this as a executable statement, and does not allow declarations after the line. */
DECLARE_ARRAY_DYNAMIC_DEC(out, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
WC_DECLARE_ARRAY_DYNAMIC_DEC(out, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
#else
byte* out[BENCH_MAX_PENDING];
#endif
@ -4957,9 +4957,9 @@ static void bench_rsa_helper(int doAsync, RsaKey rsaKey[BENCH_MAX_PENDING],
byte* out[BENCH_MAX_PENDING];
#endif
DECLARE_ARRAY_DYNAMIC_EXE(enc, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
WC_DECLARE_ARRAY_DYNAMIC_EXE(enc, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
#if !defined(WOLFSSL_RSA_VERIFY_INLINE) && !defined(WOLFSSL_RSA_PUBLIC_ONLY)
DECLARE_ARRAY_DYNAMIC_EXE(out, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
WC_DECLARE_ARRAY_DYNAMIC_EXE(out, byte, BENCH_MAX_PENDING, rsaKeySz, HEAP_HINT);
if (out[0] == NULL) {
ret = MEMORY_E;
goto exit;
@ -4969,7 +4969,7 @@ static void bench_rsa_helper(int doAsync, RsaKey rsaKey[BENCH_MAX_PENDING],
ret = MEMORY_E;
goto exit;
}
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (message == NULL) {
ret = MEMORY_E;
goto exit;
@ -5127,11 +5127,11 @@ exit_rsa_verifyinline:
exit:
FREE_ARRAY_DYNAMIC(enc, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY_DYNAMIC(enc, BENCH_MAX_PENDING, HEAP_HINT);
#if !defined(WOLFSSL_RSA_VERIFY_INLINE) && !defined(WOLFSSL_RSA_PUBLIC_ONLY)
FREE_ARRAY_DYNAMIC(out, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY_DYNAMIC(out, BENCH_MAX_PENDING, HEAP_HINT);
#endif
FREE_VAR(message, HEAP_HINT);
WC_FREE_VAR(message, HEAP_HINT);
}
void bench_rsa(int doAsync)
@ -5335,12 +5335,12 @@ void bench_dh(int doAsync)
#endif
#endif
DECLARE_ARRAY(pub, byte, BENCH_MAX_PENDING, BENCH_DH_KEY_SIZE, HEAP_HINT);
DECLARE_VAR(pub2, byte, BENCH_DH_KEY_SIZE, HEAP_HINT);
DECLARE_ARRAY(agree, byte, BENCH_MAX_PENDING, BENCH_DH_KEY_SIZE, HEAP_HINT);
DECLARE_ARRAY(priv, byte, BENCH_MAX_PENDING, BENCH_DH_PRIV_SIZE, HEAP_HINT);
DECLARE_VAR(priv2, byte, BENCH_DH_PRIV_SIZE, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
WC_DECLARE_ARRAY(pub, byte, BENCH_MAX_PENDING, BENCH_DH_KEY_SIZE, HEAP_HINT);
WC_DECLARE_VAR(pub2, byte, BENCH_DH_KEY_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(agree, byte, BENCH_MAX_PENDING, BENCH_DH_KEY_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(priv, byte, BENCH_MAX_PENDING, BENCH_DH_PRIV_SIZE, HEAP_HINT);
WC_DECLARE_VAR(priv2, byte, BENCH_DH_PRIV_SIZE, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (pub[0] == NULL || pub2 == NULL || agree[0] == NULL || priv[0] == NULL || priv2 == NULL) {
ret = MEMORY_E;
goto exit;
@ -5506,11 +5506,11 @@ exit:
wc_FreeDhKey(&dhKey[i]);
}
FREE_ARRAY(pub, BENCH_MAX_PENDING, HEAP_HINT);
FREE_VAR(pub2, HEAP_HINT);
FREE_ARRAY(priv, BENCH_MAX_PENDING, HEAP_HINT);
FREE_VAR(priv2, HEAP_HINT);
FREE_ARRAY(agree, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(pub, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_VAR(pub2, HEAP_HINT);
WC_FREE_ARRAY(priv, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_VAR(priv2, HEAP_HINT);
WC_FREE_ARRAY(agree, BENCH_MAX_PENDING, HEAP_HINT);
}
#endif /* !NO_DH */
@ -5630,11 +5630,11 @@ void bench_ecc(int doAsync, int curveId)
const char**desc = bench_desc_words[lng_index];
#ifdef HAVE_ECC_DHE
DECLARE_ARRAY(shared, byte, BENCH_MAX_PENDING, MAX_ECC_BYTES, HEAP_HINT);
WC_DECLARE_ARRAY(shared, byte, BENCH_MAX_PENDING, MAX_ECC_BYTES, HEAP_HINT);
#endif
#if !defined(NO_ASN) && defined(HAVE_ECC_SIGN)
DECLARE_ARRAY(sig, byte, BENCH_MAX_PENDING, ECC_MAX_SIG_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, MAX_ECC_BYTES, HEAP_HINT);
WC_DECLARE_ARRAY(sig, byte, BENCH_MAX_PENDING, ECC_MAX_SIG_SIZE, HEAP_HINT);
WC_DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, MAX_ECC_BYTES, HEAP_HINT);
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
@ -5808,11 +5808,11 @@ exit:
}
#ifdef HAVE_ECC_DHE
FREE_ARRAY(shared, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(shared, BENCH_MAX_PENDING, HEAP_HINT);
#endif
#if !defined(NO_ASN) && defined(HAVE_ECC_SIGN)
FREE_ARRAY(sig, BENCH_MAX_PENDING, HEAP_HINT);
FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(sig, BENCH_MAX_PENDING, HEAP_HINT);
WC_FREE_ARRAY(digest, BENCH_MAX_PENDING, HEAP_HINT);
#endif
(void)doAsync;

12
wolfcrypt/src/kdf.c
View File

@ -223,7 +223,7 @@ int wc_PRF_TLSv1(byte* digest, word32 digLen, const byte* secret,
byte sha_result[MAX_PRF_DIG]; /* digLen is real size */
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
WC_DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
if (labelSeed == NULL)
return MEMORY_E;
#else
@ -235,7 +235,7 @@ int wc_PRF_TLSv1(byte* digest, word32 digLen, const byte* secret,
digLen > MAX_PRF_DIG)
{
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(labelSeed, heap);
WC_FREE_VAR(labelSeed, heap);
#endif
return BUFFER_E;
}
@ -253,7 +253,7 @@ int wc_PRF_TLSv1(byte* digest, word32 digLen, const byte* secret,
if (md5_result) XFREE(md5_result, heap, DYNAMIC_TYPE_DIGEST);
if (sha_result) XFREE(sha_result, heap, DYNAMIC_TYPE_DIGEST);
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(labelSeed, heap);
WC_FREE_VAR(labelSeed, heap);
#endif
return MEMORY_E;
@ -287,7 +287,7 @@ int wc_PRF_TLSv1(byte* digest, word32 digLen, const byte* secret,
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(labelSeed, heap);
WC_FREE_VAR(labelSeed, heap);
#endif
return ret;
@ -303,7 +303,7 @@ int wc_PRF_TLS(byte* digest, word32 digLen, const byte* secret, word32 secLen,
if (useAtLeastSha256) {
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
WC_DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
if (labelSeed == NULL)
return MEMORY_E;
#else
@ -325,7 +325,7 @@ int wc_PRF_TLS(byte* digest, word32 digLen, const byte* secret, word32 secLen,
labLen + seedLen, hash_type, heap, devId);
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
FREE_VAR(labelSeed, heap);
WC_FREE_VAR(labelSeed, heap);
#endif
}
else {

16
wolfcrypt/src/random.c
View File

@ -351,7 +351,7 @@ static int Hash_df(DRBG_internal* drbg, byte* out, word32 outSz, byte type,
wc_Sha256 sha[1];
#endif
#ifdef WC_ASYNC_ENABLE_SHA256
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
WC_DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
if (digest == NULL)
return MEMORY_E;
#else
@ -419,7 +419,7 @@ static int Hash_df(DRBG_internal* drbg, byte* out, word32 outSz, byte type,
ForceZero(digest, WC_SHA256_DIGEST_SIZE);
#ifdef WC_ASYNC_ENABLE_SHA256
FREE_VAR(digest, drbg->heap);
WC_FREE_VAR(digest, drbg->heap);
#endif
return (ret == 0) ? DRBG_SUCCESS : DRBG_FAILURE;
@ -486,7 +486,7 @@ static int Hash_gen(DRBG_internal* drbg, byte* out, word32 outSz, const byte* V)
wc_Sha256 sha[1];
#endif
#ifdef WC_ASYNC_ENABLE_SHA256
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
WC_DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
if (digest == NULL)
return MEMORY_E;
#else
@ -556,7 +556,7 @@ static int Hash_gen(DRBG_internal* drbg, byte* out, word32 outSz, const byte* V)
ForceZero(data, sizeof(data));
#ifdef WC_ASYNC_ENABLE_SHA256
FREE_VAR(digest, drbg->heap);
WC_FREE_VAR(digest, drbg->heap);
#endif
return (ret == 0) ? DRBG_SUCCESS : DRBG_FAILURE;
@ -601,7 +601,7 @@ static int Hash_DRBG_Generate(DRBG_internal* drbg, byte* out, word32 outSz)
return DRBG_NEED_RESEED;
} else {
#ifdef WC_ASYNC_ENABLE_SHA256
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
WC_DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
if (digest == NULL)
return MEMORY_E;
#else
@ -644,7 +644,7 @@ static int Hash_DRBG_Generate(DRBG_internal* drbg, byte* out, word32 outSz)
}
ForceZero(digest, WC_SHA256_DIGEST_SIZE);
#ifdef WC_ASYNC_ENABLE_SHA256
FREE_VAR(digest, drbg->heap);
WC_FREE_VAR(digest, drbg->heap);
#endif
}
@ -801,7 +801,7 @@ static int _InitRng(WC_RNG* rng, byte* nonce, word32 nonceSz,
if (wc_RNG_HealthTestLocal(0) == 0) {
#ifdef WC_ASYNC_ENABLE_SHA256
DECLARE_VAR(seed, byte, MAX_SEED_SZ, rng->heap);
WC_DECLARE_VAR(seed, byte, MAX_SEED_SZ, rng->heap);
if (seed == NULL)
return MEMORY_E;
#else
@ -855,7 +855,7 @@ static int _InitRng(WC_RNG* rng, byte* nonce, word32 nonceSz,
ForceZero(seed, seedSz);
#ifdef WC_ASYNC_ENABLE_SHA256
FREE_VAR(seed, rng->heap);
WC_FREE_VAR(seed, rng->heap);
#endif
}
else

108
wolfcrypt/test/test.c
View File

@ -13622,11 +13622,11 @@ static int rsa_pss_test(WC_RNG* rng, RsaKey* key)
#endif
};
DECLARE_VAR(in, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(sig, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(in, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(sig, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || sig == NULL)
ERROR_OUT(MEMORY_E, exit_rsa_pss);
#endif
@ -13903,9 +13903,9 @@ static int rsa_pss_test(WC_RNG* rng, RsaKey* key)
ret = 0;
exit_rsa_pss:
FREE_VAR(sig, HEAP_HINT);
FREE_VAR(in, HEAP_HINT);
FREE_VAR(out, HEAP_HINT);
WC_FREE_VAR(sig, HEAP_HINT);
WC_FREE_VAR(in, HEAP_HINT);
WC_FREE_VAR(out, HEAP_HINT);
return ret;
}
@ -13928,11 +13928,11 @@ WOLFSSL_TEST_SUBROUTINE int rsa_no_pad_test(void)
!defined(NO_FILESYSTEM)
XFILE file;
#endif
DECLARE_VAR(key, RsaKey, 1, HEAP_HINT);
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(key, RsaKey, 1, HEAP_HINT);
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (key == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa_nopadding);
#endif
@ -14128,9 +14128,9 @@ WOLFSSL_TEST_SUBROUTINE int rsa_no_pad_test(void)
exit_rsa_nopadding:
wc_FreeRsaKey(key);
XFREE(tmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
FREE_VAR(key, HEAP_HINT);
FREE_VAR(out, HEAP_HINT);
FREE_VAR(plain, HEAP_HINT);
WC_FREE_VAR(key, HEAP_HINT);
WC_FREE_VAR(out, HEAP_HINT);
WC_FREE_VAR(plain, HEAP_HINT);
wc_FreeRng(&rng);
return ret;
@ -14155,11 +14155,11 @@ static int rsa_even_mod_test(WC_RNG* rng, RsaKey* key)
!defined(USE_CERT_BUFFERS_4096) && !defined(NO_FILESYSTEM)
XFILE file;
#endif
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#endif
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (out == NULL
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
|| plain == NULL
@ -14285,9 +14285,9 @@ static int rsa_even_mod_test(WC_RNG* rng, RsaKey* key)
exit_rsa_even_mod:
XFREE(tmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
FREE_VAR(out, HEAP_HINT);
WC_FREE_VAR(out, HEAP_HINT);
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
FREE_VAR(plain, HEAP_HINT);
WC_FREE_VAR(plain, HEAP_HINT);
#endif
(void)out;
@ -14981,18 +14981,18 @@ static int rsa_oaep_padding_test(RsaKey* key, WC_RNG* rng)
const word32 plainSz = RSA_TEST_BYTES;
byte* res = NULL;
DECLARE_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
#endif
XMEMCPY(in, inStr, inLen);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
#endif
@ -15298,9 +15298,9 @@ static int rsa_oaep_padding_test(RsaKey* key, WC_RNG* rng)
#endif /* WOLFSSL_RSA_PUBLIC_ONLY */
exit_rsa:
FREE_VAR(in, HEAP_HINT);
FREE_VAR(out, HEAP_HINT);
FREE_VAR(plain, HEAP_HINT);
WC_FREE_VAR(in, HEAP_HINT);
WC_FREE_VAR(out, HEAP_HINT);
WC_FREE_VAR(plain, HEAP_HINT);
(void)idx;
(void)inStr;
@ -15365,11 +15365,11 @@ WOLFSSL_TEST_SUBROUTINE int rsa_test(void)
#endif
#endif
DECLARE_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
#endif
@ -15963,9 +15963,9 @@ exit_rsa:
XFREE(tmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
wc_FreeRng(&rng);
FREE_VAR(in, HEAP_HINT);
FREE_VAR(out, HEAP_HINT);
FREE_VAR(plain, HEAP_HINT);
WC_FREE_VAR(in, HEAP_HINT);
WC_FREE_VAR(out, HEAP_HINT);
WC_FREE_VAR(plain, HEAP_HINT);
(void)res;
(void)bytes;
@ -20834,15 +20834,15 @@ static int ecc_test_vector_item(const eccVector* vector)
#else
ecc_key userA[1];
#endif
DECLARE_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_DECLARE_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
#if !defined(NO_ASN) && !defined(HAVE_SELFTEST)
word32 sigRawSz, rSz = MAX_ECC_BYTES, sSz = MAX_ECC_BYTES;
DECLARE_VAR(sigRaw, byte, ECC_SIG_SIZE, HEAP_HINT);
DECLARE_VAR(r, byte, MAX_ECC_BYTES, HEAP_HINT);
DECLARE_VAR(s, byte, MAX_ECC_BYTES, HEAP_HINT);
WC_DECLARE_VAR(sigRaw, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_DECLARE_VAR(r, byte, MAX_ECC_BYTES, HEAP_HINT);
WC_DECLARE_VAR(s, byte, MAX_ECC_BYTES, HEAP_HINT);
#endif
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (sig == NULL)
ERROR_OUT(MEMORY_E, done);
#if !defined(NO_ASN) && !defined(HAVE_SELFTEST)
@ -20920,11 +20920,11 @@ done:
#endif
#if !defined(NO_ASN) && !defined(HAVE_SELFTEST)
FREE_VAR(sigRaw, HEAP_HINT);
FREE_VAR(r, HEAP_HINT);
FREE_VAR(s, HEAP_HINT);
WC_FREE_VAR(sigRaw, HEAP_HINT);
WC_FREE_VAR(r, HEAP_HINT);
WC_FREE_VAR(s, HEAP_HINT);
#endif
FREE_VAR(sig, HEAP_HINT);
WC_FREE_VAR(sig, HEAP_HINT);
return ret;
}
@ -21928,12 +21928,12 @@ static int ecc_test_curve_size(WC_RNG* rng, int keySize, int testVerifyCount,
{
#if (defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)) && !defined(WC_NO_RNG) && \
!defined(WOLFSSL_ATECC508A) && !defined(WOLFSSL_ATECC608A)
DECLARE_VAR(sharedA, byte, ECC_SHARED_SIZE, HEAP_HINT);
DECLARE_VAR(sharedB, byte, ECC_SHARED_SIZE, HEAP_HINT);
WC_DECLARE_VAR(sharedA, byte, ECC_SHARED_SIZE, HEAP_HINT);
WC_DECLARE_VAR(sharedB, byte, ECC_SHARED_SIZE, HEAP_HINT);
#endif
#ifdef HAVE_ECC_KEY_EXPORT
#define ECC_KEY_EXPORT_BUF_SIZE (MAX_ECC_BYTES * 2 + 32)
DECLARE_VAR(exportBuf, byte, ECC_KEY_EXPORT_BUF_SIZE, HEAP_HINT);
WC_DECLARE_VAR(exportBuf, byte, ECC_KEY_EXPORT_BUF_SIZE, HEAP_HINT);
#endif
word32 x = 0;
#if (defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)) && !defined(WC_NO_RNG) && \
@ -21941,8 +21941,8 @@ static int ecc_test_curve_size(WC_RNG* rng, int keySize, int testVerifyCount,
word32 y;
#endif
#ifdef HAVE_ECC_SIGN
DECLARE_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
DECLARE_VAR(digest, byte, ECC_DIGEST_SIZE, HEAP_HINT);
WC_DECLARE_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_DECLARE_VAR(digest, byte, ECC_DIGEST_SIZE, HEAP_HINT);
int i;
#ifdef HAVE_ECC_VERIFY
int verify;
@ -21962,7 +21962,7 @@ static int ecc_test_curve_size(WC_RNG* rng, int keySize, int testVerifyCount,
int curveSize;
#endif
#ifdef DECLARE_VAR_IS_HEAP_ALLOC
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
#if (defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)) && !defined(WC_NO_RNG) && \
!defined(WOLFSSL_ATECC508A) && !defined(WOLFSSL_ATECC608A)
if (sharedA == NULL || sharedB == NULL)
@ -22336,15 +22336,15 @@ done:
#endif
#if defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)
FREE_VAR(sharedA, HEAP_HINT);
FREE_VAR(sharedB, HEAP_HINT);
WC_FREE_VAR(sharedA, HEAP_HINT);
WC_FREE_VAR(sharedB, HEAP_HINT);
#endif
#ifdef HAVE_ECC_KEY_EXPORT
FREE_VAR(exportBuf, HEAP_HINT);
WC_FREE_VAR(exportBuf, HEAP_HINT);
#endif
#ifdef HAVE_ECC_SIGN
FREE_VAR(sig, HEAP_HINT);
FREE_VAR(digest, HEAP_HINT);
WC_FREE_VAR(sig, HEAP_HINT);
WC_FREE_VAR(digest, HEAP_HINT);
#endif
(void)keySize;

47
wolfssl/wolfcrypt/types.h
View File

@ -482,10 +482,10 @@ decouple library dependencies with standard string, memory and so on.
/* declare/free variable handling for async and smallstack */
#if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_SMALL_STACK)
#define DECLARE_VAR_IS_HEAP_ALLOC
#define DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
#define WC_DECLARE_VAR_IS_HEAP_ALLOC
#define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
VAR_TYPE* VAR_NAME = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * VAR_SIZE, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT)
#define DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
#define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE* VAR_NAME[VAR_ITEMS]; \
int idx##VAR_NAME, inner_idx_##VAR_NAME; \
for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \
@ -501,31 +501,31 @@ decouple library dependencies with standard string, memory and so on.
break; \
} \
}
#define FREE_VAR(VAR_NAME, HEAP) \
#define WC_FREE_VAR(VAR_NAME, HEAP) \
XFREE(VAR_NAME, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT)
#define FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \
#define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \
for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \
XFREE(VAR_NAME[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \
}
#define DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \
FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP)
#define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define WC_FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \
WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP)
#else
#undef DECLARE_VAR_IS_HEAP_ALLOC
#define DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
#undef WC_DECLARE_VAR_IS_HEAP_ALLOC
#define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
VAR_TYPE VAR_NAME[VAR_SIZE]
#define DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
#define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE VAR_NAME[VAR_ITEMS][VAR_SIZE]
#define FREE_VAR(VAR_NAME, HEAP) /* nothing to free, its stack */
#define FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) /* nothing to free, its stack */
#define WC_FREE_VAR(VAR_NAME, HEAP) /* nothing to free, its stack */
#define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) /* nothing to free, its stack */
#define DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
#define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE* VAR_NAME[VAR_ITEMS]; \
int idx##VAR_NAME, inner_idx_##VAR_NAME;
#define DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
#define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \
VAR_NAME[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \
if (VAR_NAME[idx##VAR_NAME] == NULL) { \
@ -539,12 +539,23 @@ decouple library dependencies with standard string, memory and so on.
break; \
} \
}
#define FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \
#define WC_FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \
for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \
XFREE(VAR_NAME[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \
}
#endif
#if defined(HAVE_FIPS) || defined(HAVE_SELFTEST)
/* These are here for the FIPS code that can't be changed. New definitions don't need to be added here. */
#define DECLARE_VAR WC_DECLARE_VAR
#define DECLARE_ARRAY WC_DECLARE_ARRAY
#define FREE_VAR WC_FREE_VAR
#define FREE_ARRAY WC_FREE_ARRAY
#define DECLARE_ARRAY_DYNAMIC_DEC WC_DECLARE_ARRAY_DYNAMIC_DEC
#define DECLARE_ARRAY_DYNAMIC_EXE WC_DECLARE_ARRAY_DYNAMIC_EXE
#define FREE_ARRAY_DYNAMIC WC_FREE_ARRAY_DYNAMIC
#endif /* HAVE_FIPS */
#if !defined(USE_WOLF_STRTOK) && \
((defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)) || \
defined(WOLFSSL_TIRTOS) || defined(WOLF_C99))