DES对称加密算法详解和c++代码实现(带样例和详细的中间数据)

c/c++

浏览数:71

2019-5-14

特点:

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

需要记住的是:每一对CnDn都是由前一对Cn-1Dn-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轮的左右两个区块:

  1. L16 = 0100 0011 0100 0010 0011 0010 0011 0100
  2. R16 = 0000 1010 0100 1100 1101 1001 1001 0101

我们将这两个区块调换位置,然后执行最终变换:

  1. R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100
  2. IP-1 = 10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101

写成16进制得到:

  1. 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;
}

 

作者:Y先森0.0