实战篇-OpenSSL之调用EVP框架实现AES多种加密模式

最新推荐文章于 2024-08-16 23:23:07 发布
最新推荐文章于 2024-08-16 23:23:07 发布
阅读量6.8k 收藏 27
点赞数 7
分类专栏： OpenSSL 文章标签： AES加密 EVP框架 ECB、CBC、CFB1 CFB8、CFB128 OFB128、CTR、GCM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyhse/article/details/112294229
版权

本文属于《OpenSSL加密算法库使用系列教程》之一，欢迎查看其它文章。

实战篇-OpenSSL之调用EVP框架实现AES多种加密模式

一、OpenSSL EVP简介

OpenSSL EVP(high-level cryptographic functions)提供了丰富的密码学中的各种函数。Openssl 中实现了各种对称算法、摘要算法以及签名/验签算法。EVP 函数将这些具体的算法进行了封装。

通过这样的统一的封装，使得只需要在初始化参数的时候做很少的改变，就可以使用相同的代码但采用不同的加密算法进行数据的加密和解密。

一句话，EVP是封装的高层接口，通过它加解密，可以不用关心更多细节问题，使用更简单。

二、EVP中对称加密与解密流程

EVP中用于对称加密的函数，主要有下面这些。

一般加密流程，执行步骤如下所示：

  • EVP_CIPHER_CTX_init，初始化对称计算上下文
  • EVP_EncryptInit_ex，加密初始化函数，本函数调用具体算法的init 回调函数，将外送密钥key 转换
    为内部密钥形式，将初始化向量iv 拷贝到ctx 结构中。
  • EVP_EncryptUpdate，加密函数，用于多次计算，它调用了具体算法的 do_cipher 回调函数。
  • EVP_EncryptFinal_ex，获取加密结果，函数可能涉及填充，它调用了具体算法的 do_cipher 回调函数。

一般解密流程，执行步骤如下所示：

  • EVP_CIPHER_CTX_init，初始化对称计算上下文
  • EVP_DecryptInit_ex，解密初始化函数。
  • EVP_DecryptUpdate，解密函数，用于多次计算，它调用了具体算法的 do_cipher 回调函数。
  • EVP_DecryptFinal_ex，获取解密结果，函数可能涉及去填充，它调用了具体算法的 do_cipher 回调函数。

根据上述的步骤，封装一个基本的，EVP加解密函数，如下：

EvpAES::EvpAES()
{
    // 初始化CTX
    ctx = EVP_CIPHER_CTX_new();
    EVP_CIPHER_CTX_init(ctx);
}

EvpAES::~EvpAES()
{
    // 释放CTX
    EVP_CIPHER_CTX_cleanup(ctx);
    EVP_CIPHER_CTX_free(ctx);
}

bool EvpAES::encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, const EVP_CIPHER *ciper, bool enc)
{
    if (enc)
    {
        // 指定加密算法及key和iv
        int ret = EVP_EncryptInit_ex(ctx, ciper, NULL, (const unsigned char*)key.data(), (const unsigned char*)ivec.data());
        if(ret != 1)
        {
            return false;
        }

        // 进行加密操作
        int mlen = 0;
        out.resize(in.size() + AES_BLOCK_SIZE);
        ret = EVP_EncryptUpdate(ctx, (unsigned char*)out.data(), &mlen, (const unsigned char*)in.data(), in.size());
        if(ret != 1)
        {
            return false;
        }

        // 结束加密操作
        int flen = 0;
        ret = EVP_EncryptFinal_ex(ctx, (unsigned char *)out.data() + mlen, &flen);
        if(ret != 1)
        {
            return false;
        }
        out.resize(mlen + flen);
        return true;
    }
    else
    {
        // 指定解密算法及key和iv
        int ret = EVP_DecryptInit_ex(ctx, ciper, NULL, (const unsigned char*)key.data(), (const unsigned char*)ivec.data());
        if(ret != 1)
        {
            return false;
        }

        // 进行解密操作
        int mlen = 0;
        out.resize(in.size());
        ret = EVP_DecryptUpdate(ctx, (unsigned char*)out.data(), &mlen, (const unsigned char*)in.data(), in.size());
        if(ret != 1)
        {
            return false;
        }

        // 结束解密操作
        int flen = 0;
        ret = EVP_DecryptFinal_ex(ctx, (unsigned char *)out.data() + mlen, &flen);
        if(ret != 1)
        {
            return false;
        }
        out.resize(mlen + flen);
        return true;
    }
}

三、通过EVP实现AES多种加密模式

使用EVP的好处就是，不用考虑诸如对齐填充、秘钥、处理长度等等细节，这些细节每个加密模式，可能都不一样。EVP把这些加密算法全部统一了，以统一的方式去操作。

与直接调用具体的加密函数相比，EVP的步骤更多了一些，所以具体使用哪种，根据自己实际情况来即可。

我们在前面的encrypt函数基础上，封装更多的加密模式方法出来，以供外部使用。

这里实现了ECB、CBC、CFB1、CFB8、CFB128、OFB128、CTR、GCM、XTS、OCB共10种模式。如下：

#include "EvpAES.h"
#include <openssl/evp.h>
#include <openssl/aes.h>

#define KEY_SIZE_16B            16
#define KEY_SIZE_24B            24
#define KEY_SIZE_32B            32

bool EvpAES::ecb_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_ecb();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_ecb();
    }
    else
    {
        cipher = EVP_aes_256_ecb();
    }

    // 执行加解密
    return encrypt(in, out, key, QByteArray(), cipher, enc);
}

bool EvpAES::cbc_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_cbc();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_cbc();
    }
    else
    {
        cipher = EVP_aes_256_cbc();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::cfb1_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_cfb1();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_cfb1();
    }
    else
    {
        cipher = EVP_aes_256_cfb1();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::cfb8_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_cfb8();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_cfb8();
    }
    else
    {
        cipher = EVP_aes_256_cfb8();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::cfb128_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_cfb128();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_cfb128();
    }
    else
    {
        cipher = EVP_aes_256_cfb128();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::ofb128_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_ofb();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_ofb();
    }
    else
    {
        cipher = EVP_aes_256_ofb();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::ctr_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_ctr();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_ctr();
    }
    else
    {
        cipher = EVP_aes_256_ctr();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::gcm_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_gcm();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_gcm();
    }
    else
    {
        cipher = EVP_aes_256_gcm();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::xts_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_xts();
    }
    else
    {
        cipher = EVP_aes_256_xts();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

bool EvpAES::ocb_encrypt(const QByteArray &in, QByteArray &out, const QByteArray &key, const QByteArray &ivec, bool enc)
{
    // 检查密钥合法性(只能是16、24、32字节)
    Q_ASSERT(key.size() == KEY_SIZE_16B || key.size() == KEY_SIZE_24B || key.size() == KEY_SIZE_32B);
    Q_ASSERT(ivec.size() == KEY_SIZE_16B); // 初始向量为16字节

    // 根据key大小创建EVP_CIPHER
    const EVP_CIPHER * cipher = nullptr;
    if (key.size() == KEY_SIZE_16B)
    {
        cipher = EVP_aes_128_ocb();
    }
    else if (key.size() == KEY_SIZE_24B)
    {
        cipher = EVP_aes_192_ocb();
    }
    else
    {
        cipher = EVP_aes_256_ocb();
    }

    // 执行加解密
    return encrypt(in, out, key, ivec, cipher, enc);
}

代码虽多，但结构类似，比较简单，直接看。

经测试，本类中加解密函数，支持对任意长度输入数据进行加解密。

扩展：

应该DES、TripleDES等对称加密算法，也可以按照上述的方法，从encrypt函数，进行再次封装，以向外提供该算法方法。毕竟都是属于对称加密，道理上应该是可以的。这个就不去试了，感兴趣的小伙伴，自行尝试吧。

四、测试代码

void createTestData(QByteArray& data, int size)
{
    data.resize(size);
    for (int i = 0; i < size; i++)
    {
        data[i] = i % 128;
    }
}

void testEvpAES(const QByteArray& data)
{
    QByteArray plainText = data;
    QByteArray encryptText;
    QByteArray decryptText;

    QByteArray key = QByteArray::fromHex("8cc72b05705d5c46f412af8cbed55aad");
    QByteArray ivec = QByteArray::fromHex("667b02a85c61c786def4521b060265e8");

    // EvpAES ecb模式加密验证
    EvpAES aes;
    aes.ecb_encrypt(plainText, encryptText, key, true);
    aes.ecb_encrypt(encryptText, decryptText, key, false);
    qDebug() << "EvpAES ecb encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES cbc模式加密验证
    aes.cbc_encrypt(plainText, encryptText, key, ivec, true);
    aes.cbc_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES cbc encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES cfb1模式加密验证
    aes.cfb1_encrypt(plainText, encryptText, key, ivec, true);
    aes.cfb1_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES cfb1 encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES cfb8模式加密验证
    aes.cfb8_encrypt(plainText, encryptText, key, ivec, true);
    aes.cfb8_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES cfb8 encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES cfb128模式加密验证
    aes.cfb128_encrypt(plainText, encryptText, key, ivec, true);
    aes.cfb128_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES cfb128 encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES ofb128模式加密验证
    aes.ofb128_encrypt(plainText, encryptText, key, ivec, true);
    aes.ofb128_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES ofb128 encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES ctr模式加密验证
    aes.ctr_encrypt(plainText, encryptText, key, ivec, true);
    aes.ctr_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES ctr encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES gcm模式加密验证
    aes.gcm_encrypt(plainText, encryptText, key, ivec, true);
    aes.gcm_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES gcm encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES xts模式加密验证
    aes.xts_encrypt(plainText, encryptText, key, ivec, true);
    aes.xts_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES xts encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();

    // EvpAES ocb模式加密验证
    aes.ocb_encrypt(plainText, encryptText, key, ivec, true);
    aes.ocb_encrypt(encryptText, decryptText, key, ivec, false);
    qDebug() << "EvpAES ocb encrypt verify" << ((decryptText == plainText) ? "succeeded" : "failed");
    encryptText.clear();
    decryptText.clear();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 产生1MB的测试数据
    QByteArray data;
    createTestData(data, 1*1024*1024);

    // 测试AES
    testEvpAES(data);  // 测试，通过EVP框架调用AES算法

    return a.exec();
}

执行结果：

在这里插入图片描述

本文涉及工程代码地址：https://gitee.com/bailiyang/cdemo/tree/master/Qt/49OpenSSL/OpenSSL


若对你有帮助，欢迎点赞、收藏、评论，你的支持就是我的最大动力！！！

同时，阿超为大家准备了丰富的学习资料，欢迎关注公众号“超哥学编程”，即可领取。

在这里插入图片描述

百里杨
关注
专栏目录
openSSL中EVP接口
新时代农民工
08-03 841
OpenSSL在日常开发者通常是以so的形式引入程序中，下面我们来跟踪一下EVP是如何把这些算法接口抽象统一实现的。ossl_init_add_all_ciphers作为静态方式加载，只加载一次把所有的cipher通过openssl_add_all_ciphers_int添加到改进程中。
openssl evp 对称加密(AES_ecb,ccb)
weixin_34302561的博客
12-01 496
openssl evp 对称加密(AES_ecb,ccb) evp.h 封装了openssl常用密码学工具，以下主要说对称加密的接口 1. 如下使用 aes_256_ecb 模式的加密解密测试代码 unsigned char key[32] = {1}; unsigned char iv[16] = {0}; unsigned char *inStr = "this is...
C语言使用OpenSSL对文件进行加解密操作
最新发布
weixin_71669458的博客
08-16 853
OpenSSL是一个强大的开源加密库，‌广泛应用于互联网安全通信的各个方面。‌‌在本篇文章中，博主会在windows7的环境下使用DEVC++来编写加密和解密的C代码，同时和大家一起探讨关于openssl的安装和使用
linux openssl之EVP AES
weixin_44522306的博客
06-17 675
linux openssl 值 AES加解密解说，本文章只要对openssl 之 EVP的api 函数讲解和使用例程 openssl EVP相关api函数定义在（openssl/aes.h）头文件间，摘取如下所以： /********对称加解密常用并推荐使用的api函数********/ int EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a); int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *typ
openssl+EVP详解
N阶二进制的博客
11-29 4070
EVP 提供了通用的加密和解密函数，可以用于对称加密和非对称加密。选择加密算法，创建相应的EVP_CIPHER结构。初始化上下文。使用或初始化加密或解密操作。使用或处理数据。使用或完成加密或解密操作。由digest.c实现，实现过程中调用了对应摘要算法的回调函数。各个摘要算法提供了自己的EVP_MD静态结构，对应源码为m_xxx.c。
openssl框架闲谈--EVP加密/解密接口(附：加密)
Netfilter
02-09 9145
openssl 框架中的另一个重头戏就是EVP接口，它提供了所有的加密和解密实现，不但封装了已有的著名算法，而且其简单易用的接口可以让你自己轻松实现一个算法，这 就增强了它的可扩展性，基本上，openssl只是提供了机制框架，策略由用户实现。EVP接口的重要数据结构如下： typedef struct evp_cipher_st {     int nid;        //对象
OpenSSL中文手册之EVP库详解
热门推荐
liao20081228的博客
07-29 5万+
说明：这一系列文章参考自http://blog.csdn.net/xiaoting451292510/article/category/5609403/3 ，个人做了整理 。OpenSSL之EVP——加密算法  EVP加密算法包括了对称加密算法和非对称加密算法. 函数名称：EVP_Encrypt*…,EVP_Cipher…* 功能描述：该系列函数封装提供了对称加密算法的功能。 相关文件：e
调用openssl实现的 aes_gcm加解密源码-易语言
06-11
在易语言中，调用外部动态链接库（DLL）如OpenSSL的libeay32.dll，可以实现高级加密标准AES的GCM模式。 OpenSSL是一个开源的密码学软件库，包含了各种安全协议和算法，如AES。libeay32.dll是OpenSSL的一部分，提供...
C语言使用openSSL库AES模块实现加密功能详解
08-30
openSSL库提供了AES加密的实现。使用openSSL库需要了解以下函数接口： 1. `AES_set_encrypt_key`：设置加密key。 2. `AES_set_decrypt_key`：设置解密key。 3. `AES_cbc_encrypt`：进行AES加密。 AES加密实现 ...
php使用openssl_encrypt中的AES-128-ECB加密.docx
11-05
- 使用 `openssl_encrypt` 函数进行加密，第一个参数是 `$string`，第二个参数指定加密算法及模式，这里是 `'AES-128-ECB'`，表示使用AES-128位加密并采用ECB模式。 - 第四个参数 `OPENSSL_RAW_DATA` 表示加密后的...
evp.rar_EVP加密_evp_openssl evp
09-21
EVP加密是OpenSSL中的核心组件之一，它提供了一种统一的方式来处理多种加密和摘要算法。EVP API允许开发者选择不同的加密算法，如AES（高级加密标准）、DES（数据加密标准）、Blowfish等，并支持不同模式的加密，如...
openssl evp aes 加解密算法调试例程
07-11
0、此例程调试环境 运行uname -a的结果如下： Linux freescale 3.0.35-2666-gbdde708-g6f31253 #1 SMP PREEMPT Thu Nov 30 15:45:33 CST 2017 armv7l GNU/Linux 简称2017 armv7l GNU/Linux 1、openssl 直接处理AES的API 在openssl/aes.h定义。是基本的AES库函数接口，可以直接调用，但是那个接口是没有填充的。而如果要与Java通信，必须要有填充模式。所以看第2条。 2、利用openssl EVP接口 在openssl/evp.h中定义。在这个接口中提供的AES是默认是pkcs5padding方式填充方案。 3、注意openssl新老版本的区别 看如下这段 One of the primary differences between master (OpenSSL 1.1.0) and the 1.0.2 version is that many types have been made opaque, i.e. applications are no longer allowed to look inside the internals of the structures. The biggest impact on applications is that: 1）You cannot instantiate these structures directly on the stack. So instead of: EVP_CIPHER_CTX ctx; you must instead do: EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); .... EVP_CIPHER_CTX_free(ctx); 2）You must only use the provided accessor functions to access the internals of the structure. 4、注意加密的内容是数据不限制是否为字符串 openssl接口加密的是数据，不限制是否为字符串，我看到有些人在加密时使用strlen（），来获取要加密的长度，如果是对字符串加密的话没有问题，如果不是字符串的话，用它获取的长度是到第一个0处，因为这个函数获取的是字符串长度，字符串是以零为终止的。 5、在调用EVP_EncryptFinal_ex时不要画蛇添足 正常加解密处理过程，引用网友的代码如下，经测试正确。 int kk_encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key, unsigned char *iv, unsigned char *ciphertext) { EVP_CIPHER_CTX *ctx; int len; int ciphertext_len; ctx = EVP_CIPHER_CTX_new(); EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv); //EVP_EncryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, key, iv); EVP_EncryptUpdate(ctx, ciphertext, &len;, plaintext, plaintext_len); ciphertext_len = len; EVP_EncryptFinal_ex(ctx, ciphertext + len, &len;); ciphertext_len += len; EVP_CIPHER_CTX_free(ctx); return ciphertext_len; } int kk_decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext) { EVP_CIPHER_CTX *ctx; int len; int plaintext_len; ctx = EVP_CIPHER_CTX_new(); EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv); //EVP_DecryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, key, iv); EVP_DecryptUpdate(ctx, plaintext, &len;, ciphertext, ciphertext_len); plaintext_len = len; EVP_DecryptFinal_ex(ctx, plaintext + len, &len;); plaintext_len += len; EVP_CIPHER_CTX_free(ctx); return plaintext_len; } 我看到有人提供的代码在加密长度正好是16字节的整数倍时特意不去调用EVP_EncryptFinal_ex，这实在是画蛇添足啊，不论什么情况下，最后一定要调用EVP_EncryptFinal_ex一次，然后结束加密过程。 6、Base64陷阱 如果用到了base64，要注意如下： 1）base64算法是将3个字节变成4个可显示字符。所以在如果数据长度不是3字节对齐时，会补0凑齐。 2）在解密时先要解base64，再解AES。在解base64后，要减掉补上的0。算法就去查看base64后的字符串尾处有几个=号，最多是2个，如果正好要加密的数据是3的倍数，不需要补0，那么base64后的数据尾处就没有=，如果补了1个0，就有一个=号。 算法如下： int encode_str_size = EVP_EncodeBlock(base64, en, el); int length = EVP_DecodeBlock(base64_out, base64, encode_str_size ); //EVP_DecodeBlock内部同样调用EVP_DecodeInit + EVP_DecodeUpdate + Evp_DecodeFinal实现，但是并未处理尾部的'='字符，因此结果字符串长度总是为3的倍数 while(base64[--encode_str_size] == '=') length--; 算法网友提供，测试正确。
使用openssl中aes加密算法实现文件的加密解密（源代码）
05-03
实现EVP_aes_128(256)_ecb模式，适合初学者熟悉openssl中的加密解密函数。可运行..
openssl AES-cbc 加密 通过C++实现
萧海的博客
04-20 1415
最近工作需要使用到加密，对于程序内的数据就采用了对称加密，于是就使用了AES加密。废话不多说了，直接上代码 bob_aes.h #ifndef bob_aes_h #define bob_aes_h #include <iostream> #include <stdio.h> #include <string> #include <string.h> #include <cstdlib> #include <openssl/aes.h&gt
OpenSSL中的EVP接口
02-07 4944
索引摘要算法（Digest）获取EVP_MDDigest API例子对称加密（Cipher）获取EVP_CIPHERCipher API上下文管理Encrypt APIDecrypt API加解密统一API其他设置例子非对称加密密钥管理公钥算法上下文 EVP_PKEY_CTX生成密钥密钥参数打印密钥的提取和指定密钥的保存和读取使用OSSL_ENCODER和OSSL_DECODER使用EVP_PKEY_todata和EVP_PKEY_fromdata检测私钥是否正确加解密签名和验签 摘要算法（Digest）
OpenSSL之调用EVP框架实现AES多种加密模式
宁静致远的博客
11-13 2696
OpenSSL之调用EVP框架实现AES多种加密模式前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： impor
使用openssl应用层接口(EVP_***)实现对称(aes,idea等)加密
guolisong的专栏
11-17 1103
通过调用openssl的库函数，来实现对称加密
Linux C语言调用OpenSSL：EVP 接口概述
Penseur2018的博客
06-19 961
本文介绍了openssl中的EVP高级API的应用场景和优缺点等，并对比了它和低级接口之间的性能差异
aes128加密算法c语言git
01-19
AES128加密算法是一种对称加密算法，使用128位密钥进行加密和解密操作。它在C语言中有很好的实现，并且可以轻松地集成到Git版本控制系统中。 在C语言中，可以使用openssl库或者其他加密库来实现AES128加密算法。开发者可以使用这些库中提供的函数来实现对数据的加密和解密操作。例如，可以使用openssl库中的EVP_aes_128_cbc函数来进行AES128加密和解密操作。 在Git版本控制系统中，可以通过使用Git钩子来实现AES128加密算法。通过在提交或者推送操作前调用加密函数，可以对敏感数据进行加密，从而保护数据的安全性。在接收端，可以使用相同的密钥和算法对数据进行解密操作，以获取原始的数据内容。 总的来说，AES128加密算法在C语言中有很好的实现，并且可以轻松地集成到Git版本控制系统中。这为开发者提供了一种方便、高效的数据加密和保护方式，从而确保敏感数据的安全性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

百里杨

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

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

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

打赏作者

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

抵扣说明：

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

余额充值