【DES加密】

发布于：2025-02-10 ⋅ 阅读:(67) ⋅ 点赞:(0)

什么是DES

DES(Data Encryption Standard) 是一种对称加密算法。它的设计目标是提供高度的数据安全性和性能。

DES的概念

DES使用56位的密钥和64位的明文块进行加密。DES算法的分组大小是64位，因此，如果需要加密的明文长度不足64位，需要进行填充；如果明文长度超过64位，则需要使用分组模式进行分组加密。

DES的加密流程

在这里插入图片描述

  1. 初始置换(Initial Permulation,IP置换)：
    将64位明块进行重新排列，生成新的64未明文块。

  2. 16轮次加密：
    DES加密算法共有16个轮次，每个轮次都包含以下六个步骤：
    a. 将64位数据块分为左右两个32位块。
    b. 右侧32位作为输入，扩展到48位，然后与轮密钥进行 ⊕ \oplus ⊕运算，再经过S盒置换压缩 得到32位的数据块。
    c. P盒置换，输出32位数据块。
    d. c步骤的输出与左侧的32位数据块进行 ⊕ \oplus ⊕，得到本轮次的右边32位数据块的输出。
    e. a步骤得到的右侧32位数据块作为本轮次的左侧数据块输出。
    f. 拼接e，d的输出得到本轮次的加密输出。

  3. 末置换（Final Permutation）:
    在最后一个轮次完成后，将经过加密的数据块进行置换，得到最终的64位密文。

    总的来说，DES加密的过程就是通过一系列置换、异或、扩展等运算，将明文分成若干个小块，然后根据主密钥生成一系列的轮密钥，利用轮密钥对每个小块进行加密，最终将加密结果重新组合成一个整体，得到密文。

DES算法加密步骤详解

  1. 初始置换
    IP置换是将输入的64位明文块进行置换和重新排列，生成新的64位数据块。我们将把64位的顺序按下表中规定的顺序放置，图中的数字是在64位明文中每个比特的索引位置。

    I II III IV V VI VII VIII
    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

    目的:增加加密的混乱程度，使明文中的每一位都能够对后面的加密过程产生影响，提高加密强度。

  2. 加密轮次

    初始置换完成后，明文被划分成了相同长度（32位）的左右两部分，记作L0,R0。接下来就会进行16个轮次的加密了。

    以第一轮次的加密为例，过程如下：
    在这里插入图片描述
    从上图可以看出：右边的部分的R0会作为下一轮次的左半部分L1的输入。R0先补位到48位和本轮次的密钥K1进行 ⊕ \oplus ⊕，之后经过S盒置换得到32位的数据块，再经过P和置换，最后与L0进行 ⊕ \oplus ⊕，得到的结果作为下一轮的R1。上面的过程可以使用以下公式表示：

    R i = ( 48 R i − 1 ⊕ K i ) ⊕ L i − 1 L i = R i − 1 \begin{aligned} R_i&=(_{48}R_{i-1} \oplus K_{i})\oplus L_{i-1}\\ L_i&=R_{i-1} \end{aligned} Ri​Li​​=(48​Ri−1​⊕Ki​)⊕Li−1​=Ri−1​​

    详细步骤如下：

    1. 扩展R到48位
      将32位的R0通过以下表格中的规则扩展到48位。

      I II III IV V VI
      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

    2. 生成子密钥
      DES算法采用了每轮子密钥生成的方式来增加密钥的复杂性和安全性。每轮子密钥都是由主密钥（64位）通过密钥调度算法（Key Schedule Algorithm）生成的。DES算法的密钥调度算法可以将64位的主密钥分成16个子密钥，每个子密钥48位，用于每轮加密中与输入数据进行异或运算。
      通过子密钥生成的流程图来看下整个过程。

      在这里插入图片描述
      a. 将64位的主密钥通过PC-1置换表进行置换，得到56位的数据块。
      b. 将56位的数据块分成两个28位的数据块，分别为C0和D0。
      c. 将C0和D0分别左移1位或2位，得到C1和D1。
      d. 将C1和D1合并成56位的数据块，通过PC-2置换表进行置换，得到48位的子密钥K1。
      e. 重复c和d步骤，得到16个子密钥。
      注意:

      • PC-1置换表如下：

        I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI
        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 1 2 3 4 5 6 7 8

      • PC-2置换表如下：

        I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI
        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

      • 左移位数表如下：

        I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI
        1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1

    3. 当前轮次的密钥与扩展后的R进行异或运算
      将扩展后的R0与当前轮次的密钥Ki进行异或运算，得到48位的数据块。

    4. S盒置换(Substitution Box Substitution)
      将上一步得到的48位数据块分成8个6位的数据块，每个6位数据块作为S盒的输入，经过S盒置换后，得到4位的数据块。
      S盒是一个4行16列的表，每个S盒都有一个特定的输入和输出。S盒的输入是6位的数据块，输出是4位的数据块。S盒的作用是将输入的6位数据块映射到4位的数据块，从而实现数据的压缩。
      举个例子：输入100011，第一位和最后一位组成一个二进制数1001，即9，作为S盒的行数；中间的4位组成一个二进制数0001，即1，作为S盒的列数。在S盒中找到第9行第1列的元素，即为14，转换为二进制为1110，即为S盒的输出。
      注意: S盒子的行列号是从0开始的。

      S盒的具体内容如下：

      I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI
      S盒1：
      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
      S盒2：
      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
      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
      S盒3：
      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
      S盒4：
      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
      S盒5：
      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
      S盒6：
      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
      S盒7：
      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
      S盒8：
      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

    5. P盒替换
      将上一步得到的32位数据块通过P盒子进行置换，得到32位的数据块。
      P盒子置换表如下：

      I II III IV V VI VII VIII
      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

  3. 逆置换（Inverse Permutation）
    在经过16轮次计算后，DES会对最后的结果进行最后一次置换。即为最后的输出结果。置换表如下：

    I II III IV V VI VII VIII
    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

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布