diff --git a/mcapi/crypto.c b/mcapi/crypto.c index d0216035d..8ccf00460 100644 --- a/mcapi/crypto.c +++ b/mcapi/crypto.c @@ -52,9 +52,7 @@ int CRYPT_MD5_Initialize(CRYPT_MD5_CTX* md5) if (md5 == NULL) return BAD_FUNC_ARG; - wc_InitMd5((Md5*)md5); - - return 0; + return wc_InitMd5((Md5*)md5); } @@ -65,9 +63,7 @@ int CRYPT_MD5_DataAdd(CRYPT_MD5_CTX* md5, const unsigned char* input, if (md5 == NULL || input == NULL) return BAD_FUNC_ARG; - wc_Md5Update((Md5*)md5, input, sz); - - return 0; + return wc_Md5Update((Md5*)md5, input, sz); } @@ -77,9 +73,7 @@ int CRYPT_MD5_Finalize(CRYPT_MD5_CTX* md5, unsigned char* digest) if (md5 == NULL || digest == NULL) return BAD_FUNC_ARG; - wc_Md5Final((Md5*)md5, digest); - - return 0; + return wc_Md5Final((Md5*)md5, digest); } diff --git a/mcapi/mcapi_test.c b/mcapi/mcapi_test.c index 0a6d77e74..75f86c3f5 100644 --- a/mcapi/mcapi_test.c +++ b/mcapi/mcapi_test.c @@ -214,17 +214,27 @@ static int check_md5(void) { CRYPT_MD5_CTX mcMd5; Md5 defMd5; + int ret; byte mcDigest[CRYPT_MD5_DIGEST_SIZE]; byte defDigest[MD5_DIGEST_SIZE]; CRYPT_MD5_Initialize(&mcMd5); - wc_InitMd5(&defMd5); + ret = wc_InitMd5(&defMd5); + if (ret != 0) { + return ret; + } CRYPT_MD5_DataAdd(&mcMd5, ourData, OUR_DATA_SIZE); - wc_Md5Update(&defMd5, ourData, OUR_DATA_SIZE); + ret = wc_Md5Update(&defMd5, ourData, OUR_DATA_SIZE); + if (ret != 0) { + return ret; + } CRYPT_MD5_Finalize(&mcMd5, mcDigest); - wc_Md5Final(&defMd5, defDigest); + ret = wc_Md5Final(&defMd5, defDigest); + if (ret != 0) { + return ret; + } if (memcmp(mcDigest, defDigest, CRYPT_MD5_DIGEST_SIZE) != 0) { printf("md5 final memcmp fialed\n"); @@ -232,7 +242,7 @@ static int check_md5(void) } printf("md5 mcapi test passed\n"); - return 0; + return ret; } diff --git a/src/internal.c b/src/internal.c index e4701b8bf..a214b7fcb 100644 --- a/src/internal.c +++ b/src/internal.c @@ -3531,7 +3531,10 @@ int InitSSL(WOLFSSL* ssl, WOLFSSL_CTX* ctx) #ifndef NO_OLD_TLS #ifndef NO_MD5 - wc_InitMd5(&ssl->hsHashes->hashMd5); + ret = wc_InitMd5(&ssl->hsHashes->hashMd5); + if (ret != 0) { + return ret; + } #endif #ifndef NO_SHA ret = wc_InitSha(&ssl->hsHashes->hashSha); @@ -4746,7 +4749,10 @@ static int HashOutputRaw(WOLFSSL* ssl, const byte* output, int sz) wc_ShaUpdate(&ssl->hsHashes->hashSha, output, sz); #endif #ifndef NO_MD5 - wc_Md5Update(&ssl->hsHashes->hashMd5, output, sz); + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, output, sz); + if (ret != 0) { + return ret; + } #endif #endif /* NO_OLD_TLS */ @@ -4794,10 +4800,16 @@ static int HashOutput(WOLFSSL* ssl, const byte* output, int sz, int ivSz) #endif #ifndef NO_OLD_TLS #ifndef NO_SHA - wc_ShaUpdate(&ssl->hsHashes->hashSha, adj, sz); + ret = wc_ShaUpdate(&ssl->hsHashes->hashSha, adj, sz); + if (ret != 0) { + return ret; + } #endif #ifndef NO_MD5 - wc_Md5Update(&ssl->hsHashes->hashMd5, adj, sz); + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, adj, sz); + if (ret != 0) { + return ret; + } #endif #endif @@ -5439,9 +5451,9 @@ static const byte PAD2[PAD_MD5] = #include #endif -static void BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender) +static int BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender) { - + int ret; byte md5_result[MD5_DIGEST_SIZE]; #ifdef WOLFSSL_SMALL_STACK @@ -5455,24 +5467,81 @@ static void BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender) /* make md5 inner */ md5[0] = ssl->hsHashes->hashMd5 ; /* Save current position */ - wc_Md5Update(&ssl->hsHashes->hashMd5, sender, SIZEOF_SENDER); - wc_Md5Update(&ssl->hsHashes->hashMd5, ssl->arrays->masterSecret,SECRET_LEN); - wc_Md5Update(&ssl->hsHashes->hashMd5, PAD1, PAD_MD5); + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, sender, SIZEOF_SENDER); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, ssl->arrays->masterSecret, + SECRET_LEN); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, PAD1, PAD_MD5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } wc_Md5GetHash(&ssl->hsHashes->hashMd5, md5_result); wc_Md5RestorePos(&ssl->hsHashes->hashMd5, md5) ; /* Restore current position */ /* make md5 outer */ - wc_InitMd5(md5_2) ; - wc_Md5Update(md5_2, ssl->arrays->masterSecret,SECRET_LEN); - wc_Md5Update(md5_2, PAD2, PAD_MD5); - wc_Md5Update(md5_2, md5_result, MD5_DIGEST_SIZE); - wc_Md5Final(md5_2, hashes->md5); + ret = wc_InitMd5(md5_2) ; + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, ssl->arrays->masterSecret,SECRET_LEN); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, PAD2, PAD_MD5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, md5_result, MD5_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Final(md5_2, hashes->md5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } #ifdef WOLFSSL_SMALL_STACK XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif - + return ret; } @@ -5551,7 +5620,14 @@ static int BuildFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender) #endif #ifndef NO_OLD_TLS if (!ssl->options.tls) { - BuildMD5(ssl, hashes, sender); + if (BuildMD5(ssl, hashes, sender) != 0) { + #ifdef WOLFSSL_SMALL_STACK + #ifdef WOLFSSL_SHA384 + XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + #endif + return SSL_FATAL_ERROR; + } BuildSHA(ssl, hashes, sender); } #endif @@ -9899,10 +9975,9 @@ static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz, byte result[MAX_DIGEST_SIZE]; word32 digestSz = ssl->specs.hash_size; /* actual sizes */ word32 padSz = ssl->specs.pad_size; - int ret = 0; - Md5 md5; Sha sha; + int ret; /* data */ byte seq[SEQ_SZ]; @@ -9920,45 +9995,109 @@ static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz, WriteSEQ(ssl, verify, seq); if (ssl->specs.mac_algorithm == md5_mac) { - wc_InitMd5(&md5); + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } /* inner */ - wc_Md5Update(&md5, macSecret, digestSz); - wc_Md5Update(&md5, PAD1, padSz); - wc_Md5Update(&md5, seq, SEQ_SZ); - wc_Md5Update(&md5, conLen, sizeof(conLen)); + ret = wc_Md5Update(&md5, macSecret, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, PAD1, padSz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, seq, SEQ_SZ); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, conLen, sizeof(conLen)); + if (ret != 0) { + return ret; + } /* in buffer */ - wc_Md5Update(&md5, in, sz); - wc_Md5Final(&md5, result); + ret = wc_Md5Update(&md5, in, sz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, result); + if (ret != 0) { + return ret; + } /* outer */ - wc_Md5Update(&md5, macSecret, digestSz); - wc_Md5Update(&md5, PAD2, padSz); - wc_Md5Update(&md5, result, digestSz); - wc_Md5Final(&md5, digest); + ret = wc_Md5Update(&md5, macSecret, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, PAD2, padSz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, result, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, digest); + if (ret != 0) { + return ret; + } } else { ret = wc_InitSha(&sha); if (ret != 0) return ret; /* inner */ - wc_ShaUpdate(&sha, macSecret, digestSz); - wc_ShaUpdate(&sha, PAD1, padSz); - wc_ShaUpdate(&sha, seq, SEQ_SZ); - wc_ShaUpdate(&sha, conLen, sizeof(conLen)); + ret = wc_ShaUpdate(&sha, macSecret, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&sha, PAD1, padSz); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&sha, seq, SEQ_SZ); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&sha, conLen, sizeof(conLen)); + if (ret != 0) { + return ret; + } /* in buffer */ - wc_ShaUpdate(&sha, in, sz); - wc_ShaFinal(&sha, result); + ret = wc_ShaUpdate(&sha, in, sz); + if (ret != 0) { + return ret; + } + ret = wc_ShaFinal(&sha, result); + if (ret != 0) { + return ret; + } /* outer */ - wc_ShaUpdate(&sha, macSecret, digestSz); - wc_ShaUpdate(&sha, PAD2, padSz); - wc_ShaUpdate(&sha, result, digestSz); - wc_ShaFinal(&sha, digest); + ret = wc_ShaUpdate(&sha, macSecret, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&sha, PAD2, padSz); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&sha, result, digestSz); + if (ret != 0) { + return ret; + } + ret = wc_ShaFinal(&sha, digest); + if (ret != 0) { + return ret; + } } - return 0; + return ret; } #ifndef NO_CERTS -static void BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest) +static int BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest) { + int ret; byte md5_result[MD5_DIGEST_SIZE]; #ifdef WOLFSSL_SMALL_STACK @@ -9971,23 +10110,75 @@ static void BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest) /* make md5 inner */ md5[0] = ssl->hsHashes->hashMd5 ; /* Save current position */ - wc_Md5Update(&ssl->hsHashes->hashMd5, ssl->arrays->masterSecret,SECRET_LEN); - wc_Md5Update(&ssl->hsHashes->hashMd5, PAD1, PAD_MD5); + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, ssl->arrays->masterSecret, + SECRET_LEN); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(&ssl->hsHashes->hashMd5, PAD1, PAD_MD5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } wc_Md5GetHash(&ssl->hsHashes->hashMd5, md5_result); wc_Md5RestorePos(&ssl->hsHashes->hashMd5, md5) ; /* Restore current position */ /* make md5 outer */ - wc_InitMd5(md5_2) ; - wc_Md5Update(md5_2, ssl->arrays->masterSecret, SECRET_LEN); - wc_Md5Update(md5_2, PAD2, PAD_MD5); - wc_Md5Update(md5_2, md5_result, MD5_DIGEST_SIZE); + ret = wc_InitMd5(md5_2) ; + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, ssl->arrays->masterSecret, SECRET_LEN); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, PAD2, PAD_MD5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5_2, md5_result, MD5_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } - wc_Md5Final(md5_2, digest); + ret = wc_Md5Final(md5_2, digest); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } #ifdef WOLFSSL_SMALL_STACK XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(md5_2, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif + + return ret; } @@ -10064,7 +10255,9 @@ static int BuildCertHashes(WOLFSSL* ssl, Hashes* hashes) } #if ! defined( NO_OLD_TLS ) else { - BuildMD5_CertVerify(ssl, hashes->md5); + if (BuildMD5_CertVerify(ssl, hashes->md5) != 0) { + return SSL_FATAL_ERROR; + } BuildSHA_CertVerify(ssl, hashes->sha); } #endif diff --git a/src/keys.c b/src/keys.c index a1095b1eb..80440612e 100644 --- a/src/keys.c +++ b/src/keys.c @@ -2862,7 +2862,7 @@ int DeriveKeys(WOLFSSL* ssl) 2 * ssl->specs.iv_size; int rounds = (length + MD5_DIGEST_SIZE - 1 ) / MD5_DIGEST_SIZE, i; int ret = 0; - + #ifdef WOLFSSL_SMALL_STACK byte* shaOutput; byte* md5Input; @@ -2878,7 +2878,7 @@ int DeriveKeys(WOLFSSL* ssl) Md5 md5[1]; Sha sha[1]; #endif - + #ifdef WOLFSSL_SMALL_STACK shaOutput = (byte*)XMALLOC(SHA_DIGEST_SIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER); @@ -2890,7 +2890,7 @@ int DeriveKeys(WOLFSSL* ssl) NULL, DYNAMIC_TYPE_TMP_BUFFER); md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER); sha = (Sha*)XMALLOC(sizeof(Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER); - + if (shaOutput == NULL || md5Input == NULL || shaInput == NULL || keyData == NULL || md5 == NULL || sha == NULL) { if (shaOutput) XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); @@ -2899,12 +2899,23 @@ int DeriveKeys(WOLFSSL* ssl) if (keyData) XFREE(keyData, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (md5) XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (sha) XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); - + return MEMORY_E; } #endif - wc_InitMd5(md5); + ret = wc_InitMd5(md5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(keyData, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } ret = wc_InitSha(sha); @@ -2931,8 +2942,30 @@ int DeriveKeys(WOLFSSL* ssl) wc_ShaFinal(sha, shaOutput); XMEMCPY(md5Input + SECRET_LEN, shaOutput, SHA_DIGEST_SIZE); - wc_Md5Update(md5, md5Input, SECRET_LEN + SHA_DIGEST_SIZE); - wc_Md5Final(md5, keyData + i * MD5_DIGEST_SIZE); + ret = wc_Md5Update(md5, md5Input, SECRET_LEN + SHA_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(keyData, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Final(md5, keyData + i * MD5_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(keyData, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } } if (ret == 0) @@ -3010,7 +3043,7 @@ static int MakeSslMasterSecret(WOLFSSL* ssl) NULL, DYNAMIC_TYPE_TMP_BUFFER); md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER); sha = (Sha*)XMALLOC(sizeof(Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER); - + if (shaOutput == NULL || md5Input == NULL || shaInput == NULL || md5 == NULL || sha == NULL) { if (shaOutput) XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); @@ -3018,15 +3051,25 @@ static int MakeSslMasterSecret(WOLFSSL* ssl) if (shaInput) XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (md5) XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (sha) XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); - + return MEMORY_E; } #endif - wc_InitMd5(md5); - + ret = wc_InitMd5(md5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_InitSha(sha); - + if (ret == 0) { XMEMCPY(md5Input, ssl->arrays->preMasterSecret, pmsSz); @@ -3053,8 +3096,28 @@ static int MakeSslMasterSecret(WOLFSSL* ssl) idx = pmsSz; /* preSz */ XMEMCPY(md5Input + idx, shaOutput, SHA_DIGEST_SIZE); idx += SHA_DIGEST_SIZE; - wc_Md5Update(md5, md5Input, idx); - wc_Md5Final(md5, &ssl->arrays->masterSecret[i * MD5_DIGEST_SIZE]); + ret = wc_Md5Update(md5, md5Input, idx); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Final(md5, &ssl->arrays->masterSecret[i * MD5_DIGEST_SIZE]); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(shaOutput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5Input, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(shaInput, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } } #ifdef SHOW_SECRETS diff --git a/src/sniffer.c b/src/sniffer.c index 33278f4e0..35d38a5c1 100644 --- a/src/sniffer.c +++ b/src/sniffer.c @@ -576,8 +576,12 @@ static int HashInit(HsHashes* hash) ret = wc_InitSha(&hash->hashSha); #endif #ifndef NO_MD5 - if (ret == 0) - wc_InitMd5(&hash->hashMd5); + if (ret == 0) { + ret = wc_InitMd5(&hash->hashMd5); + if (ret != 0) { + return ret; + } + } #endif #endif #ifndef NO_SHA256 @@ -606,8 +610,12 @@ static int HashUpdate(HsHashes* hash, const byte* input, int sz) ret = wc_ShaUpdate(&hash->hashSha, input, sz); #endif #ifndef NO_MD5 - if (ret == 0) - wc_Md5Update(&hash->hashMd5, input, sz); + if (ret == 0) { + ret = wc_Md5Update(&hash->hashMd5, input, sz); + if (ret !=0) { + return ret; + } + } #endif #endif #ifndef NO_SHA256 diff --git a/src/ssl.c b/src/ssl.c index a865bed42..04b30517a 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -1671,7 +1671,10 @@ int wolfSSL_Rehandshake(WOLFSSL* ssl) #ifndef NO_OLD_TLS #ifndef NO_MD5 - wc_InitMd5(&ssl->hsHashes->hashMd5); + ret = wc_InitMd5(&ssl->hsHashes->hashMd5); + if (ret != 0) { + return ret; + } #endif #ifndef NO_SHA ret = wc_InitSha(&ssl->hsHashes->hashSha); @@ -7017,6 +7020,9 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl, int wolfSSL_connect(WOLFSSL* ssl) { int neededState; + #if !defined(NO_OLD_TLS) && defined(WOLFSSL_DTLS) + int ret; + #endif WOLFSSL_ENTER("SSL_connect()"); @@ -7105,14 +7111,17 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl, #ifdef WOLFSSL_DTLS if (IsDtlsNotSctpMode(ssl)) { /* re-init hashes, exclude first hello and verify request */ -#ifndef NO_OLD_TLS - wc_InitMd5(&ssl->hsHashes->hashMd5); + #ifndef NO_OLD_TLS + ret = wc_InitMd5(&ssl->hsHashes->hashMd5); + if (ret) { + return ret; + } if ( (ssl->error = wc_InitSha(&ssl->hsHashes->hashSha)) != 0) { WOLFSSL_ERROR(ssl->error); return SSL_FATAL_ERROR; } -#endif + #endif if (IsAtLeastTLSv1_2(ssl)) { #ifndef NO_SHA256 if ( (ssl->error = wc_InitSha256( @@ -9540,6 +9549,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl) int keyLeft; int ivLeft; int keyOutput = 0; + int ret; byte digest[MD5_DIGEST_SIZE]; #ifdef WOLFSSL_SMALL_STACK Md5* md5 = NULL; @@ -9556,7 +9566,9 @@ int wolfSSL_set_compression(WOLFSSL* ssl) (void)type; WOLFSSL_ENTER("wolfSSL_EVP_BytesToKey"); - wc_InitMd5(md5); + if (wc_InitMd5(md5)) { + return SSL_FATAL_ERROR; + } /* only support MD5 for now */ if (XSTRNCMP(md, "MD5", 3) != 0) return 0; @@ -9601,18 +9613,56 @@ int wolfSSL_set_compression(WOLFSSL* ssl) while (keyOutput < (keyLen + ivLen)) { int digestLeft = MD5_DIGEST_SIZE; /* D_(i - 1) */ - if (keyOutput) /* first time D_0 is empty */ - wc_Md5Update(md5, digest, MD5_DIGEST_SIZE); + if (keyOutput) { /* first time D_0 is empty */ + ret = wc_Md5Update(md5, digest, MD5_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + } /* data */ - wc_Md5Update(md5, data, sz); + ret = wc_Md5Update(md5, data, sz); + if (ret !=0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } /* salt */ - if (salt) - wc_Md5Update(md5, salt, EVP_SALT_SIZE); - wc_Md5Final(md5, digest); + if (salt) { + ret = wc_Md5Update(md5, salt, EVP_SALT_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + } + ret = wc_Md5Final(md5, digest); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } /* count */ for (j = 1; j < count; j++) { - wc_Md5Update(md5, digest, MD5_DIGEST_SIZE); - wc_Md5Final(md5, digest); + ret = wc_Md5Update(md5, digest, MD5_DIGEST_SIZE); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Final(md5, digest); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } } if (keyLeft) { diff --git a/tests/api.c b/tests/api.c index 26eea6794..fa04d30bb 100644 --- a/tests/api.c +++ b/tests/api.c @@ -43,6 +43,22 @@ #include #include +#ifndef NO_MD5 + #include +#endif +#ifndef NO_SHA + #include +#endif +#ifndef NO_SHA256 + #include +#endif +#ifdef WOLFSSL_SHA512 + #include +#endif +#ifdef WOLFSSL_SHA384 + #include +#endif + #ifdef OPENSSL_EXTRA #include #include @@ -57,6 +73,16 @@ #endif #include + +typedef struct testVector { + const char* input; + const char* output; + size_t inLen; + size_t outLen; + +} testVector; + + /*----------------------------------------------------------------------------* | Constants *----------------------------------------------------------------------------*/ @@ -2165,7 +2191,7 @@ static int test_wolfSSL_UseOCSPStapling(void) * check. * PRE: HAVE_CERTIFICATE_STATUS_REQUEST_V2 and HAVE_OCSP defined. */ -static int test_wolfSSL_UseOCSPStaplingV2(void) +static int test_wolfSSL_UseOCSPStaplingV2 (void) { #if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) && defined(HAVE_OCSP) int ret; @@ -2185,7 +2211,7 @@ static int test_wolfSSL_UseOCSPStaplingV2(void) wolfSSL_free(ssl); wolfSSL_CTX_free(ctx); - if(ret != SSL_SUCCESS){ + if (ret != SSL_SUCCESS){ wolfSSL_Cleanup(); return SSL_FAILURE; } @@ -2197,6 +2223,868 @@ static int test_wolfSSL_UseOCSPStaplingV2(void) } /*END test_wolfSSL_UseOCSPStaplingV2*/ +/*----------------------------------------------------------------------------* + | Wolfcrypt + *----------------------------------------------------------------------------*/ + +/* + * Unit test for the wc_InitMd5() + */ +static int test_wc_InitMd5 (void) +{ +#ifndef NO_MD5 + + Md5 md5; + int ret, flag; + + printf(testingFmt, "wc_InitMd5()"); + + flag = SSL_SUCCESS; + /* Test good arg. */ + ret = wc_InitMd5(&md5); + if (ret) { + flag = SSL_FAILURE; + } + /* Test bad arg. */ + ret = wc_InitMd5(NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_InitMd5 */ + +/* + * Unit test for the wc_InitSha() + */ +static int test_wc_InitSha(void) +{ +#ifndef NO_SHA + Sha sha; + int ret, flag; + + flag = SSL_SUCCESS; + + printf(testingFmt, "wc_InitSha()"); + /* Test good arg. */ + ret = wc_InitSha(&sha); + if (ret != 0) { + flag = SSL_FAILURE; + } + /* Test bad arg. */ + ret = wc_InitSha(NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_InitSha */ + +/* + * Unit test for wc_InitSha256() + */ +static int test_wc_InitSha256 (void) +{ +#ifndef NO_SHA256 + Sha256 sha256; + int ret, flag; + + flag = SSL_SUCCESS; + + printf(testingFmt, "wc_InitSha256()"); + /* Test good arg. */ + ret = wc_InitSha256(&sha256); + if (ret != 0) { + flag = SSL_FAILURE; + } + /* Test bad arg. */ + ret = wc_InitSha256(NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_InitSha256 */ + + +/* + * Testing wc_InitSha512() + */ +static int test_wc_InitSha512 (void) +{ +#ifdef WOLFSSL_SHA512 + Sha512 sha512; + int ret, flag; + + flag = SSL_SUCCESS; + + printf(testingFmt, "wc_InitSha512()"); + /* Test good arg. */ + ret = wc_InitSha512(&sha512); + if (ret != 0) { + flag = SSL_FAILURE; + } + /* Test bad arg. */ + ret = wc_InitSha512(NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_InitSha512 */ + +/* + * Testing wc_InitSha384() + */ +static int test_wc_InitSha384 (void) +{ +#ifdef WOLFSSL_SHA384 + Sha384 sha384; + int ret, flag; + + flag = SSL_SUCCESS; + + printf(testingFmt, "wc_InitSha384()"); + /* Test good arg. */ + ret = wc_InitSha384(&sha384); + if (ret != 0) { + flag = SSL_FAILURE; + } + /* Test bad arg. */ + ret = wc_InitSha384(NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_InitSha384 */ + + +/* + * Testing wc_UpdateMd5() + */ +static int test_wc_UpdateMd5 (void) +{ + +#ifndef NO_MD5 + Md5 md5; + byte hash[MD5_DIGEST_SIZE]; + testVector a, b, c; + int ret; + + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } + + printf(testingFmt, "wc_Md5Update()"); + + /* Input */ + a.input = "a"; + a.inLen = XSTRLEN(a.input); + + ret = wc_Md5Update(&md5, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, hash); + if (ret != 0) { + return ret; + } + + /* 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); + + ret = wc_Md5Update(&md5, (byte*) a.input, (word32) a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, hash); + if (ret != 0) { + return ret; + } + if (ret != 0 && XMEMCMP(hash, a.output, MD5_DIGEST_SIZE) != 0) { + return SSL_FAILURE; + } + + /*Pass in bad values. */ + b.input = NULL; + b.inLen = 0; + + ret = wc_Md5Update(&md5, (byte*)b.input, (word32)b.inLen); + + if (ret != 0) { + return ret; + } + + c.input = NULL; + c.inLen = MD5_DIGEST_SIZE; + + ret = wc_Md5Update(&md5, (byte*)c.input, (word32)c.inLen); + if (ret == 0) { + return SSL_FAILURE; + } + + ret = wc_Md5Update(NULL, (byte*)a.input, (word32)a.inLen); + if (ret != BAD_FUNC_ARG) { + return SSL_FAILURE; + } + + /* If not returned then the unit test passed test vectors. */ + printf(resultFmt, 0 == 0 ? passed : failed); + + return SSL_SUCCESS; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_UpdateMd5 */ + +/* + * Tesing wc_ShaUpdate() + */ +static int test_wc_ShaUpdate (void) +{ +#ifndef NO_SHA + Sha sha; + byte hash[SHA_DIGEST_SIZE]; + testVector a, b, c; + int ret; + + ret = wc_InitSha(&sha); + if (ret != 0) { + return ret; + } + + printf(testingFmt, "wc_ShaUpdate()"); + + /* Input. */ + a.input = "a"; + a.inLen = XSTRLEN(a.input); + + ret = wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_ShaFinal(&sha, hash); + if (ret != 0) { + return ret; + } + + /* 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); + + ret = wc_ShaUpdate(&sha, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_ShaFinal(&sha, hash); + if (ret !=0) { + return ret; + } + if (ret != 0 && XMEMCMP(hash, a.output, SHA_DIGEST_SIZE) != 0) { + return SSL_FAILURE; + } + + /* Try passing in bad values. */ + b.input = NULL; + b.inLen = 0; + + ret = wc_ShaUpdate(&sha, (byte*)b.input, (word32)b.inLen); + if (ret != 0) { + return ret; + } + + c.input = NULL; + c.inLen = SHA_DIGEST_SIZE; + + ret = wc_ShaUpdate(&sha, (byte*)c.input, (word32)c.inLen); + if (ret == 0) { + return SSL_FAILURE; + } + + ret = wc_ShaUpdate(NULL, (byte*)a.input, (word32)a.inLen); + if (ret != BAD_FUNC_ARG) { + return SSL_FAILURE; + } + + /* If not returned then the unit test passed test vectors. */ + printf(resultFmt, 0 == 0 ? passed : failed); + + return SSL_SUCCESS; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_ShaFinal */ + + +/* + * Unit test for wc_Sha256Update() + */ +static int test_wc_Sha256Update (void) +{ +#ifndef NO_SHA256 + Sha256 sha256; + byte hash[SHA256_DIGEST_SIZE]; + testVector a, b, c; + int ret; + + ret = wc_InitSha256(&sha256); + if (ret != 0) { + return ret; + } + + printf(testingFmt, "wc_Sha256Update()"); + + /* Input. */ + a.input = "a"; + a.inLen = XSTRLEN(a.input); + + ret = wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha256Final(&sha256, hash); + if (ret != 0) { + return ret; + } + + /* 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); + + ret = wc_Sha256Update(&sha256, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha256Final(&sha256, hash); + if (ret != 0) { + return ret; + } + if (ret != 0 && XMEMCMP(hash, a.output, SHA256_DIGEST_SIZE) != 0) { + return SSL_FAILURE; + } + + /* Try passing in bad values */ + b.input = NULL; + b.inLen = 0; + + ret = wc_Sha256Update(&sha256, (byte*)b.input, (word32)b.inLen); + if (ret != 0) { + return ret; + } + + c.input = NULL; + c.inLen = SHA256_DIGEST_SIZE; + + ret = wc_Sha256Update(&sha256, (byte*)c.input, (word32)c.inLen); + if (ret == 0) { + return SSL_FAILURE; + } + + ret = wc_Sha256Update(NULL, (byte*)a.input, (word32)a.inLen); + if (ret != BAD_FUNC_ARG) { + return SSL_FAILURE; + } + + /* If not returned then the unit test passed. */ + printf(resultFmt, 0 == 0 ? passed : failed); + + return SSL_SUCCESS; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_Sha256Update */ + +/* + * test wc_Sha384Update() + */ +static int test_wc_Sha384Update (void) +{ +#ifdef WOLFSSL_SHA384 + Sha384 sha384; + byte hash[SHA384_DIGEST_SIZE]; + testVector a, b, c; + int ret; + + ret = wc_InitSha384(&sha384); + if (ret != 0) { + return ret; + } + + printf(testingFmt, "wc_Sha384Update()"); + + /* Input */ + a.input = "a"; + a.inLen = XSTRLEN(a.input); + + ret = wc_Sha384Update(&sha384, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha384Final(&sha384, hash); + if (ret != 0) { + return ret; + } + + /* Update input. */ + a.input = "abc"; + a.output = "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50" + "\x07\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff" + "\x5b\xed\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34" + "\xc8\x25\xa7"; + a.inLen = XSTRLEN(a.input); + a.outLen = XSTRLEN(a.output); + + ret = wc_Sha384Update(&sha384, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha384Final(&sha384, hash); + if (ret != 0) { + return ret; + } + if (ret != 0 && XMEMCMP(hash, a.output, SHA384_DIGEST_SIZE) != 0) { + return SSL_FAILURE; + } + + /* Pass in bad values. */ + b.input = NULL; + b.inLen = 0; + + ret = wc_Sha384Update(&sha384, (byte*)b.input, (word32)b.inLen); + + if (ret != 0) { + return ret; + } + + c.input = NULL; + c.inLen = SHA384_DIGEST_SIZE; + + ret = wc_Sha384Update(&sha384, (byte*)c.input, (word32)c.inLen); + if (ret == 0) { + return SSL_FAILURE; + } + + ret = wc_Sha384Update(NULL, (byte*)a.input, (word32)a.inLen); + if (ret != BAD_FUNC_ARG) { + return SSL_FAILURE; + } + + /* If not returned then the unit test passed test vectors. */ + printf(resultFmt, 0 == 0 ? passed : failed); + + return SSL_SUCCESS; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_Sha384Update */ + +/* + * wc_Sha512Update() test. + */ + +static int test_wc_Sha512Update (void) +{ +#ifdef WOLFSSL_SHA512 + Sha512 sha512; + byte hash[SHA512_DIGEST_SIZE]; + testVector a, b, c; + int ret; + + ret = wc_InitSha512(&sha512); + if (ret != 0) { + return ret; + } + + printf(testingFmt, "wc_Sha512Update()"); + + /* Input. */ + a.input = "a"; + a.inLen = XSTRLEN(a.input); + + ret = wc_Sha512Update(&sha512, (byte*)a.input, (word32)a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha512Final(&sha512, hash); + if (ret != 0) { + return ret; + } + + /* Update input. */ + a.input = "abc"; + a.output = "\xdd\xaf\x35\xa1\x93\x61\x7a\xba\xcc\x41\x73\x49\xae\x20\x41\x31" + "\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2\x0a\x9e\xee\xe6\x4b\x55\xd3" + "\x9a\x21\x92\x99\x2a\x27\x4f\xc1\xa8\x36\xba\x3c\x23\xa3\xfe" + "\xeb\xbd\x45\x4d\x44\x23\x64\x3c\xe8\x0e\x2a\x9a\xc9\x4f\xa5" + "\x4c\xa4\x9f"; + a.inLen = XSTRLEN(a.input); + a.outLen = XSTRLEN(a.output); + + ret = wc_Sha512Update(&sha512, (byte*) a.input, (word32) a.inLen); + if (ret != 0) { + return ret; + } + ret = wc_Sha512Final(&sha512, hash); + if (ret != 0) { + return ret; + } + if (ret != 0 && XMEMCMP(hash, a.output, SHA512_DIGEST_SIZE) != 0) { + return SSL_FAILURE; + } + + /* Try passing in bad values */ + b.input = NULL; + b.inLen = 0; + + ret = wc_Sha512Update(&sha512, (byte*)b.input, (word32)b.inLen); + if (ret != 0) { + return ret; + } + + c.input = NULL; + c.inLen = SHA512_DIGEST_SIZE; + + ret = wc_Sha512Update(&sha512, (byte*)c.input, (word32)c.inLen); + if (ret ==0) { + return SSL_FAILURE; + } + + ret = wc_Sha512Update(NULL, (byte*)a.input, (word32)a.inLen); + if (ret != BAD_FUNC_ARG) { + return SSL_FAILURE; + } + + /* If not returned then the unit test passed test vectors. */ + printf(resultFmt, 0 == 0 ? passed : failed); + + return SSL_SUCCESS; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_Sha512Update */ + +/* + * Unit test on wc_Md5Final() in wolfcrypt/src/md5.c + */ +static int test_wc_Md5Final (void) +{ + +#ifndef NO_MD5 + /* Instantiate */ + Md5 md5; + byte* hash_test[3]; + byte hash1[MD5_DIGEST_SIZE]; + byte hash2[2*MD5_DIGEST_SIZE]; + byte hash3[5*MD5_DIGEST_SIZE]; + int times, i, flag, ret; + + /* Initialize */ + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } + + hash_test[0] = hash1; + hash_test[1] = hash2; + hash_test[2] = hash3; + + times = sizeof(hash_test)/sizeof(byte*); + + flag = SSL_SUCCESS; + + /* Test good args. */ + printf(testingFmt, "wc_Md5Final()"); + + for (i = 0; i < times; i++) { + ret = wc_Md5Final(&md5, hash_test[i]); + if (ret != 0) { + flag = SSL_FAILURE; + } + } + /* Test bad args. */ + ret = wc_Md5Final(NULL, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Md5Final(NULL, hash1); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Md5Final(&md5, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + return flag; +#else + return SSL_SUCCESS; +#endif +} + +/* + * Unit test on wc_ShaFinal + */ +static int test_wc_ShaFinal (void) +{ +#ifndef NO_SHA + Sha sha; + byte* hash_test[3]; + byte hash1[SHA_DIGEST_SIZE]; + byte hash2[2*SHA_DIGEST_SIZE]; + byte hash3[5*SHA_DIGEST_SIZE]; + int times, i, ret, flag; + /*Initialize*/ + ret = wc_InitSha(&sha); + if (ret) { + return ret; + } + + hash_test[0] = hash1; + hash_test[1] = hash2; + hash_test[2] = hash3; + times = sizeof(hash_test)/sizeof(byte*); + flag = SSL_SUCCESS; + + /* Good test args. */ + printf(testingFmt, "wc_ShaFinal()"); + + for (i = 0; i < times; i++) { + ret = wc_ShaFinal(&sha, hash_test[i]); + if (ret != 0) { + flag = SSL_FAILURE; + } + } + /* Test bad args. */ + ret = wc_ShaFinal(NULL, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_ShaFinal(NULL, hash1); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_ShaFinal(&sha, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + return flag; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_ShaFinal */ + +/* + * Unit test function for wc_Sha256Final() + */ +static int test_wc_Sha256Final (void) +{ +#ifndef NO_SHA256 + Sha256 sha256; + byte* hash_test[3]; + byte hash1[SHA256_DIGEST_SIZE]; + byte hash2[2*SHA256_DIGEST_SIZE]; + byte hash3[5*SHA256_DIGEST_SIZE]; + int times, i, ret, flag; + /* Initialize */ + ret = wc_InitSha256(&sha256); + if (ret) { + return ret; + } + + hash_test[0] = hash1; + hash_test[1] = hash2; + hash_test[2] = hash3; + times = sizeof(hash_test) / sizeof(byte*); + flag = SSL_SUCCESS; + /* Good test args. */ + printf(testingFmt, "wc_Sha256Final()"); + + for (i = 0; i < times; i++) { + ret = wc_Sha256Final(&sha256, hash_test[i]); + if (ret != 0) { + flag = SSL_FAILURE; + } + } + /* Test bad args. */ + ret = wc_Sha256Final(NULL, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha256Final(NULL, hash1); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha256Final(&sha256, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_Sha256Final */ + +/* + * Unit test function for wc_Sha512Final() + */ +static int test_wc_Sha512Final (void) +{ +#ifdef WOLFSSL_SHA512 + Sha512 sha512; + byte* hash_test[3]; + byte hash1[SHA512_DIGEST_SIZE]; + byte hash2[2*SHA512_DIGEST_SIZE]; + byte hash3[5*SHA512_DIGEST_SIZE]; + int times, i, ret, flag; + /* Initialize */ + ret = wc_InitSha512(&sha512); + if (ret) { + return ret; + } + + hash_test[0] = hash1; + hash_test[1] = hash2; + hash_test[2] = hash3; + times = sizeof(hash_test) / sizeof(byte *); + flag = SSL_SUCCESS; + + /* Good test args. */ + printf(testingFmt, "wc_Sha512Final()"); + + for (i = 0; i < times; i++) { + ret = wc_Sha512Final(&sha512, hash_test[i]); + if (ret != 0) { + flag = SSL_FAILURE; + } + } + /* Test bad args. */ + ret = wc_Sha512Final(NULL, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha512Final(NULL, hash1); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha512Final(&sha512, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; +#else + return SSL_SUCCESS; +#endif +} /* END test_wc_Sha512Final */ + +/* + * Unit test functionf or wc_Sha384Final(); + */ +static int test_wc_Sha384Final (void) +{ +#ifdef WOLFSSL_SHA384 + Sha384 sha384; + byte* hash_test[3]; + byte hash1[SHA384_DIGEST_SIZE]; + byte hash2[2*SHA384_DIGEST_SIZE]; + byte hash3[5*SHA384_DIGEST_SIZE]; + int times, i, ret, flag; + /* Initialize */ + ret = wc_InitSha384(&sha384); + if (ret) { + return ret; + } + + hash_test[0] = hash1; + hash_test[1] = hash2; + hash_test[2] = hash3; + times = sizeof(hash_test) / sizeof(byte*); + flag = SSL_SUCCESS; + + /* Good test args. */ + printf(testingFmt, "wc_Sha384Final()"); + for (i = 0; i < times; i++) { + ret = wc_Sha384Final(&sha384, hash_test[i]); + if (ret != 0) { + flag = SSL_FAILURE; + } + } + /* Test bad args. */ + ret = wc_Sha384Final(NULL, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha384Final(NULL, hash1); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + ret = wc_Sha384Final(&sha384, NULL); + if (ret != BAD_FUNC_ARG) { + flag = SSL_FAILURE; + } + + printf(resultFmt, flag == SSL_SUCCESS ? passed : failed); + + return flag; + +#else + return SSL_SUCCESS; +#endif + +} /* END test_wc_Sha384Final */ + /*----------------------------------------------------------------------------* | Compatibility Tests @@ -2254,7 +3142,6 @@ void ApiTest(void) printf(" Begin API Tests\n"); AssertIntEQ(test_wolfSSL_Init(), SSL_SUCCESS); /* wolfcrypt initialization tests */ - AssertFalse(test_wolfCrypt_Init()); test_wolfSSL_Method_Allocators(); test_wolfSSL_CTX_new(wolfSSLv23_server_method()); test_wolfSSL_CTX_use_certificate_file(); @@ -2293,6 +3180,25 @@ void ApiTest(void) test_wolfSSL_DES(); AssertIntEQ(test_wolfSSL_Cleanup(), SSL_SUCCESS); + + /*wolfcrypt */ + printf("\n-----------------wolfcrypt unit tests------------------\n"); + AssertFalse(test_wolfCrypt_Init()); + AssertTrue(test_wc_InitMd5()); + AssertTrue(test_wc_UpdateMd5()); + AssertTrue(test_wc_Md5Final()); + AssertTrue(test_wc_InitSha()); + AssertTrue(test_wc_ShaUpdate()); + AssertTrue(test_wc_ShaFinal()); + AssertTrue(test_wc_InitSha256()); + AssertTrue(test_wc_Sha256Update()); + AssertTrue(test_wc_Sha256Final()); + AssertTrue(test_wc_InitSha512()); + AssertTrue(test_wc_Sha512Update()); + AssertTrue(test_wc_Sha512Final()); + AssertTrue(test_wc_InitSha384()); + AssertTrue(test_wc_Sha384Update()); + AssertTrue(test_wc_Sha384Final()); printf(" End API Tests\n"); } diff --git a/tests/hash.c b/tests/hash.c index 9167cda16..c32e34efc 100644 --- a/tests/hash.c +++ b/tests/hash.c @@ -255,6 +255,7 @@ int md4_test(void) int md5_test(void) { Md5 md5; + int ret; byte hash[MD5_DIGEST_SIZE]; testVector a, b, c, d, e; @@ -299,11 +300,22 @@ int md5_test(void) test_md5[3] = d; test_md5[4] = e; - wc_InitMd5(&md5); + ret = wc_InitMd5(&md5); + if (ret) { + return ret; + } for (i = 0; i < times; ++i) { - wc_Md5Update(&md5, (byte*)test_md5[i].input, (word32)test_md5[i].inLen); - wc_Md5Final(&md5, hash); + ret = wc_Md5Update(&md5, (byte*)test_md5[i].input, + (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) return -5 - i; diff --git a/wolfcrypt/src/hmac.c b/wolfcrypt/src/hmac.c index a699b6542..8f42a94a1 100644 --- a/wolfcrypt/src/hmac.c +++ b/wolfcrypt/src/hmac.c @@ -169,7 +169,7 @@ static int InitHmac(Hmac* hmac, int type) switch (type) { #ifndef NO_MD5 case MD5: - wc_InitMd5(&hmac->hash.md5); + ret = wc_InitMd5(&hmac->hash.md5); break; #endif @@ -248,8 +248,14 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length) XMEMCPY(ip, key, length); } else { - wc_Md5Update(&hmac->hash.md5, key, length); - wc_Md5Final(&hmac->hash.md5, ip); + ret = wc_Md5Update(&hmac->hash.md5, key, length); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&hmac->hash.md5, ip); + if (ret != 0) { + return ret; + } length = MD5_DIGEST_SIZE; } } @@ -403,13 +409,21 @@ static int HmacKeyInnerHash(Hmac* hmac) switch (hmac->macType) { #ifndef NO_MD5 case MD5: - wc_Md5Update(&hmac->hash.md5, (byte*) hmac->ipad, MD5_BLOCK_SIZE); + ret = wc_Md5Update(&hmac->hash.md5, (byte*) hmac->ipad, + MD5_BLOCK_SIZE); + if (ret != 0) { + return ret; + } break; #endif #ifndef NO_SHA case SHA: - wc_ShaUpdate(&hmac->hash.sha, (byte*) hmac->ipad, SHA_BLOCK_SIZE); + ret = wc_ShaUpdate(&hmac->hash.sha, (byte*) hmac->ipad, + SHA_BLOCK_SIZE); + if (ret != 0) { + return ret; + } break; #endif @@ -487,13 +501,19 @@ int wc_HmacUpdate(Hmac* hmac, const byte* msg, word32 length) switch (hmac->macType) { #ifndef NO_MD5 case MD5: - wc_Md5Update(&hmac->hash.md5, msg, length); + ret = wc_Md5Update(&hmac->hash.md5, msg, length); + if (ret != 0) { + return ret; + } break; #endif #ifndef NO_SHA case SHA: - wc_ShaUpdate(&hmac->hash.sha, msg, length); + ret = wc_ShaUpdate(&hmac->hash.sha, msg, length); + if (ret != 0) { + return ret; + } break; #endif @@ -565,13 +585,27 @@ int wc_HmacFinal(Hmac* hmac, byte* hash) #ifndef NO_MD5 case MD5: { - wc_Md5Final(&hmac->hash.md5, (byte*) hmac->innerHash); + ret = wc_Md5Final(&hmac->hash.md5, (byte*) hmac->innerHash); + if (ret != 0) { + return ret; + } - wc_Md5Update(&hmac->hash.md5, (byte*) hmac->opad, MD5_BLOCK_SIZE); - wc_Md5Update(&hmac->hash.md5, + ret = wc_Md5Update(&hmac->hash.md5, (byte*) hmac->opad, + MD5_BLOCK_SIZE); + if (ret != 0) { + return ret; + } + + ret = wc_Md5Update(&hmac->hash.md5, (byte*) hmac->innerHash, MD5_DIGEST_SIZE); + if (ret != 0) { + return ret; + } - wc_Md5Final(&hmac->hash.md5, hash); + ret = wc_Md5Final(&hmac->hash.md5, hash); + if (ret != 0) { + return ret; + } } break; #endif @@ -579,13 +613,24 @@ int wc_HmacFinal(Hmac* hmac, byte* hash) #ifndef NO_SHA case SHA: { - wc_ShaFinal(&hmac->hash.sha, (byte*) hmac->innerHash); - - wc_ShaUpdate(&hmac->hash.sha, (byte*) hmac->opad, SHA_BLOCK_SIZE); - wc_ShaUpdate(&hmac->hash.sha, + ret = wc_ShaFinal(&hmac->hash.sha, (byte*) hmac->innerHash); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&hmac->hash.sha, (byte*) hmac->opad, + SHA_BLOCK_SIZE); + if (ret != 0) { + return ret; + } + ret = wc_ShaUpdate(&hmac->hash.sha, (byte*) hmac->innerHash, SHA_DIGEST_SIZE); - - wc_ShaFinal(&hmac->hash.sha, hash); + if (ret != 0) { + return ret; + } + ret = wc_ShaFinal(&hmac->hash.sha, hash); + if (ret != 0) { + return ret; + } } break; #endif diff --git a/wolfcrypt/src/md5.c b/wolfcrypt/src/md5.c index fdde46ff7..525882fc8 100644 --- a/wolfcrypt/src/md5.c +++ b/wolfcrypt/src/md5.c @@ -180,8 +180,12 @@ #endif /* WOLFSSL_HAVE_MIN */ -void wc_InitMd5(Md5* md5) +int wc_InitMd5(Md5* md5) { + if (md5 == NULL) { + return BAD_FUNC_ARG; + } + md5->digest[0] = 0x67452301L; md5->digest[1] = 0xefcdab89L; md5->digest[2] = 0x98badcfeL; @@ -190,6 +194,8 @@ void wc_InitMd5(Md5* md5) md5->buffLen = 0; md5->loLen = 0; md5->hiLen = 0; + + return 0; } #ifdef FREESCALE_MMCAU_SHA @@ -308,10 +314,15 @@ static INLINE void AddLength(Md5* md5, word32 len) } -void wc_Md5Update(Md5* md5, const byte* data, word32 len) +int wc_Md5Update(Md5* md5, const byte* data, word32 len) { + byte* local; + + if (md5 == NULL || (data == NULL && len > 0)){ + return BAD_FUNC_ARG; + } /* do block size increments */ - byte* local = (byte*)md5->buffer; + local = (byte*)md5->buffer; while (len) { word32 add = min(len, MD5_BLOCK_SIZE - md5->buffLen); @@ -330,12 +341,19 @@ void wc_Md5Update(Md5* md5, const byte* data, word32 len) md5->buffLen = 0; } } + return 0; } -void wc_Md5Final(Md5* md5, byte* hash) +int wc_Md5Final(Md5* md5, byte* hash) { - byte* local = (byte*)md5->buffer; + byte* local; + + if (md5 == NULL || hash == NULL) { + return BAD_FUNC_ARG; + } + + local = (byte*)md5->buffer; AddLength(md5, md5->buffLen); /* before adding pads */ @@ -373,7 +391,8 @@ void wc_Md5Final(Md5* md5, byte* hash) #endif XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); - wc_InitMd5(md5); /* reset state */ + + return wc_InitMd5(md5); /* reset state */ } #endif /* End wolfCrypt software implementation */ @@ -381,6 +400,7 @@ void wc_Md5Final(Md5* md5, byte* hash) int wc_Md5Hash(const byte* data, word32 len, byte* hash) { + int ret; #ifdef WOLFSSL_SMALL_STACK Md5* md5; #else @@ -393,9 +413,27 @@ int wc_Md5Hash(const byte* data, word32 len, byte* hash) return MEMORY_E; #endif - wc_InitMd5(md5); - wc_Md5Update(md5, data, len); - wc_Md5Final(md5, hash); + ret = wc_InitMd5(md5); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Update(md5, data, len); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } + ret = wc_Md5Final(md5, hash); + if (ret != 0) { + #ifdef WOLFSSL_SMALL_STACK + XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + #endif + return ret; + } #ifdef WOLFSSL_SMALL_STACK XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); diff --git a/wolfcrypt/src/pwdbased.c b/wolfcrypt/src/pwdbased.c index 1492e72ed..7fcbf5cb6 100644 --- a/wolfcrypt/src/pwdbased.c +++ b/wolfcrypt/src/pwdbased.c @@ -100,10 +100,22 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt, switch (hashType) { #ifndef NO_MD5 case MD5: - wc_InitMd5(&md5); - wc_Md5Update(&md5, passwd, pLen); - wc_Md5Update(&md5, salt, sLen); - wc_Md5Final(&md5, buffer); + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } + 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; #endif /* NO_MD5 */ case SHA: @@ -124,8 +136,14 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt, } #ifndef NO_MD5 else { - wc_Md5Update(&md5, buffer, hLen); - wc_Md5Final(&md5, buffer); + ret = wc_Md5Update(&md5, buffer, hLen); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, buffer); + if (ret != 0) { + return ret; + } } #endif } @@ -310,13 +328,28 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen, case MD5: { Md5 md5; - wc_InitMd5(&md5); - wc_Md5Update(&md5, buffer, totalLen); - wc_Md5Final(&md5, Ai); + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } + ret = wc_Md5Update(&md5, buffer, totalLen); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, Ai); + if (ret != 0) { + return ret; + } for (i = 1; i < iterations; i++) { - wc_Md5Update(&md5, Ai, u); - wc_Md5Final(&md5, Ai); + ret = wc_Md5Update(&md5, Ai, u); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, Ai); + if (ret != 0) { + return ret; + } } } break; diff --git a/wolfcrypt/src/sha.c b/wolfcrypt/src/sha.c index 499d72399..63c47cba1 100644 --- a/wolfcrypt/src/sha.c +++ b/wolfcrypt/src/sha.c @@ -45,16 +45,25 @@ #ifdef HAVE_FIPS int wc_InitSha(Sha* sha) { + if (sha == NULL) { + return -173; + } return InitSha_fips(sha); } int wc_ShaUpdate(Sha* sha, const byte* data, word32 len) { + if (sha == NULL || (data == NULL && len > 0)) { + return -173; + } return ShaUpdate_fips(sha, data, len); } int wc_ShaFinal(Sha* sha, byte* out) { + if (sha == NULL || out == NULL) { + return -173; + } return ShaFinal_fips(sha,out); } @@ -255,6 +264,9 @@ { int ret = 0; + if (sha == NULL) { + return BAD_FUNC_ARG; + } sha->digest[0] = 0x67452301L; sha->digest[1] = 0xEFCDAB89L; sha->digest[2] = 0x98BADCFEL; @@ -393,10 +405,16 @@ static INLINE void AddLength(Sha* sha, word32 len) } -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 */ - byte* local = (byte*)sha->buffer; + local = (byte*)sha->buffer; while (len) { word32 add = min(len, SHA_BLOCK_SIZE - sha->buffLen); @@ -421,7 +439,13 @@ int wc_ShaUpdate(Sha* sha, const byte* data, word32 len) 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; AddLength(sha, sha->buffLen); /* before adding pads */ diff --git a/wolfcrypt/src/sha256.c b/wolfcrypt/src/sha256.c index e0d986546..287522b9f 100644 --- a/wolfcrypt/src/sha256.c +++ b/wolfcrypt/src/sha256.c @@ -34,18 +34,27 @@ int wc_InitSha256(Sha256* sha) { + if (sha == NULL) { + return -173; + } return InitSha256_fips(sha); } int wc_Sha256Update(Sha256* sha, const byte* data, word32 len) { + if (sha == NULL || (data == NULL && len > 0)) { + return -173; + } return Sha256Update_fips(sha, data, len); } int wc_Sha256Final(Sha256* sha, byte* out) { + if (sha == NULL || out == NULL) { + return -173; + } return Sha256Final_fips(sha, out); } @@ -309,28 +318,33 @@ int wc_InitSha256(Sha256* sha256) int wc_InitSha256(Sha256* sha256) { int ret = 0; - #ifdef FREESCALE_MMCAU_SHA - ret = wolfSSL_CryptHwMutexLock(); - if(ret != 0) { - return ret; - } - MMCAU_SHA256_InitializeOutput((uint32_t*)sha256->digest); - wolfSSL_CryptHwMutexUnLock(); - #else - sha256->digest[0] = 0x6A09E667L; - sha256->digest[1] = 0xBB67AE85L; - sha256->digest[2] = 0x3C6EF372L; - sha256->digest[3] = 0xA54FF53AL; - sha256->digest[4] = 0x510E527FL; - sha256->digest[5] = 0x9B05688CL; - sha256->digest[6] = 0x1F83D9ABL; - sha256->digest[7] = 0x5BE0CD19L; - #endif + + if (sha256 == NULL) { + return BAD_FUNC_ARG; + } + +#ifdef FREESCALE_MMCAU_SHA + ret = wolfSSL_CryptHwMutexLock(); + if(ret != 0) { + return ret; + } + MMCAU_SHA256_InitializeOutput((uint32_t*)sha256->digest); + wolfSSL_CryptHwMutexUnLock(); +#else + sha256->digest[0] = 0x6A09E667L; + sha256->digest[1] = 0xBB67AE85L; + sha256->digest[2] = 0x3C6EF372L; + sha256->digest[3] = 0xA54FF53AL; + sha256->digest[4] = 0x510E527FL; + sha256->digest[5] = 0x9B05688CL; + sha256->digest[6] = 0x1F83D9ABL; + sha256->digest[7] = 0x5BE0CD19L; +#endif sha256->buffLen = 0; sha256->loLen = 0; sha256->hiLen = 0; - + #if defined(HAVE_INTEL_AVX1)|| defined(HAVE_INTEL_AVX2) set_Transform() ; /* choose best Transform function under this runtime environment */ #endif @@ -457,9 +471,14 @@ int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len) #else static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len) { + byte* local; + + if (sha256 == NULL || (data == NULL && len > 0)) { + return BAD_FUNC_ARG; + } /* do block size increments */ - byte* local = (byte*)sha256->buffer; + local = (byte*)sha256->buffer; SAVE_XMM_YMM ; /* for Intel AVX */ @@ -573,6 +592,10 @@ int wc_Sha256Final(Sha256* sha256, byte* hash) { int ret; + if (sha256 == NULL || hash == NULL) { + return BAD_FUNC_ARG; + } + ret = Sha256Final(sha256); if (ret != 0) return ret; diff --git a/wolfcrypt/src/sha512.c b/wolfcrypt/src/sha512.c index 9e8b1f7d8..0c971db33 100644 --- a/wolfcrypt/src/sha512.c +++ b/wolfcrypt/src/sha512.c @@ -32,18 +32,27 @@ #ifdef HAVE_FIPS int wc_InitSha512(Sha512* sha) { + if (sha == NULL) { + return -173; + } return InitSha512_fips(sha); } int wc_Sha512Update(Sha512* sha, const byte* data, word32 len) { + if (sha == NULL || (data == NULL && len > 0)) { + return -173; + } return Sha512Update_fips(sha, data, len); } int wc_Sha512Final(Sha512* sha, byte* out) { + if (sha == NULL || out == NULL) { + return -173; + } return Sha512Final_fips(sha, out); } @@ -52,18 +61,27 @@ int wc_Sha512Final(Sha512* sha, byte* out) int wc_InitSha384(Sha384* sha) { + if (sha == NULL) { + return -173; + } return InitSha384_fips(sha); } int wc_Sha384Update(Sha384* sha, const byte* data, word32 len) { + if (sha == NULL || (data == NULL && len > 0)) { + return -173; + } return Sha384Update_fips(sha, data, len); } int wc_Sha384Final(Sha384* sha, byte* out) { + if (sha == NULL || out == NULL) { + return -173; + } return Sha384Final_fips(sha, out); } @@ -113,7 +131,7 @@ Intel AVX1/AVX2 Macro Control Structure #define HAVE_INTEL_AVX2 #endif -int InitSha512(Sha512* sha512) { +int InitSha512(Sha512* sha512) { Save/Recover XMM, YMM ... @@ -121,27 +139,27 @@ int InitSha512(Sha512* sha512) { } #if defined(HAVE_INTEL_AVX1)|| defined(HAVE_INTEL_AVX2) - Transform_AVX1() ; # Function prototype + Transform_AVX1() ; # Function prototype Transform_AVX2() ; # #endif _Transform() { # Native Transform Function body - + } - - int Sha512Update() { + + int Sha512Update() { Save/Recover XMM, YMM ... } - - int Sha512Final() { + + int Sha512Final() { Save/Recover XMM, YMM ... } #if defined(HAVE_INTEL_AVX1) - + XMM Instructions/INLINE asm Definitions #endif @@ -153,7 +171,7 @@ int InitSha512(Sha512* sha512) { #endif #if defnied(HAVE_INTEL_AVX1) - + int Transform_AVX1() { Stitched Message Sched/Round } @@ -161,7 +179,7 @@ int InitSha512(Sha512* sha512) { #endif #if defnied(HAVE_INTEL_AVX2) - + int Transform_AVX2() { Stitched Message Sched/Round } @@ -195,9 +213,9 @@ int InitSha512(Sha512* sha512) { #define EAX 0 #define EBX 1 -#define ECX 2 +#define ECX 2 #define EDX 3 - + #define CPUID_AVX1 0x1 #define CPUID_AVX2 0x2 #define CPUID_RDRAND 0x4 @@ -215,15 +233,15 @@ static word32 cpuid_flags = 0 ; static word32 cpuid_flag(word32 leaf, word32 sub, word32 num, word32 bit) { int got_intel_cpu=0; - unsigned int reg[5]; - + unsigned int reg[5]; + reg[4] = '\0' ; - cpuid(reg, 0, 0); - if(XMEMCMP((char *)&(reg[EBX]), "Genu", 4) == 0 && - XMEMCMP((char *)&(reg[EDX]), "ineI", 4) == 0 && - XMEMCMP((char *)&(reg[ECX]), "ntel", 4) == 0) { - got_intel_cpu = 1; - } + cpuid(reg, 0, 0); + if(XMEMCMP((char *)&(reg[EBX]), "Genu", 4) == 0 && + XMEMCMP((char *)&(reg[EDX]), "ineI", 4) == 0 && + XMEMCMP((char *)&(reg[ECX]), "ntel", 4) == 0) { + got_intel_cpu = 1; + } if (got_intel_cpu) { cpuid(reg, leaf, sub); return((reg[num]>>bit)&0x1) ; @@ -237,7 +255,7 @@ static int set_cpuid_flags() { if(cpuid_flag(1, 0, ECX, 28)){ cpuid_flags |= CPUID_AVX1 ;} if(cpuid_flag(7, 0, EBX, 5)){ cpuid_flags |= CPUID_AVX2 ; } 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 ; } cpuid_check = 1 ; return 0 ; @@ -253,7 +271,7 @@ static int Transform_AVX1(Sha512 *sha512) ; #endif #if defined(HAVE_INTEL_AVX2) -static int Transform_AVX2(Sha512 *sha512) ; +static int Transform_AVX2(Sha512 *sha512) ; #if defined(HAVE_INTEL_AVX1) && defined(HAVE_INTEL_AVX2) && defined(HAVE_INTEL_RORX) static int Transform_AVX1_RORX(Sha512 *sha512) ; @@ -261,8 +279,8 @@ static int Transform_AVX1_RORX(Sha512 *sha512) ; #endif -static int _Transform(Sha512 *sha512) ; - +static int _Transform(Sha512 *sha512) ; + static int (*Transform_p)(Sha512* sha512) = _Transform ; #define Transform(sha512) (*Transform_p)(sha512) @@ -271,9 +289,9 @@ static void set_Transform(void) { if(set_cpuid_flags()) return ; #if defined(HAVE_INTEL_AVX2) - if(IS_INTEL_AVX2 && IS_INTEL_BMI2){ - Transform_p = Transform_AVX1_RORX; return ; - Transform_p = Transform_AVX2 ; + if(IS_INTEL_AVX2 && IS_INTEL_BMI2){ + Transform_p = Transform_AVX1_RORX; return ; + Transform_p = Transform_AVX2 ; /* for avoiding warning,"not used" */ } #endif @@ -338,6 +356,10 @@ static INLINE ROTR(rotrFixed64_41, 41, x) int wc_InitSha512(Sha512* sha512) { + if (sha512 == NULL) { + return BAD_FUNC_ARG; + } + sha512->digest[0] = W64LIT(0x6a09e667f3bcc908); sha512->digest[1] = W64LIT(0xbb67ae8584caa73b); sha512->digest[2] = W64LIT(0x3c6ef372fe94f82b); @@ -350,11 +372,11 @@ int wc_InitSha512(Sha512* sha512) sha512->buffLen = 0; sha512->loLen = 0; sha512->hiLen = 0; - + #if defined(HAVE_INTEL_AVX1)|| defined(HAVE_INTEL_AVX2) set_Transform() ; /* choose best Transform function under this runtime environment */ #endif - + return 0 ; } @@ -452,7 +474,7 @@ static int _Transform(Sha512* sha512) /* over twice as small, but 50% slower */ /* 80 operations, not unrolled */ for (j = 0; j < 80; j += 16) { - int m; + int m; for (m = 0; m < 16; m++) { /* braces needed here for macros {} */ R(m); } @@ -499,8 +521,13 @@ static INLINE void AddLength(Sha512* sha512, word32 len) static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len) { + byte* local; + + if (sha512 == NULL ||(data == NULL && len > 0)) { + return BAD_FUNC_ARG; + } /* do block size increments */ - byte* local = (byte*)sha512->buffer; + local = (byte*)sha512->buffer; SAVE_XMM_YMM ; /* for Intel AVX */ while (len) { @@ -515,7 +542,7 @@ static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len) int ret; #if defined(LITTLE_ENDIAN_ORDER) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) - if(!IS_INTEL_AVX1 && !IS_INTEL_AVX2) + if(!IS_INTEL_AVX1 && !IS_INTEL_AVX2) #endif ByteReverseWords64(sha512->buffer, sha512->buffer, SHA512_BLOCK_SIZE); @@ -551,7 +578,7 @@ static INLINE int Sha512Final(Sha512* sha512) if (sha512->buffLen > SHA512_PAD_SIZE) { XMEMSET(&local[sha512->buffLen], 0, SHA512_BLOCK_SIZE -sha512->buffLen); sha512->buffLen += SHA512_BLOCK_SIZE - sha512->buffLen; - #if defined(LITTLE_ENDIAN_ORDER) + #if defined(LITTLE_ENDIAN_ORDER) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) if(!IS_INTEL_AVX1 && !IS_INTEL_AVX2) #endif @@ -564,9 +591,9 @@ static INLINE int Sha512Final(Sha512* sha512) sha512->buffLen = 0; } XMEMSET(&local[sha512->buffLen], 0, SHA512_PAD_SIZE - sha512->buffLen); - + /* put lengths in bits */ - sha512->hiLen = (sha512->loLen >> (8*sizeof(sha512->loLen) - 3)) + + sha512->hiLen = (sha512->loLen >> (8*sizeof(sha512->loLen) - 3)) + (sha512->hiLen << 3); sha512->loLen = sha512->loLen << 3; @@ -600,7 +627,13 @@ static INLINE int Sha512Final(Sha512* sha512) int wc_Sha512Final(Sha512* sha512, byte* hash) { - int ret = Sha512Final(sha512); + int ret; + + if (sha512 == NULL || hash == NULL) { + return BAD_FUNC_ARG; + } + + ret = Sha512Final(sha512); if (ret != 0) return ret; @@ -624,8 +657,8 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) #endif -#if defined(HAVE_INTEL_AVX2) -#define Ry_1(i, w) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j] + w ; +#if defined(HAVE_INTEL_AVX2) +#define Ry_1(i, w) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j] + w ; #define Ry_2(i, w) d(i)+=h(i); #define Ry_3(i, w) h(i)+=S0(a(i))+Maj(a(i),b(i),c(i)); #endif @@ -648,13 +681,13 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) RECV_REG(10); RECV_REG(11); RECV_REG(12); RECV_REG(13); RECV_REG(14); RECV_REG(15);\ } -#define DUMP_REG(REG) _DUMP_REG(REG, #REG) -#define PRINTF(fmt, ...) +#define DUMP_REG(REG) _DUMP_REG(REG, #REG) +#define PRINTF(fmt, ...) #else -#define DUMP_REG(REG) -#define PRINTF(fmt, ...) +#define DUMP_REG(REG) +#define PRINTF(fmt, ...) #endif @@ -681,7 +714,7 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) #define MOVE_to_REG(xymm, mem) _MOVE_to_REG(xymm, mem) #define MOVE_to_MEM(mem, i, xymm) _MOVE_to_MEM(mem, i, xymm) -#define MOVE(dest, src) _MOVE(dest, src) +#define MOVE(dest, src) _MOVE(dest, src) #define XOR(dest, src1, src2) _XOR(dest, src1, src2) #define OR(dest, src1, src2) _OR(dest, src1, src2) @@ -693,7 +726,7 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) #define Init_Mask(mask) \ __asm__ volatile("vmovdqu %0, %%xmm1\n\t"::"m"(mask):"%xmm1") ; - + #define _W_from_buff1(w, buff, xmm) \ /* X0..3(xmm4..7), W[0..15] = sha512->buffer[0.15]; */\ __asm__ volatile("vmovdqu %1, %%"#xmm"\n\t"\ @@ -701,7 +734,7 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) "vmovdqu %%"#xmm", %0"\ :"=m"(w): "m"(buff):"%xmm0") ; -#define W_from_buff1(w, buff, xmm) _W_from_buff1(w, buff, xmm) +#define W_from_buff1(w, buff, xmm) _W_from_buff1(w, buff, xmm) #define W_from_buff(w, buff)\ Init_Mask(mBYTE_FLIP_MASK[0]) ;\ @@ -713,7 +746,7 @@ int wc_Sha512Final(Sha512* sha512, byte* hash) W_from_buff1(w[10],buff[10],W_10);\ W_from_buff1(w[12],buff[12],W_12);\ W_from_buff1(w[14],buff[14],W_14); - + static word64 mBYTE_FLIP_MASK[] = { 0x0001020304050607, 0x08090a0b0c0d0e0f } ; #define W_I_15 xmm14 @@ -735,35 +768,35 @@ static word64 mBYTE_FLIP_MASK[] = { 0x0001020304050607, 0x08090a0b0c0d0e0f } ; #define XMM_REGs -#define s0_1(dest, src) AVX1_S(dest, src, 1); -#define s0_2(dest, src) AVX1_S(G_TEMP, src, 8); XOR(dest, G_TEMP, dest) ; +#define s0_1(dest, src) AVX1_S(dest, src, 1); +#define s0_2(dest, src) AVX1_S(G_TEMP, src, 8); XOR(dest, G_TEMP, dest) ; #define s0_3(dest, src) AVX1_R(G_TEMP, src, 7); XOR(dest, G_TEMP, dest) ; #define s1_1(dest, src) AVX1_S(dest, src, 19); -#define s1_2(dest, src) AVX1_S(G_TEMP, src, 61); XOR(dest, G_TEMP, dest) ; +#define s1_2(dest, src) AVX1_S(G_TEMP, src, 61); XOR(dest, G_TEMP, dest) ; #define s1_3(dest, src) AVX1_R(G_TEMP, src, 6); XOR(dest, G_TEMP, dest) ; #define s0_(dest, src) s0_1(dest, src) ; s0_2(dest, src) ; s0_3(dest, src) #define s1_(dest, src) s1_1(dest, src) ; s1_2(dest, src) ; s1_3(dest, src) - + #define Block_xx_1(i) \ MOVE_to_REG(W_I_15, W_X[(i-15)&15]) ;\ MOVE_to_REG(W_I_7, W_X[(i- 7)&15]) ;\ - + #define Block_xx_2(i) \ MOVE_to_REG(W_I_2, W_X[(i- 2)&15]) ;\ MOVE_to_REG(W_I, W_X[(i)]) ;\ - + #define Block_xx_3(i) \ s0_ (XMM_TEMP0, W_I_15) ;\ - + #define Block_xx_4(i) \ ADD(W_I, W_I, XMM_TEMP0) ;\ ADD(W_I, W_I, W_I_7) ;\ - + #define Block_xx_5(i) \ s1_ (XMM_TEMP0, W_I_2) ;\ - + #define Block_xx_6(i) \ ADD(W_I, W_I, XMM_TEMP0) ;\ MOVE_to_MEM(W_X,i, W_I) ;\ @@ -773,7 +806,7 @@ static word64 mBYTE_FLIP_MASK[] = { 0x0001020304050607, 0x08090a0b0c0d0e0f } ; #define Block_xx_7(i) \ MOVE_to_REG(W_I_15, W_X[(i-15)&15]) ;\ MOVE_to_REG(W_I_7, W_X[(i- 7)&15]) ;\ - + #define Block_xx_8(i) \ MOVE_to_REG(W_I_2, W_X[(i- 2)&15]) ;\ MOVE_to_REG(W_I, W_X[(i)]) ;\ @@ -884,15 +917,15 @@ static const unsigned long mBYTE_FLIP_MASK_Y[] = RECV_REG_Y(13); RECV_REG_Y(14); RECV_REG_Y(15);\ } -#define DUMP_REG_Y(REG) _DUMP_REG_Y(REG, #REG) -#define DUMP_REG2_Y(REG) _DUMP_REG_Y(REG, #REG) -#define PRINTF_Y(fmt, ...) +#define DUMP_REG_Y(REG) _DUMP_REG_Y(REG, #REG) +#define DUMP_REG2_Y(REG) _DUMP_REG_Y(REG, #REG) +#define PRINTF_Y(fmt, ...) #else -#define DUMP_REG_Y(REG) +#define DUMP_REG_Y(REG) #define DUMP_REG2_Y(REG) -#define PRINTF_Y(fmt, ...) +#define PRINTF_Y(fmt, ...) #endif @@ -921,7 +954,7 @@ static const unsigned long mBYTE_FLIP_MASK_Y[] = #define MOVE_to_REGy(ymm, mem) _MOVE_to_REGy(ymm, mem) #define MOVE_to_MEMy(mem, i, ymm) _MOVE_to_MEMy(mem, i, ymm) -#define MOVE_128y(ymm0, ymm1, ymm2, map) _MOVE_128y(ymm0, ymm1, ymm2, map) +#define MOVE_128y(ymm0, ymm1, ymm2, map) _MOVE_128y(ymm0, ymm1, ymm2, map) #define XORy(dest, src1, src2) _XORy(dest, src1, src2) #define ADDy(dest, src1, src2) _ADDy(dest, src1, src2) #define BLENDy(map, dest, src1, src2) _BLENDy(map, dest, src1, src2) @@ -935,12 +968,12 @@ static const unsigned long mBYTE_FLIP_MASK_Y[] = #define FEEDBACK1_to_W_I_2(w_i_2, w_i) MOVE_128y(YMM_TEMP0, w_i, w_i, 0x08) ;\ - BLENDy(0xf0, w_i_2, YMM_TEMP0, w_i_2) ; + BLENDy(0xf0, w_i_2, YMM_TEMP0, w_i_2) ; #define MOVE_W_to_W_I_15(w_i_15, w_0, w_4) BLENDQy(0x1, w_i_15, w_4, w_0) ;\ PERMQy(0x39, w_i_15, w_i_15) ; #define MOVE_W_to_W_I_7(w_i_7, w_8, w_12) BLENDQy(0x1, w_i_7, w_12, w_8) ;\ - PERMQy(0x39, w_i_7, w_i_7) ; + PERMQy(0x39, w_i_7, w_i_7) ; #define MOVE_W_to_W_I_2(w_i_2, w_12) BLENDQy(0xc, w_i_2, w_12, w_i_2) ;\ PERMQy(0x0e, w_i_2, w_i_2) ; @@ -1002,25 +1035,25 @@ static int Transform_AVX1(Sha512* sha512) W_from_buff(W_X, sha512->buffer) ; for (j = 0; j < 80; j += 16) { - Rx_1( 0); Block_0_1(W_X); Rx_2( 0); Block_0_2(W_X); Rx_3( 0); Block_0_3(); - Rx_1( 1); Block_0_4(); Rx_2( 1); Block_0_5(); Rx_3( 1); Block_0_6(W_X); + Rx_1( 0); Block_0_1(W_X); Rx_2( 0); Block_0_2(W_X); Rx_3( 0); Block_0_3(); + Rx_1( 1); Block_0_4(); Rx_2( 1); Block_0_5(); Rx_3( 1); Block_0_6(W_X); Rx_1( 2); Block_0_7(W_X); Rx_2( 2); Block_0_8(W_X); Rx_3( 2); Block_0_9(); - Rx_1( 3); Block_0_10();Rx_2( 3); Block_0_11();Rx_3( 3); Block_0_12(W_X); - - Rx_1( 4); Block_4_1(W_X); Rx_2( 4); Block_4_2(W_X); Rx_3( 4); Block_4_3(); - Rx_1( 5); Block_4_4(); Rx_2( 5); Block_4_5(); Rx_3( 5); Block_4_6(W_X); + Rx_1( 3); Block_0_10();Rx_2( 3); Block_0_11();Rx_3( 3); Block_0_12(W_X); + + Rx_1( 4); Block_4_1(W_X); Rx_2( 4); Block_4_2(W_X); Rx_3( 4); Block_4_3(); + Rx_1( 5); Block_4_4(); Rx_2( 5); Block_4_5(); Rx_3( 5); Block_4_6(W_X); Rx_1( 6); Block_4_7(W_X); Rx_2( 6); Block_4_8(W_X); Rx_3( 6); Block_4_9(); - Rx_1( 7); Block_4_10();Rx_2( 7); Block_4_11();Rx_3( 7); Block_4_12(W_X); - - Rx_1( 8); Block_8_1(W_X); Rx_2( 8); Block_8_2(W_X); Rx_3( 8); Block_8_3(); - Rx_1( 9); Block_8_4(); Rx_2( 9); Block_8_5(); Rx_3( 9); Block_8_6(W_X); + Rx_1( 7); Block_4_10();Rx_2( 7); Block_4_11();Rx_3( 7); Block_4_12(W_X); + + Rx_1( 8); Block_8_1(W_X); Rx_2( 8); Block_8_2(W_X); Rx_3( 8); Block_8_3(); + Rx_1( 9); Block_8_4(); Rx_2( 9); Block_8_5(); Rx_3( 9); Block_8_6(W_X); Rx_1(10); Block_8_7(W_X); Rx_2(10); Block_8_8(W_X); Rx_3(10); Block_8_9(); - Rx_1(11); Block_8_10();Rx_2(11); Block_8_11();Rx_3(11); Block_8_12(W_X); - - Rx_1(12); Block_12_1(W_X); Rx_2(12); Block_12_2(W_X); Rx_3(12); Block_12_3(); - Rx_1(13); Block_12_4(); Rx_2(13); Block_12_5(); Rx_3(13); Block_12_6(W_X); + Rx_1(11); Block_8_10();Rx_2(11); Block_8_11();Rx_3(11); Block_8_12(W_X); + + Rx_1(12); Block_12_1(W_X); Rx_2(12); Block_12_2(W_X); Rx_3(12); Block_12_3(); + Rx_1(13); Block_12_4(); Rx_2(13); Block_12_5(); Rx_3(13); Block_12_6(W_X); Rx_1(14); Block_12_7(W_X); Rx_2(14); Block_12_8(W_X); Rx_3(14); Block_12_9(); - Rx_1(15); Block_12_10();Rx_2(15); Block_12_11();Rx_3(15); Block_12_12(W_X); + Rx_1(15); Block_12_10();Rx_2(15); Block_12_11();Rx_3(15); Block_12_12(W_X); } /* Add the working vars back into digest */ @@ -1058,41 +1091,41 @@ static int Transform_AVX1_RORX(Sha512* sha512) W_from_buff(W_X, sha512->buffer) ; for (j = 0; j < 80; j += 16) { - Rx_RORX_1( 0); Block_0_1(W_X); Rx_RORX_2( 0); Block_0_2(W_X); - Rx_RORX_3( 0); Block_0_3(); - Rx_RORX_1( 1); Block_0_4(); Rx_RORX_2( 1); Block_0_5(); - Rx_RORX_3( 1); Block_0_6(W_X); - Rx_RORX_1( 2); Block_0_7(W_X); Rx_RORX_2( 2); Block_0_8(W_X); + Rx_RORX_1( 0); Block_0_1(W_X); Rx_RORX_2( 0); Block_0_2(W_X); + Rx_RORX_3( 0); Block_0_3(); + Rx_RORX_1( 1); Block_0_4(); Rx_RORX_2( 1); Block_0_5(); + Rx_RORX_3( 1); Block_0_6(W_X); + Rx_RORX_1( 2); Block_0_7(W_X); Rx_RORX_2( 2); Block_0_8(W_X); Rx_RORX_3( 2); Block_0_9(); Rx_RORX_1( 3); Block_0_10();Rx_RORX_2( 3); Block_0_11(); - Rx_RORX_3( 3); Block_0_12(W_X); - - Rx_RORX_1( 4); Block_4_1(W_X); Rx_RORX_2( 4); Block_4_2(W_X); - Rx_RORX_3( 4); Block_4_3(); - Rx_RORX_1( 5); Block_4_4(); Rx_RORX_2( 5); Block_4_5(); - Rx_RORX_3( 5); Block_4_6(W_X); - Rx_RORX_1( 6); Block_4_7(W_X); Rx_RORX_2( 6); Block_4_8(W_X); + Rx_RORX_3( 3); Block_0_12(W_X); + + Rx_RORX_1( 4); Block_4_1(W_X); Rx_RORX_2( 4); Block_4_2(W_X); + Rx_RORX_3( 4); Block_4_3(); + Rx_RORX_1( 5); Block_4_4(); Rx_RORX_2( 5); Block_4_5(); + Rx_RORX_3( 5); Block_4_6(W_X); + Rx_RORX_1( 6); Block_4_7(W_X); Rx_RORX_2( 6); Block_4_8(W_X); Rx_RORX_3( 6); Block_4_9(); Rx_RORX_1( 7); Block_4_10();Rx_RORX_2( 7); Block_4_11(); - Rx_RORX_3( 7); Block_4_12(W_X); - - Rx_RORX_1( 8); Block_8_1(W_X); Rx_RORX_2( 8); Block_8_2(W_X); - Rx_RORX_3( 8); Block_8_3(); - Rx_RORX_1( 9); Block_8_4(); Rx_RORX_2( 9); Block_8_5(); - Rx_RORX_3( 9); Block_8_6(W_X); - Rx_RORX_1(10); Block_8_7(W_X); Rx_RORX_2(10); Block_8_8(W_X); + Rx_RORX_3( 7); Block_4_12(W_X); + + Rx_RORX_1( 8); Block_8_1(W_X); Rx_RORX_2( 8); Block_8_2(W_X); + Rx_RORX_3( 8); Block_8_3(); + Rx_RORX_1( 9); Block_8_4(); Rx_RORX_2( 9); Block_8_5(); + Rx_RORX_3( 9); Block_8_6(W_X); + Rx_RORX_1(10); Block_8_7(W_X); Rx_RORX_2(10); Block_8_8(W_X); Rx_RORX_3(10); Block_8_9(); Rx_RORX_1(11); Block_8_10();Rx_RORX_2(11); Block_8_11(); - Rx_RORX_3(11); Block_8_12(W_X); - - Rx_RORX_1(12); Block_12_1(W_X); Rx_RORX_2(12); Block_12_2(W_X); - Rx_RORX_3(12); Block_12_3(); - Rx_RORX_1(13); Block_12_4(); Rx_RORX_2(13); Block_12_5(); - Rx_RORX_3(13); Block_12_6(W_X); - Rx_RORX_1(14); Block_12_7(W_X); Rx_RORX_2(14); Block_12_8(W_X); + Rx_RORX_3(11); Block_8_12(W_X); + + Rx_RORX_1(12); Block_12_1(W_X); Rx_RORX_2(12); Block_12_2(W_X); + Rx_RORX_3(12); Block_12_3(); + Rx_RORX_1(13); Block_12_4(); Rx_RORX_2(13); Block_12_5(); + Rx_RORX_3(13); Block_12_6(W_X); + Rx_RORX_1(14); Block_12_7(W_X); Rx_RORX_2(14); Block_12_8(W_X); Rx_RORX_3(14); Block_12_9(); Rx_RORX_1(15); Block_12_10();Rx_RORX_2(15); Block_12_11(); - Rx_RORX_3(15); Block_12_12(W_X); + Rx_RORX_3(15); Block_12_12(W_X); } /* Add the working vars back into digest */ @@ -1117,12 +1150,12 @@ static int Transform_AVX1_RORX(Sha512* sha512) #if defined(HAVE_INTEL_AVX2) -#define s0_1y(dest, src) AVX2_S(dest, src, 1); -#define s0_2y(dest, src) AVX2_S(G_TEMPy, src, 8); XORy(dest, G_TEMPy, dest) ; +#define s0_1y(dest, src) AVX2_S(dest, src, 1); +#define s0_2y(dest, src) AVX2_S(G_TEMPy, src, 8); XORy(dest, G_TEMPy, dest) ; #define s0_3y(dest, src) AVX2_R(G_TEMPy, src, 7); XORy(dest, G_TEMPy, dest) ; #define s1_1y(dest, src) AVX2_S(dest, src, 19); -#define s1_2y(dest, src) AVX2_S(G_TEMPy, src, 61); XORy(dest, G_TEMPy, dest) ; +#define s1_2y(dest, src) AVX2_S(G_TEMPy, src, 61); XORy(dest, G_TEMPy, dest) ; #define s1_3y(dest, src) AVX2_R(G_TEMPy, src, 6); XORy(dest, G_TEMPy, dest) ; #define s0_y(dest, src) s0_1y(dest, src) ; s0_2y(dest, src) ; s0_3y(dest, src) @@ -1235,45 +1268,45 @@ static int Transform_AVX2(Sha512* sha512) XMEMCPY(T, sha512->digest, sizeof(T)); W_from_buff_Y(sha512->buffer) ; - MOVE_to_MEMy(w,0, W_0y) ; + MOVE_to_MEMy(w,0, W_0y) ; for (j = 0; j < 80; j += 16) { - Ry_1( 0, w[0]); Block_Y_0_1(); Ry_2( 0, w[0]); Block_Y_0_2(); - Ry_3( 0, w[0]); Block_Y_0_3(); - Ry_1( 1, w[1]); Block_Y_0_4(); Ry_2( 1, w[1]); Block_Y_0_5(); - Ry_3( 1, w[1]); Block_Y_0_6(); - Ry_1( 2, w[2]); Block_Y_0_7(); Ry_2( 2, w[2]); Block_Y_0_8(); + Ry_1( 0, w[0]); Block_Y_0_1(); Ry_2( 0, w[0]); Block_Y_0_2(); + Ry_3( 0, w[0]); Block_Y_0_3(); + Ry_1( 1, w[1]); Block_Y_0_4(); Ry_2( 1, w[1]); Block_Y_0_5(); + Ry_3( 1, w[1]); Block_Y_0_6(); + Ry_1( 2, w[2]); Block_Y_0_7(); Ry_2( 2, w[2]); Block_Y_0_8(); Ry_3( 2, w[2]); Block_Y_0_9(); Ry_1( 3, w[3]); Block_Y_0_10();Ry_2( 3, w[3]); Block_Y_0_11(); Ry_3( 3, w[3]); Block_Y_0_12(w); - - Ry_1( 4, w[0]); Block_Y_4_1(); Ry_2( 4, w[0]); Block_Y_4_2(); - Ry_3( 4, w[0]); Block_Y_4_3(); - Ry_1( 5, w[1]); Block_Y_4_4(); Ry_2( 5, w[1]); Block_Y_4_5(); + + Ry_1( 4, w[0]); Block_Y_4_1(); Ry_2( 4, w[0]); Block_Y_4_2(); + Ry_3( 4, w[0]); Block_Y_4_3(); + Ry_1( 5, w[1]); Block_Y_4_4(); Ry_2( 5, w[1]); Block_Y_4_5(); Ry_3( 5, w[1]); Block_Y_4_6(); - Ry_1( 6, w[2]); Block_Y_4_7(); Ry_2( 6, w[2]); Block_Y_4_8(); + Ry_1( 6, w[2]); Block_Y_4_7(); Ry_2( 6, w[2]); Block_Y_4_8(); Ry_3( 6, w[2]); Block_Y_4_9(); - Ry_1( 7, w[3]); Block_Y_4_10(); Ry_2( 7, w[3]);Block_Y_4_11(); - Ry_3( 7, w[3]);Block_Y_4_12(w); - - Ry_1( 8, w[0]); Block_Y_8_1(); Ry_2( 8, w[0]); Block_Y_8_2(); + Ry_1( 7, w[3]); Block_Y_4_10(); Ry_2( 7, w[3]);Block_Y_4_11(); + Ry_3( 7, w[3]);Block_Y_4_12(w); + + Ry_1( 8, w[0]); Block_Y_8_1(); Ry_2( 8, w[0]); Block_Y_8_2(); Ry_3( 8, w[0]); Block_Y_8_3(); - Ry_1( 9, w[1]); Block_Y_8_4(); Ry_2( 9, w[1]); Block_Y_8_5(); + Ry_1( 9, w[1]); Block_Y_8_4(); Ry_2( 9, w[1]); Block_Y_8_5(); Ry_3( 9, w[1]); Block_Y_8_6(); - Ry_1(10, w[2]); Block_Y_8_7(); Ry_2(10, w[2]); Block_Y_8_8(); - Ry_3(10, w[2]); Block_Y_8_9(); + Ry_1(10, w[2]); Block_Y_8_7(); Ry_2(10, w[2]); Block_Y_8_8(); + Ry_3(10, w[2]); Block_Y_8_9(); Ry_1(11, w[3]); Block_Y_8_10();Ry_2(11, w[3]); Block_Y_8_11(); Ry_3(11, w[3]); Block_Y_8_12(w); - - Ry_1(12, w[0]); Block_Y_12_1(); Ry_2(12, w[0]); Block_Y_12_2(); + + Ry_1(12, w[0]); Block_Y_12_1(); Ry_2(12, w[0]); Block_Y_12_2(); Ry_3(12, w[0]); Block_Y_12_3(); - Ry_1(13, w[1]); Block_Y_12_4(); Ry_2(13, w[1]); Block_Y_12_5(); - Ry_3(13, w[1]); Block_Y_12_6(); - Ry_1(14, w[2]); Block_Y_12_7(); Ry_2(14, w[2]); Block_Y_12_8(); + Ry_1(13, w[1]); Block_Y_12_4(); Ry_2(13, w[1]); Block_Y_12_5(); + Ry_3(13, w[1]); Block_Y_12_6(); + Ry_1(14, w[2]); Block_Y_12_7(); Ry_2(14, w[2]); Block_Y_12_8(); Ry_3(14, w[2]); Block_Y_12_9(); Ry_1(15, w[3]); Block_Y_12_10();Ry_2(15, w[3]); Block_Y_12_11(); Ry_3(15, w[3]);Block_Y_12_12(w); } - + /* Add the working vars back into digest */ sha512->digest[0] += a(0); @@ -1300,6 +1333,10 @@ static int Transform_AVX2(Sha512* sha512) #ifdef WOLFSSL_SHA384 int wc_InitSha384(Sha384* sha384) { + if (sha384 == NULL) { + return BAD_FUNC_ARG; + } + sha384->digest[0] = W64LIT(0xcbbb9d5dc1059ed8); sha384->digest[1] = W64LIT(0x629a292a367cd507); sha384->digest[2] = W64LIT(0x9159015a3070dd17); @@ -1316,7 +1353,7 @@ int wc_InitSha384(Sha384* sha384) #if defined(HAVE_INTEL_AVX1)|| defined(HAVE_INTEL_AVX2) set_Transform() ; #endif - + return 0; } @@ -1328,7 +1365,13 @@ int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len) int wc_Sha384Final(Sha384* sha384, byte* hash) { - int ret = Sha512Final((Sha512 *)sha384); + int ret; + + if (sha384 == NULL || hash == NULL) { + return BAD_FUNC_ARG; + } + + ret = Sha512Final((Sha512 *)sha384); if (ret != 0) return ret; diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index 1b26570f6..c4cbcf1ed 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -842,6 +842,7 @@ int md5_test(void) testVector a, b, c, d, e; testVector test_md5[5]; int times = sizeof(test_md5) / sizeof(testVector), i; + int ret; a.input = "abc"; a.output = "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f" @@ -881,11 +882,21 @@ int md5_test(void) test_md5[3] = d; test_md5[4] = e; - wc_InitMd5(&md5); + ret = wc_InitMd5(&md5); + if (ret != 0) { + return ret; + } for (i = 0; i < times; ++i) { - wc_Md5Update(&md5, (byte*)test_md5[i].input, (word32)test_md5[i].inLen); - wc_Md5Final(&md5, hash); + ret = wc_Md5Update(&md5, (byte*)test_md5[i].input, + (word32)test_md5[i].inLen); + if (ret != 0) { + return ret; + } + ret = wc_Md5Final(&md5, hash); + if (ret != 0){ + return ret; + } if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0) return -5 - i; diff --git a/wolfssl/wolfcrypt/md5.h b/wolfssl/wolfcrypt/md5.h index 17783b173..b3d1c43af 100644 --- a/wolfssl/wolfcrypt/md5.h +++ b/wolfssl/wolfcrypt/md5.h @@ -73,9 +73,11 @@ typedef struct Md5 { #include "wolfssl/wolfcrypt/port/ti/ti-hash.h" #endif -WOLFSSL_API void wc_InitMd5(Md5*); -WOLFSSL_API void wc_Md5Update(Md5*, const byte*, word32); -WOLFSSL_API void wc_Md5Final(Md5*, byte*); + +WOLFSSL_API int wc_InitMd5(Md5*); +WOLFSSL_API int wc_Md5Update(Md5*, const byte*, word32); +WOLFSSL_API int wc_Md5Final(Md5*, byte*); + WOLFSSL_API int wc_Md5Hash(const byte*, word32, byte*); #ifdef __cplusplus