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

鸿蒙南向设备开发(OpenHarmony)口令认证-Pin_auth 用户认证框架与各个基础认证服务(包含口令认证、人脸识别等)组成的身份认证系统,支持用户认证凭据设置、删除、认证等基础功能。 阅读详情

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


概述

功能简介

口令认证是端侧设备不可或缺的一部分,为设备提供一种用户认证能力,可应用于设备解锁、支付、应用登录等身份认证场景。用户注册口令后,口令认证模块就可为设备提供密码解锁的功能,保证设备的安全使用。口令识别的整体架构如图1。

基于HDF(Hardware Driver Foundation)驱动框架开发的Pin_auth驱动,Pin_auth驱动模型屏蔽硬件差异,为上层用户IAM子系统基础框架和口令认证SA提供稳定的口令认证基础能力,包括口令认证执行器列表查询、执行器信息查询、指定模板防暴信息查询、用户认证和执行器间的模板信息对账,以及口令的录入、认证、删除。

图1 口令认证架构图

image

基本概念

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

  • 执行器

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

  • 执行器安全等级

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

  • 执行器角色

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

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

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

  • 执行器类型

    同一种身份认证类型的不同认证方式会产生认证算法差异,设备器件差异也会导致算法差异,执行器根据支持的算法类型差异或对接的器件差异,会定义不同的执行器类型。

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

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

    • 执行器通过用户认证框架公钥校验调度指令的准确性。

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

  • 口令认证凭据模板

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

  • 执行器对账

    用户认证框架统一管理用户身份和凭据ID的映射关系,执行器对接到用户认证框架时,会读取用户身份认证框架内保存的该执行器的模板ID列表,执行器需要与自己维护的模板ID列表进行比对,并删除冗余信息。

  • IDL接口

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

  • IPC通信

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

  • HDI

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

运作机制

Pin_auth驱动的主要工作是为上层用户认证框架和Pin_auth服务提供稳定的口令认证的基础能力,保证口令认证的功能可以正常运行。开发者可基于HDF框架对不同芯片进行各自驱动的开发以及HDI层接口的调用。

图2 Pin_auth服务和pin_auth驱动接口

image

约束与限制

口令认证的实现需要在TEE安全环境中实现,口令凭据等数据的加密信息需要在安全环境中存储。

开发指导

场景介绍

Pin_auth驱动的主要工作是为上层用户认证框架和Pin_auth服务提供稳定的口令认证基础能力,保证设备上口令认证功能可以正常运行。

接口说明

注:以下接口列举的为IDL接口描述生成的对应C++语言函数接口,接口声明见idl文件(/drivers/interface/pin_auth)。 在本文中,口令凭据的录入、认证和删除相关的HDI接口如表1所示,表2中的回调函数分别用于口令执行器返回操作结果给框架和获取用户输入的口令信息。

表1 接口功能介绍

接口名称功能介绍
GetExecutorInfo(ExecutorInfo& executorInfo)获取执行器信息。
GetExecutorList(std::vector<sptr<V2_0::IAllInOneExecutor>>& allInOneExecutors,
std::vector<sptr<V2_0::IVerifier>>& verifiers,
std::vector<sptr<V2_0::ICollector>>& collectors)
获取V2_0执行器列表。
OnRegisterFinish(const std::vector<uint64_t>& templateIdList,
const std::vector<uint8_t>& frameworkPublicKey,
const std::vector<uint8_t>& extraInfo)
执行器注册成功后,获取用户认证框架的公钥信息;获取用户认证框架的template 列表用于对账。
Cancel(uint64_t scheduleId)通过scheduleId取消指定操作。
SetData(uint64_t scheduleId, uint64_t authSubType,
const std::vector<uint8_t> &data, int32_t resultCode)
回调函数,返回用户录入的口令子类型和录入的口令脱敏数据。
Enroll(uint64_t scheduleId, const std::vector<uint8_t>& extraInfo,
const sptr& callbackObj)
录入pin码。
Authenticate(uint64_t scheduleId, const std::vector<uint64_t>& templateIdList, const std::vector<uint8_t>& extraInfo, const sptr& callbackObj)pin码认证。
Delete(uint64_t templateId)删除pin码模板。
GetProperty(const std::vector<uint64_t>& templateIdList,
const std::vector& propertyTypes, Property& property)
获取执行器属性信息。

表2 回调函数介绍

接口名称功能介绍
IExecutorCallback::OnResult(int32_t result, const std::vector<uint8_t>& extraInfo)返回操作的最终结果。
IExecutorCallback::OnTip(int32_t tip, const std::vector<uint8_t>& extraInfo)返回操作的过程提示信息。
IExecutorCallback::OnGetData(const std::vector<uint8_t>& algoParameter, uint64_t authSubType, uint32_t algoVersion, const std::vector<uint8_t>& challenge)返回获取pin码数据信息。
IExecutorCallback::OnMessage(int32_t destRole, const std::vector<uint8_t>& msg)返回操作的过程交互消息。

开发步骤

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

// drivers/peripheral/pin_auth
├── BUILD.gn     # 编译脚本
├── bundle.json  # 组件描述文件
├── test         # 测试用例
└── hdi_service  # Pin_auth驱动实现
    ├── BUILD.gn   # 编译脚本
    ├── adaptor    # 相关算法实现
    ├── common     # 公共接口实现
    ├── database   # 数据库实现
    ├── main       # 口令相关功能实现入口
    └── service    # Pin_auth驱动实现入口
        ├── inc      # 头文件
        └── src      # 源文件
            ├── all_in_one_impl.cpp             # 全功能执行器认证、录入等功能接口实现
            ├── verifier_impl.cpp               # 认证器认证、录入等功能接口实现
            ├── collector_impl.cpp              # 采集器认证、录入等功能接口实现
            ├── executor_impl_common.cpp        # 工具类
            ├── pin_auth_interface_driver.cpp   # Pin_auth驱动入口
            └── pin_auth_interface_service.cpp  # 获取执行器列表接口实现

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

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

    // 通过自定义的HdfPinAuthInterfaceHost对象包含IoService对象和真正的HDI Service实现PinAuthInterfaceService对象
    struct HdfPinAuthInterfaceHost {
        struct IDeviceIoService ioService;
        OHOS::sptr<OHOS::IRemoteObject> stub;
    };
    
    // 服务接口调用响应接口
    static int32_t PinAuthInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
    {
        IAM_LOGI("start");
        auto *hdfPinAuthInterfaceHost = CONTAINER_OF(client->device->service,
            struct HdfPinAuthInterfaceHost, ioService);
    
        OHOS::MessageParcel *dataParcel = nullptr;
        OHOS::MessageParcel *replyParcel = nullptr;
        OHOS::MessageOption option;
    
        if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {
            IAM_LOGE("%{public}s:invalid data sbuf object to dispatch", __func__);
            return HDF_ERR_INVALID_PARAM;
        }
        if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) {
            IAM_LOGE("%{public}s:invalid reply sbuf object to dispatch", __func__);
            return HDF_ERR_INVALID_PARAM;
        }
    
        return hdfPinAuthInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option);
    }
    
    // 初始化接口
    static int HdfPinAuthInterfaceDriverInit(struct HdfDeviceObject *deviceObject)
    {
        IAM_LOGI("start");
        std::shared_ptr<OHOS::UserIAM::PinAuth::PinAuth> pinHdi =
            OHOS::UserIAM::Common::MakeShared<OHOS::UserIAM::PinAuth::PinAuth>();
        constexpr uint32_t SUCCESS = 0;
        if (pinHdi == nullptr || pinHdi->Init() != SUCCESS) {
            IAM_LOGE("Pin hal init failed");
            return HDF_FAILURE;
        }
        return HDF_SUCCESS;
    }
    
    // PinAuth驱动对外提供的服务绑定到HDF框架
    static int HdfPinAuthInterfaceDriverBind(struct HdfDeviceObject *deviceObject)
    {
        IAM_LOGI("start");
        auto *hdfPinAuthInterfaceHost = new (std::nothrow) HdfPinAuthInterfaceHost;
        if (hdfPinAuthInterfaceHost == nullptr) {
            IAM_LOGE("%{public}s: failed to create HdfPinAuthInterfaceHost object", __func__);
            return HDF_FAILURE;
        }
    
        hdfPinAuthInterfaceHost->ioService.Dispatch = PinAuthInterfaceDriverDispatch;
        hdfPinAuthInterfaceHost->ioService.Open = NULL;
        hdfPinAuthInterfaceHost->ioService.Release = NULL;
    
        auto serviceImpl = IPinAuthInterface::Get(true);
        if (serviceImpl == nullptr) {
            IAM_LOGE("%{public}s: failed to get of implement service", __func__);
            return HDF_FAILURE;
        }
    
        hdfPinAuthInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl,
            IPinAuthInterface::GetDescriptor());
        if (hdfPinAuthInterfaceHost->stub == nullptr) {
            IAM_LOGE("%{public}s: failed to get stub object", __func__);
            return HDF_FAILURE;
        }
    
        deviceObject->service = &hdfPinAuthInterfaceHost->ioService;
        IAM_LOGI("success");
        return HDF_SUCCESS;
    }
    
    // 释放PinAuth驱动中的资源
    static void HdfPinAuthInterfaceDriverRelease(struct HdfDeviceObject *deviceObject)
    {
        IAM_LOGI("start");
        auto *hdfPinAuthInterfaceHost = CONTAINER_OF(deviceObject->service,
            struct HdfPinAuthInterfaceHost, ioService);
        delete hdfPinAuthInterfaceHost;
        IAM_LOGI("success");
    }
    
    static struct HdfDriverEntry g_pinAuthInterfaceDriverEntry = {
        .moduleVersion = 1,
        .moduleName = "pinauth_interface_service",
        .Bind = HdfPinAuthInterfaceDriverBind,
        .Init = HdfPinAuthInterfaceDriverInit,
        .Release = HdfPinAuthInterfaceDriverRelease,
    };
    
    // 调用HDF_INIT将驱动入口注册到HDF框架中,在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动,当Init调用异常时,HDF框架会调用Release释放驱动资源并退出
    HDF_INIT(g_pinauthinterfaceDriverEntry);
    
  2. 完成获取执行器列表接口实现,详细代码参见pin_auth_interface_service.cpp文件。

    // 执行器实现类
     class ExecutorImpl : public HdiIExecutor, public NoCopyable {
     public:
         explicit ExecutorImpl(std::shared_ptr<OHOS::UserIam::PinAuth::PinAuth> pinHdi);
         ~ExecutorImpl() override;
    
         int32_t GetExecutorInfo(HdiExecutorInfo &info) override;
         int32_t OnRegisterFinish(const std::vector<uint64_t> &templateIdList,
             const std::vector<uint8_t> &frameworkPublicKey, const std::vector<uint8_t> &extraInfo) override;
         int32_t Cancel(uint64_t scheduleId) override;
         int32_t SendMessage(uint64_t scheduleId, int32_t srcRole, const std::vector<uint8_t>& msg) override;
         int32_t SetData(uint64_t scheduleId, uint64_t authSubType, const std::vector<uint8_t> &data,
             int32_t resultCode) override;
         int32_t Enroll(uint64_t scheduleId, const std::vector<uint8_t> &extraInfo,
             const sptr<HdiIExecutorCallback> &callbackObj) override;
         int32_t Authenticate(uint64_t scheduleId, const std::vector<uint64_t>& templateIdList,
             const std::vector<uint8_t> &extraInfo, const sptr<HdiIExecutorCallback> &callbackObj) override;
         int32_t Delete(uint64_t templateId) override;
         int32_t GetProperty(const std::vector<uint64_t> &templateIdList, const std::vector<int32_t> &propertyTypes,
             HdiProperty &property) override;
    
     private:
         class ScheduleMap {
         public:
             uint32_t AddScheduleInfo(const uint64_t scheduleId, const uint32_t commandId,
                 const sptr<HdiIExecutorCallback> callback, const uint64_t templateId,
                 const std::vector<uint8_t> algoParameter);
             uint32_t GetScheduleInfo(const uint64_t scheduleId, uint32_t &commandId, sptr<HdiIExecutorCallback> &callback,
                 uint64_t &templateId, std::vector<uint8_t> &algoParameter);
             uint32_t DeleteScheduleId(const uint64_t scheduleId);
    
         private:
             struct ScheduleInfo {
                 uint32_t commandId;
                 sptr<HdiIExecutorCallback> callback;
                 uint64_t templateId;
                 std::vector<uint8_t> algoParameter;
             };
    
             std::mutex mutex_;
             std::map<uint64_t, struct ScheduleInfo> scheduleInfo_;
         };
    
     private:
         void CallError(const sptr<HdiIExecutorCallback> &callbackObj, uint32_t errorCode);
         int32_t AuthPin(uint64_t scheduleId, uint64_t templateId,
             const std::vector<uint8_t> &data, std::vector<uint8_t> &resultTlv);
         int32_t AuthenticateInner(uint64_t scheduleId, uint64_t templateId, std::vector<uint8_t> &algoParameter,
             const sptr<HdiIExecutorCallback> &callbackObj);
         int32_t EnrollInner(uint64_t scheduleId, const std::vector<uint8_t> &extraInfo,
             const sptr<HdiIExecutorCallback> &callbackObj, std::vector<uint8_t> &algoParameter, uint32_t &algoVersion);
         void ReportAuthenticate(uint64_t scheduleId, uint64_t templateId, PinAuthResultBigData pinAuthResultBigData);
         std::shared_ptr<OHOS::UserIam::PinAuth::PinAuth> pinHdi_;
         ScheduleMap scheduleMap_;
         OHOS::ThreadPool threadPool_;
     };
    
    // 获取执行器列表实现,创建执行器(仅作示例)
    int32_t PinAuthInterfaceService::GetExecutorList(std::vector<sptr<HdiIExecutor>>& allInOneExecutors,
         std::vector<sptr<HdiIVerifier>>& verifiers, std::vector<sptr<HdiICollector>>& collectors)
    {
        IAM_LOGI("start");
        static_cast<void>(verifiers);
        static_cast<void>(collectors);
        std::shared_ptr<OHOS::UserIam::PinAuth::PinAuth> pinHdi =
            OHOS::UserIam::Common::MakeShared<OHOS::UserIam::PinAuth::PinAuth>();
        if (pinHdi == nullptr) {
            IAM_LOGE("Generate pinHdi failed");
            return HDF_FAILURE;
        }
        sptr<HdiIExecutor> executor = new (std::nothrow) ExecutorImpl(pinHdi);
        if (executor == nullptr) {
            IAM_LOGE("Generate executor failed");
            return HDF_FAILURE;
        }
        allInOneExecutors.push_back(executor);
        IAM_LOGI("end");
        return HDF_SUCCESS;
    }
    
  3. 完成执行器每个功能接口实现,详细代码参见all_in_one_impl.cpp文件。

    // 实现获取执行器信息接口(仅作示例)
    int32_t ExecutorImpl::GetExecutorInfo(HdiExecutorInfo &info)
    {
        IAM_LOGI("start");
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            return HDF_FAILURE;
        }
        constexpr unsigned short SENSOR_ID = 1;
        info.sensorId = SENSOR_ID;
        info.executorMatcher = EXECUTOR_TYPE;
        info.executorRole = HdiExecutorRole::ALL_IN_ONE;
        info.authType = HdiAuthType::PIN;
        uint32_t eslRet = 0;
        int32_t result = pinHdi_->GetExecutorInfo(info.publicKey, eslRet);
        if (result != SUCCESS) {
            IAM_LOGE("Get ExecutorInfo failed, fail code : %{public}d", result);
            return result;
        }
        info.esl = static_cast<HdiExecutorSecureLevel>(eslRet);
    
        return HDF_SUCCESS;
    }
    
    // 实现执行器注册成功后,获取用户认证框架的公钥信息、获取用户认证框架的template 列表接口,将公钥信息保存,template列表用于和本地的template做对账
    int32_t ExecutorImpl::OnRegisterFinish(const std::vector<uint64_t> &templateIdList,
        const std::vector<uint8_t> &frameworkPublicKey, const std::vector<uint8_t> &extraInfo)
    {
        IAM_LOGI("start");
        static_cast<void>(frameworkPublicKey);
        static_cast<void>(extraInfo);
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            return HDF_FAILURE;
        }
        int32_t result = pinHdi_->VerifyTemplateData(templateIdList);
        if (result != SUCCESS) {
            IAM_LOGE("Verify templateData failed");
            return result;
        }
    
        return HDF_SUCCESS;
    }
    
    // 实现口令录入接口
    int32_t ExecutorImpl::Enroll(uint64_t scheduleId, const std::vector<uint8_t> &extraInfo,
        const sptr<IExecutorCallback> &callbackObj)
    {
        IAM_LOGI("start");
        if (callbackObj == nullptr) {
            IAM_LOGE("callbackObj is nullptr");
            return HDF_ERR_INVALID_PARAM;
        }
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            CallError(callbackObj, INVALID_PARAMETERS);
            return HDF_SUCCESS;
        }
        std::vector<uint8_t> algoParameter;
        uint32_t algoVersion = 0;
        int32_t result = EnrollInner(scheduleId, extraInfo, callbackObj, algoParameter, algoVersion);
        if (result != SUCCESS) {
            IAM_LOGE("EnrollInner failed, fail code : %{public}d", result);
            return HDF_SUCCESS;
        }
    
        std::vector<uint8_t> challenge;
        result = callbackObj->OnGetData(algoParameter, 0, algoVersion, challenge);
        if (result != SUCCESS) {
            IAM_LOGE("Enroll Pin failed, fail code : %{public}d", result);
            CallError(callbackObj, GENERAL_ERROR);
            // If the enroll fails, delete scheduleId of scheduleMap
            if (scheduleMap_.DeleteScheduleId(scheduleId) != HDF_SUCCESS) {
                IAM_LOGI("delete scheduleId failed");
            }
        }
    
        return HDF_SUCCESS;
    }
    
    // 实现回调数据获取的接口
    int32_t ExecutorImpl::SetData(uint64_t scheduleId, uint64_t authSubType, const std::vector<uint8_t> &data,
        int32_t resultCode)
    {
        IAM_LOGI("start");
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            return HDF_FAILURE;
        }
        std::vector<uint8_t> resultTlv;
        int32_t result = GENERAL_ERROR;
        constexpr uint32_t INVALID_ID = 2;
        uint32_t commandId = INVALID_ID;
        sptr<HdiIExecutorCallback> callback = nullptr;
        uint64_t templateId = 0;
        std::vector<uint8_t> algoParameter(0, 0);
        if (scheduleMap_.GetScheduleInfo(scheduleId, commandId, callback, templateId, algoParameter) != HDF_SUCCESS) {
            IAM_LOGE("Get ScheduleInfo failed, fail code : %{public}d", result);
            return HDF_FAILURE;
        }
        if (resultCode != SUCCESS && callback != nullptr) {
            IAM_LOGE("SetData failed, resultCode is %{public}d", resultCode);
            CallError(callback, resultCode);
            return resultCode;
        }
        switch (commandId) {
            case ENROLL_PIN:
                result = pinHdi_->EnrollPin(scheduleId, authSubType, algoParameter, data, resultTlv);
                if (result != SUCCESS) {
                    IAM_LOGE("Enroll Pin failed, fail code : %{public}d", result);
                }
                break;
            case AUTH_PIN:
                result = AuthPin(scheduleId, templateId, data, resultTlv);
                if (result != SUCCESS) {
                    IAM_LOGE("Auth Pin failed, fail code : %{public}d", result);
                }
                break;
            default:
                IAM_LOGE("Error commandId");
        }
    
        if (callback == nullptr || callback->OnResult(result, resultTlv) != SUCCESS) {
            IAM_LOGE("callbackObj Pin failed");
        }
        // Delete scheduleId from the scheduleMap_ when the enroll and authentication are successful
        if (scheduleMap_.DeleteScheduleId(scheduleId) != HDF_SUCCESS) {
            IAM_LOGI("delete scheduleId failed");
        }
    
        return HDF_SUCCESS;
    }
    
    // 实现口令认证接口
    int32_t ExecutorImpl::Authenticate(uint64_t scheduleId, const std::vector<uint64_t>& templateIdList,
        const std::vector<uint8_t> &extraInfo, const sptr<HdiIExecutorCallback> &callbackObj)
    {
        IAM_LOGI("start");
        if (callbackObj == nullptr) {
            IAM_LOGE("callbackObj is nullptr");
            return HDF_ERR_INVALID_PARAM;
        }
        if (pinHdi_ == nullptr || templateIdList.size() != 1) {
            IAM_LOGE("pinHdi_ is nullptr or templateIdList size not 1");
            CallError(callbackObj, INVALID_PARAMETERS);
            return HDF_SUCCESS;
        }
        static_cast<void>(extraInfo);
        std::vector<uint8_t> algoParameter;
        uint32_t algoVersion = 0;
        uint64_t templateId = templateIdList[0];
        int32_t result = pinHdi_->GetAlgoParameter(templateId, algoParameter, algoVersion);
        if (result != SUCCESS) {
            IAM_LOGE("Get algorithm parameter failed, fail code : %{public}d", result);
            CallError(callbackObj, result);
            return GENERAL_ERROR;
        }
        result = AuthenticateInner(scheduleId, templateId, algoParameter, callbackObj);
        if (result != SUCCESS) {
            IAM_LOGE("AuthenticateInner failed, fail code : %{public}d", result);
            return HDF_SUCCESS;
        }
    
        std::vector<uint8_t> challenge;
        result = callbackObj->OnGetData(algoParameter, 0, algoVersion, challenge);
        if (result != SUCCESS) {
            IAM_LOGE("Authenticate Pin failed, fail code : %{public}d", result);
            CallError(callbackObj, GENERAL_ERROR);
            // If the authentication fails, delete scheduleId of scheduleMap
            if (scheduleMap_.DeleteScheduleId(scheduleId) != HDF_SUCCESS) {
                IAM_LOGI("delete scheduleId failed");
            }
        }
    
        return HDF_SUCCESS;
    }
    
    // 实现删除口令模板接口
    int32_t ExecutorImpl::Delete(uint64_t templateId)
    {
        IAM_LOGI("start");
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            return HDF_FAILURE;
        }
        int32_t result = pinHdi_->DeleteTemplate(templateId);
        if (result != SUCCESS) {
            IAM_LOGE("Verify templateData failed, fail code : %{public}d", result);
            return result;
        }
    
        return HDF_SUCCESS;
    }
    
    // 实现通过scheduleId取消指定操作接口
    int32_t ExecutorImpl::Cancel(uint64_t scheduleId)
    {
        IAM_LOGI("start");
        if (scheduleMap_.DeleteScheduleId(scheduleId) != HDF_SUCCESS) {
            IAM_LOGE("scheduleId is not found");
            return HDF_FAILURE;
        }
        return HDF_SUCCESS;
    }
    
    // 获取执行器属性信息接口
    int32_t ExecutorImpl::GetProperty(
        const std::vector<uint64_t> &templateIdList, const std::vector<GetPropertyType> &propertyTypes, Property &property)
    {
        IAM_LOGI("start");
        if (pinHdi_ == nullptr) {
            IAM_LOGE("pinHdi_ is nullptr");
            return HDF_FAILURE;
        }
    
        if (templateIdList.size() != 1) {
            IAM_LOGE("templateIdList size is not 1");
            return HDF_FAILURE;
        }
    
        uint64_t templateId = templateIdList[0];
        OHOS::UserIam::PinAuth::PinCredentialInfo infoRet = {};
        int32_t result = pinHdi_->QueryPinInfo(templateId, infoRet);
        if (result != SUCCESS) {
            IAM_LOGE("Get TemplateInfo failed, fail code : %{public}d", result);
            return HDF_FAILURE;
        }
    
        property.authSubType = infoRet.subType;
        property.remainAttempts = infoRet.remainTimes;
        property.lockoutDuration = infoRet.freezingTime;
        return HDF_SUCCESS;
    }
    

调测验证

驱动开发完成后,可基于RK3568平台验证, 通过设备的设置和锁屏功能验证口令认证功能是否正常,测试步骤如下:

  1. 点击设备的 “ 设置 > 生物识别和密码 > 锁屏密码" 后,录入锁屏密码。
  2. 按设备电源键进行锁屏,再次按设备的电源键进行解锁,输入锁屏密码进行解锁验证,至此就完成了口令的录入和认证功能。
  3. 进入设置中的生物识别和密码,点击关闭锁屏密码或者更改锁屏密码,来验证口令的删除和更新功能是否正常。
  4. 在步骤1完成后,进行步骤2的输入锁屏密码时,输入错误密码达到一定的次数来验证,防暴力破解能力是否正常(例如:连续输入5次错误密码,设备将被冻结60s)。

鸿蒙OpenHarmony【外设驱动使用之Pin_auth】 子系统 口令认证是端侧设备不可或缺的一部分,为设备提供一种用户认证能力,可应用于设备解锁、支付、应用登录等身份认证场景。用户注册口令后,口令认证模块就可为设备提供密码解锁的功能,保证设备的安全使用。口令识别的整体架构如图1。 阅读详情

相关推荐

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

基于HDF(Hardware Driver Foundation)驱动框架开发的Pin_auth驱动,Pin_auth驱动模型屏蔽硬件差异......

初一十五的博客 789

OpenHarmony外设驱动使用 (九),Pin_auth

Pin_auth驱动的主要工作是为上层用户认证框架和Pin_auth服务提供稳定的口令认证基础能力,保证设备上口令认证功能可以正常运行。

__Benco的博客 1581

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

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

weixin_34413103的博客 518

Flutter三方库 HarmonyOS ArkTS API 24 pin_code_fields 适配 OpenHarmony —— 实现应用锁

输入配置:密码长度、完成回调、变化回调、文本样式颜色配置:激活颜色、未激活颜色、选中颜色、错误颜色尺寸配置:输入框宽度、高度、圆角大小错误配置:是否显示错误、错误提示文本安全配置:是否密文显示(默认开启)文本配置:标题文本(默认"应用锁")、副标题文本(默认"请输入应用解锁密码")与支付密码和 OTP 验证码不同,应用锁组件自带了标题和副标题,形成了一个更完整的界面模块。使用者只需要传入组件,就可以得到一个完整的应用锁界面。完整的应用锁流程。

2301_79516858的博客 368

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

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

weixin_33851429的博客 409

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

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

weixin_49199313的博客 116

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

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

ze_lin_zfh的博客 1946

基于OSPF技术的某企业网络设计(完整文档+ENSP拓扑图)

主要对网络规划与设计,以企业网络为背景,对某个中型企业网络进行规划设计,该企业总部在南京,在常州有一个分公司,需要实现总部和分公司能够访问外网,能够让分公司内的用户或主机访问总部服务器的资源,并且保证数据的安全性。在这次总部企业网络设计中,考虑到资金的问题,核心层部署2台核心三层交换机,负责转发总部内部用户的流量,并充当内部用户网关,能够实现内部不同网段的用户之间的连通性。对于一些对网络比较敏感的企业或用户,对网络的要求较高,对于网络的稳定性和安全性也有较高的要求。

qq1325513482的博客 2万+

OpenHarmony硬件调试三板斧:串口日志、JTAG与逻辑分析仪实战

在嵌入式Linux及OpenHarmony系统级开发中,当设备启动异常、内核崩溃或外设时序错误时,传统软件调试手段往往力不从心。硬件调试的核心在于从系统外部观测内部状态:串口日志提供最基础的状态信息,JTAG/SWD调试器可精准定位CPU运行现场,逻辑分析仪与示波器则能验证物理时序。三者分别对应信息收集、定向深入和物理确认,构成完整的调试闭环。以RK3568平台为例,从设备树选择、内核参数配置到实际故障排查,合理组合这三板斧,能将复杂软硬件问题从“大海捞针”变为“精准定位”。无论是底层驱动开发还是系统启动优

weixin_34221775的博客 294

scRNA-seq的fastq文件处理流程——持续更新

获得了一批新的scRNA-seq的fastq.gz文件,每个样本的数据形式为: 我打算使用10X cellranger处理fastq.gz文件,下载及安装方式在官网:https://support.10xgenomics.com/single-cell-gene-expression/software/downloads/2.0这个网址写了10X cellranger处理fastq.gz文件的命名规则https://support.10xgenomics.com/single-cell-gene-expr

watermel__的博客 3200

Winform零基础从入门到精通(3)——WinForm基础语法与事件机制详解

通过系统学习基础语法与事件机制,结合实际问题调试,可以快速掌握WinForm开发的核心技能。遇到问题时,优先检查事件绑定和异常处理,逐步培养代码规范意识。​安全转换字符串为数值,避免输入错误导致的崩溃。验证输入(如仅允许数字)​)传递事件相关数据。◦ 事件参数类型:​。

WangMing_X的博客 1494

OpenHarmony 网络请求实战:@ohos/axios 库的安装、配置与上传下载全指南

`@ohos/axios` 是基于经典 [Axios](https://github.com/axios/axios) 原库 v1.3.4 适配 OpenHarmony 的 Promise 网络请求库,保留了 HTTP 请求、拦截器、数据转换、JSON 自动解析等原生特性,是鸿蒙应用中最常用的网络层选型之一。本篇以黄鹤开源社区鸿蒙应用(本项目)为实践背景,系统讲解该库的安装、权限声明、请求配置、实

gitblog_00526的博客 78

simulink调用C代码函数-C Caller模块

simulink中如何调用写好的C代码函数?使用C Caller模块调用C代码。

weixin_40531919的博客 5675

黄鹤开源社区鸿蒙应用网络层实战:@ohos/axios 在 OpenHarmony 中的完整接入指南

本文以黄鹤开源社区鸿蒙应用(`nutpi/huanghe_community_openHarmony_App`)为背景,系统讲解 OpenHarmony 适配版网络请求库 `@ohos/axios` 的安装配置、泛型 API、请求配置、拦截器、证书安全、文件上传下载与错误处理等完整能力。`@ohos/axios` 基于 axios 原库 v1.3.4 适配移植,可在 OpenHarmony 设备上

gitblog_00311的博客 233

MATLAB新手必看:Stewart平台运动学逆解从入门到实战(附完整代码)

本文详细介绍了如何使用MATLAB实现Stewart平台的运动学逆解,从基础原理到完整代码实现,涵盖并联机器人的数学建模、MATLAB编程和Simulink集成。通过实战案例和可视化分析,帮助新手快速掌握Stewart平台的运动学逆解技术,适用于机器人学和控制理论领域的研究与应用。

dream的博客 551

华为OD机试双机位C卷-用户入网定期复评(C/C++/Py/Java/Js/Go)

华为OD机试(机考)双机位C卷 【用户入网定期复评】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【用户入网定期复评】。

qq_45776114的博客 841

鸿蒙软总线学习路线:从“设备怎么连上的“到“我也能写配对工具“

配对(建立互信)→ 发现(找到设备)→ 组网(JoinLNN)→ 传输(Socket)每个环节都有知识文档做向导,不需要在源码里迷路。如果你正在做鸿蒙分布式开发,希望这条路线能帮你少走几周弯路。

465

读懂 ABAP CDS 注解的直接、继承与派生

本文系统梳理了ABAP CDS注解的评估逻辑,重点解析直接注解(Direct)、继承注解(Inherited)和派生注解(Derived)的差异及其在CL_DD_DDL_ANNOTATION_SERVICE中的处理方式。通过视图注解@Metadata.ignorePropagatedAnnotations可调控注解传播行为,避免下游语义影响上层视图。文章还提供了基于标准表的完整示例(包含底层视图、消费视图和ABAP报告程序),帮助开发者在实际系统中验证三层注解的叠加效果与阻断机制。关键点包括:派生注解的数据

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 247

STM32+华为云IoT+Qt手把手搭建智能家居远程控制系统

物联网系统的核心链路通常由嵌入式采集端、云平台和跨平台应用层构成。设备通过MQTT协议上报传感器数据,云端负责数据存储、命令路由和设备状态同步,应用端则通过统一API实现远程监控与控制。这种三层架构在智能家居、环境监测和工业远程运维中有着广泛应用,既能保证系统实时性,又能降低模块耦合度。通过搭配STM32、华为云IoT与Qt,可以低成本复现一个从硬件到软件全栈可控的智能终端项目,涵盖DHT11数据采集、继电器控制、设备影子状态同步以及桌面/移动端远程交互。本文将以一套温湿度采集与电器控制系统的完整搭建过程为

weixin_33816300的博客 270

众包更新高精地图:如何保证数据一致性?

众包更新高精地图:如何保证数据一致性?​ ,人工智能,计算机视觉,大模型,AI,该文章围绕众包更新高精地图的数据一致性保障展开,介绍了测试方法,包括单元、集成、性能和一致性测试;阐述了部署与运维,涉及部署架构、监控告警及系统升级维护;还提及行业标准与规范,涵盖数据采集、处理及安全隐私保护标准,全方位为众包更新高精地图的数据一致性提供技术与规范支持。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 16万+

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

芯参谋(100):RT-Thread_驱动开发指南

本文档为Microchip PIC/AVR/SAM三族MCU的全流程开发指南,覆盖从选型、MCC配置、代码生成到量产烧录的完整链路。针对三族工具链差异大、生态复杂的问题,按“选型→配置→应用→烧录→调试”顺序组织,明确各环节官方出处与可复现命令。重点解决跨族迁移中的共性难题:MCC生成边界、PPS引脚映射失效、UPDI连接失败、内存溢出及量产固件一次性烧录等。通过机制-配置-排查三段式结构,结合速查表与读者路径,实现工程问题快速定位,提升开发效率与产品可靠性。

qq520131714的专栏 615

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

基于PIC32CX1025SG41128 USB CDC Dual-Bank Bootloader设计

本项目基于PIC32CX1025SG41128实现支持USB CDC虚拟串口的双Bank安全Bootloader,替代传统UART升级方式。通过抽象通信接口,实现固件分块传输、CRC校验与安全切换,确保升级中断时系统可回退。采用双Bank布局,预留failsafe区域记录版本与重试信息,支持RAM触发重启进入升级模式。配套上位机工具btl_host.py与打包脚本make_merged_bin.py,完成镜像生成与下载。工程结构清晰,兼容MPLAB X/VSCode开发环境,适用于高可靠性嵌入式设备远程升级

lindd911911的博客 289

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

TMC2209步进电机驱动开发

TMC2209是两相步进电机驱动,最高峰值电流2A(有效值1.4A),供电电压4.75V~29V。开发时一定要注意电流的阈值,2A的电流可能不适配大扭矩的电机需求。通信接口:半双工UART(单数据线,共用一根线收发,必须控制收发方向)细分:最高 256 微步(UART 模式),引脚模式最高 16 细分控制方式:STEP + DIR 脉冲方向控制(主流用法,不是串口发脉冲)用法:引脚模式和UART配置模式,UART模式可实时改变寄存器状态MS1/MS2:引脚模式时用于改变细分;

weixin_44425713的博客 378

SPI总线协议与RFID-RC522读卡器驱动开发—【万物智能之开源鸿蒙OpenHarmony系统实战开发系列教程】

本文详述了在OpenHarmony4.1环境下基于RK3568平台使用SPI驱动RC522 NFC芯片的调试过程。核心要点包括:正确复位(CommandReg=0x0F,延时50ms)后读取VersionReg(0x37)判断芯片状态;避免将read返回值误作字节数,禁止“先write地址再read”错误操作;区分0x00/0xFF(未检出)与正常版本号(如0xB2兼容片);以4字节UID为终极判据,非版本号;排除硬件干扰(如MAX7219共用引脚)、权限(chmod 0666)、设备树匹配等问题;用户态代

wanwuzhineng_01的博客 270

BcoreOS 系统制作实战:用一个升级包,让Rocky Linux10.1跑进Ubuntu 25.04

本节以 Rocky 10.1 作为系统母盘,演示如何根据内核校验和匹配 AOS 镜像,并最终生成可用的 BcoreOS 升级包。

xiaozhi@fslib.org的博客 251

AI 如何接进 LabVIEW:链路怎么搭、边界在哪、还差什么

这篇讨论的是:如果让 AI 真正连进 LabVIEW 开发环境,链路该怎么搭、边界在哪,以及从开源 demo 走到可交付系统还差哪些工程工作。阅读说明:本文基于公开开源项目与通用工程方法整理,用于技术选型讨论,不代表已完成的客户案例、已交付系统或实测性能指标。文中能力模块是常见需求分类,具体范围与指标需按实际工况沟通与验收确认。

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值