Star1150
753
代码
代码
Issues34
Pull Requests59
Actions
项目讨论
Wiki
分析
Star1150
753
已合并
feat: Add context copy capability for cipher,kdf and MAC algorithms. #981
Dongjianwei001创建于 1月5日
feat: Add context copy capability for cipher,kdf and MAC algorithms. #981
已合并
Dongjianwei001创建于 1月5日
从Dongjianwei001/openhitlsopenhitls-0.2合入到openHiTLS/openhitlsopenhitls-0.2
共 76 个文件变更+3576-81
Mcrypto/cmac/include/crypt_cbc_mac.h+7-0
@@ -100,6 +100,13 @@ int32_t CRYPT_CBC_MAC_Ctrl(CRYPT_CBC_MAC_Ctx *ctx, uint32_t opt, void *val, uint
100 */100 */
101void CRYPT_CBC_MAC_FreeCtx(CRYPT_CBC_MAC_Ctx *ctx);101void CRYPT_CBC_MAC_FreeCtx(CRYPT_CBC_MAC_Ctx *ctx);
102 102 
103+/**
104+ * @brief Dup the CBC_MAC context.
105+ * @param ctx [IN] CBC_MAC context.
106+ * @retval CBC_MAC context.
107+ */
108+CRYPT_CBC_MAC_Ctx *CRYPT_CBC_MAC_DupCtx(const CRYPT_CBC_MAC_Ctx *ctx);
109+ 
103#ifdef __cplusplus110#ifdef __cplusplus
104}111}
105#endif /* __cpluscplus */112#endif /* __cpluscplus */
Mcrypto/cmac/include/crypt_cmac.h+7-0
@@ -98,6 +98,13 @@ int32_t CRYPT_CMAC_Ctrl(CRYPT_CMAC_Ctx *ctx, uint32_t opt, void *val, uint32_t l
98 */98 */
99void CRYPT_CMAC_FreeCtx(CRYPT_CMAC_Ctx *ctx);99void CRYPT_CMAC_FreeCtx(CRYPT_CMAC_Ctx *ctx);
100 100 
101+/**
102+ * @brief Dup the CMAC context.
103+ * @param ctx [IN] CMAC context.
104+ * @retval CMAC context.
105+ */
106+CRYPT_CMAC_Ctx *CRYPT_CMAC_DupCtx(const CRYPT_CMAC_Ctx *ctx);
107+ 
101#ifdef __cplusplus108#ifdef __cplusplus
102}109}
103#endif /* __cpluscplus */110#endif /* __cpluscplus */
Mcrypto/cmac/src/cbc_mac.c+23-0
@@ -164,4 +164,27 @@ void CRYPT_CBC_MAC_FreeCtx(CRYPT_CBC_MAC_Ctx *ctx)
164 CipherMacDeinitCtx(&ctx->common);164 CipherMacDeinitCtx(&ctx->common);
165 BSL_SAL_Free(ctx);165 BSL_SAL_Free(ctx);
166}166}
167+ 
168+CRYPT_CBC_MAC_Ctx *CRYPT_CBC_MAC_DupCtx(const CRYPT_CBC_MAC_Ctx *ctx)
169+{
170+ if (ctx == NULL) {
171+ BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
172+ return NULL;
173+ }
174+ 
175+ CRYPT_CBC_MAC_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_CBC_MAC_Ctx));
176+ if (newCtx == NULL) {
177+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
178+ return NULL;
179+ }
180+ 
181+ void *key = BSL_SAL_Dump(ctx->common.key, ctx->common.method->ctxSize);
182+ if (key == NULL) {
183+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
184+ BSL_SAL_Free(newCtx);
185+ return NULL;
186+ }
187+ newCtx->common.key = key;
188+ return newCtx;
189+}
167#endif190#endif
Mcrypto/cmac/src/cmac.c+23-0
@@ -173,4 +173,27 @@ void CRYPT_CMAC_FreeCtx(CRYPT_CMAC_Ctx *ctx)
173 BSL_SAL_Free(ctx);173 BSL_SAL_Free(ctx);
174}174}
175 175 
176+CRYPT_CMAC_Ctx *CRYPT_CMAC_DupCtx(const CRYPT_CMAC_Ctx *ctx)
177+{
178+ if (ctx == NULL) {
179+ BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
180+ return NULL;
181+ }
182+ 
183+ CRYPT_CMAC_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_CMAC_Ctx));
184+ if (newCtx == NULL) {
185+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
186+ return NULL;
187+ }
188+ 
189+ void *key = BSL_SAL_Dump(ctx->key, ctx->method->ctxSize);
190+ if (key == NULL) {
191+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
192+ BSL_SAL_Free(newCtx);
193+ return NULL;
194+ }
195+ newCtx->key = key;
196+ return newCtx;
197+}
198+ 
176#endif /* HITLS_CRYPTO_CMAC */199#endif /* HITLS_CRYPTO_CMAC */
Mcrypto/eal/src/eal_cipher.c+68-0
@@ -40,6 +40,7 @@ static void CipherCopyMethod(const EAL_CipherMethod *modeMethod, EAL_CipherUnita
40 method->final = modeMethod->final;40 method->final = modeMethod->final;
41 method->ctrl = modeMethod->ctrl;41 method->ctrl = modeMethod->ctrl;
42 method->freeCtx = modeMethod->freeCtx;42 method->freeCtx = modeMethod->freeCtx;
43+ method->dupCtx = modeMethod->dupCtx;
43}44}
44 45 
45static CRYPT_EAL_CipherCtx *CipherNewDefaultCtx(CRYPT_CIPHER_AlgId id)46static CRYPT_EAL_CipherCtx *CipherNewDefaultCtx(CRYPT_CIPHER_AlgId id)
@@ -115,6 +116,9 @@ static int32_t CRYPT_EAL_SetCipherMethod(CRYPT_EAL_CipherCtx *ctx, const CRYPT_E
115 case CRYPT_EAL_IMPLCIPHER_CTRL:116 case CRYPT_EAL_IMPLCIPHER_CTRL:
116 method->ctrl = funcs[index].func;117 method->ctrl = funcs[index].func;
117 break;118 break;
119+ case CRYPT_EAL_IMPLCIPHER_DUPCTX:
120+ method->dupCtx = funcs[index].func;
121+ break;
118 default:122 default:
119 BSL_SAL_FREE(method);123 BSL_SAL_FREE(method);
120 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);124 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
@@ -539,4 +543,68 @@ int32_t CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AlgId id, int32_t type, uint32_t *i
539 return CRYPT_SUCCESS;543 return CRYPT_SUCCESS;
540}544}
541 545 
546+int32_t CRYPT_EAL_CipherCopyCtx(CRYPT_EAL_CipherCtx *to, const CRYPT_EAL_CipherCtx *from)
547+{
548+ if (to == NULL || from == NULL || from->method == NULL || from->method->dupCtx == NULL) {
549+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, CRYPT_CIPHER_MAX, CRYPT_NULL_INPUT);
550+ return CRYPT_NULL_INPUT;
551+ }
552+ 
553+ if (to->ctx != NULL) {
554+ if (to->method == NULL || to->method->freeCtx == NULL) {
555+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_INVALID_ARG);
556+ return CRYPT_INVALID_ARG;
557+ }
558+ to->method->freeCtx(to->ctx);
559+ to->ctx = NULL;
560+ }
561+ if (to->method != NULL) {
562+ BSL_SAL_FREE(to->method);
563+ }
564+ 
565+ EAL_CipherUnitaryMethod *tmpMethod = BSL_SAL_Dump(from->method, sizeof(EAL_CipherUnitaryMethod));
566+ if (tmpMethod == NULL) {
567+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_MEM_ALLOC_FAIL);
568+ return CRYPT_MEM_ALLOC_FAIL;
569+ }
570+ void *ctx = from->method->dupCtx(from->ctx);
571+ if (ctx == NULL) {
572+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_MEM_ALLOC_FAIL);
573+ BSL_SAL_Free(tmpMethod);
574+ return CRYPT_MEM_ALLOC_FAIL;
575+ }
576+ (void)memcpy_s(to, sizeof(CRYPT_EAL_CipherCtx), from, sizeof(CRYPT_EAL_CipherCtx));
577+ to->ctx = ctx;
578+ to->method = tmpMethod;
579+ return CRYPT_SUCCESS;
580+}
581+ 
582+CRYPT_EAL_CipherCtx *CRYPT_EAL_CipherDupCtx(const CRYPT_EAL_CipherCtx *from)
583+{
584+ if (from == NULL || from->method == NULL || from->method->dupCtx == NULL) {
585+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, CRYPT_CIPHER_MAX, CRYPT_NULL_INPUT);
586+ return NULL;
587+ }
588+ 
589+ CRYPT_EAL_CipherCtx *newCtx = BSL_SAL_Dump(from, sizeof(CRYPT_EAL_CipherCtx));
590+ if (newCtx == NULL) {
591+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_MEM_ALLOC_FAIL);
592+ return NULL;
593+ }
594+ newCtx->method = BSL_SAL_Dump(from->method, sizeof(EAL_CipherUnitaryMethod));
595+ if (newCtx->method == NULL) {
596+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_MEM_ALLOC_FAIL);
597+ BSL_SAL_Free(newCtx);
598+ return NULL;
599+ }
600+ newCtx->ctx = from->method->dupCtx(from->ctx);
601+ if (newCtx->ctx == NULL) {
602+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_CIPHER, from->id, CRYPT_MEM_ALLOC_FAIL);
603+ BSL_SAL_Free(newCtx->method);
604+ BSL_SAL_Free(newCtx);
605+ return NULL;
606+ }
607+ return newCtx;
608+}
609+ 
542#endif610#endif
Mcrypto/eal/src/eal_cipher_method.c+22-11
@@ -72,7 +72,8 @@ static const EAL_CipherMethod CHACHA20_POLY1305_METHOD = {
72 (CipherUpdate)MODES_CHACHA20POLY1305_Update,72 (CipherUpdate)MODES_CHACHA20POLY1305_Update,
73 (CipherFinal)MODES_CHACHA20POLY1305_Final,73 (CipherFinal)MODES_CHACHA20POLY1305_Final,
74 (CipherCtrl)MODES_CHACHA20POLY1305_Ctrl,74 (CipherCtrl)MODES_CHACHA20POLY1305_Ctrl,
75- (CipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtx75+ (CipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtx,
76+ (CipherDupCtx)MODES_CHACHA20POLY1305_DupCtx
76};77};
77#endif78#endif
78 79 
@@ -84,7 +85,8 @@ static const EAL_CipherMethod CTR_METHOD = {
84 (CipherUpdate)MODES_CTR_UpdateEx,85 (CipherUpdate)MODES_CTR_UpdateEx,
85 (CipherFinal)MODES_CTR_Final,86 (CipherFinal)MODES_CTR_Final,
86 (CipherCtrl)MODES_CTR_Ctrl,87 (CipherCtrl)MODES_CTR_Ctrl,
87- (CipherFreeCtx)MODES_CTR_FreeCtx88+ (CipherFreeCtx)MODES_CTR_FreeCtx,
89+ (CipherDupCtx)MODES_CipherDupCtx
88};90};
89#endif91#endif
90 92 
@@ -96,7 +98,8 @@ static const EAL_CipherMethod CBC_METHOD = {
96 (CipherUpdate)MODES_CBC_UpdateEx,98 (CipherUpdate)MODES_CBC_UpdateEx,
97 (CipherFinal)MODES_CBC_FinalEx,99 (CipherFinal)MODES_CBC_FinalEx,
98 (CipherCtrl)MODES_CBC_Ctrl,100 (CipherCtrl)MODES_CBC_Ctrl,
99- (CipherFreeCtx)MODES_CBC_FreeCtx101+ (CipherFreeCtx)MODES_CBC_FreeCtx,
102+ (CipherDupCtx)MODES_CipherDupCtx
100};103};
101#endif104#endif
102 105 
@@ -108,7 +111,8 @@ static const EAL_CipherMethod ECB_METHOD = {
108 (CipherUpdate)MODES_ECB_UpdateEx,111 (CipherUpdate)MODES_ECB_UpdateEx,
109 (CipherFinal)MODES_ECB_FinalEx,112 (CipherFinal)MODES_ECB_FinalEx,
110 (CipherCtrl)MODES_ECB_Ctrl,113 (CipherCtrl)MODES_ECB_Ctrl,
111- (CipherFreeCtx)MODES_ECB_FreeCtx114+ (CipherFreeCtx)MODES_ECB_FreeCtx,
115+ (CipherDupCtx)MODES_CipherDupCtx
112};116};
113#endif117#endif
114 118 
@@ -120,7 +124,8 @@ static const EAL_CipherMethod CCM_METHOD = {
120 (CipherUpdate)MODES_CCM_UpdateEx,124 (CipherUpdate)MODES_CCM_UpdateEx,
121 (CipherFinal)MODES_CCM_Final,125 (CipherFinal)MODES_CCM_Final,
122 (CipherCtrl)MODES_CCM_Ctrl,126 (CipherCtrl)MODES_CCM_Ctrl,
123- (CipherFreeCtx)MODES_CCM_FreeCtx127+ (CipherFreeCtx)MODES_CCM_FreeCtx,
128+ (CipherDupCtx)MODES_CCM_DupCtx
124};129};
125#endif130#endif
126 131 
@@ -132,7 +137,8 @@ static const EAL_CipherMethod GCM_METHOD = {
132 (CipherUpdate)MODES_GCM_UpdateEx,137 (CipherUpdate)MODES_GCM_UpdateEx,
133 (CipherFinal)MODES_GCM_Final,138 (CipherFinal)MODES_GCM_Final,
134 (CipherCtrl)MODES_GCM_Ctrl,139 (CipherCtrl)MODES_GCM_Ctrl,
135- (CipherFreeCtx)MODES_GCM_FreeCtx140+ (CipherFreeCtx)MODES_GCM_FreeCtx,
141+ (CipherDupCtx)MODES_GCM_DupCtx
136};142};
137#endif143#endif
138 144 
@@ -145,7 +151,8 @@ static const EAL_CipherMethod CFB_METHOD = {
145 (CipherUpdate)MODES_CFB_UpdateEx,151 (CipherUpdate)MODES_CFB_UpdateEx,
146 (CipherFinal)MODES_CFB_Final,152 (CipherFinal)MODES_CFB_Final,
147 (CipherCtrl)MODES_CFB_Ctrl,153 (CipherCtrl)MODES_CFB_Ctrl,
148- (CipherFreeCtx)MODES_CFB_FreeCtx154+ (CipherFreeCtx)MODES_CFB_FreeCtx,
155+ (CipherDupCtx)MODES_CFB_DupCtx
149};156};
150#endif157#endif
151 158 
@@ -157,7 +164,8 @@ static const EAL_CipherMethod OFB_METHOD = {
157 (CipherUpdate)MODES_OFB_UpdateEx,164 (CipherUpdate)MODES_OFB_UpdateEx,
158 (CipherFinal)MODES_OFB_Final,165 (CipherFinal)MODES_OFB_Final,
159 (CipherCtrl)MODES_OFB_Ctrl,166 (CipherCtrl)MODES_OFB_Ctrl,
160- (CipherFreeCtx)MODES_OFB_FreeCtx167+ (CipherFreeCtx)MODES_OFB_FreeCtx,
168+ (CipherDupCtx)MODES_CipherDupCtx
161};169};
162#endif170#endif
163 171 
@@ -169,7 +177,8 @@ static const EAL_CipherMethod XTS_METHOD = {
169 (CipherUpdate)MODES_XTS_UpdateEx,177 (CipherUpdate)MODES_XTS_UpdateEx,
170 (CipherFinal)MODES_XTS_Final,178 (CipherFinal)MODES_XTS_Final,
171 (CipherCtrl)MODES_XTS_Ctrl,179 (CipherCtrl)MODES_XTS_Ctrl,
172- (CipherFreeCtx)MODES_XTS_FreeCtx180+ (CipherFreeCtx)MODES_XTS_FreeCtx,
181+ (CipherDupCtx)MODES_XTS_DupCtx
173};182};
174#endif183#endif
175 184 
@@ -181,7 +190,8 @@ static const EAL_CipherMethod AES_WRAP_NOPAD_METHOD = {
181 (CipherUpdate)MODES_WRAP_Update,190 (CipherUpdate)MODES_WRAP_Update,
182 (CipherFinal)MODES_WRAP_Final,191 (CipherFinal)MODES_WRAP_Final,
183 (CipherCtrl)MODE_WRAP_Ctrl,192 (CipherCtrl)MODE_WRAP_Ctrl,
184- (CipherFreeCtx)MODES_WRAP_FreeCtx193+ (CipherFreeCtx)MODES_WRAP_FreeCtx,
194+ (CipherDupCtx)MODES_WRAP_DupCtx,
185};195};
186 196 
187static const EAL_CipherMethod AES_WRAP_PAD_METHOD = {197static const EAL_CipherMethod AES_WRAP_PAD_METHOD = {
@@ -191,7 +201,8 @@ static const EAL_CipherMethod AES_WRAP_PAD_METHOD = {
191 (CipherUpdate)MODES_WRAP_Update,201 (CipherUpdate)MODES_WRAP_Update,
192 (CipherFinal)MODES_WRAP_Final,202 (CipherFinal)MODES_WRAP_Final,
193 (CipherCtrl)MODE_WRAP_Ctrl,203 (CipherCtrl)MODE_WRAP_Ctrl,
194- (CipherFreeCtx)MODES_WRAP_FreeCtx204+ (CipherFreeCtx)MODES_WRAP_FreeCtx,
205+ (CipherDupCtx)MODES_WRAP_DupCtx,
195};206};
196#endif // HITLS_CRYPTO_WRAP207#endif // HITLS_CRYPTO_WRAP
197 208 
Mcrypto/eal/src/eal_kdf.c+70-0
@@ -74,6 +74,7 @@ static void EalKdfCopyMethod(const EAL_KdfMethod *method, EAL_KdfUnitaryMethod *
74 dest->deinit = method->deinit;74 dest->deinit = method->deinit;
75 dest->freeCtx = method->freeCtx;75 dest->freeCtx = method->freeCtx;
76 dest->ctrl = method->ctrl;76 dest->ctrl = method->ctrl;
77+ dest->dupCtx = method->dupCtx;
77}78}
78 79 
79#ifdef HITLS_CRYPTO_PROVIDER80#ifdef HITLS_CRYPTO_PROVIDER
@@ -106,6 +107,9 @@ static int32_t CRYPT_EAL_SetKdfMethod(CRYPT_EAL_KdfCTX *ctx, const CRYPT_EAL_Fun
106 case CRYPT_EAL_IMPLKDF_FREECTX:107 case CRYPT_EAL_IMPLKDF_FREECTX:
107 method->freeCtx = funcs[index].func;108 method->freeCtx = funcs[index].func;
108 break;109 break;
110+ case CRYPT_EAL_IMPLKDF_DUPCTX:
111+ method->dupCtx = funcs[index].func;
112+ break;
109 default:113 default:
110 BSL_SAL_FREE(method);114 BSL_SAL_FREE(method);
111 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);115 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
@@ -261,4 +265,70 @@ void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx)
261 return;265 return;
262}266}
263 267 
268+int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCTX *to, const CRYPT_EAL_KdfCTX *from)
269+{
270+ if (to == NULL || from == NULL || from->method == NULL || from->method->dupCtx == NULL) {
271+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
272+ return CRYPT_NULL_INPUT;
273+ }
274+ if (to->data != NULL) {
275+ if (to->method == NULL || to->method->freeCtx == NULL) {
276+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_INVALID_ARG);
277+ return CRYPT_INVALID_ARG;
278+ }
279+ to->method->freeCtx(to->data);
280+ to->data = NULL;
281+ }
282+ if (to->method != NULL) {
283+ BSL_SAL_FREE(to->method);
284+ }
285+ 
286+ EAL_KdfUnitaryMethod *tmpMethod = BSL_SAL_Dump(from->method, sizeof(EAL_KdfUnitaryMethod));
287+ if (tmpMethod == NULL) {
288+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
289+ return CRYPT_MEM_ALLOC_FAIL;
290+ }
291+ 
292+ void *newData = from->method->dupCtx(from->data);
293+ if (newData == NULL) {
294+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
295+ BSL_SAL_Free(tmpMethod);
296+ return CRYPT_MEM_ALLOC_FAIL;
297+ }
298+ (void)memcpy_s(to, sizeof(CRYPT_EAL_KdfCTX), from, sizeof(CRYPT_EAL_KdfCTX));
299+ to->data = newData;
300+ to->method = tmpMethod;
301+ return CRYPT_SUCCESS;
302+}
303+ 
304+CRYPT_EAL_KdfCTX *CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCTX *from)
305+{
306+ if (from == NULL || from->method == NULL || from->method->dupCtx == NULL) {
307+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, CRYPT_KDF_MAX, CRYPT_NULL_INPUT);
308+ return NULL;
309+ }
310+ 
311+ CRYPT_EAL_KdfCTX *newCtx = BSL_SAL_Dump(from, sizeof(CRYPT_EAL_KdfCTX));
312+ if (newCtx == NULL ) {
313+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
314+ return NULL;
315+ }
316+ 
317+ newCtx->method = BSL_SAL_Dump(from->method, sizeof(EAL_KdfUnitaryMethod));
318+ if (newCtx->method == NULL) {
319+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
320+ BSL_SAL_Free(newCtx);
321+ return NULL;
322+ }
323+ 
324+ newCtx->data = from->method->dupCtx(from->data);
325+ if (newCtx->data == NULL) {
326+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_KDF, from->id, CRYPT_MEM_ALLOC_FAIL);
327+ BSL_SAL_Free(newCtx->method);
328+ BSL_SAL_Free(newCtx);
329+ return NULL;
330+ }
331+ return newCtx;
332+}
333+ 
264#endif334#endif
Mcrypto/eal/src/eal_kdf_method.c+2-2
@@ -38,7 +38,7 @@
38 EAL_KdfMethod g_kdfMethod_##name = { \38 EAL_KdfMethod g_kdfMethod_##name = { \
39 (KdfNewCtx)CRYPT_##name##_NewCtx, (KdfSetParam)CRYPT_##name##_SetParam, \39 (KdfNewCtx)CRYPT_##name##_NewCtx, (KdfSetParam)CRYPT_##name##_SetParam, \
40 (KdfDerive)CRYPT_##name##_Derive, (KdfDeinit)CRYPT_##name##_Deinit, \40 (KdfDerive)CRYPT_##name##_Derive, (KdfDeinit)CRYPT_##name##_Deinit, \
41- (KdfFreeCtx)CRYPT_##name##_FreeCtx, NULL \41+ (KdfFreeCtx)CRYPT_##name##_FreeCtx, NULL, (KdfDupCtx)CRYPT_##name##_DupCtx \
42 }42 }
43 43 
44#ifdef HITLS_CRYPTO_PBKDF244#ifdef HITLS_CRYPTO_PBKDF2
@@ -87,4 +87,4 @@ const EAL_KdfMethod *EAL_KdfFindMethod(CRYPT_KDF_AlgId id)
87 return NULL;87 return NULL;
88}88}
89 89 
90-#endif90+#endif
Mcrypto/eal/src/eal_mac.c+70-0
@@ -46,6 +46,7 @@ static void EalMacCopyMethod(const EAL_MacMethod *src, EAL_MacUnitaryMethod *dst
46 dst->newCtx = src->newCtx;46 dst->newCtx = src->newCtx;
47 dst->ctrl = src->ctrl;47 dst->ctrl = src->ctrl;
48 dst->freeCtx = src->freeCtx;48 dst->freeCtx = src->freeCtx;
49+ dst->dupCtx = src->dupCtx;
49}50}
50 51 
51#ifdef HITLS_CRYPTO_PROVIDER52#ifdef HITLS_CRYPTO_PROVIDER
@@ -83,6 +84,9 @@ static int32_t CRYPT_EAL_SetMacMethod(CRYPT_EAL_MacCtx *ctx, const CRYPT_EAL_Fun
83 case CRYPT_EAL_IMPLMAC_FREECTX:84 case CRYPT_EAL_IMPLMAC_FREECTX:
84 method->freeCtx = funcs[index].func;85 method->freeCtx = funcs[index].func;
85 break;86 break;
87+ case CRYPT_EAL_IMPLMAC_DUPCTX:
88+ method->dupCtx = funcs[index].func;
89+ break;
86 default:90 default:
87 BSL_SAL_Free(method);91 BSL_SAL_Free(method);
88 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);92 BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
@@ -379,4 +383,70 @@ bool CRYPT_EAL_MacIsValidAlgId(CRYPT_MAC_AlgId id)
379 return EAL_MacFindMethod(id, &method) == CRYPT_SUCCESS;383 return EAL_MacFindMethod(id, &method) == CRYPT_SUCCESS;
380}384}
381 385 
386+int32_t CRYPT_EAL_MacCopyCtx(CRYPT_EAL_MacCtx *to, const CRYPT_EAL_MacCtx *from)
387+{
388+ if (to == NULL || from == NULL || from->macMeth == NULL || from->macMeth->dupCtx == NULL) {
389+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, CRYPT_MAC_MAX, CRYPT_NULL_INPUT);
390+ return CRYPT_NULL_INPUT;
391+ }
392+ 
393+ if (to->ctx != NULL) {
394+ if (to->macMeth->freeCtx == NULL) {
395+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_INVALID_ARG);
396+ return CRYPT_INVALID_ARG;
397+ }
398+ to->macMeth->freeCtx(to->ctx);
399+ to->ctx = NULL;
400+ }
401+ 
402+ if (to->macMeth != NULL) {
403+ BSL_SAL_FREE(to->macMeth);
404+ }
405+ 
406+ EAL_MacUnitaryMethod *tmpMethod = BSL_SAL_Dump(from->macMeth, sizeof(EAL_MacUnitaryMethod));
407+ if (tmpMethod == NULL) {
408+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_MEM_ALLOC_FAIL);
409+ return CRYPT_MEM_ALLOC_FAIL;
410+ }
411+ 
412+ void *ctx = from->macMeth->dupCtx(from->ctx);
413+ if (ctx == NULL) {
414+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_MEM_ALLOC_FAIL);
415+ BSL_SAL_Free(tmpMethod);
416+ return CRYPT_INVALID_ARG;
417+ }
418+ (void)memcpy_s(to, sizeof(CRYPT_EAL_MacCtx), from, sizeof(CRYPT_EAL_MacCtx));
419+ to->ctx = ctx;
420+ to->macMeth = tmpMethod;
421+ return CRYPT_SUCCESS;
422+}
423+ 
424+CRYPT_EAL_MacCtx *CRYPT_EAL_MacDupCtx(const CRYPT_EAL_MacCtx *from)
425+{
426+ if (from == NULL || from->macMeth == NULL || from->macMeth->dupCtx == NULL) {
427+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, CRYPT_MAC_MAX, CRYPT_NULL_INPUT);
428+ return NULL;
429+ }
430+ 
431+ CRYPT_EAL_MacCtx *newCtx = BSL_SAL_Dump(from, sizeof(CRYPT_EAL_MacCtx));
432+ if (newCtx == NULL ) {
433+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_MEM_ALLOC_FAIL);
434+ return NULL;
435+ }
436+ newCtx->macMeth = BSL_SAL_Dump(from->macMeth, sizeof(EAL_MacUnitaryMethod));
437+ if (newCtx->macMeth == NULL) {
438+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_MEM_ALLOC_FAIL);
439+ BSL_SAL_Free(newCtx);
440+ return NULL;
441+ }
442+ newCtx->ctx = from->macMeth->dupCtx(from->ctx);
443+ if (newCtx->ctx == NULL) {
444+ EAL_ERR_REPORT(CRYPT_EVENT_ERR, CRYPT_ALGO_MAC, from->id, CRYPT_MEM_ALLOC_FAIL);
445+ BSL_SAL_Free(newCtx->macMeth);
446+ BSL_SAL_Free(newCtx);
447+ return NULL;
448+ }
449+ return newCtx;
450+}
451+ 
382#endif452#endif
Mcrypto/eal/src/eal_mac_method.c+4-2
@@ -52,7 +52,8 @@
52 (MacDeinit)CRYPT_##name##_Deinit, \52 (MacDeinit)CRYPT_##name##_Deinit, \
53 (MacReinit)CRYPT_##name##_Reinit, \53 (MacReinit)CRYPT_##name##_Reinit, \
54 (MacCtrl)CRYPT_##name##_Ctrl, \54 (MacCtrl)CRYPT_##name##_Ctrl, \
55- (MacFreeCtx)CRYPT_##name##_FreeCtx \55+ (MacFreeCtx)CRYPT_##name##_FreeCtx, \
56+ (MacDupCtx)CRYPT_##name##_DupCtx, \
56 }57 }
57 58 
58#ifdef HITLS_CRYPTO_HMAC59#ifdef HITLS_CRYPTO_HMAC
@@ -77,7 +78,8 @@ EAL_MacMethod g_macMethod_GMAC = {
77 // (MacReinit)78 // (MacReinit)
78 NULL,79 NULL,
79 (MacCtrl)CRYPT_GMAC_Ctrl,80 (MacCtrl)CRYPT_GMAC_Ctrl,
80- (MacFreeCtx)CRYPT_GMAC_FreeCtx81+ (MacFreeCtx)CRYPT_GMAC_FreeCtx,
82+ (MacDupCtx)CRYPT_GMAC_DupCtx,
81};83};
82#endif84#endif
83 85 
Mcrypto/gmac/include/crypt_gmac.h+2-0
@@ -40,6 +40,8 @@ void CRYPT_GMAC_Deinit(MODES_GCM_Ctx *ctx);
40 40 
41int32_t CRYPT_GMAC_Ctrl(MODES_GCM_Ctx *ctx, int32_t opt, void *val, uint32_t len);41int32_t CRYPT_GMAC_Ctrl(MODES_GCM_Ctx *ctx, int32_t opt, void *val, uint32_t len);
42 42 
43+#define CRYPT_GMAC_DupCtx MODES_GCM_DupCtx
44+ 
43#ifdef __cplusplus45#ifdef __cplusplus
44}46}
45#endif /* __cpluscplus */47#endif /* __cpluscplus */
Mcrypto/hkdf/include/crypt_hkdf.h+9-0
@@ -82,6 +82,15 @@ int32_t CRYPT_HKDF_Deinit(CRYPT_HKDF_Ctx *ctx);
82 */82 */
83void CRYPT_HKDF_FreeCtx(CRYPT_HKDF_Ctx *ctx);83void CRYPT_HKDF_FreeCtx(CRYPT_HKDF_Ctx *ctx);
84 84 
85+/**
86+ * @ingroup HKDF
87+ * @brief Copy HKDF context.
88+ *
89+ * @param ctx [IN] HKDF handle.
90+ * @retval New HKDF handle.
91+ */
92+CRYPT_HKDF_Ctx *CRYPT_HKDF_DupCtx(const CRYPT_HKDF_Ctx *ctx);
93+ 
85#ifdef __cplusplus94#ifdef __cplusplus
86}95}
87#endif // __cplusplus96#endif // __cplusplus
Mcrypto/hkdf/src/hkdf.c+47-0
@@ -396,4 +396,51 @@ void CRYPT_HKDF_FreeCtx(CRYPT_HKDF_Ctx *ctx)
396 BSL_SAL_ClearFree((void *)ctx->info, ctx->infoLen);396 BSL_SAL_ClearFree((void *)ctx->info, ctx->infoLen);
397 BSL_SAL_Free(ctx);397 BSL_SAL_Free(ctx);
398}398}
399+ 
400+CRYPT_HKDF_Ctx *CRYPT_HKDF_DupCtx(const CRYPT_HKDF_Ctx *ctx)
401+{
402+ if (ctx == NULL) {
403+ return NULL;
404+ }
405+ uint8_t *key = NULL;
406+ uint8_t *salt = NULL;
407+ uint8_t *prk = NULL;
408+ uint8_t *info = NULL;
409+ 
410+ CRYPT_HKDF_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_HKDF_Ctx));
411+ if (newCtx == NULL) {
412+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
413+ return NULL;
414+ }
415+ if (ctx->key != NULL) {
416+ key = BSL_SAL_Dump(ctx->key, ctx->keyLen);
417+ GOTO_EXIT_IF((key == NULL), CRYPT_MEM_ALLOC_FAIL);
418+ }
419+ if (ctx->salt != NULL) {
420+ salt = BSL_SAL_Dump(ctx->salt, ctx->saltLen);
421+ GOTO_EXIT_IF((salt == NULL), CRYPT_MEM_ALLOC_FAIL);
422+ }
423+ if (ctx->prk != NULL) {
424+ prk = BSL_SAL_Dump(ctx->prk, ctx->prkLen);
425+ GOTO_EXIT_IF((prk == NULL), CRYPT_MEM_ALLOC_FAIL);
426+ }
427+ if (ctx->info != NULL) {
428+ info = BSL_SAL_Dump(ctx->info, ctx->infoLen);
429+ GOTO_EXIT_IF((info == NULL), CRYPT_MEM_ALLOC_FAIL);
430+ }
431+ newCtx->key = key;
432+ newCtx->salt = salt;
433+ newCtx->prk = prk;
434+ newCtx->info = info;
435+ newCtx->outLen = NULL;
436+ return newCtx;
437+EXIT:
438+ BSL_SAL_ClearFree(key, ctx->keyLen);
439+ BSL_SAL_ClearFree(prk, ctx->prkLen);
440+ BSL_SAL_ClearFree(info, ctx->infoLen);
441+ BSL_SAL_Free(salt);
442+ BSL_SAL_Free(newCtx);
443+ return NULL;
444+}
445+ 
399#endif // HITLS_CRYPTO_HKDF446#endif // HITLS_CRYPTO_HKDF
Mcrypto/hmac/include/crypt_hmac.h+1-0
@@ -40,6 +40,7 @@ void CRYPT_HMAC_Reinit(CRYPT_HMAC_Ctx *ctx);
40void CRYPT_HMAC_Deinit(CRYPT_HMAC_Ctx *ctx);40void CRYPT_HMAC_Deinit(CRYPT_HMAC_Ctx *ctx);
41int32_t CRYPT_HMAC_Ctrl(CRYPT_HMAC_Ctx *ctx, CRYPT_MacCtrl opt, void *val, uint32_t len);41int32_t CRYPT_HMAC_Ctrl(CRYPT_HMAC_Ctx *ctx, CRYPT_MacCtrl opt, void *val, uint32_t len);
42void CRYPT_HMAC_FreeCtx(CRYPT_HMAC_Ctx *ctx);42void CRYPT_HMAC_FreeCtx(CRYPT_HMAC_Ctx *ctx);
43+CRYPT_HMAC_Ctx *CRYPT_HMAC_DupCtx(const CRYPT_HMAC_Ctx *macCtx);
43 44 
44#ifdef __cplusplus45#ifdef __cplusplus
45}46}
Mcrypto/hmac/src/hmac.c+35-0
@@ -250,4 +250,39 @@ void CRYPT_HMAC_FreeCtx(CRYPT_HMAC_Ctx *ctx)
250 250 
251 BSL_SAL_FREE(ctx);251 BSL_SAL_FREE(ctx);
252}252}
253+ 
254+CRYPT_HMAC_Ctx *CRYPT_HMAC_DupCtx(const CRYPT_HMAC_Ctx *macCtx)
255+{
256+ if (macCtx == NULL) {
257+ BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
258+ return NULL;
259+ }
260+ 
261+ if (macCtx->method->dupCtx == NULL) {
262+ BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
263+ return NULL;
264+ }
265+ CRYPT_HMAC_Ctx *ctx = BSL_SAL_Dump(macCtx, sizeof(CRYPT_HMAC_Ctx));
266+ if (ctx == NULL) {
267+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
268+ return NULL;
269+ }
270+ 
271+ void *mdCtx = macCtx->method->dupCtx(macCtx->mdCtx);
272+ void *oCtx = macCtx->method->dupCtx(macCtx->oCtx);
273+ void *iCtx = macCtx->method->dupCtx(macCtx->iCtx);
274+ if (mdCtx == NULL || oCtx == NULL || iCtx == NULL) {
275+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
276+ BSL_SAL_Free(ctx);
277+ BSL_SAL_Free(mdCtx);
278+ BSL_SAL_Free(oCtx);
279+ BSL_SAL_Free(iCtx);
280+ return NULL;
281+ }
282+ ctx->mdCtx = mdCtx;
283+ ctx->oCtx = oCtx;
284+ ctx->iCtx = iCtx;
285+ return ctx;
286+}
287+ 
253#endif // HITLS_CRYPTO_HMAC288#endif // HITLS_CRYPTO_HMAC
Mcrypto/include/crypt_local_types.h+9-0
@@ -227,6 +227,7 @@ typedef int32_t (*CipherUpdate)(void *ctx, const uint8_t *in, uint32_t inLen, ui
227typedef int32_t (*CipherFinal)(void *ctx, uint8_t *out, uint32_t *outLen);227typedef int32_t (*CipherFinal)(void *ctx, uint8_t *out, uint32_t *outLen);
228typedef int32_t (*CipherCtrl)(void *ctx, int32_t opt, void *val, uint32_t len);228typedef int32_t (*CipherCtrl)(void *ctx, int32_t opt, void *val, uint32_t len);
229typedef void (*CipherFreeCtx)(void *ctx);229typedef void (*CipherFreeCtx)(void *ctx);
230+typedef void *(*CipherDupCtx)(const void *ctx);
230 231 
231typedef int32_t (*SetEncryptKey)(void *ctx, const uint8_t *key, uint32_t len);232typedef int32_t (*SetEncryptKey)(void *ctx, const uint8_t *key, uint32_t len);
232typedef int32_t (*SetDecryptKey)(void *ctx, const uint8_t *key, uint32_t len);233typedef int32_t (*SetDecryptKey)(void *ctx, const uint8_t *key, uint32_t len);
@@ -257,6 +258,7 @@ typedef struct {
257 CipherFinal final;258 CipherFinal final;
258 CipherCtrl ctrl;259 CipherCtrl ctrl;
259 CipherFreeCtx freeCtx;260 CipherFreeCtx freeCtx;
261+ CipherDupCtx dupCtx;
260} EAL_CipherMethod;262} EAL_CipherMethod;
261 263 
262typedef struct {264typedef struct {
@@ -268,6 +270,7 @@ typedef struct {
268 CipherFinal final;270 CipherFinal final;
269 CipherCtrl ctrl;271 CipherCtrl ctrl;
270 CipherFreeCtx freeCtx;272 CipherFreeCtx freeCtx;
273+ CipherDupCtx dupCtx;
271} EAL_CipherUnitaryMethod;274} EAL_CipherUnitaryMethod;
272 275 
273/* prototype of MAC algorithm operation functions */276/* prototype of MAC algorithm operation functions */
@@ -282,6 +285,7 @@ typedef void (*MacDeinit)(void *ctx);
282typedef void (*MacReinit)(void *ctx);285typedef void (*MacReinit)(void *ctx);
283typedef int32_t (*MacCtrl)(void *data, int32_t cmd, void *val, uint32_t valLen);286typedef int32_t (*MacCtrl)(void *data, int32_t cmd, void *val, uint32_t valLen);
284typedef void (*MacFreeCtx)(void *ctx);287typedef void (*MacFreeCtx)(void *ctx);
288+typedef void* (*MacDupCtx)(const void *ctx);
285 289 
286/* set of MAC algorithm operation methods */290/* set of MAC algorithm operation methods */
287typedef struct {291typedef struct {
@@ -294,6 +298,7 @@ typedef struct {
294 MacReinit reinit;298 MacReinit reinit;
295 MacCtrl ctrl;299 MacCtrl ctrl;
296 MdFreeCtx freeCtx;300 MdFreeCtx freeCtx;
301+ MacDupCtx dupCtx;
297} EAL_MacMethod;302} EAL_MacMethod;
298 303 
299typedef struct {304typedef struct {
@@ -307,6 +312,7 @@ typedef struct {
307 // Re-initialize the key. This method is used where the keys are the same during multiple MAC calculations.312 // Re-initialize the key. This method is used where the keys are the same during multiple MAC calculations.
308 MacReinit reinit;313 MacReinit reinit;
309 MacCtrl ctrl;314 MacCtrl ctrl;
315+ MacDupCtx dupCtx;
310} EAL_MacUnitaryMethod;316} EAL_MacUnitaryMethod;
311 317 
312typedef struct {318typedef struct {
@@ -359,6 +365,7 @@ typedef int32_t (*KdfDerive)(void *ctx, uint8_t *key, uint32_t keyLen);
359typedef int32_t (*KdfDeinit)(void *ctx);365typedef int32_t (*KdfDeinit)(void *ctx);
360typedef int32_t (*KdfCtrl)(void *data, int32_t cmd, void *val, uint32_t valLen);366typedef int32_t (*KdfCtrl)(void *data, int32_t cmd, void *val, uint32_t valLen);
361typedef void (*KdfFreeCtx)(void *ctx);367typedef void (*KdfFreeCtx)(void *ctx);
368+typedef void *(*KdfDupCtx)(const void *ctx);
362 369 
363typedef struct {370typedef struct {
364 KdfNewCtx newCtx;371 KdfNewCtx newCtx;
@@ -367,6 +374,7 @@ typedef struct {
367 KdfDeinit deinit;374 KdfDeinit deinit;
368 KdfFreeCtx freeCtx;375 KdfFreeCtx freeCtx;
369 KdfCtrl ctrl;376 KdfCtrl ctrl;
377+ KdfDupCtx dupCtx;
370} EAL_KdfMethod;378} EAL_KdfMethod;
371 379 
372typedef struct {380typedef struct {
@@ -377,6 +385,7 @@ typedef struct {
377 KdfDeinit deinit;385 KdfDeinit deinit;
378 KdfFreeCtx freeCtx;386 KdfFreeCtx freeCtx;
379 KdfCtrl ctrl;387 KdfCtrl ctrl;
388+ KdfDupCtx dupCtx;
380} EAL_KdfUnitaryMethod;389} EAL_KdfUnitaryMethod;
381 390 
382typedef struct {391typedef struct {
Mcrypto/kdf/include/crypt_kdf_tls12.h+8-0
@@ -82,6 +82,14 @@ int32_t CRYPT_KDFTLS12_Deinit(CRYPT_KDFTLS12_Ctx *ctx);
82 */82 */
83void CRYPT_KDFTLS12_FreeCtx(CRYPT_KDFTLS12_Ctx *ctx);83void CRYPT_KDFTLS12_FreeCtx(CRYPT_KDFTLS12_Ctx *ctx);
84 84 
85+/**
86+ * @ingroup KDFTLS12
87+ * @brief Copy KDFTLS12 context.
88+ *
89+ * @param ctx [IN] KDFTLS12 handle.
90+ * @retval New KDFTLS12 handle.
91+ */
92+CRYPT_KDFTLS12_Ctx *CRYPT_KDFTLS12_DupCtx(const CRYPT_KDFTLS12_Ctx *ctx);
85 93 
86#ifdef __cplusplus94#ifdef __cplusplus
87}95}
Mcrypto/kdf/src/kdf_tls12.c+48-0
@@ -270,4 +270,52 @@ void CRYPT_KDFTLS12_FreeCtx(CRYPT_KDFTLS12_Ctx *ctx)
270 BSL_SAL_Free(ctx);270 BSL_SAL_Free(ctx);
271}271}
272 272 
273+CRYPT_KDFTLS12_Ctx *CRYPT_KDFTLS12_DupCtx(const CRYPT_KDFTLS12_Ctx *ctx)
274+{
275+ if (ctx == NULL) {
276+ return NULL;
277+ }
278+ uint8_t *key = NULL;
279+ uint8_t *seed = NULL;
280+ uint8_t *label = NULL;
281+ CRYPT_KDFTLS12_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_KDFTLS12_Ctx));
282+ if (newCtx == NULL) {
283+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
284+ return NULL;
285+ }
286+ 
287+ void *macCtx = NULL;
288+ if (ctx->macCtx != NULL) {
289+ macCtx = ctx->macMeth->dupCtx(ctx->macCtx);
290+ GOTO_EXIT_IF((macCtx == NULL), CRYPT_MEM_ALLOC_FAIL);
291+ }
292+ 
293+ if (ctx->key != NULL) {
294+ key = BSL_SAL_Dump(ctx->key, ctx->keyLen);
295+ GOTO_EXIT_IF((key == NULL), CRYPT_MEM_ALLOC_FAIL);
296+ }
297+ if (ctx->seed != NULL) {
298+ seed = BSL_SAL_Dump(ctx->seed, ctx->seedLen);
299+ GOTO_EXIT_IF((seed == NULL), CRYPT_MEM_ALLOC_FAIL);
300+ }
301+ if (ctx->label != NULL) {
302+ label = BSL_SAL_Dump(ctx->label, ctx->labelLen);
303+ GOTO_EXIT_IF((label == NULL), CRYPT_MEM_ALLOC_FAIL);
304+ }
305+ 
306+ newCtx->macCtx = macCtx;
307+ newCtx->key = key;
308+ newCtx->seed = seed;
309+ newCtx->label = label;
310+ return newCtx;
311+EXIT:
312+ if (macCtx != NULL) {
313+ ctx->macMeth->freeCtx(macCtx);
314+ }
315+ BSL_SAL_ClearFree(key, ctx->keyLen);
316+ BSL_SAL_ClearFree(label, ctx->labelLen);
317+ BSL_SAL_ClearFree(seed, ctx->seedLen);
318+ BSL_SAL_Free(newCtx);
319+ return NULL;
320+}
273#endif // HITLS_CRYPTO_KDFTLS12321#endif // HITLS_CRYPTO_KDFTLS12
Mcrypto/modes/include/crypt_modes.h+1-0
@@ -60,6 +60,7 @@ typedef struct {
60void MODES_Clean(MODES_CipherCommonCtx *ctx);60void MODES_Clean(MODES_CipherCommonCtx *ctx);
61int32_t MODES_SetIv(MODES_CipherCommonCtx *ctx, const uint8_t *val, uint32_t len);61int32_t MODES_SetIv(MODES_CipherCommonCtx *ctx, const uint8_t *val, uint32_t len);
62int32_t MODES_GetIv(MODES_CipherCommonCtx *ctx, uint8_t *val, uint32_t len);62int32_t MODES_GetIv(MODES_CipherCommonCtx *ctx, uint8_t *val, uint32_t len);
63+MODES_CipherCtx *MODES_CipherDupCtx(const MODES_CipherCtx *modeCtx);
63#ifdef __cplusplus64#ifdef __cplusplus
64}65}
65#endif // __cplusplus66#endif // __cplusplus
Mcrypto/modes/include/crypt_modes_aes_wrap.h+2-0
@@ -67,6 +67,8 @@ int32_t MODE_WRAP_DeInitCtx(MODES_WRAP_Ctx *modeCtx);
67 67 
68void MODES_WRAP_FreeCtx(MODES_WRAP_Ctx *modeCtx);68void MODES_WRAP_FreeCtx(MODES_WRAP_Ctx *modeCtx);
69 69 
70+MODES_WRAP_Ctx *MODES_WRAP_DupCtx(const MODES_WRAP_Ctx *modeCtx);
71+ 
70#ifdef __cplusplus72#ifdef __cplusplus
71}73}
72#endif // __cplusplus74#endif // __cplusplus
Mcrypto/modes/include/crypt_modes_ccm.h+1-0
@@ -60,6 +60,7 @@ void MODES_CCM_FreeCtx(MODES_CCM_Ctx *modeCtx);
60int32_t AES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);60int32_t AES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
61 61 
62int32_t MODES_CCM_UpdateEx(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);62int32_t MODES_CCM_UpdateEx(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
63+MODES_CCM_Ctx *MODES_CCM_DupCtx(const MODES_CCM_Ctx *modeCtx);
63 64 
64#ifdef __cplusplus65#ifdef __cplusplus
65}66}
Mcrypto/modes/include/crypt_modes_cfb.h+1-0
@@ -62,6 +62,7 @@ int32_t SM4_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen
62int32_t MODES_CFB_InitCtxEx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,62int32_t MODES_CFB_InitCtxEx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
63 uint32_t ivLen, void *param, bool enc);63 uint32_t ivLen, void *param, bool enc);
64int32_t MODES_CFB_UpdateEx(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);64int32_t MODES_CFB_UpdateEx(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
65+MODES_CFB_Ctx *MODES_CFB_DupCtx(const MODES_CFB_Ctx *modeCtx);
65 66 
66#ifdef __cplusplus67#ifdef __cplusplus
67}68}
Mcrypto/modes/include/crypt_modes_chacha20poly1305.h+1-0
@@ -59,6 +59,7 @@ int32_t MODES_CHACHA20POLY1305_Final(MODES_CHACHAPOLY_Ctx *modeCtx, uint8_t *out
59int32_t MODES_CHACHA20POLY1305_DeInitCtx(MODES_CHACHAPOLY_Ctx *modeCtx);59int32_t MODES_CHACHA20POLY1305_DeInitCtx(MODES_CHACHAPOLY_Ctx *modeCtx);
60int32_t MODES_CHACHA20POLY1305_Ctrl(MODES_CHACHAPOLY_Ctx *modeCtx, int32_t cmd, void *val, uint32_t len);60int32_t MODES_CHACHA20POLY1305_Ctrl(MODES_CHACHAPOLY_Ctx *modeCtx, int32_t cmd, void *val, uint32_t len);
61void MODES_CHACHA20POLY1305_FreeCtx(MODES_CHACHAPOLY_Ctx *modeCtx);61void MODES_CHACHA20POLY1305_FreeCtx(MODES_CHACHAPOLY_Ctx *modeCtx);
62+MODES_CHACHAPOLY_Ctx *MODES_CHACHA20POLY1305_DupCtx(const MODES_CHACHAPOLY_Ctx *modeCtx);
62 63 
63#ifdef __cplusplus64#ifdef __cplusplus
64}65}
Mcrypto/modes/include/crypt_modes_gcm.h+2-0
@@ -81,6 +81,8 @@ int32_t MODES_GCM_UpdateEx(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t i
81 81 
82int32_t MODES_GCM_InitHashTable(MODES_CipherGCMCtx *ctx);82int32_t MODES_GCM_InitHashTable(MODES_CipherGCMCtx *ctx);
83int32_t MODES_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len);83int32_t MODES_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len);
84+MODES_GCM_Ctx *MODES_GCM_DupCtx(const MODES_GCM_Ctx *modeCtx);
85+ 
84#ifdef __cplusplus86#ifdef __cplusplus
85}87}
86#endif // __cplusplus88#endif // __cplusplus
Mcrypto/modes/include/crypt_modes_xts.h+2-0
@@ -69,6 +69,8 @@ int32_t AES_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen
69 69 
70int32_t AES_XTS_Final(MODES_XTS_Ctx *modeCtx, uint8_t *out, uint32_t *outLen);70int32_t AES_XTS_Final(MODES_XTS_Ctx *modeCtx, uint8_t *out, uint32_t *outLen);
71 71 
72+MODES_XTS_Ctx *MODES_XTS_DupCtx(const MODES_XTS_Ctx *modeCtx);
73+ 
72#ifdef __cplusplus74#ifdef __cplusplus
73}75}
74#endif // __cplusplus76#endif // __cplusplus
Mcrypto/modes/src/modes.c+22-0
@@ -560,4 +560,26 @@ int32_t MODES_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint
560 return ctx->ciphMeth->setDecryptKey(ctx->ciphCtx, key, len);560 return ctx->ciphMeth->setDecryptKey(ctx->ciphCtx, key, len);
561}561}
562 562 
563+MODES_CipherCtx *MODES_CipherDupCtx(const MODES_CipherCtx *modeCtx)
564+{
565+ if (modeCtx == NULL) {
566+ return NULL;
567+ }
568+ MODES_CipherCtx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_CipherCtx));
569+ if (ctx == NULL) {
570+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
571+ return ctx;
572+ }
573+ 
574+ void *ciphCtx = BSL_SAL_Dump(modeCtx->commonCtx.ciphCtx, modeCtx->commonCtx.ciphMeth->ctxSize);
575+ if (ciphCtx == NULL) {
576+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
577+ BSL_SAL_ClearFree(ctx, sizeof(MODES_CipherCtx));
578+ return NULL;
579+ }
580+ 
581+ ctx->commonCtx.ciphCtx = ciphCtx;
582+ return ctx;
583+}
584+ 
563#endif // HITLS_CRYPTO_MODES585#endif // HITLS_CRYPTO_MODES
Mcrypto/modes/src/modes_aes_wrap.c+23-0
@@ -441,4 +441,27 @@ int32_t MODE_WRAP_Ctrl(MODES_WRAP_Ctx *modeCtx, int32_t opt, void *val, uint32_t
441 }441 }
442}442}
443 443 
444+MODES_WRAP_Ctx *MODES_WRAP_DupCtx(const MODES_WRAP_Ctx *modeCtx)
445+{
446+ if (modeCtx == NULL) {
447+ return NULL;
448+ }
449+ MODES_WRAP_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_WRAP_Ctx));
450+ if (ctx == NULL) {
451+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
452+ return ctx;
453+ }
454+ 
455+ void *ciphCtx = BSL_SAL_Dump(modeCtx->wrapCtx.ciphCtx, modeCtx->wrapCtx.ciphMeth->ctxSize);
456+ if (ciphCtx == NULL) {
457+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
458+ BSL_SAL_CleanseData(ctx->wrapCtx.iv, CRYPT_WRAP_BLOCKSIZE);
459+ BSL_SAL_Free(ctx);
460+ return NULL;
461+ }
462+ 
463+ ctx->wrapCtx.ciphCtx = ciphCtx;
464+ return ctx;
465+}
466+ 
444#endif467#endif
Mcrypto/modes/src/modes_ccm.c+23-0
@@ -622,4 +622,27 @@ int32_t MODES_CCM_UpdateEx(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t i
622 }622 }
623}623}
624 624 
625+MODES_CCM_Ctx *MODES_CCM_DupCtx(const MODES_CCM_Ctx *modeCtx)
626+{
627+ if (modeCtx == NULL) {
628+ return NULL;
629+ }
630+ MODES_CCM_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_CCM_Ctx));
631+ if (ctx == NULL) {
632+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
633+ return ctx;
634+ }
635+ 
636+ void *ciphCtx = BSL_SAL_Dump(modeCtx->ccmCtx.ciphCtx, modeCtx->ccmCtx.ciphMeth->ctxSize);
637+ if (ciphCtx == NULL) {
638+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
639+ BSL_SAL_CleanseData(&ctx->ccmCtx, sizeof(MODES_CipherCCMCtx));
640+ BSL_SAL_Free(ctx);
641+ return NULL;
642+ }
643+ 
644+ ctx->ccmCtx.ciphCtx = ciphCtx;
645+ return ctx;
646+}
647+ 
625#endif648#endif
Mcrypto/modes/src/modes_cfb.c+22-0
@@ -554,4 +554,26 @@ int32_t MODES_CFB_UpdateEx(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t i
554 }554 }
555}555}
556 556 
557+MODES_CFB_Ctx *MODES_CFB_DupCtx(const MODES_CFB_Ctx *modeCtx)
558+{
559+ if (modeCtx == NULL) {
560+ return NULL;
561+ }
562+ MODES_CFB_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_CFB_Ctx));
563+ if (ctx == NULL) {
564+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
565+ return ctx;
566+ }
567+ 
568+ void *ciphCtx = BSL_SAL_Dump(modeCtx->cfbCtx.modeCtx.ciphCtx, modeCtx->cfbCtx.modeCtx.ciphMeth->ctxSize);
569+ if (ciphCtx == NULL) {
570+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
571+ BSL_SAL_ClearFree(ctx, sizeof(MODES_CFB_Ctx));
572+ return NULL;
573+ }
574+ 
575+ ctx->cfbCtx.modeCtx.ciphCtx = ciphCtx;
576+ return ctx;
577+}
578+ 
557#endif579#endif
Mcrypto/modes/src/modes_chacha20_poly1305.c+22-0
@@ -437,4 +437,26 @@ void MODES_CHACHA20POLY1305_FreeCtx(MODES_CHACHAPOLY_Ctx *modeCtx)
437 BSL_SAL_ClearFree(modeCtx, sizeof(MODES_CHACHAPOLY_Ctx));437 BSL_SAL_ClearFree(modeCtx, sizeof(MODES_CHACHAPOLY_Ctx));
438}438}
439 439 
440+MODES_CHACHAPOLY_Ctx *MODES_CHACHA20POLY1305_DupCtx(const MODES_CHACHAPOLY_Ctx *modeCtx)
441+{
442+ if (modeCtx == NULL) {
443+ return NULL;
444+ }
445+ MODES_CHACHAPOLY_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_CHACHAPOLY_Ctx));
446+ if (ctx == NULL) {
447+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
448+ return ctx;
449+ }
450+ 
451+ void *ciphCtx = BSL_SAL_Dump(modeCtx->chachaCtx.key, modeCtx->chachaCtx.method->ctxSize);
452+ if (ciphCtx == NULL) {
453+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
454+ BSL_SAL_ClearFree(ctx, sizeof(MODES_CHACHAPOLY_Ctx));
455+ return NULL;
456+ }
457+ 
458+ ctx->chachaCtx.key = ciphCtx;
459+ return ctx;
460+}
461+ 
440#endif462#endif
Mcrypto/modes/src/modes_gcm.c+22-0
@@ -559,4 +559,26 @@ int32_t MODES_GCM_UpdateEx(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t i
559 }559 }
560}560}
561 561 
562+MODES_GCM_Ctx *MODES_GCM_DupCtx(const MODES_GCM_Ctx *modeCtx)
563+{
564+ if (modeCtx == NULL) {
565+ return NULL;
566+ }
567+ MODES_GCM_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_GCM_Ctx));
568+ if (ctx == NULL) {
569+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
570+ return ctx;
571+ }
572+ 
573+ void *ciphCtx = BSL_SAL_Dump(modeCtx->gcmCtx.ciphCtx, modeCtx->gcmCtx.ciphMeth->ctxSize);
574+ if (ciphCtx == NULL) {
575+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
576+ BSL_SAL_ClearFree(ctx, sizeof(MODES_GCM_Ctx));
577+ return NULL;
578+ }
579+ 
580+ ctx->gcmCtx.ciphCtx = ciphCtx;
581+ return ctx;
582+}
583+ 
562#endif584#endif
Mcrypto/modes/src/modes_xts.c+25-0
@@ -537,4 +537,29 @@ int32_t MODES_XTS_UpdateEx(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t i
537 }537 }
538}538}
539 539 
540+MODES_XTS_Ctx *MODES_XTS_DupCtx(const MODES_XTS_Ctx *modeCtx)
541+{
542+ if (modeCtx == NULL) {
543+ return NULL;
544+ }
545+ MODES_XTS_Ctx *ctx = BSL_SAL_Dump(modeCtx, sizeof(MODES_XTS_Ctx));
546+ if (ctx == NULL) {
547+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
548+ return ctx;
549+ }
550+ // In the MODES_XTS_NewCtx function, memory allocated for ciphCtx is ctxSize * 2.
551+ void *ciphCtx = BSL_SAL_Dump(modeCtx->xtsCtx.ciphCtx, modeCtx->xtsCtx.ciphMeth->ctxSize * 2);
552+ if (ciphCtx == NULL) {
553+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
554+ BSL_SAL_CleanseData(ctx->xtsCtx.iv, MODES_MAX_IV_LENGTH);
555+ BSL_SAL_CleanseData(ctx->xtsCtx.tweak, MODES_MAX_IV_LENGTH);
556+ (void)memset_s(ctx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
557+ BSL_SAL_Free(ctx);
558+ return NULL;
559+ }
560+ 
561+ ctx->xtsCtx.ciphCtx = ciphCtx;
562+ return ctx;
563+}
564+ 
540#endif // HITLS_CRYPTO_XTS565#endif // HITLS_CRYPTO_XTS
Mcrypto/pbkdf2/include/crypt_pbkdf2.h+9-0
@@ -82,6 +82,15 @@ int32_t CRYPT_PBKDF2_Deinit(CRYPT_PBKDF2_Ctx *ctx);
82 */82 */
83void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx);83void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx);
84 84 
85+/**
86+ * @ingroup PBKDF2
87+ * @brief Copy PBKDF2 context.
88+ *
89+ * @param ctx [IN] PBKDF2 handle.
90+ * @retval New PBKDF2 handle.
91+ */
92+CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_DupCtx(const CRYPT_PBKDF2_Ctx *ctx);
93+ 
85#ifdef __cplusplus94#ifdef __cplusplus
86}95}
87#endif // __cplusplus96#endif // __cplusplus
Mcrypto/pbkdf2/src/pbkdf2.c+41-0
@@ -406,4 +406,45 @@ void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx)
406 BSL_SAL_Free(ctx);406 BSL_SAL_Free(ctx);
407}407}
408 408 
409+CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_DupCtx(const CRYPT_PBKDF2_Ctx *ctx)
410+{
411+ if (ctx == NULL) {
412+ return NULL;
413+ }
414+ uint8_t *password = NULL;
415+ uint8_t *salt = NULL;
416+ CRYPT_PBKDF2_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_PBKDF2_Ctx));
417+ if (newCtx == NULL) {
418+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
419+ return NULL;
420+ }
421+ 
422+ void *macCtx = NULL;
423+ if (ctx->macCtx != NULL) {
424+ macCtx = ctx->macMeth->dupCtx(ctx->macCtx);
425+ GOTO_EXIT_IF((macCtx == NULL), CRYPT_MEM_ALLOC_FAIL);
426+ }
427+ 
428+ if (ctx->password != NULL) {
429+ password = BSL_SAL_Dump(ctx->password, ctx->passLen);
430+ GOTO_EXIT_IF((password == NULL), CRYPT_MEM_ALLOC_FAIL);
431+ }
432+ if (ctx->salt != NULL) {
433+ salt = BSL_SAL_Dump(ctx->salt, ctx->saltLen);
434+ GOTO_EXIT_IF((salt == NULL), CRYPT_MEM_ALLOC_FAIL);
435+ }
436+ newCtx->macCtx = macCtx;
437+ newCtx->password = password;
438+ newCtx->salt = salt;
439+ return newCtx;
440+EXIT:
441+ if (macCtx != NULL) {
442+ ctx->macMeth->freeCtx(macCtx);
443+ }
444+ BSL_SAL_ClearFree(password, ctx->passLen);
445+ BSL_SAL_Free(salt);
446+ BSL_SAL_Free(newCtx);
447+ return NULL;
448+}
449+ 
409#endif // HITLS_CRYPTO_PBKDF2450#endif // HITLS_CRYPTO_PBKDF2
Mcrypto/provider/src/default/crypt_default_cipher.c+13-3
@@ -100,6 +100,7 @@ const CRYPT_EAL_Func g_defEalCbc[] = {
100 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CBC_DeInitCtx},100 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CBC_DeInitCtx},
101 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CBC_Ctrl},101 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CBC_Ctrl},
102 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CBC_FreeCtx},102 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CBC_FreeCtx},
103+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CipherDupCtx},
103#endif104#endif
104 CRYPT_EAL_FUNC_END,105 CRYPT_EAL_FUNC_END,
105};106};
@@ -113,6 +114,7 @@ const CRYPT_EAL_Func g_defEalCcm[] = {
113 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CCM_DeInitCtx},114 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CCM_DeInitCtx},
114 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CCM_Ctrl},115 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CCM_Ctrl},
115 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CCM_FreeCtx},116 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CCM_FreeCtx},
117+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CCM_DupCtx},
116#endif118#endif
117 CRYPT_EAL_FUNC_END,119 CRYPT_EAL_FUNC_END,
118};120};
@@ -126,6 +128,7 @@ const CRYPT_EAL_Func g_defEalCfb[] = {
126 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CFB_DeInitCtx},128 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CFB_DeInitCtx},
127 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CFB_Ctrl},129 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CFB_Ctrl},
128 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CFB_FreeCtx},130 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CFB_FreeCtx},
131+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CFB_DupCtx},
129#endif132#endif
130 CRYPT_EAL_FUNC_END,133 CRYPT_EAL_FUNC_END,
131};134};
@@ -139,6 +142,7 @@ const CRYPT_EAL_Func g_defEalChaCha[] = {
139 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CHACHA20POLY1305_DeInitCtx},142 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CHACHA20POLY1305_DeInitCtx},
140 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CHACHA20POLY1305_Ctrl},143 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CHACHA20POLY1305_Ctrl},
141 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtx},144 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtx},
145+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CHACHA20POLY1305_DupCtx},
142#endif146#endif
143 CRYPT_EAL_FUNC_END,147 CRYPT_EAL_FUNC_END,
144};148};
@@ -152,6 +156,7 @@ const CRYPT_EAL_Func g_defEalCtr[] = {
152 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CTR_DeInitCtx},156 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CTR_DeInitCtx},
153 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CTR_Ctrl},157 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CTR_Ctrl},
154 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CTR_FreeCtx},158 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CTR_FreeCtx},
159+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CipherDupCtx},
155#endif160#endif
156 CRYPT_EAL_FUNC_END,161 CRYPT_EAL_FUNC_END,
157};162};
@@ -165,6 +170,7 @@ const CRYPT_EAL_Func g_defEalEcb[] = {
165 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_ECB_DeinitCtx},170 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_ECB_DeinitCtx},
166 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_ECB_Ctrl},171 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_ECB_Ctrl},
167 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_ECB_FreeCtx},172 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_ECB_FreeCtx},
173+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CipherDupCtx},
168#endif174#endif
169 CRYPT_EAL_FUNC_END,175 CRYPT_EAL_FUNC_END,
170};176};
@@ -178,6 +184,7 @@ const CRYPT_EAL_Func g_defEalGcm[] = {
178 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_GCM_DeInitCtx},184 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_GCM_DeInitCtx},
179 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_GCM_Ctrl},185 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_GCM_Ctrl},
180 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_GCM_FreeCtx},186 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_GCM_FreeCtx},
187+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_GCM_DupCtx},
181#endif188#endif
182 CRYPT_EAL_FUNC_END,189 CRYPT_EAL_FUNC_END,
183};190};
@@ -191,6 +198,7 @@ const CRYPT_EAL_Func g_defEalOfb[] = {
191 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_OFB_DeInitCtx},198 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_OFB_DeInitCtx},
192 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_OFB_Ctrl},199 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_OFB_Ctrl},
193 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_OFB_FreeCtx},200 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_OFB_FreeCtx},
201+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_CipherDupCtx},
194#endif202#endif
195 CRYPT_EAL_FUNC_END,203 CRYPT_EAL_FUNC_END,
196};204};
@@ -204,12 +212,13 @@ const CRYPT_EAL_Func g_defEalXts[] = {
204 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_XTS_DeInitCtx},212 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_XTS_DeInitCtx},
205 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_XTS_Ctrl},213 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_XTS_Ctrl},
206 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_XTS_FreeCtx},214 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_XTS_FreeCtx},
215+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_XTS_DupCtx},
207#endif216#endif
208 CRYPT_EAL_FUNC_END,217 CRYPT_EAL_FUNC_END,
209};218};
210 219 
211-#ifdef HITLS_CRYPTO_WRAP
212const CRYPT_EAL_Func g_defEalWrap[] = {220const CRYPT_EAL_Func g_defEalWrap[] = {
221+#ifdef HITLS_CRYPTO_WRAP
213 {CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},222 {CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
214 {CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_WRAP_InitCtx},223 {CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_WRAP_InitCtx},
215 {CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_WRAP_Update},224 {CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_WRAP_Update},
@@ -217,8 +226,9 @@ const CRYPT_EAL_Func g_defEalWrap[] = {
217 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODE_WRAP_DeInitCtx},226 {CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODE_WRAP_DeInitCtx},
218 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODE_WRAP_Ctrl},227 {CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODE_WRAP_Ctrl},
219 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_WRAP_FreeCtx},228 {CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_WRAP_FreeCtx},
229+ {CRYPT_EAL_IMPLCIPHER_DUPCTX, (CRYPT_EAL_ImplCipherDupCtx)MODES_WRAP_DupCtx},
230+#endif
220 CRYPT_EAL_FUNC_END,231 CRYPT_EAL_FUNC_END,
221};232};
222-#endif
223 233 
224-#endif /* HITLS_CRYPTO_PROVIDER */234+#endif /* HITLS_CRYPTO_PROVIDER */
Mcrypto/provider/src/default/crypt_default_kdf.c+4-0
@@ -72,6 +72,7 @@ const CRYPT_EAL_Func g_defEalKdfScrypt[] = {
72 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_SCRYPT_Deinit},72 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_SCRYPT_Deinit},
73 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},73 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},
74 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_SCRYPT_FreeCtx},74 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_SCRYPT_FreeCtx},
75+ {CRYPT_EAL_IMPLKDF_DUPCTX, (CRYPT_EAL_ImplKdfDupCtx)CRYPT_SCRYPT_DupCtx},
75#endif76#endif
76 CRYPT_EAL_FUNC_END,77 CRYPT_EAL_FUNC_END,
77};78};
@@ -84,6 +85,7 @@ const CRYPT_EAL_Func g_defEalKdfPBKdf2[] = {
84 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_PBKDF2_Deinit},85 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_PBKDF2_Deinit},
85 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},86 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},
86 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_PBKDF2_FreeCtx},87 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_PBKDF2_FreeCtx},
88+ {CRYPT_EAL_IMPLKDF_DUPCTX, (CRYPT_EAL_ImplKdfDupCtx)CRYPT_PBKDF2_DupCtx},
87#endif89#endif
88 CRYPT_EAL_FUNC_END,90 CRYPT_EAL_FUNC_END,
89};91};
@@ -96,6 +98,7 @@ const CRYPT_EAL_Func g_defEalKdfKdfTLS12[] = {
96 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_KDFTLS12_Deinit},98 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_KDFTLS12_Deinit},
97 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},99 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},
98 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_KDFTLS12_FreeCtx},100 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_KDFTLS12_FreeCtx},
101+ {CRYPT_EAL_IMPLKDF_DUPCTX, (CRYPT_EAL_ImplKdfDupCtx)CRYPT_KDFTLS12_DupCtx},
99#endif102#endif
100 CRYPT_EAL_FUNC_END,103 CRYPT_EAL_FUNC_END,
101};104};
@@ -108,6 +111,7 @@ const CRYPT_EAL_Func g_defEalKdfHkdf[] = {
108 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_HKDF_Deinit},111 {CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_HKDF_Deinit},
109 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},112 {CRYPT_EAL_IMPLKDF_CTRL, (CRYPT_EAL_ImplKdfCtrl)CRYPT_EAL_DefKdfCtrl},
110 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_HKDF_FreeCtx},113 {CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_HKDF_FreeCtx},
114+ {CRYPT_EAL_IMPLKDF_DUPCTX, (CRYPT_EAL_ImplKdfDupCtx)CRYPT_HKDF_DupCtx},
111#endif115#endif
112 CRYPT_EAL_FUNC_END,116 CRYPT_EAL_FUNC_END,
113};117};
Mcrypto/provider/src/default/crypt_default_mac.c+5-0
@@ -128,6 +128,7 @@ const CRYPT_EAL_Func g_defEalMacHmac[] = {
128 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_HMAC_ReinitWrapper},128 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_HMAC_ReinitWrapper},
129 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_HMAC_Ctrl},129 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_HMAC_Ctrl},
130 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_HMAC_FreeCtx},130 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_HMAC_FreeCtx},
131+ {CRYPT_EAL_IMPLMAC_DUPCTX, (CRYPT_EAL_ImplMacDupCtx)CRYPT_HMAC_DupCtx},
131#endif132#endif
132 CRYPT_EAL_FUNC_END,133 CRYPT_EAL_FUNC_END,
133};134};
@@ -142,6 +143,7 @@ const CRYPT_EAL_Func g_defEalMacCmac[] = {
142 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CMAC_ReinitWrapper},143 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CMAC_ReinitWrapper},
143 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CMAC_Ctrl},144 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CMAC_Ctrl},
144 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CMAC_FreeCtx},145 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CMAC_FreeCtx},
146+ {CRYPT_EAL_IMPLMAC_DUPCTX, (CRYPT_EAL_ImplMacDupCtx)CRYPT_CMAC_DupCtx},
145#endif147#endif
146 CRYPT_EAL_FUNC_END,148 CRYPT_EAL_FUNC_END,
147};149};
@@ -156,6 +158,7 @@ const CRYPT_EAL_Func g_defEalMacCbcMac[] = {
156 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CBC_MAC_ReinitWrapper},158 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CBC_MAC_ReinitWrapper},
157 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CBC_MAC_Ctrl},159 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CBC_MAC_Ctrl},
158 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CBC_MAC_FreeCtx},160 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CBC_MAC_FreeCtx},
161+ {CRYPT_EAL_IMPLMAC_DUPCTX, (CRYPT_EAL_ImplMacDupCtx)CRYPT_CBC_MAC_DupCtx},
159#endif162#endif
160 CRYPT_EAL_FUNC_END,163 CRYPT_EAL_FUNC_END,
161};164};
@@ -170,6 +173,7 @@ const CRYPT_EAL_Func g_defEalMacGmac[] = {
170 {CRYPT_EAL_IMPLMAC_REINITCTX, NULL},173 {CRYPT_EAL_IMPLMAC_REINITCTX, NULL},
171 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_GMAC_Ctrl},174 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_GMAC_Ctrl},
172 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_GMAC_FreeCtx},175 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_GMAC_FreeCtx},
176+ {CRYPT_EAL_IMPLMAC_DUPCTX, (CRYPT_EAL_ImplMacDupCtx)CRYPT_GMAC_DupCtx},
173#endif177#endif
174 CRYPT_EAL_FUNC_END,178 CRYPT_EAL_FUNC_END,
175};179};
@@ -184,6 +188,7 @@ const CRYPT_EAL_Func g_defEalMacSiphash[] = {
184 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_SIPHASH_ReinitWrapper},188 {CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_SIPHASH_ReinitWrapper},
185 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_SIPHASH_Ctrl},189 {CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_SIPHASH_Ctrl},
186 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_SIPHASH_FreeCtx},190 {CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_SIPHASH_FreeCtx},
191+ {CRYPT_EAL_IMPLMAC_DUPCTX, (CRYPT_EAL_ImplMacDupCtx)CRYPT_SIPHASH_DupCtx},
187#endif192#endif
188 CRYPT_EAL_FUNC_END,193 CRYPT_EAL_FUNC_END,
189};194};
Mcrypto/scrypt/include/crypt_scrypt.h+9-0
@@ -87,6 +87,15 @@ int32_t CRYPT_SCRYPT_Deinit(CRYPT_SCRYPT_Ctx *ctx);
87 */87 */
88void CRYPT_SCRYPT_FreeCtx(CRYPT_SCRYPT_Ctx *ctx);88void CRYPT_SCRYPT_FreeCtx(CRYPT_SCRYPT_Ctx *ctx);
89 89 
90+/**
91+ * @ingroup SCRYPT
92+ * @brief Copy SCRYPT context.
93+ *
94+ * @param ctx [IN] SCRYPT handle.
95+ * @retval New SCRYPT handle.
96+ */
97+CRYPT_SCRYPT_Ctx *CRYPT_SCRYPT_DupCtx(const CRYPT_SCRYPT_Ctx *ctx);
98+ 
90#ifdef __cplusplus99#ifdef __cplusplus
91}100}
92#endif // __cplusplus101#endif // __cplusplus
Mcrypto/scrypt/src/scrypt.c+33-0
@@ -531,4 +531,37 @@ void CRYPT_SCRYPT_FreeCtx(CRYPT_SCRYPT_Ctx *ctx)
531 BSL_SAL_Free(ctx);531 BSL_SAL_Free(ctx);
532}532}
533 533 
534+CRYPT_SCRYPT_Ctx *CRYPT_SCRYPT_DupCtx(const CRYPT_SCRYPT_Ctx *ctx)
535+{
536+ if (ctx == NULL) {
537+ return NULL;
538+ }
539+ uint8_t *password = NULL;
540+ uint8_t *salt = NULL;
541+ CRYPT_SCRYPT_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_SCRYPT_Ctx));
542+ if (newCtx == NULL) {
543+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
544+ return NULL;
545+ }
546+ 
547+ if (ctx->password != NULL) {
548+ password = BSL_SAL_Dump(ctx->password, ctx->passLen);
549+ GOTO_EXIT_IF((password == NULL), CRYPT_MEM_ALLOC_FAIL);
550+ }
551+ if (ctx->salt != NULL) {
552+ salt = BSL_SAL_Dump(ctx->salt, ctx->saltLen);
553+ GOTO_EXIT_IF((salt == NULL), CRYPT_MEM_ALLOC_FAIL);
554+ }
555+ 
556+ newCtx->password = password;
557+ newCtx->salt = salt;
558+ return newCtx;
559+EXIT:
560+ BSL_SAL_ClearFree(password, ctx->passLen);
561+ BSL_SAL_Free(salt);
562+ BSL_SAL_Free(newCtx);
563+ return NULL;
564+}
565+ 
566+ 
534#endif /* HITLS_CRYPTO_SCRYPT */567#endif /* HITLS_CRYPTO_SCRYPT */
Mcrypto/siphash/include/crypt_siphash.h+7-0
@@ -108,6 +108,13 @@ int32_t CRYPT_SIPHASH_Ctrl(CRYPT_SIPHASH_Ctx *ctx, uint32_t opt, void *val, uint
108 */108 */
109void CRYPT_SIPHASH_FreeCtx(CRYPT_SIPHASH_Ctx *ctx);109void CRYPT_SIPHASH_FreeCtx(CRYPT_SIPHASH_Ctx *ctx);
110 110 
111+/**
112+ * @brief siphash dup context
113+ * @param ctx [IN] siphash context
114+ * @retval siphash context
115+ */
116+CRYPT_SIPHASH_Ctx *CRYPT_SIPHASH_DupCtx(const CRYPT_SIPHASH_Ctx *ctx);
117+ 
111#ifdef __cplusplus118#ifdef __cplusplus
112}119}
113#endif120#endif
Mcrypto/siphash/src/siphash.c+16-0
@@ -327,4 +327,20 @@ void CRYPT_SIPHASH_FreeCtx(CRYPT_SIPHASH_Ctx *ctx)
327 BSL_SAL_Free(ctx);327 BSL_SAL_Free(ctx);
328 }328 }
329}329}
330+ 
331+CRYPT_SIPHASH_Ctx *CRYPT_SIPHASH_DupCtx(const CRYPT_SIPHASH_Ctx *ctx)
332+{
333+ if (ctx == NULL) {
334+ BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
335+ return NULL;
336+ }
337+ 
338+ CRYPT_SIPHASH_Ctx *newCtx = BSL_SAL_Dump(ctx, sizeof(CRYPT_SIPHASH_Ctx));
339+ if (newCtx == NULL) {
340+ BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
341+ return NULL;
342+ }
343+ return newCtx;
344+}
345+ 
330#endif /* HITLS_CRYPTO_SIPHASH */346#endif /* HITLS_CRYPTO_SIPHASH */
Minclude/crypto/crypt_eal_cipher.h+22-0
@@ -249,6 +249,28 @@ int32_t CRYPT_EAL_CipherGetPadding(CRYPT_EAL_CipherCtx *ctx);
249 */249 */
250int32_t CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AlgId id, int32_t type, uint32_t *infoValue);250int32_t CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AlgId id, int32_t type, uint32_t *infoValue);
251 251 
252+/**
253+ * @ingroup crypt_eal_cipher
254+ * @brief Copy the cipher context.
255+ *
256+ * @param to [IN] target cipher context.
257+ * @param from [IN] original cipher context.
258+ * @retval #CRYPT_SUCCESS, parameters are set successfully.
259+ * @retval #CRYPT_NULL_INPUT, the input parameter is NULL.
260+ * Other error codes see crypt_errno.h
261+ */
262+int32_t CRYPT_EAL_CipherCopyCtx(CRYPT_EAL_CipherCtx *to, const CRYPT_EAL_CipherCtx *from);
263+ 
264+/**
265+ * @ingroup crypt_eal_cipher
266+ * @brief Dup the cipher context.
267+ *
268+ * @param from [IN] original cipher context.
269+ * @retval CRYPT_EAL_CipherCtx, cipher context pointer.
270+ * NULL, if the operation fails.
271+ */
272+CRYPT_EAL_CipherCtx *CRYPT_EAL_CipherDupCtx(const CRYPT_EAL_CipherCtx *from);
273+ 
252#ifdef __cplusplus274#ifdef __cplusplus
253}275}
254#endif // __cplusplus276#endif // __cplusplus
Minclude/crypto/crypt_eal_implprovider.h+7-1
@@ -113,6 +113,7 @@ typedef int32_t (*CRYPT_EAL_ImplProviderInit)(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_
113#define CRYPT_EAL_IMPLCIPHER_DEINITCTX 5113#define CRYPT_EAL_IMPLCIPHER_DEINITCTX 5
114#define CRYPT_EAL_IMPLCIPHER_CTRL 6114#define CRYPT_EAL_IMPLCIPHER_CTRL 6
115#define CRYPT_EAL_IMPLCIPHER_FREECTX 7115#define CRYPT_EAL_IMPLCIPHER_FREECTX 7
116+#define CRYPT_EAL_IMPLCIPHER_DUPCTX 8
116 117 
117typedef void *(*CRYPT_EAL_ImplCipherNewCtx)(void *provCtx, int32_t algId);118typedef void *(*CRYPT_EAL_ImplCipherNewCtx)(void *provCtx, int32_t algId);
118typedef int32_t (*CRYPT_EAL_ImplCipherInitCtx)(void *ctx, const uint8_t *key, uint32_t keyLen,119typedef int32_t (*CRYPT_EAL_ImplCipherInitCtx)(void *ctx, const uint8_t *key, uint32_t keyLen,
@@ -123,7 +124,7 @@ typedef int32_t (*CRYPT_EAL_ImplCipherFinal)(void *ctx, uint8_t *out, uint32_t *
123typedef int32_t (*CRYPT_EAL_ImplCipherDeinitCtx)(void *ctx);124typedef int32_t (*CRYPT_EAL_ImplCipherDeinitCtx)(void *ctx);
124typedef int32_t (*CRYPT_EAL_ImplCipherCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen);125typedef int32_t (*CRYPT_EAL_ImplCipherCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen);
125typedef void (*CRYPT_EAL_ImplCipherFreeCtx)(void *ctx);126typedef void (*CRYPT_EAL_ImplCipherFreeCtx)(void *ctx);
126- 127+typedef void *(*CRYPT_EAL_ImplCipherDupCtx)(const void *ctx);
127 128 
128// CRYPT_EAL_OPERAID_KEYMGMT129// CRYPT_EAL_OPERAID_KEYMGMT
129#define CRYPT_EAL_IMPLPKEYMGMT_NEWCTX 1130#define CRYPT_EAL_IMPLPKEYMGMT_NEWCTX 1
@@ -238,6 +239,8 @@ typedef int32_t (*CRYPT_EAL_ImplMdSqueeze)(void *ctx, uint8_t *out, uint32_t len
238#define CRYPT_EAL_IMPLMAC_REINITCTX 6239#define CRYPT_EAL_IMPLMAC_REINITCTX 6
239#define CRYPT_EAL_IMPLMAC_CTRL 7240#define CRYPT_EAL_IMPLMAC_CTRL 7
240#define CRYPT_EAL_IMPLMAC_FREECTX 8241#define CRYPT_EAL_IMPLMAC_FREECTX 8
242+#define CRYPT_EAL_IMPLMAC_SETPARAM 9
243+#define CRYPT_EAL_IMPLMAC_DUPCTX 10
241 244 
242typedef void *(*CRYPT_EAL_ImplMacNewCtx)(void *provCtx, int32_t algId);245typedef void *(*CRYPT_EAL_ImplMacNewCtx)(void *provCtx, int32_t algId);
243typedef int32_t (*CRYPT_EAL_ImplMacInit)(void *ctx, const uint8_t *key, uint32_t len, BSL_Param *param);246typedef int32_t (*CRYPT_EAL_ImplMacInit)(void *ctx, const uint8_t *key, uint32_t len, BSL_Param *param);
@@ -247,6 +250,7 @@ typedef int32_t (*CRYPT_EAL_ImplMacDeInitCtx)(void *ctx);
247typedef int32_t (*CRYPT_EAL_ImplMacReInitCtx)(void *ctx);250typedef int32_t (*CRYPT_EAL_ImplMacReInitCtx)(void *ctx);
248typedef int32_t (*CRYPT_EAL_ImplMacCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen);251typedef int32_t (*CRYPT_EAL_ImplMacCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen);
249typedef void (*CRYPT_EAL_ImplMacFreeCtx)(void *ctx);252typedef void (*CRYPT_EAL_ImplMacFreeCtx)(void *ctx);
253+typedef void *(*CRYPT_EAL_ImplMacDupCtx)(const void *ctx);
250 254 
251// CRYPT_EAL_OPERAID_KDF255// CRYPT_EAL_OPERAID_KDF
252#define CRYPT_EAL_IMPLKDF_NEWCTX 1256#define CRYPT_EAL_IMPLKDF_NEWCTX 1
@@ -255,6 +259,7 @@ typedef void (*CRYPT_EAL_ImplMacFreeCtx)(void *ctx);
255#define CRYPT_EAL_IMPLKDF_DEINITCTX 4259#define CRYPT_EAL_IMPLKDF_DEINITCTX 4
256#define CRYPT_EAL_IMPLKDF_CTRL 5 // not support260#define CRYPT_EAL_IMPLKDF_CTRL 5 // not support
257#define CRYPT_EAL_IMPLKDF_FREECTX 6261#define CRYPT_EAL_IMPLKDF_FREECTX 6
262+#define CRYPT_EAL_IMPLKDF_DUPCTX 7
258 263 
259typedef void *(*CRYPT_EAL_ImplKdfNewCtx)(void *provCtx, int32_t algId);264typedef void *(*CRYPT_EAL_ImplKdfNewCtx)(void *provCtx, int32_t algId);
260typedef int32_t (*CRYPT_EAL_ImplKdfSetParam)(void *ctx, BSL_Param *param);265typedef int32_t (*CRYPT_EAL_ImplKdfSetParam)(void *ctx, BSL_Param *param);
@@ -262,6 +267,7 @@ typedef int32_t (*CRYPT_EAL_ImplKdfDerive)(void *ctx, uint8_t *key, uint32_t key
262typedef int32_t (*CRYPT_EAL_ImplKdfDeInitCtx)(void *ctx);267typedef int32_t (*CRYPT_EAL_ImplKdfDeInitCtx)(void *ctx);
263typedef int32_t (*CRYPT_EAL_ImplKdfCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen); // not support268typedef int32_t (*CRYPT_EAL_ImplKdfCtrl)(void *ctx, int32_t cmd, void *val, uint32_t valLen); // not support
264typedef void (*CRYPT_EAL_ImplKdfFreeCtx)(void *ctx);269typedef void (*CRYPT_EAL_ImplKdfFreeCtx)(void *ctx);
270+typedef void *(*CRYPT_EAL_ImplKdfDupCtx)(const void *ctx);
265 271 
266// CRYPT_EAL_OPERAID_RAND272// CRYPT_EAL_OPERAID_RAND
267#define CRYPT_EAL_IMPLRAND_DRBGNEWCTX 1273#define CRYPT_EAL_IMPLRAND_DRBGNEWCTX 1
Minclude/crypto/crypt_eal_kdf.h+21-0
@@ -100,6 +100,27 @@ int32_t CRYPT_EAL_KdfDeInitCtx(CRYPT_EAL_KdfCTX *ctx);
100 */100 */
101void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx);101void CRYPT_EAL_KdfFreeCtx(CRYPT_EAL_KdfCTX *ctx);
102 102 
103+ /**
104+ * @ingroup crypt_eal_kdf
105+ * @brief Copy the context of kdf
106+ * Note: When using HKDF for key derivation in CRYPT_KDF_HKDF_MODE_EXTRACT mode,
107+ * need set the new context's extended length use CRYPT_PARAM_KDF_EXLEN.
108+ * @param from [IN] kdf context
109+ * @param to [OUT] kdf context
110+ *
111+ */
112+int32_t CRYPT_EAL_KdfCopyCtx(CRYPT_EAL_KdfCTX *to, const CRYPT_EAL_KdfCTX *from);
113+ 
114+/**
115+ * @ingroup crypt_eal_kdf
116+ * @brief Dup the kdf context.
117+ *
118+ * @param from [IN] original kdf context.
119+ * @retval CRYPT_EAL_KdfCTX, kdf context pointer.
120+ * NULL, if the operation fails.
121+ */
122+CRYPT_EAL_KdfCTX *CRYPT_EAL_KdfDupCtx(const CRYPT_EAL_KdfCTX *from);
123+ 
103#ifdef __cplusplus124#ifdef __cplusplus
104}125}
105#endif // __cplusplus126#endif // __cplusplus
Minclude/crypto/crypt_eal_mac.h+22-0
@@ -202,6 +202,28 @@ uint32_t CRYPT_EAL_GetMacLen(const CRYPT_EAL_MacCtx *ctx);
202 */202 */
203int32_t CRYPT_EAL_MacCtrl(CRYPT_EAL_MacCtx *ctx, int32_t type, void *in, uint32_t len);203int32_t CRYPT_EAL_MacCtrl(CRYPT_EAL_MacCtx *ctx, int32_t type, void *in, uint32_t len);
204 204 
205+/**
206+ * @ingroup crypt_eal_mac
207+ * @brief Copy the MAC context.
208+ *
209+ * @param to [IN] target MAC context.
210+ * @param from [IN] original MAC context.
211+ * @retval #CRYPT_SUCCESS, parameters are set successfully.
212+ * @retval #CRYPT_NULL_INPUT, the input parameter is NULL.
213+ * Other error codes see crypt_errno.h
214+ */
215+int32_t CRYPT_EAL_MacCopyCtx(CRYPT_EAL_MacCtx *to, const CRYPT_EAL_MacCtx *from);
216+ 
217+/**
218+ * @ingroup crypt_eal_mac
219+ * @brief Dup the MAC context.
220+ *
221+ * @param from [IN] original MAC context.
222+ * @retval CRYPT_EAL_MacCtx, MAC context pointer.
223+ * NULL, if the operation fails.
224+ */
225+CRYPT_EAL_MacCtx *CRYPT_EAL_MacDupCtx(const CRYPT_EAL_MacCtx *from);
226+ 
205#ifdef __cplusplus227#ifdef __cplusplus
206} // end extern "C"228} // end extern "C"
207#endif229#endif
Minclude/crypto/crypt_eal_md.h+1-1
@@ -91,7 +91,7 @@ int32_t CRYPT_EAL_MdCopyCtx(CRYPT_EAL_MdCTX *to, const CRYPT_EAL_MdCTX *from);
91 91 
92/**92/**
93 * @ingroup crypt_eal_md93 * @ingroup crypt_eal_md
94- * @brief Copy the MD context.94+ * @brief Dup the MD context.
95 *95 *
96 * Note that need to call the CRYPT_EAL_MdFreeCtx interface to release the memory after the duplication is complete.96 * Note that need to call the CRYPT_EAL_MdFreeCtx interface to release the memory after the duplication is complete.
97 *97 *
Minclude/crypto/crypt_eal_pkey.h+1-1
@@ -158,7 +158,7 @@ int32_t CRYPT_EAL_PkeyCopyCtx(CRYPT_EAL_PkeyCtx *to, const CRYPT_EAL_PkeyCtx *fr
158 158 
159/**159/**
160 * @ingroup crypt_eal_pkey160 * @ingroup crypt_eal_pkey
161- * @brief Copy the Pkey context.161+ * @brief Dup the Pkey context.
162 * After the duplication is complete, call the CRYPT_EAL_PkeyFreeCtx interface to release the memory.162 * After the duplication is complete, call the CRYPT_EAL_PkeyFreeCtx interface to release the memory.
163 *163 *
164 * @param ctx [IN] Source Pkey context164 * @param ctx [IN] Source Pkey context
Mtestcode/framework/crypto/crypto_test_util.c+37-1
@@ -304,4 +304,40 @@ CRYPT_EAL_PkeyCtx *TestPkeyNewCtx(
304 return CRYPT_EAL_PkeyNewCtx(id);304 return CRYPT_EAL_PkeyNewCtx(id);
305#endif305#endif
306}306}
307-#endif307+#endif
308+ 
309+static volatile uint32_t g_malloc_called_idx = 0;
310+static volatile uint32_t g_malloc_failed_idx = 0;
311+static volatile bool g_malloc_fail_enabled = true;
312+ 
313+void *STUB_BSL_SAL_Malloc(uint32_t size)
314+{
315+ uint32_t current_call_index = g_malloc_called_idx;
316+ g_malloc_called_idx = current_call_index + 1;
317+ 
318+ if (g_malloc_fail_enabled && current_call_index == g_malloc_failed_idx) {
319+ return NULL;
320+ }
321+ 
322+ return malloc(size);
323+}
324+ 
325+void STUB_ResetMallocCount(void)
326+{
327+ g_malloc_called_idx = 0;
328+}
329+ 
330+void STUB_SetMallocFailIndex(uint32_t failIdx)
331+{
332+ g_malloc_failed_idx = failIdx;
333+}
334+ 
335+uint32_t STUB_GetMallocCallCount(void)
336+{
337+ return g_malloc_called_idx;
338+}
339+ 
340+void STUB_EnableMallocFail(bool enable)
341+{
342+ g_malloc_fail_enabled = enable;
343+}
Mtestcode/framework/include/test.h+49-0
@@ -161,6 +161,55 @@ void PrintLog(FILE *logFile);
161 161 
162void PrintDiff(const uint8_t *str1, uint32_t size1, const uint8_t *str2, uint32_t size2);162void PrintDiff(const uint8_t *str1, uint32_t size1, const uint8_t *str2, uint32_t size2);
163 163 
164+/**
165+ * @brief Stub function for BSL_SAL_Malloc to simulate malloc failures
166+ *
167+ * This function is used in memory leak tests to trigger malloc failures at specific points.
168+ * It tracks the number of malloc calls and returns NULL when the call count matches
169+ * the configured failure index.
170+ *
171+ * @param size Size to allocate
172+ * @return Allocated memory pointer, or NULL if simulating a failure
173+ */
174+void *STUB_BSL_SAL_Malloc(uint32_t size);
175+ 
176+/**
177+ * @brief Reset malloc stub counters
178+ *
179+ * Resets the internal counters used by STUB_BSL_SAL_Malloc. Should be called
180+ * before each test case to ensure clean state.
181+ */
182+void STUB_ResetMallocCount(void);
183+ 
184+/**
185+ * @brief Set which malloc call should fail
186+ *
187+ * Configures STUB_BSL_SAL_Malloc to fail on a specific call number.
188+ * For example, SetMallocFailIndex(3) will cause the 3rd malloc call to return NULL.
189+ *
190+ * @param failIdx The index (0-based) of the malloc call that should fail
191+ */
192+void STUB_SetMallocFailIndex(uint32_t failIdx);
193+ 
194+/**
195+ * @brief Get current malloc call count
196+ *
197+ * Returns the number of malloc calls made since the last reset.
198+ *
199+ * @return Current call count
200+ */
201+uint32_t STUB_GetMallocCallCount(void);
202+ 
203+/**
204+ * @brief Enable or disable malloc failure injection
205+ *
206+ * When disabled, STUB_BSL_SAL_Malloc will never return NULL (acts like normal malloc).
207+ * This is useful for the "probe" phase to count total malloc calls.
208+ *
209+ * @param enable true to enable failure injection, false to disable
210+ */
211+void STUB_EnableMallocFail(bool enable);
212+ 
164#ifdef __cplusplus213#ifdef __cplusplus
165}214}
166#endif215#endif
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_cipher.c+325-0
@@ -26,6 +26,7 @@
26#include "crypt_aes.h"26#include "crypt_aes.h"
27#include "crypt_eal_cipher.h"27#include "crypt_eal_cipher.h"
28#include "eal_cipher_local.h"28#include "eal_cipher_local.h"
29+#include "stub_replace.h"
29 30 
30#define DATA_LEN 1631#define DATA_LEN 16
31#define DATA_MAX_LEN 102432#define DATA_MAX_LEN 1024
@@ -285,3 +286,327 @@ EXIT:
285 CRYPT_EAL_CipherFreeCtx(ctx);286 CRYPT_EAL_CipherFreeCtx(ctx);
286}287}
287/* END_CASE */288/* END_CASE */
289+ 
290+/* BEGIN_CASE */
291+void SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001(int algId, int isProvider)
292+{
293+ TestMemInit();
294+ CRYPT_EAL_CipherCtx *ctxA = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
295+ ASSERT_TRUE(ctxA != NULL);
296+ 
297+ CRYPT_EAL_CipherCtx *ctxB = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
298+ ASSERT_TRUE(ctxB != NULL);
299+ 
300+ CRYPT_EAL_CipherCtx ctxC = { 0 };
301+ 
302+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
303+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
304+ // Copy failed because ctxC lacks a method.
305+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
306+ 
307+ CRYPT_EAL_CipherCtx *ctxD = CRYPT_EAL_CipherDupCtx(NULL);
308+ ASSERT_TRUE(ctxD == NULL);
309+ ctxD = CRYPT_EAL_CipherDupCtx(&ctxC);
310+ ASSERT_TRUE(ctxD == NULL);
311+ ctxD = CRYPT_EAL_CipherDupCtx(ctxA);
312+ ASSERT_TRUE(ctxD != NULL);
313+ 
314+ // A directly created context can also be used as the destination for copying.
315+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
316+ ctxC.method->freeCtx(ctxC.ctx);
317+ BSL_SAL_Free(ctxC.method);
318+EXIT:
319+ CRYPT_EAL_CipherFreeCtx(ctxA);
320+ CRYPT_EAL_CipherFreeCtx(ctxB);
321+ CRYPT_EAL_CipherFreeCtx(ctxD);
322+}
323+/* END_CASE */
324+ 
325+static int32_t TestCipherUpdate(CRYPT_EAL_CipherCtx *ctx, uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
326+{
327+ uint32_t tmpLen = *outLen;
328+ int32_t ret = CRYPT_SUCCESS;
329+ uint32_t totalLen = 0;
330+ if (inLen > 0) {
331+ ret = CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &tmpLen);
332+ ASSERT_EQ(ret, CRYPT_SUCCESS);
333+ totalLen = tmpLen;
334+ }
335+ 
336+ // Some algorithms do not support final.
337+ if (ctx->id != CRYPT_CIPHER_AES128_CCM && ctx->id != CRYPT_CIPHER_AES192_CCM &&
338+ ctx->id != CRYPT_CIPHER_AES256_CCM && ctx->id != CRYPT_CIPHER_AES128_GCM &&
339+ ctx->id != CRYPT_CIPHER_AES192_GCM && ctx->id != CRYPT_CIPHER_AES256_GCM &&
340+ ctx->id != CRYPT_CIPHER_SM4_GCM &&
341+ ctx->id != CRYPT_CIPHER_CHACHA20_POLY1305) {
342+ tmpLen = *outLen - totalLen;
343+ ret = CRYPT_EAL_CipherFinal(ctx, out + totalLen, &tmpLen);
344+ ASSERT_EQ(ret, CRYPT_SUCCESS);
345+ totalLen += tmpLen;
346+ }
347+ *outLen = totalLen;
348+EXIT:
349+ return ret;
350+}
351+ 
352+static int32_t TestCipherSetParam(CRYPT_EAL_CipherCtx *ctx, Hex *msg, Hex *tag, Hex *aad, int padType)
353+{
354+ int32_t algId = ctx->id;
355+ int32_t ret = CRYPT_SUCCESS;
356+ if (tag->len > 0 && algId != CRYPT_CIPHER_CHACHA20_POLY1305) {
357+ uint32_t tagLen = tag->len;
358+ ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen));
359+ ASSERT_EQ(ret, CRYPT_SUCCESS);
360+ }
361+ if (algId == CRYPT_CIPHER_AES128_CCM || algId == CRYPT_CIPHER_AES192_CCM || algId == CRYPT_CIPHER_AES256_CCM) {
362+ uint64_t inLen = msg->len;
363+ ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &inLen, sizeof(inLen));
364+ ASSERT_EQ(ret, CRYPT_SUCCESS);
365+ }
366+ if (aad->len > 0) {
367+ ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len);
368+ ASSERT_EQ(ret, CRYPT_SUCCESS);
369+ }
370+ if (padType > 0) {
371+ ret = CRYPT_EAL_CipherSetPadding(ctx, (int32_t)padType);
372+ ASSERT_TRUE(ret == CRYPT_SUCCESS);
373+ }
374+EXIT:
375+ return ret;
376+}
377+ 
378+static void TestForCopyCtx(int32_t algId, int isProvider)
379+{
380+ TestMemInit();
381+ uint8_t key[DATA_MAX_LEN];
382+ uint8_t iv[DATA_MAX_LEN];
383+ uint32_t keyLen = 0;
384+ uint32_t ivLen = 0;
385+ CRYPT_EAL_CipherCtx ctxA = {0};
386+ CRYPT_EAL_CipherCtx *ctxB = NULL;
387+ CRYPT_EAL_CipherCtx *ctxC = NULL;
388+ 
389+ ASSERT_EQ(CRYPT_EAL_CipherGetInfo(algId, CRYPT_INFO_KEY_LEN, &keyLen), CRYPT_SUCCESS);
390+ ASSERT_EQ(CRYPT_EAL_CipherGetInfo(algId, CRYPT_INFO_IV_LEN, &ivLen), CRYPT_SUCCESS);
391+ 
392+ CRYPT_EAL_CipherCtx *srcCtx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
393+ ASSERT_TRUE(srcCtx != NULL);
394+ ASSERT_EQ(CRYPT_EAL_CipherInit(srcCtx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
395+ 
396+ /* Set key and IV in srcCtx, then copy it to ctxA and ctxB. */
397+ ctxB = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
398+ ASSERT_TRUE(ctxB != NULL);
399+ 
400+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(&ctxA, srcCtx), CRYPT_SUCCESS);
401+ // Create ctxC from srcCtx.
402+ ctxC = CRYPT_EAL_CipherDupCtx(srcCtx);
403+ ASSERT_TRUE(ctxC != NULL);
404+ 
405+ CRYPT_EAL_CipherDeinit(srcCtx);
406+ ASSERT_EQ(CRYPT_EAL_CipherInit(srcCtx, key, keyLen, iv, ivLen, false), CRYPT_SUCCESS);
407+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(ctxB, srcCtx), CRYPT_SUCCESS);
408+ 
409+ uint32_t encLen = DATA_MAX_LEN;
410+ uint32_t dupEncLen = DATA_MAX_LEN;
411+ uint32_t decLen = DATA_MAX_LEN;
412+ uint8_t inTmp[DATA_MAX_LEN - 16];
413+ uint8_t encTmp[DATA_MAX_LEN];
414+ uint8_t dupEncTmp[DATA_MAX_LEN];
415+ uint8_t decTmp[DATA_MAX_LEN];
416+ /* Use ctxA for encryption and ctxB for decryption,
417+ Test that the copied contexts function identically to the source context. */
418+ ASSERT_EQ(TestCipherUpdate(&ctxA, inTmp, sizeof(inTmp), encTmp, &encLen), CRYPT_SUCCESS);
419+ ASSERT_EQ(TestCipherUpdate(ctxB, encTmp, encLen, decTmp, &decLen), CRYPT_SUCCESS);
420+ ASSERT_COMPARE("compare:", inTmp, sizeof(inTmp), decTmp, decLen);
421+ 
422+ /* Use ctxC for encryption*/
423+ ASSERT_EQ(TestCipherUpdate(ctxC, inTmp, sizeof(inTmp), dupEncTmp, &dupEncLen), CRYPT_SUCCESS);
424+ ASSERT_COMPARE("compare:", dupEncTmp, dupEncLen, encTmp, encLen);
425+ 
426+EXIT:
427+ ctxA.method->freeCtx(ctxA.ctx);
428+ BSL_SAL_Free(ctxA.method);
429+ CRYPT_EAL_CipherFreeCtx(ctxB);
430+ CRYPT_EAL_CipherFreeCtx(ctxC);
431+ CRYPT_EAL_CipherFreeCtx(srcCtx);
432+}
433+ 
434+static const int32_t g_algidList[] = {
435+ CRYPT_CIPHER_AES128_CBC, CRYPT_CIPHER_AES192_CBC, CRYPT_CIPHER_AES256_CBC,
436+ CRYPT_CIPHER_AES128_CTR, CRYPT_CIPHER_AES192_CTR, CRYPT_CIPHER_AES256_CTR,
437+ CRYPT_CIPHER_AES128_ECB, CRYPT_CIPHER_AES192_ECB, CRYPT_CIPHER_AES256_ECB,
438+ CRYPT_CIPHER_AES128_XTS, CRYPT_CIPHER_AES256_XTS,
439+ CRYPT_CIPHER_AES128_CCM, CRYPT_CIPHER_AES192_CCM, CRYPT_CIPHER_AES256_CCM,
440+ CRYPT_CIPHER_AES128_GCM, CRYPT_CIPHER_AES192_GCM, CRYPT_CIPHER_AES256_GCM,
441+ CRYPT_CIPHER_AES128_CFB, CRYPT_CIPHER_AES192_CFB, CRYPT_CIPHER_AES256_CFB,
442+ CRYPT_CIPHER_AES128_OFB, CRYPT_CIPHER_AES192_OFB, CRYPT_CIPHER_AES256_OFB,
443+ 
444+ CRYPT_CIPHER_AES128_WRAP_NOPAD, CRYPT_CIPHER_AES192_WRAP_NOPAD, CRYPT_CIPHER_AES256_WRAP_NOPAD,
445+ CRYPT_CIPHER_AES128_WRAP_PAD, CRYPT_CIPHER_AES192_WRAP_PAD, CRYPT_CIPHER_AES256_WRAP_PAD,
446+ 
447+ CRYPT_CIPHER_SM4_XTS, CRYPT_CIPHER_SM4_CBC, CRYPT_CIPHER_SM4_ECB, CRYPT_CIPHER_SM4_CTR,
448+ CRYPT_CIPHER_SM4_GCM, CRYPT_CIPHER_SM4_CFB, CRYPT_CIPHER_SM4_OFB,
449+ 
450+ CRYPT_CIPHER_CHACHA20_POLY1305
451+};
452+ 
453+/* BEGIN_CASE */
454+void SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC001(int isProvider)
455+{
456+ for (size_t i = 0; i < sizeof(g_algidList) / g_algidList[0]; i++) {
457+ TestForCopyCtx(g_algidList[i], isProvider);
458+ }
459+}
460+/* END_CASE */
461+ 
462+/* BEGIN_CASE */
463+void SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, Hex *tag, Hex *aad,
464+ int isProvider, int padType)
465+{
466+ if (IsAesAlgDisabled(algId)) {
467+ SKIP_TEST();
468+ }
469+ TestMemInit();
470+ uint8_t encTmp[DATA_MAX_LEN];
471+ uint8_t decTmp[DATA_MAX_LEN];
472+ uint32_t encLen = DATA_MAX_LEN;
473+ uint32_t decLen = DATA_MAX_LEN;
474+ uint8_t tagResult[32];
475+ 
476+ CRYPT_EAL_CipherCtx *ctxA = NULL;
477+ CRYPT_EAL_CipherCtx *ctxB = NULL;
478+ CRYPT_EAL_CipherCtx *ctxC = NULL;
479+ CRYPT_EAL_CipherCtx *srcCtx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
480+ ASSERT_TRUE(srcCtx != NULL);
481+ ctxA = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
482+ ASSERT_TRUE(ctxA != NULL);
483+ ctxB = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
484+ ASSERT_TRUE(ctxB != NULL);
485+ ASSERT_EQ(CRYPT_EAL_CipherInit(srcCtx, key->x, key->len, iv->x, iv->len, true), CRYPT_SUCCESS);
486+ ASSERT_EQ(TestCipherSetParam(srcCtx, in, tag, aad, padType), CRYPT_SUCCESS);
487+ 
488+ // Use the copied context to encryption and then decryption.
489+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(ctxA, srcCtx), CRYPT_SUCCESS);
490+ ASSERT_EQ(TestCipherUpdate(ctxA, in->x, in->len, encTmp, &encLen), CRYPT_SUCCESS);
491+ ASSERT_COMPARE("compare1:", encTmp, encLen, out->x, out->len);
492+ if (tag->len > 0) {
493+ ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctxA, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len), CRYPT_SUCCESS);
494+ ASSERT_COMPARE("tag1:", tagResult, tag->len, tag->x, tag->len);
495+ }
496+ 
497+ CRYPT_EAL_CipherDeinit(ctxA);
498+ ASSERT_EQ(CRYPT_EAL_CipherInit(ctxA, key->x, key->len, iv->x, iv->len, false), CRYPT_SUCCESS);
499+ ASSERT_EQ(TestCipherSetParam(ctxA, in, tag, aad, padType), CRYPT_SUCCESS);
500+ ASSERT_EQ(TestCipherUpdate(ctxA, encTmp, encLen, decTmp, &decLen), CRYPT_SUCCESS);
501+ ASSERT_COMPARE("compare2:", decTmp, decLen, in->x, in->len);
502+ if (tag->len > 0) {
503+ ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctxA, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len), CRYPT_SUCCESS);
504+ ASSERT_COMPARE("tag2:", tagResult, tag->len, tag->x, tag->len);
505+ }
506+ CRYPT_EAL_CipherFreeCtx(ctxA);
507+ ctxA = NULL;
508+ 
509+ // Create a new ctxC from srcCtx, use ctxC for encryption, and verify functional correctness.
510+ ctxC = CRYPT_EAL_CipherDupCtx(srcCtx);
511+ ASSERT_TRUE(ctxC != NULL);
512+ ASSERT_EQ(TestCipherUpdate(ctxC, in->x, in->len, encTmp, &encLen), CRYPT_SUCCESS);
513+ ASSERT_COMPARE("compare3:", encTmp, encLen, out->x, out->len);
514+ if (tag->len > 0) {
515+ ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctxC, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len), CRYPT_SUCCESS);
516+ ASSERT_COMPARE("tag3:", tagResult, tag->len, tag->x, tag->len);
517+ }
518+ 
519+ uint32_t totalLen = DATA_MAX_LEN;
520+ uint32_t blockLen = (in->len >= 16) ? 16 : in->len;
521+ if ((algId >= CRYPT_CIPHER_AES128_WRAP_NOPAD && algId <= CRYPT_CIPHER_AES256_WRAP_PAD) ||
522+ algId == CRYPT_CIPHER_SM4_XTS) {
523+ blockLen = in->len;
524+ }
525+ // After encrypt a portion of data, copy the ctx and encrypt of the remaining data, then compare the results.
526+ ASSERT_EQ(CRYPT_EAL_CipherUpdate(srcCtx, in->x, blockLen, encTmp, &totalLen), CRYPT_SUCCESS);
527+ encLen = DATA_MAX_LEN - totalLen;
528+ ASSERT_EQ(CRYPT_EAL_CipherCopyCtx(ctxB, srcCtx), CRYPT_SUCCESS);
529+ ASSERT_EQ(TestCipherUpdate(ctxB, in->x + blockLen, in->len - blockLen, encTmp + totalLen, &encLen), CRYPT_SUCCESS);
530+ totalLen += encLen;
531+ ASSERT_COMPARE("compare4:", encTmp, totalLen, out->x, out->len);
532+ if (tag->len > 0) {
533+ ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctxB, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len), CRYPT_SUCCESS);
534+ ASSERT_COMPARE("tag4:", tagResult, tag->len, tag->x, tag->len);
535+ }
536+ 
537+EXIT:
538+ CRYPT_EAL_CipherFreeCtx(ctxA);
539+ CRYPT_EAL_CipherFreeCtx(srcCtx);
540+ CRYPT_EAL_CipherFreeCtx(ctxB);
541+ CRYPT_EAL_CipherFreeCtx(ctxC);
542+}
543+/* END_CASE */
544+ 
545+static int32_t TestCipherCopyCtxMemCheck(int32_t algId, int isProvider)
546+{
547+ uint8_t key[DATA_MAX_LEN];
548+ uint8_t iv[DATA_MAX_LEN];
549+ uint32_t keyLen = 0;
550+ uint32_t ivLen = 0;
551+ CRYPT_EAL_CipherCtx *ctxA = NULL;
552+ CRYPT_EAL_CipherCtx *ctxB = NULL;
553+ 
554+ ASSERT_EQ(CRYPT_EAL_CipherGetInfo(algId, CRYPT_INFO_KEY_LEN, &keyLen), CRYPT_SUCCESS);
555+ ASSERT_EQ(CRYPT_EAL_CipherGetInfo(algId, CRYPT_INFO_IV_LEN, &ivLen), CRYPT_SUCCESS);
556+ 
557+ CRYPT_EAL_CipherCtx *srcCtx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
558+ /* Set key and IV in srcCtx */
559+ int32_t ret = CRYPT_EAL_CipherInit(srcCtx, key, keyLen, iv, ivLen, true);
560+ if (ret != CRYPT_SUCCESS) {
561+ goto EXIT;
562+ }
563+
564+ ctxA = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
565+ ret = CRYPT_EAL_CipherCopyCtx(ctxA, srcCtx);
566+ if (ret != CRYPT_SUCCESS) {
567+ goto EXIT;
568+ }
569+ ctxB = CRYPT_EAL_CipherDupCtx(srcCtx);
570+ if (ctxB == NULL) {
571+ ret = CRYPT_MEM_ALLOC_FAIL;
572+ goto EXIT;
573+ }
574+ 
575+EXIT:
576+ CRYPT_EAL_CipherFreeCtx(ctxA);
577+ CRYPT_EAL_CipherFreeCtx(ctxB);
578+ CRYPT_EAL_CipherFreeCtx(srcCtx);
579+ return ret;
580+}
581+ 
582+/**
583+ * @test SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001
584+ * title 1. Test the cipher copy context with stub malloc fail
585+ *
586+ */
587+/* BEGIN_CASE */
588+void SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001(int isProvider)
589+{
590+ TestMemInit();
591+ uint32_t totalMallocCount = 0;
592+ STUB_Init();
593+ FuncStubInfo tmpRpInfo = {0};
594+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
595+ for (uint32_t i = 0; i < sizeof(g_algidList) / g_algidList[0]; i++) {
596+ STUB_EnableMallocFail(false);
597+ STUB_ResetMallocCount();
598+ ASSERT_EQ(TestCipherCopyCtxMemCheck(g_algidList[i], isProvider), CRYPT_SUCCESS);
599+ totalMallocCount = STUB_GetMallocCallCount();
600+ 
601+ STUB_EnableMallocFail(true);
602+ for (uint32_t j = 0; j < totalMallocCount; j++)
603+ {
604+ STUB_ResetMallocCount();
605+ STUB_SetMallocFailIndex(j);
606+ ASSERT_NE(TestCipherCopyCtxMemCheck(g_algidList[i], isProvider), CRYPT_SUCCESS);
607+ }
608+ }
609+EXIT:
610+ STUB_Reset(&tmpRpInfo);
611+}
612+/* END_CASE */
Mtestcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_cipher.data+147-0
@@ -207,3 +207,150 @@ SDV_CRYPTO_EAL_CIPHER_FUNC_TC001:CRYPT_PADDING_PKCS7:CRYPT_CIPHER_SM4_CBC:"2b7e1
207 207 
208SDV_CRYPTO_EAL_CIPHER_FUNC_TC001 #9208SDV_CRYPTO_EAL_CIPHER_FUNC_TC001 #9
209SDV_CRYPTO_EAL_CIPHER_FUNC_TC001:CRYPT_PADDING_PKCS7:CRYPT_CIPHER_SM4_ECB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":32:480:CRYPT_SUCCESS209SDV_CRYPTO_EAL_CIPHER_FUNC_TC001:CRYPT_PADDING_PKCS7:CRYPT_CIPHER_SM4_ECB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":32:480:CRYPT_SUCCESS
210+ 
211+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001 CRYPT_CIPHER_AES128_CBC
212+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001:CRYPT_CIPHER_AES128_CBC:0
213+ 
214+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001 CRYPT_CIPHER_AES256_OFB
215+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001:CRYPT_CIPHER_AES256_OFB:1
216+ 
217+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001 CRYPT_CIPHER_SM4_CTR
218+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001:CRYPT_CIPHER_SM4_CTR:0
219+ 
220+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001 CRYPT_CIPHER_CHACHA20_POLY1305
221+SDV_CRYPTO_CIPHER_COPY_CTX_API_TC001:CRYPT_CIPHER_CHACHA20_POLY1305:0
222+ 
223+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC001
224+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC001:0
225+ 
226+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC001 Provider
227+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC001:1
228+ 
229+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_CBC
230+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_CBC:"3348aa51e9a45c2dbe33ccc47f96e8de":"19153c673160df2b1d38c28060e59b96":"9b7cee827a26575afdbb7c7a329f887238052e3601a7917456ba61251c214763d5e1847a6ad5d54127a399ab07ee3599":"d5aed6c9622ec451a15db12819952b6752501cf05cdbf8cda34a457726ded97818e1f127a28d72db5652749f0c6afee5":"":"":0:0
231+ 
232+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CBC PADDING_PKCS7
233+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CBC:"0493ff637108af6a5b8e90ac1fdf035a3d4bafd1afb573be7ade9e8682e663e5":"c0cd2bebccbb6c49920bd5482ac756e8":"8b37f9148df4bb25956be6310c73c8dc58ea9714ff49b643107b34c9bff096a94fedd6823526abc27a8e0b16616eee254ab4":"05d5c77729421b08b737e41119fa4438d1f570cc772a4d6c3df7ffeda0384ef84288ce37fc4c4c7d1125a499b051364c9696766e185b4fe717da75c7b1f88312":"":"":0:CRYPT_PADDING_PKCS7
234+ 
235+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_CTR
236+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_CTR:"2b7e151628aed2a6abf7158809cf4f3c":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6bc1bee22e409f96e93d7e117393172a":"874d6191b620e3261bef6864990db6ce":"":"":0:0
237+ 
238+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_ECB
239+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_ECB:"edfdb257cb37cdf182c5455b0c0efebb":"":"1695fe475421cace3557daca01f445ff":"7888beae6e7a426332a7eaa2f808e637":"":"":0:0
240+ 
241+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_ECB PADDING_PKCS7
242+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_ECB:"cc22da787f375711c76302bef0979d8eddf842829c2b99ef3dd04e23e54cc24b":"":"8b37f9148df4bb25956be6310c73c8dc58ea9714ff49b643107b34c9bff096a94fedd6823526abc27a8e0b16616eee254ab4":"ce7ef65514eef925182082cdb5dc275e5da20070dcc54b26ef130a7a81b3e74de709e57fd3fda0631605104b61e5f57ea328d0b66f95a5eecff65bb881764b9c":"":"":0:CRYPT_PADDING_PKCS7
243+ 
244+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_XTS #2
245+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_XTS:"1ea661c58d943a0e4801e42f4b0947149e7f9f8e3e68d0c7505210bd311a0e7cd6e13ffdf2418d8d1911c004cda58da3d619b7e2b9141e58318eea392cf41b08":"adf8d92627464ad2f0428e84a9f87564":"2eedea52cd8215e1acc647e810bbc3642e87287f8d2e57e36c0a24fbc12a202e":"cbaad0e2f6cea3f50b37f934d46a9b130b9d54f07e34f36af793e86f73c6d7db":"":"":0:0
246+ 
247+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_XTS #2
248+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_XTS:"266c336b3b01489f3267f52835fd92f674374b88b4e1ebd2d36a5f457581d9d042c3eef7b0b7e5137b086496b4d9e6ac658d7196a23f23f036172fdb8faee527":"06b209a7a22f486ecbfadb0f3137ba42":"ca7d65ef8d3dfad345b61ccddca1ad81de830b9e86c7b426d76cb7db766852d981c6b21409399d78f42cc0b33a7bbb06":"c73256870cc2f4dd57acc74b5456dbd776912a128bc1f77d72cdebbf270044b7a43ceed29025e1e8be211fa3c3ed002d":"":"":0:0
249+ 
250+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CCM
251+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CCM:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":"a544218dadd3c1":"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":"3341168eb8c48468c414347fb08f71d2086f7c2d1bd581ce":"1ac68bd42f5ec7fa7e068cc0ecd79c2a":"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":0:0
252+ 
253+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_GCM
254+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_GCM:"65b7171b55b22edd711a076f2eb6a125e873993e8d54564cd62d03c665cd6374":"54d118d32a56138f04212684b1e47c5d6808c128996e1d6ebf739ef9ff138aac1181fcde820a5f68749e1fed791314c73c54169aee5556bf206998d95432719fc9ffe22fbbc4925f32774d31e075393c0907e27c3f40da02c424b402eff596f6300b881b8f561d5ae4535a1fa9d4bafe86dd6751b0da245ae7b74ddcc3f5033c":"0521e41d827d6104ecdab1f8e7fb70cd8abca87500ecd36e65906194327b1b61014fd310f4e1bf7d5bf356a5d731c0d0d47c7e":"2ecf7a3a35abb50d212588c2ef50880212b53c052738767c9ea215709208afae6e94acd68980207bf63382495be1acde784b92":"49563e12797eefbee2fd75a1e844869b":"4a3b04decbec0a549666e87036e78433b896270792e7932810c38eb063139ade6a4befd4dfdb38d53cdb95accbdee7ad5478c3bc55a21226c2b0fa79fe7c30262fa5383de3d3b45e951d7ef955f3a18b9689783898bedb66f0b8":0:0
255+ 
256+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CFB
257+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CFB:"ae59254c66d8f533e7f5002ced480c33984a421d7816e27be66c34c19bfbc2a8":"821dd21653ece3af675cd25d26017ae3":"3cb4f17e775c2d6d06dd60f15d6c3a103e5131727f9c6cb80d13e00f316eb904":"ae375db9f28148c460f6c6b6665fcc2ff6b50b8eaf82c64bba8c649efd4731bc":"":"":0:0
258+ 
259+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_OFB
260+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_OFB:"318aa7c73006ff95840f17f2b9cf01fe7f031105ff01daa66ff95834e47b6f5c":"0e28bd0603b31c26250345a118408ffc":"257f3fc84537158b68c8af111b1e9eb41f8841686ab1e94c6fd13a7f9f24d535309c340a1dd3d4966e439a41b9b97058e9072f613ef9c1ac958b872bea59f8831b578b63eec2d7155657f953f2c2375b":"ba4ebcdc894e6de54f8f1d7ccbb19e13d2ae0ca66c05c10e2f90bad2e9b8db94ee7770c3557927029d49fd2b3f80a01025af0e7a343237fb625dbdee85367ddfbd7f6664b511cdc7e832b2c4d91f1c0e":"":"":0:0
261+ 
262+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES192_WRAP_NOPAD
263+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES192_WRAP_NOPAD:"000102030405060708090A0B0C0D0E0F1011121314151617":"":"00112233445566778899AABBCCDDEEFF":"96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D":"":"":0:0
264+ 
265+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES192_WRAP_PAD
266+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES192_WRAP_PAD:"5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8":"":"c37b7e6492584340bed12207808941155068f738":"138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a":"":"":0:0
267+ 
268+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_XTS
269+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_XTS:"2b7e151628aed2a6abf7158809cf4f3c000102030405060708090a0b0c0d0e0f":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17":"E9538251C71D7B80BBE4483FEF497BD12C5C581BD6242FC51E08964FB4F60FDB0BA42F63499279213D318D2C11F6886E903BE7F93A1B3479":"":"":0:0
270+ 
271+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CBC
272+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CBC:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"AC529AF989A62FCE9CDDC5FFB84125CAB168DD69DB3C0EEA1AB16DE6AEA43C592C15567BFF8F707486C202C7BE59101F74A629B350CD7E11BE99998AF5206D6C":"":"":0:0
273+ 
274+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_ECB
275+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_ECB:"2b7e151628aed2a6abf7158809cf4f3c":"":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"a51411ff04a711443891fce7ab842a29d5b50f46a9a730a0f590ffa776d99855c9a86a4d71447f4e873ada4f388af9b92b25557b50514d155939e6ec940ad90e":"":"":0:0
276+ 
277+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CTR
278+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CTR:"2b7e151628aed2a6abf7158809cf4f3c":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"14AE4A72B97A93CE1216CCD998E371C160F7EF8B6344BD6DA1992505E5FC219B0BF057F86C5D75103C0F46519C7FB2E7292805035ADB9A90ECEF145359D7CF0E":"":"":0:0
279+ 
280+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_GCM
281+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_GCM:"0123456789ABCDEFFEDCBA9876543210":"00001234567800000000ABCD":"AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB":"17f399f08c67d5ee19d0dc9969c4bb7d":"":"":0:0
282+ 
283+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CFB
284+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CFB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172A":"bc710d762d070b26361da82b54565e46":"":"":0:0
285+ 
286+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_OFB
287+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_OFB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"BC710D762D070B26361DA82B54565E4607A0C62834740AD3240D239125E11621D476B21CC9F04951F0741D2EF9E094981584FC142BF13AA626B82F9D7D076CCE":"":"":0:0
288+ 
289+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_CHACHA20_POLY1305
290+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_CHACHA20_POLY1305:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":"070000004041424344454647":"4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e":"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116":"1ae10b594f09e26a7e902ecbd0600691":"50515253c0c1c2c3c4c5c6c7":0:0
291+ 
292+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_CBC Provider
293+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_CBC:"3348aa51e9a45c2dbe33ccc47f96e8de":"19153c673160df2b1d38c28060e59b96":"9b7cee827a26575afdbb7c7a329f887238052e3601a7917456ba61251c214763d5e1847a6ad5d54127a399ab07ee3599":"d5aed6c9622ec451a15db12819952b6752501cf05cdbf8cda34a457726ded97818e1f127a28d72db5652749f0c6afee5":"":"":1:0
294+ 
295+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CBC PADDING_PKCS7 Provider
296+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CBC:"0493ff637108af6a5b8e90ac1fdf035a3d4bafd1afb573be7ade9e8682e663e5":"c0cd2bebccbb6c49920bd5482ac756e8":"8b37f9148df4bb25956be6310c73c8dc58ea9714ff49b643107b34c9bff096a94fedd6823526abc27a8e0b16616eee254ab4":"05d5c77729421b08b737e41119fa4438d1f570cc772a4d6c3df7ffeda0384ef84288ce37fc4c4c7d1125a499b051364c9696766e185b4fe717da75c7b1f88312":"":"":1:CRYPT_PADDING_PKCS7
297+ 
298+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_CTR Provider
299+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_CTR:"2b7e151628aed2a6abf7158809cf4f3c":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6bc1bee22e409f96e93d7e117393172a":"874d6191b620e3261bef6864990db6ce":"":"":1:0
300+ 
301+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_ECB Provider
302+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_ECB:"edfdb257cb37cdf182c5455b0c0efebb":"":"1695fe475421cace3557daca01f445ff":"7888beae6e7a426332a7eaa2f808e637":"":"":1:0
303+ 
304+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_ECB PADDING_PKCS7 Provider
305+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_ECB:"cc22da787f375711c76302bef0979d8eddf842829c2b99ef3dd04e23e54cc24b":"":"8b37f9148df4bb25956be6310c73c8dc58ea9714ff49b643107b34c9bff096a94fedd6823526abc27a8e0b16616eee254ab4":"ce7ef65514eef925182082cdb5dc275e5da20070dcc54b26ef130a7a81b3e74de709e57fd3fda0631605104b61e5f57ea328d0b66f95a5eecff65bb881764b9c":"":"":1:CRYPT_PADDING_PKCS7
306+ 
307+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_XTS Provider
308+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_XTS:"1ea661c58d943a0e4801e42f4b0947149e7f9f8e3e68d0c7505210bd311a0e7cd6e13ffdf2418d8d1911c004cda58da3d619b7e2b9141e58318eea392cf41b08":"adf8d92627464ad2f0428e84a9f87564":"2eedea52cd8215e1acc647e810bbc3642e87287f8d2e57e36c0a24fbc12a202e":"cbaad0e2f6cea3f50b37f934d46a9b130b9d54f07e34f36af793e86f73c6d7db":"":"":1:0
309+ 
310+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CCM Provider
311+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CCM:"705334e30f53dd2f92d190d2c1437c8772f940c55aa35e562214ed45bd458ffe":"a544218dadd3c1":"78c46e3249ca28e1ef0531d80fd37c124d9aecb7be6668e3":"3341168eb8c48468c414347fb08f71d2086f7c2d1bd581ce":"1ac68bd42f5ec7fa7e068cc0ecd79c2a":"d3d5424e20fbec43ae495353ed830271515ab104f8860c988d15b6d36c038eab":1:0
312+ 
313+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_GCM Provider
314+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_GCM:"65b7171b55b22edd711a076f2eb6a125e873993e8d54564cd62d03c665cd6374":"54d118d32a56138f04212684b1e47c5d6808c128996e1d6ebf739ef9ff138aac1181fcde820a5f68749e1fed791314c73c54169aee5556bf206998d95432719fc9ffe22fbbc4925f32774d31e075393c0907e27c3f40da02c424b402eff596f6300b881b8f561d5ae4535a1fa9d4bafe86dd6751b0da245ae7b74ddcc3f5033c":"0521e41d827d6104ecdab1f8e7fb70cd8abca87500ecd36e65906194327b1b61014fd310f4e1bf7d5bf356a5d731c0d0d47c7e":"2ecf7a3a35abb50d212588c2ef50880212b53c052738767c9ea215709208afae6e94acd68980207bf63382495be1acde784b92":"49563e12797eefbee2fd75a1e844869b":"4a3b04decbec0a549666e87036e78433b896270792e7932810c38eb063139ade6a4befd4dfdb38d53cdb95accbdee7ad5478c3bc55a21226c2b0fa79fe7c30262fa5383de3d3b45e951d7ef955f3a18b9689783898bedb66f0b8":1:0
315+ 
316+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_CFB Provider
317+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_CFB:"ae59254c66d8f533e7f5002ced480c33984a421d7816e27be66c34c19bfbc2a8":"821dd21653ece3af675cd25d26017ae3":"3cb4f17e775c2d6d06dd60f15d6c3a103e5131727f9c6cb80d13e00f316eb904":"ae375db9f28148c460f6c6b6665fcc2ff6b50b8eaf82c64bba8c649efd4731bc":"":"":1:0
318+ 
319+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_OFB Provider
320+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_OFB:"318aa7c73006ff95840f17f2b9cf01fe7f031105ff01daa66ff95834e47b6f5c":"0e28bd0603b31c26250345a118408ffc":"257f3fc84537158b68c8af111b1e9eb41f8841686ab1e94c6fd13a7f9f24d535309c340a1dd3d4966e439a41b9b97058e9072f613ef9c1ac958b872bea59f8831b578b63eec2d7155657f953f2c2375b":"ba4ebcdc894e6de54f8f1d7ccbb19e13d2ae0ca66c05c10e2f90bad2e9b8db94ee7770c3557927029d49fd2b3f80a01025af0e7a343237fb625dbdee85367ddfbd7f6664b511cdc7e832b2c4d91f1c0e":"":"":1:0
321+ 
322+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES128_WRAP_NOPAD Provider
323+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES128_WRAP_NOPAD:"000102030405060708090A0B0C0D0E0F":"":"00112233445566778899AABBCCDDEEFF":"1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5":"":"":1:0
324+ 
325+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_AES256_WRAP_NOPAD Provider
326+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_AES256_WRAP_NOPAD:"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F":"":"00112233445566778899AABBCCDDEEFF0001020304050607":"A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1":"":"":1:0
327+ 
328+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_XTS Provider
329+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_XTS:"2b7e151628aed2a6abf7158809cf4f3c000102030405060708090a0b0c0d0e0f":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17":"E9538251C71D7B80BBE4483FEF497BD12C5C581BD6242FC51E08964FB4F60FDB0BA42F63499279213D318D2C11F6886E903BE7F93A1B3479":"":"":1:0
330+ 
331+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CBC Provider
332+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CBC:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"AC529AF989A62FCE9CDDC5FFB84125CAB168DD69DB3C0EEA1AB16DE6AEA43C592C15567BFF8F707486C202C7BE59101F74A629B350CD7E11BE99998AF5206D6C":"":"":1:0
333+ 
334+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_ECB Provider
335+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_ECB:"2b7e151628aed2a6abf7158809cf4f3c":"":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"a51411ff04a711443891fce7ab842a29d5b50f46a9a730a0f590ffa776d99855c9a86a4d71447f4e873ada4f388af9b92b25557b50514d155939e6ec940ad90e":"":"":1:0
336+ 
337+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CTR Provider
338+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CTR:"2b7e151628aed2a6abf7158809cf4f3c":"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"14AE4A72B97A93CE1216CCD998E371C160F7EF8B6344BD6DA1992505E5FC219B0BF057F86C5D75103C0F46519C7FB2E7292805035ADB9A90ECEF145359D7CF0E":"":"":1:0
339+ 
340+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_GCM Provider
341+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_GCM:"0123456789ABCDEFFEDCBA9876543210":"00001234567800000000ABCD":"AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB":"17f399f08c67d5ee19d0dc9969c4bb7d":"":"":1:0
342+ 
343+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_CFB Provider
344+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_CFB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172A":"bc710d762d070b26361da82b54565e46":"":"":1:0
345+ 
346+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_SM4_OFB Provider
347+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_SM4_OFB:"2b7e151628aed2a6abf7158809cf4f3c":"000102030405060708090A0B0C0D0E0F":"6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17AD2B417BE66C3710":"BC710D762D070B26361DA82B54565E4607A0C62834740AD3240D239125E11621D476B21CC9F04951F0741D2EF9E094981584FC142BF13AA626B82F9D7D076CCE":"":"":1:0
348+ 
349+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002 CRYPT_CIPHER_CHACHA20_POLY1305 Provider
350+SDV_CRYPTO_CIPHER_COPY_CTX_FUNC_TC002:CRYPT_CIPHER_CHACHA20_POLY1305:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":"070000004041424344454647":"4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e20776f756c642062652069742e":"d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116":"1ae10b594f09e26a7e902ecbd0600691":"50515253c0c1c2c3c4c5c6c7":1:0
351+ 
352+SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001
353+SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001:0
354+ 
355+SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001 Provider
356+SDV_CRYPTO_CIPHER_COPY_CTX_STUB_TC001:1
Mtestcode/sdv/testcase/crypto/cbc_mac/test_suite_sdv_eal_mac_cbc_mac.c+184-0
@@ -16,8 +16,10 @@
16/* BEGIN_HEADER */16/* BEGIN_HEADER */
17#include "securec.h"17#include "securec.h"
18#include "crypt_eal_mac.h"18#include "crypt_eal_mac.h"
19+#include "eal_mac_local.h"
19#include "crypt_errno.h"20#include "crypt_errno.h"
20#include "bsl_sal.h"21#include "bsl_sal.h"
22+#include "stub_replace.h"
21 23 
22#define CBC_MAC_MAC_LEN 1624#define CBC_MAC_MAC_LEN 16
23#define SM4_KEY_LEN 1625#define SM4_KEY_LEN 16
@@ -581,3 +583,185 @@ void SDV_CRYPT_EAL_CBC_MAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *d
581 TestMacAddrNotAlign(algId, key, data, mac);583 TestMacAddrNotAlign(algId, key, data, mac);
582}584}
583/* END_CASE */585/* END_CASE */
586+ 
587+/* BEGIN_CASE */
588+void SDV_CRYPTO_CBC_MAC_COPY_CTX_API_TC001(int algId, int isProvider)
589+{
590+ TestMemInit();
591+ CRYPT_EAL_MacCtx *ctxB = NULL;
592+ CRYPT_EAL_MacCtx ctxC = { 0 };
593+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
594+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
595+ ASSERT_TRUE(ctxA != NULL);
596+ 
597+ ctxB = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
598+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
599+ ASSERT_TRUE(ctxB != NULL);
600+ 
601+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
602+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
603+ // Copy failed because ctxC lacks a method.
604+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
605+ 
606+ // A directly created context can also be used as the destination for copying.
607+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
608+ ctxC.macMeth->freeCtx(ctxC.ctx);
609+ BSL_SAL_Free(ctxC.macMeth);
610+EXIT:
611+ CRYPT_EAL_MacFreeCtx(ctxA);
612+ CRYPT_EAL_MacFreeCtx(ctxB);
613+}
614+/* END_CASE */
615+ 
616+/* BEGIN_CASE */
617+void SDV_CRYPTO_CBC_MAC_DUP_CTX_API_TC001(int algId, int isProvider)
618+{
619+ TestMemInit();
620+ CRYPT_EAL_MacCtx *ctxB = NULL;
621+ CRYPT_EAL_MacCtx ctxC = { 0 };
622+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
623+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
624+ ASSERT_TRUE(ctxA != NULL);
625+ 
626+ ctxB = CRYPT_EAL_MacDupCtx(NULL);
627+ ASSERT_TRUE(ctxB == NULL);
628+ ctxB = CRYPT_EAL_MacDupCtx(&ctxC);
629+ ASSERT_TRUE(ctxB == NULL);
630+ ctxB = CRYPT_EAL_MacDupCtx(ctxA);
631+ ASSERT_TRUE(ctxB != NULL);
632+ 
633+EXIT:
634+ CRYPT_EAL_MacFreeCtx(ctxA);
635+ CRYPT_EAL_MacFreeCtx(ctxB);
636+}
637+/* END_CASE */
638+ 
639+/* BEGIN_CASE */
640+void SDV_CRYPT_EAL_CBC_MAC_COPY_CTX_TC001(int algId, int padType, Hex *key, Hex *data, Hex *vecMac, int isProvider)
641+{
642+ if (IsHmacAlgDisabled(algId)) {
643+ SKIP_TEST();
644+ }
645+ TestMemInit();
646+ uint32_t macLen = vecMac->len;
647+ uint8_t mac[64];
648+ 
649+ CRYPT_EAL_MacCtx *copyCtx1 = NULL;
650+ CRYPT_EAL_MacCtx *copyCtx2 = NULL;
651+ CRYPT_EAL_MacCtx *copyCtx3 = NULL;
652+ CRYPT_EAL_MacCtx *ctx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
653+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
654+ ASSERT_TRUE(ctx != NULL);
655+ ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
656+ int32_t pad = (int32_t)padType;
657+ ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
658+ 
659+ copyCtx1 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
660+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
661+ ASSERT_TRUE(copyCtx1 != NULL);
662+ copyCtx2 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
663+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
664+ ASSERT_TRUE(copyCtx2 != NULL);
665+ 
666+ // Test that the copied context functions correctly and is independent of the original context.
667+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
668+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx1, data->x, data->len), CRYPT_SUCCESS);
669+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx1, mac, &macLen), CRYPT_SUCCESS);
670+ ASSERT_COMPARE("mac1 cmp", mac, macLen, vecMac->x, vecMac->len);
671+ CRYPT_EAL_MacFreeCtx(copyCtx1);
672+ copyCtx1 = NULL;
673+ 
674+ // Create a new copyCtx3 from ctx, use copyCtx3 for encryption, and verify functional correctness.
675+ copyCtx3 = CRYPT_EAL_MacDupCtx(ctx);
676+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx3, data->x, data->len), CRYPT_SUCCESS);
677+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx3, mac, &macLen), CRYPT_SUCCESS);
678+ ASSERT_COMPARE("mac2 cmp", mac, macLen, vecMac->x, vecMac->len);
679+ CRYPT_EAL_MacFreeCtx(copyCtx3);
680+ copyCtx3 = NULL;
681+ 
682+ macLen = vecMac->len;
683+ ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
684+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
685+ ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
686+ ASSERT_COMPARE("mac3 cmp", mac, macLen, vecMac->x, vecMac->len);
687+ CRYPT_EAL_MacFreeCtx(ctx);
688+ ctx = NULL;
689+ 
690+ macLen = vecMac->len;
691+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx2, mac, &macLen), CRYPT_SUCCESS);
692+ ASSERT_COMPARE("mac4 cmp", mac, macLen, vecMac->x, vecMac->len);
693+ 
694+EXIT:
695+ CRYPT_EAL_MacFreeCtx(copyCtx3);
696+ CRYPT_EAL_MacFreeCtx(copyCtx2);
697+ CRYPT_EAL_MacFreeCtx(copyCtx1);
698+ CRYPT_EAL_MacFreeCtx(ctx);
699+}
700+/* END_CASE */
701+ 
702+static int32_t TestMacCopyCtxMemCheck(int32_t algId, Hex *key, int isProvider)
703+{
704+ CRYPT_EAL_MacCtx *ctxA = NULL;
705+ CRYPT_EAL_MacCtx *ctxB = NULL;
706+ CRYPT_EAL_MacCtx *srcCtx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
707+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
708+ /* Set key in srcCtx */
709+ int32_t ret = CRYPT_EAL_MacInit(srcCtx, key->x, key->len);
710+ if (ret != CRYPT_SUCCESS) {
711+ goto EXIT;
712+ }
713+ int32_t pad = CRYPT_PADDING_ZEROS;
714+ ret = CRYPT_EAL_MacCtrl(srcCtx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &pad, sizeof(pad));
715+ if (ret != CRYPT_SUCCESS) {
716+ goto EXIT;
717+ }
718+ 
719+ ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
720+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
721+ ret = CRYPT_EAL_MacCopyCtx(ctxA, srcCtx);
722+ if (ret != CRYPT_SUCCESS) {
723+ goto EXIT;
724+ }
725+ ctxB = CRYPT_EAL_MacDupCtx(srcCtx);
726+ if (ctxB == NULL) {
727+ ret = CRYPT_MEM_ALLOC_FAIL;
728+ goto EXIT;
729+ }
730+ 
731+EXIT:
732+ CRYPT_EAL_MacFreeCtx(ctxA);
733+ CRYPT_EAL_MacFreeCtx(ctxB);
734+ CRYPT_EAL_MacFreeCtx(srcCtx);
735+ return ret;
736+}
737+ 
738+/**
739+ * @test SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001
740+ * title 1. Test the mac copy context with stub malloc fail
741+ *
742+ */
743+/* BEGIN_CASE */
744+void SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001(int algId, Hex *key, int isProvider)
745+{
746+ TestMemInit();
747+ uint32_t totalMallocCount = 0;
748+ STUB_Init();
749+ FuncStubInfo tmpRpInfo = {0};
750+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
751+ 
752+ STUB_EnableMallocFail(false);
753+ STUB_ResetMallocCount();
754+ ASSERT_EQ(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
755+ totalMallocCount = STUB_GetMallocCallCount();
756+ 
757+ STUB_EnableMallocFail(true);
758+ for (uint32_t j = 0; j < totalMallocCount; j++) {
759+ STUB_ResetMallocCount();
760+ STUB_SetMallocFailIndex(j);
761+ ASSERT_NE(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
762+ }
763+ 
764+EXIT:
765+ STUB_Reset(&tmpRpInfo);
766+}
767+/* END_CASE */
Mtestcode/sdv/testcase/crypto/cbc_mac/test_suite_sdv_eal_mac_cbc_mac.data+25-1
@@ -50,4 +50,28 @@ in/out same address test: CRYPT_MAC_CBC_MAC_SM4
50SDV_CRYPT_EAL_CBC_MAC_SAMEADDR_FUNC_TC001:CRYPT_MAC_CBC_MAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"dbbe98446572391ff7fc5a2a7c82dacc"50SDV_CRYPT_EAL_CBC_MAC_SAMEADDR_FUNC_TC001:CRYPT_MAC_CBC_MAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"dbbe98446572391ff7fc5a2a7c82dacc"
51 51 
52address misalignment test: CRYPT_MAC_CBC_MAC_SM452address misalignment test: CRYPT_MAC_CBC_MAC_SM4
53-SDV_CRYPT_EAL_CBC_MAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_CBC_MAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"dbbe98446572391ff7fc5a2a7c82dacc"53+SDV_CRYPT_EAL_CBC_MAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_CBC_MAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"dbbe98446572391ff7fc5a2a7c82dacc"
54+ 
55+SDV_CRYPTO_CBC_MAC_COPY_CTX_API_TC001
56+SDV_CRYPTO_CBC_MAC_COPY_CTX_API_TC001:CRYPT_MAC_CBC_MAC_SM4:0
57+ 
58+SDV_CRYPTO_CBC_MAC_COPY_CTX_API_TC001 Provider
59+SDV_CRYPTO_CBC_MAC_COPY_CTX_API_TC001:CRYPT_MAC_CBC_MAC_SM4:1
60+ 
61+SDV_CRYPTO_CBC_MAC_DUP_CTX_API_TC001
62+SDV_CRYPTO_CBC_MAC_DUP_CTX_API_TC001:CRYPT_MAC_CBC_MAC_SM4:0
63+ 
64+SDV_CRYPTO_CBC_MAC_DUP_CTX_API_TC001 Provider
65+SDV_CRYPTO_CBC_MAC_DUP_CTX_API_TC001:CRYPT_MAC_CBC_MAC_SM4:1
66+ 
67+SDV_CRYPT_EAL_CBC_MAC_COPY_CTX_TC001 CRYPT_MAC_CBC_MAC_SM4
68+SDV_CRYPT_EAL_CBC_MAC_COPY_CTX_TC001:CRYPT_MAC_CBC_MAC_SM4:CRYPT_PADDING_ZEROS:"0a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffff":"648574aa0f0659bfcc43ede6560c5a23":0
69+ 
70+SDV_CRYPT_EAL_CBC_MAC_COPY_CTX_TC001 CRYPT_MAC_CBC_MAC_SM4 Provider
71+SDV_CRYPT_EAL_CBC_MAC_COPY_CTX_TC001:CRYPT_MAC_CBC_MAC_SM4:CRYPT_PADDING_ZEROS:"0a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffff":"648574aa0f0659bfcc43ede6560c5a23":1
72+ 
73+SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001
74+SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CBC_MAC_SM4:"0a00000000000000d71d5e0000000000":0
75+ 
76+SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001 Provider
77+SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CBC_MAC_SM4:"0a00000000000000d71d5e0000000000":1
Mtestcode/sdv/testcase/crypto/cmac/test_suite_sdv_eal_mac_cmac.c+181-1
@@ -18,8 +18,11 @@
18#include <pthread.h>18#include <pthread.h>
19#include "securec.h"19#include "securec.h"
20#include "crypt_eal_mac.h"20#include "crypt_eal_mac.h"
21+#include "eal_mac_local.h"
21#include "crypt_errno.h"22#include "crypt_errno.h"
22#include "bsl_sal.h"23#include "bsl_sal.h"
24+#include "stub_replace.h"
25+/* END_HEADER */
23 26 
24#define AES128_KEY_LEN 1627#define AES128_KEY_LEN 16
25#define AES192_KEY_LEN 2428#define AES192_KEY_LEN 24
@@ -43,7 +46,6 @@ uint32_t GetKeyLen(int algId)
43 return 0;46 return 0;
44 }47 }
45}48}
46-/* END_HEADER */
47 49 
48/* @50/* @
49* @test SDV_CRYPT_EAL_CMAC_API_TC00151* @test SDV_CRYPT_EAL_CMAC_API_TC001
@@ -837,3 +839,181 @@ void SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *data
837 TestMacAddrNotAlign(algId, key, data, mac);839 TestMacAddrNotAlign(algId, key, data, mac);
838}840}
839/* END_CASE */841/* END_CASE */
842+ 
843+/* BEGIN_CASE */
844+void SDV_CRYPTO_CMAC_COPY_CTX_API_TC001(int algId, int isProvider)
845+{
846+ TestMemInit();
847+ CRYPT_EAL_MacCtx *ctxB = NULL;
848+ CRYPT_EAL_MacCtx ctxC = { 0 };
849+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
850+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
851+ ASSERT_TRUE(ctxA != NULL);
852+ 
853+ ctxB = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
854+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
855+ ASSERT_TRUE(ctxB != NULL);
856+ 
857+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
858+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
859+ // Copy failed because ctxC lacks a method.
860+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
861+ 
862+ // A directly created context can also be used as the destination for copying.
863+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
864+ ctxC.macMeth->freeCtx(ctxC.ctx);
865+ BSL_SAL_Free(ctxC.macMeth);
866+EXIT:
867+ CRYPT_EAL_MacFreeCtx(ctxA);
868+ CRYPT_EAL_MacFreeCtx(ctxB);
869+}
870+/* END_CASE */
871+ 
872+/* BEGIN_CASE */
873+void SDV_CRYPTO_CMAC_DUP_CTX_API_TC001(int algId, int isProvider)
874+{
875+ TestMemInit();
876+ CRYPT_EAL_MacCtx *ctxB = NULL;
877+ CRYPT_EAL_MacCtx ctxC = { 0 };
878+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
879+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
880+ ASSERT_TRUE(ctxA != NULL);
881+ 
882+ ctxB = CRYPT_EAL_MacDupCtx(NULL);
883+ ASSERT_TRUE(ctxB == NULL);
884+ ctxB = CRYPT_EAL_MacDupCtx(&ctxC);
885+ ASSERT_TRUE(ctxB == NULL);
886+ ctxB = CRYPT_EAL_MacDupCtx(ctxA);
887+ ASSERT_TRUE(ctxB != NULL);
888+ 
889+EXIT:
890+ CRYPT_EAL_MacFreeCtx(ctxA);
891+ CRYPT_EAL_MacFreeCtx(ctxB);
892+}
893+/* END_CASE */
894+ 
895+/* BEGIN_CASE */
896+void SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001(int algId, Hex *key, Hex *data, Hex *vecMac, int isProvider)
897+{
898+ if (IsHmacAlgDisabled(algId)) {
899+ SKIP_TEST();
900+ }
901+ TestMemInit();
902+ uint32_t macLen = vecMac->len;
903+ uint8_t mac[64];
904+ 
905+ CRYPT_EAL_MacCtx *copyCtx1 = NULL;
906+ CRYPT_EAL_MacCtx *copyCtx2 = NULL;
907+ CRYPT_EAL_MacCtx *copyCtx3 = NULL;
908+ CRYPT_EAL_MacCtx *ctx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
909+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
910+ ASSERT_TRUE(ctx != NULL);
911+ ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
912+ 
913+ copyCtx1 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
914+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
915+ ASSERT_TRUE(copyCtx1 != NULL);
916+ copyCtx2 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
917+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
918+ ASSERT_TRUE(copyCtx2 != NULL);
919+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(NULL, ctx), CRYPT_NULL_INPUT);
920+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx1, NULL), CRYPT_NULL_INPUT);
921+ 
922+ // Test that the copied context functions correctly and is independent of the original context.
923+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
924+ 
925+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx1, data->x, data->len), CRYPT_SUCCESS);
926+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx1, mac, &macLen), CRYPT_SUCCESS);
927+ ASSERT_COMPARE("mac1 cmp", mac, macLen, vecMac->x, vecMac->len);
928+ CRYPT_EAL_MacFreeCtx(copyCtx1);
929+ copyCtx1 = NULL;
930+ 
931+ // Create a new copyCtx3 from ctx, use copyCtx3 for encryption, and verify functional correctness.
932+ copyCtx3 = CRYPT_EAL_MacDupCtx(ctx);
933+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx3, data->x, data->len), CRYPT_SUCCESS);
934+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx3, mac, &macLen), CRYPT_SUCCESS);
935+ ASSERT_COMPARE("mac2 cmp", mac, macLen, vecMac->x, vecMac->len);
936+ CRYPT_EAL_MacFreeCtx(copyCtx3);
937+ copyCtx3 = NULL;
938+ 
939+ macLen = vecMac->len;
940+ ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
941+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
942+ ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
943+ ASSERT_COMPARE("mac3 cmp", mac, macLen, vecMac->x, vecMac->len);
944+ CRYPT_EAL_MacFreeCtx(ctx);
945+ ctx = NULL;
946+ 
947+ macLen = vecMac->len;
948+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx2, mac, &macLen), CRYPT_SUCCESS);
949+ ASSERT_COMPARE("mac4 cmp", mac, macLen, vecMac->x, vecMac->len);
950+ 
951+EXIT:
952+ CRYPT_EAL_MacFreeCtx(copyCtx3);
953+ CRYPT_EAL_MacFreeCtx(copyCtx2);
954+ CRYPT_EAL_MacFreeCtx(copyCtx1);
955+ CRYPT_EAL_MacFreeCtx(ctx);
956+}
957+/* END_CASE */
958+ 
959+static int32_t TestMacCopyCtxMemCheck(int32_t algId, Hex *key, int isProvider)
960+{
961+ CRYPT_EAL_MacCtx *ctxA = NULL;
962+ CRYPT_EAL_MacCtx *ctxB = NULL;
963+ CRYPT_EAL_MacCtx *srcCtx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
964+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
965+ /* Set key in srcCtx */
966+ int32_t ret = CRYPT_EAL_MacInit(srcCtx, key->x, key->len);
967+ if (ret != CRYPT_SUCCESS) {
968+ goto EXIT;
969+ }
970+ 
971+ ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
972+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
973+ ret = CRYPT_EAL_MacCopyCtx(ctxA, srcCtx);
974+ if (ret != CRYPT_SUCCESS) {
975+ goto EXIT;
976+ }
977+ ctxB = CRYPT_EAL_MacDupCtx(srcCtx);
978+ if (ctxB == NULL) {
979+ ret = CRYPT_MEM_ALLOC_FAIL;
980+ goto EXIT;
981+ }
982+ 
983+EXIT:
984+ CRYPT_EAL_MacFreeCtx(ctxA);
985+ CRYPT_EAL_MacFreeCtx(ctxB);
986+ CRYPT_EAL_MacFreeCtx(srcCtx);
987+ return ret;
988+}
989+ 
990+/**
991+ * @test SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001
992+ * title 1. Test the mac copy context with stub malloc fail
993+ *
994+ */
995+/* BEGIN_CASE */
996+void SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001(int algId, Hex *key, int isProvider)
997+{
998+ TestMemInit();
999+ uint32_t totalMallocCount = 0;
1000+ STUB_Init();
1001+ FuncStubInfo tmpRpInfo = {0};
1002+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
1003+ 
1004+ STUB_EnableMallocFail(false);
1005+ STUB_ResetMallocCount();
1006+ ASSERT_EQ(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
1007+ totalMallocCount = STUB_GetMallocCallCount();
1008+ 
1009+ STUB_EnableMallocFail(true);
1010+ for (uint32_t j = 0; j < totalMallocCount; j++) {
1011+ STUB_ResetMallocCount();
1012+ STUB_SetMallocFailIndex(j);
1013+ ASSERT_NE(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
1014+ }
1015+ 
1016+EXIT:
1017+ STUB_Reset(&tmpRpInfo);
1018+}
1019+/* END_CASE */
Mtestcode/sdv/testcase/crypto/cmac/test_suite_sdv_eal_mac_cmac.data+48-0
@@ -216,3 +216,51 @@ SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_CMAC_AES256:"000000000000
216 216 
217address misalignment test: CRYPT_MAC_CMAC_SM4 #self generate test data217address misalignment test: CRYPT_MAC_CMAC_SM4 #self generate test data
218SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_CMAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"623e0dc299d72edad99ed0ba20c13f53"218SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_CMAC_SM4:"00000000000000000000000000000000":"60437d010000000064fafee5787f0000":"623e0dc299d72edad99ed0ba20c13f53"
219+ 
220+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001 CRYPT_MAC_CMAC_AES256
221+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001:CRYPT_MAC_CMAC_AES256:0
222+ 
223+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001 CRYPT_MAC_CMAC_SM4
224+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001:CRYPT_MAC_CMAC_SM4:0
225+ 
226+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001 CRYPT_MAC_CMAC_AES128 Provider
227+SDV_CRYPTO_CMAC_COPY_CTX_API_TC001:CRYPT_MAC_CMAC_AES128:1
228+ 
229+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001 CRYPT_MAC_CMAC_AES256
230+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001:CRYPT_MAC_CMAC_AES256:0
231+ 
232+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001 CRYPT_MAC_CMAC_SM4
233+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001:CRYPT_MAC_CMAC_SM4:0
234+ 
235+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001 CRYPT_MAC_CMAC_AES128 Provider
236+SDV_CRYPTO_CMAC_DUP_CTX_API_TC001:CRYPT_MAC_CMAC_AES128:1
237+ 
238+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_AES128
239+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_AES128:"0a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffff":"253d6426be10b0a1c9a010fd7234225f":0
240+ 
241+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_AES192
242+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_AES192:"ffffffffffffffff642ad2b2c97f00000a00000000000000":"ffffffffffffffffffffffffffffffffffffffffffffffff":"93b892b8f9920688781d48112fa549bf":0
243+ 
244+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_AES256
245+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_AES256:"ffffffffffffffff642ad2b2c97f00000a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff":"93946d2fb9c4f5d0b3f29baaaf4427b9":0
246+ 
247+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_SM4
248+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_SM4:"0a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffff":"ce837ff991368d769a3beff3260f32e6":0
249+ 
250+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_AES256 Provider
251+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_AES256:"ffffffffffffffff642ad2b2c97f00000a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff":"93946d2fb9c4f5d0b3f29baaaf4427b9":1
252+ 
253+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001 CRYPT_MAC_CMAC_SM4 Provider
254+SDV_CRYPT_EAL_CMAC_COPY_CTX_TC001:CRYPT_MAC_CMAC_SM4:"0a00000000000000d71d5e0000000000":"ffffffffffffffffffffffffffffffff":"ce837ff991368d769a3beff3260f32e6":1
255+ 
256+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001
257+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CMAC_AES256:"ffffffffffffffff642ad2b2c97f00000a00000000000000d71d5e0000000000":0
258+ 
259+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001
260+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CMAC_SM4:"0a00000000000000d71d5e0000000000":0
261+ 
262+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001 Provider
263+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CMAC_AES128:"0a00000000000000d71d5e0000000000":1
264+ 
265+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001 Provider
266+SDV_CRYPTO_CMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_CMAC_SM4:"0a00000000000000d71d5e0000000000":1
Mtestcode/sdv/testcase/crypto/encode/test_suite_sdv_asn1_certkey.c+2-2
@@ -919,7 +919,7 @@ EXIT:
919 919 
920static int32_t test = 0;920static int32_t test = 0;
921static int32_t marked = 0;921static int32_t marked = 0;
922-static void *STUB_BSL_SAL_Malloc(uint32_t size)922+static void *STUB_BSL_SAL_Malloc_cert(uint32_t size)
923{923{
924 if (marked <= test) {924 if (marked <= test) {
925 marked++;925 marked++;
@@ -959,7 +959,7 @@ void SDV_BSL_ASN1_PARSE_BUFF_STUB_TC001(char *formatStr, char *typeStr, char *pa
959 marked = 0;959 marked = 0;
960 STUB_Init();960 STUB_Init();
961 FuncStubInfo tmpRpInfo;961 FuncStubInfo tmpRpInfo;
962- STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc);962+ STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc_cert);
963 for (int i = maxTriggers; i > 0; i--) {963 for (int i = maxTriggers; i > 0; i--) {
964 marked = 0;964 marked = 0;
965 test--;965 test--;
Mtestcode/sdv/testcase/crypto/gmac/test_suite_sdv_eal_gmac.c+149-0
@@ -23,6 +23,7 @@
23#include "crypt_eal_mac.h"23#include "crypt_eal_mac.h"
24#include "bsl_sal.h"24#include "bsl_sal.h"
25#include "eal_mac_local.h"25#include "eal_mac_local.h"
26+#include "stub_replace.h"
26 27 
27/* END_HEADER */28/* END_HEADER */
28#define GMAC_DEFAULT_TAGLEN 1629#define GMAC_DEFAULT_TAGLEN 16
@@ -266,3 +267,151 @@ EXIT:
266 CRYPT_EAL_MacFreeCtx(ctx);267 CRYPT_EAL_MacFreeCtx(ctx);
267}268}
268/* END_CASE */269/* END_CASE */
270+ 
271+/* BEGIN_CASE */
272+void SDV_CRYPTO_GMAC_COPY_CTX_API_TC001(int algId, int isProvider)
273+{
274+ TestMemInit();
275+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
276+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
277+ ASSERT_TRUE(ctxA != NULL);
278+ 
279+ CRYPT_EAL_MacCtx *ctxB = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
280+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
281+ ASSERT_TRUE(ctxB != NULL);
282+ 
283+ CRYPT_EAL_MacCtx ctxC = { 0 };
284+ 
285+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
286+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
287+ // Copy failed because ctxC lacks a method.
288+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
289+ 
290+ // A directly created context can also be used as the destination for copying.
291+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
292+ ctxC.macMeth->freeCtx(ctxC.ctx);
293+ BSL_SAL_Free(ctxC.macMeth);
294+EXIT:
295+ CRYPT_EAL_MacFreeCtx(ctxA);
296+ CRYPT_EAL_MacFreeCtx(ctxB);
297+}
298+/* END_CASE */
299+ 
300+/* BEGIN_CASE */
301+void SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001(int algId, Hex *key, Hex *iv, Hex *data, Hex *vecMac, int isProvider)
302+{
303+ if (IsHmacAlgDisabled(algId)) {
304+ SKIP_TEST();
305+ }
306+ TestMemInit();
307+ uint32_t macLen = vecMac->len;
308+ uint8_t mac[64];
309+ 
310+ CRYPT_EAL_MacCtx *copyCtx1 = NULL;
311+ CRYPT_EAL_MacCtx *copyCtx2 = NULL;
312+ CRYPT_EAL_MacCtx *ctx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
313+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
314+ ASSERT_TRUE(ctx != NULL);
315+ ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
316+ ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_SUCCESS);
317+ ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &macLen, sizeof(uint32_t)) == CRYPT_SUCCESS);
318+ 
319+ copyCtx1 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
320+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
321+ ASSERT_TRUE(copyCtx1 != NULL);
322+ copyCtx2 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
323+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
324+ ASSERT_TRUE(copyCtx2 != NULL);
325+ 
326+ // Test that the copied context functions correctly and is independent of the original context.
327+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
328+ 
329+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx1, data->x, data->len), CRYPT_SUCCESS);
330+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx1, mac, &macLen), CRYPT_SUCCESS);
331+ ASSERT_COMPARE("mac1 cmp", mac, macLen, vecMac->x, vecMac->len);
332+ CRYPT_EAL_MacFreeCtx(copyCtx1);
333+ copyCtx1 = NULL;
334+ 
335+ macLen = vecMac->len;
336+ ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
337+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
338+ ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
339+ ASSERT_COMPARE("mac2 cmp", mac, macLen, vecMac->x, vecMac->len);
340+ CRYPT_EAL_MacFreeCtx(ctx);
341+ ctx = NULL;
342+ 
343+ macLen = vecMac->len;
344+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx2, mac, &macLen), CRYPT_SUCCESS);
345+ ASSERT_COMPARE("mac3 cmp", mac, macLen, vecMac->x, vecMac->len);
346+ 
347+EXIT:
348+ CRYPT_EAL_MacFreeCtx(copyCtx2);
349+ CRYPT_EAL_MacFreeCtx(copyCtx1);
350+ CRYPT_EAL_MacFreeCtx(ctx);
351+}
352+/* END_CASE */
353+ 
354+static int32_t TestMacCopyCtxMemCheck(int32_t algId, Hex *key, Hex *iv, Hex *vecMac, int isProvider)
355+{
356+ CRYPT_EAL_MacCtx *ctxA = NULL;
357+ CRYPT_EAL_MacCtx *ctxB = NULL;
358+ CRYPT_EAL_MacCtx *srcCtx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
359+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
360+ /* Set key in srcCtx */
361+ int32_t ret = CRYPT_EAL_MacInit(srcCtx, key->x, key->len);
362+ if (ret != CRYPT_SUCCESS) {
363+ goto EXIT;
364+ }
365+ uint32_t macLen = vecMac->len;
366+ ASSERT_TRUE(CRYPT_EAL_MacCtrl(srcCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_SUCCESS);
367+ ASSERT_TRUE(CRYPT_EAL_MacCtrl(srcCtx, CRYPT_CTRL_SET_TAGLEN, &macLen, sizeof(uint32_t)) == CRYPT_SUCCESS);
368+ 
369+ ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
370+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
371+ ret = CRYPT_EAL_MacCopyCtx(ctxA, srcCtx);
372+ if (ret != CRYPT_SUCCESS) {
373+ goto EXIT;
374+ }
375+ ctxB = CRYPT_EAL_MacDupCtx(srcCtx);
376+ if (ctxB == NULL) {
377+ ret = CRYPT_MEM_ALLOC_FAIL;
378+ goto EXIT;
379+ }
380+ 
381+EXIT:
382+ CRYPT_EAL_MacFreeCtx(ctxA);
383+ CRYPT_EAL_MacFreeCtx(ctxB);
384+ CRYPT_EAL_MacFreeCtx(srcCtx);
385+ return ret;
386+}
387+ 
388+/**
389+ * @test SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001
390+ * title 1. Test the mac copy context with stub malloc fail
391+ *
392+ */
393+/* BEGIN_CASE */
394+void SDV_CRYPTO_GMAC_COPY_CTX_STUB_TC001(int algId, Hex *key, Hex *iv, Hex *vecMac, int isProvider)
395+{
396+ TestMemInit();
397+ uint32_t totalMallocCount = 0;
398+ STUB_Init();
399+ FuncStubInfo tmpRpInfo = {0};
400+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
401+ 
402+ STUB_EnableMallocFail(false);
403+ STUB_ResetMallocCount();
404+ ASSERT_EQ(TestMacCopyCtxMemCheck((int32_t)algId, key, iv, vecMac, isProvider), CRYPT_SUCCESS);
405+ totalMallocCount = STUB_GetMallocCallCount();
406+ 
407+ STUB_EnableMallocFail(true);
408+ for (uint32_t j = 0; j < totalMallocCount; j++) {
409+ STUB_ResetMallocCount();
410+ STUB_SetMallocFailIndex(j);
411+ ASSERT_NE(TestMacCopyCtxMemCheck((int32_t)algId, key, iv, vecMac, isProvider), CRYPT_SUCCESS);
412+ }
413+ 
414+EXIT:
415+ STUB_Reset(&tmpRpInfo);
416+}
417+/* END_CASE */
Mtestcode/sdv/testcase/crypto/gmac/test_suite_sdv_eal_gmac.data+24-0
@@ -51,3 +51,27 @@ SDV_CRYPT_EAL_GMAC_SAMEADDR_FUNC_TC001:CRYPT_MAC_GMAC_AES256:"d437aceaf416d9f4a3
51 51 
52address misalignment test: CRYPT_MAC_GMAC_AES25652address misalignment test: CRYPT_MAC_GMAC_AES256
53SDV_CRYPT_EAL_GMAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_GMAC_AES256:"d437aceaf416d9f4a357850e3e9c6519d1c10fd46bf869100b1781277668ec0e":"cf92aa3963016d33cc7b04a4e5cf1c7fe2394d64d9cd93e781c51adf78f3c1d49f2a971597aaabab9000fadf82b57fa4c9ad46c213672d744edfe36bb19b83f1a0e2b58fe0dd1deef776bf3a74446436ed1d8ff027a3f2e5acc1c6f6946e0563ec741ae20ddf8507bc1ced071e12268d2350d768cd4dea6b0404c2686066a1f8":"cf768eee6d26c9400cb6ca1136a6167a74883fcd":"3b11637f48eff130d1ac076be0"53SDV_CRYPT_EAL_GMAC_ADDR_NOT_ALIGN_FUNC_TC001:CRYPT_MAC_GMAC_AES256:"d437aceaf416d9f4a357850e3e9c6519d1c10fd46bf869100b1781277668ec0e":"cf92aa3963016d33cc7b04a4e5cf1c7fe2394d64d9cd93e781c51adf78f3c1d49f2a971597aaabab9000fadf82b57fa4c9ad46c213672d744edfe36bb19b83f1a0e2b58fe0dd1deef776bf3a74446436ed1d8ff027a3f2e5acc1c6f6946e0563ec741ae20ddf8507bc1ced071e12268d2350d768cd4dea6b0404c2686066a1f8":"cf768eee6d26c9400cb6ca1136a6167a74883fcd":"3b11637f48eff130d1ac076be0"
54+ 
55+SDV_CRYPTO_GMAC_COPY_CTX_API_TC001 CRYPT_MAC_GMAC_AES128
56+SDV_CRYPTO_GMAC_COPY_CTX_API_TC001:CRYPT_MAC_GMAC_AES128:0
57+ 
58+SDV_CRYPTO_GMAC_COPY_CTX_API_TC001 CRYPT_MAC_GMAC_AES192 Provider
59+SDV_CRYPTO_GMAC_COPY_CTX_API_TC001:CRYPT_MAC_GMAC_AES192:1
60+ 
61+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001 CRYPT_MAC_GMAC_AES128
62+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001:CRYPT_MAC_GMAC_AES128:"77be63708971c4e240d1cb79e8d77feb":"e0e00f19fed7ba0136a797f3":"7a43ec1d9c0a5a78a0b16533a6213cab":"209fcc8d3675ed938e9c7166709dd946":0
63+ 
64+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001 CRYPT_MAC_GMAC_AES192
65+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001:CRYPT_MAC_GMAC_AES192:"31389612d244c9792a510eca3f9c94f9f48c97ed67ae965a":"df6b54ec8b58114df5b09279":"0863bec42ee93385efbec665adfc46dafcd793f29e859e3b531c15b168f1888dd13e905cd7d5bc03f9f1f6495717df62":"77e5682a49243d5b9016eb1adafa2d":0
66+ 
67+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001 CRYPT_MAC_GMAC_AES256
68+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001:CRYPT_MAC_GMAC_AES256:"6c78c9585e007ef9841262fa8b042779b05673723ddc5d469d32555104120f67":"a75e955f306f5dd8b9ec39e9":"8cac27e4cc8f7f9dd8d65f845bf8ffd94928cfaa4a80166e5fffbb3835f8892017fc82a3486f7417defed78d6019be6d7cad01e34791c33f453603c5cc2127d79a5cfceb36f1e9a424e9adcc4f6d770fdef3e8694b8a3747bfeb":"61bd5ec2ab58024a145daa2eee":0
69+ 
70+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001 CRYPT_MAC_GMAC_AES192 Provider
71+SDV_CRYPT_EAL_GMAC_COPY_CTX_TC001:CRYPT_MAC_GMAC_AES192:"31389612d244c9792a510eca3f9c94f9f48c97ed67ae965a":"df6b54ec8b58114df5b09279":"0863bec42ee93385efbec665adfc46dafcd793f29e859e3b531c15b168f1888dd13e905cd7d5bc03f9f1f6495717df62":"77e5682a49243d5b9016eb1adafa2d":1
72+ 
73+SDV_CRYPTO_GMAC_COPY_CTX_STUB_TC001 CRYPT_MAC_GMAC_AES192
74+SDV_CRYPTO_GMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_GMAC_AES192:"31389612d244c9792a510eca3f9c94f9f48c97ed67ae965a":"df6b54ec8b58114df5b09279":"77e5682a49243d5b9016eb1adafa2d":0
75+ 
76+SDV_CRYPTO_GMAC_COPY_CTX_STUB_TC001 CRYPT_MAC_GMAC_AES256 Provider
77+SDV_CRYPTO_GMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_GMAC_AES256:"6c78c9585e007ef9841262fa8b042779b05673723ddc5d469d32555104120f67":"a75e955f306f5dd8b9ec39e9":"61bd5ec2ab58024a145daa2eee":1
Mtestcode/sdv/testcase/crypto/hkdf/test_suite_sdv_eal_kdf_hkdf.c+299-1
@@ -17,15 +17,16 @@
17 17 
18#include "securec.h"18#include "securec.h"
19#include "crypt_eal_kdf.h"19#include "crypt_eal_kdf.h"
20+#include "eal_kdf_local.h"
20#include "crypt_errno.h"21#include "crypt_errno.h"
21#include "bsl_sal.h"22#include "bsl_sal.h"
22#include "bsl_params.h"23#include "bsl_params.h"
23#include "crypt_params_key.h"24#include "crypt_params_key.h"
25+#include "stub_replace.h"
24/* END_HEADER */26/* END_HEADER */
25 27 
26#define DATA_LEN (64)28#define DATA_LEN (64)
27 29 
28- 
29static uint32_t GetMaxKeyLen(int algId)30static uint32_t GetMaxKeyLen(int algId)
30{31{
31 switch (algId) {32 switch (algId) {
@@ -213,3 +214,300 @@ EXIT:
213 CRYPT_EAL_KdfFreeCtx(ctx);214 CRYPT_EAL_KdfFreeCtx(ctx);
214}215}
215/* END_CASE */216/* END_CASE */
217+ 
218+/* BEGIN_CASE */
219+void SDV_CRYPTO_HKDF_COPY_CTX_API_TC001(int isProvider)
220+{
221+ TestMemInit();
222+ CRYPT_EAL_KdfCTX *ctxA = NULL;
223+ CRYPT_EAL_KdfCTX *ctxB = NULL;
224+ CRYPT_EAL_KdfCTX ctxC = { 0 };
225+ if (isProvider != 0) {
226+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
227+ ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
228+ } else {
229+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
230+ ctxB = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
231+ }
232+ ASSERT_TRUE(ctxA != NULL);
233+ ASSERT_TRUE(ctxB != NULL);
234+ 
235+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
236+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
237+ // Copy failed because ctxC lacks a method.
238+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
239+ 
240+ // A directly created context can also be used as the destination for copying.
241+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
242+ ctxC.method->freeCtx(ctxC.data);
243+ BSL_SAL_Free(ctxC.method);
244+EXIT:
245+ CRYPT_EAL_KdfFreeCtx(ctxA);
246+ CRYPT_EAL_KdfFreeCtx(ctxB);
247+}
248+/* END_CASE */
249+ 
250+/* BEGIN_CASE */
251+void SDV_CRYPTO_HKDF_DUP_CTX_API_TC001(int isProvider)
252+{
253+ TestMemInit();
254+ CRYPT_EAL_KdfCTX *ctxA = NULL;
255+ CRYPT_EAL_KdfCTX *ctxB = NULL;
256+ CRYPT_EAL_KdfCTX ctxC = { 0 };
257+ if (isProvider != 0) {
258+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
259+ } else {
260+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
261+ }
262+ ASSERT_TRUE(ctxA != NULL);
263+ 
264+ ctxB = CRYPT_EAL_KdfDupCtx(NULL);
265+ ASSERT_TRUE(ctxB == NULL);
266+ ctxB = CRYPT_EAL_KdfDupCtx(&ctxC);
267+ ASSERT_TRUE(ctxB == NULL);
268+ ctxB = CRYPT_EAL_KdfDupCtx(ctxA);
269+ ASSERT_TRUE(ctxB != NULL);
270+ 
271+EXIT:
272+ CRYPT_EAL_KdfFreeCtx(ctxA);
273+ CRYPT_EAL_KdfFreeCtx(ctxB);
274+}
275+/* END_CASE */
276+ 
277+/* BEGIN_CASE */
278+void SDV_CRYPTO_HKDF_COPY_CTX_API_TC002(int algId, Hex *key, Hex *salt, Hex *info, int isProvider)
279+{
280+ TestMemInit();
281+ uint32_t tmpLenA = DATA_LEN;
282+ uint8_t tmpBufA[DATA_LEN] = {0};
283+ uint32_t tmpLenB = DATA_LEN;
284+ uint8_t tmpBufB[DATA_LEN] = {0};
285+ uint32_t tmpLenC = DATA_LEN;
286+ uint8_t tmpBufC[DATA_LEN] = {0};
287+ 
288+ CRYPT_EAL_KdfCTX *ctxA = NULL;
289+ CRYPT_EAL_KdfCTX *ctxB = NULL;
290+ CRYPT_EAL_KdfCTX *ctxC = NULL;
291+ if (isProvider != 0) {
292+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
293+ ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
294+ } else {
295+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
296+ ctxB = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
297+ }
298+ ASSERT_TRUE(ctxA != NULL);
299+ ASSERT_TRUE(ctxB != NULL);
300+ 
301+ CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_EXTRACT;
302+ BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
303+ int32_t id = (int32_t)algId;
304+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
305+ &id, sizeof(id)), CRYPT_SUCCESS);
306+ ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
307+ &mode, sizeof(mode)), CRYPT_SUCCESS);
308+ ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
309+ key->x, key->len), CRYPT_SUCCESS);
310+ ASSERT_EQ(BSL_PARAM_InitValue(&params[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
311+ salt->x, salt->len), CRYPT_SUCCESS);
312+ ASSERT_EQ(BSL_PARAM_InitValue(&params[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
313+ info->x, info->len), CRYPT_SUCCESS);
314+ ASSERT_EQ(BSL_PARAM_InitValue(&params[5], CRYPT_PARAM_KDF_EXLEN, BSL_PARAM_TYPE_UINT32_PTR,
315+ &tmpLenA, sizeof(tmpLenA)), CRYPT_SUCCESS);
316+ 
317+ // Set parameters in ctxA, then copy to ctxB
318+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctxA, params), CRYPT_SUCCESS);
319+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(ctxB, ctxA), CRYPT_SUCCESS);
320+ ctxC = CRYPT_EAL_KdfDupCtx(ctxA);
321+ ASSERT_TRUE(ctxC != NULL);
322+ 
323+ // Key derivation fails in ctxB due to unset tmpBuf length
324+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctxA, tmpBufA, 0), CRYPT_SUCCESS);
325+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctxB, tmpBufB, 0), CRYPT_NULL_INPUT);
326+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctxC, tmpBufC, 0), CRYPT_NULL_INPUT);
327+ 
328+ // After setting ctxB's length, redo key derivation and compare results (should match)
329+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_EXLEN, BSL_PARAM_TYPE_UINT32_PTR,
330+ &tmpLenB, sizeof(tmpLenB)), CRYPT_SUCCESS);
331+ (void)memset_s(&params[1], sizeof(BSL_Param), 0, sizeof(BSL_Param));
332+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctxB, params), CRYPT_SUCCESS);
333+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctxB, tmpBufB, 0), CRYPT_SUCCESS);
334+ ASSERT_COMPARE("result cmp", tmpBufA, tmpLenA, tmpBufB, tmpLenB);
335+ 
336+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_EXLEN, BSL_PARAM_TYPE_UINT32_PTR,
337+ &tmpLenC, sizeof(tmpLenC)), CRYPT_SUCCESS);
338+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctxC, params), CRYPT_SUCCESS);
339+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctxC, tmpBufC, 0), CRYPT_SUCCESS);
340+ ASSERT_COMPARE("result cmp", tmpBufA, tmpLenA, tmpBufC, tmpLenC);
341+ 
342+EXIT:
343+ CRYPT_EAL_KdfFreeCtx(ctxA);
344+ CRYPT_EAL_KdfFreeCtx(ctxB);
345+ CRYPT_EAL_KdfFreeCtx(ctxC);
346+}
347+/* END_CASE */
348+ 
349+/* BEGIN_CASE */
350+void SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001(int algId, Hex *key, Hex *salt, Hex *info, Hex *result, int isProvider)
351+{
352+ if (IsHmacAlgDisabled(algId)) {
353+ SKIP_TEST();
354+ }
355+ TestMemInit();
356+ uint32_t outLen = result->len;
357+ uint8_t *out = BSL_SAL_Malloc(outLen * sizeof(uint8_t));
358+ ASSERT_TRUE(out != NULL);
359+ 
360+ CRYPT_EAL_KdfCTX *ctx = NULL;
361+ CRYPT_EAL_KdfCTX *copyCtx = NULL;
362+ CRYPT_EAL_KdfCTX *copyCtx1 = NULL;
363+ CRYPT_EAL_KdfCTX *copyCtx2 = NULL;
364+ CRYPT_EAL_KdfCTX *copyCtx3 = NULL;
365+ if (isProvider != 0) {
366+ ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
367+ copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
368+ copyCtx1 = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
369+ copyCtx2 = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
370+ } else {
371+ ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
372+ copyCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
373+ copyCtx1 = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
374+ copyCtx2 = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
375+ }
376+ ASSERT_TRUE(ctx != NULL);
377+ ASSERT_TRUE(copyCtx != NULL);
378+ ASSERT_TRUE(copyCtx1 != NULL);
379+ ASSERT_TRUE(copyCtx2 != NULL);
380+ 
381+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx, ctx), CRYPT_SUCCESS);
382+ CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
383+ BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
384+ int32_t id = (int32_t)algId;
385+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
386+ &id, sizeof(id)), CRYPT_SUCCESS);
387+ ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
388+ &mode, sizeof(mode)), CRYPT_SUCCESS);
389+ ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
390+ key->x, key->len), CRYPT_SUCCESS);
391+ ASSERT_EQ(BSL_PARAM_InitValue(&params[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
392+ salt->x, salt->len), CRYPT_SUCCESS);
393+ ASSERT_EQ(BSL_PARAM_InitValue(&params[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
394+ info->x, info->len), CRYPT_SUCCESS);
395+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
396+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(copyCtx, params), CRYPT_SUCCESS);
397+ 
398+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
399+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
400+ 
401+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx, out, outLen), CRYPT_SUCCESS);
402+ ASSERT_COMPARE("result1 cmp", out, outLen, result->x, result->len);
403+ (void)memset_s(out, outLen, 0, outLen);
404+ CRYPT_EAL_KdfFreeCtx(copyCtx);
405+ copyCtx = NULL;
406+ 
407+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx1, out, outLen), CRYPT_SUCCESS);
408+ ASSERT_COMPARE("result2 cmp", out, outLen, result->x, result->len);
409+ (void)memset_s(out, outLen, 0, outLen);
410+ CRYPT_EAL_KdfFreeCtx(copyCtx1);
411+ copyCtx1 = NULL;
412+ 
413+ copyCtx3 = CRYPT_EAL_KdfDupCtx(ctx);
414+ ASSERT_TRUE(copyCtx3 != NULL);
415+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx3, out, outLen), CRYPT_SUCCESS);
416+ ASSERT_COMPARE("result3 cmp", out, outLen, result->x, result->len);
417+ (void)memset_s(out, outLen, 0, outLen);
418+ CRYPT_EAL_KdfFreeCtx(copyCtx3);
419+ copyCtx3 = NULL;
420+ 
421+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
422+ ASSERT_COMPARE("result4 cmp", out, outLen, result->x, result->len);
423+ (void)memset_s(out, outLen, 0, outLen);
424+ CRYPT_EAL_KdfFreeCtx(ctx);
425+ ctx = NULL;
426+ 
427+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx2, out, outLen), CRYPT_SUCCESS);
428+ ASSERT_COMPARE("result5 cmp", out, outLen, result->x, result->len);
429+EXIT:
430+ BSL_SAL_Free(out);
431+ CRYPT_EAL_KdfFreeCtx(ctx);
432+ CRYPT_EAL_KdfFreeCtx(copyCtx);
433+ CRYPT_EAL_KdfFreeCtx(copyCtx1);
434+ CRYPT_EAL_KdfFreeCtx(copyCtx2);
435+}
436+/* END_CASE */
437+ 
438+static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex *key, Hex *salt, Hex *info, int isProvider)
439+{
440+ CRYPT_EAL_KdfCTX *ctxA = NULL;
441+ CRYPT_EAL_KdfCTX *ctxB = NULL;
442+ CRYPT_EAL_KdfCTX *srcCtx = NULL;
443+ if (isProvider != 0) {
444+ srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
445+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
446+ } else {
447+ srcCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
448+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
449+ }
450+ CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
451+ BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
452+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
453+ &algId, sizeof(algId)), CRYPT_SUCCESS);
454+ ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
455+ &mode, sizeof(mode)), CRYPT_SUCCESS);
456+ ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
457+ key->x, key->len), CRYPT_SUCCESS);
458+ ASSERT_EQ(BSL_PARAM_InitValue(&params[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
459+ salt->x, salt->len), CRYPT_SUCCESS);
460+ ASSERT_EQ(BSL_PARAM_InitValue(&params[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
461+ info->x, info->len), CRYPT_SUCCESS);
462+ int32_t ret = CRYPT_EAL_KdfSetParam(srcCtx, params);
463+ if (ret != CRYPT_SUCCESS) {
464+ goto EXIT;
465+ }
466+ 
467+ ret = CRYPT_EAL_KdfCopyCtx(ctxA, srcCtx);
468+ if (ret != CRYPT_SUCCESS) {
469+ goto EXIT;
470+ }
471+ ctxB = CRYPT_EAL_KdfDupCtx(srcCtx);
472+ if (ctxB == NULL) {
473+ ret = CRYPT_MEM_ALLOC_FAIL;
474+ goto EXIT;
475+ }
476+EXIT:
477+ CRYPT_EAL_KdfFreeCtx(ctxA);
478+ CRYPT_EAL_KdfFreeCtx(ctxB);
479+ CRYPT_EAL_KdfFreeCtx(srcCtx);
480+ return ret;
481+}
482+ 
483+/**
484+ * @test SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001
485+ * title 1. Test the kdf copy context with stub malloc fail
486+ *
487+ */
488+/* BEGIN_CASE */
489+void SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001(int algId, Hex *key, Hex *salt, Hex *info, int isProvider)
490+{
491+ TestMemInit();
492+ uint32_t totalMallocCount = 0;
493+ STUB_Init();
494+ FuncStubInfo tmpRpInfo = {0};
495+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
496+ 
497+ STUB_EnableMallocFail(false);
498+ STUB_ResetMallocCount();
499+ ASSERT_EQ(TestKdfCopyCtxMemCheck((int32_t)algId, key, salt, info, isProvider), CRYPT_SUCCESS);
500+ totalMallocCount = STUB_GetMallocCallCount();
501+ 
502+ STUB_EnableMallocFail(true);
503+ for (uint32_t j = 0; j < totalMallocCount; j++)
504+ {
505+ STUB_ResetMallocCount();
506+ STUB_SetMallocFailIndex(j);
507+ ASSERT_NE(TestKdfCopyCtxMemCheck((int32_t)algId, key, salt, info, isProvider), CRYPT_SUCCESS);
508+ }
509+ 
510+EXIT:
511+ STUB_Reset(&tmpRpInfo);
512+}
513+/* END_CASE */
Mtestcode/sdv/testcase/crypto/hkdf/test_suite_sdv_eal_kdf_hkdf.data+42-0
@@ -39,3 +39,45 @@ SDV_CRYPT_EAL_KDF_HKDF_FUN_TC001:CRYPT_MAC_HMAC_MD5:"000000000000000000000000000
39 39 
40SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001 default provider40SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001 default provider
41SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SHA1:"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c":"":"":"2c91117204d745f3500d636a62f64f0ab3bae548aa53d423b0d1f27ebba6f5e5673a081d70cce7acfc48"41SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SHA1:"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c":"":"":"2c91117204d745f3500d636a62f64f0ab3bae548aa53d423b0d1f27ebba6f5e5673a081d70cce7acfc48"
42+ 
43+SDV_CRYPTO_HKDF_COPY_CTX_API_TC001
44+SDV_CRYPTO_HKDF_COPY_CTX_API_TC001:0
45+ 
46+SDV_CRYPTO_HKDF_COPY_CTX_API_TC001 Provider
47+SDV_CRYPTO_HKDF_COPY_CTX_API_TC001:1
48+ 
49+SDV_CRYPTO_HKDF_DUP_CTX_API_TC001
50+SDV_CRYPTO_HKDF_DUP_CTX_API_TC001:0
51+ 
52+SDV_CRYPTO_HKDF_DUP_CTX_API_TC001 Provider
53+SDV_CRYPTO_HKDF_DUP_CTX_API_TC001:1
54+ 
55+SDV_CRYPTO_HKDF_COPY_CTX_API_TC002 CRYPT_MAC_HMAC_SHA1 Provider
56+SDV_CRYPTO_HKDF_COPY_CTX_API_TC002:CRYPT_MAC_HMAC_SHA1:"0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":1
57+ 
58+SDV_CRYPTO_HKDF_COPY_CTX_API_TC002 CRYPT_MAC_HMAC_SHA256
59+SDV_CRYPTO_HKDF_COPY_CTX_API_TC002:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":0
60+ 
61+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_MD5
62+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_MD5:"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000":"dd30769c87c8094d9b44e3c1aa0020c0f6966a72b8fd4340fb5c29d2eddf2b7ebc56e91ef18fc193f39f6c73fae03c283e1def62d5ceeb45f1c08c7e51ecce73":"cb6c6721b590d0f2790236b76fb238b55807b75a12578610792d33162d20dbd5dbc69439e330c80251b5d625b8698f16c241116a1f18b7691232e52b664ddcea":"9274b590e6cd99a07a9c6fdfe2aff0b2f1f3947c40c4384e2afd1b2b71dcb1c2267342fc5f34be683dab27d62a1424b4c44587ada53b1ebce237991ef4c432c0":0
63+ 
64+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA1
65+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA1:"0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":"085a01ea1b10f36933068b56efa5ad81a4f14b822f5b091568a9cdd4f155fda2c22e422478d305f3f896":0
66+ 
67+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA256
68+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":"3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865":0
69+ 
70+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA1 Provider
71+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA1:"0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":"085a01ea1b10f36933068b56efa5ad81a4f14b822f5b091568a9cdd4f155fda2c22e422478d305f3f896":1
72+ 
73+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA256 Provider
74+SDV_CRYPT_EAL_HKDF_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":"3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865":1
75+ 
76+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001 CRYPT_MAC_HMAC_MD5
77+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_MD5:"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000":"dd30769c87c8094d9b44e3c1aa0020c0f6966a72b8fd4340fb5c29d2eddf2b7ebc56e91ef18fc193f39f6c73fae03c283e1def62d5ceeb45f1c08c7e51ecce73":"cb6c6721b590d0f2790236b76fb238b55807b75a12578610792d33162d20dbd5dbc69439e330c80251b5d625b8698f16c241116a1f18b7691232e52b664ddcea":0
78+ 
79+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001 CRYPT_MAC_HMAC_SHA1
80+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA1:"0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":0
81+ 
82+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001 CRYPT_MAC_HMAC_SHA256 Provider
83+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"000102030405060708090a0b0c":"f0f1f2f3f4f5f6f7f8f9":1
Mtestcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.base.c+2-0
@@ -16,6 +16,7 @@
16#include <pthread.h>16#include <pthread.h>
17#include "securec.h"17#include "securec.h"
18#include "crypt_eal_mac.h"18#include "crypt_eal_mac.h"
19+#include "eal_mac_local.h"
19#include "crypt_errno.h"20#include "crypt_errno.h"
20#include "bsl_sal.h"21#include "bsl_sal.h"
21#include "crypt_sha1.h"22#include "crypt_sha1.h"
@@ -23,6 +24,7 @@
23#include "crypt_sha3.h"24#include "crypt_sha3.h"
24#include "crypt_sm3.h"25#include "crypt_sm3.h"
25#include "crypt_md5.h"26#include "crypt_md5.h"
27+#include "stub_replace.h"
26 28 
27#define TEST_FAIL (-1)29#define TEST_FAIL (-1)
28#define TEST_SUCCESS (0)30#define TEST_SUCCESS (0)
Mtestcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.c+174-0
@@ -460,3 +460,177 @@ EXIT:
460 BSL_SAL_FREE(mac);460 BSL_SAL_FREE(mac);
461}461}
462/* END_CASE */462/* END_CASE */
463+ 
464+/* BEGIN_CASE */
465+void SDV_CRYPTO_HMAC_COPY_CTX_API_TC001(int algId, int isProvider)
466+{
467+ TestMemInit();
468+ CRYPT_EAL_MacCtx *ctxB = NULL;
469+ CRYPT_EAL_MacCtx ctxC = { 0 };
470+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
471+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
472+ ASSERT_TRUE(ctxA != NULL);
473+ 
474+ ctxB = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
475+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
476+ ASSERT_TRUE(ctxB != NULL);
477+ 
478+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
479+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
480+ // Copy failed because ctxC lacks a method.
481+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
482+ 
483+ // A directly created context can also be used as the destination for copying.
484+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
485+ ctxC.macMeth->freeCtx(ctxC.ctx);
486+ BSL_SAL_Free(ctxC.macMeth);
487+EXIT:
488+ CRYPT_EAL_MacFreeCtx(ctxA);
489+ CRYPT_EAL_MacFreeCtx(ctxB);
490+}
491+/* END_CASE */
492+ 
493+/* BEGIN_CASE */
494+void SDV_CRYPTO_HMAC_DUP_CTX_API_TC001(int algId, int isProvider)
495+{
496+ TestMemInit();
497+ CRYPT_EAL_MacCtx *ctxB = NULL;
498+ CRYPT_EAL_MacCtx ctxC = { 0 };
499+ CRYPT_EAL_MacCtx *ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
500+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
501+ ASSERT_TRUE(ctxA != NULL);
502+ 
503+ ctxB = CRYPT_EAL_MacDupCtx(NULL);
504+ ASSERT_TRUE(ctxB == NULL);
505+ ctxB = CRYPT_EAL_MacDupCtx(&ctxC);
506+ ASSERT_TRUE(ctxB == NULL);
507+ ctxB = CRYPT_EAL_MacDupCtx(ctxA);
508+ ASSERT_TRUE(ctxB != NULL);
509+ 
510+EXIT:
511+ CRYPT_EAL_MacFreeCtx(ctxA);
512+ CRYPT_EAL_MacFreeCtx(ctxB);
513+}
514+/* END_CASE */
515+ 
516+/* BEGIN_CASE */
517+void SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001(int algId, Hex *key, Hex *data, Hex *vecMac, int isProvider)
518+{
519+ if (IsHmacAlgDisabled(algId)) {
520+ SKIP_TEST();
521+ }
522+ TestMemInit();
523+ uint32_t macLen = GetMacLen(algId);
524+ uint8_t mac[64];
525+ 
526+ CRYPT_EAL_MacCtx *copyCtx1 = NULL;
527+ CRYPT_EAL_MacCtx *copyCtx2 = NULL;
528+ CRYPT_EAL_MacCtx *copyCtx3 = NULL;
529+ CRYPT_EAL_MacCtx *ctx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
530+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
531+ ASSERT_TRUE(ctx != NULL);
532+ ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
533+ 
534+ copyCtx1 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
535+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
536+ ASSERT_TRUE(copyCtx1 != NULL);
537+ copyCtx2 = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
538+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
539+ ASSERT_TRUE(copyCtx2 != NULL);
540+ 
541+ // Test that the copied context functions correctly and is independent of the original context.
542+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
543+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx1, data->x, data->len), CRYPT_SUCCESS);
544+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx1, mac, &macLen), CRYPT_SUCCESS);
545+ ASSERT_COMPARE("mac1 cmp", mac, macLen, vecMac->x, vecMac->len);
546+ CRYPT_EAL_MacFreeCtx(copyCtx1);
547+ copyCtx1 = NULL;
548+ 
549+ // Create a new copyCtx3 from ctx, use copyCtx3 for encryption, and verify functional correctness.
550+ copyCtx3 = CRYPT_EAL_MacDupCtx(ctx);
551+ ASSERT_EQ(CRYPT_EAL_MacUpdate(copyCtx3, data->x, data->len), CRYPT_SUCCESS);
552+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx3, mac, &macLen), CRYPT_SUCCESS);
553+ ASSERT_COMPARE("mac2 cmp", mac, macLen, vecMac->x, vecMac->len);
554+ CRYPT_EAL_MacFreeCtx(copyCtx3);
555+ copyCtx3 = NULL;
556+ 
557+ macLen = GetMacLen(algId);
558+ ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
559+ ASSERT_EQ(CRYPT_EAL_MacCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
560+ ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
561+ ASSERT_COMPARE("mac3 cmp", mac, macLen, vecMac->x, vecMac->len);
562+ CRYPT_EAL_MacFreeCtx(ctx);
563+ ctx = NULL;
564+ 
565+ macLen = vecMac->len;
566+ ASSERT_EQ(CRYPT_EAL_MacFinal(copyCtx2, mac, &macLen), CRYPT_SUCCESS);
567+ ASSERT_COMPARE("mac4 cmp", mac, macLen, vecMac->x, vecMac->len);
568+ 
569+EXIT:
570+ CRYPT_EAL_MacFreeCtx(copyCtx2);
571+ CRYPT_EAL_MacFreeCtx(copyCtx1);
572+ CRYPT_EAL_MacFreeCtx(ctx);
573+}
574+/* END_CASE */
575+ 
576+static int32_t TestMacCopyCtxMemCheck(int32_t algId, Hex *key, int isProvider)
577+{
578+ CRYPT_EAL_MacCtx *ctxA = NULL;
579+ CRYPT_EAL_MacCtx *ctxB = NULL;
580+ CRYPT_EAL_MacCtx *srcCtx = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
581+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
582+ /* Set key in srcCtx */
583+ int32_t ret = CRYPT_EAL_MacInit(srcCtx, key->x, key->len);
584+ if (ret != CRYPT_SUCCESS) {
585+ goto EXIT;
586+ }
587+ 
588+ ctxA = (isProvider == 0) ? CRYPT_EAL_MacNewCtx(algId) :
589+ CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
590+ ret = CRYPT_EAL_MacCopyCtx(ctxA, srcCtx);
591+ if (ret != CRYPT_SUCCESS) {
592+ goto EXIT;
593+ }
594+ ctxB = CRYPT_EAL_MacDupCtx(srcCtx);
595+ if (ctxB == NULL) {
596+ ret = CRYPT_MEM_ALLOC_FAIL;
597+ goto EXIT;
598+ }
599+ 
600+EXIT:
601+ CRYPT_EAL_MacFreeCtx(ctxA);
602+ CRYPT_EAL_MacFreeCtx(ctxB);
603+ CRYPT_EAL_MacFreeCtx(srcCtx);
604+ return ret;
605+}
606+ 
607+/**
608+ * @test SDV_CRYPTO_CBC_MAC_COPY_CTX_STUB_TC001
609+ * title 1. Test the mac copy context with stub malloc fail
610+ *
611+ */
612+/* BEGIN_CASE */
613+void SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001(int algId, Hex *key, int isProvider)
614+{
615+ TestMemInit();
616+ uint32_t totalMallocCount = 0;
617+ STUB_Init();
618+ FuncStubInfo tmpRpInfo = {0};
619+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
620+ 
621+ STUB_EnableMallocFail(false);
622+ STUB_ResetMallocCount();
623+ ASSERT_EQ(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
624+ totalMallocCount = STUB_GetMallocCallCount();
625+ 
626+ STUB_EnableMallocFail(true);
627+ for (uint32_t j = 0; j < totalMallocCount; j++) {
628+ STUB_ResetMallocCount();
629+ STUB_SetMallocFailIndex(j);
630+ ASSERT_NE(TestMacCopyCtxMemCheck((int32_t)algId, key, isProvider), CRYPT_SUCCESS);
631+ }
632+ 
633+EXIT:
634+ STUB_Reset(&tmpRpInfo);
635+}
636+/* END_CASE */
Mtestcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.data+87-0
@@ -495,3 +495,90 @@ SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SM3:"aaaaaaaaaaaaaaaaa
495 495 
496SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001 CRYPT_MAC_HMAC_SM3 #5496SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001 CRYPT_MAC_HMAC_SM3 #5
497SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SM3:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"dad342089a24eaa650975de2701754ff513b504f829bac67964915f9efb7c3f1"497SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SM3:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"dad342089a24eaa650975de2701754ff513b504f829bac67964915f9efb7c3f1"
498+ 
499+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001 CRYPT_MAC_HMAC_SHA1
500+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SHA1:0
501+ 
502+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SHA256
503+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SHA256:0
504+ 
505+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SHA3_384
506+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SHA3_384:1
507+ 
508+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SM3
509+SDV_CRYPTO_HMAC_COPY_CTX_API_TC001:CRYPT_MAC_HMAC_SM3:1
510+ 
511+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001 CRYPT_MAC_HMAC_SHA1
512+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SHA1:0
513+ 
514+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SHA256
515+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SHA256:0
516+ 
517+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SHA3_384
518+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SHA3_384:1
519+ 
520+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SM3
521+SDV_CRYPTO_HMAC_DUP_CTX_API_TC001:CRYPT_MAC_HMAC_SM3:1
522+ 
523+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_MD5
524+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_MD5:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"9294727a3638bb1c13f48ef8158bfc9d":0
525+ 
526+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA1
527+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA1:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"b617318655057264e28bc0b6fb378c8ef146be00":0
528+ 
529+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA224
530+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA224:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22":0
531+ 
532+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA256
533+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7":0
534+ 
535+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA384
536+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA384:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6":0
537+ 
538+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA512
539+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA512:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854":0
540+ 
541+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SM3
542+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SM3:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"51b00d1fb49832bfb01c3ce27848e59f871d9ba938dc563b338ca964755cce70":0
543+ 
544+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA3_224
545+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA3_224:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"332cfd59347fdb8e576e77260be4aba2d6dc53117b3bfb52c6d18c04":0
546+ 
547+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA3_256
548+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA3_256:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"4fe8e202c4f058e8dddc23d8c34e467343e23555e24fc2f025d598f558f67205":0
549+ 
550+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA3_384
551+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA3_384:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"d588a3c51f3f2d906e8298c1199aa8ff6296218127f6b38a90b6afe2c5617725bc99987f79b22a557b6520db710b7f42":0
552+ 
553+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA3_512
554+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA3_512:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"4efd629d6c71bf86162658f29943b1c308ce27cdfa6db0d9c3ce81763f9cbce5f7ebe9868031db1a8f8eb7b6b95e5c5e3f657a8996c86a2f6527e307f0213196":0
555+ 
556+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_MD5 Provider
557+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_MD5:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"9294727a3638bb1c13f48ef8158bfc9d":1
558+ 
559+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA256 Provider
560+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7":1
561+ 
562+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SM3 Provider
563+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SM3:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":"4869205468657265":"51b00d1fb49832bfb01c3ce27848e59f871d9ba938dc563b338ca964755cce70":1
564+ 
565+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001 CRYPT_MAC_HMAC_SHA3_384 Provider
566+SDV_CRYPT_EAL_HMAC_COPY_CTX_TC001:CRYPT_MAC_HMAC_SHA3_384:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f":"53616d706c65206d65737361676520666f72206b65796c656e3c626c6f636b6c656e":"d588a3c51f3f2d906e8298c1199aa8ff6296218127f6b38a90b6afe2c5617725bc99987f79b22a557b6520db710b7f42":1
567+ 
568+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001
569+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_MD5:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":0
570+ 
571+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001
572+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":0
573+ 
574+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001
575+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SM3:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":0
576+ 
577+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001
578+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA3_384:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f":0
579+ 
580+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001 Provider
581+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA256:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":1
582+ 
583+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001 Provider
584+SDV_CRYPTO_HMAC_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SM3:"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b":1
Mtestcode/sdv/testcase/crypto/kdf_tls12/test_suite_sdv_eal_kdf_tls12.c+223-0
@@ -17,10 +17,12 @@
17 17 
18#include "securec.h"18#include "securec.h"
19#include "crypt_eal_kdf.h"19#include "crypt_eal_kdf.h"
20+#include "eal_kdf_local.h"
20#include "crypt_errno.h"21#include "crypt_errno.h"
21#include "bsl_sal.h"22#include "bsl_sal.h"
22#include "bsl_params.h"23#include "bsl_params.h"
23#include "crypt_params_key.h"24#include "crypt_params_key.h"
25+#include "stub_replace.h"
24/* END_HEADER */26/* END_HEADER */
25 27 
26#define DATA_LEN (64)28#define DATA_LEN (64)
@@ -183,3 +185,224 @@ EXIT:
183 CRYPT_EAL_KdfFreeCtx(ctx);185 CRYPT_EAL_KdfFreeCtx(ctx);
184}186}
185/* END_CASE */187/* END_CASE */
188+ 
189+/* BEGIN_CASE */
190+void SDV_CRYPTO_KDFTLS12_COPY_CTX_API_TC001(int isProvider)
191+{
192+ TestMemInit();
193+ CRYPT_EAL_KdfCTX *ctxA = NULL;
194+ CRYPT_EAL_KdfCTX *ctxB = NULL;
195+ CRYPT_EAL_KdfCTX ctxC = { 0 };
196+ if (isProvider != 0) {
197+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
198+ ctxB = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
199+ } else {
200+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
201+ ctxB = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
202+ }
203+ ASSERT_TRUE(ctxA != NULL);
204+ ASSERT_TRUE(ctxB != NULL);
205+ 
206+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(NULL, ctxA), CRYPT_NULL_INPUT);
207+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(ctxB, NULL), CRYPT_NULL_INPUT);
208+ // Copy failed because ctxC lacks a method.
209+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(ctxB, &ctxC), CRYPT_NULL_INPUT);
210+ 
211+ // A directly created context can also be used as the destination for copying.
212+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(&ctxC, ctxA), CRYPT_SUCCESS);
213+ ctxC.method->freeCtx(ctxC.data);
214+ BSL_SAL_Free(ctxC.method);
215+EXIT:
216+ CRYPT_EAL_KdfFreeCtx(ctxA);
217+ CRYPT_EAL_KdfFreeCtx(ctxB);
218+}
219+/* END_CASE */
220+ 
221+/* BEGIN_CASE */
222+void SDV_CRYPTO_KDF_TLS12_DUP_CTX_API_TC001(int isProvider)
223+{
224+ TestMemInit();
225+ CRYPT_EAL_KdfCTX *ctxA = NULL;
226+ CRYPT_EAL_KdfCTX *ctxB = NULL;
227+ CRYPT_EAL_KdfCTX ctxC = { 0 };
228+ if (isProvider != 0) {
229+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
230+ } else {
231+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
232+ }
233+ ASSERT_TRUE(ctxA != NULL);
234+ 
235+ ctxB = CRYPT_EAL_KdfDupCtx(NULL);
236+ ASSERT_TRUE(ctxB == NULL);
237+ ctxB = CRYPT_EAL_KdfDupCtx(&ctxC);
238+ ASSERT_TRUE(ctxB == NULL);
239+ ctxB = CRYPT_EAL_KdfDupCtx(ctxA);
240+ ASSERT_TRUE(ctxB != NULL);
241+EXIT:
242+ CRYPT_EAL_KdfFreeCtx(ctxA);
243+ CRYPT_EAL_KdfFreeCtx(ctxB);
244+}
245+/* END_CASE */
246+ 
247+/* BEGIN_CASE */
248+void SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001(int algId, Hex *key, Hex *label, Hex *seed, Hex *result,
249+ int isProvider)
250+{
251+ if (IsHmacAlgDisabled(algId)) {
252+ SKIP_TEST();
253+ }
254+ TestMemInit();
255+ uint32_t outLen = result->len;
256+ uint8_t *out = BSL_SAL_Malloc(outLen * sizeof(uint8_t));
257+ ASSERT_TRUE(out != NULL);
258+ 
259+ CRYPT_EAL_KdfCTX *ctx = NULL;
260+ CRYPT_EAL_KdfCTX *copyCtx = NULL;
261+ CRYPT_EAL_KdfCTX *copyCtx1 = NULL;
262+ CRYPT_EAL_KdfCTX *copyCtx2 = NULL;
263+ CRYPT_EAL_KdfCTX *copyCtx3 = NULL;
264+ if (isProvider != 0) {
265+ ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
266+ copyCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
267+ copyCtx1 = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
268+ copyCtx2 = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
269+ } else {
270+ ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
271+ copyCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
272+ copyCtx1 = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
273+ copyCtx2 = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
274+ }
275+ ASSERT_TRUE(ctx != NULL);
276+ ASSERT_TRUE(copyCtx != NULL);
277+ ASSERT_TRUE(copyCtx1 != NULL);
278+ ASSERT_TRUE(copyCtx2 != NULL);
279+ 
280+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx, ctx), CRYPT_SUCCESS);
281+ 
282+ BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
283+ int32_t id = (int32_t)algId;
284+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
285+ &id, sizeof(id)), CRYPT_SUCCESS);
286+ ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
287+ key->x, key->len), CRYPT_SUCCESS);
288+ ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
289+ label->x, label->len), CRYPT_SUCCESS);
290+ ASSERT_EQ(BSL_PARAM_InitValue(&params[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
291+ seed->x, seed->len), CRYPT_SUCCESS);
292+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
293+ ASSERT_EQ(CRYPT_EAL_KdfSetParam(copyCtx, params), CRYPT_SUCCESS);
294+ 
295+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx1, ctx), CRYPT_SUCCESS);
296+ ASSERT_EQ(CRYPT_EAL_KdfCopyCtx(copyCtx2, ctx), CRYPT_SUCCESS);
297+ 
298+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx, out, outLen), CRYPT_SUCCESS);
299+ ASSERT_COMPARE("result1 cmp", out, outLen, result->x, result->len);
300+ (void)memset_s(out, outLen, 0, outLen);
301+ CRYPT_EAL_KdfFreeCtx(copyCtx);
302+ copyCtx = NULL;
303+ 
304+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx1, out, outLen), CRYPT_SUCCESS);
305+ ASSERT_COMPARE("result2 cmp", out, outLen, result->x, result->len);
306+ (void)memset_s(out, outLen, 0, outLen);
307+ CRYPT_EAL_KdfFreeCtx(copyCtx1);
308+ copyCtx1 = NULL;
309+ 
310+ copyCtx3 = CRYPT_EAL_KdfDupCtx(ctx);
311+ ASSERT_TRUE(copyCtx3 != NULL);
312+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx3, out, outLen), CRYPT_SUCCESS);
313+ ASSERT_COMPARE("result3 cmp", out, outLen, result->x, result->len);
314+ (void)memset_s(out, outLen, 0, outLen);
315+ CRYPT_EAL_KdfFreeCtx(copyCtx3);
316+ copyCtx3 = NULL;
317+ 
318+ ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
319+ ASSERT_COMPARE("result4 cmp", out, outLen, result->x, result->len);
320+ (void)memset_s(out, outLen, 0, outLen);
321+ CRYPT_EAL_KdfFreeCtx(ctx);
322+ ctx = NULL;
323+ 
324+ ASSERT_EQ(CRYPT_EAL_KdfDerive(copyCtx2, out, outLen), CRYPT_SUCCESS);
325+ ASSERT_COMPARE("result5 cmp", out, outLen, result->x, result->len);
326+EXIT:
327+ BSL_SAL_Free(out);
328+ CRYPT_EAL_KdfFreeCtx(ctx);
329+ CRYPT_EAL_KdfFreeCtx(copyCtx);
330+ CRYPT_EAL_KdfFreeCtx(copyCtx1);
331+ CRYPT_EAL_KdfFreeCtx(copyCtx2);
332+ CRYPT_EAL_KdfFreeCtx(copyCtx3);
333+}
334+/* END_CASE */
335+ 
336+static int32_t TestKdfCopyCtxMemCheck(int32_t algId, Hex *key, Hex *label, Hex *seed, int isProvider)
337+{
338+ CRYPT_EAL_KdfCTX *ctxA = NULL;
339+ CRYPT_EAL_KdfCTX *ctxB = NULL;
340+ CRYPT_EAL_KdfCTX *srcCtx = NULL;
341+ if (isProvider != 0) {
342+ srcCtx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
343+ ctxA = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
344+ } else {
345+ srcCtx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
346+ ctxA = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
347+ }
348+ BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
349+ ASSERT_EQ(BSL_PARAM_InitValue(&params[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
350+ &algId, sizeof(algId)), CRYPT_SUCCESS);
351+ ASSERT_EQ(BSL_PARAM_InitValue(&params[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
352+ key->x, key->len), CRYPT_SUCCESS);
353+ ASSERT_EQ(BSL_PARAM_InitValue(&params[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
354+ label->x, label->len), CRYPT_SUCCESS);
355+ ASSERT_EQ(BSL_PARAM_InitValue(&params[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
356+ seed->x, seed->len), CRYPT_SUCCESS);
357+ int32_t ret = CRYPT_EAL_KdfSetParam(srcCtx, params);
358+ if (ret != CRYPT_SUCCESS) {
359+ goto EXIT;
360+ }
361+ 
362+ ret = CRYPT_EAL_KdfCopyCtx(ctxA, srcCtx);
363+ if (ret != CRYPT_SUCCESS) {
364+ goto EXIT;
365+ }
366+ ctxB = CRYPT_EAL_KdfDupCtx(srcCtx);
367+ if (ctxB == NULL) {
368+ ret = CRYPT_MEM_ALLOC_FAIL;
369+ goto EXIT;
370+ }
371+EXIT:
372+ CRYPT_EAL_KdfFreeCtx(ctxA);
373+ CRYPT_EAL_KdfFreeCtx(ctxB);
374+ CRYPT_EAL_KdfFreeCtx(srcCtx);
375+ return ret;
376+}
377+ 
378+/**
379+ * @test SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001
380+ * title 1. Test the kdf copy context with stub malloc fail
381+ *
382+ */
383+/* BEGIN_CASE */
384+void SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001(int algId, Hex *key, Hex *label, Hex *seed, int isProvider)
385+{
386+ TestMemInit();
387+ uint32_t totalMallocCount = 0;
388+ STUB_Init();
389+ FuncStubInfo tmpRpInfo = {0};
390+ ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, STUB_BSL_SAL_Malloc) == 0);
391+ 
392+ STUB_EnableMallocFail(false);
393+ STUB_ResetMallocCount();
394+ ASSERT_EQ(TestKdfCopyCtxMemCheck((int32_t)algId, key, label, seed, isProvider), CRYPT_SUCCESS);
395+ totalMallocCount = STUB_GetMallocCallCount();
396+ 
397+ STUB_EnableMallocFail(true);
398+ for (uint32_t j = 0; j < totalMallocCount; j++)
399+ {
400+ STUB_ResetMallocCount();
401+ STUB_SetMallocFailIndex(j);
402+ ASSERT_NE(TestKdfCopyCtxMemCheck((int32_t)algId, key, label, seed, isProvider), CRYPT_SUCCESS);
403+ }
404+ 
405+EXIT:
406+ STUB_Reset(&tmpRpInfo);
407+}
408+/* END_CASE */
Mtestcode/sdv/testcase/crypto/kdf_tls12/test_suite_sdv_eal_kdf_tls12.data+31-0
@@ -27,3 +27,34 @@ SDV_CRYPT_EAL_KDF_TLS12_FUN_TC001:CRYPT_MAC_HMAC_SHA512:"74348710df03212b648663b
27 27 
28SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001 default provider28SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001 default provider
29SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SHA256:"202c88c00f84a17a20027079604787461176455539e705be730890602c289a5001e34eeb3a043e5d52a65e66125188bf":"6b657920657870616e73696f6eae6c806f8ad4d80784549dff28a4b58fd837681a51d928c3e30ee5ff14f3986862e1fd91":"f23f558a605f28478c58cf72637b89784d959df7e946d3f07bd1b616":"d06139889fffac1e3a71865f504aa5d0d2a2e89506c6f2279b670c3e1b74f531016a2530c51a3a0f7e1d6590d0f0566b2f387f8d11fd4f731cdd572d2eae927f6f2f81410b25e6960be68985add6c38445ad9f8c64bf8068bf9a6679485d966f1ad6f68b43495b10a683755ea2b858d70ccac7ec8b053c6bd41ca299d4e51928"29SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001:CRYPT_MAC_HMAC_SHA256:"202c88c00f84a17a20027079604787461176455539e705be730890602c289a5001e34eeb3a043e5d52a65e66125188bf":"6b657920657870616e73696f6eae6c806f8ad4d80784549dff28a4b58fd837681a51d928c3e30ee5ff14f3986862e1fd91":"f23f558a605f28478c58cf72637b89784d959df7e946d3f07bd1b616":"d06139889fffac1e3a71865f504aa5d0d2a2e89506c6f2279b670c3e1b74f531016a2530c51a3a0f7e1d6590d0f0566b2f387f8d11fd4f731cdd572d2eae927f6f2f81410b25e6960be68985add6c38445ad9f8c64bf8068bf9a6679485d966f1ad6f68b43495b10a683755ea2b858d70ccac7ec8b053c6bd41ca299d4e51928"
30+ 
31+SDV_CRYPTO_KDFTLS12_COPY_CTX_API_TC001
32+SDV_CRYPTO_KDFTLS12_COPY_CTX_API_TC001:0
33+ 
34+SDV_CRYPTO_KDFTLS12_COPY_CTX_API_TC001 Provider
35+SDV_CRYPTO_KDFTLS12_COPY_CTX_API_TC001:1
36+ 
37+SDV_CRYPTO_KDF_TLS12_DUP_CTX_API_TC001
38+SDV_CRYPTO_KDF_TLS12_DUP_CTX_API_TC001:0
39+ 
40+SDV_CRYPTO_KDF_TLS12_DUP_CTX_API_TC001 Provider
41+SDV_CRYPTO_KDF_TLS12_DUP_CTX_API_TC001:1
42+ 
43+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA256
44+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA256:"918b60d280f8471784392edbb9dd1fef7a78f823672a78fdb62822707e717a6d1ef54ca58f0b3b84a6fa092eb27089dd":"6b657920657870616e73696f6ed2ec44801e16c23e9d4cfe4c5c238523860dcca2b3f7dea5409fb31fceefa713284806ac208958e6fff30ebf99d908cb00fc5af915a19a5b34cac30340031f65":"":"1910e1496131f7ef05a7a568fffe7a3d3073e4f08500c97fce69d1c42a4ccf7553e52bc1ce84b760214f2632fee46ab0c4fb2bbe1214a560c7b041cbf4be44162d559ed8e8b34ab847f66aa5e948bef5a336d9d5c1e58b9ec4484f2024c4c453d87f1e9542556fe4f4615e2bdc20f74af7cf2311bd2a02bd415868339d50414d":0
45+ 
46+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA384
47+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA384:"2a1d6063b37a458b07746a7b04ed54c9ddeef5f2e488050dfb4b0f38cc5b178e3c20e6a72307efc859bd2e1c24f790c7":"6b657920657870616e73696f6ec68423e2743b91bf9e2e10":"78bab5c5c884bd70983e0272343279e41738e943b5dce4c7973f3b0468d944de1870025bcc130e7832fd3fbfcd40ad287b13ee28f9":"de9f2ce42403605743e84e71b2fba535bbb2020e5899d98773c140c27abbfef4b4754ff01ea10e38604ec621f48a4af14715ee81b0ba10bdbebb5104bbc2411004a2962b0e7f5c2ebb27590678510c06cf880f9f529b164e75be0b7481881089944744bc33a0b8fd35d7f7a4f1dcc1bea500919e42aabb7f84d821fb1f018a4b":0
48+ 
49+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA512
50+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA512:"74348710df03212b648663bd0a2b9940190e59bdb592876c747656b26f36ce0843505b999138459cf921503ab1c2bffb":"6b657920657870616e73696f6e8e111a579904a5c79e6db0832c":"cb8190ee88db5fd722d8b3f96379286a19f94a00ac1cf7a2a6376548eba6b6f69ba9e10ab93cedca87521df83e84269628e45f":"edeed5638bda76490ff7a3d39f8bb8bc25c9811dd8b2bcd67ddd9c588bd7f05fb8c3328bc6a3252d5a4fc6b07444f5bbb39f67a6e193adc45e282e2e40d5ffe77342101f7e414b28babb94e727cbafa0bf2fc1895ca1c3045a6b75e4d0612345988b54821072432a5b835699bba58bf7cbeb1496461fd99bd76bc82e738794b2":0
51+ 
52+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001 CRYPT_MAC_HMAC_SHA512 Provider
53+SDV_CRYPT_EAL_KDF_TLS12_COPY_CTX_FUNC_TC001:CRYPT_MAC_HMAC_SHA512:"74348710df03212b648663bd0a2b9940190e59bdb592876c747656b26f36ce0843505b999138459cf921503ab1c2bffb":"6b657920657870616e73696f6e8e111a579904a5c79e6db0832c":"cb8190ee88db5fd722d8b3f96379286a19f94a00ac1cf7a2a6376548eba6b6f69ba9e10ab93cedca87521df83e84269628e45f":"edeed5638bda76490ff7a3d39f8bb8bc25c9811dd8b2bcd67ddd9c588bd7f05fb8c3328bc6a3252d5a4fc6b07444f5bbb39f67a6e193adc45e282e2e40d5ffe77342101f7e414b28babb94e727cbafa0bf2fc1895ca1c3045a6b75e4d0612345988b54821072432a5b835699bba58bf7cbeb1496461fd99bd76bc82e738794b2":1
54+ 
55+ 
56+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001 CRYPT_MAC_HMAC_SHA384
57+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA384:"2a1d6063b37a458b07746a7b04ed54c9ddeef5f2e488050dfb4b0f38cc5b178e3c20e6a72307efc859bd2e1c24f790c7":"6b657920657870616e73696f6ec68423e2743b91bf9e2e10":"78bab5c5c884bd70983e0272343279e41738e943b5dce4c7973f3b0468d944de1870025bcc130e7832fd3fbfcd40ad287b13ee28f9":0
58+ 
59+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001 CRYPT_MAC_HMAC_SHA256 Provider
60+SDV_CRYPTO_HKDF_COPY_CTX_STUB_TC001:CRYPT_MAC_HMAC_SHA256:"918b60d280f8471784392edbb9dd1fef7a78f823672a78fdb62822707e717a6d1ef54ca58f0b3b84a6fa092eb27089dd":"6b657920657870616e73696f6ed2ec44801e16c23e9d4cfe4c5c238523860dcca2b3f7dea5409fb31fceefa713284806ac208958e6fff30ebf99d908cb00fc5af915a19a5b34cac30340031f65":"":1