AES-CBC加解密

2022-11-22

将字符串使用AES加密（CBC的方式，IV填充’0000000000000000’）

使用openssl

    #aes.h

#pragma once
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

using namespace std;

static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

// 密钥
static const string s_aeskey = "YBC$08XTncsP6B1!";

class AES
{
public:
	static AES* getInstance() 
	{
		static AES _aaes;
		return &_aaes;
	}
	virtual ~AES();

	std::string aes_256_cbc_encode(const std::string& data);
	std::string aes_256_cbc_decode(const std::string& strData);
private:
	static inline bool is_base64(unsigned char c) {
		return (isalnum(c) || (c == '+') || (c == '/'));
	}

	std::string base64_encode(char const* bytes_to_encode, int in_len);
	std::string base64_decode(std::string& encoded_string);

private:
	AES();
};

	#aes.cpp

#include "AES.h"

AES::AES() 
{

}

AES::~AES()
{

}

// 转base64，返回结果
std::string AES::base64_encode(char const* bytes_to_encode, int in_len) 
{
	std::string ret;
	int i = 0;
	int j = 0;
	unsigned char char_array_3[3];
	unsigned char char_array_4[4];

	while (in_len--) {
		char_array_3[i++] = *(bytes_to_encode++);
		if (i == 3) {
			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
			char_array_4[3] = char_array_3[2] & 0x3f;

			for (i = 0; (i < 4); i++)
				ret += base64_chars[char_array_4[i]];
			i = 0;
		}
	}

	if (i)
	{
		for (j = i; j < 3; j++)
			char_array_3[j] = '\0';

		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
		char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
		char_array_4[3] = char_array_3[2] & 0x3f;

		for (j = 0; (j < i + 1); j++)
			ret += base64_chars[char_array_4[j]];

		while ((i++ < 3))
			ret += '=';

	}

	return ret;
}

// base64解码，返回结果
std::string AES::base64_decode(std::string& encoded_string) 
{
	int in_len = encoded_string.size();
	int i = 0;
	int j = 0;
	int in_ = 0;
	unsigned char char_array_4[4], char_array_3[3];
	std::string ret;

	while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
		char_array_4[i++] = encoded_string[in_]; in_++;
		if (i == 4) {
			for (i = 0; i < 4; i++)
				char_array_4[i] = base64_chars.find(char_array_4[i]);

			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

			for (i = 0; (i < 3); i++)
				ret += char_array_3[i];
			i = 0;
		}
	}

	if (i) {
		for (j = i; j < 4; j++)
			char_array_4[j] = 0;

		for (j = 0; j < 4; j++)
			char_array_4[j] = base64_chars.find(char_array_4[j]);

		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

		for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
	}

	return ret;
}

// aes加密
std::string AES::aes_256_cbc_encode(const std::string& data) 
{
	unsigned char s_aesiv[AES_BLOCK_SIZE] = { '0','0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0' };
	AES_KEY aes_key;
	if (AES_set_encrypt_key((const unsigned char*)s_aeskey.c_str(), s_aeskey.length() * 8, &aes_key) < 0)
	{
		return "";
	}
	std::string strRet;
	std::string data_bak = data;
	unsigned int data_length = data_bak.length();

	// ZeroPadding
	// 根据长度补充相应的字符
	int padding = 0;
	if (data_bak.length() % (AES_BLOCK_SIZE) > 0)
	{
		padding = AES_BLOCK_SIZE - data_bak.length() % (AES_BLOCK_SIZE);
	}

	data_length += padding;
	if (padding > 0)
	{
		data_bak.append(size_t(padding), char(padding));
	}

	for (unsigned int i = 0; i < data_length / (AES_BLOCK_SIZE); i++)
	{
		std::string str16 = data_bak.substr(i * AES_BLOCK_SIZE, AES_BLOCK_SIZE);
		unsigned char out[AES_BLOCK_SIZE];
		::memset(out, 0, AES_BLOCK_SIZE);
		AES_cbc_encrypt((const unsigned char*)str16.c_str(), out, AES_BLOCK_SIZE, &aes_key, s_aesiv, AES_ENCRYPT);
		strRet += std::string((const char*)out, AES_BLOCK_SIZE);
	}

	// 加密后转base64
	return base64_encode(strRet.c_str(), strRet.length());
}

// aes解密
std::string AES::aes_256_cbc_decode(const std::string& strData) 
{
	unsigned char s_aesiv[AES_BLOCK_SIZE] = { '0','0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0' };
	// 先base64解码
	std::string decode_base64 = strData;
	string str_decode_base64 = base64_decode(decode_base64);
	AES_KEY aes_key;
	if (AES_set_decrypt_key((const unsigned char*)s_aeskey.c_str(), s_aeskey.length() * 8, &aes_key) < 0)
	{
		return "";
	}
	std::string strRet;
	for (unsigned int i = 0; i < str_decode_base64.length() / AES_BLOCK_SIZE; i++)
	{
		std::string str16 = str_decode_base64.substr(i * AES_BLOCK_SIZE, AES_BLOCK_SIZE);
		unsigned char out[AES_BLOCK_SIZE];
		::memset(out, 0, AES_BLOCK_SIZE);
		AES_cbc_encrypt((const unsigned char*)str16.c_str(), out, AES_BLOCK_SIZE, &aes_key, s_aesiv, AES_DECRYPT);
		strRet += std::string((const char*)out, AES_BLOCK_SIZE);
	}

	// 根据最后一个填充字符 并删除所有填充字符
	char paddingSize = strRet.at(strRet.size() - 1);
	int nPos = strRet.find(paddingSize);
	strRet = strRet.substr(0, nPos);
	return strRet;
}

另一种写法,推荐使用此方法


#include <string>
#include <iostream>

#include <openssl/aes.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

using namespace std;

#if _DEBUG
#pragma comment(lib,"libcrypto64MDd.lib")
#pragma comment(lib,"libssl64MDd.lib")
#else
#pragma comment(lib,"libcrypto_static.lib")
#pragma comment(lib,"libssl_static.lib")
#endif

static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

static bool is_base64(unsigned char c) 
{
    return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(char const* bytes_to_encode, int in_len) 
{
    std::string ret;
    int i = 0;
    int j = 0;
    unsigned char char_array_3[3];
    unsigned char char_array_4[4];

    while (in_len--) 
    {
        char_array_3[i++] = *(bytes_to_encode++);
        if (i == 3) 
        {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for (i = 0; (i < 4); i++)
                ret += base64_chars[char_array_4[i]];
            i = 0;
        }
    }

    if (i)
    {
        for (j = i; j < 3; j++)
            char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; (j < i + 1); j++)
            ret += base64_chars[char_array_4[j]];

        while ((i++ < 3))
            ret += '=';

    }

    return ret;
}

std::string base64_decode(std::string& encoded_string) 
{
    int in_len = encoded_string.size();
    int i = 0;
    int j = 0;
    int in_ = 0;
    unsigned char char_array_4[4], char_array_3[3];
    std::string ret;

    while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) 
    {
        char_array_4[i++] = encoded_string[in_]; in_++;
        if (i == 4) 
        {
            for (i = 0; i < 4; i++)
                char_array_4[i] = base64_chars.find(char_array_4[i]);

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

            for (i = 0; (i < 3); i++)
                ret += char_array_3[i];
            i = 0;
        }
    }

    if (i) 
    {
        for (j = i; j < 4; j++)
            char_array_4[j] = 0;

        for (j = 0; j < 4; j++)
            char_array_4[j] = base64_chars.find(char_array_4[j]);

        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
    }

    return ret;
}

string encrypt(string plaintext) 
{
    // Set up encryption context
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    //默认使用PKCS7填充
    EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, (const unsigned char*)"YBC$08XTncsP6B1!", (const unsigned char*)"0000000000000000");

#if 0 //如果需要使用ZERO填充,先禁用自动填充,再将'\0'追加到加密字符串后补充为16的倍数
    // Disable automatic padding
    EVP_CIPHER_CTX_set_padding(ctx, 0);

    // Manually pad plaintext with zeros
    int block_size = EVP_CIPHER_CTX_block_size(ctx);
    int padding_len = block_size - (plaintext.length() % block_size);
    plaintext.append(padding_len, '\0');
#endif
    // Encrypt plaintext
    int outlen1, outlen2;
    unsigned char outbuf[1024];
    string ciphertext;
    for (int i = 0; i < plaintext.length(); i += 1024) 
    {
        int len = min(1024, (int)plaintext.length() - i);
        EVP_EncryptUpdate(ctx, outbuf, &outlen1, (const unsigned char*)plaintext.c_str() + i, len);
        ciphertext.append((const char*)outbuf, outlen1);
    }
    EVP_EncryptFinal_ex(ctx, outbuf, &outlen2);
    ciphertext.append((const char*)outbuf, outlen2);

    // Clean up
    EVP_CIPHER_CTX_free(ctx);

    // Return encrypted text
    return ciphertext;
}

string decrypt(string ciphertext) 
{
    // Set up decryption context
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, (const unsigned char*)"YBC$08XTncsP6B1!", (const unsigned char*)"0000000000000000");

#if 0 //如果需要使用ZERO填充,先禁用自动填充
    // Disable automatic padding
    EVP_CIPHER_CTX_set_padding(ctx, 0);
#endif

    // Decrypt ciphertext
    int outlen1, outlen2;
    unsigned char outbuf[1024];
    string plaintext;
    for (int i = 0; i < ciphertext.length(); i += 1024) 
    {
        int len = min(1024, (int)ciphertext.length() - i);
        EVP_DecryptUpdate(ctx, outbuf, &outlen1, (const unsigned char*)ciphertext.c_str() + i, len);
        plaintext.append((const char*)outbuf, outlen1);
    }
    EVP_DecryptFinal_ex(ctx, outbuf, &outlen2);
    plaintext.append((const char*)outbuf, outlen2);

    // Clean up
    EVP_CIPHER_CTX_free(ctx);


#if 0 //如果使用ZERO填充,使用一个循环来手动删除解密后文本末尾的零字符
    // Manually remove padding zeros
    int plaintext_len = plaintext.length();
    while (plaintext_len > 0 && plaintext[plaintext_len - 1] == '\0') 
    {
        plaintext_len--;
    }
    plaintext.resize(plaintext_len);

#endif

    // Return decrypted text
    return plaintext;
}

int main(int argc, char* argv[]) 
{
    // 原始文本
    string plaintext = "test";

    // 加密
    string ciphertext = encrypt(plaintext);
    //加密结果转base64
    string cipherbase64 = base64_encode(ciphertext.c_str(), ciphertext.length());
    cout << "Encrypted: " << cipherbase64 << endl;

    // 解密
    // 先将base64解码
    string decrypted = base64_decode(cipherbase64);
    cout << "Decrypted: " << decrypt(ciphertext) << endl;

    getchar();

    return 0;
}