/** * @file Crypto_Level1Api.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" /********************************************* Level0 function * *********************************************************/ HSM_StatusType HSM_TrueRandGetSrc0(HSM_CmdType *pCmd, const HSMCom_TrueRandType *pCfg); HSM_StatusType HSM_TrueRandGetSrc1(HSM_CmdType *pCmd, const HSMCom_TrueRandType *pCfg); HSM_StatusType HSM_TrueRandGetSrcXor(HSM_CmdType *pCmd, const HSMCom_TrueRandType *pCfg); HSM_StatusType HSM_TrueRandGetSrcShiftXor(HSM_CmdType *pCmd, const HSMCom_TrueRandType *pCfg); HSM_StatusType HSM_TrueRandGet(HSM_CmdType *pCmd, const HSMCom_TrueRandExType *pCfg); HSM_StatusType HSM_TrueRandGetAny(HSM_CmdType *pCmd, const HSMCom_TrueRandType *pCfg); HSM_StatusType HSM_Sha(HSM_CmdType *pCmd, const HSMCom_ShaType *pCfg); HSM_StatusType HSM_FW_ShaEx(HSM_CmdType *pCmd, const HSMCom_ShaExType *pCfg, HSM_BoolType bKeyUseId); HSM_StatusType HSM_EccVerify(HSM_CmdType *pCmd, const HSMCom_EccVerifyType *pCfg); HSM_StatusType HSM_EccCalculateEx(HSM_CmdType *pCmd, const HSMCom_EccCalcType *pCfg); HSM_StatusType HSM_Sm2Decry(HSM_CmdType *pCmd, const HSMCom_Sm2DecryptType *pCfg); HSM_StatusType HSM_Sm2Verify(HSM_CmdType *pCmd, const HSMCom_Sm2VerifyType *pCfg); HSM_StatusType HSM_Sm2GenZa(HSM_CmdType *pCmd, const HSMCom_Sm2GenZaType *pCfg); HSM_StatusType HSM_Sm2GenHash(HSM_CmdType *pCmd, const HSMCom_Sm2GenHashType *pCfg); HSM_StatusType HSM_Sm4EncryptStart(HSM_CmdType *pCmd, HSMWrap_Sm4EncryptType *pCtx, HSMCom_Sm4EncryptType *pDecrypt); HSM_StatusType HSM_Sm4EncryptUpdate(HSM_CmdType *pCmd, HSMWrap_Sm4EncryptType *pCtx); HSM_StatusType HSM_Sm4DecryptEx(HSM_CmdType *pCmd, const HSMCom_Sm4DecryptExType *pCfg); HSM_StatusType HSM_Sm4EncryptExStart(HSM_CmdType *pCmd, HSMWrap_Sm4EncryptExType *pCtx, HSMCom_Sm4EncryptExType *pCfg); HSM_StatusType HSM_Sm4EncryptExUpdate(HSM_CmdType *pCmd, HSMWrap_Sm4EncryptExType *pCtx); HSM_StatusType HSM_Sm4Decrypt(HSM_CmdType *pCmd, const HSMCom_Sm4DecryptType *pCfg); HSM_StatusType HSM_EccEasyDecry(HSM_CmdType *pCmd, const HSMCom_EccEasyDecryType *pCfg); HSM_StatusType HSM_RequestAuthorization(HSM_CmdType *pCmd, const HSMCom_RequestAuthType *pCfg); HSM_StatusType HSM_LifeCycleTakeEffect(HSM_CmdType *pCmd, HSMCom_LifeCycleTakeEffectType *pCfg); HSM_StatusType HSM_OemDevEnter(HSM_CmdType *pCmd, const HSMCom_AuthCheckType *pCfg); HSM_StatusType HSM_OemPdtEnter(HSM_CmdType *pCmd, const HSMCom_AuthCheckType *pCfg); HSM_StatusType HSM_InFieldEnter(HSM_CmdType *pCmd, const HSMCom_AuthCheckType *pCfg); HSM_StatusType HSM_CancelJob(HSM_CmdType *pCmd, const HSMCom_CancelJobType *pCfg); HSM_StatusType HSM_SelfTest(HSM_CmdType *pCmd, volatile HSMCom_SelfTestType *pCfg); HSM_StatusType HSM_NvrOtpProgram(HSM_CmdType *pCmd, const HSMCom_NvrOtpType *pCfg); HSM_StatusType HSM_NvrOtpRead(HSM_CmdType *pCmd, const HSMCom_NvrOtpType *pCfg); HSM_StatusType HSM_UserKeyImport(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_UserKeyExport(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_GetKeySpaceStat(HSM_CmdType *pCmd, const HSMCom_KeySpaceStatusType *pCfg); HSM_StatusType HSM_TidyUpKeySpace(HSM_CmdType *pCmd, const HSMCom_KeySpaceStatusType *pCfg); HSM_StatusType HSM_UserKeyRevoke(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_AesEncrypt(HSM_CmdType *pCmd, const HSMCom_AesEncryptType *pCfg); HSM_StatusType HSM_AesEncryptEx(HSM_CmdType *pCmd, const HSMCom_FlexAesEncryptType *pCfg); HSM_StatusType HSM_AesDecrypt(HSM_CmdType *pCmd, const HSMCom_AesDecryptType *pCfg); HSM_StatusType HSM_AesDecryptEx(HSM_CmdType *pCmd, const HSMCom_FlexAesDecryptType *pCfg); HSM_StatusType HSM_CMac(HSM_CmdType *pCmd, const HSMCom_CMacType *pCfg); HSM_StatusType HSM_CMacEx(HSM_CmdType *pCmd, const HSMCom_CMacExType *pCfg); HSM_StatusType HSM_XMac(HSM_CmdType *pCmd, const HSMCom_XMacType *pCfg); HSM_StatusType HSM_CcmEncry(HSM_CmdType *pCmd, const HSMCom_CcmEncryptType *pCfg); HSM_StatusType HSM_CcmDecry(HSM_CmdType *pCmd, const HSMCom_CcmDecryptType *pCfg); HSM_StatusType HSM_GcmEncry(HSM_CmdType *pCmd, const HSMCom_GcmEncryptType *pCfg); HSM_StatusType HSM_GcmDecry(HSM_CmdType *pCmd, const HSMCom_GcmDecryptType *pCfg); HSM_StatusType HSM_Md5(HSM_CmdType *pCmd, const HSMCom_Md5Type *pCfg); HSM_StatusType HSM_FW_Md5Ex(HSM_CmdType *pCmd, const HSMCom_Md5ExType *pCfg, HSM_BoolType bKeyUseId); HSM_StatusType HSM_Sm3(HSM_CmdType *pCmd, const HSMCom_Sm3Type *pCfg); HSM_StatusType HSM_FW_Sm3Ex(HSM_CmdType *pCmd, const HSMCom_Sm3ExType *pCfg, HSM_BoolType bKeyUseId); HSM_StatusType HSM_MonotonicCounterIncrease(HSM_CmdType *pCmd, const HSMCom_MonCountType *pCfg); HSM_StatusType HSM_MonotonicCounterRead(HSM_CmdType *pCmd, const HSMCom_MonCountType *pCfg); HSM_StatusType HSM_Rsa(HSM_CmdType *pCmd, const HSMCom_RsaType *pCfg); HSM_StatusType HSM_BigNumberCalculateEx(HSM_CmdType *pCmd, const HSMCom_BigNumberCalcType *pCfg); HSM_StatusType HSM_LoadFirmware(HSM_CmdType *pCmd, HSMCom_LoadFirmwareType *pCfg); HSM_StatusType HSM_FW_ScatterHashInit(HSM_CmdType *pCmd, const HSMCom_ScatterHashType *pCfg, HSM_BoolType bKeyUseId, HSM_DataFormatType eInputFmt); HSM_StatusType HSM_FW_ScatterHashUpdate(HSM_CmdType *pCmd, const HSMCom_ScatterHashType *pCfg, HSM_BoolType bKeyUseId, HSM_DataFormatType eInputFmt); HSM_StatusType HSM_FW_ScatterHashFinal(HSM_CmdType *pCmd, const HSMCom_ScatterHashType *pCfg, HSM_BoolType bKeyUseId, HSM_DataFormatType eInputFmt); HSM_StatusType HSM_FW_EccEncrypt(HSM_CmdType *pCmd, const HSMCom_EccEasyEncryType *pCfg); HSM_StatusType HSM_FW_UserKeyGenPair(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_FW_EccSign(HSM_CmdType *pCmd, const HSMCom_EccSignType *pCfg); HSM_StatusType HSM_FW_Sm2GenKeyPair(HSM_CmdType *pCmd, const HSMCom_Sm2GenKeyPairType *pCfg); HSM_StatusType HSM_FW_Sm2Encry(HSM_CmdType *pCmd, const HSMCom_Sm2EncryptType *pCfg); HSM_StatusType HSM_FW_EccEncrypt(HSM_CmdType *pCmd, const HSMCom_EccEasyEncryType *pCfg); HSM_StatusType HSM_FW_Sm2Sign(HSM_CmdType *pCmd, const HSMCom_Sm2SignType *pCfg); HSM_StatusType HSM_FW_UserKeyRevoke(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_FW_ScatterCMacInit(HSM_CmdType *pCmd, const HSMCom_AesmRawApiType *pCfg, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); HSM_StatusType HSM_FW_ScatterCMacUpdate(HSM_CmdType *pCmd, const HSMCom_AesmRawApiType *pCfg, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); HSM_StatusType HSM_FW_ScatterCMacFinal(HSM_CmdType *pCmd, const HSMCom_AesmRawApiType *pCfg, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); HSM_StatusType HSM_FW_RsaSsaPssVerify(HSM_CmdType *pCmd, const HSMCom_RsaSsaPssVerifyType *pCfg); HSM_StatusType HSM_FW_RsaSsaPkcs1v15Verify(HSM_CmdType *pCmd, const HSMCom_RsaSsaPkcs1V15VerifyType *pCfg); HSM_StatusType HSM_FW_UserKeyImportNew(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_FW_CheckKeyIdExt(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_FW_CopyKeyExt(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); HSM_StatusType HSM_FW_BigNumberCalculateEx(HSM_CmdType *pCmd, const HSMCom_BigNumberCalcExtType *pCfg); HSM_StatusType HSM_FW_RsaSsaPssSign(HSM_CmdType *pCmd, const HSMCom_RsaSsaPssSignType *pCfg); HSM_StatusType HSM_FW_RsaSsaPkcs1v15Sign(HSM_CmdType *pCmd, const HSMCom_RsaSsaPkcs1v15SignType *pCfg); #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) HSM_StatusType HSM_FW_GetKeyIdStatus(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); #endif #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) #else HSM_StatusType HSM_UpdateKeyContentOfSpecificKeyId(HSM_CmdType *pCmd, const HSMCom_UserKeyManageType *pCfg); #endif /****************************************** Local function declarations * ***********************************************/ 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_LoadFirmwareSetupEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_LoadFirmware(HSM_L1_RtCtxType *pCtx, uint32 u32TimeoutMs); HSM_StatusType HSM_L1_LoadFirmwarePoll(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_LoadFirmwareReset(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_LoadFirmwareExitEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_LoadFirmware_Isr(HSM_L1_RtCtxType *pCtx); 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_Sm2GenZaSetupEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2GenZaExitEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2GenZa(HSM_L1_RtCtxType *pCtx, const HSM_LN_Sm2GenZaType *pCfg, hsm_uint32_t u32TimeoutMs); HSM_StatusType HSM_L1_Sm2GenZa_Isr(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2GenZaPoll(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2GenZaReset(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2VerifySetupEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2VerifyExitEnv(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2Verify(HSM_L1_RtCtxType *pCtx, const HSM_L1_Sm2VerifyType *pCfg, hsm_uint32_t u32TimeoutMs); HSM_StatusType HSM_L1_Sm2Verify_Isr(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2VerifyPoll(HSM_L1_RtCtxType *pCtx); HSM_StatusType HSM_L1_Sm2VerifyReset(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); static HSM_StatusType hsm_l1_scatter_hash_init(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt); static HSM_StatusType hsm_l1_scatter_hash_update(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt); static HSM_StatusType hsm_l1_scatter_hash_final(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt); static HSM_StatusType hsm_l1_scatter_hash_init2final(HSM_L1_RtCtxType *pCtx, HSMCom_ShaExType *pShaParm); static HSM_StatusType hsm_l1_scatter_cmac_init(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); static HSM_StatusType hsm_l1_scatter_cmac_update(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); static HSM_StatusType hsm_l1_scatter_cmac_final(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt); static HSM_StatusType hsm_l1_scatter_cmac_init2final(HSM_L1_RtCtxType *pCtx, HSMCom_CMacExType *pParm); /********************************************* Global 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) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; hsm_uint32_t u32Idx, u32Idx2; if ((u32SrcStopIdx - u32SrcStartIdx) <= (u32DstBufByteSize - u32DstStartIdx)) { if (HSM_DATA_FORMAT_4B == eDstFmt) { if (HSM_DATA_FORMAT_4B == eSrcFmt) { for (u32Idx = u32SrcStartIdx, u32Idx2 = u32DstStartIdx; u32Idx < u32SrcStopIdx; ++u32Idx, ++u32Idx2) { *(((hsm_uint8_t *)pDst) + HSM_4B_BYTE_INDEX_TO_OFFSET(u32Idx2)) = *( ((hsm_uint8_t *)pSrc) + HSM_4B_BYTE_INDEX_TO_OFFSET(u32Idx)); } } else { for (u32Idx = u32SrcStartIdx, u32Idx2 = u32DstStartIdx; u32Idx < u32SrcStopIdx; ++u32Idx, ++u32Idx2) { *(((hsm_uint8_t *)pDst) + HSM_4B_BYTE_INDEX_TO_OFFSET(u32Idx2)) = *(((hsm_uint8_t *)pSrc) + (u32Idx)); } } } else { if (HSM_DATA_FORMAT_4B == eSrcFmt) { for (u32Idx = u32SrcStartIdx, u32Idx2 = u32DstStartIdx; u32Idx < u32SrcStopIdx; ++u32Idx, ++u32Idx2) { *(((hsm_uint8_t *)pDst) + (u32Idx2)) = *(((hsm_uint8_t *)pSrc) + HSM_4B_BYTE_INDEX_TO_OFFSET(u32Idx)); } } else { for (u32Idx = u32SrcStartIdx, u32Idx2 = u32DstStartIdx; u32Idx < u32SrcStopIdx; ++u32Idx, ++u32Idx2) { *(((hsm_uint8_t *)pDst) + (u32Idx2)) = *(((hsm_uint8_t *)pSrc) + (u32Idx)); } } } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } void hsm_bidi_memcpy(void *pDstMem, const void *pSrcMem, hsm_uint32_t u32OpCnt, hsm_int32_t sOpDirection) { hsm_uint8_t *pDstByte = pDstMem; const hsm_uint8_t *pSrcByte = pSrcMem; hsm_int32_t sDirection = sOpDirection; hsm_uint32_t u32Cnt = u32OpCnt; if ((pSrcMem != pDstMem) && (u32Cnt > 0)) { if (sDirection >= 0) { if (((hsm_uint32_t)pDstMem) > ((hsm_uint32_t)pSrcMem)) /* for safe */ { pDstByte += u32Cnt; pSrcByte += u32Cnt; pDstByte -= 1; pSrcByte -= 1; sDirection = -1; } else { sDirection = 1; } } else { if (((hsm_uint32_t)pDstMem) < ((hsm_uint32_t)pSrcMem)) /* for safe */ { pDstByte -= u32Cnt; pSrcByte -= u32Cnt; pDstByte += 1; pSrcByte += 1; sDirection = 1; } else { sDirection = -1; } } while (u32Cnt > 0u) { *pDstByte = *pSrcByte; pDstByte += sDirection; pSrcByte += sDirection; u32Cnt--; } } else { ; /* nothing to do */ } } void hsm_memcpy(void *pDstMem, const void *pSrcMem, hsm_uint32_t u32Cnt) { hsm_bidi_memcpy(pDstMem, pSrcMem, u32Cnt, 1U); } void hsm_memset(void *pDstMem, hsm_uint8_t u8Val, hsm_uint32_t u32Cnt) { hsm_uint8_t *pData = (hsm_uint8_t *)pDstMem; hsm_uint32_t u32Idx; for (u32Idx = 0; u32Idx < u32Cnt; ++u32Idx) { pData[u32Idx] = u8Val; } } hsm_int32_t hsm_memcmp(const void *pDst, const void *pSrc, hsm_uint32_t u32OpCnt) { const hsm_uint8_t *pByteData1 = (const hsm_uint8_t *)pDst; const hsm_uint8_t *pByteData2 = (const hsm_uint8_t *)pSrc; hsm_int32_t sRet, sData1, sData2; hsm_uint32_t u32Cnt = u32OpCnt; sRet = 0; while (u32Cnt > 0u) { sData1 = (hsm_int32_t)(*pByteData1); sData2 = (hsm_int32_t)(*pByteData2); sRet = sData1 - sData2; if (0u != sRet) { break; } u32Cnt--; pByteData1++; pByteData2++; } return sRet; } HSM_StatusType hsm_hash_get_result_byte_count(HFAM_MODE_E eMode, hsm_uint32_t *pRetByteCnt) { hsm_uint32_t u32ByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; switch (eMode) { case HFA_MD5: u32ByteCnt = 16u; /* 16 */ break; case HFA_SHA160: u32ByteCnt = 160 / 8; /* 20 */ break; case HFA_SHA224: u32ByteCnt = 224 / 8; /* 28 */ break; case HFA_SHA256: u32ByteCnt = 256 / 8; /* 32 */ break; case HFA_SHA384: u32ByteCnt = 384 / 8; /* 48 */ break; case HFA_SHA512: u32ByteCnt = 512 / 8; /* 64 */ break; case HFA_SHA512_224: u32ByteCnt = 224 / 8; /* 28 */ break; case HFA_SHA512_256: u32ByteCnt = 256 / 8; /* 32 */ break; case HFA_SM3: u32ByteCnt = 32u; /* 32 */ break; default: u32ByteCnt = 0; eRet = HSM_STATUS_PARAM_ERR; break; } if (NULL_PTR != pRetByteCnt) { *pRetByteCnt = u32ByteCnt; } return eRet; } void hsm_u32_array_swap(hsm_uint32_t *pData, hsm_uint32_t u32WordCnt) { hsm_uint32_t u32Idx; for (u32Idx = 0u; u32Idx < u32WordCnt; ++u32Idx) { pData[u32Idx] = hsm_hw_swap_u32(pData[u32Idx]); } } void hsm_u32_array_swap_to(hsm_uint32_t *pData, const hsm_uint32_t *pSrc, hsm_uint32_t u32WordCnt) { hsm_uint32_t u32Idx; for (u32Idx = 0u; u32Idx < u32WordCnt; ++u32Idx) { pData[u32Idx] = hsm_hw_swap_u32(pSrc[u32Idx]); } } 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) { const hsm_uint8_t *pInter = (const hsm_uint8_t *)pData; const hsm_uint32_t *pInterU32 = (const hsm_uint32_t *)pData; hsm_uint32_t u32DataCount = u32ByteCount; if (HSM_DATA_FORMAT_1B == eInputFmt) { while ((0u == *pInter) && (u32DataCount > 0u)) { pInter++; u32DataCount--; } } else { if (0x3u == (((hsm_uint32_t)pData) & 0x3u)) { while ((u32DataCount >= 4u) && (0u == pInter[0]) && (0u == pInter[1]) && (0u == pInter[2]) && (0u == pInter[3])) { pInter += 4u; u32DataCount -= 4u; } } else { while ((0u == *pInterU32) && (u32DataCount >= 4u)) { pInterU32++; u32DataCount -= 4U; } } pInter = (const hsm_uint8_t *)pInterU32; } if (NULL_PTR != ppActualData) { *ppActualData = pInter; } /* else do nothing */ if (NULL_PTR != pActualByteCnt) { *pActualByteCnt = u32DataCount; } /* else do nothing */ } 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) { hsm_uint32_t u32Idx = 0; hsm_uint32_t u32Temp; hsm_uint32_t u32Data; hsm_uint32_t u32DestIdx; const hsm_uint32_t *pSrcWord = (const hsm_uint32_t *)pSrc; hsm_uint32_t u32SrcByteCnt = u32SrcOpByteCnt; if ((u32DestWordCnt << 2u) < u32SrcByteCnt) { u32SrcByteCnt = (u32DestWordCnt << 2u); } u32Temp = u32SrcByteCnt >> 2u; if (0u == (((hsm_uint32_t)pSrc) & 0x3u)) { if (HSM_FALSE != bSwap) { for (; u32Idx < u32Temp; ++u32Idx) { pAlignedDest[u32Idx] = hsm_hw_swap_u32(pSrcWord[u32Idx]); } } else { for (; u32Idx < u32Temp; ++u32Idx) { pAlignedDest[u32Idx] = pSrcWord[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; if (0u == (((hsm_uint32_t)pSrcWord) & 0x3u)) { u32Data = pSrcWord[u32Idx]; } else { u32SrcByteCnt = (hsm_uint32_t)pSrc + (u32Idx * 4); u32Data = *((hsm_uint8_t *)u32SrcByteCnt + 3); u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 2)); u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 1)); u32Data = (u32Data << 8u) | (*((hsm_uint8_t *)u32SrcByteCnt + 0)); } if (HSM_FALSE != bPadFromMSB) { 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_L1_CleanEnv(HSM_L1_RtCtxType *pCtx) { pCtx->eLastestHsmRet = HSM_STATUS_IDLE; pCtx->bInProcess = HSM_FALSE; pCtx->eOperationCata = HSM_OP_NONE; } HSM_StatusType HSM_L1_CommonExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_L1_DrvSMType eState = pCtx->eStat; HSM_L1_CleanEnv(pCtx); if (HSM_TRUE == bInProcess) { if (HSM_DRV_SM_ARITH == eState) { eRet = pCtx->pCancelCmdCb(); } } return eRet; } /* abort current operation, the operation will goto None */ HSM_StatusType HSM_L1_Abort(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_L1_DrvSMType eState = pCtx->eStat; HSM_L1_CleanEnv(pCtx); if (HSM_TRUE == bInProcess) { if (HSM_DRV_SM_ARITH == eState) { eRet = pCtx->pCancelCmdCb(); } } return eRet; } void HSM_L1_Init(HSM_L1_RtCtxType *pCtx, HSM_L1_InitParmType *pParm) { pCtx->eTriggerSrc = pParm->eTriggerSrc; pCtx->pStopCb = pParm->pStopCb; pCtx->pSendCmdCb = pParm->pSendCmdCb; pCtx->pReadAckCb = pParm->pReadAckCb; pCtx->pCancelCmdCb = pParm->pCancelCmdCb; pCtx->pCleanDCache = pParm->pCleanDCache; pCtx->pCleanAndFlushDcache = pParm->pCleanAndFlushDcache; HSM_L1_CleanEnv(pCtx); } #if 0 /* * IF use key id of RSA E/D/N, the key data in key space of HSM side, * only support 4B format, * and the N size must 8bytes aligned, * the D/E size should equal to N size. * So use HSM_L1_BnCalc instead. */ HSM_StatusType HSM_L1_RsaSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32RsaBitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32RsaBitCnt <= 4096u) && (u32RsaBitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RSA; pCtx->tL1AlgCtx.tRsaInf.u32NBitCnt = u32RsaBitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRsaInf.pRsaParm = (HSMCom_RsaType *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaParmBuf[0])); pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pInputData = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])); pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pKey_E = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaE[0])); pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pKey_N = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaN[0])); pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pResult = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])); pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32ResultBufByteCnt = sizeof(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult) - 4; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* For interrupt usage */ HSM_StatusType HSM_L1_Rsa(HSM_L1_RtCtxType *pCtx, const HSM_L1_RsaType *pCfg, hsm_uint32_t u32TimeoutMs) { hsm_uint32_t u32NByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { u32NByteCnt = ((pCtx->tL1AlgCtx.tRsaInf.u32NBitCnt + 63u) / 64u) * 8u; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32RsaBitCnt = pCtx->tL1AlgCtx.tRsaInf.u32NBitCnt; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32InputDataByteCount = u32NByteCnt; hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pInputData, pCfg->u32InputDataByteCount, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])), u32NByteCnt / 4U); } else { ; } if (pCfg->u32KeyEId) { pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32UserKeyID_KEY_E = pCfg->u32KeyEId; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_E_ByteCount = pCfg->u32KeyEByteCount; } else { pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_E_ByteCount = u32NByteCnt; hsm_rm_prefix_zeros(pCfg->eKeyEFmt, pCfg->pKeyE, pCfg->u32KeyEByteCount, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaE[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaE[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eKeyEFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaE[0])), u32NByteCnt / 4U); } else { ; } } if (pCfg->u32KeyNId) { pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount = pCfg->u32KeyNByteCount; } else { pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount = u32NByteCnt; hsm_rm_prefix_zeros(pCfg->eKeyNFmt, pCfg->pKeyN, pCfg->u32KeyNByteCount, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaN[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaN[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eKeyNFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaN[0])), u32NByteCnt / 4U); } else { ; } } pCtx->tL1AlgCtx.tRsaInf.pResultBuf = pCfg->pResult; pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt = pCfg->pResultByteCnt; pCtx->tL1AlgCtx.tRsaInf.eOutFmt = pCfg->eOutputFmt; eRet = HSM_Rsa(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaInf.pRsaParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Rsa_Isr(HSM_L1_RtCtxType *pCtx) { const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tRsaInf.pRsaParm->u32HSMStatusRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tRsaInf.eOutFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])), pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount / 4U); hsm_rm_prefix_zeros(HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pResult, pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tRsaInf.pResultBuf, pStart, u32ActualSize); if (NULL_PTR != pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt) { *pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } else if (HSM_DATA_FORMAT_1B_PAD_0_LEFT_FIT_BUF == pCtx->tL1AlgCtx.tRsaInf.eOutFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaInf.aRsaInputAndResult[0])), pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount / 4U); hsm_rm_prefix_zeros(HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pResult, pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memset(pCtx->tL1AlgCtx.tRsaInf.pResultBuf, 0, pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)pCtx->tL1AlgCtx.tRsaInf.pResultBuf) + (pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize - u32ActualSize), pStart, u32ActualSize); if (NULL_PTR != pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt) { *pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt = pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize; } eRet = HSM_STATUS_SUCCESS; } } else { hsm_rm_prefix_zeros(HSM_DATA_FORMAT_4B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.pResult, pCtx->tL1AlgCtx.tRsaInf.pRsaParm->tCfg.u32Key_N_ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tRsaInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tRsaInf.pResultBuf, pStart, u32ActualSize); *pCtx->tL1AlgCtx.tRsaInf.pResultByteCnt = u32ActualSize; eRet = HSM_STATUS_SUCCESS; } } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_RsaPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Rsa_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } #endif HSM_StatusType HSM_L1_Md5SetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_MD5; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tMd5Inf.pParm = (HSMCom_Md5ExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tMd5Inf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Md5Reset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_MD5 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Md5ExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_MD5 == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Md5(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Md5Type *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (NULL_PTR != pCfg->pResult) && (pCfg->u32ResultBufSize > 0) && ((HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) || ((pCfg->u32ResultBufSize >= 4u) && (0u == (pCfg->u32ResultBufSize & 0x3))))) /* not check the input address 4byte aligned here for eco support this */ { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_MD5 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tMd5Inf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tMd5Inf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tMd5Inf.pResultBuf = pCfg->pResult; if (pCfg->u32ResultBufSize > 16u) { pCtx->tL1AlgCtx.tMd5Inf.u32ResultBufSize = 16u; } else { pCtx->tL1AlgCtx.tMd5Inf.u32ResultBufSize = pCfg->u32ResultBufSize; ; } pCtx->tL1AlgCtx.tMd5Inf.pOutResultSize = pCfg->pResultSize; hsm_memcpy(&(pCtx->tL1AlgCtx.tMd5Inf.pParm->tCfg.tCfg), &(pCfg->tCfg), sizeof(HSM_Md5CtxType)); pCtx->tL1AlgCtx.tMd5Inf.pParm->tCfg.pRet = (hsm_uint32_t(*)[4])HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tMd5Inf.aResultCacheBuf[0])); pCtx->tL1AlgCtx.tMd5Inf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tMd5Inf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; /* require output 4B format */ if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tMd5Inf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tMd5Inf.bSwapOut = HSM_FALSE; } eRet = HSM_FW_Md5Ex(&(pCtx->tCmd), pCtx->tL1AlgCtx.tMd5Inf.pParm, pCfg->bKeyUseId); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Md5_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tMd5Inf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tMd5Inf.bSwapOut) /* 1B format output */ { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tMd5Inf.aResultCacheBuf[0])), 16 / 4U); /* md5 has 16bytes result data */ } else { } hsm_memcpy(pCtx->tL1AlgCtx.tMd5Inf.pResultBuf, pCtx->tL1AlgCtx.tMd5Inf.pParm->tCfg.pRet, pCtx->tL1AlgCtx.tMd5Inf.u32ResultBufSize); if (NULL_PTR != (pCtx->tL1AlgCtx.tMd5Inf.pOutResultSize)) { hsm_memcpy(pCtx->tL1AlgCtx.tMd5Inf.pOutResultSize, &(pCtx->tL1AlgCtx.tMd5Inf.u32ResultBufSize), sizeof(pCtx->tL1AlgCtx.tMd5Inf.u32ResultBufSize)); } else { ; } eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Md5Poll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_MD5 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Md5_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm3SetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SM3; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tSm3Inf.pParm = (HSMCom_Sm3ExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm3Inf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm3Reset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM3 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm3ExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM3 == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm3(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm3Type *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (NULL_PTR != pCfg->pResult) && (pCfg->u32ResultBufSize > 0) && ((HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) || ((pCfg->u32ResultBufSize >= 4u) && (0u == (pCfg->u32ResultBufSize & 0x3))))) /* not check the input address 4byte aligned here for eco support this */ { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM3 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tSm3Inf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tSm3Inf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tSm3Inf.pResultBuf = pCfg->pResult; if (pCfg->u32ResultBufSize > 32U) { pCtx->tL1AlgCtx.tSm3Inf.u32ResultBufSize = 32u; } else { pCtx->tL1AlgCtx.tSm3Inf.u32ResultBufSize = pCfg->u32ResultBufSize; } pCtx->tL1AlgCtx.tSm3Inf.pOutResultSize = pCfg->pResultSize; hsm_memcpy(&(pCtx->tL1AlgCtx.tSm3Inf.pParm->tCfg.tCfg), &(pCfg->tCfg), sizeof(HSM_Sm3CtxType)); pCtx->tL1AlgCtx.tSm3Inf.pParm->tCfg.pRet = (hsm_uint32_t(*)[8])(hsm_uint32_t(*)[8]) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tSm3Inf.aResultCacheBuf[0])); pCtx->tL1AlgCtx.tSm3Inf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tSm3Inf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tSm3Inf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tSm3Inf.bSwapOut = HSM_FALSE; } eRet = HSM_FW_Sm3Ex(&(pCtx->tCmd), pCtx->tL1AlgCtx.tSm3Inf.pParm, pCfg->bKeyUseId); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm3_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tSm3Inf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tSm3Inf.bSwapOut) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tSm3Inf.aResultCacheBuf[0])), 32u / 4U); /* sm3 has 32bytes result data */ } else { } hsm_memcpy(pCtx->tL1AlgCtx.tSm3Inf.pResultBuf, pCtx->tL1AlgCtx.tSm3Inf.pParm->tCfg.pRet, pCtx->tL1AlgCtx.tSm3Inf.u32ResultBufSize); if (NULL_PTR != pCtx->tL1AlgCtx.tSm3Inf.pOutResultSize) { hsm_memcpy(pCtx->tL1AlgCtx.tSm3Inf.pOutResultSize, &(pCtx->tL1AlgCtx.tSm3Inf.u32ResultBufSize), sizeof(pCtx->tL1AlgCtx.tSm3Inf.u32ResultBufSize)); } else { ; } eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm3Poll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM3 == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sm3_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ShaSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SHA; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tShaInf.pParm = (HSMCom_ShaExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tShaInf.aParmBuf[0])); pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.pResult = (HSM_ShaResultBufType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tShaInf.aShaResultCache[0])); ; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ShaReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SHA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ShaExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SHA == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sha(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ShaType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; hsm_uint32_t u32HashRetSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (NULL_PTR != pCfg->pResult) && (pCfg->u32ResultBufSize > 0) && ((HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) || ((pCfg->u32ResultBufSize >= 4u) && (0u == (pCfg->u32ResultBufSize & 0x3))))) /* not check the input address 4byte aligned here for eco support this */ { eRet = hsm_hash_get_result_byte_count((HFAM_MODE_E)pCfg->eAlg, &u32HashRetSize); if (HSM_STATUS_SUCCESS == eRet) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SHA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tShaInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tShaInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tShaInf.pResultBuf = pCfg->pResult; if (pCfg->u32ResultBufSize >= u32HashRetSize) { pCtx->tL1AlgCtx.tShaInf.u32ResultBufSize = u32HashRetSize; } else { pCtx->tL1AlgCtx.tShaInf.u32ResultBufSize = pCfg->u32ResultBufSize; } pCtx->tL1AlgCtx.tShaInf.pOutResultSize = pCfg->pResultSize; pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.eAlg = pCfg->eAlg; hsm_memcpy(&(pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.tCfg), &(pCfg->tCfg), sizeof(HSM_ShaCtxType)); pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tShaInf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tShaInf.bSwapOut = HSM_FALSE; } eRet = HSM_FW_ShaEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tShaInf.pParm, pCfg->bKeyUseId); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sha_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; hsm_uint32_t u32HashRetSize; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tShaInf.pParm->u32HSMStatusRet) { eRet = hsm_hash_get_result_byte_count((HFAM_MODE_E)pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.eAlg, &u32HashRetSize); if (HSM_STATUS_SUCCESS == eRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tShaInf.bSwapOut) { hsm_u32_array_swap( (hsm_uint32_t *)&(pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.pResult->aResult[0]), u32HashRetSize / 4U); /* all result data size is 4*N */ } else { } hsm_memcpy(pCtx->tL1AlgCtx.tShaInf.pResultBuf, &(pCtx->tL1AlgCtx.tShaInf.pParm->tCfg.pResult->aResult[0]), pCtx->tL1AlgCtx.tShaInf.u32ResultBufSize); if (NULL_PTR != pCtx->tL1AlgCtx.tShaInf.pOutResultSize) { hsm_memcpy(pCtx->tL1AlgCtx.tShaInf.pOutResultSize, &(pCtx->tL1AlgCtx.tShaInf.u32ResultBufSize), sizeof(pCtx->tL1AlgCtx.tShaInf.u32ResultBufSize)); } else { ; } eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_ShaPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SHA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sha_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RngSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RNG; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRngInf.pParm = (HSMCom_TrueRandExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tRngInf.aParmBuf[0])); pCtx->tL1AlgCtx.tRngInf.pParm->aRandom = (hsm_uint32_t(*)[HSM_TRNG_RAND_U32_CNT]) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRngInf.aRandom[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RngReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RNG == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RngExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_RNG == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Rng(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RngType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32ResultBufSize > 0)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RNG == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRngInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRngInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRngInf.pParm->u32RandSrc = pCfg->eSrc; pCtx->tL1AlgCtx.tRngInf.pResultBuf = pCfg->pResult; pCtx->tL1AlgCtx.tRngInf.u32ResultBufSize = pCfg->u32ResultBufSize; pCtx->tL1AlgCtx.tRngInf.u32GetSize = 0u; eRet = HSM_TrueRandGet(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRngInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Rng_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tRngInf.pParm->u32HSMStatusRet) { if ((pCtx->tL1AlgCtx.tRngInf.u32GetSize + (sizeof(hsm_uint32_t) * HSM_TRNG_RAND_U32_CNT)) < pCtx->tL1AlgCtx.tRngInf.u32ResultBufSize) { hsm_memcpy(((hsm_uint8_t *)pCtx->tL1AlgCtx.tRngInf.pResultBuf) + pCtx->tL1AlgCtx.tRngInf.u32GetSize, &((*(pCtx->tL1AlgCtx.tRngInf.pParm->aRandom))[0]), (sizeof(hsm_uint32_t) * HSM_TRNG_RAND_U32_CNT)); pCtx->tL1AlgCtx.tRngInf.u32GetSize += (sizeof(hsm_uint32_t) * HSM_TRNG_RAND_U32_CNT); pCtx->tL1AlgCtx.tRngInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; eRet = HSM_TrueRandGet(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRngInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } else { eRet = HSM_STATUS_AGAIN; } } else { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_ERROR_STOP; } } else { hsm_memcpy(((hsm_uint8_t *)pCtx->tL1AlgCtx.tRngInf.pResultBuf) + pCtx->tL1AlgCtx.tRngInf.u32GetSize, &((*(pCtx->tL1AlgCtx.tRngInf.pParm->aRandom))[0]), pCtx->tL1AlgCtx.tRngInf.u32ResultBufSize - pCtx->tL1AlgCtx.tRngInf.u32GetSize); pCtx->tL1AlgCtx.tRngInf.u32GetSize = pCtx->tL1AlgCtx.tRngInf.u32ResultBufSize; pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SUCCESS; } } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_RngPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RNG == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Rng_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccVerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32BitCnt <= 1024) && (u32BitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_ECC_VERIFY; pCtx->tL1AlgCtx.tEccVerifyInf.u32NBitCnt = u32BitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tEccVerifyInf.pParm = (HSMCom_EccVerifyType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aParmBuf[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pP = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aP[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pN = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aN[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pA = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aA[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pB = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aB[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pGx = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aGx[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.tCurve.pGy = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aGy[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.pkG_x = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.akGx[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.pkG_y = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.akGy[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.pHashData = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aHash[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.pR = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aR[0])); pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.pS = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aS[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccVerifyExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_VERIFY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* For interrupt usage */ HSM_StatusType HSM_L1_EccVerify(HSM_L1_RtCtxType *pCtx, const HSM_L1_EccVerifyType *pCfg, hsm_uint32_t u32TimeoutMs) { hsm_uint32_t u32NByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { u32NByteCnt = ((pCtx->tL1AlgCtx.tEccVerifyInf.u32NBitCnt + 63u) / 64u) * 8u; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32UserKeyID_PublicKey = pCfg->u32PublicKeyId; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32BitCnt = pCtx->tL1AlgCtx.tEccVerifyInf.u32NBitCnt; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32EccCurve = pCfg->u32EccCurve; pCtx->tL1AlgCtx.tEccVerifyInf.pParm->tCfg.u32DataByteCnt = u32NByteCnt; if (HSM_DRV_ECC_CURVE_PRM_IDX_MAX <= pCfg->u32EccCurve) { hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pP, pCfg->tCurve.u32PByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aP[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aP[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pN, pCfg->tCurve.u32NByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aN[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aN[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pA, pCfg->tCurve.u32AByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aA[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aA[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pB, pCfg->tCurve.u32BByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aB[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aB[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pGx, pCfg->tCurve.u32GxByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aGx[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aGx[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eCurveDataFmt, pCfg->tCurve.pGy, pCfg->tCurve.u32GyByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aGy[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aGy[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eCurveDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aP[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aN[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aA[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aB[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aGx[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aGy[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32PublicKeyId) { hsm_rm_prefix_zeros(pCfg->ekGxyDataFmt, pCfg->pkGx, pCfg->u32kGxByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.akGx[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.akGx[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->ekGxyDataFmt, pCfg->pkGy, pCfg->u32kGyByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.akGy[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.akGy[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->ekGxyDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.akGx[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.akGy[0])), u32NByteCnt / 4U); } else { ; } } else { ; } hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->pData, pCfg->u32DataByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aHash[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aHash[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccVerifyInf.aHash[0])), u32NByteCnt / 4U); } else { ; } hsm_rm_prefix_zeros(pCfg->eRDataFmt, pCfg->pR, pCfg->u32RByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aR[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aR[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eRDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aR[0])), u32NByteCnt / 4U); } else { ; } hsm_rm_prefix_zeros(pCfg->eSDataFmt, pCfg->pS, pCfg->u32SByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aS[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aS[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eSDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccVerifyInf.aS[0])), u32NByteCnt / 4U); } else { ; } eRet = HSM_EccVerify(&(pCtx->tCmd), pCtx->tL1AlgCtx.tEccVerifyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccVerify_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_PASS == pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_PASS; pCtx->eStat = HSM_DRV_SM_STOP; } else if (MAILBOXAPI_RET_FAIL == pCtx->tL1AlgCtx.tEccVerifyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_FAIL; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_EccVerifyPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_EccVerify_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccVerifyReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccDecryptSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32BitCnt <= 1024) && (u32BitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_ECC_EASYDECRY; pCtx->tL1AlgCtx.tEccDecryptInf.u32NBitCnt = u32BitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tEccDecryptInf.pParm = (HSMCom_EccEasyDecryType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aParmBuf[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32BitCnt = u32BitCnt; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pP = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aP[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pN = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aN[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pCoeffi_A = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aA[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pCoeffi_B = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aB[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pOtherSidePublicKey_x = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.akGx[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pOtherSidePublicKey_y = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.akGy[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pPrivateKey = (const hsm_uint32_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aPrivate[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pEncryedData = (const hsm_uint32_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aEncrypted[0])); pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pPlainData = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aPlain[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccDecryptExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_EASYDECRY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccDecrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccDecryptType *pCfg, hsm_uint32_t u32TimeoutMs) { hsm_uint32_t u32NByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_EASYDECRY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { u32NByteCnt = ((pCtx->tL1AlgCtx.tEccDecryptInf.u32NBitCnt + 63u) / 64u) * 8u; pCtx->tL1AlgCtx.tEccDecryptInf.eOutFmt = pCfg->eOutputDataFmt; pCtx->tL1AlgCtx.tEccDecryptInf.pResultBuf = pCfg->pPlainData; pCtx->tL1AlgCtx.tEccDecryptInf.u32ResultBufSize = pCfg->u32PlainDataBufferByteCnt; pCtx->tL1AlgCtx.tEccDecryptInf.pResultByteCnt = pCfg->pPlainResultByteCnt; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32UserKeyID_PrivateKey = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32UserKeyID_PublicKey = pCfg->u32PublicKeyId; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32BitCnt = pCtx->tL1AlgCtx.tEccDecryptInf.u32NBitCnt; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32EccCurve = pCfg->u32EccCurve; pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.u32ByteCount = u32NByteCnt; if (HSM_DRV_ECC_CURVE_PRM_IDX_MAX <= pCfg->u32EccCurve) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pP, pCfg->tCurve.u32PByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aP[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aP[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pN, pCfg->tCurve.u32NByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aN[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aN[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pA, pCfg->tCurve.u32AByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aA[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aA[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pB, pCfg->tCurve.u32BByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aB[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aB[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aA[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aB[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aP[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aN[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32PublicKeyId) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pkGx, pCfg->u32kGxByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.akGx[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.akGx[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pkGy, pCfg->u32kGyByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.akGy[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.akGy[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.akGx[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.akGy[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32PrivateKeyId) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pPrivateKey, pCfg->u32PrivateKeyByteCnt, &pStart, &u32ActualSize); hsm_memset( (void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aPrivate[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aPrivate[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aPrivate[0])), u32NByteCnt / 4U); } else { ; } } else { ; } hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pEncryptedData, pCfg->u32EncryptedDataByteCnt, &pStart, &u32ActualSize); hsm_memset( (void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccDecryptInf.aEncrypted[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aEncrypted[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccDecryptInf.aEncrypted[0])), u32NByteCnt / 4U); } else { ; } eRet = HSM_EccEasyDecry(&(pCtx->tCmd), pCtx->tL1AlgCtx.tEccDecryptInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccDecrypt_Isr(HSM_L1_RtCtxType *pCtx) { const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tEccDecryptInf.pParm->u32HSMStatusRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccDecryptInf.eOutFmt) { hsm_u32_array_swap(pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pPlainData, pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.u32ByteCount / 4U); /* 4B -> 1B */ hsm_rm_prefix_zeros( HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pPlainData, pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccDecryptInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccDecryptInf.pResultBuf, pStart, u32ActualSize); if (0u != pCtx->tL1AlgCtx.tEccDecryptInf.pResultByteCnt) { *pCtx->tL1AlgCtx.tEccDecryptInf.pResultByteCnt = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } else { hsm_rm_prefix_zeros( HSM_DATA_FORMAT_4B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.pPlainData, pCtx->tL1AlgCtx.tEccDecryptInf.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccDecryptInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccDecryptInf.pResultBuf, pStart, u32ActualSize); if (0u != pCtx->tL1AlgCtx.tEccDecryptInf.pResultByteCnt) { *pCtx->tL1AlgCtx.tEccDecryptInf.pResultByteCnt = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_EccDecryptPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_EASYDECRY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_EccDecrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccDecryptReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_EASYDECRY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccCalculateSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32BitCnt <= 1024) && (u32BitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_ECC_CALC; pCtx->tL1AlgCtx.tEccCalc.u32NBitCnt = u32BitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tEccCalc.pParm = (HSMCom_EccCalcType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aParmBuf[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->u32BitCnt = u32BitCnt; pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pCoeffi_A = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aA[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pCoeffi_B = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aB[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pP = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pN = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aN[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pP1x = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP1x[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pP1y = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP1y[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pE = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aE[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pP2x = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP2x[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResultx = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aResultX[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pP2y = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP2y[0])); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResulty = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aResultY[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccCalculateExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_CALC == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccCalculateKP(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccKPType *pCfg, hsm_uint32_t u32TimeoutMs) { hsm_uint32_t u32NByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { u32NByteCnt = ((pCtx->tL1AlgCtx.tEccCalc.u32NBitCnt + 63u) / 64u) * 8u; pCtx->tL1AlgCtx.tEccCalc.eOutFmt = pCfg->eOutputDataFmt; pCtx->tL1AlgCtx.tEccCalc.pResultBufX = pCfg->pResultX; pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeX = pCfg->u32ResultXBufferByteCnt; pCtx->tL1AlgCtx.tEccCalc.pResultByteCntX = pCfg->pResultXByteCnt; pCtx->tL1AlgCtx.tEccCalc.pResultBufY = pCfg->pResultY; pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeY = pCfg->u32ResultYBufferByteCnt; pCtx->tL1AlgCtx.tEccCalc.pResultByteCntY = pCfg->pResultYByteCnt; pCtx->tL1AlgCtx.tEccCalc.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tEccCalc.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tEccCalc.pParm->u32UserKeyID_E = pCfg->u32KId; pCtx->tL1AlgCtx.tEccCalc.pParm->u32UserKeyID_P1 = pCfg->u32PointId; pCtx->tL1AlgCtx.tEccCalc.pParm->u32BitCnt = pCtx->tL1AlgCtx.tEccCalc.u32NBitCnt; pCtx->tL1AlgCtx.tEccCalc.pParm->u32EccCurve = pCfg->u32EccCurve; pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount = u32NByteCnt; if (HSM_DRV_ECC_CURVE_PRM_IDX_MAX <= pCfg->u32EccCurve) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pP, pCfg->tCurve.u32PByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pN, pCfg->tCurve.u32NByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aN[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aN[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pA, pCfg->tCurve.u32AByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aA[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aA[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->tCurve.pB, pCfg->tCurve.u32BByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aB[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aB[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aA[0])), u32NByteCnt / 4U); hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aB[0])), u32NByteCnt / 4U); hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP[0])), u32NByteCnt / 4U); hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aN[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32PointId) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pPointX, pCfg->u32PointXByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP1x[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP1x[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pPointY, pCfg->u32PointYByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP1y[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP1y[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP1x[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccCalc.aP1y[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32KId) { hsm_rm_prefix_zeros(pCfg->eInputDataFmt, pCfg->pK, pCfg->u32KByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aE[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy( ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aE[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eInputDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aE[0])), u32NByteCnt / 4U); } else { ; } } else { ; } hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP2x[0])), 0, sizeof(pCtx->tL1AlgCtx.tEccCalc.aP2x)); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccCalc.aP2y[0])), 0, sizeof(pCtx->tL1AlgCtx.tEccCalc.aP2y)); pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32CalcType = HSM_ECC_CALC_PMUL; eRet = HSM_EccCalculateEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tEccCalc.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccCalculate_Isr(HSM_L1_RtCtxType *pCtx) { const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tEccCalc.pParm->u32HSMStatusRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccCalc.eOutFmt) { hsm_u32_array_swap(pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResultx, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount / 4U); /* 4B -> 1B */ hsm_rm_prefix_zeros(HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResultx, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeX) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccCalc.pResultBufX, pStart, u32ActualSize); if (0u != pCtx->tL1AlgCtx.tEccCalc.pResultByteCntX) { *pCtx->tL1AlgCtx.tEccCalc.pResultByteCntX = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } else { hsm_rm_prefix_zeros(HSM_DATA_FORMAT_4B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResultx, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeX) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccCalc.pResultBufX, pStart, u32ActualSize); if (pCtx->tL1AlgCtx.tEccCalc.pResultByteCntX) { *pCtx->tL1AlgCtx.tEccCalc.pResultByteCntX = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } if (HSM_STATUS_SUCCESS == eRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccCalc.eOutFmt) { hsm_u32_array_swap(pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResulty, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount / 4U); /* 4B -> 1B */ hsm_rm_prefix_zeros(HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResulty, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeX) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccCalc.pResultBufY, pStart, u32ActualSize); if (pCtx->tL1AlgCtx.tEccCalc.pResultByteCntY) { *pCtx->tL1AlgCtx.tEccCalc.pResultByteCntY = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } else { hsm_rm_prefix_zeros(HSM_DATA_FORMAT_4B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.pResulty, pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tEccCalc.u32ResultBufSizeY) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { hsm_memcpy(pCtx->tL1AlgCtx.tEccCalc.pResultBufY, pStart, u32ActualSize); if (0u != pCtx->tL1AlgCtx.tEccCalc.pResultByteCntY) { *pCtx->tL1AlgCtx.tEccCalc.pResultByteCntY = u32ActualSize; } eRet = HSM_STATUS_SUCCESS; } } } /* else do nothing */ pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_EccCalculatePoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { if (pCtx->tL1AlgCtx.tEccCalc.pParm->tCfg.u32CalcType != HSM_ECC_CALC_PCHK) { eRet = HSM_L1_EccDecrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_ERROR_STOP; } } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccCalculateReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_CMacSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_CMAC; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tCMacInf.pParm = (HSMCom_CMacExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tCMacInf.aParmBuf[0])); pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataOutput = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &pCtx->tL1AlgCtx.tCMacInf.aResultCacheBuf[0]); pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.u32OutputMemSize = sizeof( pCtx->tL1AlgCtx.tCMacInf.aResultCacheBuf); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_CMacReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_CMAC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_CMacExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_CMAC == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_CMac(HSM_L1_RtCtxType *pCtx, const HSM_Ln_CMacType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; hsm_uint32_t *pInputCache; hsm_uint32_t u32GenMacByteCnt; hsm_uint32_t u32ActualGenMacByteCnt; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && ((NULL_PTR != pCfg->pDataOutput) || ((HSM_FALSE != pCfg->bCheckMacEn) && (NULL_PTR != pCfg->pVerifyResult))) && ((HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) || ((pCfg->u32ResultBufSize >= 4u) && (0u == (pCfg->u32ResultBufSize & 0x3)))) && ((HSM_FALSE == pCfg->bCheckMacEn) || (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) || ((pCfg->u32CheckByteCnt >= 4u) && (0u == (pCfg->u32CheckByteCnt & 0x3))))) /* not check the input address 4byte aligned here for eco support this */ { bInProcess = pCtx->bInProcess; if (HSM_XCMAC_ENGINE_AES == pCfg->eEngine) { if (HSM_AES_KEY_NEW == pCfg->eUseKeyType) { if (HSM_AES_KEY128 == pCfg->tNewKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else if (HSM_AES_KEY192 == pCfg->tNewKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else if (HSM_AES_KEY256 == pCfg->tNewKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else if (HSM_AES_KEY_CHIP_VENDOR_IFR == pCfg->eUseKeyType) { if (HSM_AES_KEY128 == pCfg->tVendorKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else if (HSM_AES_KEY192 == pCfg->tVendorKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else if (HSM_AES_KEY256 == pCfg->tVendorKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { if (HSM_AES_KEY_NEW == pCfg->eUseKeyType) { if (HSM_AES_KEY128 == pCfg->tNewKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else if (HSM_AES_KEY_CHIP_VENDOR_IFR == pCfg->eUseKeyType) { if (HSM_AES_KEY128 == pCfg->tVendorKeyInf.eKeyType) { u32ActualGenMacByteCnt = 16u; if (pCfg->u32GenMacByteCnt > 16u) { u32GenMacByteCnt = 16u; } else { u32GenMacByteCnt = pCfg->u32GenMacByteCnt; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } } if (HSM_STATUS_SUCCESS == eRet) { if ((HSM_TRUE == bInProcess) && (HSM_OP_CMAC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { if (u32GenMacByteCnt > pCfg->u32ResultBufSize) { u32GenMacByteCnt = pCfg->u32ResultBufSize; } pCtx->tL1AlgCtx.tCMacInf.pResultBuf = pCfg->pDataOutput; pCtx->tL1AlgCtx.tCMacInf.u32ResultBufByteCnt = u32GenMacByteCnt; pCtx->tL1AlgCtx.tCMacInf.pOutResultSize = pCfg->pResultSize; pCtx->tL1AlgCtx.tCMacInf.bCheckMac = pCfg->bCheckMacEn; pCtx->tL1AlgCtx.tCMacInf.pMacToCheck = pCfg->pCheckExternalMac; pCtx->tL1AlgCtx.tCMacInf.u32MacToCheckByteCnt = pCfg->u32CheckByteCnt; pCtx->tL1AlgCtx.tCMacInf.pVerifyResult = pCfg->pVerifyResult; pCtx->tL1AlgCtx.tCMacInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tCMacInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tCMacInf.pParm->u32UserKeyID = pCfg->u32NewKeyId; pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.eUseKeyType = pCfg->eUseKeyType; hsm_memcpy(&(pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.tNewKeyInf), &(pCfg->tNewKeyInf), sizeof(HSM_AesNewKeyInfType)); hsm_memcpy(&(pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.tVendorKeyInf), &(pCfg->tVendorKeyInf), sizeof(HSM_AesVendorKeyInfType)); pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.u32GenMacByteCnt = u32ActualGenMacByteCnt; pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.bCheckMacEn = HSM_FALSE; pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataInput = (const hsm_uint32_t *)pCfg->pDataInput; pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.u32InputByteCnt = pCfg->u32InputByteCnt; pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.eEngine = pCfg->eEngine; if ((HSM_DATA_FORMAT_1B == pCfg->eInputFmt) && (0u == pCfg->u32NewKeyId) && (pCfg->u32InputByteCnt <= (sizeof(pCtx->tL1AlgCtx.tCMacInf.aInputCacheBuf) - 4u))) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tCMacInf.aInputCacheBuf[0])); hsm_core_swap_u32_array_pad(pInputCache, (pCfg->u32InputByteCnt + 3u) >> 2u, pCfg->pDataInput, pCfg->u32InputByteCnt, 0u, HSM_TRUE, HSM_TRUE); pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataInput = pInputCache; if (HSM_AES_KEY_NEW == pCfg->eUseKeyType) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tCMacInf.aResultCacheBuf[0])); if (HSM_AES_KEY128 == pCfg->tNewKeyInf.eKeyType) { hsm_core_swap_u32_array_pad(pInputCache, 4U, pCfg->tNewKeyInf.pKeyAddr, 16U, 0u, HSM_TRUE, HSM_TRUE); } else if (HSM_AES_KEY192 == pCfg->tNewKeyInf.eKeyType) { hsm_core_swap_u32_array_pad(pInputCache, 6U, pCfg->tNewKeyInf.pKeyAddr, 24U, 0u, HSM_TRUE, HSM_TRUE); } else /* AES 256 */ { hsm_core_swap_u32_array_pad(pInputCache, 8U, pCfg->tNewKeyInf.pKeyAddr, 32U, 0u, HSM_TRUE, HSM_TRUE); } pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.tNewKeyInf.pKeyAddr = (const hsm_uint8_t *)pInputCache; } pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.eInputFmt = HSM_DATA_FORMAT_4B; } else { pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; } pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tCMacInf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tCMacInf.bSwapOut = HSM_FALSE; } eRet = HSM_CMacEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tCMacInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_CMac_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; Crypto_VerifyResultType eVerifyRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tCMacInf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tCMacInf.bSwapOut) { hsm_u32_array_swap(pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataOutput, (pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.u32GenMacByteCnt + 3u) >> 2u); } else { } if (HSM_TRUE == (pCtx->tL1AlgCtx.tCMacInf.bCheckMac)) { if (0 == hsm_memcmp(pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataOutput, pCtx->tL1AlgCtx.tCMacInf.pMacToCheck, pCtx->tL1AlgCtx.tCMacInf.u32MacToCheckByteCnt)) { eVerifyRet = CRYPTO_E_VER_OK; } else { eVerifyRet = CRYPTO_E_VER_NOT_OK; } if (NULL_PTR != (pCtx->tL1AlgCtx.tCMacInf.pVerifyResult)) { hsm_memcpy(pCtx->tL1AlgCtx.tCMacInf.pVerifyResult, &eVerifyRet, sizeof(eVerifyRet)); } else { ; } } if (NULL_PTR != (pCtx->tL1AlgCtx.tCMacInf.pResultBuf)) { hsm_memcpy(pCtx->tL1AlgCtx.tCMacInf.pResultBuf, pCtx->tL1AlgCtx.tCMacInf.pParm->tCfg.pDataOutput, pCtx->tL1AlgCtx.tCMacInf.u32ResultBufByteCnt); } else { } if (NULL_PTR != pCtx->tL1AlgCtx.tCMacInf.pOutResultSize) { hsm_memcpy(pCtx->tL1AlgCtx.tCMacInf.pOutResultSize, &(pCtx->tL1AlgCtx.tCMacInf.u32ResultBufByteCnt), sizeof(pCtx->tL1AlgCtx.tCMacInf.u32ResultBufByteCnt)); } else { } eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_CMacPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_CMAC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_CMac_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesEncryptSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_AES_ENCRYPT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tAesEncryptInf.pParm = (HSMCom_FlexAesEncryptType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesEncryptInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesEncryptReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesEncryptExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_ENCRYPT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesEncrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_AesEncryptType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; hsm_uint32_t *pInputCache; hsm_uint32_t u32ResultLen; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32InputByteCnt > 0u)) /* not check the input address 4byte aligned here for eco support this */ { if (HSM_FLEXAES_PAD_ZERO == pCfg->ePad) { u32ResultLen = (pCfg->u32InputByteCnt + 0xfu) & 0xfffffff0u; } else /* HSM_FLEXAES_PAD_PKCS7 */ { u32ResultLen = (pCfg->u32InputByteCnt + 0x10u) & 0xfffffff0u; } if (u32ResultLen <= pCfg->u32OutputMemSize) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tAesEncryptInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->u32UserKeyID = pCfg->u32KeyId; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eUseKeyType = pCfg->eUseKeyType; hsm_memcpy(&(pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.tNewKeyInf), &(pCfg->tNewKeyInf), sizeof(HSM_AesNewKeyInfType)); hsm_memcpy(&(pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.tVendorKeyInf), &(pCfg->tVendorKeyInf), sizeof(HSM_AesVendorKeyInfType)); pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eAesAlg = pCfg->eAesAlg; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataInput = pCfg->pDataInput; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.u32InputByteCnt = pCfg->u32InputByteCnt; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataOutput = pCfg->pDataOutput; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.u32OutputMemSize = pCfg->u32OutputMemSize; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pIvData = (hsm_uint8_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tAesEncryptInf.aIvData[0])); pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.ePad = pCfg->ePad; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (NULL_PTR != pCfg->pGenerateOutByteCnt) { pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pGenerateOutByteCnt = pCfg->pGenerateOutByteCnt; } else { pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pGenerateOutByteCnt = &( pCtx->tL1AlgCtx.tAesEncryptInf.u32HsmRetResultSize); } if ((HSM_DATA_FORMAT_1B == pCfg->eInputFmt) && (0u == pCfg->u32KeyId) && (pCfg->u32InputByteCnt <= (sizeof(pCtx->tL1AlgCtx.tAesEncryptInf.aInputCacheBuf) - 4u))) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesEncryptInf.aInputCacheBuf[0])); hsm_core_swap_u32_array_pad(pInputCache, (pCfg->u32InputByteCnt + 3u) >> 2u, pCfg->pDataInput, pCfg->u32InputByteCnt, 0u, HSM_TRUE, HSM_TRUE); if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_core_swap_u32_array_pad( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesEncryptInf.aIvData[0])), 4u, pCfg->pIvData, 16u, 0u, HSM_TRUE, HSM_TRUE); } pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataInput = (const hsm_uint8_t *)pInputCache; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataOutput = (hsm_uint8_t *)&(pCtx->tL1AlgCtx.tAesEncryptInf.aResultCacheBuf[0]); pCtx->tL1AlgCtx.tAesEncryptInf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tAesEncryptInf.bSwapOut = HSM_FALSE; } pCtx->tL1AlgCtx.tAesEncryptInf.pResultBuf = pCfg->pDataOutput; pCtx->tL1AlgCtx.tAesEncryptInf.u32ResultByteCnt = u32ResultLen; if (HSM_AES_KEY_NEW == pCfg->eUseKeyType) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesEncryptInf.aResultCacheBuf[0])); if (HSM_AES_KEY128 == pCfg->tNewKeyInf.eKeyType) { hsm_core_swap_u32_array_pad(pInputCache, 4U, pCfg->tNewKeyInf.pKeyAddr, 16U, 0u, HSM_TRUE, HSM_TRUE); } else if (HSM_AES_KEY192 == pCfg->tNewKeyInf.eKeyType) { hsm_core_swap_u32_array_pad(pInputCache, 6U, pCfg->tNewKeyInf.pKeyAddr, 24U, 0u, HSM_TRUE, HSM_TRUE); } else /* AES 256 */ { hsm_core_swap_u32_array_pad(pInputCache, 8U, pCfg->tNewKeyInf.pKeyAddr, 32U, 0u, HSM_TRUE, HSM_TRUE); } pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.tNewKeyInf.pKeyAddr = (const hsm_uint8_t *)pInputCache; } /* else do nothing */ } else { if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_memcpy((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesEncryptInf.aIvData[0])), pCfg->pIvData, 16u); } pCtx->tL1AlgCtx.tAesEncryptInf.bSwapOut = HSM_FALSE; pCtx->tL1AlgCtx.tAesEncryptInf.pResultBuf = pCfg->pDataOutput; pCtx->tL1AlgCtx.tAesEncryptInf.u32ResultByteCnt = u32ResultLen; } eRet = HSM_AesEncryptEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tAesEncryptInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_AesEncrypt_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tAesEncryptInf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tAesEncryptInf.bSwapOut) { hsm_u32_array_swap( (hsm_uint32_t *)(pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataOutput), pCtx->tL1AlgCtx.tAesEncryptInf.u32ResultByteCnt >> 2u); hsm_memcpy(pCtx->tL1AlgCtx.tAesEncryptInf.pResultBuf, pCtx->tL1AlgCtx.tAesEncryptInf.pParm->tCfg.pDataOutput, pCtx->tL1AlgCtx.tAesEncryptInf.u32ResultByteCnt); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_SUCCESS; } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_AesEncryptPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_AesEncrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesDecryptSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_AES_DECRYPT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tAesDecryptInf.pParm = (HSMCom_FlexAesDecryptType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesDecryptInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesDecryptReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesDecryptExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_DECRYPT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_AesDecrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_AesDecryptType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; hsm_uint8_t *pU8Cache; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32InputByteCnt > 0u) && (!(pCfg->u32InputByteCnt & 0xf))) /* not check the input address 4byte aligned here for eco support this */ { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pU8Cache = (hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tAesDecryptInf.aIvData[0])); pCtx->tL1AlgCtx.tAesDecryptInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->u32UserKeyID = pCfg->u32KeyId; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.eUseKeyType = pCfg->eUseKeyType; hsm_memcpy(&(pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.tNewKeyInf), &(pCfg->tNewKeyInf), sizeof(HSM_AesNewKeyInfType)); hsm_memcpy(&(pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.tVendorKeyInf), &(pCfg->tVendorKeyInf), sizeof(HSM_AesVendorKeyInfType)); pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.eAesAlg = pCfg->eAesAlg; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.pDataInput = pCfg->pDataInput; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.u32InputByteCnt = pCfg->u32InputByteCnt; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.pDataOutput = pCfg->pDataOutput; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.u32OutputMemSize = pCfg->u32OutputMemSize; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.pIvData = pU8Cache; /* pCfg->pIvData; */ pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.ePad = pCfg->ePad; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_memcpy(pU8Cache, pCfg->pIvData, 16u); } if (NULL_PTR != pCfg->pGenerateOutByteCnt) { pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.pGenerateOutByteCnt = pCfg->pGenerateOutByteCnt; } else { pCtx->tL1AlgCtx.tAesDecryptInf.pParm->tCfg.pGenerateOutByteCnt = &( pCtx->tL1AlgCtx.tAesDecryptInf.u32HsmRetResultSize); } eRet = HSM_AesDecryptEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tAesDecryptInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_AesDecrypt_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tAesDecryptInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_AesDecryptPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_AES_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_AesDecrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4EncryptSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SM4_ENCRYPT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm = (HSMCom_Sm4EncryptExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4EncryptInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4EncryptReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4EncryptExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_ENCRYPT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4Encrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm4EncryptType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; hsm_uint32_t *pInputCache; hsm_uint32_t u32ResultLen; hsm_uint8_t *pU8Cache; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32InputByteCnt > 0u)) /* not check the input address 4byte aligned here for eco support this */ { if (HSM_FLEXAES_PAD_ZERO == pCfg->ePad) { u32ResultLen = (pCfg->u32InputByteCnt + 0xfu) & 0xfffffff0u; } else /* HSM_FLEXAES_PAD_PKCS7 */ { u32ResultLen = (pCfg->u32InputByteCnt + 0x10u) & 0xfffffff0u; } if (u32ResultLen <= pCfg->u32OutputMemSize) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pU8Cache = (hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4EncryptInf.aIvData[0])); pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->u32UserKeyID = pCfg->u32KeyId; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eUseKeyType = pCfg->eUseKeyType; hsm_memcpy(&(pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.tNewKeyInf), &(pCfg->tNewKeyInf), sizeof(HSM_AesNewKeyInfType)); hsm_memcpy(&(pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.tVendorKeyInf), &(pCfg->tVendorKeyInf), sizeof(HSM_AesVendorKeyInfType)); pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eAesAlg = pCfg->eAesAlg; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataInput = pCfg->pDataInput; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.u32InputByteCnt = pCfg->u32InputByteCnt; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataOutput = pCfg->pDataOutput; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.u32OutputMemSize = pCfg->u32OutputMemSize; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pIvData = pU8Cache; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.ePad = pCfg->ePad; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (NULL_PTR != pCfg->pGenerateOutByteCnt) { pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pGenerateOutByteCnt = pCfg->pGenerateOutByteCnt; } else { pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pGenerateOutByteCnt = &( pCtx->tL1AlgCtx.tSm4EncryptInf.u32HsmRetResultSize); } if ((HSM_DATA_FORMAT_1B == pCfg->eInputFmt) && (0u == pCfg->u32KeyId) && (pCfg->u32InputByteCnt <= (sizeof(pCtx->tL1AlgCtx.tSm4EncryptInf.aInputCacheBuf) - 4u))) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4EncryptInf.aInputCacheBuf[0])); hsm_core_swap_u32_array_pad(pInputCache, (pCfg->u32InputByteCnt + 3u) >> 2u, pCfg->pDataInput, pCfg->u32InputByteCnt, 0u, HSM_TRUE, HSM_TRUE); if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_core_swap_u32_array_pad((hsm_uint32_t *)pU8Cache, 4u, pCfg->pIvData, 16u, 0u, HSM_TRUE, HSM_TRUE); } pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataInput = (const hsm_uint8_t *)pInputCache; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataOutput = (hsm_uint8_t *)&(pCtx->tL1AlgCtx.tSm4EncryptInf.aResultCacheBuf[0]); pCtx->tL1AlgCtx.tSm4EncryptInf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tSm4EncryptInf.bSwapOut = HSM_FALSE; } pCtx->tL1AlgCtx.tSm4EncryptInf.pResultBuf = pCfg->pDataOutput; pCtx->tL1AlgCtx.tSm4EncryptInf.u32ResultByteCnt = u32ResultLen; if (HSM_AES_KEY_NEW == pCfg->eUseKeyType) { pInputCache = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4EncryptInf.aResultCacheBuf[0])); hsm_core_swap_u32_array_pad(pInputCache, 4U, pCfg->tNewKeyInf.pKeyAddr, 16, 0u, HSM_TRUE, HSM_TRUE); pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.tNewKeyInf.pKeyAddr = (const hsm_uint8_t *)pInputCache; } } else { if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_memcpy(pU8Cache, pCfg->pIvData, 16U); } pCtx->tL1AlgCtx.tSm4EncryptInf.bSwapOut = HSM_FALSE; pCtx->tL1AlgCtx.tSm4EncryptInf.pResultBuf = pCfg->pDataOutput; pCtx->tL1AlgCtx.tSm4EncryptInf.u32ResultByteCnt = u32ResultLen; } eRet = HSM_Sm4EncryptExStart(&(pCtx->tCmd), &(pCtx->tL1AlgCtx.tSm4EncryptInf.tWrapper), pCtx->tL1AlgCtx.tSm4EncryptInf.pParm); if ((HSM_STATUS_AGAIN == eRet) || (HSM_STATUS_FINISH == eRet)) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4Encrypt_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tSm4EncryptInf.bSwapOut) { hsm_u32_array_swap((hsm_uint32_t *)pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataOutput, pCtx->tL1AlgCtx.tSm4EncryptInf.u32ResultByteCnt >> 2u); hsm_memcpy(pCtx->tL1AlgCtx.tSm4EncryptInf.pResultBuf, pCtx->tL1AlgCtx.tSm4EncryptInf.pParm->tCfg.pDataOutput, pCtx->tL1AlgCtx.tSm4EncryptInf.u32ResultByteCnt); } else { ; } eRet = HSM_Sm4EncryptExUpdate(&(pCtx->tCmd), &(pCtx->tL1AlgCtx.tSm4EncryptInf.tWrapper)); if ((HSM_STATUS_AGAIN == eRet) || (HSM_STATUS_FINISH == eRet)) { eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } else { eRet = HSM_STATUS_AGAIN; } } else if (HSM_STATUS_ALREADY_FINISHED == eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SUCCESS; } else { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_ERROR; } } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm4EncryptPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_ENCRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sm4Encrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4DecryptSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SM4_DECRYPT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm = (HSMCom_Sm4DecryptExType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4DecryptInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4DecryptReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4DecryptExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_DECRYPT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4Decrypt(HSM_L1_RtCtxType *pCtx, const HSM_Ln_Sm4DecryptType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32InputByteCnt > 0u) && (!(pCfg->u32InputByteCnt & 0xf))) /* not check the input address 4byte aligned here for eco support this */ { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->u32UserKeyID = pCfg->u32KeyId; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.eUseKeyType = pCfg->eUseKeyType; hsm_memcpy(&(pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.tNewKeyInf), &(pCfg->tNewKeyInf), sizeof(HSM_AesNewKeyInfType)); hsm_memcpy(&(pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.tVendorKeyInf), &(pCfg->tVendorKeyInf), sizeof(HSM_AesVendorKeyInfType)); pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.eAesAlg = pCfg->eAesAlg; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.pDataInput = pCfg->pDataInput; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.u32InputByteCnt = pCfg->u32InputByteCnt; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.pDataOutput = pCfg->pDataOutput; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.u32OutputMemSize = pCfg->u32OutputMemSize; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.pIvData = (hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tSm4DecryptInf.aIvData[0])); pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.ePad = pCfg->ePad; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (HSM_SYMM_ENDECRYPT_MODE_ECB != pCfg->eAesAlg) { hsm_memcpy((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tSm4DecryptInf.aIvData[0])), pCfg->pIvData, 16U); } if (NULL_PTR != pCfg->pGenerateOutByteCnt) { pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.pGenerateOutByteCnt = pCfg->pGenerateOutByteCnt; } else { pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->tCfg.pGenerateOutByteCnt = &( pCtx->tL1AlgCtx.tSm4DecryptInf.u32HsmRetResultSize); } eRet = HSM_Sm4DecryptEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tSm4DecryptInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm4Decrypt_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tSm4DecryptInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm4DecryptPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM4_DECRYPT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sm4Decrypt_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_BnCalcSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_BN_CALC; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm = (HSMCom_BigNumberCalcExtType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tBnCalcInf.aBnCalcParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_BnCalcExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_BN_CALC == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } hsm_uint32_t hsm_pkam_get_actual_size(HSM_DataFormatType eDataFormat, const void *pData, hsm_uint32_t u32ByteCount, const hsm_uint8_t **ppLastNonZero) { hsm_int32_t s32Idx; HSM_BoolType bFindNonZero = HSM_FALSE; const hsm_uint8_t *pLastNoneZeroByte = (const hsm_uint8_t *)pData; const hsm_uint8_t *pInterU8 = (const hsm_uint8_t *)pData; if (HSM_DATA_FORMAT_1B == eDataFormat) { while ((u32ByteCount > 0u) && (0u == *pInterU8)) { pInterU8++; u32ByteCount--; } pLastNoneZeroByte = pInterU8; } else { while (u32ByteCount > 3u) { for (s32Idx = 3; s32Idx >= 0; --s32Idx) { if (0u == pInterU8[s32Idx]) { u32ByteCount--; } else { bFindNonZero = HSM_TRUE; pLastNoneZeroByte = (const hsm_uint8_t *)pInterU8 + s32Idx; break; } } if (HSM_TRUE == bFindNonZero) { break; } else { ; /* nothing to do */ } pInterU8 += 4u; } if (HSM_TRUE != bFindNonZero) { for (s32Idx = 3; s32Idx >= (4 - (hsm_int8_t)u32ByteCount); --s32Idx) { if (0u == pInterU8[s32Idx]) { u32ByteCount--; } else { bFindNonZero = HSM_TRUE; pLastNoneZeroByte = pInterU8 + s32Idx; break; } } } } if (NULL_PTR != ppLastNonZero) { *ppLastNonZero = pLastNoneZeroByte; } else { ; /* nothing to do */ } return u32ByteCount; } /* if 4B format input, but size error, return HSM_STATUS_PARAM_ERR, others, HSM_STATUS_SUCCESS */ 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 eRet = HSM_STATUS_SUCCESS; const hsm_uint8_t *pLastNonZero; hsm_uint32_t u32Size; hsm_uint32_t u32Idx; hsm_uint32_t u32Data; if (u32ByteCnt > 0) { if (HSM_DATA_FORMAT_1B == eFmt) { u32Size = hsm_pkam_get_actual_size(eFmt, pData, u32ByteCnt, &pLastNonZero); if (u32Size > 0u) { for (u32Idx = 8u; u32Idx > 0u; u32Idx--) { if (pLastNonZero[0] & (((hsm_uint8_t)0x1u) << (u32Idx - 1u))) { break; } } u32Size = u32Idx + ((u32Size - 1u) * 8u); } /* else do nothing */ } else if ((HSM_DATA_FORMAT_4B == eFmt) && (u32ByteCnt >= 4u) && (0u == (u32ByteCnt & 0x3u))) { u32Size = hsm_pkam_get_actual_size(eFmt, pData, u32ByteCnt, &pLastNonZero); if (u32Size > 0u) { u32Data = ((hsm_uint32_t)pLastNonZero[0u]); for (u32Idx = 8u; u32Idx > 0u; u32Idx--) { if (u32Data & ((hsm_uint32_t)(((hsm_uint8_t)0x1u) << (u32Idx - 1u)))) { break; } } u32Size = u32Idx + ((u32Size - 1u) * 8u); } /* else do nothing */ } else { eRet = HSM_STATUS_PARAM_ERR; } } else { u32Size = 0u; } if ((HSM_STATUS_SUCCESS == eRet) && (pBitCnt)) { hsm_memcpy(pBitCnt, &u32Size, sizeof(u32Size)); } /* else do nothing */ return eRet; } /* For interrupt usage */ HSM_StatusType HSM_L1_BnCalc(HSM_L1_RtCtxType *pCtx, const HSM_L1_BnCalcType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; hsm_uint32_t u32PassToHsmCoreSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (pCfg->u32BitCnt <= 4096U) && (pCfg->eCalcType <= HSM_L1_BNCALC_A_RECIPROCAL) && (NULL_PTR != pCfg->pA) && (pCfg->u32AByteCount > 0u) && ((pCfg->eCalcType > HSM_L1_BNCALC_A_x_B) || ((NULL_PTR != pCfg->pB) && (pCfg->u32BByteCount > 0u))) && ((pCfg->eCalcType != HSM_L1_BNCALC_A_Exp_E) || ((0u != pCfg->u32KeyEId) || ((NULL_PTR != pCfg->pE) && (pCfg->u32EByteCount > 0u)))) && ((0u != pCfg->u32KeyNId) || ((NULL_PTR != pCfg->pN) && (pCfg->u32NByteCount > 0u))) && (NULL_PTR != pCfg->pResult)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_BN_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32DataValidFlag = 0u; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32UserKeyID_KEY_E = pCfg->u32KeyEId; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32BitCnt = pCfg->u32BitCnt; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pA = pCfg->pA; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32AByteCount = pCfg->u32AByteCount; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eInputDataFmt = pCfg->eAFmt; /* load e */ if (pCfg->eCalcType == HSM_L1_BNCALC_A_Exp_E) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eKeyEFmt = pCfg->eEFmt; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32EByteCount = pCfg->u32EByteCount; if (pCfg->u32KeyEId) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pE = NULL_PTR; } else { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pE = pCfg->pE; } pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32DataValidFlag |= HSM_BN_VALID_FLAG_E; } else { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32UserKeyID_KEY_E = 0u; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32EByteCount = 0u; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pE = NULL_PTR; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eKeyEFmt = HSM_DATA_FORMAT_4B; } if (pCfg->u32KeyNId) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pN = NULL_PTR; } else { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pN = pCfg->pN; } pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32NByteCount = pCfg->u32NByteCount; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eKeyNFmt = pCfg->eNFmt; if (HSM_DATA_FORMAT_1B_PAD_0_LEFT_FIT_BUF != pCfg->eResultFmt) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResult = pCfg->pResult; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32ResultBufByteCnt = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResultByteCount = pCfg->pResultByteCnt; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eOutputFmt = pCfg->eResultFmt; if (NULL_PTR == pCfg->pResultByteCnt) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResultByteCount = &( pCtx->tL1AlgCtx.tBnCalcInf.u32ResultByteCnt); } if (NULL_PTR == pCfg->pResult) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32ResultBufByteCnt = 0u; } if (0u == pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32ResultBufByteCnt) { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResult = (hsm_uint8_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tBnCalcInf.aResultCache[0])); } } else { pCtx->tL1AlgCtx.tBnCalcInf.pResultBuf = pCfg->pResult; pCtx->tL1AlgCtx.tBnCalcInf.u32ResultBufSize = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tBnCalcInf.pResultByteCnt = pCfg->pResultByteCnt; pCtx->tL1AlgCtx.tBnCalcInf.eOutFmt = pCfg->eResultFmt; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResult = (hsm_uint8_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tBnCalcInf.aResultCache[0])); pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32ResultBufByteCnt = sizeof(pCtx->tL1AlgCtx.tBnCalcInf.aResultCache) - 4u; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResultByteCount = &( pCtx->tL1AlgCtx.tBnCalcInf.u32ResultByteCnt); pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_1B; } pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32CalcType = (hsm_uint32_t)(pCfg->eCalcType) + HSM_BIGNUMBER_CALC_A_ADD_B; /* load b */ if (pCfg->eCalcType <= HSM_L1_BNCALC_A_x_B) { if (pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.eInputDataFmt != pCfg->eBFmt) { u32PassToHsmCoreSize = ((pCfg->u32BByteCount + 7u) >> 3u) << 3u; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pB = (const hsm_uint8_t *)&( pCtx->tL1AlgCtx.tBnCalcInf.aB[0]); pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32BByteCount = u32PassToHsmCoreSize; hsm_rm_prefix_zeros(pCfg->eBFmt, pCfg->pB, pCfg->u32BByteCount, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tBnCalcInf.aB[0])), 0, u32PassToHsmCoreSize - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tBnCalcInf.aB[0]))) + (u32PassToHsmCoreSize - u32ActualSize), pStart, u32ActualSize); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tBnCalcInf.aB[0])), u32PassToHsmCoreSize >> 2u); } else { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pB = pCfg->pB; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32BByteCount = pCfg->u32BByteCount; } pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32DataValidFlag |= HSM_BN_VALID_FLAG_B; } else { pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pB = NULL_PTR; pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.u32BByteCount = 0u; } eRet = HSM_FW_BigNumberCalculateEx(&(pCtx->tCmd), pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } /* else do nothing */ } /* else do nothing */ } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_BnCalc_Isr(HSM_L1_RtCtxType *pCtx) { const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->u32HSMStatusRet) { if (HSM_DATA_FORMAT_1B_PAD_0_LEFT_FIT_BUF == pCtx->tL1AlgCtx.tBnCalcInf.eOutFmt) { hsm_rm_prefix_zeros( HSM_DATA_FORMAT_1B, (const hsm_uint8_t *)pCtx->tL1AlgCtx.tBnCalcInf.pBnCalcParm->tCfg.pResult, pCtx->tL1AlgCtx.tBnCalcInf.u32ResultByteCnt, &pStart, &u32ActualSize); if (u32ActualSize > pCtx->tL1AlgCtx.tBnCalcInf.u32ResultBufSize) { eRet = HSM_STATUS_BUFFER_SIZE_ERR; } else { if (NULL_PTR != pCtx->tL1AlgCtx.tBnCalcInf.pResultBuf) { hsm_memset(pCtx->tL1AlgCtx.tBnCalcInf.pResultBuf, 0, pCtx->tL1AlgCtx.tBnCalcInf.u32ResultBufSize - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)pCtx->tL1AlgCtx.tBnCalcInf.pResultBuf) + (pCtx->tL1AlgCtx.tBnCalcInf.u32ResultBufSize - u32ActualSize), pStart, u32ActualSize); } if (NULL_PTR != pCtx->tL1AlgCtx.tBnCalcInf.pResultByteCnt) { *pCtx->tL1AlgCtx.tBnCalcInf.pResultByteCnt = pCtx->tL1AlgCtx.tBnCalcInf.u32ResultBufSize; } eRet = HSM_STATUS_SUCCESS; } } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_BnCalcPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_BN_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_BnCalc_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_BnCalcReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_BN_CALC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ScatterHashSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SCATTER_HASH; pCtx->eStat = HSM_DRV_SM_READY; hsm_memset(&(pCtx->tL1AlgCtx.tScatterHash), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash)); pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bGenerateMacEn = HSM_FALSE; pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData = (const hsm_uint8_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])); pCtx->tL1AlgCtx.tScatterHash.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_READY; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm = (HSMCom_ScatterHashType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.tScatterHashParamShared.aScatterHashParmBuf[0])); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.pResult = &( pCtx->tL1AlgCtx.tScatterHash.tScatterHashResultShared.aHashCtx); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.bGenerateMacEn = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bGenerateMacEn; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.tKeyInfo.pKeyData = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ScatterHashSetMacCfg(HSM_L1_RtCtxType *pCtx, HSM_Ln_HashMacCfgType *ptCfg) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; hsm_uint32_t u32Temp; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata) && (HSM_L1_SCATTER_HASH_READY == pCtx->tL1AlgCtx.tScatterHash.eState)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { if (ptCfg->u32KeyByteCnt <= (4 * 0x20)) { pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bGenerateMacEn = ptCfg->bGenerateMacEn; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.bGenerateMacEn = ptCfg->bGenerateMacEn; if (HSM_FALSE != ptCfg->bGenerateMacEn) { pCtx->tL1AlgCtx.tScatterHash.tMacCfg.eMacType = ptCfg->eMacType; pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32KeyByteCnt = ptCfg->u32KeyByteCnt; pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32GenerateMacByteCnt = ptCfg->u32GenerateMacByteCnt; pCtx->tL1AlgCtx.tScatterHash.tMacCfg.eKeyDataFmt = ptCfg->eKeyDataFmt; pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId = ptCfg->bKeyUseId; if (HSM_FALSE == ptCfg->bKeyUseId) { u32Temp = ((ptCfg->u32KeyByteCnt + 3u) >> 2u) << 2u; hsm_memset((void *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])), 0, u32Temp); hsm_memcpy((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])), ptCfg->tHashMacKeyInfo.pKeyData, ptCfg->u32KeyByteCnt); if (HSM_DATA_FORMAT_1B == ptCfg->eKeyDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])), u32Temp >> 2u); } /* else do nothing */ pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData = (const hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.tKeyInfo.pKeyData = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData; } else { pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.u32KeyId = ptCfg->tHashMacKeyInfo.u32KeyId; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.tKeyInfo.u32KeyId = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.u32KeyId; } pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.eMacType = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.eMacType; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32KeyByteCnt = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32KeyByteCnt; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32GenerateMacByteCnt = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32GenerateMacByteCnt; } else { pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData = (const hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterHash.aMacKeyCache[0])); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.tKeyInfo.pKeyData = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } static HSM_StatusType hsm_l1_scatter_hash_init(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt) { HSM_StatusType eRet = HSM_FW_ScatterHashInit(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm, pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId, eInputFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_hash_update(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt) { HSM_StatusType eRet = HSM_FW_ScatterHashUpdate(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm, pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId, eInputFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_hash_final(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt) { HSM_StatusType eRet = HSM_FW_ScatterHashFinal(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm, pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId, eInputFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_hash_init2final(HSM_L1_RtCtxType *pCtx, HSMCom_ShaExType *pShaParm) { HSM_StatusType eRet = HSM_FW_ShaEx(&(pCtx->tCmd), pShaParm, pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } /* when need more data, return again, when trigger successfully, return success, others error */ HSM_StatusType HSM_L1_ScatterHashInit(HSM_L1_RtCtxType *pCtx, const HSM_ShaAlgType eAlg, const HSM_Ln_ScatterHashType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; HSM_DataFormatType eCurDataFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata) && (HSM_L1_SCATTER_HASH_READY == pCtx->tL1AlgCtx.tScatterHash.eState)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.eAlg = eAlg; pCtx->tL1AlgCtx.tScatterHash.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.u32OutBufSize = 0; pCtx->tL1AlgCtx.tScatterHash.eOutFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0; if (pCfg->u32DataSize <= HSM_HFAM_HW_PROCESS_ALIGN(eAlg)) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_INIT; pCtx->tL1AlgCtx.tScatterHash.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = eAlg; if ((0x3u == (((hsm_uint32_t)pCfg->pData) & 0x3u)) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if (pCfg->u32DataSize > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = sizeof( pCtx->tL1AlgCtx.tScatterHash.aDataBuf); } else { if (0u == (pCfg->u32DataSize % HSM_HFAM_HW_PROCESS_ALIGN(eAlg))) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = pCfg->u32DataSize - HSM_HFAM_HW_PROCESS_ALIGN(eAlg); } else { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = (pCfg->u32DataSize / HSM_HFAM_HW_PROCESS_ALIGN(eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(eAlg); } } eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); } eCurDataFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (pCfg->u32DataSize % HSM_HFAM_HW_PROCESS_ALIGN(eAlg))) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = pCfg->u32DataSize - HSM_HFAM_HW_PROCESS_ALIGN(eAlg); } else { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = (pCfg->u32DataSize / HSM_HFAM_HW_PROCESS_ALIGN(eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(eAlg); } pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = pCfg->pData; eCurDataFmt = pCfg->eDataFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_hash_init(pCtx, eCurDataFmt); } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* when need more data, return again, when trigger successfully, return success, others error */ HSM_StatusType HSM_L1_ScatterHashUpdate(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterHashType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_ScatterHashSMType eCurState = pCtx->tL1AlgCtx.tScatterHash.eState; HSM_BoolType bInProcess; HSM_DataFormatType eCurDataFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata) && ((HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_HASH_INIT_OK == eCurState) || (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState) || (HSM_L1_SCATTER_HASH_UPDATE_OK == eCurState))) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; if ((HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState)) { if ((pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt + pCfg->u32DataSize) > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_UPDATE; pCtx->tL1AlgCtx.tScatterHash.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf) - pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt; eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0u; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; eCurDataFmt = HSM_DATA_FORMAT_4B; if (HSM_STATUS_SUCCESS == eRet) { if (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) { eRet = hsm_l1_scatter_hash_init(pCtx, eCurDataFmt); } else { eRet = hsm_l1_scatter_hash_update(pCtx, eCurDataFmt); } } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } else { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { /* NOT change the state */ pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt += pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } } else /* init ok / update ok */ { if (pCfg->u32DataSize <= HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_UPDATE; pCtx->tL1AlgCtx.tScatterHash.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0u; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; if ((0x3u == (((hsm_uint32_t)pCfg->pData) & 0x3)) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if (pCfg->u32DataSize > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = sizeof( pCtx->tL1AlgCtx.tScatterHash.aDataBuf); } else { if (0u == (pCfg->u32DataSize % HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg))) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = pCfg->u32DataSize - HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } else { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = (pCfg->u32DataSize / HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); } eCurDataFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (pCfg->u32DataSize % HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg))) { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = pCfg->u32DataSize - HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } else { pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = (pCfg->u32DataSize / HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = pCfg->pData; eCurDataFmt = pCfg->eDataFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_hash_update(pCtx, eCurDataFmt); } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } static const hsm_uint8_t aMd5[] = { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e }; static const hsm_uint8_t aSha160[] = { 0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09 }; static const hsm_uint8_t aSha224[] = { 0xd1, 0x4a, 0x02, 0x8c, 0x2a, 0x3a, 0x2b, 0xc9, 0x47, 0x61, 0x02, 0xbb, 0x28, 0x82, 0x34, 0xc4, 0x15, 0xa2, 0xb0, 0x1f, 0x82, 0x8e, 0xa6, 0x2a, 0xc5, 0xb3, 0xe4, 0x2f }; static const hsm_uint8_t aSha256[] = { 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55 }; static const hsm_uint8_t aSha384[] = { 0x38, 0xb0, 0x60, 0xa7, 0x51, 0xac, 0x96, 0x38, 0x4c, 0xd9, 0x32, 0x7e, 0xb1, 0xb1, 0xe3, 0x6a, 0x21, 0xfd, 0xb7, 0x11, 0x14, 0xbe, 0x7, 0x43, 0x4c, 0xc, 0xc7, 0xbf, 0x63, 0xf6, 0xe1, 0xda, 0x27, 0x4e, 0xde, 0xbf, 0xe7, 0x6f, 0x65, 0xfb, 0xd5, 0x1a, 0xd2, 0xf1, 0x48, 0x98, 0xb9, 0x5b }; static const hsm_uint8_t aSha512[] = { 0xcf, 0x83, 0xe1, 0x35, 0x7e, 0xef, 0xb8, 0xbd, 0xf1, 0x54, 0x28, 0x50, 0xd6, 0x6d, 0x80, 0x7, 0xd6, 0x20, 0xe4, 0x5, 0xb, 0x57, 0x15, 0xdc, 0x83, 0xf4, 0xa9, 0x21, 0xd3, 0x6c, 0xe9, 0xce, 0x47, 0xd0, 0xd1, 0x3c, 0x5d, 0x85, 0xf2, 0xb0, 0xff, 0x83, 0x18, 0xd2, 0x87, 0x7e, 0xec, 0x2f, 0x63, 0xb9, 0x31, 0xbd, 0x47, 0x41, 0x7a, 0x81, 0xa5, 0x38, 0x32, 0x7a, 0xf9, 0x27, 0xda, 0x3e }; static const hsm_uint8_t aSha512_224[] = { 0x6e, 0xd0, 0xdd, 0x2, 0x80, 0x6f, 0xa8, 0x9e, 0x25, 0xde, 0x6, 0xc, 0x19, 0xd3, 0xac, 0x86, 0xca, 0xbb, 0x87, 0xd6, 0xa0, 0xdd, 0xd0, 0x5c, 0x33, 0x3b, 0x84, 0xf4 }; static const hsm_uint8_t aSha512_256[] = { 0xc6, 0x72, 0xb8, 0xd1, 0xef, 0x56, 0xed, 0x28, 0xab, 0x87, 0xc3, 0x62, 0x2c, 0x51, 0x14, 0x6, 0x9b, 0xdd, 0x3a, 0xd7, 0xb8, 0xf9, 0x73, 0x74, 0x98, 0xd0, 0xc0, 0x1e, 0xce, 0xf0, 0x96, 0x7a }; static const hsm_uint8_t aSm3[] = { 0x1a, 0xb2, 0x1d, 0x83, 0x55, 0xcf, 0xa1, 0x7f, 0x8e, 0x61, 0x19, 0x48, 0x31, 0xe8, 0x1a, 0x8f, 0x22, 0xbe, 0xc8, 0xc7, 0x28, 0xfe, 0xfb, 0x74, 0x7e, 0xd0, 0x35, 0xeb, 0x50, 0x82, 0xaa, 0x2b }; static const hsm_uint8_t *aHashArray[] = { &(aMd5[0]), &(aSha160[0]), &(aSha224[0]), &(aSha256[0]), &(aSha384[0]), &(aSha512[0]), &(aSha512_224[0]), &(aSha512_256[0]), &(aSm3[0]) }; static const hsm_uint8_t aHashDataSize[] = { sizeof(aMd5), sizeof(aSha160), sizeof(aSha224), sizeof(aSha256), sizeof(aSha384), sizeof(aSha512), sizeof(aSha512_224), sizeof(aSha512_256), sizeof(aSm3) }; HSM_StatusType hsm_aux_get_empty_data_hash(HSM_ShaAlgType eHash, const hsm_uint8_t **ppHashData, hsm_uint32_t *pByteCnt) { HSM_StatusType eRet; if (eHash < (sizeof(aHashArray) / sizeof(hsm_uint8_t *))) { *ppHashData = aHashArray[eHash]; *pByteCnt = aHashDataSize[eHash]; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } /* when need more data, return again, when trigger successfully, return success, others error */ 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 eRet = HSM_STATUS_SUCCESS; HSM_ScatterHashSMType eCurState = pCtx->tL1AlgCtx.tScatterHash.eState; HSM_BoolType bInProcess; HSM_DataFormatType eCurDataFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata) && ((HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_HASH_INIT_OK == eCurState) || (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState) || (HSM_L1_SCATTER_HASH_UPDATE_OK == eCurState))) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pOut = pResult->pData; pCtx->tL1AlgCtx.tScatterHash.u32OutBufSize = pResult->u32DataBufSize; pCtx->tL1AlgCtx.tScatterHash.eOutFmt = pResult->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.pOutSize = pResult->pDataSize; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_FINAL; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; if ((HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState) || (((hsm_uint32_t)pCfg->pData) & 0x3) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if ((pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt + pCfg->u32DataSize) > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { pCtx->tL1AlgCtx.tScatterHash.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf) - pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt; eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0u; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf); pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); eCurDataFmt = HSM_DATA_FORMAT_4B; if (HSM_STATUS_SUCCESS == eRet) { if (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) { eRet = hsm_l1_scatter_hash_init(pCtx, eCurDataFmt); } else { eRet = hsm_l1_scatter_hash_update(pCtx, eCurDataFmt); } } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } else if ((pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt + pCfg->u32DataSize) > 0) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt += pCfg->u32DataSize; if (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) { HSMCom_ShaExType *pShaParm = (HSMCom_ShaExType *)HSM_ADDRESS_UP_ALIGN(&( pCtx->tL1AlgCtx.tScatterHash.tScatterHashParamShared.aShaParmBuf[0])); pShaParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pShaParm->u32Timeout = u32TimeoutMs; pShaParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; pShaParm->tCfg.tCfg.bGenerateMacEn = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bGenerateMacEn; pShaParm->tCfg.tCfg.eMacType = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.eMacType; if (HSM_TRUE == (pCtx->tL1AlgCtx.tScatterHash.tMacCfg.bKeyUseId)) { pShaParm->tCfg.tCfg.tKeyInfo.u32KeyId = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.u32KeyId; } else { pShaParm->tCfg.tCfg.tKeyInfo.pKeyData = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.tHashMacKeyInfo.pKeyData; } pShaParm->tCfg.tCfg.u32KeyByteCnt = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32KeyByteCnt; pShaParm->tCfg.tCfg.u32GenerateMacByteCnt = pCtx->tL1AlgCtx.tScatterHash.tMacCfg.u32GenerateMacByteCnt; pShaParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&( pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); pShaParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt; pShaParm->tCfg.pResult = (HSM_ShaResultBufType *)HSM_ADDRESS_UP_ALIGN(&( pCtx->tL1AlgCtx.tScatterHash.tScatterHashResultShared.aShaResultBuf[0])); pShaParm->tCfg.eInputFmt = HSM_DATA_FORMAT_4B; pShaParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0; eRet = hsm_l1_scatter_hash_init2final(pCtx, pShaParm); } else { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0u; eCurDataFmt = HSM_DATA_FORMAT_4B; eRet = hsm_l1_scatter_hash_final(pCtx, eCurDataFmt); } } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else { if (HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_INIT == eCurState) { eRet = HSM_STATUS_FINISH; if (pResult->pData != NULL_PTR) { hsm_uint32_t u32Size; const hsm_uint8_t *pHashData; eRet = hsm_aux_get_empty_data_hash(pCtx->tL1AlgCtx.tScatterHash.eAlg, &pHashData, &u32Size); if (HSM_STATUS_SUCCESS == eRet) { if (pResult->u32DataBufSize > u32Size) { hsm_1B4B_convert_from_idx(pResult->eDataFmt, pResult->pData, 0, pResult->u32DataBufSize, HSM_DATA_FORMAT_1B, pHashData, 0, u32Size); } else { u32Size = pResult->u32DataBufSize; hsm_1B4B_convert_from_idx(pResult->eDataFmt, pResult->pData, 0, pResult->u32DataBufSize, HSM_DATA_FORMAT_1B, pHashData, 0, pResult->u32DataBufSize); } if (pResult->pDataSize != NULL_PTR) { hsm_memcpy(pResult->pDataSize, &u32Size, sizeof(u32Size)); } /* else do nothing */ } /* else do nothing */ } } else { eRet = HSM_STATUS_ERROR_STOP; } pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else /* init ok/update ok, 4B, input address 4bytes aligned */ { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)pCfg->pData; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0u; eCurDataFmt = pCfg->eDataFmt; eRet = hsm_l1_scatter_hash_final(pCtx, eCurDataFmt); } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* get result return success, trigger next process return again, others error */ HSM_StatusType HSM_L1_ScatterHash_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_ScatterHashSMType eCurState = pCtx->tL1AlgCtx.tScatterHash.eState; hsm_uint32_t u32Temp; HSM_DataFormatType eCurDataFmt; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet) { pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = 0; if ((HSM_L1_SCATTER_HASH_INIT == eCurState) || (HSM_L1_SCATTER_HASH_UPDATE == eCurState)) { if (pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize <= pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize) { if (HSM_L1_SCATTER_HASH_INIT == eCurState) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_INIT_OK; } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_UPDATE_OK; } pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; } else { u32Temp = pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; if (u32Temp <= HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCtx->tL1AlgCtx.tScatterHash.eInputFmt, pCtx->tL1AlgCtx.tScatterHash.pInputData, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize); pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_NEED_MORE_BEFORE_UPDATE_FINAL; pCtx->tL1AlgCtx.tScatterHash.u32CacheDataByteCnt = u32Temp; } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; if ( #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tScatterHash.eInputFmt) || #endif (((hsm_uint32_t)pCtx->tL1AlgCtx.tScatterHash.pInputData) & 0x3) || (pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize & 0x3)) { if (u32Temp > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { u32Temp = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf); } else { if (0u == (u32Temp % HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg))) { u32Temp = (u32Temp - HSM_HFAM_HW_PROCESS_ALIGN( pCtx->tL1AlgCtx.tScatterHash.eAlg)); } else { u32Temp = ((u32Temp / HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCtx->tL1AlgCtx.tScatterHash.eInputFmt, pCtx->tL1AlgCtx.tScatterHash.pInputData, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize + u32Temp); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = u32Temp; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); } pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize += u32Temp; eCurDataFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (u32Temp % HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg))) { u32Temp = u32Temp - HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } else { u32Temp = (u32Temp / HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg); } pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = u32Temp; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = pCtx->tL1AlgCtx.tScatterHash.pInputData + pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize += u32Temp; eCurDataFmt = pCtx->tL1AlgCtx.tScatterHash.eInputFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_hash_update(pCtx, eCurDataFmt); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } /* else do nothing */ } } } else if (HSM_L1_SCATTER_HASH_FINAL == eCurState) { pCtx->eStat = HSM_DRV_SM_STOP; if (pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize <= pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize) { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; if ((pCtx->tL1AlgCtx.tScatterHash.pOut != NULL_PTR)) { eRet = hsm_hash_get_result_byte_count( (HFAM_MODE_E)pCtx->tL1AlgCtx.tScatterHash.eAlg, &u32Temp); if (HSM_STATUS_SUCCESS == eRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tScatterHash.eOutFmt) { hsm_u32_array_swap((hsm_uint32_t *)(pCtx->tL1AlgCtx.tScatterHash .pScatterHashParm->tCfg.pResult), u32Temp / 4U); /* all result data size is 4*N */ } else { } if (pCtx->tL1AlgCtx.tScatterHash.u32OutBufSize <= u32Temp) { u32Temp = pCtx->tL1AlgCtx.tScatterHash.u32OutBufSize; } /* else do nothing */ hsm_memcpy(pCtx->tL1AlgCtx.tScatterHash.pOut, pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.pResult, u32Temp); if (NULL_PTR != pCtx->tL1AlgCtx.tScatterHash.pOutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tScatterHash.pOutSize, &u32Temp, sizeof(u32Temp)); } else { ; } } else { eRet = HSM_STATUS_HW_ERR; } } /* else do nothing */ pCtx->tL1AlgCtx.tScatterHash.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.u32OutBufSize = 0; pCtx->tL1AlgCtx.tScatterHash.eOutFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterHash.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize = 0; } else { u32Temp = pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; if (u32Temp <= HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCtx->tL1AlgCtx.tScatterHash.eInputFmt, pCtx->tL1AlgCtx.tScatterHash.pInputData, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterHash.u32InputTotalSize); pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize += u32Temp; if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = u32Temp; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); eCurDataFmt = HSM_DATA_FORMAT_4B; eRet = hsm_l1_scatter_hash_final(pCtx, eCurDataFmt); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->u32Timeout = pCtx->tL1AlgCtx.tScatterHash.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.eAlg = pCtx->tL1AlgCtx.tScatterHash.eAlg; if ( #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tScatterHash.eInputFmt) || #endif (((hsm_uint32_t)pCtx->tL1AlgCtx.tScatterHash.pInputData) & 0x3) || (pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize & 0x3)) { if (u32Temp > sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf)) { u32Temp = sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf); } else { if (0u == (u32Temp % HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg))) { u32Temp = (u32Temp - HSM_HFAM_HW_PROCESS_ALIGN( pCtx->tL1AlgCtx.tScatterHash.eAlg)); } else { u32Temp = ((u32Temp / HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)) * HSM_HFAM_HW_PROCESS_ALIGN(pCtx->tL1AlgCtx.tScatterHash.eAlg)); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterHash.aDataBuf), pCtx->tL1AlgCtx.tScatterHash.eInputFmt, pCtx->tL1AlgCtx.tScatterHash.pInputData, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize + u32Temp); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = u32Temp; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterHash.aDataBuf[0]); } pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize += u32Temp; eCurDataFmt = HSM_DATA_FORMAT_4B; if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_hash_update(pCtx, eCurDataFmt); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } else /* start address 4 aligned */ { pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.u32InputDataByteCnt = u32Temp; pCtx->tL1AlgCtx.tScatterHash.pScatterHashParm->tCfg.tCfg.pInputData = pCtx->tL1AlgCtx.tScatterHash.pInputData + pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterHash.u32ProcessedSize += u32Temp; eCurDataFmt = pCtx->tL1AlgCtx.tScatterHash.eInputFmt; if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_hash_final(pCtx, eCurDataFmt); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; eRet = HSM_STATUS_ERROR; } } } } } else { eRet = HSM_STATUS_LOGIC_ERR; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_ERR; pCtx->tL1AlgCtx.tScatterHash.eState = HSM_L1_SCATTER_HASH_STOP; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_ScatterHashPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_ScatterHash_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ScatterHashExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_HASH == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ScatterCMacSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SCATTER_CMAC; pCtx->eStat = HSM_DRV_SM_READY; hsm_memset(&(pCtx->tL1AlgCtx.tScatterCMac), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac)); pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_READY; pCtx->tL1AlgCtx.tScatterCMac.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm = (HSMCom_AesmRawApiType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacParamShared.aScatterCMacParmBuf[0])); pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.pCtx1 = &( pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacResultShared.aCMacCtx); pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.key_cfg = &( pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tKeyCfg); pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tKeyCfg.key_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aKeyData[0]); pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.key_cfg_en = 0x1; /* key enable */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.aes_mode = 0x6; /* cmac */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.enc_dec = 0x1; /* encrypt */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.mst_en = 0x1; /* ahb enable */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.icv_en = 0x0; /* not check result */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.icv_len = 0x10; /* cmac result length */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.aad_len = 0x0; /* not check result */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.out_addr = &( pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacParamShared.aCMacParmBuf[0]); pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.iv_addr = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.dbg_wait = 0x0; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.iv_len = 0x0; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } static HSM_StatusType hsm_l1_scatter_cmac_init(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt) { HSM_StatusType eRet = HSM_FW_ScatterCMacInit(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm, eInputFmt, eKeyFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.aes_as = 0x1; /* init */ pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_cmac_update(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt) { HSM_StatusType eRet = HSM_FW_ScatterCMacUpdate(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm, eInputFmt, eKeyFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.aes_as = 0x0; /* update */ pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_cmac_final(HSM_L1_RtCtxType *pCtx, HSM_DataFormatType eInputFmt, HSM_DataFormatType eKeyFmt) { HSM_StatusType eRet = HSM_FW_ScatterCMacFinal(&(pCtx->tCmd), pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm, eInputFmt, eKeyFmt); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.aes_as = 0x2; /* final */ pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } static HSM_StatusType hsm_l1_scatter_cmac_init2final(HSM_L1_RtCtxType *pCtx, HSMCom_CMacExType *pParm) { HSM_StatusType eRet = HSM_CMacEx(&(pCtx->tCmd), pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } return eRet; } /* when need more data, return again, when trigger successfully, return success, others error */ 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 eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; hsm_uint32_t u32Temp = (pKeyCfg->eKeyType * 8) + 16; HSM_DataFormatType eCurDataFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_CMAC == pCtx->eOperationCata) && (HSM_L1_SCATTER_CMAC_READY == pCtx->tL1AlgCtx.tScatterCMac.eState)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.u32OutBufSize = 0; pCtx->tL1AlgCtx.tScatterCMac.eOutFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0; pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0; pCtx->tL1AlgCtx.tScatterCMac.eUseKeyType = pKeyCfg->eUseKeyType; pCtx->tL1AlgCtx.tScatterCMac.u32KeyId = pKeyCfg->u32KeyId; pCtx->tL1AlgCtx.tScatterCMac.eKeyType = pKeyCfg->eKeyType; pCtx->tL1AlgCtx.tScatterCMac.eBackend = pKeyCfg->eBackend; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32UserKeyID = pCtx->tL1AlgCtx.tScatterCMac.u32KeyId; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tKeyCfg.key_type = pCtx->tL1AlgCtx.tScatterCMac.eKeyType; /* normal key */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tKeyCfg.key_sel = 0x1 - (pCtx->tL1AlgCtx.tScatterCMac.eUseKeyType & 0x1); /* normal key */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.eng_sel = pKeyCfg->eBackend; /* aes-cmac */ if ((HSM_AES_KEY_NEW == pKeyCfg->eUseKeyType)) { if (0 == pCtx->tL1AlgCtx.tScatterCMac.u32KeyId) { if (u32Temp <= sizeof(pCtx->tL1AlgCtx.tScatterCMac.aKeyData)) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_1B, &(pCtx->tL1AlgCtx.tScatterCMac.aKeyData[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aKeyData), pKeyCfg->eKeyDataFmt, pKeyCfg->pKeyAddr, 0, u32Temp); } else { eRet = HSM_STATUS_PARAM_ERR; } } /* else do nothing */ } else if (u32Temp > 32) /* max 256bits support */ { eRet = HSM_STATUS_PARAM_ERR; } else { /* else do nothing */ } if (HSM_STATUS_SUCCESS == eRet) { if (NULL_PTR == pCfg) { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT; eRet = HSM_STATUS_AGAIN; } else if (pCfg->u32DataSize < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_INIT; pCtx->tL1AlgCtx.tScatterCMac.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; if ((((hsm_uint32_t)pCfg->pData) & 0x3u) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if (pCfg->u32DataSize >= (sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) + HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = sizeof( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf); } else { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); } eCurDataFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = pCfg->pData; eCurDataFmt = pCfg->eDataFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_cmac_init(pCtx, eCurDataFmt, HSM_DATA_FORMAT_1B); } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* when need more data, return again, when trigger successfully, return success, others error */ HSM_StatusType HSM_L1_ScatterCMacUpdate(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ScatterCMacType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_ScatterCMacSMType eCurState = pCtx->tL1AlgCtx.tScatterCMac.eState; HSM_BoolType bInProcess; HSM_DataFormatType eCurFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_CMAC == pCtx->eOperationCata) && ((HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_CMAC_INIT_OK == eCurState) || (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState) || (HSM_L1_SCATTER_CMAC_UPDATE_OK == eCurState))) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0; if ((HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState)) { if (NULL_PTR == pCfg) { eRet = HSM_STATUS_AGAIN; } else if ((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt + pCfg->u32DataSize) < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_UPDATE; pCtx->tL1AlgCtx.tScatterCMac.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) - pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; if (pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize > pCfg->u32DataSize) /* can cache all data */ { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize; eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; } else { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; } pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); if (((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt) + (pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize)) < 16) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt -= 16u; } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); eCurFmt = HSM_DATA_FORMAT_4B; if (HSM_STATUS_SUCCESS == eRet) { if (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) { eRet = hsm_l1_scatter_cmac_init(pCtx, eCurFmt, HSM_DATA_FORMAT_1B); } else { eRet = hsm_l1_scatter_cmac_update(pCtx, eCurFmt, HSM_DATA_FORMAT_1B); } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } else /* init ok / update ok */ { if (NULL_PTR == pCfg) { eRet = HSM_STATUS_AGAIN; } else if (pCfg->u32DataSize < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = pCfg->u32DataSize; eRet = HSM_STATUS_AGAIN; } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_UPDATE; pCtx->tL1AlgCtx.tScatterCMac.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0u; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; if ((((hsm_uint32_t)pCfg->pData) & 0x3) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if (pCfg->u32DataSize >= (sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) + HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = sizeof( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf); } else { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); } eCurFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = pCfg->pData; eCurFmt = pCfg->eDataFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_cmac_update(pCtx, eCurFmt, HSM_DATA_FORMAT_1B); } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* when trigger successfully, return success, others error */ 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 eRet = HSM_STATUS_SUCCESS; HSM_ScatterCMacSMType eCurState = pCtx->tL1AlgCtx.tScatterCMac.eState; HSM_BoolType bInProcess; HSM_DataFormatType eCurFmt; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_CMAC == pCtx->eOperationCata) && ((HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_CMAC_INIT_OK == eCurState) || (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState) || (HSM_L1_SCATTER_CMAC_UPDATE_OK == eCurState))) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pOut = pResult->pData; pCtx->tL1AlgCtx.tScatterCMac.u32OutBufSize = pResult->u32DataBufSize; pCtx->tL1AlgCtx.tScatterCMac.eOutFmt = pResult->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.pOutSize = pResult->pDataSize; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_FINAL; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0; if ((HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) || (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL == eCurState)) { if ((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt + pCfg->u32DataSize) < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCfg->u32DataSize; if (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) { HSMCom_CMacExType *pParm = (HSMCom_CMacExType *)HSM_ADDRESS_UP_ALIGN(&( pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacParamShared.aCMacParmBuf[0])); /* convert from 4B to 1B */ hsm_u32_array_swap( (hsm_uint32_t *)&(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt + 3u) >> 2u); pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pParm->u32Timeout = u32TimeoutMs; pParm->u32UserKeyID = pCtx->tL1AlgCtx.tScatterCMac.u32KeyId; pParm->tCfg.eUseKeyType = HSM_AES_KEY_NEW; pParm->tCfg.tNewKeyInf.eKeyType = pCtx->tL1AlgCtx.tScatterCMac.eKeyType; pParm->tCfg.tNewKeyInf.pKeyAddr = (const hsm_uint8_t *)&( pCtx->tL1AlgCtx.tScatterCMac.aKeyData[0]); pParm->tCfg.u32GenMacByteCnt = 0x10; pParm->tCfg.bCheckMacEn = HSM_FALSE; pParm->tCfg.pDataInput = (const hsm_uint32_t *)&( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); pParm->tCfg.u32InputByteCnt = pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; pParm->tCfg.pDataOutput = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacResultShared .aCMacResultBuf[0])); pParm->tCfg.u32OutputMemSize = sizeof( pCtx->tL1AlgCtx.tScatterCMac.tScatterCMacResultShared.aCMacResultBuf); pParm->tCfg.eInputFmt = HSM_DATA_FORMAT_1B; pParm->tCfg.eOutputFmt = HSM_DATA_FORMAT_4B; pParm->tCfg.eEngine = pCtx->tL1AlgCtx.tScatterCMac.eBackend; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0; eRet = hsm_l1_scatter_cmac_init2final(pCtx, pParm); } else { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; eRet = hsm_l1_scatter_cmac_final(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else { pCtx->tL1AlgCtx.tScatterCMac.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) - pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; if (pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize > pCfg->u32DataSize) /* can cache all data */ { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize; eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; } else { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; } pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); if (((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt) + (pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize)) < 16) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt -= 16u; } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); if (HSM_STATUS_SUCCESS == eRet) { if (HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_INIT == eCurState) { eRet = hsm_l1_scatter_cmac_init(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); } else { eRet = hsm_l1_scatter_cmac_update(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); } } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } else /* init ok / update ok */ { if (pCfg->u32DataSize < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCfg->u32DataSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = (const hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; eRet = hsm_l1_scatter_cmac_final(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else /* data is enough for once at least */ { pCtx->tL1AlgCtx.tScatterCMac.pInputData = pCfg->pData; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = pCfg->u32DataSize; pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0u; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = u32TimeoutMs; if ((((hsm_uint32_t)pCfg->pData) & 0x3) #if (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM) || (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) #endif ) { if (pCfg->u32DataSize >= (sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) + HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = sizeof( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf); } else { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } } eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), 0, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCfg->eDataFmt, pCfg->pData, 0, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); } eCurFmt = HSM_DATA_FORMAT_4B; } else /* start address 4 aligned */ { if (0u == (pCfg->u32DataSize % HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = pCfg->u32DataSize - HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } else { pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = (pCfg->u32DataSize / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize -= HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = pCfg->pData; eCurFmt = pCfg->eDataFmt; } if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_cmac_update(pCtx, eCurFmt, HSM_DATA_FORMAT_1B); } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* get result return success, trigger next process return again, others error */ HSM_StatusType HSM_L1_ScatterCMac_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_ScatterCMacSMType eCurState = pCtx->tL1AlgCtx.tScatterCMac.eState; hsm_uint32_t u32Temp, u32Temp2; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet) { pCtx->eStat = HSM_DRV_SM_STOP; if ((pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt != 0u) && (pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt < pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt)) { hsm_memcpy(&(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), ((hsm_uint8_t *)&(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0])) + pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt, (((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt) + 3) >> 2) << 2); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt; pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0u; } else { pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = 0u; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; } if ((HSM_L1_SCATTER_CMAC_INIT == eCurState) || (HSM_L1_SCATTER_CMAC_UPDATE == eCurState)) { if (pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize <= pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize) { if (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt > 0u) { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL; } else { if (HSM_L1_SCATTER_CMAC_INIT == eCurState) { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_INIT_OK; } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_UPDATE_OK; } } pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0; } else { u32Temp = pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; if ((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt + u32Temp) < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0u; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0u; /* has cache all input data */ pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_NEED_MORE_BEFORE_UPDATE_FINAL; } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else { u32Temp2 = sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) - pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; if (u32Temp2 > u32Temp) /* can cache all data */ { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize += u32Temp; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp; } else { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize + u32Temp2); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize += u32Temp2; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp2; } pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); if (((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt) + (pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize)) < 16) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt -= 16u; } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_cmac_update(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } } else if (HSM_L1_SCATTER_CMAC_FINAL == eCurState) { if ((pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize <= pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize) && (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt == 0u)) /* has processed all input data */ { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; if ((pCtx->tL1AlgCtx.tScatterCMac.pOut != NULL_PTR)) { u32Temp = 16u; if (HSM_STATUS_SUCCESS == eRet) { if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tScatterCMac.eOutFmt) { hsm_u32_array_swap((hsm_uint32_t *)(pCtx->tL1AlgCtx.tScatterCMac .pScatterCMacParm->tCfg.pCtx1), u32Temp / 4U); /* all result data size is 4*N */ } else { } if (pCtx->tL1AlgCtx.tScatterCMac.u32OutBufSize <= u32Temp) { u32Temp = pCtx->tL1AlgCtx.tScatterCMac.u32OutBufSize; } /* else do nothing */ hsm_memcpy(pCtx->tL1AlgCtx.tScatterCMac.pOut, pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.pCtx1, u32Temp); if (NULL_PTR != pCtx->tL1AlgCtx.tScatterCMac.pOutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tScatterCMac.pOutSize, &u32Temp, sizeof(u32Temp)); } else { ; } } else { eRet = HSM_STATUS_HW_ERR; } } /* else do nothing */ pCtx->tL1AlgCtx.tScatterCMac.pOut = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.u32OutBufSize = 0; pCtx->tL1AlgCtx.tScatterCMac.eOutFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.pOutSize = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0; } else { u32Temp = pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize; if ((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt + u32Temp) < (2 * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN())) { eRet = hsm_1B4B_convert_from_idx(HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize); if (HSM_STATUS_SUCCESS == eRet) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp; pCtx->tL1AlgCtx.tScatterCMac.pInputData = NULL_PTR; pCtx->tL1AlgCtx.tScatterCMac.eInputFmt = HSM_DATA_FORMAT_4B; pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize = 0; pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize = 0u; /* has cache all input data */ pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt = 0u; eRet = hsm_l1_scatter_cmac_final(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; } } else { u32Temp2 = sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf) - pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt; if (u32Temp2 > u32Temp) /* can cache all data */ { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize += u32Temp; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp; } else { eRet = hsm_1B4B_convert_from_idx( HSM_DATA_FORMAT_4B, &(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]), pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt, sizeof(pCtx->tL1AlgCtx.tScatterCMac.aDataBuf), pCtx->tL1AlgCtx.tScatterCMac.eInputFmt, pCtx->tL1AlgCtx.tScatterCMac.pInputData, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize, pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize + u32Temp2); pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize += u32Temp2; pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt += u32Temp2; } pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt = (pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt / HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN()) * HSM_AESM_SCATTER_CMAC_HW_PROCESS_ALIGN(); if (((pCtx->tL1AlgCtx.tScatterCMac.u32CacheDataByteCnt - pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt) + (pCtx->tL1AlgCtx.tScatterCMac.u32InputTotalSize - pCtx->tL1AlgCtx.tScatterCMac.u32ProcessedSize)) < 16) { pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt -= 16u; } pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->u32Timeout = pCtx->tL1AlgCtx.tScatterCMac.u32TimeoutMs; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.data_len = pCtx->tL1AlgCtx.tScatterCMac.u32CacheProcByteCnt; pCtx->tL1AlgCtx.tScatterCMac.pScatterCMacParm->tCfg.tCfg.in_addr = &( pCtx->tL1AlgCtx.tScatterCMac.aDataBuf[0]); if (HSM_STATUS_SUCCESS == eRet) { eRet = hsm_l1_scatter_cmac_update(pCtx, HSM_DATA_FORMAT_4B, HSM_DATA_FORMAT_1B); if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_STATUS_AGAIN; } /* else do nothing */ } else { pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; eRet = HSM_STATUS_ERROR; } } } } else { eRet = HSM_STATUS_LOGIC_ERR; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_ERR; pCtx->tL1AlgCtx.tScatterCMac.eState = HSM_L1_SCATTER_CMAC_STOP; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_ScatterCMacPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_CMAC == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_ScatterCMac_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_ScatterCMacExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SCATTER_CMAC == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccSignSetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32BitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32BitCnt <= 1024) && (u32BitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_ECC_SIGN; pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt = u32BitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tEccSignInf.pParm = (HSMCom_EccSignType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aParmBuf[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pP = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aP[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pN = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aN[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pA = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aA[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pB = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aB[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pGx = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aGx[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.tCurve.pGy = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aGy[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.pPrivateKey = (const hsm_uint32_t *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aPrivate[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.pHashData = (const hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aHash[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.pR = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aR[0])); pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.pS = (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aS[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccSignExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_SIGN == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } /* For interrupt usage */ HSM_StatusType HSM_L1_EccSign(HSM_L1_RtCtxType *pCtx, const HSM_Ln_EccSignType *pCfg, hsm_uint32_t u32TimeoutMs) { hsm_uint32_t u32NByteCnt; HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_SIGN == pCtx->eOperationCata)) { u32NByteCnt = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 7u) / 8u); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { if (pCfg->u32RBufByteCnt < u32NByteCnt) { eRet = HSM_STATUS_PARAM_ERR; } /* else do nothing */ if (pCfg->u32SBufByteCnt < u32NByteCnt) { eRet = HSM_STATUS_PARAM_ERR; } /* else do nothing */ } else { u32NByteCnt = (((u32NByteCnt + 3u) / 4u) * 4u); if (pCfg->u32RBufByteCnt < u32NByteCnt) { eRet = HSM_STATUS_PARAM_ERR; } /* else do nothing */ if (pCfg->u32SBufByteCnt < u32NByteCnt) { eRet = HSM_STATUS_PARAM_ERR; } /* else do nothing */ } if (HSM_STATUS_SUCCESS == eRet) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { u32NByteCnt = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 63u) / 64u) * 8u; pCtx->tL1AlgCtx.tEccSignInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tEccSignInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tEccSignInf.pParm->u32UserKeyID_PrivateKey = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tEccSignInf.pParm->u32BitCnt = pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt; pCtx->tL1AlgCtx.tEccSignInf.pParm->u32EccCurve = pCfg->u32EccCurve; pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount = u32NByteCnt; pCtx->tL1AlgCtx.tEccSignInf.eOutFmt = pCfg->eDataFmt; pCtx->tL1AlgCtx.tEccSignInf.pR = pCfg->pR; pCtx->tL1AlgCtx.tEccSignInf.u32RBufByteCnt = pCfg->u32RBufByteCnt; pCtx->tL1AlgCtx.tEccSignInf.pS = pCfg->pS; pCtx->tL1AlgCtx.tEccSignInf.u32SBufByteCnt = pCfg->u32SBufByteCnt; if (HSM_DRV_ECC_CURVE_PRM_IDX_MAX <= pCfg->u32EccCurve) { hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pP, pCfg->tCurve.u32PByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aP[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aP[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pN, pCfg->tCurve.u32NByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aN[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aN[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pA, pCfg->tCurve.u32AByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aA[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aA[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pB, pCfg->tCurve.u32BByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aB[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aB[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pGx, pCfg->tCurve.u32GxByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aGx[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aGx[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->tCurve.pGy, pCfg->tCurve.u32GyByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aGy[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aGy[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aP[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aN[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aA[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aB[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aGx[0])), u32NByteCnt / 4U); hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aGy[0])), u32NByteCnt / 4U); } else { ; } } else { ; } if (0u == pCfg->u32PrivateKeyId) { hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->pPrivate, pCfg->u32PrivateByteCnt, &pStart, &u32ActualSize); hsm_memset( (void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aPrivate[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aPrivate[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aPrivate[0])), u32NByteCnt / 4U); } else { ; } } else { ; } hsm_rm_prefix_zeros(pCfg->eDataFmt, pCfg->pHashData, pCfg->u32HashDataByteCnt, &pStart, &u32ActualSize); hsm_memset((void *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aHash[0])), 0, u32NByteCnt - u32ActualSize); hsm_memcpy(((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aHash[0]))) + (u32NByteCnt - u32ActualSize), pStart, u32ActualSize); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tEccSignInf.aHash[0])), u32NByteCnt / 4U); } else { ; } eRet = HSM_FW_EccSign(&(pCtx->tCmd), pCtx->tL1AlgCtx.tEccSignInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } /* else do nothing */ } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_EccSign_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; hsm_uint32_t u32OutSize; const hsm_uint8_t *pStart; hsm_uint32_t u32ActualSize; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tEccSignInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccSignInf.eOutFmt) { hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aR[0])), pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount / 4U); hsm_u32_array_swap( (hsm_uint32_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aS[0])), pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount / 4U); } hsm_rm_prefix_zeros( pCtx->tL1AlgCtx.tEccSignInf.eOutFmt, (const hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aR[0])), pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccSignInf.eOutFmt) { u32OutSize = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 7u) / 8u); if (u32ActualSize <= u32OutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tEccSignInf.pR, ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aR[0]))) + pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount - u32OutSize, u32OutSize); } else { eRet = HSM_STATUS_ERROR; } } else { u32OutSize = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 31u) / 32u) * 4u; if (u32ActualSize <= u32OutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tEccSignInf.pR, ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aR[0]))) + pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount - u32OutSize, u32OutSize); } else { eRet = HSM_STATUS_ERROR; } } hsm_rm_prefix_zeros( pCtx->tL1AlgCtx.tEccSignInf.eOutFmt, (const hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aS[0])), pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount, &pStart, &u32ActualSize); if (HSM_DATA_FORMAT_1B == pCtx->tL1AlgCtx.tEccSignInf.eOutFmt) { u32OutSize = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 7u) / 8u); if (u32ActualSize <= u32OutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tEccSignInf.pS, ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aS[0]))) + pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount - u32OutSize, u32OutSize); } else { eRet = HSM_STATUS_ERROR; } } else { u32OutSize = ((pCtx->tL1AlgCtx.tEccSignInf.u32NBitCnt + 31u) / 32u) * 4u; if (u32ActualSize <= u32OutSize) { hsm_memcpy(pCtx->tL1AlgCtx.tEccSignInf.pS, ((hsm_uint8_t *)HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tEccSignInf.aS[0]))) + pCtx->tL1AlgCtx.tEccSignInf.pParm->tCfg.u32ByteCount - u32OutSize, u32OutSize); } else { eRet = HSM_STATUS_ERROR; } } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_EccSignPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_EccSign_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_EccSignReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_ECC_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32RsaBitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32RsaBitCnt <= 4096) && (u32RsaBitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RSA_SSA_PSS_VERIFY; pCtx->tL1AlgCtx.tRsaSsaPssVerify.u32BitCnt = u32RsaBitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm = (HSMCom_RsaSsaPssVerifyType *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaSsaPssVerify.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerify(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssVerifyType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; hsm_uint32_t u32HashLen; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (HSM_STATUS_SUCCESS == hsm_hash_get_result_byte_count((HFAM_MODE_E)pCfg->eHashType, &u32HashLen)) && (HSM_STATUS_SUCCESS == hsm_hash_get_result_byte_count((HFAM_MODE_E)pCfg->eMgfHashType, NULL_PTR)) && (((pCfg->u32EmBitCnt + 7u) >> 3u) >= (u32HashLen + pCfg->u32SaltByteCount + 2))) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32UserKeyID_KEY_E = pCfg->u32KeyEId; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32RsaBitCnt = pCtx->tL1AlgCtx.tRsaSsaPssVerify.u32BitCnt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32EmBitCnt = pCfg->u32EmBitCnt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eMgfHashType = pCfg->eMgfHashType; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32SaltByteCount = pCfg->u32SaltByteCount; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eInputDataFmt = pCfg->eInputDataFmt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eInputType = pCfg->eInputType; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.pInputData = pCfg->pInputData; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32InputDataByteCount = pCfg->u32InputDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eSignDataFmt = pCfg->eSignDataFmt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.pSignData = pCfg->pSignData; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32SignDataByteCount = pCfg->u32SignDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.ePublicKeyDataFmt = pCfg->ePublicKeyDataFmt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.pPublicKey = pCfg->pPublicKey; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32PublicKeyByteCnt = pCfg->u32PublicKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.eKeyNDataFmt = pCfg->eKeyNDataFmt; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult = pCfg->pVerifyResult; eRet = HSM_FW_RsaSsaPssVerify(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerifyPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_RsaSsaPssVerify_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerifyReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerify_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_PASS == pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_PASS; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult = CRYPTO_E_VER_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } else if (MAILBOXAPI_RET_FAIL == pCtx->tL1AlgCtx.tRsaSsaPssVerify.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_FAIL; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult = CRYPTO_E_VER_NOT_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPssVerify.pVerifyResult = CRYPTO_E_VER_NOT_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssVerifyExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_VERIFY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifySetupEnv(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32RsaBitCnt) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((u32RsaBitCnt <= 4096u) && (u32RsaBitCnt >= 1u)) { bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RSA_SSA_PKCS1V15_VERIFY; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.u32BitCnt = u32RsaBitCnt; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm = (HSMCom_RsaSsaPkcs1V15VerifyType *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15Verify(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1v15VerifyType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; hsm_uint32_t u32HashLen; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg) && (HSM_STATUS_SUCCESS == hsm_hash_get_result_byte_count((HFAM_MODE_E)pCfg->eHashType, &u32HashLen))) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32UserKeyID_KEY_E = pCfg->u32KeyEId; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32RsaBitCnt = pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.u32BitCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.eInputFmt = pCfg->eInputDataFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32EmByteCnt = pCfg->u32EmByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.pInputData = pCfg->pInputData; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32InputDataByteCount = pCfg->u32InputDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.pSignData = pCfg->pSignData; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32SignDataByteCount = pCfg->u32SignDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.pPublicKey = pCfg->pPublicKey; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32PublicKeyByteCnt = pCfg->u32PublicKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.bUseInputDer = pCfg->bUseInputDer; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.pDer = pCfg->pDer; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32DerByteCount = pCfg->u32DerByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.eInputType = HSM_RSA_SSA_INPUT_RAW_MESSAGE; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.eSignDataFmt = pCfg->eSignDataFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.ePublicKeyFmt = pCfg->ePublicKeyFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->tCfg.eKeyNFmt = pCfg->eKeyNFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult = pCfg->pVerifyResult; eRet = HSM_FW_RsaSsaPkcs1v15Verify(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_RsaSsaPkcs1V15Verify_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15Verify_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_PASS == pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_PASS; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult = CRYPTO_E_VER_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } else if (MAILBOXAPI_RET_FAIL == pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_FAIL; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult = CRYPTO_E_VER_NOT_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; if (NULL_PTR != pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult) { *pCtx->tL1AlgCtx.tRsaSsaPkcs1V15Verify.pVerifyResult = CRYPTO_E_VER_NOT_OK; } pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15VerifyExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_VERIFY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImportSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_IMPORT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImport(HSM_L1_RtCtxType *pCtx, const HSM_Ln_ImportUserKeyExtType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; void *pCache; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_IMPORT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { if (pCfg->u32DataLength > 0u) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; hsm_memcpy(&(pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tImportUserKeyExtCfg), pCfg, sizeof(pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tImportUserKeyExtCfg)); if (0u != (pCfg->u32KeyIdFix)) { pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tImportUserKeyExtCfg.pKeyID = NULL_PTR; } if ((((hsm_uint32_t)(pCfg->pDataAddr)) & 0x3u) && (pCfg->u32DataLength <= (sizeof(pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.aAlignedDataBuffer) - 4u))) { pCache = (void *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.aAlignedDataBuffer[0])); hsm_memcpy(pCache, pCfg->pDataAddr, pCfg->u32DataLength); pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tImportUserKeyExtCfg.pDataAddr = pCache; } eRet = HSM_FW_UserKeyImportNew(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImportPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_IMPORT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeyImport_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImportReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_IMPORT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImportExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_IMPORT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyImport_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) #else else if ((KEYMANAGER_STATUS_ID_ERROR | 0x80000000u) == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_EXIST; pCtx->eStat = HSM_DRV_SM_STOP; } else if ((KEYMANAGER_STATUS_SPACE_ERROR | 0x80000000u) == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SPACE_FULL; pCtx->eStat = HSM_DRV_SM_STOP; } #endif else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } #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_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_VALIDATE; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyValidate(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if (NULL_PTR != pCtx) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_VALIDATE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.u32CheckUserKeyIDExt = u32KeyId; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; eRet = HSM_FW_CheckKeyIdExt(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyValidatePoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_VALIDATE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeyValidate_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyValidateReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_VALIDATE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyValidateExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_VALIDATE == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyValidate_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_FAIL == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_NOT_EXIST; pCtx->eStat = HSM_DRV_SM_STOP; } else if (MAILBOXAPI_RET_PASS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_EXIST; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } #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_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_UpdateKeyIdContent(HSM_L1_RtCtxType *pCtx, const HSM_Ln_KeyManagerUpdateUserKeyType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if (NULL_PTR != pCtx) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; hsm_memcpy(&(pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tUpdateUserKeyCfg), pCfg, sizeof(*pCfg)); eRet = HSM_UpdateKeyContentOfSpecificKeyId(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_UpdateKeyIdContentPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_UpdateKeyIdContent_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_UpdateKeyIdContentReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_UpdateKeyIdContentExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_UpdateKeyIdContent_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else if ((KEYMANAGER_STATUS_ID_ERROR | 0x80000000u) == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_NOT_EXIST; pCtx->eStat = HSM_DRV_SM_STOP; } else if (((KEYMANAGER_STATUS_SPACE_ERROR | 0x80000000u) == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) || (KEYMANAGER_STATUS_ERROR == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet)) { eRet = HSM_STATUS_SPACE_FULL; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } #endif HSM_StatusType HSM_L1_KeyCopySetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_COPY; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyCopy(HSM_L1_RtCtxType *pCtx, const HSM_Ln_CopyUserKeyType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_COPY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; hsm_memcpy(&(pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tCopyUserKeyExtCfg), pCfg, sizeof(pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tCopyUserKeyExtCfg)); eRet = HSM_FW_CopyKeyExt(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyCopyPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_COPY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeyCopy_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyCopyReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_COPY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyCopyExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_COPY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyCopy_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_KeyRevokeSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_REVOKE; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyRevoke(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if (NULL_PTR != pCtx) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_REVOKE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.u32RevokeUserKeyID = u32KeyId; eRet = HSM_UserKeyRevoke(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyRevokePoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_REVOKE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeyRevoke_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyRevokeReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_REVOKE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyRevokeExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_REVOKE == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeyRevoke_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) #else else if ((KEYMANAGER_STATUS_ID_ERROR | 0x80000000u) == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_NOT_EXIST; pCtx->eStat = HSM_DRV_SM_STOP; } #endif else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyUpSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_TIDYUP; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm = (HSMCom_KeySpaceStatusType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeySpaceInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyUp(HSM_L1_RtCtxType *pCtx, HSM_Ln_KeySpaceStatusType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; HSM_Ln_KeySpaceStatusType *pKeySpaceStatusCfg = pCfg; if (NULL_PTR == pCfg) { pKeySpaceStatusCfg = &(pCtx->tL1AlgCtx.tKeySpaceInf.tKeySpaceStatus); } if ((NULL_PTR != pCtx)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_TIDYUP == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->pKMSpaceStatus = pKeySpaceStatusCfg; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32Timeout = u32TimeoutMs; eRet = HSM_TidyUpKeySpace(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyUpPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_TIDYUP == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeySpaceTidyup_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyUpReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_TIDYUP == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyUpExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_TIDYUP == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceTidyup_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatusSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_GETSTATUS; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm = (HSMCom_KeySpaceStatusType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeySpaceInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatus(HSM_L1_RtCtxType *pCtx, HSM_Ln_KeySpaceStatusType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GETSTATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->pKMSpaceStatus = pCfg; pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32Timeout = u32TimeoutMs; eRet = HSM_GetKeySpaceStat(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatusPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GETSTATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_KeySpaceTidyup_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatusReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GETSTATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatusExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GETSTATUS == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_KeySpaceGetStatus_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeySpaceInf.pSpaceParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } #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_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_KEY_MANAGE_GET_ID_STATUS; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tKeyInf.pParm = (HSMCom_UserKeyManageType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tKeyInf.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_GetKeyIdStatus(HSM_L1_RtCtxType *pCtx, hsm_uint32_t u32KeyId, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if (NULL_PTR != pCtx) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GET_ID_STATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tKeyInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tKeyIdStatusExtCfg.u32KeyID = u32KeyId; pCtx->tL1AlgCtx.tKeyInf.pParm->tKMParam.tKeyIdStatusExtCfg.pUserKeyStatus = &( pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.tKeyIdStatus); eRet = HSM_FW_GetKeyIdStatus(&(pCtx->tCmd), pCtx->tL1AlgCtx.tKeyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_GetKeyIdStatusPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GET_ID_STATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_GetKeyIdStatus_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_GetKeyIdStatusReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GET_ID_STATUS == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_GetKeyIdStatusExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_KEY_MANAGE_GET_ID_STATUS == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_GetKeyIdStatus_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tKeyInf.pParm->u32HSMStatusRet) { if (KEYMANAGER_USERKEY_STATUS_NOT_EXIST == pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.tKeyIdStatus) { eRet = HSM_STATUS_NOT_EXIST; } else if (KEYMANAGER_USERKEY_STATUS_EXIST_VALID == pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.tKeyIdStatus) { eRet = HSM_STATUS_EXIST; } else if (KEYMANAGER_USERKEY_STATUS_EXIST_INVALID == pCtx->tL1AlgCtx.tKeyInf.tKeyInfoShared.tKeyIdStatus) { eRet = HSM_STATUS_ZOMBIE; } else { eRet = HSM_STATUS_ERROR; } pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } #endif HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RSA_SSA_PKCS1V15_SIGN; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm = (HSMCom_RsaSsaPkcs1v15SignType *) HSM_ADDRESS_UP_ALIGN(&(pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignHash(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1V15SignHashType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_E = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32RsaBitCnt = pCfg->u32RsaBitCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (pCfg->u32RsaBitCnt > 0u) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32EmByteCnt = (pCfg->u32RsaBitCnt + 7u) >> 3u; } else { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32EmByteCnt = 0u; } pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pInputData = pCfg->pHashData; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32InputDataByteCount = pCfg->u32HashDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pPrivateKey = pCfg->pPrivateKey; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32PrivateKeyByteCnt = pCfg->u32PrivateKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.bUseInputDer = HSM_FALSE; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pDer = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32DerByteCount = 0u; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pResult = pCfg->pResult; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32ResultBufByteCnt = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pResultByteCnt = pCfg->pResultByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eInputType = HSM_RSA_SSA_INPUT_HASH_DATA; #if (FC7XXX_HSM_SUBSYSTEM_TYPE != FC7240_HSM_SUBSYSTEM) if (0u != pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_E) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pPrivateKey = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32PrivateKeyByteCnt = 0u; } if (0u != pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_N) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pKeyN = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32KeyNByteCount = 0u; } /* else do nothing */ #endif eRet = HSM_FW_RsaSsaPkcs1v15Sign(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignData(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPkcs1V15SignDataType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_E = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32RsaBitCnt = pCfg->u32RsaBitCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (pCfg->u32RsaBitCnt > 0u) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32EmByteCnt = (pCfg->u32RsaBitCnt + 7u) >> 3u; } else { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32EmByteCnt = 0u; } pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pInputData = pCfg->pInputData; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32InputDataByteCount = pCfg->u32InputDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pPrivateKey = pCfg->pPrivateKey; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32PrivateKeyByteCnt = pCfg->u32PrivateKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.bUseInputDer = HSM_FALSE; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pDer = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32DerByteCount = 0u; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pResult = pCfg->pResult; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32ResultBufByteCnt = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pResultByteCnt = pCfg->pResultByteCnt; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.eInputType = HSM_RSA_SSA_INPUT_RAW_MESSAGE; #if (FC7XXX_HSM_SUBSYSTEM_TYPE != FC7240_HSM_SUBSYSTEM) if (0u != pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_E) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pPrivateKey = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32PrivateKeyByteCnt = 0u; } if (0u != pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32UserKeyID_KEY_N) { pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.pKeyN = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->tCfg.u32KeyNByteCount = 0u; } /* else do nothing */ #endif eRet = HSM_FW_RsaSsaPkcs1v15Sign(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_RsaSsaPkcs1V15Sign_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15SignExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PKCS1V15_SIGN == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPkcs1V15Sign_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tRsaSsaPkcs1v15Sign.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_RSA_SSA_PSS_SIGN; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm = (HSMCom_RsaSsaPssSignType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tRsaSsaPssSign.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignData(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssSignDataType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_E = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32RsaBitCnt = pCfg->u32RsaBitCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.bUsePseudoRand = HSM_TRUE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eMgfHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (pCfg->u32RsaBitCnt > 0u) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32EmBitCnt = pCfg->u32RsaBitCnt - 1u; } else { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32EmBitCnt = 0u; } pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eInputType = HSM_RSA_SSA_INPUT_RAW_MESSAGE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pInputData = pCfg->pInputData; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32InputDataByteCount = pCfg->u32InputDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pPrivateKey = pCfg->pPrivateKey; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32PrivateKeyByteCnt = pCfg->u32PrivateKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.bUseInputSaltData = HSM_FALSE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pSalt = NULL_PTR; hsm_hash_get_result_byte_count( (HFAM_MODE_E)pCfg->eHashType, &pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32SaltByteCount); pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pResult = pCfg->pResult; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32ResultBufByteCnt = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pResultByteCnt = pCfg->pResultByteCnt; #if (FC7XXX_HSM_SUBSYSTEM_TYPE != FC7240_HSM_SUBSYSTEM) if (0u != pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_E) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pPrivateKey = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32PrivateKeyByteCnt = 0u; } if (0u != pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_N) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pKeyN = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32KeyNByteCount = 0u; } /* else do nothing */ #endif eRet = HSM_FW_RsaSsaPssSign(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignHash(HSM_L1_RtCtxType *pCtx, const HSM_Ln_RsaSsaPssSignHashType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_E = pCfg->u32PrivateKeyId; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_N = pCfg->u32KeyNId; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32RsaBitCnt = pCfg->u32RsaBitCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.bUsePseudoRand = HSM_TRUE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eMgfHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eInputFmt = pCfg->eInputFmt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eOutputFmt = pCfg->eOutputFmt; if (pCfg->u32RsaBitCnt > 0u) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32EmBitCnt = pCfg->u32RsaBitCnt - 1u; } else { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32EmBitCnt = 0u; } pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eHashType = pCfg->eHashType; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.eInputType = HSM_RSA_SSA_INPUT_HASH_DATA; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pInputData = pCfg->pHashData; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32InputDataByteCount = pCfg->u32HashDataByteCount; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pPrivateKey = pCfg->pPrivateKey; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32PrivateKeyByteCnt = pCfg->u32PrivateKeyByteCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.bUseInputSaltData = HSM_FALSE; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pSalt = NULL_PTR; hsm_hash_get_result_byte_count( (HFAM_MODE_E)pCfg->eHashType, &pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32SaltByteCount); pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pKeyN = pCfg->pKeyN; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32KeyNByteCount = pCfg->u32KeyNByteCount; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pResult = pCfg->pResult; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32ResultBufByteCnt = pCfg->u32ResultBufByteCnt; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pResultByteCnt = pCfg->pResultByteCnt; #if (FC7XXX_HSM_SUBSYSTEM_TYPE != FC7240_HSM_SUBSYSTEM) if (0u != pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_E) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pPrivateKey = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32PrivateKeyByteCnt = 0u; } if (0u != pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32UserKeyID_KEY_N) { pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.pKeyN = NULL_PTR; pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->tCfg.u32KeyNByteCount = 0u; } /* else do nothing */ #endif eRet = HSM_FW_RsaSsaPssSign(&(pCtx->tCmd), pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_RsaSsaPssSign_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_SIGN == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSignExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_RSA_SSA_PSS_SIGN == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_RsaSsaPssSign_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tRsaSsaPssSign.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm2VerifySetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SM2_VERIFY; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm = (HSMCom_Sm2VerifyType *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aParmBuf[0])); pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pInputData_MOrHash = pCtx->tL1AlgCtx.tSm2VerifyInf.aHash; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pInputData_R = &pCtx->tL1AlgCtx.tSm2VerifyInf.aR; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pInputData_S = &pCtx->tL1AlgCtx.tSm2VerifyInf.aS; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pPublicKey_X = &pCtx->tL1AlgCtx.tSm2VerifyInf.akGx; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pPublicKey_Y = &pCtx->tL1AlgCtx.tSm2VerifyInf.akGy; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.pInputData_ID = pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2VerifyExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_VERIFY == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2Verify(HSM_L1_RtCtxType *pCtx, const HSM_L1_Sm2VerifyType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { if ((pCfg->u32kGxByteCnt == 32u) && (pCfg->u32kGyByteCnt == 32u) && (pCfg->u32SM2InputIDByteCnt <= (sizeof(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID))) && (pCfg->u32RByteCnt == 32u) && (pCfg->u32SByteCnt == 32u)) { pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->u32UserKeyID_PublicKey = pCfg->u32PublicKeyId; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.bHashInput = HSM_TRUE; pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.bUseDefaultID = pCfg->bUseDefaultID; if (0u == pCfg->u32PublicKeyId) { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.akGx[0])), pCfg->pkGx, 32u); hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.akGy[0])), pCfg->pkGy, 32u); if (HSM_DATA_FORMAT_1B == pCfg->ekGxyDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.akGx[0])), 8u); hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.akGy[0])), 8u); } } hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aHash[0])), pCfg->pData, 32u); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aHash[0])), 8u); } hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aR[0])), pCfg->pR, 32u); hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aS[0])), pCfg->pS, 32u); if (HSM_DATA_FORMAT_1B == pCfg->eRSDataFmt) { hsm_u32_array_swap((hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aR[0])), 8u); hsm_u32_array_swap((hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aS[0])), 8u); } if (HSM_FALSE == pCfg->bUseDefaultID) { hsm_memset(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID[0]), 0, sizeof(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID)); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID[0])), pCfg->pInputData_ID, pCfg->u32SM2InputIDByteCnt); hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID[0])), HSM_ADDRESS_UP_ALIGN(pCfg->u32SM2InputIDByteCnt) >> 2u); } else { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2VerifyInf.aUserID[0])), pCfg->pInputData_ID, HSM_ADDRESS_UP_ALIGN(pCfg->u32SM2InputIDByteCnt)); } pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->tCfg.u32SM2InputIDByteCnt = pCfg->u32SM2InputIDByteCnt; } eRet = HSM_Sm2Verify(&(pCtx->tCmd), pCtx->tL1AlgCtx.tSm2VerifyInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2Verify_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_PASS == pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_PASS; pCtx->eStat = HSM_DRV_SM_STOP; } else if (MAILBOXAPI_RET_FAIL == pCtx->tL1AlgCtx.tSm2VerifyInf.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_FAIL; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm2VerifyPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sm2Verify_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2VerifyReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_VERIFY == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZaSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_SM2_GEN_ZA; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm = (HSMCom_Sm2GenZaType *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.aParmBuf[0])); pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.pPublicKey_X = &pCtx->tL1AlgCtx.tSm2GenZaInf.akGx; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.pPublicKey_Y = &pCtx->tL1AlgCtx.tSm2GenZaInf.akGy; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.pInputData_ID = pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID; eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZaExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_GEN_ZA == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZa(HSM_L1_RtCtxType *pCtx, const HSM_LN_Sm2GenZaType *pCfg, hsm_uint32_t u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if ((NULL_PTR != pCtx) && (NULL_PTR != pCfg)) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_GEN_ZA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { if ((pCfg->u32kGxByteCnt == 32u) && (pCfg->u32kGyByteCnt == 32u) && (pCfg->u32SM2InputIDByteCnt <= (sizeof(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID)))) { pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->u32Timeout = u32TimeoutMs; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->u32UserKeyID_PublicKey = pCfg->u32PublicKeyId; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.bUseDefaultID = pCfg->bUseDefaultID; pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.pOutputData_Za = pCfg->pOutputData_Za; if (HSM_DATA_FORMAT_1B == pCfg->eOutputFmt) { pCtx->tL1AlgCtx.tSm2GenZaInf.bSwapOut = HSM_TRUE; } else { pCtx->tL1AlgCtx.tSm2GenZaInf.bSwapOut = HSM_FALSE; } if (0u == pCfg->u32PublicKeyId) { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.akGx[0])), pCfg->pkGx, 32u); hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.akGy[0])), pCfg->pkGy, 32u); if (HSM_DATA_FORMAT_1B == pCfg->ekGxyDataFmt) { hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.akGx[0])), 8u); hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.akGy[0])), 8u); } } if (HSM_FALSE == pCfg->bUseDefaultID) { hsm_memset(&(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID[0]), 0, sizeof(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID)); if (HSM_DATA_FORMAT_1B == pCfg->eDataFmt) { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID[0])), pCfg->pInputData_ID, pCfg->u32SM2InputIDByteCnt); hsm_u32_array_swap( (hsm_uint32_t *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID[0])), HSM_ADDRESS_UP_ALIGN(pCfg->u32SM2InputIDByteCnt) >> 2u); } else { hsm_memcpy((void *)(&(pCtx->tL1AlgCtx.tSm2GenZaInf.aUserID[0])), pCfg->pInputData_ID, HSM_ADDRESS_UP_ALIGN(pCfg->u32SM2InputIDByteCnt)); } pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.u32SM2InputIDByteCnt = pCfg->u32SM2InputIDByteCnt; } eRet = HSM_Sm2GenZa(&(pCtx->tCmd), pCtx->tL1AlgCtx.tSm2GenZaInf.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_PARAM_ERR; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZa_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->u32HSMStatusRet) { if (HSM_TRUE == pCtx->tL1AlgCtx.tSm2GenZaInf.bSwapOut) { hsm_u32_array_swap( (hsm_uint32_t *)(pCtx->tL1AlgCtx.tSm2GenZaInf.pParm->tCfg.pOutputData_Za), 8u); } eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_ERROR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZaPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_GEN_ZA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_Sm2GenZa_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_Sm2GenZaReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_SM2_GEN_ZA == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_PKCS1_GetRsaPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_RsaPrivateKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; hsm_uint32_t aLength[3u]; const hsm_uint8_t *aDataPointer[3u]; hsm_uint32_t u32Temp; hsm_uint32_t u32Idx; hsm_uint32_t u32Length; const hsm_uint8_t *pPerData = pDer; if (0x30u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* version */ pPerData += 3u; /* n */ for (u32Idx = 0u; u32Idx < 3u; u32Idx++) { if (0x02u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { u32Temp = ((*pPerData) & 0x7Fu); u32Length = 0u; while (u32Temp > 0u) { pPerData++; u32Length = (u32Length << 8u) | (*pPerData); u32Temp--; } } else { u32Length = (*pPerData); } pPerData++; aDataPointer[u32Idx] = pPerData; aLength[u32Idx] = u32Length; pPerData += u32Length; } else { break; /* error */ } } if (u32Idx == 3u) { for (u32Idx = 0u; u32Idx < 3u; u32Idx++) { while ((*(aDataPointer[u32Idx]) == 0u) && (aLength[u32Idx] > 1u)) { aDataPointer[u32Idx]++; aLength[u32Idx]--; } } pInf->pN = aDataPointer[0u]; pInf->pE = aDataPointer[1u]; pInf->pD = aDataPointer[2u]; pInf->u32NByteCnt = aLength[0u]; pInf->u32EByteCnt = aLength[1u]; pInf->u32DByteCnt = aLength[2u]; eRet = HSM_STATUS_SUCCESS; } } return eRet; } HSM_StatusType HSM_L1_PKCS1_GetEccPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_EccPrivateKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; hsm_uint32_t aLength[1u]; const hsm_uint8_t *aDataPointer[1u]; hsm_uint32_t u32Temp; hsm_uint32_t u32Length; const hsm_uint8_t *pPerData = pDer; if (0x30u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* version */ pPerData += 3u; /* privateKey */ if (0x04u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { u32Temp = (hsm_uint32_t)((hsm_uint32_t)(*pPerData) & 0x7Fu); u32Length = 0u; while (u32Temp > 0u) { pPerData++; u32Length = (u32Length << 8u) | (*pPerData); u32Temp--; } } else { u32Length = (*pPerData); } pPerData++; aDataPointer[0u] = pPerData; aLength[0u] = u32Length; pPerData += u32Length; eRet = HSM_STATUS_SUCCESS; /* to be continue */ } /* else do nothing */ } if (HSM_STATUS_SUCCESS == eRet) { while ((*(aDataPointer[0u]) == 0u) && (aLength[0u] > 1u)) { aDataPointer[0u]++; aLength[0u]--; } pInf->pPrivate = aDataPointer[0u]; pInf->u32PrivateByteCnt = aLength[0u]; } return eRet; } HSM_StatusType HSM_L1_PKCS8_GetPrivateKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS8_PrivateKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; const hsm_uint8_t *pPerData = pDer; if (0x30u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* version */ pPerData += 3u; /* privateKeyAlgorithm */ pPerData += 3u; if (0x9u == (*pPerData)) /* RSA OID length */ { pPerData += (*pPerData); /* 2a864886f70d010101 privateKeyAlgorithm.algorithm */ if (0x1u == (*pPerData)) /* oid last byte check */ { pPerData++; /* privateKeyAlgorithm.parameter */ pPerData += 2u; /* privateKey */ if (0x04u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* RSAPrivateKey, pkcs1 format */ eRet = HSM_L1_PKCS1_GetRsaPrivateKeyInfFromDer(pPerData, &(pInf->tPrivateInfo.tRsaKeyInf)); if (HSM_STATUS_SUCCESS == eRet) { pInf->eKeyType = HSM_L1_PKCS8_RSA_PRIVATE_KEY; } /* else do nothing */ } } } else if (0x7u == (*pPerData)) /* ECC OID length */ { pPerData += (*pPerData); /* 2a8648ce3d0201 privateKeyAlgorithm.algorithm */ if (0x1u == (*pPerData)) /* oid last byte check */ { pPerData++; /* privateKeyAlgorithm.parameter */ pPerData++; /* after pPerData address, the following is the curve type OID */ pPerData += (*pPerData); pPerData++; /* privateKey */ if (0x04u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* ECPrivateKey, pkcs1 format */ eRet = HSM_L1_PKCS1_GetEccPrivateKeyInfFromDer(pPerData, &(pInf->tPrivateInfo.tEccKeyInf)); if (HSM_STATUS_SUCCESS == eRet) { pInf->eKeyType = HSM_L1_PKCS8_ECC_PRIVATE_KEY; } /* else do nothing */ } } } else { /* PRQA S 2013 */ } } return eRet; } HSM_StatusType HSM_L1_PKCS1_GetRsaPublicKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PKCS_RsaPublicKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; hsm_uint32_t aLength[2u]; const hsm_uint8_t *aDataPointer[2u]; hsm_uint32_t u32Temp; hsm_uint32_t u32Idx; hsm_uint32_t u32Length; const hsm_uint8_t *pPerData = pDer; if (0x30u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; for (u32Idx = 0u; u32Idx < 2u; u32Idx++) { if (0x02u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { u32Temp = (hsm_uint32_t)((hsm_uint32_t)(*pPerData) & 0x7Fu); u32Length = 0u; while (u32Temp > 0u) { pPerData++; u32Length = (u32Length << 8u) | (*pPerData); u32Temp--; } } else { u32Length = (*pPerData); } pPerData++; aDataPointer[u32Idx] = pPerData; aLength[u32Idx] = u32Length; pPerData += u32Length; } else { break; /* error */ } } if (u32Idx == 2u) { for (u32Idx = 0u; u32Idx < 2u; u32Idx++) { while ((*(aDataPointer[u32Idx]) == 0u) && (aLength[u32Idx] > 1u)) { aDataPointer[u32Idx]++; aLength[u32Idx]--; } } pInf->pN = aDataPointer[0u]; pInf->u32NByteCnt = aLength[0u]; pInf->pE = aDataPointer[1u]; pInf->u32EByteCnt = aLength[1u]; eRet = HSM_STATUS_SUCCESS; } } return eRet; } HSM_StatusType hsm_l1_subjectpublicinfo_bitstring_geteccpublickeyinf( const hsm_uint8_t *pDer, HSM_L1_PKCS_EccPublicKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; hsm_uint32_t aLength[2u]; const hsm_uint8_t *aDataPointer[2u]; hsm_uint32_t u32Temp; hsm_uint32_t u32Length; const hsm_uint8_t *pPerData = pDer; if (0x03u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { u32Temp = (hsm_uint32_t)((hsm_uint32_t)(*pPerData) & 0x7Fu); u32Length = 0u; while (u32Temp > 0u) { pPerData++; u32Length = (u32Length << 8u) | (*pPerData); u32Temp--; } } else { u32Length = (*pPerData); } pPerData++; u32Length -= 2u; /* byte count remove leading byte and compressed/uncompressed format byte */ if (0x0u == (*pPerData)) /* not support bit string shift now */ { pPerData++; if (0x04u == (*pPerData)) /* uncompressed format */ { pPerData++; aDataPointer[0u] = pPerData; aLength[0u] = u32Length >> 1u; aDataPointer[1u] = pPerData + aLength[0u]; aLength[1u] = u32Length >> 1u; eRet = HSM_STATUS_SUCCESS; } } } if (HSM_STATUS_SUCCESS == eRet) { pInf->pKGx = aDataPointer[0u]; pInf->pKGy = aDataPointer[1u]; pInf->u32KGxByteCnt = aLength[0u]; pInf->u32KGyByteCnt = aLength[1u]; } return eRet; } HSM_StatusType HSM_L1_SubjectPublicInfo_GetPublicKeyInfFromDer(const hsm_uint8_t *pDer, HSM_L1_PublicKeyInfType *pInf) { HSM_StatusType eRet = HSM_STATUS_ERROR; const hsm_uint8_t *pPerData = pDer; if (0x30u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* algorithm AlgorithmIdentifier */ pPerData += 3u; if (0x9u == (*pPerData)) /* RSA OID length */ { pPerData += (*pPerData); /* 2a864886f70d010101 algorithm */ if (0x1u == (*pPerData)) /* oid last byte check */ { pPerData++; /* parameter */ pPerData += 2u; /* bit string RSAPublicKey wrapper */ if (0x03u == (*pPerData)) { pPerData++; if (0x80u & (*pPerData)) { pPerData += ((*pPerData) & 0x7Fu); } pPerData++; /* bit string leading byte */ if (0x0u == (*pPerData)) { pPerData++; /* RSAPublicKey */ eRet = HSM_L1_PKCS1_GetRsaPublicKeyInfFromDer(pPerData, &(pInf->tPublicInf.tRsaKeyInf)); if (HSM_STATUS_SUCCESS == eRet) { pInf->eKeyType = HSM_L1_RSA_PUBLIC_KEY; } /* else do nothing */ } } } } else if (0x7u == (*pPerData)) /* ECC OID length */ { pPerData += (*pPerData); /* 2a8648ce3d0201 OBJ_X9_62_id_ecPublicKey */ if (0x1u == (*pPerData)) /* oid last byte check */ { pPerData++; /* parameter */ pPerData++; /* after pPerData address, the following is the curve type OID */ pPerData += (*pPerData); pPerData++; /* public key */ eRet = hsm_l1_subjectpublicinfo_bitstring_geteccpublickeyinf( pPerData, &(pInf->tPublicInf.tEccKeyInf)); if (HSM_STATUS_SUCCESS == eRet) { pInf->eKeyType = HSM_L1_ECC_PUBLIC_KEY; } /* else do nothing */ } } else { /* PRQA S 2013 */ } } return eRet; } HSM_StatusType HSM_L1_LoadFirmwareSetupEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = HSM_FALSE; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if (HSM_FALSE == bInProcess) { pCtx->bInProcess = HSM_TRUE; pCtx->eOperationCata = HSM_OP_LOAD_FIRMWARE; pCtx->eStat = HSM_DRV_SM_READY; pCtx->tL1AlgCtx.tLoadFirmware.pParm = (HSMCom_LoadFirmwareType *)HSM_ADDRESS_UP_ALIGN( &(pCtx->tL1AlgCtx.tLoadFirmware.aParmBuf[0])); eRet = HSM_STATUS_SUCCESS; } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_LoadFirmware(HSM_L1_RtCtxType *pCtx, uint32 u32TimeoutMs) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; if (NULL_PTR != pCtx) { bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_LOAD_FIRMWARE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH != pCtx->eStat) { pCtx->tL1AlgCtx.tLoadFirmware.pParm->u32HSMStatusRet = MAILBOXAPI_RET_NONE; pCtx->tL1AlgCtx.tLoadFirmware.pParm->u32Timeout = u32TimeoutMs; eRet = HSM_LoadFirmware(&(pCtx->tCmd), pCtx->tL1AlgCtx.tLoadFirmware.pParm); if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_ARITH; eRet = pCtx->pSendCmdCb(&(pCtx->tCmd)); if (HSM_STATUS_SUCCESS != eRet) { pCtx->eStat = HSM_DRV_SM_STOP; eRet = HSM_STATUS_SEND_FAIL; } } else { ; } } else { eRet = HSM_STATUS_BUSY; } } else { eRet = HSM_STATUS_LOGIC_ERR; } } else { eRet = HSM_STATUS_PARAM_ERR; } return eRet; } HSM_StatusType HSM_L1_LoadFirmwarePoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_LOAD_FIRMWARE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pReadAckCb(); if (HSM_STATUS_BUSY == eRet) { eRet = HSM_STATUS_AGAIN; } else if (HSM_STATUS_SUCCESS == eRet) { eRet = HSM_L1_LoadFirmware_Isr(pCtx); } else { pCtx->eStat = HSM_DRV_SM_STOP; } } else { eRet = HSM_STATUS_HW_IDLE; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_LoadFirmwareReset(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; bInProcess = pCtx->bInProcess; if ((HSM_TRUE == bInProcess) && (HSM_OP_LOAD_FIRMWARE == pCtx->eOperationCata)) { if (HSM_DRV_SM_ARITH == pCtx->eStat) { eRet = pCtx->pCancelCmdCb(); } if (HSM_STATUS_SUCCESS == eRet) { pCtx->eStat = HSM_DRV_SM_READY; } else { ; } } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_LoadFirmwareExitEnv(HSM_L1_RtCtxType *pCtx) { HSM_BoolType bInProcess = pCtx->bInProcess; HSM_StatusType eRet = HSM_STATUS_SUCCESS; if ((HSM_TRUE == bInProcess) && (HSM_OP_LOAD_FIRMWARE == pCtx->eOperationCata)) { eRet = HSM_L1_CommonExitEnv(pCtx); } else { eRet = HSM_STATUS_LOGIC_ERR; } return eRet; } HSM_StatusType HSM_L1_LoadFirmware_Isr(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet; if (MAILBOXAPI_RET_SUCCESS == pCtx->tL1AlgCtx.tLoadFirmware.pParm->u32HSMStatusRet) { eRet = HSM_STATUS_SUCCESS; pCtx->eStat = HSM_DRV_SM_STOP; } else { eRet = HSM_STATUS_HW_ERR; pCtx->eStat = HSM_DRV_SM_STOP; } return eRet; } HSM_StatusType HSM_L1_GetPoll(HSM_L1_RtCtxType *pCtx) { HSM_StatusType eRet = HSM_STATUS_SUCCESS; HSM_BoolType bInProcess = HSM_FALSE; bInProcess = pCtx->bInProcess; if (HSM_TRUE == bInProcess) { switch (pCtx->eOperationCata) { case HSM_OP_AES_ENCRYPT: { eRet = HSM_L1_AesEncryptPoll(pCtx); } break; case HSM_OP_AES_DECRYPT: { eRet = HSM_L1_AesDecryptPoll(pCtx); } break; case HSM_OP_SM4_ENCRYPT: { eRet = HSM_L1_Sm4EncryptPoll(pCtx); } break; case HSM_OP_SM4_DECRYPT: { eRet = HSM_L1_Sm4DecryptPoll(pCtx); } break; case HSM_OP_CMAC: { eRet = HSM_L1_CMacPoll(pCtx); } break; case HSM_OP_RNG: { eRet = HSM_L1_RngPoll(pCtx); } break; case HSM_OP_SHA: { eRet = HSM_L1_RngPoll(pCtx); } break; case HSM_OP_MD5: { eRet = HSM_L1_Md5Poll(pCtx); } break; case HSM_OP_SM3: { eRet = HSM_L1_Sm3Poll(pCtx); } break; #if 0 /* * IF use key id of RSA E/D/N, the key data in key space of HSM side, * only support 4B format, * and the N size must 8bytes aligned, * the D/E size should equal to N size. * So use HSM_L1_BnCalc instead. */ case HSM_OP_RSA: { eRet = HSM_L1_RsaPoll(pCtx); } break; #endif case HSM_OP_BN_CALC: { eRet = HSM_L1_BnCalcPoll(pCtx); } break; case HSM_OP_ECC_VERIFY: { eRet = HSM_L1_EccVerifyPoll(pCtx); } break; case HSM_OP_ECC_EASYDECRY: { eRet = HSM_L1_EccDecryptPoll(pCtx); } break; case HSM_OP_SCATTER_HASH: { eRet = HSM_L1_ScatterHashPoll(pCtx); } break; case HSM_OP_SCATTER_CMAC: { eRet = HSM_L1_ScatterCMacPoll(pCtx); } break; case HSM_OP_ECC_SIGN: { eRet = HSM_L1_EccSignPoll(pCtx); } break; case HSM_OP_ECC_CALC: { eRet = HSM_L1_EccCalculatePoll(pCtx); } break; case HSM_OP_KEY_MANAGE_IMPORT: { eRet = HSM_L1_KeyImportPoll(pCtx); } break; #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) case HSM_OP_KEY_MANAGE_VALIDATE: { eRet = HSM_L1_KeyValidatePoll(pCtx); } break; #endif case HSM_OP_KEY_MANAGE_COPY: { eRet = HSM_L1_KeyCopyPoll(pCtx); } break; case HSM_OP_KEY_MANAGE_REVOKE: { eRet = HSM_L1_KeyRevokePoll(pCtx); } break; case HSM_OP_KEY_MANAGE_TIDYUP: { eRet = HSM_L1_KeySpaceTidyUpPoll(pCtx); } break; case HSM_OP_RSA_SSA_PSS_VERIFY: { eRet = HSM_L1_RsaSsaPssVerifyPoll(pCtx); } break; case HSM_OP_RSA_SSA_PKCS1V15_VERIFY: { eRet = HSM_L1_RsaSsaPkcs1V15VerifyPoll(pCtx); } break; case HSM_OP_KEY_MANAGE_GETSTATUS: { eRet = HSM_L1_KeySpaceGetStatusPoll(pCtx); } break; case HSM_OP_RSA_SSA_PKCS1V15_SIGN: { eRet = HSM_L1_RsaSsaPkcs1V15SignPoll(pCtx); } break; case HSM_OP_RSA_SSA_PSS_SIGN: { eRet = HSM_L1_RsaSsaPssSignPoll(pCtx); } break; #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) case HSM_OP_KEY_MANAGE_GET_ID_STATUS: { eRet = HSM_L1_GetKeyIdStatusPoll(pCtx); } break; #endif #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) #else case HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT: { eRet = HSM_L1_UpdateKeyIdContentPoll(pCtx); } break; #endif default: { eRet = HSM_STATUS_LOGIC_ERR; } break; } } else { eRet = HSM_STATUS_IDLE; } return eRet; } void HSM_L1_Ack_IrqHandler(void *pUpperCtx, HSM_StatusType eRet) { HSM_Ln_RtCtxType *pLnCtx = (HSM_Ln_RtCtxType *)pUpperCtx; HSM_L1_RtCtxType *pCtx = &(pLnCtx->tHsmL1Ctx); HSM_BoolType bInProcess = pCtx->bInProcess; HSM_BoolType bErrorHappen = HSM_FALSE; if (NULL_PTR != (pCtx->pCleanAndFlushDcache)) { pCtx->pCleanAndFlushDcache(); } /* else do nothing */ if (HSM_TRUE == bInProcess) { switch (pCtx->eOperationCata) { case HSM_OP_SHA: { eRet = HSM_L1_Sha_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_MD5: { eRet = HSM_L1_Md5_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_SM3: { eRet = HSM_L1_Sm3_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #if 0 /* * IF use key id of RSA E/D/N, the key data in key space of HSM side, * only support 4B format, * and the N size must 8bytes aligned, * the D/E size should equal to N size. * So use HSM_L1_BnCalc instead. */ case HSM_OP_RSA: { eRet = HSM_L1_Rsa_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #endif case HSM_OP_BN_CALC: { eRet = HSM_L1_BnCalc_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_RNG: { eRet = HSM_L1_Rng_Isr(pCtx); if (HSM_STATUS_AGAIN != eRet) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } if (NULL_PTR != pCtx->pStopCb) { pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } /* else do nothing */ } break; case HSM_OP_ECC_VERIFY: { eRet = HSM_L1_EccVerify_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_ERROR == eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_ECC_EASYDECRY: { eRet = HSM_L1_EccDecrypt_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_CMAC: { eRet = HSM_L1_CMac_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_AES_ENCRYPT: { eRet = HSM_L1_AesEncrypt_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_AES_DECRYPT: { eRet = HSM_L1_AesDecrypt_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_SM4_ENCRYPT: { eRet = HSM_L1_Sm4Encrypt_Isr(pCtx); if (HSM_STATUS_AGAIN != eRet) { if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } else { ; } } /* else nothing, need more process revoke */ } break; case HSM_OP_SM4_DECRYPT: { eRet = HSM_L1_Sm4Decrypt_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_SCATTER_HASH: { eRet = HSM_L1_ScatterHash_Isr(pCtx); if (HSM_STATUS_AGAIN != eRet) { if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } } break; case HSM_OP_SCATTER_CMAC: { eRet = HSM_L1_ScatterCMac_Isr(pCtx); if (HSM_STATUS_AGAIN != eRet) { if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } } break; case HSM_OP_ECC_SIGN: { eRet = HSM_L1_EccSign_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_ERROR == eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_RSA_SSA_PSS_VERIFY: { eRet = HSM_L1_RsaSsaPssVerify_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_ERROR == eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_RSA_SSA_PKCS1V15_VERIFY: { eRet = HSM_L1_RsaSsaPkcs1V15Verify_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_ERROR == eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_ECC_CALC: { eRet = HSM_L1_EccCalculate_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_KEY_MANAGE_IMPORT: { eRet = HSM_L1_KeyImport_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) case HSM_OP_KEY_MANAGE_VALIDATE: { eRet = HSM_L1_KeyValidate_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if ((HSM_STATUS_EXIST != eRet) && (HSM_STATUS_NOT_EXIST != eRet)) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #endif case HSM_OP_KEY_MANAGE_COPY: { eRet = HSM_L1_KeyCopy_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_KEY_MANAGE_REVOKE: { eRet = HSM_L1_KeyRevoke_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_KEY_MANAGE_TIDYUP: { eRet = HSM_L1_KeySpaceTidyup_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_KEY_MANAGE_GETSTATUS: { eRet = HSM_L1_KeySpaceGetStatus_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_RSA_SSA_PKCS1V15_SIGN: { eRet = HSM_L1_RsaSsaPkcs1V15Sign_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_RSA_SSA_PSS_SIGN: { eRet = HSM_L1_RsaSsaPssSign_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) case HSM_OP_KEY_MANAGE_GET_ID_STATUS: { eRet = HSM_L1_GetKeyIdStatus_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if ((HSM_STATUS_ERROR == eRet) || (HSM_STATUS_HW_ERR == eRet)) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #endif case HSM_OP_LOAD_FIRMWARE: { eRet = HSM_L1_LoadFirmware_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_HW_ERR == eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } } break; #if ((FC7XXX_HSM_SUBSYSTEM_TYPE == FC7240_HSM_SUBSYSTEM) || \ (FC7XXX_HSM_SUBSYSTEM_TYPE == FC7300_HSM_SUBSYSTEM)) #else case HSM_OP_KEY_MANAGE_UPDATE_KEY_ID_CONTENT: { eRet = HSM_L1_UpdateKeyIdContent_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; #endif case HSM_OP_SM2_VERIFY: { eRet = HSM_L1_Sm2Verify_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; case HSM_OP_SM2_GEN_ZA: { eRet = HSM_L1_Sm2GenZa_Isr(pCtx); if (NULL_PTR != pCtx->pStopCb) { if (HSM_STATUS_SUCCESS != eRet) { bErrorHappen = HSM_TRUE; } pCtx->pStopCb(pUpperCtx, bErrorHappen, eRet); } /* else do nothing */ } break; /* PRQA S 2016 ++ #Misra-C:Rule-16.4 Every switch statement shall have a default label * Reason: It doesn't go to the default branch */ default: break; /* PRQA S 2016 -- */ } } else { ; } }