鸿蒙如何拿到的公钥和 MD5 值鸿蒙代码知乎

转载

IT独行侠 2024-03-28 19:03:36

文章标签 鸿蒙如何拿到的公钥和 MD5 值算法 c++ sha256 harmonyos 文章分类 运维

文章目录

安全密钥库模块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）

一、背景知识

头文件介绍相关算法介绍

二、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;
    //重置相关属性值
}