📌往期推文全新看点（文中附带最新·鸿蒙全栈学习笔记）
①📖 鸿蒙应用开发与鸿蒙系统开发哪个更有前景？
②📖嵌入式开发适不适合做鸿蒙南向开发？看完这篇你就了解了~
③📖 对于大前端开发来说，转鸿蒙开发究竟是福还是祸？
④📖 鸿蒙岗位需求突增！移动端、PC端、IoT到底该怎么选？
⑤📖 记录一场鸿蒙开发岗位面试经历~
⑥📖 持续更新中……
一、概述
上一篇博客 OpenHarmony解读之设备认证：数据接收管理-获取HiChain实例(3) 重点介绍了在生成本端长期存储的密钥对的过程中服务id的生成，本文将介绍后续两个阶段：密钥别名的生成过程以及密钥对的生成过程。
二、源码分析
这一模块的源码位于：/base/security/deviceauth。
- 密钥别名的生成过程主要是在函数generate_key_alias中实现的，对该函数以及相关数据结构的详细分析如下：
/*
函数功能：通过服务id和认证id生成密钥别名
函数参数：
service_id：服务id
auth_id：认证id
key_type：ACCESSOR_PK:0 CONTROLLER_PK:1 LT_KEY_PAIR:2 KEK:3 DEK:4
函数返回值：
返回密钥别名hc_key_alias
详细：
首先根据密钥类型key_type获取密钥类型对key_type_pair，然后计算service_id + key_type_pair + auth_id的哈希值，最后将该哈希值转换为十六进制格式的字符串，作为密钥别名hc_key_alias。
//密钥别名
struct hc_key_alias {
uint32_t length;//长度
uint8_t key_alias[HC_KEY_ALIAS_MAX_LEN];
};
*/
struct hc_key_alias generate_key_alias(const struct service_id *service_id,
const struct hc_auth_id *auth_id, enum huks_key_alias_type key_type)
{
struct hc_key_alias temp_alias;//初始化一个临时值
(void)memset_s(&temp_alias, sizeof(temp_alias), 0, sizeof(temp_alias));//清空地址空间
check_ptr_return_val(service_id, temp_alias);//检查参数service_id是否为空，若为空，则直接返回空temp_alias
check_ptr_return_val(auth_id, temp_alias);//检查参数auth_id是否为空，若为空，则直接返回空temp_alias
if (key_type >= HC_MAX_KEY_TYPE_NUM) {//如果传入的key_type大于最大密钥类型值，则为无效，返回空temp_alias
LOGE("Invalid user type");
return temp_alias;
}
if (service_id->length > HC_SERVICE_ID_BUFF_LEN) {//检查服务id长度是否符合规范
LOGE("service_id length is error");
return temp_alias;
}
if (auth_id->length > HC_AUTH_ID_BUFF_LEN) {//检查认证id长度是否符合规范
LOGE("auth_id length is error");
return temp_alias;
}
uint32_t key_type_pair_size = HC_KEY_TYPE_PAIR_LEN;//
const uint8_t *key_type_pair = G_KEY_TYPE_PAIRS[key_type];//获取密钥类型对，通过查询全局密钥类型表G_KEY_TYPE_PAIRS
uint32_t total_len = service_id->length + auth_id->length + key_type_pair_size;//计算服务id、认证id、服务类型对的总长度
struct uint8_buff key_alias_buff;//定义一个密钥别名缓冲区
(void)memset_s(&key_alias_buff, sizeof(key_alias_buff), 0, sizeof(key_alias_buff));//清空该缓冲区
key_alias_buff.val = (uint8_t *)MALLOC(total_len + 1);//申请内存空间
if (key_alias_buff.val == NULL) {//申请失败
LOGE("Malloc key alias buff failed");
return temp_alias;
}
key_alias_buff.size = total_len + 1; /* one character longer for terminator 为终止符空出一个元素的长度*/
key_alias_buff.length = total_len;//有效负载的数据长度
(void)memset_s(key_alias_buff.val, key_alias_buff.size, 0, key_alias_buff.size);//清空该别名缓冲区
(void)memcpy_s(key_alias_buff.val, key_alias_buff.size, service_id->service_id, service_id->length);//将服务id拷贝到该缓冲区
(void)memcpy_s(key_alias_buff.val + service_id->length, key_alias_buff.size - service_id->length,
key_type_pair, key_type_pair_size);//将密钥类型对拷贝到该缓冲区
(void)memcpy_s(key_alias_buff.val + service_id->length + key_type_pair_size,
key_alias_buff.size - service_id->length - key_type_pair_size,
auth_id->auth_id, auth_id->length);//将认证id拷贝到该缓冲区
//key_alias_buff缓冲区目前的结构为：service_id + key_type_pair + auth_id
struct hc_key_alias key_alias;//定义密钥别名结构体变量
(void)memset_s(&key_alias, sizeof(key_alias), 0, sizeof(key_alias));//清空该变量空间
struct sha256_value alias_sha256 = sha256(&key_alias_buff);//将service_id + key_type_pair + auth_id作为输入，通过sha256哈希算法计算出哈希值
safe_free(key_alias_buff.val);//释放缓冲区内存
key_alias_buff.val = NULL;
if (alias_sha256.length > 0) {//哈希值计算成功
//将计算出的哈希值转换为十六进制格式的字符串，作为密钥别名key_alias
int32_t length = convert_byte_to_hex_string(alias_sha256.sha256_value, alias_sha256.length,
key_alias.key_alias, HC_KEY_ALIAS_MAX_LEN);//将byte数组转换为十六进制字符串(hexString指的是由一行行符合HEX格式的文本所构成的ASCII文本)
key_alias.length = length;//赋值密钥别名长度
}
return key_alias;
}
- 对于generate_key_alias函数中调用的sha256函数，在前面的博客中已经进行分析，在此不再赘述，下面重点分析在generate_key_alias中调用的另一个工具函数convert_byte_to_hex_string，具体分析如下：
/*
函数功能：将byte数组转换为十六进制格式的字符串(hexString指的是由一行行符合HEX格式的文本所构成的ASCII文本)
函数参数：
byte_array：byte数组
byte_array_size：byte数组容量
hex_string：输出参数，用于保存十六进制格式的字符串
out_size：输出的大小
函数返回值：
返回转换完成后的字符串字节数
详细：
*/
static int32_t convert_byte_to_hex_string(const uint8_t *byte_array, uint32_t byte_array_size,
uint8_t *hex_string, uint32_t out_size)
{
int32_t length = 0;
check_num_return_val(byte_array_size, length);//检查byte数组长度是否为0
if (out_size < (byte_array_size * BYTE_TO_HEX_OPER_LENGTH)) { /* doubleword, length*2 如果out_size小于两个字的长度，返回0*/
return length;
}
uint32_t hex_str_arr_len = (uint32_t)(out_size + 1);//十六进制字符数组长度
char *hex_str_arr = (char *)MALLOC(hex_str_arr_len);//申请内存空间
if (hex_str_arr == NULL) {//申请失败
LOGE("Copy hex arr to string failed");
return 0;
}
(void)memset_s(hex_str_arr, hex_str_arr_len, 0, hex_str_arr_len);//清空该地址空间
for (uint32_t i = 0; i < byte_array_size; i++) {
if (sprintf_s((char *)(hex_str_arr + length), hex_str_arr_len - length, "%02x", byte_array[i]) < 0) {//利用格式化输出的方式进行转换
LOGE("What happened was that the probability was zero"); /* caller perceives memery error, no return */
}
length += BYTE_TO_HEX_OPER_LENGTH; /* doubleword, length increases 2 each time 长度每次增加2，因为每个十六进制数占4bits，一个字节可以转换为两个十六进制字符*/
}
if (memcpy_s(hex_string, out_size, hex_str_arr, length) != EOK) {//将转换后的字符串拷贝到hex_string所指向的内存空间中
LOGE("Copy hex arr to string failed");
length = 0;
}
safe_free(hex_str_arr);//释放内存空间
hex_str_arr = NULL;
return length;
}
- 接下来进入密钥对生成阶段，首先根据密钥别名判断长期保存的公钥是否已经存在，在函数check_lt_public_key_exist中实现，具体分析如下：
//根据密钥别名检查该lt public key是否存在，返回0表示存在
int32_t check_lt_public_key_exist(struct hc_key_alias *key_alias)
{
check_ptr_return_val(key_alias, HC_INPUT_ERROR);//检查参数有效性，无效则返回val
check_num_return_val(key_alias->length, HC_INPUT_ERROR);
struct hks_blob hks_key_alias = convert_to_blob_from_hc_key_alias(key_alias);//将密钥别名转换为blob密钥块
hks_key_alias.type = HKS_BLOB_TYPE_ALIAS;//密钥块类型
int32_t hks_status = hks_is_key_exist(&hks_key_alias);//检查该lt public key是否存在，返回0表示存在
if (hks_status == 0) {//如果hks状态为0，则返回成功码，否则返回失败码
return ERROR_CODE_SUCCESS;
} else {
LOGI("Check lt public key exist failed, status = %d", hks_status);
return ERROR_CODE_FAILED;
}
}
- 如果根据别名查询公钥不存在，则调用generate_lt_key_pair函数进行密钥对的生成，对该函数的详细分析如下：
/*
函数功能：生成长期存储有效的密钥对Generate a long-lived key pair ED25519
函数参数：
key_alias：密钥别名
auth_id：认证id
函数返回值：
成功：返回0
失败：返回错误码
详细：
*/
int32_t generate_lt_key_pair(struct hc_key_alias *key_alias, const struct hc_auth_id *auth_id)
{
check_ptr_return_val(key_alias, HC_INPUT_ERROR);//检查参数有效性
check_ptr_return_val(auth_id, HC_INPUT_ERROR);
int32_t error_code = ERROR_CODE_FAILED;
struct hks_blob hks_key_alias = convert_to_blob_from_hc_key_alias(key_alias);//将密钥别名转换为hks_blob密钥块
check_num_return_val(hks_key_alias.size, error_code);//检查hks_blob密钥别名是否为空
hks_key_alias.type = HKS_BLOB_TYPE_ALIAS;//类型为密钥别名
struct hks_key_param key_param;//hks密钥参数
(void)memset_s(&key_param, sizeof(key_param), 0, sizeof(key_param));//清空该hks_key_param结构体空间
key_param.key_type = HKS_KEY_TYPE_EDDSA_KEYPAIR_ED25519;//加密算法
key_param.key_usage = HKS_KEY_USAGE_SIGN | HKS_KEY_USAGE_VERIFY;//用法
key_param.key_mode = HKS_ALG_GCM;//分组模式
struct hc_auth_id tmp_id = *auth_id;//临时变量暂存认证id
#if (defined(_SUPPORT_SEC_CLONE_) || defined(_SUPPORT_SEC_CLONE_SERVER_))
key_param.key_len = HC_PARAM_KEY_LEN; /* interface regulations */
key_param.key_domain = HKS_ECC_CURVE_ED25519;
key_param.key_pad = HKS_PADDING_NONE;
key_param.key_digest = HKS_ALG_HASH_SHA_256;
key_param.key_param_ext.key_auth_id = convert_to_blob_from_hc_auth_id(&tmp_id);
key_param.key_param_ext.key_auth_id.type = HKS_BLOB_TYPE_AUTH_ID;
build_keyparam_ext(&key_param);
#else
key_param.key_len = HC_LT_PUBLIC_KEY_LEN;//密钥长度为HC长期存在的公钥长度
key_param.key_auth_id = convert_to_blob_from_hc_auth_id(&tmp_id);//将认证id转换为hks_blob结构的认证id
key_param.key_auth_id.type = HKS_BLOB_TYPE_AUTH_ID;//认证id类型
#endif
int32_t hks_status = hks_generate_key(&hks_key_alias, &key_param);//根据密钥别名和密钥参数生成ED25519 公-私钥对
if (hks_status == 0) {//成功
error_code = ERROR_CODE_SUCCESS;
} else {//失败
LOGE("Hks generate failed, status=%d", hks_status);
}
return error_code;
}
三、小结
本文详细介绍了本端的long store密钥对生成的最后两个阶段的内容，至此，HiChain实例的初始化和获取过程结束，在接下来的博客中将会介绍接收到的消息处理过程。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
