OpenHarmony解读之设备认证：数据接收管理-获取HiChain实例(4)

一、概述

上一篇博客 OpenHarmony解读之设备认证：数据接收管理-获取HiChain实例(3)重点介绍了在生成本端长期存储的密钥对的过程中服务id的生成，本文将介绍后续两个阶段：密钥别名的生成过程以及密钥对的生成过程。

二、源码分析

这一模块的源码位于：/base/security/deviceauth。

1. 密钥别名的生成过程主要是在函数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;}

2. 对于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;}

3. 接下来进入密钥对生成阶段，首先根据密钥别名判断长期保存的公钥是否已经存在，在函数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;    }}

4. 如果根据别名查询公钥不存在，则调用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实例的初始化和获取过程结束，在接下来的博客中将会介绍接收到的消息处理过程。