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_NUCLEO_F401RE/stm32f4xx_hal_hash_ex.c@87:085cde657901, 2014-02-08 (annotated)

Committer:
mbed_official
Date:
Sat Feb 08 19:45:06 2014 +0000
Revision:
87:085cde657901
Child:
106:ced8cbb51063
Synchronized with git revision 9272cdeb45ec7e6077641536509413da8fd2ebc2



Full URL: https://github.com/mbedmicro/mbed/commit/9272cdeb45ec7e6077641536509413da8fd2ebc2/



Add NUCLEO_F401RE, improvements

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 87:085cde657901 1 /**
mbed_official 87:085cde657901 2 ******************************************************************************
mbed_official 87:085cde657901 3 * @file stm32f4xx_hal_hash_ex.c
mbed_official 87:085cde657901 4 * @author MCD Application Team
mbed_official 87:085cde657901 5 * @version V1.0.0RC2
mbed_official 87:085cde657901 6 * @date 04-February-2014
mbed_official 87:085cde657901 7 * @brief HASH HAL Extension module driver.
mbed_official 87:085cde657901 8 * This file provides firmware functions to manage the following
mbed_official 87:085cde657901 9 * functionalities of HASH peripheral:
mbed_official 87:085cde657901 10 * + Extended HASH processing functions based on SHA224 Algorithm
mbed_official 87:085cde657901 11 * + Extended HASH processing functions based on SHA256 Algorithm
mbed_official 87:085cde657901 12 *
mbed_official 87:085cde657901 13 @verbatim
mbed_official 87:085cde657901 14 ==============================================================================
mbed_official 87:085cde657901 15 ##### How to use this driver #####
mbed_official 87:085cde657901 16 ==============================================================================
mbed_official 87:085cde657901 17 [..]
mbed_official 87:085cde657901 18 The HASH HAL driver can be used as follows:
mbed_official 87:085cde657901 19 (#)Initialize the HASH low level resources by implementing the HAL_HASH_MspInit():
mbed_official 87:085cde657901 20 (##) Enable the HASH interface clock using __HASH_CLK_ENABLE()
mbed_official 87:085cde657901 21 (##) In case of using processing APIs based on interrupts (e.g. HAL_HMACEx_SHA224_Start())
mbed_official 87:085cde657901 22 (+++) Configure the HASH interrupt priority using HAL_NVIC_SetPriority()
mbed_official 87:085cde657901 23 (+++) Enable the HASH IRQ handler using HAL_NVIC_EnableIRQ()
mbed_official 87:085cde657901 24 (+++) In HASH IRQ handler, call HAL_HASH_IRQHandler()
mbed_official 87:085cde657901 25 (##) In case of using DMA to control data transfer (e.g. HAL_HMACEx_SH224_Start_DMA())
mbed_official 87:085cde657901 26 (+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE()
mbed_official 87:085cde657901 27 (+++) Configure and enable one DMA stream one for managing data transfer from
mbed_official 87:085cde657901 28 memory to peripheral (input stream). Managing data transfer from
mbed_official 87:085cde657901 29 peripheral to memory can be performed only using CPU
mbed_official 87:085cde657901 30 (+++) Associate the initialized DMA handle to the HASH DMA handle
mbed_official 87:085cde657901 31 using __HAL_LINKDMA()
mbed_official 87:085cde657901 32 (+++) Configure the priority and enable the NVIC for the transfer complete
mbed_official 87:085cde657901 33 interrupt on the DMA Stream: HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()
mbed_official 87:085cde657901 34 (#)Initialize the HASH HAL using HAL_HASH_Init(). This function configures mainly:
mbed_official 87:085cde657901 35 (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit.
mbed_official 87:085cde657901 36 (##) For HMAC, the encryption key.
mbed_official 87:085cde657901 37 (##) For HMAC, the key size used for encryption.
mbed_official 87:085cde657901 38 (#)Three processing functions are available:
mbed_official 87:085cde657901 39 (##) Polling mode: processing APIs are blocking functions
mbed_official 87:085cde657901 40 i.e. they process the data and wait till the digest computation is finished
mbed_official 87:085cde657901 41 e.g. HAL_HASHEx_SHA224_Start()
mbed_official 87:085cde657901 42 (##) Interrupt mode: encryption and decryption APIs are not blocking functions
mbed_official 87:085cde657901 43 i.e. they process the data under interrupt
mbed_official 87:085cde657901 44 e.g. HAL_HASHEx_SHA224_Start_IT()
mbed_official 87:085cde657901 45 (##) DMA mode: processing APIs are not blocking functions and the CPU is
mbed_official 87:085cde657901 46 not used for data transfer i.e. the data transfer is ensured by DMA
mbed_official 87:085cde657901 47 e.g. HAL_HASHEx_SHA224_Start_DMA()
mbed_official 87:085cde657901 48 (#)When the processing function is called at first time after HAL_HASH_Init()
mbed_official 87:085cde657901 49 the HASH peripheral is initialized and processes the buffer in input.
mbed_official 87:085cde657901 50 After that, the digest computation is started.
mbed_official 87:085cde657901 51 When processing multi-buffer use the accumulate function to write the
mbed_official 87:085cde657901 52 data in the peripheral without starting the digest computation. In last
mbed_official 87:085cde657901 53 buffer use the start function to input the last buffer ans start the digest
mbed_official 87:085cde657901 54 computation.
mbed_official 87:085cde657901 55 (##) e.g. HAL_HASHEx_SHA224_Accumulate() : write 1st data buffer in the peripheral without starting the digest computation
mbed_official 87:085cde657901 56 (##) write (n-1)th data buffer in the peripheral without starting the digest computation
mbed_official 87:085cde657901 57 (##) HAL_HASHEx_SHA224_Start() : write (n)th data buffer in the peripheral and start the digest computation
mbed_official 87:085cde657901 58 (#)In HMAC mode, there is no Accumulate API. Only Start API is available.
mbed_official 87:085cde657901 59 (#)In case of using DMA, call the DMA start processing e.g. HAL_HASHEx_SHA224_Start_DMA().
mbed_official 87:085cde657901 60 After that, call the finish function in order to get the digest value
mbed_official 87:085cde657901 61 e.g. HAL_HASHEx_SHA224_Finish()
mbed_official 87:085cde657901 62 (#)Call HAL_HASH_DeInit() to deinitialize the HASH peripheral.
mbed_official 87:085cde657901 63
mbed_official 87:085cde657901 64 @endverbatim
mbed_official 87:085cde657901 65 ******************************************************************************
mbed_official 87:085cde657901 66 * @attention
mbed_official 87:085cde657901 67 *
mbed_official 87:085cde657901 68 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 87:085cde657901 69 *
mbed_official 87:085cde657901 70 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 87:085cde657901 71 * are permitted provided that the following conditions are met:
mbed_official 87:085cde657901 72 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 87:085cde657901 73 * this list of conditions and the following disclaimer.
mbed_official 87:085cde657901 74 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 87:085cde657901 75 * this list of conditions and the following disclaimer in the documentation
mbed_official 87:085cde657901 76 * and/or other materials provided with the distribution.
mbed_official 87:085cde657901 77 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 87:085cde657901 78 * may be used to endorse or promote products derived from this software
mbed_official 87:085cde657901 79 * without specific prior written permission.
mbed_official 87:085cde657901 80 *
mbed_official 87:085cde657901 81 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 87:085cde657901 82 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 87:085cde657901 83 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 87:085cde657901 84 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 87:085cde657901 85 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 87:085cde657901 86 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 87:085cde657901 87 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 87:085cde657901 88 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 87:085cde657901 89 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 87:085cde657901 90 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 87:085cde657901 91 *
mbed_official 87:085cde657901 92 ******************************************************************************
mbed_official 87:085cde657901 93 */
mbed_official 87:085cde657901 94
mbed_official 87:085cde657901 95 /* Includes ------------------------------------------------------------------*/
mbed_official 87:085cde657901 96 #include "stm32f4xx_hal.h"
mbed_official 87:085cde657901 97
mbed_official 87:085cde657901 98 /** @addtogroup STM32F4xx_HAL_Driver
mbed_official 87:085cde657901 99 * @{
mbed_official 87:085cde657901 100 */
mbed_official 87:085cde657901 101
mbed_official 87:085cde657901 102 /** @defgroup HASHEx
mbed_official 87:085cde657901 103 * @brief HASH Extension HAL module driver.
mbed_official 87:085cde657901 104 * @{
mbed_official 87:085cde657901 105 */
mbed_official 87:085cde657901 106
mbed_official 87:085cde657901 107 #ifdef HAL_HASH_MODULE_ENABLED
mbed_official 87:085cde657901 108
mbed_official 87:085cde657901 109 #if defined(STM32F437xx) || defined(STM32F439xx)
mbed_official 87:085cde657901 110
mbed_official 87:085cde657901 111 /* Private typedef -----------------------------------------------------------*/
mbed_official 87:085cde657901 112 /* Private define ------------------------------------------------------------*/
mbed_official 87:085cde657901 113 /* Private macro -------------------------------------------------------------*/
mbed_official 87:085cde657901 114 /* Private variables ---------------------------------------------------------*/
mbed_official 87:085cde657901 115 /* Private function prototypes -----------------------------------------------*/
mbed_official 87:085cde657901 116 static void HASHEx_DMAXferCplt(DMA_HandleTypeDef *hdma);
mbed_official 87:085cde657901 117 static void HASHEx_WriteData(uint8_t *pInBuffer, uint32_t Size);
mbed_official 87:085cde657901 118 static void HASHEx_GetDigest(uint8_t *pMsgDigest, uint8_t Size);
mbed_official 87:085cde657901 119 static void HASHEx_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 87:085cde657901 120
mbed_official 87:085cde657901 121 /* Private functions ---------------------------------------------------------*/
mbed_official 87:085cde657901 122
mbed_official 87:085cde657901 123 /** @defgroup HASHEx_Private_Functions
mbed_official 87:085cde657901 124 * @{
mbed_official 87:085cde657901 125 */
mbed_official 87:085cde657901 126
mbed_official 87:085cde657901 127 /** @defgroup HASHEx_Group1 HASH processing functions
mbed_official 87:085cde657901 128 * @brief processing functions using polling mode
mbed_official 87:085cde657901 129 *
mbed_official 87:085cde657901 130 @verbatim
mbed_official 87:085cde657901 131 ===============================================================================
mbed_official 87:085cde657901 132 ##### HASH processing using polling mode functions #####
mbed_official 87:085cde657901 133 ===============================================================================
mbed_official 87:085cde657901 134 [..] This section provides functions allowing to calculate in polling mode
mbed_official 87:085cde657901 135 the hash value using one of the following algorithms:
mbed_official 87:085cde657901 136 (+) SHA224
mbed_official 87:085cde657901 137 (+) SHA256
mbed_official 87:085cde657901 138
mbed_official 87:085cde657901 139 @endverbatim
mbed_official 87:085cde657901 140 * @{
mbed_official 87:085cde657901 141 */
mbed_official 87:085cde657901 142
mbed_official 87:085cde657901 143 /**
mbed_official 87:085cde657901 144 * @brief Initializes the HASH peripheral in SHA224 mode
mbed_official 87:085cde657901 145 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 87:085cde657901 146 * @param hhash: HASH handle
mbed_official 87:085cde657901 147 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 148 * @param pOutBuffer: Pointer to the output buffer (hashed buffer).
mbed_official 87:085cde657901 149 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 150 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 151 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 87:085cde657901 152 * @param Timeout: Specify Timeout value
mbed_official 87:085cde657901 153 * @retval HAL status
mbed_official 87:085cde657901 154 */
mbed_official 87:085cde657901 155 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 156 {
mbed_official 87:085cde657901 157 uint32_t timeout = 0;
mbed_official 87:085cde657901 158
mbed_official 87:085cde657901 159 /* Process Locked */
mbed_official 87:085cde657901 160 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 161
mbed_official 87:085cde657901 162 /* Change the HASH state */
mbed_official 87:085cde657901 163 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 164
mbed_official 87:085cde657901 165 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 166 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 167 {
mbed_official 87:085cde657901 168 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 169 the message digest of a new message */
mbed_official 87:085cde657901 170 HASH->CR |= HASH_AlgoSelection_SHA224 | HASH_CR_INIT;
mbed_official 87:085cde657901 171 }
mbed_official 87:085cde657901 172
mbed_official 87:085cde657901 173 /* Set the phase */
mbed_official 87:085cde657901 174 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 175
mbed_official 87:085cde657901 176 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 177 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 178
mbed_official 87:085cde657901 179 /* Write input buffer in data register */
mbed_official 87:085cde657901 180 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 181
mbed_official 87:085cde657901 182 /* Start the digest calculation */
mbed_official 87:085cde657901 183 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 184
mbed_official 87:085cde657901 185 /* Get timeout */
mbed_official 87:085cde657901 186 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 187
mbed_official 87:085cde657901 188 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 189 {
mbed_official 87:085cde657901 190 /* Check for the Timeout */
mbed_official 87:085cde657901 191 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 192 {
mbed_official 87:085cde657901 193 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 194 {
mbed_official 87:085cde657901 195 /* Change state */
mbed_official 87:085cde657901 196 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 197
mbed_official 87:085cde657901 198 /* Process Unlocked */
mbed_official 87:085cde657901 199 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 200
mbed_official 87:085cde657901 201 return HAL_TIMEOUT;
mbed_official 87:085cde657901 202 }
mbed_official 87:085cde657901 203 }
mbed_official 87:085cde657901 204 }
mbed_official 87:085cde657901 205
mbed_official 87:085cde657901 206 /* Read the message digest */
mbed_official 87:085cde657901 207 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 87:085cde657901 208
mbed_official 87:085cde657901 209 /* Change the HASH state */
mbed_official 87:085cde657901 210 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 211
mbed_official 87:085cde657901 212 /* Process Unlocked */
mbed_official 87:085cde657901 213 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 214
mbed_official 87:085cde657901 215 /* Return function status */
mbed_official 87:085cde657901 216 return HAL_OK;
mbed_official 87:085cde657901 217 }
mbed_official 87:085cde657901 218
mbed_official 87:085cde657901 219 /**
mbed_official 87:085cde657901 220 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 87:085cde657901 221 The digest is available in pOutBuffer.
mbed_official 87:085cde657901 222 * @param hhash: HASH handle
mbed_official 87:085cde657901 223 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 224 * @param pOutBuffer: Pointer to the output buffer (hashed buffer).
mbed_official 87:085cde657901 225 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 226 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 227 * @param pOutBuffer: Pointer to the computed digest. Its size must be 32 bytes.
mbed_official 87:085cde657901 228 * @param Timeout: Specify Timeout value
mbed_official 87:085cde657901 229 * @retval HAL status
mbed_official 87:085cde657901 230 */
mbed_official 87:085cde657901 231 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 232 {
mbed_official 87:085cde657901 233 uint32_t timeout = 0;
mbed_official 87:085cde657901 234
mbed_official 87:085cde657901 235 /* Process Locked */
mbed_official 87:085cde657901 236 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 237
mbed_official 87:085cde657901 238 /* Change the HASH state */
mbed_official 87:085cde657901 239 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 240
mbed_official 87:085cde657901 241 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 242 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 243 {
mbed_official 87:085cde657901 244 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 245 the message digest of a new message */
mbed_official 87:085cde657901 246 HASH->CR |= HASH_AlgoSelection_SHA256 | HASH_CR_INIT;
mbed_official 87:085cde657901 247 }
mbed_official 87:085cde657901 248
mbed_official 87:085cde657901 249 /* Set the phase */
mbed_official 87:085cde657901 250 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 251
mbed_official 87:085cde657901 252 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 253 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 254
mbed_official 87:085cde657901 255 /* Write input buffer in data register */
mbed_official 87:085cde657901 256 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 257
mbed_official 87:085cde657901 258 /* Start the digest calculation */
mbed_official 87:085cde657901 259 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 260
mbed_official 87:085cde657901 261 /* Get timeout */
mbed_official 87:085cde657901 262 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 263
mbed_official 87:085cde657901 264 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 265 {
mbed_official 87:085cde657901 266 /* Check for the Timeout */
mbed_official 87:085cde657901 267 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 268 {
mbed_official 87:085cde657901 269 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 270 {
mbed_official 87:085cde657901 271 /* Change state */
mbed_official 87:085cde657901 272 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 273
mbed_official 87:085cde657901 274 /* Process Unlocked */
mbed_official 87:085cde657901 275 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 276
mbed_official 87:085cde657901 277 return HAL_TIMEOUT;
mbed_official 87:085cde657901 278 }
mbed_official 87:085cde657901 279 }
mbed_official 87:085cde657901 280 }
mbed_official 87:085cde657901 281
mbed_official 87:085cde657901 282 /* Read the message digest */
mbed_official 87:085cde657901 283 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 87:085cde657901 284
mbed_official 87:085cde657901 285 /* Change the HASH state */
mbed_official 87:085cde657901 286 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 287
mbed_official 87:085cde657901 288 /* Process Unlocked */
mbed_official 87:085cde657901 289 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 290
mbed_official 87:085cde657901 291 /* Return function status */
mbed_official 87:085cde657901 292 return HAL_OK;
mbed_official 87:085cde657901 293 }
mbed_official 87:085cde657901 294
mbed_official 87:085cde657901 295
mbed_official 87:085cde657901 296 /**
mbed_official 87:085cde657901 297 * @brief Initializes the HASH peripheral in SHA224 mode
mbed_official 87:085cde657901 298 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 87:085cde657901 299 * @param hhash: HASH handle
mbed_official 87:085cde657901 300 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 301 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 302 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 303 * @retval HAL status
mbed_official 87:085cde657901 304 */
mbed_official 87:085cde657901 305 HAL_StatusTypeDef HAL_HASHEx_SHA224_Accumulate(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 306 {
mbed_official 87:085cde657901 307 /* Process Locked */
mbed_official 87:085cde657901 308 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 309
mbed_official 87:085cde657901 310 /* Change the HASH state */
mbed_official 87:085cde657901 311 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 312
mbed_official 87:085cde657901 313 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 314 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 315 {
mbed_official 87:085cde657901 316 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 317 the message digest of a new message */
mbed_official 87:085cde657901 318 HASH->CR |= HASH_AlgoSelection_SHA224 | HASH_CR_INIT;
mbed_official 87:085cde657901 319 }
mbed_official 87:085cde657901 320
mbed_official 87:085cde657901 321 /* Set the phase */
mbed_official 87:085cde657901 322 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 323
mbed_official 87:085cde657901 324 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 325 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 326
mbed_official 87:085cde657901 327 /* Write input buffer in data register */
mbed_official 87:085cde657901 328 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 329
mbed_official 87:085cde657901 330 /* Change the HASH state */
mbed_official 87:085cde657901 331 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 332
mbed_official 87:085cde657901 333 /* Process Unlocked */
mbed_official 87:085cde657901 334 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 335
mbed_official 87:085cde657901 336 /* Return function status */
mbed_official 87:085cde657901 337 return HAL_OK;
mbed_official 87:085cde657901 338 }
mbed_official 87:085cde657901 339
mbed_official 87:085cde657901 340
mbed_official 87:085cde657901 341 /**
mbed_official 87:085cde657901 342 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 87:085cde657901 343 The digest is available in pOutBuffer.
mbed_official 87:085cde657901 344 * @param hhash: HASH handle
mbed_official 87:085cde657901 345 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 346 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 347 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 348 * @retval HAL status
mbed_official 87:085cde657901 349 */
mbed_official 87:085cde657901 350 HAL_StatusTypeDef HAL_HASHEx_SHA256_Accumulate(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 351 {
mbed_official 87:085cde657901 352 /* Process Locked */
mbed_official 87:085cde657901 353 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 354
mbed_official 87:085cde657901 355 /* Change the HASH state */
mbed_official 87:085cde657901 356 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 357
mbed_official 87:085cde657901 358 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 359 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 360 {
mbed_official 87:085cde657901 361 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 362 the message digest of a new message */
mbed_official 87:085cde657901 363 HASH->CR |= HASH_AlgoSelection_SHA256 | HASH_CR_INIT;
mbed_official 87:085cde657901 364 }
mbed_official 87:085cde657901 365
mbed_official 87:085cde657901 366 /* Set the phase */
mbed_official 87:085cde657901 367 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 368
mbed_official 87:085cde657901 369 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 370 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 371
mbed_official 87:085cde657901 372 /* Write input buffer in data register */
mbed_official 87:085cde657901 373 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 374
mbed_official 87:085cde657901 375 /* Change the HASH state */
mbed_official 87:085cde657901 376 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 377
mbed_official 87:085cde657901 378 /* Process Unlocked */
mbed_official 87:085cde657901 379 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 380
mbed_official 87:085cde657901 381 /* Return function status */
mbed_official 87:085cde657901 382 return HAL_OK;
mbed_official 87:085cde657901 383 }
mbed_official 87:085cde657901 384
mbed_official 87:085cde657901 385
mbed_official 87:085cde657901 386 /**
mbed_official 87:085cde657901 387 * @}
mbed_official 87:085cde657901 388 */
mbed_official 87:085cde657901 389
mbed_official 87:085cde657901 390 /** @defgroup HASHEx_Group2 HMAC processing functions using polling mode
mbed_official 87:085cde657901 391 * @brief HMAC processing functions using polling mode .
mbed_official 87:085cde657901 392 *
mbed_official 87:085cde657901 393 @verbatim
mbed_official 87:085cde657901 394 ===============================================================================
mbed_official 87:085cde657901 395 ##### HMAC processing using polling mode functions #####
mbed_official 87:085cde657901 396 ===============================================================================
mbed_official 87:085cde657901 397 [..] This section provides functions allowing to calculate in polling mode
mbed_official 87:085cde657901 398 the HMAC value using one of the following algorithms:
mbed_official 87:085cde657901 399 (+) SHA224
mbed_official 87:085cde657901 400 (+) SHA256
mbed_official 87:085cde657901 401
mbed_official 87:085cde657901 402 @endverbatim
mbed_official 87:085cde657901 403 * @{
mbed_official 87:085cde657901 404 */
mbed_official 87:085cde657901 405
mbed_official 87:085cde657901 406 /**
mbed_official 87:085cde657901 407 * @brief Initializes the HASH peripheral in HMAC SHA224 mode
mbed_official 87:085cde657901 408 * then processes pInBuffer. The digest is available in pOutBuffer.
mbed_official 87:085cde657901 409 * @param hhash: HASH handle
mbed_official 87:085cde657901 410 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 411 * @param pOutBuffer: Pointer to the output buffer (hashed buffer).
mbed_official 87:085cde657901 412 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 413 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 414 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 87:085cde657901 415 * @retval HAL status
mbed_official 87:085cde657901 416 */
mbed_official 87:085cde657901 417 HAL_StatusTypeDef HAL_HMACEx_SHA224_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 418 {
mbed_official 87:085cde657901 419 uint32_t timeout = 0;
mbed_official 87:085cde657901 420
mbed_official 87:085cde657901 421 /* Process Locked */
mbed_official 87:085cde657901 422 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 423
mbed_official 87:085cde657901 424 /* Change the HASH state */
mbed_official 87:085cde657901 425 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 426
mbed_official 87:085cde657901 427 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 428 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 429 {
mbed_official 87:085cde657901 430 /* Check if key size is greater than 64 bytes */
mbed_official 87:085cde657901 431 if(hhash->Init.KeySize > 64)
mbed_official 87:085cde657901 432 {
mbed_official 87:085cde657901 433 /* Select the HMAC SHA224 mode */
mbed_official 87:085cde657901 434 HASH->CR |= (HASH_AlgoSelection_SHA224 | HASH_AlgoMode_HMAC | HASH_HMACKeyType_LongKey | HASH_CR_INIT);
mbed_official 87:085cde657901 435 }
mbed_official 87:085cde657901 436 else
mbed_official 87:085cde657901 437 {
mbed_official 87:085cde657901 438 /* Select the HMAC SHA224 mode */
mbed_official 87:085cde657901 439 HASH->CR |= (HASH_AlgoSelection_SHA224 | HASH_AlgoMode_HMAC | HASH_CR_INIT);
mbed_official 87:085cde657901 440 }
mbed_official 87:085cde657901 441 }
mbed_official 87:085cde657901 442
mbed_official 87:085cde657901 443 /* Set the phase */
mbed_official 87:085cde657901 444 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 445
mbed_official 87:085cde657901 446 /************************** STEP 1 ******************************************/
mbed_official 87:085cde657901 447 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 448 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 449
mbed_official 87:085cde657901 450 /* Write input buffer in data register */
mbed_official 87:085cde657901 451 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 87:085cde657901 452
mbed_official 87:085cde657901 453 /* Start the digest calculation */
mbed_official 87:085cde657901 454 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 455
mbed_official 87:085cde657901 456 /* Get timeout */
mbed_official 87:085cde657901 457 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 458
mbed_official 87:085cde657901 459 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 460 {
mbed_official 87:085cde657901 461 /* Check for the Timeout */
mbed_official 87:085cde657901 462 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 463 {
mbed_official 87:085cde657901 464 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 465 {
mbed_official 87:085cde657901 466 /* Change state */
mbed_official 87:085cde657901 467 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 468
mbed_official 87:085cde657901 469 /* Process Unlocked */
mbed_official 87:085cde657901 470 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 471
mbed_official 87:085cde657901 472 return HAL_TIMEOUT;
mbed_official 87:085cde657901 473 }
mbed_official 87:085cde657901 474 }
mbed_official 87:085cde657901 475 }
mbed_official 87:085cde657901 476 /************************** STEP 2 ******************************************/
mbed_official 87:085cde657901 477 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 478 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 479
mbed_official 87:085cde657901 480 /* Write input buffer in data register */
mbed_official 87:085cde657901 481 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 482
mbed_official 87:085cde657901 483 /* Start the digest calculation */
mbed_official 87:085cde657901 484 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 485
mbed_official 87:085cde657901 486 /* Get timeout */
mbed_official 87:085cde657901 487 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 488
mbed_official 87:085cde657901 489 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 490 {
mbed_official 87:085cde657901 491 /* Check for the Timeout */
mbed_official 87:085cde657901 492 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 493 {
mbed_official 87:085cde657901 494 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 495 {
mbed_official 87:085cde657901 496 /* Change state */
mbed_official 87:085cde657901 497 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 498
mbed_official 87:085cde657901 499 /* Process Unlocked */
mbed_official 87:085cde657901 500 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 501
mbed_official 87:085cde657901 502 return HAL_TIMEOUT;
mbed_official 87:085cde657901 503 }
mbed_official 87:085cde657901 504 }
mbed_official 87:085cde657901 505 }
mbed_official 87:085cde657901 506 /************************** STEP 3 ******************************************/
mbed_official 87:085cde657901 507 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 508 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 509
mbed_official 87:085cde657901 510 /* Write input buffer in data register */
mbed_official 87:085cde657901 511 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 87:085cde657901 512
mbed_official 87:085cde657901 513 /* Start the digest calculation */
mbed_official 87:085cde657901 514 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 515
mbed_official 87:085cde657901 516 /* Get timeout */
mbed_official 87:085cde657901 517 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 518
mbed_official 87:085cde657901 519 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 520 {
mbed_official 87:085cde657901 521 /* Check for the Timeout */
mbed_official 87:085cde657901 522 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 523 {
mbed_official 87:085cde657901 524 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 525 {
mbed_official 87:085cde657901 526 /* Change state */
mbed_official 87:085cde657901 527 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 528
mbed_official 87:085cde657901 529 /* Process Unlocked */
mbed_official 87:085cde657901 530 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 531
mbed_official 87:085cde657901 532 return HAL_TIMEOUT;
mbed_official 87:085cde657901 533 }
mbed_official 87:085cde657901 534 }
mbed_official 87:085cde657901 535 }
mbed_official 87:085cde657901 536 /* Read the message digest */
mbed_official 87:085cde657901 537 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 87:085cde657901 538
mbed_official 87:085cde657901 539 /* Change the HASH state */
mbed_official 87:085cde657901 540 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 541
mbed_official 87:085cde657901 542 /* Process Unlocked */
mbed_official 87:085cde657901 543 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 544
mbed_official 87:085cde657901 545 /* Return function status */
mbed_official 87:085cde657901 546 return HAL_OK;
mbed_official 87:085cde657901 547 }
mbed_official 87:085cde657901 548
mbed_official 87:085cde657901 549 /**
mbed_official 87:085cde657901 550 * @brief Initializes the HASH peripheral in HMAC SHA256 mode
mbed_official 87:085cde657901 551 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 87:085cde657901 552 * @param hhash: HASH handle
mbed_official 87:085cde657901 553 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 554 * @param pOutBuffer: Pointer to the output buffer (hashed buffer).
mbed_official 87:085cde657901 555 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 556 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 557 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 87:085cde657901 558 * @retval HAL status
mbed_official 87:085cde657901 559 */
mbed_official 87:085cde657901 560 HAL_StatusTypeDef HAL_HMACEx_SHA256_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 561 {
mbed_official 87:085cde657901 562 uint32_t timeout = 0;
mbed_official 87:085cde657901 563
mbed_official 87:085cde657901 564 /* Process Locked */
mbed_official 87:085cde657901 565 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 566
mbed_official 87:085cde657901 567 /* Change the HASH state */
mbed_official 87:085cde657901 568 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 569
mbed_official 87:085cde657901 570 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 571 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 572 {
mbed_official 87:085cde657901 573 /* Check if key size is greater than 64 bytes */
mbed_official 87:085cde657901 574 if(hhash->Init.KeySize > 64)
mbed_official 87:085cde657901 575 {
mbed_official 87:085cde657901 576 /* Select the HMAC SHA256 mode */
mbed_official 87:085cde657901 577 HASH->CR |= (HASH_AlgoSelection_SHA256 | HASH_AlgoMode_HMAC | HASH_HMACKeyType_LongKey);
mbed_official 87:085cde657901 578 }
mbed_official 87:085cde657901 579 else
mbed_official 87:085cde657901 580 {
mbed_official 87:085cde657901 581 /* Select the HMAC SHA256 mode */
mbed_official 87:085cde657901 582 HASH->CR |= (HASH_AlgoSelection_SHA256 | HASH_AlgoMode_HMAC);
mbed_official 87:085cde657901 583 }
mbed_official 87:085cde657901 584 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 585 the message digest of a new message */
mbed_official 87:085cde657901 586 HASH->CR |= HASH_CR_INIT;
mbed_official 87:085cde657901 587 }
mbed_official 87:085cde657901 588
mbed_official 87:085cde657901 589 /* Set the phase */
mbed_official 87:085cde657901 590 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 591
mbed_official 87:085cde657901 592 /************************** STEP 1 ******************************************/
mbed_official 87:085cde657901 593 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 594 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 595
mbed_official 87:085cde657901 596 /* Write input buffer in data register */
mbed_official 87:085cde657901 597 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 87:085cde657901 598
mbed_official 87:085cde657901 599 /* Start the digest calculation */
mbed_official 87:085cde657901 600 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 601
mbed_official 87:085cde657901 602 /* Get timeout */
mbed_official 87:085cde657901 603 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 604
mbed_official 87:085cde657901 605 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 606 {
mbed_official 87:085cde657901 607 /* Check for the Timeout */
mbed_official 87:085cde657901 608 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 609 {
mbed_official 87:085cde657901 610 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 611 {
mbed_official 87:085cde657901 612 /* Change state */
mbed_official 87:085cde657901 613 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 614
mbed_official 87:085cde657901 615 /* Process Unlocked */
mbed_official 87:085cde657901 616 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 617
mbed_official 87:085cde657901 618 return HAL_TIMEOUT;
mbed_official 87:085cde657901 619 }
mbed_official 87:085cde657901 620 }
mbed_official 87:085cde657901 621 }
mbed_official 87:085cde657901 622 /************************** STEP 2 ******************************************/
mbed_official 87:085cde657901 623 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 624 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 625
mbed_official 87:085cde657901 626 /* Write input buffer in data register */
mbed_official 87:085cde657901 627 HASHEx_WriteData(pInBuffer, Size);
mbed_official 87:085cde657901 628
mbed_official 87:085cde657901 629 /* Start the digest calculation */
mbed_official 87:085cde657901 630 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 631
mbed_official 87:085cde657901 632 /* Get timeout */
mbed_official 87:085cde657901 633 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 634
mbed_official 87:085cde657901 635 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 636 {
mbed_official 87:085cde657901 637 /* Check for the Timeout */
mbed_official 87:085cde657901 638 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 639 {
mbed_official 87:085cde657901 640 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 641 {
mbed_official 87:085cde657901 642 /* Change state */
mbed_official 87:085cde657901 643 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 644
mbed_official 87:085cde657901 645 /* Process Unlocked */
mbed_official 87:085cde657901 646 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 647
mbed_official 87:085cde657901 648 return HAL_TIMEOUT;
mbed_official 87:085cde657901 649 }
mbed_official 87:085cde657901 650 }
mbed_official 87:085cde657901 651 }
mbed_official 87:085cde657901 652 /************************** STEP 3 ******************************************/
mbed_official 87:085cde657901 653 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 654 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 655
mbed_official 87:085cde657901 656 /* Write input buffer in data register */
mbed_official 87:085cde657901 657 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 87:085cde657901 658
mbed_official 87:085cde657901 659 /* Start the digest calculation */
mbed_official 87:085cde657901 660 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 661
mbed_official 87:085cde657901 662 /* Get timeout */
mbed_official 87:085cde657901 663 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 664
mbed_official 87:085cde657901 665 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 87:085cde657901 666 {
mbed_official 87:085cde657901 667 /* Check for the Timeout */
mbed_official 87:085cde657901 668 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 669 {
mbed_official 87:085cde657901 670 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 671 {
mbed_official 87:085cde657901 672 /* Change state */
mbed_official 87:085cde657901 673 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 674
mbed_official 87:085cde657901 675 /* Process Unlocked */
mbed_official 87:085cde657901 676 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 677
mbed_official 87:085cde657901 678 return HAL_TIMEOUT;
mbed_official 87:085cde657901 679 }
mbed_official 87:085cde657901 680 }
mbed_official 87:085cde657901 681 }
mbed_official 87:085cde657901 682 /* Read the message digest */
mbed_official 87:085cde657901 683 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 87:085cde657901 684
mbed_official 87:085cde657901 685 /* Change the HASH state */
mbed_official 87:085cde657901 686 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 687
mbed_official 87:085cde657901 688 /* Process Unlocked */
mbed_official 87:085cde657901 689 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 690
mbed_official 87:085cde657901 691 /* Return function status */
mbed_official 87:085cde657901 692 return HAL_OK;
mbed_official 87:085cde657901 693 }
mbed_official 87:085cde657901 694
mbed_official 87:085cde657901 695 /**
mbed_official 87:085cde657901 696 * @}
mbed_official 87:085cde657901 697 */
mbed_official 87:085cde657901 698
mbed_official 87:085cde657901 699 /** @defgroup HASHEx_Group3 HASH processing functions using interrupt mode
mbed_official 87:085cde657901 700 * @brief processing functions using interrupt mode.
mbed_official 87:085cde657901 701 *
mbed_official 87:085cde657901 702 @verbatim
mbed_official 87:085cde657901 703 ===============================================================================
mbed_official 87:085cde657901 704 ##### HASH processing using interrupt functions #####
mbed_official 87:085cde657901 705 ===============================================================================
mbed_official 87:085cde657901 706 [..] This section provides functions allowing to calculate in interrupt mode
mbed_official 87:085cde657901 707 the hash value using one of the following algorithms:
mbed_official 87:085cde657901 708 (+) SHA224
mbed_official 87:085cde657901 709 (+) SHA256
mbed_official 87:085cde657901 710
mbed_official 87:085cde657901 711 @endverbatim
mbed_official 87:085cde657901 712 * @{
mbed_official 87:085cde657901 713 */
mbed_official 87:085cde657901 714
mbed_official 87:085cde657901 715 /**
mbed_official 87:085cde657901 716 * @brief Initializes the HASH peripheral in SHA224 mode then processes pInBuffer.
mbed_official 87:085cde657901 717 * The digest is available in pOutBuffer.
mbed_official 87:085cde657901 718 * @param hhash: HASH handle
mbed_official 87:085cde657901 719 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 720 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 721 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 722 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 87:085cde657901 723 * @retval HAL status
mbed_official 87:085cde657901 724 */
mbed_official 87:085cde657901 725 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start_IT(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer)
mbed_official 87:085cde657901 726 {
mbed_official 87:085cde657901 727 uint32_t inputaddr;
mbed_official 87:085cde657901 728 uint32_t buffercounter;
mbed_official 87:085cde657901 729 uint32_t inputcounter;
mbed_official 87:085cde657901 730
mbed_official 87:085cde657901 731 /* Process Locked */
mbed_official 87:085cde657901 732 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 733
mbed_official 87:085cde657901 734 if(hhash->HashITCounter == 0)
mbed_official 87:085cde657901 735 {
mbed_official 87:085cde657901 736 hhash->HashITCounter = 1;
mbed_official 87:085cde657901 737 }
mbed_official 87:085cde657901 738 else
mbed_official 87:085cde657901 739 {
mbed_official 87:085cde657901 740 hhash->HashITCounter = 0;
mbed_official 87:085cde657901 741 }
mbed_official 87:085cde657901 742 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 87:085cde657901 743 {
mbed_official 87:085cde657901 744 /* Change the HASH state */
mbed_official 87:085cde657901 745 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 746
mbed_official 87:085cde657901 747 hhash->HashInCount = Size;
mbed_official 87:085cde657901 748 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 87:085cde657901 749 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 87:085cde657901 750
mbed_official 87:085cde657901 751 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 752 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 753 {
mbed_official 87:085cde657901 754 /* Select the SHA224 mode */
mbed_official 87:085cde657901 755 HASH->CR |= HASH_AlgoSelection_SHA224;
mbed_official 87:085cde657901 756 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 757 the message digest of a new message */
mbed_official 87:085cde657901 758 HASH->CR |= HASH_CR_INIT;
mbed_official 87:085cde657901 759 }
mbed_official 87:085cde657901 760
mbed_official 87:085cde657901 761 /* Set the phase */
mbed_official 87:085cde657901 762 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 763
mbed_official 87:085cde657901 764 /* Process Unlocked */
mbed_official 87:085cde657901 765 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 766
mbed_official 87:085cde657901 767 /* Enable Interrupts */
mbed_official 87:085cde657901 768 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 87:085cde657901 769
mbed_official 87:085cde657901 770 /* Return function status */
mbed_official 87:085cde657901 771 return HAL_OK;
mbed_official 87:085cde657901 772 }
mbed_official 87:085cde657901 773 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 87:085cde657901 774 {
mbed_official 87:085cde657901 775 /* Read the message digest */
mbed_official 87:085cde657901 776 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 28);
mbed_official 87:085cde657901 777 if(hhash->HashInCount == 0)
mbed_official 87:085cde657901 778 {
mbed_official 87:085cde657901 779 /* Disable Interrupts */
mbed_official 87:085cde657901 780 HASH->IMR = 0;
mbed_official 87:085cde657901 781 /* Change the HASH state */
mbed_official 87:085cde657901 782 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 783 /* Call digest computation complete callback */
mbed_official 87:085cde657901 784 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 87:085cde657901 785 }
mbed_official 87:085cde657901 786 }
mbed_official 87:085cde657901 787 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 87:085cde657901 788 {
mbed_official 87:085cde657901 789 if(hhash->HashInCount > 64)
mbed_official 87:085cde657901 790 {
mbed_official 87:085cde657901 791 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 87:085cde657901 792 /* Write the Input block in the Data IN register */
mbed_official 87:085cde657901 793 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 87:085cde657901 794 {
mbed_official 87:085cde657901 795 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 796 inputaddr+=4;
mbed_official 87:085cde657901 797 }
mbed_official 87:085cde657901 798 if(hhash->HashITCounter == 0)
mbed_official 87:085cde657901 799 {
mbed_official 87:085cde657901 800 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 801 if(hhash->HashInCount >= 68)
mbed_official 87:085cde657901 802 {
mbed_official 87:085cde657901 803 /* Decrement buffer counter */
mbed_official 87:085cde657901 804 hhash->HashInCount -= 68;
mbed_official 87:085cde657901 805 hhash->pHashInBuffPtr+= 68;
mbed_official 87:085cde657901 806 }
mbed_official 87:085cde657901 807 else
mbed_official 87:085cde657901 808 {
mbed_official 87:085cde657901 809 hhash->HashInCount -= 64;
mbed_official 87:085cde657901 810 }
mbed_official 87:085cde657901 811 }
mbed_official 87:085cde657901 812 else
mbed_official 87:085cde657901 813 {
mbed_official 87:085cde657901 814 /* Decrement buffer counter */
mbed_official 87:085cde657901 815 hhash->HashInCount -= 64;
mbed_official 87:085cde657901 816 hhash->pHashInBuffPtr+= 64;
mbed_official 87:085cde657901 817 }
mbed_official 87:085cde657901 818 }
mbed_official 87:085cde657901 819 else
mbed_official 87:085cde657901 820 {
mbed_official 87:085cde657901 821 /* Get the buffer address */
mbed_official 87:085cde657901 822 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 87:085cde657901 823 /* Get the buffer counter */
mbed_official 87:085cde657901 824 inputcounter = hhash->HashInCount;
mbed_official 87:085cde657901 825 /* Disable Interrupts */
mbed_official 87:085cde657901 826 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 87:085cde657901 827 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 828 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 87:085cde657901 829
mbed_official 87:085cde657901 830 if((inputcounter > 4) && (inputcounter%4))
mbed_official 87:085cde657901 831 {
mbed_official 87:085cde657901 832 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 87:085cde657901 833 }
mbed_official 87:085cde657901 834
mbed_official 87:085cde657901 835 /* Write the Input block in the Data IN register */
mbed_official 87:085cde657901 836 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 87:085cde657901 837 {
mbed_official 87:085cde657901 838 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 839 inputaddr+=4;
mbed_official 87:085cde657901 840 }
mbed_official 87:085cde657901 841 /* Start the digest calculation */
mbed_official 87:085cde657901 842 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 843 /* Reset buffer counter */
mbed_official 87:085cde657901 844 hhash->HashInCount = 0;
mbed_official 87:085cde657901 845 }
mbed_official 87:085cde657901 846 /* Call Input data transfer complete callback */
mbed_official 87:085cde657901 847 HAL_HASH_InCpltCallback(hhash);
mbed_official 87:085cde657901 848 }
mbed_official 87:085cde657901 849
mbed_official 87:085cde657901 850 /* Process Unlocked */
mbed_official 87:085cde657901 851 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 852
mbed_official 87:085cde657901 853 /* Return function status */
mbed_official 87:085cde657901 854 return HAL_OK;
mbed_official 87:085cde657901 855 }
mbed_official 87:085cde657901 856
mbed_official 87:085cde657901 857
mbed_official 87:085cde657901 858 /**
mbed_official 87:085cde657901 859 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 87:085cde657901 860 * The digest is available in pOutBuffer.
mbed_official 87:085cde657901 861 * @param hhash: HASH handle
mbed_official 87:085cde657901 862 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 863 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 864 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 865 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 87:085cde657901 866 * @retval HAL status
mbed_official 87:085cde657901 867 */
mbed_official 87:085cde657901 868 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_IT(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer)
mbed_official 87:085cde657901 869 {
mbed_official 87:085cde657901 870 uint32_t inputaddr;
mbed_official 87:085cde657901 871 uint32_t buffercounter;
mbed_official 87:085cde657901 872 uint32_t inputcounter;
mbed_official 87:085cde657901 873
mbed_official 87:085cde657901 874 /* Process Locked */
mbed_official 87:085cde657901 875 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 876
mbed_official 87:085cde657901 877 if(hhash->HashITCounter == 0)
mbed_official 87:085cde657901 878 {
mbed_official 87:085cde657901 879 hhash->HashITCounter = 1;
mbed_official 87:085cde657901 880 }
mbed_official 87:085cde657901 881 else
mbed_official 87:085cde657901 882 {
mbed_official 87:085cde657901 883 hhash->HashITCounter = 0;
mbed_official 87:085cde657901 884 }
mbed_official 87:085cde657901 885 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 87:085cde657901 886 {
mbed_official 87:085cde657901 887 /* Change the HASH state */
mbed_official 87:085cde657901 888 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 889
mbed_official 87:085cde657901 890 hhash->HashInCount = Size;
mbed_official 87:085cde657901 891 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 87:085cde657901 892 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 87:085cde657901 893
mbed_official 87:085cde657901 894 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 895 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 896 {
mbed_official 87:085cde657901 897 /* Select the SHA256 mode */
mbed_official 87:085cde657901 898 HASH->CR |= HASH_AlgoSelection_SHA256;
mbed_official 87:085cde657901 899 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 900 the message digest of a new message */
mbed_official 87:085cde657901 901 HASH->CR |= HASH_CR_INIT;
mbed_official 87:085cde657901 902 }
mbed_official 87:085cde657901 903
mbed_official 87:085cde657901 904 /* Set the phase */
mbed_official 87:085cde657901 905 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 906
mbed_official 87:085cde657901 907 /* Process Unlocked */
mbed_official 87:085cde657901 908 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 909
mbed_official 87:085cde657901 910 /* Enable Interrupts */
mbed_official 87:085cde657901 911 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 87:085cde657901 912
mbed_official 87:085cde657901 913 /* Return function status */
mbed_official 87:085cde657901 914 return HAL_OK;
mbed_official 87:085cde657901 915 }
mbed_official 87:085cde657901 916 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 87:085cde657901 917 {
mbed_official 87:085cde657901 918 /* Read the message digest */
mbed_official 87:085cde657901 919 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 32);
mbed_official 87:085cde657901 920 if(hhash->HashInCount == 0)
mbed_official 87:085cde657901 921 {
mbed_official 87:085cde657901 922 /* Disable Interrupts */
mbed_official 87:085cde657901 923 HASH->IMR = 0;
mbed_official 87:085cde657901 924 /* Change the HASH state */
mbed_official 87:085cde657901 925 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 926 /* Call digest computation complete callback */
mbed_official 87:085cde657901 927 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 87:085cde657901 928 }
mbed_official 87:085cde657901 929 }
mbed_official 87:085cde657901 930 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 87:085cde657901 931 {
mbed_official 87:085cde657901 932 if(hhash->HashInCount > 64)
mbed_official 87:085cde657901 933 {
mbed_official 87:085cde657901 934 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 87:085cde657901 935 /* Write the Input block in the Data IN register */
mbed_official 87:085cde657901 936 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 87:085cde657901 937 {
mbed_official 87:085cde657901 938 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 939 inputaddr+=4;
mbed_official 87:085cde657901 940 }
mbed_official 87:085cde657901 941 if(hhash->HashITCounter == 0)
mbed_official 87:085cde657901 942 {
mbed_official 87:085cde657901 943 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 944
mbed_official 87:085cde657901 945 if(hhash->HashInCount >= 68)
mbed_official 87:085cde657901 946 {
mbed_official 87:085cde657901 947 /* Decrement buffer counter */
mbed_official 87:085cde657901 948 hhash->HashInCount -= 68;
mbed_official 87:085cde657901 949 hhash->pHashInBuffPtr+= 68;
mbed_official 87:085cde657901 950 }
mbed_official 87:085cde657901 951 else
mbed_official 87:085cde657901 952 {
mbed_official 87:085cde657901 953 hhash->HashInCount -= 64;
mbed_official 87:085cde657901 954 }
mbed_official 87:085cde657901 955 }
mbed_official 87:085cde657901 956 else
mbed_official 87:085cde657901 957 {
mbed_official 87:085cde657901 958 /* Decrement buffer counter */
mbed_official 87:085cde657901 959 hhash->HashInCount -= 64;
mbed_official 87:085cde657901 960 hhash->pHashInBuffPtr+= 64;
mbed_official 87:085cde657901 961 }
mbed_official 87:085cde657901 962 }
mbed_official 87:085cde657901 963 else
mbed_official 87:085cde657901 964 {
mbed_official 87:085cde657901 965 /* Get the buffer address */
mbed_official 87:085cde657901 966 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 87:085cde657901 967 /* Get the buffer counter */
mbed_official 87:085cde657901 968 inputcounter = hhash->HashInCount;
mbed_official 87:085cde657901 969 /* Disable Interrupts */
mbed_official 87:085cde657901 970 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 87:085cde657901 971 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 972 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 87:085cde657901 973
mbed_official 87:085cde657901 974 if((inputcounter > 4) && (inputcounter%4))
mbed_official 87:085cde657901 975 {
mbed_official 87:085cde657901 976 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 87:085cde657901 977 }
mbed_official 87:085cde657901 978
mbed_official 87:085cde657901 979 /* Write the Input block in the Data IN register */
mbed_official 87:085cde657901 980 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 87:085cde657901 981 {
mbed_official 87:085cde657901 982 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 983 inputaddr+=4;
mbed_official 87:085cde657901 984 }
mbed_official 87:085cde657901 985 /* Start the digest calculation */
mbed_official 87:085cde657901 986 __HAL_HASH_START_DIGEST();
mbed_official 87:085cde657901 987 /* Reset buffer counter */
mbed_official 87:085cde657901 988 hhash->HashInCount = 0;
mbed_official 87:085cde657901 989 }
mbed_official 87:085cde657901 990 /* Call Input data transfer complete callback */
mbed_official 87:085cde657901 991 HAL_HASH_InCpltCallback(hhash);
mbed_official 87:085cde657901 992 }
mbed_official 87:085cde657901 993
mbed_official 87:085cde657901 994 /* Process Unlocked */
mbed_official 87:085cde657901 995 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 996
mbed_official 87:085cde657901 997 /* Return function status */
mbed_official 87:085cde657901 998 return HAL_OK;
mbed_official 87:085cde657901 999 }
mbed_official 87:085cde657901 1000
mbed_official 87:085cde657901 1001 /**
mbed_official 87:085cde657901 1002 * @brief This function handles HASH interrupt request.
mbed_official 87:085cde657901 1003 * @param hhash: hash handle
mbed_official 87:085cde657901 1004 * @retval None
mbed_official 87:085cde657901 1005 */
mbed_official 87:085cde657901 1006 void HAL_HASHEx_IRQHandler(HASH_HandleTypeDef *hhash)
mbed_official 87:085cde657901 1007 {
mbed_official 87:085cde657901 1008 switch(HASH->CR & HASH_CR_ALGO)
mbed_official 87:085cde657901 1009 {
mbed_official 87:085cde657901 1010
mbed_official 87:085cde657901 1011 case HASH_AlgoSelection_SHA224:
mbed_official 87:085cde657901 1012 HAL_HASHEx_SHA224_Start_IT(hhash, NULL, 0, NULL);
mbed_official 87:085cde657901 1013 break;
mbed_official 87:085cde657901 1014
mbed_official 87:085cde657901 1015 case HASH_AlgoSelection_SHA256:
mbed_official 87:085cde657901 1016 HAL_HASHEx_SHA256_Start_IT(hhash, NULL, 0, NULL);
mbed_official 87:085cde657901 1017 break;
mbed_official 87:085cde657901 1018
mbed_official 87:085cde657901 1019 default:
mbed_official 87:085cde657901 1020 break;
mbed_official 87:085cde657901 1021 }
mbed_official 87:085cde657901 1022 }
mbed_official 87:085cde657901 1023
mbed_official 87:085cde657901 1024 /**
mbed_official 87:085cde657901 1025 * @}
mbed_official 87:085cde657901 1026 */
mbed_official 87:085cde657901 1027
mbed_official 87:085cde657901 1028 /** @defgroup HASHEx_Group4 HASH processing functions using DMA mode
mbed_official 87:085cde657901 1029 * @brief processing functions using DMA mode.
mbed_official 87:085cde657901 1030 *
mbed_official 87:085cde657901 1031 @verbatim
mbed_official 87:085cde657901 1032 ===============================================================================
mbed_official 87:085cde657901 1033 ##### HASH processing using DMA functions #####
mbed_official 87:085cde657901 1034 ===============================================================================
mbed_official 87:085cde657901 1035 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 87:085cde657901 1036 the hash value using one of the following algorithms:
mbed_official 87:085cde657901 1037 (+) SHA224
mbed_official 87:085cde657901 1038 (+) SHA256
mbed_official 87:085cde657901 1039
mbed_official 87:085cde657901 1040 @endverbatim
mbed_official 87:085cde657901 1041 * @{
mbed_official 87:085cde657901 1042 */
mbed_official 87:085cde657901 1043
mbed_official 87:085cde657901 1044
mbed_official 87:085cde657901 1045 /**
mbed_official 87:085cde657901 1046 * @brief Initializes the HASH peripheral in SHA224 mode then enables DMA to
mbed_official 87:085cde657901 1047 control data transfer. Use HAL_HASH_SHA224_Finish() to get the digest.
mbed_official 87:085cde657901 1048 * @param hhash: HASH handle
mbed_official 87:085cde657901 1049 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 1050 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 1051 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 1052 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 87:085cde657901 1053 * @retval HAL status
mbed_official 87:085cde657901 1054 */
mbed_official 87:085cde657901 1055 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 1056 {
mbed_official 87:085cde657901 1057 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 87:085cde657901 1058
mbed_official 87:085cde657901 1059 /* Process Locked */
mbed_official 87:085cde657901 1060 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1061
mbed_official 87:085cde657901 1062 /* Change the HASH state */
mbed_official 87:085cde657901 1063 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1064
mbed_official 87:085cde657901 1065 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 1066 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 1067 {
mbed_official 87:085cde657901 1068 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 1069 the message digest of a new message */
mbed_official 87:085cde657901 1070 HASH->CR |= HASH_AlgoSelection_SHA224 | HASH_CR_INIT;
mbed_official 87:085cde657901 1071 }
mbed_official 87:085cde657901 1072
mbed_official 87:085cde657901 1073 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 1074 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 1075
mbed_official 87:085cde657901 1076 /* Set the phase */
mbed_official 87:085cde657901 1077 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 1078
mbed_official 87:085cde657901 1079 /* Set the HASH DMA transfer complete callback */
mbed_official 87:085cde657901 1080 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 87:085cde657901 1081 /* Set the DMA error callback */
mbed_official 87:085cde657901 1082 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 87:085cde657901 1083
mbed_official 87:085cde657901 1084 /* Enable the DMA In DMA Stream */
mbed_official 87:085cde657901 1085 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 87:085cde657901 1086
mbed_official 87:085cde657901 1087 /* Enable DMA requests */
mbed_official 87:085cde657901 1088 HASH->CR |= (HASH_CR_DMAE);
mbed_official 87:085cde657901 1089
mbed_official 87:085cde657901 1090 /* Process Unlocked */
mbed_official 87:085cde657901 1091 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1092
mbed_official 87:085cde657901 1093 /* Return function status */
mbed_official 87:085cde657901 1094 return HAL_OK;
mbed_official 87:085cde657901 1095 }
mbed_official 87:085cde657901 1096
mbed_official 87:085cde657901 1097 /**
mbed_official 87:085cde657901 1098 * @brief Returns the computed digest in SHA224
mbed_official 87:085cde657901 1099 * @param hhash: HASH handle
mbed_official 87:085cde657901 1100 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 87:085cde657901 1101 * @retval HAL status
mbed_official 87:085cde657901 1102 */
mbed_official 87:085cde657901 1103 HAL_StatusTypeDef HAL_HASHEx_SHA224_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 1104 {
mbed_official 87:085cde657901 1105 uint32_t timeout = 0;
mbed_official 87:085cde657901 1106
mbed_official 87:085cde657901 1107 /* Process Locked */
mbed_official 87:085cde657901 1108 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1109
mbed_official 87:085cde657901 1110 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1111 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1112
mbed_official 87:085cde657901 1113 /* Get timeout */
mbed_official 87:085cde657901 1114 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 1115
mbed_official 87:085cde657901 1116 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 87:085cde657901 1117 {
mbed_official 87:085cde657901 1118 /* Check for the Timeout */
mbed_official 87:085cde657901 1119 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 1120 {
mbed_official 87:085cde657901 1121 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 1122 {
mbed_official 87:085cde657901 1123 /* Change state */
mbed_official 87:085cde657901 1124 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 1125
mbed_official 87:085cde657901 1126 /* Process Unlocked */
mbed_official 87:085cde657901 1127 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1128
mbed_official 87:085cde657901 1129 return HAL_TIMEOUT;
mbed_official 87:085cde657901 1130 }
mbed_official 87:085cde657901 1131 }
mbed_official 87:085cde657901 1132 }
mbed_official 87:085cde657901 1133
mbed_official 87:085cde657901 1134 /* Read the message digest */
mbed_official 87:085cde657901 1135 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 87:085cde657901 1136
mbed_official 87:085cde657901 1137 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1138 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 1139
mbed_official 87:085cde657901 1140 /* Process Unlocked */
mbed_official 87:085cde657901 1141 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1142
mbed_official 87:085cde657901 1143 /* Return function status */
mbed_official 87:085cde657901 1144 return HAL_OK;
mbed_official 87:085cde657901 1145 }
mbed_official 87:085cde657901 1146
mbed_official 87:085cde657901 1147 /**
mbed_official 87:085cde657901 1148 * @brief Initializes the HASH peripheral in SHA256 mode then enables DMA to
mbed_official 87:085cde657901 1149 control data transfer. Use HAL_HASH_SHA256_Finish() to get the digest.
mbed_official 87:085cde657901 1150 * @param hhash: HASH handle
mbed_official 87:085cde657901 1151 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 1152 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 1153 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 1154 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 87:085cde657901 1155 * @retval HAL status
mbed_official 87:085cde657901 1156 */
mbed_official 87:085cde657901 1157 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 1158 {
mbed_official 87:085cde657901 1159 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 87:085cde657901 1160
mbed_official 87:085cde657901 1161 /* Process Locked */
mbed_official 87:085cde657901 1162 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1163
mbed_official 87:085cde657901 1164 /* Change the HASH state */
mbed_official 87:085cde657901 1165 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1166
mbed_official 87:085cde657901 1167 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 1168 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 1169 {
mbed_official 87:085cde657901 1170 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 1171 the message digest of a new message */
mbed_official 87:085cde657901 1172 HASH->CR |= HASH_AlgoSelection_SHA256 | HASH_CR_INIT;
mbed_official 87:085cde657901 1173 }
mbed_official 87:085cde657901 1174
mbed_official 87:085cde657901 1175 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 1176 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 87:085cde657901 1177
mbed_official 87:085cde657901 1178 /* Set the phase */
mbed_official 87:085cde657901 1179 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 1180
mbed_official 87:085cde657901 1181 /* Set the HASH DMA transfer complete callback */
mbed_official 87:085cde657901 1182 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 87:085cde657901 1183 /* Set the DMA error callback */
mbed_official 87:085cde657901 1184 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 87:085cde657901 1185
mbed_official 87:085cde657901 1186 /* Enable the DMA In DMA Stream */
mbed_official 87:085cde657901 1187 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 87:085cde657901 1188
mbed_official 87:085cde657901 1189 /* Enable DMA requests */
mbed_official 87:085cde657901 1190 HASH->CR |= (HASH_CR_DMAE);
mbed_official 87:085cde657901 1191
mbed_official 87:085cde657901 1192 /* Process UnLock */
mbed_official 87:085cde657901 1193 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1194
mbed_official 87:085cde657901 1195 /* Return function status */
mbed_official 87:085cde657901 1196 return HAL_OK;
mbed_official 87:085cde657901 1197 }
mbed_official 87:085cde657901 1198
mbed_official 87:085cde657901 1199 /**
mbed_official 87:085cde657901 1200 * @brief Returns the computed digest in SHA256.
mbed_official 87:085cde657901 1201 * @param hhash: HASH handle
mbed_official 87:085cde657901 1202 * @param pOutBuffer: Pointer to the computed digest. Its size must be 32 bytes.
mbed_official 87:085cde657901 1203 * @retval HAL status
mbed_official 87:085cde657901 1204 */
mbed_official 87:085cde657901 1205 HAL_StatusTypeDef HAL_HASHEx_SHA256_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 87:085cde657901 1206 {
mbed_official 87:085cde657901 1207 uint32_t timeout = 0;
mbed_official 87:085cde657901 1208
mbed_official 87:085cde657901 1209 /* Process Locked */
mbed_official 87:085cde657901 1210 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1211
mbed_official 87:085cde657901 1212 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1213 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1214
mbed_official 87:085cde657901 1215 /* Get timeout */
mbed_official 87:085cde657901 1216 timeout = HAL_GetTick() + Timeout;
mbed_official 87:085cde657901 1217
mbed_official 87:085cde657901 1218 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 87:085cde657901 1219 {
mbed_official 87:085cde657901 1220 /* Check for the Timeout */
mbed_official 87:085cde657901 1221 if(Timeout != HAL_MAX_DELAY)
mbed_official 87:085cde657901 1222 {
mbed_official 87:085cde657901 1223 if(HAL_GetTick() >= timeout)
mbed_official 87:085cde657901 1224 {
mbed_official 87:085cde657901 1225 /* Change state */
mbed_official 87:085cde657901 1226 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 87:085cde657901 1227
mbed_official 87:085cde657901 1228 /* Process Unlocked */
mbed_official 87:085cde657901 1229 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1230
mbed_official 87:085cde657901 1231 return HAL_TIMEOUT;
mbed_official 87:085cde657901 1232 }
mbed_official 87:085cde657901 1233 }
mbed_official 87:085cde657901 1234 }
mbed_official 87:085cde657901 1235
mbed_official 87:085cde657901 1236 /* Read the message digest */
mbed_official 87:085cde657901 1237 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 87:085cde657901 1238
mbed_official 87:085cde657901 1239 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1240 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 1241
mbed_official 87:085cde657901 1242 /* Process Unlocked */
mbed_official 87:085cde657901 1243 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1244
mbed_official 87:085cde657901 1245 /* Return function status */
mbed_official 87:085cde657901 1246 return HAL_OK;
mbed_official 87:085cde657901 1247 }
mbed_official 87:085cde657901 1248
mbed_official 87:085cde657901 1249
mbed_official 87:085cde657901 1250 /**
mbed_official 87:085cde657901 1251 * @}
mbed_official 87:085cde657901 1252 */
mbed_official 87:085cde657901 1253 /** @defgroup HASHEx_Group5 HMAC processing functions using DMA mode
mbed_official 87:085cde657901 1254 * @brief HMAC processing functions using DMA mode .
mbed_official 87:085cde657901 1255 *
mbed_official 87:085cde657901 1256 @verbatim
mbed_official 87:085cde657901 1257 ===============================================================================
mbed_official 87:085cde657901 1258 ##### HMAC processing using DMA functions #####
mbed_official 87:085cde657901 1259 ===============================================================================
mbed_official 87:085cde657901 1260 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 87:085cde657901 1261 the HMAC value using one of the following algorithms:
mbed_official 87:085cde657901 1262 (+) SHA224
mbed_official 87:085cde657901 1263 (+) SHA256
mbed_official 87:085cde657901 1264
mbed_official 87:085cde657901 1265 @endverbatim
mbed_official 87:085cde657901 1266 * @{
mbed_official 87:085cde657901 1267 */
mbed_official 87:085cde657901 1268
mbed_official 87:085cde657901 1269 /**
mbed_official 87:085cde657901 1270 * @brief Initializes the HASH peripheral in HMAC SHA224 mode
mbed_official 87:085cde657901 1271 * then enables DMA to control data transfer.
mbed_official 87:085cde657901 1272 * @param hhash: HASH handle
mbed_official 87:085cde657901 1273 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 1274 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 1275 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 1276 * @retval HAL status
mbed_official 87:085cde657901 1277 */
mbed_official 87:085cde657901 1278 HAL_StatusTypeDef HAL_HMACEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 1279 {
mbed_official 87:085cde657901 1280 uint32_t inputaddr;
mbed_official 87:085cde657901 1281
mbed_official 87:085cde657901 1282 /* Process Locked */
mbed_official 87:085cde657901 1283 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1284
mbed_official 87:085cde657901 1285 /* Change the HASH state */
mbed_official 87:085cde657901 1286 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1287
mbed_official 87:085cde657901 1288 /* Save buffer pointer and size in handle */
mbed_official 87:085cde657901 1289 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 87:085cde657901 1290 hhash->HashBuffSize = Size;
mbed_official 87:085cde657901 1291 hhash->HashInCount = 0;
mbed_official 87:085cde657901 1292
mbed_official 87:085cde657901 1293 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 1294 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 1295 {
mbed_official 87:085cde657901 1296 /* Check if key size is greater than 64 bytes */
mbed_official 87:085cde657901 1297 if(hhash->Init.KeySize > 64)
mbed_official 87:085cde657901 1298 {
mbed_official 87:085cde657901 1299 /* Select the HMAC SHA224 mode */
mbed_official 87:085cde657901 1300 HASH->CR |= (HASH_AlgoSelection_SHA224 | HASH_AlgoMode_HMAC | HASH_HMACKeyType_LongKey | HASH_CR_INIT);
mbed_official 87:085cde657901 1301 }
mbed_official 87:085cde657901 1302 else
mbed_official 87:085cde657901 1303 {
mbed_official 87:085cde657901 1304 /* Select the HMAC SHA224 mode */
mbed_official 87:085cde657901 1305 HASH->CR |= (HASH_AlgoSelection_SHA224 | HASH_AlgoMode_HMAC | HASH_CR_INIT);
mbed_official 87:085cde657901 1306 }
mbed_official 87:085cde657901 1307 }
mbed_official 87:085cde657901 1308
mbed_official 87:085cde657901 1309 /* Set the phase */
mbed_official 87:085cde657901 1310 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 1311
mbed_official 87:085cde657901 1312 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 1313 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 1314
mbed_official 87:085cde657901 1315 /* Get the key address */
mbed_official 87:085cde657901 1316 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 87:085cde657901 1317
mbed_official 87:085cde657901 1318 /* Set the HASH DMA transfer complete callback */
mbed_official 87:085cde657901 1319 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 87:085cde657901 1320 /* Set the DMA error callback */
mbed_official 87:085cde657901 1321 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 87:085cde657901 1322
mbed_official 87:085cde657901 1323 /* Enable the DMA In DMA Stream */
mbed_official 87:085cde657901 1324 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (hhash->Init.KeySize%4 ? (hhash->Init.KeySize+3)/4:hhash->Init.KeySize/4));
mbed_official 87:085cde657901 1325 /* Enable DMA requests */
mbed_official 87:085cde657901 1326 HASH->CR |= (HASH_CR_DMAE);
mbed_official 87:085cde657901 1327
mbed_official 87:085cde657901 1328 /* Process Unlocked */
mbed_official 87:085cde657901 1329 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1330
mbed_official 87:085cde657901 1331 /* Return function status */
mbed_official 87:085cde657901 1332 return HAL_OK;
mbed_official 87:085cde657901 1333 }
mbed_official 87:085cde657901 1334
mbed_official 87:085cde657901 1335 /**
mbed_official 87:085cde657901 1336 * @brief Initializes the HASH peripheral in HMAC SHA256 mode
mbed_official 87:085cde657901 1337 * then enables DMA to control data transfer.
mbed_official 87:085cde657901 1338 * @param hhash: HASH handle
mbed_official 87:085cde657901 1339 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 87:085cde657901 1340 * @param Size: Length of the input buffer in bytes.
mbed_official 87:085cde657901 1341 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 87:085cde657901 1342 * @retval HAL status
mbed_official 87:085cde657901 1343 */
mbed_official 87:085cde657901 1344 HAL_StatusTypeDef HAL_HMACEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 1345 {
mbed_official 87:085cde657901 1346 uint32_t inputaddr;
mbed_official 87:085cde657901 1347
mbed_official 87:085cde657901 1348 /* Process Locked */
mbed_official 87:085cde657901 1349 __HAL_LOCK(hhash);
mbed_official 87:085cde657901 1350
mbed_official 87:085cde657901 1351 /* Change the HASH state */
mbed_official 87:085cde657901 1352 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 87:085cde657901 1353
mbed_official 87:085cde657901 1354 /* Save buffer pointer and size in handle */
mbed_official 87:085cde657901 1355 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 87:085cde657901 1356 hhash->HashBuffSize = Size;
mbed_official 87:085cde657901 1357 hhash->HashInCount = 0;
mbed_official 87:085cde657901 1358
mbed_official 87:085cde657901 1359 /* Check if initialization phase has already been performed */
mbed_official 87:085cde657901 1360 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 87:085cde657901 1361 {
mbed_official 87:085cde657901 1362 /* Check if key size is greater than 64 bytes */
mbed_official 87:085cde657901 1363 if(hhash->Init.KeySize > 64)
mbed_official 87:085cde657901 1364 {
mbed_official 87:085cde657901 1365 /* Select the HMAC SHA256 mode */
mbed_official 87:085cde657901 1366 HASH->CR |= (HASH_AlgoSelection_SHA256 | HASH_AlgoMode_HMAC | HASH_HMACKeyType_LongKey);
mbed_official 87:085cde657901 1367 }
mbed_official 87:085cde657901 1368 else
mbed_official 87:085cde657901 1369 {
mbed_official 87:085cde657901 1370 /* Select the HMAC SHA256 mode */
mbed_official 87:085cde657901 1371 HASH->CR |= (HASH_AlgoSelection_SHA256 | HASH_AlgoMode_HMAC);
mbed_official 87:085cde657901 1372 }
mbed_official 87:085cde657901 1373 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 87:085cde657901 1374 the message digest of a new message */
mbed_official 87:085cde657901 1375 HASH->CR |= HASH_CR_INIT;
mbed_official 87:085cde657901 1376 }
mbed_official 87:085cde657901 1377
mbed_official 87:085cde657901 1378 /* Set the phase */
mbed_official 87:085cde657901 1379 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 87:085cde657901 1380
mbed_official 87:085cde657901 1381 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 1382 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 87:085cde657901 1383
mbed_official 87:085cde657901 1384 /* Get the key address */
mbed_official 87:085cde657901 1385 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 87:085cde657901 1386
mbed_official 87:085cde657901 1387 /* Set the HASH DMA transfer complete callback */
mbed_official 87:085cde657901 1388 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 87:085cde657901 1389 /* Set the DMA error callback */
mbed_official 87:085cde657901 1390 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 87:085cde657901 1391
mbed_official 87:085cde657901 1392 /* Enable the DMA In DMA Stream */
mbed_official 87:085cde657901 1393 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (hhash->Init.KeySize%4 ? (hhash->Init.KeySize+3)/4:hhash->Init.KeySize/4));
mbed_official 87:085cde657901 1394 /* Enable DMA requests */
mbed_official 87:085cde657901 1395 HASH->CR |= (HASH_CR_DMAE);
mbed_official 87:085cde657901 1396
mbed_official 87:085cde657901 1397 /* Process Unlocked */
mbed_official 87:085cde657901 1398 __HAL_UNLOCK(hhash);
mbed_official 87:085cde657901 1399
mbed_official 87:085cde657901 1400 /* Return function status */
mbed_official 87:085cde657901 1401 return HAL_OK;
mbed_official 87:085cde657901 1402 }
mbed_official 87:085cde657901 1403
mbed_official 87:085cde657901 1404 /**
mbed_official 87:085cde657901 1405 * @}
mbed_official 87:085cde657901 1406 */
mbed_official 87:085cde657901 1407
mbed_official 87:085cde657901 1408 /**
mbed_official 87:085cde657901 1409 * @brief Writes the input buffer in data register.
mbed_official 87:085cde657901 1410 * @param pInBuffer: Pointer to input buffer
mbed_official 87:085cde657901 1411 * @param Size: The size of input buffer
mbed_official 87:085cde657901 1412 * @retval None
mbed_official 87:085cde657901 1413 */
mbed_official 87:085cde657901 1414 static void HASHEx_WriteData(uint8_t *pInBuffer, uint32_t Size)
mbed_official 87:085cde657901 1415 {
mbed_official 87:085cde657901 1416 uint32_t buffercounter;
mbed_official 87:085cde657901 1417 uint32_t inputaddr = (uint32_t) pInBuffer;
mbed_official 87:085cde657901 1418
mbed_official 87:085cde657901 1419 for(buffercounter = 0; buffercounter < Size; buffercounter+=4)
mbed_official 87:085cde657901 1420 {
mbed_official 87:085cde657901 1421 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 87:085cde657901 1422 inputaddr+=4;
mbed_official 87:085cde657901 1423 }
mbed_official 87:085cde657901 1424 }
mbed_official 87:085cde657901 1425
mbed_official 87:085cde657901 1426 /**
mbed_official 87:085cde657901 1427 * @brief Provides the message digest result.
mbed_official 87:085cde657901 1428 * @param pMsgDigest: Pointer to the message digest
mbed_official 87:085cde657901 1429 * @param Size: The size of the message digest in bytes
mbed_official 87:085cde657901 1430 * @retval None
mbed_official 87:085cde657901 1431 */
mbed_official 87:085cde657901 1432 static void HASHEx_GetDigest(uint8_t *pMsgDigest, uint8_t Size)
mbed_official 87:085cde657901 1433 {
mbed_official 87:085cde657901 1434 uint32_t msgdigest = (uint32_t)pMsgDigest;
mbed_official 87:085cde657901 1435
mbed_official 87:085cde657901 1436 switch(Size)
mbed_official 87:085cde657901 1437 {
mbed_official 87:085cde657901 1438 case 16:
mbed_official 87:085cde657901 1439 /* Read the message digest */
mbed_official 87:085cde657901 1440 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 87:085cde657901 1441 msgdigest+=4;
mbed_official 87:085cde657901 1442 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 87:085cde657901 1443 msgdigest+=4;
mbed_official 87:085cde657901 1444 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 87:085cde657901 1445 msgdigest+=4;
mbed_official 87:085cde657901 1446 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 87:085cde657901 1447 break;
mbed_official 87:085cde657901 1448 case 20:
mbed_official 87:085cde657901 1449 /* Read the message digest */
mbed_official 87:085cde657901 1450 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 87:085cde657901 1451 msgdigest+=4;
mbed_official 87:085cde657901 1452 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 87:085cde657901 1453 msgdigest+=4;
mbed_official 87:085cde657901 1454 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 87:085cde657901 1455 msgdigest+=4;
mbed_official 87:085cde657901 1456 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 87:085cde657901 1457 msgdigest+=4;
mbed_official 87:085cde657901 1458 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 87:085cde657901 1459 break;
mbed_official 87:085cde657901 1460 case 28:
mbed_official 87:085cde657901 1461 /* Read the message digest */
mbed_official 87:085cde657901 1462 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 87:085cde657901 1463 msgdigest+=4;
mbed_official 87:085cde657901 1464 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 87:085cde657901 1465 msgdigest+=4;
mbed_official 87:085cde657901 1466 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 87:085cde657901 1467 msgdigest+=4;
mbed_official 87:085cde657901 1468 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 87:085cde657901 1469 msgdigest+=4;
mbed_official 87:085cde657901 1470 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 87:085cde657901 1471 msgdigest+=4;
mbed_official 87:085cde657901 1472 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[5]);
mbed_official 87:085cde657901 1473 msgdigest+=4;
mbed_official 87:085cde657901 1474 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[6]);
mbed_official 87:085cde657901 1475 break;
mbed_official 87:085cde657901 1476 case 32:
mbed_official 87:085cde657901 1477 /* Read the message digest */
mbed_official 87:085cde657901 1478 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 87:085cde657901 1479 msgdigest+=4;
mbed_official 87:085cde657901 1480 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 87:085cde657901 1481 msgdigest+=4;
mbed_official 87:085cde657901 1482 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 87:085cde657901 1483 msgdigest+=4;
mbed_official 87:085cde657901 1484 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 87:085cde657901 1485 msgdigest+=4;
mbed_official 87:085cde657901 1486 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 87:085cde657901 1487 msgdigest+=4;
mbed_official 87:085cde657901 1488 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[5]);
mbed_official 87:085cde657901 1489 msgdigest+=4;
mbed_official 87:085cde657901 1490 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[6]);
mbed_official 87:085cde657901 1491 msgdigest+=4;
mbed_official 87:085cde657901 1492 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[7]);
mbed_official 87:085cde657901 1493 break;
mbed_official 87:085cde657901 1494 default:
mbed_official 87:085cde657901 1495 break;
mbed_official 87:085cde657901 1496 }
mbed_official 87:085cde657901 1497 }
mbed_official 87:085cde657901 1498
mbed_official 87:085cde657901 1499 /**
mbed_official 87:085cde657901 1500 * @brief DMA HASH Input Data complete callback.
mbed_official 87:085cde657901 1501 * @param hdma: DMA handle
mbed_official 87:085cde657901 1502 * @retval None
mbed_official 87:085cde657901 1503 */
mbed_official 87:085cde657901 1504 static void HASHEx_DMAXferCplt(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1505 {
mbed_official 87:085cde657901 1506 HASH_HandleTypeDef* hhash = ( HASH_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 87:085cde657901 1507 uint32_t inputaddr = 0;
mbed_official 87:085cde657901 1508 uint32_t buffersize = 0;
mbed_official 87:085cde657901 1509
mbed_official 87:085cde657901 1510 if((HASH->CR & HASH_CR_MODE) != HASH_CR_MODE)
mbed_official 87:085cde657901 1511 {
mbed_official 87:085cde657901 1512 /* Disable the DMA transfer */
mbed_official 87:085cde657901 1513 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 87:085cde657901 1514
mbed_official 87:085cde657901 1515 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1516 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 1517
mbed_official 87:085cde657901 1518 /* Call Input data transfer complete callback */
mbed_official 87:085cde657901 1519 HAL_HASH_InCpltCallback(hhash);
mbed_official 87:085cde657901 1520 }
mbed_official 87:085cde657901 1521 else
mbed_official 87:085cde657901 1522 {
mbed_official 87:085cde657901 1523 /* Increment Interrupt counter */
mbed_official 87:085cde657901 1524 hhash->HashInCount++;
mbed_official 87:085cde657901 1525 /* Disable the DMA transfer before starting the next transfer */
mbed_official 87:085cde657901 1526 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 87:085cde657901 1527
mbed_official 87:085cde657901 1528 if(hhash->HashInCount <= 2)
mbed_official 87:085cde657901 1529 {
mbed_official 87:085cde657901 1530 /* In case HashInCount = 1, set the DMA to transfer data to HASH DIN register */
mbed_official 87:085cde657901 1531 if(hhash->HashInCount == 1)
mbed_official 87:085cde657901 1532 {
mbed_official 87:085cde657901 1533 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 87:085cde657901 1534 buffersize = hhash->HashBuffSize;
mbed_official 87:085cde657901 1535 }
mbed_official 87:085cde657901 1536 /* In case HashInCount = 2, set the DMA to transfer key to HASH DIN register */
mbed_official 87:085cde657901 1537 else if(hhash->HashInCount == 2)
mbed_official 87:085cde657901 1538 {
mbed_official 87:085cde657901 1539 inputaddr = (uint32_t)hhash->Init.pKey;
mbed_official 87:085cde657901 1540 buffersize = hhash->Init.KeySize;
mbed_official 87:085cde657901 1541 }
mbed_official 87:085cde657901 1542 /* Configure the number of valid bits in last word of the message */
mbed_official 87:085cde657901 1543 HASH->STR |= 8 * (buffersize % 4);
mbed_official 87:085cde657901 1544
mbed_official 87:085cde657901 1545 /* Set the HASH DMA transfer complete */
mbed_official 87:085cde657901 1546 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 87:085cde657901 1547
mbed_official 87:085cde657901 1548 /* Enable the DMA In DMA Stream */
mbed_official 87:085cde657901 1549 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (buffersize%4 ? (buffersize+3)/4:buffersize/4));
mbed_official 87:085cde657901 1550
mbed_official 87:085cde657901 1551 /* Enable DMA requests */
mbed_official 87:085cde657901 1552 HASH->CR |= (HASH_CR_DMAE);
mbed_official 87:085cde657901 1553 }
mbed_official 87:085cde657901 1554 else
mbed_official 87:085cde657901 1555 {
mbed_official 87:085cde657901 1556 /* Disable the DMA transfer */
mbed_official 87:085cde657901 1557 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 87:085cde657901 1558
mbed_official 87:085cde657901 1559 /* Reset the InCount */
mbed_official 87:085cde657901 1560 hhash->HashInCount = 0;
mbed_official 87:085cde657901 1561
mbed_official 87:085cde657901 1562 /* Change HASH peripheral state */
mbed_official 87:085cde657901 1563 hhash->State = HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 1564
mbed_official 87:085cde657901 1565 /* Call Input data transfer complete callback */
mbed_official 87:085cde657901 1566 HAL_HASH_InCpltCallback(hhash);
mbed_official 87:085cde657901 1567 }
mbed_official 87:085cde657901 1568 }
mbed_official 87:085cde657901 1569 }
mbed_official 87:085cde657901 1570
mbed_official 87:085cde657901 1571 /**
mbed_official 87:085cde657901 1572 * @brief DMA HASH communication error callback.
mbed_official 87:085cde657901 1573 * @param hdma: DMA handle
mbed_official 87:085cde657901 1574 * @retval None
mbed_official 87:085cde657901 1575 */
mbed_official 87:085cde657901 1576 static void HASHEx_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1577 {
mbed_official 87:085cde657901 1578 HASH_HandleTypeDef* hhash = ( HASH_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 87:085cde657901 1579 hhash->State= HAL_HASH_STATE_READY;
mbed_official 87:085cde657901 1580 HAL_HASH_ErrorCallback(hhash);
mbed_official 87:085cde657901 1581 }
mbed_official 87:085cde657901 1582
mbed_official 87:085cde657901 1583
mbed_official 87:085cde657901 1584 /**
mbed_official 87:085cde657901 1585 * @}
mbed_official 87:085cde657901 1586 */
mbed_official 87:085cde657901 1587 #endif /* STM32F437xx || STM32F439xx */
mbed_official 87:085cde657901 1588
mbed_official 87:085cde657901 1589 #endif /* HAL_HASH_MODULE_ENABLED */
mbed_official 87:085cde657901 1590 /**
mbed_official 87:085cde657901 1591 * @}
mbed_official 87:085cde657901 1592 */
mbed_official 87:085cde657901 1593
mbed_official 87:085cde657901 1594 /**
mbed_official 87:085cde657901 1595 * @}
mbed_official 87:085cde657901 1596 */
mbed_official 87:085cde657901 1597
mbed_official 87:085cde657901 1598 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/