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

Merge pull request #7252 from douzzer/20240215-benchmark-smallstack-refactors

Browse Source 
20240215-benchmark-smallstack-refactors
This commit is contained in:
David Garske
2024-02-16 11:45:59 -08:00
committed by GitHub
parent 815c290293 af620513f1
commit e4ea2651a3
12 changed files with 1181 additions and 925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
linuxkm/Kbuild
View File

@@ -99,10 +99,8 @@ ifeq "$(ENABLED_LINUXKM_PIE)" "yes"
$(obj)/linuxkm/module_hooks.o: ccflags-y += $(PIE_SUPPORT_FLAGS)
endif
ifeq "$(ENABLED_LINUXKM_BENCHMARKS)" "yes"
$(obj)/linuxkm/module_hooks.o: ccflags-y = $(WOLFSSL_CFLAGS) $(CFLAGS_FPU_ENABLE) $(CFLAGS_SIMD_ENABLE) $(PIE_SUPPORT_FLAGS)
$(obj)/linuxkm/module_hooks.o: asflags-y = $(WOLFSSL_ASFLAGS) $(ASFLAGS_FPU_ENABLE_SIMD_DISABLE)
endif
$(obj)/wolfcrypt/benchmark/benchmark.o: ccflags-y = $(WOLFSSL_CFLAGS) $(CFLAGS_FPU_ENABLE) $(CFLAGS_SIMD_ENABLE) $(PIE_SUPPORT_FLAGS) -DNO_MAIN_FUNCTION
$(obj)/wolfcrypt/benchmark/benchmark.o: asflags-y = $(WOLFSSL_ASFLAGS) $(ASFLAGS_FPU_ENABLE_SIMD_DISABLE)
asflags-y := $(WOLFSSL_ASFLAGS) $(ASFLAGS_FPUSIMD_DISABLE)

4
linuxkm/Makefile
View File

@@ -47,6 +47,10 @@ else
WOLFSSL_CFLAGS+=-DNO_CRYPT_TEST
endif
ifeq "$(ENABLED_LINUXKM_BENCHMARKS)" "yes"
WOLFSSL_OBJ_FILES+=wolfcrypt/benchmark/benchmark.o
endif
ifeq "$(ENABLED_LINUXKM_PIE)" "yes"
WOLFCRYPT_PIE_FILES := linuxkm/pie_first.o $(filter wolfcrypt/src/%,$(WOLFSSL_OBJ_FILES)) linuxkm/pie_redirect_table.o linuxkm/pie_last.o
WOLFSSL_OBJ_FILES := $(WOLFCRYPT_PIE_FILES) $(filter-out $(WOLFCRYPT_PIE_FILES),$(WOLFSSL_OBJ_FILES))

6
linuxkm/module_hooks.c
View File

@@ -121,11 +121,7 @@ static int updateFipsHash(void);
#endif
#ifdef WOLFSSL_LINUXKM_BENCHMARKS
#define STRING_USER
#define NO_MAIN_FUNCTION
#define current_time benchmark_current_time
#define WOLFSSL_NO_FLOAT_FMT
#include "wolfcrypt/benchmark/benchmark.c"
extern int wolfcrypt_benchmark_main(int argc, char** argv);
#endif /* WOLFSSL_LINUXKM_BENCHMARKS */
#ifdef LINUXKM_LKCAPI_REGISTER

3
src/tls.c
View File

@@ -182,6 +182,7 @@ int BuildTlsFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
byte handshake_hash[HSHASH_SZ];
#else
WC_DECLARE_VAR(handshake_hash, byte, HSHASH_SZ, ssl->heap);
WC_ALLOC_VAR(handshake_hash, byte, HSHASH_SZ, ssl->heap);
if (handshake_hash == NULL)
return MEMORY_E;
#endif
@@ -317,6 +318,7 @@ static int _DeriveTlsKeys(byte* key_dig, word32 key_dig_len,
int ret;
#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
WC_DECLARE_VAR(seed, byte, SEED_LEN, heap);
WC_ALLOC_VAR(seed, byte, SEED_LEN, heap);
if (seed == NULL)
return MEMORY_E;
#else
@@ -422,6 +424,7 @@ static int _MakeTlsMasterSecret(byte* ms, word32 msLen,
byte seed[SEED_LEN];
#else
WC_DECLARE_VAR(seed, byte, SEED_LEN, heap);
WC_ALLOC_VAR(seed, byte, SEED_LEN, heap);
if (seed == NULL)
return MEMORY_E;
#endif

12
tests/api.c
View File

@@ -19754,6 +19754,10 @@ static int test_wc_RsaPublicEncryptDecrypt(void)
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
ExpectNotNull(in);
ExpectNotNull(plain);
@@ -19816,6 +19820,10 @@ static int test_wc_RsaPublicEncryptDecrypt_ex(void)
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
ExpectNotNull(in);
ExpectNotNull(plain);
@@ -19881,6 +19889,10 @@ static int test_wc_RsaSSL_SignVerify(void)
WC_DECLARE_VAR(out, byte, TEST_RSA_BYTES, NULL);
WC_DECLARE_VAR(plain, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(out, byte, TEST_RSA_BYTES, NULL);
WC_ALLOC_VAR(plain, byte, TEST_STRING_SZ, NULL);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
ExpectNotNull(in);
ExpectNotNull(out);

1737
wolfcrypt/benchmark/benchmark.c
View File

File diff suppressed because it is too large Load Diff

5
wolfcrypt/src/ed448.c
View File

@@ -203,7 +203,10 @@ int wc_ed448_make_public(ed448_key* key, unsigned char* pubKey, word32 pubKeySz)
az[55] |= 0x80;
az[56] = 0x00;
ge448_scalarmult_base(&A, az);
ret = ge448_scalarmult_base(&A, az);
}
if (ret == 0) {
ge448_to_bytes(pubKey, &A);
key->pubKeySet = 1;

46
wolfcrypt/src/ge_448.c
View File

@@ -342,9 +342,10 @@ static void ge448_scalarmult(ge448_p2* h, const ge448_p2* p, const byte* a)
* r [in] Point to hold result.
* a [in] Scalar to multiply by.
*/
void ge448_scalarmult_base(ge448_p2* h, const byte* a)
int ge448_scalarmult_base(ge448_p2* h, const byte* a)
{
ge448_scalarmult(h, &ed448_base, a);
return 0;
}
/* Perform a scalar multplication of the base point and public point.
@@ -10563,12 +10564,28 @@ static void ge448_select(ge448_precomp* r, int pos, byte b)
* r [in] Point to hold result.
* a [in] Scalar to multiply by.
*/
void ge448_scalarmult_base(ge448_p2* r, const byte* a)
int ge448_scalarmult_base(ge448_p2* r, const byte* a)
{
byte carry;
ge448_precomp t;
int i;
#ifdef WOLFSSL_SMALL_STACK
ge448_precomp *t = NULL;
byte *e = NULL;
#else
ge448_precomp t[1];
byte e[113];
#endif
int i;
#ifdef WOLFSSL_SMALL_STACK
t = (ge448_precomp *)XMALLOC(sizeof(*t), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (t == NULL)
return MEMORY_E;
e = (byte *)XMALLOC(113, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (e == NULL) {
XFREE(t, NULL, DYNAMIC_TYPE_TMP_BUFFER);
return MEMORY_E;
}
#endif
carry = 0;
for (i = 0; i < 56; ++i) {
@@ -10586,13 +10603,13 @@ void ge448_scalarmult_base(ge448_p2* r, const byte* a)
/* each e[i] is between -8 and 8 */
/* Odd indeces first - sum based on even index so multiply by 16 */
ge448_select(&t, 0, e[1]);
fe448_copy(r->X, t.x);
fe448_copy(r->Y, t.y);
ge448_select(t, 0, e[1]);
fe448_copy(r->X, t->x);
fe448_copy(r->Y, t->y);
fe448_1(r->Z);
for (i = 3; i < 112; i += 2) {
ge448_select(&t, i / 2, e[i]);
ge448_madd(r, r, &t);
ge448_select(t, i / 2, e[i]);
ge448_madd(r, r, t);
}
ge448_dbl(r, r);
@@ -10602,9 +10619,16 @@ void ge448_scalarmult_base(ge448_p2* r, const byte* a)
/* Add even indeces */
for (i = 0; i <= 112; i += 2) {
ge448_select(&t, i / 2, e[i]);
ge448_madd(r, r, &t);
ge448_select(t, i / 2, e[i]);
ge448_madd(r, r, t);
}
#ifdef WOLFSSL_SMALL_STACK
XFREE(t, NULL, DYNAMIC_TYPE_TMP_BUFFER);
XFREE(e, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return 0;
}
/* Create to a sliding window for the scalar multiplicaton.

1
wolfcrypt/src/sakke.c
View File

@@ -6522,7 +6522,6 @@ int wc_GenerateSakkePointITable(SakkeKey* key, byte* table, word32* len)
key->i.table = table;
key->i.tableLen = *len;
}
(void)table;
#endif
return err;

155
wolfcrypt/test/test.c
View File

@@ -11917,12 +11917,12 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes192_test(void)
0x71,0x78,0x18,0x3a,0x9f,0xa0,0x71,0xe8
};
WOLFSSL_SMALL_STACK_STATIC byte key[] = {
WOLFSSL_SMALL_STACK_STATIC const byte key[] = {
0x8e,0x73,0xb0,0xf7,0xda,0x0e,0x64,0x52,
0xc8,0x10,0xf3,0x2b,0x80,0x90,0x79,0xe5,
0x62,0xf8,0xea,0xd2,0x52,0x2c,0x6b,0x7b
};
WOLFSSL_SMALL_STACK_STATIC byte iv[] = {
WOLFSSL_SMALL_STACK_STATIC const byte iv[] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F
};
@@ -12046,7 +12046,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes256_test(void)
(byte*)guser_PKCbInfo.wrapped_key_aes256;
int keySz = (256/8);
#else
WOLFSSL_SMALL_STACK_STATIC byte key[] = {
WOLFSSL_SMALL_STACK_STATIC const byte key[] = {
0x60,0x3d,0xeb,0x10,0x15,0xca,0x71,0xbe,
0x2b,0x73,0xae,0xf0,0x85,0x7d,0x77,0x81,
0x1f,0x35,0x2c,0x07,0x3b,0x61,0x08,0xd7,
@@ -12054,7 +12054,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes256_test(void)
};
int keySz = (int)sizeof(key);
#endif
WOLFSSL_SMALL_STACK_STATIC byte iv[] = {
WOLFSSL_SMALL_STACK_STATIC const byte iv[] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F
};
@@ -15977,16 +15977,16 @@ static void initDefaultName(void)
#if !defined(NO_ASN_TIME) && !defined(NO_RSA) && defined(WOLFSSL_TEST_CERT) && \
!defined(NO_FILESYSTEM)
static byte minSerial[] = { 0x02, 0x01, 0x01 };
static byte minName[] = { 0x30, 0x00 };
static byte nameBad[] = {
static const byte minSerial[] = { 0x02, 0x01, 0x01 };
static const byte minName[] = { 0x30, 0x00 };
static const byte nameBad[] = {
0x30, 0x08,
0x31, 0x06,
0x30, 0x04,
0x06, 0x02,
0x55, 0x04,
};
static byte minDates[] = {
static const byte minDates[] = {
0x30, 0x1e,
0x17, 0x0d,
0x31, 0x38, 0x30, 0x34, 0x31, 0x33, 0x31, 0x35,
@@ -15995,7 +15995,7 @@ static byte minDates[] = {
0x32, 0x31, 0x30, 0x31, 0x30, 0x37, 0x31, 0x35,
0x32, 0x33, 0x31, 0x30, 0x5a
};
static byte minPubKey[] = {
static const byte minPubKey[] = {
0x30, 0x1c,
0x30, 0x0d,
0x06, 0x09,
@@ -16009,14 +16009,14 @@ static byte minPubKey[] = {
0x02, 0x03,
0x01, 0x00, 0x01
};
static byte minSigAlg[] = {
static const byte minSigAlg[] = {
0x30, 0x0d,
0x06, 0x09,
0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x0b,
0x05, 0x00
};
static byte minSig[] = {
static const byte minSig[] = {
0x03, 0x01,
0x00
};
@@ -16028,7 +16028,7 @@ static int add_seq(byte* certData, int offset, byte* data, byte length)
certData[offset++] = length;
return offset + length;
}
static int add_data(byte* certData, int offset, byte* data, byte length)
static int add_data(byte* certData, int offset, const byte* data, byte length)
{
XMEMCPY(certData + offset, data, length);
return offset + length;
@@ -17259,6 +17259,10 @@ static wc_test_ret_t rsa_pss_test(WC_RNG* rng, RsaKey* key)
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(sig, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(in, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(sig, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || sig == NULL)
ERROR_OUT(MEMORY_E, exit_rsa_pss);
@@ -17579,6 +17583,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_no_pad_test(void)
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(key, RsaKey, 1, HEAP_HINT);
WC_ALLOC_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (key == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa_nopadding);
@@ -17809,6 +17817,12 @@ static wc_test_ret_t rsa_even_mod_test(WC_RNG* rng, RsaKey* key)
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#endif
WC_ALLOC_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
WC_ALLOC_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#endif
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (out == NULL
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
@@ -18625,6 +18639,10 @@ static wc_test_ret_t rsa_oaep_padding_test(RsaKey* key, WC_RNG* rng)
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
WC_ALLOC_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
@@ -18985,6 +19003,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
WC_DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, HEAP_HINT);
WC_ALLOC_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
WC_ALLOC_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (in == NULL || out == NULL || plain == NULL)
ERROR_OUT(MEMORY_E, exit_rsa);
@@ -19190,7 +19212,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
#elif defined(WOLFSSL_PUBLIC_MP)
{
static byte signature_2048[] = {
static const byte signature_2048[] = {
0x07, 0x6f, 0xc9, 0x85, 0x73, 0x9e, 0x21, 0x79,
0x47, 0xf1, 0xa3, 0xd7, 0xf4, 0x27, 0x29, 0xbe,
0x99, 0x5d, 0xac, 0xb2, 0x10, 0x3f, 0x95, 0xda,
@@ -25964,6 +25986,13 @@ static wc_test_ret_t ecc_test_vector_item(const eccVector* vector)
WC_DECLARE_VAR(s, byte, MAX_ECC_BYTES, HEAP_HINT);
#endif
WC_ALLOC_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
#if !defined(NO_ASN) && !defined(HAVE_SELFTEST)
WC_ALLOC_VAR(sigRaw, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_ALLOC_VAR(r, byte, MAX_ECC_BYTES, HEAP_HINT);
WC_ALLOC_VAR(s, byte, MAX_ECC_BYTES, HEAP_HINT);
#endif
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
if (sig == NULL)
ERROR_OUT(MEMORY_E, done);
@@ -27352,6 +27381,21 @@ static wc_test_ret_t ecc_test_curve_size(WC_RNG* rng, int keySize, int testVerif
int curveSize;
#endif
#if defined(HAVE_ECC_DHE) && !defined(WC_NO_RNG) && \
!defined(WOLFSSL_ATECC508A) && !defined(WOLFSSL_ATECC608A)
WC_ALLOC_VAR(sharedA, byte, ECC_SHARED_SIZE, HEAP_HINT);
WC_ALLOC_VAR(sharedB, byte, ECC_SHARED_SIZE, HEAP_HINT);
#endif
#ifdef HAVE_ECC_KEY_EXPORT
WC_ALLOC_VAR(exportBuf, byte, ECC_KEY_EXPORT_BUF_SIZE, HEAP_HINT);
#endif
#if !defined(ECC_TIMING_RESISTANT) || (defined(ECC_TIMING_RESISTANT) && \
!defined(WC_NO_RNG) && !defined(WOLFSSL_KCAPI_ECC)) && \
defined(HAVE_ECC_SIGN)
WC_ALLOC_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_ALLOC_VAR(digest, byte, ECC_DIGEST_SIZE, HEAP_HINT);
#endif
#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)
@@ -29002,6 +29046,18 @@ static int ecc_sm2_test_curve(WC_RNG* rng, int testVerifyCount)
int curveSize;
#endif
#if (defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)) && !defined(WC_NO_RNG)
WC_ALLOC_VAR(sharedA, byte, ECC_SHARED_SIZE, HEAP_HINT);
WC_ALLOC_VAR(sharedB, byte, ECC_SHARED_SIZE, HEAP_HINT);
#endif
#ifdef HAVE_ECC_KEY_EXPORT
WC_ALLOC_VAR(exportBuf, byte, ECC_KEY_EXPORT_BUF_SIZE, HEAP_HINT);
#endif
#ifdef HAVE_ECC_SIGN
WC_ALLOC_VAR(sig, byte, ECC_SIG_SIZE, HEAP_HINT);
WC_ALLOC_VAR(digest, byte, ECC_DIGEST_SIZE, HEAP_HINT);
#endif
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
#if (defined(HAVE_ECC_DHE) || defined(HAVE_ECC_CDH)) && !defined(WC_NO_RNG)
if (sharedA == NULL || sharedB == NULL)
@@ -32680,7 +32736,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
sizeof(msg4)
};
#ifndef NO_ASN
static byte privateEd25519[] = {
static const byte privateEd25519[] = {
0x30,0x2e,0x02,0x01,0x00,0x30,0x05,0x06,
0x03,0x2b,0x65,0x70,0x04,0x22,0x04,0x20,
0x9d,0x61,0xb1,0x9d,0xef,0xfd,0x5a,0x60,
@@ -32688,7 +32744,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
0x44,0x49,0xc5,0x69,0x7b,0x32,0x69,0x19,
0x70,0x3b,0xac,0x03,0x1c,0xae,0x7f,0x60
};
static byte badPrivateEd25519[] = {
static const byte badPrivateEd25519[] = {
0x30,0x52,0x02,0x01,0x00,0x30,0x05,0x06,
0x03,0x2b,0x65,0x70,0x04,0x22,0x04,0x20,
0x9d,0x61,0xb1,0x9d,0xef,0xfd,0x5a,0x60,
@@ -32702,7 +32758,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
0xf7,0x07,0x51,0x1a,
0x00 /* add additional bytes to make the pubkey bigger */
};
static byte publicEd25519[] = {
static const byte publicEd25519[] = {
0x30,0x2a,0x30,0x05,0x06,0x03,0x2b,0x65,
0x70,0x03,0x21,0x00,0xd7,0x5a,0x98,0x01,
0x82,0xb1,0x0a,0xb7,0xd5,0x4b,0xfe,0xd3,
@@ -32712,7 +32768,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
};
/* size has been altered to catch if sanity check is done */
static byte badPublicEd25519[] = {
static const byte badPublicEd25519[] = {
0x30,0x2a,0x30,0x05,0x06,0x03,0x2b,0x65,
0x70,0x03,0x21,0x00,0xd7,0x5a,0x98,0x01,
0x82,0xb1,0x0a,0xb7,0xd5,0x4b,0xfe,0xd3,
@@ -32721,7 +32777,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
0xf7,0x07,0x51,0x1a,
0x00 /* add an additional byte to make the pubkey appear bigger */
};
static byte privPubEd25519[] = {
static const byte privPubEd25519[] = {
0x30,0x50,0x02,0x01,0x00,0x30,0x05,0x06,
0x03,0x2b,0x65,0x70,0x04,0x22,0x04,0x20,
0x9d,0x61,0xb1,0x9d,0xef,0xfd,0x5a,0x60,
@@ -36807,7 +36863,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t xmss_test(void)
* https://github.com/XMSS/xmss-reference
* */
static byte xmss_pub[XMSS_SHA256_PUBLEN] =
static const byte xmss_pub[XMSS_SHA256_PUBLEN] =
{
0x00,0x00,0x00,0x01,0xA5,0x41,0x31,0x96,
0x0A,0xF9,0xF3,0xB2,0x4B,0x2E,0x5B,0x3E,
@@ -36820,7 +36876,7 @@ static byte xmss_pub[XMSS_SHA256_PUBLEN] =
0xC9,0xB7,0x39,0x4E
};
static byte xmss_msg[32] =
static const byte xmss_msg[32] =
{
0x07,0x9F,0x80,0x86,0xDB,0x76,0x27,0xDF,
0xED,0x5B,0x2A,0x81,0x60,0x60,0x7D,0xB4,
@@ -36830,7 +36886,7 @@ static byte xmss_msg[32] =
/* This was actually the 5th signature produced from
* xmss_fast test in xmss-reference. */
static byte xmss_sig[2500] =
static const byte xmss_sig[2500] =
{
0x00,0x00,0x00,0x05,0xF0,0x15,0x34,0xBA,
0x92,0x03,0x6A,0xB9,0xA5,0x23,0x86,0x11,
@@ -37408,7 +37464,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t lms_test(void)
* */
/* "wolfSSL LMS example message!" without null terminator. */
static byte lms_msg[28] =
static const byte lms_msg[28] =
{
0x77,0x6F,0x6C,0x66,0x53,0x53,0x4C,0x20,
0x4C,0x4D,0x53,0x20,0x65,0x78,0x61,0x6D,
@@ -37416,7 +37472,7 @@ static byte lms_msg[28] =
0x61,0x67,0x65,0x21
};
static byte lms_L1H10W8_pub[HSS_MAX_PUBLIC_KEY_LEN] =
static const byte lms_L1H10W8_pub[HSS_MAX_PUBLIC_KEY_LEN] =
{
0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,
0x00,0x00,0x00,0x04,0xA1,0x26,0x76,0xF8,
@@ -37430,7 +37486,7 @@ static byte lms_L1H10W8_pub[HSS_MAX_PUBLIC_KEY_LEN] =
#define LMS_L1H10W8_SIGLEN (1456)
static byte lms_L1H10W8_sig[LMS_L1H10W8_SIGLEN] =
static const byte lms_L1H10W8_sig[LMS_L1H10W8_SIGLEN] =
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
0x00,0x00,0x00,0x04,0x18,0x70,0x09,0x2E,
@@ -39440,12 +39496,12 @@ static wc_test_ret_t sakke_kat_encapsulate_test(SakkeKey* key)
0x37, 0x30, 0x30, 0x39, 0x30, 0x30, 0x31, 0x32,
0x33, 0x00
};
static word32 idSz = sizeof(id);
static const word32 idSz = sizeof(id);
byte ssv[] = {
0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0
};
static word16 ssvSz = sizeof(ssv);
static const word16 ssvSz = sizeof(ssv);
static const byte expAuth[] = {
0x04,
0x44, 0xE8, 0xAD, 0x44, 0xAB, 0x85, 0x92, 0xA6,
@@ -43145,8 +43201,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t pkcs7encrypted_test(void)
/* Attribute example from RFC 4134, Section 7.2
* OID = 1.2.5555
* OCTET STRING = 'This is a test General ASN Attribute, number 1.' */
static byte genAttrOid[] = { 0x06, 0x03, 0x2a, 0xab, 0x33 };
static byte genAttr[] = { 0x04, 47,
static const byte genAttrOid[] = { 0x06, 0x03, 0x2a, 0xab, 0x33 };
static const byte genAttr[] = { 0x04, 47,
0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x47,
0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x41,
@@ -43154,8 +43210,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t pkcs7encrypted_test(void)
0x62, 0x75, 0x74, 0x65, 0x2c, 0x20, 0x6e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0x20, 0x31, 0x2e };
static byte genAttrOid2[] = { 0x06, 0x03, 0x2a, 0xab, 0x34 };
static byte genAttr2[] = { 0x04, 47,
static const byte genAttrOid2[] = { 0x06, 0x03, 0x2a, 0xab, 0x34 };
static const byte genAttr2[] = { 0x04, 47,
0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x47,
0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x41,
@@ -43488,12 +43544,12 @@ typedef struct {
word32 signedAttribsSz;
const char* outFileName;
int contentOID;
byte* contentType;
const byte* contentType;
word32 contentTypeSz;
int sidType;
int encryptOID; /* for single-shot encrypt alg OID */
int encCompFlag; /* for single-shot. 1 = enc, 2 = comp, 3 = both*/
byte* encryptKey; /* for single-shot, encryptedData */
const byte* encryptKey; /* for single-shot, encryptedData */
word32 encryptKeySz; /* for single-shot, encryptedData */
PKCS7Attrib* unprotectedAttribs; /* for single-shot, encryptedData */
word32 unprotectedAttribsSz; /* for single-shot, encryptedData */
@@ -43527,24 +43583,24 @@ static wc_test_ret_t pkcs7signed_run_vectors(
0x72,0x6c,0x64
};
static byte transIdOid[] =
static const byte transIdOid[] =
{ 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01,
0x09, 0x07 };
static byte messageTypeOid[] =
static const byte messageTypeOid[] =
{ 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01,
0x09, 0x02 };
static byte senderNonceOid[] =
static const byte senderNonceOid[] =
{ 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01,
0x09, 0x05 };
#ifndef NO_SHA
static byte transId[(WC_SHA_DIGEST_SIZE + 1) * 2 + 1];
byte transId[(WC_SHA_DIGEST_SIZE + 1) * 2 + 1];
#else
static byte transId[(WC_SHA256_DIGEST_SIZE + 1) * 2 + 1];
byte transId[(WC_SHA256_DIGEST_SIZE + 1) * 2 + 1];
#endif
static byte messageType[] = { 0x13, 2, '1', '9' };
static byte senderNonce[PKCS7_NONCE_SZ + 2];
static const byte messageType[] = { 0x13, 2, '1', '9' };
byte senderNonce[PKCS7_NONCE_SZ + 2];
static PKCS7Attrib attribs[] =
PKCS7Attrib attribs[] =
{
{ transIdOid, sizeof(transIdOid), transId,
sizeof(transId) - 1 }, /* take off the null */
@@ -43555,13 +43611,13 @@ static wc_test_ret_t pkcs7signed_run_vectors(
};
/* for testing custom contentType, FirmwarePkgData */
static byte customContentType[] = { 0x06, 0x0B, 0x2A, 0x86,
static const byte customContentType[] = { 0x06, 0x0B, 0x2A, 0x86,
0x48, 0x86, 0xF7, 0x0D,
0x01, 0x09, 0x10, 0x01, 0x10 };
#define MAX_TESTVECTORS_LEN 20
#define ADD_PKCS7SIGNEDVECTOR(...) { \
pkcs7SignedVector _this_vector = { __VA_ARGS__ }; \
const pkcs7SignedVector _this_vector = { __VA_ARGS__ }; \
if (testSz == MAX_TESTVECTORS_LEN) { \
ret = WC_TEST_RET_ENC_NC; \
goto out; \
@@ -43818,7 +43874,8 @@ static wc_test_ret_t pkcs7signed_run_vectors(
/* optional custom contentType, default is DATA,
overrides contentOID if set */
if (testVectors[i].contentType != NULL) {
ret = wc_PKCS7_SetContentType(pkcs7, testVectors[i].contentType,
ret = wc_PKCS7_SetContentType(pkcs7,
(byte *)testVectors[i].contentType,
testVectors[i].contentTypeSz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -43940,7 +43997,7 @@ static wc_test_ret_t pkcs7signed_run_vectors(
#else
byte buf[(WC_SHA256_DIGEST_SIZE + 1) * 2 + 1];
#endif
byte* oidPt = transIdOid + 2; /* skip object id tag and size */
const byte* oidPt = transIdOid + 2; /* skip object id tag and size */
int oidSz = (int)sizeof(transIdOid) - 2;
int bufSz = 0;
@@ -44046,7 +44103,7 @@ static wc_test_ret_t pkcs7signed_run_SingleShotVectors(
#if !defined(NO_PKCS7_ENCRYPTED_DATA) && \
defined(HAVE_AES_CBC) && defined(WOLFSSL_AES_256)
static byte aes256Key[] = {
static const byte aes256Key[] = {
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
@@ -44054,10 +44111,10 @@ static wc_test_ret_t pkcs7signed_run_SingleShotVectors(
};
#endif
static byte messageTypeOid[] =
static const byte messageTypeOid[] =
{ 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01,
0x09, 0x02 };
static byte messageType[] = { 0x13, 2, '1', '9' };
static const byte messageType[] = { 0x13, 2, '1', '9' };
PKCS7Attrib attribs[] =
{
@@ -44347,7 +44404,7 @@ static wc_test_ret_t pkcs7signed_run_SingleShotVectors(
/* encode Signed Encrypted FirmwarePkgData */
encodedSz = wc_PKCS7_EncodeSignedEncryptedFPD(pkcs7,
testVectors[i].encryptKey, testVectors[i].encryptKeySz,
(byte *)testVectors[i].encryptKey, testVectors[i].encryptKeySz,
testVectors[i].privateKey, testVectors[i].privateKeySz,
testVectors[i].encryptOID, testVectors[i].signOID,
testVectors[i].hashOID, (byte*)testVectors[i].content,
@@ -44450,7 +44507,7 @@ static wc_test_ret_t pkcs7signed_run_SingleShotVectors(
else if (testVectors[i].encCompFlag == 1) {
/* decrypt inner encryptedData */
pkcs7->encryptionKey = testVectors[i].encryptKey;
pkcs7->encryptionKey = (byte *)testVectors[i].encryptKey;
pkcs7->encryptionKeySz = testVectors[i].encryptKeySz;
ret = wc_PKCS7_DecodeEncryptedData(pkcs7, pkcs7->content,

2
wolfssl/wolfcrypt/ge_448.h
View File

@@ -64,7 +64,7 @@ WOLFSSL_LOCAL int ge448_from_bytes_negate_vartime(ge448_p2 *r, const byte *b);
WOLFSSL_LOCAL int ge448_double_scalarmult_vartime(ge448_p2 *r, const byte *a,
const ge448_p2 *A, const byte *b);
WOLFSSL_LOCAL void ge448_scalarmult_base(ge448_p2* h, const byte* a);
WOLFSSL_LOCAL int ge448_scalarmult_base(ge448_p2* h, const byte* a);
WOLFSSL_LOCAL void sc448_reduce(byte* b);
WOLFSSL_LOCAL void sc448_muladd(byte* r, const byte* a, const byte* b, const byte* d);
WOLFSSL_LOCAL void ge448_to_bytes(byte *s, const ge448_p2 *h);

129
wolfssl/wolfcrypt/types.h
View File

@@ -580,71 +580,88 @@ typedef struct w64wrapper {
#endif
/* declare/free variable handling for async and smallstack */
#ifndef WC_ALLOC_DO_ON_FAILURE
#define WC_ALLOC_DO_ON_FAILURE() WC_DO_NOTHING
#endif
#define WC_DECLARE_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE* VAR_NAME[VAR_ITEMS]; \
int idx##VAR_NAME = 0, inner_idx_##VAR_NAME
#define WC_ALLOC_HEAP_ARRAY(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) { \
for (inner_idx_##VAR_NAME = 0; inner_idx_##VAR_NAME < idx##VAR_NAME; inner_idx_##VAR_NAME++) { \
XFREE((VAR_NAME)[inner_idx_##VAR_NAME], (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; inner_idx_##VAR_NAME < (VAR_ITEMS); inner_idx_##VAR_NAME++) { \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
idx##VAR_NAME = 0; \
WC_ALLOC_DO_ON_FAILURE(); \
break; \
} \
}
#define WC_CALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
do { \
WC_ALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP); \
if (idx##VAR_NAME != 0) { \
for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \
XMEMSET((VAR_NAME)[idx##VAR_NAME], 0, VAR_SIZE); \
} \
} \
} while (0)
#define WC_HEAP_ARRAY_OK(VAR_NAME) (idx##VAR_NAME != 0)
#define WC_FREE_HEAP_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \
if (WC_HEAP_ARRAY_OK(VAR_NAME)) { \
for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \
XFREE((VAR_NAME)[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \
} \
idx##VAR_NAME = 0; \
}
#if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_SMALL_STACK)
#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 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
#define WC_INIT_ARRAY(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_WOLF_BIGINT); \
if ((VAR_NAME)[idx##VAR_NAME] == NULL) { \
for (inner_idx_##VAR_NAME = 0; inner_idx_##VAR_NAME < idx##VAR_NAME; inner_idx_##VAR_NAME++) { \
XFREE((VAR_NAME)[inner_idx_##VAR_NAME], (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; inner_idx_##VAR_NAME < (VAR_ITEMS); inner_idx_##VAR_NAME++) { \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
break; \
} \
}
VAR_TYPE* VAR_NAME = NULL
#define WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
do { \
(VAR_NAME) = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * (VAR_SIZE), (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \
if ((VAR_NAME) == NULL) { \
WC_ALLOC_DO_ON_FAILURE(); \
} \
} while (0)
#define WC_CALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
do { \
WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP); \
XMEMSET(VAR_NAME, 0, sizeof(VAR_TYPE) * (VAR_SIZE)); \
} while (0)
#define WC_FREE_VAR(VAR_NAME, HEAP) \
XFREE(VAR_NAME, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT)
#define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
WC_DECLARE_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define WC_ALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
WC_ALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define WC_CALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
WC_CALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP)
#define WC_ARRAY_OK(VAR_NAME) WC_HEAP_ARRAY_OK(VAR_NAME)
#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 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) \
WC_INIT_ARRAY(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)
WC_FREE_HEAP_ARRAY(VAR_NAME, VAR_ITEMS, HEAP)
#else
#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 WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE VAR_NAME[VAR_ITEMS][VAR_SIZE]
#define WC_INIT_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) WC_DO_NOTHING
#define WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) WC_DO_NOTHING
#define WC_CALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \
XMEMSET(VAR_NAME, 0, sizeof(var))
#define WC_FREE_VAR(VAR_NAME, HEAP) WC_DO_NOTHING /* nothing to free, its stack */
#define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE VAR_NAME[VAR_ITEMS][(VAR_SIZE) / sizeof(VAR_TYPE)] /* // NOLINT(bugprone-sizeof-expression) */
#define WC_ALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) WC_DO_NOTHING
#define WC_CALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) XMEMSET(VAR_NAME, 0, sizeof(VAR_NAME))
#define WC_ARRAY_OK(VAR_NAME) 1
#define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) WC_DO_NOTHING /* nothing to free, its stack */
#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 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) { \
for (inner_idx_##VAR_NAME = 0; inner_idx_##VAR_NAME < idx##VAR_NAME; inner_idx_##VAR_NAME++) { \
XFREE((VAR_NAME)[inner_idx_##VAR_NAME], HEAP, DYNAMIC_TYPE_TMP_BUFFER); \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; inner_idx_##VAR_NAME < (VAR_ITEMS); inner_idx_##VAR_NAME++) { \
(VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \
} \
break; \
} \
}
#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)
@@ -653,9 +670,9 @@ typedef struct w64wrapper {
#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
#define DECLARE_ARRAY_DYNAMIC_DEC WC_DECLARE_HEAP_ARRAY
#define DECLARE_ARRAY_DYNAMIC_EXE WC_ALLOC_HEAP_ARRAY
#define FREE_ARRAY_DYNAMIC WC_FREE_HEAP_ARRAY
#endif /* HAVE_FIPS */
#if !defined(USE_WOLF_STRTOK) && \