DES加密算法介绍（含例子）

野性酷女 2023-06-05 08:47 1阅读 0赞

http://www.hankcs.com/security/des-algorithm-illustrated.html

DES（Data Encryption Standard）算法是世界上最常用的加密算法。在很长时间内，许多人心目中“密码生成”与DES一直是个同义词。

DES是怎么工作的？本文通过一个简单的例子来一部一部展示DES的加密流程。自动DES诞生以来，许多加密算法都采用了类似DES的手段。一旦理解了DES中的变换，你一定能够更轻松的理解这些现代加密算法中的门道。

DES处理比特，或者说二进制数字，我们知道，没四个比特构成一个十六进制数。DES加密一组64位的信息，也就是16个16进制数。为了完成加密，DES

DES秘钥获取：

我们取16进制秘钥K为：

K = 133457799BBCDFF1

我们可以得到他的二进制形式（1为0001,3为0011，依次类推，并且将没8位写成一组。这样每组的最后一位都没有被用上。）

K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

创建16个子秘钥，每个长48比特

这个64位的秘钥首先根据表格PC-1进行变换。

表PC-1

由于上表中第一个元素为57，这将使元秘钥的第57位变换为新秘钥K+的第一位。同理，元秘钥的第49位变换为新秘钥的第2位，，，元秘钥的第4位变换为新秘钥的最后一位，注意元秘钥中只有56位会进入新秘钥，上表也只有56个元素。

比如，对于原秘钥：

K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

我们将得到56位新秘钥：

K+ = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111

然后，我们将这个密钥拆分为左右两个部分，C0和D0，每半边都有28位。

比如，对于新密钥，我们得到：

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

对于相同定义的C0和D0，我们现在创建16个块Cn和Dn 1<=n<=16.

每一对Cn和Dn都是由前一对Cn-1和Dn-1移位而来。具体来说，对于n=1,2,3，。。。，16，在前一轮移位的结果上，进行左移操作。什么叫左移？左移指的是将除第一位外的所有为往左移一位，将第一位移动至最后一位。

这意味着，比如说，C3和D3是C2和D2移位而来的，具体来说，通过2次左移位，C16和D16则是由C15和D15通过1次左移得到的。在所有情况下，一次左移就是将所有比特往左移动一位。使的一位后的比特的位置相较于变换前成为2,3,4，，，28,1.

比如，对于原始字谜要C0和D0，我们得到：

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

我们现在就可以得到第n轮的新秘钥Kn（1<=n<=16）了。具体做法是，对每一对拼合后的子秘钥CnDn，按照表PC-2执行变换：

每对子秘钥有56位，但是PC-2仅仅使用其中48位。

于是，第你轮新秘钥Kn的第一位来自组合秘钥CnDn的第14位，第2位来自第17位，以此类推，知道新秘钥的第48位来自组合秘钥的第32位。

比如：

对于第一轮的组合秘钥，我们有：

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

关于子秘钥的话题我们就到此为止，接下来我们看信息本身。

DES是一个基于组块的加密算法，这意味着无论输入还是输出都是64位长度。也就是说DES产生了一种最多264中的变换方法。每个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，我们从左读到右。

对于明文M，我们计算一下初始变换IP（Initial permutation）。IP是重新变换数据M的每一位产生的。产生过程由下表决定，表格的下标对应新数据的下标，表格的数值x表示新数据的这一位来自旧数据的第x位。

比如，对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

接着讲变换IP分为32位的左半边L0和右半边R0

比如，对于上例，我们得到：

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位的木曜区块Kn，输出一个32位的区块。定义+表示异或XOR。那么让n从1循环到16，我们计算：

Ln=Rn-1

Rn=Ln-1+f(Rn-1,Kn)

这样我们就得到最终区块，也就是n=16的L16R16.这个过程说白了就是，我们那前一个迭代结果的右边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，我们首先扩展每个Rn-1，将其从32位扩展到48位，这是通过使用一张表来重复Rn-1中的一位位来实现的。我们称这个过程为函数E。也就是说函数E（Rn-1）输入32位输出48位。

定义E为函数E的输出，将其写成8组，每组6位，这些比特是通过选择输入的某些位来产的，具体选择顺序按照如下表格实现：

<table>  E BIT-SELECTION TABLE  
 <tbody> 
  <tr> 
   <td>32</td> 
   <td>1</td> 
   <td>2</td> 
   <td>3</td> 
   <td>4</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>5</td> 
   <td>6</td> 
   <td>7</td> 
   <td>8</td> 
   <td>9</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>9</td> 
   <td>10</td> 
   <td>11</td> 
   <td>12</td> 
   <td>13</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>13</td> 
   <td>14</td> 
   <td>15</td> 
   <td>16</td> 
   <td>17</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>17</td> 
   <td>18</td> 
   <td>19</td> 
   <td>20</td> 
   <td>21</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td>21</td> 
   <td>22</td> 
   <td>23</td> 
   <td>24</td> 
   <td>25</td> 
  </tr> 
  <tr> 
   <td>24</td> 
   <td>25</td> 
   <td>26</td> 
   <td>27</td> 
   <td>28</td> 
   <td>29</td> 
  </tr> 
  <tr> 
   <td>28</td> 
   <td>29</td> 
   <td>30</td> 
   <td>31</td> 
   <td>32</td> 
   <td>1</td> 
  </tr> 
 </tbody> 
</table>

也就是说E(Rn-1)开头的三个比特分别来自Rn-1的第32、1和2位。E(Rn-1)末尾的2个比特分别来自Rn-1的第32位和第1位。

比如：给定R0，我们可以计算出E(R0)：

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

接着在f函数中，我们对输出E（Rn-1）和秘钥Kn执行XOR运算：

Kn+E(Rn-1)

比如，对K1，E(R0)，我们有：

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函数的运算，我们仅仅使用一张表将Rn-1从32位扩展为48位，并且对这个结果和秘钥Kn执行了异或运算。我们现在有了48位的结果，或者说8组6比特数据。我们现在要对每组的6比特执行一些奇怪的操作：

我们将它作为一张被称为“S盒”的表格的地址。每组6比特都将给我们一个位于不同S盒中的地址。在哪个地址里存放着一个4比特的数字。这个4比特的数字将会替换掉原来的6个比特。最终结果就是，8组6比特的数据被转换为8组4比特（一共32位）的数据。

将上一步的48位的结果写成如下形式：

Kn+E(Rn-1)=B1B2B3B4B5B6B7B8

每个Bi都是一个6比特的分组，我们现在计算

S1（B1）S2（B2）S3（B3）S4（B4）S5（B5）S6（B6）S7（B7）S8（B8）

其中，Si（Bi）指的是第i个S盒的输出。

为了计算每个S函数S1，S2，，，S8，取一个6位的区块作为输入，输出一个4位的区块。决定S1的表格如下：

S1Column Number

如果S1是定义在这张表上的函数，B是一个6位的块，那么计算S1（B）的方法是：B的第一位和最后一位组合起来，的二进制数决定一个介于0和3之间的十进制数（或者二进制00到11之间）。设这个数为i，B的中间4位二进制数代表一个介于0到15之间的二进制数（二进制0000到1111）。设这个数为j。查表找到第i行第j列的那个数，这个是一个介于0和15之间的数，并且它是能由一个唯一的4位区块表示的。这个区块就是函数S1输入B得到的输出S1（B）。比如，对输入B=011011，第一位是0，最后一位是1，决定了行号是01，也就是十进制的1，中间4位是1101，也就是十进制的13，虽有列号是13.查表第一行第13列我们得到数字5.

这就决定了输出；5的二进制是0101，所以输出就是0101，即S1（011011）=0101。

同理，定义这8个函数S1，S2，，，S8：

例子：对弈第一轮，我们得到这8个S盒的输出：

K1+E(R0)=011000 010001 011110 111010 100001 100110 010100 100111

S1（B1）S2（B2）S3（B3）S4（B4）S5（B5）S6（B6）S7（B7）S8（B8）=0101 1100 1000 0010 1011 0101 1001 0111

函数f的最后一步就是对S盒的输出进行一个变换来产生最终值：

f=P（S1（B1）S2（B2）S3（B3）S4（B4）S5（B5）S6（B6）S7（B7）S8（B8））

变换P由如下表格定义。P输入32位数据，通过下表产生32位输出：

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盒的输出：

S1（B1）S2（B2）S3（B3）S4（B4）S5（B5）S6（B6）S7（B7）S8（B8）=0101 1100 1000 0010 1011 0101 1001 0111

我们得到：

f=0010 0011 0100 1010 1010 1001 1011 1011

那么R1=L0+f（R0，K1）

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

在下一轮迭代中，我们的L2=R1，这就是我们刚刚计算的结果。之后，我们必须计算R2=L1+f(R1,K2),一直完成16个迭代之后，我们有了区块L16和R16,。接着我们逆转两个区块的顺序得到一个64位的区块：

R16L16

然后，我们对其执行一个最终的IP\-1，其定义如下：

也就是说，该变换的输出的第一位是输入的第40位，第二位是输入的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的密文：85E813540F0AB405

解密就是加密的反过程，执行上述步骤，只不过在那16轮迭代中，调转左右子秘钥的位置而已。

转载于:https://www.cnblogs.com/LoganChen/p/11432092.html