文章/答案/技术大牛

发布

社区首页 >专栏 >使用Python实现RSA加密算法及详解RSA算法「建议收藏」

使用Python实现RSA加密算法及详解RSA算法「建议收藏」

全栈程序员站长

发布于 2022-08-15 11:32:35

7.2K00

代码可运行

文章被收录于专栏：全栈程序员必看全栈程序员必看

运行总次数：0

代码可运行

大家好，又见面了，我是你们的朋友全栈君。

代码已经放上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来做一个实验来看看就知道我们优化的效率有多高了

算法实现：

# 快速幂模运算，把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+b12+b22^2+…+bn*2^n

这里我们的b0对应的是b二进制的第一位（倒数第一位），那么我们的a^b运算就可以拆解成

a^b0a^b12…a^(bn*2^n)

对于b来说，二进制位不是0就是1，那么对于bx为0的项我们的计算结果是1就不用考虑了，我们真正想要的其实是b的非0二进制位，那么假设除去了b的0的二进制位之后我们得到的式子是

a^(bx2^x)…a(bn2^n)

这里我们再应用我们一开始提到的公式，那么我们的a^b%c运算就可以转化为

(a^(bx2^x)%c）…(a^(bn2^n)%c)

这样的话，我们就很接近快速幂的本质了。

(a^(bx2^x)%c)…(a^(bn2^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概率是质数

算法实现：

# 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]