Fixes for PIC32MZ:

* Adds crypto HW support for AES Direct and AES CCM.
* Fixes to enable PIC32MZ hardware hashing where updates are cached via heap buffer and final performs single operations against hardware.
* Fix for benchmark with 1024-bit certs passing in wrong size for `wc_RsaPrivateDecrypt` when using `USE_CERT_BUFFERS_1024`.
* Fix to resolve missing `strncasecmp` for the Microchip XC32. Workaround to use case sensitive version instead. This error occurred when building with HAVE_ECC defined in Harmony with XC32.
* Cleanup of the PIC32MZ crypto and hashing hardware code. Replace `pic32mz-hash.c` with `pic32mz-crypt.c`
* Add user_settings.h for mplabx and mcapi examples.
* Sync up with Harmony changes for MCAPI.

.gitignore

@@ -169,6 +169,12 @@ mplabx/wolfcrypt_test.X/nbproject/Makefile-*
 mplabx/wolfcrypt_test.X/nbproject/Package-default.bash
 mplabx/wolfssl.X/nbproject/Makefile-*
 mplabx/wolfssl.X/nbproject/Package-default.bash
+mplabx/wolfssl.X/nbproject/private
+mplabx/wolfcrypt_test.X/nbproject/private
+mplabx/wolfcrypt_benchmark.X/nbproject/private
+mplabx/wolfssl.X/dist/default/
+mplabx/wolfcrypt_test.X/dist/default/
+mplabx/wolfcrypt_benchmark.X/dist/default/
 *.dSYM
 
 # Vagrant folder
@@ -220,3 +226,5 @@ IDE/LINUX-SGX/*.a
 
 # Binaries
 wolfcrypt/src/port/intel/qat_test
+/mplabx/wolfssl.X/dist/default/
+/mplabx/wolfcrypt_test.X/dist/default/

mcapi/PIC32MZ-serial.h

@@ -1,28 +1,75 @@
 void _mon_putc(char c);
 
-static void init_serial() {
+#define BAUD_GEN(sysclk, baud) ((sysclk / (16 * baud)) - 1)
-    #ifdef MICROCHIP_PIC32
-#if defined (__32MZ2048ECH144__) || (__32MZ2048ECM144__)
-    /* Set up PB2 divisor for UART2 */
-    SYSKEY = 0x00000000;
-    SYSKEY = 0xAA996655;
-    SYSKEY = 0x556699AA;
-    PB2DIV = 0x00008018;
-    SYSKEY = 0x33333333;
 
-    /* UART2 Init */
+#ifdef MICROCHIP_PIC32
-//    U2BRG = 0x0C;
+#if defined (__32MZ2048ECH144__) || defined(__32MZ2048ECM144__) || defined(__32MZ2048EFM144__)
-    U2BRG = 0x7;
+    /* Code generated from Harmony example then exported using Window -> PIC32 Memory View -> Configuration Bits into system_config.h */
+    #define SYS_CLK_FREQ                    200000000ul
+    #define SYS_CLK_BUS_PERIPHERAL_2        100000000ul
+
+    // DEVCFG3
+    #pragma config FMIIEN = ON              // Ethernet RMII/MII Enable (MII Enabled)
+    #pragma config FETHIO = ON              // Ethernet I/O Pin Select (Default Ethernet I/O)
+    #pragma config PGL1WAY = ON             // Permission Group Lock One Way Configuration (Allow only one reconfiguration)
+    #pragma config PMDL1WAY = ON            // Peripheral Module Disable Configuration (Allow only one reconfiguration)
+    #pragma config IOL1WAY = ON             // Peripheral Pin Select Configuration (Allow only one reconfiguration)
+    #pragma config FUSBIDIO = ON            // USB USBID Selection (Controlled by the USB Module)
+
+    // DEVCFG2
+    #pragma config FPLLIDIV = DIV_1         // System PLL Input Divider (1x Divider)
+    #pragma config FPLLRNG = RANGE_5_10_MHZ // System PLL Input Range (5-10 MHz Input)
+    #pragma config FPLLICLK = PLL_FRC       // System PLL Input Clock Selection (FRC is input to the System PLL)
+    #pragma config FPLLMULT = MUL_50        // System PLL Multiplier (PLL Multiply by 50)
+    #pragma config FPLLODIV = DIV_2         // System PLL Output Clock Divider (2x Divider)
+    #pragma config UPLLFSEL = FREQ_24MHZ    // USB PLL Input Frequency Selection (USB PLL input is 24 MHz)
+
+    // DEVCFG1
+    #pragma config FNOSC = SPLL             // Oscillator Selection Bits (System PLL)
+    #pragma config DMTINTV = WIN_127_128    // DMT Count Window Interval (Window/Interval value is 127/128 counter value)
+    #pragma config FSOSCEN = OFF            // Secondary Oscillator Enable (Disable SOSC)
+    #pragma config IESO = OFF               // Internal/External Switch Over (Disabled)
+    #pragma config POSCMOD = OFF            // Primary Oscillator Configuration (Primary osc disabled)
+    #pragma config OSCIOFNC = OFF           // CLKO Output Signal Active on the OSCO Pin (Disabled)
+    #pragma config FCKSM = CSECME           // Clock Switching and Monitor Selection (Clock Switch Enabled, FSCM Enabled)
+    #pragma config WDTPS = PS1048576        // Watchdog Timer Postscaler (1:1048576)
+    #pragma config WDTSPGM = STOP           // Watchdog Timer Stop During Flash Programming (WDT stops during Flash programming)
+    #pragma config WINDIS = NORMAL          // Watchdog Timer Window Mode (Watchdog Timer is in non-Window mode)
+    #pragma config FWDTEN = OFF             // Watchdog Timer Enable (WDT Disabled)
+    #pragma config FWDTWINSZ = WINSZ_25     // Watchdog Timer Window Size (Window size is 25%)
+    #pragma config DMTCNT = DMT31           // Deadman Timer Count Selection (2^31 (2147483648))
+    #pragma config FDMTEN = OFF             // Deadman Timer Enable (Deadman Timer is disabled)
+
+    // DEVCFG0
+    #pragma config ICESEL = ICS_PGx2        // ICE/ICD Comm Channel Select (Communicate on PGEC2/PGED2)
+
+    // DEVCP0
+    #pragma config CP = OFF                 // Code Protect (Protection Disabled)
+
+    #include <xc.h>
+#endif
+#endif
+
+static void init_serial(unsigned int sysClk) {
+#ifdef MICROCHIP_PIC32
+#if defined (__32MZ2048ECH144__) || defined(__32MZ2048ECM144__) || defined(__32MZ2048EFM144__)
+    /* This is for pin B14 which is connected to the USB to UART connector J11 located under Ethernet connector */
+
+    /* Setup UART2 */
+#ifdef SYS_CLK_BUS_PERIPHERAL_2
+    U2BRG = BAUD_GEN(SYS_CLK_BUS_PERIPHERAL_2, 115200);
+#else
+    if (sysClk > 100000000)
+        sysClk /= 2;
+    U2BRG = BAUD_GEN(sysClk, 115200);
+#endif
     ANSELBCLR = 0x4000;
     ANSELGCLR = 0x0040;
     RPB14R = 0x02;
     U2RXR = 0x01;
     U2MODE = 0x8000;
     U2STA = 0x400;
-#elif defined __PIC32MX__
-    SYSTEMConfigPerformance(80000000);
-    DBINIT();
 #endif
- 
 #endif
+    (void)sysClk;
 }

mcapi/crypto.c

@@ -20,29 +20,32 @@
  */
 
 
-
 /* Implements Microchip CRYPTO API layer */
-
+#ifdef HAVE_CONFIG_H
-
+    #include "config.h"
+#endif
+#ifdef MICROCHIP_MPLAB_HARMONY
+    #include "system_config.h"
+#endif
 
 #include "crypto.h"
 
-#include <cyassl/ctaocrypt/settings.h>
+#include <wolfssl/wolfcrypt/settings.h>
-
-#include <cyassl/ctaocrypt/md5.h>
-#include <cyassl/ctaocrypt/sha.h>
-#include <cyassl/ctaocrypt/sha256.h>
-#include <cyassl/ctaocrypt/sha512.h>
-#include <cyassl/ctaocrypt/hmac.h>
-#include <cyassl/ctaocrypt/compress.h>
-#include <cyassl/ctaocrypt/random.h>
-#include <cyassl/ctaocrypt/des3.h>
-#include <cyassl/ctaocrypt/aes.h>
-#include <cyassl/ctaocrypt/rsa.h>
-#include <cyassl/ctaocrypt/ecc.h>
-#include <cyassl/ctaocrypt/error-crypt.h>
 
+#include <wolfssl/wolfcrypt/md5.h>
+#include <wolfssl/wolfcrypt/sha.h>
+#include <wolfssl/wolfcrypt/sha256.h>
+#include <wolfssl/wolfcrypt/sha512.h>
+#include <wolfssl/wolfcrypt/hmac.h>
+#include <wolfssl/wolfcrypt/compress.h>
+#include <wolfssl/wolfcrypt/random.h>
+#include <wolfssl/wolfcrypt/des3.h>
+#include <wolfssl/wolfcrypt/aes.h>
+#include <wolfssl/wolfcrypt/rsa.h>
+#include <wolfssl/wolfcrypt/ecc.h>
+#include <wolfssl/wolfcrypt/error-crypt.h>
 
+#ifndef NO_MD5
 /* Initialize MD5 */
 int CRYPT_MD5_Initialize(CRYPT_MD5_CTX* md5)
 {
@@ -75,7 +78,9 @@ int CRYPT_MD5_Finalize(CRYPT_MD5_CTX* md5, unsigned char* digest)
 
     return wc_Md5Final((Md5*)md5, digest);
 }
+#endif
 
+#ifndef NO_SHA
 
 /* Initialize SHA */
 int CRYPT_SHA_Initialize(CRYPT_SHA_CTX* sha)
@@ -109,7 +114,9 @@ int CRYPT_SHA_Finalize(CRYPT_SHA_CTX* sha, unsigned char* digest)
 
     return wc_ShaFinal((Sha*)sha, digest);
 }
+#endif
 
+#ifndef NO_SHA256
 
 /* Initialize SHA-256 */
 int CRYPT_SHA256_Initialize(CRYPT_SHA256_CTX* sha256)
@@ -143,8 +150,10 @@ int CRYPT_SHA256_Finalize(CRYPT_SHA256_CTX* sha256, unsigned char* digest)
 
     return wc_Sha256Final((Sha256*)sha256, digest);
 }
+#endif
 
-
+#ifdef WOLFSSL_SHA512
+#ifdef WOLFSSL_SHA384
 /* Initialize SHA-384 */
 int CRYPT_SHA384_Initialize(CRYPT_SHA384_CTX* sha384)
 {
@@ -177,6 +186,7 @@ int CRYPT_SHA384_Finalize(CRYPT_SHA384_CTX* sha384, unsigned char* digest)
 
     return wc_Sha384Final((Sha384*)sha384, digest);
 }
+#endif
 
 
 /* Initialize SHA-512 */
@@ -211,8 +221,9 @@ int CRYPT_SHA512_Finalize(CRYPT_SHA512_CTX* sha512, unsigned char* digest)
 
     return wc_Sha512Final((Sha512*)sha512, digest);
 }
+#endif
 
-
+#ifndef NO_HMAC
 /* Set HMAC key with type */
 int CRYPT_HMAC_SetKey(CRYPT_HMAC_CTX* hmac, int type, const unsigned char* key,
                       unsigned int sz)
@@ -252,6 +263,9 @@ int CRYPT_HMAC_Finalize(CRYPT_HMAC_CTX* hmac, unsigned char* digest)
     return wc_HmacFinal((Hmac*)hmac, digest);
 }
 
+#endif
+
+#ifdef HAVE_LIBZ
 
 /* Huffman Compression, set flag to do static, otherwise dynamic */
 /* return compressed size, otherwise < 0 for error */
@@ -262,7 +276,7 @@ int CRYPT_HUFFMAN_Compress(unsigned char* out, unsigned int outSz,
     if (out == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return Compress(out, outSz, in, inSz, flags);
+    return wc_Compress(out, outSz, in, inSz, flags);
 }
 
 
@@ -274,9 +288,12 @@ int CRYPT_HUFFMAN_DeCompress(unsigned char* out, unsigned int outSz,
     if (out == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return DeCompress(out, outSz, in, inSz);
+    return wc_DeCompress(out, outSz, in, inSz);
 }
 
+#endif
+
+#ifndef NO_RNG
 
 /* RNG Initialize, < 0 on error */
 int CRYPT_RNG_Initialize(CRYPT_RNG_CTX* rng)
@@ -287,7 +304,7 @@ int CRYPT_RNG_Initialize(CRYPT_RNG_CTX* rng)
     if (rng == NULL)
         return BAD_FUNC_ARG;
 
-    return InitRng((WC_RNG*)rng);
+    return wc_InitRng((WC_RNG*)rng);
 }
 
 
@@ -297,7 +314,7 @@ int CRYPT_RNG_Get(CRYPT_RNG_CTX* rng, unsigned char* b)
     if (rng == NULL || b == NULL)
         return BAD_FUNC_ARG;
 
-    return RNG_GenerateByte((WC_RNG*)rng, (byte*)b);
+    return wc_RNG_GenerateByte((WC_RNG*)rng, (byte*)b);
 }
 
 
@@ -308,10 +325,12 @@ int CRYPT_RNG_BlockGenerate(CRYPT_RNG_CTX* rng, unsigned char* b,
     if (rng == NULL || b == NULL)
         return BAD_FUNC_ARG;
 
-    return RNG_GenerateBlock((WC_RNG*)rng, b, sz);
+    return wc_RNG_GenerateBlock((WC_RNG*)rng, b, sz);
 }
 
+#endif
 
+#ifndef NO_DES3
 /* Triple DES Key Set, may have iv, will have direction */
 int CRYPT_TDES_KeySet(CRYPT_TDES_CTX* tdes, const unsigned char* key,
                       const unsigned char* iv, int dir)
@@ -322,7 +341,7 @@ int CRYPT_TDES_KeySet(CRYPT_TDES_CTX* tdes, const unsigned char* key,
     if (tdes == NULL || key == NULL)
         return BAD_FUNC_ARG;
 
-    return Des3_SetKey((Des3*)tdes, key, iv, dir);
+    return wc_Des3_SetKey((Des3*)tdes, key, iv, dir);
 }
 
 
@@ -354,9 +373,12 @@ int CRYPT_TDES_CBC_Decrypt(CRYPT_TDES_CTX* tdes, unsigned char* out,
     if (tdes == NULL || out == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return Des3_CbcDecrypt((Des3*)tdes, out, in, inSz);
+    return wc_Des3_CbcDecrypt((Des3*)tdes, out, in, inSz);
 }
 
+#endif
+
+#ifndef NO_AES
 
 /* AES Key Set, may have iv, will have direction */
 int CRYPT_AES_KeySet(CRYPT_AES_CTX* aes, const unsigned char* key,
@@ -400,10 +422,11 @@ int CRYPT_AES_CBC_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
     if (aes == NULL || out == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return AesCbcDecrypt((Aes*)aes, out, in, inSz);
+    return wc_AesCbcDecrypt((Aes*)aes, out, in, inSz);
 }
+#endif
 
-
+#ifdef WOLFSSL_AES_COUNTER
 /* AES CTR Encrypt (used for decrypt too, with ENCRYPT key setup) */
 int CRYPT_AES_CTR_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                           const unsigned char* in, unsigned int inSz)
@@ -413,7 +436,9 @@ int CRYPT_AES_CTR_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 
     return wc_AesCtrEncrypt((Aes*)aes, out, in, inSz);
 }
+#endif
 
+#ifdef WOLFSSL_AES_DIRECT
 
 /* AES Direct mode encrypt, one block at a time */
 int CRYPT_AES_DIRECT_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
@@ -439,7 +464,9 @@ int CRYPT_AES_DIRECT_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 
     return 0;
 }
+#endif
 
+#ifndef NO_RSA
 
 /* RSA Initialize */
 int CRYPT_RSA_Initialize(CRYPT_RSA_CTX* rsa)
@@ -451,7 +478,7 @@ int CRYPT_RSA_Initialize(CRYPT_RSA_CTX* rsa)
     if (rsa->holder == NULL)
         return -1;
 
-    return InitRsaKey((RsaKey*)rsa->holder, NULL);
+    return wc_InitRsaKey((RsaKey*)rsa->holder, NULL);
 }
 
 
@@ -461,7 +488,7 @@ int CRYPT_RSA_Free(CRYPT_RSA_CTX* rsa)
     if (rsa == NULL)
         return BAD_FUNC_ARG;
 
-    FreeRsaKey((RsaKey*)rsa->holder);
+    wc_FreeRsaKey((RsaKey*)rsa->holder);
     XFREE(rsa->holder, NULL, DYNAMIC_TYPE_RSA);
     rsa->holder = NULL;
 
@@ -479,7 +506,7 @@ int CRYPT_RSA_PublicKeyDecode(CRYPT_RSA_CTX* rsa, const unsigned char* in,
     if (rsa == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return RsaPublicKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
+    return wc_RsaPublicKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
 }
 
 
@@ -493,7 +520,7 @@ int CRYPT_RSA_PrivateKeyDecode(CRYPT_RSA_CTX* rsa, const unsigned char* in,
     if (rsa == NULL || in == NULL)
         return BAD_FUNC_ARG;
 
-    return RsaPrivateKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
+    return wc_RsaPrivateKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
 }
 
 
@@ -505,7 +532,7 @@ int CRYPT_RSA_PublicEncrypt(CRYPT_RSA_CTX* rsa, unsigned char* out,
     if (rsa == NULL || in == NULL || out == NULL || rng == NULL)
         return BAD_FUNC_ARG;
 
-    return RsaPublicEncrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder,
+    return wc_RsaPublicEncrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder,
                             (WC_RNG*)rng);
 }
 
@@ -518,7 +545,7 @@ int CRYPT_RSA_PrivateDecrypt(CRYPT_RSA_CTX* rsa, unsigned char* out,
     if (rsa == NULL || in == NULL || out == NULL)
         return BAD_FUNC_ARG;
 
-    return RsaPrivateDecrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder);
+    return wc_RsaPrivateDecrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder);
 }
 
 
@@ -528,7 +555,7 @@ int CRYPT_RSA_EncryptSizeGet(CRYPT_RSA_CTX* rsa)
     if (rsa == NULL)
         return BAD_FUNC_ARG;
 
-    return RsaEncryptSize((RsaKey*)rsa->holder);
+    return wc_RsaEncryptSize((RsaKey*)rsa->holder);
 }
 
 
@@ -545,7 +572,9 @@ int CRYPT_RSA_SetRng(CRYPT_RSA_CTX* rsa, CRYPT_RNG_CTX* rng)
     return 0;
 #endif
 }
+#endif
 
+#ifdef HAVE_ECC
 
 /* ECC init */
 int CRYPT_ECC_Initialize(CRYPT_ECC_CTX* ecc)
@@ -698,6 +727,7 @@ int CRYPT_ECC_SignatureSizeGet(CRYPT_ECC_CTX* ecc)
     return wc_ecc_sig_size((ecc_key*)ecc->holder);
 }
 
+#endif
 
 /* Save error string from err to str which needs to be >= 80 chars */
 int CRYPT_ERROR_StringGet(int err, char* str)
@@ -705,7 +735,7 @@ int CRYPT_ERROR_StringGet(int err, char* str)
     if (str == NULL)
         return BAD_FUNC_ARG;
 
-    CTaoCryptErrorString(err, str);
+    wc_ErrorString(err, str);
 
     return 0;
 }

mcapi/crypto.h

@@ -164,7 +164,7 @@ enum {
 
 /* AES */
 typedef struct CRYPT_AES_CTX {
-    int holder[78];   /* big enough to hold internal, but check on init */
+    int holder[90];   /* big enough to hold internal, but check on init */
 } CRYPT_AES_CTX;
 
 /* key */

mcapi/include.am

@@ -15,5 +15,5 @@ noinst_HEADERS += mcapi/crypto.h
 
 EXTRA_DIST += \
          mcapi/README \
-		 mcapi/PIC32MZ-serial.h
+         mcapi/PIC32MZ-serial.h \
-
+         mcapi/user_settings.h

mcapi/mcapi_test.c

@@ -1,4 +1,4 @@
-/* test.c
+/* mcapi_test.c
  *
  * Copyright (C) 2006-2016 wolfSSL Inc.
  *
@@ -59,6 +59,8 @@
     #include <stdio.h>
     #include <stdlib.h>
     #include <p32xxxx.h>
+    #define _SUPPRESS_PLIB_WARNING
+    #define _DISABLE_OPENADC10_CONFIGPORT_WARNING
     #include <plib.h>
     #include <sys/appio.h>
     #define init_serial()  /* void out init_serial() */

mcapi/user_settings.h

@@ -0,0 +1,386 @@
+/* Example custom user settings for wolfSSL */
+
+#ifndef WOLFSSL_USER_SETTINGS_H
+#define WOLFSSL_USER_SETTINGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h> /* for size_t */
+
+
+/* ------------------------------------------------------------------------- */
+/* Platform */
+/* ------------------------------------------------------------------------- */
+#undef  WOLFSSL_GENERAL_ALIGNMENT
+#define WOLFSSL_GENERAL_ALIGNMENT   4
+
+#undef  SINGLE_THREADED
+#define SINGLE_THREADED
+
+#undef  WOLFSSL_SMALL_STACK
+#define WOLFSSL_SMALL_STACK
+
+#undef  MICROCHIP_PIC32
+#define MICROCHIP_PIC32
+
+#undef  WOLFSSL_MICROCHIP_PIC32MZ
+#define WOLFSSL_MICROCHIP_PIC32MZ
+
+
+/* ------------------------------------------------------------------------- */
+/* Math Configuration */
+/* ------------------------------------------------------------------------- */
+#undef  USE_FAST_MATH
+#define USE_FAST_MATH
+
+#ifdef USE_FAST_MATH
+    #undef  TFM_TIMING_RESISTANT
+    #define TFM_TIMING_RESISTANT
+
+    /* Optimizations */
+    //#define TFM_MIPS
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Crypto */
+/* ------------------------------------------------------------------------- */
+/* ECC */
+#if 1
+    #undef  HAVE_ECC
+    #define HAVE_ECC
+
+    /* Manually define enabled curves */
+    #undef  ECC_USER_CURVES
+    #define ECC_USER_CURVES
+
+    //#define HAVE_ECC192
+    //#define HAVE_ECC224
+    #undef NO_ECC256
+    //#define HAVE_ECC384
+    //#define HAVE_ECC521
+
+    /* Fixed point cache (speeds repeated operations against same private key) */
+    #undef  FP_ECC
+    //#define FP_ECC
+    #ifdef FP_ECC
+        /* Bits / Entries */
+        #undef  FP_ENTRIES
+        #define FP_ENTRIES  2
+        #undef  FP_LUT
+        #define FP_LUT      4
+    #endif
+
+    /* Optional ECC calculation method */
+    /* Note: doubles heap usage, but slightly faster */
+    #undef  ECC_SHAMIR
+    #define ECC_SHAMIR
+
+    /* Reduces heap usage, but slower */
+    #undef  ECC_TIMING_RESISTANT
+    #define ECC_TIMING_RESISTANT
+
+    #ifdef USE_FAST_MATH
+        /* use reduced size math buffers for ecc points */
+        #undef  ALT_ECC_SIZE
+        #define ALT_ECC_SIZE
+
+        /* Enable TFM optimizations for ECC */
+        #if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC192
+        #endif
+        #if defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC224
+        #endif
+        #if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC256
+        #endif
+        #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC384
+        #endif
+        #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC521
+        #endif
+    #endif
+#endif
+
+/* RSA */
+#undef NO_RSA
+#if 1
+    #ifdef USE_FAST_MATH
+        /* Maximum math bits (Max RSA key bits * 2) */
+        #undef  FP_MAX_BITS
+        #define FP_MAX_BITS     2048
+    #endif
+
+    /* half as much memory but twice as slow */
+    #undef  RSA_LOW_MEM
+    //#define RSA_LOW_MEM
+    
+    /* timing resistance */
+    #undef  WC_RSA_BLINDING
+    #define WC_RSA_BLINDING
+#else
+    #define NO_RSA
+#endif
+
+/* AES */
+#undef NO_AES
+#if 1
+    #undef  HAVE_AES_DECRYPT
+    #define HAVE_AES_DECRYPT
+
+    #undef  HAVE_AESGCM
+    #define HAVE_AESGCM
+
+    /* GCM Method: GCM_SMALL, GCM_WORD32 or GCM_TABLE */
+    #undef  GCM_SMALL
+    #define GCM_SMALL
+
+    #undef  HAVE_AESCCM
+    #define HAVE_AESCCM
+
+    #undef  WOLFSSL_AES_COUNTER
+    #define WOLFSSL_AES_COUNTER
+
+    #undef  WOLFSSL_AES_DIRECT
+    #define WOLFSSL_AES_DIRECT
+#else
+    #define NO_AES
+#endif
+
+/* DES3 */
+#undef NO_DES3
+#if 1
+    #undef  WOLFSSL_DES_ECB
+    #define WOLFSSL_DES_ECB
+#else
+    #define NO_DES3
+#endif
+
+
+/* ChaCha20 / Poly1305 */
+#undef HAVE_CHACHA
+#undef HAVE_POLY1305
+#if 0
+    #define HAVE_CHACHA
+    #define HAVE_POLY1305
+
+    /* Needed for Poly1305 */
+    #undef  HAVE_ONE_TIME_AUTH
+    #define HAVE_ONE_TIME_AUTH
+#endif
+
+/* Ed25519 / Curve25519 */
+#undef HAVE_CURVE25519
+#undef HAVE_ED25519
+#if 0
+    #define HAVE_CURVE25519
+    #define HAVE_ED25519
+
+    /* Optionally use small math (less flash usage, but much slower) */
+    #if 0
+        #define CURVED25519_SMALL
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Hashing */
+/* ------------------------------------------------------------------------- */
+/* Sha */
+#undef NO_SHA
+#if 1
+    /* 1k smaller, but 25% slower */
+    //#define USE_SLOW_SHA
+#else
+    #define NO_SHA
+#endif
+
+/* Sha256 */
+#undef NO_SHA256
+#if 1
+#else
+    #define NO_SHA256
+#endif
+
+/* Sha512 */
+#undef WOLFSSL_SHA512
+#if 1
+    #define WOLFSSL_SHA512
+
+    /* Sha384 */
+    #undef  WOLFSSL_SHA384
+    #if 1
+        #define WOLFSSL_SHA384
+    #endif
+
+    /* over twice as small, but 50% slower */
+    //#define USE_SLOW_SHA2
+#endif
+
+/* MD5 */
+#undef  NO_MD5
+#if 1
+#else
+    #define NO_MD5
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Benchmark / Test */
+/* ------------------------------------------------------------------------- */
+/* Use reduced benchmark / test sizes */
+#undef  BENCH_EMBEDDED
+#define BENCH_EMBEDDED
+
+#undef  USE_CERT_BUFFERS_2048
+//#define USE_CERT_BUFFERS_2048
+
+#undef  USE_CERT_BUFFERS_1024
+#define USE_CERT_BUFFERS_1024
+
+#undef  USE_CERT_BUFFERS_256
+#define USE_CERT_BUFFERS_256
+
+
+/* ------------------------------------------------------------------------- */
+/* Time */
+/* ------------------------------------------------------------------------- */
+#if 0
+    /* Override Current Time */
+    /* Allows custom "custom_time()" function to be used for benchmark */
+    #define WOLFSSL_USER_CURRTIME
+    #define USER_TICKS
+    extern unsigned long custom_time(unsigned long* timer);
+    #define XTIME custom_time
+#else
+    #warning Time/RTC disabled
+    #undef  NO_ASN_TIME
+    #define NO_ASN_TIME
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* Debugging */
+/* ------------------------------------------------------------------------- */
+#undef  DEBUG_WOLFSSL
+#define DEBUG_WOLFSSL
+
+#ifdef DEBUG_WOLFSSL
+    /* Use this to measure / print heap usage */
+    #if 0
+        #undef  USE_WOLFSSL_MEMORY
+        #define USE_WOLFSSL_MEMORY
+        #undef  WOLFSSL_TRACK_MEMORY
+        #define WOLFSSL_TRACK_MEMORY
+    #endif
+#else
+    #undef  NO_WOLFSSL_MEMORY
+    #define NO_WOLFSSL_MEMORY
+
+    #undef  NO_ERROR_STRINGS
+    //#define NO_ERROR_STRINGS
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Enable Features */
+/* ------------------------------------------------------------------------- */
+#undef  KEEP_PEER_CERT
+//#define KEEP_PEER_CERT
+
+#undef  HAVE_COMP_KEY
+//#define HAVE_COMP_KEY
+
+#undef  HAVE_TLS_EXTENSIONS
+//#define HAVE_TLS_EXTENSIONS
+
+#undef  HAVE_SUPPORTED_CURVES
+//#define HAVE_SUPPORTED_CURVES
+
+#undef  WOLFSSL_BASE64_ENCODE
+//#define WOLFSSL_BASE64_ENCODE
+
+/* TLS Session Cache */
+#if 0
+    #define SMALL_SESSION_CACHE
+#else
+    #define NO_SESSION_CACHE
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Disable Features */
+/* ------------------------------------------------------------------------- */
+#undef  NO_WOLFSSL_SERVER
+//#define NO_WOLFSSL_SERVER
+
+#undef  NO_WOLFSSL_CLIENT
+//#define NO_WOLFSSL_CLIENT
+
+#undef  NO_CRYPT_TEST
+//#define NO_CRYPT_TEST
+
+#undef  NO_CRYPT_BENCHMARK
+//#define NO_CRYPT_BENCHMARK
+
+/* In-lining of misc.c functions */
+/* If defined, must include wolfcrypt/src/misc.c in build */
+/* Slower, but about 1k smaller */
+#undef  NO_INLINE
+//#define NO_INLINE
+
+#undef  NO_FILESYSTEM
+#define NO_FILESYSTEM
+
+#undef  NO_WRITEV
+#define NO_WRITEV
+
+#undef  NO_MAIN_DRIVER
+#define NO_MAIN_DRIVER
+
+#undef  NO_DEV_RANDOM
+#define NO_DEV_RANDOM
+
+#undef  NO_DSA
+#define NO_DSA
+
+#undef  NO_DH
+#define NO_DH
+
+#undef  NO_RC4
+#define NO_RC4
+
+#undef  NO_OLD_TLS
+#define NO_OLD_TLS
+
+#undef  NO_HC128
+#define NO_HC128
+
+#undef  NO_RABBIT
+#define NO_RABBIT
+
+#undef  NO_PSK
+#define NO_PSK
+
+#undef  NO_MD4
+#define NO_MD4
+
+#undef  NO_PWDBASED
+#define NO_PWDBASED
+
+#undef  NO_CODING
+//#define NO_CODING
+
+
+/* Suppress array-bounds */
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WOLFSSL_USER_SETTINGS_H */

mcapi/wolfcrypt_mcapi.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -110,8 +111,7 @@
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS;HAVE_LIBZ;HAVE_MCAPI"/>
-                  value="WOLFSSL_SHA384;WOLFSSL_SHA512;HAVE_ECC;HAVE_LIBZ;HAVE_MCAPI"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>
@@ -149,7 +149,7 @@
         <property key="preprocessor-macros" value=""/>
         <property key="remove-unused-sections" value="false"/>
         <property key="report-memory-usage" value="false"/>
-        <property key="stack-size" value="2048"/>
+        <property key="stack-size" value="20480"/>
         <property key="symbol-stripping" value=""/>
         <property key="trace-symbols" value=""/>
         <property key="warn-section-align" value="false"/>

mcapi/wolfcrypt_test.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -110,8 +111,7 @@
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS;HAVE_LIBZ;HAVE_MCAPI"/>
-                  value="NO_MAIN_DRIVER;USE_CERT_BUFFERS_1024;WOLFSSL_SHA384;WOLFSSL_SHA512;HAVE_ECC;HAVE_LIBZ;HAVE_MCAPI"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>

mcapi/wolfssl.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -37,10 +38,8 @@
         <itemPath>../../wolfcrypt/src/md5.c</itemPath>
         <itemPath>../../wolfcrypt/src/memory.c</itemPath>
         <itemPath>../../wolfcrypt/src/misc.c</itemPath>
-        <itemPath>../../wolfcrypt/src/pic32mz-hash.c</itemPath>
         <itemPath>../../wolfcrypt/src/pkcs7.c</itemPath>
         <itemPath>../../wolfcrypt/src/poly1305.c</itemPath>
-        <itemPath>../../wolfcrypt/src/pw.c</itemPath>
         <itemPath>../../wolfcrypt/src/pwdbased.c</itemPath>
         <itemPath>../../wolfcrypt/src/rabbit.c</itemPath>
         <itemPath>../../wolfcrypt/src/random.c</itemPath>
@@ -51,6 +50,21 @@
         <itemPath>../../wolfcrypt/src/sha512.c</itemPath>
         <itemPath>../../wolfcrypt/src/tfm.c</itemPath>
         <itemPath>../../wolfcrypt/src/wc_port.c</itemPath>
+        <itemPath>../../wolfcrypt/src/port/pic32/pic32mz-hash.c</itemPath>
+        <itemPath>../../wolfcrypt/src/port/pic32/pic32mz-crypt.c</itemPath>
+        <itemPath>../../wolfcrypt/src/hash.c</itemPath>
+        <itemPath>../../wolfcrypt/src/chacha20_poly1305.c</itemPath>
+        <itemPath>../../wolfcrypt/src/curve25519.c</itemPath>
+        <itemPath>../../wolfcrypt/src/ed25519.c</itemPath>
+        <itemPath>../../wolfcrypt/src/fe_low_mem.c</itemPath>
+        <itemPath>../../wolfcrypt/src/fe_operations.c</itemPath>
+        <itemPath>../../wolfcrypt/src/ge_low_mem.c</itemPath>
+        <itemPath>../../wolfcrypt/src/ge_operations.c</itemPath>
+        <itemPath>../../wolfcrypt/src/wc_encrypt.c</itemPath>
+        <itemPath>../../wolfcrypt/src/pkcs12.c</itemPath>
+        <itemPath>../../wolfcrypt/src/signature.c</itemPath>
+        <itemPath>../../wolfcrypt/src/wolfevent.c</itemPath>
+        <itemPath>../../wolfcrypt/src/wolfmath.c</itemPath>
       </logicalFolder>
       <logicalFolder name="src" displayName="wolfssl" projectFiles="true">
         <itemPath>../../src/crl.c</itemPath>
@@ -61,6 +75,7 @@
         <itemPath>../../src/sniffer.c</itemPath>
         <itemPath>../../src/ssl.c</itemPath>
         <itemPath>../../src/tls.c</itemPath>
+        <itemPath>../../src/tls13.c</itemPath>
       </logicalFolder>
     </logicalFolder>
     <logicalFolder name="ExternalFiles"
@@ -118,7 +133,7 @@
         <property key="enable-unroll-loops" value="false"/>
         <property key="exclude-floating-point" value="false"/>
         <property key="extra-include-directories"
-                  value="../../;../../mcapi;../../zlib-1.2.8;/Users/chrisc/yaSSL/products/cyassl/git/cyassl57/zlib-1.2.7"/>
+                  value="../../;../../mcapi;../../mplabx;../../zlib-1.2.8"/>
         <property key="generate-16-bit-code" value="false"/>
         <property key="generate-micro-compressed-code" value="false"/>
         <property key="isolate-each-function" value="false"/>
@@ -127,8 +142,7 @@
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS;HAVE_LIBZ;HAVE_MCAPI"/>
-                  value="WOLFSSL_SHA512;WOLFSSL_SHA384;WOLFSSL_AES_COUNTER;WOLFSSL_AES_DIRECT;HAVE_ECC;HAVE_LIBZ;HAVE_MCAPI"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>

mplabx/PIC32MZ-serial.h

@@ -1,28 +1,96 @@
 void _mon_putc(char c);
 
-static void init_serial() {
+#define BAUD_GEN(sysclk, baud) ((sysclk / (16 * baud)) - 1)
-    #ifdef MICROCHIP_PIC32
-#if defined (__32MZ2048ECH144__) || (__32MZ2048ECM144__)
-    /* Set up PB2 divisor for UART2 */
-    SYSKEY = 0x00000000;
-    SYSKEY = 0xAA996655;
-    SYSKEY = 0x556699AA;
-    PB2DIV = 0x00008808;
-    SYSKEY = 0x33333333;
 
-    /* UART2 Init */
+#ifdef MICROCHIP_PIC32
-//    U2BRG = 0x0C;
+#if defined (__32MZ2048ECH144__) || defined(__32MZ2048ECM144__) || defined(__32MZ2048EFM144__)
-    U2BRG = 0x047;
+    /* Code generated from Harmony example then exported using Window -> PIC32 Memory View -> Configuration Bits into system_config.h */
+    #define SYS_CLK_FREQ                    200000000ul
+    #define SYS_CLK_BUS_PERIPHERAL_2        100000000ul
+
+    /* PIC32MZ2048EFM144 Configuration Bit Settings */
+
+    /*** DEVCFG0 ***/
+    #pragma config DEBUG =      OFF
+    #pragma config JTAGEN =     OFF
+    #pragma config ICESEL =     ICS_PGx2
+    #pragma config TRCEN =      OFF
+    #pragma config BOOTISA =    MIPS32
+    #pragma config FECCCON =    OFF_UNLOCKED
+    #pragma config FSLEEP =     OFF
+    #pragma config DBGPER =     PG_ALL
+    #pragma config SMCLR =      MCLR_NORM
+    #pragma config SOSCGAIN =   GAIN_2X
+    #pragma config SOSCBOOST =  ON
+    #pragma config POSCGAIN =   GAIN_2X
+    #pragma config POSCBOOST =  ON
+    #pragma config EJTAGBEN =   NORMAL
+    #pragma config CP =         OFF
+
+    /*** DEVCFG1 ***/
+    #pragma config FNOSC =      SPLL
+    #pragma config DMTINTV =    WIN_127_128
+    #pragma config FSOSCEN =    OFF
+    #pragma config IESO =       OFF
+    #pragma config POSCMOD =    EC
+    #pragma config OSCIOFNC =   OFF
+    #pragma config FCKSM =      CSECME
+    #pragma config WDTPS =      PS1048576
+    #pragma config WDTSPGM =    STOP
+    #pragma config FWDTEN =     OFF
+    #pragma config WINDIS =     NORMAL
+    #pragma config FWDTWINSZ =  WINSZ_25
+    #pragma config DMTCNT =     DMT31
+    #pragma config FDMTEN =     OFF
+
+    /*** DEVCFG2 ***/
+    #pragma config FPLLIDIV =   DIV_3
+    #pragma config FPLLRNG =    RANGE_5_10_MHZ
+    #pragma config FPLLICLK =   PLL_POSC
+    #pragma config FPLLMULT =   MUL_50
+    #pragma config FPLLODIV =   DIV_2
+    #pragma config UPLLFSEL =   FREQ_24MHZ
+
+    /*** DEVCFG3 ***/
+    #pragma config USERID =     0xffff
+    #pragma config FMIIEN =     ON
+    #pragma config FETHIO =     ON
+    #pragma config PGL1WAY =    ON
+    #pragma config PMDL1WAY =   ON
+    #pragma config IOL1WAY =    ON
+    #pragma config FUSBIDIO =   ON
+
+    /*** BF1SEQ0 ***/
+    #pragma config TSEQ =       0x0000
+    #pragma config CSEQ =       0xffff
+
+    /* #pragma config statements should precede project file includes. */
+    /* Use project enums instead of #define for ON and OFF. */
+
+    #include <xc.h>
+#endif
+#endif
+
+static void init_serial(unsigned int sysClk) {
+#ifdef MICROCHIP_PIC32
+#if defined (__32MZ2048ECH144__) || defined(__32MZ2048ECM144__) || defined(__32MZ2048EFM144__)
+    /* This is for pin B14 which is connected to the USB to UART connector J11 located under Ethernet connector */
+
+    /* Setup UART2 */
+#ifdef SYS_CLK_BUS_PERIPHERAL_2
+    U2BRG = BAUD_GEN(SYS_CLK_BUS_PERIPHERAL_2, 115200);
+#else
+    if (sysClk > 100000000)
+        sysClk /= 2;
+    U2BRG = BAUD_GEN(sysClk, 115200);
+#endif
     ANSELBCLR = 0x4000;
     ANSELGCLR = 0x0040;
     RPB14R = 0x02;
     U2RXR = 0x01;
     U2MODE = 0x8000;
     U2STA = 0x400;
-#elif defined __PIC32MX__
-    SYSTEMConfigPerformance(80000000);
-    DBINIT();
 #endif
- 
 #endif
+    (void)sysClk;
 }

mplabx/README

@@ -14,8 +14,8 @@ Included Project Files
 
 1. wolfSSL library (wolfssl.X)
 
-    This project builds a static wolfSSL library. Prior to building this
+    This project builds a static wolfSSL library. The settings for this project
-    project, uncomment the MICROCHIP_PIC32 define located in:
+    are in `user_settings.h`:
 
     <wolfssl_root>/wolfssl/wolfcrypt/settings.h
 
@@ -39,9 +39,10 @@ Included Project Files
 PIC32MX/PIC32MZ
 ---------------
 
-The projects are set for PIC32MX by default. For PIC32MZ, change project
+The projects are set for PIC32MZ by default. For PIC32MX, comment out the
-properties->Devices and add "WOLFSSL_MICROCHIP_PIC32MZ" to
+`WOLFSSL_MICROCHIP_PIC32MZ` line in `user_settings.h`.
-XC32-gcc->Preprocessing and messages-> Preprocessor macros.
+
+You also need to adjust the microcontroller device in the project properties.
 
 
 MIPS16 and MIPS32 Support
@@ -51,6 +52,14 @@ These projects support both MIPS16 and MIPS32 instruction sets. Switching
 between these two instruction sets can be done in each project's properties
 settings by checking the "Generate 16-bit code" checkbox.
 
+
+Legacy Peripheral Libraries
+___________________________
+
+If you get a linker error locating `ReadCoreTimer` and `WriteCoreTimer` you
+can enable wrappers in benchmark_main.c and test_main.c.
+
+
 Support
 -------
 Please send questions or comments to support@wolfssl.com

mplabx/benchmark_main.c

@@ -24,114 +24,55 @@
 #endif
 
 #include <wolfssl/wolfcrypt/settings.h>
+#include <wolfcrypt/benchmark/benchmark.h>
 
 #if defined(WOLFSSL_MICROCHIP_PIC32MZ)
     #define MICROCHIP_PIC32
-    #include <xc.h>
-    #pragma config ICESEL = ICS_PGx2
-            /* ICE/ICD Comm Channel Select (Communicate on PGEC2/PGED2) */
     #include <stdio.h>
     #include <stdlib.h>
     #include "PIC32MZ-serial.h"
-    #define  SYSTEMConfigPerformance /* void out SYSTEMConfigPerformance(); */
+    #include <xc.h>
+    #define SYSTEMConfigPerformance(a) /* void out SYSTEMConfigPerformance(); */
+    #define SYS_CLK 200000000
 #else
     #define PIC32_STARTER_KIT
-    #include <p32xxxx.h>
+    #define _SUPPRESS_PLIB_WARNING
+    #define _DISABLE_OPENADC10_CONFIGPORT_WARNING
     #include <plib.h>
     #include <sys/appio.h>
     #define init_serial() /* void out init_serial() ; */
+    #define SYS_CLK 80000000
 #endif
 
-void bench_des(void);
+#if 1
-void bench_arc4(void);
+/* enable this if ReadCoreTimer and WriteCoreTimer are missing */
-void bench_hc128(void);
+unsigned int ReadCoreTimer(void)
-void bench_rabbit(void);
+{
-void bench_aes(int);
+    unsigned int timer;
-void bench_aesgcm(void);
+    timer = __builtin_mfc0(9, 0);
-
+    return timer;
-void bench_md5(void);
+}
-void bench_sha(void);
+void WriteCoreTimer(unsigned int t)
-void bench_sha256(void);
+{
-void bench_sha512(void);
+    /* do nothing here */
-int  bench_ripemd(void);
+    (void)t;
-
+}
-void bench_rsa(void);
-void bench_rsaKeyGen(void);
-void bench_dh(void);
-#ifdef HAVE_ECC
-void bench_eccKeyGen(void);
-void bench_eccKeyAgree(void);
 #endif
 
 /*
  * Main driver for wolfCrypt benchmarks.
  */
-int main(int argc, char** argv) {
+int main(int argc, char** argv)
-    volatile int i ;
+{
-    int j ;
+    SYSTEMConfigPerformance(SYS_CLK);
-
-    PRECONbits.PFMWS = 2;
-    PRECONbits.PREFEN = 0b11;
-
-    init_serial() ;  /* initialize PIC32MZ serial I/O */
-    SYSTEMConfigPerformance(80000000);
     DBINIT();
+    
+    init_serial(SYS_CLK) ;  /* initialize PIC32MZ serial I/O */
+    
     printf("wolfCrypt Benchmark:\n");
 
-#ifndef NO_AES
+    benchmark_test(NULL);
-    bench_aes(0);
-    bench_aes(1);
-#endif
-#ifdef HAVE_AESGCM
-    bench_aesgcm();
-#endif
-#ifndef NO_RC4
-    bench_arc4();
-#endif
-#ifdef HAVE_HC128
-    bench_hc128();
-#endif
-#ifndef NO_RABBIT
-    bench_rabbit();
-#endif
-#ifndef NO_DES3
-    bench_des();
-#endif
 
-    printf("\n");
-
-#ifndef NO_MD5
-    bench_md5();
-#endif
-    bench_sha();
-#ifndef NO_SHA256
-    bench_sha256();
-#endif
-#ifdef WOLFSSL_SHA512
-    bench_sha512();
-#endif
-#ifdef CYASSL_RIPEMD
-    bench_ripemd();
-#endif
-
-    printf("\n");
-
-#ifndef NO_RSA
-    bench_rsa();
-#endif
-
-#ifndef NO_DH
-    bench_dh();
-#endif
-
-#if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA)
-    bench_rsaKeyGen();
-#endif
-
-#ifdef HAVE_ECC
-    bench_eccKeyGen();
-    bench_eccKeyAgree();
-#endif
     printf("End of wolfCrypt Benchmark:\n");
     return 0;
 }

mplabx/include.am

@@ -3,8 +3,8 @@
 #
 
 EXTRA_DIST += \
-         mplabx/PIC32MZ-serial.h \
 		 mplabx/README \
 		 mplabx/benchmark_main.c \
-		 mplabx/test_main.c
+		 mplabx/test_main.c \
-
+         mplabx/PIC32MZ-serial.h \
+         mplabx/user_settings.h

mplabx/test_main.c

@@ -25,24 +25,27 @@
 #endif
 
 #include <wolfssl/wolfcrypt/settings.h>
+#include <wolfcrypt/test/test.h>
 
 #if defined(WOLFSSL_MICROCHIP_PIC32MZ)
     #define MICROCHIP_PIC32
-    #include <xc.h>
-    #pragma config ICESEL = ICS_PGx2
-            /* ICE/ICD Comm Channel Select (Communicate on PGEC2/PGED2) */
     #include <stdio.h>
     #include <stdlib.h>
     #include "PIC32MZ-serial.h"
-    #define  SYSTEMConfigPerformance /* void out SYSTEMConfigPerformance(); */
+    #include <xc.h>
+    #define SYSTEMConfigPerformance(a) /* void out SYSTEMConfigPerformance(); */
+    #define SYS_CLK 200000000
 #else
     #define PIC32_STARTER_KIT
     #include <stdio.h>
     #include <stdlib.h>
     #include <p32xxxx.h>
+    #define _SUPPRESS_PLIB_WARNING
+    #define _DISABLE_OPENADC10_CONFIGPORT_WARNING
     #include <plib.h>
     #include <sys/appio.h>
     #define init_serial()  /* void out init_serial() */
+    #define SYS_CLK 80000000
 #endif
 
 /* func_args from test.h, so don't have to pull in other junk */
@@ -52,18 +55,36 @@ typedef struct func_args {
     int    return_code;
 } func_args;
 
+
+#if 1
+/* enable this if ReadCoreTimer and WriteCoreTimer are missing */
+unsigned int ReadCoreTimer(void)
+{
+    unsigned int timer;
+    timer = __builtin_mfc0(9, 0);
+    return timer;
+}
+void WriteCoreTimer(unsigned int t)
+{
+    /* do nothing here */
+    (void)t;
+}
+#endif
+
 /*
  * Main driver for WolfCrypt tests.
  */
-int main(int argc, char** argv) {
+int main(int argc, char** argv)
-    int i ;
+{
-
-    init_serial() ;  /* initialize PIC32MZ serial I/O */
-    SYSTEMConfigPerformance(80000000);
-    DBINIT();
-    printf("WolfCrypt Test:\n");
     func_args args;
     
+    SYSTEMConfigPerformance(SYS_CLK);
+    DBINIT();
+    
+    init_serial(SYS_CLK) ;  /* initialize PIC32MZ serial I/O */
+    
+    printf("WolfCrypt Test:\n");
+
     args.argc = argc;
     args.argv = argv;
 

mplabx/user_settings.h

@@ -0,0 +1,386 @@
+/* Example custom user settings for wolfSSL */
+
+#ifndef WOLFSSL_USER_SETTINGS_H
+#define WOLFSSL_USER_SETTINGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h> /* for size_t */
+
+
+/* ------------------------------------------------------------------------- */
+/* Platform */
+/* ------------------------------------------------------------------------- */
+#undef  WOLFSSL_GENERAL_ALIGNMENT
+#define WOLFSSL_GENERAL_ALIGNMENT   4
+
+#undef  SINGLE_THREADED
+#define SINGLE_THREADED
+
+#undef  WOLFSSL_SMALL_STACK
+#define WOLFSSL_SMALL_STACK
+
+#undef  MICROCHIP_PIC32
+#define MICROCHIP_PIC32
+
+#undef  WOLFSSL_MICROCHIP_PIC32MZ
+#define WOLFSSL_MICROCHIP_PIC32MZ
+
+
+/* ------------------------------------------------------------------------- */
+/* Math Configuration */
+/* ------------------------------------------------------------------------- */
+#undef  USE_FAST_MATH
+#define USE_FAST_MATH
+
+#ifdef USE_FAST_MATH
+    #undef  TFM_TIMING_RESISTANT
+    #define TFM_TIMING_RESISTANT
+
+    /* Optimizations */
+    //#define TFM_MIPS
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Crypto */
+/* ------------------------------------------------------------------------- */
+/* ECC */
+#if 1
+    #undef  HAVE_ECC
+    #define HAVE_ECC
+
+    /* Manually define enabled curves */
+    #undef  ECC_USER_CURVES
+    #define ECC_USER_CURVES
+
+    //#define HAVE_ECC192
+    //#define HAVE_ECC224
+    #undef NO_ECC256
+    //#define HAVE_ECC384
+    //#define HAVE_ECC521
+
+    /* Fixed point cache (speeds repeated operations against same private key) */
+    #undef  FP_ECC
+    //#define FP_ECC
+    #ifdef FP_ECC
+        /* Bits / Entries */
+        #undef  FP_ENTRIES
+        #define FP_ENTRIES  2
+        #undef  FP_LUT
+        #define FP_LUT      4
+    #endif
+
+    /* Optional ECC calculation method */
+    /* Note: doubles heap usage, but slightly faster */
+    #undef  ECC_SHAMIR
+    #define ECC_SHAMIR
+
+    /* Reduces heap usage, but slower */
+    #undef  ECC_TIMING_RESISTANT
+    #define ECC_TIMING_RESISTANT
+
+    #ifdef USE_FAST_MATH
+        /* use reduced size math buffers for ecc points */
+        #undef  ALT_ECC_SIZE
+        #define ALT_ECC_SIZE
+
+        /* Enable TFM optimizations for ECC */
+        #if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC192
+        #endif
+        #if defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC224
+        #endif
+        #if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC256
+        #endif
+        #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC384
+        #endif
+        #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
+            #define TFM_ECC521
+        #endif
+    #endif
+#endif
+
+/* RSA */
+#undef NO_RSA
+#if 1
+    #ifdef USE_FAST_MATH
+        /* Maximum math bits (Max RSA key bits * 2) */
+        #undef  FP_MAX_BITS
+        #define FP_MAX_BITS     2048
+    #endif
+
+    /* half as much memory but twice as slow */
+    #undef  RSA_LOW_MEM
+    //#define RSA_LOW_MEM
+    
+    /* timing resistance */
+    #undef  WC_RSA_BLINDING
+    #define WC_RSA_BLINDING
+#else
+    #define NO_RSA
+#endif
+
+/* AES */
+#undef NO_AES
+#if 1
+    #undef  HAVE_AES_DECRYPT
+    #define HAVE_AES_DECRYPT
+
+    #undef  HAVE_AESGCM
+    #define HAVE_AESGCM
+
+    /* GCM Method: GCM_SMALL, GCM_WORD32 or GCM_TABLE */
+    #undef  GCM_SMALL
+    #define GCM_SMALL
+
+    #undef  HAVE_AESCCM
+    #define HAVE_AESCCM
+
+    #undef  WOLFSSL_AES_COUNTER
+    #define WOLFSSL_AES_COUNTER
+
+    #undef  WOLFSSL_AES_DIRECT
+    #define WOLFSSL_AES_DIRECT
+#else
+    #define NO_AES
+#endif
+
+/* DES3 */
+#undef NO_DES3
+#if 1
+    #undef  WOLFSSL_DES_ECB
+    #define WOLFSSL_DES_ECB
+#else
+    #define NO_DES3
+#endif
+
+
+/* ChaCha20 / Poly1305 */
+#undef HAVE_CHACHA
+#undef HAVE_POLY1305
+#if 0
+    #define HAVE_CHACHA
+    #define HAVE_POLY1305
+
+    /* Needed for Poly1305 */
+    #undef  HAVE_ONE_TIME_AUTH
+    #define HAVE_ONE_TIME_AUTH
+#endif
+
+/* Ed25519 / Curve25519 */
+#undef HAVE_CURVE25519
+#undef HAVE_ED25519
+#if 0
+    #define HAVE_CURVE25519
+    #define HAVE_ED25519
+
+    /* Optionally use small math (less flash usage, but much slower) */
+    #if 0
+        #define CURVED25519_SMALL
+    #endif
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Hashing */
+/* ------------------------------------------------------------------------- */
+/* Sha */
+#undef NO_SHA
+#if 1
+    /* 1k smaller, but 25% slower */
+    //#define USE_SLOW_SHA
+#else
+    #define NO_SHA
+#endif
+
+/* Sha256 */
+#undef NO_SHA256
+#if 1
+#else
+    #define NO_SHA256
+#endif
+
+/* Sha512 */
+#undef WOLFSSL_SHA512
+#if 1
+    #define WOLFSSL_SHA512
+
+    /* Sha384 */
+    #undef  WOLFSSL_SHA384
+    #if 1
+        #define WOLFSSL_SHA384
+    #endif
+
+    /* over twice as small, but 50% slower */
+    //#define USE_SLOW_SHA2
+#endif
+
+/* MD5 */
+#undef  NO_MD5
+#if 1
+#else
+    #define NO_MD5
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Benchmark / Test */
+/* ------------------------------------------------------------------------- */
+/* Use reduced benchmark / test sizes */
+#undef  BENCH_EMBEDDED
+#define BENCH_EMBEDDED
+
+#undef  USE_CERT_BUFFERS_2048
+//#define USE_CERT_BUFFERS_2048
+
+#undef  USE_CERT_BUFFERS_1024
+#define USE_CERT_BUFFERS_1024
+
+#undef  USE_CERT_BUFFERS_256
+#define USE_CERT_BUFFERS_256
+
+
+/* ------------------------------------------------------------------------- */
+/* Time */
+/* ------------------------------------------------------------------------- */
+#if 0
+    /* Override Current Time */
+    /* Allows custom "custom_time()" function to be used for benchmark */
+    #define WOLFSSL_USER_CURRTIME
+    #define USER_TICKS
+    extern unsigned long custom_time(unsigned long* timer);
+    #define XTIME custom_time
+#else
+    #warning Time/RTC disabled
+    #undef  NO_ASN_TIME
+    #define NO_ASN_TIME
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* Debugging */
+/* ------------------------------------------------------------------------- */
+#undef  DEBUG_WOLFSSL
+#define DEBUG_WOLFSSL
+
+#ifdef DEBUG_WOLFSSL
+    /* Use this to measure / print heap usage */
+    #if 0
+        #undef  USE_WOLFSSL_MEMORY
+        #define USE_WOLFSSL_MEMORY
+        #undef  WOLFSSL_TRACK_MEMORY
+        #define WOLFSSL_TRACK_MEMORY
+    #endif
+#else
+    #undef  NO_WOLFSSL_MEMORY
+    #define NO_WOLFSSL_MEMORY
+
+    #undef  NO_ERROR_STRINGS
+    //#define NO_ERROR_STRINGS
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Enable Features */
+/* ------------------------------------------------------------------------- */
+#undef  KEEP_PEER_CERT
+//#define KEEP_PEER_CERT
+
+#undef  HAVE_COMP_KEY
+//#define HAVE_COMP_KEY
+
+#undef  HAVE_TLS_EXTENSIONS
+//#define HAVE_TLS_EXTENSIONS
+
+#undef  HAVE_SUPPORTED_CURVES
+//#define HAVE_SUPPORTED_CURVES
+
+#undef  WOLFSSL_BASE64_ENCODE
+//#define WOLFSSL_BASE64_ENCODE
+
+/* TLS Session Cache */
+#if 0
+    #define SMALL_SESSION_CACHE
+#else
+    #define NO_SESSION_CACHE
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+/* Disable Features */
+/* ------------------------------------------------------------------------- */
+#undef  NO_WOLFSSL_SERVER
+//#define NO_WOLFSSL_SERVER
+
+#undef  NO_WOLFSSL_CLIENT
+//#define NO_WOLFSSL_CLIENT
+
+#undef  NO_CRYPT_TEST
+//#define NO_CRYPT_TEST
+
+#undef  NO_CRYPT_BENCHMARK
+//#define NO_CRYPT_BENCHMARK
+
+/* In-lining of misc.c functions */
+/* If defined, must include wolfcrypt/src/misc.c in build */
+/* Slower, but about 1k smaller */
+#undef  NO_INLINE
+//#define NO_INLINE
+
+#undef  NO_FILESYSTEM
+#define NO_FILESYSTEM
+
+#undef  NO_WRITEV
+#define NO_WRITEV
+
+#undef  NO_MAIN_DRIVER
+#define NO_MAIN_DRIVER
+
+#undef  NO_DEV_RANDOM
+#define NO_DEV_RANDOM
+
+#undef  NO_DSA
+#define NO_DSA
+
+#undef  NO_DH
+#define NO_DH
+
+#undef  NO_RC4
+#define NO_RC4
+
+#undef  NO_OLD_TLS
+#define NO_OLD_TLS
+
+#undef  NO_HC128
+#define NO_HC128
+
+#undef  NO_RABBIT
+#define NO_RABBIT
+
+#undef  NO_PSK
+#define NO_PSK
+
+#undef  NO_MD4
+#define NO_MD4
+
+#undef  NO_PWDBASED
+#define NO_PWDBASED
+
+#undef  NO_CODING
+//#define NO_CODING
+
+
+/* Suppress array-bounds */
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WOLFSSL_USER_SETTINGS_H */

mplabx/wolfcrypt_benchmark.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -84,17 +85,16 @@
         <property key="enable-symbols" value="true"/>
         <property key="enable-unroll-loops" value="false"/>
         <property key="exclude-floating-point" value="false"/>
-        <property key="extra-include-directories" value="../../"/>
+        <property key="extra-include-directories" value="../../;../"/>
         <property key="generate-16-bit-code" value="false"/>
         <property key="generate-micro-compressed-code" value="false"/>
         <property key="isolate-each-function" value="false"/>
         <property key="make-warnings-into-errors" value="false"/>
-        <property key="optimization-level" value="-O1"/>
+        <property key="optimization-level" value="-O3"/>
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS"/>
-                  value="NO_MAIN_DRIVER;USE_CERT_BUFFERS_1024;BENCH_EMBEDDED;HAVE_ECC;WOLFSSL_SHA512"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>

mplabx/wolfcrypt_benchmark.X/nbproject/project.xml

@@ -8,7 +8,7 @@
             <make-project-type>0</make-project-type>
             <c-extensions>c</c-extensions>
             <cpp-extensions/>
-            <header-extensions/>
+            <header-extensions>h</header-extensions>
             <sourceEncoding>ISO-8859-1</sourceEncoding>
             <asminc-extensions/>
             <make-dep-projects>

mplabx/wolfcrypt_test.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -84,7 +85,7 @@
         <property key="enable-symbols" value="false"/>
         <property key="enable-unroll-loops" value="false"/>
         <property key="exclude-floating-point" value="false"/>
-        <property key="extra-include-directories" value="../../"/>
+        <property key="extra-include-directories" value="../../;../"/>
         <property key="generate-16-bit-code" value="false"/>
         <property key="generate-micro-compressed-code" value="false"/>
         <property key="isolate-each-function" value="false"/>
@@ -93,8 +94,7 @@
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS"/>
-                  value="NO_MAIN_DRIVER;USE_CERT_BUFFERS_1024;WOLFSSL_SHA384;WOLFSSL_SHA512;HAVE_ECC"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>
@@ -148,7 +148,7 @@
         <property key="preprocessor-macros" value=""/>
         <property key="remove-unused-sections" value="true"/>
         <property key="report-memory-usage" value="false"/>
-        <property key="stack-size" value=""/>
+        <property key="stack-size" value="20480"/>
         <property key="symbol-stripping" value=""/>
         <property key="trace-symbols" value=""/>
         <property key="warn-section-align" value="false"/>

mplabx/wolfcrypt_test.X/nbproject/project.xml

@@ -8,7 +8,7 @@
             <make-project-type>0</make-project-type>
             <c-extensions>c</c-extensions>
             <cpp-extensions/>
-            <header-extensions/>
+            <header-extensions>h</header-extensions>
             <sourceEncoding>ISO-8859-1</sourceEncoding>
             <asminc-extensions/>
             <make-dep-projects>

mplabx/wolfssl.X/nbproject/configurations.xml

@@ -4,6 +4,7 @@
     <logicalFolder name="HeaderFiles"
                    displayName="Header Files"
                    projectFiles="true">
+      <itemPath>../user_settings.h</itemPath>
     </logicalFolder>
     <logicalFolder name="LinkerScript"
                    displayName="Linker Files"
@@ -49,7 +50,7 @@
         <itemPath>../../wolfcrypt/src/sha512.c</itemPath>
         <itemPath>../../wolfcrypt/src/tfm.c</itemPath>
         <itemPath>../../wolfcrypt/src/wc_port.c</itemPath>
-        <itemPath>../../wolfcrypt/src/port/pic32/pic32mz-hash.c</itemPath>
+        <itemPath>../../wolfcrypt/src/port/pic32/pic32mz-crypt.c</itemPath>
         <itemPath>../../wolfcrypt/src/hash.c</itemPath>
         <itemPath>../../wolfcrypt/src/chacha20_poly1305.c</itemPath>
         <itemPath>../../wolfcrypt/src/curve25519.c</itemPath>
@@ -59,6 +60,10 @@
         <itemPath>../../wolfcrypt/src/ge_low_mem.c</itemPath>
         <itemPath>../../wolfcrypt/src/ge_operations.c</itemPath>
         <itemPath>../../wolfcrypt/src/wc_encrypt.c</itemPath>
+        <itemPath>../../wolfcrypt/src/pkcs12.c</itemPath>
+        <itemPath>../../wolfcrypt/src/signature.c</itemPath>
+        <itemPath>../../wolfcrypt/src/wolfevent.c</itemPath>
+        <itemPath>../../wolfcrypt/src/wolfmath.c</itemPath>
       </logicalFolder>
       <logicalFolder name="f1" displayName="wolfssl" projectFiles="true">
         <itemPath>../../src/crl.c</itemPath>
@@ -69,6 +74,7 @@
         <itemPath>../../src/sniffer.c</itemPath>
         <itemPath>../../src/ssl.c</itemPath>
         <itemPath>../../src/tls.c</itemPath>
+        <itemPath>../../src/tls13.c</itemPath>
       </logicalFolder>
     </logicalFolder>
     <logicalFolder name="ExternalFiles"
@@ -126,7 +132,7 @@
         <property key="enable-symbols" value="false"/>
         <property key="enable-unroll-loops" value="false"/>
         <property key="exclude-floating-point" value="false"/>
-        <property key="extra-include-directories" value="../../;..\"/>
+        <property key="extra-include-directories" value="../../;../"/>
         <property key="generate-16-bit-code" value="false"/>
         <property key="generate-micro-compressed-code" value="false"/>
         <property key="isolate-each-function" value="false"/>
@@ -135,8 +141,7 @@
         <property key="place-data-into-section" value="false"/>
         <property key="post-instruction-scheduling" value="default"/>
         <property key="pre-instruction-scheduling" value="default"/>
-        <property key="preprocessor-macros"
+        <property key="preprocessor-macros" value="WOLFSSL_USER_SETTINGS"/>
-                  value="WOLFSSL_SHA512;WOLFSSL_SHA384;HAVE_ECC"/>
         <property key="strict-ansi" value="false"/>
         <property key="support-ansi" value="false"/>
         <property key="use-cci" value="false"/>

mplabx/wolfssl.X/nbproject/project.xml

@@ -8,7 +8,7 @@
             <make-project-type>0</make-project-type>
             <c-extensions>c</c-extensions>
             <cpp-extensions/>
-            <header-extensions/>
+            <header-extensions>h</header-extensions>
             <sourceEncoding>ISO-8859-1</sourceEncoding>
             <asminc-extensions/>
             <make-dep-projects/>

wolfcrypt/benchmark/benchmark.c

@@ -2737,7 +2737,7 @@ exit_rsa_pub:
 #endif
 
     /* capture resulting encrypt length */
-    idx = RSA_BUF_SIZE; /* fixed at 2048 bit */
+    idx = rsaKeySz/8;
 
     /* begin private async RSA */
     bench_stats_start(&count, &start);
@@ -3676,10 +3676,10 @@ exit_ed_verify:
     #if defined(WOLFSSL_MICROCHIP_PIC32MZ)
         #define CLOCK 80000000.0
     #else
-        #include <peripheral/timer.h>
         #define CLOCK 40000000.0
     #endif
-
+    extern void WriteCoreTimer(word32 t);
+    extern word32 ReadCoreTimer(void);
     double current_time(int reset)
     {
         unsigned int ns;

wolfcrypt/src/aes.c

@@ -583,9 +583,27 @@
     #endif /* HAVE_AES_DECRYPT */
 
 #elif defined(WOLFSSL_PIC32MZ_CRYPT)
-    /* NOTE: no support for AES-CCM/Direct */
+
-    #define DEBUG_WOLFSSL
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
-    #include "wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h"
+
+    #if defined(HAVE_AESGCM) || defined(WOLFSSL_AES_DIRECT)
+
+    static int wc_AesEncrypt(Aes* aes, const byte* inBlock, byte* outBlock)
+    {
+        return wc_Pic32AesCrypt(aes->key_ce, aes->keylen, NULL, 0,
+            outBlock, inBlock, AES_BLOCK_SIZE,
+            PIC32_ENCRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_RECB);
+    }
+
+    #ifdef HAVE_AES_DECRYPT
+    static int wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
+    {
+        return wc_Pic32AesCrypt(aes->key_ce, aes->keylen, NULL, 0,
+            outBlock, inBlock, AES_BLOCK_SIZE,
+            PIC32_DECRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_RECB);
+    }
+    #endif /* HAVE_AES_DECRYPT */
+    #endif
 
 #elif defined(WOLFSSL_NRF51_AES)
     /* Use built-in AES hardware - AES 128 ECB Encrypt Only */
@@ -1563,8 +1581,7 @@ static void wc_AesEncrypt(Aes* aes, const byte* inBlock, byte* outBlock)
 }
 #endif /* HAVE_AES_CBC || WOLFSSL_AES_DIRECT || HAVE_AESGCM */
 
-
+#if defined(HAVE_AES_DECRYPT)
-#ifdef HAVE_AES_DECRYPT
 #if defined(HAVE_AES_CBC) || defined(WOLFSSL_AES_DIRECT)
 
 /* load 4 Td Tables into cache by cache line stride */
@@ -1757,8 +1774,9 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
     XMEMCPY(outBlock + 2 * sizeof(s0), &s2, sizeof(s2));
     XMEMCPY(outBlock + 3 * sizeof(s0), &s3, sizeof(s3));
 }
-#endif /* HAVE_AES_DECRYPT */
 #endif /* HAVE_AES_CBC || WOLFSSL_AES_DIRECT */
+#endif /* HAVE_AES_DECRYPT */
+
 #endif /* NEED_AES_TABLES */
 
 
@@ -1948,8 +1966,11 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
     static int wc_AesSetKeyLocal(Aes* aes, const byte* userKey, word32 keylen,
                 const byte* iv, int dir)
     {
-        word32 temp, *rk = aes->key;
+        word32 *rk = aes->key;
+    #ifdef NEED_AES_TABLES
+        word32 temp;
         unsigned int i = 0;
+    #endif
 
     #ifdef WOLFSSL_AESNI
         aes->use_aesni = 0;
@@ -1959,7 +1980,7 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
     #endif /* WOLFSSL_AES_COUNTER */
 
         aes->keylen = keylen;
-        aes->rounds = keylen/4 + 6;
+        aes->rounds = (keylen/4) + 6;
 
         XMEMCPY(rk, userKey, keylen);
     #ifdef LITTLE_ENDIAN_ORDER
@@ -1967,20 +1988,13 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
     #endif
 
     #ifdef WOLFSSL_PIC32MZ_CRYPT
-        {
+        XMEMCPY((word32*)aes->key_ce, userKey, keylen);
-            word32 *akey1 = aes->key_ce;
-            word32 *areg = aes->iv_ce;
-            XMEMCPY(akey1, userKey, keylen);
-            if (iv)
-                XMEMCPY(areg, iv, AES_BLOCK_SIZE);
-            else
-                XMEMSET(areg,  0, AES_BLOCK_SIZE);
-        }
     #endif
 
-        switch(keylen)
+#ifdef NEED_AES_TABLES
-        {
+
-#if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 128
+        switch (keylen) {
+    #if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 128
         case 16:
             while (1)
             {
@@ -1999,9 +2013,9 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
                 rk += 4;
             }
             break;
-#endif /* 128 */
+    #endif /* 128 */
 
-#if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 192
+    #if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 192
         case 24:
             /* for (;;) here triggers a bug in VC60 SP4 w/ Pro Pack */
             while (1)
@@ -2023,9 +2037,9 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
                 rk += 6;
             }
             break;
-#endif /* 192 */
+    #endif /* 192 */
 
-#if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 256
+    #if defined(AES_MAX_KEY_SIZE) && AES_MAX_KEY_SIZE >= 256
         case 32:
             while (1)
             {
@@ -2054,15 +2068,14 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
                 rk += 8;
             }
             break;
-#endif /* 256 */
+    #endif /* 256 */
 
         default:
             return BAD_FUNC_ARG;
-        }
+        } /* switch */
 
-#ifdef HAVE_AES_DECRYPT
+    #ifdef HAVE_AES_DECRYPT
-        if (dir == AES_DECRYPTION)
+        if (dir == AES_DECRYPTION) {
-        {
             unsigned int j;
             rk = aes->key;
 
@@ -2099,9 +2112,10 @@ static void wc_AesDecrypt(Aes* aes, const byte* inBlock, byte* outBlock)
                     Td[3][Te[1][GETBYTE(rk[3], 0)] & 0xff];
             }
         }
-#else
+    #else
         (void)dir;
-#endif /* HAVE_AES_DECRYPT */
+    #endif /* HAVE_AES_DECRYPT */
+#endif /* NEED_AES_TABLES */
 
         return wc_AesSetIV(aes, iv);
     }
@@ -2180,6 +2194,10 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
     else
         XMEMSET(aes->reg,  0, AES_BLOCK_SIZE);
 
+#ifdef WOLFSSL_PIC32MZ_CRYPT
+    XMEMCPY(aes->iv_ce, aes->reg, AES_BLOCK_SIZE);
+#endif
+
     return 0;
 }
 
@@ -2188,9 +2206,6 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
     #if defined(HAVE_COLDFIRE_SEC)
         #error "Coldfire SEC doesn't yet support AES direct"
 
-    #elif defined(WOLFSSL_PIC32MZ_CRYPT)
-        #error "PIC32MZ doesn't yet support AES direct"
-
     #elif defined(FREESCALE_LTC)
         /* Allow direct access to one block encrypt */
         void wc_AesEncryptDirect(Aes* aes, byte* out, const byte* in)
@@ -2767,116 +2782,26 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
     #endif /* HAVE_AES_DECRYPT */
 
 #elif defined(WOLFSSL_PIC32MZ_CRYPT)
-    /* core hardware crypt engine driver */
-    static void wc_AesCrypt(Aes *aes, byte* out, const byte* in, word32 sz,
-                                            int dir, int algo, int cryptoalgo)
-    {
-        securityAssociation *sa_p;
-        bufferDescriptor *bd_p;
-        volatile securityAssociation sa __attribute__((aligned (8)));
-        volatile bufferDescriptor bd __attribute__((aligned (8)));
-        volatile int k;
-
-        /* get uncached address */
-        sa_p = KVA0_TO_KVA1(&sa);
-        bd_p = KVA0_TO_KVA1(&bd);
-
-        /* Sync cache and physical memory */
-        if (PIC32MZ_IF_RAM(in)) {
-            XMEMCPY((void *)KVA0_TO_KVA1(in), (void *)in, sz);
-        }
-        XMEMSET((void *)KVA0_TO_KVA1(out), 0, sz);
-        /* Set up the Security Association */
-        XMEMSET((byte *)KVA0_TO_KVA1(&sa), 0, sizeof(sa));
-        sa_p->SA_CTRL.ALGO = algo; /* AES */
-        sa_p->SA_CTRL.LNC = 1;
-        sa_p->SA_CTRL.LOADIV = 1;
-        sa_p->SA_CTRL.FB = 1;
-        sa_p->SA_CTRL.ENCTYPE = dir; /* Encryption/Decryption */
-        sa_p->SA_CTRL.CRYPTOALGO = cryptoalgo;
-
-        if (cryptoalgo == PIC32_CRYPTOALGO_AES_GCM) {
-            switch(aes->keylen) {
-                case 32:
-                    sa_p->SA_CTRL.KEYSIZE = PIC32_AES_KEYSIZE_256;
-                    break;
-                case 24:
-                    sa_p->SA_CTRL.KEYSIZE = PIC32_AES_KEYSIZE_192;
-                    break;
-                case 16:
-                    sa_p->SA_CTRL.KEYSIZE = PIC32_AES_KEYSIZE_128;
-                    break;
-            }
-        } else
-            sa_p->SA_CTRL.KEYSIZE = PIC32_AES_KEYSIZE_128;
-
-        ByteReverseWords(
-        (word32 *)KVA0_TO_KVA1(sa.SA_ENCKEY + 8 - aes->keylen/sizeof(word32)),
-                         (word32 *)aes->key_ce, aes->keylen);
-        ByteReverseWords(
-        (word32*)KVA0_TO_KVA1(sa.SA_ENCIV), (word32 *)aes->iv_ce, 16);
-
-        XMEMSET((byte *)KVA0_TO_KVA1(&bd), 0, sizeof(bd));
-        /* Set up the Buffer Descriptor */
-        bd_p->BD_CTRL.BUFLEN = sz;
-        if (cryptoalgo == PIC32_CRYPTOALGO_AES_GCM) {
-            if(sz % 0x10)
-                bd_p->BD_CTRL.BUFLEN = (sz/0x10 + 1) * 0x10;
-        }
-        bd_p->BD_CTRL.LIFM = 1;
-        bd_p->BD_CTRL.SA_FETCH_EN = 1;
-        bd_p->BD_CTRL.LAST_BD = 1;
-        bd_p->BD_CTRL.DESC_EN = 1;
-
-        bd_p->SA_ADDR = (unsigned int)KVA_TO_PA(&sa);
-        bd_p->SRCADDR = (unsigned int)KVA_TO_PA(in);
-        bd_p->DSTADDR = (unsigned int)KVA_TO_PA(out);
-        bd_p->MSGLEN = sz;
-
-        CECON = 1 << 6;
-        while (CECON);
-
-        /* Run the engine */
-        CEBDPADDR = (unsigned int)KVA_TO_PA(&bd);
-        CEINTEN = 0x07;
-        CECON = 0x27;
-
-        WAIT_ENGINE;
-
-        if((cryptoalgo == PIC32_CRYPTOALGO_CBC) ||
-           (cryptoalgo == PIC32_CRYPTOALGO_TCBC)||
-           (cryptoalgo == PIC32_CRYPTOALGO_RCBC)) {
-            /* set iv for the next call */
-            if (dir == PIC32_ENCRYPTION) {
-                XMEMCPY((void *)aes->iv_ce,
-                        (void*)KVA0_TO_KVA1(out + sz - AES_BLOCK_SIZE),
-                        AES_BLOCK_SIZE);
-            } else {
-                ByteReverseWords((word32*)aes->iv_ce,
-                        (word32 *)KVA0_TO_KVA1(in + sz - AES_BLOCK_SIZE),
-                        AES_BLOCK_SIZE);
-            }
-        }
-        XMEMCPY((byte *)out, (byte *)KVA0_TO_KVA1(out), sz);
-        ByteReverseWords((word32*)out, (word32 *)out, sz);
-    }
 
     int wc_AesCbcEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
     {
-        wc_AesCrypt(aes, out, in, sz, PIC32_ENCRYPTION, PIC32_ALGO_AES,
+        return wc_Pic32AesCrypt(
-                                                      PIC32_CRYPTOALGO_RCBC );
+            aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
-        return 0;
+            out, in, sz, PIC32_ENCRYPTION,
+            PIC32_ALGO_AES, PIC32_CRYPTOALGO_RCBC);
     }
     #ifdef HAVE_AES_DECRYPT
     int wc_AesCbcDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
     {
-        wc_AesCrypt(aes, out, in, sz, PIC32_DECRYPTION, PIC32_ALGO_AES,
+        return wc_Pic32AesCrypt(
-                                                      PIC32_CRYPTOALGO_RCBC);
+            aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
-        return 0;
+            out, in, sz, PIC32_DECRYPTION,
+            PIC32_ALGO_AES, PIC32_CRYPTOALGO_RCBC);
     }
     #endif /* HAVE_AES_DECRYPT */
 
 #else
+
     int wc_AesCbcEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
     {
         word32 blocks = (sz / AES_BLOCK_SIZE);
@@ -3226,67 +3151,76 @@ int wc_AesEcbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
         #endif /* WOLFSSL_STM32_CUBEMX */
 
     #elif defined(WOLFSSL_PIC32MZ_CRYPT)
+        static void Pic32AesIncIV(Aes* aes) {
+            int i;
+            for (i = AES_BLOCK_SIZE - 1; i >= 0; i--) {
+                if (++((byte *)aes->iv_ce)[i])
+                    break;
+            }
+        }
         int wc_AesCtrEncrypt(Aes* aes, byte* out, const byte* in, word32 sz)
         {
-            int i;
+            int ret = 0;
-            char out_block[AES_BLOCK_SIZE];
+            byte out_block[AES_BLOCK_SIZE];
-            int odd;
+            int odd, even, blocks;
-            int even;
+            byte *tmp;
-            char *tmp; /* (char *)aes->tmp, for short */
             
             if (aes == NULL || out == NULL || in == NULL) {
                 return BAD_FUNC_ARG;
             }
 
-            tmp = (char *)aes->tmp;
+            tmp = (byte *)aes->tmp;
-            if(aes->left) {
+            if (aes->left) {
-                if((aes->left + sz) >= AES_BLOCK_SIZE){
+                if ((aes->left + sz) >= AES_BLOCK_SIZE) {
                     odd = AES_BLOCK_SIZE - aes->left;
                 } else {
                     odd = sz;
                 }
-                XMEMCPY(tmp+aes->left, in, odd);
+                XMEMCPY(tmp + aes->left, in, odd);
-                if((odd+aes->left) == AES_BLOCK_SIZE){
+                if ((odd + aes->left) == AES_BLOCK_SIZE) {
-                    wc_AesCrypt(aes, out_block, tmp, AES_BLOCK_SIZE,
+                    ret = wc_Pic32AesCrypt(
+                        aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
+                        out_block, tmp, AES_BLOCK_SIZE,
                         PIC32_ENCRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_RCTR);
-                    XMEMCPY(out, out_block+aes->left, odd);
+                    XMEMCPY(out, out_block + aes->left, odd);
                     aes->left = 0;
                     XMEMSET(tmp, 0x0, AES_BLOCK_SIZE);
-                    /* Increment IV */
+                    Pic32AesIncIV(aes);
-                    for (i = AES_BLOCK_SIZE - 1; i >= 0; i--) {
-                        if (++((byte *)aes->iv_ce)[i])
-                            break;
-                    }
                 }
                 in += odd;
                 out+= odd;
                 sz -= odd;
             }
-            odd = sz % AES_BLOCK_SIZE;  /* if there is tail fragment */
+
-            if(sz / AES_BLOCK_SIZE) {
+            blocks = sz / AES_BLOCK_SIZE;
-                even = (sz/AES_BLOCK_SIZE)*AES_BLOCK_SIZE;
+            if (blocks) {
-                wc_AesCrypt(aes, out, in, even, PIC32_ENCRYPTION, PIC32_ALGO_AES,
+                even = blocks * AES_BLOCK_SIZE;
-                                                        PIC32_CRYPTOALGO_RCTR);
+                ret = wc_Pic32AesCrypt(
+                    aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
+                    out, in, even,
+                    PIC32_ENCRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_RCTR);
                 out += even;
                 in  += even;
-                do {  /* Increment IV */
+                do {
-                    for (i = AES_BLOCK_SIZE - 1; i >= 0; i--) {
+                    Pic32AesIncIV(aes);
-                        if (++((byte *)aes->iv_ce)[i])
-                            break;
-                    }
                     even -= AES_BLOCK_SIZE;
-                } while((int)even > 0);
+                } while (even > 0);
             }
-            if(odd) {
+
-                XMEMSET(tmp+aes->left, 0x0, AES_BLOCK_SIZE - aes->left);
+            /* if there is tail fragment */
-                XMEMCPY(tmp+aes->left, in, odd);
+            odd = sz % AES_BLOCK_SIZE;
-                wc_AesCrypt(aes, out_block, tmp, AES_BLOCK_SIZE,
+            if (odd) {
+                XMEMSET(tmp + aes->left, 0x0, AES_BLOCK_SIZE - aes->left);
+                XMEMCPY(tmp + aes->left, in, odd);
+                ret = wc_Pic32AesCrypt(
+                    aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
+                    out_block, tmp, AES_BLOCK_SIZE,
                     PIC32_ENCRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_RCTR);
-                XMEMCPY(out, out_block+aes->left,odd);
+                XMEMCPY(out, out_block + aes->left, odd);
                 aes->left += odd;
             }
 
-            return 0;
+            return ret;
         }
 
     #elif defined(HAVE_COLDFIRE_SEC)
@@ -7180,12 +7114,7 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
     }
 #endif
 
-#ifdef WOLFSSL_PIC32MZ_CRYPT
-    ctr = (char *)aes->iv_ce;
-#else
     ctr = counter;
-#endif
-
     XMEMSET(initialCounter, 0, AES_BLOCK_SIZE);
     if (ivSz == NONCE_SZ) {
         XMEMCPY(initialCounter, iv, ivSz);
@@ -7198,8 +7127,15 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
 
 #ifdef WOLFSSL_PIC32MZ_CRYPT
     if (blocks) {
-        wc_AesCrypt(aes, out, in, blocks * AES_BLOCK_SIZE,
+        /* use intitial IV for PIC32 HW, but don't use it below */
+        XMEMCPY(aes->iv_ce, ctr, AES_BLOCK_SIZE);
+
+        ret = wc_Pic32AesCrypt(
+            aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
+            out, in, (blocks * AES_BLOCK_SIZE),
             PIC32_ENCRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_AES_GCM);
+        if (ret != 0)
+            return ret;
     }
     /* process remainder using partial handling */
 #endif
@@ -7443,12 +7379,7 @@ int  wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
     }
 #endif
 
-#ifdef WOLFSSL_PIC32MZ_CRYPT
-    ctr = (char *)aes->iv_ce;
-#else
     ctr = counter;
-#endif
-
     XMEMSET(initialCounter, 0, AES_BLOCK_SIZE);
     if (ivSz == NONCE_SZ) {
         XMEMCPY(initialCounter, iv, ivSz);
@@ -7470,8 +7401,15 @@ int  wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
 
 #ifdef WOLFSSL_PIC32MZ_CRYPT
     if (blocks) {
-        wc_AesCrypt(aes, out, in, blocks * AES_BLOCK_SIZE,
+        /* use intitial IV for PIC32 HW, but don't use it below */
+        XMEMCPY(aes->iv_ce, ctr, AES_BLOCK_SIZE);
+
+        ret = wc_Pic32AesCrypt(
+            aes->key_ce, aes->keylen, aes->iv_ce, AES_BLOCK_SIZE,
+            out, in, (blocks * AES_BLOCK_SIZE),
             PIC32_DECRYPTION, PIC32_ALGO_AES, PIC32_CRYPTOALGO_AES_GCM);
+        if (ret != 0)
+            return ret;
     }
     /* process remainder using partial handling */
 #endif
@@ -7523,27 +7461,83 @@ WOLFSSL_API int wc_GmacUpdate(Gmac* gmac, const byte* iv, word32 ivSz,
 
 #ifdef HAVE_AESCCM
 
+int wc_AesCcmSetKey(Aes* aes, const byte* key, word32 keySz)
+{
+    return wc_AesSetKey(aes, key, keySz, NULL, AES_ENCRYPTION);
+}
+
 #if defined(HAVE_COLDFIRE_SEC)
     #error "Coldfire SEC doesn't currently support AES-CCM mode"
 
-#elif defined(WOLFSSL_PIC32MZ_CRYPT)
+#elif defined(FREESCALE_LTC)
-    #error "PIC32MZ doesn't currently support AES-CCM mode"
 
-#endif
+/* return 0 on success */
-
+int wc_AesCcmEncrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
-int wc_AesCcmSetKey(Aes* aes, const byte* key, word32 keySz)
+                   const byte* nonce, word32 nonceSz,
+                   byte* authTag, word32 authTagSz,
+                   const byte* authIn, word32 authInSz)
 {
-    byte nonce[AES_BLOCK_SIZE];
+    byte *key;
+    uint32_t keySize;
+    status_t status;
 
-    if (!((keySz == 16) || (keySz == 24) || (keySz == 32)))
+    /* sanity check on arguments */
+    if (aes == NULL || out == NULL || in == NULL || nonce == NULL
+            || authTag == NULL || nonceSz < 7 || nonceSz > 13)
         return BAD_FUNC_ARG;
 
-    XMEMSET(nonce, 0, sizeof(nonce));
+    key = (byte*)aes->key;
-    return wc_AesSetKey(aes, key, keySz, nonce, AES_ENCRYPTION);
+
+    status = wc_AesGetKeySize(aes, &keySize);
+    if (status != 0) {
+        return status;
+    }
+
+    status = LTC_AES_EncryptTagCcm(LTC_BASE, in, out, inSz,
+        nonce, nonceSz, authIn, authInSz, key, keySize, authTag, authTagSz);
+
+    return (kStatus_Success == status) ? 0 : BAD_FUNC_ARG;
 }
 
+#ifdef HAVE_AES_DECRYPT
+int  wc_AesCcmDecrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
+                   const byte* nonce, word32 nonceSz,
+                   const byte* authTag, word32 authTagSz,
+                   const byte* authIn, word32 authInSz)
+{
+    byte *key;
+    uint32_t keySize;
+    status_t status;
+
+    /* sanity check on arguments */
+    if (aes == NULL || out == NULL || in == NULL || nonce == NULL
+            || authTag == NULL || nonceSz < 7 || nonceSz > 13)
+        return BAD_FUNC_ARG;
+
+    key = (byte*)aes->key;
+
+    status = wc_AesGetKeySize(aes, &keySize);
+    if (status != 0) {
+        return status;
+    }
+
+    status = LTC_AES_DecryptTagCcm(LTC_BASE, in, out, inSz,
+        nonce, nonceSz, authIn, authInSz, key, keySize, authTag, authTagSz);
+
+    if (status == kStatus_Success) {
+        return 0;
+    }
+    else {
+        XMEMSET(out, 0, inSz);
+        return AES_CCM_AUTH_E;
+    }
+}
+#endif /* HAVE_AES_DECRYPT */
+
+
+/* software AES CCM */
+#else
 
-#ifndef FREESCALE_LTC
 static void roll_x(Aes* aes, const byte* in, word32 inSz, byte* out)
 {
     /* process the bulk of the data */
@@ -7562,7 +7556,6 @@ static void roll_x(Aes* aes, const byte* in, word32 inSz, byte* out)
     }
 }
 
-
 static void roll_auth(Aes* aes, const byte* in, word32 inSz, byte* out)
 {
     word32 authLenSz;
@@ -7616,7 +7609,6 @@ static INLINE void AesCcmCtrInc(byte* B, word32 lenSz)
         if (++B[AES_BLOCK_SIZE - 1 - i] != 0) return;
     }
 }
-#endif /* !FREESCALE_LTC */
 
 /* return 0 on success */
 int wc_AesCcmEncrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
@@ -7624,29 +7616,12 @@ int wc_AesCcmEncrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
                    byte* authTag, word32 authTagSz,
                    const byte* authIn, word32 authInSz)
 {
-#ifdef FREESCALE_LTC
-    byte *key;
-    uint32_t keySize;
-    status_t status;
-
-    key = (byte*)aes->key;
-
-    status = wc_AesGetKeySize(aes, &keySize);
-    if (status != 0) {
-        return status;
-    }
-
-    status = LTC_AES_EncryptTagCcm(LTC_BASE, in, out, inSz,
-        nonce, nonceSz, authIn, authInSz, key, keySize, authTag, authTagSz);
-
-    return (kStatus_Success == status) ? 0 : BAD_FUNC_ARG;
-#else
     byte A[AES_BLOCK_SIZE];
     byte B[AES_BLOCK_SIZE];
     byte lenSz;
     word32 i;
     byte mask = 0xFF;
-    word32 wordSz = (word32)sizeof(word32);
+    const word32 wordSz = (word32)sizeof(word32);
 
     /* sanity check on arguments */
     if (aes == NULL || out == NULL || in == NULL || nonce == NULL
@@ -7699,7 +7674,6 @@ int wc_AesCcmEncrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
     ForceZero(B, AES_BLOCK_SIZE);
 
     return 0;
-#endif /* FREESCALE_LTC */
 }
 
 #ifdef HAVE_AES_DECRYPT
@@ -7708,30 +7682,6 @@ int  wc_AesCcmDecrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
                    const byte* authTag, word32 authTagSz,
                    const byte* authIn, word32 authInSz)
 {
-#ifdef FREESCALE_LTC
-    byte *key;
-    uint32_t keySize;
-    status_t status;
-
-    key = (byte*)aes->key;
-
-    status = wc_AesGetKeySize(aes, &keySize);
-    if (status != 0) {
-        return status;
-    }
-
-    status = LTC_AES_DecryptTagCcm(LTC_BASE, in, out, inSz,
-        nonce, nonceSz, authIn, authInSz, key, keySize, authTag, authTagSz);
-
-    if (status == kStatus_Success) {
-        return 0;
-    }
-    else {
-        XMEMSET(out, 0, inSz);
-        return AES_CCM_AUTH_E;
-    }
-#else /* FREESCALE_LTC */
-
     byte A[AES_BLOCK_SIZE];
     byte B[AES_BLOCK_SIZE];
     byte* o;
@@ -7739,7 +7689,7 @@ int  wc_AesCcmDecrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
     word32 i, oSz;
     int result = 0;
     byte mask = 0xFF;
-    word32 wordSz = (word32)sizeof(word32);
+    const word32 wordSz = (word32)sizeof(word32);
 
     /* sanity check on arguments */
     if (aes == NULL || out == NULL || in == NULL || nonce == NULL
@@ -7814,9 +7764,10 @@ int  wc_AesCcmDecrypt(Aes* aes, byte* out, const byte* in, word32 inSz,
     o = NULL;
 
     return result;
-#endif /* FREESCALE_LTC */
 }
 #endif /* HAVE_AES_DECRYPT */
+#endif /* software AES CCM */
+
 #endif /* HAVE_AESCCM */
 
 

wolfcrypt/src/des3.c

@@ -658,7 +658,7 @@
         return 0;
 
     }
-#elif (defined FREESCALE_LTC_DES)
+#elif defined(FREESCALE_LTC_DES)
 
     #include "fsl_ltc.h"
     int wc_Des_SetKey(Des* des, const byte* key, const byte* iv, int dir)
@@ -744,6 +744,7 @@
             return -1;
 
     }
+
 #elif defined(FREESCALE_MMCAU)
     /*
      * Freescale mmCAU hardware DES/3DES support through the CAU/mmCAU library.
@@ -1010,139 +1011,105 @@
 
 #elif defined(WOLFSSL_PIC32MZ_CRYPT)
 
-    #include "wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h"
+    /* PIC32MZ DES hardware requires size multiple of block size */
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
 
     int wc_Des_SetKey(Des* des, const byte* key, const byte* iv, int dir)
     {
-        word32 *dkey = des->key;
+        if (des == NULL || key == NULL || iv == NULL)
-        word32 *dreg = des->reg;
+            return BAD_FUNC_ARG;
 
-        XMEMCPY((byte *)dkey, (byte *)key, 8);
+        XMEMCPY(des->key, key, DES_KEYLEN);
-        ByteReverseWords(dkey, dkey, 8);
+        XMEMCPY(des->reg, iv, DES_IVLEN);
-        XMEMCPY((byte *)dreg, (byte *)iv, 8);
-        ByteReverseWords(dreg, dreg, 8);
 
         return 0;
     }
 
     int wc_Des3_SetKey(Des3* des, const byte* key, const byte* iv, int dir)
     {
-        word32 *dkey1 = des->key[0];
+        if (des == NULL || key == NULL || iv == NULL)
-        word32 *dreg = des->reg;
+            return BAD_FUNC_ARG;
 
-        XMEMCPY(dkey1, key, 24);
+        XMEMCPY(des->key[0], key, DES3_KEYLEN);
-        ByteReverseWords(dkey1, dkey1, 24);
+        XMEMCPY(des->reg, iv, DES3_IVLEN);
-        XMEMCPY(dreg, iv, 8);
-        ByteReverseWords(dreg, dreg, 8);
 
         return 0;
     }
 
-    void DesCrypt(word32 *key, word32 *iv, byte* out, const byte* in, word32 sz,
-                  int dir, int algo, int cryptoalgo)
-    {
-        securityAssociation *sa_p;
-        bufferDescriptor *bd_p;
-        const byte *in_p, *in_l;
-        byte *out_p, *out_l;
-        volatile securityAssociation sa __attribute__((aligned (8)));
-        volatile bufferDescriptor bd __attribute__((aligned (8)));
-        volatile int k;
-
-        /* get uncached address */
-
-        in_l = in;
-        out_l = out;
-        sa_p = KVA0_TO_KVA1(&sa);
-        bd_p = KVA0_TO_KVA1(&bd);
-        in_p = KVA0_TO_KVA1(in_l);
-        out_p= KVA0_TO_KVA1(out_l);
-
-        if(PIC32MZ_IF_RAM(in_p))
-            XMEMCPY((void *)in_p, (void *)in, sz);
-        XMEMSET((void *)out_p, 0, sz);
-
-        /* Set up the Security Association */
-        XMEMSET((byte *)KVA0_TO_KVA1(&sa), 0, sizeof(sa));
-        sa_p->SA_CTRL.ALGO = algo;
-        sa_p->SA_CTRL.LNC = 1;
-        sa_p->SA_CTRL.LOADIV = 1;
-        sa_p->SA_CTRL.FB = 1;
-        sa_p->SA_CTRL.ENCTYPE = dir; /* Encryption/Decryption */
-        sa_p->SA_CTRL.CRYPTOALGO = cryptoalgo;
-        sa_p->SA_CTRL.KEYSIZE = 1; /* KEY is 192 bits */
-        XMEMCPY((byte *)KVA0_TO_KVA1(&sa.SA_ENCKEY[algo==PIC32_ALGO_TDES ? 2 : 6]),
-                (byte *)key, algo==PIC32_ALGO_TDES ? 24 : 8);
-        XMEMCPY((byte *)KVA0_TO_KVA1(&sa.SA_ENCIV[2]), (byte *)iv, 8);
-
-        XMEMSET((byte *)KVA0_TO_KVA1(&bd), 0, sizeof(bd));
-        /* Set up the Buffer Descriptor */
-        bd_p->BD_CTRL.BUFLEN = sz;
-        bd_p->BD_CTRL.LIFM = 1;
-        bd_p->BD_CTRL.SA_FETCH_EN = 1;
-        bd_p->BD_CTRL.LAST_BD = 1;
-        bd_p->BD_CTRL.DESC_EN = 1;
-
-        bd_p->SA_ADDR = (unsigned int)KVA_TO_PA(&sa); /* (unsigned int)sa_p; */
-        bd_p->SRCADDR = (unsigned int)KVA_TO_PA(in); /* (unsigned int)in_p; */
-        bd_p->DSTADDR = (unsigned int)KVA_TO_PA(out); /* (unsigned int)out_p; */
-        bd_p->NXTPTR = (unsigned int)KVA_TO_PA(&bd);
-        bd_p->MSGLEN = sz;
-
-        /* Fire in the hole! */
-        CECON = 1 << 6;
-        while (CECON);
-
-        /* Run the engine */
-        CEBDPADDR = (unsigned int)KVA_TO_PA(&bd); /* (unsigned int)bd_p; */
-        CEINTEN = 0x07;
-        CECON = 0x27;
-
-        WAIT_ENGINE;
-
-        if((cryptoalgo == PIC32_CRYPTOALGO_CBC) ||
-           (cryptoalgo == PIC32_CRYPTOALGO_TCBC)||
-           (cryptoalgo == PIC32_CRYPTOALGO_RCBC)) {
-            /* set iv for the next call */
-            if(dir == PIC32_ENCRYPTION) {
-	            XMEMCPY((void *)iv, (void*)&(out_p[sz-DES_IVLEN]), DES_IVLEN);
-	        } else {
-                ByteReverseWords((word32*)iv, (word32 *)&(in_p[sz-DES_IVLEN]),
-                                 DES_IVLEN);
-            }
-        }
-
-        ByteReverseWords((word32*)out, (word32 *)KVA0_TO_KVA1(out), sz);
-    }
-
     int wc_Des_CbcEncrypt(Des* des, byte* out, const byte* in, word32 sz)
     {
-        DesCrypt(des->key, des->reg, out, in, sz,
+        word32 blocks = sz / DES_BLOCK_SIZE;
-                PIC32_ENCRYPTION, PIC32_ALGO_DES, PIC32_CRYPTOALGO_CBC );
+
-        return 0;
+        if (des == NULL || out == NULL || in == NULL)
+            return BAD_FUNC_ARG;
+
+        return wc_Pic32DesCrypt(des->key, DES_KEYLEN, des->reg, DES_IVLEN,
+            out, in, (blocks * DES_BLOCK_SIZE),
+            PIC32_ENCRYPTION, PIC32_ALGO_DES, PIC32_CRYPTOALGO_CBC);
     }
 
     int wc_Des_CbcDecrypt(Des* des, byte* out, const byte* in, word32 sz)
     {
-        DesCrypt(des->key, des->reg, out, in, sz,
+        word32 blocks = sz / DES_BLOCK_SIZE;
+
+        if (des == NULL || out == NULL || in == NULL)
+            return BAD_FUNC_ARG;
+
+        return wc_Pic32DesCrypt(des->key, DES_KEYLEN, des->reg, DES_IVLEN,
+            out, in, (blocks * DES_BLOCK_SIZE),
             PIC32_DECRYPTION, PIC32_ALGO_DES, PIC32_CRYPTOALGO_CBC);
-        return 0;
     }
 
     int wc_Des3_CbcEncrypt(Des3* des, byte* out, const byte* in, word32 sz)
     {
-        DesCrypt(des->key[0], des->reg, out, in, sz,
+        word32 blocks = sz / DES_BLOCK_SIZE;
+
+        if (des == NULL || out == NULL || in == NULL)
+            return BAD_FUNC_ARG;
+
+        return wc_Pic32DesCrypt(des->key[0], DES3_KEYLEN, des->reg, DES3_IVLEN,
+            out, in, (blocks * DES_BLOCK_SIZE),
             PIC32_ENCRYPTION, PIC32_ALGO_TDES, PIC32_CRYPTOALGO_TCBC);
-        return 0;
     }
 
     int wc_Des3_CbcDecrypt(Des3* des, byte* out, const byte* in, word32 sz)
     {
-        DesCrypt(des->key[0], des->reg, out, in, sz,
+        word32 blocks = sz / DES_BLOCK_SIZE;
+
+        if (des == NULL || out == NULL || in == NULL)
+            return BAD_FUNC_ARG;
+
+        return wc_Pic32DesCrypt(des->key[0], DES3_KEYLEN, des->reg, DES3_IVLEN,
+            out, in, (blocks * DES_BLOCK_SIZE),
             PIC32_DECRYPTION, PIC32_ALGO_TDES, PIC32_CRYPTOALGO_TCBC);
-        return 0;
     }
 
+    #ifdef WOLFSSL_DES_ECB
+        int wc_Des_EcbEncrypt(Des* des, byte* out, const byte* in, word32 sz)
+        {
+            word32 blocks = sz / DES_BLOCK_SIZE;
+
+            if (des == NULL || out == NULL || in == NULL)
+                return BAD_FUNC_ARG;
+
+            return wc_Pic32DesCrypt(des->key, DES_KEYLEN, des->reg, DES_IVLEN,
+                out, in, (blocks * DES_BLOCK_SIZE),
+                    PIC32_ENCRYPTION, PIC32_ALGO_DES, PIC32_CRYPTOALGO_ECB);
+        }
+
+        int wc_Des3_EcbEncrypt(Des3* des, byte* out, const byte* in, word32 sz)
+        {
+            word32 blocks = sz / DES_BLOCK_SIZE;
+
+            if (des == NULL || out == NULL || in == NULL)
+                return BAD_FUNC_ARG;
+
+            return wc_Pic32DesCrypt(des->key[0], DES3_KEYLEN, des->reg, DES3_IVLEN,
+                out, in, (blocks * DES_BLOCK_SIZE),
+                PIC32_ENCRYPTION, PIC32_ALGO_TDES, PIC32_CRYPTOALGO_TECB);
+        }
+    #endif /* WOLFSSL_DES_ECB */
+
 #else
     #define NEED_SOFT_DES
 
@@ -1706,8 +1673,6 @@
         int wc_Des3_EcbEncrypt(Des3* des, byte* out, const byte* in, word32 sz)
         {
             word32 blocks = sz / DES_BLOCK_SIZE;
-            /* printf("wc_Des3_EcbEncrypt(%016x, %016x, %d)\n",
-                *(unsigned long *)in, *(unsigned long *)out, sz) ; */
 
             if (des == NULL || out == NULL || in == NULL) {
                 return BAD_FUNC_ARG;

wolfcrypt/src/ecc.c

@@ -97,6 +97,7 @@ ECC Curve Sizes:
 #include <wolfssl/wolfcrypt/asn.h>
 #include <wolfssl/wolfcrypt/error-crypt.h>
 #include <wolfssl/wolfcrypt/logging.h>
+#include <wolfssl/wolfcrypt/types.h>
 
 #ifdef HAVE_ECC_ENCRYPT
     #include <wolfssl/wolfcrypt/hmac.h>

wolfcrypt/src/hmac.c

@@ -103,20 +103,7 @@
 #else /* else build without fips */
 
 
-#ifdef WOLFSSL_PIC32MZ_HASH
+#include <wolfssl/wolfcrypt/error-crypt.h>
-    #define wc_InitMd5   wc_InitMd5_sw
-    #define wc_Md5Update wc_Md5Update_sw
-    #define wc_Md5Final  wc_Md5Final_sw
-
-    #define wc_InitSha   wc_InitSha_sw
-    #define wc_ShaUpdate wc_ShaUpdate_sw
-    #define wc_ShaFinal  wc_ShaFinal_sw
-
-    #define wc_InitSha256   wc_InitSha256_sw
-    #define wc_Sha256Update wc_Sha256Update_sw
-    #define wc_Sha256Final  wc_Sha256Final_sw
-#endif /* WOLFSSL_PIC32MZ_HASH */
-
 
 
 int wc_HmacSizeByType(int type)

wolfcrypt/src/include.am

@@ -47,7 +47,7 @@ EXTRA_DIST += wolfcrypt/src/port/ti/ti-aes.c \
               wolfcrypt/src/port/ti/ti-des3.c \
               wolfcrypt/src/port/ti/ti-hash.c \
               wolfcrypt/src/port/ti/ti-ccm.c \
-              wolfcrypt/src/port/pic32/pic32mz-hash.c \
+              wolfcrypt/src/port/pic32/pic32mz-crypt.c \
               wolfcrypt/src/port/nrf51.c \
               wolfcrypt/src/port/arm/armv8-aes.c \
               wolfcrypt/src/port/arm/armv8-sha256.c \

wolfcrypt/src/md5.c

@@ -36,6 +36,7 @@
 
 #include <wolfssl/wolfcrypt/md5.h>
 #include <wolfssl/wolfcrypt/error-crypt.h>
+#include <wolfssl/wolfcrypt/logging.h>
 
 #ifdef NO_INLINE
     #include <wolfssl/wolfcrypt/misc.h>
@@ -185,11 +186,8 @@
     }
 
 #elif defined(WOLFSSL_PIC32MZ_HASH)
-    #define wc_InitMd5   wc_InitMd5_sw
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
-    #define wc_Md5Update wc_Md5Update_sw
+    #define HAVE_MD5_CUST_API
-    #define wc_Md5Final  wc_Md5Final_sw
-
-    #define NEED_SOFT_MD5
 
 #else
     #define NEED_SOFT_MD5
@@ -421,19 +419,21 @@ int wc_Md5Final(Md5* md5, byte* hash)
     }
     XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen);
 
+#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
+    ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
+#endif
+
     /* put lengths in bits */
     md5->hiLen = (md5->loLen >> (8*sizeof(md5->loLen) - 3)) +
                  (md5->hiLen << 3);
     md5->loLen = md5->loLen << 3;
 
     /* store lengths */
-#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
-    ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
-#endif
     /* ! length ordering dependent on digest endian type ! */
     XMEMCPY(&local[MD5_PAD_SIZE], &md5->loLen, sizeof(word32));
     XMEMCPY(&local[MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32));
 
+    /* final transform and result to hash */
     XTRANSFORM(md5, local);
 #ifdef BIG_ENDIAN_ORDER
     ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE);

wolfcrypt/src/port/pic32/pic32mz-crypt.c

@@ -0,0 +1,508 @@
+/* pic32mz-crypt.c
+ *
+ * Copyright (C) 2006-2016 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+
+#ifdef HAVE_CONFIG_H
+    #include <config.h>
+#endif
+
+#include <wolfssl/wolfcrypt/settings.h>
+
+#ifdef WOLFSSL_MICROCHIP_PIC32MZ
+
+#ifdef NO_INLINE
+    #include <wolfssl/wolfcrypt/misc.h>
+#else
+    #define WOLFSSL_MISC_INCLUDED
+    #include <wolfcrypt/src/misc.c>
+#endif
+
+#include <wolfssl/wolfcrypt/logging.h>
+#include <wolfssl/wolfcrypt/error-crypt.h>
+
+#include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
+
+#ifdef WOLFSSL_PIC32MZ_CRYPT
+#include <wolfssl/wolfcrypt/aes.h>
+#include <wolfssl/wolfcrypt/des3.h>
+#endif
+
+#ifdef WOLFSSL_PIC32MZ_HASH
+#include <wolfssl/wolfcrypt/md5.h>
+#include <wolfssl/wolfcrypt/sha.h>
+#include <wolfssl/wolfcrypt/sha256.h>
+#endif
+
+
+#if defined(WOLFSSL_PIC32MZ_CRYPT) || defined(WOLFSSL_PIC32MZ_HASH)
+
+static int Pic32GetBlockSize(int algo)
+{
+    switch (algo) {
+        case PIC32_ALGO_HMAC1:
+            return PIC32_BLOCKSIZE_HMAC;
+        case PIC32_ALGO_SHA256:
+            return PIC32_BLOCKSIZE_SHA256;
+        case PIC32_ALGO_SHA1:
+            return PIC32_BLOCKSIZE_SHA1;
+        case PIC32_ALGO_MD5:
+            return PIC32_BLOCKSIZE_MD5;
+        case PIC32_ALGO_AES:
+            return PIC32_BLOCKSIZE_AES;
+        case PIC32_ALGO_TDES:
+            return PIC32_BLOCKSIZE_TDES;
+        case PIC32_ALGO_DES:
+            return PIC32_BLOCKSIZE_DES;
+    }
+    return 0;
+}
+
+static int Pic32Crypto(const byte* in, int inLen, word32* out, int outLen,
+    int dir, int algo, int cryptoalgo,
+
+    /* For DES/AES only */
+    word32* key, int keyLen, word32* iv, int ivLen)
+{
+    int ret = 0;
+    int blockSize = Pic32GetBlockSize(algo);
+    volatile bufferDescriptor bd __attribute__((aligned (8)));
+    securityAssociation sa __attribute__((aligned (8)));
+    securityAssociation *sa_p;
+    bufferDescriptor *bd_p;
+    byte *in_p;
+    byte *out_p;
+    word32* dst;
+    word32 padRemain;
+    int timeout = 0xFFFFFF;
+
+    /* check args */
+    if (in == NULL || inLen <= 0 || out == NULL || blockSize == 0) {
+        return BAD_FUNC_ARG;
+    }
+
+    /* check pointer alignment - must be word aligned */
+    if (((size_t)in % sizeof(word32)) || ((size_t)out % sizeof(word32))) {
+        return BUFFER_E; /* buffer is not aligned */
+    }
+
+    /* get uncached address */
+    sa_p = KVA0_TO_KVA1(&sa);
+    bd_p = KVA0_TO_KVA1(&bd);
+    out_p= KVA0_TO_KVA1(out);
+
+    if (in) {
+        in_p = KVA0_TO_KVA1(in);
+
+        /* Sync cache if in physical memory (not flash) */
+        if (PIC32MZ_IF_RAM(in_p)) {
+            XMEMCPY(in_p, in, inLen);
+        }
+    }
+
+    /* Set up the Security Association */
+    XMEMSET(sa_p, 0, sizeof(sa));
+    sa_p->SA_CTRL.ALGO = algo;
+    sa_p->SA_CTRL.ENCTYPE = dir;
+    sa_p->SA_CTRL.FB = 1; /* first block */
+    sa_p->SA_CTRL.LNC = 1; /* Load new set of keys */
+    if (key) {
+        /* cipher */
+        sa_p->SA_CTRL.CRYPTOALGO = cryptoalgo;
+
+        switch (keyLen) {
+            case 32:
+                sa_p->SA_CTRL.KEYSIZE = PIC32_KEYSIZE_256;
+                break;
+            case 24:
+            case 8: /* DES */
+                sa_p->SA_CTRL.KEYSIZE = PIC32_KEYSIZE_192;
+                break;
+            case 16:
+                sa_p->SA_CTRL.KEYSIZE = PIC32_KEYSIZE_128;
+                break;
+        }
+
+        dst = (word32*)KVA0_TO_KVA1(sa.SA_ENCKEY +
+            (sizeof(sa.SA_ENCKEY)/sizeof(word32)) - (keyLen/sizeof(word32)));
+        ByteReverseWords(dst, key, keyLen);
+
+        if (iv && ivLen > 0) {
+            sa_p->SA_CTRL.LOADIV = 1;
+            dst = (word32*)KVA0_TO_KVA1(sa.SA_ENCIV +
+                (sizeof(sa.SA_ENCIV)/sizeof(word32)) - (ivLen/sizeof(word32)));
+            ByteReverseWords(dst, iv, ivLen);
+        }
+    }
+    else {
+        /* hashing */
+        sa_p->SA_CTRL.LOADIV = 1;
+        sa_p->SA_CTRL.IRFLAG = 0; /* immediate result for hashing */
+
+        dst = (word32*)KVA0_TO_KVA1(sa.SA_AUTHIV +
+            (sizeof(sa.SA_AUTHIV)/sizeof(word32)) - (outLen/sizeof(word32)));
+        ByteReverseWords(dst, out, outLen);
+    }
+
+    /* Set up the Buffer Descriptor */
+    XMEMSET(bd_p, 0, sizeof(bd));
+    bd_p->BD_CTRL.BUFLEN = inLen;
+    padRemain = (inLen % 4); /* make sure buffer is 4-byte multiple */
+    if (padRemain != 0) {
+        bd_p->BD_CTRL.BUFLEN += (4 - padRemain);
+    }
+    bd_p->BD_CTRL.SA_FETCH_EN = 1; /* Fetch the security association */
+    bd_p->BD_CTRL.PKT_INT_EN = 1;  /* enable interrupt */
+    bd_p->BD_CTRL.LAST_BD = 1;     /* last buffer desc in chain */
+    bd_p->BD_CTRL.LIFM = 1;        /* last in frame */
+    bd_p->SA_ADDR = (unsigned int)KVA_TO_PA(&sa);
+    bd_p->SRCADDR = (unsigned int)KVA_TO_PA(in);
+    if (key) {
+        /* cipher */
+        if (in != (byte*)out)
+            XMEMSET(out_p, 0, outLen); /* clear output buffer */
+        bd_p->DSTADDR = (unsigned int)KVA_TO_PA(out);
+    }
+    else {
+        /* hashing */
+        /* digest result returned in UPDPTR */
+        bd_p->UPDPTR = (unsigned int)KVA_TO_PA(out);
+    }
+    bd_p->NXTPTR = (unsigned int)KVA_TO_PA(&bd);
+    bd_p->MSGLEN = inLen;          /* actual message size */
+    bd_p->BD_CTRL.DESC_EN = 1;     /* enable this descriptor */
+
+    /* begin access to hardware */
+    ret = wolfSSL_CryptHwMutexLock();
+    if (ret == 0) {
+        /* Software Reset the Crypto Engine */
+        CECON = 1 << 6;
+        while (CECON);
+
+        /* Run the engine */
+        CEBDPADDR = (unsigned int)KVA_TO_PA(&bd);
+        CEINTEN = 0x07; /* enable DMA Packet Completion Interrupt */
+
+        /* input swap, enable BD fetch and start DMA */
+    #if PIC32_NO_OUT_SWAP
+        CECON = 0x25;
+    #else
+        CECON = 0xa5; /* bit 7 = enable out swap */
+    #endif
+
+        /* wait for operation to complete */
+        while (CEINTSRCbits.PKTIF == 0 && --timeout > 0) {};
+
+        /* Clear the interrupt flags */
+        CEINTSRC = 0xF;
+
+        /* check for errors */
+        if (CESTATbits.ERROP || timeout <= 0) {
+        #if 1
+            printf("PIC32 Crypto: ERROP %x, ERRPHASE %x, TIMEOUT %d\n",
+                CESTATbits.ERROP, CESTATbits.ERRPHASE, timeout);
+        #endif
+            ret = ASYNC_OP_E;
+        }
+
+        wolfSSL_CryptHwMutexUnLock();
+
+        if (iv && ivLen > 0) {
+            /* set iv for the next call */
+            if (dir == PIC32_ENCRYPTION) {
+                XMEMCPY(iv, KVA0_TO_KVA1(out + (outLen - ivLen)), ivLen);
+            #if !PIC32_NO_OUT_SWAP
+                /* hardware already swapped output, so we need to swap back */
+                ByteReverseWords(iv, iv, ivLen);
+            #endif
+            }
+            else {
+                ByteReverseWords(iv, KVA0_TO_KVA1(in + (inLen - ivLen)), ivLen);
+            }
+        }
+
+        if (outLen > 0) {
+            /* copy result to output */
+        #if PIC32_NO_OUT_SWAP
+            /* swap bytes */
+            ByteReverseWords(out, (word32*)out_p, outLen);
+        #else
+            /* sync cache */
+            #ifdef _SYS_DEVCON_LOCAL_H
+                SYS_DEVCON_DataCacheInvalidate((word32)out, outLen);
+            #else
+                XMEMCPY(out, out_p, outLen);
+            #endif
+        #endif
+        }
+        else {
+            /* sync cache */
+        #if PIC32_NO_OUT_SWAP
+            /* swap bytes */
+            ByteReverseWords(out, (word32*)out_p, PIC32_DIGEST_SIZE);
+        #else
+            /* sync cache */
+            #ifdef _SYS_DEVCON_LOCAL_H
+                SYS_DEVCON_DataCacheInvalidate((word32)out, PIC32_DIGEST_SIZE);
+            #else
+                XMEMCPY(out, out_p, PIC32_DIGEST_SIZE);
+            #endif
+        #endif
+        }
+    }
+
+    return ret;
+}
+#endif /* WOLFSSL_PIC32MZ_CRYPT || WOLFSSL_PIC32MZ_HASH */
+
+#ifdef WOLFSSL_PIC32MZ_HASH
+int wc_Pic32Hash(const byte* in, int inLen, word32* out, int outLen, int algo)
+{
+    return Pic32Crypto(in, inLen, out, outLen, PIC32_ENCRYPTION, algo, 0,
+        NULL, 0, NULL, 0);
+}
+
+static int wc_Pic32HashUpdate(hashUpdCache* cache, byte* stdBuf, word32 stdBufLen,
+ const byte* data, word32 len, void* heap)
+{
+    /* cache updates */
+    word32 newLenUpd, newLenPad, padRemain;
+    byte* newBuf;
+    int isNewBuf = 0;
+
+    /* calculate new len */
+    newLenUpd = cache->updLen + len;
+
+    /* calculate padded len - pad buffer at 64-bytes for hardware */
+    newLenPad = newLenUpd;
+    padRemain = (newLenUpd % PIC32_BLOCKSIZE_HASH);
+    if (padRemain != 0) {
+        newLenPad += (PIC32_BLOCKSIZE_HASH - padRemain);
+    }
+
+    /* determine buffer source */
+    if (newLenPad <= stdBufLen) {
+        /* use standard buffer */
+        newBuf = stdBuf;
+    }
+    else if (newLenPad > cache->bufLen) {
+        /* alloc buffer */
+        newBuf = (byte*)XMALLOC(newLenPad, heap, DYNAMIC_TYPE_HASH_TMP);
+        if (newBuf == NULL) {
+            if (cache->buf != stdBuf) {
+                XFREE(cache->buf, heap, DYNAMIC_TYPE_HASH_TMP);
+            }
+            return MEMORY_E;
+        }
+        isNewBuf = 1;
+    }
+    else {
+        /* use existing buffer */
+        newBuf = cache->buf;
+    }
+    if (cache->buf && cache->updLen > 0) {
+        XMEMCPY(newBuf, cache->buf, cache->updLen);
+        if (isNewBuf && cache->buf != stdBuf) {
+            XFREE(cache->buf, heap, DYNAMIC_TYPE_HASH_TMP);
+        }
+    }
+    XMEMCPY(newBuf + cache->updLen, data, len);
+
+    cache->buf = newBuf;
+    cache->updLen = newLenUpd;
+    cache->bufLen = newLenPad;
+
+    return 0;
+}
+
+static int wc_Pic32HashFinal(hashUpdCache* cache, byte* stdBuf, byte* hash,
+    int digestSz, int algo, void* heap)
+{
+    int ret;
+    word32 digest[PIC32_DIGEST_SIZE / sizeof(word32)] = {0};
+
+    /* if room add the pad */
+    if (cache->updLen < cache->bufLen) {
+        cache->buf[cache->updLen] = 0x80;
+    }
+
+    ret = wc_Pic32Hash(cache->buf, cache->updLen, digest, digestSz, algo);
+    if (ret == 0) {
+        XMEMCPY(hash, digest, digestSz);
+    }
+    if (cache->buf != stdBuf) {
+        XFREE(cache->buf, heap, DYNAMIC_TYPE_HASH_TMP);
+    }
+    cache->buf = NULL;
+    cache->bufLen = 0;
+    cache->updLen = 0;
+
+    return ret;
+}
+
+/* API's for compatability with Harmony wrappers - not used */
+#ifndef NO_MD5
+    int wc_InitMd5_ex(Md5* md5, void* heap, int devId)
+    {
+        if (md5 == NULL)
+            return BAD_FUNC_ARG;
+
+        XMEMSET(md5, 0, sizeof(Md5));
+        md5->heap = heap;
+        (void)devId;
+        return 0;
+    }
+
+    int wc_Md5Update(Md5* md5, const byte* data, word32 len)
+    {
+        if (md5 == NULL || (data == NULL && len > 0))
+            return BAD_FUNC_ARG;
+        return wc_Pic32HashUpdate(&md5->cache, (byte*)md5->buffer,
+            sizeof(md5->buffer), data, len, md5->heap);
+    }
+
+    int wc_Md5Final(Md5* md5, byte* hash)
+    {
+        int ret;
+
+        if (md5 == NULL || hash == NULL)
+            return BAD_FUNC_ARG;
+
+        ret = wc_Pic32HashFinal(&md5->cache, (byte*)md5->buffer,
+            hash, MD5_DIGEST_SIZE, PIC32_ALGO_MD5, md5->heap);
+
+        wc_InitMd5_ex(md5, md5->heap, INVALID_DEVID);  /* reset state */
+
+        return ret;
+    }
+
+    void wc_Md5SizeSet(Md5* md5, word32 len)
+    {
+        (void)md5;
+        (void)len;
+    }
+#endif /* !NO_MD5 */
+#ifndef NO_SHA
+    int wc_InitSha_ex(Sha* sha, void* heap, int devId)
+    {
+        if (sha == NULL)
+            return BAD_FUNC_ARG;
+
+        XMEMSET(sha, 0, sizeof(Sha));
+        sha->heap = heap;
+        (void)devId;
+        return 0;
+    }
+
+    int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
+    {
+        if (sha == NULL || (data == NULL && len > 0))
+            return BAD_FUNC_ARG;
+        return wc_Pic32HashUpdate(&sha->cache, (byte*)sha->buffer,
+            sizeof(sha->buffer), data, len, sha->heap);
+    }
+
+    int wc_ShaFinal(Sha* sha, byte* hash)
+    {
+        int ret;
+
+        if (sha == NULL || hash == NULL)
+            return BAD_FUNC_ARG;
+
+        ret = wc_Pic32HashFinal(&sha->cache, (byte*)sha->buffer,
+            hash, SHA_DIGEST_SIZE, PIC32_ALGO_SHA1, sha->heap);
+
+        wc_InitSha_ex(sha, sha->heap, INVALID_DEVID);  /* reset state */
+
+        return ret;
+    }
+    void wc_ShaSizeSet(Sha* sha, word32 len)
+    {
+        (void)sha;
+        (void)len;
+    }
+#endif /* !NO_SHA */
+#ifndef NO_SHA256
+    int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
+    {
+        if (sha256 == NULL)
+            return BAD_FUNC_ARG;
+
+        XMEMSET(sha256, 0, sizeof(Sha256));
+        sha256->heap = heap;
+        (void)devId;
+        return 0;
+    }
+
+    int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
+    {
+        if (sha256 == NULL || (data == NULL && len > 0))
+            return BAD_FUNC_ARG;
+        return wc_Pic32HashUpdate(&sha256->cache, (byte*)sha256->buffer,
+            sizeof(sha256->buffer), data, len, sha256->heap);
+    }
+
+    int wc_Sha256Final(Sha256* sha256, byte* hash)
+    {
+        int ret;
+
+        if (sha256 == NULL || hash == NULL)
+            return BAD_FUNC_ARG;
+
+        ret = wc_Pic32HashFinal(&sha256->cache, (byte*)sha256->buffer,
+            hash, SHA256_DIGEST_SIZE, PIC32_ALGO_SHA256, sha256->heap);
+
+        wc_InitSha256_ex(sha256, sha256->heap, INVALID_DEVID);  /* reset state */
+
+        return ret;
+    }
+
+    void wc_Sha256SizeSet(Sha256* sha256, word32 len)
+    {
+        (void)sha256;
+        (void)len;
+    }
+#endif /* !NO_SHA256 */
+#endif
+
+
+#ifdef WOLFSSL_PIC32MZ_CRYPT
+#if !defined(NO_AES)
+    int wc_Pic32AesCrypt(word32 *key, int keyLen, word32 *iv, int ivLen,
+        byte* out, const byte* in, word32 sz,
+        int dir, int algo, int cryptoalgo)
+    {
+        return Pic32Crypto(in, sz, (word32*)out, sz, dir, algo, cryptoalgo,
+            key, keyLen, iv, ivLen);
+    }
+#endif /* !NO_AES */
+
+#ifndef NO_DES3
+    int wc_Pic32DesCrypt(word32 *key, int keyLen, word32 *iv, int ivLen,
+        byte* out, const byte* in, word32 sz,
+        int dir, int algo, int cryptoalgo)
+    {
+        return Pic32Crypto(in, sz, (word32*)out, sz, dir, algo, cryptoalgo,
+            key, keyLen, iv, ivLen);
+    }
+#endif /* !NO_DES3 */
+#endif /* WOLFSSL_PIC32MZ_CRYPT */
+
+#endif /* WOLFSSL_MICROCHIP_PIC32MZ */

wolfcrypt/src/port/pic32/pic32mz-hash.c

@@ -1,357 +0,0 @@
-/* pic32mz-hash.c
- *
- * Copyright (C) 2006-2016 wolfSSL Inc.
- *
- * This file is part of wolfSSL.
- *
- * wolfSSL is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * wolfSSL is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
- */
-
-
-#ifdef HAVE_CONFIG_H
-    #include <config.h>
-#endif
-
-#include <wolfssl/wolfcrypt/settings.h>
-
-#ifdef WOLFSSL_PIC32MZ_HASH
-
-#include <wolfssl/wolfcrypt/logging.h>
-#include <wolfssl/wolfcrypt/md5.h>
-#include <wolfssl/wolfcrypt/sha.h>
-#include <wolfssl/wolfcrypt/sha256.h>
-
-#include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
-
-#if !defined(NO_MD5) && !defined(NO_SHA) && !defined(NO_SHA256)
-
-static uint8_t dataBuffer[PIC32MZ_MAX_BD][PIC32_BLOCK_SIZE] __attribute__((aligned (4), coherent));
-
-static void reset_engine(pic32mz_desc *desc, int algo)
-{
-    int i;
-    pic32mz_desc* uc_desc = KVA0_TO_KVA1(desc);
-
-    CECON = 1 << 6;
-    while (CECON);
-
-    /* Make sure everything is clear first before we make settings. */
-    XMEMSET((void *)&uc_desc->sa, 0, sizeof(uc_desc->sa));
-
-    /* Set up the security association */
-    uc_desc->sa.SA_CTRL.ALGO = algo ;
-    uc_desc->sa.SA_CTRL.LNC = 1;
-    uc_desc->sa.SA_CTRL.FB = 1;
-    uc_desc->sa.SA_CTRL.ENCTYPE = 1;
-    uc_desc->sa.SA_CTRL.LOADIV = 1;
-
-    /* Set up the buffer descriptor */
-    uc_desc->err = 0 ;
-    for (i = 0; i < PIC32MZ_MAX_BD; i++)
-    {
-        XMEMSET((void *)&uc_desc->bd[i], 0, sizeof(uc_desc->bd[i]));
-        uc_desc->bd[i].BD_CTRL.LAST_BD = 1;
-        uc_desc->bd[i].BD_CTRL.LIFM = 1;
-        uc_desc->bd[i].BD_CTRL.PKT_INT_EN = 1;
-        uc_desc->bd[i].SA_ADDR = KVA_TO_PA(&uc_desc->sa);
-        uc_desc->bd[i].SRCADDR = KVA_TO_PA(&dataBuffer[i]);
-        if (PIC32MZ_MAX_BD > i+1)
-            uc_desc->bd[i].NXTPTR = KVA_TO_PA(&uc_desc->bd[i+1]);
-        else
-            uc_desc->bd[i].NXTPTR = KVA_TO_PA(&uc_desc->bd[0]);
-        XMEMSET((void *)&dataBuffer[i], 0, PIC32_BLOCK_SIZE);
-    }
-    uc_desc->bd[0].BD_CTRL.SA_FETCH_EN = 1; /* Fetch the security association on the first BD */
-    desc->dbPtr = 0;
-    desc->currBd = 0;
-    desc->msgSize = 0;
-    desc->processed = 0;
-    CEBDPADDR = KVA_TO_PA(&(desc->bd[0]));
-
-    CEPOLLCON = 10;
-
-    CECON = 0x27;
-}
-
-#define PIC32MZ_IF_RAM(addr) (KVA_TO_PA(addr) < 0x80000)
-
-static void update_engine(pic32mz_desc *desc, const byte *input, word32 len,
-                    word32 *hash)
-{
-   int total ;
-    pic32mz_desc    *uc_desc = KVA0_TO_KVA1(desc);
-
-    uc_desc->bd[desc->currBd].UPDPTR = KVA_TO_PA(hash);
-    /* Add the data to the current buffer. If the buffer fills, start processing it
-       and fill the next one. */
-    while (len)
-    {
-        /* If the engine is processing the current BD, spin.
-        if (uc_desc->bd[desc->currBd].BD_CTRL.DESC_EN)
-            continue; */
-        if (desc->msgSize)
-        {
-            /* If we've been given the message size, we can process along the
-               way.
-               Enable the current buffer descriptor if it is full. */
-            if (desc->dbPtr >= PIC32_BLOCK_SIZE)
-            {
-                /* Wrap up the buffer descriptor and enable it so the engine can process */
-                uc_desc->bd[desc->currBd].MSGLEN = desc->msgSize;
-                uc_desc->bd[desc->currBd].BD_CTRL.BUFLEN = desc->dbPtr;
-                uc_desc->bd[desc->currBd].BD_CTRL.LAST_BD = 0;
-                uc_desc->bd[desc->currBd].BD_CTRL.LIFM = 0;
-                /* SYS_DEVCON_DataCacheClean((word32)desc, sizeof(pic32mz_desc)); */
-                uc_desc->bd[desc->currBd].BD_CTRL.DESC_EN = 1;
-                /* Move to the next buffer descriptor, or wrap around. */
-                desc->currBd++;
-                if (desc->currBd >= PIC32MZ_MAX_BD)
-                    desc->currBd = 0;
-                /* Wait until the engine has processed the new BD. */
-                while (uc_desc->bd[desc->currBd].BD_CTRL.DESC_EN);
-                uc_desc->bd[desc->currBd].UPDPTR = KVA_TO_PA(hash);
-                desc->dbPtr = 0;
-            }
-            if (!PIC32MZ_IF_RAM(input)) /* If we're inputting from flash, let the BD have 
-                                         the address and max the buffer size */
-            {
-                uc_desc->bd[desc->currBd].SRCADDR = KVA_TO_PA(input);
-                total = (len > PIC32MZ_MAX_BLOCK ? PIC32MZ_MAX_BLOCK : len);
-                desc->dbPtr = total;
-                len -= total;
-                input += total;
-            }
-            else
-            {
-                if (len > PIC32_BLOCK_SIZE - desc->dbPtr)
-                {
-                    /* We have more data than can be put in the buffer. Fill what we can.*/
-                    total = PIC32_BLOCK_SIZE - desc->dbPtr;
-                    XMEMCPY(&dataBuffer[desc->currBd][desc->dbPtr], input, total);
-                    len -= total;
-                    desc->dbPtr = PIC32_BLOCK_SIZE;
-                    input += total;
-                }
-                else
-                {
-                    /* Fill up what we have, but don't turn on the engine.*/
-                    XMEMCPY(&dataBuffer[desc->currBd][desc->dbPtr], input, len);
-                    desc->dbPtr += len;
-                    len = 0;
-                }
-            }
-        }
-        else
-        {
-            /* We have to buffer everything and keep track of how much has been
-               added in order to get a total size. If the buffer fills, we move
-               to the next one. If we try to add more when the last buffer is
-               full, we error out. */
-            if (desc->dbPtr == PIC32_BLOCK_SIZE)
-            {
-                /* We filled the last BD buffer, so move on to the next one */
-                uc_desc->bd[desc->currBd].BD_CTRL.LAST_BD = 0;
-                uc_desc->bd[desc->currBd].BD_CTRL.LIFM = 0;
-                uc_desc->bd[desc->currBd].BD_CTRL.BUFLEN = PIC32_BLOCK_SIZE;
-                desc->currBd++;
-                uc_desc->bd[desc->currBd].UPDPTR = KVA_TO_PA(hash);
-                desc->dbPtr = 0;
-                if (desc->currBd >= PIC32MZ_MAX_BD)
-                {
-                    desc->err = 1;
-                }
-            }
-            if (len > PIC32_BLOCK_SIZE - desc->dbPtr)
-            {
-                /* We have more data than can be put in the buffer. Fill what we can. */
-                total = PIC32_BLOCK_SIZE - desc->dbPtr;
-                XMEMCPY(&dataBuffer[desc->currBd][desc->dbPtr], input, total);
-                len -= total;
-                desc->processed += total;
-                desc->dbPtr = PIC32_BLOCK_SIZE;
-                input += total;
-            }
-            else
-            {
-                /* Fill up what we have */
-                XMEMCPY(&dataBuffer[desc->currBd][desc->dbPtr], input, len);
-                desc->dbPtr += len;
-                desc->processed += len;
-                len = 0;
-            }
-        }
-    }
-}
-
-static void start_engine(pic32mz_desc *desc) {
-    /* Wrap up the last buffer descriptor and enable it */
-    int i ;
-    int bufferLen ;
-    pic32mz_desc *uc_desc = KVA0_TO_KVA1(desc);
-
-    bufferLen = desc->dbPtr;
-    if (bufferLen % 4)
-        bufferLen = (bufferLen + 4) - (bufferLen % 4);
-    uc_desc->bd[desc->currBd].BD_CTRL.BUFLEN = bufferLen;
-    uc_desc->bd[desc->currBd].BD_CTRL.LAST_BD = 1;
-    uc_desc->bd[desc->currBd].BD_CTRL.LIFM = 1;
-    if (desc->msgSize == 0)
-    {
-        /* We were not given the size, so now we have to go through every BD
-           and give it what will be processed, and enable them. */
-        for (i = desc->currBd; i >= 0; i--)
-        {
-            uc_desc->bd[i].MSGLEN = desc->processed;
-            uc_desc->bd[i].BD_CTRL.DESC_EN = 1;
-        }
-    }
-    else
-    {
-        uc_desc->bd[desc->currBd].BD_CTRL.DESC_EN = 1;
-    }
-}
-
-void wait_engine(pic32mz_desc *desc, char *hash, int hash_sz) {
-    unsigned int i;
-    unsigned int *intptr;
-    pic32mz_desc *uc_desc = KVA0_TO_KVA1(desc);
-    enum {true = 1, false = 0} engineRunning = true;
-
-    while (engineRunning)
-    {
-        engineRunning = false;
-        for (i = 0; i < PIC32MZ_MAX_BD; i++)
-            engineRunning = engineRunning || uc_desc->bd[i].BD_CTRL.DESC_EN;
-    }
-    XMEMCPY(hash, KVA0_TO_KVA1(hash), hash_sz) ;
-
-    #ifdef DEBUG_CYASSL
-    print_mem(KVA0_TO_KVA1(hash), hash_sz) ;
-    print_mem(             hash , hash_sz) ;
-    #endif
-    for (i = 0, intptr = (unsigned int *)hash; i < hash_sz/sizeof(unsigned int);
-                                                                  i++, intptr++)
-    {
-        *intptr = ntohl(*intptr);
-    }
-}
-
-#endif
-
-#ifndef NO_MD5
-void wc_InitMd5(Md5* md5)
-{
-    WOLFSSL_ENTER("InitMd5\n") ;
-    XMEMSET((void *)md5, 0xcc, sizeof(Md5)) ;
-    XMEMSET((void *)KVA0_TO_KVA1(md5), 0xcc, sizeof(Md5)) ;
-    reset_engine(&(md5->desc), PIC32_ALGO_MD5) ;
-
-}
-
-void wc_Md5Update(Md5* md5, const byte* data, word32 len)
-{
-     WOLFSSL_ENTER("Md5Update\n") ;
-     update_engine(&(md5->desc), data, len, md5->digest) ;
-}
-
-void wc_Md5Final(Md5* md5, byte* hash)
-{
-     WOLFSSL_ENTER("Md5Final\n") ;
-    start_engine(&(md5->desc)) ;
-    wait_engine(&(md5->desc), (char *)md5->digest, MD5_HASH_SIZE) ;
-    XMEMCPY(hash, md5->digest, MD5_HASH_SIZE) ;
-    wc_InitMd5(md5);  /* reset state */
-}
-
-void Md5SizeSet(Md5* md5, word32 len)
-{
-    WOLFSSL_ENTER("Md5SizeSet\n");
-    md5->desc.msgSize = len;
-}
-#endif
-
-#ifndef NO_SHA
-int wc_InitSha(Sha* sha)
-{
-    WOLFSSL_ENTER("InitSha\n") ;
-    XMEMSET((void *)sha, 0xcc, sizeof(Sha)) ;
-    XMEMSET((void *)KVA0_TO_KVA1(sha), 0xcc, sizeof(Sha)) ;
-    reset_engine(&(sha->desc), PIC32_ALGO_SHA1) ;
-    return 0;
-}
-
-int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
-{
-    WOLFSSL_ENTER("ShaUpdate\n") ;
-    update_engine(&(sha->desc), data, len, sha->digest) ;
-    return 0;
-}
-
-int wc_ShaFinal(Sha* sha, byte* hash)
-{
-    WOLFSSL_ENTER("ShaFinal\n") ;
-    start_engine(&(sha->desc)) ;
-    wait_engine(&(sha->desc), (char *)sha->digest, SHA1_HASH_SIZE) ;
-    XMEMCPY(hash, sha->digest, SHA1_HASH_SIZE) ;
-
-    wc_InitSha(sha);  /* reset state */
-    return 0;
-}
-
-void ShaSizeSet(Sha* sha, word32 len)
-{
-    sha->desc.msgSize = len;
-}
-#endif /* NO_SHA */
-
-#ifndef NO_SHA256
-int wc_InitSha256(Sha256* sha256)
-{
-    WOLFSSL_ENTER("InitSha256\n") ;
-    XMEMSET((void *)sha256, 0xcc, sizeof(Sha256)) ;
-    XMEMSET((void *)KVA0_TO_KVA1(sha256), 0xcc, sizeof(Sha256)) ;
-    reset_engine(&(sha256->desc), PIC32_ALGO_SHA256) ;
-    return 0;
-}
-
-int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
-{
-    WOLFSSL_ENTER("Sha256Update\n") ;
-    update_engine(&(sha256->desc), data, len, sha256->digest) ;
-
-    return 0;
-}
-
-int wc_Sha256Final(Sha256* sha256, byte* hash)
-{
-    WOLFSSL_ENTER("Sha256Final\n") ;
-    start_engine(&(sha256->desc)) ;
-    wait_engine(&(sha256->desc), (char *)sha256->digest, SHA256_HASH_SIZE) ;
-    XMEMCPY(hash, sha256->digest, SHA256_HASH_SIZE) ;
-    wc_InitSha256(sha256);  /* reset state */
-
-    return 0;
-}
-
-void Sha256SizeSet(Sha256* sha256, word32 len)
-{
-    WOLFSSL_ENTER("Sha256SizeSet\n");
-    sha256->desc.msgSize = len;
-}
-
-#endif /* NO_SHA256 */
-
-#endif
-

wolfcrypt/src/pwdbased.c

@@ -28,22 +28,6 @@
 
 #ifndef NO_PWDBASED
 
-#ifdef WOLFSSL_PIC32MZ_HASH
-    #ifndef NO_MD5
-        #define wc_InitMd5   wc_InitMd5_sw
-        #define wc_Md5Update wc_Md5Update_sw
-        #define wc_Md5Final  wc_Md5Final_sw
-    #endif /* NO_MD5 */
-
-    #define wc_InitSha   wc_InitSha_sw
-    #define wc_ShaUpdate wc_ShaUpdate_sw
-    #define wc_ShaFinal  wc_ShaFinal_sw
-
-    #define wc_InitSha256   wc_InitSha256_sw
-    #define wc_Sha256Update wc_Sha256Update_sw
-    #define wc_Sha256Final  wc_Sha256Final_sw
-#endif
-
 #include <wolfssl/wolfcrypt/pwdbased.h>
 #include <wolfssl/wolfcrypt/hmac.h>
 #include <wolfssl/wolfcrypt/integer.h>

wolfcrypt/src/random.c

@@ -1228,10 +1228,11 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
         #if !defined(WOLFSSL_MICROCHIP_PIC32MZ)
             #include <peripheral/timer.h>
         #endif
+        extern word32 ReadCoreTimer(void);
         #define PIC32_SEED_COUNT ReadCoreTimer
     #endif
 
-    #ifdef WOLFSSL_MIC32MZ_RNG
+    #ifdef WOLFSSL_PIC32MZ_RNG
         #include "xc.h"
         int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
         {
@@ -1241,20 +1242,30 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
             word32 size = sz;
             byte* op = output;
             
-            /* This part has to be replaced with better random seed */
+#if ((__PIC32_FEATURE_SET0 == 'E') && (__PIC32_FEATURE_SET1 == 'C'))
-            RNGNUMGEN1 = ReadCoreTimer();
+            RNGNUMGEN1 = _CP0_GET_COUNT();
-            RNGPOLY1 = ReadCoreTimer();
+            RNGPOLY1 = _CP0_GET_COUNT();
-            RNGPOLY2 = ReadCoreTimer();
+            RNGPOLY2 = _CP0_GET_COUNT();
-            RNGNUMGEN2 = ReadCoreTimer();
+            RNGNUMGEN2 = _CP0_GET_COUNT();
-        #ifdef DEBUG_WOLFSSL
+#else
-            printf("GenerateSeed::Seed=%08x, %08x\n", RNGNUMGEN1, RNGNUMGEN2);
+            // All others can be seeded from the TRNG
-        #endif
+            RNGCONbits.TRNGMODE = 1;
+            RNGCONbits.TRNGEN = 1;
+            while (RNGCNT < 64);
+            RNGCONbits.LOAD = 1;
+            while (RNGCONbits.LOAD == 1);
+            while (RNGCNT < 64);
+            RNGPOLY2 = RNGSEED2;
+            RNGPOLY1 = RNGSEED1;
+#endif
+
             RNGCONbits.PLEN = 0x40;
             RNGCONbits.PRNGEN = 1;
-            for(i=0; i<5; i++) { /* wait for RNGNUMGEN ready */
+            for (i=0; i<5; i++) { /* wait for RNGNUMGEN ready */
                 volatile int x;
                 x = RNGNUMGEN1;
                 x = RNGNUMGEN2;
+                (void)x;
             }
             do {
                 rnd32[0] = RNGNUMGEN1;
@@ -1268,7 +1279,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
             } while(size);
             return 0;
         }
-    #else  /* WOLFSSL_MIC32MZ_RNG */
+    #else  /* WOLFSSL_PIC32MZ_RNG */
         /* uses the core timer, in nanoseconds to seed srand */
         int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
         {
@@ -1282,7 +1293,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
             }
             return 0;
         }
-    #endif /* WOLFSSL_MIC32MZ_RNG */
+    #endif /* WOLFSSL_PIC32MZ_RNG */
 
 #elif defined(FREESCALE_MQX) || defined(FREESCALE_KSDK_MQX) || \
       defined(FREESCALE_KSDK_BM) || defined(FREESCALE_FREE_RTOS)

wolfcrypt/src/sha.c

@@ -90,10 +90,7 @@
 
 /* Hardware Acceleration */
 #if defined(WOLFSSL_PIC32MZ_HASH)
-    #define USE_SHA_SOFTWARE_IMPL
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
-    #define wc_InitSha   wc_InitSha_sw
-    #define wc_ShaUpdate wc_ShaUpdate_sw
-    #define wc_ShaFinal  wc_ShaFinal_sw
 
 #elif defined(STM32F2_HASH) || defined(STM32F4_HASH)
 
@@ -244,13 +241,13 @@
     #endif
 
     #define USE_SHA_SOFTWARE_IMPL /* Only for API's, actual transform is here */
-    #define XSHATRANSFORM   ShaTransform
+    #define XTRANSFORM(S,B)   Transform((S),(B))
 
     static int InitSha(Sha* sha)
     {
         int ret = 0;
         ret = wolfSSL_CryptHwMutexLock();
-        if(ret != 0) {
+        if (ret != 0) {
             return ret;
         }
     #ifdef FREESCALE_MMCAU_CLASSIC_SHA
@@ -267,7 +264,7 @@
         return ret;
     }
 
-    static int ShaTransform(Sha* sha, byte* data)
+    static int Transform(Sha* sha, byte* data)
     {
         int ret = wolfSSL_CryptHwMutexLock();
         if(ret == 0) {
@@ -310,8 +307,8 @@
 #ifdef USE_SHA_SOFTWARE_IMPL
 
 /* Check if custom Sha transform is used */
-#ifndef XSHATRANSFORM
+#ifndef XTRANSFORM
-    #define XSHATRANSFORM   ShaTransform
+    #define XTRANSFORM(S,B)   Transform((S),(B))
 
     #define blk0(i) (W[i] = sha->buffer[i])
     #define blk1(i) (W[(i)&15] = \
@@ -334,7 +331,7 @@
     #define R4(v,w,x,y,z,i) (z)+= f4((w),(x),(y)) + blk1((i)) + 0xCA62C1D6+ \
         rotlFixed((v),5); (w) = rotlFixed((w),30);
 
-    static void ShaTransform(Sha* sha, byte* data)
+    static void Transform(Sha* sha, byte* data)
     {
         word32 W[SHA_BLOCK_SIZE / sizeof(word32)];
 
@@ -443,7 +440,7 @@ int wc_InitSha_ex(Sha* sha, void* heap, int devId)
     return ret;
 }
 
-int wc_ShaUpdate (Sha* sha, const byte* data, word32 len)
+int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
 {
     byte* local;
 
@@ -478,7 +475,7 @@ int wc_ShaUpdate (Sha* sha, const byte* data, word32 len)
 #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
             ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
 #endif
-            XSHATRANSFORM(sha, local);
+            XTRANSFORM(sha, local);
             AddLength(sha, SHA_BLOCK_SIZE);
             sha->buffLen = 0;
         }
@@ -517,20 +514,20 @@ int wc_ShaFinal(Sha* sha, byte* hash)
 #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
         ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
 #endif
-        XSHATRANSFORM(sha, local);
+        XTRANSFORM(sha, local);
         sha->buffLen = 0;
     }
     XMEMSET(&local[sha->buffLen], 0, SHA_PAD_SIZE - sha->buffLen);
 
-    /* put lengths in bits */
-    sha->hiLen = (sha->loLen >> (8*sizeof(sha->loLen) - 3)) +
-    (sha->hiLen << 3);
-    sha->loLen = sha->loLen << 3;
-
-    /* store lengths */
 #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
     ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
 #endif
+
+    /* store lengths */
+    /* put lengths in bits */
+    sha->hiLen = (sha->loLen >> (8*sizeof(sha->loLen) - 3)) + (sha->hiLen << 3);
+    sha->loLen = sha->loLen << 3;
+
     /* ! length ordering dependent on digest endian type ! */
     XMEMCPY(&local[SHA_PAD_SIZE], &sha->hiLen, sizeof(word32));
     XMEMCPY(&local[SHA_PAD_SIZE + sizeof(word32)], &sha->loLen, sizeof(word32));
@@ -542,7 +539,7 @@ int wc_ShaFinal(Sha* sha, byte* hash)
                      2 * sizeof(word32));
 #endif
 
-    XSHATRANSFORM(sha, local);
+    XTRANSFORM(sha, local);
 #ifdef LITTLE_ENDIAN_ORDER
     ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE);
 #endif

wolfcrypt/src/sha256.c

@@ -100,6 +100,7 @@
 #endif
 
 
+#ifndef WOLFSSL_PIC32MZ_HASH
 static int InitSha256(Sha256* sha256)
 {
     int ret = 0;
@@ -107,6 +108,7 @@ static int InitSha256(Sha256* sha256)
     if (sha256 == NULL)
         return BAD_FUNC_ARG;
 
+    XMEMSET(sha256->digest, 0, sizeof(sha256->digest));
     sha256->digest[0] = 0x6A09E667L;
     sha256->digest[1] = 0xBB67AE85L;
     sha256->digest[2] = 0x3C6EF372L;
@@ -122,6 +124,7 @@ static int InitSha256(Sha256* sha256)
 
     return ret;
 }
+#endif
 
 
 /* Hardware Acceleration */
@@ -198,7 +201,7 @@ static int InitSha256(Sha256* sha256)
     static int (*Transform_p)(Sha256* sha256) /* = _Transform */;
     static int transform_check = 0;
     static word32 intel_flags;
-    #define XTRANSFORM(sha256, B)  (*Transform_p)(sha256)
+    #define XTRANSFORM(S, B)  (*Transform_p)((S))
 
     static void Sha256_SetTransform(void)
     {
@@ -283,7 +286,7 @@ static int InitSha256(Sha256* sha256)
         #include "fsl_mmcau.h"
     #endif
 
-    #define XTRANSFORM(sha256, B) Transform(sha256, B)
+    #define XTRANSFORM(S, B)  Transform((S), (B))
 
     int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
     {
@@ -325,27 +328,11 @@ static int InitSha256(Sha256* sha256)
     }
 
 #elif defined(WOLFSSL_PIC32MZ_HASH)
-    #define NEED_SOFT_SHA256
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
-
-    #define wc_InitSha256   wc_InitSha256_sw
-    #define wc_Sha256Update wc_Sha256Update_sw
-    #define wc_Sha256Final  wc_Sha256Final_sw
-
-    int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
-    {
-        if (sha256 == NULL)
-            return BAD_FUNC_ARG;
-
-        sha256->heap = heap;
-
-        return InitSha256(sha256);
-    }
 
 #else
     #define NEED_SOFT_SHA256
 
-    #define XTRANSFORM(sha256, B) Transform(sha256)
-
     int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
     {
         int ret = 0;
@@ -407,6 +394,10 @@ static int InitSha256(Sha256* sha256)
          (d) += t0; \
          (h)  = t0 + t1;
 
+    #ifndef XTRANSFORM
+         #define XTRANSFORM(S, B) Transform((S))
+     #endif
+
     static int Transform(Sha256* sha256)
     {
         word32 S[8], t0, t1;

wolfcrypt/test/test.c

@@ -3907,7 +3907,7 @@ int aes_test(void)
 #if defined(HAVE_AES_CBC) || defined(WOLFSSL_AES_COUNTER)
     Aes enc;
     byte cipher[AES_BLOCK_SIZE * 4];
-#ifdef HAVE_AES_DECRYPT
+#if defined(HAVE_AES_DECRYPT) || defined(WOLFSSL_AES_COUNTER)
     Aes dec;
     byte plain [AES_BLOCK_SIZE * 4];
 #endif
@@ -4191,7 +4191,9 @@ int aes_test(void)
         if (XMEMCMP(cipher, ctr128Cipher, sizeof(oddCipher)))
             return -4216;
 
-#if !defined(STM32F2_CRYPTO) && !defined(STM32F4_CRYPTO) /* test not supported on STM32 crypto HW */
+    /* test not supported on STM32 crypto HW or PIC32MZ HW */
+#if !defined(STM32F2_CRYPTO) && !defined(STM32F4_CRYPTO) && \
+    !defined(WOLFSSL_PIC32MZ_CRYPT)
         /* and an additional 9 bytes to reuse tmp left buffer */
         ret = wc_AesCtrEncrypt(&enc, cipher, ctrPlain, sizeof(oddCipher));
         if (ret != 0) {
@@ -4547,9 +4549,14 @@ int aesgcm_test(void)
         0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
     };
 
+    /* FIPS, QAT and STM32F2/4 HW Crypto only support 12-byte IV */
 #if !defined(HAVE_FIPS) && !defined(HAVE_INTEL_QA) && \
         !defined(STM32F2_CRYPTO) && !defined(STM32F4_CRYPTO) && \
+        !defined(WOLFSSL_PIC32MZ_CRYPT) && \
         !defined(WOLFSSL_XILINX_CRYPT)
+
+    #define ENABLE_NON_12BYTE_IV_TEST
+
     /* Test Case 12, uses same plaintext and AAD data. */
     const byte k2[] =
     {
@@ -4587,7 +4594,7 @@ int aesgcm_test(void)
         0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
         0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9
     };
-#endif /* !HAVE_FIPS && !HAVE_INTEL_QA && !STM32F2_CRYPTO && !STM32F4_CRYPTO */
+#endif
 
     byte resultT[sizeof(t1)];
     byte resultP[sizeof(p)];
@@ -4732,10 +4739,8 @@ int aesgcm_test(void)
             return -4315;
     }
 
-    /* FIPS, QAT and STM32F2/4 HW Crypto only support 12-byte IV */
+    /* test with IV != 12 bytes */
-#if !defined(HAVE_FIPS) && !defined(HAVE_INTEL_QA) && \
+#ifdef ENABLE_NON_12BYTE_IV_TEST
-        !defined(STM32F2_CRYPTO) && !defined(STM32F4_CRYPTO) && \
-        !defined(WOLFSSL_XILINX_CRYPT)
     XMEMSET(resultT, 0, sizeof(resultT));
     XMEMSET(resultC, 0, sizeof(resultC));
     XMEMSET(resultP, 0, sizeof(resultP));
@@ -4763,7 +4768,7 @@ int aesgcm_test(void)
         return -4319;
     if (XMEMCMP(p, resultP, sizeof(resultP)))
         return -4320;
-#endif /* !HAVE_FIPS && !HAVE_INTEL_QA && !STM32F2_CRYPTO && !STM32F4_CRYPTO */
+#endif /* ENABLE_NON_12BYTE_IV_TEST */
 
     wc_AesFree(&enc);
 

wolfssl/wolfcrypt/aes.h

@@ -101,8 +101,8 @@ typedef struct Aes {
     word32  left;            /* unused bytes left from last call */
 #endif
 #ifdef WOLFSSL_PIC32MZ_CRYPT
-    word32 key_ce[AES_BLOCK_SIZE*2/sizeof(word32)] ;
+    word32 key_ce[AES_BLOCK_SIZE*2/sizeof(word32)];
-    word32 iv_ce [AES_BLOCK_SIZE  /sizeof(word32)] ;
+    word32 iv_ce [AES_BLOCK_SIZE  /sizeof(word32)];
 #endif
 #ifdef WOLFSSL_XILINX_CRYPT
     XSecure_Aes xilAes;

wolfssl/wolfcrypt/md5.h

@@ -49,8 +49,8 @@ enum {
     MD5_PAD_SIZE    = 56
 };
 
-#if defined(WOLFSSL_PIC32MZ_HASH)
+#ifdef WOLFSSL_MICROCHIP_PIC32MZ
-    #include "port/pic32/pic32mz-crypt.h"
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
 #endif
 #ifdef WOLFSSL_ASYNC_CRYPT
     #include <wolfssl/wolfcrypt/async.h>
@@ -66,13 +66,11 @@ typedef struct Md5 {
     word32  loLen;     /* length in bytes   */
     word32  hiLen;     /* length in bytes   */
     word32  buffer[MD5_BLOCK_SIZE  / sizeof(word32)];
-#if !defined(WOLFSSL_PIC32MZ_HASH)
     word32  digest[MD5_DIGEST_SIZE / sizeof(word32)];
-#else
-    word32  digest[PIC32_HASH_SIZE / sizeof(word32)];
-    pic32mz_desc desc; /* Crypt Engine descriptor */
-#endif
     void*   heap;
+#ifdef WOLFSSL_PIC32MZ_HASH
+    hashUpdCache cache; /* cache for updates */
+#endif
 #ifdef WOLFSSL_ASYNC_CRYPT
     WC_ASYNC_DEV asyncDev;
 #endif /* WOLFSSL_ASYNC_CRYPT */
@@ -89,6 +87,9 @@ WOLFSSL_API void wc_Md5Free(Md5*);
 WOLFSSL_API int  wc_Md5GetHash(Md5*, byte*);
 WOLFSSL_API int  wc_Md5Copy(Md5*, Md5*);
 
+#ifdef WOLFSSL_PIC32MZ_HASH
+WOLFSSL_API void wc_Md5SizeSet(Md5* md5, word32 len);
+#endif
 
 #ifdef __cplusplus
     } /* extern "C" */

wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h

@@ -23,13 +23,36 @@
 #ifndef PIC32MZ_CRYPT_H
 #define PIC32MZ_CRYPT_H
 
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
 #ifdef WOLFSSL_MICROCHIP_PIC32MZ
 
-#define MICROCHIP_PIC32
+#ifndef MICROCHIP_PIC32
+    #define MICROCHIP_PIC32
+#endif
+
+/* If algos aren't enabled then turn off */
+#ifdef WOLFSSL_PIC32MZ_HASH
+    #if defined(NO_MD5) && defined(NO_SHA) && defined(NO_SHA256)
+        #undef WOLFSSL_PIC32MZ_HASH
+    #endif
+#endif
+
+#ifdef WOLFSSL_PIC32MZ_CRYPT
+    #if defined(NO_AES) && defined(NO_DES3)
+        #undef WOLFSSL_PIC32MZ_CRYPT
+    #endif
+#endif
+
+
 #include <xc.h>
 #include <sys/endian.h>
 #include <sys/kmem.h>
 
+
+/* PIC32 Crypto Structures */
 typedef struct saCtrl {
     unsigned int CRYPTOALGO : 4;
     unsigned int MULTITASK : 3;
@@ -63,11 +86,12 @@ typedef struct bdCtrl {
     unsigned int CBD_INT_EN : 1;
     unsigned int PKT_INT_EN : 1;
     unsigned int LIFM : 1;
-    unsigned int LAST_BD: 1;
+    unsigned int LAST_BD : 1;
-    unsigned int : 2;
+    unsigned int CRDMA_EN : 1;
+    unsigned int UPD_RES : 1;
     unsigned int SA_FETCH_EN : 1;
-    unsigned int : 8;
+    unsigned int SEC_CODE : 8;
-    unsigned int DESC_EN : 1;
+    volatile unsigned int DESC_EN : 1;
 } bdCtrl;
 
 typedef struct bufferDescriptor {
@@ -82,58 +106,93 @@ typedef struct bufferDescriptor {
 } bufferDescriptor;
 
 
+/* Cache Updates Struct */
+typedef struct hashUpdCache {
+    unsigned char*  buf;
+    unsigned int    bufLen;
+    unsigned int    updLen;
+} hashUpdCache;
+
+
+/* Direction */
 #define PIC32_ENCRYPTION     0b1
 #define PIC32_DECRYPTION     0b0
 
+/* Algorithm */
 #define PIC32_ALGO_HMAC1     0b01000000
 #define PIC32_ALGO_SHA256    0b00100000
 #define PIC32_ALGO_SHA1      0b00010000
 #define PIC32_ALGO_MD5       0b00001000
+
 #define PIC32_ALGO_AES       0b00000100
 #define PIC32_ALGO_TDES      0b00000010
 #define PIC32_ALGO_DES       0b00000001
 
+/* Crypto Algo */
+/* AES */
 #define PIC32_CRYPTOALGO_AES_GCM  0b1110
 #define PIC32_CRYPTOALGO_RCTR     0b1101
+#define PIC32_CRYPTOALGO_RCBC_MAC 0b1100
+#define PIC32_CRYPTOALGO_ROFB     0b1011
+#define PIC32_CRYPTOALGO_RCFB     0b1010
 #define PIC32_CRYPTOALGO_RCBC     0b1001
-#define PIC32_CRYPTOALGO_REBC    0b1000
+#define PIC32_CRYPTOALGO_RECB     0b1000
+/* Triple-DES */
+#define PIC32_CRYPTOALGO_TOFB     0b0111
+#define PIC32_CRYPTOALGO_TCFB     0b0110
 #define PIC32_CRYPTOALGO_TCBC     0b0101
+#define PIC32_CRYPTOALGO_TECB     0b0100
+/* DES */
+#define PIC32_CRYPTOALGO_OFB      0b0011
+#define PIC32_CRYPTOALGO_CFB      0b0010
 #define PIC32_CRYPTOALGO_CBC      0b0001
+#define PIC32_CRYPTOALGO_ECB      0b0000
 
-#define PIC32_AES_KEYSIZE_256     0b10
+/* Key Size */
-#define PIC32_AES_KEYSIZE_192     0b01
+#define PIC32_KEYSIZE_256         0b10
-#define PIC32_AES_KEYSIZE_128     0b00
+#define PIC32_KEYSIZE_192         0b01
+#define PIC32_KEYSIZE_128         0b00
 
-#define PIC32_AES_BLOCK_SIZE 16
+/* PIC32 Minimum Buffer/Block Sizes */
-#define MD5_HASH_SIZE 16
+#define PIC32_BLOCKSIZE_HASH    64
-#define SHA1_HASH_SIZE 20
+#define PIC32_BLOCKSIZE_HMAC    PIC32_BLOCKSIZE_HASH
-#define SHA256_HASH_SIZE 32
+#define PIC32_BLOCKSIZE_MD5     PIC32_BLOCKSIZE_HASH
-#define PIC32_HASH_SIZE 32
+#define PIC32_BLOCKSIZE_SHA1    PIC32_BLOCKSIZE_HASH
+#define PIC32_BLOCKSIZE_SHA256  PIC32_BLOCKSIZE_HASH
+#define PIC32_BLOCKSIZE_AES     16
+#define PIC32_BLOCKSIZE_TDES    24
+#define PIC32_BLOCKSIZE_DES     8
 
-#define PIC32MZ_MAX_BD   2
+#define PIC32_DIGEST_SIZE       32
-typedef struct {      /* Crypt Engine descriptor */
-    int bdCount ;
-    int err   ;
-    volatile bufferDescriptor 
-        bd[PIC32MZ_MAX_BD] __attribute__((aligned (8), coherent));
-    securityAssociation 
-        sa                 __attribute__((aligned (8), coherent));
-} pic32mz_desc ;
 
-#define PIC32MZ_IF_RAM(addr) (KVA_TO_PA(addr) < 0x80000)
 
-#define WAIT_ENGINE \
+/* Helper Macros */
-    { volatile int v ; while (CESTATbits.ACTIVE) ; for(v=0; v<100; v++) ; }
+#define PIC32MZ_IF_RAM(addr) (KVA_TO_PA(addr) < 0x1D000000)
 
-#ifdef DEBUG_CYASSL
+/* If EF part then Crypto engine supports swapping output bytes */
-static void print_mem(const unsigned char *p, int size) {
+#define PIC32_NO_OUT_SWAP    ((__PIC32_FEATURE_SET0 == 'E') && \
-    for(; size>0; size--, p++) {
+                              (__PIC32_FEATURE_SET1 == 'C'))
-        if(size%4 == 0)printf(" ") ;
+
-            printf("%02x", (int)*p) ;
+
-    }
+#ifndef NO_AES
-    puts("") ;
+int wc_Pic32AesCrypt(word32 *key, int keyLen, word32 *iv, int ivLen,
-}
+        byte* out, const byte* in, word32 sz,
+        int dir, int algo, int cryptoalgo);
+#endif
+#ifndef NO_DES3
+int wc_Pic32DesCrypt(word32 *key, int keyLen, word32 *iv, int ivLen,
+        byte* out, const byte* in, word32 sz,
+        int dir, int algo, int cryptoalgo);
 #endif
 
+#ifdef WOLFSSL_PIC32MZ_HASH
+int wc_Pic32Hash(const byte* in, int inLen, word32* out, int outLen, int algo);
 #endif
+
+#endif /* WOLFSSL_MICROCHIP_PIC32MZ */
+
+#ifdef __cplusplus
+    } /* extern "C" */
+#endif
+
 #endif /* PIC32MZ_CRYPT_H */

wolfssl/wolfcrypt/settings.h

@@ -217,19 +217,15 @@
     #define NO_FILESYSTEM
     #define USE_FAST_MATH
     #define TFM_TIMING_RESISTANT
-    #define NEED_AES_TABLES
     #define WOLFSSL_HAVE_MIN
+    #define WOLFSSL_HAVE_MAX
+    #define NO_BIG_INT
 #endif
 
 #ifdef WOLFSSL_MICROCHIP_PIC32MZ
-    #define WOLFSSL_PIC32MZ_CE
     #define WOLFSSL_PIC32MZ_CRYPT
-    #define HAVE_AES_ENGINE
     #define WOLFSSL_PIC32MZ_RNG
-    /* #define WOLFSSL_PIC32MZ_HASH */
+    #define WOLFSSL_PIC32MZ_HASH
-    #define WOLFSSL_AES_COUNTER
-    #define HAVE_AESGCM
-    #define NO_BIG_INT
 #endif
 
 #ifdef MICROCHIP_TCPIP_V5

wolfssl/wolfcrypt/sha.h

@@ -42,8 +42,8 @@
 
 #ifndef HAVE_FIPS /* avoid redefining structs */
 
-#ifdef WOLFSSL_PIC32MZ_HASH
+#ifdef WOLFSSL_MICROCHIP_PIC32MZ
-    #include "port/pic32/pic32mz-crypt.h"
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
 #endif
 #ifdef WOLFSSL_ASYNC_CRYPT
     #include <wolfssl/wolfcrypt/async.h>
@@ -71,14 +71,10 @@ typedef struct Sha {
         word32  loLen;     /* length in bytes   */
         word32  hiLen;     /* length in bytes   */
         word32  buffer[SHA_BLOCK_SIZE  / sizeof(word32)];
-    #ifndef WOLFSSL_PIC32MZ_HASH
         word32  digest[SHA_DIGEST_SIZE / sizeof(word32)];
-    #else
-        word32  digest[PIC32_HASH_SIZE / sizeof(word32)];
-    #endif
         void*   heap;
     #ifdef WOLFSSL_PIC32MZ_HASH
-        pic32mz_desc desc; /* Crypt Engine descriptor */
+        hashUpdCache cache; /* cache for updates */
     #endif
     #ifdef WOLFSSL_ASYNC_CRYPT
         WC_ASYNC_DEV asyncDev;
@@ -102,6 +98,10 @@ WOLFSSL_API void wc_ShaFree(Sha*);
 WOLFSSL_API int wc_ShaGetHash(Sha*, byte*);
 WOLFSSL_API int wc_ShaCopy(Sha*, Sha*);
 
+#ifdef WOLFSSL_PIC32MZ_HASH
+WOLFSSL_API void wc_ShaSizeSet(Sha* sha, word32 len);
+#endif
+
 #ifdef __cplusplus
     } /* extern "C" */
 #endif

wolfssl/wolfcrypt/sha256.h

@@ -45,8 +45,8 @@
 
 #ifndef HAVE_FIPS /* avoid redefinition of structs */
 
-#ifdef WOLFSSL_PIC32MZ_HASH
+#ifdef WOLFSSL_MICROCHIP_PIC32MZ
-    #include "port/pic32/pic32mz-crypt.h"
+    #include <wolfssl/wolfcrypt/port/pic32/pic32mz-crypt.h>
 #endif
 #ifdef WOLFSSL_ASYNC_CRYPT
     #include <wolfssl/wolfcrypt/async.h>
@@ -75,7 +75,7 @@ typedef struct Sha256 {
     word32  hiLen;     /* length in bytes   */
     void*   heap;
 #ifdef WOLFSSL_PIC32MZ_HASH
-    pic32mz_desc desc; /* Crypt Engine descriptor */
+    hashUpdCache cache; /* cache for updates */
 #endif
 #ifdef WOLFSSL_ASYNC_CRYPT
     WC_ASYNC_DEV asyncDev;
@@ -98,6 +98,10 @@ WOLFSSL_API void wc_Sha256Free(Sha256*);
 WOLFSSL_API int wc_Sha256GetHash(Sha256*, byte*);
 WOLFSSL_API int wc_Sha256Copy(Sha256* src, Sha256* dst);
 
+#ifdef WOLFSSL_PIC32MZ_HASH
+WOLFSSL_API void wc_Sha256SizeSet(Sha256*, word32);
+#endif
+
 #ifdef WOLFSSL_SHA224
 
 #ifndef HAVE_FIPS /* avoid redefinition of structs */

wolfssl/wolfcrypt/types.h

@@ -305,10 +305,14 @@
 	    #define XSTRNSTR(s1,s2,n) mystrnstr((s1),(s2),(n))
 	    #define XSTRNCMP(s1,s2,n) strncmp((s1),(s2),(n))
 	    #define XSTRNCAT(s1,s2,n) strncat((s1),(s2),(n))
-	    #ifndef USE_WINDOWS_API
+
-	        #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n))
+        #ifdef MICROCHIP_PIC32
-	    #else
+            /* XC32 does not support strncasecmp, so use case sensitive one */
+            #define XSTRNCASECMP(s1,s2,n) strncmp((s1),(s2),(n))
+        #elif defined(USE_WINDOWS_API)
 	        #define XSTRNCASECMP(s1,s2,n) _strnicmp((s1),(s2),(n))
+        #else
+	        #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n))
 	    #endif
 
         /* snprintf is used in asn.c for GetTimeString and PKCS7 test */
@@ -435,6 +439,7 @@
         DYNAMIC_TYPE_ECC_BUFFER   = 85,
         DYNAMIC_TYPE_QSH          = 86,
         DYNAMIC_TYPE_SALT         = 87,
+        DYNAMIC_TYPE_HASH_TMP     = 88,
 	};
 
 	/* max error buffer string size */

wolfssl/wolfcrypt/wc_port.h

@@ -161,8 +161,8 @@
     #endif /* USE_WINDOWS_API */
 #endif /* SINGLE_THREADED */
 
-/* Enable crypt HW mutex for Freescale MMCAU */
+/* Enable crypt HW mutex for Freescale MMCAU or PIC32MZ */
-#if defined(FREESCALE_MMCAU)
+#if defined(FREESCALE_MMCAU) || defined(WOLFSSL_MICROCHIP_PIC32MZ)
     #ifndef WOLFSSL_CRYPT_HW_MUTEX
         #define WOLFSSL_CRYPT_HW_MUTEX  1
     #endif