1443 lines
64 KiB
C
1443 lines
64 KiB
C
/**
|
|
* @file Crypto_Level2Api.c
|
|
* @version 0.8.0
|
|
*
|
|
* @brief AUTOSAR Crypto - Low level part of CRY driver.
|
|
* @details Hardware security module (HSM) provides several standards based cryptographic
|
|
* services and security services.
|
|
*
|
|
* @addtogroup CRYPTO
|
|
* @{
|
|
*/
|
|
/*==================================================================================================
|
|
* PERIPHERAL : CRYPTO,MAILBOX
|
|
* PLATFORM : Flagchip FC7300
|
|
* AUTOSAR VERSION : 4.6.0
|
|
* AUTOSAR REVISION : ASR_REL_R20-11
|
|
* SOFTWARE VERSION : 0.8.0
|
|
* VENDOR : Flagchip Semiconductors
|
|
*
|
|
* Copyright 2020-2023 Flagchip Semiconductors Co., Ltd.
|
|
* All Rights Reserved.
|
|
==================================================================================================*/
|
|
/*==================================================================================================
|
|
* Revision History:
|
|
*
|
|
* Version Date Initials CR# Descriptions
|
|
* --------- ---------- ------------- ---------- ---------------
|
|
* 0.1.0 15/02/2024 QXW0051 N/A CRYPTO Initial Version
|
|
* 0.6.0 23/03/2024 QXW0071 N/A Add Support For FC7240
|
|
==================================================================================================*/
|
|
|
|
#include "module_driver_hsm.h"
|
|
#include "module_driver_hsm_level1_leveln.h"
|
|
|
|
/********************************************* Level1 function *********************************************************/
|
|
HSM_StatusType hsm_1B4B_convert_from_idx(HSM_DataFormatType eDstFmt, void *pDst, hsm_uint32_t u32DstStartIdx, hsm_uint32_t u32DstBufByteSize,
|
|
HSM_DataFormatType eSrcFmt, const void *pSrc, hsm_uint32_t u32SrcStartIdx, hsm_uint32_t u32SrcStopIdx);
|
|
void hsm_bidi_memcpy(void *pDstMem, const void *pSrcMem, hsm_uint32_t u32OpCnt, hsm_int32_t sOpDirection);
|
|
void hsm_memcpy(void *pDstMem, const void *pSrcMem, hsm_uint32_t u32Cnt);
|
|
void hsm_memset(void *pDstMem, hsm_uint8_t u8Val, hsm_uint32_t u32Cnt);
|
|
hsm_int32_t hsm_memcmp(const void *pDst, const void *pSrc, hsm_uint32_t u32OpCnt);
|
|
HSM_StatusType hsm_hash_get_result_byte_count(HFAM_MODE_E eMode, hsm_uint32_t *pRetByteCnt);
|
|
void hsm_u32_array_swap(hsm_uint32_t *pData, hsm_uint32_t u32WordCnt);
|
|
void hsm_u32_array_swap_to(hsm_uint32_t *pData, const hsm_uint32_t *pSrc, hsm_uint32_t u32WordCnt);
|
|
void hsm_rm_prefix_zeros(
|
|
HSM_DataFormatType eInputFmt, const hsm_uint8_t *pData, hsm_uint32_t u32ByteCount, const hsm_uint8_t **ppActualData, hsm_uint32_t *pActualByteCnt);
|
|
void hsm_core_swap_u32_array_pad(
|
|
hsm_uint32_t *pAlignedDest, hsm_uint32_t u32DestWordCnt, const hsm_uint8_t *pSrc,
|
|
hsm_uint32_t u32SrcOpByteCnt, hsm_uint8_t u8PadByte, HSM_BoolType bPadFromMSB, HSM_BoolType bSwap);
|
|
void HSM_L1_CleanEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CommonExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Abort(HSM_L1_RtCtxType *pCtx);
|
|
void HSM_L1_Init(HSM_L1_RtCtxType *pCtx, HSM_L1_InitParmType *pParm);
|
|
HSM_StatusType HSM_L1_Md5SetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Md5Reset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Md5ExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Md5(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Md5Type *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Md5_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Md5Poll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm3SetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm3Reset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm3ExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm3(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm3Type *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Sm3_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm3Poll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ShaSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ShaReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ShaExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sha(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ShaType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Sha_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ShaPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RngSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RngReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RngExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Rng(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RngType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Rng_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RngPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccVerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt);
|
|
HSM_StatusType HSM_L1_EccVerifyExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccVerify(HSM_L1_RtCtxType *pCtx, const HSM_L1_EccVerifyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_EccVerify_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccVerifyPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccVerifyReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccDecryptSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt);
|
|
HSM_StatusType HSM_L1_EccDecryptExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccDecrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccDecryptType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_EccDecrypt_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccDecryptPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccDecryptReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccCalculateSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt);
|
|
HSM_StatusType HSM_L1_EccCalculateExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccCalculateKP(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccKPType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_EccCalculate_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccCalculatePoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccCalculateReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CMacSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CMacReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CMacExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CMac(HSM_L1_RtCtxType *pCtx, const HSM_Ln_CMacType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_CMac_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_CMacPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesEncryptSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesEncryptReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesEncryptExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesEncrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_AesEncryptType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_AesEncrypt_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesEncryptPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesDecryptSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesDecryptReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesDecryptExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesDecrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_AesDecryptType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_AesDecrypt_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_AesDecryptPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4EncryptSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4EncryptReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4EncryptExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4Encrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm4EncryptType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Sm4Encrypt_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4EncryptPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4DecryptSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4DecryptReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4DecryptExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4Decrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm4DecryptType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_Sm4Decrypt_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_Sm4DecryptPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_BnCalcSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_BnCalcExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
hsm_uint32_t hsm_pkam_get_actual_size(HSM_DataFormatType eDataFormat, const void *pData, hsm_uint32_t u32ByteCount, const hsm_uint8_t **ppLastNonZero);
|
|
HSM_StatusType hsm_pkam_get_bn_bit_count(HSM_DataFormatType eFmt, const hsm_uint8_t *pData, hsm_uint32_t u32ByteCnt, hsm_uint32_t *pBitCnt);
|
|
HSM_StatusType HSM_L1_BnCalc(HSM_L1_RtCtxType *pCtx, const HSM_L1_BnCalcType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_BnCalc_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_BnCalcPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_BnCalcReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterHashSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterHashSetMacCfg(HSM_L1_RtCtxType *pCtx, HSM_Ln_HashMacCfgType *ptCfg);
|
|
HSM_StatusType HSM_L1_ScatterHashInit(HSM_L1_RtCtxType *pCtx, const HSM_ShaAlgType eAlg, const HSM_Ln_ScatterHashType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_ScatterHashUpdate(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterHashType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType hsm_aux_get_empty_data_hash(HSM_ShaAlgType eHash, const hsm_uint8_t **ppHashData, hsm_uint32_t *pByteCnt);
|
|
HSM_StatusType HSM_L1_ScatterHashFinal(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterHashType *pCfg, const HSM_Ln_ResultBufInfoType *pResult, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_ScatterHash_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterHashPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterHashExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterCMacSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterCMacInit(HSM_L1_RtCtxType *pCtx, const HSM_Ln_CMacCfgParmsType *pKeyCfg, const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_ScatterCMacUpdate(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_ScatterCMacFinal(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterCMacType *pCfg, const HSM_Ln_ResultBufInfoType *pResult, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_ScatterCMac_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterCMacPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_ScatterCMacExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccSignSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt);
|
|
HSM_StatusType HSM_L1_EccSignExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccSign(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccSignType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_EccSign_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccSignPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_EccSignReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32RsaBitCnt);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerify(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssVerifyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerifyPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerifyReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerify_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssVerifyExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32RsaBitCnt);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15Verify(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1v15VerifyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15Verify_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyImportSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyImport(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ImportUserKeyExtType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeyImportPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyImportReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyImportExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyImport_Isr(HSM_L1_RtCtxType *pCtx);
|
|
#if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM))
|
|
HSM_StatusType HSM_L1_KeyValidateSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyValidate(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeyValidatePoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyValidateReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyValidateExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyValidate_Isr(HSM_L1_RtCtxType *pCtx);
|
|
#endif
|
|
#if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM))
|
|
#else
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContentSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContent(HSM_L1_RtCtxType *pCtx, const HSM_Ln_KeyManagerUpdateUserKeyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContentPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContentReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContentExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_UpdateKeyIdContent_Isr(HSM_L1_RtCtxType *pCtx);
|
|
#endif
|
|
HSM_StatusType HSM_L1_KeyCopySetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyCopy(HSM_L1_RtCtxType *pCtx, const HSM_Ln_CopyUserKeyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeyCopyPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyCopyReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyCopyExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyCopy_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyRevokeSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyRevoke(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeyRevokePoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyRevokeReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyRevokeExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeyRevoke_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyUpSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyUp(HSM_L1_RtCtxType *pCtx, HSM_Ln_KeySpaceStatusType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyUpPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyUpReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyUpExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceTidyup_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatusSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatus(HSM_L1_RtCtxType *pCtx, HSM_Ln_KeySpaceStatusType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatusPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatusReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatusExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_KeySpaceGetStatus_Isr(HSM_L1_RtCtxType *pCtx);
|
|
#if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM))
|
|
HSM_StatusType HSM_L1_GetKeyIdStatusSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_GetKeyIdStatus(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_GetKeyIdStatusPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_GetKeyIdStatusReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_GetKeyIdStatusExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_GetKeyIdStatus_Isr(HSM_L1_RtCtxType *pCtx);
|
|
#endif
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignHash(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1V15SignHashType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignData(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1V15SignDataType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPkcs1V15Sign_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignSetupEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignData(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssSignDataType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignHash(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssSignHashType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignPoll(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignReset(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSignExitEnv(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_RsaSsaPssSign_Isr(HSM_L1_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L1_PKCS1_GetRsaPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_RsaPrivateKeyInfType *pInf);
|
|
HSM_StatusType HSM_L1_PKCS1_GetEccPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_EccPrivateKeyInfType *pInf);
|
|
HSM_StatusType HSM_L1_PKCS8_GetPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS8_PrivateKeyInfType *pInf);
|
|
HSM_StatusType HSM_L1_PKCS1_GetRsaPublicKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_RsaPublicKeyInfType *pInf);
|
|
HSM_StatusType hsm_l1_subjectpublicinfo_bitstring_geteccpublickeyinf(const hsm_uint8_t *pDer, HSM_L1_PKCS_EccPublicKeyInfType *pInf);
|
|
HSM_StatusType HSM_L1_SubjectPublicInfo_GetPublicKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PublicKeyInfType *pInf);
|
|
HSM_StatusType HSM_L1_GetPoll(HSM_L1_RtCtxType *pCtx);
|
|
void HSM_L1_Ack_IrqHandler(void *pUpperCtx, HSM_StatusType eRet);
|
|
|
|
/********************************************* Level2 function *********************************************************/
|
|
HSM_StatusType hsm_l2_cmac_empty_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs, HSM_L2_DrvCMacEmptyInfType *pCfg,
|
|
HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
HSM_StatusType hsm_l2_revoke_key_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs, HSM_L2_DrvRevokeKeyInfType *pCfg,
|
|
HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
HSM_StatusType hsm_l2_ecc_verify_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs, HSM_L2_DrvEccVerifyInfType *pCfg,
|
|
HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
|
|
HSM_StatusType HSM_L2_CMacEmptySetupEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_CMacEmptyReset(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_CMacEmptyExitEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType hsm_l2_cmac_empty_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L2_DrvCMacEmptyInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
HSM_StatusType HSM_L2_CMacEmpty(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_CMacCfgParmsType *pKeyCfg, const HSM_Ln_ResultBufInfoType *pResult,
|
|
hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_CMacEmptyPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
#if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)
|
|
HSM_StatusType hsm_l2_update_key_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L2_DrvUpdateKeyInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
#else
|
|
HSM_StatusType hsm_l2_update_key_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L2_DrvUpdateKeyInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
#endif
|
|
HSM_StatusType HSM_L2_UpdateKeySetupEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_UpdateKeyReset(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_UpdateKey(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_ImportUserKeyExtType *pKeyCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_UpdateKeyPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_UpdateKeyExitEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_RevokeKeySetupEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_RevokeKeyReset(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_RevokeKey(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_RevokeKeyPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_RevokeKeyExitEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType hsm_l2_ecc_verify_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L2_DrvEccVerifyInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
HSM_StatusType HSM_L2_EccVerifySetupEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32BitCnt);
|
|
HSM_StatusType HSM_L2_EccVerifyReset(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_EccVerify(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_EccVerifyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_EccVerifyPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_EccVerifyExitEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
|
|
HSM_StatusType HSM_L2_Sm2VerifySetupEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_Sm2VerifyReset(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L2_Sm2Verify(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_Sm2VerifyType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_Sm2VerifyPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L2_Sm2VerifyExitEnv(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
|
|
void HSM_L2_Ack_IrqHandler(void *pUpperCtx, HSM_BoolType bIsErrorHappen, HSM_StatusType eRet);
|
|
void HSM_L2_Init(HSM_L2_RtCtxType *pCtx, HSM_L2_InitParmType *pParm);
|
|
void HSM_L2_CleanEnv(HSM_L2_RtCtxType *pCtx);
|
|
void HSM_L2_Abort(HSM_L2_RtCtxType *pCtx);
|
|
void HSM_L2_CommonExitEnv(HSM_L2_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L2_GetPoll(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType hsm_l2_revoke_key_process(HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L2_DrvRevokeKeyInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
|
|
/****************************************** Local function declarations ***********************************************/
|
|
HSM_StatusType HSM_L3_ScatterCMacSetupEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L3_ScatterCMacReset(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L3_ScatterCMacExitEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L3_ScatterCMacInit(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_CMacCfgParmsType *pKeyCfg,
|
|
const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L3_ScatterCMacUpdate(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_ScatterCMacType *pCfg,
|
|
hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L3_ScatterCMacFinal(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_ScatterCMacType *pCfg,
|
|
const HSM_Ln_ResultBufInfoType *pResult, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L3_ScatterCMacPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L3_UpdateKeySetupEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L3_UpdateKeyReset(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
HSM_StatusType HSM_L3_UpdateKeyExitEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx);
|
|
void hsm_core_padding_and_swap_array(
|
|
hsm_uint32_t *pAlignedDest, hsm_uint32_t u32DestOpWordCnt, const void *pSrcData,
|
|
hsm_uint32_t u32SrcOpByteCnt, HSM_DataFormatType eSrcFmt, hsm_uint8_t u8PadByte, HSM_BoolType bPadFromMSB, HSM_BoolType bSwap);
|
|
void hsm_pkam_u32_array_append_zero_from_left(hsm_uint8_t *pDest, const hsm_uint8_t *pSrc, hsm_uint32_t u32SrcByteCnt, hsm_uint32_t u32ZeroByteCnt);
|
|
const hsm_uint32_t *hsm_pkam_get_loadable_buf(HSM_DataFormatType eInputFmt, hsm_uint32_t *pCacheBufferMayUse,
|
|
hsm_uint32_t u32LastCacheByteCnt, const hsm_uint32_t *pSrc, hsm_uint32_t u32SrcByteCnt, hsm_uint32_t u32LoadByteCount);
|
|
HSM_StatusType HSM_L3_UpdatePlainKey(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx,
|
|
const HSM_Ln_PlainKeyImport *pPlainKey, hsm_uint32_t u32TimeoutMs);
|
|
HSM_StatusType HSM_L3_UpdateKeyPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
void HSM_L3_Ack_IrqHandler(void *pUpperCtx, HSM_BoolType bErrorHappen, HSM_StatusType eRet);
|
|
void HSM_L3_Init(HSM_L3_RtCtxType *pCtx, HSM_L3_InitParmType *pParm);
|
|
void HSM_L3_CleanEnv(HSM_L3_RtCtxType *pCtx);
|
|
void HSM_L3_Abort(HSM_L3_RtCtxType *pCtx);
|
|
void HSM_L3_CommonExitEnv(HSM_L3_RtCtxType *pCtx);
|
|
HSM_StatusType HSM_L3_GetPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs);
|
|
|
|
|
|
static HSM_StatusType hsm_scatter_cmac_process(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L3_DrvScatterCMacInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode);
|
|
|
|
/********************************************* Global function *********************************************************/
|
|
HSM_StatusType HSM_L3_ScatterCMacSetupEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
(void)pL2Ctx;
|
|
(void)pL1Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_NONE == pL3Ctx->eOperation)
|
|
{
|
|
pL3Ctx->eOperation = HSM_LEVEL_3RD_OP_SCATTER_CMAC;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_READY;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = 0u;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacReset(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
(void)pL2Ctx;
|
|
(void)pL1Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L1_Abort(pL1Ctx);
|
|
HSM_L2_Abort(pL2Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_READY;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
return eRet;
|
|
}
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacExitEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L1_Abort(pL1Ctx);
|
|
HSM_L2_Abort(pL2Ctx);
|
|
pL3Ctx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacInit(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_CMacCfgParmsType *pKeyCfg,
|
|
const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
(void)pL2Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
if (pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_READY)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
if (pCfg->u32DataSize > 0)
|
|
{
|
|
eRet = HSM_L1_ScatterCMacSetupEnv(pL1Ctx);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_INIT;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L1_ScatterCMacInit(pL1Ctx, pKeyCfg, pCfg, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else if (HSM_STATUS_AGAIN == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_INIT;
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = 0u;
|
|
hsm_memcpy(&(pL3Ctx->tL3AlgCtx.tScatterCMac.tCfgParm), pKeyCfg, sizeof(pL3Ctx->tL3AlgCtx.tScatterCMac.tCfgParm));
|
|
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_EMPTY_INPUT;
|
|
eRet = HSM_STATUS_AGAIN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_LOGIC_ERR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacUpdate(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
(void)pL2Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
if ((pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_INIT) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_INIT_OK) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_UPDATE) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_UPDATE_OK))
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_UPDATE;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize += pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L1_ScatterCMacUpdate(pL1Ctx, pCfg, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else if (HSM_STATUS_AGAIN == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_UPDATE;
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else if (pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_EMPTY_INPUT)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
if (pCfg->u32DataSize > 0)
|
|
{
|
|
eRet = HSM_L1_ScatterCMacSetupEnv(pL1Ctx);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_INIT;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L1_ScatterCMacInit(pL1Ctx, &(pL3Ctx->tL3AlgCtx.tScatterCMac.tCfgParm), pCfg, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else if (HSM_STATUS_AGAIN == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_INIT;
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_AGAIN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_LOGIC_ERR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacFinal(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, const HSM_Ln_ScatterCMacType *pCfg,
|
|
const HSM_Ln_ResultBufInfoType *pResult, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
if ((pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_INIT) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_INIT_OK) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_NEED_MORE_AFTER_UPDATE) ||
|
|
(pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_UPDATE_OK))
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_FINAL;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize += pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L1_ScatterCMacFinal(pL1Ctx, pCfg, pResult, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else if (pL3Ctx->tL3AlgCtx.tScatterCMac.eState == HSM_L3_SCATTER_CMAC_EMPTY_INPUT)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
if (pCfg->u32DataSize > 0)
|
|
{
|
|
eRet = HSM_L1_ScatterCMacSetupEnv(pL1Ctx);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_FINAL;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L1_ScatterCMacInit(pL1Ctx, &(pL3Ctx->tL3AlgCtx.tScatterCMac.tCfgParm), NULL_PTR, u32TimeoutMs);
|
|
if (HSM_STATUS_AGAIN == eRet)
|
|
{
|
|
eRet = HSM_L1_ScatterCMacFinal(pL1Ctx, pCfg, pResult, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_L2_CMacEmptySetupEnv(pL2Ctx, pL1Ctx);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_FINAL;
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize;
|
|
|
|
eRet = HSM_L2_CMacEmpty(pL2Ctx, pL1Ctx, &(pL3Ctx->tL3AlgCtx.tScatterCMac.tCfgParm), pResult, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
HSM_L2_CMacEmptyExitEnv(pL2Ctx, pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_LOGIC_ERR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
static HSM_StatusType hsm_scatter_cmac_process(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs,
|
|
HSM_L3_DrvScatterCMacInfType *pCfg, HSM_StatusType eRetFromPrevious, HSM_TriggerSrcType bTriggerMode)
|
|
{
|
|
HSM_StatusType eRet;
|
|
HSM_StatusType eTempRetFromPrevious = eRetFromPrevious;
|
|
|
|
|
|
switch (pCfg->eState)
|
|
{
|
|
case HSM_L3_SCATTER_CMAC_INIT:
|
|
{
|
|
if (HSM_TRIGGER_SRC_ISR == bTriggerMode)
|
|
{
|
|
; /* nothing to do */
|
|
}
|
|
else
|
|
{
|
|
eTempRetFromPrevious = HSM_L1_ScatterCMacPoll(pL1Ctx);
|
|
if ((HSM_STATUS_AGAIN != eTempRetFromPrevious) && (HSM_STATUS_SUCCESS != eTempRetFromPrevious))
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
}
|
|
}
|
|
|
|
if (HSM_STATUS_SUCCESS == eTempRetFromPrevious)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_INIT_OK;
|
|
eRet = HSM_STATUS_SUCCESS;
|
|
}
|
|
else if ((HSM_TRIGGER_SRC_ISR != bTriggerMode) && (HSM_STATUS_AGAIN == eTempRetFromPrevious))
|
|
{
|
|
eRet = HSM_STATUS_AGAIN;
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HSM_L3_SCATTER_CMAC_UPDATE:
|
|
{
|
|
if (HSM_TRIGGER_SRC_ISR == bTriggerMode)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
eTempRetFromPrevious = HSM_L1_ScatterCMacPoll(pL1Ctx);
|
|
if ((HSM_STATUS_AGAIN != eTempRetFromPrevious) && (HSM_STATUS_SUCCESS != eTempRetFromPrevious))
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
}
|
|
}
|
|
|
|
if (HSM_STATUS_SUCCESS == eTempRetFromPrevious)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_UPDATE_OK;
|
|
eRet = HSM_STATUS_SUCCESS;
|
|
}
|
|
else if ((HSM_TRIGGER_SRC_ISR != bTriggerMode) && (HSM_STATUS_AGAIN == eTempRetFromPrevious))
|
|
{
|
|
eRet = HSM_STATUS_AGAIN;
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HSM_L3_SCATTER_CMAC_FINAL:
|
|
{
|
|
if (HSM_TRIGGER_SRC_ISR == bTriggerMode)
|
|
{
|
|
HSM_L1_CommonExitEnv(pL1Ctx);
|
|
HSM_L2_CommonExitEnv(pL2Ctx);
|
|
}
|
|
else
|
|
{
|
|
if (pL3Ctx->tL3AlgCtx.tScatterCMac.u32InputTotalSize > 0u)
|
|
{
|
|
eTempRetFromPrevious = HSM_L1_ScatterCMacPoll(pL1Ctx);
|
|
if (HSM_STATUS_AGAIN != eTempRetFromPrevious)
|
|
{
|
|
HSM_L1_ScatterCMacExitEnv(pL1Ctx);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eTempRetFromPrevious = HSM_L2_CMacEmptyPoll(pL2Ctx, pL1Ctx, u32TimeoutMs);
|
|
if (HSM_STATUS_AGAIN != eTempRetFromPrevious)
|
|
{
|
|
HSM_L2_CMacEmptyExitEnv(pL2Ctx, pL1Ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (HSM_STATUS_SUCCESS == eTempRetFromPrevious)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
eRet = HSM_STATUS_SUCCESS;
|
|
}
|
|
else if ((HSM_TRIGGER_SRC_ISR != bTriggerMode) && (HSM_STATUS_AGAIN == eTempRetFromPrevious))
|
|
{
|
|
eRet = HSM_STATUS_AGAIN;
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tScatterCMac.eState = HSM_L3_SCATTER_CMAC_STOP;
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
eRet = HSM_STATUS_LOGIC_ERR;
|
|
break;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
|
|
|
|
HSM_StatusType HSM_L3_ScatterCMacPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
eRet = hsm_scatter_cmac_process(pL3Ctx, pL2Ctx, pL1Ctx, u32TimeoutMs, &(pL3Ctx->tL3AlgCtx.tScatterCMac), HSM_STATUS_SUCCESS, pL1Ctx->eTriggerSrc);
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------- */
|
|
/* --------------------------------------------------------------------------- */
|
|
|
|
HSM_StatusType HSM_L3_UpdateKeySetupEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
(void)pL2Ctx;
|
|
(void)pL1Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_NONE == pL3Ctx->eOperation)
|
|
{
|
|
pL3Ctx->eOperation = HSM_LEVEL_3RD_OP_UPDATE_KEY;
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.eState = HSM_L3_UPDATE_KEY_READY;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
HSM_StatusType HSM_L3_UpdateKeyReset(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
(void)pL2Ctx;
|
|
(void)pL1Ctx;
|
|
|
|
if (HSM_LEVEL_3RD_OP_UPDATE_KEY == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L1_Abort(pL1Ctx);
|
|
HSM_L2_Abort(pL2Ctx);
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.eState = HSM_L3_UPDATE_KEY_READY;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
return eRet;
|
|
}
|
|
|
|
HSM_StatusType HSM_L3_UpdateKeyExitEnv(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx)
|
|
{
|
|
HSM_StatusType eRet = HSM_STATUS_SUCCESS;
|
|
|
|
if (HSM_LEVEL_3RD_OP_UPDATE_KEY == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L1_Abort(pL1Ctx);
|
|
HSM_L2_Abort(pL2Ctx);
|
|
pL3Ctx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
void hsm_core_padding_and_swap_array(
|
|
hsm_uint32_t *pAlignedDest, hsm_uint32_t u32DestOpWordCnt, const void *pSrcData,
|
|
hsm_uint32_t u32SrcOpByteCnt, HSM_DataFormatType eSrcFmt, hsm_uint8_t u8PadByte, HSM_BoolType bPadFromMSB, HSM_BoolType bSwap)
|
|
{
|
|
hsm_uint32_t u32Idx = 0;
|
|
hsm_uint32_t u32Temp;
|
|
hsm_uint32_t u32Data;
|
|
hsm_uint32_t u32DestIdx;
|
|
const hsm_uint32_t *pSrc = (const hsm_uint32_t *)pSrcData;
|
|
hsm_uint32_t u32DestWordCnt = u32DestOpWordCnt;
|
|
hsm_uint32_t u32SrcByteCnt = u32SrcOpByteCnt;
|
|
|
|
if ((u32DestWordCnt << 2u) < u32SrcByteCnt)
|
|
{
|
|
u32SrcByteCnt = (u32DestWordCnt << 2u);
|
|
}
|
|
|
|
u32Temp = u32SrcByteCnt >> 2u; /* the word cnt, remove the extra bytes */
|
|
|
|
if (0u == (((hsm_uint32_t)pSrc) & 0x3u))
|
|
{
|
|
if (HSM_FALSE != bSwap)
|
|
{
|
|
for (; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
pAlignedDest[u32Idx] = hsm_hw_swap_u32(pSrc[u32Idx]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
pAlignedDest[u32Idx] = pSrc[u32Idx];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (HSM_FALSE != bSwap)
|
|
{
|
|
for (; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
u32DestIdx = (hsm_uint32_t)pSrc + (u32Idx * 4);
|
|
|
|
u32Data = *((hsm_uint8_t *)u32DestIdx + 3);
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 2));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 1));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 0));
|
|
|
|
pAlignedDest[u32Idx] = hsm_hw_swap_u32(u32Data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
u32DestIdx = (hsm_uint32_t)pSrc + (u32Idx * 4);
|
|
|
|
u32Data = *((hsm_uint8_t *)u32DestIdx + 3);
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 2));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 1));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32DestIdx + 0));
|
|
|
|
pAlignedDest[u32Idx] = (u32Data);
|
|
}
|
|
}
|
|
}
|
|
|
|
u32DestIdx = u32Idx;
|
|
|
|
u32Temp = (u32SrcByteCnt % 4u);
|
|
if (0u != u32Temp)
|
|
{
|
|
u32Temp = 4u - u32Temp; /* 1-3 -> 3-1, get the pad byte cnt */
|
|
u32SrcByteCnt = (hsm_uint32_t)pSrc + (u32Idx * 4);
|
|
u32Data = 0u;
|
|
|
|
if (HSM_DATA_FORMAT_1B == eSrcFmt)
|
|
{
|
|
/* be careful to not read exceed the border */
|
|
if (u32Temp == 1u) /* pad 1 byte, so can read 3bytes */
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 2));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 1));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 0));
|
|
}
|
|
else if (u32Temp == 2u)
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 1));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 0));
|
|
}
|
|
else
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 0));
|
|
}
|
|
}
|
|
else /* source is 4B format */
|
|
{
|
|
/* be careful to not read exceed the border */
|
|
if (u32Temp == 1u) /* pad 1 byte, so can read 3bytes */
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 3));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 2));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 1));
|
|
u32Data = (u32Data << 8u); /* & 0xFFFFFF00u */
|
|
}
|
|
else if (u32Temp == 2u)
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 3));
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 2));
|
|
u32Data = (u32Data << 16u); /* & 0xFFFF0000u */
|
|
}
|
|
else
|
|
{
|
|
u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 3));
|
|
u32Data = (u32Data << 24u); /* & 0xFF000000u */
|
|
}
|
|
}
|
|
|
|
if (HSM_FALSE != bPadFromMSB) /* pad data at the high address of the last word of the input buffer */
|
|
{
|
|
u32Data = u32Data << (u32Temp * 8u);
|
|
|
|
for (u32Idx = 0; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
u32Data = (u32Data >> 8u) | (((hsm_uint32_t)u8PadByte) << 24u);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u32Data = u32Data >> (u32Temp * 8u);
|
|
|
|
for (u32Idx = 0; u32Idx < u32Temp; ++u32Idx)
|
|
{
|
|
u32Data = (u32Data << 8u) | (((hsm_uint32_t)u8PadByte));
|
|
}
|
|
}
|
|
|
|
if (HSM_FALSE != bSwap)
|
|
{
|
|
pAlignedDest[u32DestIdx] = hsm_hw_swap_u32(u32Data);
|
|
}
|
|
else
|
|
{
|
|
pAlignedDest[u32DestIdx] = (u32Data);
|
|
}
|
|
u32DestIdx++;
|
|
}
|
|
|
|
|
|
hsm_memset(pAlignedDest + u32DestIdx, u8PadByte, (u32DestWordCnt << 2u) - (u32DestIdx << 2u));
|
|
}
|
|
|
|
void hsm_pkam_u32_array_append_zero_from_left(hsm_uint8_t *pDest, const hsm_uint8_t *pSrc, hsm_uint32_t u32SrcByteCnt, hsm_uint32_t u32ZeroByteCnt)
|
|
{
|
|
hsm_uint32_t u32PadZeroTailCnt;
|
|
hsm_uint32_t u32Left;
|
|
hsm_uint8_t *pDestInter;
|
|
const hsm_uint8_t *pSrcInter;
|
|
hsm_uint8_t u8Data;
|
|
|
|
if (0u == u32ZeroByteCnt)
|
|
{
|
|
if (pDest != pSrc)
|
|
{
|
|
hsm_bidi_memcpy(pDest, pSrc, u32SrcByteCnt, 1);
|
|
}
|
|
else
|
|
{
|
|
; /* nothing to do */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSrcInter = pSrc;
|
|
u32Left = u32SrcByteCnt;
|
|
pDestInter = pDest + u32ZeroByteCnt;
|
|
hsm_memset(pDest, 0, u32ZeroByteCnt);
|
|
while (u32Left > 3u)
|
|
{
|
|
pDestInter[0] = pSrcInter[3];
|
|
pDestInter[1] = pSrcInter[2];
|
|
pDestInter[2] = pSrcInter[1];
|
|
pDestInter[3] = pSrcInter[0];
|
|
u32Left -= 4u;
|
|
pDestInter += 4u;
|
|
pSrcInter += 4u;
|
|
}
|
|
|
|
if (3u == u32Left)
|
|
{
|
|
pDestInter[0] = pSrcInter[3];
|
|
pDestInter[1] = pSrcInter[2];
|
|
pDestInter[2] = pSrcInter[1];
|
|
pDestInter += 3u;
|
|
}
|
|
else if (2u == u32Left)
|
|
{
|
|
pDestInter[0] = pSrcInter[3];
|
|
pDestInter[1] = pSrcInter[2];
|
|
pDestInter += 2u;
|
|
}
|
|
else if (1u == u32Left)
|
|
{
|
|
pDestInter[0] = pSrcInter[3];
|
|
pDestInter += 1u;
|
|
}
|
|
else
|
|
{
|
|
; /* nothing to do */
|
|
}
|
|
|
|
u32PadZeroTailCnt = 4u - ((u32SrcByteCnt + u32ZeroByteCnt) % 4u);
|
|
hsm_memset(pDestInter, 0, u32PadZeroTailCnt);
|
|
|
|
u32Left = u32ZeroByteCnt + u32SrcByteCnt + u32PadZeroTailCnt;
|
|
pDestInter = pDest;
|
|
while (u32Left > 3u)
|
|
{
|
|
u8Data = pDestInter[3];
|
|
pDestInter[3] = pDestInter[0];
|
|
pDestInter[0] = u8Data;
|
|
|
|
u8Data = pDestInter[2];
|
|
pDestInter[2] = pDestInter[1];
|
|
pDestInter[1] = u8Data;
|
|
|
|
u32Left -= 4u;
|
|
pDestInter += 4u;
|
|
}
|
|
}
|
|
}
|
|
|
|
const hsm_uint32_t *hsm_pkam_get_loadable_buf(HSM_DataFormatType eInputFmt, hsm_uint32_t *pCacheBufferMayUse,
|
|
hsm_uint32_t u32LastCacheByteCnt, const hsm_uint32_t *pSrc, hsm_uint32_t u32SrcByteCnt, hsm_uint32_t u32LoadByteCount)
|
|
{
|
|
const hsm_uint32_t *pRet;
|
|
hsm_uint32_t u32WordCnt = u32LoadByteCount >> 2U;
|
|
hsm_uint32_t u32Temp;
|
|
hsm_uint32_t u32CacheByteCnt = u32LastCacheByteCnt;
|
|
hsm_uint32_t *pCacheMayUse = pCacheBufferMayUse;
|
|
hsm_uint32_t *pAlignedCache = (hsm_uint32_t *)(((((hsm_uint32_t)pCacheMayUse) + 3u) >> 2u) << 2u);
|
|
|
|
u32CacheByteCnt = u32CacheByteCnt - (((hsm_uint32_t)pAlignedCache) - ((hsm_uint32_t)pCacheMayUse));
|
|
pCacheMayUse = pAlignedCache; /* make sure the buffer start address is 4bytes aligned */
|
|
|
|
if (((((u32LoadByteCount + 7u) >> 3u) << 3u) <= u32CacheByteCnt) && /* require load cache size is enough for load data 8byte aligned */
|
|
(0 == (u32LoadByteCount % 4)) &&
|
|
(u32LoadByteCount >= u32SrcByteCnt))
|
|
{
|
|
if (u32SrcByteCnt == u32LoadByteCount)
|
|
{
|
|
if (HSM_DATA_FORMAT_1B == eInputFmt) /* 1bytes unit format */
|
|
{
|
|
hsm_core_padding_and_swap_array(pCacheMayUse, u32WordCnt, pSrc, u32LoadByteCount, eInputFmt, 0, HSM_TRUE, HSM_TRUE);
|
|
if (0u != (u32LoadByteCount % 8u))
|
|
{
|
|
pCacheMayUse[u32WordCnt] = 0u;
|
|
}
|
|
/* else nothing */
|
|
|
|
pRet = pCacheMayUse;
|
|
}
|
|
/* 4byte format, if input start address not 4bytes aligned, or load byte cnt not 8bytes aligned, need pad 0, these two case should use cache */
|
|
else if (((((hsm_uint32_t)pSrc) & 0x3u) != 0u) || (0u != (u32LoadByteCount % 8u))) /* && (0u != pSrc[u32LoadByteCount/4u]))) not read more to trigger MPU protect */
|
|
{
|
|
hsm_core_padding_and_swap_array(pCacheMayUse, u32WordCnt, pSrc, u32LoadByteCount, eInputFmt, 0, HSM_FALSE, HSM_FALSE);
|
|
|
|
if (0u != (u32LoadByteCount % 8u))
|
|
{
|
|
pCacheMayUse[u32WordCnt] = 0u;
|
|
}
|
|
/* else nothing */
|
|
|
|
pRet = pCacheMayUse;
|
|
}
|
|
else
|
|
{
|
|
pRet = pSrc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pRet = pCacheMayUse;
|
|
if (HSM_DATA_FORMAT_1B == eInputFmt) /* 1bytes unit format */
|
|
{
|
|
u32Temp = u32LoadByteCount - u32SrcByteCnt;
|
|
hsm_memset(pCacheMayUse, 0U, u32Temp);
|
|
hsm_bidi_memcpy(((hsm_uint8_t *)pCacheMayUse) + u32Temp, pSrc, u32SrcByteCnt, 1);
|
|
hsm_core_padding_and_swap_array(pCacheMayUse, u32WordCnt, pCacheMayUse, u32LoadByteCount, eInputFmt, 0, HSM_TRUE,
|
|
HSM_TRUE); /* the data size has patched to u32LoadByteCount size */
|
|
|
|
if (0u != (u32LoadByteCount % 8u))
|
|
{
|
|
pCacheMayUse[u32WordCnt] = 0u;
|
|
}
|
|
}
|
|
else /* 4bytes unit format */
|
|
{
|
|
u32Temp = u32LoadByteCount - u32SrcByteCnt;
|
|
|
|
hsm_pkam_u32_array_append_zero_from_left((hsm_uint8_t *)pCacheMayUse, (const hsm_uint8_t *)pSrc, u32SrcByteCnt, u32Temp);
|
|
|
|
|
|
if (0u != (u32LoadByteCount % 8u))
|
|
{
|
|
pCacheMayUse[u32WordCnt] = 0u;
|
|
}
|
|
/* else nothing */
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pRet = pSrc; /* error case, make sure the caller not trigger this */
|
|
}
|
|
|
|
|
|
return pRet;
|
|
}
|
|
|
|
HSM_StatusType HSM_L3_UpdatePlainKey(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx,
|
|
const HSM_Ln_PlainKeyImport *pPlainKey, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
HSM_Ln_ImportUserKeyExtType tCfg;
|
|
hsm_uint32_t u32ActualStoreSize;
|
|
|
|
if (HSM_LEVEL_3RD_OP_UPDATE_KEY == pL3Ctx->eOperation)
|
|
{
|
|
if (pL3Ctx->tL3AlgCtx.tUpdateKey.eState == HSM_L3_UPDATE_KEY_READY)
|
|
{
|
|
|
|
if ((pPlainKey->u32KeyId) &&
|
|
(!((HSM_LN_KEY_DATA_STORE_FMT_SPLIT_BN_LOADABLE == pPlainKey->eKeyStoreFmt) && (pPlainKey->u32KeyDataByteCnt & 0x1u))))
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.u32TimeoutMs = u32TimeoutMs;
|
|
|
|
u32ActualStoreSize = pPlainKey->u32KeyDataByteCnt;
|
|
|
|
tCfg.bStoreInFlash = (pPlainKey->u32KeyId & 0x1u) ? HSM_FALSE : HSM_TRUE;
|
|
tCfg.eExportType = pPlainKey->eExportType;
|
|
tCfg.pKeyID = NULL_PTR;
|
|
tCfg.eDecryType = KEYMANAGER_ENDECRY_NONE;
|
|
tCfg.u32DecryKeyID = 0U;
|
|
tCfg.eUserKeyType = KEYMANAGER_USER_KEY_TYPE_NONE; /* ignore the key type */
|
|
tCfg.eAlgType = KEYMANAGER_ENDECRY_ALG_CTR;
|
|
tCfg.pIV = NULL_PTR;
|
|
tCfg.u32KeyIdFix = pPlainKey->u32KeyId;
|
|
tCfg.u32Protect = 0u;
|
|
|
|
if (HSM_LN_KEY_DATA_STORE_FMT_BN_LOADABLE == pPlainKey->eKeyStoreFmt)
|
|
{
|
|
/* 4B format, 8bytes size aligned */
|
|
u32ActualStoreSize = ((pPlainKey->u32KeyDataByteCnt + 7u) >> 3u) << 3u;
|
|
tCfg.pDataAddr = hsm_pkam_get_loadable_buf(
|
|
pPlainKey->eKeyDataFmt, &(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]),
|
|
sizeof(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache), (const hsm_uint32_t *)pPlainKey->pKeyData, pPlainKey->u32KeyDataByteCnt, u32ActualStoreSize);
|
|
|
|
tCfg.u32DataLength = u32ActualStoreSize;
|
|
}
|
|
else if (HSM_LN_KEY_DATA_STORE_FMT_SPLIT_BN_LOADABLE == pPlainKey->eKeyStoreFmt)
|
|
{
|
|
if (KEYMANAGER_USER_KEY_TYPE_SM2_PUBLIC == pPlainKey->eKeyUsage)
|
|
{
|
|
u32ActualStoreSize = 32u;
|
|
}
|
|
else
|
|
{
|
|
u32ActualStoreSize = (((pPlainKey->u32KeyDataByteCnt >> 1u) + 7u) >> 3u) << 3u;
|
|
}
|
|
|
|
tCfg.pDataAddr = hsm_pkam_get_loadable_buf(
|
|
pPlainKey->eKeyDataFmt, &(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]),
|
|
u32ActualStoreSize, (const hsm_uint32_t *)pPlainKey->pKeyData, pPlainKey->u32KeyDataByteCnt >> 1u, u32ActualStoreSize);
|
|
|
|
if ((const void *)tCfg.pDataAddr != (const void *)pPlainKey->pKeyData)
|
|
{
|
|
hsm_pkam_get_loadable_buf(
|
|
pPlainKey->eKeyDataFmt, (hsm_uint32_t *)(((hsm_uint8_t *)tCfg.pDataAddr) + u32ActualStoreSize),
|
|
u32ActualStoreSize,
|
|
(const hsm_uint32_t *)((const hsm_uint8_t *)pPlainKey->pKeyData + (pPlainKey->u32KeyDataByteCnt >> 1u)),
|
|
pPlainKey->u32KeyDataByteCnt >> 1u, u32ActualStoreSize);
|
|
}
|
|
|
|
tCfg.u32DataLength = u32ActualStoreSize << 1u;
|
|
}
|
|
else if (HSM_LN_KEY_DATA_STORE_FMT_1B == pPlainKey->eKeyStoreFmt)
|
|
{
|
|
/* force 1B format */
|
|
if (HSM_DATA_FORMAT_4B == pPlainKey->eKeyDataFmt)
|
|
{
|
|
u32ActualStoreSize = ((pPlainKey->u32KeyDataByteCnt + 3u) >> 2u) << 2u;
|
|
|
|
hsm_core_padding_and_swap_array(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]), u32ActualStoreSize >> 2u,
|
|
pPlainKey->pKeyData, pPlainKey->u32KeyDataByteCnt, pPlainKey->eKeyDataFmt, 0, HSM_FALSE, HSM_TRUE);
|
|
|
|
tCfg.pDataAddr = &(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]);
|
|
tCfg.u32DataLength = pPlainKey->u32KeyDataByteCnt;
|
|
/* tCfg.u32DataLength NOT change */
|
|
}
|
|
else
|
|
{
|
|
hsm_memcpy((void*)(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0])),(const void *)pPlainKey->pKeyData,pPlainKey->u32KeyDataByteCnt);
|
|
tCfg.pDataAddr = &(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]);
|
|
tCfg.u32DataLength = pPlainKey->u32KeyDataByteCnt;
|
|
}
|
|
}
|
|
else /* HSM_LN_KEY_DATA_STORE_FMT_4B */
|
|
{
|
|
if (HSM_DATA_FORMAT_1B == pPlainKey->eKeyDataFmt)
|
|
{
|
|
u32ActualStoreSize = ((pPlainKey->u32KeyDataByteCnt + 3u) >> 2u) << 2u; /* normal key data, size 4bytes aligned, force 4B format */
|
|
|
|
hsm_core_padding_and_swap_array(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]), u32ActualStoreSize >> 2u,
|
|
pPlainKey->pKeyData, pPlainKey->u32KeyDataByteCnt, pPlainKey->eKeyDataFmt, 0, HSM_TRUE, HSM_TRUE);
|
|
|
|
tCfg.pDataAddr = (const hsm_uint32_t *)(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]));
|
|
tCfg.u32DataLength = u32ActualStoreSize;
|
|
}
|
|
else
|
|
{
|
|
hsm_memcpy((void*)(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0])),(const void *)pPlainKey->pKeyData,pPlainKey->u32KeyDataByteCnt);
|
|
tCfg.pDataAddr = (const hsm_uint32_t *)(&(pL3Ctx->tL3AlgCtx.tUpdateKey.aKeyDataCache[0]));
|
|
tCfg.u32DataLength = pPlainKey->u32KeyDataByteCnt;
|
|
}
|
|
|
|
}
|
|
|
|
eRet = HSM_L2_UpdateKeySetupEnv(pL2Ctx, pL1Ctx);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.eState = HSM_L3_UPDATE_KEY_PROCESS;
|
|
|
|
eRet = HSM_L2_UpdateKey(pL2Ctx, pL1Ctx, &tCfg, u32TimeoutMs);
|
|
if (HSM_STATUS_SUCCESS == eRet)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
HSM_L2_UpdateKeyExitEnv(pL2Ctx, pL1Ctx);
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.eState = HSM_L3_UPDATE_KEY_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL3Ctx->tL3AlgCtx.tUpdateKey.eState = HSM_L3_UPDATE_KEY_STOP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_PARAM_ERR;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_LOGIC_ERR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_BUSY;
|
|
}
|
|
|
|
return eRet;
|
|
}
|
|
|
|
HSM_StatusType HSM_L3_UpdateKeyPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
if (HSM_LEVEL_3RD_OP_UPDATE_KEY == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L2_UpdateKeyPoll(pL2Ctx, pL1Ctx, u32TimeoutMs);
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
|
|
return eRet;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------- */
|
|
/* --------------------------------------------------------------------------- */
|
|
void HSM_L3_Ack_IrqHandler(void *pUpperCtx, HSM_BoolType bErrorHappen, HSM_StatusType eRet)
|
|
{
|
|
HSM_StatusType eCurStat = eRet;
|
|
HSM_BoolType bRunning = HSM_TRUE;
|
|
HSM_Ln_RtCtxType *pLnCtx = (HSM_Ln_RtCtxType *)pUpperCtx;
|
|
HSM_L3_RtCtxType *pL3Ctx = &(pLnCtx->tHsmL3Ctx);
|
|
HSM_L2_RtCtxType *pL2Ctx = &(pLnCtx->tHsmL2Ctx);
|
|
HSM_L1_RtCtxType *pL1Ctx = &(pLnCtx->tHsmL1Ctx);
|
|
HSM_BoolType bTempErrorHappen = bErrorHappen;
|
|
|
|
switch (pL3Ctx->eOperation)
|
|
{
|
|
case HSM_LEVEL_3RD_OP_SCATTER_CMAC:
|
|
{
|
|
eCurStat = hsm_scatter_cmac_process(pL3Ctx, pL2Ctx, pL1Ctx, pLnCtx->u32OpLimitMs, &(pL3Ctx->tL3AlgCtx.tScatterCMac), eRet, pL1Ctx->eTriggerSrc);
|
|
if (HSM_STATUS_AGAIN != eCurStat)
|
|
{
|
|
if (HSM_STATUS_SUCCESS != eCurStat)
|
|
{
|
|
bTempErrorHappen = HSM_TRUE;
|
|
}
|
|
else
|
|
{
|
|
bTempErrorHappen = HSM_FALSE;
|
|
}
|
|
}
|
|
/* else do nothing */
|
|
}
|
|
break;
|
|
|
|
case HSM_LEVEL_3RD_OP_UPDATE_KEY:
|
|
{
|
|
; /* nothing to do */
|
|
}
|
|
break;
|
|
|
|
default:
|
|
eCurStat = eRet;
|
|
bRunning = HSM_FALSE;
|
|
break;
|
|
}
|
|
|
|
if ((HSM_FALSE == bRunning) || (HSM_STATUS_AGAIN != eCurStat))
|
|
{
|
|
if (NULL_PTR != pL3Ctx->pStopCb)
|
|
{
|
|
pL3Ctx->pStopCb(pUpperCtx, bTempErrorHappen, eCurStat);
|
|
}
|
|
/* else nothing */
|
|
}
|
|
/* else do nothing */
|
|
}
|
|
|
|
void HSM_L3_Init(HSM_L3_RtCtxType *pCtx, HSM_L3_InitParmType *pParm)
|
|
{
|
|
pCtx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
pCtx->pStopCb = pParm->pStopCb;
|
|
}
|
|
|
|
void HSM_L3_CleanEnv(HSM_L3_RtCtxType *pCtx)
|
|
{
|
|
pCtx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
}
|
|
|
|
/* abort the second level operation, the operation goto none */
|
|
void HSM_L3_Abort(HSM_L3_RtCtxType *pCtx)
|
|
{
|
|
pCtx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
}
|
|
|
|
void HSM_L3_CommonExitEnv(HSM_L3_RtCtxType *pCtx)
|
|
{
|
|
pCtx->eOperation = HSM_LEVEL_3RD_OP_NONE;
|
|
}
|
|
|
|
HSM_StatusType HSM_L3_GetPoll(HSM_L3_RtCtxType *pL3Ctx, HSM_L2_RtCtxType *pL2Ctx, HSM_L1_RtCtxType *pL1Ctx, hsm_uint32_t u32TimeoutMs)
|
|
{
|
|
HSM_StatusType eRet;
|
|
|
|
if (HSM_LEVEL_3RD_OP_SCATTER_CMAC == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L3_ScatterCMacPoll(pL3Ctx, pL2Ctx, pL1Ctx, u32TimeoutMs);
|
|
}
|
|
else if (HSM_LEVEL_3RD_OP_UPDATE_KEY == pL3Ctx->eOperation)
|
|
{
|
|
eRet = HSM_L3_UpdateKeyPoll(pL3Ctx, pL2Ctx, pL1Ctx, u32TimeoutMs);
|
|
}
|
|
else
|
|
{
|
|
eRet = HSM_STATUS_ERROR;
|
|
}
|
|
|
|
return eRet;
|
|
}
|