现代密码学之对称密码体制---DES

0x01 DES概述

 DES(Data Encryption Standard)，数据加密标准，曾被美国国家标准局确定为联邦信息处理标准，得到过广泛的使用。
 DES起源于1973年美国国家标准局征求国家密码标准方案，IBM提交的算法基于Lucifer的密码，Lucifer是一种feistel密码，使用128位的密钥对64位的分组进行加密，然后受NSA的影响，对Lucifer进行了一些修改，形成了之后的DES密码。
 

0x02 加密原理

 DES密码使用了Feistel网络，其加密过程和解密过程几乎完全相同，解密只需要一个逆向密钥编排。
 DES的加密过程如下：
 首先将64位的明文$x$进行初始置换IP，获得第一阶段的密文下$x_1$。之后将$x_1$分为左右长度相等的两部分$L_0$和$R_0$；然后将左右的两部分输入到Feistel网络中，进行16轮的加密。每一轮中右半部分的$R_i$将被送入函数$f$之中，$f$函数的输出再与左半部分的$L_i$进行$XOR$(异或)操作，左后，将左右两部分进行交换，得到新一轮的明文。数学公式可以表示如下：
$$L_i=R_i{-}_1$$
$$R_i=L_i{-}_1⨁f(R_i{-}_1,k_i)$$

其中，$i=1,...16$。值得注意的是DES的最后一轮加密不会交换$R_i$和$L_i$。
 在加密完成之后，DES还会进行一次逆初始置换IP，得到最后的密文。
 

0x03 步骤详解：

  0x0301 IP置换

 IP置换是按位置置，就是根据IP表的内容将明文的中的位置换掉，IP表可以排列为一行，而其中的数字就代表者明文的第几位，即将明文中相应的位放置到IP表内形成下一步的输入。
 初始置换IP和逆初始置换IP都是IP置换，$f$函数内部的扩充和置换以及轮密钥之中的置换都可以看作是IP置换。
 

  0x0302 $f$函数

  $f$函数在DES之中扮演着重要作用，$f$函数首先将输入的明文进行IP置换(扩展IP置换)，将32位的明文扩展为48位的明文，明文与轮密钥进行异或操作，再将输出分为8个6位的分组，将每个分组放入S-盒内部进行替换，再将新的输出进行一轮置换得到密文。流程如下图(不想画图了)：

 其中，S-盒是一个查找表，将6位输入映射为4位的输出，其映射规律如下：

将6位输入的第一位和最后一位提取出来，组成一个二进制数，代表S-盒之中的行，而中间四位则组成S-盒的列，查找到该数字之后再替换出来。
 

  0x0303 轮密钥

 在DES之中，每一轮的密钥都是不同的，是由输入的密钥通过置换产生的子密钥，其产生规则如下：

 DES输入的密钥有65位，但实际用到的就只有56位，将64位的密钥k输入之后，通过PC-1的IP置换，得到56位的新密钥$k_1$，再将56位新密钥分为$C_i$和$D_i$两部分，每轮变换之中，两部分分别循环左移，得到$k_i$，再将$k_i$进行PC-2的IP置换，得到48位的子密钥。
其左移规律如下：

轮数	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
左移位数	1	1	2	2	2	2	2	2	1	2	2	2	2	2	2	1

 

0x04 解密：

 DES的优势之一就是其解密过程与加密过程在本质上是相同的，解密只需要将密钥进行逆向编排就行。
 

参考书目：深入浅出密码学—Christof Paar，Jan Pelzl(马小婷译)

0x05 算法实现：

 c语言版本实现的DES算法，其输入的明文和密钥都是十六进制，输出也是十六进制，除了输入与输出，其余不变。

#include
#include
#include
#include
int  mint[64];
int  key[56];

int move_time[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

//初始置换 
int IP_first[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_last[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
};

//密钥置换选择1 
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,33,15,
    7,62,54,46,38,30,22,
    14,6,61,53,45,37,29,
    21,13,5,28,20,12,4
};

//密钥置换选择2 
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,//两个30？ 
    44,49,39,56,34,53,
    46,42,50,36,29,32
};

//扩展置换E
int E[48]=
{
    32,1,2,3,4,5,
    4,5,6,7,8,9,
    8,9,10,11,12,13,
    12,13,14,15,16,17,
    16,17,18,19,20,21,
    20,21,22,23,24,25,
    24,25,26,27,28,29,
    28,29,30,31,32,1
};

//扩展置换P
int P[32]=
{
    16,7,20,21,29,12,28,17,
    1,15,23,26,5,18,31,10,
    2,8,24,14,32,27,3,9,
    19,13,30,6,22,11,4,25
};

int S_Box[8][65]=
{
    {
        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,14,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,10,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,1,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
    }
};

//将输入字符转为数字 
int hex(char c){
	/*
		c ：单个字符 
	*/ 
	if(c>='0'&&c<='9') return c-'0';
	else return c-'A'+10;
}

//将数字转为字符 
char hex_re(int *C){
	/*
		C ：四位二进制数 
	*/ 
	int t = 0;
	for(int i=0; i<4; i++){
		t += pow(2, 3-i)*C[i];
	}
	if(t>=0 && t<=9) return t+'0';
	else return t-10+'A';
}

//读取明文字符串
void getstr(int *m){
	/*
		m ：64位明文 
	*/ 
	char mstr[18];
//	char mstr[] = "123456ABCD132536";
	printf("请输入明文(16进制)：");
	scanf("%s", mstr); 
	for(int i=0, j=0; i<64; i+=4, j++){
		int t = hex(mstr[j]);
		for(int k=0; k<4; k++){
			int temp = t%2;
			if(temp == 0) m[i+3-k] = 0;
			else m[i+3-k] = 1;
			t /= 2;
		}
	}
}

//读取密钥字符串 
void getkey(int *key_pre){
	/*
		key_pre ：64位密钥 
	*/ 
	char keystr[18];
//	char keystr[] = "AABB09182736CCDD";
	printf("请输入密钥(16进制)：");
	scanf("%s", keystr);
	for(int i=0, j=0; i<64; i+=4, j++){
		int t = hex(keystr[j]);
		for(int k=0; k<4; k++){
			int temp = t%2;
			if(temp == 0) key_pre[i+3-k] = 0;
			else key_pre[i+3-k] = 1;
			t /= 2;
		}
	}
}

//IP置换 
void exchangeIP(int *d, int *s, int *IP, int n){
	/*
		d ：置换后的二进制串
		s ：置换前的二进制串
		IP ：置换所用的IP表
		n ：d的长度 
	*/ 
	for(int i=0; i<n; i++){
		d[i] = s[IP[i]-1];
	}
}

//循环左移 
void shiftL(int *dest, int step){
	/*
		dest ：二进制串
		step ：左移位数 
	*/ 
	int temp[8];
	for(int i=0; i<step; i++) temp[i] = dest[i];
	for(int i=step; i<28; i++){
		dest[i-step] = dest[i];
	}
	for(int i=0; i<step; i++){
		dest[28-step+i] = temp[i];
	}
}

//获取轮密钥 
int * getroundkey(int *dest, int * k, int n){
	/*
		dest ：生成的48位轮密钥
		k ：原56位密钥
		n ：第几轮
		return ：生成的轮密钥 
	*/ 
	shiftL(k, move_time[n]);
	shiftL(k+28, move_time[n]);
	exchangeIP(dest, k, PC_2, 48);
	char C[18];
	return dest;	
}

//S盒替代 
void replaceS(int *dest, int *source, int n){
	/*
		dest ：s盒替代之后的二进制串
		source ：s盒替代之前的二进制串
		n ：使用第n个s盒 
	*/ 
	int y = source[0]*2+source[5];
	int x = source[1]*8+source[2]*4+source[3]*2+source[4];
	int temp = S_Box[n][y*16+x];
	for(int i=3; i>=0; i--){ 
		dest[i] = temp%2;
		temp /= 2;
	}
}

//加密 
void encode(int *m, int *k){
	/*
		m ：明文二进制串
		k ：密钥二进制串 
	*/ 
	int temp[48];
	int ec[32];
	exchangeIP(temp, m+32, E, 48);
	for(int i=0; i<48; i++){
		temp[i] = temp[i]^k[i];
	}
	
	for(int i=0; i<48; i+=6){
		replaceS(ec+i/6*4, temp+i, i/6);
	}
	exchangeIP(temp, ec, P, 32);
	for(int i=0; i<32; i++){
		m[i] = temp[i]^m[i];
	}
}


int main(){
	int m[64];//二进制明文 
	int key_pre[64];//二进制密钥 
	char C[18];//密文字符串 
	getstr(m);//获取明文字符串并转为二进制 
	getkey(key_pre);//获取密钥字符串并转为二进制 
	exchangeIP(mint, m, IP_first, 64);//对明文进行初始IP置换 
	exchangeIP(key, key_pre, PC_1, 56);//对密钥进行IP置换 
	int dest[48];//轮密钥 
	for(int i=0; i<16; i++){
		encode(mint, getroundkey(dest, key, i));//加密16轮 
		if(i == 15) continue;
		//进行左右交换26轮 
		for(int j=0; j<32; j++){
			int temp = mint[j];
			mint[j] = mint[j+32];
			mint[j+32] = temp; 
		}
	}
	exchangeIP(m, mint, IP_last, 64);//逆初始IP置换
	//转化密文二进制为字符串 
	for(int i=0; i<64; i+=4){
		C[i/4] = hex_re(m+i);
	}
	C[16] = 0;
	printf("密文(16进制)：");
	printf("%s", C);
}

自己创建的网络安全公众号，欢迎各位朋友们关注！