HarmonyOSAPI：@ohos.security.huks (通用密钥库系统)

joytrian

发布于 2023-4-4 16:27

浏览

0收藏

版本：v3.1 Beta

@ohos.security.huks (通用密钥库系统)

更新时间: 2023-03-10 16:42

向应用提供密钥库能力，包括密钥管理及密钥的密码学操作等功能。

HUKS所管理的密钥可以由应用导入或者由应用调用HUKS接口生成。

说明

本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。

导入模块

import huks from '@ohos.security.huks'

HuksParam

调用接口使用的options中的properties数组中的param。

系统能力：SystemCapability.Security.Huks

名称	类型	必填	说明
tag	HuksTag	是	标签。
value	boolean\|number\|bigint\|Uint8Array	是	标签对应值。

HuksOptions

调用接口使用的options。

系统能力：SystemCapability.Security.Huks

名称	类型	必填	说明
properties	Array<HuksParam>	否	属性，用于存HuksParam的数组。
inData	Uint8Array	否	输入数据。

HuksSessionHandle⁹⁺

huks Handle结构体。

系统能力：SystemCapability.Security.Huks

名称	类型	必填	说明
handle	number	是	表示handle值。
challenge	Uint8Array	否	表示init操作之后获取到的challenge信息。

HuksReturnResult⁹⁺

调用接口返回的result。

系统能力：SystemCapability.Security.Huks

名称	类型	必填	说明
outData	Uint8Array	否	表示输出数据。
properties	Array<HuksParam>	否	表示属性信息。
certChains	Array<string>	否	表示证书链数据。

huks.generateKeyItem⁹⁺

generateKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback<void>) : void

生成密钥，使用Callback回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	别名。
options	HuksOptions	是	用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。
callback	AsyncCallback<void>	是	回调函数。不返回err值时表示接口使用成功，其他时为错误。

示例：

/* 以生成ECC256密钥为例 */
let keyAlias = 'keyAlias';
let properties = new Array();
properties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_ECC
};
properties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256
};
properties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value:
    huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN |
    huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY
};
properties[3] = {
    tag: huks.HuksTag.HUKS_TAG_DIGEST,
    value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
};
let options = {
    properties: properties
};
try {
    huks.generateKeyItem(keyAlias, options, function (error, data) {
        if (error) {
            console.error(`callback: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        } else {
            console.info(`callback: generateKeyItem key success`);
        }
    });
} catch (error) {
    console.error(`callback: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.generateKeyItem⁹⁺

generateKeyItem(keyAlias: string, options: HuksOptions) : Promise<void>

生成密钥，使用Promise方式异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名。
options	HuksOptions	是	用于存放生成key所需TAG。其中密钥使用的算法、密钥用途、密钥长度为必选参数。

示例：

/* 以生成ECC256密钥为例 */
let keyAlias = 'keyAlias';
let properties = new Array();
properties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_ECC
};
properties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256
};
properties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value:
    huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_SIGN |
    huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_VERIFY
};
properties[3] = {
    tag: huks.HuksTag.HUKS_TAG_DIGEST,
    value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
};
let options = {
    properties: properties
};
try {
    huks.generateKeyItem(keyAlias, options)
        .then((data) => {
            console.info(`promise: generateKeyItem success`);
        })
        .catch(error => {
            console.error(`promise: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.deleteKeyItem⁹⁺

deleteKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback<void>) : void

删除密钥，使用Callback回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应为生成key时传入的别名。
options	HuksOptions	是	空对象（此处传空即可）。
callback	AsyncCallback<void>	是	回调函数。不返回err值时表示接口使用成功，其他时为错误。

示例：

/* 此处options选择emptyOptions传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.deleteKeyItem(keyAlias, emptyOptions, function (error, data) {
        if (error) {
            console.error(`callback: deleteKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        } else {
            console.info(`callback: deleteKeyItem key success`);
        }
    });
} catch (error) {
    console.error(`callback: deleteKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.deleteKeyItem⁹⁺

deleteKeyItem(keyAlias: string, options: HuksOptions) : Promise<void>

删除密钥，使用Promise方式异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应为生成key时传入的别名。
options	HuksOptions	是	空对象（此处传空即可）。

示例：

/* 此处options选择emptyOptions传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.deleteKeyItem(keyAlias, emptyOptions)
        .then ((data) => {
            console.info(`promise: deleteKeyItem key success`);
        })
        .catch(error => {
            console.error(`promise: deleteKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: deleteKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.getSdkVersion

getSdkVersion(options: HuksOptions) : string

获取当前系统sdk版本。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
options	HuksOptions	是	空对象，用于存放sdk版本。

返回值：

类型	说明
string	返回sdk版本。

示例：

/* 此处options选择emptyOptions传空 */
let emptyOptions = {
  properties: []
};
let result = huks.getSdkVersion(emptyOptions);

huks.importKeyItem⁹⁺

importKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback<void>) : void

导入明文密钥，使用Callback方式回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名。
options	HuksOptions	是	用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。
callback	AsyncCallback<void>	是	回调函数。不返回err值时表示接口使用成功，其他时为错误。

示例：

/* 以导入AES256密钥为例 */
let plainTextSize32 = makeRandomArr(32);
function makeRandomArr(size) {
    let arr = new Uint8Array(size);
    for (let i = 0; i < size; i++) {
        arr[i] = Math.floor(Math.random() * 10);
    }
    return arr;
};
let keyAlias = 'keyAlias';
let properties = new Array();
properties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_AES
};
properties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256
};
properties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value:
    huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT
};
properties[3] = {
    tag: huks.HuksTag.HUKS_TAG_PADDING,
    value:huks.HuksKeyPadding.HUKS_PADDING_PKCS7
};
properties[4] = {
    tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE,
    value: huks.HuksCipherMode.HUKS_MODE_CBC
};
let options = {
    properties: properties,
    inData: plainTextSize32
};
try {
    huks.importKeyItem(keyAlias, options, function (error, data) {
        if (error) {
            console.error(`callback: importKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        } else {
            console.info(`callback: importKeyItem success`);
        }
    });
} catch (error) {
    console.error(`callback: importKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.importKeyItem⁹⁺

importKeyItem(keyAlias: string, options: HuksOptions) : Promise<void>

导入明文密钥，使用Promise方式异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名。
options	HuksOptions	是	用于导入时所需TAG和需要导入的密钥。其中密钥使用的算法、密钥用途、密钥长度为必选参数。

示例：

/* 以导入AES128为例 */
let plainTextSize32 = makeRandomArr(32);

function makeRandomArr(size) {
    let arr = new Uint8Array(size);
    for (let i = 0; i < size; i++) {
        arr[i] = Math.floor(Math.random() * 10);
    }
    return arr;
};

/*第一步：生成密钥*/
let keyAlias = 'keyAlias';
let properties = new Array();
properties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_AES
};
properties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_128
};
properties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT
};
properties[3] = {
    tag: huks.HuksTag.HUKS_TAG_PADDING,
    value:huks.HuksKeyPadding.HUKS_PADDING_PKCS7
};
properties[4] = {
    tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE,
    value: huks.HuksCipherMode.HUKS_MODE_CBC
};
let huksoptions = {
    properties: properties,
    inData: plainTextSize32
};
try {
    huks.importKeyItem(keyAlias, huksoptions)
        .then ((data) => {
            console.info(`promise: importKeyItem success`);
        })
        .catch(error => {
            console.error(`promise: importKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: importKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.importWrappedKeyItem⁹⁺

importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions, callback: AsyncCallback<void>) : void

导入加密密钥，使用Callback方式回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，存放待导入密钥的别名。
wrappingKeyAlias	string	是	密钥别名，对应密钥用于解密加密的密钥数据。
options	HuksOptions	是	用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。
callback	AsyncCallback<void>	是	回调函数。不返回err值时表示接口使用成功，其他时为错误。

示例：

/*
 * 以下以SM2密钥的Callback操作验证为例
 */
import huks from '@ohos.security.huks';

/*
 * 确定密钥别名
 */
let importAlias = "importAlias";
let wrapAlias = "wrappingKeyAlias";
let exportKey;

/*
 * 加密导入用途的密钥材料原文：转换成HUKS ECC-P-256密钥对格式的密钥材料
 */
let inputEccPair = new Uint8Array([
    0x02, 0x00, 0x00, 0x00, // 密钥算法：huks.HuksKeyAlg.HUKS_ALG_ECC = 2
    0x00, 0x01, 0x00, 0x00, // 密钥大小（比特）：256
    0x20, 0x00, 0x00, 0x00, // 坐标x长度（字节）：32
    0x20, 0x00, 0x00, 0x00, // 坐标y长度（字节）：32
    0x20, 0x00, 0x00, 0x00, // 坐标z长度（字节）：32
    // 坐标x
    0xa5, 0xb8, 0xa3, 0x78, 0x1d, 0x6d, 0x76, 0xe0, 0xb3, 0xf5, 0x6f, 0x43, 0x9d, 0xcf, 0x60, 0xf6,
    0x0b, 0x3f, 0x64, 0x45, 0xa8, 0x3f, 0x1a, 0x96, 0xf1, 0xa1, 0xa4, 0x5d, 0x3e, 0x2c, 0x3f, 0x13,
    // 坐标y
    0xd7, 0x81, 0xf7, 0x2a, 0xb5, 0x8d, 0x19, 0x3d, 0x9b, 0x96, 0xc7, 0x6a, 0x10, 0xf0, 0xaa, 0xbc,
    0x91, 0x6f, 0x4d, 0xa7, 0x09, 0xb3, 0x57, 0x88, 0x19, 0x6f, 0x00, 0x4b, 0xad, 0xee, 0x34, 0x35,
    // 坐标z
    0xfb, 0x8b, 0x9f, 0x12, 0xa0, 0x83, 0x19, 0xbe, 0x6a, 0x6f, 0x63, 0x2a, 0x7c, 0x86, 0xba, 0xca,
    0x64, 0x0b, 0x88, 0x96, 0xe2, 0xfa, 0x77, 0xbc, 0x71, 0xe3, 0x0f, 0x0f, 0x9e, 0x3c, 0xe5, 0xf9
    ]);

/*
 * 封装密钥属性参数集
 */
// 生成加密导入用途的密钥的属性集
let properties = new Array();
properties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_ECC
};
properties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_ECC_KEY_SIZE_256
};
properties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_UNWRAP
};
properties[3] = {
    tag: huks.HuksTag.HUKS_TAG_DIGEST,
    value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
};
properties[4] = {
    tag: huks.HuksTag.HUKS_TAG_IMPORT_KEY_TYPE,
    value: huks.HuksImportKeyType.HUKS_KEY_TYPE_KEY_PAIR,
};
let huksOptions = {
    properties: properties,
    inData: inputEccPair
};

// 待导入密钥的属性集:AES256
let importProperties = new Array();
importProperties[0] = {
    tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
    value: huks.HuksKeyAlg.HUKS_ALG_AES
};
importProperties[1] = {
    tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
    value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256
};
importProperties[2] = {
    tag: huks.HuksTag.HUKS_TAG_PURPOSE,
    value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT
};
importProperties[3] = {
    tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE,
    value: huks.HuksCipherMode.HUKS_MODE_CBC
};
importProperties[4] = {
    tag: huks.HuksTag.HUKS_TAG_PADDING,
    value: huks.HuksKeyPadding.HUKS_PADDING_NONE
};
importProperties[5] = {
    tag: huks.HuksTag.HUKS_TAG_UNWRAP_ALGORITHM_SUITE,
    value: huks.HuksUnwrapSuite.HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING // 使用“ECDH+AES256GCM”加密导入套件
};
let importOptions = {
    properties: importProperties,
    inData: new Uint8Array(new Array())
};

// 导出加密导入用途的公钥
function exportKeyItem(keyAlias:string, huksOptions:huks.HuksOptions, throwObject) : Promise<huks.HuksReturnResult> {
    return new Promise((resolve, reject) => {
        try {
            huks.exportKeyItem(keyAlias, huksOptions, function (error, data) {
                if (error) {
                    reject(error);
                } else {
                    resolve(data);
                }
            });
        } catch (error) {
            throwObject.isThrow = true;
            throw(error);
        }
    });
}

async function publicExportKeyFunc(keyAlias:string, huksOptions:huks.HuksOptions) {
    console.info(`enter callback export`);
    let throwObject = {isThrow: false};
    try {
        await exportKeyItem(keyAlias, huksOptions, throwObject)
            .then ((data) => {
                console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`);
                exportKey = data.outData;
            })
            .catch(error => {
                if (throwObject.isThrow) {
                    throw(error);
                } else {
                    console.error(`callback: exportKeyItem failed, code: ${error.code}, msg: ${error.message}`);
                }
            });
    } catch (error) {
        console.error(`callback: exportKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

// 此处用导入密钥来模拟“生成加密导入用途的密钥”
function importKeyItem(keyAlias:string, huksOptions:huks.HuksOptions, throwObject) {
    return new Promise((resolve, reject) => {
        try {
            huks.importKeyItem(keyAlias, huksOptions, function (error, data) {
                if (error) {
                    reject(error);
                } else {
                    resolve(data);
                }
            });
        } catch (error) {
            throwObject.isThrow = true;
            throw(error);
        }
    });
}

async function publicImportKeyFunc(keyAlias:string, huksOptions:huks.HuksOptions) {
    console.info(`enter promise importKeyItem`);
    let throwObject = {isThrow: false};
    try {
        await importKeyItem(keyAlias, huksOptions, throwObject)
            .then ((data) => {
                console.info(`callback: importKeyItem success, data = ${JSON.stringify(data)}`);
            })
            .catch(error => {
                if (throwObject.isThrow) {
                    throw(error);
                } else {
                    console.error(`callback: importKeyItem failed, code: ${error.code}, msg: ${error.message}`);
                }
            });
    } catch (error) {
        console.error(`callback: importKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

// 执行加密导入
async function publicImportWrappedKey(keyAlias:string, wrappingKeyAlias:string, huksOptions:huks.HuksOptions) {
    console.info(`enter callback importWrappedKeyItem`);
    var throwObject = {isThrow: false};
    try {
        await importWrappedKeyItem(keyAlias, wrappingKeyAlias, huksOptions, throwObject)
            .then ((data) => {
                console.info(`callback: importWrappedKeyItem success, data = ${JSON.stringify(data)}`);
            })
            .catch(error => {
                if (throwObject.isThrow) {
                    throw(error);
                } else {
                    console.error(`callback: importWrappedKeyItem failed, code: ${error.code}, msg: ${error.message}`);
                }
            });
    } catch (error) {
        console.error(`callback: importWrappedKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

function importWrappedKeyItem(keyAlias:string, wrappingKeyAlias:string, huksOptions:huks.HuksOptions, throwObject) {
    return new Promise((resolve, reject) => {
        try {
            huks.importWrappedKeyItem(keyAlias, wrappingKeyAlias, huksOptions, function (error, data) {
                if (error) {
                    reject(error);
                } else {
                    resolve(data);
                }
            });
        } catch (error) {
            throwObject.isThrow = true;
            throw(error);
        }
    });
}

// 删除加密导入用途的密钥
function deleteKeyItem(keyAlias:string, huksOptions:huks.HuksOptions, throwObject) {
    return new Promise((resolve, reject) => {
        try {
            huks.deleteKeyItem(keyAlias, huksOptions, function (error, data) {
                if (error) {
                    reject(error);
                } else {
                    resolve(data);
                }
            });
        } catch (error) {
            throwObject.isThrow = true;
            throw(error);
        }
    });
}

async function publicDeleteKeyFunc(keyAlias:string, huksOptions:huks.HuksOptions) {
    console.info(`enter callback deleteKeyItem`);
    let throwObject = {isThrow: false};
    try {
        await deleteKeyItem(keyAlias, huksOptions, throwObject)
            .then ((data) => {
                console.info(`callback: deleteKeyItem key success, data = ${JSON.stringify(data)}`);
            })
            .catch(error => {
                if (throwObject.isThrow) {
                    throw(error);
                } else {
                    console.error(`callback: deleteKeyItem failed, code: ${error.code}, msg: ${error.message}`);
                }
            });
    } catch (error) {
        console.error(`callback: deletKeeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function ImportWrappedKeyNormalTest() {
    console.info(`enter ImportWrapKey test`);
    /*
     * 生成加密导入用途的密钥（此处使用导入进行模拟）
     */
    await publicImportKeyFunc(wrapAlias, huksOptions);

    /*
     * 导出加密导入用途密钥的公钥材料
     */
    await publicExportKeyFunc(wrapAlias, huksOptions);

    /*----------------------------------------------------------------------------------------------
     * 此处省略业务本地生成ECC密钥对、业务本地ECDH密钥协商、业务本地生成密钥加密密钥K3、业务本地加密K1'和K3的流程
     *----------------------------------------------------------------------------------------------*/

    /* 封装加密导入密钥材料：参考加密导入
     * 拼接importOptions.inData字段，满足以下格式:
     * PK2长度（4字节）     + PK2的数据     + AAD2的长度（4字节） + AAD2的数据 +
     * Nonce2的长度（4字节）+ Nonce2的数据  + AEAD2的长度（4字节） + AEAD2的数据 +
     * K3密文的长度（4字节） + K3密文的数据  + AAD3的长度（4字节） + AAD3的数据 +
     * Nonce3的长度（4字节） + Nonce3的数据  + AEAD3的长度（4字节） + AEAD3的数据 +
     * K1'_size的长度（4字节） + K1'_size   + K1'_enc的长度（4字节） + K1'_enc的数据
     */
    let inputKey = new Uint8Array([
        0x5b, 0x00, 0x00, 0x00, // ECC-P-256 公钥长度（X.509规范DER格式）：91
        // ECC-P-256 公钥
        0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a,
        0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xa5, 0xb8, 0xa3, 0x78, 0x1d,
        0x6d, 0x76, 0xe0, 0xb3, 0xf5, 0x6f, 0x43, 0x9d, 0xcf, 0x60, 0xf6, 0x0b, 0x3f, 0x64, 0x45, 0xa8,
        0x3f, 0x1a, 0x96, 0xf1, 0xa1, 0xa4, 0x5d, 0x3e, 0x2c, 0x3f, 0x13, 0xd7, 0x81, 0xf7, 0x2a, 0xb5,
        0x8d, 0x19, 0x3d, 0x9b, 0x96, 0xc7, 0x6a, 0x10, 0xf0, 0xaa, 0xbc, 0x91, 0x6f, 0x4d, 0xa7, 0x09,
        0xb3, 0x57, 0x88, 0x19, 0x6f, 0x00, 0x4b, 0xad, 0xee, 0x34, 0x35,

        0x10, 0x00, 0x00, 0x00, // AAD2长度：16
        // AAD2
        0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x00,

        0x0c, 0x00, 0x00, 0x00, // Nonce2长度：16
        // Nonce2
        0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x00,

        0x10, 0x00, 0x00, 0x00, // AEAD2长度：16
        // AEAD2
        0x85, 0xfe, 0xff, 0x5b, 0x47, 0x30, 0xbe, 0x10, 0xea, 0x3c, 0x30, 0x94, 0x8a, 0x99, 0xc4, 0x86,

        0x20, 0x00, 0x00, 0x00, // K3密文长度：32
        // K3密文
        0xb4, 0xa9, 0x31, 0x5f, 0x28, 0x39, 0x53, 0x12, 0xa0, 0xfd, 0x8c, 0x9e, 0xfd, 0x36, 0xb8, 0xcb,
        0x73, 0xb3, 0x08, 0xce, 0x16, 0xc9, 0x3b, 0xea, 0xd5, 0xca, 0x41, 0x85, 0xb8, 0x25, 0x7d, 0x1b,

        0x10, 0x00, 0x00, 0x00, // AAD3长度：16
        // AAD3
        0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x62, 0x61, 0x00,

        0x0c, 0x00, 0x00, 0x00, // Nonce3长度：16
        // Nonce3
        0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x61, 0x68, 0x00,

        0x10, 0x00, 0x00, 0x00, // AEAD3长度：16
        // AEAD3
        0x23, 0xe2, 0xdb, 0xb5, 0x2e, 0xa7, 0xbb, 0x2d, 0xc5, 0x57, 0x05, 0xd8, 0x9d, 0x0e, 0xcf, 0x62,

        0x04, 0x00, 0x00, 0x00, // “密钥明文材料长度”的长度（字节）：4
        // 密钥明文材料的长度：32字节
        0x20, 0x00, 0x00, 0x00,

        0x20, 0x00, 0x00, 0x00, // 待导入密钥密文长度（字节）：32
        // 待导入密钥密文
        0xf4, 0x17, 0xbb, 0x90, 0x88, 0x62, 0x3d, 0x6e, 0xd8, 0x5f, 0x03, 0x51, 0x7f, 0xf5, 0x8b, 0x97,
        0x8a, 0x41, 0x33, 0x64, 0xf5, 0x6f, 0x61, 0x16, 0xf9, 0x3c, 0x7a, 0x0b, 0xee, 0x3d, 0x92, 0xbb,
    ]);
    importOptions.inData = inputKey;

    /*
     * 导入封装的加密密钥材料
     */
    await publicImportWrappedKey(importAlias, wrapAlias, importOptions);

    /*
     * 删除用于加密导入的密钥
     */
    await publicDeleteKeyFunc(wrapAlias, huksOptions);
}

huks.importWrappedKeyItem⁹⁺

importWrappedKeyItem(keyAlias: string, wrappingKeyAlias: string, options: HuksOptions) : Promise<void>

导入加密密钥，使用Promise方式异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，存放待导入密钥的别名。
wrappingKeyAlias	string	是	密钥别名，对应密钥用于解密加密的密钥数据。
options	HuksOptions	是	用于导入时所需TAG和需要导入的加密的密钥数据。其中密钥使用的算法、密钥用途、密钥长度为必选参数。

示例：

/* 处理流程与callback类似，主要差异点为如下函数： */
async function TestImportWrappedFunc(alias, wrappingAlias, options) {
    try {
        await huks.importWrappedKeyItem(alias, wrappingAlias, options)
            .then ((data) => {
                console.info(`promise: importWrappedKeyItem success`);
            })
            .catch(error => {
                console.error(`promise: importWrappedKeyItem failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: importWrappedKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

huks.exportKeyItem⁹⁺

exportKeyItem(keyAlias: string, options: HuksOptions, callback: AsyncCallback<HuksReturnResult>) : void

导出密钥，使用Callback方式回调异步返回的结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应与所用密钥生成时使用的别名相同。
options	HuksOptions	是	空对象（此处传空即可）。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.exportKeyItem(keyAlias, emptyOptions, function (error, data) {
        if (error) {
            console.error(`callback: exportKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        } else {
            console.info(`callback: exportKeyItem success, data = ${JSON.stringify(data)}`);
        }
    });
} catch (error) {
    console.error(`callback: exportKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.exportKeyItem⁹⁺

exportKeyItem(keyAlias: string, options: HuksOptions) : Promise<HuksReturnResult>

导出密钥，使用Promise方式回调异步返回的结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应与所用密钥生成时使用的别名相同。
options	HuksOptions	是	空对象（此处传空即可）。

返回值：

类型	说明
Promise<HuksReturnResult>	Promise对象。不返回err值时表示接口使用成功，其他时为错误。outData：返回从密钥中导出的公钥。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.exportKeyItem(keyAlias, emptyOptions)
        .then ((data) => {
            console.info(`promise: exportKeyItem success, data = ${JSON.stringify(data)}`);
        })
        .catch(error => {
            console.error(`promise: exportKeyItem failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: exportKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.getKeyItemProperties⁹⁺

getKeyItemProperties(keyAlias: string, options: HuksOptions, callback: AsyncCallback<HuksReturnResult>) : void

获取密钥属性，使用Callback回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应与所用密钥生成时使用的别名相同。
options	HuksOptions	是	空对象（此处传空即可）。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。errorCode：返回HUKS_SUCCESS时表示接口使用成功，其他时为错误。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.getKeyItemProperties(keyAlias, emptyOptions, function (error, data) {
        if (error) {
            console.error(`callback: getKeyItemProperties failed, code: ${error.code}, msg: ${error.message}`);
        } else {
            console.info(`callback: getKeyItemProperties success, data = ${JSON.stringify(data)}`);
        }
    });
} catch (error) {
    console.error(`callback: getKeyItemProperties input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.getKeyItemProperties⁹⁺

getKeyItemProperties(keyAlias: string, options: HuksOptions) : Promise<HuksReturnResult>

获取密钥属性，使用Promise回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	密钥别名，应与所用密钥生成时使用的别名相同。
options	HuksOptions	是	空对象（此处传空即可）。

返回值：

类型	说明
Promise<HuksReturnResult>	Promise对象。不返回err值时表示接口使用成功，其他时为错误。properties：返回值为生成密钥时所需参数。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.getKeyItemProperties(keyAlias, emptyOptions)
        .then ((data) => {
            console.info(`promise: getKeyItemProperties success, data = ${JSON.stringify(data)}`);
        })
        .catch(error => {
            console.error(`promise: getKeyItemProperties failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: getKeyItemProperties input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.isKeyItemExist⁹⁺

isKeyItemExist(keyAlias: string, options: HuksOptions, callback: AsyncCallback<boolean>) : void

判断密钥是否存在，使用Callback回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	所需查找的密钥的别名。
options	HuksOptions	是	空对象（此处传空即可）。
callback	AsyncCallback<boolean>	是	回调函数。FALSE代表密钥不存在，TRUE代表密钥存在。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.isKeyItemExist(keyAlias, emptyOptions, function (error, data) {
        if (error) {
            console.info(`callback: isKeyItemExist success, data = ${JSON.stringify(data)}`);
        } else {
            console.error(`callback: isKeyItemExist failed, code: ${error.code}, msg: ${error.message}`);
        }
    });
} catch (error) {
    console.error(`promise: isKeyItemExist input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.isKeyItemExist⁹⁺

isKeyItemExist(keyAlias: string, options: HuksOptions) : Promise<boolean>

判断密钥是否存在，使用Promise回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	所需查找的密钥的别名。
options	HuksOptions	是	空对象（此处传空即可）。

返回值：

类型	说明
Promise<boolean>	Promise对象。FALSE代表密钥不存在，TRUE代表密钥存在。

示例：

/* 此处options选择emptyOptions来传空 */
let keyAlias = 'keyAlias';
let emptyOptions = {
    properties: []
};
try {
    huks.isKeyItemExist(keyAlias, emptyOptions)
        .then ((data) => {
            console.info(`promise: isKeyItemExist success, data = ${JSON.stringify(data)}`);
        })
        .catch(error => {
            console.error(`promise: isKeyItemExist failed, code: ${error.code}, msg: ${error.message}`);
        });
} catch (error) {
    console.error(`promise: isKeyItemExist input arg invalid, code: ${error.code}, msg: ${error.message}`);
}

huks.initSession⁹⁺

initSession(keyAlias: string, options: HuksOptions, callback: AsyncCallback<HuksSessionHandle>) : void

initSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	Init操作密钥的别名。
options	HuksOptions	是	Init操作的参数集合。
callback	AsyncCallback<HuksSessionHandle>	是	回调函数。将Init操作操作返回的handle添加到密钥管理系统的回调。

huks.initSession⁹⁺

initSession(keyAlias: string, options: HuksOptions) : Promise<HuksSessionHandle>

initSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
keyAlias	string	是	Init操作密钥的别名。
options	HuksOptions	是	Init参数集合。

返回值：

类型	说明
Promise<HuksSessionHandle>	Promise对象。将Init操作返回的handle添加到密钥管理系统的回调。

huks.updateSession⁹⁺

updateSession(handle: number, options: HuksOptions, callback: AsyncCallback<HuksReturnResult>) : void

updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Update操作的handle。
options	HuksOptions	是	Update的参数集合。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。将Update操作的结果添加到密钥管理系统的回调。

huks.updateSession⁹⁺

updateSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback<HuksReturnResult>) : void

updateSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Update操作的handle。
options	HuksOptions	是	Update操作的参数集合。
token	Uint8Array	是	Update操作的token。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。将Update操作的结果添加到密钥管理系统的回调。

huks.updateSession⁹⁺

updateSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise<HuksReturnResult>

uupdateSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Update操作的handle。
options	HuksOptions	是	Update操作的参数集合。
token	Uint8Array	否	Update操作的token。

返回值：

类型	说明
Promise<HuksReturnResult>	Promise对象。将Update操作的结果添加到密钥管理系统的回调。

huks.finishSession⁹⁺

finishSession(handle: number, options: HuksOptions, callback: AsyncCallback<HuksReturnResult>) : void

finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Finish操作的handle。
options	HuksOptions	是	Finish的参数集合。
token	Uint8Array	是	Finish操作的token。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。将Finish操作的结果添加到密钥管理系统的回调。

huks.finishSession⁹⁺

finishSession(handle: number, options: HuksOptions, token: Uint8Array, callback: AsyncCallback<HuksReturnResult>) : void

finishSession操作密钥接口，使用Callback回调异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Finish操作的handle。
options	HuksOptions	是	Finish的参数集合。
token	Uint8Array	是	Finish操作的token。
callback	AsyncCallback<HuksReturnResult>	是	回调函数。将Finish操作的结果添加到密钥管理系统的回调。

huks.finishSession⁹⁺

finishSession(handle: number, options: HuksOptions, token?: Uint8Array) : Promise<HuksReturnResult>

finishSession操作密钥接口，使用Promise方式异步返回结果。huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Finish操作的handle。
options	HuksOptions	是	Finish操作的参数集合。
token	Uint8Array	否	Finish操作的token。

返回值：

类型	说明
Promise<HuksReturnResult>	Promise对象，用于获取异步返回结果。

huks.abortSession⁹⁺

abortSession(handle: number, options: HuksOptions, callback: AsyncCallback<void>) : void

abort操作密钥接口，使用Callback回调异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Abort操作的handle。
options	HuksOptions	是	Abort操作的参数集合。
callback	AsyncCallback<void>	是	回调函数。将Abort操作的结果添加到密钥管理系统的回调。

示例：

/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当
 * huks.initSession和huks.updateSession
 * 以及huks.finishSession操作中的任一阶段发生错误时，
 * 都需要调用huks.abortSession来终止密钥的使用。
 *
 * 以下以RSA2048密钥的callback功能使用为例
 */
function stringToUint8Array(str) {
    let arr = [];
    for (let i = 0, j = str.length; i < j; ++i) {
        arr.push(str.charCodeAt(i));
    }
    let tmpUint8Array = new Uint8Array(arr);
    return tmpUint8Array;
}

let keyAlias = "HuksDemoRSA";
let properties = new Array();
let options = {
    properties: properties,
    inData: new Uint8Array(0)
};
let handle;
async function generateKey() {
    properties[0] = {
        tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
        value: huks.HuksKeyAlg.HUKS_ALG_RSA
    };
    properties[1] = {
        tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
        value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048
    };
    properties[2] = {
        tag: huks.HuksTag.HUKS_TAG_PURPOSE,
        value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT
    };
    properties[3] = {
        tag: huks.HuksTag.HUKS_TAG_PADDING,
        value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5
    };
    properties[4] = {
        tag: huks.HuksTag.HUKS_TAG_DIGEST,
        value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
    };
    properties[5] = {
        tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE,
        value: huks.HuksCipherMode.HUKS_MODE_ECB,
    }

    try {
        await huks.generateKeyItem(keyAlias, options, function (error, data) {
            if (error) {
                console.error(`callback: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`);
            } else {
                console.info(`callback: generateKeyItem success`);
            }
        });
    } catch (error) {
        console.error(`callback: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksInit() {
    console.log('enter huksInit');
    try {
        huks.initSession(keyAlias, options, function (error, data) {
            if (error) {
                console.error(`callback: initSession failed, code: ${error.code}, msg: ${error.message}`);
            } else {
                console.info(`callback: initSession success, data = ${JSON.stringify(data)}`);
                handle = data.handle;
            }
        });
    } catch (error) {
        console.error(`callback: initSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksUpdate() {
    console.log('enter huksUpdate');
    options.inData = stringToUint8Array("huksHmacTest");
    try {
        huks.updateSession(handle, options, function (error, data) {
            if (error) {
                console.error(`callback: updateSession failed, code: ${error.code}, msg: ${error.message}`);
            } else {
                console.info(`callback: updateSession success, data = ${JSON.stringify(data)}`);
            }
        });
    } catch (error) {
        console.error(`callback: updateSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksFinish() {
    console.log('enter huksFinish');
    options.inData = new Uint8Array(0);
    try {
        huks.finishSession(handle, options, function (error, data) {
            if (error) {
                console.error(`callback: finishSession failed, code: ${error.code}, msg: ${error.message}`);
            } else {
                console.info(`callback: finishSession success, data = ${JSON.stringify(data)}`);
            }
        });
    } catch (error) {
        console.error(`callback: finishSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksAbort() {
    console.log('enter huksAbort');
    try {
        huks.abortSession(handle, options, function (error, data) {
            if (error) {
                console.error(`callback: abortSession failed, code: ${error.code}, msg: ${error.message}`);
            } else {
                console.info(`callback: abortSession success`);
            }
        });
    } catch (error) {
        console.error(`callback: abortSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

huks.abortSession⁹⁺

abortSession(handle: number, options: HuksOptions) : Promise<void>;

abort操作密钥接口，使用Promise方式异步返回结果。

系统能力：SystemCapability.Security.Huks

参数：

参数名	类型	必填	说明
handle	number	是	Abort操作的handle。
options	HuksOptions	是	Abort操作的参数集合。

返回值：

类型	说明
Promise<void>	Promise对象。将Abort操作的结果添加到密钥管理系统的回调。

示例：

/* huks.initSession, huks.updateSession, huks.finishSession为三段式接口，需要一起使用，当
 * huks.initSession和huks.updateSession
 * 以及huks.finishSession操作中的任一阶段发生错误时，
 * 都需要调用huks.abortSession来终止密钥的使用。
 *
 * 以下以RSA2048密钥的callback功能使用为例
 */
function stringToUint8Array(str) {
    let arr = [];
    for (let i = 0, j = str.length; i < j; ++i) {
        arr.push(str.charCodeAt(i));
    }
    let tmpUint8Array = new Uint8Array(arr);
    return tmpUint8Array;
}

let keyAlias = "HuksDemoRSA";
let properties = new Array();
let options = {
    properties: properties,
    inData: new Uint8Array(0)
};
let handle;
async function generateKey() {
    properties[0] = {
        tag: huks.HuksTag.HUKS_TAG_ALGORITHM,
        value: huks.HuksKeyAlg.HUKS_ALG_RSA
    };
    properties[1] = {
        tag: huks.HuksTag.HUKS_TAG_KEY_SIZE,
        value: huks.HuksKeySize.HUKS_RSA_KEY_SIZE_2048
    };
    properties[2] = {
        tag: huks.HuksTag.HUKS_TAG_PURPOSE,
        value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT
    };
    properties[3] = {
        tag: huks.HuksTag.HUKS_TAG_PADDING,
        value: huks.HuksKeyPadding.HUKS_PADDING_PKCS1_V1_5
    };
    properties[4] = {
        tag: huks.HuksTag.HUKS_TAG_DIGEST,
        value: huks.HuksKeyDigest.HUKS_DIGEST_SHA256
    };
    properties[5] = {
        tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE,
        value: huks.HuksCipherMode.HUKS_MODE_ECB,
    }

    try {
        await huks.generateKeyItem(keyAlias, options)
            .then((data) => {
                console.info(`promise: generateKeyItem success`);
            })
            .catch(error => {
                console.error(`promise: generateKeyItem failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: generateKeyItem input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksInit() {
    console.log('enter huksInit');
    try {
        await huks.initSession(keyAlias, options)
            .then ((data) => {
                console.info(`promise: initSession success, data = ${JSON.stringify(data)}`);
                    handle = data.handle;
            })
            .catch(error => {
                console.error(`promise: initSession key failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: initSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksUpdate() {
    console.log('enter huksUpdate');
    options.inData = stringToUint8Array("huksHmacTest");
    try {
        await huks.updateSession(handle, options)
            .then ((data) => {
                console.info(`promise: updateSession success, data = ${JSON.stringify(data)}`);
            })
            .catch(error => {
                console.error(`promise: updateSession failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: updateSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksFinish() {
    console.log('enter huksFinish');
    options.inData = new Uint8Array(0);
    try {
        await huks.finishSession(handle, options)
            .then ((data) => {
                console.info(`promise: finishSession success, data = ${JSON.stringify(data)}`);
            })
            .catch(error => {
                console.error(`promise: finishSession failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: finishSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

async function huksAbort() {
    console.log('enter huksAbort');
    try {
        await huks.abortSession(handle, options)
            .then ((data) => {
                console.info(`promise: abortSession success`);
            })
            .catch(error => {
                console.error(`promise: abortSession failed, code: ${error.code}, msg: ${error.message}`);
            });
    } catch (error) {
        console.error(`promise: abortSession input arg invalid, code: ${error.code}, msg: ${error.message}`);
    }
}

HuksExceptionErrCode⁹⁺

表示错误码的枚举以及对应的错误信息，错误码表示错误类型，错误信息展示错误详情。

关于错误码的具体信息，可在错误码参考文档中查看。

系统能力：SystemCapability.Security.Huks

名称	值	说明
HUKS_ERR_CODE_PERMISSION_FAIL	201	权限错误导致失败。
HUKS_ERR_CODE_ILLEGAL_ARGUMENT	401	参数错误导致失败。
HUKS_ERR_CODE_NOT_SUPPORTED_API	801	不支持的API。
HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED	12000001	不支持的功能/特性。
HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT	12000002	缺少密钥算法参数。
HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT	12000003	无效密钥算法参数。
HUKS_ERR_CODE_FILE_OPERATION_FAIL	12000004	文件操作失败。
HUKS_ERR_CODE_COMMUNICATION_FAIL	12000005	通信失败。
HUKS_ERR_CODE_CRYPTO_FAIL	12000006	算法库操作失败。
HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED	12000007	密钥访问失败-密钥访问失效。
HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED	12000008	密钥访问失败-密钥认证失败。
HUKS_ERR_CODE_KEY_AUTH_TIME_OUT	12000009	密钥访问失败-密钥访问超时。
HUKS_ERR_CODE_SESSION_LIMIT	12000010	密钥操作会话数已达上限。
HUKS_ERR_CODE_ITEM_NOT_EXIST	12000011	目标对象不存在。
HUKS_ERR_CODE_EXTERNAL_ERROR	12000012	外部错误。
HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST	12000013	缺失所需凭据。
HUKS_ERR_CODE_INSUFFICIENT_MEMORY	12000014	内存不足。
HUKS_ERR_CODE_CALL_SERVICE_FAILED	12000015	调用其他系统服务失败。

HuksKeyPurpose

表示密钥用途。

系统能力：SystemCapability.Security.Huks

名称	值	说明
HUKS_KEY_PURPOSE_ENCRYPT	1	表示密钥用于对明文进行加密操作。
HUKS_KEY_PURPOSE_DECRYPT	2	表示密钥用于对密文进行解密操作。
HUKS_KEY_PURPOSE_SIGN	4	表示密钥用于对数据进行签名。
HUKS_KEY_PURPOSE_VERIFY	8	表示密钥用于验证签名后的数据。
HUKS_KEY_PURPOSE_DERIVE	16	表示密钥用于派生密钥。
HUKS_KEY_PURPOSE_WRAP	32	表示密钥用于加密导出。
HUKS_KEY_PURPOSE_UNWRAP	64	表示密钥加密导入。
HUKS_KEY_PURPOSE_MAC	128	表示密钥用于生成mac消息验证码。
HUKS_KEY_PURPOSE_AGREE	256	表示密钥用于进行密钥协商。

HuksKeyDigest

表示摘要算法。

系统能力：SystemCapability.Security.Huks

名称	值	说明
HUKS_DIGEST_NONE	0	表示无摘要算法。
HUKS_DIGEST_SM3⁹⁺	2	表示SM3摘要算法。
HUKS_DIGEST_SHA256	12	表示SHA256摘要算法。
HUKS_DIGEST_SHA384	13	表示SHA384摘要算法。
HUKS_DIGEST_SHA512	14	表示SHA512摘要算法。

文章转载自：https://developer.harmonyos.com/cn/docs/documentation/doc-references-V3/js-apis-huks-0000001427902680-V3?catalogVersion=V3#ZH-CN_TOPIC_0000001427902680__导入模块

分类

卡片开发

三方库

标签

HarmonyOS API

已于2023-4-4 16:29:50修改

51CTO

51CTO博客

51CTO学堂

HarmonyOSAPI：@ohos.security.huks (通用密钥库系统)

@ohos.security.huks (通用密钥库系统)

导入模块

HuksParam

HuksOptions

HuksSessionHandle⁹⁺

HuksReturnResult⁹⁺

huks.generateKeyItem⁹⁺

huks.generateKeyItem⁹⁺

huks.deleteKeyItem⁹⁺

huks.deleteKeyItem⁹⁺

huks.getSdkVersion

huks.importKeyItem⁹⁺

huks.importKeyItem⁹⁺

huks.importWrappedKeyItem⁹⁺

huks.importWrappedKeyItem⁹⁺

huks.exportKeyItem⁹⁺

huks.exportKeyItem⁹⁺

huks.getKeyItemProperties⁹⁺

huks.getKeyItemProperties⁹⁺

huks.isKeyItemExist⁹⁺

huks.isKeyItemExist⁹⁺

huks.initSession⁹⁺

huks.initSession⁹⁺

huks.updateSession⁹⁺

huks.updateSession⁹⁺

huks.updateSession⁹⁺

huks.finishSession⁹⁺

huks.finishSession⁹⁺

huks.finishSession⁹⁺

huks.abortSession⁹⁺

huks.abortSession⁹⁺

HuksExceptionErrCode⁹⁺

HuksKeyPurpose

HuksKeyDigest

目录

订阅鸿蒙技术特刊，精选内容抢先看

51CTO

51CTO博客

51CTO学堂

HarmonyOSAPI：@ohos.security.huks (通用密钥库系统)

@ohos.security.huks (通用密钥库系统)

导入模块

HuksParam

HuksOptions

HuksSessionHandle9+

HuksReturnResult9+

huks.generateKeyItem9+

huks.generateKeyItem9+

huks.deleteKeyItem9+

huks.deleteKeyItem9+

huks.getSdkVersion

huks.importKeyItem9+

huks.importKeyItem9+

huks.importWrappedKeyItem9+

huks.importWrappedKeyItem9+

huks.exportKeyItem9+

huks.exportKeyItem9+

huks.getKeyItemProperties9+

huks.getKeyItemProperties9+

huks.isKeyItemExist9+

huks.isKeyItemExist9+

huks.initSession9+

huks.initSession9+

huks.updateSession9+

huks.updateSession9+

huks.updateSession9+

huks.finishSession9+

huks.finishSession9+

huks.finishSession9+

huks.abortSession9+

huks.abortSession9+

HuksExceptionErrCode9+

HuksKeyPurpose

HuksKeyDigest

目录

订阅鸿蒙技术特刊，精选内容抢先看

HuksSessionHandle⁹⁺

HuksReturnResult⁹⁺

huks.generateKeyItem⁹⁺

huks.generateKeyItem⁹⁺

huks.deleteKeyItem⁹⁺

huks.deleteKeyItem⁹⁺

huks.importKeyItem⁹⁺

huks.importKeyItem⁹⁺

huks.importWrappedKeyItem⁹⁺

huks.importWrappedKeyItem⁹⁺

huks.exportKeyItem⁹⁺

huks.exportKeyItem⁹⁺

huks.getKeyItemProperties⁹⁺

huks.getKeyItemProperties⁹⁺

huks.isKeyItemExist⁹⁺

huks.isKeyItemExist⁹⁺

huks.initSession⁹⁺

huks.initSession⁹⁺

huks.updateSession⁹⁺

huks.updateSession⁹⁺

huks.updateSession⁹⁺

huks.finishSession⁹⁺

huks.finishSession⁹⁺

huks.finishSession⁹⁺

huks.abortSession⁹⁺

huks.abortSession⁹⁺

HuksExceptionErrCode⁹⁺