RSA How it work？

RSA How it work？

注：下文分为两大主要的part，第一部分主要说明RSA运算的原理，约束问题。第二部分验证RSA算法的一致性。

截一个大脑袋给自己：

本文初稿于 5/15 2020

一.RSA原理与基本约束

Ⅰ.公钥密码体系

​ 1976年提出公共密钥密码体制，其原理是加密密钥和解密密钥分离。这样，一个具体用户就可以将自己设计的加密密钥和算法公诸于众，而只保密解密密钥。任何人利用这个加密密钥和算法向该用户发送的加密信息，该用户均可以将之还原。公共密钥密码的优点是不需要经安全渠道传递密钥，大大简化了密钥管理。

​ RSA是公钥密码体系的代表。

说明：

1.仅根据密码算法和加密密钥来确定解密密钥在计算上是不可能的。
2.两个密钥中任何一个都可以用来加密，另外一个可以用来解密。
3.同一算法用于加密和解密，但加密和解密使用不同的密钥。
4.两个密钥之一必须是保密的。

公钥密码体系的应用：

1.对user data的加密/解密。
2.数字签名。
3.密钥交换。
注：由于RSA算法的计算速度较慢，该算法常用于2和3。

Ⅱ.欧拉定理

定义：欧拉函数Φ(n)，他是指小于n且与n互质的正整数的个数，习惯上Φ(1)=1。

举例说明：
    Φ(7)=6;//因为7为质数{1,2,3,4,5,6}
    Φ(8)=4;//{1,3,5,7}

性质一：若p,q互质，n=p*q,则Φ(pq) = Φ§ x Φ(q)：
p q 集 合 = { 1 ， 2 ， . . . p q − 1 } , 不 与 n 互 质 的 元 素 集 合 为 { p , 2 p , . . . , ( q − 1 ) p }   { q , 2 q , . . . , ( p − 1 ) q } Φ ( n ) = Φ ( p q ) = ( p q − 1 ) − [ ( q − 1 ) + ( p − 1 ) ] = p q − ( p + q ) + 1 = ( p − 1 ) ∗ ( q − 1 ) = Φ ( p ) ∗ Φ ( q ) pq集合=\{1，2，...pq-1\},不与n互质的元素集合为\{p,2p,...,(q-1)p\} \ \{q,2q,...,(p-1)q\}\\ Φ(n) = Φ(pq)=(pq-1)-[(q-1)+(p-1)]\\ =pq-(p+q)+1\\ =(p-1)*(q-1)\\ =Φ(p) * Φ(q) pq集合={1，2，...pq−1},不与n互质的元素集合为{p,2p,...,(q−1)p} {q,2q,...,(p−1)q}Φ(n)=Φ(pq)=(pq−1)−[(q−1)+(p−1)]=pq−(p+q)+1=(p−1)∗(q−1)=Φ(p)∗Φ(q)
所以对于质数p有：Φ§=p-1;

假设有两个质数p和q：

其中p≠q，令n=p*q，则
Φ(n) = Φ(pq) = Φ(p) x Φ(q) = (p-1) x (q-1)

欧拉定理：对于任意 互质的a和n有
$$a^{\Phi (n)}\equiv 1（modn）即两者同余$$

Ⅲ.RSA算法

首先进行约定：
$$\begin{gathered} PR:私钥 \\ PU:公钥 \\ M:明文 \\ C:密文 \\ C=E(PU,M):使用公钥对M加密 \\ M=D(PR,C);使用私钥解密 \end{gathered}$$
​ RSA体制是一种分组密码，其明文M和密文C均是[ 0 , n-1 ]之间的整数，通常n的大小为1024位2进制数（或309位十进制数）。
$$定义lb(n)为整数n的位数$$
换句话来说，明文以分组形式进行加密，每个分组的值均小于n（即，分组大小≤lb(n)）
$$约束1：分组的大小是i位，其中2^i<n\le 2^{(i+1)}$$
RSA加密过程:
$$C=M^{e}modn$$
RSA解密过程:
$$M=C^{d}modn=(M^e{)}^{d}modn=M^{ed}modn$$
公钥与私钥：公钥与私钥并不是一个具体数，而是两个数的集合

PU = { e , n }
PR = { d, n }

下面继续给出约束：
$$\begin{gathered} 约束2：可以找到e,d,n使得对于所有M<n,有M^{ed}modn=M。 \\ 约束3：对于所有M<n，计算M^{e}modn和C^{d}modn是比较容易的。 \\ 约束4：由e和n确定d是不可行的。 \end{gathered}$$
接着聚焦参数e和参数d，how to calculate？（详细证明见第Ⅵ小节）
$$\begin{gathered} M=Mmodn=M\ast 1(modn) \\ 由欧拉定理M^{\Phi (n)}=1(modn),前提M和n互质 \\ {M}^{k\Phi (n)}=1(modn)，其中k为正整数。 \\ M\ast 1(modn)=M\ast M^{k\Phi (n)}(modn)=M^{k\Phi (n)+1}(modn) \end{gathered}$$
换句话来说，当e*d =kΦ(n)+1时（即，当e为Φ(n)的逆元时），则可以使得下式成立：
$$M=C^{d}modn=(M^e{)}^{d}modn=M^{ed}modn$$

约束5：gcd(d,Φ(n)) = gcd(e,Φ(n)) = 1

Ⅳ.RSA计算

首先给出 （n bit）RSA算法的定义：指的是n=pq中n的位数，如果lb(n)长度为512bit，则该RSA为512bitRSA算法。

给出RSA密钥计算步骤：

1.两个质数p q;（p，q为保密的，提前选定好的）
2.n = pq;
3.选定e，使得e满足gcd(e,Φ(n)) = 1;且 1 < e < Φ(n); 
4.利用欧几里得算法，d = e关于Φ(n)的逆元。
5.PU = { e , n } PR = { d, n }

下面给出示例：

第一步:随机选择两个不相等的质数p和q。
	p=17,q=11。（实际应用中，这两个质数越大，就越难破解）。 
	
第二步:计算p和q的乘积n。
	n = pq = 17x11 = 187,  对应二进制为 ‭10111011‬，所以当前lb(n)长度为8bit。

第三步，计算n的欧拉函数φ(n)。
	根据公式： φ(n) = (p-1)(q-1) 爱丽丝算出φ(n)等于16×10=160。

第四步，随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n) 互质。
	爱丽丝就在1到3120之间，随机选择了e=7。（实际应用中,在n为大数的情况下，常常选择65537。）   

第五步，计算e对于φ(n)的模逆元d。
	ed ≡ 1 (mod φ(n)) 这个式子等价于 ed - 1 = kφ(n) 实质上就是对下面这个二元一次方程求解。
	ed + φ(n)k = 1 已知 e=7, φ(n)=160， 17d + 3120k = 1 这个方程可以用"扩展欧几里得算法"求解，此处省略具体过程。
	总之，爱丽丝算出一组整数解为 (d,k)=(2753,-15)，即 d=23。
	
第六步,将n和e封装成公钥，n和d封装成私钥。
	在爱丽丝的例子中，n=187，e=7，d=23，所以PU={7,187} PR={23,187}。

下面进行加密解密运算：在上面前提下，假设M = 88

加密运算：
$$\begin{gathered} 即计算C=88^{7}mod187 \\ 88^{7}mod187=[(88^{4}mod187)\ast (88^{2}mod187)\ast (88^{1}mod187)]mod187 \\ 88^{1}mod187=88 \\ 88^{2}mod187=77 \\ 88^{4}mod187=132 \\ 88^{7}mod187=(88\ast 77\ast 132)mod187=11 \end{gathered}$$
解密运算：
$$\begin{gathered} 即，计算M=11^{23}mod187 \\ M=11^{23}mod187=[(11^{1}mod187)\ast (11^{2}mod187)\ast (11^{4}mod187)\ast \\ (11^{8}mod187)\ast (11^{8}mod187)]mod187 \\ 11^{1}mod187=11 \\ 11^{2}mod187=121 \\ 11^{4}mod187=55 \\ 11^{8}mod187=33 \\ 11^{23}mod187=(11\ast 121\ast 55\ast 33\ast 33)mod187=88 \end{gathered}$$

Ⅴ.增加RSA抵抗能力的一些约束

约束6：p和q的长度应仅仅相差几位。
约束7：（p-1）和（q-1）都应该有一个较大的质因子。
约束8：gcd(（p-1）,（q-1）)应该较小。

Ⅵ.RSA加密算法证明

由余运算可得：给出两条运算定理

1. [(a mod n) x (b mod n)]mod n = (a x b)mod n;  

显然有：
$$\begin{gathered} 若xmodn=1(modn),则x^{2}modn=[(xmodn)\ast (xmodn)]modn=1(modn) \\ 则有x^{y}modn=1成立 \\ 同样若xmodn=0,则对任意整数y，有x^{y}modn=0 \end{gathered}$$

2. [(a mod n) - (b mod n)]mod n = (a - b)mod n;

下面证明RSA算法：
$$即证明M^{k\Phi (n)+1}modn=M^{k(p-1)(q-1)+1}modn=M$$
step1：
$$\begin{gathered} 首先证明M^{k(p-1)(q-1)+1}modp=Mmodp; \\ 情况1：若M和p不是互质的，即p整出M，此时Mmodp=0，显然有上式成立。 \\ 情况2：若M和p互质，由欧拉定理M^{k\Phi (n)}modp=1 \\ {M}^{k(p-1)(q-1)+1}modp=[(M)M^{k(p-1)(q-1)}]modp \\ =[(M)(M^{p-1}{)}^{k(q-1)}]modp \\ =[(M)(M^{\Phi (p)}{)}^{k(q-1)}]modp \\ =(Mmodp)\ast 1[M^{\Phi (p)}modp{]}^{k(q-1)} \\ =(Mmodp)\ast 1^{k(q-1)} \\ =Mmodp \end{gathered}$$
step2:
$$\begin{gathered} 故现在有[M^{k(p-1)(q-1)+1}-M]modp=[M^{k(p-1)(q-1)+1}modp]-[Mmodp]=0 \\ 因此p整除[M^{k(p-1)(q-1)+1}-M] \\ 同理q整出[M^{k(p-1)(q-1)+1}-M] \\ 由于p，q为不同的质数，必定存在一个整数r满足[M^{k(p-1)(q-1)+1}-M]=(pq)r=nr \\ 即，n整除[M^{k(p-1)(q-1)+1}-M]，且结果为r \\ 即，[M^{k(p-1)(q-1)+1}-M]modn=0 \\ 即M^{k(p-1)(q-1)+1}modn=Mmodn=M^{k\Phi (n)+1}modn \end{gathered}$$

Ⅶ.RSA与Montgomery幂模

经过上述过程的思考，有以下结论：

1.RSA算法所使用的密钥可以提前预计算好PU，PR。
2.Montgomery幂模主要应用于加密和解密过程中。
	即已知明文M和公钥PU，计算密文C，
	已知密文C和私钥PR，计算明文M。
3.(n bit)Montgomery运算与(n bit)RSA中 n 的含义是相同的。

二.RSA算法的一致性验证

Ⅰ.验证公钥私钥算法

思路：将第三方文件，以及第三方文件使用的p,q,e通过“rsatool.py”进行运算获得私钥，“rsatool.py”的运算私钥方案等同于上述计算私钥的方案。将该私钥解密第三方加密后的文件，可以正确解密，完成验证。

验证博客

下面为rsatool里面的私钥计算部分：
class RSA:
    def __init__(self, p=None, q=None, n=None, d=None, e=DEFAULT_EXP):
        """
        Initialize RSA instance using primes (p, q)
        or modulus and private exponent (n, d)
        """

        self.e = e

        if p and q:
            assert gmpy.is_prime(p), 'p is not prime'
            assert gmpy.is_prime(q), 'q is not prime'

            self.p = p
            self.q = q
        elif n and d:   
            self.p, self.q = factor_modulus(n, d, e)
        else:
            raise ArgumentError('Either (p, q) or (n, d) must be provided')

        self._calc_values()

    def _calc_values(self):
        self.n = self.p * self.q

        if self.p != self.q:
            phi = (self.p - 1) * (self.q - 1)
        else:
            phi = (self.p ** 2) - self.p

        self.d = gmpy.invert(self.e, phi)

        # CRT-RSA precomputation
        self.dP = self.d % (self.p - 1)
        self.dQ = self.d % (self.q - 1)
        self.qInv = gmpy.invert(self.q, self.p)