DES原理学习以及C语言实现（三）

三、子密钥Ki及获取

子密钥的获取主要通过置换和移位运算得到。

DES的密钥长度时64位，由用户输入。但参与加密的只有56位。用户输入的64位按照8*8矩阵排列，把其中每行的第8个用于奇偶检验。

经过一系列的置换和移位得到K1~K16共16个子密钥。每个密钥长度是48位（压缩过后的）。其每个子密钥实现过程如下：

1、首先将输入的64位密钥按照8*8排列，将每行第8个去掉。

2、然后对剩下的56位按照PC-1表置换。其置换方法跟IP方法类似。PC-1表如下：

                                                        表一

有上表可知，第8，16，24，32，40，48，56，64位的检验位去掉了。剩下的按照上表置换规则进行置换。

3、移位。置换后，将将输出分为前28位C0和后28位D0两部分。上一轮置换得到的输出的两部分经过循环左移1位或者2位之后（每轮按照表3进行移位），然后将两份合成56位。

                        表二

4、压缩置换得到48位子密钥。PC-2置换，也就是压缩置换，输出比输入短，及运算过程中，将某些位的数据去掉了。将原来的8行7列压缩成8行6列48位数据。置换规则按照下表。也有下表可知，第9，18，22，25，35，38，43，54位被去掉了。下下表置换后的数据就是密钥K1。

5、同时，上一轮的两部分，在按照表三进行移位，压缩得到密钥Ki。一共经过16轮。

总体来说，密钥获取过程就是如此，原理不复杂。

把前面的代码也是放在一起的，这部分的代码有以下：

1、将用户输入的密钥转化为二进制：void *toKeytBinary(char *key)

2、将二进制通过PC-1置换：void displace()

3、第n次移位后：void leftShift(int n)

4、压缩得到密钥：void condenseBinary(int n)

C语言实现：

#include<stdio.h>
#include<stdlib.h>//要使用malloc是要包含此头文件
#include <memory.h>//要使用memset是要包含此头文件

int plaintextBinary[64];  //明文二进制
int inputBinary[64]; 
char keyBinary64[64];    //二进制key
char temporary[56]={0};  //置换过后的key 以及第n轮移位后的key
char keyBinary56[16][64];  //i轮的子密钥
char subKeyBinary[16][48];  //子密钥
// 正向置换表
int DES_IP[] = 
{
	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 DES_NIP[] = 
{
	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
};
//PC-1置换表
int DES_PC_1[]=
{
	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 shift[]=
{
	1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
//压缩表PC-2
int condense[]=
{
	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
};

//将用户的输入转换位二进制
void *toPlainTextBinary(char *p)
{
	int temp;  //临时存放
	int a =1;  //二进制时的余数
	int m=0;
	int i,j,k;  //用于循环
	int b[8]={0};  //存放每个字符二进制
	printf("\n");
	for(i =0;i<8;i++)
	{
		temp = p[i];
		for(j=0;j<8;j++)
		{
			a=(int)temp%2;
			temp=temp/2;
			b[j]=a;
		}
		for(j=7;j>=0;j--)
		{
			inputBinary[m++]=b[j];
		}
	}
	printf("该数二进制为:");
	for(j=0;j<64;j++)
	{
		if(j%8==0)
			printf("\n");
		printf("%d",inputBinary[j]);
	}
	printf("\n");
}


//将用户的输入的密钥转换位二进制
void *toKeytBinary(char *key)
{
	int temp;  //临时存放
	int a =1;  //二进制时的余数
	int m=0;
	int i,j,k;  //用于循环
	int b[8]={0};  //存放每个字符二进制
	printf("\n");
	for(i =0;i<8;i++)
	{
		temp = key[i];
		for(j=0;j<8;j++)
		{
			a=(int)temp%2;
			temp=temp/2;
			b[j]=a;
		}
		for(j=7;j>=0;j--)
		{
			keyBinary64[m++]=b[j];
		}
	}
	printf("该数二进制为:");
	for(j=0;j<64;j++)
	{
		if(j%8==0)
			printf("\n");
		printf("%d",keyBinary64[j]);
	}
	printf("\n");
}

//置换函数PC-1
void displace()
{
	int i,j=0,m=0;
	//置换
	for(i=0;i<56;i++)
	{
		temporary[i]=keyBinary64[DES_PC_1[i]-1];
	}
	printf("PC-1置换后的key:");
	for(i=0;i<56;i++)
	{
		if(i%7==0)
			printf("\n");
		printf("%d",temporary[i]);
	}
	printf("\n");
}

//压缩 得到的结果就是密钥Ki
void condenseBinary(int n)
{
	int i;
	for(i=0;i<48;i++)
	{
		subKeyBinary[n][i]=temporary[condense[i]-1];
	}
	printf("\n第%d轮子密钥：\n",n);
	for(i=0;i<48;i++)
	{
		if(i%6==0&&i!=0)
			printf("\n");
		printf("%d",subKeyBinary[n][i]);
	}
}

//第n次移位运算  得到的结果是压缩置换的输入即两部分经过移位后合在一起
void leftShift(int n)
{
	int i;
	//保存前两个数据  这里是分成里前后两个部分
	int temporary0=temporary[0];
	int temporary1=temporary[1];
	int temporary28=temporary[28];
	int temporary29=temporary[29];
	for(i=0;i<28;i++)
	{
		temporary[i]=temporary[i+shift[n-1]];
		if(i>=26)
			continue;
		temporary[i+28]=temporary[i+shift[n-1]+28];
	}
	if(shift[n-1]==1)
	{
		temporary[27]=temporary0;
		temporary[55]=temporary28;
	}
	else if(shift[n-1]==2)
	{
		temporary[26]=temporary0;
		temporary[27]=temporary1;
		temporary[54]=temporary28;
		temporary[55]=temporary29;
	}

	printf("\n第%d轮移位后的：",n);
	for(i=0;i<56;i++)
	{
		if(i%7==0)
			printf("\n");
		printf("%d",temporary[i]);
	}
}
//PKCS7Padding  填充方式
//对加密数据字节长度对8取余为r，如r大于0，
//则补8-r个字节，字节为8-r的值；如果r等于0，则补8个字节8。
//比如：
//加密字符串为为AAA，则补位为AAA55555;
//加密字符串为BBBBBB，则补位为BBBBBB22；
//加密字符串为CCCCCCCC，则补位为CCCCCCCC88888888
//在这里为了简单，如果r=0，就不补充
char *Padding(char *p,int m)
{
	int n=8-m;
	int i;
	if(m==8)
		return p;
	else
	{
		for(i=m;i<8;i++)
		{
			p[i]=(char)('0'+n);  
		}
		printf("\n填充过后的：");
		for (i=0;i<8;i++)//数组赋值
		{
			printf("%c",p[i]);
		}
		return p;
	}
}

//置换函数IP
void IP()
{
	int i;
	printf("IP置换后的明文：\n");
	for(i=0;i<64;i++)
	{
		plaintextBinary[i]=inputBinary[DES_IP[i]-1];
	}
	for(i=0;i<64;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",plaintextBinary[i]);

	}
}
int main()
{
	int m;  //为方便  只能输入英文且为8个以内 
	int i;  //用作循环
	char *p;
	char *key;

	//用户输入的密钥
	//可以是64个0 1数字，越随机越安全   为方便直接设置与明文一样的八个字节的英文字母 
	//超出只取前8个
	printf("输入密钥（8个字母或者数字）：");
	key=(char*)malloc(10*(sizeof(char)));
	memset(key,0,10);
	gets(key);
	printf("密钥：%s",key);
	toKeytBinary(key);
	displace();
	for(i=0;i<16;i++)
	{
		leftShift(i+1);
		condenseBinary(i+1);
	}





	//用户输入的要加密的明文
	printf("\n你要加密的英文字母或者数字个数（8个以内）：");
	scanf("%d",&m);//scanf只是遇到回车符的时候结束，并没有把回车符输入，因此输入流中还有一个回车符
	getchar();//把输入流中的回车符读走
	p = (char*)malloc(8*(sizeof(char)));//动态申请内存
	memset(p,0,8);//初始化，每个元素都为零
	for (i=0;i<m; i++)//数组赋值
	{
		scanf("%c",&p[i]);
	}
	for (i=0;i<8;i++)//数组赋值
	{
		printf("%c",p[i]);
	}
	toPlainTextBinary(Padding(p,m));
	IP();



	free(p);
	free(key);
	return 0;
}