1# Fingerprint_auth 2 3## 概述 4 5### 功能简介 6 7指纹认证是端侧设备不可或缺的功能，为设备提供用户认证能力，可应用于设备解锁、支付、应用登录等身份认证场景。用户注册指纹后，指纹认证模块就可为设备提供指纹认证的功能。指纹认证功能整体框架如图1。 8 9基于HDF（Hardware Driver Foundation）驱动框架开发的Fingerprint_auth驱动，能够屏蔽硬件器件差异，为上层用户认证框架和Fingerprint_auth服务提供稳定的指纹认证基础能力接口，包括指纹认证执行器列表查询、执行器信息查询、指定指纹模板ID查询模板信息、用户认证框架和执行器间的指纹模板信息对账、指纹的录入、删除、认证和识别等。 10 11**图1** 指纹认证功能整体框架 12 13 14 15### 基本概念 16 17用户认证框架与各基础认证服务组成的身份认证系统支持用户认证凭据设置、删除、认证等基础功能。系统支持用户身份认证，需要提供数据采集、处理、存储及比对能力。 18- 执行器 19 20 执行器是能够提供以上能力的处理模块，各基础认证服务提供执行器能力，被身份认证框架调度完成各项基础能力。 21 22- 执行器安全等级 23 24 执行器提供能力时所在运行环境达到的安全级别。 25 26- 执行器角色 27 28 - 全功能执行器：执行器可独立处理一次凭据注册和身份认证请求，即可提供用户认证数据采集、处理、储存及比对能力。 29 30 - 采集器：执行器提供用户认证时的数据采集能力，需要和认证器配合完成用户认证。 31 32 - 认证器：认证器提供用户认证时数据处理能力，读取存储的凭据模板与当前认证信息完成比对。 33 34- 执行器类型 35 36 同一种身份认证类型的不同认证方式会产生认证算法差异，设备器件差异也会导致算法差异，执行器根据支持的算法类型差异或对接的器件差异，会定义不同的执行器类型。 37 38- 用户认证框架公钥 & 执行器公钥 39 40 用户身份认证处理需要保证用户数据安全以及认证结果的准确性，用户认证框架与基础认证服务间的关键交互信息需要做数据完整性保护，各基础认证服务将提供的执行器能力对接到用户认证框架时，需要交换各自的公钥，其中： 41 42 1）执行器通过用户认证框架公钥校验调度指令的准确性。 43 44 2）执行器公钥可被用户认证框架用于校验认证结果的准确性，同时用于执行器交互认证时的校验交互信息的完整性。 45 46- 认证凭据 47 48 在用户设置认证凭据时认证服务会产生并存储认证凭据，每个模板有一个ID，用于索引模板信息文件，在认证时读取模板信息并用于与当次认证过程中产生的认证数据做对比，完成身份认证。 49 50- 执行器对账 51 52 用户认证框架统一管理用户身份和凭据ID的映射关系，执行器对接到用户认证框架时，会读取用户身份认证框架内保存的该执行器的模板ID列表，执行器需要与自己维护的模板ID列表进行比对，并删除冗余信息。 53 54- HAPs 55 56 HAPs（OpenHarmony Ability Packages），广义上指可以安装在OpenHarmony上的应用包，本章节中仅代表Fingerprint_auth驱动的上层应用。 57 58- IDL接口 59 60 接口定义语言（Interface Definition Language）通过IDL编译器编译后，能够生成与编程语言相关的文件：客户端桩文件，服务器框架文件。本文主要是通过IDL接口生成的客户端和服务端来实现Fingerprint_auth服务和驱动的通信，详细使用方法可参考[IDL简介](https://gitee.com/openharmony/ability_idl_tool/blob/master/README.md)。 61 62- IPC通信 63 64 IPC（Inter Process Communication），进程间通信是指两个进程的数据之间产生交互，详细原理可参考[IPC通信简介](https://gitee.com/openharmony/communication_ipc/blob/master/README_zh.md)。 65 66- HDI 67 68 HDI（Hardware Device Interface），硬件设备接口，位于基础系统服务层和设备驱动层之间，是提供给硬件系统服务开发者使用的、统一的硬件设备功能抽象接口，其目的是为系统服务屏蔽底层硬件设备差异，具体可参考[HDI规范](../../design/hdi-design-specifications.md)。 69 70### 运作机制 71 72Fingerprint_auth驱动的主要工作是为上层用户认证框架和Fingerprint_auth服务提供稳定的指纹认证基础能力，保证设备上指纹认证功能可以正常运行。如图2，Fingerprint_auth服务通过执行器列表接口获取执行器信息后，向用户认证框架注册执行器。Fingerprint_auth服务通过执行器功能接口实现和Fingerprint_auth驱动的认证、识别、查询等功能的信息交互。 73开发者可基于HDF框架对不同芯片进行各自驱动的开发及HDI层接口的调用。 74 75**图2** Fingerprint_auth服务和Fingerprint_auth驱动交互 76 77 78 79### 约束与限制 80 81要求设备上具有可信执行环境TEE（Trusted Execution Environment），指纹特征信息高强度加密保存在可信执行环境中。 82 83## 开发指导 84 85### 场景介绍 86 87Fingerprint_auth驱动的主要工作是为上层用户认证框架和Fingerprint_auth服务提供稳定的指纹认证基础能力，保证设备上指纹认证功能可以正常运行。为实现上述场景的功能，开发者首先需要基于HDF驱动框架，完成Fingerprint_auth驱动开发，其次实现获取执行器列表接口和认证、识别查询等功能接口。 88 89### 接口说明 90 91注：以下接口列举的为IDL接口描述生成的对应C++语言函数接口，接口声明见idl文件（/drivers/interface/fingerprint_auth/v1_0/）。 92在本文中，指纹凭据的录入、认证、识别和删除相关的HDI接口如表1所示，表2中的回调函数分别用于指纹执行器返回操作结果给框架和返回操作过程中的提示信息给上层应用。 93 94**表1** 接口功能介绍 95 96| 接口名称 | 功能介绍 | 97| -------------------------------- | ----------------------------------- | 98| GetExecutorList(std::vector<sptr<IExecutor>>& executorList) | 获取执行器列表。 | 99| GetExecutorInfo(ExecutorInfo& info) | 获取执行器信息，包括执行器类型、执行器角色、认证类型、安全等级、执行器公钥等信息，用于向用户认证框架注册执行器。 | 100| GetTemplateInfo(uint64_t templateId, TemplateInfo& info) | 获取指定模板ID的模板信息。 | 101| OnRegisterFinish(const std::vector<uint64_t>& templateIdList,<br/> const std::vector<uint8_t>& frameworkPublicKey, const std::vector<uint8_t>& extraInfo) | 执行器注册成功后，获取用户认证框架的公钥信息；获取用户认证框架的模板列表用于对账。 | 102| Enroll(uint64_t scheduleId, const std::vector<uint8_t>& extraInfo,<br/> const sptr<IExecutorCallback>& callbackObj) | 录入指纹模板。 | 103| Authenticate(uint64_t scheduleId, const std::vector<uint64_t>& templateIdList,<br/> const std::vector<uint8_t>& extraInfo, const sptr<IExecutorCallback>& callbackObj) | 认证指纹模板。 | 104| Identify(uint64_t scheduleId, const std::vector<uint8_t>& extraInfo,<br/> const sptr<IExecutorCallback>& callbackObj) | 识别指纹模板。 | 105| Delete(const std::vector<uint64_t>& templateIdList) | 删除指纹模板。 | 106| Cancel(uint64_t scheduleId) | 通过scheduleId取消指定录入、认证、识别操作。 | 107| SendCommand(int32_t commandId, const std::vector<uint8_t>& extraInfo,<br/> const sptr<IExecutorCallback>& callbackObj) | 指纹认证服务向Fingerprint_auth驱动传递参数的通用接口。 | 108 109**表2** 回调函数介绍 110 111| 接口名称 | 功能介绍 | 112| ------------------------------------------------------------ | ------------------------ | 113| IExecutorCallback::OnResult(int32_t code, const std::vector<uint8_t>& extraInfo) | 返回操作的最终结果。 | 114| IExecutorCallback::OnTip(int32_t code, const std::vector<uint8_t>& extraInfo) | 返回操作的过程交互信息。 | 115 116### 开发步骤 117 118以Hi3516DV300平台为例，我们提供了Fingerprint_auth驱动DEMO实例，以下是目录结构及各部分功能简介。 119 120```undefined 121// drivers/peripheral/fingerprint_auth 122├── BUILD.gn # 编译脚本 123├── bundle.json # 组件描述文件 124└── hdi_service # Fingerprint_auth驱动实现 125 ├── BUILD.gn # 编译脚本 126 ├── include # 头文件 127 └── src # 源文件 128 ├── executor_impl.cpp # 认证、录入等功能接口实现 129 ├── fingerprint_auth_interface_driver.cpp # Fingerprint_auth驱动入口 130 └── fingerprint_auth_interface_service.cpp # 获取执行器列表接口实现 131``` 132 133下面结合DEMO实例介绍驱动开发的具体步骤。 134 1351. Fingerprint_auth驱动是基于HDF驱动框架设计，所以开发者需要按照驱动Driver Entry程序，完成Fingerprint_auth驱动框架开发，主要由Bind、Init、Release、Dispatch函数接口实现。关键代码如下，详细代码请参见[fingerprint_auth_interface_driver.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_driver.cpp)文件。 136 137 ```c++ 138 // 通过自定义的HdfFingerprintAuthInterfaceHost对象包含ioService对象和真正的HDI Service实现IRemoteObject对象 139 struct HdfFingerprintAuthInterfaceHost { 140 struct IDeviceIoService ioService; 141 OHOS::sptr<OHOS::IRemoteObject> stub; 142 }; 143 144 // 服务接口调用响应接口 145 static int32_t FingerprintAuthInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, 146 struct HdfSBuf *reply) 147 { 148 IAM_LOGI("start"); 149 auto *hdfFingerprintAuthInterfaceHost = CONTAINER_OF(client->device->service, 150 struct HdfFingerprintAuthInterfaceHost, ioService); 151 152 OHOS::MessageParcel *dataParcel = nullptr; 153 OHOS::MessageParcel *replyParcel = nullptr; 154 OHOS::MessageOption option; 155 156 if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) { 157 IAM_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__); 158 return HDF_ERR_INVALID_PARAM; 159 } 160 if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) { 161 IAM_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__); 162 return HDF_ERR_INVALID_PARAM; 163 } 164 165 return hdfFingerprintAuthInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); 166 } 167 168 // 初始化接口 169 int HdfFingerprintAuthInterfaceDriverInit(struct HdfDeviceObject *deviceObject) 170 { 171 IAM_LOGI("start"); 172 if (!HdfDeviceSetClass(deviceObject, DEVICE_CLASS_USERAUTH)) { 173 IAM_LOGE("set fingerprint auth hdf class failed"); 174 return HDF_FAILURE; 175 } 176 return HDF_SUCCESS; 177 } 178 179 // Fingerprint_auth驱动对外提供的服务绑定到HDF框架 180 int HdfFingerprintAuthInterfaceDriverBind(struct HdfDeviceObject *deviceObject) 181 { 182 IAM_LOGI("start"); 183 auto *hdfFingerprintAuthInterfaceHost = new (std::nothrow) HdfFingerprintAuthInterfaceHost; 184 if (hdfFingerprintAuthInterfaceHost == nullptr) { 185 IAM_LOGE("%{public}s: failed to create HdfFaceAuthInterfaceHost object", __func__); 186 return HDF_FAILURE; 187 } 188 189 hdfFingerprintAuthInterfaceHost->ioService.Dispatch = FingerprintAuthInterfaceDriverDispatch; 190 hdfFingerprintAuthInterfaceHost->ioService.Open = NULL; 191 hdfFingerprintAuthInterfaceHost->ioService.Release = NULL; 192 193 auto serviceImpl = IFingerprintAuthInterface::Get(true); 194 if (serviceImpl == nullptr) { 195 IAM_LOGE("%{public}s: failed to implement service", __func__); 196 return HDF_FAILURE; 197 } 198 199 hdfFingerprintAuthInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, 200 IFaceAuthInterface::GetDescriptor()); 201 if (hdfFingerprintAuthInterfaceHost->stub == nullptr) { 202 IAM_LOGE("%{public}s: failed to get stub object", __func__); 203 return HDF_FAILURE; 204 } 205 206 deviceObject->service = &hdfFingerprintAuthInterfaceHost->ioService; 207 IAM_LOGI("success"); 208 return HDF_SUCCESS; 209 } 210 211 // 释放Fingerprint_auth驱动中的资源 212 void HdfFingerprintAuthInterfaceDriverRelease(struct HdfDeviceObject *deviceObject) 213 { 214 IAM_LOGI("start"); 215 auto *hdfFingerprintAuthInterfaceHost = CONTAINER_OF(deviceObject->service, 216 struct HdfFaceAuthInterfaceHost, ioService); 217 delete hdfFaceAuthInterfaceHost; 218 IAM_LOGI("success"); 219 } 220 221 // 注册Fingerprint_auth驱动入口数据结构体对象 222 struct HdfDriverEntry g_fingerprintAuthInterfaceDriverEntry = { 223 .moduleVersion = 1, 224 .moduleName = "fingerprint_auth_interface_service", 225 .Bind = HdfFingerprintAuthInterfaceDriverBind, 226 .Init = HdfFingerprintAuthInterfaceDriverInit, 227 .Release = HdfFingerprintAuthInterfaceDriverRelease, 228 }; 229 230 // 调用HDF_INIT将驱动入口注册到HDF框架中。在加载驱动时HDF框架会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 231 HDF_INIT(g_fingerprintAuthInterfaceDriverEntry); 232 ``` 233 2342. Fingerprint_auth驱动框架开发完成后，Fingerprint_auth驱动需要向Fingerprint_auth服务和统一身份认证注册执行器，所以需要实现获取执行器列表接口。关键代码如下，详细代码请参见[fingerprint_auth_interface_service.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/fingerprint_auth/hdi_service/src/fingerprint_auth_interface_service.cpp)文件。 235 236 ```c++ 237 // 执行器实现类 238 class ExecutorImpl : public IExecutor { 239 public: 240 ExecutorImpl(struct ExecutorInfo executorInfo); 241 virtual ~ExecutorImpl() {} 242 243 private: 244 struct ExecutorInfo executorInfo_; // 执行器信息 245 }; 246 247 static constexpr uint16_t SENSOR_ID = 123; // 执行器sensorID 248 static constexpr uint32_t EXECUTOR_TYPE = 123; // 执行器类型 249 static constexpr size_t PUBLIC_KEY_LEN = 32; // 执行器32字节公钥 250 251 // 创建HDI服务对象 252 extern "C" IFaceAuthInterface *FingerprintAuthInterfaceImplGetInstance(void) 253 { 254 auto fingerprintAuthInterfaceService = new (std::nothrow) FingerprintAuthInterfaceService(); 255 if (fingerprintAuthInterfaceService == nullptr) { 256 IAM_LOGE("faceAuthInterfaceService is nullptr"); 257 return nullptr; 258 } 259 return fingerprintAuthInterfaceService; 260 } 261 262 // 获取执行器列表实现，创建执行器 263 int32_t GetExecutorList(std::vector<sptr<IExecutor>>& executorList) 264 { 265 IAM_LOGI("interface mock start"); 266 executorList.clear(); 267 struct ExecutorInfo executorInfoExample = { 268 .sensorId = SENSOR_ID, 269 .executorType = EXECUTOR_TYPE, 270 .executorRole = ExecutorRole::ALL_IN_ONE, 271 .authType = AuthType::FINGERPRINT, 272 .esl = ExecutorSecureLevel::ESL0, // ExecutorSecureLevel标识执行器的安全等级，范围是ESL0~ESL3，其中ESL3标识的安全等级最高 273 .publicKey = std::vector<uint8_t>(PUBLIC_KEY_LEN, 0), // 32字节公钥，算法是Ed25519 274 .extraInfo = {}, 275 }; 276 auto executor = new (std::nothrow) ExecutorImpl(executorInfoExample); 277 if (executor == nullptr) { 278 IAM_LOGE("executor is nullptr"); 279 return HDF_FAILURE; 280 } 281 executorList.push_back(sptr<IExecutor>(executor)); 282 IAM_LOGI("interface mock success"); 283 return HDF_SUCCESS; 284 } 285 ``` 286 2873. 步骤1、2完成后基本实现了Fingerprint_auth驱动和Fingerprint_auth服务对接。接下来需实现执行器每个功能接口，来完成指纹认证基础能力。关键代码如下，详细代码请参见[executor_impl.cpp](https://gitee.com/openharmony/drivers_peripheral/blob/master/fingerprint_auth/hdi_service/src/executor_impl.cpp)文件。 288 289 ```c++ 290 // 实现获取执行器信息接口 291 int32_t GetExecutorInfo(ExecutorInfo& info) 292 { 293 IAM_LOGI("interface mock start"); 294 info = executorInfo_; 295 IAM_LOGI("get executor information success"); 296 return HDF_SUCCESS; 297 } 298 299 // 实现获取指定模板ID的模板信息接口 300 int32_t GetTemplateInfo(uint64_t templateId, TemplateInfo& info) 301 { 302 IAM_LOGI("interface mock start"); 303 static_cast<void>(templateId); 304 info = {0}; 305 IAM_LOGI("get template information success"); 306 return HDF_SUCCESS; 307 } 308 309 // 实现执行器注册成功后，获取用户认证框架的公钥信息、获取用户认证框架的模板列表接口。将公钥信息保持，模板列表用于和本地的模板做对账 310 int32_t OnRegisterFinish(const std::vector<uint64_t>& templateIdList, 311 const std::vector<uint8_t>& frameworkPublicKey, const std::vector<uint8_t>& extraInfo) 312 { 313 IAM_LOGI("interface mock start"); 314 static_cast<void>(templateIdList); 315 static_cast<void>(extraInfo); 316 static_cast<void>(frameworkPublicKey); 317 IAM_LOGI("register finish"); 318 return HDF_SUCCESS; 319 } 320 321 // 实现指纹录入接口 322 int32_t Enroll(uint64_t scheduleId, const std::vector<uint8_t>& extraInfo, 323 const sptr<IExecutorCallback>& callbackObj) 324 { 325 IAM_LOGI("interface mock start"); 326 static_cast<void>(scheduleId); 327 static_cast<void>(extraInfo); 328 IAM_LOGI("enroll, result is %{public}d", ResultCode::OPERATION_NOT_SUPPORT); 329 int32_t ret = callbackObj->OnResult(ResultCode::OPERATION_NOT_SUPPORT, {}); 330 if (ret != ResultCode::SUCCESS) { 331 IAM_LOGE("callback result is %{public}d", ret); 332 return HDF_FAILURE; 333 } 334 return HDF_SUCCESS; 335 } 336 337 // 实现指纹认证接口 338 int32_t Authenticate(uint64_t scheduleId, const std::vector<uint64_t>& templateIdList, 339 const std::vector<uint8_t>& extraInfo, const sptr<IExecutorCallback>& callbackObj) 340 { 341 IAM_LOGI("interface mock start"); 342 static_cast<void>(scheduleId); 343 static_cast<void>(templateIdList); 344 static_cast<void>(extraInfo); 345 IAM_LOGI("authenticate, result is %{public}d", ResultCode::NOT_ENROLLED); 346 int32_t ret = callbackObj->OnResult(ResultCode::NOT_ENROLLED, {}); 347 if (ret != ResultCode::SUCCESS) { 348 IAM_LOGE("callback result is %{public}d", ret); 349 return HDF_FAILURE; 350 } 351 return HDF_SUCCESS; 352 } 353 354 // 实现指纹识别接口 355 int32_t Identify(uint64_t scheduleId, const std::vector<uint8_t>& extraInfo, 356 const sptr<IExecutorCallback>& callbackObj) 357 { 358 IAM_LOGI("interface mock start"); 359 static_cast<void>(scheduleId); 360 static_cast<void>(extraInfo); 361 IAM_LOGI("identify, result is %{public}d", ResultCode::OPERATION_NOT_SUPPORT); 362 int32_t ret = callbackObj->OnResult(ResultCode::OPERATION_NOT_SUPPORT, {}); 363 if (ret != ResultCode::SUCCESS) { 364 IAM_LOGE("callback result is %{public}d", ret); 365 return HDF_FAILURE; 366 } 367 return HDF_SUCCESS; 368 } 369 370 // 实现删除指纹模板接口 371 int32_t Delete(const std::vector<uint64_t>& templateIdList) 372 { 373 IAM_LOGI("interface mock start"); 374 static_cast<void>(templateIdList); 375 IAM_LOGI("delete success"); 376 return HDF_SUCCESS; 377 } 378 379 // 实现通过scheduleId取消指定操作接口 380 int32_t Cancel(uint64_t scheduleId) 381 { 382 IAM_LOGI("interface mock start"); 383 static_cast<void>(scheduleId); 384 IAM_LOGI("cancel success"); 385 return HDF_SUCCESS; 386 } 387 388 // 实现指纹认证服务向Fingerprint_auth驱动传递参数的通用接口，当前需要实现冻结与解锁模板命令 389 int32_t SendCommand(int32_t commandId, const std::vector<uint8_t>& extraInfo, 390 const sptr<IExecutorCallback>& callbackObj) 391 { 392 IAM_LOGI("interface mock start"); 393 static_cast<void>(extraInfo); 394 int32_t ret; 395 switch (commandId) { 396 case LOCK_TEMPLATE: 397 IAM_LOGI("unlock template, result is %{public}d", ResultCode::SUCCESS); 398 ret = callbackObj->OnResult(ResultCode::SUCCESS, {}); 399 if (ret != ResultCode::SUCCESS) { 400 IAM_LOGE("callback result is %{public}d", ret); 401 return HDF_FAILURE; 402 } 403 break; 404 case UNLOCK_TEMPLATE: 405 IAM_LOGI("unlock template, result is %{public}d", ResultCode::SUCCESS); 406 ret = callbackObj->OnResult(ResultCode::SUCCESS, {}); 407 if (ret != ResultCode::SUCCESS) { 408 IAM_LOGE("callback result is %{public}d", ret); 409 return HDF_FAILURE; 410 } 411 break; 412 default: 413 IAM_LOGD("not support CommandId : %{public}d", commandId); 414 ret = callbackObj->OnResult(ResultCode::GENERAL_ERROR, {}); 415 if (ret != ResultCode::SUCCESS) { 416 IAM_LOGE("callback result is %{public}d", ret); 417 return HDF_FAILURE; 418 } 419 } 420 return HDF_SUCCESS; 421 } 422 ``` 423 4244. 用户身份认证框架支持多driver，当增加driver或者修改driver信息，需要修改如下文件中serviceName2Config。 425 426 ```c++ 427 // base/user_iam/fingerprint_auth/services/src/fingerprint_auth_service.cpp 428 void FingerprintAuthService::StartDriverManager() 429 { 430 IAM_LOGI("start"); 431 // 此处增加或修改driver服务名字和ID，driver服务名字和ID需要全局唯一 432 const std::map<std::string, UserAuth::ServiceConfig> serviceName2Config = { 433 {"fingerprint_auth_interface_service", {2, std::make_shared<FingerprintAuthDriverHdi>()}}, 434 }; 435 UserIAM::UserAuth::IDriverManager::GetInstance().Start(serviceName2Config); 436 } 437 ``` 438 439### 调测验证 440 441驱动开发完成后，开发者可以通过[用户认证API接口](../../application-dev/reference/apis/js-apis-useriam-userauth.md)开发JS应用，JS应用通过Fingerprint_auth服务调用Fingerprint_auth驱动，从而验证驱动开发是否符合预期。基于Hi3516DV300平台验证，认证功能验证的JS测试代码如下： 442 443 ```js 444 // API version 9 445 import userIAM_userAuth from '@ohos.userIAM.userAuth'; 446 447 let challenge = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); 448 let authType = userIAM_userAuth.UserAuthType.FINGERPRINT; 449 let authTrustLevel = userIAM_userAuth.AuthTrustLevel.ATL1; 450 451 // 获取认证对象 452 let auth; 453 try { 454 auth = userIAM_userAuth.getAuthInstance(challenge, authType, authTrustLevel); 455 console.log("get auth instance success"); 456 } catch (error) { 457 console.log("get auth instance failed" + error); 458 } 459 460 // 订阅认证结果 461 try { 462 auth.on("result", { 463 callback: (result: userIAM_userAuth.AuthResultInfo) => { 464 console.log("authV9 result " + result.result); 465 console.log("authV9 token " + result.token); 466 console.log("authV9 remainAttempts " + result.remainAttempts); 467 console.log("authV9 lockoutDuration " + result.lockoutDuration); 468 } 469 }); 470 console.log("subscribe authentication event success"); 471 } catch (error) { 472 console.log("subscribe authentication event failed " + error); 473 } 474 475 // 开始认证 476 try { 477 auth.start(); 478 console.info("authV9 start auth success"); 479 } catch (error) { 480 console.info("authV9 start auth failed, error = " + error); 481 } 482 483 // 取消认证 484 try { 485 auth.cancel(); 486 console.info("cancel auth success"); 487 } catch (error) { 488 console.info("cancel auth failed, error = " + error); 489 } 490 491 // 取消订阅认证结果 492 try { 493 auth.off("result"); 494 console.info("cancel subscribe authentication event success"); 495 } catch (error) { 496 console.info("cancel subscribe authentication event failed, error = " + error); 497 } 498 ``` 499