encrypt.cpp

3DES加密解密

// Encrypt.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "Encrypt.h"
BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
    return TRUE;
}

// This is the constructor of a class that has been exported.
// see Encrypt.h for the class definition
CD3Wrapper::CD3Wrapper()
{
	memset(KnL, 0, 32);
	memset(KnR, 0, 32);
	memset(Kn3, 0, 32);

	m_bKeySetted = false;
	m_nMode      = -1;
}

CD3Wrapper::~CD3Wrapper()
{

}

int CD3Wrapper::SetDes3Key(unsigned char szKey[24], short nMode)
{
	try
	{
		if (0 == szKey)
		{
			return -1;
		}

		des3key(szKey, nMode);

		m_bKeySetted = true;

		m_nMode = nMode;
	}
	catch(...)
	{
		return -1;
	}
	return 0;
}

int CD3Wrapper::DoD3Des(unsigned char *pSrc, int nLenSrc, unsigned char *&pDst)
{
	try
	{
		unsigned char from[KEY_SIZE];

		if (m_nMode < 0)
		{
			return -1;
		}

		if (NULL != pDst
			|| NULL == pSrc)
		{
			return -2;
		}

		unsigned char *pStart = pSrc;
		unsigned char *pEnd   = pSrc + nLenSrc;

		int nLenDst = (nLenSrc + KEY_SIZE - 1) / KEY_SIZE * KEY_SIZE;

		if( nLenDst == 0 )
			return nLenDst;

		pDst = new unsigned char[nLenDst];

		if (NULL == pDst)
		{
			return -3;
		}

		memset(pDst, 0, nLenDst);

		unsigned char *pRet = pDst;
		memset(from, 0xFF, KEY_SIZE);

		while (pStart < pEnd)
		{
			if ((pStart + KEY_SIZE) > pEnd)
			{
				memcpy(from, pStart, pEnd - pStart);
				D3des(from, pRet);
			}
			else
			{
				D3des(pStart, pRet);
			}

			pRet   += KEY_SIZE;
			pStart += KEY_SIZE;
		}

		while (*--pRet == 0xFF)
		{
			nLenDst--;
			*pRet = '\0';
		}
		return nLenDst;
	}
	catch(...)
	{
		return -4;
	}
}

void CD3Wrapper::ReleaseBuffer(void* pBuffer)
{
	try
	{
		delete[] pBuffer;
	}
	catch(...)
	{
	}
}

void CD3Wrapper::Make3Key(char *szDigest, unsigned char szKey[KEY_SIZE])
{
	try
	{
		make3key(szDigest, szKey);
	}
	catch(...)
	{
	}
}

void CD3Wrapper::deskey(unsigned char *key, short edf)	/* Thanks to James Gillogly & Phil Karn! */
{

	register int i, j, l, m, n;

	unsigned char pc1m[56], pcr[56];

	unsigned long kn[32];



	for ( j = 0; j < 56; j++ ) {

		l = pc1[j];

		m = l & 07;

		pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;

	}

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

		if( edf == DE1 ) m = (15 - i) << 1;

		else m = i << 1;

		n = m + 1;

		kn[m] = kn[n] = 0L;

		for( j = 0; j < 28; j++ ) {

			l = j + totrot[i];

			if( l < 28 ) pcr[j] = pc1m[l];

			else pcr[j] = pc1m[l - 28];

		}

		for( j = 28; j < 56; j++ ) {

			l = j + totrot[i];

			if( l < 56 ) pcr[j] = pc1m[l];

			else pcr[j] = pc1m[l - 28];

		}

		for( j = 0; j < 24; j++ ) {

			if( pcr[pc2[j]] ) kn[m] |= bigbyte[j];

			if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j];

		}

	}

	cookey(kn);

	return;

}

void CD3Wrapper::cookey(register unsigned long *raw1)
{
	register unsigned long *cook, *raw0;

	unsigned long dough[32];

	register int i;



	cook = dough;

	for( i = 0; i < 16; i++, raw1++ ) {

		raw0 = raw1++;

		*cook	 = (*raw0 & 0x00fc0000L) << 6;

		*cook	|= (*raw0 & 0x00000fc0L) << 10;

		*cook	|= (*raw1 & 0x00fc0000L) >> 10;

		*cook++ |= (*raw1 & 0x00000fc0L) >> 6;

		*cook	 = (*raw0 & 0x0003f000L) << 12;

		*cook	|= (*raw0 & 0x0000003fL) << 16;

		*cook	|= (*raw1 & 0x0003f000L) >> 4;

		*cook++ |= (*raw1 & 0x0000003fL);

	}

	usekey(dough);

	return;

}



void CD3Wrapper::cpkey(register unsigned long *into)
{

	register unsigned long *from, *endp;



	from = KnL, endp = &KnL[32];

	while( from < endp ) *into++ = *from++;

	return;

}



void CD3Wrapper::usekey(register unsigned long *from)
{

	register unsigned long *to, *endp;



	to = KnL, endp = &KnL[32];

	while( to < endp ) *to++ = *from++;

	return;

}



void CD3Wrapper::des(unsigned char *inblock, unsigned char *outblock)
{

	unsigned long work[2];



	scrunch(inblock, work);

	desfunc(work, KnL);

	unscrun(work, outblock);

	return;

}



void CD3Wrapper::scrunch(register unsigned char *outof, register unsigned long *into)
{

	*into	 = (*outof++ & 0xffL) << 24;

	*into	|= (*outof++ & 0xffL) << 16;

	*into	|= (*outof++ & 0xffL) << 8;

	*into++ |= (*outof++ & 0xffL);

	*into	 = (*outof++ & 0xffL) << 24;

	*into	|= (*outof++ & 0xffL) << 16;

	*into	|= (*outof++ & 0xffL) << 8;

	*into	|= (*outof   & 0xffL);

	return;

}



void CD3Wrapper::unscrun(register unsigned long *outof, register unsigned char *into)
{

	*into++ = (*outof >> 24) & 0xffL;

	*into++ = (*outof >> 16) & 0xffL;

	*into++ = (*outof >>  8) & 0xffL;

	*into++ =  *outof++	 & 0xffL;

	*into++ = (*outof >> 24) & 0xffL;

	*into++ = (*outof >> 16) & 0xffL;

	*into++ = (*outof >>  8) & 0xffL;

	*into	=  *outof	 & 0xffL;

	return;

}


void CD3Wrapper::desfunc(register unsigned long *block, register unsigned long *keys)
{

	register unsigned long fval, work, right, leftt;

	register int round;



	leftt = block[0];

	right = block[1];

	work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;

	right ^= work;

	leftt ^= (work << 4);

	work = ((leftt >> 16) ^ right) & 0x0000ffffL;

	right ^= work;

	leftt ^= (work << 16);

	work = ((right >> 2) ^ leftt) & 0x33333333L;

	leftt ^= work;

	right ^= (work << 2);

	work = ((right >> 8) ^ leftt) & 0x00ff00ffL;

	leftt ^= work;

	right ^= (work << 8);

	right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;

	work = (leftt ^ right) & 0xaaaaaaaaL;

	leftt ^= work;

	right ^= work;

	leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;



	for( round = 0; round < 8; round++ ) {

		work  = (right << 28) | (right >> 4);

		work ^= *keys++;

		fval  = SP7[ work		 & 0x3fL];

		fval |= SP5[(work >>  8) & 0x3fL];

		fval |= SP3[(work >> 16) & 0x3fL];

		fval |= SP1[(work >> 24) & 0x3fL];

		work  = right ^ *keys++;

		fval |= SP8[ work		 & 0x3fL];

		fval |= SP6[(work >>  8) & 0x3fL];

		fval |= SP4[(work >> 16) & 0x3fL];

		fval |= SP2[(work >> 24) & 0x3fL];

		leftt ^= fval;

		work  = (leftt << 28) | (leftt >> 4);

		work ^= *keys++;

		fval  = SP7[ work		 & 0x3fL];

		fval |= SP5[(work >>  8) & 0x3fL];

		fval |= SP3[(work >> 16) & 0x3fL];

		fval |= SP1[(work >> 24) & 0x3fL];

		work  = leftt ^ *keys++;

		fval |= SP8[ work		 & 0x3fL];

		fval |= SP6[(work >>  8) & 0x3fL];

		fval |= SP4[(work >> 16) & 0x3fL];

		fval |= SP2[(work >> 24) & 0x3fL];

		right ^= fval;

	}



	right = (right << 31) | (right >> 1);

	work = (leftt ^ right) & 0xaaaaaaaaL;

	leftt ^= work;

	right ^= work;

	leftt = (leftt << 31) | (leftt >> 1);

	work = ((leftt >> 8) ^ right) & 0x00ff00ffL;

	right ^= work;

	leftt ^= (work << 8);

	work = ((leftt >> 2) ^ right) & 0x33333333L;

	right ^= work;

	leftt ^= (work << 2);

	work = ((right >> 16) ^ leftt) & 0x0000ffffL;

	leftt ^= work;

	right ^= (work << 16);

	work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;

	leftt ^= work;

	right ^= (work << 4);

	*block++ = right;

	*block = leftt;

	return;

}

#ifdef D2_DES

void CD3Wrapper::des2key(unsigned char *hexkey/* unsigned char[16] */, short mode)		/* stomps on Kn3 too */
{
	short revmod;

	revmod = (mode == EN0) ? DE1 : EN0;

	deskey(&hexkey[8], revmod);

	cpkey(KnR);

	deskey(hexkey, mode);

	cpkey(Kn3);					/* Kn3 = KnL */

	return;

}

void CD3Wrapper::Ddes(unsigned char *from, unsigned char *into)/* unsigned char[8] */
{

	unsigned long work[2];



	scrunch(from, work);

	desfunc(work, KnL);

	desfunc(work, KnR);

	desfunc(work, Kn3);

	unscrun(work, into);

	return;

}

void CD3Wrapper::D2des(unsigned char *from/* unsigned char[16] */, unsigned char *into/* unsigned char[16] */)
{

	unsigned long *right, *l1, swap;

	unsigned long leftt[2], bufR[2];



	right = bufR;

	l1 = &leftt[1];

	scrunch(from, leftt);

	scrunch(&from[8], right);

	desfunc(leftt, KnL);

	desfunc(right, KnL);

	swap = *l1;

	*l1 = *right;

	*right = swap;

	desfunc(leftt, KnR);

	desfunc(right, KnR);

	swap = *l1;

	*l1 = *right;

	*right = swap;

	desfunc(leftt, Kn3);

	desfunc(right, Kn3);

	unscrun(leftt, into);

	unscrun(right, &into[8]);

	return;
}


void CD3Wrapper::makekey(register char *aptr/* NULL-terminated  */, register unsigned char *kptr/* unsigned char[8] */)
{

	register unsigned char *store;

	register int first, i;

	unsigned long savek[96];



	cpDkey(savek);

	des2key(Df_Key, EN0);

	for( i = 0; i < 8; i++ ) kptr[i] = Df_Key[i];

	first = 1;

	while( (*aptr != '\0') || first ) {

		store = kptr;

		for( i = 0; i < 8 && (*aptr != '\0'); i++ ) {

			*store++ ^= *aptr & 0x7f;

			*aptr++ = '\0';

		}

		Ddes(kptr, kptr);

		first = 0;

	}

	useDkey(savek);

	return;

}

void CD3Wrapper::make2key(register char *aptr/* NULL-terminated   */, register unsigned char *kptr/* unsigned char[16] */)
{

	register unsigned char *store;

	register int first, i;

	unsigned long savek[96];



	cpDkey(savek);

	des2key(Df_Key, EN0);

	for( i = 0; i < 16; i++ ) kptr[i] = Df_Key[i];

	first = 1;

	while( (*aptr != '\0') || first ) {

		store = kptr;

		for( i = 0; i < 16 && (*aptr != '\0'); i++ ) {

			*store++ ^= *aptr & 0x7f;

			*aptr++ = '\0';

		}

		D2des(kptr, kptr);

		first = 0;

	}

	useDkey(savek);

	return;

}

#ifndef D3_DES	/* D2_DES only */

#ifdef	D2_DES	/* iff D2_DES! */

void CD3Wrapper::cp2key(register unsigned long *into/* unsigned long[64] */)
{

	register unsigned long *from, *endp;



	cpkey(into);

	into = &into[32];

	from = KnR, endp = &KnR[32];

	while( from < endp ) *into++ = *from++;

	return;

}

void CD3Wrapper::use2key(register unsigned long *from/* unsigned long[64] */)				/* stomps on Kn3 too */
{

	register unsigned long *to, *endp;

	usekey(from);

	from = &from[32];

	to = KnR, endp = &KnR[32];

	while( to < endp ) *to++ = *from++;

	cpkey(Kn3);					/* Kn3 = KnL */

	return;

}

#endif	/* iff D2_DES */

#else	/* D3_DES too */

void CD3Wrapper::des3key(unsigned char *hexkey, short mode)/* unsigned char[24] */
{

	unsigned char *first, *third;

	short revmod;



	if( mode == EN0 ) {

		revmod = DE1;

		first = hexkey;

		third = &hexkey[16];

	}

	else {

		revmod = EN0;

		first = &hexkey[16];

		third = hexkey;

	}

	deskey(&hexkey[8], revmod);

	cpkey(KnR);

	deskey(third, mode);

	cpkey(Kn3);

	deskey(first, mode);

	return;

}

void CD3Wrapper::cp3key(register unsigned long *into/* unsigned long[96] */)
{

	register unsigned long *from, *endp;



	cpkey(into);

	into = &into[32];

	from = KnR, endp = &KnR[32];

	while( from < endp ) *into++ = *from++;

	from = Kn3, endp = &Kn3[32];

	while( from < endp ) *into++ = *from++;

	return;

}

void CD3Wrapper::use3key(register unsigned long *from)/* unsigned long[96] */
{
	register unsigned long *to, *endp;

	usekey(from);

	from = &from[32];

	to = KnR, endp = &KnR[32];

	while( to < endp ) *to++ = *from++;

	to = Kn3, endp = &Kn3[32];

	while( to < endp ) *to++ = *from++;

	return;

}

void CD3Wrapper::D3des(unsigned char *from/* unsigned char[24] */, unsigned char *into/* unsigned char[24] */)	/* amateur theatrics */
{

	unsigned long swap, leftt[2], middl[2], right[2];

	scrunch(from, leftt);

	scrunch(&from[8], middl);

	scrunch(&from[16], right);

	desfunc(leftt, KnL);

	desfunc(middl, KnL);

	desfunc(right, KnL);

	swap = leftt[1];

	leftt[1] = middl[0];

	middl[0] = swap;

	swap = middl[1];

	middl[1] = right[0];

	right[0] = swap;

	desfunc(leftt, KnR);

	desfunc(middl, KnR);

	desfunc(right, KnR);

	swap = leftt[1];

	leftt[1] = middl[0];

	middl[0] = swap;

	swap = middl[1];

	middl[1] = right[0];

	right[0] = swap;

	desfunc(leftt, Kn3);

	desfunc(middl, Kn3);

	desfunc(right, Kn3);

	unscrun(leftt, into);

	unscrun(middl, &into[8]);

	unscrun(right, &into[16]);

	return;

}

void CD3Wrapper::make3key(register char *aptr/* NULL-terminated   */, register unsigned char *kptr/* unsigned char[24] */)
{

	register unsigned char *store;

	register int first, i;

	unsigned long savek[96];



	cp3key(savek);

	des3key(Df_Key, EN0);

	for( i = 0; i < 24; i++ ) kptr[i] = Df_Key[i];

	first = 1;

	while( (*aptr != '\0') || first ) {

		store = kptr;

		for( i = 0; i < 24 && (*aptr != '\0'); i++ ) {

			*store++ ^= *aptr & 0x7f;

			*aptr++ = '\0';

		}

		D3des(kptr, kptr);

		first = 0;

	}

	use3key(savek);

	return;

}

#endif	/* D3_DES */

#endif	/* D2_DES */


/* Validation sets:

*

* Single-length key, single-length plaintext -

* Key	  : 0123 4567 89ab cdef

* Plain  : 0123 4567 89ab cde7

* Cipher : c957 4425 6a5e d31d

*

* Double-length key, single-length plaintext -

* Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210

* Plain  : 0123 4567 89ab cde7

* Cipher : 7f1d 0a77 826b 8aff

*

* Double-length key, double-length plaintext -

* Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210

* Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff

* Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7

*

* Triple-length key, single-length plaintext -

* Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

* Plain  : 0123 4567 89ab cde7

* Cipher : de0b 7c06 ae5e 0ed5

*

* Triple-length key, double-length plaintext -

* Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

* Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff

* Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5

*

* d3des V5.0a rwo 9208.07 18:44 Graven Imagery

**********************************************************************/