EL4121 Embedded System / mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

features/mbedtls/targets/TARGET_STM/sha1_alt.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /*
be_bryan 0:b74591d5ab33 2 * sha1_alt.c for SHA1 HASH
be_bryan 0:b74591d5ab33 3 *******************************************************************************
be_bryan 0:b74591d5ab33 4 * Copyright (c) 2017, STMicroelectronics
be_bryan 0:b74591d5ab33 5 * SPDX-License-Identifier: Apache-2.0
be_bryan 0:b74591d5ab33 6 *
be_bryan 0:b74591d5ab33 7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
be_bryan 0:b74591d5ab33 8 * not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 9 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 10 *
be_bryan 0:b74591d5ab33 11 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 12 *
be_bryan 0:b74591d5ab33 13 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
be_bryan 0:b74591d5ab33 15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 16 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 17 * limitations under the License.
be_bryan 0:b74591d5ab33 18 *
be_bryan 0:b74591d5ab33 19 */
be_bryan 0:b74591d5ab33 20 #include "mbedtls/sha1.h"
be_bryan 0:b74591d5ab33 21 #if defined(MBEDTLS_SHA1_ALT)
be_bryan 0:b74591d5ab33 22 #include "mbedtls/platform.h"
be_bryan 0:b74591d5ab33 23
be_bryan 0:b74591d5ab33 24 /* Implementation that should never be optimized out by the compiler */
be_bryan 0:b74591d5ab33 25 static void mbedtls_zeroize( void *v, size_t n ) {
be_bryan 0:b74591d5ab33 26 volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
be_bryan 0:b74591d5ab33 27 }
be_bryan 0:b74591d5ab33 28
be_bryan 0:b74591d5ab33 29 static int st_sha1_restore_hw_context(mbedtls_sha1_context *ctx)
be_bryan 0:b74591d5ab33 30 {
be_bryan 0:b74591d5ab33 31 uint32_t i;
be_bryan 0:b74591d5ab33 32 uint32_t tickstart;
be_bryan 0:b74591d5ab33 33 /* allow multi-instance of HASH use: save context for HASH HW module CR */
be_bryan 0:b74591d5ab33 34 /* Check that there is no HASH activity on going */
be_bryan 0:b74591d5ab33 35 tickstart = HAL_GetTick();
be_bryan 0:b74591d5ab33 36 while ((HASH->SR & (HASH_FLAG_BUSY | HASH_FLAG_DMAS)) != 0) {
be_bryan 0:b74591d5ab33 37 if ((HAL_GetTick() - tickstart) > ST_SHA1_TIMEOUT) {
be_bryan 0:b74591d5ab33 38 return 0; // timeout: HASH processor is busy
be_bryan 0:b74591d5ab33 39 }
be_bryan 0:b74591d5ab33 40 }
be_bryan 0:b74591d5ab33 41 HASH->STR = ctx->ctx_save_str;
be_bryan 0:b74591d5ab33 42 HASH->CR = (ctx->ctx_save_cr | HASH_CR_INIT);
be_bryan 0:b74591d5ab33 43 for (i=0;i<38;i++) {
be_bryan 0:b74591d5ab33 44 HASH->CSR[i] = ctx->ctx_save_csr[i];
be_bryan 0:b74591d5ab33 45 }
be_bryan 0:b74591d5ab33 46 return 1;
be_bryan 0:b74591d5ab33 47 }
be_bryan 0:b74591d5ab33 48
be_bryan 0:b74591d5ab33 49 static int st_sha1_save_hw_context(mbedtls_sha1_context *ctx)
be_bryan 0:b74591d5ab33 50 {
be_bryan 0:b74591d5ab33 51 uint32_t i;
be_bryan 0:b74591d5ab33 52 uint32_t tickstart;
be_bryan 0:b74591d5ab33 53 /* Check that there is no HASH activity on going */
be_bryan 0:b74591d5ab33 54 tickstart = HAL_GetTick();
be_bryan 0:b74591d5ab33 55 while ((HASH->SR & (HASH_FLAG_BUSY | HASH_FLAG_DMAS)) != 0) {
be_bryan 0:b74591d5ab33 56 if ((HAL_GetTick() - tickstart) > ST_SHA1_TIMEOUT) {
be_bryan 0:b74591d5ab33 57 return 0; // timeout: HASH processor is busy
be_bryan 0:b74591d5ab33 58 }
be_bryan 0:b74591d5ab33 59 }
be_bryan 0:b74591d5ab33 60 /* allow multi-instance of HASH use: restore context for HASH HW module CR */
be_bryan 0:b74591d5ab33 61 ctx->ctx_save_cr = HASH->CR;
be_bryan 0:b74591d5ab33 62 ctx->ctx_save_str = HASH->STR;
be_bryan 0:b74591d5ab33 63 for (i=0;i<38;i++) {
be_bryan 0:b74591d5ab33 64 ctx->ctx_save_csr[i] = HASH->CSR[i];
be_bryan 0:b74591d5ab33 65 }
be_bryan 0:b74591d5ab33 66 return 1;
be_bryan 0:b74591d5ab33 67 }
be_bryan 0:b74591d5ab33 68
be_bryan 0:b74591d5ab33 69 void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
be_bryan 0:b74591d5ab33 70 {
be_bryan 0:b74591d5ab33 71 mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
be_bryan 0:b74591d5ab33 72
be_bryan 0:b74591d5ab33 73 /* Enable HASH clock */
be_bryan 0:b74591d5ab33 74 __HAL_RCC_HASH_CLK_ENABLE();
be_bryan 0:b74591d5ab33 75
be_bryan 0:b74591d5ab33 76 }
be_bryan 0:b74591d5ab33 77
be_bryan 0:b74591d5ab33 78 void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
be_bryan 0:b74591d5ab33 79 {
be_bryan 0:b74591d5ab33 80 if( ctx == NULL )
be_bryan 0:b74591d5ab33 81 return;
be_bryan 0:b74591d5ab33 82 mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
be_bryan 0:b74591d5ab33 83 }
be_bryan 0:b74591d5ab33 84
be_bryan 0:b74591d5ab33 85 void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
be_bryan 0:b74591d5ab33 86 const mbedtls_sha1_context *src )
be_bryan 0:b74591d5ab33 87 {
be_bryan 0:b74591d5ab33 88 *dst = *src;
be_bryan 0:b74591d5ab33 89 }
be_bryan 0:b74591d5ab33 90
be_bryan 0:b74591d5ab33 91 void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
be_bryan 0:b74591d5ab33 92 {
be_bryan 0:b74591d5ab33 93 /* Deinitializes the HASH peripheral */
be_bryan 0:b74591d5ab33 94 if (HAL_HASH_DeInit(&ctx->hhash_sha1) == HAL_ERROR) {
be_bryan 0:b74591d5ab33 95 // error found to be returned
be_bryan 0:b74591d5ab33 96 return;
be_bryan 0:b74591d5ab33 97 }
be_bryan 0:b74591d5ab33 98
be_bryan 0:b74591d5ab33 99 /* HASH Configuration */
be_bryan 0:b74591d5ab33 100 ctx->hhash_sha1.Init.DataType = HASH_DATATYPE_8B;
be_bryan 0:b74591d5ab33 101 /* clear CR ALGO value */
be_bryan 0:b74591d5ab33 102 HASH->CR &= ~HASH_CR_ALGO_Msk;
be_bryan 0:b74591d5ab33 103 if (HAL_HASH_Init(&ctx->hhash_sha1) == HAL_ERROR) {
be_bryan 0:b74591d5ab33 104 // error found to be returned
be_bryan 0:b74591d5ab33 105 return;
be_bryan 0:b74591d5ab33 106 }
be_bryan 0:b74591d5ab33 107 if (st_sha1_save_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 108 return; // return HASH_BUSY timeout Error here
be_bryan 0:b74591d5ab33 109 }
be_bryan 0:b74591d5ab33 110 }
be_bryan 0:b74591d5ab33 111
be_bryan 0:b74591d5ab33 112 void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[ST_SHA1_BLOCK_SIZE] )
be_bryan 0:b74591d5ab33 113 {
be_bryan 0:b74591d5ab33 114 if (st_sha1_restore_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 115 return; // Return HASH_BUSY timout error here
be_bryan 0:b74591d5ab33 116 }
be_bryan 0:b74591d5ab33 117 if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *) data, ST_SHA1_BLOCK_SIZE) != 0) {
be_bryan 0:b74591d5ab33 118 return; // Return error code
be_bryan 0:b74591d5ab33 119 }
be_bryan 0:b74591d5ab33 120
be_bryan 0:b74591d5ab33 121 if (st_sha1_save_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 122 return; // return HASH_BUSY timeout Error here
be_bryan 0:b74591d5ab33 123 }
be_bryan 0:b74591d5ab33 124 }
be_bryan 0:b74591d5ab33 125
be_bryan 0:b74591d5ab33 126 void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen )
be_bryan 0:b74591d5ab33 127 {
be_bryan 0:b74591d5ab33 128 size_t currentlen = ilen;
be_bryan 0:b74591d5ab33 129 if (st_sha1_restore_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 130 return; // Return HASH_BUSY timout error here
be_bryan 0:b74591d5ab33 131 }
be_bryan 0:b74591d5ab33 132
be_bryan 0:b74591d5ab33 133 // store mechanism to accumulate ST_SHA1_BLOCK_SIZE bytes (512 bits) in the HW
be_bryan 0:b74591d5ab33 134 if (currentlen == 0){ // only change HW status is size if 0
be_bryan 0:b74591d5ab33 135 if(ctx->hhash_sha1.Phase == HAL_HASH_PHASE_READY) {
be_bryan 0:b74591d5ab33 136 /* Select the SHA1 mode and reset the HASH processor core, so that the HASH will be ready to compute
be_bryan 0:b74591d5ab33 137 the message digest of a new message */
be_bryan 0:b74591d5ab33 138 HASH->CR |= HASH_ALGOSELECTION_SHA1 | HASH_CR_INIT;
be_bryan 0:b74591d5ab33 139 }
be_bryan 0:b74591d5ab33 140 ctx->hhash_sha1.Phase = HAL_HASH_PHASE_PROCESS;
be_bryan 0:b74591d5ab33 141 } else if (currentlen < (ST_SHA1_BLOCK_SIZE - ctx->sbuf_len)) {
be_bryan 0:b74591d5ab33 142 // only buffurize
be_bryan 0:b74591d5ab33 143 memcpy(ctx->sbuf + ctx->sbuf_len, input, currentlen);
be_bryan 0:b74591d5ab33 144 ctx->sbuf_len += currentlen;
be_bryan 0:b74591d5ab33 145 } else {
be_bryan 0:b74591d5ab33 146 // fill buffer and process it
be_bryan 0:b74591d5ab33 147 memcpy(ctx->sbuf + ctx->sbuf_len, input, (ST_SHA1_BLOCK_SIZE - ctx->sbuf_len));
be_bryan 0:b74591d5ab33 148 currentlen -= (ST_SHA1_BLOCK_SIZE - ctx->sbuf_len);
be_bryan 0:b74591d5ab33 149 mbedtls_sha1_process(ctx, ctx->sbuf);
be_bryan 0:b74591d5ab33 150 // Process every input as long as it is %64 bytes, ie 512 bits
be_bryan 0:b74591d5ab33 151 size_t iter = currentlen / ST_SHA1_BLOCK_SIZE;
be_bryan 0:b74591d5ab33 152 if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, (uint8_t *)(input + ST_SHA1_BLOCK_SIZE - ctx->sbuf_len), (iter * ST_SHA1_BLOCK_SIZE)) != 0) {
be_bryan 0:b74591d5ab33 153 return; // Return error code here
be_bryan 0:b74591d5ab33 154 }
be_bryan 0:b74591d5ab33 155 // sbuf is completely accumulated, now copy up to 63 remaining bytes
be_bryan 0:b74591d5ab33 156 ctx->sbuf_len = currentlen % ST_SHA1_BLOCK_SIZE;
be_bryan 0:b74591d5ab33 157 if (ctx->sbuf_len !=0) {
be_bryan 0:b74591d5ab33 158 memcpy(ctx->sbuf, input + ilen - ctx->sbuf_len, ctx->sbuf_len);
be_bryan 0:b74591d5ab33 159 }
be_bryan 0:b74591d5ab33 160 }
be_bryan 0:b74591d5ab33 161 if (st_sha1_save_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 162 return; // return HASH_BUSY timeout Error here
be_bryan 0:b74591d5ab33 163 }
be_bryan 0:b74591d5ab33 164 }
be_bryan 0:b74591d5ab33 165
be_bryan 0:b74591d5ab33 166 void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
be_bryan 0:b74591d5ab33 167 {
be_bryan 0:b74591d5ab33 168 if (st_sha1_restore_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 169 return; // Return HASH_BUSY timout error here
be_bryan 0:b74591d5ab33 170 }
be_bryan 0:b74591d5ab33 171
be_bryan 0:b74591d5ab33 172 if (ctx->sbuf_len > 0) {
be_bryan 0:b74591d5ab33 173 if (HAL_HASH_SHA1_Accumulate(&ctx->hhash_sha1, ctx->sbuf, ctx->sbuf_len) != 0) {
be_bryan 0:b74591d5ab33 174 return; // Return error code here
be_bryan 0:b74591d5ab33 175 }
be_bryan 0:b74591d5ab33 176 }
be_bryan 0:b74591d5ab33 177 mbedtls_zeroize(ctx->sbuf, ST_SHA1_BLOCK_SIZE);
be_bryan 0:b74591d5ab33 178 ctx->sbuf_len = 0;
be_bryan 0:b74591d5ab33 179 __HAL_HASH_START_DIGEST();
be_bryan 0:b74591d5ab33 180
be_bryan 0:b74591d5ab33 181 if (HAL_HASH_SHA1_Finish(&ctx->hhash_sha1, output, 10) != 0){
be_bryan 0:b74591d5ab33 182 return; // error code to be returned
be_bryan 0:b74591d5ab33 183 }
be_bryan 0:b74591d5ab33 184 if (st_sha1_save_hw_context(ctx) != 1) {
be_bryan 0:b74591d5ab33 185 return; // return HASH_BUSY timeout Error here
be_bryan 0:b74591d5ab33 186 }
be_bryan 0:b74591d5ab33 187 }
be_bryan 0:b74591d5ab33 188
be_bryan 0:b74591d5ab33 189 #endif /*MBEDTLS_SHA1_ALT*/