POJ 2447 破解RSA(经典公钥算法)

周五刚好在俞研的网络安全课上学了RSA，回来想实现以下，由于以前数论方面的积累还算比较深厚，很快就过了这一题，呵呵:-)
总结一下吧，这题可以说是数论部分的一个大综合题，因为它将算法导论上数论这部分的知识点全部包含了进来，包括gcd,扩展gcd,模线性方程，a^b mod c(还是比较难的那种，相关题目可以看一下FOZ上面的2道题),miller-rabin素数测试，pollard_rho质因数分解等等，把这题搞定了说明你对算法导论的数论部分已经可以做到熟练掌握了，相当于<算法导论>数论部分的期末测试，呵呵^_^。
下面简要的说一下这题的做法，首先简要介绍一下RSA算法加密解密的过程：
我们首先生成两个大的素数P,Q,乘起来得 N=P*Q .然后算出N的欧拉函数 Phi(N)=(P-1)*(Q-1) .(什么是欧拉函数？这个世界上有一种东西叫做百度...）,然后我们取一个范围在 [1,phi(N)]中且与phi(N)互质的正整数E .它就是所谓的公钥。得到公钥之后，我们再算出E关于 phi(N)的逆元D,即E*D mod phi(N)=1 .这个D就是私钥。在得到这些数据以后，P,Q被丢弃，E,N做为公钥被公开，D做为私钥被解密人私人保存。

好了，下面看一下如何用公钥和私钥对数据进行加密解密。
假设有一个明文M,那么它所对应的密文就是 C=M^E mod N.
如果我们现在得到一个密文C,那么它所对应的明文就是 M=C^D mod N
也就是说，任何人都可以用公钥对数据进行加密，但是只有拥有私钥的人才可以对数据进行解密。

那么RSA算法为什么不易被破解呢？从解密的过程来看如果你能够知道D那么你就能解密数据。而E,D是逆元关系，要求出D,需要知道phi(N)，由于N非常之大，普通的做法是从1开始枚举到N-1，计算和N互质的元素个数。可是N可以是几百位到上千位的数字，普通的计算机只能在1s内算到10^8量级，显然是不可能破解的。唯一有可能的方法基于大素数分解，如果你能将N分解成P*Q的乘积。那么就可以直接利用公式phi(N)=(P-1)*(Q-1)绕开暴力求解欧拉函数的过程，从而实现RSA的破解。

这道题就是模拟这个破解过程，下面来说说具体的做法：
1.首先用miller-rabin,pollard_rho做大整数的质因数分解，得到两个素数P,Q，pollard_rho的复杂度在N^0.25次方，那么一个64位的整数 要计算的次数为 2^64^0.25=2^16 =65536次，可以瞬间出解。
2.求出phi(N)=(P-1)*(Q-1)
3.然后用ext_gcd求出E关于phi(N)的逆元。
4.用得到的私钥对数据C进行解密即可。

PS:对这题而言，仅仅完成上述步骤还是不够的。因为N达到2^62次方，即使是使用无符号long long ,也很容易因为出乘法操作而溢出。这也是网上说要避免使用扩展欧几里德的原因。其实实现的时候，我们可以自己写一个特殊的乘法（内部用加法实现），由于使用的无符号的long long ，第64位刚好可以用来保存两个数加过之后的进位位，再模除又可以保证其在2^62范围内，即可避免溢出。

题目来源：http://poj.org/problem?id=2447

题目大意：

破解RSA。RSA是什么？这个世界有一种东西叫google，他的妻子是百度。。。

题目分析：

这是一道数论的综合题！经典！

用很多数论知识。其实如果有板子的话就是几句话的事。。。具体解法如下：

1.首先用miller-rabin,pollard_rho做大整数的质因数分解，得到两个素数P,Q，pollard_rho的复杂度在N^0.25次方，那么一个64位的整数 要计算的次数为 2^64^0.25=2^16 =65536次，可以瞬间出解。
2.求出phi(N)=(P-1)*(Q-1)
3.然后用ext_gcd求出E关于phi(N)的逆元。
4.用得到的私钥对数据C进行解密即可。

代码如下：

 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>
 #include<time.h>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 //x 就是（a,b）的逆元
 long long extgcd(long long a, long long b, long long &x, long long &y)
 {
     long long d, t;
     if (b == 0)
     {
         x = 1;
         y = 0;
         return a;
     }
     d = extgcd(b, a % b, x, y);
     t = x - a / b * y;
     x = y;
     y = t;
     return d;
 }

 //****************************************************************
 // Miller_Rabin 算法进行素数测试
 //速度快，而且可以判断 <2^63的数
 //****************************************************************
 const int S=20;//随机算法判定次数，S越大，判错概率越小


 //计算 (a*b)%c.   a,b都是long long的数，直接相乘可能溢出的
 //  a,b,c <2^63
 //计算A*B的时候，也可以将B化成2^n相加的式子。
 //于是，我们可以将a*b mod c转换成[a*(2^b0+2^b1+……2^bn)] mod c=[a*2^b0+a*2^b1+……a*2^bn] mod c。
 //利用公式(a+b)mod c=[(a mod c)+(b mod c)]mod c这个公式进行运算。
 long long mult_mod(long long a,long long b,long long mod)
 {
     long long ans = 0;
     while (b)
     {
         if (b & 1)
         {
             ans += a;
             if (ans >= mod) ans -= mod;
         }
         a <<= 1;
         if (a >= mod) a -= mod;
         b >>= 1;
     }
     return ans;
 }



 //计算  x^n %c,类似于计算a^b
 long long pow_mod(long long x,long long n,long long mod)//x^n%c
 {
     if(n==1)return x%mod;
     x%=mod;
     long long tmp=x;
     long long ret=1;
     while(n)
     {
         if(n&1) ret=mult_mod(ret,tmp,mod);
         tmp=mult_mod(tmp,tmp,mod);
         n>>=1;
     }
     return ret;
 }





 //以a为基,n-1=x*2^t      a^(n-1)=1(mod n)  验证n是不是合数
 //一定是合数返回true,不一定返回false
 bool check(long long a,long long n,long long x,long long t)
 {
     long long ret=pow_mod(a,x,n);
     long long last=ret;
     for(int i=1; i<=t; i++)
     {
         ret=mult_mod(ret,ret,n);
         if(ret==1&&last!=1&&last!=n-1) return true;//合数
         last=ret;
     }
     if(ret!=1) return true;
     return false;
 }

 // Miller_Rabin()算法素数判定
 //是素数返回true.(可能是伪素数，但概率极小)
 //合数返回false;

 bool Miller_Rabin(long long n)
 {
     if(n<2)return false;
     if(n==2)return true;
     if((n&1)==0) return false;//偶数
     long long x=n-1;
     long long t=0;
     while((x&1)==0)
     {
         x>>=1;
         t++;
     }
     for(int i=0; i<S; i++)
     {
         long long a=rand()%(n-1)+1;//rand()需要stdlib.h头文件
         if(check(a,n,x,t))
             return false;//合数
     }
     return true;
 }


 //************************************************
 //pollard_rho 算法进行质因数分解
 //************************************************
 long long factor[3];//质因数分解结果（刚返回时是无序的）
 int tol;//质因数的个数。数组小标从0开始

 long long gcd(long long a,long long b)
 {
     if(a==0)return 1;//???????
     if(a<0) return gcd(-a,b);
     while(b)
     {
         long long t=a%b;
         a=b;
         b=t;
     }
     return a;
 }

 long long Pollard_rho(long long x,long long c)
 {
     long long i=1,k=2;
     long long x0=rand()%x;
     long long y=x0;
     while(1)
     {
         i++;
         x0=(mult_mod(x0,x0,x)+c)%x;
         long long d=gcd(y-x0,x);
         if(d!=1&&d!=x) return d;
         if(y==x0) return x;
         if(i==k)
         {
             y=x0;
             k+=k;
         }
     }
 }
 //对n进行素因子分解
 void findfac(long long n)
 {
     if(Miller_Rabin(n))//素数
     {
         factor[tol++]=n;
         return;
     }
     long long p=n;
     while(p>=n)p=Pollard_rho(p,rand()%(n-1)+1);
     findfac(p);
     findfac(n/p);
 }

 int main()
 {
     //srand(time(NULL));//需要time.h头文件//POJ上G++不能加这句话
     long long c,e,n;
     while(scanf("%I64d %I64d %I64d",&c,&e,&n) != EOF)
     {
         tol=0;
         findfac(n);
         //
         long long fai = (factor[0] - 1) * (factor[1] - 1);
         long long D,k;
         extgcd(e,fai,D,k);
         D = (D%fai + fai) % fai;
         //
         long long M = pow_mod(c,D,n);
         //printf("c = %I64d d = %I64d n = %I64d\n",c,D,n);
         printf("%I64d\n",M);
     }
     return 0;
 }