工作需要使用RSA和BLOWFISH加密，主要使用CRYPTO库，但是CRYPTO并不是很方便使用，封装的有点复杂。我整理CRYPTO的文档，简单的封装了主要的加密和解密方法。代码如下：
代码需要配置boost和crypto才能运行。
首先是 data_package_t.hpp 这个类和加解密没有关系，只是简单的封装了shared_array, 添加了一个_size_datalen，能够直接获取数组的长度。方法也很简单，只有一个构造函数和 reset_data。构造函数只有一个参数，传入数组的长度。reset_data 的作用是把数据的数据全部清0.
#ifndef UNIT_TEST_DATA_PACKAGE_T_H
#define UNIT_TEST_DATA_PACKAGE_T_H
#include
#include
#include
namespace my_utils {
namespace types {
template
class package {
public:
inline package(std::size_t _init_datalen = 0)
: _arr_data(new data_type[_init_datalen]), _size_datalen(_init_datalen) {
reset_data();
}
inline void reset_data() {
memset(_arr_data.get(), 0x0, sizeof(data_type) * _size_datalen);
}
boost::shared_array _arr_data;
std::size_t _size_datalen;
};
typedef unsigned char data_t;
typedef package data_package_t;
}
}
#endif //UNIT_TEST_DATA_PACKAGE_T_H
接下来是主要的头文件 encryption_utils.h 里面定义了主要的方法，包含了主要的密钥创建和初始换，和加解密的方法。每个方法都加了注释，这里就不详细解释了。
#ifndef ACCP_SERVER_SDK_LIBS_ENCRYPTION_UTILS_H
#define ACCP_SERVER_SDK_LIBS_ENCRYPTION_UTILS_H
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "data_package_t.hpp"
namespace my_utils {
namespace utils {
/**
* 存放 blowfish 的密钥
* data_key 为 key
* data_iv 为 iv
*/
struct blowfish_key_value {
blowfish_key_value(std::size_t key_len = 0, std::size_t iv_len = 0)
: data_key(key_len), data_iv(iv_len) {}
types::data_package_t data_key;
types::data_package_t data_iv;
};
/**
* 从数组导入rsa的 private key
* @param private_key 需要导入的private key
* @param _key_data 导入的数组
* @return 执行是否成功
*/
bool import_rsa_private_key_from_byte(CryptoPP::RSA::PrivateKey &private_key,
const types::data_package_t &_key_data);
/**
* 从数组导入rsa的 public key
* @param public_key 需要 导入的 public key
* @param _key_data 导入的数组
* @return 执行是否成功
*/
bool import_rsa_public_key_from_byte(CryptoPP::RSA::PublicKey &public_key,
const types::data_package_t &_key_data);
/**
* 导出rsa的private_key到数组
* @param private_key 需要导出的private key
* @param _key_data 导出的数组
* @return 执行是否成功
*/
bool export_rsa_private_key_to_byte(const CryptoPP::RSA::PrivateKey &private_key,
types::data_package_t &_key_data);
/**
* 导出rsa的public_key到数组
* @param public_key 需要导出的public_key
* @param _key_data 导出的数组
* @return 执行是否成功
*/
bool export_rsa_public_key (const CryptoPP::RSA::PublicKey &public_key,
types::data_package_t &_key_data);
/**
* 生成rsa密钥对
* @param public_key 公钥
* @param private_key 私钥
* @param key_size 密钥的长度
* @return 执行是否成功
*/
bool generate_rsa_key(CryptoPP::RSA::PublicKey &public_key,
CryptoPP::RSA::PrivateKey &private_key,
unsigned int key_size);
/**
* RSA加密函数
* @param public_key 公钥
* @param str_data 需要加密的数据
* @param cipher_data 加密后的数据
* @return 执行是否成功
*/
bool rsa_encrypt_std_string(CryptoPP::RSA::PublicKey &public_key,
const std::string &str_data,
my_utils::types::data_package_t &cipher_data);
/**
* RSA解密函数
* @param private_key 私钥
* @param raw_data 需要解密的数据
* @param plain 解密后的数据
* @return 执行是否成功
*/
bool rsa_decrypt_byte_data(CryptoPP::RSA::PrivateKey &private_key,
const my_utils::types::data_package_t &raw_data,
std::string &plain);
/**
* 生成Blowfish 的密钥和iv
* @param _key_value 密钥和iv
* @return 执行是否成功
*/
bool generate_blowfish_key(my_utils::utils::blowfish_key_value &_key_value);
/**
* 使用blowfish 加密数据
* @param _key_value 密钥
* @param plain 加密前的数据
* @param cipher 加密后的数据
* @return 执行是否成功
*/
bool blowfish_encrypt_std_string(const blowfish_key_value &_key_value,
const std::string &plain,
std::string &cipher);
/**
* 使用blowfish 解密数据
* @param _key_value 密钥
* @param cipher 解密前的数据
* @param plain 解密后的数据
* @return 执行是否成功
*/
bool blowfish_decrypt_byte_data(const blowfish_key_value &_key_value,
const std::string &cipher,
std::string &plain);
}
}
#endif //ACCP_SERVER_SDK_LIBS_ENCRYPTION_UTILS_H
encryption_utils.cpp 加解密的实现文件，主要参考了crypto的文档。
#include "../include/encryption_utils.h"
static CryptoPP::AutoSeededRandomPool g_rng;
using namespace CryptoPP;
bool my_utils::utils::import_rsa_private_key_from_byte(CryptoPP::RSA::PrivateKey &private_key,
const my_utils::types::data_package_t &_key_data) {
try {
CryptoPP::ByteQueue byte_queue;
byte_queue.Put2(_key_data._arr_data.get(), _key_data._size_datalen, 0, false);
private_key.Load(byte_queue.Ref());
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool ::my_utils::utils::import_rsa_public_key_from_byte(CryptoPP::RSA::PublicKey &public_key,
const my_utils::types::data_package_t &_key_data) {
try {
CryptoPP::ByteQueue byte_queue;
byte_queue.Put2(_key_data._arr_data.get(), _key_data._size_datalen, 0, false);
public_key.Load(byte_queue.Ref());
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::export_rsa_private_key_to_byte(const CryptoPP::RSA::PrivateKey &private_key,
my_utils::types::data_package_t &_key_data) {
try {
CryptoPP::ByteQueue byte_queue;
private_key.Save(byte_queue);
_key_data = my_utils::types::data_package_t(byte_queue.CurrentSize());
byte_queue.Get(_key_data._arr_data.get(), _key_data._size_datalen);
return true;
} catch (const CryptoPP::Exception &) {
return false;
}
}
bool my_utils::utils::export_rsa_public_key(const CryptoPP::RSA::PublicKey &public_key,
my_utils::types::data_package_t &_key_data) {
try {
CryptoPP::ByteQueue byte_queue;
public_key.Save(byte_queue);
_key_data = my_utils::types::data_package_t(byte_queue.CurrentSize());
byte_queue.Get(_key_data._arr_data.get(), _key_data._size_datalen);
return true;
} catch (const CryptoPP::Exception &) {
return false;
}
}
bool my_utils::utils::generate_rsa_key(CryptoPP::RSA::PublicKey &public_key,
CryptoPP::RSA::PrivateKey &private_key,
unsigned int key_size) {
try {
CryptoPP::InvertibleRSAFunction parameters;
parameters.GenerateRandomWithKeySize(g_rng, key_size);
public_key = CryptoPP::RSA::PublicKey(parameters);
private_key = CryptoPP::RSA::PrivateKey(parameters);
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::generate_blowfish_key(my_utils::utils::blowfish_key_value &_key_value) {
try {
_key_value = my_utils::utils::blowfish_key_value((std::size_t) CryptoPP::Blowfish::DEFAULT_KEYLENGTH,
(std::size_t) CryptoPP::Blowfish::BLOCKSIZE);
g_rng.GenerateBlock(_key_value.data_key._arr_data.get(), _key_value.data_key._size_datalen);
g_rng.GenerateBlock(_key_value.data_iv._arr_data.get(), _key_value.data_key._size_datalen);
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::rsa_encrypt_std_string(CryptoPP::RSA::PublicKey &public_key,
const std::string &str_data,
my_utils::types::data_package_t &cipher_data) {
try {
CryptoPP::SecByteBlock plaintext(str_data.length());
memcpy(plaintext.data(), str_data.c_str(), str_data.length());
CryptoPP::RSAES_OAEP_SHA_Encryptor encryptor(public_key);
assert(0 != encryptor.FixedMaxPlaintextLength());
assert(str_data.length() <= encryptor.FixedMaxPlaintextLength());
size_t ecl = encryptor.CiphertextLength(plaintext.size());
CryptoPP::SecByteBlock ciphertext(ecl);
encryptor.Encrypt(g_rng, plaintext, plaintext.size(), ciphertext);
cipher_data = my_utils::types::data_package_t(ecl);
memcpy(cipher_data._arr_data.get(), ciphertext.data(), ciphertext.size());
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::rsa_decrypt_byte_data(CryptoPP::RSA::PrivateKey &private_key,
const my_utils::types::data_package_t &raw_data,
std::string &plain) {
try {
CryptoPP::SecByteBlock ciphertext(raw_data._size_datalen);
assert(raw_data._size_datalen <= ciphertext.size());
memcpy(ciphertext.data(), raw_data._arr_data.get(), raw_data._size_datalen);
// Decrypt
CryptoPP::RSAES_OAEP_SHA_Decryptor decryptor(private_key);
// Now that there is a concrete object, we can validate
assert(0 != decryptor.FixedCiphertextLength());
assert(ciphertext.size() <= decryptor.FixedCiphertextLength());
size_t dpl = decryptor.MaxPlaintextLength(ciphertext.size());
assert(0 != dpl);
CryptoPP::SecByteBlock recovered(dpl);
// Paydirt
CryptoPP::DecodingResult result = decryptor.Decrypt(g_rng,
ciphertext, ciphertext.size(), recovered);
// More sanity checks
assert(result.isValidCoding);
assert(result.messageLength <=
decryptor.MaxPlaintextLength(ciphertext.size()));
plain = std::string((char *) recovered.data(), result.messageLength);
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::blowfish_encrypt_std_string(const my_utils::utils::blowfish_key_value &_key_value,
const std::string &plain,
std::string &cipher) {
try {
CBC_Mode::Encryption e;
e.SetKeyWithIV(_key_value.data_key._arr_data.get(),
_key_value.data_key._size_datalen,
_key_value.data_iv._arr_data.get());
StringSource(plain, true,
new StreamTransformationFilter(e,
new StringSink(cipher)
)
);
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
bool my_utils::utils::blowfish_decrypt_byte_data(const my_utils::utils::blowfish_key_value &_key_value,
const std::string &cipher,
std::string &plain) {
try {
CBC_Mode::Decryption d;
d.SetKeyWithIV(_key_value.data_key._arr_data.get(),
_key_value.data_key._size_datalen,
_key_value.data_iv._arr_data.get());
StringSource s(cipher, true,
new StreamTransformationFilter(d,
new StringSink(plain)
)
);
return true;
} catch (const CryptoPP::Exception &e) {
return false;
}
}
下面是测试代码:
#include "../include/encryption_utils.h"
using namespace std;
using namespace my_utils;
using namespace my_utils::utils;
using namespace my_utils::types;
using namespace boost;
/**
* RSA加密解密测试代码
*/
void rsa_encrypt_test() {
bool b_result = false;
CryptoPP::RSA::PublicKey _rsa_publickey;
CryptoPP::RSA::PrivateKey _rsa_privatekey;
// 生成密钥
generate_rsa_key(_rsa_publickey, _rsa_privatekey, 1024);
data_package_t cipher_data;
// 加密前的数据
std::string str_data("Hello World");
// 执行加密操作
b_result = rsa_encrypt_std_string(_rsa_publickey, str_data, cipher_data);
assert(b_result);
// 导出加密数据
std::string outdata((char *) cipher_data._arr_data.get(), cipher_data._size_datalen);
data_package_t cipher_data_1(outdata.size());
memcpy(cipher_data_1._arr_data.get(), outdata.c_str(), outdata.size());
// 测试密钥的导出和导入
data_package_t _output_private_key;
b_result = export_rsa_private_key_to_byte(_rsa_privatekey, _output_private_key);
assert(b_result);
data_package_t _output_public_key;
b_result = export_rsa_public_key(_rsa_publickey, _output_public_key);
assert(b_result);
CryptoPP::RSA::PublicKey _rsa_second_publickey;
CryptoPP::RSA::PrivateKey _rsa_second_privatekey;
b_result = import_rsa_private_key_from_byte(_rsa_second_privatekey, _output_private_key);
assert(b_result);
b_result = import_rsa_public_key_from_byte(_rsa_second_publickey, _output_public_key);
assert(b_result);
std::string plain;
// 执行解密操作
b_result = rsa_decrypt_byte_data(_rsa_second_privatekey, cipher_data_1, plain);
assert(b_result);
assert(plain == str_data);
}
/**
* blowfish 加密解密测试
*/
void blowfish_encrtpt_test() {
bool b_result = false;
blowfish_key_value _key_value;
// 生成密钥
b_result = generate_blowfish_key(_key_value);
assert (b_result);
// 加密前的密钥
std::string plain_1("Hello World");
std::string cipher_1;
// 执行加密操作
b_result = blowfish_encrypt_std_string(_key_value, plain_1, cipher_1);
assert(b_result);
std::string plain_2;
// 执行解密操作
b_result = blowfish_decrypt_byte_data(_key_value, cipher_1, plain_2);
assert(b_result);
assert(plain_2 == plain_1);
}