From 6016cc0c974c2761617673fb920553d0467f6d1f Mon Sep 17 00:00:00 2001 From: Sean Parkinson Date: Tue, 25 Feb 2025 08:50:41 +1000 Subject: [PATCH] Digest testing: improve Make testing digests consistent. Add KATs for all digests. Check unaligned input and output works. Perform chunking tests for all digests. Fix Blake2b and Blake2s to checkout parameters in update and final functions. Fix Shake256 and Shake128 to checkout parameters in absorb and squeeze blocks functions. Add default digest size enums for Blake2b and Blake2s. --- tests/api.c | 121 +- tests/api/include.am | 1 + tests/api/test_blake2.c | 485 ++++++- tests/api/test_blake2.h | 10 + tests/api/test_digest.h | 692 ++++++++++ tests/api/test_md5.c | 190 +-- tests/api/test_md5.h | 6 + tests/api/test_ripemd.c | 190 ++- tests/api/test_ripemd.h | 2 + tests/api/test_sha.c | 208 ++- tests/api/test_sha.h | 7 + tests/api/test_sha256.c | 537 +++----- tests/api/test_sha256.h | 16 +- tests/api/test_sha3.c | 1810 +++++++++++++++++-------- tests/api/test_sha3.h | 34 +- tests/api/test_sha512.c | 1335 ++++++++---------- tests/api/test_sha512.h | 31 +- tests/api/test_sm3.c | 460 ++++--- tests/api/test_sm3.h | 13 +- wolfcrypt/src/blake2b.c | 21 +- wolfcrypt/src/blake2s.c | 21 +- wolfcrypt/src/port/arm/armv8-sha256.c | 12 +- wolfcrypt/src/port/arm/armv8-sha512.c | 17 +- wolfcrypt/src/sha256.c | 2 +- wolfcrypt/src/sha3.c | 18 +- wolfssl/wolfcrypt/blake2.h | 4 +- 26 files changed, 4155 insertions(+), 2088 deletions(-) create mode 100644 tests/api/test_digest.h diff --git a/tests/api.c b/tests/api.c index 4101c4e484..f86c6e4d80 100644 --- a/tests/api.c +++ b/tests/api.c @@ -98724,103 +98724,158 @@ TEST_CASE testCases[] = { TEST_DECL(test_wc_InitMd5), TEST_DECL(test_wc_Md5Update), TEST_DECL(test_wc_Md5Final), + TEST_DECL(test_wc_Md5_KATs), + TEST_DECL(test_wc_Md5_other), + TEST_DECL(test_wc_Md5Copy), + TEST_DECL(test_wc_Md5GetHash), + TEST_DECL(test_wc_Md5Transform), + TEST_DECL(test_wc_Md5_Flags), + + /* test_sha.c */ TEST_DECL(test_wc_InitSha), TEST_DECL(test_wc_ShaUpdate), TEST_DECL(test_wc_ShaFinal), + TEST_DECL(test_wc_ShaFinalRaw), + TEST_DECL(test_wc_Sha_KATs), + TEST_DECL(test_wc_Sha_other), + TEST_DECL(test_wc_ShaCopy), + TEST_DECL(test_wc_ShaGetHash), + TEST_DECL(test_wc_ShaTransform), + TEST_DECL(test_wc_Sha_Flags), /* test_sha256.c */ TEST_DECL(test_wc_InitSha256), TEST_DECL(test_wc_Sha256Update), TEST_DECL(test_wc_Sha256Final), TEST_DECL(test_wc_Sha256FinalRaw), - TEST_DECL(test_wc_Sha256GetFlags), - TEST_DECL(test_wc_Sha256Free), - TEST_DECL(test_wc_Sha256GetHash), + TEST_DECL(test_wc_Sha256_KATs), + TEST_DECL(test_wc_Sha256_other), TEST_DECL(test_wc_Sha256Copy), + TEST_DECL(test_wc_Sha256GetHash), + TEST_DECL(test_wc_Sha256Transform), + TEST_DECL(test_wc_Sha256_Flags), TEST_DECL(test_wc_InitSha224), TEST_DECL(test_wc_Sha224Update), TEST_DECL(test_wc_Sha224Final), - TEST_DECL(test_wc_Sha224SetFlags), - TEST_DECL(test_wc_Sha224GetFlags), - TEST_DECL(test_wc_Sha224Free), - TEST_DECL(test_wc_Sha224GetHash), + TEST_DECL(test_wc_Sha224_KATs), + TEST_DECL(test_wc_Sha224_other), TEST_DECL(test_wc_Sha224Copy), + TEST_DECL(test_wc_Sha224GetHash), + TEST_DECL(test_wc_Sha224_Flags), /* test_sha512.c */ TEST_DECL(test_wc_InitSha512), TEST_DECL(test_wc_Sha512Update), TEST_DECL(test_wc_Sha512Final), TEST_DECL(test_wc_Sha512FinalRaw), - TEST_DECL(test_wc_Sha512GetFlags), - TEST_DECL(test_wc_Sha512Free), - TEST_DECL(test_wc_Sha512GetHash), + TEST_DECL(test_wc_Sha512_KATs), + TEST_DECL(test_wc_Sha512_other), TEST_DECL(test_wc_Sha512Copy), + TEST_DECL(test_wc_Sha512GetHash), + TEST_DECL(test_wc_Sha512Transform), + TEST_DECL(test_wc_Sha512_Flags), TEST_DECL(test_wc_InitSha512_224), TEST_DECL(test_wc_Sha512_224Update), TEST_DECL(test_wc_Sha512_224Final), TEST_DECL(test_wc_Sha512_224FinalRaw), - TEST_DECL(test_wc_Sha512_224GetFlags), - TEST_DECL(test_wc_Sha512_224Free), - TEST_DECL(test_wc_Sha512_224GetHash), + TEST_DECL(test_wc_Sha512_224_KATs), + TEST_DECL(test_wc_Sha512_224_other), TEST_DECL(test_wc_Sha512_224Copy), + TEST_DECL(test_wc_Sha512_224GetHash), + TEST_DECL(test_wc_Sha512_224Transform), + TEST_DECL(test_wc_Sha512_224_Flags), TEST_DECL(test_wc_InitSha512_256), TEST_DECL(test_wc_Sha512_256Update), TEST_DECL(test_wc_Sha512_256Final), TEST_DECL(test_wc_Sha512_256FinalRaw), - TEST_DECL(test_wc_Sha512_256GetFlags), - TEST_DECL(test_wc_Sha512_256Free), - TEST_DECL(test_wc_Sha512_256GetHash), + TEST_DECL(test_wc_Sha512_256_KATs), + TEST_DECL(test_wc_Sha512_256_other), TEST_DECL(test_wc_Sha512_256Copy), + TEST_DECL(test_wc_Sha512_256GetHash), + TEST_DECL(test_wc_Sha512_256Transform), + TEST_DECL(test_wc_Sha512_256_Flags), TEST_DECL(test_wc_InitSha384), TEST_DECL(test_wc_Sha384Update), TEST_DECL(test_wc_Sha384Final), TEST_DECL(test_wc_Sha384FinalRaw), - TEST_DECL(test_wc_Sha384GetFlags), - TEST_DECL(test_wc_Sha384Free), - TEST_DECL(test_wc_Sha384GetHash), + TEST_DECL(test_wc_Sha384_KATs), + TEST_DECL(test_wc_Sha384_other), TEST_DECL(test_wc_Sha384Copy), + TEST_DECL(test_wc_Sha384GetHash), + TEST_DECL(test_wc_Sha384_Flags), /* test_sha3.c */ TEST_DECL(test_wc_InitSha3), TEST_DECL(test_wc_Sha3_Update), - TEST_DECL(test_wc_Sha3_224_Final), - TEST_DECL(test_wc_Sha3_256_Final), - TEST_DECL(test_wc_Sha3_384_Final), - TEST_DECL(test_wc_Sha3_512_Final), - TEST_DECL(test_wc_Sha3_224_Copy), - TEST_DECL(test_wc_Sha3_256_Copy), - TEST_DECL(test_wc_Sha3_384_Copy), - TEST_DECL(test_wc_Sha3_512_Copy), - TEST_DECL(test_wc_Sha3_GetFlags), + TEST_DECL(test_wc_Sha3_Final), + TEST_DECL(test_wc_Sha3_224_KATs), + TEST_DECL(test_wc_Sha3_256_KATs), + TEST_DECL(test_wc_Sha3_384_KATs), + TEST_DECL(test_wc_Sha3_512_KATs), + TEST_DECL(test_wc_Sha3_other), + TEST_DECL(test_wc_Sha3_Copy), + TEST_DECL(test_wc_Sha3_GetHash), + TEST_DECL(test_wc_Sha3_Flags), + + TEST_DECL(test_wc_InitShake128), + TEST_DECL(test_wc_Shake128_Update), + TEST_DECL(test_wc_Shake128_Final), + TEST_DECL(test_wc_Shake128_KATs), + TEST_DECL(test_wc_Shake128_other), + TEST_DECL(test_wc_Shake128_Copy), + TEST_DECL(test_wc_Shake128Hash), + TEST_DECL(test_wc_Shake128_Absorb), + TEST_DECL(test_wc_Shake128_SqueezeBlocks), + TEST_DECL(test_wc_Shake128_XOF), TEST_DECL(test_wc_InitShake256), TEST_DECL(test_wc_Shake256_Update), TEST_DECL(test_wc_Shake256_Final), + TEST_DECL(test_wc_Shake256_KATs), + TEST_DECL(test_wc_Shake256_other), TEST_DECL(test_wc_Shake256_Copy), TEST_DECL(test_wc_Shake256Hash), + TEST_DECL(test_wc_Shake256_Absorb), + TEST_DECL(test_wc_Shake256_SqueezeBlocks), + TEST_DECL(test_wc_Shake256_XOF), /* test_blake.c */ TEST_DECL(test_wc_InitBlake2b), TEST_DECL(test_wc_InitBlake2b_WithKey), + TEST_DECL(test_wc_Blake2bUpdate), + TEST_DECL(test_wc_Blake2bFinal), + TEST_DECL(test_wc_Blake2b_KATs), + TEST_DECL(test_wc_Blake2b_other), + + TEST_DECL(test_wc_InitBlake2s), TEST_DECL(test_wc_InitBlake2s_WithKey), + TEST_DECL(test_wc_Blake2sUpdate), + TEST_DECL(test_wc_Blake2sFinal), + TEST_DECL(test_wc_Blake2s_KATs), + TEST_DECL(test_wc_Blake2s_other), /* test_sm3.c: SM3 Digest */ - TEST_DECL(test_wc_InitSm3Free), - TEST_DECL(test_wc_Sm3UpdateFinal), - TEST_DECL(test_wc_Sm3GetHash), - TEST_DECL(test_wc_Sm3Copy), + TEST_DECL(test_wc_InitSm3), + TEST_DECL(test_wc_Sm3Update), + TEST_DECL(test_wc_Sm3Final), TEST_DECL(test_wc_Sm3FinalRaw), - TEST_DECL(test_wc_Sm3GetSetFlags), + TEST_DECL(test_wc_Sm3_KATs), + TEST_DECL(test_wc_Sm3_other), + TEST_DECL(test_wc_Sm3Copy), + TEST_DECL(test_wc_Sm3GetHash), + TEST_DECL(test_wc_Sm3_Flags), TEST_DECL(test_wc_Sm3Hash), /* test_ripemd.c */ TEST_DECL(test_wc_InitRipeMd), TEST_DECL(test_wc_RipeMdUpdate), TEST_DECL(test_wc_RipeMdFinal), + TEST_DECL(test_wc_RipeMd_KATs), + TEST_DECL(test_wc_RipeMd_other), /* test_hash.c */ TEST_DECL(test_wc_HashInit), diff --git a/tests/api/include.am b/tests/api/include.am index 45374b724a..95a7af9326 100644 --- a/tests/api/include.am +++ b/tests/api/include.am @@ -23,6 +23,7 @@ EXTRA_DIST += tests/api/test_sha3.h EXTRA_DIST += tests/api/test_blake2.h EXTRA_DIST += tests/api/test_sm3.h EXTRA_DIST += tests/api/test_ripemd.h +EXTRA_DIST += tests/api/test_digest.h EXTRA_DIST += tests/api/test_hash.h EXTRA_DIST += tests/api/test_ascon.h EXTRA_DIST += tests/api/test_ascon.h diff --git a/tests/api/test_blake2.c b/tests/api/test_blake2.c index d3931a55a7..2530c45374 100644 --- a/tests/api/test_blake2.c +++ b/tests/api/test_blake2.c @@ -41,30 +41,30 @@ #include #include -/* - * Unit test for the wc_InitBlake2b() - */ +/******************************************************************************* + * BLAKE2b + ******************************************************************************/ + int test_wc_InitBlake2b(void) { EXPECT_DECLS; #ifdef HAVE_BLAKE2 Blake2b blake; - /* Test good arg. */ - ExpectIntEQ(wc_InitBlake2b(&blake, 64), 0); /* Test bad arg. */ - ExpectIntEQ(wc_InitBlake2b(NULL, 64), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_InitBlake2b(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_InitBlake2b(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_InitBlake2b(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_InitBlake2b(&blake, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b(NULL, WC_BLAKE2B_DIGEST_SIZE), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); #endif return EXPECT_RESULT(); -} /* END test_wc_InitBlake2b*/ +} -/* - * Unit test for the wc_InitBlake2b_WithKey() - */ int test_wc_InitBlake2b_WithKey(void) { EXPECT_DECLS; @@ -76,21 +76,267 @@ int test_wc_InitBlake2b_WithKey(void) XMEMSET(key, 0, sizeof(key)); - /* Test good arg. */ - ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0); /* Test bad args. */ - ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, keylen), + ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, NULL, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, NULL, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, NULL, keylen), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, 256), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, keylen), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, NULL, keylen), 0); + ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0); #endif return EXPECT_RESULT(); -} /* END wc_InitBlake2b_WithKey*/ +} + +int test_wc_Blake2bUpdate(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2 + Blake2b blake; + + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + + /* Pass in bad values. */ + ExpectIntEQ(wc_Blake2bUpdate(NULL, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2bUpdate(NULL, NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 0), 0); + ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)"a", 1), 0); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Blake2bFinal(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2 + Blake2b blake; + byte hash[WC_BLAKE2B_DIGEST_SIZE]; + + /* Initialize */ + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + + /* Test bad args. */ + ExpectIntEQ(wc_Blake2bFinal(NULL, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2bFinal(&blake, NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2bFinal(NULL, hash, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0); +#endif + return EXPECT_RESULT(); +} + +#define BLAKE2B_KAT_CNT 7 +int test_wc_Blake2b_KATs(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2 + Blake2b blake; + + testVector blake2b_kat[BLAKE2B_KAT_CNT]; + byte hash[WC_BLAKE2B_DIGEST_SIZE]; + int i = 0; + + blake2b_kat[i].input = ""; + blake2b_kat[i].inLen = 0; + blake2b_kat[i].output = + "\x78\x6a\x02\xf7\x42\x01\x59\x03" + "\xc6\xc6\xfd\x85\x25\x52\xd2\x72" + "\x91\x2f\x47\x40\xe1\x58\x47\x61" + "\x8a\x86\xe2\x17\xf7\x1f\x54\x19" + "\xd2\x5e\x10\x31\xaf\xee\x58\x53" + "\x13\x89\x64\x44\x93\x4e\xb0\x4b" + "\x90\x3a\x68\x5b\x14\x48\xb7\x55" + "\xd5\x6f\x70\x1a\xfe\x9b\xe2\xce"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = "a"; + blake2b_kat[i].inLen = 1; + blake2b_kat[i].output = + "\x33\x3f\xcb\x4e\xe1\xaa\x7c\x11" + "\x53\x55\xec\x66\xce\xac\x91\x7c" + "\x8b\xfd\x81\x5b\xf7\x58\x7d\x32" + "\x5a\xec\x18\x64\xed\xd2\x4e\x34" + "\xd5\xab\xe2\xc6\xb1\xb5\xee\x3f" + "\xac\xe6\x2f\xed\x78\xdb\xef\x80" + "\x2f\x2a\x85\xcb\x91\xd4\x55\xa8" + "\xf5\x24\x9d\x33\x08\x53\xcb\x3c"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = "abc"; + blake2b_kat[i].inLen = 3; + blake2b_kat[i].output = + "\xba\x80\xa5\x3f\x98\x1c\x4d\x0d" + "\x6a\x27\x97\xb6\x9f\x12\xf6\xe9" + "\x4c\x21\x2f\x14\x68\x5a\xc4\xb7" + "\x4b\x12\xbb\x6f\xdb\xff\xa2\xd1" + "\x7d\x87\xc5\x39\x2a\xab\x79\x2d" + "\xc2\x52\xd5\xde\x45\x33\xcc\x95" + "\x18\xd3\x8a\xa8\xdb\xf1\x92\x5a" + "\xb9\x23\x86\xed\xd4\x00\x99\x23"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = "message digest"; + blake2b_kat[i].inLen = 14; + blake2b_kat[i].output = + "\x3c\x26\xce\x48\x7b\x1c\x0f\x06" + "\x23\x63\xaf\xa3\xc6\x75\xeb\xdb" + "\xf5\xf4\xef\x9b\xdc\x02\x2c\xfb" + "\xef\x91\xe3\x11\x1c\xdc\x28\x38" + "\x40\xd8\x33\x1f\xc3\x0a\x8a\x09" + "\x06\xcf\xf4\xbc\xdb\xcd\x23\x0c" + "\x61\xaa\xec\x60\xfd\xfa\xd4\x57" + "\xed\x96\xb7\x09\xa3\x82\x35\x9a"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = "abcdefghijklmnopqrstuvwxyz"; + blake2b_kat[i].inLen = 26; + blake2b_kat[i].output = + "\xc6\x8e\xde\x14\x3e\x41\x6e\xb7" + "\xb4\xaa\xae\x0d\x8e\x48\xe5\x5d" + "\xd5\x29\xea\xfe\xd1\x0b\x1d\xf1" + "\xa6\x14\x16\x95\x3a\x2b\x0a\x56" + "\x66\xc7\x61\xe7\xd4\x12\xe6\x70" + "\x9e\x31\xff\xe2\x21\xb7\xa7\xa7" + "\x39\x08\xcb\x95\xa4\xd1\x20\xb8" + "\xb0\x90\xa8\x7d\x1f\xbe\xdb\x4c"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789"; + blake2b_kat[i].inLen = 62; + blake2b_kat[i].output = + "\x99\x96\x48\x02\xe5\xc2\x5e\x70" + "\x37\x22\x90\x5d\x3f\xb8\x00\x46" + "\xb6\xbc\xa6\x98\xca\x9e\x2c\xc7" + "\xe4\x9b\x4f\xe1\xfa\x08\x7c\x2e" + "\xdf\x03\x12\xdf\xbb\x27\x5c\xf2" + "\x50\xa1\xe5\x42\xfd\x5d\xc2\xed" + "\xd3\x13\xf9\xc4\x91\x12\x7c\x2e" + "\x8c\x0c\x9b\x24\x16\x8e\x2d\x50"; + blake2b_kat[i].outLen = 0; + i++; + blake2b_kat[i].input = "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890"; + blake2b_kat[i].inLen = 80; + blake2b_kat[i].output = + "\x68\x6f\x41\xec\x5a\xff\xf6\xe8" + "\x7e\x1f\x07\x6f\x54\x2a\xa4\x66" + "\x46\x6f\xf5\xfb\xde\x16\x2c\x48" + "\x48\x1b\xa4\x8a\x74\x8d\x84\x27" + "\x99\xf5\xb3\x0f\x5b\x67\xfc\x68" + "\x47\x71\xb3\x3b\x99\x42\x06\xd0" + "\x5c\xc3\x10\xf3\x19\x14\xed\xd7" + "\xb9\x7e\x41\x86\x0d\x77\xd2\x82"; + blake2b_kat[i].outLen = 0; + + for (i = 0; i < BLAKE2B_KAT_CNT; i++) { + /* Do KAT. */ + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)blake2b_kat[i].input, + (word32)blake2b_kat[i].inLen), 0); + ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)blake2b_kat[i].output, WC_BLAKE2B_DIGEST_SIZE); + } +#endif + return EXPECT_RESULT(); +} + +int test_wc_Blake2b_other(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2 + Blake2b blake; + byte hash[WC_BLAKE2B_DIGEST_SIZE + 1]; + byte data[WC_BLAKE2B_DIGEST_SIZE * 8 + 1]; + int dataLen = WC_BLAKE2B_DIGEST_SIZE * 8; + const char* expHash = + "\xfb\xea\x44\x32\x0b\x4a\x40\x44" + "\xa0\xad\x54\x0c\x39\x62\xa6\x4d" + "\x2a\xc2\x08\x3f\xce\xb4\x1d\x71" + "\x77\x04\xa6\xfc\x38\xe5\xd9\x99" + "\xe6\x92\xf1\x9f\xe7\x21\x10\x94" + "\xe6\x08\xc1\x9c\x1d\xdf\x87\x11" + "\xfa\xf4\xe6\x7b\xf1\xe5\xc8\x12" + "\x55\x90\x05\x00\xfa\x0d\x61\x3d"; + int i; + int j; + + XMEMSET(data, 0xa5, sizeof(data)); + + /* Initialize */ + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + + /* Unaligned input and output buffer. */ + ExpectIntEQ(wc_Blake2bUpdate(&blake, data + 1, dataLen), 0); + ExpectIntEQ(wc_Blake2bFinal(&blake, hash + 1, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectBufEQ(hash + 1, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE); + + /* Test that empty updates work. */ + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 0), 0); + ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)"", 0), 0); + ExpectIntEQ(wc_Blake2bUpdate(&blake, data, dataLen), 0); + ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE); + + /* Ensure chunking works. */ + for (i = 1; i < dataLen; i++) { + ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0); + for (j = 0; j < dataLen; j += i) { + int len = dataLen - j; + if (i < len) + len = i; + ExpectIntEQ(wc_Blake2bUpdate(&blake, data + j, len), 0); + } + ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE); + } +#endif + return EXPECT_RESULT(); +} + +/******************************************************************************* + * BLAKE2s + ******************************************************************************/ + +int test_wc_InitBlake2s(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2S + Blake2s blake; + + /* Test bad arg. */ + ExpectIntEQ(wc_InitBlake2s(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s(&blake, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s(NULL, WC_BLAKE2S_DIGEST_SIZE), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); +#endif + return EXPECT_RESULT(); +} -/* - * Unit test for the wc_InitBlake2s_WithKey() - */ int test_wc_InitBlake2s_WithKey(void) { EXPECT_DECLS; @@ -100,15 +346,208 @@ int test_wc_InitBlake2s_WithKey(void) byte *key = (byte*)"01234567890123456789012345678901"; word32 keylen = BLAKE2S_KEYBYTES; - /* Test good arg. */ - ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0); /* Test bad args. */ - ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, keylen), + ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, NULL, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, NULL, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, 256), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, NULL, keylen), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, 256), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, keylen), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, NULL, keylen), 0); + ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Blake2sUpdate(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2S + Blake2s blake; + + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + + /* Pass in bad values. */ + ExpectIntEQ(wc_Blake2sUpdate(NULL, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2sUpdate(&blake, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2sUpdate(NULL, NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_Blake2sUpdate(&blake, NULL, 0), 0); + ExpectIntEQ(wc_Blake2sUpdate(&blake, (byte*)"a", 1), 0); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Blake2sFinal(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2S + Blake2s blake; + byte hash[WC_BLAKE2B_DIGEST_SIZE]; + + /* Initialize */ + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + + /* Test bad args. */ + ExpectIntEQ(wc_Blake2sFinal(NULL, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2sFinal(&blake, NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Blake2sFinal(NULL, hash, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_Blake2sFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0); +#endif + return EXPECT_RESULT(); +} + +#define BLAKE2S_KAT_CNT 7 +int test_wc_Blake2s_KATs(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2S + Blake2s blake; + + testVector blake2s_kat[BLAKE2S_KAT_CNT]; + byte hash[WC_BLAKE2S_DIGEST_SIZE]; + int i = 0; + + blake2s_kat[i].input = ""; + blake2s_kat[i].inLen = 0; + blake2s_kat[i].output = + "\x69\x21\x7a\x30\x79\x90\x80\x94" + "\xe1\x11\x21\xd0\x42\x35\x4a\x7c" + "\x1f\x55\xb6\x48\x2c\xa1\xa5\x1e" + "\x1b\x25\x0d\xfd\x1e\xd0\xee\xf9"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = "a"; + blake2s_kat[i].inLen = 1; + blake2s_kat[i].output = + "\x4a\x0d\x12\x98\x73\x40\x30\x37" + "\xc2\xcd\x9b\x90\x48\x20\x36\x87" + "\xf6\x23\x3f\xb6\x73\x89\x56\xe0" + "\x34\x9b\xd4\x32\x0f\xec\x3e\x90"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = "abc"; + blake2s_kat[i].inLen = 3; + blake2s_kat[i].output = + "\x50\x8c\x5e\x8c\x32\x7c\x14\xe2" + "\xe1\xa7\x2b\xa3\x4e\xeb\x45\x2f" + "\x37\x45\x8b\x20\x9e\xd6\x3a\x29" + "\x4d\x99\x9b\x4c\x86\x67\x59\x82"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = "message digest"; + blake2s_kat[i].inLen = 14; + blake2s_kat[i].output = + "\xfa\x10\xab\x77\x5a\xcf\x89\xb7" + "\xd3\xc8\xa6\xe8\x23\xd5\x86\xf6" + "\xb6\x7b\xdb\xac\x4c\xe2\x07\xfe" + "\x14\x5b\x7d\x3a\xc2\x5c\xd2\x8c"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = "abcdefghijklmnopqrstuvwxyz"; + blake2s_kat[i].inLen = 26; + blake2s_kat[i].output = + "\xbd\xf8\x8e\xb1\xf8\x6a\x0c\xdf" + "\x0e\x84\x0b\xa8\x8f\xa1\x18\x50" + "\x83\x69\xdf\x18\x6c\x73\x55\xb4" + "\xb1\x6c\xf7\x9f\xa2\x71\x0a\x12"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789"; + blake2s_kat[i].inLen = 62; + blake2s_kat[i].output = + "\xc7\x54\x39\xea\x17\xe1\xde\x6f" + "\xa4\x51\x0c\x33\x5d\xc3\xd3\xf3" + "\x43\xe6\xf9\xe1\xce\x27\x73\xe2" + "\x5b\x41\x74\xf1\xdf\x8b\x11\x9b"; + blake2s_kat[i].outLen = 0; + i++; + blake2s_kat[i].input = "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890"; + blake2s_kat[i].inLen = 80; + blake2s_kat[i].output = + "\xfd\xae\xdb\x29\x0a\x0d\x5a\xf9" + "\x87\x08\x64\xfe\xc2\xe0\x90\x20" + "\x09\x89\xdc\x9c\xd5\x3a\x3c\x09" + "\x21\x29\xe8\x53\x5e\x8b\x4f\x66"; + blake2s_kat[i].outLen = 0; + + for (i = 0; i < BLAKE2S_KAT_CNT; i++) { + /* Do KAT. */ + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectIntEQ(wc_Blake2sUpdate(&blake, (byte*)blake2s_kat[i].input, + (word32)blake2s_kat[i].inLen), 0); + ExpectIntEQ(wc_Blake2sFinal(&blake, hash, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)blake2s_kat[i].output, WC_BLAKE2S_DIGEST_SIZE); + } +#endif + return EXPECT_RESULT(); +} + +int test_wc_Blake2s_other(void) +{ + EXPECT_DECLS; +#ifdef HAVE_BLAKE2S + Blake2s blake; + byte hash[WC_BLAKE2S_DIGEST_SIZE + 1]; + byte data[WC_BLAKE2S_DIGEST_SIZE * 8 + 1]; + int dataLen = WC_BLAKE2S_DIGEST_SIZE * 8; + const char* expHash = + "\x30\x1c\x41\x93\xd0\x63\x99\xeb" + "\x17\x68\x7a\xfb\xba\x58\x47\x33" + "\xad\x62\xea\x91\x77\x20\xf0\x72" + "\x11\xe3\x9e\x29\xe9\xc8\x24\x59"; + int i; + int j; + + XMEMSET(data, 0xa5, sizeof(data)); + + /* Initialize */ + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + + /* Unaligned input and output buffer. */ + ExpectIntEQ(wc_Blake2sUpdate(&blake, data + 1, dataLen), 0); + ExpectIntEQ(wc_Blake2sFinal(&blake, hash + 1, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectBufEQ(hash + 1, (byte*)expHash, WC_BLAKE2S_DIGEST_SIZE); + + /* Test that empty updates work. */ + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectIntEQ(wc_Blake2sUpdate(&blake, NULL, 0), 0); + ExpectIntEQ(wc_Blake2sUpdate(&blake, (byte*)"", 0), 0); + ExpectIntEQ(wc_Blake2sUpdate(&blake, data, dataLen), 0); + ExpectIntEQ(wc_Blake2sFinal(&blake, hash, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2S_DIGEST_SIZE); + + /* Ensure chunking works. */ + for (i = 1; i < dataLen; i++) { + ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0); + for (j = 0; j < dataLen; j += i) { + int len = dataLen - j; + if (i < len) + len = i; + ExpectIntEQ(wc_Blake2sUpdate(&blake, data + j, len), 0); + } + ExpectIntEQ(wc_Blake2sFinal(&blake, hash, WC_BLAKE2S_DIGEST_SIZE), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2S_DIGEST_SIZE); + } #endif return EXPECT_RESULT(); -} /* END wc_InitBlake2s_WithKey*/ +} diff --git a/tests/api/test_blake2.h b/tests/api/test_blake2.h index 752256d47a..858694364c 100644 --- a/tests/api/test_blake2.h +++ b/tests/api/test_blake2.h @@ -24,6 +24,16 @@ int test_wc_InitBlake2b(void); int test_wc_InitBlake2b_WithKey(void); +int test_wc_Blake2bUpdate(void); +int test_wc_Blake2bFinal(void); +int test_wc_Blake2b_KATs(void); +int test_wc_Blake2b_other(void); + +int test_wc_InitBlake2s(void); int test_wc_InitBlake2s_WithKey(void); +int test_wc_Blake2sUpdate(void); +int test_wc_Blake2sFinal(void); +int test_wc_Blake2s_KATs(void); +int test_wc_Blake2s_other(void); #endif /* WOLFCRYPT_TEST_BLAKE2_H */ diff --git a/tests/api/test_digest.h b/tests/api/test_digest.h new file mode 100644 index 0000000000..c4a466efbc --- /dev/null +++ b/tests/api/test_digest.h @@ -0,0 +1,692 @@ +/* test_digest.h + * + * Copyright (C) 2006-2025 wolfSSL Inc. + * + * This file is part of wolfSSL. + * + * wolfSSL is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * wolfSSL is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA + */ + +#define PRINT_DATA(name, data, len) \ +do { \ + int ii; \ + fprintf(stderr, "%s\n", name); \ + for (ii = 0; ii < (int)(len); ii++) { \ + if ((ii % 8) == 0) \ + fprintf(stderr, " \""); \ + fprintf(stderr, "\\x%02x", (data)[ii]); \ + if ((ii % 8) == 7) \ + fprintf(stderr, "\"\n"); \ + } \ + if ((ii % 8) != 0) \ + fprintf(stderr, "\""); \ + fprintf(stderr, "\n"); \ +} while (0) + + +#define DIGEST_INIT_TEST(type, name) \ +do { \ + type dgst; \ + \ + /* Test bad arg. */ \ + ExpectIntEQ(wc_Init##name(NULL, HEAP_HINT, INVALID_DEVID), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good arg. */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + wc_##name##_Free(&dgst); \ + \ + wc_##name##_Free(NULL); \ +} while (0) + +#define DIGEST_INIT_AND_INIT_EX_TEST(type, name) \ + type dgst; \ + \ + /* Test bad arg. */ \ + ExpectIntEQ(wc_Init##name(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_Init##name##_ex(NULL, HEAP_HINT, INVALID_DEVID), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good arg. */ \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + wc_##name##Free(&dgst); \ + \ + ExpectIntEQ(wc_Init##name##_ex(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + wc_##name##Free(&dgst); \ + \ + wc_##name##Free(NULL) + +#define DIGEST_UPDATE_TEST(type, name) \ + type dgst; \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Pass in bad values. */ \ + ExpectIntEQ(wc_##name##Update(NULL, NULL, 1), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Update(&dgst, NULL, 1), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Update(NULL, NULL, 0), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + ExpectIntEQ(wc_##name##Update(&dgst, NULL, 0), 0); \ + ExpectIntEQ(wc_##name##Update(&dgst, (byte*)"a", 1), 0); \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_ALT_UPDATE_TEST(type, name) \ +do { \ + type dgst; \ + \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Pass in bad values. */ \ + ExpectIntEQ(wc_##name##_Update(NULL, NULL, 1), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Update(&dgst, NULL, 1), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Update(NULL, NULL, 0), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + ExpectIntEQ(wc_##name##_Update(&dgst, NULL, 0), 0); \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)"a", 1), 0); \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + +#define DIGEST_FINAL_TEST(type, name, upper) \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Final(&dgst, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good args. */ \ + ExpectIntEQ(wc_##name##Final(&dgst, hash), 0); \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_ALT_FINAL_TEST(type, name, upper) \ +do { \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##_Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Final(&dgst, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good args. */ \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash), 0); \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + +#define DIGEST_COUNT_FINAL_TEST(type, name, upper) \ +do { \ + type dgst; \ + byte hash[WC_##upper##_COUNT * 8]; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##_Final(NULL, NULL, WC_##upper##_COUNT * 8), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Final(&dgst, NULL, WC_##upper##_COUNT * 8), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Final(NULL, hash, WC_##upper##_COUNT * 8), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good args. */ \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash, WC_##upper##_COUNT * 8), 0); \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + +#define DIGEST_FINAL_RAW_TEST(type, name, upper, hashStr) \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + const char* expHash = hashStr; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##FinalRaw(NULL, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##FinalRaw(&dgst, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##FinalRaw(NULL, hash), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test good args. */ \ + ExpectIntEQ(wc_##name##FinalRaw(&dgst, hash), 0); \ + ExpectBufEQ(hash, expHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_KATS_TEST_VARS(type, upper) \ + type dgst; \ + testVector dgst_kat[upper##_KAT_CNT]; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + int i = 0 + +#define DIGEST_COUNT_KATS_TEST_VARS(type, upper, count) \ + type dgst; \ + testVector dgst_kat[upper##_KAT_CNT]; \ + byte hash[WC_##count##_COUNT * 8]; \ + int i = 0 + +#define DIGEST_KATS_ADD(in, len, out) \ + dgst_kat[i].input = in; \ + dgst_kat[i].inLen = len; \ + dgst_kat[i].output = out; \ + dgst_kat[i].outLen = 0; \ + i++ + +#define DIGEST_KATS_TEST(name, upper) \ + (void)i; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + for (i = 0; i < upper##_KAT_CNT; i++) { \ + /* Do KAT. */ \ + ExpectIntEQ(wc_##name##Update(&dgst, (byte*)dgst_kat[i].input, \ + (word32)dgst_kat[i].inLen), 0); \ + ExpectIntEQ(wc_##name##Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)dgst_kat[i].output, \ + WC_##upper##_DIGEST_SIZE); \ + } \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_COUNT_KATS_TEST(name, upper, count) \ + (void)i; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + for (i = 0; i < upper##_KAT_CNT; i++) { \ + /* Do KAT. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)dgst_kat[i].input, \ + (word32)dgst_kat[i].inLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash, WC_##count##_COUNT * 8), \ + 0); \ + ExpectBufEQ(hash, (byte*)dgst_kat[i].output, \ + WC_##count##_COUNT * 8); \ + } \ + \ + wc_##name##_Free(&dgst) + +#define DIGEST_OTHER_TEST(type, name, upper, hashStr) \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE + 1]; \ + byte data[WC_##upper##_DIGEST_SIZE * 8 + 1]; \ + int dataLen = WC_##upper##_DIGEST_SIZE * 8; \ + const char* expHash = hashStr; \ + int i; \ + int j; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Unaligned input and output buffer. */ \ + ExpectIntEQ(wc_##name##Update(&dgst, data + 1, dataLen), 0); \ + ExpectIntEQ(wc_##name##Final(&dgst, hash + 1), 0); \ + ExpectBufEQ(hash + 1, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + \ + /* Test that empty updates work. */ \ + ExpectIntEQ(wc_##name##Update(&dgst, NULL, 0), 0); \ + ExpectIntEQ(wc_##name##Update(&dgst, (byte*)"", 0), 0); \ + ExpectIntEQ(wc_##name##Update(&dgst, data, dataLen), 0); \ + ExpectIntEQ(wc_##name##Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + \ + /* Ensure chunking works. */ \ + for (i = 1; i < dataLen; i++) { \ + for (j = 0; j < dataLen; j += i) { \ + int len = dataLen - j; \ + if (i < len) \ + len = i; \ + ExpectIntEQ(wc_##name##Update(&dgst, data + j, len), 0); \ + } \ + ExpectIntEQ(wc_##name##Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + } \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_ALT_OTHER_TEST(type, name, upper, hashStr) \ +do { \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE + 1]; \ + byte data[WC_##upper##_DIGEST_SIZE * 8 + 1]; \ + int dataLen = WC_##upper##_DIGEST_SIZE * 8; \ + const char* expHash = hashStr; \ + int i; \ + int j; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Unaligned input and output buffer. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, data + 1, dataLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash + 1), 0); \ + ExpectBufEQ(hash + 1, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + \ + /* Test that empty updates work. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, NULL, 0), 0); \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)"", 0), 0); \ + ExpectIntEQ(wc_##name##_Update(&dgst, data, dataLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + \ + /* Ensure chunking works. */ \ + for (i = 1; i < dataLen; i++) { \ + for (j = 0; j < dataLen; j += i) { \ + int len = dataLen - j; \ + if (i < len) \ + len = i; \ + ExpectIntEQ(wc_##name##_Update(&dgst, data + j, len), 0); \ + } \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_DIGEST_SIZE); \ + } \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + +#define DIGEST_COUNT_OTHER_TEST(type, name, upper, hashStr) \ +do { \ + type dgst; \ + byte hash[WC_##upper##_COUNT * 8 + 1]; \ + byte data[WC_##upper##_COUNT * 8 * 8 + 1]; \ + int dataLen = WC_##upper##_COUNT * 8 * 8; \ + const char* expHash = hashStr; \ + int i; \ + int j; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Unaligned input and output buffer. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, data + 1, dataLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash + 1, WC_##upper##_COUNT * 8), \ + 0); \ + ExpectBufEQ(hash + 1, (byte*)expHash, WC_##upper##_COUNT * 8); \ + \ + /* Test that empty updates work. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, NULL, 0), 0); \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)"", 0), 0); \ + ExpectIntEQ(wc_##name##_Update(&dgst, data, dataLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash, WC_##upper##_COUNT * 8), 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_COUNT * 8); \ + \ + /* Ensure chunking works. */ \ + for (i = 1; i < dataLen; i++) { \ + for (j = 0; j < dataLen; j += i) { \ + int len = dataLen - j; \ + if (i < len) \ + len = i; \ + ExpectIntEQ(wc_##name##_Update(&dgst, data + j, len), 0); \ + } \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash, WC_##upper##_COUNT * 8), \ + 0); \ + ExpectBufEQ(hash, (byte*)expHash, WC_##upper##_COUNT * 8); \ + } \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + +#define DIGEST_COPY_TEST(type, name, upper, emptyHashStr, abcHashStr) \ + type src; \ + type dst; \ + byte hashSrc[WC_##upper##_DIGEST_SIZE]; \ + byte hashDst[WC_##upper##_DIGEST_SIZE]; \ + const char* emptyHash = emptyHashStr; \ + const char* abcHash = abcHashStr; \ + byte data[WC_##upper##_BLOCK_SIZE]; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + ExpectIntEQ(wc_Init##name(&src), 0); \ + XMEMSET(&dst, 0, sizeof(dst)); \ + \ + /* Tests bad params. */ \ + ExpectIntEQ(wc_##name##Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Copy(&src, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##Copy(NULL, &dst), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test copy works. */ \ + ExpectIntEQ(wc_##name##Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, emptyHash, WC_##upper##_DIGEST_SIZE); \ + ExpectBufEQ(hashDst, emptyHash, WC_##upper##_DIGEST_SIZE); \ + wc_##name##Free(&dst); \ + \ + /* Test buffered data is copied. */ \ + ExpectIntEQ(wc_##name##Update(&src, (byte*)"abc", 3), 0); \ + ExpectIntEQ(wc_##name##Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, abcHash, WC_##upper##_DIGEST_SIZE); \ + ExpectBufEQ(hashDst, abcHash, WC_##upper##_DIGEST_SIZE); \ + wc_##name##Free(&dst); \ + \ + /* Test count of length is copied. */ \ + ExpectIntEQ(wc_##name##Update(&src, data, sizeof(data)), 0); \ + ExpectIntEQ(wc_##name##Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, hashDst, WC_##upper##_DIGEST_SIZE); \ + wc_##name##Free(&dst); \ + \ + wc_##name##Free(&src) + +#define DIGEST_ALT_COPY_TEST(type, name, upper, emptyHashStr, abcHashStr) \ +do { \ + type src; \ + type dst; \ + byte hashSrc[WC_##upper##_DIGEST_SIZE]; \ + byte hashDst[WC_##upper##_DIGEST_SIZE]; \ + const char* emptyHash = emptyHashStr; \ + const char* abcHash = abcHashStr; \ + byte data[WC_##upper##_BLOCK_SIZE]; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + ExpectIntEQ(wc_Init##name(&src, HEAP_HINT, INVALID_DEVID), 0); \ + XMEMSET(&dst, 0, sizeof(dst)); \ + \ + ExpectIntEQ(wc_##name##_Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Copy(&src, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Copy(NULL, &dst), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test copy works. */ \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, emptyHash, WC_##upper##_DIGEST_SIZE); \ + ExpectBufEQ(hashDst, emptyHash, WC_##upper##_DIGEST_SIZE); \ + wc_##name##_Free(&dst); \ + \ + /* Test buffered data is copied. */ \ + ExpectIntEQ(wc_##name##_Update(&src, (byte*)"abc", 3), 0); \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, abcHash, WC_##upper##_DIGEST_SIZE); \ + ExpectBufEQ(hashDst, abcHash, WC_##upper##_DIGEST_SIZE); \ + wc_##name##_Free(&dst); \ + \ + /* Test count of length is copied. */ \ + ExpectIntEQ(wc_##name##_Update(&src, data, sizeof(data)), 0); \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst), 0); \ + ExpectBufEQ(hashSrc, hashDst, WC_##upper##_DIGEST_SIZE); \ + wc_##name##_Free(&dst); \ + \ + wc_##name##_Free(&src); \ +} while (0) + +#define DIGEST_COUNT_COPY_TEST(type, name, upper, emptyHashStr, abcHashStr) \ +do { \ + type src; \ + type dst; \ + byte hashSrc[WC_##upper##_COUNT * 8]; \ + byte hashDst[WC_##upper##_COUNT * 8]; \ + const char* emptyHash = emptyHashStr; \ + const char* abcHash = abcHashStr; \ + byte data[WC_##upper##_BLOCK_SIZE]; \ + \ + XMEMSET(data, 0xa5, sizeof(data)); \ + \ + ExpectIntEQ(wc_Init##name(&src, HEAP_HINT, INVALID_DEVID), 0); \ + XMEMSET(&dst, 0, sizeof(dst)); \ + \ + ExpectIntEQ(wc_##name##_Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Copy(&src, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_Copy(NULL, &dst), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + /* Test copy works. */ \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc, WC_##upper##_COUNT * 8), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst, WC_##upper##_COUNT * 8), 0); \ + ExpectBufEQ(hashSrc, emptyHash, WC_##upper##_COUNT * 8); \ + ExpectBufEQ(hashDst, emptyHash, WC_##upper##_COUNT * 8); \ + wc_##name##_Free(&src); \ + \ + /* Test buffered data is copied. */ \ + ExpectIntEQ(wc_##name##_Update(&src, (byte*)"abc", 3), 0); \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc, WC_##upper##_COUNT * 8), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst, WC_##upper##_COUNT * 8), 0); \ + ExpectBufEQ(hashSrc, abcHash, WC_##upper##_COUNT * 8); \ + ExpectBufEQ(hashDst, abcHash, WC_##upper##_COUNT * 8); \ + wc_##name##_Free(&src); \ + \ + /* Test count of length is copied. */ \ + ExpectIntEQ(wc_##name##_Update(&src, data, sizeof(data)), 0); \ + ExpectIntEQ(wc_##name##_Copy(&src, &dst), 0); \ + ExpectIntEQ(wc_##name##_Final(&src, hashSrc, WC_##upper##_COUNT * 8), 0); \ + ExpectIntEQ(wc_##name##_Final(&dst, hashDst, WC_##upper##_COUNT * 8), 0); \ + ExpectBufEQ(hashSrc, hashDst, WC_##upper##_COUNT * 8); \ + wc_##name##_Free(&dst); \ + \ + wc_##name##_Free(&src); \ +} while (0) + +#define DIGEST_GET_HASH_TEST(type, name, upper, emptyHashStr, abcHashStr) \ + type dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + const char* emptyHash = emptyHashStr; \ + const char* abcHash = abcHashStr; \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + ExpectIntEQ(wc_##name##GetHash(NULL, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##GetHash(&dgst, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##GetHash(NULL, hash), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + ExpectIntEQ(wc_##name##GetHash(&dgst, hash), 0); \ + ExpectBufEQ(hash, emptyHash, WC_##upper##_DIGEST_SIZE); \ + /* Test that the hash state hasn't been modified. */ \ + ExpectIntEQ(wc_##name##Update(&dgst, (byte*)"abc", 3), 0); \ + ExpectIntEQ(wc_##name##GetHash(&dgst, hash), 0); \ + ExpectBufEQ(hash, abcHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#ifdef LITTLE_ENDIAN_ORDER + +#define DIGEST_TRANSFORM_TEST(type, name, upper, abcBlockStr, abcHashStr) \ + type dgst; \ + const char* abc##name##Data = abcBlockStr; \ + const char* abcHash = abcHashStr; \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##Transform(NULL, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(&dgst, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(NULL, (byte*)abc##name##Data), \ + BAD_FUNC_ARG); \ + \ + ExpectIntEQ(wc_##name##Transform(&dgst, (byte*)abc##name##Data), 0); \ + ExpectBufEQ((byte*)dgst.digest, (byte*)abcHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_TRANSFORM_FINAL_RAW_TEST(type, name, upper, abcBlockStr, \ + abcHashStr) \ + type dgst; \ + const char* abc##name##Data = abcBlockStr; \ + const char* abcHash = abcHashStr; \ + byte abcData[WC_##upper##_BLOCK_SIZE]; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + \ + XMEMCPY(abcData, abc##name##Data, WC_##upper##_BLOCK_SIZE); \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##Transform(NULL, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(&dgst, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(NULL, (byte*)abc##name##Data), \ + BAD_FUNC_ARG); \ + \ + ExpectIntEQ(wc_##name##Transform(&dgst, (byte*)abcData), 0); \ + ExpectIntEQ(wc_##name##FinalRaw(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)abcHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#else + +#define DIGEST_TRANSFORM_TEST(type, name, upper, abcBlockStr, abcHashStr) \ + type dgst; \ + const char* abc##name##Data = abcBlockStr; \ + const char* abcHash = abcHashStr; \ + char abc##name##DataBE[WC_##upper##_BLOCK_SIZE]; \ + char abcHashBE[WC_##upper##_DIGEST_SIZE]; \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##Transform(NULL, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(&dgst, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(NULL, (byte*)abc##name##Data), \ + BAD_FUNC_ARG); \ + \ + ByteReverseWords((word32*)abc##name##DataBE, (word32*)abc##name##Data, \ + WC_##upper##_BLOCK_SIZE); \ + ByteReverseWords((word32*)abcHashBE, (word32*)abcHash, \ + WC_##upper##_DIGEST_SIZE); \ + ExpectIntEQ(wc_##name##Transform(&dgst, (byte*)abc##name##DataBE), 0); \ + ExpectBufEQ((byte*)dgst.digest, (byte*)abcHashBE, \ + WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#define DIGEST_TRANSFORM_FINAL_RAW_TEST(type, name, upper, abcBlockStr, \ + abcHashStr) \ + type dgst; \ + const char* abc##name##Data = abcBlockStr; \ + const char* abcHash = abcHashStr; \ + char abc##name##DataBE[WC_##upper##_BLOCK_SIZE]; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Test bad args. */ \ + ExpectIntEQ(wc_##name##Transform(NULL, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(&dgst, NULL), BAD_FUNC_ARG); \ + ExpectIntEQ(wc_##name##Transform(NULL, (byte*)abc##name##Data), \ + BAD_FUNC_ARG); \ + \ + ByteReverseWords((word32*)abc##name##DataBE, (word32*)abc##name##Data, \ + WC_##upper##_BLOCK_SIZE); \ + ExpectIntEQ(wc_##name##Transform(&dgst, (byte*)abc##name##DataBE), 0); \ + ExpectIntEQ(wc_##name##FinalRaw(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)abcHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##Free(&dgst) + +#endif + +#define DIGEST_FLAGS_TEST(type, name) \ + type dgst; \ + type dgst_copy; \ + word32 flags; \ + \ + XMEMSET(&dgst_copy, 0, sizeof(dgst_copy)); \ + ExpectIntEQ(wc_Init##name(&dgst), 0); \ + \ + /* Do nothing. */ \ + ExpectIntEQ(wc_##name##GetFlags(NULL, NULL), 0); \ + ExpectIntEQ(wc_##name##GetFlags(&dgst, NULL), 0); \ + ExpectIntEQ(wc_##name##GetFlags(NULL, &flags), 0); \ + ExpectIntEQ(wc_##name##SetFlags(NULL, 1), 0); \ + \ + ExpectIntEQ(wc_##name##GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, 0); \ + \ + ExpectIntEQ(wc_##name##Copy(&dgst, &dgst_copy), 0); \ + ExpectIntEQ(wc_##name##GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, 0); \ + ExpectIntEQ(wc_##name##GetFlags(&dgst_copy, &flags), 0); \ + ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY); \ + \ + ExpectIntEQ(wc_##name##SetFlags(&dgst, WC_HASH_FLAG_WILLCOPY), 0); \ + ExpectIntEQ(wc_##name##GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, WC_HASH_FLAG_WILLCOPY); \ + ExpectIntEQ(wc_##name##SetFlags(&dgst, 0), 0); \ + \ + wc_##name##Free(&dgst_copy); \ + wc_##name##Free(&dgst) + +#define DIGEST_ALT_FLAGS_TEST(type, name, inst) \ + type dgst; \ + type dgst_copy; \ + word32 flags; \ + \ + XMEMSET(&dgst_copy, 0, sizeof(dgst_copy)); \ + ExpectIntEQ(wc_Init##inst(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + /* Do nothing. */ \ + ExpectIntEQ(wc_##name##_GetFlags(NULL, NULL), 0); \ + ExpectIntEQ(wc_##name##_GetFlags(&dgst, NULL), 0); \ + ExpectIntEQ(wc_##name##_GetFlags(NULL, &flags), 0); \ + ExpectIntEQ(wc_##name##_SetFlags(NULL, 1), 0); \ + \ + ExpectIntEQ(wc_##name##_GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, 0); \ + \ + ExpectIntEQ(wc_##inst##_Copy(&dgst, &dgst_copy), 0); \ + ExpectIntEQ(wc_##name##_GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, 0); \ + ExpectIntEQ(wc_##name##_GetFlags(&dgst_copy, &flags), 0); \ + ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY); \ + \ + ExpectIntEQ(wc_##name##_SetFlags(&dgst, 1), 0); \ + ExpectIntEQ(wc_##name##_GetFlags(&dgst, &flags), 0); \ + ExpectIntEQ(flags, 1); \ + ExpectIntEQ(wc_##name##_SetFlags(&dgst, 0), 0); \ + \ + wc_##inst##_Free(&dgst_copy); \ + wc_##inst##_Free(&dgst) + diff --git a/tests/api/test_md5.c b/tests/api/test_md5.c index 7022635812..2e94b88d2a 100644 --- a/tests/api/test_md5.c +++ b/tests/api/test_md5.c @@ -40,104 +40,138 @@ #include #include #include +#include -/* - * Unit test for the wc_InitMd5() - */ +/* Unit test for wc_InitMd5() and wc_InitMd5_ex() */ int test_wc_InitMd5(void) { EXPECT_DECLS; #ifndef NO_MD5 - wc_Md5 md5; + DIGEST_INIT_AND_INIT_EX_TEST(wc_Md5, Md5); +#endif + return EXPECT_RESULT(); +} - /* Test good arg. */ - ExpectIntEQ(wc_InitMd5(&md5), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitMd5(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +/* Unit test for wc_UpdateMd5() */ +int test_wc_Md5Update(void) +{ + EXPECT_DECLS; +#ifndef NO_MD5 + DIGEST_UPDATE_TEST(wc_Md5, Md5); +#endif + return EXPECT_RESULT(); +} - wc_Md5Free(&md5); +/* Unit test for wc_Md5Final() */ +int test_wc_Md5Final(void) +{ + EXPECT_DECLS; +#ifndef NO_MD5 + DIGEST_FINAL_TEST(wc_Md5, Md5, MD5); #endif return EXPECT_RESULT(); -} /* END test_wc_InitMd5 */ +} +#define MD5_KAT_CNT 7 -/* - * Testing wc_UpdateMd5() - */ -int test_wc_Md5Update(void) +int test_wc_Md5_KATs(void) { EXPECT_DECLS; #ifndef NO_MD5 - wc_Md5 md5; - byte hash[WC_MD5_DIGEST_SIZE]; - testVector a, b, c; - - ExpectIntEQ(wc_InitMd5(&md5), 0); - - /* Input */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Md5Update(&md5, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Md5Final(&md5, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f" - "\x72"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Md5Update(&md5, (byte*) a.input, (word32) a.inLen), 0); - ExpectIntEQ(wc_Md5Final(&md5, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_MD5_DIGEST_SIZE), 0); - - /* Pass in bad values. */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_Md5Update(&md5, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_MD5_DIGEST_SIZE; - ExpectIntEQ(wc_Md5Update(&md5, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Md5Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Md5Free(&md5); + DIGEST_KATS_TEST_VARS(wc_Md5, MD5); + + /* From RFC 1321. */ + DIGEST_KATS_ADD("", 0, + "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04" + "\xe9\x80\x09\x98\xec\xf8\x42\x7e"); + DIGEST_KATS_ADD("a", 1, + "\x0c\xc1\x75\xb9\xc0\xf1\xb6\xa8" + "\x31\xc3\x99\xe2\x69\x77\x26\x61"); + DIGEST_KATS_ADD("abc", 3, + "\x90\x01\x50\x98\x3c\xd2\x4f\xb0" + "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72"); + DIGEST_KATS_ADD("message digest", 14, + "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d" + "\x52\x5a\x2f\x31\xaa\xf1\x61\xd0"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xc3\xfc\xd3\xd7\x61\x92\xe4\x00" + "\x7d\xfb\x49\x6c\xca\x67\xe1\x3b"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xd1\x74\xab\x98\xd2\x77\xd9\xf5" + "\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55" + "\xac\x49\xda\x2e\x21\x07\xb6\x7a"); + + DIGEST_KATS_TEST(Md5, MD5); #endif return EXPECT_RESULT(); -} /* END test_wc_Md5Update() */ +} -/* - * Unit test on wc_Md5Final() in wolfcrypt/src/md5.c - */ -int test_wc_Md5Final(void) +int test_wc_Md5_other(void) { EXPECT_DECLS; #ifndef NO_MD5 - /* Instantiate */ - wc_Md5 md5; - byte* hash_test[3]; - byte hash1[WC_MD5_DIGEST_SIZE]; - byte hash2[2*WC_MD5_DIGEST_SIZE]; - byte hash3[5*WC_MD5_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitMd5(&md5), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test)/sizeof(byte*); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Md5Final(&md5, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Md5Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Md5Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Md5Final(&md5, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Md5Free(&md5); + DIGEST_OTHER_TEST(wc_Md5, Md5, MD5, + "\xd9\xa6\xc2\x1f\xf4\x05\xab\x62" + "\xd6\xad\xa8\xcd\x0c\xb9\x49\x14"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Md5Copy(void) +{ + EXPECT_DECLS; +#ifndef NO_MD5 + DIGEST_COPY_TEST(wc_Md5, Md5, MD5, + "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04" + "\xe9\x80\x09\x98\xec\xf8\x42\x7e", + "\x90\x01\x50\x98\x3c\xd2\x4f\xb0" + "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Md5GetHash(void) +{ + EXPECT_DECLS; +#ifndef NO_MD5 + DIGEST_GET_HASH_TEST(wc_Md5, Md5, MD5, + "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04" + "\xe9\x80\x09\x98\xec\xf8\x42\x7e", + "\x90\x01\x50\x98\x3c\xd2\x4f\xb0" + "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Md5Transform(void) +{ + EXPECT_DECLS; +#if !defined(NO_MD5) && (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_MD5_CUST_API) + DIGEST_TRANSFORM_TEST(wc_Md5, Md5, MD5, + "\x61\x62\x63\x80\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x18\x00\x00\x00\x00\x00\x00\x00", + "\x90\x01\x50\x98\x3c\xd2\x4f\xb0" + "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Md5_Flags(void) +{ + EXPECT_DECLS; +#if !defined(NO_MD5) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Md5, Md5); #endif return EXPECT_RESULT(); } diff --git a/tests/api/test_md5.h b/tests/api/test_md5.h index f9c5e07ece..56ec522e38 100644 --- a/tests/api/test_md5.h +++ b/tests/api/test_md5.h @@ -25,5 +25,11 @@ int test_wc_InitMd5(void); int test_wc_Md5Update(void); int test_wc_Md5Final(void); +int test_wc_Md5_KATs(void); +int test_wc_Md5_other(void); +int test_wc_Md5Copy(void); +int test_wc_Md5GetHash(void); +int test_wc_Md5Transform(void); +int test_wc_Md5_Flags(void); #endif /* WOLFCRYPT_TEST_MD5_H */ diff --git a/tests/api/test_ripemd.c b/tests/api/test_ripemd.c index 5b030cf31a..a59cdb5996 100644 --- a/tests/api/test_ripemd.c +++ b/tests/api/test_ripemd.c @@ -40,6 +40,7 @@ #include #include #include +#include /* * Testing wc_InitRipeMd() @@ -50,10 +51,11 @@ int test_wc_InitRipeMd(void) #ifdef WOLFSSL_RIPEMD RipeMd ripemd; - /* Test good arg. */ - ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); /* Test bad arg. */ ExpectIntEQ(wc_InitRipeMd(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ + ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); #endif return EXPECT_RESULT(); @@ -67,37 +69,20 @@ int test_wc_RipeMdUpdate(void) EXPECT_DECLS; #ifdef WOLFSSL_RIPEMD RipeMd ripemd; - byte hash[RIPEMD_DIGEST_SIZE]; - testVector a, b, c; ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); - /* Input */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6" - "\xb0\x87\xf1\x5a\x0b\xfc"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, RIPEMD_DIGEST_SIZE), 0); - - /* Pass in bad values. */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = RIPEMD_DIGEST_SIZE; - ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)c.input, (word32)c.inLen), + /* Test bad arg. */ + ExpectIntEQ(wc_RipeMdUpdate(NULL , NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_RipeMdUpdate(NULL, (byte*)a.input, (word32)a.inLen), + ExpectIntEQ(wc_RipeMdUpdate(NULL , NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good arg. */ + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 0), 0); + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)"a", 1), 0); #endif return EXPECT_RESULT(); } /* END test_wc_RipeMdUdpate */ @@ -110,30 +95,149 @@ int test_wc_RipeMdFinal(void) EXPECT_DECLS; #ifdef WOLFSSL_RIPEMD RipeMd ripemd; - byte* hash_test[3]; - byte hash1[RIPEMD_DIGEST_SIZE]; - byte hash2[2*RIPEMD_DIGEST_SIZE]; - byte hash3[5*RIPEMD_DIGEST_SIZE]; - int times, i; + byte hash[RIPEMD_DIGEST_SIZE]; /* Initialize */ ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - /* Testing oversized buffers. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash_test[i]), 0); - } - /* Test bad args. */ ExpectIntEQ(wc_RipeMdFinal(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_RipeMdFinal(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_RipeMdFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_RipeMdFinal(&ripemd, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); #endif return EXPECT_RESULT(); } /* END test_wc_RipeMdFinal */ +#define RIPEMD_KAT_CNT 7 +int test_wc_RipeMd_KATs( void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_RIPEMD + RipeMd ripemd; + testVector ripemd_kat[RIPEMD_KAT_CNT]; + byte hash[RIPEMD_DIGEST_SIZE]; + int i = 0; + + ripemd_kat[i].input = ""; + ripemd_kat[i].inLen = 0; + ripemd_kat[i].output = + "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54" + "\x61\x28\x08\x97\x7e\xe8\xf5\x48" + "\xb2\x25\x8d\x31"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = "a"; + ripemd_kat[i].inLen = 1; + ripemd_kat[i].output = + "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9" + "\xda\xae\x34\x7b\xe6\xf4\xdc\x83" + "\x5a\x46\x7f\xfe"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = "abc"; + ripemd_kat[i].inLen = 3; + ripemd_kat[i].output = + "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a" + "\x9b\x04\x4a\x8e\x98\xc6\xb0\x87" + "\xf1\x5a\x0b\xfc"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = "message digest"; + ripemd_kat[i].inLen = 14; + ripemd_kat[i].output = + "\x5d\x06\x89\xef\x49\xd2\xfa\xe5" + "\x72\xb8\x81\xb1\x23\xa8\x5f\xfa" + "\x21\x59\x5f\x36"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = "abcdefghijklmnopqrstuvwxyz"; + ripemd_kat[i].inLen = 26; + ripemd_kat[i].output = + "\xf7\x1c\x27\x10\x9c\x69\x2c\x1b" + "\x56\xbb\xdc\xeb\x5b\x9d\x28\x65" + "\xb3\x70\x8d\xbc"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789"; + ripemd_kat[i].inLen = 62; + ripemd_kat[i].output = + "\xb0\xe2\x0b\x6e\x31\x16\x64\x02" + "\x86\xed\x3a\x87\xa5\x71\x30\x79" + "\xb2\x1f\x51\x89"; + ripemd_kat[i].outLen = 0; + i++; + ripemd_kat[i].input = "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890"; + ripemd_kat[i].inLen = 80; + ripemd_kat[i].output = + "\x9b\x75\x2e\x45\x57\x3d\x4b\x39" + "\xf4\xdb\xd3\x32\x3c\xab\x82\xbf" + "\x63\x32\x6b\xfb"; + ripemd_kat[i].outLen = 0; + + ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); + for (i = 0; i < RIPEMD_KAT_CNT; i++) { + /* Do KAT. */ + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)ripemd_kat[i].input, + (word32)ripemd_kat[i].inLen), 0); + ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); + ExpectBufEQ(hash, (byte*)ripemd_kat[i].output, RIPEMD_DIGEST_SIZE); + } +#endif + return EXPECT_RESULT(); +} + +int test_wc_RipeMd_other(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_RIPEMD + RipeMd ripemd; + byte hash[RIPEMD_DIGEST_SIZE + 1]; + byte data[RIPEMD_DIGEST_SIZE * 8 + 1]; + int dataLen = RIPEMD_DIGEST_SIZE * 8; + const char* expHash = + "\x11\x8f\x4f\x23\xa9\xc2\xcb\x04" + "\x10\x10\xbb\x44\x5a\x1d\xfb\x17" + "\x6b\x68\x09\xb4"; + int i; + int j; + + XMEMSET(data, 0xa5, sizeof(data)); + + /* Initialize */ + ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); + + /* Unaligned input and output buffer. */ + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data + 1, dataLen), 0); + ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash + 1), 0); + ExpectBufEQ(hash + 1, (byte*)expHash, RIPEMD_DIGEST_SIZE); + + /* Test that empty updates work. */ + ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 0), 0); + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)"", 0), 0); + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data, dataLen), 0); + ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); + ExpectBufEQ(hash, (byte*)expHash, RIPEMD_DIGEST_SIZE); + + /* Ensure chunking works. */ + for (i = 1; i < dataLen; i++) { + ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); + for (j = 0; j < dataLen; j += i) { + int len = dataLen - j; + if (i < len) + len = i; + ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data + j, len), 0); + } + ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0); + ExpectBufEQ(hash, (byte*)expHash, RIPEMD_DIGEST_SIZE); + } +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_ripemd.h b/tests/api/test_ripemd.h index 23cb0ac07a..f954b64d32 100644 --- a/tests/api/test_ripemd.h +++ b/tests/api/test_ripemd.h @@ -25,5 +25,7 @@ int test_wc_InitRipeMd(void); int test_wc_RipeMdUpdate(void); int test_wc_RipeMdFinal(void); +int test_wc_RipeMd_KATs(void); +int test_wc_RipeMd_other(void); #endif /* WOLFCRYPT_TEST_RIPEMD_H */ diff --git a/tests/api/test_sha.c b/tests/api/test_sha.c index 5fbcfc3a31..12017e1b62 100644 --- a/tests/api/test_sha.c +++ b/tests/api/test_sha.c @@ -40,6 +40,7 @@ #include #include #include +#include /* * Unit test for the wc_InitSha() @@ -48,14 +49,7 @@ int test_wc_InitSha(void) { EXPECT_DECLS; #ifndef NO_SHA - wc_Sha sha; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha(&sha), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_ShaFree(&sha); + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha, Sha); #endif return EXPECT_RESULT(); } /* END test_wc_InitSha */ @@ -67,44 +61,7 @@ int test_wc_ShaUpdate(void) { EXPECT_DECLS; #ifndef NO_SHA - wc_Sha sha; - byte hash[WC_SHA_DIGEST_SIZE]; - testVector a, b, c; - - ExpectIntEQ(wc_InitSha(&sha), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - - ExpectIntEQ(wc_ShaUpdate(&sha, NULL, 0), 0); - ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, 0), 0); - ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_ShaFinal(&sha, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2" - "\x6C\x9C\xD0\xD8\x9D"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - - ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_ShaFinal(&sha, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA_DIGEST_SIZE), 0); - - /* Try passing in bad values. */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_SHA_DIGEST_SIZE; - ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_ShaUpdate(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_ShaFree(&sha); + DIGEST_UPDATE_TEST(wc_Sha, Sha); #endif return EXPECT_RESULT(); } /* END test_wc_ShaUpdate() */ @@ -116,31 +73,142 @@ int test_wc_ShaFinal(void) { EXPECT_DECLS; #ifndef NO_SHA - wc_Sha sha; - byte* hash_test[3]; - byte hash1[WC_SHA_DIGEST_SIZE]; - byte hash2[2*WC_SHA_DIGEST_SIZE]; - byte hash3[5*WC_SHA_DIGEST_SIZE]; - int times, i; - - /* Initialize*/ - ExpectIntEQ(wc_InitSha(&sha), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test)/sizeof(byte*); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_ShaFinal(&sha, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_ShaFinal(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_ShaFinal(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_ShaFinal(&sha, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_ShaFree(&sha); + DIGEST_FINAL_TEST(wc_Sha, Sha, SHA); +#endif + return EXPECT_RESULT(); +} /* END test_wc_ShaFinal */ + +/* + * Unit test on wc_ShaFinalRaw + */ +int test_wc_ShaFinalRaw(void) +{ + EXPECT_DECLS; +#if !defined(NO_SHA) && !defined(HAVE_SELFTEST) && \ + !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ + !defined(WOLFSSL_NO_HASH_RAW) + DIGEST_FINAL_RAW_TEST(wc_Sha, Sha, SHA, + "\x67\x45\x23\x01\xef\xcd\xab\x89" + "\x98\xba\xdc\xfe\x10\x32\x54\x76" + "\xc3\xd2\xe1\xf0"); +#endif + return EXPECT_RESULT(); +} /* END test_wc_ShaFinal */ + +#define SHA_KAT_CNT 7 +int test_wc_Sha_KATs(void) +{ + EXPECT_DECLS; +#ifndef NO_SHA + DIGEST_KATS_TEST_VARS(wc_Sha, SHA); + + DIGEST_KATS_ADD("", 0, + "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d" + "\x32\x55\xbf\xef\x95\x60\x18\x90" + "\xaf\xd8\x07\x09"); + DIGEST_KATS_ADD("a", 1, + "\x86\xf7\xe4\x37\xfa\xa5\xa7\xfc" + "\xe1\x5d\x1d\xdc\xb9\xea\xea\xea" + "\x37\x76\x67\xb8"); + DIGEST_KATS_ADD("abc", 3, + "\xa9\x99\x3e\x36\x47\x06\x81\x6a" + "\xba\x3e\x25\x71\x78\x50\xc2\x6c" + "\x9c\xd0\xd8\x9d"); + DIGEST_KATS_ADD("message digest", 14, + "\xc1\x22\x52\xce\xda\x8b\xe8\x99" + "\x4d\x5f\xa0\x29\x0a\x47\x23\x1c" + "\x1d\x16\xaa\xe3"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x32\xd1\x0c\x7b\x8c\xf9\x65\x70" + "\xca\x04\xce\x37\xf2\xa1\x9d\x84" + "\x24\x0d\x3a\x89"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\x76\x1c\x45\x7b\xf7\x3b\x14\xd2" + "\x7e\x9e\x92\x65\xc4\x6f\x4b\x4d" + "\xda\x11\xf9\x40"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x50\xab\xf5\x70\x6a\x15\x09\x90" + "\xa0\x8b\x2c\x5e\xa4\x0f\xa0\xe5" + "\x85\x55\x47\x32"); + + DIGEST_KATS_TEST(Sha, SHA); +#endif + return EXPECT_RESULT(); +} /* END test_wc_ShaFinal */ + +int test_wc_Sha_other(void) +{ + EXPECT_DECLS; +#ifndef NO_SHA + DIGEST_OTHER_TEST(wc_Sha, Sha, SHA, + "\xf0\xc2\x3f\xeb\xe0\xb0\xd9\x8c" + "\x01\x23\x6c\x4c\x3b\x72\x7b\x01" + "\xc7\x0d\x2b\x60"); #endif return EXPECT_RESULT(); } /* END test_wc_ShaFinal */ +int test_wc_ShaCopy(void) +{ + EXPECT_DECLS; +#ifndef NO_SHA + DIGEST_COPY_TEST(wc_Sha, Sha, SHA, + "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d" + "\x32\x55\xbf\xef\x95\x60\x18\x90" + "\xaf\xd8\x07\x09", + "\xa9\x99\x3e\x36\x47\x06\x81\x6a" + "\xba\x3e\x25\x71\x78\x50\xc2\x6c" + "\x9c\xd0\xd8\x9d"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_ShaGetHash(void) +{ + EXPECT_DECLS; +#ifndef NO_SHA + DIGEST_GET_HASH_TEST(wc_Sha, Sha, SHA, + "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d" + "\x32\x55\xbf\xef\x95\x60\x18\x90" + "\xaf\xd8\x07\x09", + "\xa9\x99\x3e\x36\x47\x06\x81\x6a" + "\xba\x3e\x25\x71\x78\x50\xc2\x6c" + "\x9c\xd0\xd8\x9d"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_ShaTransform(void) +{ + EXPECT_DECLS; +#if !defined(NO_SHA) && (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) + DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha, Sha, SHA, + "\x80\x63\x62\x61\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x18\x00\x00\x00", + "\xa9\x99\x3e\x36\x47\x06\x81\x6a" + "\xba\x3e\x25\x71\x78\x50\xc2\x6c" + "\x9c\xd0\xd8\x9d"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Sha_Flags(void) +{ + EXPECT_DECLS; +#if !defined(NO_SHA) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha, Sha); +#endif + return EXPECT_RESULT(); +} + diff --git a/tests/api/test_sha.h b/tests/api/test_sha.h index 651ff459bf..54d36a027b 100644 --- a/tests/api/test_sha.h +++ b/tests/api/test_sha.h @@ -25,5 +25,12 @@ int test_wc_InitSha(void); int test_wc_ShaUpdate(void); int test_wc_ShaFinal(void); +int test_wc_ShaFinalRaw(void); +int test_wc_Sha_KATs(void); +int test_wc_Sha_other(void); +int test_wc_ShaCopy(void); +int test_wc_ShaGetHash(void); +int test_wc_ShaTransform(void); +int test_wc_Sha_Flags(void); #endif /* WOLFCRYPT_TEST_SHA_H */ diff --git a/tests/api/test_sha256.c b/tests/api/test_sha256.c index 41176033af..acb7748c6f 100644 --- a/tests/api/test_sha256.c +++ b/tests/api/test_sha256.c @@ -40,121 +40,50 @@ #include #include #include +#include /******************************************************************************* * SHA-256 ******************************************************************************/ /* - * Unit test for wc_InitSha256() + * Unit test for the wc_InitSha256() */ int test_wc_InitSha256(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256 sha256; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha256(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha256Free(&sha256); + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha256, Sha256); #endif return EXPECT_RESULT(); } /* END test_wc_InitSha256 */ /* - * Unit test for wc_Sha256Update() + * Tesing wc_Sha256Update() */ int test_wc_Sha256Update(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256 sha256; - byte hash[WC_SHA256_DIGEST_SIZE]; - byte hash_unaligned[WC_SHA256_DIGEST_SIZE+1]; - testVector a, b, c; - - ExpectIntEQ(wc_InitSha256(&sha256), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha256Update(&sha256, NULL, 0), 0); - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha256Final(&sha256, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22" - "\x23\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00" - "\x15\xAD"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha256Final(&sha256, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA256_DIGEST_SIZE), 0); - - /* Unaligned check. */ - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input+1, (word32)a.inLen-1), - 0); - ExpectIntEQ(wc_Sha256Final(&sha256, hash_unaligned + 1), 0); - - /* Try passing in bad values */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_SHA256_DIGEST_SIZE; - ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha256Free(&sha256); + DIGEST_UPDATE_TEST(wc_Sha256, Sha256); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha256Update */ +} /* END test_wc_Sha256Update() */ /* - * Unit test function for wc_Sha256Final() + * Unit test on wc_Sha256Final */ int test_wc_Sha256Final(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256 sha256; - byte* hash_test[3]; - byte hash1[WC_SHA256_DIGEST_SIZE]; - byte hash2[2*WC_SHA256_DIGEST_SIZE]; - byte hash3[5*WC_SHA256_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha256Final(&sha256, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha256Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256Final(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha256Free(&sha256); + DIGEST_FINAL_TEST(wc_Sha256, Sha256, SHA256); #endif return EXPECT_RESULT(); } /* END test_wc_Sha256Final */ /* - * Unit test function for wc_Sha256FinalRaw() + * Unit test on wc_Sha256FinalRaw */ int test_wc_Sha256FinalRaw(void) { @@ -163,341 +92,287 @@ int test_wc_Sha256FinalRaw(void) !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ !defined(WOLFSSL_NO_HASH_RAW) - wc_Sha256 sha256; - byte* hash_test[3]; - byte hash1[WC_SHA256_DIGEST_SIZE]; - byte hash2[2*WC_SHA256_DIGEST_SIZE]; - byte hash3[5*WC_SHA256_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha256FinalRaw(&sha256, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha256FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256FinalRaw(&sha256, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha256Free(&sha256); + DIGEST_FINAL_RAW_TEST(wc_Sha256, Sha256, SHA256, + "\x6a\x09\xe6\x67\xbb\x67\xae\x85" + "\x3c\x6e\xf3\x72\xa5\x4f\xf5\x3a" + "\x51\x0e\x52\x7f\x9b\x05\x68\x8c" + "\x1f\x83\xd9\xab\x5b\xe0\xcd\x19"); #endif return EXPECT_RESULT(); +} /* END test_wc_Sha256Final */ -} /* END test_wc_Sha256FinalRaw */ - -/* - * Unit test function for wc_Sha256GetFlags() - */ -int test_wc_Sha256GetFlags(void) +#define SHA256_KAT_CNT 7 +int test_wc_Sha256_KATs(void) { EXPECT_DECLS; -#if !defined(NO_SHA256) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha256 sha256; - word32 flags = 0; - - /* Initialize */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - - ExpectIntEQ(wc_Sha256GetFlags(&sha256, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - wc_Sha256Free(&sha256); +#ifndef NO_SHA256 + DIGEST_KATS_TEST_VARS(wc_Sha256, SHA256); + + DIGEST_KATS_ADD("", 0, + "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14" + "\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24" + "\x27\xae\x41\xe4\x64\x9b\x93\x4c" + "\xa4\x95\x99\x1b\x78\x52\xb8\x55"); + DIGEST_KATS_ADD("a", 1, + "\xca\x97\x81\x12\xca\x1b\xbd\xca" + "\xfa\xc2\x31\xb3\x9a\x23\xdc\x4d" + "\xa7\x86\xef\xf8\x14\x7c\x4e\x72" + "\xb9\x80\x77\x85\xaf\xee\x48\xbb"); + DIGEST_KATS_ADD("abc", 3, + "\xba\x78\x16\xbf\x8f\x01\xcf\xea" + "\x41\x41\x40\xde\x5d\xae\x22\x23" + "\xb0\x03\x61\xa3\x96\x17\x7a\x9c" + "\xb4\x10\xff\x61\xf2\x00\x15\xad"); + DIGEST_KATS_ADD("message digest", 14, + "\xf7\x84\x6f\x55\xcf\x23\xe1\x4e" + "\xeb\xea\xb5\xb4\xe1\x55\x0c\xad" + "\x5b\x50\x9e\x33\x48\xfb\xc4\xef" + "\xa3\xa1\x41\x3d\x39\x3c\xb6\x50"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x71\xc4\x80\xdf\x93\xd6\xae\x2f" + "\x1e\xfa\xd1\x44\x7c\x66\xc9\x52" + "\x5e\x31\x62\x18\xcf\x51\xfc\x8d" + "\x9e\xd8\x32\xf2\xda\xf1\x8b\x73"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xdb\x4b\xfc\xbd\x4d\xa0\xcd\x85" + "\xa6\x0c\x3c\x37\xd3\xfb\xd8\x80" + "\x5c\x77\xf1\x5f\xc6\xb1\xfd\xfe" + "\x61\x4e\xe0\xa7\xc8\xfd\xb4\xc0"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\xf3\x71\xbc\x4a\x31\x1f\x2b\x00" + "\x9e\xef\x95\x2d\xd8\x3c\xa8\x0e" + "\x2b\x60\x02\x6c\x8e\x93\x55\x92" + "\xd0\xf9\xc3\x08\x45\x3c\x81\x3e"); + + DIGEST_KATS_TEST(Sha256, SHA256); #endif return EXPECT_RESULT(); +} /* END test_wc_Sha256Final */ -} /* END test_wc_Sha256GetFlags */ - -/* - * Unit test function for wc_Sha256Free() - */ -int test_wc_Sha256Free(void) +int test_wc_Sha256_other(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_OTHER_TEST(wc_Sha256, Sha256, SHA256, + "\x2c\x41\xa1\xdd\x58\x4e\x37\x73" + "\xb9\x56\x74\x84\x1b\x68\x5f\x36" + "\xc7\x6b\x48\xec\x4d\xb7\x58\x63" + "\x37\x2c\x2f\xd6\xe1\x9a\x61\xce"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha256Free */ -/* - * Unit test function for wc_Sha256GetHash() - */ -int test_wc_Sha256GetHash(void) +} /* END test_wc_Sha256Final */ + +int test_wc_Sha256Copy(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256 sha256; - byte hash1[WC_SHA256_DIGEST_SIZE]; - - /* Initialize */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - - ExpectIntEQ(wc_Sha256GetHash(&sha256, hash1), 0); - - /* test bad arguments*/ - ExpectIntEQ(wc_Sha256GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256GetHash(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha256Free(&sha256); + DIGEST_COPY_TEST(wc_Sha256, Sha256, SHA256, + "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14" + "\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24" + "\x27\xae\x41\xe4\x64\x9b\x93\x4c" + "\xa4\x95\x99\x1b\x78\x52\xb8\x55", + "\xba\x78\x16\xbf\x8f\x01\xcf\xea" + "\x41\x41\x40\xde\x5d\xae\x22\x23" + "\xb0\x03\x61\xa3\x96\x17\x7a\x9c" + "\xb4\x10\xff\x61\xf2\x00\x15\xad"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha256GetHash */ +} -/* - * Unit test function for wc_Sha256Copy() - */ -int test_wc_Sha256Copy(void) +int test_wc_Sha256GetHash(void) { EXPECT_DECLS; #ifndef NO_SHA256 - wc_Sha256 sha256; - wc_Sha256 temp; - - XMEMSET(&sha256, 0, sizeof(sha256)); - XMEMSET(&temp, 0, sizeof(temp)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha256(&sha256), 0); - ExpectIntEQ(wc_InitSha256(&temp), 0); - - ExpectIntEQ(wc_Sha256Copy(&sha256, &temp), 0); - - /* test bad arguments*/ - ExpectIntEQ(wc_Sha256Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha256Copy(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + DIGEST_GET_HASH_TEST(wc_Sha256, Sha256, SHA256, + "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14" + "\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24" + "\x27\xae\x41\xe4\x64\x9b\x93\x4c" + "\xa4\x95\x99\x1b\x78\x52\xb8\x55", + "\xba\x78\x16\xbf\x8f\x01\xcf\xea" + "\x41\x41\x40\xde\x5d\xae\x22\x23" + "\xb0\x03\x61\xa3\x96\x17\x7a\x9c" + "\xb4\x10\xff\x61\xf2\x00\x15\xad"); +#endif + return EXPECT_RESULT(); +} - wc_Sha256Free(&sha256); - wc_Sha256Free(&temp); +int test_wc_Sha256Transform(void) +{ + EXPECT_DECLS; +#if !defined(NO_SHA256) && (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) + DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha256, Sha256, SHA256, + "\x80\x63\x62\x61\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x18\x00\x00\x00", + "\xba\x78\x16\xbf\x8f\x01\xcf\xea" + "\x41\x41\x40\xde\x5d\xae\x22\x23" + "\xb0\x03\x61\xa3\x96\x17\x7a\x9c" + "\xb4\x10\xff\x61\xf2\x00\x15\xad"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha256Copy */ +} +int test_wc_Sha256_Flags(void) +{ + EXPECT_DECLS; +#if !defined(NO_SHA256) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha256, Sha256); +#endif + return EXPECT_RESULT(); +} /******************************************************************************* * SHA-224 ******************************************************************************/ /* - * Testing wc_InitSha224(); + * Unit test for the wc_InitSha224() */ int test_wc_InitSha224(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA224 - wc_Sha224 sha224; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha224(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha224Free(&sha224); + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha224, Sha224); #endif return EXPECT_RESULT(); } /* END test_wc_InitSha224 */ /* - * Unit test on wc_Sha224Update + * Tesing wc_Sha224Update() */ int test_wc_Sha224Update(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA224 - wc_Sha224 sha224; - byte hash[WC_SHA224_DIGEST_SIZE]; - testVector a, b, c; - - ExpectIntEQ(wc_InitSha224(&sha224), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha224Update(&sha224, NULL, 0), 0); - ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha224Final(&sha224, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2" - "\x55\xb3\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha224Final(&sha224, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA224_DIGEST_SIZE), 0); - - /* Pass in bad values. */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_SHA224_DIGEST_SIZE; - ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha224Free(&sha224); + DIGEST_UPDATE_TEST(wc_Sha224, Sha224); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha224Update */ +} /* END test_wc_Sha224Update() */ /* - * Unit test for wc_Sha224Final(); + * Unit test on wc_Sha224Final */ int test_wc_Sha224Final(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA224 - wc_Sha224 sha224; - byte* hash_test[3]; - byte hash1[WC_SHA224_DIGEST_SIZE]; - byte hash2[2*WC_SHA224_DIGEST_SIZE]; - byte hash3[5*WC_SHA224_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - /* Good test args. */ - /* Testing oversized buffers. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha224Final(&sha224, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha224Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224Final(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha224Free(&sha224); + DIGEST_FINAL_TEST(wc_Sha224, Sha224, SHA224); #endif return EXPECT_RESULT(); } /* END test_wc_Sha224Final */ -/* - * Unit test function for wc_Sha224SetFlags() - */ -int test_wc_Sha224SetFlags(void) +#define SHA224_KAT_CNT 7 +int test_wc_Sha224_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA224) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha224 sha224; - word32 flags = WC_HASH_FLAG_WILLCOPY; - - /* Initialize */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - - ExpectIntEQ(wc_Sha224SetFlags(&sha224, flags), 0); - flags = 0; - ExpectIntEQ(wc_Sha224GetFlags(&sha224, &flags), 0); - ExpectTrue(flags == WC_HASH_FLAG_WILLCOPY); - - wc_Sha224Free(&sha224); +#ifdef WOLFSSL_SHA224 + DIGEST_KATS_TEST_VARS(wc_Sha224, SHA224); + + DIGEST_KATS_ADD("", 0, + "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9" + "\x47\x61\x02\xbb\x28\x82\x34\xc4" + "\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a" + "\xc5\xb3\xe4\x2f"); + DIGEST_KATS_ADD("a", 1, + "\xab\xd3\x75\x34\xc7\xd9\xa2\xef" + "\xb9\x46\x5d\xe9\x31\xcd\x70\x55" + "\xff\xdb\x88\x79\x56\x3a\xe9\x80" + "\x78\xd6\xd6\xd5"); + DIGEST_KATS_ADD("abc", 3, + "\x23\x09\x7d\x22\x34\x05\xd8\x22" + "\x86\x42\xa4\x77\xbd\xa2\x55\xb3" + "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7" + "\xe3\x6c\x9d\xa7"); + DIGEST_KATS_ADD("message digest", 14, + "\x2c\xb2\x1c\x83\xae\x2f\x00\x4d" + "\xe7\xe8\x1c\x3c\x70\x19\xcb\xcb" + "\x65\xb7\x1a\xb6\x56\xb2\x2d\x6d" + "\x0c\x39\xb8\xeb"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x45\xa5\xf7\x2c\x39\xc5\xcf\xf2" + "\x52\x2e\xb3\x42\x97\x99\xe4\x9e" + "\x5f\x44\xb3\x56\xef\x92\x6b\xcf" + "\x39\x0d\xcc\xc2"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xbf\xf7\x2b\x4f\xcb\x7d\x75\xe5" + "\x63\x29\x00\xac\x5f\x90\xd2\x19" + "\xe0\x5e\x97\xa7\xbd\xe7\x2e\x74" + "\x0d\xb3\x93\xd9"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\xb5\x0a\xec\xbe\x4e\x9b\xb0\xb5" + "\x7b\xc5\xf3\xae\x76\x0a\x8e\x01" + "\xdb\x24\xf2\x03\xfb\x3c\xdc\xd1" + "\x31\x48\x04\x6e"); + + DIGEST_KATS_TEST(Sha224, SHA224); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha224SetFlags */ +} /* END test_wc_Sha224Final */ -/* - * Unit test function for wc_Sha224GetFlags() - */ -int test_wc_Sha224GetFlags(void) +int test_wc_Sha224_other(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA224) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha224 sha224; - word32 flags = 0; - - /* Initialize */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - - ExpectIntEQ(wc_Sha224GetFlags(&sha224, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - - wc_Sha224Free(&sha224); +#ifdef WOLFSSL_SHA224 + DIGEST_OTHER_TEST(wc_Sha224, Sha224, SHA224, + "\x60\x81\xdf\x2f\xae\xe2\x25\xe9" + "\x87\x61\x2a\x8e\x25\x19\x16\x39" + "\x80\xfb\x77\xfa\x28\x74\x17\x4d" + "\xf3\x15\x52\x2b"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha224GetFlags */ -/* - * Unit test function for wc_Sha224Free() - */ -int test_wc_Sha224Free(void) +} /* END test_wc_Sha224Final */ + +int test_wc_Sha224Copy(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA224 - wc_Sha224Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_COPY_TEST(wc_Sha224, Sha224, SHA224, + "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9" + "\x47\x61\x02\xbb\x28\x82\x34\xc4" + "\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a" + "\xc5\xb3\xe4\x2f", + "\x23\x09\x7d\x22\x34\x05\xd8\x22" + "\x86\x42\xa4\x77\xbd\xa2\x55\xb3" + "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7" + "\xe3\x6c\x9d\xa7"); #endif return EXPECT_RESULT(); +} -} /* END test_wc_Sha224Free */ - -/* - * Unit test function for wc_Sha224GetHash() - */ int test_wc_Sha224GetHash(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA224 - wc_Sha224 sha224; - byte hash1[WC_SHA224_DIGEST_SIZE]; - - /* Initialize */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - - ExpectIntEQ(wc_Sha224GetHash(&sha224, hash1), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha224GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224GetHash(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha224Free(&sha224); + DIGEST_GET_HASH_TEST(wc_Sha224, Sha224, SHA224, + "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9" + "\x47\x61\x02\xbb\x28\x82\x34\xc4" + "\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a" + "\xc5\xb3\xe4\x2f", + "\x23\x09\x7d\x22\x34\x05\xd8\x22" + "\x86\x42\xa4\x77\xbd\xa2\x55\xb3" + "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7" + "\xe3\x6c\x9d\xa7"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha224GetHash */ +} -/* - * Unit test function for wc_Sha224Copy() - */ -int test_wc_Sha224Copy(void) +int test_wc_Sha224_Flags(void) { EXPECT_DECLS; -#ifdef WOLFSSL_SHA224 - wc_Sha224 sha224; - wc_Sha224 temp; - - XMEMSET(&sha224, 0, sizeof(wc_Sha224)); - XMEMSET(&temp, 0, sizeof(wc_Sha224)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha224(&sha224), 0); - ExpectIntEQ(wc_InitSha224(&temp), 0); - - ExpectIntEQ(wc_Sha224Copy(&sha224, &temp), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha224Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha224Copy(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha224Free(&sha224); - wc_Sha224Free(&temp); +#if defined(WOLFSSL_SHA224) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha224, Sha224); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha224Copy */ +} diff --git a/tests/api/test_sha256.h b/tests/api/test_sha256.h index 068e21b06d..9a30537237 100644 --- a/tests/api/test_sha256.h +++ b/tests/api/test_sha256.h @@ -26,18 +26,20 @@ int test_wc_InitSha256(void); int test_wc_Sha256Update(void); int test_wc_Sha256Final(void); int test_wc_Sha256FinalRaw(void); -int test_wc_Sha256GetFlags(void); -int test_wc_Sha256Free(void); -int test_wc_Sha256GetHash(void); +int test_wc_Sha256_KATs(void); +int test_wc_Sha256_other(void); int test_wc_Sha256Copy(void); +int test_wc_Sha256GetHash(void); +int test_wc_Sha256Transform(void); +int test_wc_Sha256_Flags(void); int test_wc_InitSha224(void); int test_wc_Sha224Update(void); int test_wc_Sha224Final(void); -int test_wc_Sha224SetFlags(void); -int test_wc_Sha224GetFlags(void); -int test_wc_Sha224Free(void); -int test_wc_Sha224GetHash(void); +int test_wc_Sha224_KATs(void); +int test_wc_Sha224_other(void); int test_wc_Sha224Copy(void); +int test_wc_Sha224GetHash(void); +int test_wc_Sha224_Flags(void); #endif /* WOLFCRYPT_TEST_SHA256_H */ diff --git a/tests/api/test_sha3.c b/tests/api/test_sha3.c index aa8faccf97..d5bb453f46 100644 --- a/tests/api/test_sha3.c +++ b/tests/api/test_sha3.c @@ -40,536 +40,961 @@ #include #include #include +#include + +#if defined(HAVE_SELFTEST) || (defined(HAVE_FIPS) && \ + (!defined(HAVE_FIPS_VERSION) || (HAVE_FIPS_VERSION < 3))) + #define WC_SHA3_128_BLOCK_SIZE 168 + #define WC_SHA3_224_BLOCK_SIZE 144 + #define WC_SHA3_256_BLOCK_SIZE 136 + #define WC_SHA3_384_BLOCK_SIZE 104 + #define WC_SHA3_512_BLOCK_SIZE 72 +#endif /******************************************************************************* * SHA-3 ******************************************************************************/ -/* - * Testing wc_InitSha3_224, wc_InitSha3_256, wc_InitSha3_384, and - * wc_InitSha3_512 - */ +#define SHA3_KATS_TEST(name, upper) \ + (void)i; \ + \ + /* Initialize */ \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + for (i = 0; i < upper##_KAT_CNT; i++) { \ + /* Do KAT. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)dgst_kat[i].input, \ + (word32)dgst_kat[i].inLen), 0); \ + ExpectIntEQ(wc_##name##_Final(&dgst, hash), 0); \ + ExpectBufEQ(hash, (byte*)dgst_kat[i].output, \ + WC_##upper##_DIGEST_SIZE); \ + } \ + \ + wc_##name##_Free(&dgst) + +#define SHA3_GET_HASH_TEST(name, upper, emptyHashStr, abcHashStr) \ +do { \ + wc_Sha3 dgst; \ + byte hash[WC_##upper##_DIGEST_SIZE]; \ + const char* emptyHash = emptyHashStr; \ + const char* abcHash = abcHashStr; \ + \ + ExpectIntEQ(wc_Init##name(&dgst, HEAP_HINT, INVALID_DEVID), 0); \ + \ + ExpectIntEQ(wc_##name##_GetHash(NULL, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_GetHash(&dgst, NULL), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + ExpectIntEQ(wc_##name##_GetHash(NULL, hash), \ + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); \ + \ + ExpectIntEQ(wc_##name##_GetHash(&dgst, hash), 0); \ + ExpectBufEQ(hash, emptyHash, WC_##upper##_DIGEST_SIZE); \ + /* Test that the hash state hasn't been modified. */ \ + ExpectIntEQ(wc_##name##_Update(&dgst, (byte*)"abc", 3), 0); \ + ExpectIntEQ(wc_##name##_GetHash(&dgst, hash), 0); \ + ExpectBufEQ(hash, abcHash, WC_##upper##_DIGEST_SIZE); \ + \ + wc_##name##_Free(&dgst); \ +} while (0) + + int test_wc_InitSha3(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) - wc_Sha3 sha3; +#ifdef WOLFSSL_SHA3 + DIGEST_INIT_TEST(wc_Sha3, Sha3_224); + DIGEST_INIT_TEST(wc_Sha3, Sha3_256); + DIGEST_INIT_TEST(wc_Sha3, Sha3_384); + DIGEST_INIT_TEST(wc_Sha3, Sha3_512); +#endif + return EXPECT_RESULT(); +} - (void)sha3; +int test_wc_Sha3_Update(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHA3 + DIGEST_ALT_UPDATE_TEST(wc_Sha3, Sha3_224); + DIGEST_ALT_UPDATE_TEST(wc_Sha3, Sha3_256); + DIGEST_ALT_UPDATE_TEST(wc_Sha3, Sha3_384); + DIGEST_ALT_UPDATE_TEST(wc_Sha3, Sha3_512); +#endif + return EXPECT_RESULT(); +} -#if !defined(WOLFSSL_NOSHA3_224) - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - /* Test bad args. */ - ExpectIntEQ(wc_InitSha3_224(NULL, HEAP_HINT, testDevId), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_224_Free(&sha3); -#endif /* NOSHA3_224 */ -#if !defined(WOLFSSL_NOSHA3_256) - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - /* Test bad args. */ - ExpectIntEQ(wc_InitSha3_256(NULL, HEAP_HINT, testDevId), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_256_Free(&sha3); -#endif /* NOSHA3_256 */ -#if !defined(WOLFSSL_NOSHA3_384) - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - /* Test bad args. */ - ExpectIntEQ(wc_InitSha3_384(NULL, HEAP_HINT, testDevId), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_384_Free(&sha3); -#endif /* NOSHA3_384 */ -#if !defined(WOLFSSL_NOSHA3_512) - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - /* Test bad args. */ - ExpectIntEQ(wc_InitSha3_512(NULL, HEAP_HINT, testDevId), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_512_Free(&sha3); -#endif /* NOSHA3_512 */ +int test_wc_Sha3_Final(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHA3 + DIGEST_ALT_FINAL_TEST(wc_Sha3, Sha3_224, SHA3_224); + DIGEST_ALT_FINAL_TEST(wc_Sha3, Sha3_256, SHA3_256); + DIGEST_ALT_FINAL_TEST(wc_Sha3, Sha3_384, SHA3_384); + DIGEST_ALT_FINAL_TEST(wc_Sha3, Sha3_512, SHA3_512); #endif return EXPECT_RESULT(); -} /* END test_wc_InitSha3 */ +} -/* - * Testing wc_Sha3_Update() - */ -int test_wc_Sha3_Update(void) +#define SHA3_224_KAT_CNT 7 +int test_wc_Sha3_224_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_XILINX_CRYPT) && \ - !defined(WOLFSSL_AFALG_XILINX) - wc_Sha3 sha3; - byte msg[] = "Everybody's working for the weekend."; - byte msg2[] = "Everybody gets Friday off."; - byte msgCmp[] = "\x45\x76\x65\x72\x79\x62\x6f\x64\x79\x27\x73\x20" - "\x77\x6f\x72\x6b\x69\x6e\x67\x20\x66\x6f\x72\x20\x74" - "\x68\x65\x20\x77\x65\x65\x6b\x65\x6e\x64\x2e\x45\x76" - "\x65\x72\x79\x62\x6f\x64\x79\x20\x67\x65\x74\x73\x20" - "\x46\x72\x69\x64\x61\x79\x20\x6f\x66\x66\x2e"; - word32 msglen = sizeof(msg) - 1; - word32 msg2len = sizeof(msg2); - word32 msgCmplen = sizeof(msgCmp); - - #if !defined(WOLFSSL_NOSHA3_224) - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, msg, msglen), 0); - ExpectIntEQ(XMEMCMP(msg, sha3.t, msglen), 0); - ExpectTrue(sha3.i == msglen); - - ExpectIntEQ(wc_Sha3_224_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(sha3.t, msgCmp, msgCmplen), 0); - - /* Pass bad args. */ - ExpectIntEQ(wc_Sha3_224_Update(NULL, msg2, msg2len), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, NULL, 5), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_224_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, NULL, 0), 0); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(msg2, sha3.t, msg2len), 0); - wc_Sha3_224_Free(&sha3); - #endif /* SHA3_224 */ - - #if !defined(WOLFSSL_NOSHA3_256) - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, msg, msglen), 0); - ExpectIntEQ(XMEMCMP(msg, sha3.t, msglen), 0); - ExpectTrue(sha3.i == msglen); - - ExpectIntEQ(wc_Sha3_256_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(sha3.t, msgCmp, msgCmplen), 0); - - /* Pass bad args. */ - ExpectIntEQ(wc_Sha3_256_Update(NULL, msg2, msg2len), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, NULL, 5), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_256_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, NULL, 0), 0); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(msg2, sha3.t, msg2len), 0); - wc_Sha3_256_Free(&sha3); - #endif /* SHA3_256 */ - - #if !defined(WOLFSSL_NOSHA3_384) - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, msg, msglen), 0); - ExpectIntEQ(XMEMCMP(msg, sha3.t, msglen), 0); - ExpectTrue(sha3.i == msglen); - - ExpectIntEQ(wc_Sha3_384_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(sha3.t, msgCmp, msgCmplen), 0); - - /* Pass bad args. */ - ExpectIntEQ(wc_Sha3_384_Update(NULL, msg2, msg2len), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, NULL, 5), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_384_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, NULL, 0), 0); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(msg2, sha3.t, msg2len), 0); - wc_Sha3_384_Free(&sha3); - #endif /* SHA3_384 */ - - #if !defined(WOLFSSL_NOSHA3_512) - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, msg, msglen), 0); - ExpectIntEQ(XMEMCMP(msg, sha3.t, msglen), 0); - ExpectTrue(sha3.i == msglen); - - ExpectIntEQ(wc_Sha3_512_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(sha3.t, msgCmp, msgCmplen), 0); - - /* Pass bad args. */ - ExpectIntEQ(wc_Sha3_512_Update(NULL, msg2, msg2len), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, NULL, 5), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_512_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, NULL, 0), 0); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(msg2, sha3.t, msg2len), 0); - wc_Sha3_512_Free(&sha3); - #endif /* SHA3_512 */ -#endif /* WOLFSSL_SHA3 */ +#ifdef WOLFSSL_SHA3 + DIGEST_KATS_TEST_VARS(wc_Sha3, SHA3_224); + + DIGEST_KATS_ADD("", 0, + "\x6b\x4e\x03\x42\x36\x67\xdb\xb7" + "\x3b\x6e\x15\x45\x4f\x0e\xb1\xab" + "\xd4\x59\x7f\x9a\x1b\x07\x8e\x3f" + "\x5b\x5a\x6b\xc7"); + DIGEST_KATS_ADD("a", 1, + "\x9e\x86\xff\x69\x55\x7c\xa9\x5f" + "\x40\x5f\x08\x12\x69\x68\x5b\x38" + "\xe3\xa8\x19\xb3\x09\xee\x94\x2f" + "\x48\x2b\x6a\x8b"); + DIGEST_KATS_ADD("abc", 3, + "\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a" + "\xd0\x92\x34\xee\x7d\x3c\x76\x6f" + "\xc9\xa3\xa5\x16\x8d\x0c\x94\xad" + "\x73\xb4\x6f\xdf"); + DIGEST_KATS_ADD("message digest", 14, + "\x18\x76\x8b\xb4\xc4\x8e\xb7\xfc" + "\x88\xe5\xdd\xb1\x7e\xfc\xf2\x96" + "\x4a\xbd\x77\x98\xa3\x9d\x86\xa4" + "\xb4\xa1\xe4\xc8"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x5c\xde\xca\x81\xe1\x23\xf8\x7c" + "\xad\x96\xb9\xcb\xa9\x99\xf1\x6f" + "\x6d\x41\x54\x96\x08\xd4\xe0\xf4" + "\x68\x1b\x82\x39"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xa6\x7c\x28\x9b\x82\x50\xa6\xf4" + "\x37\xa2\x01\x37\x98\x5d\x60\x55" + "\x89\xa8\xc1\x63\xd4\x52\x61\xb1" + "\x54\x19\x55\x6e"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x05\x26\x89\x8e\x18\x58\x69\xf9" + "\x1b\x3e\x2a\x76\xdd\x72\xa1\x5d" + "\xc6\x94\x0a\x67\xc8\x16\x4a\x04" + "\x4c\xd2\x5c\xc8"); + + SHA3_KATS_TEST(Sha3_224, SHA3_224); +#endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_Update */ +} -/* - * Testing wc_Sha3_224_Final() - */ -int test_wc_Sha3_224_Final(void) +#define SHA3_256_KAT_CNT 7 +int test_wc_Sha3_256_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) - wc_Sha3 sha3; - const char* msg = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnom" - "nopnopq"; - const char* expOut = "\x8a\x24\x10\x8b\x15\x4a\xda\x21\xc9\xfd\x55" - "\x74\x49\x44\x79\xba\x5c\x7e\x7a\xb7\x6e\xf2" - "\x64\xea\xd0\xfc\xce\x33"; - byte hash[WC_SHA3_224_DIGEST_SIZE]; - byte hashRet[WC_SHA3_224_DIGEST_SIZE]; - - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_224_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(expOut, hash, WC_SHA3_224_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_224_Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_224_Final(&sha3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_224_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashRet, 0, sizeof(hashRet)); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_224_GetHash(&sha3, hashRet), 0); - ExpectIntEQ(wc_Sha3_224_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(hash, hashRet, WC_SHA3_224_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_224_GetHash(NULL, hashRet), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_224_GetHash(&sha3, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHA3 + DIGEST_KATS_TEST_VARS(wc_Sha3, SHA3_256); + + DIGEST_KATS_ADD("", 0, + "\xa7\xff\xc6\xf8\xbf\x1e\xd7\x66" + "\x51\xc1\x47\x56\xa0\x61\xd6\x62" + "\xf5\x80\xff\x4d\xe4\x3b\x49\xfa" + "\x82\xd8\x0a\x4b\x80\xf8\x43\x4a"); + DIGEST_KATS_ADD("a", 1, + "\x80\x08\x4b\xf2\xfb\xa0\x24\x75" + "\x72\x6f\xeb\x2c\xab\x2d\x82\x15" + "\xea\xb1\x4b\xc6\xbd\xd8\xbf\xb2" + "\xc8\x15\x12\x57\x03\x2e\xcd\x8b"); + DIGEST_KATS_ADD("abc", 3, + "\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2" + "\x04\x5c\x17\x2d\x6b\xd3\x90\xbd" + "\x85\x5f\x08\x6e\x3e\x9d\x52\x5b" + "\x46\xbf\xe2\x45\x11\x43\x15\x32"); + DIGEST_KATS_ADD("message digest", 14, + "\xed\xcd\xb2\x06\x93\x66\xe7\x52" + "\x43\x86\x0c\x18\xc3\xa1\x14\x65" + "\xec\xa3\x4b\xce\x61\x43\xd3\x0c" + "\x86\x65\xce\xfc\xfd\x32\xbf\xfd"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x7c\xab\x2d\xc7\x65\xe2\x1b\x24" + "\x1d\xbc\x1c\x25\x5c\xe6\x20\xb2" + "\x9f\x52\x7c\x6d\x5e\x7f\x5f\x84" + "\x3e\x56\x28\x8f\x0d\x70\x75\x21"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xa7\x9d\x6a\x9d\xa4\x7f\x04\xa3" + "\xb9\xa9\x32\x3e\xc9\x99\x1f\x21" + "\x05\xd4\xc7\x8a\x7b\xc7\xbe\xeb" + "\x10\x38\x55\xa7\xa1\x1d\xfb\x9f"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x29\x3e\x5c\xe4\xce\x54\xee\x71" + "\x99\x0a\xb0\x6e\x51\x1b\x7c\xcd" + "\x62\x72\x2b\x1b\xeb\x41\x4f\x5f" + "\xf6\x5c\x82\x74\xe0\xf5\xbe\x1d"); + + SHA3_KATS_TEST(Sha3_256, SHA3_256); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_224_Free(&sha3); +#define SHA3_384_KAT_CNT 7 +int test_wc_Sha3_384_KATs(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHA3 + DIGEST_KATS_TEST_VARS(wc_Sha3, SHA3_384); + + DIGEST_KATS_ADD("", 0, + "\x0c\x63\xa7\x5b\x84\x5e\x4f\x7d" + "\x01\x10\x7d\x85\x2e\x4c\x24\x85" + "\xc5\x1a\x50\xaa\xaa\x94\xfc\x61" + "\x99\x5e\x71\xbb\xee\x98\x3a\x2a" + "\xc3\x71\x38\x31\x26\x4a\xdb\x47" + "\xfb\x6b\xd1\xe0\x58\xd5\xf0\x04"); + DIGEST_KATS_ADD("a", 1, + "\x18\x15\xf7\x74\xf3\x20\x49\x1b" + "\x48\x56\x9e\xfe\xc7\x94\xd2\x49" + "\xee\xb5\x9a\xae\x46\xd2\x2b\xf7" + "\x7d\xaf\xe2\x5c\x5e\xdc\x28\xd7" + "\xea\x44\xf9\x3e\xe1\x23\x4a\xa8" + "\x8f\x61\xc9\x19\x12\xa4\xcc\xd9"); + DIGEST_KATS_ADD("abc", 3, + "\xec\x01\x49\x82\x88\x51\x6f\xc9" + "\x26\x45\x9f\x58\xe2\xc6\xad\x8d" + "\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25" + "\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2" + "\x98\xd8\x8c\xea\x92\x7a\xc7\xf5" + "\x39\xf1\xed\xf2\x28\x37\x6d\x25"); + DIGEST_KATS_ADD("message digest", 14, + "\xd9\x51\x97\x09\xf4\x4a\xf7\x3e" + "\x2c\x8e\x29\x11\x09\xa9\x79\xde" + "\x3d\x61\xdc\x02\xbf\x69\xde\xf7" + "\xfb\xff\xdf\xff\xe6\x62\x75\x15" + "\x13\xf1\x9a\xd5\x7e\x17\xd4\xb9" + "\x3b\xa1\xe4\x84\xfc\x19\x80\xd5"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xfe\xd3\x99\xd2\x21\x7a\xaf\x4c" + "\x71\x7a\xd0\xc5\x10\x2c\x15\x58" + "\x9e\x1c\x99\x0c\xc2\xb9\xa5\x02" + "\x90\x56\xa7\xf7\x48\x58\x88\xd6" + "\xab\x65\xdb\x23\x70\x07\x7a\x5c" + "\xad\xb5\x3f\xc9\x28\x0d\x27\x8f"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xd5\xb9\x72\x30\x2f\x50\x80\xd0" + "\x83\x0e\x0d\xe7\xb6\xb2\xcf\x38" + "\x36\x65\xa0\x08\xf4\xc4\xf3\x86" + "\xa6\x11\x12\x65\x2c\x74\x2d\x20" + "\xcb\x45\xaa\x51\xbd\x4f\x54\x2f" + "\xc7\x33\xe2\x71\x9e\x99\x92\x91"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x3c\x21\x3a\x17\xf5\x14\x63\x8a" + "\xcb\x3b\xf1\x7f\x10\x9f\x3e\x24" + "\xc1\x6f\x9f\x14\xf0\x85\xb5\x2a" + "\x2f\x2b\x81\xad\xc0\xdb\x83\xdf" + "\x1a\x58\xdb\x2c\xe0\x13\x19\x1b" + "\x8b\xa7\x2d\x8f\xae\x7e\x2a\x5e"); + + SHA3_KATS_TEST(Sha3_384, SHA3_384); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_224_Final */ +} -/* - * Testing wc_Sha3_256_Final() - */ -int test_wc_Sha3_256_Final(void) +#define SHA3_512_KAT_CNT 7 +int test_wc_Sha3_512_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) - wc_Sha3 sha3; - const char* msg = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnom" - "nopnopq"; - const char* expOut = "\x41\xc0\xdb\xa2\xa9\xd6\x24\x08\x49\x10\x03\x76\xa8" - "\x23\x5e\x2c\x82\xe1\xb9\x99\x8a\x99\x9e\x21\xdb\x32" - "\xdd\x97\x49\x6d\x33\x76"; - byte hash[WC_SHA3_256_DIGEST_SIZE]; - byte hashRet[WC_SHA3_256_DIGEST_SIZE]; - - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_256_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(expOut, hash, WC_SHA3_256_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_256_Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_256_Final(&sha3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_256_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashRet, 0, sizeof(hashRet)); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_256_GetHash(&sha3, hashRet), 0); - ExpectIntEQ(wc_Sha3_256_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(hash, hashRet, WC_SHA3_256_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_256_GetHash(NULL, hashRet), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_256_GetHash(&sha3, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHA3 + DIGEST_KATS_TEST_VARS(wc_Sha3, SHA3_512); + + DIGEST_KATS_ADD("", 0, + "\xa6\x9f\x73\xcc\xa2\x3a\x9a\xc5" + "\xc8\xb5\x67\xdc\x18\x5a\x75\x6e" + "\x97\xc9\x82\x16\x4f\xe2\x58\x59" + "\xe0\xd1\xdc\xc1\x47\x5c\x80\xa6" + "\x15\xb2\x12\x3a\xf1\xf5\xf9\x4c" + "\x11\xe3\xe9\x40\x2c\x3a\xc5\x58" + "\xf5\x00\x19\x9d\x95\xb6\xd3\xe3" + "\x01\x75\x85\x86\x28\x1d\xcd\x26"); + DIGEST_KATS_ADD("a", 1, + "\x69\x7f\x2d\x85\x61\x72\xcb\x83" + "\x09\xd6\xb8\xb9\x7d\xac\x4d\xe3" + "\x44\xb5\x49\xd4\xde\xe6\x1e\xdf" + "\xb4\x96\x2d\x86\x98\xb7\xfa\x80" + "\x3f\x4f\x93\xff\x24\x39\x35\x86" + "\xe2\x8b\x5b\x95\x7a\xc3\xd1\xd3" + "\x69\x42\x0c\xe5\x33\x32\x71\x2f" + "\x99\x7b\xd3\x36\xd0\x9a\xb0\x2a"); + DIGEST_KATS_ADD("abc", 3, + "\xb7\x51\x85\x0b\x1a\x57\x16\x8a" + "\x56\x93\xcd\x92\x4b\x6b\x09\x6e" + "\x08\xf6\x21\x82\x74\x44\xf7\x0d" + "\x88\x4f\x5d\x02\x40\xd2\x71\x2e" + "\x10\xe1\x16\xe9\x19\x2a\xf3\xc9" + "\x1a\x7e\xc5\x76\x47\xe3\x93\x40" + "\x57\x34\x0b\x4c\xf4\x08\xd5\xa5" + "\x65\x92\xf8\x27\x4e\xec\x53\xf0"); + DIGEST_KATS_ADD("message digest", 14, + "\x34\x44\xe1\x55\x88\x1f\xa1\x55" + "\x11\xf5\x77\x26\xc7\xd7\xcf\xe8" + "\x03\x02\xa7\x43\x30\x67\xb2\x9d" + "\x59\xa7\x14\x15\xca\x9d\xd1\x41" + "\xac\x89\x2d\x31\x0b\xc4\xd7\x81" + "\x28\xc9\x8f\xda\x83\x9d\x18\xd7" + "\xf0\x55\x6f\x2f\xe7\xac\xb3\xc0" + "\xcd\xa4\xbf\xf3\xa2\x5f\x5f\x59"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xaf\x32\x8d\x17\xfa\x28\x75\x3a" + "\x3c\x9f\x5c\xb7\x2e\x37\x6b\x90" + "\x44\x0b\x96\xf0\x28\x9e\x57\x03" + "\xb7\x29\x32\x4a\x97\x5a\xb3\x84" + "\xed\xa5\x65\xfc\x92\xaa\xde\xd1" + "\x43\x66\x99\x00\xd7\x61\x86\x16" + "\x87\xac\xdc\x0a\x5f\xfa\x35\x8b" + "\xd0\x57\x1a\xaa\xd8\x0a\xca\x68"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xd1\xdb\x17\xb4\x74\x5b\x25\x5e" + "\x5e\xb1\x59\xf6\x65\x93\xcc\x9c" + "\x14\x38\x50\x97\x9f\xc7\xa3\x95" + "\x17\x96\xab\xa8\x01\x65\xaa\xb5" + "\x36\xb4\x61\x74\xce\x19\xe3\xf7" + "\x07\xf0\xe5\xc6\x48\x7f\x5f\x03" + "\x08\x4b\xc0\xec\x94\x61\x69\x1e" + "\xf2\x01\x13\xe4\x2a\xd2\x81\x63"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x95\x24\xb9\xa5\x53\x6b\x91\x06" + "\x95\x26\xb4\xf6\x19\x6b\x7e\x94" + "\x75\xb4\xda\x69\xe0\x1f\x0c\x85" + "\x57\x97\xf2\x24\xcd\x73\x35\xdd" + "\xb2\x86\xfd\x99\xb9\xb3\x2f\xfe" + "\x33\xb5\x9a\xd4\x24\xcc\x17\x44" + "\xf6\xeb\x59\x13\x7f\x5f\xb8\x60" + "\x19\x32\xe8\xa8\xaf\x0a\xe9\x30"); + + SHA3_KATS_TEST(Sha3_512, SHA3_512); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_256_Free(&sha3); +int test_wc_Sha3_other(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHA3 + DIGEST_ALT_OTHER_TEST(wc_Sha3, Sha3_224, SHA3_224, + "\xbb\x4e\xb3\xf7\xfb\x7b\x50\xff" + "\x3b\xf8\xb0\x53\x8c\x13\x40\xce" + "\x0c\x43\x5f\xff\x6a\x08\x43\x87" + "\x34\x9f\x7a\x4c"); + DIGEST_ALT_OTHER_TEST(wc_Sha3, Sha3_256, SHA3_256, + "\x78\xc4\x14\xa4\x5d\x85\x07\xf4" + "\x48\x64\xe0\x5f\x73\x2c\x3b\x78" + "\xce\x5a\x78\x45\x97\x0b\x29\xa8" + "\xb4\x53\xed\x38\x19\xd2\x4e\xa9"); + DIGEST_ALT_OTHER_TEST(wc_Sha3, Sha3_384, SHA3_384, + "\x22\x29\x8c\x46\xa7\xf0\xf9\xc7" + "\xa7\xaf\x66\x5d\x58\x88\xb3\x6c" + "\xc2\x02\x43\x83\x71\x5f\xce\x12" + "\x65\x1b\x11\xba\x1c\xde\x52\xdc" + "\x6f\xde\x26\x43\xf1\x9f\xbe\xea" + "\x5f\xd6\x25\x06\x7c\xad\x16\xed"); + DIGEST_ALT_OTHER_TEST(wc_Sha3, Sha3_512, SHA3_512, + "\xc3\xaf\x62\x06\x69\x92\xa1\x2f" + "\xa5\x66\xcc\xcd\xec\x80\xdd\x27" + "\x93\xbd\x11\xb0\xb7\xba\x6a\x5e" + "\x36\xcf\x23\x4c\x1a\xf4\x8d\x37" + "\xb9\xb6\x7f\xb1\xb4\x9a\x04\x23" + "\x23\x42\x51\x5d\x8f\x07\x0d\x42" + "\x04\x68\x84\xc4\x56\x24\x14\x65" + "\x84\x28\xa9\x2f\x10\x35\x7b\x6d"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_256_Final */ +} -/* - * Testing wc_Sha3_384_Final() - */ -int test_wc_Sha3_384_Final(void) +int test_wc_Sha3_Copy(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) - wc_Sha3 sha3; - const char* msg = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnom" - "nopnopq"; - const char* expOut = "\x99\x1c\x66\x57\x55\xeb\x3a\x4b\x6b\xbd\xfb\x75\xc7" - "\x8a\x49\x2e\x8c\x56\xa2\x2c\x5c\x4d\x7e\x42\x9b\xfd" - "\xbc\x32\xb9\xd4\xad\x5a\xa0\x4a\x1f\x07\x6e\x62\xfe" - "\xa1\x9e\xef\x51\xac\xd0\x65\x7c\x22"; - byte hash[WC_SHA3_384_DIGEST_SIZE]; - byte hashRet[WC_SHA3_384_DIGEST_SIZE]; - - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_384_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(expOut, hash, WC_SHA3_384_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_384_Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_384_Final(&sha3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_384_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashRet, 0, sizeof(hashRet)); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_384_GetHash(&sha3, hashRet), 0); - ExpectIntEQ(wc_Sha3_384_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(hash, hashRet, WC_SHA3_384_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_384_GetHash(NULL, hashRet), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_384_GetHash(&sha3, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHA3 + DIGEST_ALT_COPY_TEST(wc_Sha3, Sha3_224, SHA3_224, + "\x6b\x4e\x03\x42\x36\x67\xdb\xb7" + "\x3b\x6e\x15\x45\x4f\x0e\xb1\xab" + "\xd4\x59\x7f\x9a\x1b\x07\x8e\x3f" + "\x5b\x5a\x6b\xc7", + "\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a" + "\xd0\x92\x34\xee\x7d\x3c\x76\x6f" + "\xc9\xa3\xa5\x16\x8d\x0c\x94\xad" + "\x73\xb4\x6f\xdf"); + DIGEST_ALT_COPY_TEST(wc_Sha3, Sha3_256, SHA3_256, + "\xa7\xff\xc6\xf8\xbf\x1e\xd7\x66" + "\x51\xc1\x47\x56\xa0\x61\xd6\x62" + "\xf5\x80\xff\x4d\xe4\x3b\x49\xfa" + "\x82\xd8\x0a\x4b\x80\xf8\x43\x4a", + "\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2" + "\x04\x5c\x17\x2d\x6b\xd3\x90\xbd" + "\x85\x5f\x08\x6e\x3e\x9d\x52\x5b" + "\x46\xbf\xe2\x45\x11\x43\x15\x32"); + DIGEST_ALT_COPY_TEST(wc_Sha3, Sha3_384, SHA3_384, + "\x0c\x63\xa7\x5b\x84\x5e\x4f\x7d" + "\x01\x10\x7d\x85\x2e\x4c\x24\x85" + "\xc5\x1a\x50\xaa\xaa\x94\xfc\x61" + "\x99\x5e\x71\xbb\xee\x98\x3a\x2a" + "\xc3\x71\x38\x31\x26\x4a\xdb\x47" + "\xfb\x6b\xd1\xe0\x58\xd5\xf0\x04", + "\xec\x01\x49\x82\x88\x51\x6f\xc9" + "\x26\x45\x9f\x58\xe2\xc6\xad\x8d" + "\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25" + "\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2" + "\x98\xd8\x8c\xea\x92\x7a\xc7\xf5" + "\x39\xf1\xed\xf2\x28\x37\x6d\x25"); + DIGEST_ALT_COPY_TEST(wc_Sha3, Sha3_512, SHA3_512, + "\xa6\x9f\x73\xcc\xa2\x3a\x9a\xc5" + "\xc8\xb5\x67\xdc\x18\x5a\x75\x6e" + "\x97\xc9\x82\x16\x4f\xe2\x58\x59" + "\xe0\xd1\xdc\xc1\x47\x5c\x80\xa6" + "\x15\xb2\x12\x3a\xf1\xf5\xf9\x4c" + "\x11\xe3\xe9\x40\x2c\x3a\xc5\x58" + "\xf5\x00\x19\x9d\x95\xb6\xd3\xe3" + "\x01\x75\x85\x86\x28\x1d\xcd\x26", + "\xb7\x51\x85\x0b\x1a\x57\x16\x8a" + "\x56\x93\xcd\x92\x4b\x6b\x09\x6e" + "\x08\xf6\x21\x82\x74\x44\xf7\x0d" + "\x88\x4f\x5d\x02\x40\xd2\x71\x2e" + "\x10\xe1\x16\xe9\x19\x2a\xf3\xc9" + "\x1a\x7e\xc5\x76\x47\xe3\x93\x40" + "\x57\x34\x0b\x4c\xf4\x08\xd5\xa5" + "\x65\x92\xf8\x27\x4e\xec\x53\xf0"); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_384_Free(&sha3); +int test_wc_Sha3_GetHash(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHA3 + SHA3_GET_HASH_TEST(Sha3_224, SHA3_224, + "\x6b\x4e\x03\x42\x36\x67\xdb\xb7" + "\x3b\x6e\x15\x45\x4f\x0e\xb1\xab" + "\xd4\x59\x7f\x9a\x1b\x07\x8e\x3f" + "\x5b\x5a\x6b\xc7", + "\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a" + "\xd0\x92\x34\xee\x7d\x3c\x76\x6f" + "\xc9\xa3\xa5\x16\x8d\x0c\x94\xad" + "\x73\xb4\x6f\xdf"); + SHA3_GET_HASH_TEST(Sha3_256, SHA3_256, + "\xa7\xff\xc6\xf8\xbf\x1e\xd7\x66" + "\x51\xc1\x47\x56\xa0\x61\xd6\x62" + "\xf5\x80\xff\x4d\xe4\x3b\x49\xfa" + "\x82\xd8\x0a\x4b\x80\xf8\x43\x4a", + "\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2" + "\x04\x5c\x17\x2d\x6b\xd3\x90\xbd" + "\x85\x5f\x08\x6e\x3e\x9d\x52\x5b" + "\x46\xbf\xe2\x45\x11\x43\x15\x32"); + SHA3_GET_HASH_TEST(Sha3_384, SHA3_384, + "\x0c\x63\xa7\x5b\x84\x5e\x4f\x7d" + "\x01\x10\x7d\x85\x2e\x4c\x24\x85" + "\xc5\x1a\x50\xaa\xaa\x94\xfc\x61" + "\x99\x5e\x71\xbb\xee\x98\x3a\x2a" + "\xc3\x71\x38\x31\x26\x4a\xdb\x47" + "\xfb\x6b\xd1\xe0\x58\xd5\xf0\x04", + "\xec\x01\x49\x82\x88\x51\x6f\xc9" + "\x26\x45\x9f\x58\xe2\xc6\xad\x8d" + "\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25" + "\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2" + "\x98\xd8\x8c\xea\x92\x7a\xc7\xf5" + "\x39\xf1\xed\xf2\x28\x37\x6d\x25"); + SHA3_GET_HASH_TEST(Sha3_512, SHA3_512, + "\xa6\x9f\x73\xcc\xa2\x3a\x9a\xc5" + "\xc8\xb5\x67\xdc\x18\x5a\x75\x6e" + "\x97\xc9\x82\x16\x4f\xe2\x58\x59" + "\xe0\xd1\xdc\xc1\x47\x5c\x80\xa6" + "\x15\xb2\x12\x3a\xf1\xf5\xf9\x4c" + "\x11\xe3\xe9\x40\x2c\x3a\xc5\x58" + "\xf5\x00\x19\x9d\x95\xb6\xd3\xe3" + "\x01\x75\x85\x86\x28\x1d\xcd\x26", + "\xb7\x51\x85\x0b\x1a\x57\x16\x8a" + "\x56\x93\xcd\x92\x4b\x6b\x09\x6e" + "\x08\xf6\x21\x82\x74\x44\xf7\x0d" + "\x88\x4f\x5d\x02\x40\xd2\x71\x2e" + "\x10\xe1\x16\xe9\x19\x2a\xf3\xc9" + "\x1a\x7e\xc5\x76\x47\xe3\x93\x40" + "\x57\x34\x0b\x4c\xf4\x08\xd5\xa5" + "\x65\x92\xf8\x27\x4e\xec\x53\xf0"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_384_Final */ +} -/* - * Testing wc_Sha3_512_Final() - */ -int test_wc_Sha3_512_Final(void) +int test_wc_Sha3_Flags(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) && \ - !defined(WOLFSSL_NOSHA3_384) - wc_Sha3 sha3; - const char* msg = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnom" - "nopnopq"; - const char* expOut = "\x04\xa3\x71\xe8\x4e\xcf\xb5\xb8\xb7\x7c\xb4\x86\x10" - "\xfc\xa8\x18\x2d\xd4\x57\xce\x6f\x32\x6a\x0f\xd3\xd7" - "\xec\x2f\x1e\x91\x63\x6d\xee\x69\x1f\xbe\x0c\x98\x53" - "\x02\xba\x1b\x0d\x8d\xc7\x8c\x08\x63\x46\xb5\x33\xb4" - "\x9c\x03\x0d\x99\xa2\x7d\xaf\x11\x39\xd6\xe7\x5e"; - byte hash[WC_SHA3_512_DIGEST_SIZE]; - byte hashRet[WC_SHA3_512_DIGEST_SIZE]; - - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_512_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(expOut, hash, WC_SHA3_512_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_512_Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_512_Final(&sha3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Sha3_512_Free(&sha3); - - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashRet, 0, sizeof(hashRet)); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, (byte*)msg, (word32)XSTRLEN(msg)), 0); - ExpectIntEQ(wc_Sha3_512_GetHash(&sha3, hashRet), 0); - ExpectIntEQ(wc_Sha3_512_Final(&sha3, hash), 0); - ExpectIntEQ(XMEMCMP(hash, hashRet, WC_SHA3_512_DIGEST_SIZE), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_512_GetHash(NULL, hashRet), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_512_GetHash(&sha3, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_ALT_FLAGS_TEST(wc_Sha3, Sha3, Sha3_256); +#endif + return EXPECT_RESULT(); +} + +/******************************************************************************* + * SHAKE-128 + ******************************************************************************/ - wc_Sha3_512_Free(&sha3); +int test_wc_InitShake128(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE128 + DIGEST_INIT_TEST(wc_Shake, Shake128); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_512_Final */ +} -/* - * Testing wc_Sha3_224_Copy() - */ -int test_wc_Sha3_224_Copy(void) +int test_wc_Shake128_Update(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) - wc_Sha3 sha3, sha3Cpy; - const char* msg = TEST_STRING; - word32 msglen = (word32)TEST_STRING_SZ; - byte hash[WC_SHA3_224_DIGEST_SIZE]; - byte hashCpy[WC_SHA3_224_DIGEST_SIZE]; - - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashCpy, 0, sizeof(hashCpy)); - XMEMSET(&sha3, 0, sizeof(wc_Sha3)); - XMEMSET(&sha3Cpy, 0, sizeof(wc_Sha3)); - - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_InitSha3_224(&sha3Cpy, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_224_Update(&sha3, (byte*)msg, msglen), 0); - ExpectIntEQ(wc_Sha3_224_Copy(&sha3Cpy, &sha3), 0); - ExpectIntEQ(wc_Sha3_224_Final(&sha3, hash), 0); - ExpectIntEQ(wc_Sha3_224_Final(&sha3Cpy, hashCpy), 0); - ExpectIntEQ(XMEMCMP(hash, hashCpy, sizeof(hash)), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_224_Copy(NULL, &sha3), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_224_Copy(&sha3Cpy, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHAKE128 + DIGEST_ALT_UPDATE_TEST(wc_Shake, Shake128); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_224_Free(&sha3); - wc_Sha3_224_Free(&sha3Cpy); +int test_wc_Shake128_Final(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE128 + DIGEST_COUNT_FINAL_TEST(wc_Shake, Shake128, SHA3_128); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_224_Copy */ +} -/* - * Testing wc_Sha3_256_Copy() - */ -int test_wc_Sha3_256_Copy(void) +#define SHAKE128_KAT_CNT 7 +int test_wc_Shake128_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) - wc_Sha3 sha3, sha3Cpy; - const char* msg = TEST_STRING; - word32 msglen = (word32)TEST_STRING_SZ; - byte hash[WC_SHA3_256_DIGEST_SIZE]; - byte hashCpy[WC_SHA3_256_DIGEST_SIZE]; - - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashCpy, 0, sizeof(hashCpy)); - XMEMSET(&sha3, 0, sizeof(wc_Sha3)); - XMEMSET(&sha3Cpy, 0, sizeof(wc_Sha3)); - - ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_InitSha3_256(&sha3Cpy, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_256_Update(&sha3, (byte*)msg, msglen), 0); - ExpectIntEQ(wc_Sha3_256_Copy(&sha3Cpy, &sha3), 0); - ExpectIntEQ(wc_Sha3_256_Final(&sha3, hash), 0); - ExpectIntEQ(wc_Sha3_256_Final(&sha3Cpy, hashCpy), 0); - ExpectIntEQ(XMEMCMP(hash, hashCpy, sizeof(hash)), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_256_Copy(NULL, &sha3), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_256_Copy(&sha3Cpy, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHAKE128 + DIGEST_COUNT_KATS_TEST_VARS(wc_Shake, SHAKE128, SHA3_128); + + DIGEST_KATS_ADD("", 0, + "\x7f\x9c\x2b\xa4\xe8\x8f\x82\x7d" + "\x61\x60\x45\x50\x76\x05\x85\x3e" + "\xd7\x3b\x80\x93\xf6\xef\xbc\x88" + "\xeb\x1a\x6e\xac\xfa\x66\xef\x26" + "\x3c\xb1\xee\xa9\x88\x00\x4b\x93" + "\x10\x3c\xfb\x0a\xee\xfd\x2a\x68" + "\x6e\x01\xfa\x4a\x58\xe8\xa3\x63" + "\x9c\xa8\xa1\xe3\xf9\xae\x57\xe2" + "\x35\xb8\xcc\x87\x3c\x23\xdc\x62" + "\xb8\xd2\x60\x16\x9a\xfa\x2f\x75" + "\xab\x91\x6a\x58\xd9\x74\x91\x88" + "\x35\xd2\x5e\x6a\x43\x50\x85\xb2" + "\xba\xdf\xd6\xdf\xaa\xc3\x59\xa5" + "\xef\xbb\x7b\xcc\x4b\x59\xd5\x38" + "\xdf\x9a\x04\x30\x2e\x10\xc8\xbc" + "\x1c\xbf\x1a\x0b\x3a\x51\x20\xea" + "\x17\xcd\xa7\xcf\xad\x76\x5f\x56" + "\x23\x47\x4d\x36\x8c\xcc\xa8\xaf" + "\x00\x07\xcd\x9f\x5e\x4c\x84\x9f" + "\x16\x7a\x58\x0b\x14\xaa\xbd\xef" + "\xae\xe7\xee\xf4\x7c\xb0\xfc\xa9"); + DIGEST_KATS_ADD("a", 1, + "\x85\xc8\xde\x88\xd2\x88\x66\xbf" + "\x08\x68\x09\x0b\x39\x61\x16\x2b" + "\xf8\x23\x92\xf6\x90\xd9\xe4\x73" + "\x09\x10\xf4\xaf\x7c\x6a\xb3\xee" + "\x43\x54\xb4\x9c\xa7\x29\xeb\x35" + "\x6e\xe3\xf5\xb0\xfb\xd2\x9b\x66" + "\x76\x93\x83\xe5\xe4\x01\xb1\xf8" + "\x5e\x04\x4c\x92\xbb\x52\x31\xaa" + "\x4d\xee\x17\x99\xaf\x7a\x7c\xee" + "\x21\x3a\x23\xad\xcd\x03\xc4\x80" + "\x6c\x9a\x8b\x0d\x8a\x2e\xea\xd8" + "\xea\x7a\x61\x34\xc1\x3e\x52\x3c" + "\xcf\x93\xad\x39\xd2\x27\xd3\xe7" + "\xd0\x22\xd9\x65\x4f\x3b\x49\x41" + "\x37\x88\x75\x8a\x64\x17\xe4\x2d" + "\x41\x95\x7c\xb3\x0c\xf0\x4d\xa3" + "\x7f\x26\x89\x7c\x2c\xf2\xf8\x00" + "\x55\x84\x62\x93\xfd\xe0\x23\x31" + "\xcf\x4a\x26\x9a\xaf\x2d\x47\xeb" + "\x27\xab\xa0\xfa\xba\x4a\x67\x8e" + "\xc0\x02\xbc\x0d\x30\x64\xea\xd0"); + DIGEST_KATS_ADD("abc", 3, + "\x58\x81\x09\x2d\xd8\x18\xbf\x5c" + "\xf8\xa3\xdd\xb7\x93\xfb\xcb\xa7" + "\x40\x97\xd5\xc5\x26\xa6\xd3\x5f" + "\x97\xb8\x33\x51\x94\x0f\x2c\xc8" + "\x44\xc5\x0a\xf3\x2a\xcd\x3f\x2c" + "\xdd\x06\x65\x68\x70\x6f\x50\x9b" + "\xc1\xbd\xde\x58\x29\x5d\xae\x3f" + "\x89\x1a\x9a\x0f\xca\x57\x83\x78" + "\x9a\x41\xf8\x61\x12\x14\xce\x61" + "\x23\x94\xdf\x28\x6a\x62\xd1\xa2" + "\x25\x2a\xa9\x4d\xb9\xc5\x38\x95" + "\x6c\x71\x7d\xc2\xbe\xd4\xf2\x32" + "\xa0\x29\x4c\x85\x7c\x73\x0a\xa1" + "\x60\x67\xac\x10\x62\xf1\x20\x1f" + "\xb0\xd3\x77\xcf\xb9\xcd\xe4\xc6" + "\x35\x99\xb2\x7f\x34\x62\xbb\xa4" + "\xa0\xed\x29\x6c\x80\x1f\x9f\xf7" + "\xf5\x73\x02\xbb\x30\x76\xee\x14" + "\x5f\x97\xa3\x2a\xe6\x8e\x76\xab" + "\x66\xc4\x8d\x51\x67\x5b\xd4\x9a" + "\xcc\x29\x08\x2f\x56\x47\x58\x4e"); + DIGEST_KATS_ADD("message digest", 14, + "\xcb\xef\x73\x29\x61\xb5\x5b\x4c" + "\x31\x39\x67\x96\x57\x7d\xf4\x91" + "\xb6\xee\xd6\x1d\x89\x49\xce\x96" + "\x72\x26\x80\x1e\x41\x1e\x53\xf0" + "\x95\x44\xc1\x3f\xe4\xdf\x40\xfc" + "\x8d\xf5\xf9\x85\x3e\x85\x41\xd0" + "\x45\x41\xf1\x00\x77\xd9\xd4\x4e" + "\x74\x93\xe8\x7f\x16\x0a\x0a\x0d" + "\x37\xb3\xd6\xda\xc9\x64\x59\x88" + "\xed\x5d\x06\xdd\x53\x21\x99\x3d" + "\x87\x35\x74\xd1\x47\xe3\x36\xd7" + "\x23\x3a\x68\x27\x31\x87\x21\x48" + "\xe9\x3e\x72\x28\x16\xb3\xb1\xcc" + "\x31\x3b\xc4\x33\x94\x5f\x74\xf2" + "\x14\x39\xdf\xd8\xc8\x9b\xc5\x9b" + "\xf3\xd1\x6d\x48\x9a\x5d\x5c\xaf" + "\xdf\x77\xac\x07\xbe\x5d\x96\xa7" + "\x6e\x95\x27\x53\x07\xd8\x83\xca" + "\xd6\x25\x71\x43\xb5\x61\x00\x73" + "\xcb\xbf\x7b\x8e\x89\x70\x31\x74" + "\x66\xa8\xb6\x85\xd4\x81\x78\xb8"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x96\x1c\x91\x9c\x08\x54\x57\x6e" + "\x56\x13\x20\xe8\x15\x14\xbf\x37" + "\x24\x19\x7d\x07\x15\xe1\x6a\x36" + "\x45\x20\x38\x4e\xe9\x97\xf6\xef" + "\x3b\xe7\xad\x1a\xb6\x87\xd3\x1e" + "\xbd\x7e\x66\x04\xef\x2c\x76\x52" + "\x93\x2e\x42\x06\x11\x3d\x26\x35" + "\x14\xe7\x2f\x31\xf5\xe1\xdf\x87" + "\xc5\xf5\x4f\xc4\x3e\x8f\x85\x7f" + "\xc4\xa5\x2b\xbb\x56\x5b\xd6\xd4" + "\x58\x69\xdf\x92\x59\xc0\x97\x74" + "\x72\x83\x94\xe3\xe0\xc3\xb3\x26" + "\x41\x00\x85\xc3\x56\xe5\xb1\x73" + "\xd5\x70\x08\x79\x45\xb0\xf0\x68" + "\xe4\xc6\x3a\x5b\x19\x1f\xef\x22" + "\xd9\x3b\x9f\xd4\x21\x13\x28\xd7" + "\x0e\x51\x4f\xec\x92\xb1\xb4\x86" + "\x43\x49\x59\x18\xb6\x41\xea\xb0" + "\x54\x60\xd0\x79\x8c\xbe\x42\xfd" + "\xa4\x7a\x23\x75\xf1\x06\x5d\x03" + "\x7e\xbc\x76\xbd\xce\xff\x29\xef"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\x54\xdd\x20\x1e\x53\x24\x99\x10" + "\xdb\x3c\x7d\x36\x65\x74\xfb\xb6" + "\x4e\x71\xfa\xe4\x42\xa4\xba\xc1" + "\x34\x39\xf2\x6d\xd4\x89\x68\x83" + "\x70\xd0\x12\xa1\x55\x86\xd8\x7e" + "\x73\x00\xbe\xed\xd9\x23\x3e\xea" + "\x98\xf9\x16\xda\xb2\x66\x51\x38" + "\x02\x50\x24\x40\x31\x5b\xba\x9e" + "\x40\xcd\xb8\x60\x09\x7b\x12\xdf" + "\xd8\x8d\x4f\x24\x2f\x77\xc2\x2e" + "\x93\xad\xfd\x3e\xb7\x89\x94\x82" + "\xd3\x9f\x7c\x0f\x16\x0e\xcc\x07" + "\x04\x73\x47\x82\x94\x73\x31\x46" + "\x74\xa5\x6a\x13\xe7\x01\xd5\xd8" + "\xaa\x37\x54\x6b\x43\xc5\x73\x36" + "\x56\xc1\xac\x3c\xa4\x69\x7a\x30" + "\x32\x0b\x98\xad\xf9\xbc\xa3\xc6" + "\x8b\xec\x9f\x14\xe3\x3b\x8f\xae" + "\x30\xd5\x5e\xc6\x0e\x80\x15\xa5" + "\x16\x80\xbb\x37\xeb\x5a\x7e\xbc" + "\x90\x88\xcd\xcf\x09\xff\x2d\x6b"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x7b\xf4\x51\xc9\x2f\xdc\x77\xb9" + "\x77\x1e\x6c\x90\x56\x44\x58\x94" + "\xee\x86\x7f\x00\xc2\xb7\x0d\x3a" + "\xf0\xd1\x96\xa0\xcf\x6b\x28\xe1" + "\x2c\xed\x96\x05\x37\xf2\x2a\x0e" + "\x90\x33\x41\x03\x67\x58\x44\x99" + "\x3c\x4f\xd7\x13\x64\x68\x00\xbd" + "\x89\x99\x51\xe5\x6f\x06\x45\xfc" + "\xf0\x39\x78\xa6\x27\xc0\x7c\x62" + "\xa7\x5a\x54\x3b\x8a\xf7\xed\xb0" + "\xaf\xe7\x64\x3d\x94\x95\x36\x3b" + "\x30\xbc\xc5\x50\x1c\x74\xdf\x19" + "\x5b\x2a\xd4\x28\x83\x1b\x77\x9b" + "\xf1\xab\x2a\x0d\xfc\x92\xa5\x92" + "\x5a\xc8\xd5\x97\x90\xee\xbc\xf2" + "\xec\x29\xb3\x33\x8f\x66\x0c\x5a" + "\x6f\x66\x73\xce\x32\x2c\xc1\x03" + "\x9a\xe5\xf1\x46\x3b\x86\xca\x7e" + "\x96\xaa\xa9\x9a\x27\x09\x93\x02" + "\x6a\xc8\x13\xda\xc4\xb9\xeb\x82" + "\x14\xe3\x1c\xe8\x68\x27\xcb\x21"); + + DIGEST_COUNT_KATS_TEST(Shake128, SHAKE128, SHA3_128); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_256_Free(&sha3); - wc_Sha3_256_Free(&sha3Cpy); +int test_wc_Shake128_other(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE128 + DIGEST_COUNT_OTHER_TEST(wc_Shake, Shake128, SHA3_128, + "\x1b\xbe\x22\xa0\x40\xc7\x15\x88" + "\xcc\x2b\xaa\x3e\x5a\x7c\x89\x03" + "\x33\xd4\xac\x54\x27\x14\xf9\x96" + "\x0e\x60\x3d\x8f\x13\x9a\xf8\x1e" + "\x8f\x45\xc8\x37\xa8\x63\x16\x7b" + "\x96\x69\xd4\xe4\x2e\x45\x9f\x1d" + "\x50\xaa\x92\x2e\x0d\x32\x37\x97" + "\xf7\xd7\xcc\x7c\x5c\xfa\x71\x42" + "\xf3\x23\x68\x6a\x36\x03\xd4\x0a" + "\x77\x7d\xd3\x84\x40\x75\xc5\xad" + "\x1f\xb7\xa4\x90\x80\x66\x91\x49" + "\x7d\x3e\x8a\x69\xb9\x94\xbf\x0f" + "\x0a\x09\xde\xc8\xfe\x10\xb5\x4f" + "\xe5\x78\xda\x4c\x3a\xcd\xcd\xc2" + "\x30\xb0\x14\x75\x45\x2b\x2e\x40" + "\x74\xf4\x5c\xad\x2e\xcf\x1c\xa0" + "\x0b\x8d\x58\x30\xcd\x0f\xaa\x11" + "\x68\x84\x2b\x55\xa7\x62\x1b\x9a" + "\xec\x6e\xd6\xcc\xa1\xc9\x9f\xc8" + "\x11\x74\xb4\x22\x18\xc0\xe6\x37" + "\xc4\xef\xc2\xe4\xc3\x26\x27\x0b"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_256_Copy */ +} -/* - * Testing wc_Sha3_384_Copy() - */ -int test_wc_Sha3_384_Copy(void) +int test_wc_Shake128_Copy(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) - wc_Sha3 sha3, sha3Cpy; - const char* msg = TEST_STRING; - word32 msglen = (word32)TEST_STRING_SZ; - byte hash[WC_SHA3_384_DIGEST_SIZE]; - byte hashCpy[WC_SHA3_384_DIGEST_SIZE]; - - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashCpy, 0, sizeof(hashCpy)); - XMEMSET(&sha3, 0, sizeof(wc_Sha3)); - XMEMSET(&sha3Cpy, 0, sizeof(wc_Sha3)); - - ExpectIntEQ(wc_InitSha3_384(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_InitSha3_384(&sha3Cpy, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_384_Update(&sha3, (byte*)msg, msglen), 0); - ExpectIntEQ(wc_Sha3_384_Copy(&sha3Cpy, &sha3), 0); - ExpectIntEQ(wc_Sha3_384_Final(&sha3, hash), 0); - ExpectIntEQ(wc_Sha3_384_Final(&sha3Cpy, hashCpy), 0); - ExpectIntEQ(XMEMCMP(hash, hashCpy, sizeof(hash)), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_384_Copy(NULL, &sha3), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_384_Copy(&sha3Cpy, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WOLFSSL_SHAKE128 + DIGEST_COUNT_COPY_TEST(wc_Shake, Shake128, SHA3_128, + "\x7f\x9c\x2b\xa4\xe8\x8f\x82\x7d" + "\x61\x60\x45\x50\x76\x05\x85\x3e" + "\xd7\x3b\x80\x93\xf6\xef\xbc\x88" + "\xeb\x1a\x6e\xac\xfa\x66\xef\x26" + "\x3c\xb1\xee\xa9\x88\x00\x4b\x93" + "\x10\x3c\xfb\x0a\xee\xfd\x2a\x68" + "\x6e\x01\xfa\x4a\x58\xe8\xa3\x63" + "\x9c\xa8\xa1\xe3\xf9\xae\x57\xe2" + "\x35\xb8\xcc\x87\x3c\x23\xdc\x62" + "\xb8\xd2\x60\x16\x9a\xfa\x2f\x75" + "\xab\x91\x6a\x58\xd9\x74\x91\x88" + "\x35\xd2\x5e\x6a\x43\x50\x85\xb2" + "\xba\xdf\xd6\xdf\xaa\xc3\x59\xa5" + "\xef\xbb\x7b\xcc\x4b\x59\xd5\x38" + "\xdf\x9a\x04\x30\x2e\x10\xc8\xbc" + "\x1c\xbf\x1a\x0b\x3a\x51\x20\xea" + "\x17\xcd\xa7\xcf\xad\x76\x5f\x56" + "\x23\x47\x4d\x36\x8c\xcc\xa8\xaf" + "\x00\x07\xcd\x9f\x5e\x4c\x84\x9f" + "\x16\x7a\x58\x0b\x14\xaa\xbd\xef" + "\xae\xe7\xee\xf4\x7c\xb0\xfc\xa9", + "\x58\x81\x09\x2d\xd8\x18\xbf\x5c" + "\xf8\xa3\xdd\xb7\x93\xfb\xcb\xa7" + "\x40\x97\xd5\xc5\x26\xa6\xd3\x5f" + "\x97\xb8\x33\x51\x94\x0f\x2c\xc8" + "\x44\xc5\x0a\xf3\x2a\xcd\x3f\x2c" + "\xdd\x06\x65\x68\x70\x6f\x50\x9b" + "\xc1\xbd\xde\x58\x29\x5d\xae\x3f" + "\x89\x1a\x9a\x0f\xca\x57\x83\x78" + "\x9a\x41\xf8\x61\x12\x14\xce\x61" + "\x23\x94\xdf\x28\x6a\x62\xd1\xa2" + "\x25\x2a\xa9\x4d\xb9\xc5\x38\x95" + "\x6c\x71\x7d\xc2\xbe\xd4\xf2\x32" + "\xa0\x29\x4c\x85\x7c\x73\x0a\xa1" + "\x60\x67\xac\x10\x62\xf1\x20\x1f" + "\xb0\xd3\x77\xcf\xb9\xcd\xe4\xc6" + "\x35\x99\xb2\x7f\x34\x62\xbb\xa4" + "\xa0\xed\x29\x6c\x80\x1f\x9f\xf7" + "\xf5\x73\x02\xbb\x30\x76\xee\x14" + "\x5f\x97\xa3\x2a\xe6\x8e\x76\xab" + "\x66\xc4\x8d\x51\x67\x5b\xd4\x9a" + "\xcc\x29\x08\x2f\x56\x47\x58\x4e"); +#endif + return EXPECT_RESULT(); +} - wc_Sha3_384_Free(&sha3); - wc_Sha3_384_Free(&sha3Cpy); +int test_wc_Shake128Hash(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE128 + const byte data[] = { /* Hello World */ + 0x48,0x65,0x6c,0x6c,0x6f,0x20,0x57,0x6f, + 0x72,0x6c,0x64 + }; + word32 len = sizeof(data); + byte hash[WC_SHA3_128_COUNT * 8]; + word32 hashLen = sizeof(hash); + const char* expHash = + "\x12\x27\xc5\xf8\x82\xf9\xc5\x7b" + "\xf2\xe3\xe4\x8d\x2c\x87\xeb\x20" + "\xf3\x82\xa4\xb6\x39\xb5\x4d\x26" + "\xf6\xd5\x95\xff\x3d\xb9\x06\x4d" + "\x07\x4e\xe7\x88\xf0\x74\x7c\xa3" + "\xfc\x46\xce\x86\x93\x6c\xfc\x6b" + "\xd3\x63\x8d\xae\x5a\x2b\x7d\x65" + "\x92\x52\x29\x98\xd6\xda\x6f\xaa" + "\x5f\x5d\x41\x5d\x99\xd5\x56\x51" + "\x46\xee\x3c\xd2\xb8\xec\x15\x38" + "\xbc\x62\xdd\xe9\x46\x94\x9b\x23" + "\xb8\xcf\x3c\xa3\xe4\x7f\x35\x2d" + "\x3c\x46\x2f\x16\x87\x10\x84\x34" + "\xf7\x84\x95\x2c\xcf\xe3\x26\xaf" + "\xdf\x78\x53\xb3\x98\x20\x22\xca" + "\x14\x82\xbc\x9c\xd1\x8f\x9a\x6c" + "\xe0\x92\x0b\x8f\x34\x5a\xa0\x4e" + "\x7f\xd5\x83\xa4\xe2\x01\x25\x33" + "\x45\x0b\x00\xc1\x6a\x5a\x14\xe8" + "\x6a\xd1\x45\x0c\x4e\x8a\x4a\x6f" + "\x37\xb4\x15\x5d\xd6\x0d\xd1\xab"; + + ExpectIntEQ(wc_Shake128Hash(data, len, hash, hashLen), 0); + ExpectBufEQ(hash, expHash, hashLen); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_384_Copy */ +} -/* - * Testing wc_Sha3_512_Copy() - */ -int test_wc_Sha3_512_Copy(void) +int test_wc_Shake128_Absorb(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) - wc_Sha3 sha3, sha3Cpy; - const char* msg = TEST_STRING; - word32 msglen = (word32)TEST_STRING_SZ; - byte hash[WC_SHA3_512_DIGEST_SIZE]; - byte hashCpy[WC_SHA3_512_DIGEST_SIZE]; - - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashCpy, 0, sizeof(hashCpy)); - XMEMSET(&sha3, 0, sizeof(wc_Sha3)); - XMEMSET(&sha3Cpy, 0, sizeof(wc_Sha3)); - - ExpectIntEQ(wc_InitSha3_512(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_InitSha3_512(&sha3Cpy, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_512_Update(&sha3, (byte*)msg, msglen), 0); - ExpectIntEQ(wc_Sha3_512_Copy(&sha3Cpy, &sha3), 0); - ExpectIntEQ(wc_Sha3_512_Final(&sha3, hash), 0); - ExpectIntEQ(wc_Sha3_512_Final(&sha3Cpy, hashCpy), 0); - ExpectIntEQ(XMEMCMP(hash, hashCpy, sizeof(hash)), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Sha3_512_Copy(NULL, &sha3), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha3_512_Copy(&sha3Cpy, NULL), +#ifdef WOLFSSL_SHAKE128 + wc_Shake shake128; + + ExpectIntEQ(wc_InitShake128(&shake128, HEAP_HINT, INVALID_DEVID), 0); + + ExpectIntEQ(wc_Shake128_Absorb(NULL , NULL , 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake128_Absorb(&shake128, NULL , 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake128_Absorb(NULL , NULL , 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectIntEQ(wc_Shake128_Absorb(&shake128, NULL, 0), 0); + ExpectIntEQ(wc_Shake128_Absorb(&shake128, (byte*)"a", 1), 0); - wc_Sha3_512_Free(&sha3); - wc_Sha3_512_Free(&sha3Cpy); + wc_Shake128_Free(&shake128); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_512_Copy */ +} -/* - * Unit test function for wc_Sha3_GetFlags() - */ -int test_wc_Sha3_GetFlags(void) +int test_wc_Shake128_SqueezeBlocks(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha3 sha3; - word32 flags = 0; +#ifdef WOLFSSL_SHAKE128 + wc_Shake shake128; + byte hash[WC_SHA3_128_COUNT * 8]; + + ExpectIntEQ(wc_InitShake128(&shake128, HEAP_HINT, INVALID_DEVID), 0); - /* Initialize */ - ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Sha3_GetFlags(&sha3, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - wc_Sha3_224_Free(&sha3); + ExpectIntEQ(wc_Shake128_SqueezeBlocks(NULL , NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake128_SqueezeBlocks(NULL , NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, NULL, 0), 0); + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, hash, 1), 0); + + wc_Shake128_Free(&shake128); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha3_GetFlags */ +} + +#define TEST_SHAKE128_MAX_BLOCKS 3 +int test_wc_Shake128_XOF(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE128 + wc_Shake shake128; + byte hash[WC_SHA3_128_COUNT * 8 * TEST_SHAKE128_MAX_BLOCKS]; + const char* expOut = + "\xf4\x2f\xac\xcf\x13\x0e\x25\x5f" + "\xfd\x4a\x29\xbb\x9d\x47\x25\xea" + "\x19\xfe\x86\xd3\xeb\x58\xd7\x74" + "\xc1\x3c\xf9\xc7\x0e\xdc\xc6\x3b" + "\x4b\x97\x0d\x2b\xbc\xa6\x89\x4c" + "\xda\x48\x8c\x02\x62\x15\x1f\x2e" + "\x36\xb1\x95\x78\xfe\x02\x81\x35" + "\x30\x55\x5f\x3c\x06\x47\x2b\x93" + "\x1e\xf5\x8e\xf2\xfc\x81\x5b\xec" + "\x9f\xde\xf3\xee\xc0\xac\xb0\x90" + "\x5c\x19\xc8\x3e\x8a\xa4\xf6\xa7" + "\xdf\xa3\x39\xdf\x22\x03\x6c\x07" + "\xaa\xbb\xea\x3d\xec\x00\xc2\xb2" + "\x6e\x4c\x6b\xdc\xb8\x39\x8b\xb5" + "\x67\x3f\xdc\x2a\xf5\x91\x32\xb9" + "\x07\xbc\x1d\xb3\x92\x79\x13\xdb" + "\x56\xe5\xae\x43\x91\x58\x18\x41" + "\xa8\xe1\x75\x8e\x5b\xeb\xac\x4f" + "\xeb\x41\xac\x5d\x8b\x4a\x3d\xf6" + "\xb6\x5f\xe6\x9c\x19\x1e\x33\x97" + "\xbc\x7c\xa7\x7e\xed\x5c\xe5\x4b" + "\xdb\xa2\x34\xcd\x90\x94\x46\x19" + "\x2e\x60\xbb\xf4\xb1\xe6\x78\xc8" + "\xb2\x89\x0b\x2b\x0a\xb9\x69\x81" + "\x90\x36\xc7\x5e\xcc\x36\x46\xde" + "\x5e\x1d\xb2\x1d\x62\x46\x58\xdf" + "\x9a\x07\xea\xe5\x6e\xac\x06\x53" + "\x4f\xb4\xb5\x1e\xe3\x78\x60\x84" + "\xe0\x96\xfd\xe8\xc0\xf4\x3b\x80" + "\x7a\x2d\xb5\x22\x3e\xb5\x0f\x21" + "\xcb\x47\x13\x2d\x97\xb5\x28\x25" + "\xe7\x84\xa1\x64\x46\xa8\xeb\x8d" + "\xa7\xf9\xbe\x89\x3f\x96\x8a\x08" + "\x97\x8d\x5c\x72\x7c\x9d\x52\x27" + "\xea\xb2\xf0\x9d\x9c\x00\x0d\x3e" + "\xd1\xa4\x0f\xdd\xba\x43\x41\xfb" + "\xf8\x26\x13\x98\x27\x88\xae\x8b" + "\xfb\x8f\xcd\x37\x72\xb3\x37\x09" + "\xf4\xde\xde\x33\x8e\x1f\xbd\x49" + "\x90\x3c\x8a\x8b\xd2\x89\xb0\x26" + "\x39\xc8\x2f\xc7\xfc\x2d\xf9\xa7" + "\xd3\x5d\x69\x3d\x90\x17\x9c\xc1" + "\x83\xc7\x1d\xd6\xd3\xa2\x01\x57" + "\x33\x4f\x0d\xfc\x52\x9e\x2a\xd1" + "\x9e\xfb\x36\xdf\x3e\xb3\x49\x9f" + "\x83\x22\xa8\x24\x0e\xa1\xfb\xca" + "\xd5\x17\x58\x1a\x40\x3f\x4f\x54" + "\x3f\xd4\xed\x99\xd2\x39\xad\x37" + "\x03\x39\xf7\x3b\xcf\x52\x55\xc4" + "\x76\x74\x1d\x33\x04\x76\x44\x0d" + "\xf6\x93\x89\x9d\x74\x19\x9c\x09" + "\xd9\xf4\x5f\x0b\xbc\xf4\x13\xec" + "\x2c\xce\x5f\x2b\x00\xeb\x8b\xa0" + "\xa2\xf1\xdd\x93\xc0\x9c\x7c\xb5" + "\xca\xe2\xfb\x07\xa9\x1b\xa8\xc9" + "\xc9\x84\x2b\x7e\x1e\x05\x8c\x98" + "\xfd\x8d\x2a\xd0\xf2\x3a\x7b\x88" + "\x26\x4d\xed\x2b\xdb\x99\xb8\x9f" + "\x88\x01\x47\x29\xeb\x23\x80\x81" + "\x2b\xdd\xac\xbf\xcb\x1e\x80\x0d" + "\x4f\xba\xc3\x13\xfa\xb1\xa6\xa9" + "\x69\x09\x48\xe6\xb8\xd5\x55\x12" + "\xb5\x25\xba\xf6\xd4\x2a\x5e\xf0"; + int i; + int j; + + for (i = 1; i <= TEST_SHAKE128_MAX_BLOCKS; i++) { + ExpectIntEQ(wc_InitShake128(&shake128, HEAP_HINT, INVALID_DEVID), 0); + + ExpectIntEQ(wc_Shake128_Absorb(&shake128, (byte*)"Starting point", 15), + 0); + + for (j = 0; j < TEST_SHAKE128_MAX_BLOCKS; j += i) { + int cnt = TEST_SHAKE128_MAX_BLOCKS - j; + if (i < cnt) + cnt = i; + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, + hash + WC_SHA3_128_COUNT * 8 * j, cnt), 0); + } + ExpectBufEQ(hash, expOut, + WC_SHA3_128_COUNT * 8 * TEST_SHAKE128_MAX_BLOCKS); + } + + wc_Shake128_Free(&shake128); +#endif + return EXPECT_RESULT(); +} /******************************************************************************* * SHAKE-256 @@ -579,56 +1004,17 @@ int test_wc_InitShake256(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHAKE256 - wc_Shake shake; - - ExpectIntEQ(wc_InitShake256(&shake, HEAP_HINT, testDevId), 0); - /* Test bad args. */ - ExpectIntEQ(wc_InitShake256(NULL, HEAP_HINT, testDevId), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Shake256_Free(&shake); + DIGEST_INIT_TEST(wc_Shake, Shake256); #endif return EXPECT_RESULT(); } - int test_wc_Shake256_Update(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHAKE256 - wc_Shake shake; - byte msg[] = "Everybody's working for the weekend."; - byte msg2[] = "Everybody gets Friday off."; - byte msgCmp[] = "\x45\x76\x65\x72\x79\x62\x6f\x64\x79\x27\x73\x20" - "\x77\x6f\x72\x6b\x69\x6e\x67\x20\x66\x6f\x72\x20\x74" - "\x68\x65\x20\x77\x65\x65\x6b\x65\x6e\x64\x2e\x45\x76" - "\x65\x72\x79\x62\x6f\x64\x79\x20\x67\x65\x74\x73\x20" - "\x46\x72\x69\x64\x61\x79\x20\x6f\x66\x66\x2e"; - word32 msglen = sizeof(msg) - 1; - word32 msg2len = sizeof(msg2); - word32 msgCmplen = sizeof(msgCmp); - - ExpectIntEQ(wc_InitShake256(&shake, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Shake256_Update(&shake, msg, msglen), 0); - ExpectIntEQ(XMEMCMP(msg, shake.t, msglen), 0); - ExpectTrue(shake.i == msglen); - - ExpectIntEQ(wc_Shake256_Update(&shake, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(shake.t, msgCmp, msgCmplen), 0); - - /* Pass bad args. */ - ExpectIntEQ(wc_Shake256_Update(NULL, msg2, msg2len), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Shake256_Update(&shake, NULL, 5), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_Shake256_Free(&shake); - - ExpectIntEQ(wc_InitShake256(&shake, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Shake256_Update(&shake, NULL, 0), 0); - ExpectIntEQ(wc_Shake256_Update(&shake, msg2, msg2len), 0); - ExpectIntEQ(XMEMCMP(msg2, shake.t, msg2len), 0); - wc_Shake256_Free(&shake); -#endif /* WOLFSSL_SHAKE256 */ + DIGEST_ALT_UPDATE_TEST(wc_Shake, Shake256); +#endif return EXPECT_RESULT(); } @@ -636,95 +1022,385 @@ int test_wc_Shake256_Final(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHAKE256 - wc_Shake shake; - const char* msg = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnom" - "nopnopq"; - const char* expOut = "\x4d\x8c\x2d\xd2\x43\x5a\x01\x28\xee\xfb\xb8\xc3\x6f" - "\x6f\x87\x13\x3a\x79\x11\xe1\x8d\x97\x9e\xe1\xae\x6b" - "\xe5\xd4\xfd\x2e\x33\x29\x40\xd8\x68\x8a\x4e\x6a\x59" - "\xaa\x80\x60\xf1\xf9\xbc\x99\x6c\x05\xac\xa3\xc6\x96" - "\xa8\xb6\x62\x79\xdc\x67\x2c\x74\x0b\xb2\x24\xec\x37" - "\xa9\x2b\x65\xdb\x05\x39\xc0\x20\x34\x55\xf5\x1d\x97" - "\xcc\xe4\xcf\xc4\x91\x27\xd7\x26\x0a\xfc\x67\x3a\xf2" - "\x08\xba\xf1\x9b\xe2\x12\x33\xf3\xde\xbe\x78\xd0\x67" - "\x60\xcf\xa5\x51\xee\x1e\x07\x91\x41\xd4"; - byte hash[114]; - - /* Init stack variables. */ - XMEMSET(hash, 0, sizeof(hash)); - - ExpectIntEQ(wc_InitShake256(&shake, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_Shake256_Update(&shake, (byte*)msg, (word32)XSTRLEN(msg)), - 0); - ExpectIntEQ(wc_Shake256_Final(&shake, hash, (word32)sizeof(hash)), 0); - ExpectIntEQ(XMEMCMP(expOut, hash, (word32)sizeof(hash)), 0); - - /* Test bad args. */ - ExpectIntEQ(wc_Shake256_Final(NULL, hash, (word32)sizeof(hash)), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Shake256_Final(&shake, NULL, (word32)sizeof(hash)), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + DIGEST_COUNT_FINAL_TEST(wc_Shake, Shake256, SHA3_256); +#endif + return EXPECT_RESULT(); +} - wc_Shake256_Free(&shake); +#define SHAKE256_KAT_CNT 7 +int test_wc_Shake256_KATs(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE256 + DIGEST_COUNT_KATS_TEST_VARS(wc_Shake, SHAKE256, SHA3_256); + + DIGEST_KATS_ADD("", 0, + "\x46\xb9\xdd\x2b\x0b\xa8\x8d\x13" + "\x23\x3b\x3f\xeb\x74\x3e\xeb\x24" + "\x3f\xcd\x52\xea\x62\xb8\x1b\x82" + "\xb5\x0c\x27\x64\x6e\xd5\x76\x2f" + "\xd7\x5d\xc4\xdd\xd8\xc0\xf2\x00" + "\xcb\x05\x01\x9d\x67\xb5\x92\xf6" + "\xfc\x82\x1c\x49\x47\x9a\xb4\x86" + "\x40\x29\x2e\xac\xb3\xb7\xc4\xbe" + "\x14\x1e\x96\x61\x6f\xb1\x39\x57" + "\x69\x2c\xc7\xed\xd0\xb4\x5a\xe3" + "\xdc\x07\x22\x3c\x8e\x92\x93\x7b" + "\xef\x84\xbc\x0e\xab\x86\x28\x53" + "\x34\x9e\xc7\x55\x46\xf5\x8f\xb7" + "\xc2\x77\x5c\x38\x46\x2c\x50\x10" + "\xd8\x46\xc1\x85\xc1\x51\x11\xe5" + "\x95\x52\x2a\x6b\xcd\x16\xcf\x86" + "\xf3\xd1\x22\x10\x9e\x3b\x1f\xdd"); + DIGEST_KATS_ADD("a", 1, + "\x86\x7e\x2c\xb0\x4f\x5a\x04\xdc" + "\xbd\x59\x25\x01\xa5\xe8\xfe\x9c" + "\xea\xaf\xca\x50\x25\x56\x26\xca" + "\x73\x6c\x13\x80\x42\x53\x0b\xa4" + "\x36\xb7\xb1\xec\x0e\x06\xa2\x79" + "\xbc\x79\x07\x33\xbb\x0a\xee\x6f" + "\xa8\x02\x68\x3c\x7b\x35\x50\x63" + "\xc4\x34\xe9\x11\x89\xb0\xc6\x51" + "\xd0\x92\xb0\x1e\x55\xce\x4d\x61" + "\x0b\x54\xa5\x46\x6d\x02\xf8\x8f" + "\xc3\x78\x09\x6f\xb0\xda\xd0\x25" + "\x48\x57\xfe\x1e\x63\x81\xab\xc0" + "\x4e\x07\xe3\x3d\x91\x69\x35\x93" + "\x56\x36\x00\x48\x96\xc5\xb1\x25" + "\x34\x64\xf1\xcb\x5e\xa7\x3b\x00" + "\x7b\xc5\x02\x8b\xbb\xea\x13\xeb" + "\xc2\x86\x68\xdb\xfc\x26\xb1\x24"); + DIGEST_KATS_ADD("abc", 3, + "\x48\x33\x66\x60\x13\x60\xa8\x77" + "\x1c\x68\x63\x08\x0c\xc4\x11\x4d" + "\x8d\xb4\x45\x30\xf8\xf1\xe1\xee" + "\x4f\x94\xea\x37\xe7\x8b\x57\x39" + "\xd5\xa1\x5b\xef\x18\x6a\x53\x86" + "\xc7\x57\x44\xc0\x52\x7e\x1f\xaa" + "\x9f\x87\x26\xe4\x62\xa1\x2a\x4f" + "\xeb\x06\xbd\x88\x01\xe7\x51\xe4" + "\x13\x85\x14\x12\x04\xf3\x29\x97" + "\x9f\xd3\x04\x7a\x13\xc5\x65\x77" + "\x24\xad\xa6\x4d\x24\x70\x15\x7b" + "\x3c\xdc\x28\x86\x20\x94\x4d\x78" + "\xdb\xcd\xdb\xd9\x12\x99\x3f\x09" + "\x13\xf1\x64\xfb\x2c\xe9\x51\x31" + "\xa2\xd0\x9a\x3e\x6d\x51\xcb\xfc" + "\x62\x27\x20\xd7\xa7\x5c\x63\x34" + "\xe8\xa2\xd7\xec\x71\xa7\xcc\x29"); + DIGEST_KATS_ADD("message digest", 14, + "\x71\x8e\x22\x40\x88\x85\x68\x40" + "\xad\xe4\xdc\x73\x48\x7e\x15\x82" + "\x6a\x07\xec\xb8\xed\x5e\x2b\xda" + "\x52\x6c\xc1\xac\xdd\xb9\x9d\x00" + "\x60\x49\x81\x58\x44\xbe\x0c\x6c" + "\x29\xb7\x59\xdb\x80\xb7\xda\xa6" + "\x84\xcb\x46\xd9\x0f\x7e\xef\x10" + "\x7d\x24\xaa\xfc\xfa\xf0\xda\xca" + "\xca\x28\x88\xdf\xaa\x73\x76\x94" + "\xbc\x46\xd5\xc9\x5f\x17\xc5\xcf" + "\xe7\xb0\xc9\x5c\xfd\x6a\x12\x6d" + "\xd9\x64\x0c\x8e\x62\xe5\xad\x1c" + "\x06\xe5\x75\x61\x6a\x2d\xec\x06" + "\x46\x06\x6e\x80\x37\xe5\x1a\x00" + "\x54\x78\x3d\x82\x0b\x92\xc1\x14" + "\x17\x96\xf7\xc3\xe9\x35\x03\x8e" + "\x67\x13\xbb\xba\x46\x08\x0b\x2e"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xb7\xb7\x8b\x04\xa3\xdd\x30\xa2" + "\x65\xc8\x88\x6c\x33\xfd\xa9\x47" + "\x99\x85\x3d\xe5\xd3\xd1\x05\x41" + "\xfd\x4e\x9f\x46\x13\x70\x1c\x61" + "\x07\x52\x49\xbe\xd1\x6b\x07\x81" + "\x10\x8f\xcf\xe0\x86\xdb\xf3\x8a" + "\x7f\xb8\x30\x08\x07\xce\xa8\x5c" + "\xc6\x49\x32\x8d\x07\xd4\xff\x2b" + "\x5e\x89\x08\x56\x3f\xf0\xfd\xcc" + "\x06\xa8\x09\x2f\xbf\xe7\x72\xf8" + "\x0e\x49\xf8\x7a\x10\x3b\x2a\xee" + "\x12\x99\x0c\xcb\x47\x98\xe9\xec" + "\x03\xaa\x48\x18\xa4\xbf\x5a\xbd" + "\xa0\x84\xe1\xa5\xfe\x68\x7c\x2c" + "\xfe\xf4\x40\x68\x46\xfe\x47\xa0" + "\xd0\x7b\xf4\x50\x55\xa2\x69\x9c" + "\x37\xd6\xb6\xd9\xcd\x6c\x4f\xf0"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\x31\xf1\x9a\x09\x7c\x72\x3e\x91" + "\xfa\x59\xb0\x99\x8d\xd8\x52\x3c" + "\x2a\x9e\x7e\x13\xb4\x02\x5d\x6b" + "\x48\xfc\xbc\x32\x89\x73\xa1\x08" + "\x78\xcf\xbe\xb3\x81\x0d\x88\x2f" + "\xdb\x6a\x06\xe8\x7f\x3e\xa5\x2c" + "\xf8\x26\xca\x55\x22\x31\x6f\xb6" + "\x45\xb7\x08\xac\xbe\x43\xb2\xcb" + "\x32\x52\x09\x24\x32\x42\x70\x60" + "\xc9\x63\x9e\x21\xa8\x98\xd3\x88" + "\xa7\xe1\x53\xe4\x2a\x8b\x89\x33" + "\xf2\xad\x0c\x27\x52\x97\x69\x8e" + "\x25\x7e\x05\xd2\x62\x75\x39\xb4" + "\x2c\x10\x1b\x97\x67\xbc\x6d\x90" + "\x06\x39\x31\x1f\x8e\x4a\x2e\x88" + "\x26\x7b\xbb\x85\xb3\xfa\x4e\xad" + "\xf4\x01\xe0\x74\x18\x9f\x6b\xbf"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x24\xc5\x08\xad\xef\xdf\x5e\x3f" + "\x25\x96\xe8\xb5\xa8\x88\xfe\x10" + "\xeb\x7b\x5b\x22\xe1\xf3\x5d\x85" + "\x8e\x6e\xff\x30\x25\xc4\xcc\x18" + "\xa3\xc9\xac\xe5\x1d\xdd\x24\x3d" + "\x08\xc8\xc7\x0c\xf6\x8e\x91\xd1" + "\x70\x60\x3d\xc3\xe2\xa3\x1c\x6c" + "\xa8\x9f\x20\xc4\xa5\x95\xa2\x65" + "\x4f\xb7\xd5\x35\x29\x42\x7e\x81" + "\x2d\xea\x48\xe8\xe8\x9a\xbe\x06" + "\x2b\x88\x90\x2f\x9b\xff\xb5\xee" + "\xf2\x8a\x65\x80\xfb\x24\x1a\x15" + "\x20\x1f\x18\xf5\x29\x9d\x03\xc3" + "\xe7\x17\x3d\x41\x43\x88\x68\x80" + "\xe4\xfb\x0b\xe1\xf5\x03\xeb\x4a" + "\x10\x9a\xf6\xf9\xe9\x7f\xa8\xdc" + "\x2e\xe6\x42\xe3\xc9\x18\x1b\x85"); + + DIGEST_COUNT_KATS_TEST(Shake256, SHAKE256, SHA3_256); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Shake256_other(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE256 + DIGEST_COUNT_OTHER_TEST(wc_Shake, Shake256, SHA3_256, + "\x97\x52\xa7\xbe\xe4\x06\x06\x10" + "\xb2\x43\xb5\xca\x1e\x3a\x76\x06" + "\x68\xac\x62\xfe\xad\xa4\xad\xc9" + "\x23\xa2\x72\xeb\x90\x54\xeb\xd9" + "\x06\x7f\x1e\xea\x2d\x80\x92\xb2" + "\xd1\xe7\xae\x6b\xc0\x1d\x46\x6a" + "\x3f\x62\x67\x35\x7b\x50\x4b\xe2" + "\x05\x63\xf7\x97\x10\x4e\x9c\x14" + "\xff\x21\x64\x40\xf6\xd4\x55\x79" + "\x2e\x7b\x9b\x5b\xfb\xa2\x15\xf9" + "\x6d\x6a\x54\xae\x5e\x7d\x6c\x72" + "\x4a\x4e\x91\xcc\xc2\x37\x1c\x9d" + "\x14\x95\x27\x38\x64\x6c\x62\x10" + "\x19\x04\x6f\x19\xde\x61\x5e\xc8" + "\x6d\xd2\xcc\x5b\xf4\xe0\xf2\x54" + "\x0f\xe9\x2a\xe7\x0a\x7d\xb0\x55" + "\x8a\x74\x83\x49\xf0\x2a\x6e\xa9"); #endif return EXPECT_RESULT(); } -/* - * Testing wc_Shake256_Copy() - */ int test_wc_Shake256_Copy(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHAKE256 - wc_Shake shake, shakeCpy; - const char* msg = TEST_STRING; - word32 msglen = (word32)TEST_STRING_SZ; - byte hash[144]; - byte hashCpy[144]; + DIGEST_COUNT_COPY_TEST(wc_Shake, Shake256, SHA3_256, + "\x46\xb9\xdd\x2b\x0b\xa8\x8d\x13" + "\x23\x3b\x3f\xeb\x74\x3e\xeb\x24" + "\x3f\xcd\x52\xea\x62\xb8\x1b\x82" + "\xb5\x0c\x27\x64\x6e\xd5\x76\x2f" + "\xd7\x5d\xc4\xdd\xd8\xc0\xf2\x00" + "\xcb\x05\x01\x9d\x67\xb5\x92\xf6" + "\xfc\x82\x1c\x49\x47\x9a\xb4\x86" + "\x40\x29\x2e\xac\xb3\xb7\xc4\xbe" + "\x14\x1e\x96\x61\x6f\xb1\x39\x57" + "\x69\x2c\xc7\xed\xd0\xb4\x5a\xe3" + "\xdc\x07\x22\x3c\x8e\x92\x93\x7b" + "\xef\x84\xbc\x0e\xab\x86\x28\x53" + "\x34\x9e\xc7\x55\x46\xf5\x8f\xb7" + "\xc2\x77\x5c\x38\x46\x2c\x50\x10" + "\xd8\x46\xc1\x85\xc1\x51\x11\xe5" + "\x95\x52\x2a\x6b\xcd\x16\xcf\x86" + "\xf3\xd1\x22\x10\x9e\x3b\x1f\xdd", + "\x48\x33\x66\x60\x13\x60\xa8\x77" + "\x1c\x68\x63\x08\x0c\xc4\x11\x4d" + "\x8d\xb4\x45\x30\xf8\xf1\xe1\xee" + "\x4f\x94\xea\x37\xe7\x8b\x57\x39" + "\xd5\xa1\x5b\xef\x18\x6a\x53\x86" + "\xc7\x57\x44\xc0\x52\x7e\x1f\xaa" + "\x9f\x87\x26\xe4\x62\xa1\x2a\x4f" + "\xeb\x06\xbd\x88\x01\xe7\x51\xe4" + "\x13\x85\x14\x12\x04\xf3\x29\x97" + "\x9f\xd3\x04\x7a\x13\xc5\x65\x77" + "\x24\xad\xa6\x4d\x24\x70\x15\x7b" + "\x3c\xdc\x28\x86\x20\x94\x4d\x78" + "\xdb\xcd\xdb\xd9\x12\x99\x3f\x09" + "\x13\xf1\x64\xfb\x2c\xe9\x51\x31" + "\xa2\xd0\x9a\x3e\x6d\x51\xcb\xfc" + "\x62\x27\x20\xd7\xa7\x5c\x63\x34" + "\xe8\xa2\xd7\xec\x71\xa7\xcc\x29"); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Shake256Hash(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE256 + const byte data[] = { /* Hello World */ + 0x48,0x65,0x6c,0x6c,0x6f,0x20,0x57,0x6f, + 0x72,0x6c,0x64 + }; + word32 len = sizeof(data); + byte hash[WC_SHA3_256_COUNT * 8]; word32 hashLen = sizeof(hash); - word32 hashLenCpy = sizeof(hashCpy); + const char* expHash = + "\x84\x0d\x1c\xe8\x1a\x43\x27\x84" + "\x0b\x54\xcb\x1d\x41\x99\x07\xfd" + "\x1f\x62\x35\x9b\xad\x33\x65\x6e" + "\x05\x86\x53\xd2\xe4\x17\x2a\x43" + "\xac\xc9\x58\xdb\xec\x0c\xf0\xd4" + "\x73\xdb\x45\x8c\xe1\xc0\x07\xaa" + "\x6e\xb4\x0e\xac\x92\xaa\x0e\x65" + "\x20\x2e\xdb\x4d\x7f\xee\xd3\x78" + "\x8a\x77\xed\x6a\x6d\xdc\x5a\xbf" + "\xbf\xbf\xf7\x2f\x22\xf4\x9e\x66" + "\x7e\x45\x03\x2c\x1e\xe8\xcf\xb0" + "\x79\xf8\x08\x9b\x43\xd1\x6a\xe6" + "\xe5\x8f\x06\x3a\x4d\x93\xef\x36" + "\x99\xb3\x2b\x9d\x00\xb3\x3c\x37" + "\x2c\x10\xa4\x8d\x72\xf6\x4d\xa0" + "\x25\x97\xf4\xfa\x23\xd5\x89\x0a" + "\x4d\x65\x0a\xcb\x7b\xf8\xd2\x36"; - XMEMSET(hash, 0, sizeof(hash)); - XMEMSET(hashCpy, 0, sizeof(hashCpy)); + ExpectIntEQ(wc_Shake256Hash(data, len, hash, hashLen), 0); + ExpectBufEQ(hash, expHash, hashLen); +#endif + return EXPECT_RESULT(); +} /* END test_wc_Shake256Hash */ - ExpectIntEQ(wc_InitShake256(&shake, HEAP_HINT, testDevId), 0); - ExpectIntEQ(wc_InitShake256(&shakeCpy, HEAP_HINT, testDevId), 0); +int test_wc_Shake256_Absorb(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE256 + wc_Shake shake256; - ExpectIntEQ(wc_Shake256_Update(&shake, (byte*)msg, msglen), 0); - ExpectIntEQ(wc_Shake256_Copy(&shakeCpy, &shake), 0); - ExpectIntEQ(wc_Shake256_Final(&shake, hash, hashLen), 0); - ExpectIntEQ(wc_Shake256_Final(&shakeCpy, hashCpy, hashLenCpy), 0); - ExpectIntEQ(XMEMCMP(hash, hashCpy, sizeof(hash)), 0); + ExpectIntEQ(wc_InitShake256(&shake256, HEAP_HINT, INVALID_DEVID), 0); - /* Test bad args. */ - ExpectIntEQ(wc_Shake256_Copy(NULL, &shake), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Shake256_Copy(&shakeCpy, NULL), + ExpectIntEQ(wc_Shake256_Absorb(NULL , NULL , 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake256_Absorb(&shake256, NULL , 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake256_Absorb(NULL , NULL , 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectIntEQ(wc_Shake256_Absorb(&shake256, NULL, 0), 0); + ExpectIntEQ(wc_Shake256_Absorb(&shake256, (byte*)"a", 1), 0); - wc_Shake256_Free(&shake); - wc_Shake256_Free(&shakeCpy); + wc_Shake256_Free(&shake256); #endif return EXPECT_RESULT(); -} /* END test_wc_Shake256_Copy */ +} -/* - * Unit test function for wc_Shake256Hash() - */ -int test_wc_Shake256Hash(void) +int test_wc_Shake256_SqueezeBlocks(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHAKE256 - const byte data[] = { /* Hello World */ - 0x48,0x65,0x6c,0x6c,0x6f,0x20,0x57,0x6f, - 0x72,0x6c,0x64 - }; - word32 len = sizeof(data); - byte hash[144]; - word32 hashLen = sizeof(hash); + wc_Shake shake256; + byte hash[WC_SHA3_256_COUNT * 8]; - ExpectIntEQ(wc_Shake256Hash(data, len, hash, hashLen), 0); + ExpectIntEQ(wc_InitShake256(&shake256, HEAP_HINT, INVALID_DEVID), 0); + + ExpectIntEQ(wc_Shake256_SqueezeBlocks(NULL , NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Shake256_SqueezeBlocks(NULL , NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, NULL, 0), 0); + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, hash, 1), 0); + + wc_Shake256_Free(&shake256); #endif return EXPECT_RESULT(); -} /* END test_wc_Shake256Hash */ +} + +#define TEST_SHAKE256_MAX_BLOCKS 3 +int test_wc_Shake256_XOF(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SHAKE256 + wc_Shake shake256; + byte hash[WC_SHA3_256_COUNT * 8 * TEST_SHAKE256_MAX_BLOCKS]; + const char* expOut = + "\x26\x16\x27\x51\x34\xae\xba\x85" + "\x2e\x81\x43\x9a\x50\x72\x03\xd8" + "\x1c\x58\x2b\x87\xb5\x89\x3a\x45" + "\x66\xfe\x0e\x5a\xde\x60\x8e\xca" + "\x2e\x27\x87\x25\x08\x0f\x13\x0e" + "\x4e\x82\xb0\x6a\x4b\xe0\xca\x79" + "\xcc\x55\xd8\x3f\xb4\x36\x74\x18" + "\x5d\x2d\xb9\xa7\x95\x25\x6b\x44" + "\x70\xc5\xa0\xa5\x21\x7e\x88\xed" + "\x70\x67\x71\x57\x61\xb2\x3c\xb8" + "\x89\x0f\x43\x28\x8a\xa9\xf1\x29" + "\x4c\x71\x33\xe7\x96\x4e\x8b\x58" + "\x7c\x16\x12\xed\xac\x10\xfb\xc8" + "\xf8\xd2\x1f\xa3\x12\x29\x34\xb2" + "\xf1\xaa\xcd\x4a\x10\x7a\xd1\x68" + "\x00\xc1\xb2\xb8\x4b\xb2\xe5\x8a" + "\xa3\xa0\xda\x73\x15\x3e\xb4\x50" + "\x70\x3a\x3c\x7f\x8d\xd7\xa8\xfc" + "\x03\x63\x0f\x80\x15\xd7\x05\x4f" + "\x48\x42\x52\x12\x4f\xa1\x87\x85" + "\xb9\xa4\x9b\x04\x17\xdb\x9f\x62" + "\x9a\xbb\x07\x40\x56\x6c\xb0\xb9" + "\x20\xf1\x85\x18\x36\x4f\x2e\x71" + "\x16\x7d\xc0\xed\xb3\x89\x22\x3c" + "\x93\xbd\xee\x71\x36\x59\x25\x7b" + "\xae\x3c\x8b\x4b\xa8\xac\x63\xef" + "\xd5\xfe\x6c\x07\x6b\xb9\x3b\x41" + "\x8f\x30\x6d\xee\x7b\x1d\xfc\x6c" + "\xda\x21\x1f\xaa\x63\x72\xc6\xf1" + "\x51\x27\xce\xdc\x6b\xb2\x84\x7c" + "\x79\x3b\xa3\xaf\xf0\xb7\x2d\xd8" + "\x6e\xd9\xc5\x2e\x5e\x48\x42\xbc" + "\xc3\xe5\x3a\xee\x82\x6c\x90\x21" + "\xc9\x17\x9e\x17\x2c\x30\x11\x34" + "\x0a\x53\x33\x93\x47\xca\x7d\x9e" + "\x4e\xb4\xea\x70\xb7\x58\x39\xc2" + "\x3c\x29\x6c\x9d\x75\x45\x88\x3d" + "\x68\x5c\x1c\x6a\x52\x56\x6c\xe5" + "\x28\x51\xf1\x64\xce\x0b\x45\x66" + "\x7a\xc4\xb7\x42\x08\x39\x00\x17" + "\xbe\x55\xd2\xda\x05\x5e\x70\xc3" + "\xdc\x65\x36\x0b\xa9\x49\x95\xce" + "\x8a\x04\x04\x4e\xb2\xff\xfa\x31" + "\x07\x09\x5d\xe4\xa8\x04\x10\xf2" + "\x84\x3c\x5d\xf4\x99\x5d\x75\x23" + "\x03\x66\xed\xac\x07\xbb\x89\x61" + "\xd6\xd0\x5f\x19\xd2\x2f\x1c\xd7" + "\x73\x4d\x92\x12\x85\x07\x9c\x38" + "\xd2\x50\x6e\xe5\xe8\x15\x6c\xf6" + "\xde\x66\x9a\x10\x6f\xa1\xaf\x20" + "\x99\x1d\xc0\xe6\xdc\xeb\xbc\x74"; + int i; + int j; + + for (i = 1; i <= TEST_SHAKE256_MAX_BLOCKS; i++) { + ExpectIntEQ(wc_InitShake256(&shake256, HEAP_HINT, INVALID_DEVID), 0); + + ExpectIntEQ(wc_Shake256_Absorb(&shake256, (byte*)"Starting point", 15), + 0); + + for (j = 0; j < TEST_SHAKE256_MAX_BLOCKS; j += i) { + int cnt = TEST_SHAKE256_MAX_BLOCKS - j; + if (i < cnt) + cnt = i; + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, + hash + WC_SHA3_256_COUNT * 8 * j, cnt), 0); + } + ExpectBufEQ(hash, expOut, + WC_SHA3_256_COUNT * 8 * TEST_SHAKE256_MAX_BLOCKS); + } + + wc_Shake256_Free(&shake256); +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_sha3.h b/tests/api/test_sha3.h index 2da1fba7da..f4692f5c40 100644 --- a/tests/api/test_sha3.h +++ b/tests/api/test_sha3.h @@ -24,20 +24,36 @@ int test_wc_InitSha3(void); int test_wc_Sha3_Update(void); -int test_wc_Sha3_224_Final(void); -int test_wc_Sha3_256_Final(void); -int test_wc_Sha3_384_Final(void); -int test_wc_Sha3_512_Final(void); -int test_wc_Sha3_224_Copy(void); -int test_wc_Sha3_256_Copy(void); -int test_wc_Sha3_384_Copy(void); -int test_wc_Sha3_512_Copy(void); -int test_wc_Sha3_GetFlags(void); +int test_wc_Sha3_Final(void); +int test_wc_Sha3_224_KATs(void); +int test_wc_Sha3_256_KATs(void); +int test_wc_Sha3_384_KATs(void); +int test_wc_Sha3_512_KATs(void); +int test_wc_Sha3_other(void); +int test_wc_Sha3_Copy(void); +int test_wc_Sha3_GetHash(void); +int test_wc_Sha3_Flags(void); + +int test_wc_InitShake128(void); +int test_wc_Shake128_Update(void); +int test_wc_Shake128_Final(void); +int test_wc_Shake128_KATs(void); +int test_wc_Shake128_other(void); +int test_wc_Shake128_Copy(void); +int test_wc_Shake128Hash(void); +int test_wc_Shake128_Absorb(void); +int test_wc_Shake128_SqueezeBlocks(void); +int test_wc_Shake128_XOF(void); int test_wc_InitShake256(void); int test_wc_Shake256_Update(void); int test_wc_Shake256_Final(void); +int test_wc_Shake256_KATs(void); +int test_wc_Shake256_other(void); int test_wc_Shake256_Copy(void); int test_wc_Shake256Hash(void); +int test_wc_Shake256_Absorb(void); +int test_wc_Shake256_SqueezeBlocks(void); +int test_wc_Shake256_XOF(void); #endif /* WOLFCRYPT_TEST_SHA3_H */ diff --git a/tests/api/test_sha512.c b/tests/api/test_sha512.c index df16026488..3148e29b1d 100644 --- a/tests/api/test_sha512.c +++ b/tests/api/test_sha512.c @@ -40,570 +40,456 @@ #include #include #include +#include /******************************************************************************* * SHA-512 ******************************************************************************/ /* - * Testing wc_InitSha512() + * Unit test for the wc_InitSha512() */ int test_wc_InitSha512(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA512 - wc_Sha512 sha512; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha512(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha512, Sha512); #endif return EXPECT_RESULT(); } /* END test_wc_InitSha512 */ - /* - * wc_Sha512Update() test. + * Tesing wc_Sha512Update() */ int test_wc_Sha512Update(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA512 - wc_Sha512 sha512; - byte hash[WC_SHA512_DIGEST_SIZE]; - byte hash_unaligned[WC_SHA512_DIGEST_SIZE + 1]; - testVector a, b, c; - - ExpectIntEQ(wc_InitSha512(&sha512), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha512Update(&sha512, NULL, 0), 0); - ExpectIntEQ(wc_Sha512Update(&sha512,(byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha512Update(&sha512, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha512Final(&sha512, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\xdd\xaf\x35\xa1\x93\x61\x7a\xba\xcc\x41\x73\x49\xae\x20\x41" - "\x31\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2\x0a\x9e\xee\xe6\x4b" - "\x55\xd3\x9a\x21\x92\x99\x2a\x27\x4f\xc1\xa8\x36\xba\x3c" - "\x23\xa3\xfe\xeb\xbd\x45\x4d\x44\x23\x64\x3c\xe8\x0e\x2a" - "\x9a\xc9\x4f\xa5\x4c\xa4\x9f"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha512Update(&sha512, (byte*) a.input, (word32) a.inLen), 0); - ExpectIntEQ(wc_Sha512Final(&sha512, hash), 0); - - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA512_DIGEST_SIZE), 0); - - /* Unaligned check. */ - ExpectIntEQ(wc_Sha512Update(&sha512, (byte*)a.input+1, (word32)a.inLen-1), - 0); - ExpectIntEQ(wc_Sha512Final(&sha512, hash_unaligned+1), 0); - - /* Try passing in bad values */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_Sha512Update(&sha512, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_SHA512_DIGEST_SIZE; - ExpectIntEQ(wc_Sha512Update(&sha512, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); -#endif - return EXPECT_RESULT(); - -} /* END test_wc_Sha512Update */ - -#ifdef WOLFSSL_SHA512 -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - (!defined(WOLFSSL_NOSHA512_224) || !defined(WOLFSSL_NOSHA512_256)) -/* Performs test for - * - wc_Sha512Final/wc_Sha512FinalRaw - * - wc_Sha512_224Final/wc_Sha512_224Final - * - wc_Sha512_256Final/wc_Sha512_256Final - * parameter: - * - type : must be one of WC_HASH_TYPE_SHA512, WC_HASH_TYPE_SHA512_224 or - * WC_HASH_TYPE_SHA512_256 - * - isRaw: if is non-zero, xxxFinalRaw function will be tested - *return 0 on success - */ -static int test_Sha512_Family_Final(int type, int isRaw) -{ - EXPECT_DECLS; - wc_Sha512 sha512; - byte* hash_test[3]; - byte hash1[WC_SHA512_DIGEST_SIZE]; - byte hash2[2*WC_SHA512_DIGEST_SIZE]; - byte hash3[5*WC_SHA512_DIGEST_SIZE]; - int times, i; - - int(*initFp)(wc_Sha512*); - int(*finalFp)(wc_Sha512*, byte*); - void(*freeFp)(wc_Sha512*); - - if (type == WC_HASH_TYPE_SHA512) { - initFp = wc_InitSha512; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - !defined(WOLFSSL_NO_HASH_RAW) - finalFp = (isRaw)? wc_Sha512FinalRaw : wc_Sha512Final; -#else - finalFp = (isRaw)? NULL : wc_Sha512Final; -#endif - freeFp = wc_Sha512Free; - } -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if !defined(WOLFSSL_NOSHA512_224) - else if (type == WC_HASH_TYPE_SHA512_224) { - initFp = wc_InitSha512_224; - #if !defined(WOLFSSL_NO_HASH_RAW) - finalFp = (isRaw)? wc_Sha512_224FinalRaw : wc_Sha512_224Final; - #else - finalFp = (isRaw)? NULL : wc_Sha512_224Final; - #endif - freeFp = wc_Sha512_224Free; - } -#endif -#if !defined(WOLFSSL_NOSHA512_256) - else if (type == WC_HASH_TYPE_SHA512_256) { - initFp = wc_InitSha512_256; - #if !defined(WOLFSSL_NO_HASH_RAW) - finalFp = (isRaw)? wc_Sha512_256FinalRaw : wc_Sha512_256Final; - #else - finalFp = (isRaw)? NULL : wc_Sha512_256Final; - #endif - freeFp = wc_Sha512_256Free; - } -#endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ - else - return TEST_FAIL; - - /* Initialize */ - ExpectIntEQ(initFp(&sha512), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte *); - -#if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) || \ - defined(WOLFSSL_NO_HASH_RAW) - if (finalFp != NULL) -#endif - { - /* Good test args. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(finalFp(&sha512, hash_test[i]), 0); - } - /* Test bad args. */ - ExpectIntEQ(finalFp(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(finalFp(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(finalFp(&sha512, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - } - - freeFp(&sha512); - + DIGEST_UPDATE_TEST(wc_Sha512, Sha512); +#endif return EXPECT_RESULT(); -} -#endif /* !HAVE_FIPS && !HAVE_SELFTEST && - (!WOLFSSL_NOSHA512_224 || !WOLFSSL_NOSHA512_256) */ -#endif /* WOLFSSL_SHA512 */ +} /* END test_wc_Sha512Update() */ + /* - * Unit test function for wc_Sha512Final() + * Unit test on wc_Sha512Final */ int test_wc_Sha512Final(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA512 - wc_Sha512 sha512; - byte* hash_test[3]; - byte hash1[WC_SHA512_DIGEST_SIZE]; - byte hash2[2*WC_SHA512_DIGEST_SIZE]; - byte hash3[5*WC_SHA512_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte *); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha512Final(&sha512, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha512Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512Final(&sha512, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); + DIGEST_FINAL_TEST(wc_Sha512, Sha512, SHA512); #endif return EXPECT_RESULT(); } /* END test_wc_Sha512Final */ + /* - * Unit test function for wc_Sha512FinalRaw() + * Unit test on wc_Sha512FinalRaw */ int test_wc_Sha512FinalRaw(void) { EXPECT_DECLS; -#if (defined(WOLFSSL_SHA512) && !defined(HAVE_SELFTEST) && \ - (!defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \ - (HAVE_FIPS_VERSION >= 3)))) && \ +#if defined(WOLFSSL_SHA512) && !defined(HAVE_SELFTEST) && \ + !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ !defined(WOLFSSL_NO_HASH_RAW) - wc_Sha512 sha512; - byte* hash_test[3]; - byte hash1[WC_SHA512_DIGEST_SIZE]; - byte hash2[2*WC_SHA512_DIGEST_SIZE]; - byte hash3[5*WC_SHA512_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - /* Good test args. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha512FinalRaw(&sha512, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha512FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512FinalRaw(&sha512, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); + DIGEST_FINAL_RAW_TEST(wc_Sha512, Sha512, SHA512, + "\x6a\x09\xe6\x67\xf3\xbc\xc9\x08" + "\xbb\x67\xae\x85\x84\xca\xa7\x3b" + "\x3c\x6e\xf3\x72\xfe\x94\xf8\x2b" + "\xa5\x4f\xf5\x3a\x5f\x1d\x36\xf1" + "\x51\x0e\x52\x7f\xad\xe6\x82\xd1" + "\x9b\x05\x68\x8c\x2b\x3e\x6c\x1f" + "\x1f\x83\xd9\xab\xfb\x41\xbd\x6b" + "\x5b\xe0\xcd\x19\x13\x7e\x21\x79"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha512FinalRaw */ +} /* END test_wc_Sha512Final */ -/* - * Unit test function for wc_Sha512GetFlags() - */ -int test_wc_Sha512GetFlags(void) +#define SHA512_KAT_CNT 7 +int test_wc_Sha512_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha512 sha512; - word32 flags = 0; - - /* Initialize */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - - ExpectIntEQ(wc_Sha512GetFlags(&sha512, &flags), 0); - ExpectIntEQ((flags & WC_HASH_FLAG_ISCOPY), 0); - - wc_Sha512Free(&sha512); +#ifdef WOLFSSL_SHA512 + DIGEST_KATS_TEST_VARS(wc_Sha512, SHA512); + + DIGEST_KATS_ADD("", 0, + "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd" + "\xf1\x54\x28\x50\xd6\x6d\x80\x07" + "\xd6\x20\xe4\x05\x0b\x57\x15\xdc" + "\x83\xf4\xa9\x21\xd3\x6c\xe9\xce" + "\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0" + "\xff\x83\x18\xd2\x87\x7e\xec\x2f" + "\x63\xb9\x31\xbd\x47\x41\x7a\x81" + "\xa5\x38\x32\x7a\xf9\x27\xda\x3e"); + DIGEST_KATS_ADD("a", 1, + "\x1f\x40\xfc\x92\xda\x24\x16\x94" + "\x75\x09\x79\xee\x6c\xf5\x82\xf2" + "\xd5\xd7\xd2\x8e\x18\x33\x5d\xe0" + "\x5a\xbc\x54\xd0\x56\x0e\x0f\x53" + "\x02\x86\x0c\x65\x2b\xf0\x8d\x56" + "\x02\x52\xaa\x5e\x74\x21\x05\x46" + "\xf3\x69\xfb\xbb\xce\x8c\x12\xcf" + "\xc7\x95\x7b\x26\x52\xfe\x9a\x75"); + DIGEST_KATS_ADD("abc", 3, + "\xdd\xaf\x35\xa1\x93\x61\x7a\xba" + "\xcc\x41\x73\x49\xae\x20\x41\x31" + "\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2" + "\x0a\x9e\xee\xe6\x4b\x55\xd3\x9a" + "\x21\x92\x99\x2a\x27\x4f\xc1\xa8" + "\x36\xba\x3c\x23\xa3\xfe\xeb\xbd" + "\x45\x4d\x44\x23\x64\x3c\xe8\x0e" + "\x2a\x9a\xc9\x4f\xa5\x4c\xa4\x9f"); + DIGEST_KATS_ADD("message digest", 14, + "\x10\x7d\xbf\x38\x9d\x9e\x9f\x71" + "\xa3\xa9\x5f\x6c\x05\x5b\x92\x51" + "\xbc\x52\x68\xc2\xbe\x16\xd6\xc1" + "\x34\x92\xea\x45\xb0\x19\x9f\x33" + "\x09\xe1\x64\x55\xab\x1e\x96\x11" + "\x8e\x8a\x90\x5d\x55\x97\xb7\x20" + "\x38\xdd\xb3\x72\xa8\x98\x26\x04" + "\x6d\xe6\x66\x87\xbb\x42\x0e\x7c"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\x4d\xbf\xf8\x6c\xc2\xca\x1b\xae" + "\x1e\x16\x46\x8a\x05\xcb\x98\x81" + "\xc9\x7f\x17\x53\xbc\xe3\x61\x90" + "\x34\x89\x8f\xaa\x1a\xab\xe4\x29" + "\x95\x5a\x1b\xf8\xec\x48\x3d\x74" + "\x21\xfe\x3c\x16\x46\x61\x3a\x59" + "\xed\x54\x41\xfb\x0f\x32\x13\x89" + "\xf7\x7f\x48\xa8\x79\xc7\xb1\xf1"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\x1e\x07\xbe\x23\xc2\x6a\x86\xea" + "\x37\xea\x81\x0c\x8e\xc7\x80\x93" + "\x52\x51\x5a\x97\x0e\x92\x53\xc2" + "\x6f\x53\x6c\xfc\x7a\x99\x96\xc4" + "\x5c\x83\x70\x58\x3e\x0a\x78\xfa" + "\x4a\x90\x04\x1d\x71\xa4\xce\xab" + "\x74\x23\xf1\x9c\x71\xb9\xd5\xa3" + "\xe0\x12\x49\xf0\xbe\xbd\x58\x94"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x72\xec\x1e\xf1\x12\x4a\x45\xb0" + "\x47\xe8\xb7\xc7\x5a\x93\x21\x95" + "\x13\x5b\xb6\x1d\xe2\x4e\xc0\xd1" + "\x91\x40\x42\x24\x6e\x0a\xec\x3a" + "\x23\x54\xe0\x93\xd7\x6f\x30\x48" + "\xb4\x56\x76\x43\x46\x90\x0c\xb1" + "\x30\xd2\xa4\xfd\x5d\xd1\x6a\xbb" + "\x5e\x30\xbc\xb8\x50\xde\xe8\x43"); + + DIGEST_KATS_TEST(Sha512, SHA512); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha512GetFlags */ +} /* END test_wc_Sha512Final */ -/* - * Unit test function for wc_Sha512Free() - */ -int test_wc_Sha512Free(void) +int test_wc_Sha512_other(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA512 - wc_Sha512Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_OTHER_TEST(wc_Sha512, Sha512, SHA512, + "\xf2\x7d\xa3\xe0\x25\x71\x51\x3f" + "\x75\xf4\xdc\xea\xdc\xf7\x7f\xf1" + "\xad\x5a\x51\x32\x07\x73\x1d\xf8" + "\xdd\xaa\xf1\x15\x3e\xa3\x3c\xc5" + "\x00\x76\x6e\x1d\xa5\xa2\x4a\x44" + "\x99\x3e\x2d\xaa\xa8\x05\xc8\x49" + "\xf0\x83\x34\x02\x07\x43\x8b\xac" + "\xfb\xe6\x02\x40\x6b\x48\x54\x8e"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha512Free */ -#ifdef WOLFSSL_SHA512 +} /* END test_wc_Sha512Final */ -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - (!defined(WOLFSSL_NOSHA512_224) || !defined(WOLFSSL_NOSHA512_256)) -static int test_Sha512_Family_GetHash(int type ) +int test_wc_Sha512Copy(void) { EXPECT_DECLS; - int(*initFp)(wc_Sha512*); - int(*ghashFp)(wc_Sha512*, byte*); - wc_Sha512 sha512; - byte hash1[WC_SHA512_DIGEST_SIZE]; - - if (type == WC_HASH_TYPE_SHA512) { - initFp = wc_InitSha512; - ghashFp = wc_Sha512GetHash; - } -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if !defined(WOLFSSL_NOSHA512_224) - else if (type == WC_HASH_TYPE_SHA512_224) { - initFp = wc_InitSha512_224; - ghashFp = wc_Sha512_224GetHash; - } -#endif -#if !defined(WOLFSSL_NOSHA512_256) - else if (type == WC_HASH_TYPE_SHA512_256) { - initFp = wc_InitSha512_256; - ghashFp = wc_Sha512_256GetHash; - } +#ifdef WOLFSSL_SHA512 + DIGEST_COPY_TEST(wc_Sha512, Sha512, SHA512, + "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd" + "\xf1\x54\x28\x50\xd6\x6d\x80\x07" + "\xd6\x20\xe4\x05\x0b\x57\x15\xdc" + "\x83\xf4\xa9\x21\xd3\x6c\xe9\xce" + "\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0" + "\xff\x83\x18\xd2\x87\x7e\xec\x2f" + "\x63\xb9\x31\xbd\x47\x41\x7a\x81" + "\xa5\x38\x32\x7a\xf9\x27\xda\x3e", + "\xdd\xaf\x35\xa1\x93\x61\x7a\xba" + "\xcc\x41\x73\x49\xae\x20\x41\x31" + "\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2" + "\x0a\x9e\xee\xe6\x4b\x55\xd3\x9a" + "\x21\x92\x99\x2a\x27\x4f\xc1\xa8" + "\x36\xba\x3c\x23\xa3\xfe\xeb\xbd" + "\x45\x4d\x44\x23\x64\x3c\xe8\x0e" + "\x2a\x9a\xc9\x4f\xa5\x4c\xa4\x9f"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ - else { - initFp = NULL; - ghashFp = NULL; - } - - if (initFp == NULL || ghashFp == NULL) - return TEST_FAIL; - - ExpectIntEQ(initFp(&sha512), 0); - ExpectIntEQ(ghashFp(&sha512, hash1), 0); - - /* test bad arguments*/ - ExpectIntEQ(ghashFp(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(ghashFp(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(ghashFp(&sha512, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); return EXPECT_RESULT(); } -#endif /* !HAVE_FIPS && !HAVE_SELFTEST && - (!WOLFSSL_NOSHA512_224 || !WOLFSSL_NOSHA512_256) */ -#endif /* WOLFSSL_SHA512 */ -/* - * Unit test function for wc_Sha512GetHash() - */ int test_wc_Sha512GetHash(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA512 - wc_Sha512 sha512; - byte hash1[WC_SHA512_DIGEST_SIZE]; - - /* Initialize */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - - ExpectIntEQ(wc_Sha512GetHash(&sha512, hash1), 0); - - /* test bad arguments*/ - ExpectIntEQ(wc_Sha512GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512GetHash(&sha512, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + DIGEST_GET_HASH_TEST(wc_Sha512, Sha512, SHA512, + "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd" + "\xf1\x54\x28\x50\xd6\x6d\x80\x07" + "\xd6\x20\xe4\x05\x0b\x57\x15\xdc" + "\x83\xf4\xa9\x21\xd3\x6c\xe9\xce" + "\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0" + "\xff\x83\x18\xd2\x87\x7e\xec\x2f" + "\x63\xb9\x31\xbd\x47\x41\x7a\x81" + "\xa5\x38\x32\x7a\xf9\x27\xda\x3e", + "\xdd\xaf\x35\xa1\x93\x61\x7a\xba" + "\xcc\x41\x73\x49\xae\x20\x41\x31" + "\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2" + "\x0a\x9e\xee\xe6\x4b\x55\xd3\x9a" + "\x21\x92\x99\x2a\x27\x4f\xc1\xa8" + "\x36\xba\x3c\x23\xa3\xfe\xeb\xbd" + "\x45\x4d\x44\x23\x64\x3c\xe8\x0e" + "\x2a\x9a\xc9\x4f\xa5\x4c\xa4\x9f"); +#endif + return EXPECT_RESULT(); +} - wc_Sha512Free(&sha512); +int test_wc_Sha512Transform(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && \ + (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) + DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha512, Sha512, SHA512, + "\x80\x63\x62\x61\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x18\x00\x00\x00", + "\x54\x52\xb6\x73\x58\x3e\x6f\x12" + "\xcb\x0b\xf3\x61\x38\xb9\x76\xe8" + "\x2e\x46\x13\xd9\x4a\x67\xe3\x7c" + "\x5c\xd7\xa5\xe6\x43\x55\x16\xa2" + "\x83\x06\x9a\x32\x69\x55\x63\x95" + "\x68\x75\xde\x70\x09\x4d\xcd\xfe" + "\xbe\x11\x20\xd6\xe7\x7c\x49\xd3" + "\x5b\xd7\x07\x75\x19\xc9\x8a\xfa"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha512GetHash */ +} -/* - * Unit test function for wc_Sha512Copy() - */ -int test_wc_Sha512Copy(void) +int test_wc_Sha512_Flags(void) { EXPECT_DECLS; -#ifdef WOLFSSL_SHA512 - wc_Sha512 sha512; - wc_Sha512 temp; - - XMEMSET(&sha512, 0, sizeof(wc_Sha512)); - XMEMSET(&temp, 0, sizeof(wc_Sha512)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha512(&sha512), 0); - ExpectIntEQ(wc_InitSha512(&temp), 0); - - ExpectIntEQ(wc_Sha512Copy(&sha512, &temp), 0); - - /* test bad arguments*/ - ExpectIntEQ(wc_Sha512Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512Copy(&sha512, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512Free(&sha512); - wc_Sha512Free(&temp); +#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha512, Sha512); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha512Copy */ +} /******************************************************************************* * SHA-512-224 ******************************************************************************/ +/* + * Unit test for the wc_InitSha512_224() + */ int test_wc_InitSha512_224(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - wc_Sha512 sha512; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha512_224(&sha512), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha512_224(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512_224Free(&sha512); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_224 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha512, Sha512_224); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_InitSha512_224 */ +/* + * Tesing wc_Sha512_224Update() + */ int test_wc_Sha512_224Update(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - wc_Sha512 sha512; - byte hash[WC_SHA512_DIGEST_SIZE]; - testVector a, c; - - ExpectIntEQ(wc_InitSha512_224(&sha512), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha512_224Update(&sha512, NULL, 0), 0); - ExpectIntEQ(wc_Sha512_224Update(&sha512,(byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha512_224Update(&sha512, (byte*)a.input, (word32)a.inLen), - 0); - ExpectIntEQ(wc_Sha512_224Final(&sha512, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\x46\x34\x27\x0f\x70\x7b\x6a\x54\xda\xae\x75\x30\x46\x08" - "\x42\xe2\x0e\x37\xed\x26\x5c\xee\xe9\xa4\x3e\x89\x24\xaa"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha512_224Update(&sha512, (byte*) a.input, (word32) a.inLen), - 0); - ExpectIntEQ(wc_Sha512_224Final(&sha512, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA512_224_DIGEST_SIZE), 0); - - c.input = NULL; - c.inLen = WC_SHA512_224_DIGEST_SIZE; - ExpectIntEQ(wc_Sha512_224Update(&sha512, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_224Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512_224Free(&sha512); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_224 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_UPDATE_TEST(wc_Sha512, Sha512_224); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_224Update() */ +/* + * Unit test on wc_Sha512_224Final + */ int test_wc_Sha512_224Final(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - ExpectIntEQ(test_Sha512_Family_Final(WC_HASH_TYPE_SHA512_224, 0), - TEST_SUCCESS); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_224 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_FINAL_TEST(wc_Sha512, Sha512_224, SHA512_224); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_224Final */ +/* + * Unit test on wc_Sha512_224FinalRaw + */ int test_wc_Sha512_224FinalRaw(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) && \ - !defined(WOLFSSL_NO_HASH_RAW) - ExpectIntEQ(test_Sha512_Family_Final(WC_HASH_TYPE_SHA512_224, 1), - TEST_SUCCESS); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) && \ + !defined(HAVE_SELFTEST) && !defined(WOLFSSL_DEVCRYPTO) && \ + (!defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \ + (HAVE_FIPS_VERSION >= 3))) && !defined(WOLFSSL_NO_HASH_RAW) + DIGEST_FINAL_RAW_TEST(wc_Sha512, Sha512_224, SHA512_224, + "\x8c\x3d\x37\xc8\x19\x54\x4d\xa2" + "\x73\xe1\x99\x66\x89\xdc\xd4\xd6" + "\x1d\xfa\xb7\xae\x32\xff\x9c\x82" + "\x67\x9d\xd5\x14"); #endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_224Final */ -int test_wc_Sha512_224GetFlags(void) +#define SHA512_224_KAT_CNT 7 +int test_wc_Sha512_224_KATs(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) && \ - defined(WOLFSSL_HASH_FLAGS) - wc_Sha512 sha512; - wc_Sha512 copy; - word32 flags = 0; - - XMEMSET(&sha512, 0, sizeof(wc_Sha512)); - XMEMSET(©, 0, sizeof(wc_Sha512)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha512_224(&sha512), 0); - ExpectIntEQ(wc_InitSha512_224(©), 0); - - ExpectIntEQ(wc_Sha512_224GetFlags(&sha512, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - - ExpectIntEQ(wc_Sha512_224Copy(&sha512, ©), 0); - ExpectIntEQ(wc_Sha512_224GetFlags(©, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == WC_HASH_FLAG_ISCOPY); - - wc_Sha512_224Free(©); - wc_Sha512_224Free(&sha512); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + DIGEST_KATS_TEST_VARS(wc_Sha512, SHA512_224); + + DIGEST_KATS_ADD("", 0, + "\x6e\xd0\xdd\x02\x80\x6f\xa8\x9e" + "\x25\xde\x06\x0c\x19\xd3\xac\x86" + "\xca\xbb\x87\xd6\xa0\xdd\xd0\x5c" + "\x33\x3b\x84\xf4"); + DIGEST_KATS_ADD("a", 1, + "\xd5\xcd\xb9\xcc\xc7\x69\xa5\x12" + "\x1d\x41\x75\xf2\xbf\xdd\x13\xd6" + "\x31\x0e\x0d\x3d\x36\x1e\xa7\x5d" + "\x82\x10\x83\x27"); + DIGEST_KATS_ADD("abc", 3, + "\x46\x34\x27\x0f\x70\x7b\x6a\x54" + "\xda\xae\x75\x30\x46\x08\x42\xe2" + "\x0e\x37\xed\x26\x5c\xee\xe9\xa4" + "\x3e\x89\x24\xaa"); + DIGEST_KATS_ADD("message digest", 14, + "\xad\x1a\x4d\xb1\x88\xfe\x57\x06" + "\x4f\x4f\x24\x60\x9d\x2a\x83\xcd" + "\x0a\xfb\x9b\x39\x8e\xb2\xfc\xae" + "\xaa\xe2\xc5\x64"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xff\x83\x14\x8a\xa0\x7e\xc3\x06" + "\x55\xc1\xb4\x0a\xff\x86\x14\x1c" + "\x02\x15\xfe\x2a\x54\xf7\x67\xd3" + "\xf3\x87\x43\xd8"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xa8\xb4\xb9\x17\x4b\x99\xff\xc6" + "\x7d\x6f\x49\xbe\x99\x81\x58\x7b" + "\x96\x44\x10\x51\xe1\x6e\x6d\xd0" + "\x36\xb1\x40\xd3"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\xae\x98\x8f\xaa\xa4\x7e\x40\x1a" + "\x45\xf7\x04\xd1\x27\x2d\x99\x70" + "\x24\x58\xfe\xa2\xdd\xc6\x58\x28" + "\x27\x55\x6d\xd2"); + + DIGEST_KATS_TEST(Sha512_224, SHA512_224); +#endif + return EXPECT_RESULT(); +} /* END test_wc_Sha512_224Final */ + +int test_wc_Sha512_224_other(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + DIGEST_OTHER_TEST(wc_Sha512, Sha512_224, SHA512_224, + "\xbe\xbb\x85\xa0\x14\x9f\xd7\xae" + "\xc4\xbe\xa4\x8f\xa3\xeb\xac\xc0" + "\x88\x02\x6b\xa0\xe8\x22\x5c\xb3" + "\x12\x11\xa0\x48"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_224Final */ -int test_wc_Sha512_224Free(void) +int test_wc_Sha512_224Copy(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - wc_Sha512_224Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_COPY_TEST(wc_Sha512, Sha512_224, SHA512_224, + "\x6e\xd0\xdd\x02\x80\x6f\xa8\x9e" + "\x25\xde\x06\x0c\x19\xd3\xac\x86" + "\xca\xbb\x87\xd6\xa0\xdd\xd0\x5c" + "\x33\x3b\x84\xf4", + "\x46\x34\x27\x0f\x70\x7b\x6a\x54" + "\xda\xae\x75\x30\x46\x08\x42\xe2" + "\x0e\x37\xed\x26\x5c\xee\xe9\xa4" + "\x3e\x89\x24\xaa"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); } int test_wc_Sha512_224GetHash(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - ExpectIntEQ(test_Sha512_Family_GetHash(WC_HASH_TYPE_SHA512_224), - TEST_SUCCESS); + DIGEST_GET_HASH_TEST(wc_Sha512, Sha512_224, SHA512_224, + "\x6e\xd0\xdd\x02\x80\x6f\xa8\x9e" + "\x25\xde\x06\x0c\x19\xd3\xac\x86" + "\xca\xbb\x87\xd6\xa0\xdd\xd0\x5c" + "\x33\x3b\x84\xf4", + "\x46\x34\x27\x0f\x70\x7b\x6a\x54" + "\xda\xae\x75\x30\x46\x08\x42\xe2" + "\x0e\x37\xed\x26\x5c\xee\xe9\xa4" + "\x3e\x89\x24\xaa"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); } -int test_wc_Sha512_224Copy(void) + +int test_wc_Sha512_224Transform(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) - wc_Sha512 sha512; - wc_Sha512 temp; - - XMEMSET(&sha512, 0, sizeof(wc_Sha512)); - XMEMSET(&temp, 0, sizeof(wc_Sha512)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha512_224(&sha512), 0); - ExpectIntEQ(wc_InitSha512_224(&temp), 0); - - ExpectIntEQ(wc_Sha512_224Copy(&sha512, &temp), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha512_224Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_224Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_224Copy(&sha512, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) && \ + (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) + DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha512, Sha512_224, SHA512_224, + "\x61\x62\x63\x80\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x18", + "\x46\x34\x27\x0f\x70\x7b\x6a\x54" + "\xda\xae\x75\x30\x46\x08\x42\xe2" + "\x0e\x37\xed\x26\x5c\xee\xe9\xa4" + "\x3e\x89\x24\xaa"); +#endif + return EXPECT_RESULT(); +} - wc_Sha512_224Free(&sha512); - wc_Sha512_224Free(&temp); +int test_wc_Sha512_224_Flags(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) && \ + defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha512, Sha512_224); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); } @@ -611,174 +497,197 @@ int test_wc_Sha512_224Copy(void) * SHA-512-256 ******************************************************************************/ +/* + * Unit test for the wc_InitSha512_256() + */ int test_wc_InitSha512_256(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - wc_Sha512 sha512; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha512_256(&sha512), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha512_256(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512_256Free(&sha512); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_256 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha512, Sha512_256); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_InitSha512_256 */ +/* + * Tesing wc_Sha512_256Update() + */ int test_wc_Sha512_256Update(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - wc_Sha512 sha512; - byte hash[WC_SHA512_DIGEST_SIZE]; - testVector a, c; - - ExpectIntEQ(wc_InitSha512_256(&sha512), 0); - - /* Input. */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha512_256Update(&sha512, NULL, 0), 0); - ExpectIntEQ(wc_Sha512_256Update(&sha512,(byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha512_256Update(&sha512, (byte*)a.input, (word32)a.inLen), - 0); - ExpectIntEQ(wc_Sha512_256Final(&sha512, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\x53\x04\x8e\x26\x81\x94\x1e\xf9\x9b\x2e\x29\xb7\x6b\x4c" - "\x7d\xab\xe4\xc2\xd0\xc6\x34\xfc\x6d\x46\xe0\xe2\xf1\x31" - "\x07\xe7\xaf\x23"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha512_256Update(&sha512, (byte*) a.input, (word32) a.inLen), - 0); - ExpectIntEQ(wc_Sha512_256Final(&sha512, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA512_256_DIGEST_SIZE), 0); - - c.input = NULL; - c.inLen = WC_SHA512_256_DIGEST_SIZE; - ExpectIntEQ(wc_Sha512_256Update(&sha512, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_256Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha512_256Free(&sha512); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_256 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_UPDATE_TEST(wc_Sha512, Sha512_256); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_256Update() */ +/* + * Unit test on wc_Sha512_256Final + */ int test_wc_Sha512_256Final(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - ExpectIntEQ(test_Sha512_Family_Final(WC_HASH_TYPE_SHA512_256, 0), - TEST_SUCCESS); -#endif /* WOLFSSL_SHA512 && !WOLFSSL_NOSHA512_256 */ -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ + DIGEST_FINAL_TEST(wc_Sha512, Sha512_256, SHA512_256); +#endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_256Final */ +/* + * Unit test on wc_Sha512_256FinalRaw + */ int test_wc_Sha512_256FinalRaw(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) && \ - !defined(WOLFSSL_NO_HASH_RAW) - ExpectIntEQ(test_Sha512_Family_Final(WC_HASH_TYPE_SHA512_256, 1), - TEST_SUCCESS); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) && \ + !defined(HAVE_SELFTEST) && !defined(WOLFSSL_DEVCRYPTO) && \ + (!defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \ + (HAVE_FIPS_VERSION >= 3))) && !defined(WOLFSSL_NO_HASH_RAW) + DIGEST_FINAL_RAW_TEST(wc_Sha512, Sha512_256, SHA512_256, + "\x22\x31\x21\x94\xfc\x2b\xf7\x2c" + "\x9f\x55\x5f\xa3\xc8\x4c\x64\xc2" + "\x23\x93\xb8\x6b\x6f\x53\xb1\x51" + "\x96\x38\x77\x19\x59\x40\xea\xbd"); #endif return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_256Final */ -int test_wc_Sha512_256GetFlags(void) +#define SHA512_256_KAT_CNT 7 +int test_wc_Sha512_256_KATs(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) && \ - defined(WOLFSSL_HASH_FLAGS) - wc_Sha512 sha512, copy; - word32 flags = 0; - - XMEMSET(&sha512, 0, sizeof(wc_Sha512)); - XMEMSET(©, 0, sizeof(wc_Sha512)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha512_256(&sha512), 0); - ExpectIntEQ(wc_InitSha512_256(©), 0); - - ExpectIntEQ(wc_Sha512_256GetFlags(&sha512, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - - ExpectIntEQ(wc_Sha512_256Copy(&sha512, ©), 0); - ExpectIntEQ(wc_Sha512_256GetFlags(©, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == WC_HASH_FLAG_ISCOPY); - - wc_Sha512_256Free(&sha512); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) + DIGEST_KATS_TEST_VARS(wc_Sha512, SHA512_256); + + DIGEST_KATS_ADD("", 0, + "\xc6\x72\xb8\xd1\xef\x56\xed\x28" + "\xab\x87\xc3\x62\x2c\x51\x14\x06" + "\x9b\xdd\x3a\xd7\xb8\xf9\x73\x74" + "\x98\xd0\xc0\x1e\xce\xf0\x96\x7a"); + DIGEST_KATS_ADD("a", 1, + "\x45\x5e\x51\x88\x24\xbc\x06\x01" + "\xf9\xfb\x85\x8f\xf5\xc3\x7d\x41" + "\x7d\x67\xc2\xf8\xe0\xdf\x2b\xab" + "\xe4\x80\x88\x58\xae\xa8\x30\xf8"); + DIGEST_KATS_ADD("abc", 3, + "\x53\x04\x8e\x26\x81\x94\x1e\xf9" + "\x9b\x2e\x29\xb7\x6b\x4c\x7d\xab" + "\xe4\xc2\xd0\xc6\x34\xfc\x6d\x46" + "\xe0\xe2\xf1\x31\x07\xe7\xaf\x23"); + DIGEST_KATS_ADD("message digest", 14, + "\x0c\xf4\x71\xfd\x17\xed\x69\xd9" + "\x90\xda\xf3\x43\x3c\x89\xb1\x6d" + "\x63\xde\xc1\xbb\x9c\xb4\x2a\x60" + "\x94\x60\x4e\xe5\xd7\xb4\xe9\xfb"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xfc\x31\x89\x44\x3f\x9c\x26\x8f" + "\x62\x6a\xea\x08\xa7\x56\xab\xe7" + "\xb7\x26\xb0\x5f\x70\x1c\xb0\x82" + "\x22\x31\x2c\xcf\xd6\x71\x0a\x26"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\xcd\xf1\xcc\x0e\xff\xe2\x6e\xcc" + "\x0c\x13\x75\x8f\x7b\x4a\x48\xe0" + "\x00\x61\x5d\xf2\x41\x28\x41\x85" + "\xc3\x9e\xb0\x5d\x35\x5b\xb9\xc8"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\x2c\x9f\xdb\xc0\xc9\x0b\xdd\x87" + "\x61\x2e\xe8\x45\x54\x74\xf9\x04" + "\x48\x50\x24\x1d\xc1\x05\xb1\xe8" + "\xb9\x4b\x8d\xdf\x5f\xac\x91\x48"); + + DIGEST_KATS_TEST(Sha512_256, SHA512_256); +#endif + return EXPECT_RESULT(); +} /* END test_wc_Sha512_256Final */ + +int test_wc_Sha512_256_other(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) + DIGEST_OTHER_TEST(wc_Sha512, Sha512_256, SHA512_256, + "\x0c\x80\x73\xf5\xf4\xc8\xc7\x13" + "\x4a\xc4\x8a\xda\x04\xfc\x77\x74" + "\xea\xa0\x85\xa9\x29\xb3\x54\xa4" + "\x08\xef\x2a\x87\x61\x1f\x8c\xb8"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); -} +} /* END test_wc_Sha512_256Final */ -int test_wc_Sha512_256Free(void) +int test_wc_Sha512_256Copy(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - wc_Sha512_256Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_COPY_TEST(wc_Sha512, Sha512_256, SHA512_256, + "\xc6\x72\xb8\xd1\xef\x56\xed\x28" + "\xab\x87\xc3\x62\x2c\x51\x14\x06" + "\x9b\xdd\x3a\xd7\xb8\xf9\x73\x74" + "\x98\xd0\xc0\x1e\xce\xf0\x96\x7a", + "\x53\x04\x8e\x26\x81\x94\x1e\xf9" + "\x9b\x2e\x29\xb7\x6b\x4c\x7d\xab" + "\xe4\xc2\xd0\xc6\x34\xfc\x6d\x46" + "\xe0\xe2\xf1\x31\x07\xe7\xaf\x23"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); } int test_wc_Sha512_256GetHash(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - ExpectIntEQ(test_Sha512_Family_GetHash(WC_HASH_TYPE_SHA512_256), - TEST_SUCCESS); + DIGEST_GET_HASH_TEST(wc_Sha512, Sha512_256, SHA512_256, + "\xc6\x72\xb8\xd1\xef\x56\xed\x28" + "\xab\x87\xc3\x62\x2c\x51\x14\x06" + "\x9b\xdd\x3a\xd7\xb8\xf9\x73\x74" + "\x98\xd0\xc0\x1e\xce\xf0\x96\x7a", + "\x53\x04\x8e\x26\x81\x94\x1e\xf9" + "\x9b\x2e\x29\xb7\x6b\x4c\x7d\xab" + "\xe4\xc2\xd0\xc6\x34\xfc\x6d\x46" + "\xe0\xe2\xf1\x31\x07\xe7\xaf\x23"); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); - } -int test_wc_Sha512_256Copy(void) +int test_wc_Sha512_256Transform(void) { EXPECT_DECLS; -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) - wc_Sha512 sha512; - wc_Sha512 temp; - - XMEMSET(&sha512, 0, sizeof(wc_Sha512)); - XMEMSET(&temp, 0, sizeof(wc_Sha512)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha512_256(&sha512), 0); - ExpectIntEQ(wc_InitSha512_256(&temp), 0); - - ExpectIntEQ(wc_Sha512_256Copy(&sha512, &temp), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha512_256Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_256Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha512_256Copy(&sha512, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) && \ + (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \ + !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) + DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha512, Sha512_256, SHA512_256, + "\x61\x62\x63\x80\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x18", + "\x53\x04\x8e\x26\x81\x94\x1e\xf9" + "\x9b\x2e\x29\xb7\x6b\x4c\x7d\xab" + "\xe4\xc2\xd0\xc6\x34\xfc\x6d\x46" + "\xe0\xe2\xf1\x31\x07\xe7\xaf\x23"); +#endif + return EXPECT_RESULT(); +} - wc_Sha512_256Free(&sha512); - wc_Sha512_256Free(&temp); +int test_wc_Sha512_256_Flags(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) && \ + defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha512, Sha512_256); #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ return EXPECT_RESULT(); } @@ -787,235 +696,189 @@ int test_wc_Sha512_256Copy(void) ******************************************************************************/ /* - * Testing wc_InitSha384() + * Unit test for the wc_InitSha384() */ int test_wc_InitSha384(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384 sha384; - - /* Test good arg. */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - /* Test bad arg. */ - ExpectIntEQ(wc_InitSha384(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha384Free(&sha384); + DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha384, Sha384); #endif return EXPECT_RESULT(); } /* END test_wc_InitSha384 */ /* - * test wc_Sha384Update() + * Tesing wc_Sha384Update() */ int test_wc_Sha384Update(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384 sha384; - byte hash[WC_SHA384_DIGEST_SIZE]; - testVector a, b, c; - - ExpectIntEQ(wc_InitSha384(&sha384), 0); - - /* Input */ - a.input = "a"; - a.inLen = XSTRLEN(a.input); - ExpectIntEQ(wc_Sha384Update(&sha384, NULL, 0), 0); - ExpectIntEQ(wc_Sha384Update(&sha384, (byte*)a.input, 0), 0); - ExpectIntEQ(wc_Sha384Update(&sha384, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha384Final(&sha384, hash), 0); - - /* Update input. */ - a.input = "abc"; - a.output = "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50" - "\x07\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff" - "\x5b\xed\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34" - "\xc8\x25\xa7"; - a.inLen = XSTRLEN(a.input); - a.outLen = XSTRLEN(a.output); - ExpectIntEQ(wc_Sha384Update(&sha384, (byte*)a.input, (word32)a.inLen), 0); - ExpectIntEQ(wc_Sha384Final(&sha384, hash), 0); - ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA384_DIGEST_SIZE), 0); - - /* Pass in bad values. */ - b.input = NULL; - b.inLen = 0; - ExpectIntEQ(wc_Sha384Update(&sha384, (byte*)b.input, (word32)b.inLen), 0); - c.input = NULL; - c.inLen = WC_SHA384_DIGEST_SIZE; - ExpectIntEQ( wc_Sha384Update(&sha384, (byte*)c.input, (word32)c.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384Update(NULL, (byte*)a.input, (word32)a.inLen), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha384Free(&sha384); -#endif - return EXPECT_RESULT(); -} /* END test_wc_Sha384Update */ + DIGEST_UPDATE_TEST(wc_Sha384, Sha384); +#endif + return EXPECT_RESULT(); +} /* END test_wc_Sha384Update() */ /* - * Unit test function for wc_Sha384Final(); + * Unit test on wc_Sha384Final */ int test_wc_Sha384Final(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384 sha384; - byte* hash_test[3]; - byte hash1[WC_SHA384_DIGEST_SIZE]; - byte hash2[2*WC_SHA384_DIGEST_SIZE]; - byte hash3[5*WC_SHA384_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - /* Good test args. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha384Final(&sha384, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha384Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384Final(&sha384, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha384Free(&sha384); + DIGEST_FINAL_TEST(wc_Sha384, Sha384, SHA384); #endif return EXPECT_RESULT(); } /* END test_wc_Sha384Final */ /* - * Unit test function for wc_Sha384FinalRaw() + * Unit test on wc_Sha384FinalRaw */ int test_wc_Sha384FinalRaw(void) { EXPECT_DECLS; -#if (defined(WOLFSSL_SHA384) && !defined(HAVE_SELFTEST) && \ - (!defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \ - (HAVE_FIPS_VERSION >= 3)))) && \ +#if defined(WOLFSSL_SHA384) && !defined(HAVE_SELFTEST) && \ + !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ !defined(WOLFSSL_NO_HASH_RAW) - wc_Sha384 sha384; - byte* hash_test[3]; - byte hash1[WC_SHA384_DIGEST_SIZE]; - byte hash2[2*WC_SHA384_DIGEST_SIZE]; - byte hash3[5*WC_SHA384_DIGEST_SIZE]; - int times, i; - - /* Initialize */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - - hash_test[0] = hash1; - hash_test[1] = hash2; - hash_test[2] = hash3; - times = sizeof(hash_test) / sizeof(byte*); - /* Good test args. */ - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sha384FinalRaw(&sha384, hash_test[i]), 0); - } - - /* Test bad args. */ - ExpectIntEQ(wc_Sha384FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384FinalRaw(&sha384, NULL), - WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha384Free(&sha384); + DIGEST_FINAL_RAW_TEST(wc_Sha384, Sha384, SHA384, + "\xcb\xbb\x9d\x5d\xc1\x05\x9e\xd8" + "\x62\x9a\x29\x2a\x36\x7c\xd5\x07" + "\x91\x59\x01\x5a\x30\x70\xdd\x17" + "\x15\x2f\xec\xd8\xf7\x0e\x59\x39" + "\x67\x33\x26\x67\xff\xc0\x0b\x31" + "\x8e\xb4\x4a\x87\x68\x58\x15\x11"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha384FinalRaw */ +} /* END test_wc_Sha384 */ -/* - * Unit test function for wc_Sha384GetFlags() - */ -int test_wc_Sha384GetFlags(void) +#define SHA384_KAT_CNT 7 +int test_wc_Sha384_KATs(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SHA384) && defined(WOLFSSL_HASH_FLAGS) - wc_Sha384 sha384; - word32 flags = 0; - - /* Initialize */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - ExpectIntEQ(wc_Sha384GetFlags(&sha384, &flags), 0); - ExpectTrue((flags & WC_HASH_FLAG_ISCOPY) == 0); - - wc_Sha384Free(&sha384); +#ifdef WOLFSSL_SHA384 + DIGEST_KATS_TEST_VARS(wc_Sha384, SHA384); + + DIGEST_KATS_ADD("", 0, + "\x38\xb0\x60\xa7\x51\xac\x96\x38" + "\x4c\xd9\x32\x7e\xb1\xb1\xe3\x6a" + "\x21\xfd\xb7\x11\x14\xbe\x07\x43" + "\x4c\x0c\xc7\xbf\x63\xf6\xe1\xda" + "\x27\x4e\xde\xbf\xe7\x6f\x65\xfb" + "\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b"); + DIGEST_KATS_ADD("a", 1, + "\x54\xa5\x9b\x9f\x22\xb0\xb8\x08" + "\x80\xd8\x42\x7e\x54\x8b\x7c\x23" + "\xab\xd8\x73\x48\x6e\x1f\x03\x5d" + "\xce\x9c\xd6\x97\xe8\x51\x75\x03" + "\x3c\xaa\x88\xe6\xd5\x7b\xc3\x5e" + "\xfa\xe0\xb5\xaf\xd3\x14\x5f\x31"); + DIGEST_KATS_ADD("abc", 3, + "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b" + "\xb5\xa0\x3d\x69\x9a\xc6\x50\x07" + "\x27\x2c\x32\xab\x0e\xde\xd1\x63" + "\x1a\x8b\x60\x5a\x43\xff\x5b\xed" + "\x80\x86\x07\x2b\xa1\xe7\xcc\x23" + "\x58\xba\xec\xa1\x34\xc8\x25\xa7"); + DIGEST_KATS_ADD("message digest", 14, + "\x47\x3e\xd3\x51\x67\xec\x1f\x5d" + "\x8e\x55\x03\x68\xa3\xdb\x39\xbe" + "\x54\x63\x9f\x82\x88\x68\xe9\x45" + "\x4c\x23\x9f\xc8\xb5\x2e\x3c\x61" + "\xdb\xd0\xd8\xb4\xde\x13\x90\xc2" + "\x56\xdc\xbb\x5d\x5f\xd9\x9c\xd5"); + DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26, + "\xfe\xb6\x73\x49\xdf\x3d\xb6\xf5" + "\x92\x48\x15\xd6\xc3\xdc\x13\x3f" + "\x09\x18\x09\x21\x37\x31\xfe\x5c" + "\x7b\x5f\x49\x99\xe4\x63\x47\x9f" + "\xf2\x87\x7f\x5f\x29\x36\xfa\x63" + "\xbb\x43\x78\x4b\x12\xf3\xeb\xb4"); + DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789", 62, + "\x17\x61\x33\x6e\x3f\x7c\xbf\xe5" + "\x1d\xeb\x13\x7f\x02\x6f\x89\xe0" + "\x1a\x44\x8e\x3b\x1f\xaf\xa6\x40" + "\x39\xc1\x46\x4e\xe8\x73\x2f\x11" + "\xa5\x34\x1a\x6f\x41\xe0\xc2\x02" + "\x29\x47\x36\xed\x64\xdb\x1a\x84"); + DIGEST_KATS_ADD("1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890", 80, + "\xb1\x29\x32\xb0\x62\x7d\x1c\x06" + "\x09\x42\xf5\x44\x77\x64\x15\x56" + "\x55\xbd\x4d\xa0\xc9\xaf\xa6\xdd" + "\x9b\x9e\xf5\x31\x29\xaf\x1b\x8f" + "\xb0\x19\x59\x96\xd2\xde\x9c\xa0" + "\xdf\x9d\x82\x1f\xfe\xe6\x70\x26"); + + DIGEST_KATS_TEST(Sha384, SHA384); #endif return EXPECT_RESULT(); +} /* END test_wc_Sha384Final */ -} /* END test_wc_Sha384GetFlags */ - -/* - * Unit test function for wc_Sha384Free() - */ -int test_wc_Sha384Free(void) +int test_wc_Sha384_other(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384Free(NULL); - /* Set result to SUCCESS. */ - ExpectTrue(1); + DIGEST_OTHER_TEST(wc_Sha384, Sha384, SHA384, + "\xbe\x28\x56\x36\xd3\xae\x1c\x63" + "\x94\x7a\xc0\x7f\xb1\x71\x5c\x19" + "\x45\xfd\x81\x7b\x46\xfb\x03\xc2" + "\x46\x2c\x80\x8d\xd2\xc0\x16\x91" + "\x23\x51\x6b\xa5\x0d\x71\x6f\x8b" + "\x2f\x52\x74\x86\x0d\x05\xa5\x95"); #endif return EXPECT_RESULT(); +} /* END test_wc_Sha384Final */ -} /* END test_wc_Sha384Free */ - -/* - * Unit test function for wc_Sha384GetHash() - */ -int test_wc_Sha384GetHash(void) +int test_wc_Sha384Copy(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384 sha384; - byte hash1[WC_SHA384_DIGEST_SIZE]; - - /* Initialize */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - - ExpectIntEQ(wc_Sha384GetHash(&sha384, hash1), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha384GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384GetHash(&sha384, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - wc_Sha384Free(&sha384); + DIGEST_COPY_TEST(wc_Sha384, Sha384, SHA384, + "\x38\xb0\x60\xa7\x51\xac\x96\x38" + "\x4c\xd9\x32\x7e\xb1\xb1\xe3\x6a" + "\x21\xfd\xb7\x11\x14\xbe\x07\x43" + "\x4c\x0c\xc7\xbf\x63\xf6\xe1\xda" + "\x27\x4e\xde\xbf\xe7\x6f\x65\xfb" + "\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b", + "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b" + "\xb5\xa0\x3d\x69\x9a\xc6\x50\x07" + "\x27\x2c\x32\xab\x0e\xde\xd1\x63" + "\x1a\x8b\x60\x5a\x43\xff\x5b\xed" + "\x80\x86\x07\x2b\xa1\xe7\xcc\x23" + "\x58\xba\xec\xa1\x34\xc8\x25\xa7"); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha384GetHash */ +} -/* - * Unit test function for wc_Sha384Copy() - */ -int test_wc_Sha384Copy(void) +int test_wc_Sha384GetHash(void) { EXPECT_DECLS; #ifdef WOLFSSL_SHA384 - wc_Sha384 sha384; - wc_Sha384 temp; - - XMEMSET(&sha384, 0, sizeof(wc_Sha384)); - XMEMSET(&temp, 0, sizeof(wc_Sha384)); - - /* Initialize */ - ExpectIntEQ(wc_InitSha384(&sha384), 0); - ExpectIntEQ(wc_InitSha384(&temp), 0); - - ExpectIntEQ(wc_Sha384Copy(&sha384, &temp), 0); - /* test bad arguments*/ - ExpectIntEQ(wc_Sha384Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sha384Copy(&sha384, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + DIGEST_GET_HASH_TEST(wc_Sha384, Sha384, SHA384, + "\x38\xb0\x60\xa7\x51\xac\x96\x38" + "\x4c\xd9\x32\x7e\xb1\xb1\xe3\x6a" + "\x21\xfd\xb7\x11\x14\xbe\x07\x43" + "\x4c\x0c\xc7\xbf\x63\xf6\xe1\xda" + "\x27\x4e\xde\xbf\xe7\x6f\x65\xfb" + "\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b", + "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b" + "\xb5\xa0\x3d\x69\x9a\xc6\x50\x07" + "\x27\x2c\x32\xab\x0e\xde\xd1\x63" + "\x1a\x8b\x60\x5a\x43\xff\x5b\xed" + "\x80\x86\x07\x2b\xa1\xe7\xcc\x23" + "\x58\xba\xec\xa1\x34\xc8\x25\xa7"); +#endif + return EXPECT_RESULT(); +} - wc_Sha384Free(&sha384); - wc_Sha384Free(&temp); +int test_wc_Sha384_Flags(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA384) && defined(WOLFSSL_HASH_FLAGS) + DIGEST_FLAGS_TEST(wc_Sha384, Sha384); #endif return EXPECT_RESULT(); -} /* END test_wc_Sha384Copy */ +} diff --git a/tests/api/test_sha512.h b/tests/api/test_sha512.h index d7ed7a82b2..e7b8ac9ab3 100644 --- a/tests/api/test_sha512.h +++ b/tests/api/test_sha512.h @@ -26,36 +26,43 @@ int test_wc_InitSha512(void); int test_wc_Sha512Update(void); int test_wc_Sha512Final(void); int test_wc_Sha512FinalRaw(void); -int test_wc_Sha512GetFlags(void); -int test_wc_Sha512Free(void); -int test_wc_Sha512GetHash(void); +int test_wc_Sha512_KATs(void); +int test_wc_Sha512_other(void); int test_wc_Sha512Copy(void); +int test_wc_Sha512GetHash(void); +int test_wc_Sha512Transform(void); +int test_wc_Sha512_Flags(void); int test_wc_InitSha512_224(void); int test_wc_Sha512_224Update(void); int test_wc_Sha512_224Final(void); int test_wc_Sha512_224FinalRaw(void); -int test_wc_Sha512_224GetFlags(void); -int test_wc_Sha512_224Free(void); -int test_wc_Sha512_224GetHash(void); +int test_wc_Sha512_224_KATs(void); +int test_wc_Sha512_224_other(void); int test_wc_Sha512_224Copy(void); +int test_wc_Sha512_224GetHash(void); +int test_wc_Sha512_224Transform(void); +int test_wc_Sha512_224_Flags(void); int test_wc_InitSha512_256(void); int test_wc_Sha512_256Update(void); int test_wc_Sha512_256Final(void); int test_wc_Sha512_256FinalRaw(void); -int test_wc_Sha512_256GetFlags(void); -int test_wc_Sha512_256Free(void); -int test_wc_Sha512_256GetHash(void); +int test_wc_Sha512_256_KATs(void); +int test_wc_Sha512_256_other(void); int test_wc_Sha512_256Copy(void); +int test_wc_Sha512_256GetHash(void); +int test_wc_Sha512_256Transform(void); +int test_wc_Sha512_256_Flags(void); int test_wc_InitSha384(void); int test_wc_Sha384Update(void); int test_wc_Sha384Final(void); int test_wc_Sha384FinalRaw(void); -int test_wc_Sha384GetFlags(void); -int test_wc_Sha384Free(void); -int test_wc_Sha384GetHash(void); +int test_wc_Sha384_KATs(void); +int test_wc_Sha384_other(void); int test_wc_Sha384Copy(void); +int test_wc_Sha384GetHash(void); +int test_wc_Sha384_Flags(void); #endif /* WOLFCRYPT_TEST_SHA512_H */ diff --git a/tests/api/test_sm3.c b/tests/api/test_sm3.c index b61bf65ec1..0c90548ed7 100644 --- a/tests/api/test_sm3.c +++ b/tests/api/test_sm3.c @@ -40,250 +40,388 @@ #include #include #include +#include -/* - * Testing wc_InitSm3(), wc_Sm3Free() - */ -int test_wc_InitSm3Free(void) + +int test_wc_InitSm3(void) { EXPECT_DECLS; #ifdef WOLFSSL_SM3 wc_Sm3 sm3; - /* Invalid Parameters */ - ExpectIntEQ(wc_InitSm3(NULL, NULL, INVALID_DEVID), + /* Test bad arg. */ + ExpectIntEQ(wc_InitSm3(NULL, HEAP_HINT, INVALID_DEVID), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - /* Valid Parameters */ - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); + /* Test good arg. */ + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); + wc_Sm3Free(&sm3); wc_Sm3Free(NULL); - wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_InitSm3 */ +} -/* - * Testing wc_Sm3Update(), wc_Sm3Final() - */ -int test_wc_Sm3UpdateFinal(void) +int test_wc_Sm3Update(void) { EXPECT_DECLS; #ifdef WOLFSSL_SM3 wc_Sm3 sm3; - byte data[WC_SM3_BLOCK_SIZE * 4]; - byte hash[WC_SM3_DIGEST_SIZE]; - byte calcHash[WC_SM3_DIGEST_SIZE]; - byte expHash[WC_SM3_DIGEST_SIZE] = { - 0x38, 0x48, 0x15, 0xa7, 0x0e, 0xae, 0x0b, 0x27, - 0x5c, 0xde, 0x9d, 0xa5, 0xd1, 0xa4, 0x30, 0xa1, - 0xca, 0xd4, 0x54, 0x58, 0x44, 0xa2, 0x96, 0x1b, - 0xd7, 0x14, 0x80, 0x3f, 0x80, 0x1a, 0x07, 0xb6 - }; - word32 chunk; - word32 i; - - XMEMSET(data, 0, sizeof(data)); - - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); - - /* Invalid Parameters */ - ExpectIntEQ(wc_Sm3Update(NULL, NULL, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Update(&sm3, NULL, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Update(NULL, data, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - /* Valid Parameters */ - ExpectIntEQ(wc_Sm3Update(&sm3, NULL, 0), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, 1), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, 1), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE - 2), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE * 2), 0); - /* Ensure too many bytes for lengths. */ - ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_PAD_SIZE), 0); - - /* Invalid Parameters */ - ExpectIntEQ(wc_Sm3Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Final(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - /* Valid Parameters */ - ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); - ExpectBufEQ(hash, expHash, WC_SM3_DIGEST_SIZE); + /* Initialize */ + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); - /* Chunk tests. */ - ExpectIntEQ(wc_Sm3Update(&sm3, data, sizeof(data)), 0); - ExpectIntEQ(wc_Sm3Final(&sm3, calcHash), 0); - for (chunk = 1; chunk <= WC_SM3_BLOCK_SIZE + 1; chunk++) { - for (i = 0; i + chunk <= (word32)sizeof(data); i += chunk) { - ExpectIntEQ(wc_Sm3Update(&sm3, data + i, chunk), 0); - } - if (i < (word32)sizeof(data)) { - ExpectIntEQ(wc_Sm3Update(&sm3, data + i, (word32)sizeof(data) - i), - 0); - } - ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); - ExpectBufEQ(hash, calcHash, WC_SM3_DIGEST_SIZE); - } + /* Pass in bad values. */ + ExpectIntEQ(wc_Sm3Update(NULL, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Update(&sm3, NULL, 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Update(NULL, NULL, 0), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - /* Not testing when the low 32-bit length overflows. */ + ExpectIntEQ(wc_Sm3Update(&sm3, NULL, 0), 0); + ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)"a", 1), 0); wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_Sm3Update */ +} -/* - * Testing wc_Sm3GetHash() - */ -int test_wc_Sm3GetHash(void) +int test_wc_Sm3Final(void) { EXPECT_DECLS; #ifdef WOLFSSL_SM3 wc_Sm3 sm3; byte hash[WC_SM3_DIGEST_SIZE]; - byte calcHash[WC_SM3_DIGEST_SIZE]; - byte data[WC_SM3_BLOCK_SIZE]; - XMEMSET(data, 0, sizeof(data)); - - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); - ExpectIntEQ(wc_Sm3Final(&sm3, calcHash), 0); - - /* Invalid Parameters */ - ExpectIntEQ(wc_Sm3GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3GetHash(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3GetHash(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + /* Initialize */ + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); - /* Valid Parameters */ - ExpectIntEQ(wc_Sm3GetHash(&sm3, hash), 0); - ExpectBufEQ(hash, calcHash, WC_SM3_DIGEST_SIZE); + /* Test bad args. */ + ExpectIntEQ(wc_Sm3Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Final(&sm3, NULL), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - /* With update. */ - ExpectIntEQ(wc_Sm3Update(&sm3, data, sizeof(data)), 0); - ExpectIntEQ(wc_Sm3GetHash(&sm3, hash), 0); - ExpectIntEQ(wc_Sm3Final(&sm3, calcHash), 0); - ExpectBufEQ(hash, calcHash, WC_SM3_DIGEST_SIZE); + /* Test good args. */ + ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_Sm3Update */ +} -/* - * Testing wc_Sm3Copy() - */ -int test_wc_Sm3Copy(void) +int test_wc_Sm3FinalRaw(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS) +#if defined(WOLFSSL_SM3) && !defined(HAVE_SELFTEST) && \ + !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ + (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ + !defined(WOLFSSL_NO_HASH_RAW) wc_Sm3 sm3; - wc_Sm3 sm3Copy; byte hash[WC_SM3_DIGEST_SIZE]; - byte hashCopy[WC_SM3_DIGEST_SIZE]; - byte data[WC_SM3_BLOCK_SIZE + 1]; - int i; + const char* expHash = + "\x73\x80\x16\x6f\x49\x14\xb2\xb9" + "\x17\x24\x42\xd7\xda\x8a\x06\x00" + "\xa9\x6f\x30\xbc\x16\x31\x38\xaa" + "\xe3\x8d\xee\x4d\xb0\xfb\x0e\x4e"; - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); - ExpectIntEQ(wc_InitSm3(&sm3Copy, NULL, INVALID_DEVID), 0); + /* Initialize */ + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); - /* Invalid Parameters */ - ExpectIntEQ(wc_Sm3Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Copy(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3Copy(NULL, &sm3Copy), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - - /* Valid Parameters */ - ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3Copy), 0); - - /* Ensure all parts of data updated during hashing are copied. */ - for (i = 0; i < WC_SM3_BLOCK_SIZE + 1; i++) { - ExpectIntEQ(wc_Sm3Update(&sm3, data, i), 0); - ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3Copy), 0); - ExpectIntEQ(wc_Sm3Update(&sm3, data, 1), 0); - ExpectIntEQ(wc_Sm3Update(&sm3Copy, data, 1), 0); + /* Test bad args. */ + ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3FinalRaw(&sm3, NULL), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3FinalRaw(NULL, hash), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test good args. */ + ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash), 0); + ExpectBufEQ(hash, expHash, WC_SM3_DIGEST_SIZE); + + wc_Sm3Free(&sm3); +#endif + return EXPECT_RESULT(); +} + +#define SM3_KAT_CNT 7 +int test_wc_Sm3_KATs(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SM3 + wc_Sm3 sm3; + + testVector sm3_kat[SM3_KAT_CNT]; + byte hash[WC_SM3_DIGEST_SIZE]; + int i = 0; + + sm3_kat[i].input = ""; + sm3_kat[i].inLen = 0; + sm3_kat[i].output = + "\x1a\xb2\x1d\x83\x55\xcf\xa1\x7f" + "\x8e\x61\x19\x48\x31\xe8\x1a\x8f" + "\x22\xbe\xc8\xc7\x28\xfe\xfb\x74" + "\x7e\xd0\x35\xeb\x50\x82\xaa\x2b"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = "a"; + sm3_kat[i].inLen = 1; + sm3_kat[i].output = + "\x62\x34\x76\xac\x18\xf6\x5a\x29" + "\x09\xe4\x3c\x7f\xec\x61\xb4\x9c" + "\x7e\x76\x4a\x91\xa1\x8c\xcb\x82" + "\xf1\x91\x7a\x29\xc8\x6c\x5e\x88"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = "abc"; + sm3_kat[i].inLen = 3; + sm3_kat[i].output = + "\x66\xc7\xf0\xf4\x62\xee\xed\xd9" + "\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2" + "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2" + "\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = "message digest"; + sm3_kat[i].inLen = 14; + sm3_kat[i].output = + "\xc5\x22\xa9\x42\xe8\x9b\xd8\x0d" + "\x97\xdd\x66\x6e\x7a\x55\x31\xb3" + "\x61\x88\xc9\x81\x71\x49\xe9\xb2" + "\x58\xdf\xe5\x1e\xce\x98\xed\x77"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = "abcdefghijklmnopqrstuvwxyz"; + sm3_kat[i].inLen = 26; + sm3_kat[i].output = + "\xb8\x0f\xe9\x7a\x4d\xa2\x4a\xfc" + "\x27\x75\x64\xf6\x6a\x35\x9e\xf4" + "\x40\x46\x2a\xd2\x8d\xcc\x6d\x63" + "\xad\xb2\x4d\x5c\x20\xa6\x15\x95"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789"; + sm3_kat[i].inLen = 62; + sm3_kat[i].output = + "\x29\x71\xd1\x0c\x88\x42\xb7\x0c" + "\x97\x9e\x55\x06\x34\x80\xc5\x0b" + "\xac\xff\xd9\x0e\x98\xe2\xe6\x0d" + "\x25\x12\xab\x8a\xbf\xdf\xce\xc5"; + sm3_kat[i].outLen = 0; + i++; + sm3_kat[i].input = "1234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890"; + sm3_kat[i].inLen = 80; + sm3_kat[i].output = + "\xad\x81\x80\x53\x21\xf3\xe6\x9d" + "\x25\x12\x35\xbf\x88\x6a\x56\x48" + "\x44\x87\x3b\x56\xdd\x7d\xde\x40" + "\x0f\x05\x5b\x7d\xde\x39\x30\x7a"; + sm3_kat[i].outLen = 0; + + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); + + for (i = 0; i < SM3_KAT_CNT; i++) { + /* Do KAT. */ + ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)sm3_kat[i].input, + (word32)sm3_kat[i].inLen), 0); ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); - ExpectIntEQ(wc_Sm3Final(&sm3Copy, hashCopy), 0); - ExpectBufEQ(hash, hashCopy, WC_SM3_DIGEST_SIZE); + ExpectBufEQ(hash, (byte*)sm3_kat[i].output, WC_SM3_DIGEST_SIZE); } - wc_Sm3Free(&sm3Copy); wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_Sm3Copy */ +} -/* - * Testing wc_Sm3FinalRaw() - */ -int test_wc_Sm3FinalRaw(void) +int test_wc_Sm3_other(void) { EXPECT_DECLS; -#if defined(WOLFSSL_SM3) && !defined(HAVE_SELFTEST) && \ - !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ - (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ - !defined(WOLFSSL_NO_HASH_RAW) +#ifdef WOLFSSL_SM3 wc_Sm3 sm3; - byte hash1[WC_SM3_DIGEST_SIZE]; - byte hash2[WC_SM3_DIGEST_SIZE]; - byte hash3[WC_SM3_DIGEST_SIZE]; - byte* hash_test[3] = { hash1, hash2, hash3 }; - int times; + byte hash[WC_SM3_DIGEST_SIZE + 1]; + byte data[WC_SM3_DIGEST_SIZE * 8 + 1]; + int dataLen = WC_SM3_DIGEST_SIZE * 8; + const char* expHash = + "\x76\x6e\x30\x64\x3f\x02\x26\x7f" + "\xb1\x94\x26\xd4\x41\xd1\xed\x87" + "\x40\x5a\x58\xa5\xaa\x65\xd6\x61" + "\xe9\x95\xcc\x5d\xdd\xe8\x49\x34"; int i; + int j; - XMEMSET(&sm3, 0, sizeof(sm3)); + XMEMSET(data, 0xa5, sizeof(data)); /* Initialize */ - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); - /* Invalid Parameters */ - ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3FinalRaw(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Sm3FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + /* Unaligned input and output buffer. */ + ExpectIntEQ(wc_Sm3Update(&sm3, data + 1, dataLen), 0); + ExpectIntEQ(wc_Sm3Final(&sm3, hash + 1), 0); + ExpectBufEQ(hash + 1, (byte*)expHash, WC_SM3_DIGEST_SIZE); - times = sizeof(hash_test) / sizeof(byte*); - for (i = 0; i < times; i++) { - ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash_test[i]), 0); + /* Test that empty updates work. */ + ExpectIntEQ(wc_Sm3Update(&sm3, NULL, 0), 0); + ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)"", 0), 0); + ExpectIntEQ(wc_Sm3Update(&sm3, data, dataLen), 0); + ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_SM3_DIGEST_SIZE); + + /* Ensure chunking works. */ + for (i = 1; i < dataLen; i++) { + for (j = 0; j < dataLen; j += i) { + int len = dataLen - j; + if (i < len) + len = i; + ExpectIntEQ(wc_Sm3Update(&sm3, data + j, len), 0); + } + ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); + ExpectBufEQ(hash, (byte*)expHash, WC_SM3_DIGEST_SIZE); } wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_Sm3FinalRaw */ +} -/* - * Testing wc_Sm3GetFlags, wc_Sm3SetFlags() - */ -int test_wc_Sm3GetSetFlags(void) +int test_wc_Sm3Copy(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SM3 + wc_Sm3 src; + wc_Sm3 dst; + byte hashSrc[WC_SM3_DIGEST_SIZE]; + byte hashDst[WC_SM3_DIGEST_SIZE]; + const char* emptyHash = + "\x1a\xb2\x1d\x83\x55\xcf\xa1\x7f" + "\x8e\x61\x19\x48\x31\xe8\x1a\x8f" + "\x22\xbe\xc8\xc7\x28\xfe\xfb\x74" + "\x7e\xd0\x35\xeb\x50\x82\xaa\x2b"; + const char* abcHash = + "\x66\xc7\xf0\xf4\x62\xee\xed\xd9" + "\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2" + "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2" + "\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0"; + byte data[WC_SM3_BLOCK_SIZE]; + + XMEMSET(data, 0xa5, sizeof(data)); + + ExpectIntEQ(wc_InitSm3(&src, HEAP_HINT, INVALID_DEVID), 0); + XMEMSET(&dst, 0, sizeof(dst)); + + ExpectIntEQ(wc_Sm3Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Copy(&src, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3Copy(NULL, &dst), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* Test copy works. */ + ExpectIntEQ(wc_Sm3Copy(&src, &dst), 0); + ExpectIntEQ(wc_Sm3Final(&src, hashSrc), 0); + ExpectIntEQ(wc_Sm3Final(&dst, hashDst), 0); + ExpectBufEQ(hashSrc, emptyHash, WC_SM3_DIGEST_SIZE); + ExpectBufEQ(hashDst, emptyHash, WC_SM3_DIGEST_SIZE); + wc_Sm3Free(&dst); + + /* Test buffered data is copied. */ + ExpectIntEQ(wc_Sm3Update(&src, (byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sm3Copy(&src, &dst), 0); + ExpectIntEQ(wc_Sm3Final(&src, hashSrc), 0); + ExpectIntEQ(wc_Sm3Final(&dst, hashDst), 0); + ExpectBufEQ(hashSrc, abcHash, WC_SM3_DIGEST_SIZE); + ExpectBufEQ(hashDst, abcHash, WC_SM3_DIGEST_SIZE); + wc_Sm3Free(&dst); + + /* Test count of length is copied. */ + ExpectIntEQ(wc_Sm3Update(&src, data, sizeof(data)), 0); + ExpectIntEQ(wc_Sm3Copy(&src, &dst), 0); + ExpectIntEQ(wc_Sm3Final(&src, hashSrc), 0); + ExpectIntEQ(wc_Sm3Final(&dst, hashDst), 0); + ExpectBufEQ(hashSrc, hashDst, WC_SM3_DIGEST_SIZE); + wc_Sm3Free(&dst); + + wc_Sm3Free(&src); +#endif + return EXPECT_RESULT(); +} + +int test_wc_Sm3GetHash(void) +{ + EXPECT_DECLS; +#ifdef WOLFSSL_SM3 + wc_Sm3 sm3; + byte hash[WC_SM3_DIGEST_SIZE]; + const char* emptyHash = + "\x1a\xb2\x1d\x83\x55\xcf\xa1\x7f" + "\x8e\x61\x19\x48\x31\xe8\x1a\x8f" + "\x22\xbe\xc8\xc7\x28\xfe\xfb\x74" + "\x7e\xd0\x35\xeb\x50\x82\xaa\x2b"; + const char* abcHash = + "\x66\xc7\xf0\xf4\x62\xee\xed\xd9" + "\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2" + "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2" + "\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0"; + + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); + + ExpectIntEQ(wc_Sm3GetHash(NULL, NULL), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3GetHash(&sm3, NULL), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wc_Sm3GetHash(NULL, hash), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectIntEQ(wc_Sm3GetHash(&sm3, hash), 0); + ExpectBufEQ(hash, emptyHash, WC_SM3_DIGEST_SIZE); + /* Test that the hash state hasn't been modified. */ + ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sm3GetHash(&sm3, hash), 0); + ExpectBufEQ(hash, abcHash, WC_SM3_DIGEST_SIZE); + + wc_Sm3Free(&sm3); +#endif + return EXPECT_RESULT(); +} + + +int test_wc_Sm3_Flags(void) { EXPECT_DECLS; #if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS) wc_Sm3 sm3; - wc_Sm3 sm3Copy; - word32 flags = 0; + wc_Sm3 sm3_copy; + word32 flags; - ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); - ExpectIntEQ(wc_InitSm3(&sm3Copy, NULL, INVALID_DEVID), 0); + XMEMSET(&sm3_copy, 0, sizeof(sm3_copy)); + ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0); + /* Do nothing. */ + ExpectIntEQ(wc_Sm3GetFlags(NULL, NULL), 0); + ExpectIntEQ(wc_Sm3GetFlags(&sm3, NULL), 0); ExpectIntEQ(wc_Sm3GetFlags(NULL, &flags), 0); + ExpectIntEQ(wc_Sm3SetFlags(NULL, 1), 0); + + ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0); ExpectIntEQ(flags, 0); - ExpectIntEQ(wc_Sm3SetFlags(NULL, WC_HASH_FLAG_WILLCOPY), 0); - ExpectIntEQ(wc_Sm3GetFlags(NULL, &flags), 0); - ExpectIntEQ(flags, 0); + + ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3_copy), 0); ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0); ExpectIntEQ(flags, 0); + ExpectIntEQ(wc_Sm3GetFlags(&sm3_copy, &flags), 0); + ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY); + ExpectIntEQ(wc_Sm3SetFlags(&sm3, WC_HASH_FLAG_WILLCOPY), 0); ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0); ExpectIntEQ(flags, WC_HASH_FLAG_WILLCOPY); + ExpectIntEQ(wc_Sm3SetFlags(&sm3, 0), 0); - ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3Copy), 0); - ExpectIntEQ(wc_Sm3GetFlags(&sm3Copy, &flags), 0); - ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY | WC_HASH_FLAG_WILLCOPY); - - wc_Sm3Free(&sm3Copy); + wc_Sm3Free(&sm3_copy); wc_Sm3Free(&sm3); #endif return EXPECT_RESULT(); -} /* END test_wc_Sm3Update */ +} /* * Testing wc_Sm3Hash() diff --git a/tests/api/test_sm3.h b/tests/api/test_sm3.h index 6980209345..f50fb8d23e 100644 --- a/tests/api/test_sm3.h +++ b/tests/api/test_sm3.h @@ -22,12 +22,15 @@ #ifndef WOLFCRYPT_TEST_SM3_H #define WOLFCRYPT_TEST_SM3_H -int test_wc_InitSm3Free(void); -int test_wc_Sm3UpdateFinal(void); -int test_wc_Sm3GetHash(void); -int test_wc_Sm3Copy(void); +int test_wc_InitSm3(void); +int test_wc_Sm3Update(void); +int test_wc_Sm3Final(void); int test_wc_Sm3FinalRaw(void); -int test_wc_Sm3GetSetFlags(void); +int test_wc_Sm3_KATs(void); +int test_wc_Sm3_other(void); +int test_wc_Sm3Copy(void); +int test_wc_Sm3GetHash(void); +int test_wc_Sm3_Flags(void); int test_wc_Sm3Hash(void); #endif /* WOLFCRYPT_TEST_SM3_H */ diff --git a/wolfcrypt/src/blake2b.c b/wolfcrypt/src/blake2b.c index 3d4c62095b..fed8eac38d 100644 --- a/wolfcrypt/src/blake2b.c +++ b/wolfcrypt/src/blake2b.c @@ -491,6 +491,16 @@ int wc_InitBlake2b_WithKey(Blake2b* b2b, word32 digestSz, const byte *key, word3 /* Blake2b Update */ int wc_Blake2bUpdate(Blake2b* b2b, const byte* data, word32 sz) { + if (b2b == NULL){ + return BAD_FUNC_ARG; + } + if (data == NULL && sz != 0){ + return BAD_FUNC_ARG; + } + if (sz == 0){ + return 0; + } + return blake2b_update(b2b->S, data, sz); } @@ -498,7 +508,16 @@ int wc_Blake2bUpdate(Blake2b* b2b, const byte* data, word32 sz) /* Blake2b Final, if pass in zero size we use init digestSz */ int wc_Blake2bFinal(Blake2b* b2b, byte* final, word32 requestSz) { - word32 sz = requestSz ? requestSz : b2b->digestSz; + word32 sz; + + if (b2b == NULL){ + return BAD_FUNC_ARG; + } + if (final == NULL){ + return BAD_FUNC_ARG; + } + + sz = requestSz ? requestSz : b2b->digestSz; return blake2b_final(b2b->S, final, (byte)sz); } diff --git a/wolfcrypt/src/blake2s.c b/wolfcrypt/src/blake2s.c index 25452bfb89..e55cf76400 100644 --- a/wolfcrypt/src/blake2s.c +++ b/wolfcrypt/src/blake2s.c @@ -487,6 +487,16 @@ int wc_InitBlake2s_WithKey(Blake2s* b2s, word32 digestSz, const byte *key, word3 /* Blake2s Update */ int wc_Blake2sUpdate(Blake2s* b2s, const byte* data, word32 sz) { + if (b2s == NULL){ + return BAD_FUNC_ARG; + } + if (data == NULL && sz != 0){ + return BAD_FUNC_ARG; + } + if (sz == 0){ + return 0; + } + return blake2s_update(b2s->S, data, sz); } @@ -494,7 +504,16 @@ int wc_Blake2sUpdate(Blake2s* b2s, const byte* data, word32 sz) /* Blake2s Final, if pass in zero size we use init digestSz */ int wc_Blake2sFinal(Blake2s* b2s, byte* final, word32 requestSz) { - word32 sz = requestSz ? requestSz : b2s->digestSz; + word32 sz; + + if (b2s == NULL){ + return BAD_FUNC_ARG; + } + if (final == NULL){ + return BAD_FUNC_ARG; + } + + sz = requestSz ? requestSz : b2s->digestSz; return blake2s_final(b2s->S, final, (byte)sz); } diff --git a/wolfcrypt/src/port/arm/armv8-sha256.c b/wolfcrypt/src/port/arm/armv8-sha256.c index 14ef1519ba..33df2a2f04 100644 --- a/wolfcrypt/src/port/arm/armv8-sha256.c +++ b/wolfcrypt/src/port/arm/armv8-sha256.c @@ -141,7 +141,7 @@ static const FLASH_QUALIFIER ALIGN32 word32 K[64] = { W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL, DYNAMIC_TYPE_DIGEST); if (W == NULL) - return MEMORY_E; + return; sha256->W = W; } #elif defined(WOLFSSL_SMALL_STACK) @@ -149,7 +149,7 @@ static const FLASH_QUALIFIER ALIGN32 word32 K[64] = { W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (W == NULL) - return MEMORY_E; + return; #else word32 W[WC_SHA256_BLOCK_SIZE]; #endif @@ -1914,6 +1914,10 @@ int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst) } #endif +#ifdef WOLFSSL_HASH_FLAGS + dst->flags |= WC_HASH_FLAG_ISCOPY; +#endif + return ret; } @@ -2143,6 +2147,10 @@ int wc_Sha256HashBlock(wc_Sha256* sha256, const unsigned char* data, XMEMCPY(dst, src, sizeof(wc_Sha224)); + #ifdef WOLFSSL_HASH_FLAGS + dst->flags |= WC_HASH_FLAG_ISCOPY; + #endif + return ret; } diff --git a/wolfcrypt/src/port/arm/armv8-sha512.c b/wolfcrypt/src/port/arm/armv8-sha512.c index a2f0943113..63f108aec6 100644 --- a/wolfcrypt/src/port/arm/armv8-sha512.c +++ b/wolfcrypt/src/port/arm/armv8-sha512.c @@ -621,7 +621,7 @@ static WC_INLINE int Sha512Final(wc_Sha512* sha512) #ifdef WOLFSSL_SHA512 -int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash) +static int Sha512FinalRaw(wc_Sha512* sha512, byte* hash, size_t digestSz) { #ifdef LITTLE_ENDIAN_ORDER word64 digest[WC_SHA512_DIGEST_SIZE / sizeof(word64)]; @@ -633,15 +633,20 @@ int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash) #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords64((word64*)digest, (word64*)sha512->digest, - WC_SHA512_DIGEST_SIZE); - XMEMCPY(hash, digest, WC_SHA512_DIGEST_SIZE); + WC_SHA512_DIGEST_SIZE); + XMEMCPY(hash, digest, digestSz); #else - XMEMCPY(hash, sha512->digest, WC_SHA512_DIGEST_SIZE); + XMEMCPY(hash, sha512->digest, digestSz); #endif return 0; } +int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash) +{ + return Sha512FinalRaw(sha512, hash, WC_SHA512_DIGEST_SIZE); +} + static int Sha512_Family_Final(wc_Sha512* sha512, byte* hash, enum wc_HashType type) { @@ -1039,7 +1044,7 @@ int wc_Sha512_224Update(wc_Sha512* sha, const byte* data, word32 len) } int wc_Sha512_224FinalRaw(wc_Sha512* sha, byte* hash) { - return wc_Sha512FinalRaw(sha, hash); + return Sha512FinalRaw(sha, hash, WC_SHA512_224_DIGEST_SIZE); } int wc_Sha512_224Final(wc_Sha512* sha512, byte* hash) { @@ -1089,7 +1094,7 @@ int wc_Sha512_256Update(wc_Sha512* sha, const byte* data, word32 len) } int wc_Sha512_256FinalRaw(wc_Sha512* sha, byte* hash) { - return wc_Sha512FinalRaw(sha, hash); + return Sha512FinalRaw(sha, hash, WC_SHA512_256_DIGEST_SIZE); } int wc_Sha512_256Final(wc_Sha512* sha512, byte* hash) { diff --git a/wolfcrypt/src/sha256.c b/wolfcrypt/src/sha256.c index dd722f9554..93b6afc546 100644 --- a/wolfcrypt/src/sha256.c +++ b/wolfcrypt/src/sha256.c @@ -2590,7 +2590,7 @@ int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst) #endif #ifdef WOLFSSL_HASH_FLAGS - dst->flags |= WC_HASH_FLAG_ISCOPY; + dst->flags |= WC_HASH_FLAG_ISCOPY; #endif #if defined(WOLFSSL_HASH_KEEP) diff --git a/wolfcrypt/src/sha3.c b/wolfcrypt/src/sha3.c index 3f2deae183..de4dbb94d4 100644 --- a/wolfcrypt/src/sha3.c +++ b/wolfcrypt/src/sha3.c @@ -761,7 +761,9 @@ static int Sha3Update(wc_Sha3* sha3, const byte* data, word32 len, byte p) if (SHA3_BLOCK == sha3_block_avx2) RESTORE_VECTOR_REGISTERS(); #endif - XMEMCPY(sha3->t, data, len); + if (len > 0) { + XMEMCPY(sha3->t, data, len); + } sha3->i = (byte)(sha3->i + len); return 0; @@ -1499,6 +1501,10 @@ int wc_Shake128_Absorb(wc_Shake* shake, const byte* data, word32 len) { int ret; + if ((shake == NULL) || (data == NULL && len != 0)) { + return BAD_FUNC_ARG; + } + ret = Sha3Update(shake, data, len, WC_SHA3_128_COUNT); if (ret == 0) { byte hash[1]; @@ -1526,6 +1532,9 @@ int wc_Shake128_Absorb(wc_Shake* shake, const byte* data, word32 len) */ int wc_Shake128_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt) { + if ((shake == NULL) || (out == NULL && blockCnt != 0)) { + return BAD_FUNC_ARG; + } #if defined(WOLFSSL_LINUXKM) && defined(USE_INTEL_SPEEDUP) if (SHA3_BLOCK == sha3_block_avx2) SAVE_VECTOR_REGISTERS(return _svr_ret;); @@ -1644,6 +1653,10 @@ int wc_Shake256_Absorb(wc_Shake* shake, const byte* data, word32 len) { int ret; + if ((shake == NULL) || (data == NULL && len != 0)) { + return BAD_FUNC_ARG; + } + ret = Sha3Update(shake, data, len, WC_SHA3_256_COUNT); if (ret == 0) { byte hash[1]; @@ -1664,6 +1677,9 @@ int wc_Shake256_Absorb(wc_Shake* shake, const byte* data, word32 len) */ int wc_Shake256_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt) { + if ((shake == NULL) || (out == NULL && blockCnt != 0)) { + return BAD_FUNC_ARG; + } #if defined(WOLFSSL_LINUXKM) && defined(USE_INTEL_SPEEDUP) if (SHA3_BLOCK == sha3_block_avx2) SAVE_VECTOR_REGISTERS(return _svr_ret;); diff --git a/wolfssl/wolfcrypt/blake2.h b/wolfssl/wolfcrypt/blake2.h index 679c7a63fd..5d42c15df5 100644 --- a/wolfssl/wolfcrypt/blake2.h +++ b/wolfssl/wolfcrypt/blake2.h @@ -49,10 +49,12 @@ enum { #ifdef HAVE_BLAKE2B BLAKE2B_ID = WC_HASH_TYPE_BLAKE2B, BLAKE2B_256 = 32, /* 256 bit type, SSL default */ + WC_BLAKE2B_DIGEST_SIZE = 64, #endif #ifdef HAVE_BLAKE2S BLAKE2S_ID = WC_HASH_TYPE_BLAKE2S, - BLAKE2S_256 = 32 /* 256 bit type */ + BLAKE2S_256 = 32, /* 256 bit type */ + WC_BLAKE2S_DIGEST_SIZE = 32 #endif };