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

update to md functions and blake for hmac

Browse Source
This commit is contained in:
Jacob Barthelmeh
2015-01-03 17:24:51 -07:00
parent f64d76257e
commit 144798c962
7 changed files with 389 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

738
ctaocrypt/src/md5.c
View File

@@ -20,372 +20,372 @@
*/ */
//#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
// #include <config.h> #include <config.h>
//#endif #endif
//
//#include <cyassl/ctaocrypt/settings.h> #include <cyassl/ctaocrypt/settings.h>
//
//#if !defined(NO_MD5) #if !defined(NO_MD5)
//
//#ifdef CYASSL_PIC32MZ_HASH #ifdef CYASSL_PIC32MZ_HASH
//#define InitMd5 InitMd5_sw #define InitMd5 InitMd5_sw
//#define Md5Update Md5Update_sw #define Md5Update Md5Update_sw
//#define Md5Final Md5Final_sw #define Md5Final Md5Final_sw
//#endif #endif
//
//#include <cyassl/ctaocrypt/md5.h> #include <cyassl/ctaocrypt/md5.h>
//#include <cyassl/ctaocrypt/error-crypt.h> #include <cyassl/ctaocrypt/error-crypt.h>
//
//#ifdef NO_INLINE #ifdef NO_INLINE
// #include <cyassl/ctaocrypt/misc.h> #include <cyassl/ctaocrypt/misc.h>
//#else #else
// #include <ctaocrypt/src/misc.c> #include <ctaocrypt/src/misc.c>
//#endif #endif
//
//#ifdef FREESCALE_MMCAU #ifdef FREESCALE_MMCAU
// #include "cau_api.h" #include "cau_api.h"
// #define XTRANSFORM(S,B) cau_md5_hash_n((B), 1, (unsigned char*)(S)->digest) #define XTRANSFORM(S,B) cau_md5_hash_n((B), 1, (unsigned char*)(S)->digest)
//#else #else
// #define XTRANSFORM(S,B) Transform((S)) #define XTRANSFORM(S,B) Transform((S))
//#endif #endif
//
//
//#ifdef STM32F2_HASH #ifdef STM32F2_HASH
// /* /*
// * STM32F2 hardware MD5 support through the STM32F2 standard peripheral * STM32F2 hardware MD5 support through the STM32F2 standard peripheral
// * library. Documentation located in STM32F2xx Standard Peripheral Library * library. Documentation located in STM32F2xx Standard Peripheral Library
// * document (See note in README). * document (See note in README).
// */ */
// #include "stm32f2xx.h" #include "stm32f2xx.h"
//
// void InitMd5(Md5* md5) void InitMd5(Md5* md5)
// { {
// /* STM32F2 struct notes: /* STM32F2 struct notes:
// * md5->buffer = first 4 bytes used to hold partial block if needed * md5->buffer = first 4 bytes used to hold partial block if needed
// * md5->buffLen = num bytes currently stored in md5->buffer * md5->buffLen = num bytes currently stored in md5->buffer
// * md5->loLen = num bytes that have been written to STM32 FIFO * md5->loLen = num bytes that have been written to STM32 FIFO
// */ */
// XMEMSET(md5->buffer, 0, MD5_REG_SIZE); XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
//
// md5->buffLen = 0; md5->buffLen = 0;
// md5->loLen = 0; md5->loLen = 0;
//
// /* initialize HASH peripheral */ /* initialize HASH peripheral */
// HASH_DeInit(); HASH_DeInit();
//
// /* configure algo used, algo mode, datatype */ /* configure algo used, algo mode, datatype */
// HASH->CR &= ~ (HASH_CR_ALGO | HASH_CR_DATATYPE | HASH_CR_MODE); HASH->CR &= ~ (HASH_CR_ALGO | HASH_CR_DATATYPE | HASH_CR_MODE);
// HASH->CR |= (HASH_AlgoSelection_MD5 | HASH_AlgoMode_HASH HASH->CR |= (HASH_AlgoSelection_MD5 | HASH_AlgoMode_HASH
// | HASH_DataType_8b); | HASH_DataType_8b);
//
// /* reset HASH processor */ /* reset HASH processor */
// HASH->CR |= HASH_CR_INIT; HASH->CR |= HASH_CR_INIT;
// } }
//
// void Md5Update(Md5* md5, const byte* data, word32 len) void Md5Update(Md5* md5, const byte* data, word32 len)
// { {
// word32 i = 0; word32 i = 0;
// word32 fill = 0; word32 fill = 0;
// word32 diff = 0; word32 diff = 0;
//
// /* if saved partial block is available */ /* if saved partial block is available */
// if (md5->buffLen > 0) { if (md5->buffLen > 0) {
// fill = 4 - md5->buffLen; fill = 4 - md5->buffLen;
//
// /* if enough data to fill, fill and push to FIFO */ /* if enough data to fill, fill and push to FIFO */
// if (fill <= len) { if (fill <= len) {
// XMEMCPY((byte*)md5->buffer + md5->buffLen, data, fill); XMEMCPY((byte*)md5->buffer + md5->buffLen, data, fill);
// HASH_DataIn(*(uint32_t*)md5->buffer); HASH_DataIn(*(uint32_t*)md5->buffer);
//
// data += fill; data += fill;
// len -= fill; len -= fill;
// md5->loLen += 4; md5->loLen += 4;
// md5->buffLen = 0; md5->buffLen = 0;
// } else { } else {
// /* append partial to existing stored block */ /* append partial to existing stored block */
// XMEMCPY((byte*)md5->buffer + md5->buffLen, data, len); XMEMCPY((byte*)md5->buffer + md5->buffLen, data, len);
// md5->buffLen += len; md5->buffLen += len;
// return; return;
// } }
// } }
//
// /* write input block in the IN FIFO */ /* write input block in the IN FIFO */
// for (i = 0; i < len; i += 4) for (i = 0; i < len; i += 4)
// { {
// diff = len - i; diff = len - i;
// if (diff < 4) { if (diff < 4) {
// /* store incomplete last block, not yet in FIFO */ /* store incomplete last block, not yet in FIFO */
// XMEMSET(md5->buffer, 0, MD5_REG_SIZE); XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
// XMEMCPY((byte*)md5->buffer, data, diff); XMEMCPY((byte*)md5->buffer, data, diff);
// md5->buffLen = diff; md5->buffLen = diff;
// } else { } else {
// HASH_DataIn(*(uint32_t*)data); HASH_DataIn(*(uint32_t*)data);
// data+=4; data+=4;
// } }
// } }
//
// /* keep track of total data length thus far */ /* keep track of total data length thus far */
// md5->loLen += (len - md5->buffLen); md5->loLen += (len - md5->buffLen);
// } }
//
// void Md5Final(Md5* md5, byte* hash) void Md5Final(Md5* md5, byte* hash)
// { {
// __IO uint16_t nbvalidbitsdata = 0; __IO uint16_t nbvalidbitsdata = 0;
//
// /* finish reading any trailing bytes into FIFO */ /* finish reading any trailing bytes into FIFO */
// if (md5->buffLen > 0) { if (md5->buffLen > 0) {
// HASH_DataIn(*(uint32_t*)md5->buffer); HASH_DataIn(*(uint32_t*)md5->buffer);
// md5->loLen += md5->buffLen; md5->loLen += md5->buffLen;
// } }
//
// /* calculate number of valid bits in last word of input data */ /* calculate number of valid bits in last word of input data */
// nbvalidbitsdata = 8 * (md5->loLen % MD5_REG_SIZE); nbvalidbitsdata = 8 * (md5->loLen % MD5_REG_SIZE);
//
// /* configure number of valid bits in last word of the data */ /* configure number of valid bits in last word of the data */
// HASH_SetLastWordValidBitsNbr(nbvalidbitsdata); HASH_SetLastWordValidBitsNbr(nbvalidbitsdata);
//
// /* start HASH processor */ /* start HASH processor */
// HASH_StartDigest(); HASH_StartDigest();
//
// /* wait until Busy flag == RESET */ /* wait until Busy flag == RESET */
// while (HASH_GetFlagStatus(HASH_FLAG_BUSY) != RESET) {} while (HASH_GetFlagStatus(HASH_FLAG_BUSY) != RESET) {}
//
// /* read message digest */ /* read message digest */
// md5->digest[0] = HASH->HR[0]; md5->digest[0] = HASH->HR[0];
// md5->digest[1] = HASH->HR[1]; md5->digest[1] = HASH->HR[1];
// md5->digest[2] = HASH->HR[2]; md5->digest[2] = HASH->HR[2];
// md5->digest[3] = HASH->HR[3]; md5->digest[3] = HASH->HR[3];
//
// ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE); ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE);
//
// XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE);
//
// InitMd5(md5); /* reset state */ InitMd5(md5); /* reset state */
// } }
//
//#else /* CTaoCrypt software implementation */ #else /* CTaoCrypt software implementation */
//
//#ifndef min #ifndef min
//
// static INLINE word32 min(word32 a, word32 b) static INLINE word32 min(word32 a, word32 b)
// { {
// return a > b ? b : a; return a > b ? b : a;
// } }
//
//#endif /* min */ #endif /* min */
//
//
//void InitMd5(Md5* md5) void InitMd5(Md5* md5)
//{ {
// md5->digest[0] = 0x67452301L; md5->digest[0] = 0x67452301L;
// md5->digest[1] = 0xefcdab89L; md5->digest[1] = 0xefcdab89L;
// md5->digest[2] = 0x98badcfeL; md5->digest[2] = 0x98badcfeL;
// md5->digest[3] = 0x10325476L; md5->digest[3] = 0x10325476L;
//
// md5->buffLen = 0; md5->buffLen = 0;
// md5->loLen = 0; md5->loLen = 0;
// md5->hiLen = 0; md5->hiLen = 0;
//} }
//
//#ifndef FREESCALE_MMCAU #ifndef FREESCALE_MMCAU
//
//static void Transform(Md5* md5) static void Transform(Md5* md5)
//{ {
//#define F1(x, y, z) (z ^ (x & (y ^ z))) #define F1(x, y, z) (z ^ (x & (y ^ z)))
//#define F2(x, y, z) F1(z, x, y) #define F2(x, y, z) F1(z, x, y)
//#define F3(x, y, z) (x ^ y ^ z) #define F3(x, y, z) (x ^ y ^ z)
//#define F4(x, y, z) (y ^ (x | ~z)) #define F4(x, y, z) (y ^ (x | ~z))
//
//#define MD5STEP(f, w, x, y, z, data, s) \ #define MD5STEP(f, w, x, y, z, data, s) \
// w = rotlFixed(w + f(x, y, z) + data, s) + x w = rotlFixed(w + f(x, y, z) + data, s) + x
//
// /* Copy context->state[] to working vars */ /* Copy context->state[] to working vars */
// word32 a = md5->digest[0]; word32 a = md5->digest[0];
// word32 b = md5->digest[1]; word32 b = md5->digest[1];
// word32 c = md5->digest[2]; word32 c = md5->digest[2];
// word32 d = md5->digest[3]; word32 d = md5->digest[3];
//
// MD5STEP(F1, a, b, c, d, md5->buffer[0] + 0xd76aa478, 7); MD5STEP(F1, a, b, c, d, md5->buffer[0] + 0xd76aa478, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[1] + 0xe8c7b756, 12); MD5STEP(F1, d, a, b, c, md5->buffer[1] + 0xe8c7b756, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[2] + 0x242070db, 17); MD5STEP(F1, c, d, a, b, md5->buffer[2] + 0x242070db, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[3] + 0xc1bdceee, 22); MD5STEP(F1, b, c, d, a, md5->buffer[3] + 0xc1bdceee, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[4] + 0xf57c0faf, 7); MD5STEP(F1, a, b, c, d, md5->buffer[4] + 0xf57c0faf, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[5] + 0x4787c62a, 12); MD5STEP(F1, d, a, b, c, md5->buffer[5] + 0x4787c62a, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[6] + 0xa8304613, 17); MD5STEP(F1, c, d, a, b, md5->buffer[6] + 0xa8304613, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[7] + 0xfd469501, 22); MD5STEP(F1, b, c, d, a, md5->buffer[7] + 0xfd469501, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[8] + 0x698098d8, 7); MD5STEP(F1, a, b, c, d, md5->buffer[8] + 0x698098d8, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[9] + 0x8b44f7af, 12); MD5STEP(F1, d, a, b, c, md5->buffer[9] + 0x8b44f7af, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[10] + 0xffff5bb1, 17); MD5STEP(F1, c, d, a, b, md5->buffer[10] + 0xffff5bb1, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[11] + 0x895cd7be, 22); MD5STEP(F1, b, c, d, a, md5->buffer[11] + 0x895cd7be, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[12] + 0x6b901122, 7); MD5STEP(F1, a, b, c, d, md5->buffer[12] + 0x6b901122, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[13] + 0xfd987193, 12); MD5STEP(F1, d, a, b, c, md5->buffer[13] + 0xfd987193, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[14] + 0xa679438e, 17); MD5STEP(F1, c, d, a, b, md5->buffer[14] + 0xa679438e, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[15] + 0x49b40821, 22); MD5STEP(F1, b, c, d, a, md5->buffer[15] + 0x49b40821, 22);
//
// MD5STEP(F2, a, b, c, d, md5->buffer[1] + 0xf61e2562, 5); MD5STEP(F2, a, b, c, d, md5->buffer[1] + 0xf61e2562, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[6] + 0xc040b340, 9); MD5STEP(F2, d, a, b, c, md5->buffer[6] + 0xc040b340, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[11] + 0x265e5a51, 14); MD5STEP(F2, c, d, a, b, md5->buffer[11] + 0x265e5a51, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[0] + 0xe9b6c7aa, 20); MD5STEP(F2, b, c, d, a, md5->buffer[0] + 0xe9b6c7aa, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[5] + 0xd62f105d, 5); MD5STEP(F2, a, b, c, d, md5->buffer[5] + 0xd62f105d, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[10] + 0x02441453, 9); MD5STEP(F2, d, a, b, c, md5->buffer[10] + 0x02441453, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[15] + 0xd8a1e681, 14); MD5STEP(F2, c, d, a, b, md5->buffer[15] + 0xd8a1e681, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[4] + 0xe7d3fbc8, 20); MD5STEP(F2, b, c, d, a, md5->buffer[4] + 0xe7d3fbc8, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[9] + 0x21e1cde6, 5); MD5STEP(F2, a, b, c, d, md5->buffer[9] + 0x21e1cde6, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[14] + 0xc33707d6, 9); MD5STEP(F2, d, a, b, c, md5->buffer[14] + 0xc33707d6, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[3] + 0xf4d50d87, 14); MD5STEP(F2, c, d, a, b, md5->buffer[3] + 0xf4d50d87, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[8] + 0x455a14ed, 20); MD5STEP(F2, b, c, d, a, md5->buffer[8] + 0x455a14ed, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[13] + 0xa9e3e905, 5); MD5STEP(F2, a, b, c, d, md5->buffer[13] + 0xa9e3e905, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[2] + 0xfcefa3f8, 9); MD5STEP(F2, d, a, b, c, md5->buffer[2] + 0xfcefa3f8, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[7] + 0x676f02d9, 14); MD5STEP(F2, c, d, a, b, md5->buffer[7] + 0x676f02d9, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[12] + 0x8d2a4c8a, 20); MD5STEP(F2, b, c, d, a, md5->buffer[12] + 0x8d2a4c8a, 20);
//
// MD5STEP(F3, a, b, c, d, md5->buffer[5] + 0xfffa3942, 4); MD5STEP(F3, a, b, c, d, md5->buffer[5] + 0xfffa3942, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[8] + 0x8771f681, 11); MD5STEP(F3, d, a, b, c, md5->buffer[8] + 0x8771f681, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[11] + 0x6d9d6122, 16); MD5STEP(F3, c, d, a, b, md5->buffer[11] + 0x6d9d6122, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[14] + 0xfde5380c, 23); MD5STEP(F3, b, c, d, a, md5->buffer[14] + 0xfde5380c, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[1] + 0xa4beea44, 4); MD5STEP(F3, a, b, c, d, md5->buffer[1] + 0xa4beea44, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[4] + 0x4bdecfa9, 11); MD5STEP(F3, d, a, b, c, md5->buffer[4] + 0x4bdecfa9, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[7] + 0xf6bb4b60, 16); MD5STEP(F3, c, d, a, b, md5->buffer[7] + 0xf6bb4b60, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[10] + 0xbebfbc70, 23); MD5STEP(F3, b, c, d, a, md5->buffer[10] + 0xbebfbc70, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[13] + 0x289b7ec6, 4); MD5STEP(F3, a, b, c, d, md5->buffer[13] + 0x289b7ec6, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[0] + 0xeaa127fa, 11); MD5STEP(F3, d, a, b, c, md5->buffer[0] + 0xeaa127fa, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[3] + 0xd4ef3085, 16); MD5STEP(F3, c, d, a, b, md5->buffer[3] + 0xd4ef3085, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[6] + 0x04881d05, 23); MD5STEP(F3, b, c, d, a, md5->buffer[6] + 0x04881d05, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[9] + 0xd9d4d039, 4); MD5STEP(F3, a, b, c, d, md5->buffer[9] + 0xd9d4d039, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[12] + 0xe6db99e5, 11); MD5STEP(F3, d, a, b, c, md5->buffer[12] + 0xe6db99e5, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[15] + 0x1fa27cf8, 16); MD5STEP(F3, c, d, a, b, md5->buffer[15] + 0x1fa27cf8, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[2] + 0xc4ac5665, 23); MD5STEP(F3, b, c, d, a, md5->buffer[2] + 0xc4ac5665, 23);
//
// MD5STEP(F4, a, b, c, d, md5->buffer[0] + 0xf4292244, 6); MD5STEP(F4, a, b, c, d, md5->buffer[0] + 0xf4292244, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[7] + 0x432aff97, 10); MD5STEP(F4, d, a, b, c, md5->buffer[7] + 0x432aff97, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[14] + 0xab9423a7, 15); MD5STEP(F4, c, d, a, b, md5->buffer[14] + 0xab9423a7, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[5] + 0xfc93a039, 21); MD5STEP(F4, b, c, d, a, md5->buffer[5] + 0xfc93a039, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[12] + 0x655b59c3, 6); MD5STEP(F4, a, b, c, d, md5->buffer[12] + 0x655b59c3, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[3] + 0x8f0ccc92, 10); MD5STEP(F4, d, a, b, c, md5->buffer[3] + 0x8f0ccc92, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[10] + 0xffeff47d, 15); MD5STEP(F4, c, d, a, b, md5->buffer[10] + 0xffeff47d, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[1] + 0x85845dd1, 21); MD5STEP(F4, b, c, d, a, md5->buffer[1] + 0x85845dd1, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[8] + 0x6fa87e4f, 6); MD5STEP(F4, a, b, c, d, md5->buffer[8] + 0x6fa87e4f, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[15] + 0xfe2ce6e0, 10); MD5STEP(F4, d, a, b, c, md5->buffer[15] + 0xfe2ce6e0, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[6] + 0xa3014314, 15); MD5STEP(F4, c, d, a, b, md5->buffer[6] + 0xa3014314, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[13] + 0x4e0811a1, 21); MD5STEP(F4, b, c, d, a, md5->buffer[13] + 0x4e0811a1, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[4] + 0xf7537e82, 6); MD5STEP(F4, a, b, c, d, md5->buffer[4] + 0xf7537e82, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[11] + 0xbd3af235, 10); MD5STEP(F4, d, a, b, c, md5->buffer[11] + 0xbd3af235, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[2] + 0x2ad7d2bb, 15); MD5STEP(F4, c, d, a, b, md5->buffer[2] + 0x2ad7d2bb, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[9] + 0xeb86d391, 21); MD5STEP(F4, b, c, d, a, md5->buffer[9] + 0xeb86d391, 21);
//
// /* Add the working vars back into digest state[] */ /* Add the working vars back into digest state[] */
// md5->digest[0] += a; md5->digest[0] += a;
// md5->digest[1] += b; md5->digest[1] += b;
// md5->digest[2] += c; md5->digest[2] += c;
// md5->digest[3] += d; md5->digest[3] += d;
//} }
//
//#endif /* FREESCALE_MMCAU */ #endif /* FREESCALE_MMCAU */
//
//
//static INLINE void AddLength(Md5* md5, word32 len) static INLINE void AddLength(Md5* md5, word32 len)
//{ {
// word32 tmp = md5->loLen; word32 tmp = md5->loLen;
// if ( (md5->loLen += len) < tmp) if ( (md5->loLen += len) < tmp)
// md5->hiLen++; /* carry low to high */ md5->hiLen++; /* carry low to high */
//} }
//
//
//void Md5Update(Md5* md5, const byte* data, word32 len) void Md5Update(Md5* md5, const byte* data, word32 len)
//{ {
// /* do block size increments */ /* do block size increments */
// byte* local = (byte*)md5->buffer; byte* local = (byte*)md5->buffer;
//
// while (len) { while (len) {
// word32 add = min(len, MD5_BLOCK_SIZE - md5->buffLen); word32 add = min(len, MD5_BLOCK_SIZE - md5->buffLen);
// XMEMCPY(&local[md5->buffLen], data, add); XMEMCPY(&local[md5->buffLen], data, add);
//
// md5->buffLen += add; md5->buffLen += add;
// data += add; data += add;
// len -= add; len -= add;
//
// if (md5->buffLen == MD5_BLOCK_SIZE) { if (md5->buffLen == MD5_BLOCK_SIZE) {
// #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU)
// ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE); ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
// #endif #endif
// XTRANSFORM(md5, local); XTRANSFORM(md5, local);
// AddLength(md5, MD5_BLOCK_SIZE); AddLength(md5, MD5_BLOCK_SIZE);
// md5->buffLen = 0; md5->buffLen = 0;
// } }
// } }
//} }
//
//
//void Md5Final(Md5* md5, byte* hash) void Md5Final(Md5* md5, byte* hash)
//{ {
// byte* local = (byte*)md5->buffer; byte* local = (byte*)md5->buffer;
//
// AddLength(md5, md5->buffLen); /* before adding pads */ AddLength(md5, md5->buffLen); /* before adding pads */
//
// local[md5->buffLen++] = 0x80; /* add 1 */ local[md5->buffLen++] = 0x80; /* add 1 */
//
// /* pad with zeros */ /* pad with zeros */
// if (md5->buffLen > MD5_PAD_SIZE) { if (md5->buffLen > MD5_PAD_SIZE) {
// XMEMSET(&local[md5->buffLen], 0, MD5_BLOCK_SIZE - md5->buffLen); XMEMSET(&local[md5->buffLen], 0, MD5_BLOCK_SIZE - md5->buffLen);
// md5->buffLen += MD5_BLOCK_SIZE - md5->buffLen; md5->buffLen += MD5_BLOCK_SIZE - md5->buffLen;
//
// #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU)
// ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE); ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
// #endif #endif
// XTRANSFORM(md5, local); XTRANSFORM(md5, local);
// md5->buffLen = 0; md5->buffLen = 0;
// } }
// XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen); XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen);
//
// /* put lengths in bits */ /* put lengths in bits */
// md5->hiLen = (md5->loLen >> (8*sizeof(md5->loLen) - 3)) + md5->hiLen = (md5->loLen >> (8*sizeof(md5->loLen) - 3)) +
// (md5->hiLen << 3); (md5->hiLen << 3);
// md5->loLen = md5->loLen << 3; md5->loLen = md5->loLen << 3;
//
// /* store lengths */ /* store lengths */
// #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU)
// ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE); ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
// #endif #endif
// /* ! length ordering dependent on digest endian type ! */ /* ! length ordering dependent on digest endian type ! */
// XMEMCPY(&local[MD5_PAD_SIZE], &md5->loLen, sizeof(word32)); XMEMCPY(&local[MD5_PAD_SIZE], &md5->loLen, sizeof(word32));
// XMEMCPY(&local[MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32)); XMEMCPY(&local[MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32));
//
// XTRANSFORM(md5, local); XTRANSFORM(md5, local);
// #ifdef BIG_ENDIAN_ORDER #ifdef BIG_ENDIAN_ORDER
// ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE); ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE);
// #endif #endif
// XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE);
//
// InitMd5(md5); /* reset state */ InitMd5(md5); /* reset state */
//} }
//
//#endif /* STM32F2_HASH */ #endif /* STM32F2_HASH */
//
//
//int Md5Hash(const byte* data, word32 len, byte* hash) int Md5Hash(const byte* data, word32 len, byte* hash)
//{ {
//#ifdef CYASSL_SMALL_STACK #ifdef CYASSL_SMALL_STACK
// Md5* md5; Md5* md5;
//#else #else
// Md5 md5[1]; Md5 md5[1];
//#endif #endif
//
//#ifdef CYASSL_SMALL_STACK #ifdef CYASSL_SMALL_STACK
// md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER); md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
// if (md5 == NULL) if (md5 == NULL)
// return MEMORY_E; return MEMORY_E;
//#endif #endif
//
// InitMd5(md5); InitMd5(md5);
// Md5Update(md5, data, len); Md5Update(md5, data, len);
// Md5Final(md5, hash); Md5Final(md5, hash);
//
//#ifdef CYASSL_SMALL_STACK #ifdef CYASSL_SMALL_STACK
// XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
//#endif #endif
//
// return 0; return 0;
//} }
//
//#endif /* NO_MD5 */ #endif /* NO_MD5 */

2
cyassl/ctaocrypt/blake2.h
View File

@@ -28,7 +28,7 @@
#include <wolfssl/wolfcrypt/blake2.h> #include <wolfssl/wolfcrypt/blake2.h>
/* for blake2 reverse compatibility */ /* for blake2 reverse compatibility */
#ifdef HAVE_BLAKE2 #ifndef HAVE_FIPS
#define InitBlake2b wc_InitBlake2b #define InitBlake2b wc_InitBlake2b
#define Blake2bUpdate wc_Blake2bUpdate #define Blake2bUpdate wc_Blake2bUpdate
#define Blake2bFinal wc_Blake2bFinal #define Blake2bFinal wc_Blake2bFinal

1
cyassl/ctaocrypt/md2.h
View File

@@ -39,3 +39,4 @@
#endif /* CTAO_CRYPT_MD2_H */ #endif /* CTAO_CRYPT_MD2_H */
#endif /* CYASSL_MD2 */ #endif /* CYASSL_MD2 */

46
cyassl/ctaocrypt/md5.h
View File

@@ -40,50 +40,6 @@
#define wc_Md5Hash Md5Hash #define wc_Md5Hash Md5Hash
#endif #endif
/* commented out until clarification on 2nd removed fips calls discussed */
//#ifdef __cplusplus
// extern "C" {
//#endif
//
//
///* in bytes */
//enum {
//#ifdef STM32F2_HASH
// MD5_REG_SIZE = 4, /* STM32 register size, bytes */
//#endif
// MD5 = 0, /* hash type unique */
// MD5_BLOCK_SIZE = 64,
// MD5_DIGEST_SIZE = 16,
// MD5_PAD_SIZE = 56
//};
//
//#ifdef CYASSL_PIC32MZ_HASH
//#include "port/pic32/pic32mz-crypt.h"
//#endif
//
///* MD5 digest */
//typedef struct Md5 {
// word32 buffLen; /* in bytes */
// word32 loLen; /* length in bytes */
// word32 hiLen; /* length in bytes */
// word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)];
// #ifndef CYASSL_PIC32MZ_HASH
// word32 digest[MD5_DIGEST_SIZE / sizeof(word32)];
// #else
// word32 digest[PIC32_HASH_SIZE / sizeof(word32)];
// pic32mz_desc desc ; /* Crypt Engine descripter */
// #endif
//} Md5;
//
//CYASSL_API void InitMd5(Md5*);
//CYASSL_API void Md5Update(Md5*, const byte*, word32);
//CYASSL_API void Md5Final(Md5*, byte*);
//CYASSL_API int Md5Hash(const byte*, word32, byte*);
//
//
//#ifdef __cplusplus
// } /* extern "C" */
//#endif
#endif /* CTAO_CRYPT_MD5_H */ #endif /* CTAO_CRYPT_MD5_H */
#endif /* NO_MD5 */ #endif /* NO_MD5 */

7
src/include.am
View File

@@ -134,9 +134,12 @@ endif
endif endif
if BUILD_MD5 if BUILD_MD5
if BUILD_FIPS
src_libwolfssl_la_SOURCES += ctaocrypt/src/md5.c src_libwolfssl_la_SOURCES += ctaocrypt/src/md5.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/md5.c src_libwolfssl_la_SOURCES += wolfcrypt/src/md5.c
endif endif
endif
if BUILD_PWDBASED if BUILD_PWDBASED
if BUILD_FIPS if BUILD_FIPS
@@ -171,8 +174,12 @@ src_libwolfssl_la_SOURCES += wolfcrypt/src/ripemd.c
endif endif
if BUILD_BLAKE2 if BUILD_BLAKE2
if BUILD_FIPS
src_libwolfssl_la_SOURCES += ctaocrypt/src/blake2b.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/blake2b.c src_libwolfssl_la_SOURCES += wolfcrypt/src/blake2b.c
endif endif
endif
if BUILD_HC128 if BUILD_HC128
# temporarily removed needs revisited # temporarily removed needs revisited

8
wolfssl/wolfcrypt/blake2.h
View File

@@ -27,6 +27,14 @@
#include <wolfssl/wolfcrypt/blake2-int.h> #include <wolfssl/wolfcrypt/blake2-int.h>
/* call old functions if using fips for the sake of hmac @wc_fips */
#ifdef HAVE_FIPS
/* Since hmac can call blake functions provide original calls */
#define wc_InitBlake2b InitBlake2b
#define wc_Blake2bUpdate Blake2bUpdate
#define wc_Blake2bFinal Blake2bFinal
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif