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 | 是 | 表示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| 名称 | 类型 | 必填 | 说明 | 64| ---------- | ------------------------------- | ---- | ---------------- | 65| outData | Uint8Array | 否 | 表示输出数据。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 66| properties | Array\<[HuksParam](#huksparam)> | 否 | 表示属性信息。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 | 67| certChains | Array\<string> | 否 | 表示证书链数据。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 68 69## HuksListAliasesReturnResult<sup>12+</sup> 70 71调用接口返回的result。 72 73**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 74 75**系统能力**：SystemCapability.Security.Huks.Extension 76 77 78 79| 名称 | 类型 | 必填 | 说明 | 80| ---------- | ------------------------------- | ---- | ---------------- | 81| keyAliases | Array\<string> | 是 | 表示密钥别名集。 | 82 83 84## huks.generateKeyItem<sup>9+</sup> 85 86generateKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 87 88生成密钥，使用Callback回调异步返回结果。 89 90**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 91 92**系统能力：** SystemCapability.Security.Huks.Core 93 94**参数：** 95 96| 参数名 | 类型 | 必填 | 说明 | 97| -------- | --------------------------- | ---- | --------------------------------------------- | 98| keyAlias | string | 是 | 别名。 | 99| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 100| callback | AsyncCallback\<void> | 是 | 回调函数。未捕获error时代表用户指定别名的密钥生成成功，基于密钥不出TEE原则，此接口不会返回密钥材料内容，若捕获error，则为生成阶段出现异常。 | 101 102**错误码：** 103 104以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 105 106| 错误码ID | 错误信息 | 107| -------- | ------------- | 108| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 109| 801 | api is not supported. | 110| 12000001 | algorithm mode is not supported. | 111| 12000002 | algorithm param is missing. | 112| 12000003 | algorithm param is invalid. | 113| 12000004 | operating file failed. | 114| 12000005 | IPC communication failed. | 115| 12000006 | error occurred in crypto engine. | 116| 12000012 | external error. | 117| 12000013 | queried credential does not exist. | 118| 12000014 | memory is insufficient. | 119| 12000015 | call service failed. | 120 121**示例：** 122 123```ts 124import { huks } from '@kit.UniversalKeystoreKit'; 125/* 以生成ECC256密钥为例 */ 126let keyAlias: string = 'keyAlias'; 127let properties: Array<huks.HuksParam> =[ 128 { 129 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 130 value: huks.HuksKeyAlg.HUKS_ALG_ECC 131 }, 132 { 133 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 134 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 135 }, 136 { 137 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 138 value: 139 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 140 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 141 }, 142 { 143 tag: huks.HuksTag.HUKS_TAG_DIGEST, 144 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 145 }, 146]; 147let options: huks.HuksOptions = { 148 properties: properties 149}; 150try { 151 huks.generateKeyItem(keyAlias, options, (error, data) => { 152 if (error) { 153 console.error(`callback: generateKeyItem failed`); 154 } else { 155 console.info(`callback: generateKeyItem key success`); 156 } 157 }); 158} catch (error) { 159 console.error(`callback: generateKeyItem input arg invalid`); 160} 161``` 162 163## huks.generateKeyItem<sup>9+</sup> 164 165generateKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 166 167生成密钥，使用Promise方式异步返回结果。基于密钥不出TEE原则，通过promise不会返回密钥材料内容，只用于表示此次调用是否成功。 168 169**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 170 171**系统能力：** SystemCapability.Security.Huks.Extension 172 173**参数：** 174 175| 参数名 | 类型 | 必填 | 说明 | 176| -------- | --------------------------- | ---- | ------------------------ | 177| keyAlias | string | 是 | 密钥别名。 | 178| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 179 180**返回值：** 181 182| 类型 | 说明 | 183| ---------------------------------------------- | --------------------------------------------- | 184| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 185 186**错误码：** 187 188以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 189 190| 错误码ID | 错误信息 | 191| -------- | ------------- | 192| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 193| 801 | api is not supported. | 194| 12000001 | algorithm mode is not supported. | 195| 12000002 | algorithm param is missing. | 196| 12000003 | algorithm param is invalid. | 197| 12000004 | operating file failed. | 198| 12000005 | IPC communication failed. | 199| 12000006 | error occurred in crypto engine. | 200| 12000012 | external error. | 201| 12000013 | queried credential does not exist. | 202| 12000014 | memory is insufficient. | 203| 12000015 | call service failed. | 204 205**示例：** 206 207```ts 208/* 以生成ECC256密钥为例 */ 209import { huks } from '@kit.UniversalKeystoreKit'; 210let keyAlias = 'keyAlias'; 211let properties: Array<huks.HuksParam> =[ 212 { 213 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 214 value: huks.HuksKeyAlg.HUKS_ALG_ECC 215 }, 216 { 217 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 218 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 219 }, 220 { 221 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 222 value: 223 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 224 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 225 }, 226 { 227 tag: huks.HuksTag.HUKS_TAG_DIGEST, 228 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 229 }, 230]; 231let options: huks.HuksOptions = { 232 properties: properties 233}; 234try { 235 huks.generateKeyItem(keyAlias, options) 236 .then((data) => { 237 console.info(`promise: generateKeyItem success`); 238 }) 239 .catch((error: Error) => { 240 console.error(`promise: generateKeyItem failed`); 241 }); 242} catch (error) { 243 console.error(`promise: generateKeyItem input arg invalid`); 244} 245``` 246 247## huks.deleteKeyItem<sup>9+</sup> 248 249deleteKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 250 251删除密钥，使用Callback回调异步返回结果。 252 253**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 254 255**系统能力：** SystemCapability.Security.Huks.Core 256 257**参数：** 258 259| 参数名 | 类型 | 必填 | 说明 | 260| -------- | --------------------------- | ---- | --------------------------------------------- | 261| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 262| options | [HuksOptions](#huksoptions) | 是 | 用于删除时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需删除密钥的安全级别，可传空，传空时默认DE。 | 263| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 264 265**错误码：** 266 267以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 268 269| 错误码ID | 错误信息 | 270| -------- | ------------- | 271| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 272| 801 | api is not supported. | 273| 12000004 | operating file failed. | 274| 12000005 | IPC communication failed. | 275| 12000011 | queried entity does not exist. | 276| 12000012 | external error. | 277| 12000014 | memory is insufficient. | 278 279**示例：** 280 281```ts 282import { huks } from '@kit.UniversalKeystoreKit'; 283/* 此处options选择emptyOptions传空 */ 284let keyAlias = 'keyAlias'; 285let emptyOptions: huks.HuksOptions = { 286 properties: [] 287}; 288try { 289 huks.deleteKeyItem(keyAlias, emptyOptions, (error, data) => { 290 if (error) { 291 console.error(`callback: deleteKeyItem failed`); 292 } else { 293 console.info(`callback: deleteKeyItem key success`); 294 } 295 }); 296} catch (error) { 297 console.error(`callback: deleteKeyItem input arg invalid`); 298} 299``` 300 301## huks.deleteKeyItem<sup>9+</sup> 302 303deleteKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 304 305删除密钥，使用Promise方式异步返回结果。 306 307**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 308 309**系统能力：** SystemCapability.Security.Huks.Extension 310 311**参数：** 312 313| 参数名 | 类型 | 必填 | 说明 | 314| -------- | --------------------------- | ---- | ----------------------------------- | 315| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 316| options | [HuksOptions](#huksoptions) | 是 | 用于删除时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需删除密钥的安全级别，可传空，传空时默认DE。 | 317 318**返回值：** 319 320| 类型 | 说明 | 321| ---------------------------------------------- | --------------------------------------------- | 322| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 323 324**错误码：** 325 326以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 327 328| 错误码ID | 错误信息 | 329| -------- | ------------- | 330| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 331| 801 | api is not supported. | 332| 12000004 | operating file failed. | 333| 12000005 | IPC communication failed. | 334| 12000011 | queried entity does not exist. | 335| 12000012 | external error. | 336| 12000014 | memory is insufficient. | 337 338**示例：** 339 340```ts 341import { huks } from '@kit.UniversalKeystoreKit'; 342/* 此处options选择emptyOptions传空 */ 343let keyAlias = 'keyAlias'; 344let emptyOptions: huks.HuksOptions = { 345 properties: [] 346}; 347try { 348 huks.deleteKeyItem(keyAlias, emptyOptions) 349 .then ((data) => { 350 console.info(`promise: deleteKeyItem key success`); 351 }) 352 .catch((error: Error) => { 353 console.error(`promise: deleteKeyItem failed`); 354 }); 355} catch (error) { 356 console.error(`promise: deleteKeyItem input arg invalid`); 357} 358``` 359 360## huks.importKeyItem<sup>9+</sup> 361 362importKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 363 364导入明文密钥，使用Callback方式回调异步返回结果 。 365 366**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 367 368**系统能力：** SystemCapability.Security.Huks.Core 369 370API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 371 372**参数：** 373 374| 参数名 | 类型 | 必填 | 说明 | 375| -------- | --------------------------- | ---- | --------------------------------------------- | 376| keyAlias | string | 是 | 密钥别名。 | 377| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 378| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 379 380**错误码：** 381 382以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 383 384| 错误码ID | 错误信息 | 385| -------- | ------------- | 386| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 387| 801 | api is not supported. | 388| 12000001 | algorithm mode is not supported. | 389| 12000002 | algorithm param is missing. | 390| 12000003 | algorithm param is invalid. | 391| 12000004 | operating file failed. | 392| 12000005 | IPC communication failed. | 393| 12000006 | error occurred in crypto engine. | 394| 12000011 | queried entity does not exist. | 395| 12000012 | external error. | 396| 12000013 | queried credential does not exist. | 397| 12000014 | memory is insufficient. | 398| 12000015 | call service failed. | 399 400**示例：** 401 402```ts 403import { huks } from '@kit.UniversalKeystoreKit'; 404/* 以导入AES256密钥为例 */ 405let plainTextSize32 = makeRandomArr(32); 406function makeRandomArr(size: number) { 407 let arr = new Uint8Array(size); 408 for (let i = 0; i < size; i++) { 409 arr[i] = Math.floor(Math.random() * 10); 410 } 411 return arr; 412}; 413let keyAlias = 'keyAlias'; 414let properties: Array<huks.HuksParam> = [ 415 { 416 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 417 value: huks.HuksKeyAlg.HUKS_ALG_AES 418 }, 419 { 420 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 421 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 422 }, 423 { 424 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 425 value: 426 huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 427 }, 428 { 429 tag: huks.HuksTag.HUKS_TAG_PADDING, 430 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 431 }, 432 { 433 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 434 value: huks.HuksCipherMode.HUKS_MODE_ECB 435 } 436]; 437let options: huks.HuksOptions = { 438 properties: properties, 439 inData: plainTextSize32 440}; 441try { 442 huks.importKeyItem(keyAlias, options, (error, data) => { 443 if (error) { 444 console.error(`callback: importKeyItem failed`); 445 } else { 446 console.info(`callback: importKeyItem success`); 447 } 448 }); 449} catch (error) { 450 console.error(`callback: importKeyItem input arg invalid`); 451} 452``` 453 454## huks.importKeyItem<sup>9+</sup> 455 456importKeyItem(keyAlias: string, options: HuksOptions) : Promise\<void> 457 458导入明文密钥，使用Promise方式异步返回结果。 459 460**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 461 462**系统能力：** SystemCapability.Security.Huks.Extension 463 464**参数：** 465 466| 参数名 | 类型 | 必填 | 说明 | 467| -------- | --------------------------- | ---- | ----------------------------------- | 468| keyAlias | string | 是 | 密钥别名。 | 469| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 470 471**返回值：** 472 473| 类型 | 说明 | 474| ---------------------------------------------- | --------------------------------------------- | 475| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 476 477**错误码：** 478 479以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 480 481| 错误码ID | 错误信息 | 482| -------- | ------------- | 483| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 484| 801 | api is not supported. | 485| 12000001 | algorithm mode is not supported. | 486| 12000002 | algorithm param is missing. | 487| 12000003 | algorithm param is invalid. | 488| 12000004 | operating file failed. | 489| 12000005 | IPC communication failed. | 490| 12000006 | error occurred in crypto engine. | 491| 12000011 | queried entity does not exist. | 492| 12000012 | external error. | 493| 12000013 | queried credential does not exist. | 494| 12000014 | memory is insufficient. | 495| 12000015 | call service failed. | 496 497**示例：** 498 499```ts 500import { huks } from '@kit.UniversalKeystoreKit'; 501/* 以导入AES128为例 */ 502let plainTextSize32 = makeRandomArr(32); 503function makeRandomArr(size: number) { 504 let arr = new Uint8Array(size); 505 for (let i = 0; i < size; i++) { 506 arr[i] = Math.floor(Math.random() * 10); 507 } 508 return arr; 509}; 510/*第一步：生成密钥*/ 511let keyAlias = 'keyAlias'; 512let properties: Array<huks.HuksParam> = [ 513 { 514 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 515 value: huks.HuksKeyAlg.HUKS_ALG_AES 516 }, 517 { 518 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 519 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 520 }, 521 { 522 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 523 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 524 }, 525 { 526 tag: huks.HuksTag.HUKS_TAG_PADDING, 527 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS7 528 }, 529 { 530 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 531 value: huks.HuksCipherMode.HUKS_MODE_ECB 532 } 533]; 534let huksOptions: huks.HuksOptions = { 535 properties: properties, 536 inData: plainTextSize32 537}; 538try { 539 huks.importKeyItem(keyAlias, huksOptions) 540 .then((data) => { 541 console.info(`promise: importKeyItem success`); 542 }) 543 .catch((error: Error) => { 544 console.error(`promise: importKeyItem failed`); 545 }); 546} catch (error) { 547 console.error(`promise: importKeyItem input arg invalid`); 548} 549``` 550 551## huks.attestKeyItem<sup>9+</sup> 552 553attestKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 554 555获取密钥证书，使用Callback方式回调异步返回结果 。 556 557**需要权限**：ohos.permission.ATTEST_KEY，该权限仅系统应用可申请。 558 559**系统能力：** SystemCapability.Security.Huks.Extension 560 561**参数：** 562 563| 参数名 | 类型 | 必填 | 说明 | 564| -------- | ---------------------------------------------------- | ---- | --------------------------------------------- | 565| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 566| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 567| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 568 569**错误码：** 570 571以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 572 573| 错误码ID | 错误信息 | 574| -------- | ------------- | 575| 201 | check permission failed. | 576| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 577| 801 | api is not supported. | 578| 12000001 | algorithm mode is not supported. | 579| 12000002 | algorithm param is missing. | 580| 12000003 | algorithm param is invalid. | 581| 12000004 | operating file failed. | 582| 12000005 | IPC communication failed. | 583| 12000006 | error occurred in crypto engine. | 584| 12000011 | queried entity does not exist. | 585| 12000012 | external error. | 586| 12000014 | memory is insufficient. | 587 588**示例：** 589 590```ts 591import { huks } from '@kit.UniversalKeystoreKit'; 592let securityLevel = stringToUint8Array('sec_level'); 593let challenge = stringToUint8Array('challenge_data'); 594let versionInfo = stringToUint8Array('version_info'); 595let keyAliasString = "key attest"; 596function stringToUint8Array(str: string) { 597 let arr: number[] = []; 598 for (let i = 0, j = str.length; i < j; ++i) { 599 arr.push(str.charCodeAt(i)); 600 } 601 let tmpUint8Array = new Uint8Array(arr); 602 return tmpUint8Array; 603} 604 605async function generateKeyThenattestKey(alias: string) { 606 let aliasString = keyAliasString; 607 let aliasUint8 = stringToUint8Array(aliasString); 608 let generateProperties: Array<huks.HuksParam> = [ 609 { 610 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 611 value: huks.HuksKeyAlg.HUKS_ALG_RSA 612 }, 613 { 614 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 615 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 616 }, 617 { 618 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 619 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 620 }, 621 { 622 tag: huks.HuksTag.HUKS_TAG_DIGEST, 623 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 624 }, 625 { 626 tag: huks.HuksTag.HUKS_TAG_PADDING, 627 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 628 }, 629 { 630 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 631 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 632 }, 633 { 634 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 635 value: huks.HuksCipherMode.HUKS_MODE_ECB 636 } 637 ]; 638 let generateOptions: huks.HuksOptions = { 639 properties: generateProperties 640 }; 641 let attestProperties: Array<huks.HuksParam> = [ 642 { 643 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 644 value: securityLevel 645 }, 646 { 647 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 648 value: challenge 649 }, 650 { 651 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 652 value: versionInfo 653 }, 654 { 655 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 656 value: aliasUint8 657 } 658 ]; 659 let attestOptions: huks.HuksOptions = { 660 properties: attestProperties 661 }; 662 try { 663 huks.generateKeyItem(alias, generateOptions, (error, data) => { 664 if (error) { 665 console.error(`callback: generateKeyItem failed`); 666 } else { 667 console.info(`callback: generateKeyItem success`); 668 try { 669 huks.attestKeyItem(aliasString, attestOptions, (error, data) => { 670 if (error) { 671 console.error(`callback: attestKeyItem failed`); 672 } else { 673 console.info(`callback: attestKeyItem success`); 674 } 675 }); 676 } catch (error) { 677 console.error(`callback: attestKeyItem input arg invalid`); 678 } 679 } 680 }); 681 } catch (error) { 682 console.error(`callback: generateKeyItem input arg invalid`); 683 } 684} 685``` 686 687## huks.attestKeyItem<sup>9+</sup> 688 689attestKeyItem(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 690 691获取密钥证书，使用Promise方式异步返回结果 。 692 693**需要权限**：ohos.permission.ATTEST_KEY，该权限仅系统应用可申请。 694 695**系统能力：** SystemCapability.Security.Huks.Extension 696 697**参数：** 698 699| 参数名 | 类型 | 必填 | 说明 | 700| -------- | --------------------------- | ---- | ------------------------------------ | 701| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 702| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 703 704**返回值：** 705 706| 类型 | 说明 | 707| ---------------------------------------------- | --------------------------------------------- | 708| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的certChains成员非空，为获取到的证书链，否则为失败。 | 709 710**错误码：** 711 712以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 713 714| 错误码ID | 错误信息 | 715| -------- | ------------- | 716| 201 | check permission failed. | 717| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 718| 801 | api is not supported. | 719| 12000001 | algorithm mode is not supported. | 720| 12000002 | algorithm param is missing. | 721| 12000003 | algorithm param is invalid. | 722| 12000004 | operating file failed. | 723| 12000005 | IPC communication failed. | 724| 12000006 | error occurred in crypto engine. | 725| 12000011 | queried entity does not exist. | 726| 12000012 | external error. | 727| 12000014 | memory is insufficient. | 728 729**示例：** 730 731```ts 732import { huks } from '@kit.UniversalKeystoreKit'; 733 734let securityLevel = stringToUint8Array('sec_level'); 735let challenge = stringToUint8Array('challenge_data'); 736let versionInfo = stringToUint8Array('version_info'); 737let keyAliasString = "key attest"; 738function stringToUint8Array(str: string) { 739 let arr: number[] = []; 740 for (let i = 0, j = str.length; i < j; ++i) { 741 arr.push(str.charCodeAt(i)); 742 } 743 let tmpUint8Array = new Uint8Array(arr); 744 return tmpUint8Array; 745} 746async function generateKey(alias: string) { 747 let properties: Array<huks.HuksParam> = [ 748 { 749 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 750 value: huks.HuksKeyAlg.HUKS_ALG_RSA 751 }, 752 { 753 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 754 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 755 }, 756 { 757 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 758 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 759 }, 760 { 761 tag: huks.HuksTag.HUKS_TAG_DIGEST, 762 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 763 }, 764 { 765 tag: huks.HuksTag.HUKS_TAG_PADDING, 766 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 767 }, 768 { 769 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 770 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 771 }, 772 { 773 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 774 value: huks.HuksCipherMode.HUKS_MODE_ECB 775 } 776 ]; 777 let options: huks.HuksOptions = { 778 properties: properties 779 }; 780 try { 781 await huks.generateKeyItem(alias, options) 782 .then((data) => { 783 console.info(`promise: generateKeyItem success`); 784 }) 785 .catch((error: Error) => { 786 console.error(`promise: generateKeyItem failed`); 787 }); 788 } catch (error) { 789 console.error(`promise: generateKeyItem input arg invalid`); 790 } 791} 792async function attestKey() { 793 let aliasString = keyAliasString; 794 let aliasUint8 = stringToUint8Array(aliasString); 795 let properties: Array<huks.HuksParam> = [ 796 { 797 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 798 value: securityLevel 799 }, 800 { 801 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 802 value: challenge 803 }, 804 { 805 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 806 value: versionInfo 807 }, 808 { 809 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 810 value: aliasUint8 811 } 812 ]; 813 let options: huks.HuksOptions = { 814 properties: properties 815 }; 816 await generateKey(aliasString); 817 try { 818 await huks.attestKeyItem(aliasString, options) 819 .then((data) => { 820 console.info(`promise: attestKeyItem success`); 821 }) 822 .catch((error: Error) => { 823 console.error(`promise: attestKeyItem failed`); 824 }); 825 } catch (error) { 826 console.error(`promise: attestKeyItem input arg invalid`); 827 } 828} 829``` 830 831## huks.anonAttestKeyItem<sup>11+</sup> 832 833anonAttestKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 834 835获取匿名化密钥证书，使用Callback方式回调异步返回结果。 836 837该操作需要联网进行，且耗时较长。返回12000012错误码时，可能是由于网络异常导致。此时如果没有联网，需要提示用户网络没有连接，如果已经联网，可能是由于网络抖动导致失败，建议重试。 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**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 977 978**系统能力：** SystemCapability.Security.Huks.Extension 979 980**参数：** 981 982| 参数名 | 类型 | 必填 | 说明 | 983| -------- | --------------------------- | ---- | ------------------------------------ | 984| keyAlias | string | 是 | 密钥别名，存放待获取证书密钥的别名。 | 985| options | [HuksOptions](#huksoptions) | 是 | 用于获取证书时指定所需参数与数据。 | 986 987**返回值：** 988 989| 类型 | 说明 | 990| ---------------------------------------------- | --------------------------------------------- | 991| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的certChains成员非空，为获取到的证书链，否则为失败。 | 992 993**错误码：** 994 995以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 996 997| 错误码ID | 错误信息 | 998| -------- | ------------- | 999| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1000| 801 | api is not supported. | 1001| 12000001 | algorithm mode is not supported. | 1002| 12000002 | algorithm param is missing. | 1003| 12000003 | algorithm param is invalid. | 1004| 12000004 | operating file failed. | 1005| 12000005 | IPC communication failed. | 1006| 12000006 | error occurred in crypto engine. | 1007| 12000011 | queried entity does not exist. | 1008| 12000012 | external error. | 1009| 12000014 | memory is insufficient. | 1010 1011**示例：** 1012 1013```ts 1014import { huks } from '@kit.UniversalKeystoreKit'; 1015 1016let securityLevel = stringToUint8Array('sec_level'); 1017let challenge = stringToUint8Array('challenge_data'); 1018let versionInfo = stringToUint8Array('version_info'); 1019let keyAliasString = "key anon attest"; 1020function stringToUint8Array(str: string): Uint8Array { 1021 let arr: number[] = []; 1022 for (let i = 0, j = str.length; i < j; ++i) { 1023 arr.push(str.charCodeAt(i)); 1024 } 1025 let tmpUint8Array = new Uint8Array(arr); 1026 return tmpUint8Array; 1027} 1028async function generateKey(alias: string): Promise<void> { 1029 let properties: Array<huks.HuksParam> = [ 1030 { 1031 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1032 value: huks.HuksKeyAlg.HUKS_ALG_RSA 1033 }, 1034 { 1035 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1036 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 1037 }, 1038 { 1039 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1040 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 1041 }, 1042 { 1043 tag: huks.HuksTag.HUKS_TAG_DIGEST, 1044 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 1045 }, 1046 { 1047 tag: huks.HuksTag.HUKS_TAG_PADDING, 1048 value: huks.HuksKeyPadding.HUKS_PADDING_PSS 1049 }, 1050 { 1051 tag: huks.HuksTag.HUKS_TAG_KEY_GENERATE_TYPE, 1052 value: huks.HuksKeyGenerateType.HUKS_KEY_GENERATE_TYPE_DEFAULT 1053 }, 1054 { 1055 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 1056 value: huks.HuksCipherMode.HUKS_MODE_ECB 1057 } 1058 ]; 1059 let options: huks.HuksOptions = { 1060 properties: properties 1061 }; 1062 try { 1063 let data = await huks.generateKeyItem(alias, options); 1064 } catch (error) { 1065 console.error(`promise: generateKeyItem failed`); 1066 } 1067} 1068async function anonAttestKey(): Promise<void> { 1069 let aliasString = keyAliasString; 1070 let aliasUint8 = stringToUint8Array(aliasString); 1071 let properties: Array<huks.HuksParam> = [ 1072 { 1073 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO, 1074 value: securityLevel 1075 }, 1076 { 1077 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_CHALLENGE, 1078 value: challenge 1079 }, 1080 { 1081 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_VERSION_INFO, 1082 value: versionInfo 1083 }, 1084 { 1085 tag: huks.HuksTag.HUKS_TAG_ATTESTATION_ID_ALIAS, 1086 value: aliasUint8 1087 } 1088 ]; 1089 let options: huks.HuksOptions = { 1090 properties: properties 1091 }; 1092 await generateKey(aliasString); 1093 try { 1094 let data = await huks.anonAttestKeyItem(aliasString, options); 1095 } catch (error) { 1096 console.error(`promise: anonAttestKeyItem fail`); 1097 } 1098} 1099``` 1100 1101## huks.importWrappedKeyItem<sup>9+</sup> 1102 1103importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions, callback: AsyncCallback\<void>) : void 1104 1105导入加密密钥，使用Callback方式回调异步返回结果 。 1106 1107**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1108 1109**系统能力：** SystemCapability.Security.Huks.Core 1110 1111API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1112 1113**参数：** 1114 1115| 参数名 | 类型 | 必填 | 说明 | 1116| ---------------- | --------------------------- | ---- | --------------------------------------------- | 1117| keyAlias | string | 是 | 密钥别名，存放待导入密钥的别名。 | 1118| wrappingKeyAlias | string | 是 | 密钥别名，对应密钥用于解密加密的密钥数据。 | 1119| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 1120| callback | AsyncCallback\<void> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。 | 1121 1122**错误码：** 1123 1124以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1125 1126| 错误码ID | 错误信息 | 1127| -------- | ------------- | 1128| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1129| 801 | api is not supported. | 1130| 12000001 | algorithm mode is not supported. | 1131| 12000002 | algorithm param is missing. | 1132| 12000003 | algorithm param is invalid. | 1133| 12000004 | operating file failed. | 1134| 12000005 | IPC communication failed. | 1135| 12000006 | error occurred in crypto engine. | 1136| 12000011 | queried entity does not exist. | 1137| 12000012 | external error. | 1138| 12000013 | queried credential does not exist. | 1139| 12000014 | memory is insufficient. | 1140| 12000015 | call service failed. | 1141 1142**示例：** 1143 1144```ts 1145import { huks } from '@kit.UniversalKeystoreKit'; 1146 1147let alias1 = "importAlias"; 1148let alias2 = "wrappingKeyAlias"; 1149async function TestGenFunc(alias: string, options: huks.HuksOptions) { 1150 try { 1151 await genKey(alias, options) 1152 .then((data) => { 1153 console.info(`callback: generateKeyItem success`); 1154 }) 1155 .catch((error: Error) => { 1156 console.error(`callback: generateKeyItem failed`); 1157 }); 1158 } catch (error) { 1159 console.error(`callback: generateKeyItem input arg invalid`); 1160 } 1161} 1162function genKey(alias: string, options: huks.HuksOptions) { 1163 return new Promise<void>((resolve, reject) => { 1164 try { 1165 huks.generateKeyItem(alias, options, (error, data) => { 1166 if (error) { 1167 reject(error); 1168 } else { 1169 resolve(data); 1170 } 1171 }); 1172 } catch (error) { 1173 throw (new Error(error)); 1174 } 1175 }); 1176} 1177async function TestExportFunc(alias: string, options: huks.HuksOptions) { 1178 try { 1179 await exportKey(alias, options) 1180 .then((data) => { 1181 console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`); 1182 }) 1183 .catch((error: Error) => { 1184 console.error(`callback: exportKeyItem failed`); 1185 }); 1186 } catch (error) { 1187 console.error(`callback: exportKeyItem input arg invalid`); 1188 } 1189} 1190function exportKey(alias: string, options: huks.HuksOptions) { 1191 return new Promise<huks.HuksReturnResult>((resolve, reject) => { 1192 try { 1193 huks.exportKeyItem(alias, options, (error, data) => { 1194 if (error) { 1195 reject(error); 1196 } else { 1197 resolve(data); 1198 } 1199 }); 1200 } catch (error) { 1201 throw (new Error(error)); 1202 } 1203 }); 1204} 1205async function TestImportWrappedFunc(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1206 try { 1207 await importWrappedKey(alias, wrappingAlias, options) 1208 .then((data) => { 1209 console.info(`callback: importWrappedKeyItem success`); 1210 }) 1211 .catch((error: Error) => { 1212 console.error(`callback: importWrappedKeyItem failed`); 1213 }); 1214 } catch (error) { 1215 console.error(`callback: importWrappedKeyItem input arg invalid`); 1216 } 1217} 1218function importWrappedKey(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1219 return new Promise<void>((resolve, reject) => { 1220 try { 1221 huks.importWrappedKeyItem(alias, wrappingAlias, options, (error, data) => { 1222 if (error) { 1223 reject(error); 1224 } else { 1225 resolve(data); 1226 } 1227 }); 1228 } catch (error) { 1229 throw (new Error(error)); 1230 } 1231 }); 1232} 1233async function TestImportWrappedKeyFunc( 1234 alias: string, 1235 wrappingAlias: string, 1236 genOptions: huks.HuksOptions, 1237 importOptions: huks.HuksOptions 1238) { 1239 await TestGenFunc(wrappingAlias, genOptions); 1240 await TestExportFunc(wrappingAlias, genOptions); 1241 1242 /* 以下操作不需要调用HUKS接口，此处不给出具体实现。 1243 * 假设待导入的密钥为keyA 1244 * 1.生成ECC公私钥keyB，公钥为keyB_pub, 私钥为keyB_pri 1245 * 2.使用keyB_pri和wrappingAlias密钥中获取的公钥进行密钥协商，协商出共享密钥share_key 1246 * 3.随机生成密钥kek，用于加密keyA，采用AES-GCM加密，加密过程中需要记录：nonce1、aad1、加密后的密文keyA_enc、加密后的tag1。 1247 * 4.使用share_key加密kek，采用AES-GCM加密，加密过程中需要记录：nonce2、aad2、加密后的密文kek_enc、加密后的tag2。 1248 * 5.拼接importOptions.inData字段，满足以下格式: 1249 * keyB_pub的长度（4字节） + keyB_pub的数据 + aad2的长度（4字节） + aad2的数据 + 1250 * nonce2的长度（4字节） + nonce2的数据 + tag2的长度（4字节） + tag2的数据 + 1251 * kek_enc的长度（4字节） + kek_enc的数据 + aad1的长度（4字节） + aad1的数据 + 1252 * nonce1的长度（4字节） + nonce1的数据 + tag1的长度（4字节） + tag1的数据 + 1253 * keyA长度占用的内存长度（4字节） + keyA的长度 + keyA_enc的长度（4字节） + keyA_enc的数据 1254 */ 1255 /* 该处为示例代码，实际运行过程中，应使用实际导入密钥数据。数据构造方式由上注释可见说明 */ 1256 let inputKey = new Uint8Array([0x02, 0x00, 0x00, 0x00]); 1257 importOptions.inData = inputKey; 1258 await TestImportWrappedFunc(alias, wrappingAlias, importOptions); 1259} 1260function makeGenerateOptions() { 1261 let properties: Array<huks.HuksParam> = [ 1262 { 1263 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1264 value: huks.HuksKeyAlg.HUKS_ALG_ECC 1265 }, 1266 { 1267 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1268 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 1269 }, 1270 { 1271 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1272 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_UNWRAP 1273 }, 1274 { 1275 tag: huks.HuksTag.HUKS_TAG_DIGEST, 1276 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 1277 }, 1278 { 1279 tag: huks.HuksTag.HUKS_TAG_IMPORT_KEY_TYPE, 1280 value: huks.HuksImportKeyType.HUKS_KEY_TYPE_KEY_PAIR, 1281 } 1282 ]; 1283 let options: huks.HuksOptions = { 1284 properties: properties 1285 }; 1286 return options; 1287}; 1288function makeImportOptions() { 1289 let properties: Array<huks.HuksParam> = [ 1290 { 1291 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1292 value: huks.HuksKeyAlg.HUKS_ALG_AES 1293 }, 1294 { 1295 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1296 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 1297 }, 1298 { 1299 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1300 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 1301 }, 1302 { 1303 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 1304 value: huks.HuksCipherMode.HUKS_MODE_CBC 1305 }, 1306 { 1307 tag: huks.HuksTag.HUKS_TAG_PADDING, 1308 value: huks.HuksKeyPadding.HUKS_PADDING_NONE 1309 }, 1310 { 1311 tag: huks.HuksTag.HUKS_TAG_UNWRAP_ALGORITHM_SUITE, 1312 value: huks.HuksUnwrapSuite.HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING 1313 } 1314 ]; 1315 let options: huks.HuksOptions = { 1316 properties: properties 1317 }; 1318 return options; 1319}; 1320function huksImportWrappedKey() { 1321 let genOptions = makeGenerateOptions(); 1322 let importOptions = makeImportOptions(); 1323 TestImportWrappedKeyFunc( 1324 alias1, 1325 alias2, 1326 genOptions, 1327 importOptions 1328 ); 1329} 1330``` 1331 1332## huks.importWrappedKeyItem<sup>9+</sup> 1333 1334importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions) : Promise\<void> 1335 1336导入加密密钥，使用Promise方式异步返回结果。 1337 1338**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1339 1340**系统能力：** SystemCapability.Security.Huks.Extension 1341 1342**参数：** 1343 1344| 参数名 | 类型 | 必填 | 说明 | 1345| ---------------- | --------------------------- | ---- | --------------------------------------------- | 1346| keyAlias | string | 是 | 密钥别名，存放待导入密钥的别名。 | 1347| wrappingKeyAlias | string | 是 | 密钥别名，对应密钥用于解密加密的密钥数据。 | 1348| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。 | 1349 1350**返回值：** 1351 1352| 类型 | 说明 | 1353| ---------------------------------------------- | --------------------------------------------- | 1354| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1355 1356**错误码：** 1357 1358以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1359 1360| 错误码ID | 错误信息 | 1361| -------- | ------------- | 1362| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1363| 801 | api is not supported. | 1364| 12000001 | algorithm mode is not supported. | 1365| 12000002 | algorithm param is missing. | 1366| 12000003 | algorithm param is invalid. | 1367| 12000004 | operating file failed. | 1368| 12000005 | IPC communication failed. | 1369| 12000006 | error occurred in crypto engine. | 1370| 12000011 | queried entity does not exist. | 1371| 12000012 | external error. | 1372| 12000013 | queried credential does not exist. | 1373| 12000014 | memory is insufficient. | 1374| 12000015 | call service failed. | 1375 1376**示例：** 1377 1378```ts 1379import { huks } from '@kit.UniversalKeystoreKit'; 1380/* 处理流程与callback类似，主要差异点为如下函数： */ 1381/* 该处为示例代码，实际运行过程中，应使用实际导入密钥数据。数据构造方式由上注释可见说明 */ 1382async function TestImportWrappedFunc(alias: string, wrappingAlias: string, options: huks.HuksOptions) { 1383 try { 1384 await huks.importWrappedKeyItem(alias, wrappingAlias, options) 1385 .then ((data) => { 1386 console.info(`promise: importWrappedKeyItem success`); 1387 }) 1388 .catch((error: Error) => { 1389 console.error(`promise: importWrappedKeyItem failed`); 1390 }); 1391 } catch (error) { 1392 console.error(`promise: importWrappedKeyItem input arg invalid`); 1393 } 1394} 1395``` 1396 1397## huks.exportKeyItem<sup>9+</sup> 1398 1399exportKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1400 1401导出密钥，使用Callback方式回调异步返回的结果。 1402 1403**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1404 1405**系统能力：** SystemCapability.Security.Huks.Core 1406 1407API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1408 1409**参数：** 1410 1411| 参数名 | 类型 | 必填 | 说明 | 1412| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 1413| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1414| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1415| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 1416 1417**错误码：** 1418 1419以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1420 1421| 错误码ID | 错误信息 | 1422| -------- | ------------- | 1423| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1424| 801 | api is not supported. | 1425| 12000001 | algorithm mode is not supported. | 1426| 12000002 | algorithm param is missing. | 1427| 12000003 | algorithm param is invalid. | 1428| 12000004 | operating file failed. | 1429| 12000005 | IPC communication failed. | 1430| 12000006 | error occurred in crypto engine. | 1431| 12000011 | queried entity does not exist. | 1432| 12000012 | external error. | 1433| 12000014 | memory is insufficient. | 1434 1435**示例：** 1436 1437```ts 1438import { huks } from '@kit.UniversalKeystoreKit'; 1439/* 此处options选择emptyOptions来传空 */ 1440let keyAlias = 'keyAlias'; 1441let emptyOptions: huks.HuksOptions = { 1442 properties: [] 1443}; 1444try { 1445 huks.exportKeyItem(keyAlias, emptyOptions, (error, data) => { 1446 if (error) { 1447 console.error(`callback: exportKeyItem failed`); 1448 } else { 1449 console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`); 1450 } 1451 }); 1452} catch (error) { 1453 console.error(`callback: exportKeyItem input arg invalid`); 1454} 1455``` 1456 1457## huks.exportKeyItem<sup>9+</sup> 1458 1459exportKeyItem(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 1460 1461导出密钥，使用Promise方式回调异步返回的结果。 1462 1463**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1464 1465**系统能力：** SystemCapability.Security.Huks.Extension 1466 1467**参数：** 1468 1469| 参数名 | 类型 | 必填 | 说明 | 1470| -------- | --------------------------- | ---- | -------------------------------------------- | 1471| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1472| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1473 1474**返回值：** 1475 1476| 类型 | 说明 | 1477| ---------------------------------------------- | ------------------------------------------------------------ | 1478| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的outData成员非空，为从密钥中导出的公钥。| 1479 1480**错误码：** 1481 1482以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1483 1484| 错误码ID | 错误信息 | 1485| -------- | ------------- | 1486| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1487| 801 | api is not supported. | 1488| 12000001 | algorithm mode is not supported. | 1489| 12000002 | algorithm param is missing. | 1490| 12000003 | algorithm param is invalid. | 1491| 12000004 | operating file failed. | 1492| 12000005 | IPC communication failed. | 1493| 12000006 | error occurred in crypto engine. | 1494| 12000011 | queried entity does not exist. | 1495| 12000012 | external error. | 1496| 12000014 | memory is insufficient. | 1497 1498**示例：** 1499 1500```ts 1501import { huks } from '@kit.UniversalKeystoreKit'; 1502/* 此处options选择emptyOptions来传空 */ 1503let keyAlias = 'keyAlias'; 1504let emptyOptions: huks.HuksOptions = { 1505 properties: [] 1506}; 1507try { 1508 huks.exportKeyItem(keyAlias, emptyOptions) 1509 .then ((data) => { 1510 console.info(`promise: exportKeyItem success, data = ${JSON.stringify(data)}`); 1511 }) 1512 .catch((error: Error) => { 1513 console.error(`promise: exportKeyItem failed`); 1514 }); 1515} catch (error) { 1516 console.error(`promise: exportKeyItem input arg invalid`); 1517} 1518``` 1519 1520## huks.getKeyItemProperties<sup>9+</sup> 1521 1522getKeyItemProperties(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1523 1524获取密钥属性，使用Callback回调异步返回结果。 1525 1526**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1527 1528**系统能力：** SystemCapability.Security.Huks.Core 1529 1530API version 9-11系统能力为SystemCapability.Security.Huks.Extension；从API version 12开始为SystemCapability.Security.Huks.Core 1531 1532**参数：** 1533 1534| 参数名 | 类型 | 必填 | 说明 | 1535| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 1536| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1537| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1538| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。不返回err值时表示接口使用成功，其他时为错误。properties：返回值为生成密钥时所需参数。 | 1539 1540**错误码：** 1541 1542以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1543 1544| 错误码ID | 错误信息 | 1545| -------- | ------------- | 1546| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1547| 801 | api is not supported. | 1548| 12000001 | algorithm mode is not supported. | 1549| 12000002 | algorithm param is missing. | 1550| 12000003 | algorithm param is invalid. | 1551| 12000004 | operating file failed. | 1552| 12000005 | IPC communication failed. | 1553| 12000006 | error occurred in crypto engine. | 1554| 12000011 | queried entity does not exist. | 1555| 12000012 | external error. | 1556| 12000014 | memory is insufficient. | 1557 1558**示例：** 1559 1560```ts 1561import { huks } from '@kit.UniversalKeystoreKit'; 1562/* 此处options选择emptyOptions来传空 */ 1563let keyAlias = 'keyAlias'; 1564let emptyOptions: huks.HuksOptions = { 1565 properties: [] 1566}; 1567try { 1568 huks.getKeyItemProperties(keyAlias, emptyOptions, (error, data) => { 1569 if (error) { 1570 console.error(`callback: getKeyItemProperties failed`); 1571 } else { 1572 console.info(`callback: getKeyItemProperties success, data = ${JSON.stringify(data)}`); 1573 } 1574 }); 1575} catch (error) { 1576 console.error(`callback: getKeyItemProperties input arg invalid`); 1577} 1578``` 1579 1580## huks.getKeyItemProperties<sup>9+</sup> 1581 1582getKeyItemProperties(keyAlias: string, options: HuksOptions) : Promise\<HuksReturnResult> 1583 1584获取密钥属性，使用Promise回调异步返回结果。 1585 1586**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1587 1588**系统能力：** SystemCapability.Security.Huks.Extension 1589 1590**参数：** 1591 1592| 参数名 | 类型 | 必填 | 说明 | 1593| -------- | --------------------------- | ---- | -------------------------------------------- | 1594| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 1595| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 1596 1597**返回值：** 1598 1599| 类型 | 说明 | 1600| ----------------------------------------------- | ------------------------------------------------------------ | 1601| Promise\<[HuksReturnResult](#huksreturnresult9)> | Promise对象。当调用成功时，HuksReturnResult的properties成员非空，为生成密钥时所需参数，否则为失败。| 1602 1603**错误码：** 1604 1605以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1606 1607| 错误码ID | 错误信息 | 1608| -------- | ------------- | 1609| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1610| 801 | api is not supported. | 1611| 12000001 | algorithm mode is not supported. | 1612| 12000002 | algorithm param is missing. | 1613| 12000003 | algorithm param is invalid. | 1614| 12000004 | operating file failed. | 1615| 12000005 | IPC communication failed. | 1616| 12000006 | error occurred in crypto engine. | 1617| 12000011 | queried entity does not exist. | 1618| 12000012 | external error. | 1619| 12000014 | memory is insufficient. | 1620 1621**示例：** 1622 1623```ts 1624import { huks } from '@kit.UniversalKeystoreKit'; 1625/* 此处options选择emptyOptions来传空 */ 1626let keyAlias = 'keyAlias'; 1627let emptyOptions: huks.HuksOptions = { 1628 properties: [] 1629}; 1630try { 1631 huks.getKeyItemProperties(keyAlias, emptyOptions) 1632 .then ((data) => { 1633 console.info(`promise: getKeyItemProperties success, data = ${JSON.stringify(data)}`); 1634 }) 1635 .catch((error: Error) => { 1636 console.error(`promise: getKeyItemProperties failed`); 1637 }); 1638} catch (error) { 1639 console.error(`promise: getKeyItemProperties input arg invalid`); 1640} 1641``` 1642 1643## huks.isKeyItemExist<sup>9+</sup> 1644 1645isKeyItemExist(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<boolean>) : void 1646 1647判断密钥是否存在，使用Callback回调异步返回结果 。 1648 1649**系统能力：** SystemCapability.Security.Huks.Core 1650 1651**参数：** 1652 1653| 参数名 | 类型 | 必填 | 说明 | 1654| -------- | --------------------------- | ---- |--------------------------------------------------------| 1655| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1656| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，可传空，传空时默认DE。 | 1657| callback | AsyncCallback\<boolean> | 是 | 回调函数。若密钥存在，data为true，若密钥不存在，则error中会输出密钥不存在的error code。 | 1658 1659**错误码：** 1660 1661以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1662 1663| 错误码ID | 错误信息 | 1664| -------- | ------------- | 1665| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1666| 801 | api is not supported. | 1667| 12000002 | algorithm param is missing. | 1668| 12000003 | algorithm param is invalid. | 1669| 12000004 | operating file failed. | 1670| 12000005 | IPC communication failed. | 1671| 12000006 | error occurred in crypto engine. | 1672| 12000011 | queried entity does not exist. | 1673| 12000012 | external error. | 1674| 12000014 | memory is insufficient. | 1675 1676**示例：** 1677 1678```ts 1679import { huks } from '@kit.UniversalKeystoreKit'; 1680import { promptAction } from '@kit.ArkUI'; 1681/* 此处options选择emptyOptions来传空 */ 1682let keyAlias = 'keyAlias'; 1683let emptyOptions: huks.HuksOptions = { 1684 properties: [] 1685}; 1686huks.isKeyItemExist(keyAlias, emptyOptions, (error, data) => { 1687 if (data) { 1688 promptAction.showToast({ 1689 message: "keyAlias: " + keyAlias +"is existed！", 1690 duration: 2500, 1691 }) 1692 } else { 1693 promptAction.showToast({ 1694 message: "find key failed", 1695 duration: 2500, 1696 }) 1697 } 1698}); 1699``` 1700 1701## huks.isKeyItemExist<sup>9+</sup> 1702 1703isKeyItemExist(keyAlias: string, options: HuksOptions) : Promise\<boolean> 1704 1705判断密钥是否存在，使用Promise回调异步返回结果 。 1706 1707**系统能力：** SystemCapability.Security.Huks.Extension 1708 1709**参数：** 1710 1711| 参数名 | 类型 | 必填 | 说明 | 1712| -------- | --------------------------- | ---- | ------------------------ | 1713| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1714| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，可传空，传空时默认DE。 | 1715 1716**返回值：** 1717 1718| 类型 | 说明 | 1719| ----------------- | --------------------------------------- | 1720| Promise\<boolean> | Promise对象。密钥存在时，可通过then进行密钥存在后的相关处理，若不存在，可通过error处理密钥不存在后的相关业务操作。 | 1721 1722**错误码：** 1723 1724以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1725 1726| 错误码ID | 错误信息 | 1727| -------- | ------------- | 1728| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1729| 801 | api is not supported. | 1730| 12000002 | algorithm param is missing. | 1731| 12000003 | algorithm param is invalid. | 1732| 12000004 | operating file failed. | 1733| 12000005 | IPC communication failed. | 1734| 12000006 | error occurred in crypto engine. | 1735| 12000011 | queried entity does not exist. | 1736| 12000012 | external error. | 1737| 12000014 | memory is insufficient. | 1738 1739**示例：** 1740 1741```ts 1742import { huks } from '@kit.UniversalKeystoreKit'; 1743import { promptAction } from '@kit.ArkUI'; 1744 1745/* 此处options选择emptyOptions来传空 */ 1746let keyAlias = 'keyAlias'; 1747let emptyOptions: huks.HuksOptions = { 1748 properties: [] 1749}; 1750huks.isKeyItemExist(keyAlias, emptyOptions).then((data) => { 1751 promptAction.showToast({ 1752 message: "keyAlias: " + keyAlias +"is existed！", 1753 duration: 500, 1754 }) 1755}).catch((error: Error)=>{ 1756 promptAction.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'; 1801import { promptAction } from '@kit.ArkUI'; 1802/* 此处options选择emptyOptions来传空 */ 1803let keyAlias = 'keyAlias'; 1804let emptyOptions: huks.HuksOptions = { 1805 properties: [] 1806}; 1807 1808try { 1809 huks.hasKeyItem(keyAlias, emptyOptions, (error, data) => { 1810 if (data) { 1811 promptAction.showToast({ 1812 message: "keyAlias: " + keyAlias +" is existed!", 1813 duration: 2500, 1814 }) 1815 } else { 1816 promptAction.showToast({ 1817 message: "find key failed", 1818 duration: 2500, 1819 }) 1820 } 1821 }); 1822} catch (error) { 1823 console.error(`callback: hasKeyItem input args may be invalid`); 1824} 1825``` 1826 1827## huks.hasKeyItem<sup>11+</sup> 1828 1829hasKeyItem(keyAlias: string, options: HuksOptions) : Promise\<boolean> 1830 1831判断密钥是否存在，使用Promise回调异步返回结果 。 1832 1833**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1834 1835**系统能力：** SystemCapability.Security.Huks.Extension 1836 1837**参数：** 1838 1839| 参数名 | 类型 | 必填 | 说明 | 1840| -------- | --------------------------- | ---- | ------------------------ | 1841| keyAlias | string | 是 | 所需查找的密钥的别名。 | 1842| options | [HuksOptions](#huksoptions) | 是 | 用于查询时指定密钥的属性TAG，如使用[HuksAuthStorageLevel](#huksauthstoragelevel11)指定需查询密钥的安全级别，可传空，传空时默认DE。 | 1843 1844**返回值：** 1845 1846| 类型 | 说明 | 1847| ----------------- | --------------------------------------- | 1848| Promise\<boolean> | Promise对象。若密钥存在，返回值为true，若密钥不存在，返回值为false。 | 1849 1850**错误码：** 1851 1852以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1853 1854| 错误码ID | 错误信息 | 1855| -------- | ------------- | 1856| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1857| 801 | api is not supported. | 1858| 12000002 | algorithm param is missing. | 1859| 12000003 | algorithm param is invalid. | 1860| 12000004 | operating file failed. | 1861| 12000005 | IPC communication failed. | 1862| 12000006 | error occurred in crypto engine. | 1863| 12000012 | external error. | 1864| 12000014 | memory is insufficient. | 1865 1866**示例：** 1867 1868```ts 1869import { huks } from '@kit.UniversalKeystoreKit'; 1870import { promptAction } from '@kit.ArkUI'; 1871 1872/* 此处options选择emptyOptions来传空 */ 1873let keyAlias = 'keyAlias'; 1874let emptyOptions: huks.HuksOptions = { 1875 properties: [] 1876}; 1877huks.hasKeyItem(keyAlias, emptyOptions).then((data) => { 1878 if (data) { 1879 promptAction.showToast({ 1880 message: "keyAlias: " + keyAlias +" is existed!", 1881 duration: 2500, 1882 }) 1883 } else { 1884 promptAction.showToast({ 1885 message: "find key failed", 1886 duration: 2500, 1887 }) 1888 } 1889}).catch((error: Error)=>{ 1890 promptAction.showToast({ 1891 message: "find key failed", 1892 duration: 6500, 1893 }) 1894}) 1895``` 1896 1897## huks.initSession<sup>9+</sup> 1898 1899initSession(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksSessionHandle>) : void 1900 1901initSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1902 1903**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1904 1905**系统能力：** SystemCapability.Security.Huks.Core 1906 1907**参数：** 1908 1909| 参数名 | 类型 | 必填 | 说明 | 1910| -------- | ------------------------------------------------------- | ---- | ---------------------------------------------------- | 1911| keyAlias | string | 是 | initSession操作密钥的别名。 | 1912| options | [HuksOptions](#huksoptions) | 是 | initSession操作的参数集合。 | 1913| callback | AsyncCallback\<[HuksSessionHandle](#hukssessionhandle9)> | 是 | 回调函数。将initSession操作返回的handle添加到密钥管理系统的回调。 | 1914 1915**错误码：** 1916 1917以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1918 1919| 错误码ID | 错误信息 | 1920| -------- | ------------- | 1921| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1922| 801 | api is not supported. | 1923| 12000001 | algorithm mode is not supported. | 1924| 12000002 | algorithm param is missing. | 1925| 12000003 | algorithm param is invalid. | 1926| 12000004 | operating file failed. | 1927| 12000005 | IPC communication failed. | 1928| 12000006 | error occurred in crypto engine. | 1929| 12000010 | the number of sessions has reached limit. | 1930| 12000011 | queried entity does not exist. | 1931| 12000012 | external error. | 1932| 12000014 | memory is insufficient. | 1933 1934## huks.initSession<sup>9+</sup> 1935 1936initSession(keyAlias: string, options: HuksOptions) : Promise\<HuksSessionHandle> 1937 1938initSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1939 1940**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1941 1942**系统能力：** SystemCapability.Security.Huks.Extension 1943 1944**参数：** 1945 1946| 参数名 | 类型 | 必填 | 说明 | 1947| -------- | ------------------------------------------------- | ---- | ------------------------------------------------ | 1948| keyAlias | string | 是 | initSession操作密钥的别名。 | 1949| options | [HuksOptions](#huksoptions) | 是 | initSession参数集合。 | 1950 1951**返回值**： 1952 1953| 类型 | 说明 | 1954| ----------------------------------- | -------------------------------------------------- | 1955| Promise\<[HuksSessionHandle](#hukssessionhandle9)> | Promise对象。将initSession操作返回的handle添加到密钥管理系统的回调。 | 1956 1957**错误码：** 1958 1959以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1960 1961| 错误码ID | 错误信息 | 1962| -------- | ------------- | 1963| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 1964| 801 | api is not supported. | 1965| 12000001 | algorithm mode is not supported. | 1966| 12000002 | algorithm param is missing. | 1967| 12000003 | algorithm param is invalid. | 1968| 12000004 | operating file failed. | 1969| 12000005 | IPC communication failed. | 1970| 12000006 | error occurred in crypto engine. | 1971| 12000010 | the number of sessions has reached limit. | 1972| 12000011 | queried entity does not exist. | 1973| 12000012 | external error. | 1974| 12000014 | memory is insufficient. | 1975 1976## huks.updateSession<sup>9+</sup> 1977 1978updateSession(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 1979 1980updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1981 1982**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 1983 1984**系统能力：** SystemCapability.Security.Huks.Core 1985 1986**参数：** 1987 1988| 参数名 | 类型 | 必填 | 说明 | 1989| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 1990| handle | number | 是 | updateSession操作的handle。 | 1991| options | [HuksOptions](#huksoptions) | 是 | updateSession的参数集合。 | 1992| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将updateSession操作的结果添加到密钥管理系统的回调。 | 1993 1994**错误码：** 1995 1996以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 1997 1998| 错误码ID | 错误信息 | 1999| -------- | ------------- | 2000| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2001| 801 | api is not supported. | 2002| 12000001 | algorithm mode is not supported. | 2003| 12000002 | algorithm param is missing. | 2004| 12000003 | algorithm param is invalid. | 2005| 12000004 | operating file failed. | 2006| 12000005 | IPC communication failed. | 2007| 12000006 | error occurred in crypto engine. | 2008| 12000007 | this credential is already invalidated permanently. | 2009| 12000008 | verify auth token failed. | 2010| 12000009 | auth token is already timeout. | 2011| 12000011 | queried entity does not exist. | 2012| 12000012 | external error. | 2013| 12000014 | memory is insufficient. | 2014 2015## huks.updateSession<sup>9+</sup> 2016 2017updateSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback\<HuksReturnResult>) : void 2018 2019updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2020 2021**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2022 2023**系统能力：** SystemCapability.Security.Huks.Extension 2024 2025**参数：** 2026 2027| 参数名 | 类型 | 必填 | 说明 | 2028| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 2029| handle | number | 是 | updateSession操作的handle。 | 2030| options | [HuksOptions](#huksoptions) | 是 | updateSession操作的参数集合。 | 2031| token | Uint8Array | 是 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md)的用户鉴权证明(AuthToken)。 | 2032| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将updateSession操作的结果添加到密钥管理系统的回调。 | 2033 2034**错误码：** 2035 2036以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2037 2038| 错误码ID | 错误信息 | 2039| -------- | ------------- | 2040| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2041| 801 | api is not supported. | 2042| 12000001 | algorithm mode is not supported. | 2043| 12000002 | algorithm param is missing. | 2044| 12000003 | algorithm param is invalid. | 2045| 12000004 | operating file failed. | 2046| 12000005 | IPC communication failed. | 2047| 12000006 | error occurred in crypto engine. | 2048| 12000007 | this credential is already invalidated permanently. | 2049| 12000008 | verify auth token failed. | 2050| 12000009 | auth token is already timeout. | 2051| 12000011 | queried entity does not exist. | 2052| 12000012 | external error. | 2053| 12000014 | memory is insufficient. | 2054 2055## huks.updateSession<sup>9+</sup> 2056 2057updateSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise\<HuksReturnResult> 2058 2059updateSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2060 2061**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2062 2063**系统能力：** SystemCapability.Security.Huks.Extension 2064 2065**参数：** 2066 2067| 参数名 | 类型 | 必填 | 说明 | 2068| ------- | ---------------------------------------------- | ---- | -------------------------------------------- | 2069| handle | number | 是 | updateSession操作的handle。 | 2070| options | [HuksOptions](#huksoptions) | 是 | updateSession操作的参数集合。 | 2071| token | Uint8Array | 否 |密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md)的用户鉴权证明(AuthToken)，不填表示不进行二次认证密钥访问控制。 | 2072 2073**返回值**： 2074 2075| 类型 | 说明 | 2076| ----------------------------------- | -------------------------------------------------- | 2077| Promise<[HuksReturnResult](#huksreturnresult9)> | Promise对象。将updateSession操作的结果添加到密钥管理系统的回调。 | 2078 2079**错误码：** 2080 2081以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2082 2083| 错误码ID | 错误信息 | 2084| -------- | ------------- | 2085| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2086| 801 | api is not supported. | 2087| 12000001 | algorithm mode is not supported. | 2088| 12000002 | algorithm param is missing. | 2089| 12000003 | algorithm param is invalid. | 2090| 12000004 | operating file failed. | 2091| 12000005 | IPC communication failed. | 2092| 12000006 | error occurred in crypto engine. | 2093| 12000007 | this credential is already invalidated permanently. | 2094| 12000008 | verify auth token failed. | 2095| 12000009 | auth token is already timeout. | 2096| 12000011 | queried entity does not exist. | 2097| 12000012 | external error. | 2098| 12000014 | memory is insufficient. | 2099 2100## huks.finishSession<sup>9+</sup> 2101 2102finishSession(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksReturnResult>) : void 2103 2104finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2105 2106**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2107 2108**系统能力：** SystemCapability.Security.Huks.Core 2109 2110**参数：** 2111 2112| 参数名 | 类型 | 必填 | 说明 | 2113| -------- | ---------------------------------------------------- | ---- | -------------------------------------------- | 2114| handle | number | 是 | finishSession操作的handle。 | 2115| options | [HuksOptions](#huksoptions) | 是 | finishSession的参数集合。 | 2116| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到密钥管理系统的回调。 | 2117 2118**错误码：** 2119 2120以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2121 2122| 错误码ID | 错误信息 | 2123| -------- | ------------- | 2124| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2125| 801 | api is not supported. | 2126| 12000001 | algorithm mode is not supported. | 2127| 12000002 | algorithm param is missing. | 2128| 12000003 | algorithm param is invalid. | 2129| 12000004 | operating file failed. | 2130| 12000005 | IPC communication failed. | 2131| 12000006 | error occurred in crypto engine. | 2132| 12000007 | this credential is already invalidated permanently. | 2133| 12000008 | verify auth token failed. | 2134| 12000009 | auth token is already timeout. | 2135| 12000011 | queried entity does not exist. | 2136| 12000012 | external error. | 2137| 12000014 | memory is insufficient. | 2138 2139## huks.finishSession<sup>9+</sup> 2140 2141finishSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback\<HuksReturnResult>) : void 2142 2143finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2144 2145**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2146 2147**系统能力：** SystemCapability.Security.Huks.Extension 2148 2149**参数：** 2150 2151| 参数名 | 类型 | 必填 | 说明 | 2152| -------- | ----------------------------------------------------- | ---- | -------------------------------------------- | 2153| handle | number | 是 | finishSession操作的handle。 | 2154| options | [HuksOptions](#huksoptions) | 是 | finishSession的参数集合。 | 2155| token | Uint8Array | 是 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md)的用户鉴权证明(AuthToken)。 | 2156| callback | AsyncCallback\<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到密钥管理系统的回调。 | 2157 2158**错误码：** 2159 2160以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2161 2162| 错误码ID | 错误信息 | 2163| -------- | ------------- | 2164| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2165| 801 | api is not supported. | 2166| 12000001 | algorithm mode is not supported. | 2167| 12000002 | algorithm param is missing. | 2168| 12000003 | algorithm param is invalid. | 2169| 12000004 | operating file failed. | 2170| 12000005 | IPC communication failed. | 2171| 12000006 | error occurred in crypto engine. | 2172| 12000007 | this credential is already invalidated permanently. | 2173| 12000008 | verify auth token failed. | 2174| 12000009 | auth token is already timeout. | 2175| 12000011 | queried entity does not exist. | 2176| 12000012 | external error. | 2177| 12000014 | memory is insufficient. | 2178 2179## huks.finishSession<sup>9+</sup> 2180 2181finishSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise\<HuksReturnResult> 2182 2183finishSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 2184 2185**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2186 2187**系统能力：** SystemCapability.Security.Huks.Extension 2188 2189**参数：** 2190 2191| 参数名 | 类型 | 必填 | 说明 | 2192| ------- | ----------------------------------------------- | ---- | ----------------------------------- | 2193| handle | number | 是 | finishSession操作的handle。 | 2194| options | [HuksOptions](#huksoptions) | 是 | finishSession操作的参数集合。 | 2195| token | Uint8Array | 否 | 密钥[二次认证密钥访问控制](../../security/UniversalKeystoreKit/huks-identity-authentication-overview.md)的用户鉴权证明(AuthToken)，不填表示不进行二次认证密钥访问控制。 | 2196 2197**返回值**： 2198 2199| 类型 | 说明 | 2200| ----------------------------------- | -------------------------------------------------- | 2201| Promise\<[HuksReturnResult](#huksreturnresult9)> | Promise对象，用于获取异步返回结果。 | 2202 2203**错误码：** 2204 2205以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2206 2207| 错误码ID | 错误信息 | 2208| -------- | ------------- | 2209| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2210| 801 | api is not supported. | 2211| 12000001 | algorithm mode is not supported. | 2212| 12000002 | algorithm param is missing. | 2213| 12000003 | algorithm param is invalid. | 2214| 12000004 | operating file failed. | 2215| 12000005 | IPC communication failed. | 2216| 12000006 | error occurred in crypto engine. | 2217| 12000007 | this credential is already invalidated permanently. | 2218| 12000008 | verify auth token failed. | 2219| 12000009 | auth token is already timeout. | 2220| 12000011 | queried entity does not exist. | 2221| 12000012 | external error. | 2222| 12000014 | memory is insufficient. | 2223 2224## huks.abortSession<sup>9+</sup> 2225 2226abortSession(handle: number, options: HuksOptions, callback: AsyncCallback\<void>) : void 2227 2228abortSession操作密钥接口，使用Callback回调异步返回结果 。 2229 2230**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2231 2232**系统能力：** SystemCapability.Security.Huks.Core 2233 2234**参数：** 2235 2236| 参数名 | 类型 | 必填 | 说明 | 2237| -------- | --------------------------- | ---- | ------------------------------------------- | 2238| handle | number | 是 | abortSession操作的handle。 | 2239| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 2240| callback | AsyncCallback\<void> | 是 | 回调函数。将abortSession操作的结果添加到密钥管理系统的回调。 | 2241 2242**错误码：** 2243 2244以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2245 2246| 错误码ID | 错误信息 | 2247| -------- | ------------- | 2248| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2249| 801 | api is not supported. | 2250| 12000004 | operating file failed. | 2251| 12000005 | IPC communication failed. | 2252| 12000006 | error occurred in crypto engine. | 2253| 12000012 | external error. | 2254| 12000014 | memory is insufficient. | 2255 2256**示例：** 2257 2258```ts 2259import { huks } from '@kit.UniversalKeystoreKit'; 2260/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 2261 * huks.initSession和huks.updateSession 2262 * 以及huks.finishSession操作中的任一阶段发生错误时， 2263 * 都需要调用huks.abortSession来终止密钥的使用。 2264 * 2265 * 以下以RSA2048密钥的callback功能使用为例 2266 */ 2267 2268let keyAlias = "HuksDemoRSA"; 2269let properties: Array<huks.HuksParam> = [] 2270let options: huks.HuksOptions = { 2271 properties: properties, 2272 inData: new Uint8Array(0) 2273}; 2274let handle: number = 0; 2275async function huksAbort() { 2276 properties[0] = { 2277 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2278 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2279 }; 2280 properties[1] = { 2281 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2282 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 2283 }; 2284 properties[2] = { 2285 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2286 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2287 }; 2288 properties[3] = { 2289 tag: huks.HuksTag.HUKS_TAG_PADDING, 2290 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 2291 }; 2292 properties[4] = { 2293 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2294 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2295 }; 2296 properties[5] = { 2297 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2298 value: huks.HuksCipherMode.HUKS_MODE_ECB, 2299 } 2300 try { 2301 huks.generateKeyItem(keyAlias, options, (error, data) => { 2302 if (error) { 2303 console.error(`callback: generateKeyItem failed`); 2304 } else { 2305 console.info(`callback: generateKeyItem success`); 2306 huks.initSession(keyAlias, options, (error, data) => { // 以initSession阶段进行abortSession为例 2307 if (error) { 2308 console.error(`callback: initSession failed`); 2309 } else { 2310 console.info(`callback: initSession success, data = ${JSON.stringify(data)}`); 2311 handle = data.handle; 2312 huks.abortSession(handle, options, (error, data) => { 2313 if (error) { 2314 console.error(`callback: abortSession failed`); 2315 } else { 2316 console.info(`callback: abortSession success`); 2317 } 2318 }); 2319 } 2320 }); 2321 } 2322 }); 2323 } catch (error) { 2324 console.error(`callback: huksAbort failed`); 2325 } 2326} 2327``` 2328 2329## huks.abortSession<sup>9+</sup> 2330 2331abortSession(handle: number, options: HuksOptions) : Promise\<void>; 2332 2333abortSession操作密钥接口，使用Promise方式异步返回结果。 2334 2335**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。 2336 2337**系统能力：** SystemCapability.Security.Huks.Extension 2338 2339**参数：** 2340 2341| 参数名 | 类型 | 必填 | 说明 | 2342| ------- | --------------------------- | ---- | ------------------------------------------- | 2343| handle | number | 是 | abortSession操作的handle。 | 2344| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 2345 2346**返回值**： 2347 2348| 类型 | 说明 | 2349| ----------------------------------- | -------------------------------------------------- | 2350| Promise\<void> | Promise对象。将abortSession操作的结果添加到密钥管理系统的回调。 | 2351 2352**错误码：** 2353 2354以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2355 2356| 错误码ID | 错误信息 | 2357| -------- | ------------- | 2358| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2359| 801 | api is not supported. | 2360| 12000004 | operating file failed. | 2361| 12000005 | IPC communication failed. | 2362| 12000006 | error occurred in crypto engine. | 2363| 12000012 | external error. | 2364| 12000014 | memory is insufficient. | 2365 2366**示例：** 2367 2368```ts 2369import { huks } from '@kit.UniversalKeystoreKit'; 2370/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 2371 * huks.initSession和huks.updateSession 2372 * 以及huks.finishSession操作中的任一阶段发生错误时， 2373 * 都需要调用huks.abortSession来终止密钥的使用。 2374 * 2375 * 以下以RSA2048密钥的promise功能使用为例 2376 */ 2377 2378function stringToUint8Array(str: string) { 2379 let arr: number[] = []; 2380 for (let i = 0, j = str.length; i < j; ++i) { 2381 arr.push(str.charCodeAt(i)); 2382 } 2383 let tmpUint8Array = new Uint8Array(arr); 2384 return tmpUint8Array; 2385} 2386 2387let keyAlias = "HuksDemoRSA"; 2388let properties: Array<huks.HuksParam> = [] 2389let options: huks.HuksOptions = { 2390 properties: properties, 2391 inData: new Uint8Array(0) 2392}; 2393let handle: number = 0; 2394 2395async function generateKey() { 2396 properties[0] = { 2397 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2398 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2399 }; 2400 properties[1] = { 2401 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2402 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048 2403 }; 2404 properties[2] = { 2405 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2406 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2407 }; 2408 properties[3] = { 2409 tag: huks.HuksTag.HUKS_TAG_PADDING, 2410 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 2411 }; 2412 properties[4] = { 2413 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2414 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2415 }; 2416 properties[5] = { 2417 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2418 value: huks.HuksCipherMode.HUKS_MODE_ECB, 2419 } 2420 2421 try { 2422 await huks.generateKeyItem(keyAlias, options) 2423 .then((data) => { 2424 console.info(`promise: generateKeyItem success`); 2425 }) 2426 .catch((error: Error) => { 2427 console.error(`promise: generateKeyItem failed`); 2428 }); 2429 } catch (error) { 2430 console.error(`promise: generateKeyItem input arg invalid`); 2431 } 2432} 2433 2434async function huksInit() { 2435 console.info('enter huksInit'); 2436 try { 2437 await huks.initSession(keyAlias, options) 2438 .then((data) => { 2439 console.info(`promise: initSession success, data = ${JSON.stringify(data)}`); 2440 handle = data.handle; 2441 }) 2442 .catch((error: Error) => { 2443 console.error(`promise: initSession key failed`); 2444 }); 2445 } catch (error) { 2446 console.error(`promise: initSession input arg invalid`); 2447 } 2448} 2449 2450async function huksUpdate() { 2451 console.info('enter huksUpdate'); 2452 options.inData = stringToUint8Array("huksHmacTest"); 2453 try { 2454 await huks.updateSession(handle, options) 2455 .then((data) => { 2456 console.info(`promise: updateSession success, data = ${JSON.stringify(data)}`); 2457 }) 2458 .catch((error: Error) => { 2459 console.error(`promise: updateSession failed`); 2460 }); 2461 } catch (error) { 2462 console.error(`promise: updateSession input arg invalid`); 2463 } 2464} 2465 2466async function huksFinish() { 2467 console.info('enter huksFinish'); 2468 options.inData = new Uint8Array(0); 2469 try { 2470 await huks.finishSession(handle, options) 2471 .then((data) => { 2472 console.info(`promise: finishSession success, data = ${JSON.stringify(data)}`); 2473 }) 2474 .catch((error: Error) => { 2475 console.error(`promise: finishSession failed`); 2476 }); 2477 } catch (error) { 2478 console.error(`promise: finishSession input arg invalid`); 2479 } 2480} 2481 2482async function huksAbort() { 2483 console.info('enter huksAbort'); 2484 try { 2485 await huks.abortSession(handle, options) 2486 .then((data) => { 2487 console.info(`promise: abortSession success`); 2488 }) 2489 .catch((error: Error) => { 2490 console.error(`promise: abortSession failed`); 2491 }); 2492 } catch (error) { 2493 console.error(`promise: abortSession input arg invalid`); 2494 } 2495} 2496 2497async function testAbort() { 2498 await generateKey(); 2499 await huksInit(); // 以initSession阶段进行abortSession为例 2500 await huksAbort(); 2501} 2502``` 2503 2504## huks.listAliases<sup>12+</sup> 2505 2506listAliases(options: HuksOptions): Promise\<HuksListAliasesReturnResult>; 2507 2508查询密钥别名集接口，使用Promise方式异步返回结果。 2509 2510**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2511 2512**系统能力**：SystemCapability.Security.Huks.Extension 2513 2514**参数：** 2515 2516| 参数名 | 类型 | 必填 | 说明 | 2517| ------- | --------------------------- | ---- | ------------------------------------------- | 2518| options | [HuksOptions](#huksoptions) | 是 | listAliases操作的参数集合。 | 2519 2520 2521**返回值**： 2522 2523| 类型 | 说明 | 2524| ----------------------------------- | -------------------------------------------------- | 2525| Promise<[HuksListAliasesReturnResult](#hukslistaliasesreturnresult12)> | Promise对象。将listAliases操作的结果添加到密钥管理系统的回调。 | 2526 2527**错误码：** 2528 2529以下错误码的详细介绍请参见[HUKS错误码](errorcode-huks.md)。 2530 2531| 错误码ID | 错误信息 | 2532| -------- | ------------- | 2533| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3. Parameter verification failed. | 2534| 12000004 | operating file failed. | 2535| 12000005 | IPC communication failed. | 2536| 12000012 | external error. | 2537| 12000014 | memory is insufficient. | 2538 2539**示例：** 2540 2541```ts 2542import { huks } from '@kit.UniversalKeystoreKit' 2543 2544async function testListAliases() { 2545 let queryProperties: Array<huks.HuksParam> = [ 2546 { 2547 tag: huks.HuksTag.HUKS_TAG_AUTH_STORAGE_LEVEL, 2548 value: huks.HuksAuthStorageLevel.HUKS_AUTH_STORAGE_LEVEL_DE 2549 } 2550 ]; 2551 let queryOptions: huks.HuksOptions = { 2552 properties: queryProperties 2553 }; 2554 2555 try { 2556 let result: huks.HuksListAliasesReturnResult = await huks.listAliases(queryOptions); 2557 console.info(`promise: listAliases success`); 2558 } catch (error) { 2559 console.error(`promise: listAliases fail , code: ` + error.code + `, msg: ` + error.message); 2560 } 2561} 2562 2563``` 2564 2565 2566## HuksExceptionErrCode<sup>9+</sup> 2567 2568表示错误码的枚举以及对应的错误信息， 错误码表示错误类型，错误信息展示错误详情。 2569 2570关于错误码的具体信息，可在[错误码参考文档](errorcode-huks.md)中查看。 2571 2572**系统能力：** SystemCapability.Security.Huks.Core 2573 2574| 名称 | 值 | 说明 | 2575| ---------------------------------------------- | -------- |--------------------------- | 2576| HUKS_ERR_CODE_PERMISSION_FAIL | 201 | 权限错误导致失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2577| HUKS_ERR_CODE_NOT_SYSTEM_APP<sup>12+</sup> | 202 | 非系统应用不可以调用系统API。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2578| HUKS_ERR_CODE_ILLEGAL_ARGUMENT | 401 | 参数错误导致失败。可能原因：1. 必选参数未指定。2. 参数类型不正确。3. 参数校验失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2579| HUKS_ERR_CODE_NOT_SUPPORTED_API | 801 | 不支持的API。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2580| HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED | 12000001 | 不支持的功能/特性。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2581| HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT | 12000002 | 缺少密钥算法参数。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2582| HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT | 12000003 | 无效密钥算法参数。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2583| HUKS_ERR_CODE_FILE_OPERATION_FAIL | 12000004 | 文件操作失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2584| HUKS_ERR_CODE_COMMUNICATION_FAIL | 12000005 | 通信失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2585| HUKS_ERR_CODE_CRYPTO_FAIL | 12000006 | 算法库操作失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2586| HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED | 12000007 | 密钥访问失败-密钥访问失效。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2587| HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED | 12000008 | 密钥访问失败-密钥认证失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2588| HUKS_ERR_CODE_KEY_AUTH_TIME_OUT | 12000009 | 密钥访问失败-密钥访问超时。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2589| HUKS_ERR_CODE_SESSION_LIMIT | 12000010 | 密钥操作会话数已达上限。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2590| HUKS_ERR_CODE_ITEM_NOT_EXIST | 12000011 | 目标对象不存在。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2591| HUKS_ERR_CODE_EXTERNAL_ERROR | 12000012 | 外部错误。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2592| HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST | 12000013 | 缺失所需凭据。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2593| HUKS_ERR_CODE_INSUFFICIENT_MEMORY | 12000014 | 内存不足。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2594| HUKS_ERR_CODE_CALL_SERVICE_FAILED | 12000015 | 调用其他系统服务失败。<br>**原子化服务API：** 从API version 11开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Core | 2595| HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET<sup>11+</sup> | 12000016 | 需要锁屏密码但未设置。<br>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。<br> **系统能力：** SystemCapability.Security.Huks.Extension | 2596 2597## HuksKeyPurpose 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 <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<sup>10+</sup> | 0 | 表示以摘要长度设置salt_len。 | 2830| HUKS_RSA_PSS_SALT_LEN_MAX<sup>10+</sup> | 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 | 是 | 别名。 | 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 | 是 | 密钥别名。 | 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 | 是 | 密钥别名。 | 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操作的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操作的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操作的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操作的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操作的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操作的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 | 是 | 表示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 |表示未知错误。|