【入门到实战】OpenHarmony子系统外设驱动使用:User_auth

鸿蒙5.0【在OpenHarmony上使用SeetaFace2人脸识别库】 相信大部分同学们都已了解或接触过OpenAtom OpenHarmony(以下简称“OpenHarmony”)了,但你一定没在OpenHarmony上实现过人脸识别功能,跟着本文带你快速在OpenHarmony标准设备上基于SeetaFace2和OpenCV实现人脸识别。 阅读详情

往期鸿蒙5.0全套实战文章必看:(文中附带全栈鸿蒙5.0学习资料)


概述

功能简介

用户认证功能是端侧设备不可或缺的一部分,可应用于设备解锁、支付、应用登录等身份认证场景。用户认证(User_auth)框架统一管理用户身份与认证凭据模板的映射关系,通过调度各认证基础服务(包含口令认证、人脸识别等)实现的执行器完成用户认证凭据注册、凭据删除、身份认证及相关信息查询。用户认证的整体架构如图1。

基于HDF(Hardware Driver Foundation)驱动框架开发的User_auth驱动,能够屏蔽硬件器件差异,为上层应用(设置、锁屏等)和账号管理SA(System Ability)提供稳定的用户身份认证能力,支持用户凭据管理、认证信息录入、认证方案生成以及认证执行器信息管理能力。

图1 用户认证功能整体框架

image

基本概念

用户认证框架与各个基础认证服务(包含口令认证、人脸识别等)组成的身份认证系统,支持用户认证凭据设置、删除、认证等基础功能。

  • 认证凭据信息

    用户设置口令、录入人脸时,会生成认证凭据模板,凭据信息由用户身份信息与凭据模板信息组成,用于在认证用户时找到匹配指定用户的凭据模板。

  • 认证凭据模板

    认证凭据模板在用户设置认证凭据时由认证服务产生并存储。每个模板有一个ID,用于索引模板信息文件。在认证时,读取模板信息并和当次认证过程中产生的认证数据做对比,完成身份认证。

  • 执行器

    执行器是能够提供数据采集、处理、存储及比对能力的模块,各基础认证服务提供执行器能力,被身份认证框架调度完成各项基础功能。

  • 执行器角色

    • ​ 全功能执行器:执行器可独立处理凭据注册和身份认证请求,即可提供用户认证数据采集、处理、储存及比对能力。

    • ​ 采集器:执行器提供用户认证时的数据采集能力,需要和认证器配合完成用户认证。

    • ​ 认证器:认证器提供用户认证时的数据处理能力,读取存储凭据模板信息并完成比对。

  • 执行器类型

    同一种身份认证类型的不同认证方式、设备器件差异都会产生认证算法差异,执行器根据这些差异定义不同的执行器类型。

  • 执行器安全等级

    执行器提供能力时所在运行环境达到的安全级别。

  • 用户认证框架公钥 & 执行器公钥

    用户身份认证处理需要保证用户数据安全以及认证结果的准确性,用户认证框架与基础认证服务间的关键交互信息需要做数据完整性保护,各基础认证服务将提供的执行器能力对接到用户认证框架时,需要交换各自的公钥,其中:

    • 执行器通过用户认证框架公钥校验调度指令的准确性,如锁定一个人脸模板,这种情况导致无法使用人脸功能,属于敏感操作,需要确保指令准确,才可处理。

    • 执行器公钥可被用户认证框架用于校验认证结果的准确性,同时用于执行器交互认证时的校验交互信息的完整性。

  • 认证结果可信等级

    不同认证方式及认证过程运行环境的安全级别差异,使得生成的认证结果的可信级别不同。

  • 认证方案

    用户发起认证请求所使用的认证方式、认证结果可信等级、执行器信息和凭据信息等相关信息。

  • 调度信息

    包括执行器信息及执行器处理请求需要的凭据模板信息,用于用户认证框架调度执行器完成基础功能。

  • System Ability

    系统能力,由系统服务管理服务(System Ability Manager)加载,向OpenHarmony系统提供系统基础能力的基础服务。

  • Kit

    OpenHarmony系统向第三方应用提供的基础应用编程接口。

  • Inner API

    OpenHarmony系统向系统应用提供的应用编程接口。

  • IDL接口

    接口定义语言(Interface Definition Language),通过IDL编译器编译后,能够生成与编程语言相关的文件:客户端桩文件,服务器框架文件。本文主要是通过IDL接口生成的客户端和服务端来实现User_auth服务和驱动的通信。

  • IPC通信

    IPC(Inter Process Communication),进程间通信是指两个进程的数据之间产生交互。

  • HDI

    HDI(Hardware Device Interface),硬件设备接口,位于基础系统服务层和设备驱动层之间,是提供给硬件系统服务开发者使用的、统一的硬件设备功能抽象接口,其目的是为系统服务屏蔽底层硬件设备差异。

运作机制

User_auth驱动主要工作是屏蔽不同安全器件和安全环境的差异,通过统一的认证能力注册、录入、认证接口,向User_auth服务提供认证执行器管理、认证凭据管理和认证方案生成管理等能力。 开发者可基于HDF框架对不同芯片进行各自驱动的开发及HDI层接口的调用。

图2 User_auth服务和User_auth驱动交互

image

约束与限制

User_auth驱动的实现需要在可信执行环境中实现,保证用户凭据信息的安全存储及用户身份认证结果的可信可靠。

开发指导

场景介绍

User_auth驱动的主要工作是为User_auth服务提供稳定的用户凭据管理、认证会话管理以及执行器信息管理能力,保证设备上口令认证和生物识别功能可以正常运行。

接口说明

注:以下接口列举的为IDL接口描述生成的对应C++语言函数接口,接口声明见idl文件(/drivers/interface/user_auth)。 在本文中,执行器注册、凭据录入、凭据删除、用户认证和用户识别相关的HDI接口如表1所示。

表1 接口功能介绍

接口名称功能介绍
Init()初始化缓存信息。
AddExecutor(const HdiExecutorRegisterInfo &info, uint64_t &index, std::vector<uint8_t> &publicKey, std::vector<uint64_t> &templateIds)添加认证执行器,获得此认证能力。
DeleteExecutor(uint64_t index)根据索引值index删除认证执行器。
OpenSession(int32_t userId, std::vector<uint8_t> &challenge)开启认证凭据管理Session。
CloseSession(int32_t userId)关闭认证凭据管理Session。
BeginEnrollment(const std::vector<uint8_t> &authToken, const HdiEnrollParam &param, HdiScheduleInfo &info)发起用户的认证凭据的录入,当录入类型为PIN码且当前用户已录入PIN码的情况下会更新PIN码。
UpdateEnrollmentResult(int32_t userId, const std::vector<uint8_t> & scheduleResult, EnrollResultInfo &info)更新录入结果,完成此次录入。
CancelEnrollment(int32_t userId)取消此次录入。
DeleteCredential(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, CredentialInfo &info)根据credentialId删除凭据信息。
DeleteUser(int32_t userId, const std::vector<uint8_t> &authToken, std::vector &deletedInfos, std::vector<uint8_t> &rootSecret)删除PIN码即在用户认证框架中删除用户。
EnforceDeleteUser(int32_t userId, std::vector &deletedInfos)强制删除用户,当系统内此用户被删除时强制调用。
GetCredential(int32_t userId, int32_t authType, std::vector &infos)查询用户某种认证类型下的凭据信息。
BeginAuthentication(uint64_t contextId, const HdiAuthParam &param, std::vector &infos)发起认证,生成认证方案和调度信息。
UpdateAuthenticationResult(uint64_t contextId, const std::vector<uint8_t> & scheduleResult, HdiAuthResultInfo &info, HdiEnrolledState &enrolledState)更新认证结果,进行此次认证方案结果的评估。
CancelAuthentication(uint64_t contextId)取消此次认证。
BeginIdentification(uint64_t contextId, int32_t authType, const std::vector<uint8_t> &challenge, uint32_t executorSensorHint, HdiScheduleInfo &scheduleInfo)发起识别,生成识别方案和调度信息。
UpdateIdentificationResult(uint64_t contextId, const std::vector<uint8_t> &scheduleResult, IdentifyResultInfo &info)更新识别结果,进行此次识别方案结果的评估。
CancelIdentification(uint64_t contextId)取消此次识别。
GetAuthTrustLevel(int32_t userId, int32_t authType, uint32_t &authTrustLevel)获取此用户当前认证类型的认证可信等级。
GetValidSolution(int32_t userId, const std::vector<int32_t> &authTypes, uint32_t authTrustLevel, std::vector<int32_t> &validTypes)筛选此用户当前认证可信等级下可用的认证方式。
GetAllUserInfo(std::vector &userInfos)查询所有用户信息(不包含userId)。
GetUserInfo(int32_t userId, uint64_t &secureUid, int32_t &pinSubType, std::vector &infos)查询用户信息。
GetAllExtUserInfo(std::vector &userInfos)查询所有用户信息(包含userId)。
GetEnrolledState(int32_t userId, int32_t authType, HdiEnrolledState &enrolledState)查询录入信息。
CheckReuseUnlockResult(const ReuseUnlockParam& param, ReuseUnlockInfo& info)检查是否复用设备解锁结果。
SendMessage(uint64_t scheduleId, int32_t srcRole, const std::vector<uint8_t>& msg)向执行器发消息。
RegisterMessageCallback(const sptr& messageCallback)注册执行器消息回调。
GetLocalScheduleFromMessage(const std::vector<uint8_t>& remoteDeviceId, const std::vector<uint8_t>& message, HdiScheduleInfo& scheduleInfo)获取本地执行器调度信息。
GetSignedExecutorInfo(const std::vector<int32_t>& authTypes, int32_t executorRole, const std::vector<uint8_t>& remoteDeviceId, std::vector<uint8_t>& signedExecutorInfo)获取签名后的执行器信息。

开发步骤

以Hi3516DV300平台为例,我们提供了User_auth驱动DEMO实例,以下是目录结构及各部分功能简介。

// drivers/peripheral/user_auth
├── BUILD.gn     # 编译脚本
├── bundle.json  # 组件描述文件
└── hdi_service  # User_auth驱动实现
    ├── BUILD.gn   # 编译脚本
    ├── module     # 功能实现
    └── service
        ├── user_auth_interface_driver.cpp   # User_auth驱动入口
        └── user_auth_interface_service.cpp  # 获取执行器列表接口实现

下面结合DEMO实例介绍驱动开发的具体步骤。

  1. 基于HDF驱动框架,按照驱动Driver Entry程序,完成User_auth驱动开发,主要由Bind、Init、Release、Dispatch函数接口实现,详细代码参见user_auth_interface_driver.cpp文件。

    // 通过自定义的HdfUserAuthInterfaceHost对象包含IoService对象和真正的HDI Service实现IRemoteObject对象
    struct HdfUserAuthInterfaceHost {
        struct IDeviceIoService ioService;
        OHOS::sptr<OHOS::IRemoteObject> stub;
    };
    
    // 服务接口调用响应接口
    static int32_t UserAuthInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
        struct HdfSBuf *reply)
    {
        auto *hdfUserAuthInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUserAuthInterfaceHost, ioService);
    
        OHOS::MessageParcel *dataParcel = nullptr;
        OHOS::MessageParcel *replyParcel = nullptr;
        OHOS::MessageOption option;
    
        if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {
            HDF_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__);
            return HDF_ERR_INVALID_PARAM;
        }
        if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) {
            HDF_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__);
            return HDF_ERR_INVALID_PARAM;
        }
    
        return hdfUserAuthInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option);
    }
    
    // 初始化接口
    int HdfUserAuthInterfaceDriverInit(struct HdfDeviceObject *deviceObject)
    {
        HDF_LOGI("HdfUserAuthInterfaceDriverInit enter");
        OHOS::UserIAM::Common::Init();
        return HDF_SUCCESS;
    }
    
    // User_auth驱动对外提供的服务绑定到HDF框架
    int HdfUserAuthInterfaceDriverBind(struct HdfDeviceObject *deviceObject)
    {
        HDF_LOGI("HdfUserAuthInterfaceDriverBind enter");
    
        auto *hdfUserAuthInterfaceHost = new (std::nothrow) HdfUserAuthInterfaceHost;
        if (hdfUserAuthInterfaceHost == nullptr) {
            HDF_LOGE("%{public}s: failed to create HdfUserAuthInterfaceHost object", __func__);
            return HDF_FAILURE;
        }
    
        hdfUserAuthInterfaceHost->ioService.Dispatch = UserAuthInterfaceDriverDispatch;
        hdfUserAuthInterfaceHost->ioService.Open = NULL;
        hdfUserAuthInterfaceHost->ioService.Release = NULL;
    
        auto serviceImpl = IUserAuthInterface::Get(true);
        if (serviceImpl == nullptr) {
            HDF_LOGE("%{public}s: failed to implement service", __func__);
            return HDF_FAILURE;
        }
    
        hdfUserAuthInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl,
            IUserAuthInterface::GetDescriptor());
        if (hdfUserAuthInterfaceHost->stub == nullptr) {
            HDF_LOGE("%{public}s: failed to get stub object", __func__);
            return HDF_FAILURE;
        }
    
        deviceObject->service = &hdfUserAuthInterfaceHost->ioService;
        return HDF_SUCCESS;
    }
    
    // 释放User_auth驱动中的资源
    void HdfUserAuthInterfaceDriverRelease(struct HdfDeviceObject *deviceObject){
        HDF_LOGI("HdfUserAuthInterfaceDriverRelease enter");
        auto *hdfUserAuthInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfUserAuthInterfaceHost, ioService);
        delete hdfUserAuthInterfaceHost;
    }
    
    // 注册User_auth驱动入口数据结构体对象
    struct HdfDriverEntry g_userAuthInterfaceDriverEntry = {
        .moduleVersion = 1,
        .moduleName = "user_auth_device_driver",
        .Bind = HdfUserAuthInterfaceDriverBind,
        .Init = HdfUserAuthInterfaceDriverInit,
        .Release = HdfUserAuthInterfaceDriverRelease,
    };
    
    // 调用HDF_INIT将驱动入口注册到HDF框架中,在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动,当Init调用异常时,HDF框架会调用Release释放驱动资源并退出
    #ifndef __cplusplus
    extern "C" {
    #endif
    HDF_INIT(g_userAuthInterfaceDriverEntry);
    #ifndef __cplusplus
    }
    #endif
    
  2. 执行器注册接口举例实现,详细代码参见user_auth_interface_service.cpp文件。

    // 添加执行器
    int32_t UserAuthInterfaceService::AddExecutor(const HdiExecutorRegisterInfo &info, uint64_t &index,
     std::vector<uint8_t> &publicKey, std::vector<uint64_t> &templateIds)
    {
        GlobalLock();
        ExecutorInfoHal executorInfoHal;
        CopyExecutorInfo(info, executorInfoHal);
        int32_t ret = RegisterExecutor(&executorInfoHal, &index);
        GlobalUnLock();
        return ret;
    }
    
    // 删除执行器
    int32_t UserAuthInterfaceService::DeleteExecutor(uint64_t index)
    {
        return UnRegisterExecutor(index);
    }
    
  3. 录入接口举例实现,详细代码参见user_auth_interface_service.cpp文件。

    // 开启认证凭据管理会话
    int32_t UserAuthInterfaceService::OpenSession(int32_t userId, std::vector<uint8_t>& challenge)
    {
        GlobalLock();
        uint64_t challengeU64 = 0;
        int32_t ret = OpenEditSession(userId, &challengeU64);
        challenge.resize(sizeof(uint64_t));
        if (memcpy_s(&challenge[0], challenge.size(), &challengeU64, sizeof(uint64_t)) != EOK) {
            IAM_LOGE("failed to copy challengeU64");
            return RESULT_BAD_COPY;
        }
        GlobalUnLock();
        return ret;
    }
    
    // 关闭认证凭据管理会话
    int32_t UserAuthInterfaceService::CloseSession(int32_t userId)
    {
        GlobalLock();
        int32_t ret = CloseEditSession();
        GlobalUnLock();
        return ret;
    }
    
    // 发起录入,生成录入调度信息
    int32_t UserAuthInterfaceService::BeginEnrollment(
     const std::vector<uint8_t> &authToken, const HdiEnrollParam &param, HdiScheduleInfo &info)
    {
        IAM_LOGI("start");
        GlobalLock();
        if (authToken.size() != sizeof(UserAuthTokenHal) && param.authType != PIN) {
            IAM_LOGE("authToken len is invalid");
            GlobalUnLock();
            return RESULT_BAD_PARAM;
        }
        PermissionCheckParam checkParam;
        if (authToken.size() == sizeof(UserAuthTokenHal) &&
            memcpy_s(checkParam.token, AUTH_TOKEN_LEN, &authToken[0], authToken.size()) != EOK) {
            GlobalUnLock();
            return RESULT_BAD_COPY;
        }
        checkParam.authType = param.authType;
        checkParam.userId = userId;
        checkParam.authSubType = (uint64_t)param.executorType;
        CoAuthSchedule scheduleInfo;
        int32_t ret = CheckEnrollPermission(checkParam, &scheduleInfo.scheduleId);
        if (ret != RESULT_SUCCESS) {
            IAM_LOGE("Failed to check permission");
            GlobalUnLock();
            return ret;
        }
        ret = GetCoAuthSchedule(&scheduleInfo);
        if (ret != RESULT_SUCCESS) {
            IAM_LOGE("Failed to get schedule info");
            GlobalUnLock();
            return ret;
        }
        if (!CopyScheduleInfo(&scheduleInfo, &info)) {
            IAM_LOGE("Failed to copy schedule info");
            ret = RESULT_BAD_COPY;
        }
        GlobalUnLock();
        return ret;
    }
    
    // 取消录入接口实现
    int32_t UserAuthInterfaceService::CancelEnrollment(int32_t userId)
    {
        IAM_LOGI("start");
        BreakOffCoauthSchedule(userId);
        return RESULT_SUCCESS;
    }
    
    // 录入凭据信息存储接口实现
    int32_t UserAuthInterfaceService::UpdateEnrollmentResult(int32_t userId, const std::vector<uint8_t> &scheduleResult, EnrollResultInfo &info)
    {
        IAM_LOGI("start");
        GlobalLock();
        if (scheduleResult.size() == 0) {
            IAM_LOGE("enrollToken is invalid");
            GlobalUnLock();
            return RESULT_BAD_PARAM;
        }
        Buffer *scheduleResultBuffer = CreateBufferByData(&scheduleResult[0], scheduleResult.size());
        if (scheduleResultBuffer == nullptr) {
            IAM_LOGE("scheduleTokenBuffer is null");
            GlobalUnLock();
            return RESULT_NO_MEMORY;
        }
        bool isUpdate;
        int32_t ret = GetIsUpdate(&isUpdate);
        if (ret != RESULT_SUCCESS) {
            IAM_LOGE("Failed to get isUpdate");
            return ret;
        }
        if (isUpdate) {
            CredentialInfoHal oldCredentialHal;
            ret = UpdateCredentialFunc(scheduleResultBuffer, &credentialId, &oldCredentialHal);
            oldInfo.authType = static_cast<AuthType>(oldCredentialHal.authType);
            oldInfo.credentialId = oldCredentialHal.credentialId;
            oldInfo.templateId = oldCredentialHal.templateId;
            oldInfo.executorType = static_cast<uint32_t>(oldCredentialHal.authSubType);
            oldInfo.executorId = 0;
            oldInfo.index = 0;
        } else {
            ret = AddCredentialFunc(scheduleResultBuffer, &credentialId);
        }
        DestoryBuffer(scheduleResultBuffer);
        GlobalUnLock();
        return ret;
    }
    
  4. 认证接口举例实现,详细代码参见user_auth_interface_service.cpp文件。

    // 创建HDI服务对象
    extern "C" IUserAuthInterface *UserAuthInterfaceImplGetInstance(void)
    {
        auto userAuthInterfaceService = new (std::nothrow) UserAuthInterfaceService();
        if (userAuthInterfaceService == nullptr) {
            IAM_LOGE("userAuthInterfaceService is nullptr");
            return nullptr;
        }
        return userAuthInterfaceService;
    }
    
    // 发起认证,生成认证方案和调度信息
    int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const HdiAuthParam &param,
     std::vector<HdiScheduleInfo> &infos)
    {
        IAM_LOGI("start");
        if (param.challenge.size() != sizeof(uint64_t)) {
            IAM_LOGE("Failed to copy challenge");
            return RESULT_BAD_PARAM;
        }
        GlobalLock();
        CoAuthSchedule *schedulesGet = nullptr;
        uint32_t scheduleIdNum = 0;
        AuthSolutionHal solutionIn;
        solutionIn.contextId = contextId;
        solutionIn.userId = param.userId;
        solutionIn.authType = static_cast<uint32_t>(param.authType);
        solutionIn.authTrustLevel = param.authTrustLevel;
        if (memcpy_s(&solutionIn.challenge, sizeof(uint64_t), &param.challenge[0],
            param.challenge.size()) != EOK) {
            IAM_LOGE("Failed to copy challenge");
            GlobalUnLock();
            return RESULT_BAD_COPY;
        }
        int32_t ret = GenerateSolutionFunc(solutionIn, &schedulesGet, &scheduleIdNum);
        if (ret != RESULT_SUCCESS) {
            IAM_LOGE("Failed to generate solution");
            GlobalUnLock();
            return ret;
        }
        for (uint32_t i = 0; i < scheduleIdNum; i++) {
            ScheduleInfoV1_1 temp;
            if (!CopyScheduleInfo(schedulesGet + i, &temp)) {
                infos.clear();
                ret = RESULT_GENERAL_ERROR;
                break;
            }
            infos.push_back(temp);
        }
        free(schedulesGet);
        GlobalUnLock();
        return ret;
    }
    
    // 更新认证结果,进行此次认证方案结果的评估
    int32_t UserAuthInterfaceService::UpdateAuthenticationResult(uint64_t contextId,
     const std::vector<uint8_t> &scheduleResult, HdiAuthResultInfo &info, HdiEnrolledState &enrolledState)
    {
        IAM_LOGI("start");
        GlobalLock();
        if (scheduleResult.size() == 0) {
            IAM_LOGE("param is invalid");
            info.result = RESULT_BAD_PARAM;
            GlobalUnLock();
            return RESULT_BAD_PARAM;
        }
        Buffer *scheduleResultBuffer = CreateBufferByData(&scheduleResult[0], scheduleResult.size());
        if (scheduleResultBuffer == nullptr) {
            IAM_LOGE("scheduleTokenBuffer is null");
            info.result = RESULT_GENERAL_ERROR;
            GlobalUnLock();
            return RESULT_NO_MEMORY;
        }
        UserAuthTokenHal authTokenHal;
        info.result = RequestAuthResultFunc(contextId, scheduleResultBuffer, &authTokenHal);
        if (info.result != RESULT_SUCCESS) {
            IAM_LOGE("Failed to execute func");
            DestoryBuffer(scheduleResultBuffer);
            GlobalUnLock();
            return info.result;
        }
        info.token.resize(sizeof(UserAuthTokenHal));
        if (memcpy_s(&info.token[0], info.token.size(), &authTokenHal, sizeof(authTokenHal)) != EOK) {
            IAM_LOGE("Failed to copy authToken");
            DestoryBuffer(scheduleResultBuffer);
            GlobalUnLock();
            return RESULT_BAD_COPY;
        }
        DestoryBuffer(scheduleResultBuffer);
        GlobalUnLock();
        return RESULT_SUCCESS;
    }
    
    // 取消认证
    int32_t UserAuthInterfaceService::CancelAuthentication(uint64_t contextId)
    {
        IAM_LOGI("start");
        GlobalLock();
        uint32_t scheduleIdNum = 0;
        int32_t ret = CancelContextFunc(contextId, nullptr, &scheduleIdNum);
        if (ret != RESULT_SUCCESS) {
            IAM_LOGE("Failed to execute func");
            GlobalUnLock();
            return ret;
        }
        GlobalUnLock();
        return RESULT_SUCCESS;
    }
    

调测验证

驱动开发完成后,通过用户认证API接口开发HAP应用,基于RK3568平台验证。

1.发起认证并获取认证结果的测试代码如下:

  // API version 10
  import type {BusinessError} from '@ohos.base';
  import userIAM_userAuth from '@ohos.userIAM.userAuth';

  // 设置认证参数
  const authParam: userIAM_userAuth.AuthParam = {
    challenge: new Uint8Array([49, 49, 49, 49, 49, 49]),
    authType: [userIAM_userAuth.UserAuthType.PIN, userIAM_userAuth.UserAuthType.FACE],
    authTrustLevel: userIAM_userAuth.AuthTrustLevel.ATL3,
  };
  // 配置认证界面
  const widgetParam: userIAM_userAuth.WidgetParam = {
    title: '请进行身份认证',
  };
  try {
    // 获取认证对象
    let userAuthInstance = userIAM_userAuth.getUserAuthInstance(authParam, widgetParam);
    console.info('get userAuth instance success');
    // 订阅认证结果
    userAuthInstance.on('result', {
      onResult(result) {
        console.info(`userAuthInstance callback result: ${JSON.stringify(result)}`);
        // 可在认证结束或其他业务需要场景,取消订阅认证结果
        userAuthInstance.off('result');
      }
  });
    console.info('auth on success');
    userAuthInstance.start();
    console.info('auth start success');
  } catch (error) {
    const err: BusinessError = error as BusinessError;
    console.error(`auth catch error. Code is ${err?.code}, message is ${err?.message}`);
  }

2.取消认证的测试代码如下:

  // API version 10
  import type {BusinessError} from '@ohos.base';
  import userIAM_userAuth from '@ohos.userIAM.userAuth';

  const authParam: userIAM_userAuth.AuthParam = {
    challenge: new Uint8Array([49, 49, 49, 49, 49, 49]),
    authType: [userIAM_userAuth.UserAuthType.PIN, userIAM_userAuth.UserAuthType.FACE],
    authTrustLevel: userIAM_userAuth.AuthTrustLevel.ATL3,
  };
  const widgetParam: userIAM_userAuth.WidgetParam = {
    title: '请进行身份认证',
  };
  try {
    // 获取认证对象
    let userAuthInstance = userIAM_userAuth.getUserAuthInstance(authParam, widgetParam);
    console.info('get userAuth instance success');
    // 开始认证
    userAuthInstance.start();
    console.info('auth start success');
    // 取消认证
    userAuthInstance.cancel();
    console.info('auth cancel success');
  } catch (error) {
    const err: BusinessError = error as BusinessError;
    console.error(`auth catch error. Code is ${err?.code}, message is ${err?.message}`);
  }

Harmony鸿蒙南向外设驱动开发-User_auth 用户认证功能是端侧设备不可或缺的一部分,可应用于设备解锁、支付、应用登录等身份认证场景。 阅读详情

相关推荐

鸿蒙OpenHarmony【外设驱动使用之User_auth】 子系统

用户认证功能是端侧设备不可或缺的一部分,可应用于设备解锁、支付、应用登录等身份认证场景。用户认证(User_auth)框架统一管理用户身份与认证凭据模板的映射关系,通过调度各认证基础服务(包含口令认证、人脸识别等)实现的执行器完成用户认证凭据注册、凭据删除、身份认证及相关信息查询。用户认证的整体架构如图1。

zxc95279527q的博客 1012

User_Auth:用户身份验证和会话管理API

学生认证和会话管理 安装 克隆此仓库 git clone https://github.com/WahabDev12/User_Auth.git 转到仓库目录 cd User_Auth 安装并激活虚拟环境 pip install pipenv pipenv shell 用pip安装依赖项 pip install -r requirements.txt 启动开发服务器 python run.py 在本地主机上查看应用 http://127.0.0.1:5000/student/signup

OpenHarmony南向设备开发:子系统外设驱动使用-User_auth

用户认证功能是端侧设备不可或缺的一部分,可应用于设备解锁、支付、应用登录等身份认证场景。

初一十五的博客 896

如何在OpenHarmony上使用SeetaFace2人脸识别库?

相信大部分同学们都已了解或接触过OpenAtom OpenHarmony(以下简称“OpenHarmony”)了,但你一定没在OpenHarmony上实现过人脸识别功能,跟着本文带你快速在OpenHarmony标准设备上基于SeetaFace2和OpenCV实现人脸识别。本项目实现了导入人脸模型、人脸框选和人脸识别三大功能,操作流程如下:1. 录入页面点击右下角按钮,跳转拍摄页面进行拍照;2. 选择一张或多张人脸作为训练模型,并设置对应的名字;3. 选择一张未录入的人脸图片,点击框选按钮实现人脸图片框选功能

OpenHarmony_dev的博客 2835

Godot引擎HarmonyOS支付与账号SDK开发实战:架构设计与安全实现

在移动应用开发中,应用内支付(IAP)和统一账号系统是支撑产品商业化的核心技术组件。其原理在于通过安全的授权与交易流程,连接用户、应用与支付渠道,实现数字商品与服务的变现。这项技术的核心价值在于为开发者提供了标准化的商业闭环解决方案,能有效提升用户支付体验、保障交易安全,并便于跨平台生态整合。典型的应用场景广泛覆盖游戏、工具软件及订阅服务等领域。本文聚焦于为跨平台游戏引擎Godot适配HarmonyOS生态,深入探讨如何通过三层桥接架构(Godot C++模块、JNI层、HarmonyOS服务层)解决引擎与

weixin_30634661的博客 399

HarmonyOS 6原生重构:从App开发到系统能力编排的范式迁移

HarmonyOS 6并非Android兼容层升级,而是以Stage模型、ArkTS语言和分布式能力为核心的全新操作系统范式。其核心原理在于将应用生命周期、后台调度、安全执行等关键逻辑收归系统管控,强制开发者转向‘能力调用’而非‘代码堆砌’——例如ExtensionAbility替代Service、TEE可信执行环境开箱即用、WantAgent实现跨设备意图调度。这一转变带来显著技术价值:更细粒度的资源控制、更高确定性的安全边界、更轻量的业务逻辑。典型应用场景涵盖政务核验(交管12123)、出行协同(高德融

weixin_34413103的博客 518

带你玩转OpenHarmony AI:基于Seetaface2的人脸识别

随着时代的进步,全民刷脸已经成为一种新型的生活方式,这也是全球科技进步的又一阶梯,人脸识别技术已经成为一种大趋势,无论在智慧出行、智能家居、智慧办公等场景均有较广泛的应用场景,本文介绍了基于SeetaFace2人脸识别引擎在OpenAtom OpenHarmony(以下简称“OpenHarmony”)上实现人脸识别的AI能力。其中的PD是三大模块中的关键点定位模块(FaceLandmarker),关键点定位需要根据面部特征模型进行对比分析的,SeetaFace2提供2种面部特征模型。

OpenHarmony_dev的博客 1302

企业级AI编程助手私有化部署:2026年可信、可控、可审的落地指南

AI编程助手已从开发者效率工具升级为企业核心研发基础设施,其私有化部署本质是构建具备代码资产保护、敏感信息治理与全链路审计能力的AI网关系统。技术原理上需融合模型服务容器化、上下文AST级脱敏、RBAC权限控制及国密SM2签名等多重安全机制;技术价值在于满足等保三级、金融信创、GDPR等强监管要求,保障API密钥、内网IP、未公开算法等核心资产不出域;典型应用场景覆盖银行信创云、汽车电子AUTOSAR开发、医疗SaaS离线环境等高合规需求领域;本文聚焦2026年L3/L4级就绪方案,深度解析DeepSeek

weixin_33851429的博客 409

OpenHarmony外设驱动使用 (十二),User_auth

User_auth驱动的主要工作是为User_auth服务提供稳定的用户凭据管理、认证会话管理以及执行器信息管理能力,保证设备上口令认证和生物识别功能可以正常运行。

__Benco的博客 1485

Mythos技术跃迁:从AI辅助到自主漏洞挖掘的范式革命

大语言模型在代码安全分析中的能力演进,已从基础语法理解迈向深度语义建模与自主推理。其核心原理在于激活稀疏度优化、多尺度思维树架构及0day利用三元组强化训练,显著提升对未知漏洞的发现能力与利用链生成精度。该技术突破不仅重塑了渗透测试、SRE运维和CI/CD安全左移等工程实践,更推动AI从‘工具使用者’升级为具备验证闭环的‘可执行责任主体’。Mythos所代表的自主攻击假设空间构建与终端语义理解能力,标志着大模型在真实系统级任务中首次实现工业级鲁棒性。

weixin_33725515的博客 312

【OpenHarmony鸿蒙实战】在RK3399开发板实现智能门禁人脸识别

本样例是基于RK3399开发板,使用OpenHarmony3.0-LTS开发的应用。通过定时获取摄像头数据,实现人脸识别比对等功能。

m0_62167422的博客 2425

Flutter三方库适配OpenHarmony【secure_application】— 认证流程与 authenticationEvents 流

欢迎加入开源鸿蒙跨平台社区:https://openharmonycrossplatform.youkuaiyun.comsecure_application 不强制你用某种认证方式——PIN 码、手势密码、指纹、面容识别,甚至一个简单的"确认"按钮都行。它只提供了一个回调和一套事件流,让你自由接入任何认证方案。这种"不绑定具体实现"的设计非常灵活,但也意味着你需要理解它的工作机制才能正确使用。.overlay!controller?

ze_lin_zfh的博客 1946

OpenHarmony OpenCV应用样例开发

本文主要介绍 OpenHarmony 如何用 opencvlib 进行应用样例开发

m0_64420071的博客 2699

Flutter在OpenHarmony上开发个人理财App实践

跨平台开发框架Flutter以其高效的UI渲染和热重载特性,正在改变移动应用开发的方式。通过自绘引擎实现平台无关性,开发者可以用一套代码构建多平台应用。当Flutter遇上OpenHarmony这一新兴分布式操作系统,技术组合展现出独特优势:既保留跨平台开发效率,又能利用分布式能力创造新体验。在个人理财等金融类应用场景中,这种组合通过Flutter的widget体系保障UI一致性,借助OpenHarmony的微内核架构强化数据安全。实践表明,通过适配Flutter引擎和OpenHarmony工具链,开发者可

weixin_34087307的博客 299

【信息科学与工程学】【产品体系】计算机科学与自动化——第一百八十九篇 操作系统内核(微内核/宏内核)函数与算法02

宏内核(Linux)更多典型内核函数/算法,从编号271开始,覆盖中断管理、热插拔、PCI、ACPI、固件、崩溃转储、kexec、休眠、watchdog、RTC、hwmon、LED、backlight、input子系统、remoteproc等更多领域。编号类型领域内核类型内核中的函数/算法/模块/模组模块的调用关系模块/函数/算法逐步推理思考的数学表达式及参数列表及参数数值设计模块的C/C++/其他代码关联知识271中断管理中断描述符宏内核 / (中断子系统核心)驱动申请中断 → → → 分配irq_

weixin_49199313的博客 116

【信息科学与工程学】计算机科学与自动化——第一百五十五篇 缓存系统设计06

字段详细内容编号​B1类型​PaaS + MaaS(基于微服务 + 事件溯源 + CQRS + 国产化组件:鲲鹏CPU + 昇腾GPU + TiDB + Ceph国产版 + Kafka国产版 + 东方通中间件 + 华为云CDN + WebSocket + QUIC)问题​微服务 + 事件溯源 + 鲲鹏920 + 昇腾910 + TiDB + Ceph(XSKY)+ 国产Kafka + WebSocket + QUIC 电-热-力耦合:如何支持单个超大客户(10亿注册用户,5亿日活),每秒1亿条消息 + 10

weixin_49199313的博客 843

什么是 SeetaFace 开源人脸识别引擎

区分不同的人是很多智能系统的必备能力。为实现此目的,一种可能的技术手段是通过对人脸的光学成像来感知人、识别人,即所谓的人脸识别技术。经过几十年的研发积累,特别是近年来深度学习技术的涌现,人脸识别取得了长足的进步,在安防、金融、教育、社保等领域得到了越来越多的应用,成为计算机视觉领域最为成功的分支领域之一。 然而,人脸识别并非完全成熟的技术,离公众期望的全...

weixin_34293911的博客 434

LabVIEW面向对象编程:操作者框架入门实战

本文是LabVIEW面向对象编程中操作者框架的入门实战指南。针对传统“面条式代码”在复杂项目中的维护难题,文章通过创建操作者、定义消息与处理函数、在主VI中调用等步骤,详细演示了如何利用操作者框架构建模块化、易扩展的应用程序架构,有效管理并行任务。

f0g1h2的博客 591
上一篇: 【入门到实战】OpenHarmony子系统外设驱动使用:USB
下一篇: 【入门到实战】OpenHarmony子系统外设驱动使用:Vibrator
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值