sdes加密

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

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

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

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

(1)sdes加密擴展閱讀

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

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

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

2. des演算法加密解密的實現

本文介紹了一種國際上通用的加密演算法—DES演算法的原理，並給出了在VC++6.0語言環境下實現的源代碼。最後給出一個示例，以供參考。
關鍵字：DES演算法、明文、密文、密鑰、VC；

本文程序運行效果圖如下：

正文：
當今社會是信息化的社會。為了適應社會對計算機數據安全保密越來越高的要求，美國國家標准局(NBS)於1997年公布了一個由IBM公司研製的一種加密演算法，並且確定為非機要部門使用的數據加密標准，簡稱DES(Data Encrypton Standard)。自公布之日起，DES演算法作為國際上商用保密通信和計算機通信的最常用演算法，一直活躍在國際保密通信的舞台上，扮演了十分突出的角色。現將DES演算法簡單介紹一下，並給出實現DES演算法的VC源代碼。
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 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

經過置換IP-1後生成的比特串就是密文e.。
下面再講一下變換f(Ri-1,Ki)。
它的功能是將32比特的輸入再轉化為32比特的輸出。其過程如圖所示：

對f變換說明如下：輸入Ri-1(32比特)經過變換E後，膨脹為48比特。膨脹後的比特串的下標列表如下：

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 31

膨脹後的比特串分為8組，每組6比特。各組經過各自的S盒後，又變為4比特(具體過程見後)，合並後又成為32比特。該32比特經過P變換後，其下標列表如下：

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變換後輸出的比特串才是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演算法加密原理講完了。在VC++6.0下的程序源代碼為：

for(i=1;i<=64;i++)
m1[i]=m[ip[i-1]];//64位明文串輸入，經過IP置換。

下面進行迭代。由於各次迭代的方法相同只是輸入輸出不同，因此只給出其中一次。以第八次為例：//進行第八次迭代。首先進行S盒的運算，輸入32位比特串。
for(i=1;i<=48;i++)//經過E變換擴充，由32位變為48位
RE1[i]=R7[E[i-1]];
for(i=1;i<=48;i++)//與K8按位作不進位加法運算
RE1[i]=RE1[i]+K8[i];
for(i=1;i<=48;i++)
{
if(RE1[i]==2)
RE1[i]=0;
}
for(i=1;i<7;i++)//48位分成8組
{
s11[i]=RE1[i];
s21[i]=RE1[i+6];
s31[i]=RE1[i+12];
s41[i]=RE1[i+18];
s51[i]=RE1[i+24];
s61[i]=RE1[i+30];
s71[i]=RE1[i+36];
s81[i]=RE1[i+42];
}//下面經過S盒，得到8個數。S1,s2,s3,s4,s5,s6,s7,s8分別為S表
s[1]=s1[s11[6]+s11[1]*2][s11[5]+s11[4]*2+s11[3]*4+s11[2]*8];
s[2]=s2[s21[6]+s21[1]*2][s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];
s[3]=s3[s31[6]+s31[1]*2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];
s[4]=s4[s41[6]+s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8];
s[5]=s5[s51[6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];
s[6]=s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8];
s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];
s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8];
for(i=0;i<8;i++)//8個數變換輸出二進制
{
for(j=1;j<5;j++)
{
temp[j]=s[i+1]%2;
s[i+1]=s[i+1]/2;
}
for(j=1;j<5;j++)
f[4*i+j]=temp[5-j];
}
for(i=1;i<33;i++)//經過P變換
frk[i]=f[P[i-1]];//S盒運算完成
for(i=1;i<33;i++)//左右交換
L8[i]=R7[i];
for(i=1;i<33;i++)//R8為L7與f(R,K)進行不進位二進制加法運算結果
{
R8[i]=L7[i]+frk[i];
if(R8[i]==2)
R8[i]=0;
}

[ 原創文檔 本文適合中級讀者 已閱讀21783次 ] 文檔 代碼 工具

DES演算法及其在VC++6.0下的實現(下)
作者：航天醫學工程研究所四室 朱彥軍

在《DES演算法及其在VC++6.0下的實現(上)》中主要介紹了DES演算法的基本原理，下面讓我們繼續：

二．子密鑰的生成
64比特的密鑰生成16個48比特的子密鑰。其生成過程見圖：

子密鑰生成過程具體解釋如下：
64比特的密鑰K，經過PC-1後，生成56比特的串。其下標如表所示：

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

該比特串分為長度相等的比特串C0和D0。然後C0和D0分別循環左移1位，得到C1和D1。C1和D1合並起來生成C1D1。C1D1經過PC-2變換後即生成48比特的K1。K1的下標列表為：

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

C1、D1分別循環左移LS2位，再合並，經過PC-2，生成子密鑰K2……依次類推直至生成子密鑰K16。
注意：Lsi (I =1,2,….16)的數值是不同的。具體見下表：

迭代順序 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位數 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1

生成子密鑰的VC程序源代碼如下：

for(i=1;i<57;i++)//輸入64位K，經過PC-1變為56位 k0[i]=k[PC_1[i-1]];

56位的K0，均分為28位的C0，D0。C0，D0生成K1和C1，D1。以下幾次迭代方法相同，僅以生成K8為例。 for(i=1;i<27;i++)//循環左移兩位
{
C8[i]=C7[i+2];
D8[i]=D7[i+2];
}
C8[27]=C7[1];
D8[27]=D7[1];
C8[28]=C7[2];
D8[28]=D7[2];
for(i=1;i<=28;i++)
{
C[i]=C8[i];
C[i+28]=D8[i];
}
for(i=1;i<=48;i++)
K8[i]=C[PC_2[i-1]];//生成子密鑰k8

注意：生成的子密鑰不同，所需循環左移的位數也不同。源程序中以生成子密鑰 K8為例，所以循環左移了兩位。但在編程中，生成不同的子密鑰應以Lsi表為准。

三．解密

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。
其程序源代碼與加密相同。在此就不重寫。

四．示例
例如：已知明文m=learning, 密鑰 k=computer。
明文m的ASCII二進製表示：

m= 01101100 01100101 01100001 01110010
01101110 01101001 01101110 01100111

密鑰k的ASCII二進製表示：

k=01100011 01101111 01101101 01110000
01110101 01110100 01100101 01110010

明文m經過IP置換後，得：

11111111 00001000 11010011 10100110 00000000 11111111 01110001 11011000

等分為左右兩段：

L0=11111111 00001000 11010011 10100110 R0=00000000 11111111 01110001 11011000

經過16次迭代後，所得結果為：

L1=00000000 11111111 01110001 11011000 R1=00110101 00110001 00111011 10100101
L2=00110101 00110001 00111011 10100101 R2=00010111 11100010 10111010 10000111
L3=00010111 11100010 10111010 10000111 R3=00111110 10110001 00001011 10000100
L4= R4=
L5= R5=
L6= R6=
L7= R7=
L8= R8=
L9= R9=
L10= R10=
L11= R11=
L12= R12=
L13= R13=
L14= R14=
L15= R15=
L16= R16=

其中，f函數的結果為：

f1= f2=
f3= f4=
f5= f6=
f7= f8=
f9= f10=
f11= f12=
f13= f14=
f15= f16=

16個子密鑰為：

K1= K2=
K3= K4=
K5= K6=
K7= K8=
K9= K10=
K11= K12=
K13= K14=
K15= K16=

S盒中，16次運算時，每次的8 個結果為：
第一次：5，11，4，1，0，3，13，9；
第二次：7，13，15，8，12，12，13，1；
第三次：8，0，0，4，8，1，9，12；
第四次：0，7，4，1，7，6，12，4；
第五次：8，1，0，11，5，0，14，14；
第六次：14，12，13，2，7，15，14，10；
第七次：12，15，15，1，9，14，0，4；
第八次：15，8，8，3，2，3，14，5；
第九次：8，14，5，2，1，15，5，12；
第十次：2，8，13，1，9，2，10，2；
第十一次：10，15，8，2，1，12，12，3；
第十二次：5，4，4，0，14，10，7，4；
第十三次：2，13，10，9，2，4，3，13；
第十四次：13，7，14，9，15，0，1，3；
第十五次：3，1，15，5，11，9，11，4；
第十六次：12，3，4，6，9，3，3，0；

子密鑰生成過程中，生成的數值為：

C0=0000000011111111111111111011 D0=1000001101110110000001101000
C1=0000000111111111111111110110 D1=0000011011101100000011010001
C2=0000001111111111111111101100 D2=0000110111011000000110100010
C3=0000111111111111111110110000 D3=0011011101100000011010001000
C4=0011111111111111111011000000 D4=1101110110000001101000100000
C5=1111111111111111101100000000 D5=0111011000000110100010000011
C6=1111111111111110110000000011 D6=1101100000011010001000001101
C7=1111111111111011000000001111 D7=0110000001101000100000110111
C8=1111111111101100000000111111 D8=1000000110100010000011011101
C9=1111111111011000000001111111 D9=0000001101000100000110111011
C10=1111111101100000000111111111 D10=0000110100010000011011101100
C11=1111110110000000011111111111 D11=0011010001000001101110110000
C12=1111011000000001111111111111 D12=1101000100000110111011000000
C13=1101100000000111111111111111 D13=0100010000011011101100000011
C14=0110000000011111111111111111 D14=0001000001101110110000001101
C15=1000000001111111111111111101 D15=0100000110111011000000110100
C16=0000000011111111111111111011 D16=1000001101110110000001101000

解密過程與加密過程相反，所得的數據的順序恰好相反。在此就不贅述。

參考書目：
《計算機系統安全》 重慶出版社 盧開澄等編著
《計算機密碼應用基礎》 科學出版社 朱文余等編著
《Visual C++ 6.0 編程實例與技巧》 機械工業出版社 王華等編著

3. 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

程序運行如下：

4. DES加密演算法C語言實現

#include<iostream.h>
class SubKey{ //定義子密鑰為一個類
public:
int key[8][6];
}subkey[16]; //定義子密鑰對象數組

class DES{
int encipher_decipher; //判斷加密還是解密
int key_in[8][8]; //用戶原始輸入的64位二進制數
int key_out[8][7]; //除去每行的最後一位校驗位
int c0_d0[8][7]; //存儲經PC-1轉換後的56位數據
int c0[4][7],d0[4][7]; //分別存儲c0,d0
int text[8][8]; //64位明文
int text_ip[8][8]; //經IP轉換過後的明文
int A[4][8],B[4][8]; //A,B分別存儲經IP轉換過後明文的兩部分,便於交換
int temp[8][6]; //存儲經擴展置換後的48位二進制值
int temp1[8][6]; //存儲和子密鑰異或後的結果
int s_result[8][4]; //存儲經S變換後的32位值
int text_p[8][4]; //經P置換後的32位結果
int secret_ip[8][8]; //經逆IP轉換後的密文
public:
void Key_Putting();
void PC_1();
int function(int,int); //異或
void SubKey_Proction();
void IP_Convert();
void f();
void _IP_Convert();
void Out_secret();
};
void DES::Key_Putting() //得到密鑰中對演算法有用的56位
{
cout<<"請輸入64位的密鑰(8行8列且每行都得有奇數個1):\n";
for(int i=0;i<8;i++)
for(int j=0;j<8;j++){
cin>>key_in[i][j];
if(j!=7) key_out[i][j]=key_in[i][j];
}
}
void DES::PC_1() //PC-1置換函數
{
int pc_1[8][7]={ //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}
};
int i,j;
for(i=0;i<8;i++)
for(j=0;j<7;j++)
c0_d0[i][j]=key_out[ (pc_1[i][j]-1)/8 ][ (pc_1[i][j]-1)%8 ];
}
int DES::function(int a,int b) //模擬二進制數的異或運算,a和b為整型的0和1,返回值為整型的0或1
{
if(a!=b)return 1;
else return 0;
}
void DES::SubKey_Proction() //生成子密鑰
{
int move[16][2]={ //循環左移的位數
1 , 1 , 2 , 1 ,
3 , 2 , 4 , 2 ,
5 , 2 , 6 , 2 ,
7 , 2 , 8 , 2 ,
9 , 1, 10 , 2,
11 , 2, 12 , 2,
13 , 2, 14 , 2,
15 , 2, 16 , 1
};
int pc_2[8][6]={ //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
};
for(int i=0;i<16;i++) //生成子密鑰
{
int j,k;
int a[2],b[2];
int bb[28],cc[28];
for(j=0;j<4;j++)
for(k=0;k<7;k++)
c0[j][k]=c0_d0[j][k];
for(j=4;j<8;j++)
for(k=0;k<7;k++)
d0[j-4][k]=c0_d0[j][k];
for(j=0;j<4;j++)
for(k=0;k<7;k++){
bb[7*j+k]=c0[j][k];
cc[7*j+k]=d0[j][k];
}
for(j=0;j<move[i][1];j++){
a[j]=bb[j];
b[j]=cc[j];
}
for(j=0;j<28-move[i][1];j++){
bb[j]=bb[j+1];
cc[j]=cc[j+1];
}
for(j=0;j<move[i][1];j++){
bb[27-j]=a[j];
cc[27-j]=b[j];
}
for(j=0;j<28;j++){
c0[j/7][j%7]=bb[j];
d0[j/7][j%7]=cc[j];
}
for(j=0;j<4;j++) //L123--L128是把c0,d0合並成c0_d0
for(k=0;k<7;k++)
c0_d0[j][k]=c0[j][k];
for(j=4;j<8;j++)
for(k=0;k<7;k++)
c0_d0[j][k]=d0[j-4][k];
for(j=0;j<8;j++) //對Ci,Di進行PC-2置換
for(k=0;k<6;k++)
subkey[i].key[j][k]=c0_d0[ (pc_2[j][k]-1)/7 ][ (pc_2[j][k]-1)%7 ];
}
}
void DES::IP_Convert()
{
int IP[8][8]={ //初始置換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
};
cout<<"你好,你要加密還是解密?加密請按1號鍵(輸入1),解密請按2號鍵,並確定."<<'\n';
cin>>encipher_decipher;
char * s;
if(encipher_decipher==1) s="明文";
else s="密文";
cout<<"請輸入64位"<<s<<"(二進制):\n";
int i,j;
for(i=0;i<8;i++)
for(j=0;j<8;j++)
cin>>text[i][j];
for(i=0;i<8;i++) //進行IP變換
for(j=0;j<8;j++)
text_ip[i][j]=text[ (IP[i][j]-1)/8 ][ (IP[i][j]-1)%8 ];
}

5. S-DES加密解密演算法C++版（下載一下）

到VCKBase上找

6. 如何使用java實現對字元串的DES加密和解密

java加密字元串可以使用des加密演算法，實例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since http://blog.csdn.net/qiushyfm
*/
public class CryptTest {
/**
* 進行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一個md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
/**
* 進行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一個SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 創建密匙
*
* @param algorithm
* 加密演算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（對稱）密鑰
*/
public SecretKey createSecretKey(String algorithm) {
// 聲明KeyGenerator對象
KeyGenerator keygen;
// 聲明 密鑰對象
SecretKey deskey = null;
try {
// 返回生成指定演算法的秘密密鑰的 KeyGenerator 對象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一個密鑰
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根據密匙進行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密後的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定義 加密演算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密隨機數生成器 (RNG),(可以不寫)
SecureRandom sr = new SecureRandom();
// 定義要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
// 參數:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 對要加密的內容進行編碼處理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六進制形式
return byte2hex(cipherByte);
}
/**
* 根據密匙進行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密後信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定義 加密演算法,
String Algorithm = "DES";
// 加密隨機數生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 對要解密的內容進行編碼處理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 創建密匙組，並將公匙，私匙放入到指定文件中
*
* 默認放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根據特定的演算法一個密鑰對生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密隨機數生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新設置此隨機對象的種子
random.setSeed(1000);
// 使用給定的隨機源（和默認的參數集合）初始化確定密鑰大小的密鑰對生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密鑰組
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 將公匙私匙寫入到文件當中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙對信息進行簽名 把簽名後的信息放入到指定的文件中
*
* @param info
* 要簽名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 從文件當中讀取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 從文件中讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 對象可用來生成和驗證數字簽名
Signature signet = Signature.getInstance("DSA");
// 初始化簽署簽名的私鑰
signet.initSign(myprikey);
// 更新要由位元組簽名或驗證的數據
signet.update(info.getBytes());
// 簽署或驗證所有更新位元組的簽名，返回簽名
byte[] signed = signet.sign();
// 將數字簽名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 讀取數字簽名文件 根據公匙，簽名，信息驗證信息的合法性
*
* @return true 驗證成功 false 驗證失敗
*/
public boolean validateSign(String signfile) {
// 讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 讀取簽名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 讀取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一個Signature對象,並用公鑰和簽名進行驗證
Signature signetcheck = Signature.getInstance("DSA");
// 初始化驗證簽名的公鑰
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 數組更新要簽名或驗證的數據
signetcheck.update(info.getBytes());
System.out.println(info);
// 驗證傳入的簽名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 將二進制轉化為16進制字元串
*
* @param b
* 二進制位元組數組
* @return String
*/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
}
/**
* 十六進制字元串轉化為2進制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 將兩個ASCII字元合成一個位元組； 如："EF"--> 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 將指定的對象寫入指定的文件
*
* @param file
* 指定寫入的文件
* @param objs
* 要寫入的對象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的對象
*
* @param file
* 指定的文件
* @param i
* 從1開始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 測試
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 執行MD5加密"Hello world!"
System.out.println("Hello經過MD5:" + jiami.encryptToMD5("Hello"));
// 生成一個DES演算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello為:" + str1);
// 使用這個密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密後為：" + str2);
// 創建公匙和私匙
jiami.createPairKey();
// 對Hello world!使用私匙進行簽名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙對簽名進行驗證。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}

7. 求DES加密演算法詳解拜託了各位 謝謝

DES加密演算法是分組加密演算法,明文以64位為單位分成塊。64位數據在64位密鑰的控制下,經過初始變換後,進行16輪加密迭代:64位數據被分成左右兩半部分,每部分32位,密鑰與右半部分相結合,然後再與左半部分相結合,結果作為新的右半部分;結合前的右半部分作為新的左半部分。這一系列步驟組成一輪。這種輪換要重復16次。最後一輪之後,再進行初始置換的逆置換,就得到了64位的密文。 DES的加密過程可分為加密處理,加密變換和子密鑰生成幾個部分組成。 1.加密處理過程 (1)初始變換。加密處理首先要對64位的明文按表1所示的初始換位表IP進行變換。表中的數值表示輸入位被置換後的新位置。例如輸入的第58位,在輸出的時候被置換到第1位;輸入的是第7位,在輸出時被置換到第64位。 (2)加密處理。上述換位處理的輸出,中間要經過16輪加密變換。初始換位的64位的輸出作為下一次的輸入,將64位分為左、右兩個32位,分別記為L0和R0,從L0、R0到L16、R16,共進行16輪加密變換。其中,經過n輪處理後的點左右32位分別為Ln和Rn,則可做如下定義: Ln=Rn-1 Rn=Ln-1 其中,kn是向第n輪輸入的48位的子密鑰,Ln-1和Rn-1分別是第n-1輪的輸出,f是Mangler函數。 (3)最後換位。進行16輪的加密變換之後,將L16和R16合成64位的數據,再按照表2所示的 最後換位表進行IP-1的換位,得到64位的密文,這就是DES演算法加密的結果。 2.加密變換過程 通過重復某些位將32位的右半部分按照擴展表3擴展換位表擴展為48位,而56位的密鑰先移位然後通過選擇其中的某些位減少至48位,48位的右半部分通過異或操作和48位的密鑰結合,並分成6位的8個分組,通過8個S-盒將這48位替代成新的32位數據,再將其置換一次。這些S-盒輸入6位,輸出4位。 一個S盒中具有4種替換表(行號用0、1、2、3表示),通過輸入的6位的開頭和末尾兩位選定行,然後按選定的替換表將輸入的6位的中間4位進行替代,例如:當向S1輸入011011時,開頭和結尾的組合是01,所以選中編號為1的替代表,根據中間4位1101,選定第13列,查找表中第1行第13列所示的值為5,即輸出0101,這4位就是經過替代後的值。按此進行,輸出32位,再按照表4 單純換位表P進行變換,這樣就完成了f(R,K)的變換 3.子密鑰生成過程 鑰通常表示為64位的自然數,首先通過壓縮換位PC-1去掉每個位元組的第8位,用作奇偶校驗,因此,密鑰去掉第8、16、24……64位減至56位,所以實際密鑰長度為56位,而每輪要生成48位的子密鑰。 輸入的64位密鑰,首先通過壓縮換位得到56位的密鑰,每層分成兩部分,上部分28位為C0,下部分為D0。C0和D0依次進行循環左移操作生成了C1和D1,將C1和D1合成56位,再通過壓縮換位PC-2輸出48位的子密鑰K1,再將C1和D1進行循環左移和PC-2壓縮換位,得到子密鑰K2......以此類推,得到16個子密鑰。密鑰壓縮換位表如表6所示。在產生子密鑰的過程中,L1、L2、L9、L16是循環左移1位,其餘都是左移2位,左移次數如表7所示。 詳細信息見 http://www.studa.net/yingyong/100126/11085967.html

8. 什麼是SSL加密

SSL是一個安全協議，它提供使用 TCP/IP 的通信應用程序間的隱私與完整性。網際網路的 超文本傳輸協議（HTTP）使用 SSL 來實現安全的通信。

在客戶端與伺服器間傳輸的數據是通過使用對稱演算法（如 DES 或 RC4）進行加密的。公用密鑰演算法（通常為 RSA）是用來獲得加密密鑰交換和數字簽名的，此演算法使用伺服器的SSL數字證書中的公用密鑰。有了伺服器的SSL數字證書，客戶端也可以驗證伺服器的身份。SSL 協議的版本 1 和 2 只提供伺服器認證。版本 3 添加了客戶端認證，此認證同時需要客戶端和伺服器的數字證書。

非對稱加密

那麼什麼是SSL使它對在線安全如此重要？應該探索的一個方面稱為非對稱加密。當您訪問網站時，瀏覽器會與網站建立連接。目標是在站點和瀏覽器之間的任何數據流之前確定SSL證書是否有效。所有這一切發生得如此之快，以至於您沒有發現延遲。

換句話說，連接的加密是在您看到任何內容之前確定的。如果出現問題，瀏覽器會阻止您進入您的軌道並讓您有機會從網站遷移。

什麼是非對稱加密很重要？它使用私鑰和公鑰。公鑰加密數據，而私有密鑰解密數據。只有在兩個鍵確定功能後才能繼續。

對稱加密

那麼對稱加密呢？這對驗證SSL證書的過程也很重要。在安全會話建立後，一旦瀏覽器和站點相互通信，這就是保持連接的原因。

由於使用了這種類型的加密，會話密鑰能夠加密和解密數據。你看到的是來回的數據流暢，仍然是安全的。

他們如何共同合作形成SSL

將非對稱加密視為檢查，確認和驗證瀏覽器和網站可以通信的手段。從某種意義上說，它會檢查SSL證書並確保通信安全。從那裡開始，對稱加密接管並允許通信流動不減，直到一方或另一方結束對話。

深入挖掘：RSA和ECC

當您了解有關SSL和加密的更多信息時，您可能會聽到兩個術語。其中之一稱為RSA加密。

這個名字基於提出這種加密理念的三個人：Rivest，Shamir和Adelman。它側重於公鑰加密，並且只要使用瀏覽器連接網站，就會使用特定的數學公式生成兩個大的素數。素數在任何時候都是保密的，最終導致公鑰和私鑰的發展。一旦完成該過程，就不再需要兩個素數。

這是瀏覽器和站點之間「握手」的另一層保護。與一般的加密一樣，它發生得如此之快，以至於您沒有時間看到它發生。它做的是保持連接安全。

您還將聽到ECC加密。這代表Elliptic Curve Cryptography。它已經使用了十多年，通常被認為比SSL的其他方面更復雜。它是如何參與建立連接的驗證過程的。

與RSA一樣，ECC也是關於評估和確定站點與瀏覽器之間的連接是安全可靠的。一旦驗證，就會有來回溝通的基礎。將其視為防止第三方闖入用戶與您訪問的網站之間的對話的另一種方式。

9. 密碼學部分 數據加密標准（DES）相關知識來回答，越詳細約好

額……我該說啥呢……
首先給你一個網址看看：http://kweenzy.blog.51cto.com/1093584/1008506
嘛……這個就是我本人的博客，所以不算抄襲哈……

1、見鏈接中【輪結構】下面的圖，每一個方框的右下角都寫了諸如「56bit」的字樣（1bit就是1位）……
2、見整個文章的中部位置紅色字體「密鑰的處理流程……」下面所述……
3、和4、……請參見原文然後想一下該怎麼回答……不過S盒的工作原理是啥我還真不知道……
5、DES的安全弱點啊……最顯而易見的是有弱密鑰，但是數量很少，在每次產生子密鑰的時候稍微做一下檢查就可以解決這個問題，貌似也說不上什麼弱點？以及，S盒是整個運算里唯一的一個非線性運算，其他的都是線性運算，線性運算就表示可以進行反推，所以S盒的安全性非常重要！但是S盒是完全公開的啊……更神奇的是研究了半天發現了一些S盒的規律但是根據發現出來的規律編程重新生成S盒的話，安全性沒有這個S盒高！另外，其實整個DES的加密過程經過了NSA（美國國家安全局）的修改，他們還拒絕提供為什麼修改的信息，所以很多人擔心其實NSA可以分分鍾破解DES……其他的安全弱點……記不清了……回頭找資料來補充回答哈……
6、我靠不會描述！……騷年你自己加油看完資料再思考怎麼進行數學描述……
7、密鑰的使用順序是相反的……【其實好像密鑰進行左循環移位時，加密密鑰第一輪移位是1位，解密密鑰第一輪是0位……
8、騷年你自己加油畫出示意圖……【EDE就是先加密再解密再加密，3就是使用三個不同的密鑰K1K2K3……