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

unit test md5, sha, sha256, sha384, sha512

Browse Source 
Memory leak fix.
This commit is contained in:
David Garske
2016-12-19 12:15:10 -08:00
committed by jrblixt
parent cb0cc92ff2
commit 050ba9d6e0
16 changed files with 1754 additions and 299 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)
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);
}

18
mcapi/mcapi_test.c
View File

@@ -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;
}

295
src/internal.c
View File

@@ -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 <wolfssl/wolfcrypt/hash.h>
#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));
/* in buffer */
wc_ShaUpdate(&sha, in, sz);
wc_ShaFinal(&sha, result);
/* 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;
}
return 0;
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 */
ret = wc_ShaUpdate(&sha, in, sz);
if (ret != 0) {
return ret;
}
ret = wc_ShaFinal(&sha, result);
if (ret != 0) {
return ret;
}
/* outer */
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 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

75
src/keys.c
View File

@@ -2904,7 +2904,18 @@ int DeriveKeys(WOLFSSL* ssl)
}
#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)
@@ -3023,7 +3056,17 @@ static int MakeSslMasterSecret(WOLFSSL* ssl)
}
#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);
@@ -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

16
src/sniffer.c
View File

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

76
src/ssl.c
View File

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

912
tests/api.c
View File

@@ -43,6 +43,22 @@
#include <wolfssl/test.h>
#include <tests/unit.h>
#ifndef NO_MD5
#include <wolfssl/wolfcrypt/md5.h>
#endif
#ifndef NO_SHA
#include <wolfssl/wolfcrypt/sha.h>
#endif
#ifndef NO_SHA256
#include <wolfssl/wolfcrypt/sha256.h>
#endif
#ifdef WOLFSSL_SHA512
#include <wolfssl/wolfcrypt/sha512.h>
#endif
#ifdef WOLFSSL_SHA384
#include <wolfssl/wolfcrypt/sha512.h>
#endif
#ifdef OPENSSL_EXTRA
#include <wolfssl/openssl/ssl.h>
#include <wolfssl/openssl/pkcs12.h>
@@ -57,6 +73,16 @@
#endif
#include <wolfssl/certs_test.h>
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");
}

18
tests/hash.c
View File

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

79
wolfcrypt/src/hmac.c
View File

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

56
wolfcrypt/src/md5.c
View File

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

55
wolfcrypt/src/pwdbased.c
View File

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

30
wolfcrypt/src/sha.c
View File

@@ -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 */

31
wolfcrypt/src/sha256.c
View File

@@ -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,14 +318,19 @@ int wc_InitSha256(Sha256* sha256)
int wc_InitSha256(Sha256* sha256)
{
int ret = 0;
#ifdef FREESCALE_MMCAU_SHA
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
#else
sha256->digest[0] = 0x6A09E667L;
sha256->digest[1] = 0xBB67AE85L;
sha256->digest[2] = 0x3C6EF372L;
@@ -325,7 +339,7 @@ int wc_InitSha256(Sha256* sha256)
sha256->digest[5] = 0x9B05688CL;
sha256->digest[6] = 0x1F83D9ABL;
sha256->digest[7] = 0x5BE0CD19L;
#endif
#endif
sha256->buffLen = 0;
sha256->loLen = 0;
@@ -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;

49
wolfcrypt/src/sha512.c
View File

@@ -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);
}
@@ -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);
@@ -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) {
@@ -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;
@@ -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);
@@ -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;

17
wolfcrypt/test/test.c
View File

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

8
wolfssl/wolfcrypt/md5.h
View File

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