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 #define HUKS_DISABLE_LOG_AT_FILE_TO_REDUCE_ROM_SIZE
16
17 #include "hks_errcode_adapter.h"
18
19 #include <stddef.h>
20
21 #include "hks_error_code.h"
22 #include "hks_log.h"
23 #include "hks_type.h"
24
25 static const char *g_convertErrMsg = "HUKS operation failed.";
26
27 static struct HksError g_errCodeTable[] = {
28 {
29 .innerErrCode = HKS_SUCCESS,
30 .hksResult = {
31 .errorCode = HKS_SUCCESS,
32 .errorMsg = "Success.",
33 .data = NULL
34 }
35 }, {
36 .innerErrCode = HKS_ERROR_NO_PERMISSION,
37 .hksResult = {
38 .errorCode = HUKS_ERR_CODE_PERMISSION_FAIL,
39 .errorMsg = "Permission check failed. Apply for the required permissions first.",
40 .data = NULL
41 }
42 }, {
43 .innerErrCode = HKS_ERROR_NOT_SYSTEM_APP,
44 .hksResult = {
45 .errorCode = HUKS_ERR_CODE_NOT_SYSTEM_APP,
46 .errorMsg = "Non-system applications are not allowed to use system APIs.",
47 .data = NULL
48 }
49 }, {
50 .innerErrCode = HKS_ERROR_INVALID_ARGUMENT,
51 .hksResult = {
52 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
53 .errorMsg = "Invalid parameters.",
54 .data = NULL
55 }
56 }, {
57 .innerErrCode = HKS_ERROR_INSUFFICIENT_DATA,
58 .hksResult = {
59 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
60 .errorMsg = "Some input parameters are not set.",
61 .data = NULL
62 }
63 }, {
64 .innerErrCode = HKS_ERROR_BUFFER_TOO_SMALL,
65 .hksResult = {
66 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
67 .errorMsg = "Insufficient buffer size.",
68 .data = NULL
69 }
70 }, {
71 .innerErrCode = HKS_ERROR_NULL_POINTER,
72 .hksResult = {
73 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
74 .errorMsg = "The parameter value cannot be null.",
75 .data = NULL
76 }
77 }, {
78 .innerErrCode = HKS_ERROR_INVALID_PUBLIC_KEY,
79 .hksResult = {
80 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
81 .errorMsg = "Invalid public key.",
82 .data = NULL
83 }
84 }, {
85 .innerErrCode = HKS_ERROR_INVALID_KEY_INFO,
86 .hksResult = {
87 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
88 .errorMsg = "Invalid key information.",
89 .data = NULL
90 }
91 }, {
92 .innerErrCode = HKS_ERROR_PARAM_NOT_EXIST,
93 .hksResult = {
94 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
95 .errorMsg = "The parameter does not exist.",
96 .data = NULL
97 }
98 }, {
99 .innerErrCode = HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST,
100 .hksResult = {
101 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
102 .errorMsg = "The root key material already exists.",
103 .data = NULL
104 }
105 }, {
106 .innerErrCode = HKS_ERROR_INVALID_WRAPPED_FORMAT,
107 .hksResult = {
108 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
109 .errorMsg = "The wrapped key data is in invalid format.",
110 .data = NULL
111 }
112 }, {
113 .innerErrCode = HKS_ERROR_CHECK_GET_AUTH_TYP_FAILED,
114 .hksResult = {
115 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
116 .errorMsg = "Failed to obtain the authentication type. It is not set in ParamSet.",
117 .data = NULL
118 }
119 }, {
120 .innerErrCode = HKS_ERROR_CHECK_GET_CHALLENGE_TYPE_FAILED,
121 .hksResult = {
122 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
123 .errorMsg = "Failed to obtain the challenge type. It is not set in ParamSet.",
124 .data = NULL
125 }
126 }, {
127 .innerErrCode = HKS_ERROR_CHECK_GET_ACCESS_TYPE_FAILED,
128 .hksResult = {
129 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
130 .errorMsg = "Failed to obtain the access type. It is not set in ParamSet.",
131 .data = NULL
132 }
133 }, {
134 .innerErrCode = HKS_ERROR_CHECK_GET_AUTH_TOKEN_FAILED,
135 .hksResult = {
136 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
137 .errorMsg = "Failed to obtain the authentication token. It is not set in ParamSet.",
138 .data = NULL
139 }
140 }, {
141 .innerErrCode = HKS_ERROR_INVALID_TIME_OUT,
142 .hksResult = {
143 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
144 .errorMsg = "Invalid timeout parameter.",
145 .data = NULL
146 }
147 }, {
148 .innerErrCode = HKS_ERROR_INVALID_AUTH_TYPE,
149 .hksResult = {
150 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
151 .errorMsg = "Invalid authentication type.",
152 .data = NULL
153 }
154 }, {
155 .innerErrCode = HKS_ERROR_INVALID_CHALLENGE_TYPE,
156 .hksResult = {
157 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
158 .errorMsg = "Invalid challenge type.",
159 .data = NULL
160 }
161 }, {
162 .innerErrCode = HKS_ERROR_INVALID_ACCESS_TYPE,
163 .hksResult = {
164 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
165 .errorMsg = "Invalid access type.",
166 .data = NULL
167 }
168 }, {
169 .innerErrCode = HKS_ERROR_INVALID_AUTH_TOKEN,
170 .hksResult = {
171 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
172 .errorMsg = "Invalid authentication token.",
173 .data = NULL
174 }
175 }, {
176 .innerErrCode = HKS_ERROR_INVALID_SECURE_SIGN_TYPE,
177 .hksResult = {
178 .errorCode = HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
179 .errorMsg = "Invalid secure sign type.",
180 .data = NULL
181 }
182 }, {
183 .innerErrCode = HKS_ERROR_API_NOT_SUPPORTED,
184 .hksResult = {
185 .errorCode = HUKS_ERR_CODE_NOT_SUPPORTED_API,
186 .errorMsg = "This API is not supported.",
187 .data = NULL
188 }
189 }, {
190 .innerErrCode = HKS_ERROR_NOT_SUPPORTED,
191 .hksResult = {
192 .errorCode = HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED,
193 .errorMsg = "The feature is not support.",
194 .data = NULL
195 }
196 }, {
197 .innerErrCode = HKS_ERROR_USER_AUTH_TYPE_NOT_SUPPORT,
198 .hksResult = {
199 .errorCode = HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED,
200 .errorMsg = "The user authentication type is not supported.",
201 .data = NULL
202 }
203 }, {
204 .innerErrCode = HKS_ERROR_CHECK_GET_ALG_FAIL,
205 .hksResult = {
206 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
207 .errorMsg = "Failed to obtain the algorithm. It is not set in ParamSet.",
208 .data = NULL
209 }
210 }, {
211 .innerErrCode = HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL,
212 .hksResult = {
213 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
214 .errorMsg = "Failed to obtain the key size. It is not set in ParamSet.",
215 .data = NULL
216 }
217 }, {
218 .innerErrCode = HKS_ERROR_CHECK_GET_PADDING_FAIL,
219 .hksResult = {
220 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
221 .errorMsg = "Failed to obtain the padding algorithm. It is not set in ParamSet.",
222 .data = NULL
223 }
224 }, {
225 .innerErrCode = HKS_ERROR_CHECK_GET_PURPOSE_FAIL,
226 .hksResult = {
227 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
228 .errorMsg = "Failed to obtain the key purpose. It is not set in ParamSet.",
229 .data = NULL
230 }
231 }, {
232 .innerErrCode = HKS_ERROR_CHECK_GET_DIGEST_FAIL,
233 .hksResult = {
234 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
235 .errorMsg = "Failed to obtain the digest algorithm. It is not set in ParamSet.",
236 .data = NULL
237 }
238 }, {
239 .innerErrCode = HKS_ERROR_CHECK_GET_MODE_FAIL,
240 .hksResult = {
241 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
242 .errorMsg = "Failed to obtain the cipher mode. It is not set in ParamSet.",
243 .data = NULL
244 }
245 }, {
246 .innerErrCode = HKS_ERROR_CHECK_GET_NONCE_FAIL,
247 .hksResult = {
248 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
249 .errorMsg = "Failed to obtain the nonce. It is not set in ParamSet.",
250 .data = NULL
251 }
252 }, {
253 .innerErrCode = HKS_ERROR_CHECK_GET_AAD_FAIL,
254 .hksResult = {
255 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
256 .errorMsg = "Failed to obtain the AAD. It is not set in ParamSet.",
257 .data = NULL
258 }
259 }, {
260 .innerErrCode = HKS_ERROR_CHECK_GET_IV_FAIL,
261 .hksResult = {
262 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
263 .errorMsg = "Failed to obtain the IV. It is not set in ParamSet.",
264 .data = NULL
265 }
266 }, {
267 .innerErrCode = HKS_ERROR_CHECK_GET_AE_TAG_FAIL,
268 .hksResult = {
269 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
270 .errorMsg = "Failed to obtain the AEAD. It is not set in ParamSet.",
271 .data = NULL
272 }
273 }, {
274 .innerErrCode = HKS_ERROR_CHECK_GET_SALT_FAIL,
275 .hksResult = {
276 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
277 .errorMsg = "Failed to obtain the salt value. It is not set in ParamSet.",
278 .data = NULL
279 }
280 }, {
281 .innerErrCode = HKS_ERROR_CHECK_GET_ITERATION_FAIL,
282 .hksResult = {
283 .errorCode = HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT,
284 .errorMsg = "Failed to obtain the number of iterations. It is not set in ParamSet.",
285 .data = NULL
286 }
287 }, {
288 .innerErrCode = HKS_ERROR_INVALID_ALGORITHM,
289 .hksResult = {
290 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
291 .errorMsg = "Invalid algorithm.",
292 .data = NULL
293 }
294 }, {
295 .innerErrCode = HKS_ERROR_INVALID_KEY_SIZE,
296 .hksResult = {
297 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
298 .errorMsg = "Invalid key size.",
299 .data = NULL
300 }
301 }, {
302 .innerErrCode = HKS_ERROR_INVALID_PADDING,
303 .hksResult = {
304 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
305 .errorMsg = "Invalid padding algorithm.",
306 .data = NULL
307 }
308 }, {
309 .innerErrCode = HKS_ERROR_INVALID_PURPOSE,
310 .hksResult = {
311 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
312 .errorMsg = "Invalid key purpose.",
313 .data = NULL
314 }
315 }, {
316 .innerErrCode = HKS_ERROR_INVALID_MODE,
317 .hksResult = {
318 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
319 .errorMsg = "Invalid cipher mode.",
320 .data = NULL
321 }
322 }, {
323 .innerErrCode = HKS_ERROR_INVALID_DIGEST,
324 .hksResult = {
325 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
326 .errorMsg = "Invalid digest algorithm.",
327 .data = NULL
328 }
329 }, {
330 .innerErrCode = HKS_ERROR_INVALID_SIGNATURE_SIZE,
331 .hksResult = {
332 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
333 .errorMsg = "Invalid signature size.",
334 .data = NULL
335 }
336 }, {
337 .innerErrCode = HKS_ERROR_INVALID_IV,
338 .hksResult = {
339 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
340 .errorMsg = "Invalid IV.",
341 .data = NULL
342 }
343 }, {
344 .innerErrCode = HKS_ERROR_INVALID_AAD,
345 .hksResult = {
346 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
347 .errorMsg = "Invalid AAD.",
348 .data = NULL
349 }
350 }, {
351 .innerErrCode = HKS_ERROR_INVALID_NONCE,
352 .hksResult = {
353 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
354 .errorMsg = "Invalid nonce.",
355 .data = NULL
356 }
357 }, {
358 .innerErrCode = HKS_ERROR_INVALID_AE_TAG,
359 .hksResult = {
360 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
361 .errorMsg = "Invalid AE.",
362 .data = NULL
363 }
364 }, {
365 .innerErrCode = HKS_ERROR_INVALID_SALT,
366 .hksResult = {
367 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
368 .errorMsg = "Invalid salt value.",
369 .data = NULL
370 }
371 }, {
372 .innerErrCode = HKS_ERROR_INVALID_ITERATION,
373 .hksResult = {
374 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
375 .errorMsg = "Invalid iteration count.",
376 .data = NULL
377 }
378 }, {
379 .innerErrCode = HKS_ERROR_INVALID_USAGE_OF_KEY,
380 .hksResult = {
381 .errorCode = HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT,
382 .errorMsg = "Invalid key purpose.",
383 .data = NULL
384 }
385 }, {
386 .innerErrCode = HKS_ERROR_STORAGE_FAILURE,
387 .hksResult = {
388 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
389 .errorMsg = "Insufficient storage space.",
390 .data = NULL
391 }
392 }, {
393 .innerErrCode = HKS_ERROR_FILE_SIZE_FAIL,
394 .hksResult = {
395 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
396 .errorMsg = "Invalid file size.",
397 .data = NULL
398 }
399 }, {
400 .innerErrCode = HKS_ERROR_READ_FILE_FAIL,
401 .hksResult = {
402 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
403 .errorMsg = "Failed to read the file.",
404 .data = NULL
405 }
406 }, {
407 .innerErrCode = HKS_ERROR_WRITE_FILE_FAIL,
408 .hksResult = {
409 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
410 .errorMsg = "Failed to write the file.",
411 .data = NULL
412 }
413 }, {
414 .innerErrCode = HKS_ERROR_REMOVE_FILE_FAIL,
415 .hksResult = {
416 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
417 .errorMsg = "Failed to remove the file.",
418 .data = NULL
419 }
420 }, {
421 .innerErrCode = HKS_ERROR_OPEN_FILE_FAIL,
422 .hksResult = {
423 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
424 .errorMsg = "Failed to open the file.",
425 .data = NULL
426 }
427 }, {
428 .innerErrCode = HKS_ERROR_CLOSE_FILE_FAIL,
429 .hksResult = {
430 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
431 .errorMsg = "Failed to close the file.",
432 .data = NULL
433 }
434 }, {
435 .innerErrCode = HKS_ERROR_MAKE_DIR_FAIL,
436 .hksResult = {
437 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
438 .errorMsg = "Failed to create the directory.",
439 .data = NULL
440 }
441 }, {
442 .innerErrCode = HKS_ERROR_INVALID_KEY_FILE,
443 .hksResult = {
444 .errorCode = HUKS_ERR_CODE_FILE_OPERATION_FAIL,
445 .errorMsg = "Failed to read the key from an invalid key file.",
446 .data = NULL
447 }
448 }, {
449 .innerErrCode = HKS_ERROR_IPC_MSG_FAIL,
450 .hksResult = {
451 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
452 .errorMsg = "Failed to get message from IPC.",
453 .data = NULL
454 }
455 }, {
456 .innerErrCode = HKS_ERROR_COMMUNICATION_TIMEOUT,
457 .hksResult = {
458 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
459 .errorMsg = "IPC timed out.",
460 .data = NULL
461 }
462 }, {
463 .innerErrCode = HKS_ERROR_IPC_INIT_FAIL,
464 .hksResult = {
465 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
466 .errorMsg = "IPC initialization failed.",
467 .data = NULL
468 }
469 }, {
470 .innerErrCode = HKS_ERROR_UNKNOWN_ERROR,
471 .hksResult = {
472 .errorCode = HUKS_ERR_CODE_COMMUNICATION_FAIL,
473 .errorMsg = "IPC async call failed.",
474 .data = NULL
475 }
476 }, {
477 .innerErrCode = HKS_ERROR_CRYPTO_ENGINE_ERROR,
478 .hksResult = {
479 .errorCode = HUKS_ERR_CODE_CRYPTO_FAIL,
480 .errorMsg = "Crypto engine error.",
481 .data = NULL
482 }
483 }, {
484 .innerErrCode = HKS_ERROR_KEY_AUTH_PERMANENTLY_INVALIDATED,
485 .hksResult = {
486 .errorCode = HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED,
487 .errorMsg = "This credential is invalidated permanently.",
488 .data = NULL
489 }
490 }, {
491 .innerErrCode = HKS_ERROR_KEY_AUTH_VERIFY_FAILED,
492 .hksResult = {
493 .errorCode = HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED,
494 .errorMsg = "The authentication token verification failed.",
495 .data = NULL
496 }
497 }, {
498 .innerErrCode = HKS_ERROR_KEY_AUTH_TIME_OUT,
499 .hksResult = {
500 .errorCode = HUKS_ERR_CODE_KEY_AUTH_TIME_OUT,
501 .errorMsg = "This authentication token timed out.",
502 .data = NULL
503 }
504 }, {
505 .innerErrCode = HKS_ERROR_SESSION_REACHED_LIMIT,
506 .hksResult = {
507 .errorCode = HUKS_ERR_CODE_SESSION_LIMIT,
508 .errorMsg = "The number of key operation sessions has reached the limit.",
509 .data = NULL
510 }
511 }, {
512 .innerErrCode = HKS_ERROR_NOT_EXIST,
513 .hksResult = {
514 .errorCode = HUKS_ERR_CODE_ITEM_NOT_EXIST,
515 .errorMsg = "The entity does not exist.",
516 .data = NULL
517 }
518 }, {
519 .innerErrCode = HKS_FAILURE,
520 .hksResult = {
521 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
522 .errorMsg = "Device environment or input parameter abnormal.",
523 .data = NULL
524 }
525 }, {
526 .innerErrCode = HKS_ERROR_BAD_STATE,
527 .hksResult = {
528 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
529 .errorMsg = "Device environment or input parameter abnormal.",
530 .data = NULL
531 }
532 }, {
533 .innerErrCode = HKS_ERROR_INTERNAL_ERROR,
534 .hksResult = {
535 .errorCode = HUKS_ERR_CODE_EXTERNAL_ERROR,
536 .errorMsg = "Device environment or input parameter abnormal.",
537 .data = NULL
538 }
539 }, {
540 .innerErrCode = HKS_ERROR_CREDENTIAL_NOT_EXIST,
541 .hksResult = {
542 .errorCode = HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST,
543 .errorMsg = "The credential does not exist.",
544 .data = NULL
545 }
546 }, {
547 .innerErrCode = HKS_ERROR_INSUFFICIENT_MEMORY,
548 .hksResult = {
549 .errorCode = HUKS_ERR_CODE_INSUFFICIENT_MEMORY,
550 .errorMsg = "Insufficient memory.",
551 .data = NULL
552 }
553 }, {
554 .innerErrCode = HKS_ERROR_MALLOC_FAIL,
555 .hksResult = {
556 .errorCode = HUKS_ERR_CODE_INSUFFICIENT_MEMORY,
557 .errorMsg = "Malloc failed.",
558 .data = NULL
559 }
560 }, {
561 .innerErrCode = HKS_ERROR_GET_USERIAM_SECINFO_FAILED,
562 .hksResult = {
563 .errorCode = HUKS_ERR_CODE_CALL_SERVICE_FAILED,
564 .errorMsg = "Failed to obtain the security information via UserIAM.",
565 .data = NULL
566 }
567 }, {
568 .innerErrCode = HKS_ERROR_GET_USERIAM_AUTHINFO_FAILED,
569 .hksResult = {
570 .errorCode = HUKS_ERR_CODE_CALL_SERVICE_FAILED,
571 .errorMsg = "Failed to obtain the authentication information via UserIAM.",
572 .data = NULL
573 }
574 }, {
575 .innerErrCode = HKS_ERROR_DEVICE_PASSWORD_UNSET,
576 .hksResult = {
577 .errorCode = HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET,
578 .errorMsg = "A device password is required but not set.",
579 .data = NULL
580 }
581 }, {
582 .innerErrCode = HKS_ERROR_NEW_INVALID_ARGUMENT,
583 .hksResult = {
584 .errorCode = HUKS_ERR_CODE_INVALID_ARGUMENT,
585 .errorMsg = "The input parameter is invalid.",
586 .data = NULL
587 }
588 }, {
589 .innerErrCode = HKS_ERROR_CODE_KEY_ALREADY_EXIST,
590 .hksResult = {
591 .errorCode = HUKS_ERR_CODE_KEY_ALREADY_EXIST,
592 .errorMsg = "The key with same name is already exist.",
593 .data = NULL
594 }
595 }
596 };
597
598 /**
599 * Convert ErrCode.
600 * Convert internal error code to formal error code and return.
601 * Return HUKS_ERR_CODE_EXTERNAL_ERROR in case of converting failed.
602 */
HksConvertErrCode(int32_t ret)603 struct HksResult HksConvertErrCode(int32_t ret)
604 {
605 struct HksResult result = {HUKS_ERR_CODE_EXTERNAL_ERROR, g_convertErrMsg, NULL};
606 uint32_t i = 0;
607 uint32_t uErrCodeCount = sizeof(g_errCodeTable) / sizeof(g_errCodeTable[0]);
608 for (; i < uErrCodeCount; ++i) {
609 if (ret == g_errCodeTable[i].innerErrCode) {
610 return g_errCodeTable[i].hksResult;
611 }
612 }
613 HKS_LOG_E("convert error code form %" LOG_PUBLIC "d failed!", ret);
614 return result;
615 }
616
617