首先官网下载OpenSSL最新版本源代码,拿到lib库和包含文件,包含进我的工程项目,在加密和编码过程中需要它们。


OpenSSLRSA.cpp文件

#include "pch.h"
#include "OpenSSLRSA.h"

OpenSSLRSA::OpenSSLRSA()
{
	initalize();
}

OpenSSLRSA::~OpenSSLRSA()
{
	finalize();
}

RSA* OpenSSLRSA::getPublicKey(char* filename)
{
	//从文件读公钥
	string data = readFile(filename);
	return getPublicKey(data);
}

RSA* OpenSSLRSA::getPrivateKey(char* filename)
{
	//从文件读取私钥
	string data = readFile(filename);
	return getPrivateKey(data);
}

RSA* OpenSSLRSA::getPublicKey(string data)
{
	const char* publicKeyStr = data.c_str();
	BIO* bio = BIO_new_mem_buf((void*)publicKeyStr, -1);
	BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);

	RSA* rsaPubKey = PEM_read_bio_RSA_PUBKEY(bio, NULL, NULL, NULL);
	if (!rsaPubKey)
	{
		cout << "could not load public key" << endl;
	}

	BIO_free(bio);

	return rsaPubKey;
}

RSA* OpenSSLRSA::getPrivateKey(string data)
{
	const char* privateKeyStr = data.c_str();
	BIO* bio = BIO_new_mem_buf((void*)privateKeyStr, -1);
	BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);

	RSA* rsaPrivateKey = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);
	if (!rsaPrivateKey)
		cout << "could not load private key" << endl;

	BIO_free(bio);

	return rsaPrivateKey;
}

string OpenSSLRSA::encryptRSA(RSA* key, string data)
{
	string buffer;
	int dataSize = data.length();
	const unsigned char* str = (const unsigned char*)data.c_str();	
	int rsaLen = RSA_size(key);

	unsigned char* ed = (unsigned char*)malloc(rsaLen);

	int resultLen = RSA_public_encrypt(dataSize, (const unsigned char*)str, ed, key, PADDING);
	if (resultLen == -1)
	{
		cout << "could not encryptRSA" << endl;
		return buffer;
	}
	buffer = string(reinterpret_cast<char*>(ed), resultLen);

	return buffer;
}

string OpenSSLRSA::decryptRSA(RSA* key, string data)
{
	//解密
	string buffer;
	const unsigned char* encryptedData = (const unsigned char*)data.c_str();
	//int dataSize = data.length();
	//const unsigned char* str = (const unsigned char*)data.c_str();
	int rsaLen = RSA_size(key);

	unsigned char* ed = (unsigned char*)malloc(rsaLen);

	int resultLen = RSA_private_decrypt(rsaLen, encryptedData, ed, key, PADDING);
	if (resultLen == -1)
	{
		cout << "could not decryptRSA" << endl;
		return buffer;
	}
	buffer = string(reinterpret_cast<char*>(ed), resultLen);
	
	/*ofstream out("解密后.txt", ios::out);
	out << buffer;
	out.close();
*/

	return buffer;
}

char* OpenSSLRSA::encryptBase64(char* in_data,int in_len)
{
	BIO* b64, * bio;
	BUF_MEM* bptr = NULL;
	size_t size = 0;

	if (in_data == NULL)
		return nullptr;

	b64 = BIO_new(BIO_f_base64());
	bio = BIO_new(BIO_s_mem());
	bio = BIO_push(b64, bio);
	BIO_write(bio, in_data, in_len);
	BIO_flush(bio);
	BIO_get_mem_ptr(bio, &bptr);
	
	char* buff = (char*)malloc(bptr->length + 1);
	memcpy(buff, bptr->data, bptr->length);
	buff[bptr->length] = '\0';

	BIO_free_all(bio);

	return buff;
}

char* OpenSSLRSA::decryptBase64(char* in_data, int in_len)
{
	BIO* b64 = NULL;
	BIO* bmem = NULL;
	char* buffer = (char*)malloc(in_len);
	memset(buffer, 0, in_len);
	b64 = BIO_new(BIO_f_base64());
	bmem = BIO_new_mem_buf(in_data, in_len);
	bmem = BIO_push(b64, bmem);
	BIO_read(bmem, buffer, in_len);
	BIO_free_all(bmem);

	return buffer;
}

void OpenSSLRSA::initalize()
{
	ERR_load_CRYPTO_strings();
	OpenSSL_add_all_algorithms();
	OPENSSL_config(NULL);
}

void OpenSSLRSA::finalize()
{
	EVP_cleanup();
	ERR_free_strings();
}

string OpenSSLRSA::readFile(string filename)
{
	ifstream ifile(filename);
	ostringstream buf;
	
	char ch;
	while (buf && ifile.get(ch))
		buf.put(ch);
	

	return buf.str();
}


OpenSSLRSA.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include "openssl/rsa.h"
#include "openssl/engine.h"
#include "openssl/evp.h"
#include "openssl/pem.h"
#include "openssl/bio.h"
#include "openssl/conf.h"
#include "openssl/err.h"
#include "openssl/rand.h"
#define PADDING RSA_PKCS1_PADDING
#define PRIVATE_KEY_FILE   "privatekey.pem"
#define PUBLIC_KEY_FILE	   "publickey.pem"

using namespace std;
class OpenSSLRSA
{
public:
	OpenSSLRSA();
	~OpenSSLRSA();
public:
	RSA* getPublicKey(char* fielname);
	RSA* getPrivateKey(char* filename);
	RSA* getPublicKey(string data);
	RSA* getPrivateKey(string data);

	string encryptRSA(RSA* key, string data);
	string decryptRSA(RSA* key, string data);
	char* encryptBase64(char* in_data,int in_len);
	char* decryptBase64(char* in_data,int in_len);

	void freeRSAKey(RSA* key);

private:
	void initalize();
	void finalize();

	string readFile(string filename);
	void writeFile(char* filename, char& data);

};


main.cpp

#include <iostream>
#include "OpenSSLRSA.h"

using namespace std;

string getPublicKeyString()
{
        //以下...中填充为openSSL生成的SHA256公钥和私钥
	string testPublicKey;

	testPublicKey.append("-----BEGIN PUBLIC KEY-----\n");
	testPublicKey.append("...n");
	testPublicKey.append("...\n");
	testPublicKey.append("...\n");
	testPublicKey.append("...\n");
	testPublicKey.append("-----END PUBLIC KEY-----");


	return testPublicKey;
}

string getPrivateKeyString()
{
	string testPrivateKey;

	testPrivateKey.append("-----BEGIN RSA PRIVATE KEY-----\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("...\n");
	testPrivateKey.append("-----END RSA PRIVATE KEY-----");

	return testPrivateKey;
}

void testRSA()
{
	cout << "Loading keys..\n";
	string testPrivateKey = getPrivateKeyString();
	string testPublicKey = getPublicKeyString();

	OpenSSLRSA test;

	RSA* publickey = test.getPublicKey(testPublicKey);
	RSA* privatekey = test.getPrivateKey(testPrivateKey);

	string plain = "Hello World!\nHello World!!!";


	string encrypted = test.encryptRSA(publickey, plain);

	char* in_plain = (char*)malloc(strlen(encrypted.c_str()));
	memcpy(in_plain, encrypted.c_str(), strlen(encrypted.c_str()));
	char* out_plain = test.encryptBase64(in_plain, strlen(encrypted.c_str()));

	char* de_out_plain = test.decryptBase64(out_plain, strlen(out_plain));

	string decrypted = test.decryptRSA(privatekey, de_out_plain);
	
	
	cout << "原文:" << endl;
	cout << plain << endl << endl;

	cout << "RSA加密:" << endl;
	cout << encrypted << endl << endl;

	cout << "BASE64编码" << endl;
	cout << out_plain << endl << endl;
	cout << "BASE64解码" << endl;
	cout << de_out_plain << endl << endl;

	cout << "RSA解密:" << endl;
	cout << decrypted << endl;
	
}

int main()
{
        //经过测试,加密后的字符串解密后与原字符串相同
	testRSA();

	return 0;yuan
}