1 /*
2 * Copyright (C) 2023 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_test_common_c.h"
17
TestConstuctBlob(struct HksBlob ** blob,bool blobExist,uint32_t blobSize,bool blobDataExist,uint32_t realBlobDataSize)18 int32_t TestConstuctBlob(struct HksBlob **blob, bool blobExist, uint32_t blobSize, bool blobDataExist,
19 uint32_t realBlobDataSize)
20 {
21 if (!blobExist) { // blob not exist
22 return 0; // do nothing, return null
23 }
24
25 *blob = (struct HksBlob *)HksTestMalloc(sizeof(struct HksBlob));
26 if (*blob == NULL) {
27 return HKS_ERROR_MALLOC_FAIL;
28 }
29 (void)memset_s(*blob, sizeof(struct HksBlob), 0, sizeof(struct HksBlob));
30
31 if (blobDataExist) {
32 (*blob)->size = realBlobDataSize;
33 (*blob)->data = (uint8_t *)HksTestMalloc(realBlobDataSize);
34 if ((*blob)->data == NULL) {
35 HksTestFree(*blob);
36 *blob = NULL;
37 return HKS_ERROR_MALLOC_FAIL;
38 }
39 (void)memset_s((*blob)->data, realBlobDataSize, 0, realBlobDataSize);
40 uint32_t offset = 0;
41 for (uint32_t i = 0; i < (realBlobDataSize - 1) / HKS_TEST_1024; i++) {
42 struct HksBlob tmp;
43 tmp.size = HKS_TEST_1024;
44 tmp.data = (uint8_t *)HksTestMalloc(tmp.size);
45 HKS_TEST_ASSERT(tmp.data != NULL);
46 (void)memset_s(tmp.data, tmp.size, 0, tmp.size);
47
48 HKS_TEST_ASSERT(HksGenerateRandom(NULL, &tmp) == 0);
49
50 HKS_TEST_ASSERT(memcpy_s((*blob)->data + offset, realBlobDataSize - offset, tmp.data, tmp.size) == EOK);
51 offset += tmp.size;
52 HksTestFree(tmp.data);
53 }
54
55 uint32_t remainSize = realBlobDataSize - offset;
56 struct HksBlob tmp;
57 tmp.size = remainSize;
58 tmp.data = (uint8_t *)HksTestMalloc(tmp.size);
59 HKS_TEST_ASSERT(tmp.data != NULL);
60 (void)memset_s(tmp.data, tmp.size, 0, tmp.size);
61 HksInitialize();
62 HKS_TEST_ASSERT(HksGenerateRandom(NULL, &tmp) == 0);
63 HKS_TEST_ASSERT(memcpy_s((*blob)->data + offset, remainSize, tmp.data, tmp.size) == EOK);
64 HksTestFree(tmp.data);
65 } else {
66 (*blob)->data = NULL;
67 }
68
69 (*blob)->size = blobSize;
70 return 0;
71 }
72
TestGenerateKeyParamSetPre(struct GenerateKeyParamSetStructure * paramStruct,struct HksParamSet * paramSet)73 int32_t TestGenerateKeyParamSetPre(struct GenerateKeyParamSetStructure *paramStruct,
74 struct HksParamSet *paramSet)
75 {
76 if (!paramStruct->paramSetExist) {
77 return 0; // do nothing, return null
78 }
79 int32_t ret = 1;
80
81 if (paramStruct->setAlg) {
82 struct HksParam algParam = {0};
83 algParam.tag = HKS_TAG_ALGORITHM;
84 algParam.uint32Param = paramStruct->alg;
85 ret = HksAddParams(paramSet, (const struct HksParam *) &algParam, 1);
86 HKS_TEST_ASSERT(ret == 0);
87 }
88
89 if (paramStruct->setKeySize) {
90 struct HksParam keySizeParam = {0};
91 keySizeParam.tag = HKS_TAG_KEY_SIZE;
92 keySizeParam.uint32Param = paramStruct->keySize;
93 ret = HksAddParams(paramSet, (const struct HksParam *) &keySizeParam, 1);
94 HKS_TEST_ASSERT(ret == 0);
95 }
96
97 if (paramStruct->setPurpose) {
98 struct HksParam purposeParam = {0};
99 purposeParam.tag = HKS_TAG_PURPOSE;
100 purposeParam.uint32Param = paramStruct->purpose;
101 ret = HksAddParams(paramSet, (const struct HksParam *) &purposeParam, 1);
102 HKS_TEST_ASSERT(ret == 0);
103 }
104
105 if (paramStruct->setDigest) {
106 struct HksParam digestParam = {0};
107 digestParam.tag = HKS_TAG_DIGEST;
108 digestParam.uint32Param = paramStruct->digest;
109 ret = HksAddParams(paramSet, (const struct HksParam *) &digestParam, 1);
110 HKS_TEST_LOG_I("HksAddParams ret = 0x%X", ret);
111 HKS_TEST_ASSERT(ret == 0);
112 }
113
114 if (paramStruct->setPadding) {
115 struct HksParam paddingParam = {0};
116 paddingParam.tag = HKS_TAG_PADDING;
117 paddingParam.uint32Param = paramStruct->padding;
118 ret = HksAddParams(paramSet, (const struct HksParam *) &paddingParam, 1);
119 HKS_TEST_ASSERT(ret == 0);
120 }
121 return ret;
122 }
123
TestGenerateKeyParamSetPost(struct GenerateKeyParamSetStructure * paramStruct,struct HksParamSet * paramSet)124 int32_t TestGenerateKeyParamSetPost(struct GenerateKeyParamSetStructure *paramStruct,
125 struct HksParamSet *paramSet)
126 {
127 if (!paramStruct->paramSetExist) {
128 return 0; // do nothing, return null
129 }
130 int32_t ret = 1;
131 if (paramStruct->setBlockMode) {
132 struct HksParam keyMode = {0};
133 keyMode.tag = HKS_TAG_BLOCK_MODE;
134 keyMode.uint32Param = paramStruct->mode;
135 ret = HksAddParams(paramSet, (const struct HksParam *) &keyMode, 1);
136 HKS_TEST_ASSERT(ret == 0);
137 }
138
139 if (paramStruct->setKeyStorageFlag) {
140 struct HksParam keyStorageFlagParam = {0};
141 keyStorageFlagParam.tag = HKS_TAG_KEY_STORAGE_FLAG;
142 keyStorageFlagParam.uint32Param = paramStruct->keyStorageFlag;
143 ret = HksAddParams(paramSet, (const struct HksParam *) &keyStorageFlagParam, 1);
144 HKS_TEST_ASSERT(ret == 0);
145 }
146
147 struct HksParam tmpParam = {0};
148 tmpParam.tag = HKS_TAG_KEY_ROLE;
149 tmpParam.uint32Param = 0xFFFFFFFF;
150 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
151 HKS_TEST_ASSERT(ret == 0);
152
153 ret = HksBuildParamSet(¶mSet);
154 HKS_TEST_ASSERT(ret == 0);
155
156 *(paramStruct->outParamSet) = paramSet;
157 return ret;
158 }
159
TestConstructGenerateKeyParamSet(struct GenerateKeyParamSetStructure * paramStruct)160 int32_t TestConstructGenerateKeyParamSet(struct GenerateKeyParamSetStructure *paramStruct)
161 {
162 struct HksParamSet *paramSet = NULL;
163 int32_t ret = HksInitParamSet(¶mSet);
164 HKS_TEST_ASSERT(ret == 0);
165
166 ret = TestGenerateKeyParamSetPre(paramStruct, paramSet);
167 HKS_TEST_ASSERT(ret == 0);
168 ret = TestGenerateKeyParamSetPost(paramStruct, paramSet);
169 HKS_TEST_ASSERT(ret == 0);
170 return ret;
171 }
172
173
TestConstructGenerateKeyParamSetOut(struct HksParamSet ** outParamSet,bool paramSetExist,uint32_t paramSetSize)174 int32_t TestConstructGenerateKeyParamSetOut(
175 struct HksParamSet **outParamSet,
176 bool paramSetExist, uint32_t paramSetSize)
177 {
178 if (!paramSetExist) {
179 return 0; // do nothing, return null
180 }
181 struct HksParamSet *tempParamSet = (struct HksParamSet *)HksTestMalloc(paramSetSize);
182 if (tempParamSet == NULL) {
183 return -1; // -1 is error code
184 }
185 (void)memset_s(tempParamSet, paramSetSize, 0, paramSetSize);
186 tempParamSet->paramSetSize = paramSetSize;
187
188 *outParamSet = tempParamSet;
189 return 0;
190 }
191
TestConstructRsaCipherParamSet(struct TestRsaCipherParamSet * paramStruct)192 int32_t TestConstructRsaCipherParamSet(struct TestRsaCipherParamSet *paramStruct)
193 {
194 struct GenerateKeyParamSetStructure genParamStruct = {
195 paramStruct->outParamSet, paramStruct->paramSetExist,
196 paramStruct->setAlg, paramStruct->alg,
197 false, 0,
198 paramStruct->setPurpose, paramStruct->purpose,
199 paramStruct->setDigest, paramStruct->digest,
200 paramStruct->setPadding, paramStruct->padding,
201 false, 0,
202 false, 0
203 };
204 return TestConstructGenerateKeyParamSet(&genParamStruct);
205 }
206
TestAesCipherParamSetPre(struct AesCipherParamSetStructure * paramStruct,struct HksParamSet * paramSet)207 int32_t TestAesCipherParamSetPre(struct AesCipherParamSetStructure *paramStruct, struct HksParamSet *paramSet)
208 {
209 if (!paramStruct->paramSetExist) {
210 return 0; // do nothing, return null
211 }
212 int32_t ret = 1;
213 if (paramStruct->setAlg) {
214 struct HksParam algParamTest = {0};
215 algParamTest.tag = HKS_TAG_ALGORITHM;
216 algParamTest.uint32Param = paramStruct->alg;
217 ret = HksAddParams(paramSet, (const struct HksParam *) &algParamTest, 1);
218 HKS_TEST_ASSERT(ret == 0);
219 }
220
221 if (paramStruct->setPurpose) {
222 struct HksParam purposeParam = {0};
223 purposeParam.tag = HKS_TAG_PURPOSE;
224 purposeParam.uint32Param = paramStruct->purpose;
225 ret = HksAddParams(paramSet, (const struct HksParam *) &purposeParam, 1);
226 HKS_TEST_ASSERT(ret == 0);
227 }
228
229 if (paramStruct->setPadding) {
230 struct HksParam paddingParam = {0};
231 paddingParam.tag = HKS_TAG_PADDING;
232 paddingParam.uint32Param = paramStruct->padding;
233 ret = HksAddParams(paramSet, (const struct HksParam *) &paddingParam, 1);
234 HKS_TEST_ASSERT(ret == 0);
235 }
236
237 if (paramStruct->setBlockMode) {
238 struct HksParam keyMode = {0};
239 keyMode.tag = HKS_TAG_BLOCK_MODE;
240 keyMode.uint32Param = paramStruct->mode;
241 ret = HksAddParams(paramSet, (const struct HksParam *) &keyMode, 1);
242 HKS_TEST_ASSERT(ret == 0);
243 }
244
245 if (paramStruct->setIv) {
246 struct HksParam ivParam = {0};
247 ivParam.tag = HKS_TAG_IV;
248 ivParam.blob = *(paramStruct->ivBlob);
249 ret = HksAddParams(paramSet, (const struct HksParam *)&ivParam, 1);
250 HKS_TEST_ASSERT(ret == 0);
251 }
252 return ret;
253 }
254
TestAesCipherParamSetPost(struct AesCipherParamSetStructure * paramStruct,struct HksParamSet * paramSet)255 int32_t TestAesCipherParamSetPost(struct AesCipherParamSetStructure *paramStruct, struct HksParamSet *paramSet)
256 {
257 if (!paramStruct->paramSetExist) {
258 return 0; // do nothing, return null
259 }
260 int32_t ret = 1;
261 if (paramStruct->setNonce) {
262 struct HksParam nonceParam = {0};
263 nonceParam.tag = HKS_TAG_NONCE;
264 nonceParam.blob = *(paramStruct->nonceBlob);
265 ret = HksAddParams(paramSet, (const struct HksParam *)&nonceParam, 1);
266 HKS_TEST_ASSERT(ret == 0);
267 }
268
269 if (paramStruct->setAad) {
270 struct HksParam aadParam = {0};
271 aadParam.tag = HKS_TAG_ASSOCIATED_DATA;
272 aadParam.blob = *(paramStruct->aadBlob);
273 ret = HksAddParams(paramSet, (const struct HksParam *)&aadParam, 1);
274 HKS_TEST_ASSERT(ret == 0);
275 }
276
277 if (paramStruct->setIsKeyAlias) {
278 struct HksParam isKeyAilasParam = {0};
279 isKeyAilasParam.tag = HKS_TAG_IS_KEY_ALIAS;
280 isKeyAilasParam.boolParam = paramStruct->isKeyAlias;
281 ret = HksAddParams(paramSet, (const struct HksParam *) &isKeyAilasParam, 1);
282 HKS_TEST_ASSERT(ret == 0);
283 }
284
285 struct HksParam tmpParam = {0};
286 tmpParam.tag = HKS_TAG_KEY_ROLE;
287 tmpParam.uint32Param = 0xFFFFFFFF;
288 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
289 HKS_TEST_ASSERT(ret == 0);
290
291 ret = HksBuildParamSet(¶mSet);
292 HKS_TEST_ASSERT(ret == 0);
293
294 *(paramStruct->outParamSet) = paramSet;
295 return ret;
296 }
297
TestConstructAesCipherParamSet(struct AesCipherParamSetStructure * paramStruct)298 int32_t TestConstructAesCipherParamSet(struct AesCipherParamSetStructure *paramStruct)
299 {
300 struct HksParamSet *paramSet = NULL;
301 int32_t ret = HksInitParamSet(¶mSet);
302 HKS_TEST_ASSERT(ret == 0);
303
304 ret = TestAesCipherParamSetPre(paramStruct, paramSet);
305 HKS_TEST_ASSERT(ret == 0);
306 ret = TestAesCipherParamSetPost(paramStruct, paramSet);
307 HKS_TEST_ASSERT(ret == 0);
308 return ret;
309 }
310
TestConstructMacParamSet(struct TestMacParamSetStructure * paramStruct)311 int32_t TestConstructMacParamSet(struct TestMacParamSetStructure *paramStruct)
312 {
313 if (!paramStruct->paramSetExist) {
314 return 0; // do nothing, return null
315 }
316 struct HksParamSet *paramSet = NULL;
317 int32_t ret = HksInitParamSet(¶mSet);
318 HKS_TEST_ASSERT(ret == 0);
319
320 if (paramStruct->setPurpose) {
321 struct HksParam purposeParam = {0};
322 purposeParam.tag = HKS_TAG_PURPOSE;
323 purposeParam.uint32Param = paramStruct->purpose;
324 ret = HksAddParams(paramSet, (const struct HksParam *) &purposeParam, 1);
325 HKS_TEST_ASSERT(ret == 0);
326 }
327
328 if (paramStruct->setDigest) {
329 struct HksParam digestParam = {0};
330 digestParam.tag = HKS_TAG_DIGEST;
331 digestParam.uint32Param = paramStruct->digest;
332 ret = HksAddParams(paramSet, (const struct HksParam *) &digestParam, 1);
333 HKS_TEST_ASSERT(ret == 0);
334 }
335
336 if (paramStruct->setKeyAlias) {
337 struct HksParam keyIsKeyAlias = {0};
338 keyIsKeyAlias.tag = HKS_TAG_IS_KEY_ALIAS;
339 keyIsKeyAlias.boolParam = paramStruct->isKeyAlias;
340 ret = HksAddParams(paramSet, (const struct HksParam *) &keyIsKeyAlias, 1);
341 HKS_TEST_ASSERT(ret == 0);
342 }
343
344 struct HksParam tmpParam = {0};
345 tmpParam.tag = HKS_TAG_KEY_ROLE;
346 tmpParam.uint32Param = 0xFFFFFFFF;
347 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
348 HKS_TEST_ASSERT(ret == 0);
349
350 ret = HksBuildParamSet(¶mSet);
351 HKS_TEST_ASSERT(ret == 0);
352
353 *(paramStruct->outParamSet) = paramSet;
354 return ret;
355 }
356
TestConstructAgreeParamSet(struct TestAgreeParamSetStructure * paramStruct)357 int32_t TestConstructAgreeParamSet(struct TestAgreeParamSetStructure *paramStruct)
358 {
359 if (!paramStruct->paramSetExist) {
360 return 0; // do nothing, return null
361 }
362 struct HksParamSet *paramSet = NULL;
363 int32_t ret = HksInitParamSet(¶mSet);
364 HKS_TEST_ASSERT(ret == 0);
365
366 if (paramStruct->setAlg) {
367 struct HksParam algParam = {0};
368 algParam.tag = HKS_TAG_ALGORITHM;
369 algParam.uint32Param = paramStruct->alg;
370 ret = HksAddParams(paramSet, (const struct HksParam *) &algParam, 1);
371 HKS_TEST_ASSERT(ret == 0);
372 }
373
374 if (paramStruct->setKeySize) {
375 struct HksParam keySizeParam = {0};
376 keySizeParam.tag = HKS_TAG_KEY_SIZE;
377 keySizeParam.uint32Param = paramStruct->keySize;
378 ret = HksAddParams(paramSet, (const struct HksParam *) &keySizeParam, 1);
379 HKS_TEST_ASSERT(ret == 0);
380 }
381
382 if (paramStruct->setIsKeyAlias) {
383 struct HksParam isKeyAliasParam = {0};
384 isKeyAliasParam.tag = HKS_TAG_IS_KEY_ALIAS;
385 isKeyAliasParam.uint32Param = paramStruct->isKeyAlias;
386 ret = HksAddParams(paramSet, (const struct HksParam *) &isKeyAliasParam, 1);
387 HKS_TEST_ASSERT(ret == 0);
388 }
389
390 struct HksParam tmpParam = {0};
391 tmpParam.tag = HKS_TAG_KEY_ROLE;
392 tmpParam.uint32Param = 0xFFFFFFFF;
393 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
394 HKS_TEST_ASSERT(ret == 0);
395
396 ret = HksBuildParamSet(¶mSet);
397 HKS_TEST_ASSERT(ret == 0);
398
399 *(paramStruct->outParamSet) = paramSet;
400 return ret;
401 }
402
403
TestDeriveParamSetPre(struct TestDeriveParamSetStructure * paramStruct,struct HksParamSet * paramSet)404 int32_t TestDeriveParamSetPre(struct TestDeriveParamSetStructure *paramStruct, struct HksParamSet *paramSet)
405 {
406 if (!paramStruct->paramSetExist) {
407 return 0; // do nothing, return null
408 }
409 int32_t ret = 1;
410 if (paramStruct->setAlg) {
411 struct HksParam algParam = {0};
412 algParam.tag = HKS_TAG_ALGORITHM;
413 algParam.uint32Param = paramStruct->alg;
414 ret = HksAddParams(paramSet, (const struct HksParam *) &algParam, 1);
415 HKS_TEST_ASSERT(ret == 0);
416 }
417
418 if (paramStruct->setPurpose) {
419 struct HksParam purposeParam = {0};
420 purposeParam.tag = HKS_TAG_PURPOSE;
421 purposeParam.uint32Param = paramStruct->purpose;
422 ret = HksAddParams(paramSet, (const struct HksParam *) &purposeParam, 1);
423 HKS_TEST_ASSERT(ret == 0);
424 }
425
426 if (paramStruct->setDigest) {
427 struct HksParam digestParam = {0};
428 digestParam.tag = HKS_TAG_DIGEST;
429 digestParam.uint32Param = paramStruct->digest;
430 ret = HksAddParams(paramSet, (const struct HksParam *)&digestParam, 1);
431 HKS_TEST_ASSERT(ret == 0);
432 }
433
434 if (paramStruct->setIteration) {
435 struct HksParam iterationParam = {0};
436 iterationParam.tag = HKS_TAG_ITERATION;
437 iterationParam.uint32Param = paramStruct->iteration;
438 ret = HksAddParams(paramSet, (const struct HksParam *)&iterationParam, 1);
439 HKS_TEST_ASSERT(ret == 0);
440 }
441 return ret;
442 }
443
TestDeriveParamSetPost(struct TestDeriveParamSetStructure * paramStruct,struct HksParamSet * paramSet)444 int32_t TestDeriveParamSetPost(struct TestDeriveParamSetStructure *paramStruct, struct HksParamSet *paramSet)
445 {
446 if (!paramStruct->paramSetExist) {
447 return 0; // do nothing, return null
448 }
449 int32_t ret = 1;
450 if (paramStruct->setSalt) {
451 struct HksParam saltParam = {0};
452 saltParam.tag = HKS_TAG_SALT;
453 saltParam.blob = *(paramStruct->saltBlob);
454 ret = HksAddParams(paramSet, (const struct HksParam *)&saltParam, 1);
455 HKS_TEST_ASSERT(ret == 0);
456 }
457
458 if (paramStruct->setInfo) {
459 struct HksParam infoParam = {0};
460 infoParam.tag = HKS_TAG_INFO;
461 infoParam.blob = *(paramStruct->infoBlob);
462 ret = HksAddParams(paramSet, (const struct HksParam *)&infoParam, 1);
463 HKS_TEST_ASSERT(ret == 0);
464 }
465
466 if (paramStruct->setIsKeyAlias) {
467 struct HksParam isKeyAliasParam = {0};
468 isKeyAliasParam.tag = HKS_TAG_IS_KEY_ALIAS;
469 isKeyAliasParam.boolParam = paramStruct->isKeyAlias;
470 ret = HksAddParams(paramSet, (const struct HksParam *)&isKeyAliasParam, 1);
471 HKS_TEST_ASSERT(ret == 0);
472 }
473
474 struct HksParam tmpParam = {0};
475 tmpParam.tag = HKS_TAG_KEY_ROLE;
476 tmpParam.uint32Param = 0xFFFFFFFF;
477 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
478 HKS_TEST_ASSERT(ret == 0);
479
480 ret = HksBuildParamSet(¶mSet);
481 HKS_TEST_ASSERT(ret == 0);
482
483 *(paramStruct->outParamSet) = paramSet;
484 return ret;
485 }
486
TestConstructDeriveParamSet(struct TestDeriveParamSetStructure * paramStruct)487 int32_t TestConstructDeriveParamSet(struct TestDeriveParamSetStructure *paramStruct)
488 {
489 struct HksParamSet *paramSet = NULL;
490 int32_t ret = HksInitParamSet(¶mSet);
491 HKS_TEST_ASSERT(ret == 0);
492
493 ret = TestDeriveParamSetPre(paramStruct, paramSet);
494 HKS_TEST_ASSERT(ret == 0);
495 ret = TestDeriveParamSetPost(paramStruct, paramSet);
496 HKS_TEST_ASSERT(ret == 0);
497 return ret;
498 }
499
TestConstructHashParamSet(struct HksParamSet ** outParamSet,bool paramSetExist,bool setDigest,uint32_t digest)500 int32_t TestConstructHashParamSet(
501 struct HksParamSet **outParamSet,
502 bool paramSetExist,
503 bool setDigest, uint32_t digest)
504 {
505 if (!paramSetExist) {
506 return 0; // do nothing, return null
507 }
508 struct HksParamSet *paramSet = NULL;
509 int32_t ret = HksInitParamSet(¶mSet);
510 HKS_TEST_ASSERT(ret == 0);
511
512 if (setDigest) {
513 struct HksParam digestParam = {0};
514 digestParam.tag = HKS_TAG_DIGEST;
515 digestParam.uint32Param = digest;
516 ret = HksAddParams(paramSet, (const struct HksParam *) &digestParam, 1);
517 HKS_TEST_ASSERT(ret == 0);
518 }
519
520 struct HksParam tmpParam = {0};
521 tmpParam.tag = HKS_TAG_KEY_ROLE;
522 tmpParam.uint32Param = 0xFFFFFFFF;
523 ret = HksAddParams(paramSet, (const struct HksParam *) &tmpParam, 1);
524 HKS_TEST_ASSERT(ret == 0);
525
526 ret = HksBuildParamSet(¶mSet);
527 HKS_TEST_ASSERT(ret == 0);
528
529 *outParamSet = paramSet;
530 return ret;
531 }
532
GenerateKey(struct HksBlob ** keyAlias,const struct HksTestBlobParams * keyAliasParams,const struct HksTestGenKeyParamsParamSet * genKeyParamSetParams,const struct HksTestGenKeyParamsParamSetOut * genKeyParamSetParamsOut)533 int32_t GenerateKey(struct HksBlob **keyAlias, const struct HksTestBlobParams *keyAliasParams,
534 const struct HksTestGenKeyParamsParamSet *genKeyParamSetParams,
535 const struct HksTestGenKeyParamsParamSetOut *genKeyParamSetParamsOut)
536 {
537 int32_t ret = TestConstuctBlob(keyAlias,
538 keyAliasParams->blobExist,
539 keyAliasParams->blobSize,
540 keyAliasParams->blobDataExist,
541 keyAliasParams->blobDataSize);
542 HKS_TEST_ASSERT(ret == 0);
543
544 struct HksParamSet *paramSet = NULL;
545 struct GenerateKeyParamSetStructure paramStruct = {
546 ¶mSet,
547 genKeyParamSetParams->paramSetExist,
548 genKeyParamSetParams->setAlg, genKeyParamSetParams->alg,
549 genKeyParamSetParams->setKeySize, genKeyParamSetParams->keySize,
550 genKeyParamSetParams->setPurpose, genKeyParamSetParams->purpose,
551 genKeyParamSetParams->setDigest, genKeyParamSetParams->digest,
552 genKeyParamSetParams->setPadding, genKeyParamSetParams->padding,
553 genKeyParamSetParams->setBlockMode, genKeyParamSetParams->mode,
554 genKeyParamSetParams->setKeyStorageFlag, genKeyParamSetParams->keyStorageFlag
555 };
556 ret = TestConstructGenerateKeyParamSet(¶mStruct);
557 HKS_TEST_ASSERT(ret == 0);
558
559 struct HksParamSet *paramSetOut = NULL;
560 if (genKeyParamSetParamsOut != NULL) {
561 ret = TestConstructGenerateKeyParamSetOut(¶mSet,
562 genKeyParamSetParamsOut->paramSetExist, genKeyParamSetParamsOut->paramSetSize);
563 HKS_TEST_ASSERT(ret == 0);
564 }
565
566 ret = HksGenerateKey(*keyAlias, paramSet, paramSetOut);
567 HKS_TEST_ASSERT(ret == 0);
568
569 HksFreeParamSet(¶mSet);
570 return ret;
571 }
572
GenerateLocalRandomKey(struct HksBlob ** keyAlias,const struct HksTestBlobParams * localKeyParams)573 int32_t GenerateLocalRandomKey(struct HksBlob **keyAlias, const struct HksTestBlobParams *localKeyParams)
574 {
575 int32_t ret = TestConstuctBlob(keyAlias,
576 localKeyParams->blobExist,
577 localKeyParams->blobSize,
578 localKeyParams->blobDataExist,
579 localKeyParams->blobDataSize);
580 HKS_TEST_ASSERT(ret == 0);
581 return ret;
582 }
583
TestConstructBlobOut(struct HksBlob ** blob,bool blobExist,uint32_t blobSize,bool blobDataExist,uint32_t realBlobDataSize)584 int32_t TestConstructBlobOut(struct HksBlob **blob,
585 bool blobExist,
586 uint32_t blobSize,
587 bool blobDataExist,
588 uint32_t realBlobDataSize)
589 {
590 if (!blobExist) { // blob not exist
591 return 0; // do nothing, return null
592 }
593
594 *blob = (struct HksBlob *)HksTestMalloc(sizeof(struct HksBlob));
595 if (*blob == NULL) {
596 HKS_TEST_LOG_E("malloc fail");
597 return HKS_ERROR_MALLOC_FAIL;
598 }
599 (void)memset_s(*blob, sizeof(struct HksBlob), 0, sizeof(struct HksBlob));
600
601 if (blobDataExist) {
602 (*blob)->size = realBlobDataSize;
603 (*blob)->data = (uint8_t *)HksTestMalloc(realBlobDataSize);
604 if ((*blob)->data == NULL) {
605 HKS_TEST_LOG_E("malloc fail");
606 HksTestFree(*blob);
607 *blob = NULL;
608 return HKS_ERROR_MALLOC_FAIL;
609 }
610 (void)memset_s((*blob)->data, realBlobDataSize, 0, realBlobDataSize);
611 } else {
612 (*blob)->data = NULL;
613 }
614
615 (*blob)->size = blobSize;
616 return 0;
617 }
618
GenerateLocalX25519Key(struct HksBlob ** privateKey,struct HksBlob ** publicKey,const struct HksTestBlobParams * localPrivateKeyParams,const struct HksTestBlobParams * localPublicKeyParams)619 int32_t GenerateLocalX25519Key(struct HksBlob **privateKey, struct HksBlob **publicKey,
620 const struct HksTestBlobParams *localPrivateKeyParams, const struct HksTestBlobParams *localPublicKeyParams)
621 {
622 int32_t ret = 1;
623 if ((privateKey != NULL) && (localPrivateKeyParams != NULL)) {
624 ret = TestConstuctBlob(privateKey,
625 localPrivateKeyParams->blobExist,
626 localPrivateKeyParams->blobSize,
627 localPrivateKeyParams->blobDataExist,
628 localPrivateKeyParams->blobDataSize);
629 HKS_TEST_ASSERT(ret == 0);
630 }
631
632 if ((publicKey != NULL) && (localPublicKeyParams != NULL)) {
633 ret = TestConstuctBlob(publicKey,
634 localPublicKeyParams->blobExist,
635 localPublicKeyParams->blobSize,
636 localPublicKeyParams->blobDataExist,
637 localPublicKeyParams->blobDataSize);
638 HKS_TEST_ASSERT(ret == 0);
639 }
640
641 struct HksParamSet *paramSet = NULL;
642 struct GenerateKeyParamSetStructure paramStruct = {
643 ¶mSet, true, true, HKS_ALG_X25519,
644 true, HKS_CURVE25519_KEY_SIZE_256, true, HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, false, 0,
645 false, 0, false, 0, true, HKS_STORAGE_TEMP
646 };
647 ret = TestConstructGenerateKeyParamSet(¶mStruct);
648 HKS_TEST_ASSERT(ret == 0);
649
650 struct HksParamSet *paramSetOut = NULL;
651 ret = TestConstructGenerateKeyParamSetOut(¶mSetOut, true, HKS_TEST_COMMON_128);
652 HKS_TEST_ASSERT(ret == 0);
653
654 ret = HksGenerateKey(NULL, paramSet, paramSetOut);
655 HKS_TEST_ASSERT(ret == 0);
656
657 if ((publicKey != NULL) && ((*publicKey) != NULL) && (localPublicKeyParams != NULL) &&
658 (localPublicKeyParams->blobDataExist) &&
659 (localPublicKeyParams->blobDataSize == (HKS_CURVE25519_KEY_SIZE_256 / HKS_TEST_COMMON_8))) {
660 ret = memcpy_s((*publicKey)->data, (*publicKey)->size,
661 paramSetOut->params[0].blob.data, paramSetOut->params[0].blob.size);
662 HKS_TEST_ASSERT(ret == 0);
663 }
664
665 if ((privateKey != NULL) && ((*privateKey) != NULL) && (localPrivateKeyParams != NULL) &&
666 (localPrivateKeyParams->blobDataExist) &&
667 (localPrivateKeyParams->blobDataSize == (HKS_CURVE25519_KEY_SIZE_256 / HKS_TEST_COMMON_8))) {
668 ret = memcpy_s((*privateKey)->data, (*privateKey)->size,
669 paramSetOut->params[1].blob.data, paramSetOut->params[1].blob.size);
670 HKS_TEST_ASSERT(ret == 0);
671 }
672
673 HksFreeParamSet(¶mSet);
674 HksFreeParamSet(¶mSetOut);
675 return ret;
676 }
677
TestGenDefaultKeyAndGetAlias(struct HksBlob ** keyAlias)678 int32_t TestGenDefaultKeyAndGetAlias(struct HksBlob **keyAlias)
679 {
680 struct HksTestGenKeyParams genKeyParam = {
681 0xffffffff, HKS_SUCCESS,
682 { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE }, {
683 true,
684 true, HKS_ALG_AES,
685 true, HKS_AES_KEY_SIZE_128,
686 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
687 true, HKS_DIGEST_SHA256,
688 true, HKS_PADDING_NONE,
689 true, HKS_MODE_CBC },
690 { false, 0 }
691 };
692
693 int32_t ret = TestConstuctBlob(keyAlias,
694 genKeyParam.keyAliasParams.blobExist,
695 genKeyParam.keyAliasParams.blobSize,
696 genKeyParam.keyAliasParams.blobDataExist,
697 genKeyParam.keyAliasParams.blobDataSize);
698 HKS_TEST_ASSERT(ret == 0);
699
700 struct HksParamSet *paramSet = NULL;
701 struct GenerateKeyParamSetStructure paramStruct = {
702 ¶mSet, genKeyParam.paramSetParams.paramSetExist,
703 genKeyParam.paramSetParams.setAlg, genKeyParam.paramSetParams.alg,
704 genKeyParam.paramSetParams.setKeySize, genKeyParam.paramSetParams.keySize,
705 genKeyParam.paramSetParams.setPurpose, genKeyParam.paramSetParams.purpose,
706 genKeyParam.paramSetParams.setDigest, genKeyParam.paramSetParams.digest,
707 genKeyParam.paramSetParams.setPadding, genKeyParam.paramSetParams.padding,
708 genKeyParam.paramSetParams.setBlockMode, genKeyParam.paramSetParams.mode,
709 false, 0
710 };
711 ret = TestConstructGenerateKeyParamSet(¶mStruct);
712 HKS_TEST_ASSERT(ret == 0);
713
714 ret = HksGenerateKey(*keyAlias, paramSet, NULL);
715 HKS_TEST_ASSERT(ret == 0);
716
717 HksFreeParamSet(¶mSet);
718 return ret;
719 }