鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 密鑰協(xié)商 C、C++
密鑰協(xié)商(C/C++)
以協(xié)商密鑰類型為ECDH，并密鑰僅在HUKS內(nèi)使用為例，完成密鑰協(xié)商。具體的場景介紹及支持的算法規(guī)格，請參考[密鑰生成支持的算法]。
在CMake腳本中鏈接相關動態(tài)庫
target_link_libraries(entry PUBLIC libhuks_ndk.z.so)
開發(fā)步驟
生成密鑰
設備A、設備B各自生成一個非對稱密鑰，具體請參考[密鑰生成]或[密鑰導入]。
密鑰生成時，可指定參數(shù)，OH_HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG（可選），用于標識基于該密鑰協(xié)商出的密鑰是否由HUKS管理。
- 當TAG設置為OH_HUKS_STORAGE_ONLY_USED_IN_HUKS時，表示基于該密鑰協(xié)商出的密鑰，由HUKS管理，可保證協(xié)商密鑰全生命周期不出安全環(huán)境。
- 當TAG設置為OH_HUKS_STORAGE_KEY_EXPORT_ALLOWED時，表示基于該密鑰協(xié)商出的密鑰，返回給調(diào)用方管理，由業(yè)務自行保證密鑰安全。
- 若業(yè)務未設置TAG的具體值，表示基于該密鑰協(xié)商出的密鑰，即可由HUKS管理，也可返回給調(diào)用方管理，業(yè)務可在后續(xù)協(xié)商時再選擇使用何種方式保護密鑰。
- 開發(fā)前請熟悉鴻蒙開發(fā)指導文檔 ：[
gitee.com/li-shizhen-skin/harmony-os/blob/master/README.md]
導出密鑰
設備A、B導出非對稱密鑰對的公鑰材料。
密鑰協(xié)商
設備A、B分別基于本端私鑰和對端設備的公鑰，協(xié)商出共享密鑰。
密鑰協(xié)商時，可指定參數(shù)OH_HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG（可選），用于標識協(xié)商得到的密鑰是否由HUKS管理。
| 生成 | 協(xié)商 | 規(guī)格 |
|---|---|---|
| OH_HUKS_STORAGE_ONLY_USED_IN_HUKS | OH_HUKS_STORAGE_ONLY_USED_IN_HUKS | 密鑰由HUKS管理 |
| OH_HUKS_STORAGE_KEY_EXPORT_ALLOWED | OH_HUKS_STORAGE_KEY_EXPORT_ALLOWED | 密鑰返回給調(diào)用方管理 |
| 未指定TAG具體值 | OH_HUKS_STORAGE_ONLY_USED_IN_HUKS | 密鑰由HUKS管理 |
| 未指定TAG具體值 | OH_HUKS_STORAGE_KEY_EXPORT_ALLOWED | 密鑰返回給調(diào)用方管理 |
| 未指定TAG具體值 | 未指定TAG具體值HarmonyOS與OpenHarmony鴻蒙文檔籽料：mau123789是v直接拿 | 密鑰返回給調(diào)用方管理 |
注：協(xié)商時指定的TAG值，不可與生成時指定的TAG值沖突。表格中僅列舉有效的指定方式。
刪除密鑰
當密鑰廢棄不用時，設備A、B均需要刪除密鑰
#include "huks/native_huks_api.h"
#include "huks/native_huks_param.h"
#include < string.h >
/* 初始化參數(shù) */
OH_Huks_Result InitParamSet(
struct OH_Huks_ParamSet **paramSet,
const struct OH_Huks_Param *params,
uint32_t paramCount)
{
OH_Huks_Result ret = OH_Huks_InitParamSet(paramSet);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
ret = OH_Huks_AddParams(*paramSet, params, paramCount);
if (ret.errorCode != OH_HUKS_SUCCESS) {
OH_Huks_FreeParamSet(paramSet);
return ret;
}
ret = OH_Huks_BuildParamSet(paramSet);
if (ret.errorCode != OH_HUKS_SUCCESS) {
OH_Huks_FreeParamSet(paramSet);
return ret;
}
return ret;
}
static const uint32_t IV_SIZE = 16;
static uint8_t IV[IV_SIZE] = { 0 }; // this is a test value, for real use the iv should be different every time
static struct OH_Huks_Blob g_keyAliasFinal1001 = {
(uint32_t)strlen("HksECDHAgreeKeyAliasTest001_1_final"),
(uint8_t *)"HksECDHAgreeKeyAliasTest001_1_final"
};
/* 集成密鑰參數(shù)集 */
static struct OH_Huks_Param g_genAgreeParams[] = {
{
.tag = OH_HUKS_TAG_ALGORITHM,
.uint32Param = OH_HUKS_ALG_ECC
}, {
.tag = OH_HUKS_TAG_PURPOSE,
.uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
}, {
.tag = OH_HUKS_TAG_KEY_SIZE,
.uint32Param = OH_HUKS_ECC_KEY_SIZE_256
}, {
.tag = OH_HUKS_TAG_DIGEST,
.uint32Param = OH_HUKS_DIGEST_NONE
}
};
static struct OH_Huks_Param g_agreeParamsInit01[] = {
{
.tag = OH_HUKS_TAG_ALGORITHM,
.uint32Param = OH_HUKS_ALG_ECDH
}, {
.tag = OH_HUKS_TAG_PURPOSE,
.uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
}, {
.tag = OH_HUKS_TAG_KEY_SIZE,
.uint32Param = OH_HUKS_ECC_KEY_SIZE_256
}
};
static struct OH_Huks_Param g_agreeParamsFinish01[] = {
{
.tag = OH_HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG,
.uint32Param = OH_HUKS_STORAGE_ONLY_USED_IN_HUKS
}, {
.tag = OH_HUKS_TAG_ALGORITHM,
.uint32Param = OH_HUKS_ALG_AES
}, {
.tag = OH_HUKS_TAG_KEY_SIZE,
.uint32Param = OH_HUKS_AES_KEY_SIZE_256
}, {
.tag = OH_HUKS_TAG_PURPOSE,
.uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
}, {
.tag = OH_HUKS_TAG_KEY_ALIAS,
.blob = g_keyAliasFinal1001
}, {
.tag = OH_HUKS_TAG_PADDING,
.uint32Param = OH_HUKS_PADDING_NONE
}, {
.tag = OH_HUKS_TAG_BLOCK_MODE,
.uint32Param = OH_HUKS_MODE_CBC
}
};
static struct OH_Huks_Blob g_keyAliasFinal2001 = {
(uint32_t)strlen("HksECDHAgreeKeyAliasTest001_2_final"),
(uint8_t *)"HksECDHAgreeKeyAliasTest001_2_final"
};
static struct OH_Huks_Param g_agreeParamsInit02[] = {
{
.tag = OH_HUKS_TAG_ALGORITHM,
.uint32Param = OH_HUKS_ALG_ECDH
}, {
.tag = OH_HUKS_TAG_PURPOSE,
.uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
}, {
.tag = OH_HUKS_TAG_KEY_SIZE,
.uint32Param = OH_HUKS_ECC_KEY_SIZE_256
}
};
static struct OH_Huks_Param g_agreeParamsFinish02[] = {
{
.tag = OH_HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG,
.uint32Param = OH_HUKS_STORAGE_ONLY_USED_IN_HUKS
}, {
.tag = OH_HUKS_TAG_ALGORITHM,
.uint32Param = OH_HUKS_ALG_AES
}, {
.tag = OH_HUKS_TAG_KEY_SIZE,
.uint32Param = OH_HUKS_AES_KEY_SIZE_256
}, {
.tag = OH_HUKS_TAG_PURPOSE,
.uint32Param = OH_HUKS_KEY_PURPOSE_DERIVE
}, {
.tag = OH_HUKS_TAG_KEY_ALIAS,
.blob = g_keyAliasFinal2001
}, {
.tag = OH_HUKS_TAG_PADDING,
.uint32Param = OH_HUKS_PADDING_NONE
}, {
.tag = OH_HUKS_TAG_BLOCK_MODE,
.uint32Param = OH_HUKS_MODE_CBC
}
};
static const uint32_t ECDH_COMMON_SIZE = 1024;
static struct OH_Huks_Blob g_keyAlias01001 = {
(uint32_t)strlen("HksECDHAgreeKeyAliasTest001_1"),
(uint8_t *)"HksECDHAgreeKeyAliasTest001_1"
};
static struct OH_Huks_Blob g_keyAlias02001 = {
(uint32_t)strlen("HksECDHAgreeKeyAliasTest001_2"),
(uint8_t *)"HksECDHAgreeKeyAliasTest001_2"
};
OH_Huks_Result MallocAndCheckBlobData(
struct OH_Huks_Blob *blob,
const uint32_t blobSize)
{
struct OH_Huks_Result ret;
ret.errorCode = OH_HUKS_SUCCESS;
blob- >data = (uint8_t *)malloc(blobSize);
if (blob- >data == NULL) {
ret.errorCode = OH_HUKS_ERR_CODE_INTERNAL_ERROR;
}
return ret;
}
/* 導出密鑰 */
OH_Huks_Result HksEcdhAgreeExport(const struct OH_Huks_Blob *keyAlias1, const struct OH_Huks_Blob *keyAlias2,
struct OH_Huks_Blob *publicKey1, struct OH_Huks_Blob *publicKey2, const struct OH_Huks_ParamSet *genParamSet)
{
OH_Huks_Result ret = OH_Huks_ExportPublicKeyItem(keyAlias1, genParamSet, publicKey1);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
ret = OH_Huks_ExportPublicKeyItem(keyAlias2, genParamSet, publicKey2);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
return ret;
}
static const char *g_inData = "Hks_ECDH_Agree_Test_000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000000000000000000000000_string";
/* 協(xié)商密鑰操作 */
OH_Huks_Result HksEcdhAgreeFinish(const struct OH_Huks_Blob *keyAlias, const struct OH_Huks_Blob *publicKey,
const struct OH_Huks_ParamSet *initParamSet, const struct OH_Huks_ParamSet *finishParamSet, struct OH_Huks_Blob *outData)
{
struct OH_Huks_Blob inData = {
(uint32_t)strlen(g_inData),
(uint8_t *)g_inData
};
uint8_t handleU[sizeof(uint64_t)] = {0};
struct OH_Huks_Blob handle = { sizeof(uint64_t), handleU };
OH_Huks_Result ret = OH_Huks_InitSession(keyAlias, initParamSet, &handle, nullptr);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
uint8_t outDataU[ECDH_COMMON_SIZE] = {0};
struct OH_Huks_Blob outDataUpdate = { ECDH_COMMON_SIZE, outDataU };
ret = OH_Huks_UpdateSession(&handle, initParamSet, publicKey, &outDataUpdate);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
ret = OH_Huks_FinishSession(&handle, finishParamSet, &inData, outData);
if (ret.errorCode != OH_HUKS_SUCCESS) {
return ret;
}
return ret;
}
/* 協(xié)商密鑰整體流程 */
static napi_value AgreeKey(napi_env env, napi_callback_info info)
{
struct OH_Huks_ParamSet *genParamSet = nullptr;
struct OH_Huks_ParamSet *initParamSet01 = nullptr;
struct OH_Huks_ParamSet *finishParamSet01 = nullptr;
struct OH_Huks_ParamSet *initParamSet02 = nullptr;
struct OH_Huks_ParamSet *finishParamSet02 = nullptr;
struct OH_Huks_Blob publicKey01 = { .size = OH_HUKS_ECC_KEY_SIZE_256, .data = nullptr };
struct OH_Huks_Blob publicKey02 = { .size = OH_HUKS_ECC_KEY_SIZE_256, .data = nullptr };
struct OH_Huks_Blob outData01 = { .size = ECDH_COMMON_SIZE, .data = nullptr };
struct OH_Huks_Blob outData02 = { .size = ECDH_COMMON_SIZE, .data = nullptr };
OH_Huks_Result ohResult;
do {
/* 1.確定密鑰別名集成密鑰參數(shù)集 */
ohResult = InitParamSet(&genParamSet, g_genAgreeParams, sizeof(g_genAgreeParams) / sizeof(OH_Huks_Param));
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = InitParamSet(&initParamSet01, g_agreeParamsInit01, sizeof(g_agreeParamsInit01) / sizeof(OH_Huks_Param));
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = InitParamSet(&finishParamSet01, g_agreeParamsFinish01,
sizeof(g_agreeParamsFinish01) / sizeof(OH_Huks_Param));
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = InitParamSet(&initParamSet02, g_agreeParamsInit02, sizeof(g_agreeParamsInit02) / sizeof(OH_Huks_Param));
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = InitParamSet(&finishParamSet02, g_agreeParamsFinish02,
sizeof(g_agreeParamsFinish02) / sizeof(OH_Huks_Param));
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
/* 2.設備A生成密鑰 */
ohResult = OH_Huks_GenerateKeyItem(&g_keyAlias01001, genParamSet, nullptr);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
/* 3.設備B生成密鑰 */
ohResult = OH_Huks_GenerateKeyItem(&g_keyAlias02001, genParamSet, nullptr);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = MallocAndCheckBlobData(&publicKey01, publicKey01.size);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = MallocAndCheckBlobData(&publicKey02, publicKey02.size);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
/* 4.設備A、B導出公鑰 */
ohResult = HksEcdhAgreeExport(&g_keyAlias01001, &g_keyAlias02001, &publicKey01, &publicKey02, genParamSet);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = MallocAndCheckBlobData(&outData01, outData01.size);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
ohResult = MallocAndCheckBlobData(&outData02, outData02.size);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
/* 5.設備A協(xié)商密鑰 */
ohResult = HksEcdhAgreeFinish(&g_keyAlias01001, &publicKey02, initParamSet01, finishParamSet01, &outData01);
if (ohResult.errorCode != OH_HUKS_SUCCESS) {
break;
}
/* 5.設備B協(xié)商密鑰 */
ohResult = HksEcdhAgreeFinish(&g_keyAlias02001, &publicKey01, initParamSet02, finishParamSet02, &outData02);
} while (0);
free(publicKey01.data);
free(publicKey02.data);
free(outData01.data);
free(outData02.data);
/* 6.設備A、B刪除密鑰 */
OH_Huks_DeleteKeyItem(&g_keyAlias01001, genParamSet);
OH_Huks_DeleteKeyItem(&g_keyAlias02001, genParamSet);
OH_Huks_DeleteKeyItem(&g_keyAliasFinal1001, NULL);
OH_Huks_DeleteKeyItem(&g_keyAliasFinal2001, NULL);
OH_Huks_FreeParamSet(&genParamSet);
OH_Huks_FreeParamSet(&initParamSet01);
OH_Huks_FreeParamSet(&finishParamSet01);
OH_Huks_FreeParamSet(&initParamSet02);
OH_Huks_FreeParamSet(&finishParamSet02);
napi_value ret;
napi_create_int32(env, ohResult.errorCode, &ret);
return ret;
}
審核編輯 黃宇
聲明：本文內(nèi)容及配圖由入駐作者撰寫或者入駐合作網(wǎng)站授權轉(zhuǎn)載。文章觀點僅代表作者本人，不代表電子發(fā)燒友網(wǎng)立場。文章及其配圖僅供工程師學習之用，如有內(nèi)容侵權或者其他違規(guī)問題，請聯(lián)系本站處理。
舉報投訴
-
C++
+關注
關注
22文章
2119瀏覽量
75332 -
鴻蒙
+關注
關注
60文章
2620瀏覽量
44063
發(fā)布評論請先 登錄
相關推薦
熱點推薦
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務簡介
Universal Keystore Kit（密鑰管理服務，下述簡稱為HUKS）向業(yè)務/應用提供
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 生成密鑰C、C++
以生成ECC密鑰為例，生成隨機密鑰。具體的場景介紹及支持的算法規(guī)格。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 密鑰導入介紹及算法規(guī)格
如果業(yè)務在HUKS外部生成密鑰（比如應用間協(xié)商生成、服務器端生成），業(yè)務可以將密鑰導入到HUKS中由HUKS進行管理。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 明文導入密鑰C、C++
以明文導入ECC密鑰為例。具體的場景介紹及支持的算法規(guī)格
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 加密導入密鑰 ArkTS
以加密導入ECDH密鑰對為例，涉及業(yè)務側(cè)加密密鑰的[密鑰生成]、[協(xié)商])等操作不在本示例中體現(xiàn)。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 加密導入密鑰C、C++
以加密導入ECDH密鑰對為例，涉及業(yè)務側(cè)加密密鑰的[密鑰生成]、[協(xié)商]等操作不在本示例中體現(xiàn)。
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 密鑰協(xié)商ArkTS
以協(xié)商密鑰類型為X25519 256，并密鑰僅在HUKS內(nèi)使用為例，完成密鑰協(xié)商。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 密鑰派生C、C++
以HKDF256密鑰為例，完成密鑰派生。具體的場景介紹及支持的算法規(guī)格，請參考[密鑰生成支持的算法]。
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 HMAC ArkTS
HMAC是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code），是一種基于Hash函數(shù)和密鑰進行消息認證的方法。
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 HMAC C、C++
HMAC是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code），是一種基于Hash函數(shù)和密鑰進行消息認證的方法。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 密鑰刪除C C++
為保證數(shù)據(jù)安全性，當不需要使用該密鑰時，應該刪除密鑰。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 查詢密鑰是否存在C、C++
HUKS提供了接口供應用查詢指定密鑰是否存在。
鴻蒙開發(fā)：Universal Keystore Kit密鑰管理服務 查詢密鑰是否存在C C++
HUKS提供了接口供應用查詢指定密鑰是否存在。
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 獲取密鑰屬性C C++
HUKS提供了接口供業(yè)務獲取指定密鑰的相關屬性。在獲取指定密鑰屬性前，需要確保已在HUKS中生成或?qū)氤志没鎯Φ?b class='flag-5'>密鑰。
鴻蒙開發(fā)：Universal Keystore Kit 密鑰管理服務 密鑰導出 C C++
業(yè)務需要獲取持久化存儲的非對稱密鑰的公鑰時使用，當前支持ECC/RSA/ED25519/X25519的公鑰導出。
工商網(wǎng)監(jiān)
評論