Standardize the naming of external structures-openHiTLS-AtomGit

Mapps/src/app_dgst.c+10-10

	@@ -96,9 +96,9 @@ static AlgInfo g_dgstInfo = {"sha256", CRYPT_MD_SHA256, 0};
96	static int32_t g_argc = 0;	96	static int32_t g_argc = 0;
97	static char **g_argv;	97	static char **g_argv;
98		98
99	-static CRYPT_EAL_MdCTX *InitAlgDigest(CRYPT_MD_AlgId id)	99	+static CRYPT_EAL_MdCtx *InitAlgDigest(CRYPT_MD_AlgId id)
100	{	100	{
101	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(APP_GetCurrent_LibCtx(), id, g_signInfo.provider->providerAttr);	101	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(APP_GetCurrent_LibCtx(), id, g_signInfo.provider->providerAttr);
102	if (ctx == NULL) {	102	if (ctx == NULL) {
103	AppPrintError("dgst: Failed to create the algorithm(%s) context\n", g_dgstInfo.algName);	103	AppPrintError("dgst: Failed to create the algorithm(%s) context\n", g_dgstInfo.algName);
104	return NULL;	104	return NULL;
	@@ -156,7 +156,7 @@ static int32_t HashValToFinal(
156	return HITLS_APP_SUCCESS;	156	return HITLS_APP_SUCCESS;
157	}	157	}
158		158
159	-static int32_t MdFinalToBuf(CRYPT_EAL_MdCTX ctx, uint8_t buf, uint32_t bufLen, const char *filename)	159	+static int32_t MdFinalToBuf(CRYPT_EAL_MdCtx ctx, uint8_t buf, uint32_t bufLen, const char *filename)
160	{	160	{
161	int32_t outRet = HITLS_APP_SUCCESS;	161	int32_t outRet = HITLS_APP_SUCCESS;
162	// save the initial hash value	162	// save the initial hash value
	@@ -202,7 +202,7 @@ static int32_t BufOutToUio(const char outfile, BSL_UIO fileWriteUio, uint8_t *
202	return HITLS_APP_SUCCESS;	202	return HITLS_APP_SUCCESS;
203	}	203	}
204		204
205	-static int32_t StdSumAndOut(CRYPT_EAL_MdCTX ctx, const char outfile)	205	+static int32_t StdSumAndOut(CRYPT_EAL_MdCtx ctx, const char outfile)
206	{	206	{
207	int32_t stdRet = HITLS_APP_SUCCESS;	207	int32_t stdRet = HITLS_APP_SUCCESS;
208	uint8_t *outBuf = NULL;	208	uint8_t *outBuf = NULL;
	@@ -263,7 +263,7 @@ static int32_t StdSumAndOut(CRYPT_EAL_MdCTX ctx, const char outfile)
263	return stdRet;	263	return stdRet;
264	}	264	}
265		265
266	-static int32_t ReadFileToBuf(CRYPT_EAL_MdCTX ctx, const char filename)	266	+static int32_t ReadFileToBuf(CRYPT_EAL_MdCtx ctx, const char filename)
267	{	267	{
268	int32_t readRet = HITLS_APP_SUCCESS;	268	int32_t readRet = HITLS_APP_SUCCESS;
269	BSL_UIO *readUio = HITLS_APP_UioOpen(filename, 'r', 0);	269	BSL_UIO *readUio = HITLS_APP_UioOpen(filename, 'r', 0);
	@@ -310,7 +310,7 @@ static int32_t ReadFileToBuf(CRYPT_EAL_MdCTX ctx, const char filename)
310	return readRet;	310	return readRet;
311	}	311	}
312		312
313	-static int32_t FileSumOutStd(CRYPT_EAL_MdCTX *ctx)	313	+static int32_t FileSumOutStd(CRYPT_EAL_MdCtx *ctx)
314	{	314	{
315	int32_t outRet = HITLS_APP_SUCCESS;	315	int32_t outRet = HITLS_APP_SUCCESS;
316	// Traverse the files that need to be digested, obtain the file content, calculate the file content digest,	316	// Traverse the files that need to be digested, obtain the file content, calculate the file content digest,
	@@ -356,7 +356,7 @@ static int32_t FileSumOutStd(CRYPT_EAL_MdCTX *ctx)
356	return HITLS_APP_SUCCESS;	356	return HITLS_APP_SUCCESS;
357	}	357	}
358		358
359	-static int32_t MultiFileSetCtx(CRYPT_EAL_MdCTX *ctx)	359	+static int32_t MultiFileSetCtx(CRYPT_EAL_MdCtx *ctx)
360	{	360	{
361	int32_t outRet = CRYPT_EAL_MdDeinit(ctx); // md release	361	int32_t outRet = CRYPT_EAL_MdDeinit(ctx); // md release
362	if (outRet != CRYPT_SUCCESS) {	362	if (outRet != CRYPT_SUCCESS) {
	@@ -371,7 +371,7 @@ static int32_t MultiFileSetCtx(CRYPT_EAL_MdCTX *ctx)
371	return HITLS_APP_SUCCESS;	371	return HITLS_APP_SUCCESS;
372	}	372	}
373		373
374	-static int32_t FileSumOutFile(CRYPT_EAL_MdCTX ctx, const char outfile)	374	+static int32_t FileSumOutFile(CRYPT_EAL_MdCtx ctx, const char outfile)
375	{	375	{
376	int32_t outRet = HITLS_APP_SUCCESS;	376	int32_t outRet = HITLS_APP_SUCCESS;
377	BSL_UIO *fileWriteUio = HITLS_APP_UioOpen(outfile, 'w', 0); // overwrite the original content	377	BSL_UIO *fileWriteUio = HITLS_APP_UioOpen(outfile, 'w', 0); // overwrite the original content
	@@ -425,7 +425,7 @@ static int32_t FileSumOutFile(CRYPT_EAL_MdCTX ctx, const char outfile)
425	return HITLS_APP_SUCCESS;	425	return HITLS_APP_SUCCESS;
426	}	426	}
427		427
428	-static int32_t FileSumAndOut(CRYPT_EAL_MdCTX ctx, const char outfile)	428	+static int32_t FileSumAndOut(CRYPT_EAL_MdCtx ctx, const char outfile)
429	{	429	{
430	int32_t outRet = HITLS_APP_SUCCESS;	430	int32_t outRet = HITLS_APP_SUCCESS;
431	if (outfile == NULL) {	431	if (outfile == NULL) {
	@@ -441,7 +441,7 @@ static int32_t FileSumAndOut(CRYPT_EAL_MdCTX ctx, const char outfile)
441	static int32_t CalculateDgst(char *outfile)	441	static int32_t CalculateDgst(char *outfile)
442	{	442	{
443	int32_t ret = HITLS_APP_SUCCESS;	443	int32_t ret = HITLS_APP_SUCCESS;
444	- CRYPT_EAL_MdCTX *ctx = InitAlgDigest(g_dgstInfo.algId);	444	+ CRYPT_EAL_MdCtx *ctx = InitAlgDigest(g_dgstInfo.algId);
445	if (ctx == NULL) {	445	if (ctx == NULL) {
446	ret = HITLS_APP_CRYPTO_FAIL;	446	ret = HITLS_APP_CRYPTO_FAIL;
447	return ret;	447	return ret;

Mapps/src/app_enc.c+1-1

	@@ -625,7 +625,7 @@ static int32_t GetCipherKey(EncCmdOpt *encOpt)
625	return GetKeyFromP12(encOpt);	625	return GetKeyFromP12(encOpt);
626	}	626	}
627	#endif	627	#endif
628	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), CRYPT_KDF_PBKDF2,	628	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), CRYPT_KDF_PBKDF2,
629	encOpt->provider->providerAttr);	629	encOpt->provider->providerAttr);
630	if (ctx == NULL) {	630	if (ctx == NULL) {
631	return HITLS_APP_MEM_ALLOC_FAIL;	631	return HITLS_APP_MEM_ALLOC_FAIL;

Mapps/src/app_kdf.c+6-6

	@@ -294,9 +294,9 @@ static int32_t CheckParam(KdfOpt *kdfOpt)
294	return HITLS_APP_SUCCESS;	294	return HITLS_APP_SUCCESS;
295	}	295	}
296		296
297	-static CRYPT_EAL_KdfCTX InitAlgKdf(KdfOpt kdfOpt)	297	+static CRYPT_EAL_KdfCtx InitAlgKdf(KdfOpt kdfOpt)
298	{	298	{
299	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), kdfOpt->kdfId,	299	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), kdfOpt->kdfId,
300	kdfOpt->provider->providerAttr);	300	kdfOpt->provider->providerAttr);
301	if (ctx == NULL) {	301	if (ctx == NULL) {
302	AppPrintError("Failed to create the algorithm(%s) context\n", kdfOpt->kdfName);	302	AppPrintError("Failed to create the algorithm(%s) context\n", kdfOpt->kdfName);
	@@ -344,7 +344,7 @@ static int32_t KdfParseSalt(KdfOpt kdfOpt, uint8_t salt, uint32_t saltLen)
344	return HITLS_APP_SUCCESS;	344	return HITLS_APP_SUCCESS;
345	}	345	}
346		346
347	-static int32_t Pbkdf2Params(CRYPT_EAL_KdfCTX ctx, BSL_Param params, KdfOpt *kdfOpt)	347	+static int32_t Pbkdf2Params(CRYPT_EAL_KdfCtx ctx, BSL_Param params, KdfOpt *kdfOpt)
348	{	348	{
349	uint32_t index = 0;	349	uint32_t index = 0;
350	uint8_t *pass = NULL;	350	uint8_t *pass = NULL;
	@@ -402,7 +402,7 @@ static int32_t Pbkdf2Params(CRYPT_EAL_KdfCTX ctx, BSL_Param params, KdfOpt *kd
402	return ret;	402	return ret;
403	}	403	}
404		404
405	-static int32_t PbkdfParamSet(CRYPT_EAL_KdfCTX ctx, KdfOpt kdfOpt)	405	+static int32_t PbkdfParamSet(CRYPT_EAL_KdfCtx ctx, KdfOpt kdfOpt)
406	{	406	{
407	if (kdfOpt->kdfId == CRYPT_KDF_PBKDF2) {	407	if (kdfOpt->kdfId == CRYPT_KDF_PBKDF2) {
408	BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};	408	BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -412,7 +412,7 @@ static int32_t PbkdfParamSet(CRYPT_EAL_KdfCTX ctx, KdfOpt kdfOpt)
412	return HITLS_APP_OPT_VALUE_INVALID;	412	return HITLS_APP_OPT_VALUE_INVALID;
413	}	413	}
414		414
415	-static int32_t KdfResult(CRYPT_EAL_KdfCTX ctx, KdfOpt kdfOpt)	415	+static int32_t KdfResult(CRYPT_EAL_KdfCtx ctx, KdfOpt kdfOpt)
416	{	416	{
417	uint8_t *out = NULL;	417	uint8_t *out = NULL;
418	uint32_t outLen = kdfOpt->keyLen;	418	uint32_t outLen = kdfOpt->keyLen;
	@@ -469,7 +469,7 @@ int32_t HITLS_KdfMain(int argc, char *argv[])
469	AppInitParam initParam = {CRYPT_RAND_SHA256, &appProvider};	469	AppInitParam initParam = {CRYPT_RAND_SHA256, &appProvider};
470	KdfOpt kdfOpt = {CRYPT_MAC_HMAC_SHA256, NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, 1000, &appProvider, 0};	470	KdfOpt kdfOpt = {CRYPT_MAC_HMAC_SHA256, NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, 1000, &appProvider, 0};
471	#endif	471	#endif
472	- CRYPT_EAL_KdfCTX *ctx = NULL;	472	+ CRYPT_EAL_KdfCtx *ctx = NULL;
473	do {	473	do {
474	mainRet = HITLS_APP_OptBegin(argc, argv, g_kdfOpts);	474	mainRet = HITLS_APP_OptBegin(argc, argv, g_kdfOpts);
475	if (mainRet != HITLS_APP_SUCCESS) {	475	if (mainRet != HITLS_APP_SUCCESS) {

Mapps/src/app_sm.c+1-1

	@@ -186,7 +186,7 @@ static int32_t GetPassword(char **password)
186	static int32_t DeriveKeyFromPassword(AppProvider provider, char password, UserParam userParam, uint8_t dKey,	186	static int32_t DeriveKeyFromPassword(AppProvider provider, char password, UserParam userParam, uint8_t dKey,
187	uint32_t dKeyLen)	187	uint32_t dKeyLen)
188	{	188	{
189	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), CRYPT_KDF_PBKDF2,	189	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(APP_GetCurrent_LibCtx(), CRYPT_KDF_PBKDF2,
190	provider->providerAttr);	190	provider->providerAttr);
191	if (kdfCtx == NULL) {	191	if (kdfCtx == NULL) {
192	AppPrintError("Failed to create kdf context.\n");	192	AppPrintError("Failed to create kdf context.\n");

Mauth/pake/pake.c+5-5

	@@ -124,7 +124,7 @@ HITLS_AUTH_PakeCtx HITLS_AUTH_PakeNewCtx(CRYPT_EAL_LibCtx libCtx, const char *
124	return ctx;	124	return ctx;
125	}	125	}
126		126
127	-static int32_t HITLS_AUTH_PakeReqRegister(HITLS_AUTH_PakeCtx ctx, CRYPT_EAL_KdfCTX kdfctx,	127	+static int32_t HITLS_AUTH_PakeReqRegister(HITLS_AUTH_PakeCtx ctx, CRYPT_EAL_KdfCtx kdfctx,
128	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)	128	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)
129	{	129	{
130	if (ctx == NULL \|\| kdfctx == NULL) {	130	if (ctx == NULL \|\| kdfctx == NULL) {
	@@ -149,7 +149,7 @@ static int32_t HITLS_AUTH_PakeReqRegister(HITLS_AUTH_PakeCtx *ctx, CRYPT_EAL_Kdf
149	return ret;	149	return ret;
150	}	150	}
151		151
152	-static int32_t HITLS_AUTH_PakeRespRegister(HITLS_AUTH_PakeCtx ctx, CRYPT_EAL_KdfCTX kdfctx,	152	+static int32_t HITLS_AUTH_PakeRespRegister(HITLS_AUTH_PakeCtx ctx, CRYPT_EAL_KdfCtx kdfctx,
153	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)	153	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)
154	{	154	{
155	(void)kdfctx;	155	(void)kdfctx;
	@@ -175,7 +175,7 @@ static int32_t HITLS_AUTH_PakeRespRegister(HITLS_AUTH_PakeCtx *ctx, CRYPT_EAL_Kd
175	return ret;	175	return ret;
176	}	176	}
177		177
178	-int32_t HITLS_AUTH_Pake_Ctrl(HITLS_AUTH_PakeCtx ctx, HITLS_AUTH_PAKE_CtrlCmd cmd, CRYPT_EAL_KdfCTX kdfctx,	178	+int32_t HITLS_AUTH_Pake_Ctrl(HITLS_AUTH_PakeCtx ctx, HITLS_AUTH_PAKE_CtrlCmd cmd, CRYPT_EAL_KdfCtx kdfctx,
179	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)	179	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2)
180	{	180	{
181	if (ctx == NULL) {	181	if (ctx == NULL) {
	@@ -307,7 +307,7 @@ int32_t HITLS_AUTH_PakeRespDerive(HITLS_AUTH_PakeCtx *ctx, BSL_Buffer in0, BSL_B
307	return ret;	307	return ret;
308	}	308	}
309		309
310	-CRYPT_EAL_KdfCTX* HITLS_AUTH_PakeGetKdfCtx(HITLS_AUTH_PakeCtx* ctx, HITLS_AUTH_PAKE_KDF kdf)	310	+CRYPT_EAL_KdfCtx* HITLS_AUTH_PakeGetKdfCtx(HITLS_AUTH_PakeCtx* ctx, HITLS_AUTH_PAKE_KDF kdf)
311	{	311	{
312	if (ctx == NULL) {	312	if (ctx == NULL) {
313	BSL_ERR_PUSH_ERROR(HITLS_AUTH_NULL_INPUT);	313	BSL_ERR_PUSH_ERROR(HITLS_AUTH_NULL_INPUT);
	@@ -333,7 +333,7 @@ CRYPT_EAL_KdfCTX* HITLS_AUTH_PakeGetKdfCtx(HITLS_AUTH_PakeCtx* ctx, HITLS_AUTH_P
333	(void)memcpy_s(buffer + ctx->password.dataLen, ctx->prover.dataLen, ctx->prover.data, ctx->prover.dataLen);	333	(void)memcpy_s(buffer + ctx->password.dataLen, ctx->prover.dataLen, ctx->prover.data, ctx->prover.dataLen);
334	(void)memcpy_s(buffer + ctx->password.dataLen + ctx->prover.dataLen, ctx->verifier.dataLen,	334	(void)memcpy_s(buffer + ctx->password.dataLen + ctx->prover.dataLen, ctx->verifier.dataLen,
335	ctx->verifier.data, ctx->verifier.dataLen);	335	ctx->verifier.data, ctx->verifier.dataLen);
336	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_KdfNewCtx(kdf.algId);	336	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_KdfNewCtx(kdf.algId);
337	if (kdfCtx == NULL) {	337	if (kdfCtx == NULL) {
338	BSL_SAL_Free(buffer);	338	BSL_SAL_Free(buffer);
339	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL);	339	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL);

Mauth/pake/spake2plus/include/spake2plus.h+1-1

	@@ -78,7 +78,7 @@ int32_t Spake2PlusInitCipherSuite(Spake2plusCtx* ctx, HITLS_AUTH_PAKE_CipherSuit
78	* @retval #HITLS_AUTH_SUCCESS if successful	78	* @retval #HITLS_AUTH_SUCCESS if successful
79	* Other error codes defined in hitls_errno.h if an error occurs	79	* Other error codes defined in hitls_errno.h if an error occurs
80	*/	80	*/
81	-int32_t HITLS_AUTH_Spake2plusReqRegister(HITLS_AUTH_PakeCtx* ctx, CRYPT_EAL_KdfCTX* kdfCtx,	81	+int32_t HITLS_AUTH_Spake2plusReqRegister(HITLS_AUTH_PakeCtx* ctx, CRYPT_EAL_KdfCtx* kdfCtx,
82	BSL_Buffer exist_w0, BSL_Buffer exist_w1, BSL_Buffer exist_l);	82	BSL_Buffer exist_w0, BSL_Buffer exist_w1, BSL_Buffer exist_l);
83		83
84	/**	84	/**

Mauth/pake/spake2plus/src/spake2plus.c+2-2

	@@ -228,7 +228,7 @@ static int32_t Spake2PlusGetEcc(CRYPT_EAL_PkeyCtx *pkey, EccParamType type, uint
228	return HITLS_AUTH_SUCCESS;	228	return HITLS_AUTH_SUCCESS;
229	}	229	}
230		230
231	-int32_t HITLS_AUTH_Spake2plusReqRegister(HITLS_AUTH_PakeCtx* ctx, CRYPT_EAL_KdfCTX* kdfCtx, BSL_Buffer exist_w0,	231	+int32_t HITLS_AUTH_Spake2plusReqRegister(HITLS_AUTH_PakeCtx* ctx, CRYPT_EAL_KdfCtx* kdfCtx, BSL_Buffer exist_w0,
232	BSL_Buffer exist_w1, BSL_Buffer exist_l)	232	BSL_Buffer exist_w1, BSL_Buffer exist_l)
233	{	233	{
234	bool allNull = (exist_w0.data == NULL && exist_w1.data == NULL && exist_l.data == NULL);	234	bool allNull = (exist_w0.data == NULL && exist_w1.data == NULL && exist_l.data == NULL);
	@@ -1032,7 +1032,7 @@ static int32_t Spake2PlusComputeKeySchedule(Spake2plusCtx *ctx, BSL_Buffer tt, B
1032	macId=CRYPT_MAC_HMAC_SHA512;	1032	macId=CRYPT_MAC_HMAC_SHA512;
1033	}	1033	}
1034		1034
1035	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);	1035	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
1036	if (kdfCtx == NULL) {	1036	if (kdfCtx == NULL) {
1037	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL);	1037	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL);
1038	return HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL;	1038	return HITLS_AUTH_PAKE_MEMORY_ALLOC_FAIL;

Mauth/privpass_token/src/privpass_token_wrapper.c+1-1

	@@ -57,7 +57,7 @@ static int32_t PrivPassPubDigest(void libCtx, const char attrName, int32_t alg
57	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PRIVPASS_INVALID_INPUT);	57	BSL_ERR_PUSH_ERROR(HITLS_AUTH_PRIVPASS_INVALID_INPUT);
58	return HITLS_AUTH_PRIVPASS_INVALID_INPUT;	58	return HITLS_AUTH_PRIVPASS_INVALID_INPUT;
59	}	59	}
60	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(algId);	60	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(algId);
61	if (ctx == NULL) {	61	if (ctx == NULL) {
62	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);	62	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
63	return BSL_MALLOC_FAIL;	63	return BSL_MALLOC_FAIL;

Mcrypto/codecskey/src/crypt_codecskey_utils.c+1-1

	@@ -330,7 +330,7 @@ EXIT:
330	static int32_t PbkdfDeriveKey(CRYPT_EAL_LibCtx libctx, const char attrName, uint32_t iter, int32_t prfId,	330	static int32_t PbkdfDeriveKey(CRYPT_EAL_LibCtx libctx, const char attrName, uint32_t iter, int32_t prfId,
331	BSL_Buffer salt, const uint8_t pwd, uint32_t pwdLen, BSL_Buffer *key)	331	BSL_Buffer salt, const uint8_t pwd, uint32_t pwdLen, BSL_Buffer *key)
332	{	332	{
333	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libctx, CRYPT_KDF_PBKDF2, attrName);	333	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libctx, CRYPT_KDF_PBKDF2, attrName);
334	if (kdfCtx == NULL) {	334	if (kdfCtx == NULL) {
335	BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_NOT_SUPPORTED);	335	BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_NOT_SUPPORTED);
336	return CRYPT_PBKDF2_NOT_SUPPORTED;	336	return CRYPT_PBKDF2_NOT_SUPPORTED;

Mcrypto/eal/src/eal_kdf.c+12-12

	@@ -54,12 +54,12 @@ bool CRYPT_EAL_KdfIsValidAlgId(CRYPT_KDF_AlgId id)
54	return EAL_KdfFindMethod(id, NULL) == CRYPT_SUCCESS;	54	return EAL_KdfFindMethod(id, NULL) == CRYPT_SUCCESS;
55	}	55	}
56		56
57	-CRYPT_EAL_KdfCTX KdfNewCtxInner(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName, bool isProvider)	57	+CRYPT_EAL_KdfCtx KdfNewCtxInner(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName, bool isProvider)
58	{	58	{
59	(void)libCtx;	59	(void)libCtx;
60	(void)attrName;	60	(void)attrName;
61	(void)isProvider;	61	(void)isProvider;
62	- CRYPT_EAL_KdfCTX *ctx = BSL_SAL_Calloc(1u, sizeof(CRYPT_EAL_KdfCTX));	62	+ CRYPT_EAL_KdfCtx *ctx = BSL_SAL_Calloc(1u, sizeof(CRYPT_EAL_KdfCtx));
63	if (ctx == NULL) {	63	if (ctx == NULL) {
64	BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);	64	BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
65	return NULL;	65	return NULL;
	@@ -97,17 +97,17 @@ ERR:
97	return NULL;	97	return NULL;
98	}	98	}
99		99
100	-CRYPT_EAL_KdfCTX CRYPT_EAL_ProviderKdfNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)	100	+CRYPT_EAL_KdfCtx CRYPT_EAL_ProviderKdfNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)
101	{	101	{
102	return KdfNewCtxInner(libCtx, algId, attrName, true);	102	return KdfNewCtxInner(libCtx, algId, attrName, true);
103	}	103	}
104		104
105	-CRYPT_EAL_KdfCTX *CRYPT_EAL_KdfNewCtx(CRYPT_KDF_AlgId algId)	105	+CRYPT_EAL_KdfCtx *CRYPT_EAL_KdfNewCtx(CRYPT_KDF_AlgId algId)
106	{	106	{
107	return KdfNewCtxInner(NULL, algId, NULL, false);	107	return KdfNewCtxInner(NULL, algId, NULL, false);
108	}	108	}
109		109
110	-int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCTX ctx, const BSL_Param param)	110	+int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCtx ctx, const BSL_Param param)
111	{	111	{
112	if (ctx == NULL) {	112	if (ctx == NULL) {
113	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);	113	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
	@@ -125,7 +125,7 @@ int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCTX ctx, const BSL_Param param)
125	return ret;	125	return ret;
126	}	126	}
127		127
128	-int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCTX ctx, uint8_t key, uint32_t keyLen)	128	+int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCtx ctx, uint8_t key, uint32_t keyLen)
129	{	129	{
130	if (ctx == NULL) {	130	if (ctx == NULL) {
131	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);	131	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
	@@ -144,7 +144,7 @@ int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCTX ctx, uint8_t key, uint32_t keyLen
144	return CRYPT_SUCCESS;	144	return CRYPT_SUCCESS;
145	}	145	}
146		146
147	-int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCTX *ctx)	147	+int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCtx *ctx)
148	{	148	{
149	if (ctx == NULL \|\| ctx->method.deinit == NULL) {	149	if (ctx == NULL \|\| ctx->method.deinit == NULL) {
150	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);	150	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
	@@ -155,7 +155,7 @@ int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCTX *ctx)
155	return CRYPT_SUCCESS;	155	return CRYPT_SUCCESS;
156	}	156	}
157		157
158	-void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx)	158	+void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCtx *ctx)
159	{	159	{
160	if (ctx == NULL) {	160	if (ctx == NULL) {
161	return;	161	return;
	@@ -169,7 +169,7 @@ void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx)
169	BSL_SAL_Free(ctx);	169	BSL_SAL_Free(ctx);
170	}	170	}
171		171
172	-int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCTX to, const CRYPT_EAL_KdfCTX from)	172	+int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCtx to, const CRYPT_EAL_KdfCtx from)
173	{	173	{
174	if (to == NULL \|\| from == NULL \|\| from->method.dupCtx == NULL) {	174	if (to == NULL \|\| from == NULL \|\| from->method.dupCtx == NULL) {
175	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);	175	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
	@@ -188,19 +188,19 @@ int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCTX to, const CRYPT_EAL_KdfCTX from)
188	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);	188	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
189	return CRYPT_MEM_ALLOC_FAIL;	189	return CRYPT_MEM_ALLOC_FAIL;
190	}	190	}
191	- (void)memcpy_s(to, sizeof(CRYPT_EAL_KdfCTX), from, sizeof(CRYPT_EAL_KdfCTX));	191	+ (void)memcpy_s(to, sizeof(CRYPT_EAL_KdfCtx), from, sizeof(CRYPT_EAL_KdfCtx));
192	to->data = newData;	192	to->data = newData;
193	return CRYPT_SUCCESS;	193	return CRYPT_SUCCESS;
194	}	194	}
195		195
196	-CRYPT_EAL_KdfCTX CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCTX from)	196	+CRYPT_EAL_KdfCtx CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCtx from)
197	{	197	{
198	if (from == NULL \|\| from->method.dupCtx == NULL) {	198	if (from == NULL \|\| from->method.dupCtx == NULL) {
199	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);	199	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
200	return NULL;	200	return NULL;
201	}	201	}
202		202
203	- CRYPT_EAL_KdfCTX *newCtx = BSL_SAL_Dump(from, sizeof(CRYPT_EAL_KdfCTX));	203	+ CRYPT_EAL_KdfCtx *newCtx = BSL_SAL_Dump(from, sizeof(CRYPT_EAL_KdfCtx));
204	if (newCtx == NULL ) {	204	if (newCtx == NULL ) {
205	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);	205	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
206	return NULL;	206	return NULL;

Mcrypto/eal/src/eal_md.c+20-23

	@@ -35,14 +35,11 @@
35	#include "crypt_provider.h"	35	#include "crypt_provider.h"
36	#endif	36	#endif
37		37
38	-static CRYPT_EAL_MdCTX MdNewCtxInner(CRYPT_MD_AlgId id, CRYPT_EAL_LibCtx libCtx, const char *attrName,	38	+static CRYPT_EAL_MdCtx MdNewCtxInner(CRYPT_MD_AlgId id, CRYPT_EAL_LibCtx libCtx, const char *attrName,
39	bool isProvider)	39	bool isProvider)
40	{	40	{
41	- (void)libCtx;
42	- (void)attrName;
43	- (void)isProvider;
44	EAL_MdMethod *method = NULL;	41	EAL_MdMethod *method = NULL;
45	- CRYPT_EAL_MdCTX *ctx = BSL_SAL_Malloc(sizeof(CRYPT_EAL_MdCTX));	42	+ CRYPT_EAL_MdCtx *ctx = BSL_SAL_Malloc(sizeof(CRYPT_EAL_MdCtx));
46	if (ctx == NULL) {	43	if (ctx == NULL) {
47	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, id, CRYPT_MEM_ALLOC_FAIL);	44	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, id, CRYPT_MEM_ALLOC_FAIL);
48	return NULL;	45	return NULL;
	@@ -69,7 +66,7 @@ ERR:
69	return NULL;	66	return NULL;
70	}	67	}
71		68
72	-CRYPT_EAL_MdCTX CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)	69	+CRYPT_EAL_MdCtx CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)
73	{	70	{
74	#ifdef HITLS_CRYPTO_PROVIDER	71	#ifdef HITLS_CRYPTO_PROVIDER
75	return MdNewCtxInner(algId, libCtx, attrName, true);	72	return MdNewCtxInner(algId, libCtx, attrName, true);
	@@ -80,7 +77,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t al
80	#endif	77	#endif
81	}	78	}
82		79
83	-CRYPT_EAL_MdCTX *CRYPT_EAL_MdNewCtx(CRYPT_MD_AlgId id)	80	+CRYPT_EAL_MdCtx *CRYPT_EAL_MdNewCtx(CRYPT_MD_AlgId id)
84	{	81	{
85	#ifdef HITLS_CRYPTO_ASM_CHECK	82	#ifdef HITLS_CRYPTO_ASM_CHECK
86	if (CRYPT_ASMCAP_Md(id) != CRYPT_SUCCESS) {	83	if (CRYPT_ASMCAP_Md(id) != CRYPT_SUCCESS) {
	@@ -97,7 +94,7 @@ bool CRYPT_EAL_MdIsValidAlgId(CRYPT_MD_AlgId id)
97	return EAL_MdFindDefaultMethod(id) != NULL;	94	return EAL_MdFindDefaultMethod(id) != NULL;
98	}	95	}
99		96
100	-int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCTX *ctx)	97	+int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCtx *ctx)
101	{	98	{
102	if (ctx == NULL) {	99	if (ctx == NULL) {
103	return CRYPT_MD_MAX;	100	return CRYPT_MD_MAX;
	@@ -105,7 +102,7 @@ int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCTX *ctx)
105	return ctx->id;	102	return ctx->id;
106	}	103	}
107		104
108	-int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCTX to, const CRYPT_EAL_MdCTX from)	105	+int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCtx to, const CRYPT_EAL_MdCtx from)
109	{	106	{
110	if (to == NULL) {	107	if (to == NULL) {
111	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	108	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -134,7 +131,7 @@ int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCTX to, const CRYPT_EAL_MdCTX from)
134	return CRYPT_SUCCESS;	131	return CRYPT_SUCCESS;
135	}	132	}
136		133
137	-CRYPT_EAL_MdCTX CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCTX ctx)	134	+CRYPT_EAL_MdCtx CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCtx ctx)
138	{	135	{
139	if (ctx == NULL) {	136	if (ctx == NULL) {
140	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	137	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -145,7 +142,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCTX ctx)
145	return NULL;	142	return NULL;
146	}	143	}
147		144
148	- CRYPT_EAL_MdCTX *newCtx = BSL_SAL_Malloc(sizeof(CRYPT_EAL_MdCTX));	145	+ CRYPT_EAL_MdCtx *newCtx = BSL_SAL_Malloc(sizeof(CRYPT_EAL_MdCtx));
149	if (newCtx == NULL) {	146	if (newCtx == NULL) {
150	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);	147	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
151	return NULL;	148	return NULL;
	@@ -160,7 +157,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCTX ctx)
160	return newCtx;	157	return newCtx;
161	}	158	}
162		159
163	-void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCTX *ctx)	160	+void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCtx *ctx)
164	{	161	{
165	if (ctx == NULL) {	162	if (ctx == NULL) {
166	return;	163	return;
	@@ -174,7 +171,7 @@ void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCTX *ctx)
174	BSL_SAL_Free(ctx);	171	BSL_SAL_Free(ctx);
175	}	172	}
176		173
177	-int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx)	174	+int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCtx *ctx)
178	{	175	{
179	if (ctx == NULL) {	176	if (ctx == NULL) {
180	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	177	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -194,7 +191,7 @@ int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx)
194	return CRYPT_SUCCESS;	191	return CRYPT_SUCCESS;
195	}	192	}
196		193
197	-int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data, uint32_t len)	194	+int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCtx ctx, const uint8_t data, uint32_t len)
198	{	195	{
199	if (ctx == NULL) {	196	if (ctx == NULL) {
200	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	197	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -220,7 +217,7 @@ int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data, uint32_t l
220	return CRYPT_SUCCESS;	217	return CRYPT_SUCCESS;
221	}	218	}
222		219
223	-int32_t CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t *len)	220	+int32_t CRYPT_EAL_MdFinal(CRYPT_EAL_MdCtx ctx, uint8_t out, uint32_t *len)
224	{	221	{
225	if (ctx == NULL) {	222	if (ctx == NULL) {
226	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	223	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -249,7 +246,7 @@ int32_t CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t *len)
249	return CRYPT_SUCCESS;	246	return CRYPT_SUCCESS;
250	}	247	}
251		248
252	-int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t len)	249	+int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCtx ctx, uint8_t out, uint32_t len)
253	{	250	{
254	if (ctx == NULL) {	251	if (ctx == NULL) {
255	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	252	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -274,7 +271,7 @@ int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t len)
274	return CRYPT_SUCCESS;	271	return CRYPT_SUCCESS;
275	}	272	}
276		273
277	-int32_t CRYPT_EAL_MdDeinit(CRYPT_EAL_MdCTX *ctx)	274	+int32_t CRYPT_EAL_MdDeinit(CRYPT_EAL_MdCtx *ctx)
278	{	275	{
279	if (ctx == NULL \|\| ctx->method.deinit == NULL) {	276	if (ctx == NULL \|\| ctx->method.deinit == NULL) {
280	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	277	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -335,7 +332,7 @@ int32_t CRYPT_EAL_ProviderMd(CRYPT_EAL_LibCtx *libCtx, CRYPT_MD_AlgId id, const
335		332
336	#ifdef HITLS_CRYPTO_MD_MB	333	#ifdef HITLS_CRYPTO_MD_MB
337		334
338	-CRYPT_EAL_MdCTX CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint32_t num)	335	+CRYPT_EAL_MdCtx CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint32_t num)
339	{	336	{
340	(void)libCtx;	337	(void)libCtx;
341	if (UNLIKELY(num == 0)) {	338	if (UNLIKELY(num == 0)) {
	@@ -356,7 +353,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint
356	return NULL;	353	return NULL;
357	}	354	}
358		355
359	- CRYPT_EAL_MdCTX *ctx = BSL_SAL_Calloc(1, sizeof(CRYPT_EAL_MdCTX));	356	+ CRYPT_EAL_MdCtx *ctx = BSL_SAL_Calloc(1, sizeof(CRYPT_EAL_MdCtx));
360	if (ctx == NULL) {	357	if (ctx == NULL) {
361	mbMethod.freeCtx(mbData);	358	mbMethod.freeCtx(mbData);
362	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, id, CRYPT_MEM_ALLOC_FAIL);	359	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, id, CRYPT_MEM_ALLOC_FAIL);
	@@ -370,7 +367,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint
370	return ctx;	367	return ctx;
371	}	368	}
372		369
373	-void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCTX *ctx)	370	+void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCtx *ctx)
374	{	371	{
375	if (ctx == NULL) {	372	if (ctx == NULL) {
376	return;	373	return;
	@@ -381,7 +378,7 @@ void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCTX *ctx)
381	BSL_SAL_Free(ctx);	378	BSL_SAL_Free(ctx);
382	}	379	}
383		380
384	-int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCTX *ctx)	381	+int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCtx *ctx)
385	{	382	{
386	if (UNLIKELY(ctx == NULL)) {	383	if (UNLIKELY(ctx == NULL)) {
387	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	384	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -402,7 +399,7 @@ int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCTX *ctx)
402	return ret;	399	return ret;
403	}	400	}
404		401
405	-int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data[], uint32_t nbytes[], uint32_t num)	402	+int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCtx ctx, const uint8_t data[], uint32_t nbytes[], uint32_t num)
406	{	403	{
407	if (UNLIKELY(ctx == NULL \|\| data == NULL \|\| nbytes == NULL \|\| num == 0)) {	404	if (UNLIKELY(ctx == NULL \|\| data == NULL \|\| nbytes == NULL \|\| num == 0)) {
408	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	405	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);
	@@ -426,7 +423,7 @@ int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data[], uint32
426	return ret;	423	return ret;
427	}	424	}
428		425
429	-int32_t CRYPT_EAL_MdMBFinal(CRYPT_EAL_MdCTX ctx, uint8_t digest[], uint32_t *outlen, uint32_t num)	426	+int32_t CRYPT_EAL_MdMBFinal(CRYPT_EAL_MdCtx ctx, uint8_t digest[], uint32_t *outlen, uint32_t num)
430	{	427	{
431	if (UNLIKELY(ctx == NULL \|\| digest == NULL \|\| outlen == NULL \|\| num == 0)) {	428	if (UNLIKELY(ctx == NULL \|\| digest == NULL \|\| outlen == NULL \|\| num == 0)) {
432	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);	429	EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MD, CRYPT_MD_MAX, CRYPT_NULL_INPUT);

Mcrypto/hpke/src/hpke.c+9-9

	@@ -73,7 +73,7 @@ struct CRYPT_EAL_HpkeCtx {
73	uint32_t exporterSecretLen;	73	uint32_t exporterSecretLen;
74	uint32_t sharedSecretLen;	74	uint32_t sharedSecretLen;
75	uint64_t seq; // Message sequence number	75	uint64_t seq; // Message sequence number
76	- CRYPT_EAL_KdfCTX *kdfCtx;	76	+ CRYPT_EAL_KdfCtx *kdfCtx;
77	CRYPT_EAL_CipherCtx *cipherCtx;	77	CRYPT_EAL_CipherCtx *cipherCtx;
78	CRYPT_EAL_LibCtx *libCtx;	78	CRYPT_EAL_LibCtx *libCtx;
79	char *attrName;	79	char *attrName;
	@@ -176,7 +176,7 @@ static int32_t HpkeCheckCipherSuite(const CRYPT_HPKE_CipherSuite *cipherSuite, u
176	static int32_t InitCipherSuiteCtx(CRYPT_EAL_HpkeCtx ctx, uint8_t aeadIndex, CRYPT_EAL_LibCtx libCtx,	176	static int32_t InitCipherSuiteCtx(CRYPT_EAL_HpkeCtx ctx, uint8_t aeadIndex, CRYPT_EAL_LibCtx libCtx,
177	const char *attrName)	177	const char *attrName)
178	{	178	{
179	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	179	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
180	CRYPT_EAL_CipherCtx *cipherCtx = NULL;	180	CRYPT_EAL_CipherCtx *cipherCtx = NULL;
181	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);	181	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
182	if (kdfCtx == NULL) {	182	if (kdfCtx == NULL) {
	@@ -422,7 +422,7 @@ typedef struct {
422	uint32_t infoLen;	422	uint32_t infoLen;
423	} HPKE_HkdfExpandParam;	423	} HPKE_HkdfExpandParam;
424		424
425	-static int32_t HpkeHkdfExtract(CRYPT_EAL_KdfCTX hkdfCtx, HPKE_HkdfExtractParams extractParams, uint8_t *out,	425	+static int32_t HpkeHkdfExtract(CRYPT_EAL_KdfCtx hkdfCtx, HPKE_HkdfExtractParams extractParams, uint8_t *out,
426	uint32_t outLen)	426	uint32_t outLen)
427	{	427	{
428	int32_t ret;	428	int32_t ret;
	@@ -468,7 +468,7 @@ static int32_t HpkeHkdfExtract(CRYPT_EAL_KdfCTX *hkdfCtx, HPKE_HkdfExtractParams
468	return ret;	468	return ret;
469	}	469	}
470		470
471	-static int32_t HpkeHkdfExpand(CRYPT_EAL_KdfCTX hkdfCtx, HPKE_HkdfExpandParam expandParams, uint8_t *out,	471	+static int32_t HpkeHkdfExpand(CRYPT_EAL_KdfCtx hkdfCtx, HPKE_HkdfExpandParam expandParams, uint8_t *out,
472	uint32_t outLen)	472	uint32_t outLen)
473	{	473	{
474	int32_t ret;	474	int32_t ret;
	@@ -532,7 +532,7 @@ typedef struct {
532	uint32_t suiteIdLen;	532	uint32_t suiteIdLen;
533	} HPKE_LabeledExpandParams;	533	} HPKE_LabeledExpandParams;
534		534
535	-static int32_t HpkeLabeledExtract(CRYPT_EAL_KdfCTX hkdfCtx, HPKE_LabeledExtractParams params, uint8_t *out,	535	+static int32_t HpkeLabeledExtract(CRYPT_EAL_KdfCtx hkdfCtx, HPKE_LabeledExtractParams params, uint8_t *out,
536	uint32_t outLen)	536	uint32_t outLen)
537	{	537	{
538	// labeled_ikm = "HPKE-v1" \|\| suite_id \|\| label \|\| ikm	538	// labeled_ikm = "HPKE-v1" \|\| suite_id \|\| label \|\| ikm
	@@ -566,7 +566,7 @@ static int32_t HpkeLabeledExtract(CRYPT_EAL_KdfCTX *hkdfCtx, HPKE_LabeledExtract
566	return ret;	566	return ret;
567	}	567	}
568		568
569	-static int32_t HpkeLabeledExpand(CRYPT_EAL_KdfCTX hkdfCtx, HPKE_LabeledExpandParams params, uint8_t *out,	569	+static int32_t HpkeLabeledExpand(CRYPT_EAL_KdfCtx hkdfCtx, HPKE_LabeledExpandParams params, uint8_t *out,
570	uint32_t outLen)	570	uint32_t outLen)
571	{	571	{
572	// labeled_info = I2OSP(L, 2) \|\| "HPKE-v1" \|\| suite_id \|\| label \|\| info	572	// labeled_info = I2OSP(L, 2) \|\| "HPKE-v1" \|\| suite_id \|\| label \|\| info
	@@ -1427,7 +1427,7 @@ static int32_t HpkeGetEccOrder(CRYPT_EAL_PkeyCtx pkey, BN_BigNum *order)
1427	return CRYPT_SUCCESS;	1427	return CRYPT_SUCCESS;
1428	}	1428	}
1429		1429
1430	-static int32_t HpkeExpandEccPriKey(CRYPT_EAL_PkeyCtx pkey, CRYPT_EAL_KdfCTX hkdfCtx, uint32_t kemIndex,	1430	+static int32_t HpkeExpandEccPriKey(CRYPT_EAL_PkeyCtx pkey, CRYPT_EAL_KdfCtx hkdfCtx, uint32_t kemIndex,
1431	HPKE_LabeledExpandParams params, uint8_t sk, uint32_t skLen)	1431	HPKE_LabeledExpandParams params, uint8_t sk, uint32_t skLen)
1432	{	1432	{
1433	BN_BigNum *order = NULL;	1433	BN_BigNum *order = NULL;
	@@ -1476,7 +1476,7 @@ static int32_t HpkeExpandEccPriKey(CRYPT_EAL_PkeyCtx pkey, CRYPT_EAL_KdfCTX hk
1476	return ret;	1476	return ret;
1477	}	1477	}
1478		1478
1479	-static int32_t DeriveSk(uint8_t kemIndex, CRYPT_EAL_KdfCTX kdfCtx, CRYPT_EAL_PkeyCtx pkey,	1479	+static int32_t DeriveSk(uint8_t kemIndex, CRYPT_EAL_KdfCtx kdfCtx, CRYPT_EAL_PkeyCtx pkey,
1480	HPKE_LabeledExpandParams expandParams, uint8_t sk, uint32_t skLen)	1480	HPKE_LabeledExpandParams expandParams, uint8_t sk, uint32_t skLen)
1481	{	1481	{
1482	if (g_hpkeKemAlgInfo[kemIndex].hpkeKemId == CRYPT_KEM_DHKEM_X25519_HKDF_SHA256) {	1482	if (g_hpkeKemAlgInfo[kemIndex].hpkeKemId == CRYPT_KEM_DHKEM_X25519_HKDF_SHA256) {
	@@ -1503,7 +1503,7 @@ static int32_t HpkeDeriveKeyPair(uint8_t kemIndex, uint8_t *ikm, uint32_t ikmLen
1503	CRYPT_MAC_AlgId macId = g_hpkeKemAlgInfo[kemIndex].macId;	1503	CRYPT_MAC_AlgId macId = g_hpkeKemAlgInfo[kemIndex].macId;
1504	uint32_t skLen = g_hpkeKemAlgInfo[kemIndex].privateKeyLen;	1504	uint32_t skLen = g_hpkeKemAlgInfo[kemIndex].privateKeyLen;
1505		1505
1506	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	1506	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
1507	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);	1507	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
1508	if (kdfCtx == NULL) {	1508	if (kdfCtx == NULL) {
1509	BSL_ERR_PUSH_ERROR(CRYPT_HPKE_FAILED_FETCH_KDF);	1509	BSL_ERR_PUSH_ERROR(CRYPT_HPKE_FAILED_FETCH_KDF);

Mcrypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_hkdf.c+1-1

	@@ -52,7 +52,7 @@ static bool CRYPT_CMVP_SelftestHkdfInternal(void libCtx, const char attrName)
52	uint8_t *expOut = NULL;	52	uint8_t *expOut = NULL;
53	uint8_t *out = NULL;	53	uint8_t *out = NULL;
54	uint32_t keyLen, saltLen, infoLen, expOutLen;	54	uint32_t keyLen, saltLen, infoLen, expOutLen;
55	- CRYPT_EAL_KdfCTX *ctx = NULL;	55	+ CRYPT_EAL_KdfCtx *ctx = NULL;
56	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;	56	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
57	CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;	57	CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
58		58

Mcrypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_kdftls12.c+1-1

	@@ -56,7 +56,7 @@ static bool CRYPT_CMVP_SelftestKdfTls12Internal(void libCtx, const char attrNa
56	uint8_t *expDk = NULL;	56	uint8_t *expDk = NULL;
57	uint8_t *dk = NULL;	57	uint8_t *dk = NULL;
58	uint32_t keyLen, labelLen, seedLen, expDkLen;	58	uint32_t keyLen, labelLen, seedLen, expDkLen;
59	- CRYPT_EAL_KdfCTX *ctx = NULL;	59	+ CRYPT_EAL_KdfCtx *ctx = NULL;
60	CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;	60	CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
61	key = CMVP_StringsToBins(KDF_TLS12_VECTOR.key, &keyLen);	61	key = CMVP_StringsToBins(KDF_TLS12_VECTOR.key, &keyLen);
62	GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);	62	GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);

Mcrypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_md.c+1-1

	@@ -161,7 +161,7 @@ static bool CRYPT_CMVP_SelftestMdInternal(void libCtx, const char attrName, CR
161	uint8_t *md = NULL;	161	uint8_t *md = NULL;
162	uint8_t *expectMd = NULL;	162	uint8_t *expectMd = NULL;
163	uint32_t msgLen, mdLen, expectMdLen;	163	uint32_t msgLen, mdLen, expectMdLen;
164	- CRYPT_EAL_MdCTX *ctx = NULL;	164	+ CRYPT_EAL_MdCtx *ctx = NULL;
165		165
166	const CMVP_HASH_VECTOR *hashVec = FindVectorById(id);	166	const CMVP_HASH_VECTOR *hashVec = FindVectorById(id);
167	if (hashVec == NULL \|\| hashVec->msg == NULL) {	167	if (hashVec == NULL \|\| hashVec->msg == NULL) {

Mcrypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_pbkdf2.c+1-1

	@@ -76,7 +76,7 @@ static bool CRYPT_CMVP_SelftestPbkdf2Internal(void libCtx, const char attrName
76	uint8_t *expOut = NULL;	76	uint8_t *expOut = NULL;
77	uint8_t *out = NULL;	77	uint8_t *out = NULL;
78	uint32_t expOutLen, pwLen, saltLen, iter;	78	uint32_t expOutLen, pwLen, saltLen, iter;
79	- CRYPT_EAL_KdfCTX *ctx = NULL;	79	+ CRYPT_EAL_KdfCtx *ctx = NULL;
80	const CMVP_PBKDF2_VECTOR *pbkdf2Vec = FindVectorById(id);	80	const CMVP_PBKDF2_VECTOR *pbkdf2Vec = FindVectorById(id);
81	if (pbkdf2Vec == NULL \|\| pbkdf2Vec->pw == NULL) {	81	if (pbkdf2Vec == NULL \|\| pbkdf2Vec->pw == NULL) {
82	return false;	82	return false;

Mcrypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_scrypt.c+1-1

	@@ -57,7 +57,7 @@ static bool CRYPT_CMVP_SelftestScryptInternal(void libCtx, const char attrName
57	uint32_t n = SCRYPT_VECTOR.n;	57	uint32_t n = SCRYPT_VECTOR.n;
58	uint32_t r = SCRYPT_VECTOR.r;	58	uint32_t r = SCRYPT_VECTOR.r;
59	uint32_t p = SCRYPT_VECTOR.p;	59	uint32_t p = SCRYPT_VECTOR.p;
60	- CRYPT_EAL_KdfCTX *ctx = NULL;	60	+ CRYPT_EAL_KdfCtx *ctx = NULL;
61	pw = CMVP_StringsToBins(SCRYPT_VECTOR.pw, &pwLen);	61	pw = CMVP_StringsToBins(SCRYPT_VECTOR.pw, &pwLen);
62	GOTO_ERR_IF_TRUE(pw == NULL, CRYPT_CMVP_COMMON_ERR);	62	GOTO_ERR_IF_TRUE(pw == NULL, CRYPT_CMVP_COMMON_ERR);
63	salt = CMVP_StringsToBins(SCRYPT_VECTOR.salt, &saltLen);	63	salt = CMVP_StringsToBins(SCRYPT_VECTOR.salt, &saltLen);

Mdocs/en/5_Developer Guide/1_Encryption and Integrity Protection Application Development Guide.md+1-1

	@@ -610,7 +610,7 @@ int main(void)
610	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);	610	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
611	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);	611	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
612		612
613	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	613	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
614	if (ctx == NULL) {	614	if (ctx == NULL) {
615	PrintLastError();	615	PrintLastError();
616	goto EXIT;	616	goto EXIT;

Mdocs/en/5_Developer Guide/4_provider Development Guide.md+4-4

Mdocs/zh/5_开发指南/1_加密完保应用开发指南.md+1-1

	@@ -610,7 +610,7 @@ int main(void)
610	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);	610	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
611	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);	611	BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
612		612
613	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	613	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
614	if (ctx == NULL) {	614	if (ctx == NULL) {
615	PrintLastError();	615	PrintLastError();
616	goto EXIT;	616	goto EXIT;

Mdocs/zh/5_开发指南/4_provider开发指南.md+4-4

	@@ -267,7 +267,7 @@ capabilities 提供了一种机制：使得应用程序可以获取provider支
267	assert(ret == CRYPT_SUCCESS);	267	assert(ret == CRYPT_SUCCESS);
268	...	268	...
269	// 实际使用时推荐使用eal层各类算法对外的包装接口,会自动进行查找算法并调用算法进行初始化等工作。	269	// 实际使用时推荐使用eal层各类算法对外的包装接口,会自动进行查找算法并调用算法进行初始化等工作。
270	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=no_hitls,type=hash");	270	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=no_hitls,type=hash");
271	assert(ctx != NULL);	271	assert(ctx != NULL);
272	...	272	...
273	```	273	```
	@@ -447,7 +447,7 @@ int main() {
447		447
448	// 调用hitls自带的算法库初始化方式：	448	// 调用hitls自带的算法库初始化方式：
449	// 步骤 1：调用eal层的md对外接口直接进行初始化	449	// 步骤 1：调用eal层的md对外接口直接进行初始化
450	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "provider=default");	450	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "provider=default");
451	ASSERT_TRUE(ctx != NULL);	451	ASSERT_TRUE(ctx != NULL);
452		452
453	-----------------------------------------------	453	-----------------------------------------------
	@@ -466,7 +466,7 @@ int main() {
466	ASSERT_TRUE(ret == CRYPT_SUCCESS);	466	ASSERT_TRUE(ret == CRYPT_SUCCESS);
467		467
468	// 步骤 4：调用eal层的md对外接口直接进行初始化	468	// 步骤 4：调用eal层的md对外接口直接进行初始化
469	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");	469	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");
470	ASSERT_TRUE(ctx != NULL);	470	ASSERT_TRUE(ctx != NULL);
471		471
472	-----------------------------------------------	472	-----------------------------------------------
	@@ -481,7 +481,7 @@ int main() {
481	ASSERT_TRUE(ret == CRYPT_SUCCESS);	481	ASSERT_TRUE(ret == CRYPT_SUCCESS);
482		482
483	// 步骤 3：调用eal层的md对外接口直接进行初始化	483	// 步骤 3：调用eal层的md对外接口直接进行初始化
484	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");	484	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");
485	ASSERT_TRUE(ctx != NULL);	485	ASSERT_TRUE(ctx != NULL);
486		486
487	------------------------------------------------------------------------------------------------------	487	------------------------------------------------------------------------------------------------------

Minclude/auth/auth_pake.h+3-3

	@@ -117,7 +117,7 @@ void HITLS_AUTH_PakeFreeCtx(HITLS_AUTH_PakeCtx *ctx);
117	* @retval #HITLS_AUTH_SUCCESS if successful	117	* @retval #HITLS_AUTH_SUCCESS if successful
118	* Other error codes defined in hitls_errno.h if an error occurs	118	* Other error codes defined in hitls_errno.h if an error occurs
119	*/	119	*/
120	-int32_t HITLS_AUTH_Pake_Ctrl(HITLS_AUTH_PakeCtx ctx, HITLS_AUTH_PAKE_CtrlCmd cmd, CRYPT_EAL_KdfCTX kdfctx,	120	+int32_t HITLS_AUTH_Pake_Ctrl(HITLS_AUTH_PakeCtx ctx, HITLS_AUTH_PAKE_CtrlCmd cmd, CRYPT_EAL_KdfCtx kdfctx,
121	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2);	121	BSL_Buffer in0, BSL_Buffer in1, BSL_Buffer in2);
122		122
123	/**	123	/**
	@@ -185,9 +185,9 @@ int32_t HITLS_AUTH_PakeRespDerive(HITLS_AUTH_PakeCtx *ctx, BSL_Buffer in0, BSL_B
185	* @param ctx [IN] PAKE context	185	* @param ctx [IN] PAKE context
186	* @param kdf [IN] KDF algorithm configuration	186	* @param kdf [IN] KDF algorithm configuration
187	*	187	*
188	- * @retval #CRYPT_EAL_KdfCTX pointer if successful, NULL if failed	188	+ * @retval #CRYPT_EAL_KdfCtx pointer if successful, NULL if failed
189	*/	189	*/
190	-CRYPT_EAL_KdfCTX* HITLS_AUTH_PakeGetKdfCtx(HITLS_AUTH_PakeCtx* ctx, HITLS_AUTH_PAKE_KDF kdf);	190	+CRYPT_EAL_KdfCtx* HITLS_AUTH_PakeGetKdfCtx(HITLS_AUTH_PakeCtx* ctx, HITLS_AUTH_PAKE_KDF kdf);
191	#ifdef __cplusplus	191	#ifdef __cplusplus
192	}	192	}
193	#endif // __cplusplus	193	#endif // __cplusplus

Minclude/crypto/crypt_eal_kdf.h+12-10

	@@ -32,7 +32,9 @@
32	extern "C" {	32	extern "C" {
33	#endif // __cplusplus	33	#endif // __cplusplus
34		34
35	-typedef struct EalKdfCtx CRYPT_EAL_KdfCTX;	35	+typedef struct EalKdfCtx CRYPT_EAL_KdfCtx;
		36	+
		37	+#define CRYPT_EAL_KdfCTX CRYPT_EAL_KdfCtx
36		38
37	/**	39	/**
38	* @ingroup crypt_eal_kdf	40	* @ingroup crypt_eal_kdf
	@@ -55,7 +57,7 @@ bool CRYPT_EAL_KdfIsValidAlgId(CRYPT_KDF_AlgId id);
55	* @retval Success: kdf ctx.	57	* @retval Success: kdf ctx.
56	* Fails: NULL.	58	* Fails: NULL.
57	*/	59	*/
58	-CRYPT_EAL_KdfCTX CRYPT_EAL_ProviderKdfNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName);	60	+CRYPT_EAL_KdfCtx CRYPT_EAL_ProviderKdfNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName);
59		61
60	/**	62	/**
61	* @ingroup crypt_eal_kdf	63	* @ingroup crypt_eal_kdf
	@@ -64,7 +66,7 @@ CRYPT_EAL_KdfCTX CRYPT_EAL_ProviderKdfNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t
64	* @retval Success: kdf ctx.	66	* @retval Success: kdf ctx.
65	* Fails: NULL.	67	* Fails: NULL.
66	*/	68	*/
67	-CRYPT_EAL_KdfCTX *CRYPT_EAL_KdfNewCtx(CRYPT_KDF_AlgId algId);	69	+CRYPT_EAL_KdfCtx *CRYPT_EAL_KdfNewCtx(CRYPT_KDF_AlgId algId);
68		70
69	/**	71	/**
70	* @ingroup crypt_eal_kdf	72	* @ingroup crypt_eal_kdf
	@@ -76,7 +78,7 @@ CRYPT_EAL_KdfCTX *CRYPT_EAL_KdfNewCtx(CRYPT_KDF_AlgId algId);
76	* @retval CRYPT_SUCCESS	78	* @retval CRYPT_SUCCESS
77	* For other error codes, see crypt_errno.h.	79	* For other error codes, see crypt_errno.h.
78	*/	80	*/
79	-int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCTX ctx, const BSL_Param param);	81	+int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCtx ctx, const BSL_Param param);
80		82
81	/**	83	/**
82	* @ingroup crypt_eal_kdf	84	* @ingroup crypt_eal_kdf
	@@ -89,7 +91,7 @@ int32_t CRYPT_EAL_KdfSetParam(CRYPT_EAL_KdfCTX ctx, const BSL_Param param);
89	* @retval CRYPT_SUCCESS	91	* @retval CRYPT_SUCCESS
90	* For other error codes, see crypt_errno.h.	92	* For other error codes, see crypt_errno.h.
91	*/	93	*/
92	-int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCTX ctx, uint8_t key, uint32_t keyLen);	94	+int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCtx ctx, uint8_t key, uint32_t keyLen);
93		95
94	/**	96	/**
95	* @ingroup crypt_eal_kdf	97	* @ingroup crypt_eal_kdf
	@@ -100,7 +102,7 @@ int32_t CRYPT_EAL_KdfDerive(CRYPT_EAL_KdfCTX ctx, uint8_t key, uint32_t keyLen
100	* @retval CRYPT_SUCCESS	102	* @retval CRYPT_SUCCESS
101	* For other error codes, see crypt_errno.h.	103	* For other error codes, see crypt_errno.h.
102	*/	104	*/
103	-int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCTX *ctx);	105	+int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCtx *ctx);
104		106
105	/**	107	/**
106	* @ingroup crypt_eal_kdf	108	* @ingroup crypt_eal_kdf
	@@ -109,7 +111,7 @@ int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCTX *ctx);
109	* @param ctx [IN] kdf context	111	* @param ctx [IN] kdf context
110	*	112	*
111	*/	113	*/
112	-void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx);	114	+void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCtx *ctx);
113		115
114	/**	116	/**
115	* @ingroup crypt_eal_kdf	117	* @ingroup crypt_eal_kdf
	@@ -120,17 +122,17 @@ void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx);
120	* @param to [OUT] kdf context	122	* @param to [OUT] kdf context
121	*	123	*
122	*/	124	*/
123	-int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCTX to, const CRYPT_EAL_KdfCTX from);	125	+int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCtx to, const CRYPT_EAL_KdfCtx from);
124		126
125	/**	127	/**
126	* @ingroup crypt_eal_kdf	128	* @ingroup crypt_eal_kdf
127	* @brief Dup the kdf context.	129	* @brief Dup the kdf context.
128	*	130	*
129	* @param from [IN] original kdf context.	131	* @param from [IN] original kdf context.
130	- * @retval CRYPT_EAL_KdfCTX, kdf context pointer.	132	+ * @retval CRYPT_EAL_KdfCtx, kdf context pointer.
131	* NULL, if the operation fails.	133	* NULL, if the operation fails.
132	*/	134	*/
133	-CRYPT_EAL_KdfCTX CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCTX from);	135	+CRYPT_EAL_KdfCtx CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCtx from);
134		136
135	#ifdef __cplusplus	137	#ifdef __cplusplus
136	}	138	}

Minclude/crypto/crypt_eal_md.h+22-21

	@@ -31,7 +31,9 @@
31	extern "C" {	31	extern "C" {
32	#endif // __cplusplus	32	#endif // __cplusplus
33		33
34	-typedef struct EAL_MdCtx CRYPT_EAL_MdCTX;	34	+typedef struct EAL_MdCtx CRYPT_EAL_MdCtx;
		35	+
		36	+#define CRYPT_EAL_MdCTX CRYPT_EAL_MdCtx
35		37
36	/**	38	/**
37	* @ingroup crypt_eal_md	39	* @ingroup crypt_eal_md
	@@ -40,10 +42,10 @@ typedef struct EAL_MdCtx CRYPT_EAL_MdCTX;
40	* After the calculation is complete, call the CRYPT_EAL_MdFreeCtx interface to release the memory.	42	* After the calculation is complete, call the CRYPT_EAL_MdFreeCtx interface to release the memory.
41	*	43	*
42	* @param id [IN] Algorithm ID	44	* @param id [IN] Algorithm ID
43	- * @retval CRYPT_EAL_MdCTX, MD context pointer.	45	+ * @retval CRYPT_EAL_MdCtx, MD context pointer.
44	* NULL, if the operation fails.	46	* NULL, if the operation fails.
45	*/	47	*/
46	-CRYPT_EAL_MdCTX *CRYPT_EAL_MdNewCtx(CRYPT_MD_AlgId id);	48	+CRYPT_EAL_MdCtx *CRYPT_EAL_MdNewCtx(CRYPT_MD_AlgId id);
47		49
48	/**	50	/**
49	* @ingroup crypt_eal_md	51	* @ingroup crypt_eal_md
	@@ -56,7 +58,7 @@ CRYPT_EAL_MdCTX *CRYPT_EAL_MdNewCtx(CRYPT_MD_AlgId id);
56	* @retval CRYPT_EAL_PkeyCtx pointer.	58	* @retval CRYPT_EAL_PkeyCtx pointer.
57	* NULL, if the operation fails.	59	* NULL, if the operation fails.
58	*/	60	*/
59	-CRYPT_EAL_MdCTX CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName);	61	+CRYPT_EAL_MdCtx CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName);
60		62
61	/**	63	/**
62	* @ingroup crypt_eal_md	64	* @ingroup crypt_eal_md
	@@ -76,7 +78,7 @@ bool CRYPT_EAL_MdIsValidAlgId(CRYPT_MD_AlgId id);
76	* @retval ID, MD algorithm ID.	78	* @retval ID, MD algorithm ID.
77	* CRYPT_MD_MAX, which indicates invalid ID or the input parameter is null.	79	* CRYPT_MD_MAX, which indicates invalid ID or the input parameter is null.
78	*/	80	*/
79	-int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCTX *ctx);	81	+int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCtx *ctx);
80		82
81	/**	83	/**
82	* @ingroup crypt_eal_md	84	* @ingroup crypt_eal_md
	@@ -87,7 +89,7 @@ int32_t CRYPT_EAL_MdGetId(CRYPT_EAL_MdCTX *ctx);
87	* @retval CRYPT_SUCCESS	89	* @retval CRYPT_SUCCESS
88	* For other error codes, see crypt_errno.h.	90	* For other error codes, see crypt_errno.h.
89	*/	91	*/
90	-int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCTX to, const CRYPT_EAL_MdCTX from);	92	+int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCtx to, const CRYPT_EAL_MdCtx from);
91		93
92	/**	94	/**
93	* @ingroup crypt_eal_md	95	* @ingroup crypt_eal_md
	@@ -96,10 +98,10 @@ int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCTX to, const CRYPT_EAL_MdCTX from);
96	* Note that need to call the CRYPT_EAL_MdFreeCtx interface to release the memory after the duplication is complete.	98	* Note that need to call the CRYPT_EAL_MdFreeCtx interface to release the memory after the duplication is complete.
97	*	99	*
98	* @param ctx [IN] Source MD context	100	* @param ctx [IN] Source MD context
99	- * @retval CRYPT_EAL_MdCTX, MD context pointer.	101	+ * @retval CRYPT_EAL_MdCtx, MD context pointer.
100	* NULL, if the operation fails.	102	* NULL, if the operation fails.
101	*/	103	*/
102	-CRYPT_EAL_MdCTX CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCTX ctx);	104	+CRYPT_EAL_MdCtx CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCtx ctx);
103		105
104	/**	106	/**
105	* @ingroup crypt_eal_md	107	* @ingroup crypt_eal_md
	@@ -109,7 +111,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdDupCtx(const CRYPT_EAL_MdCTX ctx);
109	* NULL by caller.	111	* NULL by caller.
110	* @retval Void, no return value.	112	* @retval Void, no return value.
111	*/	113	*/
112	-void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCTX *ctx);	114	+void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCtx *ctx);
113		115
114	/**	116	/**
115	* @ingroup crypt_eal_md	117	* @ingroup crypt_eal_md
	@@ -119,7 +121,7 @@ void CRYPT_EAL_MdFreeCtx(CRYPT_EAL_MdCTX *ctx);
119	* @retval CRYPT_SUCCESS	121	* @retval CRYPT_SUCCESS
120	* For other error codes, see crypt_errno.h.	122	* For other error codes, see crypt_errno.h.
121	*/	123	*/
122	-int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx);	124	+int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCtx *ctx);
123		125
124	/**	126	/**
125	* @ingroup crypt_eal_md	127	* @ingroup crypt_eal_md
	@@ -134,7 +136,7 @@ int32_t CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx);
134	* @retval CRYPT_SUCCESS	136	* @retval CRYPT_SUCCESS
135	* For other error codes, see crypt_errno.h.	137	* For other error codes, see crypt_errno.h.
136	*/	138	*/
137	-int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data, uint32_t len);	139	+int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCtx ctx, const uint8_t data, uint32_t len);
138		140
139	/**	141	/**
140	* @ingroup crypt_eal_md	142	* @ingroup crypt_eal_md
	@@ -150,7 +152,7 @@ int32_t CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data, uint32_t l
150	* @retval CRYPT_E_SHORT_BUFFER if output buffer is too small	152	* @retval CRYPT_E_SHORT_BUFFER if output buffer is too small
151	* For other error codes, see crypt_errno.h	153	* For other error codes, see crypt_errno.h
152	*/	154	*/
153	-int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t len);	155	+int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCtx ctx, uint8_t out, uint32_t len);
154		156
155	/**	157	/**
156	* @ingroup crypt_eal_md	158	* @ingroup crypt_eal_md
	@@ -166,7 +168,7 @@ int32_t CRYPT_EAL_MdSqueeze(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t len);
166	* @retval CRYPT_SUCCESS	168	* @retval CRYPT_SUCCESS
167	* For other error codes, see crypt_errno.h.	169	* For other error codes, see crypt_errno.h.
168	*/	170	*/
169	-int32_t CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t *len);	171	+int32_t CRYPT_EAL_MdFinal(CRYPT_EAL_MdCtx ctx, uint8_t out, uint32_t *len);
170		172
171	/**	173	/**
172	* @ingroup crypt_eal_md	174	* @ingroup crypt_eal_md
	@@ -219,8 +221,7 @@ int32_t CRYPT_EAL_ProviderMd(CRYPT_EAL_LibCtx *libCtx, CRYPT_MD_AlgId id, const
219	*	221	*
220	* @param ctx [IN] Md Context	222	* @param ctx [IN] Md Context
221	*/	223	*/
222	-int32_t CRYPT_EAL_MdDeinit(CRYPT_EAL_MdCTX *ctx);	224	+int32_t CRYPT_EAL_MdDeinit(CRYPT_EAL_MdCtx *ctx);
223	-
224		225
225	/**	226	/**
226	* @ingroup crypt_eal_md	227	* @ingroup crypt_eal_md
	@@ -237,10 +238,10 @@ int32_t CRYPT_EAL_MdDeinit(CRYPT_EAL_MdCTX *ctx);
237	* @param libCtx [IN] Library context (reserved, currently unused).	238	* @param libCtx [IN] Library context (reserved, currently unused).
238	* @param id [IN] MD algorithm ID (e.g. #CRYPT_MD_SHA256).	239	* @param id [IN] MD algorithm ID (e.g. #CRYPT_MD_SHA256).
239	* @param num [IN] Number of contexts/messages.	240	* @param num [IN] Number of contexts/messages.
240	- * @retval CRYPT_EAL_MdCTX pointer on success.	241	+ * @retval CRYPT_EAL_MdCtx pointer on success.
241	* NULL if memory allocation fails or input is invalid.	242	* NULL if memory allocation fails or input is invalid.
242	*/	243	*/
243	-CRYPT_EAL_MdCTX CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint32_t num);	244	+CRYPT_EAL_MdCtx CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint32_t num);
244		245
245	/**	246	/**
246	* @ingroup crypt_eal_md	247	* @ingroup crypt_eal_md
	@@ -248,7 +249,7 @@ CRYPT_EAL_MdCTX CRYPT_EAL_MdMBNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t id, uint
248	*	249	*
249	* @param ctx [IN] MB context pointer.	250	* @param ctx [IN] MB context pointer.
250	*/	251	*/
251	-void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCTX *ctx);	252	+void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCtx *ctx);
252		253
253	/**	254	/**
254	* @ingroup crypt_eal_md	255	* @ingroup crypt_eal_md
	@@ -260,7 +261,7 @@ void CRYPT_EAL_MdMBFreeCtx(CRYPT_EAL_MdCTX *ctx);
260	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode.	261	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode.
261	* For other error codes, see crypt_errno.h.	262	* For other error codes, see crypt_errno.h.
262	*/	263	*/
263	-int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCTX *ctx);	264	+int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCtx *ctx);
264		265
265	/**	266	/**
266	* @ingroup crypt_eal_md	267	* @ingroup crypt_eal_md
	@@ -279,7 +280,7 @@ int32_t CRYPT_EAL_MdMBInit(CRYPT_EAL_MdCTX *ctx);
279	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode or the nbytes are not equal.	280	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode or the nbytes are not equal.
280	* For other error codes, see crypt_errno.h.	281	* For other error codes, see crypt_errno.h.
281	*/	282	*/
282	-int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data[], uint32_t nbytes[], uint32_t num);	283	+int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCtx ctx, const uint8_t data[], uint32_t nbytes[], uint32_t num);
283		284
284	/**	285	/**
285	* @ingroup crypt_eal_md	286	* @ingroup crypt_eal_md
	@@ -297,7 +298,7 @@ int32_t CRYPT_EAL_MdMBUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data[], uint32
297	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode.	298	* #CRYPT_NOT_SUPPORT if the algorithm does not support multi-buffer mode.
298	* For other error codes, see crypt_errno.h.	299	* For other error codes, see crypt_errno.h.
299	*/	300	*/
300	-int32_t CRYPT_EAL_MdMBFinal(CRYPT_EAL_MdCTX ctx, uint8_t digest[], uint32_t *outlen, uint32_t num);	301	+int32_t CRYPT_EAL_MdMBFinal(CRYPT_EAL_MdCtx ctx, uint8_t digest[], uint32_t *outlen, uint32_t num);
301		302
302	#ifdef __cplusplus	303	#ifdef __cplusplus
303	}	304	}

Mpki/cms/include/hitls_cms_local.h+1-1

	@@ -39,7 +39,7 @@ extern "C" {
39	typedef struct {	39	typedef struct {
40	int32_t id; /*< Algorithm OID /	40	int32_t id; /*< Algorithm OID /
41	BSL_Buffer param; /*< Algorithm parameters (optional) /	41	BSL_Buffer param; /*< Algorithm parameters (optional) /
42	- CRYPT_EAL_MdCTX mdCtx; /< Message digest context for streaming signature /	42	+ CRYPT_EAL_MdCtx mdCtx; /< Message digest context for streaming signature /
43	} CMS_AlgId;	43	} CMS_AlgId;
44		44
45	/**	45	/**

Mpki/cms/src/hitls_cms_signdata.c+2-2

	@@ -2318,9 +2318,9 @@ static int32_t SignedData_SignUpdate(HITLS_CMS cms, const BSL_Buffer msg)
2318	}	2318	}
2319		2319
2320	// Get digest from MD context	2320	// Get digest from MD context
2321	-static int32_t GetDigestValue(CRYPT_EAL_MdCTX mdCtx, uint8_t hash, uint32_t *hashLen)	2321	+static int32_t GetDigestValue(CRYPT_EAL_MdCtx mdCtx, uint8_t hash, uint32_t *hashLen)
2322	{	2322	{
2323	- CRYPT_EAL_MdCTX *tmp = CRYPT_EAL_MdDupCtx(mdCtx);	2323	+ CRYPT_EAL_MdCtx *tmp = CRYPT_EAL_MdDupCtx(mdCtx);
2324	if (tmp == NULL) {	2324	if (tmp == NULL) {
2325	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);	2325	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
2326	return BSL_MALLOC_FAIL;	2326	return BSL_MALLOC_FAIL;

Mpki/cms/src/hitls_cms_util.h+4-0

	@@ -21,6 +21,10 @@
21	#include "bsl_asn1_internal.h"	21	#include "bsl_asn1_internal.h"
22	#include "bsl_obj.h"	22	#include "bsl_obj.h"
23		23
		24	+#ifdef __cplusplus
		25	+extern "C" {
		26	+#endif /* __cplusplus */
		27	+
24	/**	28	/**
25	* @brief Get default digest algorithm for ML-DSA variant	29	* @brief Get default digest algorithm for ML-DSA variant
26	* @param mldsaVariant ML-DSA variant CID	30	* @param mldsaVariant ML-DSA variant CID

Mpki/pkcs12/src/hitls_pkcs12_util.c+2-2

	@@ -349,7 +349,7 @@ static int32_t InitKdfParam(const Pkcs12KdfParam param, uint8_t D, uint8_t *
349	return HITLS_PKI_SUCCESS;	349	return HITLS_PKI_SUCCESS;
350	}	350	}
351		351
352	-static int32_t MacLoop(uint32_t LoopTimes, CRYPT_EAL_MdCTX ctx, const Pkcs12KdfParam param, uint8_t *D,	352	+static int32_t MacLoop(uint32_t LoopTimes, CRYPT_EAL_MdCtx ctx, const Pkcs12KdfParam param, uint8_t *D,
353	uint8_t I, uint8_t A, uint32_t k, uint32_t dataLen)	353	uint8_t I, uint8_t A, uint32_t k, uint32_t dataLen)
354	{	354	{
355	int32_t ret;	355	int32_t ret;
	@@ -442,7 +442,7 @@ int32_t HITLS_PKCS12_KDF(HITLS_PKCS12 p12, const uint8_t pwd, uint32_t pwdLen,
442	BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_ALGO);	442	BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_ALGO);
443	return HITLS_PKCS12_ERR_INVALID_ALGO;	443	return HITLS_PKCS12_ERR_INVALID_ALGO;
444	}	444	}
445	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(p12->libCtx, (CRYPT_MD_AlgId)macData->alg, p12->attrName);	445	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(p12->libCtx, (CRYPT_MD_AlgId)macData->alg, p12->attrName);
446	if (ctx == NULL) {	446	if (ctx == NULL) {
447	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);	447	BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
448	return BSL_MALLOC_FAIL;	448	return BSL_MALLOC_FAIL;

Mpki/x509_verify/src/hitls_x509_verify.c+1-1

	@@ -804,7 +804,7 @@ static int32_t HITLS_X509_GetCertBySubjectDer(HITLS_X509_StoreCtx *storeCtx, con
804	uint8_t digest[CRYPT_SHA1_DIGESTSIZE];	804	uint8_t digest[CRYPT_SHA1_DIGESTSIZE];
805	uint32_t digestLen = CRYPT_SHA1_DIGESTSIZE;	805	uint32_t digestLen = CRYPT_SHA1_DIGESTSIZE;
806	int32_t ret = HITLS_PKI_SUCCESS;	806	int32_t ret = HITLS_PKI_SUCCESS;
807	- CRYPT_EAL_MdCTX *mdCtx = CRYPT_EAL_ProviderMdNewCtx(storeCtx->libCtx, CRYPT_MD_SHA1, storeCtx->attrName);	807	+ CRYPT_EAL_MdCtx *mdCtx = CRYPT_EAL_ProviderMdNewCtx(storeCtx->libCtx, CRYPT_MD_SHA1, storeCtx->attrName);
808	if (mdCtx != NULL) {	808	if (mdCtx != NULL) {
809	if (CRYPT_EAL_MdInit(mdCtx) == CRYPT_SUCCESS &&	809	if (CRYPT_EAL_MdInit(mdCtx) == CRYPT_SUCCESS &&
810	CRYPT_EAL_MdUpdate(mdCtx, subjectDerData->buff, subjectDerData->len) == CRYPT_SUCCESS) {	810	CRYPT_EAL_MdUpdate(mdCtx, subjectDerData->buff, subjectDerData->len) == CRYPT_SUCCESS) {

Mtestcode/demo/hash.c+1-1

	@@ -35,7 +35,7 @@ void PrintLastError(void) {
35	int main(void)	35	int main(void)
36	{	36	{
37	int ret = 0;	37	int ret = 0;
38	- CRYPT_EAL_MdCTX *ctx = NULL;	38	+ CRYPT_EAL_MdCtx *ctx = NULL;
39	uint8_t digest[32] = {0};	39	uint8_t digest[32] = {0};
40	unsigned int digestLen = 32;	40	unsigned int digestLen = 32;
41	uint8_t data[] = {0x1b, 0x50, 0x3f, 0xb9, 0xa7, 0x3b, 0x16, 0xad, 0xa3,	41	uint8_t data[] = {0x1b, 0x50, 0x3f, 0xb9, 0xa7, 0x3b, 0x16, 0xad, 0xa3,

Mtestcode/demo/pbkdf2.c+1-1

	@@ -53,7 +53,7 @@ int main(void)
53	uint8_t out[sizeof(result)] = {0};	53	uint8_t out[sizeof(result)] = {0};
54	uint32_t outLen = sizeof(result);	54	uint32_t outLen = sizeof(result);
55		55
56	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	56	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
57	if (ctx == NULL) {	57	if (ctx == NULL) {
58	PrintLastError();	58	PrintLastError();
59	goto EXIT;	59	goto EXIT;

Mtestcode/sdv/testcase/apps/test_suite_ut_dgst.c+8-8

	@@ -39,10 +39,10 @@ STUB_DEFINE_RET4(int32_t, BSL_UIO_Ctrl, BSL_UIO , int32_t, int32_t, void );
39	STUB_DEFINE_RET0(char *, HITLS_APP_OptGetValueStr);	39	STUB_DEFINE_RET0(char *, HITLS_APP_OptGetValueStr);
40	STUB_DEFINE_RET4(int32_t, HITLS_APP_OptWriteUio, BSL_UIO , uint8_t , uint32_t, int32_t);	40	STUB_DEFINE_RET4(int32_t, HITLS_APP_OptWriteUio, BSL_UIO , uint8_t , uint32_t, int32_t);
41	STUB_DEFINE_RET1(uint32_t, CRYPT_EAL_MdGetDigestSize, CRYPT_MD_AlgId);	41	STUB_DEFINE_RET1(uint32_t, CRYPT_EAL_MdGetDigestSize, CRYPT_MD_AlgId);
42	-STUB_DEFINE_RET3(CRYPT_EAL_MdCTX , CRYPT_EAL_ProviderMdNewCtx, CRYPT_EAL_LibCtx , int32_t, const char *);	42	+STUB_DEFINE_RET3(CRYPT_EAL_MdCtx , CRYPT_EAL_ProviderMdNewCtx, CRYPT_EAL_LibCtx , int32_t, const char *);
43	-STUB_DEFINE_RET1(int32_t, CRYPT_EAL_MdInit, CRYPT_EAL_MdCTX *);	43	+STUB_DEFINE_RET1(int32_t, CRYPT_EAL_MdInit, CRYPT_EAL_MdCtx *);
44	-STUB_DEFINE_RET3(int32_t, CRYPT_EAL_MdUpdate, CRYPT_EAL_MdCTX , const uint8_t , uint32_t);	44	+STUB_DEFINE_RET3(int32_t, CRYPT_EAL_MdUpdate, CRYPT_EAL_MdCtx , const uint8_t , uint32_t);
45	-STUB_DEFINE_RET3(int32_t, CRYPT_EAL_MdFinal, CRYPT_EAL_MdCTX , uint8_t , uint32_t *);	45	+STUB_DEFINE_RET3(int32_t, CRYPT_EAL_MdFinal, CRYPT_EAL_MdCtx , uint8_t , uint32_t *);
46		46
47		47
48	#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"	48	#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"
	@@ -387,7 +387,7 @@ EXIT:
387	}	387	}
388	/* END_CASE */	388	/* END_CASE */
389		389
390	-CRYPT_EAL_MdCTX STUB_CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)	390	+CRYPT_EAL_MdCtx STUB_CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx libCtx, int32_t algId, const char *attrName)
391	{	391	{
392	(void)algId;	392	(void)algId;
393	(void)attrName;	393	(void)attrName;
	@@ -423,7 +423,7 @@ EXIT:
423	}	423	}
424	/* END_CASE */	424	/* END_CASE */
425		425
426	-int32_t STUB_CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx){	426	+int32_t STUB_CRYPT_EAL_MdInit(CRYPT_EAL_MdCtx *ctx){
427	(void)ctx;	427	(void)ctx;
428	return HITLS_APP_CRYPTO_FAIL;	428	return HITLS_APP_CRYPTO_FAIL;
429	}	429	}
	@@ -456,7 +456,7 @@ EXIT:
456	}	456	}
457	/* END_CASE */	457	/* END_CASE */
458		458
459	-int32_t STUB_CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX ctx, const uint8_t data, uint32_t len){	459	+int32_t STUB_CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCtx ctx, const uint8_t data, uint32_t len){
460	(void)ctx;	460	(void)ctx;
461	(void)data;	461	(void)data;
462	(void)len;	462	(void)len;
	@@ -491,7 +491,7 @@ EXIT:
491	}	491	}
492	/* END_CASE */	492	/* END_CASE */
493		493
494	-int32_t STUB_CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX ctx, uint8_t out, uint32_t *len){	494	+int32_t STUB_CRYPT_EAL_MdFinal(CRYPT_EAL_MdCtx ctx, uint8_t out, uint32_t *len){
495	(void)ctx;	495	(void)ctx;
496	(void)out;	496	(void)out;
497	(void)len;	497	(void)len;

Mtestcode/sdv/testcase/auth/pake/test_suite_sdv_pake.c+2-2

	@@ -103,7 +103,7 @@ void SDV_CRYPT_EAL_SPAKE2PLUS_TC001(Hex context, Hex prover, Hex *verifier, in
103	BSL_Buffer emptyBuf0 = { 0 };	103	BSL_Buffer emptyBuf0 = { 0 };
104	BSL_Buffer emptyBuf1 = { 0 };	104	BSL_Buffer emptyBuf1 = { 0 };
105	BSL_Buffer emptyBuf2 = { 0 };	105	BSL_Buffer emptyBuf2 = { 0 };
106	- CRYPT_EAL_KdfCTX* kdfCtxTmp = HITLS_AUTH_PakeGetKdfCtx(ctx2, kdfParam);	106	+ CRYPT_EAL_KdfCtx* kdfCtxTmp = HITLS_AUTH_PakeGetKdfCtx(ctx2, kdfParam);
107	ASSERT_TRUE(kdfCtxTmp != NULL);	107	ASSERT_TRUE(kdfCtxTmp != NULL);
108	ASSERT_EQ(HITLS_AUTH_Pake_Ctrl(ctx2, HITLS_AUTH_PAKE_REQ_REGISTER, kdfCtxTmp, emptyBuf0, emptyBuf1, emptyBuf2),	108	ASSERT_EQ(HITLS_AUTH_Pake_Ctrl(ctx2, HITLS_AUTH_PAKE_REQ_REGISTER, kdfCtxTmp, emptyBuf0, emptyBuf1, emptyBuf2),
109	HITLS_AUTH_SUCCESS);	109	HITLS_AUTH_SUCCESS);
	@@ -115,7 +115,7 @@ void SDV_CRYPT_EAL_SPAKE2PLUS_TC001(Hex context, Hex prover, Hex *verifier, in
115	passwordBuf, proverBuf, verifierBuf, contextBuf);	115	passwordBuf, proverBuf, verifierBuf, contextBuf);
116	ASSERT_TRUE(ctx1 != NULL);	116	ASSERT_TRUE(ctx1 != NULL);
117		117
118	- CRYPT_EAL_KdfCTX* kdfCtx = HITLS_AUTH_PakeGetKdfCtx(ctx2, kdfParam);	118	+ CRYPT_EAL_KdfCtx* kdfCtx = HITLS_AUTH_PakeGetKdfCtx(ctx2, kdfParam);
119	ASSERT_TRUE(kdfCtx != NULL);	119	ASSERT_TRUE(kdfCtx != NULL);
120	ASSERT_EQ(HITLS_AUTH_Pake_Ctrl(ctx0, HITLS_AUTH_PAKE_REQ_REGISTER, kdfCtx, w0Buf, w1Buf, LBuf),	120	ASSERT_EQ(HITLS_AUTH_Pake_Ctrl(ctx0, HITLS_AUTH_PAKE_REQ_REGISTER, kdfCtx, w0Buf, w1Buf, LBuf),
121	HITLS_AUTH_SUCCESS);	121	HITLS_AUTH_SUCCESS);

Mtestcode/sdv/testcase/crypto/dsa/test_suite_sdv_eal_dsa.c+1-1

	@@ -88,7 +88,7 @@ int32_t STUB_RandRangeK(void libCtx, BN_BigNum r, const BN_BigNum *p)
88	int Compute_Md(CRYPT_MD_AlgId mdId, Hex msgIn, Hex mdOut)	88	int Compute_Md(CRYPT_MD_AlgId mdId, Hex msgIn, Hex mdOut)
89	{	89	{
90	uint32_t outLen;	90	uint32_t outLen;
91	- CRYPT_EAL_MdCTX *mdCtx = NULL;	91	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
92	uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);	92	uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);
93	ASSERT_TRUE(mdOutLen != 0);	93	ASSERT_TRUE(mdOutLen != 0);
94	mdOut->x = (uint8_t *)malloc(mdOutLen);	94	mdOut->x = (uint8_t *)malloc(mdOutLen);

Mtestcode/sdv/testcase/crypto/eal/test_suite_sdv_eal.c+3-3

	@@ -128,7 +128,7 @@ static bool IsPkeyAlgIdValid(int id)
128		128
129	#define MD_OUTPUT_MAXSIZE 128	129	#define MD_OUTPUT_MAXSIZE 128
130		130
131	-static int32_t MdTest(CRYPT_EAL_MdCTX ctx, Hex msg, Hex *hash)	131	+static int32_t MdTest(CRYPT_EAL_MdCtx ctx, Hex msg, Hex *hash)
132	{	132	{
133	(void)msg;	133	(void)msg;
134	(void)hash;	134	(void)hash;
	@@ -205,8 +205,8 @@ EXIT:
205	void SDV_CRYPTO_MD_COPY_FUNC_TC001(int id, Hex msg, Hex hash)	205	void SDV_CRYPTO_MD_COPY_FUNC_TC001(int id, Hex msg, Hex hash)
206	{	206	{
207	TestMemInit();	207	TestMemInit();
208	- CRYPT_EAL_MdCTX *cpyCtx = NULL;	208	+ CRYPT_EAL_MdCtx *cpyCtx = NULL;
209	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);	209	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(id);
210	ASSERT_TRUE(ctx != NULL);	210	ASSERT_TRUE(ctx != NULL);
211	ASSERT_EQ(MdTest(ctx, msg, hash), 0);	211	ASSERT_EQ(MdTest(ctx, msg, hash), 0);
212		212

Mtestcode/sdv/testcase/crypto/ealinit/test_suite_sdv_ealinit.c+2-2

	@@ -197,7 +197,7 @@ EXIT:
197	/* BEGIN_CASE */	197	/* BEGIN_CASE */
198	void SDV_CRYPTO_CRYPT_EAL_Init_TC003()	198	void SDV_CRYPTO_CRYPT_EAL_Init_TC003()
199	{	199	{
200	- CRYPT_EAL_MdCTX *ctx = NULL;	200	+ CRYPT_EAL_MdCtx *ctx = NULL;
201	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);	201	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
202	ASSERT_TRUE(ctx != NULL);	202	ASSERT_TRUE(ctx != NULL);
203	CRYPT_EAL_MdFreeCtx(ctx);	203	CRYPT_EAL_MdFreeCtx(ctx);
	@@ -238,7 +238,7 @@ void SDV_CRYPTO_CRYPT_EAL_Init_TC004()
238	uint32_t outLen = DATA_LEN;	238	uint32_t outLen = DATA_LEN;
239	uint8_t out[outLen];	239	uint8_t out[outLen];
240		240
241	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	241	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
242	ASSERT_TRUE(ctx != NULL);	242	ASSERT_TRUE(ctx != NULL);
243		243
244	CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA256;	244	CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA256;

Mtestcode/sdv/testcase/crypto/hkdf/test_suite_sdv_eal_kdf_hkdf.c+23-23

	@@ -64,7 +64,7 @@ void SDV_CRYPT_EAL_KDF_HKDF_API_TC001(int algId)
64	uint32_t outLen = DATA_LEN;	64	uint32_t outLen = DATA_LEN;
65	uint8_t out[DATA_LEN];	65	uint8_t out[DATA_LEN];
66		66
67	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);	67	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
68	ASSERT_TRUE(ctx != NULL);	68	ASSERT_TRUE(ctx != NULL);
69	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;	69	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
70	BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	70	BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -128,7 +128,7 @@ EXIT:
128	* @title Perform the vector test to check whether the calculation result is consistent with the standard output.	128	* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
129	* @precon nan	129	* @precon nan
130	* @brief	130	* @brief
131	- * 1.Call CRYPT_EAL_KdfCTX functions get output, expected result 1.	131	+ * 1.Call CRYPT_EAL_KdfCtx functions get output, expected result 1.
132	* 2.Compare the result to the expected value, expected result 2.	132	* 2.Compare the result to the expected value, expected result 2.
133	* @expect	133	* @expect
134	* 1.Successful.	134	* 1.Successful.
	@@ -145,7 +145,7 @@ void SDV_CRYPT_EAL_KDF_HKDF_FUN_TC001(int algId, Hex key, Hex salt, Hex *info,
145	uint8_t out = malloc(outLen sizeof(uint8_t));	145	uint8_t out = malloc(outLen sizeof(uint8_t));
146	ASSERT_TRUE(out != NULL);	146	ASSERT_TRUE(out != NULL);
147		147
148	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);	148	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
149	ASSERT_TRUE(ctx != NULL);	149	ASSERT_TRUE(ctx != NULL);
150	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;	150	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
151	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	151	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -188,7 +188,7 @@ void SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex key, Hex salt,
188	uint32_t outLen = result->len;	188	uint32_t outLen = result->len;
189	uint8_t out = malloc(outLen sizeof(uint8_t));	189	uint8_t out = malloc(outLen sizeof(uint8_t));
190	ASSERT_TRUE(out != NULL);	190	ASSERT_TRUE(out != NULL);
191	- CRYPT_EAL_KdfCTX *ctx = NULL;	191	+ CRYPT_EAL_KdfCtx *ctx = NULL;
192	#ifdef HITLS_CRYPTO_PROVIDER	192	#ifdef HITLS_CRYPTO_PROVIDER
193	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	193	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
194	#else	194	#else
	@@ -227,7 +227,7 @@ void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC001(int algId, Hex key, Hex salt, Hex *
227	uint32_t outLen = result->len;	227	uint32_t outLen = result->len;
228	uint8_t out = malloc(outLen sizeof(uint8_t));	228	uint8_t out = malloc(outLen sizeof(uint8_t));
229	ASSERT_TRUE(out != NULL);	229	ASSERT_TRUE(out != NULL);
230	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);	230	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
231	ASSERT_TRUE(ctx != NULL);	231	ASSERT_TRUE(ctx != NULL);
232	uint32_t mode = CRYPT_KDF_HKDF_MODE_FULL;	232	uint32_t mode = CRYPT_KDF_HKDF_MODE_FULL;
233		233
	@@ -265,7 +265,7 @@ void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC002(int algId, Hex key, Hex salt, Hex *
265	uint32_t outLen = result->len;	265	uint32_t outLen = result->len;
266	uint8_t out = malloc(outLen sizeof(uint8_t));	266	uint8_t out = malloc(outLen sizeof(uint8_t));
267	ASSERT_TRUE(out != NULL);	267	ASSERT_TRUE(out != NULL);
268	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);	268	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
269	ASSERT_TRUE(ctx != NULL);	269	ASSERT_TRUE(ctx != NULL);
270	uint32_t mode = CRYPT_KDF_HKDF_MODE_FULL;	270	uint32_t mode = CRYPT_KDF_HKDF_MODE_FULL;
271		271
	@@ -300,9 +300,9 @@ EXIT:
300	void SDV_CRYPTO_HKDF_COPY_CTX_API_TC001(int isProvider)	300	void SDV_CRYPTO_HKDF_COPY_CTX_API_TC001(int isProvider)
301	{	301	{
302	TestMemInit();	302	TestMemInit();
303	- CRYPT_EAL_KdfCTX *ctxA = NULL;	303	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
304	- CRYPT_EAL_KdfCTX *ctxB = NULL;	304	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
305	- CRYPT_EAL_KdfCTX ctxC = { 0 };	305	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
306	if (isProvider != 0) {	306	if (isProvider != 0) {
307	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	307	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
308	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	308	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
	@@ -331,9 +331,9 @@ EXIT:
331	void SDV_CRYPTO_HKDF_DUP_CTX_API_TC001(int isProvider)	331	void SDV_CRYPTO_HKDF_DUP_CTX_API_TC001(int isProvider)
332	{	332	{
333	TestMemInit();	333	TestMemInit();
334	- CRYPT_EAL_KdfCTX *ctxA = NULL;	334	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
335	- CRYPT_EAL_KdfCTX *ctxB = NULL;	335	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
336	- CRYPT_EAL_KdfCTX ctxC = { 0 };	336	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
337	if (isProvider != 0) {	337	if (isProvider != 0) {
338	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	338	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
339	} else {	339	} else {
	@@ -365,9 +365,9 @@ void SDV_CRYPTO_HKDF_COPY_CTX_API_TC002(int algId, Hex key, Hex salt, Hex *inf
365	uint32_t tmpLenC = DATA_LEN;	365	uint32_t tmpLenC = DATA_LEN;
366	uint8_t tmpBufC[DATA_LEN] = {0};	366	uint8_t tmpBufC[DATA_LEN] = {0};
367		367
368	- CRYPT_EAL_KdfCTX *ctxA = NULL;	368	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
369	- CRYPT_EAL_KdfCTX *ctxB = NULL;	369	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
370	- CRYPT_EAL_KdfCTX *ctxC = NULL;	370	+ CRYPT_EAL_KdfCtx *ctxC = NULL;
371	if (isProvider != 0) {	371	if (isProvider != 0) {
372	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	372	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
373	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	373	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
	@@ -437,11 +437,11 @@ void SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001(int algId, Hex key, Hex salt, Hex
437	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));	437	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));
438	ASSERT_TRUE(out != NULL);	438	ASSERT_TRUE(out != NULL);
439		439
440	- CRYPT_EAL_KdfCTX *ctx = NULL;	440	+ CRYPT_EAL_KdfCtx *ctx = NULL;
441	- CRYPT_EAL_KdfCTX *copyCtx = NULL;	441	+ CRYPT_EAL_KdfCtx *copyCtx = NULL;
442	- CRYPT_EAL_KdfCTX *copyCtx1 = NULL;	442	+ CRYPT_EAL_KdfCtx *copyCtx1 = NULL;
443	- CRYPT_EAL_KdfCTX *copyCtx2 = NULL;	443	+ CRYPT_EAL_KdfCtx *copyCtx2 = NULL;
444	- CRYPT_EAL_KdfCTX *copyCtx3 = NULL;	444	+ CRYPT_EAL_KdfCtx *copyCtx3 = NULL;
445	if (isProvider != 0) {	445	if (isProvider != 0) {
446	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	446	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
447	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	447	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
	@@ -517,9 +517,9 @@ EXIT:
517		517
518	static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex key, Hex salt, Hex *info, int isProvider)	518	static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex key, Hex salt, Hex *info, int isProvider)
519	{	519	{
520	- CRYPT_EAL_KdfCTX *ctxA = NULL;	520	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
521	- CRYPT_EAL_KdfCTX *ctxB = NULL;	521	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
522	- CRYPT_EAL_KdfCTX *srcCtx = NULL;	522	+ CRYPT_EAL_KdfCtx *srcCtx = NULL;
523	if (isProvider != 0) {	523	if (isProvider != 0) {
524	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	524	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
525	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	525	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");

Mtestcode/sdv/testcase/crypto/md5/test_suite_sdv_eal_md5.c+11-11

	@@ -37,7 +37,7 @@ void Md5MultiThreadTest(void *arg)
37	ThreadParameter threadParameter = (ThreadParameter )arg;	37	ThreadParameter threadParameter = (ThreadParameter )arg;
38	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	38	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
39	uint8_t out[CRYPT_MD5_DIGESTSIZE];	39	uint8_t out[CRYPT_MD5_DIGESTSIZE];
40	- CRYPT_EAL_MdCTX *ctx = NULL;	40	+ CRYPT_EAL_MdCtx *ctx = NULL;
41	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);	41	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
42	ASSERT_TRUE(ctx != NULL);	42	ASSERT_TRUE(ctx != NULL);
43	for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times	43	for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times
	@@ -82,7 +82,7 @@ void SDV_CRYPTO_MD5_API_TC001(void)
82	uint32_t dataLen = sizeof(data);	82	uint32_t dataLen = sizeof(data);
83	uint8_t output[CRYPT_MD5_DIGESTSIZE + 1];	83	uint8_t output[CRYPT_MD5_DIGESTSIZE + 1];
84	uint32_t outputLen = CRYPT_MD5_DIGESTSIZE;	84	uint32_t outputLen = CRYPT_MD5_DIGESTSIZE;
85	- CRYPT_EAL_MdCTX *md5Ctx = NULL;	85	+ CRYPT_EAL_MdCtx *md5Ctx = NULL;
86	ASSERT_EQ(CRYPT_EAL_MdDeinit(md5Ctx), CRYPT_NULL_INPUT);	86	ASSERT_EQ(CRYPT_EAL_MdDeinit(md5Ctx), CRYPT_NULL_INPUT);
87	md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);	87	md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
88	ASSERT_TRUE(md5Ctx != NULL);	88	ASSERT_TRUE(md5Ctx != NULL);
	@@ -138,7 +138,7 @@ void SDV_CRYPTO_MD5_FUNC_TC001(Hex *hash)
138	uint8_t output[CRYPT_MD5_DIGESTSIZE];	138	uint8_t output[CRYPT_MD5_DIGESTSIZE];
139	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	139	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
140		140
141	- CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);	141	+ CRYPT_EAL_MdCtx *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
142	ASSERT_TRUE(md5Ctx != NULL);	142	ASSERT_TRUE(md5Ctx != NULL);
143	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);	143	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
144	ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);	144	ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
	@@ -171,7 +171,7 @@ void SDV_CRYPTO_MD5_FUNC_TC002(Hex msg, Hex hash)
171	uint8_t output[CRYPT_MD5_DIGESTSIZE];	171	uint8_t output[CRYPT_MD5_DIGESTSIZE];
172	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	172	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
173		173
174	- CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);	174	+ CRYPT_EAL_MdCtx *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
175	ASSERT_TRUE(md5Ctx != NULL);	175	ASSERT_TRUE(md5Ctx != NULL);
176		176
177	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);	177	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
	@@ -207,8 +207,8 @@ EXIT:
207	void SDV_CRYPTO_MD5_FUNC_TC003(void)	207	void SDV_CRYPTO_MD5_FUNC_TC003(void)
208	{	208	{
209	TestMemInit();	209	TestMemInit();
210	- CRYPT_EAL_MdCTX *ctx1 = NULL;	210	+ CRYPT_EAL_MdCtx *ctx1 = NULL;
211	- CRYPT_EAL_MdCTX *ctx2 = NULL;	211	+ CRYPT_EAL_MdCtx *ctx2 = NULL;
212		212
213	ctx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);	213	ctx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
214	ASSERT_TRUE(ctx1 != NULL);	214	ASSERT_TRUE(ctx1 != NULL);
	@@ -268,7 +268,7 @@ void SDV_CRYPTO_MD5_FUNC_TC004(Hex data1, Hex data2, Hex data3, Hex hash)
268	TestMemInit();	268	TestMemInit();
269	uint8_t output[CRYPT_MD5_DIGESTSIZE];	269	uint8_t output[CRYPT_MD5_DIGESTSIZE];
270	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	270	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
271	- CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);	271	+ CRYPT_EAL_MdCtx *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
272	ASSERT_TRUE(md5Ctx != NULL);	272	ASSERT_TRUE(md5Ctx != NULL);
273		273
274	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);	274	ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
	@@ -307,9 +307,9 @@ EXIT:
307	void SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)	307	void SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)
308	{	308	{
309	TestMemInit();	309	TestMemInit();
310	- CRYPT_EAL_MdCTX *cpyCtx = NULL;	310	+ CRYPT_EAL_MdCtx *cpyCtx = NULL;
311	- CRYPT_EAL_MdCTX *dupCtx = NULL;	311	+ CRYPT_EAL_MdCtx *dupCtx = NULL;
312	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);	312	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(id);
313	ASSERT_TRUE(ctx != NULL);	313	ASSERT_TRUE(ctx != NULL);
314	uint8_t output[CRYPT_MD5_DIGESTSIZE];	314	uint8_t output[CRYPT_MD5_DIGESTSIZE];
315	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	315	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
	@@ -364,7 +364,7 @@ void SDV_CRYPTO_MD5_FUNC_TC005(int id, Hex msg, Hex hash)
364	TestMemInit();	364	TestMemInit();
365	uint8_t output[CRYPT_MD5_DIGESTSIZE];	365	uint8_t output[CRYPT_MD5_DIGESTSIZE];
366	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;	366	uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
367	- CRYPT_EAL_MdCTX *ctx = NULL;	367	+ CRYPT_EAL_MdCtx *ctx = NULL;
368	#ifdef HITLS_CRYPTO_PROVIDER	368	#ifdef HITLS_CRYPTO_PROVIDER
369	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");	369	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
370	#else	370	#else

Mtestcode/sdv/testcase/crypto/pbkdf2/test_suite_sdv_eal_kdf_pbkdf2.c+17-17

	@@ -49,7 +49,7 @@ void SDV_CRYPT_EAL_KDF_PBKDF2_API_TC001(void)
49	uint32_t outLen = DATA_LEN;	49	uint32_t outLen = DATA_LEN;
50	uint8_t out[DATA_LEN];	50	uint8_t out[DATA_LEN];
51		51
52	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	52	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
53	ASSERT_TRUE(ctx != NULL);	53	ASSERT_TRUE(ctx != NULL);
54		54
55	CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA1;	55	CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA1;
	@@ -159,7 +159,7 @@ void SDV_CRYPT_EAL_KDF_PBKDF2_FUN_TC001(int algId, Hex key, Hex salt, int it,
159	uint8_t out = malloc(outLen sizeof(uint8_t));	159	uint8_t out = malloc(outLen sizeof(uint8_t));
160	ASSERT_TRUE(out != NULL);	160	ASSERT_TRUE(out != NULL);
161		161
162	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);	162	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
163	ASSERT_TRUE(ctx != NULL);	163	ASSERT_TRUE(ctx != NULL);
164		164
165	BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};	165	BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -200,7 +200,7 @@ void SDV_CRYPTO_PBKDF2_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex key, Hex sal
200	uint32_t outLen = result->len;	200	uint32_t outLen = result->len;
201	uint8_t out = malloc(outLen sizeof(uint8_t));	201	uint8_t out = malloc(outLen sizeof(uint8_t));
202	ASSERT_TRUE(out != NULL);	202	ASSERT_TRUE(out != NULL);
203	- CRYPT_EAL_KdfCTX *ctx = NULL;	203	+ CRYPT_EAL_KdfCtx *ctx = NULL;
204		204
205	#ifdef HITLS_CRYPTO_PROVIDER	205	#ifdef HITLS_CRYPTO_PROVIDER
206	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	206	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
	@@ -235,9 +235,9 @@ EXIT:
235	void SDV_CRYPTO_PBKDF2_COPY_CTX_API_TC001(int isProvider)	235	void SDV_CRYPTO_PBKDF2_COPY_CTX_API_TC001(int isProvider)
236	{	236	{
237	TestMemInit();	237	TestMemInit();
238	- CRYPT_EAL_KdfCTX *ctxA = NULL;	238	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
239	- CRYPT_EAL_KdfCTX *ctxB = NULL;	239	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
240	- CRYPT_EAL_KdfCTX ctxC = { 0 };	240	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
241	if (isProvider != 0) {	241	if (isProvider != 0) {
242	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	242	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
243	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	243	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
	@@ -266,9 +266,9 @@ EXIT:
266	void SDV_CRYPTO_PBKDF2_DUP_CTX_API_TC001(int isProvider)	266	void SDV_CRYPTO_PBKDF2_DUP_CTX_API_TC001(int isProvider)
267	{	267	{
268	TestMemInit();	268	TestMemInit();
269	- CRYPT_EAL_KdfCTX *ctxA = NULL;	269	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
270	- CRYPT_EAL_KdfCTX *ctxB = NULL;	270	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
271	- CRYPT_EAL_KdfCTX ctxC = { 0 };	271	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
272	if (isProvider != 0) {	272	if (isProvider != 0) {
273	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	273	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
274	} else {	274	} else {
	@@ -299,11 +299,11 @@ void SDV_CRYPT_EAL_PBKDF2_COPY_CTX_FUNC_TC001(int algId, Hex key, Hex salt, in
299	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));	299	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));
300	ASSERT_TRUE(out != NULL);	300	ASSERT_TRUE(out != NULL);
301		301
302	- CRYPT_EAL_KdfCTX *ctx = NULL;	302	+ CRYPT_EAL_KdfCtx *ctx = NULL;
303	- CRYPT_EAL_KdfCTX *copyCtx = NULL;	303	+ CRYPT_EAL_KdfCtx *copyCtx = NULL;
304	- CRYPT_EAL_KdfCTX *copyCtx1 = NULL;	304	+ CRYPT_EAL_KdfCtx *copyCtx1 = NULL;
305	- CRYPT_EAL_KdfCTX *copyCtx2 = NULL;	305	+ CRYPT_EAL_KdfCtx *copyCtx2 = NULL;
306	- CRYPT_EAL_KdfCTX *copyCtx3 = NULL;	306	+ CRYPT_EAL_KdfCtx *copyCtx3 = NULL;
307	if (isProvider != 0) {	307	if (isProvider != 0) {
308	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	308	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
309	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");	309	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
	@@ -377,9 +377,9 @@ EXIT:
377		377
378	static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex key, Hex salt, int it, int isProvider)	378	static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex key, Hex salt, int it, int isProvider)
379	{	379	{
380	- CRYPT_EAL_KdfCTX *ctxA = NULL;	380	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
381	- CRYPT_EAL_KdfCTX *ctxB = NULL;	381	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
382	- CRYPT_EAL_KdfCTX *srcCtx = NULL;	382	+ CRYPT_EAL_KdfCtx *srcCtx = NULL;
383	if (isProvider != 0) {	383	if (isProvider != 0) {
384	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	384	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
385	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	385	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");

Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_iso19790_provider.c+8-8

	@@ -504,7 +504,7 @@ void SDV_ISO19790_PROVIDER_MD_TEST_TC001(int algId)
504	SKIP_TEST();	504	SKIP_TEST();
505	#else	505	#else
506	Iso19790_ProviderLoadCtx ctx = {0};	506	Iso19790_ProviderLoadCtx ctx = {0};
507	- CRYPT_EAL_MdCTX *mdCtx = NULL;	507	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
508	uint8_t plaintext[128] = {0};	508	uint8_t plaintext[128] = {0};
509	uint32_t plaintextLen = sizeof(plaintext);	509	uint32_t plaintextLen = sizeof(plaintext);
510	uint8_t md[128] = {0};	510	uint8_t md[128] = {0};
	@@ -588,7 +588,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
588	SKIP_TEST();	588	SKIP_TEST();
589	#else	589	#else
590	Iso19790_ProviderLoadCtx ctx = {0};	590	Iso19790_ProviderLoadCtx ctx = {0};
591	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	591	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
592	uint8_t password[32] = {0};	592	uint8_t password[32] = {0};
593	uint32_t passwordLen = sizeof(password);	593	uint32_t passwordLen = sizeof(password);
594	uint8_t salt[32] = {0};	594	uint8_t salt[32] = {0};
	@@ -636,7 +636,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC002(int algId, Hex key, Hex salt, Hex *i
636	}	636	}
637	TestMemInit();	637	TestMemInit();
638	Iso19790_ProviderLoadCtx ctx = {0};	638	Iso19790_ProviderLoadCtx ctx = {0};
639	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	639	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
640	uint32_t outLen = 32;	640	uint32_t outLen = 32;
641	uint8_t out = malloc(outLen sizeof(uint8_t));	641	uint8_t out = malloc(outLen sizeof(uint8_t));
642	ASSERT_TRUE(out != NULL);	642	ASSERT_TRUE(out != NULL);
	@@ -689,7 +689,7 @@ void SDV_ISO19790_PROVIDER_KDF_TEST_TC003(int algId, Hex key, Hex label, Hex *
689	uint8_t out = malloc(outLen sizeof(uint8_t));	689	uint8_t out = malloc(outLen sizeof(uint8_t));
690	ASSERT_TRUE(out != NULL);	690	ASSERT_TRUE(out != NULL);
691	Iso19790_ProviderLoadCtx ctx = {0};	691	Iso19790_ProviderLoadCtx ctx = {0};
692	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	692	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
693		693
694	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);	694	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);
695		695
	@@ -966,7 +966,7 @@ void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC001(Hex key, Hex label, Hex *seed
966	SKIP_TEST();	966	SKIP_TEST();
967	#else	967	#else
968	Iso19790_ProviderLoadCtx ctx = {0};	968	Iso19790_ProviderLoadCtx ctx = {0};
969	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	969	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
970		970
971	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);	971	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);
972		972
	@@ -1014,7 +1014,7 @@ void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC002(Hex key, Hex salt, Hex *info)
1014	SKIP_TEST();	1014	SKIP_TEST();
1015	#else	1015	#else
1016	Iso19790_ProviderLoadCtx ctx = {0};	1016	Iso19790_ProviderLoadCtx ctx = {0};
1017	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	1017	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
1018	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);	1018	ASSERT_EQ(Iso19790_ProviderLoad(&ctx), CRYPT_SUCCESS);
1019		1019
1020	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_HKDF, HITLS_ISO_PROVIDER_ATTR);	1020	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_HKDF, HITLS_ISO_PROVIDER_ATTR);
	@@ -1065,7 +1065,7 @@ void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC003()
1065	SKIP_TEST();	1065	SKIP_TEST();
1066	#else	1066	#else
1067	Iso19790_ProviderLoadCtx ctx = {0};	1067	Iso19790_ProviderLoadCtx ctx = {0};
1068	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	1068	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
1069	uint8_t password[32] = {0};	1069	uint8_t password[32] = {0};
1070	uint32_t passwordLen = sizeof(password);	1070	uint32_t passwordLen = sizeof(password);
1071	uint8_t salt[32] = {0};	1071	uint8_t salt[32] = {0};
	@@ -1347,7 +1347,7 @@ void SDV_ISO19790_PROVIDER_MD_USE_DEFAULT_LIBCTX_TEST_TC001(int algId)
1347	SKIP_TEST();	1347	SKIP_TEST();
1348	#else	1348	#else
1349	int32_t ret = CRYPT_SUCCESS;	1349	int32_t ret = CRYPT_SUCCESS;
1350	- CRYPT_EAL_MdCTX *mdCtx = NULL;	1350	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
1351	uint8_t plaintext[128] = {0};	1351	uint8_t plaintext[128] = {0};
1352	uint32_t plaintextLen = sizeof(plaintext);	1352	uint32_t plaintextLen = sizeof(plaintext);
1353	uint8_t md[128] = {0};	1353	uint8_t md[128] = {0};

Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_multi_provider.c+4-4

	@@ -79,7 +79,7 @@ void SDV_PROVIDER_SHA256_TC001(char path, char defProName, char *customProName
79	Hex in, Hex digest)	79	Hex in, Hex digest)
80	{	80	{
81	#if defined(HITLS_CRYPTO_MD) && defined(HITLS_CRYPTO_PROVIDER)	81	#if defined(HITLS_CRYPTO_MD) && defined(HITLS_CRYPTO_PROVIDER)
82	- CRYPT_EAL_MdCTX *ctx = NULL;	82	+ CRYPT_EAL_MdCtx *ctx = NULL;
83	CRYPT_EAL_LibCtx *libCtx = NULL;	83	CRYPT_EAL_LibCtx *libCtx = NULL;
84	uint8_t out[SHA2_OUTPUT_MAXSIZE];	84	uint8_t out[SHA2_OUTPUT_MAXSIZE];
85	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;	85	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
	@@ -167,7 +167,7 @@ void SDV_PROVIDER_HKDF_TC001(char path, char defProName, char *customProName,
167	uint8_t *out = NULL;	167	uint8_t *out = NULL;
168	uint32_t outLen = result->len;	168	uint32_t outLen = result->len;
169	CRYPT_EAL_LibCtx *libCtx = NULL;	169	CRYPT_EAL_LibCtx *libCtx = NULL;
170	- CRYPT_EAL_KdfCTX *ctx = NULL;	170	+ CRYPT_EAL_KdfCtx *ctx = NULL;
171	BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 6 parameters for hkdf	171	BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 6 parameters for hkdf
172	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;	172	CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
173		173
	@@ -222,7 +222,7 @@ void SDV_PROVIDER_PBKDF2_TC001(char path, char defProName, char *customProName
222	uint8_t *out = NULL;	222	uint8_t *out = NULL;
223	uint32_t outLen = result->len;	223	uint32_t outLen = result->len;
224	CRYPT_EAL_LibCtx *libCtx = NULL;	224	CRYPT_EAL_LibCtx *libCtx = NULL;
225	- CRYPT_EAL_KdfCTX *ctx = NULL;	225	+ CRYPT_EAL_KdfCtx *ctx = NULL;
226	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for pbkdf2	226	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for pbkdf2
227		227
228	TestMemInit();	228	TestMemInit();
	@@ -275,7 +275,7 @@ void SDV_PROVIDER_KDFTLS12_TC001(char path, char defProName, char *customProNa
275	uint8_t *out = NULL;	275	uint8_t *out = NULL;
276	uint32_t outLen = result->len;	276	uint32_t outLen = result->len;
277	CRYPT_EAL_LibCtx *libCtx = NULL;	277	CRYPT_EAL_LibCtx *libCtx = NULL;
278	- CRYPT_EAL_KdfCTX *ctx = NULL;	278	+ CRYPT_EAL_KdfCtx *ctx = NULL;
279	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12	279	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12
280		280
281	TestMemInit();	281	TestMemInit();

Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_load.c+6-6

	@@ -215,7 +215,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_TC003(char path, int cmd, char test1, char *attr
215	(void)attrName;	215	(void)attrName;
216	SKIP_TEST();	216	SKIP_TEST();
217	#else	217	#else
218	- CRYPT_EAL_MdCTX *mdCtx = NULL;	218	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
219	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(NULL, path), CRYPT_SUCCESS);	219	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(NULL, path), CRYPT_SUCCESS);
220	ASSERT_EQ(CRYPT_EAL_ProviderLoad(NULL, cmd, test1, NULL, NULL), CRYPT_SUCCESS);	220	ASSERT_EQ(CRYPT_EAL_ProviderLoad(NULL, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
221	ASSERT_EQ(CRYPT_EAL_ProviderUnload(NULL, cmd, test1), CRYPT_SUCCESS);	221	ASSERT_EQ(CRYPT_EAL_ProviderUnload(NULL, cmd, test1), CRYPT_SUCCESS);
	@@ -409,11 +409,11 @@ void SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC001(char path, char providerNoInit,
409	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);	409	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
410	ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoInit, NULL, NULL), CRYPT_SUCCESS);	410	ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoInit, NULL, NULL), CRYPT_SUCCESS);
411		411
412	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);	412	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);
413	ASSERT_TRUE(kdfCtx == NULL);	413	ASSERT_TRUE(kdfCtx == NULL);
414	CRYPT_EAL_MacCtx *macCtx = CRYPT_EAL_ProviderMacNewCtx(libCtx, CRYPT_MAC_HMAC_MD5, NULL);	414	CRYPT_EAL_MacCtx *macCtx = CRYPT_EAL_ProviderMacNewCtx(libCtx, CRYPT_MAC_HMAC_MD5, NULL);
415	ASSERT_TRUE(macCtx == NULL);	415	ASSERT_TRUE(macCtx == NULL);
416	- CRYPT_EAL_MdCTX *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);	416	+ CRYPT_EAL_MdCtx *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);
417	ASSERT_TRUE(mdCtx == NULL);	417	ASSERT_TRUE(mdCtx == NULL);
418	CRYPT_EAL_PkeyCtx *pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, NULL);	418	CRYPT_EAL_PkeyCtx *pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, NULL);
419	ASSERT_TRUE(pkeyCtx == NULL);	419	ASSERT_TRUE(pkeyCtx == NULL);
	@@ -448,7 +448,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC002(char path, char providerNoFree,
448	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);	448	ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
449	ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoFree, NULL, NULL), CRYPT_SUCCESS);	449	ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoFree, NULL, NULL), CRYPT_SUCCESS);
450		450
451	- CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);	451	+ CRYPT_EAL_KdfCtx *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);
452	ASSERT_TRUE(kdfCtx != NULL);	452	ASSERT_TRUE(kdfCtx != NULL);
453	void *tempData = kdfCtx->data;	453	void *tempData = kdfCtx->data;
454	CRYPT_EAL_KdfFreeCtx(kdfCtx);	454	CRYPT_EAL_KdfFreeCtx(kdfCtx);
	@@ -458,7 +458,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC002(char path, char providerNoFree,
458	tempData = macCtx->ctx;	458	tempData = macCtx->ctx;
459	CRYPT_EAL_MacFreeCtx(macCtx);	459	CRYPT_EAL_MacFreeCtx(macCtx);
460	BSL_SAL_FREE(tempData);	460	BSL_SAL_FREE(tempData);
461	- CRYPT_EAL_MdCTX *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);	461	+ CRYPT_EAL_MdCtx *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);
462	ASSERT_TRUE(mdCtx != NULL);	462	ASSERT_TRUE(mdCtx != NULL);
463	tempData = mdCtx->data;	463	tempData = mdCtx->data;
464	CRYPT_EAL_MdFreeCtx(mdCtx);	464	CRYPT_EAL_MdFreeCtx(mdCtx);
	@@ -494,7 +494,7 @@ void SDV_CRYPTO_PROVIDER_LOAD_DEFAULT_TC001(char path, char test1, int cmd, He
494	SKIP_TEST();	494	SKIP_TEST();
495	#else	495	#else
496	CRYPT_EAL_LibCtx *libCtx = NULL;	496	CRYPT_EAL_LibCtx *libCtx = NULL;
497	- CRYPT_EAL_MdCTX *ctx = NULL;	497	+ CRYPT_EAL_MdCtx *ctx = NULL;
498	int32_t ret;	498	int32_t ret;
499		499
500	// Test CRYPT_EAL_LibCtxNew	500	// Test CRYPT_EAL_LibCtxNew

Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_reg.c+2-2

	@@ -231,7 +231,7 @@ void SDV_CRYPTO_PROVIDER_REG_FUNC_TC001(void)
231	#ifndef HITLS_CRYPTO_PROVIDER	231	#ifndef HITLS_CRYPTO_PROVIDER
232	SKIP_TEST();	232	SKIP_TEST();
233	#else	233	#else
234	- CRYPT_EAL_MdCTX *mdCtx = NULL;	234	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
235		235
236	TestMemInit();	236	TestMemInit();
237	CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();	237	CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
	@@ -292,7 +292,7 @@ void SDV_CRYPTO_PROVIDER_REG_FUNC_TC002(void)
292	#ifndef HITLS_CRYPTO_PROVIDER	292	#ifndef HITLS_CRYPTO_PROVIDER
293	SKIP_TEST();	293	SKIP_TEST();
294	#else	294	#else
295	- CRYPT_EAL_MdCTX *mdCtx = NULL;	295	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
296	TestMemInit();	296	TestMemInit();
297	CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();	297	CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
298	ASSERT_TRUE(libCtx != NULL);	298	ASSERT_TRUE(libCtx != NULL);

Mtestcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_sm_provider.c+4-4

	@@ -176,7 +176,7 @@ void SDV_SM_PROVIDER_MD_TEST_TC001(int algId)
176	SKIP_TEST();	176	SKIP_TEST();
177	#else	177	#else
178	CRYPT_EAL_LibCtx *libCtx = NULL;	178	CRYPT_EAL_LibCtx *libCtx = NULL;
179	- CRYPT_EAL_MdCTX *mdCtx = NULL;	179	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
180	uint8_t plaintext[128] = {0};	180	uint8_t plaintext[128] = {0};
181	uint32_t plaintextLen = sizeof(plaintext);	181	uint32_t plaintextLen = sizeof(plaintext);
182	uint8_t md[128] = {0};	182	uint8_t md[128] = {0};
	@@ -259,7 +259,7 @@ void SDV_SM_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
259	SKIP_TEST();	259	SKIP_TEST();
260	#else	260	#else
261	CRYPT_EAL_LibCtx *libCtx = NULL;	261	CRYPT_EAL_LibCtx *libCtx = NULL;
262	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	262	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
263	uint8_t password[32] = {0};	263	uint8_t password[32] = {0};
264	uint32_t passwordLen = sizeof(password);	264	uint32_t passwordLen = sizeof(password);
265	uint8_t salt[32] = {0};	265	uint8_t salt[32] = {0};
	@@ -398,7 +398,7 @@ void SDV_SM_PROVIDER_KDF_PARAM_CHECK_TC001()
398	SKIP_TEST();	398	SKIP_TEST();
399	#else	399	#else
400	CRYPT_EAL_LibCtx *libCtx = NULL;	400	CRYPT_EAL_LibCtx *libCtx = NULL;
401	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	401	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
402	uint8_t password[32] = {0};	402	uint8_t password[32] = {0};
403	uint32_t passwordLen = sizeof(password);	403	uint32_t passwordLen = sizeof(password);
404	uint8_t salt[32] = {0};	404	uint8_t salt[32] = {0};
	@@ -494,7 +494,7 @@ void SDV_SM_PROVIDER_KDF_KDFTLS12_TEST_TC001(int algId, Hex key, Hex label, He
494	}	494	}
495	TestMemInit();	495	TestMemInit();
496	CRYPT_EAL_LibCtx *libCtx = NULL;	496	CRYPT_EAL_LibCtx *libCtx = NULL;
497	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	497	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
498	uint32_t outLen = 32;	498	uint32_t outLen = 32;
499	uint8_t out = malloc(outLen sizeof(uint8_t));	499	uint8_t out = malloc(outLen sizeof(uint8_t));
500	ASSERT_TRUE(out != NULL);	500	ASSERT_TRUE(out != NULL);

Mtestcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_sign_verify.c+2-2

	@@ -33,7 +33,7 @@
33	int MD_Data(CRYPT_MD_AlgId mdId, Hex msgIn, Hex mdOut)	33	int MD_Data(CRYPT_MD_AlgId mdId, Hex msgIn, Hex mdOut)
34	{	34	{
35	uint32_t outLen;	35	uint32_t outLen;
36	- CRYPT_EAL_MdCTX *mdCtx = NULL;	36	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
37	uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);	37	uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);
38	ASSERT_TRUE(mdOutLen != 0);	38	ASSERT_TRUE(mdOutLen != 0);
39	mdOut->x = (uint8_t *)malloc(mdOutLen);	39	mdOut->x = (uint8_t *)malloc(mdOutLen);
	@@ -1844,7 +1844,7 @@ void SDV_CRYPTO_RSA_SIGN_VERIFY_ISO9796_2_NEGATIVE_TC001(int isProvider, int bit
1844	CRYPT_RSA_Ctx *rsaCtx = NULL;	1844	CRYPT_RSA_Ctx *rsaCtx = NULL;
1845	CRYPT_EAL_PkeyPara para = {0};	1845	CRYPT_EAL_PkeyPara para = {0};
1846	CRYPT_EAL_PkeyPub pubKey = {0};	1846	CRYPT_EAL_PkeyPub pubKey = {0};
1847	- CRYPT_EAL_MdCTX *mdCtx = NULL;	1847	+ CRYPT_EAL_MdCtx *mdCtx = NULL;
1848	uint8_t e[] = {1, 0, 1};	1848	uint8_t e[] = {1, 0, 1};
1849	uint8_t *msg = NULL;	1849	uint8_t *msg = NULL;
1850	uint8_t *msgTamper = NULL;	1850	uint8_t *msgTamper = NULL;

Mtestcode/sdv/testcase/crypto/scrypt/test_suite_sdv_eal_kdf_scrypt.c+19-19

	@@ -54,7 +54,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_API_TC001(void)
54	uint32_t outLen = DATA_LEN;	54	uint32_t outLen = DATA_LEN;
55	uint8_t out[DATA_LEN];	55	uint8_t out[DATA_LEN];
56		56
57	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);	57	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
58	ASSERT_TRUE(ctx != NULL);	58	ASSERT_TRUE(ctx != NULL);
59		59
60	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	60	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -173,7 +173,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_API_TC002(void)
173	uint32_t outLen = DATA_LEN;	173	uint32_t outLen = DATA_LEN;
174	uint8_t out[DATA_LEN];	174	uint8_t out[DATA_LEN];
175		175
176	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);	176	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
177	ASSERT_TRUE(ctx != NULL);	177	ASSERT_TRUE(ctx != NULL);
178		178
179	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	179	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -307,7 +307,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC001(Hex key, Hex salt, int N, int r, int p
307	uint8_t out = malloc(outLen sizeof(uint8_t));	307	uint8_t out = malloc(outLen sizeof(uint8_t));
308	ASSERT_TRUE(out != NULL);	308	ASSERT_TRUE(out != NULL);
309		309
310	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);	310	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
311	ASSERT_TRUE(ctx != NULL);	311	ASSERT_TRUE(ctx != NULL);
312	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	312	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
313	ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,	313	ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
	@@ -346,7 +346,7 @@ void SDV_CRYPTO_SCRYPT_DEFAULT_PROVIDER_FUNC_TC001(Hex key, Hex salt, int N, i
346	uint32_t outLen = result->len;	346	uint32_t outLen = result->len;
347	uint8_t out = malloc(outLen sizeof(uint8_t));	347	uint8_t out = malloc(outLen sizeof(uint8_t));
348	ASSERT_TRUE(out != NULL);	348	ASSERT_TRUE(out != NULL);
349	- CRYPT_EAL_KdfCTX *ctx = NULL;	349	+ CRYPT_EAL_KdfCtx *ctx = NULL;
350	#ifdef HITLS_CRYPTO_PROVIDER	350	#ifdef HITLS_CRYPTO_PROVIDER
351	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	351	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
352	#else	352	#else
	@@ -401,7 +401,7 @@ void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC002(int testN, int testR, int testP)
401	uint32_t outLen = DATA_LEN;	401	uint32_t outLen = DATA_LEN;
402	uint8_t out[DATA_LEN];	402	uint8_t out[DATA_LEN];
403		403
404	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);	404	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
405	ASSERT_TRUE(ctx != NULL);	405	ASSERT_TRUE(ctx != NULL);
406		406
407	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};	407	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
	@@ -428,9 +428,9 @@ EXIT:
428	void SDV_CRYPTO_SCRYPT_COPY_CTX_API_TC001(int isProvider)	428	void SDV_CRYPTO_SCRYPT_COPY_CTX_API_TC001(int isProvider)
429	{	429	{
430	TestMemInit();	430	TestMemInit();
431	- CRYPT_EAL_KdfCTX *ctxA = NULL;	431	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
432	- CRYPT_EAL_KdfCTX *ctxB = NULL;	432	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
433	- CRYPT_EAL_KdfCTX ctxC = { 0 };	433	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
434	if (isProvider != 0) {	434	if (isProvider != 0) {
435	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	435	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
436	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	436	ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
	@@ -459,9 +459,9 @@ EXIT:
459	void SDV_CRYPTO_SCRYPT_DUP_CTX_API_TC001(int isProvider)	459	void SDV_CRYPTO_SCRYPT_DUP_CTX_API_TC001(int isProvider)
460	{	460	{
461	TestMemInit();	461	TestMemInit();
462	- CRYPT_EAL_KdfCTX *ctxA = NULL;	462	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
463	- CRYPT_EAL_KdfCTX *ctxB = NULL;	463	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
464	- CRYPT_EAL_KdfCTX ctxC = { 0 };	464	+ CRYPT_EAL_KdfCtx ctxC = { 0 };
465	if (isProvider != 0) {	465	if (isProvider != 0) {
466	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	466	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
467	} else {	467	} else {
	@@ -489,11 +489,11 @@ void SDV_CRYPT_EAL_SCRYPT_COPY_CTX_FUNC_TC001(Hex key, Hex salt, int N, int r,
489	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));	489	uint8_t out = BSL_SAL_Malloc(outLen sizeof(uint8_t));
490	ASSERT_TRUE(out != NULL);	490	ASSERT_TRUE(out != NULL);
491		491
492	- CRYPT_EAL_KdfCTX *ctx = NULL;	492	+ CRYPT_EAL_KdfCtx *ctx = NULL;
493	- CRYPT_EAL_KdfCTX *copyCtx = NULL;	493	+ CRYPT_EAL_KdfCtx *copyCtx = NULL;
494	- CRYPT_EAL_KdfCTX *copyCtx1 = NULL;	494	+ CRYPT_EAL_KdfCtx *copyCtx1 = NULL;
495	- CRYPT_EAL_KdfCTX *copyCtx2 = NULL;	495	+ CRYPT_EAL_KdfCtx *copyCtx2 = NULL;
496	- CRYPT_EAL_KdfCTX *copyCtx3 = NULL;	496	+ CRYPT_EAL_KdfCtx *copyCtx3 = NULL;
497	if (isProvider != 0) {	497	if (isProvider != 0) {
498	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	498	ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
499	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");	499	copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
	@@ -568,9 +568,9 @@ EXIT:
568		568
569	static int32_t TestKdfCopyCtxMemCheck(Hex key, Hex salt, int N, int r, int p, int isProvider)	569	static int32_t TestKdfCopyCtxMemCheck(Hex key, Hex salt, int N, int r, int p, int isProvider)
570	{	570	{
571	- CRYPT_EAL_KdfCTX *ctxA = NULL;	571	+ CRYPT_EAL_KdfCtx *ctxA = NULL;
572	- CRYPT_EAL_KdfCTX *ctxB = NULL;	572	+ CRYPT_EAL_KdfCtx *ctxB = NULL;
573	- CRYPT_EAL_KdfCTX *srcCtx = NULL;	573	+ CRYPT_EAL_KdfCtx *srcCtx = NULL;
574	if (isProvider != 0) {	574	if (isProvider != 0) {
575	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	575	srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
576	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");	576	ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");

Mtestcode/sdv/testcase/crypto/sha1/test_suite_sdv_eal_md_sha1.c+10-10

	@@ -37,7 +37,7 @@ void MultiThreadTest(void *arg)
37	ThreadParameter threadParameter = (ThreadParameter )arg;	37	ThreadParameter threadParameter = (ThreadParameter )arg;
38	uint32_t outLen = SHA1_DIGEST_LEN;	38	uint32_t outLen = SHA1_DIGEST_LEN;
39	uint8_t out[SHA1_DIGEST_LEN];	39	uint8_t out[SHA1_DIGEST_LEN];
40	- CRYPT_EAL_MdCTX *ctx = NULL;	40	+ CRYPT_EAL_MdCtx *ctx = NULL;
41	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);	41	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
42	ASSERT_TRUE(ctx != NULL);	42	ASSERT_TRUE(ctx != NULL);
43	for (uint32_t i = 0; i < 10; i++) {	43	for (uint32_t i = 0; i < 10; i++) {
	@@ -68,7 +68,7 @@ EXIT:
68	void SDV_CRYPT_EAL_SHA1_API_TC001(void)	68	void SDV_CRYPT_EAL_SHA1_API_TC001(void)
69	{	69	{
70	TestMemInit();	70	TestMemInit();
71	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MAX);;	71	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MAX);;
72	ASSERT_TRUE(ctx == NULL);	72	ASSERT_TRUE(ctx == NULL);
73	ASSERT_EQ(CRYPT_EAL_MdInit(NULL), CRYPT_NULL_INPUT);	73	ASSERT_EQ(CRYPT_EAL_MdInit(NULL), CRYPT_NULL_INPUT);
74		74
	@@ -104,7 +104,7 @@ EXIT:
104	void SDV_CRYPT_EAL_SHA1_API_TC002(void)	104	void SDV_CRYPT_EAL_SHA1_API_TC002(void)
105	{	105	{
106	TestMemInit();	106	TestMemInit();
107	- CRYPT_EAL_MdCTX *ctx = NULL;	107	+ CRYPT_EAL_MdCtx *ctx = NULL;
108	const uint32_t dataLen = SHA1_DIGEST_LEN;	108	const uint32_t dataLen = SHA1_DIGEST_LEN;
109	uint8_t data[SHA1_DIGEST_LEN];	109	uint8_t data[SHA1_DIGEST_LEN];
110	uint32_t digestLen = SHA1_DIGEST_LEN;	110	uint32_t digestLen = SHA1_DIGEST_LEN;
	@@ -163,7 +163,7 @@ EXIT:
163	void SDV_CRYPT_EAL_SHA1_API_TC003(Hex hash1, Hex data2, Hex hash2, Hex hash3)	163	void SDV_CRYPT_EAL_SHA1_API_TC003(Hex hash1, Hex data2, Hex hash2, Hex hash3)
164	{	164	{
165	TestMemInit();	165	TestMemInit();
166	- CRYPT_EAL_MdCTX *ctx = NULL;	166	+ CRYPT_EAL_MdCtx *ctx = NULL;
167	uint32_t digestLen = SHA1_DIGEST_LEN;	167	uint32_t digestLen = SHA1_DIGEST_LEN;
168	uint8_t out[SHA1_DIGEST_LEN];	168	uint8_t out[SHA1_DIGEST_LEN];
169	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);	169	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
	@@ -231,7 +231,7 @@ EXIT:
231	void SDV_CRYPT_EAL_SHA1_FUN_TC001(Hex data, Hex hash)	231	void SDV_CRYPT_EAL_SHA1_FUN_TC001(Hex data, Hex hash)
232	{	232	{
233	TestMemInit();	233	TestMemInit();
234	- CRYPT_EAL_MdCTX *ctx = NULL;	234	+ CRYPT_EAL_MdCtx *ctx = NULL;
235	uint32_t digestLen = SHA1_DIGEST_LEN;	235	uint32_t digestLen = SHA1_DIGEST_LEN;
236	uint8_t out[SHA1_DIGEST_LEN];	236	uint8_t out[SHA1_DIGEST_LEN];
237	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);	237	ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
	@@ -307,7 +307,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC003(Hex plain_text1, Hex plain_text2, Hex *plain
307	uint32_t outLen = SHA1_DIGEST_LEN;	307	uint32_t outLen = SHA1_DIGEST_LEN;
308		308
309	TestMemInit();	309	TestMemInit();
310	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);	310	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
311	ASSERT_TRUE(ctx != NULL);	311	ASSERT_TRUE(ctx != NULL);
312	ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);	312	ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
313		313
	@@ -347,9 +347,9 @@ EXIT:
347	void SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)	347	void SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)
348	{	348	{
349	TestMemInit();	349	TestMemInit();
350	- CRYPT_EAL_MdCTX *cpyCtx = NULL;	350	+ CRYPT_EAL_MdCtx *cpyCtx = NULL;
351	- CRYPT_EAL_MdCTX *dupCtx = NULL;	351	+ CRYPT_EAL_MdCtx *dupCtx = NULL;
352	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);	352	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(id);
353	ASSERT_TRUE(ctx != NULL);	353	ASSERT_TRUE(ctx != NULL);
354	uint8_t output[SHA1_DIGEST_LEN];	354	uint8_t output[SHA1_DIGEST_LEN];
355	uint32_t outLen = SHA1_DIGEST_LEN;	355	uint32_t outLen = SHA1_DIGEST_LEN;
	@@ -402,7 +402,7 @@ void SDV_CRYPT_EAL_SHA1_FUN_TC004(int id, Hex msg, Hex hash)
402	TestMemInit();	402	TestMemInit();
403	uint8_t output[SHA1_DIGEST_LEN];	403	uint8_t output[SHA1_DIGEST_LEN];
404	uint32_t outLen = SHA1_DIGEST_LEN;	404	uint32_t outLen = SHA1_DIGEST_LEN;
405	- CRYPT_EAL_MdCTX *ctx = NULL;	405	+ CRYPT_EAL_MdCtx *ctx = NULL;
406	#ifdef HITLS_CRYPTO_PROVIDER	406	#ifdef HITLS_CRYPTO_PROVIDER
407	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");	407	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
408	#else	408	#else

Mtestcode/sdv/testcase/crypto/sha2/test_suite_sdv_eal_md_sha2.c+21-21

	@@ -39,7 +39,7 @@ void Sha2MultiThreadTest(void *arg)
39	ThreadParameter threadParameter = (ThreadParameter )arg;	39	ThreadParameter threadParameter = (ThreadParameter )arg;
40	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;	40	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
41	uint8_t out[SHA2_OUTPUT_MAXSIZE];	41	uint8_t out[SHA2_OUTPUT_MAXSIZE];
42	- CRYPT_EAL_MdCTX *ctx = NULL;	42	+ CRYPT_EAL_MdCtx *ctx = NULL;
43	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);	43	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
44	ASSERT_TRUE(ctx != NULL);	44	ASSERT_TRUE(ctx != NULL);
45	for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times	45	for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times
	@@ -68,7 +68,7 @@ EXIT:
68	void SDV_CRYPT_EAL_SHA2_API_TC001(void)	68	void SDV_CRYPT_EAL_SHA2_API_TC001(void)
69	{	69	{
70	TestMemInit();	70	TestMemInit();
71	- CRYPT_EAL_MdCTX *ctx = NULL;	71	+ CRYPT_EAL_MdCtx *ctx = NULL;
72		72
73	ctx = CRYPT_EAL_MdNewCtx(-1);	73	ctx = CRYPT_EAL_MdNewCtx(-1);
74	ASSERT_TRUE(ctx == NULL);	74	ASSERT_TRUE(ctx == NULL);
	@@ -146,7 +146,7 @@ EXIT:
146	void SDV_CRYPT_EAL_SHA2_API_TC003(int id)	146	void SDV_CRYPT_EAL_SHA2_API_TC003(int id)
147	{	147	{
148	TestMemInit();	148	TestMemInit();
149	- CRYPT_EAL_MdCTX *ctx = NULL;	149	+ CRYPT_EAL_MdCtx *ctx = NULL;
150		150
151	ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_NULL_INPUT);	151	ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_NULL_INPUT);
152		152
	@@ -208,8 +208,8 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC001(int id)
208	SKIP_TEST();	208	SKIP_TEST();
209	}	209	}
210	TestMemInit();	210	TestMemInit();
211	- CRYPT_EAL_MdCTX *ctx1 = NULL;	211	+ CRYPT_EAL_MdCtx *ctx1 = NULL;
212	- CRYPT_EAL_MdCTX *ctx2 = NULL;	212	+ CRYPT_EAL_MdCtx *ctx2 = NULL;
213		213
214	ctx1 = CRYPT_EAL_MdNewCtx(id);	214	ctx1 = CRYPT_EAL_MdNewCtx(id);
215	ASSERT_TRUE(ctx1 != NULL);	215	ASSERT_TRUE(ctx1 != NULL);
	@@ -266,7 +266,7 @@ EXIT:
266	void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC002(int id, Hex *digest)	266	void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC002(int id, Hex *digest)
267	{	267	{
268	TestMemInit();	268	TestMemInit();
269	- CRYPT_EAL_MdCTX *ctx = NULL;	269	+ CRYPT_EAL_MdCtx *ctx = NULL;
270	ctx = CRYPT_EAL_MdNewCtx(id);	270	ctx = CRYPT_EAL_MdNewCtx(id);
271	ASSERT_TRUE(ctx != NULL);	271	ASSERT_TRUE(ctx != NULL);
272		272
	@@ -301,7 +301,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC003(int algId, Hex in, Hex digest)
301	SKIP_TEST();	301	SKIP_TEST();
302	}	302	}
303	TestMemInit();	303	TestMemInit();
304	- CRYPT_EAL_MdCTX *ctx = NULL;	304	+ CRYPT_EAL_MdCtx *ctx = NULL;
305		305
306	uint8_t out[SHA2_OUTPUT_MAXSIZE];	306	uint8_t out[SHA2_OUTPUT_MAXSIZE];
307	uint32_t outLen = CRYPT_EAL_MdGetDigestSize(algId);	307	uint32_t outLen = CRYPT_EAL_MdGetDigestSize(algId);
	@@ -347,7 +347,7 @@ void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC004(int algId, Hex plain_text1, Hex plain_te
347	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;	347	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
348		348
349	TestMemInit();	349	TestMemInit();
350	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(algId);	350	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(algId);
351	ASSERT_TRUE(ctx != NULL);	351	ASSERT_TRUE(ctx != NULL);
352	ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);	352	ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
353		353
	@@ -425,9 +425,9 @@ void SDV_CRYPTO_SHA2_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)
425	SKIP_TEST();	425	SKIP_TEST();
426	}	426	}
427	TestMemInit();	427	TestMemInit();
428	- CRYPT_EAL_MdCTX *cpyCtx = NULL;	428	+ CRYPT_EAL_MdCtx *cpyCtx = NULL;
429	- CRYPT_EAL_MdCTX *dupCtx = NULL;	429	+ CRYPT_EAL_MdCtx *dupCtx = NULL;
430	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);	430	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(id);
431	ASSERT_TRUE(ctx != NULL);	431	ASSERT_TRUE(ctx != NULL);
432	uint8_t output[SHA2_OUTPUT_MAXSIZE];	432	uint8_t output[SHA2_OUTPUT_MAXSIZE];
433	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;	433	uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
	@@ -476,7 +476,7 @@ EXIT:
476	void SDV_CRYPTO_SHA2_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex msg, Hex hash)	476	void SDV_CRYPTO_SHA2_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex msg, Hex hash)
477	{	477	{
478	TestMemInit();	478	TestMemInit();
479	- CRYPT_EAL_MdCTX *ctx = NULL;	479	+ CRYPT_EAL_MdCtx *ctx = NULL;
480	#ifdef HITLS_CRYPTO_PROVIDER	480	#ifdef HITLS_CRYPTO_PROVIDER
481	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");	481	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
482	#else	482	#else
	@@ -672,8 +672,8 @@ void SDV_CRYPTO_SHA256_MB_FUNC_TC004(int msgLen)
672	TestMemInit();	672	TestMemInit();
673	uint8_t *data1 = NULL;	673	uint8_t *data1 = NULL;
674	uint8_t *data2 = NULL;	674	uint8_t *data2 = NULL;
675	- CRYPT_EAL_MdCTX *seqCtx1 = NULL;	675	+ CRYPT_EAL_MdCtx *seqCtx1 = NULL;
676	- CRYPT_EAL_MdCTX *seqCtx2 = NULL;	676	+ CRYPT_EAL_MdCtx *seqCtx2 = NULL;
677		677
678	/* Allocate and fill test data */	678	/* Allocate and fill test data */
679	data1 = (uint8_t *)malloc(msgLen);	679	data1 = (uint8_t *)malloc(msgLen);
	@@ -786,8 +786,8 @@ void SDV_CRYPTO_SHA256_MB_FUNC_TC003(void)
786		786
787	AARCH64_CHECK_CANARY();	787	AARCH64_CHECK_CANARY();
788	/* Sequential computation for verification */	788	/* Sequential computation for verification */
789	- CRYPT_EAL_MdCTX *seqCtx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);	789	+ CRYPT_EAL_MdCtx *seqCtx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
790	- CRYPT_EAL_MdCTX *seqCtx2 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);	790	+ CRYPT_EAL_MdCtx *seqCtx2 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
791	ASSERT_TRUE(seqCtx1 != NULL && seqCtx2 != NULL);	791	ASSERT_TRUE(seqCtx1 != NULL && seqCtx2 != NULL);
792		792
793	uint8_t seqDgst1[CRYPT_SHA2_256_DIGESTSIZE];	793	uint8_t seqDgst1[CRYPT_SHA2_256_DIGESTSIZE];
	@@ -881,7 +881,7 @@ void SDV_CRYPT_EAL_SHA256_MB_API_TC002(void)
881	#else	881	#else
882	TestMemInit();	882	TestMemInit();
883		883
884	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdMBNewCtx(NULL, CRYPT_MD_SHA256_MB, 2);	884	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdMBNewCtx(NULL, CRYPT_MD_SHA256_MB, 2);
885	ASSERT_TRUE(ctx != NULL);	885	ASSERT_TRUE(ctx != NULL);
886	ASSERT_EQ(CRYPT_EAL_MdMBInit(ctx), CRYPT_SUCCESS);	886	ASSERT_EQ(CRYPT_EAL_MdMBInit(ctx), CRYPT_SUCCESS);
887		887
	@@ -937,7 +937,7 @@ void SDV_CRYPT_EAL_SHA256_MB_FUNC_TC001(Hex msg, Hex digest)
937	#else	937	#else
938	TestMemInit();	938	TestMemInit();
939		939
940	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdMBNewCtx(NULL, CRYPT_MD_SHA256_MB, 2);	940	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdMBNewCtx(NULL, CRYPT_MD_SHA256_MB, 2);
941	ASSERT_TRUE(ctx != NULL);	941	ASSERT_TRUE(ctx != NULL);
942		942
943	const uint8_t *dataArr[2] = {msg->x, msg->x};	943	const uint8_t *dataArr[2] = {msg->x, msg->x};
	@@ -989,9 +989,9 @@ void SDV_CRYPT_EAL_SHA256_MB_FUNC_TC002(int msgLen)
989		989
990	uint8_t *data1 = NULL;	990	uint8_t *data1 = NULL;
991	uint8_t *data2 = NULL;	991	uint8_t *data2 = NULL;
992	- CRYPT_EAL_MdCTX *mbCtx = NULL;	992	+ CRYPT_EAL_MdCtx *mbCtx = NULL;
993	- CRYPT_EAL_MdCTX *seqCtx1 = NULL;	993	+ CRYPT_EAL_MdCtx *seqCtx1 = NULL;
994	- CRYPT_EAL_MdCTX *seqCtx2 = NULL;	994	+ CRYPT_EAL_MdCtx *seqCtx2 = NULL;
995		995
996	uint32_t allocLen = (msgLen == 0) ? 1u : (uint32_t)msgLen;	996	uint32_t allocLen = (msgLen == 0) ? 1u : (uint32_t)msgLen;
997	data1 = (uint8_t *)malloc(allocLen);	997	data1 = (uint8_t *)malloc(allocLen);

Mtestcode/sdv/testcase/crypto/sha3/test_suite_sdv_eal_md_sha3.c+13-13

	@@ -41,7 +41,7 @@ void Sha3MultiThreadTest(void *arg)
41	ThreadParameter threadParameter = (ThreadParameter )arg;	41	ThreadParameter threadParameter = (ThreadParameter )arg;
42	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;	42	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
43	uint8_t out[SHA3_OUTPUT_MAXSIZE];	43	uint8_t out[SHA3_OUTPUT_MAXSIZE];
44	- CRYPT_EAL_MdCTX *ctx = NULL;	44	+ CRYPT_EAL_MdCtx *ctx = NULL;
45	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);	45	ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
46	ASSERT_TRUE(ctx != NULL);	46	ASSERT_TRUE(ctx != NULL);
47	for (uint32_t i = 0; i < 10; i++) {	47	for (uint32_t i = 0; i < 10; i++) {
	@@ -113,7 +113,7 @@ EXIT:
113	void SDV_CRYPT_EAL_SHA3_API_TC002(int algId)	113	void SDV_CRYPT_EAL_SHA3_API_TC002(int algId)
114	{	114	{
115	TestMemInit();	115	TestMemInit();
116	- CRYPT_EAL_MdCTX *sha3Ctx = NULL;	116	+ CRYPT_EAL_MdCtx *sha3Ctx = NULL;
117		117
118	ASSERT_EQ(CRYPT_EAL_MdDeinit(sha3Ctx), CRYPT_NULL_INPUT);	118	ASSERT_EQ(CRYPT_EAL_MdDeinit(sha3Ctx), CRYPT_NULL_INPUT);
119		119
	@@ -169,8 +169,8 @@ EXIT:
169	void SDV_CRYPT_EAL_SHA3_FUNC_TC001(int algId)	169	void SDV_CRYPT_EAL_SHA3_FUNC_TC001(int algId)
170	{	170	{
171	TestMemInit();	171	TestMemInit();
172	- CRYPT_EAL_MdCTX *ctx1 = NULL;	172	+ CRYPT_EAL_MdCtx *ctx1 = NULL;
173	- CRYPT_EAL_MdCTX *ctx2 = NULL;	173	+ CRYPT_EAL_MdCtx *ctx2 = NULL;
174		174
175	ctx1 = CRYPT_EAL_MdNewCtx(algId);	175	ctx1 = CRYPT_EAL_MdNewCtx(algId);
176	ASSERT_TRUE(ctx1 != NULL);	176	ASSERT_TRUE(ctx1 != NULL);
	@@ -264,7 +264,7 @@ EXIT:
264	void SDV_CRYPT_EAL_SHA3_FUNC_TC003(int algId, Hex in, Hex digest)	264	void SDV_CRYPT_EAL_SHA3_FUNC_TC003(int algId, Hex in, Hex digest)
265	{	265	{
266	TestMemInit();	266	TestMemInit();
267	- CRYPT_EAL_MdCTX *ctx = NULL;	267	+ CRYPT_EAL_MdCtx *ctx = NULL;
268		268
269	uint8_t out[SHA3_OUTPUT_MAXSIZE];	269	uint8_t out[SHA3_OUTPUT_MAXSIZE];
270	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;	270	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
	@@ -299,7 +299,7 @@ EXIT:
299	void SDV_CRYPT_EAL_SHA3_FUNC_TC004(int algId, Hex in, Hex digest)	299	void SDV_CRYPT_EAL_SHA3_FUNC_TC004(int algId, Hex in, Hex digest)
300	{	300	{
301	TestMemInit();	301	TestMemInit();
302	- CRYPT_EAL_MdCTX *ctx = NULL;	302	+ CRYPT_EAL_MdCtx *ctx = NULL;
303		303
304	uint8_t out[SHA3_OUTPUT_MAXSIZE];	304	uint8_t out[SHA3_OUTPUT_MAXSIZE];
305	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;	305	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
	@@ -329,7 +329,7 @@ EXIT:
329	void SDV_CRYPT_EAL_SHA3_FUNC_TC005(int algId, Hex in, Hex digest, int isProvider)	329	void SDV_CRYPT_EAL_SHA3_FUNC_TC005(int algId, Hex in, Hex digest, int isProvider)
330	{	330	{
331	TestMemInit();	331	TestMemInit();
332	- CRYPT_EAL_MdCTX *ctx = NULL;	332	+ CRYPT_EAL_MdCtx *ctx = NULL;
333		333
334	uint8_t out[SHA3_OUTPUT_MAXSIZE];	334	uint8_t out[SHA3_OUTPUT_MAXSIZE];
335	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;	335	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
	@@ -366,7 +366,7 @@ EXIT:
366	void SDV_CRYPT_EAL_SHA3_FUNC_TC006(int algId, Hex in, int outLen, Hex digest, int isProvider)	366	void SDV_CRYPT_EAL_SHA3_FUNC_TC006(int algId, Hex in, int outLen, Hex digest, int isProvider)
367	{	367	{
368	TestMemInit();	368	TestMemInit();
369	- CRYPT_EAL_MdCTX *ctx = NULL;	369	+ CRYPT_EAL_MdCtx *ctx = NULL;
370	int32_t squeezeLen = digest->len / 3;	370	int32_t squeezeLen = digest->len / 3;
371	uint8_t *out = malloc(outLen);	371	uint8_t *out = malloc(outLen);
372	ASSERT_TRUE(out != NULL);	372	ASSERT_TRUE(out != NULL);
	@@ -418,9 +418,9 @@ EXIT:
418	void SDV_CRYPTO_SHA3_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)	418	void SDV_CRYPTO_SHA3_COPY_CTX_FUNC_TC001(int id, Hex msg, Hex hash)
419	{	419	{
420	TestMemInit();	420	TestMemInit();
421	- CRYPT_EAL_MdCTX *cpyCtx = NULL;	421	+ CRYPT_EAL_MdCtx *cpyCtx = NULL;
422	- CRYPT_EAL_MdCTX *dupCtx = NULL;	422	+ CRYPT_EAL_MdCtx *dupCtx = NULL;
423	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);	423	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_MdNewCtx(id);
424	ASSERT_TRUE(ctx != NULL);	424	ASSERT_TRUE(ctx != NULL);
425	uint8_t output[SHA3_OUTPUT_MAXSIZE];	425	uint8_t output[SHA3_OUTPUT_MAXSIZE];
426	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;	426	uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
	@@ -471,7 +471,7 @@ EXIT:
471	void SDV_CRYPTO_SHA3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex msg, Hex hash)	471	void SDV_CRYPTO_SHA3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex msg, Hex hash)
472	{	472	{
473	TestMemInit();	473	TestMemInit();
474	- CRYPT_EAL_MdCTX *ctx = NULL;	474	+ CRYPT_EAL_MdCtx *ctx = NULL;
475	#ifdef HITLS_CRYPTO_PROVIDER	475	#ifdef HITLS_CRYPTO_PROVIDER
476	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");	476	ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
477	#else	477	#else
	@@ -505,7 +505,7 @@ EXIT:
505	void SDV_CRYPT_EAL_SHA3_FUNC_TC007(int algId, int outLen, Hex in, Hex digest)	505	void SDV_CRYPT_EAL_SHA3_FUNC_TC007(int algId, int outLen, Hex in, Hex digest)
506	{	506	{
507	TestMemInit();	507	TestMemInit();
508	- CRYPT_EAL_MdCTX *ctx = NULL;	508	+ CRYPT_EAL_MdCtx *ctx = NULL;
509	int32_t squeezeLen = 130;	509	int32_t squeezeLen = 130;
510	uint32_t tmpLen = outLen;	510	uint32_t tmpLen = outLen;
511	uint8_t *out1 = malloc(outLen);	511	uint8_t *out1 = malloc(outLen);

Mtls/crypt/crypt_self/hitls_crypt.c+5-5

	@@ -284,7 +284,7 @@ int32_t HITLS_CRYPT_HMAC(HITLS_Lib_Ctx libCtx, const char attrName,
284	HITLS_HASH_Ctx HITLS_CRYPT_DigestInit(HITLS_Lib_Ctx libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)	284	HITLS_HASH_Ctx HITLS_CRYPT_DigestInit(HITLS_Lib_Ctx libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)
285	{	285	{
286	#ifdef HITLS_CRYPTO_MD	286	#ifdef HITLS_CRYPTO_MD
287	- CRYPT_EAL_MdCTX *ctx = NULL;	287	+ CRYPT_EAL_MdCtx *ctx = NULL;
288	ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);	288	ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);
289	if (ctx == NULL) {	289	if (ctx == NULL) {
290	BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16628, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MdNewCtx fail", 0, 0, 0, 0);	290	BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16628, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MdNewCtx fail", 0, 0, 0, 0);
	@@ -313,7 +313,7 @@ int32_t HITLS_CRYPT_Digest(HITLS_Lib_Ctx libCtx, const char attrName,
313	{	313	{
314	#ifdef HITLS_CRYPTO_MD	314	#ifdef HITLS_CRYPTO_MD
315	int32_t ret;	315	int32_t ret;
316	- CRYPT_EAL_MdCTX *ctx = NULL;	316	+ CRYPT_EAL_MdCtx *ctx = NULL;
317	ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);	317	ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);
318	if (ctx == NULL) {	318	if (ctx == NULL) {
319	return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DIGEST, BINLOG_ID16631, "MdNewCtx fail");	319	return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DIGEST, BINLOG_ID16631, "MdNewCtx fail");
	@@ -1005,7 +1005,7 @@ int32_t HITLS_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx,
1005	"GetHmacAlgId fail", 0, 0, 0, 0);	1005	"GetHmacAlgId fail", 0, 0, 0, 0);
1006	return HITLS_CRYPT_ERR_HMAC;	1006	return HITLS_CRYPT_ERR_HMAC;
1007	}	1007	}
1008	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	1008	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
1009	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);	1009	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
1010	if (kdfCtx == NULL) {	1010	if (kdfCtx == NULL) {
1011	return HITLS_CRYPT_ERR_HKDF_EXTRACT;	1011	return HITLS_CRYPT_ERR_HKDF_EXTRACT;
	@@ -1053,7 +1053,7 @@ int32_t HITLS_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx,
1053	if (id == CRYPT_MAC_MAX) {	1053	if (id == CRYPT_MAC_MAX) {
1054	return HITLS_CRYPT_ERR_HMAC;	1054	return HITLS_CRYPT_ERR_HMAC;
1055	}	1055	}
1056	- CRYPT_EAL_KdfCTX *kdfCtx = NULL;	1056	+ CRYPT_EAL_KdfCtx *kdfCtx = NULL;
1057	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);	1057	kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
1058	if (kdfCtx == NULL) {	1058	if (kdfCtx == NULL) {
1059	return HITLS_CRYPT_ERR_HKDF_EXPAND;	1059	return HITLS_CRYPT_ERR_HKDF_EXPAND;
	@@ -1264,7 +1264,7 @@ int32_t HITLS_CRYPT_PRF(CRYPT_KeyDeriveParameters input, uint8_t out, uint32_t
1264	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12	1264	BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12
1265	InitKdfTls12Param(input, &id, params);	1265	InitKdfTls12Param(input, &id, params);
1266		1266
1267	- CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_ProviderKdfNewCtx(input->libCtx, CRYPT_KDF_KDFTLS12, input->attrName);	1267	+ CRYPT_EAL_KdfCtx *ctx = CRYPT_EAL_ProviderKdfNewCtx(input->libCtx, CRYPT_KDF_KDFTLS12, input->attrName);
1268	if (ctx == NULL) {	1268	if (ctx == NULL) {
1269	BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17374, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "KdfNewCtx fail", 0, 0, 0, 0);	1269	BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17374, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "KdfNewCtx fail", 0, 0, 0, 0);
1270	return HITLS_CRYPT_ERR_KDF;	1270	return HITLS_CRYPT_ERR_KDF;

	@@ -273,7 +273,7 @@ For example code, refer to `crypt_default_provider.c:CryptGetSignAlgCaps`
273	...	273	...
274	// For actual use, it is recommended to use EAL layer wrapping interfaces for each algorithm,	274	// For actual use, it is recommended to use EAL layer wrapping interfaces for each algorithm,
275	// which automatically locate and initialize the algorithm.	275	// which automatically locate and initialize the algorithm.
276	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=no_hitls,type=hash");	276	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=no_hitls,type=hash");
277	assert(ctx != NULL);	277	assert(ctx != NULL);
278	...	278	...
279	```	279	```
	@@ -453,7 +453,7 @@ int main() {
453		453
454	// Using the built-in HITLS algorithm library:	454	// Using the built-in HITLS algorithm library:
455	// Step 1: Directly initialize using EAL layer MD interface	455	// Step 1: Directly initialize using EAL layer MD interface
456	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "provider=default");	456	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "provider=default");
457	ASSERT_TRUE(ctx != NULL);	457	ASSERT_TRUE(ctx != NULL);
458		458
459	-----------------------------------------------	459	-----------------------------------------------
	@@ -472,7 +472,7 @@ int main() {
472	ASSERT_TRUE(ret == CRYPT_SUCCESS);	472	ASSERT_TRUE(ret == CRYPT_SUCCESS);
473		473
474	// Step 4: Directly initialize using EAL layer MD interface	474	// Step 4: Directly initialize using EAL layer MD interface
475	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");	475	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");
476	ASSERT_TRUE(ctx != NULL);	476	ASSERT_TRUE(ctx != NULL);
477		477
478	-----------------------------------------------	478	-----------------------------------------------
	@@ -487,7 +487,7 @@ int main() {
487	ASSERT_TRUE(ret == CRYPT_SUCCESS);	487	ASSERT_TRUE(ret == CRYPT_SUCCESS);
488		488
489	// Step 3: Directly initialize using EAL layer MD interface	489	// Step 3: Directly initialize using EAL layer MD interface
490	- CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");	490	+ CRYPT_EAL_MdCtx *ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_SM3, "attr1=temp_attr1,attr2=temp_attr2");
491	ASSERT_TRUE(ctx != NULL);	491	ASSERT_TRUE(ctx != NULL);
492		492
493	------------------------------------------------------------------------------------------------------	493	------------------------------------------------------------------------------------------------------