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