wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-08-02 12:14:38 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #640 from jrblixt/unitTest_api_dev

Browse Source 
unit test md5, sha, sha256, sha384, sha512
This commit is contained in:
toddouska
2017-05-17 09:17:32 -07:00
committed by GitHub
parent 4c451a6c61 cb3b10054d
commit 2f15d57a6f
11 changed files with 1539 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
mcapi/crypto.c
View File

@@ -52,9 +52,7 @@ int CRYPT_MD5_Initialize(CRYPT_MD5_CTX* md5)
if (md5 == NULL) if (md5 == NULL)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
wc_InitMd5((Md5*)md5); return wc_InitMd5((Md5*)md5);
return 0;
} }
@@ -65,9 +63,7 @@ int CRYPT_MD5_DataAdd(CRYPT_MD5_CTX* md5, const unsigned char* input,
if (md5 == NULL || input == NULL) if (md5 == NULL || input == NULL)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
wc_Md5Update((Md5*)md5, input, sz); return wc_Md5Update((Md5*)md5, input, sz);
return 0;
} }
@@ -77,9 +73,7 @@ int CRYPT_MD5_Finalize(CRYPT_MD5_CTX* md5, unsigned char* digest)
if (md5 == NULL || digest == NULL) if (md5 == NULL || digest == NULL)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
wc_Md5Final((Md5*)md5, digest); return wc_Md5Final((Md5*)md5, digest);
return 0;
} }

17
mcapi/mcapi_test.c
View File

@@ -214,17 +214,22 @@ static int check_md5(void)
{ {
CRYPT_MD5_CTX mcMd5; CRYPT_MD5_CTX mcMd5;
Md5 defMd5; Md5 defMd5;
int ret;
byte mcDigest[CRYPT_MD5_DIGEST_SIZE]; byte mcDigest[CRYPT_MD5_DIGEST_SIZE];
byte defDigest[MD5_DIGEST_SIZE]; byte defDigest[MD5_DIGEST_SIZE];
CRYPT_MD5_Initialize(&mcMd5); CRYPT_MD5_Initialize(&mcMd5);
wc_InitMd5(&defMd5); ret = wc_InitMd5(&defMd5);
CRYPT_MD5_DataAdd(&mcMd5, ourData, OUR_DATA_SIZE); if (ret == 0) {
wc_Md5Update(&defMd5, ourData, OUR_DATA_SIZE); CRYPT_MD5_DataAdd(&mcMd5, ourData, OUR_DATA_SIZE);
ret = wc_Md5Update(&defMd5, ourData, OUR_DATA_SIZE);
}
CRYPT_MD5_Finalize(&mcMd5, mcDigest); if (ret == 0) {
wc_Md5Final(&defMd5, defDigest); CRYPT_MD5_Finalize(&mcMd5, mcDigest);
ret = wc_Md5Final(&defMd5, defDigest);
}
if (memcmp(mcDigest, defDigest, CRYPT_MD5_DIGEST_SIZE) != 0) { if (memcmp(mcDigest, defDigest, CRYPT_MD5_DIGEST_SIZE) != 0) {
printf("md5 final memcmp fialed\n"); printf("md5 final memcmp fialed\n");
@@ -232,7 +237,7 @@ static int check_md5(void)
} }
printf("md5 mcapi test passed\n"); printf("md5 mcapi test passed\n");
return 0; return ret;
} }

53
src/keys.c
View File

@@ -3087,10 +3087,10 @@ int DeriveKeys(WOLFSSL* ssl)
} }
#endif #endif
wc_InitMd5(md5); ret = wc_InitMd5(md5);
if (ret == 0) {
ret = wc_InitSha(sha); ret = wc_InitSha(sha);
}
if (ret == 0) { if (ret == 0) {
XMEMCPY(md5Input, ssl->arrays->masterSecret, SECRET_LEN); XMEMCPY(md5Input, ssl->arrays->masterSecret, SECRET_LEN);
@@ -3108,14 +3108,21 @@ int DeriveKeys(WOLFSSL* ssl)
XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN); XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN);
idx += RAN_LEN; idx += RAN_LEN;
XMEMCPY(shaInput + idx, ssl->arrays->clientRandom, RAN_LEN); XMEMCPY(shaInput + idx, ssl->arrays->clientRandom, RAN_LEN);
if (ret == 0) {
wc_ShaUpdate(sha, shaInput, (KEY_PREFIX + SECRET_LEN + 2 * RAN_LEN) ret = wc_ShaUpdate(sha, shaInput,
- KEY_PREFIX + j); (KEY_PREFIX + SECRET_LEN + 2 * RAN_LEN) - KEY_PREFIX + j);
wc_ShaFinal(sha, shaOutput); }
if (ret == 0) {
ret = wc_ShaFinal(sha, shaOutput);
}
XMEMCPY(md5Input + SECRET_LEN, shaOutput, SHA_DIGEST_SIZE); XMEMCPY(md5Input + SECRET_LEN, shaOutput, SHA_DIGEST_SIZE);
wc_Md5Update(md5, md5Input, SECRET_LEN + SHA_DIGEST_SIZE); if (ret == 0) {
wc_Md5Final(md5, keyData + i * MD5_DIGEST_SIZE); ret = wc_Md5Update(md5, md5Input, SECRET_LEN + SHA_DIGEST_SIZE);
}
if (ret == 0) {
ret = wc_Md5Final(md5, keyData + i * MD5_DIGEST_SIZE);
}
} }
if (ret == 0) if (ret == 0)
@@ -3206,10 +3213,10 @@ static int MakeSslMasterSecret(WOLFSSL* ssl)
} }
#endif #endif
wc_InitMd5(md5); ret = wc_InitMd5(md5);
if (ret == 0) {
ret = wc_InitSha(sha); ret = wc_InitSha(sha);
}
if (ret == 0) { if (ret == 0) {
XMEMCPY(md5Input, ssl->arrays->preMasterSecret, pmsSz); XMEMCPY(md5Input, ssl->arrays->preMasterSecret, pmsSz);
@@ -3230,14 +3237,22 @@ static int MakeSslMasterSecret(WOLFSSL* ssl)
idx += RAN_LEN; idx += RAN_LEN;
XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN); XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN);
idx += RAN_LEN; idx += RAN_LEN;
wc_ShaUpdate(sha, shaInput, idx); if (ret == 0) {
wc_ShaFinal(sha, shaOutput); ret = wc_ShaUpdate(sha, shaInput, idx);
}
if (ret == 0) {
ret = wc_ShaFinal(sha, shaOutput);
}
idx = pmsSz; /* preSz */ idx = pmsSz; /* preSz */
XMEMCPY(md5Input + idx, shaOutput, SHA_DIGEST_SIZE); XMEMCPY(md5Input + idx, shaOutput, SHA_DIGEST_SIZE);
idx += SHA_DIGEST_SIZE; idx += SHA_DIGEST_SIZE;
wc_Md5Update(md5, md5Input, idx); if (ret == 0) {
wc_Md5Final(md5, &ssl->arrays->masterSecret[i * MD5_DIGEST_SIZE]); ret = wc_Md5Update(md5, md5Input, idx);
}
if (ret == 0) {
ret = wc_Md5Final(md5,
&ssl->arrays->masterSecret[i * MD5_DIGEST_SIZE]);
}
} }
#ifdef SHOW_SECRETS #ifdef SHOW_SECRETS

10
src/sniffer.c
View File

@@ -566,8 +566,9 @@ static int HashInit(HsHashes* hash)
ret = wc_InitSha(&hash->hashSha); ret = wc_InitSha(&hash->hashSha);
#endif #endif
#ifndef NO_MD5 #ifndef NO_MD5
if (ret == 0) if (ret == 0) {
wc_InitMd5(&hash->hashMd5); ret = wc_InitMd5(&hash->hashMd5);
}
#endif #endif
#endif #endif
#ifndef NO_SHA256 #ifndef NO_SHA256
@@ -596,8 +597,9 @@ static int HashUpdate(HsHashes* hash, const byte* input, int sz)
ret = wc_ShaUpdate(&hash->hashSha, input, sz); ret = wc_ShaUpdate(&hash->hashSha, input, sz);
#endif #endif
#ifndef NO_MD5 #ifndef NO_MD5
if (ret == 0) if (ret == 0) {
wc_Md5Update(&hash->hashMd5, input, sz); ret = wc_Md5Update(&hash->hashMd5, input, sz);
}
#endif #endif
#endif #endif
#ifndef NO_SHA256 #ifndef NO_SHA256

1093
tests/api.c
View File

File diff suppressed because it is too large Load Diff

18
tests/hash.c
View File

@@ -255,6 +255,7 @@ int md4_test(void)
int md5_test(void) int md5_test(void)
{ {
Md5 md5; Md5 md5;
int ret;
byte hash[MD5_DIGEST_SIZE]; byte hash[MD5_DIGEST_SIZE];
testVector a, b, c, d, e; testVector a, b, c, d, e;
@@ -299,11 +300,22 @@ int md5_test(void)
test_md5[3] = d; test_md5[3] = d;
test_md5[4] = e; test_md5[4] = e;
wc_InitMd5(&md5); ret = wc_InitMd5(&md5);
if (ret) {
return ret;
}
for (i = 0; i < times; ++i) { for (i = 0; i < times; ++i) {
wc_Md5Update(&md5, (byte*)test_md5[i].input, (word32)test_md5[i].inLen); ret = wc_Md5Update(&md5, (byte*)test_md5[i].input,
wc_Md5Final(&md5, hash); (word32)test_md5[i].inLen);
if (ret) {
return ret;
}
ret = wc_Md5Final(&md5, hash);
if (ret) {
return ret;
}
if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0) if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0)
return -5 - i; return -5 - i;

3
wolfcrypt/src/md5.c
View File

@@ -443,6 +443,9 @@ int wc_Md5Final(Md5* md5, byte* hash)
int wc_InitMd5(Md5* md5) int wc_InitMd5(Md5* md5)
{ {
if (md5 == NULL) {
return BAD_FUNC_ARG;
}
return wc_InitMd5_ex(md5, NULL, INVALID_DEVID); return wc_InitMd5_ex(md5, NULL, INVALID_DEVID);
} }

75
wolfcrypt/src/pwdbased.c
View File

@@ -90,10 +90,22 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
switch (hashType) { switch (hashType) {
#ifndef NO_MD5 #ifndef NO_MD5
case MD5: case MD5:
wc_InitMd5(&md5); ret = wc_InitMd5(&md5);
wc_Md5Update(&md5, passwd, pLen); if (ret != 0) {
wc_Md5Update(&md5, salt, sLen); return ret;
wc_Md5Final(&md5, buffer); }
ret = wc_Md5Update(&md5, passwd, pLen);
if (ret != 0) {
return ret;
}
ret = wc_Md5Update(&md5, salt, sLen);
if (ret != 0) {
return ret;
}
ret = wc_Md5Final(&md5, buffer);
if (ret != 0) {
return ret;
}
break; break;
#endif /* NO_MD5 */ #endif /* NO_MD5 */
case SHA: case SHA:
@@ -114,8 +126,14 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
} }
#ifndef NO_MD5 #ifndef NO_MD5
else { else {
wc_Md5Update(&md5, buffer, hLen); ret = wc_Md5Update(&md5, buffer, hLen);
wc_Md5Final(&md5, buffer); if (ret != 0) {
return ret;
}
ret = wc_Md5Final(&md5, buffer);
if (ret != 0) {
return ret;
}
} }
#endif #endif
} }
@@ -302,13 +320,28 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
case MD5: case MD5:
{ {
Md5 md5; Md5 md5;
wc_InitMd5(&md5); ret = wc_InitMd5(&md5);
wc_Md5Update(&md5, buffer, totalLen); if (ret != 0) {
wc_Md5Final(&md5, Ai); break;
}
ret = wc_Md5Update(&md5, buffer, totalLen);
if (ret != 0) {
break;
}
ret = wc_Md5Final(&md5, Ai);
if (ret != 0) {
break;
}
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
wc_Md5Update(&md5, Ai, u); ret = wc_Md5Update(&md5, Ai, u);
wc_Md5Final(&md5, Ai); if (ret != 0) {
break;
}
ret = wc_Md5Final(&md5, Ai);
if (ret != 0) {
break;
}
} }
} }
break; break;
@@ -320,12 +353,24 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
ret = wc_InitSha(&sha); ret = wc_InitSha(&sha);
if (ret != 0) if (ret != 0)
break; break;
wc_ShaUpdate(&sha, buffer, totalLen); ret = wc_ShaUpdate(&sha, buffer, totalLen);
wc_ShaFinal(&sha, Ai); if (ret != 0) {
break;
}
ret = wc_ShaFinal(&sha, Ai);
if (ret != 0) {
break;
}
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
wc_ShaUpdate(&sha, Ai, u); ret = wc_ShaUpdate(&sha, Ai, u);
wc_ShaFinal(&sha, Ai); if (ret != 0) {
break;
}
ret = wc_ShaFinal(&sha, Ai);
if (ret != 0) {
break;
}
} }
} }
break; break;

52
wolfcrypt/src/sha.c
View File

@@ -33,25 +33,37 @@
/* fips wrapper calls, user can call direct */ /* fips wrapper calls, user can call direct */
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
int wc_InitSha(Sha* sha) int wc_InitSha(Sha* sha)
{ {
return InitSha_fips(sha); if (sha == NULL) {
} return BAD_FUNC_ARG;
}
return InitSha_fips(sha);
}
int wc_InitSha_ex(Sha* sha, void* heap, int devId) int wc_InitSha_ex(Sha* sha, void* heap, int devId)
{ {
(void)heap; (void)heap;
(void)devId; (void)devId;
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha_fips(sha); return InitSha_fips(sha);
} }
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len) int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
{ {
return ShaUpdate_fips(sha, data, len); if (sha == NULL || (data == NULL && len > 0)) {
} return BAD_FUNC_ARG;
}
return ShaUpdate_fips(sha, data, len);
}
int wc_ShaFinal(Sha* sha, byte* out) int wc_ShaFinal(Sha* sha, byte* out)
{ {
return ShaFinal_fips(sha,out); if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return ShaFinal_fips(sha,out);
} }
void wc_ShaFree(Sha* sha) void wc_ShaFree(Sha* sha)
{ {
@@ -418,10 +430,16 @@ int wc_InitSha_ex(Sha* sha, void* heap, int devId)
return ret; return ret;
} }
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len) int wc_ShaUpdate (Sha* sha, const byte* data, word32 len)
{ {
byte* local;
if (sha == NULL ||(data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
/* do block size increments */ /* do block size increments */
byte* local = (byte*)sha->buffer; local = (byte*)sha->buffer;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA)
if (sha->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA) { if (sha->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA) {
@@ -458,7 +476,13 @@ int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
int wc_ShaFinal(Sha* sha, byte* hash) int wc_ShaFinal(Sha* sha, byte* hash)
{ {
byte* local = (byte*)sha->buffer; byte* local;
if (sha == NULL || hash == NULL) {
return BAD_FUNC_ARG;
}
local = (byte*)sha->buffer;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA)
if (sha->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA) { if (sha->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA) {

17
wolfcrypt/src/sha256.c
View File

@@ -38,20 +38,32 @@
int wc_InitSha256(Sha256* sha) int wc_InitSha256(Sha256* sha)
{ {
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha256_fips(sha); return InitSha256_fips(sha);
} }
int wc_InitSha256_ex(Sha256* sha, void* heap, int devId) int wc_InitSha256_ex(Sha256* sha, void* heap, int devId)
{ {
(void)heap; (void)heap;
(void)devId; (void)devId;
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha256_fips(sha); return InitSha256_fips(sha);
} }
int wc_Sha256Update(Sha256* sha, const byte* data, word32 len) int wc_Sha256Update(Sha256* sha, const byte* data, word32 len)
{ {
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
return Sha256Update_fips(sha, data, len); return Sha256Update_fips(sha, data, len);
} }
int wc_Sha256Final(Sha256* sha, byte* out) int wc_Sha256Final(Sha256* sha, byte* out)
{ {
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return Sha256Final_fips(sha, out); return Sha256Final_fips(sha, out);
} }
void wc_Sha256Free(Sha256* sha) void wc_Sha256Free(Sha256* sha)
@@ -553,9 +565,14 @@ static int InitSha256(Sha256* sha256)
static INLINE int Sha256Final(Sha256* sha256) static INLINE int Sha256Final(Sha256* sha256)
{ {
int ret; int ret;
byte* local = (byte*)sha256->buffer; byte* local = (byte*)sha256->buffer;
if (sha256 == NULL) {
return BAD_FUNC_ARG;
}
SAVE_XMM_YMM; /* for Intel AVX */ SAVE_XMM_YMM; /* for Intel AVX */
AddLength(sha256, sha256->buffLen); /* before adding pads */ AddLength(sha256, sha256->buffLen); /* before adding pads */

140
wolfcrypt/src/sha512.c
View File

@@ -27,6 +27,7 @@
#include <wolfssl/wolfcrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifdef WOLFSSL_SHA512 #ifdef WOLFSSL_SHA512
#include <wolfssl/wolfcrypt/error-crypt.h>
#include <wolfssl/wolfcrypt/sha512.h> #include <wolfssl/wolfcrypt/sha512.h>
#include <wolfssl/wolfcrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
@@ -35,20 +36,35 @@
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
int wc_InitSha512(Sha512* sha) int wc_InitSha512(Sha512* sha)
{ {
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha512_fips(sha); return InitSha512_fips(sha);
} }
int wc_InitSha512_ex(Sha512* sha, void* heap, int devId) int wc_InitSha512_ex(Sha512* sha, void* heap, int devId)
{ {
(void)heap; (void)heap;
(void)devId; (void)devId;
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha512_fips(sha); return InitSha512_fips(sha);
} }
int wc_Sha512Update(Sha512* sha, const byte* data, word32 len) int wc_Sha512Update(Sha512* sha, const byte* data, word32 len)
{ {
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
return Sha512Update_fips(sha, data, len); return Sha512Update_fips(sha, data, len);
} }
int wc_Sha512Final(Sha512* sha, byte* out) int wc_Sha512Final(Sha512* sha, byte* out)
{ {
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return Sha512Final_fips(sha, out); return Sha512Final_fips(sha, out);
} }
void wc_Sha512Free(Sha512* sha) void wc_Sha512Free(Sha512* sha)
@@ -60,20 +76,32 @@
#if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM) #if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM)
int wc_InitSha384(Sha384* sha) int wc_InitSha384(Sha384* sha)
{ {
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha384_fips(sha); return InitSha384_fips(sha);
} }
int wc_InitSha384_ex(Sha384* sha, void* heap, int devId) int wc_InitSha384_ex(Sha384* sha, void* heap, int devId)
{ {
(void)heap; (void)heap;
(void)devId; (void)devId;
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha384_fips(sha); return InitSha384_fips(sha);
} }
int wc_Sha384Update(Sha384* sha, const byte* data, word32 len) int wc_Sha384Update(Sha384* sha, const byte* data, word32 len)
{ {
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
return Sha384Update_fips(sha, data, len); return Sha384Update_fips(sha, data, len);
} }
int wc_Sha384Final(Sha384* sha, byte* out) int wc_Sha384Final(Sha384* sha, byte* out)
{ {
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return Sha384Final_fips(sha, out); return Sha384Final_fips(sha, out);
} }
void wc_Sha384Free(Sha384* sha) void wc_Sha384Free(Sha384* sha)
@@ -294,8 +322,8 @@ static int InitSha512(Sha512* sha512)
if(cpuid_flag(7, 0, EBX, 8)) { cpuid_flags |= CPUID_BMI2 ; } if(cpuid_flag(7, 0, EBX, 8)) { cpuid_flags |= CPUID_BMI2 ; }
if(cpuid_flag(1, 0, ECX, 30)){ cpuid_flags |= CPUID_RDRAND ; } if(cpuid_flag(1, 0, ECX, 30)){ cpuid_flags |= CPUID_RDRAND ; }
if(cpuid_flag(7, 0, EBX, 18)){ cpuid_flags |= CPUID_RDSEED ; } if(cpuid_flag(7, 0, EBX, 18)){ cpuid_flags |= CPUID_RDSEED ; }
cpuid_check = 1 ; cpuid_check = 1 ;
return 0 ; return 0 ;
} }
return 1 ; return 1 ;
} }
@@ -384,46 +412,46 @@ static int InitSha512(Sha512* sha512)
#endif #endif
static const word64 K512[80] = { static const word64 K512[80] = {
W64LIT(0x428a2f98d728ae22), W64LIT(0x7137449123ef65cd), W64LIT(0x428a2f98d728ae22), W64LIT(0x7137449123ef65cd),
W64LIT(0xb5c0fbcfec4d3b2f), W64LIT(0xe9b5dba58189dbbc), W64LIT(0xb5c0fbcfec4d3b2f), W64LIT(0xe9b5dba58189dbbc),
W64LIT(0x3956c25bf348b538), W64LIT(0x59f111f1b605d019), W64LIT(0x3956c25bf348b538), W64LIT(0x59f111f1b605d019),
W64LIT(0x923f82a4af194f9b), W64LIT(0xab1c5ed5da6d8118), W64LIT(0x923f82a4af194f9b), W64LIT(0xab1c5ed5da6d8118),
W64LIT(0xd807aa98a3030242), W64LIT(0x12835b0145706fbe), W64LIT(0xd807aa98a3030242), W64LIT(0x12835b0145706fbe),
W64LIT(0x243185be4ee4b28c), W64LIT(0x550c7dc3d5ffb4e2), W64LIT(0x243185be4ee4b28c), W64LIT(0x550c7dc3d5ffb4e2),
W64LIT(0x72be5d74f27b896f), W64LIT(0x80deb1fe3b1696b1), W64LIT(0x72be5d74f27b896f), W64LIT(0x80deb1fe3b1696b1),
W64LIT(0x9bdc06a725c71235), W64LIT(0xc19bf174cf692694), W64LIT(0x9bdc06a725c71235), W64LIT(0xc19bf174cf692694),
W64LIT(0xe49b69c19ef14ad2), W64LIT(0xefbe4786384f25e3), W64LIT(0xe49b69c19ef14ad2), W64LIT(0xefbe4786384f25e3),
W64LIT(0x0fc19dc68b8cd5b5), W64LIT(0x240ca1cc77ac9c65), W64LIT(0x0fc19dc68b8cd5b5), W64LIT(0x240ca1cc77ac9c65),
W64LIT(0x2de92c6f592b0275), W64LIT(0x4a7484aa6ea6e483), W64LIT(0x2de92c6f592b0275), W64LIT(0x4a7484aa6ea6e483),
W64LIT(0x5cb0a9dcbd41fbd4), W64LIT(0x76f988da831153b5), W64LIT(0x5cb0a9dcbd41fbd4), W64LIT(0x76f988da831153b5),
W64LIT(0x983e5152ee66dfab), W64LIT(0xa831c66d2db43210), W64LIT(0x983e5152ee66dfab), W64LIT(0xa831c66d2db43210),
W64LIT(0xb00327c898fb213f), W64LIT(0xbf597fc7beef0ee4), W64LIT(0xb00327c898fb213f), W64LIT(0xbf597fc7beef0ee4),
W64LIT(0xc6e00bf33da88fc2), W64LIT(0xd5a79147930aa725), W64LIT(0xc6e00bf33da88fc2), W64LIT(0xd5a79147930aa725),
W64LIT(0x06ca6351e003826f), W64LIT(0x142929670a0e6e70), W64LIT(0x06ca6351e003826f), W64LIT(0x142929670a0e6e70),
W64LIT(0x27b70a8546d22ffc), W64LIT(0x2e1b21385c26c926), W64LIT(0x27b70a8546d22ffc), W64LIT(0x2e1b21385c26c926),
W64LIT(0x4d2c6dfc5ac42aed), W64LIT(0x53380d139d95b3df), W64LIT(0x4d2c6dfc5ac42aed), W64LIT(0x53380d139d95b3df),
W64LIT(0x650a73548baf63de), W64LIT(0x766a0abb3c77b2a8), W64LIT(0x650a73548baf63de), W64LIT(0x766a0abb3c77b2a8),
W64LIT(0x81c2c92e47edaee6), W64LIT(0x92722c851482353b), W64LIT(0x81c2c92e47edaee6), W64LIT(0x92722c851482353b),
W64LIT(0xa2bfe8a14cf10364), W64LIT(0xa81a664bbc423001), W64LIT(0xa2bfe8a14cf10364), W64LIT(0xa81a664bbc423001),
W64LIT(0xc24b8b70d0f89791), W64LIT(0xc76c51a30654be30), W64LIT(0xc24b8b70d0f89791), W64LIT(0xc76c51a30654be30),
W64LIT(0xd192e819d6ef5218), W64LIT(0xd69906245565a910), W64LIT(0xd192e819d6ef5218), W64LIT(0xd69906245565a910),
W64LIT(0xf40e35855771202a), W64LIT(0x106aa07032bbd1b8), W64LIT(0xf40e35855771202a), W64LIT(0x106aa07032bbd1b8),
W64LIT(0x19a4c116b8d2d0c8), W64LIT(0x1e376c085141ab53), W64LIT(0x19a4c116b8d2d0c8), W64LIT(0x1e376c085141ab53),
W64LIT(0x2748774cdf8eeb99), W64LIT(0x34b0bcb5e19b48a8), W64LIT(0x2748774cdf8eeb99), W64LIT(0x34b0bcb5e19b48a8),
W64LIT(0x391c0cb3c5c95a63), W64LIT(0x4ed8aa4ae3418acb), W64LIT(0x391c0cb3c5c95a63), W64LIT(0x4ed8aa4ae3418acb),
W64LIT(0x5b9cca4f7763e373), W64LIT(0x682e6ff3d6b2b8a3), W64LIT(0x5b9cca4f7763e373), W64LIT(0x682e6ff3d6b2b8a3),
W64LIT(0x748f82ee5defb2fc), W64LIT(0x78a5636f43172f60), W64LIT(0x748f82ee5defb2fc), W64LIT(0x78a5636f43172f60),
W64LIT(0x84c87814a1f0ab72), W64LIT(0x8cc702081a6439ec), W64LIT(0x84c87814a1f0ab72), W64LIT(0x8cc702081a6439ec),
W64LIT(0x90befffa23631e28), W64LIT(0xa4506cebde82bde9), W64LIT(0x90befffa23631e28), W64LIT(0xa4506cebde82bde9),
W64LIT(0xbef9a3f7b2c67915), W64LIT(0xc67178f2e372532b), W64LIT(0xbef9a3f7b2c67915), W64LIT(0xc67178f2e372532b),
W64LIT(0xca273eceea26619c), W64LIT(0xd186b8c721c0c207), W64LIT(0xca273eceea26619c), W64LIT(0xd186b8c721c0c207),
W64LIT(0xeada7dd6cde0eb1e), W64LIT(0xf57d4f7fee6ed178), W64LIT(0xeada7dd6cde0eb1e), W64LIT(0xf57d4f7fee6ed178),
W64LIT(0x06f067aa72176fba), W64LIT(0x0a637dc5a2c898a6), W64LIT(0x06f067aa72176fba), W64LIT(0x0a637dc5a2c898a6),
W64LIT(0x113f9804bef90dae), W64LIT(0x1b710b35131c471b), W64LIT(0x113f9804bef90dae), W64LIT(0x1b710b35131c471b),
W64LIT(0x28db77f523047d84), W64LIT(0x32caab7b40c72493), W64LIT(0x28db77f523047d84), W64LIT(0x32caab7b40c72493),
W64LIT(0x3c9ebe0a15c9bebc), W64LIT(0x431d67c49c100d4c), W64LIT(0x3c9ebe0a15c9bebc), W64LIT(0x431d67c49c100d4c),
W64LIT(0x4cc5d4becb3e42b6), W64LIT(0x597f299cfc657e2a), W64LIT(0x4cc5d4becb3e42b6), W64LIT(0x597f299cfc657e2a),
W64LIT(0x5fcb6fab3ad6faec), W64LIT(0x6c44198c4a475817) W64LIT(0x5fcb6fab3ad6faec), W64LIT(0x6c44198c4a475817)
}; };
@@ -524,10 +552,13 @@ static INLINE void AddLength(Sha512* sha512, word32 len)
static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len) static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len)
{ {
int ret = 0; int ret = 0;
/* do block size increments */ /* do block size increments */
byte* local = (byte*)sha512->buffer; byte* local = (byte*)sha512->buffer;
if (sha512 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
/* check that internal buffLen is valid */ /* check that internal buffLen is valid */
if (sha512->buffLen >= SHA512_BLOCK_SIZE) if (sha512->buffLen >= SHA512_BLOCK_SIZE)
return BUFFER_E; return BUFFER_E;
@@ -564,6 +595,10 @@ static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len)
int wc_Sha512Update(Sha512* sha512, const byte* data, word32 len) int wc_Sha512Update(Sha512* sha512, const byte* data, word32 len)
{ {
if (sha512 == NULL ||(data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) { if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) {
#if defined(HAVE_INTEL_QA) #if defined(HAVE_INTEL_QA)
@@ -581,6 +616,10 @@ static INLINE int Sha512Final(Sha512* sha512)
byte* local = (byte*)sha512->buffer; byte* local = (byte*)sha512->buffer;
int ret; int ret;
if (sha512 == NULL) {
return BAD_FUNC_ARG;
}
SAVE_XMM_YMM ; /* for Intel AVX */ SAVE_XMM_YMM ; /* for Intel AVX */
AddLength(sha512, sha512->buffLen); /* before adding pads */ AddLength(sha512, sha512->buffLen); /* before adding pads */
@@ -642,6 +681,10 @@ int wc_Sha512Final(Sha512* sha512, byte* hash)
{ {
int ret; int ret;
if (sha512 == NULL || hash == NULL) {
return BAD_FUNC_ARG;
}
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) { if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) {
#if defined(HAVE_INTEL_QA) #if defined(HAVE_INTEL_QA)
@@ -1362,6 +1405,10 @@ static int Transform_AVX2(Sha512* sha512)
#ifdef WOLFSSL_SHA384 #ifdef WOLFSSL_SHA384
static int InitSha384(Sha384* sha384) static int InitSha384(Sha384* sha384)
{ {
if (sha384 == NULL) {
return BAD_FUNC_ARG;
}
sha384->digest[0] = W64LIT(0xcbbb9d5dc1059ed8); sha384->digest[0] = W64LIT(0xcbbb9d5dc1059ed8);
sha384->digest[1] = W64LIT(0x629a292a367cd507); sha384->digest[1] = W64LIT(0x629a292a367cd507);
sha384->digest[2] = W64LIT(0x9159015a3070dd17); sha384->digest[2] = W64LIT(0x9159015a3070dd17);
@@ -1380,6 +1427,9 @@ static int InitSha384(Sha384* sha384)
int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len) int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len)
{ {
if (sha384 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) { if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {
@@ -1397,6 +1447,10 @@ int wc_Sha384Final(Sha384* sha384, byte* hash)
{ {
int ret; int ret;
if (sha384 == NULL || hash == NULL) {
return BAD_FUNC_ARG;
}
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) { if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {
#if defined(HAVE_INTEL_QA) #if defined(HAVE_INTEL_QA)