对称加密与非对称加密，以及RSA的原理

一 ， 概述

在现代密码学诞生以前，就已经有很多的加密方法了。例如，最古老的斯巴达加密棒，广泛应用于公元前7世纪的古希腊。16世纪意大利数学家卡尔达诺发明的栅格密码，基于单表代换的凯撒密码、猪圈密码，基于多表代换的维吉尼亚密码，二战中德军广泛使用的恩格玛加密机….但最终都找到了有效的破解算法。

现代密码学的诞生标志是1977年1月由美国国家标准局公布的数据加密标准(Data Encryption Standard，DES)。 
在经过20多年之后，为适应现代的安全要求，2000年美国国家和标准技术协会筛选和评测出了被称为AES(Advanced Encryption Standard)的加密算法作为新的加密标准。目前，AES已被广泛使用，且未发现致命缺陷。到目前为止，AES是一个安全的加密算法。

然而，在加密算法之外，面临一个问题，那就是：秘钥的分发。就是说，解密方如何获得加密方的秘钥呢？ 从而出现了：对称加密和非对称加密。

二，对称加密和非对称加密

1. 对称加密

对称加密指的就是加密和解密使用同一个秘钥，所以叫做对称加密。对称加密只有一个秘钥，作为私钥。 
常见的对称加密算法：DES，AES，3EDS等等。

2. 非对称加密

非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。私钥加密的信息，只有公钥才能解密。 
常见的非对称加密算法：RSA，ECC

3. 区别

对称加密算法相比非对称加密算法来说，加解密的效率要高得多。但是缺陷在于对于秘钥的管理上，以及在非安全信道中通讯时，密钥交换的安全性不能保障。所以在实际的网络环境中，会将两者混合使用.

例如针对C/S模型， 
1. 服务端计算出一对秘钥pub/pri。将私钥保密，将公钥公开。 
2. 客户端请求服务端时，拿到服务端的公钥pub。 
3. 客户端通过AES计算出一个对称加密的秘钥X。 然后使用pub将X进行加密。 
4. 客户端将加密后的密文发送给服务端。服务端通过pri解密获得X。 
5. 然后两边的通讯内容就通过对称密钥X以对称加密算法来加解密。

三，RSA原理

我们先来看这样一些基础知识，并且以下我们讨论全都是整数：

整数运算

在整数运算中 我们定义一个整数 x ，那么他的负数为- x ，并且有 x +(- x )=0；

他的倒数为 x−1  , 并且有 x×x−1  =1;

同余运算

有整数a，b，正整数m。 假如a除以m余b。我们称为a模m同余b，模数为m。并且记为 a≡b(modm)  ,例如10除以3余1

我们称10模3同余1，记为 10≡1(mod3)  。

我们分别讨论模数为合数和质数情况下，基于同余运算的负数和倒数。

1. 当模数为合数 n 时

简单起见，我们讨论当 n 为10的情况,10是两个质数乘积

当模数为10的时候，参与运算的都是小于10的数。因为大于10的数除模取余之后都会小于10，所以只需要考虑小于模的数。

那么在同余运算中

一个小于10的数a，他的负数是什么？ 也就是说使得 a+(−a)≡0(mod10)  ; 那就是 n−a ;

有 a+(n−a)≡a+(−a)+n≡n≡(modn)  。 当 n=10 的时候 ，有如下表

a	0	1	2	3	4	5	6	7	8	9
−a	0	9	8	7	6	5	4	3	2	1

那么， a 的倒数 a−1 是什么呢？ 它要使得 a×a−1 在模数为n的情况下等于1，即 a×a−1≡1(modn)

当 n=10 的时候我们会发现，对于有的数我们可以找到它的倒数，有的数却找不到

例如当 a=3 ，我们可以找到7，使得 3×7≡21≡1(mod10)  ;

而当a=4的时候，我们有 4×0=0 ， 4×1=4 ， 4×2=8 ， 4×3=12 ， 4×4=16 ， 4×5=20 ， 4×6=24 ， 4×7=28 ， 4×8=32 ， 4×9=36 ，在模10的情况下，都不会等于1。

我们对于所有小于10的 a 都找他的倒数 a−1 ，有下表

a	1	2	3	4	5	6	7	8	9
a−1	9	不存在	7	不存在	不存在	不存在	3	不存在	1

有什么规律呢？

数学界已证明：当 a<n 时，只有当 a 和 n 互质才能找到 a−1 。 同时还有以下结论，当 n=p×q  ,且 p 和 q 都为质数时，所有小于 n 的数中，能找到倒数的数的个数为 (p−1)×(q−1) 个。如果n有更多的质因子，那么计算会更复杂点。

我们把所有小于n，并且能和n互质的数的总个数记为一个函数 φ(n)  ，这个函数叫做欧拉函数。例

即当 n=p×q  ,且 p 和 q 都为质数时，有 φ(n)=(p−1)×(q−1) , 那么就有 φ(10)=(2−1)×(5−1)=4

同时这些数还有以下两个有趣的情况

1. 这些数之间进行互乘的同余运算，结果还是这些数。

   例如对于1： 1×1≡1(mod10) , 1×3≡3(mod10) , 1×7≡7(mod10) , 1×9≡9(mod10)

   对于3： 3×1≡3(mod10) , 3×3≡9(mod10) , 3×7≡1(mod10) , 3×9≡7(mod10)

   对于7： 7×1≡7(mod10) , 7×3≡1(mod10) , 7×7≡9(mod10) , 7×9≡3(mod10)

   对于9： 9×1≡9(mod10) , 9×3≡7(mod10) , 9×7≡3(mod10) , 9×9≡1(mod10)

   如果一些数在互相运算之后，得到的结果还是这些数中，我们称这些数在这个运算条件下具有封闭性。

2. 对这些数进行求幂运算，并且模10，结果如下表

a	1	3	7	9
a0	1	1	1	1
a1	1	3	7	9
a2	1×1=1	3×3=9	7×7=9	9×9=1
a3	1×1×1=1	3×3×3=7	7×7×7=3	9×9×9=9
a4	1×1×1×1=1	3×3×3×3=1	7×7×7×7=1	1×1×1×1=1

其中，

• 我们规定 a0=1

• 所有 aφ(10) 的结果都为1,即有 aφ(n)=1

• 对于3和7来说，他们的 a0 、 a1 、 a2 、 a3 刚好把1,3,7,9各得到了一遍。到 a4 时刚好又回到了1，如果大于4之后，又会开始循环

  在模n的情况下一定能找到一个数 g ,使得 g0 、 g1 、 g2 、…… gφ(n)−1 刚好把所有与n互质并且小于n的数各得到一遍。我们把满足这种条件的数称为 生成元。

2. 当模数为质数 p 的时候

当模 p 为质数的时候，我们假设 p=7 时。

同样求小于 p 的数 a 的负数 −a 有如下表

a	0	1	2	3	4	5	6
−a	0	6	5	4	3	2	1

而求 a 的倒数时，因为p是质数，所有小于 p 的数都和它互质。所以，所有小于 p 的数 a 都能找到它的倒数 −a 。它的欧拉函数 φ(n)=p−1 。

如下表

a	1	2	3	4	5	6
a−1	1	4	5	2	3	6

它同样有模数为合数 n 时的性质

1. 这些数在同余运算规则下进行乘法运算，同样具有封闭性
2. 任意的 a 求幂依然满足 aφ(n)=1 的规则，且同样有生成元

3. 离散对数问题

前面我们得到了有这么一个结论:

在模n的情况下一定能找到一个数 g ,使得 g0 ,  g1  , g2 、…… gφ(n)−1 刚好把所有与n互质并且小于n的数各得到一遍。我们把满足这种条件的数称为 生成元。

那么，在模 n 的条件下，给定它的生成元 g ,以及一个小于 n 的正整数 a 。通过一个叫做同余幂的算法能够快速的算出 ga 的值,我们把算得的结果记为 b 。 即我们在模 n 的条件下，能够快速的算出 b=ga 的值。

由于生成元的特性，我们知道，在模 n 的条件下，给定生成元 g ，以及 b 的值，一定存在一个小于 n 的正整数 a ，使得 b=ga 。那么如何求a的值？

我们发现，这个问题没有任何规律。例如，当n=11，g=2时，有如下表

g	2	2	2	2	2	2	2	2	2	2	2
b=ga	1	2	3	4	5	6	7	8	9	10	1
a	0	1	8	2	4	9	7	3	6	5	10

在实数计算中，我们知道当 b=ga 时， a=logbg 。然而这个计算在模 n 的条件下非常困难。这样一个问题被称为离散对数问题。在目前的技术条件下，这是一个极为困难的计算。当这个 n 值达到十进制两三百位时，即便是有大型计算机的情况下，所要花费的时间依然是个天文数字。

4.RSA原理

当 n=p×q ， p 与 q 是两个大质数。你只知道n，想要计算 p 和 q ，这也是一个世界性的极为困难的数学难题。RSA的基础就是基于的n的两个质数分解难题。

具体过程如下：

• service 端选择两个大质数 p 和 q ，求得 n=p×q 。接下来，service选择一个与 φ(n) 互质的数e，并计算 s=e−1(modφ(n)) 。即在模  φ(n) 的条件下，计算出当 e−1 的值。其中 φ(n)=(p−1)×(q−1)

  我们知道， e 与 φ(n) 互质，所以一定存在 e−1 , 这一步，service 就算出了公钥和私钥，其中，公钥为( n ， e ),私钥为 s

• 接下来，client可以在非安全信道请求service获得公钥。假定client需要发送的内容为m，计算 D=me(modn) ,然后把D发送给service

• service收到D之后，计算 Ds=me(e−1)=me×e−1=m(modn) .

其中，在不安全信道中传输的是 n 和 e 。然而， p 和 q 只有service才知道，即便别人获得了n，基于质数分解难题，他无法算出 p 和 q ，也就无法算出私钥来揭秘被加密的消息。