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| callback | AsyncCallback<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到密钥管理系统的回调。 | 1260 1261## huks.finishSession<sup>9+</sup> 1262 1263finishSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback\<HuksReturnResult>) : void 1264 1265finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1266 1267**系统能力**：SystemCapability.Security.Huks 1268 1269**参数：** 1270 1271| 参数名 | 类型 | 必填 | 说明 | 1272| -------- | ----------------------------------------------------- | ---- | -------------------------------------------- | 1273| handle | number | 是 | finishSession操作的handle。 | 1274| options | [HuksOptions](#huksoptions) | 是 | finishSession的参数集合。 | 1275| token | Uint8Array | 是 | finishSession操作的token。 | 1276| callback | AsyncCallback\<[HuksReturnResult](#huksreturnresult9)> | 是 | 回调函数。将finishSession操作的结果添加到密钥管理系统的回调。 | 1277 1278## huks.finishSession<sup>9+</sup> 1279 1280finishSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise\<HuksReturnResult> 1281 1282finishSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。 1283 1284**系统能力**：SystemCapability.Security.Huks 1285 1286**参数：** 1287 1288| 参数名 | 类型 | 必填 | 说明 | 1289| ------- | ----------------------------------------------- | ---- | ----------------------------------- | 1290| handle | number | 是 | finishSession操作的handle。 | 1291| options | [HuksOptions](#huksoptions) | 是 | finishSession操作的参数集合。 | 1292| token | Uint8Array | 否 | finishSession操作的token。 | 1293 1294**返回值**： 1295 1296| 类型 | 说明 | 1297| ----------------------------------- | -------------------------------------------------- | 1298| Promise\<[HuksReturnResult](#huksreturnresult9)> | Promise对象，用于获取异步返回结果。 | 1299 1300## huks.abortSession<sup>9+</sup> 1301 1302abortSession(handle: number, options: HuksOptions, callback: AsyncCallback\<void>) : void 1303 1304abortSession操作密钥接口，使用Callback回调异步返回结果 。 1305 1306**系统能力**：SystemCapability.Security.Huks 1307 1308**参数：** 1309 1310| 参数名 | 类型 | 必填 | 说明 | 1311| -------- | --------------------------- | ---- | ------------------------------------------- | 1312| handle | number | 是 | abortSession操作的handle。 | 1313| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 1314| callback | AsyncCallback\<void> | 是 | 回调函数。将abortSession操作的结果添加到密钥管理系统的回调。 | 1315 1316**示例：** 1317 1318```js 1319/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 1320 * huks.initSession和huks.updateSession 1321 * 以及huks.finishSession操作中的任一阶段发生错误时， 1322 * 都需要调用huks.abortSession来终止密钥的使用。 1323 * 1324 * 以下以RSA1024密钥的callback功能使用为例 1325 */ 1326function stringToUint8Array(str) { 1327 let arr = []; 1328 for (let i = 0, j = str.length; i < j; ++i) { 1329 arr.push(str.charCodeAt(i)); 1330 } 1331 let tmpUint8Array = new Uint8Array(arr); 1332 return tmpUint8Array; 1333} 1334 1335let keyAlias = "HuksDemoRSA"; 1336let properties = new Array(); 1337let options = { 1338 properties: properties, 1339 inData: new Uint8Array(0) 1340}; 1341let handle; 1342async function generateKey() { 1343 properties[0] = { 1344 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1345 value: huks.HuksKeyAlg.HUKS_ALG_RSA 1346 }; 1347 properties[1] = { 1348 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1349 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_1024 1350 }; 1351 properties[2] = { 1352 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1353 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 1354 }; 1355 properties[3] = { 1356 tag: huks.HuksTag.HUKS_TAG_PADDING, 1357 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 1358 }; 1359 properties[4] = { 1360 tag: huks.HuksTag.HUKS_TAG_DIGEST, 1361 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 1362 }; 1363 properties[5] = { 1364 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 1365 value: huks.HuksCipherMode.HUKS_MODE_ECB, 1366 } 1367 1368 try { 1369 await huks.generateKeyItem(keyAlias, options, function (error, data) { 1370 if (error) { 1371 console.error(`callback: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`); 1372 } else { 1373 console.info(`callback: generateKeyItem success`); 1374 } 1375 }); 1376 } catch (error) { 1377 console.error(`callback: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`); 1378 } 1379} 1380 1381async function huksInit() { 1382 console.log('enter huksInit'); 1383 try { 1384 huks.initSession(keyAlias, options, function (error, data) { 1385 if (error) { 1386 console.error(`callback: initSession failed, code: ${error.code}, msg: ${error.message}`); 1387 } else { 1388 console.info(`callback: initSession success, data = ${JSON.stringify(data)}`); 1389 handle = data.handle; 1390 } 1391 }); 1392 } catch (error) { 1393 console.error(`callback: initSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1394 } 1395} 1396 1397async function huksUpdate() { 1398 console.log('enter huksUpdate'); 1399 options.inData = stringToUint8Array("huksHmacTest"); 1400 try { 1401 huks.updateSession(handle, options, function (error, data) { 1402 if (error) { 1403 console.error(`callback: updateSession failed, code: ${error.code}, msg: ${error.message}`); 1404 } else { 1405 console.info(`callback: updateSession success, data = ${JSON.stringify(data)}`); 1406 } 1407 }); 1408 } catch (error) { 1409 console.error(`callback: updateSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1410 } 1411} 1412 1413async function huksFinish() { 1414 console.log('enter huksFinish'); 1415 options.inData = new Uint8Array(0); 1416 try { 1417 huks.finishSession(handle, options, function (error, data) { 1418 if (error) { 1419 console.error(`callback: finishSession failed, code: ${error.code}, msg: ${error.message}`); 1420 } else { 1421 console.info(`callback: finishSession success, data = ${JSON.stringify(data)}`); 1422 } 1423 }); 1424 } catch (error) { 1425 console.error(`callback: finishSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1426 } 1427} 1428 1429async function huksAbort() { 1430 console.log('enter huksAbort'); 1431 try { 1432 huks.abortSession(handle, options, function (error, data) { 1433 if (error) { 1434 console.error(`callback: abortSession failed, code: ${error.code}, msg: ${error.message}`); 1435 } else { 1436 console.info(`callback: abortSession success`); 1437 } 1438 }); 1439 } catch (error) { 1440 console.error(`callback: abortSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1441 } 1442} 1443``` 1444 1445## huks.abortSession<sup>9+</sup> 1446 1447abortSession(handle: number, options: HuksOptions) : Promise\<void>; 1448 1449abortSession操作密钥接口，使用Promise方式异步返回结果。 1450 1451**系统能力**：SystemCapability.Security.Huks 1452 1453**参数：** 1454 1455| 参数名 | 类型 | 必填 | 说明 | 1456| ------- | --------------------------- | ---- | ------------------------------------------- | 1457| handle | number | 是 | abortSession操作的handle。 | 1458| options | [HuksOptions](#huksoptions) | 是 | abortSession操作的参数集合。 | 1459 1460**返回值**： 1461 1462| 类型 | 说明 | 1463| ----------------------------------- | -------------------------------------------------- | 1464| Promise\<void> | Promise对象。将abortSession操作的结果添加到密钥管理系统的回调。 | 1465 1466**示例：** 1467 1468```js 1469/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当 1470 * huks.initSession和huks.updateSession 1471 * 以及huks.finishSession操作中的任一阶段发生错误时， 1472 * 都需要调用huks.abortSession来终止密钥的使用。 1473 * 1474 * 以下以RSA1024密钥的callback功能使用为例 1475 */ 1476function stringToUint8Array(str) { 1477 let arr = []; 1478 for (let i = 0, j = str.length; i < j; ++i) { 1479 arr.push(str.charCodeAt(i)); 1480 } 1481 let tmpUint8Array = new Uint8Array(arr); 1482 return tmpUint8Array; 1483} 1484 1485let keyAlias = "HuksDemoRSA"; 1486let properties = new Array(); 1487let options = { 1488 properties: properties, 1489 inData: new Uint8Array(0) 1490}; 1491let handle; 1492async function generateKey() { 1493 properties[0] = { 1494 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 1495 value: huks.HuksKeyAlg.HUKS_ALG_RSA 1496 }; 1497 properties[1] = { 1498 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 1499 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_1024 1500 }; 1501 properties[2] = { 1502 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 1503 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 1504 }; 1505 properties[3] = { 1506 tag: huks.HuksTag.HUKS_TAG_PADDING, 1507 value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5 1508 }; 1509 properties[4] = { 1510 tag: huks.HuksTag.HUKS_TAG_DIGEST, 1511 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 1512 }; 1513 properties[5] = { 1514 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 1515 value: huks.HuksCipherMode.HUKS_MODE_ECB, 1516 } 1517 1518 try { 1519 await huks.generateKeyItem(keyAlias, options) 1520 .then((data) => { 1521 console.info(`promise: generateKeyItem success`); 1522 }) 1523 .catch(error => { 1524 console.error(`promise: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`); 1525 }); 1526 } catch (error) { 1527 console.error(`promise: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`); 1528 } 1529} 1530 1531async function huksInit() { 1532 console.log('enter huksInit'); 1533 try { 1534 await huks.initSession(keyAlias, options) 1535 .then ((data) => { 1536 console.info(`promise: initSession success, data = ${JSON.stringify(data)}`); 1537 handle = data.handle; 1538 }) 1539 .catch(error => { 1540 console.error(`promise: initSession key failed, code: ${error.code}, msg: ${error.message}`); 1541 }); 1542 } catch (error) { 1543 console.error(`promise: initSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1544 } 1545} 1546 1547async function huksUpdate() { 1548 console.log('enter huksUpdate'); 1549 options.inData = stringToUint8Array("huksHmacTest"); 1550 try { 1551 await huks.updateSession(handle, options) 1552 .then ((data) => { 1553 console.info(`promise: updateSession success, data = ${JSON.stringify(data)}`); 1554 }) 1555 .catch(error => { 1556 console.error(`promise: updateSession failed, code: ${error.code}, msg: ${error.message}`); 1557 }); 1558 } catch (error) { 1559 console.error(`promise: updateSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1560 } 1561} 1562 1563async function huksFinish() { 1564 console.log('enter huksFinish'); 1565 options.inData = new Uint8Array(0); 1566 try { 1567 await huks.finishSession(handle, options) 1568 .then ((data) => { 1569 console.info(`promise: finishSession success, data = ${JSON.stringify(data)}`); 1570 }) 1571 .catch(error => { 1572 console.error(`promise: finishSession failed, code: ${error.code}, msg: ${error.message}`); 1573 }); 1574 } catch (error) { 1575 console.error(`promise: finishSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1576 } 1577} 1578 1579async function huksAbort() { 1580 console.log('enter huksAbort'); 1581 try { 1582 await huks.abortSession(handle, options) 1583 .then ((data) => { 1584 console.info(`promise: abortSession success`); 1585 }) 1586 .catch(error => { 1587 console.error(`promise: abortSession failed, code: ${error.code}, msg: ${error.message}`); 1588 }); 1589 } catch (error) { 1590 console.error(`promise: abortSession input arg invalid, code: ${error.code}, msg: ${error.message}`); 1591 } 1592} 1593``` 1594 1595 1596## HuksExceptionErrCode<sup>9+</sup> 1597 1598表示错误码的枚举以及对应的错误信息， 错误码表示错误类型，错误信息展示错误详情。 1599 1600关于错误码的具体信息，可在[错误码参考文档](../errorcodes/errorcode-huks.md)中查看。 1601 1602**系统能力**：SystemCapability.Security.Huks 1603 1604| 名称 | 值 | 说明 | 1605| ---------------------------------------------- | -------- |--------------------------- | 1606| HUKS_ERR_CODE_PERMISSION_FAIL | 201 | 权限错误导致失败。 | 1607| HUKS_ERR_CODE_ILLEGAL_ARGUMENT | 401 | 参数错误导致失败。 | 1608| HUKS_ERR_CODE_NOT_SUPPORTED_API | 801 | 不支持的API。 | 1609| HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED | 12000001 | 不支持的功能/特性。 | 1610| HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT | 12000002 | 缺少密钥算法参数。 | 1611| HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT | 12000003 | 无效密钥算法参数。 | 1612| HUKS_ERR_CODE_FILE_OPERATION_FAIL | 12000004 | 文件操作失败。 | 1613| HUKS_ERR_CODE_COMMUNICATION_FAIL | 12000005 | 通信失败。 | 1614| HUKS_ERR_CODE_CRYPTO_FAIL | 12000006 | 算法库操作失败。 | 1615| HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED | 12000007 | 密钥访问失败-密钥访问失效。 | 1616| HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED | 12000008 | 密钥访问失败-密钥认证失败。 | 1617| HUKS_ERR_CODE_KEY_AUTH_TIME_OUT | 12000009 | 密钥访问失败-密钥访问超时。 | 1618| HUKS_ERR_CODE_SESSION_LIMIT | 12000010 | 密钥操作会话数已达上限。 | 1619| HUKS_ERR_CODE_ITEM_NOT_EXIST | 12000011 | 目标对象不存在。 | 1620| HUKS_ERR_CODE_EXTERNAL_ERROR | 12000012 | 外部错误。 | 1621| HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST | 12000013 | 缺失所需凭据。 | 1622| HUKS_ERR_CODE_INSUFFICIENT_MEMORY | 12000014 | 内存不足。 | 1623| HUKS_ERR_CODE_CALL_SERVICE_FAILED | 12000015 | 调用其他系统服务失败。 | 1624 1625## HuksKeyPurpose 1626 1627表示密钥用途。 1628 1629**系统能力**：SystemCapability.Security.Huks 1630 1631| 名称 | 值 | 说明 | 1632| ------------------------ | ---- | -------------------------------- | 1633| HUKS_KEY_PURPOSE_ENCRYPT | 1 | 表示密钥用于对明文进行加密操作。 | 1634| HUKS_KEY_PURPOSE_DECRYPT | 2 | 表示密钥用于对密文进行解密操作。 | 1635| HUKS_KEY_PURPOSE_SIGN | 4 | 表示密钥用于对数据进行签名。 | 1636| HUKS_KEY_PURPOSE_VERIFY | 8 | 表示密钥用于验证签名后的数据。 | 1637| HUKS_KEY_PURPOSE_DERIVE | 16 | 表示密钥用于派生密钥。 | 1638| HUKS_KEY_PURPOSE_WRAP | 32 | 表示密钥用于加密导出。 | 1639| HUKS_KEY_PURPOSE_UNWRAP | 64 | 表示密钥加密导入。 | 1640| HUKS_KEY_PURPOSE_MAC | 128 | 表示密钥用于生成mac消息验证码。 | 1641| HUKS_KEY_PURPOSE_AGREE | 256 | 表示密钥用于进行密钥协商。 | 1642 1643## HuksKeyDigest 1644 1645表示摘要算法。 1646 1647**系统能力**：SystemCapability.Security.Huks 1648 1649| 名称 | 值 | 说明 | 1650| ---------------------- | ---- | ---------------------------------------- | 1651| HUKS_DIGEST_NONE | 0 | 表示无摘要算法。 | 1652| HUKS_DIGEST_MD5 | 1 | 表示MD5摘要算法。 | 1653| HUKS_DIGEST_SM3<sup>9+</sup> | 2 | 表示SM3摘要算法。 | 1654| HUKS_DIGEST_SHA1 | 10 | 表示SHA1摘要算法。 | 1655| HUKS_DIGEST_SHA224 | 11 | 表示SHA224摘要算法。 | 1656| HUKS_DIGEST_SHA256 | 12 | 表示SHA256摘要算法。 | 1657| HUKS_DIGEST_SHA384 | 13 | 表示SHA384摘要算法。 | 1658| HUKS_DIGEST_SHA512 | 14 | 表示SHA512摘要算法。 | 1659 1660## HuksKeyPadding 1661 1662表示补齐算法。 1663 1664**系统能力**：SystemCapability.Security.Huks 1665 1666| 名称 | 值 | 说明 | 1667| ---------------------- | ---- | ---------------------------------------- | 1668| HUKS_PADDING_NONE | 0 | 表示不使用补齐算法。 | 1669| HUKS_PADDING_OAEP | 1 | 表示使用OAEP补齐算法。 | 1670| HUKS_PADDING_PSS | 2 | 表示使用PSS补齐算法。 | 1671| HUKS_PADDING_PKCS1_V1_5 | 3 | 表示使用PKCS1_V1_5补齐算法。 | 1672| HUKS_PADDING_PKCS5 | 4 | 表示使用PKCS5补齐算法。 | 1673| HUKS_PADDING_PKCS7 | 5 | 表示使用PKCS7补齐算法。 | 1674 1675## HuksCipherMode 1676 1677表示加密模式。 1678 1679**系统能力**：SystemCapability.Security.Huks 1680 1681| 名称 | 值 | 说明 | 1682| ------------- | ---- | --------------------- | 1683| HUKS_MODE_ECB | 1 | 表示使用ECB加密模式。 | 1684| HUKS_MODE_CBC | 2 | 表示使用CBC加密模式。 | 1685| HUKS_MODE_CTR | 3 | 表示使用CTR加密模式。 | 1686| HUKS_MODE_OFB | 4 | 表示使用OFB加密模式。 | 1687| HUKS_MODE_CCM | 31 | 表示使用CCM加密模式。 | 1688| HUKS_MODE_GCM | 32 | 表示使用GCM加密模式。 | 1689 1690## HuksKeySize 1691 1692表示密钥长度。 1693 1694**系统能力**：SystemCapability.Security.Huks 1695 1696| 名称 | 值 | 说明 | 1697| ---------------------------------- | ---- | ------------------------------------------ | 1698| HUKS_RSA_KEY_SIZE_512 | 512 | 表示使用RSA算法的密钥长度为512bit。 | 1699| HUKS_RSA_KEY_SIZE_768 | 768 | 表示使用RSA算法的密钥长度为768bit。 | 1700| HUKS_RSA_KEY_SIZE_1024 | 1024 | 表示使用RSA算法的密钥长度为1024bit。 | 1701| HUKS_RSA_KEY_SIZE_2048 | 2048 | 表示使用RSA算法的密钥长度为2048bit。 | 1702| HUKS_RSA_KEY_SIZE_3072 | 3072 | 表示使用RSA算法的密钥长度为3072bit。 | 1703| HUKS_RSA_KEY_SIZE_4096 | 4096 | 表示使用RSA算法的密钥长度为4096bit。 | 1704| HUKS_ECC_KEY_SIZE_224 | 224 | 表示使用ECC算法的密钥长度为224bit。 | 1705| HUKS_ECC_KEY_SIZE_256 | 256 | 表示使用ECC算法的密钥长度为256bit。 | 1706| HUKS_ECC_KEY_SIZE_384 | 384 | 表示使用ECC算法的密钥长度为384bit。 | 1707| HUKS_ECC_KEY_SIZE_521 | 521 | 表示使用ECC算法的密钥长度为521bit。 | 1708| HUKS_AES_KEY_SIZE_128 | 128 | 表示使用AES算法的密钥长度为128bit。 | 1709| HUKS_AES_KEY_SIZE_192 | 192 | 表示使用AES算法的密钥长度为196bit。 | 1710| HUKS_AES_KEY_SIZE_256 | 256 | 表示使用AES算法的密钥长度为256bit。 | 1711| HUKS_AES_KEY_SIZE_512 | 512 | 表示使用AES算法的密钥长度为512bit。 | 1712| HUKS_CURVE25519_KEY_SIZE_256 | 256 | 表示使用CURVE25519算法的密钥长度为256bit。 | 1713| HUKS_DH_KEY_SIZE_2048 | 2048 | 表示使用DH算法的密钥长度为2048bit。 | 1714| HUKS_DH_KEY_SIZE_3072 | 3072 | 表示使用DH算法的密钥长度为3072bit。 | 1715| HUKS_DH_KEY_SIZE_4096 | 4096 | 表示使用DH算法的密钥长度为4096bit。 | 1716| HUKS_SM2_KEY_SIZE_256<sup>9+</sup> | 256 | 表示SM2算法的密钥长度为256bit。 | 1717| HUKS_SM4_KEY_SIZE_128<sup>9+</sup> | 128 | 表示SM4算法的密钥长度为128bit。 | 1718 1719## HuksKeyAlg 1720 1721表示密钥使用的算法。 1722 1723**系统能力**：SystemCapability.Security.Huks 1724 1725| 名称 | 值 | 说明 | 1726| ------------------------- | ---- | --------------------- | 1727| HUKS_ALG_RSA | 1 | 表示使用RSA算法。 | 1728| HUKS_ALG_ECC | 2 | 表示使用ECC算法。 | 1729| HUKS_ALG_DSA | 3 | 表示使用DSA算法。 | 1730| HUKS_ALG_AES | 20 | 表示使用AES算法。 | 1731| HUKS_ALG_HMAC | 50 | 表示使用HMAC算法。 | 1732| HUKS_ALG_HKDF | 51 | 表示使用HKDF算法。 | 1733| HUKS_ALG_PBKDF2 | 52 | 表示使用PBKDF2算法。 | 1734| HUKS_ALG_ECDH | 100 | 表示使用ECDH算法。 | 1735| HUKS_ALG_X25519 | 101 | 表示使用X25519算法。 | 1736| HUKS_ALG_ED25519 | 102 | 表示使用ED25519算法。 | 1737| HUKS_ALG_DH | 103 | 表示使用DH算法。 | 1738| HUKS_ALG_SM2<sup>9+</sup> | 150 | 表示使用SM2算法。 | 1739| HUKS_ALG_SM3<sup>9+</sup> | 151 | 表示使用SM3算法。 | 1740| HUKS_ALG_SM4<sup>9+</sup> | 152 | 表示使用SM4算法。 | 1741 1742## HuksKeyGenerateType 1743 1744表示生成密钥的类型。 1745 1746**系统能力**：SystemCapability.Security.Huks 1747 1748| 名称 | 值 | 说明 | 1749| ------------------------------ | ---- | ---------------- | 1750| HUKS_KEY_GENERATE_TYPE_DEFAULT | 0 | 默认生成的密钥。 | 1751| HUKS_KEY_GENERATE_TYPE_DERIVE | 1 | 派生生成的密钥。 | 1752| HUKS_KEY_GENERATE_TYPE_AGREE | 2 | 协商生成的密钥。 | 1753 1754## HuksKeyFlag 1755 1756表示密钥的产生方式。 1757 1758**系统能力**：SystemCapability.Security.Huks 1759 1760| 名称 | 值 | 说明 | 1761| -------------------------- | ---- | ------------------------------------ | 1762| HUKS_KEY_FLAG_IMPORT_KEY | 1 | 表示通过导入公钥接口导入的密钥。 | 1763| HUKS_KEY_FLAG_GENERATE_KEY | 2 | 表示通过生成密钥接口生成的密钥。 | 1764| HUKS_KEY_FLAG_AGREE_KEY | 3 | 表示通过生成密钥协商接口生成的密钥。 | 1765| HUKS_KEY_FLAG_DERIVE_KEY | 4 | 表示通过生成密钥派生接口生成的密钥。 | 1766 1767## HuksKeyStorageType 1768 1769表示密钥存储方式。 1770 1771**系统能力**：SystemCapability.Security.Huks 1772 1773| 名称 | 值 | 说明 | 1774| ----------------------- | ---- | ------------------------------ | 1775| HUKS_STORAGE_TEMP | 0 | 表示通过本地直接管理密钥。 | 1776| HUKS_STORAGE_PERSISTENT | 1 | 表示通过HUKS service管理密钥。 | 1777 1778## HuksSendType 1779 1780表示发送Tag的方式。 1781 1782**系统能力**：SystemCapability.Security.Huks 1783 1784| 名称 | 值 | 说明 | 1785| -------------------- | ---- | ----------------- | 1786| HUKS_SEND_TYPE_ASYNC | 0 | 表示异步发送TAG。 | 1787| HUKS_SEND_TYPE_SYNC | 1 | 表示同步发送TAG。 | 1788 1789## HuksUnwrapSuite<sup>9+</sup> 1790 1791表示导入加密密钥的算法套件。 1792 1793**系统能力**：SystemCapability.Security.Huks 1794 1795| 名称 | 值 | 说明 | 1796| ---------------------------------------------- | ---- | ----------------------------------------------------- | 1797| HUKS_UNWRAP_SUITE_X25519_AES_256_GCM_NOPADDING | 1 | 导入加密密钥时，X25519密钥协商后使用AES-256 GCM加密。 | 1798| HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING | 2 | 导入加密密钥时，ECDH密钥协商后使用AES-256 GCM加密。 | 1799 1800## HuksImportKeyType<sup>9+</sup> 1801 1802表示导入密钥的密钥类型，默认为导入公钥，导入对称密钥时不需要该字段。 1803 1804**系统能力**：SystemCapability.Security.Huks 1805 1806| 名称 | 值 | 说明 | 1807| ------------------------- | ---- | ------------------------------ | 1808| HUKS_KEY_TYPE_PUBLIC_KEY | 0 | 表示导入的密钥类型为公钥。 | 1809| HUKS_KEY_TYPE_PRIVATE_KEY | 1 | 表示导入的密钥类型为私钥。 | 1810| HUKS_KEY_TYPE_KEY_PAIR | 2 | 表示导入的密钥类型为公私钥对。 | 1811 1812## HuksUserAuthType<sup>9+</sup> 1813 1814表示用户认证类型。 1815 1816**系统能力**：SystemCapability.Security.Huks 1817 1818| 名称 | 值 | 说明 | 1819| ------------------------------- | ---- | ------------------------- | 1820| HUKS_USER_AUTH_TYPE_FINGERPRINT | 1 << 0 | 表示用户认证类型为指纹。 | 1821| HUKS_USER_AUTH_TYPE_FACE | 1 << 1 | 表示用户认证类型为人脸 。 | 1822| HUKS_USER_AUTH_TYPE_PIN | 1 << 2 | 表示用户认证类型为PIN码。 | 1823 1824## HuksAuthAccessType<sup>9+</sup> 1825 1826表示安全访问控制类型。 1827 1828**系统能力**：SystemCapability.Security.Huks 1829 1830| 名称 | 值 | 说明 | 1831| --------------------------------------- | ---- | ------------------------------------------------ | 1832| HUKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD | 1 << 0 | 表示安全访问控制类型为清除密码后密钥无效。 | 1833| HUKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL | 1 << 1 | 表示安全访问控制类型为新录入生物特征后密钥无效。 | 1834 1835## HuksChallengeType<sup>9+</sup> 1836 1837表示密钥使用时生成challenge的类型。 1838 1839**系统能力**：SystemCapability.Security.Huks 1840 1841| 名称 | 值 | 说明 | 1842| ------------------------------- | ---- | ------------------------------ | 1843| HUKS_CHALLENGE_TYPE_NORMAL | 0 | 表示challenge为普通类型，默认32字节。 | 1844| HUKS_CHALLENGE_TYPE_CUSTOM | 1 | 表示challenge为用户自定义类型。支持使用多个密钥仅一次认证。 | 1845| HUKS_CHALLENGE_TYPE_NONE | 2 | 表示免challenge类型。 | 1846 1847## HuksChallengePosition<sup>9+</sup> 1848 1849表示challenge类型为用户自定义类型时，生成的challenge有效长度仅为8字节连续的数据，且仅支持4种位置 。 1850 1851**系统能力**：SystemCapability.Security.Huks 1852 1853| 名称 | 值 | 说明 | 1854| ------------------------------- | ---- | ------------------------------ | 1855| HUKS_CHALLENGE_POS_0 | 0 | 表示0~7字节为当前密钥的有效challenge。 | 1856| HUKS_CHALLENGE_POS_1 | 1 | 表示8~15字节为当前密钥的有效challenge。 | 1857| HUKS_CHALLENGE_POS_2 | 2 | 表示16~23字节为当前密钥的有效challenge。 | 1858| HUKS_CHALLENGE_POS_3 | 3 | 表示24~31字节为当前密钥的有效challenge。 | 1859 1860## HuksSecureSignType<sup>9+</sup> 1861 1862表示生成或导入密钥时，指定该密钥的签名类型。 1863 1864**系统能力**：SystemCapability.Security.Huks 1865 1866| 名称 | 值 | 说明 | 1867| ------------------------------ | ---- | ------------------------------------------------------------ | 1868| HUKS_SECURE_SIGN_WITH_AUTHINFO | 1 | 表示签名类型为携带认证信息。生成或导入密钥时指定该字段，则在使用密钥进行签名时，对待签名的数据添加认证信息后进行签名。 | 1869 1870## HuksTagType 1871 1872表示Tag的数据类型。 1873 1874**系统能力**：SystemCapability.Security.Huks 1875 1876| 名称 | 值 | 说明 | 1877| --------------------- | ------- | --------------------------------------- | 1878| HUKS_TAG_TYPE_INVALID | 0 << 28 | 表示非法的Tag类型。 | 1879| HUKS_TAG_TYPE_INT | 1 << 28 | 表示该Tag的数据类型为int类型的number。 | 1880| HUKS_TAG_TYPE_UINT | 2 << 28 | 表示该Tag的数据类型为uint类型的number。 | 1881| HUKS_TAG_TYPE_ULONG | 3 << 28 | 表示该Tag的数据类型为bigint。 | 1882| HUKS_TAG_TYPE_BOOL | 4 << 28 | 表示该Tag的数据类型为boolean。 | 1883| HUKS_TAG_TYPE_BYTES | 5 << 28 | 表示该Tag的数据类型为Uint8Array。 | 1884 1885## HuksTag 1886 1887表示调用参数的Tag。 1888 1889**系统能力**：SystemCapability.Security.Huks 1890 1891| 名称 | 值 | 说明 | 1892| -------------------------------------------- | ---------------------------------------- | -------------------------------------- | 1893| HUKS_TAG_INVALID | HuksTagType.HUKS_TAG_TYPE_INVALID \| 0 | 表示非法的Tag。 | 1894| HUKS_TAG_ALGORITHM | HuksTagType.HUKS_TAG_TYPE_UINT \| 1 | 表示算法的Tag。 | 1895| HUKS_TAG_PURPOSE | HuksTagType.HUKS_TAG_TYPE_UINT \| 2 | 表示密钥用途的Tag。 | 1896| HUKS_TAG_KEY_SIZE | HuksTagType.HUKS_TAG_TYPE_UINT \| 3 | 表示密钥长度的Tag。 | 1897| HUKS_TAG_DIGEST | HuksTagType.HUKS_TAG_TYPE_UINT \| 4 | 表示摘要算法的Tag。 | 1898| HUKS_TAG_PADDING | HuksTagType.HUKS_TAG_TYPE_UINT \| 5 | 表示补齐算法的Tag。 | 1899| HUKS_TAG_BLOCK_MODE | HuksTagType.HUKS_TAG_TYPE_UINT \| 6 | 表示加密模式的Tag。 | 1900| HUKS_TAG_KEY_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 7 | 表示密钥类型的Tag。 | 1901| HUKS_TAG_ASSOCIATED_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 8 | 表示附加身份验证数据的Tag。 | 1902| HUKS_TAG_NONCE | HuksTagType.HUKS_TAG_TYPE_BYTES \| 9 | 表示密钥加解密的字段。 | 1903| HUKS_TAG_IV | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10 | 表示密钥初始化的向量。 | 1904| HUKS_TAG_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 11 | 表示密钥派生时的info。 | 1905| HUKS_TAG_SALT | HuksTagType.HUKS_TAG_TYPE_BYTES \| 12 | 表示密钥派生时的盐值。 | 1906| HUKS_TAG_PWD | HuksTagType.HUKS_TAG_TYPE_BYTES \| 13 | 表示密钥派生时的password。 | 1907| HUKS_TAG_ITERATION | HuksTagType.HUKS_TAG_TYPE_UINT \| 14 | 表示密钥派生时的迭代次数。 | 1908| HUKS_TAG_KEY_GENERATE_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 15 | 表示生成密钥类型的Tag。 | 1909| HUKS_TAG_DERIVE_MAIN_KEY | HuksTagType.HUKS_TAG_TYPE_BYTES \| 16 | 表示密钥派生时的主密钥。 | 1910| HUKS_TAG_DERIVE_FACTOR | HuksTagType.HUKS_TAG_TYPE_BYTES \| 17 | 表示密钥派生时的派生因子。 | 1911| HUKS_TAG_DERIVE_ALG | HuksTagType.HUKS_TAG_TYPE_UINT \| 18 | 表示密钥派生时的算法类型。 | 1912| HUKS_TAG_AGREE_ALG | HuksTagType.HUKS_TAG_TYPE_UINT \| 19 | 表示密钥协商时的算法类型。 | 1913| HUKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 20 | 表示密钥协商时的公钥别名。 | 1914| HUKS_TAG_AGREE_PRIVATE_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 21 | 表示密钥协商时的私钥别名。 | 1915| HUKS_TAG_AGREE_PUBLIC_KEY | HuksTagType.HUKS_TAG_TYPE_BYTES \| 22 | 表示密钥协商时的公钥。 | 1916| HUKS_TAG_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 23 | 表示密钥别名。 | 1917| HUKS_TAG_DERIVE_KEY_SIZE | HuksTagType.HUKS_TAG_TYPE_UINT \| 24 | 表示派生密钥的大小。 | 1918| HUKS_TAG_IMPORT_KEY_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 25 | 表示导入的密钥类型。 | 1919| HUKS_TAG_UNWRAP_ALGORITHM_SUITE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 26 | 表示导入加密密钥的套件。 | 1920| HUKS_TAG_ACTIVE_DATETIME | HuksTagType.HUKS_TAG_TYPE_ULONG \| 201 | 预留。 | 1921| HUKS_TAG_ORIGINATION_EXPIRE_DATETIME | HuksTagType.HUKS_TAG_TYPE_ULONG \| 202 | 预留。 | 1922| HUKS_TAG_USAGE_EXPIRE_DATETIME | HuksTagType.HUKS_TAG_TYPE_ULONG \| 203 | 预留。 | 1923| HUKS_TAG_CREATION_DATETIME | HuksTagType.HUKS_TAG_TYPE_ULONG \| 204 | 预留。 | 1924| HUKS_TAG_ALL_USERS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 301 | 预留。 | 1925| HUKS_TAG_USER_ID | HuksTagType.HUKS_TAG_TYPE_UINT \| 302 | 预留。 | 1926| HUKS_TAG_NO_AUTH_REQUIRED | HuksTagType.HUKS_TAG_TYPE_BOOL \| 303 | 预留。 | 1927| 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 | 1928| HUKS_TAG_AUTH_TIMEOUT | HuksTagType.HUKS_TAG_TYPE_UINT \| 305 | 预留。 | 1929| HUKS_TAG_AUTH_TOKEN | HuksTagType.HUKS_TAG_TYPE_BYTES \| 306 | 预留。 | 1930| HUKS_TAG_KEY_AUTH_ACCESS_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 307 | 表示安全访问控制类型。从[HuksAuthAccessType](#huksauthaccesstype9)中选择，需要和用户认证类型同时设置。 | 1931| HUKS_TAG_KEY_SECURE_SIGN_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 308 | 表示生成或导入密钥时，指定该密钥的签名类型。 | 1932| HUKS_TAG_CHALLENGE_TYPE<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 309 | 表示密钥使用时生成的challenge类型。从[HuksChallengeType](#hukschallengetype9)中选择 | 1933| HUKS_TAG_CHALLENGE_POS<sup>9+</sup> | HuksTagType.HUKS_TAG_TYPE_UINT \| 310 | 表示challenge类型为用户自定义类型时，huks产生的challenge有效长度仅为8字节连续的数据。从[HuksChallengePosition](#hukschallengeposition9)中选择。 | 1934| HUKS_TAG_ATTESTATION_CHALLENGE | HuksTagType.HUKS_TAG_TYPE_BYTES \| 501 | 表示attestation时的挑战值。 | 1935| HUKS_TAG_ATTESTATION_APPLICATION_ID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 502 | 表示attestation时拥有该密钥的application的Id。 | 1936| HUKS_TAG_ATTESTATION_ID_BRAND | HuksTagType.HUKS_TAG_TYPE_BYTES \| 503 | 表示设备的品牌。 | 1937| HUKS_TAG_ATTESTATION_ID_DEVICE | HuksTagType.HUKS_TAG_TYPE_BYTES \| 504 | 表示设备的设备ID。 | 1938| HUKS_TAG_ATTESTATION_ID_PRODUCT | HuksTagType.HUKS_TAG_TYPE_BYTES \| 505 | 表示设备的产品名。 | 1939| HUKS_TAG_ATTESTATION_ID_SERIAL | HuksTagType.HUKS_TAG_TYPE_BYTES \| 506 | 表示设备的SN号。 | 1940| HUKS_TAG_ATTESTATION_ID_IMEI | HuksTagType.HUKS_TAG_TYPE_BYTES \| 507 | 表示设备的IMEI号。 | 1941| HUKS_TAG_ATTESTATION_ID_MEID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 508 | 表示设备的MEID号。 | 1942| HUKS_TAG_ATTESTATION_ID_MANUFACTURER | HuksTagType.HUKS_TAG_TYPE_BYTES \| 509 | 表示设备的制造商。 | 1943| HUKS_TAG_ATTESTATION_ID_MODEL | HuksTagType.HUKS_TAG_TYPE_BYTES \| 510 | 表示设备的型号。 | 1944| HUKS_TAG_ATTESTATION_ID_ALIAS | HuksTagType.HUKS_TAG_TYPE_BYTES \| 511 | 表示attestation时的密钥别名。 | 1945| HUKS_TAG_ATTESTATION_ID_SOCID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 512 | 表示设备的SOCID。 | 1946| HUKS_TAG_ATTESTATION_ID_UDID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 513 | 表示设备的UDID。 | 1947| HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 514 | 表示attestation时的安全凭据。 | 1948| HUKS_TAG_ATTESTATION_ID_VERSION_INFO | HuksTagType.HUKS_TAG_TYPE_BYTES \| 515 | 表示attestation时的版本号。 | 1949| HUKS_TAG_IS_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1001 | 表示是否使用生成key时传入的别名的Tag。 | 1950| HUKS_TAG_KEY_STORAGE_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1002 | 表示密钥存储方式的Tag。 | 1951| HUKS_TAG_IS_ALLOWED_WRAP | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1003 | 预留。 | 1952| HUKS_TAG_KEY_WRAP_TYPE | HuksTagType.HUKS_TAG_TYPE_UINT \| 1004 | 预留。 | 1953| HUKS_TAG_KEY_AUTH_ID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 1005 | 预留。 | 1954| HUKS_TAG_KEY_ROLE | HuksTagType.HUKS_TAG_TYPE_UINT \| 1006 | 预留。 | 1955| HUKS_TAG_KEY_FLAG | HuksTagType.HUKS_TAG_TYPE_UINT \| 1007 | 表示密钥标志的Tag。 | 1956| HUKS_TAG_IS_ASYNCHRONIZED | HuksTagType.HUKS_TAG_TYPE_UINT \| 1008 | 预留。 | 1957| HUKS_TAG_SECURE_KEY_ALIAS | HuksTagType.HUKS_TAG_TYPE_BOOL \| 1009 | 预留。 | 1958| HUKS_TAG_SECURE_KEY_UUID | HuksTagType.HUKS_TAG_TYPE_BYTES \| 1010 | 预留。 | 1959| HUKS_TAG_KEY_DOMAIN | HuksTagType.HUKS_TAG_TYPE_UINT \| 1011 | 预留。 | 1960| HUKS_TAG_PROCESS_NAME | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10001 | 表示进程名称的Tag。 | 1961| HUKS_TAG_PACKAGE_NAME | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10002 | 预留。 | 1962| HUKS_TAG_ACCESS_TIME | HuksTagType.HUKS_TAG_TYPE_UINT \| 10003 | 预留。 | 1963| HUKS_TAG_USES_TIME | HuksTagType.HUKS_TAG_TYPE_UINT \| 10004 | 预留。 | 1964| HUKS_TAG_CRYPTO_CTX | HuksTagType.HUKS_TAG_TYPE_ULONG \| 10005 | 预留。 | 1965| HUKS_TAG_KEY | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10006 | 预留。 | 1966| HUKS_TAG_KEY_VERSION | HuksTagType.HUKS_TAG_TYPE_UINT \| 10007 | 表示密钥版本的Tag。 | 1967| HUKS_TAG_PAYLOAD_LEN | HuksTagType.HUKS_TAG_TYPE_UINT \| 10008 | 预留。 | 1968| HUKS_TAG_AE_TAG | HuksTagType.HUKS_TAG_TYPE_BYTES \| 10009 | 预留。 | 1969| HUKS_TAG_IS_KEY_HANDLE | HuksTagType.HUKS_TAG_TYPE_ULONG \| 10010 | 预留。 | 1970| HUKS_TAG_OS_VERSION | HuksTagType.HUKS_TAG_TYPE_UINT \| 10101 | 表示操作系统版本的Tag。 | 1971| HUKS_TAG_OS_PATCHLEVEL | HuksTagType.HUKS_TAG_TYPE_UINT \| 10102 | 表示操作系统补丁级别的Tag。 | 1972| HUKS_TAG_SYMMETRIC_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20001 | 预留。 | 1973| HUKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20002 | 预留。 | 1974| HUKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA | HuksTagType.HUKS_TAG_TYPE_BYTES \| 20003 | 预留。 | 1975 1976## huks.generateKey<sup>(deprecated)</sup> 1977 1978generateKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 1979 1980生成密钥，使用Callback回调异步返回结果。 1981 1982> **说明：** 从API Version 9开始废弃，建议使用[huks.generateKeyItem<sup>9+</sup>](#huksgeneratekeyitem9)替代。 1983 1984**系统能力**：SystemCapability.Security.Huks 1985 1986**参数：** 1987 1988| 参数名 | 类型 | 必填 | 说明 | 1989| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1990| keyAlias | string | 是 | 别名。 | 1991| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。 | 1992| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其余结果请参考HuksResult进行错误码查询。 | 1993 1994**示例：** 1995 1996```js 1997/* 以生成RSA512密钥为例 */ 1998let keyAlias = 'keyAlias'; 1999let properties = new Array(); 2000properties[0] = { 2001 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2002 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2003}; 2004properties[1] = { 2005 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2006 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_512 2007}; 2008properties[2] = { 2009 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2010 value: 2011huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | 2012huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 2013}; 2014properties[3] = { 2015 tag: huks.HuksTag.HUKS_TAG_PADDING, 2016 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 2017}; 2018properties[4] = { 2019 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2020 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2021}; 2022let options = { 2023 properties: properties 2024}; 2025huks.generateKey(keyAlias, options, function (err, data){}); 2026``` 2027 2028## huks.generateKey<sup>(deprecated)</sup> 2029 2030generateKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 2031 2032生成密钥，使用Promise方式异步返回结果。 2033 2034> **说明：** 从API Version 9开始废弃，建议使用[huks.generateKeyItem<sup>9+</sup>](#huksgeneratekeyitem9-1)替代。 2035 2036**系统能力**：SystemCapability.Security.Huks 2037 2038**参数：** 2039 2040| 参数名 | 类型 | 必填 | 说明 | 2041| -------- | --------------------------- | ---- | ------------------------ | 2042| keyAlias | string | 是 | 密钥别名。 | 2043| options | [HuksOptions](#huksoptions) | 是 | 用于存放生成key所需TAG。 | 2044 2045**返回值**： 2046 2047| 类型 | 说明 | 2048| ----------------------------------- | -------------------------------------------------- | 2049| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2050 2051**示例：** 2052 2053```js 2054/* 以生成ECC256密钥为例 */ 2055let keyAlias = 'keyAlias'; 2056let properties = new Array(); 2057properties[0] = { 2058 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2059 value: huks.HuksKeyAlg.HUKS_ALG_ECC 2060}; 2061properties[1] = { 2062 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2063 value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256 2064}; 2065properties[2] = { 2066 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2067 value: 2068huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN | 2069huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY 2070}; 2071properties[3] = { 2072 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2073 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2074}; 2075let options = { 2076 properties: properties 2077}; 2078let result = huks.generateKey(keyAlias, options); 2079``` 2080 2081## huks.deleteKey<sup>(deprecated)</sup> 2082 2083deleteKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2084 2085删除密钥，使用Callback回调异步返回结果。 2086 2087> **说明：** 从API Version 9开始废弃，建议使用[huks.deleteKeyItem<sup>9+</sup>](#huksdeletekeyitem9)替代。 2088 2089**系统能力**：SystemCapability.Security.Huks 2090 2091**参数：** 2092 2093| 参数名 | 类型 | 必填 | 说明 | 2094| -------- | ----------------------------------------- | ---- | -------------------------------------------------- | 2095| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 2096| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2097| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2098 2099**示例：** 2100 2101```js 2102/* 此处options选择emptyOptions传空 */ 2103let keyAlias = 'keyAlias'; 2104let emptyOptions = { 2105 properties: [] 2106}; 2107huks.deleteKey(keyAlias, emptyOptions, function (err, data) {}); 2108``` 2109 2110## huks.deleteKey<sup>(deprecated)</sup> 2111 2112deleteKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 2113 2114删除密钥，使用Promise方式异步返回结果。 2115 2116> **说明：** 从API Version 9开始废弃，建议使用[huks.deleteKeyItem<sup>9+</sup>](#huksdeletekeyitem9-1)替代。 2117 2118**系统能力**：SystemCapability.Security.Huks 2119 2120**参数：** 2121 2122| 参数名 | 类型 | 必填 | 说明 | 2123| -------- | ----------- | ---- | ----------------------------------------------------- | 2124| keyAlias | string | 是 | 密钥别名，应为生成key时传入的别名。 | 2125| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2126 2127**返回值：** 2128 2129| 类型 | 说明 | 2130| ----------------------------------- | -------------------------------------------------- | 2131| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2132 2133**示例：** 2134 2135```js 2136/* 此处options选择emptyOptions传空 */ 2137let keyAlias = 'keyAlias'; 2138let emptyOptions = { 2139 properties: [] 2140}; 2141let result = huks.deleteKey(keyAlias, emptyOptions); 2142``` 2143 2144## huks.importKey<sup>(deprecated)</sup> 2145 2146importKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2147 2148导入明文密钥，使用Callback方式回调异步返回结果 。 2149 2150> **说明：** 从API Version 9开始废弃，建议使用[huks.importKeyItem<sup>9+</sup>](#huksimportkeyitem9)替代。 2151 2152**系统能力**：SystemCapability.Security.Huks 2153 2154**参数：** 2155 2156| 参数名 | 类型 | 必填 | 说明 | 2157| -------- | ------------------------ | ---- | ------------------------------------------------- | 2158| keyAlias | string | 是 | 密钥别名。 | 2159| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。 | 2160| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2161 2162**示例：** 2163 2164```js 2165/* 以导入AES256密钥为例 */ 2166let plainTextSize32 = makeRandomArr(32); 2167function makeRandomArr(size) { 2168 let arr = new Uint8Array(size); 2169 for (let i = 0; i < size; i++) { 2170 arr[i] = Math.floor(Math.random() * 10); 2171 } 2172 return arr; 2173}; 2174let keyAlias = 'keyAlias'; 2175let properties = new Array(); 2176properties[0] = { 2177 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2178 value: huks.HuksKeyAlg.HUKS_ALG_AES 2179}; 2180properties[1] = { 2181 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2182 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 2183}; 2184properties[2] = { 2185 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2186 value: 2187huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 2188}; 2189properties[3] = { 2190 tag: huks.HuksTag.HUKS_TAG_PADDING, 2191 value:huks.HuksKeyPadding.HUKS_PADDING_PKCS7 2192}; 2193properties[4] = { 2194 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2195 value: huks.HuksCipherMode.HUKS_MODE_ECB 2196}; 2197let options = { 2198 properties: properties, 2199 inData: plainTextSize32 2200}; 2201huks.importKey(keyAlias, options, function (err, data){}); 2202``` 2203 2204## huks.importKey<sup>(deprecated)</sup> 2205 2206importKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 2207 2208导入明文密钥，使用Promise方式异步返回结果。 2209 2210> **说明：** 从API Version 9开始废弃，建议使用[huks.importKeyItem<sup>9+</sup>](#huksimportkeyitem9-1)替代。 2211 2212**系统能力**：SystemCapability.Security.Huks 2213 2214**参数：** 2215 2216| 参数名 | 类型 | 必填 | 说明 | 2217| -------- | ----------- | ---- | ------------------------------------ | 2218| keyAlias | string | 是 | 密钥别名。 | 2219| options | [HuksOptions](#huksoptions) | 是 | 用于导入时所需TAG和需要导入的密钥。 | 2220 2221**返回值：** 2222 2223| 类型 | 说明 | 2224| ----------------------------------- | -------------------------------------------------- | 2225| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2226 2227**示例：** 2228 2229```js 2230/* 以导入AES128为例 */ 2231let plainTextSize32 = makeRandomArr(32); 2232 2233function makeRandomArr(size) { 2234 let arr = new Uint8Array(size); 2235 for (let i = 0; i < size; i++) { 2236 arr[i] = Math.floor(Math.random() * 10); 2237 } 2238 return arr; 2239}; 2240 2241/*第一步：生成密钥*/ 2242let keyAlias = 'keyAlias'; 2243let properties = new Array(); 2244properties[0] = { 2245 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2246 value: huks.HuksKeyAlg.HUKS_ALG_AES 2247}; 2248properties[1] = { 2249 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2250 value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_128 2251}; 2252properties[2] = { 2253 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2254 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT 2255}; 2256properties[3] = { 2257 tag: huks.HuksTag.HUKS_TAG_PADDING, 2258 value:huks.HuksKeyPadding.HUKS_PADDING_PKCS7 2259}; 2260properties[4] = { 2261 tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, 2262 value: huks.HuksCipherMode.HUKS_MODE_ECB 2263}; 2264let huksoptions = { 2265 properties: properties, 2266 inData: plainTextSize32 2267}; 2268let result = huks.importKey(keyAlias, huksoptions); 2269``` 2270 2271## huks.exportKey<sup>(deprecated)</sup> 2272 2273exportKey(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2274 2275导出密钥，使用Callback方式回调异步返回的结果。 2276 2277> **说明：** 从API Version 9开始废弃，建议使用[huks.exportKeyItem<sup>9+</sup>](#huksexportkeyitem9)替代。 2278 2279**系统能力**：SystemCapability.Security.Huks 2280 2281**参数：** 2282 2283| 参数名 | 类型 | 必填 | 说明 | 2284| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2285| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 2286| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2287| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 2288 2289**示例：** 2290 2291```js 2292/* 此处options选择emptyOptions来传空 */ 2293let keyAlias = 'keyAlias'; 2294let emptyOptions = { 2295 properties: [] 2296}; 2297huks.exportKey(keyAlias, emptyOptions, function (err, data){}); 2298``` 2299 2300## huks.exportKey<sup>(deprecated)</sup> 2301 2302exportKey(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 2303 2304导出密钥，使用Promise方式回调异步返回的结果。 2305 2306> **说明：** 从API Version 9开始废弃，建议使用[huks.exportKeyItem<sup>9+</sup>](#huksexportkeyitem9-1))替代。 2307 2308**系统能力**：SystemCapability.Security.Huks 2309 2310**参数：** 2311 2312| 参数名 | 类型 | 必填 | 说明 | 2313| -------- | ----------- | ---- | ------------------------------------------------------------ | 2314| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 2315| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2316 2317**返回值：** 2318 2319| 类型 | 说明 | 2320| ----------------------------------- | ------------------------------------------------------------ | 2321| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。 | 2322 2323**示例：** 2324 2325```js 2326/* 此处options选择emptyOptions来传空 */ 2327let keyAlias = 'keyAlias'; 2328let emptyOptions = { 2329 properties: [] 2330}; 2331let result = huks.exportKey(keyAlias, emptyOptions); 2332``` 2333 2334## huks.getKeyProperties<sup>(deprecated)</sup> 2335 2336getKeyProperties(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2337 2338获取密钥属性，使用Callback回调异步返回结果。 2339 2340> **说明：** 从API Version 9开始废弃，建议使用[huks.getKeyItemProperties<sup>9+</sup>](#huksgetkeyitemproperties9)替代。 2341 2342**系统能力**：SystemCapability.Security.Huks 2343 2344**参数：** 2345 2346| 参数名 | 类型 | 必填 | 说明 | 2347| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2348| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 2349| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2350| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。errorCode：返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。 | 2351 2352**示例：** 2353 2354```js 2355/* 此处options选择emptyOptions来传空 */ 2356let keyAlias = 'keyAlias'; 2357let emptyOptions = { 2358 properties: [] 2359}; 2360huks.getKeyProperties(keyAlias, emptyOptions, function (err, data){}); 2361``` 2362 2363## huks.getKeyProperties<sup>(deprecated)</sup> 2364 2365getKeyProperties(keyAlias: string, options: HuksOptions) : Promise\<HuksResult> 2366 2367获取密钥属性，使用Promise回调异步返回结果。 2368 2369> **说明：** 从API Version 9开始废弃，建议使用[huks.getKeyItemProperties<sup>9+</sup>](#huksgetkeyitemproperties9-1)替代。 2370 2371**系统能力**：SystemCapability.Security.Huks 2372 2373**参数：** 2374 2375| 参数名 | 类型 | 必填 | 说明 | 2376| -------- | ----------- | ---- | ------------------------------------------------------------ | 2377| keyAlias | string | 是 | 密钥别名，应与所用密钥生成时使用的别名相同。 | 2378| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2379 2380**返回值：** 2381 2382| 类型 | 说明 | 2383| ------------------ | ------------------------------------------------------------ | 2384| Promise\<[HuksResult](#huksoptions)> | Promise对象。errorCode：返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。properties：返回值为生成密钥时所需参数。 | 2385 2386**示例：** 2387 2388```js 2389/* 此处options选择emptyOptions来传空 */ 2390let keyAlias = 'keyAlias'; 2391let emptyOptions = { 2392 properties: [] 2393}; 2394let result = huks.getKeyProperties(keyAlias, emptyOptions); 2395``` 2396 2397## huks.isKeyExist<sup>(deprecated)</sup> 2398 2399isKeyExist(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<boolean>) : void 2400 2401判断密钥是否存在，使用Callback回调异步返回结果 。 2402 2403> **说明：** 从API Version 9开始废弃，建议使用[huks.isKeyItemExist<sup>9+</sup>](#huksiskeyitemexist9)替代。 2404 2405**系统能力**：SystemCapability.Security.Huks 2406 2407**参数：** 2408 2409| 参数名 | 类型 | 必填 | 说明 | 2410| -------- | ---------------------- | ---- | ------------------------------------- | 2411| keyAlias | string | 是 | 所需查找的密钥的别名。 | 2412| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2413| callback | AsyncCallback\<boolean> | 是 | 回调函数。FALSE代表密钥不存在，TRUE代表密钥存在。 | 2414 2415**示例：** 2416 2417```js 2418/* 此处options选择emptyOptions来传空 */ 2419let keyAlias = 'keyAlias'; 2420let emptyOptions = { 2421 properties: [] 2422}; 2423huks.isKeyExist(keyAlias, emptyOptions, function (err, data){}); 2424``` 2425 2426## huks.isKeyExist<sup>(deprecated)</sup> 2427 2428isKeyExist(keyAlias: string, options: HuksOptions) : Promise\<boolean> 2429 2430判断密钥是否存在，使用Promise回调异步返回结果 。 2431 2432> **说明：** 从API Version 9开始废弃，建议使用[huks.isKeyItemExist<sup>9+</sup>](#huksiskeyitemexist9-1)替代。 2433 2434**系统能力**：SystemCapability.Security.Huks 2435 2436**参数：** 2437 2438| 参数名 | 类型 | 必填 | 说明 | 2439| -------- | ----------- | ---- | -------------------------------- | 2440| keyAlias | string | 是 | 所需查找的密钥的别名。 | 2441| options | [HuksOptions](#huksoptions) | 是 | 空对象（此处传空即可）。 | 2442 2443**返回值：** 2444 2445| 类型 | 说明 | 2446| ----------------- | --------------------------------------- | 2447| Promise\<boolean> | Promise对象。FALSE代表密钥不存在，TRUE代表密钥存在。 | 2448 2449**示例：** 2450 2451```js 2452/* 此处options选择emptyOptions来传空 */ 2453let keyAlias = 'keyAlias'; 2454let emptyOptions = { 2455 properties: [] 2456}; 2457let result = huks.isKeyExist(keyAlias, emptyOptions); 2458``` 2459 2460## huks.init<sup>(deprecated)</sup> 2461 2462init(keyAlias: string, options: HuksOptions, callback: AsyncCallback\<HuksHandle>) : void 2463 2464init操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2465 2466> **说明：** 从API Version 9开始废弃，建议使用[huks.initSession<sup>9+</sup>](#huksinitsession9-1)替代。 2467 2468**系统能力**：SystemCapability.Security.Huks 2469 2470**参数：** 2471 2472| 参数名 | 类型 | 必填 | 说明 | 2473| -------- | ---------------------- | ---- | ------------------------------------- | 2474| keyAlias | string | 是 | Init操作密钥的别名。 | 2475| options | [HuksOptions](#huksoptions) | 是 | Init操作的参数集合。 | 2476| callback | AsyncCallback\<[HuksHandle](#hukshandledeprecated)> | 是 | 回调函数。将Init操作操作返回的handle添加到密钥管理系统的回调。 | 2477 2478## huks.init<sup>(deprecated)</sup> 2479 2480init(keyAlias: string, options: HuksOptions) : Promise\<HuksHandle> 2481 2482init操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2483 2484> **说明：** 从API Version 9开始废弃，建议使用[huks.initSession<sup>9+</sup>](#huksinitsession9-1)替代。 2485 2486**系统能力**：SystemCapability.Security.Huks 2487 2488**参数：** 2489 2490| 参数名 | 类型 | 必填 | 说明 | 2491| -------- | ---------------------- | ---- | ------------------------------------- | 2492| keyAlias | string | 是 | Init操作密钥的别名。 | 2493| options | [HuksOptions](#huksoptions) | 是 | Init参数集合。 | 2494 2495**返回值**： 2496 2497| 类型 | 说明 | 2498| ----------------------------------- | -------------------------------------------------- | 2499| Promise\<[HuksHandle](#hukshandledeprecated)> | Promise对象。将Init操作返回的handle添加到密钥管理系统的回调。 | 2500 2501## huks.update<sup>(deprecated)</sup> 2502 2503update(handle: number, token?: Uint8Array, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2504 2505update操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2506 2507> **说明：** 从API Version 9开始废弃，建议使用[huks.updateSession<sup>9+</sup>](#huksupdatesession9-1)替代。 2508 2509**系统能力**： SystemCapability.Security.Huks 2510 2511**参数：** 2512 2513| 参数名 | 类型 | 必填 | 说明 | 2514| -------- | ----------------------------------------- | ---- | -------------------------------------------- | 2515| handle | number | 是 | Update操作的handle。 | 2516| token | Uint8Array | 否 | Update操作的token。 | 2517| options | [HuksOptions](#huksoptions) | 是 | Update操作的参数集合。 | 2518| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Update操作的结果添加到密钥管理系统的回调。 | 2519 2520## huks.update<sup>(deprecated)</sup> 2521 2522update(handle: number, token?: Uint8Array, options: HuksOptions) : Promise\<HuksResult>; 2523 2524update操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2525 2526> **说明：** 从API Version 9开始废弃，建议使用[huks.updateSession<sup>9+</sup>](#huksupdatesession9-2)替代。 2527 2528**系统能力**： SystemCapability.Security.Huks 2529 2530**参数：** 2531 2532| 参数名 | 类型 | 必填 | 说明 | 2533| ------- | ----------------------------------- | ---- | -------------------------------------------- | 2534| handle | number | 是 | Update操作的handle。 | 2535| token | Uint8Array | 否 | Update操作的token。 | 2536| options | [HuksOptions](#huksoptions) | 是 | Update操作的参数集合。 | 2537 2538**返回值**： 2539 2540| 类型 | 说明 | 2541| ----------------------------------- | -------------------------------------------------- | 2542| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。将Update操作的结果添加到密钥管理系统的回调。 | 2543 2544## huks.finish<sup>(deprecated)</sup> 2545 2546finish(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2547 2548finish操作密钥接口，使用Callback回调异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2549 2550> **说明：** 从API Version 9开始废弃，建议使用[huks.finishSession<sup>9+</sup>](#huksfinishsession9)替代。 2551 2552**系统能力**：SystemCapability.Security.Huks 2553 2554**参数：** 2555 2556| 参数名 | 类型 | 必填 | 说明 | 2557| -------- | ---------------------- | ---- | ------------------------------------- | 2558| handle | number | 是 | Finish操作的handle。 | 2559| options | [HuksOptions](#huksoptions) | 是 | Finish的参数集合。 | 2560| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Finish操作的结果添加到密钥管理系统的回调。 | 2561 2562## huks.finish<sup>(deprecated)</sup> 2563 2564finish(handle: number, options: HuksOptions) : Promise\<HuksResult> 2565 2566finish操作密钥接口，使用Promise方式异步返回结果。huks.init, huks.update, huks.finish为三段式接口，需要一起使用。 2567 2568> **说明：** 从API Version 9开始废弃，建议使用[huks.finishSession<sup>9+</sup>](#huksfinishsession9-1)替代。 2569 2570**系统能力**：SystemCapability.Security.Huks 2571 2572**参数：** 2573 2574| 参数名 | 类型 | 必填 | 说明 | 2575| -------- | ---------------------- | ---- | ------------------------------------- | 2576| handle | number | 是 | Finish操作的handle。 | 2577| options | [HuksOptions](#huksoptions) | 是 | Finish操作的参数集合。 | 2578 2579**返回值**： 2580 2581| 类型 | 说明 | 2582| ----------------------------------- | -------------------------------------------------- | 2583| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象，用于获取异步返回结果。 | 2584 2585## huks.abort<sup>(deprecated)</sup> 2586 2587abort(handle: number, options: HuksOptions, callback: AsyncCallback\<HuksResult>) : void 2588 2589abort操作密钥接口，使用Callback回调异步返回结果。 2590 2591> **说明：** 从API Version 9开始废弃，建议使用[huks.abortSession<sup>9+</sup>](#huksabortsession9)替代。 2592 2593**系统能力**：SystemCapability.Security.Huks 2594 2595**参数：** 2596 2597| 参数名 | 类型 | 必填 | 说明 | 2598| -------- | ---------------------- | ---- | ------------------------------------- | 2599| handle | number | 是 | Abort操作的handle。 | 2600| options | [HuksOptions](#huksoptions) | 是 | Abort操作的参数集合。 | 2601| callback | AsyncCallback\<[HuksResult](#huksresultdeprecated)> | 是 | 回调函数。将Abort操作的结果添加到密钥管理系统的回调。 | 2602 2603**示例：** 2604 2605```js 2606/* huks.init, huks.update, huks.finish为三段式接口，需要一起使用，当huks.init和huks.update 2607 * 以及huks.finish操作中的任一阶段发生错误时，都需要调用huks.abort来终止密钥的使用。 2608 * 2609 * 以下以RSA1024密钥的callback操作使用为例 2610 */ 2611let keyalias = "HuksDemoRSA"; 2612let properties = new Array(); 2613let options = { 2614 properties: properties, 2615 inData: new Uint8Array(0) 2616}; 2617let handle; 2618let resultMessage = ""; 2619async function generateKey() { 2620 properties[0] = { 2621 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2622 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2623 }; 2624 properties[1] = { 2625 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2626 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_1024 2627 }; 2628 properties[2] = { 2629 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2630 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2631 }; 2632 properties[3] = { 2633 tag: huks.HuksTag.HUKS_TAG_PADDING, 2634 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 2635 }; 2636 properties[4] = { 2637 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2638 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2639 }; 2640 huks.generateKey(keyalias, options); 2641} 2642function stringToUint8Array(str) { 2643 let arr = []; 2644 for (let i = 0, j = str.length; i < j; ++i) { 2645 arr.push(str.charCodeAt(i)); 2646 } 2647 let tmpUint8Array = new Uint8Array(arr); 2648 return tmpUint8Array; 2649} 2650async function huksInit() { 2651 await huks.init(keyalias, options).then((data) => { 2652 console.log(`test init data: ${JSON.stringify(data)}`); 2653 handle = data.handle; 2654 }).catch((err) => { 2655 console.log("test init err information: " + JSON.stringify(err)) 2656 }) 2657} 2658async function huksUpdate() { 2659 options.inData = stringToUint8Array("huksHmacTest"); 2660 await huks.update(handle, options).then((data) => { 2661 if (data.errorCode === 0) { 2662 resultMessage += "update success!"; 2663 } else { 2664 resultMessage += "update fail!"; 2665 } 2666 }); 2667 console.log(resultMessage); 2668} 2669function huksFinish() { 2670 options.inData = stringToUint8Array("HuksDemoHMAC"); 2671 huks.finish(handle, options).then((data) => { 2672 if (data.errorCode === 0) { 2673 resultMessage = "finish success!"; 2674 } else { 2675 resultMessage = "finish fail errorCode: " + data.errorCode; 2676 } 2677 }).catch((err) => { 2678 resultMessage = "finish fail， catch errorMessage:" + JSON.stringify(err) 2679 }); 2680 console.log(resultMessage); 2681} 2682async function huksAbort() { 2683 huks.abort(handle, options).then((data) => { 2684 if (data.errorCode === 0) { 2685 resultMessage = "abort success!"; 2686 } else { 2687 resultMessage = "abort fail errorCode: " + data.errorCode; 2688 } 2689 }).catch((err) => { 2690 resultMessage = "abort fail， catch errorMessage:" + JSON.stringify(err) 2691 }); 2692 console.log(resultMessage); 2693} 2694``` 2695 2696## huks.abort<sup>(deprecated)</sup> 2697 2698abort(handle: number, options: HuksOptions) : Promise\<HuksResult>; 2699 2700abort操作密钥接口，使用Promise方式异步返回结果。 2701 2702> **说明：** 从API Version 9开始废弃，建议使用[huks.abortSession<sup>9+</sup>](#huksabortsession9-1)替代。 2703 2704**系统能力**：SystemCapability.Security.Huks 2705 2706**参数：** 2707 2708| 参数名 | 类型 | 必填 | 说明 | 2709| -------- | ---------------------- | ---- | ------------------------------------- | 2710| handle | number | 是 | Abort操作的handle。 | 2711| options | [HuksOptions](#huksoptions) | 是 | Abort操作的参数集合。 | 2712 2713**返回值**： 2714 2715| 类型 | 说明 | 2716| ----------------------------------- | -------------------------------------------------- | 2717| Promise\<[HuksResult](#huksresultdeprecated)> | Promise对象。将Abort操作的结果添加到密钥管理系统的回调。 | 2718 2719**示例：** 2720 2721```js 2722/* huks.init, huks.update, huks.finish为三段式接口，需要一起使用，当huks.init和huks.update 2723 * 以及huks.finish操作中的任一阶段发生错误时，都需要调用huks.abort来终止密钥的使用。 2724 * 2725 * 以下以RSA1024密钥的promise操作使用为例 2726 */ 2727let keyalias = "HuksDemoRSA"; 2728let properties = new Array(); 2729let options = { 2730 properties: properties, 2731 inData: new Uint8Array(0) 2732}; 2733let handle; 2734let resultMessage = ""; 2735function stringToUint8Array(str) { 2736 let arr = []; 2737 for (let i = 0, j = str.length; i < j; ++i) { 2738 arr.push(str.charCodeAt(i)); 2739 } 2740 let tmpUint8Array = new Uint8Array(arr); 2741 return tmpUint8Array; 2742} 2743 2744async function generateKey() { 2745 properties[0] = { 2746 tag: huks.HuksTag.HUKS_TAG_ALGORITHM, 2747 value: huks.HuksKeyAlg.HUKS_ALG_RSA 2748 }; 2749 properties[1] = { 2750 tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, 2751 value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_1024 2752 }; 2753 properties[2] = { 2754 tag: huks.HuksTag.HUKS_TAG_PURPOSE, 2755 value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT 2756 }; 2757 properties[3] = { 2758 tag: huks.HuksTag.HUKS_TAG_PADDING, 2759 value: huks.HuksKeyPadding.HUKS_PADDING_OAEP 2760 }; 2761 properties[4] = { 2762 tag: huks.HuksTag.HUKS_TAG_DIGEST, 2763 value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256 2764 }; 2765 huks.generateKey(keyalias, options, function (err, data) { }); 2766} 2767async function huksInit() { 2768 return new Promise((resolve, reject) => { 2769 huks.init(keyalias, options, async function (err, data) { 2770 if (data.errorCode === 0) { 2771 resultMessage = "init success!" 2772 handle = data.handle; 2773 } else { 2774 resultMessage = "init fail errorCode: " + data.errorCode 2775 } 2776 }); 2777 }); 2778} 2779 2780async function huksUpdate() { 2781 options.inData = stringToUint8Array("huksHmacTest"); 2782 new Promise((resolve, reject) => { 2783 huks.update(handle, options, function (err, data) { 2784 if (data.errorCode === 0) { 2785 resultMessage += "update success!"; 2786 } else { 2787 resultMessage += "update fail!"; 2788 } 2789 }); 2790 }); 2791 console.log(resultMessage); 2792 2793} 2794 2795async function huksFinish() { 2796 options.inData = stringToUint8Array("0"); 2797 new Promise((resolve, reject) => { 2798 huks.finish(handle, options, function (err, data) { 2799 if (data.errorCode === 0) { 2800 resultMessage = "finish success!"; 2801 } else { 2802 resultMessage = "finish fail errorCode: " + data.errorCode; 2803 } 2804 }); 2805 }); 2806} 2807 2808function huksAbort() { 2809 new Promise((resolve, reject) => { 2810 huks.abort(handle, options, function (err, data) { 2811 console.log(`Huks_Demo hmac huksAbort1 data ${JSON.stringify(data)}`); 2812 console.log(`Huks_Demo hmac huksAbort1 err ${JSON.stringify(err)}`); 2813 }); 2814 }); 2815} 2816``` 2817 2818## HuksHandle<sup>(deprecated)</sup> 2819 2820huks Handle结构体。 2821 2822**系统能力**：SystemCapability.Security.Huks 2823 2824| 名称 | 类型 | 必填 | 说明 | 2825| ---------- | ---------------- | ---- | -------- | 2826| errorCode | number | 是 | 表示错误码。 | 2827| handle | number | 是 | 表示handle值。 | 2828| token | Uint8Array | 否 | 表示[init](#huksinitdeprecated)操作之后获取到的challenge信息。 | 2829 2830## HuksResult<sup>(deprecated)</sup> 2831 2832调用接口返回的result。 2833 2834**系统能力**：SystemCapability.Security.Huks 2835 2836| 名称 | 类型 | 必填 | 说明 | 2837| ---------- | ------------------------------- | ---- | ---------------- | 2838| errorCode | number | 是 | 表示错误码。 | 2839| outData | Uint8Array | 否 | 表示输出数据。 | 2840| properties | Array\<[HuksParam](#huksparam)> | 否 | 表示属性信息。 | 2841| certChains | Array\<string> | 否 | 表示证书链数据。 | 2842 2843 2844## HuksErrorCode<sup>(deprecated)</sup> 2845 2846表示错误码的枚举。 2847 2848**系统能力**：SystemCapability.Security.Huks 2849 2850| 名称 | 值 | 说明 | 2851| -------------------------- | ----- | ---- | 2852| HUKS_SUCCESS | 0 |表示成功。| 2853| HUKS_FAILURE | -1 |表示失败。| 2854| HUKS_ERROR_BAD_STATE | -2 |表示错误的状态。| 2855| HUKS_ERROR_INVALID_ARGUMENT | -3 |表示无效的数据。| 2856| HUKS_ERROR_NOT_SUPPORTED | -4 |表示不支持。| 2857| HUKS_ERROR_NO_PERMISSION | -5 |表示没有许可。| 2858| HUKS_ERROR_INSUFFICIENT_DATA | -6 |表示数据不足。| 2859| HUKS_ERROR_BUFFER_TOO_SMALL | -7 |表示缓冲区太小。| 2860| HUKS_ERROR_INSUFFICIENT_MEMORY | -8 |表示内存不足。| 2861| HUKS_ERROR_COMMUNICATION_FAILURE | -9 |表示通讯失败。| 2862| HUKS_ERROR_STORAGE_FAILURE | -10 |表示存储故障。| 2863| HUKS_ERROR_HARDWARE_FAILURE | -11 |表示硬件故障。| 2864| HUKS_ERROR_ALREADY_EXISTS | -12 |表示已经存在。| 2865| HUKS_ERROR_NOT_EXIST | -13 |表示不存在。| 2866| HUKS_ERROR_NULL_POINTER | -14 |表示空指针。| 2867| HUKS_ERROR_FILE_SIZE_FAIL | -15 |表示文件大小失败。| 2868| HUKS_ERROR_READ_FILE_FAIL | -16 |表示读取文件失败。| 2869| HUKS_ERROR_INVALID_PUBLIC_KEY | -17 |表示无效的公钥。| 2870| HUKS_ERROR_INVALID_PRIVATE_KEY | -18 |表示无效的私钥。| 2871| HUKS_ERROR_INVALID_KEY_INFO | -19 |表示无效的密钥信息。| 2872| HUKS_ERROR_HASH_NOT_EQUAL | -20 |表示哈希不相等。| 2873| HUKS_ERROR_MALLOC_FAIL | -21 |表示MALLOC 失败。| 2874| HUKS_ERROR_WRITE_FILE_FAIL | -22 |表示写文件失败。| 2875| HUKS_ERROR_REMOVE_FILE_FAIL | -23 |表示删除文件失败。| 2876| HUKS_ERROR_OPEN_FILE_FAIL | -24 |表示打开文件失败。| 2877| HUKS_ERROR_CLOSE_FILE_FAIL | -25 |表示关闭文件失败。| 2878| HUKS_ERROR_MAKE_DIR_FAIL | -26 |表示创建目录失败。| 2879| HUKS_ERROR_INVALID_KEY_FILE | -27 |表示无效的密钥文件。| 2880| HUKS_ERROR_IPC_MSG_FAIL | -28 |表示IPC 信息失败。| 2881| HUKS_ERROR_REQUEST_OVERFLOWS | -29 |表示请求溢出。| 2882| HUKS_ERROR_PARAM_NOT_EXIST | -30 |表示参数不存在。| 2883| HUKS_ERROR_CRYPTO_ENGINE_ERROR | -31 |表示CRYPTO ENGINE错误。| 2884| HUKS_ERROR_COMMUNICATION_TIMEOUT | -32 |表示通讯超时。| 2885| HUKS_ERROR_IPC_INIT_FAIL | -33 |表示IPC 初始化失败。| 2886| HUKS_ERROR_IPC_DLOPEN_FAIL | -34 |表示IPC DLOPEN 失败。| 2887| HUKS_ERROR_EFUSE_READ_FAIL | -35 |表示EFUSE 读取失败。| 2888| HUKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST | -36 |表示存在新的根密钥材料。| 2889| HUKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL | -37 |表示更新根密钥材料失败。| 2890| HUKS_ERROR_VERIFICATION_FAILED | -38 |表示验证证书链失败。| 2891| HUKS_ERROR_CHECK_GET_ALG_FAIL | -100 |表示检查获取 ALG 失败。| 2892| HUKS_ERROR_CHECK_GET_KEY_SIZE_FAIL | -101 |表示检查获取密钥大小失败。| 2893| HUKS_ERROR_CHECK_GET_PADDING_FAIL | -102 |表示检查获取填充失败。| 2894| HUKS_ERROR_CHECK_GET_PURPOSE_FAIL | -103 |表示检查获取目的失败。| 2895| HUKS_ERROR_CHECK_GET_DIGEST_FAIL | -104 |表示检查获取摘要失败。| 2896| HUKS_ERROR_CHECK_GET_MODE_FAIL | -105 |表示检查获取模式失败。| 2897| HUKS_ERROR_CHECK_GET_NONCE_FAIL | -106 |表示检查获取随机数失败。| 2898| HUKS_ERROR_CHECK_GET_AAD_FAIL | -107 |表示检查获取 AAD 失败。| 2899| HUKS_ERROR_CHECK_GET_IV_FAIL | -108 |表示检查 GET IV 失败。| 2900| HUKS_ERROR_CHECK_GET_AE_TAG_FAIL | -109 |表示检查获取 AE 标记失败。| 2901| HUKS_ERROR_CHECK_GET_SALT_FAIL | -110 |表示检查获取SALT失败。| 2902| HUKS_ERROR_CHECK_GET_ITERATION_FAIL | -111 |表示检查获取迭代失败。| 2903| HUKS_ERROR_INVALID_ALGORITHM | -112 |表示无效的算法。| 2904| HUKS_ERROR_INVALID_KEY_SIZE | -113 |表示无效的密钥大小。| 2905| HUKS_ERROR_INVALID_PADDING | -114 |表示无效的填充。| 2906| HUKS_ERROR_INVALID_PURPOSE | -115 |表示无效的目的。| 2907| HUKS_ERROR_INVALID_MODE | -116 |表示无效模式。| 2908| HUKS_ERROR_INVALID_DIGEST | -117 |表示无效的摘要。| 2909| HUKS_ERROR_INVALID_SIGNATURE_SIZE | -118 |表示签名大小无效。| 2910| HUKS_ERROR_INVALID_IV | -119 |表示无效的 IV。| 2911| HUKS_ERROR_INVALID_AAD | -120 |表示无效的 AAD。| 2912| HUKS_ERROR_INVALID_NONCE | -121 |表示无效的随机数。| 2913| HUKS_ERROR_INVALID_AE_TAG | -122 |表示无效的 AE 标签。| 2914| HUKS_ERROR_INVALID_SALT | -123 |表示无效SALT。| 2915| HUKS_ERROR_INVALID_ITERATION | -124 |表示无效的迭代。| 2916| HUKS_ERROR_INVALID_OPERATION | -125 |表示无效操作。| 2917| HUKS_ERROR_INTERNAL_ERROR | -999 |表示内部错误。| 2918| HUKS_ERROR_UNKNOWN_ERROR | -1000 |表示未知错误。|