RSA简单加密解密

简介:
　　RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。
　　RSA的算法涉及三个参数，n、e1、e2。
　　其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。
　　e1和e2是一对相关的值，e1可以任意取，但要求e1与(p-1)*(q-1)互质；再选择e2，要求(e2*e1)mod((p-1)*(q-1))=1。
　　(n,e1)为公钥对,(n,e2)是密钥对。
　　RSA加解密的算法完全相同,设A为明文，B为密文，则：A=B^e1 mod n；B=A^e2 mod n；
　　e1和e2可以互换使用，即：A=B^e2 mod n；B=A^e1 mod n; 

　　更详解的介绍请自行查阅相关资料....

算法(源码) :(注:本代码只适合小数,不适合大数)

#include <stdio.h>
#include <iostream>
#include <time.h>
#include <math.h>

// PRIMENUMBER指定构造素数数组的元素个数,200以内的素数有39个
#define PRIMENUMBER 39

usingnamespace std;

bool IsPrime(long PrimeArray[], constlong&nPositiveInteger);
void MakePrimeArray(long PrimeArray[], constlong&nPrimeNumber);
long PrimeABCalc(constlong&PrimeA, constlong&PrimeB);
void GetPrimeAuto( long PrimeArray[], long&PrimeA, long&PrimeB);
void GetPrimeHand( long PrimeArray[], long&PrimeA, long&PrimeB);
long GCD(long KeyE, long fn);
long GetKeyE(long fn);
long GetKeyD(long KeyE, long fn);
long Encrypt( long KeyE, long n, long cleartext);
long Decipher( long KeyD, long n, long ciphertext);

// 主函数
long main(long argc, char* argv[])
{
long MyPrimeArray[PRIMENUMBER] = {0};
    MakePrimeArray(MyPrimeArray, PRIMENUMBER);
long PrimeA =0;
long PrimeB =0;
long n =0;
long PrimeAB =0;
long e =0;
long d =0;
long cleartext =0;
long ciphertext =0;
long nSelect =0;
    cout<<"素数产生方式(1~100):";
    cout<<"1 手动指定   "<<"2 自动随机\t";
    cout<<"选择:";
    cin>>nSelect;

if (1== nSelect)
        GetPrimeHand(MyPrimeArray, PrimeA, PrimeB);
elseif (2== nSelect)
        GetPrimeAuto(MyPrimeArray, PrimeA, PrimeB);
else
        cout<<"选择错误!"<<endl;

    cout<<"随机数 p: "<<PrimeA<<"\tq: "<<PrimeB<<endl;
    n = PrimeA * PrimeB;
    cout<<"素数的乘积n = pq: "<<n<<"\t";
    PrimeAB = PrimeABCalc(PrimeA, PrimeB);
    cout<<"值f(n) = (p-1)(q-1): "<<PrimeAB<<endl;
    e = GetKeyE(PrimeAB);
    cout<<"公钥e: "<<e<<"\t";
    d = GetKeyD(e, PrimeAB);
    cout<<"密钥d: "<<d<<endl;
    cout<<"输入一个正整数明文:";
    cin>>cleartext;
    ciphertext = Encrypt(e, n, cleartext);
    cout<<"加密后密文: "<<ciphertext<<endl;
    cleartext = Decipher(d, n, ciphertext);
    cout<<"解密后明文: "<<cleartext<<endl;
    cout<<"\n该RSA加密仅做参考,运算时可能会溢出."<<endl;
    system("Pause");
return0;
}

// 计算f(n)=(p-1)(q-1)
long PrimeABCalc(constlong&PrimeA, constlong&PrimeB)
{
return ((PrimeA -1) * (PrimeB -1));
}

// 手动输入素数
void GetPrimeHand( long PrimeArray[], long&PrimeA, long&PrimeB )
{
bool PrimeTrue =true;
// 输入第一个素数
do 
    {
if (PrimeTrue)
        {
            cout<<"请输入第一个素数:";
        } 
else
        {
            cout<<"该数不是素数,请重新输入第一个素数:";
        }
        cin>>PrimeA;
        PrimeTrue = IsPrime(PrimeArray, PrimeA);
    } while (!PrimeTrue);
    
    PrimeTrue =true;
// 输入第二个素数
do 
    {
if (PrimeTrue)
        {
            cout<<"请输入第二个素数:";
        } 
else
        {
            cout<<"该数不是素数,请重新输入第二个素数:";
        }
        cin>>PrimeB;
        PrimeTrue = IsPrime(PrimeArray, PrimeB);
    } while (!PrimeTrue);
while (PrimeA == PrimeB)
    {
do 
        {
            cout<<"请重新输入第二个素数:";
            cin>>PrimeB;
        } while (!IsPrime(PrimeArray, PrimeB));
    }
return;
}

// 自动产生1~100的随机数
void GetPrimeAuto( long PrimeArray[], long&PrimeA, long&PrimeB)
{
    srand((unsigned)time(NULL));
do 
    {
        PrimeA = rand()%100;
    } while (!IsPrime(PrimeArray, PrimeA));
    
do 
    {
        PrimeB = rand()%100;
    } while (!IsPrime(PrimeArray, PrimeB));
    
while (PrimeA == PrimeB)
    {
do 
        {
            PrimeB = rand()%200;
        } while (!IsPrime(PrimeArray, PrimeB));
    }
return;
}

// 判断是否是素数
bool IsPrime(long PrimeArray[], constlong&nPositiveInteger)
{
if(nPositiveInteger <2) 
returnfalse;
for(long i =0; PrimeArray[i]*PrimeArray[i] <= nPositiveInteger; ++i)
    {
if(nPositiveInteger%PrimeArray[i] ==0)
returnfalse;
    }
returntrue;
}

// 构造素数序列primes[]
void MakePrimeArray(long PrimeArray[], constlong&nPrimeNumber)
{
long i, cnt;
    PrimeArray[0] =2;
    PrimeArray[1] =3;
for(i =5, cnt =2; cnt < nPrimeNumber; i +=2)
    {
bool flag =true;
        flag = IsPrime(PrimeArray, i);
if(flag)
            PrimeArray[cnt++] = i;
    }
}

// 找一个与f(n)互质的数e,且1<e<f(n),此处随机产生
long GetKeyE( long fn )
{
long KeyE =0;
long SelectKeyE =0;
    
    cout<<"产生公钥e方式: "<<"1 随机   2 顺序"<<"\t";
while (1)
    {
        cout<<"选择: ";
        cin>>SelectKeyE;
if ( 1== SelectKeyE)
        {
            srand(NULL);
while(1)
            {
/*KeyE = rand()%fn;    // 如果随机可能会造成后面幂运算溢出*/
                KeyE++;
if ((KeyE>=2) && (GCD(KeyE, fn) ==1))
break;
if ( KeyE > fn)
break;
            }
break;
        }
elseif ( 2== SelectKeyE)
        {
long i =2;
while (1)
            {
if (GCD(i, fn) ==1)
                {
                    KeyE = i;
break;
                }
                i++;
            }
break;
        }
else
            cout<<"选择有误!"<<endl;
    }
return KeyE;    
}

// 求两数最大公约数,若为1则说明两数为互质数
long GCD( long KeyE, long fn )
{
long iDividend = fn;        // 被除数
long iDivisor = KeyE;    // 除数
long iResidual = iDividend%iDivisor;        //余数
// 辗转相除法
while (iResidual !=0)
    {
//将除数作为被除数
        iDividend=iDivisor;
//把余数作为除数
        iDivisor=iResidual;
//求新的余数
        iResidual=iDividend%iDivisor;
    }
return iDivisor;
}

// 计算d,使得d*e≡1 mod f(n).这个公式也可以表达为d ≡e-1 mod f(n)
long GetKeyD( long KeyE, long fn )
{
long iKeyD =0;
long Ji =0;
    srand(NULL);
do 
    {
/*iKeyD = rand();    // 如果随机可能会造成后面的幂运算溢出*/
        iKeyD++;
        Ji = iKeyD * KeyE;
    } while (!(GCD(Ji, fn) ==1&& ((Ji+fn)%fn ==1)));
return iKeyD;
}

// 加密
long Encrypt( long KeyE, long n, long cleartext )
{
long ciphertext =0;
    ciphertext = ((long)pow(cleartext, KeyE)%n);
return ciphertext;
}

// 解密
long Decipher( long KeyD, long n, long ciphertext )
{
//     long cleartext = 0;
//     cleartext = ((long)pow(ciphertext, KeyD)%n);
//     return cleartext;
// 下面是用的模幂运算的简便算法,我自己的代码会造成计算溢出.
long cleartext =1;
    KeyD = KeyD +1;
while( KeyD !=1)
    {
        cleartext = cleartext * ciphertext;
        cleartext = cleartext % n;
        KeyD--;
    }
return cleartext;
}

转载自：http://www.cnblogs.com/ziwuge/archive/2011/09/18/2180492.html