加密算法文档.docx

加密算法文档.docx

《加密算法文档.docx》由会员分享，可在线阅读，更多相关《加密算法文档.docx（37页珍藏版）》请在冰豆网上搜索。

加密算法文档

IDEA算法

IDEA（InternationalDataEncryptionAlgorithm）是瑞士的JamesMassey，XuejiaLai等人提出的加密算法，在密码学中属于数据块加密算法（BlockCipher）类。

IDEA使用长度为128bit的密钥，数据块大小为64bit。

从理论上讲，IDEA属于“强”加密算法，至今还没有出现对该算法的有效攻击算法。

早在1990年，XuejiaLai等人在EuroCrypt’90年会上提出了分组密码建议PES（ProposedEncryptionStandard）。

在EuroCrypt’91年会上,XuejiaLai等人又提出了PES的修正版IPES（ImprovedPES）。

目前IPES已经商品化，并改名为IDEA。

IDEA已由瑞士的Ascom公司注册专利，以商业目的使用IDEA算法必须向该公司申请许可。

IDEA是一种由8个相似圈（Round）和一个输出变换（OutputTransformation）组成的迭代算法。

IDEA的每个圈都由三种函数：

模（2161）乘法、模216加法和按位XOR组成。

在加密之前，IDEA通过密钥扩展（KeyExpansion）将128bit的密钥扩展为52Byte的加密密钥EK（EncryptionKey），然后由EK计算出解密密钥DK（DecryptionKey）。

EK和DK分为8组半密钥，每组长度为6Byte，前8组密钥用于8圈加密，最后半组密钥（4Byte）用于输出变换。

IDEA的加密过程和解密过程是一样的，只不过使用不同的密钥（加密时用EK，解密时用DK）。

密钥扩展的过程如下：

1．将128bit的密钥作为EK的前8byte；

2．将前8byte循环左移25bit，得到下一8byte,将这个过程循环7次；

3．在第7次循环时，取前4byte作为EK的最后4byte；

4．至此52byte的EK生成完毕。

密钥扩展的过程如表1所示，为了能够清楚的看出每个8Byte的关系，在表1中用粗线条将将每个8Byte划分开了

表1IDEA的密钥扩展过程

解密密钥EK和加密密钥DK的关系如表2所示：

IDEA算法如图1所示。

图1IDEA算法

IDEA算法相对来说是一个比较新的算法，其安全性研究也在不断进行之中。

在IDEA算法公布后不久，就有学者指出：

IDEA的密钥扩展算法存在缺陷，导致在IDEA算法中存在大量弱密钥类，但这个弱点通过简单的修改密钥扩展算法（加入异或算子）即可克服。

在1997年的EuroCrypt’97年会上，JohnBorst等人提出了对圈数减少的IDEA的两种攻击算法：

对3.5圈IDEA的截短差分攻击（TruncateDiffrentialAttack）和对3圈IDEA的差分线性攻击（DiffrentialLinearAttack）。

但作者也同时指出，这两种攻击算法对整8.5圈的IDEA算法不可能取得实质性的攻击效果。

目前尚未出现新的攻击算法，一般认为攻击整8.5圈IDEA算法唯一有效的方法是穷尽搜索128bit的密钥空间。

目前IDEA在工程中已有大量应用实例，PGP（PrettyGoodPrivacy）就使用IDEA作为其分组加密算法；安全套接字层SSL（SecureSocketLayer）也将IDEA包含在其加密算法库SSLRef中；IDEA算法专利的所有者Ascom公司也推出了一系列基于IDEA算法的安全产品，包括：

基于IDEA的Exchange安全插件、IDEA加密芯片、IDEA加密软件包等。

IDEA算法的应用和研究正在不断走向成熟

Lai和Massey开发出IDEA加密算法雏形，称为PES，即"建议的加密标准"。

第二年，根据有关专家对这一密码算法的分析结果，设计者对该算法进行了强化并称之为IPES，即"改进的建议加密标准"。

该算法于1992年更名为IDEA，即"国际加密标准"。

IDEA算法的密钥长度为128位,针对64位的数据进行加密或解密操作.设计者尽可能使该算法不受差分密码分析的影响，XueJia Lai已证明IDEA算法在其8轮迭代的第4圈之后便不受差分密码分析的影响了。

假定穷举法攻击有效的话，那么即使设计一种每秒种可以试验10亿个密钥的专用芯片，并将10亿片这样的芯片用于此项工作，仍需1013年才能解决问题；另一方面，若用1024片这样的芯片，有可能在一天内找到密钥，不过人们还无法找到足够的硅原子来制造这样一台机器。

目前，尚无一片公开发表的试图对IDEA进行密码分析的文章。

因此，就现在来看应当说IDEA是非常安全的。

IDEA有大量的弱密钥，这些弱密钥是否会威胁它的安全性还是一个迷。

IDEA密码能够抵抗差分分析和线性分析。

 设计者Lai认为IDEA不是一个群，但目前仍未得到证实。

Eurocrypt'97会议上给出了两种新的攻击低圈IDEA的方法，第一种攻击方法可破译大约3·5-圈的IDEA；第二种攻击方法可破译大约3-圈的IDEA。

但从分析结果来看，这两种攻击方法并未对IDEA的安全性构成威胁。

2.IDEA算法概述  

IDEA是一个迭代分组密码，分组长度为64比特，密钥长度为128比特。

IDEA密码中使用了以下三种不同的运算：

逐位异或运算；  

模216加运算； 

模216 1乘运算，0与216对应。

IDEA算法是由8轮迭代和随后的一个输出变换组成。

它将64比特的数据分成4个子块，每个16比特，令这四个子块作为迭代第一轮的输出，全部共8轮迭代。

每轮迭代都是4个子块彼此间以及16比特的子密钥进行异或，模216加运算，模216 1乘运算。

除最后一轮外把每轮迭代输出的四个子块的第二和第三子块互换。

该算法所需要的"混淆"可通过连续使用三个"不相容"的群运算于两个16比特子块来获得，并且该算法所选择使用的MA-（乘加）结构可提供必要的"扩散"。

3.IDEA算法的具体描述

3.1密钥生成

用户输入128位长密钥  

Key = k1k2k3…k127k128  

IDEA总共进行8轮迭代操作,每轮需要6个子密钥,另外还需要4个额外子密钥,所以总共需要52个子密钥,这个52个子密钥都是从用户输入的128位密钥中扩展出来的. 

首先把输入的Key分成8个16位的子密钥, 1~6号子密钥供第一轮加密使用,7~8号子密钥供第二轮使用,然后把这个128位密钥循环左移25位,这样Key = k26k27k28…k24k25 

把新生成的Key在分成8个16位的子密钥,1~4号子密钥供第二轮加密使用（前面已经提供了两个）5~8号子密钥供第三轮加密使用 ,到此我们已经得到了16个子密钥,如此继续,当循环左移了5次之后已经生成了48个子密钥,还有四个额外的子密钥需要生成,再次把Key循环左移25位,选取划分出来的8个16位子密钥的前4个作为那4个额外的加密密钥.供加密使用的52个子密钥生成完毕. 

K[0]

K[1]

K[2]

K[3]

K[4]

K[5]

…

K[48]

K[49]

K[50]

K[51] 

第一轮

…

额外密钥  

3.2加密明文  

64-位数据分组被分成4个16-位子分组：

D0,D1,D2,D3。

这4个子分组成为算法的第一轮的输入，总共有8轮。

密钥（6组） K1, K2, K3, K4, K5,K6  

执行的顺序如下：

D0和第一个子密钥（K1） 模216 1乘。

D1和第二个子密钥（K2） 模216加。

D2和第三个子密钥（K3） 模216加。

D4和第四个子密钥（K4） 模216 1乘。

第

（1）步和第（3）步的结果相异或。

将第

（2）步和第（4）步的结果相异或。

将第（5）步的结果与第五个子密钥（K5） 模216 1乘。

将第（6）步和第（7）步的结果模216加。

将第（8）步的结果与第六个子密钥（K6） 模216 1乘。

将第（7）步和第（9）步的结果模216加。

将第

（1）步和第（9）步的结果相异或。

将第（3）步和第（9）步的结果相异或。

将第

（2）步和第（10）步的结果相异或。

将第（4）步和第（10）步的结果相异或。

　　将第（11）、（12）、（13）和（14） 步的结果形成的4个子分组D0,D1,D2,D3作为输出,然后将中间两个分组（D1,D2）交换（最后一轮除外）后，作为为下一轮的输入。

　　经过8轮运算之后，有一个最终的输出D0,D1,D2,D3,对这4个输出子分组进行如下操作：

（1） D0和第一个额外子密钥模216 1乘。

（2） D1和第二个额外子密钥模216加。

　　（3） D2和第三个额外子密钥模216加。

　　（4） D3和第四个额外子密钥模216 1乘。

　　最后，这4个子分组重新连接到一起产生密文。

3.3.密文解密

　　介绍IDEA加密算法的资料本就不多而且对于解密过程往往一笔带过,笔者在编程实现IDEA算法时为此大伤脑筋,好在这块骨头总算被啃下了.下文笔者将结合实现代码介绍一下解密过程,如果读者想亲自动手实现IDEA算法,笔者的”痛苦经验”是可以让你少走些弯路的. 

解密操作和加密的步骤基本相同,但是在求密钥时有所区别. 

首先从用户输入的128位密钥扩展出52个子密钥,存放在ULONG16 Key[52]数组中,然后对这个52个子密钥进行换位操作,  

原位置:

6

8

7

9

4

5

0

1

2

3

表中的原位置行的值代表该子密钥在原密钥数组中的位置,比如新密钥数组中的第0号子密钥为原来子密钥组中的第48号子密钥,对子密钥数组换位后,就需要对某些子密钥进行模216 1的乘法逆或模216加法逆的替换,详情见下表（位置是针对换位后的子密钥组） 

1

2

7

8

13

14

19

20

25 

26

31

32

37

38

43

44

49

50 

0

3

6

9

12

15

18

21

24  

27

30

33

36

39

42

45

48

51 

需要变化的子密钥总共18 18 = 36个,另外的52 – 36 = 16个子密钥不变化.  

下面介绍有关x逆元的计算方法. 

x -1 = 65536 – x  

X模216 1乘法法逆和X的关系如下:

（X*X-1 ） e537 = 1  

#define LOW16（x） （（x）&0xffff）  

ULONG16 mulInv（ ULONG16 x）  

{  

ULONG16 t0,t1; 

ULONG16 q,y;  

if （ x<=1）  

{  

return x;  

}  

t1 = 0x10001L/x; 

y = 0x10001L%x; 

if（y == 1）  

{  

return LOW16（1-t1）;  

}  

t0 = 1 ; 

do 

{ 

q = x/y; 

x %= y; 

t0 = q*t1; 

if（ x == 1）  

{  

return t0; 

}  

q = y/x; 

y %=x;  

t1 = q*t0;  

}while（ y !

= 1）;  

return LOW16（1-t1）;  

}  

3.4注意事项

由于在IDEA中采用了乘法运算,这就要考虑到两个乘数是否为0 的情况,如果两个乘数都为0,那么乘法运算结果为0,如果仅有一个乘数为0,那么用65536替换那个为0的乘数,取乘法运算结果的低16位作为输出结果.  

INT32 MUL（ ULONG16 a, ULONG16 b）/*（a*b）*/ 

{  

ULONG32 p;  

if （ a == 0 && b == 0 ） 

{  

p = 0 ;  

}  

else if （ a == 0 ） 

{ 

p = 65536*（ULONG32）b;  

}  

else if （ b == 0）  

{  

p = 65536*（ULONG32）a; 

} 

else  

{ 

p = （ULONG32）a*（ULONG32）b; 

} 

return （ULONG16 ）（pe537）; 

}  

3.5 算法实现代码

/*此处略去信息说明和头文件*/  

#include "idea.h" 

#define NULL （（void *）0） 

typedef int INT32;  

typedef char INT8;  

typedef unsigned char ULONG8;  

typedef unsigned short ULONG16;  

typedef unsigned long ULONG32;  

#define SUCCESS 0  

#define FAIL -1 

#define LOW16（x） （（x）&0xffff） 

#define _USEDFINDTABLE_ 1 /*是否采用查表实现*/  

/*解密时密钥的换位表*/ 

file:

//ULONG16 outkey[52] = { 0 };  

static ULONG8 wz_spkey[52] = { 

48,49,50,51,46,47, 

->43*/  

->37*/ 

->31*/ 

->25*/ 

->19*/ 

->13*/ 

6, 8, 7, 9, 4, 5,/*解密密钥配置,2,3位要交换:

8<->7*/  

0, 1, 2, 3 

};  

static ULONG8 wz_spmulrevr[18] = {/*变乘法逆的位*/ 

0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51  

}; 

static ULONG8 wz_spaddrever[18] ={/*变加法逆的位*/ 

1,2,7,8,13,14,19,20,25,26,31,32,37,38,43,44,49,50  

}; 

INT32 mulInv（ ULONG16 x）;/*取x的（%0x10001L）乘法逆*/  

INT32 handle_data（ ULONG16 *data, /*待加密的64位数据首地址*/  

ULONG16 *key /* 6组本轮使用的16位长的密钥首地址*/ 

）; 

INT32 idea_makekey（ ULONG32 *inkey,/*用户输入的128位密钥首地址*/  

ULONG16 *outkey/*生成的52组16位密钥的首地址*/ 

）;  

INT32 key_leftmove（ULONG32 *inkey）; 

INT32 key_decryExp（ULONG16 *outkey）;/*解密密钥的变逆处理*/ 

INT32 MUL（ ULONG16 a, ULONG16 b）;/*（a*b）*/ 

INT32 idea_dec（ ULONG16 *data, /*待解密的64位数据首地址*/  

ULONG16 *outkey  

） 

{  

ULONG32 i ;  

ULONG16 tmp;  

if （ NULL == data || NULL == outkey） 

{  

return FAIL;  

} 

for （ i = 0 ; i < 48 ; i = 6）/*8轮*/ 

{ 

handle_data（ data , &outkey[i]）;  

/*交换中间两个*/  

tmp = data[1]; 

data[1] = data[2]; 

data[2] = tmp;  

} 

tmp = data[1];/*最后一轮不交换*/  

data[1] = data[2]; 

data[2] = tmp; 

data[0] = MUL（data[0],outkey[48]）; 

data[1] = outkey[49];  

data[2] = outkey[50]; 

data[3] = MUL（data[3],outkey[51]）;  

return SUCCESS;  

}  

INT32 idea_enc（ ULONG16 *data, /*待加密的64位数据首地址*/  

ULONG16 *outkey  

）  

{ 

ULONG32 i ; 

ULONG16 tmp;  

if （ NULL == data || NULL == outkey） 

{  

return FAIL; 

}  

for （ i = 0 ; i < 48 ; i = 6）/*8轮*/  

{  

handle_data（ data , &outkey[i]）;  

/*交换中间两个*/ 

tmp = data[1];  

data[1] = data[2]; 

data[2] = tmp; 

} 

tmp = data[1];/*最后一轮不交换*/  

data[1] = data[2]; 

data[2] = tmp; 

data[0] = MUL（data[0],outkey[48]）; 

data[1] = outkey[49]; 

data[2] = outkey[50]; 

data[3] = MUL（data[3],outkey[51]）;  

return SUCCESS; 

} 

INT32 handle_data（ ULONG16 *data, /*待加密的64位数据首地址*/  

ULONG16 *key /* 6组本轮使用的16位长的密钥首地址*/  

） 

{ 

ULONG16 *D1,*D2,*D3,*D4; 

ULONG16 D57;/*提供给第5,7步用的暂存数据的*/ 

ULONG16 D68;/*提供给第6,8,9,10步用的暂存数据的*/  

D1 = &data[0]; 

D2 = &data[1]; 

D3 = &data[2]; 

D4 = &data[3];  

/*start*/ 

*D1 = MUL（*D1,key[0]）;/*第1步*/  

*D2 = key[1];/*第2步*/  

*D3 = key[2];/*第3步*/ 

*D4 = MUL（*D4,key[3]）;/*第4步*/  

D57 = *D1 ^ *D3;/*第5步*/ 

D68 = *D2 ^ *D4;/*第6步*/ 

D57 = MUL（D57,key[4]）;/*第7步*/  

D68 = D57;/*第8步*/ 

D68 = MUL（D68,key[5]）;/*第9步*/ 

*D1 ^= D68;/*第11步*/ 

*D3 ^= D68;/*第12步*/  

D68 = D57;/*第10步*/  

*D2 ^= D68;/*第13步*/ 

*D4 ^= D68;/*第14步*/ 

return SUCCESS;  

}  

INT32 idea_makekey（ ULONG32 *inkey,/*用户输入的128位密钥首地址*/  

ULONG16 *outkey/*生成的52组16位密钥的首地址*/ 

）  

{ 

ULONG32 i,j,k;  

ULONG16 *Pkey = （ ULONG16*）inkey;  

for （i = 0 ; i < 6; i ）  

{ 

k = i << 3; 

for（ j = 0 ; j < 8 ; j ）/*生成8组密钥*/  

{ 

outkey[k j] = Pkey[j] ;  

} 

key_leftmove（inkey）;/*128位密钥左环移25位*/ 

}  

for（ i = 0 ; i < 4; i ） 

{  

outkey[48 i] = Pkey[i] ; 

}  

return SUCCESS; 

}  

INT32 key_leftmove（ULONG32 *inkey）/*密钥左环移25位*/ 

{ 

ULONG32 itmpfirst = 0,itmp = 0 ; 

3.6 加密工具的实现

利用算法核心代码封装的接口函数笔者编写了一个加密工具, IDEA算法是对固定大小（64位）的数据块进行加密解密操作的,对于那些不够64位的数据块需要采用填充机制补位到64位长,为了方便使用,数据位的填充是对用户而言是透明的,利用该工具进行加密解密操作时,用户只需输入操作的类型、读取数据的文件名、写入操作结果的文件名、密钥等信息.  

#define READFILESIZE 512  

以二进制的形式从文件中读取READFILESIZE个字节的数据,如果从文件中读出的数据少于READFILESIZE个,以0补足,然后根据用户指定的类型对这READFILESIZE个字节的数据进行操作. 

判断文件是否结束,如果还没有介绍则返回执行步骤1 

把加密后的文件实际长度和读出数据的文件名加密后添加到密文的末尾  

结束 

采用一次只从文件读取READFILESIZE个字节是在为了防止由于需要加密或解密的文件太大导致内存不够的情况出现.  

使用该程序加密文件,用户不必记住加密前文件的类型,程序会在解密时自动将密文恢复成原文件的类型和长度. 

3.6.1 加密工具实现源代码

下面列出按照上述操作思路编写的实现源代码  

/**********************************************************************/  

/*-文件名：

idea.c */  

/*- */ 

/*-功能：

 利用idea加密算法实现文件的加密 */ 

/*- */  

/*-说明：

 */ 

/*- 这是利用IDEA算法实现的文件加密工具可以在法律允许范围内以非商 */  

/*-业形式自由使用,该程序的所有权利由作者吴真保留 */ 

/*- */ 

/*-版本号：

1.0.0（2002.6） */  

*/ 

/*- */ 

/************