RSA密码
RSA密码是1978年美国麻省理工学院三位密码学者R.L.Rivest、A.Shamir和L.Adleman提出的一种基于大合数因子分解困难性的公开密钥密码。由于RSA密码既可用于加密，又可用于数字签名，通俗易懂，因此RSA密码已成为目前应用最广泛的公开密钥密码。
RSA加解密算法
1.随机地选择两个大素数p和q，而且保密；
2.计算n=pq，将n公开；
3.计算φ(n)=(p-1)(q-1)，对φ(n)保密；
4.随机地选取一个正整数e，1<e<φ(n)且(e,φ(n))=1，将e公开；
5.根据ed=1(mod φ(n))，求出d，并对d保密；
6.加密运算：C=Me(mod n)；
7.解密运算：M=Cd(mod n)。
注意：在加密运算和解密运算中，M和C的值都必须小于n，也就是说，如果明文（或密文）太大，必须进行分组加密（或解密）。
RSA算法细节
实现RSA算法，主要需要实现以下几个部分：
1.对大数的素数判定；
2.模逆运算；
3.模指运算。
对大数的素数判定
一个较小的数是否为素数，可以用试除法来判定，而如果这个数很大的话，试除法的效率就会变得很低下。也就是说，试除法不适用于对大数进行素数判定，所以对大数的素数判定一般采用素数的概率性检验算法，其中又以Miller算法最为常见。
使用素数的概率性检验算法判定一个数是否为素数，虽然相比试除法而言效率非常之高，但是对该数的判定结果并不准确。该算法通过循环使用Miller算法来提高判定结果的正确性。
素数的概率性检验算法的流程：对于奇整数n，在2~n-2之间随机地选取k个互不相同的整数，循环使用Miller算法来检验n是否为素数。若结果为true，则认为n可能为素数，否则肯定n为合数。
一轮Miller算法判定大整数n不是素数的概率≤4-1，所以，素数的概率性检验算法判定大整数n不是素数的概率≤4-k（k为Miller算法的循环次数）。
Miller算法
若n为奇素数，则对∀a∈[2,n-2]，由于a与n互素，根据欧拉定理可得aφ(n)=an-1=1(mod n)。
若n是奇素数，则不存在1(mod n)的非平凡平方根，即对于x2=1(mod n)的解有且仅有±1。
若n是奇素数，则n-1是偶数。不妨令n=2tm+1（t≥1），则m为n-1的最大奇因子。根据上述两点，不难得出，对∀a∈[2,n-2]，∃τ∈[1,t]使得
Miller算法正是通过上述的逆否命题而设计出来的，其原理是：对∀a∈[2,n-2]，n是一个合数的充要条件是对∀τ∈[1,t]使得
Miller算法的设计思路：令b=am(mod n)，如果b=±1(mod n)则n可能是一个素数；否则，b=b2(mod n)，并判断是否满足b=-1(mod n)（满足则n可能是一个素数），由此循环t-1次。如果都满足b≠-1(mod n)，则n一定是一个合数。
e.m.判定221是否为素数
n=221=22*55+1
所以m=55，t=2
取a=174，则
17455(mod 221)=47
174110(mod 221)=220
所以n要么是一个素数，要么a=174是一个“强伪证”。
再取a=137，则
13755(mod 221)=188
137110(mod 221)=205
所以n是一个合数。
模逆运算
模逆运算就是求满足方程ax=1(mod m)的解x，而ab=1(mod m)有解的前提条件是(a,m)=1，即a和m互素。
对方程ax=1(mod m)的求解可以转换为求解ax+my=1=(a,m)，即转换为扩展欧几里德算法。
e.m.求243-1(mod 325)
325=1*325+0*243
243=0*325+1*243
82=325-243=1*325+(-1)*243
79=243-2*82=(-2)*325+3*243
3=82-79=3*325+(-4)*243
1=79-26*3=(-80)*325+107*243
所以
243-1(mod 325)=107
模指运算
模指运算就是对an(mod m)的计算。当指数n的值较大时，如果先求出bn再去模m的话，效率会很低下。所以，对于指数n较大的情况一般采用反复平方乘算法。
反复平方乘算法
所以，反复平方乘算法的原理是将指数n转化为2的幂之和的形式，即n=2kek+2k-1ek-1+...+2e1+e0，然后根据l1=a2(mod m)，l2=a4(mod m)=l12(mod m)，...，
最后根据an(mod m)=e0a·e1l1·...·eklk(mod m)求解。
e.m.求2335(mod 101)
35=32+2+1
231(mod 101)=23
232(mod 101)=24
234(mod 101)=242(mod 101)=71
238(mod 101)=712(mod 101)=92
2316(mod 101)=922(mod 101)=81
2332(mod 101)=812(mod 101)=97
所以
2335(mod 101)=97×24×23(mod 101)=14
RSA密码的安全性
密码分析者攻击RSA密码的一种可能途径是截获密文C，通过M=Cd(mod n)求出M。其中，n是公开的，而d是保密的。因为e是公开的，所以可以通过ed=1(mod φ(n))求出d，而φ(n)是保密的。虽然n是公开的，但是φ(n)=(p-1)(q-1)=pq-p-q+1=n-p-q+1，其中p和q是保密的，也就是说欲求得φ(n)必须知道p和q，即必须将n进行因式分解。
小合数的因子分解是容易的，然而大合数的因子分解却是十分困难的。由此可以得出，破译RSA密码的困难性约为对n进行因子分解的困难性。
RSA密码的安全性除了与因子分解密切相关之外，还与其参数p、q、e、d的选取有密切关系。只要合理地选取参数，并正确使用，RSA密码就是安全的。这就是目前RSA密码仍然广泛使用的重要原因。
Java实现
RSA
1 p = BigInteger.probablePrime(new Random().nextInt(100) + 100, new Random()); 2 q = BigInteger.probablePrime(new Random().nextInt(100) + 100, new Random()); 3 n = p.multiply(q); 4 phi_n = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE)); 5 do { 6 e = new BigInteger(new Random().nextInt(phi_n.bitLength() - 1) + 1, new Random()); 7 } while (e.compareTo(phi_n) != -1 || e.gcd(phi_n).intValue() != 1); 8 d = e.modPow(new BigInteger("-1"), phi_n);
1 /** 2 * 加密 3 * <p> C=M^e(mod n) 4 * @param M 5 * @param n 6 * @param e 7 * @return 8 */ 9 public static BigInteger encrypt(BigInteger M, BigInteger n, BigInteger e) { 10 return M.modPow(e, n); 11 }
1 /** 2 * 解密 3 * <p> M=C^d(mod n) 4 * @param C 5 * @param n 6 * @param d 7 * @return 8 */ 9 public static BigInteger decrypt(BigInteger C, BigInteger n, BigInteger d) { 10 return C.modPow(d, n); 11 }
对大数的素数判定
1 /** 2 * 素数的概率性检验算法 3 * @param k 4 * @param n 5 * @return 6 */ 7 static boolean isPrime(int k, long n) { 8 List<Long> a = new ArrayList<Long>(); 9 int t = n - 2 > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) (n - 2); 10 do { 11 long l = (long) (new Random().nextInt(t - 2) + 2); 12 if (-1 == a.indexOf(l)) 13 a.add(l); 14 } while (a.size() < k); 15 for (int i = 0; i < k; i++) 16 if (! Miller(n, a.get(i))) 17 return false; 18 return true; 19 } 20 static boolean Miller(long n, long a) { 21 long m = n - 1; 22 int t = 0; 23 while (m % 2 == 0) { 24 m /= 2; 25 t++; 26 } 27 long b = modExp(a, m, n); 28 if (b == 1 || b == n - 1) 29 return true; 30 for (int j = 1; j < t; j++) { 31 b = b * b % n; 32 if (b == n - 1) 33 return true; 34 } 35 return false; 36 }
模逆运算
1 /** 2 * 模逆运算 3 * @param b 4 * @param m 5 * @return b^-1(mod m) 6 */ 7 static long modInv(long b, long m) { 8 if (b >= m) b %= m; 9 return exGcd(b, m)[1] < 0 ? exGcd(b, m)[1] + m : exGcd(b, m)[1]; 10 } 11 /** 12 * 扩展欧几里德算法 13 * <p>(a,b)=ax+by 14 * @param a 15 * @param b 16 * @return 返回一个long数组result，result[0]=x，result[1]=y，result[2]=(a,b) 17 */ 18 static long[] exGcd(long a, long b) { 19 if (a < b) { 20 long temp = a; 21 a = b; 22 b = temp; 23 } 24 long[] result = new long[3]; 25 if (b == 0) { 26 result[0] = 1; 27 result[1] = 0; 28 result[2] = a; 29 return result; 30 } 31 long[] temp = exGcd(b, a % b); 32 result[0] = temp[1]; 33 result[1] = temp[0] - a / b * temp[1]; 34 result[2] = temp[2]; 35 return result; 36 }
模指运算
1 /** 2 * 模指运算 3 * @param b 4 * @param n 5 * @param m 6 * @return b^n(mod m) 7 */ 8 static long modExp(long b, long n, long m) { 9 long result = 1; 10 b = b % m; 11 do { 12 if ((n & 1) == 1) 13 result=result*b%m; 14 b = b * b % m; 15 n = n >> 1; 16 } while (n != 0); 17 return result; 18 }
测试
测试数据
p=e86c7f16fd24818ffc502409d33a83c2a2a07fdfe971eb52de97a3de092980279ea29e32f378f5e6b7ab1049bb9e8c5eae84dbf2847eb94ff14c1e84cf568415
q=d7d9d94071fcc67ede82084bbedeae1aaf765917b6877f3193bbaeb5f9f36007127c9aa98d436a80b3cce3fcd56d57c4103fb18f1819d5c238a49b0985fe7b49
e=10001
M=b503be7137293906649e0ae436e29819ea2d06abf31e10091a7383349de84c5b
测试结果
参考文献
张焕国，唐明.密码学引论（第三版）.武汉大学出版社，2015年