security_huks模块下hks_service.c代码评注（三）

最新推荐文章于 2024-09-28 20:07:53 发布

心永向阳

最新推荐文章于 2024-09-28 20:07:53 发布

阅读量203

点赞数

分类专栏： security_function OpenHarmony security_huks 文章标签： c语言

本文链接：https://blog.csdn.net/HORHEART/article/details/120675071

版权

OpenHarmony 同时被 3 个专栏收录

32 篇文章 8 订阅

订阅专栏

security_huks

19 篇文章 0 订阅

订阅专栏

security_function

10 篇文章 0 订阅

订阅专栏

本文概述了security_huks模块中hks_service.c文件关于非对称密钥服务（如签名、验证和初始化）以及大数运算（如模幂运算）的函数细节。涉及关键函数如hks_service_asymmetric_sign、hks_service_asymmetric_verify和hks_service_bn_exp_mod，展示了如何使用和验证密钥以及执行复杂的数学操作。

摘要由CSDN通过智能技术生成

security_huks模块下hks_service.c代码评注（三）

本篇概述
代码框架
非对称密钥与认证服务
大数运算服务
- 1. hks_service_bn_exp_mod_check
- 2. hks_service_bn_exp_mod

本篇概述

本篇接续security_huks模块下hks_service.c代码评注（二），继续讲解hks_service下有关非对称密钥服务以及部分跟大数幂模运算相关的函数服务。

代码框架

hks_service.c
├── asymmetric_service
│ └── hks_service_asymmetric_sign
│ └── hks_service_asymmetric_verify
│ └── hks_service_verify_with_alias
│ └── hks_service_asymmetric_verify_init
├── computing_service
│ └── hks_service_bn_exp_mod_check
│ └── hks_service_bn_exp_mod

非对称密钥与认证服务

1. hks_service_asymmetric_sign

函数功能：非对称签名服务
非对称密钥的签名的工作思路大致为：在检查传入密钥别名、密钥参数以及相关算法与签名符合条件的基础上，不通过公钥获取私钥的签名，具体来说就是利用ED25519_sign签名算法直接对说呢过程的私钥进行签名，并将签名内容附在私钥数据的后32位。详细代码和标注如下：

//函数功能：非对称签名服务
int32_t hks_service_asymmetric_sign(const struct hks_blob *key_alias,
    const struct hks_key_param *key_param, const struct hks_blob *hash,
    struct hks_blob *signature)
{
    //判断传入参数是否合规
    hks_if_true_return_error(((key_alias == NULL) || (key_param == NULL) || (hash == NULL) ||
        (signature == NULL)), HKS_ERROR_NULL_POINTER);

    hks_if_true_return_error((signature == NULL), HKS_ERROR_NULL_POINTER);
    if ((key_param->key_usage & HKS_KEY_USAGE_SIGN) == 0)
        return HKS_ERROR_NOT_SUPPORTED;

    if ((signature->data == NULL) || (signature->size < CRYPTO_BYTES))
        return HKS_ERROR_BUFFER_TOO_SMALL;

    uint32_t key_size = 0;
    //获取存储时的密钥大小信息
    int32_t res = hks_storage_get_key_size(key_alias, &key_size);

    if ((res != HKS_SUCCESS) || (key_size == 0))
        return HKS_ERROR_INVALID_PRIVATE_KEY;

    //定义参数、私钥以及密钥信息结构体
    struct hks_key_param param;
    struct hks_blob  private_key;
    struct hks_storage_key_info key_info;

    //初始化参数与密钥信息为0
    (void)memset_s(&param, sizeof(param), 0, sizeof(param));
    (void)memset_s(&key_info, sizeof(key_info), 0, sizeof(key_info));

    //私钥类别和大小赋值
    private_key.type = HKS_BLOB_TYPE_KEY;
    private_key.size = CRYPTO_SECRET_KEY_BYTES;
    //私钥的初始化
    res = hks_malloc_init_ptr(CRYPTO_SECRET_KEY_BYTES,
        &(private_key.data));
    hks_if_status_error_goto_error(res, exit);

    //参数部分密钥id数据初始化
    res = hks_malloc_init_ptr(HKS_AUTH_ID_MAX_SIZE,
        &(param.key_auth_id.data));
    hks_if_status_error_goto_error(res, exit);
    //密钥参数的赋值
    param.key_auth_id.size = HKS_AUTH_ID_MAX_SIZE;

    key_info.param = &param;
    key_info.public_key = NULL;
    key_info.private_key = &private_key;

    //从存储内容中读取密钥信息
    res = hks_storage_read_key_info(key_alias, &key_info);
    if (res != HKS_SUCCESS)
        goto exit;
    //检查私钥数据与大小
    if ((private_key.data == NULL) || (private_key.size != CRYPTO_SECRET_KEY_BYTES)) {
        res = HKS_ERROR_INVALID_PRIVATE_KEY;
        goto exit;
    }
    //进行椭圆曲线25519签名服务，在私钥数据后32位加上签名内容
    if (ED25519_sign(signature->data, hash->data, hash->size,
        private_key.data + CRYPTO_PUBLIC_KEY_BYTES, private_key.data) != HKS_BOOL_TRUE)
        res = HKS_FAILURE;

exit:
    //销毁私钥、参数信息，返回检查状态码
    hks_blob_destroy(&private_key);
    hks_free_ptr(param.key_auth_id.data);
    hks_check_return_code(res, &res);
    return res;
}
#endif

2. hks_service_asymmetric_verify

函数功能:非对称认证服务
本部分服务的关键在于调用非对称认证初始化服务后使用椭圆曲线ED25519进行密钥认证，返回认证结果状态。详细代码及标注如下：

#ifndef _CUT_AUTHENTICATE_
//函数功能:非对称认证服务
int32_t hks_service_asymmetric_verify(const struct hks_blob *key_alias,
    const struct hks_blob *hash, const struct hks_blob *signature)
{
    hks_if_true_return_error(((key_alias == NULL) || (hash == NULL) || (signature == NULL)), HKS_ERROR_NULL_POINTER);
    
    //密钥参数、公钥、存储密钥信息结构体定义
    struct hks_key_param param;
    struct hks_blob  public_key = HKS_BLOB_DEFAULT_VALUE;
    struct hks_storage_key_info key_info;

    //参数与密钥信息的赋值
    (void)memset_s(&param, sizeof(param), 0, sizeof(param));
    (void)memset_s(&key_info, sizeof(key_info), 0, sizeof(key_info));

    //调用非对称认证初始化服务
    int32_t ret = hks_service_asymmetric_verify_init(key_alias,
        &param, &public_key, &key_info);

    if (ret != HKS_STATUS_OK)
        goto exit;

    //使用椭圆曲线ED25519进行密钥认证，返回认证结果状态
    if (ED25519_verify(hash->data, hash->size, signature->data,
        public_key.data) == HKS_BOOL_TRUE)
        ret = HKS_SUCCESS;
    else
        ret = HKS_FAILURE;
exit:
    //释放公钥数据以及密钥参数id数据
    if (key_alias->type == HKS_BLOB_TYPE_ALIAS) {
        hks_free_ptr(public_key.data);
        hks_free_ptr(param.key_auth_id.data);
    }
    //返回系统状态值
    return ret;
}

3. hks_service_verify_with_alias

函数功能：使用别名认证服务
该部分的服务认证主要是通过检查key_alias对应的密钥大小来进行的，详细代码及标注如下：

//函数功能：使用别名认证服务（主要是通过检查key_alias对应的密钥大小来进行认证的）
static int32_t hks_service_verify_with_alias(const struct hks_blob *key_alias,
    struct hks_blob *public_key,
    struct hks_key_param *param, struct hks_storage_key_info *key_info)
{
    //从key_alias对应的存储内容中获取密钥大小
    uint32_t key_size = 0;
    int32_t res = hks_storage_get_key_size(key_alias, &key_size);

    //检查密钥大小与系统状态是否合规
    hks_if_true_return_error(((res != HKS_SUCCESS) || (key_size == 0)),
        HKS_ERROR_INVALID_PUBLIC_KEY);
    //初始化公钥数据
    res = hks_malloc_init_ptr(CRYPTO_PUBLIC_KEY_BYTES,
        &(public_key->data));
    //检查初始化状态
    hks_if_status_error_goto_error(res, exit);
    //初始化密钥参数id数据
    res = hks_malloc_init_ptr(HKS_AUTH_ID_MAX_SIZE,
        &(param->key_auth_id.data));
    //检查初始化状态
    hks_if_status_error_goto_error(res, exit);
    param->key_auth_id.size = HKS_AUTH_ID_MAX_SIZE;
    //从key_alias下读取密钥信息存储数据
    res = hks_storage_read_key_info(key_alias, key_info);
    if (res != HKS_SUCCESS)
        goto exit;

    //进行公钥大小检查
    if (key_info->public_key->size != CRYPTO_PUBLIC_KEY_BYTES) {
        res = HKS_ERROR_INVALID_PUBLIC_KEY;
        goto exit;
    }
exit:
    //进行内存空间的释放
    if (res != HKS_STATUS_OK) {
        hks_free_ptr(public_key->data);
        hks_free_ptr(param->key_auth_id.data);
    }
    return res;
}

4. hks_service_asymmetric_verify_init

函数功能：非对称认证初始化服务
此函数的关键在于公钥、密钥信息的赋值与初始化工作之后的一个判断，如果密钥别名类型为BLOB_TYPE_ALIAS则直接调用hks_service_verify_with_alias（）函数进行别名认证，如果密钥别名类型为BLOB_TYPE_KEY则直接进行公钥的赋值。详细代码及标注如下：

//函数功能：非对称认证初始化服务
static int32_t hks_service_asymmetric_verify_init(
    const struct hks_blob *key_alias, struct hks_key_param *param,
    struct hks_blob *public_key, struct hks_storage_key_info *key_info)
{
    //进行公钥、密钥信息的赋值与初始化工作
    public_key->type = HKS_BLOB_TYPE_KEY;
    public_key->size = CRYPTO_PUBLIC_KEY_BYTES;
    key_info->param = param;
    key_info->public_key = public_key;
    key_info->private_key = NULL;
    
    //检查密钥别名类型为BLOB_TYPE_ALIAS则直接调用hks_service_verify_with_alias函数进行别名认证
    if (key_alias->type == HKS_BLOB_TYPE_ALIAS) {
        int32_t res = hks_service_verify_with_alias(key_alias,
            public_key, param, key_info);

        hks_if_status_error_return(res);
    } else if (key_alias->type == HKS_BLOB_TYPE_KEY) {
        //如果密钥别名类型为BLOB_TYPE_KEY则直接进行公钥的赋值
        public_key->data = key_alias->data;
        public_key->size = key_alias->size;
    }
    hks_if_true_return_error((public_key->data == NULL),
        HKS_ERROR_INVALID_KEY_INFO);
    hks_if_true_return_error((public_key->size < CRYPTO_PUBLIC_KEY_BYTES),
        HKS_ERROR_BUFFER_TOO_SMALL);
    return HKS_STATUS_OK;
}

大数运算服务

1. hks_service_bn_exp_mod_check

函数功能：模幂运算服务参数检查
模幂运算服务参数检查是大数运算服务的辅助功能，详细代码及标注如下：

//模幂运算服务参数检查
static int32_t hks_service_bn_exp_mod_check(struct hks_blob* x,
    const struct hks_blob* a, const struct hks_blob* e,
    const struct hks_blob* n)
{
    //判断输入数据的大小以及数据是否合规
    hks_if_true_return_error((x->data == NULL), HKS_ERROR_NULL_POINTER);
    hks_if_true_return_error(((a->data == NULL) || (a->size <= 0)),
        HKS_ERROR_NULL_POINTER);
    hks_if_true_return_error(((e->data == NULL) || (e->size <= 0)),
        HKS_ERROR_NULL_POINTER);
    hks_if_true_return_error(((n->data == NULL) || (n->size <= 0)),
        HKS_ERROR_NULL_POINTER);
    hks_if_true_return_error((x->size < n->size),
        HKS_ERROR_INVALID_ARGUMENT);
    return HKS_STATUS_OK;
}

2. hks_service_bn_exp_mod

函数功能：实现大数的幂-模运算
该部分大数运算的主要过程由接口函数实现

调用参数检查函数hks_service_bn_exp_mod_check（）进行参数的检查
调用接口初始化参数并分配空间hks_bn_init（）
初始化接口函数为：

void hks_bn_init(mbedtls_mpi *bn)
{
    mbedtls_mpi_init(bn);
}

调用接口hks_bn_import（）读入二进制数包括数据的内容和大小
接口函数为：

int32_t hks_bn_import(mbedtls_mpi *bn, const unsigned char *data, size_t size)
{
    return mbedtls_mpi_read_binary(bn, data, size);
}

调用接口函数hks_bn_mpi_exp_mod（）进行模幂计算
模幂运算接口为：

int32_t hks_bn_mpi_exp_mod(mbedtls_mpi *x, const mbedtls_mpi *a,
    const mbedtls_mpi *e, const mbedtls_mpi *n)
{
    return mbedtls_mpi_exp_mod(x, a, e, n, NULL);
}

参数检查有误则通过调用接口函数hks_bn_free（）将空间释放，最终返回状态量
接口函数为：

void hks_bn_free(mbedtls_mpi *bn)
{
    mbedtls_mpi_free(bn);
}

详细代码及标注如下：

//函数功能：实现大数的幂-模运算
int32_t hks_service_bn_exp_mod(struct hks_blob* x,
    const struct hks_blob* a, const struct hks_blob* e,
    const struct hks_blob* n)
{
    //判断传入参数是否为空
    hks_if_true_return_error(((x == NULL) || (a == NULL) || (e == NULL) || (n == NULL)), HKS_ERROR_NULL_POINTER);

    //调用参数检查函数进行参数的检查
    int32_t status = hks_service_bn_exp_mod_check(x, a, e, n);

    hks_if_status_error_return(status);
    mbedtls_mpi bn_x, bn_a, bn_e, bn_n;

    //初始化大数
    /*void hks_bn_init(mbedtls_mpi *bn)
{
    mbedtls_mpi_init(bn);
}*/
//接口调用初始化参数并分配空间
/* init param & allocate memory */
    hks_bn_init(&bn_x);
    hks_bn_init(&bn_a);
    hks_bn_init(&bn_e);
    hks_bn_init(&bn_n);

    //调用接口读入二进制数包括数据的内容和大小
    /*int32_t hks_bn_import(mbedtls_mpi *bn, const unsigned char *data, size_t size)
{
    return mbedtls_mpi_read_binary(bn, data, size);
}*/
/* import data to mbedtls */
    status = hks_bn_import(&bn_a, a->data, a->size);
    hks_if_status_error_goto_error(status, error);
    status = hks_bn_import(&bn_e, e->data, e->size);
    hks_if_status_error_goto_error(status, error);
    status = hks_bn_import(&bn_n, n->data, n->size);
    hks_if_status_error_goto_error(status, error);

    //调用接口函数进行模幂计算
    /*int32_t hks_bn_mpi_exp_mod(mbedtls_mpi *x, const mbedtls_mpi *a,
    const mbedtls_mpi *e, const mbedtls_mpi *n)
{
    return mbedtls_mpi_exp_mod(x, a, e, n, NULL);
}*/
/* caculate mod */
    status = hks_bn_mpi_exp_mod(&bn_x, &bn_a, &bn_e, &bn_n);
    hks_if_status_error_goto_error(status, error);

    //调用接口函数将数据传输至blob
    /*int32_t hks_bn_export(const mbedtls_mpi *bn, unsigned char *data, size_t size)
{
    return mbedtls_mpi_write_binary(bn, data, size);
}*/
/* export data to blob */
    status = hks_bn_export(&bn_x, x->data, x->size);

    //参数检查有误则通过调用接口函数将空间释放，最终返回状态量
    /*void hks_bn_free(mbedtls_mpi *bn)
{
    mbedtls_mpi_free(bn);
}*/
error:
    //释放大数运算传入参数
    hks_bn_free(&bn_x);
    hks_bn_free(&bn_a);
    hks_bn_free(&bn_e);
    hks_bn_free(&bn_n);
    //返回检查返回状态码
    hks_check_return_code(status, &status);
    return status;
}