DES加密算法实现

实验要求：编写DES算法实现程序，运行DES程序，演示DES加密与解密的过程。在加密时显示明文和密钥，在加密过程中在每一轮执行完毕后显示该轮的输出。
（话不多说，直接上代码！！！）
实验代码：
点击查看代码

1. import binascii
2. class ArrangeSimpleDES():
3.     def __init__(self):
4.         # 出初始化DES加密的参数
5.         self.ip = [
6.             58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
7.             62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
8.             57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
9.             61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7,
10.         ]  # ip置换
12.         self.ip1 = [
13.             40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
14.             38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
15.             36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
16.             34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25,
17.         ]  # 逆ip置换
18.         self.E = [
19.             32, 1, 2, 3, 4, 5,
20.             4, 5, 6, 7, 8, 9,
21.             8, 9, 10, 11, 12, 13,
22.             12, 13, 14, 15, 16, 17,
23.             16, 17, 18, 19, 20, 21,
24.             20, 21, 22, 23, 24, 25,
25.             24, 25, 26, 27, 28, 29,
26.             28, 29, 30, 31, 32, 1,
27.         ]  # E置换，将32位明文置换位48位
28.         self.P = [
29.             16, 7, 20, 21, 29, 12, 28, 17,
30.             1, 15, 23, 26, 5, 18, 31, 10,
31.             2, 8, 24, 14, 32, 27, 3, 9,
32.             19, 13, 30, 6, 22, 11, 4, 25,
33.         ]  # P置换，对经过S盒之后的数据再次进行置换
34.         # 设置默认密钥
35.         self.K = '0111010001101000011010010111001101101001011100110110100101110110'
36.         self.k1 = [
37.             57, 49, 41, 33, 25, 17, 9,
38.             1, 58, 50, 42, 34, 26, 18,
39.             10, 2, 59, 51, 43, 35, 27,
40.             19, 11, 3, 60, 52, 44, 36,
41.             63, 55, 47, 39, 31, 23, 15,
42.             7, 62, 54, 46, 38, 30, 22,
43.             14, 6, 61, 53, 45, 37, 29,
44.             21, 13, 5, 28, 20, 12, 4,
45.         ]  # 密钥的K1初始置换
46.         self.k2 = [
47.             14, 17, 11, 24, 1, 5, 3, 28,
48.             15, 6, 21, 10, 23, 19, 12, 4,
49.             26, 8, 16, 7, 27, 20, 13, 2,
50.             41, 52, 31, 37, 47, 55, 30, 40,
51.             51, 45, 33, 48, 44, 49, 39, 56,
52.             34, 53, 46, 42, 50, 36, 29, 32,
53.         ]
55.         self.k0 = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, ]  # 秘钥循环移位的位数
57.         self.S = [
58.             [
59.                 0xe, 0x4, 0xd, 0x1, 0x2, 0xf, 0xb, 0x8, 0x3, 0xa, 0x6, 0xc, 0x5, 0x9, 0x0, 0x7,
60.                 0x0, 0xf, 0x7, 0x4, 0xe, 0x2, 0xd, 0x1, 0xa, 0x6, 0xc, 0xb, 0x9, 0x5, 0x3, 0x8,
61.                 0x4, 0x1, 0xe, 0x8, 0xd, 0x6, 0x2, 0xb, 0xf, 0xc, 0x9, 0x7, 0x3, 0xa, 0x5, 0x0,
62.                 0xf, 0xc, 0x8, 0x2, 0x4, 0x9, 0x1, 0x7, 0x5, 0xb, 0x3, 0xe, 0xa, 0x0, 0x6, 0xd,
63.             ],
64.             [
65.                 0xf, 0x1, 0x8, 0xe, 0x6, 0xb, 0x3, 0x4, 0x9, 0x7, 0x2, 0xd, 0xc, 0x0, 0x5, 0xa,
66.                 0x3, 0xd, 0x4, 0x7, 0xf, 0x2, 0x8, 0xe, 0xc, 0x0, 0x1, 0xa, 0x6, 0x9, 0xb, 0x5,
67.                 0x0, 0xe, 0x7, 0xb, 0xa, 0x4, 0xd, 0x1, 0x5, 0x8, 0xc, 0x6, 0x9, 0x3, 0x2, 0xf,
68.                 0xd, 0x8, 0xa, 0x1, 0x3, 0xf, 0x4, 0x2, 0xb, 0x6, 0x7, 0xc, 0x0, 0x5, 0xe, 0x9,
69.             ],
70.             [
71.                 0xa, 0x0, 0x9, 0xe, 0x6, 0x3, 0xf, 0x5, 0x1, 0xd, 0xc, 0x7, 0xb, 0x4, 0x2, 0x8,
72.                 0xd, 0x7, 0x0, 0x9, 0x3, 0x4, 0x6, 0xa, 0x2, 0x8, 0x5, 0xe, 0xc, 0xb, 0xf, 0x1,
73.                 0xd, 0x6, 0x4, 0x9, 0x8, 0xf, 0x3, 0x0, 0xb, 0x1, 0x2, 0xc, 0x5, 0xa, 0xe, 0x7,
74.                 0x1, 0xa, 0xd, 0x0, 0x6, 0x9, 0x8, 0x7, 0x4, 0xf, 0xe, 0x3, 0xb, 0x5, 0x2, 0xc,
75.             ],
76.             [
77.                 0x7, 0xd, 0xe, 0x3, 0x0, 0x6, 0x9, 0xa, 0x1, 0x2, 0x8, 0x5, 0xb, 0xc, 0x4, 0xf,
78.                 0xd, 0x8, 0xb, 0x5, 0x6, 0xf, 0x0, 0x3, 0x4, 0x7, 0x2, 0xc, 0x1, 0xa, 0xe, 0x9,
79.                 0xa, 0x6, 0x9, 0x0, 0xc, 0xb, 0x7, 0xd, 0xf, 0x1, 0x3, 0xe, 0x5, 0x2, 0x8, 0x4,
80.                 0x3, 0xf, 0x0, 0x6, 0xa, 0x1, 0xd, 0x8, 0x9, 0x4, 0x5, 0xb, 0xc, 0x7, 0x2, 0xe,
81.             ],
82.             [
83.                 0x2, 0xc, 0x4, 0x1, 0x7, 0xa, 0xb, 0x6, 0x8, 0x5, 0x3, 0xf, 0xd, 0x0, 0xe, 0x9,
84.                 0xe, 0xb, 0x2, 0xc, 0x4, 0x7, 0xd, 0x1, 0x5, 0x0, 0xf, 0xa, 0x3, 0x9, 0x8, 0x6,
85.                 0x4, 0x2, 0x1, 0xb, 0xa, 0xd, 0x7, 0x8, 0xf, 0x9, 0xc, 0x5, 0x6, 0x3, 0x0, 0xe,
86.                 0xb, 0x8, 0xc, 0x7, 0x1, 0xe, 0x2, 0xd, 0x6, 0xf, 0x0, 0x9, 0xa, 0x4, 0x5, 0x3,
87.             ],
88.             [
89.                 0xc, 0x1, 0xa, 0xf, 0x9, 0x2, 0x6, 0x8, 0x0, 0xd, 0x3, 0x4, 0xe, 0x7, 0x5, 0xb,
90.                 0xa, 0xf, 0x4, 0x2, 0x7, 0xc, 0x9, 0x5, 0x6, 0x1, 0xd, 0xe, 0x0, 0xb, 0x3, 0x8,
91.                 0x9, 0xe, 0xf, 0x5, 0x2, 0x8, 0xc, 0x3, 0x7, 0x0, 0x4, 0xa, 0x1, 0xd, 0xb, 0x6,
92.                 0x4, 0x3, 0x2, 0xc, 0x9, 0x5, 0xf, 0xa, 0xb, 0xe, 0x1, 0x7, 0x6, 0x0, 0x8, 0xd,
93.             ],
94.             [
95.                 0x4, 0xb, 0x2, 0xe, 0xf, 0x0, 0x8, 0xd, 0x3, 0xc, 0x9, 0x7, 0x5, 0xa, 0x6, 0x1,
96.                 0xd, 0x0, 0xb, 0x7, 0x4, 0x9, 0x1, 0xa, 0xe, 0x3, 0x5, 0xc, 0x2, 0xf, 0x8, 0x6,
97.                 0x1, 0x4, 0xb, 0xd, 0xc, 0x3, 0x7, 0xe, 0xa, 0xf, 0x6, 0x8, 0x0, 0x5, 0x9, 0x2,
98.                 0x6, 0xb, 0xd, 0x8, 0x1, 0x4, 0xa, 0x7, 0x9, 0x5, 0x0, 0xf, 0xe, 0x2, 0x3, 0xc,
99.             ],
100.             [
101.                 0xd, 0x2, 0x8, 0x4, 0x6, 0xf, 0xb, 0x1, 0xa, 0x9, 0x3, 0xe, 0x5, 0x0, 0xc, 0x7,
102.                 0x1, 0xf, 0xd, 0x8, 0xa, 0x3, 0x7, 0x4, 0xc, 0x5, 0x6, 0xb, 0x0, 0xe, 0x9, 0x2,
103.                 0x7, 0xb, 0x4, 0x1, 0x9, 0xc, 0xe, 0x2, 0x0, 0x6, 0xa, 0xd, 0xf, 0x3, 0x5, 0x8,
104.                 0x2, 0x1, 0xe, 0x7, 0x4, 0xa, 0x8, 0xd, 0xf, 0xc, 0x9, 0x0, 0x3, 0x5, 0x6, 0xb,
105.             ],
106.         ]  # 16进制表示S盒的数据，S盒是为了将48位转换为32位，有8个盒子
108.     def __substitution(self, table: str, self_table: list) -> str:
109.         """
110.         :param table: 需要进行置换的列表,是一个01字符串
111.         :param self_table: 置换表，在__init__中初始化了
112.         :return: 返回置换后的01字符串
113.         """
114.         sub_result = ""
115.         for i in self_table:
116.             sub_result += table[i - 1]
117.         return sub_result
119.     def str2bin(self, string: str) -> str:
120.         """
121.         将明文转为二进制字符串:
122.         :param string: 任意字符串
123.         :return:二进制字符串
124.         """
125.         plaintext_list = list(bytes(string, 'utf8'))  # 将字符串转成bytes类型，再转成list
126.         result = []  # 定义返回结果
127.         for num in plaintext_list:
128.             result.append(bin(num)[2:].zfill(8))  # 将列表的每个元素转成二进制字符串，8位宽度
129.         return "".join(result)
131.     def bin2str(self, binary: str) -> str:
132.         """
133.         二进制字符串转成字符串
134.         :param binary:
135.         :return:
136.         """
137.         list_bin = [binary[i:i + 8] for i in range(0, len(binary), 8)]  # 对二进制字符串进行切分，每8位为一组
138.         list_int = []
139.         for b in list_bin:
140.             list_int.append(int(b, 2))  # 对二进制转成int
141.         result = bytes(list_int).decode()  # 将列表转成bytes，在进行解码，得到字符串
142.         return result
144.     def __bin2int(self, binary: str) -> list:
145.         """
146.         由于加密之后的二进制无法直接转成字符，有不可见字符在，utf8可能无法解码，所以需要将二进制字符串每8位转成int型号列表，用于转成bytes再转hex
147.         :param binary: 二进制字符串
148.         :return: int型列表
149.         """
150.         list_bin = [binary[i:i + 8] for i in range(0, len(binary), 8)]  # 对二进制字符串进行切分，每8位为一组
151.         list_int = []
152.         for b in list_bin:
153.             list_int.append(int(b, 2))
154.         return list_int
156.     def __int2bin(self, list_int: list) -> str:
157.         result = []
158.         for num in list_int:
159.             result.append(bin(num)[2:].zfill(8))
160.         return ''.join(result)
162.     def __get_block_list(self, binary: str) -> list:
163.         """
164.         对明文二进制串进行切分，每64位为一块，DES加密以64位为一组进行加密的
165.         :type binary: 二进制串
166.         """
167.         len_binary = len(binary)
168.         if len_binary % 64 != 0:
169.             binary_block = binary + ("0" * (64 - (len_binary % 64)))
170.             return [binary_block[i:i + 64] for i in range(0, len(binary_block), 64)]
171.         else:
172.             return [binary[j:j + 64] for j in range(0, len(binary), 64)]
174.     def modify_secretkey(self):
175.         """
176.         修改默认密钥函数
177.         :return: None
178.         """
179.         print('当前二进制形式密钥为:{}'.format(self.K))
180.         print("当前字符串形式密钥为：{}".format(self.bin2str(self.K)))
181.         newkey = input("输入新的密钥（长度为8）：")
182.         if len(newkey) != 8:
183.             print("密钥长度不符合，请重新输入：")
184.             self.modify_secretkey()
185.         else:
186.             bin_key = self.str2bin(newkey)
187.             self.K = bin_key
188.             print("当前二进制形式密钥为:{}".format(self.K))
190.     def __f_funtion(self, right: str, key: str):
191.         """
192.         :param right: 明文二进制的字符串加密过程的右半段
193.         :param key: 当前轮数的密钥
194.         :return: 进行E扩展，与key异或操作，S盒操作后返回32位01字符串
195.         """
196.         # 对right进行E扩展
197.         e_result = self.__substitution(right, self.E)
198.         # 与key 进行异或操作
199.         xor_result = self.__xor_function(e_result, key)
200.         # 进入S盒子
201.         s_result = self.__s_box(xor_result)
202.         # 进行P置换
203.         p_result = self.__substitution(s_result, self.P)
204.         return p_result
206.     def __get_key_list(self):
207.         """
208.         :return: 返回加密过程中16轮的子密钥
209.         """
210.         key = self.__substitution(self.K, self.k1)
211.         left_key = key[0:28]
212.         right_key = key[28:56]
213.         keys = []
214.         for i in range(1, 17):
215.             move = self.k0[i - 1]
216.             move_left = left_key[move:28] + left_key[0:move]
217.             move_right = right_key[move:28] + right_key[0:move]
218.             left_key = move_left
219.             right_key = move_right
220.             move_key = left_key + right_key
221.             ki = self.__substitution(move_key, self.k2)
222.             keys.append(ki)
223.         return keys
225.     def __xor_function(self, xor1: str, xor2: str):
226.         """
227.         :param xor1: 01字符串
228.         :param xor2: 01字符串
229.         :return: 异或操作返回的结果
230.         """
231.         size = len(xor1)
232.         result = ""
233.         for i in range(0, size):
234.             result += '0' if xor1[i] == xor2[i] else '1'
235.         return result
237.     def __s_box(self, xor_result: str):
238.         """
239.         :param xor_result: 48位01字符串
240.         :return: 返回32位01字符串
241.         """
242.         result = ""
243.         for i in range(0, 8):
244.             # 将48位数据分为6组，循环进行
245.             block = xor_result[i * 6:(i + 1) * 6]
246.             line = int(block[0] + block[5], 2)
247.             colmn = int(block[1:4], 2)
248.             res = bin(self.S[i][line * 16 + colmn])[2:]
249.             if len(res) < 4:
250.                 res = '0' * (4 - len(res)) + res
251.             result += res
252.         return result
254.     def __iteration(self, bin_plaintext: str, key_list: list):
255.         """
256.         :param bin_plaintext: 01字符串，64位
257.         :param key_list: 密钥列表，共16个
258.         :return: 进行F函数以及和left异或操作之后的字符串
259.         """
260.         left = bin_plaintext[0:32]
261.         right = bin_plaintext[32:64]
262.         for i in range(0, 16):
263.             next_lift = right
264.             f_result = self.__f_funtion(right, key_list[i])
265.             next_right = self.__xor_function(left, f_result)
266.             left = next_lift
267.             right = next_right
268.         bin_plaintext_result = left + right
269.         return bin_plaintext_result[32:] + bin_plaintext_result[:32]
271.     def encode(self, plaintext):
272.         """
273.         :param plaintext: 明文字符串
274.         :return: 密文字符串
275.         """
276.         bin_plaintext = self.str2bin(plaintext)
277.         bin_plaintext_block = self.__get_block_list(bin_plaintext)
278.         ciphertext_bin_list = []
279.         key_list = self.__get_key_list()
280.         counter = 1
281.         for i in key_list:
282.             print(f"第{counter}轮子密钥是：{i}")
283.             counter += 1
284.         for block in bin_plaintext_block:
285.             # 初代ip置换
286.             sub_ip = self.__substitution(block, self.ip)
287.             ite_result = self.__iteration(sub_ip, key_list)
288.             # 逆ip置换
289.             sub_ip1 = self.__substitution(ite_result, self.ip1)
290.             ciphertext_bin_list.append(sub_ip1)
291.         ciphertext_bin = ''.join(ciphertext_bin_list)
292.         result = self.__bin2int(ciphertext_bin)
293.         counter = 1
294.         for i in result:
295.             print(f"第{counter}轮加密结果为：{i}")
296.             counter += 1
297.         return bytes(result).hex().upper()
299.     def decode(self, ciphertext):
300.         '''
301.         :param ciphertext: 密文字符串
302.         :return: 明文字符串
303.         '''
304.         b_ciphertext = binascii.a2b_hex(ciphertext)
305.         bin_ciphertext = self.__int2bin(list(b_ciphertext))
306.         bin_plaintext_list = []
307.         key_list = self.__get_key_list()
308.         key_list = key_list[::-1]
309.         counter = 1
310.         for i in key_list:
311.             print(f"第{counter}轮子密钥是：{i}")
312.             counter += 1
313.         bin_ciphertext_block = [bin_ciphertext[i:i + 64] for i in range(0, len(bin_ciphertext), 64)]
314.         for block in bin_ciphertext_block:
315.             sub_ip = self.__substitution(block, self.ip)
316.             ite = self.__iteration(sub_ip, key_list)
317.             sub_ip1 = self.__substitution(ite, self.ip1)
318.             bin_plaintext_list.append(sub_ip1)
319.         bin_plaintext = ''.join(bin_plaintext_list)
320.         result = self.__bin2int(bin_plaintext)
321.         counter = 1
322.         for i in result:
323.             print(f"第{counter}轮解密结果为：{i}")
324.             counter += 1
325.         bin_plaintext = ''.join(bin_plaintext_list).replace('00000000', '')
326.         return self.bin2str(bin_plaintext)
328.     def main(self):
329.         select = input("请选择:\n1、加密\t 2、解密\n请你选择1或2:")
330.         if select == '1':
331.             plaintext = input("明文：")
332.             ciphertext = self.encode(plaintext)
333.             print("密文:{}".format(ciphertext))
334.         elif select == '2':
335.             plaintext = input("密文：")
336.             plaintext = self.decode(plaintext)
337.             print("明文:{}".format(plaintext))
338.         else:
339.             input("请重新选择！")
340.             self.main()
343. if __name__ == '__main__':
344.     mydes = ArrangeSimpleDES()
345.     mydes.modify_secretkey()
346.     while True:
347.         mydes.main()
348.         print("")

复制代码

运行结果：
加密过程


解密过程


解析：
其中，子密钥生成操作如下：

用流程图表示为（手写版见谅啦~）

加密操作过程如下：

用流程图表示为（手写版嘿嘿有点丑就是说。。。）

实验报告搬运完毕！希望能帮助到您~拜拜拜拜啦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！