【密码学：RSA加密算法详解】

RSA简介

  1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。从那时直到现在，RSA算法一直是最广为使用的"非对称加密算法"。毫不夸张地说，只要有计算机网络的地方，就有RSA算法。

                                                                                   -- 摘自网络

数学背景

  此部分旨在补充本文的完整性。如果说你已经了解，或是不想了解此部分内容。那么可以直接跳过此部分的阅读。

  虽说只是补充说明（只能是补充的原因是因为博主的数学也是比较差的-_-!!!），但是此部分的内容却是相当重要的。博主还是希望可以重新阅读一下此部分。

1.互质

  从小学开始，我们就了解了什么是质数。互质是针对多个数字而言的，如果两个正整数，除了1以外，没有其他公因子，那么就称这两个数是互质关系（注意，这里并没有说这两个数一定是质数或有一个为质数。比如15跟4就是互质关系）。以下有一些关于质数与互质的性质：

• 质数只能被1和它自身整除
• 任意两个质数都是互质关系
• 如果两个数之中，较大的那个数是质数，则两者构成互质关系
  
• 如果两个数之中，较小的那个数是质数，且较大数不为较小数的整数倍，则两者构成互质关系
  
• 1和任意一个自然数是都是互质关系
  
• p是大于1的整数，则p和p-1构成互质关系
  
• p是大于1的奇数，则p和p-2构成互质关系
  

2.欧拉函数

  欧拉函数是求小于x并且和x互质的数的个数。其通式为：φ(x) = x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn)。

  其中p1, p2……pn为x的所有质因数，x是不为0的整数。看到这里是不是有一些头疼，太理论的东西的确不够具象。我们且不去理会后面公式计算与论证，因为已经超出本文的范围了。就前一句来说说吧，欧拉函数是求小于x并且和x互质的数的个数。这里我可以列举一个例子：

  令x = 16，那么x的所有质因数为：φ(16) = 16 * (1 - 1/2) = 8

  我们也可以枚举出所有比16小，且与16互质的数：1, 3, 5, 7, 9, 11, 13, 15

  现在也给出部分欧拉函数的性质：

• 若n是素数p的k次幂，，因为除了p的倍数外，其他数都跟n互质
  
• 欧拉函数是积性函数——若m,n互质，
  
• 当n为奇数时，
  
• p是素数，，φ(p)称为p的欧拉值
  

  欧拉函数更多参考请见这里的链接。

3.模反元素

定义：如果两个正整数a和n互质，那么一定可以找到整数b，使得 ab-1 被n整除，或者说ab被n除的余数是1。

关于模反元素的求解，使用的是朴素的解法。如果读者想要更进一步了解的话，请自行搜索其他解法（比如：辗转相除法、欧几里德算法）。

RSA原理

  在RSA原理之前，我想还是有必要了解一下非对称加密算法的加密跟解密过程。下面就是一幅非称加密算法的流程图。

  

  在此可以看到，非对称加密是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。对于非对称的加密和解密为什么可以使用不同的密钥来进行，这些都是数学上的问题了。不同的非对称加密算法也会应用到不同的数学知识。上面也对RSA中使用的数学问题做了一个小小的介绍。现在就来看看RSA算法是怎么来对数据进行加密的吧，如下是一幅RSA加密算法流程及加密过程图。

  

RSA应用

1. 实例模型

  就以上图中的Bob和Alice来举例吧。

  现在Alice通过密钥生成器生成了一对密钥（公钥-私钥）。只把公钥对外公开了。并说，你有什么要跟我说的，就用模幂运算和公钥加密后发给我吧。

  此时，Bob已经获得了Alice发布的公钥。使用模幂运算对明文进行了加密，就把加密后的密文发送给了Alice。

  Alice获得Bob发来的密文并没有使用公钥对密文进行解密，并获得了明文。因为解密过程需要使用的密钥是私钥。

2. RSA算法实现

  下面的代码只是根据RSA算法的定义，使用Java开发语言实现。且这里只是展示了一些关键步骤，完整过程可以参见下面的源码下载文档。

[java] view plain copy

 print?

1. public class RSA {      
2.     /** 
3.      * 获得(公/私)密钥 
4.      */  
5.     public final Map<String, RSAKey> getCipherKeys() {  
6.         ...  
7.         int[] primes = getRandomPrimes(2);  
8.         int modulus = modulus(primes[0], primes[1]);  
9.         int euler = euler(primes[0], primes[1]);  
10.         int e = cipherExponent(euler);  
11.         int inverse = inverse(euler, e);  
12.         publicKey.setExponent(e);  
13.         publicKey.setModulus(modulus);  
14.         privateKey.setExponent(inverse);  
15.         privateKey.setModulus(modulus);  
16.         ...  
17.     }  
18.       
19.     /** 
20.      * 加密 
21.      */  
22.     public int encode(int plaintext, RSAPublicKey key) {  
23.         return modularPower2(plaintext, key.getExponent(), key.getModulus());  
24.     }  
25.       
26.     /** 
27.      * 解密 
28.      */  
29.     public int decode(int chipertext, RSAPrivateKey key) {  
30.         return modularPower2(chipertext, key.getExponent(), key.getModulus());  
31.     }  
32.   
33.     // 随机生成count个素数  
34.     private final int[] getRandomPrimes(int count) {  
35.         ...  
36.         try {  
37.             primeLabels = FileReadUtils.readLines("./data/prime_table");  
38.         } catch (IOException e) {  
39.             e.printStackTrace();  
40.         }  
41.         for (int i = 0; i < primes.length; i++) {  
42.             primes[i] = Integer.parseInt(primeLabels.get(indexs.get(i)));  
43.         }  
44.   
45.         return primes;  
46.     }  
47.   
48.     // 计算公共模数  
49.     private final int modulus(int p, int q) {  
50.         return p * q;  
51.     }  
52.   
53.     // 计算欧拉数  
54.     private final int euler(int p, int q) {  
55.         return (p - 1) * (q - 1);  
56.     }  
57.   
58.     // 计算加密指数  
59.     private final int cipherExponent(int euler) {  
60.         Random random = new Random();  
61.   
62.         int e = 7;  
63.         do {  
64.             e = random.nextInt(euler - 1);  
65.         } while (!isCoprime(e, euler) || e <= 1);  
66.   
67.         return e;  
68.     }  
69.   
70.     // 判断两个数互素  
71.     private final boolean isCoprime(int number1, int number2) {  
72.   
73.         int sqrt = (int) Math.sqrt(Math.max(number1, number2));  
74.         for (int i = 2; i <= sqrt; i++) {  
75.             if (number1 % i == 0 && number2 % 2 == 0) {  
76.                 return false;  
77.             }  
78.         }  
79.   
80.         return true;  
81.     }  
82.   
83.     // 计算“模的逆元”  
84.     // (d * e) ≡ 1 mod euler  
85.     private final int inverse(int euler, int e) {  
86.         ...  
87.         while (flag) {  
88.             q = m[2] / n[2];  
89.             for (int i = 0; i < 3; i++) {  
90.                 temp[i] = m[i] - q * n[i];  
91.                 m[i] = n[i];  
92.                 n[i] = temp[i];  
93.             }  
94.             if (n[2] == 1) {  
95.                 if (n[1] < 0) {  
96.                     n[1] = n[1] + euler;  
97.                 }  
98.                 return n[1];  
99.             }  
100.             if (n[2] == 0) {  
101.                 flag = false;  
102.             }  
103.         }  
104.         return 0;  
105.     }  
106.       
107.     // 模幂运算  
108.     private final int modularPower(int base, int e, int modular) {  
109.         int result = 1;  
110.         do {  
111.             if (isOdd(e)) {  
112.                 result = (result * (base % modular)) % modular;  
113.                 e -= 1;  
114.             } else {  
115.                 base = (base * base) % modular;  
116.                 e /= 2;  
117.             }  
118.         } while (e > 0);  
119.           
120.         result %= modular;  
121.           
122.         return result;  
123.     }  
124. }  

RSA算法判别

RSA算法优点

1. 不需要进行密钥传递，提高了安全性
2. 可以进行数字签名认证

RSA算法缺点

1. 加密解密效率不高，一般只适用于处理小量数据（如：密钥）
2. 容易遭受小指数攻击

Ref

1. 《算法导论》
2. 《算法的乐趣》
3. 《深入浅出密码学》
4. RSA算法原理（一） -- 阮一峰
5. RSA算法原理（二） -- 阮一峰
6. 逆元详解 -- ACdreamers
   
7. JAVA实现扩展欧几里德算法求乘法逆元
   

源码下载

http://download.csdn.net/detail/u013761665/9439852