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
16 #include "useridm_coauth_handler.h"
17 #include "useridm_hilog_wrapper.h"
18 #include "useridm_adapter.h"
19
20 namespace OHOS {
21 namespace UserIAM {
22 namespace UserIDM {
UserIDMCoAuthHandler(CoAuthType type,const uint64_t challenge,const uint64_t scheduleId,const std::shared_ptr<UserIDMModule> & data,const sptr<IIDMCallback> & callback)23 UserIDMCoAuthHandler::UserIDMCoAuthHandler(CoAuthType type, const uint64_t challenge, const uint64_t scheduleId,
24 const std::shared_ptr<UserIDMModule>& data, const sptr<IIDMCallback>& callback)
25 {
26 USERIDM_HILOGD(MODULE_SERVICE, "UserIDMCoAuthHandler constructor start");
27
28 type_ = type;
29 lastChallenge_ = challenge;
30 lastScheduleId_ = scheduleId;
31 dataCallback_ = data;
32 innerCallback_ = callback;
33 if (innerCallback_ == nullptr) {
34 USERIDM_HILOGE(MODULE_SERVICE, "sorry: input callback is nullptr");
35 }
36 }
37
OnFinishModify(uint32_t resultCode,std::vector<uint8_t> & scheduleToken,uint64_t & credentialId)38 int32_t UserIDMCoAuthHandler::OnFinishModify(uint32_t resultCode, std::vector<uint8_t>& scheduleToken,
39 uint64_t& credentialId)
40 {
41 if (innerCallback_ == nullptr) {
42 USERIDM_HILOGE(MODULE_SERVICE, "sorry: innerCallback_ is nullptr");
43 return INVALID_PARAMETERS;
44 }
45 uint64_t challenge = 0;
46 uint64_t scheduleId = 0;
47 if (dataCallback_ == nullptr) {
48 USERIDM_HILOGE(MODULE_SERVICE, "dataCallback error: no found");
49 return FAIL;
50 }
51 bool res = dataCallback_->CheckChallenge(challenge);
52 if (!res) {
53 USERIDM_HILOGE(MODULE_SERVICE, "check challenge num error: no challenge");
54 return FAIL;
55 }
56
57 res = dataCallback_->CheckScheduleIdIsActive(scheduleId);
58 if (res && (scheduleId == lastScheduleId_)) {
59 CredentialInfo credentialInfo;
60 UserIDMAdapter::GetInstance().UpdateCredential(scheduleToken, credentialId, credentialInfo);
61
62 std::shared_ptr<UserIDMSetPropHandler> setPropCallback =
63 std::make_shared<UserIDMSetPropHandler>(PIN, challenge, scheduleId, credentialId,
64 dataCallback_, innerCallback_);
65 AuthResPool::AuthAttributes condition;
66 condition.SetUint32Value(AuthAttributeType::AUTH_PROPERTY_MODE, 0);
67 condition.SetUint64Value(AuthAttributeType::AUTH_CALLER_UID, 0);
68 condition.SetUint64Value(AuthAttributeType::AUTH_CREDENTIAL_ID, credentialInfo.credentialId);
69 condition.SetUint32Value(AuthAttributeType::AUTH_TYPE, credentialInfo.authType);
70 condition.SetUint64Value(AuthAttributeType::AUTH_TEMPLATE_ID, credentialInfo.templateId);
71 CoAuth::CoAuth::GetInstance().SetExecutorProp(condition, setPropCallback);
72 return SUCCESS;
73 } else {
74 USERIDM_HILOGE(MODULE_SERVICE, "scheduleId wrong");
75 return FAIL;
76 }
77 }
78
OnFinish(uint32_t resultCode,std::vector<uint8_t> & scheduleToken)79 void UserIDMCoAuthHandler::OnFinish(uint32_t resultCode, std::vector<uint8_t>& scheduleToken)
80 {
81 USERIDM_HILOGD(MODULE_SERVICE, "UserIDMCoAuthHandler OnFinish start: %{public}u type_ is %{public}d",
82 resultCode, type_);
83 std::lock_guard<std::mutex> lock(mutex_);
84 if (innerCallback_ == nullptr) {
85 USERIDM_HILOGE(MODULE_SERVICE, "sorry: innerCallback_ is nullptr");
86 return;
87 }
88 int32_t result = FAIL;
89 uint64_t credentialId = 0;
90 if (resultCode != SUCCESS) {
91 dataCallback_->DeleteSessionId();
92 RequestResult reqRet;
93 reqRet.credentialId = credentialId;
94 innerCallback_->OnResult(result, reqRet);
95 return;
96 }
97 if ((type_ == ADD_PIN_CRED) || (type_ == ADD_FACE_CRED)) {
98 uint64_t scheduleId = 0;
99 bool res = dataCallback_->CheckScheduleIdIsActive(scheduleId);
100 if (res && (scheduleId == lastScheduleId_)) {
101 result = UserIDMAdapter::GetInstance().AddCredential(scheduleToken, credentialId);
102 if (result != SUCCESS) {
103 USERIDM_HILOGE(MODULE_SERVICE, "call TA info addCred failed");
104 }
105 }
106 dataCallback_->DeleteSessionId();
107 RequestResult reqRet;
108 reqRet.credentialId = credentialId;
109 innerCallback_->OnResult(result, reqRet);
110 } else if (type_ == MODIFY_CRED) {
111 result = OnFinishModify(resultCode, scheduleToken, credentialId);
112 RequestResult reqRet;
113 reqRet.credentialId = credentialId;
114 innerCallback_->OnResult(result, reqRet);
115 dataCallback_->DeleteSessionId();
116 } else {
117 USERIDM_HILOGE(MODULE_SERVICE, "callback type error: %{public}d", type_);
118 }
119 }
120
OnAcquireInfo(uint32_t acquire)121 void UserIDMCoAuthHandler::OnAcquireInfo(uint32_t acquire)
122 {
123 USERIDM_HILOGD(MODULE_SERVICE, "UserIDMCoAuthHandler OnAcquireInfo start");
124 std::lock_guard<std::mutex> lock(mutex_);
125 if (innerCallback_ == nullptr) {
126 USERIDM_HILOGE(MODULE_SERVICE, "sorry: innerCallback_ is nullptr");
127 return;
128 }
129
130 if (type_ == ADD_FACE_CRED) {
131 RequestResult reqRet = {};
132 const int32_t faceModule = 1;
133 innerCallback_->OnAcquireInfo(faceModule, acquire, reqRet);
134 }
135 }
136
ResetCallback()137 void UserIDMCoAuthHandler::ResetCallback()
138 {
139 std::lock_guard<std::mutex> lock(mutex_);
140 innerCallback_ = nullptr;
141 }
142 } // namespace UserIDM
143 } // namespace UserIAM
144 } // namespace OHOS
145