1 /*
2 * Copyright (c) 2021-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_param.h"
17
18 #include <stddef.h>
19
20 #include "hks_log.h"
21 #include "hks_mem.h"
22 #include "hks_template.h"
23 #include "hks_type_inner.h"
24
25 #include "securec.h"
26
27 static uint32_t g_validTags[] = {
28 HKS_TAG_ALGORITHM,
29 HKS_TAG_PURPOSE,
30 HKS_TAG_KEY_SIZE,
31 HKS_TAG_DIGEST,
32 HKS_TAG_PADDING,
33 HKS_TAG_BLOCK_MODE,
34 HKS_TAG_KEY_TYPE,
35 HKS_TAG_ASSOCIATED_DATA,
36 HKS_TAG_NONCE,
37 HKS_TAG_IV,
38
39 HKS_TAG_SALT,
40 HKS_TAG_PWD,
41 HKS_TAG_INFO,
42 HKS_TAG_ITERATION,
43
44 HKS_TAG_KEY_GENERATE_TYPE,
45 HKS_TAG_DERIVE_MAIN_KEY,
46 HKS_TAG_DERIVE_FACTOR,
47 HKS_TAG_DERIVE_ALG,
48 HKS_TAG_AGREE_ALG,
49 HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS,
50 HKS_TAG_AGREE_PRIVATE_KEY_ALIAS,
51 HKS_TAG_AGREE_PUBLIC_KEY,
52 HKS_TAG_KEY_ALIAS,
53 HKS_TAG_DERIVE_KEY_SIZE,
54 HKS_TAG_IMPORT_KEY_TYPE,
55 HKS_TAG_UNWRAP_ALGORITHM_SUITE,
56 HKS_TAG_DERIVE_AGREE_KEY_STORAGE_FLAG,
57 HKS_TAG_RSA_PSS_SALT_LEN_TYPE,
58 HKS_TAG_MGF_DIGEST,
59
60 HKS_TAG_ACTIVE_DATETIME,
61 HKS_TAG_ORIGINATION_EXPIRE_DATETIME,
62 HKS_TAG_USAGE_EXPIRE_DATETIME,
63 HKS_TAG_CREATION_DATETIME,
64
65 HKS_TAG_ALL_USERS,
66 HKS_TAG_USER_ID,
67 HKS_TAG_FRONT_USER_ID,
68 HKS_TAG_NO_AUTH_REQUIRED,
69 HKS_TAG_USER_AUTH_TYPE,
70 HKS_TAG_AUTH_TIMEOUT,
71 HKS_TAG_AUTH_TOKEN,
72 HKS_TAG_AUTH_STORAGE_LEVEL,
73 HKS_TAG_SPECIFIC_USER_ID,
74
75 HKS_TAG_OS_VERSION,
76 HKS_TAG_OS_PATCHLEVEL,
77
78 HKS_TAG_ATTESTATION_CHALLENGE,
79 HKS_TAG_ATTESTATION_APPLICATION_ID,
80 HKS_TAG_ATTESTATION_APPLICATION_ID_TYPE,
81 HKS_TAG_ATTESTATION_ID_BRAND,
82 HKS_TAG_ATTESTATION_ID_DEVICE,
83 HKS_TAG_ATTESTATION_ID_PRODUCT,
84 HKS_TAG_ATTESTATION_ID_SERIAL,
85 HKS_TAG_ATTESTATION_ID_IMEI,
86 HKS_TAG_ATTESTATION_ID_MEID,
87 HKS_TAG_ATTESTATION_ID_MANUFACTURER,
88 HKS_TAG_ATTESTATION_ID_MODEL,
89 HKS_TAG_ATTESTATION_ID_ALIAS,
90 HKS_TAG_ATTESTATION_ID_SOCID,
91 HKS_TAG_ATTESTATION_ID_UDID,
92 HKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO,
93 HKS_TAG_ATTESTATION_ID_VERSION_INFO,
94 HKS_TAG_ATTESTATION_BASE64,
95 HKS_TAG_ATTESTATION_MODE,
96 HKS_TAG_ATTESTATION_CERT_TYPE,
97
98 HKS_TAG_IS_KEY_ALIAS,
99 HKS_TAG_KEY_STORAGE_FLAG,
100 HKS_TAG_IS_ALLOWED_WRAP,
101 HKS_TAG_KEY_WRAP_TYPE,
102 HKS_TAG_WRAP_KEY_VERSION,
103 HKS_TAG_IS_ALLOWED_DATA_WRAP,
104 HKS_TAG_DATA_WRAP_TYPE,
105 HKS_TAG_KEY_AUTH_ID,
106 HKS_TAG_KEY_ROLE,
107 HKS_TAG_KEY_FLAG,
108 HKS_TAG_KEY_DOMAIN,
109
110 HKS_TAG_KEY_AUTH_ACCESS_TYPE,
111 HKS_TAG_KEY_SECURE_SIGN_TYPE,
112 HKS_TAG_CHALLENGE_TYPE,
113 HKS_TAG_CHALLENGE_POS,
114 HKS_TAG_KEY_AUTH_PURPOSE,
115 HKS_TAG_BATCH_PURPOSE,
116 HKS_TAG_IS_BATCH_OPERATION,
117 HKS_TAG_BATCH_OPERATION_TIMEOUT,
118 HKS_TAG_USER_AUTH_MODE,
119
120 HKS_TAG_KEY_INIT_CHALLENGE,
121 HKS_TAG_IS_USER_AUTH_ACCESS,
122 HKS_TAG_USER_AUTH_CHALLENGE,
123 HKS_TAG_USER_AUTH_ENROLL_ID_INFO,
124 HKS_TAG_USER_AUTH_SECURE_UID,
125 HKS_TAG_KEY_AUTH_RESULT,
126 HKS_TAG_IF_NEED_APPEND_AUTH_INFO,
127 HKS_TAG_VERIFIED_AUTH_TOKEN,
128 HKS_TAG_IS_APPEND_UPDATE_DATA,
129 HKS_TAG_IS_COPY_NEW_KEY,
130
131 HKS_TAG_PROCESS_NAME,
132 HKS_TAG_PACKAGE_NAME,
133 HKS_TAG_PAYLOAD_LEN,
134 HKS_TAG_AE_TAG,
135 HKS_TAG_CRYPTO_CTX,
136 HKS_TAG_KEY,
137 HKS_TAG_KEY_VERSION,
138 HKS_TAG_IS_KEY_HANDLE,
139 HKS_TAG_SYMMETRIC_KEY_DATA,
140 HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA,
141 HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA,
142 HKS_TAG_KEY_ACCESS_TIME,
143
144 HKS_TAG_ACCESS_TOKEN_ID,
145 HKS_TAG_BUNDLE_NAME,
146 HKS_TAG_IS_DEVICE_PASSWORD_SET,
147 HKS_TAG_ACCOUNT_ID,
148 HKS_TAG_OWNER_ID,
149 HKS_TAG_OWNER_TYPE,
150 HKS_TAG_AGREE_PUBKEY_TYPE,
151 HKS_TAG_IS_CHANGE_STORAGE_LEVEL,
152 HKS_TAG_SCREEN_STATE,
153 };
154
GetTagType(enum HksTag tag)155 HKS_API_EXPORT enum HksTagType GetTagType(enum HksTag tag)
156 {
157 return (enum HksTagType)((uint32_t)tag & (uint32_t)HKS_TAG_TYPE_MASK);
158 }
159
IsValidTag(uint32_t tag)160 static bool IsValidTag(uint32_t tag)
161 {
162 uint32_t tagSize = HKS_ARRAY_SIZE(g_validTags);
163 for (uint32_t i = 0; i < tagSize; ++i) {
164 if (tag == g_validTags[i]) {
165 return true;
166 }
167 }
168 return false;
169 }
170
HksCheckParamSetTag(const struct HksParamSet * paramSet)171 HKS_API_EXPORT int32_t HksCheckParamSetTag(const struct HksParamSet *paramSet)
172 {
173 HKS_IF_NULL_RETURN(paramSet, HKS_ERROR_NULL_POINTER)
174
175 for (uint32_t i = 0; i < paramSet->paramsCnt; ++i) {
176 uint32_t curTag = paramSet->params[i].tag;
177 if (!IsValidTag(curTag)) {
178 HKS_LOG_E("paramSet contains invalid tag! 0x%" LOG_PUBLIC "x", curTag);
179 return HKS_ERROR_INVALID_ARGUMENT;
180 }
181
182 for (uint32_t j = i + 1; j < paramSet->paramsCnt; ++j) {
183 if (curTag == paramSet->params[j].tag) {
184 HKS_LOG_E("paramSet contains multi-tags! 0x%" LOG_PUBLIC "x", curTag);
185 return HKS_ERROR_INVALID_ARGUMENT;
186 }
187 }
188 }
189
190 return HKS_SUCCESS;
191 }
192
CheckBeforeAddParams(const struct HksParamSet * paramSet,const struct HksParam * params,uint32_t paramCnt)193 static int32_t CheckBeforeAddParams(const struct HksParamSet *paramSet, const struct HksParam *params,
194 uint32_t paramCnt)
195 {
196 if ((params == NULL) || (paramSet == NULL) || (paramSet->paramSetSize > HKS_PARAM_SET_MAX_SIZE) ||
197 (paramCnt > HKS_DEFAULT_PARAM_CNT) || (paramSet->paramsCnt > (HKS_DEFAULT_PARAM_CNT - paramCnt))) {
198 HKS_LOG_E("invalid params or paramset!");
199 return HKS_ERROR_INVALID_ARGUMENT;
200 }
201
202 for (uint32_t i = 0; i < paramCnt; i++) {
203 if ((GetTagType((enum HksTag)(params[i].tag)) == HKS_TAG_TYPE_BYTES) &&
204 (params[i].blob.data == NULL)) {
205 HKS_LOG_E("invalid blob param!");
206 return HKS_ERROR_INVALID_ARGUMENT;
207 }
208 }
209 return HKS_SUCCESS;
210 }
211
BuildParamSet(struct HksParamSet ** paramSet)212 static int32_t BuildParamSet(struct HksParamSet **paramSet)
213 {
214 struct HksParamSet *freshParamSet = *paramSet;
215 uint32_t size = freshParamSet->paramSetSize;
216 uint32_t offset = sizeof(struct HksParamSet) + sizeof(struct HksParam) * freshParamSet->paramsCnt;
217
218 if (size > HKS_DEFAULT_PARAM_SET_SIZE) {
219 freshParamSet = (struct HksParamSet *)HksMalloc(size);
220 HKS_IF_NULL_LOGE_RETURN(freshParamSet, HKS_ERROR_MALLOC_FAIL, "malloc params failed!")
221
222 if (memcpy_s(freshParamSet, size, *paramSet, offset) != EOK) {
223 HKS_FREE(freshParamSet);
224 HKS_LOG_E("copy params failed!");
225 return HKS_ERROR_INSUFFICIENT_MEMORY;
226 }
227 HKS_FREE(*paramSet);
228 *paramSet = freshParamSet;
229 }
230
231 return HksFreshParamSet(freshParamSet, true);
232 }
233
HksCheckParamSet(const struct HksParamSet * paramSet,uint32_t size)234 HKS_API_EXPORT int32_t HksCheckParamSet(const struct HksParamSet *paramSet, uint32_t size)
235 {
236 HKS_IF_NULL_RETURN(paramSet, HKS_ERROR_NULL_POINTER)
237
238 if ((size < sizeof(struct HksParamSet)) || (size > HKS_PARAM_SET_MAX_SIZE) ||
239 (paramSet->paramSetSize != size) ||
240 (paramSet->paramsCnt > ((size - sizeof(struct HksParamSet)) / sizeof(struct HksParam)))) {
241 HKS_LOG_E("invalid param set!");
242 return HKS_ERROR_INVALID_ARGUMENT;
243 }
244 return HKS_SUCCESS;
245 }
246
HksInitParamSet(struct HksParamSet ** paramSet)247 HKS_API_EXPORT int32_t HksInitParamSet(struct HksParamSet **paramSet)
248 {
249 HKS_IF_NULL_LOGE_RETURN(paramSet, HKS_ERROR_NULL_POINTER, "invalid init params!")
250
251 *paramSet = (struct HksParamSet *)HksMalloc(HKS_DEFAULT_PARAM_SET_SIZE);
252 HKS_IF_NULL_LOGE_RETURN(*paramSet, HKS_ERROR_MALLOC_FAIL, "malloc init param set failed!")
253
254 (*paramSet)->paramsCnt = 0;
255 (*paramSet)->paramSetSize = sizeof(struct HksParamSet);
256 return HKS_SUCCESS;
257 }
258
HksAddParams(struct HksParamSet * paramSet,const struct HksParam * params,uint32_t paramCnt)259 HKS_API_EXPORT int32_t HksAddParams(struct HksParamSet *paramSet,
260 const struct HksParam *params, uint32_t paramCnt)
261 {
262 int32_t ret = CheckBeforeAddParams(paramSet, params, paramCnt);
263 HKS_IF_NOT_SUCC_RETURN(ret, ret)
264
265 for (uint32_t i = 0; i < paramCnt; i++) {
266 paramSet->paramSetSize += sizeof(struct HksParam);
267 if (GetTagType((enum HksTag)(params[i].tag)) == HKS_TAG_TYPE_BYTES) {
268 if (IsAdditionOverflow(paramSet->paramSetSize, params[i].blob.size)) {
269 HKS_LOG_E("params size overflow!");
270 paramSet->paramSetSize -= sizeof(struct HksParam);
271 return HKS_ERROR_INVALID_ARGUMENT;
272 }
273 paramSet->paramSetSize += params[i].blob.size;
274 }
275 if (memcpy_s(¶mSet->params[paramSet->paramsCnt++], sizeof(struct HksParam), ¶ms[i],
276 sizeof(struct HksParam)) != EOK) {
277 HKS_LOG_E("copy paramSet failed!");
278 return HKS_ERROR_INSUFFICIENT_MEMORY;
279 }
280 }
281 return HKS_SUCCESS;
282 }
283
HksBuildParamSet(struct HksParamSet ** paramSet)284 HKS_API_EXPORT int32_t HksBuildParamSet(struct HksParamSet **paramSet)
285 {
286 if ((paramSet == NULL) || (*paramSet == NULL)) {
287 return HKS_ERROR_NULL_POINTER;
288 }
289
290 int ret = HksCheckParamSet(*paramSet, (*paramSet)->paramSetSize);
291 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "invalid build params!")
292
293 return BuildParamSet(paramSet);
294 }
295
HksFreeParamSet(struct HksParamSet ** paramSet)296 HKS_API_EXPORT void HksFreeParamSet(struct HksParamSet **paramSet)
297 {
298 if (paramSet == NULL) {
299 HKS_LOG_E("invalid free paramset!");
300 return;
301 }
302 HKS_FREE(*paramSet);
303 }
304
HksFreeKeyAliasSet(struct HksKeyAliasSet * aliasSet)305 HKS_API_EXPORT void HksFreeKeyAliasSet(struct HksKeyAliasSet *aliasSet)
306 {
307 if (aliasSet == NULL) {
308 return;
309 }
310
311 if (aliasSet->aliasesCnt > 0 && aliasSet->aliases != NULL) {
312 for (uint32_t i = 0; i < aliasSet->aliasesCnt; i++) {
313 HKS_FREE_BLOB(aliasSet->aliases[i]);
314 }
315 }
316 aliasSet->aliasesCnt = 0;
317
318 HKS_FREE(aliasSet->aliases);
319 HKS_FREE(aliasSet);
320 aliasSet = NULL;
321 }
322
FreshParamSet(struct HksParamSet * paramSet,bool isCopy)323 static int32_t FreshParamSet(struct HksParamSet *paramSet, bool isCopy)
324 {
325 uint32_t size = paramSet->paramSetSize;
326 uint32_t offset = sizeof(struct HksParamSet) + sizeof(struct HksParam) * paramSet->paramsCnt;
327
328 for (uint32_t i = 0; i < paramSet->paramsCnt; i++) {
329 if (offset > size) {
330 HKS_LOG_E("invalid param set offset!");
331 return HKS_ERROR_INVALID_ARGUMENT;
332 }
333 if (GetTagType((enum HksTag)(paramSet->params[i].tag)) == HKS_TAG_TYPE_BYTES) {
334 if (IsAdditionOverflow(offset, paramSet->params[i].blob.size)) {
335 HKS_LOG_E("blob size overflow!");
336 return HKS_ERROR_INVALID_ARGUMENT;
337 }
338 if (isCopy && (memcpy_s((uint8_t *)paramSet + offset, size - offset,
339 paramSet->params[i].blob.data, paramSet->params[i].blob.size) != EOK)) {
340 HKS_LOG_E("copy param blob failed!");
341 return HKS_ERROR_INSUFFICIENT_MEMORY;
342 }
343 paramSet->params[i].blob.data = (uint8_t *)paramSet + offset;
344 offset += paramSet->params[i].blob.size;
345 }
346 }
347
348 if (paramSet->paramSetSize != offset) {
349 HKS_LOG_E("invalid param set size!");
350 return HKS_ERROR_INVALID_ARGUMENT;
351 }
352 return HKS_SUCCESS;
353 }
354
355
HksFreshParamSet(struct HksParamSet * paramSet,bool isCopy)356 HKS_API_EXPORT int32_t HksFreshParamSet(struct HksParamSet *paramSet, bool isCopy)
357 {
358 HKS_IF_NULL_LOGE_RETURN(paramSet, HKS_ERROR_NULL_POINTER, "invalid NULL paramSet")
359
360 int32_t ret = HksCheckParamSet(paramSet, paramSet->paramSetSize);
361 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "invalid fresh paramSet")
362
363 return FreshParamSet(paramSet, isCopy);
364 }
365
HksGetParam(const struct HksParamSet * paramSet,uint32_t tag,struct HksParam ** param)366 HKS_API_EXPORT int32_t HksGetParam(const struct HksParamSet *paramSet, uint32_t tag, struct HksParam **param)
367 {
368 if ((paramSet == NULL) || (param == NULL)) {
369 HKS_LOG_E("invalid params!");
370 return HKS_ERROR_INVALID_ARGUMENT;
371 }
372
373 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckParamSet(paramSet, paramSet->paramSetSize),
374 HKS_ERROR_INVALID_ARGUMENT, "invalid paramSet!")
375
376 for (uint32_t i = 0; i < paramSet->paramsCnt; i++) {
377 if (tag == paramSet->params[i].tag) {
378 *param = (struct HksParam *)¶mSet->params[i];
379 if ((GetTagType((enum HksTag)tag) == HKS_TAG_TYPE_BYTES) &&
380 (CheckBlob(&(*param)->blob) != HKS_SUCCESS)) {
381 HKS_LOG_E("invalid paramSet!");
382 return HKS_ERROR_INVALID_ARGUMENT;
383 }
384 return HKS_SUCCESS;
385 }
386 }
387
388 return HKS_ERROR_PARAM_NOT_EXIST;
389 }
390
HksGetParamSet(const struct HksParamSet * inParamSet,uint32_t inParamSetSize,struct HksParamSet ** outParamSet)391 HKS_API_EXPORT int32_t HksGetParamSet(const struct HksParamSet *inParamSet,
392 uint32_t inParamSetSize, struct HksParamSet **outParamSet)
393 {
394 int32_t ret = HksCheckParamSet(inParamSet, inParamSetSize);
395 HKS_IF_NOT_SUCC_RETURN(ret, ret)
396
397 HKS_IF_NULL_RETURN(outParamSet, HKS_ERROR_NULL_POINTER)
398
399 uint32_t size = inParamSet->paramSetSize;
400 struct HksParamSet *buf = (struct HksParamSet *)HksMalloc(size);
401 HKS_IF_NULL_LOGE_RETURN(buf, HKS_ERROR_MALLOC_FAIL, "malloc from param set failed!")
402
403 (void)memcpy_s(buf, size, inParamSet, size);
404
405 ret = FreshParamSet(buf, false);
406 if (ret != HKS_SUCCESS) {
407 HKS_FREE(buf);
408 return ret;
409 }
410 *outParamSet = buf;
411 return HKS_SUCCESS;
412 }
413
HksCheckParamMatch(const struct HksParam * baseParam,const struct HksParam * param)414 HKS_API_EXPORT int32_t HksCheckParamMatch(const struct HksParam *baseParam, const struct HksParam *param)
415 {
416 if (baseParam == NULL || param == NULL) {
417 return HKS_ERROR_NULL_POINTER;
418 }
419
420 if (baseParam->tag != param->tag) {
421 HKS_LOG_E("unmatch param type!");
422 return HKS_ERROR_INVALID_ARGUMENT;
423 }
424
425 switch (GetTagType((enum HksTag)(baseParam->tag))) {
426 case HKS_TAG_TYPE_INT:
427 return (baseParam->int32Param == param->int32Param) ? HKS_SUCCESS : HKS_ERROR_INVALID_ARGUMENT;
428 case HKS_TAG_TYPE_UINT:
429 return (baseParam->uint32Param == param->uint32Param) ? HKS_SUCCESS : HKS_ERROR_INVALID_ARGUMENT;
430 case HKS_TAG_TYPE_ULONG:
431 return (baseParam->uint64Param == param->uint64Param) ? HKS_SUCCESS : HKS_ERROR_INVALID_ARGUMENT;
432 case HKS_TAG_TYPE_BOOL:
433 return (baseParam->boolParam == param->boolParam) ? HKS_SUCCESS : HKS_ERROR_INVALID_ARGUMENT;
434 case HKS_TAG_TYPE_BYTES:
435 if (baseParam->blob.size != param->blob.size ||
436 baseParam->blob.data == NULL ||(param->blob.data == NULL)) {
437 HKS_LOG_E("unmatch byte type len!");
438 return HKS_ERROR_INVALID_ARGUMENT;
439 }
440 if (HksMemCmp(baseParam->blob.data, param->blob.data, baseParam->blob.size)) {
441 HKS_LOG_E("unmatch byte type content!");
442 return HKS_ERROR_INVALID_ARGUMENT;
443 }
444 return HKS_SUCCESS;
445 default:
446 HKS_LOG_E("invalid tag type:%" LOG_PUBLIC "x", GetTagType((enum HksTag)(baseParam->tag)));
447 return HKS_ERROR_INVALID_ARGUMENT;
448 }
449 }
450
HksCheckIsTagAlreadyExist(const struct HksParam * params,uint32_t paramsCnt,const struct HksParamSet * targetParamSet)451 HKS_API_EXPORT int32_t HksCheckIsTagAlreadyExist(const struct HksParam *params, uint32_t paramsCnt,
452 const struct HksParamSet *targetParamSet)
453 {
454 if (params == NULL || targetParamSet == NULL) {
455 return HKS_ERROR_NULL_POINTER;
456 }
457
458 int32_t ret = HksCheckParamSet(targetParamSet, targetParamSet->paramSetSize);
459 HKS_IF_NOT_SUCC_RETURN(ret, ret)
460
461 for (uint32_t i = 0; i < targetParamSet->paramsCnt; ++i) {
462 for (uint32_t j = 0; j < paramsCnt; ++j) {
463 if (params[j].tag == targetParamSet->params[i].tag) {
464 return HKS_ERROR_INVALID_ARGUMENT;
465 }
466 }
467 }
468
469 return HKS_SUCCESS;
470 }
471
HksDeleteTagsFromParamSet(const uint32_t * tag,uint32_t tagCount,const struct HksParamSet * paramSet,struct HksParamSet ** outParamSet)472 HKS_API_EXPORT int32_t HksDeleteTagsFromParamSet(const uint32_t *tag, uint32_t tagCount,
473 const struct HksParamSet *paramSet, struct HksParamSet **outParamSet)
474 {
475 if (tag == NULL || paramSet == NULL || outParamSet == NULL) {
476 return HKS_ERROR_NULL_POINTER;
477 }
478 int32_t ret = HksFreshParamSet((struct HksParamSet *)paramSet, false);
479 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "fresh paramset failed")
480
481 struct HksParamSet *newParamSet = NULL;
482 ret = HksInitParamSet(&newParamSet);
483 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "init param set failed")
484
485 for (uint32_t i = 0; i < paramSet->paramsCnt; ++i) {
486 bool isDeleteTag = false;
487 for (uint32_t j = 0; j < tagCount; ++j) {
488 if (paramSet->params[i].tag == tag[j]) {
489 isDeleteTag = true;
490 break;
491 }
492 }
493 if (!isDeleteTag) {
494 ret = HksAddParams(newParamSet, ¶mSet->params[i], 1);
495 if (ret != HKS_SUCCESS) {
496 HKS_LOG_E("add in params failed");
497 HksFreeParamSet(&newParamSet);
498 return ret;
499 }
500 }
501 }
502
503 ret = HksBuildParamSet(&newParamSet);
504 if (ret != HKS_SUCCESS) {
505 HKS_LOG_E("build paramset failed");
506 HksFreeParamSet(&newParamSet);
507 return ret;
508 }
509
510 *outParamSet = newParamSet;
511 return HKS_SUCCESS;
512 }
513