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 "pin_auth_executor_hdi_common.h"
17
18 #include <map>
19
20 #include "iam_logger.h"
21
22 #define LOG_TAG "PIN_AUTH_SA"
23
24 namespace OHOS {
25 namespace UserIam {
26 namespace PinAuth {
ConvertAuthType(AuthType in,UserAuth::AuthType & out)27 UserAuth::ResultCode ConvertAuthType(AuthType in, UserAuth::AuthType &out)
28 {
29 static const std::map<AuthType, UserAuth::AuthType> data = {
30 {AuthType::PIN, UserAuth::AuthType::PIN},
31 {AuthType::RECOVERY_KEY, UserAuth::AuthType::RECOVERY_KEY},
32 {AuthType::PRIVATE_PIN, UserAuth::AuthType::PRIVATE_PIN},
33 };
34 auto it = data.find(in);
35 if (it == data.end()) {
36 IAM_LOGE("authType %{public}d is invalid", in);
37 return UserAuth::ResultCode::GENERAL_ERROR;
38 }
39 out = it->second;
40 return UserAuth::ResultCode::SUCCESS;
41 }
42
ConvertExecutorRole(ExecutorRole in,UserAuth::ExecutorRole & out)43 UserAuth::ResultCode ConvertExecutorRole(ExecutorRole in, UserAuth::ExecutorRole &out)
44 {
45 static const std::map<ExecutorRole, UserAuth::ExecutorRole> data = {
46 {ExecutorRole::COLLECTOR, UserAuth::ExecutorRole::COLLECTOR},
47 {ExecutorRole::VERIFIER, UserAuth::ExecutorRole::VERIFIER},
48 {ExecutorRole::ALL_IN_ONE, UserAuth::ExecutorRole::ALL_IN_ONE},
49 };
50 auto it = data.find(in);
51 if (it == data.end()) {
52 IAM_LOGE("executorRole %{public}d is invalid", in);
53 return UserAuth::ResultCode::GENERAL_ERROR;
54 }
55 out = it->second;
56 return UserAuth::ResultCode::SUCCESS;
57 }
58
ConvertExecutorSecureLevel(ExecutorSecureLevel in,UserAuth::ExecutorSecureLevel & out)59 UserAuth::ResultCode ConvertExecutorSecureLevel(ExecutorSecureLevel in, UserAuth::ExecutorSecureLevel &out)
60 {
61 static const std::map<ExecutorSecureLevel, UserAuth::ExecutorSecureLevel> data = {
62 {ExecutorSecureLevel::ESL0, UserAuth::ExecutorSecureLevel::ESL0},
63 {ExecutorSecureLevel::ESL1, UserAuth::ExecutorSecureLevel::ESL1},
64 {ExecutorSecureLevel::ESL2, UserAuth::ExecutorSecureLevel::ESL2},
65 {ExecutorSecureLevel::ESL3, UserAuth::ExecutorSecureLevel::ESL3},
66 };
67 auto it = data.find(in);
68 if (it == data.end()) {
69 IAM_LOGE("executorSecureLevel %{public}d is invalid", in);
70 return UserAuth::ResultCode::GENERAL_ERROR;
71 }
72 out = it->second;
73 return UserAuth::ResultCode::SUCCESS;
74 }
75
MoveHdiExecutorInfo(ExecutorInfo & in,UserAuth::ExecutorInfo & out)76 UserAuth::ResultCode MoveHdiExecutorInfo(ExecutorInfo &in, UserAuth::ExecutorInfo &out)
77 {
78 out.executorSensorHint = static_cast<uint32_t>(in.sensorId);
79 out.executorMatcher = in.executorMatcher;
80 int32_t ret = ConvertExecutorRole(static_cast<ExecutorRole>(in.executorRole), out.executorRole);
81 if (ret != UserAuth::ResultCode::SUCCESS) {
82 IAM_LOGE("executorProxy is null");
83 return UserAuth::ResultCode::GENERAL_ERROR;
84 }
85 ret = ConvertAuthType(static_cast<AuthType>(in.authType), out.authType);
86 if (ret != UserAuth::ResultCode::SUCCESS) {
87 IAM_LOGE("ConvertAuthType fail ret=%{public}d", ret);
88 return UserAuth::ResultCode::GENERAL_ERROR;
89 }
90 ret = ConvertExecutorSecureLevel(static_cast<ExecutorSecureLevel>(in.esl), out.esl);
91 if (ret != UserAuth::ResultCode::SUCCESS) {
92 IAM_LOGE("ConvertExecutorSecureLevel fail ret=%{public}d", ret);
93 return UserAuth::ResultCode::GENERAL_ERROR;
94 }
95 out.maxTemplateAcl = in.maxTemplateAcl;
96 in.publicKey.swap(out.publicKey);
97 return UserAuth::ResultCode::SUCCESS;
98 }
99
ConvertHdiResultCode(int32_t in)100 UserAuth::ResultCode ConvertHdiResultCode(int32_t in)
101 {
102 HDF_STATUS hdfIn = static_cast<HDF_STATUS>(in);
103 static const std::map<HDF_STATUS, UserAuth::ResultCode> data = {
104 {HDF_SUCCESS, UserAuth::ResultCode::SUCCESS},
105 {HDF_FAILURE, UserAuth::ResultCode::GENERAL_ERROR},
106 {HDF_ERR_TIMEOUT, UserAuth::ResultCode::TIMEOUT},
107 {HDF_ERR_QUEUE_FULL, UserAuth::ResultCode::BUSY},
108 {HDF_ERR_DEVICE_BUSY, UserAuth::ResultCode::BUSY},
109 {HDF_ERR_INVALID_PARAM, UserAuth::ResultCode::INVALID_PARAMETERS},
110 };
111
112 UserAuth::ResultCode out;
113 auto it = data.find(hdfIn);
114 if (it == data.end()) {
115 out = UserAuth::ResultCode::GENERAL_ERROR;
116 } else {
117 out = it->second;
118 }
119 IAM_LOGI("covert hdi result code %{public}d to framework result code %{public}d", in, out);
120 return out;
121 }
122 } // namespace PinAuth
123 } // namespace UserIam
124 } // namespace OHOS
125