鸿蒙源码分析（二十四）

绝地灬酷狼 2022-09-04 06:45 184阅读 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]

## 二、代码分析 ##

**hks\_blob结构体的初始化**  
参数详解：

*  \*blob 加密
 *  nmemb 要申请空间的数量
 *  size ：要申请空间的大小
 *  type：数据类型

//初始化hks_blob
    int32_t hks_blob_init(struct hks_blob *blob, size_t nmemb, size_t size, uint8_t type)
    { 
        if (blob == NULL)
            return HKS_ERROR_NULL_POINTER;
        if ((nmemb == 0) || (size == 0))
            return HKS_ERROR_INVALID_ARGUMENT;
        //检查传入参数
        blob->data = (uint8_t *)HKS_CALLOC(nmemb, size);
        //对blob_data进行内存申请分配
        if (blob->data == NULL)
            return HKS_ERROR_INSUFFICIENT_MEMORY;
        //检查是否申请成功
        blob->size = (uint32_t)size;
        blob->type = type;
        //对blob结构体的其他属性进行初始化
        return HKS_STATUS_OK;
    }

**检查数据别名**  
整个函数就是检查alias是否为空，以及相关属性data指向的内存是否为空，同时检查大小和数据类型是否可用

int32_t hks_is_valid_alias(const struct hks_blob *alias)
    { 
        if (alias == NULL)
            return HKS_ERROR_NULL_POINTER;
        if (alias->data == NULL)
            return HKS_ERROR_INVALID_ARGUMENT;
        if ((alias->size > HKS_ALIAS_MAX_SIZE) || (alias->size == 0))
            return HKS_ERROR_INVALID_ARGUMENT;
        if (alias->type != HKS_BLOB_TYPE_ALIAS)
            return HKS_ERROR_INVALID_ARGUMENT;
        return HKS_STATUS_OK;
    }
    //整个函数就是检查alias是否为空，以及相关属性data指向的内存

**检查用户id是否可用**  
该函数之用来检查auth\_id的可用性。  
参数详解：

*  key\_param ：一组密钥参数

int32_t hks_is_valid_auth_id(const struct hks_key_param *key_param)
    { 
        if (key_param == NULL)
            return HKS_ERROR_NULL_POINTER;
    
        if (key_param->key_auth_id.data == NULL)
            return HKS_ERROR_NULL_POINTER;
    
        if ((key_param->key_auth_id.size == 0) ||
            (key_param->key_auth_id.size > HKS_AUTH_ID_MAX_SIZE))
            return HKS_ERROR_INVALID_ARGUMENT;
    
        if (key_param->key_auth_id.type != HKS_BLOB_TYPE_AUTH_ID)
            return HKS_ERROR_INVALID_ARGUMENT;
    
        return HKS_STATUS_OK;
    }

**复制密钥参数**  
该函数hks\_cpy\_key\_param讲密钥参数从src源地址复制到目的地地址dst。  
参数详解：

*  dst：目的地址
 *  src：源地址

int32_t hks_cpy_key_param(struct hks_key_param *dst,
        const struct hks_key_param *src)
    { 
        if (dst == NULL || src == NULL)
            return HKS_ERROR_NULL_POINTER;
        //先检查两个地址是否为空
        int32_t status = hks_is_valid_auth_id(src);
        //检查源地址的用户id是否可用
        if (status != HKS_STATUS_OK)
            return status;
    
        if ((dst->key_auth_id.data == NULL) ||
            (dst->key_auth_id.size < src->key_auth_id.size))
            return HKS_ERROR_INSUFFICIENT_CAPACITY;
    
        dst->key_domain = src->key_domain;
        dst->key_len = src->key_len;
        dst->key_mode = src->key_mode;
        dst->key_pad = src->key_pad;
        dst->key_role = src->key_role;
        dst->key_type = src->key_type;
        dst->key_usage = src->key_usage;
        dst->key_auth_id.type = src->key_auth_id.type;
        //将dst中数据赋值为src中的值，实现复制
        if (memcpy_s(dst->key_auth_id.data, src->key_auth_id.size,
            src->key_auth_id.data, src->key_auth_id.size) != EOK)
            return HKS_ERROR_BAD_STATE;
        //初始化dst中密钥的autu_id
        dst->key_auth_id.size = src->key_auth_id.size;
        return HKS_STATUS_OK;
    }

**密钥参数的摧毁**  
将密钥参数key\_param中的数据置为空，之后释放空间

void hks_key_param_destroy(struct hks_key_param *pram)
    { 
        if (pram == NULL)
            return;
    	//检查传入参数
        if (pram->key_auth_id.data != NULL)
            hks_free_ptr(pram->key_auth_id.data);
    	//将非空内存释放
        pram->key_auth_id.data = NULL;
    }

**返回码的检查**  
函数功能：将传入的参数s转换为一个可识别的位于hks\_errno.h的值

void hks_check_return_code(int32_t s, int32_t *ret)
    { 
        if (ret == NULL)
            return;
        if (s == HKS_STATUS_OK) { 
            *ret = s;
            return;
        }
    	//检查传入参数
        log_error("error : %d.\n", s);
        if (((s <= HKS_FAILURE) && (s > HKS_ERROR_MBEDTLS_RANGE_MIN)) ||
            ((s <= HKS_ERROR_NULL_POINTER) && (s > HKS_ERROR_RANGE_MIN)))
            *ret = s;
            //转换s
        else
            *ret = HKS_ERROR_INTERNAL_UNKOWN;
    }

**检查aead算法相关参数**  
主要检查aead算法过程中所用到参数的可用性和是否为空值  
参数详解：

*  key：密钥
 *  key\_param：密钥相关参数
 *  aead\_data：aead算法数据
 *  output\_length：输出的大小

//检查aead算法相关参数
    static int32_t check_mbedtls_aead_args(const struct hks_blob *key, const struct hks_key_param *key_param,
        const struct hks_aead_data *aead_data, const size_t *output_length)
    { 
        if ((key == NULL) || (key_param == NULL) || (aead_data == NULL) ||  //判断输出参数是否空
            (output_length == NULL) || (aead_data->nonce == NULL) || //判断aead中的各个属性
            (aead_data->additional_data == NULL) || (aead_data->plaintext == NULL) ||
            (aead_data->ciphertext == NULL))
            return HKS_ERROR_NULL_POINTER;
    
        if ((aead_data->nonce_length == 0) || (aead_data->additional_data_length == 0) ||
            (aead_data->ciphertext_length <= HKS_SALT_MAX_SIZE) || (aead_data->plaintext_length == 0))
            return HKS_ERROR_INVALID_ARGUMENT;
        //检验aead_data数据中的各个属性是否为空或者0值
        if (key_param->key_mode != HKS_ALG_GCM) //判断参数魔术是否为gcm验证
            return HKS_ERROR_NOT_SUPPORTED;
    
        return HKS_SUCCESS;
    }

**aead算法中的解密过程**  
hks\_mbedtls\_aead\_decrypt函数主要用来解密aead算法过程。  
参数详解：

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

//aead算法过程中的解密过程
    int32_t hks_mbedtls_aead_decrypt(const struct hks_blob *key,
        const struct hks_key_param *key_param,
        struct hks_aead_data *aead_data, size_t *plaintext_output_length)
    { 
        int32_t status = check_mbedtls_aead_args(key, key_param, aead_data, plaintext_output_length);
        //先检查参数
        if (status != HKS_SUCCESS)
            return status;//查看检查是否成功
    
        struct hks_aead_operation operation;
        const uint8_t *tag = NULL;
    
        *plaintext_output_length = 0;
    
        status = hks_aead_setup(key, key_param, &operation); //aead算法的设置
    
        if (status != HKS_SUCCESS)
            return status;
    
        if (operation.core_alg == HKS_ALG_GCM) { 
            status = hks_aead_unpadded_locate_tag(operation.tag_length,
                aead_data->ciphertext, aead_data->ciphertext_length, aead_data->plaintext_length, &tag);
            if (status != HKS_SUCCESS)
                goto exit;
    
            /* length had been checked in hks_aead_unpadded_locate_tag */
            status = mbedtls_gcm_auth_decrypt(&operation.gcm, aead_data->ciphertext_length - operation.tag_length,
                aead_data->nonce, aead_data->nonce_length, aead_data->additional_data,
                aead_data->additional_data_length, tag, operation.tag_length, aead_data->ciphertext,
                aead_data->plaintext);
            //解密autu基于gcm验证
        } else { 
            status = HKS_ERROR_NOT_SUPPORTED;
            goto exit;
        }
        if (status != HKS_SUCCESS && aead_data->plaintext_length != 0)
            (void)memset_s(aead_data->plaintext, aead_data->plaintext_length, 0, aead_data->plaintext_length);
            //初始化明文
    exit:
        mbedtls_gcm_free(&(operation.gcm));
        if (status == HKS_SUCCESS)
            *plaintext_output_length =//明文的长度为密文长度减去标记域的长度
            aead_data->ciphertext_length - operation.tag_length;
        return mbedtls_to_hks_error(status);//返回status状态值对饮hks的错误码
    }

## 三、总结 ##

以上就是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