rsawang1.cpp

非常不错的RSA源代码,极局参考价值!请大家使用

		IntCpy(Prm,B);                       //将B拷贝到prm中 C=N result prime
		Substract(B,ONEVALUE,buf1);          //将B-ONEVALUE的结果放到buf1中
		SetMode(buf1,TWOVALUE,buf2,B);       //B=(B-1)/2的商,buf2=(B-1)/2的余数=0
		TransBi(B,flag);                     //将B转换为二进制大数
		ok=1;
		for(i=0;i<TESTNUM;i++)
		{
			LoadInt(A,Model[i]);             //将数组Model中的第i+1个数读取到A中
			k=PowerMode(A,Prm,D,flag);       //(A^flag) mod Prm ->D
			if(k!=1 && k!=2)                 //不符合判定规则
			{
				ok=0;
				break;
			}
			if(k==1)                         //判定条件1，G=A^(n-1)/2=1
			{
			}
			if(k==2)                         //判定条件2，G=A^(n-1)/2=p-1
			{
			}
		
		}
		if (ok)//if(ok && pass_2)
		{
			return 0;
		}//for循环用来检测IntRandom(B,MLENGTH)产生的数B是否是一个素数	
	}
}

/*---------------------------------------------------------------------------
功能：计算公钥PK
入口参数：$(r)的值在Rvalue中，私钥SK，公钥PK
返回值：成功找到，返回1
----------------------------------------------------------------------------*/
int CRsaA::ComputingPK(byteint Rvalue,byteint SK,byteint PK)
{
	register i;
	byteint PA,PB,PC,buf1,temp,buf2;
	SetZero(PK); SetZero(PA); SetZero(PB); SetZero(PC); SetZero(buf1);   //清零初始化
	SetZero(temp); SetZero(buf2);
	while(1)
	{
		IntRandom(SK,SKLENGTH);        //随机产生一个大数奇数作为Generated secret key

		IntCpy(PB,SK);
		IntCpy(PA,Rvalue);
		while(1)
		{
			SetMode(PA,PB,PC,PK);     //PA=PB*PK+PC
			i=IntCmp(PC,ONEVALUE);
			if(i==0)                  //PC=1, i=0
				break;                //满足条件，是互质的
			i=IntCmp(PC,ZEROVALUE);
			if(i==0)
			{
				i=-1;                 //PC=0,i=-1
				break;                //不满足互质条件，跳出循环，从新生成一个随机数
			}
			IntCpy(PA,PB);            //按照欧几里的定理继续判断

			IntCpy(PB,PC);
		}
		if(i==0)                      //满足，跳出查找循环
			break;
	}

	IntCpy(temp,ONEVALUE);
	IntCpy(PA,Rvalue);
	IntCpy(PB,SK);
	while(1)
	{
		Multiply(PA,temp,buf1);  //buf1=PA*temp
		Plus(buf1,ONEVALUE,buf2);//buf2=(PA*temp)+1
		SetMode(buf2,PB,buf1,PK);//buf=((PA*temp)+1)%PB
		if(IntCmp(buf1,ZEROVALUE)==0)
			break;
		Plus(temp,ONEVALUE,buf1);
		IntCpy(temp,buf1);
	}
	return 1;                   //SK and PK found
}


/*---------------------------------------------------------------------------
功能：计算模R
入口参数：产生的质数p，q，模R
返回值：无
----------------------------------------------------------------------------*/
void CRsaA::ComputingR(byteint p,byteint q,byteint R)
{
	Multiply(p,q,R);              // R=p*q, public mode number
}

/*---------------------------------------------------------------------------
功能：计算$(r)
入口参数：质数p，质数q，模$(r)放在Rvalue
返回值：无
----------------------------------------------------------------------------*/
void CRsaA::ComputingRvalue(byteint p,byteint q,byteint Rvalue)
{
	byteint buf1,buf2;
	SetZero(buf1); SetZero(buf2);

	Substract(p,ONEVALUE,buf1);   // buf1=p-1
	Substract(q,ONEVALUE,buf2);   // buf2=q-1
	Multiply(buf1,buf2,Rvalue);   // Rvalue=(p-1)*(q-1)
}

/*---------------------------------------------------------------------------
功能：将接受的字符串转换为大数类型
入口参数：大数result,字符串input
返回值：数的长度
----------------------------------------------------------------------------*/
int CRsaA::Getinput(byteint result,CString input)
{
	int i=DATALENGTH,m=0;
	long strlen;
	strlen=input.GetLength();
	
	if(strlen==0) return 0;
	else
	{
		for(int j=0;j<strlen;j++)
		{
			result[i-strlen+j] = (input.GetAt(j)-'0');
		}
		return j;
	}
}

/*---------------------------------------------------------------------------
功能：实现加密，解密运算功能
入口参数：明文(大数类型source)，模R，秘钥key，结果desti
返回值：无
----------------------------------------------------------------------------*/
void CRsaA::RsaDo(byteint source,byteint R,byteint key,byteint desti)
{
	TransBi(key,flag);
	PowerMode(source,R,desti,flag);
}

/*---------------------------------------------------------------------------
功能：将长整形的数转换为大数类型
入口参数：大数类型result,长整形input
返回值：成功，返回数的长度，否则返回0；
----------------------------------------------------------------------------*/
int CRsaA::Getinput1(byteint result,unsigned long input)
{
	int i=DATALENGTH-1,m=0;
	long j=0;
	int k=0;
	
	if(input)
	{
		do
		{
			j=input/10;
			k=input-j*10;
			result[i]=k;
			i--;
			m++;
			input=j;
		}while(j);
		return m;
	}
	else
		return 0;
}

/*---------------------------------------------------------------------------
功能：将十六进制的串转换为数值
入口参数：字符串指针
返回值：成功，返回数
----------------------------------------------------------------------------*/
unsigned long CRsaA::Os2ip(unsigned char* pstr)
{
	unsigned long ch=0;
	unsigned int j=0;
	unsigned long k=1;
	for(int i=0;i<4;i++)
	{
		j = (unsigned int) (*(pstr+3-i));
	/*	if( (*(pstr+3-i))>='0'&&(*(pstr+3-i))<='9')
			j = (*(pstr+3-i)) - '0';
		if( (*(pstr+3-i))>='a'&&(*(pstr+3-i))<='f') 
			j = (*(pstr+3-i)) - 'a'+10;
		if( (*(pstr+3-i))>='A'&&(*(pstr+3-i))<='F')
			j = (*(pstr+3-i)) - 'A'+10;*/
		ch += j*k;
		k*=256;
	}
	return ch;
} 

/*---------------------------------------------------------------------------
功能：将数串转换为相应的字符串
入口参数：字符串str
返回值：返回转换的结果；
----------------------------------------------------------------------------*/
CString CRsaA::Ip2os(CString str)
{
	int strlen=str.GetLength(),quotient=0,remainder=0;
	unsigned long num=0,temp=0;
	unsigned int k=1;
	CString strResult="";

	for(int i=strlen;i>0;i--)  //得到相应的数字串,存放在num中
	{
		temp = (str.GetAt(i-1) - '0');
			num += temp*k;
		k *= 10;
	}
	//采用模除的方式,求得相应的十六进制数
	for(int j=0;j<4;j++)
	{
		quotient = num/256;
		remainder = num - quotient*256;
		/*if(remainder>=0&&remainder<=9)
			strResult.Insert(0,(remainder+'0'));
		if(remainder>=10&&remainder<=15)
			strResult.Insert(0,(remainder-10+'a'));*/
		strResult.Insert(0,(unsigned char)remainder);
		num = quotient;
	}
	
	return strResult; 
}

/*---------------------------------------------------------------------------
功能：产生RSA秘钥对
入口参数：存放结果的字符串地址 
返回值：无
----------------------------------------------------------------------------*/
void CRsaA::GenKeys(CString& pk,CString& sk,CString& R)
{
	byteint m_p,m_q,m_R,m_Rvalue,m_PK,m_SK;
	SetZero(m_p);      //对大数变量进行清零初始化
	SetZero(m_q);
    SetZero(m_R);
    SetZero(m_Rvalue);
    SetZero(m_PK);
    SetZero(m_SK);

	Mdata();         //生成比较数表
	AfxMessageBox("开始计算质数P...");
	Prime(m_p);        //生成素数p q
	AfxMessageBox("开始计算质数Q...");
	Prime(m_q);

	AfxMessageBox("开始计算模R...");
	ComputingR(m_p,m_q,m_R); //计算模R
	AfxMessageBox("开始计算模r");
	ComputingRvalue(m_p,m_q,m_Rvalue);  //计算r
	AfxMessageBox("开始计算秘钥SK,PK");
	ComputingPK(m_Rvalue,m_PK,m_SK);    // Generate PK and SK
	
	//CGenKeyBusyDlg dlg1;
	//g1.DoModal();
	R=PrtInt(m_R);
	pk=PrtInt(m_PK);
	sk=PrtInt(m_SK);
	return ;

}

/*---------------------------------------------------------------------------
功能：实现加密功能接口
入口参数：明文字符串source，模字符串R，秘钥字符串key，结果字符串数组result
返回值：无
----------------------------------------------------------------------------*/
int CRsaA::RsaEncrypt(CString& source,const char *key,const char *R,CStringArray& result)
{
	unsigned char* pstr;
	int j;//sourcelen,j;
	byteint m_key,m_R,desti,aa;
	SetZero(desti);              //将大数变量清零初始化
	SetZero(aa);
	//SetZero(bb);
	SetZero(m_key);
	SetZero(m_R);

	pstr = (unsigned char*)(LPCTSTR)source;               //得到字符串数据的指针
	j = source.GetLength()/4;    //得到数组的元素个数

	result.SetSize(j,1);
	Getinput(m_key,key);             //将字符串转换为大数类型
	Getinput(m_R,R);
	
	for(int i=0;i<j;i++)
	{
		Getinput1(desti,Os2ip(pstr));    //将四个字节的输入转换为大数类型数值
		RsaDo(desti,m_R,m_key,aa);  //进行加密运算
		result.SetAt(i,PrtInt(aa));          //将结果存放到数组中
		SetZero(desti);  SetZero(aa);
		pstr += 4;
	}
	return j;
}

/*---------------------------------------------------------------------------
功能：实现解密功能接口
入口参数：密文字符串数组source，秘钥字符串sk，模字符串R，
返回值：结果字符串数组result
----------------------------------------------------------------------------*/
CString CRsaA::RsaDecrypt(CStringArray& source,const char* sk,const char* R)
{
	int index=0;
	CString result;
	byteint m_sk,m_r,desti,aa;
	SetZero(m_sk);  SetZero(m_r); SetZero(desti); SetZero(aa);  //SetZero(bb);

	index=source.GetSize();   //得到数组的元素个数
	Getinput(m_sk,sk);        //将字符串转换为大数类型
	Getinput(m_r,R);

	for(int i=0;i<index;i++)
	{
		Getinput(desti,source.GetAt(i));   //将加密结果转换为大数类型
		RsaDo(desti,m_r,m_sk,aa);          //解密运算
		result += Ip2os(PrtInt(aa));       //组合初始明文
		SetZero(aa);  SetZero(desti);
	}

	return result;        //返回明文串
}

/*---------------------------------------------------------------------------
功能：生成一个秘钥存贮文件
入口参数：无
返回值：无
----------------------------------------------------------------------------*/
void CRsaA::GenKeysTable()
{
	CStringArray RArray,SKArray,PKArray;
	CString r,pk,sk;
	int j=1,i;      //参数j表示产生的秘钥对的个数
	unsigned char strlength;
	//设置数组的元素个数
	RArray.SetSize(j,1);	SKArray.SetSize(j,1);	PKArray.SetSize(j,1);
	
	/*-----------------------------------------------------------------------
	文件格式为：
	长度   秘钥   长度   秘钥......
	----   ----   ----   ----
	1byte  nbyte  1byte  nbyte       (中间无空格,R,SK,PK)
	*/
	CFile file;

	for(i=0;i<j;i++)
	{
		GenKeys(pk,sk,r);  //循环产生秘钥
		RArray.SetAt(i,r); SKArray.SetAt(i,sk); PKArray.SetAt(i,pk);		
	}

	if(file.Open("c:\\key.txt",CFile::modeCreate|CFile::modeReadWrite)==0)
	{
		AfxMessageBox("open file error!");  //打开文件失败
		return;
	}
	

	for(i=0;i<j;i++)
	{                //循环写入结果
		strlength = (unsigned char)(RArray.GetAt(i)).GetLength();
		file.Write(&strlength,1);
		
		file.Write(RArray.GetAt(i),(RArray.GetAt(i)).GetLength());
		
		strlength = (unsigned char)(SKArray.GetAt(i)).GetLength();
		file.Write(&strlength,1);
		
		file.Write(SKArray.GetAt(i),(SKArray.GetAt(i)).GetLength());
		
		strlength = (unsigned char)(PKArray.GetAt(i)).GetLength();
		file.Write(&strlength,1);
		
		file.Write(PKArray.GetAt(i),(PKArray.GetAt(i)).GetLength());
	}
	
	file.Close();
}

void CRsaA::LoadKeysFromFile(CString& r,CString& sk,CString& pk)
{
	int            j=10,len;
	char           *pbuffer;
	unsigned char  strlen1;
	
	CFile          file;
	CFileException e;
	CString        strFileName;
	if(file.Open("c:\\key.txt",CFile::modeRead)==0)
	{	
		AfxMessageBox("File(key.txt)could not be opened" );
	}
	file.Read(&strlen1,1);  //读出R长度
	len = (int)strlen1;

	pbuffer = new char[len+1];
	pbuffer[len]='\0';
	file.Read(pbuffer,len);  //读出R
	r=pbuffer;
	delete pbuffer;

	file.Read(&strlen1,1);  //读出SK长度
	len = (int)strlen1;

	pbuffer = new char[len+1];
	pbuffer[len]='\0';
	file.Read(pbuffer,len);  //读出SK
	sk=pbuffer;
	delete pbuffer;

	file.Read(&strlen1,1);  //读出PK长度
	len = (int)strlen1;

	pbuffer = new char[len+1];
	pbuffer[len]='\0';
	file.Read(pbuffer,len);  //读出PK
	pk=pbuffer;
	delete pbuffer;

	file.Close();
}//