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

Improvements to SHA-1, SHA-256 and MD5 performance:

Browse Source 
* Added detection for buffer alignment to avoid memcpy.
* Added MD5 and SHA-1 support for XTRANSFORM_LEN to process blocks.
* Cleanups for consistency between algorithms and code commenting.
* Enhancement for NXP MMCAU to process more than one block at a time.
* Improved MMCAU performance: SHA-1 by 35%, SHA-256 by 20% and MD5 by 78%.

```
NXP K64 w/MMCAU after:

MD5                  8 MB took 1.000 seconds,    7.910 MB/s
SHA                  4 MB took 1.005 seconds,    3.644 MB/s
SHA-256              2 MB took 1.006 seconds,    2.306 MB/s

NXP K64 w/MMCAU before:
MD5                  4 MB took 1.004 seconds,    4.450 MB/s
SHA                  3 MB took 1.006 seconds,    2.670 MB/s
SHA-256              2 MB took 1.008 seconds,    1.913 MB/s
```
This commit is contained in:
David Garske
2019-09-25 12:47:12 -07:00
parent 4a6925e2ef
commit 4c709f1f2c
8 changed files with 605 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
IDE/ROWLEY-CROSSWORKS-ARM/kinetis_hw.c
View File

@ -89,7 +89,6 @@
/* Note: You will also need to update the UART clock gate in hw_uart_init (SIM_SCGC1_UART5_MASK) */ /* Note: You will also need to update the UART clock gate in hw_uart_init (SIM_SCGC1_UART5_MASK) */
/* Note: TWR-K60 is UART3, PTC17 */ /* Note: TWR-K60 is UART3, PTC17 */
/* Note: FRDM-K64 is UART4, PTE24 */
/* Note: FRDM-K64 is UART4, PTE24 or UART0 PTB17 for OpenOCD (SIM_SCGC4_UART0_MASK)*/ /* Note: FRDM-K64 is UART4, PTE24 or UART0 PTB17 for OpenOCD (SIM_SCGC4_UART0_MASK)*/
/* Note: TWR-K64 is UART5, PTE8 */ /* Note: TWR-K64 is UART5, PTE8 */
/* Note: FRDM-K82F is LPUART0 A2, LPUART4 PTC15 */ /* Note: FRDM-K82F is LPUART0 A2, LPUART4 PTC15 */

2
IDE/ROWLEY-CROSSWORKS-ARM/test_main.c
View File

@ -65,7 +65,7 @@ void main(void)
test_num++; test_num++;
} while(args.return_code == 0); } while(args.return_code == 0);
/*Print this again for redundancy*/ /* Print this again for redundancy */
#ifdef WOLFSSL_FRDM_K64_JENKINS #ifdef WOLFSSL_FRDM_K64_JENKINS
printf("\n&&&&&&&&&&&&&& done &&&&&&&&&&&&&\n"); printf("\n&&&&&&&&&&&&&& done &&&&&&&&&&&&&\n");
delay_us(1000000); delay_us(1000000);

1
IDE/ROWLEY-CROSSWORKS-ARM/user_settings.h
View File

@ -208,6 +208,7 @@ extern "C" {
/* MD5 */ /* MD5 */
#undef NO_MD5 #undef NO_MD5
#if 1 #if 1
#else
#define NO_MD5 #define NO_MD5
#endif #endif

438
wolfcrypt/src/md5.c
View File

@ -22,7 +22,7 @@
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
#endif #endif
#include <wolfssl/wolfcrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
@ -30,7 +30,7 @@
#if !defined(NO_MD5) #if !defined(NO_MD5)
#if defined(WOLFSSL_TI_HASH) #if defined(WOLFSSL_TI_HASH)
/* #include <wolfcrypt/src/port/ti/ti-hash.c> included by wc_port.c */ /* #include <wolfcrypt/src/port/ti/ti-hash.c> included by wc_port.c */
#else #else
@ -40,197 +40,225 @@
#include <wolfssl/wolfcrypt/hash.h> #include <wolfssl/wolfcrypt/hash.h>
#ifdef NO_INLINE #ifdef NO_INLINE
#include <wolfssl/wolfcrypt/misc.h> #include <wolfssl/wolfcrypt/misc.h>
#else #else
#define WOLFSSL_MISC_INCLUDED #define WOLFSSL_MISC_INCLUDED
#include <wolfcrypt/src/misc.c> #include <wolfcrypt/src/misc.c>
#endif #endif
/* Hardware Acceleration */ /* Hardware Acceleration */
#if defined(STM32_HASH) #if defined(STM32_HASH)
/* Supports CubeMX HAL or Standard Peripheral Library */ /* Supports CubeMX HAL or Standard Peripheral Library */
#define HAVE_MD5_CUST_API #define HAVE_MD5_CUST_API
int wc_InitMd5_ex(wc_Md5* md5, void* heap, int devId) int wc_InitMd5_ex(wc_Md5* md5, void* heap, int devId)
{ {
if (md5 == NULL) { if (md5 == NULL) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
}
(void)devId;
(void)heap;
wc_Stm32_Hash_Init(&md5->stmCtx);
return 0;
} }
int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len) (void)devId;
{ (void)heap;
int ret;
if (md5 == NULL || (data == NULL && len > 0)) { wc_Stm32_Hash_Init(&md5->stmCtx);
return BAD_FUNC_ARG;
}
ret = wolfSSL_CryptHwMutexLock(); return 0;
if (ret == 0) { }
ret = wc_Stm32_Hash_Update(&md5->stmCtx, HASH_AlgoSelection_MD5,
data, len); int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len)
wolfSSL_CryptHwMutexUnLock(); {
} int ret;
return ret;
if (md5 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
} }
int wc_Md5Final(wc_Md5* md5, byte* hash) ret = wolfSSL_CryptHwMutexLock();
{ if (ret == 0) {
int ret; ret = wc_Stm32_Hash_Update(&md5->stmCtx, HASH_AlgoSelection_MD5,
data, len);
if (md5 == NULL || hash == NULL) { wolfSSL_CryptHwMutexUnLock();
return BAD_FUNC_ARG;
}
ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
ret = wc_Stm32_Hash_Final(&md5->stmCtx, HASH_AlgoSelection_MD5,
hash, WC_MD5_DIGEST_SIZE);
wolfSSL_CryptHwMutexUnLock();
}
(void)wc_InitMd5(md5); /* reset state */
return ret;
} }
return ret;
}
int wc_Md5Final(wc_Md5* md5, byte* hash)
{
int ret;
if (md5 == NULL || hash == NULL) {
return BAD_FUNC_ARG;
}
ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
ret = wc_Stm32_Hash_Final(&md5->stmCtx, HASH_AlgoSelection_MD5,
hash, WC_MD5_DIGEST_SIZE);
wolfSSL_CryptHwMutexUnLock();
}
(void)wc_InitMd5(md5); /* reset state */
return ret;
}
#elif defined(FREESCALE_MMCAU_SHA) #elif defined(FREESCALE_MMCAU_SHA)
#include "cau_api.h"
#define XTRANSFORM(S,B) Transform((S), (B))
static int Transform(wc_Md5* md5, byte* data) #ifdef FREESCALE_MMCAU_CLASSIC_SHA
{ #include "cau_api.h"
int ret = wolfSSL_CryptHwMutexLock(); #else
if(ret == 0) { #include "fsl_mmcau.h"
#ifdef FREESCALE_MMCAU_CLASSIC_SHA #endif
cau_md5_hash_n(data, 1, (unsigned char*)md5->digest);
#else #define XTRANSFORM(S,B) Transform((S), (B))
MMCAU_MD5_HashN(data, 1, (uint32_t*)md5->digest); #define XTRANSFORM_LEN(S,B,L) Transform_Len((S), (B), (L))
#endif
wolfSSL_CryptHwMutexUnLock(); static int Transform(wc_Md5* md5, const byte* data)
} {
return ret; int ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_md5_hash_n((byte*)data, 1, (unsigned char*)md5->digest);
#else
MMCAU_MD5_HashN((byte*)data, 1, (uint32_t*)md5->digest);
#endif
wolfSSL_CryptHwMutexUnLock();
} }
return ret;
}
static int Transform_Len(wc_Md5* md5, const byte* data, word32 len)
{
int ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_md5_hash_n((byte*)data, len / WC_MD5_BLOCK_SIZE,
(unsigned char*)md5->digest);
#else
MMCAU_MD5_HashN((byte*)data, len / WC_MD5_BLOCK_SIZE,
(uint32_t*)md5->digest);
#endif
wolfSSL_CryptHwMutexUnLock();
}
return ret;
}
#elif defined(WOLFSSL_PIC32MZ_HASH) #elif defined(WOLFSSL_PIC32MZ_HASH)
#include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h> #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
#define HAVE_MD5_CUST_API #define HAVE_MD5_CUST_API
#elif defined(WOLFSSL_IMX6_CAAM) && !defined(NO_IMX6_CAAM_HASH) #elif defined(WOLFSSL_IMX6_CAAM) && !defined(NO_IMX6_CAAM_HASH)
/* functions implemented in wolfcrypt/src/port/caam/caam_sha.c */ /* functions implemented in wolfcrypt/src/port/caam/caam_sha.c */
#define HAVE_MD5_CUST_API #define HAVE_MD5_CUST_API
#else #else
#define NEED_SOFT_MD5 #define NEED_SOFT_MD5
#endif /* End Hardware Acceleration */ #endif /* End Hardware Acceleration */
#ifndef WC_MD5_DATA_ALIGNMENT
/* default to 32-bit alignement */
#define WC_MD5_DATA_ALIGNMENT 4
#endif
#ifdef NEED_SOFT_MD5 #ifdef NEED_SOFT_MD5
#define XTRANSFORM(S,B) Transform((S)) #define XTRANSFORM(S,B) Transform((S),(B))
#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
static int Transform(wc_Md5* md5) static int Transform(wc_Md5* md5, const byte* data)
{ {
/* Copy context->state[] to working vars */ word32* buffer = (word32*)data;
word32 a = md5->digest[0]; /* Copy context->state[] to working vars */
word32 b = md5->digest[1]; word32 a = md5->digest[0];
word32 c = md5->digest[2]; word32 b = md5->digest[1];
word32 d = md5->digest[3]; word32 c = md5->digest[2];
word32 d = md5->digest[3];
MD5STEP(F1, a, b, c, d, md5->buffer[0] + 0xd76aa478, 7); MD5STEP(F1, a, b, c, d, buffer[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[1] + 0xe8c7b756, 12); MD5STEP(F1, d, a, b, c, buffer[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[2] + 0x242070db, 17); MD5STEP(F1, c, d, a, b, buffer[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[3] + 0xc1bdceee, 22); MD5STEP(F1, b, c, d, a, buffer[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[4] + 0xf57c0faf, 7); MD5STEP(F1, a, b, c, d, buffer[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[5] + 0x4787c62a, 12); MD5STEP(F1, d, a, b, c, buffer[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[6] + 0xa8304613, 17); MD5STEP(F1, c, d, a, b, buffer[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[7] + 0xfd469501, 22); MD5STEP(F1, b, c, d, a, buffer[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[8] + 0x698098d8, 7); MD5STEP(F1, a, b, c, d, buffer[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[9] + 0x8b44f7af, 12); MD5STEP(F1, d, a, b, c, buffer[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[10] + 0xffff5bb1, 17); MD5STEP(F1, c, d, a, b, buffer[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[11] + 0x895cd7be, 22); MD5STEP(F1, b, c, d, a, buffer[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[12] + 0x6b901122, 7); MD5STEP(F1, a, b, c, d, buffer[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[13] + 0xfd987193, 12); MD5STEP(F1, d, a, b, c, buffer[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[14] + 0xa679438e, 17); MD5STEP(F1, c, d, a, b, buffer[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[15] + 0x49b40821, 22); MD5STEP(F1, b, c, d, a, buffer[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, md5->buffer[1] + 0xf61e2562, 5); MD5STEP(F2, a, b, c, d, buffer[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[6] + 0xc040b340, 9); MD5STEP(F2, d, a, b, c, buffer[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[11] + 0x265e5a51, 14); MD5STEP(F2, c, d, a, b, buffer[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[0] + 0xe9b6c7aa, 20); MD5STEP(F2, b, c, d, a, buffer[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[5] + 0xd62f105d, 5); MD5STEP(F2, a, b, c, d, buffer[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[10] + 0x02441453, 9); MD5STEP(F2, d, a, b, c, buffer[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[15] + 0xd8a1e681, 14); MD5STEP(F2, c, d, a, b, buffer[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[4] + 0xe7d3fbc8, 20); MD5STEP(F2, b, c, d, a, buffer[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[9] + 0x21e1cde6, 5); MD5STEP(F2, a, b, c, d, buffer[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[14] + 0xc33707d6, 9); MD5STEP(F2, d, a, b, c, buffer[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[3] + 0xf4d50d87, 14); MD5STEP(F2, c, d, a, b, buffer[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[8] + 0x455a14ed, 20); MD5STEP(F2, b, c, d, a, buffer[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[13] + 0xa9e3e905, 5); MD5STEP(F2, a, b, c, d, buffer[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[2] + 0xfcefa3f8, 9); MD5STEP(F2, d, a, b, c, buffer[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[7] + 0x676f02d9, 14); MD5STEP(F2, c, d, a, b, buffer[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[12] + 0x8d2a4c8a, 20); MD5STEP(F2, b, c, d, a, buffer[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, md5->buffer[5] + 0xfffa3942, 4); MD5STEP(F3, a, b, c, d, buffer[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[8] + 0x8771f681, 11); MD5STEP(F3, d, a, b, c, buffer[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[11] + 0x6d9d6122, 16); MD5STEP(F3, c, d, a, b, buffer[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[14] + 0xfde5380c, 23); MD5STEP(F3, b, c, d, a, buffer[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[1] + 0xa4beea44, 4); MD5STEP(F3, a, b, c, d, buffer[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[4] + 0x4bdecfa9, 11); MD5STEP(F3, d, a, b, c, buffer[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[7] + 0xf6bb4b60, 16); MD5STEP(F3, c, d, a, b, buffer[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[10] + 0xbebfbc70, 23); MD5STEP(F3, b, c, d, a, buffer[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[13] + 0x289b7ec6, 4); MD5STEP(F3, a, b, c, d, buffer[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[0] + 0xeaa127fa, 11); MD5STEP(F3, d, a, b, c, buffer[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[3] + 0xd4ef3085, 16); MD5STEP(F3, c, d, a, b, buffer[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[6] + 0x04881d05, 23); MD5STEP(F3, b, c, d, a, buffer[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[9] + 0xd9d4d039, 4); MD5STEP(F3, a, b, c, d, buffer[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[12] + 0xe6db99e5, 11); MD5STEP(F3, d, a, b, c, buffer[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[15] + 0x1fa27cf8, 16); MD5STEP(F3, c, d, a, b, buffer[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[2] + 0xc4ac5665, 23); MD5STEP(F3, b, c, d, a, buffer[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, md5->buffer[0] + 0xf4292244, 6); MD5STEP(F4, a, b, c, d, buffer[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[7] + 0x432aff97, 10); MD5STEP(F4, d, a, b, c, buffer[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[14] + 0xab9423a7, 15); MD5STEP(F4, c, d, a, b, buffer[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[5] + 0xfc93a039, 21); MD5STEP(F4, b, c, d, a, buffer[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[12] + 0x655b59c3, 6); MD5STEP(F4, a, b, c, d, buffer[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[3] + 0x8f0ccc92, 10); MD5STEP(F4, d, a, b, c, buffer[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[10] + 0xffeff47d, 15); MD5STEP(F4, c, d, a, b, buffer[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[1] + 0x85845dd1, 21); MD5STEP(F4, b, c, d, a, buffer[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[8] + 0x6fa87e4f, 6); MD5STEP(F4, a, b, c, d, buffer[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[15] + 0xfe2ce6e0, 10); MD5STEP(F4, d, a, b, c, buffer[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[6] + 0xa3014314, 15); MD5STEP(F4, c, d, a, b, buffer[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[13] + 0x4e0811a1, 21); MD5STEP(F4, b, c, d, a, buffer[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[4] + 0xf7537e82, 6); MD5STEP(F4, a, b, c, d, buffer[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[11] + 0xbd3af235, 10); MD5STEP(F4, d, a, b, c, buffer[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[2] + 0x2ad7d2bb, 15); MD5STEP(F4, c, d, a, b, buffer[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[9] + 0xeb86d391, 21); MD5STEP(F4, b, c, d, a, 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;
return 0; return 0;
} }
#endif /* NEED_SOFT_MD5 */ #endif /* NEED_SOFT_MD5 */
#ifndef HAVE_MD5_CUST_API #ifndef HAVE_MD5_CUST_API
@ -277,17 +305,20 @@ int wc_InitMd5_ex(wc_Md5* md5, void* heap, int devId)
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5)
ret = wolfAsync_DevCtxInit(&md5->asyncDev, WOLFSSL_ASYNC_MARKER_MD5, ret = wolfAsync_DevCtxInit(&md5->asyncDev, WOLFSSL_ASYNC_MARKER_MD5,
md5->heap, devId); md5->heap, devId);
#else #else
(void)devId; (void)devId;
#endif #endif
return ret; return ret;
} }
/* do block size increments/updates */
int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len) int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len)
{ {
int ret = 0; int ret = 0;
byte* local; word32 blocksLen;
byte* local;
word32* local32;
if (md5 == NULL || (data == NULL && len > 0)) { if (md5 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
@ -295,36 +326,92 @@ int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len)
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5)
if (md5->asyncDev.marker == WOLFSSL_ASYNC_MARKER_MD5) { if (md5->asyncDev.marker == WOLFSSL_ASYNC_MARKER_MD5) {
#if defined(HAVE_INTEL_QA) #if defined(HAVE_INTEL_QA)
return IntelQaSymMd5(&md5->asyncDev, NULL, data, len); return IntelQaSymMd5(&md5->asyncDev, NULL, data, len);
#endif #endif
} }
#endif /* WOLFSSL_ASYNC_CRYPT */ #endif /* WOLFSSL_ASYNC_CRYPT */
/* do block size increments */
local = (byte*)md5->buffer;
/* check that internal buffLen is valid */ /* check that internal buffLen is valid */
if (md5->buffLen >= WC_MD5_BLOCK_SIZE) if (md5->buffLen >= WC_MD5_BLOCK_SIZE)
return BUFFER_E; return BUFFER_E;
while (len) { if (data == NULL && len == 0) {
word32 add = min(len, WC_MD5_BLOCK_SIZE - md5->buffLen); /* valid, but do nothing */
XMEMCPY(&local[md5->buffLen], data, add); return 0;
}
md5->buffLen += add; /* add length for final */
data += add; AddLength(md5, len);
len -= add;
local = (byte*)md5->buffer;
local32 = md5->buffer;
/* process any remainder from previous operation */
if (md5->buffLen > 0) {
blocksLen = min(len, WC_MD5_BLOCK_SIZE - md5->buffLen);
XMEMCPY(&local[md5->buffLen], data, blocksLen);
md5->buffLen += blocksLen;
data += blocksLen;
len -= blocksLen;
if (md5->buffLen == WC_MD5_BLOCK_SIZE) { if (md5->buffLen == WC_MD5_BLOCK_SIZE) {
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE); ByteReverseWords(local32, local32, WC_MD5_BLOCK_SIZE);
#endif #endif
XTRANSFORM(md5, local);
AddLength(md5, WC_MD5_BLOCK_SIZE); ret = XTRANSFORM(md5, (const byte*)local);
if (ret != 0)
return ret;
md5->buffLen = 0; md5->buffLen = 0;
} }
} }
/* process blocks */
#ifdef XTRANSFORM_LEN
/* get number of blocks */
/* 64-1 = 0x3F (~ Inverted = 0xFFFFFFC0) */
/* len (masked by 0xFFFFFFC0) returns block aligned length */
blocksLen = len & ~(WC_MD5_BLOCK_SIZE-1);
if (blocksLen > 0) {
/* Byte reversal performed in function if required. */
XTRANSFORM_LEN(md5, data, blocksLen);
data += blocksLen;
len -= blocksLen;
}
#else
while (len >= WC_MD5_BLOCK_SIZE) {
/* optimization to avoid memcpy if data pointer is properly aligned */
/* Big Endian requires byte swap, so can't use data directly */
#if defined(WC_MD5_DATA_ALIGNMENT) && !defined(BIG_ENDIAN_ORDER)
if (((size_t)data % WC_MD5_DATA_ALIGNMENT) == 0) {
local32 = (word32*)data;
}
else
#endif
{
XMEMCPY(local32, data, WC_MD5_BLOCK_SIZE);
}
data += WC_MD5_BLOCK_SIZE;
len -= WC_MD5_BLOCK_SIZE;
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(local32, local32, WC_MD5_BLOCK_SIZE);
#endif
ret = XTRANSFORM(md5, (const byte*)local32);
}
#endif /* XTRANSFORM_LEN */
/* save remainder */
if (len > 0) {
XMEMCPY(local, data, len);
md5->buffLen = len;
}
return ret; return ret;
} }
@ -338,15 +425,14 @@ int wc_Md5Final(wc_Md5* md5, byte* hash)
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5) #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5)
if (md5->asyncDev.marker == WOLFSSL_ASYNC_MARKER_MD5) { if (md5->asyncDev.marker == WOLFSSL_ASYNC_MARKER_MD5) {
#if defined(HAVE_INTEL_QA) #if defined(HAVE_INTEL_QA)
return IntelQaSymMd5(&md5->asyncDev, hash, NULL, WC_MD5_DIGEST_SIZE); return IntelQaSymMd5(&md5->asyncDev, hash, NULL, WC_MD5_DIGEST_SIZE);
#endif #endif
} }
#endif /* WOLFSSL_ASYNC_CRYPT */ #endif /* WOLFSSL_ASYNC_CRYPT */
local = (byte*)md5->buffer; local = (byte*)md5->buffer;
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 */
@ -354,9 +440,9 @@ int wc_Md5Final(wc_Md5* md5, byte* hash)
XMEMSET(&local[md5->buffLen], 0, WC_MD5_BLOCK_SIZE - md5->buffLen); XMEMSET(&local[md5->buffLen], 0, WC_MD5_BLOCK_SIZE - md5->buffLen);
md5->buffLen += WC_MD5_BLOCK_SIZE - md5->buffLen; md5->buffLen += WC_MD5_BLOCK_SIZE - md5->buffLen;
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE); ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE);
#endif #endif
XTRANSFORM(md5, local); XTRANSFORM(md5, local);
md5->buffLen = 0; md5->buffLen = 0;
} }
@ -367,7 +453,7 @@ int wc_Md5Final(wc_Md5* md5, byte* hash)
#endif #endif
/* 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;
@ -441,7 +527,7 @@ int wc_Md5Copy(wc_Md5* src, wc_Md5* dst)
ret = wc_Pic32HashCopy(&src->cache, &dst->cache); ret = wc_Pic32HashCopy(&src->cache, &dst->cache);
#endif #endif
#if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB)
dst->flags |= WC_HASH_FLAG_ISCOPY; dst->flags |= WC_HASH_FLAG_ISCOPY;
#endif #endif
return ret; return ret;

10
wolfcrypt/src/port/Espressif/esp32_sha.c
View File

@ -279,7 +279,7 @@ static void esp_digest_state(WC_ESP32SHA* ctx, byte* hash, enum SHA_TYPE sha_typ
/* /*
* sha1 process * sha1 process
*/ */
int esp_sha_process(struct wc_Sha* sha) int esp_sha_process(struct wc_Sha* sha, const byte* data)
{ {
int ret = 0; int ret = 0;
@ -287,7 +287,7 @@ int esp_sha_process(struct wc_Sha* sha)
word32 SHA_START_REG = SHA_1_START_REG; word32 SHA_START_REG = SHA_1_START_REG;
esp_process_block(&sha->ctx, SHA_START_REG, sha->buffer, esp_process_block(&sha->ctx, SHA_START_REG, (const word32*)data,
WC_SHA_BLOCK_SIZE); WC_SHA_BLOCK_SIZE);
ESP_LOGV(TAG, "leave esp_sha_process"); ESP_LOGV(TAG, "leave esp_sha_process");
@ -322,7 +322,7 @@ int esp_sha_digest_process(struct wc_Sha* sha, byte blockproc)
/* /*
* sha256 process * sha256 process
*/ */
int esp_sha256_process(struct wc_Sha256* sha) int esp_sha256_process(struct wc_Sha256* sha, const byte* data)
{ {
int ret = 0; int ret = 0;
word32 SHA_START_REG = SHA_1_START_REG; word32 SHA_START_REG = SHA_1_START_REG;
@ -332,8 +332,8 @@ int esp_sha256_process(struct wc_Sha256* sha)
/* start register offset */ /* start register offset */
SHA_START_REG += (SHA2_256 << 4); SHA_START_REG += (SHA2_256 << 4);
esp_process_block(&sha->ctx, SHA_START_REG, sha->buffer, esp_process_block(&sha->ctx, SHA_START_REG, (const word32*)data,
WC_SHA256_BLOCK_SIZE); WC_SHA256_BLOCK_SIZE);
ESP_LOGV(TAG, "leave esp_sha256_process"); ESP_LOGV(TAG, "leave esp_sha256_process");

210
wolfcrypt/src/sha.c
View File

@ -205,7 +205,9 @@
#endif #endif
#define USE_SHA_SOFTWARE_IMPL /* Only for API's, actual transform is here */ #define USE_SHA_SOFTWARE_IMPL /* Only for API's, actual transform is here */
#define XTRANSFORM(S,B) Transform((S),(B))
#define XTRANSFORM(S,B) Transform((S),(B))
#define XTRANSFORM_LEN(S,B,L) Transform_Len((S),(B),(L))
static int InitSha(wc_Sha* sha) static int InitSha(wc_Sha* sha)
{ {
@ -228,14 +230,29 @@
return ret; return ret;
} }
static int Transform(wc_Sha* sha, byte* data) static int Transform(wc_Sha* sha, const byte* data)
{ {
int ret = wolfSSL_CryptHwMutexLock(); int ret = wolfSSL_CryptHwMutexLock();
if(ret == 0) { if(ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA #ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_sha1_hash_n(data, 1, sha->digest); cau_sha1_hash_n((byte*)data, 1, sha->digest);
#else #else
MMCAU_SHA1_HashN(data, 1, (uint32_t*)sha->digest); MMCAU_SHA1_HashN((byte*)data, 1, (uint32_t*)sha->digest);
#endif
wolfSSL_CryptHwMutexUnLock();
}
return ret;
}
static int Transform_Len(wc_Sha* sha, const byte* data, word32 len)
{
int ret = wolfSSL_CryptHwMutexLock();
if(ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_sha1_hash_n((byte*)data, len/WC_SHA_BLOCK_SIZE, sha->digest);
#else
MMCAU_SHA1_HashN((byte*)data, len/WC_SHA_BLOCK_SIZE,
(uint32_t*)sha->digest);
#endif #endif
wolfSSL_CryptHwMutexUnLock(); wolfSSL_CryptHwMutexUnLock();
} }
@ -280,12 +297,12 @@
return ret; return ret;
} }
#elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \ #elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \
!defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH) !defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH)
/* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */ /* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */
#else #else
/* Software implementation */ /* Software implementation */
#define USE_SHA_SOFTWARE_IMPL #define USE_SHA_SOFTWARE_IMPL
@ -312,6 +329,10 @@
#endif /* End Hardware Acceleration */ #endif /* End Hardware Acceleration */
#ifndef WC_SHA_DATA_ALIGNMENT
/* default to 32-bit alignement */
#define WC_SHA_DATA_ALIGNMENT 4
#endif
/* Software implementation */ /* Software implementation */
#ifdef USE_SHA_SOFTWARE_IMPL #ifdef USE_SHA_SOFTWARE_IMPL
@ -327,7 +348,7 @@ static WC_INLINE void AddLength(wc_Sha* sha, word32 len)
#ifndef XTRANSFORM #ifndef XTRANSFORM
#define XTRANSFORM(S,B) Transform((S),(B)) #define XTRANSFORM(S,B) Transform((S),(B))
#define blk0(i) (W[i] = sha->buffer[i]) #define blk0(i) (W[i] = *((word32*)&data[i*sizeof(word32)]))
#define blk1(i) (W[(i)&15] = \ #define blk1(i) (W[(i)&15] = \
rotlFixed(W[((i)+13)&15]^W[((i)+8)&15]^W[((i)+2)&15]^W[(i)&15],1)) rotlFixed(W[((i)+13)&15]^W[((i)+8)&15]^W[((i)+2)&15]^W[(i)&15],1))
@ -356,7 +377,7 @@ static WC_INLINE void AddLength(wc_Sha* sha, word32 len)
#define R4(v,w,x,y,z,i) (z)+= f4((w),(x),(y)) + blk1((i)) + 0xCA62C1D6+ \ #define R4(v,w,x,y,z,i) (z)+= f4((w),(x),(y)) + blk1((i)) + 0xCA62C1D6+ \
rotlFixed((v),5); (w) = rotlFixed((w),30); rotlFixed((v),5); (w) = rotlFixed((w),30);
static void Transform(wc_Sha* sha, byte* data) static int Transform(wc_Sha* sha, const byte* data)
{ {
word32 W[WC_SHA_BLOCK_SIZE / sizeof(word32)]; word32 W[WC_SHA_BLOCK_SIZE / sizeof(word32)];
@ -431,6 +452,8 @@ static WC_INLINE void AddLength(wc_Sha* sha, word32 len)
sha->digest[4] += e; sha->digest[4] += e;
(void)data; /* Not used */ (void)data; /* Not used */
return 0;
} }
#endif /* !USE_CUSTOM_SHA_TRANSFORM */ #endif /* !USE_CUSTOM_SHA_TRANSFORM */
@ -466,17 +489,18 @@ int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId)
return ret; return ret;
} }
/* do block size increments/updates */
int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len) int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
{ {
int ret = 0;
word32 blocksLen;
byte* local; byte* local;
word32* local32;
if (sha == NULL ||(data == NULL && len > 0)) { if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
} }
/* do block size increments */
local = (byte*)sha->buffer;
#ifdef WOLF_CRYPTO_CB #ifdef WOLF_CRYPTO_CB
if (sha->devId != INVALID_DEVID) { if (sha->devId != INVALID_DEVID) {
int ret = wc_CryptoCb_ShaHash(sha, data, len, NULL); int ret = wc_CryptoCb_ShaHash(sha, data, len, NULL);
@ -497,37 +521,107 @@ int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
if (sha->buffLen >= WC_SHA_BLOCK_SIZE) if (sha->buffLen >= WC_SHA_BLOCK_SIZE)
return BUFFER_E; return BUFFER_E;
while (len) { if (data == NULL && len == 0) {
word32 add = min(len, WC_SHA_BLOCK_SIZE - sha->buffLen); /* valid, but do nothing */
XMEMCPY(&local[sha->buffLen], data, add); return 0;
}
sha->buffLen += add; /* add length for final */
data += add; AddLength(sha, len);
len -= add;
local = (byte*)sha->buffer;
local32 = sha->buffer;
/* process any remainder from previous operation */
if (sha->buffLen > 0) {
blocksLen = min(len, WC_SHA_BLOCK_SIZE - sha->buffLen);
XMEMCPY(&local[sha->buffLen], data, blocksLen);
sha->buffLen += blocksLen;
data += blocksLen;
len -= blocksLen;
if (sha->buffLen == WC_SHA_BLOCK_SIZE) { if (sha->buffLen == WC_SHA_BLOCK_SIZE) {
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE); ByteReverseWords(local32, local32, WC_SHA_BLOCK_SIZE);
#endif #endif
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH) #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
XTRANSFORM(sha, local); !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
#else if (sha->ctx.mode == ESP32_SHA_INIT) {
if(sha->ctx.mode == ESP32_SHA_INIT){
esp_sha_try_hw_lock(&sha->ctx); esp_sha_try_hw_lock(&sha->ctx);
} }
if(sha->ctx.mode == ESP32_SHA_SW){ if (sha->ctx.mode == ESP32_SHA_SW {
XTRANSFORM(sha, local); ret = XTRANSFORM(sha, (const byte*)local);
} else { } else {
esp_sha_process(sha); esp_sha_process(sha, (const byte*)local);
} }
#endif #else
AddLength(sha, WC_SHA_BLOCK_SIZE); ret = XTRANSFORM(sha, (const byte*)local);
#endif
if (ret != 0)
return ret;
sha->buffLen = 0; sha->buffLen = 0;
} }
} }
return 0; /* process blocks */
#ifdef XTRANSFORM_LEN
/* get number of blocks */
/* 64-1 = 0x3F (~ Inverted = 0xFFFFFFC0) */
/* len (masked by 0xFFFFFFC0) returns block aligned length */
blocksLen = len & ~(WC_SHA_BLOCK_SIZE-1);
if (blocksLen > 0) {
/* Byte reversal performed in function if required. */
XTRANSFORM_LEN(sha, data, blocksLen);
data += blocksLen;
len -= blocksLen;
}
#else
while (len >= WC_SHA_BLOCK_SIZE) {
/* optimization to avoid memcpy if data pointer is properly aligned */
/* Little Endian requires byte swap, so can't use data directly */
#if defined(WC_SHA_DATA_ALIGNMENT) && !defined(LITTLE_ENDIAN_ORDER)
if (((size_t)data % WC_SHA_DATA_ALIGNMENT) == 0) {
local32 = (word32*)data;
}
else
#endif
{
XMEMCPY(local32, data, WC_SHA_BLOCK_SIZE);
}
data += WC_SHA_BLOCK_SIZE;
len -= WC_SHA_BLOCK_SIZE;
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(local32, local32, WC_SHA_BLOCK_SIZE);
#endif
#if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
!defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
if (sha->ctx.mode == ESP32_SHA_INIT){
esp_sha_try_hw_lock(&sha->ctx);
}
if (sha->ctx.mode == ESP32_SHA_SW){
ret = XTRANSFORM(sha, (const byte*)local32);
} else {
esp_sha_process(sha, (const byte*)local32);
}
#else
ret = XTRANSFORM(sha, (const byte*)local32);
#endif
}
#endif /* XTRANSFORM_LEN */
/* save remainder */
if (len > 0) {
XMEMCPY(local, data, len);
sha->buffLen = len;
}
return ret;
} }
int wc_ShaFinalRaw(wc_Sha* sha, byte* hash) int wc_ShaFinalRaw(wc_Sha* sha, byte* hash)
@ -552,6 +646,7 @@ int wc_ShaFinalRaw(wc_Sha* sha, byte* hash)
int wc_ShaFinal(wc_Sha* sha, byte* hash) int wc_ShaFinal(wc_Sha* sha, byte* hash)
{ {
int ret;
byte* local; byte* local;
if (sha == NULL || hash == NULL) { if (sha == NULL || hash == NULL) {
@ -576,8 +671,6 @@ int wc_ShaFinal(wc_Sha* sha, byte* hash)
} }
#endif /* WOLFSSL_ASYNC_CRYPT */ #endif /* WOLFSSL_ASYNC_CRYPT */
AddLength(sha, sha->buffLen); /* before adding pads */
local[sha->buffLen++] = 0x80; /* add 1 */ local[sha->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */ /* pad with zeros */
@ -585,22 +678,26 @@ int wc_ShaFinal(wc_Sha* sha, byte* hash)
XMEMSET(&local[sha->buffLen], 0, WC_SHA_BLOCK_SIZE - sha->buffLen); XMEMSET(&local[sha->buffLen], 0, WC_SHA_BLOCK_SIZE - sha->buffLen);
sha->buffLen += WC_SHA_BLOCK_SIZE - sha->buffLen; sha->buffLen += WC_SHA_BLOCK_SIZE - sha->buffLen;
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE); ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE);
#endif #endif
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH) #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
XTRANSFORM(sha, local); !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
#else if (sha->ctx.mode == ESP32_SHA_INIT) {
if(sha->ctx.mode == ESP32_SHA_INIT){
esp_sha_try_hw_lock(&sha->ctx); esp_sha_try_hw_lock(&sha->ctx);
} }
if(sha->ctx.mode == ESP32_SHA_SW){ if (sha->ctx.mode == ESP32_SHA_SW) {
XTRANSFORM(sha, local); ret = XTRANSFORM(sha, (const byte*)local);
} else { } else {
esp_sha_process(sha); esp_sha_process(sha, (const byte*)local);
} }
#endif #else
ret = XTRANSFORM(sha, (const byte*)local);
#endif
if (ret != 0)
return ret;
sha->buffLen = 0; sha->buffLen = 0;
} }
XMEMSET(&local[sha->buffLen], 0, WC_SHA_PAD_SIZE - sha->buffLen); XMEMSET(&local[sha->buffLen], 0, WC_SHA_PAD_SIZE - sha->buffLen);
@ -625,26 +722,29 @@ int wc_ShaFinal(wc_Sha* sha, byte* hash)
2 * sizeof(word32)); 2 * sizeof(word32));
#endif #endif
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \ #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH) !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
XTRANSFORM(sha, local); if (sha->ctx.mode == ESP32_SHA_INIT) {
#else
if(sha->ctx.mode == ESP32_SHA_INIT){
esp_sha_try_hw_lock(&sha->ctx); esp_sha_try_hw_lock(&sha->ctx);
} }
if(sha->ctx.mode == ESP32_SHA_SW){ if (sha->ctx.mode == ESP32_SHA_SW) {
XTRANSFORM(sha, local); ret = XTRANSFORM(sha, (const byte*)local);
} else { } else {
esp_sha_digest_process(sha, 1); esp_sha_digest_process(sha, 1);
} }
#else
ret = XTRANSFORM(sha, (const byte*)local);
#endif #endif
#ifdef LITTLE_ENDIAN_ORDER #ifdef LITTLE_ENDIAN_ORDER
ByteReverseWords(sha->digest, sha->digest, WC_SHA_DIGEST_SIZE); ByteReverseWords(sha->digest, sha->digest, WC_SHA_DIGEST_SIZE);
#endif #endif
XMEMCPY(hash, sha->digest, WC_SHA_DIGEST_SIZE); XMEMCPY(hash, sha->digest, WC_SHA_DIGEST_SIZE);
return InitSha(sha); /* reset state */ (void)InitSha(sha); /* reset state */
return ret;
} }
#endif /* USE_SHA_SOFTWARE_IMPL */ #endif /* USE_SHA_SOFTWARE_IMPL */
@ -707,7 +807,7 @@ int wc_ShaGetHash(wc_Sha* sha, byte* hash)
sha->ctx.mode = ESP32_SHA_SW; sha->ctx.mode = ESP32_SHA_SW;
#endif #endif
} }
return ret; return ret;
} }

319
wolfcrypt/src/sha256.c
View File

@ -165,7 +165,7 @@
!defined(WOLFSSL_AFALG_HASH) && !defined(WOLFSSL_DEVCRYPTO_HASH) && \ !defined(WOLFSSL_AFALG_HASH) && !defined(WOLFSSL_DEVCRYPTO_HASH) && \
(!defined(WOLFSSL_ESP32WROOM32_CRYPT) || defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)) && \ (!defined(WOLFSSL_ESP32WROOM32_CRYPT) || defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)) && \
(!defined(WOLFSSL_RENESAS_TSIP_CRYPT) || defined(NO_WOLFSSL_RENESAS_TSIP_HASH)) (!defined(WOLFSSL_RENESAS_TSIP_CRYPT) || defined(NO_WOLFSSL_RENESAS_TSIP_HASH))
static int InitSha256(wc_Sha256* sha256) static int InitSha256(wc_Sha256* sha256)
{ {
int ret = 0; int ret = 0;
@ -201,6 +201,9 @@ static int InitSha256(wc_Sha256* sha256)
/* in case intel instructions aren't available, plus we need the K[] global */ /* in case intel instructions aren't available, plus we need the K[] global */
#define NEED_SOFT_SHA256 #define NEED_SOFT_SHA256
/* requires 128-bit alignment */
#define WC_SHA256_DATA_ALIGNMENT 16
/***** /*****
Intel AVX1/AVX2 Macro Control Structure Intel AVX1/AVX2 Macro Control Structure
@ -258,43 +261,44 @@ static int InitSha256(wc_Sha256* sha256)
*/ */
/* #if defined(HAVE_INTEL_AVX1/2) at the tail of sha256 */ /* #if defined(HAVE_INTEL_AVX1/2) at the tail of sha256 */
static int Transform_Sha256(wc_Sha256* sha256); static int Transform_Sha256(wc_Sha256* sha256, const byte* data);
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if defined(HAVE_INTEL_AVX1) #if defined(HAVE_INTEL_AVX1)
extern int Transform_Sha256_AVX1(wc_Sha256 *sha256); extern int Transform_Sha256_AVX1(wc_Sha256 *sha256, const byte* data);
extern int Transform_Sha256_AVX1_Len(wc_Sha256* sha256, extern int Transform_Sha256_AVX1_Len(wc_Sha256* sha256,
const byte* data, word32 len); const byte* data, word32 len);
#endif #endif
#if defined(HAVE_INTEL_AVX2) #if defined(HAVE_INTEL_AVX2)
extern int Transform_Sha256_AVX2(wc_Sha256 *sha256); extern int Transform_Sha256_AVX2(wc_Sha256 *sha256, const byte* data);
extern int Transform_Sha256_AVX2_Len(wc_Sha256* sha256, extern int Transform_Sha256_AVX2_Len(wc_Sha256* sha256,
const byte* data, word32 len); const byte* data, word32 len);
#ifdef HAVE_INTEL_RORX #ifdef HAVE_INTEL_RORX
extern int Transform_Sha256_AVX1_RORX(wc_Sha256 *sha256); extern int Transform_Sha256_AVX1_RORX(wc_Sha256 *sha256, const byte* data);
extern int Transform_Sha256_AVX1_RORX_Len(wc_Sha256* sha256, extern int Transform_Sha256_AVX1_RORX_Len(wc_Sha256* sha256,
const byte* data, word32 len); const byte* data, word32 len);
extern int Transform_Sha256_AVX2_RORX(wc_Sha256 *sha256); extern int Transform_Sha256_AVX2_RORX(wc_Sha256 *sha256, const byte* data);
extern int Transform_Sha256_AVX2_RORX_Len(wc_Sha256* sha256, extern int Transform_Sha256_AVX2_RORX_Len(wc_Sha256* sha256,
const byte* data, word32 len); const byte* data, word32 len);
#endif #endif /* HAVE_INTEL_RORX */
#endif #endif /* HAVE_INTEL_AVX2 */
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
static int (*Transform_Sha256_p)(wc_Sha256* sha256); static int (*Transform_Sha256_p)(wc_Sha256* sha256, const byte* data);
/* = _Transform_Sha256 */ /* = _Transform_Sha256 */
static int (*Transform_Sha256_Len_p)(wc_Sha256* sha256, const byte* data, static int (*Transform_Sha256_Len_p)(wc_Sha256* sha256, const byte* data,
word32 len); word32 len);
/* = NULL */ /* = NULL */
static int transform_check = 0; static int transform_check = 0;
static word32 intel_flags; static word32 intel_flags;
#define XTRANSFORM(S) (*Transform_Sha256_p)((S))
#define XTRANSFORM(S, D) (*Transform_Sha256_p)((S),(D))
#define XTRANSFORM_LEN(S, D, L) (*Transform_Sha256_Len_p)((S),(D),(L)) #define XTRANSFORM_LEN(S, D, L) (*Transform_Sha256_Len_p)((S),(D),(L))
static void Sha256_SetTransform(void) static void Sha256_SetTransform(void)
@ -390,7 +394,7 @@ static int InitSha256(wc_Sha256* sha256)
#include "fsl_mmcau.h" #include "fsl_mmcau.h"
#endif #endif
#define XTRANSFORM(S) Transform_Sha256((S)) #define XTRANSFORM(S, D) Transform_Sha256((S),(D))
#define XTRANSFORM_LEN(S, D, L) Transform_Sha256_Len((S),(D),(L)) #define XTRANSFORM_LEN(S, D, L) Transform_Sha256_Len((S),(D),(L))
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId) int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
@ -418,14 +422,31 @@ static int InitSha256(wc_Sha256* sha256)
return ret; return ret;
} }
static int Transform_Sha256(wc_Sha256* sha256) static int Transform_Sha256(wc_Sha256* sha256, const byte* data)
{ {
int ret = wolfSSL_CryptHwMutexLock(); int ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) { if (ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA #ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_sha256_hash_n((byte*)sha256->buffer, 1, sha256->digest); cau_sha256_hash_n((byte*)data, 1, sha256->digest);
#else #else
MMCAU_SHA256_HashN((byte*)sha256->buffer, 1, sha256->digest); MMCAU_SHA256_HashN((byte*)data, 1, sha256->digest);
#endif
wolfSSL_CryptHwMutexUnLock();
}
return ret;
}
static int Transform_Sha256_Len(wc_Sha256* sha256, const byte* data,
word32 len)
{
int ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
#ifdef FREESCALE_MMCAU_CLASSIC_SHA
cau_sha256_hash_n((byte*)data, len/WC_SHA256_BLOCK_SIZE,
sha256->digest);
#else
MMCAU_SHA256_HashN((byte*)data, len/WC_SHA256_BLOCK_SIZE,
sha256->digest);
#endif #endif
wolfSSL_CryptHwMutexUnLock(); wolfSSL_CryptHwMutexUnLock();
} }
@ -553,12 +574,12 @@ static int InitSha256(wc_Sha256* sha256)
return ret; return ret;
} }
#elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \ #elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \
!defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH) !defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH)
/* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */ /* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */
#else #else
#define NEED_SOFT_SHA256 #define NEED_SOFT_SHA256
@ -593,6 +614,11 @@ static int InitSha256(wc_Sha256* sha256)
} }
#endif /* End Hardware Acceleration */ #endif /* End Hardware Acceleration */
#ifndef WC_SHA256_DATA_ALIGNMENT
/* default is 32-bit alignment required */
#define WC_SHA256_DATA_ALIGNMENT 4
#endif
#ifdef NEED_SOFT_SHA256 #ifdef NEED_SOFT_SHA256
static const ALIGN32 word32 K[64] = { static const ALIGN32 word32 K[64] = {
@ -639,6 +665,10 @@ static int InitSha256(wc_Sha256* sha256)
#define g(i) S[(6-i) & 7] #define g(i) S[(6-i) & 7]
#define h(i) S[(7-i) & 7] #define h(i) S[(7-i) & 7]
#ifndef XTRANSFORM
#define XTRANSFORM(S, D) Transform_Sha256((S),(D))
#endif
#ifndef SHA256_MANY_REGISTERS #ifndef SHA256_MANY_REGISTERS
#define RND(j) \ #define RND(j) \
t0 = h(j) + Sigma1(e(j)) + Ch(e(j), f(j), g(j)) + K[i+j] + W[i+j]; \ t0 = h(j) + Sigma1(e(j)) + Ch(e(j), f(j), g(j)) + K[i+j] + W[i+j]; \
@ -646,12 +676,7 @@ static int InitSha256(wc_Sha256* sha256)
d(j) += t0; \ d(j) += t0; \
h(j) = t0 + t1 h(j) = t0 + t1
#ifndef XTRANSFORM static int Transform_Sha256(wc_Sha256* sha256, const byte* data)
#define XTRANSFORM(S) Transform_Sha256((S))
#define XTRANSFORM_LEN(S, D, L) Transform_Sha256_Len((S),(D),(L))
#endif
static int Transform_Sha256(wc_Sha256* sha256)
{ {
word32 S[8], t0, t1; word32 S[8], t0, t1;
int i; int i;
@ -680,7 +705,7 @@ static int InitSha256(wc_Sha256* sha256)
S[i] = sha256->digest[i]; S[i] = sha256->digest[i];
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
W[i] = sha256->buffer[i]; W[i] = *((word32*)&data[i*sizeof(word32)]);
for (i = 16; i < WC_SHA256_BLOCK_SIZE; i++) for (i = 16; i < WC_SHA256_BLOCK_SIZE; i++)
W[i] = Gamma1(W[i-2]) + W[i-7] + Gamma0(W[i-15]) + W[i-16]; W[i] = Gamma1(W[i-2]) + W[i-7] + Gamma0(W[i-15]) + W[i-16];
@ -713,7 +738,7 @@ static int InitSha256(wc_Sha256* sha256)
} }
#else #else
/* SHA256 version that keeps all data in registers */ /* SHA256 version that keeps all data in registers */
#define SCHED1(j) (W[j] = sha256->buffer[j]) #define SCHED1(j) (W[j] = *((word32*)&data[j*sizeof(word32)]))
#define SCHED(j) ( \ #define SCHED(j) ( \
W[ j & 15] += \ W[ j & 15] += \
Gamma1(W[(j-2) & 15])+ \ Gamma1(W[(j-2) & 15])+ \
@ -732,12 +757,7 @@ static int InitSha256(wc_Sha256* sha256)
d(j) += t0; \ d(j) += t0; \
h(j) = t0 + t1 h(j) = t0 + t1
#ifndef XTRANSFORM static int Transform_Sha256(wc_Sha256* sha256, const byte* data)
#define XTRANSFORM(S) Transform_Sha256((S))
#define XTRANSFORM_LEN(S, D, L) Transform_Sha256_Len((S),(D),(L))
#endif
static int Transform_Sha256(wc_Sha256* sha256)
{ {
word32 S[8], t0, t1; word32 S[8], t0, t1;
int i; int i;
@ -788,14 +808,18 @@ static int InitSha256(wc_Sha256* sha256)
static WC_INLINE void AddLength(wc_Sha256* sha256, word32 len) static WC_INLINE void AddLength(wc_Sha256* sha256, word32 len)
{ {
word32 tmp = sha256->loLen; word32 tmp = sha256->loLen;
if ((sha256->loLen += len) < tmp) if ((sha256->loLen += len) < tmp) {
sha256->hiLen++; /* carry low to high */ sha256->hiLen++; /* carry low to high */
}
} }
/* do block size increments/updates */
static WC_INLINE int Sha256Update(wc_Sha256* sha256, const byte* data, word32 len) static WC_INLINE int Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{ {
int ret = 0; int ret = 0;
byte* local; word32 blocksLen;
byte* local;
word32* local32;
if (sha256 == NULL || (data == NULL && len > 0)) { if (sha256 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
@ -806,117 +830,128 @@ static int InitSha256(wc_Sha256* sha256)
return 0; return 0;
} }
/* check that internal buffLen is valid */
if (sha256->buffLen >= WC_SHA256_BLOCK_SIZE) {
return BUFFER_E;
}
/* add length for final */
AddLength(sha256, len); AddLength(sha256, len);
/* do block size increments */
local = (byte*)sha256->buffer; local = (byte*)sha256->buffer;
local32 = sha256->buffer;
/* check that internal buffLen is valid */ /* process any remainder from previous operation */
if (sha256->buffLen >= WC_SHA256_BLOCK_SIZE)
return BUFFER_E;
if (sha256->buffLen > 0) { if (sha256->buffLen > 0) {
word32 add = min(len, WC_SHA256_BLOCK_SIZE - sha256->buffLen); blocksLen = min(len, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
XMEMCPY(&local[sha256->buffLen], data, add); XMEMCPY(&local[sha256->buffLen], data, blocksLen);
sha256->buffLen += add; sha256->buffLen += blocksLen;
data += add; data += blocksLen;
len -= add; len -= blocksLen;
if (sha256->buffLen == WC_SHA256_BLOCK_SIZE) { if (sha256->buffLen == WC_SHA256_BLOCK_SIZE) {
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags)) if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif #endif
{ {
ByteReverseWords(sha256->buffer, sha256->buffer, ByteReverseWords(local32, local32, WC_SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
} }
#endif #endif
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \ #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH) !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
ret = XTRANSFORM(sha256); if (sha256->ctx.mode == ESP32_SHA_INIT){
#else
if(sha256->ctx.mode == ESP32_SHA_INIT) {
esp_sha_try_hw_lock(&sha256->ctx); esp_sha_try_hw_lock(&sha256->ctx);
} }
if(sha256->ctx.mode == ESP32_SHA_SW){ if (sha256->ctx.mode == ESP32_SHA_SW){
ret = XTRANSFORM(sha256); ret = XTRANSFORM(sha256, (const byte*)local);
} else { } else {
esp_sha256_process(sha256); esp_sha256_process(sha256, (const byte*)local);
} }
#endif #else
ret = XTRANSFORM(sha256, (const byte*)local);
#endif
if (ret == 0) if (ret == 0)
sha256->buffLen = 0; sha256->buffLen = 0;
else else
len = 0; len = 0; /* error */
} }
} }
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) /* process blocks */
if (Transform_Sha256_Len_p != NULL) { #ifdef XTRANSFORM_LEN
word32 blocksLen = len & ~(WC_SHA256_BLOCK_SIZE-1); #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (Transform_Sha256_Len_p != NULL)
#endif
{
/* get number of blocks */
/* 64-1 = 0x3F (~ Inverted = 0xFFFFFFC0) */
/* len (masked by 0xFFFFFFC0) returns block aligned length */
blocksLen = len & ~(WC_SHA256_BLOCK_SIZE-1);
if (blocksLen > 0) { if (blocksLen > 0) {
/* Byte reversal performed in function if required. */ /* Byte reversal and alignment handled in function if required */
XTRANSFORM_LEN(sha256, data, blocksLen); XTRANSFORM_LEN(sha256, data, blocksLen);
data += blocksLen; data += blocksLen;
len -= blocksLen; len -= blocksLen;
} }
} }
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
else else
#endif #endif
#if !defined(LITTLE_ENDIAN_ORDER) || defined(FREESCALE_MMCAU_SHA) || \ #endif /* XTRANSFORM_LEN */
defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if !defined(XTRANSFORM_LEN) || defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
{ {
while (len >= WC_SHA256_BLOCK_SIZE) { while (len >= WC_SHA256_BLOCK_SIZE) {
XMEMCPY(local, data, WC_SHA256_BLOCK_SIZE); /* optimization to avoid memcpy if data pointer is properly aligned */
/* Intel transform function requires use of sha256->buffer */
/* Little Endian requires byte swap, so can't use data directly */
#if defined(WC_SHA256_DATA_ALIGNMENT) && !defined(LITTLE_ENDIAN_ORDER) && \
!defined(HAVE_INTEL_AVX1) && !defined(HAVE_INTEL_AVX2)
if (((size_t)data % WC_SHA256_DATA_ALIGNMENT) == 0) {
local32 = (word32*)data;
}
else
#endif
{
XMEMCPY(local32, data, WC_SHA256_BLOCK_SIZE);
}
data += WC_SHA256_BLOCK_SIZE; data += WC_SHA256_BLOCK_SIZE;
len -= WC_SHA256_BLOCK_SIZE; len -= WC_SHA256_BLOCK_SIZE;
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags)) if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif
{ {
ByteReverseWords(sha256->buffer, sha256->buffer, ByteReverseWords(local32, local32, WC_SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
} }
#endif #endif
ret = XTRANSFORM(sha256);
if (ret != 0)
break;
}
}
#else
{
while (len >= WC_SHA256_BLOCK_SIZE) {
XMEMCPY(local, data, WC_SHA256_BLOCK_SIZE);
data += WC_SHA256_BLOCK_SIZE; #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
len -= WC_SHA256_BLOCK_SIZE; !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
if (sha256->ctx.mode == ESP32_SHA_INIT){
ByteReverseWords(sha256->buffer, sha256->buffer,
WC_SHA256_BLOCK_SIZE);
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
ret = XTRANSFORM(sha256);
#else
if(sha256->ctx.mode == ESP32_SHA_INIT){
esp_sha_try_hw_lock(&sha256->ctx); esp_sha_try_hw_lock(&sha256->ctx);
} }
if (sha256->ctx.mode == ESP32_SHA_SW){
if(sha256->ctx.mode == ESP32_SHA_SW){ ret = XTRANSFORM(sha256, (const byte*)local32);
ret = XTRANSFORM(sha256);
} else { } else {
esp_sha256_process(sha256); esp_sha256_process(sha256, (const byte*)local32);
} }
#endif #else
ret = XTRANSFORM(sha256, (const byte*)local32);
#endif
if (ret != 0) if (ret != 0)
break; break;
} }
} }
#endif #endif
/* save remainder */
if (len > 0) { if (len > 0) {
XMEMCPY(local, data, len); XMEMCPY(local, data, len);
sha256->buffLen = len; sha256->buffLen = len;
@ -959,13 +994,14 @@ static int InitSha256(wc_Sha256* sha256)
{ {
int ret; int ret;
byte* local = (byte*)sha256->buffer; byte* local;
if (sha256 == NULL) { if (sha256 == NULL) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
} }
local[sha256->buffLen++] = 0x80; /* add 1 */ local = (byte*)sha256->buffer;
local[sha256->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */ /* pad with zeros */
if (sha256->buffLen > WC_SHA256_PAD_SIZE) { if (sha256->buffLen > WC_SHA256_PAD_SIZE) {
@ -973,36 +1009,36 @@ static int InitSha256(wc_Sha256* sha256)
WC_SHA256_BLOCK_SIZE - sha256->buffLen); WC_SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += WC_SHA256_BLOCK_SIZE - sha256->buffLen; sha256->buffLen += WC_SHA256_BLOCK_SIZE - sha256->buffLen;
{
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags)) if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif #endif
{ {
ByteReverseWords(sha256->buffer, sha256->buffer, ByteReverseWords(sha256->buffer, sha256->buffer,
WC_SHA256_BLOCK_SIZE); WC_SHA256_BLOCK_SIZE);
} }
#endif #endif
#if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
!defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
if (sha256->ctx.mode == ESP32_SHA_INIT) {
esp_sha_try_hw_lock(&sha256->ctx);
}
if (sha256->ctx.mode == ESP32_SHA_SW) {
ret = XTRANSFORM(sha256, (const byte*)local);
} else {
ret = esp_sha256_process(sha256, (const byte*)local);
} }
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
ret = XTRANSFORM(sha256);
#else #else
if(sha256->ctx.mode == ESP32_SHA_INIT){ ret = XTRANSFORM(sha256, (const byte*)local);
esp_sha_try_hw_lock(&sha256->ctx);
}
if(sha256->ctx.mode == ESP32_SHA_SW){
ret = XTRANSFORM(sha256);
} else {
ret = esp_sha256_process(sha256);
}
#endif #endif
if (ret != 0) if (ret != 0)
return ret; return ret;
sha256->buffLen = 0; sha256->buffLen = 0;
} }
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_PAD_SIZE - sha256->buffLen); XMEMSET(&local[sha256->buffLen], 0,
WC_SHA256_PAD_SIZE - sha256->buffLen);
/* put lengths in bits */ /* put lengths in bits */
sha256->hiLen = (sha256->loLen >> (8 * sizeof(sha256->loLen) - 3)) + sha256->hiLen = (sha256->loLen >> (8 * sizeof(sha256->loLen) - 3)) +
@ -1012,12 +1048,12 @@ static int InitSha256(wc_Sha256* sha256)
/* store lengths */ /* store lengths */
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA) #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags)) if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif #endif
{ {
ByteReverseWords(sha256->buffer, sha256->buffer, ByteReverseWords(sha256->buffer, sha256->buffer,
WC_SHA256_BLOCK_SIZE); WC_SHA256_BLOCK_SIZE);
} }
#endif #endif
/* ! length ordering dependent on digest endian type ! */ /* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[WC_SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32)); XMEMCPY(&local[WC_SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
@ -1028,30 +1064,31 @@ static int InitSha256(wc_Sha256* sha256)
defined(HAVE_INTEL_AVX2) defined(HAVE_INTEL_AVX2)
/* Kinetis requires only these bytes reversed */ /* Kinetis requires only these bytes reversed */
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2) #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (IS_INTEL_AVX1(intel_flags) || IS_INTEL_AVX2(intel_flags)) if (IS_INTEL_AVX1(intel_flags) || IS_INTEL_AVX2(intel_flags))
#endif #endif
{ {
ByteReverseWords( ByteReverseWords(
&sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)], &sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)],
&sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)], &sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)],
2 * sizeof(word32)); 2 * sizeof(word32));
} }
#endif #endif
#if !defined(WOLFSSL_ESP32WROOM32_CRYPT) || \ #if defined(WOLFSSL_ESP32WROOM32_CRYPT) && \
defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH) !defined(NO_WOLFSSL_ESP32WROOM32_CRYPT_HASH)
return XTRANSFORM(sha256); if (sha256->ctx.mode == ESP32_SHA_INIT) {
esp_sha_try_hw_lock(&sha256->ctx);
}
if (sha256->ctx.mode == ESP32_SHA_SW) {
ret = XTRANSFORM(sha256, (const byte*)local);
} else {
ret = esp_sha256_digest_process(sha256, 1);
}
#else #else
if(sha256->ctx.mode == ESP32_SHA_INIT){ ret = XTRANSFORM(sha256, (const byte*)local);
esp_sha_try_hw_lock(&sha256->ctx);
}
if(sha256->ctx.mode == ESP32_SHA_SW){
return XTRANSFORM(sha256);
} else {
ret = esp_sha256_digest_process(sha256, 1);
}
return ret;
#endif #endif
return ret;
} }
int wc_Sha256FinalRaw(wc_Sha256* sha256, byte* hash) int wc_Sha256FinalRaw(wc_Sha256* sha256, byte* hash)
@ -1439,10 +1476,10 @@ void wc_Sha256Free(wc_Sha256* sha256)
#elif defined(WOLFSSL_DEVCRYPTO_HASH) #elif defined(WOLFSSL_DEVCRYPTO_HASH)
/* implemented in wolfcrypt/src/port/devcrypto/devcrypt_hash.c */ /* implemented in wolfcrypt/src/port/devcrypto/devcrypt_hash.c */
#elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \ #elif defined(WOLFSSL_RENESAS_TSIP_CRYPT) && \
!defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH) !defined(NO_WOLFSSL_RENESAS_TSIP_CRYPT_HASH)
/* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */ /* implemented in wolfcrypt/src/port/Renesas/renesas_tsip_sha.c */
#else #else

6
wolfssl/wolfcrypt/port/Espressif/esp32-crypt.h
View File

@ -114,12 +114,12 @@ void esp_sha_hw_unlock( void );
struct wc_Sha; struct wc_Sha;
int esp_sha_digest_process(struct wc_Sha* sha, byte bockprocess); int esp_sha_digest_process(struct wc_Sha* sha, byte bockprocess);
int esp_sha_process(struct wc_Sha* sha); int esp_sha_process(struct wc_Sha* sha, const byte* data);
#ifndef NO_SHA256 #ifndef NO_SHA256
struct wc_Sha256; struct wc_Sha256;
int esp_sha256_digest_process(struct wc_Sha256* sha, byte bockprocess); int esp_sha256_digest_process(struct wc_Sha256* sha, byte bockprocess);
int esp_sha256_process(struct wc_Sha256* sha); int esp_sha256_process(struct wc_Sha256* sha, const byte* data);
#endif #endif
#if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384) #if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384)
@ -140,7 +140,7 @@ struct fp_int;
int esp_mp_mul(struct fp_int* X, struct fp_int* Y, struct fp_int* Z); int esp_mp_mul(struct fp_int* X, struct fp_int* Y, struct fp_int* Z);
int esp_mp_exptmod(struct fp_int* G, struct fp_int* X, word32 Xbits, struct fp_int* P, int esp_mp_exptmod(struct fp_int* G, struct fp_int* X, word32 Xbits, struct fp_int* P,
struct fp_int* Y); struct fp_int* Y);
int esp_mp_mulmod(struct fp_int* X, struct fp_int* Y, struct fp_int* M, int esp_mp_mulmod(struct fp_int* X, struct fp_int* Y, struct fp_int* M,
struct fp_int* Z); struct fp_int* Z);
#endif /* NO_RSA || HAVE_ECC*/ #endif /* NO_RSA || HAVE_ECC*/