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