摘要： IDEA即國(guó)際數(shù)據(jù)加密算法，也是目前使用廣泛的一種算法。本文詳細(xì)介紹了IDEA算法以及c語(yǔ)言如何實(shí)現(xiàn)idea算法，下面一起來看看原文。

　　IDEA算法介紹

　　IDEA，即國(guó)際數(shù)據(jù)加密算法。是旅居瑞士中國(guó)青年學(xué)者來學(xué)嘉和著名密碼專家J.Massey于1990年提出的。它在1990年正式公布并在以后得到增強(qiáng)。這種算法是在DES算法的基礎(chǔ)上發(fā)展出來的，類似于三重DES，和DES一樣IDEA也是屬于對(duì)稱密鑰算法。發(fā)展IDEA也是因?yàn)楦械紻ES具有密鑰太短等缺點(diǎn)，已經(jīng)過時(shí)。IDEA的密鑰為128位，這么長(zhǎng)的密鑰在今后若干年內(nèi)應(yīng)該是安全的。

　　類似于DES，IDEA算法也是一種數(shù)據(jù)塊加密算法，它設(shè)計(jì)了一系列加密輪次，每輪加密都使用從完整的加密密鑰中生成的一個(gè)子密鑰。與DES的不同處在于，它采用軟件實(shí)現(xiàn)和采用硬件實(shí)現(xiàn)同樣快速。

　　由于IDEA是在美國(guó)之外提出并發(fā)展起來的，避開了美國(guó)法律上對(duì)加密技術(shù)的諸多限制，因此，有關(guān)IDEA算法和實(shí)現(xiàn)技術(shù)的書籍都可以自由出版和交流，可極大地促進(jìn)IDEA的發(fā)展和完善。但由于該算法出現(xiàn)的時(shí)間不長(zhǎng)，針對(duì)它的攻擊也還不多，還未經(jīng)過較長(zhǎng)時(shí)間的考驗(yàn)。因此，尚不能判斷出它的優(yōu)勢(shì)和缺陷。

　　IDEA算法特點(diǎn)

　　類似于DES，IDEA算法也是一種數(shù)據(jù)塊加密算法，它設(shè)計(jì)了一系列加密輪次，每輪加密都使用從完整的加密密鑰中生成的一個(gè)子密鑰。與DES的不同處在于，它采用軟件實(shí)現(xiàn)和采用硬件實(shí)現(xiàn)同樣快速。

　　由于IDEA是在美國(guó)之外提出并發(fā)展起來的，避開了美國(guó)法律上對(duì)加密技術(shù)的諸多限制，因此，有關(guān)IDEA算法和實(shí)現(xiàn)技術(shù)的書籍都可以自由出版和交流，可極大地促進(jìn)IDEA的發(fā)展和完善。但由于該算法出現(xiàn)的時(shí)間不長(zhǎng)，針對(duì)它的攻擊也還不多，還未經(jīng)過較長(zhǎng)時(shí)間的考驗(yàn)。因此，尚不能判斷出它的優(yōu)勢(shì)和缺陷。

　　IDEA算法詳解

　　1.產(chǎn)生密鑰

　　算法用了52個(gè)子密鑰。首先，將128-位源密鑰分成8個(gè)16-位子密鑰。源密鑰再次向左環(huán)移25位產(chǎn)生另外8個(gè)子密鑰，如此進(jìn)行直到產(chǎn)生完52個(gè)密匙。具體是：

　　IDEA總共進(jìn)行8輪迭代操作，每輪需要6個(gè)子密鑰，另外還需要4個(gè)額外子密鑰，所以總共需要52個(gè)子密鑰，這個(gè)52個(gè)子密鑰都是從128位密鑰中擴(kuò)展出來的。

　　2.加密、解密過程

　　輸入的64-位數(shù)據(jù)分組被分成4個(gè)16-位子分組：xl，X2，x3和x4。這4個(gè)子分組成為算法的第一輪的輸入，總共有8輪。在每一輪中，這4個(gè)子分組相互相異或，相加，相乘，且與6個(gè)16-位子密鑰相異或，相加，相乘。在輪與輪間，第二和第三個(gè)子分組交換。最后在輸出變換中4個(gè)子分組與4個(gè)子密鑰進(jìn)行運(yùn)算。

　　注意上面的加法運(yùn)算是對(duì)模2的16次方的加法運(yùn)算，即求兩個(gè)數(shù)的和對(duì)65536的余數(shù)，

　　乘法運(yùn)算是對(duì)模2的16次方加1的乘法運(yùn)算，即兩個(gè)數(shù)的積對(duì)65537的余數(shù)。

　　在每一輪中，執(zhí)行的順序如下：

　　（1）X1和第一個(gè)子密鑰相乘。

　　（2）x2和第二個(gè)子密鑰相加。

　　（3）X3和第三個(gè)子密鑰相加。

　　（4）x4和第四個(gè)子密鑰相乘。

　　（5）將第（1）步和第（3）步的結(jié)果相異或。 ·

　　（6）將第（2）步和第（4）步的結(jié)果相異或。

　　（7）將第（5）步的結(jié)果與第五個(gè)子密鑰相乘。

　　（8）將第（6）步和第（7）步的結(jié)果相加。

　　（9）將第（8）步的結(jié)果與第六個(gè)子密鑰相乘。

　　（10）將第（7）步和第（9）步的結(jié)果相加。

　　（11）將第（1）步和第（9）步的結(jié)果相異或。

　　（12）將第（3）步和第（9）步的結(jié)果相異或。

　　（13）將第（2）步和第（10）步的結(jié)果相異或。

　　（14）將第（4）步和第（10）步的結(jié)果相異或。

　　每一輪的輸出是第（11）、（12）、（13）和（14） 步的結(jié)果形成的4個(gè)子分組。將中間兩個(gè)分組分組交換（最后一輪除外）后，即為下一輪的輸入。

　　經(jīng)過8輪運(yùn)算之后，有一個(gè)最終的輸出變換：

　　（1） X1和第一個(gè)子密鑰相乘。

　　（2） x2和第二個(gè)子密鑰相加。

　　（3） x3和第三個(gè)子密鑰相加。

　　（4） x4和第四個(gè)子密鑰相乘。

　　最后，這4個(gè)子分組重新連接到一起產(chǎn)生密文。

? ? ??c語(yǔ)言如何實(shí)現(xiàn)idea算法程例

　　Idea的密匙長(zhǎng)度幾乎是des的兩倍多，因此對(duì)idea的窮舉攻擊幾乎是不可能的（它的空間復(fù)雜度將達(dá)到10的39次方，也許在整個(gè)宇宙中有這么多的存儲(chǔ)空間），idea也可以有效的抵抗中間相遇攻擊和差分分析攻擊事實(shí)上在idea的八輪算法中在第四輪就已經(jīng)具有對(duì)差分密碼分析的免疫了。

　　雖然idea是目前公開算法的最好和最安全的加密算法，但是隨著時(shí)間的流失看似安全的算法往往會(huì)被新的密碼分析方法破譯，目前有幾個(gè)軍事組織已經(jīng)對(duì)idea進(jìn)行密碼分析，他們中的沒有一個(gè)人愿意公布可能成功破譯的結(jié)果，但將來的某一天他們可能會(huì)成功。

　　［c-sharp］ view plain copytypedef unsigned char byte;

　　typedef char *string;

　　typedef unsigned short word16;

　　typedef unsigned long word32;

　　typedef unsigned short uint16;

　　typedef unsigned long ulong;

　　#ifndef TRUE

　　#define FAUSE 0

　　#define TRUE （！FAUSE）

　　#endif

　　#ifndef min

　　#define min（a，b） （（a）《（b）？（a）：（b））

　　#define max（a，b） （（a）》（b）？（a）：（b））

　　#endif

　　#define keysize 16

　　#define blocksize 8

　　#define rounds 8

　　#define keylen （6*rounds+4）

　　typedef struct {

　　word16 jia_key［10］［7］，jie_key［10］［7］;

　　}idea_key;

　　#ifdef IDEA32

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

　　#else

　　#define low16（x） （x）

　　#endif

　　suanfa.cpp

　　［c-sharp］ view plain copy#define HIGHFIRST

　　void key_move（byte a［］） //將源密匙向左移動(dòng)25位

　　{

　　int i;

　　byte b［17］;

　　for（i=0;i《=16;i++）

　　b［i］=0;

　　for（i=1;i《=12;i++）{

　　b［i］|=a［i+3］;

　　b［i］《《=1;

　　b［i］|=（a［i+4］》》7）;

　　}

　　b［13］|=a［16］;

　　b［13］《《=1;

　　b［13］|=a［1］》》7;

　　for（i=14;i《=16;i++）{

　　b［i］|=a［i-13］;

　　b［i］《《=1;

　　b［i］|=（a［i-12］》》7）;

　　}

　　for（i=0;i《=16;i++）

　　a［i］=b［i］;

　　}

　　void get_jia_key（byte userkey［］，uint16 jia_key［］［7］） //從源密匙得到加密密匙

　　{

　　int i，j;

　　uint16 S［54］;

　　for（i=0;i《54;i++）

　　S［i］=0;

　　byte *key=（byte *）（userkey-1）;

　　for（i=0;i《6;i++）{

　　for（j=0;j《8;j++）{

　　S［i*8+j］|=key［2*j+1］;

　　S［i*8+j］《《=8;

　　S［i*8+j］|=key［2*j+2］;

　　}

　　key_move（key）;

　　}

　　for（j=0;j《4;j++）{

　　S［48+j］|=key［2*j+1］;

　　S［48+j］《《=8;

　　S［48+j］|=key［2*j+2］;

　　}

　　for（i=1;i《=8;i++）

　　for（j=1;j《=6;j++）

　　jia_key［i］［j］=S［（i-1）*6+j-1］;

　　for（i=48;i《=51;i++）

　　jia_key［9］［i-47］=S［i］;

　　}

　　uint16 mulinv（uint16 b） //求一個(gè)整數(shù)對(duì)65537的乘法逆元

　　{

　　int a=65537;

　　int x1，x2，x3;

　　int y1，y2，y3;

　　int t1，t2，t3;

　　x1=1;

　　x2=0;

　　x3=a;

　　y1=0;

　　y2=1;

　　y3=b;

　　int k;

　　for（t3=x3%y3;t3！=0;t3=x3%y3）{

　　k=x3/y3;

　　t2=x2-k*y2;

　　t1=x1-k*y1;

　　x1=y1;

　　x2=y2;

　　x3=y3;

　　y1=t1;

　　y2=t2;

　　y3=t3;

　　}

　　if（y2《0）

　　y2+=a;

　　if（y3==1）

　　return （uint16）y2;

　　else

　　return 0;

　　}

　　void get_jie_key（uint16 jia_key［］［7］，uint16 jie_key［］［7］） //從加密密匙得到解密密匙

　　{

　　int j;

　　for（j=1;j《=rounds+1;j++）{

　　if（j==9||j==1）{

　　jie_key［j］［2］=-jia_key［10-j］［2］;

　　jie_key［j］［3］=-jia_key［10-j］［3］;

　　}

　　else {

　　jie_key［j］［2］=-jia_key［10-j］［3］;

　　jie_key［j］［3］=-jia_key［10-j］［2］;

　　}

　　jie_key［j］［1］=mulinv（jia_key［10-j］［1］）;

　　jie_key［j］［4］=mulinv（jia_key［10-j］［4］）;

　　}

　　for（j=1;j《=8;j++）{

　　jie_key［j］［5］=jia_key［9-j］［5］;

　　jie_key［j］［6］=jia_key［9-j］［6］;

　　}

　　}

　　uint16 MULi（uint16 x，uint16 y） //求兩個(gè)數(shù)的積對(duì)65537的余數(shù)

　　{

　　#ifndef SMALL_CACHE

　　uint16 t16;

　　word32 t32;

　　#endif

　　#ifdef SMALL_CACHE

　　return mul（low16（x），y）;

　　#else

　　#ifdef AVOID_JUMPS

　　x=low16（x-1）;

　　t16=low16（（y）-1）;

　　t32=（word32）x*t16+x+t16+1;

　　x=low16（t32）;

　　t16=t32》》16;

　　x=（x-t16）+（x《t16）;

　　return x;

　　#else

　　if（t16=（y））{

　　if（x=low16（x））{

　　t32=（word32）x*t16;

　　x=low16（t32）;

　　t16=t32》》16;

　　x=（x-t16）+（x《t16）;

　　}

　　else

　　x=1-t16;

　　}

　　else

　　x=1-x;

　　return x;

　　#endif

　　#endif

　　}

　　void change（uint16 a［］，uint16 *key） //每一輪的變換

　　{

　　uint16 jie_guo［11］;

　　jie_guo［1］=MULi（a［1］，key［1］）;

　　jie_guo［2］=a［2］+key［2］;

　　jie_guo［3］=a［3］+key［3］;

　　jie_guo［4］=MULi（a［4］，key［4］）;

　　jie_guo［5］=jie_guo［1］^jie_guo［3］;

　　jie_guo［6］=jie_guo［2］^jie_guo［4］;

　　jie_guo［7］=MULi（jie_guo［5］，key［5］）;

　　jie_guo［8］=jie_guo［6］+jie_guo［7］;

　　jie_guo［9］=MULi（jie_guo［8］，key［6］）;

　　jie_guo［10］=jie_guo［7］+jie_guo［9］;

　　a［1］=jie_guo［1］^jie_guo［9］;

　　a［2］=jie_guo［3］^jie_guo［9］;

　　a［3］=jie_guo［2］^jie_guo［10］;

　　a［4］=jie_guo［4］^jie_guo［10］;

　　}

　　int jia_jie（byte in_buf［］，byte out_buf［］，uint16 key［］［7］） //模擬加密過程

　　{

　　int i;

　　uint16 temp;

　　uint16 x［5］，s2，s3;

　　word16 *in，*out;

　　in=（word16 *）in_buf;

　　for（i=1;i《=4;i++）

　　x［i］=in［i-1］;

　　#ifndef HIGHFIRST

　　for（i=1;i《=4;i++）

　　x［i］=（x［i］》》8|x［i］《《8）;

　　#endif

　　for（i=1;i《=rounds;i++）

　　change（x，&key［i］［0］）;

　　x［1］=MULi（x［1］，key［9］［1］）;

　　x［3］+=key［9］［2］;

　　x［2］+=key［9］［3］;

　　x［4］=MULi（x［4］，key［9］［4］）;

　　out=（word16 *）out_buf;

　　#ifdef HIGHFIRST

　　*out++=x［1］;

　　*out++=x［3］;

　　*out++=x［2］;

　　*out=x［4］;

　　#else

　　*out++=（x［1］》》8）|（x［1］《《8）;

　　*out++=（x［3］》》8）|（x［3］《《8）;

　　*out++=（x［2］》》8）|（x［2］《《8）;

　　*out=（x［4］》》8）|（x［4］《《8）;

　　#endif

　　return 0;

　　}

　　main.cpp

　　［c-sharp］ view plain copy#include《stdio.h》

　　#include《string.h》

　　#include《stdlib.h》

　　#include “idea.h”

　　#include “suanfa.cpp”

　　char prin_ch（）

　　{

　　char ch;

　　printf（“shu ru ni de xuan ze/n”）;

　　printf（“1:jia mi wen jian/n”）;

　　printf（“2:jie mi wen jian/n”）;

　　printf（“q:tui chu/n”）;

　　scanf（“%c”，&ch）;

　　getchar（）;

　　return ch;

　　}

　　void get_key（idea_key *key）

　　{

　　byte sou_key［17］;

　　printf（“enter your passwor/n”）;

　　scanf（“%s”，sou_key）;

　　int b=strlen（（char *）sou_key）;

　　memset（&sou_key［b］，1，16-b）;

　　get_jia_key（sou_key，key-》jia_key）;

　　get_jie_key（key-》jia_key，key-》jie_key）;

　　}

　　void change（byte *in，byte *out，word16 key［］［7］，int a）

　　{

　　for（int i=0;i《a;i++）{

　　jia_jie（in，out，key）;

　　in+=8;

　　out+=8;

　　}

　　}

　　void lock_file（word16 key［］［7］）

　　{

　　char filename［40］;

　　printf（“enter file name/n”）;

　　scanf（“%s”，filename）;

　　getchar（）;

　　FILE *fp，*fp1;

　　fp=fopen（filename，“r”）;

　　fp1=fopen（“l(fā)ocked”，“wb”）;

　　byte temp_buf［256］;

　　byte sou_buf［256］;

　　byte temp［256］;

　　while（！feof（fp））{

　　fgets（（char *）temp，8，fp）;

　　jia_jie（temp，temp_buf，key）;

　　fwrite（temp_buf，sizeof（byte），8，fp1）;

　　fputc（‘@’，fp1）;

　　}

　　fclose（fp）;

　　fclose（fp1）;

　　}

　　void unlock_file（word16 key［］［7］）

　　{

　　char filename［40］;

　　printf（“enter file name/n”）;

　　scanf（“%s”，filename）;

　　getchar（）;

　　FILE *fp，*fp1;

　　fp=fopen（filename，“rb”）;

　　fp1=fopen（“unlocked”，“w”）;

　　byte temp［256］;

　　byte temp_buf［256］;

　　while（！feof（fp））{

　　int length=0;

　　while（1）{

　　fread（&temp［length++］，1，1，fp）;

　　if（temp［length-1］==‘@’）

　　break;

　　}

　　jia_jie（temp，temp_buf，key）;

　　fputs（（char *）temp_buf，fp1）;

　　}

　　fclose（fp）;

　　fclose（fp1）;

　　}

　　int main（）

　　{

　　char ch;

　　while（1）{

　　ch=prin_ch（）;

　　if（ch==‘q’）

　　break;

　　idea_key key;

　　get_key（&key）;

　　switch（ch）{

　　case ‘1’：

　　lock_file（key.jia_key）;

　　break;

　　case ‘2’：

　　unlock_file（key.jie_key）;

　　default：

　　break;

　　}

　　}