鸿蒙源码分析（二十三）

Myth丶恋晨 2022-09-04 05:50 221阅读 0赞

### 文章目录 ###

*  安全密钥库模块hks\_common.c代码分析
 *   *  一、背景知识
     *  二、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]

## 二、hks\_common.c代码分析 ##

**生成随机数算法**  
该函数用来生成一个随机数，其中使用到了ctr\_drbg这个伪随机数生成器。  
参数解释

*  random ：随机数存储的缓冲区
 *  len ：随机数的长度

返回值：返回成功或者错误码

//生成随机数函数，返回错误码或者成功
    int32_t hks_gen_random(uint8_t *random, uint32_t len)
    { 
        if (random == NULL) { 
            log_error("invalid random");
            return HKS_ERROR_NULL_POINTER;
        }
    
        if ((len == 0) || (len > HKS_RANDOM_MAX_LEN)) { 
            log_error("invalid len=%u", len);
            return HKS_ERROR_INVALID_ARGUMENT;
        }
        //检查传入参数的合理性
    
        mbedtls_ctr_drbg_context ctr_drbg;
        mbedtls_entropy_context entropy;
    
        (void)memset_s(&ctr_drbg, sizeof(ctr_drbg), 0, sizeof(ctr_drbg));
        //初始化ctr_drbg内容
        mbedtls_entropy_init(&entropy); //初始化entropy
        int ret = HKS_SUCCESS;
    
        /* use the g_hks_random_seed_custom without string terminator */
        int32_t rc = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
            &entropy, g_hks_random_seed_custom,
            sizeof(g_hks_random_seed_custom));
        //生成一个伪随机数
    
        if (rc != HKS_STATUS_OK) { 
            log_error("ctr drbg seed fail,rc=%d", rc);
            ret = HKS_ERROR_INTERNAL_UNKOWN;
            goto exit;
        }//对生成随机数的成功状态进行检查
    
        rc = mbedtls_ctr_drbg_random(&ctr_drbg, random, len);
        if (rc != HKS_STATUS_OK) { 
            log_error("ctr drbg random fail,rc=%d", rc);
            ret = HKS_ERROR_INTERNAL_UNKOWN;
        }
    exit:
        mbedtls_ctr_drbg_free(&ctr_drbg);
        mbedtls_entropy_free(&entropy);
        //释放相关空间，返回ret值。
        return ret;
    }

**计算sha526相关算法原理**  
这个函数主要涉及SHA256算法中的计算过程，SHA256算法是一个单向的哈希函数  
参数详解：

*  hash\_src ：哈希函数的来源、
 *  hash\_src\_num：哈希函数来源的数量
 *  hash\_result ：哈希函数的结果

返回值：成功则返回成功值，否则返回错误代码

//计算sha526相关算法原理
    int32_t hks_calc_sha256(const struct hks_blob *hash_src, uint32_t hash_src_num, struct hks_blob *hash_result)
    { 
        if (hash_src == NULL) { 
            log_error("invalid hash src");
            return HKS_ERROR_NULL_POINTER;
        }
        if (hash_result == NULL) { 
            log_error("invalid hash result");
            return HKS_ERROR_NULL_POINTER;
        }
        //检查传入参数的合理性
        mbedtls_sha256_context sha256_ctx;
        mbedtls_sha256_init(&sha256_ctx);
        //定义SHA256并且完成初始化
        int rc = mbedtls_sha256_starts_ret(&sha256_ctx, HKS_BOOL_FALSE);
        //SHA256开始设置
        if (rc != HKS_SUCCESS) { 
            log_error("sha256 starts fail,rc=%d", rc);
            return HKS_ERROR_INTERNAL_UNKOWN;
            //start_ret设置失败的处理
        }
    
        do { 
            uint32_t i = 0;
            for (; i < hash_src_num; ++i) { 
                rc = mbedtls_sha256_update_ret(&sha256_ctx,
                    hash_src[i].data, hash_src[i].size);
                //更新相关内容
                if (rc != HKS_SUCCESS) { 
                    log_error("sha256 update fail,rc=%d,i=%u", rc, i);
                    break;
                }
            }
            if (rc != HKS_STATUS_OK)
                break;
    
            rc = mbedtls_sha256_finish_ret(&sha256_ctx, hash_result->data);
            //结束sha256算法
            if (rc != HKS_SUCCESS) { 
                log_error("sha256 finish fail,rc=%d,i=%u", rc, i);
                break;
            }
        } while (0);//用来执行一次的循环
    
        mbedtls_sha256_free(&sha256_ctx); //释放sha256_ctx空间
        if (rc != HKS_STATUS_OK)
            return HKS_ERROR_INTERNAL_UNKOWN;
    
        return HKS_STATUS_OK;
    }

**检查缓冲区数据初始化的参数**  
基于hks\_chk\_init\_buf\_data\_para函数实现上述功能，  
参数详解：

*  data\_type ：数据类型
 *  buf ：缓冲区
 *  buf\_len ：缓冲区的长度

返回值：成功值或者失败代码

//用来检查缓冲区数据初始化的参数
    static int32_t hks_chk_init_buf_data_para(uint8_t data_type, const uint8_t *buf, uint32_t buf_len)
    { 
        if (buf == NULL) { 
            log_error("invalid buf");
            return HKS_ERROR_NULL_POINTER;
        } //检查缓冲区是否为空
    
        if ((data_type > HKS_INIT_DATA_TYPE_MAX) || (buf_len == 0)) { 
            log_error("invalid para,data_type=%u,buf_len=%u", data_type,
                buf_len);
        //检查数据类型和混缓冲区长度
            return HKS_ERROR_INVALID_ARGUMENT;
        }
    
        return HKS_STATUS_OK;
    }

**初始化缓冲区数据**  
hks\_init\_buf\_data函数用来初始化buf\_data中数据。  
参数详解：

*  data\_type ：数据类型
 *  buf ：缓冲区
 *  buf\_len ：缓冲区的长度

int32_t hks_init_buf_data(uint8_t data_type, uint8_t *buf, uint32_t buf_len)
    { 
        int32_t rc = hks_chk_init_buf_data_para(data_type, buf, buf_len);
    
        if (rc != HKS_STATUS_OK)
            return rc;
    
        if (data_type == HKS_INIT_DATA_TYPE_ALL_ZERO) { 
            (void)memset_s(buf, buf_len, 0, buf_len);
            //初始化为全0
        } else if (data_type == HKS_INIT_DATA_TYPE_ALL_ONE) { 
            (void)memset_s(buf, buf_len, 0xFF, buf_len);
            //初始化为全1
        } else { 
            /* random data */
            rc = hks_gen_random(buf, buf_len);//初始化为随机值
        }
    
        return rc;
    }

**申请并且初始化内存**  
hks\_malloc\_init\_ptr函数基于malloc来申请斌初始化申请的内存空间  
参数解释

*  size：索要申请的内存空间大小
 *  ptr：输出的指针

//申请并初始化内存空间
    int32_t hks_malloc_init_ptr(uint32_t size, uint8_t **ptr)
    { 
        if (ptr == NULL)
            return HKS_ERROR_NULL_POINTER;
        if (size == 0)
            return HKS_ERROR_INVALID_ARGUMENT;
        //先检查传入的参数是否合理
        *ptr = (uint8_t *)HKS_MALLOC(size);
        //申请空间
        if (*ptr == NULL)
            return HKS_ERROR_INSUFFICIENT_MEMORY;
        //检查是否申请成功
        if (memset_s(*ptr, size, 0, size) != EOK) { 
            //初始化内存空间，否则就释放
            hks_free_ptr(*ptr);
            return HKS_ERROR_BAD_STATE;
        }
        return HKS_STATUS_OK;
        //返回状态值
    }

**摧毁hks\_blob**  
这个函数主要用来释放blob->data所指向的内存空间。

void hks_blob_destroy(struct hks_blob *blob)
    { 
        if (blob == NULL)
            return;
        if (blob->size == 0)
            return;
        //检查传入的参数合理性
    
        if (blob->data != NULL) { 
            (void)memset_s(blob->data, blob->size, 0, blob->size);
            hks_free_ptr(blob->data);
        //如果blob->data指向的内容不为空，先初始化其中内容为0，然后就释放所指向的空间，
        }
    
        blob->size = 0;
        blob->type = HKS_BLOB_TYPE_RAW;
        //重置相关属性值
    }

## 三、总结 ##

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

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