DES算法實現過程期刊論文發表

　　1. 處理密鑰:

　　1.1 從用戶處獲得64位密鑰.(每第8位為校驗位,為使密鑰有正確的奇偶校驗,每個密鑰要有奇 數個”1”位.(本文如未特指，均指二進制位)

　　1.2 具體過程:

　　1.2.1 對密鑰實施變換,使得變換以后的密鑰的各個位與原密鑰位對應關系如下表所示:

　　表一為忽略校驗位以后情況

　　1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

　　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

　　29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

　　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

　　1.2.2 把變換后的密鑰等分成兩部分,前28位記為C[0], 后28位記為D[0].

　　1.2.3 計算子密鑰(共16個)， 從i=1開始。

　　1.2.3.1 分別對C[i-1],D[i-1]作循環左移來生成C[i],D[i].(共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

　　1.2.3.2 串聯C[i],D[i]，得到一個56位數，然后對此數作如下變換以產生48位子密鑰K[i]。

　　變換過程如下：

　　1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

　　14 17 11 24 1 5 3 28 15 6 21 10 23 19 12 4 26 8 16 7 27 20 13 2

　　25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

　　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.2.3.3 按以上方法計算出16個子密鑰。

　　2.對64位數據塊的處理：

　　2.1 把數據分成64位的數據塊，不夠64位的以適當的方式填補。

　　2.2對數據塊作變換。

　　bit goes to bit bit goes to bit

　　58 1 57 33

　　50 2 49 34

　　42 3 41 35

　　34 4 33 36

　　26 5 25 37

　　18 6 17 38

　　10 7 9 39

　　2 8 1 40

　　60 9 59 41

　　52 10 51 42

　　44 11 43 43

　　36 12 35 44

　　28 13 27 45

　　20 14 19 46

　　12 15 11 47

　　4 16 3 48

　　62 17 61 49

　　54 18 53 50

　　46 19 45 51

　　38 20 37 52

　　30 21 29 53

　　22 22 21 54

　　14 23 13 55

　　6 24 5 56

　　64 25 63 57

　　56 26 55 58

　　48 27 47 59

　　40 28 39 60

　　32 29 31 61

　　24 30 23 62

　　16 31 15 63

　　8 32 7 64

　　2.3 將變換后的數據塊等分成前后兩部分，前32位記為L[0],后32位記為R[0]。

　　2.4 用16個子密鑰對數據加密。

　　2.4.1 根據下面的擴沖函數E，擴展32位的成48位

　　bit goes to bit bit goes to bit bit goes to bit bit goes to bit

　　32 1 8 13 16 25 24 37

　　1 2 9 14 17 26 25 38

　　2 3 10 15 18 27 26 39

　　3 4 11 16 19 28 27 40

　　4 5 12 17 20 29 28 41

　　5 6 13 18 21 30 29 42

　　4 7 12 19 20 31 28 43

　　5 8 13 20 21 32 29 44

　　6 9 14 21 22 33 30 45

　　7 10 15 22 23 34 31 46

　　8 11 16 23 24 35 32 47

　　9 12 17 24 25 36 1 48

　　2.4.2 用E{R[i-1]}與K[i]作異或運算。

　　2.4.3 把所得的48位數分成8個6位數。1-6位為B[1]，7-12位為B[2],……43-48位為B[8]。

　　2.4.4 用S密箱里的值替換B[j]。從j=1開始。S密箱里的值為4位數，共8個S密箱

　　2.4.4.1 取出B[j]的第1和第6位串聯起來成一個2位數，記為m.。m即是S密箱里用來替換

　　B[j]的數所在的列數。

　　2.4.4.2 取出B[j]的第2至第5位串聯起來成一個4位數，記為n。n即是S密箱里用來替換

　　B[j]的數所在的行數。

　　2.4.4.3 用S密箱里的值S[j][ m][ n]替換B[j]。8個S密箱如下所示：

　　--------

　　S-BOXES1

　　Binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ Dec 0 1 2 3

　　0000 0 14 0 4 15

　　0001 1 4 15 1 12

　　0010 2 13 7 14 8

　　0011 3 1 4 8 2

　　0100 4 2 14 13 4

　　0101 5 15 2 6 9

　　0110 6 11 13 2 1

　　0111 7 8 1 11 7

　　1000 8 3 10 15 5

　　1001 9 10 6 12 11

　　1010 10 6 12 9 3

　　1011 11 12 11 7 14

　　1100 12 5 9 3 10

　　1101 13 9 5 10 0

　　1110 14 0 3 5 6

　　1111 15 7 8 0 13

　　--------

　　S-BOXES2

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 15 3 0 13

　　0001 1 1 13 14 8

　　0010 2 8 4 7 10

　　0011 3 14 7 11 1

　　0100 4 6 15 10 3

　　0101 5 11 2 4 15

　　0110 6 3 8 13 4

　　0111 7 4 14 1 2

　　1000 8 9 12 5 11

　　1001 9 7 0 8 6

　　1010 10 2 1 12 7

　　1011 11 13 10 6 12

　　1100 12 12 6 9 0

　　1101 13 0 9 3 5

　　1110 14 5 11 2 14

　　1111 15 10 5 15 9

　　--------

　　S-BOXES3

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 10 13 13 1

　　0001 1 0 7 6 10

　　0010 2 9 0 4 13

　　0011 3 14 9 9 0

　　0100 4 6 3 8 6

　　0101 5 3 4 15 9

　　0110 6 15 6 3 8

　　0111 7 5 10 0 7

　　1000 8 1 2 11 4

　　1001 9 13 8 1 15

　　1010 10 12 5 2 14

　　1011 11 7 14 12 3

　　1100 12 11 12 5 11

　　1101 13 4 11 10 5

　　1110 14 2 15 14 2

　　1111 15 8 1 7 12

　　--------

　　S-BOXES4

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 7 13 10 3

　　0001 1 13 8 6 15

　　0010 2 14 11 9 0

　　0011 3 3 5 0 6

　　0100 4 0 6 12 10

　　0101 5 6 15 11 1

　　0110 6 9 0 7 13

　　0111 7 10 3 13 8

　　1000 8 1 4 15 9

　　1001 9 2 7 1 4

　　1010 10 8 2 3 5

　　1011 11 5 12 14 11

　　1100 12 11 1 5 12

　　1101 13 12 10 2 7

　　1110 14 4 14 8 2

　　1111 15 15 9 4 14

　　--------

　　S-BOXES5

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 2 14 4 11

　　0001 1 12 11 2 8

　　0010 2 4 2 1 12

　　0011 3 1 12 11 7

　　0100 4 7 4 10 1

　　0101 5 10 7 13 14

　　0110 6 11 13 7 2

　　0111 7 6 1 8 13

　　1000 8 8 5 15 6

　　1001 9 5 0 9 15

　　1010 10 3 15 12 0

　　1011 11 15 10 5 9

　　1100 12 13 3 6 10

　　1101 13 0 9 3 4

　　1110 14 14 8 0 5

　　1111 15 9 6 14 3

　　--------

　　S-BOXES6

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 12 10 9 4

　　0001 1 1 15 14 3

　　0010 2 10 4 15 2

　　0011 3 15 2 5 12

　　0100 4 9 7 2 9

　　0101 5 2 12 8 5

　　0110 6 6 9 12 15

　　0111 7 8 5 3 10

　　1000 8 0 6 7 11

　　1001 9 13 1 0 14

　　1010 10 3 13 4 1

　　1011 11 4 14 10 7

　　1100 12 14 0 1 6

　　1101 13 7 11 13 0

　　1110 14 5 3 11 8

　　1111 15 11 8 6 13

　　--------

　　S-BOXES7

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 4 13 1 6

　　0001 1 11 0 4 11

　　0010 2 2 11 11 13

　　0011 3 14 7 13 8

　　0100 4 15 4 12 1

　　0101 5 0 9 3 4

　　0110 6 8 1 7 10

　　0111 7 13 10 14 7

　　1000 8 3 14 10 9

　　1001 9 12 3 15 5

　　1010 10 9 5 6 0

　　1011 11 7 12 8 15

　　1100 12 5 2 0 14

　　1101 13 10 15 5 2

　　1110 14 6 8 9 3

　　1111 15 1 6 2 12

　　--------

　　S-BOXES8

　　binary d1d6 => 00 01 10 11

　　\/ d2..d5 \/ dec 0 1 2 3

　　0000 0 13 1 7 2

　　0001 1 2 15 11 1

　　0010 2 8 13 4 14

　　0011 3 4 8 1 7

　　0100 4 6 10 9 4

　　0101 5 15 3 12 10

　　0110 6 11 7 14 8

　　0111 7 1 4 2 13

　　1000 8 10 12 0 15

　　1001 9 9 5 6 12

　　1010 10 3 6 10 9

　　1011 11 14 11 13 0

　　1100 12 5 0 15 3

　　1101 13 0 14 3 5

　　1110 14 12 9 5 6

　　1111 15 7 2 8 11

　　2.4.4.4 返回2.4.4.1直至8個數據塊都被替換。

　　2.4.5 把B[1]至B[8] 順序串聯起來得到一個32位數。對這個數做如下變換：

　　bit goes to bit bit goes to bit

　　16 1 2 17

　　7 2 8 18

　　20 3 24 19

　　21 4 14 20

　　29 5 32 21

　　12 6 27 22

　　28 7 3 23

　　17 8 9 24

　　1 9 19 25

　　15 10 13 26

　　23 11 30 27

　　26 12 6 28

　　5 13 22 29

　　18 14 11 30

　　31 15 4 31

　　10 16 25 32

　　2.4.6 把得到的結果與L[i-1]作異或運算。把計算結果賦給R[i]。

　　2.4.7 把R[i-1]的值賦給L[i]。

　　2.4.8 從2.4.1循環執行，直到K[16]也被用到。

　　2.5 把R[16]和L[16] 順序串聯起來得到一個64位數。對這個數實施2.2變換的逆變換。

　　以上就是DES算法如何加密一段64位數據塊。解密時用同樣的過程，只需把16個子密鑰的

　　順續顛倒過來，應用的順序為K[16]，K[15]，K[14]，。。。。K[1]。