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