1 /*
2 * Copyright (c) 2024 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_log.h"
18 #include "hks_mem.h"
19 #include "hks_param.h"
20
GenerateParamSet(struct HksParamSet ** paramSet,const struct HksParam tmpParams[],uint32_t paramCount)21 static int32_t GenerateParamSet(struct HksParamSet **paramSet, const struct HksParam tmpParams[], uint32_t paramCount)
22 {
23 int32_t ret = HksInitParamSet(paramSet);
24 if (ret != HKS_SUCCESS) {
25 HKS_LOG_E("HksInitParamSet failed");
26 return ret;
27 }
28
29 if (tmpParams != NULL) {
30 ret = HksAddParams(*paramSet, tmpParams, paramCount);
31 if (ret != HKS_SUCCESS) {
32 HKS_LOG_E("HksAddParams failed");
33 HksFreeParamSet(paramSet);
34 return ret;
35 }
36 }
37
38 ret = HksBuildParamSet(paramSet);
39 if (ret != HKS_SUCCESS) {
40 HKS_LOG_E("HksBuildParamSet failed");
41 HksFreeParamSet(paramSet);
42 return ret;
43 }
44 return ret;
45 }
46
ConstructNewParamSet(const struct HksParamSet * paramSet,struct HksParamSet ** newParamSet)47 int32_t ConstructNewParamSet(const struct HksParamSet *paramSet, struct HksParamSet **newParamSet)
48 {
49 int32_t ret = HksCheckParamSet(paramSet, paramSet->paramSetSize);
50 if (ret != HKS_SUCCESS) {
51 HKS_LOG_E("check paramSet fail");
52 return ret;
53 }
54 ret = HksInitParamSet(newParamSet);
55 if (ret != HKS_SUCCESS) {
56 HKS_LOG_E("init paramSet fail");
57 return ret;
58 }
59 do {
60 ret = HksAddParams(*newParamSet, paramSet->params, paramSet->paramsCnt);
61 if (ret != HKS_SUCCESS) {
62 HKS_LOG_E("copy params fail");
63 break;
64 }
65 struct HksParam storageLevel = {
66 .tag = HKS_TAG_AUTH_STORAGE_LEVEL,
67 .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE
68 };
69 ret = HksAddParams(*newParamSet, &storageLevel, 1);
70 if (ret != HKS_SUCCESS) {
71 HKS_LOG_E("add param attestMode fail");
72 break;
73 }
74 ret = HksBuildParamSet(newParamSet);
75 if (ret != HKS_SUCCESS) {
76 HKS_LOG_E("build paramSet fail");
77 break;
78 }
79 return HKS_SUCCESS;
80 } while (false);
81 HksFreeParamSet(newParamSet);
82 return ret;
83 }
84
HksGenerateKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksParamSet * paramSetOut)85 int32_t HksGenerateKeyForDe(const struct HksBlob *keyAlias,
86 const struct HksParamSet *paramSet, struct HksParamSet *paramSetOut)
87 {
88 int32_t ret;
89 struct HksParamSet *newParamSet = NULL;
90 if (paramSet != NULL) {
91 ret = ConstructNewParamSet(paramSet, &newParamSet);
92 } else {
93 struct HksParam tmpParams[] = {
94 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
95 };
96 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
97 }
98 if (ret != HKS_SUCCESS) {
99 HKS_LOG_E("construct new paramSet fail");
100 return ret;
101 }
102 ret = HksGenerateKey(keyAlias, newParamSet, paramSetOut);
103 HksFreeParamSet(&newParamSet);
104 return ret;
105 }
106
HksImportKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,const struct HksBlob * key)107 int32_t HksImportKeyForDe(const struct HksBlob *keyAlias,
108 const struct HksParamSet *paramSet, const struct HksBlob *key)
109 {
110 int32_t ret;
111 struct HksParamSet *newParamSet = NULL;
112 if (paramSet != NULL) {
113 ret = ConstructNewParamSet(paramSet, &newParamSet);
114 } else {
115 struct HksParam tmpParams[] = {
116 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
117 };
118 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
119 }
120 if (ret != HKS_SUCCESS) {
121 HKS_LOG_E("construct new paramSet fail");
122 return ret;
123 }
124 ret = HksImportKey(keyAlias, newParamSet, key);
125 HksFreeParamSet(&newParamSet);
126 return ret;
127 }
128
HksImportWrappedKeyForDe(const struct HksBlob * keyAlias,const struct HksBlob * wrappingKeyAlias,const struct HksParamSet * paramSet,const struct HksBlob * wrappedKeyData)129 int32_t HksImportWrappedKeyForDe(const struct HksBlob *keyAlias, const struct HksBlob *wrappingKeyAlias,
130 const struct HksParamSet *paramSet, const struct HksBlob *wrappedKeyData)
131 {
132 int32_t ret;
133 struct HksParamSet *newParamSet = NULL;
134 if (paramSet != NULL) {
135 ret = ConstructNewParamSet(paramSet, &newParamSet);
136 } else {
137 struct HksParam tmpParams[] = {
138 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
139 };
140 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
141 }
142 if (ret != HKS_SUCCESS) {
143 HKS_LOG_E("construct new paramSet fail");
144 return ret;
145 }
146 ret = HksImportWrappedKey(keyAlias, wrappingKeyAlias, newParamSet, wrappedKeyData);
147 HksFreeParamSet(&newParamSet);
148 return ret;
149 }
150
HksExportPublicKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksBlob * key)151 int32_t HksExportPublicKeyForDe(const struct HksBlob *keyAlias,
152 const struct HksParamSet *paramSet, struct HksBlob *key)
153 {
154 int32_t ret;
155 struct HksParamSet *newParamSet = NULL;
156 if (paramSet != NULL) {
157 ret = ConstructNewParamSet(paramSet, &newParamSet);
158 } else {
159 struct HksParam tmpParams[] = {
160 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
161 };
162 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
163 }
164 if (ret != HKS_SUCCESS) {
165 HKS_LOG_E("construct new paramSet fail");
166 return ret;
167 }
168 ret = HksExportPublicKey(keyAlias, newParamSet, key);
169 HksFreeParamSet(&newParamSet);
170 return ret;
171 }
172
HksDeleteKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet)173 int32_t HksDeleteKeyForDe(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet)
174 {
175 int32_t ret;
176 struct HksParamSet *newParamSet = NULL;
177 if (paramSet != NULL) {
178 ret = ConstructNewParamSet(paramSet, &newParamSet);
179 } else {
180 struct HksParam tmpParams[] = {
181 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
182 };
183 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
184 }
185 if (ret != HKS_SUCCESS) {
186 HKS_LOG_E("construct or generate new paramSet fail");
187 return ret;
188 }
189 ret = HksDeleteKey(keyAlias, newParamSet);
190 HksFreeParamSet(&newParamSet);
191 return ret;
192 }
193
HksGetKeyParamSetForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksParamSet * paramSetOut)194 int32_t HksGetKeyParamSetForDe(const struct HksBlob *keyAlias,
195 const struct HksParamSet *paramSet, struct HksParamSet *paramSetOut)
196 {
197 int32_t ret;
198 struct HksParamSet *newParamSet = NULL;
199 if (paramSet != NULL) {
200 ret = ConstructNewParamSet(paramSet, &newParamSet);
201 } else {
202 struct HksParam tmpParams[] = {
203 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
204 };
205 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
206 }
207 if (ret != HKS_SUCCESS) {
208 HKS_LOG_E("construct new paramSet fail");
209 return ret;
210 }
211 ret = HksGetKeyParamSet(keyAlias, newParamSet, paramSetOut);
212 HksFreeParamSet(&newParamSet);
213 return ret;
214 }
215
HksKeyExistForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet)216 int32_t HksKeyExistForDe(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet)
217 {
218 int32_t ret;
219 struct HksParamSet *newParamSet = NULL;
220 if (paramSet != NULL) {
221 ret = ConstructNewParamSet(paramSet, &newParamSet);
222 } else {
223 struct HksParam tmpParams[] = {
224 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
225 };
226 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
227 }
228 if (ret != HKS_SUCCESS) {
229 HKS_LOG_E("construct new paramSet fail");
230 return ret;
231 }
232 ret = HksKeyExist(keyAlias, newParamSet);
233 HksFreeParamSet(&newParamSet);
234 return ret;
235 }
236
HksSignForDe(const struct HksBlob * key,const struct HksParamSet * paramSet,const struct HksBlob * srcData,struct HksBlob * signature)237 int32_t HksSignForDe(const struct HksBlob *key, const struct HksParamSet *paramSet,
238 const struct HksBlob *srcData, struct HksBlob *signature)
239 {
240 int32_t ret;
241 struct HksParamSet *newParamSet = NULL;
242 if (paramSet != NULL) {
243 ret = ConstructNewParamSet(paramSet, &newParamSet);
244 } else {
245 struct HksParam tmpParams[] = {
246 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
247 };
248 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
249 }
250 if (ret != HKS_SUCCESS) {
251 HKS_LOG_E("construct new paramSet fail");
252 return ret;
253 }
254 ret = HksSign(key, newParamSet, srcData, signature);
255 HksFreeParamSet(&newParamSet);
256 return ret;
257 }
258
HksVerifyForDe(const struct HksBlob * key,const struct HksParamSet * paramSet,const struct HksBlob * srcData,const struct HksBlob * signature)259 int32_t HksVerifyForDe(const struct HksBlob *key, const struct HksParamSet *paramSet,
260 const struct HksBlob *srcData, const struct HksBlob *signature)
261 {
262 int32_t ret;
263 struct HksParamSet *newParamSet = NULL;
264 if (paramSet != NULL) {
265 ret = ConstructNewParamSet(paramSet, &newParamSet);
266 } else {
267 struct HksParam tmpParams[] = {
268 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
269 };
270 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
271 }
272 if (ret != HKS_SUCCESS) {
273 HKS_LOG_E("construct new paramSet fail");
274 return ret;
275 }
276 ret = HksVerify(key, newParamSet, srcData, signature);
277 HksFreeParamSet(&newParamSet);
278 return ret;
279 }
280
HksEncryptForDe(const struct HksBlob * key,const struct HksParamSet * paramSet,const struct HksBlob * plainText,struct HksBlob * cipherText)281 int32_t HksEncryptForDe(const struct HksBlob *key, const struct HksParamSet *paramSet,
282 const struct HksBlob *plainText, struct HksBlob *cipherText)
283 {
284 int32_t ret;
285 struct HksParamSet *newParamSet = NULL;
286 if (paramSet != NULL) {
287 ret = ConstructNewParamSet(paramSet, &newParamSet);
288 } else {
289 struct HksParam tmpParams[] = {
290 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
291 };
292 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
293 }
294 if (ret != HKS_SUCCESS) {
295 HKS_LOG_E("construct new paramSet fail");
296 return ret;
297 }
298 ret = HksEncrypt(key, newParamSet, plainText, cipherText);
299 HksFreeParamSet(&newParamSet);
300 return ret;
301 }
302
HksDecryptForDe(const struct HksBlob * key,const struct HksParamSet * paramSet,const struct HksBlob * cipherText,struct HksBlob * plainText)303 int32_t HksDecryptForDe(const struct HksBlob *key, const struct HksParamSet *paramSet,
304 const struct HksBlob *cipherText, struct HksBlob *plainText)
305 {
306 int32_t ret;
307 struct HksParamSet *newParamSet = NULL;
308 if (paramSet != NULL) {
309 ret = ConstructNewParamSet(paramSet, &newParamSet);
310 } else {
311 struct HksParam tmpParams[] = {
312 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
313 };
314 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
315 }
316 if (ret != HKS_SUCCESS) {
317 HKS_LOG_E("construct new paramSet fail");
318 return ret;
319 }
320 ret = HksDecrypt(key, newParamSet, cipherText, plainText);
321 HksFreeParamSet(&newParamSet);
322 return ret;
323 }
324
HksAgreeKeyForDe(const struct HksParamSet * paramSet,const struct HksBlob * privateKey,const struct HksBlob * peerPublicKey,struct HksBlob * agreedKey)325 int32_t HksAgreeKeyForDe(const struct HksParamSet *paramSet, const struct HksBlob *privateKey,
326 const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey)
327 {
328 int32_t ret;
329 struct HksParamSet *newParamSet = NULL;
330 if (paramSet != NULL) {
331 ret = ConstructNewParamSet(paramSet, &newParamSet);
332 } else {
333 struct HksParam tmpParams[] = {
334 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
335 };
336 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
337 }
338 if (ret != HKS_SUCCESS) {
339 HKS_LOG_E("construct new paramSet fail");
340 return ret;
341 }
342 ret = HksAgreeKey(newParamSet, privateKey, peerPublicKey, agreedKey);
343 HksFreeParamSet(&newParamSet);
344 return ret;
345 }
346
HksDeriveKeyForDe(const struct HksParamSet * paramSet,const struct HksBlob * mainKey,struct HksBlob * derivedKey)347 int32_t HksDeriveKeyForDe(const struct HksParamSet *paramSet, const struct HksBlob *mainKey,
348 struct HksBlob *derivedKey)
349 {
350 int32_t ret;
351 struct HksParamSet *newParamSet = NULL;
352 if (paramSet != NULL) {
353 ret = ConstructNewParamSet(paramSet, &newParamSet);
354 } else {
355 struct HksParam tmpParams[] = {
356 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
357 };
358 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
359 }
360 if (ret != HKS_SUCCESS) {
361 HKS_LOG_E("construct new paramSet fail");
362 return ret;
363 }
364 ret = HksDeriveKey(newParamSet, mainKey, derivedKey);
365 HksFreeParamSet(&newParamSet);
366 return ret;
367 }
368
HksMacForDe(const struct HksBlob * key,const struct HksParamSet * paramSet,const struct HksBlob * srcData,struct HksBlob * mac)369 int32_t HksMacForDe(const struct HksBlob *key, const struct HksParamSet *paramSet,
370 const struct HksBlob *srcData, struct HksBlob *mac)
371 {
372 int32_t ret;
373 struct HksParamSet *newParamSet = NULL;
374 if (paramSet != NULL) {
375 ret = ConstructNewParamSet(paramSet, &newParamSet);
376 } else {
377 struct HksParam tmpParams[] = {
378 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
379 };
380 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
381 }
382 if (ret != HKS_SUCCESS) {
383 HKS_LOG_E("construct new paramSet fail");
384 return ret;
385 }
386 ret = HksMac(key, newParamSet, srcData, mac);
387 HksFreeParamSet(&newParamSet);
388 return ret;
389 }
390
HksGetKeyInfoListForDe(const struct HksParamSet * paramSet,struct HksKeyInfo * keyInfoList,uint32_t * listCount)391 int32_t HksGetKeyInfoListForDe(const struct HksParamSet *paramSet,
392 struct HksKeyInfo *keyInfoList, uint32_t *listCount)
393 {
394 int32_t ret;
395 struct HksParamSet *newParamSet = NULL;
396 if (paramSet != NULL) {
397 ret = ConstructNewParamSet(paramSet, &newParamSet);
398 } else {
399 struct HksParam tmpParams[] = {
400 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
401 };
402 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
403 }
404 if (ret != HKS_SUCCESS) {
405 HKS_LOG_E("construct new paramSet fail");
406 return ret;
407 }
408 ret = HksGetKeyInfoList(newParamSet, keyInfoList, listCount);
409 HksFreeParamSet(&newParamSet);
410 return ret;
411 }
412
HksAttestKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksCertChain * certChain)413 int32_t HksAttestKeyForDe(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet,
414 struct HksCertChain *certChain)
415 {
416 int32_t ret;
417 struct HksParamSet *newParamSet = NULL;
418 if (paramSet != NULL) {
419 ret = ConstructNewParamSet(paramSet, &newParamSet);
420 } else {
421 struct HksParam tmpParams[] = {
422 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
423 };
424 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
425 }
426 if (ret != HKS_SUCCESS) {
427 HKS_LOG_E("construct new paramSet fail");
428 return ret;
429 }
430 ret = HksAttestKey(keyAlias, newParamSet, certChain);
431 HksFreeParamSet(&newParamSet);
432 return ret;
433 }
434
HksAnonAttestKeyForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksCertChain * certChain)435 int32_t HksAnonAttestKeyForDe(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet,
436 struct HksCertChain *certChain)
437 {
438 int32_t ret;
439 struct HksParamSet *newParamSet = NULL;
440 if (paramSet != NULL) {
441 ret = ConstructNewParamSet(paramSet, &newParamSet);
442 } else {
443 struct HksParam tmpParams[] = {
444 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
445 };
446 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
447 }
448 if (ret != HKS_SUCCESS) {
449 HKS_LOG_E("construct new paramSet fail");
450 return ret;
451 }
452 ret = HksAnonAttestKey(keyAlias, newParamSet, certChain);
453 HksFreeParamSet(&newParamSet);
454 return ret;
455 }
456
HksInitForDe(const struct HksBlob * keyAlias,const struct HksParamSet * paramSet,struct HksBlob * handle,struct HksBlob * token)457 int32_t HksInitForDe(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet,
458 struct HksBlob *handle, struct HksBlob *token)
459 {
460 int32_t ret;
461 struct HksParamSet *newParamSet = NULL;
462 if (paramSet != NULL) {
463 ret = ConstructNewParamSet(paramSet, &newParamSet);
464 } else {
465 struct HksParam tmpParams[] = {
466 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
467 };
468 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
469 }
470 if (ret != HKS_SUCCESS) {
471 HKS_LOG_E("construct new paramSet fail");
472 return ret;
473 }
474 ret = HksInit(keyAlias, newParamSet, handle, token);
475 HksFreeParamSet(&newParamSet);
476 return ret;
477 }
478
HksUpdateForDe(const struct HksBlob * handle,const struct HksParamSet * paramSet,const struct HksBlob * inData,struct HksBlob * outData)479 int32_t HksUpdateForDe(const struct HksBlob *handle, const struct HksParamSet *paramSet,
480 const struct HksBlob *inData, struct HksBlob *outData)
481 {
482 int32_t ret;
483 struct HksParamSet *newParamSet = NULL;
484 if (paramSet != NULL) {
485 ret = ConstructNewParamSet(paramSet, &newParamSet);
486 } else {
487 struct HksParam tmpParams[] = {
488 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
489 };
490 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
491 }
492 if (ret != HKS_SUCCESS) {
493 HKS_LOG_E("construct new paramSet fail");
494 return ret;
495 }
496 ret = HksUpdate(handle, newParamSet, inData, outData);
497 HksFreeParamSet(&newParamSet);
498 return ret;
499 }
500
HksFinishForDe(const struct HksBlob * handle,const struct HksParamSet * paramSet,const struct HksBlob * inData,struct HksBlob * outData)501 int32_t HksFinishForDe(const struct HksBlob *handle, const struct HksParamSet *paramSet,
502 const struct HksBlob *inData, struct HksBlob *outData)
503 {
504 int32_t ret;
505 struct HksParamSet *newParamSet = NULL;
506 if (paramSet != NULL) {
507 ret = ConstructNewParamSet(paramSet, &newParamSet);
508 } else {
509 struct HksParam tmpParams[] = {
510 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
511 };
512 ret = GenerateParamSet(&newParamSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
513 }
514 if (ret != HKS_SUCCESS) {
515 HKS_LOG_E("construct new paramSet fail");
516 return ret;
517 }
518 ret = HksFinish(handle, newParamSet, inData, outData);
519 HksFreeParamSet(&newParamSet);
520 return ret;
521 }
522