mycryptlib.cpp

提供加密的c/s 聊天程序。用到对称加密算法和非对称加密算法

	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -8;
	}


	if ( BNSubtractdw(pQ1,q,1,nPrimeSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -8;
	}

	// Make sure that GCD(p-1,e)!=1 and GCD(q-1,e)!=1 

	BNGcd(pG, pP1, pE,nPrimeSize);

	if ( BNComparedw(pG,1,nPrimeSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -9;
	}



	BNGcd(pG, pQ1, pE,nPrimeSize);

	if ( BNComparedw(pG,1,nPrimeSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -9;
	}


	// n = pq 
	BNMultiply(n, p, q,nPrimeSize);

	nNSize=BNSizeof(n,nSize);

	if ( BNIsZero(n,nNSize)) 
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -11;
	}
	//
	// d = e^-1 mod (p-1)(q-1) 
	// 

	// pPhi = (p-1)(q-1) 
	BNMultiply(pPhi, pP1, pQ1,nPrimeSize);
	// pPhi have the operation size of nPrimeSize*2<=nSize

	if ( BNIsZero(pPhi,nSize))  
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -11;
	}

	nRet = BNModInv(d, pE, pPhi,nSize);

	nDSize=BNSizeof(d,nSize);


	if ( BNIsZero(d,nDSize) || nRet!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -11;
	}

	// Check ed = 1 mod phi 
	BNSetZero(pG,nSize);
	//BNModMult(pG, pE, d, pPhi,nSize);
	BNModMult(pG, pE, d, pPhi,max(nDSize,nPrimeSize*2));


	if ( BNComparedw(pG,1,nSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -11;
	}

	if ( BNModInv(dP, pE, pP1,nPrimeSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -12;
	}

	if ( BNModInv(dQ, pE, pQ1,nPrimeSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -13;
	}

	if ( BNModInv(qInv, q, p,nSize)!=0 )
	{
		BNFree(&pG);
		BNFree(&pP1);
		BNFree(&pQ1);
		BNFree(&pPhi);
		BNFree(&pE);
		return -14;
	}

	BNFree(&pG);
	BNFree(&pP1);
	BNFree(&pQ1);
	BNFree(&pPhi);
	BNFree(&pE);
	return nNSize;	
}

#ifdef _MYCRYPTLIB_DEMOS_


void MyCryptLib::DemoDiffieHellman(CHistoryEdit *pLogg, UINT nSize)
{
	if(!pLogg) // be safe.. 
		return; 
	pLogg->AppendString("Diffie Hellman Key Exchange Test.. \r\n---------");

	CString stmp;
	// We need some variables. 
	UINT i=0;
	UINT j=0;
	DWORD dwStartTime=0;
	DWORD dwEndTime=0;
	DWORD dwTotalComputeBTime=0;
	DWORD dwTotalComputeATime=0;
	DWORD dwTotalComputeS1Time=0;
	DWORD dwTotalComputeS2Time=0;
	DWORD dwTotalComputePTime=0;

	// Allocate memory 
	DWORD* p=BNAlloc(nSize);


	UINT nKeySize=nSize/2;

	DWORD* g=BNAlloc(nKeySize);
	DWORD* A=BNAlloc(nKeySize);
	DWORD* B=BNAlloc(nKeySize);
	DWORD* a=BNAlloc(nKeySize);
	DWORD* b=BNAlloc(nKeySize);
	DWORD* S1=BNAlloc(nKeySize);
	DWORD* S2=BNAlloc(nKeySize);


	// be Safe.. 
	if( !p || !g || !A || !B || !a || !b || !S1 || !S2 )
	{
		BNFree(&p);
		BNFree(&g);
		BNFree(&A);
		BNFree(&B);
		BNFree(&a);
		BNFree(&b);
		BNFree(&S1);
		BNFree(&S2);
		return ;

	}



	// Make them all zero.. 

	BNSetZero(p,nSize);
	BNSetZero(g,nKeySize);
	BNSetZero(A,nKeySize);
	BNSetZero(B,nKeySize);
	BNSetZero(a,nKeySize);
	BNSetZero(b,nKeySize);
	BNSetZero(S1,nKeySize);
	BNSetZero(S2,nKeySize);


	// Compute how much time in sekonds it takes to generate the prime nrs. 
	// The Keygeneration is an socastic function with these estimated parameters. 
	double time=0.3518*exp(0.0016*nSize*8*4);

	stmp.Format("Exchanging a secure Session key of size %i bits.",nKeySize*4*8);
	pLogg->AppendString(stmp);

	// Generate prime number. 
	stmp.Format("Generating a ~ %i bit prime nr. This may take a while..\r\n",nSize*8*4);
	pLogg->AppendString(stmp);


	timeBeginPeriod(1);
	dwStartTime=timeGetTime();

	BNSetEqualdw(g,5,nKeySize);
	int iRet=BNMakePrime(p,nSize);

	if ( iRet <0 )
	{
		BNFree(&p);
		BNFree(&g);
		BNFree(&A);
		BNFree(&B);
		BNFree(&a);
		BNFree(&b);
		BNFree(&S1);
		BNFree(&S2);
		pLogg->AppendString("Failed to Generate Prime number..");
		return;
	}

	dwEndTime=timeGetTime();
	timeEndPeriod(1);
	dwTotalComputePTime=dwEndTime-dwStartTime;
	UINT nPsize=BNBitLength(p,nSize);

	stmp.Format("Using public key: Ppub (size %ibits) Gpub %i.",nPsize,5);
	pLogg->AppendString(stmp);

	for(i=0;i<10;i++)
	{

		stmp.Format("------ Test nr %i.\r\n",i+1);
		pLogg->AppendString(stmp);

		// Generate Random secret keys a,b
		// 16= 256bit + 256bit
		for (j = 0; j <nKeySize ; j++)
			a[j] = MTRandom();	

		for (j = 0; j <nKeySize ; j++)
			b[j] = MTRandom();	


		// Alice Computes A 
		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		BNModExp(A, g, a, p,nKeySize);
		dwEndTime=timeGetTime();
		dwTotalComputeATime+=dwEndTime-dwStartTime;
		pLogg->AppendString("const DWORD Apub"+BNPrintC(A,nKeySize));


		// Bob Computes B 
		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		BNModExp(B, g, b, p,nKeySize);
		dwEndTime=timeGetTime();
		dwTotalComputeBTime+=dwEndTime-dwStartTime;
		pLogg->AppendString("const DWORD Bpub"+BNPrintC(B,nKeySize));


		// Exchange A and B 
		pLogg->AppendString("Exchange A and B, and compute secret keys..");

		// Alice computes S1=B^a mod(p)
		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		BNModExp(S1, B, a, p,nKeySize);
		dwEndTime=timeGetTime();
		timeEndPeriod(1);
		dwTotalComputeS1Time+=(dwEndTime-dwStartTime);

		// Bob Computes S2=A^b mod(p)
		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		BNModExp(S2, B, a, p,nKeySize);
		dwEndTime=timeGetTime();
		timeEndPeriod(1);
		dwTotalComputeS2Time+=(dwEndTime-dwStartTime);


		if ( !BNIsEqual(S1,S2,nKeySize) )
		{
			pLogg->AppendString("Error Secret key S1 is not equal S2");
			BNFree(&p);
			BNFree(&g);
			BNFree(&A);
			BNFree(&B);
			BNFree(&a);
			BNFree(&b);
			BNFree(&S1);
			BNFree(&S2);
			return;
		}else
		{

			pLogg->AppendString("Exchanged: const DWORD S"+BNPrintC(S1,nKeySize));
		}

	}

	pLogg->AppendString("\r\n---------------------------\r\n");


	pLogg->AppendString("const DWORD Ppub"+BNPrintC(p,nSize));

	stmp.Format("\r\nconst DWORD Gpub = %i",5);
	pLogg->AppendString(stmp);


	stmp.Format("Prime number generation time: %ims, keysize: %i \r\n",dwTotalComputePTime,nPsize);
	pLogg->AppendString(stmp);

	stmp.Format("Mean A & B (A= g^ a mod(p)) computation time: %0.2fms.\r\n",(dwTotalComputeATime+dwTotalComputeBTime)/(double)(i*2));
	pLogg->AppendString(stmp);


	stmp.Format("Mean S1 & S2 computation time: %0.2fms.\r\n",(dwTotalComputeS1Time+dwTotalComputeS2Time)/(double)(i*2));
	pLogg->AppendString(stmp);


	double dTotal=((dwTotalComputeATime+dwTotalComputeBTime)/(double)(i*2)) +  ((dwTotalComputeS1Time+dwTotalComputeS2Time)/(double)(i*2));

	stmp.Format("Total mean key Exchange time: %0.2fms.\r\n",dTotal);
	pLogg->AppendString(stmp);

	BNFree(&p);
	BNFree(&g);
	BNFree(&A);
	BNFree(&B);
	BNFree(&a);
	BNFree(&b);
	BNFree(&S1);
	BNFree(&S2);
}

void MyCryptLib::DemoDSA(CHistoryEdit *pLogg, UINT nSize, BYTE* pEntropyPool,UINT nEntropySize)
{	
	// Be Safe.
	if ( !pLogg )
		return;


	// Compute the size of P,Q primes. 
	UINT nPSize=nSize/2;
	UINT nQSize=nSize-nPSize;

	// let nSize be big enough for operations. 
	nSize=max(nPSize,nQSize)*2;

	pLogg->AppendString("DSA Test.. \r\n---------");


	CString stmp;
	// We need some variables. 
	BOOL bTestOK=TRUE;
	UINT i=0;
	UINT j=0;
	DWORD dwStartTime=0;
	DWORD dwEndTime=0;
	DWORD dwTotalSignTime=0;
	DWORD dwTotalVerifyTime=0;
	DWORD dwTotalRSAKeyGenerationTime=0;
	DWORD dwOverFlow=0;

	// Allocate memory 
	DWORD* n=BNAlloc(nSize);
	DWORD* d=BNAlloc(nSize);
	DWORD* p=BNAlloc(nSize);
	DWORD* q=BNAlloc(nSize);	
	DWORD* dQ=BNAlloc(nSize);
	DWORD* dP=BNAlloc(nSize);
	DWORD* qInv=BNAlloc(nSize);
	DWORD* m=BNAlloc(nSize);
	DWORD* S=BNAlloc(nSize);
	DWORD* e=BNAlloc(nSize);

	// be Safe.. 
	if ( !n||!d||!p||!q||!dQ||!dP||!qInv||!m||!S||!e )
	{
		BNFree(&n);
		BNFree(&d);
		BNFree(&p);
		BNFree(&q);
		BNFree(&dQ);
		BNFree(&dP);
		BNFree(&qInv);
		BNFree(&m);
		BNFree(&S);
		BNFree(&e);
		return ;
	}



	// Make them all zero.. 

	BNSetZero(n,nSize);
	BNSetZero(d,nSize);
	BNSetZero(p,nSize);
	BNSetZero(q,nSize);
	BNSetZero(dP,nSize);
	BNSetZero(dQ,nSize);
	BNSetZero(qInv,nSize);
	BNSetZero(m,nSize);
	BNSetZero(S,nSize);

	// Compute how much time in sekonds it takes to generate the prime nrs. 
	// The Keygeneration is an socastic function with these estimated parameters. 
	double time=0.3518*exp(0.0016*nSize*8*4);

	stmp.Format("Generating a ~ %i bit RSA/DSA key. This may take approximately %0.1f seconds. \r\n",nSize*8*4,time);

	pLogg->AppendString(stmp);

	timeBeginPeriod(1);
	dwStartTime=timeGetTime();

	DWORD dwe=3;


	int iRet=RSAGenerateKey(n,d,p,q,dP,dQ,qInv,nSize,nPSize,nQSize,dwe,pEntropyPool,nEntropySize);
	if ( iRet<0 )
	{
		pLogg->AppendString("Failed to Generate RSA Keys..");
		return;
	}

	dwEndTime=timeGetTime();
	timeEndPeriod(1);

	dwTotalRSAKeyGenerationTime=dwEndTime-dwStartTime;

	UINT nNsize=BNBitLength(n,nSize);
	nSize=BNSizeof(d,nSize);

	pLogg->AppendString("-------------- DSA  test");
	for ( i=0  ; i<25 ; i++ )
	{

		stmp.Format("------ Test nr %i.\r\n",i+1);
		pLogg->AppendString(stmp);
		pLogg->AppendString("Generating a Random message m.");
		BNSetZero(m,nSize);
		for (j = 0; j <nSize-2; j++)
			m[j] = MTRandom();	




		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		// Sign the message.. 
		DigitalSignSHA1rDSA((unsigned char *)m,nSize*4,d,n,S,nSize);
		dwEndTime=timeGetTime();
		dwTotalSignTime+=dwEndTime-dwStartTime;

		// Send (m,S) to Client that already have and trust public keys (n,e)..

		// Verify.  
		pLogg->AppendString("Verify the signature..");
		timeBeginPeriod(1);
		dwStartTime=timeGetTime();
		bTestOK=DigitalVerifySHA1rDSA((unsigned char *)m,nSize*4,n,dwe,S,nSize);

		dwEndTime=timeGetTime();
		dwTotalVerifyTime +=dwEndTime-dwStartTime;

		if ( !bTestOK )
		{
			pLogg->AppendString("Verification failed fatal error");
			break;
		}


	}


	pLogg->AppendString("\r\n---------------------------\r\n");
	pLogg->AppendString("const DWORD SecureChatIOCP::m_DSAKeypubN"+BNPrintC(n,nSize));
	pLogg->AppendString("const DWORD SecureChatIOCP::m_DSAKeypubD"+BNPrintC(d,nSize));
	stmp.Format("const DWORD SecureChatIOCP::m_DSAKeypubE = %i;",dwe);
	pLogg->AppendString(stmp);

	if ( bTestOK )
	{

		pLogg->AppendString("\r\n---------------------------\r\n");
		pLogg->AppendString("Test OK");
		stmp.Format("RSA/DSA Key size %i bits.",nNsize);
		pLogg->AppendString(stmp);
		stmp.Format("RSA/DSA Key Computation time: %ims.\r\n",dwTotalRSAKeyGenerationTime);
		pLogg->AppendString(stmp);
		stmp.Format("Mean Signature time: %0.4fms.\r\n",dwTotalSignTime/(double)i);
		pLogg->AppendString(stmp);
		stmp.Format("Mean Verfication time: %0.4fms.\r\n",dwTotalVerifyTime/(double)i);
		pLogg->AppendString(stmp);
	}	
	// free the variables. 
	BNFree(&n);
	BNFree(&d);
	BNFree(&p);
	BNFree(&q);
	BNFree(&dQ);
	BNFree(&dP);
	BNFree(&qInv);
	BNFree(&m);
	BNFree(&S);
	BNFree(&e);
}


void MyCryptLib::DemoRSA(CHistoryEdit *pLogg, UINT nSize)
{
	if ( !pLogg ) // be safe.. 
		return; 

	// The size of prime nrs P,Q. 
	UINT nPSize=nSize/2;
	UINT nQSize=nSize - nPSize;


	pLogg->AppendString("RSA Test.. \r\n---------");



	CString stmp;
	// We need some variables. 
	BOOL bTestOK=TRUE;
	UINT i=0;
	UINT j=0;
	DWORD dwStartTime=0;
	DWORD dwEndTime=0;
	DWORD dwTotalEncryptionTime=0;
	DWORD dwTotalNormalDecryptionTime=0;
	DWORD dwTotalDecryptionTime=0;
	DWORD dwTotalRSAKeyGenerationTime=0;
	DWORD dwOverFlow=0;
	// Allocate memory 
	DWORD* n=BNAlloc(nSize);
	DWORD* d=BNAlloc(nSize);
	DWORD* p=BNAlloc(nSize);
	DWORD* q=BNAlloc(nSize);	
	DWORD* dQ=BNAlloc(nSize);
	DWORD* dP=BNAlloc(nSize);
	DWORD* qInv=BNAlloc(nSize);
	DWORD* m=BNAlloc(nSize);
	DWORD* e=BNAlloc(nSize);
	DWORD* c=BNAlloc(nSize);
	DWORD* m1=BNAlloc(nSize);
	DWORD* m2=BNAlloc(nSize);
	DWORD* h=BNAlloc(nSize);
	DWORD* hq=BNAlloc(nSize);

	// be Safe.. 
	if ( !n||!d||!p||!q||!dQ||!dP||!qInv||!m||!e||!c||!m1||!m2||!h||!hq )
	{
		BNFree(&n);
		BNFree(&d);
		BNFree(&p);
		BNFree(&q);
		BNFree(&dQ);
		BNFree(&dP);
		BNFree(&qInv);
		BNFree(&m);
		BNFree(&e);
		BNFree(&c);
		BNFree(&m1);
		BNFree(&m2);
		BNFree(&h);
		BNFree(&hq);
		return ;

	}



	// Make them all zero.. 

	BNSetZero(n,nS