des.h

DES 加密解密代码实例

void turntoB(int B[],char word[],int length)			//将字符转换位64比特二进制数	OK
{
	int g,h,t;
	for(g=0;g<length*8;g++)
	{
		B[g]=0;
	}
	for(g=0;g<length;g++)
	{
		t=int(word[g]);
		if(t==0);
		else
		{
			for(h=7;t!=1;h--)
			{
				B[g*8+h]=t%2;
				t=(t-B[g*8+h])/2;
			}
			B[g*8+h]=1;
		}
	}
}

void turntoCH(char word[],int B[],int length)				//将二进制数转换成字符形式	OK
{
	for(int f=0;f<length;f++)
		word[f]=char(B[f*8]*128+B[f*8+1]*64+B[f*8+2]*32+B[f*8+3]*16+B[f*8+4]*8+B[f*8+5]*4+B[f*8+6]*2+B[f*8+7]);
	word[f]='\0';
}

void selectC(int c[],int b[])				//得到C		OK
{
	for(int i=27,j=0;i>=0;i--,j++)			
		c[i]=b[(35+j*8)%65];
}

void selectD(int d[],int b[])				//得到D		OK
{
	d[27]=b[3];						
	d[26]=b[11];
	d[25]=b[19];
	d[24]=b[27];
	for(int i=23,j=0;i>=0;i--,j++)
		d[i]=b[(4+j*8)%63];
}

void shift_left(int a[],int length)			//循环左移1位	OK
{
	int temp=a[0];
	for(int i=0;i<length-1;i++)
		a[i]=a[i+1];
	a[length-1]=temp;
}

void EtoK(int e[],int k[])				//由E生成Ki		OK
{
	k[0]=e[13];
	k[1]=e[16];
	k[2]=e[10];
	k[3]=e[23];
	k[4]=e[0];
	k[5]=e[4];
	k[6]=e[2];
	k[7]=e[27];
	k[8]=e[14];
	k[9]=e[5];
	k[10]=e[20];
	k[11]=e[9];
	k[12]=e[22];
	k[13]=e[18];
	k[14]=e[11];
	k[15]=e[3];
	k[16]=e[25];
	k[17]=e[7];
	k[18]=e[15];
	k[19]=e[6];
	k[20]=e[26];
	k[21]=e[19];
	k[22]=e[12];
	k[23]=e[1];
	k[24]=e[40];
	k[25]=e[51];
	k[26]=e[30];
	k[27]=e[36];
	k[28]=e[46];
	k[29]=e[54];
	k[30]=e[29];
	k[31]=e[39];
	k[32]=e[50];
	k[33]=e[44];
	k[34]=e[32];
	k[35]=e[47];
	k[36]=e[43];
	k[37]=e[48];
	k[38]=e[38];
	k[39]=e[55];
	k[40]=e[33];
	k[41]=e[52];
	k[42]=e[45];
	k[43]=e[41];
	k[44]=e[49];
	k[45]=e[35];
	k[46]=e[28];
	k[47]=e[31];
}

void exchange_start(int A[],int B[])		//初始换位函数	OK
{
	int m,n;
	for(m=0,n=0;m<8;m++,n++)
	{
		A[m]=B[57-n*8];
		A[m+8]=B[59-n*8];
		A[m+16]=B[61-n*8];
		A[m+24]=B[63-n*8];
		A[m+32]=B[56-n*8];
		A[m+40]=B[58-n*8];
		A[m+48]=B[60-n*8];
		A[m+56]=B[62-n*8];
	}
}

void exchange_end(int b[],int a[])			//逆初始换位函数	OK
{
	for(int m=0;m<8;m++)
	{
		b[m*8]=a[39-m];
		b[m*8+1]=a[7-m];
		b[m*8+2]=a[47-m];
		b[m*8+3]=a[15-m];
		b[m*8+4]=a[55-m];
		b[m*8+5]=a[23-m];
		b[m*8+6]=a[63-m];
		b[m*8+7]=a[31-m];
	}
}

void expansion(int p[],int r[])			//扩充函数		OK
{
	p[0]=r[31];
	p[1]=r[0];
	p[2]=r[1];
	p[3]=r[2];
	p[4]=r[3];
	p[5]=r[4];
	p[6]=r[3];
	p[7]=r[4];
	p[8]=r[5];
	p[9]=r[6];
	p[10]=r[7];
	p[11]=r[8];
	p[12]=r[7];
	p[13]=r[8];
	p[14]=r[9];
	p[15]=r[10];
	p[16]=r[11];
	p[17]=r[12];
	p[18]=r[11];
	p[19]=r[12];
	p[20]=r[13];
	p[21]=r[14];
	p[22]=r[15];
	p[23]=r[16];
	p[24]=r[15];
	p[25]=r[16];
	p[26]=r[17];
	p[27]=r[18];
	p[28]=r[19];
	p[29]=r[20];
	p[30]=r[19];
	p[31]=r[20];
	p[32]=r[21];
	p[33]=r[22];
	p[34]=r[23];
	p[35]=r[24];
	p[36]=r[23];
	p[37]=r[24];
	p[38]=r[25];
	p[39]=r[26];
	p[40]=r[27];
	p[41]=r[28];
	p[42]=r[27];
	p[43]=r[28];
	p[44]=r[29];
	p[45]=r[30];
	p[46]=r[31];
	p[47]=r[0];
}

void xor(int m[],int n[],int length)		//数组异或		OK	
{
	for(int f=0;f<length;f++)
	{
		if(m[f]==n[f])
			m[f]=0;
		else
			m[f]=1;
	}
}

void table(int x[],int p[])				//查表替代函数		OK
{
	int m,n,q;
	int s[8][4][16]={{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
	{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
	{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
	{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
	{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
	{3,13,4,7,15,2,8,15,12,0,1,10,6,9,11,5},
	{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
	{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
	{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
	{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
	{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
	{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
	{{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
	{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
	{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
	{3,15,0,6,10,10,13,8,9,4,5,11,12,7,2,14}},
	{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
	{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
	{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
	{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
	{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
	{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
	{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
	{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
	{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
	{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
	{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
	{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
	{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
	{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
	{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
	{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
	for(int i=0;i<32;i++)
	{
		x[i]=0;
	}
	for(int w=0;w<8;w++)
	{
		m=p[w*6]*2+p[w*6+5];
		n=p[w*6+1]*8+p[w*6+2]*4+p[w*6+3]*2+p[w*6+4];
		q=s[w][m][n];
		if(q==0);
		else
		{
			for(i=3;q!=1;i--)
			{
				x[w*4+i]=q%2;
				q=(q-x[w*4+i])/2;
			}
			x[w*4+i]=1;
		}
	}
}

void P(int x[])					//换位函数P OK
{
	int v[32];
	for(int i=0;i<32;i++)
		v[i]=x[i];
	x[0]=v[15];
	x[1]=v[6];
	x[2]=v[19];
	x[3]=v[20];
	x[4]=v[28];
	x[5]=v[11];
	x[6]=v[27];
	x[7]=v[16];
	x[8]=v[0];
	x[9]=v[14];
	x[10]=v[22];
	x[11]=v[25];
	x[12]=v[4];
	x[13]=v[17];
	x[14]=v[30];
	x[15]=v[9];
	x[16]=v[1];
	x[17]=v[7];
	x[18]=v[23];
	x[19]=v[13];
	x[20]=v[31];
	x[21]=v[26];
	x[22]=v[2];
	x[23]=v[8];
	x[24]=v[18];
	x[25]=v[12];
	x[26]=v[29];
	x[27]=v[5];
	x[28]=v[21];
	x[29]=v[10];
	x[30]=v[3];
	x[31]=v[24];
}


void DES_encryption(char m[],int miwen[],char key[],int length)
{
	int i,index;
	int a[64],b[64],c[28],d[28],l[32],r[32],store[32],p[48],x[32],e[56],k1[48],k2[48],k3[48],k4[48],k5[48],k6[48],k7[48],k8[48],k9[48],k10[48],k11[48],k12[48],k13[48],k14[48],k15[48],k16[48];
	char temp[9];
	turntoB(b,key,8);			//得到初始64比特密钥
	selectC(c,b);
	selectD(d,b);
	/////////////////////////////////////取得K1
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k1);
//	for(i=0;i<48;i++)
//		cout<<k1[i];
//	cout<<endl;
	/////////////////////////////////////取得K2
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k2);
	/////////////////////////////////////取得K3
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k3);
	/////////////////////////////////////取得K4
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k4);
	/////////////////////////////////////取得K5
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k5);
	/////////////////////////////////////取得K6
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k6);
	/////////////////////////////////////取得K7
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k7);
	/////////////////////////////////////取得K8
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k8);
	/////////////////////////////////////取得K9
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k9);
	/////////////////////////////////////取得K10
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k10);
	/////////////////////////////////////取得K11
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k11);
	/////////////////////////////////////取得K12
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k12);
	/////////////////////////////////////取得K13
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k13);
	/////////////////////////////////////取得K14
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k14);
	/////////////////////////////////////取得K15
	shift_left(c,28);
	shift_left(d,28);
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k15);
	/////////////////////////////////////取得K16
	shift_left(c,28);
	shift_left(d,28);
	for(i=0;i<28;i++)
		e[i]=c[i];
	for(i=0;i<28;i++)
		e[28+i]=d[i];
	EtoK(e,k16);
	/////////////////////密钥处理完毕

	if (length!=64)			//补位使明文字符数为8的倍数
	{
		for(i=0;i<64-length;i++)
		{
			m[length+i]=char(65+i);
		}
		m[64]='\0';
	}


	///////////////////////明文处理阶段

	for(index=0;index<64;index+=8)	//将明文分块
	{
		for(i=0;i<8;i++)
			temp[i]=m[index+i];
		turntoB(b,temp,8);
		exchange_start(a,b);		//初始换位
		for(i=0;i<32;i++)			//得到L和R
		{	
			l[i]=a[i];
			r[i]=a[32+i];
		}
		/////////////////第1次运算
		for(i=0;i<32;i++)
			store[i]=r[i];
		expansion(p,r);
		xor(p,k1,48);
		table(x,p);
		P(x);
		xor(x,l,32);
		for(i=0;i<32;i++)
			r[i]=x[i];
		for(i=0;i<32;i++)
			l[i]=store[i];
		/////////////////第2次运算
		for(i=0;i<32;i++)
			store[i]=r[i];
		expansion(p,r);
		xor(p,k2,48);
		table(x,p);
		P(x);
		xor(x,l,32);
		for(i=0;i<32;i++)
			r[i]=x[i];
		for(i=0;i<32;i++)
			l[i]=store[i];
		/////////////////第3次运算
		for(i=0;i<32;i++)
			store[i]=r[i];
		expansion(p,r);
		xor(p,k3,48);
		table(x,p);
		P(x);
		xor(x,l,32);
		for(i=0;i<32;i++)
			r[i]=x[i];
		for(i=0;i<32;i++)
			l[i]=store[i];
		/////////////////第4次运算
		for(i=0;i<32;i++)
			store[i]=r[i];
		expansion(p,r);
		xor(p,k4,48);
		table(x,p);
		P(x);
		xor(x,l,32);
		for(i=0;i<32;i++)
			r[i]=x[i];
		for(i=0;i<32;i++)
			l[i]=store[i];
		/////////////////第5次运算
		for(i=0;i<32;i++)