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