Star897
5800
代码
代码
Issues904
Pull Requests1203
项目讨论
Wiki
分析
Star897
5800
已合并
add ukey doc #115368
欢欢创建于 2025年11月5日
add ukey doc #115368
已合并
欢欢创建于 2025年11月5日
从yang_jinhuan/docsukey合入到openharmony/docsmaster
共 28 个文件变更+3054-90
Mzh-cn/application-dev/quick-start/module-configuration-file.md+1-1
@@ -457,7 +457,7 @@ skills示例：
457| description | 标识当前ExtensionAbility组件的描述，开发者可以通过该标签描述当前组件的功能与作用，取值为长度不超过255字节的字符串，可以是对描述内容的资源索引，用于支持多语言。 | 字符串 | 该标签可缺省，缺省值为空。 |457| description | 标识当前ExtensionAbility组件的描述，开发者可以通过该标签描述当前组件的功能与作用，取值为长度不超过255字节的字符串，可以是对描述内容的资源索引，用于支持多语言。 | 字符串 | 该标签可缺省，缺省值为空。 |
458| icon | 标识当前ExtensionAbility组件的图标，取值为资源文件的索引。 | 字符串 | 该标签可缺省，缺省值为空。 |458| icon | 标识当前ExtensionAbility组件的图标，取值为资源文件的索引。 | 字符串 | 该标签可缺省，缺省值为空。 |
459| label | 标识当前ExtensionAbility组件对用户显示的名称，取值为该名称的资源索引，以支持多语言，字符串长度不超过255字节。 | 字符串 | 该标签可缺省，缺省值为空。 |459| label | 标识当前ExtensionAbility组件对用户显示的名称，取值为该名称的资源索引，以支持多语言，字符串长度不超过255字节。 | 字符串 | 该标签可缺省，缺省值为空。 |
460-| type | 标识当前ExtensionAbility组件的类型，支持的取值如下：<br/>-&nbsp;form：卡片的ExtensionAbility。<br/>-&nbsp;workScheduler：延时任务的ExtensionAbility。<br/>-&nbsp;inputMethod：输入法的ExtensionAbility。<!--Del--><br/>-&nbsp;service：后台运行的service组件。<!--DelEnd--><br/>-&nbsp;accessibility：辅助能力的ExtensionAbility。<!--Del--><br/>-&nbsp;fileAccess：公共数据访问的ExtensionAbility，允许应用程序提供文件和文件夹给文件管理类应用展示。<br/>-&nbsp;dataShare：数据共享的ExtensionAbility。<br/>-&nbsp;staticSubscriber：静态广播的ExtensionAbility。<!--DelEnd--><br/>-&nbsp;wallpaper：壁纸的ExtensionAbility。<br/>-&nbsp;backup：数据备份的ExtensionAbility。<br/>-&nbsp;enterpriseAdmin：[企业设备管理](../mdm/mdm-kit-admin.md)的ExtensionAbility。企业设备管理应用必须拥有此类型的ExtensionAbility。<!--Del--><br/>-&nbsp;window：该ExtensionAbility会在启动过程中创建一个window，为开发者提供界面开发。开发者开发出来的界面将通过UIExtensionComponent控件组合到其他应用的窗口中。<!--DelEnd--><br/>-&nbsp;thumbnail：获取文件缩略图的ExtensionAbility，开发者可以对自定义文件类型的文件提供缩略。<br/>-&nbsp;preview：该ExtensionAbility会将文件解析后在一个窗口中显示，开发者可以通过将此窗口组合到其他应用窗口中。<br/>-&nbsp;print：打印框架的ExtensionAbility。<br/>-&nbsp;push：推送的ExtensionAbility。<br/>-&nbsp;driver：驱动框架的ExtensionAbility。应用配置了driver类型的ExtensionAbility后会被视为驱动应用，驱动应用在安装、卸载和恢复时不会区分用户，且创建新用户时也会安装设备上已有的驱动应用。例如，创建子用户时会默认安装主用户已有的驱动应用，在子用户上卸载驱动应用时，主用户上对应的驱动应用也会同时被卸载。<br/>-&nbsp;remoteNotification：远程通知的ExtensionAbility。<br/>-&nbsp;remoteLocation：远程定位的ExtensionAbility。<br/>-&nbsp;voip：网络音视频通话的ExtensionAbility。<br/>-&nbsp;action：自定义操作业务模板的ExtensionAbility，为开发者提供基于UIExtension的自定义操作业务模板。<!--Del--><br/>-&nbsp;adsService：广告业务的ExtensionAbility，提供广告业务框架。<!--DelEnd--><br/>-&nbsp;embeddedUI：嵌入式UI扩展能力，提供跨进程界面嵌入的能力。<br/>-&nbsp;insightIntentUI：为开发者提供能被小艺意图调用，以窗口形态呈现内容的扩展能力。<br/>-&nbsp;ads：广告业务的ExtensionAbility，与AdComponent控件组合使用，将广告页面展示到其他应用中。仅支持设备厂商使用。<br/>-&nbsp;photoEditor：图片编辑业务的ExtensionAbility，为开发者提供基于UIExtension的图片编辑业务模版。<br/>-&nbsp;appAccountAuthorization：应用账号授权扩展能力的ExtensionAbility，用于处理账号授权请求，比如账号登录授权。<br/>-&nbsp;autoFill/password：用于账号和密码自动填充业务的ExtensionAbility，支持数据的保存、填充能力。<br/>-&nbsp;hms/account：应用账号管理能力的ExtensionAbility。<!--Del--><br/>-&nbsp;sysDialog/atomicServicePanel：提供构建原子化服务服务面板的基础能力的ExtensionAbility，使用时基于UIExtensionAbility实现。<br/>-&nbsp;sysDialog/userAuth：本地用户鉴权的ExtensionAbility。<br/>-&nbsp;sysDialog/common：通用弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/power：关机重启弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/print：打印模态弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/meetimeCall：畅连通话的ExtensionAbility。<br/>-&nbsp;sysDialog/meetimeContact：畅连联系人的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeMessage：畅连消息的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeContact：畅连联系人列表的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeCallLog：畅连通话记录列表的ExtensionAbility。<br/>-&nbsp;sysPicker/share：系统分享的ExtensionAbility。<br/>-&nbsp;sysPicker/mediaControl：投播组件的ExtensionAbility。<br/>-&nbsp;sysPicker/photoPicker：三方应用通过对应的UIExtensionType拉起图库picker界面。<br/>-&nbsp;sysPicker/filePicker：文件下载弹窗的ExtensionAbility。<br/>-&nbsp;sysPicker/audioPicker：音频管理弹窗的ExtensionAbility。<br/>-&nbsp;sysPicker/photoEditor：图片编辑弹窗的ExtensionAbility。<br/>-&nbsp;sys/commonUI：非通用的ExtensionAbility，提供业务属性强相关的嵌入式显示或弹框。<!--DelEnd--><br/>-&nbsp;autoFill/smart：用于情景化场景自动填充业务的ExtensionAbility，支持数据的保存、填充能力。<!--Del--><br/>-&nbsp;uiService：弹窗服务组件，在启动过程中会创建window，并支持双向通信。<!--DelEnd--> <!--RP9--><!--RP9End--><br/>-&nbsp;recentPhoto：最近照片推荐的ExtensionAbility。<br/>-&nbsp;fence：地理围栏的ExtensionAbility。<br/>-&nbsp;callerInfoQuery：企业联系人查询的ExtensionAbility。<br/>-&nbsp;assetAcceleration：资源预下载的ExtensionAbility。<br/>-&nbsp;formEdit：卡片编辑的ExtensionAbility。<br/>-&nbsp;distributed：分布式扩展的ExtensionAbility。<br/>-&nbsp;liveForm：互动卡片的[ExtensionAbility](../reference/apis-form-kit/js-apis-app-form-LiveFormExtensionAbility.md)。从API version 20开始，支持该标签。<br/>-&nbsp;appService：为应用提供后台服务相关扩展能力[AppServiceExtensionAbility](../reference/apis-ability-kit/js-apis-app-ability-appServiceExtensionAbility.md)，包括后台服务的创建、销毁、连接、断开等生命周期回调。从API version 20开始，支持该标签。<br/>-&nbsp;webNativeMessaging：为开发者提供Web原生消息通信能力的[ExtensionAbility](../reference/apis-arkweb/arkts-apis-web-webNativeMessagingExtensionAbility.md)。从API version 21开始，支持该标签。<br/>-&nbsp;faultLog：故障延迟通知的[ExtensionAbility](../reference/apis-performance-analysis-kit/js-apis-hiviewdfx-FaultLogExtensionAbility.md)。从API version 21开始，支持该标签。<br/>-&nbsp;notificationSubscriber：提供通知订阅相关功能的[ExtensionAbility](../reference/apis-notification-kit/js-apis-notificationSubscriberExtensionAbility.md)。从API version 22开始，支持该标签。<!--Del--><br/>-&nbsp;awc/webpage：通用网页浏览的ExtensionAbility。<br/>-&nbsp;awc/newsfeed：信息流资讯业务的ExtensionAbility。<br/>-&nbsp;selection：划词扩展的[ExtensionAbility](../reference/apis-basic-services-kit/js-apis-selectionInput-selectionExtensionAbility-sys.md)。从API version 20开始，支持该标签。<br/>-&nbsp;crypto：UKey驱动应用拓展的ExtensionAbility。<br/>**说明：**<br/>其中service、adsService、staticSubscriber、window、sys/commonUI、fileAccess、selection、sysDialog类型、sysPicker类型、dataShare类型和uiService类型，三方应用的配置不生效，当前配置仅在系统应用中有效。<!--DelEnd--> | 字符串 | 该标签不可缺省。 |460+| type | 标识当前ExtensionAbility组件的类型，支持的取值如下：<br/>-&nbsp;form：卡片的ExtensionAbility。<br/>-&nbsp;workScheduler：延时任务的ExtensionAbility。<br/>-&nbsp;inputMethod：输入法的ExtensionAbility。<!--Del--><br/>-&nbsp;service：后台运行的service组件。<!--DelEnd--><br/>-&nbsp;accessibility：辅助能力的ExtensionAbility。<!--Del--><br/>-&nbsp;fileAccess：公共数据访问的ExtensionAbility，允许应用程序提供文件和文件夹给文件管理类应用展示。<br/>-&nbsp;dataShare：数据共享的ExtensionAbility。<br/>-&nbsp;staticSubscriber：静态广播的ExtensionAbility。<!--DelEnd--><br/>-&nbsp;wallpaper：壁纸的ExtensionAbility。<br/>-&nbsp;backup：数据备份的ExtensionAbility。<br/>-&nbsp;enterpriseAdmin：[企业设备管理](../mdm/mdm-kit-admin.md)的ExtensionAbility。企业设备管理应用必须拥有此类型的ExtensionAbility。<!--Del--><br/>-&nbsp;window：该ExtensionAbility会在启动过程中创建一个window，为开发者提供界面开发。开发者开发出来的界面将通过UIExtensionComponent控件组合到其他应用的窗口中。<!--DelEnd--><br/>-&nbsp;thumbnail：获取文件缩略图的ExtensionAbility，开发者可以对自定义文件类型的文件提供缩略。<br/>-&nbsp;preview：该ExtensionAbility会将文件解析后在一个窗口中显示，开发者可以通过将此窗口组合到其他应用窗口中。<br/>-&nbsp;print：打印框架的ExtensionAbility。<br/>-&nbsp;push：推送的ExtensionAbility。<br/>-&nbsp;driver：驱动框架的ExtensionAbility。应用配置了driver类型的ExtensionAbility后会被视为驱动应用，驱动应用在安装、卸载和恢复时不会区分用户，且创建新用户时也会安装设备上已有的驱动应用。例如，创建子用户时会默认安装主用户已有的驱动应用，在子用户上卸载驱动应用时，主用户上对应的驱动应用也会同时被卸载。<br/>-&nbsp;remoteNotification：远程通知的ExtensionAbility。<br/>-&nbsp;remoteLocation：远程定位的ExtensionAbility。<br/>-&nbsp;voip：网络音视频通话的ExtensionAbility。<br/>-&nbsp;action：自定义操作业务模板的ExtensionAbility，为开发者提供基于UIExtension的自定义操作业务模板。<!--Del--><br/>-&nbsp;adsService：广告业务的ExtensionAbility，提供广告业务框架。<!--DelEnd--><br/>-&nbsp;embeddedUI：嵌入式UI扩展能力，提供跨进程界面嵌入的能力。<br/>-&nbsp;insightIntentUI：为开发者提供能被小艺意图调用，以窗口形态呈现内容的扩展能力。<br/>-&nbsp;ads：广告业务的ExtensionAbility，与AdComponent控件组合使用，将广告页面展示到其他应用中。仅支持设备厂商使用。<br/>-&nbsp;photoEditor：图片编辑业务的ExtensionAbility，为开发者提供基于UIExtension的图片编辑业务模版。<br/>-&nbsp;appAccountAuthorization：应用账号授权扩展能力的ExtensionAbility，用于处理账号授权请求，比如账号登录授权。<br/>-&nbsp;autoFill/password：用于账号和密码自动填充业务的ExtensionAbility，支持数据的保存、填充能力。<br/>-&nbsp;hms/account：应用账号管理能力的ExtensionAbility。<!--Del--><br/>-&nbsp;sysDialog/atomicServicePanel：提供构建原子化服务服务面板的基础能力的ExtensionAbility，使用时基于UIExtensionAbility实现。<br/>-&nbsp;sysDialog/userAuth：本地用户鉴权的ExtensionAbility。<br/>-&nbsp;sysDialog/common：通用弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/power：关机重启弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/print：打印模态弹窗的ExtensionAbility。<br/>-&nbsp;sysDialog/meetimeCall：畅连通话的ExtensionAbility。<br/>-&nbsp;sysDialog/meetimeContact：畅连联系人的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeMessage：畅连消息的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeContact：畅连联系人列表的ExtensionAbility。<br/>-&nbsp;sysPicker/meetimeCallLog：畅连通话记录列表的ExtensionAbility。<br/>-&nbsp;sysPicker/share：系统分享的ExtensionAbility。<br/>-&nbsp;sysPicker/mediaControl：投播组件的ExtensionAbility。<br/>-&nbsp;sysPicker/photoPicker：三方应用通过对应的UIExtensionType拉起图库picker界面。<br/>-&nbsp;sysPicker/filePicker：文件下载弹窗的ExtensionAbility。<br/>-&nbsp;sysPicker/audioPicker：音频管理弹窗的ExtensionAbility。<br/>-&nbsp;sysPicker/photoEditor：图片编辑弹窗的ExtensionAbility。<br/>-&nbsp;sys/commonUI：非通用的ExtensionAbility，提供业务属性强相关的嵌入式显示或弹框。<!--DelEnd--><br/>-&nbsp;autoFill/smart：用于情景化场景自动填充业务的ExtensionAbility，支持数据的保存、填充能力。<!--Del--><br/>-&nbsp;uiService：弹窗服务组件，在启动过程中会创建window，并支持双向通信。<!--DelEnd--> <!--RP9--><!--RP9End--><br/>-&nbsp;recentPhoto：最近照片推荐的ExtensionAbility。<br/>-&nbsp;fence：地理围栏的ExtensionAbility。<br/>-&nbsp;callerInfoQuery：企业联系人查询的ExtensionAbility。<br/>-&nbsp;assetAcceleration：资源预下载的ExtensionAbility。<br/>-&nbsp;formEdit：卡片编辑的ExtensionAbility。<br/>-&nbsp;distributed：分布式扩展的ExtensionAbility。<br/>-&nbsp;liveForm：互动卡片的[ExtensionAbility](../reference/apis-form-kit/js-apis-app-form-LiveFormExtensionAbility.md)。从API version 20开始，支持该标签。<br/>-&nbsp;appService：为应用提供后台服务相关扩展能力[AppServiceExtensionAbility](../reference/apis-ability-kit/js-apis-app-ability-appServiceExtensionAbility.md)，包括后台服务的创建、销毁、连接、断开等生命周期回调。从API version 20开始，支持该标签。<br/>-&nbsp;webNativeMessaging：为开发者提供Web原生消息通信能力的[ExtensionAbility](../reference/apis-arkweb/arkts-apis-web-webNativeMessagingExtensionAbility.md)。从API version 21开始，支持该标签。<br/>-&nbsp;faultLog：故障延迟通知的[ExtensionAbility](../reference/apis-performance-analysis-kit/js-apis-hiviewdfx-FaultLogExtensionAbility.md)。从API version 21开始，支持该标签。<br/>-&nbsp;notificationSubscriber：提供通知订阅相关功能的[ExtensionAbility](../reference/apis-notification-kit/js-apis-notificationSubscriberExtensionAbility.md)。从API version 22开始，支持该标签。<br/>-&nbsp;crypto：外部密钥管理扩展的[ExtensionAbility](../security/UniversalKeystoreKit/huks-extension-ability-support-dev.md)。从API version 22开始，支持该标签。<!--Del--><br/>-&nbsp;awc/webpage：通用网页浏览的ExtensionAbility。<br/>-&nbsp;awc/newsfeed：信息流资讯业务的ExtensionAbility。<br/>-&nbsp;selection：划词扩展的[ExtensionAbility](../reference/apis-basic-services-kit/js-apis-selectionInput-selectionExtensionAbility-sys.md)。从API version 20开始，支持该标签。<br/>**说明：**<br/>其中service、adsService、staticSubscriber、window、sys/commonUI、fileAccess、selection、sysDialog类型、sysPicker类型、dataShare类型和uiService类型，三方应用的配置不生效，当前配置仅在系统应用中有效。<!--DelEnd--> | 字符串 | 该标签不可缺省。 |
461| permissions | 标识当前ExtensionAbility组件的权限信息。当其他应用访问该ExtensionAbility时，需要申请相应的权限。<br/>一个数组元素为一个权限名称。不超过255字节，取值请参考[应用权限列表](../security/AccessToken/app-permissions.md)。 | 字符串数组 | 该标签可缺省，缺省值为空。 |461| permissions | 标识当前ExtensionAbility组件的权限信息。当其他应用访问该ExtensionAbility时，需要申请相应的权限。<br/>一个数组元素为一个权限名称。不超过255字节，取值请参考[应用权限列表](../security/AccessToken/app-permissions.md)。 | 字符串数组 | 该标签可缺省，缺省值为空。 |
462| appIdentifierAllowList | 标识允许启动此ExtensionAbility的应用程序列表。<br/>一个数组元素为一个应用程序的appIdentifier，appIdentifier信息可参考[什么是appIdentifier](../quick-start/common_problem_of_application.md#什么是appidentifier)。<br/>**说明：**<br/>仅当ExtensionAbility组件的type为appService时支持配置该标签。<br/>从API version 20开始，支持该标签。 | 字符串数组 | 该标签可缺省，缺省值为空。 |462| appIdentifierAllowList | 标识允许启动此ExtensionAbility的应用程序列表。<br/>一个数组元素为一个应用程序的appIdentifier，appIdentifier信息可参考[什么是appIdentifier](../quick-start/common_problem_of_application.md#什么是appidentifier)。<br/>**说明：**<br/>仅当ExtensionAbility组件的type为appService时支持配置该标签。<br/>从API version 20开始，支持该标签。 | 字符串数组 | 该标签可缺省，缺省值为空。 |
463| readPermission | 标识读取当前ExtensionAbility组件数据所需的权限，取值为长度不超过255字节的字符串。仅当预置的系统应用ExtensionAbility的type配置为dataShare时，该标签生效。dataShare类型仅支持系统应用支持配置，三方应用配置不生效。 | 字符串 | 该标签可缺省，缺省值为空。 |463| readPermission | 标识读取当前ExtensionAbility组件数据所需的权限，取值为长度不超过255字节的字符串。仅当预置的系统应用ExtensionAbility的type配置为dataShare时，该标签生效。dataShare类型仅支持系统应用支持配置，三方应用配置不生效。 | 字符串 | 该标签可缺省，缺省值为空。 |
Mzh-cn/application-dev/reference/apis-ability-kit/js-apis-bundleManager.md+1-0
@@ -78,6 +78,7 @@ import { bundleManager } from '@kit.AbilityKit';
78| WEB_NATIVE_MESSAGING<sup>21+</sup> | 32 | [WebNativeMessagingExtensionAbility](../apis-arkweb/arkts-apis-web-webNativeMessagingExtensionAbility.md)：为开发者提供Web原生消息通信能力的ExtensionAbility。|78| WEB_NATIVE_MESSAGING<sup>21+</sup> | 32 | [WebNativeMessagingExtensionAbility](../apis-arkweb/arkts-apis-web-webNativeMessagingExtensionAbility.md)：为开发者提供Web原生消息通信能力的ExtensionAbility。|
79| FAULT_LOG<sup>21+</sup> | 33 | [FaultLogExtensionAbility](../apis-performance-analysis-kit/js-apis-hiviewdfx-FaultLogExtensionAbility.md)：提供故障延迟通知的能力。|79| FAULT_LOG<sup>21+</sup> | 33 | [FaultLogExtensionAbility](../apis-performance-analysis-kit/js-apis-hiviewdfx-FaultLogExtensionAbility.md)：提供故障延迟通知的能力。|
80| NOTIFICATION_SUBSCRIBER<sup>22+</sup> | 34 | [NotificationSubscriberExtensionAbility](../apis-notification-kit/js-apis-notificationSubscriberExtensionAbility.md)：提供通知订阅的相关功能。|80| NOTIFICATION_SUBSCRIBER<sup>22+</sup> | 34 | [NotificationSubscriberExtensionAbility](../apis-notification-kit/js-apis-notificationSubscriberExtensionAbility.md)：提供通知订阅的相关功能。|
81+| CRYPTO<sup>22+</sup> | 35 | [CryptoExtensionAbility](../../security/UniversalKeystoreKit/huks-extension-ability-support-dev.md)：提供外部密钥管理扩展的相关功能。|
81| UNSPECIFIED | 255 | 不指定类型<!--Del-->，配合[queryExtensionAbilityInfo接口](js-apis-bundleManager-sys.md#bundlemanagerqueryextensionabilityinfo)可以查询所有类型的ExtensionAbility<!--DelEnd-->。 |82| UNSPECIFIED | 255 | 不指定类型<!--Del-->，配合[queryExtensionAbilityInfo接口](js-apis-bundleManager-sys.md#bundlemanagerqueryextensionabilityinfo)可以查询所有类型的ExtensionAbility<!--DelEnd-->。 |
82<!--RP2--><!--RP2End-->83<!--RP2--><!--RP2End-->
83 84 
Mzh-cn/application-dev/reference/apis-universal-keystore-kit/Readme-CN.md+2-0
@@ -8,6 +8,8 @@
8 8 
9- ArkTS API<!--universal-keystore-arkts-->9- ArkTS API<!--universal-keystore-arkts-->
10 - [@ohos.security.huks (通用密钥库系统)](js-apis-huks.md)10 - [@ohos.security.huks (通用密钥库系统)](js-apis-huks.md)
11+ - [@ohos.security.huksExternalCrypto (外部密钥管理)](js-apis-huksExternalCrypto.md)
12+ - [@ohos.security.CryptoExtensionAbility (密钥扩展能力)](js-apis-CryptoExtensionAbility.md)
11 <!--Del-->13 <!--Del-->
12 - [@ohos.security.huks (通用密钥库系统)(系统接口)](js-apis-huks-sys.md)14 - [@ohos.security.huks (通用密钥库系统)(系统接口)](js-apis-huks-sys.md)
13 <!--DelEnd-->15 <!--DelEnd-->
Mzh-cn/application-dev/reference/apis-universal-keystore-kit/errorcode-huks.md+130-5
@@ -122,15 +122,15 @@ Invalid ``${messageInfo}``.
122 122 
123**错误信息**123**错误信息**
124 124 
125-Crypto engine error.125+Crypto engine error or Ukey driver error.
126 126 
127**错误描述**127**错误描述**
128 128 
129-算法库操作失败。129+算法库操作失败或者Ukey驱动失败。
130 130 
131**可能原因**131**可能原因**
132 132 
133-该错误码表示算法库操作失败，可能原因如下。133+该错误码表示算法库操作失败或者Ukey驱动失败，可能原因如下。
134 134 
1351. 算法库加解密错误，可能是密文数据不对。1351. 算法库加解密错误，可能是密文数据不对。
1362. 密钥参数不正确。1362. 密钥参数不正确。
@@ -215,14 +215,14 @@ The number of key operation sessions has reached the limit.
215 215 
216**处理步骤**216**处理步骤**
217 217 
218-1. 检查同应用内部是否同时存在多个密钥会话操作（init)，存在则修改避免同时调用。218+1. 检查同应用内部是否同时存在多个密钥会话操作（init），存在则修改避免同时调用。
2192. 如不存在上述情形，则可能是其它应用同时调用多个会话，通过等待其它应用释放会话后再使用。2192. 如不存在上述情形，则可能是其它应用同时调用多个会话，通过等待其它应用释放会话后再使用。
220 220 
221## 12000011 目标对象不存在221## 12000011 目标对象不存在
222 222 
223**错误信息**223**错误信息**
224 224 
225-The entity does not exist.225+Queried entity does not exist.
226 226 
227**错误描述**227**错误描述**
228 228 
@@ -358,3 +358,128 @@ The input parameter is invalid.
358 358 
359请检查必选参数是否传入，或者传入的参数类型是否错误。对于参数校验失败原因，请阅读参数规格约束，按照可能原因进行排查。359请检查必选参数是否传入，或者传入的参数类型是否错误。对于参数校验失败原因，请阅读参数规格约束，按照可能原因进行排查。
360 360 
361+## 12000019 同名provider已注册
362+ 
363+**错误信息**
364+ 
365+The provider is already registered.
366+ 
367+**错误描述**
368+ 
369+注册的provider已存在。
370+ 
371+**可能原因**
372+ 
373+注册的provider已存在。
374+ 
375+**处理步骤**
376+ 
377+检查注册的provider是否正确，如果确定没问题，则需要先注销，再注册。
378+ 
379+## 12000020 依赖的模块报错
380+ 
381+**错误信息**
382+ 
383+The provider operation failed.
384+ 
385+**错误描述**
386+ 
387+下游依赖的模块报错。
388+ 
389+**可能原因**
390+ 
391+下游依赖的模块报错。
392+ 
393+**处理步骤**
394+ 
395+根据下游返回的error code或者error message查看下游模块具体报错的原因。
396+ 
397+## 12000021 Ukey PIN码被锁
398+ 
399+**错误信息**
400+ 
401+The Ukey PIN is locked.
402+ 
403+**错误描述**
404+ 
405+Ukey PIN码被锁。
406+ 
407+**可能原因**
408+ 
409+PIN码输入错误次数过多导致被锁。
410+ 
411+**处理步骤**
412+ 
413+咨询相关银行，解锁Ukey。
414+ 
415+## 12000022 Ukey PIN码错误
416+ 
417+**错误信息**
418+ 
419+The Ukey PIN is incorrect.
420+ 
421+**错误描述**
422+ 
423+Ukey PIN码错误。
424+ 
425+**可能原因**
426+ 
427+PIN码输入错误。
428+ 
429+**处理步骤**
430+ 
431+输入正确PIN码。
432+ 
433+## 12000023 Ukey PIN码未认证
434+ 
435+**错误信息**
436+ 
437+The Ukey PIN is not authenticated.
438+ 
439+**错误描述**
440+ 
441+Ukey PIN码未认证。
442+ 
443+**可能原因**
444+ 
445+执行操作需要进行PIN码认证，但实际PIN码尚未认证。
446+ 
447+**处理步骤**
448+ 
449+执行操作需要进行PIN码认证，但实际PIN码尚未认证。
450+ 
451+## 12000024 设备或资源繁忙
452+ 
453+**错误信息**
454+ 
455+The provider or Ukey is busy.
456+ 
457+**错误描述**
458+ 
459+设备或资源繁忙。
460+ 
461+**可能原因**
462+ 
463+设备或资源繁忙。
464+ 
465+**处理步骤**
466+ 
467+再次重试或者插拔Ukey后重试。
468+ 
469+## 12000025 资源超过限制
470+ 
471+**错误信息**
472+ 
473+The resource exceeds the limit.
474+ 
475+**错误描述**
476+ 
477+资源超过限制。
478+ 
479+**可能原因**
480+ 
481+资源超过限制。
482+ 
483+**处理步骤**
484+ 
485+检查是否有未释放资源，释放已有资源后重试。
Azh-cn/application-dev/reference/apis-universal-keystore-kit/js-apis-CryptoExtensionAbility.md+497-0
@@ -0,0 +1,497 @@
1+# @ohos.security.CryptoExtensionAbility (密钥扩展能力)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+模块提供外部密钥扩展能力，包括资源管理、PIN码认证管理、密码操作、通用操作等接口能力。
11+ 
12+ExtensionAbility实现约束：
13+1. 设备管理，单个ExtensionAbility实现，最多支持10个Ukey接入。
14+2. 句柄管理，针对同一个Ukey资源（例如，容器下的密钥），支持应用维度资源句柄管理。
15+ - 支持多个OpenHarmony应用，打开同一个Ukey密钥资源。例如：OpenHarmony应用1打开容器A后，OpenHarmony应用2也可以再次打开容器A。
16+ - 支持多个OpenHarmony应用，操作同一个Ukey密钥资源。例如：OpenHarmony应用1操作容器A中的私钥签名后，OpenHarmony应用2也验证PIN码后，也可以操作容器A中的私钥进行签名，两者互不影响。
17+3. 密钥会话管理，支持三段式密钥管理操作，单次签名验签需通过[onInitSession](#cryptoextensionabilityoninitsession)/[onUpdateSession](#cryptoextensionabilityonupdatesession)/[onFinishSession](#cryptoextensionabilityonfinishsession)s三个函数三步配合完成，需支持会话管理，缓存密钥会话状态。
18+ - init操作，初始化密钥会话，并返回会话句柄信息。
19+ - update操作，传入分组数据，对分组数据进行密码操作，更新密钥会话信息后，将中间数据（如果有）返回。
20+ - finish操作，对传入最后一段分组数据，进行密钥返回操作，并结束密钥会话，将最终结果返回。
21+4. 认证状态管理，支持应用维度的认证状态管理。针对同一个Ukey中的应用A，OpenHarmony应用1验证Ukey应用A的PIN码后，OpenHarmony应用2如果要访问Ukey应用A，也需要进行PIN码认证操作。
22+5. 证书查询，支持根据证书类型，枚举所有证书或查询单个容器中的证书。
23+ 
24+> **说明**
25+>
26+> 本模块首批接口从API version 22开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
27+ 
28+## 导入模块
29+ 
30+```ts
31+import { huks, huksExternalCrypto, CryptoExtensionAbility } from '@kit.UniversalKeystoreKit';
32+```
33+ 
34+## HuksCryptoExtensionCertInfo
35+ 
36+[HuksCryptoExtensionResult](#hukscryptoextensionresult)中的certs数组中的元素。
37+ 
38+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
39+ 
40+| 名称 | 类型 | 只读 | 可选 | 说明 |
41+| ------ | --------- | ---- | ---- | ------ |
42+| purpose | [certificateManager.CertificatePurpose](../apis-device-certificate-kit/js-apis-certManager.md#certificatepurpose22) | 否 | 否 | 表示证书链对应密钥的使用类型。 |
43+| resourceId | string | 否 | 否 | 资源ID。 |
44+| cert | Uint8Array | 否 | 否 | 证书。 |
45+ 
46+## HuksCryptoExtensionResult
47+ 
48+接口返回值的通用类型。
49+ 
50+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
51+ 
52+| 名称 | 类型 | 只读 | 可选 | 说明 |
53+| ------ | ------ | ---- | ---- | ------ |
54+| resultCode | int | 否 | 否 | 返回值的错误码。 |
55+| handle | string | 否 | 是 | 资源句柄。 |
56+| authState | int | 否 | 是 | 认证状态。 |
57+| retryCount | int | 否 | 是 | 重试次数。 |
58+| certs | Array<[HuksCryptoExtensionCertInfo](#hukscryptoextensioncertinfo)> | 否 | 是 | 证书。 |
59+| property | Array<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 否 | 是 | 属性。 |
60+| outData | int | 否 | 是 | 返回的数据。 |
61+ 
62+## cryptoExtensionAbility.onOpenResource
63+ 
64+onOpenResource(resourceId: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
65+ 
66+根据参数中的resourceId，打开Ukey的密钥资源。使用Promise异步回调。
67+ 
68+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
69+ 
70+**参数：**
71+ 
72+| 参数名 | 类型 | 必填 | 说明 |
73+| -------- | --------- | ---- | -------- |
74+| resourceId | string | 是 | 资源ID。 |
75+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
76+ 
77+**返回值：**
78+ 
79+| 类型 | 说明 |
80+| ---------- | ----------- |
81+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，handle携带资源句柄信息。调用失败时，resultCode携带错误码信息。 |
82+ 
83+**示例：**
84+ 
85+```ts
86+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
87+ 
88+export default class CryptoExtension extends CryptoExtensionAbility {
89+ onOpenResource(resourceId: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
90+ // 解析resourceId，打开底层句柄，并映射为新的句柄返回。
91+ let result: HuksCryptoExtensionResult = {
92+ resultCode: 0,
93+ handle: "test handle"
94+ };
95+ 
96+ // ...
97+ return Promise.resolve(result)
98+ }
99+}
100+```
101+ 
102+## cryptoExtensionAbility.onCloseResource
103+ 
104+onCloseResource(handle: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
105+ 
106+根据参数中的handle，关闭Ukey的密钥资源。使用Promise异步回调。
107+ 
108+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
109+ 
110+**参数：**
111+ 
112+| 参数名 | 类型 | 必填 | 说明 |
113+| -------- | ------ | ---- | ------ |
114+| handle | string | 是 | 会话句柄。 |
115+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
116+ 
117+**返回值：**
118+ 
119+| 类型 | 说明 |
120+| ----------- | ------------- |
121+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，表示关闭资源成功。调用失败时，resultCode携带错误码信息。 |
122+ 
123+**示例：**
124+ 
125+```ts
126+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
127+ 
128+export default class CryptoExtension extends CryptoExtensionAbility {
129+ onCloseResource(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
130+ // 执行句柄关闭操作。如果需要关闭底层句柄，则执行关闭操作。
131+ const result: HuksCryptoExtensionResult = {
132+ resultCode: 0,
133+ };
134+ 
135+ // ...
136+ return Promise.resolve(result)
137+ }
138+}
139+```
140+ 
141+## cryptoExtensionAbility.onGetProperty
142+ 
143+onGetProperty(handle: string, propertyId: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
144+ 
145+根据参数中的handle和propertyId获取属性。使用Promise异步回调。
146+ 
147+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
148+ 
149+**参数：**
150+ 
151+| 参数名 | 类型 | 必填 | 说明 |
152+| -------- | ----- | ---- | ------|
153+| handle | string | 是 | 资源句柄。 |
154+| propertyId | string | 是 | 查找操作的属性名称，是GMT 0016-2023中定义的SKF接口名，要业务针对接口名适配。 |
155+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
156+ 
157+**返回值：**
158+ 
159+| 类型 | 说明 |
160+| -------- | -----------|
161+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，HuksCryptoExtensionResult的property成员非空，包含获取到的属性，由[HUKS_EXT_CRYPTO_TAG_EXTRA_DATA](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。调用失败时，resultCode携带错误码信息。 |
162+ 
163+**示例：**
164+ 
165+```ts
166+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
167+ 
168+export default class CryptoExtension extends CryptoExtensionAbility {
169+ onGetProperty(handle: string, propertyId: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
170+ // 按照propertyId执行相关函数，函数参数从params中获取。输出数据封装到返回值的property字段中，由HUKS_EXT_CRYPTO_TAG_EXTRA_DATA携带。
171+ const emptyArray: Array<huksExternalCrypto.HuksExternalCryptoParam> = [];
172+ const result: HuksCryptoExtensionResult = {
173+ resultCode: 0,
174+ property: emptyArray
175+ };
176+ 
177+ // ...
178+ return Promise.resolve(result)
179+ }
180+}
181+```
182+ 
183+## cryptoExtensionAbility.onAuthUkeyPin
184+ 
185+onAuthUkeyPin(handle: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
186+ 
187+请求Ukey认证PIN码。使用Promise异步回调。
188+ 
189+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
190+ 
191+**参数：**
192+ 
193+| 参数名 | 类型 | 必填 | 说明 |
194+| ------ | ------ | ---- | ------- |
195+| handle | string | 是 | 资源句柄。 |
196+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
197+ 
198+**返回值：**
199+ 
200+| 类型 | 说明 |
201+| -------- | --------|
202+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，authState非0，表示认证请求成功。调用失败时，resultCode携带错误码信息。 |
203+ 
204+**示例：**
205+ 
206+```ts
207+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
208+ 
209+export default class CryptoExtension extends CryptoExtensionAbility {
210+ onAuthUkeyPin(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
211+ // 执行PIN码认证操作，并且维护应用的PIN码认证状态。
212+ const result: HuksCryptoExtensionResult = {
213+ resultCode: 0,
214+ authState: 1
215+ };
216+ 
217+ // ...
218+ return Promise.resolve(result)
219+ }
220+}
221+```
222+ 
223+## cryptoExtensionAbility.onGetUkeyPinAuthState
224+ 
225+onGetUkeyPinAuthState(handle: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
226+ 
227+获取Ukey的PIN码认证状态。使用Promise异步回调。
228+ 
229+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
230+ 
231+**参数：**
232+ 
233+| 参数名 | 类型 | 必填 | 说明 |
234+| -------- | ------- | ---- | -------|
235+| handle | string | 是 | 资源句柄。 |
236+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
237+ 
238+**返回值：**
239+ 
240+| 类型 | 说明 |
241+| -------- | ------- |
242+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，HuksCryptoExtensionResult的authState成员非空，为获取的PIN码认证状态。调用失败时，resultCode携带错误码信息。 |
243+ 
244+**示例：**
245+ 
246+```ts
247+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
248+ 
249+export default class CryptoExtension extends CryptoExtensionAbility {
250+ onGetUkeyPinAuthState(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
251+ // 查询PIN码认证状态。
252+ const result: HuksCryptoExtensionResult = {
253+ resultCode: 0,
254+ authState: 1
255+ };
256+ 
257+ // ...
258+ return Promise.resolve(result)
259+ }
260+}
261+```
262+ 
263+## cryptoExtensionAbility.onClearUkeyPinAuthState
264+ 
265+onClearUkeyPinAuthState(handle: string, params: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
266+ 
267+清除应用维度PIN码的认证状态。使用Promise异步回调。
268+ 
269+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
270+ 
271+**参数：**
272+ 
273+| 参数名 | 类型 | 必填 | 说明 |
274+| -------- | ----- | ---- | ------|
275+| handle | string | 是 | 会话句柄。 |
276+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
277+ 
278+**返回值：**
279+ 
280+| 类型 | 说明 |
281+| ------------ | ---------|
282+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，表示清除PIN码认证状态成功。调用失败时，resultCode携带错误码信息。 |
283+ 
284+**示例：**
285+ 
286+```ts
287+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
288+ 
289+export default class CryptoExtension extends CryptoExtensionAbility {
290+ onClearUkeyPinAuthState(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
291+ const result: HuksCryptoExtensionResult = {
292+ resultCode: 0
293+ };
294+ 
295+ // ...
296+ return Promise.resolve(result)
297+ }
298+}
299+```
300+ 
301+## cryptoExtensionAbility.onInitSession
302+ 
303+onInitSession(handle: string, params: huks.HuksOptions): Promise\<HuksCryptoExtensionResult>
304+ 
305+三段式初始化密钥会话操作。使用Promise异步回调。
306+ 
307+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
308+ 
309+**参数：**
310+ 
311+| 参数名 | 类型 | 必填 | 说明 |
312+| -------- | ----- | ---- | ------- |
313+| handle | string | 是 | 资源句柄。|
314+| params | [HuksOptions](js-apis-huks.md#huksoptions) | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
315+ 
316+**返回值：**
317+ 
318+| 类型 | 说明 |
319+| --------- | ---------|
320+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0，handle成员非空。调用失败时，resultCode携带错误码信息。 |
321+ 
322+**示例：**
323+ 
324+```ts
325+import { huks, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
326+ 
327+export default class CryptoExtension extends CryptoExtensionAbility {
328+ onInitSession(handle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
329+ const result: HuksCryptoExtensionResult = {
330+ resultCode: 0,
331+ handle: "test handle"
332+ };
333+ 
334+ // ...
335+ return Promise.resolve(result)
336+ }
337+}
338+```
339+ 
340+## cryptoExtensionAbility.onUpdateSession
341+ 
342+onUpdateSession(handle: string, params: huks.HuksOptions): Promise\<HuksCryptoExtensionResult>
343+ 
344+三段式密钥会话更新数据操作。使用Promise异步回调。
345+ 
346+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
347+ 
348+**参数：**
349+ 
350+| 参数名 | 类型 | 必填 | 说明 |
351+| -------- | ----- | ---- | ------|
352+| handle | string | 是 | 资源句柄。 |
353+| params | [HuksOptions](js-apis-huks.md#huksoptions) | 是 | 传入的参数，应用身份通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带。 |
354+ 
355+**返回值：**
356+ 
357+| 类型 | 说明 |
358+| --------- | ---------|
359+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0。调用失败时，resultCode携带错误码信息。 |
360+ 
361+**示例：**
362+ 
363+```ts
364+import { huks, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
365+ 
366+export default class CryptoExtension extends CryptoExtensionAbility {
367+ onUpdateSession(initHandle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
368+ const certs: Array<CryptoExtensionAbility.HuksCryptoExtensionCertInfo> = [];
369+ const result: HuksCryptoExtensionResult = {
370+ resultCode: 0,
371+ outData: certs
372+ };
373+ 
374+ // ...
375+ return Promise.resolve(result)
376+ }
377+}
378+```
379+ 
380+## cryptoExtensionAbility.onFinishSession
381+ 
382+onFinishSession(handle: string, params: huks.HuksOptions): Promise\<HuksCryptoExtensionResult>
383+ 
384+三段式密钥会话结束操作。使用Promise异步回调。
385+ 
386+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
387+ 
388+**参数：**
389+ 
390+| 参数名 | 类型 | 必填 | 说明 |
391+| -------- | -------- | ---- | --------- |
392+| handle | string | 是 | 资源句柄。 |
393+| params | [HuksOptions](js-apis-huks.md#huksoptions) | 是 | 传入的参数，应用身份可通过[HUKS_EXT_CRYPTO_TAG_UID](js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数携带，还包括算法参数（算法类型、填充模式等）。 |
394+ 
395+**返回值：**
396+ 
397+| 类型 | 说明 |
398+| ------- | ---------- |
399+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，resultCode为0。调用失败时，resultCode携带错误码信息。 |
400+ 
401+**示例：**
402+ 
403+```ts
404+import { huks, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
405+ 
406+export default class CryptoExtension extends CryptoExtensionAbility {
407+ onFinishSession(initHandle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
408+ const certs: Array<CryptoExtensionAbility.HuksCryptoExtensionCertInfo> = [];
409+ const result: HuksCryptoExtensionResult = {
410+ resultCode: 0,
411+ outData: certs
412+ };
413+ 
414+ // ...
415+ return Promise.resolve(result)
416+ }
417+}
418+```
419+ 
420+## cryptoExtensionAbility.onExportCertificate
421+ 
422+onExportCertificate(resourceId: string, params?: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
423+ 
424+查询指定resourceId下的证书。使用Promise异步回调。
425+ 
426+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
427+ 
428+**参数：**
429+ 
430+| 参数名 | 类型 | 必填 | 说明 |
431+| -------- | ---------- | ---- | --------- |
432+| resourceId | string | 是 | 资源ID。会附带在[HuksCryptoExtensionCertInfo](#hukscryptoextensioncertinfo)中。 |
433+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 否 | 操作属性。默认获取签名类型的证书，也可以通过参数[HUKS_EXT_CRYPTO_TAG_PURPOSE](js-apis-huksExternalCrypto.md#huksexternalcryptotag)指定获取证书类型，支持的类型包括签名验签、加解密等。 |
434+ 
435+**返回值：**
436+ 
437+| 类型 | 说明 |
438+| ---------- | --------- |
439+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，certs成员非空，包含获取的单本证书。调用失败时，resultCode携带错误码信息。 |
440+ 
441+**示例：**
442+ 
443+```ts
444+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
445+ 
446+export default class CryptoExtension extends CryptoExtensionAbility {
447+ onExportCertificate(resourceId: string, params?: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
448+ const certInfoSetArray: Array<CryptoExtensionAbility.HuksCryptoExtensionCertInfo> = []
449+ const result: HuksCryptoExtensionResult = {
450+ resultCode: 0,
451+ certs: certInfoSetArray
452+ };
453+ 
454+ // ...
455+ return Promise.resolve(result)
456+ }
457+}
458+```
459+ 
460+## cryptoExtensionAbility.onEnumCertificates
461+ 
462+onEnumCertificates(params?: Array\<huksExternalCrypto.HuksExternalCryptoParam>): Promise\<HuksCryptoExtensionResult>
463+ 
464+枚举Extension下所有Ukey设备的证书信息。使用Promise异步回调。
465+ 
466+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
467+ 
468+**参数：**
469+ 
470+| 参数名 | 类型 | 必填 | 说明 |
471+| -------- | -----| ---- | ---------- |
472+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 否 | 操作属性。默认获取签名类型的[证书](../../security/DeviceCertificateKit/certManager-overview.md)，也可以通过参数[HUKS_EXT_CRYPTO_TAG_PURPOSE](js-apis-huksExternalCrypto.md#huksexternalcryptotag)指定获取证书类型，支持的类型包括签名验签、加解密等。 |
473+ 
474+**返回值：**
475+ 
476+| 类型 | 说明 |
477+| ---------- | ---------|
478+| Promise\<[HuksCryptoExtensionResult](#hukscryptoextensionresult)> | Promise对象。当调用成功时，certs成员非空，包含获取的所有证书。调用失败时，resultCode携带错误码信息。 |
479+ 
480+**示例：**
481+ 
482+```ts
483+import { huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
484+ 
485+export default class CryptoExtension extends CryptoExtensionAbility {
486+ onEnumCertificates(params?: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
487+ const certInfoSetArray: Array<CryptoExtensionAbility.HuksCryptoExtensionCertInfo> = []
488+ const result: HuksCryptoExtensionResult = {
489+ resultCode: 0,
490+ certs: certInfoSetArray
491+ };
492+ 
493+ // ...
494+ return Promise.resolve(result)
495+ }
496+}
497+```
Mzh-cn/application-dev/reference/apis-universal-keystore-kit/js-apis-huks.md+53-6
@@ -1855,12 +1855,16 @@ initSession操作密钥接口，使用Callback回调异步返回结果。huks.in
1855| 12000003 | algorithm param is invalid. |1855| 12000003 | algorithm param is invalid. |
1856| 12000004 | operating file failed. |1856| 12000004 | operating file failed. |
1857| 12000005 | IPC communication failed. |1857| 12000005 | IPC communication failed. |
1858-| 12000006 | error occurred in crypto engine. |1858+| 12000006 | error occurred in crypto engine or Ukey driver. |
1859| 12000010 | the number of sessions has reached limit. |1859| 12000010 | the number of sessions has reached limit. |
1860| 12000011 | queried entity does not exist. |1860| 12000011 | queried entity does not exist. |
1861| 12000012 | Device environment or input parameter abnormal. |1861| 12000012 | Device environment or input parameter abnormal. |
1862| 12000014 | memory is insufficient. |1862| 12000014 | memory is insufficient. |
1863| 12000018 | the input parameter is invalid. |1863| 12000018 | the input parameter is invalid. |
1864+| 12000020 | the provider operation failed. |
1865+| 12000021 | the Ukey PIN is locked. |
1866+| 12000023 | the Ukey PIN not authenticated. |
1867+| 12000024 | the provider or Ukey is busy. |
1864 1868 
1865## huks.initSession<sup>9+</sup>1869## huks.initSession<sup>9+</sup>
1866 1870 
@@ -1898,12 +1902,16 @@ initSession操作密钥接口，使用Promise方式异步返回结果。huks.ini
1898| 12000003 | algorithm param is invalid. |1902| 12000003 | algorithm param is invalid. |
1899| 12000004 | operating file failed. |1903| 12000004 | operating file failed. |
1900| 12000005 | IPC communication failed. |1904| 12000005 | IPC communication failed. |
1901-| 12000006 | error occurred in crypto engine. |1905+| 12000006 | error occurred in crypto engine or Ukey driver. |
1902| 12000010 | the number of sessions has reached limit. |1906| 12000010 | the number of sessions has reached limit. |
1903| 12000011 | queried entity does not exist. |1907| 12000011 | queried entity does not exist. |
1904| 12000012 | Device environment or input parameter abnormal. |1908| 12000012 | Device environment or input parameter abnormal. |
1905| 12000014 | memory is insufficient. |1909| 12000014 | memory is insufficient. |
1906| 12000018 | the input parameter is invalid. |1910| 12000018 | the input parameter is invalid. |
1911+| 12000020 | the provider operation failed. |
1912+| 12000021 | the Ukey PIN is locked. |
1913+| 12000023 | the Ukey PIN not authenticated. |
1914+| 12000024 | the provider or Ukey is busy. |
1907 1915 
1908## huks.updateSession<sup>9+</sup>1916## huks.updateSession<sup>9+</sup>
1909 1917 
@@ -1980,13 +1988,17 @@ huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需
1980| 12000003 | algorithm param is invalid. |1988| 12000003 | algorithm param is invalid. |
1981| 12000004 | operating file failed. |1989| 12000004 | operating file failed. |
1982| 12000005 | IPC communication failed. |1990| 12000005 | IPC communication failed. |
1983-| 12000006 | error occurred in crypto engine. |1991+| 12000006 | error occurred in crypto engine or Ukey driver. |
1984| 12000007 | this credential is already invalidated permanently. |1992| 12000007 | this credential is already invalidated permanently. |
1985| 12000008 | verify auth token failed. |1993| 12000008 | verify auth token failed. |
1986| 12000009 | auth token is already timeout. |1994| 12000009 | auth token is already timeout. |
1987| 12000011 | queried entity does not exist. |1995| 12000011 | queried entity does not exist. |
1988| 12000012 | Device environment or input parameter abnormal. |1996| 12000012 | Device environment or input parameter abnormal. |
1989| 12000014 | memory is insufficient. |1997| 12000014 | memory is insufficient. |
1998+| 12000020 | the provider operation failed. |
1999+| 12000021 | the Ukey PIN is locked. |
2000+| 12000023 | the Ukey PIN not authenticated. |
2001+| 12000024 | the provider or Ukey is busy. |
1990 2002 
1991## huks.updateSession<sup>9+</sup>2003## huks.updateSession<sup>9+</sup>
1992 2004 
@@ -2027,13 +2039,17 @@ huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需
2027| 12000003 | algorithm param is invalid. |2039| 12000003 | algorithm param is invalid. |
2028| 12000004 | operating file failed. |2040| 12000004 | operating file failed. |
2029| 12000005 | IPC communication failed. |2041| 12000005 | IPC communication failed. |
2030-| 12000006 | error occurred in crypto engine. |2042+| 12000006 | error occurred in crypto engine or Ukey driver. |
2031| 12000007 | this credential is already invalidated permanently. |2043| 12000007 | this credential is already invalidated permanently. |
2032| 12000008 | verify auth token failed. |2044| 12000008 | verify auth token failed. |
2033| 12000009 | auth token is already timeout. |2045| 12000009 | auth token is already timeout. |
2034| 12000011 | queried entity does not exist. |2046| 12000011 | queried entity does not exist. |
2035| 12000012 | Device environment or input parameter abnormal. |2047| 12000012 | Device environment or input parameter abnormal. |
2036| 12000014 | memory is insufficient. |2048| 12000014 | memory is insufficient. |
2049+| 12000020 | the provider operation failed. |
2050+| 12000021 | the Ukey PIN is locked. |
2051+| 12000023 | the Ukey PIN not authenticated. |
2052+| 12000024 | the provider or Ukey is busy. |
2037 2053 
2038## huks.finishSession<sup>9+</sup>2054## huks.finishSession<sup>9+</sup>
2039 2055 
@@ -2076,6 +2092,10 @@ huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需
2076| 12000012 | Device environment or input parameter abnormal. |2092| 12000012 | Device environment or input parameter abnormal. |
2077| 12000014 | memory is insufficient. |2093| 12000014 | memory is insufficient. |
2078| 12000017 | The key with same alias is already exist. |2094| 12000017 | The key with same alias is already exist. |
2095+| 12000020 | the provider operation failed. |
2096+| 12000021 | the Ukey PIN is locked. |
2097+| 12000023 | the Ukey PIN not authenticated. |
2098+| 12000024 | the provider or Ukey is busy. |
2079 2099 
2080## huks.finishSession<sup>9+</sup>2100## huks.finishSession<sup>9+</sup>
2081 2101 
@@ -2167,6 +2187,10 @@ huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需
2167| 12000012 | Device environment or input parameter abnormal. |2187| 12000012 | Device environment or input parameter abnormal. |
2168| 12000014 | memory is insufficient. |2188| 12000014 | memory is insufficient. |
2169| 12000017 | The key with same alias is already exist. |2189| 12000017 | The key with same alias is already exist. |
2190+| 12000020 | the provider operation failed. |
2191+| 12000021 | the Ukey PIN is locked. |
2192+| 12000023 | the Ukey PIN not authenticated. |
2193+| 12000024 | the provider or Ukey is busy. |
2170 2194 
2171## huks.abortSession<sup>9+</sup>2195## huks.abortSession<sup>9+</sup>
2172 2196 
@@ -2196,9 +2220,11 @@ abortSession操作密钥接口，使用Callback回调异步返回结果。
2196| 801 | api is not supported. |2220| 801 | api is not supported. |
2197| 12000004 | operating file failed. |2221| 12000004 | operating file failed. |
2198| 12000005 | IPC communication failed. |2222| 12000005 | IPC communication failed. |
2199-| 12000006 | error occurred in crypto engine. |2223+| 12000006 | error occurred in crypto engine or Ukey driver. |
2200| 12000012 | Device environment or input parameter abnormal. |2224| 12000012 | Device environment or input parameter abnormal. |
2201| 12000014 | memory is insufficient. |2225| 12000014 | memory is insufficient. |
2226+| 12000020 | the provider operation failed. |
2227+| 12000024 | the provider or Ukey is busy. |
2202 2228 
2203**示例：**2229**示例：**
2204 2230 
@@ -2303,9 +2329,11 @@ abortSession操作密钥接口，使用Promise方式异步返回结果。
2303| 801 | api is not supported. |2329| 801 | api is not supported. |
2304| 12000004 | operating file failed. |2330| 12000004 | operating file failed. |
2305| 12000005 | IPC communication failed. |2331| 12000005 | IPC communication failed. |
2306-| 12000006 | error occurred in crypto engine. |2332+| 12000006 | error occurred in crypto engine or Ukey driver. |
2307| 12000012 | Device environment or input parameter abnormal. |2333| 12000012 | Device environment or input parameter abnormal. |
2308| 12000014 | memory is insufficient. |2334| 12000014 | memory is insufficient. |
2335+| 12000020 | the provider operation failed. |
2336+| 12000024 | the provider or Ukey is busy. |
2309 2337 
2310**示例：**2338**示例：**
2311 2339 
@@ -2499,6 +2527,13 @@ async function testListAliases() {
2499| HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET<sup>11+</sup> | 12000016 | 需要锁屏密码但未设置。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |2527| HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET<sup>11+</sup> | 12000016 | 需要锁屏密码但未设置。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |
2500| HUKS_ERR_CODE_KEY_ALREADY_EXIST<sup>20+</sup> | 12000017 | 同名密钥已存在。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2528| HUKS_ERR_CODE_KEY_ALREADY_EXIST<sup>20+</sup> | 12000017 | 同名密钥已存在。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
2501| HUKS_ERR_CODE_INVALID_ARGUMENT<sup>20+</sup> | 12000018 | 输入参数非法。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2529| HUKS_ERR_CODE_INVALID_ARGUMENT<sup>20+</sup> | 12000018 | 输入参数非法。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
2530+| HUKS_ERR_CODE_ITEM_EXISTS<sup>22+</sup> | 12000019 | 同名provider已注册。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2531+| HUKS_ERR_CODE_EXTERNAL_MODULE<sup>22+</sup> | 12000020 | 依赖的模块报错。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2532+| HUKS_ERR_CODE_PIN_LOCKED<sup>22+</sup> | 12000021 | Ukey PIN码被锁。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2533+| HUKS_ERR_CODE_PIN_INCORRECT<sup>22+</sup> | 12000022 | Ukey PIN码错误。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2534+| HUKS_ERR_CODE_PIN_NO_AUTH<sup>22+</sup> | 12000023 | Ukey PIN码未认证。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2535+| HUKS_ERR_CODE_BUSY<sup>22+</sup> | 12000024 | 设备或资源繁忙。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2536+| HUKS_ERR_CODE_EXCEED_LIMIT<sup>22+</sup> | 12000025 | 资源超过限制。<br> **系统能力**: SystemCapability.Security.Huks.Extension |
2502 2537 
2503## HuksKeyPurpose2538## HuksKeyPurpose
2504 2539 
@@ -2691,6 +2726,17 @@ API version 8-11系统能力为SystemCapability.Security.Huks.Extension；从API
2691| HUKS_SEND_TYPE_ASYNC | 0 | 表示异步发送TAG。 |2726| HUKS_SEND_TYPE_ASYNC | 0 | 表示异步发送TAG。 |
2692| HUKS_SEND_TYPE_SYNC | 1 | 表示同步发送TAG。 |2727| HUKS_SEND_TYPE_SYNC | 1 | 表示同步发送TAG。 |
2693 2728 
2729+## HuksKeyClassType<sup>22+</sup>
2730+ 
2731+表示密钥的来源。
2732+ 
2733+**系统能力：** SystemCapability.Security.Huks.Extension
2734+ 
2735+| 名称 | 值 | 说明 |
2736+| -------------------- | ---- | ----------------- |
2737+| HUKS_KEY_CLASS_DEFAULT | 0 | 表示HUKS本地管理的密钥。 |
2738+| HUKS_KEY_CLASS_EXTENSION | 1 | 表示外部密钥管理扩展管理的密钥。 |
2739+ 
2694## HuksUnwrapSuite<sup>9+</sup>2740## HuksUnwrapSuite<sup>9+</sup>
2695 2741 
2696表示导入加密密钥的算法套件。2742表示导入加密密钥的算法套件。
@@ -2934,6 +2980,7 @@ API version 11系统能力为SystemCapability.Security.Huks.Extension；从API v
2934| HUKS_TAG_ATTESTATION_ID_VERSION_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 515 | 表示attestation时的版本号。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |2980| HUKS_TAG_ATTESTATION_ID_VERSION_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 515 | 表示attestation时的版本号。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |
2935| HUKS_TAG_KEY_OVERRIDE<sup>20+</sup> | HuksTagType.HUKS_TAG_TYPE_BOOL \| 520 | 表示是否覆写同名密钥。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2981| HUKS_TAG_KEY_OVERRIDE<sup>20+</sup> | HuksTagType.HUKS_TAG_TYPE_BOOL \| 520 | 表示是否覆写同名密钥。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
2936| HUKS_TAG_AE_TAG_LEN<sup>22+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 521 | 表示指定的AEAD标签长度。<br>**原子化服务API：** 从API version 22开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2982| HUKS_TAG_AE_TAG_LEN<sup>22+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 521 | 表示指定的AEAD标签长度。<br>**原子化服务API：** 从API version 22开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
2983+| HUKS_TAG_KEY_CLASS<sup>22+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 522 | 表示密钥来源。<br> **系统能力：** SystemCapability.Security.Huks.Extension |
2937| HUKS_TAG_KEY_ACCESS_GROUP<sup>23+</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 523 | 表示指定的分组信息。<br>**原子化服务API：** 从API version 23开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |2984| HUKS_TAG_KEY_ACCESS_GROUP<sup>23+</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 523 | 表示指定的分组信息。<br>**原子化服务API：** 从API version 23开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension |
2938| HUKS_TAG_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1001 | 表示是否使用生成key时传入的别名的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2985| HUKS_TAG_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1001 | 表示是否使用生成key时传入的别名的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
2939| HUKS_TAG_KEY_STORAGE_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1002 | 表示密钥存储方式的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |2986| HUKS_TAG_KEY_STORAGE_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1002 | 表示密钥存储方式的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core |
Azh-cn/application-dev/reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto-sys.md+92-0
@@ -0,0 +1,92 @@
1+# @ohos.security.huksExternalCrypto（外部密钥管理）
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+模块提供外部密钥管理扩展功能的注册与注销，PIN码认证与认证状态获取等。
11+ 
12+> **说明**
13+>
14+> 本模块首批接口从API version 22开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
15+ 
16+## 导入模块
17+ 
18+```ts
19+import { huks } from '@kit.UniversalKeystoreKit';
20+```
21+ 
22+## huksExternalCrypto.authUkeyPin
23+ 
24+authUkeyPin(resourceId: string, params: Array\<HuksExternalCryptoParam>): Promise\<void>
25+ 
26+PIN码认证。使用Promise异步回调。
27+ 
28+**系统接口：** 此接口为系统接口。
29+ 
30+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
31+ 
32+**参数：**
33+ 
34+| 参数名 | 类型 | 必填 | 说明 |
35+| -------- | -------- | ---- | -------|
36+| resourceId | string | 是 | Ukey中某容器的资源ID，可通过[导出证书的接口](../apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取，其结果中附带resourceId。 |
37+| params | Array\<[HuksExternalCryptoParam](js-apis-huksExternalCrypto.md#huksexternalcryptoparam)> | 是 | 操作时需传入的参数，必选TAG：[HUKS_EXT_CRYPTO_TAG_UKEY_PIN](js-apis-huksExternalCrypto.md#huksexternalcryptotag)。 |
38+ 
39+**返回值：**
40+ 
41+| 类型 | 说明 |
42+| -------- | ---------- |
43+| Promise\<void> | Promise对象，无返回结果。 |
44+ 
45+**错误码：**
46+ 
47+以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。
48+ 
49+| 错误码ID | 错误信息 |
50+| -------- | ------------- |
51+| 202 | non-system applications are not allowed to use system APIs. |
52+| 801 | api is not supported. |
53+| 12000005 | IPC communication failed. |
54+| 12000006 | the Ukey driver operation failed. |
55+| 12000011 | the provider is not found. |
56+| 12000014 | memory is insufficient. |
57+| 12000018 | the input parameter is invalid. |
58+| 12000020 | the provider operation failed. |
59+| 12000021 | the Ukey PIN is locked. |
60+| 12000022 | The Ukey PIN is incorrect. |
61+| 12000024 | The provider or Ukey is busy. |
62+ 
63+**示例：**
64+ 
65+```ts
66+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
67+ 
68+function StringToUint8Array(str: string) {
69+ let arr: number[] = [];
70+ for (let i = 0, j = str.length; i < j; ++i) {
71+ arr.push(str.charCodeAt(i));
72+ }
73+ return new Uint8Array(arr);
74+}
75+ 
76+let uid: number = 3511
77+const testResourceId = "{\"providerName\":\"testProviderName\", \"bundleName\":\"com.example.cryptoapplication\", \"abilityName\":\"CryptoExtension\",\"index\":{\"key\":\"testKey\"}}";
78+const pin = "123456";
79+const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
80+ {
81+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_UID,
82+ value: uid
83+ }, {
84+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_UKEY_PIN,
85+ value: StringToUint8Array(pin)
86+ }
87+];
88+huksExternalCrypto.authUkeyPin(testResourceId, extProperties)
89+ .then((data) => {
90+ console.info(`promise: authUkeyPin success`);
91+ });
92+```
Azh-cn/application-dev/reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md+238-0
@@ -0,0 +1,238 @@
1+# @ohos.security.huksExternalCrypto（外部密钥管理）
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+模块提供外部密钥管理扩展功能的注册与注销，PIN码认证与认证状态获取等。
11+ 
12+> **说明**
13+>
14+> 本模块首批接口从API version 22开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
15+ 
16+## 导入模块
17+ 
18+```ts
19+import { huks } from '@kit.UniversalKeystoreKit';
20+```
21+ 
22+## HuksExternalCryptoTagType
23+ 
24+表示外部加密数据类型的枚举。
25+ 
26+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
27+ 
28+| 名称 | 值 | 说明 |
29+| ----- | ---- | -------- |
30+| HUKS_EXT_CRYPTO_TAG_TYPE_INT | 1 << 28 | 表示TAG的值为整数类型。 |
31+| HUKS_EXT_CRYPTO_TAG_TYPE_BYTES | 5 << 28 | 表示TAG的值为字节数组。 |
32+ 
33+## HuksExternalCryptoTag
34+ 
35+表示指定参数tag类型的枚举。
36+ 
37+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
38+ 
39+| 名称 | 值 | 说明 |
40+| ------- | ---- | -------- |
41+| HUKS_EXT_CRYPTO_TAG_UKEY_PIN | HuksExternalCryptoTagType.HUKS_EXT_CRYPTO_TAG_TYPE_BYTES \| 200001 | 表示PIN码的TAG。 |
42+| HUKS_EXT_CRYPTO_TAG_ABILITY_NAME | HuksExternalCryptoTagType.HUKS_EXT_CRYPTO_TAG_TYPE_BYTES \| 200002 | 表示[CryptoExtensionAbility](js-apis-CryptoExtensionAbility.md)的名称。 |
43+| HUKS_EXT_CRYPTO_TAG_EXTRA_DATA | HuksExternalCryptoTagType.HUKS_EXT_CRYPTO_TAG_TYPE_BYTES \| 200003 | 外部数据，在通用查询场景，表示返回的数据。 |
44+| HUKS_EXT_CRYPTO_TAG_UID | HuksExternalCryptoTagType.HUKS_EXT_CRYPTO_TAG_TYPE_INT \| 200004 | 表示调用方的uid。 |
45+| HUKS_EXT_CRYPTO_TAG_PURPOSE | HuksExternalCryptoTagType.HUKS_EXT_CRYPTO_TAG_TYPE_INT \| 200005 | 表示证书链对应密钥的使用类型，具体类型详见[CertificatePurpose定义](../apis-device-certificate-kit/js-apis-certManager.md#certificatepurpose22)。 |
46+ 
47+## HuksExternalCryptoParam
48+ 
49+表示传入的参数类型定义。
50+ 
51+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
52+ 
53+| 名称 | 类型 | 只读 | 可选 | 说明 |
54+| ------ | ----------------------------------- | ---- | ---- | ------------ |
55+| tag | [HuksExternalCryptoTag](#huksexternalcryptotag) | 否 | 否 | 参数标签，用于区分参数。 |
56+| value | boolean\|number\|bigint\|Uint8Array | 否 | 否 | 标签对应值。 |
57+ 
58+## huksExternalCrypto.registerProvider
59+ 
60+registerProvider(providerName: string, params: Array\<HuksExternalCryptoParam>): Promise\<void>
61+ 
62+注册指定外部provider。使用Promise异步回调。
63+ 
64+**需要权限**：ohos.permission.CRYPTO_EXTENSION_REGISTER
65+ 
66+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
67+ 
68+**参数：**
69+ 
70+| 参数名 | 类型 | 必填 | 说明 |
71+| -------- | ------- | ---- | -------|
72+| providerName | string | 是 | provider名称，最大长度为128。建议包含厂商信息，全局唯一，不要包含个人联系方式等敏感数据。<br>最多支持注册10个provider。 |
73+| params | Array<[HuksExternalCryptoParam](#huksexternalcryptoparam)> | 是 | 操作时需传入的参数，必选TAG：[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](#huksexternalcryptotag)，表示ability的名字，根据业务自己内部定义按照实际填写。 |
74+ 
75+**返回值：**
76+ 
77+| 类型 | 说明 |
78+| ------------- | --------|
79+| Promise\<void> | Promise对象，无返回结果。 |
80+ 
81+**错误码：**
82+ 
83+以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。
84+ 
85+| 错误码ID | 错误信息 |
86+| -------- | ------------- |
87+| 201 | check permission failed. |
88+| 801 | api is not supported. |
89+| 12000002 | the ability name param is missing. |
90+| 12000005 | IPC communication failed. |
91+| 12000014 | memory is insufficient. |
92+| 12000018 | the input parameter is invalid. |
93+| 12000019 | the provider is already registered. |
94+| 12000020 | an error occured in the dependent module. |
95+| 12000025 | the number of providers exceeds the limit. |
96+ 
97+**示例：**
98+ 
99+```ts
100+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
101+ 
102+function StringToUint8Array(str: string) {
103+ let arr: number[] = [];
104+ for (let i = 0, j = str.length; i < j; ++i) {
105+ arr.push(str.charCodeAt(i));
106+ }
107+ return new Uint8Array(arr);
108+}
109+ 
110+const providerName = "testProviderName";
111+const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
112+ {
113+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
114+ value: StringToUint8Array("CryptoExtension")
115+ }
116+];
117+huksExternalCrypto.registerProvider(providerName, extProperties)
118+ .then((data) => {
119+ console.info(`promise: registerProvider success`);
120+ });
121+```
122+ 
123+## huksExternalCrypto.unregisterProvider
124+ 
125+unregisterProvider(providerName: string, params?: Array\<HuksExternalCryptoParam>): Promise\<void>
126+ 
127+注销provider。使用Promise异步回调。
128+ 
129+**需要权限**：ohos.permission.CRYPTO_EXTENSION_REGISTER
130+ 
131+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
132+ 
133+**参数：**
134+ 
135+| 参数名 | 类型 | 必填 | 说明 |
136+| -------- | ------| ---- | -----|
137+| providerName | string | 是 | provider名称，最大长度为128。建议包含厂商信息，全局唯一，不要包含个人联系方式等敏感数据。如果provider注册了多个扩展能力，则该provider下的扩展能力都会被注销。 |
138+| params | Array\<[HuksExternalCryptoParam](#huksexternalcryptoparam)> | 否 | 操作时需传入的参数。<br>可以在param参数中指定[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](#huksexternalcryptotag)，将根据“包名 + providerName + abilityName”注销对应的cryptoExtensionAbility。<br>如果未在params参数中指定[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](#huksexternalcryptotag)，或者未传入params参数，则注销对应的providerName下的所有Provider。|
139+ 
140+**返回值：**
141+ 
142+| 类型 | 说明 |
143+| -------| ------ |
144+| Promise\<void> | Promise对象，无返回结果。 |
145+ 
146+**错误码：**
147+ 
148+以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。
149+ 
150+| 错误码ID | 错误信息 |
151+| -------- | ------------- |
152+| 201 | check permission failed. |
153+| 801 | api is not supported. |
154+| 12000005 | IPC communication failed. |
155+| 12000011 | the provider is not found. |
156+| 12000014 | memory is insufficient. |
157+| 12000018 | the input parameter is invalid. |
158+| 12000020 | an error occured in the dependent module. |
159+ 
160+**示例：**
161+ 
162+```ts
163+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
164+ 
165+function StringToUint8Array(str: string) {
166+ let arr: number[] = [];
167+ for (let i = 0, j = str.length; i < j; ++i) {
168+ arr.push(str.charCodeAt(i));
169+ }
170+ return new Uint8Array(arr);
171+}
172+ 
173+const providerName = "testProviderName";
174+const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
175+ {
176+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
177+ value: StringToUint8Array("CryptoExtension")
178+ }
179+];
180+huksExternalCrypto.unregisterProvider(providerName, extProperties)
181+ .then((data) => {
182+ console.info(`promise: unregisterProvider success`);
183+ });
184+```
185+ 
186+## huksExternalCrypto.getUkeyPinAuthState
187+ 
188+getUkeyPinAuthState(resourceId: string, params?: Array\<HuksExternalCryptoParam>): Promise\<boolean>
189+ 
190+获取PIN码认证状态。使用Promise异步回调。
191+ 
192+**系统能力：** SystemCapability.Security.Huks.CryptoExtension
193+ 
194+**参数：**
195+ 
196+| 参数名 | 类型 | 必填 | 说明 |
197+| -------- | ------- | ---- | ----------|
198+| resourceId | string | 是 | 资源ID，可通过[导出证书的接口](../apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取，其结果中附带资源ID。 |
199+| params | Array\<[HuksExternalCryptoParam](#huksexternalcryptoparam)> | 否 | 操作的属性。 |
200+ 
201+**返回值：**
202+ 
203+| 类型 | 说明 |
204+| -------- | ------- |
205+| Promise\<boolean> | Promise对象，返回认证结果。<br>true表示认证成功；false表示认证失败。 |
206+ 
207+**错误码：**
208+ 
209+以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。
210+ 
211+| 错误码ID | 错误信息 |
212+| -------- | ------------- |
213+| 801 | api is not supported. |
214+| 12000005 | IPC communication failed. |
215+| 12000014 | memory is insufficient. |
216+| 12000018 | the input parameter is invalid. |
217+| 12000020 | an error occured in the dependent module. |
218+ 
219+**示例：**
220+ 
221+```ts
222+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
223+ 
224+function StringToUint8Array(str: string) {
225+ let arr: number[] = [];
226+ for (let i = 0, j = str.length; i < j; ++i) {
227+ arr.push(str.charCodeAt(i));
228+ }
229+ return new Uint8Array(arr);
230+}
231+ 
232+const testResourceId = "{\"providerName\":\"testProviderName\", \"bundleName\":\"com.example.cryptoapplication\", \"abilityName\":\"CryptoExtension\",\"index\":{\"key\":\"testKey\"}}";
233+const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [];
234+huksExternalCrypto.getUkeyPinAuthState(testResourceId, extProperties)
235+ .then((data) => {
236+ console.info(`promise: getUkeyPinAuthState success`);
237+ });
238+```
Mzh-cn/application-dev/security/UniversalKeystoreKit/Readme-CN.md+108-77
@@ -8,82 +8,113 @@
8<!--Adviser: @zengyawen-->8<!--Adviser: @zengyawen-->
9 9 
10- [Universal Keystore Kit简介](huks-overview.md)10- [Universal Keystore Kit简介](huks-overview.md)
11-- [通用密钥库基础概念](huks-concepts.md)11+- 本地密钥管理<!--huks-local-key-management-->
12-- 密钥生成/导入<!--huks-key-generation-import-->12+ - [本地密钥管理基础概念](huks-concepts.md)
13- - 密钥生成<!--huks-key-generation-->13+ - 密钥生成/导入<!--huks-key-generation-import-->
14- - [密钥生成介绍及算法规格](huks-key-generation-overview.md)14+ - 密钥生成<!--huks-key-generation-->
15- - 开发指导<!--huks-key-generation-dev-->15+ - [密钥生成介绍及算法规格](huks-key-generation-overview.md)
16- - [生成密钥(ArkTS)](huks-key-generation-arkts.md)16+ - 开发指导<!--huks-key-generation-dev-->
17- - [生成密钥(C/C++)](huks-key-generation-ndk.md)17+ - [生成密钥(ArkTS)](huks-key-generation-arkts.md)
18- - 密钥导入<!--huks-key-import-->18+ - [生成密钥(C/C++)](huks-key-generation-ndk.md)
19- - [密钥导入介绍及算法规格](huks-key-import-overview.md)19+ - 密钥导入<!--huks-key-import-->
20- - 开发指导<!--huks-key-import-dev-->20+ - [密钥导入介绍及算法规格](huks-key-import-overview.md)
21- - [明文导入密钥(ArkTS)](huks-import-key-in-plaintext-arkts.md)21+ - 开发指导<!--huks-key-import-dev-->
22- - [明文导入密钥(C/C++)](huks-import-key-in-plaintext-ndk.md)22+ - [明文导入密钥(ArkTS)](huks-import-key-in-plaintext-arkts.md)
23- - [加密导入密钥(ArkTS)](huks-import-wrapped-key-arkts.md)23+ - [明文导入密钥(C/C++)](huks-import-key-in-plaintext-ndk.md)
24- - [加密导入密钥(C/C++)](huks-import-wrapped-key-ndk.md)24+ - [加密导入密钥(ArkTS)](huks-import-wrapped-key-arkts.md)
25-- 密钥使用<!--huks-key-use-->25+ - [加密导入密钥(C/C++)](huks-import-wrapped-key-ndk.md)
26- - [密钥使用介绍及通用流程](huks-key-use-overview.md)26+ - 密钥使用<!--huks-key-use-->
27- - 加密/解密<!--huks-encryption-decryption-->27+ - [密钥使用介绍及通用流程](huks-key-use-overview.md)
28- - [加密/解密介绍及算法规格](huks-encryption-decryption-overview.md)28+ - 加密/解密<!--huks-encryption-decryption-->
29- - 开发指导<!--huks-encryption-decryption-dev-->29+ - [加密/解密介绍及算法规格](huks-encryption-decryption-overview.md)
30- - [加解密(ArkTS)](huks-encryption-decryption-arkts.md)30+ - 开发指导<!--huks-encryption-decryption-dev-->
31- - [加解密(C/C++)](huks-encryption-decryption-ndk.md)31+ - [加解密(ArkTS)](huks-encryption-decryption-arkts.md)
32- - 签名/验签<!--huks-signing-signature-verification-->32+ - [加解密(C/C++)](huks-encryption-decryption-ndk.md)
33- - [签名/验签介绍及算法规格](huks-signing-signature-verification-overview.md)33+ - 签名/验签<!--huks-signing-signature-verification-->
34- - 开发指导<!--huks-signing-signature-verification-dev-->34+ - [签名/验签介绍及算法规格](huks-signing-signature-verification-overview.md)
35- - [签名/验签(ArkTS)](huks-signing-signature-verification-arkts.md)35+ - 开发指导<!--huks-signing-signature-verification-dev-->
36- - [签名/验签(C/C++)](huks-signing-signature-verification-ndk.md)36+ - [签名/验签(ArkTS)](huks-signing-signature-verification-arkts.md)
37- - 密钥协商<!--huks-key-agreement-->37+ - [签名/验签(C/C++)](huks-signing-signature-verification-ndk.md)
38- - [密钥协商介绍及算法规格](huks-key-agreement-overview.md)38+ - 密钥协商<!--huks-key-agreement-->
39- - 开发指导<!--huks-key-agreement-dev-->39+ - [密钥协商介绍及算法规格](huks-key-agreement-overview.md)
40- - [密钥协商(ArkTS)](huks-key-agreement-arkts.md)40+ - 开发指导<!--huks-key-agreement-dev-->
41- - [密钥协商(C/C++)](huks-key-agreement-ndk.md)41+ - [密钥协商(ArkTS)](huks-key-agreement-arkts.md)
42- - 密钥派生<!--huks-key-derivation-->42+ - [密钥协商(C/C++)](huks-key-agreement-ndk.md)
43- - [密钥派生介绍及算法规格](huks-key-derivation-overview.md)43+ - 密钥派生<!--huks-key-derivation-->
44- - 开发指导<!--huks-key-derivation-dev-->44+ - [密钥派生介绍及算法规格](huks-key-derivation-overview.md)
45- - [密钥派生(ArkTS)](huks-key-derivation-arkts.md)45+ - 开发指导<!--huks-key-derivation-dev-->
46- - [密钥派生(C/C++)](huks-key-derivation-ndk.md)46+ - [密钥派生(ArkTS)](huks-key-derivation-arkts.md)
47- - 访问控制<!--huks-identity-authentication-->47+ - [密钥派生(C/C++)](huks-key-derivation-ndk.md)
48- - [用户身份认证访问控制简介](huks-identity-authentication-overview.md)48+ - 访问控制<!--huks-identity-authentication-->
49- - 开发指导<!--huks-identity-authentication-dev-->49+ - [用户身份认证访问控制简介](huks-identity-authentication-overview.md)
50- - [用户身份认证访问控制开发指导](huks-user-identity-authentication.md)50+ - 开发指导<!--huks-identity-authentication-dev-->
51- - [细粒度用户身份认证访问控制开发指导](huks-refined-user-identity-authentication.md)51+ - [用户身份认证访问控制开发指导](huks-user-identity-authentication.md)
52- - HMAC<!--huks-hmac-->52+ - [细粒度用户身份认证访问控制开发指导](huks-refined-user-identity-authentication.md)
53- - [HMAC介绍及算法规格](huks-hmac-overview.md)53+ - HMAC<!--huks-hmac-->
54- - 开发指导<!--huks-hmac-dev-->54+ - [HMAC介绍及算法规格](huks-hmac-overview.md)
55- - [HMAC(ArkTS)](huks-hmac-arkts.md)55+ - 开发指导<!--huks-hmac-dev-->
56- - [HMAC(C/C++)](huks-hmac-ndk.md)<!--RP1--><!--RP1End-->56+ - [HMAC(ArkTS)](huks-hmac-arkts.md)
57-- 密钥删除<!--huks-delete-key-->57+ - [HMAC(C/C++)](huks-hmac-ndk.md)
58- - [密钥删除(ArkTS)](huks-delete-key-arkts.md)58+ - 密钥删除<!--huks-delete-key-->
59- - [密钥删除(C/C++)](huks-delete-key-ndk.md)59+ - [密钥删除(ArkTS)](huks-delete-key-arkts.md)
60-- 密钥证明<!--huks-key-attestation-->60+ - [密钥删除(C/C++)](huks-delete-key-ndk.md)
61- - [密钥证明介绍及算法规格](huks-key-attestation-overview.md)61+ - 密钥证明<!--huks-key-attestation-->
62- - 开发指导<!--huks-key-attestation-dev-->62+ - [密钥证明介绍及算法规格](huks-key-attestation-overview.md)
63- - [匿名密钥证明(ArkTS)](huks-key-anon-attestation-arkts.md)63+ - 开发指导<!--huks-key-attestation-dev-->
64- - [匿名密钥证明(C/C++)](huks-key-anon-attestation-ndk.md)64+ - [匿名密钥证明(ArkTS)](huks-key-anon-attestation-arkts.md)
65+ - [匿名密钥证明(C/C++)](huks-key-anon-attestation-ndk.md)
66+ <!--Del-->
67+ - [非匿名密钥证明(仅对系统应用开放)(ArkTS)](huks-key-attestation-arkts-sys.md)
68+ - [非匿名密钥证明(仅对系统应用开放)(C/C++)](huks-key-attestation-ndk-sys.md)
69+ <!--DelEnd-->
70+ - 其他操作<!--huks-other-operations-->
71+ - 查询密钥是否存在<!--huks-check-key-->
72+ - [查询密钥是否存在(ArkTS)](huks-check-key-arkts.md)
73+ - [查询密钥是否存在(C/C++)](huks-check-key-ndk.md)
74+ - 获取密钥属性<!--huks-obtain-key-properties-->
75+ - [获取密钥属性(ArkTS)](huks-obtain-key-properties-arkts.md)
76+ - [获取密钥属性(C/C++)](huks-obtain-key-properties-ndk.md)
77+ - 密钥导出<!--huks-export-key-->
78+ - [密钥导出(ArkTS)](huks-export-key-arkts.md)
79+ - [密钥导出(C/C++)](huks-export-key-ndk.md)
80+ - 查询密钥别名集<!--huks-list-aliases-->
81+ - [查询密钥别名集(ArkTS)](huks-list-aliases-arkts.md)
82+ - [查询密钥别名集(C/C++)](huks-list-aliases-ndk.md)
83+ - 群组密钥<!--huks-group-key-->
84+ - [群组密钥介绍](huks-group-key-overview.md)
85+ - 开发指导<!--huks-group-key-dev-->
86+ - [群组密钥(ArkTS)](huks-group-key-arkts.md)
87+ - [群组密钥(C/C++)](huks-group-key-ndk.md)
65 <!--Del-->88 <!--Del-->
66- - [非匿名密钥证明(仅对系统应用开放)(ArkTS)](huks-key-attestation-arkts-sys.md)89+ - [指定用户身份操作(仅对系统应用开放)](huks-as-user-sys.md)
67- - [非匿名密钥证明(仅对系统应用开放)(C/C++)](huks-key-attestation-ndk-sys.md)
68 <!--DelEnd-->90 <!--DelEnd-->
69-- 其他操作<!--huks-other-operations-->91+- 外部密钥管理扩展<!--huks-external-key-management-->
70- - 查询密钥是否存在<!--huks-check-key-->92+ - [外部密钥管理扩展简介](huks-external-hardware-key-management-overview.md)
71- - [查询密钥是否存在(ArkTS)](huks-check-key-arkts.md)93+ - Provider管理<!--huks-provider-management-->
72- - [查询密钥是否存在(C/C++)](huks-check-key-ndk.md)94+ - [Provider管理介绍及规格](huks-provider-management-overview.md)
73- - 获取密钥属性<!--huks-obtain-key-properties-->95+ - 开发指导<!--huks-extension-operation-dev-->
74- - [获取密钥属性(ArkTS)](huks-obtain-key-properties-arkts.md)96+ - [注册/注销Provider(ArkTS)](huks-extension-registration-and-unregistration-arkts.md)
75- - [获取密钥属性(C/C++)](huks-obtain-key-properties-ndk.md)97+ - [注册/注销Provider(C/C++)](huks-extension-registration-and-unregistration-ndk.md)
76- - 密钥导出<!--huks-export-key-->98+ - 资源管理<!--huks-resource-management-->
77- - [密钥导出(ArkTS)](huks-export-key-arkts.md)99+ - [资源管理介绍及规格](huks-resource-management-overview.md)
78- - [密钥导出(C/C++)](huks-export-key-ndk.md)100+ - 开发指导<!--huks-resource-operation-dev-->
79- - 查询密钥别名集<!--huks-list-aliases-->101+ - [打开资源/关闭资源(C/C++)](huks-open-close-resource-ndk.md)
80- - [查询密钥别名集(ArkTS)](huks-list-aliases-arkts.md)102+ - UkeyPIN码认证管理<!--huks-ukey-pin-authentication-management-->
81- - [查询密钥别名集(C/C++)](huks-list-aliases-ndk.md)103+ - [UkeyPIN码认证介绍及规格](huks-ukey-pin-authentication-management-overview.md)
82- - 群组密钥<!--huks-group-key-->104+ - 开发指导<!--huks-ukey-pin-authentication-dev-->
83- - [群组密钥介绍](huks-group-key-overview.md)105+ - [UkeyPIN码认证(ArkTS)](huks-ukey-pin-authentication-arkts.md)
84- - 开发指导<!--huks-group-key-dev-->106+ - [查询认证状态(ArkTS)](huks-query-authentication-status-arkts.md)
85- - [群组密钥(ArkTS)](huks-group-key-arkts.md)107+ - [查询认证状态(C/C++)](huks-query-authentication-status-ndk.md)
86- - [群组密钥(C/C++)](huks-group-key-ndk.md)108+ - 签名/验签<!--huks-ukey-signing-signature-verification-->
87- <!--Del-->109+ - [签名/验签介绍及算法规格](huks-ukey-signing-signature-verification-overview.md)
88- - [指定用户身份操作(仅对系统应用开放)](huks-as-user-sys.md)110+ - 开发指导<!--huks-ukey-signing-signature-verification-dev-->
89- <!--DelEnd-->111+ - [签名/验签(ArkTS)](huks-ukey-signing-signature-verification-arkts.md)
112+ - [签名/验签(C/C++)](huks-ukey-signing-signature-verification-ndk.md)
113+ - 通用操作<!--huks-ukey-general-operation-->
114+ - [通用查询介绍及规格](huks-ukey-general-query-overview.md)
115+ - 开发指导<!--huks-ukey-general-query-dev-->
116+ - [通用查询(C/C++)](huks-ukey-general-query-ndk.md)
117+ - 驱动HAP ExtensionAbility适配指导<!--huks-extension-ability-support-->
118+ - [CryptoExtensionAbility扩展能力介绍](huks-extension-ability-support-overview.md)
119+ - 开发指导<!--huks-extension-ability-support-dev-->
120+ - [CryptoExtensionAbility适配开发指导](huks-extension-ability-support-dev.md)
Mzh-cn/application-dev/security/UniversalKeystoreKit/huks-concepts.md+1-1
@@ -1,4 +1,4 @@
1-# 通用密钥库基础概念1+# 本地密钥管理基础概念
2 2 
3<!--Kit: Universal Keystore Kit-->3<!--Kit: Universal Keystore Kit-->
4<!--Subsystem: Security-->4<!--Subsystem: Security-->
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-extension-ability-support-dev.md+452-0
@@ -0,0 +1,452 @@
1+# CryptoExtensionAbility适配开发指导
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+## 适配指导
11+ 
12+本指导是提供给驱动厂商继承实现[CryptoExtensionAbility](../../reference/apis-ability-kit/js-apis-app-ability-extensionAbility.md)需要的接口能力，此处给出实现参考，其他实现依照业务需要依次调用driver封装的底层驱动函数。
13+ 
14+在DevEco Studio工程中手动新建一个CryptoExtensionAbility组件，具体步骤如下：
15+ 
16+1. 在工程Module对应的ets目录下，右键选择“New > Directory”，新建一个目录，名称可以自己定义，例如cryptoability。
17+ 
18+2. 在cryptoability目录，右键选择“New > ArkTS File”，新建一个文件，名称可以自己定义，例如CryptoAbility.ets。
19+ 
20+ 其目录结构如下所示：
21+ ```
22+ ├── ets
23+ │ └── cryptoability
24+ │ └── CryptoAbility.ets
25+ ```
26+ 
27+3. 在工程Module对应的module.json5配置文件中注册AppServiceExtensionAbility组件，name标签表示ability名称，长度最大为127字节，srcEntry标签表示当前CryptoExtensionAbility组件所对应的代码路径，type标签需要设置为“crypto”，exported标签设置为false表示不允许三方驱动应用调用，配置多个ability时要求每个name标签必须是唯一的。
28+ 
29+ ```json5
30+ // entry/src/main/module.json5
31+ {
32+ "module": {
33+ // ...
34+ "extensionAbilities": [
35+ {
36+ "name": "CryptoExtension",
37+ "srcEntry": "./ets/cryptoability/CryptoAbility.ets",
38+ "type": "crypto",
39+ "exported": false
40+ }
41+ ],
42+ }
43+ }
44+ ```
45+ 
46+4. 在CryptoAbility.ets文件中，增加导入CryptoExtensionAbility的依赖包，自定义类继承CryptoExtensionAbility组件并实现其中的接口函数。导入CryptoExtensionAbility需要实现在[CryptoExtensionAbility](../../reference/apis-ability-kit/js-apis-app-ability-extensionAbility.md)中给出的所有函数，此处给出实现参考，与底层驱动的调用对应关系见下文。
47+ 
48+ ```ts
49+ import { huks, huksExternalCrypto, CryptoExtensionAbility, HuksCryptoExtensionCertInfo, HuksCryptoExtensionResult } from '@kit.UniversalKeystoreKit';
50+ 
51+ function Uint8ArrayToString(fileData: Uint8Array) {
52+ let dataString = '';
53+ for (let i = 0; i < fileData.length; i++) {
54+ dataString += String.fromCharCode(fileData[i]);
55+ }
56+ return dataString;
57+ }
58+ 
59+ class CryptoExtension extends CryptoExtensionAbility {
60+ // ...
61+ onOpenResource(resourceId: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
62+ let resource: string = JSON.parse(resourceId);
63+ let index: string = '';
64+ if (resource['index']['key']) {
65+ index = resource['index']['key'];
66+ } else {
67+ index = resource['index'];
68+ }
69+ // ...
70+ let result: HuksCryptoExtensionResult = {
71+ resultCode: -1,
72+ };
73+
74+ let res: HuksCryptoExtensionResult
75+ try {
76+ let driver: YourUKeyDriver = YourDriverInstance;
77+ res = driver.YourDriver_onOpenResource(index, ...);
78+ // 场景：打开资源成功
79+ result.resultCode = res.resultCode
80+ result.handle = res.handle
81+ } catch (error) {
82+ // 场景：打开资源失败
83+ result.resultCode = res.resultCode
84+ console.error(`promise: onOpenResource failed`);
85+ }
86+ return Promise.resolve(result);
87+ }
88+
89+ onCloseResource(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
90+ // ...
91+ let result: HuksCryptoExtensionResult = {
92+ resultCode: -1,
93+ };
94+
95+ let res: HuksCryptoExtensionResult
96+ try {
97+ let driver: YourUKeyDriver = YourDriverInstance;
98+ res = driver.YourDriver_closeOpenResource(handle, ...);
99+ // 场景：关闭资源成功
100+ result.resultCode = res.resultCode
101+ } catch (error) {
102+ // 场景：关闭资源失败
103+ result.resultCode = res.resultCode
104+ console.error(`promise: onCloseResource failed`);
105+ }
106+ return Promise.resolve(result);
107+ }
108+
109+ onGetProperty(handle: string, propertyId: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
110+ // ...
111+ let emptyArray: Array<huksExternalCrypto.HuksExternalCryptoParam> = [];
112+ let result: HuksCryptoExtensionResult = {
113+ resultCode: -1,
114+ property: emptyArray
115+ };
116+
117+ let res: HuksCryptoExtensionResult
118+ try {
119+ // 场景：获取属性成功
120+ let driver: YourUKeyDriver = YourDriverInstance;
121+ res = driver.YourDriver_onGetProperty(...);
122+ result.resultCode = res.resultCode
123+ result.property = res.property
124+ } catch (error) {
125+ // 场景：获取属性失败
126+ result.resultCode = res.resultCode
127+ console.error(`promise: onGetProperty failed`);
128+ }
129+ return Promise.resolve(result);
130+ }
131+
132+ onAuthUkeyPin(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
133+ let pin: string | undefined = undefined;
134+ for (let param of params) {
135+ if (param.tag == huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_UKEY_PIN) {
136+ pin = Uint8ArrayToString(param.value as Uint8Array);
137+ }
138+ }
139+ // ...
140+ let result: HuksCryptoExtensionResult = {
141+ resultCode: -1,
142+ authState: 0,
143+ retryCount: 0
144+ };
145+
146+ let res: HuksCryptoExtensionResult
147+ try {
148+ // 场景：PIN码认证成功
149+ let driver: YourUKeyDriver = YourDriverInstance;
150+ res = driver.YourDriver_onAuthUkeyPin(pin, ...);
151+ result.resultCode = res.resultCode
152+ result.authState = res.authState
153+ } catch (error) {
154+ // 场景：PIN码认证失败
155+ result.resultCode = res.resultCode
156+ result.retryCount = res.retryCount
157+ console.error(`promise: onAuthUkeyPin failed`);
158+ }
159+ return Promise.resolve(result);
160+ }
161+
162+ onGetUkeyPinAuthState(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
163+ // ...
164+ let result: HuksCryptoExtensionResult = {
165+ resultCode: -1,
166+ authState: 0
167+ };
168+
169+ let res: HuksCryptoExtensionResult
170+ try {
171+ // 场景：获取PIN码认证状态成功
172+ let driver: YourUKeyDriver = YourDriverInstance;
173+ res = driver.YourDriver_onAuthUkeyPin(...);
174+ result.resultCode = res.resultCode
175+ result.authState = res.authState
176+ if (result.authState != 0) {
177+ // 场景： PIN码已认证
178+ // ...
179+ } else {
180+ // 场景： PIN码未认证
181+ // ...
182+ }
183+ } catch (error) {
184+ // 场景：获取PIN码认证状态失败
185+ result.resultCode = res.resultCode
186+ console.error(`promise: onGetUkeyPinAuthState failed`);
187+ }
188+ return Promise.resolve(result);
189+ }
190+
191+ onClearUkeyPinAuthState(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
192+ // ...
193+ let result: HuksCryptoExtensionResult = {
194+ resultCode: -1,
195+ };
196+
197+ let res: HuksCryptoExtensionResult
198+ try {
199+ // 场景：清除PIN码认证状态成功
200+ let driver: YourUKeyDriver = YourDriverInstance;
201+ res = driver.YourDriver_onClearUkeyPinAuthState(...);
202+ result.resultCode = res.resultCode
203+ } catch (error) {
204+ // 场景：清除PIN码认证状态失败
205+ result.resultCode = res.resultCode
206+ console.error(`promise: onClearUkeyPinAuthState failed`);
207+ }
208+ return Promise.resolve(result);
209+ }
210+
211+ onInitSession(handle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
212+ // ...
213+ let result: HuksCryptoExtensionResult = {
214+ resultCode: -1,
215+ handle: ""
216+ };
217+
218+ let res: HuksCryptoExtensionResult
219+ try {
220+ // 场景：三段式init阶段成功
221+ let driver: YourUKeyDriver = YourDriverInstance;
222+ res = driver.YourDriver_onInitSession(...);
223+ result.resultCode = res.resultCode
224+ result.handle = res.handle
225+ } catch (error) {
226+ // 场景：三段式init阶段失败
227+ result.resultCode = res.resultCode
228+ console.error(`promise: onInitSession failed`);
229+ }
230+ return Promise.resolve(result);
231+ }
232+
233+ onUpdateSession(handle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
234+ // ...
235+ let certs: Uint8Array = new Uint8Array();
236+ let result: HuksCryptoExtensionResult = {
237+ resultCode: -1,
238+ outData: certs
239+ };
240+
241+ let res: HuksCryptoExtensionResult
242+ try {
243+ // 场景：三段式update阶段成功
244+ let driver: YourUKeyDriver = YourDriverInstance;
245+ res = driver.YourDriver_onUpdateSession(...);
246+ result.resultCode = res.resultCode
247+ result.outData = res.outData
248+ } catch (error) {
249+ // 场景：三段式update阶段失败
250+ result.resultCode = res.resultCode
251+ console.error(`promise: onUpdateSession failed`);
252+ }
253+ return Promise.resolve(result);
254+ }
255+
256+ onFinishSession(handle: string, params: huks.HuksOptions): Promise<HuksCryptoExtensionResult> {
257+ // ...
258+ let certs: Uint8Array = new Uint8Array();
259+ let result: HuksCryptoExtensionResult = {
260+ resultCode: -1,
261+ outData: certs
262+ };
263+
264+ let res: HuksCryptoExtensionResult
265+ try {
266+ // 场景：三段式finish阶段成功
267+ let driver: YourUKeyDriver = YourDriverInstance;
268+ res = driver.YourDriver_onFinishSession(...);
269+ result.resultCode = res.resultCode
270+ result.outData = res.outData
271+ } catch (error) {
272+ // 场景：三段式finish阶段失败
273+ result.resultCode = res.resultCode
274+ console.error(`promise: onFinishSession failed`);
275+ }
276+ return Promise.resolve(result);
277+ }
278+
279+ onExportCertificate(resourceId: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
280+ // ...
281+ let certInfoSetArray: Array<HuksCryptoExtensionCertInfo> = []
282+ let result: HuksCryptoExtensionResult = {
283+ resultCode: -1,
284+ certs: certInfoSetArray
285+ };
286+
287+ let res: HuksCryptoExtensionResult
288+ try {
289+ // 场景：导出证书成功
290+ let driver: YourUKeyDriver = YourDriverInstance;
291+ res = driver.YourDriver_onExportCertificate(...);
292+ result.resultCode = res.resultCode
293+ result.certs = res.certs
294+ } catch (error) {
295+ // 场景：导出证书失败
296+ result.resultCode = res.resultCode
297+ console.error(`promise: onExportCertificate failed`);
298+ }
299+ return Promise.resolve(result);
300+ }
301+
302+ onEnumCertificates(handle: string, params: Array<huksExternalCrypto.HuksExternalCryptoParam>): Promise<HuksCryptoExtensionResult> {
303+ // ...
304+ let certInfoSetArray: Array<HuksCryptoExtensionCertInfo> = []
305+ let result: HuksCryptoExtensionResult = {
306+ resultCode: -1,
307+ certs: certInfoSetArray
308+ };
309+
310+ let res: HuksCryptoExtensionResult
311+ try {
312+ // 场景：导出所有证书成功
313+ let driver: YourUKeyDriver = YourDriverInstance;
314+ res = driver.YourDriver_onEnumCertificates(...);
315+ result.resultCode = res.resultCode
316+ result.certs = res.certs
317+ } catch (error) {
318+ // 场景：导出所有证书失败
319+ result.resultCode = res.resultCode
320+ console.error(`promise: onEnumCertificates failed`);
321+ }
322+ return Promise.resolve(result);
323+ }
324+ }
325+ ```
326+ 
327+5. HuksCryptoExtensionResult的构造与错误码转换，详细错误码详见API参考中的定义，如无要求直接返回SKF错误码即可。
328+ 
329+ ```ts
330+ let huksResult: HuksCryptoExtensionResult = {
331+ resultCode: -1,
332+ }
333+ ```
334+ 
335+6. 封装底层Ukey driver实现接口调用，此处以使用SKF库的driver为例。
336+ 
337+ ```ts
338+ import { HuksCryptoExtensionResult, HuksCryptoExtensionCertInfo } from '@kit.UniversalKeystoreKit';
339+ 
340+ class YourUKeyDriver {
341+ YourDriver_onOpenResource(index, ...) {
342+ // ...
343+ // 根据index索引具体资源（app/device/container等）,调用相应SKF函数打开
344+ SKF_OpenApplication();
345+ SKF_ConnectDev();
346+ SKF_OpenContainer();
347+ // ...
348+ }
349+
350+ YourDriver_onCloseResource(handle, ...) {
351+ // ...
352+ // 根据index索引具体资源（app/device/container等）,调用相应SKF函数关闭
353+ SKF_CloseApplication();
354+ SKF_DisconnectDev();
355+ SKF_CloseContainer();
356+ // ...
357+ }
358+
359+ YourDriver_onGetProperty(...) {
360+ // ...
361+ }
362+
363+ YourDriver_onAuthUkeyPin(pin, ...) {
364+ // ...
365+ SKF_VerifyPIN();
366+ // ...
367+ }
368+
369+ YourDriver_onGetUkeyPinAuthState(...) {
370+ // ...
371+ }
372+
373+ YourDriver_onClearUkeyPinAuthState(...) {
374+ // ...
375+ SKF_ClearSecureState();
376+ // ...
377+ }
378+
379+ YourDriver_onInitSession(...) {
380+ // ...
381+ SKF_DigestInit();
382+ // ...
383+ }
384+
385+ YourDriver_onUpdateSession(...) {
386+ // ...
387+ SKF_DigestUpdate();
388+ // ...
389+ }
390+
391+ YourDriver_onFinishSession(...) {
392+ // ...
393+ SKF_DigestFinish();
394+ // ...
395+ }
396+
397+ YourDriver_onExportCertificate(...) {
398+ // ...
399+ SKF_ExportCertificate();
400+ // ...
401+ }
402+
403+ YourDriver_onEnumCertificates(...): HuksCryptoExtensionResult {
404+ // ...
405+ let huksResult: HuksCryptoExtensionResult = {
406+ resultCode: -1,
407+ certs: new Array<HuksCryptoExtensionCertInfo>()
408+ }
409+ for (...) {
410+ if (huksResult.certs != undefined) {
411+ huksResult.certs.push(SKF_ExportCertificate());
412+ }
413+ }
414+ return huksResult;
415+ }
416+ }
417+ ```
418+ 
419+## 驱动应用注册、解注册CryptoExtensionAbility适配
420+ 
421+### 注册CryptoExtensionAbility
422+ 
423+在Ukey插入时，向系统注册CryptoExtensionAbility。
424+ 
425+**示例：**
426+ 
427+```ts
428+// ./ets/cryptoability/CryptoAbility.ts
429+ 
430+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
431+ 
432+let ExtPropertiesTemp: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
433+ {
434+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
435+ value: stringToUint8Array("YourCryptoExtensionName")
436+ }
437+]
438+ 
439+// provider名称，为保证全局唯一，建议包含厂商信息。
440+let provider = "testProvider"
441+huksExternalCrypto.registerProvider(provider, ExtPropertiesTemp);
442+```
443+ 
444+### 解注册CryptoExtensionAbility
445+ 
446+在Ukey拔出时，向系统解注册CryptoExtensionAbility。
447+ 
448+**示例：**
449+ 
450+```ts
451+huksExternalCrypto.unregisterProvider(provider, ExtPropertiesTemp);
452+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-extension-ability-support-overview.md+26-0
@@ -0,0 +1,26 @@
1+# CryptoExtensionAbility扩展能力介绍
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+CryptoExtensionAbility给驱动厂商提供外部密钥管理扩展能力所需接口定义，包括打开/关闭资源、PIN码认证、签名验签、导出证书等接口。
11+CryptoExtensionAbility可以隔离底层硬件（Ukey驱动）厂商实现差异。三方驱动HAP应用如需定义自身外部密钥管理扩展能力；首先，需继承CryptoExtensionAbility并完成相关的接口实现；然后，通过Provider注册接口完成能力注册；最后，由HUKS和证书管理将对应的密钥管理扩展能力开放给北向应用。
12+ 
13+## 核心能力实现
14+ 
15+CryptoExtensionAbility主要实现以下能力：
16+ 
17+1. 设备管理，单个ExtensionAbility实现，支持多个Ukey。
18+2. 句柄管理，针对同一个Ukey资源（例如容器下的密钥），支持应用维度句柄资源管理。
19+ - 支持多个OpenHarmony应用，打开同一个Ukey密钥资源。例如：OpenHarmony应用1，打开容器A后， OpenHarmony应用2，也可以再次打开容器A。
20+ - 支持多个OpenHarmony应用，操作同一个Ukey密钥资源。例如：OpenHarmony应用1操作容器A中的私钥签名后，OpenHarmony应用2也验证PIN码后，也可以操作容器A中的私钥进行签名，两者互不影响。
21+3. 密钥会话管理，支持三段式密钥管理操作，单次签名验签需通过[onInitSession](../../reference/apis-universal-keystore-kit/js-apis-CryptoExtensionAbility.md#cryptoextensionabilityoninitsession)/[onUpdateSession](../../reference/apis-universal-keystore-kit/js-apis-CryptoExtensionAbility.md#cryptoextensionabilityonupdatesession)/[onFinishSession](../../reference/apis-universal-keystore-kit/js-apis-CryptoExtensionAbility.md#cryptoextensionabilityonfinishsession)三个函数三步配合完成，需支持会话管理，缓存密钥会话状态。
22+ - init操作，初始化密钥会话，并返回会话句柄信息。
23+ - update操作，传入分组数据，对分组数据进行密码操作，更新密钥会话信息后，将中间数据（如果有）返回。
24+ - finish操作，对传入最后一段分组数据，进行密钥返回操作，并结束密钥会话，将最终结果返回。
25+4. 认证状态管理，支持应用维度的认证状态管理。针对同一个Ukey中的应用A，OpenHarmony应用1验证Ukey应用A的PIN码后，OpenHarmony应用2如果要访问Ukey应用A，也需要进行PIN码认证操作。
26+5. 证书查询，支持根据证书类型，枚举所有证书或查询单个容器中的证书。
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-extension-registration-and-unregistration-arkts.md+133-0
@@ -0,0 +1,133 @@
1+# 注册/注销Provider(ArkTS)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+## 注册Provider
11+ 
12+### 开发步骤
13+ 
14+1. 构造注册参数，需要传入[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptotag)。
15+ 
16+2. 调用注册接口[registerProvider](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptoregisterprovider)。
17+ 
18+```ts
19+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
20+import { BusinessError } from "@kit.BasicServicesKit";
21+ 
22+function StringToUint8Array(str: string) {
23+ let arr: number[] = [];
24+ for (let i = 0, j = str.length; i < j; ++i) {
25+ arr.push(str.charCodeAt(i));
26+ }
27+ return new Uint8Array(arr);
28+}
29+ 
30+async function registerProvider(): Promise<void> {
31+ try {
32+ /* 1.构造注册参数 */
33+ const providerName = "testProvider";
34+ const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
35+ {
36+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
37+ value: StringToUint8Array("CryptoExtension")
38+ }
39+ ];
40+ 
41+ /* 2.调用registerProvider */
42+ await huksExternalCrypto.registerProvider(providerName, extProperties)
43+ .then(() => {
44+ console.info(`promise: registerProvider success`);
45+ }).catch((error: BusinessError) => {
46+ console.error(`promise: registerProvider failed, errCode : ${error.code}, errMsg : ${error.message}`);
47+ });
48+ } catch (error) {
49+ console.error(`promise: registerProvider input arg invalid`);
50+ }
51+}
52+ 
53+async function TestRegisterProvider() {
54+ await registerProvider();
55+}
56+```
57+ 
58+## 注销Provider
59+ 
60+### 开发步骤
61+ 
62+1. 构造注销参数，注销单个ability需要传入[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数。批量注销不需要传入[HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptotag)参数。
63+ 
64+2. 调用注销接口[unregisterProvider](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptounregisterprovider)。
65+ 
66+**注销单个ability**
67+```ts
68+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
69+import { BusinessError } from "@kit.BasicServicesKit";
70+ 
71+function StringToUint8Array(str: string) {
72+ let arr: number[] = [];
73+ for (let i = 0, j = str.length; i < j; ++i) {
74+ arr.push(str.charCodeAt(i));
75+ }
76+ return new Uint8Array(arr);
77+}
78+ 
79+async function unregisterProvider(): Promise<void> {
80+ try {
81+ /* 1.构造注销参数 */
82+ const providerName = "testProvider";
83+ const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
84+ {
85+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
86+ value: StringToUint8Array("CryptoExtension")
87+ }
88+ ];
89+ 
90+ /* 2.调用unregisterProvider */
91+ await huksExternalCrypto.unregisterProvider(providerName, extProperties)
92+ .then(() => {
93+ console.info(`promise: unregisterProvider success`);
94+ }).catch((error: BusinessError) => {
95+ console.error(`promise: unregisterProvider failed, errCode : ${error.code}, errMsg : ${error.message}`);
96+ });
97+ } catch (error) {
98+ console.error(`promise: unregisterProvider input arg invalid`);
99+ }
100+}
101+ 
102+async function TestRegisterProvider() {
103+ await unregisterProvider();
104+}
105+```
106+ 
107+**批量注销**
108+```ts
109+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
110+import { BusinessError } from "@kit.BasicServicesKit";
111+ 
112+async function unregisterProvider(): Promise<void> {
113+ try {
114+ /* 1.构造注销参数 */
115+ const providerName = "testProvider";
116+ const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [];
117+ 
118+ /* 2.调用unregisterProvider */
119+ await huksExternalCrypto.unregisterProvider(providerName, extProperties)
120+ .then(() => {
121+ console.info(`promise: unregisterProvider success`);
122+ }).catch((error: BusinessError) => {
123+ console.error(`promise: unregisterProvider failed, errCode : ${error.code}, errMsg : ${error.message}`);
124+ });
125+ } catch (error) {
126+ console.error(`promise: unregisterProvider input arg invalid`);
127+ }
128+}
129+ 
130+async function TestRegisterProvider() {
131+ await unregisterProvider();
132+}
133+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-extension-registration-and-unregistration-ndk.md+231-0
@@ -0,0 +1,231 @@
1+# 注册/注销Provider(C/C++)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+## 注册Provider
11+ 
12+### 开发步骤
13+ 
14+1. 构造注册参数，需要传入[OH_HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-type-h.md#oh_huks_externalcryptotag)。
15+ 
16+2. 调用注册接口[OH_Huks_RegisterProvider](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_registerprovider)。
17+ 
18+```c++
19+#include "napi/native_api.h"
20+#include "huks/native_huks_api.h"
21+#include "huks/native_huks_type.h"
22+#include "huks/native_huks_param.h"
23+#include "huks/native_huks_external_crypto_api.h"
24+#include <cstring>
25+ 
26+OH_Huks_Result InitParamSet(
27+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
28+ const struct OH_Huks_ExternalCryptoParam *params,
29+ uint32_t paramCount)
30+{
31+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
32+ if (ret.errorCode != OH_HUKS_SUCCESS) {
33+ return ret;
34+ }
35+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
36+ if (ret.errorCode != OH_HUKS_SUCCESS) {
37+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
38+ return ret;
39+ }
40+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
41+ if (ret.errorCode != OH_HUKS_SUCCESS) {
42+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
43+ return ret;
44+ }
45+ return ret;
46+}
47+ 
48+static struct OH_Huks_Blob g_abilityName = {
49+ (uint32_t)strlen("testAbility"),
50+ (uint8_t *)"testAbility"
51+};
52+ 
53+struct OH_Huks_Blob g_providerName = {
54+ (uint32_t)strlen("testProviderName"),
55+ (uint8_t *)"testProviderName"
56+};
57+ 
58+static struct OH_Huks_ExternalCryptoParam g_abilityParams[] = {
59+ {
60+ .tag = OH_HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
61+ .blob = g_abilityName
62+ },
63+};
64+ 
65+static napi_value registerProvider(napi_env env, napi_callback_info info)
66+{
67+ struct OH_Huks_ExternalCryptoParamSet *providerParamSet = nullptr;
68+ OH_Huks_Result ohResult;
69+ do {
70+ ohResult = InitParamSet(&providerParamSet, g_abilityParams,
71+ sizeof(g_abilityParams) / sizeof(OH_Huks_ExternalCryptoParam));
72+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
73+ break;
74+ }
75+ ohResult = OH_Huks_RegisterProvider(&g_providerName, providerParamSet);
76+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
77+ break;
78+ }
79+ } while (0);
80+ OH_Huks_FreeExternalCryptoParamSet(&providerParamSet);
81+ 
82+ napi_value ret;
83+ napi_create_int32(env, ohResult.errorCode, &ret);
84+ return ret;
85+}
86+```
87+ 
88+## 注销Provider
89+ 
90+### 开发步骤
91+ 
92+1. 构造注销参数，注销单个ability需要传入[OH_HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-type-h.md#oh_huks_externalcryptotag)。批量注销不需要传入[OH_HUKS_EXT_CRYPTO_TAG_ABILITY_NAME](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-type-h.md#oh_huks_externalcryptotag)。
93+ 
94+2. 调用注销接口[OH_Huks_UnregisterProvider](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_unregisterprovider)。
95+ 
96+**注销单个ability**
97+```c++
98+#include "napi/native_api.h"
99+#include "huks/native_huks_api.h"
100+#include "huks/native_huks_type.h"
101+#include "huks/native_huks_param.h"
102+#include "huks/native_huks_external_crypto_api.h"
103+#include <cstring>
104+ 
105+OH_Huks_Result InitParamSet(
106+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
107+ const struct OH_Huks_ExternalCryptoParam *params,
108+ uint32_t paramCount)
109+{
110+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
111+ if (ret.errorCode != OH_HUKS_SUCCESS) {
112+ return ret;
113+ }
114+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
115+ if (ret.errorCode != OH_HUKS_SUCCESS) {
116+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
117+ return ret;
118+ }
119+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
120+ if (ret.errorCode != OH_HUKS_SUCCESS) {
121+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
122+ return ret;
123+ }
124+ return ret;
125+}
126+ 
127+static struct OH_Huks_Blob g_abilityName = {
128+ (uint32_t)strlen("testAbility"),
129+ (uint8_t *)"testAbility"
130+};
131+ 
132+struct OH_Huks_Blob g_providerName = {
133+ (uint32_t)strlen("testProviderName"),
134+ (uint8_t *)"testProviderName"
135+};
136+ 
137+static struct OH_Huks_ExternalCryptoParam g_abilityParams[] = {
138+ {
139+ .tag = OH_HUKS_EXT_CRYPTO_TAG_ABILITY_NAME,
140+ .blob = g_abilityName
141+ },
142+};
143+ 
144+static napi_value unregisterProvider(napi_env env, napi_callback_info info)
145+{
146+ struct OH_Huks_ExternalCryptoParamSet *providerParamSet = nullptr;
147+ OH_Huks_Result ohResult;
148+ do {
149+ ohResult = InitParamSet(&providerParamSet, g_abilityParams,
150+ sizeof(g_abilityParams) / sizeof(OH_Huks_ExternalCryptoParam));
151+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
152+ break;
153+ }
154+ ohResult = OH_Huks_UnregisterProvider(&g_providerName, providerParamSet);
155+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
156+ break;
157+ }
158+ } while (0);
159+ OH_Huks_FreeExternalCryptoParamSet(&providerParamSet);
160+ 
161+ napi_value ret;
162+ napi_create_int32(env, ohResult.errorCode, &ret);
163+ return ret;
164+}
165+```
166+ 
167+**批量注销**
168+```c++
169+#include "napi/native_api.h"
170+#include "huks/native_huks_api.h"
171+#include "huks/native_huks_type.h"
172+#include "huks/native_huks_param.h"
173+#include "huks/native_huks_external_crypto_api.h"
174+#include <cstring>
175+ 
176+OH_Huks_Result InitParamSet(
177+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
178+ const struct OH_Huks_ExternalCryptoParam *params,
179+ uint32_t paramCount)
180+{
181+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
182+ if (ret.errorCode != OH_HUKS_SUCCESS) {
183+ return ret;
184+ }
185+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
186+ if (ret.errorCode != OH_HUKS_SUCCESS) {
187+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
188+ return ret;
189+ }
190+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
191+ if (ret.errorCode != OH_HUKS_SUCCESS) {
192+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
193+ return ret;
194+ }
195+ return ret;
196+}
197+ 
198+static struct OH_Huks_Blob g_abilityName = {
199+ (uint32_t)strlen("testAbility"),
200+ (uint8_t *)"testAbility"
201+};
202+ 
203+struct OH_Huks_Blob g_providerName = {
204+ (uint32_t)strlen("testProviderName"),
205+ (uint8_t *)"testProviderName"
206+};
207+ 
208+static struct OH_Huks_ExternalCryptoParam g_abilityParams[] = {};
209+ 
210+static napi_value unregisterProvider(napi_env env, napi_callback_info info)
211+{
212+ struct OH_Huks_ExternalCryptoParamSet *providerParamSet = nullptr;
213+ OH_Huks_Result ohResult;
214+ do {
215+ ohResult = InitParamSet(&providerParamSet, g_abilityParams,
216+ sizeof(g_abilityParams) / sizeof(OH_Huks_ExternalCryptoParam));
217+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
218+ break;
219+ }
220+ ohResult = OH_Huks_UnregisterProvider(&g_providerName, providerParamSet);
221+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
222+ break;
223+ }
224+ } while (0);
225+ OH_Huks_FreeExternalCryptoParamSet(&providerParamSet);
226+ 
227+ napi_value ret;
228+ napi_create_int32(env, ohResult.errorCode, &ret);
229+ return ret;
230+}
231+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-external-hardware-key-management-overview.md+67-0
@@ -0,0 +1,67 @@
1+# 外部密钥管理扩展简介
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+HUKS提供外部密钥管理扩展能力，允许三方驱动HAP应用注册、注销自定义的硬件密钥管理模块。用于满足金融领域基于Ukey的浏览器双向SSL认证等场景的身份认证诉求。
11+ 
12+总体流程如下：
13+1. 驱动HAP应用根据业务场景编写应用自身的密钥管理拓展能力。
14+2. 驱动HAP需要将密钥管理扩展能力注册到系统HUKS服务中。
15+3. 浏览器等应用通过HUKS和[证书管理](../DeviceCertificateKit/certManager-overview.md)提供的API去使用驱动HAP提供的外部应用管理能力。包括证书查询、PIN码认证、签名验签等操作。
16+ 
17+整体架构如下：
18+1. 外部密钥管理扩展能力，需要驱动HAP应用开发。
19+2. 通过HUKS和[证书管理](../DeviceCertificateKit/certManager-overview.md)的SDK将驱动HAP提供的外部密钥管理能力开放出去。
20+ 
21+流程如下图所示：
22+ 
23+<div align=center>
24+ 
25+<img src=figures/huks_extension.png width=80% align=center/>
26+ 
27+</div>
28+ 
29+核心功能：
30+HUKS提供Provider管理接口，用于驱动HAP应用注册、注销外部密钥管理扩展能力。提供资源管理、PIN码管理、三段式密钥操作等能力，用于浏览器等应用操作外部密钥管理拓展中的密钥。
31+ 
32+## Provider管理
33+ 
34+| 功能 | 说明 |
35+| -------- | -------- |
36+| **[Provider管理](huks-provider-management-overview.md)** | 注册与注销外部硬件密钥的提供者。 |
37+ 
38+## 资源管理
39+ 
40+| 功能 | 说明 |
41+| -------- | -------- |
42+| **[资源管理](huks-resource-management-overview.md)** | 打开与关闭句柄资源。 |
43+ 
44+## 外部密钥操作
45+ 
46+| 功能 | 说明 |
47+| -------- | -------- |
48+| **[Ukey PIN码认证](huks-ukey-pin-authentication-management-overview.md)** | PC浏览器通过Ukey完成双向SSL认证，可获取认证状态。 |
49+| **[签名验签](huks-ukey-signing-signature-verification-overview.md)** | 用于认证消息内容以及消息发送者身份的真实性。 |
50+ 
51+## 通用操作
52+ 
53+| 功能 | 说明 |
54+| -------- | -------- |
55+| **[通用查询](huks-ukey-general-query-overview.md)** | 获取Ukey的密钥相关属性。 |
56+ 
57+## ExtensionAbility扩展能力
58+ 
59+| 功能 | 说明 |
60+| -------- | -------- |
61+| **[ExtensionAbility扩展能力](huks-extension-ability-support-overview.md)** | 应用接入ExtensionAbility。 |
62+ 
63+## HUKS接入外部硬件密钥管理
64+ 
65+HUKS接入外部硬件密钥管理，需要实现CryptoExtensionAbility接口。在开发前，需要先了解ExtensionAbility组件，建议参考[ExtensionAbility组件概述](../../application-models/extensionability-overview.md)。
66+ 
67+CryptoExtensionAbility是Stage模型中扩展组件ExtensionAbility的派生类。开发者可以通过修改配置文件，定制外部硬件密钥管理的行为，包括：调用外部硬件密钥管理的接口、外部硬件密钥管理的实现、外部硬件密钥管理的配置等，可以参考[ExtensionAbility适配开发指导](huks-extension-ability-support-dev.md)。
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-open-close-resource-ndk.md+176-0
@@ -0,0 +1,176 @@
1+# 打开资源/关闭资源(C/C++)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+## 打开资源
11+应用密钥操作之前（密钥操作、通用操作、PIN码认证等），需要先调用[OH_Huks_OpenResource](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_openresource)打开资源。打开资源需要获取resourceId，resourceId通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取。
12+ 
13+### 在CMake脚本中链接相关动态库
14+```txt
15+target_link_libraries(entry PUBLIC libhuks_ndk.z.so)
16+```
17+ 
18+### 开发步骤
19+ 
20+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId。
21+ 
22+2. 调用[OH_Huks_InitExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_initexternalcryptoparamset)初始化参数集。
23+ 
24+3. 调用[OH_Huks_AddExternalCryptoParams](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_addexternalcryptoparams)添加输入参数。
25+ 
26+4. 调用[OH_Huks_BuildExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_buildexternalcryptoparamset)构建参数集。
27+ 
28+5. 调用[OH_Huks_OpenResource](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_openresource)打开资源。
29+ 
30+```c++
31+#include "huks/native_huks_external_crypto_api.h"
32+#include "huks/native_huks_param.h"
33+#include "napi/native_api.h"
34+#include <string.h>
35+ 
36+OH_Huks_Result InitParamSet(
37+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
38+ const struct OH_Huks_ExternalCryptoParam *params,
39+ uint32_t paramCount)
40+{
41+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
42+ if (ret.errorCode != OH_HUKS_SUCCESS) {
43+ return ret;
44+ }
45+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
46+ if (ret.errorCode != OH_HUKS_SUCCESS) {
47+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
48+ return ret;
49+ }
50+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
51+ if (ret.errorCode != OH_HUKS_SUCCESS) {
52+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
53+ return ret;
54+ }
55+ return ret;
56+}
57+ 
58+static const char *resourceId = "{\"providerName\":\"testProviderName\",\"abilityName\":\"CryptoExtension\",\"bundleName\":\"com.example.cryptoapplication\",\"index\":{\"key\":\"testKey\"}}";
59+ 
60+static struct OH_Huks_ExternalCryptoParam g_openResourceParamsTest[] = {};
61+ 
62+static napi_value OpenResource(napi_env env, napi_callback_info info)
63+{
64+ struct OH_Huks_Blob g_resourceId = {
65+ (uint32_t)strlen(resourceId),
66+ (uint8_t *)resourceId
67+ };
68+ struct OH_Huks_ExternalCryptoParamSet *openResourceParamSet = nullptr;
69+ OH_Huks_Result ohResult;
70+ do {
71+ ohResult = InitParamSet(&openResourceParamSet, g_openResourceParamsTest,
72+ sizeof(g_openResourceParamsTest) / sizeof(OH_Huks_ExternalCryptoParam));
73+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
74+ break;
75+ }
76+ ohResult = OH_Huks_OpenResource(&g_resourceId, openResourceParamSet);
77+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
78+ break;
79+ }
80+ } while (0);
81+ OH_Huks_FreeExternalCryptoParamSet(&openResourceParamSet);
82+
83+ napi_value ret;
84+ napi_create_int32(env, ohResult.errorCode, &ret);
85+ return ret;
86+}
87+```
88+ 
89+## 关闭资源
90+ 
91+<!--Kit: Universal Keystore Kit-->
92+<!--Subsystem: Security-->
93+<!--Owner: @wutiantian-gitee-->
94+<!--Designer: @HighLowWorld-->
95+<!--Tester: @wxy1234564846-->
96+<!--Adviser: @zengyawen-->
97+ 
98+生态应用调用证书HAP界面，展示证书列表，用户选择证书，生态应用拿到对应的resourceId，关闭资源依赖于对应的resourceId。具体的场景介绍及规格，请参考[资源管理介绍及规格](huks-resource-management-overview.md)。
99+ 
100+### 在CMake脚本中链接相关动态库
101+```txt
102+target_link_libraries(entry PUBLIC libhuks_ndk.z.so)
103+```
104+ 
105+### 开发步骤
106+ 
107+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId。
108+ 
109+2. 调用[OH_Huks_InitExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_initexternalcryptoparamset)初始化参数集。
110+ 
111+3. 调用[OH_Huks_AddExternalCryptoParams](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_addexternalcryptoparams)添加输入参数。
112+ 
113+4. 调用[OH_Huks_BuildExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_buildexternalcryptoparamset)构建参数集。
114+ 
115+5. 调用[OH_Huks_CloseResource](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_closeresource)关闭资源。
116+ 
117+```c++
118+#include "huks/native_huks_external_crypto_api.h"
119+#include "huks/native_huks_param.h"
120+#include "huks/native_huks_type.h"
121+#include "huks/native_huks_api.h"
122+#include "napi/native_api.h"
123+#include <string.h>
124+ 
125+OH_Huks_Result InitParamSet(
126+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
127+ const struct OH_Huks_ExternalCryptoParam *params,
128+ uint32_t paramCount)
129+{
130+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
131+ if (ret.errorCode != OH_HUKS_SUCCESS) {
132+ return ret;
133+ }
134+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
135+ if (ret.errorCode != OH_HUKS_SUCCESS) {
136+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
137+ return ret;
138+ }
139+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
140+ if (ret.errorCode != OH_HUKS_SUCCESS) {
141+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
142+ return ret;
143+ }
144+ return ret;
145+}
146+ 
147+static const char *resourceId = "{\"providerName\":\"testProviderName\",\"abilityName\":\"CryptoExtension\",\"bundleName\":\"com.example.cryptoapplication\",\"index\":{\"key\":\"testKey\"}}";
148+ 
149+static struct OH_Huks_ExternalCryptoParam g_closeResourceParamsTest[] = {};
150+ 
151+static napi_value CloseResource(napi_env env, napi_callback_info info)
152+{
153+ struct OH_Huks_Blob g_resourceId = {
154+ (uint32_t)strlen(resourceId),
155+ (uint8_t *)resourceId
156+ };
157+ struct OH_Huks_ExternalCryptoParamSet *closeResourceParamSet = nullptr;
158+ OH_Huks_Result ohResult;
159+ do {
160+ ohResult = InitParamSet(&closeResourceParamSet, g_closeResourceParamsTest,
161+ sizeof(g_closeResourceParamsTest) / sizeof(OH_Huks_ExternalCryptoParam));
162+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
163+ break;
164+ }
165+ ohResult = OH_Huks_CloseResource(&g_resourceId, closeResourceParamSet);
166+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
167+ break;
168+ }
169+ } while (0);
170+ OH_Huks_FreeExternalCryptoParamSet(&closeResourceParamSet);
171+
172+ napi_value ret;
173+ napi_create_int32(env, ohResult.errorCode, &ret);
174+ return ret;
175+}
176+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-provider-management-overview.md+22-0
@@ -0,0 +1,22 @@
1+# Provider管理介绍及规格
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+HUKS 提供外部密钥管理扩展能力（简称Provider）注册和注销接口。三方驱动HAP检测到Ukey存在时，调用Provider注册接口，将驱动HAP应用提供外部密钥管理能力注册到系统中来。当检测到所有Ukey被拔出时，通过调用Provider注销接口，将其提供的外部密钥管理能力从系统中注销。
11+ 
12+> **说明：**
13+> 1. Provider名称建议包含厂商信息，全局唯一。
14+> 2. Provider名称长度最大为128字节。
15+> 3. Provider注册和注销有权限管控，需申请ohos.permission.CRYPTO_EXTENSION_REGISTER权限。
16+ 
17+**支持功能规格：**
18+ 
19+| 功能 | 说明 | API级别 |
20+| -------- | -------- | -------- |
21+| Provider注册 | 注册外部密钥管理扩展能力提供者到系统。 | 22+ |
22+| Provider注销 | 从系统中注销外部密钥管理扩展提供者。 | 22+ |
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-query-authentication-status-arkts.md+52-0
@@ -0,0 +1,52 @@
1+# 查询认证状态(ArkTS)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+HUKS提供认证状态查询接口，应用可以通过该接口查询PIN码是否认证通过。具体的场景介绍及规格，请参考[Ukey PIN码认证介绍及规格](huks-ukey-pin-authentication-management-overview.md)。
11+ 
12+## 开发步骤
13+ 
14+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId。
15+ 
16+2. 调用查询认证状态接口[getUkeyPinAuthState](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptogetukeypinauthstate)验证PIN码。
17+ 
18+```ts
19+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
20+import { BusinessError } from "@kit.BasicServicesKit";
21+ 
22+async function getUkeyPinAuthState(): Promise<boolean> {
23+ let ret: boolean = false;
24+ try {
25+ /* 1.构造查询PIN码状态参数 */
26+ const testResourceId = "{\"providerName\":\"testProviderName\", \"bundleName\":\"com.example.cryptoapplication\", \"abilityName\":\"CryptoExtension\",\"index\":{\"key\":\"testKey\"}}";
27+ const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [];
28+ 
29+ /* 2.调用getUkeyPinAuthState */
30+ await huksExternalCrypto.getUkeyPinAuthState(testResourceId, extProperties)
31+ .then(() => {
32+ console.info(`promise: getUkeyPinAuthState success`);
33+ ret = true;
34+ }).catch((error: BusinessError) => {
35+ console.error(`promise: getUkeyPinAuthState failed, errCode : ${error.code}, errMsg : ${error.message}`);
36+ });
37+ } catch (error) {
38+ console.error(`promise: getUkeyPinAuthState input arg invalid`);
39+ }
40+ return ret;
41+}
42+ 
43+async function testGetUkeyPinAuthState() {
44+ let ret: boolean = await getUkeyPinAuthState();
45+ if (ret == false) {
46+ console.error(`getUkeyPinAuthState failed`);
47+ return;
48+ }
49+ 
50+ console.info(`getUkeyPinAuthState success`);
51+}
52+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-query-authentication-status-ndk.md+84-0
@@ -0,0 +1,84 @@
1+# 查询认证状态(C/C++)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+HUKS提供认证状态查询接口，应用可以通过该接口查询PIN码是否认证通过。具体的场景介绍及规格，请参考[Ukey PIN码认证介绍及规格](huks-ukey-pin-authentication-management-overview.md)。
11+ 
12+## 在CMake脚本中链接相关动态库
13+```txt
14+target_link_libraries(entry PUBLIC libhuks_ndk.z.so)
15+```
16+ 
17+## 开发步骤
18+ 
19+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId。
20+ 
21+2. 调用[OH_Huks_InitExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-param-h.md#oh_huks_initparamset)指定参数配置。
22+ 
23+3. 调用[OH_Huks_GetUkeyPinAuthState](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_getukeypinauthstate)获取PIN码认证状态。
24+ 
25+ 
26+```c++
27+#include "huks/native_huks_external_crypto_api.h"
28+#include "huks/native_huks_param.h"
29+#include "napi/native_api.h"
30+#include <string.h>
31+ 
32+OH_Huks_Result InitParamSet(
33+ struct OH_Huks_ExternalCryptoParamSet **paramSet,
34+ const struct OH_Huks_ExternalCryptoParam *params,
35+ uint32_t paramCount)
36+{
37+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
38+ if (ret.errorCode != OH_HUKS_SUCCESS) {
39+ return ret;
40+ }
41+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
42+ if (ret.errorCode != OH_HUKS_SUCCESS) {
43+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
44+ return ret;
45+ }
46+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
47+ if (ret.errorCode != OH_HUKS_SUCCESS) {
48+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
49+ return ret;
50+ }
51+ return ret;
52+}
53+ 
54+static const char *resourceId = "{\"providerName\":\"testProviderName\",\"abilityName\":\"CryptoExtension\",\"bundleName\":\"com.example.cryptoapplication\",\"index\":{\"key\":\"testKey\"}}";
55+ 
56+static struct OH_Huks_ExternalCryptoParam g_getPinStateParamsTest[] = {};
57+ 
58+static napi_value GetUkeyPinAuthState(napi_env env, napi_callback_info info)
59+{
60+ struct OH_Huks_Blob g_resourceId = {
61+ (uint32_t)strlen(resourceId),
62+ (uint8_t *)resourceId
63+ };
64+ struct OH_Huks_ExternalCryptoParamSet *pinStateParamSet = nullptr;
65+ bool authState = true;
66+ OH_Huks_Result ohResult;
67+ do {
68+ ohResult = InitParamSet(&pinStateParamSet, g_getPinStateParamsTest,
69+ sizeof(g_getPinStateParamsTest) / sizeof(OH_Huks_ExternalCryptoParam));
70+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
71+ break;
72+ }
73+ ohResult = OH_Huks_GetUkeyPinAuthState(&g_resourceId, pinStateParamSet, &authState);
74+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
75+ break;
76+ }
77+ } while (0);
78+ OH_Huks_FreeExternalCryptoParamSet(&pinStateParamSet);
79+
80+ napi_value ret;
81+ napi_create_int32(env, ohResult.errorCode, &ret);
82+ return ret;
83+}
84+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-resource-management-overview.md+15-0
@@ -0,0 +1,15 @@
1+# 资源管理介绍及规格
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+约定外部密钥管理扩展（例如Ukey）中使用resourceId唯一标识资源。该resourceId目前支持通过[查询证书操作](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)返回。每个证书链对应1个resourceId。应用拿到resourceId后，需要[打开资源](huks-open-close-resource-ndk.md)，然后才可以进行后续密钥操作。操作完成后[关闭资源](huks-open-close-resource-ndk.md)。
11+ 
12+> **说明：**
13+>
14+> 1. 操作密钥之前，必须先打开资源。如果涉及私钥签名等高权限操作，需要验证完PIN码后，才能继续执行，否则导致资源状态异常。
15+> 2. 用户操作之后，必须手动关闭资源，避免资源泄漏。
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-ukey-general-query-ndk.md+130-0
@@ -0,0 +1,130 @@
1+# 通用查询(C/C++)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+从Ukey获取通用属性信息，完成属性查询操作。具体的场景介绍请参考[获取属性介绍及规格](huks-ukey-general-query-overview.md)。
11+ 
12+## 在CMake脚本中链接相关动态库
13+```txt
14+target_link_libraries(entry PUBLIC libhuks_ndk.z.so)
15+```
16+ 
17+## 开发步骤
18+ 
19+**获取属性**
20+ 
21+1. 构造resourceId和propertyId，先调用[OH_Huks_OpenResource](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_openresource)打开资源。
22+ 
23+2. 调用[OH_Huks_InitExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_initexternalcryptoparamset)初始化参数集。
24+ 
25+3. 调用[OH_Huks_AddExternalCryptoParams](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_addexternalcryptoparams)添加输入参数。
26+ 
27+4. 调用[OH_Huks_BuildExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_buildexternalcryptoparamset)构建参数集。
28+ 
29+5. 调用[OH_Huks_GetProperty](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_getproperty)获取属性信息。
30+ 
31+6. 调用[OH_Huks_GetExternalCryptoParam](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_getexternalcryptoparam)从输出参数集中提取结果。
32+ 
33+7. 调用[OH_Huks_FreeExternalCryptoParamSet](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_freeexternalcryptoparamset)释放参数集资源。
34+ 
35+```c++
36+#include "huks/native_huks_external_crypto_api.h"
37+#include "huks/native_huks_external_crypto_type.h"
38+#include "napi/native_api.h"
39+#include <string.h>
40+ 
41+OH_Huks_Result InitExternalCryptoParamSet(
42+ OH_Huks_ExternalCryptoParamSet **paramSet,
43+ const OH_Huks_ExternalCryptoParam *params,
44+ uint32_t paramCount)
45+{
46+ OH_Huks_Result ret = OH_Huks_InitExternalCryptoParamSet(paramSet);
47+ if (ret.errorCode != OH_HUKS_SUCCESS) {
48+ return ret;
49+ }
50+ ret = OH_Huks_AddExternalCryptoParams(*paramSet, params, paramCount);
51+ if (ret.errorCode != OH_HUKS_SUCCESS) {
52+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
53+ return ret;
54+ }
55+ ret = OH_Huks_BuildExternalCryptoParamSet(paramSet);
56+ if (ret.errorCode != OH_HUKS_SUCCESS) {
57+ OH_Huks_FreeExternalCryptoParamSet(paramSet);
58+ return ret;
59+ }
60+ return ret;
61+}
62+ 
63+static napi_value GetProperty(napi_env env, napi_callback_info info)
64+{
65+ /* 1.假设已经打开了resourceId */
66+ const char *resourceIdStr = "testResourceId";
67+ const char *propertyIdStr = "SKF_GetDevInfo"; // 定义在GMT 0016-2023标准中的属性函数名称
68+
69+ struct OH_Huks_Blob resourceId = {
70+ (uint32_t)strlen(resourceIdStr),
71+ (uint8_t *)resourceIdStr
72+ };
73+ struct OH_Huks_Blob propertyId = {
74+ (uint32_t)strlen(propertyIdStr),
75+ (uint8_t *)propertyIdStr
76+ };
77+
78+ /* 2.构造输入参数 */
79+ OH_Huks_ExternalCryptoParam params[] = {};
80+ OH_Huks_ExternalCryptoParamSet *paramSetIn = nullptr;
81+ OH_Huks_ExternalCryptoParamSet *paramSetOut = nullptr;
82+ OH_Huks_Result ohResult;
83+
84+ do {
85+ /* 3.初始化并构建输入参数集 */
86+ ohResult = InitExternalCryptoParamSet(&paramSetIn, params,
87+ sizeof(params) / sizeof(OH_Huks_ExternalCryptoParam));
88+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
89+ break;
90+ }
91+
92+ /* 4.调用OH_Huks_GetProperty获取属性 */
93+ ohResult = OH_Huks_GetProperty(&resourceId, &propertyId, paramSetIn, &paramSetOut);
94+ if (ohResult.errorCode != OH_HUKS_SUCCESS) {
95+ break;
96+ }
97+
98+ /* 5.从输出参数集中提取结果
99+ * 输出参数集由函数内部分配，查询到的属性数据放在 OH_HUKS_EXT_CRYPTO_TAG_EXTRA_DATA TAG 中。
100+ * 下面展示如何遍历返回的 params 并安全提取返回的属性字符串（示例）。
101+ */
102+ if (paramSetOut != nullptr && paramSetOut->paramsCnt > 0) {
103+ for (uint32_t i = 0; i < paramSetOut->paramsCnt; i++) {
104+ OH_Huks_ExternalCryptoParam *param = &paramSetOut->params[i];
105+ /* 返回数据约定：GetProperty 的结果放在 OH_HUKS_EXT_CRYPTO_TAG_EXTRA_DATA TAG 中（示例使用 JSON 文本）*/
106+ if (param->tag == OH_HUKS_EXT_CRYPTO_TAG_EXTRA_DATA) {
107+ /* 注意：param->blob.data 可能不是以 '\0' 结尾，需拷贝并手动添加终止符 */
108+ char *outStr = (char *)malloc(param->blob.size + 1);
109+ if (outStr != NULL) {
110+ memcpy(outStr, param->blob.data, param->blob.size);
111+ outStr[param->blob.size] = '\0';
112+ // 解析 outStr（例如使用 JSON 解析库），示例：
113+ // parse_json(outStr);
114+ free(outStr);
115+ }
116+ }
117+ }
118+ }
119+ } while (0);
120+
121+ /* 6.释放资源 */
122+ OH_Huks_FreeExternalCryptoParamSet(&paramSetIn);
123+ OH_Huks_FreeExternalCryptoParamSet(&paramSetOut);
124+
125+ napi_value ret;
126+ napi_create_int32(env, ohResult.errorCode, &ret);
127+ return ret;
128+}
129+```
130+ 
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-ukey-general-query-overview.md+29-0
@@ -0,0 +1,29 @@
1+# 通用查询介绍及规格
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+HUKS提供属性查询接口，支持从外部密钥管理执行通用查询操作，例如Ukey设备信息、PIN码信息等。
11+ 
12+> **说明：**
13+> 1. [OH_Huks_GetPropert接口](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-api-h.md#oh_huks_getproperty)的resourceId是提供者的资源ID，用于标识要查询的远程资源，长度必须介于1-1024字节。接口的属性ID采用定义在 GMT 0016-2023 标准中的SKF函数名称，长度必须介于 1-100 字节。
14+> 2. 输出参数通过[HUKS_EXT_CRYPTO_TAG_EXTRA_DATA](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto.md#huksexternalcryptotag)携带,应用可以提取该查询出的属性数据，并按照跟驱动应用（外部密钥管理扩展能力提供方）的约定，解析数据。
15+ 
16+## 支持的属性函数名称（示例）
17+ 
18+下列为部分属性函数名称示例，供实现方参考（更多详细且权威的函数名请参考 GMT 0016-2023 标准）：
19+ 
20+| 函数名 | 说明 |
21+| -------- | -------- |
22+| SKF_GetDevInfo | 获取设备信息。 |
23+| SKF_GetDevState | 获取设备状态。 |
24+| SKF_GetPINInfo | 获得PIN码信息。 |
25+| SKF_ExportPublicKey | 导出公钥。 |
26+| SKF_EnumApplication | 枚举应用。 |
27+ 
28+> **说明：**
29+实际实现应与 GMT 0016-2023 中规定的函数名保持一致。各方（调用端和CryptoExtension实现）需约定使用的函数名集合及其参数/返回格式。
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-ukey-pin-authentication-arkts.md+67-0
@@ -0,0 +1,67 @@
1+# Ukey PIN码认证(ArkTS)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+生态应用调用证书HAP界面，展示证书列表，用户选择证书后，浏览器根据选择的证书获取到resourceId，然后[打开资源](huks-open-close-resource-ndk.md)并进入PIN码认证。具体的场景介绍，请参考[Ukey PIN码认证介绍](huks-ukey-pin-authentication-management-overview.md)。
11+ 
12+## 开发步骤
13+ 
14+1. [打开资源](huks-open-close-resource-ndk.md)。
15+ 
16+2. 构造参数，必传 [HUKS_EXT_CRYPTO_TAG_UID](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-type-h.md#oh_huks_externalcryptotag)和[HUKS_EXT_CRYPTO_TAG_UKEY_PIN](../../reference/apis-universal-keystore-kit/capi-native-huks-external-crypto-type-h.md#oh_huks_externalcryptotag)。
17+ 
18+3. 调用接口[authUkeyPin](../../reference/apis-universal-keystore-kit/js-apis-huksExternalCrypto-sys.md#huksexternalcryptoauthukeypin)验证PIN码。
19+ 
20+```ts
21+import { BusinessError } from "@kit.BasicServicesKit";
22+import { huksExternalCrypto } from '@kit.UniversalKeystoreKit';
23+ 
24+function StringToUint8Array(str: string) {
25+ let arr: number[] = [];
26+ for (let i = 0, j = str.length; i < j; ++i) {
27+ arr.push(str.charCodeAt(i));
28+ }
29+ return new Uint8Array(arr);
30+}
31+ 
32+// uid由调用方自己获取
33+let uid: number = 3511
34+ 
35+async function authUkeyPin(): Promise<void> {
36+ try {
37+ /* 1.假设已打开的资源如下 */
38+ const testResourceId = "{\"providerName\":\"testProviderName\", \"bundleName\":\"com.example.cryptoapplication\", \"abilityName\":\"CryptoExtension\",\"index\":{\"key\":\"testKey\"}}";
39+ 
40+ /* 2.构造参数 */
41+ const pin = "123456";
42+ const extProperties: Array<huksExternalCrypto.HuksExternalCryptoParam> = [
43+ {
44+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_UID,
45+ value: uid
46+ }, {
47+ tag: huksExternalCrypto.HuksExternalCryptoTag.HUKS_EXT_CRYPTO_TAG_UKEY_PIN,
48+ value: StringToUint8Array(pin)
49+ }
50+ ];
51+ 
52+ /* 3.验证PIN码 */
53+ await huksExternalCrypto.authUkeyPin(testResourceId, extProperties)
54+ .then(() => {
55+ console.info(`promise: getUkeyPinAuthState success`);
56+ }).catch((error: BusinessError) => {
57+ console.error(`promise: getUkeyPinAuthState failed, errCode : ${error.code}, errMsg : ${error.message}`);
58+ });
59+ } catch (error) {
60+ console.error(`promise: getUkeyPinAuthState input arg invalid`);
61+ }
62+}
63+ 
64+async function TestAuthUkeyPin() {
65+ await authUkeyPin();
66+}
67+```
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-ukey-pin-authentication-management-overview.md+20-0
@@ -0,0 +1,20 @@
1+# Ukey PIN码认证介绍及规格
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+PIN（Personal Identification Number）码是Ukey设备的安全访问凭证，采用“硬件设备+PIN码”的双因子认证模式。用户必须同时拥有物理Ukey设备和正确的PIN码才能访问设备内的密钥材料。
11+ 
12+PIN码作用如下：
13+1. 防暴力破解：连续错误输入达到一定次数（与由驱动应用实现的外部密钥管理扩展能力相关）后自动锁定。
14+ 
15+2. 硬件级安全：PIN码验证在Ukey硬件内完成，敏感信息不出硬件。
16+ 
17+Ukey使用resourceId标识Ukey资源，生态应用打开资源之后，如需要操作resourceId对应的私钥执行签名操作，则需要先验证PIN码。
18+ 
19+> **说明：**
20+> HUKS提供PIN码认证能力和认证状态查询能力。应用PIN码认证之前，可以先查询认证状态。如果需要PIN码认证，则需要拉起[证书管理应用](../DeviceCertificateKit/certManager-overview.md)，完成PIN码认证。
Azh-cn/application-dev/security/UniversalKeystoreKit/huks-ukey-signing-signature-verification-arkts.md+203-0
@@ -0,0 +1,203 @@
1+# 签名/验签(ArkTS)
2+ 
3+<!--Kit: Universal Keystore Kit-->
4+<!--Subsystem: Security-->
5+<!--Owner: @wutiantian-gitee-->
6+<!--Designer: @HighLowWorld-->
7+<!--Tester: @wxy1234564846-->
8+<!--Adviser: @zengyawen-->
9+ 
10+当前指导提供以下示例，供开发者参考完成签名、验签开发：
11+ 
12+- [密钥算法为RSA、摘要算法为SHA256、填充模式为PSS](#rsasha256pss)
13+<!--RP1--><!--RP1End-->
14+ 
15+具体的场景介绍及支持的算法规格，请参考[签名/验签支持的算法](huks-ukey-signing-signature-verification-overview.md#规格)。
16+ 
17+## 开发步骤
18+ 
19+**签名**
20+ 
21+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId作为密钥别名，并[打开资源](huks-open-close-resource-ndk.md)完成[PIN码认证](huks-ukey-pin-authentication-arkts.md)。
22+ 
23+2. 指定待签名的明文数据。
24+ 
25+3. 获取属性参数[HuksOptions](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksoptions)，包括两个字段properties和inData。inData传入明文数据，properties传入[算法参数配置](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksparam)。
26+ 
27+4. 调用[initSession](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksinitsession9)初始化密钥会话，并获取会话的句柄handle。
28+ 
29+5. 调用[finishSession](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksfinishsession9)结束密钥会话，获取签名signature。
30+ 
31+**验签**
32+ 
33+1. 通过[证书管理应用](../../reference/apis-device-certificate-kit/js-apis-certManagerDialog.md#certificatemanagerdialogopenauthorizedialog22)获取resourceId作为密钥别名，并[打开资源](huks-open-close-resource-ndk.md)。
34+ 
35+2. 获取待验证的签名。
36+ 
37+3. 获取属性参数[HuksOptions](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksoptions)，包括两个字段properties和inData。inData传入签名signature，properties传入[算法参数配置](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksparam)。
38+ 
39+4. 调用[initSession](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksinitsession9)初始化密钥会话，并获取会话的句柄handle。
40+ 
41+5. 调用[updateSession](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksupdatesession9)更新密钥会话。
42+ 
43+6. 调用[finishSession](../../reference/apis-universal-keystore-kit/js-apis-huks.md#huksfinishsession9)结束密钥会话，验证签名。
44+ 
45+## 开发案例
46+ 
47+### RSA/SHA256/PSS
48+```ts
49+/*
50+ * 密钥算法为RSA，摘要算法为SHA256，填充模式为PSS
51+ */
52+import { huks } from '@kit.UniversalKeystoreKit';
53+import { BusinessError } from "@kit.BasicServicesKit";
54+ 
55+// 假设keyAlias是已获取的resourceId
56+let keyAlias = "{\"providerName\":\"testProviderName\",\"abilityName\":\"CryptoExtension\",\"bundleName\":\"com.example.cryptoapplication\",\"index\":{\"key\":\"testKey\"}}";
57+let handle: number;
58+let plaintext = '123456';
59+let signature: Uint8Array;
60+ 
61+function StringToUint8Array(str: string) {
62+ let arr: number[] = [];
63+ for (let i = 0, j = str.length; i < j; ++i) {
64+ arr.push(str.charCodeAt(i));
65+ }
66+ return new Uint8Array(arr);
67+}
68+ 
69+function Uint8ArrayToString(fileData: Uint8Array) {
70+ let dataString = '';
71+ for (let i = 0; i < fileData.length; i++) {
72+ dataString += String.fromCharCode(fileData[i]);
73+ }
74+ return dataString;
75+}
76+ 
77+function GetRsaSignProperties() {
78+ let properties: Array<huks.HuksParam> = [{
79+ tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
80+ value: huks.HuksKeyAlg.HUKS_ALG_RSA
81+ }, {
82+ tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
83+ value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048
84+ }, {
85+ tag: huks.HuksTag.HUKS_TAG_PADDING,
86+ value: huks.HuksKeyPadding.HUKS_PADDING_PSS
87+ }, {
88+ tag: huks.HuksTag.HUKS_TAG_DIGEST,
89+ value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
90+ }, {
91+ tag: huks.HuksTag.HUKS_TAG_PURPOSE,
92+ value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN
93+ }, {
94+ tag: huks.HuksTag.HUKS_TAG_KEY_CLASS,
95+ value: huks.HuksKeyClassType.HUKS_KEY_CLASS_EXTENSION
96+ }];
97+ return properties;
98+}
99+ 
100+function GetRsaVerifyProperties() {
101+ let properties: Array<huks.HuksParam> = [{
102+ tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
103+ value: huks.HuksKeyAlg.HUKS_ALG_RSA
104+ }, {
105+ tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
106+ value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048
107+ }, {
108+ tag: huks.HuksTag.HUKS_TAG_PADDING,
109+ value: huks.HuksKeyPadding.HUKS_PADDING_PSS
110+ }, {
111+ tag: huks.HuksTag.HUKS_TAG_DIGEST,
112+ value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
113+ }, {
114+ tag: huks.HuksTag.HUKS_TAG_PURPOSE,
115+ value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY
116+ }, {
117+ tag: huks.HuksTag.HUKS_TAG_KEY_CLASS,
118+ value: huks.HuksKeyClassType.HUKS_KEY_CLASS_EXTENSION
119+ }];
120+ return properties;
121+}
122+ 
123+async function initSession(keyAlias: string, huksOptions: huks.HuksOptions) {
124+ console.info(`promise: enter initSession`);
125+ try {
126+ await huks.initSession(keyAlias, huksOptions)
127+ .then((data) => {
128+ handle = data.handle;
129+ console.info(`promise: initSession success`);
130+ }).catch((error: BusinessError) => {
131+ console.error(`promise: initSession failed, errCode : ${error.code}, errMsg : ${error.message}`);
132+ })
133+ } catch (error) {
134+ console.error(`promise: initSession input arg invalid`);
135+ }
136+}
137+ 
138+async function updateSession(handle: number, huksOptions: huks.HuksOptions) {
139+ console.info(`promise: enter updateSession`);
140+ try {
141+ await huks.updateSession(handle, huksOptions)
142+ .then((data) => {
143+ let outData = data.outData as Uint8Array;
144+ console.info(`promise: updateSession success, data = ${Uint8ArrayToString(outData)}`);
145+ }).catch((error: BusinessError) => {
146+ console.error(`promise: updateSession failed, errCode : ${error.code}, errMsg : ${error.message}`);
147+ })
148+ } catch (error) {
149+ console.error(`promise: updateSession input arg invalid`);
150+ }
151+}
152+ 
153+async function finishSession(handle: number, huksOptions: huks.HuksOptions) {
154+ console.info(`promise: enter finishSession`);
155+ try {
156+ await huks.finishSession(handle, huksOptions)
157+ .then((data) => {
158+ signature = data.outData as Uint8Array;
159+ console.info(`promise: finishSession success, data = ${Uint8ArrayToString(signature)}`);
160+ }).catch((error: BusinessError) => {
161+ console.error(`promise: finishSession failed, errCode : ${error.code}, errMsg : ${error.message}`);
162+ })
163+ } catch (error) {
164+ console.error(`promise: finishSession input arg invalid`);
165+ }
166+}
167+ 
168+async function Sign(keyAlias: string, plaintext: string) {
169+ console.info(`enter Sign`);
170+ let signProperties = GetRsaSignProperties();
171+ let options: huks.HuksOptions = {
172+ properties: signProperties,
173+ inData: StringToUint8Array(plaintext)
174+ }
175+ await initSession(keyAlias, options);
176+ 
177+ if (handle !== undefined) {
178+ await finishSession(handle, options);
179+ }
180+}
181+ 
182+async function Verify(keyAlias: string, plaintext: string, signature: Uint8Array) {
183+ console.info(`enter Verify`);
184+ let verifyProperties = GetRsaVerifyProperties();
185+ let options: huks.HuksOptions = {
186+ properties: verifyProperties,
187+ inData: StringToUint8Array(plaintext)
188+ }
189+ 
190+ await initSession(keyAlias, options);
191+ 
192+ if (handle !== undefined) {
193+ await updateSession(handle, options);
194+ options.inData = signature;
195+ await finishSession(handle, options);
196+ }
197+}
198+ 
199+async function testSignVerify() {
200+ await Sign(keyAlias, plaintext);
201+ await Verify(keyAlias, plaintext, signature);
202+}
203+```