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 "face_auth_all_in_one_executor_hdi.h"
17 
18 #include <cstdint>
19 #include <functional>
20 #include <map>
21 #include <memory>
22 #include <new>
23 #include <utility>
24 #include <vector>
25 
26 #include "hdf_base.h"
27 #include "refbase.h"
28 
29 #include "iam_check.h"
30 #include "iam_executor_framework_types.h"
31 #include "iam_logger.h"
32 
33 #include "buffer_producer_sequenceable.h"
34 #include "face_auth_defines.h"
35 #include "face_auth_executor_callback_hdi.h"
36 #include "face_auth_hdi.h"
37 #include "sa_command_manager.h"
38 
39 #define LOG_TAG "FACE_AUTH_SA"
40 
41 namespace OHOS {
42 namespace UserIam {
43 namespace FaceAuth {
44 using IamResultCode = UserAuth::ResultCode;
45 using IamExecutorRole = UserAuth::ExecutorRole;
46 using IamExecutorInfo = UserAuth::ExecutorInfo;
47 namespace UserAuth = OHOS::UserIam::UserAuth;
FaceAuthAllInOneExecutorHdi(sptr<IAllInOneExecutor> executorProxy)48 FaceAuthAllInOneExecutorHdi::FaceAuthAllInOneExecutorHdi(sptr<IAllInOneExecutor> executorProxy)
49     : executorProxy_(executorProxy) {};
50 
GetExecutorInfo(IamExecutorInfo & info)51 IamResultCode FaceAuthAllInOneExecutorHdi::GetExecutorInfo(IamExecutorInfo &info)
52 {
53     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
54     ExecutorInfo localInfo = {};
55     int32_t status = executorProxy_->GetExecutorInfo(localInfo);
56     IamResultCode result = ConvertResultCode(status);
57     if (result != IamResultCode::SUCCESS) {
58         IAM_LOGE("GetExecutorInfo fail result %{public}d", result);
59         return result;
60     }
61     result = MoveHdiExecutorInfo(localInfo, info);
62     if (result != IamResultCode::SUCCESS) {
63         IAM_LOGE("MoveHdiExecutorInfo fail result %{public}d", result);
64         return result;
65     }
66     return IamResultCode::SUCCESS;
67 }
68 
OnRegisterFinish(const std::vector<uint64_t> & templateIdList,const std::vector<uint8_t> & frameworkPublicKey,const std::vector<uint8_t> & extraInfo)69 IamResultCode FaceAuthAllInOneExecutorHdi::OnRegisterFinish(const std::vector<uint64_t> &templateIdList,
70     const std::vector<uint8_t> &frameworkPublicKey, const std::vector<uint8_t> &extraInfo)
71 {
72     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
73     int32_t status = executorProxy_->OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
74     IamResultCode result = ConvertResultCode(status);
75     if (result != IamResultCode::SUCCESS) {
76         IAM_LOGE("OnRegisterFinish fail result %{public}d", result);
77         return result;
78     }
79 
80     result = RegisterSaCommandCallback();
81     if (result != IamResultCode::SUCCESS) {
82         IAM_LOGE("RegisterSaCommandCallback fail");
83         return result;
84     }
85     return IamResultCode::SUCCESS;
86 }
87 
SendMessage(uint64_t scheduleId,int32_t srcRole,const std::vector<uint8_t> & msg)88 IamResultCode FaceAuthAllInOneExecutorHdi::SendMessage(uint64_t scheduleId, int32_t srcRole,
89     const std::vector<uint8_t> &msg)
90 {
91     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
92     int32_t status = executorProxy_->SendMessage(scheduleId, srcRole, msg);
93     IamResultCode result = ConvertResultCode(status);
94     if (result != IamResultCode::SUCCESS) {
95         IAM_LOGE("Authenticate fail result %{public}d", result);
96         return result;
97     }
98     return IamResultCode::SUCCESS;
99 }
100 
Enroll(uint64_t scheduleId,const UserAuth::EnrollParam & param,const std::shared_ptr<UserAuth::IExecuteCallback> & callbackObj)101 IamResultCode FaceAuthAllInOneExecutorHdi::Enroll(uint64_t scheduleId, const UserAuth::EnrollParam &param,
102     const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj)
103 {
104     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
105     IF_FALSE_LOGE_AND_RETURN_VAL(callbackObj != nullptr, IamResultCode::GENERAL_ERROR);
106     sptr<IExecutorCallback> callback(new (std::nothrow) FaceAuthExecutorCallbackHdi(callbackObj, FACE_CALLBACK_ENROLL));
107     IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, IamResultCode::GENERAL_ERROR);
108     int32_t status = executorProxy_->Enroll(scheduleId, param.extraInfo, callback);
109     IamResultCode result = ConvertResultCode(status);
110     if (result != IamResultCode::SUCCESS) {
111         IAM_LOGE("Enroll fail result %{public}d", result);
112         return result;
113     }
114     return IamResultCode::SUCCESS;
115 }
116 
Authenticate(uint64_t scheduleId,const UserAuth::AuthenticateParam & param,const std::shared_ptr<UserAuth::IExecuteCallback> & callbackObj)117 IamResultCode FaceAuthAllInOneExecutorHdi::Authenticate(uint64_t scheduleId, const UserAuth::AuthenticateParam &param,
118     const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj)
119 {
120     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
121     IF_FALSE_LOGE_AND_RETURN_VAL(callbackObj != nullptr, IamResultCode::GENERAL_ERROR);
122     sptr<IExecutorCallback> callback(new (std::nothrow) FaceAuthExecutorCallbackHdi(callbackObj, FACE_CALLBACK_AUTH));
123     IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, IamResultCode::GENERAL_ERROR);
124     int32_t status = executorProxy_->Authenticate(scheduleId, param.templateIdList, param.extraInfo, callback);
125     IamResultCode result = ConvertResultCode(status);
126     if (result != IamResultCode::SUCCESS) {
127         IAM_LOGE("Authenticate fail result %{public}d", result);
128         return result;
129     }
130     return IamResultCode::SUCCESS;
131 }
132 
Identify(uint64_t scheduleId,const UserAuth::IdentifyParam & param,const std::shared_ptr<UserAuth::IExecuteCallback> & callbackObj)133 IamResultCode FaceAuthAllInOneExecutorHdi::Identify(uint64_t scheduleId, const UserAuth::IdentifyParam &param,
134     const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj)
135 {
136     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
137     IF_FALSE_LOGE_AND_RETURN_VAL(callbackObj != nullptr, IamResultCode::GENERAL_ERROR);
138     sptr<IExecutorCallback> callback(
139         new (std::nothrow) FaceAuthExecutorCallbackHdi(callbackObj, FACE_CALLBACK_IDENTIFY));
140     IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, IamResultCode::GENERAL_ERROR);
141     int32_t status = executorProxy_->Identify(scheduleId, param.extraInfo, callback);
142     IamResultCode result = ConvertResultCode(status);
143     if (result != IamResultCode::SUCCESS) {
144         IAM_LOGE("Identify fail result %{public}d", result);
145         return result;
146     }
147     return IamResultCode::SUCCESS;
148 }
149 
Delete(const std::vector<uint64_t> & templateIdList)150 IamResultCode FaceAuthAllInOneExecutorHdi::Delete(const std::vector<uint64_t> &templateIdList)
151 {
152     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
153     int32_t status = executorProxy_->Delete(templateIdList);
154     IamResultCode result = ConvertResultCode(status);
155     if (result != IamResultCode::SUCCESS) {
156         IAM_LOGE("Delete fail result %{public}d", result);
157         return result;
158     }
159     return IamResultCode::SUCCESS;
160 }
161 
Cancel(uint64_t scheduleId)162 IamResultCode FaceAuthAllInOneExecutorHdi::Cancel(uint64_t scheduleId)
163 {
164     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
165     int32_t status = executorProxy_->Cancel(scheduleId);
166     IamResultCode result = ConvertResultCode(status);
167     if (result != IamResultCode::SUCCESS) {
168         IAM_LOGE("Cancel fail result %{public}d", result);
169         return result;
170     }
171     return IamResultCode::SUCCESS;
172 }
173 
SendCommand(UserAuth::PropertyMode commandId,const std::vector<uint8_t> & extraInfo,const std::shared_ptr<UserAuth::IExecuteCallback> & callbackObj)174 IamResultCode FaceAuthAllInOneExecutorHdi::SendCommand(UserAuth::PropertyMode commandId,
175     const std::vector<uint8_t> &extraInfo, const std::shared_ptr<UserAuth::IExecuteCallback> &callbackObj)
176 {
177     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
178     IF_FALSE_LOGE_AND_RETURN_VAL(callbackObj != nullptr, IamResultCode::GENERAL_ERROR);
179     int32_t hdiCommandId;
180     IamResultCode result = ConvertCommandId(commandId, hdiCommandId);
181     if (result != IamResultCode::SUCCESS) {
182         IAM_LOGE("ConvertCommandId fail result %{public}d", result);
183         return result;
184     }
185     sptr<IExecutorCallback> callback(
186         new (std::nothrow) FaceAuthExecutorCallbackHdi(callbackObj, FACE_CALLBACK_COMMAND));
187     IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, IamResultCode::GENERAL_ERROR);
188     int32_t status = executorProxy_->SendCommand(hdiCommandId, extraInfo, callback);
189     result = ConvertResultCode(status);
190     if (result != IamResultCode::SUCCESS) {
191         IAM_LOGE("SendCommand fail result %{public}d", result);
192         return result;
193     }
194     return IamResultCode::SUCCESS;
195 }
196 
GetProperty(const std::vector<uint64_t> & templateIdList,const std::vector<UserAuth::Attributes::AttributeKey> & keys,UserAuth::Property & property)197 UserAuth::ResultCode FaceAuthAllInOneExecutorHdi::GetProperty(const std::vector<uint64_t> &templateIdList,
198     const std::vector<UserAuth::Attributes::AttributeKey> &keys, UserAuth::Property &property)
199 {
200     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
201 
202     std::vector<int32_t> propertyTypes;
203     IamResultCode result = ConvertAttributeKeyVectorToPropertyType(keys, propertyTypes);
204     IF_FALSE_LOGE_AND_RETURN_VAL(result == IamResultCode::SUCCESS, IamResultCode::GENERAL_ERROR);
205 
206     Property hdiProperty;
207     int32_t status = executorProxy_->GetProperty(templateIdList, propertyTypes, hdiProperty);
208     result = ConvertResultCode(status);
209     if (result != IamResultCode::SUCCESS) {
210         IAM_LOGE("SendCommand fail result %{public}d", result);
211         return result;
212     }
213     MoveHdiProperty(hdiProperty, property);
214     return IamResultCode::SUCCESS;
215 }
216 
SetCachedTemplates(const std::vector<uint64_t> & templateIdList)217 UserAuth::ResultCode FaceAuthAllInOneExecutorHdi::SetCachedTemplates(const std::vector<uint64_t> &templateIdList)
218 {
219     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
220 
221     int32_t status = executorProxy_->SetCachedTemplates(templateIdList);
222     IamResultCode result = ConvertResultCode(status);
223     if (result != IamResultCode::SUCCESS) {
224         IAM_LOGE("SendCommand fail result %{public}d", result);
225         return result;
226     }
227     return IamResultCode::SUCCESS;
228 }
229 
OnHdiDisconnect()230 void FaceAuthAllInOneExecutorHdi::OnHdiDisconnect()
231 {
232     IAM_LOGE("start");
233     SaCommandManager::GetInstance().OnHdiDisconnect(shared_from_this());
234 }
235 
MoveHdiExecutorInfo(ExecutorInfo & in,IamExecutorInfo & out)236 IamResultCode FaceAuthAllInOneExecutorHdi::MoveHdiExecutorInfo(ExecutorInfo &in, IamExecutorInfo &out)
237 {
238     out.executorSensorHint = static_cast<uint32_t>(in.sensorId);
239     out.executorMatcher = in.executorMatcher;
240     IamResultCode result = ConvertExecutorRole(in.executorRole, out.executorRole);
241     if (result != IamResultCode::SUCCESS) {
242         IAM_LOGE("ConvertExecutorRole fail result %{public}d", result);
243         return result;
244     }
245     result = ConvertAuthType(in.authType, out.authType);
246     if (result != IamResultCode::SUCCESS) {
247         IAM_LOGE("ConvertAuthType fail result %{public}d", result);
248         return result;
249     }
250     result = ConvertExecutorSecureLevel(in.esl, out.esl);
251     if (result != IamResultCode::SUCCESS) {
252         IAM_LOGE("ConvertExecutorSecureLevel fail result %{public}d", result);
253         return result;
254     }
255     out.maxTemplateAcl = in.maxTemplateAcl;
256     in.publicKey.swap(out.publicKey);
257     return IamResultCode::SUCCESS;
258 }
259 
MoveHdiProperty(Property & in,UserAuth::Property & out)260 void FaceAuthAllInOneExecutorHdi::MoveHdiProperty(Property &in, UserAuth::Property &out)
261 {
262     out.authSubType = in.authSubType;
263     out.lockoutDuration = in.lockoutDuration;
264     out.remainAttempts = in.remainAttempts;
265     out.enrollmentProgress.swap(in.enrollmentProgress);
266     out.sensorInfo.swap(in.sensorInfo);
267 }
268 
ConvertCommandId(const UserAuth::PropertyMode in,int32_t & out)269 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertCommandId(const UserAuth::PropertyMode in, int32_t &out)
270 {
271     if (static_cast<DriverCommandId>(in) > DriverCommandId::VENDOR_COMMAND_BEGIN) {
272         out = static_cast<DriverCommandId>(in);
273         IAM_LOGI("vendor command id %{public}d, no covert", out);
274         return IamResultCode::SUCCESS;
275     }
276 
277     static const std::map<UserAuth::PropertyMode, DriverCommandId> data = {
278         { UserAuth::PropertyMode::PROPERTY_INIT_ALGORITHM, DriverCommandId::INIT_ALGORITHM },
279         { UserAuth::PropertyMode::PROPERTY_MODE_FREEZE, DriverCommandId::LOCK_TEMPLATE },
280         { UserAuth::PropertyMode::PROPERTY_MODE_UNFREEZE, DriverCommandId::UNLOCK_TEMPLATE } };
281     auto iter = data.find(in);
282     if (iter == data.end()) {
283         IAM_LOGE("command id %{public}d is invalid", in);
284         return IamResultCode::INVALID_PARAMETERS;
285     }
286     out = static_cast<int32_t>(iter->second);
287     IAM_LOGI("covert command id %{public}d to idl command is %{public}d", in, out);
288     return IamResultCode::SUCCESS;
289 }
290 
ConvertAuthType(const int32_t in,UserAuth::AuthType & out)291 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertAuthType(const int32_t in, UserAuth::AuthType &out)
292 {
293     static const std::map<AuthType, UserAuth::AuthType> data = {
294         { AuthType::FACE, UserAuth::AuthType::FACE },
295     };
296     auto iter = data.find(static_cast<AuthType>(in));
297     if (iter == data.end()) {
298         IAM_LOGE("authType %{public}d is invalid", in);
299         return IamResultCode::GENERAL_ERROR;
300     }
301     out = iter->second;
302     return IamResultCode::SUCCESS;
303 }
304 
ConvertExecutorRole(const int32_t in,IamExecutorRole & out)305 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertExecutorRole(const int32_t in, IamExecutorRole &out)
306 {
307     static const std::map<ExecutorRole, IamExecutorRole> data = {
308         { ExecutorRole::COLLECTOR, IamExecutorRole::COLLECTOR },
309         { ExecutorRole::VERIFIER, IamExecutorRole::VERIFIER },
310         { ExecutorRole::ALL_IN_ONE, IamExecutorRole::ALL_IN_ONE },
311     };
312     auto iter = data.find(static_cast<ExecutorRole>(in));
313     if (iter == data.end()) {
314         IAM_LOGE("executorRole %{public}d is invalid", in);
315         return IamResultCode::GENERAL_ERROR;
316     }
317     out = iter->second;
318     return IamResultCode::SUCCESS;
319 }
320 
ConvertExecutorSecureLevel(const int32_t in,UserAuth::ExecutorSecureLevel & out)321 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertExecutorSecureLevel(const int32_t in,
322     UserAuth::ExecutorSecureLevel &out)
323 {
324     static const std::map<ExecutorSecureLevel, UserAuth::ExecutorSecureLevel> data = {
325         { ExecutorSecureLevel::ESL0, UserAuth::ExecutorSecureLevel::ESL0 },
326         { ExecutorSecureLevel::ESL1, UserAuth::ExecutorSecureLevel::ESL1 },
327         { ExecutorSecureLevel::ESL2, UserAuth::ExecutorSecureLevel::ESL2 },
328         { ExecutorSecureLevel::ESL3, UserAuth::ExecutorSecureLevel::ESL3 },
329     };
330     auto iter = data.find(static_cast<ExecutorSecureLevel>(in));
331     if (iter == data.end()) {
332         IAM_LOGE("executorSecureLevel %{public}d is invalid", in);
333         return IamResultCode::GENERAL_ERROR;
334     }
335     out = iter->second;
336     return IamResultCode::SUCCESS;
337 }
338 
ConvertResultCode(const int32_t in)339 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertResultCode(const int32_t in)
340 {
341     HDF_STATUS hdfIn = static_cast<HDF_STATUS>(in);
342     static const std::map<HDF_STATUS, IamResultCode> data = {
343         { HDF_SUCCESS, IamResultCode::SUCCESS },
344         { HDF_FAILURE, IamResultCode::GENERAL_ERROR },
345         { HDF_ERR_TIMEOUT, IamResultCode::TIMEOUT },
346         { HDF_ERR_QUEUE_FULL, IamResultCode::BUSY },
347         { HDF_ERR_DEVICE_BUSY, IamResultCode::BUSY },
348     };
349 
350     IamResultCode out;
351     auto iter = data.find(hdfIn);
352     if (iter == data.end()) {
353         out = IamResultCode::GENERAL_ERROR;
354     } else {
355         out = iter->second;
356     }
357     IAM_LOGI("covert hdi result code %{public}d to framework result code %{public}d", in, out);
358     return out;
359 }
360 
ConvertAttributeKeyVectorToPropertyType(const std::vector<UserAuth::Attributes::AttributeKey> inItems,std::vector<int32_t> & outItems)361 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertAttributeKeyVectorToPropertyType(
362     const std::vector<UserAuth::Attributes::AttributeKey> inItems, std::vector<int32_t> &outItems)
363 {
364     outItems.clear();
365     for (auto &inItem : inItems) {
366         int32_t outItem;
367         IamResultCode result = ConvertAttributeKeyToPropertyType(inItem, outItem);
368         IF_FALSE_LOGE_AND_RETURN_VAL(result == IamResultCode::SUCCESS, IamResultCode::GENERAL_ERROR);
369         outItems.push_back(outItem);
370     }
371 
372     return IamResultCode::SUCCESS;
373 }
374 
ConvertAttributeKeyToPropertyType(const UserAuth::Attributes::AttributeKey in,int32_t & out)375 IamResultCode FaceAuthAllInOneExecutorHdi::ConvertAttributeKeyToPropertyType(
376     const UserAuth::Attributes::AttributeKey in, int32_t &out)
377 {
378     static const std::map<UserAuth::Attributes::AttributeKey, GetPropertyType> data = {
379         { UserAuth::Attributes::ATTR_PIN_SUB_TYPE, GetPropertyType::AUTH_SUB_TYPE },
380         { UserAuth::Attributes::ATTR_FREEZING_TIME, GetPropertyType::LOCKOUT_DURATION },
381         { UserAuth::Attributes::ATTR_REMAIN_TIMES, GetPropertyType::REMAIN_ATTEMPTS },
382         { UserAuth::Attributes::ATTR_ENROLL_PROGRESS, GetPropertyType::ENROLL_PROGRESS },
383         { UserAuth::Attributes::ATTR_SENSOR_INFO, GetPropertyType::SENSOR_INFO },
384     };
385 
386     auto iter = data.find(in);
387     if (iter == data.end()) {
388         IAM_LOGE("attribute %{public}d is invalid", in);
389         return IamResultCode::GENERAL_ERROR;
390     } else {
391         out = static_cast<int32_t>(iter->second);
392     }
393     IAM_LOGI("covert hdi result code %{public}d to framework result code %{public}d", in, out);
394     return IamResultCode::SUCCESS;
395 }
396 
RegisterSaCommandCallback()397 UserAuth::ResultCode FaceAuthAllInOneExecutorHdi::RegisterSaCommandCallback()
398 {
399     IF_FALSE_LOGE_AND_RETURN_VAL(executorProxy_ != nullptr, IamResultCode::GENERAL_ERROR);
400 
401     sptr<SaCommandCallback> callback(new (std::nothrow) SaCommandCallback(shared_from_this()));
402     IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, IamResultCode::GENERAL_ERROR);
403 
404     int32_t status = executorProxy_->RegisterSaCommandCallback(callback);
405     IamResultCode result = ConvertResultCode(status);
406     if (result != IamResultCode::SUCCESS) {
407         IAM_LOGE("RegisterSaCommandCallback fail result %{public}d", result);
408         return result;
409     }
410 
411     return IamResultCode::SUCCESS;
412 }
413 
OnSaCommands(const std::vector<SaCommand> & commands)414 int32_t FaceAuthAllInOneExecutorHdi::SaCommandCallback::OnSaCommands(const std::vector<SaCommand> &commands)
415 {
416     IAM_LOGI("start");
417     IamResultCode result = SaCommandManager::GetInstance().ProcessSaCommands(executorHdi_, commands);
418     if (result != IamResultCode::SUCCESS) {
419         IAM_LOGE("ProcessSaCommands fail");
420         return HDF_FAILURE;
421     }
422     IAM_LOGI("success");
423     return HDF_SUCCESS;
424 };
425 } // namespace FaceAuth
426 } // namespace UserIam
427 } // namespace OHOS
428