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