c语言实现rsa非对称加密算法,「RSA」非对称加密算法--C++实现

CRSAhead.h

classKeyProduce{

public:

KeyProduce(UINT model_N = 0,UINT Public_Key = 0,UINT Private_Key = 0);

~KeyProduce(){};

VOID GetTwainKey(UINT &model_N,UINT &Public_Key,UINT &Private_Key);

BOOL RSAKeyEncrypt(UINT divisor,UINT model_N,UINT Private_Key,UINT &result);

private:

VOID ProduceKeyAndModel();//产生密钥和模数

BOOL JudgePrime(UINT Prime);//判断参数是否为素数

VOID order(UINT &ParamOne, UINT &ParamTwo);//排序，大的在前

UINT gcd(UINT FN, UINT E);//求两个数的最大公约数

UINT ExtendEuclid(UINT m, UINT bin);//用扩展的欧几里德算法求乘法逆元

UINT ModularMultiplication (UINT divisor,INT Bit[],UINT model_N);//做快速模幂算法

UINT primeP, primeQ;

UINT ucoprimeFN;

UINT modelN;//模数

UINT PublicKey;//公钥

UINT PrivateKey;//私钥

};

CRSAhead.Cpp

#include"stdafx.h"

#include"CRSAhead.h"

KeyProduce::KeyProduce(UINT model_N,UINT Public_Key,UINT Private_Key)

{

modelN = model_N;

PublicKey = Public_Key;

PrivateKey = Private_Key;

}

VOID KeyProduce::GetTwainKey(UINT &model_N,UINT &Public_Key,UINT &Private_Key)

{

ProduceKeyAndModel();

model_N = modelN;

Public_Key = PublicKey;

Private_Key = PrivateKey;

}

//产生密钥和模数

VOID KeyProduce::ProduceKeyAndModel()

{

srand((int)time(0));

while (TRUE)

{

// 对于大素数需要用数组进行管理,所以这里现在在500以内,但这样就不能确保安全性了.

primeP = (rand()%500);

primeQ = (rand()%500);

if (primeP == primeQ) continue;

//if ((primeP * primeQ) >= UINT_MAX) continue;

if (JudgePrime(primeP) && JudgePrime(primeQ))

{

modelN = primeP * primeQ;

ucoprimeFN = (primeP - 1) * (primeQ - 1);

if (ucoprimeFN <= 2) continue;

break;

}

}

UINT div = ucoprimeFN - 2;

while (TRUE)

{

PublicKey = (rand() + 90) % div + 2;

if (gcd(ucoprimeFN,PublicKey) == 1)

break;

}

PrivateKey = (ExtendEuclid(ucoprimeFN,PublicKey) + ucoprimeFN) % ucoprimeFN;

}

//判断参数是否为素数

BOOL KeyProduce::JudgePrime(UINT Prime)

{

if (Prime <= 1) return FALSE;

else if (Prime == 2) return TRUE;

UINTlimit = (UINT)sqrt((double)Prime);

for (UINT i = 2; i<= limit; i++)

{

if (Prime % i == 0)

return FALSE;

}

return TRUE;

}

//排序，大的在前

VOID KeyProduce::order(UINT &ParamOne, UINT &ParamTwo)

{

UINT One = (ParamOne > ParamTwo ? ParamOne : ParamTwo);

UINT Two = (ParamOne < ParamTwo ? ParamOne : ParamTwo);

ParamOne = One;

ParamTwo = Two;

}

//求两个数的最大公约数

UINT KeyProduce::gcd(UINT FN, UINT E)

{

order(FN,E);

if (E == 0) return FN;

UINTr;

while(TRUE)

{

r = FN % E;

FN = E;

E = r;

if (E == 0)

return FN;

}

}

//求乘法逆元

UINT KeyProduce::ExtendEuclid(UINT FN, UINT E)

{

order(FN,E);

if ((E == 0) || (E == 1))

return gcd(FN,E);

INTa[3] = {1,0,FN},

b[3] = {0,1,E},

t[3];

while(TRUE)

{

if( b[2] == 1)

return b[1];

INT q = a[2] / b[2];

for (INT i = 0; i < 3; i++)

{

t[i] = a[i] - q * b[i];

a[i] = b[i];

b[i] = t[i];

}

}

}

//对数据执行RSA加解密

BOOL KeyProduce::RSAKeyEncrypt(UINT divisor,UINT model_N,UINT Key,UINT &result)

{

if (divisor == '/0')return FALSE;

if (result == NULL)return FALSE;

if (!model_N || !Key) return FALSE;

INTBit[32] = {0};

for (UINT iCount = 0; Key > 0; iCount++)//将密钥转换为二进制形式

{

Bit[iCount] = Key % 2;

Key /= 2;

}

result = ModularMultiplication(divisor,Bit,model_N);

return TRUE;

}

UINT KeyProduce::ModularMultiplication (UINT divisor,INT Bit[],UINT model_N)

{

UINT result = 1;

for (INT i = 32; i >= 0; i--)

{

result = (result * result) % model_N;

if (Bit[i] == 1)

result = (result * divisor) % model_N;

}

return result;

}