crypto.cpp

这是一个用三种加密算法

void CCrypto::seal_decrypt(seal_ctx *c, DWORD *data_ptr, int w)
{
	seal_encrypt(c,data_ptr,w);
}

void CCrypto::seal_resynch(seal_ctx *c, DWORD synch_word)
{
	c->counter=synch_word;
	c->ks_pos=WORDS_PER_SEAL_CALL;
}


int CCrypto::GetFinalData(BYTE cardnum[], BYTE finaldata[],int narcardSize,int narfinalSize)
{
	des_ctx* dc=new des_ctx;
	BYTE *pdata;
	BYTE key[8]={0x84,0x79,0x06,0x91,0x26,0x8c,0x1a,0x3f};
	BYTE *pkey;
	BYTE data[24];
	DWORD *pldata,ldata[12];
	int nSize=24;
	int len,i;
	len=narcardSize;
	if(len>24) return(-1);
	if(narfinalSize!=20) return(-2);
	///////////////////////des///////////////////////////
	CardNumToData(cardnum,data,narcardSize);
	pdata=&data[0];
	pkey=&key[0];
	DesEnc(dc,pkey,pdata,nSize/8);
	delete dc;
	i=1;
	int j;
	j=nSize/2;
	while(i<(nSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
	pdata=&data[0];
	BYTE rckey[5]={0x49,0x3c,0x91,0xa5,0xf0};
	BYTE *prckey;
	int rcSize,size;
	prckey=&rckey[0];
	rc5_ctx *c=new rc5_ctx;
	CharToLong(data,24,ldata,rcSize);
	pldata=&ldata[0];
	Rc5Enc(c,15,prckey,5,pldata, rcSize/2);
	delete c;
	/////////////////////////////////////////seal///////////////////////
	seal_ctx* sc=new seal_ctx;
	BYTE sealkey[20]={
		0xa5,0x61,0x8f,0x0d,0x63,0x9e,0xfa,0x22,0x1c,0x48,
		0xe3,0x57,0x04,0x73,0xde,0x8b,0xf4,0x92,0x6a,0x9c
	};
	BYTE *psealkey;
	nSize=12;
	j=nSize/2;
	while(i<(nSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
	pldata=&ldata[0];
	psealkey=&sealkey[0];
	SealEnc(sc,sealkey,pldata,nSize);
	delete sc;
	DWORD fdata[10];
	i=0;
	for(i=0;i<10;i++)
	    fdata[i]=ldata[i];
	fdata[2]=ldata[2] ^ ldata[7];
	fdata[4]=ldata[4] ^ ldata[9];
	fdata[7]=ldata[8];
	fdata[8]=ldata[10];
	fdata[9]=ldata[11];
	BYTE sdata[20];
	LongToChar(fdata,10,sdata,size);
	DataToString(sdata,finaldata,size,narfinalSize);
	return(1);
}

int CCrypto::GetFinalData(CString cardnum, CString &finaldata)
{
	des_ctx* dc=new des_ctx;
	BYTE *pdata;
	BYTE key[8]={0x84,0x79,0x06,0x91,0x26,0x8c,0x1a,0x3f};
	BYTE *pkey;
	BYTE data[24];
	DWORD *pldata,ldata[12];
	int nSize=24;
	int len,i;
	len=cardnum.GetLength();
	if(len>24) return(-1);
	///////////////////////des///////////////////////////
	CardNumToData(cardnum,data);
	pdata=&data[0];
	pkey=&key[0];
	DesEnc(dc,pkey,pdata,nSize/8);
	delete dc;
	i=1;
	int j;
	j=nSize/2;
	while(i<(nSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
	pdata=&data[0];
	BYTE rckey[5]={0x49,0x3c,0x91,0xa5,0xf0};
	BYTE *prckey;
	int rcSize,size;
	prckey=&rckey[0];
	rc5_ctx *c=new rc5_ctx;
	CharToLong(data,24,ldata,rcSize);
	pldata=&ldata[0];
	Rc5Enc(c,15,prckey,5,pldata, rcSize/2);
	delete c;
	/////////////////////////////////////////seal///////////////////////
	seal_ctx* sc=new seal_ctx;
	BYTE sealkey[20]={
		0xa5,0x61,0x8f,0x0d,0x63,0x9e,0xfa,0x22,0x1c,0x48,
		0xe3,0x57,0x04,0x73,0xde,0x8b,0xf4,0x92,0x6a,0x9c
	};
	BYTE *psealkey;
	nSize=12;
	j=nSize/2;
	while(i<(nSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
	pldata=&ldata[0];
	psealkey=&sealkey[0];
	SealEnc(sc,sealkey,pldata,nSize); 
	delete sc;
	DWORD fdata[10];
	i=0;
	for(i=0;i<10;i++)
	    fdata[i]=ldata[i];
	fdata[2]=ldata[2] ^ ldata[7];
	fdata[4]=ldata[4] ^ ldata[9];
	fdata[7]=ldata[8];
	fdata[8]=ldata[10];
	fdata[9]=ldata[11];
	BYTE sdata[20];
	LongToChar(fdata,10,sdata,size);
	finaldata.Empty();
	DataToString(sdata,finaldata,size);
	return(1);
}


void CCrypto::CharToLong(BYTE olddata[],int oldSize,DWORD newdata[],int &newSize)
{
	int i;
	DWORD temp,data1,data2;
	for(i=0;i<oldSize;i+=2)
	{
		temp=0;
		data1=0;
		data2=0;
		data1=olddata[i+1];
		data2=((DWORD)((DWORD)olddata[i] & 0x0000ffffL))  <<  16;
		data2=data2  &  0xffff0000L;
		temp=data1  |  data2;
		newdata[i/2]=temp;
	};
	newSize=oldSize/2;
}

void CCrypto::LongToChar(DWORD olddata[], int oldSize, BYTE newdata[], int &newSize)
{
	int i;
	DWORD temp,data1,data2,tempdata;
	for(i=0;i<oldSize;i++)
	{
		temp=0;
		data1=0;
		data2=0;
		temp=olddata[i];
		data2=temp  &  0x0000ffffL;
		tempdata=temp  >>  16;
		data1=tempdata  &  0x0000ffffL;
		newdata[i*2]=(BYTE)data1;
		newdata[i*2+1]=(BYTE)data2;
	}
	newSize=oldSize*2;
}


void CCrypto::DataToString(BYTE data[], BYTE finaldata[], int dataSize, int finalSize)
{
	BYTE stringdata[36]={
		0x41, 0x59, 0x34, 0x43, 0x57, 0x36, 0x45, 0x55, 0x33, 0x47, 
		0x53, 0x37, 0x49, 0x51, 0x32, 0x4b, 0x4f, 0x4d,	0x38, 0x4e,
		0x4c, 0x50, 0x31, 0x4a, 0x52, 0x48, 0x39, 0x54, 0x46, 0x56,
		0x44, 0x35, 0x58, 0x42, 0x30, 0x5a
	};
	BYTE chardataindex[24];
	//BYTE chardata[24];
	//int charSize;
	FLOAT numsum,charsum;
	numsum=256.0;
	charsum=36.0;
	//LongToChar(data,nSize,chardata,charSize);
//	BYTE n=(BYTE)((charsum * 255)/numsum);
	int i;
	for(i=0;i<dataSize;i++)
		chardataindex[i]=(BYTE)((charsum * data[i])/numsum);
	for(i=0;i<dataSize;i++)
		finaldata[i]=stringdata[chardataindex[i]];
}

void CCrypto::DataToString(BYTE data[], CString &finaldata,int nSize)
{
	BYTE stringdata[36]={
		0x41, 0x59, 0x34, 0x43, 0x57, 0x36, 0x45, 0x55, 0x33, 0x47, 
		0x53, 0x37, 0x49, 0x51, 0x32, 0x4b, 0x4f, 0x4d,	0x38, 0x4e,
		0x4c, 0x50, 0x31, 0x4a, 0x52, 0x48, 0x39, 0x54, 0x46, 0x56,
		0x44, 0x35, 0x58, 0x42, 0x30, 0x5a
	};
	BYTE chardataindex[24];
	//BYTE chardata[24];
	//int charSize;
	FLOAT numsum,charsum;
	numsum=256.0;
	charsum=36.0;
	//LongToChar(data,nSize,chardata,charSize);
//	BYTE n=(BYTE)((charsum * 255)/numsum);
	int i;
	for(i=0;i<nSize;i++)
		chardataindex[i]=(BYTE)((charsum * data[i])/numsum);
	for(i=0;i<nSize;i++)
		finaldata.Insert(i+1,stringdata[chardataindex[i]]);
}


void CCrypto::CardNumToData(BYTE cardnum[], BYTE data[], int narcardSize, int ndataSize)
{
	int len,i,j;
	len=narcardSize;
	for(i=0;i<len;i++)
		data[i]=cardnum[i];
	i=len;
	j=0;
	while(i<ndataSize)
	{
		data[i]=data[j] ^ data[j+1];
		i++;
		j++;
	};
	i=1;
	j=ndataSize/2;
	while(i<(ndataSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
}

void CCrypto::CardNumToData(CString cardnum, BYTE data[], int nSize)
{
	int len,i,j;
	len=cardnum.GetLength();
	for(i=0;i<len;i++)
		data[i]=cardnum.GetAt(i);
	i=len;
	j=0;
	while(i<nSize)
	{
		data[i]=data[j] ^ data[j+1];
		i++;
		j++;
	};
	i=1;
	j=nSize/2;
	while(i<(nSize/2))
	{
		BYTE temp;
		temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		i+=2;
		j+=2;
	};
}

void CCrypto::des_deskey(BYTE *key, WORD edf)
{
	register int i, j, l, m, n;
    BYTE pclm[56], pcr[56];
    DWORD kn[32];
    for( j = 0; j < 56; j++ ) 
	{
		l= pc1[j];
        m=l & 0x07;
        pclm[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] = pclm[l];                         
            else 
				pcr[j] = pclm[l - 28];
        }
        for( j = 28; j < 56; j++ ) 
		{
			l=  j + totrot[i];
            if( l < 56 ) 
				pcr[j] = pclm[l];
            else 
				pcr[j] = pclm[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];
        }
	}
    des_cookey(kn);
    return;
}

void CCrypto::des_cookey(DWORD *raw1)
{
	register DWORD *cook, *raw0;
	DWORD dough[32];
	register int i;
	cook=dough;
	for(i=0; i < 16;i++)  
	{
		raw0 = raw1;
		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);
	};
	des_usekey(dough);
	return;
}

void CCrypto::des_cpkey(DWORD into[])
{
	register DWORD *from,*endp;
	int i=0;
	from = KnL;
	endp = &KnL[31];
	while( from < endp ) 
		into[i++] = *from++;
	into[i]=*from;
	return;
}

void CCrypto::des_usekey(DWORD *from)
{
	register DWORD *to, *endp;
	//int i=0;
	to = KnL;
	endp = &KnL[31];
	while( to < endp ) 
		*to++ = *from++;
	*to=*from;
	from++;
	return;
}

void CCrypto::des_des(BYTE *inblock, BYTE *outblock)
{
	DWORD work[2];
	des_scrunch(inblock, work);
	des_desfunc(work, KnL);
	des_unscrun(work, outblock);
	return;
}
      
void CCrypto::des_scrunch(BYTE *outof, DWORD *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 CCrypto::des_unscrun(DWORD *outof, BYTE *into)
{
	*into++ = (BYTE)((*outof >> 24) & 0x000000ffL);
	*into++ = (BYTE)((*outof >> 16) & 0x000000ffL);
	*into++ = (BYTE)((*outof >>  8) & 0x000000ffL);
	*into++ = (BYTE)( *outof++      & 0x000000ffL);
	*into++ = (BYTE)((*outof >> 24) & 0x000000ffL);
	*into++ = (BYTE)((*outof >> 16) & 0x000000ffL);
	*into++ = (BYTE)((*outof >>  8) & 0x000000ffL);
	*into   = (BYTE)( *outof        & 0x000000ffL);
	return;
}

void CCrypto::des_desfunc(DWORD *block, DWORD *keys)
{
	 register DWORD 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;
}

void CCrypto::des_key(des_ctx *dc, BYTE *key)
{
	des_deskey(key,ENO);
    des_cpkey(dc->ek);
    //des_deskey(key,DE1);
    //des_cpkey(dc->dk);  
}

void CCrypto::des_enc(des_ctx *dc, BYTE *data, int blocks)
{
	DWORD work[2];
    int i;
    BYTE *cp;
    cp = data;
    for(i=0;i<blocks;i++)
	{
		des_scrunch(cp,work);
		des_desfunc(work,dc->ek);
        des_unscrun(work,cp);
        cp+=8;
	}
}

void CCrypto::des_dec(des_ctx *dc, BYTE *data, int blocks)
{
	DWORD work[2];
    int i;
    BYTE *cp;
    cp = data;
    for(i=0;i<blocks;i++)
	{
		des_scrunch(cp,work);
		des_desfunc(work,dc->dk);
		des_unscrun(work,cp);
		cp+=8;
	}
}

void CCrypto::DesEnc(des_ctx *dc, BYTE *key, BYTE *data,int blocks)
{
	des_key(dc,key);
	des_enc(dc,data,blocks);
}

void CCrypto::Rc5Enc(rc5_ctx *c, int rounds, BYTE *key, int keylen, DWORD *data, int blocks)
{
	rc5_init(c,rounds);
	rc5_key(c,key,keylen);
	rc5_encrypt(c,data,blocks);
	rc5_destroy(c);
}

void CCrypto::SealEnc(seal_ctx *sc, BYTE *key, DWORD *data, int blocks)
{
	seal_key(sc,key);
	seal_encrypt(sc,data,blocks);
}