/** ****************************************************************************** * @file stm32l4xx_hal_pka.c * @author MCD Application Team * @brief PKA HAL module driver. * This file provides firmware functions to manage the following * functionalities of public key accelerator(PKA): * + Initialization and de-initialization functions * + Start an operation * + Retrieve the operation result * ****************************************************************************** * @attention * * Copyright (c) 2017 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ****************************************************************************** @verbatim ============================================================================== ##### How to use this driver ##### ============================================================================== [..] The PKA HAL driver can be used as follows: (#) Declare a PKA_HandleTypeDef handle structure, for example: PKA_HandleTypeDef hpka; (#) Initialize the PKA low level resources by implementing the HAL_PKA_MspInit() API: (##) Enable the PKA interface clock (##) NVIC configuration if you need to use interrupt process (+++) Configure the PKA interrupt priority (+++) Enable the NVIC PKA IRQ Channel (#) Initialize the PKA registers by calling the HAL_PKA_Init() API which trig HAL_PKA_MspInit(). (#) Fill entirely the input structure corresponding to your operation: For instance: PKA_ModExpInTypeDef for HAL_PKA_ModExp(). (#) Execute the operation (in polling or interrupt) and check the returned value. (#) Retrieve the result of the operation (For instance, HAL_PKA_ModExp_GetResult for HAL_PKA_ModExp operation). The function to gather the result is different for each kind of operation. The correspondence can be found in the following section. (#) Call the function HAL_PKA_DeInit() to restore the default configuration which trig HAL_PKA_MspDeInit(). *** High level operation *** ================================= [..] (+) Input structure requires buffers as uint8_t array. (+) Output structure requires buffers as uint8_t array. (+) Modular exponentiation using: (++) HAL_PKA_ModExp(). (++) HAL_PKA_ModExp_IT(). (++) HAL_PKA_ModExpFastMode(). (++) HAL_PKA_ModExpFastMode_IT(). (++) HAL_PKA_ModExp_GetResult() to retrieve the result of the operation. (+) RSA Chinese Remainder Theorem (CRT) using: (++) HAL_PKA_RSACRTExp(). (++) HAL_PKA_RSACRTExp_IT(). (++) HAL_PKA_RSACRTExp_GetResult() to retrieve the result of the operation. (+) ECC Point Check using: (++) HAL_PKA_PointCheck(). (++) HAL_PKA_PointCheck_IT(). (++) HAL_PKA_PointCheck_IsOnCurve() to retrieve the result of the operation. (+) ECDSA Sign (++) HAL_PKA_ECDSASign(). (++) HAL_PKA_ECDSASign_IT(). (++) HAL_PKA_ECDSASign_GetResult() to retrieve the result of the operation. (+) ECDSA Verify (++) HAL_PKA_ECDSAVerif(). (++) HAL_PKA_ECDSAVerif_IT(). (++) HAL_PKA_ECDSAVerif_IsValidSignature() to retrieve the result of the operation. (+) ECC Scalar Multiplication using: (++) HAL_PKA_ECCMul(). (++) HAL_PKA_ECCMul_IT(). (++) HAL_PKA_ECCMulFastMode(). (++) HAL_PKA_ECCMulFastMode_IT(). (++) HAL_PKA_ECCMul_GetResult() to retrieve the result of the operation. *** Low level operation *** ================================= [..] (+) Input structure requires buffers as uint32_t array. (+) Output structure requires buffers as uint32_t array. (+) Arithmetic addition using: (++) HAL_PKA_Add(). (++) HAL_PKA_Add_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. The resulting size can be the input parameter or the input parameter size + 1 (overflow). (+) Arithmetic subtraction using: (++) HAL_PKA_Sub(). (++) HAL_PKA_Sub_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Arithmetic multiplication using: (++) HAL_PKA_Mul(). (++) HAL_PKA_Mul_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Comparison using: (++) HAL_PKA_Cmp(). (++) HAL_PKA_Cmp_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Modular addition using: (++) HAL_PKA_ModAdd(). (++) HAL_PKA_ModAdd_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Modular subtraction using: (++) HAL_PKA_ModSub(). (++) HAL_PKA_ModSub_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Modular inversion using: (++) HAL_PKA_ModInv(). (++) HAL_PKA_ModInv_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Modular reduction using: (++) HAL_PKA_ModRed(). (++) HAL_PKA_ModRed_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. (+) Montgomery multiplication using: (++) HAL_PKA_MontgomeryMul(). (++) HAL_PKA_MontgomeryMul_IT(). (++) HAL_PKA_Arithmetic_GetResult() to retrieve the result of the operation. *** Montgomery parameter *** ================================= (+) For some operation, the computation of the Montgomery parameter is a prerequisite. (+) Input structure requires buffers as uint8_t array. (+) Output structure requires buffers as uint32_t array.(Only used inside PKA). (+) You can compute the Montgomery parameter using: (++) HAL_PKA_MontgomeryParam(). (++) HAL_PKA_MontgomeryParam_IT(). (++) HAL_PKA_MontgomeryParam_GetResult() to retrieve the result of the operation. *** Polling mode operation *** =================================== [..] (+) When an operation is started in polling mode, the function returns when: (++) A timeout is encounter. (++) The operation is completed. *** Interrupt mode operation *** =================================== [..] (+) Add HAL_PKA_IRQHandler to the IRQHandler of PKA. (+) Enable the IRQ using HAL_NVIC_EnableIRQ(). (+) When an operation is started in interrupt mode, the function returns immediately. (+) When the operation is completed, the callback HAL_PKA_OperationCpltCallback is called. (+) When an error is encountered, the callback HAL_PKA_ErrorCallback is called. (+) To stop any operation in interrupt mode, use HAL_PKA_Abort(). *** Utilities *** =================================== [..] (+) To clear the PKA RAM, use HAL_PKA_RAMReset(). (+) To get current state, use HAL_PKA_GetState(). (+) To get current error, use HAL_PKA_GetError(). *** Callback registration *** ============================================= [..] The compilation flag USE_HAL_PKA_REGISTER_CALLBACKS, when set to 1, allows the user to configure dynamically the driver callbacks. Use Functions HAL_PKA_RegisterCallback() to register an interrupt callback. [..] Function HAL_PKA_RegisterCallback() allows to register following callbacks: (+) OperationCpltCallback : callback for End of operation. (+) ErrorCallback : callback for error detection. (+) MspInitCallback : callback for Msp Init. (+) MspDeInitCallback : callback for Msp DeInit. This function takes as parameters the HAL peripheral handle, the Callback ID and a pointer to the user callback function. [..] Use function HAL_PKA_UnRegisterCallback to reset a callback to the default weak function. [..] HAL_PKA_UnRegisterCallback takes as parameters the HAL peripheral handle, and the Callback ID. This function allows to reset following callbacks: (+) OperationCpltCallback : callback for End of operation. (+) ErrorCallback : callback for error detection. (+) MspInitCallback : callback for Msp Init. (+) MspDeInitCallback : callback for Msp DeInit. [..] By default, after the HAL_PKA_Init() and when the state is HAL_PKA_STATE_RESET all callbacks are set to the corresponding weak functions: examples HAL_PKA_OperationCpltCallback(), HAL_PKA_ErrorCallback(). Exception done for MspInit and MspDeInit functions that are reset to the legacy weak functions in the HAL_PKA_Init()/ HAL_PKA_DeInit() only when these callbacks are null (not registered beforehand). [..] If MspInit or MspDeInit are not null, the HAL_PKA_Init()/ HAL_PKA_DeInit() keep and use the user MspInit/MspDeInit callbacks (registered beforehand) whatever the state. [..] Callbacks can be registered/unregistered in HAL_PKA_STATE_READY state only. Exception done MspInit/MspDeInit functions that can be registered/unregistered in HAL_PKA_STATE_READY or HAL_PKA_STATE_RESET state, thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit. [..] Then, the user first registers the MspInit/MspDeInit user callbacks using HAL_PKA_RegisterCallback() before calling HAL_PKA_DeInit() or HAL_PKA_Init() function. [..] When the compilation flag USE_HAL_PKA_REGISTER_CALLBACKS is set to 0 or not defined, the callback registration feature is not available and all callbacks are set to the corresponding weak functions. @endverbatim ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "stm32l4xx_hal.h" /** @addtogroup STM32L4xx_HAL_Driver * @{ */ #if defined(PKA) && defined(HAL_PKA_MODULE_ENABLED) /** @defgroup PKA PKA * @brief PKA HAL module driver. * @{ */ /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /** @defgroup PKA_Private_Define PKA Private Define * @{ */ #define PKA_RAM_SIZE 894U #define PKA_RAM_ERASE_TIMEOUT 1000U /* Private macro -------------------------------------------------------------*/ #define __PKA_RAM_PARAM_END(TAB,INDEX) do{ \ TAB[INDEX] = 0UL; \ } while(0) /** * @} */ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ /** @defgroup PKA_Private_Functions PKA Private Functions * @{ */ uint32_t PKA_GetMode(PKA_HandleTypeDef *hpka); HAL_StatusTypeDef PKA_PollEndOfOperation(PKA_HandleTypeDef *hpka, uint32_t Timeout, uint32_t Tickstart); uint32_t PKA_CheckError(PKA_HandleTypeDef *hpka, uint32_t mode); uint32_t PKA_GetBitSize_u8(uint32_t byteNumber); uint32_t PKA_GetOptBitSize_u8(uint32_t byteNumber, uint8_t msb); uint32_t PKA_GetBitSize_u32(uint32_t wordNumber); uint32_t PKA_GetArraySize_u8(uint32_t bitSize); void PKA_Memcpy_u32_to_u8(uint8_t dst[], __IO const uint32_t src[], size_t n); void PKA_Memcpy_u8_to_u32(__IO uint32_t dst[], const uint8_t src[], size_t n); void PKA_Memcpy_u32_to_u32(__IO uint32_t dst[], __IO const uint32_t src[], size_t n); HAL_StatusTypeDef PKA_Process(PKA_HandleTypeDef *hpka, uint32_t mode, uint32_t Timeout); HAL_StatusTypeDef PKA_Process_IT(PKA_HandleTypeDef *hpka, uint32_t mode); void PKA_ModExp_Set(PKA_HandleTypeDef *hpka, PKA_ModExpInTypeDef *in); void PKA_ModExpFastMode_Set(PKA_HandleTypeDef *hpka, PKA_ModExpFastModeInTypeDef *in); void PKA_ECDSASign_Set(PKA_HandleTypeDef *hpka, PKA_ECDSASignInTypeDef *in); void PKA_ECDSAVerif_Set(PKA_HandleTypeDef *hpka, PKA_ECDSAVerifInTypeDef *in); void PKA_RSACRTExp_Set(PKA_HandleTypeDef *hpka, PKA_RSACRTExpInTypeDef *in); void PKA_PointCheck_Set(PKA_HandleTypeDef *hpka, PKA_PointCheckInTypeDef *in); void PKA_ECCMul_Set(PKA_HandleTypeDef *hpka, PKA_ECCMulInTypeDef *in); void PKA_ECCMulFastMode_Set(PKA_HandleTypeDef *hpka, PKA_ECCMulFastModeInTypeDef *in); void PKA_ModRed_Set(PKA_HandleTypeDef *hpka, PKA_ModRedInTypeDef *in); void PKA_ModInv_Set(PKA_HandleTypeDef *hpka, PKA_ModInvInTypeDef *in); void PKA_MontgomeryParam_Set(PKA_HandleTypeDef *hpka, const uint32_t size, const uint8_t *pOp1); void PKA_ARI_Set(PKA_HandleTypeDef *hpka, const uint32_t size, const uint32_t *pOp1, const uint32_t *pOp2, const uint8_t *pOp3); /** * @} */ /* Exported functions --------------------------------------------------------*/ /** @defgroup PKA_Exported_Functions PKA Exported Functions * @{ */ /** @defgroup PKA_Exported_Functions_Group1 Initialization and de-initialization functions * @brief Initialization and de-initialization functions * @verbatim =============================================================================== ##### Initialization and de-initialization functions ##### =============================================================================== [..] This subsection provides a set of functions allowing to initialize and deinitialize the PKAx peripheral: (+) User must implement HAL_PKA_MspInit() function in which he configures all related peripherals resources (CLOCK, IT and NVIC ). (+) Call the function HAL_PKA_Init() to configure the device. (+) Call the function HAL_PKA_DeInit() to restore the default configuration of the selected PKAx peripheral. @endverbatim * @{ */ /** * @brief Initialize the PKA according to the specified * parameters in the PKA_InitTypeDef and initialize the associated handle. * @param hpka PKA handle * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Init(PKA_HandleTypeDef *hpka) { HAL_StatusTypeDef err = HAL_OK; uint32_t tickstart; /* Check the PKA handle allocation */ if (hpka != NULL) { /* Check the parameters */ assert_param(IS_PKA_ALL_INSTANCE(hpka->Instance)); if (hpka->State == HAL_PKA_STATE_RESET) { #if (USE_HAL_PKA_REGISTER_CALLBACKS == 1) /* Init the PKA Callback settings */ hpka->OperationCpltCallback = HAL_PKA_OperationCpltCallback; /* Legacy weak OperationCpltCallback */ hpka->ErrorCallback = HAL_PKA_ErrorCallback; /* Legacy weak ErrorCallback */ if (hpka->MspInitCallback == NULL) { hpka->MspInitCallback = HAL_PKA_MspInit; /* Legacy weak MspInit */ } /* Init the low level hardware */ hpka->MspInitCallback(hpka); #else /* Init the low level hardware */ HAL_PKA_MspInit(hpka); #endif /* USE_HAL_PKA_REGISTER_CALLBACKS */ } /* Set the state to busy */ hpka->State = HAL_PKA_STATE_BUSY; /* Get current tick */ tickstart = HAL_GetTick(); /* Reset the control register and enable the PKA (wait the end of PKA RAM erase) */ while ((hpka->Instance->CR & PKA_CR_EN) != PKA_CR_EN) { hpka->Instance->CR = PKA_CR_EN; /* Check the Timeout */ if ((HAL_GetTick() - tickstart) > PKA_RAM_ERASE_TIMEOUT) { /* Set timeout status */ err = HAL_TIMEOUT; break; } } if (err == HAL_OK) { /* Reset any pending flag */ SET_BIT(hpka->Instance->CLRFR, PKA_CLRFR_PROCENDFC | PKA_CLRFR_RAMERRFC | PKA_CLRFR_ADDRERRFC); /* Initialize the error code */ hpka->ErrorCode = HAL_PKA_ERROR_NONE; /* Set the state to ready */ hpka->State = HAL_PKA_STATE_READY; } else { /* Set the error code to timeout error */ hpka->ErrorCode = HAL_PKA_ERROR_TIMEOUT; /* Set the state to error */ hpka->State = HAL_PKA_STATE_ERROR; } } else { err = HAL_ERROR; } return err; } /** * @brief DeInitialize the PKA peripheral. * @param hpka PKA handle * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_DeInit(PKA_HandleTypeDef *hpka) { HAL_StatusTypeDef err = HAL_OK; /* Check the PKA handle allocation */ if (hpka != NULL) { /* Check the parameters */ assert_param(IS_PKA_ALL_INSTANCE(hpka->Instance)); /* Set the state to busy */ hpka->State = HAL_PKA_STATE_BUSY; /* Reset the control register */ /* This abort any operation in progress (PKA RAM content is not guaranteed in this case) */ hpka->Instance->CR = 0; /* Reset any pending flag */ SET_BIT(hpka->Instance->CLRFR, PKA_CLRFR_PROCENDFC | PKA_CLRFR_RAMERRFC | PKA_CLRFR_ADDRERRFC); #if (USE_HAL_PKA_REGISTER_CALLBACKS == 1) if (hpka->MspDeInitCallback == NULL) { hpka->MspDeInitCallback = HAL_PKA_MspDeInit; /* Legacy weak MspDeInit */ } /* DeInit the low level hardware: GPIO, CLOCK, NVIC */ hpka->MspDeInitCallback(hpka); #else /* DeInit the low level hardware: CLOCK, NVIC */ HAL_PKA_MspDeInit(hpka); #endif /* USE_HAL_PKA_REGISTER_CALLBACKS */ /* Reset the error code */ hpka->ErrorCode = HAL_PKA_ERROR_NONE; /* Reset the state */ hpka->State = HAL_PKA_STATE_RESET; } else { err = HAL_ERROR; } return err; } /** * @brief Initialize the PKA MSP. * @param hpka PKA handle * @retval None */ __weak void HAL_PKA_MspInit(PKA_HandleTypeDef *hpka) { /* Prevent unused argument(s) compilation warning */ UNUSED(hpka); /* NOTE : This function should not be modified, when the callback is needed, the HAL_PKA_MspInit can be implemented in the user file */ } /** * @brief DeInitialize the PKA MSP. * @param hpka PKA handle * @retval None */ __weak void HAL_PKA_MspDeInit(PKA_HandleTypeDef *hpka) { /* Prevent unused argument(s) compilation warning */ UNUSED(hpka); /* NOTE : This function should not be modified, when the callback is needed, the HAL_PKA_MspDeInit can be implemented in the user file */ } #if (USE_HAL_PKA_REGISTER_CALLBACKS == 1) /** * @brief Register a User PKA Callback * To be used instead of the weak predefined callback * @param hpka Pointer to a PKA_HandleTypeDef structure that contains * the configuration information for the specified PKA. * @param CallbackID ID of the callback to be registered * This parameter can be one of the following values: * @arg @ref HAL_PKA_OPERATION_COMPLETE_CB_ID End of operation callback ID * @arg @ref HAL_PKA_ERROR_CB_ID Error callback ID * @arg @ref HAL_PKA_MSPINIT_CB_ID MspInit callback ID * @arg @ref HAL_PKA_MSPDEINIT_CB_ID MspDeInit callback ID * @param pCallback pointer to the Callback function * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_RegisterCallback(PKA_HandleTypeDef *hpka, HAL_PKA_CallbackIDTypeDef CallbackID, pPKA_CallbackTypeDef pCallback) { HAL_StatusTypeDef status = HAL_OK; if (pCallback == NULL) { /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; return HAL_ERROR; } if (HAL_PKA_STATE_READY == hpka->State) { switch (CallbackID) { case HAL_PKA_OPERATION_COMPLETE_CB_ID : hpka->OperationCpltCallback = pCallback; break; case HAL_PKA_ERROR_CB_ID : hpka->ErrorCallback = pCallback; break; case HAL_PKA_MSPINIT_CB_ID : hpka->MspInitCallback = pCallback; break; case HAL_PKA_MSPDEINIT_CB_ID : hpka->MspDeInitCallback = pCallback; break; default : /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; break; } } else if (HAL_PKA_STATE_RESET == hpka->State) { switch (CallbackID) { case HAL_PKA_MSPINIT_CB_ID : hpka->MspInitCallback = pCallback; break; case HAL_PKA_MSPDEINIT_CB_ID : hpka->MspDeInitCallback = pCallback; break; default : /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; break; } } else { /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; } return status; } /** * @brief Unregister a PKA Callback * PKA callback is redirected to the weak predefined callback * @param hpka Pointer to a PKA_HandleTypeDef structure that contains * the configuration information for the specified PKA. * @param CallbackID ID of the callback to be unregistered * This parameter can be one of the following values: * @arg @ref HAL_PKA_OPERATION_COMPLETE_CB_ID End of operation callback ID * @arg @ref HAL_PKA_ERROR_CB_ID Error callback ID * @arg @ref HAL_PKA_MSPINIT_CB_ID MspInit callback ID * @arg @ref HAL_PKA_MSPDEINIT_CB_ID MspDeInit callback ID * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_UnRegisterCallback(PKA_HandleTypeDef *hpka, HAL_PKA_CallbackIDTypeDef CallbackID) { HAL_StatusTypeDef status = HAL_OK; if (HAL_PKA_STATE_READY == hpka->State) { switch (CallbackID) { case HAL_PKA_OPERATION_COMPLETE_CB_ID : hpka->OperationCpltCallback = HAL_PKA_OperationCpltCallback; /* Legacy weak OperationCpltCallback */ break; case HAL_PKA_ERROR_CB_ID : hpka->ErrorCallback = HAL_PKA_ErrorCallback; /* Legacy weak ErrorCallback */ break; case HAL_PKA_MSPINIT_CB_ID : hpka->MspInitCallback = HAL_PKA_MspInit; /* Legacy weak MspInit */ break; case HAL_PKA_MSPDEINIT_CB_ID : hpka->MspDeInitCallback = HAL_PKA_MspDeInit; /* Legacy weak MspDeInit */ break; default : /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; break; } } else if (HAL_PKA_STATE_RESET == hpka->State) { switch (CallbackID) { case HAL_PKA_MSPINIT_CB_ID : hpka->MspInitCallback = HAL_PKA_MspInit; /* Legacy weak MspInit */ break; case HAL_PKA_MSPDEINIT_CB_ID : hpka->MspDeInitCallback = HAL_PKA_MspDeInit; /* Legacy weak MspDeInit */ break; default : /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; break; } } else { /* Update the error code */ hpka->ErrorCode |= HAL_PKA_ERROR_INVALID_CALLBACK; /* Return error status */ status = HAL_ERROR; } return status; } #endif /* USE_HAL_PKA_REGISTER_CALLBACKS */ /** * @} */ /** @defgroup PKA_Exported_Functions_Group2 IO operation functions * @brief IO operation functions * @verbatim =============================================================================== ##### IO operation functions ##### =============================================================================== [..] This subsection provides a set of functions allowing to manage the PKA operations. (#) There are two modes of operation: (++) Blocking mode : The operation is performed in the polling mode. These functions return when data operation is completed. (++) No-Blocking mode : The operation is performed using Interrupts. These functions return immediately. The end of the operation is indicated by HAL_PKA_ErrorCallback in case of error. The end of the operation is indicated by HAL_PKA_OperationCpltCallback in case of success. To stop any operation in interrupt mode, use HAL_PKA_Abort(). (#) Blocking mode functions are : (++) HAL_PKA_ModExp() (++) HAL_PKA_ModExpFastMode() (++) HAL_PKA_ModExp_GetResult(); (++) HAL_PKA_ECDSASign() (++) HAL_PKA_ECDSASign_GetResult(); (++) HAL_PKA_ECDSAVerif() (++) HAL_PKA_ECDSAVerif_IsValidSignature(); (++) HAL_PKA_RSACRTExp() (++) HAL_PKA_RSACRTExp_GetResult(); (++) HAL_PKA_PointCheck() (++) HAL_PKA_PointCheck_IsOnCurve(); (++) HAL_PKA_ECCMul() (++) HAL_PKA_ECCMulFastMode() (++) HAL_PKA_ECCMul_GetResult(); (++) HAL_PKA_Add() (++) HAL_PKA_Sub() (++) HAL_PKA_Cmp() (++) HAL_PKA_Mul() (++) HAL_PKA_ModAdd() (++) HAL_PKA_ModSub() (++) HAL_PKA_ModInv() (++) HAL_PKA_ModRed() (++) HAL_PKA_MontgomeryMul() (++) HAL_PKA_Arithmetic_GetResult(P); (++) HAL_PKA_MontgomeryParam() (++) HAL_PKA_MontgomeryParam_GetResult(); (#) No-Blocking mode functions with Interrupt are : (++) HAL_PKA_ModExp_IT(); (++) HAL_PKA_ModExpFastMode_IT(); (++) HAL_PKA_ModExp_GetResult(); (++) HAL_PKA_ECDSASign_IT(); (++) HAL_PKA_ECDSASign_GetResult(); (++) HAL_PKA_ECDSAVerif_IT(); (++) HAL_PKA_ECDSAVerif_IsValidSignature(); (++) HAL_PKA_RSACRTExp_IT(); (++) HAL_PKA_RSACRTExp_GetResult(); (++) HAL_PKA_PointCheck_IT(); (++) HAL_PKA_PointCheck_IsOnCurve(); (++) HAL_PKA_ECCMul_IT(); (++) HAL_PKA_ECCMulFastMode_IT(); (++) HAL_PKA_ECCMul_GetResult(); (++) HAL_PKA_Add_IT(); (++) HAL_PKA_Sub_IT(); (++) HAL_PKA_Cmp_IT(); (++) HAL_PKA_Mul_IT(); (++) HAL_PKA_ModAdd_IT(); (++) HAL_PKA_ModSub_IT(); (++) HAL_PKA_ModInv_IT(); (++) HAL_PKA_ModRed_IT(); (++) HAL_PKA_MontgomeryMul_IT(); (++) HAL_PKA_Arithmetic_GetResult(); (++) HAL_PKA_MontgomeryParam_IT(); (++) HAL_PKA_MontgomeryParam_GetResult(); (++) HAL_PKA_Abort(); @endverbatim * @{ */ /** * @brief Modular exponentiation in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModExp(PKA_HandleTypeDef *hpka, PKA_ModExpInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ModExp_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_EXP, Timeout); } /** * @brief Modular exponentiation in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModExp_IT(PKA_HandleTypeDef *hpka, PKA_ModExpInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ModExp_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_EXP); } /** * @brief Modular exponentiation in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModExpFastMode(PKA_HandleTypeDef *hpka, PKA_ModExpFastModeInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ModExpFastMode_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_EXP_FAST_MODE, Timeout); } /** * @brief Modular exponentiation in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModExpFastMode_IT(PKA_HandleTypeDef *hpka, PKA_ModExpFastModeInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ModExpFastMode_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_EXP_FAST_MODE); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param pRes Output buffer * @retval HAL status */ void HAL_PKA_ModExp_GetResult(PKA_HandleTypeDef *hpka, uint8_t *pRes) { uint32_t size; /* Indicate to the user the final size */ size = (hpka->Instance->RAM[PKA_MODULAR_EXP_IN_OP_NB_BITS] + 7UL) / 8UL; /* Move the result to appropriate location (indicated in out parameter) */ PKA_Memcpy_u32_to_u8(pRes, &hpka->Instance->RAM[PKA_MODULAR_EXP_OUT_SM_ALGO_ACC1], size); } /** * @brief Sign a message using elliptic curves over prime fields in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECDSASign(PKA_HandleTypeDef *hpka, PKA_ECDSASignInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ECDSASign_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ECDSA_SIGNATURE, Timeout); } /** * @brief Sign a message using elliptic curves over prime fields in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECDSASign_IT(PKA_HandleTypeDef *hpka, PKA_ECDSASignInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ECDSASign_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ECDSA_SIGNATURE); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param out Output information * @param outExt Additional Output information (facultative) */ void HAL_PKA_ECDSASign_GetResult(PKA_HandleTypeDef *hpka, PKA_ECDSASignOutTypeDef *out, PKA_ECDSASignOutExtParamTypeDef *outExt) { uint32_t size; size = (hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_MOD_NB_BITS] + 7UL) / 8UL; if (out != NULL) { PKA_Memcpy_u32_to_u8(out->RSign, &hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_SIGNATURE_R], size); PKA_Memcpy_u32_to_u8(out->SSign, &hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_SIGNATURE_S], size); } /* If user requires the additional information */ if (outExt != NULL) { /* Move the result to appropriate location (indicated in outExt parameter) */ PKA_Memcpy_u32_to_u8(outExt->ptX, &hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_FINAL_POINT_X], size); PKA_Memcpy_u32_to_u8(outExt->ptY, &hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_FINAL_POINT_Y], size); } } /** * @brief Verify the validity of a signature using elliptic curves over prime fields in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECDSAVerif(PKA_HandleTypeDef *hpka, PKA_ECDSAVerifInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ECDSAVerif_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ECDSA_VERIFICATION, Timeout); } /** * @brief Verify the validity of a signature using elliptic curves * over prime fields in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECDSAVerif_IT(PKA_HandleTypeDef *hpka, PKA_ECDSAVerifInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ECDSAVerif_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ECDSA_VERIFICATION); } /** * @brief Return the result of the ECDSA verification operation. * @param hpka PKA handle * @retval 1 if signature is verified, 0 in other case */ uint32_t HAL_PKA_ECDSAVerif_IsValidSignature(PKA_HandleTypeDef const *const hpka) { /* Invert the state of the PKA RAM bit containing the result of the operation */ return (hpka->Instance->RAM[PKA_ECDSA_VERIF_OUT_RESULT] == 0UL) ? 1UL : 0UL; } /** * @brief RSA CRT exponentiation in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_RSACRTExp(PKA_HandleTypeDef *hpka, PKA_RSACRTExpInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_RSACRTExp_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_RSA_CRT_EXP, Timeout); } /** * @brief RSA CRT exponentiation in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_RSACRTExp_IT(PKA_HandleTypeDef *hpka, PKA_RSACRTExpInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_RSACRTExp_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_RSA_CRT_EXP); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param pRes Pointer to memory location to receive the result of the operation * @retval HAL status */ void HAL_PKA_RSACRTExp_GetResult(PKA_HandleTypeDef *hpka, uint8_t *pRes) { uint32_t size; /* Move the result to appropriate location (indicated in out parameter) */ size = (hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_MOD_NB_BITS] + 7UL) / 8UL; PKA_Memcpy_u32_to_u8(pRes, &hpka->Instance->RAM[PKA_RSA_CRT_EXP_OUT_RESULT], size); } /** * @brief Point on elliptic curve check in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_PointCheck(PKA_HandleTypeDef *hpka, PKA_PointCheckInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_PointCheck_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_POINT_CHECK, Timeout); } /** * @brief Point on elliptic curve check in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_PointCheck_IT(PKA_HandleTypeDef *hpka, PKA_PointCheckInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_PointCheck_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_POINT_CHECK); } /** * @brief Return the result of the point check operation. * @param hpka PKA handle * @retval 1 if point is on curve, 0 in other case */ uint32_t HAL_PKA_PointCheck_IsOnCurve(PKA_HandleTypeDef const *const hpka) { #define PKA_POINT_IS_ON_CURVE 0UL /* Invert the value of the PKA RAM containing the result of the operation */ return (hpka->Instance->RAM[PKA_POINT_CHECK_OUT_ERROR] == PKA_POINT_IS_ON_CURVE) ? 1UL : 0UL; } /** * @brief ECC scalar multiplication in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECCMul(PKA_HandleTypeDef *hpka, PKA_ECCMulInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ECCMul_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ECC_MUL, Timeout); } /** * @brief ECC scalar multiplication in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECCMul_IT(PKA_HandleTypeDef *hpka, PKA_ECCMulInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ECCMul_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ECC_MUL); } /** * @brief ECC scalar multiplication in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECCMulFastMode(PKA_HandleTypeDef *hpka, PKA_ECCMulFastModeInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ECCMulFastMode_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ECC_MUL_FAST_MODE, Timeout); } /** * @brief ECC scalar multiplication in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ECCMulFastMode_IT(PKA_HandleTypeDef *hpka, PKA_ECCMulFastModeInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ECCMulFastMode_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ECC_MUL_FAST_MODE); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param out Output information * @retval HAL status */ void HAL_PKA_ECCMul_GetResult(PKA_HandleTypeDef *hpka, PKA_ECCMulOutTypeDef *out) { uint32_t size; /* Retrieve the size of the array from the PKA RAM */ size = (hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_OP_NB_BITS] + 7UL) / 8UL; /* If a destination buffer is provided */ if (out != NULL) { /* Move the result to appropriate location (indicated in out parameter) */ PKA_Memcpy_u32_to_u8(out->ptX, &hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_OUT_RESULT_X], size); PKA_Memcpy_u32_to_u8(out->ptY, &hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_OUT_RESULT_Y], size); } } /** * @brief Arithmetic addition in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Add(PKA_HandleTypeDef *hpka, PKA_AddInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ARITHMETIC_ADD, Timeout); } /** * @brief Arithmetic addition in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Add_IT(PKA_HandleTypeDef *hpka, PKA_AddInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ARITHMETIC_ADD); } /** * @brief Arithmetic subtraction in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Sub(PKA_HandleTypeDef *hpka, PKA_SubInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ARITHMETIC_SUB, Timeout); } /** * @brief Arithmetic subtraction in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Sub_IT(PKA_HandleTypeDef *hpka, PKA_SubInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ARITHMETIC_SUB); } /** * @brief Arithmetic multiplication in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Mul(PKA_HandleTypeDef *hpka, PKA_MulInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_ARITHMETIC_MUL, Timeout); } /** * @brief Arithmetic multiplication in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Mul_IT(PKA_HandleTypeDef *hpka, PKA_MulInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_ARITHMETIC_MUL); } /** * @brief Comparison in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Cmp(PKA_HandleTypeDef *hpka, PKA_CmpInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_COMPARISON, Timeout); } /** * @brief Comparison in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Cmp_IT(PKA_HandleTypeDef *hpka, PKA_CmpInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, NULL); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_COMPARISON); } /** * @brief Modular addition in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModAdd(PKA_HandleTypeDef *hpka, PKA_ModAddInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_ADD, Timeout); } /** * @brief Modular addition in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModAdd_IT(PKA_HandleTypeDef *hpka, PKA_ModAddInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_ADD); } /** * @brief Modular inversion in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModInv(PKA_HandleTypeDef *hpka, PKA_ModInvInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ModInv_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_INV, Timeout); } /** * @brief Modular inversion in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModInv_IT(PKA_HandleTypeDef *hpka, PKA_ModInvInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ModInv_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_INV); } /** * @brief Modular subtraction in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModSub(PKA_HandleTypeDef *hpka, PKA_ModSubInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_SUB, Timeout); } /** * @brief Modular subtraction in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModSub_IT(PKA_HandleTypeDef *hpka, PKA_ModSubInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_SUB); } /** * @brief Modular reduction in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModRed(PKA_HandleTypeDef *hpka, PKA_ModRedInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ModRed_Set(hpka, in); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MODULAR_RED, Timeout); } /** * @brief Modular reduction in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_ModRed_IT(PKA_HandleTypeDef *hpka, PKA_ModRedInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ModRed_Set(hpka, in); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MODULAR_RED); } /** * @brief Montgomery multiplication in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_MontgomeryMul(PKA_HandleTypeDef *hpka, PKA_MontgomeryMulInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MONTGOMERY_MUL, Timeout); } /** * @brief Montgomery multiplication in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_MontgomeryMul_IT(PKA_HandleTypeDef *hpka, PKA_MontgomeryMulInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_ARI_Set(hpka, in->size, in->pOp1, in->pOp2, in->pOp3); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MONTGOMERY_MUL); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param pRes Pointer to memory location to receive the result of the operation */ void HAL_PKA_Arithmetic_GetResult(PKA_HandleTypeDef *hpka, uint32_t *pRes) { uint32_t mode = (hpka->Instance->CR & PKA_CR_MODE_Msk) >> PKA_CR_MODE_Pos; uint32_t size = 0; /* Move the result to appropriate location (indicated in pRes parameter) */ switch (mode) { case PKA_MODE_ARITHMETIC_SUB: case PKA_MODE_MODULAR_ADD: case PKA_MODE_MODULAR_RED: case PKA_MODE_MODULAR_INV: case PKA_MODE_MODULAR_SUB: case PKA_MODE_MONTGOMERY_MUL: size = hpka->Instance->RAM[1] / 32UL; break; case PKA_MODE_ARITHMETIC_ADD: size = hpka->Instance->RAM[1] / 32UL; /* Manage the overflow of the addition */ if (hpka->Instance->RAM[500U + size] != 0UL) { size += 1UL; } break; case PKA_MODE_COMPARISON: size = 1; break; case PKA_MODE_ARITHMETIC_MUL: size = hpka->Instance->RAM[1] / 32UL * 2UL; break; default: break; } if (pRes != NULL) { switch (mode) { case PKA_MODE_ARITHMETIC_SUB: case PKA_MODE_MODULAR_ADD: case PKA_MODE_MODULAR_RED: case PKA_MODE_MODULAR_INV: case PKA_MODE_MODULAR_SUB: case PKA_MODE_MONTGOMERY_MUL: case PKA_MODE_ARITHMETIC_ADD: case PKA_MODE_COMPARISON: case PKA_MODE_ARITHMETIC_MUL: PKA_Memcpy_u32_to_u32(pRes, &hpka->Instance->RAM[PKA_ARITHMETIC_ALL_OPS_OUT_RESULT], size); break; default: break; } } } /** * @brief Montgomery parameter computation in blocking mode. * @param hpka PKA handle * @param in Input information * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_MontgomeryParam(PKA_HandleTypeDef *hpka, PKA_MontgomeryParamInTypeDef *in, uint32_t Timeout) { /* Set input parameter in PKA RAM */ PKA_MontgomeryParam_Set(hpka, in->size, in->pOp1); /* Start the operation */ return PKA_Process(hpka, PKA_MODE_MONTGOMERY_PARAM, Timeout); } /** * @brief Montgomery parameter computation in non-blocking mode with Interrupt. * @param hpka PKA handle * @param in Input information * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_MontgomeryParam_IT(PKA_HandleTypeDef *hpka, PKA_MontgomeryParamInTypeDef *in) { /* Set input parameter in PKA RAM */ PKA_MontgomeryParam_Set(hpka, in->size, in->pOp1); /* Start the operation */ return PKA_Process_IT(hpka, PKA_MODE_MONTGOMERY_PARAM); } /** * @brief Retrieve operation result. * @param hpka PKA handle * @param pRes pointer to buffer where the result will be copied * @retval HAL status */ void HAL_PKA_MontgomeryParam_GetResult(PKA_HandleTypeDef *hpka, uint32_t *pRes) { uint32_t size; /* Retrieve the size of the buffer from the PKA RAM */ size = (hpka->Instance->RAM[PKA_MONTGOMERY_PARAM_IN_MOD_NB_BITS] + 31UL) / 32UL; /* Move the result to appropriate location (indicated in out parameter) */ PKA_Memcpy_u32_to_u32(pRes, &hpka->Instance->RAM[PKA_MONTGOMERY_PARAM_OUT_PARAMETER], size); } /** * @brief Abort any ongoing operation. * @param hpka PKA handle * @retval HAL status */ HAL_StatusTypeDef HAL_PKA_Abort(PKA_HandleTypeDef *hpka) { HAL_StatusTypeDef err = HAL_OK; /* Clear EN bit */ /* This abort any operation in progress (PKA RAM content is not guaranteed in this case) */ CLEAR_BIT(hpka->Instance->CR, PKA_CR_EN); SET_BIT(hpka->Instance->CR, PKA_CR_EN); /* Reset any pending flag */ SET_BIT(hpka->Instance->CLRFR, PKA_CLRFR_PROCENDFC | PKA_CLRFR_RAMERRFC | PKA_CLRFR_ADDRERRFC); /* Reset the error code */ hpka->ErrorCode = HAL_PKA_ERROR_NONE; /* Reset the state */ hpka->State = HAL_PKA_STATE_READY; return err; } /** * @brief Reset the PKA RAM. * @param hpka PKA handle * @retval None */ void HAL_PKA_RAMReset(PKA_HandleTypeDef *hpka) { uint32_t index; /* For each element in the PKA RAM */ for (index = 0; index < PKA_RAM_SIZE; index++) { /* Clear the content */ hpka->Instance->RAM[index] = 0UL; } } /** * @brief This function handles PKA event interrupt request. * @param hpka PKA handle * @retval None */ void HAL_PKA_IRQHandler(PKA_HandleTypeDef *hpka) { uint32_t mode = PKA_GetMode(hpka); FlagStatus addErrFlag = __HAL_PKA_GET_FLAG(hpka, PKA_FLAG_ADDRERR); FlagStatus ramErrFlag = __HAL_PKA_GET_FLAG(hpka, PKA_FLAG_RAMERR); FlagStatus procEndFlag = __HAL_PKA_GET_FLAG(hpka, PKA_FLAG_PROCEND); /* Address error interrupt occurred */ if ((__HAL_PKA_GET_IT_SOURCE(hpka, PKA_IT_ADDRERR) == SET) && (addErrFlag == SET)) { hpka->ErrorCode |= HAL_PKA_ERROR_ADDRERR; /* Clear ADDRERR flag */ __HAL_PKA_CLEAR_FLAG(hpka, PKA_FLAG_ADDRERR); } /* RAM access error interrupt occurred */ if ((__HAL_PKA_GET_IT_SOURCE(hpka, PKA_IT_RAMERR) == SET) && (ramErrFlag == SET)) { hpka->ErrorCode |= HAL_PKA_ERROR_RAMERR; /* Clear RAMERR flag */ __HAL_PKA_CLEAR_FLAG(hpka, PKA_FLAG_RAMERR); } /* Check the operation success in case of ECDSA signature */ if (mode == PKA_MODE_ECDSA_SIGNATURE) { /* If error output result is different from 0, ecdsa sign operation need to be repeated */ if (hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_ERROR] != 0UL) { hpka->ErrorCode |= HAL_PKA_ERROR_OPERATION; } } /* Trigger the error callback if an error is present */ if (hpka->ErrorCode != HAL_PKA_ERROR_NONE) { #if (USE_HAL_PKA_REGISTER_CALLBACKS == 1) hpka->ErrorCallback(hpka); #else HAL_PKA_ErrorCallback(hpka); #endif /* USE_HAL_PKA_REGISTER_CALLBACKS */ } /* End Of Operation interrupt occurred */ if ((__HAL_PKA_GET_IT_SOURCE(hpka, PKA_IT_PROCEND) == SET) && (procEndFlag == SET)) { /* Clear PROCEND flag */ __HAL_PKA_CLEAR_FLAG(hpka, PKA_FLAG_PROCEND); /* Set the state to ready */ hpka->State = HAL_PKA_STATE_READY; #if (USE_HAL_PKA_REGISTER_CALLBACKS == 1) hpka->OperationCpltCallback(hpka); #else HAL_PKA_OperationCpltCallback(hpka); #endif /* USE_HAL_PKA_REGISTER_CALLBACKS */ } } /** * @brief Process completed callback. * @param hpka PKA handle * @retval None */ __weak void HAL_PKA_OperationCpltCallback(PKA_HandleTypeDef *hpka) { /* Prevent unused argument(s) compilation warning */ UNUSED(hpka); /* NOTE : This function should not be modified, when the callback is needed, the HAL_PKA_OperationCpltCallback could be implemented in the user file */ } /** * @brief Error callback. * @param hpka PKA handle * @retval None */ __weak void HAL_PKA_ErrorCallback(PKA_HandleTypeDef *hpka) { /* Prevent unused argument(s) compilation warning */ UNUSED(hpka); /* NOTE : This function should not be modified, when the callback is needed, the HAL_PKA_ErrorCallback could be implemented in the user file */ } /** * @} */ /** @defgroup PKA_Exported_Functions_Group3 Peripheral State and Error functions * @brief Peripheral State and Error functions * @verbatim =============================================================================== ##### Peripheral State and Error functions ##### =============================================================================== [..] This subsection permit to get in run-time the status of the peripheral. @endverbatim * @{ */ /** * @brief Return the PKA handle state. * @param hpka PKA handle * @retval HAL status */ HAL_PKA_StateTypeDef HAL_PKA_GetState(PKA_HandleTypeDef *hpka) { /* Return PKA handle state */ return hpka->State; } /** * @brief Return the PKA error code. * @param hpka PKA handle * @retval PKA error code */ uint32_t HAL_PKA_GetError(PKA_HandleTypeDef *hpka) { /* Return PKA handle error code */ return hpka->ErrorCode; } /** * @} */ /** * @} */ /** @addtogroup PKA_Private_Functions * @{ */ /** * @brief Get PKA operating mode. * @param hpka PKA handle * @retval Return the current mode */ uint32_t PKA_GetMode(PKA_HandleTypeDef *hpka) { /* return the shifted PKA_CR_MODE value */ return (uint32_t)(READ_BIT(hpka->Instance->CR, PKA_CR_MODE) >> PKA_CR_MODE_Pos); } /** * @brief Wait for operation completion or timeout. * @param hpka PKA handle * @param Timeout Timeout duration in millisecond. * @param Tickstart Tick start value * @retval HAL status */ HAL_StatusTypeDef PKA_PollEndOfOperation(PKA_HandleTypeDef *hpka, uint32_t Timeout, uint32_t Tickstart) { /* Wait for the end of operation or timeout */ while ((hpka->Instance->SR & PKA_SR_PROCENDF) == 0UL) { /* Check if timeout is disabled (set to infinite wait) */ if (Timeout != HAL_MAX_DELAY) { if (((HAL_GetTick() - Tickstart) > Timeout) || (Timeout == 0UL)) { return HAL_TIMEOUT; } } } return HAL_OK; } /** * @brief Return a hal error code based on PKA error flags. * @param hpka PKA handle * @param mode PKA operating mode * @retval error code */ uint32_t PKA_CheckError(PKA_HandleTypeDef *hpka, uint32_t mode) { uint32_t err = HAL_PKA_ERROR_NONE; /* Check RAMERR error */ if (__HAL_PKA_GET_FLAG(hpka, PKA_FLAG_RAMERR) == SET) { err |= HAL_PKA_ERROR_RAMERR; } /* Check ADDRERR error */ if (__HAL_PKA_GET_FLAG(hpka, PKA_FLAG_ADDRERR) == SET) { err |= HAL_PKA_ERROR_ADDRERR; } /* Check the operation success in case of ECDSA signature */ if (mode == PKA_MODE_ECDSA_SIGNATURE) { #define EDCSA_SIGN_NOERROR 0UL /* If error output result is different from no error, ecsa sign operation need to be repeated */ if (hpka->Instance->RAM[PKA_ECDSA_SIGN_OUT_ERROR] != EDCSA_SIGN_NOERROR) { err |= HAL_PKA_ERROR_OPERATION; } } return err; } /** * @brief Get number of bits inside an array of u8. * @param byteNumber Number of u8 inside the array */ uint32_t PKA_GetBitSize_u8(uint32_t byteNumber) { /* Convert from number of uint8_t in an array to the associated number of bits in this array */ return byteNumber * 8UL; } /** * @brief Get optimal number of bits inside an array of u8. * @param byteNumber Number of u8 inside the array * @param msb Most significant uint8_t of the array */ uint32_t PKA_GetOptBitSize_u8(uint32_t byteNumber, uint8_t msb) { uint32_t position; position = 32UL - __CLZ(msb); return (((byteNumber - 1UL) * 8UL) + position); } /** * @brief Get number of bits inside an array of u32. * @param wordNumber Number of u32 inside the array */ uint32_t PKA_GetBitSize_u32(uint32_t wordNumber) { /* Convert from number of uint32_t in an array to the associated number of bits in this array */ return wordNumber * 32UL; } /** * @brief Get number of uint8_t element in an array of bitSize bits. * @param bitSize Number of bits in an array */ uint32_t PKA_GetArraySize_u8(uint32_t bitSize) { /* Manage the non aligned on uint8_t bitsize: */ /* 512 bits requires 64 uint8_t */ /* 521 bits requires 66 uint8_t */ return ((bitSize + 7UL) / 8UL); } /** * @brief Copy uint32_t array to uint8_t array to fit PKA number representation. * @param dst Pointer to destination * @param src Pointer to source * @param n Number of uint8_t to copy * @retval dst */ void PKA_Memcpy_u32_to_u8(uint8_t dst[], __IO const uint32_t src[], size_t n) { if (dst != NULL) { if (src != NULL) { uint32_t index_uint32_t = 0UL; /* This index is used outside of the loop */ for (; index_uint32_t < (n / 4UL); index_uint32_t++) { /* Avoid casting from uint8_t* to uint32_t* by copying 4 uint8_t in a row */ /* Apply __REV equivalent */ uint32_t index_uint8_t = n - 4UL - (index_uint32_t * 4UL); dst[index_uint8_t + 3UL] = (uint8_t)((src[index_uint32_t] & 0x000000FFU)); dst[index_uint8_t + 2UL] = (uint8_t)((src[index_uint32_t] & 0x0000FF00U) >> 8UL); dst[index_uint8_t + 1UL] = (uint8_t)((src[index_uint32_t] & 0x00FF0000U) >> 16UL); dst[index_uint8_t + 0UL] = (uint8_t)((src[index_uint32_t] & 0xFF000000U) >> 24UL); } /* Manage the buffers not aligned on uint32_t */ if ((n % 4UL) == 1UL) { dst[0UL] = (uint8_t)((src[index_uint32_t] & 0x000000FFU)); } else if ((n % 4UL) == 2UL) { dst[1UL] = (uint8_t)((src[index_uint32_t] & 0x000000FFU)); dst[0UL] = (uint8_t)((src[index_uint32_t] & 0x0000FF00U) >> 8UL); } else if ((n % 4UL) == 3UL) { dst[2UL] = (uint8_t)((src[index_uint32_t] & 0x000000FFU)); dst[1UL] = (uint8_t)((src[index_uint32_t] & 0x0000FF00U) >> 8UL); dst[0UL] = (uint8_t)((src[index_uint32_t] & 0x00FF0000U) >> 16UL); } else { /* The last element is already handle in the loop */ } } } } /** * @brief Copy uint8_t array to uint32_t array to fit PKA number representation. * @param dst Pointer to destination * @param src Pointer to source * @param n Number of uint8_t to copy (must be multiple of 4) * @retval dst */ void PKA_Memcpy_u8_to_u32(__IO uint32_t dst[], const uint8_t src[], size_t n) { if (dst != NULL) { if (src != NULL) { uint32_t index = 0UL; /* This index is used outside of the loop */ for (; index < (n / 4UL); index++) { /* Apply the equivalent of __REV from uint8_t to uint32_t */ dst[index] = ((uint32_t)src[(n - (index * 4UL) - 1UL)]) \ | ((uint32_t)src[(n - (index * 4UL) - 2UL)] << 8UL) \ | ((uint32_t)src[(n - (index * 4UL) - 3UL)] << 16UL) \ | ((uint32_t)src[(n - (index * 4UL) - 4UL)] << 24UL); } /* Manage the buffers not aligned on uint32_t */ if ((n % 4UL) == 1UL) { dst[index] = (uint32_t)src[(n - (index * 4UL) - 1UL)]; } else if ((n % 4UL) == 2UL) { dst[index] = ((uint32_t)src[(n - (index * 4UL) - 1UL)]) \ | ((uint32_t)src[(n - (index * 4UL) - 2UL)] << 8UL); } else if ((n % 4UL) == 3UL) { dst[index] = ((uint32_t)src[(n - (index * 4UL) - 1UL)]) \ | ((uint32_t)src[(n - (index * 4UL) - 2UL)] << 8UL) \ | ((uint32_t)src[(n - (index * 4UL) - 3UL)] << 16UL); } else { /* The last element is already handle in the loop */ } } } } /** * @brief Copy uint32_t array to uint32_t array. * @param dst Pointer to destination * @param src Pointer to source * @param n Number of u32 to be handled * @retval dst */ void PKA_Memcpy_u32_to_u32(__IO uint32_t dst[], __IO const uint32_t src[], size_t n) { /* If a destination buffer is provided */ if (dst != NULL) { /* If a source buffer is provided */ if (src != NULL) { /* For each element in the array */ for (uint32_t index = 0UL; index < n; index++) { /* Copy the content */ dst[index] = src[index]; } } } } /** * @brief Generic function to start a PKA operation in blocking mode. * @param hpka PKA handle * @param mode PKA operation * @param Timeout Timeout duration * @retval HAL status */ HAL_StatusTypeDef PKA_Process(PKA_HandleTypeDef *hpka, uint32_t mode, uint32_t Timeout) { HAL_StatusTypeDef err = HAL_OK; uint32_t tickstart; if (hpka->State == HAL_PKA_STATE_READY) { /* Set the state to busy */ hpka->State = HAL_PKA_STATE_BUSY; /* Clear any pending error */ hpka->ErrorCode = HAL_PKA_ERROR_NONE; /* Init tickstart for timeout management*/ tickstart = HAL_GetTick(); /* Set the mode and deactivate the interrupts */ MODIFY_REG(hpka->Instance->CR, PKA_CR_MODE | PKA_CR_PROCENDIE | PKA_CR_RAMERRIE | PKA_CR_ADDRERRIE, mode << PKA_CR_MODE_Pos); /* Start the computation */ hpka->Instance->CR |= PKA_CR_START; /* Wait for the end of operation or timeout */ if (PKA_PollEndOfOperation(hpka, Timeout, tickstart) != HAL_OK) { /* Abort any ongoing operation */ CLEAR_BIT(hpka->Instance->CR, PKA_CR_EN); hpka->ErrorCode |= HAL_PKA_ERROR_TIMEOUT; /* Make ready for the next operation */ SET_BIT(hpka->Instance->CR, PKA_CR_EN); } /* Check error */ hpka->ErrorCode |= PKA_CheckError(hpka, mode); /* Clear all flags */ hpka->Instance->CLRFR |= (PKA_CLRFR_PROCENDFC | PKA_CLRFR_RAMERRFC | PKA_CLRFR_ADDRERRFC); /* Set the state to ready */ hpka->State = HAL_PKA_STATE_READY; /* Manage the result based on encountered errors */ if (hpka->ErrorCode != HAL_PKA_ERROR_NONE) { err = HAL_ERROR; } } else { err = HAL_ERROR; } return err; } /** * @brief Generic function to start a PKA operation in non-blocking mode with Interrupt. * @param hpka PKA handle * @param mode PKA operation * @retval HAL status */ HAL_StatusTypeDef PKA_Process_IT(PKA_HandleTypeDef *hpka, uint32_t mode) { HAL_StatusTypeDef err = HAL_OK; if (hpka->State == HAL_PKA_STATE_READY) { /* Set the state to busy */ hpka->State = HAL_PKA_STATE_BUSY; /* Clear any pending error */ hpka->ErrorCode = HAL_PKA_ERROR_NONE; /* Set the mode and activate interrupts */ MODIFY_REG(hpka->Instance->CR, PKA_CR_MODE | PKA_CR_PROCENDIE | PKA_CR_RAMERRIE | PKA_CR_ADDRERRIE, (mode << PKA_CR_MODE_Pos) | PKA_CR_PROCENDIE | PKA_CR_RAMERRIE | PKA_CR_ADDRERRIE); /* Start the computation */ hpka->Instance->CR |= PKA_CR_START; } else { err = HAL_ERROR; } return err; } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ModExp_Set(PKA_HandleTypeDef *hpka, PKA_ModExpInTypeDef *in) { /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_MODULAR_EXP_IN_OP_NB_BITS] = PKA_GetBitSize_u8(in->OpSize); /* Get the number of bit of the exponent */ hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXP_NB_BITS] = PKA_GetBitSize_u8(in->expSize); /* Move the input parameters pOp1 to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXPONENT_BASE], in->pOp1, in->OpSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_EXPONENT_BASE + ((in->OpSize + 3UL) / 4UL)); /* Move the exponent to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXPONENT], in->pExp, in->expSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_EXPONENT + ((in->expSize + 3UL) / 4UL)); /* Move the modulus to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_MODULUS], in->pMod, in->OpSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_MODULUS + ((in->OpSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ModExpFastMode_Set(PKA_HandleTypeDef *hpka, PKA_ModExpFastModeInTypeDef *in) { /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_MODULAR_EXP_IN_OP_NB_BITS] = PKA_GetBitSize_u8(in->OpSize); /* Get the number of bit of the exponent */ hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXP_NB_BITS] = PKA_GetBitSize_u8(in->expSize); /* Move the input parameters pOp1 to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXPONENT_BASE], in->pOp1, in->OpSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_EXPONENT_BASE + (in->OpSize / 4UL)); /* Move the exponent to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_EXPONENT], in->pExp, in->expSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_EXPONENT + (in->expSize / 4UL)); /* Move the modulus to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_MODULUS], in->pMod, in->OpSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_MODULUS + (in->OpSize / 4UL)); /* Move the Montgomery parameter to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_MODULAR_EXP_IN_MONTGOMERY_PARAM], in->pMontgomeryParam, in->OpSize / 4UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_EXP_IN_MONTGOMERY_PARAM + (in->OpSize / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ECDSASign_Set(PKA_HandleTypeDef *hpka, PKA_ECDSASignInTypeDef *in) { /* Get the prime order n length */ hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_ORDER_NB_BITS] = PKA_GetOptBitSize_u8(in->primeOrderSize, *(in->primeOrder)); /* Get the modulus p length */ hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_MOD_NB_BITS] = PKA_GetOptBitSize_u8(in->modulusSize, *(in->modulus)); /* Get the coefficient a sign */ hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_A_COEFF_SIGN] = in->coefSign; /* Move the input parameters coefficient |a| to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_A_COEFF], in->coef, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_A_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters modulus value p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_MOD_GF], in->modulus, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_MOD_GF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters integer k to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_K], in->integer, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_K + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters base point G coordinate x to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_INITIAL_POINT_X], in->basePointX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_INITIAL_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters base point G coordinate y to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_INITIAL_POINT_Y], in->basePointY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_INITIAL_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters hash of message z to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_HASH_E], in->hash, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_HASH_E + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters private key d to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_PRIVATE_KEY_D], in->privateKey, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_PRIVATE_KEY_D + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters prime order n to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_SIGN_IN_ORDER_N], in->primeOrder, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_SIGN_IN_ORDER_N + ((in->primeOrderSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ECDSAVerif_Set(PKA_HandleTypeDef *hpka, PKA_ECDSAVerifInTypeDef *in) { /* Get the prime order n length */ hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_ORDER_NB_BITS] = PKA_GetOptBitSize_u8(in->primeOrderSize, *(in->primeOrder)); /* Get the modulus p length */ hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_MOD_NB_BITS] = PKA_GetOptBitSize_u8(in->modulusSize, *(in->modulus)); /* Get the coefficient a sign */ hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_A_COEFF_SIGN] = in->coefSign; /* Move the input parameters coefficient |a| to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_A_COEFF], in->coef, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_A_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters modulus value p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_MOD_GF], in->modulus, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_MOD_GF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters base point G coordinate x to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_INITIAL_POINT_X], in->basePointX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_INITIAL_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters base point G coordinate y to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_INITIAL_POINT_Y], in->basePointY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_INITIAL_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters public-key curve point Q coordinate xQ to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_PUBLIC_KEY_POINT_X], in->pPubKeyCurvePtX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_PUBLIC_KEY_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters public-key curve point Q coordinate xQ to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_PUBLIC_KEY_POINT_Y], in->pPubKeyCurvePtY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_PUBLIC_KEY_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters signature part r to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_SIGNATURE_R], in->RSign, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_SIGNATURE_R + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters signature part s to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_SIGNATURE_S], in->SSign, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_SIGNATURE_S + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters hash of message z to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_HASH_E], in->hash, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_HASH_E + ((in->primeOrderSize + 3UL) / 4UL)); /* Move the input parameters curve prime order n to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECDSA_VERIF_IN_ORDER_N], in->primeOrder, in->primeOrderSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECDSA_VERIF_IN_ORDER_N + ((in->primeOrderSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_RSACRTExp_Set(PKA_HandleTypeDef *hpka, PKA_RSACRTExpInTypeDef *in) { /* Get the operand length M */ hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_MOD_NB_BITS] = PKA_GetBitSize_u8(in->size); /* Move the input parameters operand dP to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_DP_CRT], in->pOpDp, in->size / 2UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_DP_CRT + (in->size / 8UL)); /* Move the input parameters operand dQ to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_DQ_CRT], in->pOpDq, in->size / 2UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_DQ_CRT + (in->size / 8UL)); /* Move the input parameters operand qinv to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_QINV_CRT], in->pOpQinv, in->size / 2UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_QINV_CRT + (in->size / 8UL)); /* Move the input parameters prime p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_PRIME_P], in->pPrimeP, in->size / 2UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_PRIME_P + (in->size / 8UL)); /* Move the input parameters prime q to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_PRIME_Q], in->pPrimeQ, in->size / 2UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_PRIME_Q + (in->size / 8UL)); /* Move the input parameters operand A to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_RSA_CRT_EXP_IN_EXPONENT_BASE], in->popA, in->size); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_RSA_CRT_EXP_IN_EXPONENT_BASE + (in->size / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_PointCheck_Set(PKA_HandleTypeDef *hpka, PKA_PointCheckInTypeDef *in) { /* Get the modulus length */ hpka->Instance->RAM[PKA_POINT_CHECK_IN_MOD_NB_BITS] = PKA_GetOptBitSize_u8(in->modulusSize, *(in->modulus)); /* Get the coefficient a sign */ hpka->Instance->RAM[PKA_POINT_CHECK_IN_A_COEFF_SIGN] = in->coefSign; /* Move the input parameters coefficient |a| to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_A_COEFF], in->coefA, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_A_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters coefficient b to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_B_COEFF], in->coefB, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_B_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters modulus value p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_MOD_GF], in->modulus, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_MOD_GF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate x to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_INITIAL_POINT_X], in->pointX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_INITIAL_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate y to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_INITIAL_POINT_Y], in->pointY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_INITIAL_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ECCMul_Set(PKA_HandleTypeDef *hpka, PKA_ECCMulInTypeDef *in) { /* Get the scalar multiplier k length */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_EXP_NB_BITS] = PKA_GetOptBitSize_u8(in->scalarMulSize, *(in->scalarMul)); /* Get the modulus length */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_OP_NB_BITS] = PKA_GetOptBitSize_u8(in->modulusSize, *(in->modulus)); /* Get the coefficient a sign */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_A_COEFF_SIGN] = in->coefSign; /* Move the input parameters coefficient |a| to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_A_COEFF], in->coefA, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_A_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters modulus value p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_MOD_GF], in->modulus, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_MOD_GF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters scalar multiplier k to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_K], in->scalarMul, in->scalarMulSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_K + ((in->scalarMulSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate x to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_INITIAL_POINT_X], in->pointX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_INITIAL_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate y to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_INITIAL_POINT_Y], in->pointY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_INITIAL_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ECCMulFastMode_Set(PKA_HandleTypeDef *hpka, PKA_ECCMulFastModeInTypeDef *in) { /* Get the scalar multiplier k length */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_EXP_NB_BITS] = PKA_GetOptBitSize_u8(in->scalarMulSize, *(in->scalarMul)); /* Get the modulus length */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_OP_NB_BITS] = PKA_GetOptBitSize_u8(in->modulusSize, *(in->modulus)); /* Get the coefficient a sign */ hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_A_COEFF_SIGN] = in->coefSign; /* Move the input parameters coefficient |a| to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_A_COEFF], in->coefA, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_A_COEFF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters modulus value p to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_MOD_GF], in->modulus, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_MOD_GF + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters scalar multiplier k to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_K], in->scalarMul, in->scalarMulSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_K + ((in->scalarMulSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate x to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_INITIAL_POINT_X], in->pointX, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_INITIAL_POINT_X + ((in->modulusSize + 3UL) / 4UL)); /* Move the input parameters Point P coordinate y to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_POINT_CHECK_IN_INITIAL_POINT_Y], in->pointY, in->modulusSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_POINT_CHECK_IN_INITIAL_POINT_Y + ((in->modulusSize + 3UL) / 4UL)); /* Move the Montgomery parameter to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_ECC_SCALAR_MUL_IN_MONTGOMERY_PARAM], in->pMontgomeryParam, (in->modulusSize + 3UL) / 4UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ECC_SCALAR_MUL_IN_MONTGOMERY_PARAM + ((in->modulusSize + 3UL) / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ModInv_Set(PKA_HandleTypeDef *hpka, PKA_ModInvInTypeDef *in) { /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_MODULAR_INV_NB_BITS] = PKA_GetBitSize_u32(in->size); /* Move the input parameters operand A to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_MODULAR_INV_IN_OP1], in->pOp1, in->size); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_INV_IN_OP1 + in->size); /* Move the input parameters modulus value n to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_INV_IN_OP2_MOD], in->pMod, in->size * 4UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_INV_IN_OP2_MOD + in->size); } /** * @brief Set input parameters. * @param hpka PKA handle * @param in Input information */ void PKA_ModRed_Set(PKA_HandleTypeDef *hpka, PKA_ModRedInTypeDef *in) { /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_MODULAR_REDUC_IN_OP_LENGTH] = PKA_GetBitSize_u32(in->OpSize); /* Get the number of bit per modulus */ hpka->Instance->RAM[PKA_MODULAR_REDUC_IN_MOD_LENGTH] = PKA_GetBitSize_u8(in->modSize); /* Move the input parameters operand A to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_MODULAR_REDUC_IN_OPERAND], in->pOp1, in->OpSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_REDUC_IN_OPERAND + in->OpSize); /* Move the input parameters modulus value n to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MODULAR_REDUC_IN_MODULUS], in->pMod, in->modSize); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MODULAR_REDUC_IN_MODULUS + (in->modSize / 4UL)); } /** * @brief Set input parameters. * @param hpka PKA handle * @param size Size of the operand * @param pOp1 Generic pointer to input data */ void PKA_MontgomeryParam_Set(PKA_HandleTypeDef *hpka, const uint32_t size, const uint8_t *pOp1) { uint32_t bytetoskip = 0UL; uint32_t newSize; if (pOp1 != NULL) { /* Count the number of zero bytes */ while ((bytetoskip < size) && (pOp1[bytetoskip] == 0UL)) { bytetoskip++; } /* Get new size after skipping zero bytes */ newSize = size - bytetoskip; /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_MONTGOMERY_PARAM_IN_MOD_NB_BITS] = PKA_GetOptBitSize_u8(newSize, pOp1[bytetoskip]); /* Move the input parameters pOp1 to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_MONTGOMERY_PARAM_IN_MODULUS], pOp1, size); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_MONTGOMERY_PARAM_IN_MODULUS + ((size + 3UL) / 4UL)); } } /** * @brief Generic function to set input parameters. * @param hpka PKA handle * @param size Size of the operand * @param pOp1 Generic pointer to input data * @param pOp2 Generic pointer to input data * @param pOp3 Generic pointer to input data */ void PKA_ARI_Set(PKA_HandleTypeDef *hpka, const uint32_t size, const uint32_t *pOp1, const uint32_t *pOp2, const uint8_t *pOp3) { /* Get the number of bit per operand */ hpka->Instance->RAM[PKA_ARITHMETIC_ALL_OPS_NB_BITS] = PKA_GetBitSize_u32(size); if (pOp1 != NULL) { /* Move the input parameters pOp1 to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_ARITHMETIC_ALL_OPS_IN_OP1], pOp1, size); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ARITHMETIC_ALL_OPS_IN_OP1 + size); } if (pOp2 != NULL) { /* Move the input parameters pOp2 to PKA RAM */ PKA_Memcpy_u32_to_u32(&hpka->Instance->RAM[PKA_ARITHMETIC_ALL_OPS_IN_OP2], pOp2, size); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ARITHMETIC_ALL_OPS_IN_OP2 + size); } if (pOp3 != NULL) { /* Move the input parameters pOp3 to PKA RAM */ PKA_Memcpy_u8_to_u32(&hpka->Instance->RAM[PKA_ARITHMETIC_ALL_OPS_IN_OP3], pOp3, size * 4UL); __PKA_RAM_PARAM_END(hpka->Instance->RAM, PKA_ARITHMETIC_ALL_OPS_IN_OP3 + size); } } /** * @} */ /** * @} */ #endif /* defined(PKA) && defined(HAL_PKA_MODULE_ENABLED) */ /** * @} */