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_part2_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 HksEcdhAgreePart2Test : 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 HksEcdhAgreePart2Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksEcdhAgreePart2Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksEcdhAgreePart2Test::SetUp()
43 {
44 }
45
TearDown()46 void HksEcdhAgreePart2Test::TearDown()
47 {
48 }
49
50 static struct HksBlob g_keyAlias01006 = {
51 strlen("HksECDHAgreeKeyAliasTest006_1"),
52 (uint8_t *)"HksECDHAgreeKeyAliasTest006_1"
53 };
54 static struct HksBlob g_keyAlias02006 = {
55 strlen("HksECDHAgreeKeyAliasTest006_2"),
56 (uint8_t *)"HksECDHAgreeKeyAliasTest006_2"
57 };
58 static struct HksParam g_genParams006[] = {
59 {
60 .tag = HKS_TAG_ALGORITHM,
61 .uint32Param = HKS_ALG_ECC
62 }, {
63 .tag = HKS_TAG_PURPOSE,
64 .uint32Param = HKS_KEY_PURPOSE_AGREE
65 }, {
66 .tag = HKS_TAG_KEY_SIZE,
67 .uint32Param = HKS_ECC_KEY_SIZE_256
68 }, {
69 .tag = HKS_TAG_DIGEST,
70 .uint32Param = HKS_DIGEST_NONE
71 }, {
72 .tag = HKS_TAG_PADDING,
73 .uint32Param = HKS_PADDING_NONE
74 }, {
75 .tag = HKS_TAG_BLOCK_MODE,
76 .uint32Param = HKS_MODE_CBC
77 }
78 };
79 static struct HksParam g_agreeParams01Init006[] = {
80 {
81 .tag = HKS_TAG_ALGORITHM,
82 .uint32Param = HKS_ALG_ECDH
83 }, {
84 .tag = HKS_TAG_PURPOSE,
85 .uint32Param = HKS_KEY_PURPOSE_AGREE
86 }, {
87 .tag = HKS_TAG_KEY_SIZE,
88 .uint32Param = HKS_ECC_KEY_SIZE_256
89 }
90 };
91 static struct HksParam g_agreeParams01Finish006[] = {
92 {
93 .tag = HKS_TAG_KEY_STORAGE_FLAG,
94 .uint32Param = HKS_STORAGE_TEMP
95 }
96 };
97 static struct HksParam g_agreeParams02Init006[] = {
98 {
99 .tag = HKS_TAG_ALGORITHM,
100 .uint32Param = HKS_ALG_ECDH
101 }, {
102 .tag = HKS_TAG_PURPOSE,
103 .uint32Param = HKS_KEY_PURPOSE_AGREE
104 }, {
105 .tag = HKS_TAG_KEY_SIZE,
106 .uint32Param = HKS_ECC_KEY_SIZE_256
107 }
108 };
109 static struct HksParam g_agreeParams02Finish006[] = {
110 {
111 .tag = HKS_TAG_KEY_STORAGE_FLAG,
112 .uint32Param = HKS_STORAGE_TEMP
113 }
114 };
115
116 static struct HksBlob g_keyAlias01007 = {
117 strlen("HksECDHAgreeKeyAliasTest007_1"),
118 (uint8_t *)"HksECDHAgreeKeyAliasTest007_1"
119 };
120 static struct HksBlob g_keyAlias02007 = {
121 strlen("HksECDHAgreeKeyAliasTest007_2"),
122 (uint8_t *)"HksECDHAgreeKeyAliasTest007_2"
123 };
124 static struct HksParam g_genParams007[] = {
125 {
126 .tag = HKS_TAG_ALGORITHM,
127 .uint32Param = HKS_ALG_ECC
128 }, {
129 .tag = HKS_TAG_PURPOSE,
130 .uint32Param = HKS_KEY_PURPOSE_AGREE
131 }, {
132 .tag = HKS_TAG_KEY_SIZE,
133 .uint32Param = HKS_ECC_KEY_SIZE_384
134 }, {
135 .tag = HKS_TAG_DIGEST,
136 .uint32Param = HKS_DIGEST_NONE
137 }, {
138 .tag = HKS_TAG_PADDING,
139 .uint32Param = HKS_PADDING_NONE
140 }, {
141 .tag = HKS_TAG_BLOCK_MODE,
142 .uint32Param = HKS_MODE_CBC
143 }
144 };
145 static struct HksParam g_agreeParams01Init007[] = {
146 {
147 .tag = HKS_TAG_ALGORITHM,
148 .uint32Param = HKS_ALG_ECDH
149 }, {
150 .tag = HKS_TAG_PURPOSE,
151 .uint32Param = HKS_KEY_PURPOSE_AGREE
152 }, {
153 .tag = HKS_TAG_KEY_SIZE,
154 .uint32Param = HKS_ECC_KEY_SIZE_384
155 }
156 };
157 static struct HksParam g_agreeParams01Finish007[] = {
158 {
159 .tag = HKS_TAG_KEY_STORAGE_FLAG,
160 .uint32Param = HKS_STORAGE_TEMP
161 }
162 };
163 static struct HksParam g_agreeParams02Init007[] = {
164 {
165 .tag = HKS_TAG_ALGORITHM,
166 .uint32Param = HKS_ALG_ECDH
167 }, {
168 .tag = HKS_TAG_PURPOSE,
169 .uint32Param = HKS_KEY_PURPOSE_AGREE
170 }, {
171 .tag = HKS_TAG_KEY_SIZE,
172 .uint32Param = HKS_ECC_KEY_SIZE_384
173 }
174 };
175 static struct HksParam g_agreeParams02Finish007[] = {
176 {
177 .tag = HKS_TAG_KEY_STORAGE_FLAG,
178 .uint32Param = HKS_STORAGE_TEMP
179 }
180 };
181
182 static struct HksBlob g_keyAlias01008 = {
183 strlen("HksECDHAgreeKeyAliasTest008_1"),
184 (uint8_t *)"HksECDHAgreeKeyAliasTest008_1"
185 };
186 static struct HksBlob g_keyAlias02008 = {
187 strlen("HksECDHAgreeKeyAliasTest008_2"),
188 (uint8_t *)"HksECDHAgreeKeyAliasTest008_2"
189 };
190 static struct HksParam g_genParams008[] = {
191 {
192 .tag = HKS_TAG_ALGORITHM,
193 .uint32Param = HKS_ALG_ECC
194 }, {
195 .tag = HKS_TAG_PURPOSE,
196 .uint32Param = HKS_KEY_PURPOSE_AGREE
197 }, {
198 .tag = HKS_TAG_KEY_SIZE,
199 .uint32Param = HKS_ECC_KEY_SIZE_521
200 }, {
201 .tag = HKS_TAG_DIGEST,
202 .uint32Param = HKS_DIGEST_NONE
203 }, {
204 .tag = HKS_TAG_PADDING,
205 .uint32Param = HKS_PADDING_NONE
206 }, {
207 .tag = HKS_TAG_BLOCK_MODE,
208 .uint32Param = HKS_MODE_CBC
209 }
210 };
211 static struct HksParam g_agreeParams01Init008[] = {
212 {
213 .tag = HKS_TAG_ALGORITHM,
214 .uint32Param = HKS_ALG_ECDH
215 }, {
216 .tag = HKS_TAG_PURPOSE,
217 .uint32Param = HKS_KEY_PURPOSE_AGREE
218 }, {
219 .tag = HKS_TAG_KEY_SIZE,
220 .uint32Param = HKS_ECC_KEY_SIZE_521
221 }
222 };
223 static struct HksParam g_agreeParams01Finish008[] = {
224 {
225 .tag = HKS_TAG_KEY_STORAGE_FLAG,
226 .uint32Param = HKS_STORAGE_TEMP
227 }
228 };
229 static struct HksParam g_agreeParams02Init008[] = {
230 {
231 .tag = HKS_TAG_ALGORITHM,
232 .uint32Param = HKS_ALG_ECDH
233 }, {
234 .tag = HKS_TAG_PURPOSE,
235 .uint32Param = HKS_KEY_PURPOSE_AGREE
236 }, {
237 .tag = HKS_TAG_KEY_SIZE,
238 .uint32Param = HKS_ECC_KEY_SIZE_521
239 }
240 };
241 static struct HksParam g_agreeParams02Finish008[] = {
242 {
243 .tag = HKS_TAG_KEY_STORAGE_FLAG,
244 .uint32Param = HKS_STORAGE_TEMP
245 }
246 };
247
248 static struct HksBlob g_keyAlias01009 = {
249 strlen("HksECDHAgreeKeyAliasTest009_1"),
250 (uint8_t *)"HksECDHAgreeKeyAliasTest009_1"
251 };
252 static struct HksBlob g_keyAlias02009 = {
253 strlen("HksECDHAgreeKeyAliasTest009_2"),
254 (uint8_t *)"HksECDHAgreeKeyAliasTest009_2"
255 };
256 static struct HksParam g_genParams009[] = {
257 {
258 .tag = HKS_TAG_ALGORITHM,
259 .uint32Param = HKS_ALG_ECC
260 }, {
261 .tag = HKS_TAG_PURPOSE,
262 .uint32Param = HKS_KEY_PURPOSE_AGREE
263 }, {
264 .tag = HKS_TAG_KEY_SIZE,
265 .uint32Param = HKS_ECC_KEY_SIZE_521
266 }, {
267 .tag = HKS_TAG_DIGEST,
268 .uint32Param = HKS_DIGEST_NONE
269 }, {
270 .tag = HKS_TAG_PADDING,
271 .uint32Param = HKS_PADDING_NONE
272 }, {
273 .tag = HKS_TAG_BLOCK_MODE,
274 .uint32Param = HKS_MODE_CBC
275 }
276 };
277 static struct HksParam g_agreeParams01Init009[] = {
278 {
279 .tag = HKS_TAG_ALGORITHM,
280 .uint32Param = HKS_ALG_ECDH
281 }, {
282 .tag = HKS_TAG_PURPOSE,
283 .uint32Param = HKS_KEY_PURPOSE_AGREE
284 }, {
285 .tag = HKS_TAG_KEY_SIZE,
286 .uint32Param = HKS_ECC_KEY_SIZE_521
287 }
288 };
289 static struct HksParam g_agreeParams02Init009[] = {
290 {
291 .tag = HKS_TAG_ALGORITHM,
292 .uint32Param = HKS_ALG_ECDH
293 }, {
294 .tag = HKS_TAG_PURPOSE,
295 .uint32Param = HKS_KEY_PURPOSE_AGREE
296 }, {
297 .tag = HKS_TAG_KEY_SIZE,
298 .uint32Param = HKS_ECC_KEY_SIZE_521
299 }
300 };
301
302 static struct HksBlob g_keyAlias01010 = {
303 strlen("HksECDHAgreeKeyAliasTest0010_1"),
304 (uint8_t *)"HksECDHAgreeKeyAliasTest0010_1"
305 };
306 static struct HksBlob g_keyAlias02010 = {
307 strlen("HksECDHAgreeKeyAliasTest0010_2"),
308 (uint8_t *)"HksECDHAgreeKeyAliasTest0010_2"
309 };
310 static struct HksParam g_genParams010[] = {
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_521
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_agreeParams01Init010[] = {
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_521
341 }
342 };
343 static struct HksParam g_agreeParams02Init010[] = {
344 {
345 .tag = HKS_TAG_ALGORITHM,
346 .uint32Param = HKS_ALG_ECDH
347 }, {
348 .tag = HKS_TAG_PURPOSE,
349 .uint32Param = HKS_KEY_PURPOSE_AGREE
350 }, {
351 .tag = HKS_TAG_KEY_SIZE,
352 .uint32Param = HKS_ECC_KEY_SIZE_521
353 }
354 };
355
356 /**
357 * @tc.name: HksEcdhAgreePart2Test.HksEcdhAgree006
358 * @tc.desc: alg-EDCH, pur-AGREE, size-256
359 * @tc.type: FUNC
360 */
361 HWTEST_F(HksEcdhAgreePart2Test, HksEcdhAgree006, TestSize.Level0)
362 {
363 struct HksParamSet *genParamSet = nullptr;
364 struct HksParamSet *initParamSet01 = nullptr;
365 struct HksParamSet *finishParamSet01 = nullptr;
366 struct HksParamSet *initParamSet02 = nullptr;
367 struct HksParamSet *finishParamSet02 = nullptr;
368 int32_t ret = InitParamSet(&genParamSet, g_genParams006, sizeof(g_genParams006)/sizeof(HksParam));
369 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
370 ret = InitParamSet(&initParamSet01, g_agreeParams01Init006, sizeof(g_agreeParams01Init006)/sizeof(HksParam));
371 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
372 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish006, sizeof(g_agreeParams01Finish006)/sizeof(HksParam));
373 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
374 ret = InitParamSet(&initParamSet02, g_agreeParams02Init006, sizeof(g_agreeParams02Init006)/sizeof(HksParam));
375 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
376 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish006, sizeof(g_agreeParams02Finish006)/sizeof(HksParam));
377 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
378
379 ret = HksGenerateKey(&g_keyAlias01006, genParamSet, nullptr);
380 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
381 ret = HksGenerateKey(&g_keyAlias02006, genParamSet, nullptr);
382 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
383
384 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_256, .data = nullptr };
385 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_256, .data = nullptr };
386 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
387 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
388 ret = HksEcdhAgreeExport(&g_keyAlias01006, &g_keyAlias02006, &publicKey01, &publicKey02, genParamSet);
389 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
390
391 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
392 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
393 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
394 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
395 ret = HksEcdhAgreeFinish(&g_keyAlias01006, &publicKey02, initParamSet01, finishParamSet01, &outData01);
396 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
397 ret = HksAgreeKey(initParamSet02, &g_keyAlias02006, &publicKey01, &outData02);
398 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAgreeKey02 failed.";
399 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
400
401 HksDeleteKey(&g_keyAlias01006, genParamSet);
402 HksDeleteKey(&g_keyAlias02006, genParamSet);
403 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
404 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
405 }
406
407 /**
408 * @tc.name: HksEcdhAgreePart2Test.HksEcdhAgree007
409 * @tc.desc: alg-EDCH, pur-AGREE, size-384
410 * @tc.type: FUNC
411 */
412 HWTEST_F(HksEcdhAgreePart2Test, HksEcdhAgree007, TestSize.Level0)
413 {
414 struct HksParamSet *genParamSet = nullptr;
415 struct HksParamSet *initParamSet01 = nullptr;
416 struct HksParamSet *finishParamSet01 = nullptr;
417 struct HksParamSet *initParamSet02 = nullptr;
418 struct HksParamSet *finishParamSet02 = nullptr;
419 int32_t ret = InitParamSet(&genParamSet, g_genParams007, sizeof(g_genParams007)/sizeof(HksParam));
420 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
421 ret = InitParamSet(&initParamSet01, g_agreeParams01Init007, sizeof(g_agreeParams01Init007)/sizeof(HksParam));
422 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
423 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish007, sizeof(g_agreeParams01Finish007)/sizeof(HksParam));
424 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
425 ret = InitParamSet(&initParamSet02, g_agreeParams02Init007, sizeof(g_agreeParams02Init007)/sizeof(HksParam));
426 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
427 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish007, sizeof(g_agreeParams02Finish007)/sizeof(HksParam));
428 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
429
430 ret = HksGenerateKey(&g_keyAlias01007, genParamSet, nullptr);
431 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
432 ret = HksGenerateKey(&g_keyAlias02007, genParamSet, nullptr);
433 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
434
435 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_384, .data = nullptr };
436 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_384, .data = nullptr };
437 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
438 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
439 ret = HksEcdhAgreeExport(&g_keyAlias01007, &g_keyAlias02007, &publicKey01, &publicKey02, genParamSet);
440 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
441
442 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
443 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
444 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
445 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
446 ret = HksEcdhAgreeFinish(&g_keyAlias01007, &publicKey02, initParamSet01, finishParamSet01, &outData01);
447 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
448 ret = HksAgreeKey(initParamSet02, &g_keyAlias02007, &publicKey01, &outData02);
449 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAgreeKey02 failed.";
450 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
451
452 HksDeleteKey(&g_keyAlias01007, genParamSet);
453 HksDeleteKey(&g_keyAlias02007, genParamSet);
454 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
455 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
456 }
457
458 /**
459 * @tc.name: HksEcdhAgreePart2Test.HksEcdhAgree008
460 * @tc.desc: alg-EDCH, pur-AGREE, size-521
461 * @tc.type: FUNC
462 */
463 HWTEST_F(HksEcdhAgreePart2Test, HksEcdhAgree008, TestSize.Level0)
464 {
465 struct HksParamSet *genParamSet = nullptr;
466 struct HksParamSet *initParamSet01 = nullptr;
467 struct HksParamSet *finishParamSet01 = nullptr;
468 struct HksParamSet *initParamSet02 = nullptr;
469 struct HksParamSet *finishParamSet02 = nullptr;
470 int32_t ret = InitParamSet(&genParamSet, g_genParams008, sizeof(g_genParams008)/sizeof(HksParam));
471 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
472 ret = InitParamSet(&initParamSet01, g_agreeParams01Init008, sizeof(g_agreeParams01Init008)/sizeof(HksParam));
473 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
474 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish008, sizeof(g_agreeParams01Finish008)/sizeof(HksParam));
475 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)01 failed.";
476 ret = InitParamSet(&initParamSet02, g_agreeParams02Init008, sizeof(g_agreeParams02Init008)/sizeof(HksParam));
477 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
478 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish008, sizeof(g_agreeParams02Finish008)/sizeof(HksParam));
479 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(finish)02 failed.";
480
481 ret = HksGenerateKey(&g_keyAlias01008, genParamSet, nullptr);
482 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
483 ret = HksGenerateKey(&g_keyAlias02008, genParamSet, nullptr);
484 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
485
486 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
487 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
488 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
489 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
490 ret = HksEcdhAgreeExport(&g_keyAlias01008, &g_keyAlias02008, &publicKey01, &publicKey02, genParamSet);
491 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
492
493 struct HksBlob outData01 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
494 struct HksBlob outData02 = { .size = Unittest::EcdhAgree::ECDH_COMMON_SIZE, .data = nullptr };
495 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size), HKS_SUCCESS) << "Malloc outData01 failed.";
496 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size), HKS_SUCCESS) << "Malloc outData02 failed.";
497 ret = HksEcdhAgreeFinish(&g_keyAlias01008, &publicKey02, initParamSet01, finishParamSet01, &outData01);
498 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeFinish01 failed.";
499 ret = HksAgreeKey(initParamSet02, &g_keyAlias02008, &publicKey01, &outData02);
500 EXPECT_EQ(ret, HKS_SUCCESS) << "HksAgreeKey02 failed.";
501 EXPECT_EQ(TestCmpKeyAliasHash(&outData01, &outData02), HKS_SUCCESS) << "outData01 not equals outData02";
502
503 HksDeleteKey(&g_keyAlias01008, genParamSet);
504 HksDeleteKey(&g_keyAlias02008, genParamSet);
505 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
506 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
507 }
508
509 /**
510 * @tc.name: HksEcdhAgreePart2Test.HksEcdhAgree009
511 * @tc.desc: alg-EDCH, pur-AGREE, size-521
512 * @tc.type: FUNC
513 */
514 HWTEST_F(HksEcdhAgreePart2Test, HksEcdhAgree009, TestSize.Level0)
515 {
516 struct HksParamSet *genParamSet = nullptr;
517 struct HksParamSet *initParamSet01 = nullptr;
518 struct HksParamSet *initParamSet02 = nullptr;
519 int32_t ret = InitParamSet(&genParamSet, g_genParams009, sizeof(g_genParams009)/sizeof(HksParam));
520 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
521 ret = InitParamSet(&initParamSet01, g_agreeParams01Init009, sizeof(g_agreeParams01Init009)/sizeof(HksParam));
522 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
523 ret = InitParamSet(&initParamSet02, g_agreeParams02Init009, sizeof(g_agreeParams02Init009)/sizeof(HksParam));
524 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
525
526 ret = HksGenerateKey(&g_keyAlias01009, genParamSet, nullptr);
527 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
528 ret = HksGenerateKey(&g_keyAlias02009, genParamSet, nullptr);
529 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
530
531 struct HksBlob publicKey01 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
532 struct HksBlob publicKey02 = { .size = HKS_ECC_KEY_SIZE_521, .data = nullptr };
533 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size), HKS_SUCCESS) << "Malloc publicKey01 failed.";
534 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size), HKS_SUCCESS) << "Malloc publicKey02 failed.";
535 ret = HksEcdhAgreeExport(&g_keyAlias01009, &g_keyAlias02009, &publicKey01, &publicKey02, genParamSet);
536 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportKey failed.";
537
538 ret = HksEcdhAgreeAbort(&g_keyAlias01009, &publicKey02, initParamSet01);
539 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeAbort01 failed.";
540 ret = HksEcdhAgreeAbort(&g_keyAlias02009, &publicKey01, initParamSet02);
541 EXPECT_EQ(ret, HKS_SUCCESS) << "HksEcdhAgreeAbort02 failed.";
542
543 HksDeleteKey(&g_keyAlias01009, genParamSet);
544 HksDeleteKey(&g_keyAlias02009, genParamSet);
545 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, initParamSet02);
546 HksEcdhAgreeFreeBlob(&publicKey01, &publicKey02);
547 }
548
549 /**
550 * @tc.name: HksEcdhAgreePart2Test.HksEcdhAgree0010
551 * @tc.desc: alg-EDCH, pur-AGREE, size-521
552 * @tc.type: FUNC abnormal
553 */
554 HWTEST_F(HksEcdhAgreePart2Test, HksEcdhAgree0010, TestSize.Level0)
555 {
556 struct HksParamSet *genParamSet = nullptr;
557 struct HksParamSet *initParamSet01 = nullptr;
558 struct HksParamSet *initParamSet02 = nullptr;
559 int32_t ret = InitParamSet(&genParamSet, g_genParams010, sizeof(g_genParams010)/sizeof(HksParam));
560 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
561 ret = InitParamSet(&initParamSet01, g_agreeParams01Init010, sizeof(g_agreeParams01Init010)/sizeof(HksParam));
562 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
563 ret = InitParamSet(&initParamSet02, g_agreeParams02Init010, sizeof(g_agreeParams02Init010)/sizeof(HksParam));
564 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
565
566 ret = HksGenerateKey(&g_keyAlias01010, genParamSet, nullptr);
567 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey01 failed.";
568 ret = HksGenerateKey(&g_keyAlias02010, genParamSet, nullptr);
569 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey02 failed.";
570
571 uint8_t handleU[sizeof(uint64_t)] = {0};
572 struct HksBlob handle = { sizeof(uint64_t), handleU };
573 ret = HksInit(NULL, initParamSet01, &handle);
574 EXPECT_NE(ret, HKS_SUCCESS) << "HksInit01 should failed.";
575 ret = HksInit(NULL, initParamSet02, &handle);
576 EXPECT_NE(ret, HKS_SUCCESS) << "HksInit02 should failed.";
577
578 HksDeleteKey(&g_keyAlias01010, genParamSet);
579 HksDeleteKey(&g_keyAlias02010, genParamSet);
580 HksEcdhAgreeFreeParamSet(genParamSet, initParamSet01, initParamSet02);
581 }
582 }