1 /*
2 * Copyright (c) 2021-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_service_ipc_serialization.h"
17
18 #include "hks_log.h"
19 #include "hks_mem.h"
20 #include "hks_template.h"
21
22 #include <securec.h>
23
CopyUint32ToBuffer(uint32_t value,const struct HksBlob * destBlob,uint32_t * destOffset)24 static int32_t CopyUint32ToBuffer(uint32_t value, const struct HksBlob *destBlob, uint32_t *destOffset)
25 {
26 if (*destOffset > destBlob->size) {
27 return HKS_ERROR_BUFFER_TOO_SMALL;
28 }
29
30 if (memcpy_s(destBlob->data + *destOffset, destBlob->size - *destOffset, &(value), sizeof(value)) != EOK) {
31 return HKS_ERROR_INSUFFICIENT_MEMORY;
32 }
33
34 *destOffset += sizeof(value);
35 return HKS_SUCCESS;
36 }
37
CopyBlobToBuffer(const struct HksBlob * blob,const struct HksBlob * destBlob,uint32_t * destOffset)38 static int32_t CopyBlobToBuffer(const struct HksBlob *blob, const struct HksBlob *destBlob, uint32_t *destOffset)
39 {
40 HKS_IF_NOT_SUCC_RETURN(CheckBlob(blob), HKS_ERROR_INVALID_ARGUMENT)
41
42 if ((*destOffset > destBlob->size) ||
43 ((destBlob->size - *destOffset) < (sizeof(blob->size) + ALIGN_SIZE(blob->size)))) {
44 return HKS_ERROR_BUFFER_TOO_SMALL;
45 }
46
47 if (memcpy_s(destBlob->data + *destOffset, destBlob->size - *destOffset, &(blob->size),
48 sizeof(blob->size)) != EOK) {
49 HKS_LOG_E("copy destBlob data failed!");
50 return HKS_ERROR_INSUFFICIENT_MEMORY;
51 }
52
53 *destOffset += sizeof(blob->size);
54
55 if (memcpy_s(destBlob->data + *destOffset, destBlob->size - *destOffset, blob->data, blob->size) != EOK) {
56 HKS_LOG_E("copy destBlob data failed!");
57 return HKS_ERROR_INSUFFICIENT_MEMORY;
58 }
59
60 *destOffset += ALIGN_SIZE(blob->size);
61 return HKS_SUCCESS;
62 }
63
CopyParamSetToBuffer(const struct HksParamSet * paramSet,const struct HksBlob * destBlob,uint32_t * destOffset)64 static int32_t CopyParamSetToBuffer(const struct HksParamSet *paramSet,
65 const struct HksBlob *destBlob, uint32_t *destOffset)
66 {
67 HKS_IF_NULL_RETURN(paramSet, HKS_ERROR_INVALID_ARGUMENT)
68
69 if ((*destOffset > destBlob->size) || (destBlob->size - *destOffset < ALIGN_SIZE(paramSet->paramSetSize))) {
70 return HKS_ERROR_BUFFER_TOO_SMALL;
71 }
72
73 if (memcpy_s(destBlob->data + *destOffset, destBlob->size - *destOffset, paramSet, paramSet->paramSetSize) != EOK) {
74 return HKS_ERROR_INSUFFICIENT_MEMORY;
75 }
76
77 *destOffset += ALIGN_SIZE(paramSet->paramSetSize);
78 return HKS_SUCCESS;
79 }
80
GetUint32FromBuffer(uint32_t * value,const struct HksBlob * srcBlob,uint32_t * srcOffset)81 static int32_t GetUint32FromBuffer(uint32_t *value, const struct HksBlob *srcBlob, uint32_t *srcOffset)
82 {
83 if ((*srcOffset > srcBlob->size) || (srcBlob->size - *srcOffset < sizeof(uint32_t))) {
84 return HKS_ERROR_BUFFER_TOO_SMALL;
85 }
86
87 if (memcpy_s(value, sizeof(*value), srcBlob->data + *srcOffset, sizeof(uint32_t)) != EOK) {
88 HKS_LOG_E("copy value failed!");
89 return HKS_ERROR_INSUFFICIENT_MEMORY;
90 }
91
92 *srcOffset += sizeof(uint32_t);
93 return HKS_SUCCESS;
94 }
95
GetBlobFromBuffer(struct HksBlob * blob,const struct HksBlob * srcBlob,uint32_t * srcOffset)96 int32_t GetBlobFromBuffer(struct HksBlob *blob, const struct HksBlob *srcBlob, uint32_t *srcOffset)
97 {
98 if ((*srcOffset > srcBlob->size) || ((srcBlob->size - *srcOffset) < sizeof(uint32_t))) {
99 return HKS_ERROR_BUFFER_TOO_SMALL;
100 }
101
102 uint32_t size = *((uint32_t *)(srcBlob->data + *srcOffset));
103 if (IsAdditionOverflow(size, DEFAULT_ALIGN_MASK_SIZE)) {
104 return HKS_ERROR_INVALID_ARGUMENT;
105 }
106 if (ALIGN_SIZE(size) > srcBlob->size - *srcOffset - sizeof(uint32_t)) {
107 return HKS_ERROR_BUFFER_TOO_SMALL;
108 }
109
110 blob->size = size;
111 *srcOffset += sizeof(blob->size);
112 blob->data = (uint8_t *)(srcBlob->data + *srcOffset);
113 *srcOffset += ALIGN_SIZE(blob->size);
114 return HKS_SUCCESS;
115 }
116
GetParamSetFromBuffer(struct HksParamSet ** paramSet,const struct HksBlob * srcBlob,uint32_t * srcOffset)117 static int32_t GetParamSetFromBuffer(struct HksParamSet **paramSet,
118 const struct HksBlob *srcBlob, uint32_t *srcOffset)
119 {
120 if (*srcOffset > srcBlob->size || ((srcBlob->size - *srcOffset) < sizeof(struct HksParamSet))) {
121 return HKS_ERROR_INVALID_ARGUMENT;
122 }
123
124 *paramSet = (struct HksParamSet*)(srcBlob->data + *srcOffset);
125 if (IsAdditionOverflow((*paramSet)->paramSetSize, DEFAULT_ALIGN_MASK_SIZE)) {
126 return HKS_ERROR_INVALID_ARGUMENT;
127 }
128 if (ALIGN_SIZE((*paramSet)->paramSetSize) > (srcBlob->size - *srcOffset) ||
129 HksFreshParamSet(*paramSet, false) != HKS_SUCCESS) {
130 return HKS_ERROR_BUFFER_TOO_SMALL;
131 }
132
133 *srcOffset += ALIGN_SIZE((*paramSet)->paramSetSize);
134 return HKS_SUCCESS;
135 }
136
GetKeyAndParamSetFromBuffer(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet,uint32_t * offset)137 static int32_t GetKeyAndParamSetFromBuffer(const struct HksBlob *srcData, struct HksBlob *keyAlias,
138 struct HksParamSet **paramSet, uint32_t *offset)
139 {
140 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, offset);
141 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
142
143 ret = GetParamSetFromBuffer(paramSet, srcData, offset);
144 HKS_IF_NOT_SUCC_LOGE(ret, "get paramSet failed")
145
146 return ret;
147 }
148
MallocBlobFromBuffer(const struct HksBlob * srcData,struct HksBlob * blob,uint32_t * offset)149 static int32_t MallocBlobFromBuffer(const struct HksBlob *srcData, struct HksBlob *blob, uint32_t *offset)
150 {
151 uint32_t blobSize = 0;
152 int32_t ret = GetUint32FromBuffer(&blobSize, srcData, offset);
153 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get blobSize failed")
154
155 if (IsInvalidLength(blobSize)) {
156 HKS_LOG_E("get blobSize failed");
157 return HKS_ERROR_INVALID_ARGUMENT;
158 }
159
160 uint8_t *blobData = (uint8_t *)HksMalloc(blobSize);
161 HKS_IF_NULL_RETURN(blobData, HKS_ERROR_MALLOC_FAIL)
162
163 blob->data = blobData;
164 blob->size = blobSize;
165 return HKS_SUCCESS;
166 }
167
MallocParamSetFromBuffer(const struct HksBlob * srcData,struct HksParamSet ** paramSet,uint32_t * offset)168 static int32_t MallocParamSetFromBuffer(const struct HksBlob *srcData, struct HksParamSet **paramSet, uint32_t *offset)
169 {
170 uint32_t paramSetOutSize = 0;
171 int32_t ret = GetUint32FromBuffer(¶mSetOutSize, srcData, offset);
172 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSetOutSize failed")
173
174 if (IsInvalidLength(paramSetOutSize) || paramSetOutSize < sizeof(struct HksParamSet)) {
175 HKS_LOG_E("get paramSetOutSize failed");
176 return HKS_ERROR_INVALID_ARGUMENT;
177 }
178
179 *paramSet = (struct HksParamSet *)HksMalloc(paramSetOutSize);
180 HKS_IF_NULL_RETURN(*paramSet, HKS_ERROR_MALLOC_FAIL)
181
182 (*paramSet)->paramSetSize = paramSetOutSize;
183 return HKS_SUCCESS;
184 }
185
HksGenerateKeyUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSetIn,struct HksBlob * keyOut)186 int32_t HksGenerateKeyUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias,
187 struct HksParamSet **paramSetIn, struct HksBlob *keyOut)
188 {
189 uint32_t offset = 0;
190 int32_t ret = GetKeyAndParamSetFromBuffer(srcData, keyAlias, paramSetIn, &offset);
191 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetKeyAndParamSetFromBuffer failed")
192
193 uint32_t keyOutSize = 0;
194 ret = GetUint32FromBuffer(&keyOutSize, srcData, &offset);
195 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyOutSize failed")
196
197 if (keyOutSize > MAX_OUT_BLOB_SIZE) {
198 HKS_LOG_E("keyOutSize out of range %" LOG_PUBLIC "u", keyOutSize);
199 return HKS_ERROR_INVALID_ARGUMENT;
200 }
201
202 /* no allocate memory when keyOutSize is 0 */
203 if (keyOutSize > 0) {
204 uint8_t *keyData = (uint8_t *)HksMalloc(keyOutSize);
205 HKS_IF_NULL_RETURN(keyData, HKS_ERROR_MALLOC_FAIL)
206
207 keyOut->data = keyData;
208 keyOut->size = keyOutSize;
209 }
210
211 return HKS_SUCCESS;
212 }
213
HksImportKeyUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet,struct HksBlob * key)214 int32_t HksImportKeyUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias, struct HksParamSet **paramSet,
215 struct HksBlob *key)
216 {
217 uint32_t offset = 0;
218 int32_t ret = GetKeyAndParamSetFromBuffer(srcData, keyAlias, paramSet, &offset);
219 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetKeyAndParamSetFromBuffer failed")
220
221 return GetBlobFromBuffer(key, srcData, &offset);
222 }
223
HksImportWrappedKeyUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksBlob * wrappingKeyAlias,struct HksParamSet ** paramSet,struct HksBlob * wrappedKeyData)224 int32_t HksImportWrappedKeyUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias,
225 struct HksBlob *wrappingKeyAlias, struct HksParamSet **paramSet, struct HksBlob *wrappedKeyData)
226 {
227 uint32_t offset = 0;
228 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
229 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
230
231 ret = GetBlobFromBuffer(wrappingKeyAlias, srcData, &offset);
232 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get wrappingKeyAlias failed")
233
234 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
235 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
236
237 return GetBlobFromBuffer(wrappedKeyData, srcData, &offset);
238 }
239
HksDeleteKeyUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet)240 int32_t HksDeleteKeyUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias, struct HksParamSet **paramSet)
241 {
242 uint32_t offset = 0;
243 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
244 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
245
246 if (offset == srcData->size) {
247 return HKS_SUCCESS;
248 }
249
250 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
251 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
252
253 return HKS_SUCCESS;
254 }
255
HksExportPublicKeyUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet,struct HksBlob * key)256 int32_t HksExportPublicKeyUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias, struct HksParamSet **paramSet,
257 struct HksBlob *key)
258 {
259 uint32_t offset = 0;
260 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
261 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
262
263 ret = MallocBlobFromBuffer(srcData, key, &offset);
264 HKS_IF_NOT_SUCC_LOGE(ret, "malloc key data failed")
265
266 if (offset == srcData->size) {
267 return HKS_SUCCESS;
268 }
269
270 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
271 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
272 return ret;
273 }
274
HksGetKeyParamSetUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSetIn,struct HksParamSet ** paramSetOut)275 int32_t HksGetKeyParamSetUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias,
276 struct HksParamSet **paramSetIn, struct HksParamSet **paramSetOut)
277 {
278 uint32_t offset = 0;
279 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
280 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
281
282 ret = MallocParamSetFromBuffer(srcData, paramSetOut, &offset);
283 HKS_IF_NOT_SUCC_LOGE(ret, "malloc paramSet failed")
284
285 if (offset == srcData->size) {
286 return HKS_SUCCESS;
287 }
288
289 ret = GetParamSetFromBuffer(paramSetIn, srcData, &offset);
290 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
291 return ret;
292 }
293
HksKeyExistUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet)294 int32_t HksKeyExistUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias, struct HksParamSet **paramSet)
295 {
296 uint32_t offset = 0;
297 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
298 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
299
300 if (offset == srcData->size) {
301 return HKS_SUCCESS;
302 }
303
304 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
305 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
306
307 return HKS_SUCCESS;
308 }
309
SignVerifyMacUnpack(const struct HksBlob * srcData,struct HksBlob * key,struct HksParamSet ** paramSet,struct HksBlob * inputData,uint32_t * offset)310 static int32_t SignVerifyMacUnpack(const struct HksBlob *srcData, struct HksBlob *key, struct HksParamSet **paramSet,
311 struct HksBlob *inputData, uint32_t *offset)
312 {
313 int32_t ret = GetKeyAndParamSetFromBuffer(srcData, key, paramSet, offset);
314 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetKeyAndParamSetFromBuffer failed")
315
316 ret = GetBlobFromBuffer(inputData, srcData, offset);
317 HKS_IF_NOT_SUCC_LOGE(ret, "get unsignedData failed")
318
319 return ret;
320 }
321
HksSignUnpack(const struct HksBlob * srcData,struct HksBlob * key,struct HksParamSet ** paramSet,struct HksBlob * unsignedData,struct HksBlob * signature)322 int32_t HksSignUnpack(const struct HksBlob *srcData, struct HksBlob *key, struct HksParamSet **paramSet,
323 struct HksBlob *unsignedData, struct HksBlob *signature)
324 {
325 uint32_t offset = 0;
326 int32_t ret = SignVerifyMacUnpack(srcData, key, paramSet, unsignedData, &offset);
327 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "SignVerifyMacUnpack failed")
328
329 ret = MallocBlobFromBuffer(srcData, signature, &offset);
330 HKS_IF_NOT_SUCC_LOGE(ret, "malloc signature data failed")
331
332 return ret;
333 }
334
HksVerifyUnpack(const struct HksBlob * srcData,struct HksBlob * key,struct HksParamSet ** paramSet,struct HksBlob * unsignedData,struct HksBlob * signature)335 int32_t HksVerifyUnpack(const struct HksBlob *srcData, struct HksBlob *key, struct HksParamSet **paramSet,
336 struct HksBlob *unsignedData, struct HksBlob *signature)
337 {
338 uint32_t offset = 0;
339 int32_t ret = SignVerifyMacUnpack(srcData, key, paramSet, unsignedData, &offset);
340 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "SignVerifyMacUnpack failed")
341
342 return GetBlobFromBuffer(signature, srcData, &offset);
343 }
344
HksEncryptDecryptUnpack(const struct HksBlob * srcData,struct HksBlob * key,struct HksParamSet ** paramSet,struct HksBlob * inputText,struct HksBlob * outputText)345 int32_t HksEncryptDecryptUnpack(const struct HksBlob *srcData, struct HksBlob *key,
346 struct HksParamSet **paramSet, struct HksBlob *inputText, struct HksBlob *outputText)
347 {
348 uint32_t offset = 0;
349 int32_t ret = GetKeyAndParamSetFromBuffer(srcData, key, paramSet, &offset);
350 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "getKeyAndParamSetFromBuffer failed")
351
352 ret = GetBlobFromBuffer(inputText, srcData, &offset);
353 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get inputText failed")
354
355 ret = MallocBlobFromBuffer(srcData, outputText, &offset);
356 HKS_IF_NOT_SUCC_LOGE(ret, "malloc outputText data failed")
357
358 return ret;
359 }
360
HksAgreeKeyUnpack(const struct HksBlob * srcData,struct HksParamSet ** paramSet,struct HksBlob * privateKey,struct HksBlob * peerPublicKey,struct HksBlob * agreedKey)361 int32_t HksAgreeKeyUnpack(const struct HksBlob *srcData, struct HksParamSet **paramSet, struct HksBlob *privateKey,
362 struct HksBlob *peerPublicKey, struct HksBlob *agreedKey)
363 {
364 uint32_t offset = 0;
365 int32_t ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
366 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
367
368 ret = GetBlobFromBuffer(privateKey, srcData, &offset);
369 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get privateKey failed")
370
371 ret = GetBlobFromBuffer(peerPublicKey, srcData, &offset);
372 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get peerPublicKey failed")
373
374 ret = MallocBlobFromBuffer(srcData, agreedKey, &offset);
375 HKS_IF_NOT_SUCC_LOGE(ret, "malloc agreedKey data failed")
376
377 return ret;
378 }
379
HksDeriveKeyUnpack(const struct HksBlob * srcData,struct HksParamSet ** paramSet,struct HksBlob * kdfKey,struct HksBlob * derivedKey)380 int32_t HksDeriveKeyUnpack(const struct HksBlob *srcData, struct HksParamSet **paramSet, struct HksBlob *kdfKey,
381 struct HksBlob *derivedKey)
382 {
383 uint32_t offset = 0;
384 int32_t ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
385 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
386
387 ret = GetBlobFromBuffer(kdfKey, srcData, &offset);
388 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get kdfKey failed")
389
390 ret = MallocBlobFromBuffer(srcData, derivedKey, &offset);
391 HKS_IF_NOT_SUCC_LOGE(ret, "malloc derivedKey data failed")
392
393 return ret;
394 }
395
HksHmacUnpack(const struct HksBlob * srcData,struct HksBlob * key,struct HksParamSet ** paramSet,struct HksBlob * inputData,struct HksBlob * mac)396 int32_t HksHmacUnpack(const struct HksBlob *srcData, struct HksBlob *key, struct HksParamSet **paramSet,
397 struct HksBlob *inputData, struct HksBlob *mac)
398 {
399 uint32_t offset = 0;
400 int32_t ret = SignVerifyMacUnpack(srcData, key, paramSet, inputData, &offset);
401 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "SignVerifyMacUnpack failed")
402
403 ret = MallocBlobFromBuffer(srcData, mac, &offset);
404 HKS_IF_NOT_SUCC_LOGE(ret, "malloc mac data failed")
405
406 return ret;
407 }
408
KeyInfoListInit(struct HksKeyInfo * keyInfoList,uint32_t listCount,const struct HksBlob * srcData,uint32_t * offset)409 static int32_t KeyInfoListInit(struct HksKeyInfo *keyInfoList, uint32_t listCount,
410 const struct HksBlob *srcData, uint32_t *offset)
411 {
412 uint32_t i = 0;
413 int32_t ret = HKS_SUCCESS;
414 for (; i < listCount; ++i) {
415 ret = MallocBlobFromBuffer(srcData, &keyInfoList[i].alias, offset);
416 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "malloc keyInfoList alias failed")
417
418 ret = MallocParamSetFromBuffer(srcData, &keyInfoList[i].paramSet, offset);
419 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "malloc keyInfoList paramSetSize failed")
420 }
421
422 if (ret != HKS_SUCCESS) {
423 for (uint32_t j = 0; j <= i; ++j) {
424 HKS_FREE_BLOB(keyInfoList[j].alias);
425 HKS_FREE(keyInfoList[j].paramSet);
426 }
427 }
428 return ret;
429 }
430
HksGetKeyInfoListUnpack(const struct HksBlob * srcData,struct HksParamSet ** paramSet,uint32_t * listCount,struct HksKeyInfo ** keyInfoList)431 int32_t HksGetKeyInfoListUnpack(const struct HksBlob *srcData, struct HksParamSet **paramSet, uint32_t *listCount,
432 struct HksKeyInfo **keyInfoList)
433 {
434 uint32_t offset = 0;
435 int32_t ret = GetUint32FromBuffer(listCount, srcData, &offset);
436 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get count failed")
437
438 enum {
439 HKS_GET_KEY_LIST_MAX_COUNT = 2048U,
440 };
441 if (*listCount == 0 || *listCount > HKS_GET_KEY_LIST_MAX_COUNT) {
442 HKS_LOG_E("invalid listCount %" LOG_PUBLIC "u", *listCount);
443 return HKS_ERROR_INSUFFICIENT_MEMORY;
444 }
445
446 uint32_t keyInfoListSize = (*listCount) * sizeof(struct HksKeyInfo);
447 if (IsInvalidLength(keyInfoListSize)) {
448 HKS_LOG_E("keyInfoListSize too big %" LOG_PUBLIC "u", keyInfoListSize);
449 return HKS_ERROR_INSUFFICIENT_MEMORY;
450 }
451
452 *keyInfoList = (struct HksKeyInfo *)HksMalloc(keyInfoListSize);
453 HKS_IF_NULL_LOGE_RETURN(*keyInfoList, HKS_ERROR_MALLOC_FAIL, "*keyInfoList is NULL")
454
455 (void)memset_s(*keyInfoList, keyInfoListSize, 0, keyInfoListSize);
456
457 ret = KeyInfoListInit(*keyInfoList, *listCount, srcData, &offset);
458 if (ret != HKS_SUCCESS) {
459 HKS_LOG_E("KeyInfoListInit failed");
460 HKS_FREE(*keyInfoList);
461 }
462
463 if (offset == srcData->size) {
464 return HKS_SUCCESS;
465 }
466
467 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
468 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
469 return ret;
470 }
471
HksGetKeyInfoListPackFromService(struct HksBlob * destData,uint32_t listCount,const struct HksKeyInfo * keyInfoList)472 int32_t HksGetKeyInfoListPackFromService(struct HksBlob *destData, uint32_t listCount,
473 const struct HksKeyInfo *keyInfoList)
474 {
475 uint32_t offset = 0;
476 int32_t ret = CopyUint32ToBuffer(listCount, destData, &offset);
477 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "copy CopyUint32ToBuffer failed")
478
479 for (uint32_t i = 0; i < listCount; ++i) {
480 ret = CopyBlobToBuffer(&keyInfoList[i].alias, destData, &offset);
481 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "copy alias failed")
482
483 ret = CopyParamSetToBuffer(keyInfoList[i].paramSet, destData, &offset);
484 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "copy paramSet failed")
485 }
486
487 return HKS_SUCCESS;
488 }
489
HksCertificateChainUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** paramSet,struct HksBlob * certChainBlob)490 int32_t HksCertificateChainUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias,
491 struct HksParamSet **paramSet, struct HksBlob *certChainBlob)
492 {
493 uint32_t offset = 0;
494 int32_t ret = GetKeyAndParamSetFromBuffer(srcData, keyAlias, paramSet, &offset);
495 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetKeyAndParamSetFromBuffer failed")
496
497 ret = MallocBlobFromBuffer(srcData, certChainBlob, &offset);
498 HKS_IF_NOT_SUCC_LOGE(ret, "malloc certChainBlob data failed")
499
500 return ret;
501 }
502
GetNullBlobParam(const struct HksParamSet * paramSet,struct HksParamOut * outParams)503 static int32_t GetNullBlobParam(const struct HksParamSet *paramSet, struct HksParamOut *outParams)
504 {
505 if (GetTagType(outParams->tag) != HKS_TAG_TYPE_BYTES) {
506 HKS_LOG_E("get param tag[0x%" LOG_PUBLIC "x] from ipc buffer failed", outParams->tag);
507 return HKS_ERROR_PARAM_NOT_EXIST;
508 }
509
510 struct HksParam *param = NULL;
511 int32_t ret = HksGetParam(paramSet, outParams->tag + HKS_PARAM_BUFFER_NULL_INTERVAL, ¶m);
512 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get param tag[0x%" LOG_PUBLIC "x] from ipc buffer failed",
513 outParams->tag + HKS_PARAM_BUFFER_NULL_INTERVAL)
514
515 outParams->blob->data = NULL;
516 outParams->blob->size = 0;
517 return HKS_SUCCESS;
518 }
519
GetNormalParam(const struct HksParam * param,struct HksParamOut * outParams)520 static int32_t GetNormalParam(const struct HksParam *param, struct HksParamOut *outParams)
521 {
522 switch (GetTagType(outParams->tag)) {
523 case HKS_TAG_TYPE_INT:
524 *(outParams->int32Param) = param->int32Param;
525 break;
526 case HKS_TAG_TYPE_UINT:
527 *(outParams->uint32Param) = param->uint32Param;
528 break;
529 case HKS_TAG_TYPE_ULONG:
530 *(outParams->uint64Param) = param->uint64Param;
531 break;
532 case HKS_TAG_TYPE_BOOL:
533 *(outParams->boolParam) = param->boolParam;
534 break;
535 case HKS_TAG_TYPE_BYTES:
536 *(outParams->blob) = param->blob;
537 break;
538 default:
539 HKS_LOG_I("invalid tag type:%" LOG_PUBLIC "x", GetTagType(outParams->tag));
540 return HKS_ERROR_INVALID_ARGUMENT;
541 }
542 return HKS_SUCCESS;
543 }
544
HksParamSetToParams(const struct HksParamSet * paramSet,struct HksParamOut * outParams,uint32_t cnt)545 int32_t HksParamSetToParams(const struct HksParamSet *paramSet, struct HksParamOut *outParams, uint32_t cnt)
546 {
547 struct HksParam *param = NULL;
548 for (uint32_t i = 0; i < cnt; i++) {
549 int32_t ret = HksGetParam(paramSet, outParams[i].tag, ¶m);
550 if (ret == HKS_SUCCESS) {
551 ret = GetNormalParam(param, &outParams[i]);
552 } else {
553 ret = GetNullBlobParam(paramSet, &outParams[i]);
554 }
555 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get param failed, ret = %" LOG_PUBLIC "d", ret)
556 }
557 return HKS_SUCCESS;
558 }
559
HksListAliasesUnpack(const struct HksBlob * srcData,struct HksParamSet ** paramSet)560 int32_t HksListAliasesUnpack(const struct HksBlob *srcData, struct HksParamSet **paramSet)
561 {
562 uint32_t offset = 0;
563 int32_t ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
564 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get paramSet failed")
565 return ret;
566 }
567
HksCopyBlobsAndCntToBlob(const struct HksBlob * srcBlob,uint32_t cnt,struct HksBlob * destBlob)568 static int32_t HksCopyBlobsAndCntToBlob(const struct HksBlob *srcBlob, uint32_t cnt, struct HksBlob *destBlob)
569 {
570 uint32_t offset = 0;
571 int32_t ret = CopyUint32ToBuffer(cnt, destBlob, &offset);
572 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "copy CopyUint32ToBuffer failed, ret = %" LOG_PUBLIC "d", ret)
573
574 for (uint32_t i = 0; i < cnt; ++i) {
575 ret = CopyBlobToBuffer(&srcBlob[i], destBlob, &offset);
576 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "copy CopyBlobToBuffer failed")
577 }
578 return HKS_SUCCESS;
579 }
580
HksListAliasesPackFromService(const struct HksKeyAliasSet * aliasSet,struct HksBlob * destData)581 int32_t HksListAliasesPackFromService(const struct HksKeyAliasSet *aliasSet, struct HksBlob *destData)
582 {
583 if (destData == NULL || destData->size != 0) {
584 HKS_LOG_E("HksListAliasesPackFromService invalid param");
585 return HKS_ERROR_INVALID_ARGUMENT;
586 }
587 if (aliasSet == NULL || aliasSet->aliasesCnt == 0) {
588 return HKS_SUCCESS;
589 }
590
591 destData->size = sizeof(aliasSet->aliasesCnt);
592 for (uint32_t i = 0; i < aliasSet->aliasesCnt; ++i) {
593 destData->size += sizeof(aliasSet->aliases[i].size) + ALIGN_SIZE(aliasSet->aliases[i].size);
594 }
595 destData->data = (uint8_t *)HksMalloc(destData->size);
596 HKS_IF_NULL_RETURN(destData->data, HKS_ERROR_MALLOC_FAIL)
597
598 return HksCopyBlobsAndCntToBlob(aliasSet->aliases, aliasSet->aliasesCnt, destData);
599 }
600
HksRenameKeyAliasUnpack(const struct HksBlob * srcData,struct HksBlob * oldKeyAlias,struct HksBlob * newKeyAlias,struct HksParamSet ** paramSet)601 int32_t HksRenameKeyAliasUnpack(const struct HksBlob *srcData, struct HksBlob *oldKeyAlias,
602 struct HksBlob *newKeyAlias, struct HksParamSet **paramSet)
603 {
604 uint32_t offset = 0;
605 int32_t ret;
606 do {
607 ret = GetBlobFromBuffer(oldKeyAlias, srcData, &offset);
608 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "get oldKeyAlias failed!");
609
610 ret = GetBlobFromBuffer(newKeyAlias, srcData, &offset);
611 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "get newKeyAlias failed!");
612
613 ret = GetParamSetFromBuffer(paramSet, srcData, &offset);
614 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "get paramSet failed!");
615 } while (0);
616 return ret;
617 }
618
HksChangeStorageLevelUnpack(const struct HksBlob * srcData,struct HksBlob * keyAlias,struct HksParamSet ** srcParamSet,struct HksParamSet ** destParamSet)619 int32_t HksChangeStorageLevelUnpack(const struct HksBlob *srcData, struct HksBlob *keyAlias,
620 struct HksParamSet **srcParamSet, struct HksParamSet **destParamSet)
621 {
622 uint32_t offset = 0;
623 int32_t ret = GetBlobFromBuffer(keyAlias, srcData, &offset);
624 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get keyAlias failed")
625
626 ret = GetParamSetFromBuffer(srcParamSet, srcData, &offset);
627 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get srcParamSet failed")
628
629 ret = GetParamSetFromBuffer(destParamSet, srcData, &offset);
630 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get destParamSet failed")
631
632 return HKS_SUCCESS;
633 }