DES原理及Python实现

简介

DES是分组密码的一类,是一种对称密码技术,使用了Feistel的网络结构,将明文分成多个等长模块,使用确定的算法以及对称并且相同的密钥对明密文进行加解密。

F5u1LF.png

算法流程

  1. 64位的明文经过初始置换而被重新排列,并将其分为左右两个分组L0和R0各32位。
  2. 在密钥的参与下,最左右两个分组进行16轮相同函数的迭代,每轮迭代都有置换和代换。注意最后一轮迭代的输出为64位。左半部分和右半部分不进行交换。
  3. 最后的预输出再通过逆初始置换产生64位的密文。
  4. 加解密过程一样,反过来即可,也就是秘钥列表得倒过来。所以得注意一下。

核心代码及算法分析

第一部经过分是明文经过IP置换的操作,这里可以直接用一维数组去完成,这需要注意的是数组下标不要写错,会导致数组越界,最后一部分IP逆的那一部分也一样的道理。

1
2
3
4
5
6
7
8
9
10
11
12
def ip_change(bin_str):
res = ""
for i in IP_table:
res += bin_str[i-1] #数组下标i-1
return res

#IP逆盒处理
def ip_re_change(bin_str):
res = ""
for i in IP_re_table:
res += bin_str[i-1]
return res

再下来就是经过16轮迭代的过程,每一步的迭代过程里面又包含了F函数,还有密钥的产生。

首先是一个大致的迭代过程,很清楚首先产生了16轮迭代的秘钥,每一轮的迭代都有密钥参与,并且通过切片完成了每一轮的左右分组,然后右边的分组作为了新的左边,左边的分组以及右边的分组还有密钥通过F函数的计算获得新的右分组,最后一轮不做交换,这也就是我为什么只循环了15轮。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def des_encrypt_one(bin_message,bin_key): #64位二进制加密的测试
#bin_message = deal_mess(str2bin(message))
mes_ip_bin = ip_change(bin_message)
#bin_key = input_key_judge(str2bin(key))
key_lst = gen_key(bin_key)
mes_left = mes_ip_bin[0:32]
mes_right = mes_ip_bin[32:]
for i in range(0,15):
mes_tmp = mes_right
f_result = fun_f(mes_tmp,key_lst[i])
mes_right = str_xor(f_result,mes_left)
mes_left = mes_tmp
f_result = fun_f(mes_right,key_lst[15])
mes_fin_left = str_xor(mes_left,f_result)
mes_fin_right = mes_right
fin_message = ip_re_change(mes_fin_left + mes_fin_right)
return fin_message

再看看产生密钥的关键代码gen_key,传进去的参数密钥实际是64位的,但实际发挥作用的是56位,是因为仅过了一次PC-1的置换,这也解释了这段代码为什么到后面切片的时候以28为中心分左右。然后根据是第几轮然后对左右分组的密钥进行循环左移,出来的56位再经过一次置换生成48位的密钥,最后用数组将所有密钥都装好。

1
2
3
4
5
6
7
8
9
10
11
def gen_key(key):
key_list = []
divide_output = change_key1(key)
key_C0 = divide_output[0:28]
key_D0 = divide_output[28:]
for i in SHIFT:
key_c = left_turn(key_C0,i)
key_d = left_turn(key_D0,i)
key_output = change_key2(key_c + key_d)
key_list.append(key_output)
return key_list

PC-1,PC-2的置换过程,跟IP置换差不多,都是利用了打表然后字符串拼接的方式实现

1
2
3
4
5
6
7
8
9
10
11
12
13
#秘钥的PC-1置换
def change_key1(my_key):
res = ""
for i in PC_1:
res += my_key[i-1]
return res

#秘钥的PC-2置换
def change_key2(my_key):
res = ""
for i in PC_2:
res += my_key[i-1]
return res

重点还有F函数的处理,也即是代码里面的fun_f,这里面主要有四个步骤,分别是扩展置换,密钥加,经过S盒的代换,最后经过了P盒的置换,最终把32位的输入变成48位的输出。E盒以及P盒的置换也是很简单打好表然后用字符串拼接就好。关键是S盒的变换原理,6位的输入4位的输出,输入前两位作为S盒横坐标,中间4位作为列,但是我这里是以bin输出得注意位数不够四位得补齐

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
# F函数的实现
def fun_f(bin_str,key):
first_output = e_key(bin_str)
second_output = str_xor(first_output,key)
third_output = s_box(second_output)
last_output = p_box(third_output)
return last_output

#E盒置换
def e_key(bin_str):
res = ""
for i in E:
res += bin_str[i-1]
return res

# S盒过程
def s_box(my_str):
res = ""
c = 0
for i in range(0,len(my_str),6):
now_str = my_str[i:i+6]
row = int(now_str[0]+now_str[5],2)
col = int(now_str[1:5],2)
num = bin(S[c][row*16 + col])[2:] #利用了bin输出有可能不是4位str类型的值,所以才有下面的循环并且加上字符0
for gz in range(0,4-len(num)):
num = '0'+ num
res += num
c += 1
return res

#P盒置换
def p_box(bin_str):
res = ""
for i in P:
res += bin_str[i-1]
return res

正确性

加密解密内容都会放到文件里面,然后通过读写文件的方式将内容成功加解密,以”helloworld”为例,能够正确加解密

F51J8s.png

详细代码(放在github上了):DES加解密


听说,打赏我的人最后都成了大佬。



文章目录
  1. 1. 简介
  2. 2. 算法流程
  3. 3. 核心代码及算法分析
  4. 4. 正确性
  5. 5. 详细代码(放在github上了):DES加解密