特点:
1.DES 是对称性加密算法, 即加密和解密是对称的, 用的是同一个密钥
2.DES 只处理二进制数据, 所以需要将明文转换成为 2 进制数据
3.DES 每次处理 64 位的数据, 所以应该将明文切割成 64 位的分组, 当最后一组数据不足 64 位的时候, 高位补 0
4.DES 使用 64 位的密钥, 但因为密钥中的每 8 位会被忽略, 所以有效的密钥长度是 56 位, 从而产生 16 个 48 位的子密钥 (变换过程后面会说明)
5. 每 64 位数据一个块, 是 DES 的永恒组织方式
具体样例分析:
(仅以一组 64 位数据为例分析加密过程)
明文 M 是: 8787878787878787
密钥 K 是: 0E329232EA6D0D73
上面的信息都是 16 进制的, 转换为 2 进制
明文 M 是: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
密钥 K 是: 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
第一步: 根据密钥生成 16 个子密钥
1. 根据密钥初始置换表将 64 位的密钥转化为 58 位的密钥
- 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
新密钥 K:1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111
2. 将新密钥拆分成 C0 和 D0, 每组都有 28 位
比如新密钥
- C0:1111000 0110011 0010101 0101111
- D0:0101010 1011001 1001111 0001111
3. 根据密钥轮次左移表, 左移特定的位数
- 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
- 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
比如第一轮是左移 1 位, 第二轮也是左移 1 位, 第三轮是左移两位
所以
- C1:1110000110011001010101011111
- D1:1010101011001100111100011110
下面给出 C1,D1 到 C16,D16 的数据:
- 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
需要记住的是: 每一对 Cn 和 Dn 都是由前一对 Cn-1 和 Dn-1 移位而来!
4. 得到 Cn,Dn 后合并 CnDn, 然后根据密钥压缩置换表将 56 位密钥压缩成 48 位的子密钥
密钥压缩置换表:
- 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 轮的新秘钥 Kn 的第 1 位来自组合子秘钥 CnDn 的第 14 位, 第 2 位来自第 17 位, 依次类推, 知道新秘钥的第 48 位来自组合秘钥的第 32 位.
下面给出子密钥 K1 到 K16 的数据:
- 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
到这里, 16 个 48 位的子密钥就生成了
第二步: 加密数据块
1. 明文初始变换, 仍然是 64 位变为 64 位
- 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: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 的最后一位.
2. 数据分组: IP 分为左半边的 L0 和右半边的 R0
对上面的 IP
- L0:1100 1100 0000 0000 1100 1100 1111 1111
- R0:1111 0000 1010 1010 1111 0000 1010 1010
3.16 轮迭代
然后我们定义一个函数 f, 输入一个 32 位的数据和一个 48 位的子密钥, 产生一个 32 位的输出
从 n=1 到 n=16
- Ln=Rn-1
- Rn=Ln-1^f(Rn-1,Kn)
通俗的说就是当前迭代的 L 是上一次迭代的 L, 当前迭代的 R 是上一次迭代的 L 异或 f(上次迭代的 R, 当前子密钥)
下面就是要了解 f 函数是怎么工作的了
f 函数第一步: 32 位的数据扩展成为 48 位
明文扩展表:
- 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
对 R0:1111 0000 1010 1010 1111 0000 1010 1010
扩展一下: E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101
f 函数第二步: 将扩展的结果和 48 位的子密钥进行异或运算
比如, 对 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 函数第三步: S 盒替代, 48 位变成 32 位
一共有 8 个 S 盒, 分别位 S1 到 S8, 所以 48 位的数据可以分为 8 组, 每组 6 个数据, 用 a1a2a3a4a5a6 表示
每组数据对应一个 S 盒
a1 和 a6 组合成 2 进制, 然后转换为 10 进制, 代表对应 S 盒的行号
a2,a3,a4,a5 组合成 2 进制, 然后转换为 10 进制, 代表对应 S 盒的列号
从行号和列号可以从对应的 S 盒中确定一个数 X,X 是十进制的, 转化为 4 位的二进制输出
所以每个 S 盒都是输入 6 位, 输出 4 位, 所以最后输出的数据是 4*8=32 位
- 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 盒的输出:
- 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 函数第四步: 进行 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 盒的输出:
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
f 函数到此结束
那么, 得到当前迭代的 R
- 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 个迭代. 在第 16 个迭代之后, 我们有了区块 L16 and R16.
下面给出 L1,R1 到 L16,R16 的数据:
- L[1]:11110000101010101111000010101010
- R[1]:11101111010010100110010101000100
- L[2]:11101111010010100110010101000100
- R[2]:11001100000000010111011100001001
- L[3]:11001100000000010111011100001001
- R[3]:10100010010111000000101111110100
- L[4]:10100010010111000000101111110100
- R[4]:01110111001000100000000001000101
- L[5]:01110111001000100000000001000101
- R[5]:10001010010011111010011000110111
- L[6]:10001010010011111010011000110111
- R[6]:11101001011001111100110101101001
- L[7]:11101001011001111100110101101001
- R[7]:00000110010010101011101000010000
- L[8]:00000110010010101011101000010000
- R[8]:11010101011010010100101110010000
- L[9]:11010101011010010100101110010000
- R[9]:00100100011111001100011001111010
- L[10]:00100100011111001100011001111010
- R[10]:10110111110101011101011110110010
- L[11]:10110111110101011101011110110010
- R[11]:11000101011110000011110001111000
- L[12]:11000101011110000011110001111000
- R[12]:01110101101111010001100001011000
- L[13]:01110101101111010001100001011000
- R[13]:00011000110000110001010101011010
- L[14]:00011000110000110001010101011010
- R[14]:11000010100011001001011000001101
- L[15]:11000010100011001001011000001101
- R[15]:01000011010000100011001000110100
- L[16]:01000011010000100011001000110100
- R[16]:00001010010011001101100110010101
4. 逆转区位和最终变换
逆转区位: 64 位输出: R16+L16
然后将 R16L16 组合的 64 位数据进行最终置换, 64 位 ->64 位
最终置换表:
- 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
比如, 如果我们使用了上述方法得到了第 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.
下面我将给出明文 M 和密钥 K 加密出密文 C 的所有中间数据!!!!
二进制明文: 0000000100100011010001010110011110001001101010111100110111101111
二进制密文: 0001001100110100010101110111100110011011101111001101111111110001
16 个子密钥:
- K1:000110110000001011101111111111000111000001110010
- K2:011110011010111011011001110110111100100111100101
- K3:010101011111110010001010010000101100111110011001
- K4:011100101010110111010110110110110011010100011101
- K5:011111001110110000000111111010110101001110101000
- K6:011000111010010100111110010100000111101100101111
- K7:111011001000010010110111111101100001100010111100
- K8:111101111000101000111010110000010011101111111011
- K9:111000001101101111101011111011011110011110000001
- K10:101100011111001101000111101110100100011001001111
- K11:001000010101111111010011110111101101001110000110
- K12:011101010111000111110101100101000110011111101001
- K13:100101111100010111010001111110101011101001000001
- K14:010111110100001110110111111100101110011100111010
- K15:101111111001000110001101001111010011111100001010
- K16:110010110011110110001011000011100001011111110101
明文初始置换结果 (64->64):1100110000000000110011001111111111110000101010101111000010101010
- L0:11001100000000001100110011111111
- R0:11110000101010101111000010101010
第 1 次迭代
32 位数据扩展为 48 位结果: 011110100001010101010101011110100001010101010101
密钥和扩展数据异或结果: 011000010001011110111010100001100110010100100111
S 盒替代结果 (48->32):01011100100000101011010110010111
P 盒替代结果 (32->32):00100011010010101010100110111011
- L[1]:11110000101010101111000010101010
- R[1]:11101111010010100110010101000100
第 2 次迭代
32 位数据扩展为 48 位结果: 011101011110101001010100001100001010101000001001
密钥和扩展数据异或结果: 000011000100010010001101111010110110001111101100
S 盒替代结果 (48->32):11111000110100000011101010101110
P 盒替代结果 (32->32):00111100101010111000011110100011
- L[2]:11101111010010100110010101000100
- R[2]:11001100000000010111011100001001
第 3 次迭代
32 位数据扩展为 48 位结果: 111001011000000000000010101110101110100001010011
密钥和扩展数据异或结果: 101100000111110010001000111110000010011111001010
S 盒替代结果 (48->32):00100111000100001110000101101111
P 盒替代结果 (32->32):01001101000101100110111010110000
- L[3]:11001100000000010111011100001001
- R[3]:10100010010111000000101111110100
第 4 次迭代
32 位数据扩展为 48 位结果: 010100000100001011111000000001010111111110101001
密钥和扩展数据异或结果: 001000101110111100101110110111100100101010110100
S 盒替代结果 (48->32):00100001111011011001111100111010
P 盒替代结果 (32->32):10111011001000110111011101001100
- L[4]:10100010010111000000101111110100
- R[4]:01110111001000100000000001000101
第 5 次迭代
32 位数据扩展为 48 位结果: 101110101110100100000100000000000000001000001010
密钥和扩展数据异或结果: 110001100000010100000011111010110101000110100010
S 盒替代结果 (48->32):01010000110010000011000111101011
P 盒替代结果 (32->32):00101000000100111010110111000011
- L[5]:01110111001000100000000001000101
- R[5]:10001010010011111010011000110111
第 6 次迭代
32 位数据扩展为 48 位结果: 110001010100001001011111110100001100000110101111
密钥和扩展数据异或结果: 101001101110011101100001100000001011101010000000
S 盒替代结果 (48->32):01000001111100110100110000111101
P 盒替代结果 (32->32):10011110010001011100110100101100
- L[6]:10001010010011111010011000110111
- R[6]:11101001011001111100110101101001
第 7 次迭代
32 位数据扩展为 48 位结果: 111101010010101100001111111001011010101101010011
密钥和扩展数据异或结果: 000110011010111110111000000100111011001111101111
S 盒替代结果 (48->32):00010000011101010100000010101101
P 盒替代结果 (32->32):10001100000001010001110000100111
- L[7]:11101001011001111100110101101001
- R[7]:00000110010010101011101000010000
第 8 次迭代
32 位数据扩展为 48 位结果: 000000001100001001010101010111110100000010100000
密钥和扩展数据异或结果: 111101110100100001101111100111100111101101011011
S 盒替代结果 (48->32):01101100000110000111110010101110
P 盒替代结果 (32->32):00111100000011101000011011111001
- L[8]:00000110010010101011101000010000
- R[8]:11010101011010010100101110010000
第 9 次迭代
32 位数据扩展为 48 位结果: 011010101010101101010010101001010111110010100001
密钥和扩展数据异或结果: 100010100111000010111001010010001001101100100000
S 盒替代结果 (48->32):00010001000011000101011101110111
P 盒替代结果 (32->32):00100010001101100111110001101010
- L[9]:11010101011010010100101110010000
- R[9]:00100100011111001100011001111010
第 10 次迭代
32 位数据扩展为 48 位结果: 000100001000001111111001011000001100001111110100
密钥和扩展数据异或结果: 101000010111000010111110110110101000010110111011
S 盒替代结果 (48->32):11011010000001000101001001110101
P 盒替代结果 (32->32):01100010101111001001110000100010
- L[10]:00100100011111001100011001111010
- R[10]:10110111110101011101011110110010
第 11 次迭代
32 位数据扩展为 48 位结果: 010110101111111010101011111010101111110110100101
密钥和扩展数据异或结果: 011110111010000101111000001101000010111000100011
S 盒替代结果 (48->32):01110011000001011101000100000001
P 盒替代结果 (32->32):11100001000001001111101000000010
- L[11]:10110111110101011101011110110010
- R[11]:11000101011110000011110001111000
第 12 次迭代
32 位数据扩展为 48 位结果: 011000001010101111110000000111111000001111110001
密钥和扩展数据异或结果: 000101011101101000000101100010111110010000011000
S 盒替代结果 (48->32):01111011100010110010011000110101
P 盒替代结果 (32->32):11000010011010001100111111101010
- L[12]:11000101011110000011110001111000
- R[12]:01110101101111010001100001011000
第 13 次迭代
32 位数据扩展为 48 位结果: 001110101011110111111010100011110000001011110000
密钥和扩展数据异或结果: 101011010111100000101011011101011011100010110001
S 盒替代结果 (48->32):10011010110100011000101101001111
P 盒替代结果 (32->32):11011101101110110010100100100010
- L[13]:01110101101111010001100001011000
- R[13]:00011000110000110001010101011010
第 14 次迭代
32 位数据扩展为 48 位结果: 000011110001011000000110100010101010101011110100
密钥和扩展数据异或结果: 010100000101010110110001011110000100110111001110
S 盒替代结果 (48->32):01100100011110011001101011110001
P 盒替代结果 (32->32):10110111001100011000111001010101
- L[14]:00011000110000110001010101011010
- R[14]:11000010100011001001011000001101
第 15 次迭代
32 位数据扩展为 48 位结果: 111000000101010001011001010010101100000001011011
密钥和扩展数据异或结果: 010111111100010111010100011101111111111101010001
S 盒替代结果 (48->32):10110010111010001000110100111100
P 盒替代结果 (32->32):01011011100000010010011101101110
- L[15]:11000010100011001001011000001101
- R[15]:01000011010000100011001000110100
第 16 次迭代
32 位数据扩展为 48 位结果: 001000000110101000000100000110100100000110101000
密钥和扩展数据异或结果: 111010110101011110001111000101000101011001011101
S 盒替代结果 (48->32):10100111100000110010010000101001
P 盒替代结果 (32->32):11001000110000000100111110011000
- L[16]:01000011010000100011001000110100
- R[16]:00001010010011001101100110010101
- R16L16:0000101001001100110110011001010101000011010000100011001000110100
最终置换结果: 1000010111101000000100110101010000001111000010101011010000000101
密文 (二进制):1000010111101000000100110101010000001111000010101011010000000101
密文 (16 进制):85E813540F0AB405
关于解密: 解密只要将密文看作明文, 然后子密钥逆序使用就可以还原成为明文, 因为 DES 是对称加密算法!
C++ 代码实现:
- /*************************************************************************
- > File Name: DES.cpp
- > Author: YB
- > E-mail: 1348756432@qq.com
- > Created Time: 2019 年 03 月 01 日 星期五
- ************************************************************************/
- #include <bits/stdc++.h>
- using namespace std;
- /**
- * 数据初始置换表
- */
- int T1[8][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};
- /**
- * 密钥初始置换表
- */
- int T2[8][7]={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,
- 3,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};
- /**
- * 密钥循环左移位数表
- */
- int T3[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
- /**
- * 密钥压缩置换表
- */
- int T4[8][6]={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};
- /**
- * 数据扩展表
- */
- int T5[8][6]={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};
- /**
- *S 盒置换表
- */
- int S[8][4][16]={{{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}}};
- /**
- *P 盒置换表
- */
- int P[4][8]={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};
- /**
- * 最终置换表
- */
- int T6[8][8]={ 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};
- /**
- * 最终置换函数 64 位 ->64 位
- * 函数说明: s 为完成最后一轮循环得到的 64 为数据
- * 返回值为密文或明文
- */
- string final_permutation(string s)
- {
- string rs="";
- for(int i=0;i<8;i++)
- {
- for(int j=0;j<8;j++)
- {
- rs+=s[T6[i][j]-1];
- }
- }
- return rs;
- }
- /**
- *P 盒置换函数 32 位 ->32 位
- * 函数说明: s 为 S 盒的输出
- */
- string P_box(string s)
- {
- string rs="";
- for(int i=0;i<4;i++)
- {
- for(int j=0;j<8;j++)
- {
- rs+=(s[P[i][j]-1]);
- }
- }
- return rs;
- }
- /**
- *S 盒置换函数 48 位 ->32 位
- * 函数说明: s 为 48 位数据
- * 返回值为 32 位
- */
- string S_box(string s)
- {
- string rs="";
- string s1;
- int k1,k2;//S 盒的行号和列号
- int h=1;// 决定使用那个 S 盒
- for(int i=0;i<=42;i=i+6,h++)
- {
- k1=(s[i]-'0')*2+(s[i+5]-'0')*1;
- k2=(s[i+1]-'0')*8+(s[i+2]-'0')*4+(s[i+3]-'0')*2+(s[i+4]-'0')*1;
- int x=S[h-1][k1][k2];
- s1="";
- int y=8;
- for(int j=1;j<=4;j++)
- {
- if(x<y)
- {
- s1+="0";
- y/=2;
- }else
- {
- s1+="1";
- x=x%y;
- y/=2;
- }
- }
- rs+=s1;
- }
- return rs;
- }
- /**
- * 异或运算函数
- * 要求位数相同
- */
- string XOR(string s1,string s2)
- {
- string rs="";
- for(int i=0;i<s1.length()&&i<s2.length();i++)
- {
- rs+=((s1[i]-'0')^(s2[i]-'0'))+'0';
- }
- return rs;
- }
- /**
- * 数据扩展函数 32->48
- * 函数说明: s 为数据的右半部分 32 位
- * 扩展成 48 位的输出
- */
- string plaintext_righthalf_extended_permutation(string s)
- {
- string rs="";
- for(int i=0;i<8;i++)
- {
- for(int j=0;j<6;j++)
- {
- rs+=s[T5[i][j]-1];
- }
- }
- return rs;
- }
- /**
- * 密钥压缩置换函数 56 位 ->48 位
- * 函数说明: s 为 56 为的密钥
- * 输出为 48 位的子密钥
- */
- string secret_key_compression_replacement(string s)
- {
- string rs="";
- for(int i=0;i<8;i++)
- {
- for(int j=0;j<6;j++)
- {
- rs+=s[T4[i][j]-1];
- }
- }
- return rs;
- }
- /**
- * 密钥循环左移函数 56 位 ->56 位
- * 函数说明: k 为左移位数 s 为密钥
- * 返回值位数不变
- */
- string secret_ket_left_move(int k,string s)// 密钥循环左移 k 位
- {
- string s1=s.substr(0,28);
- string s2=s.substr(28,28);
- string rs=s1.substr(k,28-k)+s1.substr(0,k)+s2.substr(k,28-k)+s2.substr(0,k);
- return rs;
- }
- /**
- * 密钥初始置换函数 64 位 ->58 位
- * 函数说明: s 为 64 位的初始密钥
- * 返回值为 58 位
- */
- string secret_key_initial_permutation(string s)
- {
- string rs="";
- for(int i=0;i<8;i++)
- {
- for(int j=0;j<7;j++)
- {
- rs+=s[T2[i][j]-1];
- }
- }
- return rs;
- }
- /**
- * 明文初始置换函数 64 位 ->64 位
- * 函数说明: s 为初始明文 64 位
- * 返回值为 6 位
- */
- string plaintext_initial_permutation(string s)// 明文初始置换
- {
- string rs="";
- for(int i=0;i<8;i++)
- {
- for(int j=0;j<8;j++)
- {
- rs+=s[T1[i][j]-1];
- }
- }
- return rs;
- }
- /**
- *16 进制转 2 进制函数
- * 函数说明: s 为 16 进制字符串
- * 返回为 2 进制字符串
- */
- string H(string s)
- {
- string s1;
- string rs="";
- for(int i=0;i<s.length();i++)
- {
- int x;
- if(s[i]>='0'&&s[i]<='9')
- {
- x=s[i]-'0';
- }else
- {
- x=s[i]-'A'+10;
- }
- s1="";
- int y=8;
- for(int j=1;j<=4;j++)
- {
- if(x<y)
- {
- y/=2;
- s1+="0";
- }else
- {
- s1+="1";
- x=x%y;
- y=y/2;
- }
- }
- rs+=s1;
- }
- return rs;
- }
- /**
- *2 进制转 16 进制函数
- *str 为 2 进制字符串
- * 返回值为 16 进制字符串
- */
- string G(string str)
- {
- string rs="";
- char temp;
- for(int i=0;i<=str.length()-4;i=i+4)
- {
- int x=(str[i]-'0')*8+(str[i+1]-'0')*4+(str[i+2]-'0')*2+str[i+3]-'0';
- if(x>=10)
- {
- temp=(char)(x-10+'A');
- }else
- {
- temp=(char)(x+'0');
- }
- rs+=temp;
- }
- return rs;
- }
- /**
- * 封装函数 f
- * 函数说明: 接收 32 位数据和 48 位的子密钥 产生一个 32 位的输出
- *str1:32 位数据 str2:48 位的子密钥
- * 返回值 32 位
- */
- string f(string str1,string str2)
- {
- string expendR=plaintext_righthalf_extended_permutation(str1);
- cout<<"32 位数据扩展为 48 位结果:"<<expendR<<endl;
- string rs=XOR(expendR,str2);
- cout<<"密钥和扩展数据异或结果:"<<rs<<endl;
- rs=S_box(rs);
- cout<<"S 盒替代结果 (48->32):"<<rs<<endl;
- rs=P_box(rs);
- cout<<"P 盒替代结果 (32->32):"<<rs<<endl;
- return rs;
- }
- /**
- * 子密钥生成函数
- * 函数说明: s 为给定的密钥
- * 生成 16 个子密钥
- */
- string Keys[20];
- void generateKeys(string s)
- {
- s=secret_key_initial_permutation(s);
- for(int i=1;i<=16;i++)
- {
- s=secret_ket_left_move(T3[i-1],s);
- Keys[i]=secret_key_compression_replacement(s);
- cout<<"K"<<i<<":"<<Keys[i]<<endl;
- }
- cout<<endl;
- }
- /**
- *DES 加密函数 64 位 ->64 位
- * 函数说明: str1 为 64 位的给定明文
- * 返回值为 64 位的密文
- */
- string encrypt(string str1)
- {
- // 第一步: 明文初始置换 64->64
- str1=plaintext_initial_permutation(str1);
- cout<<"明文初始置换结果 (64->64):"<<str1<<endl<<endl;
- // 第二步: 数据分组
- string left=str1.substr(0,32);
- string right=str1.substr(32,32);
- cout<<"L0:"<<left<<endl;
- cout<<"R0:"<<right<<endl<<endl;
- string newleft;
- // 第三步: 16 轮迭代
- for(int i=1;i<=16;i++)
- {
- cout<<"第"<<i<<"次迭代"<<endl;
- newleft=right;
- right=XOR(left,f(right,Keys[i]));
- left=newleft;
- cout<<"L["<<i<<"]:"<<left<<endl;
- cout<<"R["<<i<<"]:"<<right<<endl<<endl;
- }
- // 第四步: 合并数据 注意位 R16L16
- string rs=right+left;
- cout<<"R16L16:"<<rs<<endl<<endl;
- // 结尾置换
- rs=final_permutation(rs);
- cout<<"最终置换结果:"<<rs<<endl<<endl;
- return rs;
- }
- /**
- * 解密函数
- *str 为密文
- * 输出明文
- */
- string decrypt(string str)
- {
- // 把密文当作明文进行初始明文置换
- str=plaintext_initial_permutation(str);
- cout<<"密文当作明文初始置换结果 (64->64):"<<str<<endl<<endl;
- // 分组
- string left=str.substr(0,32);
- string right=str.substr(32,32);
- cout<<"L0:"<<left<<endl;
- cout<<"R0:"<<right<<endl<<endl;
- string newleft;
- // 逆序的子密钥使用 16 轮迭代
- for(int i=16;i>=1;i--)
- {
- cout<<"第"<<17-i<<"次迭代"<<endl;
- newleft=right;
- right=XOR(left,f(right,Keys[i]));
- left=newleft;
- cout<<"L["<<17-i<<"]:"<<left<<endl;
- cout<<"R["<<17-i<<"]:"<<right<<endl<<endl;
- }
- // 合并
- string rs=right+left;
- cout<<"R16L16:"<<rs<<endl<<endl;
- // 最后置换
- rs=final_permutation(rs);
- cout<<"最终置换结果:"<<rs<<endl<<endl;
- return rs;
- }
- int main()
- {
- // 明文 16 进制
- string str1="0123456789ABCDEF";
- // 密钥 16 进制
- string str2="133457799BBCDFF1";
- string temp=str1;// 保存十六进制的明文以便后面验证算法正确性
- // 进制转换 16->2
- str1=H(str1);
- str2=H(str2);
- cout<<"二进制明文:"<<str1<<endl;
- cout<<"二进制密文:"<<str2<<endl<<endl;
- cout<<"16 个子密钥:"<<endl;
- // 生成 16 个子密钥
- generateKeys(str2);
- // 加密
- string rs=encrypt(str1);
- cout<<"密文 (二进制):"<<rs<<endl;
- cout<<"密文 (16 进制):"<<G(rs)<<endl;
- cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl<<"下面是解密过程数据"<<endl<<endl;
- // 解密
- rs=decrypt(rs);
- cout<<"明文 (二进制):"<<rs<<endl;
- // 进制转换
- rs=G(rs);
- cout<<"明文 (16 进制):"<<rs<<endl;
- if(temp==rs)
- cout<<"解密得到的明文和初始明文匹配成功, 算法正确"<<endl;
- else
- cout<<"解密得到的明文和初始明文匹配不成功, 算法错误"<<endl;
- return 0;
- }
来源: https://www.cnblogs.com/yinbiao/p/10460453.html