Skip to content

Commit 39ab81b

Browse files
night1ridernight1rider
committed
Use WC_DECLARE_VAR/WC_ALLOC_VAR for shaCopy in SHA3/Shake tests to avoid stack frame overflow on small-stack builds.
1 parent ca15072 commit 39ab81b

1 file changed

Lines changed: 84 additions & 36 deletions

File tree

‎wolfcrypt/test/test.c‎

Lines changed: 84 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -5990,7 +5990,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t sha384_test(void)
59905990
#ifndef WOLFSSL_NOSHA3_224
59915991
static wc_test_ret_t sha3_224_test(void)
59925992
{
5993-
wc_Sha3 sha, shaCopy;
5993+
wc_Sha3 sha;
5994+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
5995+
* limit with two wc_Sha3 structs on the stack. */
5996+
WC_DECLARE_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
59945997
byte hash[WC_SHA3_224_DIGEST_SIZE];
59955998
byte hashcopy[WC_SHA3_224_DIGEST_SIZE];
59965999

@@ -5999,6 +6002,10 @@ static wc_test_ret_t sha3_224_test(void)
59996002
wc_test_ret_t ret = 0;
60006003
int times = sizeof(test_sha) / sizeof(struct testVector), i;
60016004

6005+
WC_ALLOC_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
6006+
if (!WC_VAR_OK(shaCopy))
6007+
return WC_TEST_RET_ENC_EC(MEMORY_E);
6008+
60026009
a.input = "";
60036010
a.output = "\x6b\x4e\x03\x42\x36\x67\xdb\xb7\x3b\x6e\x15\x45\x4f\x0e\xb1"
60046011
"\xab\xd4\x59\x7f\x9a\x1b\x07\x8e\x3f\x5b\x5a\x6b\xc7";
@@ -6073,27 +6080,28 @@ static wc_test_ret_t sha3_224_test(void)
60736080
ret = wc_InitSha3_224(&sha, HEAP_HINT, devId);
60746081
if (ret != 0)
60756082
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6076-
ret = wc_InitSha3_224(&shaCopy, HEAP_HINT, devId);
6083+
ret = wc_InitSha3_224(shaCopy, HEAP_HINT, devId);
60776084
if (ret != 0)
60786085
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6079-
ret = wc_Sha3_224_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
6086+
ret = wc_Sha3_224_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
60806087
if (ret != 0)
60816088
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
60826089
ret = wc_Sha3_224_Update(&sha, (byte*)a.input, (word32)a.inLen);
60836090
if (ret != 0)
60846091
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6085-
ret = wc_Sha3_224_Copy(&sha, &shaCopy);
6092+
ret = wc_Sha3_224_Copy(&sha, shaCopy);
60866093
if (ret != 0)
60876094
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6088-
ret = wc_Sha3_224_Final(&shaCopy, hash);
6095+
ret = wc_Sha3_224_Final(shaCopy, hash);
60896096
if (ret != 0)
60906097
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
60916098
if (XMEMCMP(hash, a.output, WC_SHA3_224_DIGEST_SIZE) != 0)
60926099
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
60936100

60946101
exit:
60956102
wc_Sha3_224_Free(&sha);
6096-
wc_Sha3_224_Free(&shaCopy);
6103+
wc_Sha3_224_Free(shaCopy);
6104+
WC_FREE_VAR(shaCopy, HEAP_HINT);
60976105

60986106
return ret;
60996107
}
@@ -6102,7 +6110,10 @@ static wc_test_ret_t sha3_224_test(void)
61026110
#ifndef WOLFSSL_NOSHA3_256
61036111
static wc_test_ret_t sha3_256_test(void)
61046112
{
6105-
wc_Sha3 sha, shaCopy;
6113+
wc_Sha3 sha;
6114+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
6115+
* limit with two wc_Sha3 structs on the stack. */
6116+
WC_DECLARE_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
61066117
byte hash[WC_SHA3_256_DIGEST_SIZE];
61076118
byte hashcopy[WC_SHA3_256_DIGEST_SIZE];
61086119

@@ -6123,6 +6134,10 @@ static wc_test_ret_t sha3_256_test(void)
61236134
"\xe5\x00\xb6\x53\xca\x82\x27\x3b\x7b\xfa\xd8\x04\x5d\x85\xa4\x70";
61246135
#endif
61256136

6137+
WC_ALLOC_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
6138+
if (!WC_VAR_OK(shaCopy))
6139+
return WC_TEST_RET_ENC_EC(MEMORY_E);
6140+
61266141
/*
61276142
** https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA3-256_Msg0.pdf
61286143
*/
@@ -6218,27 +6233,28 @@ static wc_test_ret_t sha3_256_test(void)
62186233
ret = wc_InitSha3_256(&sha, HEAP_HINT, devId);
62196234
if (ret != 0)
62206235
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6221-
ret = wc_InitSha3_256(&shaCopy, HEAP_HINT, devId);
6236+
ret = wc_InitSha3_256(shaCopy, HEAP_HINT, devId);
62226237
if (ret != 0)
62236238
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6224-
ret = wc_Sha3_256_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
6239+
ret = wc_Sha3_256_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
62256240
if (ret != 0)
62266241
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
62276242
ret = wc_Sha3_256_Update(&sha, (byte*)a.input, (word32)a.inLen);
62286243
if (ret != 0)
62296244
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6230-
ret = wc_Sha3_256_Copy(&sha, &shaCopy);
6245+
ret = wc_Sha3_256_Copy(&sha, shaCopy);
62316246
if (ret != 0)
62326247
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6233-
ret = wc_Sha3_256_Final(&shaCopy, hash);
6248+
ret = wc_Sha3_256_Final(shaCopy, hash);
62346249
if (ret != 0)
62356250
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
62366251
if (XMEMCMP(hash, a.output, WC_SHA3_256_DIGEST_SIZE) != 0)
62376252
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
62386253

62396254
exit:
62406255
wc_Sha3_256_Free(&sha);
6241-
wc_Sha3_256_Free(&shaCopy);
6256+
wc_Sha3_256_Free(shaCopy);
6257+
WC_FREE_VAR(shaCopy, HEAP_HINT);
62426258

62436259
return ret;
62446260
}
@@ -6247,7 +6263,10 @@ static wc_test_ret_t sha3_256_test(void)
62476263
#ifndef WOLFSSL_NOSHA3_384
62486264
static wc_test_ret_t sha3_384_test(void)
62496265
{
6250-
wc_Sha3 sha, shaCopy;
6266+
wc_Sha3 sha;
6267+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
6268+
* limit with two wc_Sha3 structs on the stack. */
6269+
WC_DECLARE_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
62516270
byte hash[WC_SHA3_384_DIGEST_SIZE];
62526271
byte buf[64];
62536272
#ifndef NO_INTM_HASH_TEST
@@ -6259,6 +6278,10 @@ static wc_test_ret_t sha3_384_test(void)
62596278
wc_test_ret_t ret;
62606279
int times = sizeof(test_sha) / sizeof(struct testVector), i;
62616280

6281+
WC_ALLOC_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
6282+
if (!WC_VAR_OK(shaCopy))
6283+
return WC_TEST_RET_ENC_EC(MEMORY_E);
6284+
62626285
/*
62636286
** https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA3-384_Msg0.pdf
62646287
*/
@@ -6363,27 +6386,28 @@ static wc_test_ret_t sha3_384_test(void)
63636386
ret = wc_InitSha3_384(&sha, HEAP_HINT, devId);
63646387
if (ret != 0)
63656388
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6366-
ret = wc_InitSha3_384(&shaCopy, HEAP_HINT, devId);
6389+
ret = wc_InitSha3_384(shaCopy, HEAP_HINT, devId);
63676390
if (ret != 0)
63686391
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6369-
ret = wc_Sha3_384_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
6392+
ret = wc_Sha3_384_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
63706393
if (ret != 0)
63716394
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
63726395
ret = wc_Sha3_384_Update(&sha, (byte*)a.input, (word32)a.inLen);
63736396
if (ret != 0)
63746397
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6375-
ret = wc_Sha3_384_Copy(&sha, &shaCopy);
6398+
ret = wc_Sha3_384_Copy(&sha, shaCopy);
63766399
if (ret != 0)
63776400
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6378-
ret = wc_Sha3_384_Final(&shaCopy, hash);
6401+
ret = wc_Sha3_384_Final(shaCopy, hash);
63796402
if (ret != 0)
63806403
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
63816404
if (XMEMCMP(hash, a.output, WC_SHA3_384_DIGEST_SIZE) != 0)
63826405
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
63836406

63846407
exit:
63856408
wc_Sha3_384_Free(&sha);
6386-
wc_Sha3_384_Free(&shaCopy);
6409+
wc_Sha3_384_Free(shaCopy);
6410+
WC_FREE_VAR(shaCopy, HEAP_HINT);
63876411

63886412
return ret;
63896413
}
@@ -6392,7 +6416,10 @@ static wc_test_ret_t sha3_384_test(void)
63926416
#ifndef WOLFSSL_NOSHA3_512
63936417
static wc_test_ret_t sha3_512_test(void)
63946418
{
6395-
wc_Sha3 sha, shaCopy;
6419+
wc_Sha3 sha;
6420+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
6421+
* limit with two wc_Sha3 structs on the stack. */
6422+
WC_DECLARE_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
63966423
byte hash[WC_SHA3_512_DIGEST_SIZE];
63976424
byte hashcopy[WC_SHA3_512_DIGEST_SIZE];
63986425

@@ -6401,6 +6428,10 @@ static wc_test_ret_t sha3_512_test(void)
64016428
wc_test_ret_t ret;
64026429
int times = sizeof(test_sha) / sizeof(struct testVector), i;
64036430

6431+
WC_ALLOC_VAR(shaCopy, wc_Sha3, 1, HEAP_HINT);
6432+
if (!WC_VAR_OK(shaCopy))
6433+
return WC_TEST_RET_ENC_EC(MEMORY_E);
6434+
64046435
/*
64056436
** https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA3-512_Msg0.pdf
64066437
*/
@@ -6489,27 +6520,28 @@ static wc_test_ret_t sha3_512_test(void)
64896520
ret = wc_InitSha3_512(&sha, HEAP_HINT, devId);
64906521
if (ret != 0)
64916522
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6492-
ret = wc_InitSha3_512(&shaCopy, HEAP_HINT, devId);
6523+
ret = wc_InitSha3_512(shaCopy, HEAP_HINT, devId);
64936524
if (ret != 0)
64946525
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6495-
ret = wc_Sha3_512_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
6526+
ret = wc_Sha3_512_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
64966527
if (ret != 0)
64976528
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
64986529
ret = wc_Sha3_512_Update(&sha, (byte*)a.input, (word32)a.inLen);
64996530
if (ret != 0)
65006531
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6501-
ret = wc_Sha3_512_Copy(&sha, &shaCopy);
6532+
ret = wc_Sha3_512_Copy(&sha, shaCopy);
65026533
if (ret != 0)
65036534
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6504-
ret = wc_Sha3_512_Final(&shaCopy, hash);
6535+
ret = wc_Sha3_512_Final(shaCopy, hash);
65056536
if (ret != 0)
65066537
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
65076538
if (XMEMCMP(hash, a.output, WC_SHA3_512_DIGEST_SIZE) != 0)
65086539
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
65096540

65106541
exit:
65116542
wc_Sha3_512_Free(&sha);
6512-
wc_Sha3_512_Free(&shaCopy);
6543+
wc_Sha3_512_Free(shaCopy);
6544+
WC_FREE_VAR(shaCopy, HEAP_HINT);
65136545

65146546
return ret;
65156547
}
@@ -6731,7 +6763,10 @@ static wc_test_ret_t shake128_absorb_test(wc_Shake* sha, byte *large_input_buf,
67316763

67326764
WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake128_test(void)
67336765
{
6734-
wc_Shake sha, shaCopy;
6766+
wc_Shake sha;
6767+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
6768+
* limit with two wc_Shake structs on the stack. */
6769+
WC_DECLARE_VAR(shaCopy, wc_Shake, 1, HEAP_HINT);
67356770
byte hash[250];
67366771

67376772
testVector a, b, c, d, e;
@@ -6756,6 +6791,9 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake128_test(void)
67566791
"\xfa\x1b";
67576792
WOLFSSL_ENTER("shake128_test");
67586793

6794+
WC_ALLOC_VAR(shaCopy, wc_Shake, 1, HEAP_HINT);
6795+
if (!WC_VAR_OK(shaCopy))
6796+
return WC_TEST_RET_ENC_EC(MEMORY_E);
67596797

67606798
/*
67616799
** https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHAKE128_Msg0.pdf
@@ -6895,27 +6933,28 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake128_test(void)
68956933
ret = wc_InitShake128(&sha, HEAP_HINT, devId);
68966934
if (ret != 0)
68976935
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6898-
ret = wc_InitShake128(&shaCopy, HEAP_HINT, devId);
6936+
ret = wc_InitShake128(shaCopy, HEAP_HINT, devId);
68996937
if (ret != 0)
69006938
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6901-
ret = wc_Shake128_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
6939+
ret = wc_Shake128_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
69026940
if (ret != 0)
69036941
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
69046942
ret = wc_Shake128_Update(&sha, (byte*)a.input, (word32)a.inLen);
69056943
if (ret != 0)
69066944
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6907-
ret = wc_Shake128_Copy(&sha, &shaCopy);
6945+
ret = wc_Shake128_Copy(&sha, shaCopy);
69086946
if (ret != 0)
69096947
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
6910-
ret = wc_Shake128_Final(&shaCopy, hash, (word32)a.outLen);
6948+
ret = wc_Shake128_Final(shaCopy, hash, (word32)a.outLen);
69116949
if (ret != 0)
69126950
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
69136951
if (XMEMCMP(hash, a.output, a.outLen) != 0)
69146952
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
69156953

69166954
exit:
69176955
wc_Shake128_Free(&sha);
6918-
wc_Shake128_Free(&shaCopy);
6956+
wc_Shake128_Free(shaCopy);
6957+
WC_FREE_VAR(shaCopy, HEAP_HINT);
69196958

69206959
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
69216960
XFREE(large_input, NULL, DYNAMIC_TYPE_TMP_BUFFER);
@@ -7097,7 +7136,10 @@ static wc_test_ret_t shake256_absorb_test(wc_Shake* sha, byte *large_input_buf,
70977136

70987137
WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake256_test(void)
70997138
{
7100-
wc_Shake sha, shaCopy;
7139+
wc_Shake sha;
7140+
/* Heap-allocated when WOLFSSL_SMALL_STACK to avoid exceeding stack frame
7141+
* limit with two wc_Shake structs on the stack. */
7142+
WC_DECLARE_VAR(shaCopy, wc_Shake, 1, HEAP_HINT);
71017143
byte hash[250];
71027144

71037145
testVector a, b, c, d, e;
@@ -7122,6 +7164,11 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake256_test(void)
71227164
"\xea\x26";
71237165

71247166
WOLFSSL_ENTER("shake256_test");
7167+
7168+
WC_ALLOC_VAR(shaCopy, wc_Shake, 1, HEAP_HINT);
7169+
if (!WC_VAR_OK(shaCopy))
7170+
return WC_TEST_RET_ENC_EC(MEMORY_E);
7171+
71257172
/*
71267173
** https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHAKE256_Msg0.pdf
71277174
*/
@@ -7260,27 +7307,28 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t shake256_test(void)
72607307
ret = wc_InitShake256(&sha, HEAP_HINT, devId);
72617308
if (ret != 0)
72627309
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
7263-
ret = wc_InitShake256(&shaCopy, HEAP_HINT, devId);
7310+
ret = wc_InitShake256(shaCopy, HEAP_HINT, devId);
72647311
if (ret != 0)
72657312
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
7266-
ret = wc_Shake256_Update(&shaCopy, (byte*)b.input, (word32)b.inLen);
7313+
ret = wc_Shake256_Update(shaCopy, (byte*)b.input, (word32)b.inLen);
72677314
if (ret != 0)
72687315
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
72697316
ret = wc_Shake256_Update(&sha, (byte*)a.input, (word32)a.inLen);
72707317
if (ret != 0)
72717318
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
7272-
ret = wc_Shake256_Copy(&sha, &shaCopy);
7319+
ret = wc_Shake256_Copy(&sha, shaCopy);
72737320
if (ret != 0)
72747321
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
7275-
ret = wc_Shake256_Final(&shaCopy, hash, (word32)a.outLen);
7322+
ret = wc_Shake256_Final(shaCopy, hash, (word32)a.outLen);
72767323
if (ret != 0)
72777324
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
72787325
if (XMEMCMP(hash, a.output, a.outLen) != 0)
72797326
ERROR_OUT(WC_TEST_RET_ENC_NC, exit);
72807327

72817328
exit:
72827329
wc_Shake256_Free(&sha);
7283-
wc_Shake256_Free(&shaCopy);
7330+
wc_Shake256_Free(shaCopy);
7331+
WC_FREE_VAR(shaCopy, HEAP_HINT);
72847332

72857333
#if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
72867334
XFREE(large_input, NULL, DYNAMIC_TYPE_TMP_BUFFER);

0 commit comments

Comments
 (0)