mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp_ex.c@581:39197bcd20f2, 2015-07-02 (annotated)

Committer:
mbed_official
Date:
Thu Jul 02 16:30:08 2015 +0100
Revision:
581:39197bcd20f2
Parent:
532:fe11edbda85c
Child:
613:bc40b8d2aec4
Synchronized with git revision ae2d3cdffe70184eb8736d94f76c45c93f4b7724



Full URL: https://github.com/mbedmicro/mbed/commit/ae2d3cdffe70184eb8736d94f76c45c93f4b7724/



Make it possible to build the core mbed library with yotta

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 235:685d5f11838f 1 /**
mbed_official 235:685d5f11838f 2 ******************************************************************************
mbed_official 235:685d5f11838f 3 * @file stm32f4xx_hal_cryp_ex.c
mbed_official 235:685d5f11838f 4 * @author MCD Application Team
mbed_official 532:fe11edbda85c 5 * @version V1.3.0
mbed_official 532:fe11edbda85c 6 * @date 09-March-2015
mbed_official 235:685d5f11838f 7 * @brief Extended CRYP HAL module driver
mbed_official 235:685d5f11838f 8 * This file provides firmware functions to manage the following
mbed_official 235:685d5f11838f 9 * functionalities of CRYP extension peripheral:
mbed_official 235:685d5f11838f 10 * + Extended AES processing functions
mbed_official 235:685d5f11838f 11 *
mbed_official 235:685d5f11838f 12 @verbatim
mbed_official 235:685d5f11838f 13 ==============================================================================
mbed_official 235:685d5f11838f 14 ##### How to use this driver #####
mbed_official 235:685d5f11838f 15 ==============================================================================
mbed_official 235:685d5f11838f 16 [..]
mbed_official 235:685d5f11838f 17 The CRYP Extension HAL driver can be used as follows:
mbed_official 235:685d5f11838f 18 (#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():
mbed_official 532:fe11edbda85c 19 (##) Enable the CRYP interface clock using __HAL_RCC_CRYP_CLK_ENABLE()
mbed_official 235:685d5f11838f 20 (##) In case of using interrupts (e.g. HAL_CRYPEx_AESGCM_Encrypt_IT())
mbed_official 235:685d5f11838f 21 (+++) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()
mbed_official 235:685d5f11838f 22 (+++) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()
mbed_official 235:685d5f11838f 23 (+) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()
mbed_official 235:685d5f11838f 24 (##) In case of using DMA to control data transfer (e.g. HAL_AES_ECB_Encrypt_DMA())
mbed_official 235:685d5f11838f 25 (+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE()
mbed_official 235:685d5f11838f 26 (+++) Configure and enable two DMA streams one for managing data transfer from
mbed_official 235:685d5f11838f 27 memory to peripheral (input stream) and another stream for managing data
mbed_official 235:685d5f11838f 28 transfer from peripheral to memory (output stream)
mbed_official 532:fe11edbda85c 29 (+++) Associate the initialized DMA handle to the CRYP DMA handle
mbed_official 235:685d5f11838f 30 using __HAL_LINKDMA()
mbed_official 235:685d5f11838f 31 (+++) Configure the priority and enable the NVIC for the transfer complete
mbed_official 235:685d5f11838f 32 interrupt on the two DMA Streams. The output stream should have higher
mbed_official 235:685d5f11838f 33 priority than the input stream HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()
mbed_official 235:685d5f11838f 34 (#)Initialize the CRYP HAL using HAL_CRYP_Init(). This function configures mainly:
mbed_official 235:685d5f11838f 35 (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit
mbed_official 235:685d5f11838f 36 (##) The key size: 128, 192 and 256. This parameter is relevant only for AES
mbed_official 235:685d5f11838f 37 (##) The encryption/decryption key. Its size depends on the algorithm
mbed_official 235:685d5f11838f 38 used for encryption/decryption
mbed_official 235:685d5f11838f 39 (##) The initialization vector (counter). It is not used ECB mode.
mbed_official 235:685d5f11838f 40 (#)Three processing (encryption/decryption) functions are available:
mbed_official 235:685d5f11838f 41 (##) Polling mode: encryption and decryption APIs are blocking functions
mbed_official 235:685d5f11838f 42 i.e. they process the data and wait till the processing is finished
mbed_official 235:685d5f11838f 43 e.g. HAL_CRYPEx_AESGCM_Encrypt()
mbed_official 235:685d5f11838f 44 (##) Interrupt mode: encryption and decryption APIs are not blocking functions
mbed_official 235:685d5f11838f 45 i.e. they process the data under interrupt
mbed_official 235:685d5f11838f 46 e.g. HAL_CRYPEx_AESGCM_Encrypt_IT()
mbed_official 235:685d5f11838f 47 (##) DMA mode: encryption and decryption APIs are not blocking functions
mbed_official 235:685d5f11838f 48 i.e. the data transfer is ensured by DMA
mbed_official 235:685d5f11838f 49 e.g. HAL_CRYPEx_AESGCM_Encrypt_DMA()
mbed_official 235:685d5f11838f 50 (#)When the processing function is called at first time after HAL_CRYP_Init()
mbed_official 235:685d5f11838f 51 the CRYP peripheral is initialized and processes the buffer in input.
mbed_official 235:685d5f11838f 52 At second call, the processing function performs an append of the already
mbed_official 235:685d5f11838f 53 processed buffer.
mbed_official 235:685d5f11838f 54 When a new data block is to be processed, call HAL_CRYP_Init() then the
mbed_official 235:685d5f11838f 55 processing function.
mbed_official 235:685d5f11838f 56 (#)In AES-GCM and AES-CCM modes are an authenticated encryption algorithms
mbed_official 235:685d5f11838f 57 which provide authentication messages.
mbed_official 235:685d5f11838f 58 HAL_AES_GCM_Finish() and HAL_AES_CCM_Finish() are used to provide those
mbed_official 235:685d5f11838f 59 authentication messages.
mbed_official 235:685d5f11838f 60 Call those functions after the processing ones (polling, interrupt or DMA).
mbed_official 235:685d5f11838f 61 e.g. in AES-CCM mode call HAL_CRYPEx_AESCCM_Encrypt() to encrypt the plain data
mbed_official 235:685d5f11838f 62 then call HAL_CRYPEx_AESCCM_Finish() to get the authentication message
mbed_official 532:fe11edbda85c 63 @note: For CCM Encrypt/Decrypt API's, only DataType = 8-bit is supported by this version.
mbed_official 532:fe11edbda85c 64 @note: The HAL_CRYPEx_AESGCM_xxxx() implementation is limited to 32bits inputs data length
mbed_official 532:fe11edbda85c 65 (Plain/Cyphertext, Header) compared with GCM standards specifications (800-38D).
mbed_official 235:685d5f11838f 66 (#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.
mbed_official 235:685d5f11838f 67
mbed_official 235:685d5f11838f 68 @endverbatim
mbed_official 235:685d5f11838f 69 ******************************************************************************
mbed_official 235:685d5f11838f 70 * @attention
mbed_official 235:685d5f11838f 71 *
mbed_official 532:fe11edbda85c 72 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 235:685d5f11838f 73 *
mbed_official 235:685d5f11838f 74 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 235:685d5f11838f 75 * are permitted provided that the following conditions are met:
mbed_official 235:685d5f11838f 76 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 235:685d5f11838f 77 * this list of conditions and the following disclaimer.
mbed_official 235:685d5f11838f 78 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 235:685d5f11838f 79 * this list of conditions and the following disclaimer in the documentation
mbed_official 235:685d5f11838f 80 * and/or other materials provided with the distribution.
mbed_official 235:685d5f11838f 81 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 235:685d5f11838f 82 * may be used to endorse or promote products derived from this software
mbed_official 235:685d5f11838f 83 * without specific prior written permission.
mbed_official 235:685d5f11838f 84 *
mbed_official 235:685d5f11838f 85 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 235:685d5f11838f 86 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 235:685d5f11838f 87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 235:685d5f11838f 88 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 235:685d5f11838f 89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 235:685d5f11838f 90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 235:685d5f11838f 91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 235:685d5f11838f 92 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 235:685d5f11838f 93 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 235:685d5f11838f 94 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 235:685d5f11838f 95 *
mbed_official 235:685d5f11838f 96 ******************************************************************************
mbed_official 235:685d5f11838f 97 */
mbed_official 235:685d5f11838f 98
mbed_official 235:685d5f11838f 99 /* Includes ------------------------------------------------------------------*/
mbed_official 235:685d5f11838f 100 #include "stm32f4xx_hal.h"
mbed_official 235:685d5f11838f 101
mbed_official 235:685d5f11838f 102 /** @addtogroup STM32F4xx_HAL_Driver
mbed_official 235:685d5f11838f 103 * @{
mbed_official 235:685d5f11838f 104 */
mbed_official 235:685d5f11838f 105
mbed_official 532:fe11edbda85c 106 /** @defgroup CRYPEx CRYPEx
mbed_official 235:685d5f11838f 107 * @brief CRYP Extension HAL module driver.
mbed_official 235:685d5f11838f 108 * @{
mbed_official 235:685d5f11838f 109 */
mbed_official 235:685d5f11838f 110
mbed_official 235:685d5f11838f 111 #ifdef HAL_CRYP_MODULE_ENABLED
mbed_official 235:685d5f11838f 112
mbed_official 235:685d5f11838f 113 #if defined(STM32F437xx) || defined(STM32F439xx)
mbed_official 235:685d5f11838f 114
mbed_official 235:685d5f11838f 115 /* Private typedef -----------------------------------------------------------*/
mbed_official 235:685d5f11838f 116 /* Private define ------------------------------------------------------------*/
mbed_official 532:fe11edbda85c 117 /** @addtogroup CRYPEx_Private_define
mbed_official 532:fe11edbda85c 118 * @{
mbed_official 532:fe11edbda85c 119 */
mbed_official 235:685d5f11838f 120 #define CRYPEx_TIMEOUT_VALUE 1
mbed_official 532:fe11edbda85c 121 /**
mbed_official 532:fe11edbda85c 122 * @}
mbed_official 532:fe11edbda85c 123 */
mbed_official 532:fe11edbda85c 124
mbed_official 235:685d5f11838f 125 /* Private macro -------------------------------------------------------------*/
mbed_official 235:685d5f11838f 126 /* Private variables ---------------------------------------------------------*/
mbed_official 235:685d5f11838f 127 /* Private function prototypes -----------------------------------------------*/
mbed_official 532:fe11edbda85c 128 /** @defgroup CRYPEx_Private_Functions_prototypes CRYP Private Functions Prototypes
mbed_official 532:fe11edbda85c 129 * @{
mbed_official 532:fe11edbda85c 130 */
mbed_official 532:fe11edbda85c 131 static void CRYPEx_GCMCCM_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector);
mbed_official 235:685d5f11838f 132 static void CRYPEx_GCMCCM_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key, uint32_t KeySize);
mbed_official 235:685d5f11838f 133 static HAL_StatusTypeDef CRYPEx_GCMCCM_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t *Input, uint16_t Ilength, uint8_t *Output, uint32_t Timeout);
mbed_official 235:685d5f11838f 134 static HAL_StatusTypeDef CRYPEx_GCMCCM_SetHeaderPhase(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint32_t Timeout);
mbed_official 235:685d5f11838f 135 static void CRYPEx_GCMCCM_DMAInCplt(DMA_HandleTypeDef *hdma);
mbed_official 235:685d5f11838f 136 static void CRYPEx_GCMCCM_DMAOutCplt(DMA_HandleTypeDef *hdma);
mbed_official 235:685d5f11838f 137 static void CRYPEx_GCMCCM_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 235:685d5f11838f 138 static void CRYPEx_GCMCCM_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);
mbed_official 532:fe11edbda85c 139 /**
mbed_official 532:fe11edbda85c 140 * @}
mbed_official 532:fe11edbda85c 141 */
mbed_official 532:fe11edbda85c 142
mbed_official 235:685d5f11838f 143 /* Private functions ---------------------------------------------------------*/
mbed_official 532:fe11edbda85c 144 /** @addtogroup CRYPEx_Private_Functions
mbed_official 235:685d5f11838f 145 * @{
mbed_official 235:685d5f11838f 146 */
mbed_official 235:685d5f11838f 147
mbed_official 532:fe11edbda85c 148 /**
mbed_official 532:fe11edbda85c 149 * @brief DMA CRYP Input Data process complete callback.
mbed_official 532:fe11edbda85c 150 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 151 * @retval None
mbed_official 532:fe11edbda85c 152 */
mbed_official 532:fe11edbda85c 153 static void CRYPEx_GCMCCM_DMAInCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 154 {
mbed_official 532:fe11edbda85c 155 CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 156
mbed_official 532:fe11edbda85c 157 /* Disable the DMA transfer for input Fifo request by resetting the DIEN bit
mbed_official 532:fe11edbda85c 158 in the DMACR register */
mbed_official 532:fe11edbda85c 159 hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DIEN);
mbed_official 532:fe11edbda85c 160
mbed_official 532:fe11edbda85c 161 /* Call input data transfer complete callback */
mbed_official 532:fe11edbda85c 162 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 532:fe11edbda85c 163 }
mbed_official 532:fe11edbda85c 164
mbed_official 532:fe11edbda85c 165 /**
mbed_official 532:fe11edbda85c 166 * @brief DMA CRYP Output Data process complete callback.
mbed_official 532:fe11edbda85c 167 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 168 * @retval None
mbed_official 532:fe11edbda85c 169 */
mbed_official 532:fe11edbda85c 170 static void CRYPEx_GCMCCM_DMAOutCplt(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 171 {
mbed_official 532:fe11edbda85c 172 CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 173
mbed_official 532:fe11edbda85c 174 /* Disable the DMA transfer for output Fifo request by resetting the DOEN bit
mbed_official 532:fe11edbda85c 175 in the DMACR register */
mbed_official 532:fe11edbda85c 176 hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DOEN);
mbed_official 532:fe11edbda85c 177
mbed_official 532:fe11edbda85c 178 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 179 __HAL_CRYP_DISABLE(hcryp);
mbed_official 532:fe11edbda85c 180
mbed_official 532:fe11edbda85c 181 /* Change the CRYP peripheral state */
mbed_official 532:fe11edbda85c 182 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 532:fe11edbda85c 183
mbed_official 532:fe11edbda85c 184 /* Call output data transfer complete callback */
mbed_official 532:fe11edbda85c 185 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 532:fe11edbda85c 186 }
mbed_official 532:fe11edbda85c 187
mbed_official 532:fe11edbda85c 188 /**
mbed_official 532:fe11edbda85c 189 * @brief DMA CRYP communication error callback.
mbed_official 532:fe11edbda85c 190 * @param hdma: DMA handle
mbed_official 532:fe11edbda85c 191 * @retval None
mbed_official 532:fe11edbda85c 192 */
mbed_official 532:fe11edbda85c 193 static void CRYPEx_GCMCCM_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 532:fe11edbda85c 194 {
mbed_official 532:fe11edbda85c 195 CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 532:fe11edbda85c 196 hcryp->State= HAL_CRYP_STATE_READY;
mbed_official 532:fe11edbda85c 197 HAL_CRYP_ErrorCallback(hcryp);
mbed_official 532:fe11edbda85c 198 }
mbed_official 532:fe11edbda85c 199
mbed_official 532:fe11edbda85c 200 /**
mbed_official 532:fe11edbda85c 201 * @brief Writes the Key in Key registers.
mbed_official 532:fe11edbda85c 202 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 203 * the configuration information for CRYP module
mbed_official 532:fe11edbda85c 204 * @param Key: Pointer to Key buffer
mbed_official 532:fe11edbda85c 205 * @param KeySize: Size of Key
mbed_official 532:fe11edbda85c 206 * @retval None
mbed_official 532:fe11edbda85c 207 */
mbed_official 532:fe11edbda85c 208 static void CRYPEx_GCMCCM_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key, uint32_t KeySize)
mbed_official 532:fe11edbda85c 209 {
mbed_official 532:fe11edbda85c 210 uint32_t keyaddr = (uint32_t)Key;
mbed_official 532:fe11edbda85c 211
mbed_official 532:fe11edbda85c 212 switch(KeySize)
mbed_official 532:fe11edbda85c 213 {
mbed_official 532:fe11edbda85c 214 case CRYP_KEYSIZE_256B:
mbed_official 532:fe11edbda85c 215 /* Key Initialisation */
mbed_official 532:fe11edbda85c 216 hcryp->Instance->K0LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 217 keyaddr+=4;
mbed_official 532:fe11edbda85c 218 hcryp->Instance->K0RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 219 keyaddr+=4;
mbed_official 532:fe11edbda85c 220 hcryp->Instance->K1LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 221 keyaddr+=4;
mbed_official 532:fe11edbda85c 222 hcryp->Instance->K1RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 223 keyaddr+=4;
mbed_official 532:fe11edbda85c 224 hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 225 keyaddr+=4;
mbed_official 532:fe11edbda85c 226 hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 227 keyaddr+=4;
mbed_official 532:fe11edbda85c 228 hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 229 keyaddr+=4;
mbed_official 532:fe11edbda85c 230 hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 231 break;
mbed_official 532:fe11edbda85c 232 case CRYP_KEYSIZE_192B:
mbed_official 532:fe11edbda85c 233 hcryp->Instance->K1LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 234 keyaddr+=4;
mbed_official 532:fe11edbda85c 235 hcryp->Instance->K1RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 236 keyaddr+=4;
mbed_official 532:fe11edbda85c 237 hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 238 keyaddr+=4;
mbed_official 532:fe11edbda85c 239 hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 240 keyaddr+=4;
mbed_official 532:fe11edbda85c 241 hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 242 keyaddr+=4;
mbed_official 532:fe11edbda85c 243 hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 244 break;
mbed_official 532:fe11edbda85c 245 case CRYP_KEYSIZE_128B:
mbed_official 532:fe11edbda85c 246 hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 247 keyaddr+=4;
mbed_official 532:fe11edbda85c 248 hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 249 keyaddr+=4;
mbed_official 532:fe11edbda85c 250 hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 251 keyaddr+=4;
mbed_official 532:fe11edbda85c 252 hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));
mbed_official 532:fe11edbda85c 253 break;
mbed_official 532:fe11edbda85c 254 default:
mbed_official 532:fe11edbda85c 255 break;
mbed_official 532:fe11edbda85c 256 }
mbed_official 532:fe11edbda85c 257 }
mbed_official 532:fe11edbda85c 258
mbed_official 532:fe11edbda85c 259 /**
mbed_official 532:fe11edbda85c 260 * @brief Writes the InitVector/InitCounter in IV registers.
mbed_official 532:fe11edbda85c 261 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 262 * the configuration information for CRYP module
mbed_official 532:fe11edbda85c 263 * @param InitVector: Pointer to InitVector/InitCounter buffer
mbed_official 532:fe11edbda85c 264 * @retval None
mbed_official 532:fe11edbda85c 265 */
mbed_official 532:fe11edbda85c 266 static void CRYPEx_GCMCCM_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector)
mbed_official 532:fe11edbda85c 267 {
mbed_official 532:fe11edbda85c 268 uint32_t ivaddr = (uint32_t)InitVector;
mbed_official 532:fe11edbda85c 269
mbed_official 532:fe11edbda85c 270 hcryp->Instance->IV0LR = __REV(*(uint32_t*)(ivaddr));
mbed_official 532:fe11edbda85c 271 ivaddr+=4;
mbed_official 532:fe11edbda85c 272 hcryp->Instance->IV0RR = __REV(*(uint32_t*)(ivaddr));
mbed_official 532:fe11edbda85c 273 ivaddr+=4;
mbed_official 532:fe11edbda85c 274 hcryp->Instance->IV1LR = __REV(*(uint32_t*)(ivaddr));
mbed_official 532:fe11edbda85c 275 ivaddr+=4;
mbed_official 532:fe11edbda85c 276 hcryp->Instance->IV1RR = __REV(*(uint32_t*)(ivaddr));
mbed_official 532:fe11edbda85c 277 }
mbed_official 532:fe11edbda85c 278
mbed_official 532:fe11edbda85c 279 /**
mbed_official 532:fe11edbda85c 280 * @brief Process Data: Writes Input data in polling mode and read the Output data.
mbed_official 532:fe11edbda85c 281 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 282 * the configuration information for CRYP module
mbed_official 532:fe11edbda85c 283 * @param Input: Pointer to the Input buffer.
mbed_official 532:fe11edbda85c 284 * @param Ilength: Length of the Input buffer, must be a multiple of 16
mbed_official 532:fe11edbda85c 285 * @param Output: Pointer to the returned buffer
mbed_official 532:fe11edbda85c 286 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 287 * @retval None
mbed_official 532:fe11edbda85c 288 */
mbed_official 532:fe11edbda85c 289 static HAL_StatusTypeDef CRYPEx_GCMCCM_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t *Input, uint16_t Ilength, uint8_t *Output, uint32_t Timeout)
mbed_official 532:fe11edbda85c 290 {
mbed_official 532:fe11edbda85c 291 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 292 uint32_t i = 0;
mbed_official 532:fe11edbda85c 293 uint32_t inputaddr = (uint32_t)Input;
mbed_official 532:fe11edbda85c 294 uint32_t outputaddr = (uint32_t)Output;
mbed_official 532:fe11edbda85c 295
mbed_official 532:fe11edbda85c 296 for(i=0; (i < Ilength); i+=16)
mbed_official 532:fe11edbda85c 297 {
mbed_official 532:fe11edbda85c 298 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 299 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 532:fe11edbda85c 300 inputaddr+=4;
mbed_official 532:fe11edbda85c 301 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 532:fe11edbda85c 302 inputaddr+=4;
mbed_official 532:fe11edbda85c 303 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 532:fe11edbda85c 304 inputaddr+=4;
mbed_official 532:fe11edbda85c 305 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 532:fe11edbda85c 306 inputaddr+=4;
mbed_official 532:fe11edbda85c 307
mbed_official 532:fe11edbda85c 308 /* Get tick */
mbed_official 532:fe11edbda85c 309 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 310
mbed_official 532:fe11edbda85c 311 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
mbed_official 532:fe11edbda85c 312 {
mbed_official 532:fe11edbda85c 313 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 314 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 315 {
mbed_official 532:fe11edbda85c 316 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 532:fe11edbda85c 317 {
mbed_official 532:fe11edbda85c 318 /* Change state */
mbed_official 532:fe11edbda85c 319 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 320
mbed_official 532:fe11edbda85c 321 /* Process Unlocked */
mbed_official 532:fe11edbda85c 322 __HAL_UNLOCK(hcryp);
mbed_official 532:fe11edbda85c 323
mbed_official 532:fe11edbda85c 324 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 325 }
mbed_official 532:fe11edbda85c 326 }
mbed_official 532:fe11edbda85c 327 }
mbed_official 532:fe11edbda85c 328 /* Read the Output block from the OUT FIFO */
mbed_official 532:fe11edbda85c 329 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 330 outputaddr+=4;
mbed_official 532:fe11edbda85c 331 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 332 outputaddr+=4;
mbed_official 532:fe11edbda85c 333 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 334 outputaddr+=4;
mbed_official 532:fe11edbda85c 335 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 336 outputaddr+=4;
mbed_official 532:fe11edbda85c 337 }
mbed_official 532:fe11edbda85c 338 /* Return function status */
mbed_official 532:fe11edbda85c 339 return HAL_OK;
mbed_official 532:fe11edbda85c 340 }
mbed_official 532:fe11edbda85c 341
mbed_official 532:fe11edbda85c 342 /**
mbed_official 532:fe11edbda85c 343 * @brief Sets the header phase
mbed_official 532:fe11edbda85c 344 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 345 * the configuration information for CRYP module
mbed_official 532:fe11edbda85c 346 * @param Input: Pointer to the Input buffer.
mbed_official 532:fe11edbda85c 347 * @param Ilength: Length of the Input buffer, must be a multiple of 16
mbed_official 532:fe11edbda85c 348 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 349 * @retval None
mbed_official 532:fe11edbda85c 350 */
mbed_official 532:fe11edbda85c 351 static HAL_StatusTypeDef CRYPEx_GCMCCM_SetHeaderPhase(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint32_t Timeout)
mbed_official 532:fe11edbda85c 352 {
mbed_official 532:fe11edbda85c 353 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 354 uint32_t loopcounter = 0;
mbed_official 532:fe11edbda85c 355 uint32_t headeraddr = (uint32_t)Input;
mbed_official 532:fe11edbda85c 356
mbed_official 532:fe11edbda85c 357 /***************************** Header phase *********************************/
mbed_official 532:fe11edbda85c 358 if(hcryp->Init.HeaderSize != 0)
mbed_official 532:fe11edbda85c 359 {
mbed_official 532:fe11edbda85c 360 /* Select header phase */
mbed_official 532:fe11edbda85c 361 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 532:fe11edbda85c 362 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 363 __HAL_CRYP_ENABLE(hcryp);
mbed_official 532:fe11edbda85c 364
mbed_official 532:fe11edbda85c 365 for(loopcounter = 0; (loopcounter < hcryp->Init.HeaderSize); loopcounter+=16)
mbed_official 532:fe11edbda85c 366 {
mbed_official 532:fe11edbda85c 367 /* Get tick */
mbed_official 532:fe11edbda85c 368 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 369
mbed_official 532:fe11edbda85c 370 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 532:fe11edbda85c 371 {
mbed_official 532:fe11edbda85c 372 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 373 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 374 {
mbed_official 532:fe11edbda85c 375 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 376 {
mbed_official 532:fe11edbda85c 377 /* Change state */
mbed_official 532:fe11edbda85c 378 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 379
mbed_official 532:fe11edbda85c 380 /* Process Unlocked */
mbed_official 532:fe11edbda85c 381 __HAL_UNLOCK(hcryp);
mbed_official 532:fe11edbda85c 382
mbed_official 532:fe11edbda85c 383 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 384 }
mbed_official 532:fe11edbda85c 385 }
mbed_official 532:fe11edbda85c 386 }
mbed_official 532:fe11edbda85c 387 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 388 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 532:fe11edbda85c 389 headeraddr+=4;
mbed_official 532:fe11edbda85c 390 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 532:fe11edbda85c 391 headeraddr+=4;
mbed_official 532:fe11edbda85c 392 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 532:fe11edbda85c 393 headeraddr+=4;
mbed_official 532:fe11edbda85c 394 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 532:fe11edbda85c 395 headeraddr+=4;
mbed_official 532:fe11edbda85c 396 }
mbed_official 532:fe11edbda85c 397
mbed_official 532:fe11edbda85c 398 /* Wait until the complete message has been processed */
mbed_official 532:fe11edbda85c 399
mbed_official 532:fe11edbda85c 400 /* Get tick */
mbed_official 532:fe11edbda85c 401 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 402
mbed_official 532:fe11edbda85c 403 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 532:fe11edbda85c 404 {
mbed_official 532:fe11edbda85c 405 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 406 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 407 {
mbed_official 532:fe11edbda85c 408 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 409 {
mbed_official 532:fe11edbda85c 410 /* Change state */
mbed_official 532:fe11edbda85c 411 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 412
mbed_official 532:fe11edbda85c 413 /* Process Unlocked */
mbed_official 532:fe11edbda85c 414 __HAL_UNLOCK(hcryp);
mbed_official 532:fe11edbda85c 415
mbed_official 532:fe11edbda85c 416 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 417 }
mbed_official 532:fe11edbda85c 418 }
mbed_official 532:fe11edbda85c 419 }
mbed_official 532:fe11edbda85c 420 }
mbed_official 532:fe11edbda85c 421 /* Return function status */
mbed_official 532:fe11edbda85c 422 return HAL_OK;
mbed_official 532:fe11edbda85c 423 }
mbed_official 532:fe11edbda85c 424
mbed_official 532:fe11edbda85c 425 /**
mbed_official 532:fe11edbda85c 426 * @brief Sets the DMA configuration and start the DMA transfer.
mbed_official 532:fe11edbda85c 427 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 428 * the configuration information for CRYP module
mbed_official 532:fe11edbda85c 429 * @param inputaddr: Address of the Input buffer
mbed_official 532:fe11edbda85c 430 * @param Size: Size of the Input buffer, must be a multiple of 16
mbed_official 532:fe11edbda85c 431 * @param outputaddr: Address of the Output buffer
mbed_official 532:fe11edbda85c 432 * @retval None
mbed_official 532:fe11edbda85c 433 */
mbed_official 532:fe11edbda85c 434 static void CRYPEx_GCMCCM_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)
mbed_official 532:fe11edbda85c 435 {
mbed_official 532:fe11edbda85c 436 /* Set the CRYP DMA transfer complete callback */
mbed_official 532:fe11edbda85c 437 hcryp->hdmain->XferCpltCallback = CRYPEx_GCMCCM_DMAInCplt;
mbed_official 532:fe11edbda85c 438 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 439 hcryp->hdmain->XferErrorCallback = CRYPEx_GCMCCM_DMAError;
mbed_official 532:fe11edbda85c 440
mbed_official 532:fe11edbda85c 441 /* Set the CRYP DMA transfer complete callback */
mbed_official 532:fe11edbda85c 442 hcryp->hdmaout->XferCpltCallback = CRYPEx_GCMCCM_DMAOutCplt;
mbed_official 532:fe11edbda85c 443 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 444 hcryp->hdmaout->XferErrorCallback = CRYPEx_GCMCCM_DMAError;
mbed_official 532:fe11edbda85c 445
mbed_official 532:fe11edbda85c 446 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 447 __HAL_CRYP_ENABLE(hcryp);
mbed_official 532:fe11edbda85c 448
mbed_official 532:fe11edbda85c 449 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 450 HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DR, Size/4);
mbed_official 532:fe11edbda85c 451
mbed_official 532:fe11edbda85c 452 /* Enable In DMA request */
mbed_official 532:fe11edbda85c 453 hcryp->Instance->DMACR = CRYP_DMACR_DIEN;
mbed_official 532:fe11edbda85c 454
mbed_official 532:fe11edbda85c 455 /* Enable the DMA Out DMA Stream */
mbed_official 532:fe11edbda85c 456 HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUT, outputaddr, Size/4);
mbed_official 532:fe11edbda85c 457
mbed_official 532:fe11edbda85c 458 /* Enable Out DMA request */
mbed_official 532:fe11edbda85c 459 hcryp->Instance->DMACR |= CRYP_DMACR_DOEN;
mbed_official 532:fe11edbda85c 460 }
mbed_official 532:fe11edbda85c 461
mbed_official 532:fe11edbda85c 462 /**
mbed_official 532:fe11edbda85c 463 * @}
mbed_official 532:fe11edbda85c 464 */
mbed_official 532:fe11edbda85c 465
mbed_official 532:fe11edbda85c 466 /* Exported functions---------------------------------------------------------*/
mbed_official 532:fe11edbda85c 467 /** @addtogroup CRYPEx_Exported_Functions
mbed_official 532:fe11edbda85c 468 * @{
mbed_official 532:fe11edbda85c 469 */
mbed_official 532:fe11edbda85c 470
mbed_official 532:fe11edbda85c 471 /** @defgroup CRYPEx_Exported_Functions_Group1 Extended AES processing functions
mbed_official 235:685d5f11838f 472 * @brief Extended processing functions.
mbed_official 235:685d5f11838f 473 *
mbed_official 235:685d5f11838f 474 @verbatim
mbed_official 235:685d5f11838f 475 ==============================================================================
mbed_official 235:685d5f11838f 476 ##### Extended AES processing functions #####
mbed_official 235:685d5f11838f 477 ==============================================================================
mbed_official 235:685d5f11838f 478 [..] This section provides functions allowing to:
mbed_official 235:685d5f11838f 479 (+) Encrypt plaintext using AES-128/192/256 using GCM and CCM chaining modes
mbed_official 235:685d5f11838f 480 (+) Decrypt cyphertext using AES-128/192/256 using GCM and CCM chaining modes
mbed_official 235:685d5f11838f 481 (+) Finish the processing. This function is available only for GCM and CCM
mbed_official 235:685d5f11838f 482 [..] Three processing methods are available:
mbed_official 235:685d5f11838f 483 (+) Polling mode
mbed_official 235:685d5f11838f 484 (+) Interrupt mode
mbed_official 235:685d5f11838f 485 (+) DMA mode
mbed_official 235:685d5f11838f 486
mbed_official 235:685d5f11838f 487 @endverbatim
mbed_official 235:685d5f11838f 488 * @{
mbed_official 235:685d5f11838f 489 */
mbed_official 235:685d5f11838f 490
mbed_official 235:685d5f11838f 491
mbed_official 235:685d5f11838f 492 /**
mbed_official 235:685d5f11838f 493 * @brief Initializes the CRYP peripheral in AES CCM encryption mode then
mbed_official 235:685d5f11838f 494 * encrypt pPlainData. The cypher data are available in pCypherData.
mbed_official 235:685d5f11838f 495 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 496 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 497 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 498 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 499 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 500 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 501 * @retval HAL status
mbed_official 235:685d5f11838f 502 */
mbed_official 235:685d5f11838f 503 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
mbed_official 235:685d5f11838f 504 {
mbed_official 235:685d5f11838f 505 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 506 uint32_t headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 507 uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 508 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 509 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 510 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 511 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 512 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 513
mbed_official 235:685d5f11838f 514 /* Process Locked */
mbed_official 235:685d5f11838f 515 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 516
mbed_official 235:685d5f11838f 517 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 518 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 519
mbed_official 235:685d5f11838f 520 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 521 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 522 {
mbed_official 235:685d5f11838f 523 /************************ Formatting the header block *********************/
mbed_official 235:685d5f11838f 524 if(headersize != 0)
mbed_official 235:685d5f11838f 525 {
mbed_official 235:685d5f11838f 526 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 527 if(headersize < 65280)
mbed_official 235:685d5f11838f 528 {
mbed_official 235:685d5f11838f 529 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 530 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 531 headersize += 2;
mbed_official 235:685d5f11838f 532 }
mbed_official 235:685d5f11838f 533 else
mbed_official 235:685d5f11838f 534 {
mbed_official 235:685d5f11838f 535 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 536 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 537 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 538 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 539 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 540 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 541 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 542 headersize += 6;
mbed_official 235:685d5f11838f 543 }
mbed_official 235:685d5f11838f 544 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 545 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 546 {
mbed_official 235:685d5f11838f 547 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 548 }
mbed_official 235:685d5f11838f 549 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 550 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 551 {
mbed_official 235:685d5f11838f 552 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 553 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 554 {
mbed_official 235:685d5f11838f 555 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 556 }
mbed_official 235:685d5f11838f 557 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 558 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 559 }
mbed_official 235:685d5f11838f 560 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 561 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 562 }
mbed_official 235:685d5f11838f 563 /*********************** Formatting the block B0 **************************/
mbed_official 235:685d5f11838f 564 if(headersize != 0)
mbed_official 235:685d5f11838f 565 {
mbed_official 235:685d5f11838f 566 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 567 }
mbed_official 235:685d5f11838f 568 /* Flags byte */
mbed_official 235:685d5f11838f 569 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 570 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 571 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 572
mbed_official 235:685d5f11838f 573 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 574 {
mbed_official 235:685d5f11838f 575 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 576 }
mbed_official 235:685d5f11838f 577 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 578 {
mbed_official 235:685d5f11838f 579 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 580 }
mbed_official 235:685d5f11838f 581
mbed_official 235:685d5f11838f 582 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 583 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 584
mbed_official 235:685d5f11838f 585 /************************* Formatting the initial counter *****************/
mbed_official 235:685d5f11838f 586 /* Byte 0:
mbed_official 235:685d5f11838f 587 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 588 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter blocks
mbed_official 235:685d5f11838f 589 are distinct from B0
mbed_official 235:685d5f11838f 590 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 591 */
mbed_official 235:685d5f11838f 592 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 593 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 594 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 595 {
mbed_official 235:685d5f11838f 596 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 597 }
mbed_official 235:685d5f11838f 598 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 599 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 600
mbed_official 235:685d5f11838f 601 /* Set the key */
mbed_official 235:685d5f11838f 602 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 603
mbed_official 235:685d5f11838f 604 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 605 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
mbed_official 235:685d5f11838f 606
mbed_official 235:685d5f11838f 607 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 608 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 609
mbed_official 235:685d5f11838f 610 /* Select init phase */
mbed_official 532:fe11edbda85c 611 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 612
mbed_official 235:685d5f11838f 613 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 614 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 615 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 616 b0addr+=4;
mbed_official 532:fe11edbda85c 617 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 618 b0addr+=4;
mbed_official 532:fe11edbda85c 619 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 620 b0addr+=4;
mbed_official 532:fe11edbda85c 621 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 622
mbed_official 235:685d5f11838f 623 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 624 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 625
mbed_official 235:685d5f11838f 626 /* Get tick */
mbed_official 235:685d5f11838f 627 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 628
mbed_official 235:685d5f11838f 629 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 630 {
mbed_official 235:685d5f11838f 631 /* Check for the Timeout */
mbed_official 235:685d5f11838f 632 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 633 {
mbed_official 235:685d5f11838f 634 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 635 {
mbed_official 235:685d5f11838f 636 /* Change state */
mbed_official 235:685d5f11838f 637 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 638
mbed_official 235:685d5f11838f 639 /* Process Unlocked */
mbed_official 235:685d5f11838f 640 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 641
mbed_official 235:685d5f11838f 642 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 643 }
mbed_official 235:685d5f11838f 644 }
mbed_official 235:685d5f11838f 645 }
mbed_official 235:685d5f11838f 646 /***************************** Header phase *******************************/
mbed_official 235:685d5f11838f 647 if(headersize != 0)
mbed_official 235:685d5f11838f 648 {
mbed_official 235:685d5f11838f 649 /* Select header phase */
mbed_official 532:fe11edbda85c 650 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 651
mbed_official 235:685d5f11838f 652 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 653 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 654
mbed_official 235:685d5f11838f 655 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 656 {
mbed_official 235:685d5f11838f 657 /* Get tick */
mbed_official 235:685d5f11838f 658 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 659
mbed_official 532:fe11edbda85c 660 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 661 {
mbed_official 235:685d5f11838f 662 {
mbed_official 235:685d5f11838f 663 /* Check for the Timeout */
mbed_official 235:685d5f11838f 664 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 665 {
mbed_official 235:685d5f11838f 666 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 667 {
mbed_official 235:685d5f11838f 668 /* Change state */
mbed_official 235:685d5f11838f 669 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 670
mbed_official 235:685d5f11838f 671 /* Process Unlocked */
mbed_official 235:685d5f11838f 672 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 673
mbed_official 235:685d5f11838f 674 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 675 }
mbed_official 235:685d5f11838f 676 }
mbed_official 235:685d5f11838f 677 }
mbed_official 235:685d5f11838f 678 }
mbed_official 235:685d5f11838f 679 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 680 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 681 headeraddr+=4;
mbed_official 532:fe11edbda85c 682 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 683 headeraddr+=4;
mbed_official 532:fe11edbda85c 684 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 685 headeraddr+=4;
mbed_official 532:fe11edbda85c 686 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 687 headeraddr+=4;
mbed_official 235:685d5f11838f 688 }
mbed_official 235:685d5f11838f 689
mbed_official 235:685d5f11838f 690 /* Get tick */
mbed_official 235:685d5f11838f 691 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 692
mbed_official 532:fe11edbda85c 693 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 694 {
mbed_official 235:685d5f11838f 695 /* Check for the Timeout */
mbed_official 235:685d5f11838f 696 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 697 {
mbed_official 235:685d5f11838f 698 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 699 {
mbed_official 235:685d5f11838f 700 /* Change state */
mbed_official 235:685d5f11838f 701 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 702
mbed_official 235:685d5f11838f 703 /* Process Unlocked */
mbed_official 235:685d5f11838f 704 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 705
mbed_official 235:685d5f11838f 706 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 707 }
mbed_official 235:685d5f11838f 708 }
mbed_official 235:685d5f11838f 709 }
mbed_official 235:685d5f11838f 710 }
mbed_official 235:685d5f11838f 711 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 712 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 713 {
mbed_official 235:685d5f11838f 714 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 715 }
mbed_official 235:685d5f11838f 716 /* Reset bit 0 */
mbed_official 235:685d5f11838f 717 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 718
mbed_official 235:685d5f11838f 719 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 720 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 721
mbed_official 235:685d5f11838f 722 /* Flush FIFO */
mbed_official 532:fe11edbda85c 723 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 724
mbed_official 235:685d5f11838f 725 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 726 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 727
mbed_official 235:685d5f11838f 728 /* Set the phase */
mbed_official 235:685d5f11838f 729 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 730 }
mbed_official 235:685d5f11838f 731
mbed_official 235:685d5f11838f 732 /* Write Plain Data and Get Cypher Data */
mbed_official 235:685d5f11838f 733 if(CRYPEx_GCMCCM_ProcessData(hcryp,pPlainData, Size, pCypherData, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 734 {
mbed_official 235:685d5f11838f 735 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 736 }
mbed_official 235:685d5f11838f 737
mbed_official 235:685d5f11838f 738 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 739 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 740
mbed_official 235:685d5f11838f 741 /* Process Unlocked */
mbed_official 235:685d5f11838f 742 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 743
mbed_official 235:685d5f11838f 744 /* Return function status */
mbed_official 235:685d5f11838f 745 return HAL_OK;
mbed_official 235:685d5f11838f 746 }
mbed_official 235:685d5f11838f 747
mbed_official 235:685d5f11838f 748 /**
mbed_official 235:685d5f11838f 749 * @brief Initializes the CRYP peripheral in AES GCM encryption mode then
mbed_official 235:685d5f11838f 750 * encrypt pPlainData. The cypher data are available in pCypherData.
mbed_official 235:685d5f11838f 751 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 752 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 753 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 754 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 755 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 756 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 757 * @retval HAL status
mbed_official 235:685d5f11838f 758 */
mbed_official 235:685d5f11838f 759 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
mbed_official 235:685d5f11838f 760 {
mbed_official 235:685d5f11838f 761 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 762
mbed_official 235:685d5f11838f 763 /* Process Locked */
mbed_official 235:685d5f11838f 764 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 765
mbed_official 235:685d5f11838f 766 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 767 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 768
mbed_official 235:685d5f11838f 769 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 770 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 771 {
mbed_official 235:685d5f11838f 772 /* Set the key */
mbed_official 235:685d5f11838f 773 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 774
mbed_official 235:685d5f11838f 775 /* Set the CRYP peripheral in AES GCM mode */
mbed_official 532:fe11edbda85c 776 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
mbed_official 235:685d5f11838f 777
mbed_official 235:685d5f11838f 778 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 779 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 780
mbed_official 235:685d5f11838f 781 /* Flush FIFO */
mbed_official 532:fe11edbda85c 782 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 783
mbed_official 235:685d5f11838f 784 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 785 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 786
mbed_official 235:685d5f11838f 787 /* Get tick */
mbed_official 235:685d5f11838f 788 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 789
mbed_official 235:685d5f11838f 790 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 791 {
mbed_official 235:685d5f11838f 792 /* Check for the Timeout */
mbed_official 235:685d5f11838f 793 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 794 {
mbed_official 235:685d5f11838f 795 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 796 {
mbed_official 235:685d5f11838f 797 /* Change state */
mbed_official 235:685d5f11838f 798 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 799
mbed_official 235:685d5f11838f 800 /* Process Unlocked */
mbed_official 235:685d5f11838f 801 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 802
mbed_official 235:685d5f11838f 803 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 804 }
mbed_official 235:685d5f11838f 805 }
mbed_official 235:685d5f11838f 806 }
mbed_official 235:685d5f11838f 807
mbed_official 235:685d5f11838f 808 /* Set the header phase */
mbed_official 235:685d5f11838f 809 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 810 {
mbed_official 235:685d5f11838f 811 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 812 }
mbed_official 235:685d5f11838f 813
mbed_official 235:685d5f11838f 814 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 815 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 816
mbed_official 235:685d5f11838f 817 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 818 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 819
mbed_official 235:685d5f11838f 820 /* Flush FIFO */
mbed_official 532:fe11edbda85c 821 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 822
mbed_official 235:685d5f11838f 823 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 824 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 825
mbed_official 235:685d5f11838f 826 /* Set the phase */
mbed_official 235:685d5f11838f 827 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 828 }
mbed_official 235:685d5f11838f 829
mbed_official 235:685d5f11838f 830 /* Write Plain Data and Get Cypher Data */
mbed_official 235:685d5f11838f 831 if(CRYPEx_GCMCCM_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 832 {
mbed_official 235:685d5f11838f 833 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 834 }
mbed_official 235:685d5f11838f 835
mbed_official 235:685d5f11838f 836 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 837 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 838
mbed_official 235:685d5f11838f 839 /* Process Unlocked */
mbed_official 235:685d5f11838f 840 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 841
mbed_official 235:685d5f11838f 842 /* Return function status */
mbed_official 235:685d5f11838f 843 return HAL_OK;
mbed_official 235:685d5f11838f 844 }
mbed_official 235:685d5f11838f 845
mbed_official 235:685d5f11838f 846 /**
mbed_official 235:685d5f11838f 847 * @brief Initializes the CRYP peripheral in AES GCM decryption mode then
mbed_official 235:685d5f11838f 848 * decrypted pCypherData. The cypher data are available in pPlainData.
mbed_official 235:685d5f11838f 849 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 850 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 851 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 852 * @param Size: Length of the cyphertext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 853 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 854 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 855 * @retval HAL status
mbed_official 235:685d5f11838f 856 */
mbed_official 235:685d5f11838f 857 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
mbed_official 235:685d5f11838f 858 {
mbed_official 235:685d5f11838f 859 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 860
mbed_official 235:685d5f11838f 861 /* Process Locked */
mbed_official 235:685d5f11838f 862 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 863
mbed_official 235:685d5f11838f 864 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 865 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 866
mbed_official 235:685d5f11838f 867 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 868 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 869 {
mbed_official 235:685d5f11838f 870 /* Set the key */
mbed_official 235:685d5f11838f 871 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 872
mbed_official 235:685d5f11838f 873 /* Set the CRYP peripheral in AES GCM decryption mode */
mbed_official 532:fe11edbda85c 874 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
mbed_official 235:685d5f11838f 875
mbed_official 235:685d5f11838f 876 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 877 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 878
mbed_official 235:685d5f11838f 879 /* Flush FIFO */
mbed_official 532:fe11edbda85c 880 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 881
mbed_official 235:685d5f11838f 882 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 883 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 884
mbed_official 235:685d5f11838f 885 /* Get tick */
mbed_official 235:685d5f11838f 886 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 887
mbed_official 235:685d5f11838f 888 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 889 {
mbed_official 235:685d5f11838f 890 /* Check for the Timeout */
mbed_official 235:685d5f11838f 891 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 892 {
mbed_official 235:685d5f11838f 893 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 894 {
mbed_official 235:685d5f11838f 895 /* Change state */
mbed_official 235:685d5f11838f 896 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 897
mbed_official 235:685d5f11838f 898 /* Process Unlocked */
mbed_official 235:685d5f11838f 899 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 900
mbed_official 235:685d5f11838f 901 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 902 }
mbed_official 235:685d5f11838f 903 }
mbed_official 235:685d5f11838f 904 }
mbed_official 235:685d5f11838f 905
mbed_official 235:685d5f11838f 906 /* Set the header phase */
mbed_official 235:685d5f11838f 907 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 908 {
mbed_official 235:685d5f11838f 909 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 910 }
mbed_official 235:685d5f11838f 911 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 912 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 913
mbed_official 235:685d5f11838f 914 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 915 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 916
mbed_official 235:685d5f11838f 917 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 918 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 919
mbed_official 235:685d5f11838f 920 /* Set the phase */
mbed_official 235:685d5f11838f 921 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 922 }
mbed_official 235:685d5f11838f 923
mbed_official 235:685d5f11838f 924 /* Write Plain Data and Get Cypher Data */
mbed_official 235:685d5f11838f 925 if(CRYPEx_GCMCCM_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 926 {
mbed_official 235:685d5f11838f 927 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 928 }
mbed_official 235:685d5f11838f 929
mbed_official 235:685d5f11838f 930 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 931 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 932
mbed_official 235:685d5f11838f 933 /* Process Unlocked */
mbed_official 235:685d5f11838f 934 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 935
mbed_official 235:685d5f11838f 936 /* Return function status */
mbed_official 235:685d5f11838f 937 return HAL_OK;
mbed_official 235:685d5f11838f 938 }
mbed_official 235:685d5f11838f 939
mbed_official 235:685d5f11838f 940 /**
mbed_official 235:685d5f11838f 941 * @brief Computes the authentication TAG.
mbed_official 235:685d5f11838f 942 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 943 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 944 * @param Size: Total length of the plain/cyphertext buffer
mbed_official 235:685d5f11838f 945 * @param AuthTag: Pointer to the authentication buffer
mbed_official 235:685d5f11838f 946 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 947 * @retval HAL status
mbed_official 235:685d5f11838f 948 */
mbed_official 532:fe11edbda85c 949 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Finish(CRYP_HandleTypeDef *hcryp, uint32_t Size, uint8_t *AuthTag, uint32_t Timeout)
mbed_official 235:685d5f11838f 950 {
mbed_official 235:685d5f11838f 951 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 952 uint64_t headerlength = hcryp->Init.HeaderSize * 8; /* Header length in bits */
mbed_official 532:fe11edbda85c 953 uint64_t inputlength = Size * 8; /* input length in bits */
mbed_official 235:685d5f11838f 954 uint32_t tagaddr = (uint32_t)AuthTag;
mbed_official 235:685d5f11838f 955
mbed_official 235:685d5f11838f 956 /* Process Locked */
mbed_official 235:685d5f11838f 957 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 958
mbed_official 235:685d5f11838f 959 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 960 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 961
mbed_official 235:685d5f11838f 962 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 963 if(hcryp->Phase == HAL_CRYP_PHASE_PROCESS)
mbed_official 235:685d5f11838f 964 {
mbed_official 235:685d5f11838f 965 /* Change the CRYP phase */
mbed_official 235:685d5f11838f 966 hcryp->Phase = HAL_CRYP_PHASE_FINAL;
mbed_official 235:685d5f11838f 967
mbed_official 235:685d5f11838f 968 /* Disable CRYP to start the final phase */
mbed_official 532:fe11edbda85c 969 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 970
mbed_official 235:685d5f11838f 971 /* Select final phase */
mbed_official 532:fe11edbda85c 972 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_FINAL);
mbed_official 235:685d5f11838f 973
mbed_official 235:685d5f11838f 974 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 975 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 976
mbed_official 235:685d5f11838f 977 /* Write the number of bits in header (64 bits) followed by the number of bits
mbed_official 235:685d5f11838f 978 in the payload */
mbed_official 235:685d5f11838f 979 if(hcryp->Init.DataType == CRYP_DATATYPE_1B)
mbed_official 235:685d5f11838f 980 {
mbed_official 532:fe11edbda85c 981 hcryp->Instance->DR = __RBIT(headerlength >> 32);
mbed_official 532:fe11edbda85c 982 hcryp->Instance->DR = __RBIT(headerlength);
mbed_official 532:fe11edbda85c 983 hcryp->Instance->DR = __RBIT(inputlength >> 32);
mbed_official 532:fe11edbda85c 984 hcryp->Instance->DR = __RBIT(inputlength);
mbed_official 235:685d5f11838f 985 }
mbed_official 235:685d5f11838f 986 else if(hcryp->Init.DataType == CRYP_DATATYPE_8B)
mbed_official 235:685d5f11838f 987 {
mbed_official 532:fe11edbda85c 988 hcryp->Instance->DR = __REV(headerlength >> 32);
mbed_official 532:fe11edbda85c 989 hcryp->Instance->DR = __REV(headerlength);
mbed_official 532:fe11edbda85c 990 hcryp->Instance->DR = __REV(inputlength >> 32);
mbed_official 532:fe11edbda85c 991 hcryp->Instance->DR = __REV(inputlength);
mbed_official 235:685d5f11838f 992 }
mbed_official 235:685d5f11838f 993 else if(hcryp->Init.DataType == CRYP_DATATYPE_16B)
mbed_official 235:685d5f11838f 994 {
mbed_official 532:fe11edbda85c 995 hcryp->Instance->DR = __ROR((uint32_t)(headerlength >> 32), 16);
mbed_official 532:fe11edbda85c 996 hcryp->Instance->DR = __ROR((uint32_t)headerlength, 16);
mbed_official 532:fe11edbda85c 997 hcryp->Instance->DR = __ROR((uint32_t)(inputlength >> 32), 16);
mbed_official 532:fe11edbda85c 998 hcryp->Instance->DR = __ROR((uint32_t)inputlength, 16);
mbed_official 235:685d5f11838f 999 }
mbed_official 235:685d5f11838f 1000 else if(hcryp->Init.DataType == CRYP_DATATYPE_32B)
mbed_official 235:685d5f11838f 1001 {
mbed_official 532:fe11edbda85c 1002 hcryp->Instance->DR = (uint32_t)(headerlength >> 32);
mbed_official 532:fe11edbda85c 1003 hcryp->Instance->DR = (uint32_t)(headerlength);
mbed_official 532:fe11edbda85c 1004 hcryp->Instance->DR = (uint32_t)(inputlength >> 32);
mbed_official 532:fe11edbda85c 1005 hcryp->Instance->DR = (uint32_t)(inputlength);
mbed_official 235:685d5f11838f 1006 }
mbed_official 235:685d5f11838f 1007 /* Get tick */
mbed_official 235:685d5f11838f 1008 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1009
mbed_official 532:fe11edbda85c 1010 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
mbed_official 235:685d5f11838f 1011 {
mbed_official 235:685d5f11838f 1012 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1013 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 1014 {
mbed_official 235:685d5f11838f 1015 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 1016 {
mbed_official 235:685d5f11838f 1017 /* Change state */
mbed_official 235:685d5f11838f 1018 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1019
mbed_official 235:685d5f11838f 1020 /* Process Unlocked */
mbed_official 235:685d5f11838f 1021 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1022
mbed_official 235:685d5f11838f 1023 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1024 }
mbed_official 235:685d5f11838f 1025 }
mbed_official 235:685d5f11838f 1026 }
mbed_official 235:685d5f11838f 1027
mbed_official 235:685d5f11838f 1028 /* Read the Auth TAG in the IN FIFO */
mbed_official 532:fe11edbda85c 1029 *(uint32_t*)(tagaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1030 tagaddr+=4;
mbed_official 532:fe11edbda85c 1031 *(uint32_t*)(tagaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1032 tagaddr+=4;
mbed_official 532:fe11edbda85c 1033 *(uint32_t*)(tagaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1034 tagaddr+=4;
mbed_official 532:fe11edbda85c 1035 *(uint32_t*)(tagaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1036 }
mbed_official 235:685d5f11838f 1037
mbed_official 235:685d5f11838f 1038 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1039 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1040
mbed_official 235:685d5f11838f 1041 /* Process Unlocked */
mbed_official 235:685d5f11838f 1042 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1043
mbed_official 235:685d5f11838f 1044 /* Return function status */
mbed_official 235:685d5f11838f 1045 return HAL_OK;
mbed_official 235:685d5f11838f 1046 }
mbed_official 235:685d5f11838f 1047
mbed_official 235:685d5f11838f 1048 /**
mbed_official 235:685d5f11838f 1049 * @brief Computes the authentication TAG for AES CCM mode.
mbed_official 235:685d5f11838f 1050 * @note This API is called after HAL_AES_CCM_Encrypt()/HAL_AES_CCM_Decrypt()
mbed_official 235:685d5f11838f 1051 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1052 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1053 * @param AuthTag: Pointer to the authentication buffer
mbed_official 235:685d5f11838f 1054 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 1055 * @retval HAL status
mbed_official 235:685d5f11838f 1056 */
mbed_official 235:685d5f11838f 1057 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Finish(CRYP_HandleTypeDef *hcryp, uint8_t *AuthTag, uint32_t Timeout)
mbed_official 235:685d5f11838f 1058 {
mbed_official 235:685d5f11838f 1059 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 1060 uint32_t tagaddr = (uint32_t)AuthTag;
mbed_official 235:685d5f11838f 1061 uint32_t ctraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 1062 uint32_t temptag[4] = {0}; /* Temporary TAG (MAC) */
mbed_official 235:685d5f11838f 1063 uint32_t loopcounter;
mbed_official 235:685d5f11838f 1064
mbed_official 235:685d5f11838f 1065 /* Process Locked */
mbed_official 235:685d5f11838f 1066 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 1067
mbed_official 235:685d5f11838f 1068 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1069 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 1070
mbed_official 235:685d5f11838f 1071 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 1072 if(hcryp->Phase == HAL_CRYP_PHASE_PROCESS)
mbed_official 235:685d5f11838f 1073 {
mbed_official 235:685d5f11838f 1074 /* Change the CRYP phase */
mbed_official 235:685d5f11838f 1075 hcryp->Phase = HAL_CRYP_PHASE_FINAL;
mbed_official 235:685d5f11838f 1076
mbed_official 235:685d5f11838f 1077 /* Disable CRYP to start the final phase */
mbed_official 532:fe11edbda85c 1078 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 1079
mbed_official 235:685d5f11838f 1080 /* Select final phase */
mbed_official 532:fe11edbda85c 1081 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_FINAL);
mbed_official 235:685d5f11838f 1082
mbed_official 235:685d5f11838f 1083 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1084 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1085
mbed_official 235:685d5f11838f 1086 /* Write the counter block in the IN FIFO */
mbed_official 532:fe11edbda85c 1087 hcryp->Instance->DR = *(uint32_t*)ctraddr;
mbed_official 235:685d5f11838f 1088 ctraddr+=4;
mbed_official 532:fe11edbda85c 1089 hcryp->Instance->DR = *(uint32_t*)ctraddr;
mbed_official 235:685d5f11838f 1090 ctraddr+=4;
mbed_official 532:fe11edbda85c 1091 hcryp->Instance->DR = *(uint32_t*)ctraddr;
mbed_official 235:685d5f11838f 1092 ctraddr+=4;
mbed_official 532:fe11edbda85c 1093 hcryp->Instance->DR = *(uint32_t*)ctraddr;
mbed_official 235:685d5f11838f 1094
mbed_official 235:685d5f11838f 1095 /* Get tick */
mbed_official 235:685d5f11838f 1096 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1097
mbed_official 532:fe11edbda85c 1098 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
mbed_official 235:685d5f11838f 1099 {
mbed_official 235:685d5f11838f 1100 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1101 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 1102 {
mbed_official 235:685d5f11838f 1103 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 1104 {
mbed_official 235:685d5f11838f 1105 /* Change state */
mbed_official 235:685d5f11838f 1106 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1107
mbed_official 235:685d5f11838f 1108 /* Process Unlocked */
mbed_official 235:685d5f11838f 1109 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1110
mbed_official 235:685d5f11838f 1111 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1112 }
mbed_official 235:685d5f11838f 1113 }
mbed_official 235:685d5f11838f 1114 }
mbed_official 235:685d5f11838f 1115
mbed_official 235:685d5f11838f 1116 /* Read the Auth TAG in the IN FIFO */
mbed_official 532:fe11edbda85c 1117 temptag[0] = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 1118 temptag[1] = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 1119 temptag[2] = hcryp->Instance->DOUT;
mbed_official 532:fe11edbda85c 1120 temptag[3] = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1121 }
mbed_official 235:685d5f11838f 1122
mbed_official 235:685d5f11838f 1123 /* Copy temporary authentication TAG in user TAG buffer */
mbed_official 235:685d5f11838f 1124 for(loopcounter = 0; loopcounter < hcryp->Init.TagSize ; loopcounter++)
mbed_official 235:685d5f11838f 1125 {
mbed_official 235:685d5f11838f 1126 /* Set the authentication TAG buffer */
mbed_official 235:685d5f11838f 1127 *((uint8_t*)tagaddr+loopcounter) = *((uint8_t*)temptag+loopcounter);
mbed_official 235:685d5f11838f 1128 }
mbed_official 235:685d5f11838f 1129
mbed_official 235:685d5f11838f 1130 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1131 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1132
mbed_official 235:685d5f11838f 1133 /* Process Unlocked */
mbed_official 235:685d5f11838f 1134 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1135
mbed_official 235:685d5f11838f 1136 /* Return function status */
mbed_official 235:685d5f11838f 1137 return HAL_OK;
mbed_official 235:685d5f11838f 1138 }
mbed_official 235:685d5f11838f 1139
mbed_official 235:685d5f11838f 1140 /**
mbed_official 235:685d5f11838f 1141 * @brief Initializes the CRYP peripheral in AES CCM decryption mode then
mbed_official 235:685d5f11838f 1142 * decrypted pCypherData. The cypher data are available in pPlainData.
mbed_official 235:685d5f11838f 1143 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1144 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1145 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 1146 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 1147 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 1148 * @param Timeout: Timeout duration
mbed_official 235:685d5f11838f 1149 * @retval HAL status
mbed_official 235:685d5f11838f 1150 */
mbed_official 235:685d5f11838f 1151 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
mbed_official 235:685d5f11838f 1152 {
mbed_official 235:685d5f11838f 1153 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 1154 uint32_t headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 1155 uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 1156 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 1157 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 1158 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 1159 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 1160 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 1161
mbed_official 235:685d5f11838f 1162 /* Process Locked */
mbed_official 235:685d5f11838f 1163 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 1164
mbed_official 235:685d5f11838f 1165 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1166 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 1167
mbed_official 235:685d5f11838f 1168 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 1169 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 1170 {
mbed_official 235:685d5f11838f 1171 /************************ Formatting the header block *********************/
mbed_official 235:685d5f11838f 1172 if(headersize != 0)
mbed_official 235:685d5f11838f 1173 {
mbed_official 235:685d5f11838f 1174 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 1175 if(headersize < 65280)
mbed_official 235:685d5f11838f 1176 {
mbed_official 235:685d5f11838f 1177 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 1178 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 1179 headersize += 2;
mbed_official 235:685d5f11838f 1180 }
mbed_official 235:685d5f11838f 1181 else
mbed_official 235:685d5f11838f 1182 {
mbed_official 235:685d5f11838f 1183 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 1184 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 1185 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 1186 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 1187 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 1188 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 1189 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 1190 headersize += 6;
mbed_official 235:685d5f11838f 1191 }
mbed_official 235:685d5f11838f 1192 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 1193 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 1194 {
mbed_official 235:685d5f11838f 1195 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 1196 }
mbed_official 235:685d5f11838f 1197 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 1198 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 1199 {
mbed_official 235:685d5f11838f 1200 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 1201 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 1202 {
mbed_official 235:685d5f11838f 1203 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 1204 }
mbed_official 235:685d5f11838f 1205 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 1206 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 1207 }
mbed_official 235:685d5f11838f 1208 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 1209 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 1210 }
mbed_official 235:685d5f11838f 1211 /*********************** Formatting the block B0 **************************/
mbed_official 235:685d5f11838f 1212 if(headersize != 0)
mbed_official 235:685d5f11838f 1213 {
mbed_official 235:685d5f11838f 1214 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 1215 }
mbed_official 235:685d5f11838f 1216 /* Flags byte */
mbed_official 235:685d5f11838f 1217 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 1218 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 1219 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 1220
mbed_official 235:685d5f11838f 1221 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 1222 {
mbed_official 235:685d5f11838f 1223 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 1224 }
mbed_official 235:685d5f11838f 1225 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 1226 {
mbed_official 235:685d5f11838f 1227 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 1228 }
mbed_official 235:685d5f11838f 1229
mbed_official 235:685d5f11838f 1230 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 1231 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 1232
mbed_official 235:685d5f11838f 1233 /************************* Formatting the initial counter *****************/
mbed_official 235:685d5f11838f 1234 /* Byte 0:
mbed_official 235:685d5f11838f 1235 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 1236 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
mbed_official 235:685d5f11838f 1237 blocks are distinct from B0
mbed_official 235:685d5f11838f 1238 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 1239 */
mbed_official 235:685d5f11838f 1240 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 1241 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 1242 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 1243 {
mbed_official 235:685d5f11838f 1244 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 1245 }
mbed_official 235:685d5f11838f 1246 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 1247 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 1248
mbed_official 235:685d5f11838f 1249 /* Set the key */
mbed_official 235:685d5f11838f 1250 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 1251
mbed_official 235:685d5f11838f 1252 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 1253 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
mbed_official 235:685d5f11838f 1254
mbed_official 235:685d5f11838f 1255 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 1256 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 1257
mbed_official 235:685d5f11838f 1258 /* Select init phase */
mbed_official 532:fe11edbda85c 1259 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 1260
mbed_official 235:685d5f11838f 1261 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 1262 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 1263 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1264 b0addr+=4;
mbed_official 532:fe11edbda85c 1265 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1266 b0addr+=4;
mbed_official 532:fe11edbda85c 1267 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1268 b0addr+=4;
mbed_official 532:fe11edbda85c 1269 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1270
mbed_official 235:685d5f11838f 1271 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1272 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1273
mbed_official 235:685d5f11838f 1274 /* Get tick */
mbed_official 235:685d5f11838f 1275 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1276
mbed_official 235:685d5f11838f 1277 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 1278 {
mbed_official 235:685d5f11838f 1279 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1280 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 1281 {
mbed_official 235:685d5f11838f 1282 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 1283 {
mbed_official 235:685d5f11838f 1284 /* Change state */
mbed_official 235:685d5f11838f 1285 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1286
mbed_official 235:685d5f11838f 1287 /* Process Unlocked */
mbed_official 235:685d5f11838f 1288 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1289
mbed_official 235:685d5f11838f 1290 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1291 }
mbed_official 235:685d5f11838f 1292 }
mbed_official 235:685d5f11838f 1293 }
mbed_official 235:685d5f11838f 1294 /***************************** Header phase *******************************/
mbed_official 235:685d5f11838f 1295 if(headersize != 0)
mbed_official 235:685d5f11838f 1296 {
mbed_official 235:685d5f11838f 1297 /* Select header phase */
mbed_official 532:fe11edbda85c 1298 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 1299
mbed_official 235:685d5f11838f 1300 /* Enable Crypto processor */
mbed_official 532:fe11edbda85c 1301 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1302
mbed_official 235:685d5f11838f 1303 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 1304 {
mbed_official 235:685d5f11838f 1305 /* Get tick */
mbed_official 235:685d5f11838f 1306 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1307
mbed_official 532:fe11edbda85c 1308 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 1309 {
mbed_official 235:685d5f11838f 1310 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1311 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 1312 {
mbed_official 235:685d5f11838f 1313 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 1314 {
mbed_official 235:685d5f11838f 1315 /* Change state */
mbed_official 235:685d5f11838f 1316 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1317
mbed_official 235:685d5f11838f 1318 /* Process Unlocked */
mbed_official 235:685d5f11838f 1319 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1320
mbed_official 235:685d5f11838f 1321 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1322 }
mbed_official 235:685d5f11838f 1323 }
mbed_official 235:685d5f11838f 1324 }
mbed_official 235:685d5f11838f 1325 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 1326 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1327 headeraddr+=4;
mbed_official 532:fe11edbda85c 1328 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1329 headeraddr+=4;
mbed_official 532:fe11edbda85c 1330 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1331 headeraddr+=4;
mbed_official 532:fe11edbda85c 1332 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1333 headeraddr+=4;
mbed_official 235:685d5f11838f 1334 }
mbed_official 235:685d5f11838f 1335
mbed_official 235:685d5f11838f 1336 /* Get tick */
mbed_official 235:685d5f11838f 1337 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1338
mbed_official 532:fe11edbda85c 1339 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 1340 {
mbed_official 235:685d5f11838f 1341 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1342 if(Timeout != HAL_MAX_DELAY)
mbed_official 235:685d5f11838f 1343 {
mbed_official 235:685d5f11838f 1344 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 235:685d5f11838f 1345 {
mbed_official 235:685d5f11838f 1346 /* Change state */
mbed_official 235:685d5f11838f 1347 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1348
mbed_official 235:685d5f11838f 1349 /* Process Unlocked */
mbed_official 235:685d5f11838f 1350 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1351
mbed_official 235:685d5f11838f 1352 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1353 }
mbed_official 235:685d5f11838f 1354 }
mbed_official 235:685d5f11838f 1355 }
mbed_official 235:685d5f11838f 1356 }
mbed_official 235:685d5f11838f 1357 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 1358 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 1359 {
mbed_official 235:685d5f11838f 1360 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 1361 }
mbed_official 235:685d5f11838f 1362 /* Reset bit 0 */
mbed_official 235:685d5f11838f 1363 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 1364 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 1365 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 1366
mbed_official 235:685d5f11838f 1367 /* Flush FIFO */
mbed_official 532:fe11edbda85c 1368 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 1369
mbed_official 235:685d5f11838f 1370 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1371 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1372
mbed_official 235:685d5f11838f 1373 /* Set the phase */
mbed_official 235:685d5f11838f 1374 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 1375 }
mbed_official 235:685d5f11838f 1376
mbed_official 235:685d5f11838f 1377 /* Write Plain Data and Get Cypher Data */
mbed_official 235:685d5f11838f 1378 if(CRYPEx_GCMCCM_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
mbed_official 235:685d5f11838f 1379 {
mbed_official 235:685d5f11838f 1380 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1381 }
mbed_official 235:685d5f11838f 1382
mbed_official 235:685d5f11838f 1383 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1384 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1385
mbed_official 235:685d5f11838f 1386 /* Process Unlocked */
mbed_official 235:685d5f11838f 1387 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1388
mbed_official 235:685d5f11838f 1389 /* Return function status */
mbed_official 235:685d5f11838f 1390 return HAL_OK;
mbed_official 235:685d5f11838f 1391 }
mbed_official 235:685d5f11838f 1392
mbed_official 235:685d5f11838f 1393 /**
mbed_official 235:685d5f11838f 1394 * @brief Initializes the CRYP peripheral in AES GCM encryption mode using IT.
mbed_official 235:685d5f11838f 1395 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1396 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1397 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 1398 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 1399 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 1400 * @retval HAL status
mbed_official 235:685d5f11838f 1401 */
mbed_official 235:685d5f11838f 1402 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 235:685d5f11838f 1403 {
mbed_official 235:685d5f11838f 1404 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 1405 uint32_t inputaddr;
mbed_official 235:685d5f11838f 1406 uint32_t outputaddr;
mbed_official 235:685d5f11838f 1407
mbed_official 235:685d5f11838f 1408 if(hcryp->State == HAL_CRYP_STATE_READY)
mbed_official 235:685d5f11838f 1409 {
mbed_official 235:685d5f11838f 1410 /* Process Locked */
mbed_official 235:685d5f11838f 1411 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 1412
mbed_official 235:685d5f11838f 1413 /* Get the buffer addresses and sizes */
mbed_official 235:685d5f11838f 1414 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 1415 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 1416 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 1417 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 1418
mbed_official 235:685d5f11838f 1419 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1420 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 1421
mbed_official 235:685d5f11838f 1422 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 1423 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 1424 {
mbed_official 235:685d5f11838f 1425 /* Set the key */
mbed_official 235:685d5f11838f 1426 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 1427
mbed_official 235:685d5f11838f 1428 /* Set the CRYP peripheral in AES GCM mode */
mbed_official 532:fe11edbda85c 1429 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
mbed_official 235:685d5f11838f 1430
mbed_official 235:685d5f11838f 1431 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 1432 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 1433
mbed_official 235:685d5f11838f 1434 /* Flush FIFO */
mbed_official 532:fe11edbda85c 1435 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 1436
mbed_official 235:685d5f11838f 1437 /* Enable CRYP to start the init phase */
mbed_official 532:fe11edbda85c 1438 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1439
mbed_official 235:685d5f11838f 1440 /* Get tick */
mbed_official 235:685d5f11838f 1441 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1442
mbed_official 235:685d5f11838f 1443 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 1444 {
mbed_official 235:685d5f11838f 1445 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1446
mbed_official 235:685d5f11838f 1447 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 1448 {
mbed_official 235:685d5f11838f 1449 /* Change state */
mbed_official 235:685d5f11838f 1450 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1451
mbed_official 235:685d5f11838f 1452 /* Process Unlocked */
mbed_official 235:685d5f11838f 1453 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1454
mbed_official 235:685d5f11838f 1455 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1456
mbed_official 235:685d5f11838f 1457 }
mbed_official 235:685d5f11838f 1458 }
mbed_official 235:685d5f11838f 1459
mbed_official 235:685d5f11838f 1460 /* Set the header phase */
mbed_official 235:685d5f11838f 1461 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1) != HAL_OK)
mbed_official 235:685d5f11838f 1462 {
mbed_official 235:685d5f11838f 1463 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1464 }
mbed_official 235:685d5f11838f 1465 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1466 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 1467
mbed_official 235:685d5f11838f 1468 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 1469 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 1470
mbed_official 235:685d5f11838f 1471 /* Flush FIFO */
mbed_official 532:fe11edbda85c 1472 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 1473
mbed_official 235:685d5f11838f 1474 /* Set the phase */
mbed_official 235:685d5f11838f 1475 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 1476 }
mbed_official 235:685d5f11838f 1477
mbed_official 235:685d5f11838f 1478 if(Size != 0)
mbed_official 235:685d5f11838f 1479 {
mbed_official 235:685d5f11838f 1480 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 1481 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1482 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1483 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1484 }
mbed_official 235:685d5f11838f 1485 else
mbed_official 235:685d5f11838f 1486 {
mbed_official 235:685d5f11838f 1487 /* Process Locked */
mbed_official 235:685d5f11838f 1488 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1489 /* Change the CRYP state and phase */
mbed_official 235:685d5f11838f 1490 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1491 }
mbed_official 235:685d5f11838f 1492 /* Return function status */
mbed_official 235:685d5f11838f 1493 return HAL_OK;
mbed_official 235:685d5f11838f 1494 }
mbed_official 532:fe11edbda85c 1495 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
mbed_official 235:685d5f11838f 1496 {
mbed_official 235:685d5f11838f 1497 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 235:685d5f11838f 1498 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 1499 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1500 inputaddr+=4;
mbed_official 532:fe11edbda85c 1501 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1502 inputaddr+=4;
mbed_official 532:fe11edbda85c 1503 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1504 inputaddr+=4;
mbed_official 532:fe11edbda85c 1505 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1506 hcryp->pCrypInBuffPtr += 16;
mbed_official 235:685d5f11838f 1507 hcryp->CrypInCount -= 16;
mbed_official 235:685d5f11838f 1508 if(hcryp->CrypInCount == 0)
mbed_official 235:685d5f11838f 1509 {
mbed_official 532:fe11edbda85c 1510 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
mbed_official 235:685d5f11838f 1511 /* Call the Input data transfer complete callback */
mbed_official 235:685d5f11838f 1512 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1513 }
mbed_official 235:685d5f11838f 1514 }
mbed_official 532:fe11edbda85c 1515 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
mbed_official 235:685d5f11838f 1516 {
mbed_official 235:685d5f11838f 1517 outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
mbed_official 235:685d5f11838f 1518 /* Read the Output block from the Output FIFO */
mbed_official 532:fe11edbda85c 1519 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1520 outputaddr+=4;
mbed_official 532:fe11edbda85c 1521 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1522 outputaddr+=4;
mbed_official 532:fe11edbda85c 1523 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1524 outputaddr+=4;
mbed_official 532:fe11edbda85c 1525 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1526 hcryp->pCrypOutBuffPtr += 16;
mbed_official 235:685d5f11838f 1527 hcryp->CrypOutCount -= 16;
mbed_official 235:685d5f11838f 1528 if(hcryp->CrypOutCount == 0)
mbed_official 235:685d5f11838f 1529 {
mbed_official 532:fe11edbda85c 1530 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1531 /* Process Unlocked */
mbed_official 235:685d5f11838f 1532 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1533 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1534 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1535 /* Call Input transfer complete callback */
mbed_official 235:685d5f11838f 1536 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1537 }
mbed_official 235:685d5f11838f 1538 }
mbed_official 235:685d5f11838f 1539
mbed_official 235:685d5f11838f 1540 /* Return function status */
mbed_official 235:685d5f11838f 1541 return HAL_OK;
mbed_official 235:685d5f11838f 1542 }
mbed_official 235:685d5f11838f 1543
mbed_official 235:685d5f11838f 1544 /**
mbed_official 235:685d5f11838f 1545 * @brief Initializes the CRYP peripheral in AES CCM encryption mode using interrupt.
mbed_official 235:685d5f11838f 1546 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1547 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1548 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 1549 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 1550 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 1551 * @retval HAL status
mbed_official 235:685d5f11838f 1552 */
mbed_official 235:685d5f11838f 1553 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 235:685d5f11838f 1554 {
mbed_official 235:685d5f11838f 1555 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 1556 uint32_t inputaddr;
mbed_official 235:685d5f11838f 1557 uint32_t outputaddr;
mbed_official 235:685d5f11838f 1558
mbed_official 235:685d5f11838f 1559 uint32_t headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 1560 uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 1561 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 1562 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 1563 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 1564 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 1565 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 1566
mbed_official 235:685d5f11838f 1567 if(hcryp->State == HAL_CRYP_STATE_READY)
mbed_official 235:685d5f11838f 1568 {
mbed_official 235:685d5f11838f 1569 /* Process Locked */
mbed_official 235:685d5f11838f 1570 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 1571
mbed_official 235:685d5f11838f 1572 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 1573 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 1574 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 1575 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 1576
mbed_official 235:685d5f11838f 1577 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1578 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 1579
mbed_official 235:685d5f11838f 1580 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 1581 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 1582 {
mbed_official 235:685d5f11838f 1583 /************************ Formatting the header block *******************/
mbed_official 235:685d5f11838f 1584 if(headersize != 0)
mbed_official 235:685d5f11838f 1585 {
mbed_official 235:685d5f11838f 1586 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 1587 if(headersize < 65280)
mbed_official 235:685d5f11838f 1588 {
mbed_official 235:685d5f11838f 1589 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 1590 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 1591 headersize += 2;
mbed_official 235:685d5f11838f 1592 }
mbed_official 235:685d5f11838f 1593 else
mbed_official 235:685d5f11838f 1594 {
mbed_official 235:685d5f11838f 1595 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 1596 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 1597 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 1598 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 1599 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 1600 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 1601 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 1602 headersize += 6;
mbed_official 235:685d5f11838f 1603 }
mbed_official 235:685d5f11838f 1604 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 1605 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 1606 {
mbed_official 235:685d5f11838f 1607 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 1608 }
mbed_official 235:685d5f11838f 1609 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 1610 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 1611 {
mbed_official 235:685d5f11838f 1612 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 1613 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 1614 {
mbed_official 235:685d5f11838f 1615 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 1616 }
mbed_official 235:685d5f11838f 1617 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 1618 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 1619 }
mbed_official 235:685d5f11838f 1620 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 1621 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 1622 }
mbed_official 235:685d5f11838f 1623 /*********************** Formatting the block B0 ************************/
mbed_official 235:685d5f11838f 1624 if(headersize != 0)
mbed_official 235:685d5f11838f 1625 {
mbed_official 235:685d5f11838f 1626 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 1627 }
mbed_official 235:685d5f11838f 1628 /* Flags byte */
mbed_official 235:685d5f11838f 1629 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 1630 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 1631 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 1632
mbed_official 235:685d5f11838f 1633 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 1634 {
mbed_official 235:685d5f11838f 1635 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 1636 }
mbed_official 235:685d5f11838f 1637 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 1638 {
mbed_official 235:685d5f11838f 1639 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 1640 }
mbed_official 235:685d5f11838f 1641
mbed_official 235:685d5f11838f 1642 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 1643 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 1644
mbed_official 235:685d5f11838f 1645 /************************* Formatting the initial counter ***************/
mbed_official 235:685d5f11838f 1646 /* Byte 0:
mbed_official 235:685d5f11838f 1647 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 1648 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
mbed_official 235:685d5f11838f 1649 blocks are distinct from B0
mbed_official 235:685d5f11838f 1650 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 1651 */
mbed_official 235:685d5f11838f 1652 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 1653 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 1654 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 1655 {
mbed_official 235:685d5f11838f 1656 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 1657 }
mbed_official 235:685d5f11838f 1658 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 1659 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 1660
mbed_official 235:685d5f11838f 1661 /* Set the key */
mbed_official 235:685d5f11838f 1662 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 1663
mbed_official 235:685d5f11838f 1664 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 1665 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
mbed_official 235:685d5f11838f 1666
mbed_official 235:685d5f11838f 1667 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 1668 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 1669
mbed_official 235:685d5f11838f 1670 /* Select init phase */
mbed_official 532:fe11edbda85c 1671 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 1672
mbed_official 235:685d5f11838f 1673 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 1674 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 1675 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1676 b0addr+=4;
mbed_official 532:fe11edbda85c 1677 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1678 b0addr+=4;
mbed_official 532:fe11edbda85c 1679 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1680 b0addr+=4;
mbed_official 532:fe11edbda85c 1681 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 1682
mbed_official 235:685d5f11838f 1683 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1684 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1685
mbed_official 235:685d5f11838f 1686 /* Get tick */
mbed_official 235:685d5f11838f 1687 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1688
mbed_official 235:685d5f11838f 1689 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 1690 {
mbed_official 235:685d5f11838f 1691 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1692 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 1693 {
mbed_official 235:685d5f11838f 1694 /* Change state */
mbed_official 235:685d5f11838f 1695 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1696
mbed_official 235:685d5f11838f 1697 /* Process Unlocked */
mbed_official 235:685d5f11838f 1698 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1699
mbed_official 235:685d5f11838f 1700 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1701 }
mbed_official 235:685d5f11838f 1702 }
mbed_official 235:685d5f11838f 1703 /***************************** Header phase *****************************/
mbed_official 235:685d5f11838f 1704 if(headersize != 0)
mbed_official 235:685d5f11838f 1705 {
mbed_official 235:685d5f11838f 1706 /* Select header phase */
mbed_official 532:fe11edbda85c 1707 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 1708
mbed_official 235:685d5f11838f 1709 /* Enable Crypto processor */
mbed_official 532:fe11edbda85c 1710 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1711
mbed_official 235:685d5f11838f 1712 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 1713 {
mbed_official 235:685d5f11838f 1714 /* Get tick */
mbed_official 235:685d5f11838f 1715 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1716
mbed_official 532:fe11edbda85c 1717 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 1718 {
mbed_official 235:685d5f11838f 1719 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1720 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 1721 {
mbed_official 235:685d5f11838f 1722 /* Change state */
mbed_official 235:685d5f11838f 1723 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1724
mbed_official 235:685d5f11838f 1725 /* Process Unlocked */
mbed_official 235:685d5f11838f 1726 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1727
mbed_official 235:685d5f11838f 1728 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1729 }
mbed_official 235:685d5f11838f 1730 }
mbed_official 235:685d5f11838f 1731 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 1732 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1733 headeraddr+=4;
mbed_official 532:fe11edbda85c 1734 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1735 headeraddr+=4;
mbed_official 532:fe11edbda85c 1736 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1737 headeraddr+=4;
mbed_official 532:fe11edbda85c 1738 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 1739 headeraddr+=4;
mbed_official 235:685d5f11838f 1740 }
mbed_official 235:685d5f11838f 1741
mbed_official 235:685d5f11838f 1742 /* Get tick */
mbed_official 235:685d5f11838f 1743 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1744
mbed_official 532:fe11edbda85c 1745 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 1746 {
mbed_official 235:685d5f11838f 1747 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1748 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 1749 {
mbed_official 235:685d5f11838f 1750 /* Change state */
mbed_official 235:685d5f11838f 1751 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1752
mbed_official 235:685d5f11838f 1753 /* Process Unlocked */
mbed_official 235:685d5f11838f 1754 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1755
mbed_official 235:685d5f11838f 1756 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1757 }
mbed_official 235:685d5f11838f 1758 }
mbed_official 235:685d5f11838f 1759 }
mbed_official 235:685d5f11838f 1760 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 1761 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 1762 {
mbed_official 235:685d5f11838f 1763 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 1764 }
mbed_official 235:685d5f11838f 1765 /* Reset bit 0 */
mbed_official 235:685d5f11838f 1766 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 1767
mbed_official 235:685d5f11838f 1768 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 1769 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 1770
mbed_official 235:685d5f11838f 1771 /* Flush FIFO */
mbed_official 532:fe11edbda85c 1772 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 1773
mbed_official 235:685d5f11838f 1774 /* Set the phase */
mbed_official 235:685d5f11838f 1775 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 1776 }
mbed_official 235:685d5f11838f 1777
mbed_official 235:685d5f11838f 1778 if(Size != 0)
mbed_official 235:685d5f11838f 1779 {
mbed_official 235:685d5f11838f 1780 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 1781 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1782 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1783 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1784 }
mbed_official 235:685d5f11838f 1785 else
mbed_official 235:685d5f11838f 1786 {
mbed_official 235:685d5f11838f 1787 /* Change the CRYP state and phase */
mbed_official 235:685d5f11838f 1788 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1789 }
mbed_official 235:685d5f11838f 1790
mbed_official 235:685d5f11838f 1791 /* Return function status */
mbed_official 235:685d5f11838f 1792 return HAL_OK;
mbed_official 235:685d5f11838f 1793 }
mbed_official 532:fe11edbda85c 1794 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
mbed_official 235:685d5f11838f 1795 {
mbed_official 235:685d5f11838f 1796 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 235:685d5f11838f 1797 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 1798 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1799 inputaddr+=4;
mbed_official 532:fe11edbda85c 1800 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1801 inputaddr+=4;
mbed_official 532:fe11edbda85c 1802 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1803 inputaddr+=4;
mbed_official 532:fe11edbda85c 1804 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1805 hcryp->pCrypInBuffPtr += 16;
mbed_official 235:685d5f11838f 1806 hcryp->CrypInCount -= 16;
mbed_official 235:685d5f11838f 1807 if(hcryp->CrypInCount == 0)
mbed_official 235:685d5f11838f 1808 {
mbed_official 532:fe11edbda85c 1809 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
mbed_official 235:685d5f11838f 1810 /* Call Input transfer complete callback */
mbed_official 235:685d5f11838f 1811 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1812 }
mbed_official 235:685d5f11838f 1813 }
mbed_official 532:fe11edbda85c 1814 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
mbed_official 235:685d5f11838f 1815 {
mbed_official 235:685d5f11838f 1816 outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
mbed_official 235:685d5f11838f 1817 /* Read the Output block from the Output FIFO */
mbed_official 532:fe11edbda85c 1818 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1819 outputaddr+=4;
mbed_official 532:fe11edbda85c 1820 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1821 outputaddr+=4;
mbed_official 532:fe11edbda85c 1822 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1823 outputaddr+=4;
mbed_official 532:fe11edbda85c 1824 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1825 hcryp->pCrypOutBuffPtr += 16;
mbed_official 235:685d5f11838f 1826 hcryp->CrypOutCount -= 16;
mbed_official 235:685d5f11838f 1827 if(hcryp->CrypOutCount == 0)
mbed_official 235:685d5f11838f 1828 {
mbed_official 532:fe11edbda85c 1829 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1830 /* Process Unlocked */
mbed_official 235:685d5f11838f 1831 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1832 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1833 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1834 /* Call Input transfer complete callback */
mbed_official 235:685d5f11838f 1835 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1836 }
mbed_official 235:685d5f11838f 1837 }
mbed_official 235:685d5f11838f 1838
mbed_official 235:685d5f11838f 1839 /* Return function status */
mbed_official 235:685d5f11838f 1840 return HAL_OK;
mbed_official 235:685d5f11838f 1841 }
mbed_official 235:685d5f11838f 1842
mbed_official 235:685d5f11838f 1843 /**
mbed_official 235:685d5f11838f 1844 * @brief Initializes the CRYP peripheral in AES GCM decryption mode using IT.
mbed_official 235:685d5f11838f 1845 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1846 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1847 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 1848 * @param Size: Length of the cyphertext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 1849 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 1850 * @retval HAL status
mbed_official 235:685d5f11838f 1851 */
mbed_official 235:685d5f11838f 1852 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 235:685d5f11838f 1853 {
mbed_official 235:685d5f11838f 1854 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 1855 uint32_t inputaddr;
mbed_official 235:685d5f11838f 1856 uint32_t outputaddr;
mbed_official 235:685d5f11838f 1857
mbed_official 235:685d5f11838f 1858 if(hcryp->State == HAL_CRYP_STATE_READY)
mbed_official 235:685d5f11838f 1859 {
mbed_official 235:685d5f11838f 1860 /* Process Locked */
mbed_official 235:685d5f11838f 1861 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 1862
mbed_official 235:685d5f11838f 1863 /* Get the buffer addresses and sizes */
mbed_official 235:685d5f11838f 1864 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 1865 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 1866 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 1867 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 1868
mbed_official 235:685d5f11838f 1869 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1870 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 1871
mbed_official 235:685d5f11838f 1872 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 1873 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 1874 {
mbed_official 235:685d5f11838f 1875 /* Set the key */
mbed_official 235:685d5f11838f 1876 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 1877
mbed_official 235:685d5f11838f 1878 /* Set the CRYP peripheral in AES GCM decryption mode */
mbed_official 532:fe11edbda85c 1879 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
mbed_official 235:685d5f11838f 1880
mbed_official 235:685d5f11838f 1881 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 1882 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 1883
mbed_official 235:685d5f11838f 1884 /* Flush FIFO */
mbed_official 532:fe11edbda85c 1885 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 1886
mbed_official 235:685d5f11838f 1887 /* Enable CRYP to start the init phase */
mbed_official 532:fe11edbda85c 1888 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1889
mbed_official 235:685d5f11838f 1890 /* Get tick */
mbed_official 235:685d5f11838f 1891 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 1892
mbed_official 235:685d5f11838f 1893 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 1894 {
mbed_official 235:685d5f11838f 1895 /* Check for the Timeout */
mbed_official 235:685d5f11838f 1896 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 1897 {
mbed_official 235:685d5f11838f 1898 /* Change state */
mbed_official 235:685d5f11838f 1899 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 1900
mbed_official 235:685d5f11838f 1901 /* Process Unlocked */
mbed_official 235:685d5f11838f 1902 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1903
mbed_official 235:685d5f11838f 1904 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1905 }
mbed_official 235:685d5f11838f 1906 }
mbed_official 235:685d5f11838f 1907
mbed_official 235:685d5f11838f 1908 /* Set the header phase */
mbed_official 235:685d5f11838f 1909 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1) != HAL_OK)
mbed_official 235:685d5f11838f 1910 {
mbed_official 235:685d5f11838f 1911 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 1912 }
mbed_official 235:685d5f11838f 1913 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1914 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 1915
mbed_official 235:685d5f11838f 1916 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 1917 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 1918
mbed_official 235:685d5f11838f 1919 /* Set the phase */
mbed_official 235:685d5f11838f 1920 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 1921 }
mbed_official 235:685d5f11838f 1922
mbed_official 235:685d5f11838f 1923 if(Size != 0)
mbed_official 235:685d5f11838f 1924 {
mbed_official 235:685d5f11838f 1925 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 1926 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1927 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 1928 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 1929 }
mbed_official 235:685d5f11838f 1930 else
mbed_official 235:685d5f11838f 1931 {
mbed_official 235:685d5f11838f 1932 /* Process Locked */
mbed_official 235:685d5f11838f 1933 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1934 /* Change the CRYP state and phase */
mbed_official 235:685d5f11838f 1935 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1936 }
mbed_official 235:685d5f11838f 1937
mbed_official 235:685d5f11838f 1938 /* Return function status */
mbed_official 235:685d5f11838f 1939 return HAL_OK;
mbed_official 235:685d5f11838f 1940 }
mbed_official 532:fe11edbda85c 1941 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
mbed_official 235:685d5f11838f 1942 {
mbed_official 235:685d5f11838f 1943 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 235:685d5f11838f 1944 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 1945 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1946 inputaddr+=4;
mbed_official 532:fe11edbda85c 1947 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1948 inputaddr+=4;
mbed_official 532:fe11edbda85c 1949 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1950 inputaddr+=4;
mbed_official 532:fe11edbda85c 1951 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 1952 hcryp->pCrypInBuffPtr += 16;
mbed_official 235:685d5f11838f 1953 hcryp->CrypInCount -= 16;
mbed_official 235:685d5f11838f 1954 if(hcryp->CrypInCount == 0)
mbed_official 235:685d5f11838f 1955 {
mbed_official 532:fe11edbda85c 1956 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
mbed_official 235:685d5f11838f 1957 /* Call the Input data transfer complete callback */
mbed_official 235:685d5f11838f 1958 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1959 }
mbed_official 235:685d5f11838f 1960 }
mbed_official 532:fe11edbda85c 1961 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
mbed_official 235:685d5f11838f 1962 {
mbed_official 235:685d5f11838f 1963 outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
mbed_official 235:685d5f11838f 1964 /* Read the Output block from the Output FIFO */
mbed_official 532:fe11edbda85c 1965 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1966 outputaddr+=4;
mbed_official 532:fe11edbda85c 1967 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1968 outputaddr+=4;
mbed_official 532:fe11edbda85c 1969 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1970 outputaddr+=4;
mbed_official 532:fe11edbda85c 1971 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 1972 hcryp->pCrypOutBuffPtr += 16;
mbed_official 235:685d5f11838f 1973 hcryp->CrypOutCount -= 16;
mbed_official 235:685d5f11838f 1974 if(hcryp->CrypOutCount == 0)
mbed_official 235:685d5f11838f 1975 {
mbed_official 532:fe11edbda85c 1976 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 1977 /* Process Unlocked */
mbed_official 235:685d5f11838f 1978 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 1979 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 1980 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 1981 /* Call Input transfer complete callback */
mbed_official 235:685d5f11838f 1982 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 235:685d5f11838f 1983 }
mbed_official 235:685d5f11838f 1984 }
mbed_official 235:685d5f11838f 1985
mbed_official 235:685d5f11838f 1986 /* Return function status */
mbed_official 235:685d5f11838f 1987 return HAL_OK;
mbed_official 235:685d5f11838f 1988 }
mbed_official 235:685d5f11838f 1989
mbed_official 235:685d5f11838f 1990 /**
mbed_official 235:685d5f11838f 1991 * @brief Initializes the CRYP peripheral in AES CCM decryption mode using interrupt
mbed_official 235:685d5f11838f 1992 * then decrypted pCypherData. The cypher data are available in pPlainData.
mbed_official 235:685d5f11838f 1993 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 1994 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 1995 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 1996 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 1997 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 1998 * @retval HAL status
mbed_official 235:685d5f11838f 1999 */
mbed_official 235:685d5f11838f 2000 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 235:685d5f11838f 2001 {
mbed_official 235:685d5f11838f 2002 uint32_t inputaddr;
mbed_official 235:685d5f11838f 2003 uint32_t outputaddr;
mbed_official 235:685d5f11838f 2004 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 2005 uint32_t headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 2006 uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 2007 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 2008 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 2009 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 2010 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 2011 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2012
mbed_official 235:685d5f11838f 2013 if(hcryp->State == HAL_CRYP_STATE_READY)
mbed_official 235:685d5f11838f 2014 {
mbed_official 235:685d5f11838f 2015 /* Process Locked */
mbed_official 235:685d5f11838f 2016 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 2017
mbed_official 235:685d5f11838f 2018 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 2019 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 2020 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 2021 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 2022
mbed_official 235:685d5f11838f 2023 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2024 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 2025
mbed_official 235:685d5f11838f 2026 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 2027 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 2028 {
mbed_official 235:685d5f11838f 2029 /************************ Formatting the header block *******************/
mbed_official 235:685d5f11838f 2030 if(headersize != 0)
mbed_official 235:685d5f11838f 2031 {
mbed_official 235:685d5f11838f 2032 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 2033 if(headersize < 65280)
mbed_official 235:685d5f11838f 2034 {
mbed_official 235:685d5f11838f 2035 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 2036 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 2037 headersize += 2;
mbed_official 235:685d5f11838f 2038 }
mbed_official 235:685d5f11838f 2039 else
mbed_official 235:685d5f11838f 2040 {
mbed_official 235:685d5f11838f 2041 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 2042 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 2043 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 2044 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 2045 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 2046 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 2047 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 2048 headersize += 6;
mbed_official 235:685d5f11838f 2049 }
mbed_official 235:685d5f11838f 2050 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 2051 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 2052 {
mbed_official 235:685d5f11838f 2053 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 2054 }
mbed_official 235:685d5f11838f 2055 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 2056 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 2057 {
mbed_official 235:685d5f11838f 2058 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 2059 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 2060 {
mbed_official 235:685d5f11838f 2061 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 2062 }
mbed_official 235:685d5f11838f 2063 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 2064 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 2065 }
mbed_official 235:685d5f11838f 2066 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 2067 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 2068 }
mbed_official 235:685d5f11838f 2069 /*********************** Formatting the block B0 ************************/
mbed_official 235:685d5f11838f 2070 if(headersize != 0)
mbed_official 235:685d5f11838f 2071 {
mbed_official 235:685d5f11838f 2072 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 2073 }
mbed_official 235:685d5f11838f 2074 /* Flags byte */
mbed_official 235:685d5f11838f 2075 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 2076 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 2077 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 2078
mbed_official 235:685d5f11838f 2079 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 2080 {
mbed_official 235:685d5f11838f 2081 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 2082 }
mbed_official 235:685d5f11838f 2083 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 2084 {
mbed_official 235:685d5f11838f 2085 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 2086 }
mbed_official 235:685d5f11838f 2087
mbed_official 235:685d5f11838f 2088 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 2089 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 2090
mbed_official 235:685d5f11838f 2091 /************************* Formatting the initial counter ***************/
mbed_official 235:685d5f11838f 2092 /* Byte 0:
mbed_official 235:685d5f11838f 2093 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 2094 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
mbed_official 235:685d5f11838f 2095 blocks are distinct from B0
mbed_official 235:685d5f11838f 2096 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 2097 */
mbed_official 235:685d5f11838f 2098 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 2099 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 2100 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 2101 {
mbed_official 235:685d5f11838f 2102 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 2103 }
mbed_official 235:685d5f11838f 2104 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 2105 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 2106
mbed_official 235:685d5f11838f 2107 /* Set the key */
mbed_official 235:685d5f11838f 2108 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 2109
mbed_official 235:685d5f11838f 2110 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 2111 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
mbed_official 235:685d5f11838f 2112
mbed_official 235:685d5f11838f 2113 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 2114 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 2115
mbed_official 235:685d5f11838f 2116 /* Select init phase */
mbed_official 532:fe11edbda85c 2117 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 2118
mbed_official 235:685d5f11838f 2119 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2120 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 2121 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2122 b0addr+=4;
mbed_official 532:fe11edbda85c 2123 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2124 b0addr+=4;
mbed_official 532:fe11edbda85c 2125 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2126 b0addr+=4;
mbed_official 532:fe11edbda85c 2127 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2128
mbed_official 235:685d5f11838f 2129 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2130 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2131
mbed_official 235:685d5f11838f 2132 /* Get tick */
mbed_official 235:685d5f11838f 2133 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2134
mbed_official 235:685d5f11838f 2135 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 2136 {
mbed_official 235:685d5f11838f 2137 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2138 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2139 {
mbed_official 235:685d5f11838f 2140 /* Change state */
mbed_official 235:685d5f11838f 2141 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2142
mbed_official 235:685d5f11838f 2143 /* Process Unlocked */
mbed_official 235:685d5f11838f 2144 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2145
mbed_official 235:685d5f11838f 2146 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2147 }
mbed_official 235:685d5f11838f 2148 }
mbed_official 235:685d5f11838f 2149 /***************************** Header phase *****************************/
mbed_official 235:685d5f11838f 2150 if(headersize != 0)
mbed_official 235:685d5f11838f 2151 {
mbed_official 235:685d5f11838f 2152 /* Select header phase */
mbed_official 532:fe11edbda85c 2153 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 2154
mbed_official 235:685d5f11838f 2155 /* Enable Crypto processor */
mbed_official 532:fe11edbda85c 2156 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2157
mbed_official 235:685d5f11838f 2158 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 2159 {
mbed_official 235:685d5f11838f 2160 /* Get tick */
mbed_official 235:685d5f11838f 2161 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2162
mbed_official 532:fe11edbda85c 2163 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 2164 {
mbed_official 235:685d5f11838f 2165 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2166 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2167 {
mbed_official 235:685d5f11838f 2168 /* Change state */
mbed_official 235:685d5f11838f 2169 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2170
mbed_official 235:685d5f11838f 2171 /* Process Unlocked */
mbed_official 235:685d5f11838f 2172 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2173
mbed_official 235:685d5f11838f 2174 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2175 }
mbed_official 235:685d5f11838f 2176 }
mbed_official 235:685d5f11838f 2177 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 2178 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2179 headeraddr+=4;
mbed_official 532:fe11edbda85c 2180 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2181 headeraddr+=4;
mbed_official 532:fe11edbda85c 2182 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2183 headeraddr+=4;
mbed_official 532:fe11edbda85c 2184 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2185 headeraddr+=4;
mbed_official 235:685d5f11838f 2186 }
mbed_official 235:685d5f11838f 2187
mbed_official 235:685d5f11838f 2188 /* Get tick */
mbed_official 235:685d5f11838f 2189 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2190
mbed_official 532:fe11edbda85c 2191 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 2192 {
mbed_official 235:685d5f11838f 2193 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2194 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2195 {
mbed_official 235:685d5f11838f 2196 /* Change state */
mbed_official 235:685d5f11838f 2197 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2198
mbed_official 235:685d5f11838f 2199 /* Process Unlocked */
mbed_official 235:685d5f11838f 2200 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2201
mbed_official 235:685d5f11838f 2202 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2203 }
mbed_official 235:685d5f11838f 2204 }
mbed_official 235:685d5f11838f 2205 }
mbed_official 235:685d5f11838f 2206 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 2207 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 2208 {
mbed_official 235:685d5f11838f 2209 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 2210 }
mbed_official 235:685d5f11838f 2211 /* Reset bit 0 */
mbed_official 235:685d5f11838f 2212 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 2213 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 2214 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 2215
mbed_official 235:685d5f11838f 2216 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2217 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2218
mbed_official 235:685d5f11838f 2219 /* Set the phase */
mbed_official 235:685d5f11838f 2220 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 2221 }
mbed_official 235:685d5f11838f 2222
mbed_official 235:685d5f11838f 2223 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 2224 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 2225
mbed_official 235:685d5f11838f 2226 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2227 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2228
mbed_official 235:685d5f11838f 2229 /* Return function status */
mbed_official 235:685d5f11838f 2230 return HAL_OK;
mbed_official 235:685d5f11838f 2231 }
mbed_official 532:fe11edbda85c 2232 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
mbed_official 235:685d5f11838f 2233 {
mbed_official 235:685d5f11838f 2234 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 235:685d5f11838f 2235 /* Write the Input block in the IN FIFO */
mbed_official 532:fe11edbda85c 2236 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 2237 inputaddr+=4;
mbed_official 532:fe11edbda85c 2238 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 2239 inputaddr+=4;
mbed_official 532:fe11edbda85c 2240 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 2241 inputaddr+=4;
mbed_official 532:fe11edbda85c 2242 hcryp->Instance->DR = *(uint32_t*)(inputaddr);
mbed_official 235:685d5f11838f 2243 hcryp->pCrypInBuffPtr += 16;
mbed_official 235:685d5f11838f 2244 hcryp->CrypInCount -= 16;
mbed_official 235:685d5f11838f 2245 if(hcryp->CrypInCount == 0)
mbed_official 235:685d5f11838f 2246 {
mbed_official 532:fe11edbda85c 2247 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
mbed_official 235:685d5f11838f 2248 /* Call the Input data transfer complete callback */
mbed_official 235:685d5f11838f 2249 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 235:685d5f11838f 2250 }
mbed_official 235:685d5f11838f 2251 }
mbed_official 532:fe11edbda85c 2252 else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
mbed_official 235:685d5f11838f 2253 {
mbed_official 235:685d5f11838f 2254 outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
mbed_official 235:685d5f11838f 2255 /* Read the Output block from the Output FIFO */
mbed_official 532:fe11edbda85c 2256 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 2257 outputaddr+=4;
mbed_official 532:fe11edbda85c 2258 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 2259 outputaddr+=4;
mbed_official 532:fe11edbda85c 2260 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 2261 outputaddr+=4;
mbed_official 532:fe11edbda85c 2262 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;
mbed_official 235:685d5f11838f 2263 hcryp->pCrypOutBuffPtr += 16;
mbed_official 235:685d5f11838f 2264 hcryp->CrypOutCount -= 16;
mbed_official 235:685d5f11838f 2265 if(hcryp->CrypOutCount == 0)
mbed_official 235:685d5f11838f 2266 {
mbed_official 532:fe11edbda85c 2267 __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
mbed_official 235:685d5f11838f 2268 /* Process Unlocked */
mbed_official 235:685d5f11838f 2269 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2270 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2271 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 235:685d5f11838f 2272 /* Call Input transfer complete callback */
mbed_official 235:685d5f11838f 2273 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 235:685d5f11838f 2274 }
mbed_official 235:685d5f11838f 2275 }
mbed_official 235:685d5f11838f 2276
mbed_official 235:685d5f11838f 2277 /* Return function status */
mbed_official 235:685d5f11838f 2278 return HAL_OK;
mbed_official 235:685d5f11838f 2279 }
mbed_official 235:685d5f11838f 2280
mbed_official 235:685d5f11838f 2281 /**
mbed_official 235:685d5f11838f 2282 * @brief Initializes the CRYP peripheral in AES GCM encryption mode using DMA.
mbed_official 235:685d5f11838f 2283 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 2284 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 2285 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 2286 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 2287 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 2288 * @retval HAL status
mbed_official 235:685d5f11838f 2289 */
mbed_official 235:685d5f11838f 2290 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 235:685d5f11838f 2291 {
mbed_official 235:685d5f11838f 2292 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 2293 uint32_t inputaddr;
mbed_official 235:685d5f11838f 2294 uint32_t outputaddr;
mbed_official 235:685d5f11838f 2295
mbed_official 235:685d5f11838f 2296 if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
mbed_official 235:685d5f11838f 2297 {
mbed_official 235:685d5f11838f 2298 /* Process Locked */
mbed_official 235:685d5f11838f 2299 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 2300
mbed_official 235:685d5f11838f 2301 inputaddr = (uint32_t)pPlainData;
mbed_official 235:685d5f11838f 2302 outputaddr = (uint32_t)pCypherData;
mbed_official 235:685d5f11838f 2303
mbed_official 235:685d5f11838f 2304 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2305 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 2306
mbed_official 235:685d5f11838f 2307 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 2308 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 2309 {
mbed_official 235:685d5f11838f 2310 /* Set the key */
mbed_official 235:685d5f11838f 2311 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 2312
mbed_official 235:685d5f11838f 2313 /* Set the CRYP peripheral in AES GCM mode */
mbed_official 532:fe11edbda85c 2314 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
mbed_official 235:685d5f11838f 2315
mbed_official 235:685d5f11838f 2316 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 2317 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 2318
mbed_official 235:685d5f11838f 2319 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2320 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2321
mbed_official 235:685d5f11838f 2322 /* Enable CRYP to start the init phase */
mbed_official 532:fe11edbda85c 2323 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2324
mbed_official 235:685d5f11838f 2325 /* Get tick */
mbed_official 235:685d5f11838f 2326 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2327
mbed_official 235:685d5f11838f 2328 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 2329 {
mbed_official 235:685d5f11838f 2330 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2331 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2332 {
mbed_official 235:685d5f11838f 2333 /* Change state */
mbed_official 235:685d5f11838f 2334 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2335
mbed_official 235:685d5f11838f 2336 /* Process Unlocked */
mbed_official 235:685d5f11838f 2337 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2338
mbed_official 235:685d5f11838f 2339 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2340 }
mbed_official 235:685d5f11838f 2341 }
mbed_official 235:685d5f11838f 2342 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2343 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2344
mbed_official 235:685d5f11838f 2345 /* Set the header phase */
mbed_official 235:685d5f11838f 2346 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1) != HAL_OK)
mbed_official 235:685d5f11838f 2347 {
mbed_official 235:685d5f11838f 2348 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2349 }
mbed_official 235:685d5f11838f 2350 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2351 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 2352
mbed_official 235:685d5f11838f 2353 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 2354 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 2355
mbed_official 235:685d5f11838f 2356 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2357 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2358
mbed_official 235:685d5f11838f 2359 /* Set the phase */
mbed_official 235:685d5f11838f 2360 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 2361 }
mbed_official 235:685d5f11838f 2362
mbed_official 235:685d5f11838f 2363 /* Set the input and output addresses and start DMA transfer */
mbed_official 235:685d5f11838f 2364 CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 235:685d5f11838f 2365
mbed_official 235:685d5f11838f 2366 /* Unlock process */
mbed_official 235:685d5f11838f 2367 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2368
mbed_official 235:685d5f11838f 2369 /* Return function status */
mbed_official 235:685d5f11838f 2370 return HAL_OK;
mbed_official 235:685d5f11838f 2371 }
mbed_official 235:685d5f11838f 2372 else
mbed_official 235:685d5f11838f 2373 {
mbed_official 235:685d5f11838f 2374 return HAL_ERROR;
mbed_official 235:685d5f11838f 2375 }
mbed_official 235:685d5f11838f 2376 }
mbed_official 235:685d5f11838f 2377
mbed_official 235:685d5f11838f 2378 /**
mbed_official 235:685d5f11838f 2379 * @brief Initializes the CRYP peripheral in AES CCM encryption mode using interrupt.
mbed_official 235:685d5f11838f 2380 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 2381 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 2382 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 2383 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 2384 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 2385 * @retval HAL status
mbed_official 235:685d5f11838f 2386 */
mbed_official 235:685d5f11838f 2387 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 235:685d5f11838f 2388 {
mbed_official 235:685d5f11838f 2389 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 2390 uint32_t inputaddr;
mbed_official 235:685d5f11838f 2391 uint32_t outputaddr;
mbed_official 235:685d5f11838f 2392 uint32_t headersize;
mbed_official 235:685d5f11838f 2393 uint32_t headeraddr;
mbed_official 235:685d5f11838f 2394 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 2395 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 2396 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 2397 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 2398 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2399
mbed_official 235:685d5f11838f 2400 if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
mbed_official 235:685d5f11838f 2401 {
mbed_official 235:685d5f11838f 2402 /* Process Locked */
mbed_official 235:685d5f11838f 2403 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 2404
mbed_official 235:685d5f11838f 2405 inputaddr = (uint32_t)pPlainData;
mbed_official 235:685d5f11838f 2406 outputaddr = (uint32_t)pCypherData;
mbed_official 235:685d5f11838f 2407
mbed_official 235:685d5f11838f 2408 headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 2409 headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 2410
mbed_official 235:685d5f11838f 2411 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 2412 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 2413 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 2414 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 2415
mbed_official 235:685d5f11838f 2416 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2417 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 2418
mbed_official 235:685d5f11838f 2419 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 2420 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 2421 {
mbed_official 235:685d5f11838f 2422 /************************ Formatting the header block *******************/
mbed_official 235:685d5f11838f 2423 if(headersize != 0)
mbed_official 235:685d5f11838f 2424 {
mbed_official 235:685d5f11838f 2425 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 2426 if(headersize < 65280)
mbed_official 235:685d5f11838f 2427 {
mbed_official 235:685d5f11838f 2428 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 2429 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 2430 headersize += 2;
mbed_official 235:685d5f11838f 2431 }
mbed_official 235:685d5f11838f 2432 else
mbed_official 235:685d5f11838f 2433 {
mbed_official 235:685d5f11838f 2434 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 2435 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 2436 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 2437 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 2438 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 2439 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 2440 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 2441 headersize += 6;
mbed_official 235:685d5f11838f 2442 }
mbed_official 235:685d5f11838f 2443 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 2444 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 2445 {
mbed_official 235:685d5f11838f 2446 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 2447 }
mbed_official 235:685d5f11838f 2448 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 2449 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 2450 {
mbed_official 235:685d5f11838f 2451 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 2452 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 2453 {
mbed_official 235:685d5f11838f 2454 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 2455 }
mbed_official 235:685d5f11838f 2456 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 2457 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 2458 }
mbed_official 235:685d5f11838f 2459 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 2460 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 2461 }
mbed_official 235:685d5f11838f 2462 /*********************** Formatting the block B0 ************************/
mbed_official 235:685d5f11838f 2463 if(headersize != 0)
mbed_official 235:685d5f11838f 2464 {
mbed_official 235:685d5f11838f 2465 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 2466 }
mbed_official 235:685d5f11838f 2467 /* Flags byte */
mbed_official 235:685d5f11838f 2468 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 2469 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 2470 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 2471
mbed_official 235:685d5f11838f 2472 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 2473 {
mbed_official 235:685d5f11838f 2474 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 2475 }
mbed_official 235:685d5f11838f 2476 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 2477 {
mbed_official 235:685d5f11838f 2478 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 2479 }
mbed_official 235:685d5f11838f 2480
mbed_official 235:685d5f11838f 2481 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 2482 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 2483
mbed_official 235:685d5f11838f 2484 /************************* Formatting the initial counter ***************/
mbed_official 235:685d5f11838f 2485 /* Byte 0:
mbed_official 235:685d5f11838f 2486 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 2487 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
mbed_official 235:685d5f11838f 2488 blocks are distinct from B0
mbed_official 235:685d5f11838f 2489 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 2490 */
mbed_official 235:685d5f11838f 2491 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 2492 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 2493 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 2494 {
mbed_official 235:685d5f11838f 2495 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 2496 }
mbed_official 235:685d5f11838f 2497 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 2498 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 2499
mbed_official 235:685d5f11838f 2500 /* Set the key */
mbed_official 235:685d5f11838f 2501 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 2502
mbed_official 235:685d5f11838f 2503 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 2504 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
mbed_official 235:685d5f11838f 2505
mbed_official 235:685d5f11838f 2506 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 2507 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 2508
mbed_official 235:685d5f11838f 2509 /* Select init phase */
mbed_official 532:fe11edbda85c 2510 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 2511
mbed_official 235:685d5f11838f 2512 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2513 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 2514 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2515 b0addr+=4;
mbed_official 532:fe11edbda85c 2516 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2517 b0addr+=4;
mbed_official 532:fe11edbda85c 2518 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2519 b0addr+=4;
mbed_official 532:fe11edbda85c 2520 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2521
mbed_official 235:685d5f11838f 2522 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2523 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2524
mbed_official 235:685d5f11838f 2525 /* Get tick */
mbed_official 235:685d5f11838f 2526 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2527
mbed_official 235:685d5f11838f 2528 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 2529 {
mbed_official 235:685d5f11838f 2530 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2531 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2532 {
mbed_official 235:685d5f11838f 2533 /* Change state */
mbed_official 235:685d5f11838f 2534 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2535
mbed_official 235:685d5f11838f 2536 /* Process Unlocked */
mbed_official 235:685d5f11838f 2537 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2538
mbed_official 235:685d5f11838f 2539 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2540 }
mbed_official 235:685d5f11838f 2541 }
mbed_official 235:685d5f11838f 2542 /***************************** Header phase *****************************/
mbed_official 235:685d5f11838f 2543 if(headersize != 0)
mbed_official 235:685d5f11838f 2544 {
mbed_official 235:685d5f11838f 2545 /* Select header phase */
mbed_official 532:fe11edbda85c 2546 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 2547
mbed_official 235:685d5f11838f 2548 /* Enable Crypto processor */
mbed_official 532:fe11edbda85c 2549 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2550
mbed_official 235:685d5f11838f 2551 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 2552 {
mbed_official 235:685d5f11838f 2553 /* Get tick */
mbed_official 235:685d5f11838f 2554 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2555
mbed_official 532:fe11edbda85c 2556 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 2557 {
mbed_official 235:685d5f11838f 2558 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2559 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2560 {
mbed_official 235:685d5f11838f 2561 /* Change state */
mbed_official 235:685d5f11838f 2562 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2563
mbed_official 235:685d5f11838f 2564 /* Process Unlocked */
mbed_official 235:685d5f11838f 2565 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2566
mbed_official 235:685d5f11838f 2567 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2568 }
mbed_official 235:685d5f11838f 2569 }
mbed_official 235:685d5f11838f 2570 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 2571 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2572 headeraddr+=4;
mbed_official 532:fe11edbda85c 2573 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2574 headeraddr+=4;
mbed_official 532:fe11edbda85c 2575 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2576 headeraddr+=4;
mbed_official 532:fe11edbda85c 2577 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2578 headeraddr+=4;
mbed_official 235:685d5f11838f 2579 }
mbed_official 235:685d5f11838f 2580
mbed_official 235:685d5f11838f 2581 /* Get tick */
mbed_official 235:685d5f11838f 2582 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2583
mbed_official 532:fe11edbda85c 2584 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 2585 {
mbed_official 235:685d5f11838f 2586 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2587 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2588 {
mbed_official 235:685d5f11838f 2589 /* Change state */
mbed_official 235:685d5f11838f 2590 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2591
mbed_official 235:685d5f11838f 2592 /* Process Unlocked */
mbed_official 235:685d5f11838f 2593 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2594
mbed_official 235:685d5f11838f 2595 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2596 }
mbed_official 235:685d5f11838f 2597 }
mbed_official 235:685d5f11838f 2598 }
mbed_official 235:685d5f11838f 2599 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 2600 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 2601 {
mbed_official 235:685d5f11838f 2602 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 2603 }
mbed_official 235:685d5f11838f 2604 /* Reset bit 0 */
mbed_official 235:685d5f11838f 2605 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 2606
mbed_official 235:685d5f11838f 2607 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 2608 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 2609
mbed_official 235:685d5f11838f 2610 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2611 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2612
mbed_official 235:685d5f11838f 2613 /* Set the phase */
mbed_official 235:685d5f11838f 2614 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 2615 }
mbed_official 235:685d5f11838f 2616
mbed_official 235:685d5f11838f 2617 /* Set the input and output addresses and start DMA transfer */
mbed_official 235:685d5f11838f 2618 CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 235:685d5f11838f 2619
mbed_official 235:685d5f11838f 2620 /* Unlock process */
mbed_official 235:685d5f11838f 2621 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2622
mbed_official 235:685d5f11838f 2623 /* Return function status */
mbed_official 235:685d5f11838f 2624 return HAL_OK;
mbed_official 235:685d5f11838f 2625 }
mbed_official 235:685d5f11838f 2626 else
mbed_official 235:685d5f11838f 2627 {
mbed_official 235:685d5f11838f 2628 return HAL_ERROR;
mbed_official 235:685d5f11838f 2629 }
mbed_official 235:685d5f11838f 2630 }
mbed_official 235:685d5f11838f 2631
mbed_official 235:685d5f11838f 2632 /**
mbed_official 235:685d5f11838f 2633 * @brief Initializes the CRYP peripheral in AES GCM decryption mode using DMA.
mbed_official 235:685d5f11838f 2634 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 2635 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 2636 * @param pCypherData: Pointer to the cyphertext buffer.
mbed_official 235:685d5f11838f 2637 * @param Size: Length of the cyphertext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 2638 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 2639 * @retval HAL status
mbed_official 235:685d5f11838f 2640 */
mbed_official 235:685d5f11838f 2641 HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 235:685d5f11838f 2642 {
mbed_official 235:685d5f11838f 2643 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 2644 uint32_t inputaddr;
mbed_official 235:685d5f11838f 2645 uint32_t outputaddr;
mbed_official 235:685d5f11838f 2646
mbed_official 235:685d5f11838f 2647 if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
mbed_official 235:685d5f11838f 2648 {
mbed_official 235:685d5f11838f 2649 /* Process Locked */
mbed_official 235:685d5f11838f 2650 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 2651
mbed_official 235:685d5f11838f 2652 inputaddr = (uint32_t)pCypherData;
mbed_official 235:685d5f11838f 2653 outputaddr = (uint32_t)pPlainData;
mbed_official 235:685d5f11838f 2654
mbed_official 235:685d5f11838f 2655 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2656 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 2657
mbed_official 235:685d5f11838f 2658 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 2659 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 2660 {
mbed_official 235:685d5f11838f 2661 /* Set the key */
mbed_official 235:685d5f11838f 2662 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 2663
mbed_official 235:685d5f11838f 2664 /* Set the CRYP peripheral in AES GCM decryption mode */
mbed_official 532:fe11edbda85c 2665 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
mbed_official 235:685d5f11838f 2666
mbed_official 235:685d5f11838f 2667 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 2668 CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 235:685d5f11838f 2669
mbed_official 235:685d5f11838f 2670 /* Enable CRYP to start the init phase */
mbed_official 532:fe11edbda85c 2671 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2672
mbed_official 235:685d5f11838f 2673 /* Get tick */
mbed_official 235:685d5f11838f 2674 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2675
mbed_official 235:685d5f11838f 2676 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 2677 {
mbed_official 235:685d5f11838f 2678 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2679 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2680 {
mbed_official 235:685d5f11838f 2681 /* Change state */
mbed_official 235:685d5f11838f 2682 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2683
mbed_official 235:685d5f11838f 2684 /* Process Unlocked */
mbed_official 235:685d5f11838f 2685 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2686
mbed_official 235:685d5f11838f 2687 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2688 }
mbed_official 235:685d5f11838f 2689 }
mbed_official 235:685d5f11838f 2690
mbed_official 235:685d5f11838f 2691 /* Set the header phase */
mbed_official 235:685d5f11838f 2692 if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1) != HAL_OK)
mbed_official 235:685d5f11838f 2693 {
mbed_official 235:685d5f11838f 2694 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2695 }
mbed_official 235:685d5f11838f 2696 /* Disable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2697 __HAL_CRYP_DISABLE(hcryp);
mbed_official 235:685d5f11838f 2698
mbed_official 235:685d5f11838f 2699 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 2700 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 2701
mbed_official 235:685d5f11838f 2702 /* Set the phase */
mbed_official 235:685d5f11838f 2703 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 2704 }
mbed_official 235:685d5f11838f 2705
mbed_official 235:685d5f11838f 2706 /* Set the input and output addresses and start DMA transfer */
mbed_official 235:685d5f11838f 2707 CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 235:685d5f11838f 2708
mbed_official 235:685d5f11838f 2709 /* Unlock process */
mbed_official 235:685d5f11838f 2710 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2711
mbed_official 235:685d5f11838f 2712 /* Return function status */
mbed_official 235:685d5f11838f 2713 return HAL_OK;
mbed_official 235:685d5f11838f 2714 }
mbed_official 235:685d5f11838f 2715 else
mbed_official 235:685d5f11838f 2716 {
mbed_official 235:685d5f11838f 2717 return HAL_ERROR;
mbed_official 235:685d5f11838f 2718 }
mbed_official 235:685d5f11838f 2719 }
mbed_official 235:685d5f11838f 2720
mbed_official 235:685d5f11838f 2721 /**
mbed_official 235:685d5f11838f 2722 * @brief Initializes the CRYP peripheral in AES CCM decryption mode using DMA
mbed_official 235:685d5f11838f 2723 * then decrypted pCypherData. The cypher data are available in pPlainData.
mbed_official 235:685d5f11838f 2724 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 2725 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 2726 * @param pCypherData: Pointer to the cyphertext buffer
mbed_official 235:685d5f11838f 2727 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 235:685d5f11838f 2728 * @param pPlainData: Pointer to the plaintext buffer
mbed_official 235:685d5f11838f 2729 * @retval HAL status
mbed_official 235:685d5f11838f 2730 */
mbed_official 235:685d5f11838f 2731 HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 235:685d5f11838f 2732 {
mbed_official 235:685d5f11838f 2733 uint32_t tickstart = 0;
mbed_official 235:685d5f11838f 2734 uint32_t inputaddr;
mbed_official 235:685d5f11838f 2735 uint32_t outputaddr;
mbed_official 235:685d5f11838f 2736 uint32_t headersize;
mbed_official 235:685d5f11838f 2737 uint32_t headeraddr;
mbed_official 235:685d5f11838f 2738 uint32_t loopcounter = 0;
mbed_official 235:685d5f11838f 2739 uint32_t bufferidx = 0;
mbed_official 235:685d5f11838f 2740 uint8_t blockb0[16] = {0};/* Block B0 */
mbed_official 235:685d5f11838f 2741 uint8_t ctr[16] = {0}; /* Counter */
mbed_official 235:685d5f11838f 2742 uint32_t b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2743
mbed_official 235:685d5f11838f 2744 if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
mbed_official 235:685d5f11838f 2745 {
mbed_official 235:685d5f11838f 2746 /* Process Locked */
mbed_official 235:685d5f11838f 2747 __HAL_LOCK(hcryp);
mbed_official 235:685d5f11838f 2748
mbed_official 235:685d5f11838f 2749 inputaddr = (uint32_t)pCypherData;
mbed_official 235:685d5f11838f 2750 outputaddr = (uint32_t)pPlainData;
mbed_official 235:685d5f11838f 2751
mbed_official 235:685d5f11838f 2752 headersize = hcryp->Init.HeaderSize;
mbed_official 235:685d5f11838f 2753 headeraddr = (uint32_t)hcryp->Init.Header;
mbed_official 235:685d5f11838f 2754
mbed_official 235:685d5f11838f 2755 hcryp->CrypInCount = Size;
mbed_official 235:685d5f11838f 2756 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 235:685d5f11838f 2757 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 235:685d5f11838f 2758 hcryp->CrypOutCount = Size;
mbed_official 235:685d5f11838f 2759
mbed_official 235:685d5f11838f 2760 /* Change the CRYP peripheral state */
mbed_official 235:685d5f11838f 2761 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 235:685d5f11838f 2762
mbed_official 235:685d5f11838f 2763 /* Check if initialization phase has already been performed */
mbed_official 235:685d5f11838f 2764 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 235:685d5f11838f 2765 {
mbed_official 235:685d5f11838f 2766 /************************ Formatting the header block *******************/
mbed_official 235:685d5f11838f 2767 if(headersize != 0)
mbed_official 235:685d5f11838f 2768 {
mbed_official 235:685d5f11838f 2769 /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
mbed_official 235:685d5f11838f 2770 if(headersize < 65280)
mbed_official 235:685d5f11838f 2771 {
mbed_official 235:685d5f11838f 2772 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
mbed_official 235:685d5f11838f 2773 hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
mbed_official 235:685d5f11838f 2774 headersize += 2;
mbed_official 235:685d5f11838f 2775 }
mbed_official 235:685d5f11838f 2776 else
mbed_official 235:685d5f11838f 2777 {
mbed_official 235:685d5f11838f 2778 /* Header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
mbed_official 235:685d5f11838f 2779 hcryp->Init.pScratch[bufferidx++] = 0xFF;
mbed_official 235:685d5f11838f 2780 hcryp->Init.pScratch[bufferidx++] = 0xFE;
mbed_official 235:685d5f11838f 2781 hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000;
mbed_official 235:685d5f11838f 2782 hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000;
mbed_official 235:685d5f11838f 2783 hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00;
mbed_official 235:685d5f11838f 2784 hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ff;
mbed_official 235:685d5f11838f 2785 headersize += 6;
mbed_official 235:685d5f11838f 2786 }
mbed_official 235:685d5f11838f 2787 /* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
mbed_official 235:685d5f11838f 2788 for(loopcounter = 0; loopcounter < headersize; loopcounter++)
mbed_official 235:685d5f11838f 2789 {
mbed_official 235:685d5f11838f 2790 hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
mbed_official 235:685d5f11838f 2791 }
mbed_official 235:685d5f11838f 2792 /* Check if the header size is modulo 16 */
mbed_official 235:685d5f11838f 2793 if ((headersize % 16) != 0)
mbed_official 235:685d5f11838f 2794 {
mbed_official 235:685d5f11838f 2795 /* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
mbed_official 235:685d5f11838f 2796 for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
mbed_official 235:685d5f11838f 2797 {
mbed_official 235:685d5f11838f 2798 hcryp->Init.pScratch[loopcounter] = 0;
mbed_official 235:685d5f11838f 2799 }
mbed_official 235:685d5f11838f 2800 /* Set the header size to modulo 16 */
mbed_official 235:685d5f11838f 2801 headersize = ((headersize/16) + 1) * 16;
mbed_official 235:685d5f11838f 2802 }
mbed_official 235:685d5f11838f 2803 /* Set the pointer headeraddr to hcryp->Init.pScratch */
mbed_official 235:685d5f11838f 2804 headeraddr = (uint32_t)hcryp->Init.pScratch;
mbed_official 235:685d5f11838f 2805 }
mbed_official 235:685d5f11838f 2806 /*********************** Formatting the block B0 ************************/
mbed_official 235:685d5f11838f 2807 if(headersize != 0)
mbed_official 235:685d5f11838f 2808 {
mbed_official 235:685d5f11838f 2809 blockb0[0] = 0x40;
mbed_official 235:685d5f11838f 2810 }
mbed_official 235:685d5f11838f 2811 /* Flags byte */
mbed_official 235:685d5f11838f 2812 /* blockb0[0] |= 0u | (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07) */
mbed_official 235:685d5f11838f 2813 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2))) >> 1) & (uint8_t)0x07 ) << 3);
mbed_official 235:685d5f11838f 2814 blockb0[0] |= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15) - hcryp->Init.IVSize) - (uint8_t)1) & (uint8_t)0x07);
mbed_official 235:685d5f11838f 2815
mbed_official 235:685d5f11838f 2816 for (loopcounter = 0; loopcounter < hcryp->Init.IVSize; loopcounter++)
mbed_official 235:685d5f11838f 2817 {
mbed_official 235:685d5f11838f 2818 blockb0[loopcounter+1] = hcryp->Init.pInitVect[loopcounter];
mbed_official 235:685d5f11838f 2819 }
mbed_official 235:685d5f11838f 2820 for ( ; loopcounter < 13; loopcounter++)
mbed_official 235:685d5f11838f 2821 {
mbed_official 235:685d5f11838f 2822 blockb0[loopcounter+1] = 0;
mbed_official 235:685d5f11838f 2823 }
mbed_official 235:685d5f11838f 2824
mbed_official 235:685d5f11838f 2825 blockb0[14] = (Size >> 8);
mbed_official 235:685d5f11838f 2826 blockb0[15] = (Size & 0xFF);
mbed_official 235:685d5f11838f 2827
mbed_official 235:685d5f11838f 2828 /************************* Formatting the initial counter ***************/
mbed_official 235:685d5f11838f 2829 /* Byte 0:
mbed_official 235:685d5f11838f 2830 Bits 7 and 6 are reserved and shall be set to 0
mbed_official 235:685d5f11838f 2831 Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
mbed_official 235:685d5f11838f 2832 blocks are distinct from B0
mbed_official 235:685d5f11838f 2833 Bits 0, 1, and 2 contain the same encoding of q as in B0
mbed_official 235:685d5f11838f 2834 */
mbed_official 235:685d5f11838f 2835 ctr[0] = blockb0[0] & 0x07;
mbed_official 235:685d5f11838f 2836 /* byte 1 to NonceSize is the IV (Nonce) */
mbed_official 235:685d5f11838f 2837 for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1; loopcounter++)
mbed_official 235:685d5f11838f 2838 {
mbed_official 235:685d5f11838f 2839 ctr[loopcounter] = blockb0[loopcounter];
mbed_official 235:685d5f11838f 2840 }
mbed_official 235:685d5f11838f 2841 /* Set the LSB to 1 */
mbed_official 235:685d5f11838f 2842 ctr[15] |= 0x01;
mbed_official 235:685d5f11838f 2843
mbed_official 235:685d5f11838f 2844 /* Set the key */
mbed_official 235:685d5f11838f 2845 CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
mbed_official 235:685d5f11838f 2846
mbed_official 235:685d5f11838f 2847 /* Set the CRYP peripheral in AES CCM mode */
mbed_official 532:fe11edbda85c 2848 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
mbed_official 235:685d5f11838f 2849
mbed_official 235:685d5f11838f 2850 /* Set the Initialization Vector */
mbed_official 532:fe11edbda85c 2851 CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
mbed_official 235:685d5f11838f 2852
mbed_official 235:685d5f11838f 2853 /* Select init phase */
mbed_official 532:fe11edbda85c 2854 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
mbed_official 235:685d5f11838f 2855
mbed_official 235:685d5f11838f 2856 b0addr = (uint32_t)blockb0;
mbed_official 235:685d5f11838f 2857 /* Write the blockb0 block in the IN FIFO */
mbed_official 532:fe11edbda85c 2858 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2859 b0addr+=4;
mbed_official 532:fe11edbda85c 2860 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2861 b0addr+=4;
mbed_official 532:fe11edbda85c 2862 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2863 b0addr+=4;
mbed_official 532:fe11edbda85c 2864 hcryp->Instance->DR = *(uint32_t*)(b0addr);
mbed_official 235:685d5f11838f 2865
mbed_official 235:685d5f11838f 2866 /* Enable the CRYP peripheral */
mbed_official 532:fe11edbda85c 2867 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2868
mbed_official 235:685d5f11838f 2869 /* Get tick */
mbed_official 235:685d5f11838f 2870 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2871
mbed_official 235:685d5f11838f 2872 while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
mbed_official 235:685d5f11838f 2873 {
mbed_official 235:685d5f11838f 2874 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2875
mbed_official 235:685d5f11838f 2876 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2877 {
mbed_official 235:685d5f11838f 2878 /* Change state */
mbed_official 235:685d5f11838f 2879 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2880
mbed_official 235:685d5f11838f 2881 /* Process Unlocked */
mbed_official 235:685d5f11838f 2882 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2883
mbed_official 235:685d5f11838f 2884 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2885
mbed_official 235:685d5f11838f 2886 }
mbed_official 235:685d5f11838f 2887 }
mbed_official 235:685d5f11838f 2888 /***************************** Header phase *****************************/
mbed_official 235:685d5f11838f 2889 if(headersize != 0)
mbed_official 235:685d5f11838f 2890 {
mbed_official 235:685d5f11838f 2891 /* Select header phase */
mbed_official 532:fe11edbda85c 2892 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
mbed_official 235:685d5f11838f 2893
mbed_official 235:685d5f11838f 2894 /* Enable Crypto processor */
mbed_official 532:fe11edbda85c 2895 __HAL_CRYP_ENABLE(hcryp);
mbed_official 235:685d5f11838f 2896
mbed_official 235:685d5f11838f 2897 for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
mbed_official 235:685d5f11838f 2898 {
mbed_official 235:685d5f11838f 2899 /* Get tick */
mbed_official 235:685d5f11838f 2900 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2901
mbed_official 532:fe11edbda85c 2902 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
mbed_official 235:685d5f11838f 2903 {
mbed_official 235:685d5f11838f 2904 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2905 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2906 {
mbed_official 235:685d5f11838f 2907 /* Change state */
mbed_official 235:685d5f11838f 2908 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2909
mbed_official 235:685d5f11838f 2910 /* Process Unlocked */
mbed_official 235:685d5f11838f 2911 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2912
mbed_official 235:685d5f11838f 2913 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2914 }
mbed_official 235:685d5f11838f 2915 }
mbed_official 235:685d5f11838f 2916 /* Write the header block in the IN FIFO */
mbed_official 532:fe11edbda85c 2917 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2918 headeraddr+=4;
mbed_official 532:fe11edbda85c 2919 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2920 headeraddr+=4;
mbed_official 532:fe11edbda85c 2921 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2922 headeraddr+=4;
mbed_official 532:fe11edbda85c 2923 hcryp->Instance->DR = *(uint32_t*)(headeraddr);
mbed_official 235:685d5f11838f 2924 headeraddr+=4;
mbed_official 235:685d5f11838f 2925 }
mbed_official 235:685d5f11838f 2926
mbed_official 235:685d5f11838f 2927 /* Get tick */
mbed_official 235:685d5f11838f 2928 tickstart = HAL_GetTick();
mbed_official 235:685d5f11838f 2929
mbed_official 532:fe11edbda85c 2930 while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
mbed_official 235:685d5f11838f 2931 {
mbed_official 235:685d5f11838f 2932 /* Check for the Timeout */
mbed_official 235:685d5f11838f 2933 if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
mbed_official 235:685d5f11838f 2934 {
mbed_official 235:685d5f11838f 2935 /* Change state */
mbed_official 235:685d5f11838f 2936 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 235:685d5f11838f 2937
mbed_official 235:685d5f11838f 2938 /* Process Unlocked */
mbed_official 235:685d5f11838f 2939 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2940
mbed_official 235:685d5f11838f 2941 return HAL_TIMEOUT;
mbed_official 235:685d5f11838f 2942 }
mbed_official 235:685d5f11838f 2943 }
mbed_official 235:685d5f11838f 2944 }
mbed_official 235:685d5f11838f 2945 /* Save formatted counter into the scratch buffer pScratch */
mbed_official 235:685d5f11838f 2946 for(loopcounter = 0; (loopcounter < 16); loopcounter++)
mbed_official 235:685d5f11838f 2947 {
mbed_official 235:685d5f11838f 2948 hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
mbed_official 235:685d5f11838f 2949 }
mbed_official 235:685d5f11838f 2950 /* Reset bit 0 */
mbed_official 235:685d5f11838f 2951 hcryp->Init.pScratch[15] &= 0xfe;
mbed_official 235:685d5f11838f 2952 /* Select payload phase once the header phase is performed */
mbed_official 532:fe11edbda85c 2953 __HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
mbed_official 235:685d5f11838f 2954
mbed_official 235:685d5f11838f 2955 /* Flush FIFO */
mbed_official 532:fe11edbda85c 2956 __HAL_CRYP_FIFO_FLUSH(hcryp);
mbed_official 235:685d5f11838f 2957
mbed_official 235:685d5f11838f 2958 /* Set the phase */
mbed_official 235:685d5f11838f 2959 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 235:685d5f11838f 2960 }
mbed_official 235:685d5f11838f 2961 /* Set the input and output addresses and start DMA transfer */
mbed_official 235:685d5f11838f 2962 CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 235:685d5f11838f 2963
mbed_official 235:685d5f11838f 2964 /* Unlock process */
mbed_official 235:685d5f11838f 2965 __HAL_UNLOCK(hcryp);
mbed_official 235:685d5f11838f 2966
mbed_official 235:685d5f11838f 2967 /* Return function status */
mbed_official 235:685d5f11838f 2968 return HAL_OK;
mbed_official 235:685d5f11838f 2969 }
mbed_official 235:685d5f11838f 2970 else
mbed_official 235:685d5f11838f 2971 {
mbed_official 235:685d5f11838f 2972 return HAL_ERROR;
mbed_official 235:685d5f11838f 2973 }
mbed_official 235:685d5f11838f 2974 }
mbed_official 235:685d5f11838f 2975
mbed_official 235:685d5f11838f 2976 /**
mbed_official 532:fe11edbda85c 2977 * @}
mbed_official 532:fe11edbda85c 2978 */
mbed_official 532:fe11edbda85c 2979
mbed_official 532:fe11edbda85c 2980 /** @defgroup CRYPEx_Exported_Functions_Group2 CRYPEx IRQ handler management
mbed_official 532:fe11edbda85c 2981 * @brief CRYPEx IRQ handler.
mbed_official 532:fe11edbda85c 2982 *
mbed_official 532:fe11edbda85c 2983 @verbatim
mbed_official 532:fe11edbda85c 2984 ==============================================================================
mbed_official 532:fe11edbda85c 2985 ##### CRYPEx IRQ handler management #####
mbed_official 532:fe11edbda85c 2986 ==============================================================================
mbed_official 532:fe11edbda85c 2987 [..] This section provides CRYPEx IRQ handler function.
mbed_official 532:fe11edbda85c 2988
mbed_official 532:fe11edbda85c 2989 @endverbatim
mbed_official 532:fe11edbda85c 2990 * @{
mbed_official 532:fe11edbda85c 2991 */
mbed_official 532:fe11edbda85c 2992
mbed_official 532:fe11edbda85c 2993 /**
mbed_official 532:fe11edbda85c 2994 * @brief This function handles CRYPEx interrupt request.
mbed_official 532:fe11edbda85c 2995 * @param hcryp: pointer to a CRYPEx_HandleTypeDef structure that contains
mbed_official 235:685d5f11838f 2996 * the configuration information for CRYP module
mbed_official 235:685d5f11838f 2997 * @retval None
mbed_official 235:685d5f11838f 2998 */
mbed_official 532:fe11edbda85c 2999
mbed_official 235:685d5f11838f 3000 void HAL_CRYPEx_GCMCCM_IRQHandler(CRYP_HandleTypeDef *hcryp)
mbed_official 235:685d5f11838f 3001 {
mbed_official 235:685d5f11838f 3002 switch(CRYP->CR & CRYP_CR_ALGOMODE_DIRECTION)
mbed_official 235:685d5f11838f 3003 {
mbed_official 235:685d5f11838f 3004 case CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT:
mbed_official 441:d2c15dda23c1 3005 HAL_CRYPEx_AESGCM_Encrypt_IT(hcryp, HAL_NULL, 0, HAL_NULL);
mbed_official 235:685d5f11838f 3006 break;
mbed_official 235:685d5f11838f 3007
mbed_official 235:685d5f11838f 3008 case CRYP_CR_ALGOMODE_AES_GCM_DECRYPT:
mbed_official 441:d2c15dda23c1 3009 HAL_CRYPEx_AESGCM_Decrypt_IT(hcryp, HAL_NULL, 0, HAL_NULL);
mbed_official 235:685d5f11838f 3010 break;
mbed_official 235:685d5f11838f 3011
mbed_official 235:685d5f11838f 3012 case CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT:
mbed_official 441:d2c15dda23c1 3013 HAL_CRYPEx_AESCCM_Encrypt_IT(hcryp, HAL_NULL, 0, HAL_NULL);
mbed_official 235:685d5f11838f 3014 break;
mbed_official 235:685d5f11838f 3015
mbed_official 235:685d5f11838f 3016 case CRYP_CR_ALGOMODE_AES_CCM_DECRYPT:
mbed_official 441:d2c15dda23c1 3017 HAL_CRYPEx_AESCCM_Decrypt_IT(hcryp, HAL_NULL, 0, HAL_NULL);
mbed_official 235:685d5f11838f 3018 break;
mbed_official 235:685d5f11838f 3019
mbed_official 235:685d5f11838f 3020 default:
mbed_official 235:685d5f11838f 3021 break;
mbed_official 235:685d5f11838f 3022 }
mbed_official 235:685d5f11838f 3023 }
mbed_official 235:685d5f11838f 3024
mbed_official 235:685d5f11838f 3025 /**
mbed_official 235:685d5f11838f 3026 * @}
mbed_official 235:685d5f11838f 3027 */
mbed_official 235:685d5f11838f 3028
mbed_official 235:685d5f11838f 3029 /**
mbed_official 235:685d5f11838f 3030 * @}
mbed_official 235:685d5f11838f 3031 */
mbed_official 235:685d5f11838f 3032 #endif /* STM32F437xx || STM32F439xx */
mbed_official 235:685d5f11838f 3033
mbed_official 235:685d5f11838f 3034 #endif /* HAL_CRYP_MODULE_ENABLED */
mbed_official 235:685d5f11838f 3035 /**
mbed_official 235:685d5f11838f 3036 * @}
mbed_official 235:685d5f11838f 3037 */
mbed_official 235:685d5f11838f 3038
mbed_official 235:685d5f11838f 3039 /**
mbed_official 235:685d5f11838f 3040 * @}
mbed_official 235:685d5f11838f 3041 */
mbed_official 235:685d5f11838f 3042
mbed_official 235:685d5f11838f 3043 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/