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