1# User_auth 2 3## 概述 4 5### 功能简介 6 7用户认证功能是端侧设备不可或缺的一部分，可应用于设备解锁、支付、应用登录等身份认证场景。用户认证（User_auth）框架统一管理用户身份与认证凭据模板的映射关系，通过调度各认证基础服务（包含口令认证、人脸识别等）实现的执行器完成用户认证凭据注册、凭据删除、身份认证及相关信息查询。用户认证的整体架构如图1。 8 9基于HDF（Hardware Driver Foundation）驱动框架开发的User_auth驱动，能够屏蔽硬件器件差异，为上层应用（设置、锁屏等）和账号管理SA（System Ability）提供稳定的用户身份认证能力，支持用户凭据管理、认证信息录入、认证方案生成以及认证执行器信息管理能力。 10 11**图1** 用户认证功能整体框架 12 13 14 15### 基本概念 16用户认证框架与各个基础认证服务（包含口令认证、人脸识别等）组成的身份认证系统，支持用户认证凭据设置、删除、认证等基础功能。 17 18- 认证凭据信息 19 20 用户设置口令、录入人脸时，会生成认证凭据模板，凭据信息由用户身份信息与凭据模板信息组成，用于在认证用户时找到匹配指定用户的凭据模板。 21 22- 认证凭据模板 23 24 认证凭据模板在用户设置认证凭据时由认证服务产生并存储。每个模板有一个ID，用于索引模板信息文件。在认证时，读取模板信息并和当次认证过程中产生的认证数据做对比，完成身份认证。 25 26- 执行器 27 28 执行器是能够提供数据采集、处理、存储及比对能力的模块，各基础认证服务提供执行器能力，被身份认证框架调度完成各项基础功能。 29 30- 执行器角色 31 32 - 全功能执行器：执行器可独立处理凭据注册和身份认证请求，即可提供用户认证数据采集、处理、储存及比对能力。 33 34 - 采集器：执行器提供用户认证时的数据采集能力，需要和认证器配合完成用户认证。 35 36 - 认证器：认证器提供用户认证时的数据处理能力，读取存储凭据模板信息并完成比对。 37 38- 执行器类型 39 40 同一种身份认证类型的不同认证方式、设备器件差异都会产生认证算法差异，执行器根据这些差异定义不同的执行器类型。 41 42- 执行器安全等级 43 44 执行器提供能力时所在运行环境达到的安全级别。 45 46- 用户认证框架公钥 & 执行器公钥 47 48 用户身份认证处理需要保证用户数据安全以及认证结果的准确性，用户认证框架与基础认证服务间的关键交互信息需要做数据完整性保护，各基础认证服务将提供的执行器能力对接到用户认证框架时，需要交换各自的公钥，其中： 49 50 - 执行器通过用户认证框架公钥校验调度指令的准确性，如锁定一个人脸模板，这种情况导致无法使用人脸功能，属于敏感操作，需要确保指令准确，才可处理。 51 52 - 执行器公钥可被用户认证框架用于校验认证结果的准确性，同时用于执行器交互认证时的校验交互信息的完整性。 53 54 55- 认证结果可信等级 56 57 不同认证方式及认证过程运行环境的安全级别差异，使得生成的认证结果的可信级别不同。 58 59- 认证方案 60 61 用户发起认证请求所使用的认证方式、认证结果可信等级、执行器信息和凭据信息等相关信息。 62 63- 调度信息 64 65 包括执行器信息及执行器处理请求需要的凭据模板信息，用于用户认证框架调度执行器完成基础功能。 66 67- System Ability 68 69 系统能力，由系统服务管理服务（System Ability Manager）加载，向OpenHarmony系统提供系统基础能力的基础服务。 70 71- Kit 72 73 OpenHarmony系统向第三方应用提供的基础应用编程接口。 74 75- Inner API 76 77 OpenHarmony系统向系统应用提供的应用编程接口。 78 79- IDL接口 80 81 接口定义语言（Interface Definition Language），通过IDL编译器编译后，能够生成与编程语言相关的文件：客户端桩文件，服务器框架文件。本文主要是通过IDL接口生成的客户端和服务端来实现User_auth服务和驱动的通信，详细使用方法可参考[IDL简介](https://gitee.com/openharmony/ability_idl_tool/blob/master/README.md)。 82 83- IPC通信 84 85 IPC（Inter Process Communication），进程间通信是指两个进程的数据之间产生交互，详细原理可参考[IPC通信简介](https://gitee.com/openharmony/communication_ipc/blob/master/README_zh.md)。 86 87- HDI 88 89 HDI（Hardware Device Interface），硬件设备接口，位于基础系统服务层和设备驱动层之间，是提供给硬件系统服务开发者使用的、统一的硬件设备功能抽象接口，其目的是为系统服务屏蔽底层硬件设备差异，具体可参考[HDI规范](../../design/hdi-design-specifications.md)。 90 91### 运作机制 92 93User_auth驱动主要工作是屏蔽不同安全器件和安全环境的差异，通过统一的认证能力注册、录入、认证接口，向User_auth服务提供认证执行器管理、认证凭据管理和认证方案生成管理等能力。 94开发者可基于HDF框架对不同芯片进行各自驱动的开发及HDI层接口的调用。 95 96**图2** User_auth服务和User_auth驱动交互 97 98 99 100### 约束与限制 101 102User_auth驱动的实现需要在可信执行环境中实现，保证用户凭据信息的安全存储及用户身份认证结果的可信可靠。 103 104## 开发指导 105 106### 场景介绍 107 108User_auth驱动的主要工作是为User_auth服务提供稳定的用户凭据管理、认证会话管理以及执行器信息管理能力，保证设备上口令认证和生物识别功能可以正常运行。 109 110### 接口说明 111 112注：以下接口列举的为IDL接口描述生成的对应C++语言函数接口，接口声明见idl文件（/drivers/interface/user_auth/v1_0/）。 113在本文中，执行器注册、凭据录入、凭据删除、用户认证和用户识别相关的HDI接口如表1所示。 114 115**表1** 接口功能介绍 116 117| 接口名称 | 功能介绍 | 118| --------------------------- | --------------------------- | 119| Init() | 初始化缓存信息。 | 120| AddExecutor(const ExecutorRegisterInfo& info, uint64_t& index, std::vector<uint8_t>& publicKey,<br/> std::vector<uint64_t>& templateIds) | 添加认证执行器，获得此认证能力。 | 121| DeleteExecutor(uint64_t index) | 根据索引值index删除认证执行器。 | 122| OpenSession(int32_t userId, std::vector<uint8_t>& challenge) | 开启认证凭据管理Session。 | 123| CloseSession(int32_t userId) | 关闭认证凭据管理Session。 | 124| BeginEnrollment(int32_t userId, const std::vector<uint8_t>& authToken, const EnrollParam& param,<br/> ScheduleInfo& info) | 发起用户的认证凭据的录入，当录入类型为PIN码且当前用户已录入PIN码的情况下会更新PIN码。 | 125| UpdateEnrollmentResult(int32_t userId, const std::vector<uint8_t>& scheduleResult, uint64_t& credentialId,<br/> CredentialInfo& oldInfo) | 更新录入结果，完成此次录入。 | 126| CancelEnrollment(int32_t userId) | 取消此次录入。 | 127| DeleteCredential(int32_t userId, uint64_t credentialId, const std::vector<uint8_t>& authToken,<br/> CredentialInfo& info) | 根据credentialId删除凭据信息。 | 128| DeleteUser(int32_t userId, const std::vector<uint8_t>& authToken,<br/> std::vector<CredentialInfo>& deletedInfos) | 删除PIN码即在用户认证框架中删除用户。 | 129| EnforceDeleteUser(int32_t userId, std::vector<CredentialInfo>& deletedInfos) | 强制删除用户，当系统内此用户被删除时强制调用。 | 130| GetCredential(int32_t userId, AuthType authType, std::vector<CredentialInfo>& infos) | 查询用户某种认证类型下的凭据信息。 | 131| GetSecureInfo(int32_t userId, uint64_t& secureUid, std::vector<EnrolledInfo>& infos) | 查询用户的安全用户Id和每种认证类型的录入标记Id。 | 132| BeginAuthentication(uint64_t contextId, const AuthSolution& param,<br/> std::vector<ScheduleInfo>& scheduleInfos) | 发起认证，生成认证方案和调度信息。 | 133| UpdateAuthenticationResult(uint64_t contextId, const std::vector<uint8_t>& scheduleResult,<br/> AuthResultInfo& info) | 更新认证结果，进行此次认证方案结果的评估。 | 134| CancelAuthentication(uint64_t contextId) | 取消此次认证。 | 135| BeginIdentification(uint64_t contextId, AuthType authType, const std::vector<int8_t>& challenge,<br/> uint32_t executorId, ScheduleInfo& scheduleInfo) | 发起识别，生成识别方案和调度信息。 | 136| UpdateIdentificationResult(uint64_t contextId, const std::vector<uint8_t>& scheduleResult,<br/> IdentifyResultInfo& info) | 更新识别结果，进行此次识别方案结果的评估。 | 137| CancelIdentification(uint64_t contextId) | 取消此次识别。 | 138| GetAuthTrustLevel(int32_t userId, AuthType authType, uint32_t& authTrustLevel) | 获取此用户当前认证类型的认证可信等级。 | 139| GetValidSolution(int32_t userId, const std::vector<AuthType>& authTypes, uint32_t authTrustLevel,<br/> std::vector<AuthType>& validTypes) | 筛选此用户当前认证可信等级下可用的认证方式。 | 140 141### 开发步骤 142 143以Hi3516DV300平台为例，我们提供了User_auth驱动DEMO实例，以下是目录结构及各部分功能简介。 144 145```undefined 146// drivers/peripheral/user_auth 147├── BUILD.gn # 编译脚本 148├── bundle.json # 组件描述文件 149└── hdi_service # User_auth驱动实现 150 ├── BUILD.gn # 编译脚本 151 ├── module # 功能实现 152 └── service 153 ├── user_auth_interface_driver.cpp # User_auth驱动入口 154 └── user_auth_interface_service.cpp # 获取执行器列表接口实现 155``` 156 157下面结合DEMO实例介绍驱动开发的具体步骤。 158 1591. 基于HDF驱动框架，按照驱动Driver Entry程序，完成User_auth驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现，详细代码参见[user_auth_interface_driver.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/user_auth/hdi_service/service/user_auth_interface_driver.cpp)文件。 160 161 ```c++ 162 // 通过自定义的HdfUserAuthInterfaceHost对象包含IoService对象和真正的HDI Service实现IRemoteObject对象 163 struct HdfUserAuthInterfaceHost { 164 struct IDeviceIoService ioService; 165 OHOS::sptr<OHOS::IRemoteObject> stub; 166 }; 167 168 // 服务接口调用响应接口 169 static int32_t UserAuthInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, 170 struct HdfSBuf *reply) 171 { 172 auto *hdfUserAuthInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUserAuthInterfaceHost, ioService); 173 174 OHOS::MessageParcel *dataParcel = nullptr; 175 OHOS::MessageParcel *replyParcel = nullptr; 176 OHOS::MessageOption option; 177 178 if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { 179 HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); 180 return HDF_ERR_INVALID_PARAM; 181 } 182 if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { 183 HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); 184 return HDF_ERR_INVALID_PARAM; 185 } 186 187 return hdfUserAuthInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); 188 } 189 190 // 初始化接口 191 int HdfUserAuthInterfaceDriverInit(struct HdfDeviceObject *deviceObject) 192 { 193 HDF_LOGI("HdfUserAuthInterfaceDriverInit enter"); 194 OHOS::UserIAM::Common::Init(); 195 return HDF_SUCCESS; 196 } 197 198 // User_auth驱动对外提供的服务绑定到HDF框架 199 int HdfUserAuthInterfaceDriverBind(struct HdfDeviceObject *deviceObject) 200 { 201 HDF_LOGI("HdfUserAuthInterfaceDriverBind enter"); 202 203 auto *hdfUserAuthInterfaceHost = new (std::nothrow) HdfUserAuthInterfaceHost; 204 if (hdfUserAuthInterfaceHost == nullptr) { 205 HDF_LOGE("%{public}s: failed to create HdfUserAuthInterfaceHost object", __func__); 206 return HDF_FAILURE; 207 } 208 209 hdfUserAuthInterfaceHost->ioService.Dispatch = UserAuthInterfaceDriverDispatch; 210 hdfUserAuthInterfaceHost->ioService.Open = NULL; 211 hdfUserAuthInterfaceHost->ioService.Release = NULL; 212 213 auto serviceImpl = IUserAuthInterface::Get(true); 214 if (serviceImpl == nullptr) { 215 HDF_LOGE("%{public}s: failed to implement service", __func__); 216 return HDF_FAILURE; 217 } 218 219 hdfUserAuthInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, 220 IUserAuthInterface::GetDescriptor()); 221 if (hdfUserAuthInterfaceHost->stub == nullptr) { 222 HDF_LOGE("%{public}s: failed to get stub object", __func__); 223 return HDF_FAILURE; 224 } 225 226 deviceObject->service = &hdfUserAuthInterfaceHost->ioService; 227 return HDF_SUCCESS; 228 } 229 230 // 释放User_auth驱动中的资源 231 void HdfUserAuthInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){ 232 HDF_LOGI("HdfUserAuthInterfaceDriverRelease enter"); 233 auto *hdfUserAuthInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfUserAuthInterfaceHost, ioService); 234 delete hdfUserAuthInterfaceHost; 235 } 236 237 // 注册User_auth驱动入口数据结构体对象 238 struct HdfDriverEntry g_userAuthInterfaceDriverEntry = { 239 .moduleVersion = 1, 240 .moduleName = "user_auth_device_driver", 241 .Bind = HdfUserAuthInterfaceDriverBind, 242 .Init = HdfUserAuthInterfaceDriverInit, 243 .Release = HdfUserAuthInterfaceDriverRelease, 244 }; 245 246 // 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 247 #ifndef __cplusplus 248 extern "C" { 249 #endif 250 HDF_INIT(g_userAuthInterfaceDriverEntry); 251 #ifndef __cplusplus 252 } 253 #endif 254 ``` 255 2562. 执行器注册接口举例实现，详细代码参见[user_auth_interface_service.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/user_auth/hdi_service/service/user_auth_interface_service.cpp)文件。 257 258 ```c++ 259 // 添加执行器 260 int32_t UserAuthInterfaceService::AddExecutor(const ExecutorRegisterInfo& info, uint64_t& index, 261 std::vector<uint8_t>& publicKey, std::vector<uint64_t>& templateIds) 262 { 263 GlobalLock(); 264 ExecutorInfoHal executorInfoHal; 265 CopyExecutorInfo(info, executorInfoHal); 266 int32_t ret = RegisterExecutor(&executorInfoHal, &index); 267 GlobalUnLock(); 268 return ret; 269 } 270 271 // 删除执行器 272 int32_t UserAuthInterfaceService::DeleteExecutor(uint64_t index) 273 { 274 return UnRegisterExecutor(index); 275 } 276 ``` 277 2783. 录入接口举例实现，详细代码参见[user_auth_interface_service.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/user_auth/hdi_service/service/user_auth_interface_service.cpp)文件。 279 280 ```c++ 281 // 开启认证凭据管理会话 282 int32_t UserAuthInterfaceService::OpenSession(int32_t userId, std::vector<uint8_t>& challenge) 283 { 284 GlobalLock(); 285 uint64_t challengeU64 = 0; 286 int32_t ret = OpenEditSession(userId, &challengeU64); 287 challenge.resize(sizeof(uint64_t)); 288 if (memcpy_s(&challenge[0], challenge.size(), &challengeU64, sizeof(uint64_t)) != EOK) { 289 IAM_LOGE("failed to copy challengeU64"); 290 return RESULT_BAD_COPY; 291 } 292 GlobalUnLock(); 293 return ret; 294 } 295 296 // 关闭认证凭据管理会话 297 int32_t UserAuthInterfaceService::CloseSession(int32_t userId) 298 { 299 GlobalLock(); 300 int32_t ret = CloseEditSession(); 301 GlobalUnLock(); 302 return ret; 303 } 304 305 // 发起认证，生成录入调度信息 306 int32_t UserAuthInterfaceService::BeginEnrollment(int32_t userId, const std::vector<uint8_t>& authToken, 307 const EnrollParam& param, ScheduleInfo& info) 308 { 309 IAM_LOGI("start"); 310 GlobalLock(); 311 if (authToken.size() != sizeof(UserAuthTokenHal) && param.authType != PIN) { 312 IAM_LOGE("authToken len is invalid"); 313 GlobalUnLock(); 314 return RESULT_BAD_PARAM; 315 } 316 PermissionCheckParam checkParam; 317 if (authToken.size() == sizeof(UserAuthTokenHal) && 318 memcpy_s(checkParam.token, AUTH_TOKEN_LEN, &authToken[0], authToken.size()) != EOK) { 319 GlobalUnLock(); 320 return RESULT_BAD_COPY; 321 } 322 checkParam.authType = param.authType; 323 checkParam.userId = userId; 324 checkParam.authSubType = (uint64_t)param.executorType; 325 CoAuthSchedule scheduleInfo; 326 int32_t ret = CheckEnrollPermission(checkParam, &scheduleInfo.scheduleId); 327 if (ret != RESULT_SUCCESS) { 328 IAM_LOGE("Failed to check permission"); 329 GlobalUnLock(); 330 return ret; 331 } 332 ret = GetCoAuthSchedule(&scheduleInfo); 333 if (ret != RESULT_SUCCESS) { 334 IAM_LOGE("Failed to get schedule info"); 335 GlobalUnLock(); 336 return ret; 337 } 338 if (!CopyScheduleInfo(&scheduleInfo, &info)) { 339 IAM_LOGE("Failed to copy schedule info"); 340 ret = RESULT_BAD_COPY; 341 } 342 GlobalUnLock(); 343 return ret; 344 } 345 346 // 取消录入接口实现 347 int32_t UserAuthInterfaceService::CancelEnrollment(int32_t userId) 348 { 349 IAM_LOGI("start"); 350 BreakOffCoauthSchedule(userId); 351 return RESULT_SUCCESS; 352 } 353 354 // 录入凭据信息存储接口实现 355 int32_t UserAuthInterfaceService::UpdateEnrollmentResult(int32_t userId, const std::vector<uint8_t>& scheduleResult, 356 uint64_t& credentialId, CredentialInfo& oldInfo) 357 { 358 IAM_LOGI("start"); 359 GlobalLock(); 360 if (scheduleResult.size() == 0) { 361 IAM_LOGE("enrollToken is invalid"); 362 GlobalUnLock(); 363 return RESULT_BAD_PARAM; 364 } 365 Buffer *scheduleResultBuffer = CreateBufferByData(&scheduleResult[0], scheduleResult.size()); 366 if (scheduleResultBuffer == nullptr) { 367 IAM_LOGE("scheduleTokenBuffer is null"); 368 GlobalUnLock(); 369 return RESULT_NO_MEMORY; 370 } 371 bool isUpdate; 372 int32_t ret = GetIsUpdate(&isUpdate); 373 if (ret != RESULT_SUCCESS) { 374 IAM_LOGE("Failed to get isUpdate"); 375 return ret; 376 } 377 if (isUpdate) { 378 CredentialInfoHal oldCredentialHal; 379 ret = UpdateCredentialFunc(scheduleResultBuffer, &credentialId, &oldCredentialHal); 380 oldInfo.authType = static_cast<AuthType>(oldCredentialHal.authType); 381 oldInfo.credentialId = oldCredentialHal.credentialId; 382 oldInfo.templateId = oldCredentialHal.templateId; 383 oldInfo.executorType = static_cast<uint32_t>(oldCredentialHal.authSubType); 384 oldInfo.executorId = 0; 385 oldInfo.index = 0; 386 } else { 387 ret = AddCredentialFunc(scheduleResultBuffer, &credentialId); 388 } 389 DestoryBuffer(scheduleResultBuffer); 390 GlobalUnLock(); 391 return ret; 392 } 393 ``` 394 3954. 认证接口举例实现，详细代码参见[user_auth_interface_service.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/user_auth/hdi_service/service/user_auth_interface_service.cpp)文件。 396 397 ```c++ 398 // 创建HDI服务对象 399 extern "C" IUserAuthInterface *UserAuthInterfaceImplGetInstance(void) 400 { 401 auto userAuthInterfaceService = new (std::nothrow) UserAuthInterfaceService(); 402 if (userAuthInterfaceService == nullptr) { 403 IAM_LOGE("userAuthInterfaceService is nullptr"); 404 return nullptr; 405 } 406 return userAuthInterfaceService; 407 } 408 409 // 发起认证，生成认证方案和调度信息 410 int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const AuthSolution& param, 411 std::vector<ScheduleInfo>& infos) 412 { 413 IAM_LOGI("start"); 414 if (param.challenge.size() != sizeof(uint64_t)) { 415 IAM_LOGE("Failed to copy challenge"); 416 return RESULT_BAD_PARAM; 417 } 418 GlobalLock(); 419 CoAuthSchedule *schedulesGet = nullptr; 420 uint32_t scheduleIdNum = 0; 421 AuthSolutionHal solutionIn; 422 solutionIn.contextId = contextId; 423 solutionIn.userId = param.userId; 424 solutionIn.authType = static_cast<uint32_t>(param.authType); 425 solutionIn.authTrustLevel = param.authTrustLevel; 426 if (memcpy_s(&solutionIn.challenge, sizeof(uint64_t), ¶m.challenge[0], 427 param.challenge.size()) != EOK) { 428 IAM_LOGE("Failed to copy challenge"); 429 GlobalUnLock(); 430 return RESULT_BAD_COPY; 431 } 432 int32_t ret = GenerateSolutionFunc(solutionIn, &schedulesGet, &scheduleIdNum); 433 if (ret != RESULT_SUCCESS) { 434 IAM_LOGE("Failed to generate solution"); 435 GlobalUnLock(); 436 return ret; 437 } 438 for (uint32_t i = 0; i < scheduleIdNum; i++) { 439 ScheduleInfo temp; 440 if (!CopyScheduleInfo(schedulesGet + i, &temp)) { 441 infos.clear(); 442 ret = RESULT_GENERAL_ERROR; 443 break; 444 } 445 infos.push_back(temp); 446 } 447 free(schedulesGet); 448 GlobalUnLock(); 449 return ret; 450 } 451 452 // 更新认证结果，进行此次认证方案结果的评估 453 int32_t UserAuthInterfaceService::UpdateAuthenticationResult(uint64_t contextId, 454 const std::vector<uint8_t>& scheduleResult, AuthResultInfo& info) 455 { 456 IAM_LOGI("start"); 457 GlobalLock(); 458 if (scheduleResult.size() == 0) { 459 IAM_LOGE("param is invalid"); 460 info.result = RESULT_BAD_PARAM; 461 GlobalUnLock(); 462 return RESULT_BAD_PARAM; 463 } 464 Buffer *scheduleResultBuffer = CreateBufferByData(&scheduleResult[0], scheduleResult.size()); 465 if (scheduleResultBuffer == nullptr) { 466 IAM_LOGE("scheduleTokenBuffer is null"); 467 info.result = RESULT_GENERAL_ERROR; 468 GlobalUnLock(); 469 return RESULT_NO_MEMORY; 470 } 471 UserAuthTokenHal authTokenHal; 472 info.result = RequestAuthResultFunc(contextId, scheduleResultBuffer, &authTokenHal); 473 if (info.result != RESULT_SUCCESS) { 474 IAM_LOGE("Failed to execute func"); 475 DestoryBuffer(scheduleResultBuffer); 476 GlobalUnLock(); 477 return info.result; 478 } 479 info.token.resize(sizeof(UserAuthTokenHal)); 480 if (memcpy_s(&info.token[0], info.token.size(), &authTokenHal, sizeof(authTokenHal)) != EOK) { 481 IAM_LOGE("Failed to copy authToken"); 482 DestoryBuffer(scheduleResultBuffer); 483 GlobalUnLock(); 484 return RESULT_BAD_COPY; 485 } 486 DestoryBuffer(scheduleResultBuffer); 487 GlobalUnLock(); 488 return RESULT_SUCCESS; 489 } 490 491 // 取消认证 492 int32_t UserAuthInterfaceService::CancelAuthentication(uint64_t contextId) 493 { 494 IAM_LOGI("start"); 495 GlobalLock(); 496 uint32_t scheduleIdNum = 0; 497 int32_t ret = CancelContextFunc(contextId, nullptr, &scheduleIdNum); 498 if (ret != RESULT_SUCCESS) { 499 IAM_LOGE("Failed to execute func"); 500 GlobalUnLock(); 501 return ret; 502 } 503 GlobalUnLock(); 504 return RESULT_SUCCESS; 505 } 506 ``` 507 508### 调测验证 509 510驱动开发完成后，通过[用户认证API接口](../../application-dev/reference/apis/js-apis-useriam-userauth.md)开发JS应用，基于Hi3516DV300平台验证。认证和取消功能验证的JS测试代码如下： 511 512 ```js 513 // API version 9 514 import userIAM_userAuth from '@ohos.userIAM.userAuth'; 515 516 let challenge = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); 517 let authType = userIAM_userAuth.UserAuthType.FACE; 518 let authTrustLevel = userIAM_userAuth.AuthTrustLevel.ATL1; 519 520 // 获取认证对象 521 let auth; 522 try { 523 auth = userIAM_userAuth.getAuthInstance(challenge, authType, authTrustLevel); 524 console.log("get auth instance success"); 525 } catch (error) { 526 console.log("get auth instance failed" + error); 527 } 528 529 // 订阅认证结果 530 try { 531 auth.on("result", { 532 callback: (result: userIAM_userAuth.AuthResultInfo) => { 533 console.log("authV9 result " + result.result); 534 console.log("authV9 token " + result.token); 535 console.log("authV9 remainAttempts " + result.remainAttempts); 536 console.log("authV9 lockoutDuration " + result.lockoutDuration); 537 } 538 }); 539 console.log("subscribe authentication event success"); 540 } catch (error) { 541 console.log("subscribe authentication event failed " + error); 542 } 543 544 // 开始认证 545 try { 546 auth.start(); 547 console.info("authV9 start auth success"); 548 } catch (error) { 549 console.info("authV9 start auth failed, error = " + error); 550 } 551 552 // 取消认证 553 try { 554 auth.cancel(); 555 console.info("cancel auth success"); 556 } catch (error) { 557 console.info("cancel auth failed, error = " + error); 558 } 559 560 // 取消订阅认证结果 561 try { 562 auth.off("result"); 563 console.info("cancel subscribe authentication event success"); 564 } catch (error) { 565 console.info("cancel subscribe authentication event failed, error = " + error); 566 } 567 ``` 568