1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 /* BEGIN_HEADER */
17 #include <stdio.h>
18 #include <stdint.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include "securec.h"
22 #include "bsl_sal.h"
23 #include "bsl_list.h"
24 #include "bsl_err_internal.h"
25 #include "sal_file.h"
26 #include "crypt_errno.h"
27 #include "crypt_eal_provider.h"
28 #include "crypt_eal_implprovider.h"
29 #include "crypt_provider.h"
30 #include "crypt_eal_pkey.h"
31 #include "crypt_eal_codecs.h"
32 #include "bsl_types.h"
33 #include "crypt_types.h"
34 #include "crypt_utils.h"
35 #include "decode_local.h"
36 #include "test.h"
37 #include "stub_replace.h"
38 /* END_HEADER */
39
malloc_fail(uint32_t size)40 void *malloc_fail(uint32_t size)
41 {
42 (void)size;
43 return NULL;
44 }
45
46 /**
47 * @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001
48 * @brief Test CRYPT_DECODE_ProviderNewCtx API
49 * @precon None
50 */
51 /* BEGIN_CASE */
SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001(void)52 void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001(void)
53 {
54 #ifndef HITLS_CRYPTO_PROVIDER
55 SKIP_TEST();
56 #else
57 TestMemInit();
58 CRYPT_DECODER_Ctx *ctx = NULL;
59
60 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
61 ASSERT_TRUE(ctx != NULL);
62
63 CRYPT_DECODE_Free(ctx);
64 ctx = NULL;
65
66 CRYPT_DECODE_Free(NULL);
67 /* Test with NULL libCtx */
68 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, NULL);
69 ASSERT_TRUE(ctx != NULL);
70 CRYPT_DECODE_Free(ctx);
71 ctx = NULL;
72
73 /* Test with invalid key type */
74 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, -1, NULL);
75 ASSERT_TRUE(ctx == NULL);
76
77 /* Test with valid parameters */
78 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
79 ASSERT_TRUE(ctx != NULL);
80 CRYPT_DECODE_Free(ctx);
81 ctx = NULL;
82
83 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider?default, inFormat?PEM");
84 ASSERT_TRUE(ctx != NULL);
85 CRYPT_DECODE_Free(ctx);
86 ctx = NULL;
87
88 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=PEM, outFormat=ASN1");
89 ASSERT_TRUE(ctx == NULL);
90
91 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
92 ASSERT_TRUE(ctx != NULL);
93 CRYPT_DECODE_Free(ctx);
94 ctx = NULL;
95 EXIT:
96 CRYPT_DECODE_Free(ctx);
97 #endif
98 }
99 /* END_CASE */
100
101 /**
102 * @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
103 * @brief When no provider is loaded, CRYPT_DECODE_ProviderNewCtx should return NULL
104 * @precon None
105 */
106 /* BEGIN_CASE */
SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002(void)107 void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002(void)
108 {
109 #ifndef HITLS_CRYPTO_PROVIDER
110 SKIP_TEST();
111 #else
112 CRYPT_DECODER_Ctx *ctx = NULL;
113 CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
114 ASSERT_TRUE(libCtx != NULL);
115 ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
116 ASSERT_TRUE(ctx == NULL);
117 EXIT:
118 CRYPT_EAL_LibCtxFree(libCtx);
119 #endif
120 }
121 /* END_CASE */
122
123 /**
124 * @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
125 * @brief When user provider no decoder implement, CRYPT_DECODE_ProviderNewCtx should return NULL
126 * @precon None
127 */
128 /* BEGIN_CASE */
SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC003(char * providerPath,char * providerName,int cmd,int keyType)129 void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC003(char *providerPath, char *providerName, int cmd, int keyType)
130 {
131 #ifndef HITLS_CRYPTO_PROVIDER
132 (void)providerPath;
133 (void)providerName;
134 (void)cmd;
135 (void)keyType;
136 SKIP_TEST();
137 #else
138 CRYPT_DECODER_Ctx *ctx = NULL;
139 CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
140 ASSERT_TRUE(libCtx != NULL);
141 ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath), CRYPT_SUCCESS);
142 ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerName, NULL, NULL), CRYPT_SUCCESS);
143
144 ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, keyType, NULL);
145 ASSERT_TRUE(ctx == NULL);
146
147 EXIT:
148 CRYPT_EAL_LibCtxFree(libCtx);
149 #endif
150 }
151 /* END_CASE */
152
153 /**
154 * @test SDV_CRYPT_DECODE_SET_PARAM_API_TC001
155 * @brief Test CRYPT_DECODE_SetParam API
156 * @precon None
157 */
158 /* BEGIN_CASE */
SDV_CRYPT_DECODE_SET_PARAM_API_TC001(void)159 void SDV_CRYPT_DECODE_SET_PARAM_API_TC001(void)
160 {
161 #ifndef HITLS_CRYPTO_PROVIDER
162 SKIP_TEST();
163 #else
164 CRYPT_DECODER_Ctx *ctx = NULL;
165 /* Test with NULL ctx */
166 BSL_Param param = {0};
167 ASSERT_EQ(CRYPT_DECODE_SetParam(NULL, ¶m), CRYPT_NULL_INPUT);
168
169 ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
170 ASSERT_TRUE(ctx != NULL);
171 ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, NULL), CRYPT_NULL_INPUT);
172
173 ctx->method->setParam = NULL;
174 ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, ¶m), CRYPT_NOT_SUPPORT);
175 EXIT:
176 CRYPT_DECODE_Free(ctx);
177 #endif
178 }
179 /* END_CASE */
180
181 /**
182 * @test SDV_CRYPT_DECODE_GET_PARAM_API_TC001
183 * @brief Test CRYPT_DECODE_GetParam API
184 * @precon None
185 */
186 /* BEGIN_CASE */
SDV_CRYPT_DECODE_GET_PARAM_API_TC001(void)187 void SDV_CRYPT_DECODE_GET_PARAM_API_TC001(void)
188 {
189 #ifndef HITLS_CRYPTO_PROVIDER
190 SKIP_TEST();
191 #else
192 CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
193 ASSERT_TRUE(ctx != NULL);
194
195 /* Test with NULL ctx */
196 BSL_Param param = {0};
197 int32_t ret = CRYPT_DECODE_GetParam(NULL, ¶m);
198 ASSERT_EQ(ret, CRYPT_NULL_INPUT);
199
200 ret = CRYPT_DECODE_GetParam(ctx, NULL);
201 ASSERT_EQ(ret, CRYPT_NULL_INPUT);
202
203 ctx->method->getParam = NULL;
204 ret = CRYPT_DECODE_GetParam(ctx, ¶m);
205 ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
206
207 EXIT:
208 CRYPT_DECODE_Free(ctx);
209 #endif
210 }
211 /* END_CASE */
212
213 /**
214 * @test SDV_CRYPT_DECODE_DECODE_API_TC001
215 * @title Test CRYPT_DECODE_Decode API
216 * @precon None
217 */
218 /* BEGIN_CASE */
SDV_CRYPT_DECODE_DECODE_API_TC001(void)219 void SDV_CRYPT_DECODE_DECODE_API_TC001(void)
220 {
221 #ifndef HITLS_CRYPTO_PROVIDER
222 SKIP_TEST();
223 #else
224 CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
225 ASSERT_TRUE(ctx != NULL);
226
227 /* Test with NULL ctx */
228 BSL_Param inParam[2] = {0};
229 BSL_Param *outParam = NULL;
230 int32_t ret = CRYPT_DECODE_Decode(NULL, inParam, &outParam);
231 ASSERT_EQ(ret, CRYPT_NULL_INPUT);
232
233 /* Test with NULL inParam */
234 ret = CRYPT_DECODE_Decode(ctx, NULL, &outParam);
235 ASSERT_EQ(ret, CRYPT_NULL_INPUT);
236
237 /* Test with NULL outParam */
238 ret = CRYPT_DECODE_Decode(ctx, inParam, NULL);
239 ASSERT_EQ(ret, CRYPT_NULL_INPUT);
240
241 /* Test with NULL decode function */
242 ctx->method->decode = NULL;
243 ret = CRYPT_DECODE_Decode(ctx, inParam, &outParam);
244 ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
245
246 EXIT:
247 CRYPT_DECODE_Free(ctx);
248 #endif
249 }
250 /* END_CASE */
251
252 /**
253 * @test SDV_CRYPT_DECODE_DECODE_API_TC002
254 * @title Test CRYPT_DECODE_Decode API with valid parameters,
255 * Test with valid PEM to ASN1 conversion
256 */
257 /* BEGIN_CASE */
SDV_CRYPT_DECODE_DECODE_API_TC002(char * pemPath,char * asn1Path)258 void SDV_CRYPT_DECODE_DECODE_API_TC002(char *pemPath, char *asn1Path)
259 {
260 #ifndef HITLS_CRYPTO_PROVIDER
261 (void)pemPath;
262 (void)asn1Path;
263 SKIP_TEST();
264 #else
265 CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
266 ASSERT_TRUE(ctx != NULL);
267
268 /* Test with valid PEM to ASN1 conversion */
269 uint8_t *pemData = NULL;
270 uint32_t pemDataLen = 0;
271 uint8_t *asn1Data = NULL;
272 uint32_t asn1DataLen = 0;
273 ASSERT_EQ(BSL_SAL_ReadFile(pemPath, &pemData, &pemDataLen), BSL_SUCCESS);
274
275 BSL_Param inParam[2] = {
276 {CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, pemData, pemDataLen, 0},
277 BSL_PARAM_END
278 };
279 BSL_Param *outParam = NULL;
280 ASSERT_EQ(CRYPT_DECODE_Decode(ctx, inParam, &outParam), CRYPT_SUCCESS);
281 ASSERT_TRUE(outParam != NULL);
282 ASSERT_TRUE(outParam->value != NULL);
283 ASSERT_TRUE(outParam->valueLen > 0);
284 ASSERT_EQ(BSL_SAL_ReadFile(asn1Path, &asn1Data, &asn1DataLen), BSL_SUCCESS);
285 ASSERT_EQ(outParam->valueLen, asn1DataLen);
286 ASSERT_EQ(memcmp(outParam->value, asn1Data, asn1DataLen), 0);
287
288 EXIT:
289 BSL_SAL_Free(pemData);
290 BSL_SAL_Free(asn1Data);
291 if (outParam != NULL) {
292 CRYPT_DECODE_FreeOutData(ctx, outParam);
293 }
294 CRYPT_DECODE_Free(ctx);
295 #endif
296 }
297 /* END_CASE */
298
299 /**
300 * @test SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001
301 * @title Test CRYPT_DECODE_FreeOutData API
302 * @precon None
303 */
304 /* BEGIN_CASE */
SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001(void)305 void SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001(void)
306 {
307 #ifndef HITLS_CRYPTO_PROVIDER
308 SKIP_TEST();
309 #else
310 /* Test with NULL ctx */
311 BSL_Param outData = {0};
312 CRYPT_DECODE_FreeOutData(NULL, &outData);
313
314 /* Test with NULL outData */
315 CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
316 ASSERT_TRUE(ctx != NULL);
317 CRYPT_DECODE_FreeOutData(ctx, NULL);
318
319 ctx->method->freeOutData = NULL;
320 CRYPT_DECODE_FreeOutData(ctx, &outData);
321
322 EXIT:
323 CRYPT_DECODE_Free(ctx);
324 #endif
325 }
326 /* END_CASE */
327
328 /**
329 * @test SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001
330 * @title Test CRYPT_DECODE_PoolNewCtx API
331 * @precon None
332 */
333 /* BEGIN_CASE */
SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001(void)334 void SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001(void)
335 {
336 #ifndef HITLS_CRYPTO_PROVIDER
337 SKIP_TEST();
338 #else
339 FuncStubInfo tmpRpInfo = {0};
340 CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
341 ASSERT_TRUE(poolCtx != NULL);
342
343 CRYPT_DECODE_PoolFreeCtx(poolCtx);
344 poolCtx = NULL;
345
346 CRYPT_DECODE_PoolFreeCtx(NULL);
347
348 /* Test with malloc failed */
349 STUB_Init();
350 ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
351
352 TestMemInit();
353
354 poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
355 ASSERT_TRUE(poolCtx == NULL);
356
357 EXIT:
358 STUB_Reset(&tmpRpInfo);
359 CRYPT_DECODE_PoolFreeCtx(poolCtx);
360 #endif
361 }
362 /* END_CASE */
363
364 /**
365 * @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC001
366 * @title Test CRYPT_DECODE_PoolDecode API with invalid parameters
367 * @precon None
368 */
369 /* BEGIN_CASE */
SDV_CRYPT_DECODE_POOL_DECODE_API_TC001(void)370 void SDV_CRYPT_DECODE_POOL_DECODE_API_TC001(void)
371 {
372 #ifndef HITLS_CRYPTO_PROVIDER
373 SKIP_TEST();
374 #else
375 CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
376 ASSERT_TRUE(poolCtx != NULL);
377
378 /* Test with NULL poolCtx */
379 BSL_Param inParam[2] = {0};
380 BSL_Param *outParam = NULL;
381 ASSERT_EQ(CRYPT_DECODE_PoolDecode(NULL, inParam, &outParam), CRYPT_NULL_INPUT);
382
383 /* Test with NULL inParam */
384 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, NULL, &outParam), CRYPT_NULL_INPUT);
385
386 /* Test with NULL outParam */
387 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, NULL), CRYPT_NULL_INPUT);
388
389 /* Test with invalid outParam */
390 outParam = inParam;
391 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_INVALID_ARG);
392
393 /* Test with invalid input data */
394 uint8_t invalidData[] = "Invalid PEM data";
395 inParam[0].valueType = BSL_PARAM_TYPE_OCTETS;
396 inParam[0].value = invalidData;
397 inParam[0].valueLen = sizeof(invalidData);
398 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_DECODE_ERR_NO_USABLE_DECODER);
399
400
401
402 EXIT:
403 CRYPT_DECODE_PoolFreeCtx(poolCtx);
404 #endif
405 }
406 /* END_CASE */
407
408 /**
409 * @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC002
410 * @title Test CRYPT_DECODE_PoolDecode API with valid parameters
411 * @precon None
412 * @brief
413 * 1. Test with valid parameters
414 * 2. Test with valid PEM to ASN1 conversion
415 * @expect
416 * 1. Return CRYPT_SUCCESS
417 * 2. Return CRYPT_SUCCESS and output data matches expected
418 */
419 /* BEGIN_CASE */
SDV_CRYPT_DECODE_POOL_DECODE_API_TC002(char * inputFormat,char * inputType,char * path,char * targetFormat,char * targetType,char * targetPath)420 void SDV_CRYPT_DECODE_POOL_DECODE_API_TC002(char *inputFormat, char *inputType, char *path, char *targetFormat,
421 char *targetType, char *targetPath)
422 {
423 #ifndef HITLS_CRYPTO_PROVIDER
424 (void)inputFormat;
425 (void)inputType;
426 (void)path;
427 (void)targetFormat;
428 (void)targetType;
429 (void)targetPath;
430 SKIP_TEST();
431 #else
432 if (strcmp(inputFormat, "NULL") == 0) {
433 inputFormat = NULL;
434 }
435 if (strcmp(inputType, "NULL") == 0) {
436 inputType = NULL;
437 }
438 CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, BSL_CID_DECODE_UNKNOWN, inputFormat, inputType);
439 ASSERT_TRUE(poolCtx != NULL);
440
441 /* Test with valid PEM to ASN1 conversion */
442 uint8_t *inputData = NULL;
443 uint32_t inputDataLen = 0;
444 uint8_t *outputData = NULL;
445 uint32_t outputDataLen = 0;
446 bool isFreeOutData = true;
447 ASSERT_EQ(BSL_SAL_ReadFile(path, &inputData, &inputDataLen), BSL_SUCCESS);
448
449 BSL_Param inParam[2] = {
450 {CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
451 BSL_PARAM_END
452 };
453 BSL_Param *outParam = NULL;
454
455 /* Set target format and type */
456 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, targetFormat,
457 strlen(targetFormat)), CRYPT_SUCCESS);
458 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, targetType,
459 strlen(targetType)), CRYPT_SUCCESS);
460
461 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
462 ASSERT_TRUE(outParam != NULL);
463 ASSERT_TRUE(outParam->value != NULL);
464 ASSERT_TRUE(outParam->valueLen > 0);
465 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
466 sizeof(bool)), CRYPT_SUCCESS);
467
468 if (outParam->key == CRYPT_PARAM_DECODE_BUFFER_DATA) {
469 ASSERT_EQ(BSL_SAL_ReadFile(targetPath, &outputData, &outputDataLen), BSL_SUCCESS);
470 ASSERT_EQ(outParam->valueLen, outputDataLen);
471 ASSERT_EQ(memcmp(outParam->value, outputData, outputDataLen), 0);
472 } else if (outParam->key == CRYPT_PARAM_DECODE_OBJECT_DATA) {
473 ASSERT_NE(outParam->value, NULL);
474 }
475 EXIT:
476 BSL_SAL_Free(inputData);
477 BSL_SAL_Free(outputData);
478 CRYPT_DECODE_PoolFreeCtx(poolCtx);
479 #endif
480 }
481 /* END_CASE */
482
483 /**
484 * @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC001
485 * @title Test CRYPT_DECODE_PoolCtrl API with valid parameters and boundary conditions
486 * @precon None
487 */
488 /* BEGIN_CASE */
SDV_CRYPT_DECODE_POOL_CTRL_API_TC001(void)489 void SDV_CRYPT_DECODE_POOL_CTRL_API_TC001(void)
490 {
491 #ifndef HITLS_CRYPTO_PROVIDER
492 SKIP_TEST();
493 #else
494 CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
495 ASSERT_TRUE(poolCtx != NULL);
496
497 /* Test setting target format */
498 const char *targetFormat = "ASN1";
499 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
500 strlen(targetFormat)), CRYPT_SUCCESS);
501 ASSERT_EQ(poolCtx->targetFormat, targetFormat);
502
503 /* Test setting target type */
504 const char *targetType = "PRIKEY_RSA";
505 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
506 strlen(targetType)), CRYPT_SUCCESS);
507 ASSERT_EQ(poolCtx->targetType, targetType);
508
509 /* Test setting free output data flag */
510 bool isFreeOutData = true;
511 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
512 sizeof(bool)), CRYPT_SUCCESS);
513
514 /* Test with invalid format length */
515 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
516 MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
517
518 /* Test with invalid type length */
519 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
520 MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
521
522 /* Test with invalid flag size */
523 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
524 sizeof(bool) + 1), CRYPT_INVALID_ARG);
525
526 /* Test with invalid command */
527 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, 0xFFFFFFFF, &isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
528
529 EXIT:
530 CRYPT_DECODE_PoolFreeCtx(poolCtx);
531 #endif
532 }
533 /* END_CASE */
534
535 #ifdef HITLS_CRYPTO_PROVIDER
FreeDecoderNode(CRYPT_DECODER_Node * decoderNode)536 static void FreeDecoderNode(CRYPT_DECODER_Node *decoderNode)
537 {
538 if (decoderNode == NULL) {
539 return;
540 }
541 CRYPT_DECODE_FreeOutData(decoderNode->decoderCtx, decoderNode->outData.data);
542 BSL_SAL_Free(decoderNode);
543 }
544 #endif
545
546 /**
547 * @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC002
548 * @title Test CRYPT_DECODE_PoolCtrl CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA with valid parameters and boundary
549 * conditions
550 * @precon None
551 */
552 /* BEGIN_CASE */
SDV_CRYPT_DECODE_POOL_CTRL_API_TC002(void)553 void SDV_CRYPT_DECODE_POOL_CTRL_API_TC002(void)
554 {
555 #ifndef HITLS_CRYPTO_PROVIDER
556 SKIP_TEST();
557 #else
558 BSL_Param *outParam = NULL;
559 bool isFreeOutData = true;
560 uint8_t *inputData = NULL;
561 uint32_t inputDataLen = 0;
562 CRYPT_DECODER_PoolCtx *poolCtx = NULL;
563 ASSERT_EQ(BSL_SAL_ReadFile("../testdata/cert/asn1/rsa2048key_pkcs1.pem", &inputData, &inputDataLen), BSL_SUCCESS);
564 BSL_Param inParam[2] = {
565 {CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
566 BSL_PARAM_END
567 };
568 poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
569 ASSERT_TRUE(poolCtx != NULL);
570
571 /* Manually clear the decoder path to simulate no nodes condition */
572 if (poolCtx->decoderPath != NULL) {
573 BSL_LIST_FREE(poolCtx->decoderPath, (BSL_LIST_PFUNC_FREE)FreeDecoderNode);
574 }
575
576 /* Now test the control operation with empty decoder path */
577 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
578 &isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
579
580 CRYPT_DECODE_PoolFreeCtx(poolCtx);
581 poolCtx = NULL;
582 /* Test when decoderPath has only one node (input equals output) */
583 poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
584 ASSERT_TRUE(poolCtx != NULL);
585 const char *targetFormat = "PEM";
586 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
587 strlen(targetFormat)), CRYPT_SUCCESS);
588 ASSERT_EQ(poolCtx->targetFormat, targetFormat);
589
590 const char *targetType = "PRIKEY_RSA";
591 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
592 strlen(targetType)), CRYPT_SUCCESS);
593
594 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
595 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
596 &isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
597
598 CRYPT_DECODE_PoolFreeCtx(poolCtx);
599 poolCtx = NULL;
600 outParam = NULL;
601
602 /* Test isFreeOutData is false */
603 poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
604 ASSERT_TRUE(poolCtx != NULL);
605 targetFormat = "ASN1";
606 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
607 strlen(targetFormat)), CRYPT_SUCCESS);
608 targetType = "PRIKEY_RSA";
609 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
610 strlen(targetType)), CRYPT_SUCCESS);
611 ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
612 isFreeOutData = false;
613 ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
614 &isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
615 BSL_SAL_FREE(outParam->value);
616 BSL_SAL_FREE(outParam);
617
618 EXIT:
619 BSL_SAL_Free(inputData);
620 CRYPT_DECODE_PoolFreeCtx(poolCtx);
621 #endif
622 }
623 /* END_CASE */
624