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

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

91
src/keys.c
View File

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

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

61
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,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;

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

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