鸿蒙源码分析（二十五）

快来打我* 2022-09-04 07:46 168阅读 0赞

### 文章目录 ###

*  安全密钥库模块hks\_common.c代码分析（中）
 *   *  一、背景知识
     *  二、代码分析
     *  三、总结

--------------------

# 安全密钥库模块hks\_common.c代码分析（中） #

本篇文章主要分析hks\_common.c中的相关内容  
文件路径（security\_huks\\frameworks\\huks\_lite\\source\\hw\_keystore\_sdk\\common\\hks\_common.c）

## 一、背景知识 ##

[头文件介绍][Link 1]  
[相关算法介绍][Link 2]  
[代码分析上篇][Link 3]  
[代码分析中篇][Link 4]

## 二、代码分析 ##

**aead加密**  
该函数类似于解密过程，加密和解密是两个过程很相似的算法过程，主要是数据和数据的操作方式不同，大体流程相似。  
参数详解：

*  key ：一个密钥
 *  key\_param：密钥相关参数
 *  aead\_data：aead算法数据
 *  ciphertext\_output\_length：明文输出长度

//aead加密算法
    int32_t hks_mbedtls_aead_encrypt(const struct hks_blob *key,
        const struct hks_key_param *key_param, struct hks_aead_data *aead_data,
        size_t *ciphertext_output_length)
    { 
        int32_t status = check_mbedtls_aead_args(key, key_param, aead_data, ciphertext_output_length);
        //检查aead算法相关参数
        if (status != HKS_SUCCESS)
            return status;
    
        struct hks_aead_operation operation;
    
        *ciphertext_output_length = 0;
        status = hks_aead_setup(key, key_param, &operation);
        //设置aead算法参数
        if (status != HKS_SUCCESS)
            return status;
    
        /* For all supported modes, the tag is at the end of the ciphertext. */
        if (aead_data->ciphertext_length < (aead_data->plaintext_length + operation.tag_length)) { 
            status = HKS_ERROR_BUFFER_TOO_SMALL;
            goto exit;
        }
        //如果密文长度小于明文长度加tag长度，说明密文长度过于小。程序退出
        uint8_t *tag = aead_data->ciphertext + aead_data->plaintext_length;
        //定义tag位置
        if (operation.core_alg == HKS_ALG_GCM)
            status = mbedtls_gcm_crypt_and_tag(&operation.gcm, MBEDTLS_GCM_ENCRYPT,
                aead_data->plaintext_length, aead_data->nonce, aead_data->nonce_length, aead_data->additional_data,
                aead_data->additional_data_length, aead_data->plaintext, aead_data->ciphertext, operation.tag_length, tag);
            //执行加密并且实现tag位的填写
        else
            status = HKS_ERROR_NOT_SUPPORTED;
    
        if (status != 0 && aead_data->ciphertext_length != 0)
            (void)memset_s(aead_data->ciphertext, aead_data->ciphertext_length, 0, aead_data->ciphertext_length);
            //初始化密文内容为0
    exit:
        mbedtls_gcm_free(&(operation.gcm));//释放operation.gcm空间
        if (status == HKS_SUCCESS) { 
            if (aead_data->plaintext_length > SIZE_MAX - operation.tag_length)
            //如果明文长度大于空间最大值减去标记位tag长度，函数报错
                return HKS_ERROR_BAD_STATE;
            *ciphertext_output_length = aead_data->plaintext_length + operation.tag_length;
            //定义密文的输出长度为明文加标记位
        }
    
        return mbedtls_to_hks_error(status);
    }

**标记位tag的非覆盖性更新**  
该函数主要是为了不断地计算和更新标记位tag，但是并非是直接修改tag，而是不断将新的tag写进p\_tag这个二维数组。  
参数详解：

*  tag-length：标记位长度
 *  \*ciphertext：密文
 *  ciphertext\_length：密文长度
 *  plaintext\_size：明文长度
 *  p\_tag：存放新标记位的数组

int32_t hks_aead_unpadded_locate_tag(size_t tag_length,
        const uint8_t *ciphertext, size_t ciphertext_length,
        size_t plaintext_size, const uint8_t **p_tag)
    { 
        size_t payload_length;
    
        if (tag_length > ciphertext_length)
            return HKS_ERROR_INVALID_ARGUMENT;
        //标记tag长度大于密文长度报错
        payload_length = ciphertext_length - tag_length;
        //payload长度为密文减去tag
        if (payload_length > plaintext_size)
            return HKS_ERROR_BUFFER_TOO_SMALL;
        //payload长度大于明文大小说明缓冲区较小，函数报错
        if (ciphertext_length > SIZE_MAX - payload_length)
            return HKS_ERROR_BAD_STATE;
        *p_tag = ciphertext + payload_length;
        //将p_tag置为密文起始位置加payload长度
        return HKS_SUCCESS;
    }

**数组的收尾互换**  
该函数hks\_end:ian\_swap主要用来实现数组的内容反转。  
参数详解：

*  \*p\_data：要实现反转的数组
 *  length：要反转的长度

//这个函数用来将p_data数组进行反转实现收尾颠倒
    int32_t hks_endian_swap(uint8_t *p_data, int32_t length)
    { 
        if (p_data == NULL)
            return HKS_ERROR_NULL_POINTER;
    
        if (length <= 0)
            return HKS_ERROR_BUF_TOO_SMALL;
        //检查传入参数
        int32_t end = length - 1;
        int32_t start = 0;
    
        int32_t cnt = length / 2; /* 2: count the middle index of array */
        uint8_t tmp;
    
        for (int32_t i = 0; i < cnt; i++) { 
            tmp = p_data[start + i];
            p_data[start + i] = p_data[end - i];
            p_data[end - i] = tmp;
        }
        //该循环用来反转数组p_data
        return HKS_SUCCESS;
    }

**错误码的转换**  
该函数实现错误码从mbedtls转换到华为密钥库的错误码hks\_error

//错误码的转换，从mbedtls转换到hks的错误码
    int32_t mbedtls_to_hks_error(int ret)
    { 
        int rc = ret;
    
        /* * 1. If there's both a high-level code and low-level code, dispatch on * the high-level code. * 2. Use bitwise operators only on unsigned operands */
        if (rc < MBEDTLS_RET_CODE_BOUNDARY)
            rc = -(int)(((unsigned int)-rc) &
                MBEDTLS_RET_CODE_HIGH_LEVEL_MASK);
    
        uint32_t code_cov_size = sizeof(g_code_conv) / sizeof(g_code_conv[0]);
    
        for (uint32_t i = 0; i < code_cov_size; i++) { 
            if (rc == g_code_conv[i].mbedtls_code)
                return g_code_conv[i].hks_code;
        }
        return HKS_FAILURE;
    }

**XOR运算的实现**  
函数功能顾名思义：实现异或功能  
参属详解：

*  src1：参与运算的数据1
 *  src2：参与运算的数据2
 *  result：运算结果的输出

//异或的实现
    void hks_xor(const struct hks_blob *src1, const struct hks_blob *src2,
        struct hks_blob *result)
    { 
        if ((src1 == NULL) || (src2 == NULL) || (result == NULL))
            return;
        //先检查操作数和传入参数问题
        uint32_t xor_len = (src1->size < src2->size) ? src1->size : src2->size;
        //先将异或结果长度定义为操作数中较长的一个长度
        if (xor_len > result->size)
            xor_len = result->size;
    
        uint32_t i;
    
        for (i = 0; i < xor_len; ++i)
            result->data[i] = src1->data[i] ^ src2->data[i];
        //实现异或运算
    }

**回调函数实现硬件设备标识符的获取**  
这是一个回调函数赖获取硬件设备id

int32_t hks_reg_get_hardware_udid_callback(
        hks_get_hardware_udid_callback callback)
    { 
        if (callback == NULL) { 
            log_error("invalid callback");
            return HKS_ERROR_NULL_POINTER;
        }
    
        g_hks_get_hardware_udid_callback = callback;
    
        return HKS_STATUS_OK;
    }

**获取设备描述符**  
参数详解：

*  udid：存放设备id信息
 *  udid\_len：id长度

//获取计算机硬件描述符
    int32_t hks_get_hardware_udid(uint8_t *udid, uint32_t udid_len)
    { 
        if (udid == NULL) { 
            log_error("invalid udid");
            return HKS_ERROR_NULL_POINTER;
        }
        if (udid_len != HKS_HARDWARE_UDID_LEN) { 
            log_error("invalid udid,len=%u", udid_len);
            return HKS_ERROR_INVALID_ARGUMENT;
        }
        if (g_hks_get_hardware_udid_callback == NULL) { 
            log_error("invalid callback");
            return HKS_ERROR_NULL_POINTER;
        }
        //检查参数和回调函数
        int32_t rc = g_hks_get_hardware_udid_callback(udid, udid_len);
        //udid用来保存id，udid_len是id长度
        if (rc != HKS_STATUS_OK) { 
            log_error("get udid fail,rc=%d", rc);
            return HKS_ERROR_HARDWARE_FAILURE;
        }
    
        return HKS_STATUS_OK;
    }

**计算哈希**  
实现单向散列算法SHA512的计算  
参数详解：

*  out：哈希输出值
 *  in：输入数据
 *  len：输入数据的长度

//计算哈希
    void crypto_hash_sha512(unsigned char *out, const unsigned char *in, const int len)
    { 
        if ((out == NULL) || (in == NULL))
            return;
            //检查参数
        mbedtls_sha512_context ctx;
        mbedtls_sha512_init(&ctx); //初始化
        mbedtls_sha512_starts_ret(&ctx, 0); //开始设置
        mbedtls_sha512_update(&ctx, in, len); //参数更新
        mbedtls_sha512_finish(&ctx, out); //结束
    }

## 三、总结 ##

以上就是hks\_common.c的最后一部分内容，分析了一些相关函数的定义和参数的解释。感谢阅读点赞。

[Link 1]: https://forum.trustie.net/forums/3630/detail
[Link 2]: https://forum.trustie.net/forums/3634/detail
[Link 3]: https://forum.trustie.net/forums/3639/detail
[Link 4]: https://forum.trustie.net/forums/3656/detail