des加密要經過16次迭代

❶ DES 加密演算法是怎樣的一種演算法要通俗解釋..

1977年1月，美國政府頒布：採納IBM公司設計的方案作為非機密數據的正式數據加密標准（DES棗Data Encryption Standard）。

目前在國內，隨著三金工程尤其是金卡工程的啟動，DES演算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收費站等領域被廣泛應用，以此來實現關鍵數據的保密，如信用卡持卡人的PIN的加密傳輸，IC卡與POS間的雙向認證、金融交易數據包的MAC校驗等，均用到DES演算法。
DES演算法的入口參數有三個：Key、Data、Mode。其中Key為8個位元組共64位，是DES演算法的工作密鑰；Data也為8個位元組64位，是要被加密或被解密的數據；Mode為DES的工作方式，有兩種：加密或解密。
DES演算法是這樣工作的：如Mode為加密，則用Key 去把數據Data進行加密， 生成Data的密碼形式（64位）作為DES的輸出結果；如Mode為解密，則用Key去把密碼形式的數據Data解密，還原為Data的明碼形式（64位）作為DES的輸出結果。在通信網路的兩端，雙方約定一致的Key，在通信的源點用Key對核心數據進行DES加密，然後以密碼形式在公共通信網（如電話網）中傳輸到通信網路的終點，數據到達目的地後，用同樣的Key對密碼數據進行解密，便再現了明碼形式的核心數據。這樣，便保證了核心數據（如PIN、MAC等）在公共通信網中傳輸的安全性和可靠性。
通過定期在通信網路的源端和目的端同時改用新的Key，便能更進一步提高數據的保密性，這正是現在金融交易網路的流行做法。

DES演算法詳述
DES演算法把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位，整個演算法的主流程圖如下：

其功能是把輸入的64位數據塊按位重新組合，並把輸出分為L0、R0兩部分，每部分各長32位，其置換規則見下表：
58,50,12,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,
即將輸入的第58位換到第一位，第50位換到第2位，...，依此類推，最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位，R0 是右32位，例：設置換前的輸入值為D1D2D3......D64，則經過初始置換後的結果為：L0=D58D50...D8；R0=D57D49...D7。
經過16次迭代運算後。得到L16、R16，將此作為輸入，進行逆置換，即得到密文輸出。逆置換正好是初始置的逆運算，例如，第1位經過初始置換後，處於第40位，而通過逆置換，又將第40位換回到第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,
放大換位表
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,
單純換位表
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,
在f(Ri,Ki)演算法描述圖中，S1,S2...S8為選擇函數，其功能是把6bit數據變為4bit數據。下面給出選擇函數Si(i=1,2......8)的功能表：
選擇函數Si
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,
在此以S1為例說明其功能，我們可以看到：在S1中，共有4行數據，命名為0，1、2、3行；每行有16列，命名為0、1、2、3，......，14、15列。
現設輸入為： D＝D1D2D3D4D5D6
令：列＝D2D3D4D5
行＝D1D6
然後在S1表中查得對應的數，以4位二進製表示，此即為選擇函數S1的輸出。下面給出子密鑰Ki(48bit)的生成演算法
從子密鑰Ki的生成演算法描述圖中我們可以看到：初始Key值為64位，但DES演算法規定，其中第8、16、......64位是奇偶校驗位，不參與DES運算。故Key 實際可用位數便只有56位。即：經過縮小選擇換位表1的變換後，Key 的位數由64 位變成了56位，此56位分為C0、D0兩部分，各28位，然後分別進行第1次循環左移，得到C1、D1，將C1（28位）、D1（28位）合並得到56位，再經過縮小選擇換位2，從而便得到了密鑰K0（48位）。依此類推，便可得到K1、K2、......、K15，不過需要注意的是，16次循環左移對應的左移位數要依據下述規則進行：
循環左移位數
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
以上介紹了DES演算法的加密過程。DES演算法的解密過程是一樣的，區別僅僅在於第一次迭代時用子密鑰K15，第二次K14、......，最後一次用K0，演算法本身並沒有任何變化。

❷ des加密演算法流程圖

DES(Data Encryption Standard)滿足了國家標准局欲達到的4個目的:提供高質量的數據保護，防止數據未經授權的泄露和未被察覺的修改；具有相當高的復雜性，使得破譯的開銷超過可能獲得的利益，同時又要便於理解和掌握；

DES演算法把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位，首先，DES把輸入的64位數據塊按位重新組合，並把輸出分為L0、R0兩部分，每部分各長32位，並進行前後置換（輸入的第58位換到第一位，第50位換到第2位，依此類推，最後一位是原來的第7位），最終由L0輸出左32位，R0輸出右32位，根據這個法則經過16次迭代運算後，得到L16、R16，將此作為輸入，進行與初始置換相反的逆置換，即得到密文輸出。

DES演算法的入口參數有三個：Key、Data、Mode。其中Key為8個位元組共64位，是DES演算法的工作密鑰；Data也為8個位元組64位，是要被加密或被解密的數據；Mode為DES的工作方式，有兩種：加密或解密，如果Mode為加密，則用Key去把數據Data進行加密，生成Data的密碼形式作為DES的輸出結果；如Mode為解密，則用Key去把密碼形式的數據Data解密，還原為Data的明碼形式作為DES的輸出結果。在使用DES時，雙方預先約定使用的」密碼」即Key，然後用Key去加密數據；接收方得到密文後使用同樣的Key解密得到原數據，這樣便實現了安全性較高的數據傳輸。

❸ 求DES密碼值

DES( Data Encryption Standard)演算法，於1977年得到美國政府的正式許可，是一種用56位密鑰來加密64位數據的方法。雖然56位密鑰的DES演算法已經風光不在,而且常有用Des加密的明文被破譯的報道,但是了解一下昔日美國的標准加密演算法總是有益的,而且目前DES演算法得到了廣泛的應用,在某些場合,她仍然發揮著余熱^_^.

1.1 密鑰生成

1.1.1 取得密鑰

從用戶處取得一個64位(本文如未特指，均指二進制位))長的密碼key ,

去除64位密碼中作為奇偶校驗位的第8、16、24、32、40、48、56、64位,剩下的56位作為有效輸入密鑰.

1.1.2 等分密鑰

表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 50 44 36

表2.
65 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

把在1.1.1步中生成的56位輸入密鑰分成均等的A,B兩部分,每部分為28位,參照表1和表2把輸入密鑰的位值填入相應的位置. 按照表1所示A的第一位為輸入的64位密鑰的第57位，A的第2位為64位密鑰的第49位，...，依此類推，A的最後一位最後一位是64位密鑰的第36位。

1.1.3 密鑰移位

表3. i 1 2 3 4 5 6 7 8
ǿ 1 1 2 2 2 2 2 2
i 9 10 11 12 13 14 15 16
ǿ 1 2 2 2 2 2 2 1

DES演算法的密鑰是經過16次迭代得到一組密鑰的,把在1.1.2步中生成的A,B視為迭代的起始密鑰,表3顯示在第i次迭代時密鑰循環左移的位數. 比如在第1次迭代時密鑰循環左移1位,第3次迭代時密鑰循環左移2位.
第9次迭代時密鑰循環左移1位,第14次迭代時密鑰循環左移2位.

第一次迭代:
A(1) = ǿ(1) A
B(1) = ǿ(1) B
第i次迭代:
A(i) = ǿ(i) A(i-1)
B(i) = ǿ(i) B(i-1)

1.1.4 密鑰的選取

表4.
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

在1.1.3步中第i次迭代生成的兩個28位長的密鑰為

把合並

按照表4所示k的第一位為56位密鑰的第14位，k的第2位為56位密鑰的第17位，...，依此類推，k的最後一位最後一位是56位密鑰的第32位。 生成與進行第i次迭代加密的數據進行按位異或的48位使用密鑰:

1.1.5迭代
DES演算法密鑰生成需要進行16次迭代,在完成16次迭代前,循環執行1.1.3-1.1.4步.
最終形成16套加密密鑰:key[0] , key[1] , key[2] ,…. key[14] , key[15] .

1. 2 數據的加密操作

1.2.1 取得數據
把明文數據分成64位的數據塊，不夠64位的數據塊以適當的方式補足。

1.2.2 初始換位

表5. 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
按照表5所示把輸入的64位數據的原第58位換到第一位,原第50位換到第二位，...，依此類推,最後的得到新的64位數據.
OldData newData

1.2.3 數據擴展

表6.
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
第一次迭代以1.2.2步中生成的newData作為輸入數據,第i (i > 1)次迭代以第i-1次的64位輸出數據為輸入數據,把64位數據按位置等分成左右兩部分:

保持left不變,根據表6把right由32位擴展成48位

把擴展後的48位right與第i次迭代生成的48位加密密鑰進行按位異或操作 形成一個新的48位的right.

1.2.4 數據壓縮

表7.1 1 2 3 4 5 6 7 8
1-8 0xe 0x0 0x4 0xf 0xd 0x7 0x1 0x4
9-16 0x2 0xe 0xf 0x2 0xb 0xd 0xb 0xe
17-24 0x3 0xa 0xa 0x6 0x6 0xc 0xc 0xb
25-32 0x5 0x9 0x9 0x5 0x0 0x3 0x7 0x8
33-40 0x4 0xf 0x1 0xc 0xe 0x8 0x8 0x2
41-48 0xd 0x4 0x6 0x9 0x2 0x1 0xb 0x7
49-56 0xf 0x5 0xc 0xb 0x9 0x3 0x7 0xe
57-64 0x3 0xa 0xa 0x0 0x5 0x6 0x0 0xd

表7.2 1 2 3 4 5 6 7 8
1-8 0xf 0x3 0x1 0xd 0x8 0x4 0xe 0x7
9-16 0x6 0xf 0xb 0x2 0x3 0x8 0x4 0xf
17-24 0x9 0xc 0x7 0x0 0x2 0x1 0xd 0xa
25-32 0xc 0x6 0x0 0x9 0x5 0xb 0xa 0x5
33-40 0x0 0xd 0xe 0x8 0x7 0xa 0xb 0x1
41-48 0xa 0x3 0x4 0xf 0xd 0x4 0x1 0x2
49-56 0x5 0xb 0x8 0x6 0xc 0x7 0x6 0xc
57-64 0x9 0x0 0x3 0x5 0x2 0xe 0xf 0x9

表7.3 1 2 3 4 5 6 7 8
1-8 0xa 0xd 0x0 0x7 0x9 0x0 0xe 0x9
9-16 0x6 0x3 0x3 0x4 0xf 0x6 0x5 0xa
17-24 0x1 0x2 0xd 0x8 0xc 0x5 0x7 0xe
25-32 0xb 0xc 0x4 0xb 0x2 0xf 0x8 0x1
33-40 0xd 0x1 0x6 0xa 0x4 0xd 0x9 0x0
41-48 0x8 0x6 0xf 0x9 0x3 0x8 0x0 0x7
49-56 0xb 0x4 0x1 0xf 0x2 0xe 0xc 0x3
57-64 0x5 0xb 0xa 0x5 0xe 0x2 0x7 0xc

表7.4 1 2 3 4 5 6 7 8
1-8 0x7 0xd 0xd 0x8 0xe 0xb 0x3 0x5
9-16 0x0 0x6 0x6 0xf 0x9 0x0 0xa 0x3
17-24 0x1 0x4 0x2 0x7 0x8 0x2 0x5 0xc
25-32 0xb 0x1 0xc 0xa 0x4 0xe 0xf 0x9
33-40 0xa 0x3 0x6 0xf 0x9 0x0 0x0 0x6
41-48 0xc 0xa 0xb 0xa 0x7 0xd 0xd 0x8
49-56 0xf 0x9 0x1 0x4 0x3 0x5 0xe 0xb
57-64 0x5 0xc 0x2 0x7 0x8 0x2 0x4 0xe

表7.5 1 2 3 4 5 6 7 8
1-8 0x2 0xe 0xc 0xb 0x4 0x2 0x1 0xc
9-16 0x7 0x4 0xa 0x7 0xb 0xd 0x6 0x1
17-24 0x8 0x5 0x5 0x0 0x3 0xf 0xf 0xa
25-32 0xd 0x3 0x0 0x9 0xe 0x8 0x9 0x6
33-40 0x4 0xb 0x2 0x8 0x1 0xc 0xb 0x7
41-48 0xa 0x1 0xd 0xe 0x7 0x2 0x8 0xd
49-56 0xf 0x6 0x9 0xf 0xc 0x0 0x5 0x9
57-64 0x6 0xa 0x3 0x4 0x0 0x5 0xe 0x3

表7.6 1 2 3 4 5 6 7 8
1-8 0xc 0xa 0x1 0xf 0xa 0x4 0xf 0x2
9-16 0x9 0x7 0x2 0xc 0x6 0x9 0x8 0x5
17-24 0x0 0x6 0xd 0x1 0x3 0xd 0x4 0xe
25-32 0xe 0x0 0x7 0xb 0x5 0x3 0xb 0x8
33-40 0x9 0x4 0xe 0x3 0xf 0x2 0x5 0xc
41-48 0x2 0x9 0x8 0x5 0xc 0xf 0x3 0xa
49-56 0x7 0xb 0x0 0xe 0x4 0x1 0xa 0x7
57-64 0x1 0x6 0xd 0x0 0xb 0x8 0x6 0xd

表7.7 1 2 3 4 5 6 7 8
1-8 0x4 0xd 0xb 0x0 0x2 0xb 0xe 0x7
9-16 0xf 0x4 0x0 0x9 0x8 0x1 0xd 0xa
17-24 0x3 0xe 0xc 0x3 0x9 0x5 0x7 0xc
25-32 0x5 0x2 0xa 0xf 0x6 0x8 0x1 0x6
33-40 0x1 0x6 0x4 0xb 0xb 0xd 0xd 0x8
41-48 0xc 0x1 0x3 0x4 0x7 0xa 0xe 0x7
49-56 0xa 0x9 0xf 0x5 0x6 0x0 0x8 0xf
57-64 0x0 0xe 0x5 0x2 0x9 0x3 0x2 0xc

表7.8 1 2 3 4 5 6 7 8
1-8 0xd 0x1 0x2 0xf 0x8 0xd 0x4 0x8
9-16 0x6 0xa 0xf 0x3 0xb 0x7 0x1 0x4
17-24 0xa 0xc 0x9 0x5 0x3 0x6 0xe 0xb
25-32 0x5 0x0 0x0 0xe 0xc 0x9 0x7 0x2
33-40 0x7 0x2 0xb 0x1 0x4 0xe 0x1 0x7
41-48 0x9 0x4 0xc 0xa 0xe 0x8 0x2 0xd
49-56 0x0 0xf 0x6 0xc 0xa 0x9 0xd 0x0
57-64 0xf 0x3 0x3 0x5 0x5 0x6 0x8 0xb

在1.2.3步中形成了48位的right值,

需要把48位的right值轉換成32位的right值.把right視為由8個6位二進制塊組成,

a,b….h都是6位,強制轉換成10進制整數的值都不大於64 ,a,b…h轉成10進制整數後,在對應的表中根據轉換後整數值取得對應位置的替代值,
a對應表7.1
b對應表7.2
c對應表7.3
d對應表7.4
e對應表7.5
f對應表7.6
g對應表7.7
h對應表7.8
比如:
a = 32 ,那麼到表7.1中找到32的位置,把對應的替代值0x8賦給a;
d = 53 ,那麼到表7.4中找到的位置,把對應的替代值 0x3賦給d ;
g = 16, 那麼到表7.7中找到16的位置,把對應的替代值0xa賦給g;
每6位用一個4位替換這樣就完成了從48位向32位數據的轉換.

有些資料中介紹6位轉4位的實現方法與本文所採用的不同,但殊途同歸,最終的結果是相同的.

1.2.5 數據換位

表8
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

把1.2.4步形成的32位right

根據表8進行轉換:
數據的原第16位換到第一位,原第7位換到第二位，...，依此類推,最後得到新的32位數據.

1.2.6 交換數據
把right 和left按位異或後的值賦給right,然後將本輪輸入的原始right值賦給left.

1.2.7 迭代
DES演算法需要進行16次迭代,在完成16次迭代前,把第i-1次得到的的left和right的值作為第i次的輸入數據,重復1.2.3~1.2.6的步驟,但是有一點要記住:在步驟1.2.3中第i次迭代要選擇第i次迭代生成的密鑰與數據進行按位異或.

1.2.8 數據整理

表9
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

為保證加密和解密的對稱性,DES演算法的前15次迭代每完成一次迭代都要交換left和right的值,第16次迭代不交換兩者的數值. 到此把32位的left和right合並成64位的Data

根據表9重新調整Data的位值
數據的原第40位換到第一位,原第8位換到第二位，...，依此類推,最後的得到新的64位.

Data即為密文.

1.3 數據的解密
數據解密的演算法與加密演算法相同,區別在於1.2.3步中和數據進行按位異或的密鑰的使用順序不同,在加密中是按照第i次迭代就採用第i次迭代生成的密鑰進行異或,而解密時第i次迭代就採用第17-i次迭代生成的密鑰和數據進行異或.

二.演算法實現

筆者用c語言編寫了的基於DES演算法的核心加密解密程序並針對不同的加密解密需求封裝了6個介面函數.

2. 1 演算法實現介面函數的介紹

2.1.1 int des(char *data, char *key,int readlen)
參數:
1.存放待加密明文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.待加密明文的長度(8位元組的倍數)
功能:
生成加密密鑰,把待加密的明文數據分割成64位的塊,逐塊完成16次迭代加密,密文存放在data所指向的內存中.

2.1.2 int Ddes(char *data, char *key,int readlen)
參數:
1.存放待解密文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.待解密文的長度( 8位元組的倍數)
功能:
生成解密密鑰,把待解密文分割成64位的塊,逐塊完成16次迭代解密,解密後的明文存放在data所指向的內存中.

2.1.3 int des3(char *data, char *key, int n ,int readlen)
參數:
1.存放待加密明文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.用戶指定進行多少層加密
4.待加密明文的長度(8位元組的倍數)
功能:
生成加密密鑰,把待加密的明文分割成64位的塊,把第i-1層加密後的密文作為第i層加密的明文輸入,根據用戶指定的加密層數進行n層加密,最終生成的密文存放在data所指向的內存中.
說明:
用戶僅僅輸入一條密鑰,所有的加密密鑰都是由這條密鑰生成.

2.1.4 int Ddes3(char *data, char*key, int n ,int readlen)
參數:
1.存放待解密文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.用戶指定進行多少層解密
4.待解密文的長度(8位元組的倍數)
功能:
生成解密密鑰,把待解密文分割成64位的塊,把第i-1層解密後的"明文"作為第i層解密的密文輸入,根據用戶指定的解密層數進行n層解密,最終生成的明文存放在data所指向的內存中.
說明:
用戶僅僅輸入一條密鑰,所有的解密密鑰都是由這條密鑰生成.

2.1.5 int desN(char*data,char**key,int n_key,int readlen)
參數:
1.存放待加密明文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.用戶指定了多少條密鑰
4.待加密明文的長度(8位元組的倍數)
功能:
生成加密密鑰,把待加密的明文分割成64位的塊,把第i-1層加密後的密文作為第i層加密的明文輸入,根據用戶指定的加密層數進行n層加密,最終生成的密文存放在data所指向的內存中.
說明:
這里用戶通過輸入的密鑰條數決定加密的層數,每輪16次迭代加密所使用的加密密鑰是由用戶自定的對應密鑰生成.

2.1.6 int DdesN(char*data,char**key,intn_key,int readlen)
參數:
1.存放待解密文的內存指針(長度為readlen,可能經過填充;
2.存放用戶輸入的密鑰內存的指針
3.用戶指定了多少條密鑰
4.待解密文的長度(8位元組的倍數)
功能:
生成解密密鑰,把待解密文分割成64位的塊,把第i-1層解密後的」明文」作為第i層解密的密文輸入,根據用戶指定的解密層數進行n層解密,最終生成的明文存放在data所指向的內存中.
說明:
這里用戶通過輸入的密鑰條數決定解密的層數,每輪16次迭代加密所使用的解密密鑰是由用戶自定的對應密鑰生成.

源代碼說明:
這是一個有關DES演算法實現文件加密工具的代碼,我把演算法實現的代碼封裝在了一個DLL中.工程中已經把環境設置好了,無論選擇Debug版本還是Release版本只需直接編譯就行了.使用時把.exe文件和.dll文件拷貝到同一個目錄中即可

❹ DES加密演算法中進行16次迭代的時候第一位是怎麼處理的

問題有誤，L[i]是第i次迭代的左半部分，不是左半部分的第i位。。。。

❺ DES演算法中16輪迭代運算的作用是什麼

確保密碼加密的復雜度。

❻ des演算法的主要流程

DES演算法把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位，整個演算法的主流程圖如下： 其功能是把輸入的64位數據塊按位重新組合，並把輸出分為L0、R0兩部分，每部分各長32位，其置換規則見下表：
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,
即將輸入的第58位換到第一位，第50位換到第2位，...，依此類推，最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位，R0 是右32位，例：設置換前的輸入值為D1D2D3......D64，則經過初始置換後的結果為：L0=D58D50...D8；R0=D57D49...D7。
經過16次迭代運算後。得到L16、R16，將此作為輸入，進行逆置換，即得到密文輸出。逆置換正好是初始置換的逆運算。例如，第1位經過初始置換後，處於第40位，而通過逆置換，又將第40位換回到第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, 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, 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, 在f(Ri,Ki）演算法描述圖中，S1,S2...S8為選擇函數，其功能是把48bit數據變為32bit數據。下面給出選擇函數Si(i=1,2......8）的功能表：
選擇函數Si
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,
在此以S1為例說明其功能，我們可以看到：在S1中，共有4行數據，命名為0，1、2、3行；每行有16列，命名為0、1、2、3，......，14、15列。
現設輸入為：D=D1D2D3D4D5D6
令：列=D2D3D4D5
行=D1D6
然後在S1表中查得對應的數，以4位二進製表示，此即為選擇函數S1的輸出。下面給出子密鑰Ki（48bit）的生成演算法 1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
以上介紹了DES演算法的加密過程。DES演算法的解密過程是一樣的，區別僅僅在於第一次迭代時用子密鑰K15，第二次K14、......，最後一次用K0，演算法本身並沒有任何變化。

❼ 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 編程實例與技巧》 機械工業出版社 王華等編著

❽ 求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

❾ 有關DES演算法的一道證明題

證明：DES演算法的加密演算法和解密演算法是完全一樣的，所不同的是密鑰以相反的順序依次加入到輪函數中。

DES演算法的加密流程如下：
（1）生成子密鑰
首先，將64比特的密鑰（實際有效位數只有56比特）進行置換，得到56比特的密鑰串；
然後，將56比特的串分為兩個28比特的子串，經過16輪的循環左移以及合並置換，生成16個子密鑰，記為K1K2K3...K16；
（2）加密
首先，將64比特的明文W做初始置換，得到結果IP（W）；
將結果分成兩個32比特的子串，記為L0和R0，所以L0R0=IP（W）；
然後，根據L0、R0以及K1，求得L1和R1，具體如下：
L1=R0，即L1跟R0完全相同；
R1=P(S(E(R0)^K1))^L0，其中：
E(R0)表示對R0做擴展置換；
E(R0)^K1表示上一步的結果與K1做異或運算；
S(E(R0)^K1)表示上一步的結果做S-box運算；
P(S(E(R0)^K1))表示上一步的結果做置換；
P(S(E(R0)^K1))^L0表示上一步的結果與L0做異或運算。
以上的過程就是一次輪函數。如此，再由L1、R1以及K2，求得L2R2。以此類推，經過16次輪函數的迭代即可求得L16R16。
最後，把L16R16交換順序，得到R16L16，再經過一次逆置換FP(R16L16),可以得到64比特的密文C,所以C=FP（R16L16）。

我們知道，DES的解密只需將16個子密鑰以相反的順序加入到輪函數中，重復加密的步驟即可。 現在我們要證明DES加密和解密的演算法是完全一樣，只是子密鑰使用的順序相反。也就是說，我們要證明密文經過子密鑰順序相反的加密之後可以得到明文。
DES演算法的解密流程如下：
（1）生成子密鑰
解密的時候使用的子密鑰與加密時的順序相反，記為K16K15...K2K1；
（2）解密
首先，將64比特的密文C做初始置換IP（C），
由於C=FP（R16L16），所以IP（C）=IP（FP（R16L16））=R16L16，因此得到的結果為R16L16。
將結果分成兩個32比特的子串，也就是R16和L16。
然後，對其進行輪函數運算，結果記為XY，具體如下：
X=L16，
Y=P(S(E(L16)^K16))^R16。
從加密的過程中，我們知道，
L16=R15,
R16=P(S(E(R15)^K16))^L15，
因此，Y=P(S(E(L16)^K16))^P(S(E(R15)^K16))^L15。
由於L16=R15，所以P(S(E(L16)^K16))=P(S(E(R15)^K16))，
所以P(S(E(L16)^K16))^P(S(E(R15)^K16))=，
因為^L15=L15，
所以Y=P(S(E(L16)^K16))^P(S(E(R15)^K16))^L15=L15。
由此可知，R16L16經過一次輪函數之後，得到的結果是R15L15。
如此，在對R15L15做輪函數運算，得到R14L14。以此類推，經過16次輪函數的迭代，得到R0L0。
最後，把R0L0交換順序，得到L0R0，再經過一次逆置換FP（L0R0）=FP（IP（W））=W，就得到了明文W。
綜上所述，DES演算法的加密演算法和解密演算法是完全一樣的，所不同的是密鑰以相反的順序依次加入到輪函數中。

❿ des的加密解密迭代次數為什麼是16次

你好，這個是演算法的規定。應該有兩方面的考慮，一個迭代次數太多會增加復雜度。運算時間拉長。他是1972年出現的當時的cpu跟現在比就太弱了，所以不能做太復雜的運算。另外一個方面就是迭代的次數少就比較容易被攻擊和解破，所以在當時有限的條件下選擇了16。