当前位置: article > 正文

鸿蒙源码分析（四十二）_mbedtls源码解释

作者：花生_TL007 | 2024-03-15 22:38:32

踩

mbedtls源码解释

hks_mbedtls_aes.c代码分析

一、背景知识

自己对代码的一些见解
这里主要是使用mbedtls库中aes对应的一些函数，该库中将功能基本封装好。鸿蒙这里进行了进一步的适配和封装。主要实现一些密钥的生成，加解密的实现。这里的加解密相比其他文件有一个特殊点：就是加解密都封装在一个函数内，在函数形参中传入逻辑变量来实现。相当于一个开关变量，开的时候实现加密，关闭的时候实现解密。真正的封装好各部分功能。

aes算法介绍链接：

二、代码分析

1.密钥的生成
实现最基础的密钥生成（基于随机数的生成实现密钥生成，填写随机数据进key中data）

//密钥的生成
int32_t HksMbedtlsAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key)
{
    const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE;

    uint8_t *outKey = (uint8_t *)HksMalloc(keyByteLen);
    //先申请空间用来存放随机数据（密钥数据）
    if (outKey == NULL) {
        return HKS_ERROR_MALLOC_FAIL;
    }

    mbedtls_entropy_context entropy;
    mbedtls_ctr_drbg_context ctrDrbg;
    int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy);
    //随机数种子（熵源）
    if (ret != HKS_SUCCESS) {
        HKS_FREE_PTR(outKey);
        return ret;
    }

    do {
        ret = mbedtls_ctr_drbg_random(&ctrDrbg, outKey, keyByteLen);
        //在对应空间outkey生成随机数
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls ctr drbg random failed! mbedtls ret = 0x%X", ret);
            (void)memset_s(outKey, keyByteLen, 0, keyByteLen);
            HKS_FREE_PTR(outKey);
            break;
        }
        //将最后结果写进key的数据域和size
        key->data = outKey;
        key->size = keyByteLen;
    } while (0);

    mbedtls_ctr_drbg_free(&ctrDrbg);
    mbedtls_entropy_free(&entropy);
    //释放随机数空间和熵源
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2.aes/cbc在nopadding模式下的加密
第一种加密模式，其中参数最重要的个人认为是这个bool变量 encrypt。他象个开关控制是加密还是解密。
参数介绍：

key：加解密的密钥
cipherParam：密文参数信息
message：加密的结果会生成一个消息
encrypt：逻辑变量控制是加密还是解密
ciphetext：密文信息

static int32_t AesCbcNoPaddingCrypt(const struct HksBlob *key, const struct HksCipherParam *cipherParam,
    const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
{
    mbedtls_aes_context ctx;
    mbedtls_aes_init(&ctx);

    int32_t ret;
    do {
        if (encrypt) {
            ret = mbedtls_aes_setkey_enc(&ctx, key->data, key->size * HKS_BITS_PER_BYTE);
        //根据传入的参数，如果为逻辑真就设置一套加密密钥
        } else {
            ret = mbedtls_aes_setkey_dec(&ctx, key->data, key->size * HKS_BITS_PER_BYTE);
        }
        //如果为逻辑假就设置一套解密密钥
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls aes set key failed! mbedtls ret = 0x%X", ret);
            break;
        }

        /* mbedtls_aes_crypt_cbc will refresh iv, so need a temp iv */
        uint8_t tmpIv[HKS_AES_CBC_NOPADDING_IV_SIZE];
        //定义一组临时向量iv
        if (memcpy_s(tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE, cipherParam->iv.data, cipherParam->iv.size) != EOK) {
            HKS_LOG_E("Memcpy temp iv failed!");
            break;
        }
        //初始化tmpiv的空间为cipherParam->iv.data
        ret = mbedtls_aes_crypt_cbc(&ctx, (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT),
            message->size, tmpIv, message->data, cipherText->data);
        //加解密的实现，根据逻辑值判断为加密还是解密
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtks aes cbc crypt failed! mbedtls ret = 0x%X", ret);
            (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
            break;
        }
        cipherText->size = message->size;
        //将最后加密后的message内容写进密文
    } while (0);

    mbedtls_aes_free(&ctx);
    //释放相关空间ctx
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

3.aes/cbc在pkcs7下的加密
该函数也是一种加解密的方式，上一种是nopadding，着一种是okcs7的方法。参数功能基本相似。

参数介绍：

key：加解密的密钥
cipherParam：密文参数信息
message：加密的结果会生成一个消息
encrypt：逻辑变量控制是加密还是解密
ciphetext：密文信息

//pkcs7的加解密
static int32_t AesCbcPkcs7Crypt(const struct HksBlob *key, const struct HksCipherParam *cipherParam,
    const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
{
    const uint32_t keyBitLen = key->size * HKS_BITS_PER_BYTE; 
    //密钥的位长度
    const mbedtls_cipher_info_t *info =
        mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, keyBitLen, MBEDTLS_MODE_CBC);
    //村数组中获取密文信息
    mbedtls_cipher_context_t ctx;
    mbedtls_cipher_init(&ctx);
    //cipher变量初始化
    int32_t ret;
    do {
        ret = mbedtls_cipher_setup(&ctx, info);
        //以指定信息设置ctx
        if (ret != HKS_SUCCESS) {
            HKS_LOG_E("Mbedtls cbc pkcs7 setup ctx failed! mbedtls ret = 0x%X", ret);
            break;
        }

        ret = mbedtls_cipher_setkey(&ctx, key->data, keyBitLen, (encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT));
        //根据encrypt传入的逻辑值来判断是要设置加密密文还是解密密文
        if (ret != HKS_SUCCESS) {
            HKS_LOG_E("Mbedtls cbc pkcs7 set key failed! mbedtls ret = 0x%X", ret);
            break;
        }

        ret = mbedtls_cipher_crypt(&ctx, cipherParam->iv.data, cipherParam->iv.size,
            message->data, message->size, cipherText->data, (size_t *)&(cipherText->size));
        //加解密的实现。上一步密钥密文信息的设置结果，在ctx中的结果实现加解密。
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls cbc pkcs7 crypt failed! mbedtls ret = 0x%X", ret);
            (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
        }
    } while (0);

    mbedtls_cipher_free(&ctx);
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

4.aes/cbc的普通加密
该函数主要也是调用之前的加密方法，将算法写进usageSpec进行判断选用不同的模式进行加解密。

//封装函数
#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
static int32_t AesCbcCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
    const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
{
    const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam);

    switch (usageSpec->padding) {
        //根据usageSpec中内容进行分支，里面是判断选用nopadding还是pkcs7算法
#ifdef HKS_SUPPORT_AES_CBC_NOPADDING
        case HKS_PADDING_NONE:
            return AesCbcNoPaddingCrypt(key, cipherParam, message, encrypt, cipherText);
#endif
#ifdef HKS_SUPPORT_AES_CBC_PKCS7
        case HKS_PADDING_PKCS7:
            return AesCbcPkcs7Crypt(key, cipherParam, message, encrypt, cipherText);
#endif
        default:
            HKS_LOG_E("Unsupport padding! mode = 0x%X", usageSpec->padding);
            return HKS_ERROR_INVALID_PADDING;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5.aes和gcm的加密
aes和gcm的加密模式。

static int32_t AesEncryptGcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
    const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead)
{
    mbedtls_gcm_context ctx;
    mbedtls_gcm_init(&ctx);
    //先定义及初始化一个gcm的密文信息ctx
    int32_t ret;
    do {
        ret = mbedtls_gcm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
        //设置一个密钥，写进key中
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%X", ret);
            break;
        }

        const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
        ret = mbedtls_gcm_crypt_and_tag(&ctx, MBEDTLS_GCM_ENCRYPT, message->size,
            aeadParam->nonce.data, aeadParam->nonce.size, aeadParam->aad.data, aeadParam->aad.size,
            message->data, cipherText->data, tagAead->size, tagAead->data);
        //调用mbedtls_gcm_crypt_and_tag实现加密和标记
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%X", ret);
            (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
            (void)memset_s(tagAead->data, tagAead->size, 0, tagAead->size);
            break;
        //加密失败的处理
        }
        cipherText->size = message->size;
        //将最后结果写进密文
    } while (0);

    mbedtls_gcm_free(&ctx);
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

6.aes和gcm的解密
对应的解密函数，一般加密函数会对应一个唯一的解密函数。或者是将两个函数写在一起，用逻辑变量区分。

//aes/gcm的解密
static int32_t AesDecryptGcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
    const struct HksBlob *message, struct HksBlob *cipherText)
{
    mbedtls_gcm_context ctx;
    mbedtls_gcm_init(&ctx);

    int32_t ret;
    do {
        ret = mbedtls_gcm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%X", ret);
            break;
        }

        const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
        ret = mbedtls_gcm_auth_decrypt(&ctx, message->size, aeadParam->nonce.data, aeadParam->nonce.size,
            aeadParam->aad.data, aeadParam->aad.size, aeadParam->tagDec.data, aeadParam->tagDec.size,
            message->data, cipherText->data);
        if (ret != HKS_MBEDTLS_SUCCESS) {
            HKS_LOG_E("Mbedtls aes gcm decrypt failed! mbedtls ret = 0x%X", ret);
            (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
            break;
        }
        cipherText->size = message->size;
    } while (0);

    mbedtls_gcm_free(&ctx);
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7.密钥的检查
检查密钥的位长度size是否位128、192、256等。

//密钥的检查
static int32_t CheckKeySize(const struct HksBlob *key)
{
    if ((key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)) && (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192)) &&
        (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256))) {
    //检查密钥字节长度是否为128或者是192或者是256
        return HKS_ERROR_INVALID_KEY_SIZE;
    }

    return HKS_SUCCESS;
}
1
2
3
4
5
6
7
8
9
10
11

8.加密和解密功能的封装
总的函数功能封装，将会情况写进usagespec中，然后采用switch语句将不同函数封装进去，cbc将nopadding和pkcs7封装在了一起，整体叫做cbc加密，而相对应的另一种加解密方式就是gcm和aes的加解密模式，这里封装cbc和gcm的情况。同时实现了解密的封装。

//函数功能的封装，根据不同情况判断使用何种加解密方式
int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
    const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead)
{
    if (CheckKeySize(key) != HKS_SUCCESS) {
        HKS_LOG_E("Invalid aes keySiz = 0x%X", key->size);
        return HKS_ERROR_INVALID_KEY_SIZE;
    }

    switch (usageSpec->mode) {
        //基于usageSpec->mode进行分支选择加解密算法
#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
        case HKS_MODE_CBC:
            return AesCbcCrypt(key, usageSpec, message, true, cipherText);
#endif
#ifdef HKS_SUPPORT_AES_GCM
        case HKS_MODE_GCM:
            return AesEncryptGcm(key, usageSpec, message, cipherText, tagAead);
#endif
#ifdef HKS_SUPPORT_AES_CCM
        case HKS_MODE_CCM:
            return AesEncryptCcm(key, usageSpec, message, cipherText, tagAead);
#endif
        default:
            HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode);
            return HKS_ERROR_INVALID_ARGUMENT;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

解密的封装

//解密的封装
int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
    const struct HksBlob *message, struct HksBlob *cipherText)
{
    if (CheckKeySize(key) != HKS_SUCCESS) {
        HKS_LOG_E("Invalid aes keySize = 0x%X", key->size);
        return HKS_ERROR_INVALID_KEY_SIZE;
    }

    switch (usageSpec->mode) {
#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
        case HKS_MODE_CBC:
            return AesCbcCrypt(key, usageSpec, message, false, cipherText);
#endif
#ifdef HKS_SUPPORT_AES_GCM
        case HKS_MODE_GCM:
            return AesDecryptGcm(key, usageSpec, message, cipherText);
#endif
#ifdef HKS_SUPPORT_AES_CCM
        case HKS_MODE_CCM:
            return AesDecryptCcm(key, usageSpec, message, cipherText);
#endif
        default:
            HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode);
            return HKS_ERROR_INVALID_ARGUMENT;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/245089