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/aes_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 * Hardware aes implementation for STM32F4 STM32F7 and STM32L4 families
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
be_bryan 0:b74591d5ab33 21 #include <string.h>
be_bryan 0:b74591d5ab33 22 #include "mbedtls/aes.h"
be_bryan 0:b74591d5ab33 23
be_bryan 0:b74591d5ab33 24 #if defined(MBEDTLS_AES_ALT)
be_bryan 0:b74591d5ab33 25
be_bryan 0:b74591d5ab33 26 #if defined(TARGET_STM32L486xG)
be_bryan 0:b74591d5ab33 27 //the following defines are provided to maintain compatibility between STM32 families
be_bryan 0:b74591d5ab33 28 #define __HAL_RCC_CRYP_CLK_ENABLE __HAL_RCC_AES_CLK_ENABLE
be_bryan 0:b74591d5ab33 29 #define __HAL_RCC_CRYP_FORCE_RESET __HAL_RCC_AES_FORCE_RESET
be_bryan 0:b74591d5ab33 30 #define __HAL_RCC_CRYP_RELEASE_RESET __HAL_RCC_AES_RELEASE_RESET
be_bryan 0:b74591d5ab33 31 #define CRYP AES
be_bryan 0:b74591d5ab33 32 #endif
be_bryan 0:b74591d5ab33 33
be_bryan 0:b74591d5ab33 34 static int aes_set_key( mbedtls_aes_context *ctx, const unsigned char *key, unsigned int keybits )
be_bryan 0:b74591d5ab33 35 {
be_bryan 0:b74591d5ab33 36 switch( keybits ) {
be_bryan 0:b74591d5ab33 37 case 128:
be_bryan 0:b74591d5ab33 38 ctx->hcryp_aes.Init.KeySize = CRYP_KEYSIZE_128B;
be_bryan 0:b74591d5ab33 39 memcpy(ctx->aes_key, key, 16);
be_bryan 0:b74591d5ab33 40 break;
be_bryan 0:b74591d5ab33 41 case 192:
be_bryan 0:b74591d5ab33 42 #if defined (TARGET_STM32L486xG)
be_bryan 0:b74591d5ab33 43 return(MBEDTLS_ERR_AES_INVALID_KEY_LENGTH);
be_bryan 0:b74591d5ab33 44 #else
be_bryan 0:b74591d5ab33 45 ctx->hcryp_aes.Init.KeySize = CRYP_KEYSIZE_192B;
be_bryan 0:b74591d5ab33 46 memcpy(ctx->aes_key, key, 24);
be_bryan 0:b74591d5ab33 47 break;
be_bryan 0:b74591d5ab33 48 #endif
be_bryan 0:b74591d5ab33 49
be_bryan 0:b74591d5ab33 50 case 256:
be_bryan 0:b74591d5ab33 51 ctx->hcryp_aes.Init.KeySize = CRYP_KEYSIZE_256B;
be_bryan 0:b74591d5ab33 52 memcpy(ctx->aes_key, key, 32);
be_bryan 0:b74591d5ab33 53 break;
be_bryan 0:b74591d5ab33 54 default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
be_bryan 0:b74591d5ab33 55 }
be_bryan 0:b74591d5ab33 56
be_bryan 0:b74591d5ab33 57 /* Deinitializes the CRYP peripheral */
be_bryan 0:b74591d5ab33 58 if (HAL_CRYP_DeInit(&ctx->hcryp_aes) == HAL_ERROR)
be_bryan 0:b74591d5ab33 59 return (HAL_ERROR);
be_bryan 0:b74591d5ab33 60
be_bryan 0:b74591d5ab33 61 ctx->hcryp_aes.Init.DataType = CRYP_DATATYPE_8B;
be_bryan 0:b74591d5ab33 62 ctx->hcryp_aes.Instance = CRYP;
be_bryan 0:b74591d5ab33 63 /* Enable CRYP clock */
be_bryan 0:b74591d5ab33 64 __HAL_RCC_CRYP_CLK_ENABLE();
be_bryan 0:b74591d5ab33 65
be_bryan 0:b74591d5ab33 66 ctx->hcryp_aes.Init.pKey = ctx->aes_key;
be_bryan 0:b74591d5ab33 67 #if defined (TARGET_STM32L486xG)
be_bryan 0:b74591d5ab33 68 ctx->hcryp_aes.Init.KeyWriteFlag = CRYP_KEY_WRITE_ENABLE;
be_bryan 0:b74591d5ab33 69 #endif
be_bryan 0:b74591d5ab33 70 if (HAL_CRYP_Init(&ctx->hcryp_aes) == HAL_ERROR)
be_bryan 0:b74591d5ab33 71 return (HAL_ERROR);
be_bryan 0:b74591d5ab33 72
be_bryan 0:b74591d5ab33 73 /* allow multi-instance of CRYP use: save context for CRYP HW module CR */
be_bryan 0:b74591d5ab33 74 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR;
be_bryan 0:b74591d5ab33 75 return(0);
be_bryan 0:b74591d5ab33 76
be_bryan 0:b74591d5ab33 77 }
be_bryan 0:b74591d5ab33 78
be_bryan 0:b74591d5ab33 79 /* Implementation that should never be optimized out by the compiler */
be_bryan 0:b74591d5ab33 80 static void mbedtls_zeroize( void *v, size_t n )
be_bryan 0:b74591d5ab33 81 {
be_bryan 0:b74591d5ab33 82 volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
be_bryan 0:b74591d5ab33 83 }
be_bryan 0:b74591d5ab33 84
be_bryan 0:b74591d5ab33 85
be_bryan 0:b74591d5ab33 86 void mbedtls_aes_init( mbedtls_aes_context *ctx )
be_bryan 0:b74591d5ab33 87 {
be_bryan 0:b74591d5ab33 88 memset( ctx, 0, sizeof( mbedtls_aes_context ) );
be_bryan 0:b74591d5ab33 89
be_bryan 0:b74591d5ab33 90 }
be_bryan 0:b74591d5ab33 91
be_bryan 0:b74591d5ab33 92
be_bryan 0:b74591d5ab33 93 void mbedtls_aes_free( mbedtls_aes_context *ctx )
be_bryan 0:b74591d5ab33 94 {
be_bryan 0:b74591d5ab33 95 if( ctx == NULL )
be_bryan 0:b74591d5ab33 96 return;
be_bryan 0:b74591d5ab33 97 /* Force the CRYP Periheral Clock Reset */
be_bryan 0:b74591d5ab33 98 __HAL_RCC_CRYP_FORCE_RESET();
be_bryan 0:b74591d5ab33 99
be_bryan 0:b74591d5ab33 100 /* Release the CRYP Periheral Clock Reset */
be_bryan 0:b74591d5ab33 101 __HAL_RCC_CRYP_RELEASE_RESET();
be_bryan 0:b74591d5ab33 102
be_bryan 0:b74591d5ab33 103 mbedtls_zeroize( ctx, sizeof( mbedtls_aes_context ) );
be_bryan 0:b74591d5ab33 104 }
be_bryan 0:b74591d5ab33 105
be_bryan 0:b74591d5ab33 106
be_bryan 0:b74591d5ab33 107 int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
be_bryan 0:b74591d5ab33 108 unsigned int keybits )
be_bryan 0:b74591d5ab33 109 {
be_bryan 0:b74591d5ab33 110 int ret_val = 0;
be_bryan 0:b74591d5ab33 111 ret_val = aes_set_key(ctx, key, keybits);
be_bryan 0:b74591d5ab33 112 return(ret_val);
be_bryan 0:b74591d5ab33 113 }
be_bryan 0:b74591d5ab33 114
be_bryan 0:b74591d5ab33 115 int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
be_bryan 0:b74591d5ab33 116 unsigned int keybits )
be_bryan 0:b74591d5ab33 117 {
be_bryan 0:b74591d5ab33 118 int ret_val = 0;
be_bryan 0:b74591d5ab33 119 ret_val = aes_set_key(ctx, key, keybits);
be_bryan 0:b74591d5ab33 120 return( ret_val );
be_bryan 0:b74591d5ab33 121 }
be_bryan 0:b74591d5ab33 122
be_bryan 0:b74591d5ab33 123
be_bryan 0:b74591d5ab33 124 int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 125 int mode,
be_bryan 0:b74591d5ab33 126 const unsigned char input[16],
be_bryan 0:b74591d5ab33 127 unsigned char output[16] )
be_bryan 0:b74591d5ab33 128 {
be_bryan 0:b74591d5ab33 129
be_bryan 0:b74591d5ab33 130 /* allow multi-instance of CRYP use: restore context for CRYP hw module */
be_bryan 0:b74591d5ab33 131 ctx->hcryp_aes.Instance->CR = ctx->ctx_save_cr;
be_bryan 0:b74591d5ab33 132 ctx->hcryp_aes.Phase = HAL_CRYP_PHASE_READY;
be_bryan 0:b74591d5ab33 133 ctx->hcryp_aes.Init.DataType = CRYP_DATATYPE_8B;
be_bryan 0:b74591d5ab33 134 ctx->hcryp_aes.Init.pKey = ctx->aes_key;
be_bryan 0:b74591d5ab33 135
be_bryan 0:b74591d5ab33 136 if(mode == MBEDTLS_AES_DECRYPT) { /* AES decryption */
be_bryan 0:b74591d5ab33 137 if (mbedtls_internal_aes_decrypt( ctx, input, output )){
be_bryan 0:b74591d5ab33 138 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 139 }
be_bryan 0:b74591d5ab33 140 } else { /* AES encryption */
be_bryan 0:b74591d5ab33 141 if (mbedtls_internal_aes_encrypt( ctx, input, output )) {
be_bryan 0:b74591d5ab33 142 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 143 }
be_bryan 0:b74591d5ab33 144 }
be_bryan 0:b74591d5ab33 145 /* allow multi-instance of CRYP use: save context for CRYP HW module CR */
be_bryan 0:b74591d5ab33 146 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR;
be_bryan 0:b74591d5ab33 147
be_bryan 0:b74591d5ab33 148 return( 0 );
be_bryan 0:b74591d5ab33 149 }
be_bryan 0:b74591d5ab33 150
be_bryan 0:b74591d5ab33 151 #if defined(MBEDTLS_CIPHER_MODE_CBC)
be_bryan 0:b74591d5ab33 152 #if defined (TARGET_STM32L486xG)
be_bryan 0:b74591d5ab33 153 static int st_cbc_restore_context(mbedtls_aes_context *ctx){
be_bryan 0:b74591d5ab33 154 uint32_t tickstart;
be_bryan 0:b74591d5ab33 155 tickstart = HAL_GetTick();
be_bryan 0:b74591d5ab33 156 while((ctx->hcryp_aes.Instance->SR & AES_SR_BUSY) != 0){
be_bryan 0:b74591d5ab33 157 if ((HAL_GetTick() - tickstart) > ST_AES_TIMEOUT) {
be_bryan 0:b74591d5ab33 158 return ST_ERR_AES_BUSY; // timeout: CRYP processor is busy
be_bryan 0:b74591d5ab33 159 }
be_bryan 0:b74591d5ab33 160 }
be_bryan 0:b74591d5ab33 161 /* allow multi-instance of CRYP use: restore context for CRYP hw module */
be_bryan 0:b74591d5ab33 162 ctx->hcryp_aes.Instance->CR = ctx->ctx_save_cr;
be_bryan 0:b74591d5ab33 163 return 0;
be_bryan 0:b74591d5ab33 164 }
be_bryan 0:b74591d5ab33 165
be_bryan 0:b74591d5ab33 166 static int st_hal_cryp_cbc( mbedtls_aes_context *ctx, uint32_t opmode, size_t length,
be_bryan 0:b74591d5ab33 167 unsigned char iv[16], uint8_t *input, uint8_t *output)
be_bryan 0:b74591d5ab33 168 {
be_bryan 0:b74591d5ab33 169 ctx->hcryp_aes.Init.pInitVect = &iv[0]; // used in process, not in the init
be_bryan 0:b74591d5ab33 170 /* At this moment only, we know we have CBC mode: Re-initialize AES
be_bryan 0:b74591d5ab33 171 IP with proper parameters and apply key and IV for multi context usecase */
be_bryan 0:b74591d5ab33 172 if (HAL_CRYP_DeInit(&ctx->hcryp_aes) != HAL_OK)
be_bryan 0:b74591d5ab33 173 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 174 ctx->hcryp_aes.Init.OperatingMode = opmode;
be_bryan 0:b74591d5ab33 175 ctx->hcryp_aes.Init.ChainingMode = CRYP_CHAINMODE_AES_CBC;
be_bryan 0:b74591d5ab33 176 ctx->hcryp_aes.Init.KeyWriteFlag = CRYP_KEY_WRITE_ENABLE;
be_bryan 0:b74591d5ab33 177 if (HAL_CRYP_Init(&ctx->hcryp_aes) != HAL_OK)
be_bryan 0:b74591d5ab33 178 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 179
be_bryan 0:b74591d5ab33 180 if(HAL_CRYPEx_AES(&ctx->hcryp_aes, input, length, output, 10) != 0)
be_bryan 0:b74591d5ab33 181 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 182 return 0;
be_bryan 0:b74591d5ab33 183 }
be_bryan 0:b74591d5ab33 184 #else /* STM32F4 and STM32F7 */
be_bryan 0:b74591d5ab33 185 static int st_cbc_restore_context(mbedtls_aes_context *ctx){
be_bryan 0:b74591d5ab33 186 /* allow multi-instance of CRYP use: restore context for CRYP hw module */
be_bryan 0:b74591d5ab33 187 ctx->hcryp_aes.Instance->CR = ctx->ctx_save_cr;
be_bryan 0:b74591d5ab33 188 /* Re-initialize AES processor with proper parameters
be_bryan 0:b74591d5ab33 189 and (re-)apply key and IV for multi context usecases */
be_bryan 0:b74591d5ab33 190 if (HAL_CRYP_DeInit(&ctx->hcryp_aes) != HAL_OK)
be_bryan 0:b74591d5ab33 191 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 192 if (HAL_CRYP_Init(&ctx->hcryp_aes) != HAL_OK)
be_bryan 0:b74591d5ab33 193 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 194 return 0;
be_bryan 0:b74591d5ab33 195 }
be_bryan 0:b74591d5ab33 196
be_bryan 0:b74591d5ab33 197 #endif /* TARGET_STM32L486xG */
be_bryan 0:b74591d5ab33 198
be_bryan 0:b74591d5ab33 199 int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 200 int mode,
be_bryan 0:b74591d5ab33 201 size_t length,
be_bryan 0:b74591d5ab33 202 unsigned char iv[16],
be_bryan 0:b74591d5ab33 203 const unsigned char *input,
be_bryan 0:b74591d5ab33 204 unsigned char *output )
be_bryan 0:b74591d5ab33 205 {
be_bryan 0:b74591d5ab33 206 uint32_t tickstart;
be_bryan 0:b74591d5ab33 207 uint32_t *iv_ptr = (uint32_t *)&iv[0];
be_bryan 0:b74591d5ab33 208 if( length % 16 )
be_bryan 0:b74591d5ab33 209 return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
be_bryan 0:b74591d5ab33 210 ctx->hcryp_aes.Init.pInitVect = &iv[0];
be_bryan 0:b74591d5ab33 211 if (st_cbc_restore_context(ctx) != 0)
be_bryan 0:b74591d5ab33 212 return (ST_ERR_AES_BUSY);
be_bryan 0:b74591d5ab33 213
be_bryan 0:b74591d5ab33 214 #if defined (TARGET_STM32L486xG)
be_bryan 0:b74591d5ab33 215
be_bryan 0:b74591d5ab33 216 if( mode == MBEDTLS_AES_DECRYPT ) {
be_bryan 0:b74591d5ab33 217 if (st_hal_cryp_cbc(ctx, CRYP_ALGOMODE_KEYDERIVATION_DECRYPT, length, iv, (uint8_t *)input, (uint8_t *)output) != 0)
be_bryan 0:b74591d5ab33 218 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 219 /* Save the internal IV vector for multi context purpose */
be_bryan 0:b74591d5ab33 220 tickstart = HAL_GetTick();
be_bryan 0:b74591d5ab33 221 while((ctx->hcryp_aes.Instance->SR & AES_SR_BUSY) != 0){
be_bryan 0:b74591d5ab33 222 if ((HAL_GetTick() - tickstart) > ST_AES_TIMEOUT) {
be_bryan 0:b74591d5ab33 223 return ST_ERR_AES_BUSY; // timeout: CRYP processor is busy
be_bryan 0:b74591d5ab33 224 }
be_bryan 0:b74591d5ab33 225 }
be_bryan 0:b74591d5ab33 226 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR; // save here before overwritten
be_bryan 0:b74591d5ab33 227 ctx->hcryp_aes.Instance->CR &= ~AES_CR_EN;
be_bryan 0:b74591d5ab33 228 *iv_ptr++ = ctx->hcryp_aes.Instance->IVR3;
be_bryan 0:b74591d5ab33 229 *iv_ptr++ = ctx->hcryp_aes.Instance->IVR2;
be_bryan 0:b74591d5ab33 230 *iv_ptr++ = ctx->hcryp_aes.Instance->IVR1;
be_bryan 0:b74591d5ab33 231 *iv_ptr++ = ctx->hcryp_aes.Instance->IVR0;
be_bryan 0:b74591d5ab33 232 } else {
be_bryan 0:b74591d5ab33 233 if (st_hal_cryp_cbc(ctx, CRYP_ALGOMODE_ENCRYPT, length, iv, (uint8_t *)input, (uint8_t *)output) != 0)
be_bryan 0:b74591d5ab33 234 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 235 memcpy( iv, output, 16 ); /* current output is the IV vector for the next call */
be_bryan 0:b74591d5ab33 236 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR;
be_bryan 0:b74591d5ab33 237 }
be_bryan 0:b74591d5ab33 238
be_bryan 0:b74591d5ab33 239 #else
be_bryan 0:b74591d5ab33 240
be_bryan 0:b74591d5ab33 241 if( mode == MBEDTLS_AES_DECRYPT ) {
be_bryan 0:b74591d5ab33 242 if (HAL_CRYP_AESCBC_Decrypt(&ctx->hcryp_aes, (uint8_t *)input, length, (uint8_t *)output, 10) != HAL_OK)
be_bryan 0:b74591d5ab33 243 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 244 /* Save the internal IV vector for multi context purpose */
be_bryan 0:b74591d5ab33 245 tickstart = HAL_GetTick();
be_bryan 0:b74591d5ab33 246 while((ctx->hcryp_aes.Instance->SR & (CRYP_SR_IFEM | CRYP_SR_OFNE | CRYP_SR_BUSY)) != CRYP_SR_IFEM){
be_bryan 0:b74591d5ab33 247 if ((HAL_GetTick() - tickstart) > ST_AES_TIMEOUT) {
be_bryan 0:b74591d5ab33 248 return ST_ERR_AES_BUSY; // timeout: CRYP processor is busy
be_bryan 0:b74591d5ab33 249 }
be_bryan 0:b74591d5ab33 250 }
be_bryan 0:b74591d5ab33 251 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR; // save here before overwritten
be_bryan 0:b74591d5ab33 252 ctx->hcryp_aes.Instance->CR &= ~CRYP_CR_CRYPEN;
be_bryan 0:b74591d5ab33 253 *iv_ptr++ = ctx->hcryp_aes.Instance->IV0LR;
be_bryan 0:b74591d5ab33 254 *iv_ptr++ = ctx->hcryp_aes.Instance->IV0RR;
be_bryan 0:b74591d5ab33 255 *iv_ptr++ = ctx->hcryp_aes.Instance->IV1LR;
be_bryan 0:b74591d5ab33 256 *iv_ptr++ = ctx->hcryp_aes.Instance->IV1RR;
be_bryan 0:b74591d5ab33 257 } else {
be_bryan 0:b74591d5ab33 258 if (HAL_CRYP_AESCBC_Encrypt(&ctx->hcryp_aes, (uint8_t *)input, length, (uint8_t *)output, 10) != HAL_OK)
be_bryan 0:b74591d5ab33 259 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 260 memcpy( iv, output, 16 ); /* current output is the IV vector for the next call */
be_bryan 0:b74591d5ab33 261 ctx->ctx_save_cr = ctx->hcryp_aes.Instance->CR;
be_bryan 0:b74591d5ab33 262 }
be_bryan 0:b74591d5ab33 263
be_bryan 0:b74591d5ab33 264 #endif
be_bryan 0:b74591d5ab33 265 return 0;
be_bryan 0:b74591d5ab33 266 }
be_bryan 0:b74591d5ab33 267 #endif /* MBEDTLS_CIPHER_MODE_CBC */
be_bryan 0:b74591d5ab33 268
be_bryan 0:b74591d5ab33 269 #if defined(MBEDTLS_CIPHER_MODE_CFB)
be_bryan 0:b74591d5ab33 270 int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 271 int mode,
be_bryan 0:b74591d5ab33 272 size_t length,
be_bryan 0:b74591d5ab33 273 size_t *iv_off,
be_bryan 0:b74591d5ab33 274 unsigned char iv[16],
be_bryan 0:b74591d5ab33 275 const unsigned char *input,
be_bryan 0:b74591d5ab33 276 unsigned char *output )
be_bryan 0:b74591d5ab33 277 {
be_bryan 0:b74591d5ab33 278 int c;
be_bryan 0:b74591d5ab33 279 size_t n = *iv_off;
be_bryan 0:b74591d5ab33 280
be_bryan 0:b74591d5ab33 281 if( mode == MBEDTLS_AES_DECRYPT ) {
be_bryan 0:b74591d5ab33 282 while( length-- ) {
be_bryan 0:b74591d5ab33 283 if( n == 0 )
be_bryan 0:b74591d5ab33 284 if (mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv ) != 0)
be_bryan 0:b74591d5ab33 285 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 286
be_bryan 0:b74591d5ab33 287 c = *input++;
be_bryan 0:b74591d5ab33 288 *output++ = (unsigned char)( c ^ iv[n] );
be_bryan 0:b74591d5ab33 289 iv[n] = (unsigned char) c;
be_bryan 0:b74591d5ab33 290
be_bryan 0:b74591d5ab33 291 n = ( n + 1 ) & 0x0F;
be_bryan 0:b74591d5ab33 292 }
be_bryan 0:b74591d5ab33 293 } else {
be_bryan 0:b74591d5ab33 294 while( length-- ) {
be_bryan 0:b74591d5ab33 295 if( n == 0 )
be_bryan 0:b74591d5ab33 296 if (mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv ) != 0)
be_bryan 0:b74591d5ab33 297 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 298
be_bryan 0:b74591d5ab33 299 iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
be_bryan 0:b74591d5ab33 300
be_bryan 0:b74591d5ab33 301 n = ( n + 1 ) & 0x0F;
be_bryan 0:b74591d5ab33 302 }
be_bryan 0:b74591d5ab33 303 }
be_bryan 0:b74591d5ab33 304
be_bryan 0:b74591d5ab33 305 *iv_off = n;
be_bryan 0:b74591d5ab33 306
be_bryan 0:b74591d5ab33 307 return( 0 );
be_bryan 0:b74591d5ab33 308 }
be_bryan 0:b74591d5ab33 309
be_bryan 0:b74591d5ab33 310
be_bryan 0:b74591d5ab33 311 int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 312 int mode,
be_bryan 0:b74591d5ab33 313 size_t length,
be_bryan 0:b74591d5ab33 314 unsigned char iv[16],
be_bryan 0:b74591d5ab33 315 const unsigned char *input,
be_bryan 0:b74591d5ab33 316 unsigned char *output )
be_bryan 0:b74591d5ab33 317 {
be_bryan 0:b74591d5ab33 318 unsigned char c;
be_bryan 0:b74591d5ab33 319 unsigned char ov[17];
be_bryan 0:b74591d5ab33 320
be_bryan 0:b74591d5ab33 321 while( length-- ) {
be_bryan 0:b74591d5ab33 322 memcpy( ov, iv, 16 );
be_bryan 0:b74591d5ab33 323 if (mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv ) != 0)
be_bryan 0:b74591d5ab33 324 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 325
be_bryan 0:b74591d5ab33 326 if( mode == MBEDTLS_AES_DECRYPT )
be_bryan 0:b74591d5ab33 327 ov[16] = *input;
be_bryan 0:b74591d5ab33 328
be_bryan 0:b74591d5ab33 329 c = *output++ = (unsigned char)( iv[0] ^ *input++ );
be_bryan 0:b74591d5ab33 330
be_bryan 0:b74591d5ab33 331 if( mode == MBEDTLS_AES_ENCRYPT )
be_bryan 0:b74591d5ab33 332 ov[16] = c;
be_bryan 0:b74591d5ab33 333
be_bryan 0:b74591d5ab33 334 memcpy( iv, ov + 1, 16 );
be_bryan 0:b74591d5ab33 335 }
be_bryan 0:b74591d5ab33 336
be_bryan 0:b74591d5ab33 337 return( 0 );
be_bryan 0:b74591d5ab33 338 }
be_bryan 0:b74591d5ab33 339
be_bryan 0:b74591d5ab33 340 #endif /*MBEDTLS_CIPHER_MODE_CFB */
be_bryan 0:b74591d5ab33 341
be_bryan 0:b74591d5ab33 342 #if defined(MBEDTLS_CIPHER_MODE_CTR)
be_bryan 0:b74591d5ab33 343 int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 344 size_t length,
be_bryan 0:b74591d5ab33 345 size_t *nc_off,
be_bryan 0:b74591d5ab33 346 unsigned char nonce_counter[16],
be_bryan 0:b74591d5ab33 347 unsigned char stream_block[16],
be_bryan 0:b74591d5ab33 348 const unsigned char *input,
be_bryan 0:b74591d5ab33 349 unsigned char *output )
be_bryan 0:b74591d5ab33 350 {
be_bryan 0:b74591d5ab33 351 int c, i;
be_bryan 0:b74591d5ab33 352 size_t n = *nc_off;
be_bryan 0:b74591d5ab33 353
be_bryan 0:b74591d5ab33 354 while( length-- )
be_bryan 0:b74591d5ab33 355 {
be_bryan 0:b74591d5ab33 356 if( n == 0 ) {
be_bryan 0:b74591d5ab33 357 if (mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block ) != 0)
be_bryan 0:b74591d5ab33 358 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 359
be_bryan 0:b74591d5ab33 360 for( i = 16; i > 0; i-- )
be_bryan 0:b74591d5ab33 361 if( ++nonce_counter[i - 1] != 0 )
be_bryan 0:b74591d5ab33 362 break;
be_bryan 0:b74591d5ab33 363 }
be_bryan 0:b74591d5ab33 364 c = *input++;
be_bryan 0:b74591d5ab33 365 *output++ = (unsigned char)( c ^ stream_block[n] );
be_bryan 0:b74591d5ab33 366
be_bryan 0:b74591d5ab33 367 n = ( n + 1 ) & 0x0F;
be_bryan 0:b74591d5ab33 368 }
be_bryan 0:b74591d5ab33 369
be_bryan 0:b74591d5ab33 370 *nc_off = n;
be_bryan 0:b74591d5ab33 371
be_bryan 0:b74591d5ab33 372 return( 0 );
be_bryan 0:b74591d5ab33 373 }
be_bryan 0:b74591d5ab33 374 #endif /* MBEDTLS_CIPHER_MODE_CTR */
be_bryan 0:b74591d5ab33 375
be_bryan 0:b74591d5ab33 376 int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 377 const unsigned char input[16],
be_bryan 0:b74591d5ab33 378 unsigned char output[16] )
be_bryan 0:b74591d5ab33 379 {
be_bryan 0:b74591d5ab33 380 if (HAL_CRYP_AESECB_Encrypt(&ctx->hcryp_aes, (uint8_t *)input, 16, (uint8_t *)output, 10) != HAL_OK) {
be_bryan 0:b74591d5ab33 381 // error found
be_bryan 0:b74591d5ab33 382 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 383 }
be_bryan 0:b74591d5ab33 384 return 0;
be_bryan 0:b74591d5ab33 385
be_bryan 0:b74591d5ab33 386 }
be_bryan 0:b74591d5ab33 387
be_bryan 0:b74591d5ab33 388 int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 389 const unsigned char input[16],
be_bryan 0:b74591d5ab33 390 unsigned char output[16] )
be_bryan 0:b74591d5ab33 391 {
be_bryan 0:b74591d5ab33 392 if(HAL_CRYP_AESECB_Decrypt(&ctx->hcryp_aes, (uint8_t *)input, 16, (uint8_t *)output, 10) != HAL_OK) {
be_bryan 0:b74591d5ab33 393 // error found
be_bryan 0:b74591d5ab33 394 return ST_ERR_AES_BUSY;
be_bryan 0:b74591d5ab33 395 }
be_bryan 0:b74591d5ab33 396 return 0;
be_bryan 0:b74591d5ab33 397 }
be_bryan 0:b74591d5ab33 398
be_bryan 0:b74591d5ab33 399 #if !defined(MBEDTLS_DEPRECATED_REMOVED)
be_bryan 0:b74591d5ab33 400 void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 401 const unsigned char input[16],
be_bryan 0:b74591d5ab33 402 unsigned char output[16] )
be_bryan 0:b74591d5ab33 403 {
be_bryan 0:b74591d5ab33 404 mbedtls_internal_aes_encrypt( ctx, input, output );
be_bryan 0:b74591d5ab33 405 }
be_bryan 0:b74591d5ab33 406
be_bryan 0:b74591d5ab33 407 void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
be_bryan 0:b74591d5ab33 408 const unsigned char input[16],
be_bryan 0:b74591d5ab33 409 unsigned char output[16] )
be_bryan 0:b74591d5ab33 410 {
be_bryan 0:b74591d5ab33 411 mbedtls_internal_aes_decrypt( ctx, input, output );
be_bryan 0:b74591d5ab33 412 }
be_bryan 0:b74591d5ab33 413 #endif /* MBEDTLS_DEPRECATED_REMOVED */
be_bryan 0:b74591d5ab33 414 #endif /*MBEDTLS_AES_ALT*/