c_rsa.cpp

RSA和DES的一些类~~可以对初学者有些帮助

// C_RSA.cpp: implementation of the C_RSA class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "RSA.h"
#include "C_RSA.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

C_RSA::C_RSA()
{

}

C_RSA::~C_RSA()
{

}

inline
bool C_RSA::IsPrime(int nX)
{
	int i;
	int nTop = static_cast<int>(sqrt(nX));
	nTop += 1;  // safe
	
	for (i = 2; i <= nTop; i++)
	{
		if (nX % i == 0)
		{
			break;
		}
	}

	if (i > nTop)
	{
		return true;
	}

	return false;
}

inline
int  C_RSA::Power(int nA, int nN, int nM)
{
	int nZ = 1, nTemp;

	for (nTemp = nA; nN > 0; nN >>= 1)
	{
		if (nN % 2 == 1)
		{
			nZ = (nZ * nTemp) % nM;
		}

		nTemp = (nTemp * nTemp) % nM;
	}

	return nZ;
}



int C_RSA::Gcd(int nA, int nB)
{
	
	if (nA == 0)
	{
		return nB;
	}
	else
	{
		return Gcd(nB % nA, nA);
	}	
	
}


inline
void C_RSA::ProduceEncryCode(int nFin)
{
	for (int i = 3; i < nFin; ++i)
	{
		if (IsPrime(i) && 1 == Gcd(nFin, i))
		{
			m_nEncrytInFo.nEncryptCode = i;
			break;
		}
	}
}

C_RSA::ENCRYPTTYPE & C_RSA::AutoProduceEncryptInFo(void)
{
	int nP, nQ;
	while(true)
	{
		srand(time(0));
		nP = rand() % 100;
		nQ = rand() % 100;
		if (IsPrime(nQ) && IsPrime(nP))
			break;
	}
	return ProduceEncryptInFo(nP, nQ);
}


C_RSA::ENCRYPTTYPE& C_RSA::ProduceEncryptInFo(int nP, int nQ)
{
	m_nP = nP;
	m_nQ = nQ;
	m_nEncrytInFo.nN = m_nP * m_nQ;

	int nFin = (m_nP - 1) * (m_nQ - 1);
	
    ProduceEncryCode(nFin);

	Euler(m_nEncrytInFo.nEncryptCode, nFin);

	return m_nEncrytInFo;
}

inline
void C_RSA::Euler(int nE, int nFin)
{
	int u1 = 1;
	int u2 = 0;
	int u3 = nFin;
	int v1 = 0;
	int v2 = 1;
	int v3 = nE;
	int v = 1;
	int t1, t2, t3;
	int q;
	int uu, vv;
	int inverse, z;

	while (v3 != 0)
	{
		q = u3 / v3;
		t1 = u1 - q * v1;
		t2 = u2 - q * v2;
		t3 = u3 - q * v3;
		u1 = v1;
		u2 = v2;
		u3 = v3;
		v1 = t1;
		v2 = t2;
		v3 = t3;
		z =  1;
	}


	uu = u1;
	vv = u2;
	
	if (vv < 0)
	{
		inverse = vv + nFin;
	}
	else
	{
		inverse = vv;
	}

	m_nEncrytInFo.nDecryptCode = inverse;	
}


bool C_RSA::Encrypt(string &strContent, string & strEncryptContent)
{
	if (strContent.empty())
	{
		return false;
	}

	strEncryptContent = "";
	string::size_type nIndex = 0;
	string::size_type nSize = strContent.size();
	for (nIndex = 0;  nIndex < nSize; ++nIndex)
	{
		char szBuffer[1024] = {0};
		int nECode = Power(strContent[nIndex], 
			m_nEncrytInFo.nEncryptCode,
			m_nEncrytInFo.nN);

		sprintf(szBuffer, "%d%s", nECode, "+");
		strEncryptContent += szBuffer;
		
	}
	return true;
}

bool C_RSA::Decrypt(string & strEncryptContent, string &strContent, int nDecryptCode, int nN)
{

    if (strEncryptContent.empty())
	{
		return false;
	}

	strContent = "";
	unsigned size = strEncryptContent.size();
	char *pstrEnCode  =  new char [size];
	CopyMemory(pstrEnCode, strEncryptContent.c_str(), size);

	char seps[]   = "+";
	char *token;

	token = strtok( pstrEnCode, seps );
	while( token != NULL )
	{
		int nCode = atoi(token);
		char nChar = static_cast<char>(Power(nCode, nDecryptCode, nN));
		strContent += nChar;	
		token = strtok( NULL, seps );
	}

	delete[] pstrEnCode;

	return true;

}