密码学—DES加密算法_e盒扩展密码学

DES流程

因为DES是对比特流进行加密的，所以信息在加密之前先转为二进制比特流

• 1：生成16把密钥

  • 只取给出的密钥比特流中64位，不够64则补0
  • 对64位进行PC1表置换，64位进，56位出（PC1表是固定的）
  • 将56位拆分开L，R左右各28位
  • L中比特左移16次（每次左移的大小也是固定的）
  • R中比特左移16次（每次左移步数同上）
  • 两边都分别左移一次完成后进行组合L+R成为56位
  • 将56位进行PC2表置换，56位进48位出（PC2表是固定的）
  • 因为左移一次就生成一把钥匙，那么左移16次就是16把
  • 16把密钥生成完毕，没把密钥48位比特

• 2：明文信息每64位比特为一组数据，分好组

• 3：进入加密先进行一步IP置换，64位进，64位出（IP表是固定的）

• 4：分开两份，L和R左右两份，每一份32个比特

• 5：进行十六轮的操作

  • 右边的R直接放到左边成为下一轮的L
  • R进入F函数
  • F函数（32位进，32位出）
    • 对32个比特进行 E盒扩展，32位进，48位出
      （48位应该要本能的敏感一下了，因为密钥就是48位）
    • 所以这一步：用48位数据与密钥进行 异或 操作
      （每一位数据与每一位密钥进行异或，这里的哪一轮加密就对应着哪一把钥匙，第一轮就是第一把以此类推）
    • 将48位按照每6位为一组，一共分成8组
    • 将每一组对应 S盒中替换第一个十进制数字出来
      （有8个S盒，所以每一组对应一个盒子，盒子也是固定的，替换方法后面会介绍）
    • 每一组替换出来一个十进制数字就将其转化为四位二进制数，8个盒子出8个数字，每个数字转4位二进制，所以出来就是4×8=32位。48位进，32位出
      （一定要四位，不够四位就往前补0，比如1，那补0之后就是0001）
    • 最后一步：将32位进行 P盒置换，32位进，32位出。
      （这里的P盒只是做了一次置换，没有将数据进行压缩也没有扩散）
    • F函数结束，返回一个32位比特数据

• L左边的32位数据与F函数返回的32位数据进行异或
  （这里的异或与F函数里面进行异或一样，一位对一位的进行异或）

• 如此进行15轮

• 进行到16轮的时候，将右边数据复制到右边位置，左边位置需要进行L与F函数的异或，F函数照样使用R来进行。

• 加密完成

DES细节

生成密钥

在生成密钥的时候我认为采用了一个很好的点子就是他使用的不是原生给出的密钥，而是使用原生密钥生成的，两次置换打乱了密钥，由于DES加密需要16把钥匙，因此他采用了同一份数据但是进行16轮左移很成功的动态生成16把钥匙，十分佩服了。还有一个很绝的做法就是使用64位但是取56，一开始我认为这不是多此一举吗？但是看到PC1表之后我就震惊了，因为PC1表是在64位数字中找的，所以64位原生密钥在PC1表中得到了很好的进行了乱序操作。密钥生成的最后一步是PC2，所实话这确实不太懂了，可能是大佬通过某些算法算出来的这个表是最佳的吧（虽然我心里很不舒服，毕竟换谁不都得来一句：凭啥要用你这个表？！）
下面给出各个表的固定数据，我是一点门道都看不出。。。

• PC1表

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

• 左移步数

  step = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
  1

• PC2表

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

DES加密

再重温一百年过程
IP初始置换
↓
将64位拆成两份，L、R。分别占32位
↓
进入F函数
↓
F函数的E盒扩展（数据扩散）
↓
F函数：密钥异或加密
↓
F函数：查找S盒替换
↓
F函数：P盒置换
↓
结束F函数
↓
F函数返回的32位数据与L左边的32位进行异或，设结果为result
↓
原本的R直接放到左边变成新的L，result放到右边变成新的R
↓
重复16轮
↓
第16轮的时候记得把result放到左边，原本的R放到右边

• IP置换表

  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
      ]  # ip置换表
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

E盒扩展

• F函数中的E盒扩展规则（图片出自我的密码学老师的PPT）
  

S盒替换

• F函数中的S盒（8组，每个盒子对应6位一组的数据）
  • S盒中需要48位分成6位一组的数据，每一组替换出一个数字，将数字转为四位二进制
  • X₁ X₂X₃X₄X₅ X₆ ,中间黄色部分的四位转成十进制后作为S盒查找的 列，然后第一位和最后一位 X₁X₅ 合起来转化为十进制数后作为S盒查找的 行，查找S盒的是哪一个盒子具体看的是你这8组分好的，每组6bit的数据是哪一列中，在哪一列就去找哪一个盒子，然后在那个盒子中替换你每一份6位bit数字。（因为你到这一步的时候就是48bit，已经经过E盒和加密了，现在就是使用你这8组，每组6bit的二进制数来到这里对应的S盒进行替换）

S_Box = [
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ],
    [
        [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]
    ]
]

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
48
49
50
51

P盒置换

• 这里只是将最后出来的32位进行置换一下，然后F函数结束，接着就是和L进行异或了。

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

一开始我觉得这DES也太难了，但是将其算法都实现一遍之后发现还可以接受的范围，但是由于步骤实在是太多了，而且有一些属于是你不这样做就不行，让人感到十分不舒服，毕竟我也搞不懂到底为啥要用这个表为啥要用这个方法。
整体下来我的感受就是：阿美你在教我做事？
第一次感受到是真正的打开了密码学的大门，因为DES强制要求怎么做的时候就感受到密码学这玩意似乎是块难啃的骨头，因为真的是密码的东西一堆数字，天数一样看不出一点规律，但是好在他是叫密码，看不懂才让我觉得他比较安全。
收获：对于二进制以及对于加密算法有了一定的了解。确实思维得到训练了，比如有个方法就是记录下标的方式去解决掉如何将其原本的单独的字符转为二进制之后进行区分不同字符，因为加密的时候是一连串的二进制，还是固定位数进出的，难免原本的字符对应的二进制数字会四分五裂，所以我绞尽脑汁也就想到了这方法，当然我相信不止我这种方法，还有很多，希望以后能想到然后回来优化。