NUCLEO_F429ZI/mbedtls: add SHA1 hw_acceleration

features/mbedtls/targets/TARGET_STM/TARGET_STM32F4/TARGET_NUCLEO_F439ZI/mbedtls_device.h

@@ -21,6 +21,7 @@
 #define MBEDTLS_DEVICE_H
 
 #define MBEDTLS_AES_ALT
+#define MBEDTLS_SHA1_ALT
 
-
+#define MBEDTLS_SHA1_C
 #endif /* MBEDTLS_DEVICE_H */

features/mbedtls/targets/TARGET_STM/sha1_alt.c

@@ -0,0 +1,149 @@
+/*
+ *  sha1_alt.c for SHA1 HASH
+ *******************************************************************************
+ * Copyright (c) 2017, STMicroelectronics
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+#include "mbedtls/sha1.h"
+
+#if defined(MBEDTLS_SHA1_ALT)
+
+/* Implementation that should never be optimized out by the compiler */
+static void mbedtls_zeroize( void *v, size_t n ) {
+    volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
+}
+
+void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
+{
+    memset( ctx, 0, sizeof( mbedtls_sha1_context ) );	
+
+    /* Enable HASH clock */
+    __HAL_RCC_HASH_CLK_ENABLE();
+
+    ctx->flag=0;
+}
+
+void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
+{
+    if( ctx == NULL )
+        return;
+	
+	/* Force the HASH Periheral Clock Reset */
+    __HAL_RCC_HASH_FORCE_RESET();
+
+    /* Release the HASH Periheral Clock Reset */
+    __HAL_RCC_HASH_RELEASE_RESET();
+
+    mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
+}
+
+void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
+                         const mbedtls_sha1_context *src )
+{
+    *dst = *src;
+}
+
+/*
+ * SHA-1 context setup
+ */
+void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
+{
+    /* Deinitializes the HASH peripheral */
+    if (HAL_HASH_DeInit(&ctx->hhash_sha1) == HAL_ERROR) {
+        // error found to be returned
+        return;
+    }
+    
+    /* HASH Configuration */
+    ctx->hhash_sha1.Init.DataType = HASH_DATATYPE_8B;
+    if (HAL_HASH_Init(&ctx->hhash_sha1) == HAL_ERROR) {
+        // error found to be returned
+        return;
+    }
+
+    ctx->flag=0;
+}
+
+void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] )
+{
+	HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *) data, 64);
+}
+
+/*
+ * SHA-1 process buffer
+ */
+void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen )
+{
+    unsigned char *intermediate_buf=NULL;
+    unsigned char modulus=0;
+    unsigned char buf_len=0;
+
+    // Accumulate cannot be called for a size <4 unless it is the last call
+
+    modulus = ilen % 4;
+
+    if (ilen <4)
+    {
+        ctx->sbuf=malloc(ilen);
+        memcpy(ctx->sbuf, input, ilen);
+        ctx->flag = 1;
+        ctx->sbuf_len=ilen;
+    }
+    else
+    {
+        if (modulus !=0)
+        {
+            buf_len = ilen - modulus;
+            HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *)input, buf_len);
+            ctx->sbuf_len=modulus;
+            ctx->sbuf=malloc(ctx->sbuf_len);
+            memcpy(ctx->sbuf, input+buf_len, modulus);
+            ctx->flag = 1;
+        }
+        else
+        {
+            if (ctx->flag==0)
+                HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *)input, ilen);
+            else
+            {
+                intermediate_buf=malloc(ilen+ctx->sbuf_len);
+                memcpy(intermediate_buf, ctx->sbuf, ctx->sbuf_len);
+                memcpy(intermediate_buf+ctx->sbuf_len, input, ilen);
+                HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, intermediate_buf, ilen+ctx->sbuf_len);
+                ctx->flag=0;
+            }
+        }
+    }    
+}
+
+/*
+ * SHA-1 final digest
+ */
+void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
+{
+    if (ctx->flag == 1) {
+        HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, ctx->sbuf, ctx->sbuf_len);
+        ctx->flag=0;
+    }
+
+    __HAL_HASH_START_DIGEST();
+        
+    if (HAL_HASH_SHA1_Finish(&ctx->hhash_sha1, output, 10)){
+        // error code to be returned
+    }
+}
+
+#endif /*MBEDTLS_SHA1_ALT*/

features/mbedtls/targets/TARGET_STM/sha1_alt.h

@@ -0,0 +1,127 @@
+/*
+ *  sha1_alt.h SHA-1 hash
+ *******************************************************************************
+ *  Copyright (C) 2017, STMicroelectronics
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+#ifndef MBEDTLS_SHA1_ALT_H
+#define MBEDTLS_SHA1_ALT_H
+
+#if defined MBEDTLS_SHA1_ALT
+
+#include "mbedtls/platform.h"
+#include "mbedtls/config.h"
+
+#include "cmsis.h"
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief          SHA-1 context structure
+ */
+typedef struct
+{
+    unsigned char *sbuf;
+    unsigned char sbuf_len;
+    HASH_HandleTypeDef hhash_sha1;
+    int flag;  /* flag to manage buffer constraint of crypto Hw */
+}
+mbedtls_sha1_context;
+
+/**
+ * \brief          Initialize SHA-1 context
+ *
+ * \param ctx      SHA-1 context to be initialized
+ */
+void mbedtls_sha1_init( mbedtls_sha1_context *ctx );
+
+/**
+ * \brief          Clear SHA-1 context
+ *
+ * \param ctx      SHA-1 context to be cleared
+ */
+void mbedtls_sha1_free( mbedtls_sha1_context *ctx );
+
+/**
+ * \brief          Clone (the state of) a SHA-1 context
+ *
+ * \param dst      The destination context
+ * \param src      The context to be cloned
+ */
+void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
+                         const mbedtls_sha1_context *src );
+
+/**
+ * \brief          SHA-1 context setup
+ *
+ * \param ctx      context to be initialized
+ */
+void mbedtls_sha1_starts( mbedtls_sha1_context *ctx );
+
+/**
+ * \brief          SHA-1 process buffer
+ *
+ * \param ctx      SHA-1 context
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ */
+void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen );
+
+/**
+ * \brief          SHA-1 final digest
+ *
+ * \param ctx      SHA-1 context
+ * \param output   SHA-1 checksum result
+ */
+void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] );
+
+/* Internal use */
+void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] );
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief          Output = SHA-1( input buffer )
+ *
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ * \param output   SHA-1 checksum result
+ */
+void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] );
+
+/**
+ * \brief          Checkup routine
+ *
+ * \return         0 if successful, or 1 if the test failed
+ */
+int mbedtls_sha1_self_test( int verbose );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MBEDTLS_SHA1_ALT */
+
+#endif /* sha1_alt.h */