DES原理及Python实现

简介

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

算法流程

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

核心代码及算法分析

第一部通过分是明文通过IP置换的操做，这里能够直接用一维数组去完成，这须要注意的是数组下标不要写错，会致使数组越界，最后一部分IP逆的那一部分也同样的道理。

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轮。

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位的密钥，最后用数组将全部密钥都装好。

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置换差很少，都是利用了打表而后字符串拼接的方式实现

#秘钥的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输出得注意位数不够四位得补齐

# 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"为例，可以正确加解密

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