最新RSA加密解密算法原理以及实现_rsa简介及源码实现，2024年最新还没吃透内存缓存LruCache实现原理的看这篇文章

2401_84281712

于 2024-05-14 00:58:42 发布

阅读量805

点赞数 16

分类专栏：程序员文章标签：网络安全学习面试

本文链接：https://blog.csdn.net/2401_84281712/article/details/138826335

版权

程序员专栏收录该内容

162 篇文章 1 订阅

订阅专栏

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

\varphi(n)

φ(n)已知的情况下，d只要满足ed-1=k

φ

(

n

)

\varphi(n)

φ(n)，k为任意整数，d便是e的模反元素。同时也可得到，e的模反元素d并不是唯一的。
例如，e=3，

φ

(

n

)

=

11

\varphi(n)=11

φ(n)=11，则d=4

±

\pm

±k·11。

至此，公钥，私钥便都已经得到。

6、将e、n公开作为公钥进行加密

假设明文为M，密文为C，则加密过程为

M

e

m

o

d

n

=

C

M^e mod n =C

Memodn=C

7、将d，n作为私钥进行解密

C

d

m

o

d

n

=

M

C^d mod n =M

Cdmodn=M

RSA私钥解密的证明详解

二、RSA算法使用c++语言实现时遇到的问题以及解决方案

1.问题1：模反元素的求解

在第5步中，我们需要计算出e对于

φ

(

n

)

\varphi(n)

φ(n)的模反元素d。
如果使用暴力法求解，那么时间复杂度势必为O(n)，这对于一个很大的整数来说，势必需要很长的时间去运行，效率低下，因此需要用一种更快的算法去优化该过程。
解决办法：在第四步中，我们随机产生一个整数e, e的范围是1 < e < φ(n), 并且e与 φ(n) 互质.互质的两个数的最大公约数为1，我们便可以用欧几里得算法去判断是否互质。

欧几里得算法可以用公式表示为gcd（a,b）=gcd(b,a mod b)，利用辗转相除的思路。设F(x,y）表示为x，y的最大公约数，取k=x/y，b=x%y,那么x=ky+b，如果一个数能够整除x和y,那么一定可以整除y和b，也就是说，能够整除y和b的数，一定能够整除x和y，所以x和y的公约数和y和b的公约数相同，其最大公约数也相同，则有F(x,y)=F(y,x%y)(x>=y>0),这样就把求两个数的最大公约数转化为求两个更小的数的公约数，直到其中一个数为0，那么另一个数就是两者的最大公约数。

举个例子：

F(42,30）=F（30,12）=F（12,6）=F（6,0）=6

但对于以上过过程，我们如何用代码去实现，我们先从公约数的特点入手。

设x=

k

1

x

1

k_1x_1

k1x1，y=

k

1

y

1

k_1y_1

k1y1，则F(x,y)=

k

1

k_1

k1 F(x1,y1)。
设x=p

x

1

x_1

x1，（p为素数且y%p!=0）则F(x,y)=F(x1,y)。
现在取p=2。
若x,y均为偶数，则F(x,y)=2F(x/2,y/2）。
若x为偶数，y为奇数则F(x,y)=F(x/2,y)。
若x为奇数，y为偶数则F(x,y)=F(x,y/2)。
若x和y同时为奇数，F(x,y)=F(y，x-y)。（两个奇数相减后必定会出现一个偶数）
这种做法的算法复杂度为O(log2(max(x,y)))。

#include<iostream>
#include<algorithm>
#include<string.h> 
using namespace std;
int isoushu(long x)
{
	if(x%2==0)  return 1;
	else return 0;
}
 int fun(long long a,long long b)
{   if(b>a)  return fun(b,a);
	else if(a==0)return b;

	
	else 
	{  if(isoushu(a))
	      if(isoushu(b))
	   {
	   	return (fun(a>>1,b>>1)<<1);
	   }
	   else return fun(a>>1,b);
	   
	   else 
	   {    if(isoushu(b))
	   	return  fun(a,b>>1);
	   	 else return (a-b,b);
	   	 
	   }
	
	
	}
}
main()
{
	long long a,b;
	cin>>a>>b;
    cout<<fun(a,b);

}

问题2：大数的幂运算

在计算机计算大数的指数的过程中, 计算的数字不断增大, 非常的占用我们的计算资源
我们计算的中间过程数字大的恐怖, 我们现有的计算机是没有办法记录这么长的数据的, 会导致溢出.

解决方案：在程序设计过程中，经常要去求一些大数对于某个数的余数，为了得到更快、计算范围更大的算法，产生了快速幂取模算法
从一个最简单的例子入手：求a^b % c = ？

int ans=1;
for(int i=1;i<=b;i++)
{
    ans=ans\*a;
}
ans=ans%c;

该程序实现存在很大的问题，首先算法时间度为O(n)，其次如果a和b过大，很容易就会溢出。
如何进行改进？这里就要用到中学时学到的同余定理：积的取余等于取余的积的取余。

a

b

a^b

ab% c = (a * a * a … a) % c
= ((a % c) * (a % c) * (a % c) … (a % c)) % c
= (a % c)

b

^b

b% c

此时我们可以从上述公式中想到既然某个因子取余之后相乘再取余余数保持不变，那么可以通过改良程序得到以下版本。

int ans=1;
a=a%c;//加上这一句
for(int i=1;i<=b;i++)
{
    ans=(ans\*a)%c;//取余
}
ans=ans%c;

但是这个算法在时间复杂度上没有改进，仍为O(b)，不过已经好很多的，但是在c过大的条件下，还是很有可能超时，所以，我们需要用到快速幂算法来进行改进。

关于快速幂的算法的介绍，我么从推导其公式入手。

首先我们将十进制的指数b转换为2进制的形式

在这里插入图片描述

其中

a_n

an代表对应对应第n位的二进制值，非0即1。那么由二进制转换为十进制的公式我们可以得到

在这里插入图片描述

化简上述公式可得

则

a^b

abmod c可重写为

在这里插入图片描述

此处的

a_i

ai要么为0，要么为1，如果

a_i

ai为0，那么这一项值就为1。所以可以再次将上述式子化简为

在这里插入图片描述
其中

k_i

ki表示

a_i

ai不为0的项。

同时发现，对于每一项的计算时，计算后一项的结果时用前一项的结果的平方取余。用公式表示为

在这里插入图片描述

形如上式的公式推导，我们将其用代码实现。

int ans=1;
a=a%c;
while(b>0)
{
    if(b%2==1)
        ans=(ans\*a)%c;
        b=b/2;
        a=(a\*a)%c;
}

此时，当b=0时，所有的因子都已经相乘，算法结束。于是便可以在O（log b）的时间内完成了。所以在进行模幂运算时, 运算的复杂度已经和指数b的大小没有直接关系了, 有直接关系的是b的二进制bit位数。

问题3：大数的加/减/乘/除/模运算

在RSA算法中的数字极大, 是我们现有计算机无法直接计算的, 所以需要我们手动实现大数的加减乘除. 所以在实现中，直接调用boost库中的大数运算库cppp_int。

boost中的cpp_int库的介绍文档
https://www.boost.org/doc/libs/1_58_0/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html
项目使用的是boost_1_83_0版本的大数库,下载链接https://www.boost.org/users/download/
在VS中还需要将解压好的boost库路径添加到附加目录, 步骤如下
在这里插入图片描述

问题4：大数产生随机数

我们平时用的随机数函数是 srand()设置随机数种子, 一般传入time(0), 用 rand()获取随机数, 随机数 = rand % num; 随机数范围是 [0, num). 在不同平台的不同编译器下rand()函数所能获取的随机数的范围不同, 但由于目前CPU位数的限制, 顶多也就是个64位的数字, 所以我们还需要能产生大随机数的方法.

解决方案：在boost库的random库中有着大数随机数的获取方法，在调用时包含头文件#include<boost/multiprecision/random.hpp>

问题5：大数产生质数

大数的素性检测有专门的算法, 比如fermat检测, Miller-Rabin等算法. 在boost库中的实现了Miller-Rabin素性检测算法,使用时添加头文件#include <boost/multiprecision/miller_rabin.hpp>

三、RSA加密算法代码实现

rsa.h

#pragma once
#include<iostream>
#include<boost/multiprecision/cpp\_int.hpp>//大数库
#include<boost/multiprecision/random.hpp>//随机数库
#include<boost/multiprecision/miller\_rabin.hpp>//素性检测
#include<boost/algorithm/string.hpp> //spilt()接口就在这个库中
 
namespace br = boost::random;
namespace bm = boost::multiprecision;
 
#define NUMBER 128 //临时缓冲区大小
#define SECRET\_KEY\_PATH "secret\_key.txt" //存储N,D,E的文件名
#define SIZE 128 //控制随机数大小, 范围是 0 ~ 1 << SIZE
 
typedef struct {
	bm::int1024\_t m_ekey;//公钥e
	bm::int1024\_t m_dkey;//私钥d
	bm::int1024\_t m_nkey;//公共模数n
}Key;
 
class RSA {
	Key m_key;
	bm::int1024\_t GetPrime();
	bool isPrime(bm::int1024\_t& num);
	bm::int1024\_t getNkey(bm::int1024\_t& prime1, bm::int1024\_t& prime2);//获取公共模数n
	bm::int1024\_t getOrla(bm::int1024\_t& prime1, bm::int1024\_t& prime2);//欧拉函数, 得到f(n)
	bm::int1024\_t getEkey(bm::int1024\_t& orla);//获取公钥
	bm::int1024\_t getDkey(bm::int1024\_t& ekey, bm::int1024\_t& orla);//获取私钥
	void exGcd(bm::int1024\_t a, bm::int1024\_t b, bm::int1024\_t\* x, bm::int1024\_t\* y);//求模反元素
	bm::int1024\_t getGcd(bm::int1024\_t num1, bm::int1024\_t num2);//最大公约数
	bm::int1024\_t \_encrypt(bm::int1024\_t data, bm::int1024\_t ekey, bm::int1024\_t nkey);//加密,需要加密数据和公钥(e, n)
	bm::int1024\_t \_decrypt(bm::int1024\_t data, bm::int1024\_t dkey, bm::int1024\_t nkey);//解密,需要要解密的数据和私钥(d, n)
	void getKeys();
public:
	RSA();
	bool encrypt(const std::string filename, const std::string outname);//加密
	bool decrypt(const std::string filename, const std::string outname);//解密
};

rsa.cpp

#include<fstream>
#include<vector>
#include"rsa.h"
using namespace std;
 
RSA::RSA() {
	getKeys();
}
bm::int1024\_t RSA::getNkey(bm::int1024\_t& prime1, bm::int1024\_t& prime2) {
	return prime1 \* prime2;
}
bm::int1024\_t RSA::getOrla(bm::int1024\_t& prime1, bm::int1024\_t& prime2) {//prime1和prime2必须互质
	return (prime1 - 1) \* (prime2 - 1);
}
bm::int1024\_t RSA::getEkey(bm::int1024\_t& orla) {
	bm::int1024\_t ekey;
	br::mt11213b gen((size\_t)time(0));
	br::uniform_int_distribution<bm::int1024\_t> dist(bm::int1024\_t(0), (bm::int1024\_t(orla)));
	do {
		ekey = dist(gen);
	} while (ekey < 2 || getGcd(ekey, orla) != 1);
	return ekey;
}
bm::int1024\_t RSA::getDkey(bm::int1024\_t& ekey, bm::int1024\_t& orla) {
	bm::int1024\_t x, y;
	exGcd(ekey, orla, &x, &y);
	return (x % orla + orla) % orla;//变换, 让解密密钥是一个比较小的数
}
bm::int1024\_t RSA::getGcd(bm::int1024\_t num1, bm::int1024\_t num2) {
	bm::int1024\_t num;
	while ((num = num1 % num2)) {
		num1 = num2;
		num2 = num;
	}
	return num2;
}
void RSA::exGcd(bm::int1024\_t a, bm::int1024\_t b, bm::int1024\_t\* x, bm::int1024\_t\* y) {
	if (b == 0) {
		\*x = 1;
		\*y = 0;
		return;
	}
	exGcd(b, a % b, x, y);
	bm::int1024\_t tmp = \*x;
	\*x = \*y;
	\*y = tmp - a / b \* (\*y);
}
bm::int1024\_t RSA::\_encrypt(bm::int1024\_t Ai, bm::int1024\_t ekey, bm::int1024\_t nkey) {
	//data^ekey % nkey
	//只和ekey的位数有关
	bm::int1024\_t res = 1;
	for (; ekey; ekey >>= 1) {
		if (ekey & 1) {
			res = (res\*Ai) % nkey;
		}
		Ai = (Ai\*Ai) % nkey;
	}
	return res;
}
bm::int1024\_t RSA::\_decrypt(bm::int1024\_t data, bm::int1024\_t dkey, bm::int1024\_t nkey) {
	return \_encrypt(data, dkey, nkey);
}
bool RSA::isPrime(bm::int1024\_t& num) {
	br::mt11213b gen((size\_t)time(0));//要和产生随机数的发生器不一样
	if (miller\_rabin\_test(num, 25, gen)) {
		if (miller\_rabin\_test((num - 1) / 2, 25, gen)) {
			return true;
		}
	}
	return false;
}
bm::int1024\_t RSA::GetPrime() {
	bm::int1024\_t res;
	br::mt19937 gen((size\_t)time(0));
	br::uniform_int_distribution<bm::int1024\_t> dist(bm::int1024\_t(0), (bm::int1024\_t(1) << SIZE));
	while (!isPrime(res = dist(gen)));
	return res;
}
void RSA::getKeys() {
	FILE\* fp;
	if ((fp = fopen(SECRET_KEY_PATH, "r")) == NULL) {
		cout << "生成密钥, 公钥中...\n";
		bm::int1024\_t prime1, prime2 = GetPrime();
		while ((prime1 = GetPrime()) == prime2);
		m_key.m_nkey = getNkey(prime1, prime2);
		bm::int1024\_t orla = getOrla(prime1, prime2);
		m_key.m_ekey = getEkey(orla);
		m_key.m_dkey = getDkey(m_key.m_ekey, orla);
		stringstream tmp;
		tmp << m_key.m_nkey << '\n' << m_key.m_ekey << '\n' << m_key.m_dkey << '\n';
		ofstream fout(SECRET_KEY_PATH, ofstream::binary);
		if (fout.is\_open() == false) {
			perror("file open failed!");
			return;
		}
		fout.write(tmp.str().c\_str(), tmp.str().size());
		if (fout.good() == false) {
			cout << "file " << SECRET_KEY_PATH << " read data failed!\n";
		}
		fout.close();
	}
	else {
		fseek(fp, 0L, SEEK\_END);
		size\_t fsize = ftell(fp);
		fclose(fp);
		ifstream fin(SECRET_KEY_PATH, ifstream::binary);
		if (fin.is\_open() == false) {
			perror("file open failed!");
			return;
		}
		string buf;
		buf.resize(fsize);
		fin.read(&buf[0], fsize);
		if (fin.good() == false) {
			cout << "file " << SECRET_KEY_PATH << " read data failed!\n";
		}
		vector<string> secret_key;
		//split用于分割字符串
		boost::split(secret_key, buf, boost::is\_any\_of("\n"), boost::token_compress_on);
		m_key.m_nkey = bm::int1024\_t(secret_key[0]);
		m_key.m_ekey = bm::int1024\_t(secret_key[1]);
		m_key.m_dkey = bm::int1024\_t(secret_key[2]);
		fin.close();
	}
}
bool RSA::encrypt(const string filename, const string outname) {
	ifstream fin(filename, ifstream::binary);
	ofstream fout(outname, ifstream::binary);
	if (!fin.is\_open()) {
		perror("input file open failed!");
		return false;
	}
	char\* buffer = new char[NUMBER];
	bm::int1024\_t\* bufferOut = new bm::int1024\_t[NUMBER];
	while (!fin.eof()) {
		fin.read(buffer, NUMBER);
		streamsize ret = fin.gcount();
		for (streamsize i = 0; i < ret; ++i) {
			bufferOut[i] = \_encrypt(buffer[i], m_key.m_ekey, m_key.m_nkey);
		}
		fout.write((char\*)bufferOut, ret \* sizeof(bm::int1024\_t));
	}
	delete[] bufferOut;
	delete[] buffer;
	fin.close();
	fout.close();
	return true;
}
bool RSA::decrypt(const string filename, const string outname) {
	ifstream fin(filename, ifstream::binary);
	ofstream fout(outname, ifstream::binary);
	if (!fin.is\_open()) {
		perror("file open failed");
		return false;
	}
	bm::int1024\_t\* buffer = new bm::int1024\_t[NUMBER];
	char\* bufferOut = new char[NUMBER];
	while (!fin.eof()) {
		fin.read((char\*)buffer, NUMBER \* sizeof(bm::int1024\_t));
		streamsize ret = fin.gcount() / sizeof(bm::int1024\_t);
		for (streamsize i = 0; i < ret; ++i) {
			bufferOut[i] = (char)\_decrypt(buffer[i], m_key.m_dkey, m_key.m_nkey);
		}
		fout.write(bufferOut, ret);
	}
	delete[] bufferOut;
	delete[] buffer;
	fin.close();
	fout.close();
	return true;
}

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

2401_84281712

关注

16
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
最新RSA加密解密算法原理以及实现_rsa简介及源码实现，2024年最新还没吃透内存缓存LruCache实现原理的看这篇文章

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！
复制链接

扫一扫