大家好，又见面了，我是你们的朋友全栈君。
代码已经放上github : https://github.com/chroje/RSA
一、非对称加密算法
1、乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。
2、甲方获取乙方的公钥，然后用它对信息加密。
3、乙方得到加密后的信息，用私钥解密。
二、RSA算法
1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。从那时直到现在，RSA算法一直是最广为使用的”非对称加密算法”。毫不夸张地说，只要有计算机网络的地方，就有RSA算法。
这种算法非常可靠，密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。
三、数学基础
1、互质关系
如果两个正整数，除了1以外，没有其他公因子，我们就称这两个数是互质关系（coprime）。比如，15和32没有公因子，所以它们是互质关系。这说明，不是质数也可以构成互质关系。
关于互质关系，不难得到以下结论：
1. 任意两个质数构成互质关系，比如13和61。
2. 一个数是质数，另一个数只要不是前者的倍数，两者就构成互质关系，比如3和10。
3. 如果两个数之中，较大的那个数是质数，则两者构成互质关系，比如97和57。
4. 1和任意一个自然数是都是互质关系，比如1和99。
5. p是大于1的整数，则p和p-1构成互质关系，比如57和56。
6. p是大于1的奇数，则p和p-2构成互质关系，比如17和15。
2、欧拉函数
请思考以下问题：
任意给定正整数n，请问在小于等于n的正整数之中，有多少个与n构成互质关系？（比如，在1到8之中，有多少个数与8构成互质关系？）
计算这个值的方法就叫做欧拉函数，以φ(n)表示。在1到8之中，与8形成互质关系的是1、3、5、7，所以 φ(n) = 4。
φ(n) 的计算方法并不复杂，但是为了得到最后那个公式，需要一步步讨论。
四、密钥生成
我们通过一个例子，来理解RSA算法。假设爱丽丝要与鲍勃进行加密通信，她该怎么生成公钥和私钥呢？
- 第一步，随机选择两个不相等的质数p和q。
爱丽丝选择了61和53。（实际应用中，这两个质数越大，就越难破解。）
- 第二步，计算p和q的乘积n。
爱丽丝就把61和53相乘。
n = 61×53 = 3233 |
|---|
n的长度就是密钥长度。3233写成二进制是110010100001，一共有12位，所以这个密钥就是12位。实际应用中，RSA密钥一般是1024位，重要场合则为2048位。
- 第三步，计算n的欧拉函数φ(n)。
根据公式：
φ(n) = (p-1)(q-1) |
|---|
爱丽丝算出φ(3233)等于60×52，即3120。
- 第四步，随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n) 互质。
爱丽丝就在1到3120之间，随机选择了17。（实际应用中，常常选择65537。）
- 第五步，计算e对于φ(n)的模反元素d。
所谓”模反元素”就是指有一个整数d，可以使得ed被φ(n)除的余数为1。
ed ≡ 1 (mod φ(n)) |
|---|
这个式子等价于
ed – 1 = kφ(n) (k∈Z) |
|---|
于是，找到模反元素d，实质上就是对下面这个二元一次方程求解。
ex φ(n)y = 1 |
|---|
已知 e=17, φ(n)=3120，
17x 3120y = 1 |
|---|
这个方程可以用”扩展欧几里得算法”求解，此处省略具体过程。总之，爱丽丝算出一组整数解为 (x,y)=(2753,-15)，即 d=2753。
至此所有计算完成。
- 第六步，将n和e封装成公钥，n和d封装成私钥。
在爱丽丝的例子中，n=3233，e=17，d=2753，所以公钥就是 (3233,17)，私钥就是（3233, 2753）。
- 总结，实际上就是计算n,e,d的过程
pq的作用用于求n==pq，再用 (p-1)(q-1)求φ(n)，在φ(n)范围内随机选择即为e，d==e对于φ(n)的模反元素
五、验证RSA算法的可靠性
公钥公开，私钥不公开，故d被破解即RSA算法被破解。
回顾上面的密钥生成步骤，一共出现六个数字：
p,q,n,φ(n),e,d |
|---|
这六个数字之中，公钥用到了两个（n和e），其余四个数字都是不公开的。其中最关键的是d，因为n和d组成了私钥，一旦d泄漏，就等于私钥泄漏。
那么，有无可能在已知n和e的情况下，推导出d？
- ed=1 (mod φ(n))。只有知道e和φ(n)，才能算出d。
- φ(n)=(p-1)(q-1)。只有知道p和q，才能算出φ(n)。
- n=pq。只有将n因数分解，才能算出p和q。
结论：如果n可以被因数分解，d就可以算出，也就意味着私钥被破解。
可是，大整数的因数分解，是一件非常困难的事情。目前，除了暴力破解，还没有发现别的有效方法。维基百科这样写道：”对极大整数做因数分解的难度决定了RSA算法的可靠性。换言之，对一极大整数做因数分解愈困难，RSA算法愈可靠。
假如有人找到一种快速因数分解的算法，那么RSA的可靠性就会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA密钥才可能被暴力破解。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。
只要密钥长度足够长，用RSA加密的信息实际上是不能被解破的。”
举例来说，你可以对3233进行因数分解（61×53），但是你没法对下面这个整数进行因数分解。
1230186684530117755130494958384962720772853569595334792197322452151726400507263657518745202199786469389956474942774063845925192557326303453731548268507917026122142913461670429214311602221240479274737794080665351419597459856902143413 |
|---|
它等于这样两个质数的乘积：
3347807169895689878604416984821269081770479498371376856892431388982883793878002287614711652531743087737814467999489 |
|---|
×
36746043666799590428244633799627952632279158164343087642676032283815739666511279233373417143396810270092798736308917 |
|---|
事实上，这大概是人类已经分解的最大整数（232个十进制位，768个二进制位）。比它更大的因数分解，还没有被报道过，因此目前被破解的最长RSA密钥就是768位。
六、加密与解密
有了公钥和密钥，就能进行加密和解密了。
1、加密要用公钥 (n,e)
假设鲍勃要向爱丽丝发送加密信息m，他就要用爱丽丝的公钥 (n,e) 对m进行加密。这里需要注意，m必须是整数（字符串可以取ascii值或unicode值），且m必须小于n。
所谓”加密”，就是算出下式的c：
m^e ≡ c (mod n) |
|---|
爱丽丝的公钥是 (3233, 17)，鲍勃的m假设是65，那么可以算出下面的等式：
65^17 ≡ 2790 (mod 3233)
于是，c等于2790，鲍勃就把2790发给了爱丽丝。
2、解密要用私钥(n,d)
爱丽丝拿到鲍勃发来的2790以后，就用自己的私钥(3233, 2753) 进行解密。可以证明，下面的等式一定成立：
c^d ≡ m (mod n) |
|---|
也就是说，c的d次方除以n的余数为m。现在，c等于2790，私钥是(3233, 2753)，那么，爱丽丝算出
2790^2753 ≡ 65 (mod 3233)
因此，爱丽丝知道了鲍勃加密前的原文就是65。
至此，”加密–解密”的整个过程全部完成。
我们可以看到，如果不知道d，就没有办法从c求出m。而前面已经说过，要知道d就必须分解n，这是极难做到的，所以RSA算法保证了通信安全。
你可能会问，公钥(n,e) 只能加密小于n的整数m，那么如果要加密大于n的整数，该怎么办？有两种解决方法：一种是把长信息分割成若干段短消息，每段分别加密；另一种是先选择一种”对称性加密算法”（比如DES），用这种算法的密钥加密信息，再用RSA公钥加密DES密钥。
七、私钥解密的证明
a=b(mod c)等价于a/c的余数是b,a mod c ==b
最后，我们来证明，为什么用私钥解密，一定可以正确地得到m。也就是证明下面这个式子：
c^d ≡ m (mod n) |
|---|
因为，根据加密规则
ｍ^e ≡ c (mod n) |
|---|
于是，c可以写成下面的形式：
c = m^e – kn(h∈Z) |
|---|
将c代入要我们要证明的那个解密规则：
它等同于求证由于(a-b)^n=a^n-C1n a^(n-1)b C2n a^(n-2)b^2 … (-b)^n
m^(ed) ≡ m (mod n) |
|---|
由于
ed ≡ 1 (mod φ(n)) |
|---|
所以
ed = hφ(n) 1 |
|---|
将ed代入：
m^(hφ(n) 1) ≡ m (mod n) |
|---|
接下来，分成两种情况证明上面这个式子。
- 当m与n互质。
根据欧拉定理，此时
得到
证明 (kn 1)^h*m=m(mod n)展开即可 |
|---|
原式得到证明。
- 当m与n不是互质关系。
此时，由于n等于质数p和q的乘积，所以m必然等于kp或kq。
以 m = kp为例，考虑到这时k与q必然互质，则根据欧拉定理，下面的式子成立：
(kp)^q-1 ≡ 1 (mod q) |
|---|
将它改写成下面的等式
这时t必然能被p整除，即 t=t’p
因为 m=kp，n=pq，所以
原式得到证明。
八、快速幂模算法
在讲解快速幂取模算法之前，我们先将几个必备的知识
1.对于取模运算：
(a*b)%c=(a%c)*(b%c)%c
这个是成立的：也是我们实现快速幂的基础
核心思想在于：
将大数的幂运算拆解成了相对应的乘法运算，利用上面的式子，始终将我们的运算的数据量控制在c的范围以下，这样我们可以客服朴素的算法的缺点二，我们将计算的数据量压缩了很大一部分，当指数非常大的时候这个优化是更加显著的，我们用Python来做一个实验来看看就知道我们优化的效率有多高了
算法实现：
代码语言：javascript复制# 快速幂模运算，把b拆分为二进制，遍历b的二进制，当二进制位为0时不计入计算
def quick_pow_mod(a, b, c):
a = a % c
ans = 1
# 这里我们不需要考虑b<0，因为分数没有取模运算 while b != 0: # 判断b的二进制最后一位数是不是1，是则参与计算 if b & 1: ans = (ans * a) % c # ans = (ans * a) % c,理论上等价于 ans = (ans % c) * (a % c)但是不知道为什么这样写会出错。已解决，因为可能最后一次相乘的时候返回一个未除尽的数 # 相当于遍历二进制的b b >>= 1
# A(n) == A(n-1)^2，% c可以提高效率
a = (a % c) * (a % c)
return ans a^b%c |
|---|
对于任何一个整数的模幂运算
对于b我们可以拆成二进制的形式
b=b0 b1*2 b2*2^2 … bn*2^n |
|---|
这里我们的b0对应的是b二进制的第一位（倒数第一位），那么我们的a^b运算就可以拆解成
a^b0*a^b1*2*…*a^(bn*2^n) |
|---|
对于b来说，二进制位不是0就是1，那么对于bx为0的项我们的计算结果是1就不用考虑了，我们真正想要的其实是b的非0二进制位，那么假设除去了b的0的二进制位之后我们得到的式子是
a^(bx*2^x)*…*a(bn*2^n) |
|---|
这里我们再应用我们一开始提到的公式，那么我们的a^b%c运算就可以转化为
(a^(bx*2^x)%c）*…*(a^(bn*2^n)%c) |
|---|
这样的话，我们就很接近快速幂的本质了。
(a^(bx*2^x)%c)*…*(a^(bn*2^n)%c) |
|---|
我们会发现令
A1=(a^(bx*2^x)%c) |
|---|
… |
An=(a^(bn*2^n)%c) |
这样的话，假设bx都=1，An始终等于A(n-1)的平方，依次递推。
首先，我们会观察到，我们每次都是将b的规模缩小了2倍。
那么很显然，原本的朴素的时间复杂度是O(n)。快速幂的时间复杂度就是O(logn)。在数据量越大的时候，者中优化效果越明显。
九、Miller-Rabin素性测试算法
素性测试(即测试给定的数是否为素数)是近代密码学中的一个非常重要的课题。虽然Wilson定理(对于给定的正整数n，n是素数的充要条件为)给出了一个数是素数的充要条件，但根据它来素性测试所需的计算量太大，无法实现对较大整数的测试。目前，尽管高效的确定性的素性算法尚未找到，但已有一些随机算法可用于素性测试及大整数的因数分解。下面描述的Miller-Rabin素性测试算法就是一个这样的算法。
算法：
首先要知道费马定理只是n是素数的必要条件。即费马定理不成立，n一定是合数；费马定理成立，n可能是素数。接下来请看Miller-Rabin算法的分析过程。
x^2 = 1(mod p),p为质数，x小于p
x = 1或 p -1
x的偶数次方对p取余数，结果可能是1^x * (p-1)^y对p取余数，即结果有可能是1，p-1，或(p-1)^k对p取模，当k为偶数时=1，当k为奇数时=p-1
若有解，3/4概率是质数
算法实现：
代码语言：javascript复制# n为要检验的大质数，a < n,k = n - 1 def miller_rabin_witness(a, n): if n == 1: return False if n == 2: return True # n - 1 = m * 2^q 求解 m, q,因为n为偶数，所以必有解 k = n - 1 # 2为 底数，n为N q = int(math.floor(math.log(k, 2))) while q > 0:
m = k / 2 ** q
# 必须同时满足两个条件，因为m有可能是未除尽的数
if k % 2 ** q == 0 and m % 2 == 1:
break
q = q - 1
# 先计算 a ^ (n-1) == 1 mod(n) 是否成立，不成立必定为合数
if quick_pow_mod(a, n - 1, n) != 1:
return False
# 计算第一项
b1 = quick_pow_mod(a, m, n)
for i in range(1, q 1):
if b1 == n - 1 or b1 == 1:
return True
# 后一项等于前一项的平方mod n
b2 = b1 ** 2 % n
b1 = b2
if b1 == 1:
return True
return False
# Miller-Rabin素性检验算法,检验8次
def prime_test_miller_rabin(p, k):
while k > 0:
a = random.randint(1, p - 1)
if not miller_rabin_witness(a, p):
return False
k = k - 1
return True扩展欧几里德算法是用来在已知a, b求解一组x，y，使它们满足贝祖等式： ax by = gcd(a, b) =d（解一定存在，根据数论中的相关定理）。
十、扩展欧几里德算法
e取65537，故list[0] * s list[1] * e = 1，list[1]为(e)mod(s)的乘法逆元，也就是e对于φ(n)的模反元素d，此方程必有解。
欧几里德算法停止的状态是： a= gcd ， b = 0 ，那么，这是否能给我们求解 x y 提供一种思路呢？因为，这时候，只要 a = gcd 的系数是 1 ，那么只要 b 的系数是 0 或者其他值（无所谓是多少，反正任何数乘以 0 都等于 0 但是a 的系数一定要是 1），这时，我们就会有： a*1 b*0 = gcd
当然这是最终状态，但是我们是否可以从最终状态反推到最初的状态呢？
假设当前我们要处理的是求出 a 和 b的最大公约数，并求出 x 和 y 使得 a*x b*y= gcd ，而我们已经求出了下一个状态：b 和 a%b 的最大公约数，并且求出了一组x1 和y1 使得： b*x1 (a%b)*y1 = gcd ， 那么这两个相邻的状态之间是否存在一种关系呢？
我们知道： a%b = a – (a/b)*b（这里的 “/” 指的是整除，例如 5/2=2 , 1/3=0）， 代入b*x1 (a%b)*y1 = gcd 那么，我们可以进一步得到：
gcd = b*x1 (a-(a/b)*b)*y1
= b*x1 a*y1 – (a/b)*b*y1
= a*y1 b*(x1 – a/b*y1)
对比之前我们的状态：求一组 x 和 y 使得：a*x b*y = gcd ，是否发现了什么？
这里：
x = y1
y = x1 – a/b*y1
算法实现：
# 这里的逻辑很复杂 # 扩展欧几里得算法，得到结果list[0]是a的系数，list[1]是b的系数 list[0] * a list[1] * b = 1,但是有可能得到的list[1]是负数 def ex_euclid(a, b, list): # b==0时 a 为先求出最大公约数 if b == 0: list[0] = 1L list[1] = 0L list[2] = a else: # 把b作为a传入函数，会形成一个交替的过程以 8,3为例，以次为[8,3],[3,2],[2,1],[1,0],即函数入栈时，第二个参数的值为入栈后第一个参数的值 # 对应着出栈时，函数的第一个参数的值等于出栈后第二个参数 # [8, 3], [3, 2], [2, 1], [1, 0]对应的list取值为[-1,3,1][1,-1,1][0,1,1][1,0,1] ex_euclid(b, a % b, list) temp = list[0] # a%b = a – (a/b)*b ,b*x1 (a%b)*y1 = gcd # gcd = b*x1 (a-(a/b)*b)*y1 = b*x1 a*y1–(a/b)*b*y1 = a*y1 b*(x1 – a/b*y1) # 故出栈时，函数的第二个参数的系数等于出栈后第一个参数的系数，出栈后第二个参数b的系数=x1 – a/b*y1 list[0] = list[1] # 算法 1 list[1] = temp – a / b * list[1] # 3 * x1 2 * y1 = 1,x1 已知= 1,y1 = (1 – 3 * x1 )/2 # 算法2，结果一致，使用时注释temp = list[0] # list[1] = (list[2] – a * list[0]) / b # 求模反元素 def mod_inverse(a, b): # x = list[0],y = list[1],q = list[2] list = [0L, 0L, 0L] if a < b: temp = a;a = b;b = temp; ex_euclid(a, b, list) # 改进，将负的模反元素变为正的模反元素，根据公式 ed ≡ 1 (mod (s)),ed s * k ≡ 1 (mod (s)),k为任意整数，令 k = m * e,即e的整数倍 # e(d s * m) ≡ 1 (mod (s)), abs(b) < s，所以只加一次即可 # 此处只对list[1]进行修改 if list[1] < 0: list[1] = a list[1] return list[1] |
|---|
十一、RSA实现流程
1.先创建一个包含有接近一万小质数的数组，随机获得一个30-31位数的十进制数字num，判断是否与数组元素都互质，若不互质则 2，直到获得一个都互质的整数
2.对num进行Miller-Rabin素性检验8次或者更多次。如果num没有通过检验，重新随机生成大整数重复之前步骤，否则认为num是素数。Miller-Rabin素性检验有一定概率会失败。
发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/134061.html原文链接：https://javaforall.cn
