苏州科技学院电子与信息工程学院
实验报告
实验一
（实验）课程名称 信息安全技术
实验名称 DES加密算法的简单实现
实 验 报 告
一、实验室名称： 电子学院213机房
二、实验项目名称：DES加密算法的简单实现
三、实验学时：2学时
四、实验原理：
DES的描述
DES是一种分组加密算法，他以64位为分组对数据加密。64位一组的明文从算法的一端 输入，64位的密文从另一端输出。DES是一个对称算法：加密和解密用的是同一个算法（除密钥编排不同以外）。
密钥的长度为56位(密钥通常表示为64位的数，但每个第8位都用作奇偶检验，可以忽略)。密钥可以是任意的56位数，且可以在任意的时候改变。
DES算法的入口参数有3个：Key，Data，Mode。其中Key为8个字节共64位，是DES算法 的工作密钥；Data也为8个字节64位，是要被加密或解密的数据：Mode为DES的工作方式，有两种：加密或解密。
DES算法的工作过程：若Mode为加密，则用Key对数据Data进行加密，生成Data的密码 形式（64位）作为DES的输出结果；若Mode为解密，则用Key对密码形式的数据Data解密，还 原为Data的明码形式（64位）作为DES的输出结果。
DES算法详述
DES算法把64位的明文输入块变为64位的密文输出块，他所使用的密钥也是64位，DES对64 位的明文分组进行操作。通过一个初始置换，将明文分组分成左半部分和右半部分，各32位长。然后进行16轮相同的运算，这些相同的运算被称为函数f，在运算过程中数据和密钥相结合。经过16轮运算后左、右部分在一起经过一个置换（初始置换的逆置换），这样算法就完成了。
（1）初始置换
其功能是把输入的64位数据块按位重新组合，并把输出分为L0，R0两部分，每部分各长32位，
即将输入的第58位换到第1位，第50位换到第2位，…，依次类推，最后一位是原来的第7位，L0，R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位。。
（2）逆置换
经过16次迭代运算后，得到L16，R16，将此作为输入进行逆置换，即得到密文输出。逆置换正好是初始置换的逆运算。例如，第1位经过初始置换后，处于第40位，而通过逆置 换，又将第40位换回到第1位。
（3）函数f(Ri,Ki)的计算
“扩展置换”是将32位放大成48位，“P盒置换”是32位到32位换位，
在（Ri,Ki）算法描述图中，选择函数功能是把6 b数据变为4 b数据。
(4)子密钥Ki(48 b)的生成算法
开始，由于不考虑每个字节的第8位，DES的密钥从64位变为48位，如表6所示，首先56位 密钥被分成两个部分，每部分28位，然后根据轮数，两部分分别循环左移l或2位。
DES算法规定，其中第8，16，…，64位是奇偶校验位，不参与DES运算。故Key实际可用 位数只有56位。即：经过密钥置换表的变换后，Key的位数由64位变成了56位，此56位分为C 0，D0两部分，各28位，然后分别进行第一次循环左移，得到C1，D1，将C1(28位)，D1(28位 )合并得到56位，再经过压缩置换，从而便得到了密钥K0(48位)。依次类推，便可得到K1，K 2，…，K15。需要注意的是，16次循环左移对应的左移位数要依据表7所示的规则进行。
以上介绍了DES算法的加密过程。DES算法的解密过程是一样的，区别仅在于第一次迭代时用子密钥K15，第二次是K14，…，最后一次用K0，算法本身并没有任何变化。
五、实验目的：
目的：实现DES算法算法并掌握其原理。
六、实验内容：
a) 熟悉DES算法的基本原理；
b) 依据所算则的算法，编程实现该该算法；
c) 执行程序并分析结果；
七、实验器材（设备、元器件）：
PC微机一台
八、实验步骤：
a) 选择并熟悉一种密码算法。
b) 编写概要设计，详细设计报告
c) 使用visual c++工具，编码.
d) 调试及测试
九、实验数据及结果分析：
明文差一位，密钥相同，比较密文差异
密钥12345678
明文12345678 密文96D0028878D58C89
明文12345679 密文4112EF16D979F608
test.txt：明文12345678
test2.txt：密钥12345679
程序执行成功后
test3.txt：密钥12345678
十、实验结论：
如图所示，DES算法正确运行。
十一、总结及心得体会：
通过本次实验，我对DES算法的加密解密原理有了一定的了解，熟悉了用DES算法对字符串和对文件进行加密。DES算法比较复杂，做加密解密实验时用DES算法来做难度有点大，一开始我还不太能理解。以后可以写个简单点的算法来实现。
报告评分：
指导教师签字：
第二篇：网络安全报告基于DES加密算法实现
基于DES算法的数据文件加密、解密
1 课题背景和意义
信息是一种资源，也是一种财富。在现代社会中，信息处理和通信技术日益发展，保护信息的安全，特别是保护重要信息的安全，越来越成受到国内外有关研究人员的极大重视。当前由于信息的保护不利和失误，世界各国遭受的损失是巨大的。现在，国际互联网上的各站点，几乎都有各种各样的安全措施，例如防火墙(FireWall)、网络加密等。但是，这些都是系统或网站层次的安全设施。对于广大用户来说，更为直接、也更为有效的办法，就是使用信息加密技术。加密技术是一门实用的技术，有着悠久的历史。过去，加密技术仅被军事和谋报人员以及某些大型商业企业所采用，应用范围十分有限。加密学也是一门与数学有关的深奥的科学，有能力研究加密学的人为数不多。恐怕这也是它鲜为人知、较少应用的原因。信息安全的内容主要包括五个部分：信息的保密性、信息的完整性、信息的可用性、信息的可控性、信息的不可否认性。密码技术是保证信息安全的核心。
随着信息社会的到来，人们在享受信息资源所带来的巨大的利益的同时，也面临着信息安全的严峻考验。信息安全已经成为世界性的现实问题，信息安全问题已威胁到国家的政治、经济、军事、文化、意识形态等领域，同时，信息安全问题也是人们能否护自己的个人隐私的关键。信息安全是社会稳定安全的必要前提条件，信息安全是一个综合性的交叉学科领域，广泛涉及数学、密码学、计算机、通信、控制、人工智能、安全工程、人文科学等诸多学科，是近几年迅速发展的一个热点学科领域。信息对抗和网络安全是信息安全的核心热点，它的研究和发展又将刺激、推动和促进相关学科的研究与发展。至今，密码技术是取得信息安全性最有效的一种方法, 密码技术是信息安全的核心技术。
通过数据加密，人们可以有效地保证通信线路上的内容不被泄露，而且还可以检验传送信息的完整性。进一步，密码技术可以应用于数字签名、身份认证和信息鉴定，这些应用对于资源存取控制以及其它安全措施是必须而且有效的。信息安全产品从应用类型上可以分为防火墙类产品、防病毒类产品、防攻击类产品、密码类产品、认证类产品和访问控制类产品。相对于防病毒软件和防火墙软件来说，基于密码技术密码类产品、认证类产品份额相对较小，但随着金融、电信、政府等行业信息化建设对于网络安全整体解决方案需求的增加，将会有较大的增长。
在本次研究中，对公钥密码体制和私钥密码体制进行了分析和研究，并对公钥密码体制和私钥密码体制的代表DES算法进行了专门的研究。并且实现了基本的文件加密解密的处理流程，能提供对文件的安全、有效的保护。
DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组, 密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
1.1 题目描述
本文是一篇讨论关于常用文件加密解密算法的研究性论文，它详细的讲述了文件加密解密算法实现的过程中所用到的方法、技术。对公钥密码体制和私钥密码体制进行了分析和研究，并对公钥密码体制和私钥密码体制的代表DES算法进行了研究。
对称分组密码设计思想的设计绝大部分是基于Feistel[1]结构的，DES就是一种典型的Feistel结构。Feistel网络结构是由Horst Feistel在Lucifer分组密码的设计中首先提出的，Feistel网络的基本元素是F函数：一种非线性、通常不可逆的、基于密匙的映射。Feistel结构最大的优点是容易保证加解密相似，这一点在实现中尤为重要，而SP网络比较难做到这一点，但是SP网络的扩散特性比较好。 Feistel结构使用乘积密码的概念来逼近单代密码，乘积密码是指依次使用两个或者两个以上的基本密码，所得结果的密码强度将强于单个密码的强度，本质是开发一个分组密码。对称分组密码是满足混淆和扩散原则，每一个分组密码都是明文到密文组的变换，另一方面，混淆则是尽可能事密文和加密密匙之间的统计关系更加复杂，以阻止攻击者拥有一些密文的统计特性，而恰好 Feistel密码结构就同时拥有对称结构在实际应用中的实用性，还要密码结构所需要的安全强度，其加密算法的输入是2t位的明文和密匙K，明文被分成两部分，L0和R0，两部分经过n轮迭代后变成密码文组，第i轮迭代输入Li-1和Ri-1来自上一轮的迭代输出，每轮迭代都是相同的结构，只是输入的K不同。代换作用在数据的左半部分，它通过用论函数f作用数据的右半部分，与左半部分数据进行异或来完成。
DES综合运用了置换，代换，移位多种密码技术，是一种乘积密码。在算法结构上采用迭代结构，从而使其结构清晰，调理清楚，算法为对合运算，便于实现，运行速度快。DES使用了初始置换IP和IP-1各一次（相应的置换看算法描述图表）置换P16次，安排使用这3个置换的目的是把数据彻底打乱重排。选择置换E一方面把数据打乱重排，另一方面把32位输入扩展为48位，算法中除了S-盒是非线性变换外，其余变换均为显示变换，所以保密的关键是选择S-盒。符合以下3条准则：
1、一个S-盒而言，没有任何线性方程式等价于此S-盒的输出输入关系，即是S-盒是非线性函数。
2、s-盒的任何一位输入，都会导致两位以上的输出改变，即满足"雪崩效应"。
3、定某一个位的输入时，S-盒的4个出位之间，其中0和1的个数之差小。这个准的本质是数据压缩，把四位输入压缩为4位输出。选择S-盒函数的输入中任意改变数位，其输出至少变化两位。因为算法中使用了16次迭代，大大提高了保密性。
1.2 课题目标和意义
本课题要达到的目标是研究出一套利用DES的加密算法实现针对二进制数据（文件）的加/解密软件工具，编程语言不限。与此同时要仔细研究出基于DES算法的数据文件加密、解密的基本原理，要通过这次课题调研是我们对课上所学的密码学有进一步的加深了解，
所谓加密，就是将正常情况下可懂的文件数据输入密码机，由密码机变成不可懂的乱码，即将“明文”变成“密文”；所谓解密，就是上述过程的逆过程，即将“密文” 变成“明文”。密码机可看做是一个用电子元件实现一种复杂数学运算的机器。复杂数学运算可记为，这里C=密文，p=明文，k=密钥，f是密码算法。K是自变量，C是因变量。不同的K有不同的C，对于某个密码算法f，K的选择范围越大，C的变化就越多，这个密码算法被人破译的难度就越大，保密强度就越高。如何评价K的选择范围大小呢？一般是看K的位数，位数长的（如128位以上）选择范围大，位数短的（如56位）选择范围小。一个国家的密码政策，通常是用位数长的高强度密码（位数可达）保护国家秘密，其它用于保护商业秘密。
在数据传输加密过程中，收发双方线路密码机使用的是相同的密码算法，注入了相同的密钥，发方向收方发出明文，经密码机变成密文后送上公网通信线路，到达收方后先经密码机解密再送到收方电脑上。密文在公用通信网上传输时，如果被截收，窃密方收到的是不可懂的乱码，无法窃取信息内容。
在文件存储加密中，加密解密卡加解密采用同一种算法和同一个密钥，工作人员用电脑处理文件后先将文件加密再存入磁盘，以防窃密者盗用磁盘窃取文件。工作人员调用该文件时，文件先经解密再从显示器上显示出来以供使用。
2 DES算法的数据文件加密、解密原理
DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。其密钥长度为56位，明文按64位进行分组，将分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
DES加密算法特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。
DES工作的基本原理是，其入口参数有三个:key、data、mode。 key为加密解密使用的密钥，data为加密解密的数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组，形成明文组，key用于对数据加密，当模式为解密模式时，key用于对数据解密。实际运用中，密钥只用到了64位中的56位，这样才具有高的安全性。
DES( Data Encryption Standard)算法，于1977年得到美国政府的正式许可，是一种用56位密钥来加密64位数据的方法。虽然56位密钥的DES算法已经风光不在,而且常有用Des加密的明文被破译的报道,但是了解一下昔日美国的标准加密算法总是有益的,而且目前DES算法得到了广泛的应用,在某些场合,仍然发挥着余热。
3程序设计步骤
3.1 程序设计步骤
（1）加密过程设计
DES首先对64位的明文数据分组进行操作，通过一个初始置换，将明文分组等分成左右两半部分，然后进行16轮完全相同的运算，在每一轮运算中，对密钥位进行移位，再从56位密钥中选出48位；同时通过一个扩展置换将数据的右半部分扩展成48位，再通过异或操作与计算得到的48位子密钥结合，并通过8个S盒将这48位替代成新的32位数据，再将其置换一次。
然后，通过另一个异或运算，将运算函数 f的输出与左半部分结合，其结果成为新的右半部分，旧的右半部分成为新的左半部分。将该操作重复16次，便实现了DES的16轮运算。经过16轮后，左、右半部分结合在一起，最后再通过一个逆初始置换，这样就完成DES加密算法。
DES加密算法的具体过程描述如下：
DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下：
其功能是把输入的64位数据块按位重新组合，并把输出分为L0、R0两部分，每部分各长32位，其置换规则见下表：
58,50,12,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,
即将输入的第58位换到第一位，第50位换到第2位，...，依此类推，最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0 是右32位，例：设置换前的输入值为D1D2D3......D64，则经过初始置换后的结果为：L0=D58D50...D8；R0=D57D49...D7。
经过26次迭代运算后。得到L16、R16，将此作为输入，进行逆置换，即得到密文输出。逆置换正好是初始置的逆运算，例如，第1位经过初始置换后，处于第40位，而通过逆置换，又将第40位换回到第1位，其逆置换规则如下表所示：
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,
放大换位表
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,
单纯换位表
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,
在f(Ri,Ki)算法描述图中，S1,S2...S8为选择函数，其功能是把6bit数据变为4bit数据。下面给出选择函数Si(i=1,2......8)的功能表：
选择函数Si
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,
在此以S1为例说明其功能，我们可以看到：在S1中，共有4行数据，命名为0，1、2、3行；每行有16列，命名为0、1、2、3，......，14、15列。
现设输入为： D＝D1D2D3D4D5D6
令：列＝D2D3D4D5
行＝D1D6
然后在S1表中查得对应的数，以4位二进制表示，此即为选择函数S1的输出。下面给出子密钥Ki(48bit)的生成算法
从子密钥Ki的生成算法描述图中我们可以看到：初始Key值为64位，但DES算法规定，其中第8、16、......64位是奇偶校验位，不参与DES运算。故Key 实际可用位数便只有56位。即：经过缩小选择换位表1的变换后，Key 的位数由64 位变成了56位，此56位分为C0、D0两部分，各28位，然后分别进行第1次循环左移，得到C1、D1，将C1（28位）、D1（28位）合并得到56位，再经过缩小选择换位2，从而便得到了密钥K0（48位）。依此类推，便可得到K1、K2、......、K15，不过需要注意的是，16次循环左移对应的左移位数要依据下述规则进行：
循环左移位数
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
（2）DES解密过程
解密可以表示为：
DES加解密过程：令i表示迭代次数,
表示逐位模2求和,f为加密函数.DES的解密过程（6416,,2,1), (16,,2,1)64(1616111100LRIPbitikRfLRiRLbitIPRL iiiiii>←←<←明文密文初始置换IP和初始逆置换IP—1Li-1(32比特)Ri-1(32比特)Li(32比特)48比特寄存器，选择扩展运算E48比特寄存器子密钥Ki_table(48比特)32比特寄存器选择压缩运算S置换运算PRi(32比特)Li=Ri-1DES的一轮迭代DES: Function FExpansion: 32 48S-box: 6 4Permutation选择运算
32 | 01 02 03 04 | 05
04 | 05 06 07 08 | 09
08 | 09 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 | 01
对每个盒,6比特输入中的第1和第6比特组成的二进制数确定的行,中间4位二进制数用来确定的列.中相应行,列位置的十进制数的4位二进制数表示作为输出.例如的输入为101001,则行数和列数的二进制表示分别是11和0100,即第3行和第4列,的第3行和第4列的十进制数为3,用4位二进制数表示为0011,所以的输出为0011.Permutation
16 07 20 21 29 12 28 17
01 15 23 26 05 18 31 10
02 08 24 14 32 27 03 09
19 13 30 06 22 11 04 25
子密钥的产生 k1(56位) (48位)Ki_table(56位) (48位)64位密钥置换选择1C0(28位) D0(28位)循环左移循环左移C1(28位) D1(28位)循环左移循环左移Ci(28位) Di(28位)置换选择2置换选择2密钥表的计算逻辑循环左移: 1 1 9 1，2 1 10 2，3 2 11 2，4 2 12 2，5 2 13 2，6 2 14 2，7 2 15 2，8 2 16 1置换选择1(PC-1)和置换选择2(PC-2)
3.2 重点和难点问题分析
程序设计中遇到的难点问题首先是对DES算法的数据文件加密/解密的原理的理解掌握，其次就是编程基础，由于编程基础有限所以要在理解和领悟DES算法的数据文件加密、解密原理的基础上编出一套程序来确实是很不容易的意见事情，需要查阅大量的资料。
4 系统的测试与评价
经过不断的测试与修改，程序已经可以很好的满足用户的要求，所预计的各功能都能实现。本程序可以加密1-4096个字符的任意长度字符串，如果密钥长度过短或者为空,程序将使用默认密钥进行加密，加密结果将用16进制字符显示，本加密程序同时支持中/英文字符，本加密程序支持特殊字符等等。基本完成预期的功能能够进行加密和解密工作。
5 小结
经过这段时间的调研、设计和开发，已经基本完成本系统对数据进行加密和解密的功能。在本次编写调研报告的过程中遇到很多困难，首先是编程问题由于编程基础实在是有限，其次就是对密码学这部分的只是了解比较少，很多东西得从头研究和学习，需要查阅大量的资料，由于各方面的知识水平欠缺，所谓本系统还有很多不完美的地方，但是基本的加密和解密功能还是能完成的，在完成作业的过程中，我感觉到作为计算机专业的学生我所掌握的专业只是还是很肤浅的，应该利用课余时间去多学习和研究一下这个领域的专业只是，还有就是自己的编程水平真的是很差，通过这次编写程序，让我对编程有了一点新的领悟，我觉得自己还需要在编程方面付出很大努力这对下学期的毕业设计和以后走向工作岗位都是有一定好处的，通过这次老师布置的作业是我对DES算法的特点、原理等有关DES算法的各个方面有了更深刻的了解，对数据加密解密这方面也有了一定的掌握不再像以前一样对这方面的了解像白纸一样空白一片。总之通过这次完成大作业让我对网络安全有了一定的了解，感谢娄老师这一学期的教导。让我对网络安全这个领域有了一定的认知。
6 参考文献
[1] 万正道. 网络数据DES加密算法研究与实现[J]. 工业仪表与自动化装置, 2010,(05).
[2] 黄金雪. 浅析加密机在网络安全中的应用[J]. 网络与信息, 2010,(06) .
[3] 吕后坤,雷燕. 数据加密技术的方法及应用[J]. 福建电脑, 2008,(07).
[4] 韦宝典. 高级加密标准AES中若干问题的研究[D]. 西安电子科技大学, 20## .
[5] 陈琳. DES算法的安全性及其应用[J]. 机电技术, 2009,(01) .
[6] 伍红兵. DES数据加密算法原理实现[J]. 电脑编程技巧与维护, 2000,(03) .
[7] 沈虹. 基于DES算法加密过程的研究[J]. 硅谷, 2010,(02) .
[8] 张洁,朱丽娟. DES加密算法分析与实现[J]. 软件导刊, 2007,(03) .
[3] 范小波. DES数据加密技术与应用[J]. 才智, 2010,(08) .
[10] 黄长江. 简单DES算法研究[J]. 电脑知识与技术, 2010,(18) .
实验的其它附件
源程序清单:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
publicclass Des{
publicstaticvoid main(String[] args) {
JFrame f=new JFrame();
f.setResizable(false);
JPanel p=new JPanel();
JLabel jmq=new JLabel("加密前明文");
p.add(jmq);
final JTextField txtjmq=new JTextField(20);
p.add(txtjmq);
JLabel jmh=new JLabel("加密后密文文");
p.add(jmh);
final JTextField txtjmh=new JTextField(20);
p.add(txtjmh);
JLabel jiemh=new JLabel("解密后明文");
p.add(jiemh);
final JTextField txtjiemh=new JTextField(20);
p.add(txtjiemh);
txtjmq.addActionListener(new ActionListener(){
publicvoid actionPerformed(ActionEvent e){
txtjmh.requestFocus();
txtjmh.selectAll();
}
});
txtjmh.addActionListener(new ActionListener(){
publicvoid actionPerformed(ActionEvent e){
try{
String data=txtjmq.getText();
txtjiemh.setText(data);
byte[] result = desUtil.DesEncrypt(data.getBytes(), 1);
System.err.println("加密后密文：" + new String(result));
txtjmh.setText(result);
txtjmq.requestFocus();
txtjmq.selectAll();
}catch(Exception ex){
txtjiemh.setText("程序错误");
txtjmq.requestFocus();
txtjmq.selectAll();
}
}
});
f.getContentPane().add(p);
f.setSize(300,800);
f.show();
String key = txtjmq.getText();
String data = "张小娜";
Des desUtil = new Des(key);
System.err.println("加密前明文：" + data);
byte[] result = desUtil.DesEncrypt(data.getBytes(), 1);
System.err.println("加密后密文：" + new String(result));
System.err.println("解密后明文："+ new String(desUtil.DesEncrypt(result, 0)));
}
byte[] bytekey;
public Des(String strKey) {
this.bytekey = strKey.getBytes();
} privatestaticfinalint[] 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 };
privatestaticfinalint[] IP_1 = { 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 };
privatestaticfinalint[] 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 }; // 56
privatestaticfinalint[] PC_2 = { 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 };
privatestaticfinalint[] E = { 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 }; // 48
privatestaticfinalint[] P = { 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 };
privatestaticfinalint[][][] S_Box = { {
{ 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 } }
};
privatestaticfinalint[] LeftMove = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2,2, 2, 2, 1 };
privatebyte[] UnitDes(byte[] des_key, byte[] des_data, int flag) {
if ((des_key.length != 8) || (des_data.length != 8)|| ((flag != 1) && (flag != 0))) {
thrownew RuntimeException("Data Format Error !");
}
int flags = flag;
int[] keydata = newint[64];
int[] encryptdata = newint[64];
byte[] EncryptCode = newbyte[8];
int[][] KeyArray = newint[16][48];
keydata = ReadDataToBirnaryIntArray(des_key);
encryptdata = ReadDataToBirnaryIntArray(des_data);
KeyInitialize(keydata, KeyArray);
EncryptCode = Encrypt(encryptdata, flags, KeyArray);
return EncryptCode;}
privatevoid KeyInitialize(int[] key, int[][] keyarray) {
int i;
int j;
int[] K0 = newint[56];
for (i = 0; i < 56; i++) {
K0[i] = key[PC_1[i] - 1]; }
for (i = 0; i < 16; i++) {
LeftBitMove(K0, LeftMove[i]);
for (j = 0; j < 48; j++) {
keyarray[i][j] = K0[PC_2[j] - 1]; }}}
privatebyte[] Encrypt(int[] timeData, int flag, int[][] keyarray) {
int i;
byte[] encrypt = newbyte[8];
int flags = flag;
int[] M = newint[64];
int[] MIP_1 = newint[64];
for (i = 0; i < 64; i++) {
M[i] = timeData[IP[i] - 1];
}
if (flags == 1) { for (i = 0; i < 16; i++) {
LoopF(M, i, flags, keyarray);
}
} elseif (flags == 0) {
for (i = 15; i > -1; i--) {
LoopF(M, i, flags, keyarray);
}
}
for (i = 0; i < 64; i++) {
MIP_1[i] = M[IP_1[i] - 1];
}
GetEncryptResultOfByteArray(MIP_1, encrypt);
return encrypt;
}
privateint[] ReadDataToBirnaryIntArray(byte[] intdata) {
int i;
int j;
int[] IntDa = newint[8];
for (i = 0; i < 8; i++) {
IntDa[i] = intdata[i];
if (IntDa[i] < 0) {
IntDa[i] += 256;
IntDa[i] %= 256;}}
int[] IntVa = newint[64];
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
IntVa[((i * 8) + 7) - j] = IntDa[i] % 2;
IntDa[i] = IntDa[i] / 2;}}
return IntVa;}
privatevoid LeftBitMove(int[] k, int offset) {
int i;
int[] c0 = newint[28];
int[] d0 = newint[28];
int[] c1 = newint[28];
int[] d1 = newint[28];
for (i = 0; i < 28; i++) {
c0[i] = k[i];
d0[i] = k[i + 28];}
if (offset == 1) {
for (i = 0; i < 27; i++) { /
c1[i] = c0[i + 1];
d1[i] = d0[i + 1];}
c1[27] = c0[0];
d1[27] = d0[0];
} elseif (offset == 2) {
for (i = 0; i < 26; i++) {
c1[i] = c0[i + 2];
d1[i] = d0[i + 2];}
c1[26] = c0[0];
d1[26] = d0[0];
c1[27] = c0[1];
d1[27] = d0[1];}
for (i = 0; i < 28; i++) {
k[i] = c1[i];
k[i + 28] = d1[i];}}
privatevoid LoopF(int[] M, int times, int flag, int[][] keyarray) {
int i;
int j;
int[] L0 = newint[32];
int[] R0 = newint[32];
int[] L1 = newint[32];
int[] R1 = newint[32];
int[] RE = newint[48];
int[][] S = newint[8][6];
int[] sBoxData = newint[8];
int[] sValue = newint[32];
int[] RP = newint[32];
for (i = 0; i < 32; i++) {
L0[i] = M[i];
R0[i] = M[i + 32];}
for (i = 0; i < 48; i++) {
RE[i] = R0[E[i] - 1];
RE[i] = RE[i] + keyarray[times][i];
if (RE[i] == 2) {
RE[i] = 0;}}
for (i = 0; i < 8; i++) {
for (j = 0; j < 6; j++) {
S[i][j] = RE[(i * 6) + j];}
sBoxData[i] = S_Box[i][(S[i][0] << 1) + S[i][5]][(S[i][1] << 3)
+ (S[i][2] << 2) + (S[i][3] << 1) + S[i][4]];
for (j = 0; j < 4; j++) {
sValue[((i * 4) + 3) - j] = sBoxData[i] % 2;
sBoxData[i] = sBoxData[i] / 2;}}
for (i = 0; i < 32; i++) {
RP[i] = sValue[P[i] - 1];
L1[i] = R0[i];
R1[i] = L0[i] + RP[i];
if (R1[i] == 2) {
R1[i] = 0;}
if (((flag == 0) && (times == 0)) || ((flag == 1) && (times == 15))) {
M[i] = R1[i];
M[i + 32] = L1[i];}
else {
M[i] = L1[i];
M[i + 32] = R1[i];} }
privatevoid GetEncryptResultOfByteArray(int[] data, byte[] value) {
int i;
int j;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
value[i] += (data[(i << 3) + j] << (7 - j));}}
for (i = 0; i < 8; i++) {
value[i] %= 256;
if (value[i] > 128) {
value[i] -= 255;}}}
privatebyte[] ByteDataFormat(byte[] data, int flag) {
int len = data.length;
int padlen = 8 - (len % 8);
int newlen = len + padlen;
byte[] newdata = newbyte[newlen];
System.arraycopy(data, 0, newdata, 0, len);
for (int i = len; i < newlen; i++)
newdata[i] = (byte) padlen;
return newdata;
}
publicbyte[] DesEncrypt(byte[] des_data, int flag) {
byte[] format_key = ByteDataFormat(bytekey, flag);
byte[] format_data = ByteDataFormat(des_data, flag);
int datalen = format_data.length;
int unitcount = datalen / 8;
byte[] result_data = newbyte[datalen];
for (int i = 0; i < unitcount; i++) {
byte[] tmpkey = newbyte[8];
byte[] tmpdata = newbyte[8];
System.arraycopy(format_key, 0, tmpkey, 0, 8);
System.arraycopy(format_data, i * 8, tmpdata, 0, 8);
byte[] tmpresult = UnitDes(tmpkey, tmpdata, flag);
System.arraycopy(tmpresult, 0, result_data, i * 8, 8); }
byte[] decryptbytearray = null;
if (flag == 0) {
int total_len = datalen;
int delete_len = result_data[total_len - 8 - 1];
delete_len = ((delete_len >= 1) && (delete_len <= 8)) ? delete_len : 0;
decryptbytearray = newbyte[total_len - delete_len - 8];
boolean del_flag = true;
for (int k = 0; k < delete_len; k++) {
if (delete_len != result_data[total_len - 8 - (k + 1)])
del_flag = false; }
if (del_flag == true) {
System.arraycopy(result_data, 0, decryptbytearray, 0, total_len- delete_len - 8);}}
return (flag == 1) ? result_data : decryptbytearray; }
}
组内自评成绩单（由组长填写，要求小组成员签字。并由组长最终签字确认）
表1
表2
填表人（组长）签字： 填写日期：