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 "huks_three_stage_test_common.h"
17
18 static struct OH_Huks_Param g_genParamsTest001[] = {
19 {.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_DSA},
20 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN | OH_HUKS_KEY_PURPOSE_VERIFY},
21 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = 1024},
22 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SHA1},
23 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}};
24
InitParamSet(struct OH_Huks_ParamSet ** paramSet,const struct OH_Huks_Param * params,uint32_t paramcount)25 OH_Huks_Result InitParamSet(struct OH_Huks_ParamSet **paramSet, const struct OH_Huks_Param *params, uint32_t paramcount)
26 {
27 OH_Huks_Result ret = OH_Huks_InitParamSet(paramSet);
28 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
29 return ret;
30 }
31
32 ret = OH_Huks_AddParams(*paramSet, params, paramcount);
33 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
34 OH_Huks_FreeParamSet(paramSet);
35 return ret;
36 }
37
38 ret = OH_Huks_BuildParamSet(paramSet);
39 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
40 OH_Huks_FreeParamSet(paramSet);
41 return ret;
42 }
43
44 return ret;
45 }
46
TestLessThanMaxSeg(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,uint32_t purpose,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)47 static OH_Huks_Result TestLessThanMaxSeg(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
48 uint32_t purpose, const struct OH_Huks_Blob *inData,
49 struct OH_Huks_Blob *outData)
50 {
51 struct OH_Huks_Result ret;
52 ret.errorCode = OH_HUKS_SUCCESS;
53 struct OH_Huks_Blob tmpOutData = {.size = MAX_OUTDATA_SIZE, .data = NULL};
54 if (MallocAndCheckBlobData(&tmpOutData, tmpOutData.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
55 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
56 return ret;
57 }
58 ret = OH_Huks_UpdateSession(handle, paramSet, inData, &tmpOutData);
59 HksFree(tmpOutData.data);
60 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
61 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
62 return ret;
63 }
64 struct OH_Huks_Blob tmpInData = {.size = 0, .data = NULL};
65 if (MallocAndCheckBlobData(&tmpInData, MAX_UPDATE_SIZE).errorCode != (int32_t)OH_HUKS_SUCCESS) {
66 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
67 return ret;
68 }
69
70 if (purpose == OH_HUKS_KEY_PURPOSE_VERIFY) {
71 ret = OH_Huks_FinishSession(handle, paramSet, outData, &tmpInData);
72 } else {
73 ret = OH_Huks_FinishSession(handle, paramSet, &tmpInData, outData);
74 }
75 HksFree(tmpInData.data);
76 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
77 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
78 return ret;
79 }
80 return ret;
81 }
82
HksTestUpdate(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * inData)83 OH_Huks_Result HksTestUpdate(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
84 const struct OH_Huks_Blob *inData)
85 {
86 struct OH_Huks_Blob inDataSeg = *inData;
87 inDataSeg.size = MAX_UPDATE_SIZE;
88
89 struct OH_Huks_Result ret;
90 ret.errorCode = OH_HUKS_SUCCESS;
91
92 uint8_t *lastPtr = inData->data + inData->size - 1;
93 struct OH_Huks_Blob outDataSeg = {.size = MAX_OUTDATA_SIZE, .data = NULL};
94
95 bool isFinished = false;
96
97 while (inDataSeg.data <= lastPtr) {
98 if (inDataSeg.data + MAX_UPDATE_SIZE <= lastPtr) {
99 outDataSeg.size = MAX_OUTDATA_SIZE;
100 } else {
101 isFinished = true;
102 inDataSeg.size = lastPtr - inDataSeg.data + 1;
103 outDataSeg.size = inDataSeg.size + MAX_UPDATE_SIZE;
104 }
105 if (MallocAndCheckBlobData(&outDataSeg, outDataSeg.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
106 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
107 return ret;
108 }
109 if (OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &outDataSeg).errorCode != (int32_t)OH_HUKS_SUCCESS) {
110 HksFree(outDataSeg.data);
111 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
112 return ret;
113 }
114 HksFree(outDataSeg.data);
115 if ((isFinished == false) && (inDataSeg.data + MAX_UPDATE_SIZE > lastPtr)) {
116 return ret;
117 }
118 inDataSeg.data += MAX_UPDATE_SIZE;
119 }
120 return ret;
121 }
122
TestUpdateLoopFinish(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)123 OH_Huks_Result TestUpdateLoopFinish(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
124 const struct OH_Huks_Blob *inData, struct OH_Huks_Blob *outData)
125 {
126 struct OH_Huks_Result ret;
127 ret.errorCode = OH_HUKS_SUCCESS;
128
129 struct OH_Huks_Blob inDataSeg = *inData;
130 uint8_t *lastPtr = inData->data + inData->size - 1;
131 struct OH_Huks_Blob outDataSeg = {MAX_OUTDATA_SIZE, NULL};
132 uint8_t *cur = outData->data;
133 outData->size = 0;
134
135 inDataSeg.size = MAX_UPDATE_SIZE;
136
137 bool isFinished = false;
138
139 while (inDataSeg.data <= lastPtr) {
140 if (inDataSeg.data + MAX_UPDATE_SIZE <= lastPtr) {
141 outDataSeg.size = MAX_OUTDATA_SIZE;
142 } else {
143 isFinished = true;
144 inDataSeg.size = lastPtr - inDataSeg.data + 1;
145 break;
146 }
147 if (MallocAndCheckBlobData(&outDataSeg, outDataSeg.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
148 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
149 return ret;
150 }
151 if (OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &outDataSeg).errorCode != (int32_t)OH_HUKS_SUCCESS) {
152 HksFree(outDataSeg.data);
153 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
154 return ret;
155 }
156 (void)memcpy_s(cur, outDataSeg.size, outDataSeg.data, outDataSeg.size);
157 cur += outDataSeg.size;
158 outData->size += outDataSeg.size;
159 HksFree(outDataSeg.data);
160 if ((isFinished == false) && (inDataSeg.data + MAX_UPDATE_SIZE > lastPtr)) {
161 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
162 return ret;
163 }
164 inDataSeg.data += MAX_UPDATE_SIZE;
165 }
166
167 struct OH_Huks_Blob outDataFinish = {inDataSeg.size * TIMES, NULL};
168 if (MallocAndCheckBlobData(&outDataFinish, outDataFinish.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
169 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
170 return ret;
171 }
172 if (OH_Huks_FinishSession(handle, paramSet, &inDataSeg, &outDataFinish).errorCode != (int32_t)OH_HUKS_SUCCESS) {
173 HksFree(outDataFinish.data);
174 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
175 return ret;
176 }
177 (void)memcpy_s(cur, outDataFinish.size, outDataFinish.data, outDataFinish.size);
178 outData->size += outDataFinish.size;
179 HksFree(outDataFinish.data);
180
181 return ret;
182 }
183
TestUpdateFinish(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,uint32_t purpose,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)184 OH_Huks_Result TestUpdateFinish(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
185 uint32_t purpose, const struct OH_Huks_Blob *inData, struct OH_Huks_Blob *outData)
186 {
187 struct OH_Huks_Result ret;
188 ret.errorCode = OH_HUKS_SUCCESS;
189
190 struct OH_Huks_Blob inDataSeg = *inData;
191 inDataSeg.size = MAX_UPDATE_SIZE;
192
193 uint8_t *lastPtr = inData->data + inData->size - 1;
194 struct OH_Huks_Blob outDataSeg = {MAX_OUTDATA_SIZE, NULL};
195
196 bool isFinished = false;
197
198 if (inData->size <= MAX_UPDATE_SIZE) {
199 return TestLessThanMaxSeg(handle, paramSet, purpose, inData, outData);
200 }
201 while (inDataSeg.data <= lastPtr) {
202 if (inDataSeg.data + MAX_UPDATE_SIZE <= lastPtr) {
203 outDataSeg.size = MAX_OUTDATA_SIZE;
204 if (MallocAndCheckBlobData(&outDataSeg, outDataSeg.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
205 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
206 return ret;
207 }
208 } else {
209 isFinished = true;
210 inDataSeg.size = lastPtr - inDataSeg.data + 1;
211 break;
212 }
213 if (OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &outDataSeg).errorCode != (int32_t)OH_HUKS_SUCCESS) {
214 HksFree(outDataSeg.data);
215 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
216 return ret;
217 }
218 HksFree(outDataSeg.data);
219 if ((isFinished == false) && (inDataSeg.data + MAX_UPDATE_SIZE > lastPtr)) {
220 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
221 return ret;
222 }
223 inDataSeg.data += MAX_UPDATE_SIZE;
224 }
225
226 if (purpose != OH_HUKS_KEY_PURPOSE_VERIFY) {
227 if (OH_Huks_FinishSession(handle, paramSet, &inDataSeg, outData).errorCode != (int32_t)OH_HUKS_SUCCESS) {
228 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
229 return ret;
230 }
231 } else {
232 uint8_t tmp[] = "temp";
233 struct OH_Huks_Blob tempBlob = {sizeof(tmp), tmp};
234 if (OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &tempBlob).errorCode != (int32_t)OH_HUKS_SUCCESS) {
235 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
236 return ret;
237 }
238 if (OH_Huks_FinishSession(handle, paramSet, outData, &tempBlob).errorCode != (int32_t)OH_HUKS_SUCCESS) {
239 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
240 return ret;
241 }
242 }
243 return ret;
244 }
245
MallocAndCheckBlobData(struct OH_Huks_Blob * blob,const uint32_t blobSize)246 OH_Huks_Result MallocAndCheckBlobData(struct OH_Huks_Blob *blob, const uint32_t blobSize)
247 {
248 struct OH_Huks_Result ret;
249 ret.errorCode = OH_HUKS_SUCCESS;
250
251 blob->data = (uint8_t *)HksMalloc(blobSize);
252 if (blob->data == NULL) {
253 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
254 }
255
256 return ret;
257 }
258
TestCmpKeyAliasHash(const struct OH_Huks_Blob * srcData1,const struct OH_Huks_Blob * srcData2)259 OH_Huks_Result TestCmpKeyAliasHash(const struct OH_Huks_Blob *srcData1, const struct OH_Huks_Blob *srcData2)
260 {
261 struct OH_Huks_Result ret;
262 ret.errorCode = OH_HUKS_SUCCESS;
263
264 struct OH_Huks_Param hashParam = {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SHA256};
265 struct OH_Huks_ParamSet *hashParamSet = NULL;
266 ret = InitParamSet(&hashParamSet, &hashParam, sizeof(hashParam) / sizeof(struct OH_Huks_Param));
267 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
268 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
269 return ret;
270 }
271
272 struct OH_Huks_Blob hash1 = {MAX_OUTDATA_SIZE, NULL};
273 if (MallocAndCheckBlobData(&hash1, hash1.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
274 OH_Huks_FreeParamSet(&hashParamSet);
275 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
276 return ret;
277 }
278 ret = HuksHash(hashParamSet, srcData1, &hash1);
279 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
280 OH_Huks_FreeParamSet(&hashParamSet);
281 HksFree(hash1.data);
282 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
283 return ret;
284 }
285
286 struct OH_Huks_Blob hash2 = {MAX_OUTDATA_SIZE, NULL};
287 if (MallocAndCheckBlobData(&hash2, hash2.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
288 HksFree(hash1.data);
289 OH_Huks_FreeParamSet(&hashParamSet);
290 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
291 return ret;
292 }
293 ret = HuksHash(hashParamSet, srcData2, &hash2);
294 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
295 OH_Huks_FreeParamSet(&hashParamSet);
296 HksFree(hash1.data);
297 HksFree(hash2.data);
298 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
299 return ret;
300 }
301
302 int32_t ret1 = HksMemCmp(hash1.data, hash2.data, hash2.size);
303 ret.errorCode = ret1;
304 OH_Huks_FreeParamSet(&hashParamSet);
305 HksFree(hash1.data);
306 HksFree(hash2.data);
307
308 return ret;
309 }
310
HksEncryptLoopUpdate(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)311 static OH_Huks_Result HksEncryptLoopUpdate(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
312 const struct OH_Huks_Blob *inData, struct OH_Huks_Blob *outData)
313 {
314 struct OH_Huks_Result ret;
315 ret.errorCode = OH_HUKS_SUCCESS;
316
317 struct OH_Huks_Blob inDataSeg = *inData;
318 uint8_t *lastPtr = inData->data + inData->size - 1;
319 struct OH_Huks_Blob outDataSeg = {MAX_OUTDATA_SIZE, NULL};
320 uint8_t *cur = outData->data;
321 outData->size = 0;
322
323 inDataSeg.size = MAX_UPDATE_SIZE;
324 bool isFinished = false;
325
326 while (inDataSeg.data <= lastPtr) {
327 if (inDataSeg.data + MAX_UPDATE_SIZE <= lastPtr) {
328 outDataSeg.size = MAX_OUTDATA_SIZE;
329 } else {
330 isFinished = true;
331 inDataSeg.size = lastPtr - inDataSeg.data + 1;
332 break;
333 }
334 if (MallocAndCheckBlobData(&outDataSeg, outDataSeg.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
335 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
336 return ret;
337 }
338 ret = OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &outDataSeg);
339 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
340 free(outDataSeg.data);
341 return ret;
342 }
343 (void)memcpy_s(cur, outDataSeg.size, outDataSeg.data, outDataSeg.size);
344 cur += outDataSeg.size;
345 outData->size += outDataSeg.size;
346 free(outDataSeg.data);
347 if ((isFinished == false) && (inDataSeg.data + MAX_UPDATE_SIZE > lastPtr)) {
348 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
349 return ret;
350 }
351 inDataSeg.data += MAX_UPDATE_SIZE;
352 }
353
354 struct OH_Huks_Blob outDataFinish = {inDataSeg.size * TIMES, NULL};
355 if (MallocAndCheckBlobData(&outDataFinish, outDataFinish.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
356 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
357 return ret;
358 }
359
360 ret = OH_Huks_FinishSession(handle, paramSet, &inDataSeg, &outDataFinish);
361 if (ret.errorCode != OH_HUKS_SUCCESS) {
362 free(outDataFinish.data);
363 return ret;
364 }
365 (void)memcpy_s(cur, outDataFinish.size, outDataFinish.data, outDataFinish.size);
366 outData->size += outDataFinish.size;
367 free(outDataFinish.data);
368
369 return ret;
370 }
371
HuksEncrypt(const struct OH_Huks_Blob * key,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * plainText,struct OH_Huks_Blob * cipherText)372 OH_Huks_Result HuksEncrypt(const struct OH_Huks_Blob *key, const struct OH_Huks_ParamSet *paramSet,
373 const struct OH_Huks_Blob *plainText, struct OH_Huks_Blob *cipherText)
374 {
375 uint8_t handle[sizeof(uint64_t)] = {0};
376 struct OH_Huks_Blob handleBlob = {sizeof(uint64_t), handle};
377 OH_Huks_Result ret = OH_Huks_InitSession(key, paramSet, &handleBlob, nullptr);
378 if (ret.errorCode != OH_HUKS_SUCCESS) {
379 return ret;
380 }
381
382 ret = HksEncryptLoopUpdate(&handleBlob, paramSet, plainText, cipherText);
383 return ret;
384 }
385
HksDecryptLoopUpdate(const struct OH_Huks_Blob * handle,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)386 static OH_Huks_Result HksDecryptLoopUpdate(const struct OH_Huks_Blob *handle, const struct OH_Huks_ParamSet *paramSet,
387 const struct OH_Huks_Blob *inData, struct OH_Huks_Blob *outData)
388 {
389 struct OH_Huks_Result ret;
390 ret.errorCode = OH_HUKS_SUCCESS;
391
392 struct OH_Huks_Blob inDataSeg = *inData;
393 uint8_t *lastPtr = inData->data + inData->size - 1;
394 struct OH_Huks_Blob outDataSeg = {MAX_OUTDATA_SIZE, NULL};
395 uint8_t *cur = outData->data;
396 outData->size = 0;
397
398 inDataSeg.size = MAX_UPDATE_SIZE;
399
400 bool isFinished = false;
401
402 while (inDataSeg.data <= lastPtr) {
403 if (inDataSeg.data + MAX_UPDATE_SIZE <= lastPtr) {
404 outDataSeg.size = MAX_OUTDATA_SIZE;
405 } else {
406 isFinished = true;
407 inDataSeg.size = lastPtr - inDataSeg.data + 1;
408 break;
409 }
410 if (MallocAndCheckBlobData(&outDataSeg, outDataSeg.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
411 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
412 return ret;
413 }
414 struct OH_Huks_Result result = OH_Huks_UpdateSession(handle, paramSet, &inDataSeg, &outDataSeg);
415 if (result.errorCode != OH_HUKS_SUCCESS) {
416 free(outDataSeg.data);
417 return result;
418 }
419 (void)memcpy_s(cur, outDataSeg.size, outDataSeg.data, outDataSeg.size);
420 cur += outDataSeg.size;
421 outData->size += outDataSeg.size;
422 free(outDataSeg.data);
423 if ((isFinished == false) && (inDataSeg.data + MAX_UPDATE_SIZE > lastPtr)) {
424 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
425 return ret;
426 }
427 inDataSeg.data += MAX_UPDATE_SIZE;
428 }
429
430 struct OH_Huks_Blob outDataFinish = {inDataSeg.size * TIMES, NULL};
431 if (MallocAndCheckBlobData(&outDataFinish, outDataFinish.size).errorCode != (int32_t)OH_HUKS_SUCCESS) {
432 ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
433 return ret;
434 }
435
436 struct OH_Huks_Result result2 = OH_Huks_FinishSession(handle, paramSet, &inDataSeg, &outDataFinish);
437 if (result2.errorCode != OH_HUKS_SUCCESS) {
438 free(outDataFinish.data);
439 return result2;
440 }
441 (void)memcpy_s(cur, outDataFinish.size, outDataFinish.data, outDataFinish.size);
442 outData->size += outDataFinish.size;
443 free(outDataFinish.data);
444
445 return ret;
446 }
447
HuksDecrypt(const struct OH_Huks_Blob * key,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * cipherText,struct OH_Huks_Blob * plainText)448 OH_Huks_Result HuksDecrypt(const struct OH_Huks_Blob *key, const struct OH_Huks_ParamSet *paramSet,
449 const struct OH_Huks_Blob *cipherText, struct OH_Huks_Blob *plainText)
450 {
451 uint8_t handle[sizeof(uint64_t)] = {0};
452 struct OH_Huks_Blob handleBlob = {sizeof(uint64_t), handle};
453 struct OH_Huks_Result result = OH_Huks_InitSession(key, paramSet, &handleBlob, nullptr);
454 if (result.errorCode != OH_HUKS_SUCCESS) {
455 return result;
456 }
457
458 OH_Huks_Result ret = HksDecryptLoopUpdate(&handleBlob, paramSet, cipherText, plainText);
459 return ret;
460 }
461
HksGetDigestLen(uint32_t digest,uint32_t * digestLen)462 static int32_t HksGetDigestLen(uint32_t digest, uint32_t *digestLen)
463 {
464 switch (digest) {
465 case OH_HUKS_DIGEST_MD5:
466 *digestLen = HKS_DIGEST_MD5_LEN;
467 break;
468 case OH_HUKS_DIGEST_SHA1:
469 *digestLen = HKS_DIGEST_SHA1_LEN;
470 break;
471 case OH_HUKS_DIGEST_SHA224:
472 *digestLen = HKS_DIGEST_SHA224_LEN;
473 break;
474 case OH_HUKS_DIGEST_SHA256:
475 *digestLen = HKS_DIGEST_SHA256_LEN;
476 break;
477 case OH_HUKS_DIGEST_SHA384:
478 *digestLen = HKS_DIGEST_SHA384_LEN;
479 break;
480 case OH_HUKS_DIGEST_SHA512:
481 *digestLen = HKS_DIGEST_SHA512_LEN;
482 break;
483 case OH_HUKS_DIGEST_SM3:
484 *digestLen = HKS_DIGEST_SM3_LEN;
485 break;
486 default:
487 return OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
488 }
489 return OH_HUKS_SUCCESS;
490 }
491
GetOpensslAlg(uint32_t alg)492 static const EVP_MD *GetOpensslAlg(uint32_t alg)
493 {
494 switch (alg) {
495 case OH_HUKS_DIGEST_MD5:
496 return EVP_md5();
497 case OH_HUKS_DIGEST_SHA1:
498 return EVP_sha1();
499 case OH_HUKS_DIGEST_SHA224:
500 return EVP_sha224();
501 case OH_HUKS_DIGEST_SHA256:
502 return EVP_sha256();
503 case OH_HUKS_DIGEST_SHA384:
504 return EVP_sha384();
505 case OH_HUKS_DIGEST_SHA512:
506 return EVP_sha512();
507 default:
508 return NULL;
509 }
510 }
511
HksOpensslHash(uint32_t alg,const struct OH_Huks_Blob * msg,struct OH_Huks_Blob * hash)512 static int32_t HksOpensslHash(uint32_t alg, const struct OH_Huks_Blob *msg, struct OH_Huks_Blob *hash)
513 {
514 const EVP_MD *opensslAlg = GetOpensslAlg(alg);
515 if (opensslAlg == NULL) {
516 return OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
517 }
518
519 int32_t ret = EVP_Digest(msg->data, msg->size, hash->data, &hash->size, opensslAlg, NULL);
520 if (ret != 1) {
521 return OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
522 }
523 return (int32_t)OH_HUKS_SUCCESS;
524 }
525
HuksHash(const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * srcData,struct OH_Huks_Blob * hash)526 OH_Huks_Result HuksHash(const struct OH_Huks_ParamSet *paramSet, const struct OH_Huks_Blob *srcData,
527 struct OH_Huks_Blob *hash)
528 {
529 OH_Huks_Result ret;
530
531 if ((paramSet == NULL) || (srcData == NULL) || (hash == NULL)) {
532 ret.errorCode = OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
533 return ret;
534 }
535
536 struct OH_Huks_Param *digestAlg = NULL;
537 ret = OH_Huks_GetParam(paramSet, OH_HUKS_TAG_DIGEST, &digestAlg);
538 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
539 return ret;
540 }
541
542 uint32_t digestLen;
543 int32_t ret1 = HksGetDigestLen(digestAlg->uint32Param, &digestLen);
544 ret.errorCode = ret1;
545 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
546 return ret;
547 }
548
549 if (hash->size < digestLen) {
550 ret.errorCode = OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
551 return ret;
552 }
553 ret1 = HksOpensslHash(digestAlg->uint32Param, srcData, hash);
554 ret.errorCode = ret1;
555 return ret;
556 }
557
HuksAgreeKey(const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * keyAlias,const struct OH_Huks_Blob * peerPublicKey,struct OH_Huks_Blob * agreedKey)558 OH_Huks_Result HuksAgreeKey(const struct OH_Huks_ParamSet *paramSet, const struct OH_Huks_Blob *keyAlias,
559 const struct OH_Huks_Blob *peerPublicKey, struct OH_Huks_Blob *agreedKey)
560 {
561 uint8_t temp[10] = {0};
562 struct OH_Huks_Blob inData = {sizeof(temp), temp};
563
564 uint8_t handleU[sizeof(uint64_t)] = {0};
565 struct OH_Huks_Blob handle = {sizeof(uint64_t), handleU};
566 OH_Huks_Result ret = OH_Huks_InitSession(keyAlias, paramSet, &handle, nullptr);
567 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
568 return ret;
569 }
570
571 uint8_t outDataU[1024] = {0};
572 struct OH_Huks_Blob outDataUpdate = {1024, outDataU};
573 ret = OH_Huks_UpdateSession(&handle, paramSet, peerPublicKey, &outDataUpdate);
574 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
575 return ret;
576 }
577
578 ret = OH_Huks_FinishSession(&handle, paramSet, &inData, agreedKey);
579 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
580 return ret;
581 }
582 return ret;
583 }
584
checkUseSoftware()585 bool checkUseSoftware()
586 {
587 const char *keyAliasString = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
588 struct OH_Huks_ParamSet *genParamSet = nullptr;
589 struct OH_Huks_Blob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
590 InitParamSet(&genParamSet, g_genParamsTest001, sizeof(g_genParamsTest001) / sizeof(OH_Huks_Param));
591 OH_Huks_Result ret = OH_Huks_GenerateKeyItem(&keyAlias, genParamSet, nullptr);
592 if (ret.errorCode == 0) {
593 OH_Huks_DeleteKeyItem(&keyAlias, genParamSet);
594 OH_Huks_FreeParamSet(&genParamSet);
595 return true;
596 }
597 return false;
598 }