/*=============================================================*/
/*            Name : DES(Data Ecryption Standard) C Function   */
/*         Version : 0.2                                       */
/*            Type : Freeware                                  */
/*      OS/Dev tool: Dos/Turbo C & Linux/GNU cc                */
/*      Progeammer : Atan                                      */
/*            Date : 1998-03-03                                */
/*             Tel : 1391135095 65245577(call)9735             */
/*          E_mail : ic@advanceic.com                          */
/*             WWW : http://www.advanceic.com                  */
/*=============================================================*/
/*                      << Useage >>                           */
/* endes(*Uncryption data,*password,*Encryption data)          */
/* undes(*Encryption date,*password,*Uncryption data)          */
/*                      <<  NOTE  >>                           */
/* 1.Uncryption is must = 8byte(64bit)                         */
/* 2.Encryption is must = 8byte(64bit)                         */
/* 3.Password(key) is must = 8byte(64bit)                      */
/* 4.Please include the head file(des.h) in your program.      */
/* 5.If you have a big file or data block , you can call endes */
/*   and undes function many times by 8 byte data.             */
/* 6.Good luck!!!    8-)                                       */
/*=============================================================*/

/*----------------------------------------------------*/
/*                     byte2bit                       */
/*----------------------------------------------------*/
unsigned char *byte2bit(unsigned char byte[64] , unsigned char bit[8])
/*change 64byte to 64bit(8byte)*/
{
int i = 0 ;

	/*byte1*/
	for(i = 0;i <= 7;i++)
	{
		if(byte[0] == 0x1) bit[0] = bit[0] | 0x80 ;
		else bit[0] = bit[0] & 0x7f ;
		if(byte[1] == 0x1) bit[0] = bit[0] | 0x40 ;
		else bit[0] = bit[0] & 0xbf ;
		if(byte[2] == 0x1) bit[0] = bit[0] | 0x20 ;
		else bit[0] = bit[0] & 0xdf ;
		if(byte[3] == 0x1) bit[0] = bit[0] | 0x10 ;
		else bit[0] = bit[0] & 0xef ;
		if(byte[4] == 0x1) bit[0] = bit[0] | 0x08 ;
		else bit[0] = bit[0] & 0xf7 ;
		if(byte[5] == 0x1) bit[0] = bit[0] | 0x04 ;
		else bit[0] = bit[0] & 0xfb ;
		if(byte[6] == 0x1) bit[0] = bit[0] | 0x02 ;
		else bit[0] = bit[0] & 0xfd ;
		if(byte[7] == 0x1) bit[0] = bit[0] | 0x01 ;
		else bit[0] = bit[0] & 0xfe ;
	}
	/*byte2*/
	for(i = 8;i <= 15;i++)
	{
		if(byte[8] == 0x1) bit[1] = bit[1] | 0x80 ;
		else bit[1] = bit[1] & 0x7f ;
		if(byte[9] == 0x1) bit[1] = bit[1] | 0x40 ;
		else bit[1] = bit[1] & 0xbf ;
		if(byte[10] == 0x1) bit[1] = bit[1] | 0x20 ;
		else bit[1] = bit[1] & 0xdf ;
		if(byte[11] == 0x1) bit[1] = bit[1] | 0x10 ;
		else bit[1] = bit[1] & 0xef ;
		if(byte[12] == 0x1) bit[1] = bit[1] | 0x08 ;
		else bit[1] = bit[1] & 0xf7 ;
		if(byte[13] == 0x1) bit[1] = bit[1] | 0x04 ;
		else bit[1] = bit[1] & 0xfb ;
		if(byte[14] == 0x1) bit[1] = bit[1] | 0x02 ;
		else bit[1] = bit[1] & 0xfd ;
		if(byte[15] == 0x1) bit[1] = bit[1] | 0x01 ;
		else bit[1] = bit[1] & 0xfe ;
	}
	/*byte3*/
	for(i = 16;i <= 23 ;i++)
	{
		if(byte[16] == 0x1) bit[2] = bit[2] | 0x80 ;
		else bit[2] = bit[2] & 0x7f ;
		if(byte[17] == 0x1) bit[2] = bit[2] | 0x40 ;
		else bit[2] = bit[2] & 0xbf ;
		if(byte[18] == 0x1) bit[2] = bit[2] | 0x20 ;
		else bit[2] = bit[2] & 0xdf ;
		if(byte[19] == 0x1) bit[2] = bit[2] | 0x10 ;
		else bit[2] = bit[2] & 0xef ;
		if(byte[20] == 0x1) bit[2] = bit[2] | 0x08 ;
		else bit[2] = bit[2] & 0xf7 ;
		if(byte[21] == 0x1) bit[2] = bit[2] | 0x04 ;
		else bit[2] = bit[2] & 0xfb ;
		if(byte[22] == 0x1) bit[2] = bit[2] | 0x02 ;
		else bit[2] = bit[2] & 0xfd ;
		if(byte[23] == 0x1) bit[2] = bit[2] | 0x01 ;
		else bit[2] = bit[2] & 0xfe ;
	}
	/*byte4*/
	for(i = 24;i <= 31 ;i++)
	{
		if(byte[24] == 0x1) bit[3] = bit[3] | 0x80 ;
		else bit[3] = bit[3] & 0x7f ;
		if(byte[25] == 0x1) bit[3] = bit[3] | 0x40 ;
		else bit[3] = bit[3] & 0xbf ;
		if(byte[26] == 0x1) bit[3] = bit[3] | 0x20 ;
		else bit[3] = bit[3] & 0xdf ;
		if(byte[27] == 0x1) bit[3] = bit[3] | 0x10 ;
		else bit[3] = bit[3] & 0xef ;
		if(byte[28] == 0x1) bit[3] = bit[3] | 0x08 ;
		else bit[3] = bit[3] & 0xf7 ;
		if(byte[29] == 0x1) bit[3] = bit[3] | 0x04 ;
		else bit[3] = bit[3] & 0xfb ;
		if(byte[30] == 0x1) bit[3] = bit[3] | 0x02 ;
		else bit[3] = bit[3] & 0xfd ;
		if(byte[31] == 0x1) bit[3] = bit[3] | 0x01 ;
		else bit[3] = bit[3] & 0xfe ;
	}
	/*byte5*/
	for(i = 32;i <= 39 ;i++)
	{
		if(byte[32] == 0x1) bit[4] = bit[4] | 0x80 ;
		else bit[4] = bit[4] & 0x7f ;
		if(byte[33] == 0x1) bit[4] = bit[4] | 0x40 ;
		else bit[4] = bit[4] & 0xbf ;
		if(byte[34] == 0x1) bit[4] = bit[4] | 0x20 ;
		else bit[4] = bit[4] & 0xdf ;
		if(byte[35] == 0x1) bit[4] = bit[4] | 0x10 ;
		else bit[4] = bit[4] & 0xef ;
		if(byte[36] == 0x1) bit[4] = bit[4] | 0x08 ;
		else bit[4] = bit[4] & 0xf7 ;
		if(byte[37] == 0x1) bit[4] = bit[4] | 0x04 ;
		else bit[4] = bit[4] & 0xfb ;
		if(byte[38] == 0x1) bit[4] = bit[4] | 0x02 ;
		else bit[4] = bit[4] & 0xfd ;
		if(byte[39] == 0x1) bit[4] = bit[4] | 0x01 ;
		else bit[4] = bit[4] & 0xfe ;
	}
	/*byte6*/
	for(i = 40;i <= 47 ;i++)
	{
		if(byte[40] == 0x1) bit[5] = bit[5] | 0x80 ;
		else bit[5] = bit[5] & 0x7f ;
		if(byte[41] == 0x1) bit[5] = bit[5] | 0x40 ;
		else bit[5] = bit[5] & 0xbf ;
		if(byte[42] == 0x1) bit[5] = bit[5] | 0x20 ;
		else bit[5] = bit[5] & 0xdf ;
		if(byte[43] == 0x1) bit[5] = bit[5] | 0x10 ;
		else bit[5] = bit[5] & 0xef ;
		if(byte[44] == 0x1) bit[5] = bit[5] | 0x08 ;
		else bit[5] = bit[5] & 0xf7 ;
		if(byte[45] == 0x1) bit[5] = bit[5] | 0x04 ;
		else bit[5] = bit[5] & 0xfb ;
		if(byte[46] == 0x1) bit[5] = bit[5] | 0x02 ;
		else bit[5] = bit[5] & 0xfd ;
		if(byte[47] == 0x1) bit[5] = bit[5] | 0x01 ;
		else bit[5] = bit[5] & 0xfe ;
	}
	/*byte7*/
	for(i = 48;i <= 55 ;i++)
	{
		if(byte[48] == 0x1) bit[6] = bit[6] | 0x80 ;
		else bit[6] = bit[6] & 0x7f ;
		if(byte[49] == 0x1) bit[6] = bit[6] | 0x40 ;
		else bit[6] = bit[6] & 0xbf ;
		if(byte[50] == 0x1) bit[6] = bit[6] | 0x20 ;
		else bit[6] = bit[6] & 0xdf ;
		if(byte[51] == 0x1) bit[6] = bit[6] | 0x10 ;
		else bit[6] = bit[6] & 0xef ;
		if(byte[52] == 0x1) bit[6] = bit[6] | 0x08 ;
		else bit[6] = bit[6] & 0xf7;
		if(byte[53] == 0x1) bit[6] = bit[6] | 0x04 ;
		else bit[6] = bit[6] & 0xfb ;
		if(byte[54] == 0x1) bit[6] = bit[6] | 0x02 ;
		else bit[6] = bit[6] & 0xfd ;
		if(byte[55] == 0x1) bit[6] = bit[6] | 0x01 ;
		else bit[6] = bit[6] & 0xfe ;
	}
	/*byte8*/
	for(i = 56;i <= 63 ;i++)
	{
		if(byte[56] == 0x1) bit[7] = bit[7] | 0x80 ;
		else bit[7] = bit[7] & 0x7f ;
		if(byte[57] == 0x1) bit[7] = bit[7] | 0x40 ;
		else bit[7] = bit[7] & 0xbf ;
		if(byte[58] == 0x1) bit[7] = bit[7] | 0x20 ;
		else bit[7] = bit[7] & 0xdf ;
		if(byte[59] == 0x1) bit[7] = bit[7] | 0x10 ;
		else bit[7] = bit[7] & 0xef ;
		if(byte[60] == 0x1) bit[7] = bit[7] | 0x08 ;
		else bit[7] = bit[7] & 0xf7 ;
		if(byte[61] == 0x1) bit[7] = bit[7] | 0x04 ;
		else bit[7] = bit[7] & 0xfb ;
		if(byte[62] == 0x1) bit[7] = bit[7] | 0x02 ;
		else bit[7] = bit[7] & 0xfd ;
		if(byte[63] == 0x1) bit[7] = bit[7] | 0x01 ;
		else bit[7] = bit[7] & 0xfe ;
	}
	return bit ;
}/*end of byte2bit*/

/*----------------------------------------------------*/
/*                     bit2byte                       */
/*----------------------------------------------------*/
unsigned char *bit2byte(unsigned char bit[8] , unsigned char byte[64])
/*change 64bit(8byte) to 64byte*/
{
int i=0 ;

	for(i=0 ; i<=63 ; i++)
	{
		byte[i] = 0x0 ;
	}
	for(i=0 ; i<=7 ; i++)
	{
		if((bit[i] & 0x80) == 0x80) byte[i*8+0] = 0x01 ;
		if((bit[i] & 0x40) == 0x40) byte[i*8+1] = 0x01 ;
		if((bit[i] & 0x20) == 0x20) byte[i*8+2] = 0x01 ;
		if((bit[i] & 0x10) == 0x10) byte[i*8+3] = 0x01 ;
		if((bit[i] & 0x08) == 0x08) byte[i*8+4] = 0x01 ;
		if((bit[i] & 0x04) == 0x04) byte[i*8+5] = 0x01 ;
		if((bit[i] & 0x02) == 0x02) byte[i*8+6] = 0x01 ;
		if((bit[i] & 0x01) == 0x01) byte[i*8+7] = 0x01 ;
	}
	return byte;
}/* end of bit2byte */

/*--------------------------------------------------*/
/*                  change the key                  */
/*--------------------------------------------------*/
keychange(unsigned char oldkey[8] , unsigned char newkey[16][8])
{
int i=0,j=0,k=0 ;
int pc_1[56] = {57,49,41,33,25,17,9,
		1,58,50,42,34,26,18,
		10,2,59,51,43,35,27,
		19,11,3,60,52,44,36,
		63,55,47,39,31,23,15,
		7,62,54,46,38,30,22,
		14,6,61,53,45,37,29,
		21,13,5,28,20,12,4} ;
int pc_2[48] = {14,17,11,24,1,5,
		3,28,15,6,21,10,
		23,19,12,4,26,8,
		16,7,27,20,13,2,
		41,52,31,37,47,55,
		30,40,51,45,33,48,
		44,49,39,56,34,53,
		46,42,50,36,29,32} ;
int ccmovebit[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1} ;
unsigned char oldkey_byte[64] ;
unsigned char oldkey_byte1[64] ;
unsigned char oldkey_byte2[64] ;
unsigned char oldkey_c[28] ;
unsigned char oldkey_d[28] ;
unsigned char cc_temp ;
unsigned char newkey_byte[16][64] ;

bit2byte(oldkey,oldkey_byte) ;/*change to byte*/
for(i=0;i<=55;i++) oldkey_byte1[i] = oldkey_byte[pc_1[i] - 1] ;/*goto PC-1*/
for(i=0;i<=27;i++) oldkey_c[i] = oldkey_byte1[i] ;/*move 28bit -> c0*/
for(i=28;i<=55;i++) oldkey_d[i -28] = oldkey_byte1[i] ;/*move other 28bit -> d0*/

/*cc_movebit : get c1-16,d1-16*/
for(i=0;i<=15;i++)
{
	for(j=1;j<=ccmovebit[i];j++)
	{
		cc_temp = oldkey_c[0] ; /*move out the first bit*/
		for(k=0;k<=26;k++)
		{
			oldkey_c[k] = oldkey_c[k+1] ;
		}
		oldkey_c[27] = cc_temp ; /*move the first bit to the last bit*/

		cc_temp = oldkey_d[0] ; /*move out the first bit*/
                for(k=0;k<=26;k++)
		{
			oldkey_d[k] = oldkey_d[k+1] ;
		}
		oldkey_d[27] = cc_temp ; /*move the first bit to the last bit*/
	}  /*cc_movebit*/
	/*goto pc-2 change bit*/
	for(k=0;k<=27;k++) oldkey_byte2[k] = oldkey_c[k] ;
	for(k=28;k<=55;k++) oldkey_byte2[k] = oldkey_d[k-28] ;
	/*add c(i)+d(i) -> for pc-2 change 56bit to 48bit k(i)*/
	for(k=0;k<=47;k++) newkey_byte[i][k] = oldkey_byte2[pc_2[k] - 1] ;

	/*ready to next k(i)*/
}/*end of one of change the 48bit key*/
/*byte to bit for 48bit newkey*/
for(i=0;i<=15;i++) byte2bit(newkey_byte[i],newkey[i]) ;
}/*end of keychange*/

/*--------------------------------------------------*/
/*                  data encryption                 */
/*--------------------------------------------------*/
endes(unsigned char m_bit[8] , unsigned char k_bit[8] , unsigned char e_bit[8])
{
int ip[64] = {  58,50,42,34,26,18,10,2,
		60,52,44,36,28,20,12,4,
		62,54,46,38,30,22,14,6,
		64,56,48,40,32,24,16,8,
		57,49,41,33,25,17,9,1,
		59,51,43,35,27,19,11,3,
		61,53,45,37,29,21,13,5,
		63,55,47,39,31,23,15,7
		} ;
int ip_1[64] = {40,8,48,16,56,24,64,32,
		39,7,47,15,55,23,63,31,
		38,6,46,14,54,22,62,30,
		37,5,45,13,53,21,61,29,
		36,4,44,12,52,20,60,28,
		35,3,43,11,51,19,59,27,
		34,2,42,10,50,18,58,26,
		33,1,41,9,49,17,57,25
		} ;