DES演算法例項詳解

• 國家標準局催生了DES
• 一些初步的DES例子
• DES到底是如何工作的
• 第一步：建立16個子祕鑰，每個長48位元
• 第二步：加密資料的每個64位區塊
• Reference

譯自J. Orlin Grabbe的名作《DES Algorithm Illustrated》，國外許多大學將該文章作為補充材料，可作為理解DES演算法的最佳入門手冊。反觀許多教材介紹DES時直接照搬一張流程圖，圖中IP等縮寫符號不加解釋，讓人誤解；許多部落格則直接給出蹩腳的原始碼，對內部流程缺乏解讀。事實上，DES在演算法上並不複雜，只是流程繁多而已。此時利用一個簡單的例子，手工推演一下就能輕鬆理解。

DES (Data Encryption Standard)演算法是世界上最常用的加密演算法。在很長時間內，許多人心目中“密碼生成”與DES一直是個同義詞。儘管最近有個叫Electronic Frontier Foundation的組織造了臺價值22萬的機器嘗試破解DES加密的資料，DES和它的變種“三重資料加密演算法”仍將在政府和銀行中廣泛應用（譯註：本文年代久遠，在2001年AES成為了DES的替代品）。

DES是怎樣工作的？本文將通過一個簡單的例子來一步步展示DES的加密流程。自DES誕生以來，許多加密演算法（修改資料的方法）都採用了類似DES的手段。一旦理解了DES中的變換，你一定能夠更輕鬆地理解這些現代加密演算法中的門道。

但在此之前，不妨先了解一下DES的發展歷史。

國家標準局催生了DES

1973年5月，在尼克松任期，美國國家標準局下發了紅標頭檔案，徵求加密演算法來保護傳輸過程中的資料。國家標準局等了很久一直沒有人投標，一直到1974年8月6日，尼克松卸任前三天，IBM才拿出了自己家開發的一套代號LUCIFER（金星）的東西。美國安全域性評估後，在1977年7月15日採用了LUCIFER的一個變種作為資料加密標準DES。

DES很快被非數字媒體採用，比如電話線中的訊號加密。在那些年裡，國際香料組織IFF曾用DES來加密那些用電話線傳輸的祕密配方。（“With Data Encryption, Scents Are Safe at IFF,” Computerworld 14, No. 21, 95 (1980)）

同時，作為政府之後第二大急需加密的銀行業也將DES作為廣泛應用的標準，美國國家標準協會ANSI制定了整個銀行業的加密規範。1980年採用的ANSI X3.92指定了DES演算法的應用。

一些初步的DES例子

DES處理位元，或者說二進位制數字。我們知道，每四個位元構成一個十六進位制數。DES加密一組64位的資訊，也就是16個16進位制數。為了完成加密，DES同樣使用64位長的密碼。但是，祕鑰中每8位被忽略掉，這樣導致DES中有效的祕鑰長度為56位。但是，在任何情況下，每64位一個塊是DES永恆的組織方式。

比如，如果我們手上的明文是：

8787878787878787

選取了DES祕鑰：

0E329232EA6D0D73

我們就能得到密文：

0000000000000000

如果對上述密文使用相同的DES祕鑰

0E329232EA6D0D73

來解密的話，我們就能得到原來的明文

8787878787878787

這個例子簡單明瞭，因為我們的明文就是64位長的，明文當然也可以是多個64位那麼長。但大部分情況下，現實生活中的明文都不是64位（16個16進位制位）的整數倍。

比如，對於這段文字：

Your lips are smoother than vaseline

它是38位元組（76個16進位制位）長的。所以在DES加密前，這段文字必須在尾部補充一些額外的位元組。一旦密文被解密，這些多餘的位元組將被丟棄。當然，具體有多種補充的方法。在這裡，我們簡單地補充0在尾部，使得訊息是8位元組的整數倍。

這段純文字在16進位制下是：

596F7572206C6970 732061726520736D 6F6F746865722074 68616E2076617365 6C696E650D0A

注意這裡前72個十六進位制數字代表英文，但0D代表回車符，0A代表換行符，代表文字檔案的結束。然後我們在這段十六進位制碼的尾部新增一些0，使其恰好為80個十六進位制位：

596F7572206C6970 732061726520736D 6F6F746865722074 68616E2076617365 6C696E650D0A0000

如果我們使用相同的祕鑰：

0E329232EA6D0D73

加密這段資料，我們將得到如下密文：

C0999FDDE378D7ED 727DA00BCA5A84EE 47F269A4D6438190 9DD52F78F5358499 828AC9B453E0E653

這就是可供傳輸或儲存的祕密程式碼了。解密它就可以得到原文“Your lips are smoother than vaseline”。（設想一下如果克林頓的情婦加密過這些曖昧資料的話，克林頓該是有多慶幸。）

DES到底是如何工作的

DES是一個基於組塊的加密演算法，這意味著無論輸入還是輸出都是64位長度的。也就是說DES產生了一種最多2⁶⁴種的變換方法。每個64位的區塊被分為2個32位的部分，左半部分L和右半部分R。（這種分割只在特定的操作中進行。）

比如，取明文M為

M = 0123456789ABCDEF

這裡的M是16進位制的，將M寫成二進位制，我們得到一個64位的區塊：

M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
L = 0000 0001 0010 0011 0100 0101 0110 0111
R = 1000 1001 1010 1011 1100 1101 1110 1111

M的第一位是0，最後一位是1，我們從左讀到右。

DES使用56位的祕鑰操作這個64位的區塊。祕鑰實際上也是儲存為64位的，但每8位都沒有被用上（也就是第8, 16, 24, 32, 40, 48, 56, 和64位都沒有被用上）。但是，我們仍然在接下來的運算中將祕鑰標記為從1到64位的64個位元。不過，你也許會看到，剛剛提到的這8個在建立子祕鑰的時候會被忽略掉。

舉個例子，取十六進位制祕鑰K為

 K = 133457799BBCDFF1

我們可以得到它的二進位制形式（1為0001，3為0011.依次類推，並且將每八位寫成一組。這樣每組的最後一位都沒有被用上。）

K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

第一步：建立16個子祕鑰，每個長48位元

這個64位的祕鑰首先根據表格PC-1進行變換。

                            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

由於上表中第一個元素為57，這將使原祕鑰的第57位變換為新祕鑰K+的第1位。同理，原祕鑰的第49位變換為新祕鑰的第2位……原祕鑰的第4位變換為新祕鑰的最後一位。注意原祕鑰中只有56位會進入新祕鑰，上表也只有56個元素。

比如，對於原祕鑰：

K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

我們將得到56位的新祕鑰：

K+ = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111

然後，將這個祕鑰拆分為左右兩部分，C₀ 和 D₀，每半邊都有28位。

比如，對於新祕鑰，我們得到：

C0 = 1111000 0110011 0010101 0101111 
D0 = 0101010 1011001 1001111 0001111

對相同定義的C₀ 和 D₀，我們現在建立16個塊C_n 和 D_n, 1<=n<=16。每一對C_n 和 D_n都是由前一對C_n-1 和 D_n-1移位而來。具體說來，對於n = 1, 2, …, 16，在前一輪移位的結果上，使用下表進行一些次數的左移操作。什麼叫左移？左移指的是將除第一位外的所有位往左移一位，將第一位移動至最後一位。

                     Iteration     Number of
                      Number      Left Shifts
 
                          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

這意味著，比如說，C₃ and D₃是C₂ and D₂移位而來的，具體來說，通過2次左移位；C₁₆ and D₁₆ 則是由C₁₅ and D₁₅通過1次左移得到的。在所有情況下，一次左移就是將所有位元往左移動一位，使得移位後的位元的位置相較於變換前成為2, 3,…, 28, 1。

比如，對於原始子祕鑰C₀ and D₀，我們得到：

C0 = 1111000011001100101010101111
D0 = 0101010101100110011110001111
C1 = 1110000110011001010101011111
D1 = 1010101011001100111100011110
C2 = 1100001100110010101010111111
D2 = 0101010110011001111000111101
C3 = 0000110011001010101011111111
D3 = 0101011001100111100011110101
C4 = 0011001100101010101111111100
D4 = 0101100110011110001111010101
C5 = 1100110010101010111111110000
D5 = 0110011001111000111101010101
C6 = 0011001010101011111111000011
D6 = 1001100111100011110101010101
C7 = 1100101010101111111100001100
D7 = 0110011110001111010101010110
C8 = 0010101010111111110000110011
D8 = 1001111000111101010101011001
C9 = 0101010101111111100001100110
D9 = 0011110001111010101010110011
C10 = 0101010111111110000110011001
D10 = 1111000111101010101011001100
C11 = 0101011111111000011001100101
D11 = 1100011110101010101100110011
C12 = 0101111111100001100110010101
D12 = 0001111010101010110011001111
C13 = 0111111110000110011001010101
D13 = 0111101010101011001100111100
C14 = 1111111000011001100101010101
D14 = 1110101010101100110011110001
C15 = 1111100001100110010101010111
D15 = 1010101010110011001111000111
C16 = 1111000011001100101010101111
D16 = 0101010101100110011110001111

我們現在就可以得到第n輪的新祕鑰K_n（ 1<=n<=16）了。具體做法是，對每對拼合後的子祕鑰C_nD_n，按表PC-2執行變換：

                              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

每對子祕鑰有56位，但PC-2僅僅使用其中的48位。

於是，第n輪的新祕鑰K_n 的第1位來自組合子祕鑰C_nD_n的第14位，第2位來自第17位，依次類推，知道新祕鑰的第48位來自組合祕鑰的第32位。

比如，對於第1輪的組合祕鑰，我們有：

C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110

通過PC-2的變換後，得到：

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

同理，對於其他祕鑰得到：

K2 = 011110 011010 111011 011001 110110 111100 100111 100101
K3 = 010101 011111 110010 001010 010000 101100 111110 011001
K4 = 011100 101010 110111 010110 110110 110011 010100 011101
K5 = 011111 001110 110000 000111 111010 110101 001110 101000
K6 = 011000 111010 010100 111110 010100 000111 101100 101111
K7 = 111011 001000 010010 110111 111101 100001 100010 111100
K8 = 111101 111000 101000 111010 110000 010011 101111 111011
K9 = 111000 001101 101111 101011 111011 011110 011110 000001
K10 = 101100 011111 001101 000111 101110 100100 011001 001111
K11 = 001000 010101 111111 010011 110111 101101 001110 000110
K12 = 011101 010111 000111 110101 100101 000110 011111 101001
K13 = 100101 111100 010111 010001 111110 101011 101001 000001
K14 = 010111 110100 001110 110111 111100 101110 011100 111010
K15 = 101111 111001 000110 001101 001111 010011 111100 001010
K16 = 110010 110011 110110 001011 000011 100001 011111 110101

關於子祕鑰的話題就到此為止了，接下來我們看看資訊本身。

第二步：加密資料的每個64位區塊

對於明文資料M，我們計算一個初始變換IP（Initial permutation）。IP是重新變換資料M的每一位產生的。產生過程由下表決定，表格的下標對應新資料的下標，表格的數值x表示新資料的這一位來自舊資料的第x位。

                             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

參照上表，M的第58位成為IP的第1位，M的第50位成為IP的第2位，M的第7位成為IP的最後一位。

比如，對M的區塊執行初始變換，得到：

M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
IP = 1100 1100 0000 0000 1100 1100 1111 1111 1111 0000 1010 1010 1111 0000 1010 1010

這裡M的第58位是1，變成了IP的第1位。M的第50位是1，變成了IP的第2位。M的第7位是0，變成了IP的最後一位。

接著講變換IP分為32位的左半邊L₀ 和32位的右半邊R₀ 。

比如，對於上例，我們得到：

L0 = 1100 1100 0000 0000 1100 1100 1111 1111 
R0 = 1111 0000 1010 1010 1111 0000 1010 1010

我們接著執行16個迭代，對1<=n<=16，使用一個函式f。函式f輸入兩個區塊——一個32位的資料區塊和一個48位的祕鑰區塊K_n ——輸出一個32位的區塊。定義+表示異或XOR。那麼讓n從1迴圈到16，我們計算

L_n = R_n-1 

R_n = L_n-1 + f(R_n-1,K_n)

這樣我們就得到最終區塊，也就是n = 16 的 L₁₆R₁₆。這個過程說白了就是，我們拿前一個迭代的結果的右邊32位作為當前迭代的左邊32位。對於當前迭代的右邊32位，將它和上一個迭代的f函式的輸出執行XOR運算。

比如，對n = 1，我們有：

K1 = 000110 110000 001011 101111 111111 000111 000001 110010 
L1 = R0 = 1111 0000 1010 1010 1111 0000 1010 1010 
R1 = L0 + f(R0,K1)

剩下的就是f函式是如何工作的了。為了計算f，我們首先擴充每個R_n-1，將其從32位擴充到48位。這是通過使用一張表來重複R_n-1中的一些位來實現的。我們稱這個過程為函式E。也就是說函式E(R_n-1)輸入32位輸出48位。

定義E為函式E的輸出，將其寫成8組，每組6位。這些位元是通過選擇輸入的某些位來產生的，具體選擇順序按下表實現：

                    E BIT-SELECTION TABLE
 
                 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

也就是說E(R_n-1) 開頭的三個位元分別來自R_n-1的第32、1和2位。E(R_n-1) 末尾的2個位元分別來自R_n-1的第32位和第1位。

比如，給定R₀ ，我們可以計算出E(R₀) ：

R0 = 1111 0000 1010 1010 1111 0000 1010 1010 
E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

（注意輸入的每4位一個分組被擴充為輸出的每6位一個分組。）

接著在f函式中，我們對輸出E(R_n-1) 和祕鑰K_n執行XOR運算：

K_n + E(R_n-1)

比如，對K₁ , E(R₀)，我們有：

K1 = 000110 110000 001011 101111 111111 000111 000001 110010 
E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101 
K1+E(R0) = 011000 010001 011110 111010 100001 100110 010100 100111.

到這裡我們還沒有完成f函式的運算，我們僅僅使用一張表將R_n-1 從32位擴充為48位，並且對這個結果和祕鑰K_n執行了異或運算。我們現在有了48位的結果，或者說8組6位元資料。我們現在要對每組的6位元執行一些奇怪的操作：我們將它作為一張被稱為“S盒”的表格的地址。每組6位元都將給我們一個位於不同S盒中的地址。在那個地址裡存放著一個4位元的數字。這個4位元的數字將會替換掉原來的6個位元。最終結果就是，8組6位元的資料被轉換為8組4位元（一共32位）的資料。

將上一步的48位的結果寫成如下形式：

K_n + E(R_n-1) =B₁B₂B₃B₄B₅B₆B₇B₈,

每個B_i 都是一個6位元的分組，我們現在計算

S₁(B₁)S₂(B₂)S₃(B₃)S₄(B₄)S₅(B₅)S₆(B₆)S₇(B₇)S₈(B₈)

其中，S_i(B_i) 指的是第i個S盒的輸出。

為了計算每個S函式S1, S2,…, S8，取一個6位的區塊作為輸入，輸出一個4位的區塊。決定S₁的表格如下：

                             S1
 
                        Column Number
Row
No.    0  1   2  3   4  5   6  7   8  9  10 11  12 13  14 15
 
  0   14  4  13  1   2 15  11  8   3 10   6 12   5  9   0  7
  1    0 15   7  4  14  2  13  1  10  6  12 11   9  5   3  8
  2    4  1  14  8  13  6   2 11  15 12   9  7   3 10   5  0
  3   15 12   8  2   4  9   1  7   5 11   3 14  10  0   6 13

如果S₁ 是定義在這張表上的函式，B是一個6位的塊，那麼計算S₁(B) 的方法是：B的第一位和最後一位組合起來的二進位制數決定一個介於0和3之間的十進位制數（或者二進位制00到11之間）。設這個數為i。B的中間4位二進位制數代表一個介於0到15之間的十進位制數（二進位制0000到1111）。設這個數為j。查表找到第i行第j列的那個數，這是一個介於0和15之間的數，並且它是能由一個唯一的4位區塊表示的。這個區塊就是函式S₁ 輸入B得到的輸出S₁(B)。比如，對輸入B = 011011 ，第一位是0，最後一位是1，決定了行號是01，也就是十進位制的1 。中間4位是1101，也就是十進位制的13，所以列號是13。查表第1行第13列我們得到數字5。這決定了輸出；5是二進位制0101，所以輸出就是0101。也即S₁(011011) = 0101。

同理，定義這8個函式S₁,…,S₈的表格如下所示：

                                  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

例子：對於第一輪，我們得到這8個S盒的輸出：

K₁ + E(R₀) = 011000 010001 011110 111010 100001 100110 010100 100111.

S₁(B₁)S₂(B₂)S₃(B₃)S₄(B₄)S₅(B₅)S₆(B₆)S₇(B₇)S₈(B₈) = 0101 1100 1000 0010 1011 0101 1001 0111

函式f的最後一步就是對S盒的輸出進行一個變換來產生最終值：

f = P(S₁(B₁)S₂(B₂)…S₈(B₈))

變換P由如下表格定義。P輸入32位資料，通過下標產生32位輸出：

                                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

比如，對於8個S盒的輸出：

S₁(B₁)S₂(B₂)S₃(B₃)S₄(B₄)S₅(B₅)S₆(B₆)S₇(B₇)S₈(B₈) = 0101 1100 1000 0010 1011 0101 1001 0111

我們得到

f = 0010 0011 0100 1010 1010 1001 1011 1011

那麼，

R₁ = L₀ + f(R₀ , K₁ )

= 1100 1100 0000 0000 1100 1100 1111 1111 
+ 0010 0011 0100 1010 1010 1001 1011 1011 
= 1110 1111 0100 1010 0110 0101 0100 0100

在下一輪迭代中，我們的L₂ = R₁，這就是我們剛剛計算的結果。之後我們必須計算R₂ =L₁ + f(R₁, K₂)，一直完成16個迭代。在第16個迭代之後，我們有了區塊L₁₆ and R₁₆。接著我們逆轉兩個區塊的順序得到一個64位的區塊：

R₁₆L₁₆

然後對其執行一個最終的變換 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

也就是說，該變換的的輸出的第1位是輸入的第40位，第2位是輸入的第8位，一直到將輸入的第25位作為輸出的最後一位。

比如，如果我們使用了上述方法得到了第16輪的左右兩個區塊：

L16 = 0100 0011 0100 0010 0011 0010 0011 0100 
R16 = 0000 1010 0100 1100 1101 1001 1001 0101

我們將這兩個區塊調換位置，然後執行最終變換：

R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100
IP-1 = 10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101

寫成16進製得到：

85E813540F0AB405

這就是明文M = 0123456789ABCDEF的加密形式C = 85E813540F0AB405。

解密就是加密的反過程，執行上述步驟，只不過在那16輪迭代中，調轉左右子祕鑰的位置而已。

Reference

The DES Algorithm Illustrated.pdf