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

Merge pull request #8501 from SparkiDev/digest_test_rework

Browse Source 
Digest testing: improve
This commit is contained in:
David Garske
2025-02-25 13:03:48 -08:00
committed by GitHub
parent f2c5b4e56a 6016cc0c97
commit 3557cc764a
26 changed files with 4231 additions and 2164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
tests/api.c
View File

@ -94105,103 +94105,158 @@ TEST_CASE testCases[] = {
TEST_DECL(test_wc_InitMd5), TEST_DECL(test_wc_InitMd5),
TEST_DECL(test_wc_Md5Update), TEST_DECL(test_wc_Md5Update),
TEST_DECL(test_wc_Md5Final), 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_InitSha),
TEST_DECL(test_wc_ShaUpdate), TEST_DECL(test_wc_ShaUpdate),
TEST_DECL(test_wc_ShaFinal), 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_sha256.c */
TEST_DECL(test_wc_InitSha256), TEST_DECL(test_wc_InitSha256),
TEST_DECL(test_wc_Sha256Update), TEST_DECL(test_wc_Sha256Update),
TEST_DECL(test_wc_Sha256Final), TEST_DECL(test_wc_Sha256Final),
TEST_DECL(test_wc_Sha256FinalRaw), TEST_DECL(test_wc_Sha256FinalRaw),
TEST_DECL(test_wc_Sha256GetFlags), TEST_DECL(test_wc_Sha256_KATs),
TEST_DECL(test_wc_Sha256Free), TEST_DECL(test_wc_Sha256_other),
TEST_DECL(test_wc_Sha256GetHash),
TEST_DECL(test_wc_Sha256Copy), 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_InitSha224),
TEST_DECL(test_wc_Sha224Update), TEST_DECL(test_wc_Sha224Update),
TEST_DECL(test_wc_Sha224Final), TEST_DECL(test_wc_Sha224Final),
TEST_DECL(test_wc_Sha224SetFlags), TEST_DECL(test_wc_Sha224_KATs),
TEST_DECL(test_wc_Sha224GetFlags), TEST_DECL(test_wc_Sha224_other),
TEST_DECL(test_wc_Sha224Free),
TEST_DECL(test_wc_Sha224GetHash),
TEST_DECL(test_wc_Sha224Copy), TEST_DECL(test_wc_Sha224Copy),
TEST_DECL(test_wc_Sha224GetHash),
TEST_DECL(test_wc_Sha224_Flags),
/* test_sha512.c */ /* test_sha512.c */
TEST_DECL(test_wc_InitSha512), TEST_DECL(test_wc_InitSha512),
TEST_DECL(test_wc_Sha512Update), TEST_DECL(test_wc_Sha512Update),
TEST_DECL(test_wc_Sha512Final), TEST_DECL(test_wc_Sha512Final),
TEST_DECL(test_wc_Sha512FinalRaw), TEST_DECL(test_wc_Sha512FinalRaw),
TEST_DECL(test_wc_Sha512GetFlags), TEST_DECL(test_wc_Sha512_KATs),
TEST_DECL(test_wc_Sha512Free), TEST_DECL(test_wc_Sha512_other),
TEST_DECL(test_wc_Sha512GetHash),
TEST_DECL(test_wc_Sha512Copy), 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_InitSha512_224),
TEST_DECL(test_wc_Sha512_224Update), TEST_DECL(test_wc_Sha512_224Update),
TEST_DECL(test_wc_Sha512_224Final), TEST_DECL(test_wc_Sha512_224Final),
TEST_DECL(test_wc_Sha512_224FinalRaw), TEST_DECL(test_wc_Sha512_224FinalRaw),
TEST_DECL(test_wc_Sha512_224GetFlags), TEST_DECL(test_wc_Sha512_224_KATs),
TEST_DECL(test_wc_Sha512_224Free), TEST_DECL(test_wc_Sha512_224_other),
TEST_DECL(test_wc_Sha512_224GetHash),
TEST_DECL(test_wc_Sha512_224Copy), 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_InitSha512_256),
TEST_DECL(test_wc_Sha512_256Update), TEST_DECL(test_wc_Sha512_256Update),
TEST_DECL(test_wc_Sha512_256Final), TEST_DECL(test_wc_Sha512_256Final),
TEST_DECL(test_wc_Sha512_256FinalRaw), TEST_DECL(test_wc_Sha512_256FinalRaw),
TEST_DECL(test_wc_Sha512_256GetFlags), TEST_DECL(test_wc_Sha512_256_KATs),
TEST_DECL(test_wc_Sha512_256Free), TEST_DECL(test_wc_Sha512_256_other),
TEST_DECL(test_wc_Sha512_256GetHash),
TEST_DECL(test_wc_Sha512_256Copy), 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_InitSha384),
TEST_DECL(test_wc_Sha384Update), TEST_DECL(test_wc_Sha384Update),
TEST_DECL(test_wc_Sha384Final), TEST_DECL(test_wc_Sha384Final),
TEST_DECL(test_wc_Sha384FinalRaw), TEST_DECL(test_wc_Sha384FinalRaw),
TEST_DECL(test_wc_Sha384GetFlags), TEST_DECL(test_wc_Sha384_KATs),
TEST_DECL(test_wc_Sha384Free), TEST_DECL(test_wc_Sha384_other),
TEST_DECL(test_wc_Sha384GetHash),
TEST_DECL(test_wc_Sha384Copy), TEST_DECL(test_wc_Sha384Copy),
TEST_DECL(test_wc_Sha384GetHash),
TEST_DECL(test_wc_Sha384_Flags),
/* test_sha3.c */ /* test_sha3.c */
TEST_DECL(test_wc_InitSha3), TEST_DECL(test_wc_InitSha3),
TEST_DECL(test_wc_Sha3_Update), TEST_DECL(test_wc_Sha3_Update),
TEST_DECL(test_wc_Sha3_224_Final), TEST_DECL(test_wc_Sha3_Final),
TEST_DECL(test_wc_Sha3_256_Final), TEST_DECL(test_wc_Sha3_224_KATs),
TEST_DECL(test_wc_Sha3_384_Final), TEST_DECL(test_wc_Sha3_256_KATs),
TEST_DECL(test_wc_Sha3_512_Final), TEST_DECL(test_wc_Sha3_384_KATs),
TEST_DECL(test_wc_Sha3_224_Copy), TEST_DECL(test_wc_Sha3_512_KATs),
TEST_DECL(test_wc_Sha3_256_Copy), TEST_DECL(test_wc_Sha3_other),
TEST_DECL(test_wc_Sha3_384_Copy), TEST_DECL(test_wc_Sha3_Copy),
TEST_DECL(test_wc_Sha3_512_Copy), TEST_DECL(test_wc_Sha3_GetHash),
TEST_DECL(test_wc_Sha3_GetFlags), 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_InitShake256),
TEST_DECL(test_wc_Shake256_Update), TEST_DECL(test_wc_Shake256_Update),
TEST_DECL(test_wc_Shake256_Final), 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_Shake256_Copy),
TEST_DECL(test_wc_Shake256Hash), 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_blake.c */
TEST_DECL(test_wc_InitBlake2b), TEST_DECL(test_wc_InitBlake2b),
TEST_DECL(test_wc_InitBlake2b_WithKey), 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_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_sm3.c: SM3 Digest */
TEST_DECL(test_wc_InitSm3Free), TEST_DECL(test_wc_InitSm3),
TEST_DECL(test_wc_Sm3UpdateFinal), TEST_DECL(test_wc_Sm3Update),
TEST_DECL(test_wc_Sm3GetHash), TEST_DECL(test_wc_Sm3Final),
TEST_DECL(test_wc_Sm3Copy),
TEST_DECL(test_wc_Sm3FinalRaw), 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_DECL(test_wc_Sm3Hash),
/* test_ripemd.c */ /* test_ripemd.c */
TEST_DECL(test_wc_InitRipeMd), TEST_DECL(test_wc_InitRipeMd),
TEST_DECL(test_wc_RipeMdUpdate), TEST_DECL(test_wc_RipeMdUpdate),
TEST_DECL(test_wc_RipeMdFinal), TEST_DECL(test_wc_RipeMdFinal),
TEST_DECL(test_wc_RipeMd_KATs),
TEST_DECL(test_wc_RipeMd_other),
/* test_hash.c */ /* test_hash.c */
TEST_DECL(test_wc_HashInit), TEST_DECL(test_wc_HashInit),

1
tests/api/include.am
View File

@ -26,6 +26,7 @@ EXTRA_DIST += tests/api/test_sha3.h
EXTRA_DIST += tests/api/test_blake2.h EXTRA_DIST += tests/api/test_blake2.h
EXTRA_DIST += tests/api/test_sm3.h EXTRA_DIST += tests/api/test_sm3.h
EXTRA_DIST += tests/api/test_ripemd.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_hash.h
EXTRA_DIST += tests/api/test_ascon.h EXTRA_DIST += tests/api/test_ascon.h
EXTRA_DIST += tests/api/test_ascon.h EXTRA_DIST += tests/api/test_ascon.h

485
tests/api/test_blake2.c
View File

@ -41,30 +41,30 @@
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_blake2.h> #include <tests/api/test_blake2.h>
/* /*******************************************************************************
* Unit test for the wc_InitBlake2b() * BLAKE2b
*/ ******************************************************************************/
int test_wc_InitBlake2b(void) int test_wc_InitBlake2b(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef HAVE_BLAKE2 #ifdef HAVE_BLAKE2
Blake2b blake; Blake2b blake;
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b(&blake, 64), 0);
/* Test bad arg. */ /* 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, 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, 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 #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_InitBlake2b*/ }
/*
* Unit test for the wc_InitBlake2b_WithKey()
*/
int test_wc_InitBlake2b_WithKey(void) int test_wc_InitBlake2b_WithKey(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
@ -76,21 +76,267 @@ int test_wc_InitBlake2b_WithKey(void)
XMEMSET(key, 0, sizeof(key)); XMEMSET(key, 0, sizeof(key));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0);
/* Test bad args. */ /* 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)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, 256), ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); 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, NULL, keylen), 0);
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0);
#endif #endif
return EXPECT_RESULT(); 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) int test_wc_InitBlake2s_WithKey(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
@ -100,15 +346,208 @@ int test_wc_InitBlake2s_WithKey(void)
byte *key = (byte*)"01234567890123456789012345678901"; byte *key = (byte*)"01234567890123456789012345678901";
word32 keylen = BLAKE2S_KEYBYTES; word32 keylen = BLAKE2S_KEYBYTES;
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0);
/* Test bad args. */ /* 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)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, 256), ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); 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, NULL, keylen), 0);
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END wc_InitBlake2s_WithKey*/ }
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();
}

10
tests/api/test_blake2.h
View File

@ -24,6 +24,16 @@
int test_wc_InitBlake2b(void); int test_wc_InitBlake2b(void);
int test_wc_InitBlake2b_WithKey(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_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 */ #endif /* WOLFCRYPT_TEST_BLAKE2_H */

692
tests/api/test_digest.h Normal file
View File

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

220
tests/api/test_md5.c
View File

@ -40,104 +40,138 @@
#include <tests/unit.h> #include <tests/unit.h>
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_md5.h> #include <tests/api/test_md5.h>
#include <tests/api/test_digest.h>
/* /* Unit test for wc_InitMd5() and wc_InitMd5_ex() */
* Unit test for the wc_InitMd5()
*/
int test_wc_InitMd5(void) int test_wc_InitMd5(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_MD5 #ifndef NO_MD5
wc_Md5 md5; DIGEST_INIT_AND_INIT_EX_TEST(wc_Md5, Md5);
#endif
/* Test good arg. */ return EXPECT_RESULT();
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)
wc_Md5Free(&md5); {
#endif EXPECT_DECLS;
return EXPECT_RESULT(); #ifndef NO_MD5
} /* END test_wc_InitMd5 */ DIGEST_UPDATE_TEST(wc_Md5, Md5);
#endif
return EXPECT_RESULT();
/* }
* Testing wc_UpdateMd5()
*/ /* Unit test for wc_Md5Final() */
int test_wc_Md5Update(void) int test_wc_Md5Final(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_MD5 #ifndef NO_MD5
wc_Md5 md5; DIGEST_FINAL_TEST(wc_Md5, Md5, MD5);
byte hash[WC_MD5_DIGEST_SIZE]; #endif
testVector a, b, c; return EXPECT_RESULT();
}
ExpectIntEQ(wc_InitMd5(&md5), 0);
#define MD5_KAT_CNT 7
/* Input */
a.input = "a"; int test_wc_Md5_KATs(void)
a.inLen = XSTRLEN(a.input); {
ExpectIntEQ(wc_Md5Update(&md5, (byte*)a.input, (word32)a.inLen), 0); EXPECT_DECLS;
ExpectIntEQ(wc_Md5Final(&md5, hash), 0); #ifndef NO_MD5
DIGEST_KATS_TEST_VARS(wc_Md5, MD5);
/* Update input. */
a.input = "abc"; /* From RFC 1321. */
a.output = "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f" DIGEST_KATS_ADD("", 0,
"\x72"; "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04"
a.inLen = XSTRLEN(a.input); "\xe9\x80\x09\x98\xec\xf8\x42\x7e");
a.outLen = XSTRLEN(a.output); DIGEST_KATS_ADD("a", 1,
ExpectIntEQ(wc_Md5Update(&md5, (byte*) a.input, (word32) a.inLen), 0); "\x0c\xc1\x75\xb9\xc0\xf1\xb6\xa8"
ExpectIntEQ(wc_Md5Final(&md5, hash), 0); "\x31\xc3\x99\xe2\x69\x77\x26\x61");
ExpectIntEQ(XMEMCMP(hash, a.output, WC_MD5_DIGEST_SIZE), 0); DIGEST_KATS_ADD("abc", 3,
"\x90\x01\x50\x98\x3c\xd2\x4f\xb0"
/* Pass in bad values. */ "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72");
b.input = NULL; DIGEST_KATS_ADD("message digest", 14,
b.inLen = 0; "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d"
ExpectIntEQ(wc_Md5Update(&md5, (byte*)b.input, (word32)b.inLen), 0); "\x52\x5a\x2f\x31\xaa\xf1\x61\xd0");
c.input = NULL; DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26,
c.inLen = WC_MD5_DIGEST_SIZE; "\xc3\xfc\xd3\xd7\x61\x92\xe4\x00"
ExpectIntEQ(wc_Md5Update(&md5, (byte*)c.input, (word32)c.inLen), "\x7d\xfb\x49\x6c\xca\x67\xe1\x3b");
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
ExpectIntEQ(wc_Md5Update(NULL, (byte*)a.input, (word32)a.inLen), "0123456789", 62,
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); "\xd1\x74\xab\x98\xd2\x77\xd9\xf5"
"\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f");
wc_Md5Free(&md5); DIGEST_KATS_ADD("1234567890123456789012345678901234567890"
#endif "1234567890123456789012345678901234567890", 80,
return EXPECT_RESULT(); "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55"
} /* END test_wc_Md5Update() */ "\xac\x49\xda\x2e\x21\x07\xb6\x7a");
/* DIGEST_KATS_TEST(Md5, MD5);
* Unit test on wc_Md5Final() in wolfcrypt/src/md5.c #endif
*/ return EXPECT_RESULT();
int test_wc_Md5Final(void) }
{
EXPECT_DECLS; int test_wc_Md5_other(void)
#ifndef NO_MD5 {
/* Instantiate */ EXPECT_DECLS;
wc_Md5 md5; #ifndef NO_MD5
byte* hash_test[3]; DIGEST_OTHER_TEST(wc_Md5, Md5, MD5,
byte hash1[WC_MD5_DIGEST_SIZE]; "\xd9\xa6\xc2\x1f\xf4\x05\xab\x62"
byte hash2[2*WC_MD5_DIGEST_SIZE]; "\xd6\xad\xa8\xcd\x0c\xb9\x49\x14");
byte hash3[5*WC_MD5_DIGEST_SIZE]; #endif
int times, i; return EXPECT_RESULT();
}
/* Initialize */
ExpectIntEQ(wc_InitMd5(&md5), 0); int test_wc_Md5Copy(void)
{
hash_test[0] = hash1; EXPECT_DECLS;
hash_test[1] = hash2; #ifndef NO_MD5
hash_test[2] = hash3; DIGEST_COPY_TEST(wc_Md5, Md5, MD5,
times = sizeof(hash_test)/sizeof(byte*); "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04"
for (i = 0; i < times; i++) { "\xe9\x80\x09\x98\xec\xf8\x42\x7e",
ExpectIntEQ(wc_Md5Final(&md5, hash_test[i]), 0); "\x90\x01\x50\x98\x3c\xd2\x4f\xb0"
} "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72");
#endif
/* Test bad args. */ return EXPECT_RESULT();
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)); int test_wc_Md5GetHash(void)
{
wc_Md5Free(&md5); 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 #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} }

6
tests/api/test_md5.h
View File

@ -25,5 +25,11 @@
int test_wc_InitMd5(void); int test_wc_InitMd5(void);
int test_wc_Md5Update(void); int test_wc_Md5Update(void);
int test_wc_Md5Final(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 */ #endif /* WOLFCRYPT_TEST_MD5_H */

190
tests/api/test_ripemd.c
View File

@ -40,6 +40,7 @@
#include <tests/unit.h> #include <tests/unit.h>
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_ripemd.h> #include <tests/api/test_ripemd.h>
#include <tests/api/test_digest.h>
/* /*
* Testing wc_InitRipeMd() * Testing wc_InitRipeMd()
@ -50,10 +51,11 @@ int test_wc_InitRipeMd(void)
#ifdef WOLFSSL_RIPEMD #ifdef WOLFSSL_RIPEMD
RipeMd ripemd; RipeMd ripemd;
/* Test good arg. */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
/* Test bad arg. */ /* Test bad arg. */
ExpectIntEQ(wc_InitRipeMd(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_InitRipeMd(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
@ -67,37 +69,20 @@ int test_wc_RipeMdUpdate(void)
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD #ifdef WOLFSSL_RIPEMD
RipeMd ripemd; RipeMd ripemd;
byte hash[RIPEMD_DIGEST_SIZE];
testVector a, b, c;
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
/* Input */ /* Test bad arg. */
a.input = "a"; ExpectIntEQ(wc_RipeMdUpdate(NULL , NULL, 1),
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),
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RipeMdUpdate(NULL, (byte*)a.input, (word32)a.inLen), ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 1),
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
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 #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_RipeMdUdpate */ } /* END test_wc_RipeMdUdpate */
@ -110,30 +95,149 @@ int test_wc_RipeMdFinal(void)
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD #ifdef WOLFSSL_RIPEMD
RipeMd ripemd; RipeMd ripemd;
byte* hash_test[3]; byte hash[RIPEMD_DIGEST_SIZE];
byte hash1[RIPEMD_DIGEST_SIZE];
byte hash2[2*RIPEMD_DIGEST_SIZE];
byte hash3[5*RIPEMD_DIGEST_SIZE];
int times, i;
/* Initialize */ /* Initialize */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0); 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. */ /* Test bad args. */
ExpectIntEQ(wc_RipeMdFinal(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); 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)); ExpectIntEQ(wc_RipeMdFinal(&ripemd, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good args. */
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_RipeMdFinal */ } /* 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();
}

2
tests/api/test_ripemd.h
View File

@ -25,5 +25,7 @@
int test_wc_InitRipeMd(void); int test_wc_InitRipeMd(void);
int test_wc_RipeMdUpdate(void); int test_wc_RipeMdUpdate(void);
int test_wc_RipeMdFinal(void); int test_wc_RipeMdFinal(void);
int test_wc_RipeMd_KATs(void);
int test_wc_RipeMd_other(void);
#endif /* WOLFCRYPT_TEST_RIPEMD_H */ #endif /* WOLFCRYPT_TEST_RIPEMD_H */

208
tests/api/test_sha.c
View File

@ -40,6 +40,7 @@
#include <tests/unit.h> #include <tests/unit.h>
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_sha.h> #include <tests/api/test_sha.h>
#include <tests/api/test_digest.h>
/* /*
* Unit test for the wc_InitSha() * Unit test for the wc_InitSha()
@ -48,14 +49,7 @@ int test_wc_InitSha(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA #ifndef NO_SHA
wc_Sha sha; DIGEST_INIT_AND_INIT_EX_TEST(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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_InitSha */ } /* END test_wc_InitSha */
@ -67,44 +61,7 @@ int test_wc_ShaUpdate(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA #ifndef NO_SHA
wc_Sha sha; DIGEST_UPDATE_TEST(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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_ShaUpdate() */ } /* END test_wc_ShaUpdate() */
@ -116,31 +73,142 @@ int test_wc_ShaFinal(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA #ifndef NO_SHA
wc_Sha sha; DIGEST_FINAL_TEST(wc_Sha, 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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_ShaFinal */ } /* 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();
}

7
tests/api/test_sha.h
View File

@ -25,5 +25,12 @@
int test_wc_InitSha(void); int test_wc_InitSha(void);
int test_wc_ShaUpdate(void); int test_wc_ShaUpdate(void);
int test_wc_ShaFinal(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 */ #endif /* WOLFCRYPT_TEST_SHA_H */

563
tests/api/test_sha256.c
View File

@ -40,121 +40,50 @@
#include <tests/unit.h> #include <tests/unit.h>
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_sha256.h> #include <tests/api/test_sha256.h>
#include <tests/api/test_digest.h>
/******************************************************************************* /*******************************************************************************
* SHA-256 * SHA-256
******************************************************************************/ ******************************************************************************/
/* /*
* Unit test for wc_InitSha256() * Unit test for the wc_InitSha256()
*/ */
int test_wc_InitSha256(void) int test_wc_InitSha256(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256 sha256; DIGEST_INIT_AND_INIT_EX_TEST(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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_InitSha256 */ } /* END test_wc_InitSha256 */
/* /*
* Unit test for wc_Sha256Update() * Tesing wc_Sha256Update()
*/ */
int test_wc_Sha256Update(void) int test_wc_Sha256Update(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256 sha256; DIGEST_UPDATE_TEST(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);
#endif #endif
return EXPECT_RESULT(); 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) int test_wc_Sha256Final(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256 sha256; DIGEST_FINAL_TEST(wc_Sha256, 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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha256Final */ } /* END test_wc_Sha256Final */
/* /*
* Unit test function for wc_Sha256FinalRaw() * Unit test on wc_Sha256FinalRaw
*/ */
int test_wc_Sha256FinalRaw(void) int test_wc_Sha256FinalRaw(void)
{ {
@ -163,341 +92,287 @@ int test_wc_Sha256FinalRaw(void)
!defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \ !defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \
!defined(WOLFSSL_NO_HASH_RAW) !defined(WOLFSSL_NO_HASH_RAW)
wc_Sha256 sha256; DIGEST_FINAL_RAW_TEST(wc_Sha256, Sha256, SHA256,
byte* hash_test[3]; "\x6a\x09\xe6\x67\xbb\x67\xae\x85"
byte hash1[WC_SHA256_DIGEST_SIZE]; "\x3c\x6e\xf3\x72\xa5\x4f\xf5\x3a"
byte hash2[2*WC_SHA256_DIGEST_SIZE]; "\x51\x0e\x52\x7f\x9b\x05\x68\x8c"
byte hash3[5*WC_SHA256_DIGEST_SIZE]; "\x1f\x83\xd9\xab\x5b\xe0\xcd\x19");
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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha256Final */
} /* END test_wc_Sha256FinalRaw */ #define SHA256_KAT_CNT 7
int test_wc_Sha256_KATs(void)
/*
* Unit test function for wc_Sha256GetFlags()
*/
int test_wc_Sha256GetFlags(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);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256GetFlags */
/*
* Unit test function for wc_Sha256Free()
*/
int test_wc_Sha256Free(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256Free(NULL); DIGEST_KATS_TEST_VARS(wc_Sha256, SHA256);
/* Set result to SUCCESS. */
ExpectTrue(1); 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 #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha256Free */ } /* END test_wc_Sha256Final */
/*
* Unit test function for wc_Sha256GetHash() int test_wc_Sha256_other(void)
*/
int test_wc_Sha256GetHash(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256 sha256; DIGEST_OTHER_TEST(wc_Sha256, Sha256, SHA256,
byte hash1[WC_SHA256_DIGEST_SIZE]; "\x2c\x41\xa1\xdd\x58\x4e\x37\x73"
"\xb9\x56\x74\x84\x1b\x68\x5f\x36"
/* Initialize */ "\xc7\x6b\x48\xec\x4d\xb7\x58\x63"
ExpectIntEQ(wc_InitSha256(&sha256), 0); "\x37\x2c\x2f\xd6\xe1\x9a\x61\xce");
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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha256GetHash */ } /* END test_wc_Sha256Final */
/*
* Unit test function for wc_Sha256Copy()
*/
int test_wc_Sha256Copy(void) int test_wc_Sha256Copy(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifndef NO_SHA256 #ifndef NO_SHA256
wc_Sha256 sha256; DIGEST_COPY_TEST(wc_Sha256, Sha256, SHA256,
wc_Sha256 temp; "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14"
"\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24"
XMEMSET(&sha256, 0, sizeof(sha256)); "\x27\xae\x41\xe4\x64\x9b\x93\x4c"
XMEMSET(&temp, 0, sizeof(temp)); "\xa4\x95\x99\x1b\x78\x52\xb8\x55",
"\xba\x78\x16\xbf\x8f\x01\xcf\xea"
/* Initialize */ "\x41\x41\x40\xde\x5d\xae\x22\x23"
ExpectIntEQ(wc_InitSha256(&sha256), 0); "\xb0\x03\x61\xa3\x96\x17\x7a\x9c"
ExpectIntEQ(wc_InitSha256(&temp), 0); "\xb4\x10\xff\x61\xf2\x00\x15\xad");
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));
wc_Sha256Free(&sha256);
wc_Sha256Free(&temp);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha256Copy */ }
int test_wc_Sha256GetHash(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
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();
}
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();
}
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 * SHA-224
******************************************************************************/ ******************************************************************************/
/* /*
* Testing wc_InitSha224(); * Unit test for the wc_InitSha224()
*/ */
int test_wc_InitSha224(void) int test_wc_InitSha224(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224 sha224; DIGEST_INIT_AND_INIT_EX_TEST(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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_InitSha224 */ } /* END test_wc_InitSha224 */
/* /*
* Unit test on wc_Sha224Update * Tesing wc_Sha224Update()
*/ */
int test_wc_Sha224Update(void) int test_wc_Sha224Update(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224 sha224; DIGEST_UPDATE_TEST(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);
#endif #endif
return EXPECT_RESULT(); 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) int test_wc_Sha224Final(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224 sha224; DIGEST_FINAL_TEST(wc_Sha224, 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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha224Final */ } /* END test_wc_Sha224Final */
/* #define SHA224_KAT_CNT 7
* Unit test function for wc_Sha224SetFlags() int test_wc_Sha224_KATs(void)
*/
int test_wc_Sha224SetFlags(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);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224SetFlags */
/*
* Unit test function for wc_Sha224GetFlags()
*/
int test_wc_Sha224GetFlags(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);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224GetFlags */
/*
* Unit test function for wc_Sha224Free()
*/
int test_wc_Sha224Free(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224Free(NULL); DIGEST_KATS_TEST_VARS(wc_Sha224, SHA224);
/* Set result to SUCCESS. */
ExpectTrue(1); 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 #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha224Final */
} /* END test_wc_Sha224Free */ int test_wc_Sha224_other(void)
/*
* Unit test function for wc_Sha224GetHash()
*/
int test_wc_Sha224GetHash(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224 sha224; DIGEST_OTHER_TEST(wc_Sha224, Sha224, SHA224,
byte hash1[WC_SHA224_DIGEST_SIZE]; "\x60\x81\xdf\x2f\xae\xe2\x25\xe9"
"\x87\x61\x2a\x8e\x25\x19\x16\x39"
/* Initialize */ "\x80\xfb\x77\xfa\x28\x74\x17\x4d"
ExpectIntEQ(wc_InitSha224(&sha224), 0); "\xf3\x15\x52\x2b");
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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha224GetHash */ } /* END test_wc_Sha224Final */
/*
* Unit test function for wc_Sha224Copy()
*/
int test_wc_Sha224Copy(void) int test_wc_Sha224Copy(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
wc_Sha224 sha224; DIGEST_COPY_TEST(wc_Sha224, Sha224, SHA224,
wc_Sha224 temp; "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9"
"\x47\x61\x02\xbb\x28\x82\x34\xc4"
XMEMSET(&sha224, 0, sizeof(wc_Sha224)); "\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a"
XMEMSET(&temp, 0, sizeof(wc_Sha224)); "\xc5\xb3\xe4\x2f",
"\x23\x09\x7d\x22\x34\x05\xd8\x22"
/* Initialize */ "\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
ExpectIntEQ(wc_InitSha224(&sha224), 0); "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7"
ExpectIntEQ(wc_InitSha224(&temp), 0); "\xe3\x6c\x9d\xa7");
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);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sha224Copy */ }
int test_wc_Sha224GetHash(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_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();
}
int test_wc_Sha224_Flags(void)
{
EXPECT_DECLS;
#if defined(WOLFSSL_SHA224) && defined(WOLFSSL_HASH_FLAGS)
DIGEST_FLAGS_TEST(wc_Sha224, Sha224);
#endif
return EXPECT_RESULT();
}

16
tests/api/test_sha256.h
View File

@ -26,18 +26,20 @@ int test_wc_InitSha256(void);
int test_wc_Sha256Update(void); int test_wc_Sha256Update(void);
int test_wc_Sha256Final(void); int test_wc_Sha256Final(void);
int test_wc_Sha256FinalRaw(void); int test_wc_Sha256FinalRaw(void);
int test_wc_Sha256GetFlags(void); int test_wc_Sha256_KATs(void);
int test_wc_Sha256Free(void); int test_wc_Sha256_other(void);
int test_wc_Sha256GetHash(void);
int test_wc_Sha256Copy(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_InitSha224(void);
int test_wc_Sha224Update(void); int test_wc_Sha224Update(void);
int test_wc_Sha224Final(void); int test_wc_Sha224Final(void);
int test_wc_Sha224SetFlags(void); int test_wc_Sha224_KATs(void);
int test_wc_Sha224GetFlags(void); int test_wc_Sha224_other(void);
int test_wc_Sha224Free(void);
int test_wc_Sha224GetHash(void);
int test_wc_Sha224Copy(void); int test_wc_Sha224Copy(void);
int test_wc_Sha224GetHash(void);
int test_wc_Sha224_Flags(void);
#endif /* WOLFCRYPT_TEST_SHA256_H */ #endif /* WOLFCRYPT_TEST_SHA256_H */

1826
tests/api/test_sha3.c
View File

File diff suppressed because it is too large Load Diff

34
tests/api/test_sha3.h
View File

@ -24,20 +24,36 @@
int test_wc_InitSha3(void); int test_wc_InitSha3(void);
int test_wc_Sha3_Update(void); int test_wc_Sha3_Update(void);
int test_wc_Sha3_224_Final(void); int test_wc_Sha3_Final(void);
int test_wc_Sha3_256_Final(void); int test_wc_Sha3_224_KATs(void);
int test_wc_Sha3_384_Final(void); int test_wc_Sha3_256_KATs(void);
int test_wc_Sha3_512_Final(void); int test_wc_Sha3_384_KATs(void);
int test_wc_Sha3_224_Copy(void); int test_wc_Sha3_512_KATs(void);
int test_wc_Sha3_256_Copy(void); int test_wc_Sha3_other(void);
int test_wc_Sha3_384_Copy(void); int test_wc_Sha3_Copy(void);
int test_wc_Sha3_512_Copy(void); int test_wc_Sha3_GetHash(void);
int test_wc_Sha3_GetFlags(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_InitShake256(void);
int test_wc_Shake256_Update(void); int test_wc_Shake256_Update(void);
int test_wc_Shake256_Final(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_Shake256_Copy(void);
int test_wc_Shake256Hash(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 */ #endif /* WOLFCRYPT_TEST_SHA3_H */

1379
tests/api/test_sha512.c
View File

File diff suppressed because it is too large Load Diff

31
tests/api/test_sha512.h
View File

@ -26,36 +26,43 @@ int test_wc_InitSha512(void);
int test_wc_Sha512Update(void); int test_wc_Sha512Update(void);
int test_wc_Sha512Final(void); int test_wc_Sha512Final(void);
int test_wc_Sha512FinalRaw(void); int test_wc_Sha512FinalRaw(void);
int test_wc_Sha512GetFlags(void); int test_wc_Sha512_KATs(void);
int test_wc_Sha512Free(void); int test_wc_Sha512_other(void);
int test_wc_Sha512GetHash(void);
int test_wc_Sha512Copy(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_InitSha512_224(void);
int test_wc_Sha512_224Update(void); int test_wc_Sha512_224Update(void);
int test_wc_Sha512_224Final(void); int test_wc_Sha512_224Final(void);
int test_wc_Sha512_224FinalRaw(void); int test_wc_Sha512_224FinalRaw(void);
int test_wc_Sha512_224GetFlags(void); int test_wc_Sha512_224_KATs(void);
int test_wc_Sha512_224Free(void); int test_wc_Sha512_224_other(void);
int test_wc_Sha512_224GetHash(void);
int test_wc_Sha512_224Copy(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_InitSha512_256(void);
int test_wc_Sha512_256Update(void); int test_wc_Sha512_256Update(void);
int test_wc_Sha512_256Final(void); int test_wc_Sha512_256Final(void);
int test_wc_Sha512_256FinalRaw(void); int test_wc_Sha512_256FinalRaw(void);
int test_wc_Sha512_256GetFlags(void); int test_wc_Sha512_256_KATs(void);
int test_wc_Sha512_256Free(void); int test_wc_Sha512_256_other(void);
int test_wc_Sha512_256GetHash(void);
int test_wc_Sha512_256Copy(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_InitSha384(void);
int test_wc_Sha384Update(void); int test_wc_Sha384Update(void);
int test_wc_Sha384Final(void); int test_wc_Sha384Final(void);
int test_wc_Sha384FinalRaw(void); int test_wc_Sha384FinalRaw(void);
int test_wc_Sha384GetFlags(void); int test_wc_Sha384_KATs(void);
int test_wc_Sha384Free(void); int test_wc_Sha384_other(void);
int test_wc_Sha384GetHash(void);
int test_wc_Sha384Copy(void); int test_wc_Sha384Copy(void);
int test_wc_Sha384GetHash(void);
int test_wc_Sha384_Flags(void);
#endif /* WOLFCRYPT_TEST_SHA512_H */ #endif /* WOLFCRYPT_TEST_SHA512_H */

496
tests/api/test_sm3.c
View File

@ -40,181 +40,77 @@
#include <tests/unit.h> #include <tests/unit.h>
#include <tests/api/api.h> #include <tests/api/api.h>
#include <tests/api/test_sm3.h> #include <tests/api/test_sm3.h>
#include <tests/api/test_digest.h>
/*
* Testing wc_InitSm3(), wc_Sm3Free() int test_wc_InitSm3(void)
*/
int test_wc_InitSm3Free(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SM3 #ifdef WOLFSSL_SM3
wc_Sm3 sm3; wc_Sm3 sm3;
/* Invalid Parameters */ /* Test bad arg. */
ExpectIntEQ(wc_InitSm3(NULL, NULL, INVALID_DEVID), ExpectIntEQ(wc_InitSm3(NULL, HEAP_HINT, INVALID_DEVID),
WC_NO_ERR_TRACE(BAD_FUNC_ARG)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Valid Parameters */ /* Test good arg. */
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
wc_Sm3Free(&sm3);
wc_Sm3Free(NULL); wc_Sm3Free(NULL);
wc_Sm3Free(&sm3);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_InitSm3 */ }
/* int test_wc_Sm3Update(void)
* Testing wc_Sm3Update(), wc_Sm3Final()
*/
int test_wc_Sm3UpdateFinal(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
#ifdef WOLFSSL_SM3 #ifdef WOLFSSL_SM3
wc_Sm3 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)); /* Initialize */
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); /* 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));
/* 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, NULL, 0), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, data, 1), 0); ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)"a", 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 */ wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
}
int test_wc_Sm3Final(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SM3
wc_Sm3 sm3;
byte hash[WC_SM3_DIGEST_SIZE];
/* Initialize */
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
/* Test bad args. */
ExpectIntEQ(wc_Sm3Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); 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(&sm3, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_Sm3Final(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Valid Parameters */ /* Test good args. */
ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0); ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0);
ExpectBufEQ(hash, expHash, WC_SM3_DIGEST_SIZE);
/* 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);
}
/* Not testing when the low 32-bit length overflows. */
wc_Sm3Free(&sm3); wc_Sm3Free(&sm3);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sm3Update */ }
/*
* Testing wc_Sm3GetHash()
*/
int test_wc_Sm3GetHash(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));
/* Valid Parameters */
ExpectIntEQ(wc_Sm3GetHash(&sm3, hash), 0);
ExpectBufEQ(hash, calcHash, WC_SM3_DIGEST_SIZE);
/* 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);
wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sm3Update */
/*
* Testing wc_Sm3Copy()
*/
int test_wc_Sm3Copy(void)
{
EXPECT_DECLS;
#if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS)
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;
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_InitSm3(&sm3Copy, NULL, 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);
ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0);
ExpectIntEQ(wc_Sm3Final(&sm3Copy, hashCopy), 0);
ExpectBufEQ(hash, hashCopy, 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_Sm3FinalRaw(void)
{ {
EXPECT_DECLS; EXPECT_DECLS;
@ -223,67 +119,309 @@ int test_wc_Sm3FinalRaw(void)
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \ (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \
!defined(WOLFSSL_NO_HASH_RAW) !defined(WOLFSSL_NO_HASH_RAW)
wc_Sm3 sm3; wc_Sm3 sm3;
byte hash1[WC_SM3_DIGEST_SIZE]; byte hash[WC_SM3_DIGEST_SIZE];
byte hash2[WC_SM3_DIGEST_SIZE]; const char* expHash =
byte hash3[WC_SM3_DIGEST_SIZE]; "\x73\x80\x16\x6f\x49\x14\xb2\xb9"
byte* hash_test[3] = { hash1, hash2, hash3 }; "\x17\x24\x42\xd7\xda\x8a\x06\x00"
int times; "\xa9\x6f\x30\xbc\x16\x31\x38\xaa"
int i; "\xe3\x8d\xee\x4d\xb0\xfb\x0e\x4e";
XMEMSET(&sm3, 0, sizeof(sm3));
/* Initialize */ /* Initialize */
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
/* Invalid Parameters */ /* Test bad args. */
ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL),
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3FinalRaw(NULL, hash1), 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));
times = sizeof(hash_test) / sizeof(byte*); /* Test good args. */
for (i = 0; i < times; i++) { ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash), 0);
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash_test[i]), 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);
ExpectBufEQ(hash, (byte*)sm3_kat[i].output, WC_SM3_DIGEST_SIZE);
} }
wc_Sm3Free(&sm3); wc_Sm3Free(&sm3);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sm3FinalRaw */ }
/* int test_wc_Sm3_other(void)
* Testing wc_Sm3GetFlags, wc_Sm3SetFlags() {
*/ EXPECT_DECLS;
int test_wc_Sm3GetSetFlags(void) #ifdef WOLFSSL_SM3
wc_Sm3 sm3;
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(data, 0xa5, sizeof(data));
/* Initialize */
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
/* 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);
/* 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();
}
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; EXPECT_DECLS;
#if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS) #if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS)
wc_Sm3 sm3; wc_Sm3 sm3;
wc_Sm3 sm3Copy; wc_Sm3 sm3_copy;
word32 flags = 0; word32 flags;
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0); XMEMSET(&sm3_copy, 0, sizeof(sm3_copy));
ExpectIntEQ(wc_InitSm3(&sm3Copy, NULL, INVALID_DEVID), 0); 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_Sm3GetFlags(NULL, &flags), 0);
ExpectIntEQ(flags, 0); ExpectIntEQ(wc_Sm3SetFlags(NULL, 1), 0);
ExpectIntEQ(wc_Sm3SetFlags(NULL, WC_HASH_FLAG_WILLCOPY), 0);
ExpectIntEQ(wc_Sm3GetFlags(NULL, &flags), 0);
ExpectIntEQ(flags, 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0); ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0);
ExpectIntEQ(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_Sm3SetFlags(&sm3, WC_HASH_FLAG_WILLCOPY), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0); ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0);
ExpectIntEQ(flags, WC_HASH_FLAG_WILLCOPY); ExpectIntEQ(flags, WC_HASH_FLAG_WILLCOPY);
ExpectIntEQ(wc_Sm3SetFlags(&sm3, 0), 0);
ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3Copy), 0); wc_Sm3Free(&sm3_copy);
ExpectIntEQ(wc_Sm3GetFlags(&sm3Copy, &flags), 0);
ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY | WC_HASH_FLAG_WILLCOPY);
wc_Sm3Free(&sm3Copy);
wc_Sm3Free(&sm3); wc_Sm3Free(&sm3);
#endif #endif
return EXPECT_RESULT(); return EXPECT_RESULT();
} /* END test_wc_Sm3Update */ }
/* /*
* Testing wc_Sm3Hash() * Testing wc_Sm3Hash()

13
tests/api/test_sm3.h
View File

@ -22,12 +22,15 @@
#ifndef WOLFCRYPT_TEST_SM3_H #ifndef WOLFCRYPT_TEST_SM3_H
#define WOLFCRYPT_TEST_SM3_H #define WOLFCRYPT_TEST_SM3_H
int test_wc_InitSm3Free(void); int test_wc_InitSm3(void);
int test_wc_Sm3UpdateFinal(void); int test_wc_Sm3Update(void);
int test_wc_Sm3GetHash(void); int test_wc_Sm3Final(void);
int test_wc_Sm3Copy(void);
int test_wc_Sm3FinalRaw(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); int test_wc_Sm3Hash(void);
#endif /* WOLFCRYPT_TEST_SM3_H */ #endif /* WOLFCRYPT_TEST_SM3_H */

21
wolfcrypt/src/blake2b.c
View File

@ -491,6 +491,16 @@ int wc_InitBlake2b_WithKey(Blake2b* b2b, word32 digestSz, const byte *key, word3
/* Blake2b Update */ /* Blake2b Update */
int wc_Blake2bUpdate(Blake2b* b2b, const byte* data, word32 sz) 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); 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 */ /* Blake2b Final, if pass in zero size we use init digestSz */
int wc_Blake2bFinal(Blake2b* b2b, byte* final, word32 requestSz) 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); return blake2b_final(b2b->S, final, (byte)sz);
} }

21
wolfcrypt/src/blake2s.c
View File

@ -487,6 +487,16 @@ int wc_InitBlake2s_WithKey(Blake2s* b2s, word32 digestSz, const byte *key, word3
/* Blake2s Update */ /* Blake2s Update */
int wc_Blake2sUpdate(Blake2s* b2s, const byte* data, word32 sz) 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); 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 */ /* Blake2s Final, if pass in zero size we use init digestSz */
int wc_Blake2sFinal(Blake2s* b2s, byte* final, word32 requestSz) 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); return blake2s_final(b2s->S, final, (byte)sz);
} }

12
wolfcrypt/src/port/arm/armv8-sha256.c
View File

@ -141,7 +141,7 @@ static const FLASH_QUALIFIER ALIGN32 word32 K[64] = {
W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL, W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL,
DYNAMIC_TYPE_DIGEST); DYNAMIC_TYPE_DIGEST);
if (W == NULL) if (W == NULL)
return MEMORY_E; return;
sha256->W = W; sha256->W = W;
} }
#elif defined(WOLFSSL_SMALL_STACK) #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, W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
if (W == NULL) if (W == NULL)
return MEMORY_E; return;
#else #else
word32 W[WC_SHA256_BLOCK_SIZE]; word32 W[WC_SHA256_BLOCK_SIZE];
#endif #endif
@ -1914,6 +1914,10 @@ int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst)
} }
#endif #endif
#ifdef WOLFSSL_HASH_FLAGS
dst->flags |= WC_HASH_FLAG_ISCOPY;
#endif
return ret; return ret;
} }
@ -2143,6 +2147,10 @@ int wc_Sha256HashBlock(wc_Sha256* sha256, const unsigned char* data,
XMEMCPY(dst, src, sizeof(wc_Sha224)); XMEMCPY(dst, src, sizeof(wc_Sha224));
#ifdef WOLFSSL_HASH_FLAGS
dst->flags |= WC_HASH_FLAG_ISCOPY;
#endif
return ret; return ret;
} }

17
wolfcrypt/src/port/arm/armv8-sha512.c
View File

@ -621,7 +621,7 @@ static WC_INLINE int Sha512Final(wc_Sha512* sha512)
#ifdef WOLFSSL_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 #ifdef LITTLE_ENDIAN_ORDER
word64 digest[WC_SHA512_DIGEST_SIZE / sizeof(word64)]; word64 digest[WC_SHA512_DIGEST_SIZE / sizeof(word64)];
@ -633,15 +633,20 @@ int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash)
#ifdef LITTLE_ENDIAN_ORDER #ifdef LITTLE_ENDIAN_ORDER
ByteReverseWords64((word64*)digest, (word64*)sha512->digest, ByteReverseWords64((word64*)digest, (word64*)sha512->digest,
WC_SHA512_DIGEST_SIZE); WC_SHA512_DIGEST_SIZE);
XMEMCPY(hash, digest, WC_SHA512_DIGEST_SIZE); XMEMCPY(hash, digest, digestSz);
#else #else
XMEMCPY(hash, sha512->digest, WC_SHA512_DIGEST_SIZE); XMEMCPY(hash, sha512->digest, digestSz);
#endif #endif
return 0; 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, static int Sha512_Family_Final(wc_Sha512* sha512, byte* hash,
enum wc_HashType type) 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) 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) 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) 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) int wc_Sha512_256Final(wc_Sha512* sha512, byte* hash)
{ {

2
wolfcrypt/src/sha256.c
View File

@ -2590,7 +2590,7 @@ int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst)
#endif #endif
#ifdef WOLFSSL_HASH_FLAGS #ifdef WOLFSSL_HASH_FLAGS
dst->flags |= WC_HASH_FLAG_ISCOPY; dst->flags |= WC_HASH_FLAG_ISCOPY;
#endif #endif
#if defined(WOLFSSL_HASH_KEEP) #if defined(WOLFSSL_HASH_KEEP)

18
wolfcrypt/src/sha3.c
View File

@ -761,7 +761,9 @@ static int Sha3Update(wc_Sha3* sha3, const byte* data, word32 len, byte p)
if (SHA3_BLOCK == sha3_block_avx2) if (SHA3_BLOCK == sha3_block_avx2)
RESTORE_VECTOR_REGISTERS(); RESTORE_VECTOR_REGISTERS();
#endif #endif
XMEMCPY(sha3->t, data, len); if (len > 0) {
XMEMCPY(sha3->t, data, len);
}
sha3->i = (byte)(sha3->i + len); sha3->i = (byte)(sha3->i + len);
return 0; return 0;
@ -1499,6 +1501,10 @@ int wc_Shake128_Absorb(wc_Shake* shake, const byte* data, word32 len)
{ {
int ret; int ret;
if ((shake == NULL) || (data == NULL && len != 0)) {
return BAD_FUNC_ARG;
}
ret = Sha3Update(shake, data, len, WC_SHA3_128_COUNT); ret = Sha3Update(shake, data, len, WC_SHA3_128_COUNT);
if (ret == 0) { if (ret == 0) {
byte hash[1]; 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) 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 defined(WOLFSSL_LINUXKM) && defined(USE_INTEL_SPEEDUP)
if (SHA3_BLOCK == sha3_block_avx2) if (SHA3_BLOCK == sha3_block_avx2)
SAVE_VECTOR_REGISTERS(return _svr_ret;); SAVE_VECTOR_REGISTERS(return _svr_ret;);
@ -1644,6 +1653,10 @@ int wc_Shake256_Absorb(wc_Shake* shake, const byte* data, word32 len)
{ {
int ret; int ret;
if ((shake == NULL) || (data == NULL && len != 0)) {
return BAD_FUNC_ARG;
}
ret = Sha3Update(shake, data, len, WC_SHA3_256_COUNT); ret = Sha3Update(shake, data, len, WC_SHA3_256_COUNT);
if (ret == 0) { if (ret == 0) {
byte hash[1]; 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) 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 defined(WOLFSSL_LINUXKM) && defined(USE_INTEL_SPEEDUP)
if (SHA3_BLOCK == sha3_block_avx2) if (SHA3_BLOCK == sha3_block_avx2)
SAVE_VECTOR_REGISTERS(return _svr_ret;); SAVE_VECTOR_REGISTERS(return _svr_ret;);

4
wolfssl/wolfcrypt/blake2.h
View File

@ -49,10 +49,12 @@ enum {
#ifdef HAVE_BLAKE2B #ifdef HAVE_BLAKE2B
BLAKE2B_ID = WC_HASH_TYPE_BLAKE2B, BLAKE2B_ID = WC_HASH_TYPE_BLAKE2B,
BLAKE2B_256 = 32, /* 256 bit type, SSL default */ BLAKE2B_256 = 32, /* 256 bit type, SSL default */
WC_BLAKE2B_DIGEST_SIZE = 64,
#endif #endif
#ifdef HAVE_BLAKE2S #ifdef HAVE_BLAKE2S
BLAKE2S_ID = WC_HASH_TYPE_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 #endif
}; };