DES算法实现与分析论文.docx

DES算法实现与分析论文.docx

《DES算法实现与分析论文.docx》由会员分享，可在线阅读，更多相关《DES算法实现与分析论文.docx（14页珍藏版）》请在冰豆网上搜索。

DES算法实现与分析论文

项目报告：

DES算法的实现与分析

组员：

柴彦廷李雨潇唐均王森王钰熊枫

121041302

121041316

121041328

121041333

121041334

121041337

1.引言错误!

未定义书签

2.项目研究错误!

未定义书签

2.1框架设计、模块划分错误!

未定义书签

22DES加密技术简介错误!

未定义书签

3.方案设计错误!

未定义书签

3.1明文的输入与转化错误!

未定义书签

3.2S盒及P盒原理简介错误!

未定义书签

3.3子密钥的产生错误!

未定义书签

3.416轮循环加密错误!

未定义书签

4.仿真结果输出错误!

未定义书签

5.DES算法特点总结错误!

未定义书签

6.参考文献错误!

未定义书签

7.程序代码错误!

未定义书签

、引言

项目的选题目的和意义:

DES采用分组乘积密码体制，它是由IBM开发，是对早期被称为Lucifer密码体制的改进。

DES在1975年3月17日首次在联邦记录中公布，而且声明对比算法征求意见。

到1977年2月15日拟议中的DES被采纳为“非密级”应用的一个联邦标准。

最初预期DES乍为一个标准只能使用10~15年，然而，出于种种原因，可能是DES还没有受到严重的威胁，事实证明了DES要长寿得多。

在其被采用后，大约每隔5年被评审一次。

DES的最后一次评审是在1999年1月。

但是，随着计算机计算能力的提高，由于DES的密钥过短，仅有56位，对DES的成功攻击也屡见报端。

尽管如此，DES的出现是现代密码学历史上非常重要的事件。

它对于我们分析掌握分组密码的基本理论与设计原理仍然具有重要的意义。

本课题是在Matlab的环境下对DES算法的实现和分析，探究DES算法的原理。

二、项目研究

2.1、框架设计，模块划分：

2.1.1、总体分为三个模块：

1、数据初始化：

明文的输入（字符串形式）及转化为数字串。

2、产生子密钥

3、16轮循环加密及密文输出

2.1.2、总体流程图：

2.2.DES加密技术简介:

DES是一个16轮的Feistel型结构密码，它的分组长度为64比特，用一个56比特的密钥来加密一个64比特的明文串，输出一个64比特的密文串。

其中，使用密钥为64比特，实用56比特，另8位用作奇偶校验。

加密的过程是先对64位明文分组进行初始置换，然后分左、右两部分分别经过16轮迭代，然后再进行循环移位与变换，最后进行逆变换得出密文。

加密与解密使用相同的密钥，因而它属于对称密码体制。

假设输入的明文数据是64比特。

首先经过初始置换IP后把其左半部分32比特记为L0,右半部分32比特记为R0,即成了置换后的输入；然后把R0与密钥产生器产生的子密钥k1进行运算，其结果计为f（R0,k1）;再与L0进行摸2加得到L0®f（R0,k1）,把R0记为L1放在左边，而把L0®f（R0,k1）记为R1放在右边，从而完成了第一轮迭代运算。

在此基础上，重复上述的迭代过程，一直迭代至第16轮。

所得的第16轮迭代结果左右不交换，即L15®f（R15,k16）记为R16,放在左边，而R15记为L16放在右边，成为预输出，最后经过初始置换的逆置换IP-1运算后得到密文。

三、方案设计：

3.1明文的输入与转化为数字串

由于输入的明文和密钥都是16进制表示的字符串格式，因此在输入后要将字符串转换为01数字串。

程序:

MBi=[str2num（MBi

（1））,str2num（MBi

（2））,str2num（MBi（3））,str2num（MBi（4））]；%字符串矩阵被转换成一个数值矩阵

MB=[MB,MBi];

end

M=MB;

3.2S盒及P盒原理简介

S盒运算：

在密码函数f（R,k）中有8个S盒，称为8个不同的选择函数，分别用（S1、S2-S8）表示。

每个S盒都是将6位作为输入，得到一个4位块作为输出。

以S1为例，若B是6位的一个块，则S1（B）计算如下：

B的第一和最后一位表示从0到3之间的二进制数，令该数为i;而B的中间4位表示从0到15之间的二进制数，令该数为j;在该表S1中查第i行j列的数，它是从0到15之间的一个数，且唯一地由4位块代表，则该块就是输入B的S1的输出S1（B）例如对于输入为101000而言，行是10,即第2行。

而列是由0100确定，即第5列，S1盒的第2行与第5列的交叉处即为B,因而输出为1101，因此1101就是S盒S1在输入为101000时的输出。

P盒运算：

置换函数P是通过输入块的位，从32位输入中得到32位的输出。

函数P的输出P（C），是通过C的第16位为P（C）的第1位，取第7位为P（C）的第2位,……,取第25为P（C）的第32位。

现在我们就令S1、S2...S8为8个不同的选择函数，P为置换函数，E为扩展函数。

为了计算f（R,k），先规定B1、B2...B8每个为6位块，且

B1、B2...B8=k®E（R）

于是有

f（R,k）=P[S1（B1）S2（B2）...S8（B8）]

因此，在f（R,k）的计算中将k®E（R）分成8个块，即每块6位（即Bi）,然后每个Bi取作Si的一个输入就得到每个都为4位的8个块Si（Bi）（i=1,2,…,8）的输出，再将此8块连接成32位的整块。

这个整块就构成了P的输出，经P置换，即为f（R,k）的输出。

3.3子密钥的产生

在DES中，每一轮迭代都使用了一个轮密钥。

轮密钥是从用户输入的密钥k

（64位）产生的。

实用密钥是56位，另8位是奇偶校验位：

输出密钥k的第8,16,…,64位为奇偶校验位（每一字节的最后一位），这些位的值使

得每个字节恰好包含了奇数个1,这样如果输入密钥中某个字节中存在一个错误，奇偶校验可以帮助查到这些错误。

输入的密钥k先经过一个置换（称为“置换选择T）进行重排。

置换结果

（56位）被当成两个28比特的量C0与D0,其中C0是置换结果的前28位,而D0是置换结果的后28位。

注意到，在置换选择1中不出现第8,16,24,32,40,48,6,4位，因此实际64位的密钥k在经过置换选择1后，奇偶校验位被删除掉而仅保留下有效的56位密钥。

置换选择1与初始置换IP的含义类似。

例如，置换结果C0的第7位是输入密钥k的第9位，而置换结果D0的第10位是输入密钥的第54位。

在计算第i轮迭代所需要的子密钥时，首先对Ci-1与Di-1进行循

环左移，分别得到Ci与Di。

循环的次数取决于i的值：

如果i=1,2,9和16,循环左移的次数是1;否则循环左移的次数等于2。

这些经过移位的值将作为下一个循环的输入。

然后，以CiDi作为另外一个由DES算法固定的置换选择（称为“置换选择2”）的输入，所得到的置换结果即为第i轮迭代所需要的子密钥ki。

3.4、16轮循环加密

以经过S1为例：

B=R_Ki（1:

6）;

x=B

（1）*2+B（6）+1;%将第一比特与第六比特组合在一起形成行号xy=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;%将第二三四五比特组合在一起形成列号yC=['0000',dec2bin（S1（x,y））]%将由盒s1查到的十进制数转化为四位二进制

C=C（end-3:

end）;%将C编号为

C

（1），C

（2）,C（3）,C（4）

C1=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

四、测试：

对于相同的明文，当密钥不同时，经过DES加密所得的密文是不同的。

>>DE5TCAA0BO613£73&：

CDDJ）

44Cff7C9F123456AB

0001CL00100110CD

sms=

；1CE7C9F123156A£

五、DES算法特点总结:

算法特点：

分组比较短、密钥太短、密码生命周期短、运算速度较慢。

DES算法具有极高安全性，到目前为止，除了用穷举搜索法对DES算法进行攻击外，

还没有发现更有效的办法。

而56位长的密钥的穷举空间为256，这意味着如果一台计算机

的速度是每一秒钟检测一百万个密钥，则它搜索完全部密钥就需要将近2285年的时间，可

见，这是难以实现的。

然而，这并不等于说DES是不可破解的。

而实际上，随着硬件技术

和Intemet的发展，其破解的可能性越来越大，而且，所需要的时间越来越少。

使用经过特

殊设计的硬件并行处理要几个小时。

六、参考文献：

【1】（美）帕尔，（美）佩尔茨尔，深入

2浅出密码学一一常用加密技术原理与应用【M】。

清华大学出版社，2012。

【2】（加）斯廷森，密码学原理与实践

【Ml。

电子工业出版社，2009。

【3】CleveMoler，MATLAB数值计算【M】。

北京航空航天大学出版社，2015。

七、程序代码：

functionC=DEST（M,K）

%%

%数据加密标准DES算法的Matlab实现

%输入明文M和密钥K用16进制数表示，字符串格式

%第一步：

数据初始化

%以字符串形式输入的明文转换成01数字串

MB=[];

fori=1:

16

Mi=M（i）;

MBi=['0000',dec2bin（hex2dec（Mi））];%将16进制数转化为2进制

MBi=MBi（end-3:

end）;

MBi=[str2num（MBi

（1））,str2num（MBi

（2））,str2num（MBi（3））,str2num（MBi（4））]

;%字符串矩阵被转换成一个数值矩阵

MB=[MB,MBi];

end

M=MB;

%以字符串形式将输入的密钥转化成01数字串

KB=[];

fori=1:

16

Ki=K（i）;

KBi=['0000',dec2bin（hex2dec（Ki））];

KBi=KBi（end-3:

end）;

KBi=[str2num（KBi

（1））,str2num（KBi

（2））,str2num（KBi（3））,str2num（KBi（4））]

KB=[KB,KBi];

end

K=KB;

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

%将32比特变成48比特的扩展换位表功能表（S盒）

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

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];%直接换位表、单纯换位表（P盒置换表）

PC1=[57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,27,19,1

1,3,60,52,44,36,63,55,47,39,31,23,15,7,62,54,46,38,30,22,14,6,61,53,4

5,37,29,21,13,5,28,20,12,4];%将密钥去除奇偶校验的去除表

PC2=[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];%将56比特的密钥经过压缩换位变成48比特的轮密钥

%%第二步：

产生子密钥

Ki=zeros（16,48）;

K_PC1=K（PC1）;%经过密钥初始置换

C0=K_PC1（1:

28）;%将密钥分成左边28比特

D0=K_PC1（29:

56）;%右边28比特

fori=1:

16

ifi==1||i==2||i==9||i==16%在置换之后，密钥到的左右两部分都根据比特移位

表左移一位，或者两位，由移位表可知第1、2、9、16轮循环左移1位

C0=[C0（2:

end）,C0

（1）];

D0=[D0（2:

end）,D0

（1）];

else%其它轮循环左移2位

C0=[C0（3:

end）,C0（1:

2）];

D0=[D0（3:

end）,D0（1:

2）];

end

K_LS=[C0,D0];

Ki（i,:

）=K_LS（PC2）;%将循环移位之后56比特压缩置换变为48比特的轮密钥

k1,k2,k3,k4,到k16

end%%第三步：

16轮循环加密

C1=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S2盒

B=R_Ki（7:

12）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S2（x,y））];

C=C（end-3:

end）;

C2=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S3盒

B=R_Ki（13:

18）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S3（x,y））];

C=C（end-3:

end）;

C3=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S4盒

B=R_Ki（19:

24）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S4（x,y））];

C=C（end-3:

end）;

C4=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S5盒

B=R_Ki（25:

30）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S5（x,y））];

C=C（end-3:

end）;

C5=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S6盒

B=R_Ki（31:

36）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S6（x,y））];

C=C（end-3:

end）;

C6=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S7盒

B=R_Ki（37:

42）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S7（x,y））];

C=C（end-3:

end）;

C7=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

%经过S8盒

B=R_Ki（43:

48）;

x=B

（1）*2+B（6）+1;

y=B

（2）*8+B（3）*4+B（4）*2+B（5）+1;

C=['0000',dec2bin（S8（x,y））];

C=C（end-3:

end）;

C8=[str2num（C

（1））,str2num（C

（2））,str2num（C（3））,str2num（C（4））];

C=[C1,C2,C3,C4,C5,C6,C7,C8];%经过8个S盒的结果合并起来

R_P=C（P）;

end

fori=1:

15%经过P盒置换

%交换左右两半部分

TEMP=L;L=R;R=mod（TEMP+R_P,2）;

ifi==16

TEMP=L;

L=mod（TEMP+R_P,2）;

end

%输出密文

C=[L,R];

CS=[];

C=num2str（C）;

pos=C~='';

C=C（pos）;

fori=1:

4:

61

Ci=C（i:

i+3）;

CS=[CS,num2str（dec2hex（bin2dec（Ci）））];end

C=CS;

disp（C）;

disp（Ki（1:

16））;