基于RSA和AES加密算法实现的socket加密传输模型
本文中的模型思路来自于这篇博客:https://www.cnblogs.com/sheng1255blog/p/5121536.html
基本思路:采用安全的RSA加密算法来对生成AES密钥对的种子进行加密传输。通信双方得到种子Seed之后分别生成AES加密密钥和AES解密密钥，此后就可以用AES对socket传输的数据进行加密传输了。
这样做的理由：RSA加密算法安全性高，但是加密效率低，加密速度慢，一般只用来加密短小的数据，不会直接加密大量的数据。AES加密速度快，加密效率高，但是由于是对称密钥密码体制，安全性没有RSA好，详情可见我之前的博客。所以采用RSA+AES的方法，利用了两者的优点，https据说也是采用这种做法。此外AES加密数据一般是固定长度的，所以需要自己实现分块加密，我这里封装了一下，方便使用。
客户端代码：safe_client.cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <fcntl.h>
#include <openssl/rsa.h>
#include <openssl/aes.h>
#include "myaes.h"
#define SER_PORT 6000
#define SER_IP "127.0.0.1"
using namespace std;
int main()
{
//客户端创建流式套接字
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd == -1)
{
return -1;
}
//绑定服务端IP和端口
struct sockaddr_in saddr;
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(SER_PORT);
saddr.sin_addr.s_addr = inet_addr(SER_IP);
int res=connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));
assert(res != -1);
//产生RSA密钥对
RSA* rsa = RSA_new();
BIGNUM* bne = BN_new(); //随机产生一个大数
int ret = 0;
ret = BN_set_word(bne, RSA_F4);
ret = RSA_generate_key_ex(rsa, 128, bne, NULL);
// 客户端从RSA结构中提取公钥到BUFF，以便将它传输给对方
// 128位的RSA其公钥提出出来长度是26字节，而私钥提取出来有16字节
// 保险起见，给它们预留一个128字节的空间
unsigned char PublicKey[128];
unsigned char *PKey = PublicKey; // 注意这个指针不是多余，是特意要这样做的，
int PublicKeyLen = i2d_RSAPublicKey(rsa, &PKey);
//把公钥发送给服务器
send(sockfd, PublicKey, 128, 0);
//接收服务器发来的Seed结构 这里的AES_BLOCK_SIZE宏是aes.h里定义的 大小为16
unsigned char Seed[AES_BLOCK_SIZE], EncryptedSeed[AES_BLOCK_SIZE];
memset(Seed, '\0', AES_BLOCK_SIZE);
memset(EncryptedSeed, '\0', AES_BLOCK_SIZE);
printf("recv Seed\n");
recv(sockfd, EncryptedSeed, sizeof(EncryptedSeed), 0);
//对EncryptedSeed用RSA私钥进行解密。这里得到了Seed
int rsa_len = RSA_size(rsa);
RSA_private_decrypt(AES_BLOCK_SIZE, (unsigned char*)EncryptedSeed, (unsigned char*)Seed, rsa, RSA_NO_PADDING); // 解密
// 逐个字节打印解密后的Seed信息 和服务器发送过来的Seed进行对比
/*printf("Seed after decrypt, Len=%ld\n", sizeof(Seed));
for (int i = 0; i < sizeof(Seed); i++)
{
printf("0x%d, ", *(Seed+i));
}
printf("\n");*/
//这里用封装过的AES加密算法进行加解密
BobAES a(Seed);
string str = "ssssssssssssssssssssssss";
string EncryptedData = a.aes_encrypt(str);
send(sockfd, EncryptedData.c_str(), strlen(EncryptedData.c_str()), 0);
string Data = a.aes_decrypt(EncryptedData);
cout << "date after decrypt:" << Data << endl;
//最后要释放RSA结构 AES是栈内存，系统自动管理
RSA_free(rsa);
//RSA_free(EncryptRsa); //这个是给安全通信对象释放的 从buff里面提取出来的公钥
return 0;
}服务端代码：safe_server.cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/sendfile.h>
#include <openssl/rsa.h>
#include <openssl/aes.h>
#include "myaes.h"
#define SER_PORT 6000
#define SER_IP "127.0.0.1"
using namespace std;
int main()
{
int sockfd=socket(AF_INET, SOCK_STREAM, 0);
if(sockfd == -1)
{
return -1;
}
struct sockaddr_in saddr;
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(SER_PORT);
saddr.sin_addr.s_addr=inet_addr(SER_IP);
int res = bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));
if(res== -1)
{
return -1;
}
listen(sockfd, 5);
struct sockaddr_in caddr;
socklen_t len = sizeof(caddr);
int clientfd = accept(sockfd, (struct sockaddr*)&caddr, &len);
//首先接受客户端发送过来的RSA公钥信息
unsigned char buff_rsa[512];
memset(buff_rsa, '\0', sizeof(buff_rsa));
int n = recv(clientfd, buff_rsa, 512, 0);
// 逐个字节打印PublicKey信息 看看接收是否正确
printf("PublicKeyBuff, Len=%d\n", 74);
for (int i = 0; i < 74; i++)
{
printf("0x%02x, ", *(buff_rsa+i));
}
printf("\n");
//跟据上面提出的公钥信息PublicKey构造一个新RSA密钥(这个密钥结构只有公钥信息,用来对Seed进行加密)
unsigned char *PKey = buff_rsa;
//int PublicKeyLen = strlen((char*)buff_rsa);
RSA *EncryptRsa = d2i_RSAPublicKey(NULL, (const unsigned char**)&PKey, 26);
// 使用EncryptRsa加密数据，再使用ClientRsa解密数据
// 注意, RSA加密/解密的数据长度是有限制，例如128位的RSA就只能最多能加密解密16字节的数据 8：1的关系
// 如果采用RSA_NO_PADDING加密方式，128位的RSA就只能加密长度等于16的数据
// 这个长度可以使用RSA_size()来获得
unsigned char Seed[AES_BLOCK_SIZE], EncryptedSeed[AES_BLOCK_SIZE];
//这里给Seed做一下随机 取1-100之间的数
for(int i = 0; i < AES_BLOCK_SIZE; i++)
{
Seed[i] = rand() % 100 + 1;
}
memset(EncryptedSeed, '\0', AES_BLOCK_SIZE);
// 逐个字节打印Seed信息 对比发送和接收是否正确
printf("Seed, Len=%ld\n", sizeof(Seed));
for (int i = 0; i < AES_BLOCK_SIZE; i++)
{
printf("0x%d, ", *(Seed+i));
}
printf("\n");
RSA_public_encrypt(AES_BLOCK_SIZE, (unsigned char*)Seed, (unsigned char*)EncryptedSeed, EncryptRsa, RSA_NO_PADDING);
//这里再把加密后的Seed（EncryptedSeed）发送到客户端
send(clientfd, EncryptedSeed, AES_BLOCK_SIZE, 0);
//利用Seed结构生成一个AES解密密钥
//使用封装后的AES进行数据解密
BobAES a(Seed);
char EncryptedData[256];
recv(clientfd, EncryptedData, sizeof(EncryptedData), 0);
cout << "encryptedata:" << EncryptedData << endl;
std::string str(EncryptedData);
std::string Data = a.aes_decrypt(str);
//输出解密之后的数据
std::cout << "data after decrypt:" << Data << std::endl;
//最后释放RSA结构
RSA_free(EncryptRsa);
return 0;
}Makefile：
safe_client safe_server: safe_client.cpp safe_server.cpp myaes.cpp
g++ -o safe_client safe_client.cpp myaes.cpp -L/usr/local/lib -lssl -lcrypto -lpthread
g++ -o safe_server safe_server.cpp myaes.cpp -L/usr/local/lib -lssl -lcrypto -lpthread
clean:
-rm -f safe_client safe_server注意使用的openssl需要自行安装，将使用到的库 libcrypto, libssl放在对应的工作目录中即可。
对AES的分块加密封装：
myaes.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>
class BobAES
{
public:
BobAES(unsigned char* Seed);
~BobAES();
std::string aes_encrypt(std::string msg);
std::string aes_decrypt(std::string msg);
private:
int MSG_LEN;
unsigned char key[AES_BLOCK_SIZE];
};
#endifmyaes.cpp:
#include "myaes.h"
BobAES::BobAES(unsigned char* Seed)
: MSG_LEN(0)
{
for(int i = 0; i < AES_BLOCK_SIZE; i++)
{
key[i] = Seed[i];
}
}
BobAES::~BobAES()
{
}
std::string BobAES::aes_encrypt(std::string msg)
{
int i = msg.size() / 1024;
MSG_LEN = ( i + 1 ) * 1024;
//MSG_LEN = msg.size() + 16;
char in[MSG_LEN];
char out[MSG_LEN+16];
memset((char*)in,0,MSG_LEN);
memset((char*)out,0,MSG_LEN+16);
strncpy((char*)in,msg.c_str(),msg.size());
unsigned char iv[AES_BLOCK_SIZE]; //加密的初始化向量
for(int j = 0; j < AES_BLOCK_SIZE; ++j)
{
iv[j] = 0;
}
AES_KEY aes;
if(AES_set_encrypt_key(key, 128, &aes) < 0)
{
return NULL;
}
int len = msg.size();
AES_cbc_encrypt((unsigned char*)in,(unsigned char*)out,len,&aes,iv,AES_ENCRYPT);
std::string encrypt_msg(&out[0],&out[MSG_LEN+16]);
for(int i= 0;out[i];i++){
printf("%x",(unsigned char)out[i]);
//std::cout << dstStringTemp[i];
}
std::cout << std::endl;
return encrypt_msg;
}
std::string BobAES::aes_decrypt(std::string msg)
{
MSG_LEN = msg.size();
char in[MSG_LEN];
char out[MSG_LEN+16];
memset((char*)in,0,MSG_LEN);
memset((char*)out,0,MSG_LEN+16);
strncpy((char*)in,msg.c_str(),msg.size());
for(int i= 0;in[i];i++){
printf("%x",(unsigned char)in[i]);
//std::cout << dstStringTemp[i];
}
std::cout << std::endl;
unsigned char iv[AES_BLOCK_SIZE]; //加密的初始化向量
for(int j = 0; j < AES_BLOCK_SIZE; ++j)
{
iv[j] = 0;
}
AES_KEY aes;
if(AES_set_decrypt_key(key, 128, &aes) < 0)
{
return NULL;
}
int len = msg.size();
AES_cbc_encrypt((unsigned char*)in,(unsigned char*)out,len,&aes,iv,AES_DECRYPT);
std::string decrypt_msg = out;
return decrypt_msg;
}
Momenta公司福利 285人发布