1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hks_ecdh_agree_part1_test.h"
17 #include "hks_ecdh_agree_test_common.h"
18
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace Unittest::EcdhAgree {
23 class HksEcdhAgreePart1Test : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26
27 static void TearDownTestCase(void);
28
29 void SetUp();
30
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void HksEcdhAgreePart1Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksEcdhAgreePart1Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksEcdhAgreePart1Test::SetUp()
43 {
44 }
45
TearDown()46 void HksEcdhAgreePart1Test::TearDown()
47 {
48 }
49
50 static struct HksBlob g_keyAlias01001 = {
51 strlen("HksECDHAgreeKeyAliasTest001_1"),
52 (uint8_t *)"HksECDHAgreeKeyAliasTest001_1"
53 };
54 static struct HksBlob g_keyAlias02001 = {
55 strlen("HksECDHAgreeKeyAliasTest001_2"),
56 (uint8_t *)"HksECDHAgreeKeyAliasTest001_2"
57 };
58 static struct HksBlob g_keyAliasFinal1001 = {
59 strlen("HksECDHAgreeKeyAliasTest001_1_final"),
60 (uint8_t *)"HksECDHAgreeKeyAliasTest001_1_final"
61 };
62 static struct HksBlob g_keyAliasFinal2001 = {
63 strlen("HksECDHAgreeKeyAliasTest001_2_final"),
64 (uint8_t *)"HksECDHAgreeKeyAliasTest001_2_final"
65 };
66 static struct HksParam g_genParams001[] = {
67 {
68 .tag = HKS_TAG_ALGORITHM,
69 .uint32Param = HKS_ALG_ECC
70 }, {
71 .tag = HKS_TAG_PURPOSE,
72 .uint32Param = HKS_KEY_PURPOSE_AGREE
73 }, {
74 .tag = HKS_TAG_KEY_SIZE,
75 .uint32Param = HKS_ECC_KEY_SIZE_224
76 }, {
77 .tag = HKS_TAG_DIGEST,
78 .uint32Param = HKS_DIGEST_NONE
79 }, {
80 .tag = HKS_TAG_PADDING,
81 .uint32Param = HKS_PADDING_NONE
82 }, {
83 .tag = HKS_TAG_BLOCK_MODE,
84 .uint32Param = HKS_MODE_CBC
85 }
86 };
87 static struct HksParam g_agreeParams01Init001[] = {
88 {
89 .tag = HKS_TAG_ALGORITHM,
90 .uint32Param = HKS_ALG_ECDH
91 }, {
92 .tag = HKS_TAG_PURPOSE,
93 .uint32Param = HKS_KEY_PURPOSE_AGREE
94 }, {
95 .tag = HKS_TAG_KEY_SIZE,
96 .uint32Param = HKS_ECC_KEY_SIZE_224
97 }
98 };
99 static struct HksParam g_agreeParams01Finish001[] = {
100 {
101 .tag = HKS_TAG_KEY_STORAGE_FLAG,
102 .uint32Param = HKS_STORAGE_PERSISTENT
103 }, {
104 .tag = HKS_TAG_IS_KEY_ALIAS,
105 .boolParam = true
106 }, {
107 .tag = HKS_TAG_ALGORITHM,
108 .uint32Param = HKS_ALG_AES
109 }, {
110 .tag = HKS_TAG_KEY_SIZE,
111 .uint32Param = HKS_AES_KEY_SIZE_256
112 }, {
113 .tag = HKS_TAG_PURPOSE,
114 .uint32Param = HKS_KEY_PURPOSE_DERIVE
115 }, {
116 .tag = HKS_TAG_DIGEST,
117 .uint32Param = HKS_DIGEST_SHA256
118 }, {
119 .tag = HKS_TAG_KEY_ALIAS,
120 .blob = g_keyAliasFinal1001
121 }, {
122 .tag = HKS_TAG_PADDING,
123 .uint32Param = HKS_PADDING_NONE
124 }, {
125 .tag = HKS_TAG_BLOCK_MODE,
126 .uint32Param = HKS_MODE_CBC
127 }
128 };
129 static struct HksParam g_agreeParams02Init001[] = {
130 {
131 .tag = HKS_TAG_ALGORITHM,
132 .uint32Param = HKS_ALG_ECDH
133 }, {
134 .tag = HKS_TAG_PURPOSE,
135 .uint32Param = HKS_KEY_PURPOSE_AGREE
136 }, {
137 .tag = HKS_TAG_KEY_SIZE,
138 .uint32Param = HKS_ECC_KEY_SIZE_224
139 }
140 };
141 static struct HksParam g_agreeParams02Finish001[] = {
142 {
143 .tag = HKS_TAG_KEY_STORAGE_FLAG,
144 .uint32Param = HKS_STORAGE_PERSISTENT
145 }, {
146 .tag = HKS_TAG_IS_KEY_ALIAS,
147 .boolParam = true
148 }, {
149 .tag = HKS_TAG_ALGORITHM,
150 .uint32Param = HKS_ALG_AES
151 }, {
152 .tag = HKS_TAG_KEY_SIZE,
153 .uint32Param = HKS_AES_KEY_SIZE_256
154 }, {
155 .tag = HKS_TAG_PURPOSE,
156 .uint32Param = HKS_KEY_PURPOSE_DERIVE
157 }, {
158 .tag = HKS_TAG_DIGEST,
159 .uint32Param = HKS_DIGEST_SHA256
160 }, {
161 .tag = HKS_TAG_KEY_ALIAS,
162 .blob = g_keyAliasFinal2001
163 }, {
164 .tag = HKS_TAG_PADDING,
165 .uint32Param = HKS_PADDING_NONE
166 }, {
167 .tag = HKS_TAG_BLOCK_MODE,
168 .uint32Param = HKS_MODE_CBC
169 }
170 };
171
172 static struct HksBlob g_keyAlias01002 = {
173 strlen("HksECDHAgreeKeyAliasTest002_1"),
174 (uint8_t *)"HksECDHAgreeKeyAliasTest002_1"
175 };
176 static struct HksBlob g_keyAlias02002 = {
177 strlen("HksECDHAgreeKeyAliasTest002_2"),
178 (uint8_t *)"HksECDHAgreeKeyAliasTest002_2"
179 };
180 static struct HksBlob g_keyAliasFinal1002 = {
181 strlen("HksECDHAgreeKeyAliasTest002_1_final"),
182 (uint8_t *)"HksECDHAgreeKeyAliasTest002_1_final"
183 };
184 static struct HksBlob g_keyAliasFinal2002 = {
185 strlen("HksECDHAgreeKeyAliasTest002_2_final"),
186 (uint8_t *)"HksECDHAgreeKeyAliasTest002_2_final"
187 };
188 static struct HksParam g_genParams002[] = {
189 {
190 .tag = HKS_TAG_ALGORITHM,
191 .uint32Param = HKS_ALG_ECC
192 }, {
193 .tag = HKS_TAG_PURPOSE,
194 .uint32Param = HKS_KEY_PURPOSE_AGREE
195 }, {
196 .tag = HKS_TAG_KEY_SIZE,
197 .uint32Param = HKS_ECC_KEY_SIZE_256
198 }, {
199 .tag = HKS_TAG_DIGEST,
200 .uint32Param = HKS_DIGEST_NONE
201 }, {
202 .tag = HKS_TAG_PADDING,
203 .uint32Param = HKS_PADDING_NONE
204 }, {
205 .tag = HKS_TAG_BLOCK_MODE,
206 .uint32Param = HKS_MODE_CBC
207 }
208 };
209 static struct HksParam g_agreeParams01Init002[] = {
210 {
211 .tag = HKS_TAG_ALGORITHM,
212 .uint32Param = HKS_ALG_ECDH
213 }, {
214 .tag = HKS_TAG_PURPOSE,
215 .uint32Param = HKS_KEY_PURPOSE_AGREE
216 }, {
217 .tag = HKS_TAG_KEY_SIZE,
218 .uint32Param = HKS_ECC_KEY_SIZE_256
219 }
220 };
221 static struct HksParam g_agreeParams01Finish002[] = {
222 {
223 .tag = HKS_TAG_KEY_STORAGE_FLAG,
224 .uint32Param = HKS_STORAGE_PERSISTENT
225 }, {
226 .tag = HKS_TAG_IS_KEY_ALIAS,
227 .boolParam = true
228 }, {
229 .tag = HKS_TAG_ALGORITHM,
230 .uint32Param = HKS_ALG_AES
231 }, {
232 .tag = HKS_TAG_KEY_SIZE,
233 .uint32Param = HKS_AES_KEY_SIZE_256
234 }, {
235 .tag = HKS_TAG_PURPOSE,
236 .uint32Param = HKS_KEY_PURPOSE_DERIVE
237 }, {
238 .tag = HKS_TAG_DIGEST,
239 .uint32Param = HKS_DIGEST_SHA256
240 }, {
241 .tag = HKS_TAG_KEY_ALIAS,
242 .blob = g_keyAliasFinal1002
243 }, {
244 .tag = HKS_TAG_PADDING,
245 .uint32Param = HKS_PADDING_NONE
246 }, {
247 .tag = HKS_TAG_BLOCK_MODE,
248 .uint32Param = HKS_MODE_CBC
249 }
250 };
251 static struct HksParam g_agreeParams02Init002[] = {
252 {
253 .tag = HKS_TAG_ALGORITHM,
254 .uint32Param = HKS_ALG_ECDH
255 }, {
256 .tag = HKS_TAG_PURPOSE,
257 .uint32Param = HKS_KEY_PURPOSE_AGREE
258 }, {
259 .tag = HKS_TAG_KEY_SIZE,
260 .uint32Param = HKS_ECC_KEY_SIZE_256
261 }
262 };
263 static struct HksParam g_agreeParams02Finish002[] = {
264 {
265 .tag = HKS_TAG_KEY_STORAGE_FLAG,
266 .uint32Param = HKS_STORAGE_PERSISTENT
267 }, {
268 .tag = HKS_TAG_IS_KEY_ALIAS,
269 .boolParam = true
270 }, {
271 .tag = HKS_TAG_ALGORITHM,
272 .uint32Param = HKS_ALG_AES
273 }, {
274 .tag = HKS_TAG_KEY_SIZE,
275 .uint32Param = HKS_AES_KEY_SIZE_256
276 }, {
277 .tag = HKS_TAG_PURPOSE,
278 .uint32Param = HKS_KEY_PURPOSE_DERIVE
279 }, {
280 .tag = HKS_TAG_DIGEST,
281 .uint32Param = HKS_DIGEST_SHA256
282 }, {
283 .tag = HKS_TAG_KEY_ALIAS,
284 .blob = g_keyAliasFinal2002
285 }, {
286 .tag = HKS_TAG_PADDING,
287 .uint32Param = HKS_PADDING_NONE
288 }, {
289 .tag = HKS_TAG_BLOCK_MODE,
290 .uint32Param = HKS_MODE_CBC
291 }
292 };
293
294 static struct HksBlob g_keyAlias01003 = {
295 strlen("HksECDHAgreeKeyAliasTest003_1"),
296 (uint8_t *)"HksECDHAgreeKeyAliasTest003_1"
297 };
298 static struct HksBlob g_keyAlias02003 = {
299 strlen("HksECDHAgreeKeyAliasTest003_2"),
300 (uint8_t *)"HksECDHAgreeKeyAliasTest003_2"
301 };
302 static struct HksBlob g_keyAliasFinal1003 = {
303 strlen("HksECDHAgreeKeyAliasTest003_1_final"),
304 (uint8_t *)"HksECDHAgreeKeyAliasTest003_1_final"
305 };
306 static struct HksBlob g_keyAliasFinal2003 = {
307 strlen("HksECDHAgreeKeyAliasTest003_2_final"),
308 (uint8_t *)"HksECDHAgreeKeyAliasTest003_2_final"
309 };
310 static struct HksParam g_genParams003[] = {
311 {
312 .tag = HKS_TAG_ALGORITHM,
313 .uint32Param = HKS_ALG_ECC
314 }, {
315 .tag = HKS_TAG_PURPOSE,
316 .uint32Param = HKS_KEY_PURPOSE_AGREE
317 }, {
318 .tag = HKS_TAG_KEY_SIZE,
319 .uint32Param = HKS_ECC_KEY_SIZE_384
320 }, {
321 .tag = HKS_TAG_DIGEST,
322 .uint32Param = HKS_DIGEST_NONE
323 }, {
324 .tag = HKS_TAG_PADDING,
325 .uint32Param = HKS_PADDING_NONE
326 }, {
327 .tag = HKS_TAG_BLOCK_MODE,
328 .uint32Param = HKS_MODE_CBC
329 }
330 };
331 static struct HksParam g_agreeParams01Init003[] = {
332 {
333 .tag = HKS_TAG_ALGORITHM,
334 .uint32Param = HKS_ALG_ECDH
335 }, {
336 .tag = HKS_TAG_PURPOSE,
337 .uint32Param = HKS_KEY_PURPOSE_AGREE
338 }, {
339 .tag = HKS_TAG_KEY_SIZE,
340 .uint32Param = HKS_ECC_KEY_SIZE_384
341 }
342 };
343 static struct HksParam g_agreeParams01Finish003[] = {
344 {
345 .tag = HKS_TAG_KEY_STORAGE_FLAG,
346 .uint32Param = HKS_STORAGE_PERSISTENT
347 }, {
348 .tag = HKS_TAG_IS_KEY_ALIAS,
349 .boolParam = true
350 }, {
351 .tag = HKS_TAG_ALGORITHM,
352 .uint32Param = HKS_ALG_AES
353 }, {
354 .tag = HKS_TAG_KEY_SIZE,
355 .uint32Param = HKS_AES_KEY_SIZE_256
356 }, {
357 .tag = HKS_TAG_PURPOSE,
358 .uint32Param = HKS_KEY_PURPOSE_DERIVE
359 }, {
360 .tag = HKS_TAG_DIGEST,
361 .uint32Param = HKS_DIGEST_SHA256
362 }, {
363 .tag = HKS_TAG_KEY_ALIAS,
364 .blob = g_keyAliasFinal1003
365 }, {
366 .tag = HKS_TAG_PADDING,
367 .uint32Param = HKS_PADDING_NONE
368 }, {
369 .tag = HKS_TAG_BLOCK_MODE,
370 .uint32Param = HKS_MODE_CBC
371 }
372 };
373 static struct HksParam g_agreeParams02Init003[] = {
374 {
375 .tag = HKS_TAG_ALGORITHM,
376 .uint32Param = HKS_ALG_ECDH
377 }, {
378 .tag = HKS_TAG_PURPOSE,
379 .uint32Param = HKS_KEY_PURPOSE_AGREE
380 }, {
381 .tag = HKS_TAG_KEY_SIZE,
382 .uint32Param = HKS_ECC_KEY_SIZE_384
383 }
384 };
385 static struct HksParam g_agreeParams02Finish003[] = {
386 {
387 .tag = HKS_TAG_KEY_STORAGE_FLAG,
388 .uint32Param = HKS_STORAGE_PERSISTENT
389 }, {
390 .tag = HKS_TAG_IS_KEY_ALIAS,
391 .boolParam = true
392 }, {
393 .tag = HKS_TAG_ALGORITHM,
394 .uint32Param = HKS_ALG_AES
395 }, {
396 .tag = HKS_TAG_KEY_SIZE,
397 .uint32Param = HKS_AES_KEY_SIZE_256
398 }, {
399 .tag = HKS_TAG_PURPOSE,
400 .uint32Param = HKS_KEY_PURPOSE_DERIVE
401 }, {
402 .tag = HKS_TAG_DIGEST,
403 .uint32Param = HKS_DIGEST_SHA256
404 }, {
405 .tag = HKS_TAG_KEY_ALIAS,
406 .blob = g_keyAliasFinal2003
407 }, {
408 .tag = HKS_TAG_PADDING,
409 .uint32Param = HKS_PADDING_NONE
410 }, {
411 .tag = HKS_TAG_BLOCK_MODE,
412 .uint32Param = HKS_MODE_CBC
413 }
414 };
415
416 static struct HksBlob g_keyAlias01004 = {
417 strlen("HksECDHAgreeKeyAliasTest004_1"),
418 (uint8_t *)"HksECDHAgreeKeyAliasTest004_1"
419 };
420 static struct HksBlob g_keyAlias02004 = {
421 strlen("HksECDHAgreeKeyAliasTest004_2"),
422 (uint8_t *)"HksECDHAgreeKeyAliasTest004_2"
423 };
424 static struct HksBlob g_keyAliasFinal1004 = {
425 strlen("HksECDHAgreeKeyAliasTest004_1_final"),
426 (uint8_t *)"HksECDHAgreeKeyAliasTest004_1_final"
427 };
428 static struct HksBlob g_keyAliasFinal2004 = {
429 strlen("HksECDHAgreeKeyAliasTest004_2_final"),
430 (uint8_t *)"HksECDHAgreeKeyAliasTest004_2_final"
431 };
432 static struct HksParam g_genParams004[] = {
433 {
434 .tag = HKS_TAG_ALGORITHM,
435 .uint32Param = HKS_ALG_ECC
436 }, {
437 .tag = HKS_TAG_PURPOSE,
438 .uint32Param = HKS_KEY_PURPOSE_AGREE
439 }, {
440 .tag = HKS_TAG_KEY_SIZE,
441 .uint32Param = HKS_ECC_KEY_SIZE_521
442 }, {
443 .tag = HKS_TAG_DIGEST,
444 .uint32Param = HKS_DIGEST_NONE
445 }, {
446 .tag = HKS_TAG_PADDING,
447 .uint32Param = HKS_PADDING_NONE
448 }, {
449 .tag = HKS_TAG_BLOCK_MODE,
450 .uint32Param = HKS_MODE_CBC
451 }
452 };
453 static struct HksParam g_agreeParams01Init004[] = {
454 {
455 .tag = HKS_TAG_ALGORITHM,
456 .uint32Param = HKS_ALG_ECDH
457 }, {
458 .tag = HKS_TAG_PURPOSE,
459 .uint32Param = HKS_KEY_PURPOSE_AGREE
460 }, {
461 .tag = HKS_TAG_KEY_SIZE,
462 .uint32Param = HKS_ECC_KEY_SIZE_521
463 }
464 };
465 static struct HksParam g_agreeParams01Finish004[] = {
466 {
467 .tag = HKS_TAG_KEY_STORAGE_FLAG,
468 .uint32Param = HKS_STORAGE_PERSISTENT
469 }, {
470 .tag = HKS_TAG_IS_KEY_ALIAS,
471 .boolParam = true
472 }, {
473 .tag = HKS_TAG_ALGORITHM,
474 .uint32Param = HKS_ALG_AES
475 }, {
476 .tag = HKS_TAG_KEY_SIZE,
477 .uint32Param = HKS_AES_KEY_SIZE_256
478 }, {
479 .tag = HKS_TAG_PURPOSE,
480 .uint32Param = HKS_KEY_PURPOSE_DERIVE
481 }, {
482 .tag = HKS_TAG_DIGEST,
483 .uint32Param = HKS_DIGEST_SHA256
484 }, {
485 .tag = HKS_TAG_KEY_ALIAS,
486 .blob = g_keyAliasFinal1004
487 }, {
488 .tag = HKS_TAG_PADDING,
489 .uint32Param = HKS_PADDING_NONE
490 }, {
491 .tag = HKS_TAG_BLOCK_MODE,
492 .uint32Param = HKS_MODE_CBC
493 }
494 };
495 static struct HksParam g_agreeParams02Init004[] = {
496 {
497 .tag = HKS_TAG_ALGORITHM,
498 .uint32Param = HKS_ALG_ECDH
499 }, {
500 .tag = HKS_TAG_PURPOSE,
501 .uint32Param = HKS_KEY_PURPOSE_AGREE
502 }, {
503 .tag = HKS_TAG_KEY_SIZE,
504 .uint32Param = HKS_ECC_KEY_SIZE_521
505 }
506 };
507 static struct HksParam g_agreeParams02Finish004[] = {
508 {
509 .tag = HKS_TAG_KEY_STORAGE_FLAG,
510 .uint32Param = HKS_STORAGE_PERSISTENT
511 }, {
512 .tag = HKS_TAG_IS_KEY_ALIAS,
513 .boolParam = true
514 }, {
515 .tag = HKS_TAG_ALGORITHM,
516 .uint32Param = HKS_ALG_AES
517 }, {
518 .tag = HKS_TAG_KEY_SIZE,
519 .uint32Param = HKS_AES_KEY_SIZE_256
520 }, {
521 .tag = HKS_TAG_PURPOSE,
522 .uint32Param = HKS_KEY_PURPOSE_DERIVE
523 }, {
524 .tag = HKS_TAG_DIGEST,
525 .uint32Param = HKS_DIGEST_SHA256
526 }, {
527 .tag = HKS_TAG_KEY_ALIAS,
528 .blob = g_keyAliasFinal2004
529 }, {
530 .tag = HKS_TAG_PADDING,
531 .uint32Param = HKS_PADDING_NONE
532 }, {
533 .tag = HKS_TAG_BLOCK_MODE,
534 .uint32Param = HKS_MODE_CBC
535 }
536 };
537
538 static struct HksBlob g_keyAlias01005 = {
539 strlen("HksECDHAgreeKeyAliasTest005_1"),
540 (uint8_t *)"HksECDHAgreeKeyAliasTest005_1"
541 };
542 static struct HksBlob g_keyAlias02005 = {
543 strlen("HksECDHAgreeKeyAliasTest005_2"),
544 (uint8_t *)"HksECDHAgreeKeyAliasTest005_2"
545 };
546 static struct HksParam g_genParams005[] = {
547 {
548 .tag = HKS_TAG_ALGORITHM,
549 .uint32Param = HKS_ALG_ECC
550 }, {
551 .tag = HKS_TAG_PURPOSE,
552 .uint32Param = HKS_KEY_PURPOSE_AGREE
553 }, {
554 .tag = HKS_TAG_KEY_SIZE,
555 .uint32Param = HKS_ECC_KEY_SIZE_224
556 }, {
557 .tag = HKS_TAG_DIGEST,
558 .uint32Param = HKS_DIGEST_NONE
559 }, {
560 .tag = HKS_TAG_PADDING,
561 .uint32Param = HKS_PADDING_NONE
562 }, {
563 .tag = HKS_TAG_BLOCK_MODE,
564 .uint32Param = HKS_MODE_CBC
565 }
566 };
567 static struct HksParam g_agreeParams01Init005[] = {
568 {
569 .tag = HKS_TAG_ALGORITHM,
570 .uint32Param = HKS_ALG_ECDH
571 }, {
572 .tag = HKS_TAG_PURPOSE,
573 .uint32Param = HKS_KEY_PURPOSE_AGREE
574 }, {
575 .tag = HKS_TAG_KEY_SIZE,
576 .uint32Param = HKS_ECC_KEY_SIZE_224
577 }
578 };
579 static struct HksParam g_agreeParams01Finish005[] = {
580 {
581 .tag = HKS_TAG_KEY_STORAGE_FLAG,
582 .uint32Param = HKS_STORAGE_TEMP
583 }
584 };
585 static struct HksParam g_agreeParams02Init005[] = {
586 {
587 .tag = HKS_TAG_ALGORITHM,
588 .uint32Param = HKS_ALG_ECDH
589 }, {
590 .tag = HKS_TAG_PURPOSE,
591 .uint32Param = HKS_KEY_PURPOSE_AGREE
592 }, {
593 .tag = HKS_TAG_KEY_SIZE,
594 .uint32Param = HKS_ECC_KEY_SIZE_224
595 }
596 };
597 static struct HksParam g_agreeParams02Finish005[] = {
598 {
599 .tag = HKS_TAG_KEY_STORAGE_FLAG,
600 .uint32Param = HKS_STORAGE_TEMP
601 }
602 };
603
604 /**
605 * @tc.name: HksEcdhAgreePart1Test.HksEcdhAgree001
606 * @tc.desc: alg-ECDH, pur-AGREE
607 * @tc.type: FUNC
608 */
609 HWTEST_F(HksEcdhAgreePart1Test, HksEcdhAgree001, TestSize.Level0)
610 {
611 struct HksParamSet *genParamSet = nullptr;
612 struct HksParamSet *initParamSet01 = nullptr;
613 struct HksParamSet *finishParamSet01 = nullptr;
614 struct HksParamSet *initParamSet02 = nullptr;
615 struct HksParamSet *finishParamSet02 = nullptr;
616 int32_t ret = InitParamSet(&genParamSet, g_genParams001, sizeof(g_genParams001)/sizeof(HksParam));
617 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
618 ret = InitParamSet(&initParamSet01, g_agreeParams01Init001, sizeof(g_agreeParams01Init001)/sizeof(HksParam));
619 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
620 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish001, sizeof(g_agreeParams01Finish001)/sizeof(HksParam));
621 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
622 ret = InitParamSet(&initParamSet02, g_agreeParams02Init001, sizeof(g_agreeParams02Init001)/sizeof(HksParam));
623 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
624 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish001, sizeof(g_agreeParams02Finish001)/sizeof(HksParam));
625 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
626
627 ret = HksGenerateKey(&g_keyAlias01001, genParamSet, nullptr);
628 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
629 ret = HksGenerateKey(&g_keyAlias02001, genParamSet, nullptr);
630 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
631
632 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_224, .data = nullptr };
633 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_224, .data = nullptr };
634 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
635 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
636 ret = HksEcdhAgreeExport(&g_keyAlias01001, &g_keyAlias02001, &publicKey01, &publicKey02, genParamSet);
637 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
638
639 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
640 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
641 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
642 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
643 ret = HksEcdhAgreeFinish(&g_keyAlias01001, &publicKey02, initParamSet01, finishParamSet01, &outData01);
644 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
645 ret = HksEcdhAgreeFinish(&g_keyAlias02001, &publicKey01, initParamSet02, finishParamSet02, &outData02);
646 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish02 failed.";
647 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
648
649 HksDeleteKey(&g_keyAlias01001, genParamSet);
650 HksDeleteKey(&g_keyAlias02001, genParamSet);
651 HksDeleteKey(&g_keyAliasFinal1001, NULL);
652 HksDeleteKey(&g_keyAliasFinal2001, NULL);
653 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
654 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
655 }
656
657 /**
658 * @tc.name: HksEcdhAgreePart1Test.HksEcdhAgree002
659 * @tc.desc: alg-EDCH, pur-AGREE, size-256
660 * @tc.type: FUNC
661 */
662 HWTEST_F(HksEcdhAgreePart1Test, HksEcdhAgree002, TestSize.Level0)
663 {
664 struct HksParamSet *genParamSet = nullptr;
665 struct HksParamSet *initParamSet01 = nullptr;
666 struct HksParamSet *finishParamSet01 = nullptr;
667 struct HksParamSet *initParamSet02 = nullptr;
668 struct HksParamSet *finishParamSet02 = nullptr;
669 int32_t ret = InitParamSet(&genParamSet, g_genParams002, sizeof(g_genParams002)/sizeof(HksParam));
670 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
671 ret = InitParamSet(&initParamSet01, g_agreeParams01Init002, sizeof(g_agreeParams01Init002)/sizeof(HksParam));
672 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
673 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish002, sizeof(g_agreeParams01Finish002)/sizeof(HksParam));
674 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
675 ret = InitParamSet(&initParamSet02, g_agreeParams02Init002, sizeof(g_agreeParams02Init002)/sizeof(HksParam));
676 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
677 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish002, sizeof(g_agreeParams02Finish002)/sizeof(HksParam));
678 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
679
680 ret = HksGenerateKey(&g_keyAlias01002, genParamSet, nullptr);
681 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
682 ret = HksGenerateKey(&g_keyAlias02002, genParamSet, nullptr);
683 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
684
685 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_256, .data = nullptr };
686 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_256, .data = nullptr };
687 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
688 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
689 ret = HksEcdhAgreeExport(&g_keyAlias01002, &g_keyAlias02002, &publicKey01, &publicKey02, genParamSet);
690 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
691
692 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
693 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
694 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
695 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
696 ret = HksEcdhAgreeFinish(&g_keyAlias01002, &publicKey02, initParamSet01, finishParamSet01, &outData01);
697 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
698 ret = HksEcdhAgreeFinish(&g_keyAlias02002, &publicKey01, initParamSet02, finishParamSet02, &outData02);
699 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish02 failed.";
700 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
701
702 HksDeleteKey(&g_keyAlias01002, genParamSet);
703 HksDeleteKey(&g_keyAlias02002, genParamSet);
704 HksDeleteKey(&g_keyAliasFinal1002, NULL);
705 HksDeleteKey(&g_keyAliasFinal2002, NULL);
706 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
707 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
708 }
709
710 /**
711 * @tc.name: HksEcdhAgreePart1Test.HksEcdhAgree003
712 * @tc.desc: alg-EDCH, pur-AGREE, size-256
713 * @tc.type: FUNC
714 */
715 HWTEST_F(HksEcdhAgreePart1Test, HksEcdhAgree003, TestSize.Level0)
716 {
717 struct HksParamSet *genParamSet = nullptr;
718 struct HksParamSet *initParamSet01 = nullptr;
719 struct HksParamSet *finishParamSet01 = nullptr;
720 struct HksParamSet *initParamSet02 = nullptr;
721 struct HksParamSet *finishParamSet02 = nullptr;
722 int32_t ret = InitParamSet(&genParamSet, g_genParams003, sizeof(g_genParams003)/sizeof(HksParam));
723 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
724 ret = InitParamSet(&initParamSet01, g_agreeParams01Init003, sizeof(g_agreeParams01Init003)/sizeof(HksParam));
725 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
726 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish003, sizeof(g_agreeParams01Finish003)/sizeof(HksParam));
727 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
728 ret = InitParamSet(&initParamSet02, g_agreeParams02Init003, sizeof(g_agreeParams02Init003)/sizeof(HksParam));
729 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
730 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish003, sizeof(g_agreeParams02Finish003)/sizeof(HksParam));
731 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
732
733 ret = HksGenerateKey(&g_keyAlias01003, genParamSet, nullptr);
734 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
735 ret = HksGenerateKey(&g_keyAlias02003, genParamSet, nullptr);
736 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
737
738 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_384, .data = nullptr };
739 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_384, .data = nullptr };
740 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
741 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
742 ret = HksEcdhAgreeExport(&g_keyAlias01003, &g_keyAlias02003, &publicKey01, &publicKey02, genParamSet);
743 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
744
745 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
746 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
747 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
748 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
749 ret = HksEcdhAgreeFinish(&g_keyAlias01003, &publicKey02, initParamSet01, finishParamSet01, &outData01);
750 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
751 ret = HksEcdhAgreeFinish(&g_keyAlias02003, &publicKey01, initParamSet02, finishParamSet02, &outData02);
752 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish02 failed.";
753 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
754
755 HksDeleteKey(&g_keyAlias01003, genParamSet);
756 HksDeleteKey(&g_keyAlias02003, genParamSet);
757 HksDeleteKey(&g_keyAliasFinal1003, NULL);
758 HksDeleteKey(&g_keyAliasFinal2003, NULL);
759 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
760 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
761 }
762
763 /**
764 * @tc.name: HksEcdhAgreePart1Test.HksEcdhAgree004
765 * @tc.desc: alg-EDCH, pur-AGREE, size-384
766 * @tc.type: FUNC
767 */
768 HWTEST_F(HksEcdhAgreePart1Test, HksEcdhAgree004, TestSize.Level0)
769 {
770 struct HksParamSet *genParamSet = nullptr;
771 struct HksParamSet *initParamSet01 = nullptr;
772 struct HksParamSet *finishParamSet01 = nullptr;
773 struct HksParamSet *initParamSet02 = nullptr;
774 struct HksParamSet *finishParamSet02 = nullptr;
775 int32_t ret = InitParamSet(&genParamSet, g_genParams004, sizeof(g_genParams004)/sizeof(HksParam));
776 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
777 ret = InitParamSet(&initParamSet01, g_agreeParams01Init004, sizeof(g_agreeParams01Init004)/sizeof(HksParam));
778 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
779 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish004, sizeof(g_agreeParams01Finish004)/sizeof(HksParam));
780 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
781 ret = InitParamSet(&initParamSet02, g_agreeParams02Init004, sizeof(g_agreeParams02Init004)/sizeof(HksParam));
782 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
783 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish004, sizeof(g_agreeParams02Finish004)/sizeof(HksParam));
784 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
785
786 ret = HksGenerateKey(&g_keyAlias01004, genParamSet, nullptr);
787 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
788 ret = HksGenerateKey(&g_keyAlias02004, genParamSet, nullptr);
789 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
790
791 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
792 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
793 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
794 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
795 ret = HksEcdhAgreeExport(&g_keyAlias01004, &g_keyAlias02004, &publicKey01, &publicKey02, genParamSet);
796 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
797
798 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
799 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
800 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
801 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
802 ret = HksEcdhAgreeFinish(&g_keyAlias01004, &publicKey02, initParamSet01, finishParamSet01, &outData01);
803 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
804 ret = HksEcdhAgreeFinish(&g_keyAlias02004, &publicKey01, initParamSet02, finishParamSet02, &outData02);
805 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish02 failed.";
806 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
807
808 HksDeleteKey(&g_keyAlias01004, genParamSet);
809 HksDeleteKey(&g_keyAlias02004, genParamSet);
810 HksDeleteKey(&g_keyAliasFinal1004, NULL);
811 HksDeleteKey(&g_keyAliasFinal2004, NULL);
812 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
813 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
814 }
815
816 /**
817 * @tc.name: HksEcdhAgreePart1Test.HksEcdhAgree005
818 * @tc.desc: alg-EDCH, pur-AGREE, size-521
819 * @tc.type: FUNC
820 */
821 HWTEST_F(HksEcdhAgreePart1Test, HksEcdhAgree005, TestSize.Level0)
822 {
823 struct HksParamSet *genParamSet = nullptr;
824 struct HksParamSet *initParamSet01 = nullptr;
825 struct HksParamSet *finishParamSet01 = nullptr;
826 struct HksParamSet *initParamSet02 = nullptr;
827 struct HksParamSet *finishParamSet02 = nullptr;
828 int32_t ret = InitParamSet(&genParamSet, g_genParams005, sizeof(g_genParams005)/sizeof(HksParam));
829 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
830 ret = InitParamSet(&initParamSet01, g_agreeParams01Init005, sizeof(g_agreeParams01Init005)/sizeof(HksParam));
831 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
832 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish005, sizeof(g_agreeParams01Finish005)/sizeof(HksParam));
833 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
834 ret = InitParamSet(&initParamSet02, g_agreeParams02Init005, sizeof(g_agreeParams02Init005)/sizeof(HksParam));
835 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
836 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish005, sizeof(g_agreeParams02Finish005)/sizeof(HksParam));
837 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
838
839 ret = HksGenerateKey(&g_keyAlias01005, genParamSet, nullptr);
840 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
841 ret = HksGenerateKey(&g_keyAlias02005, genParamSet, nullptr);
842 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
843
844 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_224, .data = nullptr };
845 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_224, .data = nullptr };
846 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
847 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
848 ret = HksEcdhAgreeExport(&g_keyAlias01005, &g_keyAlias02005, &publicKey01, &publicKey02, genParamSet);
849 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
850
851 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
852 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
853 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
854 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
855 ret = HksEcdhAgreeFinish(&g_keyAlias01005, &publicKey02, initParamSet01, finishParamSet01, &outData01);
856 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
857 ret = HksAgreeKey(initParamSet02, &g_keyAlias02005, &publicKey01, &outData02);
858 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAgreeKey02 failed.";
859 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
860
861 HksDeleteKey(&g_keyAlias01005, genParamSet);
862 HksDeleteKey(&g_keyAlias02005, genParamSet);
863 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
864 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
865 }
866 }