数据加密——aes-基于mbedTLS库

最新推荐文章于 2025-03-24 09:16:16 发布
最新推荐文章于 2025-03-24 09:16:16 发布
阅读量1.9k 收藏 13
点赞数 2
分类专栏： RT_rtread国产操作系统 文章标签： 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50183638/article/details/112029858
版权
本文介绍了如何在RT-Thread嵌入式操作系统中使用mbedTLS库实现AES-128 CBC加密和解密功能，包括数据加密函数和解密函数的详细代码，以及如何在实际应用中操作加密数据。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据加密——aes-基于mbedTLS库

mbedTLS（前身 PolarSSL）是一个由 ARM 公司开源和维护的 SSL/TLS 算法库。其使用 C 编程语言以最小的编码占用空间实现了 SSL/TLS 功能及各种加密算法，易于理解、使用、集成和扩展，方便开发人员轻松地在嵌入式产品中使用 SSL/TLS 功能

下面讲解在rt_thread国产实时操作系统中的使用，此处是对UDP的数据内容进行加密

1. 安装这个软件包

在这里插入图片描述
2. 添加自己的.c和.h文件

//crypto.c文件
#include <stdio.h>
#include <string.h>
#include <mbedtls/aes.h>
#include <mbedtls/arc4.h>
#include <mbedtls/md5.h>
#include <mbedtls/sha1.h>
#include <mbedtls/sha256.h>
#include <mbedtls/sha512.h>
#include "crypto.h"

static int __aes_cbc_encrypt(uint8_t *data, int len,
        const uint8_t *key, const uint8_t *iv,
        int key_size, int pad_type)
{
    int i, length;
    uint8_t ivcpy[16];
    uint8_t pad = 0;
    mbedtls_aes_context ctx;

    length = (len + 0x0f) & (~0x0f);

    if (pad_type == CRYPTO_AES_PADDING_NOPADDING && (len & 0x0f))
        return -1;

    if ((len & 0x0f) == 0 && pad_type == CRYPTO_AES_PADDING_PKCS5PADDING)
        length += 16;

    if (pad_type == CRYPTO_AES_PADDING_PKCS5PADDING)
        pad = length - len;

    for (i=0; i<length - len; i++)
        data[len + i] = pad;

    len = length;

    memcpy(ivcpy, iv, 16);

    mbedtls_aes_init(&ctx);
    mbedtls_aes_setkey_enc(&ctx, key, key_size);
    while (length > 0) {
        for (i=0; i<16; i++)
            data[i] ^= ivcpy[i];
        mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_ENCRYPT, data, data);
        memcpy(ivcpy, data, 16);
        data += 16; length -= 16;
    }
    mbedtls_aes_free(&ctx);

    return len;
}

static int __aes_cbc_decrypt(uint8_t *data, int len,
        const uint8_t *key, const uint8_t *iv,
        int key_size, int pad_type)
{
    int i, length;
    uint8_t ivcpy[16];
    uint8_t *ptr = data;
    uint8_t pad;
    mbedtls_aes_context ctx;

    if (len & 0xf)
        return -1;

    length = len;

    memcpy(ivcpy, iv, 16);

    mbedtls_aes_init(&ctx);
    mbedtls_aes_setkey_dec(&ctx, key, key_size);

    while (length > 0) {
        uint8_t tmp[16];

        memcpy(tmp, data, 16);
        mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_DECRYPT, data, data);
        for (i=0; i<16; i++)
            data[i] ^= ivcpy[i];
        memcpy(ivcpy, tmp, 16);
        data += 16; length -= 16;
    }

    mbedtls_aes_free(&ctx);

    if (pad_type == CRYPTO_AES_PADDING_NOPADDING || \
            pad_type == CRYPTO_AES_PADDING_ZEROPADDING)
        return len;

    pad = ptr[len - 1];
    if (pad < 1 || pad > 16)
        return -1;
    
    for (i=1; i<=pad; i++) {
        if (ptr[len - i] != pad)
            return -1;
        ptr[len - i] = 0;
    }

    return len - pad;
}

int crypto_aes_cbc_encrypt(const uint8_t *input, int len,
        uint8_t *output, const uint8_t *key, const uint8_t *iv,
        int key_size, int pad_type)
{
    if (key_size != CRYPTO_AES_KEY_128BITS && \
            key_size != CRYPTO_AES_KEY_256BITS)
        return -1;

    if (pad_type != CRYPTO_AES_PADDING_NOPADDING && \
            pad_type != CRYPTO_AES_PADDING_ZEROPADDING && \
            pad_type != CRYPTO_AES_PADDING_PKCS5PADDING)
        return -1;

    memcpy(output, input, len);

    return __aes_cbc_encrypt(output, len, key, iv, key_size, pad_type);
}

int crypto_aes_cbc_decrypt(const uint8_t *input, int len,
        uint8_t *output, const uint8_t *key, const uint8_t *iv,
        int key_size, int pad_type)
{
    if (key_size != CRYPTO_AES_KEY_128BITS && \
            key_size != CRYPTO_AES_KEY_256BITS)
        return -1;

    if (pad_type != CRYPTO_AES_PADDING_NOPADDING && \
            pad_type != CRYPTO_AES_PADDING_ZEROPADDING && \
            pad_type != CRYPTO_AES_PADDING_PKCS5PADDING)
        return -1;

    memcpy(output, input, len);

    return __aes_cbc_decrypt(output, len, key, iv, key_size, pad_type);
}

int crypto_aes_ecb_encrypt(const uint8_t *input, int len, 
        uint8_t *output, const uint8_t *key, int keybits)
{
    int i, cnt;
    mbedtls_aes_context ctx;

    if (len % 16)
        return -1;

    cnt = len / 16;

    if (keybits != CRYPTO_AES_KEY_128BITS && \
            keybits != CRYPTO_AES_KEY_256BITS)
        return -1;

    mbedtls_aes_init(&ctx);
    mbedtls_aes_setkey_enc(&ctx, key, keybits);
    for (i=0; i<cnt; i++)
        mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_ENCRYPT, \
                input + (i << 4), output + (i << 4));
    
    return len;
}

int crypto_aes_ecb_decrypt(const uint8_t *input, int len,
        uint8_t *output, const uint8_t *key, int keybits)
{
    int i, cnt;
    mbedtls_aes_context ctx;

    if (len % 16)
        return -1;

    cnt = len / 16;

    if (keybits != CRYPTO_AES_KEY_128BITS && \
            keybits != CRYPTO_AES_KEY_256BITS)
        return -1;

    mbedtls_aes_init(&ctx);
    mbedtls_aes_setkey_dec(&ctx, key, keybits);
    for (i=0; i<cnt; i++)
        mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_DECRYPT, \
                input + (i << 4), output + (i << 4));
    
    return len;
}

int crypto_rc4(const uint8_t *input, int len, 
        uint8_t *output, const uint8_t *key, int key_size)
{
    mbedtls_arc4_context ctx;

    mbedtls_arc4_init(&ctx);
    mbedtls_arc4_setup(&ctx, key, key_size);
    mbedtls_arc4_crypt(&ctx, len, input, output);
    mbedtls_arc4_free(&ctx);

    return len;
}

int crypto_md5(uint8_t *data, int len, uint8_t dest[16])
{
    mbedtls_md5(data, len, dest);

    return 16;
}

int crypto_sha1(uint8_t *data, int len, uint8_t dest[20])
{
    mbedtls_sha1(data, len, dest);

    return 20;
}

int crypto_sha224(uint8_t *data, int len, uint8_t dest[28])
{
    mbedtls_sha256(data, len, dest, 1);

    return 28;
}

int crypto_sha256(uint8_t *data, int len, uint8_t dest[32])
{
    mbedtls_sha256(data, len, dest, 0);
    
    return 32;
}

int crypto_sha384(uint8_t *data, int len, uint8_t dest[48])
{
    mbedtls_sha512(data, len, dest, 1);

    return 48;
}

int crypto_sha512(uint8_t *data, int len, uint8_t dest[64])
{
    mbedtls_sha512(data, len, dest, 0);

    return 64;
}

//crypto.h文件
#ifndef __CRYPTO_H__
#define __CRYPTO_H__

#include <stdint.h>

#define CRYPTO_RC4_KEY_SIZE                    16
#define CRYPTO_AES_KEY_128BITS                 128
#define CRYPTO_AES_KEY_256BITS                 256
#define CRYPTO_AES_PADDING_NOPADDING           0
#define CRYPTO_AES_PADDING_ZEROPADDING         1
#define CRYPTO_AES_PADDING_PKCS5PADDING        2

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

int crypto_aes_cbc_encrypt(const uint8_t *input, int len,
        uint8_t *output, const uint8_t *key, const uint8_t *iv,
        int keybits, int pad_type);

int crypto_aes_cbc_decrypt(const uint8_t *input, int len,
        uint8_t *output, const uint8_t *key, const uint8_t *iv,
        int keybits, int pad_type);

int crypto_aes_ecb_encrypt(const uint8_t *input, int len, 
        uint8_t *output, const uint8_t *key, int keybits);

int crypto_aes_ecb_decrypt(const uint8_t *data, int len,
        uint8_t *output, const uint8_t *key, int keybits);

int crypto_rc4(const uint8_t *data, int len, uint8_t *output,
        const uint8_t *key, int key_size);

int crypto_md5(uint8_t *data, int len, uint8_t dest[16]);

int crypto_sha1(uint8_t *data, int len, uint8_t dest[20]);

int crypto_sha224(uint8_t *data, int len, uint8_t dest[28]);

int crypto_sha256(uint8_t *data, int len, uint8_t dest[32]);

int crypto_sha384(uint8_t *data, int len, uint8_t dest[48]);

int crypto_sha512(uint8_t *data, int len, uint8_t dest[64]);

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif  /* __CRYPTO_H__ */

3. 添加头文件 #include "crypto.h"
在这里插入图片描述
3.对数据进行加密

static int protocol_data_encrypt(uint8_t *data,uint8_t *output,int len)//加密函数
{
    int encrypt;
    encrypt = (len + 0xf) & (~0xf);

    encrypt = crypto_aes_cbc_encrypt(data, len, output, pub_aes_key, initial_vector, \
            CRYPTO_AES_KEY_128BITS, CRYPTO_AES_PADDING_PKCS5PADDING);

    return encrypt;
}

需要加密时候对该函数进行引用，加密数据前是明文，加密后不可见
encrypt_data_lenth = protocol_data_encrypt((uint8_t *)payload ,data_encrypt ,rt_strlen(payload));
#encrypt_data_lenth 表示加密之后的数据长度
#payload 需要加密的数据
#data_encrypt 加密之后的数据（一般用数组保存）
#rt_strlen(payload) 传入加密数据的长度

4.解密数据

static int protocol_data_decrypt(uint8_t *intput,uint8_t *output, int len)//解密函数
{
    int decrypt = len;

    if (len & 0x0f)
        return -1;

    decrypt = crypto_aes_cbc_decrypt(intput, len, output, pub_aes_key, initial_vector, \
            CRYPTO_AES_KEY_128BITS, CRYPTO_AES_PADDING_PKCS5PADDING);
    if (decrypt < 0)
        return -1;

    return decrypt;
}

需要解密的时候对该函数进行引用，解密之后变成明文
decrypt_data_lenth = protocol_data_decrypt(data_ , data_decrypt , htons(packet_->length));
#decrypt_data_lenth 表示解密之后的数据长度
#data_ 表示需要被解密的数据
#data_decrypt 解密后的数据（一般使用数组进行保存）
#htons(packet_->length) 传入解密数据的长度

mbedtls | 06 - 非对称加密算法的配置与使用（RSA算法）
Mculover666的博客（嵌入式）
09-27 4131
mbedtls系列文章 mbedtls | 01 - 移植mbedtls库到STM32的两种方法 mbedtls | 02 - 伪随机数生成器（ctr_drbg）的配置与使用 mbedtls | 03 - 单向散列算法的配置与使用（MD5、SHA1、SHA256、SHA512） mbedtls | 04 - 对称加密算法的配置与使用（AES算法） mbedtls | 05 - 消息认证码的配置与使用（HMAC算法、GCM算法） Demo工程源码 https://github.com/Mculover6
ESP32-C3模组上跑通MD5（1）
phmatthaus的专栏
07-03 415
ESP32-C3模组上跑通MD5（1）
在ESP32下，使用mbedtls库，测试sha、aes.的简单DEMO
08-06
在ESP32下，使用mbedtls库，测试sha1和sha256/224 aes_ecb、aes_cbc的简单DEMO
基于mbedtls的AES加密(C/C++)
qq_36973838的博客
12-06 2768
高级加密标准（Advanced Encryption Standard，AES），是一种对称加密方式。AES支持三种加密方式：AES128，AES192，AES256，AES128标识密钥长度为128bit，AES128运算速度最快，AES256安全性最佳，三种方式的本质区别是加密轮数不同。
探索Mbed TLS：嵌入式系统中的加密与安全通信
最新发布
ScilogyHunter的博客
03-24 1262
Mbed TLS 是一个开源的加密库，旨在为嵌入式系统和资源受限的设备提供安全通信和加密功能。它支持多种加密算法（如AES、RSA、ECC）、哈希函数（如SHA-256）、随机数生成器以及SSL/TLS协议的实现。Mbed TLS 的设计目标是模块化、可移植和易于集成，使其成为嵌入式开发者的首选加密库。Mbed TLS 的模块化设计允许你根据需要启用或禁用特定功能。通过修改config.h文件，你可以自定义库的功能集，以减少资源占用。
mbedtls中的加密算法
b_tyro的博客
06-27 2643
AES（Advanced Encryption Standard）是目前最为流行的加密算法之一。它可以使用128位、192位或256位的密钥进行加密，安全性非常高，同时运算速度也比较快，因此得到了广泛的应用。AES加密算法采用分组加密方式，将明文按照固定的长度分成若干个块，每个块独立地进行加密。加密过程中，先将明文和密钥进行混淆，然后再通过多轮的置换和代换操作来实现加密。解密时，只需要按照相同的密钥和加密方式进行逆向操作就可以了。
C语言实现AES加密、解密算法
04-29
源文件为AES高级加密算法的C语言实现，由于AES加密算法的加密解密过程高度对称，程序可读性很强。改变宏定义中的加密轮数可以实现128位，192位以及256位的密钥加密，一次加密过程明文长度最多为128位，即16个字节，8个汉字。
C语言实现AES加密解密
sinat_28371057的博客
03-09 3680
AES加密是美国联邦政府采用的一种块加密标准，如今已经被全世界广为使用。嵌入式开发中我们也经常会用到加密解密算法，如果没有硬件模块来实现，就需要用到C代码软件实现。下面介绍调用mbedTLS中的AES加密解密函数实现AES算法。 mbedTLS是一个开源TLS协议栈，主要用于嵌入式开发，其源代码网址为https://tls.mbed.org/aes-source-code。在该页面上点击downloadmbedTLS即可下载最新的协议栈，解压该压缩包就可以得到协议栈源代码。协议栈中的各种算法都独立封装在C
mbed-tls-polarssl-1.0.0.tar.gz
06-05
尽管名字变更，其核心设计理念——提供轻量级的加密库以适应资源有限的设备——一直沿袭至今。在1.0.0版本中，PolarSSL已经具备了基础的加密算法支持，如RSA、AES、SHA等，以及支持TLSv1.2协议，能够满足基本的网络...
【鸿蒙南向开发】—— OpenHarmony源码分析之分布式软总线：mbed TLS库的应用
huchenghe2的博客
11-05 303
Mbed TLS 库旨在与现有（嵌入式）应用程序集成，并为安全通信、加密和密钥管理提供构建块。Mbed TLS 设计为尽可能松散耦合，允许您只集成您需要的部分，而无需其他部分的开销。这也导致 Mbed TLS 库的内存占用和构建占用非常低。通过消除系统中不需要的部件，您可以获得从低至 45 kB 到更典型的 300 kB 的构建大小，以实现功能更齐全的设置。
PKCS7 mbedtls
02-12
#### mbedtls库支持的加密标准概述 mbedtls是一个轻量级的密码学C语言库，广泛应用于嵌入式系统和其他资源受限环境中。该库提供了多种安全协议的支持，其中包括公钥基础设施(PKI)相关的功能。 #### PKCS7简介 PKCS7...
基于MbedTLS的AES加密实现，含STM32H7和STM32F4的实现例程-附件资源
03-05
基于MbedTLS的AES加密实现，含STM32H7和STM32F4的实现例程-附件资源
mbedtls移植之AES算法
辛勤搬砖的门卫的专栏
01-15 3341
mbedtls实现AES算法
使用mbedtls实现文件以及字符串的AES加密
生于忧患，死于安乐
08-21 3475
由于mbedtls主要支持TCP的TLS传输实现，由ARM公司加持，目前这个库的代码质量非常高，也可以用在其他加密解密领域，比如AES、DES、chacha20等加密，当然和libsodium实现互补，有些实现也必须用libsodium更好一些，不过这两个库的代码质量都很高。 示例代码展现了AES-256-ECB的加密如何使用，由于库里面有很多加密支持，可以参考mbedtls github原始代码的cipher_wrap.c实现，这里面实现了统一API封装，方便使用，只需要初始化时给出对应的类型参数，即可.
aes加密算法_基于mbedTLS的AES加密实现，含V7，V6和V5的配套测试例程
weixin_39606244的博客
11-27 395
说明：1、mbedTLS的前身是PolarSSL，开源免费。主要提供了SSL/TLS支持(在传输层对网络进行加密)，各种加密算法，各种哈希算法，随机数生成以及X.509(密码学里公钥证书的格式标准)的支持。2、mbedTLS支持的加密算法含对称加密和非对称加密：(1)mbedTLS支持的对称加密算法有：AES，ARCFOUR，Blowfish/BF，Camellia，DES/3DES，G...
mbedtls | 04 - 对称加密算法的配置与使用（AES算法）
Mculover666的博客（嵌入式）
09-23 2984
mbedtls系列文章 mbedtls | 01 - 移植mbedtls库到STM32的两种方法 mbedtls | 02 - 伪随机数生成器（ctr_drbg）的配置与使用 mbedtls | 03 - 单向散列算法的配置与使用（MD5、SHA1、SHA256、SHA512） Demo工程源码 https://github.com/Mculover666/mbedtls-study-demo 本工程基于STM32L41RCT6开发板，包含了本系列文章中所编写的所有Demo，持续更新…… 文章目录
STM32使用mbedtls的AES加密
果果小师弟的博客
10-18 2887
Author：果果小师弟 电子信息专业在读研究生 有一点思考，有一点想法，有一点理性！ 定个小小目标，努力成为习惯！在最美的年华遇见更好的自己！ CSDN@果果小师弟，CSDN首发，果果原创 唯一博客更新的地址为： ???? 果果小师弟的博客 ???? 一、安装mbedtls 转到keil官网http://www.keil.com/dd2/pack/ 找到ARM mbed Cryptographic and SSL/TLS library for Cortex-M devices并下下载 2.安装下载
mbedtls加密组件使用示例
qq_27182175的博客
02-14 1700
mbedtls
基于MbedTLS的AES加密实现，含STM32H7和STM32F4的实现例程
Simon223的博客
08-15 2840
说明： 1、mbedTLS的前身是PolarSSL，开源免费。 主要提供了的SSL/TLS支持（在传输层对网络进行加密），各种加密算法，各种哈希算法，随机数生成以及X.509（密码学里公钥证书的格式标准）的支持。 2、mbedTLS支持的加密算法含对称加密和非对称加密 （1）mbedTLS支持的对称加密算法有：AES，ARCFOUR，Blowfish/BF，Camellia，DES/3DE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HX科技

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值