cryptopp aes cbc pcsk padding 加解密

最新推荐文章于 2025-02-11 22:22:27 发布
最新推荐文章于 2025-02-11 22:22:27 发布
阅读量1k 收藏 2
点赞数 1
文章标签： c++ 拓扑学 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xmmdbk/article/details/124951870
版权 
#include "logutils.h"
#include "HttpRequestUtilsEx.h"
#include "DataTransfrom.h"
#include "utils/config.h"
#include "utils/cryptutils.h"
#include "aes.h"
#include "modes.h"
#include "filters.h"
#include "base64.h"
#include "hex.h"
#include "queue.h"
#include <fstream>


std::string StringToHex(const std::string& data)
{
	const std::string hex = "0123456789ABCDEF";
	std::stringstream ss;

	for (std::string::size_type i = 0; i < data.size(); ++i)
		ss << hex[(unsigned char)data[i] >> 4] << hex[(unsigned char)data[i] & 0xf];
	std::cout << ss.str() << std::endl;
	return ss.str();
}

std::string HexToStr(const std::string& str)
{
	std::string result;
	for (size_t i = 0; i < str.length(); i += 2)
	{
		std::string byte = str.substr(i, 2);
		char chr = (char)(int)strtol(byte.c_str(), NULL, 16);
		result.push_back(chr);
	}
	return result;
}

// AES加密字符串，结果转为BASE64
std::string test_encrypt(const std::string& str_in, const std::string& key, const std::string& iv)
{
	std::string str_out;
	CryptoPP::CBC_Mode<CryptoPP::AES>::Encryption encryption;

	encryption.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());

	CryptoPP::StringSource encryptor(str_in, true,
		new CryptoPP::StreamTransformationFilter(encryption,
			new CryptoPP::Base64Encoder(
				new CryptoPP::StringSink(str_out),
				CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING // do not append a newline
			), CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING
		)
	);
	return str_out;
}

// AES解密字符串，从BASE64解密
std::string test_decrypt2(const std::string& str_in, const std::string& key, const std::string& iv)
{
	
	std::string str_out;
	CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption decryption;

	decryption.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());

	CryptoPP::StringSource decryptor(str_in,
		true,
		new CryptoPP::Base64Decoder(
			new CryptoPP::StreamTransformationFilter(decryption,
				new CryptoPP::StringSink(str_out),
				CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING
			)
		)
	);
	
	return str_out;
}

// AES解密字符串，从BASE64解密
std::string test_decrypt(const std::string& str_in, const std::string& key, const std::string& iv)
{

	std::string strBase64Decoded = "";
	std::string strDecodeOut = "";

	try
	{
		CryptoPP::StringSource(str_in, true,
			new CryptoPP::Base64Decoder(new CryptoPP::StringSink(strBase64Decoded)));

		CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption cbc_decrypt;

		cbc_decrypt.SetKeyWithIV((byte *)key.c_str(), key.length(), (byte*)iv.c_str());

		CryptoPP::StringSource(strBase64Decoded,
			true,
			new CryptoPP::StreamTransformationFilter(cbc_decrypt,
				new CryptoPP::StringSink(strDecodeOut),
				CryptoPP::BlockPaddingSchemeDef::BlockPaddingScheme::PKCS_PADDING)
		);
	}catch (...) {
		strDecodeOut = "";
	}

	return strDecodeOut;
}


void decrypt_byte(const std::string& key, const std::string& iv, const byte cipherData[], const int cipherDataLen, byte plainData[], int &plainDataLen)
{

	CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption decryption;

	decryption.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());

	CryptoPP::ArraySink *dst = new CryptoPP::ArraySink(plainData, plainDataLen);

	CryptoPP::StreamTransformationFilter *transformation = new CryptoPP::StreamTransformationFilter(decryption, dst,
		CryptoPP::BlockPaddingSchemeDef::BlockPaddingScheme::PKCS_PADDING);

	CryptoPP::ArraySource decryptor(cipherData, cipherDataLen,true, transformation);

	plainDataLen = (int)dst->TotalPutLength();
}


void DecryptData(const std::string& key, const std::string& iv, const byte cipherData[], const int cipherDataLen, byte plainData[], int &plainDataLen)
{
	//try {

		
		CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption decrypt;
		decrypt.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());

		CryptoPP::ArraySink decSink(plainData, plainDataLen);
		CryptoPP::StreamTransformationFilter stfdec(decrypt, new CryptoPP::Redirector(decSink),
			CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING);

		stfdec.Put(cipherData, cipherDataLen);
		stfdec.MessageEnd();

//	}

	//catch (const CryptoPP::Exception &e) {

		
//	}

	

}

void decrypt_byte_gf(const std::string& key, const std::string& iv, std::string &cipher)
{
	//try
//	{
		std::string strBase64Decoded;

		CryptoPP::StringSource(cipher, true,
			new CryptoPP::Base64Decoder(new CryptoPP::StringSink(strBase64Decoded)));
		std::string recovered;

		CryptoPP::CBC_Mode< CryptoPP::AES >::Decryption d;
		d.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());

		// The StreamTransformationFilter removes
		//  padding as required.
		CryptoPP::StringSource s(strBase64Decoded.c_str(), true,
			new CryptoPP::StreamTransformationFilter(d,
				new CryptoPP::StringSink(recovered),
				CryptoPP::BlockPaddingSchemeDef::BlockPaddingScheme::PKCS_PADDING
			) // StreamTransformationFilter
		); // StringSource

#if 1
		CryptoPP::StreamTransformationFilter filter(d);
		filter.Put((const byte*)cipher.data(), cipher.size());
		filter.MessageEnd();

		const size_t ret = filter.MaxRetrievable();
		recovered.resize(ret);
		filter.Get((byte*)recovered.data(), recovered.size());
#endif

		std::cout << "recovered text: " << recovered << std::endl;
	//}
	//catch (const CryptoPP::Exception& e)
	//{
		exit(1);
	//}
}

//CryptoPP::QByteArray decrypt_byte2(QByteArray in) {
//
//	QByteArray iv = in.left(CryptoPP::AES::BLOCKSIZE);
//	in.remove(0, CryptoPP::AES::BLOCKSIZE);
//	string decrypted;
//	QByteArray result;
//
//	try {
//		CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption aes_dec;
//		aes_dec.SetKeyWithIV((byte *)key().data(), keySize(), (byte *)iv.data());
//
//		ArraySource((byte *)in.data(), in.size(), true,
//			new StreamTransformationFilter(aes_dec,
//				new StringSink(decrypted)));
//
//		result = QByteArray(decrypted.c_str(), in.size());
//	}
//	catch (CryptoPP::Exception err) {
//		result = "Failed to decrypt";
//		qDebug() << QString(err.GetWhat().c_str());
//	}
//
//	return result;
//}


// aes ebc 加密（输出 base64）
std::string aes_encrypt_ecb_base64(std::string data, unsigned char* key, int keylen)
{
	std::string encrypt_str;

	try
	{
		CryptoPP::ECB_Mode<CryptoPP::AES>::Encryption ecb_encription(key, keylen);
		CryptoPP::StreamTransformationFilter stf_encription(
			ecb_encription,
			new CryptoPP::Base64Encoder(new CryptoPP::StringSink(encrypt_str)),
			CryptoPP::BlockPaddingSchemeDef::ZEROS_PADDING
		);
		stf_encription.Put(reinterpret_cast<const unsigned char*>(data.c_str()), data.length() + 1);
		stf_encription.MessageEnd();
	}
	catch (std::exception e) {
		std::cout << e.what() << std::endl;
	}

	return encrypt_str;
}

// aes解密,这里传入的base64_data是AES加密后用base64编码得到的数据
std::string aes_encrypt(unsigned char* key, int keylen, unsigned char* iv, std::string base64_data)
{
	try {
		// 没有找到输入流的前置处理接口，这里先做base64解码
		std::string aes_encrypt_data;
		CryptoPP::Base64Encoder ecoder;
		ecoder.Attach(new CryptoPP::StringSink(aes_encrypt_data));
		ecoder.Put(reinterpret_cast<const unsigned char*>(base64_data.c_str()), base64_data.length());
		ecoder.MessageEnd();

		// 类似AES加密，得到原始数据
		std::string decrypt_data;
		CryptoPP::CBC_Mode<CryptoPP::AES>::Encryption encryption(key, keylen, iv);

		CryptoPP::StreamTransformationFilter stf_description(encryption,
			new CryptoPP::StringSink(decrypt_data), CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING);
		stf_description.Put(reinterpret_cast<const unsigned char*>(aes_encrypt_data.c_str())
			, aes_encrypt_data.length());
		stf_description.MessageEnd();
		return decrypt_data;
	}
	catch (std::exception e) {
		std::cout << e.what() << std::endl;
		return "";
	}
}

// aes解密,这里传入的base64_data是AES加密后用base64编码得到的数据
std::string aes_decrypt2(unsigned char* key, int keylen, unsigned char* iv, std::string base64_data)
{
	try {
		// 没有找到输入流的前置处理接口，这里先做base64解码
		std::string aes_encrypt_data;
		CryptoPP::Base64Decoder ecoder;
		ecoder.Attach(new CryptoPP::StringSink(aes_encrypt_data));
		ecoder.Put(reinterpret_cast<const unsigned char*>(base64_data.c_str()), base64_data.length());
		ecoder.MessageEnd();

		// 类似AES加密，得到原始数据
		std::string decrypt_data;
		CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption encryption(key, keylen, iv);

		CryptoPP::StreamTransformationFilter stf_description(encryption,
			new CryptoPP::StringSink(decrypt_data), CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING);
		stf_description.Put(reinterpret_cast<const unsigned char*>(aes_encrypt_data.c_str())
			, aes_encrypt_data.length());
		stf_description.MessageEnd();
		return decrypt_data;
	}
	catch (std::exception e) {
		std::cout << e.what() << std::endl;
		return "";
	}
}

void decrypt2(const std::string& key, const std::string& iv, const byte cipherData[], const int cipherDataLen, byte plainData[], int &plainDataLen)
{
	CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption decryption;

	decryption.SetKeyWithIV((byte*)key.c_str(), key.length(), (byte*)iv.c_str());
	CryptoPP::ArraySink *dst = new CryptoPP::ArraySink(plainData, plainDataLen);

	CryptoPP::ArraySource decryptor(cipherData, cipherDataLen, true,
		new CryptoPP::StreamTransformationFilter(decryption, dst)
	);
	plainDataLen = (int)dst->TotalPutLength();
}


// aes解密,这里传入的base64_data是AES加密后用base64编码得到的数据
std::string aes_decrypt(unsigned char* key, int keylen, unsigned char* iv, std::string base64_data)
{
	try {
		// 没有找到输入流的前置处理接口，这里先做base64解码
		std::string aes_encrypt_data;
		byte *base64_buff = new byte[base64_data.length()];
		CryptoPP::Base64Decoder decoder;

		CryptoPP::ArraySink base64_array(base64_buff, base64_data.length());
		//decoder.Attach(new CryptoPP::StringSink(aes_encrypt_data));
		decoder.Attach(&base64_array);
		decoder.Put(reinterpret_cast<const unsigned char*>(base64_data.c_str()), base64_data.length());
		decoder.MessageEnd();

		// 类似AES加密，得到原始数据
		std::string decrypt_data;
		CryptoPP::CBC_Mode<CryptoPP::AES>::Decryption cbc_description;

		cbc_description.SetKeyWithIV(key, keylen, iv);


		//CryptoPP::ArraySink decSink(buff, base64_data.length());
		CryptoPP::StreamTransformationFilter stfdec(cbc_description, new CryptoPP::Redirector(base64_array),
			CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING);

		/*byte *data = new byte[base64_array.m_to];
		stfdec.Put(data, base64_data.length());
		stfdec.MessageEnd();*/
		/*CryptoPP::StreamTransformationFilter stf_description(cbc_description,
			new CryptoPP::StringSink(decrypt_data), CryptoPP::BlockPaddingSchemeDef::PKCS_PADDING);
		stf_description.Put(reinterpret_cast<const unsigned char*>(aes_encrypt_data.c_str())
			, aes_encrypt_data.length());
		stf_description.MessageEnd();*/
		return decrypt_data;
	}
	catch (std::exception e) {
		std::cout << e.what() << std::endl;
		return "";
	}
}

xmmdbk
关注
C++使用CryptoPP密码库之AES加密算法进行文件加密
weixin_66143829的博客
01-25 1937
CryptoPP 是一个开源的密码学加密库，提供了大量的密码学算法和功能，包括对称加密、非对称加密、哈希函数、消息认证码 (MAC)、数字签名等。这里重点介绍一下对称加密算法（AES）的使用和注意事项。
CryptoPP：AES加解密
ecrisraul的博客
02-28 2541
CryptoPP：加解密之aes CryptoPP是一个强大的密码库，官网是https://www.cryptopp.com/。上面有比较详细的具体例子和说明文档，不过例子程序稍显片面，无法满足所有的应用场景，把这2天研究的一些加解密算法封装以下分享出来。 AES 简单粗暴直接贴代码 // AES编码，返回的是base64编码的数据 std::string crypto::aes_encrypt(...
DES-CBC加密和解密模式
最新发布
ray_kong的博客
02-11 366
实现简单的DES64加解密算法，支持中英文混合输入，支持处理任意长度的明文输入，自动进行PKCS#7填充等。
Cryptopp之AES加解密
wuxq的专栏
04-18 2937
// AES加密字符串，结果转为BASE64 std::string encrypt(const std::string& str_in, const std::string& key, const std::string& iv) { std::string str_out; CryptoPP::CBC_Mode<CryptoPP::AES>:...
使用Crypto++实现AES加解密
lc的大脑备份
03-17 5138
Crypto++实现AES加密和解密
Python实现AES中ECB模式pkcs5padding填充加密/解密（需要加密文档中可以有中文）
旧城旧梦的博客
08-27 1万+
Python实现AES中ECB模式pkcs5padding填充加密/解密（需要加密文档中可以有中文）一、本文主要解决的问题二、完整版代码三、遇到的问题1.填充格式错误2.传入类型错误四、安装导入的第三方库参考文档 一、本文主要解决的问题 本文主要是讲解AES加密算法中的ECB模式的加密解密的Python3.7实现，以及遇到的问题。具体AES加密算法的原理这里不做过多介绍，想了解的更多关于AES加密可以参考文末的AES加密算法的详细介绍与实现。 二、完整版代码 废话不多说直接上代码 import base64
AES CBC加解密源代码
10-10
在"VC6.0"环境下编写的"AesCBC.h"和"AesCBC.cpp"源代码文件中，包含了AES CBC模式下128位、192位和256位的加解密算法实现。这些实现通常包括以下关键部分： 1. **密钥扩展**：AES的密钥长度可以是128位、192位或256...
AES/CBC/PKCS5Padding/ 加解密
07-25
在描述中提到的“AES/CBC/PKCS5Padding”，分别代表了AES算法的不同部分： - AES：AES是高级加密标准，由NIST（美国国家标准与技术研究所）在2001年标准化，取代了之前的DES加密标准。它有三种不同尺寸的密钥，分别...
用C++开源库cryptopp 封装的Aes对称加密
03-12
Cryptopp是一个强大的、免费的C++类库，提供了多种加密、解密、哈希和伪随机数生成算法，包括AES。AES是一种分组密码，采用固定块大小128位和可变密钥长度128、192或256位，提供高效且安全的数据加密。 首先，我们...
java使用AES加密，c++使用crypto++解密
热门推荐
qq_34227896的博客
11-14 1万+
最近在做一个项目，需要用到加密解密，java端用AES加密了，准备把加好密的数据发送到c++写的服务端（crypto++开源库）。搞了几天，从不会到会，配置差点把我搞疯了，太它妈的蛋疼。 编译器：vs2017 开源库：crypto++    官网：https://blog.youkuaiyun.com/qq_34227896/article/details/84028740 使用文档：https://w...
AES加密方式AES/ECB/PKCS7Padding 报错
没有伞的孩子必须努力奔跑！—小林
04-22 3425
报错日志： Exception in thread "main" java.security.NoSuchAlgorithmException: Cannot find any provider supporting AES/ECB/PKCS7Padding 解决方案： 1、下载bcprov-jdk16-1.46.jar 拷贝到以下目录： C:\Program Files\Java\jdk1.8.0_20\jre\lib\ext 2、修改C:\Program Files\Java\jdk1.
基于Crypto++加密类库的Aes加密例子
04-18
基于Crypto++加密类库的Aes加密例子，基于Block的ProcessAndXorBlock，经过删减的Crypto++，原始test程序，参考开源库源包即可。
基于C语言的AES 128 CBC加密解密代码（MSP430F149验证通过）
10-31
这是一个基于C语言编写的AES 128位的加密及解密算法实现，已经通过MSP430F149单片机验证，很容易移植到其它单片机或者上位机。
Java实现AES/CBC/PKCS7Padding加解密的方法
08-18
主要介绍了Java实现AES/CBC/PKCS7Padding加解密的方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Crypto++库实现AES和RSA加密解密
千人斩的博客
03-15 3652
本文介绍使用Crypto++进行AES加密和RSA加密 Crypto++库在VS中配置方法 Crypto++库下载地址： https://www.cryptopp.com/， 目前已经更新到8.1版本。本文使用的是8.1版本的Crypto++。 下载压缩包后解压，然后用vs中编译cryptopp。生成debug和Realease版本的cryptlib.lib静态库。在使用时只要包含相应功能的头文件...
C/C++ 使用 cryptopp 加密解密
优快云
08-01 1万+
Crypto++（也称为CryptoPP）是一个流行的开源密码学库，提供了各种密码学算法的实现。它是用C++编写的，并在许可证允许的范围内可自由使用和修改。 Crypto++支持多种密码学算法，包括对称加密算法（如AES、DES、RC4）、哈希函数（如SHA-1、SHA-256）、消息认证码（如HMAC）、公钥加密算法（如RSA、DSA、ECC）以及其他密码学功能。
Js和Java用CryptoJS.pad.Pkcs7、AES/CBC/PKCS7Padding 实现加解密数据（crypto-js、bouncycastle、hutool-java）
西楼的博客
03-03 6848
但是对于Js中的CryptoJS，padding: CryptoJS.pad.Pkcs7，则对应Java中AES的默认模式是：AES/ECB/PKCS7Padding。最近开发遇到个对接接口的需求，而这个接口是前端的Ajax直接调用的，接口前后有进行加解密的处理，使用的是CryptoJS，加密模式为：padding: CryptoJS.pad.Pkcs7。而在Hutool的issue里面恰好有人提出这个问题，原作者也做出了回应。单使用Hutool，里面是没有这个加密算法的，所以需要配合BC库才能使用。
CryptoPP加密算法库使用
sinat_39886323的博客
12-08 1152
#include "include/cryptlib.h" #include "include/aes.h" #include "include/osrng.h" #include "include/modes.h" #include "include/base64.h" #include "include/files.h" #include "include/filters.h" #include "include/default.h" #include "include/hex.h" #include.
CryptoPP使用介绍
重文-技艺山海经
10-28 1886
CryptoPP使用介绍 发表时间：2012年06月15 分类: 编程开发 作者: 天缘 Crypto++是个免费的C++加解密类库，由于资格太老、持续更新，最新版本到了CryptoPP 5.6，对天缘而言，第一眼看到CryptoPP就感觉头大，根目录下放置大量单源文件、编译文件、项目文件，再加上多平台和多编译器支持，文件几乎又多了一倍，而且还是都混到一起，直接就让人望而却步。毕竟Cr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值