des.c

中国石油二期加油站IC系统后台通讯软件

	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;
}

/* Validation sets:
 *
 * Single-length key, single-length plaintext -
 * Key    : 0123 4567 89ab cdef
 * Plain  : 0123 4567 89ab cde7
 * Cipher : c957 4425 6a5e d31d
 *
 **********************************************************************/

void des_key(des_ctx *dc, S8 *key,S8 arrRow){
	deskey(key,EN0);
	cpkey(dc->ek[arrRow]);
	deskey(key,DE1);
	cpkey(dc->dk[arrRow]);
}


/******************************************************************************************
 *Input Data 1,for single or triple according to TIMES
 *	     	2,for Encrypts or Decrypts according to MODE ,
 *	     	3,plaintext: one block of eight byte at address. 
 *     	 	4,key: if single is  8 byte at address.if triple is 16 byte at address.
 *	     	5,ciphertext: one block of eight byte at address. 
 *Output Data :ciphertext 
 */
void des_func(S8 TIMES,S8 MODE,S8 *inblock,S8 *key,S8 *outblock)
{
	des_ctx dc,*pdc;
//	S8 arrRow;
	U32 work[2];
	pdc = &dc;
	switch(TIMES)
	{
	case SINGLE:
		{   
			des_key(&dc,key,0);
			scrunch(inblock,work);
			if( MODE == ENC )
				desfunc(work,pdc->ek[0]);
			else
				desfunc(work,pdc->dk[0]);
			unscrun(work,outblock);
			break;
		}
	case TRIPLE:
		{
			des_key(&dc,key,0);
			des_key(&dc,key+8,1);
			scrunch(inblock,work);
			if( MODE == ENC )
			{
				desfunc(work,pdc->ek[0]);
				desfunc(work,pdc->dk[1]);
				desfunc(work,pdc->ek[0]);
			}
			else
			{
				desfunc(work,pdc->dk[0]);
				desfunc(work,pdc->ek[1]);
				desfunc(work,pdc->dk[0]);
			}
			unscrun(work,outblock);
			break;
		}   
	}
}
/******************************************************************************************
 *function is 3des block Encryts or Descrypts.
 *void trides_blocks(S8 MODE,S8 blocks,S8 *inblock,S8 *key,S8 *outblock);
 *Encrypts fill data *(block+4 = 0x80)follow is 00 00 00;
 *BlackCardCount ---> block = 1;	#define CARDCOUNT 1;
 *Black ASN -------> block = 13;	#define ASN 13;
 *Input Data 
 *	     	1,for Encrypts or Decrypts according to MODE ,ENC or DEC
 *			2,blocks 
 *	     	3,plaintext: one block of eight byte at address. 
 *     	 	4,key: if single is  8 byte at address.if triple is 16 byte at address.
 *	     	5,ciphertext: one block of eight byte at address. 
 *Output Data :ciphertext 
 *****************************************************************************************/
void trides_blocks(S8 MODE,S8 blocks,S8 *inblock,S8 *key,S8 *outblock)
{
	des_ctx dc,*pdc;
	U32 work[2];
	S8 i;
	pdc = &dc;
	des_key(&dc,key,0);
	des_key(&dc,key+8,1);
	if(MODE == ENC)
	{
		*(inblock + (blocks-1)*8 + 4) = 0x80;
		for(i = 0; i < 3; i++)
			*(inblock + (blocks-1)*8 + 5 + i) = 0;
	}
	for(i = 0; i < blocks; i++)
	{
		scrunch((inblock+i*8),work);
		if( MODE == ENC )
		{
			desfunc(work,pdc->ek[0]);
			desfunc(work,pdc->dk[1]);
			desfunc(work,pdc->ek[0]);
		}
		else
		{
			desfunc(work,pdc->dk[0]);
			desfunc(work,pdc->ek[1]);
			desfunc(work,pdc->dk[0]);
		}
		unscrun(work,(outblock+i*8));
	}
}

/******************************************************************************************
 *function is calculate MAC,
 *void calc_mac(S8 *inblock,S8 *key,S8 datlen,S8 *outblock)
 *Encrypts fill data *(block+4 = 0x80)follow is 00 00 00;
 *BlackCardCount ---> block = 1;	#define MACCNT 8;
 *Black ASN -------> block = 13;	#define MACASN 104;
 *Input Data 
 *	     	1,plaintext: one block of eight byte at address. 
 *     	 	2,key: if single is  8 byte at address.if triple is 16 byte at address.
 *			3,datalen IS MACCNT or MACASN,
 *	     	5,ciphertext: one block of eight byte at address. 
 *Output Data :MAC  
 *****************************************************************************************/
void xor_calc(S8 *inxor1,S8 *inxor2,S8 *outin)
{
	S8 i;
	for(i = 0; i < 8; i++)
	{
		*outin++ = (*inxor1++)^(*inxor2++);
	}
}
void calc_mac(S8 *inblock,S8 *key,S8 datalen,S8 *outblock)
{
	S8 i,j,k;
	S8 initdata[8] ={0,0,0,0,0,0,0,0},in[8];
	i = datalen/8;
	j = datalen%8;
	*(inblock + 8*i + j) = 0x80;
	for(k = 1; k < (8 - j); k++)
		*(inblock + 8*i + j + k) = 0;
	for(k = 0; k < (i+1); k++)
	{
		xor_calc(initdata,inblock + k*8,in);
		des_func(1,ENC,in,key,initdata);
	}
	des_func(1,DEC,initdata,key + 8,in);
	des_func(1,ENC,in,key,initdata);
	for(k = 0;k < 4;k++)
		*outblock++ = initdata[k];
}
/******************************************************************************************
 *function is calculate MAC,
 *void calc_mac(S8 *inblock,S8 *key,S8 datlen,S8 *outblock)
 *Encrypts fill data *(block+4 = 0x80)follow is 00 00 00;
 *BlackCardCount ---> block = 1;	#define MACCNT 8;
 *Black ASN -------> block = 13;	#define MACASN 104;
 *Input Data 
 *	     	1,plaintext: one block of eight byte at address. 
 *     	 	2,key: if single is  8 byte at address.if triple is 16 byte at address.
 *			3,datalen IS MACCNT or MACASN,
 *	     	5,ciphertext: one block of eight byte at address. 
 *Output Data :MAC  
 *****************************************************************************************/
S16 lbCmGetMac(S8 *buf,S8 len,S8 *key,U32 *Ret_mac)
{
	S8 i,j,k,*pTemp;
	S8 initdata[8] ={0,0,0,0,0,0,0,0},in[8];
	if(len == 0)
	{
		return(FALSE);
	}
	i = len/8;
	j = len%8;
	*(buf + 8*i + j) = 0x80;
	for(k = 1; k < (8 - j); k++)
		*(buf + 8*i + j + k) = 0;
	for(k = 0; k < (i+1); k++)
	{
		xor_calc(initdata,buf + k*8,in);
		des_func(1,ENC,in,key,initdata);
	}
	des_func(1,DEC,initdata,key + 8,in);
	des_func(1,ENC,in,key,initdata);
	pTemp = (S8 *)Ret_mac;
	for(k = 0;k < 4;k++)
		*(pTemp++) = initdata[k];
	return(TRUE);
}
S16 lbCmGetKey(S8 *buf,S8 *key,S8 *Ret_Ver)
{
	S8 i;
	S8 out[24];
	des_func(3,DEC,(S8 *)&buf[16],buf,out);
	des_func(3,DEC,(S8 *)&buf[24],buf,(S8 *)&out[8]);
	des_func(3,DEC,(S8 *)&buf[32],buf,(S8 *)&out[16]);
	for(i=0; i<16; i++)
		*(key++) = out[1+i];
	*Ret_Ver = out[17];
	if(out[17] > 3)
	{
		return(RFAILED);
	}
	return(ROK);
}
S16 lbCmUnsecret(S8 *buf, S8 *key,U32 len, U32 *Ret_len)
{
	U32 temp = 0;
	U32 blocks;
	U32 i,j;
	U8 inblock[108];
	U8 outblock[108];

	j = len%8;
	if(j != 0)
		return(FALSE);
	for(i=0; i<len; i++)
	{
		inblock[i] = *(buf++);
	}
	blocks = len/8;

	for(i = 0; i < blocks; i++)
	{
		des_func(3,1,&inblock[i*8],key,&outblock[i*8]);
	}
	buf = buf - len;
	for(i=0; i<len; i++)
	{
		*(buf++) = outblock[1+i];
	}
	temp = (U32)(outblock[0]);
	*Ret_len = temp;
	if(outblock[0] == 0)
		return(RFAILED);
	return(ROK);   
}
S16 lbCmChkMacVer(S8 *buf, S8 *key,U32 len, U8 Ver)
{
	U32 Ret_mac;
	U32 mac_cmp;
	U32 i;
	S8  *p;
	S8  mac_Ver;

	if(len < 5)
	{
		RETVALUE(RFAILED);
	}

	p=(S8 *)malloc(len);
	if(p == 0)
		return(FALSE);

	for(i=0; i<len; i++)
	{
		*(p++) = *(buf++);
	}

	p -= len;
	lbCmGetMac(p,len-5,key,&Ret_mac);

	mac_cmp = *((U32 *)(buf-5));
	if(mac_cmp != Ret_mac)
		return(FALSE);
	mac_Ver = *(buf-1);
	if(mac_Ver != Ver)
		return(RFAILED);
	return(ROK);
}

S16 lbCmChkMac(S8 *buf, S8 *key,U32 len)
{
	U32 Ret_mac;
	U32 mac_cmp;
	U32 i;
	S8  *p;

	if(len < 4)
	{
		RETVALUE(RFAILED);
	}

	p=(S8 *)malloc(len);
	if(p == 0)
		return(FALSE);

	for(i=0; i<len; i++)
	{
		*(p++) = *(buf++);
	}

	p -= len;
	lbCmGetMac(p,len-5,key,&Ret_mac);

	mac_cmp = *((U32 *)(buf-5));
	if(mac_cmp != Ret_mac)
		return(FALSE);
	return(ROK);
}



S16 lbCmFillMac(S8 *buf, S8 *key,U32 len, S8 Ver)
{
	S8  i;
	S8  *p,*psrc;
	U32 Ret_mac;

	lbCmGetMac(buf,len-5,key,&Ret_mac);

	p = (S8 *)&Ret_mac;
	psrc = buf+len-5;
	for(i=0; i<4; i++)
		*(psrc++) = *(p++) ;
	*psrc = Ver;
	return(ROK);
}