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

Digest testing: improve

Browse Source 
Make testing digests consistent.
Add KATs for all digests.
Check unaligned input and output works.
Perform chunking tests for all digests.

Fix Blake2b and Blake2s to checkout parameters in update and final
functions.
Fix Shake256 and Shake128 to checkout parameters in absorb and squeeze
blocks functions.

Add default digest size enums for Blake2b and Blake2s.
This commit is contained in:
Sean Parkinson
2025-02-25 08:50:41 +10:00
parent be5f203274
commit 6016cc0c97
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

@@ -98724,103 +98724,158 @@ TEST_CASE testCases[] = {
TEST_DECL(test_wc_InitMd5),
TEST_DECL(test_wc_Md5Update),
TEST_DECL(test_wc_Md5Final),
TEST_DECL(test_wc_Md5_KATs),
TEST_DECL(test_wc_Md5_other),
TEST_DECL(test_wc_Md5Copy),
TEST_DECL(test_wc_Md5GetHash),
TEST_DECL(test_wc_Md5Transform),
TEST_DECL(test_wc_Md5_Flags),
/* test_sha.c */
TEST_DECL(test_wc_InitSha),
TEST_DECL(test_wc_ShaUpdate),
TEST_DECL(test_wc_ShaFinal),
TEST_DECL(test_wc_ShaFinalRaw),
TEST_DECL(test_wc_Sha_KATs),
TEST_DECL(test_wc_Sha_other),
TEST_DECL(test_wc_ShaCopy),
TEST_DECL(test_wc_ShaGetHash),
TEST_DECL(test_wc_ShaTransform),
TEST_DECL(test_wc_Sha_Flags),
/* test_sha256.c */
TEST_DECL(test_wc_InitSha256),
TEST_DECL(test_wc_Sha256Update),
TEST_DECL(test_wc_Sha256Final),
TEST_DECL(test_wc_Sha256FinalRaw),
TEST_DECL(test_wc_Sha256GetFlags),
TEST_DECL(test_wc_Sha256Free),
TEST_DECL(test_wc_Sha256GetHash),
TEST_DECL(test_wc_Sha256_KATs),
TEST_DECL(test_wc_Sha256_other),
TEST_DECL(test_wc_Sha256Copy),
TEST_DECL(test_wc_Sha256GetHash),
TEST_DECL(test_wc_Sha256Transform),
TEST_DECL(test_wc_Sha256_Flags),
TEST_DECL(test_wc_InitSha224),
TEST_DECL(test_wc_Sha224Update),
TEST_DECL(test_wc_Sha224Final),
TEST_DECL(test_wc_Sha224SetFlags),
TEST_DECL(test_wc_Sha224GetFlags),
TEST_DECL(test_wc_Sha224Free),
TEST_DECL(test_wc_Sha224GetHash),
TEST_DECL(test_wc_Sha224_KATs),
TEST_DECL(test_wc_Sha224_other),
TEST_DECL(test_wc_Sha224Copy),
TEST_DECL(test_wc_Sha224GetHash),
TEST_DECL(test_wc_Sha224_Flags),
/* test_sha512.c */
TEST_DECL(test_wc_InitSha512),
TEST_DECL(test_wc_Sha512Update),
TEST_DECL(test_wc_Sha512Final),
TEST_DECL(test_wc_Sha512FinalRaw),
TEST_DECL(test_wc_Sha512GetFlags),
TEST_DECL(test_wc_Sha512Free),
TEST_DECL(test_wc_Sha512GetHash),
TEST_DECL(test_wc_Sha512_KATs),
TEST_DECL(test_wc_Sha512_other),
TEST_DECL(test_wc_Sha512Copy),
TEST_DECL(test_wc_Sha512GetHash),
TEST_DECL(test_wc_Sha512Transform),
TEST_DECL(test_wc_Sha512_Flags),
TEST_DECL(test_wc_InitSha512_224),
TEST_DECL(test_wc_Sha512_224Update),
TEST_DECL(test_wc_Sha512_224Final),
TEST_DECL(test_wc_Sha512_224FinalRaw),
TEST_DECL(test_wc_Sha512_224GetFlags),
TEST_DECL(test_wc_Sha512_224Free),
TEST_DECL(test_wc_Sha512_224GetHash),
TEST_DECL(test_wc_Sha512_224_KATs),
TEST_DECL(test_wc_Sha512_224_other),
TEST_DECL(test_wc_Sha512_224Copy),
TEST_DECL(test_wc_Sha512_224GetHash),
TEST_DECL(test_wc_Sha512_224Transform),
TEST_DECL(test_wc_Sha512_224_Flags),
TEST_DECL(test_wc_InitSha512_256),
TEST_DECL(test_wc_Sha512_256Update),
TEST_DECL(test_wc_Sha512_256Final),
TEST_DECL(test_wc_Sha512_256FinalRaw),
TEST_DECL(test_wc_Sha512_256GetFlags),
TEST_DECL(test_wc_Sha512_256Free),
TEST_DECL(test_wc_Sha512_256GetHash),
TEST_DECL(test_wc_Sha512_256_KATs),
TEST_DECL(test_wc_Sha512_256_other),
TEST_DECL(test_wc_Sha512_256Copy),
TEST_DECL(test_wc_Sha512_256GetHash),
TEST_DECL(test_wc_Sha512_256Transform),
TEST_DECL(test_wc_Sha512_256_Flags),
TEST_DECL(test_wc_InitSha384),
TEST_DECL(test_wc_Sha384Update),
TEST_DECL(test_wc_Sha384Final),
TEST_DECL(test_wc_Sha384FinalRaw),
TEST_DECL(test_wc_Sha384GetFlags),
TEST_DECL(test_wc_Sha384Free),
TEST_DECL(test_wc_Sha384GetHash),
TEST_DECL(test_wc_Sha384_KATs),
TEST_DECL(test_wc_Sha384_other),
TEST_DECL(test_wc_Sha384Copy),
TEST_DECL(test_wc_Sha384GetHash),
TEST_DECL(test_wc_Sha384_Flags),
/* test_sha3.c */
TEST_DECL(test_wc_InitSha3),
TEST_DECL(test_wc_Sha3_Update),
TEST_DECL(test_wc_Sha3_224_Final),
TEST_DECL(test_wc_Sha3_256_Final),
TEST_DECL(test_wc_Sha3_384_Final),
TEST_DECL(test_wc_Sha3_512_Final),
TEST_DECL(test_wc_Sha3_224_Copy),
TEST_DECL(test_wc_Sha3_256_Copy),
TEST_DECL(test_wc_Sha3_384_Copy),
TEST_DECL(test_wc_Sha3_512_Copy),
TEST_DECL(test_wc_Sha3_GetFlags),
TEST_DECL(test_wc_Sha3_Final),
TEST_DECL(test_wc_Sha3_224_KATs),
TEST_DECL(test_wc_Sha3_256_KATs),
TEST_DECL(test_wc_Sha3_384_KATs),
TEST_DECL(test_wc_Sha3_512_KATs),
TEST_DECL(test_wc_Sha3_other),
TEST_DECL(test_wc_Sha3_Copy),
TEST_DECL(test_wc_Sha3_GetHash),
TEST_DECL(test_wc_Sha3_Flags),
TEST_DECL(test_wc_InitShake128),
TEST_DECL(test_wc_Shake128_Update),
TEST_DECL(test_wc_Shake128_Final),
TEST_DECL(test_wc_Shake128_KATs),
TEST_DECL(test_wc_Shake128_other),
TEST_DECL(test_wc_Shake128_Copy),
TEST_DECL(test_wc_Shake128Hash),
TEST_DECL(test_wc_Shake128_Absorb),
TEST_DECL(test_wc_Shake128_SqueezeBlocks),
TEST_DECL(test_wc_Shake128_XOF),
TEST_DECL(test_wc_InitShake256),
TEST_DECL(test_wc_Shake256_Update),
TEST_DECL(test_wc_Shake256_Final),
TEST_DECL(test_wc_Shake256_KATs),
TEST_DECL(test_wc_Shake256_other),
TEST_DECL(test_wc_Shake256_Copy),
TEST_DECL(test_wc_Shake256Hash),
TEST_DECL(test_wc_Shake256_Absorb),
TEST_DECL(test_wc_Shake256_SqueezeBlocks),
TEST_DECL(test_wc_Shake256_XOF),
/* test_blake.c */
TEST_DECL(test_wc_InitBlake2b),
TEST_DECL(test_wc_InitBlake2b_WithKey),
TEST_DECL(test_wc_Blake2bUpdate),
TEST_DECL(test_wc_Blake2bFinal),
TEST_DECL(test_wc_Blake2b_KATs),
TEST_DECL(test_wc_Blake2b_other),
TEST_DECL(test_wc_InitBlake2s),
TEST_DECL(test_wc_InitBlake2s_WithKey),
TEST_DECL(test_wc_Blake2sUpdate),
TEST_DECL(test_wc_Blake2sFinal),
TEST_DECL(test_wc_Blake2s_KATs),
TEST_DECL(test_wc_Blake2s_other),
/* test_sm3.c: SM3 Digest */
TEST_DECL(test_wc_InitSm3Free),
TEST_DECL(test_wc_Sm3UpdateFinal),
TEST_DECL(test_wc_Sm3GetHash),
TEST_DECL(test_wc_Sm3Copy),
TEST_DECL(test_wc_InitSm3),
TEST_DECL(test_wc_Sm3Update),
TEST_DECL(test_wc_Sm3Final),
TEST_DECL(test_wc_Sm3FinalRaw),
TEST_DECL(test_wc_Sm3GetSetFlags),
TEST_DECL(test_wc_Sm3_KATs),
TEST_DECL(test_wc_Sm3_other),
TEST_DECL(test_wc_Sm3Copy),
TEST_DECL(test_wc_Sm3GetHash),
TEST_DECL(test_wc_Sm3_Flags),
TEST_DECL(test_wc_Sm3Hash),
/* test_ripemd.c */
TEST_DECL(test_wc_InitRipeMd),
TEST_DECL(test_wc_RipeMdUpdate),
TEST_DECL(test_wc_RipeMdFinal),
TEST_DECL(test_wc_RipeMd_KATs),
TEST_DECL(test_wc_RipeMd_other),
/* test_hash.c */
TEST_DECL(test_wc_HashInit),

1
tests/api/include.am
View File

@@ -23,6 +23,7 @@ EXTRA_DIST += tests/api/test_sha3.h
EXTRA_DIST += tests/api/test_blake2.h
EXTRA_DIST += tests/api/test_sm3.h
EXTRA_DIST += tests/api/test_ripemd.h
EXTRA_DIST += tests/api/test_digest.h
EXTRA_DIST += tests/api/test_hash.h
EXTRA_DIST += tests/api/test_ascon.h
EXTRA_DIST += tests/api/test_ascon.h

485
tests/api/test_blake2.c
View File

@@ -41,30 +41,30 @@
#include <tests/api/api.h>
#include <tests/api/test_blake2.h>
/*
* Unit test for the wc_InitBlake2b()
*/
/*******************************************************************************
* BLAKE2b
******************************************************************************/
int test_wc_InitBlake2b(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2
Blake2b blake;
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b(&blake, 64), 0);
/* Test bad arg. */
ExpectIntEQ(wc_InitBlake2b(NULL, 64), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(&blake, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b(NULL, WC_BLAKE2B_DIGEST_SIZE),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
#endif
return EXPECT_RESULT();
} /* END test_wc_InitBlake2b*/
}
/*
* Unit test for the wc_InitBlake2b_WithKey()
*/
int test_wc_InitBlake2b_WithKey(void)
{
EXPECT_DECLS;
@@ -76,21 +76,267 @@ int test_wc_InitBlake2b_WithKey(void)
XMEMSET(key, 0, sizeof(key));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0);
/* Test bad args. */
ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, keylen),
ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, NULL, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, NULL, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, NULL, keylen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2b_WithKey(NULL, digestSz, key, keylen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, NULL, keylen), 0);
ExpectIntEQ(wc_InitBlake2b_WithKey(&blake, digestSz, key, keylen), 0);
#endif
return EXPECT_RESULT();
} /* END wc_InitBlake2b_WithKey*/
}
int test_wc_Blake2bUpdate(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2
Blake2b blake;
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
/* Pass in bad values. */
ExpectIntEQ(wc_Blake2bUpdate(NULL, NULL, 1),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 1),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Blake2bUpdate(NULL, NULL, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good args. */
ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 0), 0);
ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)"a", 1), 0);
#endif
return EXPECT_RESULT();
}
int test_wc_Blake2bFinal(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2
Blake2b blake;
byte hash[WC_BLAKE2B_DIGEST_SIZE];
/* Initialize */
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
/* Test bad args. */
ExpectIntEQ(wc_Blake2bFinal(NULL, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Blake2bFinal(&blake, NULL, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Blake2bFinal(NULL, hash, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good args. */
ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0);
#endif
return EXPECT_RESULT();
}
#define BLAKE2B_KAT_CNT 7
int test_wc_Blake2b_KATs(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2
Blake2b blake;
testVector blake2b_kat[BLAKE2B_KAT_CNT];
byte hash[WC_BLAKE2B_DIGEST_SIZE];
int i = 0;
blake2b_kat[i].input = "";
blake2b_kat[i].inLen = 0;
blake2b_kat[i].output =
"\x78\x6a\x02\xf7\x42\x01\x59\x03"
"\xc6\xc6\xfd\x85\x25\x52\xd2\x72"
"\x91\x2f\x47\x40\xe1\x58\x47\x61"
"\x8a\x86\xe2\x17\xf7\x1f\x54\x19"
"\xd2\x5e\x10\x31\xaf\xee\x58\x53"
"\x13\x89\x64\x44\x93\x4e\xb0\x4b"
"\x90\x3a\x68\x5b\x14\x48\xb7\x55"
"\xd5\x6f\x70\x1a\xfe\x9b\xe2\xce";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input = "a";
blake2b_kat[i].inLen = 1;
blake2b_kat[i].output =
"\x33\x3f\xcb\x4e\xe1\xaa\x7c\x11"
"\x53\x55\xec\x66\xce\xac\x91\x7c"
"\x8b\xfd\x81\x5b\xf7\x58\x7d\x32"
"\x5a\xec\x18\x64\xed\xd2\x4e\x34"
"\xd5\xab\xe2\xc6\xb1\xb5\xee\x3f"
"\xac\xe6\x2f\xed\x78\xdb\xef\x80"
"\x2f\x2a\x85\xcb\x91\xd4\x55\xa8"
"\xf5\x24\x9d\x33\x08\x53\xcb\x3c";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input = "abc";
blake2b_kat[i].inLen = 3;
blake2b_kat[i].output =
"\xba\x80\xa5\x3f\x98\x1c\x4d\x0d"
"\x6a\x27\x97\xb6\x9f\x12\xf6\xe9"
"\x4c\x21\x2f\x14\x68\x5a\xc4\xb7"
"\x4b\x12\xbb\x6f\xdb\xff\xa2\xd1"
"\x7d\x87\xc5\x39\x2a\xab\x79\x2d"
"\xc2\x52\xd5\xde\x45\x33\xcc\x95"
"\x18\xd3\x8a\xa8\xdb\xf1\x92\x5a"
"\xb9\x23\x86\xed\xd4\x00\x99\x23";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input = "message digest";
blake2b_kat[i].inLen = 14;
blake2b_kat[i].output =
"\x3c\x26\xce\x48\x7b\x1c\x0f\x06"
"\x23\x63\xaf\xa3\xc6\x75\xeb\xdb"
"\xf5\xf4\xef\x9b\xdc\x02\x2c\xfb"
"\xef\x91\xe3\x11\x1c\xdc\x28\x38"
"\x40\xd8\x33\x1f\xc3\x0a\x8a\x09"
"\x06\xcf\xf4\xbc\xdb\xcd\x23\x0c"
"\x61\xaa\xec\x60\xfd\xfa\xd4\x57"
"\xed\x96\xb7\x09\xa3\x82\x35\x9a";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input = "abcdefghijklmnopqrstuvwxyz";
blake2b_kat[i].inLen = 26;
blake2b_kat[i].output =
"\xc6\x8e\xde\x14\x3e\x41\x6e\xb7"
"\xb4\xaa\xae\x0d\x8e\x48\xe5\x5d"
"\xd5\x29\xea\xfe\xd1\x0b\x1d\xf1"
"\xa6\x14\x16\x95\x3a\x2b\x0a\x56"
"\x66\xc7\x61\xe7\xd4\x12\xe6\x70"
"\x9e\x31\xff\xe2\x21\xb7\xa7\xa7"
"\x39\x08\xcb\x95\xa4\xd1\x20\xb8"
"\xb0\x90\xa8\x7d\x1f\xbe\xdb\x4c";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
blake2b_kat[i].inLen = 62;
blake2b_kat[i].output =
"\x99\x96\x48\x02\xe5\xc2\x5e\x70"
"\x37\x22\x90\x5d\x3f\xb8\x00\x46"
"\xb6\xbc\xa6\x98\xca\x9e\x2c\xc7"
"\xe4\x9b\x4f\xe1\xfa\x08\x7c\x2e"
"\xdf\x03\x12\xdf\xbb\x27\x5c\xf2"
"\x50\xa1\xe5\x42\xfd\x5d\xc2\xed"
"\xd3\x13\xf9\xc4\x91\x12\x7c\x2e"
"\x8c\x0c\x9b\x24\x16\x8e\x2d\x50";
blake2b_kat[i].outLen = 0;
i++;
blake2b_kat[i].input = "1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890";
blake2b_kat[i].inLen = 80;
blake2b_kat[i].output =
"\x68\x6f\x41\xec\x5a\xff\xf6\xe8"
"\x7e\x1f\x07\x6f\x54\x2a\xa4\x66"
"\x46\x6f\xf5\xfb\xde\x16\x2c\x48"
"\x48\x1b\xa4\x8a\x74\x8d\x84\x27"
"\x99\xf5\xb3\x0f\x5b\x67\xfc\x68"
"\x47\x71\xb3\x3b\x99\x42\x06\xd0"
"\x5c\xc3\x10\xf3\x19\x14\xed\xd7"
"\xb9\x7e\x41\x86\x0d\x77\xd2\x82";
blake2b_kat[i].outLen = 0;
for (i = 0; i < BLAKE2B_KAT_CNT; i++) {
/* Do KAT. */
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)blake2b_kat[i].input,
(word32)blake2b_kat[i].inLen), 0);
ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectBufEQ(hash, (byte*)blake2b_kat[i].output, WC_BLAKE2B_DIGEST_SIZE);
}
#endif
return EXPECT_RESULT();
}
int test_wc_Blake2b_other(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2
Blake2b blake;
byte hash[WC_BLAKE2B_DIGEST_SIZE + 1];
byte data[WC_BLAKE2B_DIGEST_SIZE * 8 + 1];
int dataLen = WC_BLAKE2B_DIGEST_SIZE * 8;
const char* expHash =
"\xfb\xea\x44\x32\x0b\x4a\x40\x44"
"\xa0\xad\x54\x0c\x39\x62\xa6\x4d"
"\x2a\xc2\x08\x3f\xce\xb4\x1d\x71"
"\x77\x04\xa6\xfc\x38\xe5\xd9\x99"
"\xe6\x92\xf1\x9f\xe7\x21\x10\x94"
"\xe6\x08\xc1\x9c\x1d\xdf\x87\x11"
"\xfa\xf4\xe6\x7b\xf1\xe5\xc8\x12"
"\x55\x90\x05\x00\xfa\x0d\x61\x3d";
int i;
int j;
XMEMSET(data, 0xa5, sizeof(data));
/* Initialize */
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
/* Unaligned input and output buffer. */
ExpectIntEQ(wc_Blake2bUpdate(&blake, data + 1, dataLen), 0);
ExpectIntEQ(wc_Blake2bFinal(&blake, hash + 1, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectBufEQ(hash + 1, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE);
/* Test that empty updates work. */
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectIntEQ(wc_Blake2bUpdate(&blake, NULL, 0), 0);
ExpectIntEQ(wc_Blake2bUpdate(&blake, (byte*)"", 0), 0);
ExpectIntEQ(wc_Blake2bUpdate(&blake, data, dataLen), 0);
ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE);
/* Ensure chunking works. */
for (i = 1; i < dataLen; i++) {
ExpectIntEQ(wc_InitBlake2b(&blake, WC_BLAKE2B_DIGEST_SIZE), 0);
for (j = 0; j < dataLen; j += i) {
int len = dataLen - j;
if (i < len)
len = i;
ExpectIntEQ(wc_Blake2bUpdate(&blake, data + j, len), 0);
}
ExpectIntEQ(wc_Blake2bFinal(&blake, hash, WC_BLAKE2B_DIGEST_SIZE), 0);
ExpectBufEQ(hash, (byte*)expHash, WC_BLAKE2B_DIGEST_SIZE);
}
#endif
return EXPECT_RESULT();
}
/*******************************************************************************
* BLAKE2s
******************************************************************************/
int test_wc_InitBlake2s(void)
{
EXPECT_DECLS;
#ifdef HAVE_BLAKE2S
Blake2s blake;
/* Test bad arg. */
ExpectIntEQ(wc_InitBlake2s(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s(NULL, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s(&blake, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s(&blake, 128), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s(NULL, WC_BLAKE2S_DIGEST_SIZE),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2s(&blake, WC_BLAKE2S_DIGEST_SIZE), 0);
#endif
return EXPECT_RESULT();
}
/*
* Unit test for the wc_InitBlake2s_WithKey()
*/
int test_wc_InitBlake2s_WithKey(void)
{
EXPECT_DECLS;
@@ -100,15 +346,208 @@ int test_wc_InitBlake2s_WithKey(void)
byte *key = (byte*)"01234567890123456789012345678901";
word32 keylen = BLAKE2S_KEYBYTES;
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0);
/* Test bad args. */
ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, keylen),
ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, NULL, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, NULL, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, NULL, keylen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, 256),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_InitBlake2s_WithKey(NULL, digestSz, key, keylen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, NULL, keylen), 0);
ExpectIntEQ(wc_InitBlake2s_WithKey(&blake, digestSz, key, keylen), 0);
#endif
return EXPECT_RESULT();
} /* 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_WithKey(void);
int test_wc_Blake2bUpdate(void);
int test_wc_Blake2bFinal(void);
int test_wc_Blake2b_KATs(void);
int test_wc_Blake2b_other(void);
int test_wc_InitBlake2s(void);
int test_wc_InitBlake2s_WithKey(void);
int test_wc_Blake2sUpdate(void);
int test_wc_Blake2sFinal(void);
int test_wc_Blake2s_KATs(void);
int test_wc_Blake2s_other(void);
#endif /* WOLFCRYPT_TEST_BLAKE2_H */

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

6
tests/api/test_md5.h
View File

@@ -25,5 +25,11 @@
int test_wc_InitMd5(void);
int test_wc_Md5Update(void);
int test_wc_Md5Final(void);
int test_wc_Md5_KATs(void);
int test_wc_Md5_other(void);
int test_wc_Md5Copy(void);
int test_wc_Md5GetHash(void);
int test_wc_Md5Transform(void);
int test_wc_Md5_Flags(void);
#endif /* WOLFCRYPT_TEST_MD5_H */

190
tests/api/test_ripemd.c
View File

@@ -40,6 +40,7 @@
#include <tests/unit.h>
#include <tests/api/api.h>
#include <tests/api/test_ripemd.h>
#include <tests/api/test_digest.h>
/*
* Testing wc_InitRipeMd()
@@ -50,10 +51,11 @@ int test_wc_InitRipeMd(void)
#ifdef WOLFSSL_RIPEMD
RipeMd ripemd;
/* Test good arg. */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
/* Test bad arg. */
ExpectIntEQ(wc_InitRipeMd(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good arg. */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
#endif
return EXPECT_RESULT();
@@ -67,37 +69,20 @@ int test_wc_RipeMdUpdate(void)
EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD
RipeMd ripemd;
byte hash[RIPEMD_DIGEST_SIZE];
testVector a, b, c;
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
/* Input */
a.input = "a";
a.inLen = XSTRLEN(a.input);
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
/* Update input. */
a.input = "abc";
a.output = "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6"
"\xb0\x87\xf1\x5a\x0b\xfc";
a.inLen = XSTRLEN(a.input);
a.outLen = XSTRLEN(a.output);
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
ExpectIntEQ(XMEMCMP(hash, a.output, RIPEMD_DIGEST_SIZE), 0);
/* Pass in bad values. */
b.input = NULL;
b.inLen = 0;
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)b.input, (word32)b.inLen), 0);
c.input = NULL;
c.inLen = RIPEMD_DIGEST_SIZE;
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)c.input, (word32)c.inLen),
/* Test bad arg. */
ExpectIntEQ(wc_RipeMdUpdate(NULL , NULL, 1),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RipeMdUpdate(NULL, (byte*)a.input, (word32)a.inLen),
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 1),
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
return EXPECT_RESULT();
} /* END test_wc_RipeMdUdpate */
@@ -110,30 +95,149 @@ int test_wc_RipeMdFinal(void)
EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD
RipeMd ripemd;
byte* hash_test[3];
byte hash1[RIPEMD_DIGEST_SIZE];
byte hash2[2*RIPEMD_DIGEST_SIZE];
byte hash3[5*RIPEMD_DIGEST_SIZE];
int times, i;
byte hash[RIPEMD_DIGEST_SIZE];
/* Initialize */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
hash_test[0] = hash1;
hash_test[1] = hash2;
hash_test[2] = hash3;
times = sizeof(hash_test) / sizeof(byte*);
/* Testing oversized buffers. */
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash_test[i]), 0);
}
/* Test bad args. */
ExpectIntEQ(wc_RipeMdFinal(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RipeMdFinal(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RipeMdFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RipeMdFinal(&ripemd, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test good args. */
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
#endif
return EXPECT_RESULT();
} /* END test_wc_RipeMdFinal */
#define RIPEMD_KAT_CNT 7
int test_wc_RipeMd_KATs( void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD
RipeMd ripemd;
testVector ripemd_kat[RIPEMD_KAT_CNT];
byte hash[RIPEMD_DIGEST_SIZE];
int i = 0;
ripemd_kat[i].input = "";
ripemd_kat[i].inLen = 0;
ripemd_kat[i].output =
"\x9c\x11\x85\xa5\xc5\xe9\xfc\x54"
"\x61\x28\x08\x97\x7e\xe8\xf5\x48"
"\xb2\x25\x8d\x31";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input = "a";
ripemd_kat[i].inLen = 1;
ripemd_kat[i].output =
"\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9"
"\xda\xae\x34\x7b\xe6\xf4\xdc\x83"
"\x5a\x46\x7f\xfe";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input = "abc";
ripemd_kat[i].inLen = 3;
ripemd_kat[i].output =
"\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a"
"\x9b\x04\x4a\x8e\x98\xc6\xb0\x87"
"\xf1\x5a\x0b\xfc";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input = "message digest";
ripemd_kat[i].inLen = 14;
ripemd_kat[i].output =
"\x5d\x06\x89\xef\x49\xd2\xfa\xe5"
"\x72\xb8\x81\xb1\x23\xa8\x5f\xfa"
"\x21\x59\x5f\x36";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input = "abcdefghijklmnopqrstuvwxyz";
ripemd_kat[i].inLen = 26;
ripemd_kat[i].output =
"\xf7\x1c\x27\x10\x9c\x69\x2c\x1b"
"\x56\xbb\xdc\xeb\x5b\x9d\x28\x65"
"\xb3\x70\x8d\xbc";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
ripemd_kat[i].inLen = 62;
ripemd_kat[i].output =
"\xb0\xe2\x0b\x6e\x31\x16\x64\x02"
"\x86\xed\x3a\x87\xa5\x71\x30\x79"
"\xb2\x1f\x51\x89";
ripemd_kat[i].outLen = 0;
i++;
ripemd_kat[i].input = "1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890";
ripemd_kat[i].inLen = 80;
ripemd_kat[i].output =
"\x9b\x75\x2e\x45\x57\x3d\x4b\x39"
"\xf4\xdb\xd3\x32\x3c\xab\x82\xbf"
"\x63\x32\x6b\xfb";
ripemd_kat[i].outLen = 0;
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
for (i = 0; i < RIPEMD_KAT_CNT; i++) {
/* Do KAT. */
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)ripemd_kat[i].input,
(word32)ripemd_kat[i].inLen), 0);
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
ExpectBufEQ(hash, (byte*)ripemd_kat[i].output, RIPEMD_DIGEST_SIZE);
}
#endif
return EXPECT_RESULT();
}
int test_wc_RipeMd_other(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_RIPEMD
RipeMd ripemd;
byte hash[RIPEMD_DIGEST_SIZE + 1];
byte data[RIPEMD_DIGEST_SIZE * 8 + 1];
int dataLen = RIPEMD_DIGEST_SIZE * 8;
const char* expHash =
"\x11\x8f\x4f\x23\xa9\xc2\xcb\x04"
"\x10\x10\xbb\x44\x5a\x1d\xfb\x17"
"\x6b\x68\x09\xb4";
int i;
int j;
XMEMSET(data, 0xa5, sizeof(data));
/* Initialize */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
/* Unaligned input and output buffer. */
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data + 1, dataLen), 0);
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash + 1), 0);
ExpectBufEQ(hash + 1, (byte*)expHash, RIPEMD_DIGEST_SIZE);
/* Test that empty updates work. */
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, NULL, 0), 0);
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, (byte*)"", 0), 0);
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data, dataLen), 0);
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
ExpectBufEQ(hash, (byte*)expHash, RIPEMD_DIGEST_SIZE);
/* Ensure chunking works. */
for (i = 1; i < dataLen; i++) {
ExpectIntEQ(wc_InitRipeMd(&ripemd), 0);
for (j = 0; j < dataLen; j += i) {
int len = dataLen - j;
if (i < len)
len = i;
ExpectIntEQ(wc_RipeMdUpdate(&ripemd, data + j, len), 0);
}
ExpectIntEQ(wc_RipeMdFinal(&ripemd, hash), 0);
ExpectBufEQ(hash, (byte*)expHash, RIPEMD_DIGEST_SIZE);
}
#endif
return EXPECT_RESULT();
}

2
tests/api/test_ripemd.h
View File

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

208
tests/api/test_sha.c
View File

@@ -40,6 +40,7 @@
#include <tests/unit.h>
#include <tests/api/api.h>
#include <tests/api/test_sha.h>
#include <tests/api/test_digest.h>
/*
* Unit test for the wc_InitSha()
@@ -48,14 +49,7 @@ int test_wc_InitSha(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
wc_Sha sha;
/* Test good arg. */
ExpectIntEQ(wc_InitSha(&sha), 0);
/* Test bad arg. */
ExpectIntEQ(wc_InitSha(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_ShaFree(&sha);
DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha, Sha);
#endif
return EXPECT_RESULT();
} /* END test_wc_InitSha */
@@ -67,44 +61,7 @@ int test_wc_ShaUpdate(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
wc_Sha sha;
byte hash[WC_SHA_DIGEST_SIZE];
testVector a, b, c;
ExpectIntEQ(wc_InitSha(&sha), 0);
/* Input. */
a.input = "a";
a.inLen = XSTRLEN(a.input);
ExpectIntEQ(wc_ShaUpdate(&sha, NULL, 0), 0);
ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, 0), 0);
ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_ShaFinal(&sha, hash), 0);
/* Update input. */
a.input = "abc";
a.output = "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2"
"\x6C\x9C\xD0\xD8\x9D";
a.inLen = XSTRLEN(a.input);
a.outLen = XSTRLEN(a.output);
ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_ShaFinal(&sha, hash), 0);
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA_DIGEST_SIZE), 0);
/* Try passing in bad values. */
b.input = NULL;
b.inLen = 0;
ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)b.input, (word32)b.inLen), 0);
c.input = NULL;
c.inLen = WC_SHA_DIGEST_SIZE;
ExpectIntEQ(wc_ShaUpdate(&sha, (byte*)c.input, (word32)c.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_ShaUpdate(NULL, (byte*)a.input, (word32)a.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_ShaFree(&sha);
DIGEST_UPDATE_TEST(wc_Sha, Sha);
#endif
return EXPECT_RESULT();
} /* END test_wc_ShaUpdate() */
@@ -116,31 +73,142 @@ int test_wc_ShaFinal(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
wc_Sha sha;
byte* hash_test[3];
byte hash1[WC_SHA_DIGEST_SIZE];
byte hash2[2*WC_SHA_DIGEST_SIZE];
byte hash3[5*WC_SHA_DIGEST_SIZE];
int times, i;
/* Initialize*/
ExpectIntEQ(wc_InitSha(&sha), 0);
hash_test[0] = hash1;
hash_test[1] = hash2;
hash_test[2] = hash3;
times = sizeof(hash_test)/sizeof(byte*);
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_ShaFinal(&sha, hash_test[i]), 0);
}
/* Test bad args. */
ExpectIntEQ(wc_ShaFinal(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_ShaFinal(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_ShaFinal(&sha, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_ShaFree(&sha);
DIGEST_FINAL_TEST(wc_Sha, Sha, SHA);
#endif
return EXPECT_RESULT();
} /* END test_wc_ShaFinal */
/*
* Unit test on wc_ShaFinalRaw
*/
int test_wc_ShaFinalRaw(void)
{
EXPECT_DECLS;
#if !defined(NO_SHA) && !defined(HAVE_SELFTEST) && \
!defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \
!defined(WOLFSSL_NO_HASH_RAW)
DIGEST_FINAL_RAW_TEST(wc_Sha, Sha, SHA,
"\x67\x45\x23\x01\xef\xcd\xab\x89"
"\x98\xba\xdc\xfe\x10\x32\x54\x76"
"\xc3\xd2\xe1\xf0");
#endif
return EXPECT_RESULT();
} /* END test_wc_ShaFinal */
#define SHA_KAT_CNT 7
int test_wc_Sha_KATs(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
DIGEST_KATS_TEST_VARS(wc_Sha, SHA);
DIGEST_KATS_ADD("", 0,
"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d"
"\x32\x55\xbf\xef\x95\x60\x18\x90"
"\xaf\xd8\x07\x09");
DIGEST_KATS_ADD("a", 1,
"\x86\xf7\xe4\x37\xfa\xa5\xa7\xfc"
"\xe1\x5d\x1d\xdc\xb9\xea\xea\xea"
"\x37\x76\x67\xb8");
DIGEST_KATS_ADD("abc", 3,
"\xa9\x99\x3e\x36\x47\x06\x81\x6a"
"\xba\x3e\x25\x71\x78\x50\xc2\x6c"
"\x9c\xd0\xd8\x9d");
DIGEST_KATS_ADD("message digest", 14,
"\xc1\x22\x52\xce\xda\x8b\xe8\x99"
"\x4d\x5f\xa0\x29\x0a\x47\x23\x1c"
"\x1d\x16\xaa\xe3");
DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26,
"\x32\xd1\x0c\x7b\x8c\xf9\x65\x70"
"\xca\x04\xce\x37\xf2\xa1\x9d\x84"
"\x24\x0d\x3a\x89");
DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789", 62,
"\x76\x1c\x45\x7b\xf7\x3b\x14\xd2"
"\x7e\x9e\x92\x65\xc4\x6f\x4b\x4d"
"\xda\x11\xf9\x40");
DIGEST_KATS_ADD("1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890", 80,
"\x50\xab\xf5\x70\x6a\x15\x09\x90"
"\xa0\x8b\x2c\x5e\xa4\x0f\xa0\xe5"
"\x85\x55\x47\x32");
DIGEST_KATS_TEST(Sha, SHA);
#endif
return EXPECT_RESULT();
} /* END test_wc_ShaFinal */
int test_wc_Sha_other(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
DIGEST_OTHER_TEST(wc_Sha, Sha, SHA,
"\xf0\xc2\x3f\xeb\xe0\xb0\xd9\x8c"
"\x01\x23\x6c\x4c\x3b\x72\x7b\x01"
"\xc7\x0d\x2b\x60");
#endif
return EXPECT_RESULT();
} /* END test_wc_ShaFinal */
int test_wc_ShaCopy(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
DIGEST_COPY_TEST(wc_Sha, Sha, SHA,
"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d"
"\x32\x55\xbf\xef\x95\x60\x18\x90"
"\xaf\xd8\x07\x09",
"\xa9\x99\x3e\x36\x47\x06\x81\x6a"
"\xba\x3e\x25\x71\x78\x50\xc2\x6c"
"\x9c\xd0\xd8\x9d");
#endif
return EXPECT_RESULT();
}
int test_wc_ShaGetHash(void)
{
EXPECT_DECLS;
#ifndef NO_SHA
DIGEST_GET_HASH_TEST(wc_Sha, Sha, SHA,
"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d"
"\x32\x55\xbf\xef\x95\x60\x18\x90"
"\xaf\xd8\x07\x09",
"\xa9\x99\x3e\x36\x47\x06\x81\x6a"
"\xba\x3e\x25\x71\x78\x50\xc2\x6c"
"\x9c\xd0\xd8\x9d");
#endif
return EXPECT_RESULT();
}
int test_wc_ShaTransform(void)
{
EXPECT_DECLS;
#if !defined(NO_SHA) && (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \
!defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3)))
DIGEST_TRANSFORM_FINAL_RAW_TEST(wc_Sha, Sha, SHA,
"\x80\x63\x62\x61\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x18\x00\x00\x00",
"\xa9\x99\x3e\x36\x47\x06\x81\x6a"
"\xba\x3e\x25\x71\x78\x50\xc2\x6c"
"\x9c\xd0\xd8\x9d");
#endif
return EXPECT_RESULT();
}
int test_wc_Sha_Flags(void)
{
EXPECT_DECLS;
#if !defined(NO_SHA) && defined(WOLFSSL_HASH_FLAGS)
DIGEST_FLAGS_TEST(wc_Sha, Sha);
#endif
return EXPECT_RESULT();
}

7
tests/api/test_sha.h
View File

@@ -25,5 +25,12 @@
int test_wc_InitSha(void);
int test_wc_ShaUpdate(void);
int test_wc_ShaFinal(void);
int test_wc_ShaFinalRaw(void);
int test_wc_Sha_KATs(void);
int test_wc_Sha_other(void);
int test_wc_ShaCopy(void);
int test_wc_ShaGetHash(void);
int test_wc_ShaTransform(void);
int test_wc_Sha_Flags(void);
#endif /* WOLFCRYPT_TEST_SHA_H */

563
tests/api/test_sha256.c
View File

@@ -40,121 +40,50 @@
#include <tests/unit.h>
#include <tests/api/api.h>
#include <tests/api/test_sha256.h>
#include <tests/api/test_digest.h>
/*******************************************************************************
* SHA-256
******************************************************************************/
/*
* Unit test for wc_InitSha256()
* Unit test for the wc_InitSha256()
*/
int test_wc_InitSha256(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256 sha256;
/* Test good arg. */
ExpectIntEQ(wc_InitSha256(&sha256), 0);
/* Test bad arg. */
ExpectIntEQ(wc_InitSha256(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha256, Sha256);
#endif
return EXPECT_RESULT();
} /* END test_wc_InitSha256 */
/*
* Unit test for wc_Sha256Update()
* Tesing wc_Sha256Update()
*/
int test_wc_Sha256Update(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256 sha256;
byte hash[WC_SHA256_DIGEST_SIZE];
byte hash_unaligned[WC_SHA256_DIGEST_SIZE+1];
testVector a, b, c;
ExpectIntEQ(wc_InitSha256(&sha256), 0);
/* Input. */
a.input = "a";
a.inLen = XSTRLEN(a.input);
ExpectIntEQ(wc_Sha256Update(&sha256, NULL, 0), 0);
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, 0), 0);
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_Sha256Final(&sha256, hash), 0);
/* Update input. */
a.input = "abc";
a.output = "\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22"
"\x23\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00"
"\x15\xAD";
a.inLen = XSTRLEN(a.input);
a.outLen = XSTRLEN(a.output);
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_Sha256Final(&sha256, hash), 0);
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA256_DIGEST_SIZE), 0);
/* Unaligned check. */
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)a.input+1, (word32)a.inLen-1),
0);
ExpectIntEQ(wc_Sha256Final(&sha256, hash_unaligned + 1), 0);
/* Try passing in bad values */
b.input = NULL;
b.inLen = 0;
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)b.input, (word32)b.inLen), 0);
c.input = NULL;
c.inLen = WC_SHA256_DIGEST_SIZE;
ExpectIntEQ(wc_Sha256Update(&sha256, (byte*)c.input, (word32)c.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256Update(NULL, (byte*)a.input, (word32)a.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
DIGEST_UPDATE_TEST(wc_Sha256, Sha256);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256Update */
} /* END test_wc_Sha256Update() */
/*
* Unit test function for wc_Sha256Final()
* Unit test on wc_Sha256Final
*/
int test_wc_Sha256Final(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256 sha256;
byte* hash_test[3];
byte hash1[WC_SHA256_DIGEST_SIZE];
byte hash2[2*WC_SHA256_DIGEST_SIZE];
byte hash3[5*WC_SHA256_DIGEST_SIZE];
int times, i;
/* Initialize */
ExpectIntEQ(wc_InitSha256(&sha256), 0);
hash_test[0] = hash1;
hash_test[1] = hash2;
hash_test[2] = hash3;
times = sizeof(hash_test) / sizeof(byte*);
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_Sha256Final(&sha256, hash_test[i]), 0);
}
/* Test bad args. */
ExpectIntEQ(wc_Sha256Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256Final(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
DIGEST_FINAL_TEST(wc_Sha256, Sha256, SHA256);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256Final */
/*
* Unit test function for wc_Sha256FinalRaw()
* Unit test on wc_Sha256FinalRaw
*/
int test_wc_Sha256FinalRaw(void)
{
@@ -163,341 +92,287 @@ int test_wc_Sha256FinalRaw(void)
!defined(WOLFSSL_DEVCRYPTO) && (!defined(HAVE_FIPS) || \
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \
!defined(WOLFSSL_NO_HASH_RAW)
wc_Sha256 sha256;
byte* hash_test[3];
byte hash1[WC_SHA256_DIGEST_SIZE];
byte hash2[2*WC_SHA256_DIGEST_SIZE];
byte hash3[5*WC_SHA256_DIGEST_SIZE];
int times, i;
/* Initialize */
ExpectIntEQ(wc_InitSha256(&sha256), 0);
hash_test[0] = hash1;
hash_test[1] = hash2;
hash_test[2] = hash3;
times = sizeof(hash_test) / sizeof(byte*);
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_Sha256FinalRaw(&sha256, hash_test[i]), 0);
}
/* Test bad args. */
ExpectIntEQ(wc_Sha256FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256FinalRaw(&sha256, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
DIGEST_FINAL_RAW_TEST(wc_Sha256, Sha256, SHA256,
"\x6a\x09\xe6\x67\xbb\x67\xae\x85"
"\x3c\x6e\xf3\x72\xa5\x4f\xf5\x3a"
"\x51\x0e\x52\x7f\x9b\x05\x68\x8c"
"\x1f\x83\xd9\xab\x5b\xe0\xcd\x19");
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256Final */
} /* END test_wc_Sha256FinalRaw */
/*
* Unit test function for wc_Sha256GetFlags()
*/
int test_wc_Sha256GetFlags(void)
{
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)
#define SHA256_KAT_CNT 7
int test_wc_Sha256_KATs(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256Free(NULL);
/* Set result to SUCCESS. */
ExpectTrue(1);
DIGEST_KATS_TEST_VARS(wc_Sha256, SHA256);
DIGEST_KATS_ADD("", 0,
"\xe3\xb0\xc4\x42\x98\xfc\x1c\x14"
"\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24"
"\x27\xae\x41\xe4\x64\x9b\x93\x4c"
"\xa4\x95\x99\x1b\x78\x52\xb8\x55");
DIGEST_KATS_ADD("a", 1,
"\xca\x97\x81\x12\xca\x1b\xbd\xca"
"\xfa\xc2\x31\xb3\x9a\x23\xdc\x4d"
"\xa7\x86\xef\xf8\x14\x7c\x4e\x72"
"\xb9\x80\x77\x85\xaf\xee\x48\xbb");
DIGEST_KATS_ADD("abc", 3,
"\xba\x78\x16\xbf\x8f\x01\xcf\xea"
"\x41\x41\x40\xde\x5d\xae\x22\x23"
"\xb0\x03\x61\xa3\x96\x17\x7a\x9c"
"\xb4\x10\xff\x61\xf2\x00\x15\xad");
DIGEST_KATS_ADD("message digest", 14,
"\xf7\x84\x6f\x55\xcf\x23\xe1\x4e"
"\xeb\xea\xb5\xb4\xe1\x55\x0c\xad"
"\x5b\x50\x9e\x33\x48\xfb\xc4\xef"
"\xa3\xa1\x41\x3d\x39\x3c\xb6\x50");
DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26,
"\x71\xc4\x80\xdf\x93\xd6\xae\x2f"
"\x1e\xfa\xd1\x44\x7c\x66\xc9\x52"
"\x5e\x31\x62\x18\xcf\x51\xfc\x8d"
"\x9e\xd8\x32\xf2\xda\xf1\x8b\x73");
DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789", 62,
"\xdb\x4b\xfc\xbd\x4d\xa0\xcd\x85"
"\xa6\x0c\x3c\x37\xd3\xfb\xd8\x80"
"\x5c\x77\xf1\x5f\xc6\xb1\xfd\xfe"
"\x61\x4e\xe0\xa7\xc8\xfd\xb4\xc0");
DIGEST_KATS_ADD("1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890", 80,
"\xf3\x71\xbc\x4a\x31\x1f\x2b\x00"
"\x9e\xef\x95\x2d\xd8\x3c\xa8\x0e"
"\x2b\x60\x02\x6c\x8e\x93\x55\x92"
"\xd0\xf9\xc3\x08\x45\x3c\x81\x3e");
DIGEST_KATS_TEST(Sha256, SHA256);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256Free */
/*
* Unit test function for wc_Sha256GetHash()
*/
int test_wc_Sha256GetHash(void)
} /* END test_wc_Sha256Final */
int test_wc_Sha256_other(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256 sha256;
byte hash1[WC_SHA256_DIGEST_SIZE];
/* Initialize */
ExpectIntEQ(wc_InitSha256(&sha256), 0);
ExpectIntEQ(wc_Sha256GetHash(&sha256, hash1), 0);
/* test bad arguments*/
ExpectIntEQ(wc_Sha256GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256GetHash(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
DIGEST_OTHER_TEST(wc_Sha256, Sha256, SHA256,
"\x2c\x41\xa1\xdd\x58\x4e\x37\x73"
"\xb9\x56\x74\x84\x1b\x68\x5f\x36"
"\xc7\x6b\x48\xec\x4d\xb7\x58\x63"
"\x37\x2c\x2f\xd6\xe1\x9a\x61\xce");
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha256GetHash */
} /* END test_wc_Sha256Final */
/*
* Unit test function for wc_Sha256Copy()
*/
int test_wc_Sha256Copy(void)
{
EXPECT_DECLS;
#ifndef NO_SHA256
wc_Sha256 sha256;
wc_Sha256 temp;
XMEMSET(&sha256, 0, sizeof(sha256));
XMEMSET(&temp, 0, sizeof(temp));
/* Initialize */
ExpectIntEQ(wc_InitSha256(&sha256), 0);
ExpectIntEQ(wc_InitSha256(&temp), 0);
ExpectIntEQ(wc_Sha256Copy(&sha256, &temp), 0);
/* test bad arguments*/
ExpectIntEQ(wc_Sha256Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha256Copy(&sha256, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha256Free(&sha256);
wc_Sha256Free(&temp);
DIGEST_COPY_TEST(wc_Sha256, Sha256, SHA256,
"\xe3\xb0\xc4\x42\x98\xfc\x1c\x14"
"\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24"
"\x27\xae\x41\xe4\x64\x9b\x93\x4c"
"\xa4\x95\x99\x1b\x78\x52\xb8\x55",
"\xba\x78\x16\xbf\x8f\x01\xcf\xea"
"\x41\x41\x40\xde\x5d\xae\x22\x23"
"\xb0\x03\x61\xa3\x96\x17\x7a\x9c"
"\xb4\x10\xff\x61\xf2\x00\x15\xad");
#endif
return EXPECT_RESULT();
} /* END test_wc_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
******************************************************************************/
/*
* Testing wc_InitSha224();
* Unit test for the wc_InitSha224()
*/
int test_wc_InitSha224(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224 sha224;
/* Test good arg. */
ExpectIntEQ(wc_InitSha224(&sha224), 0);
/* Test bad arg. */
ExpectIntEQ(wc_InitSha224(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha224Free(&sha224);
DIGEST_INIT_AND_INIT_EX_TEST(wc_Sha224, Sha224);
#endif
return EXPECT_RESULT();
} /* END test_wc_InitSha224 */
/*
* Unit test on wc_Sha224Update
* Tesing wc_Sha224Update()
*/
int test_wc_Sha224Update(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224 sha224;
byte hash[WC_SHA224_DIGEST_SIZE];
testVector a, b, c;
ExpectIntEQ(wc_InitSha224(&sha224), 0);
/* Input. */
a.input = "a";
a.inLen = XSTRLEN(a.input);
ExpectIntEQ(wc_Sha224Update(&sha224, NULL, 0), 0);
ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, 0), 0);
ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_Sha224Final(&sha224, hash), 0);
/* Update input. */
a.input = "abc";
a.output = "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2"
"\x55\xb3\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7";
a.inLen = XSTRLEN(a.input);
a.outLen = XSTRLEN(a.output);
ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)a.input, (word32)a.inLen), 0);
ExpectIntEQ(wc_Sha224Final(&sha224, hash), 0);
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA224_DIGEST_SIZE), 0);
/* Pass in bad values. */
b.input = NULL;
b.inLen = 0;
ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)b.input, (word32)b.inLen), 0);
c.input = NULL;
c.inLen = WC_SHA224_DIGEST_SIZE;
ExpectIntEQ(wc_Sha224Update(&sha224, (byte*)c.input, (word32)c.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224Update(NULL, (byte*)a.input, (word32)a.inLen),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha224Free(&sha224);
DIGEST_UPDATE_TEST(wc_Sha224, Sha224);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224Update */
} /* END test_wc_Sha224Update() */
/*
* Unit test for wc_Sha224Final();
* Unit test on wc_Sha224Final
*/
int test_wc_Sha224Final(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224 sha224;
byte* hash_test[3];
byte hash1[WC_SHA224_DIGEST_SIZE];
byte hash2[2*WC_SHA224_DIGEST_SIZE];
byte hash3[5*WC_SHA224_DIGEST_SIZE];
int times, i;
/* Initialize */
ExpectIntEQ(wc_InitSha224(&sha224), 0);
hash_test[0] = hash1;
hash_test[1] = hash2;
hash_test[2] = hash3;
times = sizeof(hash_test) / sizeof(byte*);
/* Good test args. */
/* Testing oversized buffers. */
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_Sha224Final(&sha224, hash_test[i]), 0);
}
/* Test bad args. */
ExpectIntEQ(wc_Sha224Final(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224Final(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224Final(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha224Free(&sha224);
DIGEST_FINAL_TEST(wc_Sha224, Sha224, SHA224);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224Final */
/*
* Unit test function for wc_Sha224SetFlags()
*/
int test_wc_Sha224SetFlags(void)
{
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)
#define SHA224_KAT_CNT 7
int test_wc_Sha224_KATs(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224Free(NULL);
/* Set result to SUCCESS. */
ExpectTrue(1);
DIGEST_KATS_TEST_VARS(wc_Sha224, SHA224);
DIGEST_KATS_ADD("", 0,
"\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9"
"\x47\x61\x02\xbb\x28\x82\x34\xc4"
"\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a"
"\xc5\xb3\xe4\x2f");
DIGEST_KATS_ADD("a", 1,
"\xab\xd3\x75\x34\xc7\xd9\xa2\xef"
"\xb9\x46\x5d\xe9\x31\xcd\x70\x55"
"\xff\xdb\x88\x79\x56\x3a\xe9\x80"
"\x78\xd6\xd6\xd5");
DIGEST_KATS_ADD("abc", 3,
"\x23\x09\x7d\x22\x34\x05\xd8\x22"
"\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
"\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7"
"\xe3\x6c\x9d\xa7");
DIGEST_KATS_ADD("message digest", 14,
"\x2c\xb2\x1c\x83\xae\x2f\x00\x4d"
"\xe7\xe8\x1c\x3c\x70\x19\xcb\xcb"
"\x65\xb7\x1a\xb6\x56\xb2\x2d\x6d"
"\x0c\x39\xb8\xeb");
DIGEST_KATS_ADD("abcdefghijklmnopqrstuvwxyz", 26,
"\x45\xa5\xf7\x2c\x39\xc5\xcf\xf2"
"\x52\x2e\xb3\x42\x97\x99\xe4\x9e"
"\x5f\x44\xb3\x56\xef\x92\x6b\xcf"
"\x39\x0d\xcc\xc2");
DIGEST_KATS_ADD("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789", 62,
"\xbf\xf7\x2b\x4f\xcb\x7d\x75\xe5"
"\x63\x29\x00\xac\x5f\x90\xd2\x19"
"\xe0\x5e\x97\xa7\xbd\xe7\x2e\x74"
"\x0d\xb3\x93\xd9");
DIGEST_KATS_ADD("1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890", 80,
"\xb5\x0a\xec\xbe\x4e\x9b\xb0\xb5"
"\x7b\xc5\xf3\xae\x76\x0a\x8e\x01"
"\xdb\x24\xf2\x03\xfb\x3c\xdc\xd1"
"\x31\x48\x04\x6e");
DIGEST_KATS_TEST(Sha224, SHA224);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224Final */
} /* END test_wc_Sha224Free */
/*
* Unit test function for wc_Sha224GetHash()
*/
int test_wc_Sha224GetHash(void)
int test_wc_Sha224_other(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224 sha224;
byte hash1[WC_SHA224_DIGEST_SIZE];
/* Initialize */
ExpectIntEQ(wc_InitSha224(&sha224), 0);
ExpectIntEQ(wc_Sha224GetHash(&sha224, hash1), 0);
/* test bad arguments*/
ExpectIntEQ(wc_Sha224GetHash(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224GetHash(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224GetHash(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha224Free(&sha224);
DIGEST_OTHER_TEST(wc_Sha224, Sha224, SHA224,
"\x60\x81\xdf\x2f\xae\xe2\x25\xe9"
"\x87\x61\x2a\x8e\x25\x19\x16\x39"
"\x80\xfb\x77\xfa\x28\x74\x17\x4d"
"\xf3\x15\x52\x2b");
#endif
return EXPECT_RESULT();
} /* END test_wc_Sha224GetHash */
} /* END test_wc_Sha224Final */
/*
* Unit test function for wc_Sha224Copy()
*/
int test_wc_Sha224Copy(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SHA224
wc_Sha224 sha224;
wc_Sha224 temp;
XMEMSET(&sha224, 0, sizeof(wc_Sha224));
XMEMSET(&temp, 0, sizeof(wc_Sha224));
/* Initialize */
ExpectIntEQ(wc_InitSha224(&sha224), 0);
ExpectIntEQ(wc_InitSha224(&temp), 0);
ExpectIntEQ(wc_Sha224Copy(&sha224, &temp), 0);
/* test bad arguments*/
ExpectIntEQ(wc_Sha224Copy(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224Copy(NULL, &temp), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sha224Copy(&sha224, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
wc_Sha224Free(&sha224);
wc_Sha224Free(&temp);
DIGEST_COPY_TEST(wc_Sha224, Sha224, SHA224,
"\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9"
"\x47\x61\x02\xbb\x28\x82\x34\xc4"
"\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a"
"\xc5\xb3\xe4\x2f",
"\x23\x09\x7d\x22\x34\x05\xd8\x22"
"\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
"\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7"
"\xe3\x6c\x9d\xa7");
#endif
return EXPECT_RESULT();
} /* END test_wc_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_Sha256Final(void);
int test_wc_Sha256FinalRaw(void);
int test_wc_Sha256GetFlags(void);
int test_wc_Sha256Free(void);
int test_wc_Sha256GetHash(void);
int test_wc_Sha256_KATs(void);
int test_wc_Sha256_other(void);
int test_wc_Sha256Copy(void);
int test_wc_Sha256GetHash(void);
int test_wc_Sha256Transform(void);
int test_wc_Sha256_Flags(void);
int test_wc_InitSha224(void);
int test_wc_Sha224Update(void);
int test_wc_Sha224Final(void);
int test_wc_Sha224SetFlags(void);
int test_wc_Sha224GetFlags(void);
int test_wc_Sha224Free(void);
int test_wc_Sha224GetHash(void);
int test_wc_Sha224_KATs(void);
int test_wc_Sha224_other(void);
int test_wc_Sha224Copy(void);
int test_wc_Sha224GetHash(void);
int test_wc_Sha224_Flags(void);
#endif /* WOLFCRYPT_TEST_SHA256_H */

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_Sha3_Update(void);
int test_wc_Sha3_224_Final(void);
int test_wc_Sha3_256_Final(void);
int test_wc_Sha3_384_Final(void);
int test_wc_Sha3_512_Final(void);
int test_wc_Sha3_224_Copy(void);
int test_wc_Sha3_256_Copy(void);
int test_wc_Sha3_384_Copy(void);
int test_wc_Sha3_512_Copy(void);
int test_wc_Sha3_GetFlags(void);
int test_wc_Sha3_Final(void);
int test_wc_Sha3_224_KATs(void);
int test_wc_Sha3_256_KATs(void);
int test_wc_Sha3_384_KATs(void);
int test_wc_Sha3_512_KATs(void);
int test_wc_Sha3_other(void);
int test_wc_Sha3_Copy(void);
int test_wc_Sha3_GetHash(void);
int test_wc_Sha3_Flags(void);
int test_wc_InitShake128(void);
int test_wc_Shake128_Update(void);
int test_wc_Shake128_Final(void);
int test_wc_Shake128_KATs(void);
int test_wc_Shake128_other(void);
int test_wc_Shake128_Copy(void);
int test_wc_Shake128Hash(void);
int test_wc_Shake128_Absorb(void);
int test_wc_Shake128_SqueezeBlocks(void);
int test_wc_Shake128_XOF(void);
int test_wc_InitShake256(void);
int test_wc_Shake256_Update(void);
int test_wc_Shake256_Final(void);
int test_wc_Shake256_KATs(void);
int test_wc_Shake256_other(void);
int test_wc_Shake256_Copy(void);
int test_wc_Shake256Hash(void);
int test_wc_Shake256_Absorb(void);
int test_wc_Shake256_SqueezeBlocks(void);
int test_wc_Shake256_XOF(void);
#endif /* WOLFCRYPT_TEST_SHA3_H */

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_Sha512Final(void);
int test_wc_Sha512FinalRaw(void);
int test_wc_Sha512GetFlags(void);
int test_wc_Sha512Free(void);
int test_wc_Sha512GetHash(void);
int test_wc_Sha512_KATs(void);
int test_wc_Sha512_other(void);
int test_wc_Sha512Copy(void);
int test_wc_Sha512GetHash(void);
int test_wc_Sha512Transform(void);
int test_wc_Sha512_Flags(void);
int test_wc_InitSha512_224(void);
int test_wc_Sha512_224Update(void);
int test_wc_Sha512_224Final(void);
int test_wc_Sha512_224FinalRaw(void);
int test_wc_Sha512_224GetFlags(void);
int test_wc_Sha512_224Free(void);
int test_wc_Sha512_224GetHash(void);
int test_wc_Sha512_224_KATs(void);
int test_wc_Sha512_224_other(void);
int test_wc_Sha512_224Copy(void);
int test_wc_Sha512_224GetHash(void);
int test_wc_Sha512_224Transform(void);
int test_wc_Sha512_224_Flags(void);
int test_wc_InitSha512_256(void);
int test_wc_Sha512_256Update(void);
int test_wc_Sha512_256Final(void);
int test_wc_Sha512_256FinalRaw(void);
int test_wc_Sha512_256GetFlags(void);
int test_wc_Sha512_256Free(void);
int test_wc_Sha512_256GetHash(void);
int test_wc_Sha512_256_KATs(void);
int test_wc_Sha512_256_other(void);
int test_wc_Sha512_256Copy(void);
int test_wc_Sha512_256GetHash(void);
int test_wc_Sha512_256Transform(void);
int test_wc_Sha512_256_Flags(void);
int test_wc_InitSha384(void);
int test_wc_Sha384Update(void);
int test_wc_Sha384Final(void);
int test_wc_Sha384FinalRaw(void);
int test_wc_Sha384GetFlags(void);
int test_wc_Sha384Free(void);
int test_wc_Sha384GetHash(void);
int test_wc_Sha384_KATs(void);
int test_wc_Sha384_other(void);
int test_wc_Sha384Copy(void);
int test_wc_Sha384GetHash(void);
int test_wc_Sha384_Flags(void);
#endif /* WOLFCRYPT_TEST_SHA512_H */

496
tests/api/test_sm3.c
View File

@@ -40,181 +40,77 @@
#include <tests/unit.h>
#include <tests/api/api.h>
#include <tests/api/test_sm3.h>
#include <tests/api/test_digest.h>
/*
* Testing wc_InitSm3(), wc_Sm3Free()
*/
int test_wc_InitSm3Free(void)
int test_wc_InitSm3(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SM3
wc_Sm3 sm3;
/* Invalid Parameters */
ExpectIntEQ(wc_InitSm3(NULL, NULL, INVALID_DEVID),
/* Test bad arg. */
ExpectIntEQ(wc_InitSm3(NULL, HEAP_HINT, INVALID_DEVID),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Valid Parameters */
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0);
/* Test good arg. */
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
wc_Sm3Free(&sm3);
wc_Sm3Free(NULL);
wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
} /* END test_wc_InitSm3 */
}
/*
* Testing wc_Sm3Update(), wc_Sm3Final()
*/
int test_wc_Sm3UpdateFinal(void)
int test_wc_Sm3Update(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SM3
wc_Sm3 sm3;
byte data[WC_SM3_BLOCK_SIZE * 4];
byte hash[WC_SM3_DIGEST_SIZE];
byte calcHash[WC_SM3_DIGEST_SIZE];
byte expHash[WC_SM3_DIGEST_SIZE] = {
0x38, 0x48, 0x15, 0xa7, 0x0e, 0xae, 0x0b, 0x27,
0x5c, 0xde, 0x9d, 0xa5, 0xd1, 0xa4, 0x30, 0xa1,
0xca, 0xd4, 0x54, 0x58, 0x44, 0xa2, 0x96, 0x1b,
0xd7, 0x14, 0x80, 0x3f, 0x80, 0x1a, 0x07, 0xb6
};
word32 chunk;
word32 i;
XMEMSET(data, 0, sizeof(data));
/* 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, data, 1), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, data, 1), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE - 2), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_BLOCK_SIZE * 2), 0);
/* Ensure too many bytes for lengths. */
ExpectIntEQ(wc_Sm3Update(&sm3, data, WC_SM3_PAD_SIZE), 0);
ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)"a", 1), 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(&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));
/* Valid Parameters */
/* Test good args. */
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);
#endif
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)
{
EXPECT_DECLS;
@@ -223,67 +119,309 @@ int test_wc_Sm3FinalRaw(void)
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 3))) && \
!defined(WOLFSSL_NO_HASH_RAW)
wc_Sm3 sm3;
byte hash1[WC_SM3_DIGEST_SIZE];
byte hash2[WC_SM3_DIGEST_SIZE];
byte hash3[WC_SM3_DIGEST_SIZE];
byte* hash_test[3] = { hash1, hash2, hash3 };
int times;
int i;
XMEMSET(&sm3, 0, sizeof(sm3));
byte hash[WC_SM3_DIGEST_SIZE];
const char* expHash =
"\x73\x80\x16\x6f\x49\x14\xb2\xb9"
"\x17\x24\x42\xd7\xda\x8a\x06\x00"
"\xa9\x6f\x30\xbc\x16\x31\x38\xaa"
"\xe3\x8d\xee\x4d\xb0\xfb\x0e\x4e";
/* Initialize */
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
/* Invalid Parameters */
ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3FinalRaw(NULL, hash1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Test bad args. */
ExpectIntEQ(wc_Sm3FinalRaw(NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_Sm3FinalRaw(NULL, hash),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
times = sizeof(hash_test) / sizeof(byte*);
for (i = 0; i < times; i++) {
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash_test[i]), 0);
/* Test good args. */
ExpectIntEQ(wc_Sm3FinalRaw(&sm3, hash), 0);
ExpectBufEQ(hash, expHash, WC_SM3_DIGEST_SIZE);
wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
}
#define SM3_KAT_CNT 7
int test_wc_Sm3_KATs(void)
{
EXPECT_DECLS;
#ifdef WOLFSSL_SM3
wc_Sm3 sm3;
testVector sm3_kat[SM3_KAT_CNT];
byte hash[WC_SM3_DIGEST_SIZE];
int i = 0;
sm3_kat[i].input = "";
sm3_kat[i].inLen = 0;
sm3_kat[i].output =
"\x1a\xb2\x1d\x83\x55\xcf\xa1\x7f"
"\x8e\x61\x19\x48\x31\xe8\x1a\x8f"
"\x22\xbe\xc8\xc7\x28\xfe\xfb\x74"
"\x7e\xd0\x35\xeb\x50\x82\xaa\x2b";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input = "a";
sm3_kat[i].inLen = 1;
sm3_kat[i].output =
"\x62\x34\x76\xac\x18\xf6\x5a\x29"
"\x09\xe4\x3c\x7f\xec\x61\xb4\x9c"
"\x7e\x76\x4a\x91\xa1\x8c\xcb\x82"
"\xf1\x91\x7a\x29\xc8\x6c\x5e\x88";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input = "abc";
sm3_kat[i].inLen = 3;
sm3_kat[i].output =
"\x66\xc7\xf0\xf4\x62\xee\xed\xd9"
"\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2"
"\x41\x67\xc4\x87\x5c\xf2\xf7\xa2"
"\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input = "message digest";
sm3_kat[i].inLen = 14;
sm3_kat[i].output =
"\xc5\x22\xa9\x42\xe8\x9b\xd8\x0d"
"\x97\xdd\x66\x6e\x7a\x55\x31\xb3"
"\x61\x88\xc9\x81\x71\x49\xe9\xb2"
"\x58\xdf\xe5\x1e\xce\x98\xed\x77";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input = "abcdefghijklmnopqrstuvwxyz";
sm3_kat[i].inLen = 26;
sm3_kat[i].output =
"\xb8\x0f\xe9\x7a\x4d\xa2\x4a\xfc"
"\x27\x75\x64\xf6\x6a\x35\x9e\xf4"
"\x40\x46\x2a\xd2\x8d\xcc\x6d\x63"
"\xad\xb2\x4d\x5c\x20\xa6\x15\x95";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
sm3_kat[i].inLen = 62;
sm3_kat[i].output =
"\x29\x71\xd1\x0c\x88\x42\xb7\x0c"
"\x97\x9e\x55\x06\x34\x80\xc5\x0b"
"\xac\xff\xd9\x0e\x98\xe2\xe6\x0d"
"\x25\x12\xab\x8a\xbf\xdf\xce\xc5";
sm3_kat[i].outLen = 0;
i++;
sm3_kat[i].input = "1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890";
sm3_kat[i].inLen = 80;
sm3_kat[i].output =
"\xad\x81\x80\x53\x21\xf3\xe6\x9d"
"\x25\x12\x35\xbf\x88\x6a\x56\x48"
"\x44\x87\x3b\x56\xdd\x7d\xde\x40"
"\x0f\x05\x5b\x7d\xde\x39\x30\x7a";
sm3_kat[i].outLen = 0;
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
for (i = 0; i < SM3_KAT_CNT; i++) {
/* Do KAT. */
ExpectIntEQ(wc_Sm3Update(&sm3, (byte*)sm3_kat[i].input,
(word32)sm3_kat[i].inLen), 0);
ExpectIntEQ(wc_Sm3Final(&sm3, hash), 0);
ExpectBufEQ(hash, (byte*)sm3_kat[i].output, WC_SM3_DIGEST_SIZE);
}
wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sm3FinalRaw */
}
/*
* Testing wc_Sm3GetFlags, wc_Sm3SetFlags()
*/
int test_wc_Sm3GetSetFlags(void)
int test_wc_Sm3_other(void)
{
EXPECT_DECLS;
#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;
#if defined(WOLFSSL_SM3) && defined(WOLFSSL_HASH_FLAGS)
wc_Sm3 sm3;
wc_Sm3 sm3Copy;
word32 flags = 0;
wc_Sm3 sm3_copy;
word32 flags;
ExpectIntEQ(wc_InitSm3(&sm3, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_InitSm3(&sm3Copy, NULL, INVALID_DEVID), 0);
XMEMSET(&sm3_copy, 0, sizeof(sm3_copy));
ExpectIntEQ(wc_InitSm3(&sm3, HEAP_HINT, INVALID_DEVID), 0);
/* Do nothing. */
ExpectIntEQ(wc_Sm3GetFlags(NULL, NULL), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, NULL), 0);
ExpectIntEQ(wc_Sm3GetFlags(NULL, &flags), 0);
ExpectIntEQ(flags, 0);
ExpectIntEQ(wc_Sm3SetFlags(NULL, WC_HASH_FLAG_WILLCOPY), 0);
ExpectIntEQ(wc_Sm3GetFlags(NULL, &flags), 0);
ExpectIntEQ(flags, 0);
ExpectIntEQ(wc_Sm3SetFlags(NULL, 1), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0);
ExpectIntEQ(flags, 0);
ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3_copy), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0);
ExpectIntEQ(flags, 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3_copy, &flags), 0);
ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY);
ExpectIntEQ(wc_Sm3SetFlags(&sm3, WC_HASH_FLAG_WILLCOPY), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3, &flags), 0);
ExpectIntEQ(flags, WC_HASH_FLAG_WILLCOPY);
ExpectIntEQ(wc_Sm3SetFlags(&sm3, 0), 0);
ExpectIntEQ(wc_Sm3Copy(&sm3, &sm3Copy), 0);
ExpectIntEQ(wc_Sm3GetFlags(&sm3Copy, &flags), 0);
ExpectIntEQ(flags, WC_HASH_FLAG_ISCOPY | WC_HASH_FLAG_WILLCOPY);
wc_Sm3Free(&sm3Copy);
wc_Sm3Free(&sm3_copy);
wc_Sm3Free(&sm3);
#endif
return EXPECT_RESULT();
} /* END test_wc_Sm3Update */
}
/*
* Testing wc_Sm3Hash()

13
tests/api/test_sm3.h
View File

@@ -22,12 +22,15 @@
#ifndef WOLFCRYPT_TEST_SM3_H
#define WOLFCRYPT_TEST_SM3_H
int test_wc_InitSm3Free(void);
int test_wc_Sm3UpdateFinal(void);
int test_wc_Sm3GetHash(void);
int test_wc_Sm3Copy(void);
int test_wc_InitSm3(void);
int test_wc_Sm3Update(void);
int test_wc_Sm3Final(void);
int test_wc_Sm3FinalRaw(void);
int test_wc_Sm3GetSetFlags(void);
int test_wc_Sm3_KATs(void);
int test_wc_Sm3_other(void);
int test_wc_Sm3Copy(void);
int test_wc_Sm3GetHash(void);
int test_wc_Sm3_Flags(void);
int test_wc_Sm3Hash(void);
#endif /* WOLFCRYPT_TEST_SM3_H */

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 */
int wc_Blake2bUpdate(Blake2b* b2b, const byte* data, word32 sz)
{
if (b2b == NULL){
return BAD_FUNC_ARG;
}
if (data == NULL && sz != 0){
return BAD_FUNC_ARG;
}
if (sz == 0){
return 0;
}
return blake2b_update(b2b->S, data, sz);
}
@@ -498,7 +508,16 @@ int wc_Blake2bUpdate(Blake2b* b2b, const byte* data, word32 sz)
/* Blake2b Final, if pass in zero size we use init digestSz */
int wc_Blake2bFinal(Blake2b* b2b, byte* final, word32 requestSz)
{
word32 sz = requestSz ? requestSz : b2b->digestSz;
word32 sz;
if (b2b == NULL){
return BAD_FUNC_ARG;
}
if (final == NULL){
return BAD_FUNC_ARG;
}
sz = requestSz ? requestSz : b2b->digestSz;
return blake2b_final(b2b->S, final, (byte)sz);
}

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 */
int wc_Blake2sUpdate(Blake2s* b2s, const byte* data, word32 sz)
{
if (b2s == NULL){
return BAD_FUNC_ARG;
}
if (data == NULL && sz != 0){
return BAD_FUNC_ARG;
}
if (sz == 0){
return 0;
}
return blake2s_update(b2s->S, data, sz);
}
@@ -494,7 +504,16 @@ int wc_Blake2sUpdate(Blake2s* b2s, const byte* data, word32 sz)
/* Blake2s Final, if pass in zero size we use init digestSz */
int wc_Blake2sFinal(Blake2s* b2s, byte* final, word32 requestSz)
{
word32 sz = requestSz ? requestSz : b2s->digestSz;
word32 sz;
if (b2s == NULL){
return BAD_FUNC_ARG;
}
if (final == NULL){
return BAD_FUNC_ARG;
}
sz = requestSz ? requestSz : b2s->digestSz;
return blake2s_final(b2s->S, final, (byte)sz);
}

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

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
int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash)
static int Sha512FinalRaw(wc_Sha512* sha512, byte* hash, size_t digestSz)
{
#ifdef LITTLE_ENDIAN_ORDER
word64 digest[WC_SHA512_DIGEST_SIZE / sizeof(word64)];
@@ -633,15 +633,20 @@ int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash)
#ifdef LITTLE_ENDIAN_ORDER
ByteReverseWords64((word64*)digest, (word64*)sha512->digest,
WC_SHA512_DIGEST_SIZE);
XMEMCPY(hash, digest, WC_SHA512_DIGEST_SIZE);
WC_SHA512_DIGEST_SIZE);
XMEMCPY(hash, digest, digestSz);
#else
XMEMCPY(hash, sha512->digest, WC_SHA512_DIGEST_SIZE);
XMEMCPY(hash, sha512->digest, digestSz);
#endif
return 0;
}
int wc_Sha512FinalRaw(wc_Sha512* sha512, byte* hash)
{
return Sha512FinalRaw(sha512, hash, WC_SHA512_DIGEST_SIZE);
}
static int Sha512_Family_Final(wc_Sha512* sha512, byte* hash,
enum wc_HashType type)
{
@@ -1039,7 +1044,7 @@ int wc_Sha512_224Update(wc_Sha512* sha, const byte* data, word32 len)
}
int wc_Sha512_224FinalRaw(wc_Sha512* sha, byte* hash)
{
return wc_Sha512FinalRaw(sha, hash);
return Sha512FinalRaw(sha, hash, WC_SHA512_224_DIGEST_SIZE);
}
int wc_Sha512_224Final(wc_Sha512* sha512, byte* hash)
{
@@ -1089,7 +1094,7 @@ int wc_Sha512_256Update(wc_Sha512* sha, const byte* data, word32 len)
}
int wc_Sha512_256FinalRaw(wc_Sha512* sha, byte* hash)
{
return wc_Sha512FinalRaw(sha, hash);
return Sha512FinalRaw(sha, hash, WC_SHA512_256_DIGEST_SIZE);
}
int wc_Sha512_256Final(wc_Sha512* sha512, byte* hash)
{

2
wolfcrypt/src/sha256.c
View File

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

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

4
wolfssl/wolfcrypt/blake2.h
View File

@@ -49,10 +49,12 @@ enum {
#ifdef HAVE_BLAKE2B
BLAKE2B_ID = WC_HASH_TYPE_BLAKE2B,
BLAKE2B_256 = 32, /* 256 bit type, SSL default */
WC_BLAKE2B_DIGEST_SIZE = 64,
#endif
#ifdef HAVE_BLAKE2S
BLAKE2S_ID = WC_HASH_TYPE_BLAKE2S,
BLAKE2S_256 = 32 /* 256 bit type */
BLAKE2S_256 = 32, /* 256 bit type */
WC_BLAKE2S_DIGEST_SIZE = 32
#endif
};