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