密码学课程设计报告-基于三重DES的文件加密解密系统设计与实现.docx

成绩：

2016-2017学年第1学期

《密码学原理》课程设计

题目：基于三重DES的文件加密解密
系统设计与实现

学院名称：
班级学号：
学生姓名：
教师姓名：

2016年 12 月

一、设计要求
学生在进行课程设计时应该满足以下具体要求：
Ø 要求在设计的过程中，建立清晰的模块；
Ø 设计良好的交互界面，如要求用户输入密钥、明文字符串、得到相应的解密字符串等；
Ø 高级要求：加密、解密中文、用到的数据如明文、密文全部采用文件形式存储。（可选）
二、开发环境与工具
开发环境：Windows平台
开发工具：Visual Studio 2013
三、设计原理（算法工作原理）
l DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。
l DES算法的入口参数有三个：Key、Data、Mode。其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种:加密或解密。
l DES设计中使用了分组密码设计的两个原则：混淆（confusion）和扩散(diffusion)，其目的是抗击敌手对密码系统的统计分析。混淆是使密文的统计特性与密钥的取值之间的关系尽可能复杂化，以使密钥和明文以及密文之间的依赖性对密码分析者来说是无法利用的。扩散的作用就是将每一位明文的影响尽可能迅速地作用到较多的输出密文位中，以便在大量的密文中消除明文的统计结构，并且使每一位密钥的影响尽可能迅速地扩展到较多的密文位中，以防对密钥进行逐段破译。
l DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位（实际用到了56位，第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）。

DES算法流程

l 其算法主要分为两步：
1）初始置换
其功能是把输入的64位数据块按位重新组合，并把输出分为L0、R0两部分，每部分各长32位，其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。
其置换规则见下表：
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,
2）逆置换
经过16次迭代运算后,得到L16、R16,将此作为输入，进行逆置换，逆置换正好是初始置换的逆运算，由此即得到密文输出。
此算法是对称加密算法体系中的代表,在计算机网络系统中广泛使用。

Ø 3DES（即Triple DES）是DES向AES过渡的加密算法，它使用3条56位的密钥对数据进行三次加密。是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。比起最初的DES，3DES更为安全。
Ø 该方法使用两个密钥，执行三次DES算法，加密的过程是加密-解密-加密，解密的过程是解密-加密-解密。3DES加密过程为：C=Ek3(Dk2(Ek1(P)))
3DES解密过程为：P=Dk1(EK2(Dk3(C)))
Ø 采用两个密钥进行三重加密的好处有：
①两个密钥合起来有效密钥长度有112bit，可以满足商业应用的需要，若采用总长为
168bit的三个密钥，会产生不必要的开销。
②加密时采用加密-解密-加密，而不是加密-加密-加密的形式，这样有效的实现了与现
有DES系统的向后兼容问题。因为当K1=K2时，三重DES的效果就和原来的DES一
样，有助于逐渐推广三重DES。
③三重DES具有足够的安全性，目前还没有关于攻破3DES的报道。

四、系统功能描述与软件模块划分
//十进制-十六进制对照表
const static char Hex_Table[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
'A', 'B', 'C', 'D', 'E', 'F'
};

/十六进制-二进制对照表
const static char Bit_Table[16][4] = {
{ 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 0, 1, 1 },
{ 0, 1, 0, 0 }, { 0, 1, 0, 1 }, { 0, 1, 1, 0 }, { 0, 1, 1, 1 }, { 1, 0, 0, 0 },
{ 1, 0, 0, 1 }, { 1, 0, 1, 0 }, { 1, 0, 1, 1 }, { 1, 1, 0, 0 }, { 1, 1, 0, 1 }, { 1, 1, 1, 0 }, { 1, 1, 1, 1 }
};

//置换选择I表
const static char KeyRar_Table[] = {
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
};

//置换选择II表
const static char Rar_Table[] = {
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
};

//初始置换IP表
const static char IP_Table[] = {
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
};

//扩展函数E表
const static char Exp_Table[] = {
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表
const static char P_Table[] = {
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
};

//逆初始置换P_1表
const static char P_1_Table[] = {
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
};

//S盒
const static char S_Box[8][64] = {
/* S1 */
{ 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 },

/* S2 */
{ 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 },

/* S3 */
{ 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 },

/* S4 */
{ 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 },

/* S5 */
{ 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 },

/* S6 */
{ 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 },

/* S7 */
{ 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 },

/* S8 */
{ 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 }
};

#include"table.h"

char CipherText[200];
char K[56]; //置换选择I后的密钥比特流
char Round_Key[16][48]; //轮密钥，最后一位为结束符
char Li[32], Ri[32]; //明文比特流左32位和右32位
char E[49]; //选择运算E后比特流
char S[32]; //保存经过S盒后的输出

//字符串转换比特流函数
//Input保存用户输入的字符数组，Bit保存用户输入的比特流
void CharToBit(char* Input, char* Bit){
int length = 0, j = 0, k = 0;
char Hex[30]; //保存十六进制
for (int i = 0; Input[i] != '\0'; i++){
int temp = (int)Input[i];
if (temp / 16){
int temp1 = (int)Hex_Table[temp / 16];
Hex[j++] = temp1 + 48;
if (temp % 16 < 10){
temp1 = (int)Hex_Table[temp % 16];
Hex[j++] = temp1 + 48;
}
else{
Hex[j++] = Hex_Table[temp % 16];
}
}
else{
Hex[j++] = (char)48;
if (temp % 16 < 10){
int temp1 = (int)Hex_Table[temp % 16];
Hex[j++] = temp1 + 48;
}
else{
Hex[j++] = Hex_Table[temp % 16];
}
}
}
for (int i = 0; i < j; i++){
if (Hex[i] >= '0'&&Hex[i] <= '9'){
for (int m = 0; m < 4; m++){
Bit[k++] = (int)Bit_Table[Hex[i] - 48][m] + 48;
}
}
else if (Hex[i] >= 'A'&&Hex[i] <= 'F'){
for (int m = 0; m < 4; m++){
Bit[k++] = (int)Bit_Table[Hex[i] - 65 + 10][m] + 48;
}
}
}
Bit[k] = '\0';
}

//置换选择I函数
void Replace_I(char* K, char* Key){ //K为置换选择I后的密钥比特流，Key为初始密 钥比特流
for (int i = 0; i < 56; i++){
K[i] = Key[KeyRar_Table[i] - 1];
}
}

//轮密钥生成函数
void Round_Key_Func(char* Key){ //Key为初始密钥比特流
int Left_Move; //左移位数
int m;
char temp;
Replace_I(K, Key); //置换选择I
for (int i = 0; i<16; i++){ //16轮密钥产生
if (i == 0 || i == 1 || i == 8 || i == 15)
Left_Move = 1;
else
Left_Move = 2;
for (int k = 0; k<Left_Move; k++){ //分左右两块循环左移
temp = K[0];
for (m = 0; m < 27; m++){
K[m] = K[m + 1];
}
K[27] = temp;
temp = K[28];
for (m = 28; m < 55; m++){
K[m] = K[m + 1];
}
K[55] = temp;
}
for (int j = 0; j < 48; j++){ //压缩置换并储存
Round_Key[i][j] = K[Rar_Table[j] - 1];
}
}
}

//初始置换IP函数
void Replace_IP(char* Message, char* Li, char* Ri){
int p = 0, q = 0;
for (int i = 0; i<64; i++){
if (i < 32){
Li[p++] = Message[IP_Table[i] - 1];
}
else{
Ri[q++] = Message[IP_Table[i] - 1];
}
}
}

//扩展函数E
void Extend_Func(char* E, char* Ri){
for (int i = 0; i < 48; i++){
E[i] = Ri[Exp_Table[i] - 1];
}
}

//异或运算
void Xor(char* a, char* b, int length){
for (int i = 0; i < length; i++){
int temp1 = a[i] - 48;
int temp2 = b[i] - 48;
a[i] = char(temp1^temp2 + 48);
}
}

//置换运算P函数
void Replace_P(char* Ri, char* S){
for (int i = 0; i<32; i++)
Ri[i] = S[P_Table[i] - 1];
}

//逆初始置换IP_1函数
void Replace_IP_1(char* CipherText, char* Li, char* Ri){
char temp[64];
for (int i = 0; i < 64; i++){
if (i < 32){
temp[i] = Ri[i];
}
else if (i < 64){
temp[i] = Li[i - 32];
}
}
for (int i = 0; i < 64; i++){
CipherText[i] = temp[P_1_Table[i] - 1];
}
}

五、设计核心代码
#include<iostream>
#include"Function.h"
using namespace std;

//DES加解密函数
void DES(char* Key,char* Message,int Mode){ //Mode:0为加密，1为解密
int row, column;
Round_Key_Func(Key);
char M[5][65]; //将明文比特流分为64位一组
char temp[65];
int m = 0; //明文比特流分组数
int length = 0; //比特流长度
int k = 0, flag = 0;
for (int i = 0; Message[i] != '\0'; i++){
length++;
}
//明文比特流以64为一组分组
for (; m < 5; m++){
for (int j = 0; j < 64; j++){
if (k<length){
M[m][j] = Message[k++];
}
else{
flag = 1;
M[m][j] = '0';
}
}
M[m][64] = '\0';
if (flag){
break;
}
}
if (Mode == 0){
if (length == 128){
for (int n = 0; n < m; n++){
Replace_IP(M[n], Li, Ri);
for (int round = 0; round < 16; round++){
char Ri_Copy[33]; //保存明文比特流右半部份
for (int i = 0; i<32; i++)
Ri_Copy[i] = Ri[i];
Extend_Func(E, Ri);
char temp[48];
for (int i = 0; i < 48; i++){
temp[i] = Round_Key[round][i];
}
Xor(E, temp, 48);
for (int i = 0; i<8; i++) //S盒置换
{
row = (E[i * 6] - 48) * 2 + (E[i * 6 + 5] - 48);
column = (E[i * 6 + 1] - 48) * 8 + (E[i * 6 + 2] - 48) * 4 + (E[i
* 6 + 3] - 48) * 2 + (E[i * 6 + 4] - 48);
S[i * 4 + 3] = char(S_Box[i][row * 16 + column] % 2 + 48);
S[i * 4 + 2] = char((S_Box[i][row * 16 + column] / 2) % 2 +
48);
S[i * 4 + 1] = char((S_Box[i][row * 16 + column] / 4) % 2 +
48);
S[i * 4] = char((S_Box[i][row * 16 + column] / 8) % 2 + 48);
}
Replace_P(Ri, S);
Xor(Ri, Li, 32);
for (int i = 0; i<32; i++){ //交换左右明文
Li[i] = Ri_Copy[i];
}
}
Replace_IP_1(temp, Li, Ri);
for (int q = 0; q < 64; q++){
CipherText[n * 64 + q] = temp[q];
}
}
}
else{
for (int n = 0; n < m + 1; n++){
Replace_IP(M[n], Li, Ri);
for (int round = 0; round < 16; round++){
char Ri_Copy[33]; //保存明文比特流右半部份
for (int i = 0; i<32; i++)
Ri_Copy[i] = Ri[i];
Extend_Func(E, Ri);
char temp[48];
for (int i = 0; i < 48; i++){
temp[i] = Round_Key[round][i];
}
Xor(E, temp, 48);
for (int i = 0; i<8; i++) //S盒置换
{
row = (E[i * 6] - 48) * 2 + (E[i * 6 + 5] - 48);
column = (E[i * 6 + 1] - 48) * 8 + (E[i * 6 + 2] - 48) * 4 + (E[i
* 6 + 3] - 48) * 2 + (E[i * 6 + 4] - 48);
S[i * 4 + 3] = char(S_Box[i][row * 16 + column] % 2 + 48);
S[i * 4 + 2] = char((S_Box[i][row * 16 + column] / 2) % 2 +
48);
S[i * 4 + 1] = char((S_Box[i][row * 16 + column] / 4) % 2 +
48);
S[i * 4] = char((S_Box[i][row * 16 + column] / 8) % 2 + 48);
}
Replace_P(Ri, S);
Xor(Ri, Li, 32);
for (int i = 0; i<32; i++){ //交换左右明文
Li[i] = Ri_Copy[i];
}
}
Replace_IP_1(temp, Li, Ri);
for (int q = 0; q < 64; q++){
CipherText[n * 64 + q] = temp[q];
}
}
}
}
else{
for (int n = 0; n < m; n++){
Replace_IP(M[n], Li, Ri);
for (int round = 15; round >= 0; round--){
char Ri_Copy[33]; //保存明文比特流右半部份
for (int i = 0; i<32; i++)
Ri_Copy[i] = Ri[i];
Extend_Func(E, Ri);
char temp[48];
for (int i = 0; i < 48; i++){
temp[i] = Round_Key[round][i];
}
Xor(E, temp, 48);
for (int i = 0; i<8; i++) //S盒置换
{
row = (E[i * 6] - 48) * 2 + (E[i * 6 + 5] - 48);
column = (E[i * 6 + 1] - 48) * 8 + (E[i * 6 + 2] - 48) * 4 + (E[i * 6 +
3] - 48) * 2 + (E[i * 6 + 4] - 48);
S[i * 4 + 3] = char(S_Box[i][row * 16 + column] % 2 + 48);
S[i * 4 + 2] = char((S_Box[i][row * 16 + column] / 2) % 2 + 48);
S[i * 4 + 1] = char((S_Box[i][row * 16 + column] / 4) % 2 + 48);
S[i * 4] = char((S_Box[i][row * 16 + column] / 8) % 2 + 48);
}
Replace_P(Ri, S);
Xor(Ri, Li, 32);
for (int i = 0; i<32; i++){ //交换左右明文
Li[i] = Ri_Copy[i];
}
}
Replace_IP_1(temp, Li, Ri);
for (int q = 0; q < 64; q++){
CipherText[n * 64 + q] = temp[q];
}
}

}
}

//DES检测函数
void DES_Test(){
char Key0[100]; //第一组密钥比特流
char Message[200]; //明文信息比特流
char Message_Input[30];
char Key0_Input[20];
cout << "请输入明文信息（英文字符及数字组合）：";
cin >> Message_Input;
CharToBit(Message_Input, Message);
cout << "请输入第一组密钥（英文字符及数字组合,不少于7个字符）：";
cin >> Key0_Input;
CharToBit(Key0_Input, Key0);
DES(Key0, Message, 0); //用于检测DES加解密算法的正确性
cout << CipherText;
cout << endl;
DES(Key0, CipherText, 1);
cout << CipherText << endl;
}

//3DES加密解密函数
void Triple_DES(char* Key0,char* Key1,char* Key2,char*Message,int
Mode){ //Mode:0为加密，1为解密
if (Mode == 0){
DES(Key0, Message, 0);
DES(Key1, CipherText, 1);
DES(Key2, CipherText, 0);
}
else{
DES(Key2, CipherText, 1);
DES(Key1, CipherText, 0);
DES(Key0, CipherText, 1);
}
}

//加密前的准备工作
void Triple_DES_Prepare(){
char Key0[100]; //第一组密钥比特流
char Key1[100]; //第二组密钥比特流
char Key2[100]; //第三组密钥比特流
char Message[200]; //明文信息比特流
char Message_Input[30];
char Ke