信息安全技術 || DES加密算法

算法原理：

DES算法是一種對稱加密算法，以64位爲分組對數據加密，加密和解密用的是同一個算法。它的密鑰長度是56位（因爲每個第8 位都用作奇偶校驗），密鑰可以是任意的56位的數，而且可以任意時候改變。其中有極少數被認爲是易破解的弱密鑰，但是很容易避開它們不用。所以保密性依賴於密鑰。

其基本流程如下：

首先要生成一套加密密鑰，從用戶處取得一個64位長的密碼口令，然後通過等分、移位、選取和迭代形成一套16個加密密鑰，分別供每一輪運算中使用。

DES對64位(bit)的明文分組M進行操作，M經過一個初始置換IP，置換成m0。將m0明文分成左半部分和右半部分m0 = (L0，R0)，各32位長。然後進行16輪完全相同的運算（迭代），這些運算被稱爲函數f，在每一輪運算過程中數據與相應的密鑰結合。

在每一輪中，密鑰位移位，然後再從密鑰的56位中選出48位。通過一個擴展置換將數據的右半部分擴展成48位，並通過一個異或操作替代成新的48位數據，再將其壓縮置換成32位。這四步運算構成了函數f。然後，通過另一個異或運算，函數f的輸出與左半部分結合，其結果成爲新的右半部分，原來的右半部分成爲新的左半部分。將該操作重複16次。

經過16輪迭代後，左，右半部分合在一起經過一個末置換（數據整理），這樣就完成了加密過程。

DES的解密和加密唯一的不同是密鑰的次序相反。如果各輪加密密鑰分別是K1，K2，K3…K16，那麼解密密鑰就是K16，K15，K14…K1。

總體結構：

Feistel結構：

模塊分解：

由給定的密鑰獲取16個子密鑰：

• 對K 的56個非校驗位實行置換PC-1，得到C0D0，其中C0 和D0 分別由PC-1 置換後的前28位和後28位組成。

//密鑰置換表
const 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
};

• 計算Ci = LSi(Ci-1) 和Di = LSi(Di-1)

//密鑰置換時每輪移動的位數
const int shift[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};

//將密鑰的前後部分分別左移
void leftShift(unsigned char K[28], int shift) {
	unsigned char ar[28];
	memcpy(ar, K, 28);
	int i = 0;
	for(i = 27; i >= 0; i--)
	{
		if(i-shift < 0)
			K[i] = ar[i-shift+28];
		else
			K[i] = ar[i-shift];
	}
}

• 對56位的CiDi 實行PC-2 壓縮置換，得到48位的Ki 。i= i+1。

//壓縮置換表
const 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
};

• 之後的16輪按照以上步驟重複得到16個子密鑰

• 總的算法實現：

void getMyKey(unsigned char key[64], unsigned char subKey[16][48]) {
	//去掉奇偶檢驗位的key
	unsigned char key_f[56];
	//左半部分
	unsigned char L[28];
	//右半部分
	unsigned char R[28];
	int i = 0, j = 0;
	unsigned char C_key[48];
	for (i = 0; i < 56; i++) {
		key_f[55-i] = key[64-PC_1[i]];
	}
	//生成左右子密鑰
	for (i = 0; i < 16; i++) {
		for (j = 0; j < 28; j++) {
			L[j] = key_f[j+28];
		}
		for (j = 0; j < 28; j++) {
			R[j] = key_f[j];
		}
		//左移
		leftShift(L, shift[i]);
		leftShift(R, shift[i]);
		//壓縮置換
		
		for (j = 0; j < 28; j++) {
			key_f[j+28] = L[j];
		}
		for (j = 0; j < 28; j++) {
			key_f[j] = R[j];
		}
		for (j = 0; j < 48; j++) {
			C_key[47-j] = key_f[56-PC_2[j]];
		}
		memcpy(subKey[i], C_key, 48);
	}
}

初始IP置換：

給定64位明文塊M，通過一個固定的初始置換IP來重排M中的二進制位，得到二進制串M0 = IP(M) = L0 R0，這裏L0 和R0分別是M0 的前32位和後32位。

//IP置換表
const 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
};

//初始置換IP
	int i = 0;
	unsigned char FirstKey[64];
	for (i = 0; i < 64; i++) {
		FirstKey[63-i] = word[64-IP[i]];
	}

迭代T

• 根據L0R0 按下述規則進行16次迭代，即

$Li= Ri-1, Ri= Li-1 (XOR) f(Ri-1, Ki), i= 1 .. 16$

• 這裏 (XOR) 是32位二進制串按位異或運算，f 是輸出32位的Feistel 輪函數；
• 16個長度爲48位的子密鑰Ki(i= 1 … 16) 由密鑰K生成；
• 16次迭代後得到L16R16 ;
• 左右交換輸出R16L16 。

//16輪迭代
unsigned char L[32];
	unsigned char R[32];
	for(i = 0; i < 32; i++) {
		L[i] = FirstKey[i+32];
	}
	for(i = 0; i < 32; i++) {
		R[i] = FirstKey[i];
	}
	for (i = 0; i < 16; i++) {
		unsigned char tmp_R[32];
		unsigned char R1[32];
		memcpy(tmp_R, R, 32);
		f(R, subKey[i], R1);
		XOR_32(L, R1);
		memcpy(R, L, 32);
		memcpy(L, tmp_R, 32);
	}

輪詢函數Feistel：

• 將長度爲32位的串Ri-1作E-擴展,成爲48位的串E(Ri-1)；

//擴展置換表
const 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
};

• 將E(Ri-1) 和長度爲48位的子密鑰Ki作48位二進制串按位異或運算，Ki 由密鑰K生成；

void XOR_48(unsigned char ER[48], unsigned char K[48]) {
	int i = 0;
	for (i = 0; i < 48; i++) {
		ER[i] ^= K[i];
	}
}

• 將上面得到的結果平均分成8個分組(每個分組長度6位)，各個分 組分別經過8個不同的S-盒進行6-4 轉換，得到8個長度分別爲4 位的分組；

// S盒置換表，每個S盒是4x16的置換表
const int S_BOX[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,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,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,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}  
	} 
};

• 將上面得到的分組結果順序連接得到長度爲32位的串；
• 再將上面的32位串經過P-置換，得到的結果作爲輪函數f(Ri-1, Ki) 的最終32位輸出。

//P盒置換表
const 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 
};

• 整個函數的實現過程：

//輪詢函數Feistel
void f(unsigned char R[32], unsigned char K[48], unsigned char R1[32]) {
	//將32位進行擴展成48位
	unsigned char ER[48];
	int i = 0, j = 0;
	for (i = 0; i < 48; i++) {
		ER[47-i] = R[32-E[i]];
	}
	//擴展後的R和K異或
	XOR_48(ER, K);
	//輪詢S_Box，將6->4
	for (i = 0; i < 48; i+=6, j+=4) {
		int m = (ER[47-i]<<1) +ER[47-i-5];
		int n = (ER[47-i-1]<<3) + (ER[47-i-2]<<2) + (ER[47-i-3]<<1) + ER[47-i-4];
		int num = S_BOX[i/6][m][n];
		//printf("%d  %d", m, n);
		R1[31-j] = (num&0x08) >> 3;
		R1[31-j-1] = (num&0x04) >> 2;
		R1[31-j-2] = (num&0x02) >> 1;
		R1[31-j-3] = num&0x01;
	}
	//P置換， 32->32
	unsigned char ar[32];
	memcpy(ar, R1, 32);
	for (i = 0; i < 32; i++) {
		R1[31-i] = ar[32-P[i]];
	}
}

加密：

void EnCode(unsigned char word[64], unsigned char cipher[64], unsigned char subKey[16][48]) {
	//初始置換IP
	int i = 0;
	unsigned char FirstKey[64];
	for (i = 0; i < 64; i++) {
		FirstKey[63-i] = word[64-IP[i]];
	}
	//16輪迭代
	unsigned char L[32];
	unsigned char R[32];
	for(i = 0; i < 32; i++) {
		L[i] = FirstKey[i+32];
	}
	for(i = 0; i < 32; i++) {
		R[i] = FirstKey[i];
	}
	for (i = 0; i < 16; i++) {
		unsigned char tmp_R[32];
		unsigned char R1[32];
		memcpy(tmp_R, R, 32);
		f(R, subKey[i], R1);
		XOR_32(L, R1);
		memcpy(R, L, 32);
		memcpy(L, tmp_R, 32);
	}
	//合併迭代後的L和R,並進行IP-1的置換
	unsigned char LR[64];
	for (i = 0; i < 32; i++) {
		LR[i] = L[i];
	}
	for (i = 0; i < 32; i++) {
		LR[i+32] = R[i];
	}
	unsigned char tmp_LR[64];
	memcpy(tmp_LR, LR, 64);
	for (i = 0; i < 64; i++) {
		cipher[63-i] = tmp_LR[64-IP_1[i]];
	}
}

解密：

• 分析所有的代替、置換、異或和循環移動過程，獲得一個非常 有用的性質：DES 的加密和解密可使用相同的算法和密鑰。
• DES 的過程設計使得用相同的函數來加密或解密每個分組成爲 可能。加解密過程中使用由同一個密鑰K 經過相同的子密鑰生 成算法得到的子密鑰序列，唯一不同之處是加解密過程中子密 鑰的調度次序恰好相反。
  • 加密過程的子密鑰按(K1 K2 … K15 K16) 次序調度
  • 解密過程的子密鑰按(K16 K15 … K2 K1) 次序調度

代碼實現：

void DeCode(unsigned char cipher[64], unsigned char word[64], unsigned char subKey[16][48]) {
	//初始置換IP
	int i = 0;
	unsigned char FirstKey[64];
	for (i = 0; i < 64; i++) {
		FirstKey[63-i] = cipher[64-IP[i]];
	}
	//16輪迭代
	unsigned char L[32];
	unsigned char R[32];
	for(i = 0; i < 32; i++) {
		L[i] = FirstKey[i+32];
	}
	for(i = 0; i < 32; i++) {
		R[i] = FirstKey[i];
	}
	for (i = 0; i < 16; i++) {
		unsigned char tmp_R[32];
		unsigned char R1[32];
		memcpy(tmp_R, R, 32);
		f(R, subKey[15-i], R1);
		XOR_32(L, R1);
		memcpy(R, L, 32);
		memcpy(L, tmp_R, 32);
	}
	//合併迭代後的L和R,並進行IP-1的置換
	unsigned char LR[64];
	for (i = 0; i < 32; i++) {
		LR[i] = L[i];
	}
	for (i = 0; i < 32; i++) {
		LR[i+32] = R[i];
	}
	unsigned char tmp_LR[64];
	memcpy(tmp_LR, LR, 64);
	for (i = 0; i < 64; i++) {
		word[63-i] = tmp_LR[64-IP_1[i]];
	}
}

數據結構：

使用unsigned char數組來存儲二進制位串

通過c語言的移位操作符實現二進制位串的邏輯運算。

通過以下代碼實現字符串與二進制位串的轉換：

//字符轉換成二進制符號 
void CharToBit(unsigned char c, unsigned char bit[8]){  
    int i;  
    for(i = 0; i < 8; i++){  
        *(bit+i) = (c>>i) & 1;  
    }   
}  
    
  
//將長度爲8的字符串轉爲64位二進制  
void StringToBits(unsigned char c[8], unsigned char bit[64]){  
    int i;  
    for(i = 0; i < 8; i++){          
        CharToBit(*(c + i), bit + (i<<3));  
    } 
}  
  
//二進制轉換成字節  
void BitToChar(unsigned char bit[8], unsigned char *c){  
    int i;  
    for(i = 0; i < 8; i++){  
        *c |= *(bit + i) << i;  
    }   
}

//將二進制字節轉爲長度爲8的字符串  
void BitsToString(unsigned char bit[64], unsigned char c[8]){  
    int i;
    memset(c,0,8);  
    for(i = 0; i < 8; i++){  
        BitToChar(bit + (i<<3), c + i);  
    }  
}

二進制位串的一些邏輯運算如下：

void XOR_32(unsigned char ER[32], unsigned char K[32]) {
	int i = 0;
	for (i = 0; i < 32; i++) {
		ER[i] ^= K[i];
	}
}

int m = (ER[47-i]<<1) +ER[47-i-5];
		int n = (ER[47-i-1]<<3) + (ER[47-i-2]<<2) + (ER[47-i-3]<<1) + ER[47-i-4];
		int num = S_BOX[i/6][m][n];
		//printf("%d  %d", m, n);
		R1[31-j] = (num&0x08) >> 3;
		R1[31-j-1] = (num&0x04) >> 2;
		R1[31-j-2] = (num&0x02) >> 1;
		R1[31-j-3] = num&0x01;

編譯運行結果：

用於測試的main文件：

• 將加密的文字存到一個記事本里，解密過程讀取記事本中的位串進行解碼。

#include <stdio.h>
#include <stdlib.h>
#include "desCode.h"
#include <time.h>
int main () {
	printf("please input the words you want to encode: \n\n");
	//加密的文字
	unsigned char word[8];
	memset(word, 0, 8);
	unsigned char *s_word = (unsigned char*)malloc(8*sizeof(unsigned char));
	gets(s_word);
	strcpy(word, s_word);
	free(s_word);
	unsigned char words[64];
	StringToBits(word, words);
	//密鑰
	unsigned char c_key[8];
	//取1~9的隨機數作爲密鑰
	srand(time(0));
	for (int i = 0; i < 8; i++) {
		int key_1 = rand() % 10;
		c_key[i] = key_1 + '0';
	}
	printf("\nthe key help us to encode is: \n");
	for (int i = 0; i < 8; i++) {
		printf("%c", c_key[i]);
	}
	printf("\n\n");
	//unsigned char *c_key = "12342a78";
	unsigned char key[64];
	StringToBits(c_key, key);
	//根據提供的密鑰生成16個子密鑰
	unsigned char subKey[16][48];
	getMyKey(key, subKey);
	//加密過程
	unsigned char cipher[64];
	EnCode(words, cipher, subKey);
	printf("After encode, your cipher is: \n");
	for (int i = 0; i < 64; i++) {
		printf("%c", cipher[i]);
	}
	printf("\n\n");
	//將密碼寫到密碼本里面
	FILE *fp;
	fp = fopen("code.txt","w+t");
	fwrite(cipher, sizeof(char), 64, fp);
	fclose(fp);
	//將密碼本的密碼讀取出
	unsigned char cipher_read[64];
	fp = fopen("code.txt","r+t");
	fread(cipher_read, sizeof(char), 64, fp);
	//fscanf(fp, "%s", cipher_read);
	fclose(fp);
	//解密過程
	unsigned char decode[64];
	unsigned char answer[8];
	DeCode(cipher_read, decode, subKey);
	BitsToString(decode, answer);
	printf("After decode, your answer is: \n");
	for (int i = 0; i < 8; i++) {
		printf("%c", answer[i]);
	}
	printf("\n");
	return 0;
}

運行結果：