//DESProcess.cpp:implementation of the DESProcess class.
/////////////////////////////////////////////////////////////////////////////////////////////////
#include "DESProcess.h"
/////////////////////////////////////////////////////////////////////////////////////////////////
//Construction/Destruction
/////////////////////////////////////////////////////////////////////////////////////////////////
DESProcess::DESProcess()
{
}
DESProcess::~DESProcess()
{
}
DESProcess::chartobits(chars ch,bits *bts)
{
	int cnt1,cnt2,pos;
	for(cnt1=0;cnt1<ch.totalchar;cnt1++)
	{
		pos=int(ch.ch[cnt1]);
		pos=pos<0?pos+256:pos;
		pos=pos+28;
		for(cnt2=7;cnt2>=0;cnt2--)
		{
			bts->bit[cnt1*ch.totalchar+cnt2]=(pos%2!=0)?true:false;
			pos/=2;
		}
	}
	bts->totalbit=ch.totalchar*8;
}
DESProcess::bitstochar(bits bts,chars *ch)
{
	int cnt1,cnt2,pos,power;
	for(cnt1=0;cnt1<8;cnt1++)
	{
		pos=0;
		power=128;
		for(cnt2=0;cnt2<8;cnt2++)
		{
			if(bts.bit[cnt1*8+cnt2])pos+=power;
			power/=2;
		}
		ch->ch[cnt1]=char(pos-28);
	}
	ch->totalchar=bts.totalbit/8;
}

DESProcess::bitmaping(int bitmapno,bits inbts,bits *outbts)
{
	int cnt,mapsize;
	switch(bitmapno)
	{
	case 1: mapsize=64;break;
	case 2: mapsize=64;break;
	case 3: mapsize=48;break;
	case 4: mapsize=32;break;
	case 5: mapsize=56;break;
	case 6: mapsize=48;break;
	}
	outbts->totalbit=mapsize;
	for(cnt=0;cnt<mapsize;cnt++)
	{
		switch(bitmapno)
		{
		case 1: outbts->bit[cnt]=inbts.bit[ip[cnt]-1];break;
		case 2: outbts->bit[cnt]=inbts.bit[fp[cnt]-1];break;
		case 3: outbts->bit[cnt]=inbts.bit[e[cnt]-1];break;
		case 4: outbts->bit[cnt]=inbts.bit[p[cnt]-1];break;
		case 5: outbts->bit[cnt]=inbts.bit[pc1[cnt]-1];break;
		case 6: outbts->bit[cnt]=inbts.bit[pc2[cnt]-1];break;
		}
	}
}

DESProcess::InitIP(bits bts64,bits *Lbts32,bits *Rbts32)
{
	int cnt;
	bits tempbts;

	bitmaping(1,bts64,&tempbts);
	for(cnt=0;cnt<32;cnt++)
	{
		Lbts32->bit[cnt]=tempbts.bit[cnt];
		Rbts32->bit[cnt]=tempbts.bit[cnt+32];
	}
	Lbts32->totalbit=32;
	Rbts32->totalbit=32;
}

DESProcess::FinalIP(bits Lbts32,bits Rbts32,bits *bts64)
{
	int cnt;
	bits tempbts;
	for(cnt=0;cnt<32;cnt++)
	{
		tempbts.bit[cnt]=Lbts32.bit[cnt];
		tempbts.bit[cnt+32]=Rbts32.bit[cnt];
	}
	tempbts.totalbit=64;
	bitmaping(2,tempbts,bts64);
}

DESProcess::leftshift(bits *bit28,int times)
{
	bool lastbit;
	int cnt1,cnt2;
	for(cnt1=0;cnt1<times;cnt1++)
	{
		lastbit=bit28->bit[0];
		for(cnt2=0;cnt2<bit28->totalbit-1;cnt2++)
			bit28->bit[cnt2]=bit28->bit[cnt2+1];
		bit28->bit[bit28->totalbit-1]=lastbit;
	}
}

DESProcess::pc1tran(bits bts64,bits *Cbts28,bits *Dbts28)
{
	int cnt;
	bits tempbts;

	bitmaping(5,bts64,&tempbts);
	for(cnt=0;cnt<28;cnt++)
	{
		Cbts28->bit[cnt]=tempbts.bit[cnt];
		Dbts28->bit[cnt]=tempbts.bit[cnt+28];
	}
	Cbts28->totalbit=28;
	Dbts28->totalbit=28;
}

DESProcess::pc2tran(bits Cbts28,bits Dbts28,bits *Kbts48)
{
	int cnt;
	bits tempbts;
	for(cnt=0;cnt<28;cnt++)
	{
		tempbts.bit[cnt]=Cbts28.bit[cnt];
		tempbts.bit[cnt+28]=Dbts28.bit[cnt];
	}
	tempbts.totalbit=56;
	bitmaping(6,tempbts,Kbts48);
}

DESProcess::keygen(bits key,bitarray *subkey)
{
	bits Cbts28,Dbts28,Kbts48;
	int cnt;
	pc1tran(key,&Cbts28,&Dbts28);
	for(cnt=0;cnt<16;cnt++)
	{
		leftshift(&Cbts28,ls[cnt]);
		leftshift(&Dbts28,ls[cnt]);
		pc2tran(Cbts28,Dbts28,&Kbts48);
		subkey->bitarr[cnt]=Kbts48;
	}
}

DESProcess::etran(bits bts32,bits *bts48)
{
	bitmaping(3,bts32,bts48);
}

DESProcess::bitToSBoxPos(bits bts48,int boxno,int *row,int *col)
{
	*row=(bts48.bit[boxno*6]?2:0)+(bts48.bit[boxno*6+5]?1:0);
	*col=(bts48.bit[boxno*6+1]?8:0)+(bts48.bit[boxno*6+2]?4:0)+(bts48.bit[boxno*6+3]?2:0)+(bts48.bit[boxno*6+4]?1:0);
}

DESProcess::sboxtran(bits bts48,bits *bts32)
{
	int cnt1,cnt2,row,col,boxout;

	for(cnt1=0;cnt1<8;cnt1++)
	{
		bitToSBoxPos(bts48,cnt1,&row,&col);
		boxout=sbox[cnt1][row*16+col];
		for(cnt2=3;cnt2>=0;cnt2--)
		{
			bts32->bit[cnt1*4+cnt2]=(boxout%2!=0)?true:false;
			boxout/=2;
		}
	}
	bts32->totalbit=32;
}

DESProcess::ptran(bits bts32,bits *fout)
{
	bitmaping(4,bts32,fout);
}

DESProcess::ftran(bits inbts32,bits keyi,bits *fRes)
{
	bits bts48,bts32,xorRes48;

	etran(inbts32,&bts48);
	exclusiveOR(bts48,keyi,&xorRes48);
	sboxtran(xorRes48,&bts32);
	ptran(bts32,fRes);
}

DESProcess::exclusiveOR(bits bts1,bits bts2,bits *xorRes)
{
	int cnt;

	xorRes->totalbit=bts1.totalbit;
	for(cnt=0;cnt<bts1.totalbit;cnt++)
		xorRes->bit[cnt]=bts1.bit[cnt]^bts2.bit[cnt];
}

DESProcess::desblock(chars intext8,chars key,bool encode,chars *outtext8)
{
	int cnt,keypos;
	bits inbts,Lbts,Rbts,oldLbts;
	bits keybit,outbts,fRes;
	bitarray subkey;

	chartobits(intext8,&inbts);
	chartobits(key,&keybit);
	keygen(keybit,&subkey);

	InitIP(inbts,&Lbts,&Rbts);
	for(cnt=0;cnt<16;cnt++)
	{
		oldLbts=Lbts;
		Lbts=Rbts;
		keypos=encode?cnt:(15-cnt);
		ftran(Rbts,subkey.bitarr[keypos],&fRes);
		exclusiveOR(oldLbts,fRes,&Rbts);
	}
	FinalIP(Rbts,Lbts,&outbts);
	bitstochar(outbts,outtext8);
}

DESProcess::desEncode(char mfile[],char key[],char cfile[])
{
	desCoding(mfile,key,cfile,true);
}

DESProcess::desDecode(char mfile[],char key[],char cfile[])
{
	desCoding(mfile,key,cfile,false);
}

DESProcess::desCoding(char mfile[],char key[],char cfile[],bool codedir)
{
	int cnt1,cnt2;
	chars inch,inkey,outch;
	FILE *mfp;
	FILE *cfp;

	for(cnt1=0;cnt1<8;cnt1++)
		inkey.ch[cnt1]=key[cnt1];
	inkey.totalchar=8;

	if((mfp=fopen(mfile,"r"))==NULL)
	{cout<<"Cannot open the message file"<<endl;}
	else
	{
	cfp=fopen(cfile,"w");

	cnt1=0;
	inch.ch[cnt1]=fgetc(mfp);
	inch.totalchar=8;
	cnt2=0;
	while(!feof(mfp))
	{
		cnt1++;
		cnt2++;
		inch.ch[cnt1]=fgetc(mfp);
		if(cnt1==7)
		{
			desblock(inch,inkey,codedir,&outch);
			for(cnt1=0;cnt1<8;cnt1++)
				fputc(outch.ch[cnt1],cfp);
			cnt1=-1;
		}
	}
	cnt2=cnt2%8;
	if(cnt2!=0)
	{
		for(cnt1=0;cnt1<(8-cnt2);cnt1++)
			inch.ch[cnt1+cnt2]=' ';
		inch.totalchar=8;
		desblock(inch,inkey,codedir,&outch);
		for(cnt1=0;cnt1<8;cnt1++)
			fputc(outch.ch[cnt1],cfp);
	}
	fclose(mfp);
	fclose(cfp);
	}
}

DESProcess::dispfile(char fn[])
{
	FILE *fp;
	char ch;
	if((fp=fopen(fn,"r"))==NULL)
	{cout<<"Cannot open the file to display"<<endl;}
	else
	{
		while(!feof(fp))
		{
			ch=fgetc(fp);
			cout<<ch;
		}
		cout<<endl;
	}
}

float DESProcess::bitdiff(char mfile[],char cfile[],float *bitdiff8byte)
{
	FILE *mfp,*cfp;
	int ttch=0,xorRes,ttbitdiff=0;
	char mch,cch;
	float bdiff=0;

	if((mfp=fopen(mfile,"r"))==NULL)
	{cout<<"Cannot open the file to compare"<<endl;}
	if((cfp=fopen(cfile,"r"))==NULL)
	{cout<<"Cannot open the file to compare"<<endl;}
	else
	{
		while(!feof(mfp)&!feof(cfp))
		{
			ttch++;
			mch=fgetc(mfp);
			cch=fgetc(cfp);
			xorRes=mch^cch;
			ttbitdiff+=(xorRes&1)+(xorRes&2)/2+(xorRes&4)/4+(xorRes&8)/8+(xorRes&16)/16+(xorRes&32)/32+(xorRes&64)/64+(xorRes&128)/128;
		}
		bdiff=float(ttbitdiff)*100/float(ttch*8);
	}
	*bitdiff8byte=float(ttbitdiff)*100/float(8*8);
	return bdiff;
}