1# @ohos.security.huks (通用密钥库系统) 2 3<!--Kit: Universal Keystore Kit--> 4<!--Subsystem: Security--> 5<!--Owner: @wutiantian-gitee--> 6<!--Designer: @HighLowWorld--> 7<!--Tester: @wxy1234564846--> 8<!--Adviser: @zengyawen--> 9 10向应用提供密钥库能力，包括密钥管理及密钥的密码学操作等功能。 11HUKS所管理的密钥可以由应用导入或者由应用调用HUKS接口生成。 12 13> **说明** 14> 15> 本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 16 17## 导入模块 18 19```ts 20import { huks } from '@kit.UniversalKeystoreKit'; 21``` 22 23## HuksParam 24 25调用接口使用的options中的properties数组中的param。 26 27**系统能力：** SystemCapability.Security.Huks.Core 28 29| 名称 | 类型 | 必填 | 说明 | 30| ------ | ----------------------------------- | ---- | ------------ | 31| tag | [HuksTag](#hukstag) | 是 | 标签。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 32| value | boolean\|number\|bigint\|Uint8Array | 是 | 标签对应值。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 33 34## HuksOptions 35 36调用接口使用的options。 37 38**系统能力：** SystemCapability.Security.Huks.Core 39 40| 名称 | 类型 | 必填 | 说明 | 41| ---------- | ----------------- | ---- | ------------------------ | 42| properties | Array\<[HuksParam](#huksparam)> | 否 | 属性，用于存HuksParam的数组。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 43| inData | Uint8Array | 否 | 输入数据。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 44 45## HuksSessionHandle<sup>9+</sup> 46 47huks Handle结构体。 48 49**系统能力：** SystemCapability.Security.Huks.Core 50 51| 名称 | 类型 | 必填 | 说明 | 52| --------- | ---------- | ---- | ---------------------------------------------------- | 53| handle | number | 是 | 表示无符号整数类型的handle值。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 54| challenge | Uint8Array | 否 | 表示[initSession](#huksinitsession9)操作之后获取到的challenge信息。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 55 56## HuksReturnResult<sup>9+</sup> 57 58调用接口返回的result。 59 60**系统能力：** SystemCapability.Security.Huks.Core 61 62| 名称 | 类型 | 必填 | 说明 | 63| ---------- | ------------------------------- | ---- | ---------------- | 64| outData | Uint8Array | 否 | 表示输出数据。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 65| properties | Array\<[HuksParam](#huksparam)> | 否 | 表示属性信息。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 66| certChains | Array\<string> | 否 | 表示证书链数据。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 67 68## HuksListAliasesReturnResult<sup>12+</sup> 69 70调用接口返回的result。 71 72**系统能力**：SystemCapability.Security.Huks.Extension 73 74 75 76| 名称 | 类型 | 必填 | 说明 | 77| ---------- | ------------------------------- | ---- | ---------------- | 78| keyAliases | Array\<string> | 是 | 表示密钥别名集。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 79 80## huks.generateKeyItem<sup>9+</sup> 81 82generateKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 83 84生成密钥，使用Callback回调异步返回结果。 85 86**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 87 88**系统能力：** SystemCapability.Security.Huks.Core 89 90**参数：** 91 92| 参数名 | 类型 | 必填 | 说明 | 93| -------- | --------------------------- | ---- | --------------------------------------------- | 94| keyAlias | string | 是 | 别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 95| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 96| callback | AsyncCallback\<void> | 是 | 回调函数。未捕获error时代表用户指定别名的密钥生成成功，基于密钥不出TEE原则，此接口不会返回密钥材料内容，若捕获error，则为生成阶段出现异常。 | 97 98**错误码：** 99 100以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 101 102| 错误码ID | 错误信息 | 103| -------- | ------------- | 104| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 105| 801 | api is not supported. | 106| 12000001 | algorithm mode is not supported. | 107| 12000002 | algorithm param is missing. | 108| 12000003 | algorithm param is invalid. | 109| 12000004 | operating file failed. | 110| 12000005 | IPC communication failed. | 111| 12000006 | error occurred in crypto engine. | 112| 12000012 | Device environment or input parameter abnormal. | 113| 12000013 | queried credential does not exist. | 114| 12000014 | memory is insufficient. | 115| 12000015 | Failed to obtain the security information via UserIAM. | 116| 12000017 | The key with same alias is already exist. | 117 118**示例：** 119 120```ts 121import { huks } from '@kit.UniversalKeystoreKit'; 122/* 以生成ECC256密钥为例 */ 123let keyAlias: string = 'keyAlias'; 124let properties: Array<huks.HuksParam> =[ 125 { 126 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 127 value: huks.HuksKeyAlg.HUKS_ALG_ECC 128 }, 129 { 130 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 131 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 132 }, 133 { 134 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 135 value: 136 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 137 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 138 }, 139 { 140 tag: huks.HuksTag.HUKS_TAG_DIGEST, 141 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 142 }, 143]; 144let options: huks.HuksOptions = { 145 properties: properties 146}; 147huks.generateKeyItem(keyAlias, options, (error, data) => { 148 if (error) { 149 console.error(`callback: generateKeyItem failed`); 150 } else { 151 console.info(`callback: generateKeyItem key success`); 152 } 153}); 154 155``` 156 157## huks.generateKeyItem<sup>9+</sup> 158 159generateKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 160 161生成密钥，使用Promise方式异步返回结果。基于密钥不出TEE原则，通过promise不会返回密钥材料内容，只用于表示此次调用是否成功。 162 163**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 164 165**系统能力：** SystemCapability.Security.Huks.Extension 166 167**参数：** 168 169| 参数名 | 类型 | 必填 | 说明 | 170| -------- | --------------------------- | ---- | ------------------------ | 171| keyAlias | string | 是 | 密钥别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 172| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 173 174**返回值：** 175 176| 类型 | 说明 | 177| ---------------------------------------------- | --------------------------------------------- | 178| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 179 180**错误码：** 181 182以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 183 184| 错误码ID | 错误信息 | 185| -------- | ------------- | 186| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 187| 801 | api is not supported. | 188| 12000001 | algorithm mode is not supported. | 189| 12000002 | algorithm param is missing. | 190| 12000003 | algorithm param is invalid. | 191| 12000004 | operating file failed. | 192| 12000005 | IPC communication failed. | 193| 12000006 | error occurred in crypto engine. | 194| 12000012 | Device environment or input parameter abnormal. | 195| 12000013 | queried credential does not exist. | 196| 12000014 | memory is insufficient. | 197| 12000015 | Failed to obtain the security information via UserIAM. | 198| 12000017 | The key with same alias is already exist. | 199 200**示例：** 201 202```ts 203/* 以生成ECC256密钥为例 */ 204import { huks } from '@kit.UniversalKeystoreKit'; 205let keyAlias = 'keyAlias'; 206let properties: Array<huks.HuksParam> =[ 207 { 208 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 209 value: huks.HuksKeyAlg.HUKS_ALG_ECC 210 }, 211 { 212 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 213 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 214 }, 215 { 216 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 217 value: 218 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 219 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 220 }, 221 { 222 tag: huks.HuksTag.HUKS_TAG_DIGEST, 223 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 224 }, 225]; 226let options: huks.HuksOptions = { 227 properties: properties 228}; 229huks.generateKeyItem(keyAlias, options) 230 .then((data) => { 231 console.info(`promise: generateKeyItem success`); 232 }); 233``` 234 235## huks.deleteKeyItem<sup>9+</sup> 236 237deleteKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 238 239删除密钥，使用Callback回调异步返回结果。 240 241**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 242 243**系统能力：** SystemCapability.Security.Huks.Core 244 245**参数：** 246 247| 参数名 | 类型 | 必填 | 说明 | 248| -------- | --------------------------- | ---- | --------------------------------------------- | 249| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 250| options | [HuksOptions](#huksoptions) | 是 | 用于删除密钥时指定密钥的属性，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需删除密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 251| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 252 253**错误码：** 254 255以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 256 257| 错误码ID | 错误信息 | 258| -------- | ------------- | 259| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 260| 801 | api is not supported. | 261| 12000004 | operating file failed. | 262| 12000005 | IPC communication failed. | 263| 12000011 | queried entity does not exist. | 264| 12000012 | Device environment or input parameter abnormal. | 265| 12000014 | memory is insufficient. | 266 267**示例：** 268 269```ts 270import { huks } from '@kit.UniversalKeystoreKit'; 271/* 此处options选择emptyOptions传空 */ 272let keyAlias = 'keyAlias'; 273let emptyOptions: huks.HuksOptions = { 274 properties: [] 275}; 276huks.deleteKeyItem(keyAlias, emptyOptions, (error, data) => { 277 if (error) { 278 console.error(`callback: deleteKeyItem failed`); 279 } else { 280 console.info(`callback: deleteKeyItem key success`); 281 } 282}); 283``` 284 285## huks.deleteKeyItem<sup>9+</sup> 286 287deleteKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 288 289删除密钥，使用Promise方式异步返回结果。 290 291**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 292 293**系统能力：** SystemCapability.Security.Huks.Extension 294 295**参数：** 296 297| 参数名 | 类型 | 必填 | 说明 | 298| -------- | --------------------------- | ---- | ----------------------------------- | 299| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 300| options | [HuksOptions](#huksoptions) | 是 | 用于删除时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需删除密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 301 302**返回值：** 303 304| 类型 | 说明 | 305| ---------------------------------------------- | --------------------------------------------- | 306| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 307 308**错误码：** 309 310以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 311 312| 错误码ID | 错误信息 | 313| -------- | ------------- | 314| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 315| 801 | api is not supported. | 316| 12000004 | operating file failed. | 317| 12000005 | IPC communication failed. | 318| 12000011 | queried entity does not exist. | 319| 12000012 | Device environment or input parameter abnormal. | 320| 12000014 | memory is insufficient. | 321 322**示例：** 323 324```ts 325import { huks } from '@kit.UniversalKeystoreKit'; 326/* 此处options选择emptyOptions传空 */ 327let keyAlias = 'keyAlias'; 328let emptyOptions: huks.HuksOptions = { 329 properties: [] 330}; 331huks.deleteKeyItem(keyAlias, emptyOptions) 332 .then ((data) => { 333 console.info(`promise: deleteKeyItem key success`); 334 }); 335``` 336 337## huks.importKeyItem<sup>9+</sup> 338 339importKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 340 341导入明文密钥，使用Callback方式回调异步返回结果。 342 343**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 344 345**系统能力：** SystemCapability.Security.Huks.Core 346 347API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 348 349**参数：** 350 351| 参数名 | 类型 | 必填 | 说明 | 352| -------- | --------------------------- | ---- | --------------------------------------------- | 353| keyAlias | string | 是 | 密钥别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 354| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 355| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 356 357**错误码：** 358 359以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 360 361| 错误码ID | 错误信息 | 362| -------- | ------------- | 363| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 364| 801 | api is not supported. | 365| 12000001 | algorithm mode is not supported. | 366| 12000002 | algorithm param is missing. | 367| 12000003 | algorithm param is invalid. | 368| 12000004 | operating file failed. | 369| 12000005 | IPC communication failed. | 370| 12000006 | error occurred in crypto engine. | 371| 12000012 | Device environment or input parameter abnormal. | 372| 12000013 | queried credential does not exist. | 373| 12000014 | memory is insufficient. | 374| 12000015 | Failed to obtain the security information via UserIAM. | 375| 12000017 | The key with same alias is already exist. | 376 377**示例：** 378 379```ts 380import { huks } from '@kit.UniversalKeystoreKit'; 381/* 以导入AES256密钥为例 */ 382let plainTextSize32 = makeRandomArr(32); 383function makeRandomArr(size: number) { 384 let arr = new Uint8Array(size); 385 for (let i = 0; i < size; i++) { 386 arr[i] = Math.floor(Math.random() * 10); 387 } 388 return arr; 389}; 390let keyAlias = 'keyAlias'; 391let properties: Array<huks.HuksParam> = [ 392 { 393 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 394 value: huks.HuksKeyAlg.HUKS_ALG_AES 395 }, 396 { 397 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 398 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 399 }, 400 { 401 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 402 value: 403 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 404 }, 405 { 406 tag: huks.HuksTag.HUKS_TAG_PADDING, 407 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 408 }, 409 { 410 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 411 value: huks.HuksCipherMode.HUKS_MODE_ECB 412 } 413]; 414let options: huks.HuksOptions = { 415 properties: properties, 416 inData: plainTextSize32 417}; 418huks.importKeyItem(keyAlias, options, (error, data) => { 419 if (error) { 420 console.error(`callback: importKeyItem failed`); 421 } else { 422 console.info(`callback: importKeyItem success`); 423 } 424}); 425``` 426 427## huks.importKeyItem<sup>9+</sup> 428 429importKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 430 431导入明文密钥，使用Promise方式异步返回结果。 432 433**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 434 435**系统能力：** SystemCapability.Security.Huks.Extension 436 437**参数：** 438 439| 参数名 | 类型 | 必填 | 说明 | 440| -------- | --------------------------- | ---- | ----------------------------------- | 441| keyAlias | string | 是 | 密钥别名（密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇）。 | 442| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 443 444**返回值：** 445 446| 类型 | 说明 | 447| ---------------------------------------------- | --------------------------------------------- | 448| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 449 450**错误码：** 451 452以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 453 454| 错误码ID | 错误信息 | 455| -------- | ------------- | 456| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 457| 801 | api is not supported. | 458| 12000001 | algorithm mode is not supported. | 459| 12000002 | algorithm param is missing. | 460| 12000003 | algorithm param is invalid. | 461| 12000004 | operating file failed. | 462| 12000005 | IPC communication failed. | 463| 12000006 | error occurred in crypto engine. | 464| 12000012 | Device environment or input parameter abnormal. | 465| 12000013 | queried credential does not exist. | 466| 12000014 | memory is insufficient. | 467| 12000015 | Failed to obtain the security information via UserIAM. | 468| 12000017 | The key with same alias is already exist. | 469 470**示例：** 471 472```ts 473import { huks } from '@kit.UniversalKeystoreKit'; 474/* 以导入AES256为例 */ 475let plainTextSize32 = makeRandomArr(32); 476function makeRandomArr(size: number) { 477 let arr = new Uint8Array(size); 478 for (let i = 0; i < size; i++) { 479 arr[i] = Math.floor(Math.random() * 10); 480 } 481 return arr; 482}; 483/*第一步：生成密钥*/ 484let keyAlias = 'keyAlias'; 485let properties: Array<huks.HuksParam> = [ 486 { 487 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 488 value: huks.HuksKeyAlg.HUKS_ALG_AES 489 }, 490 { 491 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 492 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 493 }, 494 { 495 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 496 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 497 }, 498 { 499 tag: huks.HuksTag.HUKS_TAG_PADDING, 500 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 501 }, 502 { 503 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 504 value: huks.HuksCipherMode.HUKS_MODE_ECB 505 } 506]; 507let huksOptions: huks.HuksOptions = { 508 properties: properties, 509 inData: plainTextSize32 510}; 511huks.importKeyItem(keyAlias, huksOptions) 512 .then((data) => { 513 console.info(`promise: importKeyItem success`); 514 }); 515``` 516 517## huks.attestKeyItem<sup>9+</sup> 518 519attestKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 520 521获取密钥证书，使用Callback方式回调异步返回结果。 522 523**需要权限**：ohos.permission.ATTEST_KEY，该权限仅系统应用可申请。 524 525**系统能力：** SystemCapability.Security.Huks.Extension 526 527**参数：** 528 529| 参数名 | 类型 | 必填 | 说明 | 530| -------- | ---------------------------------------------------- | ---- | --------------------------------------------- | 531| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 532| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 533| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 534 535**错误码：** 536 537以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 538 539| 错误码ID | 错误信息 | 540| -------- | ------------- | 541| 201 | check permission failed. | 542| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 543| 801 | api is not supported. | 544| 12000001 | algorithm mode is not supported. | 545| 12000004 | operating file failed. | 546| 12000005 | IPC communication failed. | 547| 12000006 | error occurred in crypto engine. | 548| 12000011 | queried entity does not exist. | 549| 12000012 | Device environment or input parameter abnormal. | 550| 12000014 | memory is insufficient. | 551 552**示例：** 553 554```ts 555import { huks } from '@kit.UniversalKeystoreKit'; 556 557function stringToUint8Array(str: string) { 558 let arr: number[] = []; 559 for (let i = 0, j = str.length; i < j; ++i) { 560 arr.push(str.charCodeAt(i)); 561 } 562 let tmpUint8Array = new Uint8Array(arr); 563 return tmpUint8Array; 564} 565 566let securityLevel = stringToUint8Array('sec_level'); 567let challenge = stringToUint8Array('challenge_data'); 568let versionInfo = stringToUint8Array('version_info'); 569let keyAliasString = "key attest"; 570 571async function generateKeyThenAttestKey() { 572 let aliasString = keyAliasString; 573 let aliasUint8 = stringToUint8Array(aliasString); 574 let generateProperties: Array<huks.HuksParam> = [ 575 { 576 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 577 value: huks.HuksKeyAlg.HUKS_ALG_RSA 578 }, 579 { 580 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 581 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 582 }, 583 { 584 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 585 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 586 }, 587 { 588 tag: huks.HuksTag.HUKS_TAG_DIGEST, 589 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 590 }, 591 { 592 tag: huks.HuksTag.HUKS_TAG_PADDING, 593 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 594 }, 595 { 596 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 597 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 598 }, 599 { 600 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 601 value: huks.HuksCipherMode.HUKS_MODE_ECB 602 } 603 ]; 604 let generateOptions: huks.HuksOptions = { 605 properties: generateProperties 606 }; 607 let attestProperties: Array<huks.HuksParam> = [ 608 { 609 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 610 value: securityLevel 611 }, 612 { 613 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 614 value: challenge 615 }, 616 { 617 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 618 value: versionInfo 619 }, 620 { 621 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 622 value: aliasUint8 623 } 624 ]; 625 let attestOptions: huks.HuksOptions = { 626 properties: attestProperties 627 }; 628 huks.generateKeyItem(aliasString, generateOptions, (error, data) => { 629 if (error) { 630 console.error(`callback: generateKeyItem failed`); 631 } else { 632 console.info(`callback: generateKeyItem success`); 633 huks.attestKeyItem(aliasString, attestOptions, (error, data) => { 634 if (error) { 635 console.error(`callback: attestKeyItem failed`); 636 } else { 637 console.info(`callback: attestKeyItem success`); 638 } 639 }); 640 } 641 }); 642} 643``` 644 645## huks.attestKeyItem<sup>9+</sup> 646 647attestKeyItem(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 648 649获取密钥证书，使用Promise方式异步返回结果。 650 651**需要权限**：ohos.permission.ATTEST_KEY，该权限仅系统应用可申请。 652 653**系统能力：** SystemCapability.Security.Huks.Extension 654 655**参数：** 656 657| 参数名 | 类型 | 必填 | 说明 | 658| -------- | --------------------------- | ---- | ------------------------------------ | 659| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 660| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 661 662**返回值：** 663 664| 类型 | 说明 | 665| ---------------------------------------------- | --------------------------------------------- | 666| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的certChains成员非空，为获取到的证书链。| 667 668**错误码：** 669 670以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 671 672| 错误码ID | 错误信息 | 673| -------- | ------------- | 674| 201 | check permission failed. | 675| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 676| 801 | api is not supported. | 677| 12000001 | algorithm mode is not supported. | 678| 12000004 | operating file failed. | 679| 12000005 | IPC communication failed. | 680| 12000006 | error occurred in crypto engine. | 681| 12000011 | queried entity does not exist. | 682| 12000012 | Device environment or input parameter abnormal. | 683| 12000014 | memory is insufficient. | 684 685**示例：** 686 687```ts 688import { huks } from '@kit.UniversalKeystoreKit'; 689 690function stringToUint8Array(str: string) { 691 let arr: number[] = []; 692 for (let i = 0, j = str.length; i < j; ++i) { 693 arr.push(str.charCodeAt(i)); 694 } 695 let tmpUint8Array = new Uint8Array(arr); 696 return tmpUint8Array; 697} 698 699let securityLevel = stringToUint8Array('sec_level'); 700let challenge = stringToUint8Array('challenge_data'); 701let versionInfo = stringToUint8Array('version_info'); 702let keyAliasString = "key attest"; 703 704async function generateKey(alias: string) { 705 let properties: Array<huks.HuksParam> = [ 706 { 707 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 708 value: huks.HuksKeyAlg.HUKS_ALG_RSA 709 }, 710 { 711 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 712 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 713 }, 714 { 715 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 716 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 717 }, 718 { 719 tag: huks.HuksTag.HUKS_TAG_DIGEST, 720 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 721 }, 722 { 723 tag: huks.HuksTag.HUKS_TAG_PADDING, 724 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 725 }, 726 { 727 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 728 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 729 }, 730 { 731 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 732 value: huks.HuksCipherMode.HUKS_MODE_ECB 733 } 734 ]; 735 let options: huks.HuksOptions = { 736 properties: properties 737 }; 738 await huks.generateKeyItem(alias, options) 739 .then((data) => { 740 console.info(`promise: generateKeyItem success`); 741 }); 742} 743async function attestKey() { 744 let aliasString = keyAliasString; 745 let aliasUint8 = stringToUint8Array(aliasString); 746 let properties: Array<huks.HuksParam> = [ 747 { 748 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 749 value: securityLevel 750 }, 751 { 752 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 753 value: challenge 754 }, 755 { 756 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 757 value: versionInfo 758 }, 759 { 760 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 761 value: aliasUint8 762 } 763 ]; 764 let options: huks.HuksOptions = { 765 properties: properties 766 }; 767 await generateKey(aliasString); 768 await huks.attestKeyItem(aliasString, options) 769 .then((data) => { 770 console.info(`promise: attestKeyItem success`); 771 }); 772} 773``` 774 775## huks.anonAttestKeyItem<sup>11+</sup> 776 777anonAttestKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 778 779获取匿名化密钥证书，使用Callback方式回调异步返回结果。 780 781该操作需要联网进行，且耗时较长。返回12000012错误码时，可能是由于网络异常导致。此时如果没有联网，需要提示用户网络没有连接，如果已经联网，可能是由于网络抖动导致失败，建议重试。 782 783<!--RP1--><!--RP1End--> 784 785**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 786 787**系统能力：** SystemCapability.Security.Huks.Extension 788 789**参数：** 790 791| 参数名 | 类型 | 必填 | 说明 | 792| -------- | ---------------------------------------------------- | ---- | --------------------------------------------- | 793| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 794| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 795| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 796 797**错误码：** 798 799以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 800 801| 错误码ID | 错误信息 | 802| -------- | ------------- | 803| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 804| 801 | api is not supported. | 805| 12000001 | algorithm mode is not supported. | 806| 12000004 | operating file failed. | 807| 12000005 | IPC communication failed. | 808| 12000006 | error occurred in crypto engine. | 809| 12000011 | queried entity does not exist. | 810| 12000012 | Device environment or input parameter abnormal. | 811| 12000014 | memory is insufficient. | 812 813**示例：** 814 815```ts 816import { huks } from '@kit.UniversalKeystoreKit'; 817 818function stringToUint8Array(str: string): Uint8Array { 819 let arr: number[] = []; 820 for (let i = 0, j = str.length; i < j; ++i) { 821 arr.push(str.charCodeAt(i)); 822 } 823 let tmpUint8Array = new Uint8Array(arr); 824 return tmpUint8Array; 825} 826 827let securityLevel = stringToUint8Array('sec_level'); 828let challenge = stringToUint8Array('challenge_data'); 829let versionInfo = stringToUint8Array('version_info'); 830let keyAliasString = "key anon attest"; 831 832async function generateKeyThenAttestKey(): Promise<void> { 833 let aliasString = keyAliasString; 834 let aliasUint8 = stringToUint8Array(aliasString); 835 let generateProperties: Array<huks.HuksParam> = [ 836 { 837 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 838 value: huks.HuksKeyAlg.HUKS_ALG_RSA 839 }, 840 { 841 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 842 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 843 }, 844 { 845 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 846 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 847 }, 848 { 849 tag: huks.HuksTag.HUKS_TAG_DIGEST, 850 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 851 }, 852 { 853 tag: huks.HuksTag.HUKS_TAG_PADDING, 854 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 855 }, 856 { 857 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 858 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 859 }, 860 { 861 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 862 value: huks.HuksCipherMode.HUKS_MODE_ECB 863 } 864 ]; 865 let generateOptions: huks.HuksOptions = { 866 properties: generateProperties 867 }; 868 let anonAttestProperties: Array<huks.HuksParam> = [ 869 { 870 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 871 value: securityLevel 872 }, 873 { 874 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 875 value: challenge 876 }, 877 { 878 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 879 value: versionInfo 880 }, 881 { 882 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 883 value: aliasUint8 884 } 885 ]; 886 let anonAttestOptions: huks.HuksOptions = { 887 properties: anonAttestProperties 888 }; 889 huks.generateKeyItem(aliasString, generateOptions, (error, data) => { 890 if (error) { 891 console.error(`callback: generateKeyItem failed`); 892 } else { 893 console.info(`callback: generateKeyItem success`); 894 huks.anonAttestKeyItem(aliasString, anonAttestOptions, (error, data) => { 895 if (error) { 896 console.error(`callback: anonAttestKeyItem failed`); 897 } else { 898 console.info(`callback: anonAttestKeyItem success`); 899 } 900 }); 901 } 902 }); 903} 904``` 905 906## huks.anonAttestKeyItem<sup>11+</sup> 907 908anonAttestKeyItem(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 909 910获取匿名化密钥证书，使用Promise方式异步返回结果。 911 912该操作需要联网进行，且耗时较长。返回12000012错误码时，可能是由于网络异常导致。此时如果没有联网，需要提示用户网络没有连接，如果已经联网，可能是由于网络抖动导致失败，建议重试。 913 914<!--RP1--><!--RP1End--> 915 916**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 917 918**系统能力：** SystemCapability.Security.Huks.Extension 919 920**参数：** 921 922| 参数名 | 类型 | 必填 | 说明 | 923| -------- | --------------------------- | ---- | ------------------------------------ | 924| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 925| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 926 927**返回值：** 928 929| 类型 | 说明 | 930| ---------------------------------------------- | --------------------------------------------- | 931| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的certChains成员非空，为获取到的证书链。 | 932 933**错误码：** 934 935以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 936 937| 错误码ID | 错误信息 | 938| -------- | ------------- | 939| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 940| 801 | api is not supported. | 941| 12000001 | algorithm mode is not supported. | 942| 12000004 | operating file failed. | 943| 12000005 | IPC communication failed. | 944| 12000006 | error occurred in crypto engine. | 945| 12000011 | queried entity does not exist. | 946| 12000012 | Device environment or input parameter abnormal. | 947| 12000014 | memory is insufficient. | 948 949**示例：** 950 951```ts 952import { huks } from '@kit.UniversalKeystoreKit'; 953 954function stringToUint8Array(str: string): Uint8Array { 955 let arr: number[] = []; 956 for (let i = 0, j = str.length; i < j; ++i) { 957 arr.push(str.charCodeAt(i)); 958 } 959 let tmpUint8Array = new Uint8Array(arr); 960 return tmpUint8Array; 961} 962 963let securityLevel = stringToUint8Array('sec_level'); 964let challenge = stringToUint8Array('challenge_data'); 965let versionInfo = stringToUint8Array('version_info'); 966let keyAliasString = "key anon attest"; 967 968async function generateKey(alias: string): Promise<void> { 969 let properties: Array<huks.HuksParam> = [ 970 { 971 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 972 value: huks.HuksKeyAlg.HUKS_ALG_RSA 973 }, 974 { 975 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 976 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 977 }, 978 { 979 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 980 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 981 }, 982 { 983 tag: huks.HuksTag.HUKS_TAG_DIGEST, 984 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 985 }, 986 { 987 tag: huks.HuksTag.HUKS_TAG_PADDING, 988 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 989 }, 990 { 991 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 992 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 993 }, 994 { 995 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 996 value: huks.HuksCipherMode.HUKS_MODE_ECB 997 } 998 ]; 999 let options: huks.HuksOptions = { 1000 properties: properties 1001 }; 1002 1003 await huks.generateKeyItem(alias, options); 1004} 1005async function anonAttestKey(): Promise<void> { 1006 let aliasString = keyAliasString; 1007 let aliasUint8 = stringToUint8Array(aliasString); 1008 let properties: Array<huks.HuksParam> = [ 1009 { 1010 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 1011 value: securityLevel 1012 }, 1013 { 1014 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 1015 value: challenge 1016 }, 1017 { 1018 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 1019 value: versionInfo 1020 }, 1021 { 1022 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 1023 value: aliasUint8 1024 } 1025 ]; 1026 let options: huks.HuksOptions = { 1027 properties: properties 1028 }; 1029 1030 await generateKey(aliasString); 1031 await huks.anonAttestKeyItem(aliasString, options); 1032} 1033``` 1034 1035## huks.importWrappedKeyItem<sup>9+</sup> 1036 1037importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 1038 1039导入加密密钥，使用Callback方式回调异步返回结果。 1040 1041**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1042 1043**系统能力：** SystemCapability.Security.Huks.Core 1044 1045API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1046 1047**参数：** 1048 1049| 参数名 | 类型 | 必填 | 说明 | 1050| ---------------- | --------------------------- | ---- | --------------------------------------------- | 1051| keyAlias | string | 是 | 密钥别名，存放待导入密钥的别名。 | 1052| wrappingKeyAlias | string | 是 | 密钥别名，对应密钥用于解密加密的密钥数据。 | 1053| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 1054| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 1055 1056**错误码：** 1057 1058以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1059 1060| 错误码ID | 错误信息 | 1061| -------- | ------------- | 1062| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1063| 801 | api is not supported. | 1064| 12000001 | algorithm mode is not supported. | 1065| 12000002 | algorithm param is missing. | 1066| 12000003 | algorithm param is invalid. | 1067| 12000004 | operating file failed. | 1068| 12000005 | IPC communication failed. | 1069| 12000006 | error occurred in crypto engine. | 1070| 12000011 | queried entity does not exist. | 1071| 12000012 | Device environment or input parameter abnormal. | 1072| 12000013 | queried credential does not exist. | 1073| 12000014 | memory is insufficient. | 1074| 12000015 | Failed to obtain the security information via UserIAM. | 1075| 12000017 | The key with same alias is already exist. | 1076 1077**示例：** 1078 1079```ts 1080import { huks } from '@kit.UniversalKeystoreKit'; 1081 1082let alias1 = "importAlias"; 1083let alias2 = "wrappingKeyAlias"; 1084 1085async function TestGenFunc(alias: string, options: huks.HuksOptions) { 1086 await genKey(alias, options) 1087 .then((data) => { 1088 console.info(`callback: generateKeyItem success`); 1089 }); 1090} 1091 1092function genKey(alias: string, options: huks.HuksOptions) { 1093 return new Promise<void>((resolve, reject) => { 1094 huks.generateKeyItem(alias, options, (error, data) => { 1095 if (error) { 1096 reject(error); 1097 } else { 1098 resolve(data); 1099 } 1100 }); 1101 }); 1102} 1103 1104async function TestExportFunc(alias: string, options: huks.HuksOptions) { 1105 await exportKey(alias, options) 1106 .then((data) => { 1107 console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`); 1108 }); 1109} 1110 1111function exportKey(alias: string, options: huks.HuksOptions) { 1112 return new Promise<huks.HuksReturnResult>((resolve, reject) => { 1113 huks.exportKeyItem(alias, options, (error, data) => { 1114 if (error) { 1115 reject(error); 1116 } else { 1117 resolve(data); 1118 } 1119 }); 1120 }); 1121} 1122 1123async function TestImportWrappedFunc(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1124 await importWrappedKey(alias, wrappingAlias, options) 1125 .then((data) => { 1126 console.info(`callback: importWrappedKeyItem success`); 1127 }); 1128} 1129 1130function importWrappedKey(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1131 return new Promise<void>((resolve, reject) => { 1132 huks.importWrappedKeyItem(alias, wrappingAlias, options, (error, data) => { 1133 if (error) { 1134 reject(error); 1135 } else { 1136 resolve(data); 1137 } 1138 }); 1139 }); 1140} 1141 1142async function TestImportWrappedKeyFunc( 1143 alias: string, 1144 wrappingAlias: string, 1145 genOptions: huks.HuksOptions, 1146 importOptions: huks.HuksOptions 1147) { 1148 await TestGenFunc(wrappingAlias, genOptions); 1149 await TestExportFunc(wrappingAlias, genOptions); 1150 1151 /* 以下操作不需要调用HUKS接口，此处不给出具体实现。 1152 * 假设待导入的密钥为keyA 1153 * 1.生成ECC公私钥keyB，公钥为keyB_pub, 私钥为keyB_pri 1154 * 2.使用keyB_pri和wrappingAlias密钥中获取的公钥进行密钥协商，协商出共享密钥share_key 1155 * 3.随机生成密钥kek，用于加密keyA，采用AES-GCM加密，加密过程中需要记录：nonce1、aad1、加密后的密文keyA_enc、加密后的tag1。 1156 * 4.使用share_key加密kek，采用AES-GCM加密，加密过程中需要记录：nonce2、aad2、加密后的密文kek_enc、加密后的tag2。 1157 * 5.拼接importOptions.inData字段，满足以下格式: 1158 * keyB_pub的长度（4字节） + keyB_pub的数据 + aad2的长度（4字节） + aad2的数据 + 1159 * nonce2的长度（4字节） + nonce2的数据 + tag2的长度（4字节） + tag2的数据 + 1160 * kek_enc的长度（4字节） + kek_enc的数据 + aad1的长度（4字节） + aad1的数据 + 1161 * nonce1的长度（4字节） + nonce1的数据 + tag1的长度（4字节） + tag1的数据 + 1162 * keyA长度占用的内存长度（4字节） + keyA的长度 + keyA_enc的长度（4字节） + keyA_enc的数据 1163 */ 1164 /* 该处为示例代码，实际运行过程中，应使用实际导入密钥数据。数据构造方式由上注释可见说明 */ 1165 let inputKey = new Uint8Array([0x02, 0x00, 0x00, 0x00]); 1166 importOptions.inData = inputKey; 1167 await TestImportWrappedFunc(alias, wrappingAlias, importOptions); 1168} 1169function makeGenerateOptions() { 1170 let properties: Array<huks.HuksParam> = [ 1171 { 1172 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1173 value: huks.HuksKeyAlg.HUKS_ALG_ECC 1174 }, 1175 { 1176 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1177 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 1178 }, 1179 { 1180 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1181 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_UNWRAP 1182 }, 1183 { 1184 tag: huks.HuksTag.HUKS_TAG_DIGEST, 1185 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 1186 }, 1187 { 1188 tag: huks.HuksTag.HUKS_TAG_IMPORT_KEY_TYPE, 1189 value: huks.HuksImportKeyType.HUKS_KEY_TYPE_KEY_PAIR, 1190 } 1191 ]; 1192 let options: huks.HuksOptions = { 1193 properties: properties 1194 }; 1195 return options; 1196}; 1197function makeImportOptions() { 1198 let properties: Array<huks.HuksParam> = [ 1199 { 1200 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1201 value: huks.HuksKeyAlg.HUKS_ALG_AES 1202 }, 1203 { 1204 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1205 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 1206 }, 1207 { 1208 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1209 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 1210 }, 1211 { 1212 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 1213 value: huks.HuksCipherMode.HUKS_MODE_CBC 1214 }, 1215 { 1216 tag: huks.HuksTag.HUKS_TAG_PADDING, 1217 value: huks.HuksKeyPadding.HUKS_PADDING_NONE 1218 }, 1219 { 1220 tag: huks.HuksTag.HUKS_TAG_UNWRAP_ALGORITHM_SUITE, 1221 value: huks.HuksUnwrapSuite.HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING 1222 } 1223 ]; 1224 let options: huks.HuksOptions = { 1225 properties: properties 1226 }; 1227 return options; 1228}; 1229function huksImportWrappedKey() { 1230 let genOptions = makeGenerateOptions(); 1231 let importOptions = makeImportOptions(); 1232 TestImportWrappedKeyFunc( 1233 alias1, 1234 alias2, 1235 genOptions, 1236 importOptions 1237 ); 1238} 1239``` 1240 1241## huks.importWrappedKeyItem<sup>9+</sup> 1242 1243importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions) : Promise\<void> 1244 1245导入加密密钥，使用Promise方式异步返回结果。 1246 1247**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1248 1249**系统能力：** SystemCapability.Security.Huks.Extension 1250 1251**参数：** 1252 1253| 参数名 | 类型 | 必填 | 说明 | 1254| ---------------- | --------------------------- | ---- | --------------------------------------------- | 1255| keyAlias | string | 是 | 密钥别名，存放待导入密钥的别名。 | 1256| wrappingKeyAlias | string | 是 | 密钥别名，对应密钥用于解密加密的密钥数据。 | 1257| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 1258 1259**返回值：** 1260 1261| 类型 | 说明 | 1262| ---------------------------------------------- | --------------------------------------------- | 1263| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1264 1265**错误码：** 1266 1267以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1268 1269| 错误码ID | 错误信息 | 1270| -------- | ------------- | 1271| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1272| 801 | api is not supported. | 1273| 12000001 | algorithm mode is not supported. | 1274| 12000002 | algorithm param is missing. | 1275| 12000003 | algorithm param is invalid. | 1276| 12000004 | operating file failed. | 1277| 12000005 | IPC communication failed. | 1278| 12000006 | error occurred in crypto engine. | 1279| 12000011 | queried entity does not exist. | 1280| 12000012 | Device environment or input parameter abnormal. | 1281| 12000013 | queried credential does not exist. | 1282| 12000014 | memory is insufficient. | 1283| 12000015 | Failed to obtain the security information via UserIAM. | 1284| 12000017 | The key with same alias is already exist. | 1285 1286**示例：** 1287 1288```ts 1289import { huks } from '@kit.UniversalKeystoreKit'; 1290/* 处理流程与callback类似，主要差异点为如下函数： */ 1291/* 该处为示例代码，实际运行过程中，应使用实际导入密钥数据。数据构造方式由上注释可见说明 */ 1292async function TestImportWrappedFunc(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1293 await huks.importWrappedKeyItem(alias, wrappingAlias, options) 1294 .then ((data) => { 1295 console.info(`promise: importWrappedKeyItem success`); 1296 }); 1297} 1298``` 1299 1300## huks.exportKeyItem<sup>9+</sup> 1301 1302exportKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1303 1304导出密钥，使用Callback方式回调异步返回的结果。 1305 1306**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1307 1308**系统能力：** SystemCapability.Security.Huks.Core 1309 1310API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1311 1312**参数：** 1313 1314| 参数名 | 类型 | 必填 | 说明 | 1315| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 1316| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1317| options | [HuksOptions](#huksoptions) | 是 | 用于导出密钥时指定密钥的属性，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需导出密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 1318| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 1319 1320**错误码：** 1321 1322以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1323 1324| 错误码ID | 错误信息 | 1325| -------- | ------------- | 1326| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1327| 801 | api is not supported. | 1328| 12000001 | algorithm mode is not supported. | 1329| 12000004 | operating file failed. | 1330| 12000005 | IPC communication failed. | 1331| 12000006 | error occurred in crypto engine. | 1332| 12000011 | queried entity does not exist. | 1333| 12000012 | Device environment or input parameter abnormal. | 1334| 12000014 | memory is insufficient. | 1335 1336**示例：** 1337 1338```ts 1339import { huks } from '@kit.UniversalKeystoreKit'; 1340/* 此处options选择emptyOptions来传空 */ 1341let keyAlias = 'keyAlias'; 1342let emptyOptions: huks.HuksOptions = { 1343 properties: [] 1344}; 1345 1346huks.exportKeyItem(keyAlias, emptyOptions, (error, data) => { 1347 if (error) { 1348 console.error(`callback: exportKeyItem failed`); 1349 } else { 1350 console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`); 1351 } 1352}); 1353``` 1354 1355## huks.exportKeyItem<sup>9+</sup> 1356 1357exportKeyItem(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 1358 1359导出密钥，使用Promise方式回调异步返回的结果。 1360 1361**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1362 1363**系统能力：** SystemCapability.Security.Huks.Extension 1364 1365**参数：** 1366 1367| 参数名 | 类型 | 必填 | 说明 | 1368| -------- | --------------------------- | ---- | -------------------------------------------- | 1369| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1370| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1371 1372**返回值：** 1373 1374| 类型 | 说明 | 1375| ---------------------------------------------- | ------------------------------------------------------------ | 1376| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的outData成员非空，为从密钥中导出的公钥。| 1377 1378**错误码：** 1379 1380以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1381 1382| 错误码ID | 错误信息 | 1383| -------- | ------------- | 1384| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1385| 801 | api is not supported. | 1386| 12000001 | algorithm mode is not supported. | 1387| 12000004 | operating file failed. | 1388| 12000005 | IPC communication failed. | 1389| 12000006 | error occurred in crypto engine. | 1390| 12000011 | queried entity does not exist. | 1391| 12000012 | Device environment or input parameter abnormal. | 1392| 12000014 | memory is insufficient. | 1393 1394**示例：** 1395 1396```ts 1397import { huks } from '@kit.UniversalKeystoreKit'; 1398/* 此处options选择emptyOptions来传空 */ 1399let keyAlias = 'keyAlias'; 1400let emptyOptions: huks.HuksOptions = { 1401 properties: [] 1402}; 1403 1404huks.exportKeyItem(keyAlias, emptyOptions) 1405 .then ((data) => { 1406 console.info(`promise: exportKeyItem success, data = ${JSON.stringify(data)}`); 1407 }); 1408``` 1409 1410## huks.wrapKeyItem<sup>20+</sup> 1411 1412wrapKeyItem(keyAlias: string, params: HuksOptions): Promise\<HuksReturnResult> 1413 1414加密导出密钥（与[unwrapKeyItem](#huksunwrapkeyitem20)对应，待导出的密钥在生成时要添加[HUKS_TAG_IS_ALLOWED_WRAP](#hukstag)，指定密钥允许导出）。使用Promise异步回调。 1415 1416<!--Del-->该功能暂不支持。<!--DelEnd--> 1417 1418 1419**系统能力：** SystemCapability.Security.Huks.Core 1420 1421**参数：** 1422 1423| 参数名 | 类型 | 必填 | 说明 | 1424| -------- | --------------------------- | ---- | -------------------------------------------- | 1425| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1426| params | [HuksOptions](#huksoptions) | 是 | 用于指定导出密钥时的加密类型。 | 1427 1428**返回值：** 1429 1430| 类型 | 说明 | 1431| ---------------------------------------------- | ------------------------------------------------------------ | 1432| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的outData成员非空，为导出的密钥密文。| 1433 1434**错误码：** 1435 1436以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1437 1438| 错误码ID | 错误信息 | 1439| -------- | ------------- | 1440| 801 | api is not supported. | 1441| 12000004 | operating file failed. | 1442| 12000005 | IPC communication failed. | 1443| 12000011 | queried entity does not exist. | 1444| 12000012 | Device environment or input parameter abnormal. | 1445| 12000014 | memory is insufficient. | 1446| 12000018 | the input parameter is invalid. | 1447 1448<!--RP2--><!--RP2End--> 1449 1450## huks.unwrapKeyItem<sup>20+</sup> 1451 1452unwrapKeyItem(keyAlias: string, params: HuksOptions, wrappedKey: Uint8Array): Promise\<HuksReturnResult> 1453 1454加密导入密钥，与[wrapKeyItem](#hukswrapkeyitem20)对应。使用Promise异步回调。 1455 1456<!--Del-->该功能暂不支持。<!--DelEnd--> 1457 1458 1459**系统能力：** SystemCapability.Security.Huks.Core 1460 1461**参数：** 1462 1463| 参数名 | 类型 | 必填 | 说明 | 1464| -------- | --------------------------- | ---- | -------------------------------------------- | 1465| keyAlias | string | 是 | 密钥别名，指定导入密钥的密钥别名 | 1466| params | [HuksOptions](#huksoptions) | 是 | 用于指定导入密钥时的加密类型。 | 1467| wrappedKey | Uint8Array | 是 | 加密导出密钥的密文。 | 1468 1469**返回值：** 1470 1471| 类型 | 说明 | 1472| ---------------------------------------------- | ------------------------------------------------------------ | 1473| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。 | 1474 1475**错误码：** 1476 1477以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1478 1479| 错误码ID | 错误信息 | 1480| -------- | ------------- | 1481| 801 | api is not supported. | 1482| 12000004 | operating file failed. | 1483| 12000005 | IPC communication failed. | 1484| 12000012 | Device environment or input parameter abnormal. | 1485| 12000014 | memory is insufficient. | 1486| 12000015 | Failed to obtain the security information via UserIAM. | 1487| 12000018 | the input parameter is invalid. | 1488 1489<!--RP3--><!--RP3End--> 1490 1491## huks.getKeyItemProperties<sup>9+</sup> 1492 1493getKeyItemProperties(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1494 1495获取密钥属性，使用Callback回调异步返回结果。 1496 1497**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1498 1499**系统能力：** SystemCapability.Security.Huks.Core 1500 1501API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1502 1503**参数：** 1504 1505| 参数名 | 类型 | 必填 | 说明 | 1506| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 1507| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1508| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1509| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。properties：返回值为生成密钥时所需参数。 | 1510 1511**错误码：** 1512 1513以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1514 1515| 错误码ID | 错误信息 | 1516| -------- | ------------- | 1517| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1518| 801 | api is not supported. | 1519| 12000001 | algorithm mode is not supported. | 1520| 12000004 | operating file failed. | 1521| 12000005 | IPC communication failed. | 1522| 12000006 | error occurred in crypto engine. | 1523| 12000011 | queried entity does not exist. | 1524| 12000012 | Device environment or input parameter abnormal. | 1525| 12000014 | memory is insufficient. | 1526 1527**示例：** 1528 1529```ts 1530import { huks } from '@kit.UniversalKeystoreKit'; 1531/* 此处options选择emptyOptions来传空 */ 1532let keyAlias = 'keyAlias'; 1533let emptyOptions: huks.HuksOptions = { 1534 properties: [] 1535}; 1536 1537huks.getKeyItemProperties(keyAlias, emptyOptions, (error, data) => { 1538 if (error) { 1539 console.error(`callback: getKeyItemProperties failed`); 1540 } else { 1541 console.info(`callback: getKeyItemProperties success, data = ${JSON.stringify(data)}`); 1542 } 1543}); 1544``` 1545 1546## huks.getKeyItemProperties<sup>9+</sup> 1547 1548getKeyItemProperties(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 1549 1550获取密钥属性，使用Promise回调异步返回结果。 1551 1552**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1553 1554**系统能力：** SystemCapability.Security.Huks.Extension 1555 1556**参数：** 1557 1558| 参数名 | 类型 | 必填 | 说明 | 1559| -------- | --------------------------- | ---- | -------------------------------------------- | 1560| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1561| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1562 1563**返回值：** 1564 1565| 类型 | 说明 | 1566| ----------------------------------------------- | ------------------------------------------------------------ | 1567| Promise\<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的properties成员非空，为生成密钥时所需参数。| 1568 1569**错误码：** 1570 1571以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1572 1573| 错误码ID | 错误信息 | 1574| -------- | ------------- | 1575| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1576| 801 | api is not supported. | 1577| 12000001 | algorithm mode is not supported. | 1578| 12000004 | operating file failed. | 1579| 12000005 | IPC communication failed. | 1580| 12000006 | error occurred in crypto engine. | 1581| 12000011 | queried entity does not exist. | 1582| 12000012 | Device environment or input parameter abnormal. | 1583| 12000014 | memory is insufficient. | 1584 1585**示例：** 1586 1587```ts 1588import { huks } from '@kit.UniversalKeystoreKit'; 1589/* 此处options选择emptyOptions来传空 */ 1590let keyAlias = 'keyAlias'; 1591let emptyOptions: huks.HuksOptions = { 1592 properties: [] 1593}; 1594 1595huks.getKeyItemProperties(keyAlias, emptyOptions) 1596 .then ((data) => { 1597 console.info(`promise: getKeyItemProperties success, data = ${JSON.stringify(data)}`); 1598 }); 1599``` 1600 1601## huks.isKeyItemExist<sup>9+</sup> 1602 1603isKeyItemExist(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<boolean>) : void 1604 1605判断密钥是否存在，使用Callback回调异步返回结果。 1606 1607**系统能力：** SystemCapability.Security.Huks.Core 1608 1609**参数：** 1610 1611| 参数名 | 类型 | 必填 | 说明 | 1612| -------- | --------------------------- | ---- |--------------------------------------------------------| 1613| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1614| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 1615| callback | AsyncCallback\<boolean> | 是 | 回调函数。密钥存在时，data为true；密钥不存在时，err中的错误码为12000011，并附带对应错误描述。 | 1616 1617**错误码：** 1618 1619以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1620 1621| 错误码ID | 错误信息 | 1622| -------- | ------------- | 1623| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1624| 801 | api is not supported. | 1625| 12000004 | operating file failed. | 1626| 12000005 | IPC communication failed. | 1627| 12000006 | error occurred in crypto engine. | 1628| 12000011 | queried entity does not exist. | 1629| 12000012 | Device environment or input parameter abnormal. | 1630| 12000014 | memory is insufficient. | 1631 1632**示例：** 1633 1634```ts 1635import { huks } from '@kit.UniversalKeystoreKit'; 1636/* 此处options选择emptyOptions来传空 */ 1637let keyAlias = 'keyAlias'; 1638let emptyOptions: huks.HuksOptions = { 1639 properties: [] 1640}; 1641 1642huks.isKeyItemExist(keyAlias, emptyOptions, (error, data) => { 1643 if (error) { 1644 console.error(`callback: isKeyItemExist failed`); 1645 } else { 1646 if (data) { 1647 console.info(`keyAlias:${keyAlias} is existed!`) 1648 } else { 1649 console.error(`find key failed`) 1650 } 1651 } 1652}); 1653``` 1654 1655## huks.isKeyItemExist<sup>9+</sup> 1656 1657isKeyItemExist(keyAlias: string, options: HuksOptions) : Promise\<boolean> 1658 1659判断密钥是否存在，使用Promise回调异步返回结果。 1660 1661**系统能力：** SystemCapability.Security.Huks.Extension 1662 1663**参数：** 1664 1665| 参数名 | 类型 | 必填 | 说明 | 1666| -------- | --------------------------- | ---- | ------------------------ | 1667| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1668| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 1669 1670**返回值：** 1671 1672| 类型 | 说明 | 1673| ----------------- | --------------------------------------- | 1674| Promise\<boolean> | Promise对象。密钥存在时，可通过then进行密钥存在后的相关处理，若不存在，可通过error处理密钥不存在后的相关业务操作。 | 1675 1676**错误码：** 1677 1678以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1679 1680| 错误码ID | 错误信息 | 1681| -------- | ------------- | 1682| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1683| 801 | api is not supported. | 1684| 12000004 | operating file failed. | 1685| 12000005 | IPC communication failed. | 1686| 12000006 | error occurred in crypto engine. | 1687| 12000011 | queried entity does not exist. | 1688| 12000012 | Device environment or input parameter abnormal. | 1689| 12000014 | memory is insufficient. | 1690 1691**示例：** 1692 1693```ts 1694import { huks } from '@kit.UniversalKeystoreKit'; 1695 1696/* 此处options选择emptyOptions来传空 */ 1697let keyAlias = 'keyAlias'; 1698let emptyOptions: huks.HuksOptions = { 1699 properties: [] 1700}; 1701 1702huks.isKeyItemExist(keyAlias, emptyOptions).then((data) => { 1703 console.info(`keyAlias:${keyAlias} is existed!`) 1704}); 1705``` 1706 1707## huks.hasKeyItem<sup>11+</sup> 1708 1709hasKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<boolean>) : void 1710 1711判断密钥是否存在，使用Callback回调异步返回结果。 1712 1713**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1714 1715**系统能力：** SystemCapability.Security.Huks.Core 1716 1717**参数：** 1718 1719| 参数名 | 类型 | 必填 | 说明 | 1720| -------- | --------------------------- | ---- |--------------------------------------------------------| 1721| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1722| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 1723| callback | AsyncCallback\<boolean> | 是 | 回调函数。若密钥存在，data为true，若密钥不存在，data为false。 | 1724 1725**错误码：** 1726 1727以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1728 1729| 错误码ID | 错误信息 | 1730| -------- | ------------- | 1731| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1732| 801 | api is not supported. | 1733| 12000004 | operating file failed. | 1734| 12000005 | IPC communication failed. | 1735| 12000006 | error occurred in crypto engine. | 1736| 12000012 | Device environment or input parameter abnormal. | 1737| 12000014 | memory is insufficient. | 1738 1739**示例：** 1740 1741```ts 1742import { huks } from '@kit.UniversalKeystoreKit'; 1743/* 此处options选择emptyOptions来传空 */ 1744let keyAlias = 'keyAlias'; 1745let emptyOptions: huks.HuksOptions = { 1746 properties: [] 1747}; 1748 1749huks.hasKeyItem(keyAlias, emptyOptions, (error, data) => { 1750 if (error) { 1751 console.error(`callback: hasKeyItem failed`); 1752 } else { 1753 if (data) { 1754 console.info(`keyAlias:${keyAlias} is existed!`) 1755 } else { 1756 console.error(`find key failed`) 1757 } 1758 } 1759}); 1760``` 1761 1762## huks.hasKeyItem<sup>11+</sup> 1763 1764hasKeyItem(keyAlias: string, options: HuksOptions) : Promise\<boolean> 1765 1766判断密钥是否存在，使用Promise回调异步返回结果。 1767 1768**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1769 1770**系统能力：** SystemCapability.Security.Huks.Extension 1771 1772**参数：** 1773 1774| 参数名 | 类型 | 必填 | 说明 | 1775| -------- | --------------------------- | ---- | ------------------------ | 1776| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1777| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，<br>可传空，当API version ≥ 12时，传空默认为CE，当API version ＜ 12时，传空默认为DE。 | 1778 1779**返回值：** 1780 1781| 类型 | 说明 | 1782| ----------------- | --------------------------------------- | 1783| Promise\<boolean> | Promise对象。若密钥存在，返回值为true，若密钥不存在，返回值为false。 | 1784 1785**错误码：** 1786 1787以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1788 1789| 错误码ID | 错误信息 | 1790| -------- | ------------- | 1791| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1792| 801 | api is not supported. | 1793| 12000004 | operating file failed. | 1794| 12000005 | IPC communication failed. | 1795| 12000006 | error occurred in crypto engine. | 1796| 12000012 | Device environment or input parameter abnormal. | 1797| 12000014 | memory is insufficient. | 1798 1799**示例：** 1800 1801```ts 1802import { huks } from '@kit.UniversalKeystoreKit'; 1803 1804/* 此处options选择emptyOptions来传空 */ 1805let keyAlias = 'keyAlias'; 1806let emptyOptions: huks.HuksOptions = { 1807 properties: [] 1808}; 1809 1810huks.hasKeyItem(keyAlias, emptyOptions).then((data) => { 1811 if (data) { 1812 console.info(`keyAlias:${keyAlias} is existed!`) 1813 } else { 1814 console.info(`find key failed!`) 1815 } 1816}); 1817``` 1818 1819## huks.initSession<sup>9+</sup> 1820 1821initSession(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksSessionHandle>) : void 1822 1823initSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1824 1825**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1826 1827**系统能力：** SystemCapability.Security.Huks.Core 1828 1829**参数：** 1830 1831| 参数名 | 类型 | 必填 | 说明 | 1832| -------- | ------------------------------------------------------- | ---- | ---------------------------------------------------- | 1833| keyAlias | string | 是 | initSession操作密钥的别名。 | 1834| options | [HuksOptions](#huksoptions) | 是 | initSession操作的参数集合。 | 1835| callback | AsyncCallback\<[HuksSessionHandle](#hukssessionhandle9)> | 是 | 回调函数。将initSession操作返回的handle添加到回调函数中。 | 1836 1837**错误码：** 1838 1839以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1840 1841| 错误码ID | 错误信息 | 1842| -------- | ------------- | 1843| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1844| 801 | api is not supported. | 1845| 12000001 | algorithm mode is not supported. | 1846| 12000002 | algorithm param is missing. | 1847| 12000003 | algorithm param is invalid. | 1848| 12000004 | operating file failed. | 1849| 12000005 | IPC communication failed. | 1850| 12000006 | error occurred in crypto engine. | 1851| 12000010 | the number of sessions has reached limit. | 1852| 12000011 | queried entity does not exist. | 1853| 12000012 | Device environment or input parameter abnormal. | 1854| 12000014 | memory is insufficient. | 1855 1856## huks.initSession<sup>9+</sup> 1857 1858initSession(keyAlias: string, options: HuksOptions) : Promise\<HuksSessionHandle> 1859 1860initSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1861 1862**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1863 1864**系统能力：** SystemCapability.Security.Huks.Extension 1865 1866**参数：** 1867 1868| 参数名 | 类型 | 必填 | 说明 | 1869| -------- | ------------------------------------------------- | ---- | ------------------------------------------------ | 1870| keyAlias | string | 是 | initSession操作密钥的别名。 | 1871| options | [HuksOptions](#huksoptions) | 是 | initSession参数集合。 | 1872 1873**返回值**： 1874 1875| 类型 | 说明 | 1876| ----------------------------------- | -------------------------------------------------- | 1877| Promise\<[HuksSessionHandle](#hukssessionhandle9)> | Promise对象。将initSession操作返回的handle添加到回调函数中。 | 1878 1879**错误码：** 1880 1881以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1882 1883| 错误码ID | 错误信息 | 1884| -------- | ------------- | 1885| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1886| 801 | api is not supported. | 1887| 12000001 | algorithm mode is not supported. | 1888| 12000002 | algorithm param is missing. | 1889| 12000003 | algorithm param is invalid. | 1890| 12000004 | operating file failed. | 1891| 12000005 | IPC communication failed. | 1892| 12000006 | error occurred in crypto engine. | 1893| 12000010 | the number of sessions has reached limit. | 1894| 12000011 | queried entity does not exist. | 1895| 12000012 | Device environment or input parameter abnormal. | 1896| 12000014 | memory is insufficient. | 1897 1898## huks.updateSession<sup>9+</sup> 1899 1900updateSession(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1901 1902updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1903 1904**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1905 1906**系统能力：** SystemCapability.Security.Huks.Core 1907 1908**参数：** 1909 1910| 参数名 | 类型 | 必填 | 说明 | 1911| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 1912| handle | number | 是 | updateSession操作的uint64类型的handle值。 | 1913| options | [HuksOptions](#huksoptions) | 是 | updateSession的参数集合。 | 1914| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将updateSession操作的结果添加到回调函数中。 | 1915 1916**错误码：** 1917 1918以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1919 1920| 错误码ID | 错误信息 | 1921| -------- | ------------- | 1922| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1923| 801 | api is not supported. | 1924| 12000001 | algorithm mode is not supported. | 1925| 12000002 | algorithm param is missing. | 1926| 12000003 | algorithm param is invalid. | 1927| 12000004 | operating file failed. | 1928| 12000005 | IPC communication failed. | 1929| 12000006 | error occurred in crypto engine. | 1930| 12000007 | this credential is already invalidated permanently. | 1931| 12000008 | verify auth token failed. | 1932| 12000009 | auth token is already timeout. | 1933| 12000011 | queried entity does not exist. | 1934| 12000012 | Device environment or input parameter abnormal. | 1935| 12000014 | memory is insufficient. | 1936 1937## huks.updateSession<sup>9+</sup> 1938 1939updateSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback\<HuksReturnResult>) : void 1940 1941updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1942 1943**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1944 1945**系统能力：** SystemCapability.Security.Huks.Extension 1946 1947**参数：** 1948 1949| 参数名 | 类型 | 必填 | 说明 | 1950| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 1951| handle | number | 是 | updateSession操作的uint64类型的handle值。 | 1952| options | [HuksOptions](#huksoptions) | 是 | updateSession操作的参数集合。 | 1953| token | Uint8Array | 是 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md#二次认证密钥访问控制)的用户鉴权证明(AuthToken)。 | 1954| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将updateSession操作的结果添加到回调函数中。 | 1955 1956**错误码：** 1957 1958以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 1959 1960| 错误码ID | 错误信息 | 1961| -------- | ------------- | 1962| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1963| 801 | api is not supported. | 1964| 12000001 | algorithm mode is not supported. | 1965| 12000002 | algorithm param is missing. | 1966| 12000003 | algorithm param is invalid. | 1967| 12000004 | operating file failed. | 1968| 12000005 | IPC communication failed. | 1969| 12000006 | error occurred in crypto engine. | 1970| 12000007 | this credential is already invalidated permanently. | 1971| 12000008 | verify auth token failed. | 1972| 12000009 | auth token is already timeout. | 1973| 12000011 | queried entity does not exist. | 1974| 12000012 | Device environment or input parameter abnormal. | 1975| 12000014 | memory is insufficient. | 1976 1977## huks.updateSession<sup>9+</sup> 1978 1979updateSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise\<HuksReturnResult> 1980 1981updateSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1982 1983**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1984 1985**系统能力：** SystemCapability.Security.Huks.Extension 1986 1987**参数：** 1988 1989| 参数名 | 类型 | 必填 | 说明 | 1990| ------- | ---------------------------------------------- | ---- | -------------------------------------------- | 1991| handle | number | 是 | updateSession操作的uint64类型的handle值。 | 1992| options | [HuksOptions](#huksoptions) | 是 | updateSession操作的参数集合。 | 1993| token | Uint8Array | 否 |密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md#二次认证密钥访问控制)的用户鉴权证明(AuthToken)，不填表示不进行二次认证密钥访问控制。 | 1994 1995**返回值**： 1996 1997| 类型 | 说明 | 1998| ----------------------------------- | -------------------------------------------------- | 1999| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。将updateSession操作的结果添加到回调函数中。 | 2000 2001**错误码：** 2002 2003以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2004 2005| 错误码ID | 错误信息 | 2006| -------- | ------------- | 2007| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2008| 801 | api is not supported. | 2009| 12000001 | algorithm mode is not supported. | 2010| 12000002 | algorithm param is missing. | 2011| 12000003 | algorithm param is invalid. | 2012| 12000004 | operating file failed. | 2013| 12000005 | IPC communication failed. | 2014| 12000006 | error occurred in crypto engine. | 2015| 12000007 | this credential is already invalidated permanently. | 2016| 12000008 | verify auth token failed. | 2017| 12000009 | auth token is already timeout. | 2018| 12000011 | queried entity does not exist. | 2019| 12000012 | Device environment or input parameter abnormal. | 2020| 12000014 | memory is insufficient. | 2021 2022## huks.finishSession<sup>9+</sup> 2023 2024finishSession(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 2025 2026finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2027 2028**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2029 2030**系统能力：** SystemCapability.Security.Huks.Core 2031 2032**参数：** 2033 2034| 参数名 | 类型 | 必填 | 说明 | 2035| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 2036| handle | number | 是 | finishSession操作的uint64类型的handle值。 | 2037| options | [HuksOptions](#huksoptions) | 是 | finishSession的参数集合。 | 2038| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到回调函数中。 | 2039 2040**错误码：** 2041 2042以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2043 2044| 错误码ID | 错误信息 | 2045| -------- | ------------- | 2046| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2047| 801 | api is not supported. | 2048| 12000001 | algorithm mode is not supported. | 2049| 12000002 | algorithm param is missing. | 2050| 12000003 | algorithm param is invalid. | 2051| 12000004 | operating file failed. | 2052| 12000005 | IPC communication failed. | 2053| 12000006 | error occurred in crypto engine. | 2054| 12000007 | this credential is already invalidated permanently. | 2055| 12000008 | verify auth token failed. | 2056| 12000009 | auth token is already timeout. | 2057| 12000011 | queried entity does not exist. | 2058| 12000012 | Device environment or input parameter abnormal. | 2059| 12000014 | memory is insufficient. | 2060| 12000017 | The key with same alias is already exist. | 2061 2062## huks.finishSession<sup>9+</sup> 2063 2064finishSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback\<HuksReturnResult>) : void 2065 2066finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2067 2068**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2069 2070**系统能力：** SystemCapability.Security.Huks.Extension 2071 2072**参数：** 2073 2074| 参数名 | 类型 | 必填 | 说明 | 2075| -------- | ----------------------------------------------------- | ---- | -------------------------------------------- | 2076| handle | number | 是 | finishSession操作的uint64类型的handle值。 | 2077| options | [HuksOptions](#huksoptions) | 是 | finishSession的参数集合。 | 2078| token | Uint8Array | 是 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md#二次认证密钥访问控制)的用户鉴权证明(AuthToken)。 | 2079| callback | AsyncCallback\<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到回调函数中。 | 2080 2081**错误码：** 2082 2083以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2084 2085| 错误码ID | 错误信息 | 2086| -------- | ------------- | 2087| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2088| 801 | api is not supported. | 2089| 12000001 | algorithm mode is not supported. | 2090| 12000002 | algorithm param is missing. | 2091| 12000003 | algorithm param is invalid. | 2092| 12000004 | operating file failed. | 2093| 12000005 | IPC communication failed. | 2094| 12000006 | error occurred in crypto engine. | 2095| 12000007 | this credential is already invalidated permanently. | 2096| 12000008 | verify auth token failed. | 2097| 12000009 | auth token is already timeout. | 2098| 12000011 | queried entity does not exist. | 2099| 12000012 | Device environment or input parameter abnormal. | 2100| 12000014 | memory is insufficient. | 2101| 12000017 | The key with same alias is already exist. | 2102 2103## huks.finishSession<sup>9+</sup> 2104 2105finishSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise\<HuksReturnResult> 2106 2107finishSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2108 2109**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2110 2111**系统能力：** SystemCapability.Security.Huks.Extension 2112 2113**参数：** 2114 2115| 参数名 | 类型 | 必填 | 说明 | 2116| ------- | ----------------------------------------------- | ---- | ----------------------------------- | 2117| handle | number | 是 | finishSession操作的uint64类型的handle值。 | 2118| options | [HuksOptions](#huksoptions) | 是 | finishSession操作的参数集合。 | 2119| token | Uint8Array | 否 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md#二次认证密钥访问控制)的用户鉴权证明(AuthToken)，不填表示不进行二次认证密钥访问控制。 | 2120 2121**返回值**： 2122 2123| 类型 | 说明 | 2124| ----------------------------------- | -------------------------------------------------- | 2125| Promise\<[HuksReturnResult](#huksreturnresult9)> | Promise对象，用于获取异步返回结果。 | 2126 2127**错误码：** 2128 2129以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2130 2131| 错误码ID | 错误信息 | 2132| -------- | ------------- | 2133| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2134| 801 | api is not supported. | 2135| 12000001 | algorithm mode is not supported. | 2136| 12000002 | algorithm param is missing. | 2137| 12000003 | algorithm param is invalid. | 2138| 12000004 | operating file failed. | 2139| 12000005 | IPC communication failed. | 2140| 12000006 | error occurred in crypto engine. | 2141| 12000007 | this credential is already invalidated permanently. | 2142| 12000008 | verify auth token failed. | 2143| 12000009 | auth token is already timeout. | 2144| 12000011 | queried entity does not exist. | 2145| 12000012 | Device environment or input parameter abnormal. | 2146| 12000014 | memory is insufficient. | 2147| 12000017 | The key with same alias is already exist. | 2148 2149## huks.abortSession<sup>9+</sup> 2150 2151abortSession(handle: number, options: HuksOptions, callback: AsyncCallback\<void>) : void 2152 2153abortSession操作密钥接口，使用Callback回调异步返回结果。 2154 2155**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2156 2157**系统能力：** SystemCapability.Security.Huks.Core 2158 2159**参数：** 2160 2161| 参数名 | 类型 | 必填 | 说明 | 2162| -------- | --------------------------- | ---- | ------------------------------------------- | 2163| handle | number | 是 | abortSession操作的uint64类型的handle值。 | 2164| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 2165| callback | AsyncCallback\<void> | 是 | 回调函数。将abortSession操作的结果添加到回调函数中。 | 2166 2167**错误码：** 2168 2169以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2170 2171| 错误码ID | 错误信息 | 2172| -------- | ------------- | 2173| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2174| 801 | api is not supported. | 2175| 12000004 | operating file failed. | 2176| 12000005 | IPC communication failed. | 2177| 12000006 | error occurred in crypto engine. | 2178| 12000012 | Device environment or input parameter abnormal. | 2179| 12000014 | memory is insufficient. | 2180 2181**示例：** 2182 2183```ts 2184import { huks } from '@kit.UniversalKeystoreKit'; 2185/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 2186 * huks.initSession和huks.updateSession 2187 * 以及huks.finishSession操作中的任一阶段发生错误时， 2188 * 都需要调用huks.abortSession来终止密钥的使用。 2189 * 2190 * 以下以RSA2048密钥的callback功能使用为例 2191 */ 2192 2193let keyAlias = "HuksDemoRSA"; 2194let properties: Array<huks.HuksParam> = [] 2195let options: huks.HuksOptions = { 2196 properties: properties, 2197 inData: new Uint8Array(0) 2198}; 2199let handle: number = 0; 2200async function huksAbort() { 2201 properties[0] = { 2202 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2203 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2204 }; 2205 properties[1] = { 2206 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2207 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 2208 }; 2209 properties[2] = { 2210 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2211 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2212 }; 2213 properties[3] = { 2214 tag: huks.HuksTag.HUKS_TAG_PADDING, 2215 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 2216 }; 2217 properties[4] = { 2218 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2219 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2220 }; 2221 properties[5] = { 2222 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2223 value: huks.HuksCipherMode.HUKS_MODE_ECB, 2224 } 2225 2226 huks.generateKeyItem(keyAlias, options, (error, data) => { 2227 if (error) { 2228 console.error(`callback: generateKeyItem failed`); 2229 } else { 2230 console.info(`callback: generateKeyItem success`); 2231 huks.initSession(keyAlias, options, (error, data) => { // 以initSession阶段进行abortSession为例。 2232 if (error) { 2233 console.error(`callback: initSession failed`); 2234 } else { 2235 console.info(`callback: initSession success, data = ${JSON.stringify(data)}`); 2236 handle = data.handle; 2237 huks.abortSession(handle, options, (error, data) => { 2238 if (error) { 2239 console.error(`callback: abortSession failed`); 2240 } else { 2241 console.info(`callback: abortSession success`); 2242 } 2243 }); 2244 } 2245 }); 2246 } 2247 }); 2248} 2249``` 2250 2251## huks.abortSession<sup>9+</sup> 2252 2253abortSession(handle: number, options: HuksOptions) : Promise\<void>; 2254 2255abortSession操作密钥接口，使用Promise方式异步返回结果。 2256 2257**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2258 2259**系统能力：** SystemCapability.Security.Huks.Extension 2260 2261**参数：** 2262 2263| 参数名 | 类型 | 必填 | 说明 | 2264| ------- | --------------------------- | ---- | ------------------------------------------- | 2265| handle | number | 是 | abortSession操作的uint64类型的handle值。 | 2266| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 2267 2268**返回值**： 2269 2270| 类型 | 说明 | 2271| ----------------------------------- | -------------------------------------------------- | 2272| Promise\<void> | Promise对象。将abortSession操作的结果添加到回调函数中。 | 2273 2274**错误码：** 2275 2276以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2277 2278| 错误码ID | 错误信息 | 2279| -------- | ------------- | 2280| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2281| 801 | api is not supported. | 2282| 12000004 | operating file failed. | 2283| 12000005 | IPC communication failed. | 2284| 12000006 | error occurred in crypto engine. | 2285| 12000012 | Device environment or input parameter abnormal. | 2286| 12000014 | memory is insufficient. | 2287 2288**示例：** 2289 2290```ts 2291import { huks } from '@kit.UniversalKeystoreKit'; 2292/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 2293 * huks.initSession和huks.updateSession 2294 * 以及huks.finishSession操作中的任一阶段发生错误时， 2295 * 都需要调用huks.abortSession来终止密钥的使用。 2296 * 2297 * 以下以RSA2048密钥的promise功能使用为例 2298 */ 2299 2300function stringToUint8Array(str: string) { 2301 let arr: number[] = []; 2302 for (let i = 0, j = str.length; i < j; ++i) { 2303 arr.push(str.charCodeAt(i)); 2304 } 2305 let tmpUint8Array = new Uint8Array(arr); 2306 return tmpUint8Array; 2307} 2308 2309let keyAlias = "HuksDemoRSA"; 2310let properties: Array<huks.HuksParam> = [] 2311let options: huks.HuksOptions = { 2312 properties: properties, 2313 inData: new Uint8Array(0) 2314}; 2315let handle: number = 0; 2316 2317async function generateKey() { 2318 properties[0] = { 2319 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2320 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2321 }; 2322 properties[1] = { 2323 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2324 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 2325 }; 2326 properties[2] = { 2327 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2328 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2329 }; 2330 properties[3] = { 2331 tag: huks.HuksTag.HUKS_TAG_PADDING, 2332 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 2333 }; 2334 properties[4] = { 2335 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2336 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2337 }; 2338 properties[5] = { 2339 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2340 value: huks.HuksCipherMode.HUKS_MODE_ECB, 2341 } 2342 2343 await huks.generateKeyItem(keyAlias, options) 2344 .then((data) => { 2345 console.info(`promise: generateKeyItem success`); 2346 }); 2347} 2348 2349async function huksInit() { 2350 console.info('enter huksInit'); 2351 await huks.initSession(keyAlias, options) 2352 .then((data) => { 2353 console.info(`promise: initSession success, data = ${JSON.stringify(data)}`); 2354 handle = data.handle; 2355 }); 2356} 2357 2358async function huksUpdate() { 2359 console.info('enter huksUpdate'); 2360 options.inData = stringToUint8Array("huksHmacTest"); 2361 await huks.updateSession(handle, options) 2362 .then((data) => { 2363 console.info(`promise: updateSession success, data = ${JSON.stringify(data)}`); 2364 }); 2365} 2366 2367async function huksFinish() { 2368 console.info('enter huksFinish'); 2369 options.inData = new Uint8Array(0); 2370 await huks.finishSession(handle, options) 2371 .then((data) => { 2372 console.info(`promise: finishSession success, data = ${JSON.stringify(data)}`); 2373 }); 2374} 2375 2376async function huksAbort() { 2377 console.info('enter huksAbort'); 2378 await huks.abortSession(handle, options) 2379 .then((data) => { 2380 console.info(`promise: abortSession success`); 2381 }); 2382} 2383 2384async function testAbort() { 2385 await generateKey(); 2386 await huksInit(); // 以initSession阶段进行abortSession为例。 2387 await huksAbort(); 2388} 2389``` 2390 2391## huks.listAliases<sup>12+</sup> 2392 2393listAliases(options: HuksOptions): Promise\<HuksListAliasesReturnResult>; 2394 2395查询密钥别名集接口，使用Promise方式异步返回结果。 2396 2397**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2398 2399**系统能力**：SystemCapability.Security.Huks.Extension 2400 2401**参数：** 2402 2403| 参数名 | 类型 | 必填 | 说明 | 2404| ------- | --------------------------- | ---- | ------------------------------------------- | 2405| options | [HuksOptions](#huksoptions) | 是 | listAliases操作的参数集合。 | 2406 2407 2408**返回值**： 2409 2410| 类型 | 说明 | 2411| ----------------------------------- | -------------------------------------------------- | 2412| Promise<[HuksListAliasesReturnResult](#hukslistaliasesreturnresult12)> | Promise对象。将listAliases操作的结果添加到回调函数中。 | 2413 2414**错误码：** 2415 2416以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)。 2417 2418| 错误码ID | 错误信息 | 2419| -------- | ------------- | 2420| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2421| 12000004 | operating file failed. | 2422| 12000005 | IPC communication failed. | 2423| 12000012 | Device environment or input parameter abnormal. | 2424| 12000014 | memory is insufficient. | 2425 2426**示例：** 2427 2428```ts 2429import { huks } from '@kit.UniversalKeystoreKit' 2430 2431async function testListAliases() { 2432 let queryProperties: Array<huks.HuksParam> = [ 2433 { 2434 tag: huks.HuksTag.HUKS_TAG_AUTH_STORAGE_LEVEL, 2435 value: huks.HuksAuthStorageLevel.HUKS_AUTH_STORAGE_LEVEL_DE 2436 } 2437 ]; 2438 let queryOptions: huks.HuksOptions = { 2439 properties: queryProperties 2440 }; 2441 2442 let result: huks.HuksListAliasesReturnResult = await huks.listAliases(queryOptions); 2443 console.info(`promise: listAliases success`); 2444} 2445``` 2446 2447 2448## HuksExceptionErrCode<sup>9+</sup> 2449 2450表示错误码的枚举以及对应的错误信息，错误码表示错误类型，错误信息展示错误详情。 2451 2452关于错误码的具体信息，可在[通用错误码](../errorcode-universal.md)和[HUKS错误码](errorcode-huks.md)中查看。 2453 2454**系统能力：** SystemCapability.Security.Huks.Core 2455 2456| 名称 | 值 | 说明 | 2457| ---------------------------------------------- | -------- |--------------------------- | 2458| HUKS_ERR_CODE_PERMISSION_FAIL | 201 | 权限错误导致失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2459| HUKS_ERR_CODE_NOT_SYSTEM_APP<sup>12+</sup> | 202 | 非系统应用不可以调用系统API。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2460| HUKS_ERR_CODE_ILLEGAL_ARGUMENT | 401 | 参数错误导致失败。可能原因：1. 必选参数未指定。2. 参数类型不正确。3. 参数校验失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2461| HUKS_ERR_CODE_NOT_SUPPORTED_API | 801 | 不支持的API。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2462| HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED | 12000001 | 不支持的功能/特性。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2463| HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT | 12000002 | 缺少密钥算法参数。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2464| HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT | 12000003 | 无效密钥算法参数。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2465| HUKS_ERR_CODE_FILE_OPERATION_FAIL | 12000004 | 文件操作失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2466| HUKS_ERR_CODE_COMMUNICATION_FAIL | 12000005 | 通信失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2467| HUKS_ERR_CODE_CRYPTO_FAIL | 12000006 | 算法库操作失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2468| HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED | 12000007 | 密钥访问失败-密钥访问失效。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2469| HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED | 12000008 | 密钥访问失败-密钥认证失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2470| HUKS_ERR_CODE_KEY_AUTH_TIME_OUT | 12000009 | 密钥访问失败-密钥访问超时。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2471| HUKS_ERR_CODE_SESSION_LIMIT | 12000010 | 密钥操作会话数已达上限。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2472| HUKS_ERR_CODE_ITEM_NOT_EXIST | 12000011 | 目标对象不存在。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2473| HUKS_ERR_CODE_EXTERNAL_ERROR | 12000012 | 外部错误。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2474| HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST | 12000013 | 缺失所需凭据。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2475| HUKS_ERR_CODE_INSUFFICIENT_MEMORY | 12000014 | 内存不足。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2476| HUKS_ERR_CODE_CALL_SERVICE_FAILED | 12000015 | 调用其他系统服务失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2477| HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET<sup>11+</sup> | 12000016 | 需要锁屏密码但未设置。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2478| HUKS_ERR_CODE_KEY_ALREADY_EXIST<sup>20+</sup> | 12000017 | 同名密钥已存在。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2479| HUKS_ERR_CODE_INVALID_ARGUMENT<sup>20+</sup> | 12000018 | 输入参数非法。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2480 2481## HuksKeyPurpose 2482 2483表示密钥用途。 2484 2485一个密钥仅能用于单类用途，不能既用于加解密又用于签名验签。 2486 2487**系统能力：** SystemCapability.Security.Huks.Core 2488 2489| 名称 | 值 | 说明 | 2490| ------------------------ | ---- | -------------------------------- | 2491| HUKS_KEY_PURPOSE_ENCRYPT | 1 | 表示密钥用于对明文进行加密操作。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2492| HUKS_KEY_PURPOSE_DECRYPT | 2 | 表示密钥用于对密文进行解密操作。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2493| HUKS_KEY_PURPOSE_SIGN | 4 | 表示密钥用于对数据进行签名。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2494| HUKS_KEY_PURPOSE_VERIFY | 8 | 表示密钥用于验证签名后的数据。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2495| HUKS_KEY_PURPOSE_DERIVE | 16 | 表示密钥用于派生密钥。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2496| HUKS_KEY_PURPOSE_WRAP | 32 | 表示密钥用于加密导出。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2497| HUKS_KEY_PURPOSE_UNWRAP | 64 | 表示密钥加密导入。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2498| HUKS_KEY_PURPOSE_MAC | 128 | 表示密钥用于生成mac消息验证码。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2499| HUKS_KEY_PURPOSE_AGREE | 256 | 表示密钥用于进行密钥协商。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2500 2501## HuksKeyDigest 2502 2503表示摘要算法。 2504 2505**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2506 2507**系统能力：** SystemCapability.Security.Huks.Core 2508 2509API version 8-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2510 2511| 名称 | 值 | 说明 | 2512| ---------------------- | ---- | ---------------------------------------- | 2513| HUKS_DIGEST_NONE | 0 | 表示无摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2514| HUKS_DIGEST_MD5 | 1 | 表示MD5摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2515| HUKS_DIGEST_SM3<sup>9+</sup> | 2 | 表示SM3摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2516| HUKS_DIGEST_SHA1 | 10 | 表示SHA1摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2517| HUKS_DIGEST_SHA224 | 11 | 表示SHA224摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2518| HUKS_DIGEST_SHA256 | 12 | 表示SHA256摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2519| HUKS_DIGEST_SHA384 | 13 | 表示SHA384摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>|| 2520| HUKS_DIGEST_SHA512 | 14 | 表示SHA512摘要算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2521 2522## HuksKeyPadding 2523 2524表示补齐算法。 2525 2526**系统能力：** SystemCapability.Security.Huks.Core 2527 2528| 名称 | 值 | 说明 | 2529| ---------------------- | ---- | ---------------------------------------- | 2530| HUKS_PADDING_NONE | 0 | 表示不使用补齐算法。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2531| HUKS_PADDING_OAEP | 1 | 表示使用OAEP补齐算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2532| HUKS_PADDING_PSS | 2 | 表示使用PSS补齐算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2533| HUKS_PADDING_PKCS1_V1_5 | 3 | 表示使用PKCS1_V1_5补齐算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2534| HUKS_PADDING_PKCS5 | 4 | 表示使用PKCS5补齐算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2535| HUKS_PADDING_PKCS7 | 5 | 表示使用PKCS7补齐算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2536| HUKS_PADDING_ISO_IEC_9796_2<sup>12+</sup> | 6 | 表示使用ISO_IEC_9796_2填充算法<!--Del--> (暂不支持) <!--DelEnd-->。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2537| HUKS_PADDING_ISO_IEC_9797_1<sup>12+</sup> | 7 | 表示使用ISO_IEC_9797_1填充算法<!--Del--> (暂不支持) <!--DelEnd-->。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2538 2539## HuksCipherMode 2540 2541表示加密模式。 2542 2543**系统能力：** SystemCapability.Security.Huks.Core 2544 2545| 名称 | 值 | 说明 | 2546| ------------- | ---- | --------------------- | 2547| HUKS_MODE_ECB | 1 | 表示使用ECB加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2548| HUKS_MODE_CBC | 2 | 表示使用CBC加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2549| HUKS_MODE_CTR | 3 | 表示使用CTR加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2550| HUKS_MODE_OFB | 4 | 表示使用OFB加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2551| HUKS_MODE_CFB<sup>12+</sup> | 5 | 表示使用CFB加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2552| HUKS_MODE_CCM | 31 | 表示使用CCM加密模式。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2553| HUKS_MODE_GCM | 32 | 表示使用GCM加密模式。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2554 2555## HuksKeySize 2556 2557表示密钥长度。 2558 2559**系统能力：** SystemCapability.Security.Huks.Core 2560 2561| 名称 | 值 | 说明 | 2562| ---------------------------------- | ---- | ------------------------------------------ | 2563| HUKS_RSA_KEY_SIZE_512 | 512 | 表示使用RSA算法的密钥长度为512bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2564| HUKS_RSA_KEY_SIZE_768 | 768 | 表示使用RSA算法的密钥长度为768bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2565| HUKS_RSA_KEY_SIZE_1024 | 1024 | 表示使用RSA算法的密钥长度为1024bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2566| HUKS_RSA_KEY_SIZE_2048 | 2048 | 表示使用RSA算法的密钥长度为2048bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2567| HUKS_RSA_KEY_SIZE_3072 | 3072 | 表示使用RSA算法的密钥长度为3072bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2568| HUKS_RSA_KEY_SIZE_4096 | 4096 | 表示使用RSA算法的密钥长度为4096bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2569| HUKS_ECC_KEY_SIZE_224 | 224 | 表示使用ECC算法的密钥长度为224bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2570| HUKS_ECC_KEY_SIZE_256 | 256 | 表示使用ECC算法的密钥长度为256bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2571| HUKS_ECC_KEY_SIZE_384 | 384 | 表示使用ECC算法的密钥长度为384bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2572| HUKS_ECC_KEY_SIZE_521 | 521 | 表示使用ECC算法的密钥长度为521bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2573| HUKS_AES_KEY_SIZE_128 | 128 | 表示使用AES算法的密钥长度为128bit。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2574| HUKS_AES_KEY_SIZE_192 | 192 | 表示使用AES算法的密钥长度为192bit。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2575| HUKS_AES_KEY_SIZE_256 | 256 | 表示使用AES算法的密钥长度为256bit。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2576| HUKS_AES_KEY_SIZE_512<sup>(deprecated)</sup> | 512 | 表示使用AES算法的密钥长度为512bit。从API version 11开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core| 2577| HUKS_CURVE25519_KEY_SIZE_256 | 256 | 表示使用CURVE25519算法的密钥长度为256bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 <br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2578| HUKS_DH_KEY_SIZE_2048 | 2048 | 表示使用DH算法的密钥长度为2048bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2579| HUKS_DH_KEY_SIZE_3072 | 3072 | 表示使用DH算法的密钥长度为3072bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2580| HUKS_DH_KEY_SIZE_4096 | 4096 | 表示使用DH算法的密钥长度为4096bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2581| HUKS_SM2_KEY_SIZE_256<sup>9+</sup> | 256 | 表示SM2算法的密钥长度为256bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2582| HUKS_SM4_KEY_SIZE_128<sup>9+</sup> | 128 | 表示SM4算法的密钥长度为128bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2583| HUKS_DES_KEY_SIZE_64<sup>12+</sup> | 64 | 表示DES算法的密钥长度为64bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2584| HUKS_3DES_KEY_SIZE_128<sup>12+</sup> | 128 | 表示3DES算法的密钥长度为128bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2585| HUKS_3DES_KEY_SIZE_192<sup>12+</sup> | 192 | 表示3DES算法的密钥长度为192bit。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2586 2587## HuksKeyAlg 2588 2589表示密钥使用的算法。 2590 2591**系统能力：** SystemCapability.Security.Huks.Core 2592 2593| 名称 | 值 | 说明 | 2594| ------------------------- | ---- | --------------------- | 2595| HUKS_ALG_RSA | 1 | 表示使用RSA算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2596| HUKS_ALG_ECC | 2 | 表示使用ECC算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2597| HUKS_ALG_DSA | 3 | 表示使用DSA算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2598| HUKS_ALG_AES | 20 | 表示使用AES算法。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2599| HUKS_ALG_HMAC | 50 | 表示使用HMAC算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2600| HUKS_ALG_HKDF | 51 | 表示使用HKDF算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2601| HUKS_ALG_PBKDF2 | 52 | 表示使用PBKDF2算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2602| HUKS_ALG_ECDH | 100 | 表示使用ECDH算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2603| HUKS_ALG_X25519 | 101 | 表示使用X25519算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2604| HUKS_ALG_ED25519 | 102 | 表示使用ED25519算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2605| HUKS_ALG_DH | 103 | 表示使用DH算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2606| HUKS_ALG_SM2<sup>9+</sup> | 150 | 表示使用SM2算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2607| HUKS_ALG_SM3<sup>9+</sup> | 151 | 表示使用SM3算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2608| HUKS_ALG_SM4<sup>9+</sup> | 152 | 表示使用SM4算法。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2609| HUKS_ALG_DES<sup>12+</sup> | 160 | 表示使用DES算法（API 12开始支持<!--RP4-->轻量级设备<!--RP4End-->，API 18开始支持<!--RP5-->标准设备<!--RP5End-->）。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2610| HUKS_ALG_3DES<sup>12+</sup> | 161 | 表示使用3DES算法（API 12开始支持<!--RP4-->轻量级设备<!--RP4End-->，API 18开始支持<!--RP5-->标准设备<!--RP5End-->）。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2611| HUKS_ALG_CMAC<sup>12+</sup> | 162 | 表示使用CMAC算法（API 12开始支持<!--RP4-->轻量级设备<!--RP4End-->，API 18开始支持<!--RP5-->标准设备<!--RP5End-->）。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core| 2612 2613## HuksKeyGenerateType 2614 2615表示生成密钥的类型。 2616 2617**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2618 2619**系统能力：** SystemCapability.Security.Huks.Core 2620 2621API version 8-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2622 2623| 名称 | 值 | 说明 | 2624| ------------------------------ | ---- | ---------------- | 2625| HUKS_KEY_GENERATE_TYPE_DEFAULT | 0 | 默认生成的密钥。 | 2626| HUKS_KEY_GENERATE_TYPE_DERIVE | 1 | 派生生成的密钥。 | 2627| HUKS_KEY_GENERATE_TYPE_AGREE | 2 | 协商生成的密钥。 | 2628 2629## HuksKeyFlag 2630 2631表示密钥的产生方式。 2632 2633**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2634 2635**系统能力：** SystemCapability.Security.Huks.Core 2636 2637| 名称 | 值 | 说明 | 2638| -------------------------- | ---- | ------------------------------------ | 2639| HUKS_KEY_FLAG_IMPORT_KEY | 1 | 表示通过导入公钥接口导入的密钥。 | 2640| HUKS_KEY_FLAG_GENERATE_KEY | 2 | 表示通过生成密钥接口生成的密钥。 | 2641| HUKS_KEY_FLAG_AGREE_KEY | 3 | 表示通过生成密钥协商接口生成的密钥。 | 2642| HUKS_KEY_FLAG_DERIVE_KEY | 4 | 表示通过生成密钥派生接口生成的密钥。 | 2643 2644## HuksKeyStorageType 2645 2646表示密钥存储方式。 2647 2648**系统能力：** SystemCapability.Security.Huks.Core 2649 2650| 名称 | 值 | 说明 | 2651| -------------------------------------------- | ---- | ------------------------------ | 2652| HUKS_STORAGE_TEMP<sup>(deprecated)</sup> | 0 | 表示通过本地直接管理密钥。<br/> > **说明：** 从API version 10开始废弃，由于开发者正常使用密钥管理过程中并不需要使用此TAG，故无替代接口。针对密钥派生场景，可使用HUKS_STORAGE_ONLY_USED_IN_HUKS 与 HUKS_STORAGE_KEY_EXPORT_ALLOWED。 <br> **系统能力：** SystemCapability.Security.Huks.Core| 2653| HUKS_STORAGE_PERSISTENT<sup>(deprecated)</sup> | 1 | 表示通过HUKS service管理密钥。<br/> > **说明：** 从API version 10开始废弃，由于开发者正常使用密钥管理过程中并不需要使用此TAG，故无替代接口。针对密钥派生场景，可使用HUKS_STORAGE_ONLY_USED_IN_HUKS 与 HUKS_STORAGE_KEY_EXPORT_ALLOWED。 <br> **系统能力：** SystemCapability.Security.Huks.Core| 2654| HUKS_STORAGE_ONLY_USED_IN_HUKS<sup>10+</sup> | 2 | 表示主密钥派生的密钥存储于huks中，由HUKS进行托管。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>10-11</sup>| 2655| HUKS_STORAGE_KEY_EXPORT_ALLOWED<sup>10+</sup> | 3 | 表示主密钥派生的密钥直接导出给业务方，HUKS不对其进行托管服务。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>10-11</sup>| 2656 2657## HuksSendType 2658 2659表示发送Tag的方式。 2660 2661**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2662 2663**系统能力：** SystemCapability.Security.Huks.Core 2664 2665API version 8-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2666 2667| 名称 | 值 | 说明 | 2668| -------------------- | ---- | ----------------- | 2669| HUKS_SEND_TYPE_ASYNC | 0 | 表示异步发送TAG。 | 2670| HUKS_SEND_TYPE_SYNC | 1 | 表示同步发送TAG。 | 2671 2672## HuksUnwrapSuite<sup>9+</sup> 2673 2674表示导入加密密钥的算法套件。 2675 2676**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2677 2678**系统能力：** SystemCapability.Security.Huks.Core 2679 2680API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2681 2682| 名称 | 值 | 说明 | 2683| ---------------------------------------------- | ---- | ----------------------------------------------------- | 2684| HUKS_UNWRAP_SUITE_X25519_AES_256_GCM_NOPADDING | 1 | 导入加密密钥时，X25519密钥协商后使用AES-256 GCM加密。 | 2685| HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING | 2 | 导入加密密钥时，ECDH密钥协商后使用AES-256 GCM加密。 | 2686 2687## HuksImportKeyType<sup>9+</sup> 2688 2689表示导入密钥的密钥类型，默认为导入公钥，导入对称密钥时不需要该字段。 2690 2691**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2692 2693**系统能力：** SystemCapability.Security.Huks.Core 2694 2695API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2696 2697| 名称 | 值 | 说明 | 2698| ------------------------- | ---- | ------------------------------ | 2699| HUKS_KEY_TYPE_PUBLIC_KEY | 0 | 表示导入的密钥类型为公钥。 | 2700| HUKS_KEY_TYPE_PRIVATE_KEY | 1 | 表示导入的密钥类型为私钥。 | 2701| HUKS_KEY_TYPE_KEY_PAIR | 2 | 表示导入的密钥类型为公私钥对。 | 2702 2703## HuksRsaPssSaltLenType<sup>10+</sup> 2704 2705表示Rsa在签名验签、padding为pss时需指定的salt_len类型。 2706 2707**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2708 2709**系统能力：** SystemCapability.Security.Huks.Core 2710 2711API version 10-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2712 2713| 名称 | 值 | 说明 | 2714| ------------------------------------------ | ---- | ---------------------------- | 2715| HUKS_RSA_PSS_SALT_LEN_DIGEST | 0 | 表示以摘要长度设置salt_len。 | 2716| HUKS_RSA_PSS_SALT_LEN_MAX | 1 | 表示以最大长度设置salt_len。 | 2717 2718## HuksUserAuthType<sup>9+</sup> 2719 2720表示用户认证类型。 2721 2722**系统能力：** SystemCapability.Security.Huks.Extension 2723 2724| 名称 | 值 | 说明 | 2725| ------------------------------- | ---- | ------------------------- | 2726| HUKS_USER_AUTH_TYPE_FINGERPRINT | 1 << 0 | 表示用户认证类型为指纹。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 2727| HUKS_USER_AUTH_TYPE_FACE | 1 << 1 | 表示用户认证类型为人脸。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 2728| HUKS_USER_AUTH_TYPE_PIN | 1 << 2 | 表示用户认证类型为PIN码。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 2729| HUKS_USER_AUTH_TYPE_TUI_PIN<sup>20+</sup> | 1 << 5 | 表示用户认证类型为TUI PIN码。<!--Del-->（当前暂不支持）<!--DelEnd--> | 2730 2731## HuksUserAuthMode<sup>12+</sup> 2732 2733表示用户认证模式。 2734 2735**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2736 2737**系统能力：** SystemCapability.Security.Huks.Extension 2738 2739| 名称 | 值 | 说明 | 2740| ------------------------------- | ---- | ------------------------- | 2741| HUKS_USER_AUTH_MODE_LOCAL | 0 | 本地认证模式。 | 2742| HUKS_USER_AUTH_MODE_COAUTH | 1 | 跨端协同认证模式。| 2743 2744## HuksAuthAccessType<sup>9+</sup> 2745 2746表示安全访问控制类型。 2747 2748**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2749 2750**系统能力：** SystemCapability.Security.Huks.Extension 2751 2752| 名称 | 值 | 说明 | 2753| --------------------------------------- | ---- | ------------------------------------------------ | 2754| HUKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD | 1 << 0 | 表示安全访问控制类型为清除密码后密钥无效。 | 2755| HUKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL | 1 << 1 | 表示安全访问控制类型为新录入生物特征后密钥无效。 | 2756| HUKS_AUTH_ACCESS_ALWAYS_VALID<sup>11+</sup> | 1 << 2 | 表示安全访问控制类型为该密钥总是有效。 | 2757 2758## HuksChallengeType<sup>9+</sup> 2759 2760表示密钥使用时生成challenge的类型。 2761 2762**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2763 2764**系统能力：** SystemCapability.Security.Huks.Extension 2765 2766| 名称 | 值 | 说明 | 2767| ------------------------------- | ---- | ------------------------------ | 2768| HUKS_CHALLENGE_TYPE_NORMAL | 0 | 表示challenge为普通类型，默认32字节。 | 2769| HUKS_CHALLENGE_TYPE_CUSTOM | 1 | 表示challenge为用户自定义类型。支持使用多个密钥仅一次认证。 | 2770| HUKS_CHALLENGE_TYPE_NONE | 2 | 表示免challenge类型。 | 2771 2772## HuksChallengePosition<sup>9+</sup> 2773 2774表示challenge类型为用户自定义类型时，生成的challenge有效长度仅为8字节连续的数据，且仅支持4种位置。 2775 2776**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2777 2778**系统能力：** SystemCapability.Security.Huks.Extension 2779 2780| 名称 | 值 | 说明 | 2781| ------------------------------- | ---- | ------------------------------ | 2782| HUKS_CHALLENGE_POS_0 | 0 | 表示0~7字节为当前密钥的有效challenge。 | 2783| HUKS_CHALLENGE_POS_1 | 1 | 表示8~15字节为当前密钥的有效challenge。 | 2784| HUKS_CHALLENGE_POS_2 | 2 | 表示16~23字节为当前密钥的有效challenge。 | 2785| HUKS_CHALLENGE_POS_3 | 3 | 表示24~31字节为当前密钥的有效challenge。 | 2786 2787## HuksSecureSignType<sup>9+</sup> 2788 2789表示生成或导入密钥时，指定该密钥的签名类型。 2790 2791**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2792 2793**系统能力：** SystemCapability.Security.Huks.Extension 2794 2795| 名称 | 值 | 说明 | 2796| ------------------------------ | ---- | ------------------------------------------------------------ | 2797| HUKS_SECURE_SIGN_WITH_AUTHINFO | 1 | 表示签名类型为携带认证信息。生成或导入密钥时指定该字段，则在使用密钥进行签名时，对待签名的数据添加认证信息后进行签名。<br>**注意**：携带的认证信息包含身份信息，开发者需在其隐私声明中对此身份信息的使用目的、存留策略和销毁方式进行说明。 | 2798 2799## HuksAuthStorageLevel<sup>11+</sup> 2800 2801表示生成或导入密钥时，指定该密钥的存储安全等级。 2802 2803**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2804 2805**系统能力：** SystemCapability.Security.Huks.Core 2806 2807API version 11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 2808 2809| 名称 | 值 | 说明 | 2810| ------------------------------ | ---- | ------------------------------------------------------------ | 2811| HUKS_AUTH_STORAGE_LEVEL_DE | 0 | 表示密钥仅在开机后可访问。 | 2812| HUKS_AUTH_STORAGE_LEVEL_CE | 1 | 表示密钥仅在首次解锁后可访问。 | 2813| HUKS_AUTH_STORAGE_LEVEL_ECE | 2 | 表示密钥仅在解锁状态时可访问。 | 2814 2815## HuksKeyWrapType<sup>20+</sup> 2816 2817表示密钥加密类型（加密导出或导入密钥）的枚举。 2818 2819**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。 2820 2821**系统能力：** SystemCapability.Security.Huks.Core 2822 2823| 名称 | 值 | 说明 | 2824| ------------------------------ | ---- | ------------------------------------------------------------ | 2825| HUKS_KEY_WRAP_TYPE_HUK_BASED | 2 | 硬件唯一密钥加密类型。<!--Del-->（当前暂不支持）<!--DelEnd--> | 2826 2827## HuksTagType 2828 2829表示Tag的数据类型。 2830 2831**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2832 2833**系统能力：** SystemCapability.Security.Huks.Core 2834 2835| 名称 | 值 | 说明 | 2836| --------------------- | ------- | --------------------------------------- | 2837| HUKS_TAG_TYPE_INVALID | 0 << 28 | 表示非法的Tag类型。 | 2838| HUKS_TAG_TYPE_INT | 1 << 28 | 表示该Tag的数据类型为int类型的number。 | 2839| HUKS_TAG_TYPE_UINT | 2 << 28 | 表示该Tag的数据类型为uint类型的number。 | 2840| HUKS_TAG_TYPE_ULONG | 3 << 28 | 表示该Tag的数据类型为bigint。 | 2841| HUKS_TAG_TYPE_BOOL | 4 << 28 | 表示该Tag的数据类型为boolean。 | 2842| HUKS_TAG_TYPE_BYTES | 5 << 28 | 表示该Tag的数据类型为Uint8Array。 | 2843 2844## HuksTag 2845 2846表示调用参数的Tag。 2847 2848**系统能力：** SystemCapability.Security.Huks.Core 2849 2850| 名称 | 值 | 说明 | 2851| ----------------------------------------------------------- | ---------------------------------------- | ------------------------------------------------------------ | 2852| HUKS_TAG_INVALID<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_INVALID \| 0 | 表示非法的Tag。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2853| HUKS_TAG_ALGORITHM | HuksTagType.HUKS_TAG_TYPE_UINT \| 1 | 表示算法的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2854| HUKS_TAG_PURPOSE | HuksTagType.HUKS_TAG_TYPE_UINT \| 2 | 表示密钥用途的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2855| HUKS_TAG_KEY_SIZE | HuksTagType.HUKS_TAG_TYPE_UINT \| 3 | 表示密钥长度的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2856| HUKS_TAG_DIGEST | HuksTagType.HUKS_TAG_TYPE_UINT \| 4 | 表示摘要算法的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2857| HUKS_TAG_PADDING | HuksTagType.HUKS_TAG_TYPE_UINT \| 5 | 表示填充模式的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2858| HUKS_TAG_BLOCK_MODE | HuksTagType.HUKS_TAG_TYPE_UINT \| 6 | 表示加密模式的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2859| HUKS_TAG_KEY_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 7 | 表示密钥类型的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2860| HUKS_TAG_ASSOCIATED_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 8 | 表示附加身份验证数据的Tag。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2861| HUKS_TAG_NONCE | HuksTagType.HUKS_TAG_TYPE_BYTES \| 9 | 表示密钥加解密的NONCE字段。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2862| HUKS_TAG_IV | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10 | 表示密钥初始化的向量。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2863| HUKS_TAG_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 11 | 表示密钥派生时的info。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2864| HUKS_TAG_SALT | HuksTagType.HUKS_TAG_TYPE_BYTES \| 12 | 表示密钥派生时的盐值。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2865| HUKS_TAG_PWD<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 13 | 表示密钥派生时的password。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2866| HUKS_TAG_ITERATION | HuksTagType.HUKS_TAG_TYPE_UINT \| 14 | 表示密钥派生时的迭代次数。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2867| HUKS_TAG_KEY_GENERATE_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 15 | 表示生成密钥类型的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2868| HUKS_TAG_DERIVE_MAIN_KEY<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 16 | 表示密钥派生时的主密钥。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2869| HUKS_TAG_DERIVE_FACTOR<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 17 | 表示密钥派生时的派生因子。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2870| HUKS_TAG_DERIVE_ALG<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 18 | 表示密钥派生时的算法类型。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2871| HUKS_TAG_AGREE_ALG | HuksTagType.HUKS_TAG_TYPE_UINT \| 19 | 表示密钥协商时的算法类型。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2872| HUKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 20 | 表示密钥协商时的公钥别名。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2873| HUKS_TAG_AGREE_PRIVATE_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 21 | 表示密钥协商时的私钥别名。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2874| HUKS_TAG_AGREE_PUBLIC_KEY | HuksTagType.HUKS_TAG_TYPE_BYTES \| 22 | 表示密钥协商时的公钥。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2875| HUKS_TAG_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 23 | 表示密钥别名。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2876| HUKS_TAG_DERIVE_KEY_SIZE | HuksTagType.HUKS_TAG_TYPE_UINT \| 24 | 表示派生密钥的大小。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2877| HUKS_TAG_IMPORT_KEY_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 25 | 表示导入的密钥类型。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2878| HUKS_TAG_UNWRAP_ALGORITHM_SUITE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 26 | 表示导入加密密钥的套件。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>9-11</sup>| 2879| HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG<sup>10+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \|29 | 表示派生密钥/协商密钥的存储类型。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>10-11</sup>| 2880| HUKS_TAG_RSA_PSS_SALT_LEN_TYPE<sup>10+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \|30 | 表示rsa_pss_salt_length的类型。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>10-11</sup>| 2881| HUKS_TAG_ACTIVE_DATETIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 201 | 原为证书业务预留字段，当前证书管理已独立，此字段废弃，不再预留。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2882| HUKS_TAG_ORIGINATION_EXPIRE_DATETIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 202 | 原为证书业务预留字段，当前证书管理已独立，此字段废弃，不再预留。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2883| HUKS_TAG_USAGE_EXPIRE_DATETIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 203 | 原为证书业务预留字段，当前证书管理已独立，此字段废弃，不再预留。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2884| HUKS_TAG_CREATION_DATETIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 204 | 原为证书业务预留字段，当前证书管理已独立，此字段废弃，不再预留。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2885| HUKS_TAG_ALL_USERS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 301 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2886| HUKS_TAG_USER_ID | HuksTagType.HUKS_TAG_TYPE_UINT \| 302 | 表示当前密钥属于哪个userID。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2887| HUKS_TAG_NO_AUTH_REQUIRED | HuksTagType.HUKS_TAG_TYPE_BOOL \| 303 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2888| HUKS_TAG_USER_AUTH_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 304 | 表示用户认证类型。从[HuksUserAuthType](#huksuserauthtype9)中选择，需要与安全访问控制类型同时设置。支持同时指定两种用户认证类型，如：安全访问控制类型指定为HUKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL时，密钥访问认证类型可以指定以下三种： HUKS_USER_AUTH_TYPE_FACE 、HUKS_USER_AUTH_TYPE_FINGERPRINT、HUKS_USER_AUTH_TYPE_FACE \| HUKS_USER_AUTH_TYPE_FINGERPRINT <br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2889| HUKS_TAG_AUTH_TIMEOUT | HuksTagType.HUKS_TAG_TYPE_UINT \| 305 | 表示auth token单次有效期。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2890| HUKS_TAG_AUTH_TOKEN | HuksTagType.HUKS_TAG_TYPE_BYTES \| 306 | 用于传入authToken的字段。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2891| HUKS_TAG_KEY_AUTH_ACCESS_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 307 | 表示安全访问控制类型。从[HuksAuthAccessType](#huksauthaccesstype9)中选择，需要和用户认证类型同时设置。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2892| HUKS_TAG_KEY_SECURE_SIGN_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 308 | 表示生成或导入密钥时，指定该密钥的签名类型。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2893| HUKS_TAG_CHALLENGE_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 309 | 表示密钥使用时生成的challenge类型。从[HuksChallengeType](#hukschallengetype9)中选择。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2894| HUKS_TAG_CHALLENGE_POS<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 310 | 表示challenge类型为用户自定义类型时，huks产生的challenge有效长度仅为8字节连续的数据。从[HuksChallengePosition](#hukschallengeposition9)中选择。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2895| HUKS_TAG_KEY_AUTH_PURPOSE<sup>10+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \|311 | 表示密钥认证用途的tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2896| HUKS_TAG_AUTH_STORAGE_LEVEL<sup>11+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \|316 | 表示密钥存储安全等级的tag。从[HuksAuthStorageLevel](#huksauthstoragelevel11)中选择。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2897| HUKS_TAG_USER_AUTH_MODE<sup>12+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 319 | 表示用户认证模式。从[HuksUserAuthMode](#huksuserauthmode12)中选择。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2898| HUKS_TAG_ATTESTATION_CHALLENGE | HuksTagType.HUKS_TAG_TYPE_BYTES \| 501 | 表示attestation时的挑战值。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2899| HUKS_TAG_ATTESTATION_APPLICATION_ID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 502 | 表示attestation时拥有该密钥的application的Id。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2900| HUKS_TAG_ATTESTATION_ID_BRAND<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 503 | 表示设备的品牌。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2901| HUKS_TAG_ATTESTATION_ID_DEVICE<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 504 | 表示设备的设备ID。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2902| HUKS_TAG_ATTESTATION_ID_PRODUCT<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 505 | 表示设备的产品名。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2903| HUKS_TAG_ATTESTATION_ID_SERIAL<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 506 | 表示设备的SN号。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2904| HUKS_TAG_ATTESTATION_ID_IMEI<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 507 | 表示设备的IMEI号。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2905| HUKS_TAG_ATTESTATION_ID_MEID<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 508 | 表示设备的MEID号。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2906| HUKS_TAG_ATTESTATION_ID_MANUFACTURER<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 509 | 表示设备的制造商。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2907| HUKS_TAG_ATTESTATION_ID_MODEL<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 510 | 表示设备的型号。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2908| HUKS_TAG_ATTESTATION_ID_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 511 | 表示attestation时的密钥别名。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2909| HUKS_TAG_ATTESTATION_ID_SOCID<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 512 | 表示设备的SOCID。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2910| HUKS_TAG_ATTESTATION_ID_UDID<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 513 | 表示设备的UDID。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2911| HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 514 | 表示attestation时的安全凭据。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2912| HUKS_TAG_ATTESTATION_ID_VERSION_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 515 | 表示attestation时的版本号。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2913| HUKS_TAG_KEY_OVERRIDE<sup>20+</sup> | HuksTagType.HUKS_TAG_TYPE_BOOL \| 520 | 表示是否覆写同名密钥。<br>**原子化服务API：** 从API version 20开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2914| HUKS_TAG_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1001 | 表示是否使用生成key时传入的别名的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2915| HUKS_TAG_KEY_STORAGE_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1002 | 表示密钥存储方式的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2916| HUKS_TAG_IS_ALLOWED_WRAP | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1003 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2917| HUKS_TAG_KEY_WRAP_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 1004 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2918| HUKS_TAG_KEY_AUTH_ID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 1005 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2919| HUKS_TAG_KEY_ROLE | HuksTagType.HUKS_TAG_TYPE_UINT \| 1006 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2920| HUKS_TAG_KEY_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1007 | 表示密钥标志的Tag。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2921| HUKS_TAG_IS_ASYNCHRONIZED | HuksTagType.HUKS_TAG_TYPE_UINT \| 1008 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2922| HUKS_TAG_SECURE_KEY_ALIAS<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1009 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2923| HUKS_TAG_SECURE_KEY_UUID<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 1010 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2924| HUKS_TAG_KEY_DOMAIN | HuksTagType.HUKS_TAG_TYPE_UINT \| 1011 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2925| HUKS_TAG_IS_DEVICE_PASSWORD_SET<sup>11+</sup> | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1012 | 表示密钥锁屏密码访问控制字段，可限制密钥只有在用户设置了锁屏密码时可用。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2926| HUKS_TAG_PROCESS_NAME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10001 | 表示进程名称的Tag。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2927| HUKS_TAG_PACKAGE_NAME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10002 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2928| HUKS_TAG_ACCESS_TIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10003 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2929| HUKS_TAG_USES_TIME<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10004 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2930| HUKS_TAG_CRYPTO_CTX<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 10005 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2931| HUKS_TAG_KEY | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10006 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2932| HUKS_TAG_KEY_VERSION<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10007 | 表示密钥版本的Tag。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2933| HUKS_TAG_PAYLOAD_LEN<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10008 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Extension | 2934| HUKS_TAG_AE_TAG | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10009 | 用于传入GCM模式中的AEAD数据的字段。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2935| HUKS_TAG_IS_KEY_HANDLE<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_ULONG \| 10010 | 原为预留字段，从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2936| HUKS_TAG_OS_VERSION<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10101 | 表示操作系统版本的Tag。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2937| HUKS_TAG_OS_PATCHLEVEL<sup>(deprecated)</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 10102 | 表示操作系统补丁级别的Tag。从API version 9开始废弃。 <br> **系统能力：** SystemCapability.Security.Huks.Core | 2938| HUKS_TAG_SYMMETRIC_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20001 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2939| HUKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20002 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2940| HUKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20003 | 预留。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core<sup>12+</sup> <br>SystemCapability.Security.Huks.Extension<sup>8-11</sup>| 2941 2942## huks.getSdkVersion<sup>(deprecated)</sup> 2943 2944getSdkVersion(options: HuksOptions) : string 2945 2946获取当前系统sdk版本。 2947 2948> **说明：** 2949> 2950> 从API version 11开始废弃。 2951 2952**系统能力：** SystemCapability.Security.Huks.Extension 2953 2954**参数：** 2955 2956| 参数名 | 类型 | 必填 | 说明 | 2957| ------- | ---------- | ---- | ------------------------- | 2958| options | [HuksOptions](#huksoptions) | 是 | 空对象，用于存放sdk版本。 | 2959 2960**返回值：** 2961 2962| 类型 | 说明 | 2963| ------ | ------------- | 2964| string | 返回sdk版本。 | 2965 2966**示例：** 2967 2968```ts 2969import { huks } from '@kit.UniversalKeystoreKit'; 2970/* 此处options选择emptyOptions传空 */ 2971let emptyOptions: huks.HuksOptions = { 2972 properties: [] 2973}; 2974let result = huks.getSdkVersion(emptyOptions); 2975``` 2976 2977## huks.generateKey<sup>(deprecated)</sup> 2978 2979generateKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2980 2981生成密钥，使用Callback回调异步返回结果。 2982 2983> **说明：** 2984> 2985> 从API version 9开始废弃，建议使用[huks.generateKeyItem<sup>9+</sup>](#huksgeneratekeyitem9)替代。 2986 2987**系统能力：** SystemCapability.Security.Huks.Extension 2988 2989**参数：** 2990 2991| 参数名 | 类型 | 必填 | 说明 | 2992| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2993| keyAlias | string | 是 | 别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 2994| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。 | 2995| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其余结果请参考HuksResult进行错误码查询。 | 2996 2997**示例：** 2998 2999```ts 3000import { huks } from '@kit.UniversalKeystoreKit'; 3001/* 以生成RSA512密钥为例 */ 3002 3003let keyAlias = 'keyAlias'; 3004let properties: Array<huks.HuksParam> = [ 3005 { 3006 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3007 value: huks.HuksKeyAlg.HUKS_ALG_RSA 3008 }, 3009 { 3010 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3011 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_512 3012 }, 3013 { 3014 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3015 value: 3016 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | 3017 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 3018 }, 3019 { 3020 tag: huks.HuksTag.HUKS_TAG_PADDING, 3021 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 3022 }, 3023 { 3024 tag: huks.HuksTag.HUKS_TAG_DIGEST, 3025 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 3026 } 3027]; 3028let options: huks.HuksOptions = { 3029 properties: properties 3030}; 3031huks.generateKey(keyAlias, options, (err, data) => { 3032}); 3033``` 3034 3035## huks.generateKey<sup>(deprecated)</sup> 3036 3037generateKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 3038 3039生成密钥，使用Promise方式异步返回结果。 3040 3041> **说明：** 3042> 3043> 从API version 9开始废弃，建议使用[huks.generateKeyItem<sup>9+</sup>](#huksgeneratekeyitem9-1)替代。 3044 3045**系统能力：** SystemCapability.Security.Huks.Extension 3046 3047**参数：** 3048 3049| 参数名 | 类型 | 必填 | 说明 | 3050| -------- | --------------------------- | ---- | ------------------------ | 3051| keyAlias | string | 是 | 密钥别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 3052| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。 | 3053 3054**返回值**： 3055 3056| 类型 | 说明 | 3057| ----------------------------------- | -------------------------------------------------- | 3058| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3059 3060**示例：** 3061 3062```ts 3063import { huks } from '@kit.UniversalKeystoreKit'; 3064/* 以生成ECC256密钥为例 */ 3065 3066let keyAlias = 'keyAlias'; 3067let properties: Array<huks.HuksParam> = [ 3068 { 3069 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3070 value: huks.HuksKeyAlg.HUKS_ALG_ECC 3071 }, 3072 { 3073 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3074 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 3075 }, 3076 { 3077 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3078 value: 3079 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 3080 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 3081 }, 3082 { 3083 tag: huks.HuksTag.HUKS_TAG_DIGEST, 3084 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 3085 } 3086]; 3087let options: huks.HuksOptions = { 3088 properties: properties 3089}; 3090let result = huks.generateKey(keyAlias, options); 3091``` 3092 3093## huks.deleteKey<sup>(deprecated)</sup> 3094 3095deleteKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3096 3097删除密钥，使用Callback回调异步返回结果。 3098 3099> **说明：** 3100> 3101> 从API version 9开始废弃，建议使用[huks.deleteKeyItem<sup>9+</sup>](#huksdeletekeyitem9)替代。 3102 3103**系统能力：** SystemCapability.Security.Huks.Extension 3104 3105**参数：** 3106 3107| 参数名 | 类型 | 必填 | 说明 | 3108| -------- | ----------------------------------------- | ---- |----------------------------------------------------| 3109| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 3110| options | [HuksOptions](#huksoptions) | 是 | 用于删除时指定密钥的属性TAG。 | 3111| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3112 3113**示例：** 3114 3115```ts 3116import { huks } from '@kit.UniversalKeystoreKit'; 3117/* 此处options选择emptyOptions传空 */ 3118let keyAlias = 'keyAlias'; 3119let emptyOptions: huks.HuksOptions = { 3120 properties: [] 3121}; 3122huks.deleteKey(keyAlias, emptyOptions, (err, data) => { 3123}); 3124``` 3125 3126## huks.deleteKey<sup>(deprecated)</sup> 3127 3128deleteKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 3129 3130删除密钥，使用Promise方式异步返回结果。 3131 3132> **说明：** 3133> 3134> 从API version 9开始废弃，建议使用[huks.deleteKeyItem<sup>9+</sup>](#huksdeletekeyitem9-1)替代。 3135 3136**系统能力：** SystemCapability.Security.Huks.Extension 3137 3138**参数：** 3139 3140| 参数名 | 类型 | 必填 | 说明 | 3141| -------- | ----------- | ---- | ----------------------------------------------------- | 3142| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 3143| options | [HuksOptions](#huksoptions) | 是 | 用于删除时指定密钥的属性TAG。 | 3144 3145**返回值：** 3146 3147| 类型 | 说明 | 3148| ----------------------------------- | -------------------------------------------------- | 3149| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3150 3151**示例：** 3152 3153```ts 3154import { huks } from '@kit.UniversalKeystoreKit'; 3155import { BusinessError } from "@kit.BasicServicesKit" 3156/* 此处options选择emptyOptions传空 */ 3157let keyAlias = 'keyAlias'; 3158let emptyOptions: huks.HuksOptions = { 3159 properties: [] 3160}; 3161let result = huks.deleteKey(keyAlias, emptyOptions).then((data) => { 3162 console.info('delete key seccuss'); 3163}).catch((err: BusinessError) => { 3164 console.error("密钥删除失败，错误码是： " + err.code + " 错误码信息： " + err.message) 3165}); 3166``` 3167 3168## huks.importKey<sup>(deprecated)</sup> 3169 3170importKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3171 3172导入明文密钥，使用Callback方式回调异步返回结果。 3173 3174> **说明：** 3175> 3176> 从API version 9开始废弃，建议使用[huks.importKeyItem<sup>9+</sup>](#huksimportkeyitem9)替代。 3177 3178**系统能力：** SystemCapability.Security.Huks.Extension 3179 3180**参数：** 3181 3182| 参数名 | 类型 | 必填 | 说明 | 3183| -------- | ------------------------ | ---- | ------------------------------------------------- | 3184| keyAlias | string | 是 | 密钥别名。 | 3185| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。 | 3186| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3187 3188**示例：** 3189 3190```ts 3191import { huks } from '@kit.UniversalKeystoreKit'; 3192/* 以导入AES256密钥为例 */ 3193 3194let plainTextSize32 = makeRandomArr(32); 3195function makeRandomArr(size: number) { 3196 let arr = new Uint8Array(size); 3197 for (let i = 0; i < size; i++) { 3198 arr[i] = Math.floor(Math.random() * 10); 3199 } 3200 return arr; 3201}; 3202let keyAlias = 'keyAlias'; 3203let properties: Array<huks.HuksParam> = [ 3204 { 3205 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3206 value: huks.HuksKeyAlg.HUKS_ALG_AES 3207 }, 3208 { 3209 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3210 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 3211 }, 3212 { 3213 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3214 value: 3215 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 3216 }, 3217 { 3218 tag: huks.HuksTag.HUKS_TAG_PADDING, 3219 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 3220 }, 3221 { 3222 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 3223 value: huks.HuksCipherMode.HUKS_MODE_ECB 3224 } 3225]; 3226let options: huks.HuksOptions = { 3227 properties: properties, 3228 inData: plainTextSize32 3229}; 3230huks.importKey(keyAlias, options, (err, data) => { 3231}); 3232``` 3233 3234## huks.importKey<sup>(deprecated)</sup> 3235 3236importKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 3237 3238导入明文密钥，使用Promise方式异步返回结果。 3239 3240> **说明：** 3241> 3242> 从API version 9开始废弃，建议使用[huks.importKeyItem<sup>9+</sup>](#huksimportkeyitem9-1)替代。 3243 3244**系统能力：** SystemCapability.Security.Huks.Extension 3245 3246**参数：** 3247 3248| 参数名 | 类型 | 必填 | 说明 | 3249| -------- | ----------- | ---- | ------------------------------------ | 3250| keyAlias | string | 是 | 密钥别名。密钥别名的最大长度为128字节，建议不包含个人信息等敏感词汇。 | 3251| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。 | 3252 3253**返回值：** 3254 3255| 类型 | 说明 | 3256| ----------------------------------- | -------------------------------------------------- | 3257| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3258 3259**示例：** 3260 3261```ts 3262import { huks } from '@kit.UniversalKeystoreKit'; 3263/* 以导入AES128为例 */ 3264 3265let plainTextSize32 = makeRandomArr(32); 3266function makeRandomArr(size: number) { 3267 let arr = new Uint8Array(size); 3268 for (let i = 0; i < size; i++) { 3269 arr[i] = Math.floor(Math.random() * 10); 3270 } 3271 return arr; 3272}; 3273/*第一步：生成密钥*/ 3274let keyAlias = 'keyAlias'; 3275let properties: Array<huks.HuksParam> = [ 3276 { 3277 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3278 value: huks.HuksKeyAlg.HUKS_ALG_AES 3279 }, 3280 { 3281 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3282 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_128 3283 }, 3284 { 3285 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3286 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 3287 }, 3288 { 3289 tag: huks.HuksTag.HUKS_TAG_PADDING, 3290 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 3291 }, 3292 { 3293 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 3294 value: huks.HuksCipherMode.HUKS_MODE_ECB 3295 } 3296]; 3297let huksOptions: huks.HuksOptions = { 3298 properties: properties, 3299 inData: plainTextSize32 3300}; 3301let result = huks.importKey(keyAlias, huksOptions); 3302``` 3303 3304## huks.exportKey<sup>(deprecated)</sup> 3305 3306exportKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3307 3308导出密钥，使用Callback方式回调异步返回的结果。 3309 3310> **说明：** 3311> 3312> 从API version 9开始废弃，建议使用[huks.exportKeyItem<sup>9+</sup>](#huksexportkeyitem9)替代。 3313 3314**系统能力：** SystemCapability.Security.Huks.Extension 3315 3316**参数：** 3317 3318| 参数名 | 类型 | 必填 | 说明 | 3319| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 3320| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 3321| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 3322| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 3323 3324**示例：** 3325 3326```ts 3327import { huks } from '@kit.UniversalKeystoreKit'; 3328/* 此处options选择emptyOptions来传空 */ 3329let keyAlias = 'keyAlias'; 3330let emptyOptions: huks.HuksOptions = { 3331 properties: [] 3332}; 3333huks.exportKey(keyAlias, emptyOptions, (err, data) => { 3334}); 3335``` 3336 3337## huks.exportKey<sup>(deprecated)</sup> 3338 3339exportKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 3340 3341导出密钥，使用Promise方式回调异步返回的结果。 3342 3343> **说明：** 3344> 3345> 从API version 9开始废弃，建议使用[huks.exportKeyItem<sup>9+</sup>](#huksexportkeyitem9-1)替代。 3346 3347**系统能力：** SystemCapability.Security.Huks.Extension 3348 3349**参数：** 3350 3351| 参数名 | 类型 | 必填 | 说明 | 3352| -------- | ----------- | ---- | ------------------------------------------------------------ | 3353| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 3354| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 3355 3356**返回值：** 3357 3358| 类型 | 说明 | 3359| ----------------------------------- | ------------------------------------------------------------ | 3360| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 3361 3362**示例：** 3363 3364```ts 3365import { huks } from '@kit.UniversalKeystoreKit'; 3366/* 此处options选择emptyOptions来传空 */ 3367let keyAlias = 'keyAlias'; 3368let emptyOptions: huks.HuksOptions = { 3369 properties: [] 3370}; 3371let result = huks.exportKey(keyAlias, emptyOptions); 3372``` 3373 3374## huks.getKeyProperties<sup>(deprecated)</sup> 3375 3376getKeyProperties(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3377 3378获取密钥属性，使用Callback回调异步返回结果。 3379 3380> **说明：** 3381> 3382> 从API version 9开始废弃，建议使用[huks.getKeyItemProperties<sup>9+</sup>](#huksgetkeyitemproperties9)替代。 3383 3384**系统能力：** SystemCapability.Security.Huks.Extension 3385 3386**参数：** 3387 3388| 参数名 | 类型 | 必填 | 说明 | 3389| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 3390| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 3391| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 3392| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。errorCode：返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 3393 3394**示例：** 3395 3396```ts 3397import { huks } from '@kit.UniversalKeystoreKit'; 3398/* 此处options选择emptyOptions来传空 */ 3399let keyAlias = 'keyAlias'; 3400let emptyOptions: huks.HuksOptions = { 3401 properties: [] 3402}; 3403huks.getKeyProperties(keyAlias, emptyOptions, (err, data) => { 3404}); 3405``` 3406 3407## huks.getKeyProperties<sup>(deprecated)</sup> 3408 3409getKeyProperties(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 3410 3411获取密钥属性，使用Promise回调异步返回结果。 3412 3413> **说明：** 3414> 3415> 从API version 9开始废弃，建议使用[huks.getKeyItemProperties<sup>9+</sup>](#huksgetkeyitemproperties9-1)替代。 3416 3417**系统能力：** SystemCapability.Security.Huks.Extension 3418 3419**参数：** 3420 3421| 参数名 | 类型 | 必填 | 说明 | 3422| -------- | ----------- | ---- | ------------------------------------------------------------ | 3423| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 3424| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 3425 3426**返回值：** 3427 3428| 类型 | 说明 | 3429| ------------------ | ------------------------------------------------------------ | 3430| Promise\<[HuksResult](#huksoptions)> | Promise对象。errorCode：返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。properties：返回值为生成密钥时所需参数。 | 3431 3432**示例：** 3433 3434```ts 3435import { huks } from '@kit.UniversalKeystoreKit'; 3436/* 此处options选择emptyOptions来传空 */ 3437let keyAlias = 'keyAlias'; 3438let emptyOptions: huks.HuksOptions = { 3439 properties: [] 3440}; 3441let result = huks.getKeyProperties(keyAlias, emptyOptions); 3442``` 3443 3444## huks.isKeyExist<sup>(deprecated)</sup> 3445 3446isKeyExist(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<boolean>) : void 3447 3448判断密钥是否存在，使用Callback回调异步返回结果。 3449 3450> **说明：** 3451> 3452> 从API version 9开始废弃，建议使用[huks.isKeyItemExist<sup>9+</sup>](#huksiskeyitemexist9)替代。 3453 3454**系统能力：** SystemCapability.Security.Huks.Extension 3455 3456**参数：** 3457 3458| 参数名 | 类型 | 必填 | 说明 | 3459| -------- | ---------------------- | ---- | ------------------------------------- | 3460| keyAlias | string | 是 | 所需查找的密钥的别名。 | 3461| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG。 | 3462| callback | AsyncCallback\<boolean> | 是 | 回调函数。false代表密钥不存在，true代表密钥存在。 | 3463 3464**示例：** 3465 3466```ts 3467import { huks } from '@kit.UniversalKeystoreKit'; 3468/* 此处options选择emptyOptions来传空 */ 3469let keyAlias = 'keyAlias'; 3470let emptyOptions: huks.HuksOptions = { 3471 properties: [] 3472}; 3473huks.isKeyExist(keyAlias, emptyOptions, (err, data) => { 3474}); 3475``` 3476 3477## huks.isKeyExist<sup>(deprecated)</sup> 3478 3479isKeyExist(keyAlias: string, options: HuksOptions) : Promise\<boolean> 3480 3481判断密钥是否存在，使用Promise回调异步返回结果。 3482 3483> **说明：** 3484> 3485> 从API version 9开始废弃，建议使用[huks.isKeyItemExist<sup>9+</sup>](#huksiskeyitemexist9-1)替代。 3486 3487**系统能力：** SystemCapability.Security.Huks.Extension 3488 3489**参数：** 3490 3491| 参数名 | 类型 | 必填 | 说明 | 3492| -------- | ----------- | ---- | -------------------------------- | 3493| keyAlias | string | 是 | 所需查找的密钥的别名。 | 3494| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG。 | 3495 3496**返回值：** 3497 3498| 类型 | 说明 | 3499| ----------------- | --------------------------------------- | 3500| Promise\<boolean> | Promise对象。false代表密钥不存在，true代表密钥存在。 | 3501 3502**示例：** 3503 3504```ts 3505import { huks } from '@kit.UniversalKeystoreKit'; 3506/* 此处options选择emptyOptions来传空 */ 3507let keyAlias = 'keyAlias'; 3508let emptyOptions: huks.HuksOptions = { 3509 properties: [] 3510}; 3511let result = huks.isKeyExist(keyAlias, emptyOptions); 3512``` 3513 3514## huks.init<sup>(deprecated)</sup> 3515 3516init(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksHandle>) : void 3517 3518init操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3519 3520> **说明：** 3521> 3522> 从API version 9开始废弃，建议使用[huks.initSession<sup>9+</sup>](#huksinitsession9-1)替代。 3523 3524**系统能力：** SystemCapability.Security.Huks.Extension 3525 3526**参数：** 3527 3528| 参数名 | 类型 | 必填 | 说明 | 3529| -------- | ---------------------- | ---- | ------------------------------------- | 3530| keyAlias | string | 是 | Init操作密钥的别名。 | 3531| options | [HuksOptions](#huksoptions) | 是 | Init操作的参数集合。 | 3532| callback | AsyncCallback\<[HuksHandle](#hukshandledeprecated)> | 是 | 回调函数。将Init操作操作返回的handle添加到回调函数中。 | 3533 3534## huks.init<sup>(deprecated)</sup> 3535 3536init(keyAlias: string, options: HuksOptions) : Promise\<HuksHandle> 3537 3538init操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3539 3540> **说明：** 3541> 3542> 从API version 9开始废弃，建议使用[huks.initSession<sup>9+</sup>](#huksinitsession9-1)替代。 3543 3544**系统能力：** SystemCapability.Security.Huks.Extension 3545 3546**参数：** 3547 3548| 参数名 | 类型 | 必填 | 说明 | 3549| -------- | ---------------------- | ---- | ------------------------------------- | 3550| keyAlias | string | 是 | Init操作密钥的别名。 | 3551| options | [HuksOptions](#huksoptions) | 是 | Init参数集合。 | 3552 3553**返回值**： 3554 3555| 类型 | 说明 | 3556| ----------------------------------- | -------------------------------------------------- | 3557| Promise\<[HuksHandle](#hukshandledeprecated)> | Promise对象。将Init操作返回的handle添加到回调函数中。 | 3558 3559## huks.update<sup>(deprecated)</sup> 3560 3561update(handle: number, token?: Uint8Array, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3562 3563update操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3564 3565> **说明：** 3566> 3567> 从API version 9开始废弃，建议使用[huks.updateSession<sup>9+</sup>](#huksupdatesession9-1)替代。 3568 3569**系统能力：** SystemCapability.Security.Huks.Extension 3570 3571**参数：** 3572 3573| 参数名 | 类型 | 必填 | 说明 | 3574| -------- | ----------------------------------------- | ---- | -------------------------------------------- | 3575| handle | number | 是 | Update操作的uint64类型的handle值。 | 3576| token | Uint8Array | 否 | Update操作的token。 | 3577| options | [HuksOptions](#huksoptions) | 是 | Update操作的参数集合。 | 3578| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Update操作的结果添加到回调函数中。 | 3579 3580## huks.update<sup>(deprecated)</sup> 3581 3582update(handle: number, token?: Uint8Array, options: HuksOptions) : Promise\<HuksResult>; 3583 3584update操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3585 3586> **说明：** 3587> 3588> 从API version 9开始废弃，建议使用[huks.updateSession<sup>9+</sup>](#huksupdatesession9-2)替代。 3589 3590**系统能力：** SystemCapability.Security.Huks.Extension 3591 3592**参数：** 3593 3594| 参数名 | 类型 | 必填 | 说明 | 3595| ------- | ----------------------------------- | ---- | -------------------------------------------- | 3596| handle | number | 是 | Update操作的uint64类型的handle值。 | 3597| token | Uint8Array | 否 | Update操作的token。 | 3598| options | [HuksOptions](#huksoptions) | 是 | Update操作的参数集合。 | 3599 3600**返回值**： 3601 3602| 类型 | 说明 | 3603| ----------------------------------- | -------------------------------------------------- | 3604| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。将Update操作的结果添加到回调函数中。 | 3605 3606## huks.finish<sup>(deprecated)</sup> 3607 3608finish(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3609 3610finish操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3611 3612> **说明：** 3613> 3614> 从API version 9开始废弃，建议使用[huks.finishSession<sup>9+</sup>](#huksfinishsession9)替代。 3615 3616**系统能力：** SystemCapability.Security.Huks.Extension 3617 3618**参数：** 3619 3620| 参数名 | 类型 | 必填 | 说明 | 3621| -------- | ---------------------- | ---- | ------------------------------------- | 3622| handle | number | 是 | Finish操作的uint64类型的handle值。 | 3623| options | [HuksOptions](#huksoptions) | 是 | Finish的参数集合。 | 3624| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Finish操作的结果添加到回调函数中。 | 3625 3626## huks.finish<sup>(deprecated)</sup> 3627 3628finish(handle: number, options: HuksOptions) : Promise\<HuksResult> 3629 3630finish操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 3631 3632> **说明：** 3633> 3634> 从API version 9开始废弃，建议使用[huks.finishSession<sup>9+</sup>](#huksfinishsession9-1)替代。 3635 3636**系统能力：** SystemCapability.Security.Huks.Extension 3637 3638**参数：** 3639 3640| 参数名 | 类型 | 必填 | 说明 | 3641| -------- | ---------------------- | ---- | ------------------------------------- | 3642| handle | number | 是 | Finish操作的uint64类型的handle值。 | 3643| options | [HuksOptions](#huksoptions) | 是 | Finish操作的参数集合。 | 3644 3645**返回值**： 3646 3647| 类型 | 说明 | 3648| ----------------------------------- | -------------------------------------------------- | 3649| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象，用于获取异步返回结果。 | 3650 3651## huks.abort<sup>(deprecated)</sup> 3652 3653abort(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 3654 3655abort操作密钥接口，使用Callback回调异步返回结果。 3656 3657> **说明：** 3658> 3659> 从API version 9开始废弃，建议使用[huks.abortSession<sup>9+</sup>](#huksabortsession9)替代。 3660 3661**系统能力：** SystemCapability.Security.Huks.Extension 3662 3663**参数：** 3664 3665| 参数名 | 类型 | 必填 | 说明 | 3666| -------- | ---------------------- | ---- | ------------------------------------- | 3667| handle | number | 是 | Abort操作的uint64类型的handle值。 | 3668| options | [HuksOptions](#huksoptions) | 是 | Abort操作的参数集合。 | 3669| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Abort操作的结果添加到回调函数中。 | 3670 3671**示例：** 3672 3673```ts 3674import { huks } from '@kit.UniversalKeystoreKit'; 3675/* huks.init, huks.update, huks.finish为三段式接口，需要一起使用，当huks.init和huks.update 3676 * 以及huks.finish操作中的任一阶段发生错误时，都需要调用huks.abort来终止密钥的使用。 3677 * 3678 * 以下以RSA2048密钥的callback操作使用为例 3679 */ 3680 3681let keyAlias = "HuksDemoRSA"; 3682let properties: Array<huks.HuksParam> = []; 3683let options: huks.HuksOptions = { 3684 properties: properties, 3685 inData: new Uint8Array(0) 3686}; 3687let handle: number = 0; 3688let resultMessage = ""; 3689 3690async function generateKey() { 3691 properties[0] = { 3692 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3693 value: huks.HuksKeyAlg.HUKS_ALG_RSA 3694 }; 3695 properties[1] = { 3696 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3697 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 3698 }; 3699 properties[2] = { 3700 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3701 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 3702 }; 3703 properties[3] = { 3704 tag: huks.HuksTag.HUKS_TAG_PADDING, 3705 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 3706 }; 3707 properties[4] = { 3708 tag: huks.HuksTag.HUKS_TAG_DIGEST, 3709 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 3710 }; 3711 huks.generateKey(keyAlias, options); 3712} 3713 3714function stringToUint8Array(str: string) { 3715 let arr: number[] = []; 3716 for (let i = 0, j = str.length; i < j; ++i) { 3717 arr.push(str.charCodeAt(i)); 3718 } 3719 let tmpUint8Array = new Uint8Array(arr); 3720 return tmpUint8Array; 3721} 3722 3723async function huksInit() { 3724 await huks.init(keyAlias, options).then((data) => { 3725 console.info(`test init data: ${JSON.stringify(data)}`); 3726 handle = data.handle; 3727 }); 3728} 3729 3730async function huksUpdate() { 3731 options.inData = stringToUint8Array("huksHmacTest"); 3732 await huks.update(handle, options.inData, options).then((data) => { 3733 if (data.errorCode === 0) { 3734 resultMessage += "update success!"; 3735 } else { 3736 resultMessage += "update fail!"; 3737 } 3738 }); 3739 console.info(resultMessage); 3740} 3741 3742function huksFinish() { 3743 options.inData = stringToUint8Array("HuksDemoHMAC"); 3744 huks.finish(handle, options).then((data) => { 3745 if (data.errorCode === 0) { 3746 resultMessage = "finish success!"; 3747 console.info(resultMessage); 3748 } else { 3749 resultMessage = "finish fail errorCode: " + data.errorCode; 3750 console.error(resultMessage); 3751 } 3752 }); 3753} 3754 3755async function huksAbort() { 3756 new Promise<huks.HuksResult>((resolve, reject) => { 3757 huks.abort(handle, options, (err, data) => { 3758 console.info(`huksAbort data ${JSON.stringify(data)}`); 3759 console.error(`huksAbort err ${JSON.stringify(err)}`); 3760 }); 3761 }); 3762} 3763 3764``` 3765 3766## huks.abort<sup>(deprecated)</sup> 3767 3768abort(handle: number, options: HuksOptions) : Promise\<HuksResult>; 3769 3770abort操作密钥接口，使用Promise方式异步返回结果。 3771 3772> **说明：** 3773> 3774> 从API version 9开始废弃，建议使用[huks.abortSession<sup>9+</sup>](#huksabortsession9-1)替代。 3775 3776**系统能力：** SystemCapability.Security.Huks.Extension 3777 3778**参数：** 3779 3780| 参数名 | 类型 | 必填 | 说明 | 3781| -------- | ---------------------- | ---- | ------------------------------------- | 3782| handle | number | 是 | Abort操作的uint64类型的handle值。 | 3783| options | [HuksOptions](#huksoptions) | 是 | Abort操作的参数集合。 | 3784 3785**返回值**： 3786 3787| 类型 | 说明 | 3788| ----------------------------------- | -------------------------------------------------- | 3789| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。将Abort操作的结果添加到回调函数中。 | 3790 3791**示例：** 3792 3793```ts 3794import { huks } from '@kit.UniversalKeystoreKit'; 3795/* huks.init, huks.update, huks.finish为三段式接口，需要一起使用，当huks.init和huks.update 3796 * 以及huks.finish操作中的任一阶段发生错误时，都需要调用huks.abort来终止密钥的使用。 3797 * 3798 * 以下以RSA2048密钥的promise操作使用为例 3799 */ 3800let keyAlias = "HuksDemoRSA"; 3801let properties: Array<huks.HuksParam> = []; 3802let options: huks.HuksOptions = { 3803 properties: properties, 3804 inData: new Uint8Array(0) 3805}; 3806let handle: number = 0; 3807let resultMessage = ""; 3808 3809function stringToUint8Array(str: string) { 3810 let arr: number[] = []; 3811 for (let i = 0, j = str.length; i < j; ++i) { 3812 arr.push(str.charCodeAt(i)); 3813 } 3814 let tmpUint8Array = new Uint8Array(arr); 3815 return tmpUint8Array; 3816} 3817 3818async function generateKey() { 3819 properties[0] = { 3820 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 3821 value: huks.HuksKeyAlg.HUKS_ALG_RSA 3822 }; 3823 properties[1] = { 3824 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 3825 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 3826 }; 3827 properties[2] = { 3828 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 3829 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 3830 }; 3831 properties[3] = { 3832 tag: huks.HuksTag.HUKS_TAG_PADDING, 3833 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 3834 }; 3835 properties[4] = { 3836 tag: huks.HuksTag.HUKS_TAG_DIGEST, 3837 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 3838 }; 3839 huks.generateKey(keyAlias, options, (err, data) => { 3840 }); 3841} 3842 3843async function huksInit() { 3844 return new Promise<huks.HuksHandle>((resolve, reject) => { 3845 huks.init(keyAlias, options, async (err, data) => { 3846 if (data.errorCode === 0) { 3847 resultMessage = "init success!" 3848 handle = data.handle; 3849 } else { 3850 resultMessage = "init fail errorCode: " + data.errorCode 3851 } 3852 }); 3853 }); 3854} 3855 3856async function huksUpdate() { 3857 options.inData = stringToUint8Array("huksHmacTest"); 3858 new Promise<huks.HuksResult>((resolve, reject) => { 3859 huks.update(handle, options.inData, options, (err, data) => { 3860 if (data.errorCode === 0) { 3861 resultMessage += "update success!"; 3862 console.info(resultMessage); 3863 } else { 3864 resultMessage += "update fail!"; 3865 console.error(resultMessage); 3866 } 3867 }); 3868 }); 3869} 3870 3871async function huksFinish() { 3872 options.inData = stringToUint8Array("0"); 3873 new Promise<huks.HuksResult>((resolve, reject) => { 3874 huks.finish(handle, options, (err, data) => { 3875 if (data.errorCode === 0) { 3876 resultMessage = "finish success!"; 3877 } else { 3878 resultMessage = "finish fail errorCode: " + data.errorCode; 3879 } 3880 }); 3881 }); 3882} 3883 3884function huksAbort() { 3885 huks.abort(handle, options).then((data) => { 3886 if (data.errorCode === 0) { 3887 console.info("abort success!"); 3888 } else { 3889 console.error("abort fail errorCode: " + data.errorCode); 3890 } 3891 }); 3892} 3893``` 3894 3895## HuksHandle<sup>(deprecated)</sup> 3896 3897huks Handle结构体。 3898 3899**系统能力：** SystemCapability.Security.Huks.Extension 3900 3901> **说明：** 3902> 3903> 从API version 9开始废弃，建议使用[HuksSessionHandle<sup>9+</sup>](#hukssessionhandle9)替代。 3904 3905| 名称 | 类型 | 必填 | 说明 | 3906| ---------- | ---------------- | ---- | -------- | 3907| errorCode | number | 是 | 表示错误码。 | 3908| handle | number | 是 | 表示无符号整数类型的handle值。 | 3909| token | Uint8Array | 否 | 表示[init](#huksinitdeprecated)操作之后获取到的challenge信息。 | 3910 3911## HuksResult<sup>(deprecated)</sup> 3912 3913调用接口返回的result。 3914 3915**系统能力：** SystemCapability.Security.Huks.Extension 3916 3917> **说明：** 3918> 3919> - 从API version 9开始废弃，建议使用[HuksReturnResult<sup>9+</sup>](#huksreturnresult9)替代。 3920> - errorCode的具体信息，请参考[错误码文档](errorcode-huks.md)。 3921 3922| 名称 | 类型 | 必填 | 说明 | 3923| ---------- | ------------------------------- | ---- | ---------------- | 3924| errorCode | number | 是 | 表示错误码。 | 3925| outData | Uint8Array | 否 | 表示输出数据。 | 3926| properties | Array\<[HuksParam](#huksparam)> | 否 | 表示属性信息。 | 3927| certChains | Array\<string> | 否 | 表示证书链数据。 | 3928 3929## HuksErrorCode<sup>(deprecated)</sup> 3930 3931表示错误码的枚举。 3932 3933**系统能力：** SystemCapability.Security.Huks.Extension 3934 3935> **说明：** 3936> 3937> 从API version 9开始废弃，建议使用[HuksExceptionErrCode<sup>9+</sup>](#huksexceptionerrcode9)替代。 3938 3939| 名称 | 值 | 说明 | 3940| -------------------------- | ----- | ---- | 3941| HUKS_SUCCESS | 0 |表示成功。| 3942| HUKS_FAILURE | -1 |表示失败。| 3943| HUKS_ERROR_BAD_STATE | -2 |表示错误的状态。| 3944| HUKS_ERROR_INVALID_ARGUMENT | -3 |表示无效的数据。| 3945| HUKS_ERROR_NOT_SUPPORTED | -4 |表示不支持。| 3946| HUKS_ERROR_NO_PERMISSION | -5 |表示没有许可。| 3947| HUKS_ERROR_INSUFFICIENT_DATA | -6 |表示数据不足。| 3948| HUKS_ERROR_BUFFER_TOO_SMALL | -7 |表示缓冲区太小。| 3949| HUKS_ERROR_INSUFFICIENT_MEMORY | -8 |表示内存不足。| 3950| HUKS_ERROR_COMMUNICATION_FAILURE | -9 |表示通讯失败。| 3951| HUKS_ERROR_STORAGE_FAILURE | -10 |表示存储故障。| 3952| HUKS_ERROR_HARDWARE_FAILURE | -11 |表示硬件故障。| 3953| HUKS_ERROR_ALREADY_EXISTS | -12 |表示已经存在。| 3954| HUKS_ERROR_NOT_EXIST | -13 |表示不存在。| 3955| HUKS_ERROR_NULL_POINTER | -14 |表示空指针。| 3956| HUKS_ERROR_FILE_SIZE_FAIL | -15 |表示文件大小失败。| 3957| HUKS_ERROR_READ_FILE_FAIL | -16 |表示读取文件失败。| 3958| HUKS_ERROR_INVALID_PUBLIC_KEY | -17 |表示无效的公钥。| 3959| HUKS_ERROR_INVALID_PRIVATE_KEY | -18 |表示无效的私钥。| 3960| HUKS_ERROR_INVALID_KEY_INFO | -19 |表示无效的密钥信息。| 3961| HUKS_ERROR_HASH_NOT_EQUAL | -20 |表示哈希不相等。| 3962| HUKS_ERROR_MALLOC_FAIL | -21 |表示MALLOC 失败。| 3963| HUKS_ERROR_WRITE_FILE_FAIL | -22 |表示写文件失败。| 3964| HUKS_ERROR_REMOVE_FILE_FAIL | -23 |表示删除文件失败。| 3965| HUKS_ERROR_OPEN_FILE_FAIL | -24 |表示打开文件失败。| 3966| HUKS_ERROR_CLOSE_FILE_FAIL | -25 |表示关闭文件失败。| 3967| HUKS_ERROR_MAKE_DIR_FAIL | -26 |表示创建目录失败。| 3968| HUKS_ERROR_INVALID_KEY_FILE | -27 |表示无效的密钥文件。| 3969| HUKS_ERROR_IPC_MSG_FAIL | -28 |表示IPC 信息失败。| 3970| HUKS_ERROR_REQUEST_OVERFLOWS | -29 |表示请求溢出。| 3971| HUKS_ERROR_PARAM_NOT_EXIST | -30 |表示参数不存在。| 3972| HUKS_ERROR_CRYPTO_ENGINE_ERROR | -31 |表示CRYPTO ENGINE错误。| 3973| HUKS_ERROR_COMMUNICATION_TIMEOUT | -32 |表示通讯超时。| 3974| HUKS_ERROR_IPC_INIT_FAIL | -33 |表示IPC 初始化失败。| 3975| HUKS_ERROR_IPC_DLOPEN_FAIL | -34 |表示IPC DLOPEN 失败。| 3976| HUKS_ERROR_EFUSE_READ_FAIL | -35 |表示EFUSE 读取失败。| 3977| HUKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST | -36 |表示存在新的根密钥材料。| 3978| HUKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL | -37 |表示更新根密钥材料失败。| 3979| HUKS_ERROR_VERIFICATION_FAILED | -38 |表示验证证书链失败。| 3980| HUKS_ERROR_CHECK_GET_ALG_FAIL | -100 |表示检查获取 ALG 失败。| 3981| HUKS_ERROR_CHECK_GET_KEY_SIZE_FAIL | -101 |表示检查获取密钥大小失败。| 3982| HUKS_ERROR_CHECK_GET_PADDING_FAIL | -102 |表示检查获取填充失败。| 3983| HUKS_ERROR_CHECK_GET_PURPOSE_FAIL | -103 |表示检查获取目的失败。| 3984| HUKS_ERROR_CHECK_GET_DIGEST_FAIL | -104 |表示检查获取摘要失败。| 3985| HUKS_ERROR_CHECK_GET_MODE_FAIL | -105 |表示检查获取模式失败。| 3986| HUKS_ERROR_CHECK_GET_NONCE_FAIL | -106 |表示检查获取随机数失败。| 3987| HUKS_ERROR_CHECK_GET_AAD_FAIL | -107 |表示检查获取 AAD 失败。| 3988| HUKS_ERROR_CHECK_GET_IV_FAIL | -108 |表示检查 GET IV 失败。| 3989| HUKS_ERROR_CHECK_GET_AE_TAG_FAIL | -109 |表示检查获取 AE 标记失败。| 3990| HUKS_ERROR_CHECK_GET_SALT_FAIL | -110 |表示检查获取SALT失败。| 3991| HUKS_ERROR_CHECK_GET_ITERATION_FAIL | -111 |表示检查获取迭代失败。| 3992| HUKS_ERROR_INVALID_ALGORITHM | -112 |表示无效的算法。| 3993| HUKS_ERROR_INVALID_KEY_SIZE | -113 |表示无效的密钥大小。| 3994| HUKS_ERROR_INVALID_PADDING | -114 |表示无效的填充。| 3995| HUKS_ERROR_INVALID_PURPOSE | -115 |表示无效的目的。| 3996| HUKS_ERROR_INVALID_MODE | -116 |表示无效模式。| 3997| HUKS_ERROR_INVALID_DIGEST | -117 |表示无效的摘要。| 3998| HUKS_ERROR_INVALID_SIGNATURE_SIZE | -118 |表示签名大小无效。| 3999| HUKS_ERROR_INVALID_IV | -119 |表示无效的 IV。| 4000| HUKS_ERROR_INVALID_AAD | -120 |表示无效的 AAD。| 4001| HUKS_ERROR_INVALID_NONCE | -121 |表示无效的随机数。| 4002| HUKS_ERROR_INVALID_AE_TAG | -122 |表示无效的 AE 标签。| 4003| HUKS_ERROR_INVALID_SALT | -123 |表示无效SALT。| 4004| HUKS_ERROR_INVALID_ITERATION | -124 |表示无效的迭代。| 4005| HUKS_ERROR_INVALID_OPERATION | -125 |表示无效操作。| 4006| HUKS_ERROR_INTERNAL_ERROR | -999 |表示内部错误。| 4007| HUKS_ERROR_UNKNOWN_ERROR | -1000 |表示未知错误。|