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
18 #include "bsl_sal.h"
19 #include "crypt_errno.h"
20 #include "eal_md_local.h"
21 #include "eal_pkey_local.h"
22 #include "crypt_eal_md.h"
23 #include "crypt_eal_mac.h"
24 #include "crypt_eal_cipher.h"
25 #include "crypt_eal_pkey.h"
26 #include "eal_cipher_local.h"
27 #include "modes_local.h"
28 #include "eal_common.h"
29
IsMacAlgIdValid(int id)30 static bool IsMacAlgIdValid(int id)
31 {
32 int algList[] = {
33 CRYPT_MAC_HMAC_MD5,
34 CRYPT_MAC_HMAC_SHA1,
35 CRYPT_MAC_HMAC_SHA224,
36 CRYPT_MAC_HMAC_SHA256,
37 CRYPT_MAC_HMAC_SHA384,
38 CRYPT_MAC_HMAC_SHA512,
39 CRYPT_MAC_HMAC_SHA3_224,
40 CRYPT_MAC_HMAC_SHA3_256,
41 CRYPT_MAC_HMAC_SHA3_384,
42 CRYPT_MAC_HMAC_SHA3_512,
43 CRYPT_MAC_HMAC_SM3,
44 CRYPT_MAC_CMAC_AES128,
45 CRYPT_MAC_CMAC_AES192,
46 CRYPT_MAC_CMAC_AES256,
47 CRYPT_MAC_GMAC_AES128,
48 CRYPT_MAC_GMAC_AES192,
49 CRYPT_MAC_GMAC_AES256,
50 CRYPT_MAC_SIPHASH64,
51 CRYPT_MAC_SIPHASH128
52 };
53 int algIdCnt = sizeof(algList) / sizeof(int);
54 for (int i = 0; i < algIdCnt; i++) {
55 if (id == algList[i]) {
56 return true;
57 }
58 }
59 return false;
60 }
61
IsCipherAlgIdValid(int id)62 static bool IsCipherAlgIdValid(int id)
63 {
64 int algList[] = {
65 CRYPT_CIPHER_AES128_CBC,
66 CRYPT_CIPHER_AES192_CBC,
67 CRYPT_CIPHER_AES256_CBC,
68 CRYPT_CIPHER_AES128_CTR,
69 CRYPT_CIPHER_AES192_CTR,
70 CRYPT_CIPHER_AES256_CTR,
71 CRYPT_CIPHER_AES128_ECB,
72 CRYPT_CIPHER_AES192_ECB,
73 CRYPT_CIPHER_AES256_ECB,
74 CRYPT_CIPHER_AES128_XTS,
75 CRYPT_CIPHER_AES256_XTS,
76 CRYPT_CIPHER_AES128_CCM,
77 CRYPT_CIPHER_AES192_CCM,
78 CRYPT_CIPHER_AES256_CCM,
79 CRYPT_CIPHER_AES128_GCM,
80 CRYPT_CIPHER_AES192_GCM,
81 CRYPT_CIPHER_AES256_GCM,
82 CRYPT_CIPHER_AES128_CFB,
83 CRYPT_CIPHER_AES192_CFB,
84 CRYPT_CIPHER_AES256_CFB,
85 CRYPT_CIPHER_AES128_OFB,
86 CRYPT_CIPHER_AES192_OFB,
87 CRYPT_CIPHER_AES256_OFB,
88 CRYPT_CIPHER_CHACHA20_POLY1305,
89 CRYPT_CIPHER_SM4_XTS,
90 CRYPT_CIPHER_SM4_CBC,
91 CRYPT_CIPHER_SM4_ECB,
92 CRYPT_CIPHER_SM4_CTR,
93 CRYPT_CIPHER_SM4_GCM,
94 CRYPT_CIPHER_SM4_CFB,
95 CRYPT_CIPHER_SM4_OFB,
96 };
97 int algIdCnt = sizeof(algList) / sizeof(int);
98 for (int i = 0; i < algIdCnt; i++) {
99 if (id == algList[i]) {
100 return true;
101 }
102 }
103 return false;
104 }
105
IsPkeyAlgIdValid(int id)106 static bool IsPkeyAlgIdValid(int id)
107 {
108 int algList[] = {
109 CRYPT_PKEY_DSA,
110 CRYPT_PKEY_ED25519,
111 CRYPT_PKEY_X25519,
112 CRYPT_PKEY_RSA,
113 CRYPT_PKEY_DH,
114 CRYPT_PKEY_ECDSA,
115 CRYPT_PKEY_ECDH,
116 CRYPT_PKEY_SM2
117 };
118 int algIdCnt = sizeof(algList) / sizeof(int);
119 for (int i = 0; i < algIdCnt; i++) {
120 if (id == algList[i]) {
121 return true;
122 }
123 }
124 return false;
125 }
126
127 #define MD_OUTPUT_MAXSIZE 128
128
MdTest(CRYPT_EAL_MdCTX * ctx,Hex * msg,Hex * hash)129 static int32_t MdTest(CRYPT_EAL_MdCTX *ctx, Hex *msg, Hex *hash)
130 {
131 (void)msg;
132 (void)hash;
133 uint8_t output[MD_OUTPUT_MAXSIZE];
134 uint32_t outLen = MD_OUTPUT_MAXSIZE;
135
136 ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
137 ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
138 ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
139 if (ctx->id != CRYPT_MD_SHAKE128 && ctx->id != CRYPT_MD_SHAKE256) {
140 ASSERT_TRUE(outLen == hash->len);
141 }
142 ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
143 return 0;
144 EXIT:
145 return -1;
146 }
147 /* END_HEADER */
148
149 /**
150 * @test SDV_CRYPTO_MAC_ALG_CHECK_TC001
151 * @title Check the validity of the mac algorithm ID.
152 * @precon nan
153 * @brief
154 * 1. Call the CRYPT_EAL_MacIsValidAlgId method, compare the returned value with 'isValid', expected result 1
155 * @expect
156 * 1. Both are the same.
157 */
158 /* BEGIN_CASE */
SDV_CRYPTO_MAC_ALG_CHECK_TC001(int algId)159 void SDV_CRYPTO_MAC_ALG_CHECK_TC001(int algId)
160 {
161 int isValid = IsMacAlgIdValid(algId);
162 ASSERT_TRUE(CRYPT_EAL_MacIsValidAlgId(algId) == isValid);
163 EXIT:
164 return;
165 }
166 /* END_CASE */
167
168 /**
169 * @test SDV_CRYPTO_CIPHER_ALG_CHECK_TC001
170 * @title Check the validity of the symmetric algorithm ID.
171 * @precon nan
172 * @brief
173 * 1. Call the CRYPT_EAL_CipherIsValidAlgId method, compare the returned value with 'isValid', expected result 1
174 * @expect
175 * 1. Both are the same.
176 */
177 /* BEGIN_CASE */
SDV_CRYPTO_CIPHER_ALG_CHECK_TC001(int algId)178 void SDV_CRYPTO_CIPHER_ALG_CHECK_TC001(int algId)
179 {
180 int isValid = IsCipherAlgIdValid(algId);
181 ASSERT_TRUE(CRYPT_EAL_CipherIsValidAlgId(algId) == isValid);
182 EXIT:
183 return;
184 }
185 /* END_CASE */
186
187 /**
188 * @test SDV_CRYPTO_MD_COPY_FUNC_TC001
189 * @title CRYPT_EAL_MdCopyCtx function test.
190 * @precon nan
191 * @brief
192 * 1. Create the context ctx of md algorithm, expected result 1
193 * 2. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 2
194 * 3. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 3
195 * 4. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
196 * @expect
197 * 1. Success, the context is not null.
198 * 2. Success, the hashs are the same.
199 * 3. CRYPT_SUCCESS
200 * 4. Success, the hashs are the same.
201 */
202 /* BEGIN_CASE */
SDV_CRYPTO_MD_COPY_FUNC_TC001(int id,Hex * msg,Hex * hash)203 void SDV_CRYPTO_MD_COPY_FUNC_TC001(int id, Hex *msg, Hex *hash)
204 {
205 TestMemInit();
206 CRYPT_EAL_MdCTX *cpyCtx = NULL;
207 CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
208 ASSERT_TRUE(ctx != NULL);
209 ASSERT_EQ(MdTest(ctx, msg, hash), 0);
210
211 cpyCtx = CRYPT_EAL_MdNewCtx(id);
212 ASSERT_TRUE(cpyCtx != NULL);
213 ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
214 ASSERT_EQ(MdTest(cpyCtx, msg, hash), 0);
215
216 EXIT:
217 CRYPT_EAL_MdFreeCtx(ctx);
218 CRYPT_EAL_MdFreeCtx(cpyCtx);
219 }
220 /* END_CASE */
221
222 /**
223 * @test SDV_CRYPTO_EAL_PKEY_NEW_CTX_API_TC001
224 * @title CRYPT_EAL_PkeyNewCtx test.
225 * @precon nan
226 * @brief
227 * 1. Call the CRYPT_EAL_PkeyNewCtx method, algId is CRYPT_PKEY_MAX, expected result 1
228 * @expect
229 * 1. Return null.
230 */
231 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_NEW_CTX_API_TC001(void)232 void SDV_CRYPTO_EAL_PKEY_NEW_CTX_API_TC001(void)
233 {
234 CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_MAX);
235 ASSERT_TRUE(pkey == NULL);
236 EXIT:
237 return;
238 }
239 /* END_CASE */
240
241 /**
242 * @test SDV_CRYPTO_EAL_PKEY_FREE_CTX_API_TC001
243 * @title CRYPT_EAL_PkeyFreeCtx test.
244 * @precon nan
245 * @brief
246 * 1. Call the CRYPT_EAL_PkeyFreeCtx method, ctx is null, expected result 1
247 * @expect
248 * 1. No memory leakage occurs.
249 */
250 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_FREE_CTX_API_TC001(void)251 void SDV_CRYPTO_EAL_PKEY_FREE_CTX_API_TC001(void)
252 {
253 CRYPT_EAL_PkeyFreeCtx(NULL);
254 }
255 /* END_CASE */
256
257 /**
258 * @test SDV_CRYPTO_EAL_PKEY_SET_PARA_API_TC001
259 * @title Check the validity of the asymmetric algorithm ID.
260 * @precon nan
261 * @brief
262 * 1. Call the CRYPT_EAL_PkeySetPara method:
263 * (1) pkey = NULL, expected result 1
264 * (2) para = NULL, expected result 1
265 * (3) pkey.id != para.id, expected result 2
266 * @expect
267 * 1. CRYPT_NULL_INPUT.
268 * 2. CRYPT_EAL_ERR_ALGID.
269 */
270 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_SET_PARA_API_TC001(void)271 void SDV_CRYPTO_EAL_PKEY_SET_PARA_API_TC001(void)
272 {
273 CRYPT_EAL_PkeyPara para = {0};
274
275 CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DSA);
276 ASSERT_TRUE(pkey != NULL);
277
278 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(NULL, ¶) == CRYPT_NULL_INPUT);
279 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, NULL) == CRYPT_NULL_INPUT);
280
281 para.id = CRYPT_PKEY_RSA;
282 ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_ALGID);
283 EXIT:
284 CRYPT_EAL_PkeyFreeCtx(pkey);
285 }
286 /* END_CASE */
287
288 /**
289 * @test SDV_CRYPTO_EAL_PKEY_ALG_CHECK_TC001
290 * @title Check the validity of the asymmetric algorithm ID.
291 * @precon nan
292 * @brief
293 * 1. Call the CRYPT_EAL_PkeyIsValidAlgId method, compare the returned value with 'isValid', expected result 1
294 * @expect
295 * 1. Both are the same.
296 */
297 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_ALG_CHECK_TC001(int algId)298 void SDV_CRYPTO_EAL_PKEY_ALG_CHECK_TC001(int algId)
299 {
300 int isValid = IsPkeyAlgIdValid(algId);
301 ASSERT_TRUE(CRYPT_EAL_PkeyIsValidAlgId(algId) == isValid);
302 EXIT:
303 return;
304 }
305 /* END_CASE */
306
307 /**
308 * @test SDV_CRYPTO_EAL_PKEY_SET_PRV_API_TC001
309 * @title CRYPT_EAL_PkeySetPrv bad arguments.
310 * @precon nan
311 * @brief
312 * 1. Call the CRYPT_EAL_PkeySetPrv:
313 * (1) pkey=NULL, expected result 1
314 * (2) prv=NULL, expected result 1
315 * (3) pkey.id != prv.id, expected result 2
316 * @expect
317 * 1. CRYPT_NULL_INPUT
318 * 2. CRYPT_EAL_ERR_ALGID
319 */
320 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_SET_PRV_API_TC001(void)321 void SDV_CRYPTO_EAL_PKEY_SET_PRV_API_TC001(void)
322 {
323 CRYPT_EAL_PkeyCtx *pkey = NULL;
324 CRYPT_EAL_PkeyPrv prv = {0};
325
326 pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
327 ASSERT_TRUE(pkey != NULL);
328
329 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(NULL, &prv), CRYPT_NULL_INPUT);
330 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, NULL), CRYPT_NULL_INPUT);
331
332 prv.id = CRYPT_PKEY_DSA;
333 ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_EAL_ERR_ALGID);
334 EXIT:
335 CRYPT_EAL_PkeyFreeCtx(pkey);
336 }
337 /* END_CASE */
338
339 /**
340 * @test SDV_CRYPTO_EAL_PKEY_SET_PUB_API_TC001
341 * @title CRYPT_EAL_PkeySetPub bad arguments.
342 * @precon nan
343 * @brief
344 * 1. Call the CRYPT_EAL_PkeySetPub:
345 * (1) pkey=NULL, expected result 1
346 * (2) prv=NULL, expected result 1
347 * (3) pkey.id != prv.id, expected result 2
348 * @expect
349 * 1. CRYPT_NULL_INPUT
350 * 2. CRYPT_EAL_ERR_ALGID
351 */
352 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_SET_PUB_API_TC001(void)353 void SDV_CRYPTO_EAL_PKEY_SET_PUB_API_TC001(void)
354 {
355 CRYPT_EAL_PkeyCtx *pkey = NULL;
356 CRYPT_EAL_PkeyPub pub = {0};
357
358 pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
359 ASSERT_TRUE(pkey != NULL);
360
361 ASSERT_EQ(CRYPT_EAL_PkeySetPub(NULL, &pub), CRYPT_NULL_INPUT);
362 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, NULL), CRYPT_NULL_INPUT);
363
364 pub.id = CRYPT_PKEY_DSA;
365 ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_EAL_ERR_ALGID);
366 EXIT:
367 CRYPT_EAL_PkeyFreeCtx(pkey);
368 }
369 /* END_CASE */
370
371 /**
372 * @test SDV_CRYPTO_EAL_PKEY_GEN_API_TC001
373 * @title CRYPT_EAL_PkeyGen bad arguments.
374 * @precon nan
375 * @brief
376 * 1. Call the CRYPT_EAL_PkeySetPub: peky = NULL, expected result 1
377 * @expect
378 * 1. CRYPT_NULL_INPUT
379 */
380 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_GEN_API_TC001(void)381 void SDV_CRYPTO_EAL_PKEY_GEN_API_TC001(void)
382 {
383 ASSERT_EQ(CRYPT_EAL_PkeyGen(NULL), CRYPT_NULL_INPUT);
384 EXIT:
385 return;
386 }
387 /* END_CASE */
388
389 /**
390 * @test SDV_CRYPTO_EAL_PKEY_CMP_TC001
391 * @title CRYPT_EAL_PkeyCmp Test.
392 * @precon nan
393 * @brief
394 * 1. Call the CRYPT_EAL_PkeyCmp, ctx1=NULL, ctx2=NULL, expected result 1
395 * 2. Call the CRYPT_EAL_PkeyCmp, ctx1=NULL, ctx2!=NULL or ctx1=NULL, ctx2!=NULL, expected result 2
396 * 3. Call the CRYPT_EAL_PkeyCmp, ctx1!=NULL, ctx2!=NULL, the content in ctx1 and ctx2 is empty, expected result 2
397 * 4. Call the CRYPT_EAL_PkeyCmp, ctx1!=NULL, ctx2!=NULL, ctx1.id!=ctx2.id, expected result 3
398 * 5. Call the CRYPT_EAL_PkeyCmp, ctx1->pkey=NULL, expected result 2
399 * @expect
400 * 1. CRYPT_SUCCESS
401 * 2. CRYPT_NULL_INPUT
402 * 3. CRYPT_EAL_PKEY_CMP_DIFF_KEY_TYPE
403 */
404 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_CMP_TC001(void)405 void SDV_CRYPTO_EAL_PKEY_CMP_TC001(void)
406 {
407 CRYPT_EAL_PkeyCtx ctx1 = {0};
408 CRYPT_EAL_PkeyCtx ctx2 = {0};
409 CRYPT_EAL_PkeyCtx *pkey = NULL;
410
411 ASSERT_EQ(CRYPT_EAL_PkeyCmp(NULL, NULL), CRYPT_SUCCESS);
412 ASSERT_EQ(CRYPT_EAL_PkeyCmp(NULL, &ctx2), CRYPT_NULL_INPUT);
413 ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, NULL), CRYPT_NULL_INPUT);
414 ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_NULL_INPUT);
415
416 ctx1.id = CRYPT_PKEY_DH;
417 ctx2.id = CRYPT_PKEY_DSA;
418 ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_EAL_PKEY_CMP_DIFF_KEY_TYPE);
419
420 ctx2.id = CRYPT_PKEY_DH;
421 pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DH);
422 ASSERT_TRUE(pkey != NULL);
423 ASSERT_TRUE(pkey->method != NULL);
424 ctx1.method = pkey->method;
425 ctx2.method = pkey->method;
426 ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_NULL_INPUT);
427 EXIT:
428 CRYPT_EAL_PkeyFreeCtx(pkey);
429 }
430 /* END_CASE */
431
432 /**
433 * @test SDV_CRYPTO_EAL_PKEY_GET_ID_API_TC001
434 * @title CRYPT_EAL_PkeyGetId Test.
435 * @precon nan
436 * @brief
437 * 1. Create the context(ctx) of pkeyId, expected result 1
438 * 2. Call the CRYPT_EAL_PkeyGetId to get id of ctx, expected result 2
439 * 3. Call the CRYPT_EAL_PkeyGetId to get id of NULL, expected result 3
440 * @expect
441 * 1. Success, and context is not NULL.
442 * 2. The getted id and pkeyId are the same.
443 * 3. Get id: CRYPT_PKEY_MAX
444 */
445 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_GET_ID_API_TC001(void)446 void SDV_CRYPTO_EAL_PKEY_GET_ID_API_TC001(void)
447 {
448 int pkeyId = CRYPT_PKEY_DSA;
449
450 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(pkeyId);
451 ASSERT_TRUE(ctx != NULL);
452
453 ASSERT_EQ(CRYPT_EAL_PkeyGetId(ctx), pkeyId);
454 ASSERT_EQ(CRYPT_EAL_PkeyGetId(NULL), CRYPT_PKEY_MAX);
455 EXIT:
456 CRYPT_EAL_PkeyFreeCtx(ctx);
457 }
458 /* END_CASE */
459
460 /**
461 * @test SDV_CRYPTO_EAL_PKEY_EXT_DATA_API_TC001
462 * @title CRYPT_EAL_PkeySetExtData/CRYPT_EAL_PkeyGetExtData Test.
463 * @precon nan
464 * @brief
465 * 1. Create the context(ctx) of pkeyId, expected result 1
466 * 2. Call the CRYPT_EAL_PkeySetExtData to set ext data, ctx is null, expected result 2
467 * 3. Call the CRYPT_EAL_PkeySetExtData to set ext data, all parameters are valid, expected result 3
468 * 4. Call the CRYPT_EAL_PkeyGetExtData to get ext data, ctx is null, expected result 4
469 * 5. Call the CRYPT_EAL_PkeyGetExtData to get ext data, all parameters are valid, expected result 5
470 * @expect
471 * 1. Success, and context is not NULL.
472 * 2. CRYPT_NULL_INPUT
473 * 3. CRYPT_SUCCESS
474 * 4. Return null.
475 * 5. The returned value is not null and the value is correct.
476 */
477 /* BEGIN_CASE */
SDV_CRYPTO_EAL_PKEY_EXT_DATA_API_TC001(void)478 void SDV_CRYPTO_EAL_PKEY_EXT_DATA_API_TC001(void)
479 {
480 int pkeyId = CRYPT_PKEY_DSA;
481 int data = 1;
482 void *ptr = NULL;
483
484 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(pkeyId);
485 ASSERT_TRUE(ctx != NULL);
486
487 ASSERT_EQ(CRYPT_EAL_PkeySetExtData(NULL, &data), CRYPT_NULL_INPUT);
488 ASSERT_EQ(CRYPT_EAL_PkeySetExtData(ctx, &data), CRYPT_SUCCESS);
489
490 ASSERT_TRUE(CRYPT_EAL_PkeyGetExtData(NULL) == NULL);
491 ptr = CRYPT_EAL_PkeyGetExtData(ctx);
492 ASSERT_TRUE(ptr != NULL);
493 ASSERT_EQ(*(int *)ptr, data);
494 EXIT:
495 CRYPT_EAL_PkeyFreeCtx(ctx);
496 }
497 /* END_CASE */
498
499 /**
500 * @test SDV_CRYPTO_EAL_REINIT_TC001
501 */
502 /* BEGIN_CASE */
SDV_CRYPTO_EAL_REINIT_TC001(int id)503 void SDV_CRYPTO_EAL_REINIT_TC001(int id)
504 {
505 uint8_t key[16] = {0};
506 uint32_t keyLen = 16;
507 uint8_t iv[16] = {0};
508 uint32_t ivLen = 16;
509 uint8_t in[15] = {0};
510 uint32_t inLen = 15;
511 uint8_t out[64] = {0};
512 uint32_t outLen = 64;
513
514 CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
515 ASSERT_TRUE(ctx != NULL);
516 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
517 (void)CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
518 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
519 ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
520 struct ModesCipherCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
521 ASSERT_TRUE(ciphCtx != NULL);
522 // Check data dataLen
523 ASSERT_EQ(ciphCtx->dataLen, 0);
524 for (uint32_t i = 0; i < EAL_MAX_BLOCK_LENGTH; i++) {
525 ASSERT_EQ(ciphCtx->data[i], 0);
526 }
527 EXIT:
528 CRYPT_EAL_CipherDeinit(ctx);
529 CRYPT_EAL_CipherFreeCtx(ctx);
530 }
531 /* END_CASE */
532
533 /**
534 * @test SDV_CRYPTO_EAL_REINIT_TC002
535 */
536 /* BEGIN_CASE */
SDV_CRYPTO_EAL_REINIT_TC002(int id)537 void SDV_CRYPTO_EAL_REINIT_TC002(int id)
538 {
539 uint8_t key[32] = {0};
540 uint32_t keyLen = 32;
541 uint8_t iv[12] = {0};
542 uint32_t ivLen = 12;
543 uint8_t in[15] = {0};
544 uint32_t inLen = 15;
545 uint8_t out[64] = {0};
546 uint32_t outLen = 64;
547
548 CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
549 ASSERT_TRUE(ctx != NULL);
550 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
551 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
552 ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
553 struct ModesChaChaCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
554 ASSERT_TRUE(ciphCtx != NULL);
555 // Check data dataLen
556 ASSERT_EQ(ciphCtx->chachaCtx.polyCtx.lastLen, 0);
557 uint32_t lastSize = (uint32_t)sizeof(ciphCtx->chachaCtx.polyCtx.last);
558 for (uint32_t i = 0; i < lastSize; i++) {
559 ASSERT_EQ(ciphCtx->chachaCtx.polyCtx.last[i], 0);
560 }
561 // Check aadLen cipherTextLen
562 ASSERT_EQ(ciphCtx->chachaCtx.aadLen, 0);
563 ASSERT_EQ(ciphCtx->chachaCtx.cipherTextLen, 0);
564 EXIT:
565 CRYPT_EAL_CipherDeinit(ctx);
566 CRYPT_EAL_CipherFreeCtx(ctx);
567 }
568 /* END_CASE */
569
570 /**
571 * @test SDV_CRYPTO_EAL_REINIT_TC003
572 */
573 /* BEGIN_CASE */
SDV_CRYPTO_EAL_REINIT_TC003(int id)574 void SDV_CRYPTO_EAL_REINIT_TC003(int id)
575 {
576 uint8_t key[16] = {0};
577 uint32_t keyLen = 16;
578 uint8_t iv[12] = {0};
579 uint32_t ivLen = 12;
580 uint8_t in[15] = {0};
581 uint32_t inLen = 15;
582 uint8_t out[64] = {0};
583 uint32_t outLen = 64;
584
585 CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
586 ASSERT_TRUE(ctx != NULL);
587 ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
588 ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
589 ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
590 struct ModesGcmCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
591 ASSERT_TRUE(ciphCtx != NULL);
592 // Check data dataLen
593 ASSERT_EQ(ciphCtx->gcmCtx.aadLen, 0);
594 ASSERT_EQ(ciphCtx->gcmCtx.lastLen, 0);
595 ASSERT_EQ(ciphCtx->gcmCtx.plaintextLen, 0);
596 for (uint32_t i = 0; i < GCM_BLOCKSIZE; i++) {
597 ASSERT_EQ(ciphCtx->gcmCtx.ghash[i], 0);
598 }
599 EXIT:
600 CRYPT_EAL_CipherDeinit(ctx);
601 CRYPT_EAL_CipherFreeCtx(ctx);
602 }
603 /* END_CASE */
604
605 /**
606 * @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC001
607 */
608 /* BEGIN_CASE */
SDV_CRYPTO_EAL_GET_KEY_LEN_TC001(int algid,int paramId,int pubLen,int prvLen,int sharedLen)609 void SDV_CRYPTO_EAL_GET_KEY_LEN_TC001(int algid, int paramId, int pubLen, int prvLen, int sharedLen)
610 {
611 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
612 ASSERT_TRUE(ctx != NULL);
613 int32_t ret;
614 if (paramId != 0) {
615 ret = CRYPT_EAL_PkeySetParaById(ctx, paramId);
616 ASSERT_EQ(ret, CRYPT_SUCCESS);
617 }
618
619 uint32_t val = 0;
620 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
621 ASSERT_EQ(ret, CRYPT_SUCCESS);
622 ASSERT_EQ(val, pubLen);
623
624 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
625 ASSERT_EQ(ret, CRYPT_SUCCESS);
626 ASSERT_EQ(val, prvLen);
627
628 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
629 ASSERT_EQ(ret, CRYPT_SUCCESS);
630 ASSERT_EQ(val, sharedLen);
631 EXIT:
632 CRYPT_EAL_PkeyFreeCtx(ctx);
633 }
634 /* END_CASE */
635
636 /**
637 * @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC002
638 */
639 /* BEGIN_CASE */
SDV_CRYPTO_EAL_GET_KEY_LEN_TC002(int algid,int paramId,int pubLen,int prvLen)640 void SDV_CRYPTO_EAL_GET_KEY_LEN_TC002(int algid, int paramId, int pubLen, int prvLen)
641 {
642 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
643 ASSERT_TRUE(ctx != NULL);
644 int32_t ret;
645 if (paramId != 0) {
646 ret = CRYPT_EAL_PkeySetParaById(ctx, paramId);
647 ASSERT_EQ(ret, CRYPT_SUCCESS);
648 }
649
650 uint32_t val = 0;
651 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
652 ASSERT_EQ(ret, CRYPT_SUCCESS);
653 ASSERT_EQ(val, pubLen);
654
655 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
656 ASSERT_EQ(ret, CRYPT_SUCCESS);
657 ASSERT_EQ(val, prvLen);
658 EXIT:
659 CRYPT_EAL_PkeyFreeCtx(ctx);
660 }
661 /* END_CASE */
662
663 /**
664 * @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC003
665 */
666 /* BEGIN_CASE */
SDV_CRYPTO_EAL_GET_KEY_LEN_TC003(int algid,int rsaBits,Hex * p,Hex * q,Hex * g)667 void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003(int algid, int rsaBits, Hex *p, Hex *q, Hex *g)
668 {
669 TestRandInit();
670 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
671 ASSERT_TRUE(ctx != NULL);
672 int32_t ret;
673 CRYPT_EAL_PkeyPara para = {0};
674 uint8_t e[3] = {1, 0, 1};
675 if (algid == CRYPT_PKEY_RSA) {
676 para.id = CRYPT_PKEY_RSA;
677 para.para.rsaPara.e = e;
678 para.para.rsaPara.eLen = 3;
679 para.para.rsaPara.bits = rsaBits;
680 } else {
681 para.id = algid; // DH or DSA
682 para.para.dhPara.p = p->x;
683 para.para.dhPara.q = q->x;
684 para.para.dhPara.g = g->x;
685 para.para.dhPara.pLen = p->len;
686 para.para.dhPara.qLen = q->len;
687 para.para.dhPara.gLen = g->len;
688 }
689 ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
690 ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
691
692 uint32_t val = 0;
693 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
694 ASSERT_EQ(ret, CRYPT_SUCCESS);
695
696 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
697 ASSERT_EQ(ret, CRYPT_SUCCESS);
698
699 if (algid == CRYPT_PKEY_DH) {
700 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
701 ASSERT_EQ(ret, CRYPT_SUCCESS);
702 }
703 EXIT:
704 CRYPT_EAL_PkeyFreeCtx(ctx);
705 }
706 /* END_CASE */
707