DES加密的算法

信息安全概论·课程设计
DES加密的C语言实现
目录
摘要....................................................... 错误！未定义书签。

Abstract ................................................... 错误！未定义书签。

关键词..................................................... 错误！未定义书签。

1．算法描述................................................ 错误！未定义书签。

1.1加/解密算法的一般原理............................... 错误！未定义书签。

1.2加/解密机制的应用................................... 错误！未定义书签。

2．S盒设计................................................ 错误！未定义书签。

3．DES程序实例与分析...................................... 错误！未定义书签。

4．DES实例运行结果........................................ 错误！未定义书签。

5．结语.................................................... 错误！未定义书签。

6.参考文献................................................. 错误！未定义书签。

信息安全概论·课程设计
DES加密的C语言实现
C language achieve DES algorithm
摘要
DES算法是一种数据加密算法，自从1977年公布以来，一直是国际上的商用保密通信和计算机通信的最常用的加密标准。

DES算法的实现一般用高级语言，DES作为美国国家标准研究所（American National Standard Institute，ANSI）的数据加密算法（Data Encryption Algorithm，DEA）和ISO的DEA 1，成为一个世界范围内的标准已经二十多年。

尽管他带有过去时代的特征，但他很好地经受住了多年的密码分析，除了可能的最强有力的对手外，对其他的攻击具有较好的安全性。

Abstract
DES algorithm is a data encryption algorithm ，Since the publication in 1977, it has been the international commercial confidentiality of communications and computer communications of the most commonly used encryption standard。

DES algorithm with the general high-level language ，DES American National Standards Institute as a data encryption algorithm of the ISO and the DEA 1, a worldwide standard has been more than two decades. Despite his past with the characteristics of the times, but he stood a good many years of cryptanalysis, in addition to probably the most powerful opponent, other attacks have better security.
关键词：加密算法DES
第3页/共17页
1．算法描述
DES是一种分组加密算法，它以64位为分组对数据加密。

64位一组的明文从算法的一端输入，64位的密文从另一端输出。

DES是一个对称算法：加密和解密用的是同一个算法（除密钥编排不同以外）。

密钥的长度为56位(密钥通常表示为64位的数，但每个第8位都用作奇偶检验，可以忽略)。

密钥可以是任意的56位数，且可以在任意的时候改变。

DES算法全称为Data Encryption Standard,即数据加密算法,它是IBM公司于1975年研究成功并公开发表的。

DES算法的入口参数有三个:Key、Data、Mode。

其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。

DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位，其算法主要分为两步：
(1)初始置换
其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长3 2位,其置换规则为将输入的第58位换到第一位,第50位换到第2位......依此类推,最后一位是原来的第7位。

L0、R0则是换位输出后的两部分，L0是输出的左32位,R0是右32位,例:设置换前的输入值为D1D2D3......D64,则经过初始置换后的结果为:L0=D58D50......D8;R0=D57D49 (7)
(2)逆置换
经过16次迭代运算后,得到L16、R16,将此作为输入,进行逆置换,逆置换正好是初始置换的逆运算，由此即得到密文输出。

1.1加/解密算法的一般原理
密码体制从原理上可分为2大类，即单钥密码体制和双钥密码体制。

单钥密码体制是指信息的发送方和接受方共享一把钥匙。

在现代网络通信条件下，该体制的一个关键问题是如何将密钥安全可靠地分配给通信的对方，并进行密钥管理。

因此单钥密码体制在实际应用中除了要设计出满足安全性要求的加密算法外，还必须解决好密码的产生、分配、传输、存储和销毁等多方面问题。

单钥密码可分为古典密码、流密码和分组密码，DES就属于分组密码中的一种。

双钥密码体制又称公钥密码体制，其最大特点是采用2个密钥将加密、解密分开。

在双钥体制下，每个用户都拥有2把密钥，—个公开，一个自己专用。

当使用用户专用密钥加
信息安全概论·课程设计
密，而用该用户公开密钥解密时，则可实现一个被加密的消息能被多个用户解读；当使用用户公开密钥加密，而用该用户专用密钥解密时，则可实现传输的信息只被一个用户解读。

前者常被用于数字签名，后者常被用于保密通信。

1.2加/解密机制的应用
在信息安全领域中，凡涉及到数据通信均采用加/解密机制。

而目前日益发展的电子商务正是充分展示加/解密机制的一个十分重要的领域。

在电子商务中，订单的保密性需用加密技术来处理，而订单的可靠性、时间性则需用数字签名技术，有时还需双重签名。

例如，刘先生要买张小姐的一处房产，他发给张小姐一个购买报价单及他对银行的授权书的消息，如果张小姐同意按此价格出卖，则要求银行将钱划到张小姐的帐上。

但刘先生不想让银行看到报价，也不想让张小姐看到他的银行帐号信息。

此外，报价和付款是相连的、不可分割的，仅当张小姐同意他的报价后，钱才会转移，要达到这个要求，采用双重签名即可实现。

2．S盒设计
通过时间分析发现，S盒在整个设计中占了很大的比重。

S盒性能的提高对于整个设计性能会有很大的改善，因此S盒是整个设计优化的重点。

DES的8个S盒分别是一个满足特殊性能的6～4位的变换。

这是最简单的实现方法，但是HDL语言都属于高级语言，它们强烈依赖于编译器的优化能力，往往对设计者来说，涉及得越少、编程越简单，代码效率越不高，这对于高速实现来说是不可取的。

S盒成了速度的瓶颈，为此，采用ROM
来实现。

XC2S100的LUT可以配置为16×1位的ROM，把输入的6位作为地址，对应的地址空间里存放的就是输出的4位，从而实现了6～4位的查找表LUT，所需时间只是FPGA 中CLB的传输时间加上传输线上的延时，如图1所示。

第5页/共17页
3．DES程序实例与分析
在本次设计中，具体讲解DES加密和解密程序，并在程序中详细对程序进行了分析，以下是DES加密和解密程序设计的详细过程以及分析说明。

/*源文件：DES.cpp*/
/*本程序为本人实验程序*/
#include <stdio.h>
#include <memory.h>
#include <string.h>
// 初始置换表
const static char IP_Table[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_Table。

初始置换在第一轮运算之前执行。

将常量IP_Table看作是一个表结构。

此表应该从左向右读。

例如，初始置换把明文的第58位换到第1位的位置，把第50位换到第2位的位置，把第42位换到第3位的位置。

// 逆初始置换表
const static char IPR_Table[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
};
上面程序主要定义了逆初始置换表IPR_Table。

逆初始置换是初始置换的逆过程。

注意，DES在最后一轮后，左半部分和右半部分并未交换，而是R16和L16并在一起形成一个分组作为逆初始置换的输入。

其实交换左右两部分并循环移动，仍将获得完全相同的结果。

但这样做，能使该算法既能用作加密，又能用作解密。

信息安全概论·课程设计
// 扩展置换表
static const char Extension_Table[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
};
上面程序主要定义了扩展置换表Extension_Table。

扩展置换将数据的右半部分Ri从32bit 扩展到了48bit，这个操作改变了位的次序，重复了某些位。

这样做有两个方面的目的：一是产生了与密钥同长度的数据一进行异或运算：二是提供了更长的结果，使得在替代运算时能进行压缩。

// P盒置换表
const static char P_Table[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
};
上面程序主要定义了P盒置换表P_Table。

P盒替代运算后的32bit输出依照P盒进行置换。

该置换把每个输入位映射到输出位，任一位不能被映射两次，也不能省去。

P盒置换表就给了每位移至的位置。

例如，第21位移到了第4位处，同时第4位移到了第31位处。

.
// 密钥置换表
const static char PCK_Table[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
};
// 压缩置换表
const static char PCC_Table[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,
第7页/共17页
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
};
// 每轮移动的位数
const static char LOOP_Table[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
上面程序主要定义了密钥置换表PCK_Table，每轮移动的位数表LOOP_Table和压缩置换表PCC_Table。

由于开始时不考虑每个字节的第8位，因此DES的密钥由64bit减至56bit，如密钥置换表所示。

每个字节第8位可作为奇校验以确保密钥不发生错误。

在DES的每一轮中，从56bit密钥产生不同的48bit子密钥。

子密钥产生过程是：首先，56bit密钥被分为两部分，每部分28bit。

然后根据轮数，这两部分分别循环左移1位或2位。

LOOP_Table给出了每轮移动了的位数。

移动后，就从56bit中选出58bit。

因为这个运算不仅置换看了每位的顺序，同时也选择子密钥，所以被称为压缩置换。

表PCC_Table提供了一组48bit的集，定义了压缩置换方式。

例如，处在第33位位置的那一位在输出时移动了第35位的位置，而在第18位位置的那一位被省去了。

// S盒设计
const static char S_Box[8][4][16] = {
// S盒1
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,
// S盒2
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,
// S盒3
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,
// S盒4
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,
// S盒5
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,
// S盒6
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,
// S盒7
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,
// S盒8
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
};
上面的程序主要定了s盒S-BOX.每个S盒是一个4行，16列的表。

盒中是一个4bit 的数，S盒中的6个输入确定了其对应的输出在哪行哪列。

第9页/共17页
typedef bool (*PSubKey)[16][48];
enum {ENCRYPT,DECRYPT};
static bool SubKey[2][16][48];// 16圈子密钥
static bool Is3DES;// 3次DES标志
static char Tmp[256], deskey[16];
static void DES(char Out[8], char In[8], const PSubKey pSubKey, bool Type);
//标准DES加/解密
static void SetKey(const char* Key, int len);// 设置密钥
static void SetSubKey(PSubKey pSubKey, const char Key[8]);// 设置子密钥
static void F_func(bool In[32], const bool Ki[48]);// f 函数
static void S_func(bool Out[32], const bool In[48]);// S 盒代替
static void Transform(bool *Out, bool *In, const char *Table, int len);
// 变换
static void Xor(bool *InA, const bool *InB, int len);// 异或
static void RotateL(bool *In, int len, int loop);// 循环左移
static void ByteToBit(bool *Out, const char *In, int bits);
// 字节组转换成位组
static void BitToByte(char *Out, const bool *In, int bits);
// 位组转换成字节组
// Type—ENCRYPT:加密,DECRYPT:解密
// 输出缓冲区(Out)的长度>= ((datalen+7)/8)*8,即比datalen大的且是8的倍数的最小整数
// In 可以= Out,此时加/解密后将覆盖输入缓冲区(In)的内容
// 当keylen>8时系统自动使用3次DES加/解密,否则使用标准DES加/解密.超过16字节后只取前16字节
bool DES_Act(char *Out,char *In,long datalen,const char *Key,int keylen,bool Type = ENCRYPT);
上面的函数主要声明了DES算法所需的函数。

为了是读者有整体的理解，把这些函数罗列在次，下面具体讲解函数的实现。

// 字节转换函数
void ByteToBit(bool *Out, const char *In, int bits)
{
for(int i=0; i<bits; ++i)
信息安全概论·课程设计
Out[i] = (In[i>>3]>>(i&7)) & 1;
}
// 比特转换函数
void BitToByte(char *Out, const bool *In, int bits)
{
memset(Out, 0, bits>>3);
for(int i=0; i<bits; ++i)
Out[i>>3] |= In[i]<<(i&7);
}
上面的程序是实现字节组转换成位组和位组转换成字节组的功能函数。

在大部分函数中都会使用这两个函数，因为转换后才能进行相应的算法操作。

// 变换函数
void Transform(bool *Out, bool *In, const char *Table, int len)
{
for(int i=0; i<len; ++i)
Tmp[i] = In[ Table[i]-1 ];
memcpy(Out, Tmp, len);
}
// 异或函数的实现
void Xor(bool *InA, const bool *InB, int len)
{
for(int i=0; i<len; ++i)
InA[i] ^= InB[i];
}
// 循环左移函数
void RotateL(bool *In, int len, int loop)
{
memcpy(Tmp, In, loop);
memcpy(In, In+loop, len-loop);
第11页/共17页
memcpy(In+len-loop, Tmp, loop);
}
上面的程序实现了变换函数，异或函数，循环左移函数。

变换函数Transform功能是实现各个表中的位置变换，以实现打乱顺序的作用。

异或函数Xor的主要功能是将两个数组InA和InB进行异或运算，结果输出在数组InA 中。

循环左移函数Rotatel功能是输入的数组进行移位，参数In是输入的数组，参数loop 是移位的位数，参数len是移位的长度。

// S函数的实现
void S_func(bool Out[32], const bool In[48])
{
for(char i=0,j,k; i<8; ++i,In+=6,Out+=4) {
j = (In[0]<<1) + In[5];
k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];
ByteToBit(Out, &S_Box[i][j][k], 4);
}
}
// F函数的实现
void F_func(bool In[32], const bool Ki[48])
{
static bool MR[48];
Transform(MR, In, Extension_Table, 48);
Xor(MR, Ki, 48);
S_func(In, MR);
Transform(In, In, P_Table, 32);
}
上面的程序主要实现了S盒替换函数和F函数。

S盒替换函数功能是根据S盒的设计将48bit的输入变为32bit的输出。

参数In是输入的48bit数组，参数Out是输出的32bit 数组。

F函数是整个DES加密算法中最重要的部分。

参数In是32bit的输入,参数Ki是由初始密钥导出的第i轮子密钥，F函数输出的32bit存在于In数组中。

次函数的实现过程为，首
信息安全概论·课程设计
先经过一个扩展运算，然后进行S盒替换，再进行P盒置换。

其中，扩展运算和P盒置换的主要作用是增加算法的扩展效果。

// 设置子密钥
void SetSubKey(PSubKey pSubKey, const char Key[8])
{
static bool K[64], *KL=&K[0], *KR=&K[28];
ByteToBit(K, Key, 64); //转换格式
Transform(K, K, PCK_Table, 56);
// 由56位密钥产生48位子密钥
for(int i=0; i<16; ++i) {
RotateL(KL, 28, LOOP_Table[i]);
RotateL(KR, 28, LOOP_Table[i]);
Transform((*pSubKey)[i], K, PCC_Table, 48);
}
}
// 设置密钥
void SetKey(const char* Key, int len)
{
memset(deskey, 0, 16);
memcpy(deskey, Key, len>16?16:len);
SetSubKey(&SubKey[0], &deskey[0]);
Is3DES = len>8 ? (SetSubKey(&SubKey[1], &deskey[8]), true) : false;
}
上面的程序主要实现了设置子密钥函数和设置密钥函数。

设置子密钥函数SetSubKey 实现流程是：首先调用Transform函数根据密钥置换表将DES的密钥由64bit减至56bit,然后将56bit密钥分成两部分，每部分28bit。

然后，根据轮数表，调用RotateL函数分别将两部分密钥循环左移1位或2位。

最后根据压缩置换进行变换位置和选择子密钥。

设置密钥函数SetKey功能是判断输入的密钥是否大于16bit，如果大于16bit,则采用取3次DES加密。

// DES加解密函数
第13页/共17页
void DES(char Out[8], char In[8], const PSubKey pSubKey, bool Type)
{
static bool M[64], tmp[32], *Li=&M[0], *Ri=&M[32];
ByteToBit(M, In, 64);
Transform(M, M, IP_Table, 64);
if( Type == ENCRYPT ){
for(int i=0; i<16; ++i) {
memcpy(tmp, Ri, 32);
F_func(Ri, (*pSubKey)[i]); // 调用F函数
Xor(Ri, Li, 32);
memcpy(Li, tmp, 32);
}
}else{
for(int i=15; i>=0; --i) {
memcpy(tmp, Li, 32);
F_func(Li, (*pSubKey)[i]);
Xor(Li, Ri, 32);
memcpy(Ri, tmp, 32);
}
}
Transform(M, M, IPR_Table, 64);
BitToByte(Out, M, 64);
}
上面程序实现了DES加解密函数的功能函数。

程序流程是：首先调用Transform函数根据初始表进行位置变换。

然后开始16轮的循环运算，每轮循环中，调用F函数进行加密或者解密。

最后调用Transform根据逆初始置换进行位置变换，再进行组到字节组对的转换，输出的就是密文或者解密文了。

// DES加解密函数（可以对长明文分段加密）
bool DES_Act(char *Out, char *In, long datalen, const char *Key, int keylen, bool Type)
{
if( !( Out && In && Key && (datalen=(datalen+7)&0xfffffff8) ) )
信息安全概论·课程设计
return false;
SetKey(Key, keylen);
if( !Is3DES ) { // 1次DES
for(long i=0,j=datalen>>3; i<j; ++i,Out+=8,In+=8)
DES(Out, In, &SubKey[0], Type);
} else{ // 3次DES 加密:加(key0)-解(key1)-加(key0) 解密::解(key0)-加(key1)-解(key0) for(long i=0,j=datalen>>3; i<j; ++i,Out+=8,In+=8) {
DES(Out, In, &SubKey[0], Type);
DES(Out, Out, &SubKey[1], !Type);
DES(Out, Out, &SubKey[0], Type);
}
}
return true;
}
上面的函数主要功能是调用DES函数对输入的明文进行加密操作。

参数Out是输出的数组，参数In是输入的数组，参数datalen是输入的数组长度，参数Key是加密密钥，参数Keylen是密钥长度，参数Type是加密解密标志位。

程序首先根据密钥长度调用SetKey 函数设置密钥，然后根据输出Is3DES变量调用DES函数进行1次或3次DES加密解密。

void main()
{
// 密钥设置
char key[]={0,2,1,0,9,4,5,1,7,8,5,0,7,2,8};
// 设置明文
char plain_text[]=" Welcome to DES world! It is wonderful! ";
char encrypt_text[255]; // 密文
char decrypt_text[255]; // 解密文
memset(encrypt_text,0,sizeof(encrypt_text));
memset(decrypt_text,0,sizeof(decrypt_text));
printf("\nDES加密前的明文:\n");
printf("%s\n\n",plain_text);
// 进行DES加密
第15页/共17页
DES_Act(encrypt_text, plain_text, sizeof(plain_text), key, sizeof(key), ENCRYPT);
printf("\nDES加密后的密文:\n");
printf("%s\n\n",encrypt_text);
DES_Act(decrypt_text, encrypt_text, sizeof(plain_text), key, sizeof(key), DECRYPT);
printf("\n解密后的输出:\n");
printf("%s",decrypt_text);
getchar();
}
上面程序是主函数，主要演示了DES加密和解密的过程。

首先定义了密钥key，明文plain_text，密文encrypt_text和解密后的明文decrypt_text，然后调用DES-Act函数加密明文并输出。

最后再次调用DES-Act函数对密文进行解密，并输出结果与原来的明文进行比较。

4．DES实例运行结果
在命令提示符下输入DES.exe，显示如图3-8所示。

从结果可以看出，明文经过加密后是完全不认可的。

在经过解密，输出的结果和输入的明文一致。

信息安全概论·课程设计
5．结语
目前加密算法已被广泛的应用，随着信息化和数字化社会的发展，随着计算机和Inte rnet的普及，密码学必将在国家安全、经济交流、网络安全及人民生活等方面发挥更大作用。

经过此次的课程设计，我对加解密算法有了更深的领悟。

我回想起在做设计的过程中遇到的种种难题，虽然当时心里很着急，但是自己却能坚持下来，认真去解决每一个难题。

在设计中，我深切体会到理论与实践的差距，更加懂得实践的重要性。

我在以后的学习中，一定会牢记课本上的知识和扩展自己的知识面。

在此，我要对给与我帮助的同学和老师表示衷心的感谢。

6.参考文献
(1) 应用密码学吴世忠译机械工业出版社2000
(2) 密码分析学冯登国清华大学出版社2000
第17页/共17页。