Star1131
749
代码
代码
Issues33
Pull Requests58
Actions
项目讨论
Wiki
分析
Star1131
749
已合并
Correction of crypto error stack #1016
liwei3013创建于 1月20日
Correction of crypto error stack #1016
已合并
liwei3013创建于 1月20日
从cherry-pick-mr-944-1768913527687-auto合入到openhitls-0.3
共 123 个文件变更+1016-64
Mbsl/err/include/bsl_err_internal.h+8-0
@@ -52,10 +52,18 @@ void BSL_ERR_PushError(int32_t err, const char *file, uint32_t lineNo);
52 */52 */
53#define BSL_ERR_PUSH_ERROR(e) BSL_ERR_PushError((e), __FILENAME__, __LINE__)53#define BSL_ERR_PUSH_ERROR(e) BSL_ERR_PushError((e), __FILENAME__, __LINE__)
54 54 
55+#define BSL_ERR_SET_MARK() (void)BSL_ERR_SetMark()
56+ 
57+#define BSL_ERR_POP_TO_MARK() (void)BSL_ERR_PopToMark()
58+ 
55#else59#else
56 60 
57#define BSL_ERR_PUSH_ERROR(e)61#define BSL_ERR_PUSH_ERROR(e)
58 62 
63+#define BSL_ERR_SET_MARK()
64+ 
65+#define BSL_ERR_POP_TO_MARK()
66+ 
59#endif /* HITLS_BSL_ERR */67#endif /* HITLS_BSL_ERR */
60 68 
61#ifdef __cplusplus69#ifdef __cplusplus
Mbsl/obj/src/bsl_cid_op.c+0-2
@@ -271,14 +271,12 @@ static int32_t IsSignIdInHashTable(int32_t signId)
271 BSL_SignIdMap *signIdMap = NULL;271 BSL_SignIdMap *signIdMap = NULL;
272 int32_t ret = BSL_SAL_ThreadReadLock(g_signHashRwLock);272 int32_t ret = BSL_SAL_ThreadReadLock(g_signHashRwLock);
273 if (ret != BSL_SUCCESS) {273 if (ret != BSL_SUCCESS) {
274- BSL_ERR_PUSH_ERROR(ret);
275 return ret;274 return ret;
276 }275 }
277 276 
278 ret = BSL_HASH_At(g_signHashTable, (uintptr_t)signId, (uintptr_t *)&signIdMap);277 ret = BSL_HASH_At(g_signHashTable, (uintptr_t)signId, (uintptr_t *)&signIdMap);
279 (void)BSL_SAL_ThreadUnlock(g_signHashRwLock);278 (void)BSL_SAL_ThreadUnlock(g_signHashRwLock);
280 if (ret != BSL_SUCCESS || signIdMap == NULL) {279 if (ret != BSL_SUCCESS || signIdMap == NULL) {
281- BSL_ERR_PUSH_ERROR(BSL_OBJ_ERR_FIND_HASH_TABLE);
282 return BSL_OBJ_ERR_FIND_HASH_TABLE;280 return BSL_OBJ_ERR_FIND_HASH_TABLE;
283 }281 }
284 return BSL_SUCCESS;282 return BSL_SUCCESS;
Mbsl/params/src/bsl_params.c+0-2
@@ -231,7 +231,6 @@ const BSL_Param *BSL_PARAM_FindConstParam(const BSL_Param *param, int32_t key)
231 return NULL;231 return NULL;
232 }232 }
233 if (param == NULL) {233 if (param == NULL) {
234- BSL_ERR_PUSH_ERROR(BSL_INVALID_ARG);
235 return NULL;234 return NULL;
236 }235 }
237 int32_t index = 0;236 int32_t index = 0;
@@ -251,7 +250,6 @@ BSL_Param *BSL_PARAM_FindParam(BSL_Param *param, int32_t key)
251 return NULL;250 return NULL;
252 }251 }
253 if (param == NULL) {252 if (param == NULL) {
254- BSL_ERR_PUSH_ERROR(BSL_INVALID_ARG);
255 return NULL;253 return NULL;
256 }254 }
257 int32_t index = 0;255 int32_t index = 0;
Mbsl/uio/src/uio_abstraction.c+2-0
@@ -623,7 +623,9 @@ int32_t BSL_UIO_Append(BSL_UIO *uio, BSL_UIO *tail)
623 }623 }
624 t->next = tail;624 t->next = tail;
625 tail->prev = t;625 tail->prev = t;
626+ BSL_ERR_SET_MARK();
626 (void)BSL_UIO_Ctrl(uio, BSL_UIO_APPEND, 0, tail);627 (void)BSL_UIO_Ctrl(uio, BSL_UIO_APPEND, 0, tail);
628+ BSL_ERR_POP_TO_MARK();
627 return BSL_SUCCESS;629 return BSL_SUCCESS;
628}630}
629 631 
Mcodecs/src/decode.c+2-8
@@ -164,7 +164,7 @@ CRYPT_DECODER_Ctx *CRYPT_DECODE_ProviderNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t
164 const CRYPT_EAL_Func *funcsDecoder = NULL;164 const CRYPT_EAL_Func *funcsDecoder = NULL;
165 CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;165 CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;
166 int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_DECODER, pkeyAlgId, attrName,166 int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_DECODER, pkeyAlgId, attrName,
167- &funcsDecoder, &mgrCtx);167+ &funcsDecoder, &mgrCtx, false);
168 if (ret != CRYPT_SUCCESS) {168 if (ret != CRYPT_SUCCESS) {
169 BSL_ERR_PUSH_ERROR(ret);169 BSL_ERR_PUSH_ERROR(ret);
170 return NULL;170 return NULL;
@@ -246,15 +246,9 @@ int32_t CRYPT_DECODE_Decode(CRYPT_DECODER_Ctx *ctx, const BSL_Param *inParam, BS
246 246 
247void CRYPT_DECODE_FreeOutData(CRYPT_DECODER_Ctx *ctx, BSL_Param *outData)247void CRYPT_DECODE_FreeOutData(CRYPT_DECODER_Ctx *ctx, BSL_Param *outData)
248{248{
249- if (ctx == NULL || outData == NULL) {249+ if (ctx == NULL || outData == NULL || ctx->method == NULL || ctx->method->freeOutData == NULL) {
250- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
251 return;250 return;
252 }251 }
253- if (ctx->method == NULL || ctx->method->freeOutData == NULL) {
254- BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
255- return;
256- }
257- 
258 ctx->method->freeOutData(ctx->decoderCtx, outData);252 ctx->method->freeOutData(ctx->decoderCtx, outData);
259}253}
260 254 
Mcodecs/src/decode_chain.c+2-0
@@ -247,6 +247,7 @@ static int32_t UpdateDecoderPath(CRYPT_DECODER_PoolCtx *poolCtx, CRYPT_DECODER_N
247static int32_t TryDecodeWithDecoder(CRYPT_DECODER_PoolCtx *poolCtx, CRYPT_DECODER_Node *currNode)247static int32_t TryDecodeWithDecoder(CRYPT_DECODER_PoolCtx *poolCtx, CRYPT_DECODER_Node *currNode)
248{248{
249 /* Convert password buffer to parameter if provided */249 /* Convert password buffer to parameter if provided */
250+ BSL_ERR_SET_MARK();
250 BSL_Param *decoderParam = NULL;251 BSL_Param *decoderParam = NULL;
251 int32_t ret = CRYPT_DECODE_Decode(currNode->decoderCtx, currNode->inData.data, &decoderParam);252 int32_t ret = CRYPT_DECODE_Decode(currNode->decoderCtx, currNode->inData.data, &decoderParam);
252 if (ret == CRYPT_SUCCESS) {253 if (ret == CRYPT_SUCCESS) {
@@ -277,6 +278,7 @@ static int32_t TryDecodeWithDecoder(CRYPT_DECODER_PoolCtx *poolCtx, CRYPT_DECODE
277 278 
278 return CRYPT_SUCCESS;279 return CRYPT_SUCCESS;
279 } else {280 } else {
281+ BSL_ERR_POP_TO_MARK();
280 /* Mark the node as tried */282 /* Mark the node as tried */
281 currNode->decoderCtx->decoderState = CRYPT_DECODER_STATE_TRIED;283 currNode->decoderCtx->decoderState = CRYPT_DECODER_STATE_TRIED;
282 return CRYPT_DECODE_RETRY;284 return CRYPT_DECODE_RETRY;
Mcrypto/bn/src/bn_prime.c+0-1
@@ -365,7 +365,6 @@ static int32_t PrimeLimbCheck(const BN_BigNum *bn)
365 if (BN_IsLimb(bn, 2) || BN_IsLimb(bn, 3)) { /* 2 and 3 directly determine that the number is a prime number. */365 if (BN_IsLimb(bn, 2) || BN_IsLimb(bn, 3)) { /* 2 and 3 directly determine that the number is a prime number. */
366 return CRYPT_SUCCESS;366 return CRYPT_SUCCESS;
367 }367 }
368- BSL_ERR_PUSH_ERROR(CRYPT_BN_NOR_CHECK_PRIME);
369 return CRYPT_BN_NOR_CHECK_PRIME;368 return CRYPT_BN_NOR_CHECK_PRIME;
370}369}
371static uint32_t GetP(const BN_BigNum *bn)370static uint32_t GetP(const BN_BigNum *bn)
Mcrypto/cmac/src/cbc_mac.c+0-1
@@ -141,7 +141,6 @@ int32_t CRYPT_CBC_MAC_Reinit(CRYPT_CBC_MAC_Ctx *ctx)
141int32_t CRYPT_CBC_MAC_Deinit(CRYPT_CBC_MAC_Ctx *ctx)141int32_t CRYPT_CBC_MAC_Deinit(CRYPT_CBC_MAC_Ctx *ctx)
142{142{
143 if (ctx == NULL) {143 if (ctx == NULL) {
144- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
145 return CRYPT_NULL_INPUT;144 return CRYPT_NULL_INPUT;
146 }145 }
147 return CipherMacDeinit(&ctx->common);146 return CipherMacDeinit(&ctx->common);
Mcrypto/cmac/src/cipher_mac_common.c+0-1
@@ -135,7 +135,6 @@ int32_t CipherMacReinit(Cipher_MAC_Common_Ctx *ctx)
135int32_t CipherMacDeinit(Cipher_MAC_Common_Ctx *ctx)135int32_t CipherMacDeinit(Cipher_MAC_Common_Ctx *ctx)
136{136{
137 if (ctx == NULL || ctx->method == NULL) {137 if (ctx == NULL || ctx->method == NULL) {
138- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
139 return CRYPT_NULL_INPUT;138 return CRYPT_NULL_INPUT;
140 }139 }
141 140 
Mcrypto/codecskey/src/crypt_codecskey.c+3-0
@@ -265,9 +265,11 @@ int32_t CRYPT_EAL_UnKnownKeyParseBuff(CRYPT_EAL_LibCtx *libctx, const char *attr
265 const BSL_Buffer *pwd, BSL_Buffer *encode, CRYPT_EAL_PkeyCtx **ealPKey)265 const BSL_Buffer *pwd, BSL_Buffer *encode, CRYPT_EAL_PkeyCtx **ealPKey)
266{266{
267 int32_t ret;267 int32_t ret;
268+ BSL_ERR_SET_MARK();
268 for (int32_t type = CRYPT_PRIKEY_PKCS8_UNENCRYPT; type <= CRYPT_PRIKEY_ECC; type++) {269 for (int32_t type = CRYPT_PRIKEY_PKCS8_UNENCRYPT; type <= CRYPT_PRIKEY_ECC; type++) {
269 ret = CRYPT_EAL_PriKeyParseBuff(libctx, attrName, format, type, encode, pwd, ealPKey);270 ret = CRYPT_EAL_PriKeyParseBuff(libctx, attrName, format, type, encode, pwd, ealPKey);
270 if (ret == CRYPT_SUCCESS) {271 if (ret == CRYPT_SUCCESS) {
272+ BSL_ERR_POP_TO_MARK();
271 return ret;273 return ret;
272 }274 }
273 }275 }
@@ -275,6 +277,7 @@ int32_t CRYPT_EAL_UnKnownKeyParseBuff(CRYPT_EAL_LibCtx *libctx, const char *attr
275 for (int32_t type = CRYPT_PUBKEY_SUBKEY; type <= CRYPT_PUBKEY_SUBKEY_WITHOUT_SEQ; type++) {277 for (int32_t type = CRYPT_PUBKEY_SUBKEY; type <= CRYPT_PUBKEY_SUBKEY_WITHOUT_SEQ; type++) {
276 ret = CRYPT_EAL_PubKeyParseBuff(libctx, attrName, format, type, encode, ealPKey);278 ret = CRYPT_EAL_PubKeyParseBuff(libctx, attrName, format, type, encode, ealPKey);
277 if (ret == CRYPT_SUCCESS) {279 if (ret == CRYPT_SUCCESS) {
280+ BSL_ERR_POP_TO_MARK();
278 return ret;281 return ret;
279 }282 }
280 }283 }
Mcrypto/codecskey/src/crypt_codecskey_local.c+8-2
@@ -1530,10 +1530,12 @@ int32_t EncodeEccPrikeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPriKey, BSL_ASN1_Buffer *p
1530 1530 
1531static int32_t EncodeEccPubkeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1_Buffer *ecParamOid, BSL_Buffer *encodePub)1531static int32_t EncodeEccPubkeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1_Buffer *ecParamOid, BSL_Buffer *encodePub)
1532{1532{
1533- CRYPT_PKEY_ParaId paraId = CRYPT_EAL_PkeyGetParaId(ealPubKey);1533+ BslOidString *oid = NULL;
1534- BslOidString *oid = BSL_OBJ_GetOID((BslCid)paraId);
1535 if (CRYPT_EAL_PkeyGetId(ealPubKey) == CRYPT_PKEY_SM2) {1534 if (CRYPT_EAL_PkeyGetId(ealPubKey) == CRYPT_PKEY_SM2) {
1536 oid = BSL_OBJ_GetOID((BslCid)CRYPT_ECC_SM2);1535 oid = BSL_OBJ_GetOID((BslCid)CRYPT_ECC_SM2);
1536+ } else {
1537+ CRYPT_PKEY_ParaId paraId = CRYPT_EAL_PkeyGetParaId(ealPubKey);
1538+ oid = BSL_OBJ_GetOID((BslCid)paraId);
1537 }1539 }
1538 if (oid == NULL) {1540 if (oid == NULL) {
1539 BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);1541 BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
@@ -1646,10 +1648,12 @@ static int32_t GetMldsaSkInfo(CRYPT_EAL_PkeyCtx *ealPriKey, uint32_t *format, bo
1646 BSL_ERR_PUSH_ERROR(CRYPT_MLDSA_PRVKEY_FORMAT_ERROR);1648 BSL_ERR_PUSH_ERROR(CRYPT_MLDSA_PRVKEY_FORMAT_ERROR);
1647 return CRYPT_MLDSA_PRVKEY_FORMAT_ERROR;1649 return CRYPT_MLDSA_PRVKEY_FORMAT_ERROR;
1648 }1650 }
1651+ BSL_ERR_SET_MARK();
1649 ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_MLDSA_SEED, seedAsn1->buff, MLDSA_SEED_BYTES_LEN);1652 ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_MLDSA_SEED, seedAsn1->buff, MLDSA_SEED_BYTES_LEN);
1650 if (ret == CRYPT_SUCCESS) {1653 if (ret == CRYPT_SUCCESS) {
1651 *hasSeed = true;1654 *hasSeed = true;
1652 }1655 }
1656+ BSL_ERR_POP_TO_MARK();
1653 if (*format == (uint32_t)CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY ||1657 if (*format == (uint32_t)CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY ||
1654 *format == (uint32_t)CRYPT_ALGO_MLDSA_PRIV_FORMAT_BOTH) {1658 *format == (uint32_t)CRYPT_ALGO_MLDSA_PRIV_FORMAT_BOTH) {
1655 if (!(*hasSeed)) {1659 if (!(*hasSeed)) {
@@ -1906,10 +1910,12 @@ static int32_t GetMlkemDkInfo(CRYPT_EAL_PkeyCtx *ealPriKey, uint32_t *format, bo
1906 BSL_ERR_PUSH_ERROR(CRYPT_MLKEM_DK_FORMAT_ERROR);1910 BSL_ERR_PUSH_ERROR(CRYPT_MLKEM_DK_FORMAT_ERROR);
1907 return CRYPT_MLKEM_DK_FORMAT_ERROR;1911 return CRYPT_MLKEM_DK_FORMAT_ERROR;
1908 }1912 }
1913+ BSL_ERR_SET_MARK();
1909 ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_MLKEM_SEED, seedAsn1->buff, MLKEM_SEED_BYTES_LEN);1914 ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_MLKEM_SEED, seedAsn1->buff, MLKEM_SEED_BYTES_LEN);
1910 if (ret == CRYPT_SUCCESS) {1915 if (ret == CRYPT_SUCCESS) {
1911 *hasSeed = true;1916 *hasSeed = true;
1912 }1917 }
1918+ BSL_ERR_POP_TO_MARK();
1913 if (*format == (uint32_t)CRYPT_ALGO_MLKEM_DK_FORMAT_SEED_ONLY ||1919 if (*format == (uint32_t)CRYPT_ALGO_MLKEM_DK_FORMAT_SEED_ONLY ||
1914 *format == (uint32_t)CRYPT_ALGO_MLKEM_DK_FORMAT_BOTH) {1920 *format == (uint32_t)CRYPT_ALGO_MLKEM_DK_FORMAT_BOTH) {
1915 if (!(*hasSeed)) {1921 if (!(*hasSeed)) {
Mcrypto/eal/src/eal_pkey_gen.c+6-6
@@ -772,7 +772,7 @@ int32_t CRYPT_EAL_SetPkeyMethod(EAL_PkeyUnitaryMethod *method, const CRYPT_EAL_F
772static int32_t ProviderGetTargetFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,772static int32_t ProviderGetTargetFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,
773 const char *attrName, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx)773 const char *attrName, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx)
774{774{
775- int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, operaId, algId, attrName, funcs, mgrCtx);775+ int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, operaId, algId, attrName, funcs, mgrCtx, true);
776 return ret == CRYPT_NOT_SUPPORT ? CRYPT_SUCCESS : ret;776 return ret == CRYPT_NOT_SUPPORT ? CRYPT_SUCCESS : ret;
777}777}
778 778 
@@ -801,7 +801,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
801#ifdef HITLS_CRYPTO_PKEY_CRYPT801#ifdef HITLS_CRYPTO_PKEY_CRYPT
802 if ((pkeyOperType & CRYPT_EAL_PKEY_CIPHER_OPERATE) == CRYPT_EAL_PKEY_CIPHER_OPERATE) {802 if ((pkeyOperType & CRYPT_EAL_PKEY_CIPHER_OPERATE) == CRYPT_EAL_PKEY_CIPHER_OPERATE) {
803 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_ASYMCIPHER, algId, attrName,803 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_ASYMCIPHER, algId, attrName,
804- &funcs->funcsAsyCipher, &funcs->mgrCtx);804+ &funcs->funcsAsyCipher, &funcs->mgrCtx, false);
805 if (ret != CRYPT_SUCCESS) {805 if (ret != CRYPT_SUCCESS) {
806 BSL_ERR_PUSH_ERROR(ret);806 BSL_ERR_PUSH_ERROR(ret);
807 return ret;807 return ret;
@@ -811,7 +811,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
811#ifdef HITLS_CRYPTO_PKEY_EXCH811#ifdef HITLS_CRYPTO_PKEY_EXCH
812 if ((pkeyOperType & CRYPT_EAL_PKEY_EXCH_OPERATE) == CRYPT_EAL_PKEY_EXCH_OPERATE) {812 if ((pkeyOperType & CRYPT_EAL_PKEY_EXCH_OPERATE) == CRYPT_EAL_PKEY_EXCH_OPERATE) {
813 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYEXCH, algId, attrName,813 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYEXCH, algId, attrName,
814- &funcs->funcsExch, &funcs->mgrCtx);814+ &funcs->funcsExch, &funcs->mgrCtx, false);
815 if (ret != CRYPT_SUCCESS) {815 if (ret != CRYPT_SUCCESS) {
816 BSL_ERR_PUSH_ERROR(ret);816 BSL_ERR_PUSH_ERROR(ret);
817 return ret;817 return ret;
@@ -821,7 +821,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
821#ifdef HITLS_CRYPTO_PKEY_SIGN821#ifdef HITLS_CRYPTO_PKEY_SIGN
822 if ((pkeyOperType & CRYPT_EAL_PKEY_SIGN_OPERATE) == CRYPT_EAL_PKEY_SIGN_OPERATE) {822 if ((pkeyOperType & CRYPT_EAL_PKEY_SIGN_OPERATE) == CRYPT_EAL_PKEY_SIGN_OPERATE) {
823 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_SIGN, algId, attrName,823 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_SIGN, algId, attrName,
824- &funcs->funcSign, &funcs->mgrCtx);824+ &funcs->funcSign, &funcs->mgrCtx, false);
825 if (ret != CRYPT_SUCCESS) {825 if (ret != CRYPT_SUCCESS) {
826 BSL_ERR_PUSH_ERROR(ret);826 BSL_ERR_PUSH_ERROR(ret);
827 return ret;827 return ret;
@@ -831,7 +831,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
831#ifdef HITLS_CRYPTO_PKEY_KEM831#ifdef HITLS_CRYPTO_PKEY_KEM
832 if ((pkeyOperType & CRYPT_EAL_PKEY_KEM_OPERATE) == CRYPT_EAL_PKEY_KEM_OPERATE) {832 if ((pkeyOperType & CRYPT_EAL_PKEY_KEM_OPERATE) == CRYPT_EAL_PKEY_KEM_OPERATE) {
833 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEM, algId, attrName,833 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEM, algId, attrName,
834- &funcs->funcKem, &funcs->mgrCtx);834+ &funcs->funcKem, &funcs->mgrCtx, false);
835 if (ret != CRYPT_SUCCESS) {835 if (ret != CRYPT_SUCCESS) {
836 BSL_ERR_PUSH_ERROR(ret);836 BSL_ERR_PUSH_ERROR(ret);
837 return ret;837 return ret;
@@ -839,7 +839,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
839 }839 }
840#endif840#endif
841 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYMGMT, algId, attrName,841 ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYMGMT, algId, attrName,
842- &funcs->funcsKeyMgmt, &funcs->mgrCtx);842+ &funcs->funcsKeyMgmt, &funcs->mgrCtx, false);
843 if (ret != CRYPT_SUCCESS) {843 if (ret != CRYPT_SUCCESS) {
844 BSL_ERR_PUSH_ERROR(ret);844 BSL_ERR_PUSH_ERROR(ret);
845 }845 }
Mcrypto/ecc/src/asm_ecp_nistp256.c+4-16
@@ -312,17 +312,11 @@ static void CRYPT_ECP256_PointDouble5Times(P256_Point *r)
312// Ensure that m is not empty and is in the range (0, n-1)312// Ensure that m is not empty and is in the range (0, n-1)
313static void ECP256_WindowMul(P256_Point *r, const BN_BigNum *k, const ECC_Point *point)313static void ECP256_WindowMul(P256_Point *r, const BN_BigNum *k, const ECC_Point *point)
314{314{
315- uint8_t kOctets[33]; // m big endian byte stream. Apply for 33 bytes and reserve one byte for the following offset.315+ uint8_t kOctets[33] = {0}; // m big endian byte stream. Apply for 33 bytes and reserve one byte for the following offset.
316- uint32_t mLen = BN_Bytes(k);
317- // Offset during byte stream conversion. Ensure that the valid data of the mOctet is in the upper bits.
318- uint32_t offset = sizeof(kOctets) - mLen;
319 P256_Point table[16]; // The pre-computation window is 2 ^ (5 - 1) = 16 points316 P256_Point table[16]; // The pre-computation window is 2 ^ (5 - 1) = 16 points
320 P256_Point temp; // Apply for temporary space of two points.317 P256_Point temp; // Apply for temporary space of two points.
321 Coord tempY;318 Coord tempY;
322- (void)BN_Bn2Bin(k, kOctets + offset, &mLen);319+ (void)BN_Bn2BinFixZero(k, kOctets, sizeof(kOctets));
323- for (uint32_t i = 0; i < offset; i++) {
324- kOctets[i] = 0;
325- }
326 320 
327 ECP256_EccPoint2P256Point(&temp, point);321 ECP256_EccPoint2P256Point(&temp, point);
328 322 
@@ -381,19 +375,13 @@ static void ECP256_WindowMul(P256_Point *r, const BN_BigNum *k, const ECC_Point
381 375 
382static void ComputeK1G(P256_Point *k1G, const BN_BigNum *k1)376static void ComputeK1G(P256_Point *k1G, const BN_BigNum *k1)
383{377{
384- uint8_t kOctets[33]; // applies for 33 bytes and reserves one byte for the following offset. 256 bits are 32 bytes.378+ uint8_t kOctets[33] = {0}; // applies for 33 bytes and reserves one byte for the following offset. 256 bits are 32 bytes.
385 Coord tempY;379 Coord tempY;
386 P256_AffinePoint k1GAffine;380 P256_AffinePoint k1GAffine;
387 const ECP256_TableRow *preCompTable = NULL; // precompute window size is 2 ^(7 - 1) = 64381 const ECP256_TableRow *preCompTable = NULL; // precompute window size is 2 ^(7 - 1) = 64
388 preCompTable = ECP256_GetPreCompTable();382 preCompTable = ECP256_GetPreCompTable();
389- 
390- uint32_t kLen = BN_Bytes(k1);
391 // Offset during byte stream conversion. Ensure that the valid data of the mOctet is in the upper bits.383 // Offset during byte stream conversion. Ensure that the valid data of the mOctet is in the upper bits.
392- uint32_t offset = sizeof(kOctets) - kLen;384+ (void)BN_Bn2BinFixZero(k1, kOctets, sizeof(kOctets));
393- (void)BN_Bn2Bin(k1, kOctets + offset, &kLen);
394- for (uint32_t i = 0; i < offset; i++) {
395- kOctets[i] = 0;
396- }
397 385 
398 uint32_t w = 7; // Window size = 7386 uint32_t w = 7; // Window size = 7
399 // the recode mask, the window size is 7, thus 8 bits are used (one extra bit is the sign bit).387 // the recode mask, the window size is 7, thus 8 bits are used (one extra bit is the sign bit).
Mcrypto/entropy/src/es_entropy.c+1-1
@@ -302,7 +302,7 @@ static uint32_t EsGetEntropy(ENTROPY_EntropySource *es, uint8_t *buf, uint32_t b
302 es->runLog(ret);302 es->runLog(ret);
303 }303 }
304 if (curEntropy >= entropy) {304 if (curEntropy >= entropy) {
305- return needLen;305+ break;
306 }306 }
307 }307 }
308 if (curEntropy == tmpEntropy) {308 if (curEntropy == tmpEntropy) {
Mcrypto/entropy/src/es_noise_source.c+2-0
@@ -128,6 +128,7 @@ int32_t ES_NsListInit(BslList *nsList, bool enableTest)
128 }128 }
129 bool nsUsed = false;129 bool nsUsed = false;
130 ES_NoiseSource *ns = NULL;130 ES_NoiseSource *ns = NULL;
131+ BSL_ERR_SET_MARK();
131 for (ns = BSL_LIST_GET_FIRST(nsList); ns != NULL; ns = BSL_LIST_GET_NEXT(nsList)) {132 for (ns = BSL_LIST_GET_FIRST(nsList); ns != NULL; ns = BSL_LIST_GET_NEXT(nsList)) {
132 /*133 /*
133 * If the health check is automatically performed when the noise source is generated, no additional health134 * If the health check is automatically performed when the noise source is generated, no additional health
@@ -157,6 +158,7 @@ int32_t ES_NsListInit(BslList *nsList, bool enableTest)
157 ES_NsListDeinit(nsList);158 ES_NsListDeinit(nsList);
158 return CRYPT_ENTROPY_ES_NO_NS;159 return CRYPT_ENTROPY_ES_NO_NS;
159 }160 }
161+ BSL_ERR_POP_TO_MARK();
160 return CRYPT_SUCCESS;162 return CRYPT_SUCCESS;
161}163}
162 164 
Mcrypto/hkdf/src/hkdf.c+0-1
@@ -96,7 +96,6 @@ int32_t CRYPT_HKDF_Extract(void *macCtx, const EAL_MacMethod *macMeth, const uin
96 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);96 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
97 return CRYPT_NULL_INPUT;97 return CRYPT_NULL_INPUT;
98 }98 }
99- 
100 (void)macMeth->deinit(macCtx);99 (void)macMeth->deinit(macCtx);
101 GOTO_ERR_IF(macMeth->init(macCtx, salt, saltLen, NULL), ret);100 GOTO_ERR_IF(macMeth->init(macCtx, salt, saltLen, NULL), ret);
102 GOTO_ERR_IF(macMeth->update(macCtx, key, keyLen), ret);101 GOTO_ERR_IF(macMeth->update(macCtx, key, keyLen), ret);
Mcrypto/hmac/src/hmac.c+0-1
@@ -236,7 +236,6 @@ int32_t CRYPT_HMAC_Reinit(CRYPT_HMAC_Ctx *ctx)
236int32_t CRYPT_HMAC_Deinit(CRYPT_HMAC_Ctx *ctx)236int32_t CRYPT_HMAC_Deinit(CRYPT_HMAC_Ctx *ctx)
237{237{
238 if (ctx == NULL || ctx->method.deinit == NULL) {238 if (ctx == NULL || ctx->method.deinit == NULL) {
239- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
240 return CRYPT_NULL_INPUT;239 return CRYPT_NULL_INPUT;
241 }240 }
242 (void)ctx->method.deinit(ctx->mdCtx);241 (void)ctx->method.deinit(ctx->mdCtx);
Mcrypto/md5/src/md5.c+0-1
@@ -70,7 +70,6 @@ int32_t CRYPT_MD5_InitEx(CRYPT_MD5_Ctx *ctx, void *param)
70int32_t CRYPT_MD5_Deinit(CRYPT_MD5_Ctx *ctx)70int32_t CRYPT_MD5_Deinit(CRYPT_MD5_Ctx *ctx)
71{71{
72 if (ctx == NULL) {72 if (ctx == NULL) {
73- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
74 return CRYPT_NULL_INPUT;73 return CRYPT_NULL_INPUT;
75 }74 }
76 (void)memset_s(ctx, sizeof(CRYPT_MD5_Ctx), 0, sizeof(CRYPT_MD5_Ctx));75 (void)memset_s(ctx, sizeof(CRYPT_MD5_Ctx), 0, sizeof(CRYPT_MD5_Ctx));
Mcrypto/modes/src/modes_gcm.c+0-1
@@ -494,7 +494,6 @@ int32_t MODES_GCM_Final(MODES_GCM_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
494int32_t MODES_GCM_DeInitCtx(MODES_GCM_Ctx *modeCtx)494int32_t MODES_GCM_DeInitCtx(MODES_GCM_Ctx *modeCtx)
495{495{
496 if (modeCtx == NULL) {496 if (modeCtx == NULL) {
497- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
498 return CRYPT_NULL_INPUT;497 return CRYPT_NULL_INPUT;
499 }498 }
500 int32_t algId = modeCtx->algId;499 int32_t algId = modeCtx->algId;
Mcrypto/provider/include/crypt_provider.h+1-1
@@ -64,7 +64,7 @@ int32_t CRYPT_EAL_AddNewProvMgrCtx(CRYPT_EAL_LibCtx *libCtx, const char *provide
64 CRYPT_EAL_ImplProviderInit init, void *handle, BSL_Param *param, CRYPT_EAL_ProvMgrCtx **ctx);64 CRYPT_EAL_ImplProviderInit init, void *handle, BSL_Param *param, CRYPT_EAL_ProvMgrCtx **ctx);
65 65 
66int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,66int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,
67- const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx);67+ const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx, bool noPushError);
68 68 
69CRYPT_EAL_LibCtx* CRYPT_EAL_GetGlobalLibCtx(void);69CRYPT_EAL_LibCtx* CRYPT_EAL_GetGlobalLibCtx(void);
70CRYPT_EAL_LibCtx *GetCurrentProviderLibCtx(CRYPT_EAL_LibCtx *libCtx);70CRYPT_EAL_LibCtx *GetCurrentProviderLibCtx(CRYPT_EAL_LibCtx *libCtx);
Mcrypto/provider/src/mgr/crypt_provider_common.c+3-3
@@ -37,7 +37,7 @@ int32_t CRYPT_EAL_ProviderGetFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, in
37 const char *attribute, const CRYPT_EAL_Func **funcs, void **provCtx)37 const char *attribute, const CRYPT_EAL_Func **funcs, void **provCtx)
38{38{
39 CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;39 CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;
40- int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, operaId, algId, attribute, funcs, &mgrCtx);40+ int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, operaId, algId, attribute, funcs, &mgrCtx, false);
41 if (ret != CRYPT_SUCCESS) {41 if (ret != CRYPT_SUCCESS) {
42 BSL_ERR_PUSH_ERROR(ret);42 BSL_ERR_PUSH_ERROR(ret);
43 return ret;43 return ret;
@@ -53,7 +53,7 @@ int32_t CRYPT_EAL_ProviderGetFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, in
53}53}
54 54 
55int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,55int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,
56- const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx)56+ const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx, bool noPushError)
57{57{
58 if (funcs == NULL || mgrCtx == NULL) {58 if (funcs == NULL || mgrCtx == NULL) {
59 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);59 BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
@@ -69,7 +69,7 @@ int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t op
69 return CRYPT_PROVIDER_ERR_ATTRIBUTE;69 return CRYPT_PROVIDER_ERR_ATTRIBUTE;
70 }70 }
71 71 
72- return CRYPT_EAL_CompareAlgAndAttr(localCtx, operaId, algId, attribute, funcs, mgrCtx);72+ return CRYPT_EAL_CompareAlgAndAttr(localCtx, operaId, algId, attribute, funcs, mgrCtx, noPushError);
73}73}
74 74 
75int32_t CRYPT_EAL_ProvMgrCtrl(CRYPT_EAL_ProvMgrCtx *ctx, int32_t cmd, void *val, uint32_t valLen)75int32_t CRYPT_EAL_ProvMgrCtrl(CRYPT_EAL_ProvMgrCtx *ctx, int32_t cmd, void *val, uint32_t valLen)
Mcrypto/provider/src/mgr/crypt_provider_compare.c+11-2
@@ -435,7 +435,7 @@ static void FindHighestScoreFunc(CRYPT_EAL_LibCtx *localCtx, int32_t operaId, in
435 }435 }
436}436}
437 437 
438-int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,438+static int32_t CRYPT_EAL_CompareAlgAndAttrNoPushError(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,
439 int32_t algId, const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx)439 int32_t algId, const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx)
440{440{
441 int32_t ret;441 int32_t ret;
@@ -463,7 +463,6 @@ int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,
463 BSL_SAL_ThreadUnlock(localCtx->lock);463 BSL_SAL_ThreadUnlock(localCtx->lock);
464 BSL_HASH_Destroy(attrInfo.hash);464 BSL_HASH_Destroy(attrInfo.hash);
465 if (implFunc == NULL) {465 if (implFunc == NULL) {
466- BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
467 return CRYPT_NOT_SUPPORT;466 return CRYPT_NOT_SUPPORT;
468 }467 }
469 *funcs = implFunc;468 *funcs = implFunc;
@@ -473,4 +472,14 @@ int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,
473 return CRYPT_SUCCESS;472 return CRYPT_SUCCESS;
474}473}
475 474 
475+int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,
476+ int32_t algId, const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx, bool noPushError)
477+{
478+ int32_t ret = CRYPT_EAL_CompareAlgAndAttrNoPushError(localCtx, operaId, algId, attribute, funcs, mgrCtx);
479+ if (ret != CRYPT_SUCCESS && !noPushError) {
480+ BSL_ERR_PUSH_ERROR(ret);
481+ }
482+ return ret;
483+}
484+ 
476#endif // HITLS_CRYPTO_PROVIDER485#endif // HITLS_CRYPTO_PROVIDER
Mcrypto/provider/src/mgr/crypt_provider_local.h+1-1
@@ -62,7 +62,7 @@ int32_t CRYPT_EAL_InitProviderMethod(CRYPT_EAL_ProvMgrCtx *ctx, BSL_Param *param
62 CRYPT_EAL_ImplProviderInit providerInit);62 CRYPT_EAL_ImplProviderInit providerInit);
63CRYPT_EAL_LibCtx *CRYPT_EAL_LibCtxNewInternal(void);63CRYPT_EAL_LibCtx *CRYPT_EAL_LibCtxNewInternal(void);
64int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,64int32_t CRYPT_EAL_CompareAlgAndAttr(CRYPT_EAL_LibCtx *localCtx, int32_t operaId,
65- int32_t algId, const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx);65+ int32_t algId, const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx, bool noPushError);
66 66 
67void CRYPT_EAL_ProviderMgrCtxFree(CRYPT_EAL_ProvMgrCtx *ctx);67void CRYPT_EAL_ProviderMgrCtxFree(CRYPT_EAL_ProvMgrCtx *ctx);
68 68 
Mcrypto/sha1/src/sha1.c+0-1
@@ -80,7 +80,6 @@ int32_t CRYPT_SHA1_InitEx(CRYPT_SHA1_Ctx *ctx, void *param)
80int32_t CRYPT_SHA1_Deinit(CRYPT_SHA1_Ctx *ctx)80int32_t CRYPT_SHA1_Deinit(CRYPT_SHA1_Ctx *ctx)
81{81{
82 if (ctx == NULL) {82 if (ctx == NULL) {
83- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
84 return CRYPT_NULL_INPUT;83 return CRYPT_NULL_INPUT;
85 }84 }
86 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA1_Ctx));85 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA1_Ctx));
Mcrypto/sha2/src/sha2_256.c+0-1
@@ -81,7 +81,6 @@ int32_t CRYPT_SHA2_256_InitEx(CRYPT_SHA2_256_Ctx *ctx, void *param)
81int32_t CRYPT_SHA2_256_Deinit(CRYPT_SHA2_256_Ctx *ctx)81int32_t CRYPT_SHA2_256_Deinit(CRYPT_SHA2_256_Ctx *ctx)
82{82{
83 if (ctx == NULL) {83 if (ctx == NULL) {
84- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
85 return CRYPT_NULL_INPUT;84 return CRYPT_NULL_INPUT;
86 }85 }
87 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA2_256_Ctx));86 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA2_256_Ctx));
Mcrypto/sha2/src/sha2_512.c+0-1
@@ -113,7 +113,6 @@ int32_t CRYPT_SHA2_512_InitEx(CRYPT_SHA2_512_Ctx *ctx, void *param)
113int32_t CRYPT_SHA2_512_Deinit(CRYPT_SHA2_512_Ctx *ctx)113int32_t CRYPT_SHA2_512_Deinit(CRYPT_SHA2_512_Ctx *ctx)
114{114{
115 if (ctx == NULL) {115 if (ctx == NULL) {
116- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
117 return CRYPT_NULL_INPUT;116 return CRYPT_NULL_INPUT;
118 }117 }
119 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA2_512_Ctx));118 BSL_SAL_CleanseData((void *)(ctx), sizeof(CRYPT_SHA2_512_Ctx));
Mcrypto/sha3/src/sha3.c+0-1
@@ -163,7 +163,6 @@ int32_t CRYPT_SHA3_Squeeze(CRYPT_SHA3_Ctx *ctx, uint8_t *out, uint32_t len)
163int32_t CRYPT_SHA3_Deinit(CRYPT_SHA3_Ctx *ctx)163int32_t CRYPT_SHA3_Deinit(CRYPT_SHA3_Ctx *ctx)
164{164{
165 if (ctx == NULL) {165 if (ctx == NULL) {
166- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
167 return CRYPT_NULL_INPUT;166 return CRYPT_NULL_INPUT;
168 }167 }
169 BSL_SAL_CleanseData(ctx, sizeof(CRYPT_SHA3_Ctx));168 BSL_SAL_CleanseData(ctx, sizeof(CRYPT_SHA3_Ctx));
Mcrypto/siphash/src/siphash.c+0-1
@@ -311,7 +311,6 @@ int32_t CRYPT_SIPHASH_Reinit(CRYPT_SIPHASH_Ctx *ctx)
311int32_t CRYPT_SIPHASH_Deinit(CRYPT_SIPHASH_Ctx *ctx)311int32_t CRYPT_SIPHASH_Deinit(CRYPT_SIPHASH_Ctx *ctx)
312{312{
313 if (ctx == NULL) {313 if (ctx == NULL) {
314- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
315 return CRYPT_NULL_INPUT;314 return CRYPT_NULL_INPUT;
316 }315 }
317 return CRYPT_SUCCESS;316 return CRYPT_SUCCESS;
Mcrypto/sm3/src/sm3_public.c+0-1
@@ -71,7 +71,6 @@ int32_t CRYPT_SM3_InitEx(CRYPT_SM3_Ctx *ctx, void *param)
71int32_t CRYPT_SM3_Deinit(CRYPT_SM3_Ctx *ctx)71int32_t CRYPT_SM3_Deinit(CRYPT_SM3_Ctx *ctx)
72{72{
73 if (ctx == NULL) {73 if (ctx == NULL) {
74- BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
75 return CRYPT_NULL_INPUT;74 return CRYPT_NULL_INPUT;
76 }75 }
77 (void)memset_s(ctx, sizeof(CRYPT_SM3_Ctx), 0, sizeof(CRYPT_SM3_Ctx));76 (void)memset_s(ctx, sizeof(CRYPT_SM3_Ctx), 0, sizeof(CRYPT_SM3_Ctx));
Mpki/print/src/hitls_pki_print.c+2-0
@@ -266,6 +266,7 @@ int32_t HITLS_PKI_PrintDnName(uint32_t layer, BslList *list, bool newLine, BSL_U
266 int8_t namePosFlag = -1; // -1: not start; 0: first; 1: others266 int8_t namePosFlag = -1; // -1: not start; 0: first; 1: others
267 int32_t ret = HITLS_PKI_SUCCESS;267 int32_t ret = HITLS_PKI_SUCCESS;
268 268 
269+ BSL_ERR_SET_MARK();
269 for (name = g_nameFlag == HITLS_PKI_PRINT_DN_RFC2253 ? BSL_LIST_GET_LAST(list) : BSL_LIST_GET_FIRST(list);270 for (name = g_nameFlag == HITLS_PKI_PRINT_DN_RFC2253 ? BSL_LIST_GET_LAST(list) : BSL_LIST_GET_FIRST(list);
270 name != NULL;271 name != NULL;
271 name = g_nameFlag == HITLS_PKI_PRINT_DN_RFC2253 ? BSL_LIST_GET_PREV(list) : BSL_LIST_GET_NEXT(list)) {272 name = g_nameFlag == HITLS_PKI_PRINT_DN_RFC2253 ? BSL_LIST_GET_PREV(list) : BSL_LIST_GET_NEXT(list)) {
@@ -301,6 +302,7 @@ int32_t HITLS_PKI_PrintDnName(uint32_t layer, BslList *list, bool newLine, BSL_U
301 }302 }
302 preLayerIs2 = name->layer != 1;303 preLayerIs2 = name->layer != 1;
303 }304 }
305+ BSL_ERR_POP_TO_MARK();
304 if (newLine) {306 if (newLine) {
305 return BSL_PRINT_Buff(0, uio, HITLS_X509_PRINT_NEW_LINE, strlen(HITLS_X509_PRINT_NEW_LINE)) == 0307 return BSL_PRINT_Buff(0, uio, HITLS_X509_PRINT_NEW_LINE, strlen(HITLS_X509_PRINT_NEW_LINE)) == 0
306 ? HITLS_PKI_SUCCESS308 ? HITLS_PKI_SUCCESS
Mpki/x509_common/src/hitls_x509_common.c+2-0
@@ -508,6 +508,7 @@ static int32_t HITLS_X509_ParsePem(CRYPT_EAL_LibCtx *libCtx, const char *attrNam
508 uint32_t nextEncodeLen = encode->dataLen;508 uint32_t nextEncodeLen = encode->dataLen;
509 BSL_PEM_Symbol symbol = {0};509 BSL_PEM_Symbol symbol = {0};
510 X509_GetPemSymbol(isCert, &symbol);510 X509_GetPemSymbol(isCert, &symbol);
511+ BSL_ERR_SET_MARK();
511 while (nextEncodeLen > 0) {512 while (nextEncodeLen > 0) {
512 BSL_Buffer asn1Buf = {0};513 BSL_Buffer asn1Buf = {0};
513 int32_t ret = BSL_PEM_DecodePemToAsn1(&nextEncode, &nextEncodeLen, &symbol, &(asn1Buf.data),514 int32_t ret = BSL_PEM_DecodePemToAsn1(&nextEncode, &nextEncodeLen, &symbol, &(asn1Buf.data),
@@ -524,6 +525,7 @@ static int32_t HITLS_X509_ParsePem(CRYPT_EAL_LibCtx *libCtx, const char *attrNam
524 BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_PARSE_NO_ELEMENT);525 BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_PARSE_NO_ELEMENT);
525 return HITLS_X509_ERR_PARSE_NO_ELEMENT;526 return HITLS_X509_ERR_PARSE_NO_ELEMENT;
526 }527 }
528+ BSL_ERR_POP_TO_MARK();
527 return HITLS_PKI_SUCCESS;529 return HITLS_PKI_SUCCESS;
528}530}
529#endif // HITLS_BSL_PEM531#endif // HITLS_BSL_PEM
Mpki/x509_common/src/hitls_x509_ext.c+4-2
@@ -633,7 +633,9 @@ int32_t HITLS_X509_ParseExtItem(BSL_ASN1_Buffer *extItem, HITLS_X509_ExtEntry *e
633 }633 }
634 // extnid634 // extnid
635 extEntry->extnId = asnArr[HITLS_X509_EXT_OID_IDX];635 extEntry->extnId = asnArr[HITLS_X509_EXT_OID_IDX];
636+ BSL_ERR_SET_MARK();
636 extEntry->cid = BSL_OBJ_GetCidFromOidBuff(extEntry->extnId.buff, extEntry->extnId.len);637 extEntry->cid = BSL_OBJ_GetCidFromOidBuff(extEntry->extnId.buff, extEntry->extnId.len);
638+ BSL_ERR_POP_TO_MARK();
637 // critical639 // critical
638 if (asnArr[HITLS_X509_EXT_CRITICAL_IDX].tag == 0) {640 if (asnArr[HITLS_X509_EXT_CRITICAL_IDX].tag == 0) {
639 extEntry->critical = false;641 extEntry->critical = false;
@@ -673,6 +675,7 @@ static int32_t ParseExtAsnItem(BSL_ASN1_Buffer *asn, void *param, BSL_ASN1_List
673 return ret;675 return ret;
674 }676 }
675 677 
678+ BSL_ERR_SET_MARK();
676 switch (BSL_OBJ_GetCidFromOidBuff(extEntry.extnId.buff, extEntry.extnId.len)) {679 switch (BSL_OBJ_GetCidFromOidBuff(extEntry.extnId.buff, extEntry.extnId.len)) {
677 case BSL_CID_CE_KEYUSAGE:680 case BSL_CID_CE_KEYUSAGE:
678 return ParseExtKeyUsage(&extEntry, (HITLS_X509_CertExt *)ext->extData);681 return ParseExtKeyUsage(&extEntry, (HITLS_X509_CertExt *)ext->extData);
@@ -687,6 +690,7 @@ static int32_t ParseExtAsnItem(BSL_ASN1_Buffer *asn, void *param, BSL_ASN1_List
687 return ret;690 return ret;
688 }691 }
689 default:692 default:
693+ BSL_ERR_POP_TO_MARK();
690 return HITLS_PKI_SUCCESS;694 return HITLS_PKI_SUCCESS;
691 }695 }
692}696}
@@ -1227,7 +1231,6 @@ int32_t HITLS_X509_SetGeneralNames(HITLS_X509_ExtEntry *extEntry, void *val)
1227int32_t HITLS_X509_GetExt(BslList *ext, BslCid cid, BSL_Buffer *val, uint32_t expectLen, DecodeExtCb decodeExt)1231int32_t HITLS_X509_GetExt(BslList *ext, BslCid cid, BSL_Buffer *val, uint32_t expectLen, DecodeExtCb decodeExt)
1228{1232{
1229 if (ext == NULL) {1233 if (ext == NULL) {
1230- BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_EXT_NOT_FOUND);
1231 return HITLS_X509_ERR_EXT_NOT_FOUND;1234 return HITLS_X509_ERR_EXT_NOT_FOUND;
1232 }1235 }
1233 if (val->dataLen != expectLen) {1236 if (val->dataLen != expectLen) {
@@ -1236,7 +1239,6 @@ int32_t HITLS_X509_GetExt(BslList *ext, BslCid cid, BSL_Buffer *val, uint32_t ex
1236 }1239 }
1237 HITLS_X509_ExtEntry *extEntry = BSL_LIST_Search(ext, &cid, CmpExtByCid, NULL);1240 HITLS_X509_ExtEntry *extEntry = BSL_LIST_Search(ext, &cid, CmpExtByCid, NULL);
1238 if (extEntry == NULL) {1241 if (extEntry == NULL) {
1239- BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_EXT_NOT_FOUND);
1240 return HITLS_X509_ERR_EXT_NOT_FOUND;1242 return HITLS_X509_ERR_EXT_NOT_FOUND;
1241 }1243 }
1242 return decodeExt(extEntry, val->data);1244 return decodeExt(extEntry, val->data);
Mpki/x509_verify/src/hitls_x509_verify.c+7-0
@@ -878,6 +878,7 @@ static int32_t X509_FindIssueCert(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_List
878{878{
879 // First try to find issuer in explicitly loaded store879 // First try to find issuer in explicitly loaded store
880 HITLS_X509_List *store = storeCtx->store;880 HITLS_X509_List *store = storeCtx->store;
881+ BSL_ERR_SET_MARK();
881 int32_t ret = X509_GetIssueFromChain(storeCtx, store, cert, issue);882 int32_t ret = X509_GetIssueFromChain(storeCtx, store, cert, issue);
882 if (ret == HITLS_PKI_SUCCESS) {883 if (ret == HITLS_PKI_SUCCESS) {
883 *issueInTrust = true;884 *issueInTrust = true;
@@ -889,6 +890,7 @@ static int32_t X509_FindIssueCert(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_List
889 if (BSL_LIST_COUNT(storeCtx->caPaths) > 0) {890 if (BSL_LIST_COUNT(storeCtx->caPaths) > 0) {
890 ret = FindIssuerByDer(storeCtx, cert, issue, issueInTrust);891 ret = FindIssuerByDer(storeCtx, cert, issue, issueInTrust);
891 if (ret == HITLS_PKI_SUCCESS) {892 if (ret == HITLS_PKI_SUCCESS) {
893+ BSL_ERR_POP_TO_MARK();
892 return HITLS_PKI_SUCCESS;894 return HITLS_PKI_SUCCESS;
893 }895 }
894 }896 }
@@ -898,6 +900,7 @@ static int32_t X509_FindIssueCert(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_List
898 if (certChain != NULL) {900 if (certChain != NULL) {
899 ret = X509_GetIssueFromChain(storeCtx, certChain, cert, issue);901 ret = X509_GetIssueFromChain(storeCtx, certChain, cert, issue);
900 if (ret == HITLS_PKI_SUCCESS) {902 if (ret == HITLS_PKI_SUCCESS) {
903+ BSL_ERR_POP_TO_MARK();
901 *issueInTrust = false;904 *issueInTrust = false;
902 return ret;905 return ret;
903 }906 }
@@ -1027,7 +1030,9 @@ int32_t HITLS_X509_CertChainBuild(HITLS_X509_StoreCtx *storeCtx, bool isWithRoot
1027 *chain = tmpChain;1030 *chain = tmpChain;
1028 return HITLS_PKI_SUCCESS;1031 return HITLS_PKI_SUCCESS;
1029 }1032 }
1033+ BSL_ERR_SET_MARK();
1030 (void)X509_BuildChain(false, storeCtx, NULL, cert, tmpChain, NULL);1034 (void)X509_BuildChain(false, storeCtx, NULL, cert, tmpChain, NULL);
1035+ BSL_ERR_POP_TO_MARK();
1031 *chain = tmpChain;1036 *chain = tmpChain;
1032 1037 
1033 return HITLS_PKI_SUCCESS;1038 return HITLS_PKI_SUCCESS;
@@ -1123,7 +1128,9 @@ static int32_t CheckMlKemKeyUsage(HITLS_X509_Cert *cert)
1123{1128{
1124 // Check ML-KEM keyUsage according to draft-ietf-lamps-kyber-certificates-11 Section 51129 // Check ML-KEM keyUsage according to draft-ietf-lamps-kyber-certificates-11 Section 5
1125 // keyEncipherment MUST be the only key usage set for ML-KEM-512/768/1024 certificates1130 // keyEncipherment MUST be the only key usage set for ML-KEM-512/768/1024 certificates
1131+ BSL_ERR_SET_MARK();
1126 CRYPT_PKEY_ParaId pubKeyParaId = CRYPT_EAL_PkeyGetParaId(cert->tbs.ealPubKey);1132 CRYPT_PKEY_ParaId pubKeyParaId = CRYPT_EAL_PkeyGetParaId(cert->tbs.ealPubKey);
1133+ BSL_ERR_POP_TO_MARK();
1127 if (pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_512 &&1134 if (pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_512 &&
1128 pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_768 &&1135 pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_768 &&
1129 pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_1024) {1136 pubKeyParaId != CRYPT_KEM_TYPE_MLKEM_1024) {
Mtestcode/framework/crypto/crypto_test_util.c+46-0
@@ -36,6 +36,7 @@
36 36 
37#include "securec.h"37#include "securec.h"
38#include "crypt_util_rand.h"38#include "crypt_util_rand.h"
39+#include "bsl_err_internal.h"
39 40 
40#ifndef HITLS_BSL_SAL_MEM41#ifndef HITLS_BSL_SAL_MEM
41void *TestMalloc(uint32_t len)42void *TestMalloc(uint32_t len)
@@ -54,6 +55,47 @@ void TestMemInit(void)
54#endif55#endif
55}56}
56 57 
58+void TestErrClear(void)
59+{
60+#ifdef HITLS_BSL_ERR
61+ BSL_ERR_ClearError();
62+#endif
63+}
64+ 
65+bool TestIsErrStackEmpty(void)
66+{
67+#ifdef HITLS_BSL_ERR
68+ if (BSL_ERR_Init() != BSL_SUCCESS) {
69+ return false;
70+ }
71+ const char *file = NULL;
72+ uint32_t line = 0;
73+ int32_t err = BSL_ERR_GetErrorFileLine(&file, &line); /* get the earliest error and pop it */
74+ if (err == BSL_SUCCESS) {
75+ return true;
76+ }
77+ Print("[BSL_ERR] unexpected error in stack: file=%s, line=%u\n", (file == NULL ? "NA" : file), line);
78+ return false;
79+#else
80+ return true;
81+#endif
82+}
83+ 
84+bool TestIsErrStackNotEmpty(void)
85+{
86+#ifdef HITLS_BSL_ERR
87+ if (BSL_ERR_Init() != BSL_SUCCESS) {
88+ return true;
89+ }
90+ const char *file = NULL;
91+ uint32_t line = 0;
92+ int32_t err = BSL_ERR_GetErrorFileLine(&file, &line); /* get the earliest error and pop it */
93+ return err != BSL_SUCCESS;
94+#else
95+ return true;
96+#endif
97+}
98+ 
57#if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_DRBG)99#if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_DRBG)
58typedef struct {100typedef struct {
59 CRYPT_Data *entropy;101 CRYPT_Data *entropy;
@@ -147,6 +189,8 @@ int TestRandInitEx(void *libCtx)
147 seedCtx.entropy = &tempEntropy;189 seedCtx.entropy = &tempEntropy;
148#endif190#endif
149 191 
192+ BSL_ERR_SET_MARK();
193+ 
150#ifdef HITLS_CRYPTO_PROVIDER194#ifdef HITLS_CRYPTO_PROVIDER
151#ifndef HITLS_CRYPTO_ENTROPY195#ifndef HITLS_CRYPTO_ENTROPY
152 BSL_Param param[4] = {0};196 BSL_Param param[4] = {0};
@@ -167,6 +211,7 @@ int TestRandInitEx(void *libCtx)
167#endif211#endif
168#endif212#endif
169 if (ret == CRYPT_EAL_ERR_DRBG_REPEAT_INIT) {213 if (ret == CRYPT_EAL_ERR_DRBG_REPEAT_INIT) {
214+ BSL_ERR_POP_TO_MARK();
170 ret = CRYPT_SUCCESS;215 ret = CRYPT_SUCCESS;
171 }216 }
172 return ret;217 return ret;
@@ -303,6 +348,7 @@ void TestMacAddrNotAlign(int algId, Hex *key, Hex *data, Hex *mac)
303 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);348 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);
304 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), CRYPT_SUCCESS);349 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), CRYPT_SUCCESS);
305 ASSERT_COMPARE("mac result cmp", out, outLen, mac->x, mac->len);350 ASSERT_COMPARE("mac result cmp", out, outLen, mac->x, mac->len);
351+ ASSERT_TRUE(TestIsErrStackEmpty());
306 352 
307EXIT:353EXIT:
308 CRYPT_EAL_MacFreeCtx(ctx);354 CRYPT_EAL_MacFreeCtx(ctx);
Mtestcode/framework/crypto/crypto_test_util.h+4-0
@@ -62,6 +62,10 @@ bool IsCurveDisabled(int eccId);
62 62 
63bool IsCurve25519AlgDisabled(int id);63bool IsCurve25519AlgDisabled(int id);
64 64 
65+void TestErrClear(void);
66+bool TestIsErrStackEmpty(void);
67+bool TestIsErrStackNotEmpty(void);
68+ 
65int32_t TestSimpleRand(uint8_t *buff, uint32_t len);69int32_t TestSimpleRand(uint8_t *buff, uint32_t len);
66int32_t TestSimpleRandEx(void *libCtx, uint8_t *buff, uint32_t len);70int32_t TestSimpleRandEx(void *libCtx, uint8_t *buff, uint32_t len);
67int32_t TestSimpleRandExSelfCheck(void *libCtx, uint8_t *buff, uint32_t len);71int32_t TestSimpleRandExSelfCheck(void *libCtx, uint8_t *buff, uint32_t len);
Mtestcode/framework/gen_test/helper.c+14-1
@@ -408,7 +408,12 @@ int GenFunctionWrapper(FILE *file, FunctionTable *function)
408 }408 }
409 }409 }
410 }410 }
411- ret = fprintf(file, ");\n}\n\n");411+ ret = fprintf(file,
412+ ");\n"
413+ "#if defined(HITLS_BSL_ERR)\n"
414+ " BSL_ERR_ClearError();\n"
415+ "#endif\n"
416+ "}\n\n");
412 if (ret < 0) {417 if (ret < 0) {
413 return 1;418 return 1;
414 }419 }
@@ -949,6 +954,14 @@ int ScanFunctionFile(FILE *fpIn, FILE *fpOut, const char *dir)
949 return 1;954 return 1;
950 }955 }
951 956 
957+ /* Optional: auto clear BSL error stack after each wrapper finishes. */
958+ if (fprintf(fpOut,
959+ "\n#if defined(HITLS_BSL_ERR)\n"
960+ "#include \"bsl_err.h\"\n"
961+ "#endif\n\n") < 0) {
962+ return 1;
963+ }
964+ 
952 for (int i = 0; i < g_testFuncCount; i++) {965 for (int i = 0; i < g_testFuncCount; i++) {
953 ret = GenFunctionWrapper(fpOut, &g_testFunc[i]);966 ret = GenFunctionWrapper(fpOut, &g_testFunc[i]);
954 if (ret < 0) {967 if (ret < 0) {
Mtestcode/sdv/testcase/bsl/asn1/test_suite_sdv_asn1.c+16-0
@@ -391,6 +391,7 @@ void SDV_BSL_ASN1_DECODE_TEMPLATE_LAYER_END_OPTIONAL_TC001(Hex *encode)
391 ASSERT_EQ(asnArr[2].tag, BSL_ASN1_TAG_INTEGER);391 ASSERT_EQ(asnArr[2].tag, BSL_ASN1_TAG_INTEGER);
392 ASSERT_EQ(asnArr[2].len, 1);392 ASSERT_EQ(asnArr[2].len, 1);
393 ASSERT_EQ(asnArr[2].buff[0], 0x02);393 ASSERT_EQ(asnArr[2].buff[0], 0x02);
394+ ASSERT_TRUE(TestIsErrStackEmpty());
394EXIT:395EXIT:
395 return;396 return;
396}397}
@@ -553,6 +554,7 @@ void SDV_BSL_ASN1_PARSE_CERT_FUNC_TC001(char *path, Hex *version, Hex *serial, H
553 ASSERT_EQ_LOG("sign compare tag", asnArr[BSL_ASN1_TAG_SIGN_IDX].tag, BSL_ASN1_TAG_BITSTRING);554 ASSERT_EQ_LOG("sign compare tag", asnArr[BSL_ASN1_TAG_SIGN_IDX].tag, BSL_ASN1_TAG_BITSTRING);
554 ASSERT_COMPARE("sign compare", sign->x, sign->len,555 ASSERT_COMPARE("sign compare", sign->x, sign->len,
555 asnArr[BSL_ASN1_TAG_SIGN_IDX].buff, asnArr[BSL_ASN1_TAG_SIGN_IDX].len);556 asnArr[BSL_ASN1_TAG_SIGN_IDX].buff, asnArr[BSL_ASN1_TAG_SIGN_IDX].len);
557+ ASSERT_TRUE(TestIsErrStackEmpty());
556EXIT:558EXIT:
557 BSL_SAL_FREE(rawBuff);559 BSL_SAL_FREE(rawBuff);
558}560}
@@ -641,6 +643,7 @@ void SDV_BSL_ASN1_PARSE_BITSTRING_PRIMITIVEITEM_FUNC(Hex *val, int result, int u
641 ASSERT_EQ((uint32_t)unusedBits, res.unusedBits);643 ASSERT_EQ((uint32_t)unusedBits, res.unusedBits);
642 ASSERT_EQ(val->len - 1, res.len);644 ASSERT_EQ(val->len - 1, res.len);
643 ASSERT_COMPARE("bit string", res.buff, res.len, val->x + 1, val->len - 1);645 ASSERT_COMPARE("bit string", res.buff, res.len, val->x + 1, val->len - 1);
646+ ASSERT_TRUE(TestIsErrStackEmpty());
644 }647 }
645 648
646EXIT:649EXIT:
@@ -663,6 +666,7 @@ void SDV_BSL_ASN1_PARSE_TIME_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result,
663 ASSERT_EQ(res.hour, hour);666 ASSERT_EQ(res.hour, hour);
664 ASSERT_EQ(res.minute, minute);667 ASSERT_EQ(res.minute, minute);
665 ASSERT_EQ(res.second, second);668 ASSERT_EQ(res.second, second);
669+ ASSERT_TRUE(TestIsErrStackEmpty());
666 }670 }
667EXIT:671EXIT:
668 return;672 return;
@@ -840,6 +844,7 @@ void SDV_BSL_ASN1_ENCODE_BOOL_FUNC(int data, Hex *expect)
840 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);844 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
841 ASSERT_EQ(encodeLen, expect->len);845 ASSERT_EQ(encodeLen, expect->len);
842 ASSERT_COMPARE("Encode bool", expect->x, expect->len, encode, encodeLen);846 ASSERT_COMPARE("Encode bool", expect->x, expect->len, encode, encodeLen);
847+ ASSERT_TRUE(TestIsErrStackEmpty());
843EXIT:848EXIT:
844 BSL_SAL_Free(encode);849 BSL_SAL_Free(encode);
845}850}
@@ -881,6 +886,7 @@ void SDV_BSL_ASN1_ENCODE_INT_BN_FUNC(Hex *bn, Hex *expect)
881 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);886 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
882 ASSERT_EQ(encodeLen, expect->len);887 ASSERT_EQ(encodeLen, expect->len);
883 ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);888 ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
889+ ASSERT_TRUE(TestIsErrStackEmpty());
884EXIT:890EXIT:
885 BSL_SAL_Free(encode);891 BSL_SAL_Free(encode);
886}892}
@@ -954,6 +960,7 @@ void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC001(Hex *expect)
954 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);960 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
955 ASSERT_EQ(encodeLen, expect->len);961 ASSERT_EQ(encodeLen, expect->len);
956 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);962 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
963+ ASSERT_TRUE(TestIsErrStackEmpty());
957EXIT:964EXIT:
958 BSL_SAL_Free(encode);965 BSL_SAL_Free(encode);
959}966}
@@ -972,6 +979,7 @@ void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC002(Hex *expect)
972 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);979 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
973 ASSERT_EQ(encodeLen, expect->len);980 ASSERT_EQ(encodeLen, expect->len);
974 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);981 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
982+ ASSERT_TRUE(TestIsErrStackEmpty());
975EXIT:983EXIT:
976 BSL_SAL_Free(encode);984 BSL_SAL_Free(encode);
977}985}
@@ -1008,6 +1016,7 @@ void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC001(Hex *expect)
1008 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asns[0]), &encode, &encodeLen), BSL_SUCCESS);1016 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asns[0]), &encode, &encodeLen), BSL_SUCCESS);
1009 ASSERT_EQ(encodeLen, expect->len);1017 ASSERT_EQ(encodeLen, expect->len);
1010 ASSERT_COMPARE("Encode headonly", expect->x, expect->len, encode, encodeLen);1018 ASSERT_COMPARE("Encode headonly", expect->x, expect->len, encode, encodeLen);
1019+ ASSERT_TRUE(TestIsErrStackEmpty());
1011EXIT:1020EXIT:
1012 BSL_SAL_Free(encode);1021 BSL_SAL_Free(encode);
1013}1022}
@@ -1038,6 +1047,7 @@ void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC002(Hex *data, Hex *expect)
1038 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);1047 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
1039 ASSERT_EQ(encodeLen, expect->len);1048 ASSERT_EQ(encodeLen, expect->len);
1040 ASSERT_COMPARE("Encode optional|default", expect->x, expect->len, encode, encodeLen);1049 ASSERT_COMPARE("Encode optional|default", expect->x, expect->len, encode, encodeLen);
1050+ ASSERT_TRUE(TestIsErrStackEmpty());
1041EXIT:1051EXIT:
1042 BSL_SAL_Free(encode);1052 BSL_SAL_Free(encode);
1043}1053}
@@ -1089,6 +1099,7 @@ void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC003(Hex *data, int templIdx, Hex *expec
1089 ASSERT_EQ(BSL_ASN1_EncodeTemplate(g_templ + templIdx, asns, MAX_INT_ASN_NUM, &encode, &encodeLen), BSL_SUCCESS);1099 ASSERT_EQ(BSL_ASN1_EncodeTemplate(g_templ + templIdx, asns, MAX_INT_ASN_NUM, &encode, &encodeLen), BSL_SUCCESS);
1090 ASSERT_EQ(encodeLen, expect->len);1100 ASSERT_EQ(encodeLen, expect->len);
1091 ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);1101 ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
1102+ ASSERT_TRUE(TestIsErrStackEmpty());
1092EXIT:1103EXIT:
1093 BSL_SAL_Free(encode);1104 BSL_SAL_Free(encode);
1094}1105}
@@ -1228,6 +1239,7 @@ void SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize, Hex *encode)
1228 BSL_SUCCESS);1239 BSL_SUCCESS);
1229 ASSERT_EQ(encode->len, out.len);1240 ASSERT_EQ(encode->len, out.len);
1230 ASSERT_COMPARE("Encode list", encode->x, encode->len, out.buff, out.len);1241 ASSERT_COMPARE("Encode list", encode->x, encode->len, out.buff, out.len);
1242+ ASSERT_TRUE(TestIsErrStackEmpty());
1231EXIT:1243EXIT:
1232 BSL_SAL_FREE(out.buff);1244 BSL_SAL_FREE(out.buff);
1233#endif1245#endif
@@ -1264,6 +1276,7 @@ void SDV_BSL_ASN1_DECODE_THEN_ENCODE_FUNC_TC001(int testIdx, char *path)
1264 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, decodeAsns, asnNum, &encode, &encodeLen), BSL_SUCCESS);1276 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, decodeAsns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
1265 ASSERT_EQ(encodeLen, dataLen);1277 ASSERT_EQ(encodeLen, dataLen);
1266 ASSERT_COMPARE("Decode then encode", rawData, dataLen, encode, encodeLen);1278 ASSERT_COMPARE("Decode then encode", rawData, dataLen, encode, encodeLen);
1279+ ASSERT_TRUE(TestIsErrStackEmpty());
1267EXIT:1280EXIT:
1268 BSL_SAL_Free(decodeAsns);1281 BSL_SAL_Free(decodeAsns);
1269 BSL_SAL_Free(rawData);1282 BSL_SAL_Free(rawData);
@@ -1338,6 +1351,7 @@ void SDV_BSL_ASN1_ENCODE_THEN_DECODE_FUNC_TC001(int boolData, int number, Hex *b
1338 ASSERT_EQ(time2.hour, hour);1351 ASSERT_EQ(time2.hour, hour);
1339 ASSERT_EQ(time2.minute, minute);1352 ASSERT_EQ(time2.minute, minute);
1340 ASSERT_EQ(time2.second, second);1353 ASSERT_EQ(time2.second, second);
1354+ ASSERT_TRUE(TestIsErrStackEmpty());
1341 1355 
1342EXIT:1356EXIT:
1343 BSL_SAL_Free(integer.buff);1357 BSL_SAL_Free(integer.buff);
@@ -1371,6 +1385,7 @@ void SDV_BSL_ASN1_ENCODE_BMPSTRING_TC001(Hex *enc, char *dec)
1371 ret = BSL_ASN1_EncodeTemplate(&templ, &decode, 1, &encode.buff, &encode.len);1385 ret = BSL_ASN1_EncodeTemplate(&templ, &decode, 1, &encode.buff, &encode.len);
1372 ASSERT_EQ(ret, BSL_SUCCESS);1386 ASSERT_EQ(ret, BSL_SUCCESS);
1373 ASSERT_COMPARE("Encode String", encode.buff + 2, encode.len - 2, enc->x, enc->len); // skip 2 bytes header1387 ASSERT_COMPARE("Encode String", encode.buff + 2, encode.len - 2, enc->x, enc->len); // skip 2 bytes header
1388+ ASSERT_TRUE(TestIsErrStackEmpty());
1374 1389 
1375 BSL_SAL_FREE(encode.buff);1390 BSL_SAL_FREE(encode.buff);
1376 ret = BSL_ASN1_EncodeTemplate(&templ, &wrong, 1, &encode.buff, &encode.len);1391 ret = BSL_ASN1_EncodeTemplate(&templ, &wrong, 1, &encode.buff, &encode.len);
@@ -1393,6 +1408,7 @@ void SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001(int contentLen, int expectLen, int r
1393 ASSERT_EQ(BSL_ASN1_GetEncodeLen(contentLen, &encodeLen), ret);1408 ASSERT_EQ(BSL_ASN1_GetEncodeLen(contentLen, &encodeLen), ret);
1394 if (ret == BSL_SUCCESS) {1409 if (ret == BSL_SUCCESS) {
1395 ASSERT_EQ(encodeLen, expectLen);1410 ASSERT_EQ(encodeLen, expectLen);
1411+ ASSERT_TRUE(TestIsErrStackEmpty());
1396 }1412 }
1397EXIT:1413EXIT:
1398 return;1414 return;
Mtestcode/sdv/testcase/bsl/base64/test_suite_sdv_base64.c+8-0
@@ -242,6 +242,7 @@ void SDV_BSL_BASE64_FUNC_TC001(void)
242 ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);242 ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);
243 ASSERT_TRUE(decodeBufLen == srcLen);243 ASSERT_TRUE(decodeBufLen == srcLen);
244 }244 }
245+ ASSERT_TRUE(TestIsErrStackEmpty());
245EXIT:246EXIT:
246 return;247 return;
247}248}
@@ -324,6 +325,7 @@ void SDV_BSL_BASE64_FUNC_TC002(void)
324 free(decodeBuf);325 free(decodeBuf);
325 BSL_BASE64_CtxFree(ctx);326 BSL_BASE64_CtxFree(ctx);
326 }327 }
328+ ASSERT_TRUE(TestIsErrStackEmpty());
327EXIT:329EXIT:
328 return;330 return;
329}331}
@@ -371,6 +373,7 @@ void SDV_BSL_BASE64_FUNC_TC003(void)
371 373 
372 ASSERT_TRUE(total == sizeof(encodeResult_08_withNL) - 1);374 ASSERT_TRUE(total == sizeof(encodeResult_08_withNL) - 1);
373 ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_08_withNL, total) == 0);375 ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_08_withNL, total) == 0);
376+ ASSERT_TRUE(TestIsErrStackEmpty());
374EXIT:377EXIT:
375 free(encodeBuf);378 free(encodeBuf);
376 BSL_BASE64_CtxFree(ctx);379 BSL_BASE64_CtxFree(ctx);
@@ -419,6 +422,7 @@ void SDV_BSL_BASE64_FUNC_TC004(void)
419 422 
420 ASSERT_TRUE(total == srcLen);423 ASSERT_TRUE(total == srcLen);
421 ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, total) == 0);424 ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, total) == 0);
425+ ASSERT_TRUE(TestIsErrStackEmpty());
422EXIT:426EXIT:
423 free(decodeBuf);427 free(decodeBuf);
424 BSL_BASE64_CtxFree(ctx);428 BSL_BASE64_CtxFree(ctx);
@@ -656,6 +660,7 @@ void SDV_BSL_BASE64_FUNC_TC008(void)
656 total += tmpLen;660 total += tmpLen;
657 661 
658 ASSERT_TRUE(srcLen == total);662 ASSERT_TRUE(srcLen == total);
663+ ASSERT_TRUE(TestIsErrStackEmpty());
659EXIT:664EXIT:
660 free(encodeBuf);665 free(encodeBuf);
661 free(decodeBuf);666 free(decodeBuf);
@@ -677,6 +682,7 @@ void Base64BlockEncDec(const uint8_t *buf, const uint32_t len)
677 682 
678 TRUE_OR_EXIT(BSL_BASE64_Decode(hitlsEncResult, hitlsEncLen, hitlsDecResult, &hitlsDecLen) == BSL_SUCCESS);683 TRUE_OR_EXIT(BSL_BASE64_Decode(hitlsEncResult, hitlsEncLen, hitlsDecResult, &hitlsDecLen) == BSL_SUCCESS);
679 TRUE_OR_EXIT(hitlsDecLen == srcLen);684 TRUE_OR_EXIT(hitlsDecLen == srcLen);
685+ ASSERT_TRUE(TestIsErrStackEmpty());
680EXIT:686EXIT:
681 BSL_SAL_Free(hitlsEncResult);687 BSL_SAL_Free(hitlsEncResult);
682 BSL_SAL_Free(hitlsDecResult);688 BSL_SAL_Free(hitlsDecResult);
@@ -748,6 +754,7 @@ void Base64Stream(const uint8_t *buf, const uint32_t len)
748 tmpLen = hitlsDecLen;754 tmpLen = hitlsDecLen;
749 TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);755 TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
750 total += tmpLen;756 total += tmpLen;
757+ ASSERT_TRUE(TestIsErrStackEmpty());
751 758 
752EXIT:759EXIT:
753 BSL_SAL_Free(hitlsEncResult);760 BSL_SAL_Free(hitlsEncResult);
@@ -848,6 +855,7 @@ void Base64StreamMultiUpdate(const BASE64_TEST_DATA data[])
848 tmpLen = hitlsDecLen;855 tmpLen = hitlsDecLen;
849 TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);856 TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
850 total += tmpLen;857 total += tmpLen;
858+ ASSERT_TRUE(TestIsErrStackEmpty());
851 859 
852EXIT:860EXIT:
853 free(hitlsEncResult);861 free(hitlsEncResult);
Mtestcode/sdv/testcase/bsl/buffer/test_suite_sdv_buffer.c+1-0
@@ -41,6 +41,7 @@ void SDV_BSL_BUFFER_FUNC_buffer_new(void)
41 (void)BSL_BufMemGrowClean(buf, 6);41 (void)BSL_BufMemGrowClean(buf, 6);
42 ASSERT_EQ(buf->length, 6);42 ASSERT_EQ(buf->length, 6);
43 ASSERT_EQ(buf->max, 8);43 ASSERT_EQ(buf->max, 8);
44+ ASSERT_TRUE(TestIsErrStackEmpty());
44EXIT:45EXIT:
45 BSL_BufMemFree(buf);46 BSL_BufMemFree(buf);
46}47}
Mtestcode/sdv/testcase/bsl/hash/test_suite_sdv_hash.c+4-0
@@ -149,6 +149,7 @@ void SDV_BSL_HASH_LIST_FUNC_TC001(void)
149 }149 }
150 150 
151 ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);151 ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
152+ ASSERT_TRUE(TestIsErrStackEmpty());
152 153
153EXIT:154EXIT:
154 BSL_HASH_Destroy(hash);155 BSL_HASH_Destroy(hash);
@@ -227,6 +228,7 @@ void SDV_BSL_HASH_LIST_FUNC_TC002(void)
227 }228 }
228 229 
229 ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);230 ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
231+ ASSERT_TRUE(TestIsErrStackEmpty());
230 232
231EXIT:233EXIT:
232 BSL_HASH_Destroy(hash);234 BSL_HASH_Destroy(hash);
@@ -288,6 +290,7 @@ void SDV_BSL_HASH_LIST_FUNC_TC003(void)
288 ASSERT_TRUE(BSL_ListPopBack(list) == BSL_SUCCESS);290 ASSERT_TRUE(BSL_ListPopBack(list) == BSL_SUCCESS);
289 291 
290 ASSERT_TRUE(BSL_ListIterErase(list, it) != NULL);292 ASSERT_TRUE(BSL_ListIterErase(list, it) != NULL);
293+ ASSERT_TRUE(TestIsErrStackEmpty());
291 294 
292EXIT:295EXIT:
293 BSL_ListDeinit(list);296 BSL_ListDeinit(list);
@@ -341,6 +344,7 @@ void SDV_BSL_HASH_LIST_FUNC_TC004(void)
341 ASSERT_EQ(ListRawPopBack(list), BSL_SUCCESS);344 ASSERT_EQ(ListRawPopBack(list), BSL_SUCCESS);
342 345 
343 ASSERT_EQ(ListRawDeinit(list), BSL_SUCCESS);346 ASSERT_EQ(ListRawDeinit(list), BSL_SUCCESS);
347+ ASSERT_TRUE(TestIsErrStackEmpty());
344EXIT:348EXIT:
345 BSL_SAL_Free(list);349 BSL_SAL_Free(list);
346 BSL_SAL_Free(node);350 BSL_SAL_Free(node);
Mtestcode/sdv/testcase/bsl/hash/test_suite_sdv_hash_dynamic_resize.c+8-0
@@ -121,6 +121,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC001(void)
121 121 
122 // Verify all elements are accessible122 // Verify all elements are accessible
123 ASSERT_TRUE(verify_int_elements(hash, 0, 10) == BSL_SUCCESS);123 ASSERT_TRUE(verify_int_elements(hash, 0, 10) == BSL_SUCCESS);
124+ ASSERT_TRUE(TestIsErrStackEmpty());
124 125 
125EXIT:126EXIT:
126 BSL_HASH_Destroy(hash);127 BSL_HASH_Destroy(hash);
@@ -161,6 +162,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC002(void)
161 162 
162 // Verify all elements are accessible163 // Verify all elements are accessible
163 ASSERT_TRUE(verify_int_elements(hash, 0, 17) == BSL_SUCCESS);164 ASSERT_TRUE(verify_int_elements(hash, 0, 17) == BSL_SUCCESS);
165+ ASSERT_TRUE(TestIsErrStackEmpty());
164 166 
165EXIT:167EXIT:
166 BSL_HASH_Destroy(hash);168 BSL_HASH_Destroy(hash);
@@ -220,6 +222,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC004(void)
220 ASSERT_TRUE(userData->id == values[i].id);222 ASSERT_TRUE(userData->id == values[i].id);
221 ASSERT_TRUE(strcmp(userData->name, values[i].name) == 0);223 ASSERT_TRUE(strcmp(userData->name, values[i].name) == 0);
222 }224 }
225+ ASSERT_TRUE(TestIsErrStackEmpty());
223 226 
224EXIT:227EXIT:
225 BSL_HASH_Destroy(hash);228 BSL_HASH_Destroy(hash);
@@ -273,6 +276,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC005(void)
273 276 
274 // Verify remaining 7 elements are still accessible277 // Verify remaining 7 elements are still accessible
275 ASSERT_TRUE(verify_int_elements(hash, 9, 7) == BSL_SUCCESS);278 ASSERT_TRUE(verify_int_elements(hash, 9, 7) == BSL_SUCCESS);
279+ ASSERT_TRUE(TestIsErrStackEmpty());
276 280 
277EXIT:281EXIT:
278 BSL_HASH_Destroy(hash);282 BSL_HASH_Destroy(hash);
@@ -327,6 +331,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC006(void)
327 331 
328 // Verify remaining elements are accessible332 // Verify remaining elements are accessible
329 ASSERT_TRUE(verify_int_elements(hash, 10, 7) == BSL_SUCCESS);333 ASSERT_TRUE(verify_int_elements(hash, 10, 7) == BSL_SUCCESS);
334+ ASSERT_TRUE(TestIsErrStackEmpty());
330EXIT:335EXIT:
331 BSL_HASH_Destroy(hash);336 BSL_HASH_Destroy(hash);
332 return;337 return;
@@ -390,6 +395,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC007(void)
390 395 
391 // Verify remaining 8 elements are accessible396 // Verify remaining 8 elements are accessible
392 ASSERT_TRUE(verify_int_elements(hash, 22, 8) == BSL_SUCCESS);397 ASSERT_TRUE(verify_int_elements(hash, 22, 8) == BSL_SUCCESS);
398+ ASSERT_TRUE(TestIsErrStackEmpty());
393 399 
394EXIT:400EXIT:
395 BSL_HASH_Destroy(hash);401 BSL_HASH_Destroy(hash);
@@ -436,6 +442,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC008(void)
436 442 
437 // Verify remaining elements are accessible443 // Verify remaining elements are accessible
438 ASSERT_TRUE(verify_int_elements(hash, 7, 3) == BSL_SUCCESS);444 ASSERT_TRUE(verify_int_elements(hash, 7, 3) == BSL_SUCCESS);
445+ ASSERT_TRUE(TestIsErrStackEmpty());
439 446 
440EXIT:447EXIT:
441 BSL_HASH_Destroy(hash);448 BSL_HASH_Destroy(hash);
@@ -496,6 +503,7 @@ void SDV_BSL_HASH_DYNAMIC_RESIZE_FUNC_TC009(void)
496 uint32_t bucketSizeShrank2 = hash->bucketSize;503 uint32_t bucketSizeShrank2 = hash->bucketSize;
497 ASSERT_TRUE(bucketSizeShrank2 < bucketSizeExpanded2);504 ASSERT_TRUE(bucketSizeShrank2 < bucketSizeExpanded2);
498 ASSERT_TRUE(verify_int_elements(hash, 110, 5) == BSL_SUCCESS);505 ASSERT_TRUE(verify_int_elements(hash, 110, 5) == BSL_SUCCESS);
506+ ASSERT_TRUE(TestIsErrStackEmpty());
499 507 
500EXIT:508EXIT:
501 BSL_HASH_Destroy(hash);509 BSL_HASH_Destroy(hash);
Mtestcode/sdv/testcase/bsl/list/test_suite_sdv_list.c+16-0
@@ -265,6 +265,7 @@ void SDV_BSL_LIST_MAX_ELEMENTS_FUNC_TC001(void)
265 for (int i = 0; i < 65535; i++) {265 for (int i = 0; i < 65535; i++) {
266 ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);266 ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);
267 }267 }
268+ ASSERT_TRUE(TestIsErrStackEmpty());
268 ASSERT_EQ(BSL_LIST_GetMaxElements(), 65535);269 ASSERT_EQ(BSL_LIST_GetMaxElements(), 65535);
269 ASSERT_EQ(BSL_LIST_COUNT(list), 65535);270 ASSERT_EQ(BSL_LIST_COUNT(list), 65535);
270 ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);271 ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);
@@ -330,6 +331,7 @@ void SDV_BSL_LIST_DETACH_FUNC_TC001(void)
330 ASSERT_TRUE(UserDataCompare(testList->curr->prev->data, &data[5]) == 0);331 ASSERT_TRUE(UserDataCompare(testList->curr->prev->data, &data[5]) == 0);
331 BSL_LIST_DetachNode(testList, &testList->curr);332 BSL_LIST_DetachNode(testList, &testList->curr);
332 ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[5]) == 0);333 ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[5]) == 0);
334+ ASSERT_TRUE(TestIsErrStackEmpty());
333EXIT:335EXIT:
334 BSL_LIST_FREE(testList, UserDataFree);336 BSL_LIST_FREE(testList, UserDataFree);
335}337}
@@ -374,6 +376,7 @@ void SDV_BSL_LIST_SEARCH_FUNC_TC001(void)
374 376 
375 UserData *tmp2 = BSL_LIST_Search(testList, "Dave", UserDataCompareByName, &errNum);377 UserData *tmp2 = BSL_LIST_Search(testList, "Dave", UserDataCompareByName, &errNum);
376 ASSERT_TRUE(UserDataCompare(tmp2, &data[3]) == 0);378 ASSERT_TRUE(UserDataCompare(tmp2, &data[3]) == 0);
379+ ASSERT_TRUE(TestIsErrStackEmpty());
377EXIT:380EXIT:
378 BSL_LIST_FREE(testList, UserDataFree);381 BSL_LIST_FREE(testList, UserDataFree);
379}382}
@@ -450,6 +453,7 @@ void SDV_BSL_LIST_GET_NODE_FUNC_TC001(void)
450 // BSL_LIST_GetIndexNode changes the curr point to 3.453 // BSL_LIST_GetIndexNode changes the curr point to 3.
451 curTmp = *(UserData **)BSL_LIST_Curr(testList);454 curTmp = *(UserData **)BSL_LIST_Curr(testList);
452 ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);455 ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
456+ ASSERT_TRUE(TestIsErrStackEmpty());
453EXIT:457EXIT:
454 BSL_LIST_FREE(testList, UserDataFree);458 BSL_LIST_FREE(testList, UserDataFree);
455}459}
@@ -487,6 +491,7 @@ void SDV_BSL_LIST_COPY_FUNC_TC001(void)
487 destTmp = BSL_LIST_GET_LAST(destList);491 destTmp = BSL_LIST_GET_LAST(destList);
488 ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);492 ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);
489 ASSERT_TRUE(UserDataCompare(destList->first->next->data, srcList->first->next->data) == 0);493 ASSERT_TRUE(UserDataCompare(destList->first->next->data, srcList->first->next->data) == 0);
494+ ASSERT_TRUE(TestIsErrStackEmpty());
490EXIT:495EXIT:
491 BSL_LIST_FREE(destList, NULL);496 BSL_LIST_FREE(destList, NULL);
492 BSL_LIST_FREE(srcList, UserDataFree);497 BSL_LIST_FREE(srcList, UserDataFree);
@@ -519,6 +524,7 @@ void SDV_BSL_LIST_SORT_FUNC_TC001(void)
519 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);524 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
520 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);525 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);
521 ASSERT_TRUE(UserDataCompare(testList->first->next->next->next->data, &data[4]) == 0);526 ASSERT_TRUE(UserDataCompare(testList->first->next->next->next->data, &data[4]) == 0);
527+ ASSERT_TRUE(TestIsErrStackEmpty());
522EXIT:528EXIT:
523 BSL_LIST_FREE(testList, UserDataFree);529 BSL_LIST_FREE(testList, UserDataFree);
524}530}
@@ -558,6 +564,7 @@ void SDV_BSL_LIST_SORT_FUNC_TC002(void)
558 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 5, BSL_LIST_POS_AFTER), BSL_SUCCESS);564 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 5, BSL_LIST_POS_AFTER), BSL_SUCCESS);
559 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 8, BSL_LIST_POS_AFTER), BSL_SUCCESS);565 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 8, BSL_LIST_POS_AFTER), BSL_SUCCESS);
560 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 6, BSL_LIST_POS_AFTER), BSL_SUCCESS);566 ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 6, BSL_LIST_POS_AFTER), BSL_SUCCESS);
567+ ASSERT_TRUE(TestIsErrStackEmpty());
561 ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 100000);568 ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 100000);
562 ASSERT_EQ(BSL_LIST_SetMaxQsortCount(67108865), BSL_INVALID_ARG);569 ASSERT_EQ(BSL_LIST_SetMaxQsortCount(67108865), BSL_INVALID_ARG);
563 ASSERT_EQ(BSL_LIST_SetMaxQsortCount(10000), BSL_SUCCESS);570 ASSERT_EQ(BSL_LIST_SetMaxQsortCount(10000), BSL_SUCCESS);
@@ -657,6 +664,7 @@ void SDV_BSL_LIST_ADD_GET_FUNC_TC001(void)
657 ASSERT_TRUE(UserDataCompare(curTmp, &data[0]) == 0);664 ASSERT_TRUE(UserDataCompare(curTmp, &data[0]) == 0);
658 665 
659 ASSERT_TRUE(BSL_LIST_GetElmtIndex(&data[1], testList) == 1);666 ASSERT_TRUE(BSL_LIST_GetElmtIndex(&data[1], testList) == 1);
667+ ASSERT_TRUE(TestIsErrStackEmpty());
660EXIT:668EXIT:
661 BSL_LIST_FREE(testList, UserDataFree);669 BSL_LIST_FREE(testList, UserDataFree);
662}670}
@@ -697,6 +705,7 @@ void SDV_BSL_LIST_CONCAT_FUNC_TC001(void)
697 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(destList), &data[0]) == 0);705 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(destList), &data[0]) == 0);
698 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(destList), &data[5]) == 0);706 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(destList), &data[5]) == 0);
699 ASSERT_TRUE(UserDataCompare(destList->first->next->next->next->data, &data[3]) == 0);707 ASSERT_TRUE(UserDataCompare(destList->first->next->next->next->data, &data[3]) == 0);
708+ ASSERT_TRUE(TestIsErrStackEmpty());
700EXIT:709EXIT:
701 BSL_LIST_FREE(destList, UserDataFree);710 BSL_LIST_FREE(destList, UserDataFree);
702 BSL_SAL_FREE(srcList1);711 BSL_SAL_FREE(srcList1);
@@ -729,6 +738,7 @@ void SDV_BSL_LIST_REVERSE_FUNC_TC001(void)
729 BSL_LIST_RevList(testList);738 BSL_LIST_RevList(testList);
730 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);739 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
731 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[0]) == 0);740 ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[0]) == 0);
741+ ASSERT_TRUE(TestIsErrStackEmpty());
732EXIT:742EXIT:
733 BSL_LIST_FREE(testList, UserDataFree);743 BSL_LIST_FREE(testList, UserDataFree);
734}744}
@@ -769,6 +779,7 @@ void SDV_BSL_LIST_DELETE_NODE_FUNC_TC001(void)
769 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);779 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);
770 BSL_LIST_DeleteAll(testList, UserDataFree);780 BSL_LIST_DeleteAll(testList, UserDataFree);
771 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);781 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
782+ ASSERT_TRUE(TestIsErrStackEmpty());
772EXIT:783EXIT:
773 free(data1);784 free(data1);
774 BSL_LIST_FREE(testList, UserDataFree);785 BSL_LIST_FREE(testList, UserDataFree);
@@ -803,6 +814,7 @@ void SDV_BSL_LIST_DELETE_NODE_FUNC_TC002(void)
803 814 
804 BSL_LIST_DeleteAllAfterSort(testList);815 BSL_LIST_DeleteAllAfterSort(testList);
805 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);816 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
817+ ASSERT_TRUE(TestIsErrStackEmpty());
806EXIT:818EXIT:
807 free(data1);819 free(data1);
808 BSL_LIST_FREE(testList, UserDataFree);820 BSL_LIST_FREE(testList, UserDataFree);
@@ -851,6 +863,7 @@ void SDV_CRYPTO_LIST_Pre_API_TC001()
851 ASSERT_EQ(prv, NULL);863 ASSERT_EQ(prv, NULL);
852 prv = BSL_LIST_Prev(list);864 prv = BSL_LIST_Prev(list);
853 ASSERT_TRUE(prv != NULL && **prv == 1);865 ASSERT_TRUE(prv != NULL && **prv == 1);
866+ ASSERT_TRUE(TestIsErrStackEmpty());
854 867 
855EXIT:868EXIT:
856 BSL_LIST_FREE(list, EmptyFree);869 BSL_LIST_FREE(list, EmptyFree);
@@ -899,6 +912,7 @@ void SDV_CRYPTO_LIST_Next_API_TC002()
899 ASSERT_EQ(next, NULL);912 ASSERT_EQ(next, NULL);
900 next = BSL_LIST_Next(list);913 next = BSL_LIST_Next(list);
901 ASSERT_TRUE(next != NULL && **next == 1);914 ASSERT_TRUE(next != NULL && **next == 1);
915+ ASSERT_TRUE(TestIsErrStackEmpty());
902 916 
903EXIT:917EXIT:
904 BSL_LIST_FREE(list, EmptyFree);918 BSL_LIST_FREE(list, EmptyFree);
@@ -926,6 +940,7 @@ void SDV_BSL_LIST_SET_MAX_FUNC_TC001(void)
926 ASSERT_TRUE(BSL_LIST_GetMaxQsortCount() == 100001);940 ASSERT_TRUE(BSL_LIST_GetMaxQsortCount() == 100001);
927 ASSERT_TRUE(BSL_LIST_SetMaxElements((1 << 16)) == BSL_SUCCESS);941 ASSERT_TRUE(BSL_LIST_SetMaxElements((1 << 16)) == BSL_SUCCESS);
928 ASSERT_TRUE(BSL_LIST_GetMaxElements() == (1 << 16));942 ASSERT_TRUE(BSL_LIST_GetMaxElements() == (1 << 16));
943+ ASSERT_TRUE(TestIsErrStackEmpty());
929EXIT:944EXIT:
930 return;945 return;
931}946}
@@ -1028,6 +1043,7 @@ void SDV_BSL_LIST_DELETE_FUNC_TC001(void)
1028 ASSERT_TRUE(BSL_LIST_AddElement(testList, "cccc", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);1043 ASSERT_TRUE(BSL_LIST_AddElement(testList, "cccc", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
1029 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 1);1044 ASSERT_TRUE(BSL_LIST_COUNT(testList) == 1);
1030 BSL_LIST_DeleteCurrent(testList, UserDataFree);1045 BSL_LIST_DeleteCurrent(testList, UserDataFree);
1046+ ASSERT_TRUE(TestIsErrStackEmpty());
1031EXIT:1047EXIT:
1032 BSL_SAL_FREE(testList);1048 BSL_SAL_FREE(testList);
1033}1049}
Mtestcode/sdv/testcase/bsl/log/test_suite_sdv_log.c+3-0
@@ -239,8 +239,10 @@ void SDV_BSL_REG_BIN_LOG_FUNC_TC001(void)
239 239 
240 func.fixLenFunc = BinLogFixLenFunc;240 func.fixLenFunc = BinLogFixLenFunc;
241 func.varLenFunc = BinLogVarLenFunc;241 func.varLenFunc = BinLogVarLenFunc;
242+ TestErrClear();
242 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);243 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
243 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);244 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
245+ ASSERT_TRUE(TestIsErrStackEmpty());
244EXIT:246EXIT:
245 return;247 return;
246}248}
@@ -442,6 +444,7 @@ void SDV_BSL_BIN_LOG_FUNC_TC001(void)
442 444 
443 BSL_LOG_BINLOG_VARLEN(BINLOG_ID05003, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,445 BSL_LOG_BINLOG_VARLEN(BINLOG_ID05003, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
444 "this is test msg: %s", "hello world");446 "this is test msg: %s", "hello world");
447+ ASSERT_TRUE(TestIsErrStackEmpty());
445 448 
446EXIT:449EXIT:
447 fclose(g_LogOutput); // flush and close450 fclose(g_LogOutput); // flush and close
Mtestcode/sdv/testcase/bsl/obj/test_suite_sdv_obj.c+5-0
@@ -140,11 +140,13 @@ void SDV_BSL_OBJ_CREATE_SIGN_ID_TC002(void)
140 BSL_OBJ_FreeSignHashTable();140 BSL_OBJ_FreeSignHashTable();
141 ASSERT_TRUE(g_signHashTable == NULL);141 ASSERT_TRUE(g_signHashTable == NULL);
142 (void)BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_RUN_ONCE_CB_FUNC, PthreadRunOnce);142 (void)BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_RUN_ONCE_CB_FUNC, PthreadRunOnce);
143+ TestErrClear();
143 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);144 ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
144 ASSERT_TRUE(g_signHashTable != NULL);145 ASSERT_TRUE(g_signHashTable != NULL);
145 ASSERT_EQ(BSL_HASH_Size(g_signHashTable), 1);146 ASSERT_EQ(BSL_HASH_Size(g_signHashTable), 1);
146 147 
147 BSL_OBJ_FreeSignHashTable();148 BSL_OBJ_FreeSignHashTable();
149+ ASSERT_TRUE(TestIsErrStackEmpty());
148EXIT:150EXIT:
149 return;151 return;
150#endif152#endif
@@ -190,6 +192,7 @@ void SDV_BSL_OBJ_CREATE_TC001()
190 ASSERT_EQ(strcmp(testOidName, retrievedName), 0);192 ASSERT_EQ(strcmp(testOidName, retrievedName), 0);
191 193 
192 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);194 ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
195+ ASSERT_TRUE(TestIsErrStackEmpty());
193 196 
194 ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);197 ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);
195 198 
@@ -266,6 +269,7 @@ void SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()
266 ASSERT_EQ(strcmp(testOidName2, retrievedName2), 0);269 ASSERT_EQ(strcmp(testOidName2, retrievedName2), 0);
267 270 
268 BSL_OBJ_FreeHashTable();271 BSL_OBJ_FreeHashTable();
272+ ASSERT_TRUE(TestIsErrStackEmpty());
269EXIT:273EXIT:
270 return;274 return;
271#endif275#endif
@@ -292,6 +296,7 @@ void SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001(Hex *str, char *expect)
292 ASSERT_TRUE(hexOid != NULL);296 ASSERT_TRUE(hexOid != NULL);
293 ASSERT_EQ(outLen, str->len);297 ASSERT_EQ(outLen, str->len);
294 ASSERT_COMPARE("test obj", hexOid, outLen, str->x, str->len);298 ASSERT_COMPARE("test obj", hexOid, outLen, str->x, str->len);
299+ ASSERT_TRUE(TestIsErrStackEmpty());
295 300 
296EXIT:301EXIT:
297 if (oid != NULL) {302 if (oid != NULL) {
Mtestcode/sdv/testcase/bsl/params/test_suite_sdv_params.c+5-0
@@ -38,12 +38,14 @@ void SDV_BSL_BSL_PARAM_InitValue_API_TC001()
38 ASSERT_EQ(BSL_PARAM_InitValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);38 ASSERT_EQ(BSL_PARAM_InitValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);
39 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);39 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);
40 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, 100, &val, sizeof(val)), BSL_PARAMS_INVALID_TYPE);40 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, 100, &val, sizeof(val)), BSL_PARAMS_INVALID_TYPE);
41+ TestErrClear();
41 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);42 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
42 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);43 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
43 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);44 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
44 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);45 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);
45 valPtr = NULL;46 valPtr = NULL;
46 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);47 ASSERT_EQ(BSL_PARAM_InitValue(&param, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
48+ ASSERT_TRUE(TestIsErrStackEmpty());
47EXIT:49EXIT:
48 return;50 return;
49}51}
@@ -133,6 +135,7 @@ void SDV_BSL_BSL_PARAM_SetValue_API_TC002()
133 ASSERT_EQ(BSL_PARAM_SetValue(&param[2], 1, BSL_PARAM_TYPE_UINT32, &val3, sizeof(val3)), BSL_SUCCESS);135 ASSERT_EQ(BSL_PARAM_SetValue(&param[2], 1, BSL_PARAM_TYPE_UINT32, &val3, sizeof(val3)), BSL_SUCCESS);
134 ASSERT_EQ(val3, tmp3);136 ASSERT_EQ(val3, tmp3);
135 ASSERT_EQ(BSL_PARAM_SetValue(&param[3], 1, BSL_PARAM_TYPE_OCTETS, &buffer1, buffer1Len), BSL_INVALID_ARG);137 ASSERT_EQ(BSL_PARAM_SetValue(&param[3], 1, BSL_PARAM_TYPE_OCTETS, &buffer1, buffer1Len), BSL_INVALID_ARG);
138+ TestErrClear();
136 ASSERT_EQ(BSL_PARAM_SetValue(&param[3], 1, BSL_PARAM_TYPE_OCTETS, &buffer1, buffer1Len - 5), BSL_SUCCESS);139 ASSERT_EQ(BSL_PARAM_SetValue(&param[3], 1, BSL_PARAM_TYPE_OCTETS, &buffer1, buffer1Len - 5), BSL_SUCCESS);
137 ASSERT_COMPARE("compare value", tmpBuffer1, param[3].useLen, buffer1, buffer1Len - 5);140 ASSERT_COMPARE("compare value", tmpBuffer1, param[3].useLen, buffer1, buffer1Len - 5);
138 tmpBuffer1[0] = 2;141 tmpBuffer1[0] = 2;
@@ -151,6 +154,7 @@ void SDV_BSL_BSL_PARAM_SetValue_API_TC002()
151 ASSERT_EQ(BSL_PARAM_SetValue(&param[7], 1, BSL_PARAM_TYPE_CTX_PTR, ptr, 8), BSL_SUCCESS);154 ASSERT_EQ(BSL_PARAM_SetValue(&param[7], 1, BSL_PARAM_TYPE_CTX_PTR, ptr, 8), BSL_SUCCESS);
152 ASSERT_EQ(param[7].value, ptr);155 ASSERT_EQ(param[7].value, ptr);
153 ASSERT_EQ(param[7].useLen, 8);156 ASSERT_EQ(param[7].useLen, 8);
157+ ASSERT_TRUE(TestIsErrStackEmpty());
154EXIT:158EXIT:
155 return;159 return;
156}160}
@@ -176,6 +180,7 @@ void SDV_BSL_BSL_PARAM_FindParam_API_TC001()
176 ASSERT_EQ(temp, &param[1]);180 ASSERT_EQ(temp, &param[1]);
177 temp = BSL_PARAM_FindParam(param, 5);181 temp = BSL_PARAM_FindParam(param, 5);
178 ASSERT_EQ(temp, NULL);182 ASSERT_EQ(temp, NULL);
183+ ASSERT_TRUE(TestIsErrStackEmpty());
179 184 
180EXIT:185EXIT:
181 return;186 return;
Mtestcode/sdv/testcase/bsl/params/test_suite_sdv_params_maker.c+9-0
@@ -49,12 +49,14 @@ void SDV_BSL_BSL_PARAM_MAKER_Push_Value_API_TC001()
49 49 
50 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(NULL, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_NULL_INPUT);50 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(NULL, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_NULL_INPUT);
51 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_NULL_INPUT);51 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_NULL_INPUT);
52+ TestErrClear();
52 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);53 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
53 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);54 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
54 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);55 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
55 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_CTX_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);56 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_CTX_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
56 valPtr = NULL;57 valPtr = NULL;
57 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);58 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
59+ ASSERT_TRUE(TestIsErrStackEmpty());
58EXIT:60EXIT:
59 if (maker) {61 if (maker) {
60 BSL_PARAM_MAKER_Free(maker);62 BSL_PARAM_MAKER_Free(maker);
@@ -101,6 +103,7 @@ void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC001()
101 temp = BSL_PARAM_FindParam(params, key++);103 temp = BSL_PARAM_FindParam(params, key++);
102 ASSERT_EQ(temp->value, (&params[index++])->value);104 ASSERT_EQ(temp->value, (&params[index++])->value);
103 ASSERT_EQ(*((uint16_t *)temp->value), u16);105 ASSERT_EQ(*((uint16_t *)temp->value), u16);
106+ ASSERT_TRUE(TestIsErrStackEmpty());
104EXIT:107EXIT:
105 if (maker) {108 if (maker) {
106 BSL_PARAM_MAKER_Free(maker);109 BSL_PARAM_MAKER_Free(maker);
@@ -160,6 +163,7 @@ void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC002()
160 ASSERT_EQ(temp->value, params->value);163 ASSERT_EQ(temp->value, params->value);
161 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str) - 2) == 0);164 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str) - 2) == 0);
162 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);165 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);
166+ ASSERT_TRUE(TestIsErrStackEmpty());
163 167 
164EXIT:168EXIT:
165 if (maker) {169 if (maker) {
@@ -255,6 +259,7 @@ void SDV_HITLS_PARAM_001()
255 temp = BSL_PARAM_FindParam(params, key++);259 temp = BSL_PARAM_FindParam(params, key++);
256 ASSERT_EQ(temp->value, (&params[index++])->value);260 ASSERT_EQ(temp->value, (&params[index++])->value);
257 ASSERT_EQ(*((uint32_t *)temp->value), u32);261 ASSERT_EQ(*((uint32_t *)temp->value), u32);
262+ ASSERT_TRUE(TestIsErrStackEmpty());
258EXIT:263EXIT:
259 if (maker) {264 if (maker) {
260 BSL_PARAM_MAKER_Free(maker);265 BSL_PARAM_MAKER_Free(maker);
@@ -300,6 +305,7 @@ void SDV_HITLS_PARAM_002()
300 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT8, &val_8, sizeof(val_8)), BSL_SUCCESS);305 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT8, &val_8, sizeof(val_8)), BSL_SUCCESS);
301 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);306 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
302 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_32, sizeof(val_32)), BSL_SUCCESS);307 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_32, sizeof(val_32)), BSL_SUCCESS);
308+ ASSERT_TRUE(TestIsErrStackEmpty());
303 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_8, sizeof(val_8)), BSL_INVALID_ARG);309 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_8, sizeof(val_8)), BSL_INVALID_ARG);
304 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_8, sizeof(uint16_t)), BSL_INVALID_ARG);310 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &val_8, sizeof(uint16_t)), BSL_INVALID_ARG);
305 311 
@@ -368,6 +374,7 @@ void SDV_HITLS_PARAM_003()
368 temp = BSL_PARAM_FindParam(params, key);374 temp = BSL_PARAM_FindParam(params, key);
369 ASSERT_EQ(temp->value, params->value);375 ASSERT_EQ(temp->value, params->value);
370 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof("hello")) == 0);376 ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof("hello")) == 0);
377+ ASSERT_TRUE(TestIsErrStackEmpty());
371 378 
372EXIT:379EXIT:
373 if (maker) {380 if (maker) {
@@ -404,6 +411,7 @@ void SDV_HITLS_PARAM_004()
404 BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();411 BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
405 412
406 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof("hello world!!!")), BSL_SUCCESS);413 ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof("hello world!!!")), BSL_SUCCESS);
414+ ASSERT_TRUE(TestIsErrStackEmpty());
407EXIT:415EXIT:
408 if (maker) {416 if (maker) {
409 BSL_PARAM_MAKER_Free(maker);417 BSL_PARAM_MAKER_Free(maker);
@@ -457,6 +465,7 @@ void SDV_HITLS_PARAM_005()
457 465 
458 ASSERT_EQ(*((int32_t *)(&params[0])->value), int32_0);466 ASSERT_EQ(*((int32_t *)(&params[0])->value), int32_0);
459 ASSERT_EQ(*((int32_t *)(&params[1])->value), int32_1);467 ASSERT_EQ(*((int32_t *)(&params[1])->value), int32_1);
468+ ASSERT_TRUE(TestIsErrStackEmpty());
460 469 
461EXIT:470EXIT:
462 if (maker) {471 if (maker) {
Mtestcode/sdv/testcase/bsl/pem/test_suite_sdv_pem.c+2-0
@@ -32,6 +32,7 @@ void SDV_BSL_PEM_ISPEM_FUNC_TC001(char *data, int expflag)
32 uint32_t encodeLen = strlen(data);32 uint32_t encodeLen = strlen(data);
33 bool isPem = BSL_PEM_IsPemFormat(encode, encodeLen);33 bool isPem = BSL_PEM_IsPemFormat(encode, encodeLen);
34 ASSERT_TRUE(isPem == (bool)expflag);34 ASSERT_TRUE(isPem == (bool)expflag);
35+ ASSERT_TRUE(TestIsErrStackEmpty());
35EXIT:36EXIT:
36 return;37 return;
37}38}
@@ -87,6 +88,7 @@ void SDV_BSL_PEM_PARSE_FUNC_TC002(void)
87 ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);88 ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
88 BSL_SAL_Free(asn1Encode);89 BSL_SAL_Free(asn1Encode);
89 ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);90 ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
91+ ASSERT_TRUE(TestIsErrStackEmpty());
90EXIT:92EXIT:
91 BSL_SAL_Free(asn1Encode);93 BSL_SAL_Free(asn1Encode);
92 return;94 return;
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal.c+11-0
@@ -178,6 +178,7 @@ void SDV_BSL_SAL_REGMEM_API_TC001(void)
178 ASSERT_TRUE(ptr == NULL);178 ASSERT_TRUE(ptr == NULL);
179 179 
180 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);180 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
181+ TestErrClear();
181 182 
182 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, NULL) == BSL_SUCCESS);183 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, NULL) == BSL_SUCCESS);
183 184 
@@ -189,6 +190,7 @@ void SDV_BSL_SAL_REGMEM_API_TC001(void)
189 190 
190 BSL_SAL_FREE(ptr);191 BSL_SAL_FREE(ptr);
191 ASSERT_TRUE(ptr == NULL);192 ASSERT_TRUE(ptr == NULL);
193+ ASSERT_TRUE(TestIsErrStackEmpty());
192EXIT:194EXIT:
193 return;195 return;
194}196}
@@ -221,6 +223,7 @@ void SDV_BSL_SAL_REG_THREAD_API_TC001(void)
221 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);223 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
222 224 
223 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);225 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
226+ TestErrClear();
224 227 
225 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, pthreadRWLockNew) == BSL_SUCCESS);228 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, pthreadRWLockNew) == BSL_SUCCESS);
226 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, pthreadRWLockFree) == BSL_SUCCESS);229 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, pthreadRWLockFree) == BSL_SUCCESS);
@@ -228,6 +231,7 @@ void SDV_BSL_SAL_REG_THREAD_API_TC001(void)
228 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, pthreadRWLockWriteLock) == BSL_SUCCESS);231 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, pthreadRWLockWriteLock) == BSL_SUCCESS);
229 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, pthreadRWLockUnlock) == BSL_SUCCESS);232 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, pthreadRWLockUnlock) == BSL_SUCCESS);
230 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, pthreadGetId) == BSL_SUCCESS);233 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, pthreadGetId) == BSL_SUCCESS);
234+ TestErrClear();
231 235 
232 // Cannot create a lock handle because the pointer of the pointer is NULL.236 // Cannot create a lock handle because the pointer of the pointer is NULL.
233 ASSERT_TRUE(BSL_SAL_ThreadLockNew(NULL) == BSL_SAL_ERR_BAD_PARAM);237 ASSERT_TRUE(BSL_SAL_ThreadLockNew(NULL) == BSL_SAL_ERR_BAD_PARAM);
@@ -287,6 +291,7 @@ static int32_t MockGetPid(void)
287 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_PID_GET_ID_CB_FUNC, MockGetPid) == BSL_SUCCESS);291 ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_PID_GET_ID_CB_FUNC, MockGetPid) == BSL_SUCCESS);
288 pid = BSL_SAL_GetPid();292 pid = BSL_SAL_GetPid();
289 ASSERT_EQ(pid, -1);293 ASSERT_EQ(pid, -1);
294+ ASSERT_TRUE(TestIsErrStackEmpty());
290EXIT:295EXIT:
291#else296#else
292 SKIP_TEST();297 SKIP_TEST();
@@ -319,6 +324,7 @@ void SDV_BSL_SAL_MEM_API_TC001(void)
319 memset_s(obj, 100, 0x1, 100);324 memset_s(obj, 100, 0x1, 100);
320 325 
321 BSL_SAL_ClearFree(obj, 100);326 BSL_SAL_ClearFree(obj, 100);
327+ ASSERT_TRUE(TestIsErrStackEmpty());
322EXIT:328EXIT:
323 return;329 return;
324#endif330#endif
@@ -393,6 +399,7 @@ void SDV_BSL_SAL_DUMP_API_TC001(void)
393 ASSERT_TRUE(testPtr != NULL);399 ASSERT_TRUE(testPtr != NULL);
394 400 
395 ASSERT_TRUE(memcmp(testPtr, srcPtr, memLen) == 0);401 ASSERT_TRUE(memcmp(testPtr, srcPtr, memLen) == 0);
402+ ASSERT_TRUE(TestIsErrStackEmpty());
396EXIT:403EXIT:
397 BSL_SAL_FREE(srcPtr);404 BSL_SAL_FREE(srcPtr);
398 BSL_SAL_FREE(testPtr);405 BSL_SAL_FREE(testPtr);
@@ -477,6 +484,7 @@ void SDV_BSL_SAL_THREAD_CREATE_FUNC_TC001(void)
477 BSL_SAL_ThreadClose(thread);484 BSL_SAL_ThreadClose(thread);
478 BSL_SAL_ThreadClose(NULL);485 BSL_SAL_ThreadClose(NULL);
479 BSL_SAL_ThreadLockFree(lock);486 BSL_SAL_ThreadLockFree(lock);
487+ ASSERT_TRUE(TestIsErrStackEmpty());
480EXIT:488EXIT:
481 return;489 return;
482#endif490#endif
@@ -655,6 +663,7 @@ void SDV_BSL_SAL_CONDVAR_WAIT_FUNC_TC001(void)
655 ret = BSL_SAL_DeleteCondVar(g_condVar);663 ret = BSL_SAL_DeleteCondVar(g_condVar);
656 ASSERT_TRUE(ret == BSL_SUCCESS);664 ASSERT_TRUE(ret == BSL_SUCCESS);
657 pthread_mutex_destroy(&g_lock);665 pthread_mutex_destroy(&g_lock);
666+ ASSERT_TRUE(TestIsErrStackEmpty());
658EXIT:667EXIT:
659 return;668 return;
660#endif669#endif
@@ -742,6 +751,7 @@ void SDV_BSL_SAL_STR_FUNC_TC001(void)
742 ASSERT_TRUE(BSL_SAL_Strnlen(str1, strlen(str1)) == 7);751 ASSERT_TRUE(BSL_SAL_Strnlen(str1, strlen(str1)) == 7);
743 ASSERT_TRUE(BSL_SAL_Strnlen(str1, 100) == 7);752 ASSERT_TRUE(BSL_SAL_Strnlen(str1, 100) == 7);
744 ASSERT_TRUE(BSL_SAL_Strnlen(str1, 3) == 3);753 ASSERT_TRUE(BSL_SAL_Strnlen(str1, 3) == 3);
754+ ASSERT_TRUE(TestIsErrStackEmpty());
745EXIT:755EXIT:
746 return;756 return;
747#endif757#endif
@@ -853,6 +863,7 @@ void SDV_BSL_SAL_CALLBACK_CTRL_FUNC_TC001(void)
853#endif863#endif
854#ifdef HITLS_BSL_SAL_NET864#ifdef HITLS_BSL_SAL_NET
855 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_NET_WRITE_CB_FUNC, NULL), BSL_SUCCESS);865 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_NET_WRITE_CB_FUNC, NULL), BSL_SUCCESS);
866+ ASSERT_TRUE(TestIsErrStackEmpty());
856 ASSERT_EQ(BSL_SAL_Ioctlsocket(0, 0, NULL), BSL_SAL_ERR_NET_IOCTL);867 ASSERT_EQ(BSL_SAL_Ioctlsocket(0, 0, NULL), BSL_SAL_ERR_NET_IOCTL);
857#endif868#endif
858EXIT:869EXIT:
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_atomic.c+1-0
@@ -99,6 +99,7 @@ void SDV_BSL_SAL_ATOMIC_ADD_TC001(void)
99 pthread_join(pid2[i], NULL);99 pthread_join(pid2[i], NULL);
100 }100 }
101 ASSERT_EQ(g_threadStartNum, 0);101 ASSERT_EQ(g_threadStartNum, 0);
102+ ASSERT_TRUE(TestIsErrStackEmpty());
102 103 
103EXIT:104EXIT:
104 g_threadStartNum = 0;105 g_threadStartNum = 0;
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_dl.c+5-0
@@ -92,6 +92,7 @@ void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char
92 ret = BSL_SAL_LoadLib(test2, &handle2);92 ret = BSL_SAL_LoadLib(test2, &handle2);
93 ASSERT_EQ(ret, BSL_SUCCESS);93 ASSERT_EQ(ret, BSL_SUCCESS);
94 ASSERT_TRUE(handle2 != NULL);94 ASSERT_TRUE(handle2 != NULL);
95+ ASSERT_TRUE(TestIsErrStackEmpty());
95 96 
96 // Test BSL_SAL_LoadLib with invalid input97 // Test BSL_SAL_LoadLib with invalid input
97 ret = BSL_SAL_LoadLib(NULL, &handle1);98 ret = BSL_SAL_LoadLib(NULL, &handle1);
@@ -102,6 +103,7 @@ void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char
102 103 
103 ret = BSL_SAL_LoadLib("nonExistentLib", &nonExistentLib);104 ret = BSL_SAL_LoadLib("nonExistentLib", &nonExistentLib);
104 ASSERT_EQ(ret, BSL_SAL_ERR_DL_NOT_FOUND);105 ASSERT_EQ(ret, BSL_SAL_ERR_DL_NOT_FOUND);
106+ TestErrClear();
105 107 
106 // Test BSL_SAL_GetFuncAddress with valid input108 // Test BSL_SAL_GetFuncAddress with valid input
107 ret = BSL_SAL_GetFuncAddress(handle1, funcName, &func);109 ret = BSL_SAL_GetFuncAddress(handle1, funcName, &func);
@@ -111,6 +113,7 @@ void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char
111 // Test BSL_SAL_GetFuncAddress with provider lacking init function113 // Test BSL_SAL_GetFuncAddress with provider lacking init function
112 ret = BSL_SAL_LoadLib(testNoInit, &handleNoInit);114 ret = BSL_SAL_LoadLib(testNoInit, &handleNoInit);
113 ASSERT_EQ(ret, BSL_SUCCESS);115 ASSERT_EQ(ret, BSL_SUCCESS);
116+ ASSERT_TRUE(TestIsErrStackEmpty());
114 117
115 ret = BSL_SAL_GetFuncAddress(handleNoInit, funcName, &func);118 ret = BSL_SAL_GetFuncAddress(handleNoInit, funcName, &func);
116 ASSERT_EQ(ret, BSL_SAL_ERR_DL_NON_FUNCTION);119 ASSERT_EQ(ret, BSL_SAL_ERR_DL_NON_FUNCTION);
@@ -124,6 +127,7 @@ void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char
124#endif127#endif
125 ret = BSL_SAL_GetFuncAddress(handle1, funcName, NULL);128 ret = BSL_SAL_GetFuncAddress(handle1, funcName, NULL);
126 ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);129 ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
130+ TestErrClear();
127 131 
128 // Test BSL_SAL_UnLoadLib with valid input132 // Test BSL_SAL_UnLoadLib with valid input
129 ret = BSL_SAL_UnLoadLib(handle1);133 ret = BSL_SAL_UnLoadLib(handle1);
@@ -133,6 +137,7 @@ void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char
133 ret = BSL_SAL_UnLoadLib(handle2);137 ret = BSL_SAL_UnLoadLib(handle2);
134 ASSERT_EQ(ret, BSL_SUCCESS);138 ASSERT_EQ(ret, BSL_SUCCESS);
135 handle2 = NULL;139 handle2 = NULL;
140+ ASSERT_TRUE(TestIsErrStackEmpty());
136 141 
137 // Test BSL_SAL_UnLoadLib with invalid input142 // Test BSL_SAL_UnLoadLib with invalid input
138 ret = BSL_SAL_UnLoadLib(NULL);143 ret = BSL_SAL_UnLoadLib(NULL);
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_file.c+1-0
@@ -121,6 +121,7 @@ static void *TestFileLengthFunc(void *args)
121 121 
122 ASSERT_TRUE(len > 0); // The length of the existing file is greater than 0.122 ASSERT_TRUE(len > 0); // The length of the existing file is greater than 0.
123 ASSERT_EQ(ret, BSL_SUCCESS);123 ASSERT_EQ(ret, BSL_SUCCESS);
124+ ASSERT_TRUE(TestIsErrStackEmpty());
124 125 
125EXIT:126EXIT:
126 BSL_SAL_FileClose(stream);127 BSL_SAL_FileClose(stream);
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_socket.c+1-0
@@ -68,6 +68,7 @@ void SDV_BSL_SAL_SOCKET_FUNC_TC001(void)
68 ASSERT_TRUE(udp != -1);68 ASSERT_TRUE(udp != -1);
69 ASSERT_TRUE(BSL_SAL_SetSockopt(udp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);69 ASSERT_TRUE(BSL_SAL_SetSockopt(udp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);
70 ASSERT_TRUE(BSL_SAL_SockClose(udp) == 0);70 ASSERT_TRUE(BSL_SAL_SockClose(udp) == 0);
71+ ASSERT_TRUE(TestIsErrStackEmpty());
71EXIT:72EXIT:
72 return;73 return;
73}74}
Mtestcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_time.c+8-0
@@ -84,6 +84,7 @@ void SDV_BSL_TIME_FUNC_REGISTER_TC001(void)
84 BSL_SysTimeFuncUnReg();84 BSL_SysTimeFuncUnReg();
85 85 
86 ASSERT_NE(BSL_SAL_CurrentSysTimeGet(), 1);86 ASSERT_NE(BSL_SAL_CurrentSysTimeGet(), 1);
87+ ASSERT_TRUE(TestIsErrStackEmpty());
87EXIT:88EXIT:
88 return;89 return;
89}90}
@@ -257,6 +258,7 @@ void SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001(void)
257 258 
258 /* 2.Failed to convert the time. */259 /* 2.Failed to convert the time. */
259 ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) != BSL_SUCCESS);260 ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) != BSL_SUCCESS);
261+ TestErrClear();
260 262 
261 /* 3.Time conversion succeeded. */263 /* 3.Time conversion succeeded. */
262 dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;264 dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
@@ -266,6 +268,7 @@ void SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001(void)
266 dateTime.minute = 0;268 dateTime.minute = 0;
267 dateTime.second = 0;269 dateTime.second = 0;
268 ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) == (uint32_t)BSL_SUCCESS);270 ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) == (uint32_t)BSL_SUCCESS);
271+ ASSERT_TRUE(TestIsErrStackEmpty());
269EXIT:272EXIT:
270 return;273 return;
271}274}
@@ -326,6 +329,7 @@ void SDV_BSL_SAL_CONVERT_TIME_API_TC001(void)
326 ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);329 ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
327 ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);330 ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
328 TestBslSysTimeAndTmCompare(&dateTime, &tempTime);331 TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
332+ ASSERT_TRUE(TestIsErrStackEmpty());
329EXIT:333EXIT:
330 return;334 return;
331}335}
@@ -359,6 +363,7 @@ void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC001(void)
359 dateTime.year = 1970;363 dateTime.year = 1970;
360 ret = BSL_DateTimeCheck(&dateTime);364 ret = BSL_DateTimeCheck(&dateTime);
361 ASSERT_EQ(ret, true);365 ASSERT_EQ(ret, true);
366+ ASSERT_TRUE(TestIsErrStackEmpty());
362EXIT:367EXIT:
363 return;368 return;
364}369}
@@ -572,6 +577,7 @@ void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC004(void)
572 dateTime.millSec = 59;577 dateTime.millSec = 59;
573 ret = BSL_DateTimeCheck(&dateTime);578 ret = BSL_DateTimeCheck(&dateTime);
574 ASSERT_EQ(ret, true);579 ASSERT_EQ(ret, true);
580+ ASSERT_TRUE(TestIsErrStackEmpty());
575EXIT:581EXIT:
576 return;582 return;
577}583}
@@ -716,6 +722,7 @@ void SDV_BSL_TIME_ADD_DAY_SECOND_TC001(void)
716 722 
717 /* 4.Invalid parameter */723 /* 4.Invalid parameter */
718 ASSERT_EQ(BSL_DateTimeAddDaySecond(NULL, &base, 0, 0), BSL_INTERNAL_EXCEPTION);724 ASSERT_EQ(BSL_DateTimeAddDaySecond(NULL, &base, 0, 0), BSL_INTERNAL_EXCEPTION);
725+ ASSERT_TRUE(TestIsErrStackEmpty());
719 726 
720EXIT:727EXIT:
721 return;728 return;
@@ -747,6 +754,7 @@ void SDV_BSL_TIME_GET_NSEC_FUNC_TC001(void)
747 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_TIME_IN_NS, TestTimeGetNSec), BSL_SUCCESS);754 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_TIME_IN_NS, TestTimeGetNSec), BSL_SUCCESS);
748 ASSERT_EQ(BSL_SAL_TIME_GetNSec(), TestTimeGetNSec());755 ASSERT_EQ(BSL_SAL_TIME_GetNSec(), TestTimeGetNSec());
749 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_TIME_IN_NS, NULL), BSL_SUCCESS);756 ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_TIME_IN_NS, NULL), BSL_SUCCESS);
757+ ASSERT_TRUE(TestIsErrStackEmpty());
750EXIT:758EXIT:
751 return;759 return;
752}760}
Mtestcode/sdv/testcase/bsl/tlv/test_suite_sdv_tlv.c+1-0
@@ -54,6 +54,7 @@ void SDV_BSL_TLV_Find_API_TC001(void)
54 uint32_t length = 0;54 uint32_t length = 0;
55 ret = BSL_TLV_FindValuePos(type, data, encLen, &offset, &length);55 ret = BSL_TLV_FindValuePos(type, data, encLen, &offset, &length);
56 ASSERT_TRUE(ret == BSL_SUCCESS);56 ASSERT_TRUE(ret == BSL_SUCCESS);
57+ ASSERT_TRUE(TestIsErrStackEmpty());
57 58 
58 uint32_t invalidType = 0x0102;59 uint32_t invalidType = 0x0102;
59 ret = BSL_TLV_FindValuePos(invalidType, data, encLen, &offset, &length);60 ret = BSL_TLV_FindValuePos(invalidType, data, encLen, &offset, &length);
Mtestcode/sdv/testcase/bsl/uio/test_suite_sdv_uio.c+27-0
@@ -264,6 +264,7 @@ void SDV_BSL_UIO_NEW_API_TC001(void)
264 /* Set method to NULL */264 /* Set method to NULL */
265 BSL_UIO *uio = BSL_UIO_New(NULL);265 BSL_UIO *uio = BSL_UIO_New(NULL);
266 ASSERT_TRUE(uio == NULL);266 ASSERT_TRUE(uio == NULL);
267+ TestErrClear();
267#ifdef HITLS_BSL_UIO_TCP268#ifdef HITLS_BSL_UIO_TCP
268 /* Set transportType to tcp and construct the method structure. */269 /* Set transportType to tcp and construct the method structure. */
269 {270 {
@@ -292,6 +293,7 @@ void SDV_BSL_UIO_NEW_API_TC001(void)
292 BSL_UIO_Free(uio);293 BSL_UIO_Free(uio);
293 }294 }
294#endif295#endif
296+ASSERT_TRUE(TestIsErrStackEmpty());
295EXIT:297EXIT:
296 return;298 return;
297#else299#else
@@ -312,6 +314,7 @@ void SDV_BSL_UIO_NEW_API_TC002(void)
312 314 
313 BSL_UIO *uio = BSL_UIO_New(NULL);315 BSL_UIO *uio = BSL_UIO_New(NULL);
314 ASSERT_EQ(uio, NULL);316 ASSERT_EQ(uio, NULL);
317+ TestErrClear();
315 BSL_UIO_Method *ori = BSL_UIO_NewMethod();318 BSL_UIO_Method *ori = BSL_UIO_NewMethod();
316 ASSERT_NE(ori, NULL);319 ASSERT_NE(ori, NULL);
317 int32_t customType = BSL_UIO_EXTEND + 3;320 int32_t customType = BSL_UIO_EXTEND + 3;
@@ -324,6 +327,7 @@ void SDV_BSL_UIO_NEW_API_TC002(void)
324 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);327 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);
325 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);328 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);
326 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);329 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);
330+ ASSERT_TRUE(TestIsErrStackEmpty());
327 331 
328 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, NULL), BSL_NULL_INPUT);332 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, NULL), BSL_NULL_INPUT);
329 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB + 1, BslUioGets), BSL_INVALID_ARG);333 ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB + 1, BslUioGets), BSL_INVALID_ARG);
@@ -394,6 +398,7 @@ void SDV_BSL_UIO_NEW_FUNC_TC001(void)
394 398 
395 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);399 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);
396 ASSERT_EQ(index, 0);400 ASSERT_EQ(index, 0);
401+ ASSERT_TRUE(TestIsErrStackEmpty());
397 402 
398EXIT:403EXIT:
399 BSL_UIO_Free(uio);404 BSL_UIO_Free(uio);
@@ -450,6 +455,7 @@ void SDV_BSL_UIO_INIT_FUNC_TC001(int uioType)
450 455 
451 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd), &getFd), BSL_SUCCESS);456 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd), &getFd), BSL_SUCCESS);
452 ASSERT_EQ(getFd, fd);457 ASSERT_EQ(getFd, fd);
458+ ASSERT_TRUE(TestIsErrStackEmpty());
453 459 
454EXIT:460EXIT:
455 BSL_UIO_Free(uio);461 BSL_UIO_Free(uio);
@@ -488,6 +494,7 @@ void SDV_BSL_UIO_INIT_FUNC_TC002(int uioType)
488 ASSERT_TRUE(uio != NULL);494 ASSERT_TRUE(uio != NULL);
489 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);495 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
490 ASSERT_EQ(init, 1);496 ASSERT_EQ(init, 1);
497+ ASSERT_TRUE(TestIsErrStackEmpty());
491 498 
492EXIT:499EXIT:
493 BSL_UIO_Free(uio);500 BSL_UIO_Free(uio);
@@ -550,6 +557,7 @@ void SDV_BSL_UIO_SETUSERDATA_API_TC001(void)
550 557 
551 ret = BSL_UIO_SetUserData(uio, userData2);558 ret = BSL_UIO_SetUserData(uio, userData2);
552 ASSERT_TRUE(ret == BSL_SUCCESS);559 ASSERT_TRUE(ret == BSL_SUCCESS);
560+ ASSERT_TRUE(TestIsErrStackEmpty());
553 561 
554EXIT:562EXIT:
555 BSL_UIO_Free(uio);563 BSL_UIO_Free(uio);
@@ -590,6 +598,7 @@ void SDV_BSL_UIO_GETUSERDATA_API_TC001(void)
590 598 
591 data = BSL_UIO_GetUserData(uio);599 data = BSL_UIO_GetUserData(uio);
592 ASSERT_TRUE(data == userData);600 ASSERT_TRUE(data == userData);
601+ ASSERT_TRUE(TestIsErrStackEmpty());
593EXIT:602EXIT:
594 BSL_UIO_Free(uio);603 BSL_UIO_Free(uio);
595}604}
@@ -627,6 +636,7 @@ void SDV_BSL_UIO_FLAGS_FUNC_TC001(int uioType)
627 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_RWS), BSL_SUCCESS);636 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_RWS), BSL_SUCCESS);
628 // 0000 1000637 // 0000 1000
629 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY), BSL_SUCCESS);638 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY), BSL_SUCCESS);
639+ ASSERT_TRUE(TestIsErrStackEmpty());
630 // 0001 0000640 // 0001 0000
631 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_MEM_READ_ONLY), BSL_INVALID_ARG);641 ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_MEM_READ_ONLY), BSL_INVALID_ARG);
632 // 0010 0000642 // 0010 0000
@@ -687,6 +697,7 @@ void SDV_BSL_UIO_FLAGS_FUNC_TC002(void)
687 697 
688 ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &out) == BSL_SUCCESS);698 ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &out) == BSL_SUCCESS);
689 ASSERT_TRUE(out == BSL_UIO_FLAGS_SHOULD_RETRY);699 ASSERT_TRUE(out == BSL_UIO_FLAGS_SHOULD_RETRY);
700+ ASSERT_TRUE(TestIsErrStackEmpty());
690EXIT:701EXIT:
691 BSL_UIO_Free(uio);702 BSL_UIO_Free(uio);
692}703}
@@ -715,12 +726,14 @@ void SDV_BSL_UIO_UPREF_API_TC001(void)
715 /* The test UIO is empty. */726 /* The test UIO is empty. */
716 int32_t ret = BSL_UIO_UpRef(NULL);727 int32_t ret = BSL_UIO_UpRef(NULL);
717 ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);728 ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
729+ TestErrClear();
718 730 
719 uio = BSL_UIO_New(BSL_UIO_SctpMethod());731 uio = BSL_UIO_New(BSL_UIO_SctpMethod());
720 ASSERT_TRUE(uio != NULL);732 ASSERT_TRUE(uio != NULL);
721 733 
722 ret = BSL_UIO_UpRef(uio);734 ret = BSL_UIO_UpRef(uio);
723 ASSERT_TRUE(ret == BSL_SUCCESS);735 ASSERT_TRUE(ret == BSL_SUCCESS);
736+ ASSERT_TRUE(TestIsErrStackEmpty());
724 737 
725EXIT:738EXIT:
726 BSL_UIO_Free(uio);739 BSL_UIO_Free(uio);
@@ -870,6 +883,7 @@ void SDV_BSL_UIO_SET_USERDATA_FREE_TC001(void)
870 int32_t ret = BSL_UIO_SetUserData(uio, userData);883 int32_t ret = BSL_UIO_SetUserData(uio, userData);
871 ASSERT_TRUE(ret == BSL_SUCCESS);884 ASSERT_TRUE(ret == BSL_SUCCESS);
872 ASSERT_TRUE(uio->userData != NULL);885 ASSERT_TRUE(uio->userData != NULL);
886+ ASSERT_TRUE(TestIsErrStackEmpty());
873 887 
874 ret = BSL_UIO_SetUserDataFreeFunc(NULL, BSL_SAL_Free);888 ret = BSL_UIO_SetUserDataFreeFunc(NULL, BSL_SAL_Free);
875 ASSERT_TRUE(ret == BSL_NULL_INPUT);889 ASSERT_TRUE(ret == BSL_NULL_INPUT);
@@ -959,6 +973,7 @@ void SDV_BSL_UIO_GET_READANDWRITE_NUM_TC001(void)
959 ASSERT_TRUE(BSL_UIO_Read(uio, readBuf, dataLen, &readLen) == BSL_SUCCESS);973 ASSERT_TRUE(BSL_UIO_Read(uio, readBuf, dataLen, &readLen) == BSL_SUCCESS);
960 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_READ_NUM, (int32_t)sizeof(readNum), &readNum), BSL_SUCCESS);974 ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_READ_NUM, (int32_t)sizeof(readNum), &readNum), BSL_SUCCESS);
961 ASSERT_EQ(readNum, readLen);975 ASSERT_EQ(readNum, readLen);
976+ ASSERT_TRUE(TestIsErrStackEmpty());
962EXIT:977EXIT:
963 BSL_UIO_Free(uio);978 BSL_UIO_Free(uio);
964#else979#else
@@ -994,6 +1009,7 @@ void SDV_BSL_UIO_SET_FD_TC001(void)
994 int32_t fd1 = -1;1009 int32_t fd1 = -1;
995 ASSERT_TRUE(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd1), &fd1) == BSL_SUCCESS);1010 ASSERT_TRUE(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd1), &fd1) == BSL_SUCCESS);
996 ASSERT_TRUE(fd == fd1);1011 ASSERT_TRUE(fd == fd1);
1012+ ASSERT_TRUE(TestIsErrStackEmpty());
997EXIT:1013EXIT:
998 BSL_UIO_Free(uio);1014 BSL_UIO_Free(uio);
999 remove(filename);1015 remove(filename);
@@ -1026,6 +1042,7 @@ void SDV_BSL_UIO_NEXT_TC001(void)
1026 ASSERT_TRUE(BSL_UIO_Append(tcp1, tcp2) == BSL_SUCCESS);1042 ASSERT_TRUE(BSL_UIO_Append(tcp1, tcp2) == BSL_SUCCESS);
1027 ASSERT_TRUE(BSL_UIO_Next(tcp1) == tcp2);1043 ASSERT_TRUE(BSL_UIO_Next(tcp1) == tcp2);
1028 ASSERT_TRUE(BSL_UIO_Next(tcp2) == NULL);1044 ASSERT_TRUE(BSL_UIO_Next(tcp2) == NULL);
1045+ ASSERT_TRUE(TestIsErrStackEmpty());
1029EXIT:1046EXIT:
1030 BSL_UIO_Free(tcp1);1047 BSL_UIO_Free(tcp1);
1031 BSL_UIO_Free(tcp2);1048 BSL_UIO_Free(tcp2);
@@ -1085,6 +1102,7 @@ void SDV_BSL_UIO_UDP_API_TC001(void)
1085 1102 
1086 ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, 0, NULL);1103 ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, 0, NULL);
1087 ASSERT_TRUE(ret == BSL_SUCCESS);1104 ASSERT_TRUE(ret == BSL_SUCCESS);
1105+ ASSERT_TRUE(TestIsErrStackEmpty());
1088EXIT:1106EXIT:
1089 BSL_UIO_Free(uio);1107 BSL_UIO_Free(uio);
1090}1108}
@@ -1135,6 +1153,7 @@ void SDV_BSL_UIO_SCTP_API_TC001(void)
1135 1153 
1136 ret = BSL_UIO_Ctrl(uio, BSL_UIO_SCTP_SET_APP_STREAM_ID, sizeof(uint16_t), &sendAppStreamId);1154 ret = BSL_UIO_Ctrl(uio, BSL_UIO_SCTP_SET_APP_STREAM_ID, sizeof(uint16_t), &sendAppStreamId);
1137 ASSERT_TRUE(ret == BSL_SUCCESS);1155 ASSERT_TRUE(ret == BSL_SUCCESS);
1156+ ASSERT_TRUE(TestIsErrStackEmpty());
1138EXIT:1157EXIT:
1139 BSL_UIO_Free(uio);1158 BSL_UIO_Free(uio);
1140#endif1159#endif
@@ -1177,6 +1196,7 @@ void SDV_BSL_UIO_BUFFER_RESET_TC001(void)
1177 ret = BSL_UIO_Write(buffer, buf, 2048, &writeLen);1196 ret = BSL_UIO_Write(buffer, buf, 2048, &writeLen);
1178 ASSERT_TRUE(ret == BSL_SUCCESS);1197 ASSERT_TRUE(ret == BSL_SUCCESS);
1179 ASSERT_TRUE(writeLen == 2048);1198 ASSERT_TRUE(writeLen == 2048);
1199+ ASSERT_TRUE(TestIsErrStackEmpty());
1180 1200 
1181 ret = BSL_UIO_Ctrl(buffer, BSL_UIO_RESET, 0, NULL);1201 ret = BSL_UIO_Ctrl(buffer, BSL_UIO_RESET, 0, NULL);
1182 ASSERT_TRUE(ret = BSL_UIO_FAIL);1202 ASSERT_TRUE(ret = BSL_UIO_FAIL);
@@ -1215,6 +1235,7 @@ void SDV_BSL_UIO_MEM_BASIC_TC001(void)
1215 ret = BSL_UIO_Ctrl(uio, BSL_UIO_PENDING, sizeof(uint64_t), &pendingLen);1235 ret = BSL_UIO_Ctrl(uio, BSL_UIO_PENDING, sizeof(uint64_t), &pendingLen);
1216 ASSERT_TRUE(ret == BSL_SUCCESS);1236 ASSERT_TRUE(ret == BSL_SUCCESS);
1217 ASSERT_TRUE(pendingLen == 0); // All data has been read1237 ASSERT_TRUE(pendingLen == 0); // All data has been read
1238+ ASSERT_TRUE(TestIsErrStackEmpty());
1218 1239 
1219EXIT:1240EXIT:
1220 BSL_UIO_Free(uio);1241 BSL_UIO_Free(uio);
@@ -1285,6 +1306,7 @@ void SDV_BSL_UIO_MEM_EOF_TC001(void)
1285 uint32_t flags = 0;1306 uint32_t flags = 0;
1286 BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &flags);1307 BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &flags);
1287 ASSERT_TRUE((flags & BSL_UIO_FLAGS_SHOULD_RETRY) != 0);1308 ASSERT_TRUE((flags & BSL_UIO_FLAGS_SHOULD_RETRY) != 0);
1309+ ASSERT_TRUE(TestIsErrStackEmpty());
1288 1310 
1289EXIT:1311EXIT:
1290 BSL_UIO_Free(uio);1312 BSL_UIO_Free(uio);
@@ -1307,6 +1329,7 @@ void SDV_BSL_UIO_MEM_PUTS_TC001(void)
1307 BSL_UIO_SetInit(uio, false);1329 BSL_UIO_SetInit(uio, false);
1308 ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_UIO_UNINITIALIZED);1330 ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_UIO_UNINITIALIZED);
1309 ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_UIO_UNINITIALIZED);1331 ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_UIO_UNINITIALIZED);
1332+ TestErrClear();
1310 1333 
1311 BSL_UIO_SetInit(uio, true);1334 BSL_UIO_SetInit(uio, true);
1312 ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_SUCCESS);1335 ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_SUCCESS);
@@ -1317,6 +1340,7 @@ void SDV_BSL_UIO_MEM_PUTS_TC001(void)
1317 ASSERT_EQ(len, strlen(str));1340 ASSERT_EQ(len, strlen(str));
1318 buf[len] = '\0';1341 buf[len] = '\0';
1319 ASSERT_EQ(strcmp(buf, str), 0);1342 ASSERT_EQ(strcmp(buf, str), 0);
1343+ ASSERT_TRUE(TestIsErrStackEmpty());
1320 1344 
1321EXIT:1345EXIT:
1322 BSL_UIO_Free(uio);1346 BSL_UIO_Free(uio);
@@ -1337,6 +1361,7 @@ void SDV_BSL_UIO_MEM_GETS_TC001(void)
1337 BSL_UIO_SetInit(uio, false);1361 BSL_UIO_SetInit(uio, false);
1338 ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_UIO_UNINITIALIZED);1362 ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_UIO_UNINITIALIZED);
1339 ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_UIO_UNINITIALIZED);1363 ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_UIO_UNINITIALIZED);
1364+ TestErrClear();
1340 1365 
1341 BSL_UIO_SetInit(uio, true);1366 BSL_UIO_SetInit(uio, true);
1342 ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_SUCCESS);1367 ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_SUCCESS);
@@ -1359,6 +1384,7 @@ void SDV_BSL_UIO_MEM_GETS_TC001(void)
1359 const char *str2 = "-----END PUBLIC KEY-----";1384 const char *str2 = "-----END PUBLIC KEY-----";
1360 ASSERT_EQ(len, strlen(str2));1385 ASSERT_EQ(len, strlen(str2));
1361 ASSERT_EQ(strcmp(buf, str2), 0);1386 ASSERT_EQ(strcmp(buf, str2), 0);
1387+ ASSERT_TRUE(TestIsErrStackEmpty());
1362 1388 
1363EXIT:1389EXIT:
1364 BSL_UIO_Free(uio);1390 BSL_UIO_Free(uio);
@@ -1378,6 +1404,7 @@ void SDV_BSL_UIO_APPEND_TC001(void)
1378 ASSERT_TRUE(uio != NULL);1404 ASSERT_TRUE(uio != NULL);
1379 ASSERT_TRUE(BSL_UIO_Append(uio, BSL_UIO_New(BSL_UIO_BufferMethod())) == BSL_SUCCESS);1405 ASSERT_TRUE(BSL_UIO_Append(uio, BSL_UIO_New(BSL_UIO_BufferMethod())) == BSL_SUCCESS);
1380 ASSERT_TRUE(HITLS_SetUio(ctx, uio) == BSL_SUCCESS);1406 ASSERT_TRUE(HITLS_SetUio(ctx, uio) == BSL_SUCCESS);
1407+ ASSERT_TRUE(TestIsErrStackEmpty());
1381 1408 
1382EXIT:1409EXIT:
1383 BSL_UIO_FreeChain(uio);1410 BSL_UIO_FreeChain(uio);
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes.c+12-0
@@ -508,6 +508,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001(int isProvider, int algId, Hex *key, Hex
508 ASSERT_EQ(totalLen, out->len);508 ASSERT_EQ(totalLen, out->len);
509 ASSERT_EQ(ret, CRYPT_SUCCESS);509 ASSERT_EQ(ret, CRYPT_SUCCESS);
510 ASSERT_EQ(memcmp(outTmp, out->x, out->len), 0);510 ASSERT_EQ(memcmp(outTmp, out->x, out->len), 0);
511+ ASSERT_TRUE(TestIsErrStackEmpty());
511 512 
512EXIT:513EXIT:
513 CRYPT_EAL_CipherDeinit(ctx);514 CRYPT_EAL_CipherDeinit(ctx);
@@ -559,6 +560,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *in, He
559 }560 }
560 561 
561 ASSERT_TRUE(memcmp(mctResult[MCT_INNER_LOOP - 1], out->x, out->len) == 0);562 ASSERT_TRUE(memcmp(mctResult[MCT_INNER_LOOP - 1], out->x, out->len) == 0);
563+ ASSERT_TRUE(TestIsErrStackEmpty());
562 564 
563EXIT:565EXIT:
564 CRYPT_EAL_CipherDeinit(ctx);566 CRYPT_EAL_CipherDeinit(ctx);
@@ -622,6 +624,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC003(int isProvider, int algId, Hex *key, Hex
622 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);624 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
623 ASSERT_TRUE(ret == CRYPT_SUCCESS);625 ASSERT_TRUE(ret == CRYPT_SUCCESS);
624 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);626 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
627+ ASSERT_TRUE(TestIsErrStackEmpty());
625 628 
626EXIT:629EXIT:
627 CRYPT_EAL_CipherDeinit(ctx);630 CRYPT_EAL_CipherDeinit(ctx);
@@ -806,6 +809,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC004(int algId, Hex *key, Hex *iv, Hex *in, in
806 ASSERT_TRUE(ret == CRYPT_SUCCESS);809 ASSERT_TRUE(ret == CRYPT_SUCCESS);
807 810 
808 ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);811 ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);
812+ ASSERT_TRUE(TestIsErrStackEmpty());
809 813 
810EXIT:814EXIT:
811 CRYPT_EAL_CipherDeinit(ctxEnc);815 CRYPT_EAL_CipherDeinit(ctxEnc);
@@ -864,6 +868,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC005(int isProvider, int algId, Hex *key, Hex
864 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);868 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
865 ASSERT_TRUE(ret == CRYPT_SUCCESS);869 ASSERT_TRUE(ret == CRYPT_SUCCESS);
866 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);870 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
871+ ASSERT_TRUE(TestIsErrStackEmpty());
867 872 
868EXIT:873EXIT:
869 CRYPT_EAL_CipherDeinit(ctx);874 CRYPT_EAL_CipherDeinit(ctx);
@@ -932,6 +937,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC006(int isProvider, int algId, int feed, Hex
932 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);937 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
933 ASSERT_TRUE(ret == CRYPT_SUCCESS);938 ASSERT_TRUE(ret == CRYPT_SUCCESS);
934 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);939 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
940+ ASSERT_TRUE(TestIsErrStackEmpty());
935 941 
936EXIT:942EXIT:
937 CRYPT_EAL_CipherDeinit(ctx);943 CRYPT_EAL_CipherDeinit(ctx);
@@ -973,6 +979,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC007(int algId, Hex *key, Hex *iv, Hex *in, He
973 ret = CRYPT_EAL_CipherFinal(ctx, in->x + totalLen, &len);979 ret = CRYPT_EAL_CipherFinal(ctx, in->x + totalLen, &len);
974 ASSERT_TRUE(ret == CRYPT_SUCCESS);980 ASSERT_TRUE(ret == CRYPT_SUCCESS);
975 ASSERT_TRUE(memcmp(in->x, out->x, out->len) == 0);981 ASSERT_TRUE(memcmp(in->x, out->x, out->len) == 0);
982+ ASSERT_TRUE(TestIsErrStackEmpty());
976 983 
977EXIT:984EXIT:
978 CRYPT_EAL_CipherDeinit(ctx);985 CRYPT_EAL_CipherDeinit(ctx);
@@ -1136,6 +1143,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC008(int isProvider, int algId, Hex *key, Hex
1136 1143 
1137 ASSERT_TRUE(totalLen == out->len);1144 ASSERT_TRUE(totalLen == out->len);
1138 ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);1145 ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);
1146+ ASSERT_TRUE(TestIsErrStackEmpty());
1139 1147 
1140EXIT:1148EXIT:
1141 CRYPT_EAL_CipherDeinit(ctxEnc);1149 CRYPT_EAL_CipherDeinit(ctxEnc);
@@ -1195,6 +1203,7 @@ void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC009(int isProvider, int algId, Hex *key, Hex
1195 1203 
1196 ASSERT_TRUE(totalLen == out->len);1204 ASSERT_TRUE(totalLen == out->len);
1197 ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);1205 ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);
1206+ ASSERT_TRUE(TestIsErrStackEmpty());
1198 1207 
1199EXIT:1208EXIT:
1200 CRYPT_EAL_CipherDeinit(ctxDec);1209 CRYPT_EAL_CipherDeinit(ctxDec);
@@ -1279,6 +1288,7 @@ void SDV_CRYPTO_EAL_AES_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv,
1279 ASSERT_TRUE(totalLen == out->len);1288 ASSERT_TRUE(totalLen == out->len);
1280 ASSERT_TRUE(ret == CRYPT_SUCCESS);1289 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1281 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);1290 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
1291+ ASSERT_TRUE(TestIsErrStackEmpty());
1282 1292 
1283EXIT:1293EXIT:
1284 CRYPT_EAL_CipherDeinit(ctx);1294 CRYPT_EAL_CipherDeinit(ctx);
@@ -1326,6 +1336,7 @@ void SDV_CRYPTO_EAL_AES_FUNC_TC005(int isProvider, int algId, Hex *key, Hex *iv,
1326 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);1336 ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
1327 ASSERT_TRUE(ret == CRYPT_SUCCESS);1337 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1328 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);1338 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
1339+ ASSERT_TRUE(TestIsErrStackEmpty());
1329 1340 
1330EXIT:1341EXIT:
1331 CRYPT_EAL_CipherDeinit(ctx);1342 CRYPT_EAL_CipherDeinit(ctx);
@@ -1444,6 +1455,7 @@ void SDV_CRYPTO_EAL_AES_FUNC_TC010(int algId, Hex *key, Hex *iv, Hex *pt)
1444 ASSERT_TRUE(x26 == value);1455 ASSERT_TRUE(x26 == value);
1445 ASSERT_TRUE(x27 == value);1456 ASSERT_TRUE(x27 == value);
1446 ASSERT_TRUE(x28 == value);1457 ASSERT_TRUE(x28 == value);
1458+ ASSERT_TRUE(TestIsErrStackEmpty());
1447EXIT:1459EXIT:
1448 CRYPT_EAL_CipherFreeCtx(ctx);1460 CRYPT_EAL_CipherFreeCtx(ctx);
1449#endif1461#endif
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes_ccm.c+5-0
@@ -393,6 +393,7 @@ void SDV_CRYPTO_AES_CCM_CTRL_API_TC004(int id, int keyLen)
393 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);393 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
394 394 
395 ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);395 ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
396+ ASSERT_TRUE(TestIsErrStackEmpty());
396 397 
397 tagLen = 2;398 tagLen = 2;
398 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==399 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==
@@ -464,6 +465,7 @@ void SDV_CRYPTO_AES_CCM_CTRL_API_TC005(int id, int keyLen)
464 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);465 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
465 ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 7, out, &outLen) == CRYPT_SUCCESS);466 ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 7, out, &outLen) == CRYPT_SUCCESS);
466 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);467 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
468+ ASSERT_TRUE(TestIsErrStackEmpty());
467 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, cmpTag, tagLen), CRYPT_EAL_ERR_STATE);469 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, cmpTag, tagLen), CRYPT_EAL_ERR_STATE);
468 470 
469 ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);471 ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
@@ -526,6 +528,7 @@ void SDV_CRYPTO_AES_CCM_CTRL_API_TC006(int id, int keyLen)
526 outLen = sizeof(out);528 outLen = sizeof(out);
527 dataLen = 30;529 dataLen = 30;
528 ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);530 ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
531+ ASSERT_TRUE(TestIsErrStackEmpty());
529 tagLen = 10;532 tagLen = 10;
530 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)), CRYPT_EAL_ERR_STATE);533 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)), CRYPT_EAL_ERR_STATE);
531 tagLen = 16;534 tagLen = 16;
@@ -599,6 +602,7 @@ void SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC001(int isProvider, int id, Hex *key, Hex
599 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);602 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
600 ASSERT_TRUE(memcmp(out, plaintext->x, outLen) == 0);603 ASSERT_TRUE(memcmp(out, plaintext->x, outLen) == 0);
601 ASSERT_TRUE(memcmp(tag, ciphertext->x + outLen, tagLen) == 0);604 ASSERT_TRUE(memcmp(tag, ciphertext->x + outLen, tagLen) == 0);
605+ ASSERT_TRUE(TestIsErrStackEmpty());
602EXIT:606EXIT:
603 CRYPT_EAL_CipherFreeCtx(ctx);607 CRYPT_EAL_CipherFreeCtx(ctx);
604}608}
@@ -801,6 +805,7 @@ void SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *aad
801 805 
802 ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);806 ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);
803 ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);807 ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);
808+ ASSERT_TRUE(TestIsErrStackEmpty());
804 809 
805EXIT:810EXIT:
806 CRYPT_EAL_CipherFreeCtx(ctx);811 CRYPT_EAL_CipherFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes_gcm.c+2-1
@@ -86,6 +86,7 @@ void SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC001(int isProvider, int algId, Hex *key, H
86 outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);86 outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);
87 ASSERT_TRUE(outTag != NULL);87 ASSERT_TRUE(outTag != NULL);
88 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);88 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
89+ ASSERT_TRUE(TestIsErrStackEmpty());
89 90 
90 if (pt->x != NULL) {91 if (pt->x != NULL) {
91 ASSERT_TRUE(memcmp(out, pt->x, pt->len) == 0);92 ASSERT_TRUE(memcmp(out, pt->x, pt->len) == 0);
@@ -155,7 +156,7 @@ void SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC002(int isProvider, int algId, Hex *key, H
155 outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);156 outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);
156 ASSERT_TRUE(outTag != NULL);157 ASSERT_TRUE(outTag != NULL);
157 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);158 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
158- 159+ ASSERT_TRUE(TestIsErrStackEmpty());
159 if (ct->x != NULL) {160 if (ct->x != NULL) {
160 ASSERT_TRUE(memcmp(out, ct->x, ct->len) == 0);161 ASSERT_TRUE(memcmp(out, ct->x, ct->len) == 0);
161 }162 }
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_cipher.c+3-0
@@ -90,6 +90,7 @@ void SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *a
90 ASSERT_COMPARE("dec result1", (uint8_t *)result, pt1->len, pt1->x, pt1->len);90 ASSERT_COMPARE("dec result1", (uint8_t *)result, pt1->len, pt1->x, pt1->len);
91 ASSERT_COMPARE("dec result2", (uint8_t *)result + pt1->len, pt2->len, pt2->x, pt2->len);91 ASSERT_COMPARE("dec result2", (uint8_t *)result + pt1->len, pt2->len, pt2->x, pt2->len);
92 ASSERT_COMPARE("dec tagResult", (uint8_t *)tagResult, tag->len, tag->x, tag->len);92 ASSERT_COMPARE("dec tagResult", (uint8_t *)tagResult, tag->len, tag->x, tag->len);
93+ ASSERT_TRUE(TestIsErrStackEmpty());
93EXIT:94EXIT:
94 CRYPT_EAL_CipherFreeCtx(ctx);95 CRYPT_EAL_CipherFreeCtx(ctx);
95}96}
@@ -161,6 +162,7 @@ void SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC002(int isProvider, int algId, Hex *key,
161 ASSERT_TRUE(memcmp(result + pt1->len, pt2->x, pt2->len) == 0);162 ASSERT_TRUE(memcmp(result + pt1->len, pt2->x, pt2->len) == 0);
162 ASSERT_TRUE(memcmp(result + pt1->len + pt2->len, pt3->x, pt3->len) == 0);163 ASSERT_TRUE(memcmp(result + pt1->len + pt2->len, pt3->x, pt3->len) == 0);
163 ASSERT_TRUE(memcmp(tagResult, tag->x, tag->len) == 0);164 ASSERT_TRUE(memcmp(tagResult, tag->x, tag->len) == 0);
165+ ASSERT_TRUE(TestIsErrStackEmpty());
164 166 
165EXIT:167EXIT:
166 CRYPT_EAL_CipherFreeCtx(ctx);168 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -281,6 +283,7 @@ void SDV_CRYPTO_EAL_CIPHER_FUNC_TC001(int padding, int algId, Hex *key, Hex *iv,
281 ret = CRYPT_EAL_CipherFinal(ctx, decData + totalLen, &tmplen);283 ret = CRYPT_EAL_CipherFinal(ctx, decData + totalLen, &tmplen);
282 ASSERT_EQ(ret, CRYPT_SUCCESS);284 ASSERT_EQ(ret, CRYPT_SUCCESS);
283 ASSERT_TRUE(memcmp(testData, decData, sizeof(testData)) == 0);285 ASSERT_TRUE(memcmp(testData, decData, sizeof(testData)) == 0);
286+ ASSERT_TRUE(TestIsErrStackEmpty());
284 }287 }
285EXIT:288EXIT:
286 CRYPT_EAL_CipherDeinit(ctx);289 CRYPT_EAL_CipherDeinit(ctx);
Mtestcode/sdv/testcase/crypto/bn/test_suite_sdv_bn.c+10-0
@@ -413,6 +413,7 @@ void SDV_CRYPTO_BN_RSHIFT_FUNC_TC001(int sign, Hex *hex, int n, int signRes, Hex
413 ASSERT_TRUE(q != NULL);413 ASSERT_TRUE(q != NULL);
414 ASSERT_EQ(BN_Rshift(q, a, n), CRYPT_SUCCESS); // r != a414 ASSERT_EQ(BN_Rshift(q, a, n), CRYPT_SUCCESS); // r != a
415 ASSERT_TRUE(BN_Cmp(r, res) == 0);415 ASSERT_TRUE(BN_Cmp(r, res) == 0);
416+ ASSERT_TRUE(TestIsErrStackEmpty());
416 417 
417EXIT:418EXIT:
418 BN_Destroy(a);419 BN_Destroy(a);
@@ -570,6 +571,7 @@ void SDV_CRYPTO_BN_MODINV_FUNC_TC002(int sign, Hex *hex, Hex *modulo, Hex *resul
570 ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);571 ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
571 ASSERT_TRUE(BN_ModInv(r, a, r, opt) == CRYPT_SUCCESS);572 ASSERT_TRUE(BN_ModInv(r, a, r, opt) == CRYPT_SUCCESS);
572 ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);573 ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
574+ ASSERT_TRUE(TestIsErrStackEmpty());
573 }575 }
574 576 
575EXIT:577EXIT:
@@ -839,6 +841,7 @@ void SDV_CRYPTO_BN_MODEXP_FUNC_TC001(int sign1, Hex *hex1, Hex *hex2, Hex *modul
839 ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);841 ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
840 ASSERT_TRUE(BN_ModExp(r, a, e, r, opt) == CRYPT_SUCCESS); // r == m842 ASSERT_TRUE(BN_ModExp(r, a, e, r, opt) == CRYPT_SUCCESS); // r == m
841 ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);843 ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
844+ ASSERT_TRUE(TestIsErrStackEmpty());
842 845 
843EXIT:846EXIT:
844 BN_Destroy(a);847 BN_Destroy(a);
@@ -981,6 +984,7 @@ void SDV_CRYPTO_BN_MOD_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *modulo,
981 ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);984 ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
982 ASSERT_EQ(BN_Mod(r, r, m, opt), CRYPT_SUCCESS);985 ASSERT_EQ(BN_Mod(r, r, m, opt), CRYPT_SUCCESS);
983 ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);986 ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
987+ ASSERT_TRUE(TestIsErrStackEmpty());
984EXIT:988EXIT:
985 BN_Destroy(a);989 BN_Destroy(a);
986 BN_Destroy(m);990 BN_Destroy(m);
@@ -1048,6 +1052,7 @@ void SDV_CRYPTO_BN_PRIME_CHECK_FUNC_TC001(Hex *hex, int isPrime)
1048 ret = BN_PrimeCheck(bn, 0, opt, NULL);1052 ret = BN_PrimeCheck(bn, 0, opt, NULL);
1049 if (isPrime != 0) {1053 if (isPrime != 0) {
1050 ASSERT_EQ(ret, CRYPT_SUCCESS);1054 ASSERT_EQ(ret, CRYPT_SUCCESS);
1055+ ASSERT_TRUE(TestIsErrStackEmpty());
1051 } else {1056 } else {
1052 ASSERT_EQ(ret, CRYPT_BN_NOR_CHECK_PRIME);1057 ASSERT_EQ(ret, CRYPT_BN_NOR_CHECK_PRIME);
1053 }1058 }
@@ -1207,6 +1212,7 @@ void SDV_CRYPTO_BN_SUB_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *hex2, in
1207 1212 
1208 ASSERT_EQ(BN_Sub(a, a, b), CRYPT_SUCCESS);1213 ASSERT_EQ(BN_Sub(a, a, b), CRYPT_SUCCESS);
1209 ASSERT_TRUE_AND_LOG("a == a", BN_Cmp(a, res) == 0);1214 ASSERT_TRUE_AND_LOG("a == a", BN_Cmp(a, res) == 0);
1215+ ASSERT_TRUE(TestIsErrStackEmpty());
1210 1216 
1211EXIT:1217EXIT:
1212 BN_Destroy(a);1218 BN_Destroy(a);
@@ -1489,6 +1495,7 @@ void SDV_CRYPTO_BN_SQR_FUNC_TC001(int sign1, Hex *hex1, Hex *result)
1489 ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);1495 ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
1490 ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);1496 ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);
1491 ASSERT_TRUE(BN_Cmp(r, res) == 0);1497 ASSERT_TRUE(BN_Cmp(r, res) == 0);
1498+ ASSERT_TRUE(TestIsErrStackEmpty());
1492 1499 
1493EXIT:1500EXIT:
1494 BN_Destroy(a);1501 BN_Destroy(a);
@@ -1697,6 +1704,7 @@ void SDV_CRYPTO_BN_U64_FUNC_TC001(int len)
1697 ASSERT_TRUE(BN_U64Array2Bn(a, input, len) == CRYPT_SUCCESS);1704 ASSERT_TRUE(BN_U64Array2Bn(a, input, len) == CRYPT_SUCCESS);
1698 ASSERT_TRUE(BN_Bn2U64Array(a, output, &outlen) == CRYPT_SUCCESS);1705 ASSERT_TRUE(BN_Bn2U64Array(a, output, &outlen) == CRYPT_SUCCESS);
1699 ASSERT_TRUE(memcmp(input, output, outlen * sizeof(uint64_t)) == 0);1706 ASSERT_TRUE(memcmp(input, output, outlen * sizeof(uint64_t)) == 0);
1707+ ASSERT_TRUE(TestIsErrStackEmpty());
1700EXIT:1708EXIT:
1701 BN_Destroy(a);1709 BN_Destroy(a);
1702 free(input);1710 free(input);
@@ -1732,6 +1740,7 @@ void SDV_CRYPTO_BN_UINT_FUNC_TC001(int len)
1732 ASSERT_TRUE(BN_Array2BN(a, input, len) == CRYPT_SUCCESS);1740 ASSERT_TRUE(BN_Array2BN(a, input, len) == CRYPT_SUCCESS);
1733 ASSERT_TRUE(BN_BN2Array(a, output, len) == CRYPT_SUCCESS);1741 ASSERT_TRUE(BN_BN2Array(a, output, len) == CRYPT_SUCCESS);
1734 ASSERT_TRUE(memcmp(input, output, len * sizeof(BN_UINT)) == 0);1742 ASSERT_TRUE(memcmp(input, output, len * sizeof(BN_UINT)) == 0);
1743+ ASSERT_TRUE(TestIsErrStackEmpty());
1735EXIT:1744EXIT:
1736 BN_Destroy(a);1745 BN_Destroy(a);
1737 free(input);1746 free(input);
@@ -1809,6 +1818,7 @@ void SDV_CRYPTO_BN_GCD_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *hex2, He
1809 ASSERT_EQ(BN_Copy(out, bn2), CRYPT_SUCCESS);1818 ASSERT_EQ(BN_Copy(out, bn2), CRYPT_SUCCESS);
1810 ASSERT_EQ(BN_Gcd(out, bn, out, opt), CRYPT_SUCCESS);1819 ASSERT_EQ(BN_Gcd(out, bn, out, opt), CRYPT_SUCCESS);
1811 ASSERT_TRUE_AND_LOG("r == b", BN_Cmp(out, res) == 0);1820 ASSERT_TRUE_AND_LOG("r == b", BN_Cmp(out, res) == 0);
1821+ ASSERT_TRUE(TestIsErrStackEmpty());
1812 1822 
1813EXIT:1823EXIT:
1814 BN_Destroy(bn);1824 BN_Destroy(bn);
Mtestcode/sdv/testcase/crypto/cbc_mac/test_suite_sdv_eal_mac_cbc_mac.c+2-0
@@ -486,6 +486,7 @@ void SDV_CRYPT_EAL_CBC_MAC_FUN_TC004(int algId, int padType, Hex *key, Hex *data
486 ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);486 ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);
487 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);487 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
488 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);488 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
489+ ASSERT_TRUE(TestIsErrStackEmpty());
489EXIT:490EXIT:
490 CRYPT_EAL_MacFreeCtx(ctx);491 CRYPT_EAL_MacFreeCtx(ctx);
491}492}
@@ -547,6 +548,7 @@ void SDV_CRYPT_EAL_CBC_MAC_FUN_TC006(int algId, int padType, Hex *key, Hex *data
547 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);548 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);
548 ASSERT_TRUE(macLen1 == macLen2);549 ASSERT_TRUE(macLen1 == macLen2);
549 ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);550 ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);
551+ ASSERT_TRUE(TestIsErrStackEmpty());
550 552 
551EXIT:553EXIT:
552 BSL_SAL_FREE(totalInData);554 BSL_SAL_FREE(totalInData);
Mtestcode/sdv/testcase/crypto/chacha-poly/test_suite_sdv_eal_chachapoly.c+10-0
@@ -676,6 +676,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC001(Hex *key, Hex *iv, Hex *aad,
676 ASSERT_TRUE(outLen == data->len);676 ASSERT_TRUE(outLen == data->len);
677 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);677 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
678 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);678 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
679+ ASSERT_TRUE(TestIsErrStackEmpty());
679 680 
680EXIT:681EXIT:
681 CRYPT_EAL_CipherFreeCtx(ctx);682 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -751,6 +752,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC002(Hex *key, Hex *iv, Hex *aad,
751 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);752 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
752 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);753 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
753 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);754 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
755+ ASSERT_TRUE(TestIsErrStackEmpty());
754 756 
755EXIT:757EXIT:
756 CRYPT_EAL_CipherFreeCtx(ctx);758 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -804,6 +806,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC003(Hex *key, Hex *iv, Hex *aad,
804 ASSERT_TRUE(outLen == cipher->len);806 ASSERT_TRUE(outLen == cipher->len);
805 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);807 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
806 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);808 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
809+ ASSERT_TRUE(TestIsErrStackEmpty());
807 810 
808EXIT:811EXIT:
809 CRYPT_EAL_CipherFreeCtx(ctx);812 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -858,6 +861,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC004(Hex *key, Hex *iv, Hex *aad,
858 ASSERT_TRUE(outLen == cipher->len);861 ASSERT_TRUE(outLen == cipher->len);
859 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);862 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
860 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);863 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
864+ ASSERT_TRUE(TestIsErrStackEmpty());
861 865 
862EXIT:866EXIT:
863 CRYPT_EAL_CipherFreeCtx(ctx);867 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -894,6 +898,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC005(Hex *key, Hex *iv, Hex *aad,
894 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);898 ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
895 899 
896 ASSERT_COMPARE("tag equal", outTag, tagLen, tag->x, tag->len);900 ASSERT_COMPARE("tag equal", outTag, tagLen, tag->x, tag->len);
901+ ASSERT_TRUE(TestIsErrStackEmpty());
897 902 
898EXIT:903EXIT:
899 CRYPT_EAL_CipherFreeCtx(ctx);904 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -940,6 +945,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC006(Hex *key, Hex *iv, Hex *aad,
940 ASSERT_TRUE(outLen == cipher->len);945 ASSERT_TRUE(outLen == cipher->len);
941 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);946 ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
942 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);947 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
948+ ASSERT_TRUE(TestIsErrStackEmpty());
943 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen), CRYPT_EAL_ERR_STATE);949 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen), CRYPT_EAL_ERR_STATE);
944 950 
945EXIT:951EXIT:
@@ -986,6 +992,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC007(Hex *key, Hex *iv, Hex *aad,
986 ASSERT_TRUE(bufLen == cipher->len);992 ASSERT_TRUE(bufLen == cipher->len);
987 ASSERT_TRUE(memcmp(buf, cipher->x, cipher->len) == 0);993 ASSERT_TRUE(memcmp(buf, cipher->x, cipher->len) == 0);
988 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);994 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
995+ ASSERT_TRUE(TestIsErrStackEmpty());
989 996 
990EXIT:997EXIT:
991 CRYPT_EAL_CipherFreeCtx(ctx);998 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1049,6 +1056,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC008(Hex *key, Hex *aad, Hex *data
1049 ASSERT_TRUE(outLen == data->len);1056 ASSERT_TRUE(outLen == data->len);
1050 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);1057 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
1051 ASSERT_TRUE(memcmp(outTag1, outTag2, tagLen) == 0);1058 ASSERT_TRUE(memcmp(outTag1, outTag2, tagLen) == 0);
1059+ ASSERT_TRUE(TestIsErrStackEmpty());
1052 1060 
1053EXIT:1061EXIT:
1054 CRYPT_EAL_CipherFreeCtx(ctx);1062 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1116,6 +1124,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC009(Hex *key, Hex *iv, Hex *aad,
1116 ASSERT_TRUE(outLen == data->len);1124 ASSERT_TRUE(outLen == data->len);
1117 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);1125 ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
1118 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) != 0);1126 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) != 0);
1127+ ASSERT_TRUE(TestIsErrStackEmpty());
1119 1128 
1120EXIT:1129EXIT:
1121 CRYPT_EAL_CipherFreeCtx(ctx);1130 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1204,6 +1213,7 @@ void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC010(Hex *key, Hex *iv, Hex *aad,
1204 ASSERT_TRUE(memcmp(out + pt1->len, pt2->x, pt2->len) == 0);1213 ASSERT_TRUE(memcmp(out + pt1->len, pt2->x, pt2->len) == 0);
1205 ASSERT_TRUE(memcmp(out + pt1->len + pt2->len, pt3->x, pt3->len) == 0);1214 ASSERT_TRUE(memcmp(out + pt1->len + pt2->len, pt3->x, pt3->len) == 0);
1206 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);1215 ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
1216+ ASSERT_TRUE(TestIsErrStackEmpty());
1207 1217 
1208EXIT:1218EXIT:
1209 CRYPT_EAL_CipherFreeCtx(ctx);1219 CRYPT_EAL_CipherFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/cmac/test_suite_sdv_eal_mac_cmac.c+2-0
@@ -743,6 +743,7 @@ void SDV_CRYPT_EAL_CMAC_FUN_TC004(int algId, Hex *key, Hex *data, Hex *vecMac)
743 ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);743 ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);
744 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);744 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
745 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);745 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
746+ ASSERT_TRUE(TestIsErrStackEmpty());
746EXIT:747EXIT:
747 CRYPT_EAL_MacFreeCtx(ctx);748 CRYPT_EAL_MacFreeCtx(ctx);
748}749}
@@ -801,6 +802,7 @@ void SDV_CRYPT_EAL_CMAC_FUN_TC006(int algId, Hex *key, Hex *data, int updateTime
801 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);802 ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);
802 ASSERT_TRUE(macLen1 == macLen2);803 ASSERT_TRUE(macLen1 == macLen2);
803 ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);804 ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);
805+ ASSERT_TRUE(TestIsErrStackEmpty());
804 806 
805EXIT:807EXIT:
806 BSL_SAL_FREE(totalInData);808 BSL_SAL_FREE(totalInData);
Mtestcode/sdv/testcase/crypto/curve25519/test_suite_sdv_eal_curve25519.c+8-0
@@ -640,6 +640,7 @@ void SDV_CRYPTO_ED25519_SIGN_FUNC_TC001(Hex *key, Hex *msg, Hex *sign, int isPro
640 640 
641 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);641 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);
642 ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);642 ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);
643+ ASSERT_TRUE(TestIsErrStackEmpty());
643 644 
644EXIT:645EXIT:
645 CRYPT_EAL_PkeyFreeCtx(ctx);646 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -671,6 +672,7 @@ void SDV_CRYPTO_ED25519_VERIFY_FUNC_TC001(Hex *key, Hex *msg, Hex *sign, int isP
671 ASSERT_TRUE(pkey != NULL);672 ASSERT_TRUE(pkey != NULL);
672 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);673 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
673 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);674 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
675+ ASSERT_TRUE(TestIsErrStackEmpty());
674EXIT:676EXIT:
675 CRYPT_EAL_PkeyFreeCtx(pkey);677 CRYPT_EAL_PkeyFreeCtx(pkey);
676}678}
@@ -727,6 +729,7 @@ void SDV_CRYPTO_ED25519_SIGN_VERIFY_FUNC_TC001(Hex *prvKey, Hex *pubKey, Hex *ms
727 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);729 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);
728 ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);730 ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);
729 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);731 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
732+ ASSERT_TRUE(TestIsErrStackEmpty());
730 733 
731EXIT:734EXIT:
732 CRYPT_EAL_PkeyFreeCtx(pkey);735 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -778,6 +781,7 @@ void SDV_CRYPTO_X25519_EXCH_FUNC_TC001(int isProvider)
778 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len), CRYPT_SUCCESS);781 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len), CRYPT_SUCCESS);
779 ASSERT_EQ(share1Len, share2Len);782 ASSERT_EQ(share1Len, share2Len);
780 ASSERT_EQ(memcmp(share1, share2, share1Len), 0);783 ASSERT_EQ(memcmp(share1, share2, share1Len), 0);
784+ ASSERT_TRUE(TestIsErrStackEmpty());
781 785 
782EXIT:786EXIT:
783 TestRandDeInit();787 TestRandDeInit();
@@ -844,6 +848,7 @@ void SDV_CRYPTO_X25519_EXCH_FUNC_TC002(Hex *pubkey, Hex *prvkey, Hex *share, int
844 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, shareKey, &shareLen), CRYPT_SUCCESS);848 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, shareKey, &shareLen), CRYPT_SUCCESS);
845 ASSERT_EQ(shareLen, share->len);849 ASSERT_EQ(shareLen, share->len);
846 ASSERT_EQ(memcmp(shareKey, share->x, shareLen), 0);850 ASSERT_EQ(memcmp(shareKey, share->x, shareLen), 0);
851+ ASSERT_TRUE(TestIsErrStackEmpty());
847 852 
848EXIT:853EXIT:
849 CRYPT_EAL_PkeyFreeCtx(pkey1);854 CRYPT_EAL_PkeyFreeCtx(pkey1);
@@ -889,9 +894,11 @@ void SDV_CRYPTO_CURVE25519_CMP_FUNC_TC001(int algId, Hex *pubKey, int isProvider
889 894 
890 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);895 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
891 ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_CURVE25519_NO_PUBKEY);896 ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_CURVE25519_NO_PUBKEY);
897+ (void)TestErrClear();
892 898 
893 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);899 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
894 ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);900 ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
901+ ASSERT_TRUE(TestIsErrStackEmpty());
895 902 
896EXIT:903EXIT:
897 CRYPT_EAL_PkeyFreeCtx(ctx1);904 CRYPT_EAL_PkeyFreeCtx(ctx1);
@@ -1217,6 +1224,7 @@ void SDV_CRYPTO_CURVE25519_Import_Export_FUNC_TC001(void)
1217 CRYPT_SUCCESS);1224 CRYPT_SUCCESS);
1218 ASSERT_EQ(CRYPT_CURVE25519_Verify(dstCurve25519Ctx, CRYPT_MD_SHA512, data, dataLen, signBuf, signBufLen),1225 ASSERT_EQ(CRYPT_CURVE25519_Verify(dstCurve25519Ctx, CRYPT_MD_SHA512, data, dataLen, signBuf, signBufLen),
1219 CRYPT_SUCCESS);1226 CRYPT_SUCCESS);
1227+ ASSERT_TRUE(TestIsErrStackEmpty());
1220EXIT:1228EXIT:
1221 CRYPT_CURVE25519_FreeCtx(srcCurve25519Ctx);1229 CRYPT_CURVE25519_FreeCtx(srcCurve25519Ctx);
1222 CRYPT_CURVE25519_FreeCtx(dstCurve25519Ctx);1230 CRYPT_CURVE25519_FreeCtx(dstCurve25519Ctx);
Mtestcode/sdv/testcase/crypto/dh/test_suite_sdv_eal_dh.c+12-0
@@ -147,6 +147,7 @@ void SDV_CRYPTO_DH_FUNC_TC001(
147 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);147 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);
148 ASSERT_TRUE(shareLen == share->len);148 ASSERT_TRUE(shareLen == share->len);
149 ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);149 ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);
150+ ASSERT_TRUE(TestIsErrStackEmpty());
150EXIT:151EXIT:
151 CRYPT_EAL_PkeyFreeCtx(pkey1);152 CRYPT_EAL_PkeyFreeCtx(pkey1);
152 CRYPT_EAL_PkeyFreeCtx(pkey2);153 CRYPT_EAL_PkeyFreeCtx(pkey2);
@@ -204,6 +205,7 @@ void SDV_CRYPTO_DH_FUNC_TC002(Hex *p, Hex *g, Hex *q, int isProvider)
204 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);205 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
205 ASSERT_TRUE(share1Len == share2Len);206 ASSERT_TRUE(share1Len == share2Len);
206 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);207 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
208+ ASSERT_TRUE(TestIsErrStackEmpty());
207EXIT:209EXIT:
208 CRYPT_RandRegist(NULL);210 CRYPT_RandRegist(NULL);
209 CRYPT_RandRegistEx(NULL);211 CRYPT_RandRegistEx(NULL);
@@ -255,6 +257,7 @@ void SDV_CRYPTO_DH_FUNC_TC003(int id, int isProvider)
255 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);257 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
256 ASSERT_TRUE(share1Len == share2Len);258 ASSERT_TRUE(share1Len == share2Len);
257 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);259 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
260+ ASSERT_TRUE(TestIsErrStackEmpty());
258EXIT:261EXIT:
259 CRYPT_RandRegist(NULL);262 CRYPT_RandRegist(NULL);
260 CRYPT_RandRegistEx(NULL);263 CRYPT_RandRegistEx(NULL);
@@ -311,6 +314,7 @@ void SDV_CRYPTO_DH_FUNC_TC004(Hex *p, Hex *g, Hex *q, int isProvider)
311 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);314 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
312 ASSERT_TRUE(share1Len == share2Len);315 ASSERT_TRUE(share1Len == share2Len);
313 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);316 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
317+ ASSERT_TRUE(TestIsErrStackEmpty());
314EXIT:318EXIT:
315 CRYPT_RandRegist(NULL);319 CRYPT_RandRegist(NULL);
316 CRYPT_RandRegistEx(NULL);320 CRYPT_RandRegistEx(NULL);
@@ -446,6 +450,7 @@ void SDV_CRYPTO_DH_FUNC_TC006(
446 cmpRet2 = memcmp(shareLocal, share->x, share->len);450 cmpRet2 = memcmp(shareLocal, share->x, share->len);
447 451 
448 ASSERT_TRUE(ret1 != CRYPT_SUCCESS || cmpRet1 != 0 || ret2 != CRYPT_SUCCESS || cmpRet2 != 0);452 ASSERT_TRUE(ret1 != CRYPT_SUCCESS || cmpRet1 != 0 || ret2 != CRYPT_SUCCESS || cmpRet2 != 0);
453+ ASSERT_TRUE(TestIsErrStackEmpty());
449EXIT:454EXIT:
450 CRYPT_EAL_PkeyFreeCtx(pkey1);455 CRYPT_EAL_PkeyFreeCtx(pkey1);
451 CRYPT_EAL_PkeyFreeCtx(pkey2);456 CRYPT_EAL_PkeyFreeCtx(pkey2);
@@ -1546,6 +1551,7 @@ void SDV_CRYPTO_DH_DUP_CTX_FUNC_TC001(int isProvider)
1546 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(dupCtx, ctx, share2, &share2Len) == CRYPT_SUCCESS);1551 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(dupCtx, ctx, share2, &share2Len) == CRYPT_SUCCESS);
1547 ASSERT_TRUE(share1Len == share2Len);1552 ASSERT_TRUE(share1Len == share2Len);
1548 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);1553 ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
1554+ ASSERT_TRUE(TestIsErrStackEmpty());
1549 1555 
1550EXIT:1556EXIT:
1551 TestRandDeInit();1557 TestRandDeInit();
@@ -1584,6 +1590,7 @@ void SDV_CRYPTO_DH_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, Hex *p, Hex *g,
1584 1590 
1585 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, &para) == CRYPT_SUCCESS);1591 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, &para) == CRYPT_SUCCESS);
1586 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);1592 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
1593+ ASSERT_TRUE(TestIsErrStackEmpty());
1587EXIT:1594EXIT:
1588 CRYPT_EAL_PkeyFreeCtx(pkey);1595 CRYPT_EAL_PkeyFreeCtx(pkey);
1589}1596}
@@ -1658,6 +1665,7 @@ void SDV_CRYPTO_DH_CHECK_KEYPAIR_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
1658 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);1665 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
1659 1666 
1660 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);1667 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);
1668+ ASSERT_TRUE(TestIsErrStackEmpty());
1661EXIT:1669EXIT:
1662 TestRandDeInit();1670 TestRandDeInit();
1663 CRYPT_EAL_PkeyFreeCtx(pkey);1671 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -1689,6 +1697,7 @@ void SDV_CRYPTO_DH_CHECK_KEYPAIR_TC002(int id, int isProvider)
1689 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);1697 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
1690 1698 
1691 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);1699 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);
1700+ ASSERT_TRUE(TestIsErrStackEmpty());
1692EXIT:1701EXIT:
1693 TestRandDeInit();1702 TestRandDeInit();
1694 CRYPT_EAL_PkeyFreeCtx(pkey);1703 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -1745,11 +1754,13 @@ void SDV_CRYPTO_DH_CHECK_KEYPAIR_INVALIED_TC001(Hex *p, Hex *g, Hex *q, int isPr
1745 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(NULL, NULL) == CRYPT_NULL_INPUT);1754 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(NULL, NULL) == CRYPT_NULL_INPUT);
1746 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) == CRYPT_SUCCESS);1755 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) == CRYPT_SUCCESS);
1747 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_NULL_INPUT); // no prv key1756 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_NULL_INPUT); // no prv key
1757+ TestErrClear();
1748 1758 
1749 ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) == CRYPT_SUCCESS);1759 ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) == CRYPT_SUCCESS);
1750 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_SUCCESS);1760 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_SUCCESS);
1751 1761 
1752 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pubCtx) == CRYPT_SUCCESS);1762 ASSERT_TRUE(CRYPT_EAL_PkeyGen(pubCtx) == CRYPT_SUCCESS);
1763+ ASSERT_TRUE(TestIsErrStackEmpty());
1753 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_DH_PAIRWISE_CHECK_FAIL);1764 ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_DH_PAIRWISE_CHECK_FAIL);
1754 1765 
1755EXIT:1766EXIT:
@@ -1876,6 +1887,7 @@ void SDV_CRYPTO_DH_FUNC_SET_PARAM_EX_TC001(Hex *p, Hex *g, Hex *q, Hex *prvBuf,
1876 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);1887 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);
1877 ASSERT_TRUE(shareLen == share->len);1888 ASSERT_TRUE(shareLen == share->len);
1878 ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);1889 ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);
1890+ ASSERT_TRUE(TestIsErrStackEmpty());
1879EXIT:1891EXIT:
1880 CRYPT_EAL_PkeyFreeCtx(pkey1);1892 CRYPT_EAL_PkeyFreeCtx(pkey1);
1881 CRYPT_EAL_PkeyFreeCtx(pkey2);1893 CRYPT_EAL_PkeyFreeCtx(pkey2);
Mtestcode/sdv/testcase/crypto/drbg/test_suite_sdv_drbg.c+16-0
@@ -1073,6 +1073,7 @@ void SDV_CRYPT_DRBG_FORK_RESEED_FUNC_TC001(void)
1073 forkId = ++ctx->forkId;1073 forkId = ++ctx->forkId;
1074 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbg, output, DRBG_OUTPUT_SIZE), CRYPT_SUCCESS);1074 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbg, output, DRBG_OUTPUT_SIZE), CRYPT_SUCCESS);
1075 ASSERT_NE(ctx->forkId, forkId);1075 ASSERT_NE(ctx->forkId, forkId);
1076+ ASSERT_TRUE(TestIsErrStackEmpty());
1076 1077 
1077EXIT:1078EXIT:
1078 CRYPT_EAL_DrbgDeinit(drbg);1079 CRYPT_EAL_DrbgDeinit(drbg);
@@ -1271,6 +1272,7 @@ void SDV_CRYPT_DRBG_RAND_NUM_FUNC_TC001(int agId, int num, int dataSize)
1271 for (i = 0; i < num; i++) {1272 for (i = 0; i < num; i++) {
1272 ASSERT_EQ(CRYPT_EAL_RandbytesWithAdin(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);1273 ASSERT_EQ(CRYPT_EAL_RandbytesWithAdin(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
1273 }1274 }
1275+ ASSERT_TRUE(TestIsErrStackEmpty());
1274 1276 
1275EXIT:1277EXIT:
1276 CRYPT_EAL_RandDeinit();1278 CRYPT_EAL_RandDeinit();
@@ -1319,6 +1321,7 @@ void SDV_CRYPT_DRBG_NUM_FUNC_TC001(int agId, int num, int dataSize)
1319 for (i = 0; i < num; i++) {1321 for (i = 0; i < num; i++) {
1320 ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);1322 ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
1321 }1323 }
1324+ ASSERT_TRUE(TestIsErrStackEmpty());
1322 1325 
1323EXIT:1326EXIT:
1324 CRYPT_EAL_DrbgDeinit(drbgCtx);1327 CRYPT_EAL_DrbgDeinit(drbgCtx);
@@ -1360,6 +1363,7 @@ void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC001(int agId)
1360 ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptGlobalThreadTest, NULL), 0);1363 ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptGlobalThreadTest, NULL), 0);
1361 pthread_join(thrd, NULL);1364 pthread_join(thrd, NULL);
1362 }1365 }
1366+ ASSERT_TRUE(TestIsErrStackEmpty());
1363 1367 
1364EXIT:1368EXIT:
1365 CRYPT_EAL_RandDeinit();1369 CRYPT_EAL_RandDeinit();
@@ -1429,9 +1433,11 @@ void SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC001(int agId)
1429 1433 
1430 TestMemInit();1434 TestMemInit();
1431 ASSERT_NE(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);1435 ASSERT_NE(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
1436+ (void)TestErrClear();
1432 drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, (void *)&seedCtx);1437 drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, (void *)&seedCtx);
1433 ASSERT_TRUE(drbg != NULL);1438 ASSERT_TRUE(drbg != NULL);
1434 ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);1439 ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
1440+ ASSERT_TRUE(TestIsErrStackEmpty());
1435EXIT:1441EXIT:
1436 CRYPT_EAL_DrbgDeinit(drbg);1442 CRYPT_EAL_DrbgDeinit(drbg);
1437 CRYPT_EAL_RandDeinit();1443 CRYPT_EAL_RandDeinit();
@@ -1653,6 +1659,7 @@ void SDV_CRYPT_DRBG_INSTANTIATE_FUNC_TC001(void)
1653 drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);1659 drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
1654 ASSERT_TRUE(drbg != NULL);1660 ASSERT_TRUE(drbg != NULL);
1655 ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, pers->data, pers->len), CRYPT_SUCCESS);1661 ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, pers->data, pers->len), CRYPT_SUCCESS);
1662+ ASSERT_TRUE(TestIsErrStackEmpty());
1656 1663 
1657EXIT:1664EXIT:
1658 CRYPT_EAL_DrbgDeinit(drbg);1665 CRYPT_EAL_DrbgDeinit(drbg);
@@ -1741,6 +1748,7 @@ void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC002(int agId)
1741 CRYPT_EAL_DrbgDeinit(drbgCtx);1748 CRYPT_EAL_DrbgDeinit(drbgCtx);
1742 drbgCtx = NULL;1749 drbgCtx = NULL;
1743 }1750 }
1751+ ASSERT_TRUE(TestIsErrStackEmpty());
1744EXIT:1752EXIT:
1745 drbgDataFree(&data);1753 drbgDataFree(&data);
1746 return;1754 return;
@@ -1780,6 +1788,7 @@ void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC003(int agId)
1780 ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptEalThreadTest, drbgCtx), 0);1788 ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptEalThreadTest, drbgCtx), 0);
1781 pthread_join(thrd, NULL);1789 pthread_join(thrd, NULL);
1782 }1790 }
1791+ ASSERT_TRUE(TestIsErrStackEmpty());
1783EXIT:1792EXIT:
1784 CRYPT_EAL_DrbgDeinit(drbgCtx);1793 CRYPT_EAL_DrbgDeinit(drbgCtx);
1785 drbgDataFree(&data);1794 drbgDataFree(&data);
@@ -1859,6 +1868,7 @@ void SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *
1859 1868 
1860 ASSERT_EQ(CRYPT_EAL_Randbytes(output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);1869 ASSERT_EQ(CRYPT_EAL_Randbytes(output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
1861 ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);1870 ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);
1871+ ASSERT_TRUE(TestIsErrStackEmpty());
1862EXIT:1872EXIT:
1863 CRYPT_EAL_RandDeinit();1873 CRYPT_EAL_RandDeinit();
1864 seedCtxFree(seedCtx);1874 seedCtxFree(seedCtx);
@@ -1908,6 +1918,7 @@ void SDV_CRYPT_EAL_DRBG_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *
1908 CRYPT_SUCCESS);1918 CRYPT_SUCCESS);
1909 1919 
1910 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);1920 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
1921+ ASSERT_TRUE(TestIsErrStackEmpty());
1911 1922 
1912EXIT:1923EXIT:
1913 CRYPT_EAL_DrbgDeinit(drbgCtx);1924 CRYPT_EAL_DrbgDeinit(drbgCtx);
@@ -1958,6 +1969,7 @@ void SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC002(int id)
1958 ASSERT_EQ(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)id, &seedMeth, NULL, NULL, 0), CRYPT_SUCCESS);1969 ASSERT_EQ(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)id, &seedMeth, NULL, NULL, 0), CRYPT_SUCCESS);
1959 ASSERT_EQ(CRYPT_EAL_RandSeed(), CRYPT_SUCCESS);1970 ASSERT_EQ(CRYPT_EAL_RandSeed(), CRYPT_SUCCESS);
1960 ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);1971 ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
1972+ ASSERT_TRUE(TestIsErrStackEmpty());
1961 1973 
1962EXIT:1974EXIT:
1963 CRYPT_EAL_RandDeinit();1975 CRYPT_EAL_RandDeinit();
@@ -2029,6 +2041,7 @@ void SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC001(int id, Hex *entropy,
2029 2041 
2030 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);2042 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
2031 ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);2043 ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);
2044+ ASSERT_TRUE(TestIsErrStackEmpty());
2032EXIT:2045EXIT:
2033 CRYPT_EAL_RandDeinitEx(NULL);2046 CRYPT_EAL_RandDeinitEx(NULL);
2034 seedCtxFree(seedCtx);2047 seedCtxFree(seedCtx);
@@ -2105,6 +2118,7 @@ void SDV_CRYPT_EAL_DRBG_DEFAULT_PROVIDER_BYTES_FUNC_TC001(int id, Hex *entropy,
2105 ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),2118 ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),
2106 CRYPT_SUCCESS);2119 CRYPT_SUCCESS);
2107 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);2120 ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
2121+ ASSERT_TRUE(TestIsErrStackEmpty());
2108 2122 
2109EXIT:2123EXIT:
2110 CRYPT_EAL_DrbgDeinit(drbgCtx);2124 CRYPT_EAL_DrbgDeinit(drbgCtx);
@@ -2182,6 +2196,7 @@ void SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC002(int id)
2182 ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param), CRYPT_SUCCESS);2196 ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param), CRYPT_SUCCESS);
2183 ASSERT_EQ(CRYPT_EAL_RandSeedEx(NULL), CRYPT_SUCCESS);2197 ASSERT_EQ(CRYPT_EAL_RandSeedEx(NULL), CRYPT_SUCCESS);
2184 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);2198 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
2199+ ASSERT_TRUE(TestIsErrStackEmpty());
2185 2200 
2186EXIT:2201EXIT:
2187 CRYPT_EAL_RandDeinitEx(NULL);2202 CRYPT_EAL_RandDeinitEx(NULL);
@@ -2386,6 +2401,7 @@ void SDV_PRIMARY_DRBG_VECTOR_FUN_TC001(int algId, int entropyLen, Hex *result)
2386 2401 
2387 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, len), CRYPT_SUCCESS);2402 ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, len), CRYPT_SUCCESS);
2388 ASSERT_EQ(memcmp(output, result->x, result->len), 0);2403 ASSERT_EQ(memcmp(output, result->x, result->len), 0);
2404+ ASSERT_TRUE(TestIsErrStackEmpty());
2389EXIT:2405EXIT:
2390 seedCtxFree(seedCtx);2406 seedCtxFree(seedCtx);
2391 BSL_SAL_Free(entropy);2407 BSL_SAL_Free(entropy);
Mtestcode/sdv/testcase/crypto/dsa/test_suite_sdv_eal_dsa.c+12-0
@@ -474,6 +474,7 @@ void SDV_CRYPTO_DSA_SIGN_VERIFY_FUNC_TC001(
474 hitlsSignOutLen = signLen;474 hitlsSignOutLen = signLen;
475 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, &hitlsSignOutLen), CRYPT_SUCCESS);475 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, &hitlsSignOutLen), CRYPT_SUCCESS);
476 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);476 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);
477+ ASSERT_TRUE(TestIsErrStackEmpty());
477EXIT:478EXIT:
478 CRYPT_RandRegist(NULL);479 CRYPT_RandRegist(NULL);
479 CRYPT_RandRegistEx(NULL);480 CRYPT_RandRegistEx(NULL);
@@ -569,6 +570,7 @@ void SDV_CRYPTO_DSA_SIGN_VERIFY_DATA_FUNC_TC001(
569 570 
570 /* Verify the signature of the hash data. */571 /* Verify the signature of the hash data. */
571 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(pkey, mdOut.x, mdOut.len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);572 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(pkey, mdOut.x, mdOut.len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);
573+ ASSERT_TRUE(TestIsErrStackEmpty());
572EXIT:574EXIT:
573 CRYPT_RandRegist(NULL);575 CRYPT_RandRegist(NULL);
574 CRYPT_RandRegistEx(NULL);576 CRYPT_RandRegistEx(NULL);
@@ -639,6 +641,7 @@ void SDV_CRYPTO_DSA_GEN_FUNC_TC001(Hex *p, Hex *q, Hex *g, Hex *data, int isProv
639 641 
640 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, &signLen), CRYPT_SUCCESS);642 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, &signLen), CRYPT_SUCCESS);
641 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, signLen), CRYPT_SUCCESS);643 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, signLen), CRYPT_SUCCESS);
644+ ASSERT_TRUE(TestIsErrStackEmpty());
642EXIT:645EXIT:
643 CRYPT_EAL_PkeyFreeCtx(ctx);646 CRYPT_EAL_PkeyFreeCtx(ctx);
644 free(sign);647 free(sign);
@@ -731,6 +734,7 @@ void SDV_CRYPTO_DSA_DUP_CTX_FUNC_TC001(Hex *p, Hex *q, Hex *g, int isProvider)
731 CRYPT_SUCCESS);734 CRYPT_SUCCESS);
732 ASSERT_EQ(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SHA256, (uint8_t *)msg, msgLen, sign, signLen),735 ASSERT_EQ(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SHA256, (uint8_t *)msg, msgLen, sign, signLen),
733 CRYPT_SUCCESS);736 CRYPT_SUCCESS);
737+ ASSERT_TRUE(TestIsErrStackEmpty());
734EXIT:738EXIT:
735 TestRandDeInit();739 TestRandDeInit();
736 CRYPT_EAL_PkeyFreeCtx(ctx);740 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -825,6 +829,7 @@ void SDV_CRYPTO_DSA_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, Hex *P, Hex *Q,
825 829 
826 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, &para) == CRYPT_SUCCESS);830 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, &para) == CRYPT_SUCCESS);
827 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);831 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
832+ ASSERT_TRUE(TestIsErrStackEmpty());
828EXIT:833EXIT:
829 CRYPT_EAL_PkeyFreeCtx(pkey);834 CRYPT_EAL_PkeyFreeCtx(pkey);
830}835}
@@ -908,6 +913,7 @@ void SDV_CRYPTO_DSA_VERIFY_PQ_FUNC_TC001(int algId, Hex *seed, char *pHex, char
908 uint32_t counter = 5;913 uint32_t counter = 5;
909 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);914 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
910 ASSERT_EQ(CryptDsaFips1864ValidatePq(algId, NULL, NULL, CRYPT_DSA_FFC_PARAM, &seedTmp, &dsaPara, counter), 0);915 ASSERT_EQ(CryptDsaFips1864ValidatePq(algId, NULL, NULL, CRYPT_DSA_FFC_PARAM, &seedTmp, &dsaPara, counter), 0);
916+ ASSERT_TRUE(TestIsErrStackEmpty());
911EXIT:917EXIT:
912 TestRandDeInit();918 TestRandDeInit();
913 BN_Destroy(p);919 BN_Destroy(p);
@@ -952,6 +958,7 @@ void SDV_CRYPTO_DSA_GEN_PQ_FUNC_TC001(int algId, int L, int N, Hex *seed, char *
952 ASSERT_EQ(BN_Hex2Bn(&qReq, qHex), CRYPT_SUCCESS);958 ASSERT_EQ(BN_Hex2Bn(&qReq, qHex), CRYPT_SUCCESS);
953 ASSERT_EQ(BN_Cmp(ctx->para->p, pReq), 0);959 ASSERT_EQ(BN_Cmp(ctx->para->p, pReq), 0);
954 ASSERT_EQ(BN_Cmp(ctx->para->q, qReq), 0);960 ASSERT_EQ(BN_Cmp(ctx->para->q, qReq), 0);
961+ ASSERT_TRUE(TestIsErrStackEmpty());
955EXIT:962EXIT:
956 CRYPT_EAL_RandDeinit();963 CRYPT_EAL_RandDeinit();
957 STUB_RESTORE(CRYPT_EAL_RandbytesEx);964 STUB_RESTORE(CRYPT_EAL_RandbytesEx);
@@ -984,6 +991,7 @@ void SDV_CRYPTO_DSA_GEN_G_FUNC_TC001(char *pHex, char *qHex, char *gHex)
984 ASSERT_EQ(CryptDsaFips1864GenUnverifiableG(&dsaPara, &h), CRYPT_SUCCESS);991 ASSERT_EQ(CryptDsaFips1864GenUnverifiableG(&dsaPara, &h), CRYPT_SUCCESS);
985 ASSERT_EQ(CryptDsaFips1864PartialValidateG(&dsaPara), CRYPT_SUCCESS);992 ASSERT_EQ(CryptDsaFips1864PartialValidateG(&dsaPara), CRYPT_SUCCESS);
986 ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);993 ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);
994+ ASSERT_TRUE(TestIsErrStackEmpty());
987EXIT:995EXIT:
988 BN_Destroy(p);996 BN_Destroy(p);
989 BN_Destroy(q);997 BN_Destroy(q);
@@ -1013,6 +1021,7 @@ void SDV_CRYPTO_DSA_GEN_G_FUNC_TC002(int algId, int index, Hex *seed, char *pHex
1013 CRYPT_DSA_Para dsaPara = {p, q, NULL};1021 CRYPT_DSA_Para dsaPara = {p, q, NULL};
1014 ASSERT_EQ(CryptDsaFips1864GenVerifiableG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);1022 ASSERT_EQ(CryptDsaFips1864GenVerifiableG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
1015 ASSERT_EQ(CryptDsaFips1864ValidateG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);1023 ASSERT_EQ(CryptDsaFips1864ValidateG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
1024+ ASSERT_TRUE(TestIsErrStackEmpty());
1016EXIT:1025EXIT:
1017 BN_Destroy(p);1026 BN_Destroy(p);
1018 BN_Destroy(q);1027 BN_Destroy(q);
@@ -1072,6 +1081,7 @@ void SDV_CRYPTO_DSA_GEN_G_FUNC_TC004(int algId, int index, Hex *seed, char *pHex
1072 ASSERT_EQ(CryptDsaFips1864GenVerifiableG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);1081 ASSERT_EQ(CryptDsaFips1864GenVerifiableG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
1073 ASSERT_EQ(CryptDsaFips1864ValidateG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);1082 ASSERT_EQ(CryptDsaFips1864ValidateG(NULL, NULL, &fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
1074 ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);1083 ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);
1084+ ASSERT_TRUE(TestIsErrStackEmpty());
1075EXIT:1085EXIT:
1076 BN_Destroy(p);1086 BN_Destroy(p);
1077 BN_Destroy(q);1087 BN_Destroy(q);
@@ -1117,6 +1127,7 @@ void SDV_CRYPTO_DSA_KEY_PAIR_GEN_BY_PARAM_FUNC_TC001(int flag, int gIndex, int i
1117 ASSERT_TRUE(pkey != NULL);1127 ASSERT_TRUE(pkey != NULL);
1118 1128 
1119 ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_DSA_ERR_KEY_PARA);1129 ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_DSA_ERR_KEY_PARA);
1130+ TestErrClear();
1120 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GEN_PARA, params, 0), CRYPT_SUCCESS);1131 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GEN_PARA, params, 0), CRYPT_SUCCESS);
1121 uint32_t genFlag = (uint8_t)flag;1132 uint32_t genFlag = (uint8_t)flag;
1122 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_GEN_FLAG, &genFlag, sizeof(genFlag)), CRYPT_SUCCESS);1133 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_GEN_FLAG, &genFlag, sizeof(genFlag)), CRYPT_SUCCESS);
@@ -1131,6 +1142,7 @@ void SDV_CRYPTO_DSA_KEY_PAIR_GEN_BY_PARAM_FUNC_TC001(int flag, int gIndex, int i
1131 uint32_t dataLen = 8;1142 uint32_t dataLen = 8;
1132 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);1143 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
1133 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);1144 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
1145+ ASSERT_TRUE(TestIsErrStackEmpty());
1134EXIT:1146EXIT:
1135#ifdef HITLS_CRYPTO_DRBG1147#ifdef HITLS_CRYPTO_DRBG
1136 TestRandDeInit();1148 TestRandDeInit();
Mtestcode/sdv/testcase/crypto/eal/test_suite_sdv_eal.c+9-0
@@ -214,6 +214,7 @@ void SDV_CRYPTO_MD_COPY_FUNC_TC001(int id, Hex *msg, Hex *hash)
214 ASSERT_TRUE(cpyCtx != NULL);214 ASSERT_TRUE(cpyCtx != NULL);
215 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);215 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
216 ASSERT_EQ(MdTest(cpyCtx, msg, hash), 0);216 ASSERT_EQ(MdTest(cpyCtx, msg, hash), 0);
217+ ASSERT_TRUE(TestIsErrStackEmpty());
217 218 
218EXIT:219EXIT:
219 CRYPT_EAL_MdFreeCtx(ctx);220 CRYPT_EAL_MdFreeCtx(ctx);
@@ -516,6 +517,7 @@ void SDV_CRYPTO_EAL_REINIT_TC001(int id)
516 ASSERT_TRUE(ctx != NULL);517 ASSERT_TRUE(ctx != NULL);
517 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);518 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
518 (void)CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);519 (void)CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
520+ (void)TestErrClear();
519 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);521 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
520 ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);522 ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
521 struct ModesCipherCtx *ciphCtx = ((struct CRYPT_EAL_CipherCtxLocal *)ctx)->ctx;523 struct ModesCipherCtx *ciphCtx = ((struct CRYPT_EAL_CipherCtxLocal *)ctx)->ctx;
@@ -525,6 +527,7 @@ void SDV_CRYPTO_EAL_REINIT_TC001(int id)
525 for (uint32_t i = 0; i < EAL_MAX_BLOCK_LENGTH; i++) {527 for (uint32_t i = 0; i < EAL_MAX_BLOCK_LENGTH; i++) {
526 ASSERT_EQ(ciphCtx->data[i], 0);528 ASSERT_EQ(ciphCtx->data[i], 0);
527 }529 }
530+ ASSERT_TRUE(TestIsErrStackEmpty());
528EXIT:531EXIT:
529 CRYPT_EAL_CipherDeinit(ctx);532 CRYPT_EAL_CipherDeinit(ctx);
530 CRYPT_EAL_CipherFreeCtx(ctx);533 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -562,6 +565,7 @@ void SDV_CRYPTO_EAL_REINIT_TC002(int id)
562 // Check aadLen cipherTextLen565 // Check aadLen cipherTextLen
563 ASSERT_EQ(ciphCtx->chachaCtx.aadLen, 0);566 ASSERT_EQ(ciphCtx->chachaCtx.aadLen, 0);
564 ASSERT_EQ(ciphCtx->chachaCtx.cipherTextLen, 0);567 ASSERT_EQ(ciphCtx->chachaCtx.cipherTextLen, 0);
568+ ASSERT_TRUE(TestIsErrStackEmpty());
565EXIT:569EXIT:
566 CRYPT_EAL_CipherDeinit(ctx);570 CRYPT_EAL_CipherDeinit(ctx);
567 CRYPT_EAL_CipherFreeCtx(ctx);571 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -597,6 +601,7 @@ void SDV_CRYPTO_EAL_REINIT_TC003(int id)
597 for (uint32_t i = 0; i < GCM_BLOCKSIZE; i++) {601 for (uint32_t i = 0; i < GCM_BLOCKSIZE; i++) {
598 ASSERT_EQ(ciphCtx->gcmCtx.ghash[i], 0);602 ASSERT_EQ(ciphCtx->gcmCtx.ghash[i], 0);
599 }603 }
604+ ASSERT_TRUE(TestIsErrStackEmpty());
600EXIT:605EXIT:
601 CRYPT_EAL_CipherDeinit(ctx);606 CRYPT_EAL_CipherDeinit(ctx);
602 CRYPT_EAL_CipherFreeCtx(ctx);607 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -629,6 +634,7 @@ void SDV_CRYPTO_EAL_GET_KEY_LEN_TC001(int algid, int paramId, int pubLen, int pr
629 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));634 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
630 ASSERT_EQ(ret, CRYPT_SUCCESS);635 ASSERT_EQ(ret, CRYPT_SUCCESS);
631 ASSERT_EQ(val, sharedLen);636 ASSERT_EQ(val, sharedLen);
637+ ASSERT_TRUE(TestIsErrStackEmpty());
632EXIT:638EXIT:
633 CRYPT_EAL_PkeyFreeCtx(ctx);639 CRYPT_EAL_PkeyFreeCtx(ctx);
634}640}
@@ -701,6 +707,7 @@ void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_1(int algid, int rsaBits, Hex *p, Hex *q,
701 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));707 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
702 ASSERT_EQ(ret, CRYPT_SUCCESS);708 ASSERT_EQ(ret, CRYPT_SUCCESS);
703 }709 }
710+ ASSERT_TRUE(TestIsErrStackEmpty());
704EXIT:711EXIT:
705 CRYPT_EAL_PkeyFreeCtx(ctx);712 CRYPT_EAL_PkeyFreeCtx(ctx);
706}713}
@@ -741,6 +748,7 @@ void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_2(int algid, int rsaBits, Hex *p, Hex *q,
741 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));748 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));
742 ASSERT_EQ(ret, CRYPT_SUCCESS);749 ASSERT_EQ(ret, CRYPT_SUCCESS);
743 ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);750 ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
751+ ASSERT_TRUE(TestIsErrStackEmpty());
744EXIT:752EXIT:
745 CRYPT_EAL_PkeyFreeCtx(ctx);753 CRYPT_EAL_PkeyFreeCtx(ctx);
746}754}
@@ -777,6 +785,7 @@ void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_3(int algid, int rsaBits, Hex *p, Hex *q,
777 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));785 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));
778 ASSERT_EQ(ret, CRYPT_SUCCESS);786 ASSERT_EQ(ret, CRYPT_SUCCESS);
779 ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);787 ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
788+ ASSERT_TRUE(TestIsErrStackEmpty());
780EXIT:789EXIT:
781 CRYPT_EAL_PkeyFreeCtx(ctx);790 CRYPT_EAL_PkeyFreeCtx(ctx);
782}791}
Mtestcode/sdv/testcase/crypto/ecc/test_suite_sdv_eal_ecdh.c+5-0
@@ -641,6 +641,7 @@ void SDV_CRYPTO_ECDH_EXCH_FUNC_TC001(
641 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPubPkey, shareKey, &shareKeyLen), CRYPT_SUCCESS);641 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPubPkey, shareKey, &shareKeyLen), CRYPT_SUCCESS);
642 ASSERT_TRUE_AND_LOG("Compare ShareKey Len", shareKeyLen == shareKeyVector->len);642 ASSERT_TRUE_AND_LOG("Compare ShareKey Len", shareKeyLen == shareKeyVector->len);
643 ASSERT_COMPARE("Compare ShareKey", shareKey, shareKeyLen, shareKeyVector->x, shareKeyVector->len);643 ASSERT_COMPARE("Compare ShareKey", shareKey, shareKeyLen, shareKeyVector->x, shareKeyVector->len);
644+ ASSERT_TRUE(TestIsErrStackEmpty());
644EXIT:645EXIT:
645 CRYPT_EAL_PkeyFreeCtx(ecdhPkey);646 CRYPT_EAL_PkeyFreeCtx(ecdhPkey);
646 CRYPT_EAL_PkeyFreeCtx(peerEcdhPubPkey);647 CRYPT_EAL_PkeyFreeCtx(peerEcdhPubPkey);
@@ -720,6 +721,7 @@ void SDV_CRYPTO_ECDH_GET_KEY_BITS_FUNC_TC001(int paraid, int keyBits, int isProv
720 ASSERT_TRUE(pkey != NULL);721 ASSERT_TRUE(pkey != NULL);
721 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);722 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
722 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);723 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
724+ ASSERT_TRUE(TestIsErrStackEmpty());
723EXIT:725EXIT:
724 CRYPT_EAL_PkeyFreeCtx(pkey);726 CRYPT_EAL_PkeyFreeCtx(pkey);
725}727}
@@ -745,6 +747,7 @@ void SDV_CRYPTO_ECDH_GET_SEC_BITS_FUNC_TC001(int paraid, int secBits)
745 ASSERT_TRUE(pkey != NULL);747 ASSERT_TRUE(pkey != NULL);
746 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);748 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
747 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), secBits);749 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), secBits);
750+ ASSERT_TRUE(TestIsErrStackEmpty());
748EXIT:751EXIT:
749 CRYPT_EAL_PkeyFreeCtx(pkey);752 CRYPT_EAL_PkeyFreeCtx(pkey);
750}753}
@@ -918,6 +921,7 @@ void SDV_CRYPTO_ECC_MUL_CAL_TEST_FUNC_TC001(int paraId)
918 ASSERT_EQ(ECC_PointMul(para, point2, rand, point1), CRYPT_SUCCESS);921 ASSERT_EQ(ECC_PointMul(para, point2, rand, point1), CRYPT_SUCCESS);
919 ASSERT_EQ(ECP_PointMulFast(para, point3, rand, point1), CRYPT_SUCCESS);922 ASSERT_EQ(ECP_PointMulFast(para, point3, rand, point1), CRYPT_SUCCESS);
920 ASSERT_EQ(ECC_PointCmp(para, point2, point3), CRYPT_SUCCESS);923 ASSERT_EQ(ECC_PointCmp(para, point2, point3), CRYPT_SUCCESS);
924+ ASSERT_TRUE(TestIsErrStackEmpty());
921 925 
922EXIT:926EXIT:
923 ECC_FreePara(para);927 ECC_FreePara(para);
@@ -976,6 +980,7 @@ void SDV_CRYPTO_ECC_ADD_CAL_TEST_FUNC_TC001(int paraId, Hex *bk1, Hex *bk2, Hex
976 980 
977 ASSERT_EQ(ECC_PointMulAdd(para, r2, bnk1, bnk2, twoG), CRYPT_SUCCESS);981 ASSERT_EQ(ECC_PointMulAdd(para, r2, bnk1, bnk2, twoG), CRYPT_SUCCESS);
978 ASSERT_EQ(ECC_PointCmp(para, r1, r2), CRYPT_SUCCESS);982 ASSERT_EQ(ECC_PointCmp(para, r1, r2), CRYPT_SUCCESS);
983+ ASSERT_TRUE(TestIsErrStackEmpty());
979 984 
980EXIT:985EXIT:
981 ECC_FreePara(para);986 ECC_FreePara(para);
Mtestcode/sdv/testcase/crypto/ecc/test_suite_sdv_eal_ecdsa.c+5-0
@@ -918,6 +918,7 @@ void SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC002(int eccId, Hex *prvKeyVector, Hex *
918 918 
919 /* Verify hash data */919 /* Verify hash data */
920 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(ecdsaPkey2, hashData->x, hashData->len, hitlsSign, hitlsSignLen), CRYPT_SUCCESS);920 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(ecdsaPkey2, hashData->x, hashData->len, hitlsSign, hitlsSignLen), CRYPT_SUCCESS);
921+ ASSERT_TRUE(TestIsErrStackEmpty());
921 922 
922EXIT:923EXIT:
923 free(hitlsSign);924 free(hitlsSign);
@@ -1206,6 +1207,7 @@ void SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC001(int eccId, int mdId, Hex *prvKeyVec
1206 hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(cpyCtx);1207 hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(cpyCtx);
1207 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, msg->x, msg->len, hitlsSign, (uint32_t *)&hitlsSginLen), CRYPT_SUCCESS);1208 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, msg->x, msg->len, hitlsSign, (uint32_t *)&hitlsSginLen), CRYPT_SUCCESS);
1208 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, msg->x, msg->len, hitlsSign, hitlsSginLen), CRYPT_SUCCESS);1209 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, msg->x, msg->len, hitlsSign, hitlsSginLen), CRYPT_SUCCESS);
1210+ ASSERT_TRUE(TestIsErrStackEmpty());
1209 1211 
1210EXIT:1212EXIT:
1211 free(hitlsSign);1213 free(hitlsSign);
@@ -1261,6 +1263,7 @@ void SDV_CRYPTO_ECDSA_SET_PUB_FUNC_TC001(
1261 Ecc_SetPubKey(&ECDSAPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);1263 Ecc_SetPubKey(&ECDSAPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
1262 if (result == 1) {1264 if (result == 1) {
1263 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);1265 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);
1266+ ASSERT_TRUE(TestIsErrStackEmpty());
1264 } else {1267 } else {
1265 ASSERT_NE(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);1268 ASSERT_NE(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);
1266 }1269 }
@@ -1502,6 +1505,7 @@ void SDV_CRYPTO_ECDSA_CHECK_KEYPAIR_FUNC_TC001(int paraid, int isProvider)
1502 1505 
1503 ecdsaPrvKey.key.eccPrv.data = wrong;1506 ecdsaPrvKey.key.eccPrv.data = wrong;
1504 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdsaPrvKey), CRYPT_SUCCESS);1507 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdsaPrvKey), CRYPT_SUCCESS);
1508+ ASSERT_TRUE(TestIsErrStackEmpty());
1505 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_ECDSA_PAIRWISE_CHECK_FAIL);1509 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_ECDSA_PAIRWISE_CHECK_FAIL);
1506 1510 
1507EXIT:1511EXIT:
@@ -1625,6 +1629,7 @@ void SDV_CRYPTO_ECDSA_Import_Export_FUNC_TC001(void)
1625 1629 
1626 ASSERT_EQ(CRYPT_ECDSA_Sign(srcEcdsaCtx, CRYPT_MD_SHA256, msg, sizeof(msg), sign, &signLen), CRYPT_SUCCESS);1630 ASSERT_EQ(CRYPT_ECDSA_Sign(srcEcdsaCtx, CRYPT_MD_SHA256, msg, sizeof(msg), sign, &signLen), CRYPT_SUCCESS);
1627 ASSERT_EQ(CRYPT_ECDSA_Verify(dstEcdsaCtx, CRYPT_MD_SHA256, msg, sizeof(msg), sign, signLen), CRYPT_SUCCESS);1631 ASSERT_EQ(CRYPT_ECDSA_Verify(dstEcdsaCtx, CRYPT_MD_SHA256, msg, sizeof(msg), sign, signLen), CRYPT_SUCCESS);
1632+ ASSERT_TRUE(TestIsErrStackEmpty());
1628 1633 
1629EXIT:1634EXIT:
1630 CRYPT_ECDSA_FreeCtx(srcEcdsaCtx);1635 CRYPT_ECDSA_FreeCtx(srcEcdsaCtx);
Mtestcode/sdv/testcase/crypto/elgamal/test_suite_sdv_eal_elgamal.c+3-0
@@ -818,6 +818,7 @@ void SDV_CRYPTO_ELGAMAL_SET_KEY_API_TC001( Hex *q, int k_bits, int bits, int isP
818 SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600, pubY, 600, pubQ, 600);818 SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600, pubY, 600, pubQ, 600);
819 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);819 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
820 ASSERT_EQ(Compare_PubKey(&pubKey, &pubKey), 0);820 ASSERT_EQ(Compare_PubKey(&pubKey, &pubKey), 0);
821+ ASSERT_TRUE(TestIsErrStackEmpty());
821 822 
822EXIT:823EXIT:
823 CRYPT_EAL_PkeyFreeCtx(pkey1);824 CRYPT_EAL_PkeyFreeCtx(pkey1);
@@ -869,6 +870,7 @@ void SDV_CRYPTO_ELGAMAL_DUP_CTX_API_TC001( Hex *q,int k_bits, int bits, int isPr
869 elgamalCtx->prvKey->x->size * sizeof(BN_UINT),870 elgamalCtx->prvKey->x->size * sizeof(BN_UINT),
870 elgamalCtx2->prvKey->x->data,871 elgamalCtx2->prvKey->x->data,
871 elgamalCtx2->prvKey->x->size * sizeof(BN_UINT));872 elgamalCtx2->prvKey->x->size * sizeof(BN_UINT));
873+ ASSERT_TRUE(TestIsErrStackEmpty());
872 874 
873EXIT:875EXIT:
874 CRYPT_EAL_PkeyFreeCtx(pkey);876 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -905,6 +907,7 @@ void SDV_CRYPTO_ELGAMAL_GET_SECURITY_BITS_FUNC_TC001(Hex *q,Hex *p, Hex *g, Hex
905 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);907 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
906 908 
907 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);909 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
910+ ASSERT_TRUE(TestIsErrStackEmpty());
908 911 
909EXIT:912EXIT:
910 CRYPT_EAL_PkeyFreeCtx(pkey);913 CRYPT_EAL_PkeyFreeCtx(pkey);
Mtestcode/sdv/testcase/crypto/encode/test_suite_sdv_asn1_certkey.c+16-0
@@ -307,6 +307,7 @@ void SDV_BSL_ASN1_PARSE_RSA_PRV_TC001(char *path, Hex *version, Hex *n, Hex *e,
307 ASSERT_TRUE(signdata != NULL);307 ASSERT_TRUE(signdata != NULL);
308 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);308 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
309 ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);309 ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);
310+ ASSERT_TRUE(TestIsErrStackEmpty());
310 311 
311EXIT:312EXIT:
312 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);313 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -340,6 +341,7 @@ void SDV_BSL_ASN1_PARSE_PUBKEY_FILE_TC001(char *path, int fileType, int mdId, He
340 0);341 0);
341 }342 }
342 ASSERT_EQ(CRYPT_EAL_PkeyVerify(reDecPkeyCtx, mdId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);343 ASSERT_EQ(CRYPT_EAL_PkeyVerify(reDecPkeyCtx, mdId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
344+ ASSERT_TRUE(TestIsErrStackEmpty());
343 345 
344EXIT:346EXIT:
345 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);347 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -449,6 +451,7 @@ void SDV_BSL_ASN1_PARSE_PRIKEY_FILE_TC001(int isProvider, char *path, int fileTy
449 ASSERT_EQ(DecodeKeyBuff(isProvider, &reEnc, BSL_FORMAT_ASN1, "ASN1",451 ASSERT_EQ(DecodeKeyBuff(isProvider, &reEnc, BSL_FORMAT_ASN1, "ASN1",
450 fileType, fileTypeStr, NULL, 0, &reDecPkeyCtx), 0);452 fileType, fileTypeStr, NULL, 0, &reDecPkeyCtx), 0);
451 ASSERT_EQ(PrikeySign(reDecPkeyCtx, mdId, fileType, fileTypeStr, msg, sign), CRYPT_SUCCESS);453 ASSERT_EQ(PrikeySign(reDecPkeyCtx, mdId, fileType, fileTypeStr, msg, sign), CRYPT_SUCCESS);
454+ ASSERT_TRUE(TestIsErrStackEmpty());
452 455 
453EXIT:456EXIT:
454 BSL_SAL_Free(signdata);457 BSL_SAL_Free(signdata);
@@ -518,6 +521,7 @@ void SDV_BSL_ASN1_PARSE_ECCPRIKEY_FILE_TC001(int isProvider, int noPubKey, char
518 ASSERT_EQ(DecodeKeyBuff(isProvider, &reEnc, BSL_FORMAT_ASN1, "ASN1", fileType, fileTypeStr,521 ASSERT_EQ(DecodeKeyBuff(isProvider, &reEnc, BSL_FORMAT_ASN1, "ASN1", fileType, fileTypeStr,
519 NULL, 0, &reDecPkeyCtx), 0);522 NULL, 0, &reDecPkeyCtx), 0);
520 ASSERT_EQ(EccPrvSign(reDecPkeyCtx, mdId, alg, msg, rawKey, paraId), CRYPT_SUCCESS);523 ASSERT_EQ(EccPrvSign(reDecPkeyCtx, mdId, alg, msg, rawKey, paraId), CRYPT_SUCCESS);
524+ ASSERT_TRUE(TestIsErrStackEmpty());
521 if (noPubKey) {525 if (noPubKey) {
522 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(reDecPkeyCtx, CRYPT_CTRL_GET_FLAG, &flag, sizeof(flag)), CRYPT_SUCCESS);526 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(reDecPkeyCtx, CRYPT_CTRL_GET_FLAG, &flag, sizeof(flag)), CRYPT_SUCCESS);
523 ASSERT_EQ(flag, CRYPT_ECC_PRIKEY_NO_PUBKEY);527 ASSERT_EQ(flag, CRYPT_ECC_PRIKEY_NO_PUBKEY);
@@ -544,6 +548,7 @@ void SDV_BSL_ASN1_PARSE_25519PRIKEY_FILE_TC001(int alg, char *path, int format,
544 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);548 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
545 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyCtx, &pkeyPrv), CRYPT_SUCCESS);549 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyCtx, &pkeyPrv), CRYPT_SUCCESS);
546 ASSERT_COMPARE("key cmp", prv->x, prv->len, pkeyPrv.key.eccPrv.data, pkeyPrv.key.eccPrv.len);550 ASSERT_COMPARE("key cmp", prv->x, prv->len, pkeyPrv.key.eccPrv.data, pkeyPrv.key.eccPrv.len);
551+ ASSERT_TRUE(TestIsErrStackEmpty());
547 552 
548EXIT:553EXIT:
549 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);554 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -648,6 +653,7 @@ void SDV_BSL_ASN1_PARSE_ENCPK8_TC001(int isProvider, char *path, int fileType, c
648 if (sign->len != 0) {653 if (sign->len != 0) {
649 ASSERT_COMPARE("Signature Compare", sign->x, sign->len, signdata, signLen);654 ASSERT_COMPARE("Signature Compare", sign->x, sign->len, signdata, signLen);
650 }655 }
656+ ASSERT_TRUE(TestIsErrStackEmpty());
651 657 
652EXIT:658EXIT:
653 BSL_SAL_Free(signdata);659 BSL_SAL_Free(signdata);
@@ -688,6 +694,7 @@ void SDV_BSL_ASN1_ENCODE_PUBKEY_BUFF_TC001(char *path, int fileType, int isCompl
688 fileType, isComplete, &encodeAsn1), CRYPT_SUCCESS);694 fileType, isComplete, &encodeAsn1), CRYPT_SUCCESS);
689 695 
690 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);696 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
697+ ASSERT_TRUE(TestIsErrStackEmpty());
691EXIT:698EXIT:
692 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);699 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
693 BSL_SAL_FREE(encodeAsn1.data);700 BSL_SAL_FREE(encodeAsn1.data);
@@ -726,6 +733,7 @@ void SDV_BSL_ASN1_ENCODE_PRIKEY_BUFF_TC001(char *path, int fileType, Hex *asn1)
726 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);733 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
727 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);734 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);
728 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);735 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
736+ ASSERT_TRUE(TestIsErrStackEmpty());
729EXIT:737EXIT:
730 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);738 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
731 BSL_SAL_FREE(encodeAsn1.data);739 BSL_SAL_FREE(encodeAsn1.data);
@@ -773,6 +781,7 @@ void SDV_BSL_ASN1_ENCODE_ENCRYPTED_PRIKEY_BUFF_TC001(char *path, int fileType, i
773 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(decodeCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1Out),781 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(decodeCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1Out),
774 CRYPT_SUCCESS);782 CRYPT_SUCCESS);
775 ASSERT_COMPARE("asn1 compare.", encodeAsn1Out.data, encodeAsn1Out.dataLen, asn1->x, asn1->len);783 ASSERT_COMPARE("asn1 compare.", encodeAsn1Out.data, encodeAsn1Out.dataLen, asn1->x, asn1->len);
784+ ASSERT_TRUE(TestIsErrStackEmpty());
776 785
777EXIT:786EXIT:
778 CRYPT_EAL_PkeyFreeCtx(decodeCtx);787 CRYPT_EAL_PkeyFreeCtx(decodeCtx);
@@ -862,6 +871,7 @@ void SDV_BSL_ASN1_ENCODE_ENCRYPTED_PRIKEY_BUFF_TC002(int fileType, int keyType,
862 871 
863 /* encode again -> encrypted pkcs8 */872 /* encode again -> encrypted pkcs8 */
864 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(decodeCtx, &paramEx, BSL_FORMAT_ASN1, fileType, &reEncPk8), CRYPT_SUCCESS);873 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(decodeCtx, &paramEx, BSL_FORMAT_ASN1, fileType, &reEncPk8), CRYPT_SUCCESS);
874+ ASSERT_TRUE(TestIsErrStackEmpty());
865 875 
866EXIT:876EXIT:
867 BSL_SAL_Free(signdata);877 BSL_SAL_Free(signdata);
@@ -890,6 +900,7 @@ void SDV_BSL_ASN1_ENCODE_PRAPSSPRIKEY_BUFF_TC001(char *path, int fileType, int s
890 CRYPT_SUCCESS);900 CRYPT_SUCCESS);
891 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);901 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);
892 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);902 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
903+ ASSERT_TRUE(TestIsErrStackEmpty());
893EXIT:904EXIT:
894 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);905 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
895 BSL_SAL_FREE(encodeAsn1.data);906 BSL_SAL_FREE(encodeAsn1.data);
@@ -936,6 +947,7 @@ void SDV_BSL_ASN1_ENCODE_AND_DECODE_RSAPSS_PUBLICKEY_TC001(int keyLen, int saltL
936 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encode, NULL, 0, &decodedPkey),947 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encode, NULL, 0, &decodedPkey),
937 CRYPT_SUCCESS);948 CRYPT_SUCCESS);
938 ASSERT_TRUE(decodedPkey != NULL);949 ASSERT_TRUE(decodedPkey != NULL);
950+ ASSERT_TRUE(TestIsErrStackEmpty());
939EXIT:951EXIT:
940 TestRandDeInit();952 TestRandDeInit();
941 CRYPT_EAL_PkeyFreeCtx(pkey);953 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -955,6 +967,7 @@ void SDV_BSL_ASN1_ENCODE_RSAPSS_PUBLICKEY_BUFF_TC002(char *path, Hex *asn1)
955 CRYPT_SUCCESS);967 CRYPT_SUCCESS);
956 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encodeAsn1), CRYPT_SUCCESS);968 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encodeAsn1), CRYPT_SUCCESS);
957 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);969 ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
970+ ASSERT_TRUE(TestIsErrStackEmpty());
958EXIT:971EXIT:
959 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);972 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
960 BSL_SAL_FREE(encodeAsn1.data);973 BSL_SAL_FREE(encodeAsn1.data);
@@ -1003,8 +1016,10 @@ void SDV_BSL_ASN1_PARSE_BUFF_PROVIDER_TC001(char *formatStr, char *typeStr, char
1003 CRYPT_EAL_Init(CRYPT_EAL_INIT_CPU|CRYPT_EAL_INIT_PROVIDER|CRYPT_EAL_INIT_PROVIDER_RAND);1016 CRYPT_EAL_Init(CRYPT_EAL_INIT_CPU|CRYPT_EAL_INIT_PROVIDER|CRYPT_EAL_INIT_PROVIDER_RAND);
1004 encode.data = data;1017 encode.data = data;
1005 encode.dataLen = dataLen;1018 encode.dataLen = dataLen;
1019+ TestErrClear();
1006 ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, typeStr, &encode, &pass,1020 ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, typeStr, &encode, &pass,
1007 &pkeyCtx), CRYPT_SUCCESS);1021 &pkeyCtx), CRYPT_SUCCESS);
1022+ ASSERT_TRUE(TestIsErrStackEmpty());
1008#endif1023#endif
1009EXIT:1024EXIT:
1010 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);1025 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -1044,6 +1059,7 @@ void SDV_BSL_ASN1_PARSE_BUFF_PROVIDER_TC002(char *providerPath, char *providerNa
1044 1059 
1045 ASSERT_EQ(CRYPT_EAL_ProviderDecodeFileKey(libCtx, attrName, BSL_CID_UNKNOWN, formatStr, typeStr, path,1060 ASSERT_EQ(CRYPT_EAL_ProviderDecodeFileKey(libCtx, attrName, BSL_CID_UNKNOWN, formatStr, typeStr, path,
1046 NULL, &pkeyCtx), CRYPT_SUCCESS);1061 NULL, &pkeyCtx), CRYPT_SUCCESS);
1062+ ASSERT_TRUE(TestIsErrStackEmpty());
1047EXIT:1063EXIT:
1048 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);1064 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
1049 CRYPT_EAL_LibCtxFree(libCtx);1065 CRYPT_EAL_LibCtxFree(libCtx);
Mtestcode/sdv/testcase/crypto/encode/test_suite_sdv_encode.c+5-0
@@ -56,6 +56,7 @@ void SDV_ENCODE_SIGN_BN_FUNC_TC001(Hex *r, Hex *s, Hex *expect)
56 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);56 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);
57 ASSERT_EQ(encodeLen, expect->len);57 ASSERT_EQ(encodeLen, expect->len);
58 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);58 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
59+ ASSERT_TRUE(TestIsErrStackEmpty());
59 60 
60EXIT:61EXIT:
61 BN_Destroy(bnR);62 BN_Destroy(bnR);
@@ -190,6 +191,7 @@ void SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *x, Hex *y, Hex *hash, Hex *ciph
190 if (ret == CRYPT_SUCCESS) {191 if (ret == CRYPT_SUCCESS) {
191 ASSERT_EQ(encodeLen, expect->len);192 ASSERT_EQ(encodeLen, expect->len);
192 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);193 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
194+ ASSERT_TRUE(TestIsErrStackEmpty());
193 }195 }
194 196 
195EXIT:197EXIT:
@@ -288,6 +290,7 @@ void SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *encode, Hex *expectX, Hex *expe
288 ASSERT_TRUE(memcmp(data.y + (data.yLen - expectY->len), expectY->x, expectY->len) == 0);290 ASSERT_TRUE(memcmp(data.y + (data.yLen - expectY->len), expectY->x, expectY->len) == 0);
289 ASSERT_TRUE(memcmp(data.hash, expectHash->x, data.hashLen) == 0);291 ASSERT_TRUE(memcmp(data.hash, expectHash->x, data.hashLen) == 0);
290 ASSERT_TRUE(memcmp(data.cipher, expectCipher->x, data.cipherLen) == 0);292 ASSERT_TRUE(memcmp(data.cipher, expectCipher->x, data.cipherLen) == 0);
293+ ASSERT_TRUE(TestIsErrStackEmpty());
291 }294 }
292 295 
293EXIT:296EXIT:
@@ -448,6 +451,7 @@ void SDV_ENCODE_DECODE_SIGN_COMBO_TC001(Hex *r, Hex *s)
448 ASSERT_EQ(BN_Bn2Bin(decS, sBuf, &sLen), CRYPT_SUCCESS);451 ASSERT_EQ(BN_Bn2Bin(decS, sBuf, &sLen), CRYPT_SUCCESS);
449 ASSERT_COMPARE("Compare r", rBuf, rLen, r->x, r->len);452 ASSERT_COMPARE("Compare r", rBuf, rLen, r->x, r->len);
450 ASSERT_COMPARE("Compare s", sBuf, sLen, s->x, s->len);453 ASSERT_COMPARE("Compare s", sBuf, sLen, s->x, s->len);
454+ ASSERT_TRUE(TestIsErrStackEmpty());
451 455 
452EXIT:456EXIT:
453 BSL_SAL_Free(encode);457 BSL_SAL_Free(encode);
@@ -502,6 +506,7 @@ void SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001(Hex *x, Hex *y, Hex *hash, Hex *c
502 ASSERT_COMPARE("Compare y", decData.y + (decData.yLen - y->len), y->len, y->x, y->len);506 ASSERT_COMPARE("Compare y", decData.y + (decData.yLen - y->len), y->len, y->x, y->len);
503 ASSERT_COMPARE("Compare hash", decData.hash, decData.hashLen, hash->x, hash->len);507 ASSERT_COMPARE("Compare hash", decData.hash, decData.hashLen, hash->x, hash->len);
504 ASSERT_COMPARE("Compare cipher", decData.cipher, decData.cipherLen, cipher->x, cipher->len);508 ASSERT_COMPARE("Compare cipher", decData.cipher, decData.cipherLen, cipher->x, cipher->len);
509+ ASSERT_TRUE(TestIsErrStackEmpty());
505 510 
506EXIT:511EXIT:
507 BSL_SAL_Free(encode);512 BSL_SAL_Free(encode);
Mtestcode/sdv/testcase/crypto/entropy/test_suite_sdv_entropy.c+29-0
@@ -339,6 +339,7 @@ void SDV_CRYPTO_ENTROPY_EsNormalTest(int alg, int size, int test)
339 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);339 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);
340 BSL_SAL_ThreadClose(thrd);340 BSL_SAL_ThreadClose(thrd);
341 BSL_SAL_ThreadClose(thrdget);341 BSL_SAL_ThreadClose(thrdget);
342+ ASSERT_TRUE(TestIsErrStackEmpty());
342EXIT:343EXIT:
343 CRYPT_EAL_EsFree(es);344 CRYPT_EAL_EsFree(es);
344 return;345 return;
@@ -373,6 +374,7 @@ void SDV_CRYPTO_ENTROPY_EsCtrlTest1(int type, int state, int excRes)
373 }374 }
374 if (excRes == 1) {375 if (excRes == 1) {
375 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) == CRYPT_SUCCESS);376 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) == CRYPT_SUCCESS);
377+ ASSERT_TRUE(TestIsErrStackEmpty());
376 } else {378 } else {
377 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) != CRYPT_SUCCESS);379 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) != CRYPT_SUCCESS);
378 }380 }
@@ -432,6 +434,7 @@ void SDV_CRYPTO_ENTROPY_EsCtrlTest2(void)
432 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);434 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
433 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_STATE, &flag, 1) == CRYPT_SUCCESS);435 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_STATE, &flag, 1) == CRYPT_SUCCESS);
434 ASSERT_TRUE(flag == true);436 ASSERT_TRUE(flag == true);
437+ ASSERT_TRUE(TestIsErrStackEmpty());
435 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) != CRYPT_SUCCESS);438 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) != CRYPT_SUCCESS);
436 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) != CRYPT_SUCCESS);439 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) != CRYPT_SUCCESS);
437 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&para, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);440 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&para, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);
@@ -516,6 +519,7 @@ void SDV_CRYPTO_ENTROPY_EsWithoutNsTest()
516 /* Not sufficient entropy to pass the test yet, will fix later */519 /* Not sufficient entropy to pass the test yet, will fix later */
517 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);520 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
518#endif521#endif
522+ ASSERT_TRUE(TestIsErrStackEmpty());
519 ASSERT_TRUE(CRYPT_EAL_EsInit(es) != CRYPT_SUCCESS);523 ASSERT_TRUE(CRYPT_EAL_EsInit(es) != CRYPT_SUCCESS);
520 CRYPT_EAL_NsPara para = {524 CRYPT_EAL_NsPara para = {
521 "aaa",525 "aaa",
@@ -618,7 +622,9 @@ void SDV_CRYPTO_ENTROPY_EsMultiNsTest()
618 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);622 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
619 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);623 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
620 uint8_t buf[32] = {0};624 uint8_t buf[32] = {0};
625+ // Error stack exists
621 ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == 32);626 ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == 32);
627+ ASSERT_TRUE(TestIsErrStackNotEmpty());
622 628 
623EXIT:629EXIT:
624 CRYPT_EAL_EsFree(es);630 CRYPT_EAL_EsFree(es);
@@ -685,6 +691,7 @@ void SDV_CRYPTO_ENTROPY_EsNsNumberTest(int number, int minEn, int expLen)
685 strcat_s((char *)(intptr_t)errPara.name, strlen(name) + 3, str);691 strcat_s((char *)(intptr_t)errPara.name, strlen(name) + 3, str);
686 if (iter >= 16) {692 if (iter >= 16) {
687 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);693 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);
694+ (void)TestErrClear();
688 } else {695 } else {
689 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);696 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
690 }697 }
@@ -693,6 +700,9 @@ void SDV_CRYPTO_ENTROPY_EsNsNumberTest(int number, int minEn, int expLen)
693 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);700 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
694 uint8_t buf[32] = {0};701 uint8_t buf[32] = {0};
695 ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == (uint32_t)expLen);702 ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == (uint32_t)expLen);
703+ if (expLen != 0) {
704+ ASSERT_TRUE(TestIsErrStackEmpty());
705+ }
696 706 
697EXIT:707EXIT:
698 BSL_SAL_Free((void *)(intptr_t)errPara.name);708 BSL_SAL_Free((void *)(intptr_t)errPara.name);
@@ -767,6 +777,7 @@ void SDV_CRYPTO_ENTROPY_MutiTest(void)
767 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);777 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);
768 BSL_SAL_ThreadClose(thrdget);778 BSL_SAL_ThreadClose(thrdget);
769 }779 }
780+ ASSERT_TRUE(TestIsErrStackEmpty());
770 781 
771EXIT:782EXIT:
772 CRYPT_EAL_EsFree(es);783 CRYPT_EAL_EsFree(es);
@@ -799,6 +810,7 @@ void SDV_CRYPTO_ENTROPY_MutiBeforeInitTest(void)
799 BSL_SAL_ThreadId thrd;810 BSL_SAL_ThreadId thrd;
800 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);811 ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
801 BSL_SAL_ThreadClose(thrd);812 BSL_SAL_ThreadClose(thrd);
813+ ASSERT_TRUE(TestIsErrStackEmpty());
802 814 
803EXIT:815EXIT:
804 CRYPT_EAL_EsFree(es);816 CRYPT_EAL_EsFree(es);
@@ -843,6 +855,7 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0001(int enableTest)
843 uint8_t buf[8192] = {0};855 uint8_t buf[8192] = {0};
844 uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);856 uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
845 ASSERT_TRUE(resLen == 64);857 ASSERT_TRUE(resLen == 64);
858+ ASSERT_TRUE(TestIsErrStackEmpty());
846EXIT:859EXIT:
847 CRYPT_EAL_EsFree(es);860 CRYPT_EAL_EsFree(es);
848 return;861 return;
@@ -907,6 +920,7 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0002(int enableTest)
907 ASSERT_TRUE(resLen == 32);920 ASSERT_TRUE(resLen == 32);
908 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);921 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
909 ASSERT_EQ(size, 0);922 ASSERT_EQ(size, 0);
923+ ASSERT_TRUE(TestIsErrStackEmpty());
910EXIT:924EXIT:
911 CRYPT_EAL_EsFree(es);925 CRYPT_EAL_EsFree(es);
912 return;926 return;
@@ -953,6 +967,7 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0003(int alg, int enableTest)
953 uint8_t buf[8192] = {0};967 uint8_t buf[8192] = {0};
954 uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);968 uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
955 ASSERT_TRUE(resLen == expectGetLen);969 ASSERT_TRUE(resLen == expectGetLen);
970+ ASSERT_TRUE(TestIsErrStackEmpty());
956EXIT:971EXIT:
957 CRYPT_EAL_EsFree(es);972 CRYPT_EAL_EsFree(es);
958 return;973 return;
@@ -990,6 +1005,7 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0004(int enableTest)
990 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);1005 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);
991#endif1006#endif
992 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);1007 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);
1008+ (void)TestErrClear();
993 CRYPT_EAL_NsPara norPara1 = {1009 CRYPT_EAL_NsPara norPara1 = {
994 "normal-ns",1010 "normal-ns",
995 enableTest,1011 enableTest,
@@ -1041,7 +1057,9 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0004(int enableTest)
1041 ENTROPY_EsDeinit(es->es);1057 ENTROPY_EsDeinit(es->es);
1042 (void)BSL_SAL_ThreadUnlock(es->lock);1058 (void)BSL_SAL_ThreadUnlock(es->lock);
1043 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"normal-ns", 10) == CRYPT_SUCCESS);1059 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"normal-ns", 10) == CRYPT_SUCCESS);
1060+ ASSERT_TRUE(TestIsErrStackEmpty());
1044 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);1061 ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);
1062+ (void)TestErrClear();
1045 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara2, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);1063 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara2, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
1046#ifdef HITLS_BSL_SAL_DARWIN1064#ifdef HITLS_BSL_SAL_DARWIN
1047 /* On Darwin, re-disable health testing before second EsInit with timestamp NS */1065 /* On Darwin, re-disable health testing before second EsInit with timestamp NS */
@@ -1051,6 +1069,7 @@ void SDV_CRYPTO_ENTROPY_ES_FUNC_0004(int enableTest)
1051 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);1069 ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
1052 resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);1070 resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
1053 ASSERT_TRUE(resLen == expectGetLen);1071 ASSERT_TRUE(resLen == expectGetLen);
1072+ ASSERT_TRUE(TestIsErrStackEmpty());
1054EXIT:1073EXIT:
1055 CRYPT_EAL_EsFree(es);1074 CRYPT_EAL_EsFree(es);
1056 return;1075 return;
@@ -1259,6 +1278,7 @@ void SDV_CRYPTO_EAL_SEEDPOOL_EntropySumTest(int minEntropy1, int minEntropy2, in
1259 ASSERT_TRUE(buf != NULL);1278 ASSERT_TRUE(buf != NULL);
1260 }1279 }
1261 ASSERT_TRUE(enctx.entSum == (uint32_t)exp);1280 ASSERT_TRUE(enctx.entSum == (uint32_t)exp);
1281+ ASSERT_TRUE(TestIsErrStackEmpty());
1262EXIT:1282EXIT:
1263 BSL_SAL_Free(buf);1283 BSL_SAL_Free(buf);
1264 EAL_EntropyFreeCtx(ctx);1284 EAL_EntropyFreeCtx(ctx);
@@ -1321,6 +1341,7 @@ void SDV_CRYPTO_SEEDPOOL_DrbgTest(int isNull, int algId)
1321 CRYPT_EAL_RandDeinit();1341 CRYPT_EAL_RandDeinit();
1322 ASSERT_TRUE(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)algId, &meth, (void *)pool, NULL, 0) == CRYPT_SUCCESS);1342 ASSERT_TRUE(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)algId, &meth, (void *)pool, NULL, 0) == CRYPT_SUCCESS);
1323 ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 16) == CRYPT_SUCCESS);1343 ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 16) == CRYPT_SUCCESS);
1344+ ASSERT_TRUE(TestIsErrStackEmpty());
1324EXIT:1345EXIT:
1325 CRYPT_EAL_RandDeinit();1346 CRYPT_EAL_RandDeinit();
1326 CRYPT_EAL_SeedPoolFree(pool);1347 CRYPT_EAL_SeedPoolFree(pool);
@@ -1364,6 +1385,7 @@ void SDV_CRYPTO_ENTROPY_DrbgTest(void)
1364 CRYPT_RandSeedMethod meth = {GetEntropyTest, CleanEntropyTest, GetNonceTest, CleanNonceTest};1385 CRYPT_RandSeedMethod meth = {GetEntropyTest, CleanEntropyTest, GetNonceTest, CleanNonceTest};
1365 ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &meth, (void *)es, NULL, 0) == CRYPT_SUCCESS);1386 ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &meth, (void *)es, NULL, 0) == CRYPT_SUCCESS);
1366 ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 256) == CRYPT_SUCCESS);1387 ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 256) == CRYPT_SUCCESS);
1388+ ASSERT_TRUE(TestIsErrStackEmpty());
1367EXIT:1389EXIT:
1368 CRYPT_EAL_RandDeinit();1390 CRYPT_EAL_RandDeinit();
1369 CRYPT_EAL_EsFree(es);1391 CRYPT_EAL_EsFree(es);
@@ -1397,6 +1419,7 @@ void SDV_CRYPTO_SEEDPOOL_MutiTest(void)
1397 ASSERT_TRUE(pthread_create(&thrd, NULL, DrbgSeedTest, pool) == 0);1419 ASSERT_TRUE(pthread_create(&thrd, NULL, DrbgSeedTest, pool) == 0);
1398 pthread_join(thrd, NULL);1420 pthread_join(thrd, NULL);
1399 }1421 }
1422+ ASSERT_TRUE(TestIsErrStackEmpty());
1400 1423 
1401EXIT:1424EXIT:
1402 CRYPT_EAL_SeedPoolFree(pool);1425 CRYPT_EAL_SeedPoolFree(pool);
@@ -1662,6 +1685,7 @@ void SDV_CRYPTO_SEEDPOOL_CompleteTest(void)
1662 uint8_t out[16] = {0};1685 uint8_t out[16] = {0};
1663 ASSERT_TRUE(CRYPT_EAL_Drbgbytes(rndCtx, out, 16) == CRYPT_SUCCESS);1686 ASSERT_TRUE(CRYPT_EAL_Drbgbytes(rndCtx, out, 16) == CRYPT_SUCCESS);
1664 ASSERT_TRUE(CRYPT_EAL_DrbgSeed(rndCtx) == CRYPT_SUCCESS);1687 ASSERT_TRUE(CRYPT_EAL_DrbgSeed(rndCtx) == CRYPT_SUCCESS);
1688+ ASSERT_TRUE(TestIsErrStackEmpty());
1665 1689 
1666EXIT:1690EXIT:
1667 CRYPT_EAL_DrbgDeinit(rndCtx);1691 CRYPT_EAL_DrbgDeinit(rndCtx);
@@ -1741,6 +1765,7 @@ void HITLS_SDV_DRBG_GM_FUNC_TC019(int isCreateNullPool, int isPhysical, int minE
1741 uint32_t entropy = (uint32_t)entropyL;1765 uint32_t entropy = (uint32_t)entropyL;
1742 ctx = EAL_EntropyNewCtx(pool, isNpesUsed, minLen, maxLen, entropy);1766 ctx = EAL_EntropyNewCtx(pool, isNpesUsed, minLen, maxLen, entropy);
1743 ASSERT_TRUE(ctx != NULL);1767 ASSERT_TRUE(ctx != NULL);
1768+ ASSERT_TRUE(TestIsErrStackEmpty());
1744 if (isCreateNullPool && !isValid) {1769 if (isCreateNullPool && !isValid) {
1745 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SEED_POOL_NOT_MEET_REQUIREMENT);1770 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SEED_POOL_NOT_MEET_REQUIREMENT);
1746 } else {1771 } else {
@@ -1856,6 +1881,7 @@ void HITLS_SDV_DRBG_GM_FUNC_TC039(int isCreateNullPool, int isPhysical, int minE
1856 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);1881 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
1857 ASSERT_TRUE(ctx != NULL);1882 ASSERT_TRUE(ctx != NULL);
1858 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);1883 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
1884+ ASSERT_TRUE(TestIsErrStackEmpty());
1859EXIT:1885EXIT:
1860 CRYPT_EAL_SeedPoolFree(pool);1886 CRYPT_EAL_SeedPoolFree(pool);
1861 EAL_EntropyFreeCtx(ctx);1887 EAL_EntropyFreeCtx(ctx);
@@ -1965,6 +1991,7 @@ void HITLS_SDV_DRBG_GM_FUNC_TC067(int isCreateNullPool, int isPhysical, int minE
1965 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);1991 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);
1966 } else {1992 } else {
1967 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);1993 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
1994+ ASSERT_TRUE(TestIsErrStackEmpty());
1968 }1995 }
1969EXIT:1996EXIT:
1970 CRYPT_EAL_SeedPoolFree(pool);1997 CRYPT_EAL_SeedPoolFree(pool);
@@ -2077,6 +2104,7 @@ void HITLS_SDV_DRBG_GM_FUNC_TC071(int isCreateNullPool, int isPhysical, int minE
2077 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);2104 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
2078 ASSERT_TRUE(ctx != NULL);2105 ASSERT_TRUE(ctx != NULL);
2079 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);2106 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
2107+ ASSERT_TRUE(TestIsErrStackEmpty());
2080EXIT:2108EXIT:
2081 CRYPT_EAL_SeedPoolFree(pool);2109 CRYPT_EAL_SeedPoolFree(pool);
2082 EAL_EntropyFreeCtx(ctx);2110 EAL_EntropyFreeCtx(ctx);
@@ -2197,6 +2225,7 @@ void HITLS_SDV_DRBG_GM_FUNC_TC051(int isCreateNullPool, int isPhysical, int minE
2197 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);2225 ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
2198 ASSERT_TRUE(ctx != NULL);2226 ASSERT_TRUE(ctx != NULL);
2199 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);2227 ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
2228+ ASSERT_TRUE(TestIsErrStackEmpty());
2200EXIT:2229EXIT:
2201 CRYPT_EAL_SeedPoolFree(pool);2230 CRYPT_EAL_SeedPoolFree(pool);
2202 EAL_EntropyFreeCtx(ctx);2231 EAL_EntropyFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/gcm/test_suite_sdv_gcm.c+2-0
@@ -269,6 +269,7 @@ void SDV_CRYPTO_GCM_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt,
269 269 
270 ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);270 ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);
271 ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);271 ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);
272+ ASSERT_TRUE(TestIsErrStackEmpty());
272 273 
273EXIT:274EXIT:
274 CRYPT_EAL_CipherFreeCtx(ctx);275 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -319,6 +320,7 @@ void SDV_CRYPTO_GCM_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt,
319 for (uint32_t i = 0; i < threadNum; i++) {320 for (uint32_t i = 0; i < threadNum; i++) {
320 pthread_join(thrd[i], NULL);321 pthread_join(thrd[i], NULL);
321 }322 }
323+ ASSERT_TRUE(TestIsErrStackEmpty());
322 324 
323EXIT:325EXIT:
324 return;326 return;
Mtestcode/sdv/testcase/crypto/gmac/test_suite_sdv_eal_gmac.c+3-0
@@ -46,6 +46,7 @@ void SDV_CRYPTO_EAL_GMAC_FUNC_TC001(int id, Hex *key, Hex *iv, Hex *msg, Hex *ma
46 ASSERT_TRUE(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len) == CRYPT_SUCCESS);46 ASSERT_TRUE(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len) == CRYPT_SUCCESS);
47 ASSERT_TRUE(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen) == CRYPT_SUCCESS);47 ASSERT_TRUE(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen) == CRYPT_SUCCESS);
48 ASSERT_TRUE(memcmp(output, mac->x, outLen) == 0);48 ASSERT_TRUE(memcmp(output, mac->x, outLen) == 0);
49+ ASSERT_TRUE(TestIsErrStackEmpty());
49 50 
50EXIT:51EXIT:
51 free(output);52 free(output);
@@ -210,6 +211,7 @@ void SDV_CRYPT_EAL_GMAC_SAMEADDR_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *d
210 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, out, data->len), CRYPT_SUCCESS);211 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, out, data->len), CRYPT_SUCCESS);
211 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);212 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);
212 ASSERT_COMPARE("gmac result cmp", out, tagLen, mac->x, mac->len);213 ASSERT_COMPARE("gmac result cmp", out, tagLen, mac->x, mac->len);
214+ ASSERT_TRUE(TestIsErrStackEmpty());
213 215 
214EXIT:216EXIT:
215 free(out);217 free(out);
@@ -258,6 +260,7 @@ void SDV_CRYPT_EAL_GMAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *iv,
258 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);260 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);
259 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);261 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);
260 ASSERT_COMPARE("mac result cmp", out, tagLen, mac->x, mac->len);262 ASSERT_COMPARE("mac result cmp", out, tagLen, mac->x, mac->len);
263+ ASSERT_TRUE(TestIsErrStackEmpty());
261 264 
262EXIT:265EXIT:
263 free(out);266 free(out);
Mtestcode/sdv/testcase/crypto/hkdf/test_suite_sdv_eal_kdf_hkdf.c+4-0
@@ -162,6 +162,7 @@ void SDV_CRYPT_EAL_KDF_HKDF_FUN_TC001(int algId, Hex *key, Hex *salt, Hex *info,
162 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);162 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
163 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);163 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
164 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);164 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
165+ ASSERT_TRUE(TestIsErrStackEmpty());
165EXIT:166EXIT:
166 if (out != NULL) {167 if (out != NULL) {
167 free(out);168 free(out);
@@ -210,6 +211,7 @@ void SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *salt,
210 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);211 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
211 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);212 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
212 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);213 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
214+ ASSERT_TRUE(TestIsErrStackEmpty());
213EXIT:215EXIT:
214 if (out != NULL) {216 if (out != NULL) {
215 free(out);217 free(out);
@@ -245,6 +247,7 @@ void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC001(int algId, Hex *key, Hex *salt, Hex *
245 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);247 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);
246 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);248 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);
247 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);249 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
250+ ASSERT_TRUE(TestIsErrStackEmpty());
248EXIT:251EXIT:
249 if (out != NULL) {252 if (out != NULL) {
250 free(out);253 free(out);
@@ -282,6 +285,7 @@ void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC002(int algId, Hex *key, Hex *salt, Hex *
282 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);285 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);
283 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);286 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);
284 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);287 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
288+ ASSERT_TRUE(TestIsErrStackEmpty());
285EXIT:289EXIT:
286 if (out != NULL) {290 if (out != NULL) {
287 free(out);291 free(out);
Mtestcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.c+3-0
@@ -338,6 +338,7 @@ void SDV_CRYPT_EAL_HMAC_FUN_TC001(int algId, Hex *key, Hex *data, Hex *vecMac)
338 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);338 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
339 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);339 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
340 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);340 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
341+ ASSERT_TRUE(TestIsErrStackEmpty());
341EXIT:342EXIT:
342 CRYPT_EAL_MacFreeCtx(ctx);343 CRYPT_EAL_MacFreeCtx(ctx);
343 free(mac);344 free(mac);
@@ -378,6 +379,7 @@ void SDV_CRYPT_EAL_HMAC_FUN_TC002(int algId, Hex *key, Hex *data1, Hex *data2, H
378 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);379 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
379 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);380 ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
380 CRYPT_EAL_MacDeinit(ctx);381 CRYPT_EAL_MacDeinit(ctx);
382+ ASSERT_TRUE(TestIsErrStackEmpty());
381EXIT:383EXIT:
382 CRYPT_EAL_MacFreeCtx(ctx);384 CRYPT_EAL_MacFreeCtx(ctx);
383 free(mac);385 free(mac);
@@ -455,6 +457,7 @@ void SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *data,
455 CRYPT_EAL_MacDeinit(ctx);457 CRYPT_EAL_MacDeinit(ctx);
456 ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);458 ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
457 ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);459 ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
460+ ASSERT_TRUE(TestIsErrStackEmpty());
458EXIT:461EXIT:
459 CRYPT_EAL_MacFreeCtx(ctx);462 CRYPT_EAL_MacFreeCtx(ctx);
460 BSL_SAL_FREE(mac);463 BSL_SAL_FREE(mac);
Mtestcode/sdv/testcase/crypto/hpke/test_suite_sdv_eal_hpke.c+10-0
@@ -199,6 +199,7 @@ void SDV_CRYPT_EAL_HPKE_KEM_TC001(int mode, int kemId, int kdfId, int aeadId, He
199 199 
200 ASSERT_EQ(CRYPT_EAL_HpkeGetSharedSecret(ctxR, sharedSecretBuf, &buffLen), CRYPT_SUCCESS);200 ASSERT_EQ(CRYPT_EAL_HpkeGetSharedSecret(ctxR, sharedSecretBuf, &buffLen), CRYPT_SUCCESS);
201 ASSERT_COMPARE("hpke R sharedSecret cmp", sharedSecretBuf, buffLen, sharedSecret->x, sharedSecret->len);201 ASSERT_COMPARE("hpke R sharedSecret cmp", sharedSecretBuf, buffLen, sharedSecret->x, sharedSecret->len);
202+ ASSERT_TRUE(TestIsErrStackEmpty());
202 203 
203EXIT:204EXIT:
204 CRYPT_EAL_HpkeFreeCtx(ctxS);205 CRYPT_EAL_HpkeFreeCtx(ctxS);
@@ -248,6 +249,7 @@ void SDV_CRYPT_EAL_HPKE_AEAD_TC001(int mode, int kemId, int kdfId, int aeadId, H
248 ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);249 ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);
249 ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);250 ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);
250 ASSERT_EQ(nextSeq, seq + 1);251 ASSERT_EQ(nextSeq, seq + 1);
252+ ASSERT_TRUE(TestIsErrStackEmpty());
251 253 
252EXIT:254EXIT:
253 CRYPT_EAL_HpkeFreeCtx(ctxS);255 CRYPT_EAL_HpkeFreeCtx(ctxS);
@@ -288,6 +290,7 @@ void SDV_CRYPT_EAL_HPKE_EXPORT_SECRET_TC001(int mode, int kemId, int kdfId, int
288 memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);290 memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);
289 ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);291 ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
290 ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);292 ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
293+ ASSERT_TRUE(TestIsErrStackEmpty());
291EXIT:294EXIT:
292 CRYPT_EAL_HpkeFreeCtx(ctxS);295 CRYPT_EAL_HpkeFreeCtx(ctxS);
293 CRYPT_EAL_HpkeFreeCtx(ctxR);296 CRYPT_EAL_HpkeFreeCtx(ctxR);
@@ -381,6 +384,7 @@ static int32_t HpkeRandomTest(CRYPT_HPKE_Mode mode, CRYPT_HPKE_KEM_AlgId kemId,
381 uint8_t pskIdData[16] = { 0 };384 uint8_t pskIdData[16] = { 0 };
382 pskId.x = pskIdData;385 pskId.x = pskIdData;
383 CRYPT_EAL_Randbytes(pskId.x, pskId.len);386 CRYPT_EAL_Randbytes(pskId.x, pskId.len);
387+ (void)TestErrClear();
384 388 
385 // prepare Recipient key389 // prepare Recipient key
386 ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pkeyE), CRYPT_SUCCESS);390 ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pkeyE), CRYPT_SUCCESS);
@@ -407,6 +411,7 @@ static int32_t HpkeRandomTest(CRYPT_HPKE_Mode mode, CRYPT_HPKE_KEM_AlgId kemId,
407 if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){411 if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
408 ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_SUCCESS);412 ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_SUCCESS);
409 }413 }
414+ ASSERT_TRUE(TestIsErrStackEmpty());
410 415 
411 if (mode != CRYPT_HPKE_MODE_PSK && mode != CRYPT_HPKE_MODE_AUTH_PSK) {416 if (mode != CRYPT_HPKE_MODE_PSK && mode != CRYPT_HPKE_MODE_AUTH_PSK) {
412 ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_HPKE_ERR_CALL);417 ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_HPKE_ERR_CALL);
@@ -415,6 +420,7 @@ static int32_t HpkeRandomTest(CRYPT_HPKE_Mode mode, CRYPT_HPKE_KEM_AlgId kemId,
415 if(mode != CRYPT_HPKE_MODE_AUTH && mode != CRYPT_HPKE_MODE_AUTH_PSK){420 if(mode != CRYPT_HPKE_MODE_AUTH && mode != CRYPT_HPKE_MODE_AUTH_PSK){
416 ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_HPKE_ERR_CALL);421 ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_HPKE_ERR_CALL);
417 }422 }
423+ (void)TestErrClear();
418 424 
419 if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){425 if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
420 ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_SUCCESS);426 ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_SUCCESS);
@@ -499,6 +505,7 @@ void SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001(void)
499 }505 }
500 }506 }
501 }507 }
508+ ASSERT_TRUE(TestIsErrStackEmpty());
502EXIT:509EXIT:
503 TestRandDeInit();510 TestRandDeInit();
504 return;511 return;
@@ -905,6 +912,7 @@ void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC001(int mode, int kemId, int kdfId, int
905 ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);912 ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);
906 ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);913 ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);
907 ASSERT_EQ(nextSeq, seq + 1);914 ASSERT_EQ(nextSeq, seq + 1);
915+ ASSERT_TRUE(TestIsErrStackEmpty());
908 916 
909EXIT:917EXIT:
910 CRYPT_EAL_HpkeFreeCtx(ctxS);918 CRYPT_EAL_HpkeFreeCtx(ctxS);
@@ -942,6 +950,7 @@ void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC002(int mode, int kemId, int kdfId, int
942 memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);950 memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);
943 ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);951 ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
944 ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);952 ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
953+ ASSERT_TRUE(TestIsErrStackEmpty());
945EXIT:954EXIT:
946 CRYPT_EAL_HpkeFreeCtx(ctxS);955 CRYPT_EAL_HpkeFreeCtx(ctxS);
947 CRYPT_EAL_HpkeFreeCtx(ctxR);956 CRYPT_EAL_HpkeFreeCtx(ctxR);
@@ -985,6 +994,7 @@ void SDV_CRYPT_EAL_HPKE_GENERATE_KEY_PAIR_TC001(void)
985 }994 }
986 }995 }
987 }996 }
997+ ASSERT_TRUE(TestIsErrStackEmpty());
988EXIT:998EXIT:
989 TestRandDeInit();999 TestRandDeInit();
990}1000}
Mtestcode/sdv/testcase/crypto/hybridkem/test_suite_sdv_hybridkem.c+2-0
@@ -147,6 +147,7 @@ void SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC001(int algid, int type, int isProvi
147 147 
148 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);148 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);
149 ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);149 ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);
150+ ASSERT_TRUE(TestIsErrStackEmpty());
150EXIT:151EXIT:
151 BSL_SAL_Free(ek.key.kemEk.data);152 BSL_SAL_Free(ek.key.kemEk.data);
152 BSL_SAL_Free(ciphertext);153 BSL_SAL_Free(ciphertext);
@@ -307,6 +308,7 @@ void SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC002(int algid, int type, int isProvi
307 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctxB, ciphertext, &cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);308 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctxB, ciphertext, &cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);
308 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyA, &sharedLenA), CRYPT_SUCCESS);309 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyA, &sharedLenA), CRYPT_SUCCESS);
309 ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);310 ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);
311+ ASSERT_TRUE(TestIsErrStackEmpty());
310EXIT:312EXIT:
311 BSL_SAL_Free(ciphertext);313 BSL_SAL_Free(ciphertext);
312 BSL_SAL_Free(sharedKeyA);314 BSL_SAL_Free(sharedKeyA);
Mtestcode/sdv/testcase/crypto/kdf_tls12/test_suite_sdv_eal_kdf_tls12.c+2-0
@@ -135,6 +135,7 @@ void SDV_CRYPT_EAL_KDF_TLS12_FUN_TC001(int algId, Hex *key, Hex *label, Hex *see
135 135 
136 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);136 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
137 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);137 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
138+ ASSERT_TRUE(TestIsErrStackEmpty());
138EXIT:139EXIT:
139 if (out != NULL) {140 if (out != NULL) {
140 free(out);141 free(out);
@@ -180,6 +181,7 @@ void SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *l
180 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);181 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
181 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);182 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
182 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);183 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
184+ ASSERT_TRUE(TestIsErrStackEmpty());
183EXIT:185EXIT:
184 if (out != NULL) {186 if (out != NULL) {
185 free(out);187 free(out);
Mtestcode/sdv/testcase/crypto/md5/test_suite_sdv_eal_md5.c+8-0
@@ -144,6 +144,7 @@ void SDV_CRYPTO_MD5_FUNC_TC001(Hex *hash)
144 ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);144 ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
145 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);145 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
146 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);146 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
147+ ASSERT_TRUE(TestIsErrStackEmpty());
147 148 
148EXIT:149EXIT:
149 CRYPT_EAL_MdFreeCtx(md5Ctx);150 CRYPT_EAL_MdFreeCtx(md5Ctx);
@@ -181,6 +182,7 @@ void SDV_CRYPTO_MD5_FUNC_TC002(Hex *msg, Hex *hash)
181 182
182 ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_MD5, msg->x, msg->len, output, &outLen), CRYPT_SUCCESS);183 ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_MD5, msg->x, msg->len, output, &outLen), CRYPT_SUCCESS);
183 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);184 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
185+ ASSERT_TRUE(TestIsErrStackEmpty());
184EXIT:186EXIT:
185 CRYPT_EAL_MdFreeCtx(md5Ctx);187 CRYPT_EAL_MdFreeCtx(md5Ctx);
186}188}
@@ -236,6 +238,7 @@ void SDV_CRYPTO_MD5_FUNC_TC003(void)
236 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);238 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
237 239 
238 ASSERT_COMPARE("md5", out1, outLen, out2, outLen);240 ASSERT_COMPARE("md5", out1, outLen, out2, outLen);
241+ ASSERT_TRUE(TestIsErrStackEmpty());
239EXIT:242EXIT:
240 CRYPT_EAL_MdFreeCtx(ctx1);243 CRYPT_EAL_MdFreeCtx(ctx1);
241 CRYPT_EAL_MdFreeCtx(ctx2);244 CRYPT_EAL_MdFreeCtx(ctx2);
@@ -275,6 +278,7 @@ void SDV_CRYPTO_MD5_FUNC_TC004(Hex *data1, Hex *data2, Hex *data3, Hex *hash)
275 ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);278 ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
276 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);279 ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
277 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);280 ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
281+ ASSERT_TRUE(TestIsErrStackEmpty());
278EXIT:282EXIT:
279 CRYPT_EAL_MdFreeCtx(md5Ctx);283 CRYPT_EAL_MdFreeCtx(md5Ctx);
280}284}
@@ -320,6 +324,7 @@ void SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
320 ASSERT_TRUE(cpyCtx != NULL);324 ASSERT_TRUE(cpyCtx != NULL);
321 ASSERT_TRUE(dupCtx == NULL);325 ASSERT_TRUE(dupCtx == NULL);
322 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);326 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
327+ TestErrClear();
323 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);328 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
324 329 
325 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);330 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
@@ -337,6 +342,7 @@ void SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
337 342 
338 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));343 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
339 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);344 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
345+ ASSERT_TRUE(TestIsErrStackEmpty());
340 346 
341EXIT:347EXIT:
342 CRYPT_EAL_MdFreeCtx(ctx);348 CRYPT_EAL_MdFreeCtx(ctx);
@@ -370,6 +376,7 @@ void SDV_CRYPTO_MD5_FUNC_TC005(int id, Hex *msg, Hex *hash)
370 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);376 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
371 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);377 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
372 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);378 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
379+ ASSERT_TRUE(TestIsErrStackEmpty());
373 380
374EXIT:381EXIT:
375 CRYPT_EAL_MdFreeCtx(ctx);382 CRYPT_EAL_MdFreeCtx(ctx);
@@ -405,6 +412,7 @@ void SDV_CRYPT_EAL_MD_MD5_FUNC_TC001(int algId, Hex *data, Hex *hash)
405 for (uint32_t i = 0; i < threadNum; i++) {412 for (uint32_t i = 0; i < threadNum; i++) {
406 pthread_join(thrd[i], NULL);413 pthread_join(thrd[i], NULL);
407 }414 }
415+ ASSERT_TRUE(TestIsErrStackEmpty());
408 416 
409EXIT:417EXIT:
410 return;418 return;
Mtestcode/sdv/testcase/crypto/mldsa/test_suite_sdv_mldsa.c+7-0
@@ -370,6 +370,7 @@ void SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002(int type, Hex *seed, Hex *testPrvKey,
370 ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);370 ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
371 ASSERT_EQ(ret, CRYPT_SUCCESS);371 ASSERT_EQ(ret, CRYPT_SUCCESS);
372 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);372 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
373+ ASSERT_TRUE(TestIsErrStackEmpty());
373EXIT:374EXIT:
374 CRYPT_EAL_PkeyFreeCtx(ctx);375 CRYPT_EAL_PkeyFreeCtx(ctx);
375 BSL_SAL_FREE(out);376 BSL_SAL_FREE(out);
@@ -424,6 +425,7 @@ void SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002(int type, Hex *testPubKey, Hex *msg,
424 ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);425 ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
425 if (res == 0) {426 if (res == 0) {
426 ASSERT_EQ(ret, CRYPT_SUCCESS);427 ASSERT_EQ(ret, CRYPT_SUCCESS);
428+ ASSERT_TRUE(TestIsErrStackEmpty());
427 } else {429 } else {
428 ASSERT_NE(ret, CRYPT_SUCCESS);430 ASSERT_NE(ret, CRYPT_SUCCESS);
429 }431 }
@@ -497,6 +499,7 @@ void SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001(int type, int hashId, Hex *seed, Hex *test
497 ret = CRYPT_EAL_PkeySign(ctx, hashId, msg->x, msg->len, out, &outLen);499 ret = CRYPT_EAL_PkeySign(ctx, hashId, msg->x, msg->len, out, &outLen);
498 ASSERT_EQ(ret, CRYPT_SUCCESS);500 ASSERT_EQ(ret, CRYPT_SUCCESS);
499 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);501 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
502+ ASSERT_TRUE(TestIsErrStackEmpty());
500EXIT:503EXIT:
501 CRYPT_EAL_PkeyFreeCtx(ctx);504 CRYPT_EAL_PkeyFreeCtx(ctx);
502 BSL_SAL_FREE(out);505 BSL_SAL_FREE(out);
@@ -554,6 +557,7 @@ void SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001(int type, int hashId, Hex *testPubKey, H
554 ret = CRYPT_EAL_PkeyVerify(ctx, hashId, msg->x, msg->len, sign->x, sign->len);557 ret = CRYPT_EAL_PkeyVerify(ctx, hashId, msg->x, msg->len, sign->x, sign->len);
555 if (res == 0) {558 if (res == 0) {
556 ASSERT_EQ(ret, CRYPT_SUCCESS);559 ASSERT_EQ(ret, CRYPT_SUCCESS);
560+ ASSERT_TRUE(TestIsErrStackEmpty());
557 } else {561 } else {
558 ASSERT_NE(ret, CRYPT_SUCCESS);562 ASSERT_NE(ret, CRYPT_SUCCESS);
559 }563 }
@@ -651,8 +655,10 @@ void SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001(int type, Hex *testPubKey, Hex *testPr
651 ASSERT_EQ(ret, CRYPT_SUCCESS);655 ASSERT_EQ(ret, CRYPT_SUCCESS);
652 ret = CRYPT_EAL_PkeyVerify(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);656 ret = CRYPT_EAL_PkeyVerify(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);
653 ASSERT_EQ(ret, CRYPT_SUCCESS);657 ASSERT_EQ(ret, CRYPT_SUCCESS);
658+ ASSERT_TRUE(TestIsErrStackEmpty());
654 ret = CRYPT_EAL_PkeyCmp(ctx, ctx2);659 ret = CRYPT_EAL_PkeyCmp(ctx, ctx2);
655 ASSERT_NE(ret, CRYPT_SUCCESS);660 ASSERT_NE(ret, CRYPT_SUCCESS);
661+ (void)TestErrClear();
656 662 
657 CRYPT_EAL_PkeyCtx *ctx3 = CRYPT_EAL_PkeyDupCtx(ctx);663 CRYPT_EAL_PkeyCtx *ctx3 = CRYPT_EAL_PkeyDupCtx(ctx);
658 ASSERT_TRUE(ctx3 != NULL);664 ASSERT_TRUE(ctx3 != NULL);
@@ -663,6 +669,7 @@ void SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001(int type, Hex *testPubKey, Hex *testPr
663 ASSERT_EQ(ret, CRYPT_SUCCESS);669 ASSERT_EQ(ret, CRYPT_SUCCESS);
664 ret = CRYPT_EAL_PkeyVerify(ctx3, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);670 ret = CRYPT_EAL_PkeyVerify(ctx3, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);
665 ASSERT_EQ(ret, CRYPT_SUCCESS);671 ASSERT_EQ(ret, CRYPT_SUCCESS);
672+ ASSERT_TRUE(TestIsErrStackEmpty());
666EXIT:673EXIT:
667 CRYPT_EAL_PkeyFreeCtx(ctx);674 CRYPT_EAL_PkeyFreeCtx(ctx);
668 CRYPT_EAL_PkeyFreeCtx(ctx2);675 CRYPT_EAL_PkeyFreeCtx(ctx2);
Mtestcode/sdv/testcase/crypto/mldsa/test_suite_sdv_mldsa_util.c+3-0
@@ -86,6 +86,7 @@ void SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC001(int type)
86 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pubKey), CRYPT_SUCCESS);86 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pubKey), CRYPT_SUCCESS);
87 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);87 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
88 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);88 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
89+ ASSERT_TRUE(TestIsErrStackEmpty());
89 90 
90 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_MLDSA_INVALID_PRVKEY); // pub prv mismatch91 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_MLDSA_INVALID_PRVKEY); // pub prv mismatch
91 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_MLDSA_INVALID_PRVKEY); // no prv92 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_MLDSA_INVALID_PRVKEY); // no prv
@@ -136,6 +137,7 @@ void SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC002(void)
136 137 
137 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);138 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
138 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_KEYINFO_NOT_SET); // different key-info139 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_KEYINFO_NOT_SET); // different key-info
140+ TestErrClear();
139 141 
140 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, bits1), CRYPT_SUCCESS);142 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, bits1), CRYPT_SUCCESS);
141 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, bits1), CRYPT_SUCCESS);143 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, bits1), CRYPT_SUCCESS);
@@ -146,6 +148,7 @@ void SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC002(void)
146 148 
147 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);149 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);
148 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);150 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);
151+ ASSERT_TRUE(TestIsErrStackEmpty());
149 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_PAIRWISE_CHECK_FAIL);152 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_PAIRWISE_CHECK_FAIL);
150 153 
151EXIT:154EXIT:
Mtestcode/sdv/testcase/crypto/mlkem/test_suite_sdv_mlkem.c+16-0
@@ -568,6 +568,7 @@ void SDV_CRYPTO_MLKEM_KEYGEN_FUNC_TC001(int bits, Hex *z, Hex *d, Hex *testEK, H
568 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);568 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);
569 ASSERT_COMPARE("compare ek", ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);569 ASSERT_COMPARE("compare ek", ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
570 ASSERT_COMPARE("compare dk", dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);570 ASSERT_COMPARE("compare dk", dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
571+ ASSERT_TRUE(TestIsErrStackEmpty());
571EXIT:572EXIT:
572 BSL_SAL_Free(ek.key.kemEk.data);573 BSL_SAL_Free(ek.key.kemEk.data);
573 BSL_SAL_Free(dk.key.kemDk.data);574 BSL_SAL_Free(dk.key.kemDk.data);
@@ -651,11 +652,14 @@ void SDV_CRYPTO_MLKEM_ENCAPS_DECAPS_FUNC_TC001(int bits, Hex *m, Hex *testEK, He
651 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);652 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
652 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);653 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
653 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);654 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
655+ ASSERT_TRUE(TestIsErrStackEmpty());
654 656 
655 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);657 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);
658+ (void)TestErrClear();
656 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);659 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);
657 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, testCT->x, testCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);660 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, testCT->x, testCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
658 ASSERT_COMPARE("compare dec sk", decSharedKey, decSharedLen, testSK->x, testSK->len);661 ASSERT_COMPARE("compare dec sk", decSharedKey, decSharedLen, testSK->x, testSK->len);
662+ ASSERT_TRUE(TestIsErrStackEmpty());
659EXIT:663EXIT:
660 BSL_SAL_Free(ek.key.kemEk.data);664 BSL_SAL_Free(ek.key.kemEk.data);
661 BSL_SAL_Free(dk.key.kemDk.data);665 BSL_SAL_Free(dk.key.kemDk.data);
@@ -714,6 +718,7 @@ void SDV_CRYPTO_MLKEM_DECAPS_FUNC_TC001(int bits, Hex *testDK, Hex *testCT, Hex
714 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);718 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
715 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, testCT->x, testCT->len, sharedKey, &sharedLen), CRYPT_SUCCESS);719 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, testCT->x, testCT->len, sharedKey, &sharedLen), CRYPT_SUCCESS);
716 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);720 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
721+ ASSERT_TRUE(TestIsErrStackEmpty());
717EXIT:722EXIT:
718 BSL_SAL_Free(dk.key.kemDk.data);723 BSL_SAL_Free(dk.key.kemDk.data);
719 BSL_SAL_Free(sharedKey);724 BSL_SAL_Free(sharedKey);
@@ -829,11 +834,14 @@ void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC001(int bits, Hex *m, Hex *testEK,
829 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);834 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
830 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);835 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
831 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);836 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
837+ ASSERT_TRUE(TestIsErrStackEmpty());
832 838 
833 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);839 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);
840+ (void)TestErrClear();
834 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);841 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);
835 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, changeCT->x, changeCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);842 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, changeCT->x, changeCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
836 ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);843 ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);
844+ ASSERT_TRUE(TestIsErrStackEmpty());
837 845 
838EXIT:846EXIT:
839 BSL_SAL_Free(ek.key.kemEk.data);847 BSL_SAL_Free(ek.key.kemEk.data);
@@ -920,6 +928,7 @@ void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC002(int bits, Hex *m, Hex *testEK,
920 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);928 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
921 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);929 ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
922 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);930 ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
931+ ASSERT_TRUE(TestIsErrStackEmpty());
923 932 
924 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);933 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);
925 // validity check of private key is performed when setting the private key via decaps934 // validity check of private key is performed when setting the private key via decaps
@@ -1008,11 +1017,14 @@ void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC003(int bits, Hex *m, Hex *testDK,
1008 1017 
1009 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubKeyCtx, &ek), CRYPT_SUCCESS);1018 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubKeyCtx, &ek), CRYPT_SUCCESS);
1010 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);1019 ASSERT_EQ(CRYPT_EAL_PkeyEncaps(pubKeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
1020+ ASSERT_TRUE(TestIsErrStackEmpty());
1011 1021 
1012 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);1022 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pubKeyCtx, &dk), CRYPT_MLKEM_KEY_REPEATED_SET);
1023+ (void)TestErrClear();
1013 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);1024 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKeyCtx, &dk), CRYPT_SUCCESS);
1014 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, ciphertext, cipherLen, decSharedKey, &decSharedLen), CRYPT_SUCCESS);1025 ASSERT_EQ(CRYPT_EAL_PkeyDecaps(prvKeyCtx, ciphertext, cipherLen, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
1015 ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);1026 ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);
1027+ ASSERT_TRUE(TestIsErrStackEmpty());
1016 1028 
1017EXIT:1029EXIT:
1018 BSL_SAL_Free(ek.key.kemEk.data);1030 BSL_SAL_Free(ek.key.kemEk.data);
@@ -1048,6 +1060,7 @@ void SDV_CRYPTO_MLKEM_DECODE_OVERFLOW_TC001(int bits, Hex *testDk)
1048 prvKey.key.kemDk.len = decapsKeyLen;1060 prvKey.key.kemDk.len = decapsKeyLen;
1049 prvKey.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);1061 prvKey.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
1050 (void)memcpy_s(prvKey.key.kemDk.data, prvKey.key.kemDk.len, testDk->x, testDk->len);1062 (void)memcpy_s(prvKey.key.kemDk.data, prvKey.key.kemDk.len, testDk->x, testDk->len);
1063+ ASSERT_TRUE(TestIsErrStackEmpty());
1051 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvKey), CRYPT_MLKEM_DECODE_KEY_OVERFLOW);1064 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvKey), CRYPT_MLKEM_DECODE_KEY_OVERFLOW);
1052EXIT:1065EXIT:
1053 BSL_SAL_Free(prvKey.key.kemDk.data);1066 BSL_SAL_Free(prvKey.key.kemDk.data);
@@ -1078,6 +1091,7 @@ void SDV_CRYPTO_MLKEM_DECODE_OVERFLOW_TC002(int bits, Hex *testEk)
1078 pubKey.key.kemEk.len = encapsKeyLen;1091 pubKey.key.kemEk.len = encapsKeyLen;
1079 pubKey.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);1092 pubKey.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
1080 (void)memcpy_s(pubKey.key.kemEk.data, pubKey.key.kemEk.len, testEk->x, testEk->len);1093 (void)memcpy_s(pubKey.key.kemEk.data, pubKey.key.kemEk.len, testEk->x, testEk->len);
1094+ ASSERT_TRUE(TestIsErrStackEmpty());
1081 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubKey), CRYPT_MLKEM_DECODE_KEY_OVERFLOW);1095 ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubKey), CRYPT_MLKEM_DECODE_KEY_OVERFLOW);
1082EXIT:1096EXIT:
1083 BSL_SAL_Free(pubKey.key.kemEk.data);1097 BSL_SAL_Free(pubKey.key.kemEk.data);
@@ -1145,6 +1159,7 @@ void SDV_CRYPTO_MLKEM_KEY_PAIR_FUNC_TC001(int bits)
1145 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &ek), CRYPT_SUCCESS);1159 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &ek), CRYPT_SUCCESS);
1146 1160 
1147 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);1161 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
1162+ ASSERT_TRUE(TestIsErrStackEmpty());
1148 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_NULL_INPUT); // no pub1163 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_NULL_INPUT); // no pub
1149 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_NULL_INPUT); // no prv1164 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_NULL_INPUT); // no prv
1150 1165 
@@ -1436,6 +1451,7 @@ void SDV_CRYPTO_MLKEM_DECAPS_DUP_API_TC001(int bits)
1436 1451 
1437 ret = CRYPT_EAL_PkeyDecaps(dupCtx, ciphertext, cipherLen, sharedKey, &sharedLen);1452 ret = CRYPT_EAL_PkeyDecaps(dupCtx, ciphertext, cipherLen, sharedKey, &sharedLen);
1438 ASSERT_EQ(ret, CRYPT_SUCCESS);1453 ASSERT_EQ(ret, CRYPT_SUCCESS);
1454+ ASSERT_TRUE(TestIsErrStackEmpty());
1439 1455 
1440EXIT:1456EXIT:
1441 CRYPT_EAL_PkeyFreeCtx(ctx);1457 CRYPT_EAL_PkeyFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/paillier/test_suite_sdv_eal_paillier.c+5-0
@@ -1016,6 +1016,7 @@ void SDV_CRYPTO_PAILLIER_GET_SECURITY_BITS_FUNC_TC001(Hex *n, Hex *g, Hex *n2, i
1016 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);1016 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
1017 1017 
1018 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);1018 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
1019+ ASSERT_TRUE(TestIsErrStackEmpty());
1019 1020 
1020EXIT:1021EXIT:
1021 CRYPT_EAL_PkeyFreeCtx(pkey);1022 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -1101,6 +1102,7 @@ void SDV_CRYPTO_PAILLIER_ADD_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *g, Hex
1101 1102 
1102 /* pKey is NULL */1103 /* pKey is NULL */
1103 ASSERT_TRUE(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen) == CRYPT_PAILLIER_NO_KEY_INFO);1104 ASSERT_TRUE(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen) == CRYPT_PAILLIER_NO_KEY_INFO);
1105+ TestErrClear();
1104 1106
1105 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);1107 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
1106 1108 
@@ -1112,6 +1114,7 @@ void SDV_CRYPTO_PAILLIER_ADD_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *g, Hex
1112 BSL_PARAM_InitValue(&items[IDX_C2], CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, c2->x, c2->len),1114 BSL_PARAM_InitValue(&items[IDX_C2], CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, c2->x, c2->len),
1113 BSL_SUCCESS);1115 BSL_SUCCESS);
1114 (void)memset_s(&items[IDX_END], sizeof(items[IDX_END]), 0, sizeof(items[IDX_END]));1116 (void)memset_s(&items[IDX_END], sizeof(items[IDX_END]), 0, sizeof(items[IDX_END]));
1117+ ASSERT_TRUE(TestIsErrStackEmpty());
1115 1118 
1116 /* Test invalid inputs */1119 /* Test invalid inputs */
1117 ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(NULL, items, addResult, &addLen), CRYPT_NULL_INPUT);1120 ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(NULL, items, addResult, &addLen), CRYPT_NULL_INPUT);
@@ -1134,6 +1137,7 @@ void SDV_CRYPTO_PAILLIER_ADD_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *g, Hex
1134 /* Test invalid outLen */1137 /* Test invalid outLen */
1135 addLen = 0;1138 addLen = 0;
1136 ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen), CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);1139 ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen), CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
1140+ TestErrClear();
1137 1141 
1138 /* Test valid homomorphic addition */1142 /* Test valid homomorphic addition */
1139 addLen = 512;1143 addLen = 512;
@@ -1147,6 +1151,7 @@ void SDV_CRYPTO_PAILLIER_ADD_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *g, Hex
1147 prvkey.key.paillierPrv.n2Len = n2->len;1151 prvkey.key.paillierPrv.n2Len = n2->len;
1148 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);1152 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
1149 ASSERT_EQ(HEAdd_Correctness_Check(pkey, c1, c2, addResult, addLen), 0);1153 ASSERT_EQ(HEAdd_Correctness_Check(pkey, c1, c2, addResult, addLen), 0);
1154+ ASSERT_TRUE(TestIsErrStackEmpty());
1150 1155 
1151EXIT:1156EXIT:
1152 CRYPT_EAL_PkeyFreeCtx(pkey);1157 CRYPT_EAL_PkeyFreeCtx(pkey);
Mtestcode/sdv/testcase/crypto/pbkdf2/test_suite_sdv_eal_kdf_pbkdf2.c+2-0
@@ -174,6 +174,7 @@ void SDV_CRYPT_EAL_KDF_PBKDF2_FUN_TC001(int algId, Hex *key, Hex *salt, int it,
174 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);174 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
175 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);175 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
176 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);176 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
177+ ASSERT_TRUE(TestIsErrStackEmpty());
177EXIT:178EXIT:
178 if (out != NULL) {179 if (out != NULL) {
179 free(out);180 free(out);
@@ -221,6 +222,7 @@ void SDV_CRYPTO_PBKDF2_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *sal
221 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);222 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
222 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);223 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
223 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);224 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
225+ ASSERT_TRUE(TestIsErrStackEmpty());
224EXIT:226EXIT:
225 if (out != NULL) {227 if (out != NULL) {
226 free(out);228 free(out);
Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_iso19790_provider.c+16-0
@@ -301,6 +301,7 @@ void SDV_ISO19790_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC001()
301 ASSERT_TRUE(signatureLen > 0);301 ASSERT_TRUE(signatureLen > 0);
302 302 
303 ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);303 ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
304+ ASSERT_TRUE(TestIsErrStackEmpty());
304 305 
305EXIT:306EXIT:
306 CRYPT_EAL_PkeyFreeCtx(keyCtx);307 CRYPT_EAL_PkeyFreeCtx(keyCtx);
@@ -348,6 +349,7 @@ void SDV_ISO19790_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC002()
348 ASSERT_TRUE(signatureLen > 0);349 ASSERT_TRUE(signatureLen > 0);
349 350 
350 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);351 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
352+ ASSERT_TRUE(TestIsErrStackEmpty());
351 353 
352EXIT:354EXIT:
353 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);355 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -391,6 +393,7 @@ void SDV_ISO_PROVIDER_PKEY_ENCRYPT_DECRYPT_TEST_TC001()
391 ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyCtx, ciphertext, ciphertextLen, plaintext, &plaintextLen), CRYPT_SUCCESS);393 ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyCtx, ciphertext, ciphertextLen, plaintext, &plaintextLen), CRYPT_SUCCESS);
392 ASSERT_EQ(testDataLen, plaintextLen);394 ASSERT_EQ(testDataLen, plaintextLen);
393 ASSERT_EQ(memcmp(testData, plaintext, plaintextLen), 0);395 ASSERT_EQ(memcmp(testData, plaintext, plaintextLen), 0);
396+ ASSERT_TRUE(TestIsErrStackEmpty());
394 397 
395EXIT:398EXIT:
396 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);399 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -481,6 +484,7 @@ void SDV_ISO19790_PROVIDER_DRBG_TEST_TC001()
481 ASSERT_EQ(CRYPT_EAL_DrbgSeed(randCtx2), CRYPT_SUCCESS);484 ASSERT_EQ(CRYPT_EAL_DrbgSeed(randCtx2), CRYPT_SUCCESS);
482 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx1, data, dataLen), CRYPT_SUCCESS);485 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx1, data, dataLen), CRYPT_SUCCESS);
483 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx2, data, dataLen), CRYPT_SUCCESS);486 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx2, data, dataLen), CRYPT_SUCCESS);
487+ ASSERT_TRUE(TestIsErrStackEmpty());
484 488 
485EXIT:489EXIT:
486 CRYPT_EAL_DrbgDeinit(randCtx1);490 CRYPT_EAL_DrbgDeinit(randCtx1);
@@ -565,6 +569,7 @@ void SDV_ISO19790_PROVIDER_MAC_TEST_TC001(int algId, int keyLen)
565 }569 }
566 ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);570 ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);
567 ASSERT_EQ(ret, CRYPT_SUCCESS);571 ASSERT_EQ(ret, CRYPT_SUCCESS);
572+ ASSERT_TRUE(TestIsErrStackEmpty());
568 573 
569EXIT:574EXIT:
570 CRYPT_EAL_MacFreeCtx(macCtx);575 CRYPT_EAL_MacFreeCtx(macCtx);
@@ -607,6 +612,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
607 612 
608 ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);613 ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
609 ASSERT_EQ(ret, CRYPT_SUCCESS);614 ASSERT_EQ(ret, CRYPT_SUCCESS);
615+ ASSERT_TRUE(TestIsErrStackEmpty());
610 616 
611EXIT:617EXIT:
612 CRYPT_EAL_KdfFreeCtx(kdfCtx);618 CRYPT_EAL_KdfFreeCtx(kdfCtx);
@@ -653,6 +659,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC002(int algId, Hex *key, Hex *salt, Hex *i
653 info->x, info->len), CRYPT_SUCCESS);659 info->x, info->len), CRYPT_SUCCESS);
654 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);660 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
655 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);661 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);
662+ ASSERT_TRUE(TestIsErrStackEmpty());
656EXIT:663EXIT:
657 if (out != NULL) {664 if (out != NULL) {
658 free(out);665 free(out);
@@ -701,6 +708,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC003(int algId, Hex *key, Hex *label, Hex *
701 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);708 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
702 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);709 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);
703 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);710 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
711+ ASSERT_TRUE(TestIsErrStackEmpty());
704EXIT:712EXIT:
705 if (out != NULL) {713 if (out != NULL) {
706 free(out);714 free(out);
@@ -763,6 +771,7 @@ void SDV_ISO19790_PROVIDER_Get_Status_Test_TC001()
763 ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_PROVIDER_LIB_NAME, &isLoaded);771 ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_PROVIDER_LIB_NAME, &isLoaded);
764 ASSERT_EQ(ret, CRYPT_SUCCESS);772 ASSERT_EQ(ret, CRYPT_SUCCESS);
765 ASSERT_TRUE(isLoaded == false);773 ASSERT_TRUE(isLoaded == false);
774+ ASSERT_TRUE(TestIsErrStackEmpty());
766 775 
767EXIT:776EXIT:
768 CRYPT_EAL_ProviderUnload(libCtx, 0, HITLS_PROVIDER_LIB_NAME);777 CRYPT_EAL_ProviderUnload(libCtx, 0, HITLS_PROVIDER_LIB_NAME);
@@ -800,6 +809,7 @@ void SDV_ISO19790_PROVIDER_CMVP_SELFTEST_Test_TC001()
800 &type, sizeof(type)), CRYPT_SUCCESS);809 &type, sizeof(type)), CRYPT_SUCCESS);
801 ret = CRYPT_CMVP_Selftest(selftestCtx, params);810 ret = CRYPT_CMVP_Selftest(selftestCtx, params);
802 ASSERT_EQ(ret, CRYPT_SUCCESS);811 ASSERT_EQ(ret, CRYPT_SUCCESS);
812+ ASSERT_TRUE(TestIsErrStackEmpty());
803 813 
804EXIT:814EXIT:
805 CRYPT_CMVP_SelftestFreeCtx(selftestCtx);815 CRYPT_CMVP_SelftestFreeCtx(selftestCtx);
@@ -848,6 +858,7 @@ void SDV_ISO19790_PROVIDER_CIPHPER_TEST_TC001()
848 ASSERT_EQ(ret, CRYPT_SUCCESS);858 ASSERT_EQ(ret, CRYPT_SUCCESS);
849 859 
850 cipherLen += tmpLen;860 cipherLen += tmpLen;
861+ ASSERT_TRUE(TestIsErrStackEmpty());
851 862 
852EXIT:863EXIT:
853 CRYPT_EAL_CipherFreeCtx(cipherCtx);864 CRYPT_EAL_CipherFreeCtx(cipherCtx);
@@ -903,6 +914,7 @@ void SDV_ISO19790_PROVIDER_PKEY_TEST_TC001(int hashId, Hex *p, Hex *q, Hex *g)
903 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, hashId, testData, testDataLen, signature, &signatureLen), 0);914 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, hashId, testData, testDataLen, signature, &signatureLen), 0);
904 915 
905 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, hashId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);916 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, hashId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
917+ ASSERT_TRUE(TestIsErrStackEmpty());
906 918 
907EXIT:919EXIT:
908 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);920 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -928,6 +940,7 @@ void SDV_ISO19790_PROVIDER_MAC_PARAM_CHECK_TC001(int algId, int keyLen)
928 940 
929 macCtx = CRYPT_EAL_ProviderMacNewCtx(ctx.libCtx, algId, HITLS_ISO_PROVIDER_ATTR);941 macCtx = CRYPT_EAL_ProviderMacNewCtx(ctx.libCtx, algId, HITLS_ISO_PROVIDER_ATTR);
930 ASSERT_TRUE(macCtx != NULL);942 ASSERT_TRUE(macCtx != NULL);
943+ ASSERT_TRUE(TestIsErrStackEmpty());
931 944
932 int32_t ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);945 int32_t ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);
933 ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);946 ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);
@@ -1031,10 +1044,12 @@ void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC002(Hex *key, Hex *salt, Hex *info)
1031 ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,1044 ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
1032 key->x, 13), CRYPT_SUCCESS);1045 key->x, 13), CRYPT_SUCCESS);
1033 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);1046 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);
1047+ TestErrClear();
1034 1048 
1035 ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,1049 ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
1036 key->x, 14), CRYPT_SUCCESS);1050 key->x, 14), CRYPT_SUCCESS);
1037 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);1051 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
1052+ ASSERT_TRUE(TestIsErrStackEmpty());
1038 1053 
1039EXIT:1054EXIT:
1040 CRYPT_EAL_KdfFreeCtx(kdfCtx);1055 CRYPT_EAL_KdfFreeCtx(kdfCtx);
@@ -1315,6 +1330,7 @@ void SDV_ISO19790_PROVIDER_DH_CHECK_TEST_TC001()
1315 1330 
1316 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkeyCtx), CRYPT_SUCCESS);1331 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkeyCtx), CRYPT_SUCCESS);
1317 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkeyCtx, pkeyCtx), CRYPT_SUCCESS);1332 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkeyCtx, pkeyCtx), CRYPT_SUCCESS);
1333+ ASSERT_TRUE(TestIsErrStackEmpty());
1318 1334 
1319EXIT:1335EXIT:
1320 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);1336 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_multi_provider.c+9-0
@@ -93,6 +93,7 @@ void SDV_PROVIDER_SHA256_TC001(char *path, char *defProName, char *customProName
93 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), 0);93 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), 0);
94 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), 0);94 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), 0);
95 ASSERT_COMPARE("other provider sha256", out, outLen, digest->x, digest->len);95 ASSERT_COMPARE("other provider sha256", out, outLen, digest->x, digest->len);
96+ ASSERT_TRUE(TestIsErrStackEmpty());
96 97 
97EXIT:98EXIT:
98 CRYPT_EAL_MdFreeCtx(ctx);99 CRYPT_EAL_MdFreeCtx(ctx);
@@ -137,6 +138,7 @@ void SDV_PROVIDER_HMAC_TC001(char *path, char *defProName, char *customProName,
137 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), 0);138 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), 0);
138 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), 0);139 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), 0);
139 ASSERT_COMPARE("default hmac other sha256", out, outLen, vecMac->x, vecMac->len);140 ASSERT_COMPARE("default hmac other sha256", out, outLen, vecMac->x, vecMac->len);
141+ ASSERT_TRUE(TestIsErrStackEmpty());
140 142 
141EXIT:143EXIT:
142 CRYPT_EAL_MacFreeCtx(ctx);144 CRYPT_EAL_MacFreeCtx(ctx);
@@ -190,6 +192,7 @@ void SDV_PROVIDER_HKDF_TC001(char *path, char *defProName, char *customProName,
190 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);192 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
191 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);193 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
192 ASSERT_COMPARE("default hkdf-hmac other sha256", out, outLen, result->x, result->len);194 ASSERT_COMPARE("default hkdf-hmac other sha256", out, outLen, result->x, result->len);
195+ ASSERT_TRUE(TestIsErrStackEmpty());
193 196 
194EXIT:197EXIT:
195 CRYPT_EAL_KdfFreeCtx(ctx);198 CRYPT_EAL_KdfFreeCtx(ctx);
@@ -242,6 +245,7 @@ void SDV_PROVIDER_PBKDF2_TC001(char *path, char *defProName, char *customProName
242 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);245 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
243 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);246 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
244 ASSERT_COMPARE("default pbkdf2 other sha256", out, outLen, result->x, result->len);247 ASSERT_COMPARE("default pbkdf2 other sha256", out, outLen, result->x, result->len);
248+ ASSERT_TRUE(TestIsErrStackEmpty());
245 249 
246EXIT:250EXIT:
247 CRYPT_EAL_KdfFreeCtx(ctx);251 CRYPT_EAL_KdfFreeCtx(ctx);
@@ -294,6 +298,7 @@ void SDV_PROVIDER_KDFTLS12_TC001(char *path, char *defProName, char *customProNa
294 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);298 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
295 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);299 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
296 ASSERT_COMPARE("default kdftls12 other sha256", out, outLen, result->x, result->len);300 ASSERT_COMPARE("default kdftls12 other sha256", out, outLen, result->x, result->len);
301+ ASSERT_TRUE(TestIsErrStackEmpty());
297 302 
298EXIT:303EXIT:
299 CRYPT_EAL_KdfFreeCtx(ctx);304 CRYPT_EAL_KdfFreeCtx(ctx);
@@ -347,6 +352,7 @@ void SDV_PROVIDER_RSA_SIGN_VERIFY_PKCSV15_TC001(char *path, char *defProName, ch
347 signLen = MAX_CIPHERTEXT_LEN;352 signLen = MAX_CIPHERTEXT_LEN;
348 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);353 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);
349 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);354 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);
355+ ASSERT_TRUE(TestIsErrStackEmpty());
350 356 
351EXIT:357EXIT:
352 CRYPT_EAL_PkeyFreeCtx(ctx);358 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -405,6 +411,7 @@ void SDV_PROVIDER_RSA_SIGN_VERIFY_PSS_TC001(char *path, char *defProName, char *
405 signLen = MAX_CIPHERTEXT_LEN;411 signLen = MAX_CIPHERTEXT_LEN;
406 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);412 ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);
407 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);413 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);
414+ ASSERT_TRUE(TestIsErrStackEmpty());
408 415 
409EXIT:416EXIT:
410 CRYPT_EAL_PkeyFreeCtx(ctx);417 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -481,6 +488,7 @@ void SDV_PROVIDER_RSA_RSABSSA_BLINDING_TC001(char *path, char *defProName, char
481 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen), 0);488 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen), 0);
482#endif489#endif
483 490 
491+ ASSERT_TRUE(TestIsErrStackEmpty());
484EXIT:492EXIT:
485 CRYPT_EAL_PkeyFreeCtx(ctx);493 CRYPT_EAL_PkeyFreeCtx(ctx);
486 CRYPT_EAL_LibCtxFree(libCtx);494 CRYPT_EAL_LibCtxFree(libCtx);
@@ -548,6 +556,7 @@ void SDV_PROVIDER_RSA_CRYPT_FUNC_TC001(char *path, char *defProName, char *custo
548 ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(ctx, ct, ctLen, pt, &ptLen), 0);556 ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(ctx, ct, ctLen, pt, &ptLen), 0);
549 ASSERT_EQ(ptLen, plaintext->len);557 ASSERT_EQ(ptLen, plaintext->len);
550 ASSERT_COMPARE("rsa encrypt and decrypt", pt, ptLen, plaintext->x, plaintext->len);558 ASSERT_COMPARE("rsa encrypt and decrypt", pt, ptLen, plaintext->x, plaintext->len);
559+ ASSERT_TRUE(TestIsErrStackEmpty());
551 560 
552EXIT:561EXIT:
553 CRYPT_EAL_PkeyFreeCtx(ctx);562 CRYPT_EAL_PkeyFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_load.c+11-0
@@ -118,6 +118,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_TC001(char *path, char *path2, char *test1, char *
118 118 
119 ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);119 ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
120 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);120 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
121+ ASSERT_TRUE(TestIsErrStackEmpty());
121 122 
122 // Test loading a non-existent provider123 // Test loading a non-existent provider
123 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, "non_existent_provider", NULL, NULL), BSL_SAL_ERR_DL_NOT_FOUND);124 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, "non_existent_provider", NULL, NULL), BSL_SAL_ERR_DL_NOT_FOUND);
@@ -127,6 +128,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_TC001(char *path, char *path2, char *test1, char *
127 128 
128 // Test loading a provider without complete return methods129 // Test loading a provider without complete return methods
129 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, testNoFullfunc, NULL, NULL), CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);130 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, testNoFullfunc, NULL, NULL), CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
131+ TestErrClear();
130 132 
131 setenv("LD_LIBRARY_PATH", path, 1);133 setenv("LD_LIBRARY_PATH", path, 1);
132 ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, NULL), CRYPT_SUCCESS);134 ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, NULL), CRYPT_SUCCESS);
@@ -142,6 +144,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_TC001(char *path, char *path2, char *test1, char *
142 144 
143 // Test unloading a non-existent provider145 // Test unloading a non-existent provider
144 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, "non_existent_provider"), CRYPT_SUCCESS);146 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, "non_existent_provider"), CRYPT_SUCCESS);
147+ ASSERT_TRUE(TestIsErrStackEmpty());
145 148 
146EXIT:149EXIT:
147 if (libCtx != NULL) {150 if (libCtx != NULL) {
@@ -352,6 +355,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_COMPARE_TC002(char *path, char *test1, char *test2
352 mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);355 mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);
353 ASSERT_EQ(mdInitCtx(provCtx, NULL), result);356 ASSERT_EQ(mdInitCtx(provCtx, NULL), result);
354 funcs = provCtx = NULL;357 funcs = provCtx = NULL;
358+ ASSERT_TRUE(TestIsErrStackEmpty());
355 359 
356 // Test 2: Test when no provider can meet the attribute requirements360 // Test 2: Test when no provider can meet the attribute requirements
357 ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "n_atr=test3", &funcs, &provCtx);361 ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "n_atr=test3", &funcs, &provCtx);
@@ -521,6 +525,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_DEFAULT_TC001(char *path, char *test1, int cmd, He
521 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);525 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
522 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);526 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
523 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);527 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
528+ ASSERT_TRUE(TestIsErrStackEmpty());
524EXIT:529EXIT:
525 CRYPT_EAL_LibCtxFree(libCtx);530 CRYPT_EAL_LibCtxFree(libCtx);
526 CRYPT_EAL_MdFreeCtx(ctx);531 CRYPT_EAL_MdFreeCtx(ctx);
@@ -761,6 +766,7 @@ void SDV_CRYPTO_PROVIDER_GET_CAPS_TC001(void)
761#else766#else
762 ASSERT_EQ(sigAlgCount, 0);767 ASSERT_EQ(sigAlgCount, 0);
763#endif768#endif
769+ ASSERT_TRUE(TestIsErrStackEmpty());
764 770 
765 // Test invalid mgrCtx771 // Test invalid mgrCtx
766 ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(NULL, CRYPT_EAL_GET_GROUP_CAP, (CRYPT_EAL_ProcessFuncCb)GroupCapsCallback,772 ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(NULL, CRYPT_EAL_GET_GROUP_CAP, (CRYPT_EAL_ProcessFuncCb)GroupCapsCallback,
@@ -870,6 +876,7 @@ void SDV_CRYPTO_PROVIDER_PROC_ALL_TC001(char *path, char *test1, char *test2, in
870 providerCount = 0;876 providerCount = 0;
871 ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(NULL, CountProvidersCallback, &providerCount), CRYPT_SUCCESS);877 ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(NULL, CountProvidersCallback, &providerCount), CRYPT_SUCCESS);
872 ASSERT_EQ(providerCount, 1);878 ASSERT_EQ(providerCount, 1);
879+ ASSERT_TRUE(TestIsErrStackEmpty());
873 880 
874 // Test 3: Test NULL inputs881 // Test 3: Test NULL inputs
875 ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, NULL, &providerCount), CRYPT_NULL_INPUT);882 ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, NULL, &providerCount), CRYPT_NULL_INPUT);
@@ -978,6 +985,7 @@ void SDV_CRYPTO_PROVIDER_PROC_ALL_TC002(char *path, char *test1, char *test2, in
978 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);985 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
979 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);986 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);
980 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, BSL_SAL_LIB_FMT_OFF, "default"), CRYPT_SUCCESS);987 ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, BSL_SAL_LIB_FMT_OFF, "default"), CRYPT_SUCCESS);
988+ ASSERT_TRUE(TestIsErrStackEmpty());
981 989
982EXIT:990EXIT:
983 CRYPT_EAL_LibCtxFree(libCtx);991 CRYPT_EAL_LibCtxFree(libCtx);
@@ -1052,6 +1060,7 @@ void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC001(char *path, char *get_cap_test1, int
1052 ASSERT_TRUE(sharedKeyLen1 > 0);1060 ASSERT_TRUE(sharedKeyLen1 > 0);
1053 ASSERT_TRUE(sharedKeyLen2 > 0);1061 ASSERT_TRUE(sharedKeyLen2 > 0);
1054 ASSERT_EQ(memcmp(sharedKey1, sharedKey2, sharedKeyLen1), 0);1062 ASSERT_EQ(memcmp(sharedKey1, sharedKey2, sharedKeyLen1), 0);
1063+ ASSERT_TRUE(TestIsErrStackEmpty());
1055 1064 
1056EXIT:1065EXIT:
1057 CRYPT_EAL_PkeyFreeCtx(keyCtx1);1066 CRYPT_EAL_PkeyFreeCtx(keyCtx1);
@@ -1112,6 +1121,7 @@ void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC002(char *path, char *get_cap_test1, int
1112 ASSERT_TRUE(signatureLen > 0);1121 ASSERT_TRUE(signatureLen > 0);
1113 1122 
1114 ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SHA256, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);1123 ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SHA256, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
1124+ ASSERT_TRUE(TestIsErrStackEmpty());
1115 1125
1116 // Test 4: Modify signature and verify it should fail1126 // Test 4: Modify signature and verify it should fail
1117 signature[10] ^= 0xFF; // Flip bits in the signature1127 signature[10] ^= 0xFF; // Flip bits in the signature
@@ -1139,6 +1149,7 @@ void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC003(void)
1139 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);1149 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
1140 CRYPT_EAL_ProviderUnload(libCtx, 0, "default");1150 CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
1141 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);1151 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
1152+ ASSERT_TRUE(TestIsErrStackEmpty());
1142 1153 
1143EXIT:1154EXIT:
1144 CRYPT_EAL_ProviderUnload(libCtx, 0, "default");1155 CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_reg.c+2-0
@@ -244,6 +244,7 @@ void SDV_CRYPTO_PROVIDER_REG_FUNC_TC001(void)
244 244 
245 mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=default");245 mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=default");
246 ASSERT_TRUE(mdCtx != NULL);246 ASSERT_TRUE(mdCtx != NULL);
247+ ASSERT_TRUE(TestIsErrStackEmpty());
247 ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_SHA256_INIT_RET);248 ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_SHA256_INIT_RET);
248 CRYPT_EAL_MdFreeCtx(mdCtx);249 CRYPT_EAL_MdFreeCtx(mdCtx);
249 250 
@@ -256,6 +257,7 @@ void SDV_CRYPTO_PROVIDER_REG_FUNC_TC001(void)
256 ASSERT_TRUE(mdCtx != NULL);257 ASSERT_TRUE(mdCtx != NULL);
257 ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_A_SHA256_INIT_RET);258 ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_A_SHA256_INIT_RET);
258 CRYPT_EAL_MdFreeCtx(mdCtx);259 CRYPT_EAL_MdFreeCtx(mdCtx);
260+ mdCtx = NULL;
259 261 
260 mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=b");262 mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=b");
261 ASSERT_TRUE(mdCtx == NULL);263 ASSERT_TRUE(mdCtx == NULL);
Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_sm_provider.c+8-0
@@ -123,6 +123,7 @@ void SDV_SM_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC001()
123 123 
124 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen),124 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen),
125 CRYPT_SUCCESS);125 CRYPT_SUCCESS);
126+ ASSERT_TRUE(TestIsErrStackEmpty());
126 127 
127EXIT:128EXIT:
128 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);129 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -158,6 +159,7 @@ void SDV_SM_PROVIDER_DRBG_TEST_TC001(int algId)
158 ASSERT_EQ(CRYPT_EAL_DrbgSeed(randCtx), CRYPT_SUCCESS);159 ASSERT_EQ(CRYPT_EAL_DrbgSeed(randCtx), CRYPT_SUCCESS);
159 160 
160 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx, data, dataLen), CRYPT_SUCCESS);161 ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx, data, dataLen), CRYPT_SUCCESS);
162+ ASSERT_TRUE(TestIsErrStackEmpty());
161 163 
162EXIT:164EXIT:
163 CRYPT_EAL_DrbgDeinit(randCtx);165 CRYPT_EAL_DrbgDeinit(randCtx);
@@ -191,6 +193,7 @@ void SDV_SM_PROVIDER_MD_TEST_TC001(int algId)
191 ASSERT_EQ(ret, CRYPT_SUCCESS);193 ASSERT_EQ(ret, CRYPT_SUCCESS);
192 ret = CRYPT_EAL_MdFinal(mdCtx, md, &mdLen);194 ret = CRYPT_EAL_MdFinal(mdCtx, md, &mdLen);
193 ASSERT_EQ(ret, CRYPT_SUCCESS);195 ASSERT_EQ(ret, CRYPT_SUCCESS);
196+ ASSERT_TRUE(TestIsErrStackEmpty());
194 197 
195EXIT:198EXIT:
196 CRYPT_EAL_MdFreeCtx(mdCtx);199 CRYPT_EAL_MdFreeCtx(mdCtx);
@@ -236,6 +239,7 @@ void SDV_SM_PROVIDER_MAC_TEST_TC001(int algId, int keyLen)
236 239 
237 ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);240 ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);
238 ASSERT_EQ(ret, CRYPT_SUCCESS);241 ASSERT_EQ(ret, CRYPT_SUCCESS);
242+ ASSERT_TRUE(TestIsErrStackEmpty());
239 243 
240EXIT:244EXIT:
241 CRYPT_EAL_MacFreeCtx(macCtx);245 CRYPT_EAL_MacFreeCtx(macCtx);
@@ -280,6 +284,7 @@ void SDV_SM_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
280 284 
281 ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);285 ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
282 ASSERT_EQ(ret, CRYPT_SUCCESS);286 ASSERT_EQ(ret, CRYPT_SUCCESS);
287+ ASSERT_TRUE(TestIsErrStackEmpty());
283 288 
284EXIT:289EXIT:
285 CRYPT_EAL_KdfFreeCtx(kdfCtx);290 CRYPT_EAL_KdfFreeCtx(kdfCtx);
@@ -324,6 +329,7 @@ void SDV_SM_PROVIDER_CMVP_SELFTEST_Test_TC001()
324 ASSERT_EQ(CRYPT_EAL_RandbytesEx(libCtx, random, randomLen), CRYPT_SUCCESS);329 ASSERT_EQ(CRYPT_EAL_RandbytesEx(libCtx, random, randomLen), CRYPT_SUCCESS);
325 ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_CMVP_RANDOM, BSL_PARAM_TYPE_OCTETS,330 ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_CMVP_RANDOM, BSL_PARAM_TYPE_OCTETS,
326 random, randomLen), CRYPT_SUCCESS);331 random, randomLen), CRYPT_SUCCESS);
332+ ASSERT_TRUE(TestIsErrStackEmpty());
327 ret = CRYPT_CMVP_Selftest(selftestCtx, params);333 ret = CRYPT_CMVP_Selftest(selftestCtx, params);
328 ASSERT_TRUE(ret == CRYPT_SUCCESS || ret == CRYPT_CMVP_RANDOMNESS_ERR);334 ASSERT_TRUE(ret == CRYPT_SUCCESS || ret == CRYPT_CMVP_RANDOMNESS_ERR);
329 335 
@@ -375,6 +381,7 @@ void SDV_SM_PROVIDER_CIPHPER_TEST_TC001()
375 ASSERT_EQ(ret, CRYPT_SUCCESS);381 ASSERT_EQ(ret, CRYPT_SUCCESS);
376 382 
377 cipherLen += tmpLen;383 cipherLen += tmpLen;
384+ ASSERT_TRUE(TestIsErrStackEmpty());
378 385 
379EXIT:386EXIT:
380 CRYPT_EAL_CipherFreeCtx(cipherCtx);387 CRYPT_EAL_CipherFreeCtx(cipherCtx);
@@ -510,6 +517,7 @@ void SDV_SM_PROVIDER_KDF_KDFTLS12_TEST_TC001(int algId, Hex *key, Hex *label, He
510 seed->x, seed->len), CRYPT_SUCCESS);517 seed->x, seed->len), CRYPT_SUCCESS);
511 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);518 ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
512 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);519 ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);
520+ ASSERT_TRUE(TestIsErrStackEmpty());
513EXIT:521EXIT:
514 if (out != NULL) {522 if (out != NULL) {
515 free(out);523 free(out);
Mtestcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_api.c+10-0
@@ -1364,6 +1364,7 @@ void SDV_CRYPTO_RSA_GET_SECURITY_BITS_FUNC_TC001(Hex *n, Hex *e, int securityBit
1364 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);1364 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
1365 1365 
1366 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);1366 ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
1367+ ASSERT_TRUE(TestIsErrStackEmpty());
1367 1368 
1368EXIT:1369EXIT:
1369 CRYPT_EAL_PkeyFreeCtx(pkey);1370 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -1530,6 +1531,7 @@ void SDV_CRYPTO_RSA_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, int isProvider)
1530 ASSERT_TRUE(pkey != NULL);1531 ASSERT_TRUE(pkey != NULL);
1531 ASSERT_TRUE_AND_LOG("1k key", CRYPT_EAL_PkeySetPara(pkey, &para) == 0);1532 ASSERT_TRUE_AND_LOG("1k key", CRYPT_EAL_PkeySetPara(pkey, &para) == 0);
1532 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);1533 ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
1534+ ASSERT_TRUE(TestIsErrStackEmpty());
1533EXIT:1535EXIT:
1534 CRYPT_EAL_PkeyFreeCtx(pkey);1536 CRYPT_EAL_PkeyFreeCtx(pkey);
1535}1537}
@@ -1668,6 +1670,7 @@ void SDV_CRYPTO_RSA_SEED_KEYGEN_TC001(Hex *xp, Hex *xp1, Hex *xp2, Hex *xq, Hex
1668 // Verify if p and q are as expected1670 // Verify if p and q are as expected
1669 ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.p, p->x, p->len), 0);1671 ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.p, p->x, p->len), 0);
1670 ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.q, q->x, q->len), 0);1672 ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.q, q->x, q->len), 0);
1673+ ASSERT_TRUE(TestIsErrStackEmpty());
1671 1674 
1672EXIT:1675EXIT:
1673 CRYPT_EAL_PkeyFreeCtx(pkey1);1676 CRYPT_EAL_PkeyFreeCtx(pkey1);
@@ -1762,6 +1765,7 @@ void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC001(int bits, int isProvider)
1762 ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS); // check ctr1765 ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS); // check ctr
1763 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);1766 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
1764 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);1767 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
1768+ ASSERT_TRUE(TestIsErrStackEmpty());
1765 1769 
1766EXIT:1770EXIT:
1767 CRYPT_EAL_PkeyFreeCtx(pkey);1771 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -1814,6 +1818,9 @@ void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC002(Hex *p, Hex *q, Hex *n, Hex *d, int isPr
1814 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, pkey2), expectRet);1818 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, pkey2), expectRet);
1815 1819 
1816 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey2), CRYPT_SUCCESS);1820 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey2), CRYPT_SUCCESS);
1821+ if (expectRet == CRYPT_SUCCESS) {
1822+ ASSERT_TRUE(TestIsErrStackEmpty());
1823+ }
1817 1824 
1818EXIT:1825EXIT:
1819 CRYPT_EAL_PkeyFreeCtx(pkey1);1826 CRYPT_EAL_PkeyFreeCtx(pkey1);
@@ -1872,6 +1879,7 @@ void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC003(int bits, int isProvider)
1872 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);1879 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
1873 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);1880 ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
1874 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);1881 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
1882+ ASSERT_TRUE(TestIsErrStackEmpty());
1875EXIT:1883EXIT:
1876 CRYPT_EAL_PkeyFreeCtx(pkey);1884 CRYPT_EAL_PkeyFreeCtx(pkey);
1877 CRYPT_EAL_PkeyFreeCtx(pubCtx);1885 CRYPT_EAL_PkeyFreeCtx(pubCtx);
@@ -2128,6 +2136,7 @@ void SDV_CRYPTO_RSA_Import_Export_FUNC_TC001(void)
2128 ASSERT_TRUE(dstRsaCtx != NULL);2136 ASSERT_TRUE(dstRsaCtx != NULL);
2129 ASSERT_EQ(CRYPT_RSA_Sign(srcRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, &signDataLen), CRYPT_SUCCESS);2137 ASSERT_EQ(CRYPT_RSA_Sign(srcRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, &signDataLen), CRYPT_SUCCESS);
2130 ASSERT_EQ(CRYPT_RSA_Verify(dstRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, signDataLen), CRYPT_SUCCESS);2138 ASSERT_EQ(CRYPT_RSA_Verify(dstRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, signDataLen), CRYPT_SUCCESS);
2139+ ASSERT_TRUE(TestIsErrStackEmpty());
2131EXIT:2140EXIT:
2132 CRYPT_RSA_FreeCtx(srcRsaCtx);2141 CRYPT_RSA_FreeCtx(srcRsaCtx);
2133 CRYPT_RSA_FreeCtx(dstRsaCtx);2142 CRYPT_RSA_FreeCtx(dstRsaCtx);
@@ -2182,6 +2191,7 @@ void SDV_CRYPTO_RSA_Import_Export_FUNC_TC002(void)
2182 ASSERT_TRUE(dstRsaCtx != NULL);2191 ASSERT_TRUE(dstRsaCtx != NULL);
2183 ASSERT_EQ(CRYPT_RSA_Sign(srcRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, &signDataLen), CRYPT_SUCCESS);2192 ASSERT_EQ(CRYPT_RSA_Sign(srcRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, &signDataLen), CRYPT_SUCCESS);
2184 ASSERT_EQ(CRYPT_RSA_Verify(dstRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, signDataLen), CRYPT_SUCCESS);2193 ASSERT_EQ(CRYPT_RSA_Verify(dstRsaCtx, CRYPT_MD_SHA256, data, sizeof(data), signData, signDataLen), CRYPT_SUCCESS);
2194+ ASSERT_TRUE(TestIsErrStackEmpty());
2185EXIT:2195EXIT:
2186 CRYPT_RSA_FreeCtx(srcRsaCtx);2196 CRYPT_RSA_FreeCtx(srcRsaCtx);
2187 CRYPT_RSA_FreeCtx(dstRsaCtx);2197 CRYPT_RSA_FreeCtx(dstRsaCtx);
Mtestcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_encrypt_decrypt.c+1-0
@@ -609,6 +609,7 @@ void SDV_CRYPTO_RSA_INVLAID_DECRYPT_TEST(Hex *n, Hex *e, Hex *d, Hex *plaintext,
609 609 
610 ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);610 ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
611 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);611 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);
612+ ASSERT_TRUE(TestIsErrStackEmpty());
612 613
613 // test the output buffer is too small614 // test the output buffer is too small
614 msgLen = 1;615 msgLen = 1;
Mtestcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_sign_verify.c+15-0
@@ -170,6 +170,7 @@ void SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC001(Hex *n, Hex *d, Hex *msg, Hex *sign,
170 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);170 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
171 171 
172 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);172 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
173+ ASSERT_TRUE(TestIsErrStackEmpty());
173 174 
174EXIT:175EXIT:
175 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);176 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -228,6 +229,7 @@ void SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC002(int mdId, Hex *n, Hex *d, Hex *msg,
228 229 
229 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);230 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
230 ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);231 ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);
232+ ASSERT_TRUE(TestIsErrStackEmpty());
231 233 
232EXIT:234EXIT:
233 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);235 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -294,6 +296,7 @@ void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC001(int mdId, Hex *n, Hex *d, Hex *msg, Hex
294 ASSERT_COMPARE("Compare Sign Data", signdata, signLen, sign->x, sign->len);296 ASSERT_COMPARE("Compare Sign Data", signdata, signLen, sign->x, sign->len);
295 signLen = sign->len;297 signLen = sign->len;
296 }298 }
299+ ASSERT_TRUE(TestIsErrStackEmpty());
297 300 
298EXIT:301EXIT:
299 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);302 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -354,6 +357,7 @@ void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC002(int mdId, Hex *n, Hex *d, Hex *msg, int
354 ASSERT_TRUE(signdata != NULL);357 ASSERT_TRUE(signdata != NULL);
355 358 
356 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);359 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
360+ ASSERT_TRUE(TestIsErrStackEmpty());
357EXIT:361EXIT:
358#ifdef HITLS_CRYPTO_DRBG362#ifdef HITLS_CRYPTO_DRBG
359 TestRandDeInit();363 TestRandDeInit();
@@ -412,6 +416,7 @@ void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC003(Hex *n, Hex *d, Hex *msg, int saltLen, i
412 ASSERT_TRUE(signdata != NULL);416 ASSERT_TRUE(signdata != NULL);
413 417 
414 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);418 ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
419+ ASSERT_TRUE(TestIsErrStackEmpty());
415 420 
416EXIT:421EXIT:
417#ifdef HITLS_CRYPTO_DRBG422#ifdef HITLS_CRYPTO_DRBG
@@ -508,6 +513,7 @@ void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC001(int bits, int isProvider)
508 signLen = (bits + 7) >> 3;513 signLen = (bits + 7) >> 3;
509 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, data, dataLen, sign, &signLen), CRYPT_SUCCESS);514 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
510 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, data, dataLen, sign, signLen), CRYPT_SUCCESS);515 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, data, dataLen, sign, signLen), CRYPT_SUCCESS);
516+ ASSERT_TRUE(TestIsErrStackEmpty());
511 517 
512EXIT:518EXIT:
513#ifdef HITLS_CRYPTO_DRBG519#ifdef HITLS_CRYPTO_DRBG
@@ -601,6 +607,7 @@ void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PSS_FUNC_TC001(int bits, int isProvider)
601 607 
602 ASSERT_EQ(CRYPT_EAL_PkeySignData(cpyCtx, hash, hashLen, sign, &signLen), CRYPT_SUCCESS);608 ASSERT_EQ(CRYPT_EAL_PkeySignData(cpyCtx, hash, hashLen, sign, &signLen), CRYPT_SUCCESS);
603 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(cpyCtx, hash, hashLen, sign, signLen), CRYPT_SUCCESS);609 ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(cpyCtx, hash, hashLen, sign, signLen), CRYPT_SUCCESS);
610+ ASSERT_TRUE(TestIsErrStackEmpty());
604 611 
605EXIT:612EXIT:
606#ifdef HITLS_CRYPTO_DRBG613#ifdef HITLS_CRYPTO_DRBG
@@ -680,6 +687,7 @@ void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC002(int isProvider)
680 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);687 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
681 688 
682 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);689 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
690+ ASSERT_TRUE(TestIsErrStackEmpty());
683 691 
684EXIT:692EXIT:
685#ifdef HITLS_CRYPTO_DRBG693#ifdef HITLS_CRYPTO_DRBG
@@ -773,6 +781,7 @@ void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC003(int isProvider)
773 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);781 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
774 782 
775 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);783 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
784+ ASSERT_TRUE(TestIsErrStackEmpty());
776 785 
777EXIT:786EXIT:
778#ifdef HITLS_CRYPTO_DRBG787#ifdef HITLS_CRYPTO_DRBG
@@ -969,6 +978,7 @@ void SDV_CRYPTO_RSA_VERIFY_PSS_FUNC_TC002(int mdAlgId, Hex *n, Hex *e, Hex *msg,
969 /* Set padding. */978 /* Set padding. */
970 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);979 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
971 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdAlgId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);980 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdAlgId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
981+ ASSERT_TRUE(TestIsErrStackEmpty());
972 982 
973EXIT:983EXIT:
974 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);984 CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
@@ -1046,6 +1056,7 @@ void SDV_CRYPTO_RSA_BLINDING_FUNC_TC001(int keyLen, int hashId, int padMode, Hex
1046 newCtx = CRYPT_EAL_PkeyDupCtx(pkey);1056 newCtx = CRYPT_EAL_PkeyDupCtx(pkey);
1047 ASSERT_TRUE(newCtx != NULL);1057 ASSERT_TRUE(newCtx != NULL);
1048 ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, hashId, msg->x, msg->len, sign, &dataLen), CRYPT_SUCCESS);1058 ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, hashId, msg->x, msg->len, sign, &dataLen), CRYPT_SUCCESS);
1059+ ASSERT_TRUE(TestIsErrStackEmpty());
1049 1060 
1050EXIT:1061EXIT:
1051#ifdef HITLS_CRYPTO_DRBG1062#ifdef HITLS_CRYPTO_DRBG
@@ -1110,6 +1121,7 @@ void SDV_CRYPTO_RSA_BLINDING_FUNC_TC002(int mdId, Hex *p, Hex *q, Hex *n, Hex *d
1110 newCtx = CRYPT_EAL_PkeyDupCtx(ctx);1121 newCtx = CRYPT_EAL_PkeyDupCtx(ctx);
1111 ASSERT_TRUE(newCtx != NULL);1122 ASSERT_TRUE(newCtx != NULL);
1112 ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);1123 ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
1124+ ASSERT_TRUE(TestIsErrStackEmpty());
1113 1125 
1114EXIT:1126EXIT:
1115 CRYPT_EAL_PkeyFreeCtx(ctx);1127 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -1172,6 +1184,7 @@ void SDV_CRYPTO_RSA_KEY_PAIR_CHECK_FUNC_TC001(Hex *n, Hex *e, Hex *d, int expect
1172 1184 
1173 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);1185 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
1174 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);1186 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
1187+ ASSERT_TRUE(TestIsErrStackEmpty());
1175 1188 
1176 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);1189 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
1177 1190 
@@ -1270,6 +1283,7 @@ void SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC001(int mdId, Hex *n, Hex *e, Hex *d
1270#ifdef HITLS_CRYPTO_VERIFY1283#ifdef HITLS_CRYPTO_VERIFY
1271 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(newCtx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen) == CRYPT_SUCCESS);1284 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(newCtx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen) == CRYPT_SUCCESS);
1272#endif1285#endif
1286+ ASSERT_TRUE(TestIsErrStackEmpty());
1273EXIT:1287EXIT:
1274#ifdef HITLS_CRYPTO_DRBG1288#ifdef HITLS_CRYPTO_DRBG
1275 TestRandDeInit();1289 TestRandDeInit();
@@ -1395,6 +1409,7 @@ void SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC002(Hex *e, Hex *nBuff, Hex *d, Hex
1395 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA384, prepared_msg->x, prepared_msg->len, unBlindSig,1409 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA384, prepared_msg->x, prepared_msg->len, unBlindSig,
1396 unBlindSigLen) == CRYPT_SUCCESS);1410 unBlindSigLen) == CRYPT_SUCCESS);
1397#endif1411#endif
1412+ ASSERT_TRUE(TestIsErrStackEmpty());
1398EXIT:1413EXIT:
1399#ifdef HITLS_CRYPTO_DRBG1414#ifdef HITLS_CRYPTO_DRBG
1400 TestRandDeInit();1415 TestRandDeInit();
Mtestcode/sdv/testcase/crypto/scrypt/test_suite_sdv_eal_kdf_scrypt.c+3-0
@@ -323,6 +323,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC001(Hex *key, Hex *salt, int N, int r, int p
323 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);323 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
324 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);324 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
325 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);325 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
326+ ASSERT_TRUE(TestIsErrStackEmpty());
326EXIT:327EXIT:
327 if (out != NULL) {328 if (out != NULL) {
328 free(out);329 free(out);
@@ -368,6 +369,7 @@ void SDV_CRYPTO_SCRYPT_DEFAULT_PROVIDER_FUNC_TC001(Hex *key, Hex *salt, int N, i
368 369 
369 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);370 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
370 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);371 ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
372+ ASSERT_TRUE(TestIsErrStackEmpty());
371EXIT:373EXIT:
372 if (out != NULL) {374 if (out != NULL) {
373 free(out);375 free(out);
@@ -414,6 +416,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC002(int testN, int testR, int testP)
414 ASSERT_EQ(BSL_PARAM_InitValue(&params[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,416 ASSERT_EQ(BSL_PARAM_InitValue(&params[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
415 &p, sizeof(p)), CRYPT_SUCCESS);417 &p, sizeof(p)), CRYPT_SUCCESS);
416 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);418 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
419+ ASSERT_TRUE(TestIsErrStackEmpty());
417 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);420 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
418 421 
419EXIT:422EXIT:
Mtestcode/sdv/testcase/crypto/sha1/test_suite_sdv_eal_md_sha1.c+6-0
@@ -240,6 +240,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC001(Hex *data, Hex *hash)
240 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);240 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
241 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_SUCCESS);241 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_SUCCESS);
242 ASSERT_COMPARE("hash result cmp", out, digestLen, hash->x, hash->len);242 ASSERT_COMPARE("hash result cmp", out, digestLen, hash->x, hash->len);
243+ ASSERT_TRUE(TestIsErrStackEmpty());
243 244 
244EXIT:245EXIT:
245 CRYPT_EAL_MdFreeCtx(ctx);246 CRYPT_EAL_MdFreeCtx(ctx);
@@ -275,6 +276,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC002(Hex *data, Hex *hash)
275 for (uint32_t i = 0; i < threadNum; i++) {276 for (uint32_t i = 0; i < threadNum; i++) {
276 pthread_join(thrd[i], NULL);277 pthread_join(thrd[i], NULL);
277 }278 }
279+ ASSERT_TRUE(TestIsErrStackEmpty());
278 280 
279EXIT:281EXIT:
280 return;282 return;
@@ -315,6 +317,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC003(Hex *plain_text1, Hex *plain_text2, Hex *plain
315 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);317 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
316 318 
317 ASSERT_COMPARE("sha1", output, outLen, hash->x, hash->len);319 ASSERT_COMPARE("sha1", output, outLen, hash->x, hash->len);
320+ ASSERT_TRUE(TestIsErrStackEmpty());
318 321 
319EXIT:322EXIT:
320 CRYPT_EAL_MdFreeCtx(ctx);323 CRYPT_EAL_MdFreeCtx(ctx);
@@ -360,6 +363,7 @@ void SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
360 ASSERT_TRUE(cpyCtx != NULL);363 ASSERT_TRUE(cpyCtx != NULL);
361 ASSERT_TRUE(dupCtx == NULL);364 ASSERT_TRUE(dupCtx == NULL);
362 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);365 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
366+ TestErrClear();
363 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);367 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
364 368 
365 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);369 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
@@ -377,6 +381,7 @@ void SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
377 381 
378 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));382 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
379 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);383 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
384+ ASSERT_TRUE(TestIsErrStackEmpty());
380EXIT:385EXIT:
381 CRYPT_EAL_MdFreeCtx(ctx);386 CRYPT_EAL_MdFreeCtx(ctx);
382 CRYPT_EAL_MdFreeCtx(cpyCtx);387 CRYPT_EAL_MdFreeCtx(cpyCtx);
@@ -410,6 +415,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC004(int id, Hex *msg, Hex *hash)
410 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);415 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
411 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);416 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
412 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);417 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
418+ ASSERT_TRUE(TestIsErrStackEmpty());
413 419 
414EXIT:420EXIT:
415 CRYPT_EAL_MdFreeCtx(ctx);421 CRYPT_EAL_MdFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/sha2/test_suite_sdv_eal_md_sha2.c+6-0
@@ -240,6 +240,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC001(int id)
240 outLen = CRYPT_EAL_MdGetDigestSize(id);240 outLen = CRYPT_EAL_MdGetDigestSize(id);
241 241 
242 ASSERT_COMPARE("sha2", out1, outLen, out2, outLen);242 ASSERT_COMPARE("sha2", out1, outLen, out2, outLen);
243+ ASSERT_TRUE(TestIsErrStackEmpty());
243 244 
244EXIT:245EXIT:
245 CRYPT_EAL_MdFreeCtx(ctx1);246 CRYPT_EAL_MdFreeCtx(ctx1);
@@ -275,6 +276,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC002(int id, Hex *digest)
275 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);276 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
276 277 
277 ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);278 ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);
279+ ASSERT_TRUE(TestIsErrStackEmpty());
278EXIT:280EXIT:
279 CRYPT_EAL_MdFreeCtx(ctx);281 CRYPT_EAL_MdFreeCtx(ctx);
280}282}
@@ -313,6 +315,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC003(int algId, Hex *in, Hex *digest)
313 315
314 ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);316 ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);
315 ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);317 ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);
318+ ASSERT_TRUE(TestIsErrStackEmpty());
316EXIT:319EXIT:
317 CRYPT_EAL_MdFreeCtx(ctx);320 CRYPT_EAL_MdFreeCtx(ctx);
318}321}
@@ -353,6 +356,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC004(int algId, Hex *plain_text1, Hex *plain_te
353 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);356 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
354 357 
355 ASSERT_COMPARE("sha2", output, outLen, hash->x, hash->len);358 ASSERT_COMPARE("sha2", output, outLen, hash->x, hash->len);
359+ ASSERT_TRUE(TestIsErrStackEmpty());
356EXIT:360EXIT:
357 CRYPT_EAL_MdFreeCtx(ctx);361 CRYPT_EAL_MdFreeCtx(ctx);
358}362}
@@ -387,6 +391,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC005(int algId, Hex *data, Hex *hash)
387 for (uint32_t i = 0; i < threadNum; i++) {391 for (uint32_t i = 0; i < threadNum; i++) {
388 pthread_join(thrd[i], NULL);392 pthread_join(thrd[i], NULL);
389 }393 }
394+ ASSERT_TRUE(TestIsErrStackEmpty());
390 395 
391EXIT:396EXIT:
392 return;397 return;
@@ -484,6 +489,7 @@ void SDV_CRYPTO_SHA2_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
484 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);489 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
485 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);490 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
486 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);491 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
492+ ASSERT_TRUE(TestIsErrStackEmpty());
487 493 
488EXIT:494EXIT:
489 CRYPT_EAL_MdFreeCtx(ctx);495 CRYPT_EAL_MdFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/sha3/test_suite_sdv_eal_md_sha3.c+8-0
@@ -205,6 +205,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC001(int algId)
205 outLen = CRYPT_EAL_MdGetDigestSize(algId);205 outLen = CRYPT_EAL_MdGetDigestSize(algId);
206 206 
207 ASSERT_EQ(memcmp(out1, out2, outLen), 0);207 ASSERT_EQ(memcmp(out1, out2, outLen), 0);
208+ ASSERT_TRUE(TestIsErrStackEmpty());
208 209 
209EXIT:210EXIT:
210 CRYPT_EAL_MdFreeCtx(ctx1);211 CRYPT_EAL_MdFreeCtx(ctx1);
@@ -241,6 +242,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC002(int algId, Hex *data, Hex *hash)
241 for (uint32_t i = 0; i < threadNum; i++) {242 for (uint32_t i = 0; i < threadNum; i++) {
242 pthread_join(thrd[i], NULL);243 pthread_join(thrd[i], NULL);
243 }244 }
245+ ASSERT_TRUE(TestIsErrStackEmpty());
244 246 
245EXIT:247EXIT:
246 return;248 return;
@@ -277,6 +279,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC003(int algId, Hex *in, Hex *digest)
277 279 
278 ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);280 ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);
279 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);281 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
282+ ASSERT_TRUE(TestIsErrStackEmpty());
280 283 
281EXIT:284EXIT:
282 CRYPT_EAL_MdFreeCtx(ctx);285 CRYPT_EAL_MdFreeCtx(ctx);
@@ -307,6 +310,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC004(int algId, Hex *in, Hex *digest)
307 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);310 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
308 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);311 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
309 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);312 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
313+ ASSERT_TRUE(TestIsErrStackEmpty());
310EXIT:314EXIT:
311 CRYPT_EAL_MdFreeCtx(ctx);315 CRYPT_EAL_MdFreeCtx(ctx);
312}316}
@@ -343,6 +347,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC005(int algId, Hex *in, Hex *digest, int isProvid
343 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);347 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
344 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out, outLen), CRYPT_SUCCESS);348 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out, outLen), CRYPT_SUCCESS);
345 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);349 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
350+ ASSERT_TRUE(TestIsErrStackEmpty());
346EXIT:351EXIT:
347 CRYPT_EAL_MdFreeCtx(ctx);352 CRYPT_EAL_MdFreeCtx(ctx);
348}353}
@@ -383,6 +388,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC006(int algId, Hex *in, int outLen, Hex *digest,
383 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 2, squeezeLen), CRYPT_SUCCESS);388 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 2, squeezeLen), CRYPT_SUCCESS);
384 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 3, outLen - squeezeLen * 3), CRYPT_SUCCESS);389 ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 3, outLen - squeezeLen * 3), CRYPT_SUCCESS);
385 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);390 ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
391+ ASSERT_TRUE(TestIsErrStackEmpty());
386EXIT:392EXIT:
387 free(out);393 free(out);
388 CRYPT_EAL_MdFreeCtx(ctx);394 CRYPT_EAL_MdFreeCtx(ctx);
@@ -479,6 +485,7 @@ void SDV_CRYPTO_SHA3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
479 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);485 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
480 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);486 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
481 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);487 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
488+ ASSERT_TRUE(TestIsErrStackEmpty());
482 489 
483EXIT:490EXIT:
484 CRYPT_EAL_MdFreeCtx(ctx);491 CRYPT_EAL_MdFreeCtx(ctx);
@@ -518,6 +525,7 @@ void SDV_CRYPT_EAL_SHA3_FUNC_TC007(int algId, int outLen, Hex *in, Hex *digest)
518 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out2, &tmpLen), CRYPT_SUCCESS);525 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out2, &tmpLen), CRYPT_SUCCESS);
519 ASSERT_EQ(memcmp(out1, out2, outLen), 0);526 ASSERT_EQ(memcmp(out1, out2, outLen), 0);
520 ASSERT_EQ(memcmp(out1, digest->x, digest->len), 0);527 ASSERT_EQ(memcmp(out1, digest->x, digest->len), 0);
528+ ASSERT_TRUE(TestIsErrStackEmpty());
521EXIT:529EXIT:
522 free(out1);530 free(out1);
523 free(out2);531 free(out2);
Mtestcode/sdv/testcase/crypto/siphash/test_suite_sdv_eal_mac_siphash.c+1-0
@@ -660,6 +660,7 @@ void SDV_CRYPT_EAL_SIPHASH_FUN_TC005(int algId, Hex *key, Hex *data)
660 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, NULL, 0), CRYPT_SUCCESS);660 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, NULL, 0), CRYPT_SUCCESS);
661 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);661 ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
662 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);662 ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
663+ ASSERT_TRUE(TestIsErrStackEmpty());
663EXIT:664EXIT:
664 CRYPT_EAL_MacFreeCtx(ctx);665 CRYPT_EAL_MacFreeCtx(ctx);
665}666}
Mtestcode/sdv/testcase/crypto/slh_dsa/test_suite_sdv_eal_slh_dsa.c+7-0
@@ -214,6 +214,7 @@ void SDV_CRYPTO_SLH_DSA_GETSET_KEY_TC002(void)
214 prv.key.slhDsaPrv.pub.len = 16;214 prv.key.slhDsaPrv.pub.len = 16;
215 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);215 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
216 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);216 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
217+ ASSERT_TRUE(TestIsErrStackEmpty());
217EXIT:218EXIT:
218 CRYPT_EAL_PkeyFreeCtx(pkey);219 CRYPT_EAL_PkeyFreeCtx(pkey);
219 TestRandDeInit();220 TestRandDeInit();
@@ -253,6 +254,7 @@ void SDV_CRYPTO_SLH_DSA_GENKEY_KAT_TC001(int id, Hex *key, Hex *root)
253 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubOut), CRYPT_SUCCESS);254 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubOut), CRYPT_SUCCESS);
254 ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.seed, root->x, keyLen), 0);255 ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.seed, root->x, keyLen), 0);
255 ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.root, root->x + keyLen, keyLen), 0);256 ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.root, root->x + keyLen, keyLen), 0);
257+ ASSERT_TRUE(TestIsErrStackEmpty());
256 258 
257EXIT:259EXIT:
258 CRYPT_EAL_PkeyFreeCtx(pkey);260 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -308,6 +310,7 @@ void SDV_CRYPTO_SLH_DSA_SIGN_KAT_TC001(int isProvider, int id, Hex *key, Hex *ad
308 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);310 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);
309 ASSERT_TRUE(sigOutLen == sig->len);311 ASSERT_TRUE(sigOutLen == sig->len);
310 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);312 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);
313+ ASSERT_TRUE(TestIsErrStackEmpty());
311EXIT:314EXIT:
312 CRYPT_EAL_PkeyFreeCtx(pkey);315 CRYPT_EAL_PkeyFreeCtx(pkey);
313 CRYPT_RandRegistEx(RandInjectionEx);316 CRYPT_RandRegistEx(RandInjectionEx);
@@ -357,6 +360,7 @@ void SDV_CRYPTO_SLH_DSA_SIGN_KAT_TC002(int id, Hex *key, Hex *addrand, Hex *msg,
357 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, preHashId, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);360 ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, preHashId, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);
358 ASSERT_TRUE(sigOutLen == sig->len);361 ASSERT_TRUE(sigOutLen == sig->len);
359 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);362 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);
363+ ASSERT_TRUE(TestIsErrStackEmpty());
360EXIT:364EXIT:
361 CRYPT_EAL_PkeyFreeCtx(pkey);365 CRYPT_EAL_PkeyFreeCtx(pkey);
362 return;366 return;
@@ -423,6 +427,7 @@ void SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC001(int algId)
423 prv.key.slhDsaPrv.pub.len = keyLen;427 prv.key.slhDsaPrv.pub.len = keyLen;
424 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);428 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
425 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKey, &prv), CRYPT_SUCCESS);429 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKey, &prv), CRYPT_SUCCESS);
430+ ASSERT_TRUE(TestIsErrStackEmpty());
426 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvKey, prvKey), CRYPT_SLHDSA_ERR_NO_PUBKEY);431 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvKey, prvKey), CRYPT_SLHDSA_ERR_NO_PUBKEY);
427 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, pubKey), CRYPT_SLHDSA_ERR_NO_PRVKEY);432 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, pubKey), CRYPT_SLHDSA_ERR_NO_PRVKEY);
428 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, prvKey), CRYPT_SUCCESS);433 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, prvKey), CRYPT_SUCCESS);
@@ -470,6 +475,7 @@ void SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC002(void)
470 475 
471 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);476 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
472 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_ERR_INVALID_ALGID); // different key-info477 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_ERR_INVALID_ALGID); // different key-info
478+ TestErrClear();
473 479 
474 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, algId1), CRYPT_SUCCESS);480 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, algId1), CRYPT_SUCCESS);
475 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, algId1), CRYPT_SUCCESS);481 ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, algId1), CRYPT_SUCCESS);
@@ -480,6 +486,7 @@ void SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC002(void)
480 486 
481 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);487 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);
482 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);488 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);
489+ ASSERT_TRUE(TestIsErrStackEmpty());
483 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_PAIRWISE_CHECK_FAIL);490 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_PAIRWISE_CHECK_FAIL);
484 491 
485EXIT:492EXIT:
Mtestcode/sdv/testcase/crypto/slh_dsa/test_suite_sdv_eal_slh_dsa1.c+6-0
@@ -63,6 +63,9 @@ void SDV_CRYPTO_SLH_DSA_VERIFY_KAT_TC001(int id, Hex *key, Hex *addrand, Hex *ms
63 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);63 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
64 }64 }
65 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sig->x, sig->len), result);65 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sig->x, sig->len), result);
66+ if (result == CRYPT_SUCCESS) {
67+ ASSERT_TRUE(TestIsErrStackEmpty());
68+ }
66EXIT:69EXIT:
67 CRYPT_EAL_PkeyFreeCtx(pkey);70 CRYPT_EAL_PkeyFreeCtx(pkey);
68 return;71 return;
@@ -107,6 +110,9 @@ void SDV_CRYPTO_SLH_DSA_VERIFY_PREHASHED_KAT_TC001(int id, Hex *key, Hex *addran
107 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);110 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
108 }111 }
109 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, hashId, msg->x, msg->len, sig->x, sig->len), result);112 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, hashId, msg->x, msg->len, sig->x, sig->len), result);
113+ if (result == CRYPT_SUCCESS) {
114+ ASSERT_TRUE(TestIsErrStackEmpty());
115+ }
110EXIT:116EXIT:
111 CRYPT_EAL_PkeyFreeCtx(pkey);117 CRYPT_EAL_PkeyFreeCtx(pkey);
112 return;118 return;
Mtestcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_crypt.c+6-0
@@ -297,6 +297,7 @@ void SDV_CRYPTO_SM2_ENC_FUNC_TC001(Hex *pubKey, Hex *plain, Hex *k, Hex *cipher,
297 decodeText[0] = 0x04;297 decodeText[0] = 0x04;
298 ASSERT_EQ(encData.xLen + encData.yLen + encData.hashLen + encData.cipherLen + 1, cipher->len);298 ASSERT_EQ(encData.xLen + encData.yLen + encData.hashLen + encData.cipherLen + 1, cipher->len);
299 ASSERT_TRUE(memcmp(decodeText, cipher->x, cipher->len) == 0);299 ASSERT_TRUE(memcmp(decodeText, cipher->x, cipher->len) == 0);
300+ ASSERT_TRUE(TestIsErrStackEmpty());
300 301 
301EXIT:302EXIT:
302 CRYPT_RandRegist(NULL);303 CRYPT_RandRegist(NULL);
@@ -355,6 +356,7 @@ void SDV_CRYPTO_SM2_DEC_FUNC_TC001(Hex *prvKey, Hex *plain, Hex *cipher, int isP
355 356 
356 ASSERT_TRUE(outLen == plain->len);357 ASSERT_TRUE(outLen == plain->len);
357 ASSERT_TRUE(memcmp(plainText, plain->x, plain->len) == 0);358 ASSERT_TRUE(memcmp(plainText, plain->x, plain->len) == 0);
359+ ASSERT_TRUE(TestIsErrStackEmpty());
358 360 
359EXIT:361EXIT:
360 CRYPT_RandRegist(NULL);362 CRYPT_RandRegist(NULL);
@@ -398,6 +400,7 @@ void SDV_CRYPTO_SM2_DECOCDE_Sm2CipherText(Hex *cipher)
398 ASSERT_TRUE(c1 != NULL);400 ASSERT_TRUE(c1 != NULL);
399 401 
400 ASSERT_EQ(ECC_DecodePoint(para, c1, decode, SM2_POINT_COORDINATE_LEN), CRYPT_SUCCESS);402 ASSERT_EQ(ECC_DecodePoint(para, c1, decode, SM2_POINT_COORDINATE_LEN), CRYPT_SUCCESS);
403+ ASSERT_TRUE(TestIsErrStackEmpty());
401EXIT:404EXIT:
402 BSL_SAL_Free(decode);405 BSL_SAL_Free(decode);
403 ECC_FreePoint(c1);406 ECC_FreePoint(c1);
@@ -480,6 +483,7 @@ void SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC001(Hex *msg, int isProvider)
480 483 
481 ASSERT_TRUE(ptLen == msg->len);484 ASSERT_TRUE(ptLen == msg->len);
482 ASSERT_TRUE(memcmp(plainText, msg->x, msg->len) == 0);485 ASSERT_TRUE(memcmp(plainText, msg->x, msg->len) == 0);
486+ ASSERT_TRUE(TestIsErrStackEmpty());
483 487 
484EXIT:488EXIT:
485 CRYPT_RandRegist(NULL);489 CRYPT_RandRegist(NULL);
@@ -531,6 +535,7 @@ void SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC002(Hex *msg, int isProvider)
531 535 
532 ASSERT_TRUE(ptLen == msg->len);536 ASSERT_TRUE(ptLen == msg->len);
533 ASSERT_TRUE(memcmp(buf, msg->x, msg->len) == 0);537 ASSERT_TRUE(memcmp(buf, msg->x, msg->len) == 0);
538+ ASSERT_TRUE(TestIsErrStackEmpty());
534 539 
535EXIT:540EXIT:
536 CRYPT_RandRegist(NULL);541 CRYPT_RandRegist(NULL);
@@ -612,6 +617,7 @@ void SDV_CRYPTO_SM2_ENC_DECODE_FUNC_TC001(Hex *cipher)
612 .cipherLen = decodelen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE617 .cipherLen = decodelen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
613 };618 };
614 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(cipher->x, cipher->len, &encData), CRYPT_SUCCESS);619 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(cipher->x, cipher->len, &encData), CRYPT_SUCCESS);
620+ ASSERT_TRUE(TestIsErrStackEmpty());
615EXIT:621EXIT:
616 return;622 return;
617}623}
Mtestcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_exchange.c+4-0
@@ -656,6 +656,7 @@ void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC001(
656 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(dupCtx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);656 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(dupCtx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
657 657 
658 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(dupCtx1, dupCtx2, out, &outLen), CRYPT_SUCCESS);658 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(dupCtx1, dupCtx2, out, &outLen), CRYPT_SUCCESS);
659+ ASSERT_TRUE(TestIsErrStackEmpty());
659 660 
660EXIT:661EXIT:
661 CRYPT_RandRegist(NULL);662 CRYPT_RandRegist(NULL);
@@ -740,6 +741,7 @@ void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC002(Hex *prvKey1, Hex *pubKey2, Hex *prvKey2
740 741 
741 ASSERT_TRUE(outLen == shareKey->len);742 ASSERT_TRUE(outLen == shareKey->len);
742 ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);743 ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
744+ ASSERT_TRUE(TestIsErrStackEmpty());
743 745 
744EXIT:746EXIT:
745 CRYPT_RandRegist(NULL);747 CRYPT_RandRegist(NULL);
@@ -841,6 +843,7 @@ void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC003(int pkg, int isProvider)
841 843 
842 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx2, peerCtx2, out2, &outLen) == CRYPT_SUCCESS);844 ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx2, peerCtx2, out2, &outLen) == CRYPT_SUCCESS);
843 ASSERT_TRUE(memcmp(out1, out2, outLen) == 0);845 ASSERT_TRUE(memcmp(out1, out2, outLen) == 0);
846+ ASSERT_TRUE(TestIsErrStackEmpty());
844 847 
845EXIT:848EXIT:
846 CRYPT_RandRegist(NULL);849 CRYPT_RandRegist(NULL);
@@ -939,6 +942,7 @@ void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC004(
939 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, out, &outLen), CRYPT_SUCCESS);942 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, out, &outLen), CRYPT_SUCCESS);
940 ASSERT_TRUE(outLen == shareKey->len);943 ASSERT_TRUE(outLen == shareKey->len);
941 ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);944 ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
945+ ASSERT_TRUE(TestIsErrStackEmpty());
942 946 
943EXIT:947EXIT:
944 CRYPT_RandRegist(NULL);948 CRYPT_RandRegist(NULL);
Mtestcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_sign.c+13-0
@@ -690,6 +690,7 @@ void SDV_CRYPTO_SM2_SIGN_FUNC_TC001(Hex *prvKey, Hex *userId, Hex *k, Hex *msg,
690 ASSERT_EQ(CRYPT_EAL_PkeySign(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, signBuf, &signLen), CRYPT_SUCCESS);690 ASSERT_EQ(CRYPT_EAL_PkeySign(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, signBuf, &signLen), CRYPT_SUCCESS);
691 ASSERT_EQ(signLen, sign->len);691 ASSERT_EQ(signLen, sign->len);
692 ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);692 ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);
693+ ASSERT_TRUE(TestIsErrStackEmpty());
693 694 
694EXIT:695EXIT:
695 CRYPT_RandRegist(NULL);696 CRYPT_RandRegist(NULL);
@@ -746,6 +747,7 @@ void SDV_CRYPTO_SM2_SIGN_FUNC_TC002(
746 747 
747 ASSERT_TRUE(signLen == sign->len);748 ASSERT_TRUE(signLen == sign->len);
748 ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);749 ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);
750+ ASSERT_TRUE(TestIsErrStackEmpty());
749 751 
750EXIT:752EXIT:
751 CRYPT_RandRegist(NULL);753 CRYPT_RandRegist(NULL);
@@ -790,6 +792,7 @@ void SDV_CRYPTO_SM2_VERIFY_FUNC_TC001(Hex *pubKey, Hex *userId, Hex *msg, Hex *s
790 CRYPT_EAL_PkeyCtx *dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);792 CRYPT_EAL_PkeyCtx *dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
791 ASSERT_TRUE(dupCtx != NULL);793 ASSERT_TRUE(dupCtx != NULL);
792 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);794 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
795+ ASSERT_TRUE(TestIsErrStackEmpty());
793 796 
794EXIT:797EXIT:
795 CRYPT_EAL_PkeyFreeCtx(ctx);798 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -828,6 +831,7 @@ void SDV_CRYPTO_SM2_VERIFY_FUNC_TC002(
828 pub.key.eccPub.len = pubKey->len;831 pub.key.eccPub.len = pubKey->len;
829 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);832 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
830 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);833 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
834+ ASSERT_TRUE(TestIsErrStackEmpty());
831 835 
832EXIT:836EXIT:
833 CRYPT_EAL_PkeyFreeCtx(ctx);837 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -894,6 +898,7 @@ void SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC001(int isProvider)
894 signLen = sizeof(signBuf);898 signLen = sizeof(signBuf);
895 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen), CRYPT_SUCCESS);899 ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen), CRYPT_SUCCESS);
896 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen), CRYPT_SUCCESS);900 ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen), CRYPT_SUCCESS);
901+ ASSERT_TRUE(TestIsErrStackEmpty());
897 902 
898EXIT:903EXIT:
899 CRYPT_EAL_PkeyFreeCtx(ctx);904 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -929,6 +934,7 @@ void SDV_CRYPTO_SM2_VERIFY_FUNC_TC003(Hex *pubKey, Hex *userId, Hex *msg, Hex *s
929 934 
930 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);935 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
931 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);936 ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
937+ ASSERT_TRUE(TestIsErrStackEmpty());
932 // Different errors will return different error codes.938 // Different errors will return different error codes.
933 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) != CRYPT_SUCCESS);939 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) != CRYPT_SUCCESS);
934 940 
@@ -977,6 +983,7 @@ void SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC002(Hex *pubKey, Hex *prvKey, int isProvi
977 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);983 ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
978 ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SUCCESS);984 ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SUCCESS);
979 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen) == CRYPT_SUCCESS);985 ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen) == CRYPT_SUCCESS);
986+ ASSERT_TRUE(TestIsErrStackEmpty());
980 987 
981EXIT:988EXIT:
982 CRYPT_EAL_PkeyFreeCtx(ctx);989 CRYPT_EAL_PkeyFreeCtx(ctx);
@@ -1037,6 +1044,9 @@ void SDV_CRYPTO_SM2_KEY_PAIR_CHECK_FUNC_TC001(Hex *pubKey, Hex *prvKey, Hex *use
1037 1044 
1038 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);1045 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
1039 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);1046 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
1047+ if (expectRet == CRYPT_SUCCESS) {
1048+ ASSERT_TRUE(TestIsErrStackEmpty());
1049+ }
1040 1050 
1041EXIT:1051EXIT:
1042 TestRandDeInit();1052 TestRandDeInit();
@@ -1115,6 +1125,7 @@ void SDV_CRYPTO_SM2_CHECK_KEYPAIR_FUNC_TC001(int isProvider)
1115 1125 
1116 sm2PrvKey.key.eccPrv.data = wrong;1126 sm2PrvKey.key.eccPrv.data = wrong;
1117 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &sm2PrvKey), CRYPT_SUCCESS);1127 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &sm2PrvKey), CRYPT_SUCCESS);
1128+ ASSERT_TRUE(TestIsErrStackEmpty());
1118 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SM2_PAIRWISE_CHECK_FAIL);1129 ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SM2_PAIRWISE_CHECK_FAIL);
1119 1130 
1120EXIT:1131EXIT:
@@ -1232,6 +1243,7 @@ void SDV_CRYPTO_SM2_Import_Export_FUNC_TC001(void)
1232 1243 
1233 ASSERT_EQ(CRYPT_SM2_Sign(srcSm2Ctx, CRYPT_MD_SM3, msg, sizeof(msg), sign, &signLen), CRYPT_SUCCESS);1244 ASSERT_EQ(CRYPT_SM2_Sign(srcSm2Ctx, CRYPT_MD_SM3, msg, sizeof(msg), sign, &signLen), CRYPT_SUCCESS);
1234 ASSERT_EQ(CRYPT_SM2_Verify(dstSm2Ctx, CRYPT_MD_SM3, msg, sizeof(msg), sign, signLen), CRYPT_SUCCESS);1245 ASSERT_EQ(CRYPT_SM2_Verify(dstSm2Ctx, CRYPT_MD_SM3, msg, sizeof(msg), sign, signLen), CRYPT_SUCCESS);
1246+ ASSERT_TRUE(TestIsErrStackEmpty());
1235 1247 
1236EXIT:1248EXIT:
1237 CRYPT_SM2_FreeCtx(srcSm2Ctx);1249 CRYPT_SM2_FreeCtx(srcSm2Ctx);
@@ -1286,6 +1298,7 @@ void SDV_CRYPTO_SM2_SIGN_DATA_FUNC_TC001(int mdId, Hex *pubKey, Hex *prvKey, int
1286 if (mdId == CRYPT_MD_SM3) {1298 if (mdId == CRYPT_MD_SM3) {
1287 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg, sizeof(msg), signBuf, signLen), CRYPT_SUCCESS);1299 ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg, sizeof(msg), signBuf, signLen), CRYPT_SUCCESS);
1288 }1300 }
1301+ ASSERT_TRUE(TestIsErrStackEmpty());
1289 1302 
1290EXIT:1303EXIT:
1291 mdMethod->freeCtx(mdCtx);1304 mdMethod->freeCtx(mdCtx);
Mtestcode/sdv/testcase/crypto/sm3/test_suite_sdv_eal_sm3.c+8-0
@@ -146,6 +146,7 @@ void SDV_CRYPT_EAL_SM3_FUNC_TC001(Hex *hash)
146 ASSERT_EQ(outLen, 32);146 ASSERT_EQ(outLen, 32);
147 147 
148 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);148 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
149+ ASSERT_TRUE(TestIsErrStackEmpty());
149 150 
150EXIT:151EXIT:
151 CRYPT_EAL_MdFreeCtx(ctx);152 CRYPT_EAL_MdFreeCtx(ctx);
@@ -188,6 +189,7 @@ void SDV_CRYPT_EAL_SM3_FUNC_TC002(Hex *data, Hex *hash)
188 189 
189 ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_SM3, data->x, data->len, out, &outLen), CRYPT_SUCCESS);190 ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_SM3, data->x, data->len, out, &outLen), CRYPT_SUCCESS);
190 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);191 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
192+ ASSERT_TRUE(TestIsErrStackEmpty());
191EXIT:193EXIT:
192 CRYPT_EAL_MdFreeCtx(ctx);194 CRYPT_EAL_MdFreeCtx(ctx);
193}195}
@@ -234,6 +236,7 @@ void SDV_CRYPT_EAL_SM3_FUNC_TC003(Hex *data1, Hex *data2, Hex *data3, Hex *hash)
234 ASSERT_EQ(outLen, 32);236 ASSERT_EQ(outLen, 32);
235 237 
236 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);238 ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
239+ ASSERT_TRUE(TestIsErrStackEmpty());
237 240 
238EXIT:241EXIT:
239 CRYPT_EAL_MdFreeCtx(ctx);242 CRYPT_EAL_MdFreeCtx(ctx);
@@ -292,6 +295,7 @@ void SDV_CRYPT_EAL_SM3_FUNC_TC004(void)
292 outLen = CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3);295 outLen = CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3);
293 296 
294 ASSERT_EQ(memcmp(out1, out2, outLen), CRYPT_SUCCESS);297 ASSERT_EQ(memcmp(out1, out2, outLen), CRYPT_SUCCESS);
298+ ASSERT_TRUE(TestIsErrStackEmpty());
295 299 
296EXIT:300EXIT:
297 CRYPT_EAL_MdFreeCtx(ctx1);301 CRYPT_EAL_MdFreeCtx(ctx1);
@@ -337,6 +341,7 @@ void SDV_CRYPTO_SM3_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
337 ASSERT_TRUE(cpyCtx != NULL);341 ASSERT_TRUE(cpyCtx != NULL);
338 ASSERT_TRUE(dupCtx == NULL);342 ASSERT_TRUE(dupCtx == NULL);
339 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);343 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
344+ TestErrClear();
340 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);345 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
341 346 
342 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);347 ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
@@ -354,6 +359,7 @@ void SDV_CRYPTO_SM3_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
354 359 
355 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));360 ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
356 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);361 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
362+ ASSERT_TRUE(TestIsErrStackEmpty());
357EXIT:363EXIT:
358 CRYPT_EAL_MdFreeCtx(ctx);364 CRYPT_EAL_MdFreeCtx(ctx);
359 CRYPT_EAL_MdFreeCtx(cpyCtx);365 CRYPT_EAL_MdFreeCtx(cpyCtx);
@@ -386,6 +392,7 @@ void SDV_CRYPTO_SM3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
386 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);392 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
387 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);393 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
388 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);394 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
395+ ASSERT_TRUE(TestIsErrStackEmpty());
389 396 
390EXIT:397EXIT:
391 CRYPT_EAL_MdFreeCtx(ctx);398 CRYPT_EAL_MdFreeCtx(ctx);
@@ -421,6 +428,7 @@ void SDV_CRYPT_EAL_MD_SM3_FUNC_TC001(Hex *data, Hex *hash)
421 for (uint32_t i = 0; i < threadNum; i++) {428 for (uint32_t i = 0; i < threadNum; i++) {
422 pthread_join(thrd[i], NULL);429 pthread_join(thrd[i], NULL);
423 }430 }
431+ ASSERT_TRUE(TestIsErrStackEmpty());
424 432 
425EXIT:433EXIT:
426 return;434 return;
Mtestcode/sdv/testcase/crypto/sm4/test_suite_sdv_eal_sm4.c+21-0
@@ -520,6 +520,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC001(int id, Hex *key, Hex *iv, int padding, i
520 decLen = MAXSIZE - totalLen;520 decLen = MAXSIZE - totalLen;
521 ret = CRYPT_EAL_CipherFinal(ctxDec, result + totalLen, &decLen);521 ret = CRYPT_EAL_CipherFinal(ctxDec, result + totalLen, &decLen);
522 ASSERT_TRUE(ret == CRYPT_SUCCESS);522 ASSERT_TRUE(ret == CRYPT_SUCCESS);
523+ ASSERT_TRUE(TestIsErrStackEmpty());
523EXIT:524EXIT:
524 CRYPT_EAL_CipherFreeCtx(ctxEnc);525 CRYPT_EAL_CipherFreeCtx(ctxEnc);
525 CRYPT_EAL_CipherFreeCtx(ctxDec);526 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -587,6 +588,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC002(int algId, Hex *key, Hex *iv, int inLen,
587 ASSERT_EQ(CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen), CRYPT_SUCCESS);588 ASSERT_EQ(CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen), CRYPT_SUCCESS);
588 589 
589 ASSERT_TRUE(memcmp(input, result, inLen) == 0);590 ASSERT_TRUE(memcmp(input, result, inLen) == 0);
591+ ASSERT_TRUE(TestIsErrStackEmpty());
590EXIT:592EXIT:
591 CRYPT_EAL_CipherFreeCtx(ctxEnc);593 CRYPT_EAL_CipherFreeCtx(ctxEnc);
592 CRYPT_EAL_CipherFreeCtx(ctxDec);594 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -621,6 +623,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC003(int isProvider, int id, Hex *key, Hex *pl
621 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true), CRYPT_SUCCESS);623 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true), CRYPT_SUCCESS);
622 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, plainText->x, plainText->len, out, &len), CRYPT_SUCCESS);624 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, plainText->x, plainText->len, out, &len), CRYPT_SUCCESS);
623 ASSERT_TRUE(memcmp(out, cipherText->x, len) == 0);625 ASSERT_TRUE(memcmp(out, cipherText->x, len) == 0);
626+ ASSERT_TRUE(TestIsErrStackEmpty());
624EXIT:627EXIT:
625 CRYPT_EAL_CipherFreeCtx(ctx);628 CRYPT_EAL_CipherFreeCtx(ctx);
626}629}
@@ -657,6 +660,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC004(int isProvider, int id, Hex *key, Hex *pl
657 ret = CRYPT_EAL_CipherUpdate(ctx, cipherText->x, cipherText->len, out, &len);660 ret = CRYPT_EAL_CipherUpdate(ctx, cipherText->x, cipherText->len, out, &len);
658 ASSERT_TRUE(ret == CRYPT_SUCCESS);661 ASSERT_TRUE(ret == CRYPT_SUCCESS);
659 ASSERT_TRUE(memcmp(out, plainText->x, len) == 0);662 ASSERT_TRUE(memcmp(out, plainText->x, len) == 0);
663+ ASSERT_TRUE(TestIsErrStackEmpty());
660EXIT:664EXIT:
661 CRYPT_EAL_CipherFreeCtx(ctx);665 CRYPT_EAL_CipherFreeCtx(ctx);
662}666}
@@ -733,6 +737,7 @@ void SDV_CRYPTO_SM4_MULTI_UPDATE_TC001(int algId, Hex *key, Hex *iv, Hex *in, in
733 ASSERT_TRUE(ret == CRYPT_SUCCESS);737 ASSERT_TRUE(ret == CRYPT_SUCCESS);
734 ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);738 ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);
735 ASSERT_TRUE(memcmp(in->x, result + in->len, in->len) == 0);739 ASSERT_TRUE(memcmp(in->x, result + in->len, in->len) == 0);
740+ ASSERT_TRUE(TestIsErrStackEmpty());
736EXIT:741EXIT:
737 CRYPT_EAL_CipherFreeCtx(ctxEnc);742 CRYPT_EAL_CipherFreeCtx(ctxEnc);
738 CRYPT_EAL_CipherFreeCtx(ctxDec);743 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -822,6 +827,7 @@ void SDV_CRYPTO_SM4_MULTI_UPDATE_TC002(int algId, Hex *key, Hex *iv, Hex *in, in
822 827 
823 ASSERT_TRUE(memcmp(in->x, result, BLOCKSIZE - 1) == 0);828 ASSERT_TRUE(memcmp(in->x, result, BLOCKSIZE - 1) == 0);
824 ASSERT_TRUE(memcmp(in->x, result + BLOCKSIZE - 1, BLOCKSIZE) == 0);829 ASSERT_TRUE(memcmp(in->x, result + BLOCKSIZE - 1, BLOCKSIZE) == 0);
830+ ASSERT_TRUE(TestIsErrStackEmpty());
825EXIT:831EXIT:
826 CRYPT_EAL_CipherFreeCtx(ctxEnc);832 CRYPT_EAL_CipherFreeCtx(ctxEnc);
827 CRYPT_EAL_CipherFreeCtx(ctxDec);833 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -981,6 +987,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC005(int isProvider, Hex *key, Hex *in1, Hex *
981 ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);987 ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);
982 ASSERT_TRUE(ret == CRYPT_SUCCESS);988 ASSERT_TRUE(ret == CRYPT_SUCCESS);
983 ASSERT_TRUE(memcmp(outTmp, out1->x, out1->len) == 0);989 ASSERT_TRUE(memcmp(outTmp, out1->x, out1->len) == 0);
990+ ASSERT_TRUE(TestIsErrStackEmpty());
984EXIT:991EXIT:
985 CRYPT_EAL_CipherFreeCtx(ctx);992 CRYPT_EAL_CipherFreeCtx(ctx);
986}993}
@@ -1060,6 +1067,7 @@ void SDV_CRYPTO_SM4_MULTI_THREAD_TC001(int algId, Hex *key, Hex *in, Hex *out, H
1060 for (uint32_t i = 0; i < THREAD_NUM; i++) {1067 for (uint32_t i = 0; i < THREAD_NUM; i++) {
1061 pthread_join(thrd[i], NULL);1068 pthread_join(thrd[i], NULL);
1062 }1069 }
1070+ ASSERT_TRUE(TestIsErrStackEmpty());
1063EXIT:1071EXIT:
1064 return;1072 return;
1065}1073}
@@ -1096,6 +1104,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC006(int id, Hex *key, Hex *iv, Hex *msg, int
1096 ret = CRYPT_EAL_CipherUpdate(ctx, msg->x, msg->len, out, &outlen);1104 ret = CRYPT_EAL_CipherUpdate(ctx, msg->x, msg->len, out, &outlen);
1097 ASSERT_TRUE(ret == CRYPT_SUCCESS);1105 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1098 outlen = MAX_OUTPUT;1106 outlen = MAX_OUTPUT;
1107+ ASSERT_TRUE(TestIsErrStackEmpty());
1099 ret = CRYPT_EAL_CipherFinal(ctx, out, &outlen);1108 ret = CRYPT_EAL_CipherFinal(ctx, out, &outlen);
1100 ASSERT_TRUE(ret != CRYPT_SUCCESS);1109 ASSERT_TRUE(ret != CRYPT_SUCCESS);
1101EXIT:1110EXIT:
@@ -1138,6 +1147,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC007(int id, Hex *key, Hex *iv, int enc)
1138 ASSERT_TRUE(ret == CRYPT_SUCCESS);1147 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1139 }1148 }
1140 ASSERT_TRUE(outlen == 0);1149 ASSERT_TRUE(outlen == 0);
1150+ ASSERT_TRUE(TestIsErrStackEmpty());
1141EXIT:1151EXIT:
1142 CRYPT_EAL_CipherFreeCtx(ctx);1152 CRYPT_EAL_CipherFreeCtx(ctx);
1143}1153}
@@ -1194,6 +1204,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC008(int isProvider, int algId, Hex *key, Hex
1194 ret = Sm4CipherFinal(algId, ctx, outTmp + len, &finLen);1204 ret = Sm4CipherFinal(algId, ctx, outTmp + len, &finLen);
1195 ASSERT_TRUE(ret == CRYPT_SUCCESS);1205 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1196 ASSERT_COMPARE("Cipher compare", out->x, out->len, outTmp, len + finLen);1206 ASSERT_COMPARE("Cipher compare", out->x, out->len, outTmp, len + finLen);
1207+ ASSERT_TRUE(TestIsErrStackEmpty());
1197EXIT:1208EXIT:
1198 CRYPT_EAL_CipherFreeCtx(ctx);1209 CRYPT_EAL_CipherFreeCtx(ctx);
1199}1210}
@@ -1250,6 +1261,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC009(int isProvider, int algId, Hex *key, Hex
1250 ret = Sm4CipherFinal(algId, ctx, outTmp + len, &finLen);1261 ret = Sm4CipherFinal(algId, ctx, outTmp + len, &finLen);
1251 ASSERT_TRUE(ret == CRYPT_SUCCESS);1262 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1252 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);1263 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
1264+ ASSERT_TRUE(TestIsErrStackEmpty());
1253EXIT:1265EXIT:
1254 CRYPT_EAL_CipherFreeCtx(ctx);1266 CRYPT_EAL_CipherFreeCtx(ctx);
1255}1267}
@@ -1325,6 +1337,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC010(int algId, Hex *key, Hex *iv, int inLen,
1325 ASSERT_TRUE(ret == CRYPT_SUCCESS);1337 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1326 1338 
1327 ASSERT_TRUE(memcmp(input, result, inLen) == 0);1339 ASSERT_TRUE(memcmp(input, result, inLen) == 0);
1340+ ASSERT_TRUE(TestIsErrStackEmpty());
1328EXIT:1341EXIT:
1329 CRYPT_EAL_CipherFreeCtx(ctxEnc);1342 CRYPT_EAL_CipherFreeCtx(ctxEnc);
1330 CRYPT_EAL_CipherFreeCtx(ctxDec);1343 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -1403,6 +1416,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC011(int algId, Hex *key, Hex *iv, int inLen,
1403 ASSERT_TRUE(ret == CRYPT_SUCCESS);1416 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1404 1417 
1405 ASSERT_TRUE(memcmp(input, result, inLen) == 0);1418 ASSERT_TRUE(memcmp(input, result, inLen) == 0);
1419+ ASSERT_TRUE(TestIsErrStackEmpty());
1406EXIT:1420EXIT:
1407 CRYPT_EAL_CipherFreeCtx(ctxEnc);1421 CRYPT_EAL_CipherFreeCtx(ctxEnc);
1408 CRYPT_EAL_CipherFreeCtx(ctxDec);1422 CRYPT_EAL_CipherFreeCtx(ctxDec);
@@ -1448,6 +1462,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC012(int algId, Hex *key, Hex *iv, Hex *in, He
1448 ASSERT_TRUE(ret == CRYPT_SUCCESS);1462 ASSERT_TRUE(ret == CRYPT_SUCCESS);
1449 }1463 }
1450 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);1464 ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
1465+ ASSERT_TRUE(TestIsErrStackEmpty());
1451EXIT:1466EXIT:
1452 CRYPT_EAL_CipherFreeCtx(ctx);1467 CRYPT_EAL_CipherFreeCtx(ctx);
1453}1468}
@@ -1506,6 +1521,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC013(Hex *key, Hex *iv, Hex *aad, Hex *pt, Hex
1506 ASSERT_TRUE(memcmp(out, ct->x, ct->len) == 0);1521 ASSERT_TRUE(memcmp(out, ct->x, ct->len) == 0);
1507 }1522 }
1508 ASSERT_COMPARE("Compare Tag", outTag, tagLen, tag->x, tag->len);1523 ASSERT_COMPARE("Compare Tag", outTag, tagLen, tag->x, tag->len);
1524+ ASSERT_TRUE(TestIsErrStackEmpty());
1509 1525 
1510EXIT:1526EXIT:
1511 CRYPT_EAL_CipherFreeCtx(ctx);1527 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1560,6 +1576,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC014(int isProvider, int algId, Hex *key, Hex
1560 1576 
1561 ASSERT_TRUE(totalLen == out->len);1577 ASSERT_TRUE(totalLen == out->len);
1562 ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);1578 ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);
1579+ ASSERT_TRUE(TestIsErrStackEmpty());
1563 1580 
1564EXIT:1581EXIT:
1565 CRYPT_EAL_CipherDeinit(ctxEnc);1582 CRYPT_EAL_CipherDeinit(ctxEnc);
@@ -1612,6 +1629,7 @@ void SDV_CRYPTO_SM4_ENCRYPT_FUNC_TC015(int isProvider, int algId, Hex *key, Hex
1612 1629 
1613 ASSERT_TRUE(totalLen == out->len);1630 ASSERT_TRUE(totalLen == out->len);
1614 ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);1631 ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);
1632+ ASSERT_TRUE(TestIsErrStackEmpty());
1615 1633 
1616EXIT:1634EXIT:
1617 CRYPT_EAL_CipherDeinit(ctxDec);1635 CRYPT_EAL_CipherDeinit(ctxDec);
@@ -1650,6 +1668,7 @@ void SDV_CRYPTO_SM4_CCM_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex
1650 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, outTagLen), CRYPT_SUCCESS);1668 ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, outTagLen), CRYPT_SUCCESS);
1651 ASSERT_COMPARE("Compare ciphertext", result, out->len, out->x, out->len);1669 ASSERT_COMPARE("Compare ciphertext", result, out->len, out->x, out->len);
1652 ASSERT_COMPARE("Compare Tag", outTag, outTagLen, tag->x, tag->len);1670 ASSERT_COMPARE("Compare Tag", outTag, outTagLen, tag->x, tag->len);
1671+ ASSERT_TRUE(TestIsErrStackEmpty());
1653 1672 
1654EXIT:1673EXIT:
1655 CRYPT_EAL_CipherFreeCtx(ctx);1674 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1727,6 +1746,7 @@ void SDV_CRYPTO_SM4_HCTR_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *tw
1727 ASSERT_EQ(outLen, cipher->len);1746 ASSERT_EQ(outLen, cipher->len);
1728 1747 
1729 ASSERT_COMPARE("HCTR Decrypt Compare", plain->x, plain->len, decryptedTmp, outLen);1748 ASSERT_COMPARE("HCTR Decrypt Compare", plain->x, plain->len, decryptedTmp, outLen);
1749+ ASSERT_TRUE(TestIsErrStackEmpty());
1730 1750 
1731EXIT:1751EXIT:
1732 CRYPT_EAL_CipherFreeCtx(ctx);1752 CRYPT_EAL_CipherFreeCtx(ctx);
@@ -1854,6 +1874,7 @@ void SDV_CRYPTO_EAL_SM4_FUNC_TC005(int algId, Hex *key, Hex *iv, Hex *pt)
1854 ASSERT_TRUE(x26 == value);1874 ASSERT_TRUE(x26 == value);
1855 ASSERT_TRUE(x27 == value);1875 ASSERT_TRUE(x27 == value);
1856 ASSERT_TRUE(x28 == value);1876 ASSERT_TRUE(x28 == value);
1877+ ASSERT_TRUE(TestIsErrStackEmpty());
1857EXIT:1878EXIT:
1858 CRYPT_EAL_CipherFreeCtx(ctx);1879 CRYPT_EAL_CipherFreeCtx(ctx);
1859#endif1880#endif
Mtestcode/sdv/testcase/crypto/sm9/test_suite_sdv_eal_sm9_crypt.c+1-0
@@ -134,6 +134,7 @@ void SDV_CRYPTO_SM9_CRYPT_API_TC001(Hex *masterKey, Hex *userId, Hex *plaintext)
134 134 
135 // Step 6: Verify decrypted matches original135 // Step 6: Verify decrypted matches original
136 ASSERT_TRUE(memcmp(decrypted, plaintext->x, plaintext->len) == 0);136 ASSERT_TRUE(memcmp(decrypted, plaintext->x, plaintext->len) == 0);
137+ ASSERT_TRUE(TestIsErrStackEmpty());
137 138 
138EXIT:139EXIT:
139 CRYPT_EAL_PkeyFreeCtx(encCtx);140 CRYPT_EAL_PkeyFreeCtx(encCtx);
Mtestcode/sdv/testcase/crypto/sm9/test_suite_sdv_eal_sm9_exchange.c+1-0
@@ -135,6 +135,7 @@ void SDV_CRYPTO_SM9_KEYEX_API_TC001(Hex *masterKey, Hex *userIdA, Hex *userIdB)
135 // Verify shared keys match135 // Verify shared keys match
136 ASSERT_EQ(keyLen_A, keyLen_B);136 ASSERT_EQ(keyLen_A, keyLen_B);
137 ASSERT_TRUE(memcmp(SK_A, SK_B, keyLen_A) == 0);137 ASSERT_TRUE(memcmp(SK_A, SK_B, keyLen_A) == 0);
138+ ASSERT_TRUE(TestIsErrStackEmpty());
138 139 
139 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ctx_a, ctx_b, SK_Long, &longKeyLen), CRYPT_SUCCESS);140 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ctx_a, ctx_b, SK_Long, &longKeyLen), CRYPT_SUCCESS);
140 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ctx_a, ctx_b, SK_Short, &shortKeyLen), CRYPT_SUCCESS);141 ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ctx_a, ctx_b, SK_Short, &shortKeyLen), CRYPT_SUCCESS);
Mtestcode/sdv/testcase/crypto/sm9/test_suite_sdv_eal_sm9_sign.c+2-0
@@ -998,6 +998,7 @@ void SDV_CRYPTO_SM9_CHECK_KEYPAIR_FUNC_TC001(Hex *masterKey, Hex *userId1, Hex *
998 // Step 6: Change user ID in master context to userId2998 // Step 6: Change user ID in master context to userId2
999 ret = CRYPT_EAL_PkeyCtrl(masterCtx, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len);999 ret = CRYPT_EAL_PkeyCtrl(masterCtx, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len);
1000 ASSERT_EQ(ret, CRYPT_SUCCESS);1000 ASSERT_EQ(ret, CRYPT_SUCCESS);
1001+ ASSERT_TRUE(TestIsErrStackEmpty());
1001 1002 
1002 // Step 7: Check key pair again - should fail (different user IDs)1003 // Step 7: Check key pair again - should fail (different user IDs)
1003 ret = CRYPT_EAL_PkeyPairCheck(masterCtx, userCtx);1004 ret = CRYPT_EAL_PkeyPairCheck(masterCtx, userCtx);
@@ -1065,6 +1066,7 @@ void SDV_CRYPTO_SM9_CHECK_PRVKEY_FUNC_TC001(Hex *masterKey, Hex *userId)
1065 // Step 5: Check private key - should succeed now1066 // Step 5: Check private key - should succeed now
1066 ret = CRYPT_EAL_PkeyPrvCheck(ctx);1067 ret = CRYPT_EAL_PkeyPrvCheck(ctx);
1067 ASSERT_EQ(ret, CRYPT_SUCCESS);1068 ASSERT_EQ(ret, CRYPT_SUCCESS);
1069+ ASSERT_TRUE(TestIsErrStackEmpty());
1068 1070 
1069EXIT:1071EXIT:
1070 CRYPT_EAL_PkeyFreeCtx(ctx);1072 CRYPT_EAL_PkeyFreeCtx(ctx);
Mtestcode/sdv/testcase/crypto/xmss/test_suite_sdv_eal_xmss.c+8-0
@@ -188,6 +188,7 @@ void SDV_CRYPTO_XMSS_GETSET_KEY_TC002(void)
188 prv.key.xmssPrv.pub.len = 32;188 prv.key.xmssPrv.pub.len = 32;
189 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);189 ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
190 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);190 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
191+ ASSERT_TRUE(TestIsErrStackEmpty());
191EXIT:192EXIT:
192 CRYPT_EAL_PkeyFreeCtx(pkey);193 CRYPT_EAL_PkeyFreeCtx(pkey);
193 return;194 return;
@@ -227,6 +228,7 @@ void SDV_CRYPTO_XMSS_GENKEY_KAT_TC001(int id, Hex *key, Hex *root)
227 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubOut), CRYPT_SUCCESS);228 ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubOut), CRYPT_SUCCESS);
228 ASSERT_EQ(memcmp(pubOut.key.xmssPub.seed, root->x, hashLen), 0);229 ASSERT_EQ(memcmp(pubOut.key.xmssPub.seed, root->x, hashLen), 0);
229 ASSERT_EQ(memcmp(pubOut.key.xmssPub.root, root->x + hashLen, hashLen), 0);230 ASSERT_EQ(memcmp(pubOut.key.xmssPub.root, root->x + hashLen, hashLen), 0);
231+ ASSERT_TRUE(TestIsErrStackEmpty());
230 232 
231EXIT:233EXIT:
232 CRYPT_EAL_PkeyFreeCtx(pkey);234 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -268,6 +270,9 @@ void SDV_CRYPTO_XMSS_SIGN_KAT_TC001(int id, int index, Hex *key, Hex *msg, Hex *
268 ASSERT_TRUE(sigOutLen == sig->len);270 ASSERT_TRUE(sigOutLen == sig->len);
269 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);271 ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);
270 }272 }
273+ if (result == CRYPT_SUCCESS) {
274+ ASSERT_TRUE(TestIsErrStackEmpty());
275+ }
271EXIT:276EXIT:
272 CRYPT_EAL_PkeyFreeCtx(pkey);277 CRYPT_EAL_PkeyFreeCtx(pkey);
273 return;278 return;
@@ -295,6 +300,9 @@ void SDV_CRYPTO_XMSS_VERIFY_KAT_TC001(int id, Hex *key, Hex *msg, Hex *sig, int
295 pub.key.xmssPub.len = keyLen;300 pub.key.xmssPub.len = keyLen;
296 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);301 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
297 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, 0, msg->x, msg->len, sig->x, sig->len), result);302 ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, 0, msg->x, msg->len, sig->x, sig->len), result);
303+ if (result == CRYPT_SUCCESS) {
304+ ASSERT_TRUE(TestIsErrStackEmpty());
305+ }
298EXIT:306EXIT:
299 CRYPT_EAL_PkeyFreeCtx(pkey);307 CRYPT_EAL_PkeyFreeCtx(pkey);
300 return;308 return;
Mtestcode/sdv/testcase/pki/cert/test_suite_sdv_x509_cert.c+34-1
@@ -55,6 +55,7 @@ void SDV_X509_CERT_PARSE_FUNC_TC001(int format, char *path)
55 HITLS_X509_Cert *cert = NULL;55 HITLS_X509_Cert *cert = NULL;
56 int32_t ret = HITLS_X509_CertParseFile(format, path, &cert);56 int32_t ret = HITLS_X509_CertParseFile(format, path, &cert);
57 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);57 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
58+ ASSERT_TRUE(TestIsErrStackEmpty());
58EXIT:59EXIT:
59 HITLS_X509_CertFree(cert);60 HITLS_X509_CertFree(cert);
60 BSL_GLOBAL_DeInit();61 BSL_GLOBAL_DeInit();
@@ -77,6 +78,7 @@ void SDV_X509_CERT_PARSE_PUBKEY_FUNC_TC002(int format, char *path, Hex *key)
77 ASSERT_COMPARE("seed", pubKey.key.xmssPub.seed, 32, key->x + 36, (key->len - 4) / 2);78 ASSERT_COMPARE("seed", pubKey.key.xmssPub.seed, 32, key->x + 36, (key->len - 4) / 2);
78 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_XMSS_XDR_ALG_TYPE, buf, 4), HITLS_PKI_SUCCESS);79 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_XMSS_XDR_ALG_TYPE, buf, 4), HITLS_PKI_SUCCESS);
79 ASSERT_COMPARE("xdr", buf, 4, key->x, 4);80 ASSERT_COMPARE("xdr", buf, 4, key->x, 4);
81+ ASSERT_TRUE(TestIsErrStackEmpty());
80 82 
81EXIT:83EXIT:
82 HITLS_X509_CertFree(cert);84 HITLS_X509_CertFree(cert);
@@ -90,6 +92,7 @@ void SDV_X509_CERT_PARSE_VERSION_FUNC_TC001(char *path, int version)
90 HITLS_X509_Cert *cert = NULL;92 HITLS_X509_Cert *cert = NULL;
91 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, path, &cert), HITLS_PKI_SUCCESS);93 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, path, &cert), HITLS_PKI_SUCCESS);
92 ASSERT_EQ(cert->tbs.version, version);94 ASSERT_EQ(cert->tbs.version, version);
95+ ASSERT_TRUE(TestIsErrStackEmpty());
93EXIT:96EXIT:
94 HITLS_X509_CertFree(cert);97 HITLS_X509_CertFree(cert);
95}98}
@@ -103,6 +106,7 @@ void SDV_X509_CERT_PARSE_SERIALNUM_FUNC_TC001(char *path, Hex *serialNum)
103 ASSERT_EQ(cert->tbs.serialNum.tag, 2);106 ASSERT_EQ(cert->tbs.serialNum.tag, 2);
104 ASSERT_COMPARE("serialNum", cert->tbs.serialNum.buff, cert->tbs.serialNum.len,107 ASSERT_COMPARE("serialNum", cert->tbs.serialNum.buff, cert->tbs.serialNum.len,
105 serialNum->x, serialNum->len);108 serialNum->x, serialNum->len);
109+ ASSERT_TRUE(TestIsErrStackEmpty());
106EXIT:110EXIT:
107 HITLS_X509_CertFree(cert);111 HITLS_X509_CertFree(cert);
108}112}
@@ -119,6 +123,7 @@ void SDV_X509_CERT_PARSE_TBS_SIGNALG_FUNC_TC001(char *path, int signAlg,
119 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.mdId, rsaPssHash);123 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.mdId, rsaPssHash);
120 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.mgfId, rsaPssMgf1);124 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.mgfId, rsaPssMgf1);
121 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);125 ASSERT_EQ(cert->tbs.signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);
126+ ASSERT_TRUE(TestIsErrStackEmpty());
122 127 
123EXIT:128EXIT:
124 HITLS_X509_CertFree(cert);129 HITLS_X509_CertFree(cert);
@@ -181,7 +186,7 @@ void SDV_X509_CERT_PARSE_ISSUERNAME_FUNC_TC002(char *path, int count,
181{186{
182 HITLS_X509_Cert *cert = NULL;187 HITLS_X509_Cert *cert = NULL;
183 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, path, &cert), HITLS_PKI_SUCCESS);188 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, path, &cert), HITLS_PKI_SUCCESS);
184- 189+ ASSERT_TRUE(TestIsErrStackEmpty());
185 BSL_ASN1_Buffer expAsan1Arr[] = {190 BSL_ASN1_Buffer expAsan1Arr[] = {
186 {6, type1->len, type1->x}, {(uint8_t)tag1, value1->len, value1->x}191 {6, type1->len, type1->x}, {(uint8_t)tag1, value1->len, value1->x}
187 };192 };
@@ -288,6 +293,7 @@ void SDV_X509_CERT_PARSE_START_TIME_FUNC_TC001(char *path,
288 ASSERT_EQ(cert->tbs.validTime.start.hour, hour);293 ASSERT_EQ(cert->tbs.validTime.start.hour, hour);
289 ASSERT_EQ(cert->tbs.validTime.start.minute, minute);294 ASSERT_EQ(cert->tbs.validTime.start.minute, minute);
290 ASSERT_EQ(cert->tbs.validTime.start.second, second);295 ASSERT_EQ(cert->tbs.validTime.start.second, second);
296+ ASSERT_TRUE(TestIsErrStackEmpty());
291EXIT:297EXIT:
292 HITLS_X509_CertFree(cert);298 HITLS_X509_CertFree(cert);
293}299}
@@ -306,6 +312,7 @@ void SDV_X509_CERTPEM_PARSE_START_TIME_FUNC_TC001(char *path,
306 ASSERT_EQ(cert->tbs.validTime.start.hour, hour);312 ASSERT_EQ(cert->tbs.validTime.start.hour, hour);
307 ASSERT_EQ(cert->tbs.validTime.start.minute, minute);313 ASSERT_EQ(cert->tbs.validTime.start.minute, minute);
308 ASSERT_EQ(cert->tbs.validTime.start.second, second);314 ASSERT_EQ(cert->tbs.validTime.start.second, second);
315+ ASSERT_TRUE(TestIsErrStackEmpty());
309EXIT:316EXIT:
310 HITLS_X509_CertFree(cert);317 HITLS_X509_CertFree(cert);
311}318}
@@ -324,6 +331,7 @@ void SDV_X509_CERTPEM_PARSE_END_TIME_FUNC_TC001(char *path,
324 ASSERT_EQ(cert->tbs.validTime.end.hour, hour);331 ASSERT_EQ(cert->tbs.validTime.end.hour, hour);
325 ASSERT_EQ(cert->tbs.validTime.end.minute, minute);332 ASSERT_EQ(cert->tbs.validTime.end.minute, minute);
326 ASSERT_EQ(cert->tbs.validTime.end.second, second);333 ASSERT_EQ(cert->tbs.validTime.end.second, second);
334+ ASSERT_TRUE(TestIsErrStackEmpty());
327EXIT:335EXIT:
328 HITLS_X509_CertFree(cert);336 HITLS_X509_CertFree(cert);
329}337}
@@ -342,6 +350,7 @@ void SDV_X509_CERT_PARSE_END_TIME_FUNC_TC001(char *path,
342 ASSERT_EQ(cert->tbs.validTime.end.hour, hour);350 ASSERT_EQ(cert->tbs.validTime.end.hour, hour);
343 ASSERT_EQ(cert->tbs.validTime.end.minute, minute);351 ASSERT_EQ(cert->tbs.validTime.end.minute, minute);
344 ASSERT_EQ(cert->tbs.validTime.end.second, second);352 ASSERT_EQ(cert->tbs.validTime.end.second, second);
353+ ASSERT_TRUE(TestIsErrStackEmpty());
345EXIT:354EXIT:
346 HITLS_X509_CertFree(cert);355 HITLS_X509_CertFree(cert);
347}356}
@@ -367,6 +376,7 @@ void SDV_X509_CERT_PARSE_SUBJECTNAME_FUNC_TC001(char *path, int count,
367 {6, type5->len, type5->x}, {(uint8_t)tag5, value5->len, value5->x},376 {6, type5->len, type5->x}, {(uint8_t)tag5, value5->len, value5->x},
368 {6, type6->len, type6->x}, {(uint8_t)tag6, value6->len, value6->x},377 {6, type6->len, type6->x}, {(uint8_t)tag6, value6->len, value6->x},
369 };378 };
379+ ASSERT_TRUE(TestIsErrStackEmpty());
370 ASSERT_EQ(BSL_LIST_COUNT(cert->tbs.subjectName), count);380 ASSERT_EQ(BSL_LIST_COUNT(cert->tbs.subjectName), count);
371 HITLS_X509_NameNode **nameNode = NULL;381 HITLS_X509_NameNode **nameNode = NULL;
372 nameNode = BSL_LIST_First(cert->tbs.subjectName);382 nameNode = BSL_LIST_First(cert->tbs.subjectName);
@@ -509,7 +519,9 @@ void SDV_X509_CERT_CTRL_FUNC_TC001(char *path, int expRawDataLen, int expSignAlg
509 int32_t mdAlg = 0;519 int32_t mdAlg = 0;
510 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGNALG, &alg, sizeof(alg)), HITLS_PKI_SUCCESS);520 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGNALG, &alg, sizeof(alg)), HITLS_PKI_SUCCESS);
511 ASSERT_EQ(alg, expSignAlg);521 ASSERT_EQ(alg, expSignAlg);
522+ ASSERT_TRUE(TestIsErrStackEmpty());
512 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGN_MDALG, &mdAlg, sizeof(mdAlg) - 1), HITLS_X509_ERR_INVALID_PARAM);523 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGN_MDALG, &mdAlg, sizeof(mdAlg) - 1), HITLS_X509_ERR_INVALID_PARAM);
524+ TestErrClear();
513 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGN_MDALG, &mdAlg, sizeof(mdAlg)), HITLS_PKI_SUCCESS);525 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGN_MDALG, &mdAlg, sizeof(mdAlg)), HITLS_PKI_SUCCESS);
514 ASSERT_EQ(mdAlg, expSignMdAlg);526 ASSERT_EQ(mdAlg, expSignMdAlg);
515 527 
@@ -525,6 +537,7 @@ void SDV_X509_CERT_CTRL_FUNC_TC001(char *path, int expRawDataLen, int expSignAlg
525 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_CERT_SIGN) != 0, expKuCertSign);537 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_CERT_SIGN) != 0, expKuCertSign);
526 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_AGREEMENT) != 0, expKuKeyAgreement);538 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_AGREEMENT) != 0, expKuKeyAgreement);
527 }539 }
540+ ASSERT_TRUE(TestIsErrStackEmpty());
528 541 
529EXIT:542EXIT:
530 HITLS_X509_CertFree(cert);543 HITLS_X509_CertFree(cert);
@@ -568,6 +581,7 @@ void SDV_X509_CERT_CTRL_FUNC_TC002(char *path, char *expectedSerialNum, char *ex
568 ASSERT_NE(afterTime.data, NULL);581 ASSERT_NE(afterTime.data, NULL);
569 ASSERT_EQ (afterTime.dataLen, strlen(expectedAfterTime));582 ASSERT_EQ (afterTime.dataLen, strlen(expectedAfterTime));
570 ASSERT_EQ(strcmp((char *)afterTime.data, expectedAfterTime), 0);583 ASSERT_EQ(strcmp((char *)afterTime.data, expectedAfterTime), 0);
584+ ASSERT_TRUE(TestIsErrStackEmpty());
571EXIT:585EXIT:
572 HITLS_X509_CertFree(cert);586 HITLS_X509_CertFree(cert);
573 BSL_SAL_FREE(subjectName.data);587 BSL_SAL_FREE(subjectName.data);
@@ -590,6 +604,7 @@ void SDV_X509_CERT_PARSE_PUBKEY_FUNC_TC001(char *path, char *path2)
590 604 
591 ASSERT_EQ(HITLS_X509_CheckSignature(cert2->tbs.ealPubKey, cert->tbs.tbsRawData, cert->tbs.tbsRawDataLen,605 ASSERT_EQ(HITLS_X509_CheckSignature(cert2->tbs.ealPubKey, cert->tbs.tbsRawData, cert->tbs.tbsRawDataLen,
592 &cert->signAlgId, &cert->signature), HITLS_PKI_SUCCESS);606 &cert->signAlgId, &cert->signature), HITLS_PKI_SUCCESS);
607+ ASSERT_TRUE(TestIsErrStackEmpty());
593EXIT:608EXIT:
594 HITLS_X509_CertFree(cert);609 HITLS_X509_CertFree(cert);
595 HITLS_X509_CertFree(cert2);610 HITLS_X509_CertFree(cert2);
@@ -619,6 +634,7 @@ void SDV_X509_CERT_DUP_FUNC_TC001(char *path, int expSignAlg,
619 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_CERT_SIGN) != 0, expKuCertSign);634 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_CERT_SIGN) != 0, expKuCertSign);
620 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_AGREEMENT) != 0, expKuKeyAgreement);635 ASSERT_EQ((keyUsage & HITLS_X509_EXT_KU_KEY_AGREEMENT) != 0, expKuKeyAgreement);
621 }636 }
637+ ASSERT_TRUE(TestIsErrStackEmpty());
622 638 
623EXIT:639EXIT:
624 HITLS_X509_CertFree(cert);640 HITLS_X509_CertFree(cert);
@@ -668,6 +684,7 @@ void SDV_X509_CERT_PARSE_EXTENSIONS_FUNC_TC001(char *path, int extNum, int isCA,
668 "value", (*node)->extnValue.buff, (*node)->extnValue.len, arr[i].extnValue.buff, arr[i].extnValue.len);684 "value", (*node)->extnValue.buff, (*node)->extnValue.len, arr[i].extnValue.buff, arr[i].extnValue.len);
669 node = BSL_LIST_Next(cert->tbs.ext.extList);685 node = BSL_LIST_Next(cert->tbs.ext.extList);
670 }686 }
687+ ASSERT_TRUE(TestIsErrStackEmpty());
671EXIT:688EXIT:
672 HITLS_X509_CertFree(cert);689 HITLS_X509_CertFree(cert);
673}690}
@@ -685,6 +702,7 @@ void SDV_X509_CERT_PARSE_SIGNALG_FUNC_TC001(char *path, int signAlg,
685 ASSERT_EQ(cert->signAlgId.rsaPssParam.mdId, rsaPssHash);702 ASSERT_EQ(cert->signAlgId.rsaPssParam.mdId, rsaPssHash);
686 ASSERT_EQ(cert->signAlgId.rsaPssParam.mgfId, rsaPssMgf1);703 ASSERT_EQ(cert->signAlgId.rsaPssParam.mgfId, rsaPssMgf1);
687 ASSERT_EQ(cert->signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);704 ASSERT_EQ(cert->signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);
705+ ASSERT_TRUE(TestIsErrStackEmpty());
688 706 
689EXIT:707EXIT:
690 HITLS_X509_CertFree(cert);708 HITLS_X509_CertFree(cert);
@@ -700,6 +718,7 @@ void SDV_X509_CERT_PARSE_SIGNATURE_FUNC_TC001(char *path, Hex *buff, int unusedB
700 ASSERT_EQ(cert->signature.len, buff->len);718 ASSERT_EQ(cert->signature.len, buff->len);
701 ASSERT_COMPARE("signature", cert->signature.buff, cert->signature.len, buff->x, buff->len);719 ASSERT_COMPARE("signature", cert->signature.buff, cert->signature.len, buff->x, buff->len);
702 ASSERT_EQ(cert->signature.unusedBits, unusedBits);720 ASSERT_EQ(cert->signature.unusedBits, unusedBits);
721+ ASSERT_TRUE(TestIsErrStackEmpty());
703EXIT:722EXIT:
704 HITLS_X509_CertFree(cert);723 HITLS_X509_CertFree(cert);
705}724}
@@ -731,6 +750,7 @@ void SDV_X509_CERT_PARSE_BUNDLE_BUFF_FUNC_TC001(int format, char *path, int cert
731 // Parse certificates from buffer750 // Parse certificates from buffer
732 ASSERT_EQ(HITLS_X509_CertParseBundleBuff(format, &encodeData, &list), HITLS_PKI_SUCCESS);751 ASSERT_EQ(HITLS_X509_CertParseBundleBuff(format, &encodeData, &list), HITLS_PKI_SUCCESS);
733 ASSERT_EQ(BSL_LIST_COUNT(list), certNum);752 ASSERT_EQ(BSL_LIST_COUNT(list), certNum);
753+ ASSERT_TRUE(TestIsErrStackEmpty());
734 754
735EXIT:755EXIT:
736 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);756 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -751,6 +771,7 @@ void SDV_X509_PROVIDER_CERT_PARSE_BUNDLE_BUFF_FUNC_TC001(char *format, char *pat
751 // Parse certificates from buffer using provider mechanism771 // Parse certificates from buffer using provider mechanism
752 ASSERT_EQ(HITLS_X509_ProviderCertParseBundleBuff(NULL, NULL, format, &encodeData, &list), HITLS_PKI_SUCCESS);772 ASSERT_EQ(HITLS_X509_ProviderCertParseBundleBuff(NULL, NULL, format, &encodeData, &list), HITLS_PKI_SUCCESS);
753 ASSERT_EQ(BSL_LIST_COUNT(list), certNum);773 ASSERT_EQ(BSL_LIST_COUNT(list), certNum);
774+ ASSERT_TRUE(TestIsErrStackEmpty());
754 775
755EXIT:776EXIT:
756 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);777 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -773,6 +794,7 @@ void SDV_X509_CERT_SET_VERIOSN_FUNC_TC001(void)
773 version = HITLS_X509_VERSION_3;794 version = HITLS_X509_VERSION_3;
774 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_VERSION, &version, sizeof(int32_t)), HITLS_PKI_SUCCESS);795 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_VERSION, &version, sizeof(int32_t)), HITLS_PKI_SUCCESS);
775 ASSERT_EQ(cert->tbs.version, version);796 ASSERT_EQ(cert->tbs.version, version);
797+ ASSERT_TRUE(TestIsErrStackEmpty());
776 798 
777 // valLen799 // valLen
778 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_VERSION, &version, 1), HITLS_X509_ERR_INVALID_PARAM);800 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_VERSION, &version, 1), HITLS_X509_ERR_INVALID_PARAM);
@@ -820,6 +842,7 @@ void SDV_X509_CERT_SET_TIME_FUNC_TC001(void)
820 ASSERT_EQ(cert->tbs.validTime.flag, 0);842 ASSERT_EQ(cert->tbs.validTime.flag, 0);
821 843 
822 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_BEFORE_TIME, &time, 0), HITLS_X509_ERR_INVALID_PARAM);844 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_BEFORE_TIME, &time, 0), HITLS_X509_ERR_INVALID_PARAM);
845+ TestErrClear();
823 846 
824 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_BEFORE_TIME, &time, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);847 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_BEFORE_TIME, &time, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);
825 ASSERT_TRUE((cert->tbs.validTime.flag & BSL_TIME_BEFORE_SET) != 0);848 ASSERT_TRUE((cert->tbs.validTime.flag & BSL_TIME_BEFORE_SET) != 0);
@@ -828,6 +851,7 @@ void SDV_X509_CERT_SET_TIME_FUNC_TC001(void)
828 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_AFTER_TIME, &time, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);851 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_AFTER_TIME, &time, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);
829 ASSERT_TRUE((cert->tbs.validTime.flag & BSL_TIME_AFTER_SET) != 0);852 ASSERT_TRUE((cert->tbs.validTime.flag & BSL_TIME_AFTER_SET) != 0);
830 ASSERT_EQ(BSL_SAL_DateTimeCompare(&cert->tbs.validTime.end, &time, NULL), BSL_TIME_CMP_EQUAL);853 ASSERT_EQ(BSL_SAL_DateTimeCompare(&cert->tbs.validTime.end, &time, NULL), BSL_TIME_CMP_EQUAL);
854+ ASSERT_TRUE(TestIsErrStackEmpty());
831 855 
832EXIT:856EXIT:
833 HITLS_X509_CertFree(cert);857 HITLS_X509_CertFree(cert);
@@ -851,6 +875,7 @@ void SDV_X509_ENCODE_CERT_EXT_TC001(char *path, Hex *expectExt)
851 ASSERT_EQ(ext.tag, tag);875 ASSERT_EQ(ext.tag, tag);
852 ASSERT_COMPARE("extensions", ext.buff, ext.len, expectExt->x, expectExt->len);876 ASSERT_COMPARE("extensions", ext.buff, ext.len, expectExt->x, expectExt->len);
853 }877 }
878+ ASSERT_TRUE(TestIsErrStackEmpty());
854 879 
855EXIT:880EXIT:
856 HITLS_X509_CertFree(cert);881 HITLS_X509_CertFree(cert);
@@ -935,6 +960,7 @@ void SDV_X509_CERT_FORMAT_CONVERT_FUNC_TC001(char *inCert, int inForm, char *out
935 ASSERT_EQ(HITLS_X509_CertGenBuff(outForm, cert, &encodeCert), 0);960 ASSERT_EQ(HITLS_X509_CertGenBuff(outForm, cert, &encodeCert), 0);
936 961 
937 ASSERT_COMPARE("Format convert", expectCert.data, expectCert.dataLen, encodeCert.data, encodeCert.dataLen);962 ASSERT_COMPARE("Format convert", expectCert.data, expectCert.dataLen, encodeCert.data, encodeCert.dataLen);
963+ ASSERT_TRUE(TestIsErrStackEmpty());
938 964 
939EXIT:965EXIT:
940 HITLS_X509_CertFree(cert);966 HITLS_X509_CertFree(cert);
@@ -959,6 +985,7 @@ static int32_t SetCert(HITLS_X509_Cert *raw, HITLS_X509_Cert *new)
959 BslList *rawIssuer = NULL;985 BslList *rawIssuer = NULL;
960 ASSERT_EQ(HITLS_X509_CertCtrl(raw, HITLS_X509_GET_ISSUER_DN, &rawIssuer, sizeof(BslList *)), 0);986 ASSERT_EQ(HITLS_X509_CertCtrl(raw, HITLS_X509_GET_ISSUER_DN, &rawIssuer, sizeof(BslList *)), 0);
961 ASSERT_EQ(HITLS_X509_CertCtrl(new, HITLS_X509_SET_ISSUER_DN, rawIssuer, sizeof(BslList)), 0);987 ASSERT_EQ(HITLS_X509_CertCtrl(new, HITLS_X509_SET_ISSUER_DN, rawIssuer, sizeof(BslList)), 0);
988+ ASSERT_TRUE(TestIsErrStackEmpty());
962 989 
963 ret = 0;990 ret = 0;
964EXIT:991EXIT:
@@ -1008,6 +1035,7 @@ void SDV_X509_CERT_SETANDGEN_TC001(char *derCertPath, char *privPath, int keyTyp
1008 if (pkeyId == CRYPT_PKEY_RSA && pad == CRYPT_EMSA_PKCSV15) {1035 if (pkeyId == CRYPT_PKEY_RSA && pad == CRYPT_EMSA_PKCSV15) {
1009 ASSERT_COMPARE("Gen cert", encodeNew.data, encodeNew.dataLen, encodeRaw.data, encodeRaw.dataLen);1036 ASSERT_COMPARE("Gen cert", encodeNew.data, encodeNew.dataLen, encodeRaw.data, encodeRaw.dataLen);
1010 }1037 }
1038+ ASSERT_TRUE(TestIsErrStackEmpty());
1011 1039 
1012EXIT:1040EXIT:
1013 HITLS_X509_CertFree(raw);1041 HITLS_X509_CertFree(raw);
@@ -1199,6 +1227,7 @@ void SDV_X509_CERT_DIGEST_FUNC_TC001(char *inCert, int inForm, int mdId, Hex *ex
1199 1227 
1200 ASSERT_EQ(HITLS_X509_CertGenBuff(inForm, cert, &encodeNew), 0);1228 ASSERT_EQ(HITLS_X509_CertGenBuff(inForm, cert, &encodeNew), 0);
1201 ASSERT_COMPARE("digest then gen", encodeRaw.data, encodeRaw.dataLen, encodeNew.data, encodeNew.dataLen);1229 ASSERT_COMPARE("digest then gen", encodeRaw.data, encodeRaw.dataLen, encodeNew.data, encodeNew.dataLen);
1230+ ASSERT_TRUE(TestIsErrStackEmpty());
1202 1231 
1203EXIT:1232EXIT:
1204 HITLS_X509_CertFree(cert);1233 HITLS_X509_CertFree(cert);
@@ -1219,12 +1248,14 @@ void SDV_X509_CERT_SET_CSR_EXT_FUNC_TC001(int inForm, char *inCsr, int ret, Hex
1219 1248 
1220 ASSERT_EQ(HITLS_X509_CsrParseFile(inForm, inCsr, &csr), 0);1249 ASSERT_EQ(HITLS_X509_CsrParseFile(inForm, inCsr, &csr), 0);
1221 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, csr, 0), ret);1250 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, csr, 0), ret);
1251+ TestErrClear();
1222 ASSERT_EQ(HITLS_X509_EncodeExt(0, cert->tbs.ext.extList, &encodeExt), 0);1252 ASSERT_EQ(HITLS_X509_EncodeExt(0, cert->tbs.ext.extList, &encodeExt), 0);
1223 if (expect->len != 0) {1253 if (expect->len != 0) {
1224 ASSERT_TRUE((cert->tbs.ext.flag & HITLS_X509_EXT_FLAG_PARSE) == 0);1254 ASSERT_TRUE((cert->tbs.ext.flag & HITLS_X509_EXT_FLAG_PARSE) == 0);
1225 ASSERT_TRUE((cert->tbs.ext.flag & HITLS_X509_EXT_FLAG_GEN) != 0);1255 ASSERT_TRUE((cert->tbs.ext.flag & HITLS_X509_EXT_FLAG_GEN) != 0);
1226 ASSERT_COMPARE("Csr ext", encodeExt.buff, encodeExt.len, expect->x, expect->len);1256 ASSERT_COMPARE("Csr ext", encodeExt.buff, encodeExt.len, expect->x, expect->len);
1227 }1257 }
1258+ ASSERT_TRUE(TestIsErrStackEmpty());
1228EXIT:1259EXIT:
1229 HITLS_X509_CertFree(cert);1260 HITLS_X509_CertFree(cert);
1230 HITLS_X509_CsrFree(csr);1261 HITLS_X509_CsrFree(csr);
@@ -1263,6 +1294,7 @@ void SDV_X509_CERT_GET_BCONS_TEST_TC001(int format, char *path, int critical, in
1263 ASSERT_EQ(bc.isCa, isCa);1294 ASSERT_EQ(bc.isCa, isCa);
1264 ASSERT_EQ(bc.maxPathLen, pathLen);1295 ASSERT_EQ(bc.maxPathLen, pathLen);
1265 ASSERT_EQ(bc.critical, critical);1296 ASSERT_EQ(bc.critical, critical);
1297+ ASSERT_TRUE(TestIsErrStackEmpty());
1266EXIT:1298EXIT:
1267 HITLS_X509_CertFree(cert);1299 HITLS_X509_CertFree(cert);
1268}1300}
@@ -1319,6 +1351,7 @@ void SDV_X509_CERT_PARSE_STUB_TC001(int format, char *path)
1319 if (ret == HITLS_PKI_SUCCESS) {1351 if (ret == HITLS_PKI_SUCCESS) {
1320 HITLS_X509_CertFree(cert);1352 HITLS_X509_CertFree(cert);
1321 cert = NULL;1353 cert = NULL;
1354+ ASSERT_TRUE(TestIsErrStackEmpty());
1322 }1355 }
1323 }1356 }
1324 1357 
Mtestcode/sdv/testcase/pki/cert/test_suite_sdv_x509_check.c+26-0
@@ -519,6 +519,7 @@ void SDV_X509_CERT_VERSIONCHECK_TC001(int version, int extflag, int result, char
519 GetPrintBuff(&data, expectbuf);519 GetPrintBuff(&data, expectbuf);
520 Hex expect = {(uint8_t *)expectbuf, 0};520 Hex expect = {(uint8_t *)expectbuf, 0};
521 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);521 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
522+ ASSERT_TRUE(TestIsErrStackEmpty());
522 }523 }
523 524 
524EXIT:525EXIT:
@@ -574,6 +575,7 @@ void SDV_X509_CERT_VERSIONCHECK_TC003(char *path, int result, char *expectbuf)
574 GetPrintBuff(&data, expectbuf);575 GetPrintBuff(&data, expectbuf);
575 Hex expect = {(uint8_t *)expectbuf, 0};576 Hex expect = {(uint8_t *)expectbuf, 0};
576 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);577 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
578+ ASSERT_TRUE(TestIsErrStackEmpty());
577 }579 }
578 580 
579EXIT:581EXIT:
@@ -641,6 +643,7 @@ void SDV_X509_CERT_SERIALNUMCHECK_TC001(int extflag, int result, Hex *serialNum,
641 GetPrintBuff(&data, expectbuf);643 GetPrintBuff(&data, expectbuf);
642 Hex expect = {(uint8_t *)expectbuf, 0};644 Hex expect = {(uint8_t *)expectbuf, 0};
643 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);645 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
646+ ASSERT_TRUE(TestIsErrStackEmpty());
644 }647 }
645 648 
646EXIT:649EXIT:
@@ -681,6 +684,7 @@ void SDV_X509_CERT_KEYCHECK_TC001(int keyflag, int result)
681 }684 }
682 685
683 ASSERT_EQ(SetCertExt(cert), 0);686 ASSERT_EQ(SetCertExt(cert), 0);
687+ ASSERT_TRUE(TestIsErrStackEmpty());
684 688
685 // sign cert689 // sign cert
686 ASSERT_EQ(HITLS_X509_CertSign(CRYPT_MD_SHA256, pkey, &algParam, cert), result);690 ASSERT_EQ(HITLS_X509_CertSign(CRYPT_MD_SHA256, pkey, &algParam, cert), result);
@@ -843,6 +847,7 @@ void SDV_X509_CERT_SUBJECTCHECK_TC001(int extflag, int emailflag)
843 if (emailflag) {847 if (emailflag) {
844 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName1, 1), HITLS_PKI_SUCCESS);848 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName1, 1), HITLS_PKI_SUCCESS);
845 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName2, 1), HITLS_PKI_SUCCESS);849 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName2, 1), HITLS_PKI_SUCCESS);
850+ ASSERT_TRUE(TestIsErrStackEmpty());
846 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName3, 1), HITLS_X509_ERR_SET_DNNAME_UNKNOWN);851 ASSERT_EQ(HITLS_X509_AddDnName(dirNames, dnName3, 1), HITLS_X509_ERR_SET_DNNAME_UNKNOWN);
847 }852 }
848 853
@@ -899,6 +904,7 @@ void SDV_X509_CERT_SUBJECTCHECK_TC003(int extflag, char *expectpath, char *expec
899 GetPrintBuff(&data, expectbuf);904 GetPrintBuff(&data, expectbuf);
900 Hex expect = {(uint8_t *)expectbuf, 0};905 Hex expect = {(uint8_t *)expectbuf, 0};
901 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);906 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
907+ ASSERT_TRUE(TestIsErrStackEmpty());
902 908 
903EXIT:909EXIT:
904 TestRandDeInit();910 TestRandDeInit();
@@ -930,6 +936,7 @@ void SDV_X509_CERT_OIDCHECK_TC001(char *path, int result, char *expectbuf)
930 GetPrintBuff(&data, expectbuf);936 GetPrintBuff(&data, expectbuf);
931 Hex expect = {(uint8_t *)expectbuf, 0};937 Hex expect = {(uint8_t *)expectbuf, 0};
932 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);938 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
939+ ASSERT_TRUE(TestIsErrStackEmpty());
933 }940 }
934 if (strstr(path, (const char *)"oidparamdiff") != NULL) {941 if (strstr(path, (const char *)"oidparamdiff") != NULL) {
935 ASSERT_TRUE(cert->signAlgId.rsaPssParam.mdId != cert->tbs.signAlgId.rsaPssParam.mdId);942 ASSERT_TRUE(cert->signAlgId.rsaPssParam.mdId != cert->tbs.signAlgId.rsaPssParam.mdId);
@@ -982,6 +989,7 @@ void SDV_X509_CERT_TELETEXSTRING_PARSEGEN_TC001(char *path, char *expectbuf)
982 GetPrintBuff(&data, expectbuf);989 GetPrintBuff(&data, expectbuf);
983 Hex expect = {(uint8_t *)expectbuf, 0};990 Hex expect = {(uint8_t *)expectbuf, 0};
984 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);991 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CERT, &data, "Print cert buffer", &expect, true), 0);
992+ ASSERT_TRUE(TestIsErrStackEmpty());
985 993 
986EXIT:994EXIT:
987 TestRandDeInit();995 TestRandDeInit();
@@ -1064,6 +1072,7 @@ void SDV_X509_CERT_WITH_AKISKI_GEN_TEST_TC001(int isCritical, Hex *kid, int algI
1064 ASSERT_EQ(parsedSki.critical, isCritical);1072 ASSERT_EQ(parsedSki.critical, isCritical);
1065 ASSERT_COMPARE("Get parsedSki", parsedSki.kid.data, parsedSki.kid.dataLen, kid->x, kid->len);1073 ASSERT_COMPARE("Get parsedSki", parsedSki.kid.data, parsedSki.kid.dataLen, kid->x, kid->len);
1066 }1074 }
1075+ ASSERT_TRUE(TestIsErrStackEmpty());
1067 1076 
1068EXIT:1077EXIT:
1069 TestRandDeInit();1078 TestRandDeInit();
@@ -1127,6 +1136,7 @@ void SDV_X509_CERT_WITH_EXTAKI_PARSE_TEST_TC001(char *certPath, int isCritical,
1127 &parsedAki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);1136 &parsedAki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);
1128 ASSERT_EQ(parsedAki.critical, isCritical);1137 ASSERT_EQ(parsedAki.critical, isCritical);
1129 ASSERT_COMPARE("Get aki", parsedAki.kid.data, parsedAki.kid.dataLen, kid->x, kid->len);1138 ASSERT_COMPARE("Get aki", parsedAki.kid.data, parsedAki.kid.dataLen, kid->x, kid->len);
1139+ ASSERT_TRUE(TestIsErrStackEmpty());
1130 1140 
1131EXIT:1141EXIT:
1132 HITLS_X509_CertFree(parsedCert);1142 HITLS_X509_CertFree(parsedCert);
@@ -1147,6 +1157,7 @@ void SDV_X509_CERT_WITH_EXTSKI_PARSE_TEST_TC001(char *certPath, int isCritical,
1147 &parsedSki, sizeof(HITLS_X509_ExtSki)), HITLS_PKI_SUCCESS);1157 &parsedSki, sizeof(HITLS_X509_ExtSki)), HITLS_PKI_SUCCESS);
1148 ASSERT_EQ(parsedSki.critical, isCritical);1158 ASSERT_EQ(parsedSki.critical, isCritical);
1149 ASSERT_COMPARE("Get parsedSki", parsedSki.kid.data, parsedSki.kid.dataLen, kid->x, kid->len);1159 ASSERT_COMPARE("Get parsedSki", parsedSki.kid.data, parsedSki.kid.dataLen, kid->x, kid->len);
1160+ ASSERT_TRUE(TestIsErrStackEmpty());
1150 1161 
1151EXIT:1162EXIT:
1152 HITLS_X509_CertFree(parsedCert);1163 HITLS_X509_CertFree(parsedCert);
@@ -1245,6 +1256,7 @@ void SDV_X509_CERT_WITH_KUSAGE_GEN_TEST_TC001(int isCritical, int algId, int has
1245 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_ENCIPHER_ONLY) != 0, expKuEncipherOnly);1256 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_ENCIPHER_ONLY) != 0, expKuEncipherOnly);
1246 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_DECIPHER_ONLY) != 0, expKuDecipherOnly);1257 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_DECIPHER_ONLY) != 0, expKuDecipherOnly);
1247 }1258 }
1259+ ASSERT_TRUE(TestIsErrStackEmpty());
1248 1260 
1249EXIT:1261EXIT:
1250 TestRandDeInit();1262 TestRandDeInit();
@@ -1338,6 +1350,7 @@ void SDV_X509_CERT_WITH_KUSAGE_PARSE_TEST_TC001(char *certPath, int isEdited, in
1338 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_ENCIPHER_ONLY) != 0, expKuEncipherOnly);1350 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_ENCIPHER_ONLY) != 0, expKuEncipherOnly);
1339 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_DECIPHER_ONLY) != 0, expKuDecipherOnly);1351 ASSERT_EQ((parsedKeyUsage & HITLS_X509_EXT_KU_DECIPHER_ONLY) != 0, expKuDecipherOnly);
1340 }1352 }
1353+ ASSERT_TRUE(TestIsErrStackEmpty());
1341 1354 
1342EXIT:1355EXIT:
1343 HITLS_X509_CertFree(parsedCert);1356 HITLS_X509_CertFree(parsedCert);
@@ -1407,6 +1420,7 @@ void SDV_X509_CERT_WITH_SAN_GEN_TEST_TC001(int isCritical, int algId, int hashId
1407 ASSERT_EQ(gn->type, nameType);1420 ASSERT_EQ(gn->type, nameType);
1408 ASSERT_EQ(gn->value.dataLen, generalName.value.dataLen);1421 ASSERT_EQ(gn->value.dataLen, generalName.value.dataLen);
1409 ASSERT_EQ(memcmp(gn->value.data, generalName.value.data, gn->value.dataLen), 0);1422 ASSERT_EQ(memcmp(gn->value.data, generalName.value.data, gn->value.dataLen), 0);
1423+ ASSERT_TRUE(TestIsErrStackEmpty());
1410 1424 
1411EXIT:1425EXIT:
1412 TestRandDeInit();1426 TestRandDeInit();
@@ -1492,6 +1506,7 @@ void SDV_X509_CERT_WITH_SAN_ALL_GEN_TEST_TC001(int isCritical, int algId, int ha
1492 ASSERT_COMPARE("generalName", gn->value.data, gn->value.dataLen, str, strlen(str));1506 ASSERT_COMPARE("generalName", gn->value.data, gn->value.dataLen, str, strlen(str));
1493 gn = BSL_LIST_GET_NEXT(parsedSan.names);1507 gn = BSL_LIST_GET_NEXT(parsedSan.names);
1494 }1508 }
1509+ ASSERT_TRUE(TestIsErrStackEmpty());
1495 1510 
1496EXIT:1511EXIT:
1497 TestRandDeInit();1512 TestRandDeInit();
@@ -1566,6 +1581,7 @@ void SDV_X509_CERT_WITH_SAN_PARSE_TEST_TC001(int isCritical, char *certPath,
1566 ASSERT_EQ(gn->type, nameType);1581 ASSERT_EQ(gn->type, nameType);
1567 ASSERT_EQ(gn->value.dataLen, nameValueLen);1582 ASSERT_EQ(gn->value.dataLen, nameValueLen);
1568 ASSERT_COMPARE("subject Alternative Name", gn->value.data, gn->value.dataLen, nameValue, nameValueLen);1583 ASSERT_COMPARE("subject Alternative Name", gn->value.data, gn->value.dataLen, nameValue, nameValueLen);
1584+ ASSERT_TRUE(TestIsErrStackEmpty());
1569 1585 
1570EXIT:1586EXIT:
1571 TestRandDeInit();1587 TestRandDeInit();
@@ -1589,6 +1605,7 @@ void SDV_X509_CERT_WITH_SAN_ALL_PARSE_TC001(int isCritical, char *certPath, int
1589 &g_beforeTime, &g_afterTime, dnList, dnList, isEdited), 0);1605 &g_beforeTime, &g_afterTime, dnList, dnList, isEdited), 0);
1590 ASSERT_EQ(HITLS_X509_CertCtrl(parsedCert, HITLS_X509_EXT_GET_SAN,1606 ASSERT_EQ(HITLS_X509_CertCtrl(parsedCert, HITLS_X509_EXT_GET_SAN,
1591 &parsedSan, sizeof(HITLS_X509_ExtSan)), HITLS_PKI_SUCCESS);1607 &parsedSan, sizeof(HITLS_X509_ExtSan)), HITLS_PKI_SUCCESS);
1608+ ASSERT_TRUE(TestIsErrStackEmpty());
1592 ASSERT_EQ(parsedSan.critical, isCritical);1609 ASSERT_EQ(parsedSan.critical, isCritical);
1593 ASSERT_EQ(BSL_LIST_COUNT(parsedSan.names), nameNum);1610 ASSERT_EQ(BSL_LIST_COUNT(parsedSan.names), nameNum);
1594 gn = BSL_LIST_GET_FIRST(parsedSan.names);1611 gn = BSL_LIST_GET_FIRST(parsedSan.names);
@@ -1636,6 +1653,7 @@ void SDV_X509_CERT_WITH_ILLEGAL_SAN_PARSE_TEST_TC001(int isCritical, char *certP
1636 ASSERT_EQ(BSL_LIST_COUNT(parsedSan.names), 0);1653 ASSERT_EQ(BSL_LIST_COUNT(parsedSan.names), 0);
1637 gn = BSL_LIST_GET_FIRST(parsedSan.names);1654 gn = BSL_LIST_GET_FIRST(parsedSan.names);
1638 ASSERT_EQ(gn, NULL);1655 ASSERT_EQ(gn, NULL);
1656+ ASSERT_TRUE(TestIsErrStackEmpty());
1639 1657 
1640EXIT:1658EXIT:
1641 TestRandDeInit();1659 TestRandDeInit();
@@ -1701,6 +1719,7 @@ void SDV_X509_CERT_WITH_BCON_GEN_TEST_TC001(int isCritical, int isCa, int maxPat
1701 ASSERT_EQ(parsedBCons.critical, isCritical);1719 ASSERT_EQ(parsedBCons.critical, isCritical);
1702 ASSERT_EQ(parsedBCons.isCa, isCa);1720 ASSERT_EQ(parsedBCons.isCa, isCa);
1703 ASSERT_EQ(parsedBCons.maxPathLen, maxPathLen);1721 ASSERT_EQ(parsedBCons.maxPathLen, maxPathLen);
1722+ ASSERT_TRUE(TestIsErrStackEmpty());
1704 1723 
1705EXIT:1724EXIT:
1706 TestRandDeInit();1725 TestRandDeInit();
@@ -1728,6 +1747,7 @@ void SDV_X509_CERT_WITH_BCON_PARSE_TEST_TC001(int isCritical, int isCa, int maxP
1728 ASSERT_EQ(parsedBCons.critical, isCritical);1747 ASSERT_EQ(parsedBCons.critical, isCritical);
1729 ASSERT_EQ(parsedBCons.isCa, isCa);1748 ASSERT_EQ(parsedBCons.isCa, isCa);
1730 ASSERT_EQ(parsedBCons.maxPathLen, maxPathLen);1749 ASSERT_EQ(parsedBCons.maxPathLen, maxPathLen);
1750+ ASSERT_TRUE(TestIsErrStackEmpty());
1731 1751 
1732EXIT:1752EXIT:
1733 TestRandDeInit();1753 TestRandDeInit();
@@ -1823,6 +1843,7 @@ void SDV_X509_CERT_WITH_EXTKU_GEN_TEST_TC001(int isCritical, int oidNum, int alg
1823 dataOid = BSL_LIST_GET_NEXT(parsedExt->exKeyUsage.oidList), idx ++) {1843 dataOid = BSL_LIST_GET_NEXT(parsedExt->exKeyUsage.oidList), idx ++) {
1824 ASSERT_COMPARE("Extedned key usage", oidBuff[idx].data, oidBuff[idx].dataLen, dataOid->data, dataOid->dataLen);1844 ASSERT_COMPARE("Extedned key usage", oidBuff[idx].data, oidBuff[idx].dataLen, dataOid->data, dataOid->dataLen);
1825 }1845 }
1846+ ASSERT_TRUE(TestIsErrStackEmpty());
1826 1847 
1827EXIT:1848EXIT:
1828 TestRandDeInit();1849 TestRandDeInit();
@@ -1898,6 +1919,7 @@ void SDV_X509_CERT_WITH_EXTKU_WITH_ANYKU_GEN_TEST_TC001(int isCritical, int algI
1898 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);1919 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);
1899 BSL_Buffer *dataOid = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);1920 BSL_Buffer *dataOid = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);
1900 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, dataOid->data, dataOid->dataLen);1921 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, dataOid->data, dataOid->dataLen);
1922+ ASSERT_TRUE(TestIsErrStackEmpty());
1901 1923 
1902EXIT:1924EXIT:
1903 TestRandDeInit();1925 TestRandDeInit();
@@ -2014,6 +2036,7 @@ void SDV_X509_CERT_WITH_EXTKU_WITH_ANYKU_PARSE_TEST_TC001(int isCritical, char *
2014 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);2036 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);
2015 BSL_Buffer *data = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);2037 BSL_Buffer *data = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);
2016 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, data->data, data->dataLen);2038 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, data->data, data->dataLen);
2039+ ASSERT_TRUE(TestIsErrStackEmpty());
2017 2040 
2018EXIT:2041EXIT:
2019 TestRandDeInit();2042 TestRandDeInit();
@@ -2081,6 +2104,7 @@ void SDV_X509_CERT_WITH_DUPLICATE_EXT_GEN_TEST_TC001(int isCritical, Hex *kid, i
2081 &parsedAki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);2104 &parsedAki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);
2082 ASSERT_EQ(parsedAki.critical, isCritical);2105 ASSERT_EQ(parsedAki.critical, isCritical);
2083 ASSERT_COMPARE("Get parsedAki", parsedAki.kid.data, parsedAki.kid.dataLen, kid->x, kid->len);2106 ASSERT_COMPARE("Get parsedAki", parsedAki.kid.data, parsedAki.kid.dataLen, kid->x, kid->len);
2107+ ASSERT_TRUE(TestIsErrStackEmpty());
2084 2108 
2085EXIT:2109EXIT:
2086 TestRandDeInit();2110 TestRandDeInit();
@@ -2236,6 +2260,7 @@ void SDV_X509_CERT_WITH_ALL_EXT_GEN_TEST_TC001(Hex *kid, int algId, int hashId,
2236 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);2260 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);
2237 BSL_Buffer *OidData = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);2261 BSL_Buffer *OidData = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);
2238 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, OidData->data, OidData->dataLen);2262 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, OidData->data, OidData->dataLen);
2263+ ASSERT_TRUE(TestIsErrStackEmpty());
2239 2264 
2240EXIT:2265EXIT:
2241 TestRandDeInit();2266 TestRandDeInit();
@@ -2315,6 +2340,7 @@ void SDV_X509_CERT_WITH_ALL_EXT_PARSE_TEST_TC001(Hex *kid, char *path, int isEdi
2315 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);2340 ASSERT_EQ(BSL_LIST_COUNT(parsedExt->exKeyUsage.oidList), 1);
2316 BSL_Buffer *OidData = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);2341 BSL_Buffer *OidData = BSL_LIST_GET_FIRST(parsedExt->exKeyUsage.oidList);
2317 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, OidData->data, OidData->dataLen);2342 ASSERT_COMPARE("Extedned key usage", oidBuff.data, oidBuff.dataLen, OidData->data, OidData->dataLen);
2343+ ASSERT_TRUE(TestIsErrStackEmpty());
2318 2344 
2319EXIT:2345EXIT:
2320 TestRandDeInit();2346 TestRandDeInit();
Mtestcode/sdv/testcase/pki/cms/test_suite_sdv_cms.c+3-0
@@ -97,6 +97,7 @@ void SDV_CMS_PARSE_ENCRYPTEDDATA_TC002(Hex *buff)
97 int32_t ret = CRYPT_EAL_ParseAsn1PKCS7EncryptedData(NULL, NULL, (BSL_Buffer *)buff, (const uint8_t *)pwd, pwdlen,97 int32_t ret = CRYPT_EAL_ParseAsn1PKCS7EncryptedData(NULL, NULL, (BSL_Buffer *)buff, (const uint8_t *)pwd, pwdlen,
98 &output);98 &output);
99 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);99 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
100+ ASSERT_TRUE(TestIsErrStackEmpty());
100EXIT:101EXIT:
101 BSL_SAL_Free(output.data);102 BSL_SAL_Free(output.data);
102 return;103 return;
@@ -154,6 +155,7 @@ void SDV_CMS_PARSE_DIGESTINFO_TC002(Hex *buff, int alg, Hex *digest)
154 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);155 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
155 ASSERT_EQ(alg, cid);156 ASSERT_EQ(alg, cid);
156 ASSERT_EQ(memcmp(output.data, digest->x, digest->len), 0);157 ASSERT_EQ(memcmp(output.data, digest->x, digest->len), 0);
158+ ASSERT_TRUE(TestIsErrStackEmpty());
157EXIT:159EXIT:
158 BSL_SAL_Free(output.data);160 BSL_SAL_Free(output.data);
159 return;161 return;
@@ -273,6 +275,7 @@ void SDV_CMS_ENCODE_DIGESTINFO_TC002(int algid, Hex *in)
273 ret = HITLS_CMS_ParseDigestInfo(&output, &cid, &digest);275 ret = HITLS_CMS_ParseDigestInfo(&output, &cid, &digest);
274 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);276 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
275 ASSERT_EQ(cid, algid);277 ASSERT_EQ(cid, algid);
278+ ASSERT_TRUE(TestIsErrStackEmpty());
276EXIT:279EXIT:
277 BSL_SAL_FREE(digest.data);280 BSL_SAL_FREE(digest.data);
278 BSL_SAL_FREE(output.data);281 BSL_SAL_FREE(output.data);
Mtestcode/sdv/testcase/pki/cms/test_suite_sdv_cms_sign.c+25-0
@@ -124,6 +124,7 @@ void SDV_CMS_PARSE_SIGNEDDATA_VERIFY_TEST_TC001(char *p7path, char *msgpath, int
124 BSL_Buffer nullMsgBuf = {NULL, 0};124 BSL_Buffer nullMsgBuf = {NULL, 0};
125 ASSERT_EQ(BSL_SAL_ReadFile(msgpath, &msgBuff.data, &msgBuff.dataLen), BSL_SUCCESS);125 ASSERT_EQ(BSL_SAL_ReadFile(msgpath, &msgBuff.data, &msgBuff.dataLen), BSL_SUCCESS);
126 BSL_Buffer wrongMsgBuf = {msgBuff.data + 1, msgBuff.dataLen - 1};126 BSL_Buffer wrongMsgBuf = {msgBuff.data + 1, msgBuff.dataLen - 1};
127+ ASSERT_TRUE(TestIsErrStackEmpty());
127 if (isDetached) {128 if (isDetached) {
128 ASSERT_EQ(HITLS_CMS_DataVerify(cms, &msgBuff, params, NULL), HITLS_PKI_SUCCESS);129 ASSERT_EQ(HITLS_CMS_DataVerify(cms, &msgBuff, params, NULL), HITLS_PKI_SUCCESS);
129 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, NULL, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_CONTENT);130 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, NULL, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_CONTENT);
@@ -206,6 +207,7 @@ void SDV_CMS_PARSE_SIGNEDDATA_ENC_DEC_FILE_TC001(char *p7path, char *msgpath, in
206 ASSERT_EQ(HITLS_CMS_DataVerify(cms1, &msgBuff, params, NULL), HITLS_PKI_SUCCESS);207 ASSERT_EQ(HITLS_CMS_DataVerify(cms1, &msgBuff, params, NULL), HITLS_PKI_SUCCESS);
207 } else {208 } else {
208 ASSERT_EQ(HITLS_CMS_DataVerify(cms1, NULL, params, NULL), HITLS_PKI_SUCCESS);209 ASSERT_EQ(HITLS_CMS_DataVerify(cms1, NULL, params, NULL), HITLS_PKI_SUCCESS);
210+ ASSERT_TRUE(TestIsErrStackEmpty());
209 }211 }
210EXIT:212EXIT:
211 HITLS_CMS_Free(cms);213 HITLS_CMS_Free(cms);
@@ -306,6 +308,7 @@ void SDV_CMS_ENCODE_SIGNEDDATA_TC001(Hex *buff)
306 ASSERT_EQ(HITLS_CMS_GenSignedDataBuff(BSL_FORMAT_ASN1, cms, &encode), HITLS_PKI_SUCCESS);308 ASSERT_EQ(HITLS_CMS_GenSignedDataBuff(BSL_FORMAT_ASN1, cms, &encode), HITLS_PKI_SUCCESS);
307 ASSERT_COMPARE("encode compare", encode.data, encode.dataLen, buff->x, buff->len);309 ASSERT_COMPARE("encode compare", encode.data, encode.dataLen, buff->x, buff->len);
308 ASSERT_EQ(HITLS_CMS_ParseSignedData(NULL, NULL, &encode, &cms1), HITLS_PKI_SUCCESS);310 ASSERT_EQ(HITLS_CMS_ParseSignedData(NULL, NULL, &encode, &cms1), HITLS_PKI_SUCCESS);
311+ ASSERT_TRUE(TestIsErrStackEmpty());
309EXIT:312EXIT:
310 BSL_SAL_FREE(encode.data);313 BSL_SAL_FREE(encode.data);
311 HITLS_CMS_Free(cms1);314 HITLS_CMS_Free(cms1);
@@ -440,6 +443,7 @@ void SDV_CMS_SIGNERINFOGEN_SET_DN_TC001(void)
440 443 
441 // Verify SignerInfo structure444 // Verify SignerInfo structure
442 ASSERT_EQ(signerInfo->version, HITLS_CMS_SIGNEDDATA_SIGNERINFO_V1);445 ASSERT_EQ(signerInfo->version, HITLS_CMS_SIGNEDDATA_SIGNERINFO_V1);
446+ ASSERT_TRUE(TestIsErrStackEmpty());
443 447 
444EXIT:448EXIT:
445 HITLS_CMS_Free(cms);449 HITLS_CMS_Free(cms);
@@ -510,6 +514,7 @@ void SDV_CMS_SIGNERINFOGEN_SET_SKI_TC002(void)
510 ASSERT_EQ(signerInfo->version, HITLS_CMS_SIGNEDDATA_SIGNERINFO_V3);514 ASSERT_EQ(signerInfo->version, HITLS_CMS_SIGNEDDATA_SIGNERINFO_V3);
511 ASSERT_COMPARE("ski compare", signerInfo->subjectKeyId.kid.data, signerInfo->subjectKeyId.kid.dataLen,515 ASSERT_COMPARE("ski compare", signerInfo->subjectKeyId.kid.data, signerInfo->subjectKeyId.kid.dataLen,
512 ski.kid.data, ski.kid.dataLen);516 ski.kid.data, ski.kid.dataLen);
517+ ASSERT_TRUE(TestIsErrStackEmpty());
513 518 
514EXIT:519EXIT:
515 HITLS_CMS_Free(cms);520 HITLS_CMS_Free(cms);
@@ -593,6 +598,7 @@ void SDV_CMS_ADDSIGNERINFO_RSA_PSS_TC001(char *certPath, char *keyPath, char *ms
593 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.mdId, BSL_CID_SHA256);598 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.mdId, BSL_CID_SHA256);
594 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.mgfId, BSL_CID_SHA256);599 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.mgfId, BSL_CID_SHA256);
595 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.saltLen, 20);600 ASSERT_EQ(addedSignerInfo->sigAlg.rsaPssParam.saltLen, 20);
601+ ASSERT_TRUE(TestIsErrStackEmpty());
596 602 
597EXIT:603EXIT:
598 BSL_SAL_FREE(data);604 BSL_SAL_FREE(data);
@@ -670,6 +676,7 @@ void SDV_CMS_ADDSIGNERINFO_RSA_PKCSV15_TC001(char *certPath, char *keyPath, char
670 676 
671 // Verify signature algorithm is standard RSA.677 // Verify signature algorithm is standard RSA.
672 ASSERT_EQ(addedSignerInfo->sigAlg.algId, BSL_CID_RSA);678 ASSERT_EQ(addedSignerInfo->sigAlg.algId, BSL_CID_RSA);
679+ ASSERT_TRUE(TestIsErrStackEmpty());
673 680 
674EXIT:681EXIT:
675 BSL_SAL_FREE(data);682 BSL_SAL_FREE(data);
@@ -737,6 +744,7 @@ void SDV_CMS_ADDSIGNERINFO_ECC_KEY_TC001(char *certPath, char *keyPath, char *ms
737 BSL_PARAM_END744 BSL_PARAM_END
738 };745 };
739 ASSERT_EQ(HITLS_CMS_DataSign(cms, pkey, cert, &msgBuf, params), HITLS_PKI_SUCCESS);746 ASSERT_EQ(HITLS_CMS_DataSign(cms, pkey, cert, &msgBuf, params), HITLS_PKI_SUCCESS);
747+ ASSERT_TRUE(TestIsErrStackEmpty());
740 748 
741 // Get signerInfo back from cms to verify749 // Get signerInfo back from cms to verify
742 CMS_SignedData *signedData = cms->ctx.signedData;750 CMS_SignedData *signedData = cms->ctx.signedData;
@@ -845,6 +853,7 @@ void SDV_CMS_CTRL_ADD_CERT_TC001(char *certPath, char *keyPath, char *msg)
845 HITLS_PKI_SUCCESS);853 HITLS_PKI_SUCCESS);
846 ASSERT_EQ(addedSerial.dataLen, serialNum.dataLen);854 ASSERT_EQ(addedSerial.dataLen, serialNum.dataLen);
847 ASSERT_EQ(memcmp(addedSerial.data, serialNum.data, serialNum.dataLen), 0);855 ASSERT_EQ(memcmp(addedSerial.data, serialNum.data, serialNum.dataLen), 0);
856+ ASSERT_TRUE(TestIsErrStackEmpty());
848 857 
849EXIT:858EXIT:
850 BSL_SAL_FREE(data);859 BSL_SAL_FREE(data);
@@ -1026,6 +1035,7 @@ void SDV_CMS_GEN_ATTACH_SIGNEDDATA_TC001(int algId, char *capath, char *certPath
1026 ASSERT_EQ(BSL_LIST_COUNT(cms->ctx.signedData->signerInfos), 2); // its should be 2.1035 ASSERT_EQ(BSL_LIST_COUNT(cms->ctx.signedData->signerInfos), 2); // its should be 2.
1027 ASSERT_EQ(HITLS_CMS_DataVerify(cms, &msgBuf, params, NULL), HITLS_PKI_SUCCESS);1036 ASSERT_EQ(HITLS_CMS_DataVerify(cms, &msgBuf, params, NULL), HITLS_PKI_SUCCESS);
1028 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, params, NULL), HITLS_PKI_SUCCESS);1037 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, params, NULL), HITLS_PKI_SUCCESS);
1038+ ASSERT_TRUE(TestIsErrStackEmpty());
1029 1039 
1030EXIT:1040EXIT:
1031 BSL_SAL_FREE(data);1041 BSL_SAL_FREE(data);
@@ -1146,6 +1156,7 @@ void SDV_CMS_GEN_DETACHED_SIGNEDDATA_MULTI_SIGNER_TC001(char *capath, char *cert
1146 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_VERIFY, parsedCms, NULL), HITLS_PKI_SUCCESS);1156 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_VERIFY, parsedCms, NULL), HITLS_PKI_SUCCESS);
1147 ASSERT_EQ(HITLS_CMS_DataUpdate(parsedCms, &msgBuf), HITLS_PKI_SUCCESS);1157 ASSERT_EQ(HITLS_CMS_DataUpdate(parsedCms, &msgBuf), HITLS_PKI_SUCCESS);
1148 ASSERT_EQ(HITLS_CMS_DataFinal(parsedCms, params2), HITLS_PKI_SUCCESS);1158 ASSERT_EQ(HITLS_CMS_DataFinal(parsedCms, params2), HITLS_PKI_SUCCESS);
1159+ ASSERT_TRUE(TestIsErrStackEmpty());
1149 1160 
1150EXIT:1161EXIT:
1151 BSL_SAL_FREE(data);1162 BSL_SAL_FREE(data);
@@ -1266,6 +1277,7 @@ void SDV_CMS_STREAM_SIGN_DETACHED_TC001(char *capath, char *cert1Path, char *key
1266 HITLS_CMS *cms2 = NULL;1277 HITLS_CMS *cms2 = NULL;
1267 ASSERT_EQ(HITLS_CMS_ProviderParseBuff(NULL, NULL, NULL, &encode, &cms2), HITLS_PKI_SUCCESS);1278 ASSERT_EQ(HITLS_CMS_ProviderParseBuff(NULL, NULL, NULL, &encode, &cms2), HITLS_PKI_SUCCESS);
1268 ASSERT_TRUE(cms2 != NULL);1279 ASSERT_TRUE(cms2 != NULL);
1280+ ASSERT_TRUE(TestIsErrStackEmpty());
1269 BSL_Param verifyParams1[7] = {1281 BSL_Param verifyParams1[7] = {
1270 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, caCertchain, sizeof(HITLS_X509_List *), 0},1282 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, caCertchain, sizeof(HITLS_X509_List *), 0},
1271 BSL_PARAM_END1283 BSL_PARAM_END
@@ -1406,18 +1418,21 @@ void SDV_CMS_STREAM_NODETACHED_TEST_TC001(void)
1406 // Try to initialize streaming verification on non-detached CMS - should fail1418 // Try to initialize streaming verification on non-detached CMS - should fail
1407 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_VERIFY, cms2, NULL), HITLS_PKI_SUCCESS);1419 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_VERIFY, cms2, NULL), HITLS_PKI_SUCCESS);
1408 ASSERT_EQ(HITLS_CMS_DataUpdate(cms2, &msgBuf), HITLS_PKI_SUCCESS);1420 ASSERT_EQ(HITLS_CMS_DataUpdate(cms2, &msgBuf), HITLS_PKI_SUCCESS);
1421+ ASSERT_TRUE(TestIsErrStackEmpty());
1409 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_FIND_CERT);1422 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_FIND_CERT);
1410 BSL_Param verifyParams1[8] = {1423 BSL_Param verifyParams1[8] = {
1411 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, certchain, sizeof(HITLS_X509_List *), 0},1424 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, certchain, sizeof(HITLS_X509_List *), 0},
1412 BSL_PARAM_END1425 BSL_PARAM_END
1413 };1426 };
1414 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, verifyParams1), HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);1427 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, verifyParams1), HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
1428+ TestErrClear();
1415 BSL_Param verifyParams2[8] = {1429 BSL_Param verifyParams2[8] = {
1416 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, certchain, sizeof(HITLS_X509_List *), 0},1430 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, certchain, sizeof(HITLS_X509_List *), 0},
1417 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, caCertchain, sizeof(HITLS_X509_List *), 0},1431 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, caCertchain, sizeof(HITLS_X509_List *), 0},
1418 BSL_PARAM_END1432 BSL_PARAM_END
1419 };1433 };
1420 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, verifyParams2), HITLS_PKI_SUCCESS);1434 ASSERT_EQ(HITLS_CMS_DataFinal(cms2, verifyParams2), HITLS_PKI_SUCCESS);
1435+ ASSERT_TRUE(TestIsErrStackEmpty());
1421EXIT:1436EXIT:
1422 BSL_SAL_FREE(encode.data);1437 BSL_SAL_FREE(encode.data);
1423 HITLS_CMS_Free(cms);1438 HITLS_CMS_Free(cms);
@@ -1552,9 +1567,11 @@ void SDV_CMS_MIXED_SING_VERIFY_TC001(void)
1552 ASSERT_TRUE(encode.data != NULL && encode.dataLen > 0);1567 ASSERT_TRUE(encode.data != NULL && encode.dataLen > 0);
1553 ASSERT_EQ(HITLS_CMS_ProviderParseBuff(NULL, NULL, NULL, &encode, &cms2), HITLS_PKI_SUCCESS);1568 ASSERT_EQ(HITLS_CMS_ProviderParseBuff(NULL, NULL, NULL, &encode, &cms2), HITLS_PKI_SUCCESS);
1554 ASSERT_TRUE(cms2 != NULL);1569 ASSERT_TRUE(cms2 != NULL);
1570+ ASSERT_TRUE(TestIsErrStackEmpty());
1555 1571 
1556 // Verify all SignerInfos using one-shot API first1572 // Verify all SignerInfos using one-shot API first
1557 ASSERT_EQ(HITLS_CMS_DataVerify(cms2, &initMsgBuf, NULL, NULL), HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);1573 ASSERT_EQ(HITLS_CMS_DataVerify(cms2, &initMsgBuf, NULL, NULL), HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
1574+ TestErrClear();
1558 ASSERT_EQ(HITLS_CMS_DataVerify(cms2, &initMsgBuf, params, NULL), HITLS_PKI_SUCCESS);1575 ASSERT_EQ(HITLS_CMS_DataVerify(cms2, &initMsgBuf, params, NULL), HITLS_PKI_SUCCESS);
1559 1576 
1560 // Verify all SignerInfos using streaming API (verifies both signers simultaneously)1577 // Verify all SignerInfos using streaming API (verifies both signers simultaneously)
@@ -1568,6 +1585,7 @@ void SDV_CMS_MIXED_SING_VERIFY_TC001(void)
1568 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_SIGN, cms, NULL), HITLS_PKI_SUCCESS);1585 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_SIGN, cms, NULL), HITLS_PKI_SUCCESS);
1569 ASSERT_EQ(HITLS_CMS_DataUpdate(cms, &msgBuf), HITLS_PKI_SUCCESS);1586 ASSERT_EQ(HITLS_CMS_DataUpdate(cms, &msgBuf), HITLS_PKI_SUCCESS);
1570 ASSERT_EQ(HITLS_CMS_DataFinal(cms, signParams), HITLS_PKI_SUCCESS);1587 ASSERT_EQ(HITLS_CMS_DataFinal(cms, signParams), HITLS_PKI_SUCCESS);
1588+ ASSERT_TRUE(TestIsErrStackEmpty());
1571EXIT:1589EXIT:
1572 BSL_SAL_FREE(encode.data);1590 BSL_SAL_FREE(encode.data);
1573 HITLS_CMS_Free(cms);1591 HITLS_CMS_Free(cms);
@@ -1667,6 +1685,7 @@ void SDV_CMS_NODETACHED_DIFF_MSG_FAIL_TC001(void)
1667 };1685 };
1668 ASSERT_EQ(HITLS_CMS_DataSign(cms, pkey1, cert1, &msgBuf1, params1), HITLS_PKI_SUCCESS);1686 ASSERT_EQ(HITLS_CMS_DataSign(cms, pkey1, cert1, &msgBuf1, params1), HITLS_PKI_SUCCESS);
1669 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, params1, NULL), HITLS_PKI_SUCCESS);1687 ASSERT_EQ(HITLS_CMS_DataVerify(cms, NULL, params1, NULL), HITLS_PKI_SUCCESS);
1688+ ASSERT_TRUE(TestIsErrStackEmpty());
1670 // Create second SignerInfo1689 // Create second SignerInfo
1671 char *msg2 = "This is a different message";1690 char *msg2 = "This is a different message";
1672 BSL_Buffer msgBuf2 = {(uint8_t *)msg2, strlen(msg2)};1691 BSL_Buffer msgBuf2 = {(uint8_t *)msg2, strlen(msg2)};
@@ -1807,6 +1826,7 @@ void SDV_CMS_SIGNEDDATA_INVALID_TC002(void)
1807 1826 
1808 int32_t pkcsv15 = CRYPT_MD_SHA256;1827 int32_t pkcsv15 = CRYPT_MD_SHA256;
1809 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);1828 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
1829+ ASSERT_TRUE(TestIsErrStackEmpty());
1810 1830 
1811 BSL_Buffer msgBuf = {msg, sizeof(msg)};1831 BSL_Buffer msgBuf = {msg, sizeof(msg)};
1812 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_SIGN, cms, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_FIND_HASH);1832 ASSERT_EQ(HITLS_CMS_DataInit(HITLS_CMS_OPT_SIGN, cms, NULL), HITLS_CMS_ERR_SIGNEDDATA_NO_FIND_HASH);
@@ -1896,6 +1916,7 @@ void SDV_CMS_STREAM_INCORRECT_SEQUENCE_TC001(void)
1896 BSL_PARAM_END1916 BSL_PARAM_END
1897 };1917 };
1898 ASSERT_EQ(HITLS_CMS_DataFinal(cms, params), HITLS_PKI_SUCCESS);1918 ASSERT_EQ(HITLS_CMS_DataFinal(cms, params), HITLS_PKI_SUCCESS);
1919+ ASSERT_TRUE(TestIsErrStackEmpty());
1899 1920 
1900 // Try to update after final, Should fail.1921 // Try to update after final, Should fail.
1901 ASSERT_EQ(HITLS_CMS_DataUpdate(cms, &msgBuf), HITLS_CMS_ERR_INVALID_STATE);1922 ASSERT_EQ(HITLS_CMS_DataUpdate(cms, &msgBuf), HITLS_CMS_ERR_INVALID_STATE);
@@ -2039,6 +2060,7 @@ static int32_t LoadCertChainAndKeys(const char *basePath, TestCertChainCtx *ctx)
2039 device2KeyPath, NULL, 0, &ctx->pkey2), HITLS_PKI_SUCCESS);2060 device2KeyPath, NULL, 0, &ctx->pkey2), HITLS_PKI_SUCCESS);
2040 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx->pkey2, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)),2061 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx->pkey2, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)),
2041 HITLS_PKI_SUCCESS);2062 HITLS_PKI_SUCCESS);
2063+ ASSERT_TRUE(TestIsErrStackEmpty());
2042EXIT:2064EXIT:
2043 return ret;2065 return ret;
2044}2066}
@@ -2202,6 +2224,7 @@ void SDV_CMS_SIGN_VERIFY_WITH_CERT_CHAIN_CRL_TC002(char *basePath, char *msg)
2202 int ref;2224 int ref;
2203 ASSERT_EQ(HITLS_X509_CertCtrl(certCtx.caCert, HITLS_X509_REF_UP, &ref, sizeof(int32_t)), BSL_SUCCESS);2225 ASSERT_EQ(HITLS_X509_CertCtrl(certCtx.caCert, HITLS_X509_REF_UP, &ref, sizeof(int32_t)), BSL_SUCCESS);
2204 ASSERT_EQ(BSL_LIST_AddElement(partChain, certCtx.caCert, BSL_LIST_POS_END), BSL_SUCCESS);2226 ASSERT_EQ(BSL_LIST_AddElement(partChain, certCtx.caCert, BSL_LIST_POS_END), BSL_SUCCESS);
2227+ ASSERT_TRUE(TestIsErrStackEmpty());
2205 BSL_Param partiChain[4] = {2228 BSL_Param partiChain[4] = {
2206 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, partChain, 0, 0},2229 {HITLS_CMS_PARAM_CA_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, partChain, 0, 0},
2207 {HITLS_CMS_PARAM_CRL_LISTS, BSL_PARAM_TYPE_CTX_PTR, crlList, sizeof(HITLS_X509_List *), 0},2230 {HITLS_CMS_PARAM_CRL_LISTS, BSL_PARAM_TYPE_CTX_PTR, crlList, sizeof(HITLS_X509_List *), 0},
@@ -2301,6 +2324,7 @@ void SDV_CMS_SIGN_VERIFY_WITH_CERT_CHAIN_CRL_TC003(char *basePath, char *msg)
2301 cms = HITLS_CMS_ProviderNew(NULL, NULL, BSL_CID_PKCS7_SIGNEDDATA);2324 cms = HITLS_CMS_ProviderNew(NULL, NULL, BSL_CID_PKCS7_SIGNEDDATA);
2302 ASSERT_NE(cms, NULL);2325 ASSERT_NE(cms, NULL);
2303 ASSERT_EQ(HITLS_CMS_DataSign(cms, certCtx.pkey1, certCtx.device1Cert, &msgBuf, params), HITLS_PKI_SUCCESS);2326 ASSERT_EQ(HITLS_CMS_DataSign(cms, certCtx.pkey1, certCtx.device1Cert, &msgBuf, params), HITLS_PKI_SUCCESS);
2327+ ASSERT_TRUE(TestIsErrStackEmpty());
2304 BSL_Param verifyParams1[2] = {2328 BSL_Param verifyParams1[2] = {
2305 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, midchain, 0, 0},2329 {HITLS_CMS_PARAM_UNTRUSTED_CERT_LISTS, BSL_PARAM_TYPE_CTX_PTR, midchain, 0, 0},
2306 BSL_PARAM_END2330 BSL_PARAM_END
@@ -2400,6 +2424,7 @@ void SDV_CMS_SIGN_VERIFY_STUB_TC001(char *basePath, char *msg)
2400 STUB_ResetMallocCount();2424 STUB_ResetMallocCount();
2401 ASSERT_EQ(HITLS_CMS_DataSign(cms, certCtx.pkey1, certCtx.device1Cert, &msgBuf, params), HITLS_PKI_SUCCESS);2425 ASSERT_EQ(HITLS_CMS_DataSign(cms, certCtx.pkey1, certCtx.device1Cert, &msgBuf, params), HITLS_PKI_SUCCESS);
2402 totalMallocCount = STUB_GetMallocCallCount();2426 totalMallocCount = STUB_GetMallocCallCount();
2427+ ASSERT_TRUE(TestIsErrStackEmpty());
2403 for (uint32_t i = 0; i < totalMallocCount; i++) {2428 for (uint32_t i = 0; i < totalMallocCount; i++) {
2404 STUB_EnableMallocFail(true);2429 STUB_EnableMallocFail(true);
2405 STUB_ResetMallocCount();2430 STUB_ResetMallocCount();
Mtestcode/sdv/testcase/pki/common/test_suite_sdv_common.c+30-0
@@ -408,6 +408,7 @@ void SDV_CRYPT_EAL_ParseFilePriKeyFormat_TC001(int format, int type, char *path)
408 BSL_GLOBAL_Init();408 BSL_GLOBAL_Init();
409 CRYPT_EAL_PkeyCtx *key = NULL;409 CRYPT_EAL_PkeyCtx *key = NULL;
410 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);410 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);
411+ ASSERT_TRUE(TestIsErrStackEmpty());
411EXIT:412EXIT:
412 CRYPT_EAL_PkeyFreeCtx(key);413 CRYPT_EAL_PkeyFreeCtx(key);
413 BSL_GLOBAL_DeInit();414 BSL_GLOBAL_DeInit();
@@ -421,6 +422,7 @@ void SDV_CRYPT_EAL_ParseFilePubKeyFormat_TC001(int format, int type, char *path)
421 BSL_GLOBAL_Init();422 BSL_GLOBAL_Init();
422 CRYPT_EAL_PkeyCtx *key = NULL;423 CRYPT_EAL_PkeyCtx *key = NULL;
423 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);424 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);
425+ ASSERT_TRUE(TestIsErrStackEmpty());
424EXIT:426EXIT:
425 CRYPT_EAL_PkeyFreeCtx(key);427 CRYPT_EAL_PkeyFreeCtx(key);
426 BSL_GLOBAL_DeInit();428 BSL_GLOBAL_DeInit();
@@ -439,6 +441,7 @@ void SDV_X509_EncodeNameList_TC001(int format, char *certPath, Hex *expect)
439 ASSERT_EQ(HITLS_X509_EncodeNameList(cert->tbs.issuerName, &name), 0);441 ASSERT_EQ(HITLS_X509_EncodeNameList(cert->tbs.issuerName, &name), 0);
440 442 
441 ASSERT_COMPARE("Encode names", name.buff, name.len, expect->x, expect->len);443 ASSERT_COMPARE("Encode names", name.buff, name.len, expect->x, expect->len);
444+ ASSERT_TRUE(TestIsErrStackEmpty());
442 445 
443EXIT:446EXIT:
444 HITLS_X509_CertFree(cert);447 HITLS_X509_CertFree(cert);
@@ -869,6 +872,7 @@ void SDV_X509_EXT_EncodeBCons_TC001(int critical, int isCa, int maxPathLen, Hex
869 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);872 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);
870 ASSERT_EQ(encode.len, expect->len);873 ASSERT_EQ(encode.len, expect->len);
871 ASSERT_COMPARE("Ext: bCons", encode.buff, encode.len, expect->x, expect->len);874 ASSERT_COMPARE("Ext: bCons", encode.buff, encode.len, expect->x, expect->len);
875+ ASSERT_TRUE(TestIsErrStackEmpty());
872EXIT:876EXIT:
873 HITLS_X509_CertFree(cert);877 HITLS_X509_CertFree(cert);
874 BSL_SAL_Free(encode.buff);878 BSL_SAL_Free(encode.buff);
@@ -897,6 +901,7 @@ void SDV_X509_EXT_EncodeExtendKeyUsage_TC001(int critical, Hex *oid1, Hex *oid2,
897 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);901 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);
898 ASSERT_EQ(encode.len, expect->len);902 ASSERT_EQ(encode.len, expect->len);
899 ASSERT_COMPARE("Ext: extendKeyUsage", encode.buff, encode.len, expect->x, expect->len);903 ASSERT_COMPARE("Ext: extendKeyUsage", encode.buff, encode.len, expect->x, expect->len);
904+ ASSERT_TRUE(TestIsErrStackEmpty());
900 905 
901EXIT:906EXIT:
902 HITLS_X509_CertFree(cert);907 HITLS_X509_CertFree(cert);
@@ -994,6 +999,7 @@ void SDV_X509_EXT_EncodeSan_TC001(int critical, int type1, int type2, int type3,
994 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);999 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);
995 ASSERT_EQ(encode.len, expect->len);1000 ASSERT_EQ(encode.len, expect->len);
996 ASSERT_COMPARE("Ext: san", encode.buff, encode.len, expect->x, expect->len);1001 ASSERT_COMPARE("Ext: san", encode.buff, encode.len, expect->x, expect->len);
1002+ ASSERT_TRUE(TestIsErrStackEmpty());
997 1003 
998EXIT:1004EXIT:
999 HITLS_X509_CertFree(cert);1005 HITLS_X509_CertFree(cert);
@@ -1020,6 +1026,7 @@ void SDV_X509_EXT_EncodeKeyUsage_TC001(int critical, int usage, Hex *expect)
1020 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);1026 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);
1021 ASSERT_EQ(encode.len, expect->len);1027 ASSERT_EQ(encode.len, expect->len);
1022 ASSERT_COMPARE("Ext: keyUsage", encode.buff, encode.len, expect->x, expect->len);1028 ASSERT_COMPARE("Ext: keyUsage", encode.buff, encode.len, expect->x, expect->len);
1029+ ASSERT_TRUE(TestIsErrStackEmpty());
1023EXIT:1030EXIT:
1024 HITLS_X509_CertFree(cert);1031 HITLS_X509_CertFree(cert);
1025 BSL_SAL_Free(encode.buff);1032 BSL_SAL_Free(encode.buff);
@@ -1045,6 +1052,7 @@ void SDV_X509_EXT_EncodeAKiSki_TC001(int critical1, int critical2, Hex *kid1, He
1045 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);1052 ASSERT_EQ(HITLS_X509_EncodeExt(tag, cert->tbs.ext.extList, &encode), HITLS_PKI_SUCCESS);
1046 ASSERT_EQ(encode.len, expect->len);1053 ASSERT_EQ(encode.len, expect->len);
1047 ASSERT_COMPARE("Ext:aki ski", encode.buff, encode.len, expect->x, expect->len);1054 ASSERT_COMPARE("Ext:aki ski", encode.buff, encode.len, expect->x, expect->len);
1055+ ASSERT_TRUE(TestIsErrStackEmpty());
1048EXIT:1056EXIT:
1049 HITLS_X509_CertFree(cert);1057 HITLS_X509_CertFree(cert);
1050 BSL_SAL_Free(encode.buff);1058 BSL_SAL_Free(encode.buff);
@@ -1085,6 +1093,7 @@ void SDV_X509_EXT_ParseGeneralNames_TC001(Hex *encode, Hex *ip, Hex *uri, Hex *r
1085 ASSERT_COMPARE("gn", name->value.data, name->value.dataLen, map[idx].value->x, map[idx].value->len);1093 ASSERT_COMPARE("gn", name->value.data, name->value.dataLen, map[idx].value->x, map[idx].value->len);
1086 }1094 }
1087 }1095 }
1096+ ASSERT_TRUE(TestIsErrStackEmpty());
1088 1097 
1089EXIT:1098EXIT:
1090 HITLS_X509_ClearGeneralNames(list);1099 HITLS_X509_ClearGeneralNames(list);
@@ -1146,6 +1155,7 @@ void SDV_X509_EXT_ParseExtendedKu_TC001(Hex *encode, Hex *ku1, Hex *ku2, Hex *ku
1146 ASSERT_COMPARE("Extended key usage", values[idx]->x, values[idx]->len, data->data, data->dataLen);1155 ASSERT_COMPARE("Extended key usage", values[idx]->x, values[idx]->len, data->data, data->dataLen);
1147 idx++;1156 idx++;
1148 }1157 }
1158+ ASSERT_TRUE(TestIsErrStackEmpty());
1149 1159 
1150EXIT:1160EXIT:
1151 HITLS_X509_ClearExtendedKeyUsage(&exku);1161 HITLS_X509_ClearExtendedKeyUsage(&exku);
@@ -1167,6 +1177,7 @@ void SDV_X509_EXT_ParseAki_TC001(Hex *encode, Hex *kid, Hex *serial, int nameCnt
1167 ASSERT_COMPARE("serial", aki.serialNum.data, aki.serialNum.dataLen, serial->x, serial->len);1177 ASSERT_COMPARE("serial", aki.serialNum.data, aki.serialNum.dataLen, serial->x, serial->len);
1168 1178 
1169 ASSERT_EQ(BSL_LIST_COUNT(aki.issuerName), nameCnt);1179 ASSERT_EQ(BSL_LIST_COUNT(aki.issuerName), nameCnt);
1180+ ASSERT_TRUE(TestIsErrStackEmpty());
1170 1181 
1171EXIT:1182EXIT:
1172 HITLS_X509_ClearAuthorityKeyId(&aki);1183 HITLS_X509_ClearAuthorityKeyId(&aki);
@@ -1201,6 +1212,7 @@ void SDV_X509_EXT_ParseSan_TC001(Hex *encode, int ret, int gnNameCnt, int gnType
1201 dirName = BSL_LIST_GET_NEXT(dirNameList); // layer 21212 dirName = BSL_LIST_GET_NEXT(dirNameList); // layer 2
1202 ASSERT_COMPARE("dnname type", dirName->nameType.buff, dirName->nameType.len, dnType->x, dnType->len);1213 ASSERT_COMPARE("dnname type", dirName->nameType.buff, dirName->nameType.len, dnType->x, dnType->len);
1203 ASSERT_COMPARE("dnname value", dirName->nameValue.buff, dirName->nameValue.len, dnValue->x, dnValue->len);1214 ASSERT_COMPARE("dnname value", dirName->nameValue.buff, dirName->nameValue.len, dnValue->x, dnValue->len);
1215+ ASSERT_TRUE(TestIsErrStackEmpty());
1204 }1216 }
1205 1217 
1206EXIT:1218EXIT:
@@ -1322,7 +1334,9 @@ void SDV_X509_SIGN_Func_TC002(void)
1322 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(CRYPT_RsaPadType)), 0);1334 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(CRYPT_RsaPadType)), 0);
1323 1335 
1324 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, NULL, &obj, TestSignCb), 0);1336 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, NULL, &obj, TestSignCb), 0);
1337+ ASSERT_TRUE(TestIsErrStackEmpty());
1325 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, &algParam, &obj, TestSignCb), HITLS_X509_ERR_SIGN_PARAM);1338 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, &algParam, &obj, TestSignCb), HITLS_X509_ERR_SIGN_PARAM);
1339+ TestErrClear();
1326 1340 
1327 pad = CRYPT_EMSA_PSS;1341 pad = CRYPT_EMSA_PSS;
1328 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(CRYPT_RsaPadType)), 0);1342 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(CRYPT_RsaPadType)), 0);
@@ -1335,6 +1349,7 @@ void SDV_X509_SIGN_Func_TC002(void)
1335 {CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &pssPara.saltLen, sizeof(pssPara.saltLen), 0},1349 {CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &pssPara.saltLen, sizeof(pssPara.saltLen), 0},
1336 BSL_PARAM_END};1350 BSL_PARAM_END};
1337 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), 0);1351 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(prvKey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), 0);
1352+ ASSERT_TRUE(TestIsErrStackEmpty());
1338 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, NULL, &obj, TestSignCb), HITLS_X509_ERR_MD_NOT_MATCH);1353 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA224, prvKey, NULL, &obj, TestSignCb), HITLS_X509_ERR_MD_NOT_MATCH);
1339 1354 
1340 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA256, prvKey, NULL, &obj, TestSignCb), 0);1355 ASSERT_EQ(HITLS_X509_Sign(CRYPT_MD_SHA256, prvKey, NULL, &obj, TestSignCb), 0);
@@ -1443,6 +1458,7 @@ void SDV_HITLS_X509_PrintDn_TC002(char *certPath, int format, int printFlag, cha
1443 BSL_Buffer data = {(uint8_t *)rawIssuer, sizeof(BslList)};1458 BSL_Buffer data = {(uint8_t *)rawIssuer, sizeof(BslList)};
1444 ASSERT_EQ(HITLS_PKI_PrintCtrl(HITLS_PKI_SET_PRINT_FLAG, &printFlag, sizeof(int), NULL), HITLS_PKI_SUCCESS);1459 ASSERT_EQ(HITLS_PKI_PrintCtrl(HITLS_PKI_SET_PRINT_FLAG, &printFlag, sizeof(int), NULL), HITLS_PKI_SUCCESS);
1445 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_DNNAME, &data, "Print Distinguish name", &expectName, false), 0);1460 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_DNNAME, &data, "Print Distinguish name", &expectName, false), 0);
1461+ ASSERT_TRUE(TestIsErrStackEmpty());
1446 1462 
1447EXIT:1463EXIT:
1448 HITLS_X509_CertFree(cert);1464 HITLS_X509_CertFree(cert);
@@ -1572,6 +1588,7 @@ void SDV_HITLS_X509_PrintCrl_TC001(char *certPath, int format, int printFlag, ch
1572 BSL_Buffer data = {(uint8_t *)crl, sizeof(HITLS_X509_Crl *)};1588 BSL_Buffer data = {(uint8_t *)crl, sizeof(HITLS_X509_Crl *)};
1573 ASSERT_EQ(HITLS_PKI_PrintCtrl(HITLS_PKI_SET_PRINT_FLAG, &printFlag, sizeof(int), NULL), HITLS_PKI_SUCCESS);1589 ASSERT_EQ(HITLS_PKI_PrintCtrl(HITLS_PKI_SET_PRINT_FLAG, &printFlag, sizeof(int), NULL), HITLS_PKI_SUCCESS);
1574 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CRL, &data, "Print crl file", &expect, true), 0);1590 ASSERT_EQ(PrintBuffTest(HITLS_PKI_PRINT_CRL, &data, "Print crl file", &expect, true), 0);
1591+ ASSERT_TRUE(TestIsErrStackEmpty());
1575 1592 
1576EXIT:1593EXIT:
1577 HITLS_X509_CrlFree(crl);1594 HITLS_X509_CrlFree(crl);
@@ -1623,6 +1640,7 @@ void SDV_HITLS_MLKEM_PrivateKey_SeedFormat_TC001(int format, int type, char *pat
1623 // Compare with original file1640 // Compare with original file
1624 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);1641 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
1625 ASSERT_COMPARE("seed key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);1642 ASSERT_COMPARE("seed key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
1643+ ASSERT_TRUE(TestIsErrStackEmpty());
1626 1644 
1627EXIT:1645EXIT:
1628 BSL_SAL_FREE(encodeAsn1.data);1646 BSL_SAL_FREE(encodeAsn1.data);
@@ -1672,6 +1690,7 @@ void SDV_HITLS_MLKEM_PrivateKey_ExpandedFormat_TC001(int format, int type, char
1672 // Compare with original file1690 // Compare with original file
1673 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);1691 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
1674 ASSERT_COMPARE("expanded key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);1692 ASSERT_COMPARE("expanded key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
1693+ ASSERT_TRUE(TestIsErrStackEmpty());
1675 1694 
1676EXIT:1695EXIT:
1677 BSL_SAL_FREE(encodeAsn1.data);1696 BSL_SAL_FREE(encodeAsn1.data);
@@ -1722,6 +1741,7 @@ void SDV_HITLS_MLKEM_PrivateKey_BothFormat_TC001(int format, int type, char *pat
1722 // Compare with original file1741 // Compare with original file
1723 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);1742 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
1724 ASSERT_COMPARE("both format key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);1743 ASSERT_COMPARE("both format key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
1744+ ASSERT_TRUE(TestIsErrStackEmpty());
1725 1745 
1726EXIT:1746EXIT:
1727 BSL_SAL_FREE(encodeAsn1.data);1747 BSL_SAL_FREE(encodeAsn1.data);
@@ -1852,6 +1872,7 @@ void SDV_HITLS_MLKEM_PrivateKey_MutatedS0_TC001(int format, int type, char *path
1852 ASSERT_EQ(ret, CRYPT_MLKEM_INVALID_PRVKEY);1872 ASSERT_EQ(ret, CRYPT_MLKEM_INVALID_PRVKEY);
1853#else1873#else
1854 ASSERT_EQ(ret, CRYPT_SUCCESS);1874 ASSERT_EQ(ret, CRYPT_SUCCESS);
1875+ ASSERT_TRUE(TestIsErrStackEmpty());
1855#endif1876#endif
1856 1877 
1857EXIT:1878EXIT:
@@ -1892,6 +1913,7 @@ void SDV_HITLS_MLKEM_PublicKey_TC001(int format, int type, char *path)
1892 // Read original file and compare1913 // Read original file and compare
1893 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);1914 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
1894 ASSERT_COMPARE("public key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);1915 ASSERT_COMPARE("public key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
1916+ ASSERT_TRUE(TestIsErrStackEmpty());
1895 1917 
1896EXIT:1918EXIT:
1897 BSL_SAL_FREE(encodeAsn1.data);1919 BSL_SAL_FREE(encodeAsn1.data);
@@ -1937,6 +1959,7 @@ void SDV_HITLS_MLKEM_PrivateKey_GenerateEncode_TC001(int mlkemType, int format,
1937 1959 
1938 // Encode to file1960 // Encode to file
1939 ASSERT_EQ(CRYPT_EAL_EncodeFileKey(pkey, NULL, format, type, path), CRYPT_SUCCESS);1961 ASSERT_EQ(CRYPT_EAL_EncodeFileKey(pkey, NULL, format, type, path), CRYPT_SUCCESS);
1962+ ASSERT_TRUE(TestIsErrStackEmpty());
1940 1963 
1941EXIT:1964EXIT:
1942 TestRandDeInit();1965 TestRandDeInit();
@@ -1960,6 +1983,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC001(int format, int type, char *path)
1960 1983
1961 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);1984 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
1962 ASSERT_COMPARE("key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);1985 ASSERT_COMPARE("key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
1986+ ASSERT_TRUE(TestIsErrStackEmpty());
1963 1987 
1964EXIT:1988EXIT:
1965 BSL_SAL_FREE(encodeAsn1.data);1989 BSL_SAL_FREE(encodeAsn1.data);
@@ -1978,6 +2002,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC005(int format, int type, char *path, int key_for
1978 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);2002 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &key), CRYPT_SUCCESS);
1979 2003
1980 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(key, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);2004 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(key, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);
2005+ ASSERT_TRUE(TestIsErrStackEmpty());
1981 2006 
1982 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(key, NULL, format, type, &encodeAsn1), err);2007 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(key, NULL, format, type, &encodeAsn1), err);
1983EXIT:2008EXIT:
@@ -2001,6 +2026,7 @@ void SDV_HITLS_SLHDSA_PQCCert_TC001(int format, int type, char *path)
2001 2026 
2002 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);2027 ASSERT_EQ(ReadFile(path, expectBuf, encodeAsn1.dataLen, &expectBufLen), 0);
2003 ASSERT_COMPARE("key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);2028 ASSERT_COMPARE("key ", encodeAsn1.data, encodeAsn1.dataLen, expectBuf, expectBufLen);
2029+ ASSERT_TRUE(TestIsErrStackEmpty());
2004 2030 
2005EXIT:2031EXIT:
2006 BSL_SAL_FREE(encodeAsn1.data);2032 BSL_SAL_FREE(encodeAsn1.data);
@@ -2073,6 +2099,7 @@ void SDV_PKI_HOSTNAME_EXACT_MATCH_TC001(int flag)
2073 ASSERT_EQ(HITLS_X509_MatchPattern(testFlag, "*.web-server.openhitls.com", "app1.web-server.openhitls.com"),2099 ASSERT_EQ(HITLS_X509_MatchPattern(testFlag, "*.web-server.openhitls.com", "app1.web-server.openhitls.com"),
2074 HITLS_PKI_SUCCESS);2100 HITLS_PKI_SUCCESS);
2075 ASSERT_EQ(HITLS_X509_MatchPattern(testFlag, "192.168.1.1", "192.168.1.1"), HITLS_PKI_SUCCESS);2101 ASSERT_EQ(HITLS_X509_MatchPattern(testFlag, "192.168.1.1", "192.168.1.1"), HITLS_PKI_SUCCESS);
2102+ ASSERT_TRUE(TestIsErrStackEmpty());
2076EXIT:2103EXIT:
2077 return;2104 return;
2078#else2105#else
@@ -2111,6 +2138,7 @@ void SDV_PKI_HOSTNAME_WILDCARD_MATCH_TC002(int flag)
2111 "foobaz.example.net"), HITLS_PKI_SUCCESS);2138 "foobaz.example.net"), HITLS_PKI_SUCCESS);
2112 ASSERT_EQ(HITLS_X509_MatchPattern(HITLS_X509_FLAG_VFY_WITH_PARTIAL_WILDCARD, "b*z.example.net",2139 ASSERT_EQ(HITLS_X509_MatchPattern(HITLS_X509_FLAG_VFY_WITH_PARTIAL_WILDCARD, "b*z.example.net",
2113 "buzz.example.net"), HITLS_PKI_SUCCESS);2140 "buzz.example.net"), HITLS_PKI_SUCCESS);
2141+ ASSERT_TRUE(TestIsErrStackEmpty());
2114EXIT:2142EXIT:
2115 return;2143 return;
2116#else2144#else
@@ -2245,6 +2273,7 @@ void SDV_PKI_VERIFY_HOSTNAME_TC001(int algId, int format, Hex *encode, int flag)
2245 ASSERT_NE(cert, NULL);2273 ASSERT_NE(cert, NULL);
2246 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, -1, "test.hitls.com", strlen("test.hitls.com") - 1),2274 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, -1, "test.hitls.com", strlen("test.hitls.com") - 1),
2247 HITLS_X509_ERR_INVALID_PARAM);2275 HITLS_X509_ERR_INVALID_PARAM);
2276+ TestErrClear();
2248 // Normal cases2277 // Normal cases
2249 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "test.hitls.com", strlen("test.hitls.com")), HITLS_PKI_SUCCESS);2278 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "test.hitls.com", strlen("test.hitls.com")), HITLS_PKI_SUCCESS);
2250 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "test.hitls.net", strlen("test.hitls.net")), HITLS_PKI_SUCCESS);2279 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "test.hitls.net", strlen("test.hitls.net")), HITLS_PKI_SUCCESS);
@@ -2266,6 +2295,7 @@ void SDV_PKI_VERIFY_HOSTNAME_TC001(int algId, int format, Hex *encode, int flag)
2266 HITLS_PKI_SUCCESS);2295 HITLS_PKI_SUCCESS);
2267 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "openhitls.com", strlen("openhitls.com")), HITLS_PKI_SUCCESS);2296 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "openhitls.com", strlen("openhitls.com")), HITLS_PKI_SUCCESS);
2268 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "TEST.HITLS.COM", strlen("TEST.HITLS.COM")), HITLS_PKI_SUCCESS);2297 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "TEST.HITLS.COM", strlen("TEST.HITLS.COM")), HITLS_PKI_SUCCESS);
2298+ ASSERT_TRUE(TestIsErrStackEmpty());
2269 2299 
2270 // Abnormal cases2300 // Abnormal cases
2271 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "openhitls.com\0otherinfo", 23),2301 ASSERT_EQ(HITLS_X509_VerifyHostname(cert, testFlag, "openhitls.com\0otherinfo", 23),
Mtestcode/sdv/testcase/pki/common/test_suite_sdv_x509.c+32-0
@@ -446,6 +446,7 @@ void SDV_PKI_GEN_KEY_TC001(int algId, int type, int curveId)
446 TestMemInit();446 TestMemInit();
447 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);447 ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
448 ASSERT_EQ(TestEncodeKey(algId, type, curveId, path), CRYPT_SUCCESS);448 ASSERT_EQ(TestEncodeKey(algId, type, curveId, path), CRYPT_SUCCESS);
449+ ASSERT_TRUE(TestIsErrStackEmpty());
449 450 
450EXIT:451EXIT:
451 TestRandDeInit();452 TestRandDeInit();
@@ -485,6 +486,7 @@ void SDV_PKI_GEN_ENCKEY_TC001(int algId, int curveId, int symId, Hex *pwd)
485 ASSERT_NE(pkey, NULL);486 ASSERT_NE(pkey, NULL);
486 487 
487 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, &paramEx, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_ENCRYPT, &encode), 0);488 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, &paramEx, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_ENCRYPT, &encode), 0);
489+ ASSERT_TRUE(TestIsErrStackEmpty());
488 490 
489EXIT:491EXIT:
490 TestRandDeInit();492 TestRandDeInit();
@@ -513,6 +515,7 @@ void SDV_PKI_PARSE_KEY_FILE_TC001(int algId, int format, int type, char *path)
513 TestMemInit();515 TestMemInit();
514 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkey), CRYPT_SUCCESS);516 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkey), CRYPT_SUCCESS);
515 ASSERT_NE(pkey, NULL);517 ASSERT_NE(pkey, NULL);
518+ ASSERT_TRUE(TestIsErrStackEmpty());
516 519 
517EXIT:520EXIT:
518 CRYPT_EAL_PkeyFreeCtx(pkey);521 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -539,6 +542,7 @@ void SDV_PKI_PARSE_ENCKEY_FILE_TC001(int algId, int format, int type, char *path
539 TestMemInit();542 TestMemInit();
540 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, pass->x, pass->len, &pkey), CRYPT_SUCCESS);543 ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, pass->x, pass->len, &pkey), CRYPT_SUCCESS);
541 ASSERT_NE(pkey, NULL);544 ASSERT_NE(pkey, NULL);
545+ ASSERT_TRUE(TestIsErrStackEmpty());
542 546 
543EXIT:547EXIT:
544 CRYPT_EAL_PkeyFreeCtx(pkey);548 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -566,6 +570,7 @@ void SDV_PKI_PARSE_KEY_BUFF_TC001(int algId, int format, int type, Hex *encode)
566 TestMemInit();570 TestMemInit();
567 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(format, type, (BSL_Buffer *)encode, NULL, 0, &pkey), CRYPT_SUCCESS);571 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(format, type, (BSL_Buffer *)encode, NULL, 0, &pkey), CRYPT_SUCCESS);
568 ASSERT_NE(pkey, NULL);572 ASSERT_NE(pkey, NULL);
573+ ASSERT_TRUE(TestIsErrStackEmpty());
569 574 
570EXIT:575EXIT:
571 CRYPT_EAL_PkeyFreeCtx(pkey);576 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -633,6 +638,7 @@ void SDV_PKI_GEN_CRL_TC001(int algId, int hashId, int curveId)
633 ASSERT_EQ(HITLS_X509_CrlGenBuff(BSL_FORMAT_PEM, crl, &encode), 0);638 ASSERT_EQ(HITLS_X509_CrlGenBuff(BSL_FORMAT_PEM, crl, &encode), 0);
634 BSL_SAL_FREE(encode.data);639 BSL_SAL_FREE(encode.data);
635#endif640#endif
641+ ASSERT_TRUE(TestIsErrStackEmpty());
636 642 
637EXIT:643EXIT:
638 TestRandDeInit();644 TestRandDeInit();
@@ -659,6 +665,7 @@ void SDV_PKI_PARSE_CRL_FILE_TC001(int algId, int format, char *path)
659 665 
660 TestMemInit();666 TestMemInit();
661 ASSERT_EQ(HITLS_X509_CrlParseFile(format, path, &crl), HITLS_PKI_SUCCESS);667 ASSERT_EQ(HITLS_X509_CrlParseFile(format, path, &crl), HITLS_PKI_SUCCESS);
668+ ASSERT_TRUE(TestIsErrStackEmpty());
662 669 
663EXIT:670EXIT:
664 HITLS_X509_CrlFree(crl);671 HITLS_X509_CrlFree(crl);
@@ -681,6 +688,7 @@ void SDV_PKI_PARSE_CRL_BUFF_TC001(int algId, int format, Hex *encode)
681 688 
682 TestMemInit();689 TestMemInit();
683 ASSERT_EQ(HITLS_X509_CrlParseBuff(format, (BSL_Buffer *)encode, &crl), HITLS_PKI_SUCCESS);690 ASSERT_EQ(HITLS_X509_CrlParseBuff(format, (BSL_Buffer *)encode, &crl), HITLS_PKI_SUCCESS);
691+ ASSERT_TRUE(TestIsErrStackEmpty());
684 692 
685EXIT:693EXIT:
686 HITLS_X509_CrlFree(crl);694 HITLS_X509_CrlFree(crl);
@@ -746,6 +754,7 @@ void SDV_PKI_GEN_CSR_TC001(int algId, int hashId, int curveId)
746 ASSERT_EQ(HITLS_X509_CsrGenBuff(BSL_FORMAT_PEM, csr, &encode), 0);754 ASSERT_EQ(HITLS_X509_CsrGenBuff(BSL_FORMAT_PEM, csr, &encode), 0);
747 BSL_SAL_FREE(encode.data);755 BSL_SAL_FREE(encode.data);
748#endif756#endif
757+ ASSERT_TRUE(TestIsErrStackEmpty());
749 758 
750EXIT:759EXIT:
751 TestRandDeInit();760 TestRandDeInit();
@@ -771,6 +780,7 @@ void SDV_PKI_PARSE_CSR_FILE_TC001(int algId, int format, char *path)
771 HITLS_X509_Csr *csr = NULL;780 HITLS_X509_Csr *csr = NULL;
772 TestMemInit();781 TestMemInit();
773 ASSERT_EQ(HITLS_X509_CsrParseFile(format, path, &csr), HITLS_PKI_SUCCESS);782 ASSERT_EQ(HITLS_X509_CsrParseFile(format, path, &csr), HITLS_PKI_SUCCESS);
783+ ASSERT_TRUE(TestIsErrStackEmpty());
774 784 
775EXIT:785EXIT:
776 HITLS_X509_CsrFree(csr);786 HITLS_X509_CsrFree(csr);
@@ -792,6 +802,7 @@ void SDV_PKI_PARSE_CSR_BUFF_TC001(int algId, int format, Hex *encode)
792 HITLS_X509_Csr *csr = NULL;802 HITLS_X509_Csr *csr = NULL;
793 TestMemInit();803 TestMemInit();
794 ASSERT_EQ(HITLS_X509_CsrParseBuff(format, (BSL_Buffer *)encode, &csr), HITLS_PKI_SUCCESS);804 ASSERT_EQ(HITLS_X509_CsrParseBuff(format, (BSL_Buffer *)encode, &csr), HITLS_PKI_SUCCESS);
805+ ASSERT_TRUE(TestIsErrStackEmpty());
795 806 
796EXIT:807EXIT:
797 HITLS_X509_CsrFree(csr);808 HITLS_X509_CsrFree(csr);
@@ -863,6 +874,7 @@ void SDV_PKI_GEN_CERT_TC001(int algId, int hashId, int curveId)
863 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);874 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
864 BSL_SAL_FREE(encode.data);875 BSL_SAL_FREE(encode.data);
865#endif876#endif
877+ ASSERT_TRUE(TestIsErrStackEmpty());
866 878 
867EXIT:879EXIT:
868 TestRandDeInit();880 TestRandDeInit();
@@ -888,6 +900,7 @@ void SDV_PKI_PARSE_CERT_FILE_TC001(int algId, int format, char *path)
888 HITLS_X509_Cert *cert = NULL;900 HITLS_X509_Cert *cert = NULL;
889 TestMemInit();901 TestMemInit();
890 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);902 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);
903+ ASSERT_TRUE(TestIsErrStackEmpty());
891 904 
892EXIT:905EXIT:
893 HITLS_X509_CertFree(cert);906 HITLS_X509_CertFree(cert);
@@ -909,6 +922,7 @@ void SDV_PKI_PARSE_CERT_BUFF_TC001(int algId, int format, Hex *encode)
909 HITLS_X509_Cert *cert = NULL;922 HITLS_X509_Cert *cert = NULL;
910 TestMemInit();923 TestMemInit();
911 ASSERT_EQ(HITLS_X509_CertParseBuff(format, (BSL_Buffer *)encode, &cert), HITLS_PKI_SUCCESS);924 ASSERT_EQ(HITLS_X509_CertParseBuff(format, (BSL_Buffer *)encode, &cert), HITLS_PKI_SUCCESS);
925+ ASSERT_TRUE(TestIsErrStackEmpty());
912 926 
913EXIT:927EXIT:
914 HITLS_X509_CertFree(cert);928 HITLS_X509_CertFree(cert);
@@ -935,6 +949,7 @@ void SDV_PKI_PARSE_CERT_FILE_CONTAIN_T61_TC001(int algId, int format, char *path
935 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);949 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);
936 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);950 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);
937 ASSERT_EQ(HITLS_X509_CertParseBuff(format, &buff, &certCpy), HITLS_PKI_SUCCESS);951 ASSERT_EQ(HITLS_X509_CertParseBuff(format, &buff, &certCpy), HITLS_PKI_SUCCESS);
952+ ASSERT_TRUE(TestIsErrStackEmpty());
938EXIT:953EXIT:
939 BSL_SAL_Free(buff.data);954 BSL_SAL_Free(buff.data);
940 HITLS_X509_CertFree(cert);955 HITLS_X509_CertFree(cert);
@@ -985,6 +1000,7 @@ void SDV_HITLS_MLDSA_PQC_CERT_TC001(char *keypath)
985 // generate cert buff1000 // generate cert buff
986 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), HITLS_PKI_SUCCESS);1001 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), HITLS_PKI_SUCCESS);
987 BSL_SAL_FREE(encode.data);1002 BSL_SAL_FREE(encode.data);
1003+ ASSERT_TRUE(TestIsErrStackEmpty());
988 1004 
989EXIT:1005EXIT:
990 TestRandDeInit();1006 TestRandDeInit();
@@ -1033,6 +1049,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC003(int format, char *path)
1033 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);1049 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);
1034 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);1050 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);
1035 ASSERT_COMPARE("cert", buff.data, buff.dataLen, data, dataLen);1051 ASSERT_COMPARE("cert", buff.data, buff.dataLen, data, dataLen);
1052+ ASSERT_TRUE(TestIsErrStackEmpty());
1036EXIT:1053EXIT:
1037 BSL_SAL_Free(buff.data);1054 BSL_SAL_Free(buff.data);
1038 BSL_SAL_Free(data);1055 BSL_SAL_Free(data);
@@ -1065,6 +1082,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC004(int format, int type, int key_format, int key
1065 ASSERT_EQ(keylen, encodeAsn1.dataLen);1082 ASSERT_EQ(keylen, encodeAsn1.dataLen);
1066 1083
1067 ASSERT_EQ(CRYPT_EAL_EncodeFileKey(pkey, NULL, format, type, path), CRYPT_SUCCESS);1084 ASSERT_EQ(CRYPT_EAL_EncodeFileKey(pkey, NULL, format, type, path), CRYPT_SUCCESS);
1085+ ASSERT_TRUE(TestIsErrStackEmpty());
1068 1086
1069EXIT:1087EXIT:
1070 BSL_SAL_FREE(encodeAsn1.data);1088 BSL_SAL_FREE(encodeAsn1.data);
@@ -1123,6 +1141,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC006()
1123 // generate cert buff1141 // generate cert buff
1124 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);1142 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
1125 BSL_SAL_FREE(encode.data);1143 BSL_SAL_FREE(encode.data);
1144+ ASSERT_TRUE(TestIsErrStackEmpty());
1126 1145 
1127EXIT:1146EXIT:
1128 TestRandDeInit();1147 TestRandDeInit();
@@ -1178,6 +1197,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC007(char *keypath)
1178 // generate cert buff1197 // generate cert buff
1179 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);1198 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
1180 BSL_SAL_FREE(encode.data);1199 BSL_SAL_FREE(encode.data);
1200+ ASSERT_TRUE(TestIsErrStackEmpty());
1181 1201 
1182EXIT:1202EXIT:
1183 TestRandDeInit();1203 TestRandDeInit();
@@ -1210,6 +1230,7 @@ static int32_t SetCertExtkid(HITLS_X509_Cert *cert, uint8_t *akid, uint8_t *skid
1210 1230 
1211 san.names = GenGeneralNameList();1231 san.names = GenGeneralNameList();
1212 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_EXT_SET_SAN, &san, sizeof(HITLS_X509_ExtSan)), 0);1232 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_EXT_SET_SAN, &san, sizeof(HITLS_X509_ExtSan)), 0);
1233+ ASSERT_TRUE(TestIsErrStackEmpty());
1213 ret = 0;1234 ret = 0;
1214EXIT:1235EXIT:
1215 BSL_LIST_FREE(san.names, (BSL_LIST_PFUNC_FREE)HITLS_X509_FreeGeneralName);1236 BSL_LIST_FREE(san.names, (BSL_LIST_PFUNC_FREE)HITLS_X509_FreeGeneralName);
@@ -1289,6 +1310,7 @@ void SDV_HITLS_GEN_CSR_CERT_TC001()
1289 // generate cert buff1310 // generate cert buff
1290 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);1311 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
1291 BSL_SAL_FREE(encode.data);1312 BSL_SAL_FREE(encode.data);
1313+ ASSERT_TRUE(TestIsErrStackEmpty());
1292 1314 
1293EXIT:1315EXIT:
1294 TestRandDeInit();1316 TestRandDeInit();
@@ -1385,6 +1407,7 @@ void SDV_HITLS_GEN_CSR_MIDCERT_TC001()
1385 // generate cert buff1407 // generate cert buff
1386 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);1408 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
1387 BSL_SAL_FREE(encode.data);1409 BSL_SAL_FREE(encode.data);
1410+ ASSERT_TRUE(TestIsErrStackEmpty());
1388 1411 
1389EXIT:1412EXIT:
1390 TestRandDeInit();1413 TestRandDeInit();
@@ -1482,6 +1505,7 @@ void SDV_HITLS_GEN_CSR_EECERT_TC001()
1482 // generate cert buff1505 // generate cert buff
1483 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);1506 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_PEM, cert, &encode), 0);
1484 BSL_SAL_FREE(encode.data);1507 BSL_SAL_FREE(encode.data);
1508+ ASSERT_TRUE(TestIsErrStackEmpty());
1485 1509 
1486EXIT:1510EXIT:
1487 TestRandDeInit();1511 TestRandDeInit();
@@ -1537,6 +1561,7 @@ void SDV_HITLS_CERT_CHAIN_FUNC_TC001()
1537 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1561 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1538 ret = HITLS_X509_CertVerify(store, chain);1562 ret = HITLS_X509_CertVerify(store, chain);
1539 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1563 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1564+ ASSERT_TRUE(TestIsErrStackEmpty());
1540 1565 
1541EXIT:1566EXIT:
1542 HITLS_X509_CertFree(entity);1567 HITLS_X509_CertFree(entity);
@@ -1569,6 +1594,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC009(int key_format)
1569 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);1594 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);
1570 1595 
1571 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1), CRYPT_SUCCESS);1596 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1), CRYPT_SUCCESS);
1597+ ASSERT_TRUE(TestIsErrStackEmpty());
1572 switch (key_format)1598 switch (key_format)
1573 {1599 {
1574 case CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY:1600 case CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY:
@@ -1618,6 +1644,7 @@ void SDV_HITLS_MLDSA_PQCCert_TC010()
1618 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);1644 ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT, &key_format, sizeof(uint32_t)), CRYPT_SUCCESS);
1619 1645 
1620 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1), CRYPT_SUCCESS);1646 ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1), CRYPT_SUCCESS);
1647+ ASSERT_TRUE(TestIsErrStackEmpty());
1621 1648 
1622 encodeAsn1.data[40]++; 1649 encodeAsn1.data[40]++;
1623 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1, NULL, 0, &pkeyout), CRYPT_MLDSA_PRVKEY_SEED_INCONSISTENT);1650 ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1, NULL, 0, &pkeyout), CRYPT_MLDSA_PRVKEY_SEED_INCONSISTENT);
@@ -1650,6 +1677,7 @@ void SDV_HITLS_SLHDSA_PQCCert_TC001(int format, char *path)
1650 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);1677 ASSERT_EQ(HITLS_X509_CertParseFile(format, path, &cert), HITLS_PKI_SUCCESS);
1651 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);1678 ASSERT_EQ(HITLS_X509_CertGenBuff(format, cert, &buff), HITLS_PKI_SUCCESS);
1652 ASSERT_COMPARE("cert", buff.data, buff.dataLen, data, dataLen);1679 ASSERT_COMPARE("cert", buff.data, buff.dataLen, data, dataLen);
1680+ ASSERT_TRUE(TestIsErrStackEmpty());
1653EXIT:1681EXIT:
1654 BSL_SAL_Free(buff.data);1682 BSL_SAL_Free(buff.data);
1655 BSL_SAL_Free(data);1683 BSL_SAL_Free(data);
@@ -1693,6 +1721,7 @@ void SDV_PKI_GET_SAN_FROM_CERT_BUFF_TC001(int algId, int format, Hex *encode)
1693 1721 
1694 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SUBJECT_CN_STR, &cn, sizeof(BSL_Buffer)), 0);1722 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SUBJECT_CN_STR, &cn, sizeof(BSL_Buffer)), 0);
1695 ASSERT_NE(cn.data, NULL);1723 ASSERT_NE(cn.data, NULL);
1724+ ASSERT_TRUE(TestIsErrStackEmpty());
1696 1725 
1697EXIT:1726EXIT:
1698 HITLS_X509_CertFree(cert);1727 HITLS_X509_CertFree(cert);
@@ -1895,6 +1924,7 @@ void SDV_PKI_GEN_CERT_STUB_TC001(int algId, int hashId, int curveId)
1895 ASSERT_EQ(HITLS_X509_CertSign(hashId, key, &algParam, cert), HITLS_PKI_SUCCESS);1924 ASSERT_EQ(HITLS_X509_CertSign(hashId, key, &algParam, cert), HITLS_PKI_SUCCESS);
1896 ASSERT_EQ(HITLS_X509_CertSign(hashId, key, &algParam, testCert), HITLS_PKI_SUCCESS);1925 ASSERT_EQ(HITLS_X509_CertSign(hashId, key, &algParam, testCert), HITLS_PKI_SUCCESS);
1897 }1926 }
1927+ ASSERT_TRUE(TestIsErrStackEmpty());
1898 1928 
1899 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc);1929 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc);
1900 1930 
@@ -1986,6 +2016,7 @@ void SDV_PKI_GEN_CSR_STUB_TC001(int algId, int hashId, int curveId)
1986 ASSERT_EQ(HITLS_X509_CsrSign(hashId, key, &algParam, csr), HITLS_PKI_SUCCESS);2016 ASSERT_EQ(HITLS_X509_CsrSign(hashId, key, &algParam, csr), HITLS_PKI_SUCCESS);
1987 ASSERT_EQ(HITLS_X509_CsrSign(hashId, key, &algParam, testCsr), HITLS_PKI_SUCCESS);2017 ASSERT_EQ(HITLS_X509_CsrSign(hashId, key, &algParam, testCsr), HITLS_PKI_SUCCESS);
1988 }2018 }
2019+ ASSERT_TRUE(TestIsErrStackEmpty());
1989 2020 
1990 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc);2021 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc);
1991 2022 
@@ -2241,6 +2272,7 @@ void SDV_X509_PQ_CERT_GEN_PKI_TC001(int algId, int paraId, char *root, char *crl
2241 remove(root);2272 remove(root);
2242 remove(crl);2273 remove(crl);
2243 remove(csr);2274 remove(csr);
2275+ ASSERT_TRUE(TestIsErrStackEmpty());
2244EXIT:2276EXIT:
2245 HITLS_X509_CertFree(cert);2277 HITLS_X509_CertFree(cert);
2246 CRYPT_EAL_PkeyFreeCtx(privKey);2278 CRYPT_EAL_PkeyFreeCtx(privKey);
Mtestcode/sdv/testcase/pki/crl/test_suite_sdv_x509_crl.c+37-0
@@ -34,6 +34,9 @@
34#include "hitls_cert_local.h"34#include "hitls_cert_local.h"
35#include "stub_utils.h"35#include "stub_utils.h"
36#include "hitls_pki_utils.h"36#include "hitls_pki_utils.h"
37+#ifdef HITLS_BSL_ERR
38+#include "bsl_err.h"
39+#endif
37 40 
38STUB_DEFINE_RET1(void *, BSL_SAL_Malloc, uint32_t);41STUB_DEFINE_RET1(void *, BSL_SAL_Malloc, uint32_t);
39 42 
@@ -53,6 +56,7 @@ void SDV_X509_CRL_PARSE_FUNC_TC001(int format, char *path)
53 HITLS_X509_Crl *crl = NULL;56 HITLS_X509_Crl *crl = NULL;
54 57 
55 ASSERT_EQ(HITLS_X509_CrlParseFile((int32_t)format, path, &crl), HITLS_PKI_SUCCESS);58 ASSERT_EQ(HITLS_X509_CrlParseFile((int32_t)format, path, &crl), HITLS_PKI_SUCCESS);
59+ ASSERT_TRUE(TestIsErrStackEmpty());
56EXIT:60EXIT:
57 HITLS_X509_CrlFree(crl);61 HITLS_X509_CrlFree(crl);
58 BSL_GLOBAL_DeInit();62 BSL_GLOBAL_DeInit();
@@ -69,6 +73,7 @@ void SDV_X509_CRL_CTRL_FUNC_TC001(char *path)
69 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_REF_UP, &ref, sizeof(ref)), HITLS_PKI_SUCCESS);73 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_REF_UP, &ref, sizeof(ref)), HITLS_PKI_SUCCESS);
70 ASSERT_EQ(ref, 2);74 ASSERT_EQ(ref, 2);
71 HITLS_X509_CrlFree(crl);75 HITLS_X509_CrlFree(crl);
76+ ASSERT_TRUE(TestIsErrStackEmpty());
72 77 
73EXIT:78EXIT:
74 HITLS_X509_CrlFree(crl);79 HITLS_X509_CrlFree(crl);
@@ -81,6 +86,7 @@ void SDV_X509_CRL_PARSE_VERSION_FUNC_TC001(char *path, int version)
81 HITLS_X509_Crl *crl = NULL;86 HITLS_X509_Crl *crl = NULL;
82 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_ASN1, path, &crl), HITLS_PKI_SUCCESS);87 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_ASN1, path, &crl), HITLS_PKI_SUCCESS);
83 ASSERT_EQ(crl->tbs.version, version);88 ASSERT_EQ(crl->tbs.version, version);
89+ ASSERT_TRUE(TestIsErrStackEmpty());
84EXIT:90EXIT:
85 HITLS_X509_CrlFree(crl);91 HITLS_X509_CrlFree(crl);
86}92}
@@ -97,6 +103,7 @@ void SDV_X509_CRL_PARSE_TBS_SIGNALG_FUNC_TC001(char *path, int signAlg,
97 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.mdId, rsaPssHash);103 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.mdId, rsaPssHash);
98 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.mgfId, rsaPssMgf1);104 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.mgfId, rsaPssMgf1);
99 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);105 ASSERT_EQ(crl->tbs.signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);
106+ ASSERT_TRUE(TestIsErrStackEmpty());
100 107 
101EXIT:108EXIT:
102 HITLS_X509_CrlFree(crl);109 HITLS_X509_CrlFree(crl);
@@ -146,6 +153,7 @@ void SDV_X509_CRL_PARSE_ISSUERNAME_FUNC_TC001(char *path, int count,
146 expAsan1Arr[i + 1].buff, expAsan1Arr[i + 1].len);153 expAsan1Arr[i + 1].buff, expAsan1Arr[i + 1].len);
147 nameNode = BSL_LIST_Next(crl->tbs.issuerName);154 nameNode = BSL_LIST_Next(crl->tbs.issuerName);
148 }155 }
156+ ASSERT_TRUE(TestIsErrStackEmpty());
149EXIT:157EXIT:
150 HITLS_X509_CrlFree(crl);158 HITLS_X509_CrlFree(crl);
151}159}
@@ -183,6 +191,7 @@ void SDV_X509_CRL_PARSE_REVOKED_FUNC_TC003(char *path, int count, int num,
183 ASSERT_EQ(nameNode->time.hour, hour1);191 ASSERT_EQ(nameNode->time.hour, hour1);
184 ASSERT_EQ(nameNode->time.minute, minute1);192 ASSERT_EQ(nameNode->time.minute, minute1);
185 ASSERT_EQ(nameNode->time.second, second1);193 ASSERT_EQ(nameNode->time.second, second1);
194+ ASSERT_TRUE(TestIsErrStackEmpty());
186EXIT:195EXIT:
187 HITLS_X509_CrlFree(crl);196 HITLS_X509_CrlFree(crl);
188}197}
@@ -212,6 +221,7 @@ void SDV_X509_CRL_PARSE_START_TIME_FUNC_TC001(char *path,
212 ASSERT_EQ(crl->tbs.validTime.start.hour, hour);221 ASSERT_EQ(crl->tbs.validTime.start.hour, hour);
213 ASSERT_EQ(crl->tbs.validTime.start.minute, minute);222 ASSERT_EQ(crl->tbs.validTime.start.minute, minute);
214 ASSERT_EQ(crl->tbs.validTime.start.second, second);223 ASSERT_EQ(crl->tbs.validTime.start.second, second);
224+ ASSERT_TRUE(TestIsErrStackEmpty());
215EXIT:225EXIT:
216 HITLS_X509_CrlFree(crl);226 HITLS_X509_CrlFree(crl);
217}227}
@@ -230,6 +240,7 @@ void SDV_X509_CRL_PARSE_END_TIME_FUNC_TC001(char *path,
230 ASSERT_EQ(crl->tbs.validTime.end.hour, hour);240 ASSERT_EQ(crl->tbs.validTime.end.hour, hour);
231 ASSERT_EQ(crl->tbs.validTime.end.minute, minute);241 ASSERT_EQ(crl->tbs.validTime.end.minute, minute);
232 ASSERT_EQ(crl->tbs.validTime.end.second, second);242 ASSERT_EQ(crl->tbs.validTime.end.second, second);
243+ ASSERT_TRUE(TestIsErrStackEmpty());
233EXIT:244EXIT:
234 HITLS_X509_CrlFree(crl);245 HITLS_X509_CrlFree(crl);
235}246}
@@ -251,6 +262,7 @@ void SDV_X509_CRL_PARSE_EXTENSIONS_FUNC_TC001(char *path,
251 ASSERT_COMPARE("extnId", (*nameNode)->extnId.buff, (*nameNode)->extnId.len, value1->x, value1->len);262 ASSERT_COMPARE("extnId", (*nameNode)->extnId.buff, (*nameNode)->extnId.len, value1->x, value1->len);
252 ASSERT_EQ((*nameNode)->extnValue.tag, tag2);263 ASSERT_EQ((*nameNode)->extnValue.tag, tag2);
253 ASSERT_COMPARE("extnValue", (*nameNode)->extnValue.buff, (*nameNode)->extnValue.len, value2->x, value2->len);264 ASSERT_COMPARE("extnValue", (*nameNode)->extnValue.buff, (*nameNode)->extnValue.len, value2->x, value2->len);
265+ ASSERT_TRUE(TestIsErrStackEmpty());
254EXIT:266EXIT:
255 HITLS_X509_CrlFree(crl);267 HITLS_X509_CrlFree(crl);
256 BSL_GLOBAL_DeInit();268 BSL_GLOBAL_DeInit();
@@ -268,6 +280,7 @@ void SDV_X509_CRL_PARSE_SIGNALG_FUNC_TC001(char *path, int signAlg,
268 ASSERT_EQ(crl->signAlgId.rsaPssParam.mdId, rsaPssHash);280 ASSERT_EQ(crl->signAlgId.rsaPssParam.mdId, rsaPssHash);
269 ASSERT_EQ(crl->signAlgId.rsaPssParam.mgfId, rsaPssMgf1);281 ASSERT_EQ(crl->signAlgId.rsaPssParam.mgfId, rsaPssMgf1);
270 ASSERT_EQ(crl->signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);282 ASSERT_EQ(crl->signAlgId.rsaPssParam.saltLen, rsaPssSaltLen);
283+ ASSERT_TRUE(TestIsErrStackEmpty());
271 284 
272EXIT:285EXIT:
273 HITLS_X509_CrlFree(crl);286 HITLS_X509_CrlFree(crl);
@@ -282,6 +295,7 @@ void SDV_X509_CRL_PARSE_SIGNATURE_FUNC_TC001(char *path, Hex *buff, int unusedBi
282 ASSERT_EQ(crl->signature.len, buff->len);295 ASSERT_EQ(crl->signature.len, buff->len);
283 ASSERT_COMPARE("signature", crl->signature.buff, crl->signature.len, buff->x, buff->len);296 ASSERT_COMPARE("signature", crl->signature.buff, crl->signature.len, buff->x, buff->len);
284 ASSERT_EQ(crl->signature.unusedBits, unusedBits);297 ASSERT_EQ(crl->signature.unusedBits, unusedBits);
298+ ASSERT_TRUE(TestIsErrStackEmpty());
285EXIT:299EXIT:
286 HITLS_X509_CrlFree(crl);300 HITLS_X509_CrlFree(crl);
287}301}
@@ -295,6 +309,7 @@ void SDV_X509_MUL_CRL_PARSE_FUNC_TC001(int format, char *path, int crlNum)
295 int32_t ret = HITLS_X509_CrlParseBundleFile(format, path, &list);309 int32_t ret = HITLS_X509_CrlParseBundleFile(format, path, &list);
296 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);310 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
297 ASSERT_EQ(BSL_LIST_COUNT(list), crlNum);311 ASSERT_EQ(BSL_LIST_COUNT(list), crlNum);
312+ ASSERT_TRUE(TestIsErrStackEmpty());
298EXIT:313EXIT:
299 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CrlFree);314 BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CrlFree);
300}315}
@@ -322,6 +337,7 @@ void SDV_X509_CRL_Encode_TC001(int format, char *path)
322 ASSERT_EQ(dataLen, strlen((char *)encode.data));337 ASSERT_EQ(dataLen, strlen((char *)encode.data));
323 }338 }
324 ASSERT_EQ(memcmp(encode.data, data, dataLen), 0);339 ASSERT_EQ(memcmp(encode.data, data, dataLen), 0);
340+ ASSERT_TRUE(TestIsErrStackEmpty());
325 341 
326EXIT:342EXIT:
327 BSL_SAL_Free(data);343 BSL_SAL_Free(data);
@@ -372,6 +388,7 @@ void SDV_X509_CRL_EncodeFile_TC001(int format, char *path)
372 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);388 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
373 ASSERT_EQ(BSL_SAL_ReadFile("res.crl", &res, &resLen), BSL_SUCCESS);389 ASSERT_EQ(BSL_SAL_ReadFile("res.crl", &res, &resLen), BSL_SUCCESS);
374 ASSERT_COMPARE("crl_file com", data, dataLen, res, resLen);390 ASSERT_COMPARE("crl_file com", data, dataLen, res, resLen);
391+ ASSERT_TRUE(TestIsErrStackEmpty());
375EXIT:392EXIT:
376 BSL_SAL_Free(data);393 BSL_SAL_Free(data);
377 HITLS_X509_CrlFree(crl);394 HITLS_X509_CrlFree(crl);
@@ -389,6 +406,7 @@ void SDV_X509_CRL_Check_TC001(char *capath, char *crlpath, int res)
389 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_UNKNOWN, crlpath, &crl), HITLS_PKI_SUCCESS);406 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_UNKNOWN, crlpath, &crl), HITLS_PKI_SUCCESS);
390 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_UNKNOWN, capath, &cert), HITLS_PKI_SUCCESS);407 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_UNKNOWN, capath, &cert), HITLS_PKI_SUCCESS);
391 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_PUBKEY, &pubKey, sizeof(void *)), HITLS_PKI_SUCCESS);408 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_GET_PUBKEY, &pubKey, sizeof(void *)), HITLS_PKI_SUCCESS);
409+ ASSERT_TRUE(TestIsErrStackEmpty());
392 ASSERT_EQ(HITLS_X509_CrlVerify(pubKey, crl), res);410 ASSERT_EQ(HITLS_X509_CrlVerify(pubKey, crl), res);
393EXIT:411EXIT:
394 CRYPT_EAL_PkeyFreeCtx(pubKey);412 CRYPT_EAL_PkeyFreeCtx(pubKey);
@@ -562,6 +580,7 @@ void SDV_X509_CRL_PARSE_REVOKEDLIST_FUNC_TC001(char *parh, int revokedNum)
562 memset(&time, 0, sizeof(BSL_TIME));580 memset(&time, 0, sizeof(BSL_TIME));
563 memset(&serialNum, 0, sizeof(serialNum));581 memset(&serialNum, 0, sizeof(serialNum));
564 }582 }
583+ ASSERT_TRUE(TestIsErrStackEmpty());
565EXIT:584EXIT:
566 HITLS_X509_CrlFree(crl);585 HITLS_X509_CrlFree(crl);
567}586}
@@ -610,6 +629,7 @@ void SDV_X509_CRL_CTRL_GetFunc_TC001(void)
610 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_REVOKELIST, &revokeList, sizeof(BslList *)), HITLS_PKI_SUCCESS);629 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_REVOKELIST, &revokeList, sizeof(BslList *)), HITLS_PKI_SUCCESS);
611 ASSERT_NE(revokeList, NULL);630 ASSERT_NE(revokeList, NULL);
612 ASSERT_EQ(BSL_LIST_COUNT(revokeList), 3);631 ASSERT_EQ(BSL_LIST_COUNT(revokeList), 3);
632+ ASSERT_TRUE(TestIsErrStackEmpty());
613 633 
614EXIT:634EXIT:
615 HITLS_X509_CrlFree(crl);635 HITLS_X509_CrlFree(crl);
@@ -644,6 +664,7 @@ void SDV_X509_CRL_ExtCtrl_FuncTest_TC001(void)
644 ASSERT_EQ(getaki.critical, aki.critical);664 ASSERT_EQ(getaki.critical, aki.critical);
645 ASSERT_EQ(getaki.kid.dataLen, aki.kid.dataLen);665 ASSERT_EQ(getaki.kid.dataLen, aki.kid.dataLen);
646 ASSERT_EQ(memcmp(getaki.kid.data, aki.kid.data, aki.kid.dataLen), 0);666 ASSERT_EQ(memcmp(getaki.kid.data, aki.kid.data, aki.kid.dataLen), 0);
667+ ASSERT_TRUE(TestIsErrStackEmpty());
647 668 
648EXIT:669EXIT:
649 HITLS_X509_CrlFree(crl);670 HITLS_X509_CrlFree(crl);
@@ -684,6 +705,7 @@ void SDV_X509_CRL_CTRL_SetFunc_TC001(char *capath)
684 HITLS_X509_ExtCrlNumber crlNumberExt = {false, {serialNum, 4}};705 HITLS_X509_ExtCrlNumber crlNumberExt = {false, {serialNum, 4}};
685 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_CRLNUMBER, &crlNumberExt, sizeof(HITLS_X509_ExtCrlNumber)),706 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_CRLNUMBER, &crlNumberExt, sizeof(HITLS_X509_ExtCrlNumber)),
686 HITLS_PKI_SUCCESS);707 HITLS_PKI_SUCCESS);
708+ ASSERT_TRUE(TestIsErrStackEmpty());
687EXIT:709EXIT:
688 HITLS_X509_CertFree(cert);710 HITLS_X509_CertFree(cert);
689 HITLS_X509_CrlFree(crl);711 HITLS_X509_CrlFree(crl);
@@ -1038,6 +1060,7 @@ void SDV_X509_CRL_Sign_RevokedCheck_TC001(void)
1038 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_SET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);1060 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_SET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);
1039 1061 
1040 ASSERT_EQ(SetCrlRevoked(crl, 1), HITLS_PKI_SUCCESS);1062 ASSERT_EQ(SetCrlRevoked(crl, 1), HITLS_PKI_SUCCESS);
1063+ ASSERT_TRUE(TestIsErrStackEmpty());
1041 entry = BSL_LIST_GET_FIRST(crl->tbs.revokedCerts);1064 entry = BSL_LIST_GET_FIRST(crl->tbs.revokedCerts);
1042 ASSERT_TRUE(entry != NULL);1065 ASSERT_TRUE(entry != NULL);
1043 1066 
@@ -1093,6 +1116,9 @@ static int32_t SetCrl(HITLS_X509_Crl *crl, HITLS_X509_Cert *cert, bool isV2)
1093 }1116 }
1094 if (isV2) {1117 if (isV2) {
1095 HITLS_X509_ExtSki ski = {0};1118 HITLS_X509_ExtSki ski = {0};
1119+#ifdef HITLS_BSL_ERR
1120+ (void)BSL_ERR_SetMark();
1121+#endif
1096 int32_t ret = HITLS_X509_CertCtrl(cert, HITLS_X509_EXT_GET_SKI, &ski, sizeof(HITLS_X509_ExtSki));1122 int32_t ret = HITLS_X509_CertCtrl(cert, HITLS_X509_EXT_GET_SKI, &ski, sizeof(HITLS_X509_ExtSki));
1097 if (ret == HITLS_PKI_SUCCESS) {1123 if (ret == HITLS_PKI_SUCCESS) {
1098 HITLS_X509_ExtAki aki = {false, {ski.kid.data, ski.kid.dataLen}, NULL, {NULL, 0}};1124 HITLS_X509_ExtAki aki = {false, {ski.kid.data, ski.kid.dataLen}, NULL, {NULL, 0}};
@@ -1100,6 +1126,9 @@ static int32_t SetCrl(HITLS_X509_Crl *crl, HITLS_X509_Cert *cert, bool isV2)
1100 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_AKI, &aki, sizeof(HITLS_X509_ExtAki)),1126 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_AKI, &aki, sizeof(HITLS_X509_ExtAki)),
1101 HITLS_PKI_SUCCESS);1127 HITLS_PKI_SUCCESS);
1102 }1128 }
1129+#ifdef HITLS_BSL_ERR
1130+ (void)BSL_ERR_PopToMark();
1131+#endif
1103 1132 
1104 // Set CRL Number extension1133 // Set CRL Number extension
1105 HITLS_X509_ExtCrlNumber crlNumberExt = {1134 HITLS_X509_ExtCrlNumber crlNumberExt = {
@@ -1109,6 +1138,7 @@ static int32_t SetCrl(HITLS_X509_Crl *crl, HITLS_X509_Cert *cert, bool isV2)
1109 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_CRLNUMBER, &crlNumberExt,1138 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_SET_CRLNUMBER, &crlNumberExt,
1110 sizeof(HITLS_X509_ExtCrlNumber)), HITLS_PKI_SUCCESS);1139 sizeof(HITLS_X509_ExtCrlNumber)), HITLS_PKI_SUCCESS);
1111 }1140 }
1141+ ASSERT_TRUE(TestIsErrStackEmpty());
1112 return HITLS_PKI_SUCCESS;1142 return HITLS_PKI_SUCCESS;
1113EXIT:1143EXIT:
1114 return -1;1144 return -1;
@@ -1165,6 +1195,7 @@ void SDV_X509_CRL_Sign_Func_TC001(char *cert, char *key, int keytype, int pad, i
1165 }1195 }
1166 1196 
1167 ASSERT_EQ(HITLS_X509_CrlVerify(issuerCert->tbs.ealPubKey, parseCrl), HITLS_PKI_SUCCESS);1197 ASSERT_EQ(HITLS_X509_CrlVerify(issuerCert->tbs.ealPubKey, parseCrl), HITLS_PKI_SUCCESS);
1198+ ASSERT_TRUE(TestIsErrStackEmpty());
1168EXIT:1199EXIT:
1169 HITLS_X509_CrlFree(crl);1200 HITLS_X509_CrlFree(crl);
1170 HITLS_X509_CrlFree(parseCrl);1201 HITLS_X509_CrlFree(parseCrl);
@@ -1539,6 +1570,7 @@ void SDV_X509_CRL_GENCONSISTANT_FUNC_TC001(char *cert, char *key, int keyType, i
1539 BSL_Buffer parseData = {(uint8_t *)parseCrl, sizeof(HITLS_X509_Crl *)};1570 BSL_Buffer parseData = {(uint8_t *)parseCrl, sizeof(HITLS_X509_Crl *)};
1540 Hex expect = {(uint8_t *)printCrlFile, 0};1571 Hex expect = {(uint8_t *)printCrlFile, 0};
1541 ASSERT_EQ(PrintTest(HITLS_PKI_PRINT_CRL, &parseData, "Print parse crl file", &expect, printParseCrlFile), 0);1572 ASSERT_EQ(PrintTest(HITLS_PKI_PRINT_CRL, &parseData, "Print parse crl file", &expect, printParseCrlFile), 0);
1573+ ASSERT_TRUE(TestIsErrStackEmpty());
1542 1574 
1543EXIT:1575EXIT:
1544 HITLS_X509_CrlFree(crl);1576 HITLS_X509_CrlFree(crl);
@@ -1588,6 +1620,7 @@ void SDV_X509_CRL_GEN_SETVER0NOEXT_FUNC_TC001(char *cert, char *key, char *crlFi
1588 ASSERT_EQ(HITLS_X509_CrlVerify(issuerCert->tbs.ealPubKey, parseCrl), HITLS_PKI_SUCCESS);1620 ASSERT_EQ(HITLS_X509_CrlVerify(issuerCert->tbs.ealPubKey, parseCrl), HITLS_PKI_SUCCESS);
1589 ASSERT_EQ(crl->tbs.version, parseCrl->tbs.version);1621 ASSERT_EQ(crl->tbs.version, parseCrl->tbs.version);
1590 ASSERT_EQ(parseCrl->tbs.version, version);1622 ASSERT_EQ(parseCrl->tbs.version, version);
1623+ ASSERT_TRUE(TestIsErrStackEmpty());
1591 1624 
1592EXIT:1625EXIT:
1593 HITLS_X509_CrlFree(crl);1626 HITLS_X509_CrlFree(crl);
@@ -1698,6 +1731,7 @@ void SDV_X509_CRL_GEN_ERRBSLTIME_FUNC_TC001(char *cert, char *key, char *crlFile
1698 HITLS_X509_RevokeExtTime invalidTimeExt1 = {false, errorTime};1731 HITLS_X509_RevokeExtTime invalidTimeExt1 = {false, errorTime};
1699 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_SET_REVOKED_INVALID_TIME,1732 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_SET_REVOKED_INVALID_TIME,
1700 &invalidTimeExt1, sizeof(HITLS_X509_RevokeExtTime)), BSL_ASN1_ERR_CHECK_TIME);1733 &invalidTimeExt1, sizeof(HITLS_X509_RevokeExtTime)), BSL_ASN1_ERR_CHECK_TIME);
1734+ TestErrClear();
1701 1735 
1702 BSL_TIME testTime1 = {2025, 1, 1, 0, 0, 999, 59, 999};1736 BSL_TIME testTime1 = {2025, 1, 1, 0, 0, 999, 59, 999};
1703 BSL_TIME nextUpdateTime1 = {2025, 1, 2, 0, 0, 999, 59, 999};1737 BSL_TIME nextUpdateTime1 = {2025, 1, 2, 0, 0, 999, 59, 999};
@@ -1736,6 +1770,7 @@ void SDV_X509_CRL_GEN_ERRBSLTIME_FUNC_TC001(char *cert, char *key, char *crlFile
1736 ASSERT_EQ(CompareBslTime(parseCrl->tbs.validTime.end, nextUpdateTime2, true), 0);1770 ASSERT_EQ(CompareBslTime(parseCrl->tbs.validTime.end, nextUpdateTime2, true), 0);
1737 ASSERT_EQ(CompareBslTime(parseEntry->time, testTime2, true), 0);1771 ASSERT_EQ(CompareBslTime(parseEntry->time, testTime2, true), 0);
1738 ASSERT_EQ(CompareBslTime(parseTime, testTime2, true), 0);1772 ASSERT_EQ(CompareBslTime(parseTime, testTime2, true), 0);
1773+ ASSERT_TRUE(TestIsErrStackEmpty());
1739 1774 
1740EXIT:1775EXIT:
1741 HITLS_X509_CrlFree(crl);1776 HITLS_X509_CrlFree(crl);
@@ -1786,6 +1821,7 @@ void SDV_X509_CRL_GEN_NULLREVOKED_FUNC_TC001(char *cert, int timeNull)
1786 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_SET_REVOKED_REVOKE_TIME, &revokeTime, sizeof(BSL_TIME)),1821 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_SET_REVOKED_REVOKE_TIME, &revokeTime, sizeof(BSL_TIME)),
1787 HITLS_PKI_SUCCESS);1822 HITLS_PKI_SUCCESS);
1788 }1823 }
1824+ ASSERT_TRUE(TestIsErrStackEmpty());
1789 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_CRL_ADD_REVOKED_CERT, entry, sizeof(HITLS_X509_CrlEntry)),1825 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_CRL_ADD_REVOKED_CERT, entry, sizeof(HITLS_X509_CrlEntry)),
1790 HITLS_X509_ERR_CRL_ENTRY);1826 HITLS_X509_ERR_CRL_ENTRY);
1791 1827 
@@ -1990,6 +2026,7 @@ void SDV_X509_CRL_ENCODE_STUB_TC001(char *cert, char *key, int keytype, int pad,
1990 } else {2026 } else {
1991 ASSERT_EQ(HITLS_X509_CrlSign(mdId, prvKey, NULL, crl), HITLS_PKI_SUCCESS);2027 ASSERT_EQ(HITLS_X509_CrlSign(mdId, prvKey, NULL, crl), HITLS_PKI_SUCCESS);
1992 }2028 }
2029+ ASSERT_TRUE(TestIsErrStackEmpty());
1993 test = maxTriggers;2030 test = maxTriggers;
1994 marked = 0;2031 marked = 0;
1995 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc_Crl);2032 STUB_REPLACE(BSL_SAL_Malloc, STUB_BSL_SAL_Malloc_Crl);
Mtestcode/sdv/testcase/pki/crl/test_suite_sdv_x509_crl_rfc5280.c+17-0
@@ -49,6 +49,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC001(char *path, char *pathChangeCid, int cid
49 crl = NULL;49 crl = NULL;
50 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_PEM, pathChangeCid, &crl), HITLS_PKI_SUCCESS);50 ASSERT_EQ(HITLS_X509_CrlParseFile(BSL_FORMAT_PEM, pathChangeCid, &crl), HITLS_PKI_SUCCESS);
51 ASSERT_NE(crl->signAlgId.algId, crl->tbs.signAlgId.algId);51 ASSERT_NE(crl->signAlgId.algId, crl->tbs.signAlgId.algId);
52+ ASSERT_TRUE(TestIsErrStackEmpty());
52EXIT:53EXIT:
53 HITLS_X509_CrlFree(crl);54 HITLS_X509_CrlFree(crl);
54}55}
@@ -73,6 +74,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC002(char *pathv1, char *pathv2)
73 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_VERSION, &version, sizeof(uint32_t)), HITLS_PKI_SUCCESS);74 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_VERSION, &version, sizeof(uint32_t)), HITLS_PKI_SUCCESS);
74 // The CRL version should be 0 (v1) or 1 (v2), 5 is invalid version.75 // The CRL version should be 0 (v1) or 1 (v2), 5 is invalid version.
75 ASSERT_TRUE(version == 5);76 ASSERT_TRUE(version == 5);
77+ ASSERT_TRUE(TestIsErrStackEmpty());
76EXIT:78EXIT:
77 HITLS_X509_CrlFree(crl);79 HITLS_X509_CrlFree(crl);
78}80}
@@ -107,6 +109,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC004(char *path, int res, Hex *dn)
107 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_ISSUER_DN_STR, &issuerDN, sizeof(BSL_Buffer)),109 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_ISSUER_DN_STR, &issuerDN, sizeof(BSL_Buffer)),
108 HITLS_PKI_SUCCESS);110 HITLS_PKI_SUCCESS);
109 ASSERT_COMPARE("crl dn name", issuerDN.data, issuerDN.dataLen, dn->x, dn->len);111 ASSERT_COMPARE("crl dn name", issuerDN.data, issuerDN.dataLen, dn->x, dn->len);
112+ ASSERT_TRUE(TestIsErrStackEmpty());
110 }113 }
111 114 
112EXIT:115EXIT:
@@ -130,6 +133,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC005(char *path, int beforeYear, int afterYea
130 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);133 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);
131 ASSERT_EQ(beforeTime.year, beforeYear);134 ASSERT_EQ(beforeTime.year, beforeYear);
132 ASSERT_EQ(afterTime.year, afterYear);135 ASSERT_EQ(afterTime.year, afterYear);
136+ ASSERT_TRUE(TestIsErrStackEmpty());
133EXIT:137EXIT:
134 HITLS_X509_CrlFree(crl);138 HITLS_X509_CrlFree(crl);
135}139}
@@ -165,6 +169,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC007(char *path, int res)
165 HITLS_PKI_SUCCESS);169 HITLS_PKI_SUCCESS);
166 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);170 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_GET_AFTER_TIME, &afterTime, sizeof(BSL_TIME)), HITLS_PKI_SUCCESS);
167 ASSERT_TRUE(beforeTime.year > afterTime.year);171 ASSERT_TRUE(beforeTime.year > afterTime.year);
172+ ASSERT_TRUE(TestIsErrStackEmpty());
168 }173 }
169 174 
170EXIT:175EXIT:
@@ -187,6 +192,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC008(char *path, int res)
187 HITLS_PKI_SUCCESS);192 HITLS_PKI_SUCCESS);
188 ASSERT_TRUE(revokeList != NULL);193 ASSERT_TRUE(revokeList != NULL);
189 ASSERT_EQ(BSL_LIST_COUNT(revokeList), 0);194 ASSERT_EQ(BSL_LIST_COUNT(revokeList), 0);
195+ ASSERT_TRUE(TestIsErrStackEmpty());
190 }196 }
191EXIT:197EXIT:
192 HITLS_X509_CrlFree(crl);198 HITLS_X509_CrlFree(crl);
@@ -207,6 +213,9 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC009(char *path, int critical, Hex *crlNumber
207 ASSERT_EQ(crlNumExt.critical, critical);213 ASSERT_EQ(crlNumExt.critical, critical);
208 ASSERT_EQ(crlNumExt.crlNumber.dataLen, crlNumber->len);214 ASSERT_EQ(crlNumExt.crlNumber.dataLen, crlNumber->len);
209 ASSERT_EQ(memcmp(crlNumber->x, crlNumExt.crlNumber.data, crlNumber->len), 0);215 ASSERT_EQ(memcmp(crlNumber->x, crlNumExt.crlNumber.data, crlNumber->len), 0);
216+ if (res == HITLS_PKI_SUCCESS) {
217+ ASSERT_TRUE(TestIsErrStackEmpty());
218+ }
210EXIT:219EXIT:
211 HITLS_X509_CrlFree(crl);220 HITLS_X509_CrlFree(crl);
212}221}
@@ -224,6 +233,7 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC010(char *path, int critical)
224 HITLS_X509_ExtAki getaki = {0};233 HITLS_X509_ExtAki getaki = {0};
225 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_GET_AKI, &getaki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);234 ASSERT_EQ(HITLS_X509_CrlCtrl(crl, HITLS_X509_EXT_GET_AKI, &getaki, sizeof(HITLS_X509_ExtAki)), HITLS_PKI_SUCCESS);
226 ASSERT_EQ(getaki.critical, critical);235 ASSERT_EQ(getaki.critical, critical);
236+ ASSERT_TRUE(TestIsErrStackEmpty());
227 237 
228EXIT:238EXIT:
229 HITLS_X509_CrlFree(crl);239 HITLS_X509_CrlFree(crl);
@@ -282,6 +292,9 @@ void SDV_X509_CRL_PARSE_FILE_FUNC_TC013(char *path, int res1, int res2)
282 HITLS_X509_CrlEntry *entry = BSL_LIST_GET_FIRST(crl->tbs.revokedCerts);292 HITLS_X509_CrlEntry *entry = BSL_LIST_GET_FIRST(crl->tbs.revokedCerts);
283 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_GET_REVOKED_CERTISSUER, &certIssuer,293 ASSERT_EQ(HITLS_X509_CrlEntryCtrl(entry, HITLS_X509_CRL_GET_REVOKED_CERTISSUER, &certIssuer,
284 sizeof(certIssuer)), res2);294 sizeof(certIssuer)), res2);
295+ if (res2 == HITLS_PKI_SUCCESS) {
296+ ASSERT_TRUE(TestIsErrStackEmpty());
297+ }
285 }298 }
286EXIT:299EXIT:
287 HITLS_X509_CrlFree(crl);300 HITLS_X509_CrlFree(crl);
@@ -375,6 +388,7 @@ void SDV_X509_CRL_FILE_VERIFY_FUNC_TC002(char *rootCaPath, char *caPath, char *r
375 ret = BSL_LIST_AddElement(storeCtx->crl, rootCrl, BSL_LIST_POS_END);388 ret = BSL_LIST_AddElement(storeCtx->crl, rootCrl, BSL_LIST_POS_END);
376 ASSERT_EQ(ret, BSL_SUCCESS);389 ASSERT_EQ(ret, BSL_SUCCESS);
377 }390 }
391+ ASSERT_TRUE(TestIsErrStackEmpty());
378 392 
379 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);393 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);
380 ASSERT_EQ(ret, crlVerResult);394 ASSERT_EQ(ret, crlVerResult);
@@ -435,6 +449,7 @@ void SDV_X509_CRL_FILE_VERIFY_FUNC_TC003(char *caPath, char *crlPath, char *cert
435 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);449 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
436 ret = BSL_LIST_AddElement(storeCtx->crl, rootCrl, BSL_LIST_POS_END);450 ret = BSL_LIST_AddElement(storeCtx->crl, rootCrl, BSL_LIST_POS_END);
437 ASSERT_EQ(ret, BSL_SUCCESS);451 ASSERT_EQ(ret, BSL_SUCCESS);
452+ ASSERT_TRUE(TestIsErrStackEmpty());
438 453 
439 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);454 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);
440 ASSERT_EQ(ret, crlVerResult);455 ASSERT_EQ(ret, crlVerResult);
@@ -490,6 +505,7 @@ void SDV_X509_CRL_FILE_VERIFY_FUNC_TC004(char *caPath, char *crlPath, char *cert
490 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(storeCtx, HITLS_X509_STORECTX_SET_VFY_SM2_USERID,505 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(storeCtx, HITLS_X509_STORECTX_SET_VFY_SM2_USERID,
491 (void *)sm2UserId, sm2UserIdLen), HITLS_PKI_SUCCESS);506 (void *)sm2UserId, sm2UserIdLen), HITLS_PKI_SUCCESS);
492 }507 }
508+ ASSERT_TRUE(TestIsErrStackEmpty());
493 509 
494 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);510 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);
495 ASSERT_EQ(ret, crlVerResult);511 ASSERT_EQ(ret, crlVerResult);
@@ -557,6 +573,7 @@ void SDV_X509_CRL_FILE_VERIFY_FUNC_TC005(char *rootCaPath, char *caPath, char *r
557 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(storeCtx, HITLS_X509_STORECTX_SET_VFY_SM2_USERID,573 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(storeCtx, HITLS_X509_STORECTX_SET_VFY_SM2_USERID,
558 (void *)sm2UserId, sm2UserIdLen), HITLS_PKI_SUCCESS);574 (void *)sm2UserId, sm2UserIdLen), HITLS_PKI_SUCCESS);
559 }575 }
576+ ASSERT_TRUE(TestIsErrStackEmpty());
560 577 
561 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);578 ret = HITLS_X509_VerifyCrl(storeCtx, storeCtx->store);
562 ASSERT_EQ(ret, crlVerResult);579 ASSERT_EQ(ret, crlVerResult);
Mtestcode/sdv/testcase/pki/csr/test_suite_sdv_x509_csr.c+15-0
@@ -141,6 +141,7 @@ void SDV_X509_CSR_Free_FUNC_TC001(void)
141 HITLS_X509_Csr *csr = HITLS_X509_CsrNew();141 HITLS_X509_Csr *csr = HITLS_X509_CsrNew();
142 ASSERT_NE(csr, NULL);142 ASSERT_NE(csr, NULL);
143 HITLS_X509_CsrFree(csr);143 HITLS_X509_CsrFree(csr);
144+ ASSERT_TRUE(TestIsErrStackEmpty());
144 145 
145 HITLS_X509_CsrFree(NULL);146 HITLS_X509_CsrFree(NULL);
146 147 
@@ -237,6 +238,7 @@ void SDV_X509_CSR_PARSE_FUNC_TC001(int format, char *path, int expRawDataLen, in
237 ASSERT_EQ(csr->signature.len, expectedSign->len);238 ASSERT_EQ(csr->signature.len, expectedSign->len);
238 ASSERT_EQ(memcmp(csr->signature.buff, expectedSign->x, expectedSign->len), 0);239 ASSERT_EQ(memcmp(csr->signature.buff, expectedSign->x, expectedSign->len), 0);
239 ASSERT_EQ(csr->signature.unusedBits, expectUnusedbits);240 ASSERT_EQ(csr->signature.unusedBits, expectUnusedbits);
241+ ASSERT_TRUE(TestIsErrStackEmpty());
240 242 
241EXIT:243EXIT:
242 HITLS_X509_CsrFree(csr);244 HITLS_X509_CsrFree(csr);
@@ -278,6 +280,7 @@ void SDV_X509_CSR_PARSE_FUNC_TC002(int format, char *path, int expectedNum, char
278 ASSERT_EQ(strcmp(dnTypes[i / 2], oidName), 0);280 ASSERT_EQ(strcmp(dnTypes[i / 2], oidName), 0);
279 ASSERT_EQ(memcmp(dnName[i / 2], nameValue.buff, strlen(dnName[i / 2])), 0);281 ASSERT_EQ(memcmp(dnName[i / 2], nameValue.buff, strlen(dnName[i / 2])), 0);
280 }282 }
283+ ASSERT_TRUE(TestIsErrStackEmpty());
281 284 
282EXIT:285EXIT:
283 HITLS_X509_CsrFree(csr);286 HITLS_X509_CsrFree(csr);
@@ -310,6 +313,7 @@ void SDV_X509_CSR_PARSE_FUNC_TC003(int format, char *path, int attrNum, int attr
310 ASSERT_NE(oid, NULL);313 ASSERT_NE(oid, NULL);
311 ASSERT_COMPARE("csr attr oid", entry->attrId.buff, entry->attrId.len, (uint8_t *)oid->octs, oid->octetLen);314 ASSERT_COMPARE("csr attr oid", entry->attrId.buff, entry->attrId.len, (uint8_t *)oid->octs, oid->octetLen);
312 ASSERT_COMPARE("csr attr value", entry->attrValue.buff, entry->attrValue.len, attrValue->x, attrValue->len);315 ASSERT_COMPARE("csr attr value", entry->attrValue.buff, entry->attrValue.len, attrValue->x, attrValue->len);
316+ ASSERT_TRUE(TestIsErrStackEmpty());
313 317 
314EXIT:318EXIT:
315 HITLS_X509_CsrFree(csr);319 HITLS_X509_CsrFree(csr);
@@ -419,6 +423,7 @@ void SDV_X509_CSR_GEN_FUNC_TC001(int inFormat, char *csrPath, int outFormat)
419 ASSERT_EQ(csr->rawDataLen, encode.dataLen);423 ASSERT_EQ(csr->rawDataLen, encode.dataLen);
420 ASSERT_EQ(memcmp(encode.data, csr->rawData, encode.dataLen), 0);424 ASSERT_EQ(memcmp(encode.data, csr->rawData, encode.dataLen), 0);
421 }425 }
426+ ASSERT_TRUE(TestIsErrStackEmpty());
422EXIT:427EXIT:
423 BSL_SAL_FREE(data);428 BSL_SAL_FREE(data);
424 BSL_SAL_FREE(encode.data);429 BSL_SAL_FREE(encode.data);
@@ -548,6 +553,7 @@ void SDV_X509_CSR_GEN_FUNC_TC002(int csrFormat, char *csrPath, int keyFormat, ch
548 ASSERT_EQ(newCsrEncodeLen, rawCsrEncodeLen);553 ASSERT_EQ(newCsrEncodeLen, rawCsrEncodeLen);
549 ASSERT_EQ(memcmp(newCsrEncode, rawCsrEncode, rawCsrEncodeLen), 0);554 ASSERT_EQ(memcmp(newCsrEncode, rawCsrEncode, rawCsrEncodeLen), 0);
550 }555 }
556+ ASSERT_TRUE(TestIsErrStackEmpty());
551EXIT:557EXIT:
552 HITLS_X509_CsrFree(parsed);558 HITLS_X509_CsrFree(parsed);
553 HITLS_X509_CsrFree(raw);559 HITLS_X509_CsrFree(raw);
@@ -736,6 +742,7 @@ void SDV_X509_CSR_CTRL_SET_API_TC002(char *csrPath)
736 SetRsaPara(&rsaPara, e, sizeof(e), 2048); // 2048 is rsa key bits742 SetRsaPara(&rsaPara, e, sizeof(e), 2048); // 2048 is rsa key bits
737 ASSERT_EQ(CRYPT_EAL_PkeySetPara(rsaPkey, &rsaPara), CRYPT_SUCCESS);743 ASSERT_EQ(CRYPT_EAL_PkeySetPara(rsaPkey, &rsaPara), CRYPT_SUCCESS);
738 ASSERT_EQ(CRYPT_EAL_PkeyGen(rsaPkey), CRYPT_SUCCESS);744 ASSERT_EQ(CRYPT_EAL_PkeyGen(rsaPkey), CRYPT_SUCCESS);
745+ ASSERT_TRUE(TestIsErrStackEmpty());
739 ASSERT_NE(HITLS_X509_CsrCtrl(csr, HITLS_X509_SET_PUBKEY, NULL, 0), HITLS_PKI_SUCCESS);746 ASSERT_NE(HITLS_X509_CsrCtrl(csr, HITLS_X509_SET_PUBKEY, NULL, 0), HITLS_PKI_SUCCESS);
740 ASSERT_NE(HITLS_X509_CsrCtrl(NULL, HITLS_X509_SET_PUBKEY, rsaPkey, 0), HITLS_PKI_SUCCESS);747 ASSERT_NE(HITLS_X509_CsrCtrl(NULL, HITLS_X509_SET_PUBKEY, rsaPkey, 0), HITLS_PKI_SUCCESS);
741 748 
@@ -789,6 +796,7 @@ void SDV_X509_CSR_CTRL_FUNC_TC001(char *csrPath)
789 796 
790 ASSERT_EQ(HITLS_X509_CsrCtrl(newCsr, HITLS_X509_GET_ENCODELEN, &csrEncodeLen, sizeof(csrEncodeLen)),797 ASSERT_EQ(HITLS_X509_CsrCtrl(newCsr, HITLS_X509_GET_ENCODELEN, &csrEncodeLen, sizeof(csrEncodeLen)),
791 HITLS_PKI_SUCCESS);798 HITLS_PKI_SUCCESS);
799+ ASSERT_TRUE(TestIsErrStackEmpty());
792 800 
793EXIT:801EXIT:
794 BSL_SAL_FREE(encodeRaw.data);802 BSL_SAL_FREE(encodeRaw.data);
@@ -877,6 +885,7 @@ void SDV_X509_CSR_EncodeAttrList_FUNC_TC001(int critical1, int maxPath, int crit
877 // Test: Encode and check885 // Test: Encode and check
878 ASSERT_EQ(HITLS_X509_EncodeAttrList(1, attrs, NULL, &encode), 0);886 ASSERT_EQ(HITLS_X509_EncodeAttrList(1, attrs, NULL, &encode), 0);
879 ASSERT_COMPARE("Encode attrs", expect->x, expect->len, encode.buff, encode.len);887 ASSERT_COMPARE("Encode attrs", expect->x, expect->len, encode.buff, encode.len);
888+ ASSERT_TRUE(TestIsErrStackEmpty());
880 889 
881EXIT:890EXIT:
882 HITLS_X509_CsrFree(csr);891 HITLS_X509_CsrFree(csr);
@@ -995,6 +1004,7 @@ void SDV_X509_CSR_AddSubjectName_FUNC_TC001(int keyFormat, int keyType, char *pr
995 ASSERT_EQ(SetNewCsrInfo(new, privKey, dnType1, dnName1, dnType2, dnName2, dnType3, dnName3), 0);1004 ASSERT_EQ(SetNewCsrInfo(new, privKey, dnType1, dnName1, dnType2, dnName2, dnType3, dnName3), 0);
996 ASSERT_EQ(HITLS_X509_CsrSign(mdId, privKey, NULL, new), HITLS_PKI_SUCCESS);1005 ASSERT_EQ(HITLS_X509_CsrSign(mdId, privKey, NULL, new), HITLS_PKI_SUCCESS);
997 ASSERT_EQ(HITLS_X509_CsrGenBuff(BSL_FORMAT_PEM, new, &encode), HITLS_PKI_SUCCESS);1006 ASSERT_EQ(HITLS_X509_CsrGenBuff(BSL_FORMAT_PEM, new, &encode), HITLS_PKI_SUCCESS);
1007+ ASSERT_TRUE(TestIsErrStackEmpty());
998 ASSERT_EQ(new->reqInfo.reqInfoRawDataLen, expectedReqInfo->len);1008 ASSERT_EQ(new->reqInfo.reqInfoRawDataLen, expectedReqInfo->len);
999 ASSERT_EQ(memcmp(new->reqInfo.reqInfoRawData, expectedReqInfo->x, expectedReqInfo->len), 0);1009 ASSERT_EQ(memcmp(new->reqInfo.reqInfoRawData, expectedReqInfo->x, expectedReqInfo->len), 0);
1000 1010 
@@ -1157,6 +1167,7 @@ void SDV_X509_CSR_PARSE_ATTR_EXTS_TC001(int format, char *path, int expectIsCa,
1157 1167 
1158 /* ExtendedKeyUsage */1168 /* ExtendedKeyUsage */
1159 ASSERT_EQ(CertAssertEkuFlags(cert, expectEkuServerAuth, expectEkuClientAuth), HITLS_PKI_SUCCESS);1169 ASSERT_EQ(CertAssertEkuFlags(cert, expectEkuServerAuth, expectEkuClientAuth), HITLS_PKI_SUCCESS);
1170+ ASSERT_TRUE(TestIsErrStackEmpty());
1160 1171 
1161EXIT:1172EXIT:
1162 HITLS_X509_ExtFree(csrExt);1173 HITLS_X509_ExtFree(csrExt);
@@ -1272,6 +1283,7 @@ void SDV_X509_CSR_EncodeAttrList_SetSAN_FUNC_TC001(char *keyPath, int critical,
1272 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, parsed, 0), HITLS_PKI_SUCCESS);1283 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, parsed, 0), HITLS_PKI_SUCCESS);
1273 ASSERT_EQ(CertAssertSanEquals(cert, dns1, dns2, email1, uri1), HITLS_PKI_SUCCESS);1284 ASSERT_EQ(CertAssertSanEquals(cert, dns1, dns2, email1, uri1), HITLS_PKI_SUCCESS);
1274 HITLS_X509_CertFree(cert);1285 HITLS_X509_CertFree(cert);
1286+ ASSERT_TRUE(TestIsErrStackEmpty());
1275 1287 
1276EXIT:1288EXIT:
1277 HITLS_X509_ExtFree(ext);1289 HITLS_X509_ExtFree(ext);
@@ -1326,6 +1338,7 @@ void SDV_X509_CSR_EncodeAttrList_SetEKU_FUNC_TC001(char *keyPath, int critical,
1326 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, parsed, 0), HITLS_PKI_SUCCESS);1338 ASSERT_EQ(HITLS_X509_CertCtrl(cert, HITLS_X509_SET_CSR_EXT, parsed, 0), HITLS_PKI_SUCCESS);
1327 ASSERT_EQ(CertAssertEkuFlags(cert, withServerAuth ? 1 : 0, withClientAuth ? 1 : 0), HITLS_PKI_SUCCESS);1339 ASSERT_EQ(CertAssertEkuFlags(cert, withServerAuth ? 1 : 0, withClientAuth ? 1 : 0), HITLS_PKI_SUCCESS);
1328 HITLS_X509_CertFree(cert);1340 HITLS_X509_CertFree(cert);
1341+ ASSERT_TRUE(TestIsErrStackEmpty());
1329 1342 
1330EXIT:1343EXIT:
1331 HITLS_X509_ExtFree(ext);1344 HITLS_X509_ExtFree(ext);
@@ -1362,6 +1375,7 @@ void SDV_X509_CSR_EncodeAttrList_SetSKI_FUNC_TC001(char *keyPath, int critical,
1362 ASSERT_EQ(ski2.kid.dataLen, kid->len);1375 ASSERT_EQ(ski2.kid.dataLen, kid->len);
1363 ASSERT_COMPARE("SKI.csr", ski2.kid.data, ski2.kid.dataLen, kid->x, kid->len);1376 ASSERT_COMPARE("SKI.csr", ski2.kid.data, ski2.kid.dataLen, kid->x, kid->len);
1364 HITLS_X509_ExtFree(csrExt2);1377 HITLS_X509_ExtFree(csrExt2);
1378+ ASSERT_TRUE(TestIsErrStackEmpty());
1365 1379 
1366EXIT:1380EXIT:
1367 HITLS_X509_ExtFree(ext);1381 HITLS_X509_ExtFree(ext);
@@ -1399,6 +1413,7 @@ void SDV_X509_CSR_EncodeAttrList_SetAKI_FUNC_TC001(char *keyPath, int critical,
1399 ASSERT_COMPARE("AKI.csr.kid", aki2.kid.data, aki2.kid.dataLen, kid->x, kid->len);1413 ASSERT_COMPARE("AKI.csr.kid", aki2.kid.data, aki2.kid.dataLen, kid->x, kid->len);
1400 }1414 }
1401 HITLS_X509_ExtFree(csrExt2);1415 HITLS_X509_ExtFree(csrExt2);
1416+ ASSERT_TRUE(TestIsErrStackEmpty());
1402 1417 
1403EXIT:1418EXIT:
1404 HITLS_X509_ExtFree(ext);1419 HITLS_X509_ExtFree(ext);
Mtestcode/sdv/testcase/pki/pkcs12/test_suite_sdv_pkcs12.c+30-0
@@ -85,6 +85,7 @@ void SDV_PKCS12_PARSE_SAFEBAGS_OF_PKCS8SHROUDEDKEYBAG_TC001(int algId, Hex *buff
85 } else if (algId == CRYPT_PKEY_RSA) {85 } else if (algId == CRYPT_PKEY_RSA) {
86 ASSERT_EQ(bits, keyBits);86 ASSERT_EQ(bits, keyBits);
87 }87 }
88+ ASSERT_TRUE(TestIsErrStackEmpty());
88EXIT:89EXIT:
89 BSL_SAL_Free(safeContent.data);90 BSL_SAL_Free(safeContent.data);
90 BSL_LIST_DeleteAll(bagLists, (BSL_LIST_PFUNC_FREE)HITLS_PKCS12_SafeBagFree);91 BSL_LIST_DeleteAll(bagLists, (BSL_LIST_PFUNC_FREE)HITLS_PKCS12_SafeBagFree);
@@ -127,6 +128,7 @@ void SDV_PKCS12_PARSE_SAFEBAGS_OF_CERTBAGS_TC001(Hex *buff)
127 // get cert of the bagList.128 // get cert of the bagList.
128 ret = HITLS_PKCS12_ParseSafeBagList(bagLists, NULL, 0, p12);129 ret = HITLS_PKCS12_ParseSafeBagList(bagLists, NULL, 0, p12);
129 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);130 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
131+ ASSERT_TRUE(TestIsErrStackEmpty());
130 132 
131EXIT:133EXIT:
132 BSL_SAL_Free(safeContent.data);134 BSL_SAL_Free(safeContent.data);
@@ -189,6 +191,7 @@ void SDV_PKCS12_PARSE_SAFEBAGS_OF_ATTRIBUTE_TC001(Hex *buff, Hex *friendlyName,
189 ASSERT_EQ(memcmp(second->attrValue.data, localKeyId->x, localKeyId->len), 0);191 ASSERT_EQ(memcmp(second->attrValue.data, localKeyId->x, localKeyId->len), 0);
190 }192 }
191 }193 }
194+ ASSERT_TRUE(TestIsErrStackEmpty());
192EXIT:195EXIT:
193 HITLS_X509_AttrsFree(attrbutes, HITLS_PKCS12_AttributesFree);196 HITLS_X509_AttrsFree(attrbutes, HITLS_PKCS12_AttributesFree);
194#endif197#endif
@@ -218,6 +221,7 @@ void SDV_PKCS12_PARSE_SAFEBAGS_OF_ATTRIBUTE_TC002(Hex *buff)
218 asn.len = buff->len;221 asn.len = buff->len;
219 ret = HITLS_PKCS12_ParseSafeBagAttr(&asn, attrbutes);222 ret = HITLS_PKCS12_ParseSafeBagAttr(&asn, attrbutes);
220 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);223 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
224+ ASSERT_TRUE(TestIsErrStackEmpty());
221 225 
222 buff->x[4] = 0x00; // 4 is a random number.226 buff->x[4] = 0x00; // 4 is a random number.
223 ret = HITLS_PKCS12_ParseSafeBagAttr(&asn, attrbutes);227 ret = HITLS_PKCS12_ParseSafeBagAttr(&asn, attrbutes);
@@ -280,6 +284,7 @@ void SDV_PKCS12_PARSE_AUTHSAFE_TC002(Hex *buff)
280 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);284 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
281 ASSERT_NE(p12->key->value.key, NULL);285 ASSERT_NE(p12->key->value.key, NULL);
282 ASSERT_NE(p12->entityCert->value.cert, NULL);286 ASSERT_NE(p12->entityCert->value.cert, NULL);
287+ ASSERT_TRUE(TestIsErrStackEmpty());
283EXIT:288EXIT:
284 HITLS_PKCS12_Free(p12);289 HITLS_PKCS12_Free(p12);
285#endif290#endif
@@ -307,6 +312,7 @@ void SDV_PKCS12_PARSE_MACDATA_TC001(Hex *buff, int alg, Hex *digest, Hex *salt,
307 ASSERT_EQ(macData->iteration, iterations);312 ASSERT_EQ(macData->iteration, iterations);
308 ASSERT_EQ(memcmp(macData->macSalt->data, salt->x, salt->len), 0);313 ASSERT_EQ(memcmp(macData->macSalt->data, salt->x, salt->len), 0);
309 ASSERT_EQ(memcmp(macData->mac->data, digest->x, digest->len), 0);314 ASSERT_EQ(memcmp(macData->mac->data, digest->x, digest->len), 0);
315+ ASSERT_TRUE(TestIsErrStackEmpty());
310EXIT:316EXIT:
311 HITLS_PKCS12_MacDataFree(macData);317 HITLS_PKCS12_MacDataFree(macData);
312#endif318#endif
@@ -357,6 +363,7 @@ void SDV_PKCS12_CAL_MACDATA_TC001(Hex *initData, Hex *salt, int alg, int iter, H
357 int32_t ret = HITLS_PKCS12_CalMac(p12, &pwd, (BSL_Buffer *)initData, &output);363 int32_t ret = HITLS_PKCS12_CalMac(p12, &pwd, (BSL_Buffer *)initData, &output);
358 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);364 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
359 ASSERT_EQ(memcmp(output.data, mac->x, mac->len), 0);365 ASSERT_EQ(memcmp(output.data, mac->x, mac->len), 0);
366+ ASSERT_TRUE(TestIsErrStackEmpty());
360EXIT:367EXIT:
361 BSL_SAL_Free(output.data);368 BSL_SAL_Free(output.data);
362 HITLS_PKCS12_Free(p12);369 HITLS_PKCS12_Free(p12);
@@ -383,6 +390,7 @@ void SDV_PKCS12_CAL_KDF_TC001(Hex *pwd, Hex *salt, int alg, int iter, Hex *key)
383 int32_t ret = HITLS_PKCS12_KDF(p12, pwd->x, pwd->len, HITLS_PKCS12_KDF_MACKEY_ID, &output);390 int32_t ret = HITLS_PKCS12_KDF(p12, pwd->x, pwd->len, HITLS_PKCS12_KDF_MACKEY_ID, &output);
384 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);391 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
385 ASSERT_EQ(memcmp(output.data, key->x, key->len), 0);392 ASSERT_EQ(memcmp(output.data, key->x, key->len), 0);
393+ ASSERT_TRUE(TestIsErrStackEmpty());
386EXIT:394EXIT:
387 HITLS_PKCS12_Free(p12);395 HITLS_PKCS12_Free(p12);
388 return;396 return;
@@ -419,6 +427,7 @@ void SDV_PKCS12_PARSE_P12_TC001(Hex *encode, Hex *cert)
419 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_ASN1, p12->entityCert->value.cert, &encodeCert), HITLS_PKI_SUCCESS);427 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_ASN1, p12->entityCert->value.cert, &encodeCert), HITLS_PKI_SUCCESS);
420 ASSERT_EQ(memcmp(encodeCert.data, cert->x, cert->len), 0);428 ASSERT_EQ(memcmp(encodeCert.data, cert->x, cert->len), 0);
421#endif429#endif
430+ ASSERT_TRUE(TestIsErrStackEmpty());
422EXIT:431EXIT:
423 BSL_SAL_Free(encodeCert.data);432 BSL_SAL_Free(encodeCert.data);
424 HITLS_PKCS12_Free(p12);433 HITLS_PKCS12_Free(p12);
@@ -449,6 +458,7 @@ void SDV_PKCS12_PARSE_P12_TC002(Hex *encode, Hex *cert)
449 };458 };
450 TestMemInit();459 TestMemInit();
451 ASSERT_NE(HITLS_PKCS12_ParseBuff(BSL_FORMAT_ASN1, (BSL_Buffer *)encode, &param, &p12, true), HITLS_PKI_SUCCESS);460 ASSERT_NE(HITLS_PKCS12_ParseBuff(BSL_FORMAT_ASN1, (BSL_Buffer *)encode, &param, &p12, true), HITLS_PKI_SUCCESS);
461+ TestErrClear();
452 ASSERT_EQ(HITLS_PKCS12_ParseBuff(BSL_FORMAT_ASN1, (BSL_Buffer *)encode, &param, &p12, false), HITLS_PKI_SUCCESS);462 ASSERT_EQ(HITLS_PKCS12_ParseBuff(BSL_FORMAT_ASN1, (BSL_Buffer *)encode, &param, &p12, false), HITLS_PKI_SUCCESS);
453 ASSERT_NE(p12->key->value.key, NULL);463 ASSERT_NE(p12->key->value.key, NULL);
454 ASSERT_NE(p12->entityCert->value.cert, NULL);464 ASSERT_NE(p12->entityCert->value.cert, NULL);
@@ -456,6 +466,7 @@ void SDV_PKCS12_PARSE_P12_TC002(Hex *encode, Hex *cert)
456 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_ASN1, p12->entityCert->value.cert, &encodeCert), HITLS_PKI_SUCCESS);466 ASSERT_EQ(HITLS_X509_CertGenBuff(BSL_FORMAT_ASN1, p12->entityCert->value.cert, &encodeCert), HITLS_PKI_SUCCESS);
457 ASSERT_EQ(memcmp(encodeCert.data, cert->x, cert->len), 0);467 ASSERT_EQ(memcmp(encodeCert.data, cert->x, cert->len), 0);
458#endif468#endif
469+ ASSERT_TRUE(TestIsErrStackEmpty());
459EXIT:470EXIT:
460 BSL_SAL_Free(encodeCert.data);471 BSL_SAL_Free(encodeCert.data);
461 HITLS_PKCS12_Free(p12);472 HITLS_PKCS12_Free(p12);
@@ -488,6 +499,7 @@ void SDV_PKCS12_PARSE_P12_TC003(char *path, char *pwd)
488 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);499 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
489 ASSERT_NE(p12->key->value.key, NULL);500 ASSERT_NE(p12->key->value.key, NULL);
490 ASSERT_NE(p12->entityCert->value.cert, NULL);501 ASSERT_NE(p12->entityCert->value.cert, NULL);
502+ ASSERT_TRUE(TestIsErrStackEmpty());
491EXIT:503EXIT:
492 HITLS_PKCS12_Free(p12);504 HITLS_PKCS12_Free(p12);
493#endif505#endif
@@ -713,6 +725,7 @@ void SDV_PKCS12_ENCODE_SAFEBAGS_OF_PKCS8SHROUDEDKEYBAG_TC001(Hex *buff)
713 ASSERT_EQ(encode.dataLen, buff->len);725 ASSERT_EQ(encode.dataLen, buff->len);
714 ret = memcmp(encode.data + encode.dataLen - 37, buff->x + buff->len - 37, 37);726 ret = memcmp(encode.data + encode.dataLen - 37, buff->x + buff->len - 37, 37);
715 ASSERT_EQ(ret, 0);727 ASSERT_EQ(ret, 0);
728+ ASSERT_TRUE(TestIsErrStackEmpty());
716 729 
717EXIT:730EXIT:
718 BSL_SAL_Free(encode.data);731 BSL_SAL_Free(encode.data);
@@ -777,6 +790,7 @@ void SDV_PKCS12_ENCODE_SAFEBAGS_OF_CERTBAGS_TC001(Hex *buff)
777 ASSERT_EQ(output.dataLen, buff->len);790 ASSERT_EQ(output.dataLen, buff->len);
778 ret = memcmp(output.data, buff->x, 69);791 ret = memcmp(output.data, buff->x, 69);
779 ASSERT_EQ(ret, 0);792 ASSERT_EQ(ret, 0);
793+ ASSERT_TRUE(TestIsErrStackEmpty());
780 794 
781EXIT:795EXIT:
782 BSL_SAL_Free(safeContent.data);796 BSL_SAL_Free(safeContent.data);
@@ -873,6 +887,7 @@ void SDV_PKCS12_ENCODE_AUTHSAFE_TC001(Hex *buff)
873 887 
874 ret = HITLS_PKCS12_EncodeAsn1List(p12, list, BSL_CID_PKCS7_CONTENTINFO, &paramEx, &encode5);888 ret = HITLS_PKCS12_EncodeAsn1List(p12, list, BSL_CID_PKCS7_CONTENTINFO, &paramEx, &encode5);
875 ASSERT_EQ(encode5.dataLen, buff->len);889 ASSERT_EQ(encode5.dataLen, buff->len);
890+ ASSERT_TRUE(TestIsErrStackEmpty());
876 891 
877EXIT:892EXIT:
878 BSL_SAL_Free(encode1->data);893 BSL_SAL_Free(encode1->data);
@@ -927,6 +942,7 @@ void SDV_PKCS12_ENCODE_MACDATA_TC001(Hex *buff, Hex *initData, Hex *expectData)
927 942 
928 HITLS_PKCS12_MacParam macParam = {.para = &hmacParam, .algId = BSL_CID_PKCS12KDF};943 HITLS_PKCS12_MacParam macParam = {.para = &hmacParam, .algId = BSL_CID_PKCS12KDF};
929 ASSERT_EQ(HITLS_PKCS12_EncodeMacData(p12, (BSL_Buffer *)initData, &macParam, &output), HITLS_PKI_SUCCESS);944 ASSERT_EQ(HITLS_PKCS12_EncodeMacData(p12, (BSL_Buffer *)initData, &macParam, &output), HITLS_PKI_SUCCESS);
945+ ASSERT_TRUE(TestIsErrStackEmpty());
930 ASSERT_EQ(memcmp(output.data, expectData->x, expectData->len), 0);946 ASSERT_EQ(memcmp(output.data, expectData->x, expectData->len), 0);
931 p12_1 = HITLS_PKCS12_New();947 p12_1 = HITLS_PKCS12_New();
932 ASSERT_NE(p12_1, NULL);948 ASSERT_NE(p12_1, NULL);
@@ -1032,6 +1048,7 @@ void SDV_PKCS12_ENCODE_P12_TC001(Hex *buff, Hex *cert)
1032 BSL_SAL_Free(encodeCert3.data);1048 BSL_SAL_Free(encodeCert3.data);
1033 BSL_SAL_Free(encodeCert4.data);1049 BSL_SAL_Free(encodeCert4.data);
1034 }1050 }
1051+ ASSERT_TRUE(TestIsErrStackEmpty());
1035EXIT:1052EXIT:
1036 BSL_SAL_Free(output.data);1053 BSL_SAL_Free(output.data);
1037 BSL_SAL_Free(encodeCert1.data);1054 BSL_SAL_Free(encodeCert1.data);
@@ -1202,6 +1219,7 @@ void SDV_PKCS12_ENCODE_P12_TC003(Hex *buff)
1202 1219 
1203 ret = HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, &p12_1, &encodeParam, true, NULL);1220 ret = HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, &p12_1, &encodeParam, true, NULL);
1204 ASSERT_EQ(ret, HITLS_PKCS12_ERR_NULL_POINTER);1221 ASSERT_EQ(ret, HITLS_PKCS12_ERR_NULL_POINTER);
1222+ TestErrClear();
1205 1223 
1206 (void)memcpy(&p12_1, p12, sizeof(HITLS_PKCS12));1224 (void)memcpy(&p12_1, p12, sizeof(HITLS_PKCS12));
1207 CRYPT_EAL_PkeyCtx *temKey = p12_1.key->value.key;1225 CRYPT_EAL_PkeyCtx *temKey = p12_1.key->value.key;
@@ -1236,6 +1254,7 @@ void SDV_PKCS12_ENCODE_P12_TC003(Hex *buff)
1236 BSL_LIST_DeleteAll(p12_1.certList, (BSL_LIST_PFUNC_FREE)HITLS_PKCS12_BagFree); // test p12-encode of key attribute = NULL.1254 BSL_LIST_DeleteAll(p12_1.certList, (BSL_LIST_PFUNC_FREE)HITLS_PKCS12_BagFree); // test p12-encode of key attribute = NULL.
1237 ret = HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, &p12_1, &encodeParam, true, &output6);1255 ret = HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, &p12_1, &encodeParam, true, &output6);
1238 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1256 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1257+ ASSERT_TRUE(TestIsErrStackEmpty());
1239EXIT:1258EXIT:
1240 BSL_SAL_Free(output1.data);1259 BSL_SAL_Free(output1.data);
1241 BSL_SAL_Free(output2.data);1260 BSL_SAL_Free(output2.data);
@@ -1280,6 +1299,7 @@ void SDV_PKCS12_ENCODE_P12_TC004(char *pkeyPath, char *certPath)
1280 ASSERT_EQ(HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_SET_ENTITY_KEYBAG, keyBag, 0), HITLS_PKI_SUCCESS);1299 ASSERT_EQ(HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_SET_ENTITY_KEYBAG, keyBag, 0), HITLS_PKI_SUCCESS);
1281 1300 
1282 ASSERT_EQ(HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_SET_ENTITY_CERTBAG, certBag, 0), HITLS_PKI_SUCCESS);1301 ASSERT_EQ(HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_SET_ENTITY_CERTBAG, certBag, 0), HITLS_PKI_SUCCESS);
1302+ ASSERT_TRUE(TestIsErrStackEmpty());
1283 1303 
1284 HITLS_PKCS12_EncodeParam encodeParam = {0};1304 HITLS_PKCS12_EncodeParam encodeParam = {0};
1285 1305 
@@ -1464,6 +1484,7 @@ void SDV_PKCS12_CTRL_TEST_TC001(char *pkeyPath, char *enCertPath, char *caCertPa
1464 1484 
1465 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, sizeof(CRYPT_MD_AlgId));1485 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, sizeof(CRYPT_MD_AlgId));
1466 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1486 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1487+ ASSERT_TRUE(TestIsErrStackEmpty());
1467 1488 
1468 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, 0);1489 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, 0);
1469 ASSERT_EQ(ret, HITLS_PKCS12_ERR_INVALID_PARAM);1490 ASSERT_EQ(ret, HITLS_PKCS12_ERR_INVALID_PARAM);
@@ -1471,6 +1492,7 @@ void SDV_PKCS12_CTRL_TEST_TC001(char *pkeyPath, char *enCertPath, char *caCertPa
1471 mdId = BSL_CID_MD4 - 1;1492 mdId = BSL_CID_MD4 - 1;
1472 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, sizeof(CRYPT_MD_AlgId));1493 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_GEN_LOCALKEYID, &mdId, sizeof(CRYPT_MD_AlgId));
1473 ASSERT_EQ(ret, HITLS_PKCS12_ERR_INVALID_PARAM);1494 ASSERT_EQ(ret, HITLS_PKCS12_ERR_INVALID_PARAM);
1495+ TestErrClear();
1474 1496 
1475 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_ADD_CERTBAG, caBag, 0);1497 ret = HITLS_PKCS12_Ctrl(p12, HITLS_PKCS12_ADD_CERTBAG, caBag, 0);
1476 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1498 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
@@ -1492,6 +1514,7 @@ void SDV_PKCS12_CTRL_TEST_TC001(char *pkeyPath, char *enCertPath, char *caCertPa
1492 ASSERT_EQ(tmpCert, p12->entityCert->value.cert);1514 ASSERT_EQ(tmpCert, p12->entityCert->value.cert);
1493 ASSERT_EQ(HITLS_PKCS12_BagCtrl(pkeyBagTmp, HITLS_PKCS12_BAG_GET_VALUE, &tmpKey, 0), HITLS_PKI_SUCCESS);1515 ASSERT_EQ(HITLS_PKCS12_BagCtrl(pkeyBagTmp, HITLS_PKCS12_BAG_GET_VALUE, &tmpKey, 0), HITLS_PKI_SUCCESS);
1494 ASSERT_EQ(tmpKey, p12->key->value.key);1516 ASSERT_EQ(tmpKey, p12->key->value.key);
1517+ ASSERT_TRUE(TestIsErrStackEmpty());
1495EXIT:1518EXIT:
1496 HITLS_X509_CertFree(targetCert);1519 HITLS_X509_CertFree(targetCert);
1497 CRYPT_EAL_PkeyFreeCtx(targetKey);1520 CRYPT_EAL_PkeyFreeCtx(targetKey);
@@ -1865,6 +1888,7 @@ void SDV_PKCS12_GEN_FROM_DATA_TC001(char *pkeyPath, char *enCertPath, char *ca1C
1865 1888 
1866 ASSERT_EQ(BSL_LIST_COUNT(p12_1->certList), 2);1889 ASSERT_EQ(BSL_LIST_COUNT(p12_1->certList), 2);
1867#endif1890#endif
1891+ ASSERT_TRUE(TestIsErrStackEmpty());
1868EXIT:1892EXIT:
1869 HITLS_X509_CertFree(targetCert);1893 HITLS_X509_CertFree(targetCert);
1870 CRYPT_EAL_PkeyFreeCtx(targetKey);1894 CRYPT_EAL_PkeyFreeCtx(targetKey);
@@ -1962,6 +1986,7 @@ void SDV_PKCS12_GEN_SECRET_BAG_TC001(char *pkeyPath, char *certPath)
1962 // with mac1986 // with mac
1963 ASSERT_EQ(HITLS_PKCS12_GenFile(BSL_FORMAT_ASN1, p12, &encodeParam, true, writePath), HITLS_PKI_SUCCESS);1987 ASSERT_EQ(HITLS_PKCS12_GenFile(BSL_FORMAT_ASN1, p12, &encodeParam, true, writePath), HITLS_PKI_SUCCESS);
1964 ASSERT_EQ(HITLS_PKCS12_ParseFile(BSL_FORMAT_ASN1, writePath, &pwdParam, &p12_1, true), HITLS_PKI_SUCCESS);1988 ASSERT_EQ(HITLS_PKCS12_ParseFile(BSL_FORMAT_ASN1, writePath, &pwdParam, &p12_1, true), HITLS_PKI_SUCCESS);
1989+ ASSERT_TRUE(TestIsErrStackEmpty());
1965EXIT:1990EXIT:
1966 HITLS_X509_CertFree(enCert);1991 HITLS_X509_CertFree(enCert);
1967 CRYPT_EAL_PkeyFreeCtx(pkey);1992 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -2071,6 +2096,7 @@ void SDV_PKCS12_BAG_CTRL_TC001(void)
2071 outBuf.dataLen = 30; // init len is 30.2096 outBuf.dataLen = 30; // init len is 30.
2072 ASSERT_EQ(HITLS_PKCS12_BagCtrl(tmpBag, HITLS_PKCS12_BAG_GET_VALUE, &outBuf, sizeof(BSL_Buffer)), 0);2097 ASSERT_EQ(HITLS_PKCS12_BagCtrl(tmpBag, HITLS_PKCS12_BAG_GET_VALUE, &outBuf, sizeof(BSL_Buffer)), 0);
2073 ASSERT_COMPARE("compare secret2", outBuf.data, outBuf.dataLen, secretData2, secretDataLen2);2098 ASSERT_COMPARE("compare secret2", outBuf.data, outBuf.dataLen, secretData2, secretDataLen2);
2099+ ASSERT_TRUE(TestIsErrStackEmpty());
2074EXIT:2100EXIT:
2075 HITLS_PKCS12_BagFree(secretBag1);2101 HITLS_PKCS12_BagFree(secretBag1);
2076 HITLS_PKCS12_BagFree(secretBag2);2102 HITLS_PKCS12_BagFree(secretBag2);
@@ -2123,7 +2149,9 @@ void SDV_PKCS12_BAG_CTRL_TC002(char *pkeyPath, char *certPath)
2123 ASSERT_EQ(id, BSL_CID_CERTBAG);2149 ASSERT_EQ(id, BSL_CID_CERTBAG);
2124 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_TYPE, &type, sizeof(uint32_t)), 0);2150 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_TYPE, &type, sizeof(uint32_t)), 0);
2125 ASSERT_EQ(type, BSL_CID_X509CERTIFICATE);2151 ASSERT_EQ(type, BSL_CID_X509CERTIFICATE);
2152+ ASSERT_TRUE(TestIsErrStackEmpty());
2126 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_VALUE, NULL, 0), HITLS_PKCS12_ERR_NULL_POINTER);2153 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_VALUE, NULL, 0), HITLS_PKCS12_ERR_NULL_POINTER);
2154+ TestErrClear();
2127 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_VALUE, &tmpCert, 0), 0);2155 ASSERT_EQ(HITLS_PKCS12_BagCtrl(certBag, HITLS_PKCS12_BAG_GET_VALUE, &tmpCert, 0), 0);
2128 ASSERT_NE(tmpCert, NULL);2156 ASSERT_NE(tmpCert, NULL);
2129 2157 
@@ -2133,6 +2161,7 @@ void SDV_PKCS12_BAG_CTRL_TC002(char *pkeyPath, char *certPath)
2133 ASSERT_EQ(type, 0);2161 ASSERT_EQ(type, 0);
2134 ASSERT_EQ(HITLS_PKCS12_BagCtrl(keyBag, HITLS_PKCS12_BAG_GET_VALUE, &tmpKey, 0), 0);2162 ASSERT_EQ(HITLS_PKCS12_BagCtrl(keyBag, HITLS_PKCS12_BAG_GET_VALUE, &tmpKey, 0), 0);
2135 ASSERT_NE(tmpKey, NULL);2163 ASSERT_NE(tmpKey, NULL);
2164+ ASSERT_TRUE(TestIsErrStackEmpty());
2136EXIT:2165EXIT:
2137 HITLS_X509_CertFree(enCert);2166 HITLS_X509_CertFree(enCert);
2138 CRYPT_EAL_PkeyFreeCtx(pkey);2167 CRYPT_EAL_PkeyFreeCtx(pkey);
@@ -2212,6 +2241,7 @@ void SDV_PKCS12_BAG_CUSTOM_OID_TC001(void)
2212 ASSERT_EQ(id, BSL_CID_SECRETBAG);2241 ASSERT_EQ(id, BSL_CID_SECRETBAG);
2213 ASSERT_EQ(HITLS_PKCS12_BagCtrl(tmpBag, HITLS_PKCS12_BAG_GET_TYPE, &type, sizeof(uint32_t)), 0);2242 ASSERT_EQ(HITLS_PKCS12_BagCtrl(tmpBag, HITLS_PKCS12_BAG_GET_TYPE, &type, sizeof(uint32_t)), 0);
2214 ASSERT_EQ(type, ourCid);2243 ASSERT_EQ(type, ourCid);
2244+ ASSERT_TRUE(TestIsErrStackEmpty());
2215EXIT:2245EXIT:
2216 HITLS_PKCS12_BagFree(secretBag);2246 HITLS_PKCS12_BagFree(secretBag);
2217 HITLS_PKCS12_Free(p12);2247 HITLS_PKCS12_Free(p12);
Mtestcode/sdv/testcase/pki/pkcs12/test_suite_sdv_pkcs12_util.c+6-0
@@ -266,6 +266,7 @@ void SDV_PKCS12_GEN_KEYBAGS_TC001(char *pkeyPath, char *enCertPath, char *ca1Cer
266 ASSERT_NE(p12_1->entityCert, NULL);266 ASSERT_NE(p12_1->entityCert, NULL);
267 ASSERT_NE(p12_1->key, NULL);267 ASSERT_NE(p12_1->key, NULL);
268#endif268#endif
269+ ASSERT_TRUE(TestIsErrStackEmpty());
269EXIT:270EXIT:
270 CRYPT_EAL_PkeyFreeCtx(pkey);271 CRYPT_EAL_PkeyFreeCtx(pkey);
271 HITLS_X509_CertFree(enCert);272 HITLS_X509_CertFree(enCert);
@@ -331,12 +332,14 @@ void SDV_PKCS12_CTRL_GET_KEYBAGS_TC001(void)
331 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ID, &id, sizeof(int32_t)), 0);332 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ID, &id, sizeof(int32_t)), 0);
332 ASSERT_EQ(id, BSL_CID_KEYBAG);333 ASSERT_EQ(id, BSL_CID_KEYBAG);
333 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ATTR, &buffer, BSL_CID_FRIENDLYNAME), 0);334 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ATTR, &buffer, BSL_CID_FRIENDLYNAME), 0);
335+ ASSERT_TRUE(TestIsErrStackEmpty());
334 ASSERT_COMPARE("compare key bag attr", buffer.data, buffer.dataLen, attrName, strlen(attrName));336 ASSERT_COMPARE("compare key bag attr", buffer.data, buffer.dataLen, attrName, strlen(attrName));
335 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ATTR, &buffer, BSL_CID_LOCALKEYID),337 ASSERT_EQ(HITLS_PKCS12_BagCtrl(bag, HITLS_PKCS12_BAG_GET_ATTR, &buffer, BSL_CID_LOCALKEYID),
336 HITLS_PKCS12_ERR_NO_SAFEBAG_ATTRIBUTES);338 HITLS_PKCS12_ERR_NO_SAFEBAG_ATTRIBUTES);
337 bag = BSL_LIST_GET_NEXT(keyList);339 bag = BSL_LIST_GET_NEXT(keyList);
338 CRYPT_EAL_PkeyFreeCtx(key);340 CRYPT_EAL_PkeyFreeCtx(key);
339 key = NULL;341 key = NULL;
342+ TestErrClear();
340 }343 }
341#endif344#endif
342EXIT:345EXIT:
@@ -368,6 +371,7 @@ void SDV_PKCS12_PARSE_MULBAG_TC001(Hex *mulBag, int hasMac)
368 ASSERT_NE(BSL_LIST_COUNT(p12->keyList), 0);371 ASSERT_NE(BSL_LIST_COUNT(p12->keyList), 0);
369 ASSERT_NE(BSL_LIST_COUNT(p12->secretBags), 0);372 ASSERT_NE(BSL_LIST_COUNT(p12->secretBags), 0);
370 ASSERT_NE(p12->key, NULL);373 ASSERT_NE(p12->key, NULL);
374+ ASSERT_TRUE(TestIsErrStackEmpty());
371EXIT:375EXIT:
372 HITLS_PKCS12_Free(p12);376 HITLS_PKCS12_Free(p12);
373#endif377#endif
@@ -586,6 +590,7 @@ void SDV_PKCS12_ENCODE_STUB_TC001(Hex *mulBag, int hasMac)
586 STUB_EnableMallocFail(false);590 STUB_EnableMallocFail(false);
587 STUB_ResetMallocCount();591 STUB_ResetMallocCount();
588 ASSERT_EQ(HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, p12, &encodeParam, true, &output), HITLS_PKI_SUCCESS);592 ASSERT_EQ(HITLS_PKCS12_GenBuff(BSL_FORMAT_ASN1, p12, &encodeParam, true, &output), HITLS_PKI_SUCCESS);
593+ ASSERT_TRUE(TestIsErrStackEmpty());
589 totalMallocCount = STUB_GetMallocCallCount();594 totalMallocCount = STUB_GetMallocCallCount();
590 BSL_SAL_Free(output.data);595 BSL_SAL_Free(output.data);
591 output.data = NULL;596 output.data = NULL;
@@ -710,6 +715,7 @@ void SDV_PKCS12_CERTCHAIN_BUILD_TC001(void)
710 // Build certificate chain using the end certificate715 // Build certificate chain using the end certificate
711 ASSERT_EQ(HITLS_X509_CertChainBuild(storeCtx, true, cert3, &chain), HITLS_PKI_SUCCESS);716 ASSERT_EQ(HITLS_X509_CertChainBuild(storeCtx, true, cert3, &chain), HITLS_PKI_SUCCESS);
712 ASSERT_EQ(HITLS_X509_CertVerify(storeCtx, chain), HITLS_PKI_SUCCESS);717 ASSERT_EQ(HITLS_X509_CertVerify(storeCtx, chain), HITLS_PKI_SUCCESS);
718+ ASSERT_TRUE(TestIsErrStackEmpty());
713 719 
714EXIT:720EXIT:
715 HITLS_X509_CertFree(caCert);721 HITLS_X509_CertFree(caCert);
Mtestcode/sdv/testcase/pki/verify/test_suite_sdv_x509_vfy.c+90-2
@@ -197,6 +197,9 @@ void SDV_X509_STORE_VFY_PARAM_EXR_FUNC_TC001(char *path1, char *path2, char *pat
197 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);197 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
198 ret = HITLS_X509_VerifyParamAndExt(storeCtx, chain);198 ret = HITLS_X509_VerifyParamAndExt(storeCtx, chain);
199 ASSERT_EQ(ret, exp);199 ASSERT_EQ(ret, exp);
200+ if (exp == HITLS_PKI_SUCCESS) {
201+ ASSERT_TRUE(TestIsErrStackEmpty());
202+ }
200EXIT:203EXIT:
201 HITLS_X509_FreeStoreCtxMock(storeCtx);204 HITLS_X509_FreeStoreCtxMock(storeCtx);
202 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);205 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -227,6 +230,9 @@ void SDV_X509_STORE_VFY_CRL_FUNC_TC001(int type, int expResult, char *path1, cha
227 230 
228 ret = HITLS_X509_VerifyCrl(storeCtx, chain);231 ret = HITLS_X509_VerifyCrl(storeCtx, chain);
229 ASSERT_EQ(ret, expResult);232 ASSERT_EQ(ret, expResult);
233+ if (ret == HITLS_PKI_SUCCESS) {
234+ ASSERT_TRUE(TestIsErrStackEmpty());
235+ }
230EXIT:236EXIT:
231 HITLS_X509_FreeStoreCtxMock(storeCtx);237 HITLS_X509_FreeStoreCtxMock(storeCtx);
232 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);238 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -261,6 +267,7 @@ void SDV_X509_STORE_CTRL_FUNC_TC001(void)
261 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);267 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
262 ASSERT_EQ(ref, 2);268 ASSERT_EQ(ref, 2);
263 HITLS_X509_StoreCtxFree(store);269 HITLS_X509_StoreCtxFree(store);
270+ ASSERT_TRUE(TestIsErrStackEmpty());
264 271 
265EXIT:272EXIT:
266 HITLS_X509_StoreCtxFree(store);273 HITLS_X509_StoreCtxFree(store);
@@ -363,6 +370,7 @@ void SDV_X509_STORE_CTRL_NEW_FIELDS_FUNC_TC003(void)
363 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_CUR_DEPTH, &getDepthVal, sizeof(int32_t)),370 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_CUR_DEPTH, &getDepthVal, sizeof(int32_t)),
364 HITLS_PKI_SUCCESS);371 HITLS_PKI_SUCCESS);
365 ASSERT_EQ(getDepthVal, depthVal);372 ASSERT_EQ(getDepthVal, depthVal);
373+ ASSERT_TRUE(TestIsErrStackEmpty());
366 374 
367 /* Test invalid parameters */375 /* Test invalid parameters */
368 ASSERT_NE(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_ERROR, &errorVal, sizeof(int32_t) - 1),376 ASSERT_NE(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_ERROR, &errorVal, sizeof(int32_t) - 1),
@@ -447,6 +455,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC001(char *rootPath, char *caPath, char *ce
447 }455 }
448 456 
449 ASSERT_TRUE(HITLS_AddCertToStoreTest(cert, store, &entity) != HITLS_PKI_SUCCESS);457 ASSERT_TRUE(HITLS_AddCertToStoreTest(cert, store, &entity) != HITLS_PKI_SUCCESS);
458+ TestErrClear();
450 ASSERT_EQ(HITLS_AddCrlToStoreTest(crlPath, store, &crl), HITLS_PKI_SUCCESS);459 ASSERT_EQ(HITLS_AddCrlToStoreTest(crlPath, store, &crl), HITLS_PKI_SUCCESS);
451 460 
452 ASSERT_EQ(BSL_LIST_COUNT(store->crl), 1);461 ASSERT_EQ(BSL_LIST_COUNT(store->crl), 1);
@@ -464,6 +473,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC001(char *rootPath, char *caPath, char *ce
464 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)), 0);473 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)), 0);
465 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_CLR_PARAM_FLAGS, &flag, sizeof(flag)), 0);474 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_CLR_PARAM_FLAGS, &flag, sizeof(flag)), 0);
466 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);475 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);
476+ ASSERT_TRUE(TestIsErrStackEmpty());
467 477 
468EXIT:478EXIT:
469 HITLS_X509_StoreCtxFree(store);479 HITLS_X509_StoreCtxFree(store);
@@ -486,6 +496,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC002(void)
486 HITLS_X509_Cert *entity = NULL;496 HITLS_X509_Cert *entity = NULL;
487 ret = HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-pss-v3/end.der", store, &entity);497 ret = HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-pss-v3/end.der", store, &entity);
488 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);498 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
499+ TestErrClear();
489 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);500 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);
490 HITLS_X509_List *chain = NULL;501 HITLS_X509_List *chain = NULL;
491 ret = HITLS_X509_CertChainBuild(store, false, entity, &chain);502 ret = HITLS_X509_CertChainBuild(store, false, entity, &chain);
@@ -503,6 +514,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC002(void)
503 514 
504 ret = HITLS_X509_CertVerify(store, chain);515 ret = HITLS_X509_CertVerify(store, chain);
505 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);516 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
517+ ASSERT_TRUE(TestIsErrStackEmpty());
506 518 
507EXIT:519EXIT:
508 HITLS_X509_StoreCtxFree(store);520 HITLS_X509_StoreCtxFree(store);
@@ -547,6 +559,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC003(void)
547 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);559 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
548 ret = X509_AddCertToChainTest(chain, ca);560 ret = X509_AddCertToChainTest(chain, ca);
549 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);561 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
562+ ASSERT_TRUE(TestIsErrStackEmpty());
550 563 
551 ret = HITLS_X509_CertVerify(store, chain);564 ret = HITLS_X509_CertVerify(store, chain);
552 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);565 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
@@ -576,6 +589,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC004(void)
576 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);589 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
577 ret = HITLS_X509_CertVerify(store, chain);590 ret = HITLS_X509_CertVerify(store, chain);
578 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);591 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
592+ ASSERT_TRUE(TestIsErrStackEmpty());
579EXIT:593EXIT:
580 HITLS_X509_StoreCtxFree(store);594 HITLS_X509_StoreCtxFree(store);
581 HITLS_X509_CertFree(root);595 HITLS_X509_CertFree(root);
@@ -598,6 +612,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC005(void)
598 ASSERT_TRUE(chain != NULL);612 ASSERT_TRUE(chain != NULL);
599 ASSERT_EQ(BSL_LIST_COUNT(chain), 1);613 ASSERT_EQ(BSL_LIST_COUNT(chain), 1);
600 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);614 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
615+ ASSERT_TRUE(TestIsErrStackEmpty());
601 ret = HITLS_X509_CertVerify(store, chain);616 ret = HITLS_X509_CertVerify(store, chain);
602 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);617 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
603EXIT:618EXIT:
@@ -624,6 +639,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC006(void)
624 int64_t timeval = 5555;639 int64_t timeval = 5555;
625 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));640 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));
626 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);641 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
642+ ASSERT_TRUE(TestIsErrStackEmpty());
627 ret = HITLS_X509_CertVerify(store, chain);643 ret = HITLS_X509_CertVerify(store, chain);
628 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);644 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
629EXIT:645EXIT:
@@ -647,6 +663,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC007(void)
647 HITLS_X509_Cert *entity = NULL;663 HITLS_X509_Cert *entity = NULL;
648 ret = HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-v3/cert.der", store, &entity);664 ret = HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-v3/cert.der", store, &entity);
649 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);665 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
666+ TestErrClear();
650 ASSERT_EQ(BSL_LIST_COUNT(store->store), 2);667 ASSERT_EQ(BSL_LIST_COUNT(store->store), 2);
651 int32_t depth = 2;668 int32_t depth = 2;
652 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_PARAM_DEPTH, &depth, sizeof(depth));669 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_PARAM_DEPTH, &depth, sizeof(depth));
@@ -662,6 +679,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC007(void)
662 int64_t timeval = time(NULL);679 int64_t timeval = time(NULL);
663 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));680 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));
664 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);681 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
682+ ASSERT_TRUE(TestIsErrStackEmpty());
665 683 
666 ret = HITLS_X509_CertVerify(store, chain);684 ret = HITLS_X509_CertVerify(store, chain);
667 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);685 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
@@ -751,6 +769,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC008(char *rootPath, char *caPath, char *ce
751 HITLS_X509_Cert *entity = NULL;769 HITLS_X509_Cert *entity = NULL;
752 ret = HITLS_AddCertToStoreTest(cert, store, &entity);770 ret = HITLS_AddCertToStoreTest(cert, store, &entity);
753 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);771 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
772+ TestErrClear();
754 ASSERT_EQ(BSL_LIST_COUNT(store->store), 2);773 ASSERT_EQ(BSL_LIST_COUNT(store->store), 2);
755 HITLS_X509_Crl *rootcrl = NULL;774 HITLS_X509_Crl *rootcrl = NULL;
756 if (strlen(rootcrlpath) != 0) {775 if (strlen(rootcrlpath) != 0) {
@@ -786,6 +805,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC008(char *rootPath, char *caPath, char *ce
786 int64_t timeval = time(NULL);805 int64_t timeval = time(NULL);
787 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));806 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval));
788 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);807 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
808+ ASSERT_TRUE(TestIsErrStackEmpty());
789 ret = HITLS_X509_CertVerify(store, chain);809 ret = HITLS_X509_CertVerify(store, chain);
790 ASSERT_TRUE(ret == except);810 ASSERT_TRUE(ret == except);
791 811 
@@ -808,6 +828,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC009(void)
808 HITLS_X509_List *chain = BSL_LIST_New(sizeof(HITLS_X509_Cert *));828 HITLS_X509_List *chain = BSL_LIST_New(sizeof(HITLS_X509_Cert *));
809 int32_t ret = HITLS_X509_CertVerify(store, chain);829 int32_t ret = HITLS_X509_CertVerify(store, chain);
810 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);830 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
831+ TestErrClear();
811 HITLS_X509_Cert *root = NULL;832 HITLS_X509_Cert *root = NULL;
812 ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, "../testdata/cert/chain/rsa-pss-v3/ca.der", &root);833 ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, "../testdata/cert/chain/rsa-pss-v3/ca.der", &root);
813 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);834 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
@@ -815,6 +836,7 @@ void SDV_X509_BUILD_CERT_CHAIN_FUNC_TC009(void)
815 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);836 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
816 ret = BSL_LIST_AddElementInt(chain, NULL, BSL_LIST_POS_BEGIN);837 ret = BSL_LIST_AddElementInt(chain, NULL, BSL_LIST_POS_BEGIN);
817 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);838 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
839+ ASSERT_TRUE(TestIsErrStackEmpty());
818 ret = HITLS_X509_CertVerify(store, chain);840 ret = HITLS_X509_CertVerify(store, chain);
819 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);841 ASSERT_TRUE(ret != HITLS_PKI_SUCCESS);
820EXIT:842EXIT:
@@ -881,6 +903,7 @@ void SDV_X509_SM2_CERT_USERID_FUNC_TC001(char *caCertPath, char *interCertPath,
881 }903 }
882 ASSERT_EQ(HITLS_X509_CertChainBuild(storeCtx, false, entityCert, &chain), 0);904 ASSERT_EQ(HITLS_X509_CertChainBuild(storeCtx, false, entityCert, &chain), 0);
883 ASSERT_EQ(HITLS_X509_CertVerify(storeCtx, chain), HITLS_PKI_SUCCESS);905 ASSERT_EQ(HITLS_X509_CertVerify(storeCtx, chain), HITLS_PKI_SUCCESS);
906+ ASSERT_TRUE(TestIsErrStackEmpty());
884EXIT:907EXIT:
885 HITLS_X509_StoreCtxFree(storeCtx);908 HITLS_X509_StoreCtxFree(storeCtx);
886 HITLS_X509_CertFree(entityCert);909 HITLS_X509_CertFree(entityCert);
@@ -950,6 +973,7 @@ void SDV_X509_STORE_LOAD_CA_PATH_CHAIN_BUILD_TC001(void)
950 // Verify the certificate chain973 // Verify the certificate chain
951 ret = HITLS_X509_CertVerify(storeCtx, chain);974 ret = HITLS_X509_CertVerify(storeCtx, chain);
952 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);975 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
976+ ASSERT_TRUE(TestIsErrStackEmpty());
953EXIT:977EXIT:
954 HITLS_X509_StoreCtxFree(storeCtx);978 HITLS_X509_StoreCtxFree(storeCtx);
955 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);979 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -975,6 +999,7 @@ void SDV_X509_STORE_LOAD_CA_PATH_CHAIN_BUILD_TC002(void)
975 const char *certToVerify = "../testdata/tls/certificate/pem/rsa_sha256/client.pem";999 const char *certToVerify = "../testdata/tls/certificate/pem/rsa_sha256/client.pem";
976 ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, certToVerify, &cert);1000 ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, certToVerify, &cert);
977 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1001 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1002+ ASSERT_TRUE(TestIsErrStackEmpty());
978 1003 
979 // Build certificate chain with on-demand CA loading from multiple paths1004 // Build certificate chain with on-demand CA loading from multiple paths
980 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);1005 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);
@@ -1009,6 +1034,7 @@ void SDV_X509_STORE_LOAD_CA_PATH_CHAIN_BUILD_TC003(void)
1009 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);1034 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);
1010 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1035 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1011 ASSERT_NE(chain, NULL);1036 ASSERT_NE(chain, NULL);
1037+ ASSERT_TRUE(TestIsErrStackEmpty());
1012EXIT:1038EXIT:
1013 HITLS_X509_CertFree(cert);1039 HITLS_X509_CertFree(cert);
1014 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1040 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -1040,6 +1066,7 @@ void SDV_X509_STORE_LOAD_CA_PATH_CHAIN_BUILD_TC004(void)
1040 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);1066 ret = HITLS_X509_CertChainBuild(storeCtx, true, cert, &chain);
1041 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1067 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1042 ASSERT_NE(chain, NULL);1068 ASSERT_NE(chain, NULL);
1069+ ASSERT_TRUE(TestIsErrStackEmpty());
1043EXIT:1070EXIT:
1044 HITLS_X509_CertFree(cert);1071 HITLS_X509_CertFree(cert);
1045 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1072 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -1093,6 +1120,7 @@ void SDV_X509_STORE_CTRL_GET_CERT_CHAIN_FUNC_TC018(void)
1093 // Test getting the certificate chain after verification (should be NULL as it's cleared after verification)1120 // Test getting the certificate chain after verification (should be NULL as it's cleared after verification)
1094 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_CERT_CHAIN, &certChain, sizeof(HITLS_X509_List *));1121 ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_CERT_CHAIN, &certChain, sizeof(HITLS_X509_List *));
1095 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);1122 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
1123+ ASSERT_TRUE(TestIsErrStackEmpty());
1096 ASSERT_EQ(certChain, NULL); // Chain is cleared after verification1124 ASSERT_EQ(certChain, NULL); // Chain is cleared after verification
1097 1125 
1098 // Test invalid parameters1126 // Test invalid parameters
@@ -1270,6 +1298,7 @@ void SDV_X509_BUILD_CERT_CHAIN_CBK_FUNC_TC001(int flag, int ecp)
1270 if (flag != HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND) {1298 if (flag != HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND) {
1271 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);1299 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);
1272 }1300 }
1301+ TestErrClear();
1273 HITLS_X509_List *chain = NULL;1302 HITLS_X509_List *chain = NULL;
1274 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entity, &chain), HITLS_PKI_SUCCESS);1303 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entity, &chain), HITLS_PKI_SUCCESS);
1275 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1304 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -1283,6 +1312,7 @@ void SDV_X509_BUILD_CERT_CHAIN_CBK_FUNC_TC001(int flag, int ecp)
1283 int64_t timeval = time(NULL);1312 int64_t timeval = time(NULL);
1284 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)),1313 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)),
1285 HITLS_PKI_SUCCESS);1314 HITLS_PKI_SUCCESS);
1315+ ASSERT_TRUE(TestIsErrStackEmpty());
1286 TestReplace(flag);1316 TestReplace(flag);
1287 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), ecp);1317 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), ecp);
1288 1318 
@@ -1338,6 +1368,7 @@ void SDV_X509_BUILD_CERT_CHAIN_CBK_FUNC_TC002(int flag, int ecp)
1338 if (flag != HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND) {1368 if (flag != HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND) {
1339 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);1369 ASSERT_EQ(BSL_LIST_COUNT(store->store), 1);
1340 }1370 }
1371+ TestErrClear();
1341 HITLS_X509_List *chain = NULL;1372 HITLS_X509_List *chain = NULL;
1342 HITLS_X509_Cert *root = NULL;1373 HITLS_X509_Cert *root = NULL;
1343 ASSERT_EQ(HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-pss-v3/ca.der", store, &root), HITLS_PKI_SUCCESS);1374 ASSERT_EQ(HITLS_AddCertToStoreTest("../testdata/cert/chain/rsa-pss-v3/ca.der", store, &root), HITLS_PKI_SUCCESS);
@@ -1349,6 +1380,7 @@ void SDV_X509_BUILD_CERT_CHAIN_CBK_FUNC_TC002(int flag, int ecp)
1349 int64_t timeval = time(NULL);1380 int64_t timeval = time(NULL);
1350 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)),1381 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &timeval, sizeof(timeval)),
1351 HITLS_PKI_SUCCESS);1382 HITLS_PKI_SUCCESS);
1383+ ASSERT_TRUE(TestIsErrStackEmpty());
1352 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), ecp);1384 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), ecp);
1353 1385 
1354EXIT:1386EXIT:
@@ -1383,6 +1415,7 @@ void SDV_X509_VERIFY_CERT_CHAIN_FUNC_TC001(void)
1383 ASSERT_TRUE(chain != NULL);1415 ASSERT_TRUE(chain != NULL);
1384 ASSERT_EQ(X509_AddCertToChainTest(chain, entity), HITLS_PKI_SUCCESS);1416 ASSERT_EQ(X509_AddCertToChainTest(chain, entity), HITLS_PKI_SUCCESS);
1385 ASSERT_EQ(X509_AddCertToChainTest(chain, ca), HITLS_PKI_SUCCESS);1417 ASSERT_EQ(X509_AddCertToChainTest(chain, ca), HITLS_PKI_SUCCESS);
1418+ ASSERT_TRUE(TestIsErrStackEmpty());
1386 HITLS_X509_CertExt *certExt = (HITLS_X509_CertExt *)ca->tbs.ext.extData;1419 HITLS_X509_CertExt *certExt = (HITLS_X509_CertExt *)ca->tbs.ext.extData;
1387 certExt->extFlags &= ~HITLS_X509_EXT_FLAG_BCONS;1420 certExt->extFlags &= ~HITLS_X509_EXT_FLAG_BCONS;
1388 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_X509_ERR_VFY_INVALID_CA);1421 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_X509_ERR_VFY_INVALID_CA);
@@ -1432,6 +1465,7 @@ void SDV_X509_BUILD_MLDSA_CERT_CHAIN_FUNC_TC001(void)
1432 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1465 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1433 1466 
1434 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityWithInvalidKu, &chain), HITLS_PKI_SUCCESS);1467 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityWithInvalidKu, &chain), HITLS_PKI_SUCCESS);
1468+ ASSERT_TRUE(TestIsErrStackEmpty());
1435 ASSERT_TRUE(HITLS_X509_CertVerify(store, chain) != HITLS_PKI_SUCCESS);1469 ASSERT_TRUE(HITLS_X509_CertVerify(store, chain) != HITLS_PKI_SUCCESS);
1436 1470 
1437EXIT:1471EXIT:
@@ -1498,6 +1532,7 @@ void SDV_X509_BUILD_SLHDSA_CERT_CHAIN_FUNC_TC001(char *variant)
1498 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_PEM, invalidKuPath, &entityInvalidKu), HITLS_PKI_SUCCESS);1532 ASSERT_EQ(HITLS_X509_CertParseFile(BSL_FORMAT_PEM, invalidKuPath, &entityInvalidKu), HITLS_PKI_SUCCESS);
1499 1533 
1500 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityInvalidKu, &chain), HITLS_PKI_SUCCESS);1534 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityInvalidKu, &chain), HITLS_PKI_SUCCESS);
1535+ ASSERT_TRUE(TestIsErrStackEmpty());
1501 // Verification should fail due to forbidden keyEncipherment1536 // Verification should fail due to forbidden keyEncipherment
1502 ASSERT_NE(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);1537 ASSERT_NE(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);
1503 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1538 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -1573,6 +1608,7 @@ void SDV_X509_BUILD_MLKEM_CERT_CHAIN_FUNC_TC001(void)
1573 // Step 6: Verify certificate chain (should succeed)1608 // Step 6: Verify certificate chain (should succeed)
1574 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);1609 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);
1575 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1610 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1611+ ASSERT_TRUE(TestIsErrStackEmpty());
1576 1612 
1577EXIT:1613EXIT:
1578 HITLS_X509_StoreCtxFree(store);1614 HITLS_X509_StoreCtxFree(store);
@@ -1623,10 +1659,12 @@ void SDV_X509_VFY_MLKEM_KEYUSAGE_TC001(void)
1623 HITLS_X509_CertParseFile(BSL_FORMAT_PEM, "../testdata/cert/chain/mlkem/end_invalid_ku.crt", &entityInvalidKu),1659 HITLS_X509_CertParseFile(BSL_FORMAT_PEM, "../testdata/cert/chain/mlkem/end_invalid_ku.crt", &entityInvalidKu),
1624 HITLS_PKI_SUCCESS);1660 HITLS_PKI_SUCCESS);
1625 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityInvalidKu, &chain), HITLS_PKI_SUCCESS);1661 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityInvalidKu, &chain), HITLS_PKI_SUCCESS);
1662+ ASSERT_TRUE(TestIsErrStackEmpty());
1626 // According to draft-ietf-lamps-kyber-certificates-11 Section 5:1663 // According to draft-ietf-lamps-kyber-certificates-11 Section 5:
1627 // ML-KEM certificates MUST have keyEncipherment as the ONLY key usage1664 // ML-KEM certificates MUST have keyEncipherment as the ONLY key usage
1628 // digitalSignature is forbidden, verification should fail1665 // digitalSignature is forbidden, verification should fail
1629 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_X509_ERR_EXT_KU);1666 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_X509_ERR_EXT_KU);
1667+ TestErrClear();
1630 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1668 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1631 chain = NULL;1669 chain = NULL;
1632 1670 
@@ -1638,6 +1676,7 @@ void SDV_X509_VFY_MLKEM_KEYUSAGE_TC001(void)
1638 HITLS_PKI_SUCCESS);1676 HITLS_PKI_SUCCESS);
1639 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityMissingKu, &chain), HITLS_PKI_SUCCESS);1677 ASSERT_EQ(HITLS_X509_CertChainBuild(store, false, entityMissingKu, &chain), HITLS_PKI_SUCCESS);
1640 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);1678 ASSERT_EQ(HITLS_X509_CertVerify(store, chain), HITLS_PKI_SUCCESS);
1679+ ASSERT_TRUE(TestIsErrStackEmpty());
1641 1680 
1642EXIT:1681EXIT:
1643 HITLS_X509_StoreCtxFree(store);1682 HITLS_X509_StoreCtxFree(store);
@@ -1702,6 +1741,7 @@ void SDV_X509_VFY_PATHLEN_FAIL_TC001(void)
1702 // Set the time1741 // Set the time
1703 int64_t now = time(NULL);1742 int64_t now = time(NULL);
1704 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);1743 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
1744+ ASSERT_TRUE(TestIsErrStackEmpty());
1705 1745 
1706 // Inter(CA) fails even when pathLen=01746 // Inter(CA) fails even when pathLen=0
1707 int32_t ret = HITLS_X509_CertVerify(store, chain);1747 int32_t ret = HITLS_X509_CertVerify(store, chain);
@@ -1779,6 +1819,7 @@ void SDV_X509_VFY_PATHLEN_PASS_TC002(void)
1779 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1819 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1780 store->certChain = NULL;1820 store->certChain = NULL;
1781 }1821 }
1822+ ASSERT_TRUE(TestIsErrStackEmpty());
1782 1823 
1783EXIT:1824EXIT:
1784 HITLS_X509_FreeStoreCtxMock(store);1825 HITLS_X509_FreeStoreCtxMock(store);
@@ -1843,6 +1884,7 @@ void SDV_X509_VFY_PATHLEN_UNLIMITED_PASS_TC003(void)
1843 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);1884 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1844 store->certChain = NULL;1885 store->certChain = NULL;
1845 }1886 }
1887+ ASSERT_TRUE(TestIsErrStackEmpty());
1846 1888 
1847EXIT:1889EXIT:
1848 HITLS_X509_FreeStoreCtxMock(store);1890 HITLS_X509_FreeStoreCtxMock(store);
@@ -1892,6 +1934,7 @@ void SDV_X509_VFY_PATHLEN_KEYCERTSIGN_MISSING_FAIL_TC004(void)
1892 1934 
1893 int64_t now = time(NULL);1935 int64_t now = time(NULL);
1894 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);1936 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
1937+ ASSERT_TRUE(TestIsErrStackEmpty());
1895 1938 
1896 HITLS_X509_CertExt *interExt = (HITLS_X509_CertExt *)inter->tbs.ext.extData;1939 HITLS_X509_CertExt *interExt = (HITLS_X509_CertExt *)inter->tbs.ext.extData;
1897 ASSERT_TRUE(interExt != NULL);1940 ASSERT_TRUE(interExt != NULL);
@@ -1975,6 +2018,7 @@ void SDV_X509_VFY_TLS_CLIENT_KU_EKU_BOTH_MATCH_PASS_TC01(void)
1975 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2018 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
1976 store->certChain = NULL;2019 store->certChain = NULL;
1977 }2020 }
2021+ ASSERT_TRUE(TestIsErrStackEmpty());
1978 2022 
1979EXIT:2023EXIT:
1980 HITLS_X509_FreeStoreCtxMock(store);2024 HITLS_X509_FreeStoreCtxMock(store);
@@ -2028,6 +2072,7 @@ void SDV_X509_VFY_TLS_CLIENT_EKU_ONLY_KU_MISSING_FAIL_TC02(void)
2028 2072 
2029 int64_t now = time(NULL);2073 int64_t now = time(NULL);
2030 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);2074 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
2075+ ASSERT_TRUE(TestIsErrStackEmpty());
2031 2076 
2032 int32_t ret = HITLS_X509_CertVerify(store, chain);2077 int32_t ret = HITLS_X509_CertVerify(store, chain);
2033 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);2078 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);
@@ -2104,6 +2149,7 @@ void SDV_X509_VFY_TLS_SERVER_KU_EKU_BOTH_MATCH_PASS_TC03(void)
2104 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2149 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2105 store->certChain = NULL;2150 store->certChain = NULL;
2106 }2151 }
2152+ ASSERT_TRUE(TestIsErrStackEmpty());
2107 2153 
2108EXIT:2154EXIT:
2109 HITLS_X509_FreeStoreCtxMock(store);2155 HITLS_X509_FreeStoreCtxMock(store);
@@ -2158,6 +2204,7 @@ void SDV_X509_VFY_TLS_SERVER_EKU_ONLY_KU_MISSING_FAIL_TC04(void)
2158 2204 
2159 int64_t now = time(NULL);2205 int64_t now = time(NULL);
2160 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);2206 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
2207+ ASSERT_TRUE(TestIsErrStackEmpty());
2161 2208 
2162 int32_t ret = HITLS_X509_CertVerify(store, chain);2209 int32_t ret = HITLS_X509_CertVerify(store, chain);
2163 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);2210 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);
@@ -2234,6 +2281,7 @@ void SDV_X509_VFY_ANYEKU_EKU_ALLOW_KU_MATCH_PASS_TC05(void)
2234 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2281 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2235 store->certChain = NULL;2282 store->certChain = NULL;
2236 }2283 }
2284+ ASSERT_TRUE(TestIsErrStackEmpty());
2237 2285 
2238EXIT:2286EXIT:
2239 HITLS_X509_FreeStoreCtxMock(store);2287 HITLS_X509_FreeStoreCtxMock(store);
@@ -2287,6 +2335,7 @@ void SDV_X509_VFY_ANYEKU_KU_MISSING_FAIL_TC06(void)
2287 HITLS_PKI_SUCCESS);2335 HITLS_PKI_SUCCESS);
2288 int64_t now = time(NULL);2336 int64_t now = time(NULL);
2289 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);2337 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
2338+ ASSERT_TRUE(TestIsErrStackEmpty());
2290 2339 
2291 int32_t ret = HITLS_X509_CertVerify(store, chain);2340 int32_t ret = HITLS_X509_CertVerify(store, chain);
2292 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);2341 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PURPOSE_UNMATCH);
@@ -2349,6 +2398,7 @@ void SDV_X509_VFY_CERT_TIME_CURRENT_PASS_TC001(void)
2349 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2398 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2350 store->certChain = NULL;2399 store->certChain = NULL;
2351 }2400 }
2401+ ASSERT_TRUE(TestIsErrStackEmpty());
2352EXIT:2402EXIT:
2353 HITLS_X509_StoreCtxFree(store);2403 HITLS_X509_StoreCtxFree(store);
2354 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2404 BSL_LIST_FREE(chain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
@@ -2404,6 +2454,7 @@ void SDV_X509_VFY_CERT_TIME_HISTORY_PASS_TC001(void)
2404 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2454 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2405 store->certChain = NULL;2455 store->certChain = NULL;
2406 }2456 }
2457+ ASSERT_TRUE(TestIsErrStackEmpty());
2407 2458 
2408EXIT:2459EXIT:
2409 HITLS_X509_StoreCtxFree(store);2460 HITLS_X509_StoreCtxFree(store);
@@ -2450,6 +2501,7 @@ void SDV_X509_VFY_CERT_TIME_OUT_OF_RANGE_FAIL_TC001(void)
2450 int64_t before = start - 60;2501 int64_t before = start - 60;
2451 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &before, sizeof(before)),2502 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &before, sizeof(before)),
2452 HITLS_PKI_SUCCESS);2503 HITLS_PKI_SUCCESS);
2504+ ASSERT_TRUE(TestIsErrStackEmpty());
2453 2505 
2454 int32_t ret = HITLS_X509_CertVerify(store, chain);2506 int32_t ret = HITLS_X509_CertVerify(store, chain);
2455 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_NOTBEFORE_IN_FUTURE);2507 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_NOTBEFORE_IN_FUTURE);
@@ -2550,6 +2602,7 @@ void SDV_X509_VFY_CERT_TIME_BOUNDARY_PASS_TC001(void)
2550 2602 
2551 vret = VerifyAtTime(store, chain, end);2603 vret = VerifyAtTime(store, chain, end);
2552 ASSERT_EQ(vret, HITLS_PKI_SUCCESS);2604 ASSERT_EQ(vret, HITLS_PKI_SUCCESS);
2605+ ASSERT_TRUE(TestIsErrStackEmpty());
2553 2606 
2554EXIT:2607EXIT:
2555 HITLS_X509_StoreCtxFree(store);2608 HITLS_X509_StoreCtxFree(store);
@@ -2620,6 +2673,7 @@ void SDV_X509_VFY_CERT_TIME_BOUNDARY_PASS_TC002(void)
2620 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2673 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2621 store->certChain = NULL;2674 store->certChain = NULL;
2622 }2675 }
2676+ ASSERT_TRUE(TestIsErrStackEmpty());
2623 2677 
2624EXIT:2678EXIT:
2625 HITLS_X509_StoreCtxFree(store);2679 HITLS_X509_StoreCtxFree(store);
@@ -2685,6 +2739,7 @@ void SDV_X509_VFY_CERT_TIME_BOUNDARY_PASS_TC003(void)
2685 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2739 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2686 store->certChain = NULL;2740 store->certChain = NULL;
2687 }2741 }
2742+ ASSERT_TRUE(TestIsErrStackEmpty());
2688 2743 
2689EXIT:2744EXIT:
2690 HITLS_X509_StoreCtxFree(store);2745 HITLS_X509_StoreCtxFree(store);
@@ -2740,6 +2795,7 @@ void SDV_X509_VFY_EXT_UNSUPPORTED_NONCRIT_EXT_PASS_TC001(void)
2740 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2795 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2741 store->certChain = NULL;2796 store->certChain = NULL;
2742 }2797 }
2798+ ASSERT_TRUE(TestIsErrStackEmpty());
2743 2799 
2744EXIT:2800EXIT:
2745 HITLS_X509_StoreCtxFree(store);2801 HITLS_X509_StoreCtxFree(store);
@@ -2780,6 +2836,7 @@ void SDV_X509_VFY_EXT_UNSUPPORTED_CRIT_EXT_FAIL_TC001(void)
2780 2836 
2781 int64_t now = (int64_t)time(NULL);2837 int64_t now = (int64_t)time(NULL);
2782 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);2838 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
2839+ ASSERT_TRUE(TestIsErrStackEmpty());
2783 2840 
2784 int32_t ret = HITLS_X509_CertVerify(store, chain);2841 int32_t ret = HITLS_X509_CertVerify(store, chain);
2785 ASSERT_EQ(ret, HITLS_X509_ERR_PROCESS_CRITICALEXT);2842 ASSERT_EQ(ret, HITLS_X509_ERR_PROCESS_CRITICALEXT);
@@ -2860,6 +2917,7 @@ void SDV_X509_VFY_EXT_SUPPORTED_EXT_PASS_TC001(void)
2860 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2917 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2861 store->certChain = NULL;2918 store->certChain = NULL;
2862 }2919 }
2920+ ASSERT_TRUE(TestIsErrStackEmpty());
2863 2921 
2864EXIT:2922EXIT:
2865 HITLS_X509_StoreCtxFree(store);2923 HITLS_X509_StoreCtxFree(store);
@@ -2915,6 +2973,7 @@ void SDV_X509_VFY_CERT_CHAIN_BINDING_PASS_TC001(void)
2915 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);2973 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
2916 store->certChain = NULL;2974 store->certChain = NULL;
2917 }2975 }
2976+ ASSERT_TRUE(TestIsErrStackEmpty());
2918 2977 
2919EXIT:2978EXIT:
2920 HITLS_X509_StoreCtxFree(store);2979 HITLS_X509_StoreCtxFree(store);
@@ -2961,6 +3020,7 @@ void SDV_X509_VFY_CERT_CHAIN_BINDING_FAIL_TC001(void)
2961 3020 
2962 int64_t now = (int64_t)time(NULL);3021 int64_t now = (int64_t)time(NULL);
2963 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);3022 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
3023+ ASSERT_TRUE(TestIsErrStackEmpty());
2964 3024 
2965 int32_t ret = HITLS_X509_CertVerify(store, chain);3025 int32_t ret = HITLS_X509_CertVerify(store, chain);
2966 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);3026 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);
@@ -3029,6 +3089,7 @@ void SDV_X509_VFY_CA_CHAIN_BINDING_PASS_TC001(void)
3029 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);3089 BSL_LIST_FREE(built, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
3030 store->certChain = NULL;3090 store->certChain = NULL;
3031 }3091 }
3092+ ASSERT_TRUE(TestIsErrStackEmpty());
3032 3093 
3033EXIT:3094EXIT:
3034 HITLS_X509_StoreCtxFree(store);3095 HITLS_X509_StoreCtxFree(store);
@@ -3075,6 +3136,7 @@ void SDV_X509_VFY_CA_CHAIN_BINDING_FAIL_TC001(void)
3075 3136 
3076 int64_t now = (int64_t)time(NULL);3137 int64_t now = (int64_t)time(NULL);
3077 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);3138 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
3139+ ASSERT_TRUE(TestIsErrStackEmpty());
3078 3140 
3079 int32_t ret = HITLS_X509_CertVerify(store, chain);3141 int32_t ret = HITLS_X509_CertVerify(store, chain);
3080 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);3142 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);
@@ -3130,6 +3192,7 @@ void SDV_X509_VFY_AKI_SKI_KEYID_PASS_TC001(void)
3130 3192 
3131 int32_t ret = HITLS_X509_CertVerify(store, chain);3193 int32_t ret = HITLS_X509_CertVerify(store, chain);
3132 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3194 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3195+ ASSERT_TRUE(TestIsErrStackEmpty());
3133 3196 
3134EXIT:3197EXIT:
3135 HITLS_X509_StoreCtxFree(store);3198 HITLS_X509_StoreCtxFree(store);
@@ -3171,6 +3234,7 @@ void SDV_X509_VFY_AKI_SKI_KEYID_FAIL_TC002(void)
3171 3234 
3172 int64_t now = (int64_t)time(NULL);3235 int64_t now = (int64_t)time(NULL);
3173 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);3236 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
3237+ ASSERT_TRUE(TestIsErrStackEmpty());
3174 3238 
3175 int32_t ret = HITLS_X509_CertVerify(store, chain);3239 int32_t ret = HITLS_X509_CertVerify(store, chain);
3176 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);3240 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
@@ -3218,6 +3282,7 @@ void SDV_X509_VFY_AKI_SKI_UPPER_SKI_MISSING_PASS_TC003(void)
3218 3282 
3219 int32_t ret = HITLS_X509_CertVerify(store, chain);3283 int32_t ret = HITLS_X509_CertVerify(store, chain);
3220 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3284 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3285+ ASSERT_TRUE(TestIsErrStackEmpty());
3221 3286 
3222EXIT:3287EXIT:
3223 HITLS_X509_StoreCtxFree(store);3288 HITLS_X509_StoreCtxFree(store);
@@ -3262,6 +3327,7 @@ void SDV_X509_VFY_AKI_SKI_LOWER_AKI_MISSING_PASS_TC004(void)
3262 3327 
3263 int32_t ret = HITLS_X509_CertVerify(store, chain);3328 int32_t ret = HITLS_X509_CertVerify(store, chain);
3264 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3329 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3330+ ASSERT_TRUE(TestIsErrStackEmpty());
3265 3331 
3266EXIT:3332EXIT:
3267 HITLS_X509_StoreCtxFree(store);3333 HITLS_X509_StoreCtxFree(store);
@@ -3303,6 +3369,7 @@ void SDV_X509_VFY_AKI_SKI_ISSUER_SERIAL_FAIL_TC006(void)
3303 3369 
3304 int64_t now = (int64_t)time(NULL);3370 int64_t now = (int64_t)time(NULL);
3305 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);3371 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)), HITLS_PKI_SUCCESS);
3372+ ASSERT_TRUE(TestIsErrStackEmpty());
3306 3373 
3307 int32_t ret = HITLS_X509_CertVerify(store, chain);3374 int32_t ret = HITLS_X509_CertVerify(store, chain);
3308 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);3375 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
@@ -3350,6 +3417,7 @@ void SDV_X509_VFY_AKI_SKI_CRITICAL_PASS_TC007(void)
3350 3417 
3351 int32_t ret = HITLS_X509_CertVerify(store, chain);3418 int32_t ret = HITLS_X509_CertVerify(store, chain);
3352 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3419 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3420+ ASSERT_TRUE(TestIsErrStackEmpty());
3353 3421 
3354EXIT:3422EXIT:
3355 HITLS_X509_StoreCtxFree(store);3423 HITLS_X509_StoreCtxFree(store);
@@ -3398,6 +3466,7 @@ void SDV_X509_VFY_AKI_SKI_MULTILEVEL_PASS_TC008(void)
3398 3466 
3399 int32_t ret = HITLS_X509_CertVerify(store, chain);3467 int32_t ret = HITLS_X509_CertVerify(store, chain);
3400 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3468 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3469+ ASSERT_TRUE(TestIsErrStackEmpty());
3401 3470 
3402EXIT:3471EXIT:
3403 HITLS_X509_StoreCtxFree(store);3472 HITLS_X509_StoreCtxFree(store);
@@ -3444,6 +3513,7 @@ void SDV_X509_VFY_NOAKID_CERT_PASS_TC009(void)
3444 3513 
3445 int32_t ret = HITLS_X509_CertVerify(store, chain);3514 int32_t ret = HITLS_X509_CertVerify(store, chain);
3446 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3515 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3516+ ASSERT_TRUE(TestIsErrStackEmpty());
3447 3517 
3448EXIT:3518EXIT:
3449 HITLS_X509_StoreCtxFree(store);3519 HITLS_X509_StoreCtxFree(store);
@@ -3486,6 +3556,7 @@ void SDV_X509_VFY_BC_MISSING_FAIL_TC001(void)
3486 int64_t now = (int64_t)time(NULL);3556 int64_t now = (int64_t)time(NULL);
3487 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3557 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3488 HITLS_PKI_SUCCESS);3558 HITLS_PKI_SUCCESS);
3559+ ASSERT_TRUE(TestIsErrStackEmpty());
3489 3560 
3490 int32_t ret = HITLS_X509_CertVerify(store, chain);3561 int32_t ret = HITLS_X509_CertVerify(store, chain);
3491 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_INVALID_CA);3562 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_INVALID_CA);
@@ -3531,6 +3602,7 @@ void SDV_X509_VFY_BC_CA_FALSE_FAIL_TC002(void)
3531 int64_t now = (int64_t)time(NULL);3602 int64_t now = (int64_t)time(NULL);
3532 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3603 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3533 HITLS_PKI_SUCCESS);3604 HITLS_PKI_SUCCESS);
3605+ ASSERT_TRUE(TestIsErrStackEmpty());
3534 3606 
3535 int32_t ret = HITLS_X509_CertVerify(store, chain);3607 int32_t ret = HITLS_X509_CertVerify(store, chain);
3536 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_INVALID_CA);3608 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_INVALID_CA);
@@ -3580,6 +3652,7 @@ void SDV_X509_VFY_BC_PATHLEN_ROOT_LIMIT_FAIL_TC003(void)
3580 int64_t now = (int64_t)time(NULL);3652 int64_t now = (int64_t)time(NULL);
3581 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3653 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3582 HITLS_PKI_SUCCESS);3654 HITLS_PKI_SUCCESS);
3655+ ASSERT_TRUE(TestIsErrStackEmpty());
3583 3656 
3584 int32_t ret = HITLS_X509_CertVerify(store, chain);3657 int32_t ret = HITLS_X509_CertVerify(store, chain);
3585 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PATHLEN_EXCEEDED);3658 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PATHLEN_EXCEEDED);
@@ -3591,8 +3664,8 @@ EXIT:
3591 }3664 }
3592 HITLS_X509_CertFree(leaf);3665 HITLS_X509_CertFree(leaf);
3593 HITLS_X509_CertFree(inter2);3666 HITLS_X509_CertFree(inter2);
3594-HITLS_X509_CertFree(inter1);3667+ HITLS_X509_CertFree(inter1);
3595-HITLS_X509_CertFree(root);3668+ HITLS_X509_CertFree(root);
3596}3669}
3597/* END_CASE */3670/* END_CASE */
3598 3671 
@@ -3634,6 +3707,7 @@ void SDV_X509_VFY_BC_PATHLEN_MULTI_LIMIT_FAIL_TC004(void)
3634 int64_t now = (int64_t)time(NULL);3707 int64_t now = (int64_t)time(NULL);
3635 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3708 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3636 HITLS_PKI_SUCCESS);3709 HITLS_PKI_SUCCESS);
3710+ ASSERT_TRUE(TestIsErrStackEmpty());
3637 3711 
3638 int32_t ret = HITLS_X509_CertVerify(store, chain);3712 int32_t ret = HITLS_X509_CertVerify(store, chain);
3639 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PATHLEN_EXCEEDED);3713 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_PATHLEN_EXCEEDED);
@@ -3689,6 +3763,7 @@ void SDV_X509_VFY_DEPTH_CHAINLEN_PASS_TC001(void)
3689 3763 
3690 int32_t ret = HITLS_X509_CertVerify(store, chain);3764 int32_t ret = HITLS_X509_CertVerify(store, chain);
3691 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3765 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3766+ ASSERT_TRUE(TestIsErrStackEmpty());
3692 3767 
3693EXIT:3768EXIT:
3694 HITLS_X509_StoreCtxFree(store);3769 HITLS_X509_StoreCtxFree(store);
@@ -3723,6 +3798,7 @@ void SDV_X509_PARTIAL_CERT_VFY_FUNC_TC001(char *caCertPath, char *interCertPath,
3723 3798 
3724 ret = HITLS_AddCertToStoreTest(interCertPath, store, &ca);3799 ret = HITLS_AddCertToStoreTest(interCertPath, store, &ca);
3725 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3800 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3801+ ASSERT_TRUE(TestIsErrStackEmpty());
3726 3802 
3727 ret = HITLS_X509_CertVerify(store, chain);3803 ret = HITLS_X509_CertVerify(store, chain);
3728 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);3804 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
@@ -3776,6 +3852,7 @@ void SDV_X509_PARTIAL_CERT_VFY_FUNC_TC002(char *caCertPath, char *interCertPath,
3776 // Even if a complete chain can be built, if PARTIAL_CHAIN open, it will still be a partial chain3852 // Even if a complete chain can be built, if PARTIAL_CHAIN open, it will still be a partial chain
3777 ret = HITLS_X509_CertVerify(store, chain);3853 ret = HITLS_X509_CertVerify(store, chain);
3778 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3854 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3855+ ASSERT_TRUE(TestIsErrStackEmpty());
3779EXIT:3856EXIT:
3780 HITLS_X509_StoreCtxFree(store);3857 HITLS_X509_StoreCtxFree(store);
3781 HITLS_X509_CertFree(ca);3858 HITLS_X509_CertFree(ca);
@@ -3823,6 +3900,7 @@ void SDV_X509_VFY_DEPTH_CHAINLEN_FAIL_TC002(void)
3823 int64_t now = (int64_t)time(NULL);3900 int64_t now = (int64_t)time(NULL);
3824 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3901 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3825 HITLS_PKI_SUCCESS);3902 HITLS_PKI_SUCCESS);
3903+ ASSERT_TRUE(TestIsErrStackEmpty());
3826 int32_t ret = HITLS_X509_CertVerify(store, chain);3904 int32_t ret = HITLS_X509_CertVerify(store, chain);
3827 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);3905 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);
3828 3906 
@@ -3867,6 +3945,7 @@ void SDV_X509_VFY_SIGALG_RSA_ROOT_PASS_TC001(void)
3867 3945 
3868 int32_t ret = HITLS_X509_CertVerify(store, chain);3946 int32_t ret = HITLS_X509_CertVerify(store, chain);
3869 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);3947 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
3948+ ASSERT_TRUE(TestIsErrStackEmpty());
3870 3949 
3871EXIT:3950EXIT:
3872 HITLS_X509_StoreCtxFree(store);3951 HITLS_X509_StoreCtxFree(store);
@@ -3908,6 +3987,7 @@ void SDV_X509_VFY_SIGALG_TRUST_ANCHOR_ALG_MISMATCH_FAIL_TC002(void)
3908 int64_t now = (int64_t)time(NULL);3987 int64_t now = (int64_t)time(NULL);
3909 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),3988 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3910 HITLS_PKI_SUCCESS);3989 HITLS_PKI_SUCCESS);
3990+ ASSERT_TRUE(TestIsErrStackEmpty());
3911 3991 
3912 int32_t ret = HITLS_X509_CertVerify(store, chain);3992 int32_t ret = HITLS_X509_CertVerify(store, chain);
3913 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);3993 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
@@ -3956,6 +4036,7 @@ void SDV_X509_VFY_SIGALG_RSA_PSS_PARAM_MISSING_FAIL_TC003(void)
3956 int64_t now = (int64_t)time(NULL);4036 int64_t now = (int64_t)time(NULL);
3957 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4037 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
3958 HITLS_PKI_SUCCESS);4038 HITLS_PKI_SUCCESS);
4039+ ASSERT_TRUE(TestIsErrStackEmpty());
3959 4040 
3960 int32_t ret = HITLS_X509_CertVerify(store, chain);4041 int32_t ret = HITLS_X509_CertVerify(store, chain);
3961 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);4042 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);
@@ -4001,6 +4082,7 @@ void SDV_X509_VFY_SIGALG_SM2_USERID_MISMATCH_FAIL_TC004(void)
4001 int64_t now = (int64_t)time(NULL);4082 int64_t now = (int64_t)time(NULL);
4002 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4083 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
4003 HITLS_PKI_SUCCESS);4084 HITLS_PKI_SUCCESS);
4085+ ASSERT_TRUE(TestIsErrStackEmpty());
4004 4086 
4005 int32_t ret = HITLS_X509_CertVerify(store, chain);4087 int32_t ret = HITLS_X509_CertVerify(store, chain);
4006 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);4088 ASSERT_EQ(ret, HITLS_X509_ERR_VFY_CERT_SIGN_FAIL);
@@ -4061,6 +4143,7 @@ void SDV_X509_VFY_CHAIN_SUBJECT_ISSUER_MISMATCH_FAIL_TC001(void)
4061 int64_t now = (int64_t)time(NULL);4143 int64_t now = (int64_t)time(NULL);
4062 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4144 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
4063 HITLS_PKI_SUCCESS);4145 HITLS_PKI_SUCCESS);
4146+ ASSERT_TRUE(TestIsErrStackEmpty());
4064 4147 
4065 int32_t ret = HITLS_X509_CertVerify(store, chain);4148 int32_t ret = HITLS_X509_CertVerify(store, chain);
4066 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);4149 ASSERT_EQ(ret, HITLS_X509_ERR_ISSUE_CERT_NOT_FOUND);
@@ -4111,6 +4194,7 @@ void SDV_X509_VFY_TRUST_ANCHOR_NOT_FOUND_FAIL_TC002(void)
4111 int64_t now = (int64_t)time(NULL);4194 int64_t now = (int64_t)time(NULL);
4112 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4195 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
4113 HITLS_PKI_SUCCESS);4196 HITLS_PKI_SUCCESS);
4197+ ASSERT_TRUE(TestIsErrStackEmpty());
4114 4198 
4115 int32_t ret = HITLS_X509_CertVerify(store, chain);4199 int32_t ret = HITLS_X509_CertVerify(store, chain);
4116 ASSERT_EQ(ret, HITLS_X509_ERR_ROOT_CERT_NOT_FOUND);4200 ASSERT_EQ(ret, HITLS_X509_ERR_ROOT_CERT_NOT_FOUND);
@@ -4161,6 +4245,7 @@ void SDV_X509_VFY_CHAIN_LOOP_DEPTH_FAIL_TC001(void)
4161 int64_t now = (int64_t)time(NULL);4245 int64_t now = (int64_t)time(NULL);
4162 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4246 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
4163 HITLS_PKI_SUCCESS);4247 HITLS_PKI_SUCCESS);
4248+ ASSERT_TRUE(TestIsErrStackEmpty());
4164 4249 
4165 int32_t ret = HITLS_X509_CertVerify(store, chain);4250 int32_t ret = HITLS_X509_CertVerify(store, chain);
4166 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);4251 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);
@@ -4209,6 +4294,7 @@ void SDV_X509_PARTIAL_CERT_VFY_FUNC_TC003(char *caCertPath, char *interCertPath,
4209 4294 
4210 ret = HITLS_AddCertToStoreTest(interCertPath, store, &interCa);4295 ret = HITLS_AddCertToStoreTest(interCertPath, store, &interCa);
4211 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);4296 ASSERT_EQ(ret, HITLS_PKI_SUCCESS);
4297+ ASSERT_TRUE(TestIsErrStackEmpty());
4212 4298 
4213 ret = HITLS_X509_CertVerify(store, chain);4299 ret = HITLS_X509_CertVerify(store, chain);
4214 ASSERT_EQ(ret, HITLS_X509_ERR_ROOT_CERT_NOT_FOUND);4300 ASSERT_EQ(ret, HITLS_X509_ERR_ROOT_CERT_NOT_FOUND);
@@ -4315,6 +4401,7 @@ void SDV_X509_PARTIAL_CERT_VFY_FUNC_TC005(void)
4315 int64_t now = (int64_t)time(NULL);4401 int64_t now = (int64_t)time(NULL);
4316 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),4402 ASSERT_EQ(HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_TIME, &now, sizeof(now)),
4317 HITLS_PKI_SUCCESS);4403 HITLS_PKI_SUCCESS);
4404+ ASSERT_TRUE(TestIsErrStackEmpty());
4318 4405 
4319 int32_t ret = HITLS_X509_CertVerify(store, chain);4406 int32_t ret = HITLS_X509_CertVerify(store, chain);
4320 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);4407 ASSERT_EQ(ret, HITLS_X509_ERR_CHAIN_DEPTH_UP_LIMIT);
@@ -4368,6 +4455,7 @@ void SDV_X509_CERT_VERIFY_BY_PUBKEY_FUNC_TC001(char *CertPath, char *CertPathVer
4368 4455 
4369 /* Positive case: verify end-entity certificate with issuer's public key */4456 /* Positive case: verify end-entity certificate with issuer's public key */
4370 ASSERT_EQ(HITLS_X509_CertVerifyByPubKey(certTest, issuerPubKey), HITLS_PKI_SUCCESS);4457 ASSERT_EQ(HITLS_X509_CertVerifyByPubKey(certTest, issuerPubKey), HITLS_PKI_SUCCESS);
4458+ ASSERT_TRUE(TestIsErrStackEmpty());
4371 4459 
4372 /* Negative case: verify the same end-entity certificate with an unrelated certificate's public key */4460 /* Negative case: verify the same end-entity certificate with an unrelated certificate's public key */
4373 ASSERT_NE(HITLS_X509_CertVerifyByPubKey(certTest, otherPubKey), HITLS_PKI_SUCCESS);4461 ASSERT_NE(HITLS_X509_CertVerifyByPubKey(certTest, otherPubKey), HITLS_PKI_SUCCESS);