DES加密算法的JAVA实现Word格式文档下载.docx

DES加密算法的JAVA实现Word格式文档下载.docx

《DES加密算法的JAVA实现Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《DES加密算法的JAVA实现Word格式文档下载.docx（26页珍藏版）》请在冰点文库上搜索。

在过去近三十年的应用中，还无法将这种加密算法完全、彻底地破解掉。

而且这种算法的加解密过程非常快，至今仍被广泛应用，被公认为安全的。

虽然近年来由于硬件技术的飞速发展，破解DES已经不是一件难事，但学者们似乎不甘心让这样一个优秀的加密算法从此废弃不用，于是在DES的基础上有开发了双重DES（DoubleDES,DDES）和三重DES（TripleDES,TDES）。

在国内，随着三金工程尤其是金卡工程的启动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN码加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。

DES加密体制是ISO颁布的数据加密标准。

因此研究DES还是有非常重要的意义。

二、DES概述

DES的前身是IBM的Lucifer算法，后经美国联邦采用这个算法后更名为数据加密标准。

DES是一种块加密算法，每块长64比特。

DES的密钥长度也是64比特，但由于其中的8，16，24，32，48，56，64为作为奇偶校验位，所以实际的密钥只有56比特。

DES利用了香农提出的混淆和扩散的概念。

DES共有16论，每一轮都进行混淆和扩散。

DES主要有三个步骤：

利用初始置换函数IP对64比特明文块进行初始置换。

将初始置换的输出分成联邦，分别表示为左明文L0和右明文R0。

进行16次迭代，迭代规则如下：

Li=Ri,Ri=Li-1⊕f（Ri-1,Ki）。

其中Li和Ri分别表示第i轮的左半部和右半部。

f（）是运算函数，Ki是长为48位的子密钥。

子密钥K1,K2,……，K16是根据56比特的密钥K计算而来的。

对比特串R16L16使用逆置换IP-1得到密文。

在DES被提出时，曾出现过很多批评，其中之一就是针对S盒。

DES里的所有计算，除了S盒，全是线性的也就是说，计算两个输出的异或与先将两个对应输入异或再计算其输出是相同的。

作为非线性部分，S盒对密码体制的安全性至关重要。

在DES刚提出时就有人怀疑S盒里隐藏了“陷门（trapdoor）”，而美国国家安全局能够轻易的解密消息。

当然，无法否定这样的猜测，但到目前为止也没有任何证据能证明DES里有陷门。

事实上，后来表明DES里的S盒是被设计来防止模型攻击的。

对DES最中肯的批评是，密钥空间的规模是256，对实际安全而言确实太小了。

对于穷举法，一台每毫秒执行一次DES加密的计算机需要一千年才能破解密文。

然而，早在1977年Diffie和Hellman就指出，若用现有技术造一台并行机，它带有1百万个加密机，每个加密机都可以每毫秒执行一次DES加密，那么穷举时间大约10小时。

他们估计这台计算机造价两千万。

1998年7月当EFF（ElectronicFrontierFoundation）宣布一台造价不到25万美元、为特殊目的设计的“DES破译机”破译了DES时，DES终于被清楚地证明是不安全的。

三、DES算法加解密原理

DES算法由加密、子密钥和解密的生成三部分组成。

现将DES算法介绍如下。

加密

DES算法处理的数据对象是一组64比特的明文串。

设该明文串为m=m1m2…m64（mi=0或1）。

明文串经过64比特的密钥K来加密，最后生成长度为64比特的密文E。

其加密过程图示如下：

DES算法加密过程

对DES算法加密过程图示的说明如下：

待加密的64比特明文串m，经过IP置换（初始置换）后，得到的比特串的下标列表如下：

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

该比特串被分为32位的L0和32位的R0两部分。

R0子密钥K1（子密钥的生成将在后面讲）经过变换f（R0,K1）（f变换将在下面讲）输出32位的比特串f1,f1与L0做不进位的二进制加法运算。

运算规则为：

f1与L0做不进位的二进制加法运算后的结果赋给R1，R0则原封不动的赋给L1。

L1与R0又做与以上完全相同的运算，生成L2，R2……一共经过16次运算。

最后生成R16和L16。

其中R16为L15与f（R15,K16）做不进位二进制加法运算的结果，L16是R15的直接赋值。

R16与L16合并成64位的比特串。

值得注意的是R16一定要排在L16前面。

R16与L16合并后成的比特串，经过置换IP-1（终结置换）后所得比特串的下标列表如下：

IP-1

经过置换IP-1后生成的比特串就是密文e.。

变换f（Ri-1,Ki）:

它的功能是将32比特的输入再转化为32比特的输出。

其过程如图所示：

f变换说明：

输入Ri-1（32比特）经过变换E（扩展置换E）后，膨胀为48比特。

膨胀后的比特串的下标列表如下：

E:

膨胀后的比特串分为8组，每组6比特。

各组经过各自的S盒后，又变为4比特（具体过程见后），合并后又成为32比特。

该32比特经过P变换（压缩置换P）后，其下标列表如下：

P:

经过P变换后输出的比特串才是32比特的f（Ri-1,Ki）.

S盒的变换过程:

任取一S盒。

见图：

在其输入b1,b2,b3,b4,b5,b6中，计算出x=b1*2+b6,y=b5+b4*2+b3*4+b2*8，再从Si表中查出x行，y列的值Sxy。

将Sxy化为二进制，即得Si盒的输出。

（S表如图所示）

以上是DES算法加密原理

加密过程实现（JAVA主要源代码）

输入64位明文串，经过IP置换：

for（i=0;

i<

64;

i++）{

M[i]=timeData[IP[i]-1];

}

迭代（由于各次迭代的方法相同只是输入输出不同，因此以任意一次为例）：

首先进行S盒的运算。

输入32位比特串,经过E变换，由32位变为48位：

48;

RE[i]=R0[E[i]-1];

与keyarray[times][i]按位作不进位加法运：

RE[i]=RE[i]+keyarray[times][i];

if（RE[i]==2）{

RE[i]=0;

48位分成8组：

for（i=0;

i<

8;

i++）{

for（j=0;

j<

6;

j++）{

S[i][j]=RE[（i*6）+j];

}

经过S盒，得到8个数：

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]];

将8个数变换输出二进制：

for（j=0;

j<

4;

j++）{

sValue[（（i*4）+3）-j]=sBoxData[i]%2;

sBoxData[i]=sBoxData[i]/2;

经过P变换：

RP[i]=sValue[P[i]-1];

至此，S盒运算完成

左右交换：

L1[i]=R0[i];

R1[i]=L0[i]+RP[i];

Ri为Li-1与f（R,K）进行不进位二进制加法运算结果：

if（R1[i]==2）{

R1[i]=0;

各次迭代类似，可以依此类推。

2、子密钥的生成

64比特的密钥生成16个48比特的子密钥。

其生成过程见图：

子密钥生成过程

具体解释如下：

64比特的密钥K，经过PC-1（置换A）后，生成56比特的串。

其下标如表所示：

PC-1

该比特串分为长度相等的比特串C0和D0。

然后C0和D0分别循环左移1位，得到C1和D1。

C1和D1合并起来生成C1D1。

C1D1经过PC-2（置换B）变换后即生成48比特的K1。

K1的下标列表为：

PC-2

C1、D1分别循环左移LS2位，再合并，经过PC-2，生成子密钥K2……依次类推直至生成子密钥K16。

注意：

Lsi（I=1,2,….16）的数值是不同的。

具体见下表：

迭代顺序

左移位数

子密钥的生成（JAVA源代码）：

输入64位K，经过PC-1变为56位：

56;

K0[i]=key[PC_1[i]-1];

56位的K0，均分为28位的C0，D0。

C0，D0生成K1和C1，D1（以下几次迭代方法相同，仅以生成任意一次为例）：

if（offset==1）{

for（i=0;

27;

i++）{//循环左移一位

c1[i]=c0[i+1];

d1[i]=d0[i+1];

}

c1[27]=c0[0];

d1[27]=d0[0];

}elseif（offset==2）{

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];

28;

k[i]=c1[i];

//生成子密钥ki

k[i+28]=d1[i];

生成的子密钥不同，所需循环左移的位数也不同。

在编程中，生成不同的子密钥应以上述offset表为准。

3解密

DES的解密过程和DES的加密过程完全类似，只不过将16圈的子密钥序列K1，K2……K16的顺序倒过来。

即第一圈用第16个子密钥K16，第二圈用K15，其余类推。

第一圈：

加密后的结果

L=R15,R=L15⊕f（R15,K16）⊕f（R15,K16）=L15

同理R15=L14⊕f（R14,K15）,L15=R14。

同理类推：

得L=R0,R=L0。

其程序源代码与加密相同。

四、加解密算法的实现

1软件版本：

jdk1.6.0,JCreatorProv3.5.013汉化版

2平台:

WindowsXP

3源代码：

publicclassDesUtil{

byte[]bytekey;

publicDesUtil（StringstrKey）{

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};

//64

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};

//48

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};

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};

//32

privatestaticfinalint[][][]S_Box={//S-盒

{//S_Box[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_Box[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_Box[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_Box[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_Box[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_Box[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,