DES算法

发表于 更新于 分类于

介绍

DES算法属于对称加密算法中的分组加密算法。

分组密码

分组密码是将明文信息编码表示后的数字序列，划分成长度相等的组，每组分别在秘钥的控制下变换成等长的数组数字序列。

流密码

流密码是明文和密钥长度一致，一一进行异或运算，可以得出密文。

DES加密流程分析

DES加密步骤稍有复杂。

明文处理

首先我们的明文数据也是要进行填充和分组操作的。DES算法分组的大小是64位，如果明文不足64位，需要填充0直到长度达到64位；如果超过64位，则使用分组模式进行分组加密。

IP置换（初始置换）

这里有一个初始置换表

1
2
3
4
5
6
7
8
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

明文长度是64位的，这个表里有64份数据，将这个表中的数据作为索引进行置换，得到一份新的数据。将这份新数据分为左右两部分各32位，记为L0和R0。

轮函数

  • L1的生成
    L1直接由R0赋值所得，即L1=R0。
  • R1的生成
    R1的生成就较为复杂了。

E扩展置换

32位的R0和48位的密钥K作为参数传递给轮函数F。（这里的密钥K是经过计算生成的，过程在后面附加）。
第一步要做的就是把32位的R0扩展为48位。
这个过程可以用E扩展置换表来理解：

1
2
3
4
5
6
7
8
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

中间四列是原始的32位数据，把它分为了8组，每份4组数据，每组数据的前后各添加一位数据，这两位数据分别是上一组数据的最后一位和下一组数据的第一位。由此得到48位的数据。这样就扩展完成了。

S盒压缩处理

扩展后的48位数据和密钥K进行异或，得到48位的结果作为S盒的输入。

  • S盒 
    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
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    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  2  15  12  9  7  3  13  8  10  6  5  11  0  14
    1  14  8  13  6  2  11  15  12  9  7  3  10  5  0  4
    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
    4  1  2  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
    S4:

    7  13  10  1  3  12  14  8  11  5  0  6  9  4  2  15
    2  1  14  7  4  11  8  13  6  15  3  0  9  10  5  12
    15  12  8  2  4  9  1  7  5  11  3  14  10  0  6  13
    6  11  13  0  8  5  10  3  4  7  15  14  1  2  12  9
    S5:

    10  13  0  7  9  14  6  3  1  2  15  8  5  11  12  4
    13  7  0  9  3  4  6  10  1  2  8  5  11  14  15  12
    1  14  8  13  6  2  11  15  12  9  7  3  10  5  0  4
    11  12  14  1  2  13  4  5  3  8  6  15  9  0  10  7
    S6:

    2  8  11  6  15  12  1  13  3  10  4  9  5  0  14  7
    1  2  4  3  10  13  7  8  5  15  6  9  11  14  0  12
    7  13  10  4  8  5  15  9  6  1  2  14  0  3  11  12
    6  11  13  8  1  4  10  7  9  5  0  15  14  2  3  12
    S7:

    13  2  14  4  1  7  15  11  10  3  6  9  12  0  8  5
    4  1  2  11  10  13  7  8  15  9  12  5  3  0  14  6
    1  14  7  11  4  2  13  1  5  0  15  6  8  9  10  3
    2  12  4  1  7  10  11  13  15  9  3  5  0  14  8  6
    S8:

    14  11  2  12  4  15  1  7  8  13  6  5  10  9  3  0
    3  12  6  7  14  11  13  5  0  1  15  4  8  9  10  2
    6  11  13  8  1  4  10  7  9  5  0  15  14  2  3  12
    13  7  0  9  3  4  6  10  2  8  5  14  12  11  15  1
    将48位输入等分为8块，每块6位输入压缩为4位输出。

每个S盒都包含4行和16列，共有64个数据。

将原始六位数据的头尾数据结合在一起为行数，中间数据结合在一起为列数。

根据索引在S盒中找到对应的4位二进制数，就是S盒的输出。

最后能得到32位的数据。

轮函数P盒置换


S和的输出作为P盒的输出，得到32位的结果，这个结果就是F轮函数的结果。
这个结果与L0进行异或，所得结果赋值给R1。

逆置换

经过一次轮函数计算得到了L1和R1。加下来以同样的方式计算得到R1R16，L1L16，一共经过16次轮函数的计算。
最终得到L16和R16。
把L16和R16拼接在一起，经过逆置换的置换，得到最终的DES算法加密的结果。
逆置换表：

子密钥K的生成

首先是长度为64位的主密钥，经过PC-1表置换，去除校验位，得到56位的数据。
PC-1置换表

取前28位数据记为C0，后28位数据记为D0。

移位

接下来对C0和D0进行循环左移操作
移位表

C1和D1是由C0和D0左移一位得到的，C2和D2是由C1和D1左移一位得到的。
由此得到C1-C16，D1-D16。
把C1和D1拼接在一起，C2和D2拼接在一起…C16和D16拼接在一起。
经过PC-2表的置换，得到K1~K16，十六个48位的子密钥。这里的子密钥就是在F轮函数中S盒压缩使用的子密钥K。
PC-2置换表