RSA加密算法简单介绍

注：本篇文章只是本人在学完RSA加密之后的个人总结，若有不正确的地方，欢迎指正OVO

RSA是一种公钥加密算法，它具有公钥和私钥两种密钥：公钥用来加密，并且是公开的，私钥是用来解密的，是不公开的，也不需要和数据一起传送，这样就能防止密钥在网络传输时泄露。

RSA算法设计的原理是依靠着模幂运算，例如加密、解密以及密钥的产生。

1.密钥设计

首先，我们需要了解密钥设计的思想：
①加密计算：c = m^e mod n;
②解密计算：m = c^d mod n;
其中m为明文， c为密文，e为公钥，d为私钥，n为一个我们要产生的大数。

所以，根据以上两个式子有：
dk( ek(m) ) = m
= (m^e mod n) ^d mod n # 这里也就是先加密再解密
= m^(ed) mod n
那么要实现解密生成的数据和明文一样，**m^(ed) mod n一定要等于m。①**

m^φ(n) mod n = 1 → m ^(tφ(n)) mod n = 1 → m ^(tφ(n)+1) mod n = m ②
∴① ②中两个式子相对应，即有：ed = (t*φ(n)+1) → ed = 1 mod φ（n）。
不难看出，公钥e和私钥d是关于φ(n)互逆的。

到这里，可能会有疑问，为什么别人不能根据公钥e和 φ(n)来直接求得私钥呢？，这就是接下来要讲的：如何生成n使别人难以计算φ(n)。

2.大数n的生成

首先，我们需要知道一个定理：若n = p*q, 且p，q为素数，那么φ(n) =φ(p) * φ(q) = (p-1) * (q-1)
而且我们知道，想要分解一个大的数是非常困难的，所以我们需要找两个大数p，q，来使生成的n难以被分解计算，而且我们需要p，q都是素数，才能满足上述定理，所以我们问题就变成了如何产生大素数p，q。

3.产生大素数p，q

我们思路可以是这样：要产生大素数，我们可以先用随机数产生一个大数，然后再判断其是否为素数就行。
产生大数简单，random库可以实现，那么如何验证其是否为素数呢？这里我们不能使用简单的素数判别法：如遍历比它小的所有数，并且对其取余，看是否为0。因为这样只适用于小数，对于大数来说，计算时间太长了，根本行不通。所以这里我们需要采用一种素数检测法：Miller-Rabin算法

Miller-Rabin算法思想：
首先，由费马小定理：a^p-1 = 1 mod p （p为素数），我们可以将p-1写成2 ^k*m形式，其中，a我们可随机生成，但需满足1<=a<=n-1。
那么a ^p-1 = ((a ^m) ^2) ^2 … ，所以我们可以先验算a ^m mod p的结果是否为±1，
若是，那么a ^p-1 = ((a ^m) ^2) ^2 … 一定为1，那么可以判断出p为素数；
若不是，令b=a^ m mod p的结果，然后依次计算b, b^ 2,b^ 4,…,b^ 2^(k-1) mod n,若发现有一个为±1,则p是素数，否则，p为合数。

但是，这种算法并不是100%正确，有时候也会将合数当成素数输出，所以一般情况下，我们可以产生伪随机数来进行素数检测，而不是使用随机数来检测。

Miller-Rabin算法具体代码如下：

#判断是否为素数（Miller-Rabbin）,RoundTime表示循环测试的次数，提高准确率
def _MillerRabin(self, num: int, times: int):# Miller-Rabin素性检验# return False if n is not primem = num-1k = 0while m & 1 == 0:m >>= 1k += 1for _ in range(times):x = random.randrange(2, num)x = self._FastExpMod(x, m, num)for _ in range(k):y = (x*x) % numif y == 1 and x != 1 and x != num-1:return Falsex = yif y != 1:return Falsereturn True

4.密钥生成

我们生成两个大素数p，q后，我们就可以直接得到φ(n)。对于公钥e，我们可以随机生成，但需要满足gcd(e,φ(n))=1（可以使用欧几里得除法来判断余数是否为1）。

然后对于私钥d，因为ed = 1 mod φ（n）所以我们只需要求逆元就能得到d，然而求逆元可以根据欧几里得除法逆过程来求得。欧几里得除法求逆代码如下：

 #求x,y为两个所求逆元，其中y为私钥def _ExtendedEuclidean(self, a: int, b: int):# 扩展欧几里得算法# return x, y, gcd(a,b)# 使得x*a + y*b = gcd(a,b)# 非递归实现if b == 0:return 1, 0, ay = s1 = 1x = s2 = 0q, r = divmod(a, b)while r:m = xn = yx = s1 - x*qy = s2 - y*qs1 = ms2 = na = bb = rq, r = divmod(a, b)return x, y, b

5.加解密

加解密过程我们只需根据：
①加密计算：c = m^e mod n;
②解密计算：m = c^d mod n; 来计算就行。

但是，对于大数的计算，我们不能直接使用高级语言所给定的计算来求，这样也会导致时间太长，我们在这需要使用平方-乘算法来求。该算法具体代码如下：

#平方乘算法求余数 base^n mod mod
def _FastExpMod(self, base: int, exp: int, mod: int):# 快速幂取模: 蒙哥马利幂模运算# return base**exp % modbase = base % modexp = exp % modpower = 1while exp:if exp & 1:power = (power * base) % modexp >>= 1base = (base * base) % modreturn power

全部代码

import randomclass RSA:def __init__(self):self._lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19]for i in range(self._lowPrimes[-1]+1, 1000):for p in self._lowPrimes:if i % p:continueelse:breakelse:self._lowPrimes.append(i)def _FastExpMod(self, base: int, exp: int, mod: int):# 快速幂取模: 蒙哥马利幂模运算# return base**exp % mod# base = base % mod# exp = exp % modpower = 1while exp:if exp & 1:power = (power * base) % modexp >>= 1base = (base * base) % modreturn powerdef _MillerRabin(self, num: int, times: int):# Miller-Rabin素性检验# return False if n is not primem = num-1k = 0while m & 1 == 0:m >>= 1k += 1for _ in range(times):x = random.randrange(2, num)x = self._FastExpMod(x, m, num)for _ in range(k):y = (x*x) % numif y == 1 and x != 1 and x != num-1:return Falsex = yif y != 1:return Falsereturn Truedef _IsNotPrime(self, num: int, times: int = 10):# 分解质因数测试 + Miller-Rabin素性检验# return True if n is not primeif num < 2:return True# 分解质因数for p in self._lowPrimes:d, m = divmod(num, p)if m == 0:if d == 1:return Falseelse:return True# Miller-RabinisP = self._MillerRabin(num, times)return not isPdef _FindPrime(self, low_bits: int, high_bits: int) -> int:# 在区间[2^lowBits,2^highBits)寻找一个素数lowNum = 1 << low_bitshighNum = 1 << high_bitsn = random.randrange(lowNum, highNum)while self._IsNotPrime(n):n = random.randrange(lowNum, highNum)return ndef _ExtendedEuclidean(self, a: int, b: int):# 扩展欧几里得算法# return x, y, gcd(a,b)# 使得x*a + y*b = gcd(a,b)# 非递归实现if b == 0:return 1, 0, ay = s1 = 1x = s2 = 0q, r = divmod(a, b)while r:m = xn = yx = s1 - x*qy = s2 - y*qs1 = ms2 = na = bb = rq, r = divmod(a, b)return x, y, bdef hex2int(self, x: str) -> int:# hex字符串转换为整数return int(x, 16)def int2hex(self, x: int) -> str:# 整数转换为hex字符串return hex(x)[2:]def hex2bin(self, x: str) -> str:# hex字符串转换为字节数组if len(x) & 1:x = "0" + xbuffer = bytearray()for i in range(0, len(x), 2):buffer.append(self.hex2int(x[i:i+2]))x = bytes(buffer)return x.decode()def RSA_Key_Gen(self):# 生成RSA密钥对key_len = 1024p = self._FindPrime(key_len-6, key_len-2)q = self._FindPrime(key_len+2, key_len+6)n = p * qphi = (p-1)*(q-1)gcd = 0while gcd != 1:e = random.randint(1, 2**100)_, d, gcd = self._ExtendedEuclidean(phi, e)  # 欧几里得求逆元if d < 0:d += phiwith open("RSA_Public_Key.txt", 'w') as f:res = str(n)+"\n"+str(e)f.write(res)with open("RSA_Secret_Key.txt", 'w') as f:res = str(n)+"\n"+str(d)f.write(res)def Encrypt(self, plain_text: str, public_key: tuple) -> int:data = int(plain_text.encode().hex(), 16)  # 明文进行处理n, e = public_key  # 获得公钥result = self._FastExpMod(data, e, n)return resultdef Decrypt(self, secret_text: int, secret_key: tuple) -> str:n, d = secret_keyresult = self._FastExpMod(secret_text, d, n)return self.hex2bin(self.int2hex(result))