導航:首頁 > 源碼編譯 > des演算法測試

des演算法測試

發布時間:2022-09-27 01:35:12

① DES加密演算法的測試數據示例

其實你只要再寫個解密的過程看看加密完能不能還原回去就好了。。解密過程和加密過程基本一樣,就是使用子密鑰時的順序是倒著的。
明文是 testdata,密鑰是mydeskey 正確的des加密後二進制密文:
用base64編碼形成的密文是:4wynQOzDaiA=
解密後:

② DES加密演算法在Linux下運行異樣

只有寫的不好的程序,還沒聽說過報異常的演算法,樓主真乃神人也!
你搞清楚UNIX/Linux同Windows的在處理文件上的區別了嗎?之前我也一度寫過這類東西,Windows的換行同Linux的是不同的,所以如果用終端輸入去測試的話,很可能會有考慮不周的地方,試著用同一個字元串變數去測試,就能知道是否是演算法的問題了。

③ DES和AES演算法的比較,各自優缺點有哪些

一、數據加密標准不同

1、DES演算法的入口參數有三個:Key、Data、Mode。

其中Key為7個位元組共56位,是DES演算法的工作密鑰;Data為8個位元組64位,是要被加密或被解密的數據;Mode為DES的工作方式,有兩種:加密或解密。

2、AES的基本要求是,採用對稱分組密碼體制,密鑰的長度最少支持為128、192、256,分組長度128位,演算法應易於各種硬體和軟體實現。

因此AES的密鑰長度比DES大, 它也可設定為32比特的任意倍數,最小值為128比特,最大值為256 比特,所以用窮舉法是不可能破解的。

二、運行速度不同

1、作為分組密碼,DES的加密單位僅有64位二進制,這對於數據傳輸來說太小,因為每個分組僅含8個字元,而且其中某些位還要用於奇偶校驗或其他通訊開銷。處理速度慢、加密耗時

2、AES對內存的需求非常低,運算速度快,在有反饋模式、無反饋模式的軟硬體中,Rijndael都表現出非常好的性能。

三、適用范圍不同

1、數據加密標准,速度較快,適用於加密大量數據的場合。DES在安全上是脆弱的,但由於快速DES晶元的大量生產,使得DES仍能暫時繼續使用,為提高安全強度,通常使用獨立密鑰的三級DES

2、AES 適用於8位的小型單片機或者普通的32位微處理器,並且適合用專門的硬體實現,硬體實現能夠使其吞吐量(每秒可以到達的加密/解密bit數)達到十億量級。同樣,其也適用於RFID系統。

④ DES加密演算法中S作用S盒的輸入幾位輸出幾位說明其計算機過程

S盒是DES演算法的核心,用在分組密碼演算法中,是唯一的非線性結構,其S盒的指標的好壞直接決定了密碼演算法的好壞。

每個S盒是將6位輸入轉化為4位輸出。

根據6位輸入來查找對應S盒的表,由第一和最後一位得到行號,由中間的四位得到列號。如:對S盒1,輸入為110011,就是查找第3行、第9列,結果為11,於是輸出就是二進制的1011。



(4)des演算法測試擴展閱讀

DES於1976年被美國聯邦政府的國家標准局確定為聯邦資料處理標准(FIPS),隨後在國際上廣泛流傳開來。

目前DES現在已經不是一種安全的加密方法,主要因為它使用的56位密鑰過短。1999年1月,distributed.net與電子前哨基金會合作,在22小時15分鍾內即公開破解了一個DES密鑰。在2001年,DES作為一個標准已經被高級加密標准(AES)所取代。

DES是一種分組密碼,它使用使用56位秘鑰對64位(8位元組)分組進行加密。同時是一種對稱密碼,即其加密和解密使用相同的秘鑰。每個分組的加密分為16輪迭代,每輪是用不同的自秘鑰,而子秘鑰是根據主密鑰k編排得出。

⑤ des是什麼演算法

DES演算法為密碼體制中的對稱密碼體制。

DES演算法為密碼體制中的對稱密碼體制,又被稱為美國數據加密標准,是1972年美國IBM公司研製的對稱密碼體制加密演算法。明文按64位進行分組,密鑰長64位,密鑰事實上是56位參與DES運算,分組後的明文組和56位的密鑰按位替代或交換的方法形成密文組的加密方法。

des的應用領域

計算機網路通信:對計算機網路通信中的數據提供保護是DES的一項重要應用。但這些被保護的數據一般只限於民用敏感信息,即不在政府確定的保密范圍之內的信息。

電子資金傳送系統:採用DES的方法加密電子資金傳送系統中的信息,可准確、快速地傳送數據,並可較好地解決信息安全的問題。

保護用戶文件:用戶可自選密鑰對重要文件加密,防止未授權用戶竊密。

用戶識別:DES還可用於計算機用戶識別系統中。

⑥ 「DES」和「AES」演算法的比較,各自優缺點有哪些

DES演算法優點:DES演算法具有極高安全性,到目前為止,除了用窮舉搜索法對DES演算法進行攻擊外,還沒有發現更有效的辦法。

DES演算法缺點:

1、分組比較短。

2、密鑰太短。

3、密碼生命周期短。

4、運算速度較慢。

AES演算法優點:

1、運算速度快。

2、對內存的需求非常低,適合於受限環境。

3、分組長度和密鑰長度設計靈活。

4、 AES標准支持可變分組長度,分組長度可設定為32比特的任意倍數,最小值為128比特,最大值為256比特。

5、 AES的密鑰長度比DES大,它也可設定為32比特的任意倍數,最小值為128比特,最大值為256比特,所以用窮舉法是不可能破解的。

6、很好的抵抗差分密碼分析及線性密碼分析的能力。

AES演算法缺點:目前尚未存在對AES 演算法完整版的成功攻擊,但已經提出對其簡化演算法的攻擊。

(6)des演算法測試擴展閱讀:

高級加密標准(英語:Advanced Encryption Standard,縮寫:AES),在密碼學中又稱Rijndael加密法,是美國聯邦政府採用的一種區塊加密標准。

這個標准用來替代原先的DES,已經被多方分析且廣為全世界所使用。經過五年的甄選流程,高級加密標准由美國國家標准與技術研究院(NIST)於2001年11月26日發布於FIPS PUB 197,並在2002年5月26日成為有效的標准。2006年,高級加密標准已然成為對稱密鑰加密中最流行的演算法之一。

⑦ des演算法安全性分析

DES
是一個對稱演算法:加密和解密用的是同
一演算法(除密鑰編排不同以外),既可用於加密又可用於解密。它的核心技術是:在相信復雜函數可以通過簡單函數迭代若干圈得到的原則下,利用F函數及對合等運算,充分利用非線性運算。

至今,最有效的破解DES演算法的方法是窮舉搜索法,那麼56位長的密鑰總共要測試256次,如果每100毫秒可以測試1次,那麼需要7.2×1015秒,大約是228,493,000年。但是,仍有學者認為在可預見的將來用窮舉法尋找正確密鑰已趨於可行,所以若要安全保護10年以上的數據最好。

⑧ des加密演算法(c/c++)

des.h文件:

#ifndefCRYPTOPP_DES_H

#defineCRYPTOPP_DES_H

#include"cryptlib.h"

#include"misc.h"

NAMESPACE_BEGIN(CryptoPP)

classDES:publicBlockTransformation

{

public:

DES(constbyte*userKey,CipherDir);

voidProcessBlock(constbyte*inBlock,byte*outBlock)const;

voidProcessBlock(byte*inoutBlock)const

{DES::ProcessBlock(inoutBlock,inoutBlock);}

enum{KEYLENGTH=8,BLOCKSIZE=8};

unsignedintBlockSize()const{returnBLOCKSIZE;}

protected:

staticconstword32Spbox[8][64];

SecBlock<word32>k;

};

classDESEncryption:publicDES

{

public:

DESEncryption(constbyte*userKey)

:DES(userKey,ENCRYPTION){}

};

classDESDecryption:publicDES

{

public:

DESDecryption(constbyte*userKey)

:DES(userKey,DECRYPTION){}

};

classDES_EDE_Encryption:publicBlockTransformation

{

public:

DES_EDE_Encryption(constbyte*userKey)

:e(userKey,ENCRYPTION),d(userKey+DES::KEYLENGTH,DECRYPTION){}

voidProcessBlock(constbyte*inBlock,byte*outBlock)const;

voidProcessBlock(byte*inoutBlock)const;

enum{KEYLENGTH=16,BLOCKSIZE=8};

unsignedintBlockSize()const{returnBLOCKSIZE;}

private:

DESe,d;

};

classDES_EDE_Decryption:publicBlockTransformation

{

public:

DES_EDE_Decryption(constbyte*userKey)

:d(userKey,DECRYPTION),e(userKey+DES::KEYLENGTH,ENCRYPTION){}

voidProcessBlock(constbyte*inBlock,byte*outBlock)const;

voidProcessBlock(byte*inoutBlock)const;

enum{KEYLENGTH=16,BLOCKSIZE=8};

unsignedintBlockSize()const{returnBLOCKSIZE;}

private:

DESd,e;

};

classTripleDES_Encryption:publicBlockTransformation

{

public:

TripleDES_Encryption(constbyte*userKey)

:e1(userKey,ENCRYPTION),d(userKey+DES::KEYLENGTH,DECRYPTION),

e2(userKey+2*DES::KEYLENGTH,ENCRYPTION){}

voidProcessBlock(constbyte*inBlock,byte*outBlock)const;

voidProcessBlock(byte*inoutBlock)const;

enum{KEYLENGTH=24,BLOCKSIZE=8};

unsignedintBlockSize()const{returnBLOCKSIZE;}

private:

DESe1,d,e2;

};

classTripleDES_Decryption:publicBlockTransformation

{

public:

TripleDES_Decryption(constbyte*userKey)

:d1(userKey+2*DES::KEYLENGTH,DECRYPTION),e(userKey+DES::KEYLENGTH,ENCRYPTION),

d2(userKey,DECRYPTION){}

voidProcessBlock(constbyte*inBlock,byte*outBlock)const;

voidProcessBlock(byte*inoutBlock)const;

enum{KEYLENGTH=24,BLOCKSIZE=8};

unsignedintBlockSize()const{returnBLOCKSIZE;}

private:

DESd1,e,d2;

};

NAMESPACE_END

#endif

des.cpp文件:

//des.cpp-modifiedbyWeiDaifrom:

/*

*

*circa1987,'s1977

*publicdomaincode.,but

*theactualencrypt/

*Outerbridge'sDEScodeasprintedinSchneier's"AppliedCryptography."

*

*Thiscodeisinthepublicdomain.Iwouldappreciatebugreportsand

*enhancements.

*

*PhilKarnKA9Q,[email protected],August1994.

*/

#include"pch.h"

#include"misc.h"

#include"des.h"

NAMESPACE_BEGIN(CryptoPP)

/*

*Threeofthesetables,theinitialpermutation,thefinal

*,areregularenoughthat

*forspeed,wehard-codethem.They'rehereforreferenceonly.

*Also,,gensp.c,

*tobuildthecombinedSPbox,Spbox[].They'realsoherejust

*forreference.

*/

#ifdefnotdef

/*initialpermutationIP*/

staticbyteip[]={

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

};

/*finalpermutationIP^-1*/

staticbytefp[]={

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

};

/*expansionoperationmatrix*/

staticbyteei[]={

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

};

/*The(in)famousS-boxes*/

staticbytesbox[8][64]={

/*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

};

/*32--boxes*/

staticbytep32i[]={

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

};

#endif

/*permutedchoicetable(key)*/

staticconstbytepc1[]={

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

};

/*numberleftrotationsofpc1*/

staticconstbytetotrot[]={

1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28

};

/*permutedchoicekey(table)*/

staticconstbytepc2[]={

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

};

/*EndofDES-definedtables*/

/*bit0isleft-mostinbyte*/

staticconstintbytebit[]={

0200,0100,040,020,010,04,02,01

};

/*Setkey(initializekeyschelearray)*/

DES::DES(constbyte*key,CipherDirdir)

:k(32)

{

SecByteBlockbuffer(56+56+8);

byte*constpc1m=buffer;/*placetomodifypc1into*/

byte*constpcr=pc1m+56;/*placetorotatepc1into*/

byte*constks=pcr+56;

registerinti,j,l;

intm;

for(j=0;j<56;j++){/*convertpc1tobitsofkey*/

l=pc1[j]-1;/*integerbitlocation*/

m=l&07;/*findbit*/

pc1m[j]=(key[l>>3]&/*findwhichkeybytelisin*/

bytebit[m])/*andwhichbitofthatbyte*/

?1:0;/*andstore1-bitresult*/

}

for(i=0;i<16;i++){/*keychunkforeachiteration*/

memset(ks,0,8);/*Clearkeyschele*/

for(j=0;j<56;j++)/*rotatepc1therightamount*/

pcr[j]=pc1m[(l=j+totrot[i])<(j<28?28:56)?l:l-28];

/**/

for(j=0;j<48;j++){/*selectbitsindivially*/

/*checkbitthatgoestoks[j]*/

if(pcr[pc2[j]-1]){

/*maskitinifit'sthere*/

l=j%6;

ks[j/6]|=bytebit[l]>>2;

}

}

/*Nowconverttoodd/eveninterleavedformforuseinF*/

k[2*i]=((word32)ks[0]<<24)

|((word32)ks[2]<<16)

|((word32)ks[4]<<8)

|((word32)ks[6]);

k[2*i+1]=((word32)ks[1]<<24)

|((word32)ks[3]<<16)

|((word32)ks[5]<<8)

|((word32)ks[7]);

}

if(dir==DECRYPTION)//reversekeyscheleorder

for(i=0;i<16;i+=2)

{

std::swap(k[i],k[32-2-i]);

std::swap(k[i+1],k[32-1-i]);

}

}

/**/

/*Ccodeonlyinportableversion*/

//RichardOuterbridge'sinitialpermutationalgorithm

/*

inlinevoidIPERM(word32&left,word32&right)

{

word32work;

work=((left>>4)^right)&0x0f0f0f0f;

right^=work;

left^=work<<4;

work=((left>>16)^right)&0xffff;

right^=work;

left^=work<<16;

work=((right>>2)^left)&0x33333333;

left^=work;

right^=(work<<2);

work=((right>>8)^left)&0xff00ff;

left^=work;

right^=(work<<8);

right=rotl(right,1);

work=(left^right)&0xaaaaaaaa;

left^=work;

right^=work;

left=rotl(left,1);

}

inlinevoidFPERM(word32&left,word32&right)

{

word32work;

right=rotr(right,1);

work=(left^right)&0xaaaaaaaa;

left^=work;

right^=work;

left=rotr(left,1);

work=((left>>8)^right)&0xff00ff;

right^=work;

left^=work<<8;

work=((left>>2)^right)&0x33333333;

right^=work;

left^=work<<2;

work=((right>>16)^left)&0xffff;

left^=work;

right^=work<<16;

work=((right>>4)^left)&0x0f0f0f0f;

left^=work;

right^=work<<4;

}

*/

//WeiDai''sinitialpermutation

//algorithm,

//(likeinMSVC)

inlinevoidIPERM(word32&left,word32&right)

{

word32work;

right=rotl(right,4U);

work=(left^right)&0xf0f0f0f0;

left^=work;

right=rotr(right^work,20U);

work=(left^right)&0xffff0000;

left^=work;

right=rotr(right^work,18U);

work=(left^right)&0x33333333;

left^=work;

right=rotr(right^work,6U);

work=(left^right)&0x00ff00ff;

left^=work;

right=rotl(right^work,9U);

work=(left^right)&0xaaaaaaaa;

left=rotl(left^work,1U);

right^=work;

}

inlinevoidFPERM(word32&left,word32&right)

{

word32work;

right=rotr(right,1U);

work=(left^right)&0xaaaaaaaa;

right^=work;

left=rotr(left^work,9U);

work=(left^right)&0x00ff00ff;

right^=work;

left=rotl(left^work,6U);

work=(left^right)&0x33333333;

right^=work;

left=rotl(left^work,18U);

work=(left^right)&0xffff0000;

right^=work;

left=rotl(left^work,20U);

work=(left^right)&0xf0f0f0f0;

right^=work;

left=rotr(left^work,4U);

}

//

voidDES::ProcessBlock(constbyte*inBlock,byte*outBlock)const

{

word32l,r,work;

#ifdefIS_LITTLE_ENDIAN

l=byteReverse(*(word32*)inBlock);

r=byteReverse(*(word32*)(inBlock+4));

#else

l=*(word32*)inBlock;

r=*(word32*)(inBlock+4);

#endif

IPERM(l,r);

constword32*kptr=k;

for(unsignedi=0;i<8;i++)

{

work=rotr(r,4U)^kptr[4*i+0];

l^=Spbox[6][(work)&0x3f]

^Spbox[4][(work>>8)&0x3f]

^Spbox[2][(work>>16)&0x3f]

^Spbox[0][(work>>24)&0x3f];

work=r^kptr[4*i+1];

l^=Spbox[7][(work)&0x3f]

^Spbox[5][(work>>8)&0x3f]

^Spbox[3][(work>>16)&0x3f]

^Spbox[1][(work>>24)&0x3f];

work=rotr(l,4U)^kptr[4*i+2];

r^=Spbox[6][(work)&0x3f]

^Spbox[4][(work>>8)&0x3f]

^Spbox[2][(work>>16)&0x3f]

^Spbox[0][(work>>24)&0x3f];

work=l^kptr[4*i+3];

r^=Spbox[7][(work)&0x3f]

^Spbox[5][(work>>8)&0x3f]

^Spbox[3][(work>>16)&0x3f]

^Spbox[1][(work>>24)&0x3f];

}

FPERM(l,r);

#ifdefIS_LITTLE_ENDIAN

*(word32*)outBlock=byteReverse(r);

*(word32*)(outBlock+4)=byteReverse(l);

#else

*(word32*)outBlock=r;

*(word32*)(outBlock+4)=l;

#endif

}

voidDES_EDE_Encryption::ProcessBlock(byte*inoutBlock)const

{

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

}

voidDES_EDE_Encryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const

{

e.ProcessBlock(inBlock,outBlock);

d.ProcessBlock(outBlock);

e.ProcessBlock(outBlock);

}

voidDES_EDE_Decryption::ProcessBlock(byte*inoutBlock)const

{

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

}

voidDES_EDE_Decryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const

{

d.ProcessBlock(inBlock,outBlock);

e.ProcessBlock(outBlock);

d.ProcessBlock(outBlock);

}

voidTripleDES_Encryption::ProcessBlock(byte*inoutBlock)const

{

e1.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e2.ProcessBlock(inoutBlock);

}

voidTripleDES_Encryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const

{

e1.ProcessBlock(inBlock,outBlock);

d.ProcessBlock(outBlock);

e2.ProcessBlock(outBlock);

}

voidTripleDES_Decryption::ProcessBlock(byte*inoutBlock)const

{

d1.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d2.ProcessBlock(inoutBlock);

}

voidTripleDES_Decryption::ProcessBlock(constbyte*inBlock,byte*outBlock)const

{

d1.ProcessBlock(inBlock,outBlock);

e.ProcessBlock(outBlock);

d2.ProcessBlock(outBlock);

}

NAMESPACE_END

程序運行如下:

⑨ des是什麼演算法

DES演算法為密碼體制中的對稱密碼體制,又被稱為美國數據加密標准,是1972年美國IBM公司研製的對稱密碼體制加密演算法。明文按64位進行分組,密鑰長64位,密鑰事實上是56位參與DES運算(第8、16、24、32、40、48、56、64位是校驗位,使得每個密鑰都有奇數個1)分組後的明文組和56位的密鑰按位替代或交換的方法形成密文組的加密方法。
其入口參數有三個:key、data、mode。key為加密解密使用的密鑰,data為加密解密的數據,mode為其工作模式。當模式為加密模式時,明文按照64位進行分組,形成明文組,key用於對數據加密,當模式為解密模式時,key用於對數據解密。實際運用中,密鑰只用到了64位中的56位,這樣才具有高的安全性。

⑩ 數據加密演算法的數據加密標准DES

DES的原始思想可以參照二戰德國的恩尼格瑪機,其基本思想大致相同。傳統的密碼加密都是由古代的循環移位思想而來,恩尼格瑪機在這個基礎之上進行了擴散模糊。但是本質原理都是一樣的。現代DES在二進制級別做著同樣的事:替代模糊,增加分析的難度。 攻擊 DES 的主要形式被稱為蠻力的或窮舉,即重復嘗試各種密鑰直到有一個符合為止。如果 DES 使用 56 位的密鑰,則可能的密鑰數量是 2 的 56 次方個。隨著計算機系統能力的不斷發展,DES 的安全性比它剛出現時會弱得多,然而從非關鍵性質的實際出發,仍可以認為它是足夠的。不過 ,DES 現在僅用於舊系統的鑒定,而更多地選擇新的加密標准 — 高級加密標准(Advanced Encryption Standard,AES)。
新的分析方法有差分分析法和線性分析法兩種 本期Crackme用到MD5及DES兩種加密演算法,難度適中。這次我們重點來看一下DES的加密過程及注冊演算法過程。用調試器載入程序,下GegDlgItemTextA斷點,可以定位到下面代碼,我們先來看一下整個crackme的注冊過程:
由於代碼分析太長,故收錄到光碟中,請大家對照著分析(請見光碟「code1.doc」)
從上面分析可以看出,注冊過程是類似:f(機器碼,注冊碼)式的兩元運算。機器碼是經過md5演算法得到的中間16位值,注冊碼是經過DES解密過程取得16位注冊碼,然後兩者比較,如相等,則注冊成功。機器碼的運算過程可以參照上一期的MD5演算法來理解。下面重點來說一下注冊碼DES的運算過程。
1、密鑰處理過程:一般進行加解密過程都要初始化密鑰處理。我們可以跟進004023FA CALL Crackme1.00401A40這個call,可以看到如下代碼:
…(省略)...
00401A4D LEA ECX,DWORD PTR DS:[ECX]
00401A50 /MOV EDX,EAX
00401A52 |SHR EDX,3
00401A55 |MOV DL,BYTE PTR DS:[EDX+ESI]
00401A58 |MOV CL,AL
00401A5A |AND CL,7
00401A5D |SAR DL,CL
00401A5F |AND DL,1
00401A62 |MOV BYTE PTR DS:[EAX+417DA0],DL
00401A68 |INC EAX
00401A69 |CMP EAX,40這里比較是否小於64
00401A6C JL SHORT Crackme1.00401A50
以上過程就是去掉密鑰各第八位奇偶位。
…(省略)...
00401AB0 |MOV DL,BYTE PTR DS:[ECX+417D9F]
00401AB6 |MOV BYTE PTR DS:[EAX+417BA3],DL
00401ABC |ADD EAX,4
00401ABF |CMP EAX,38這里進行密鑰變換
…(省略)...
00401BFF ||MOVSX ECX,BYTE PTR DS:[EAX+412215]
00401C06 ||MOV CL,BYTE PTR DS:[ECX+417D9F]
00401C0C ||MOV BYTE PTR DS:[EAX+417BA5],CL
00401C12 ||ADD EAX,6
00401C15 ||CMP EAX,30這里產生48位的子密鑰
00401C18 |JL SHORT Crackme1.00401BA0
00401C1A |MOV EAX,DWORD PTR SS:[ESP+14]
00401C1E |MOV EDI,EAX
00401C20 |MOV ECX,0C
00401C25 |MOV ESI,Crackme1.00417BA0
00401C2A |REP MOVS DWORD PTR ES:[EDI],DWORD PTR D>
00401C2C |MOV EDI,DWORD PTR SS:[ESP+10]
00401C30 |ADD EAX,30下一組子密鑰
00401C33 |INC EDI
00401C34 |CMP EAX,Crackme1.00417B90這里進行16次的生成子密鑰過程
00401C39 |MOV DWORD PTR SS:[ESP+10],EDI
…(省略)...
可以看到8位密鑰為:1,9,8,0,9,1,7,0
2、對數據處理的過程,跟進004024C7 CALL Crackme1.00402050,到如下代碼:
00402072 |MOV BYTE PTR DS:[EAX+417E30],DL
00402078 |INC EAX
00402079 |CMP EAX,40這里取得64位數據
0040207C JL SHORT Crackme1.00402060
…(省略)...
004020C6 |MOV BYTE PTR DS:[EAX+417BA3],DL
004020CC |ADD EAX,4
004020CF |CMP EAX,40進行第一次變換
004020D2 JL SHORT Crackme1.00402080
004020D4 MOV AL,BYTE PTR SS:[ESP+20]
004020D8 TEST AL,AL
004020DA MOV ECX,10
…(省略)...
00402191 MOV EBP,DWORD PTR DS:[415094] ; Crackme1.00417E30
00402197 SUB EAX,EBP這里對變換後的數據分為兩部分
00402199 MOV DWORD PTR SS:[ESP+10],EAX
0040219D MOV DWORD PTR SS:[ESP+20],Crackme1.00417B60
004021A5 /MOV EAX,DWORD PTR SS:[ESP+20]
004021A9 |MOV ECX,8
004021AE |MOV ESI,EBP
004021B0 |MOV EDI,Crackme1.00417E10
004021B5 |PUSH EAX這里用上面生成的子密鑰來解密數據
004021B6 |MOV EBX,EBP
…(省略)...
004021FF |SUB EAX,30下一個子密鑰
00402202 |CMP EAX,Crackme1.00417890這里將循環16次,典型的DES加解密過程
00402207 |MOV ECX,8
0040220C |MOV ESI,Crackme1.00417E10
00402211 |REP MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI>
…(省略)...
0040225A |MOV BYTE PTR DS:[EAX+417BA2],DL
00402260 |MOV DL,BYTE PTR DS:[ECX+417E2F]
00402266 |MOV BYTE PTR DS:[EAX+417BA3],DL
0040226C |ADD EAX,4
0040226F |CMP EAX,40這里是未置換
00402272 JL SHORT Crackme1.00402220
00402274 MOV EBP,DWORD PTR SS:[ESP+18]
00402278 MOV ECX,10
0040227D MOV ESI,Crackme1.00417BA0
…(省略)...
有興趣的讀者可以參考DES演算法來理解上面的過程。 一.安全性比較高的一種演算法,目前只有一種方法可以破解該演算法,那就是窮舉法.
二.採用64位密鑰技術,實際只有56位有效,8位用來校驗的.譬如,有這樣的一台PC機器,它能每秒計算一百萬次,那麼256位空間它要窮舉的時間為2285年.所以這種演算法還是比較安全的一種演算法.
TripleDES。該演算法被用來解決使用 DES 技術的 56 位時密鑰日益減弱的強度,其方法是:使用兩個獨立密鑰對明文運行 DES 演算法三次,從而得到 112 位有效密鑰強度。TripleDES 有時稱為 DESede(表示加密、解密和加密這三個階段)。

閱讀全文

與des演算法測試相關的資料

熱點內容
日本影視網站 瀏覽:932
伺服器點亮埠以後有什麼特徵 瀏覽:980
51單片機定時器pwm 瀏覽:685
民國修真 瀏覽:386
php數組作為參數傳遞 瀏覽:991
運行命令查ip 瀏覽:202
漲奶吃奶小說 瀏覽:340
股票十大戰法主圖指標源碼 瀏覽:702
查看網路的命令是什麼意思 瀏覽:589
《鬼吹燈》1-8全本txt 瀏覽:336
python繪圖兩個圓代碼 瀏覽:607
python中end的用法 瀏覽:682
大概率30選股源碼 瀏覽:206
阿里雲伺服器如何鏡像 瀏覽:161
能看的 瀏覽:403
京東伺服器為什麼會崩 瀏覽:836
php超類 瀏覽:822
怎麼在美團APP上請假 瀏覽:100
午夜激情影院 瀏覽:242
歐拉app怎麼下訂單 瀏覽:422