精华内容
下载资源
问答
  • 主要介绍了python实现的DES加密算法和3DES加密算法,以实例形式较为详细的分析了DES加密算法和3DES加密算法的原理与实现技巧,需要的朋友可以参考下
  • DES 加解密的 Python 实现 环境 使用的 Python 版本是:Python 3.6.3。 无使用其他第三方库,根据密码学实验要求纯手工实现。 使用 加密字符串 在得到的项目文件夹下使用如下命令即可启动 GUI 界面: $ python3 main...
  • pythondes加密算法

    2011-09-11 11:27:34
    这里面是python的使用编程小例子,有图形编程的,有des加密算法的。有md5加密算法的
  • DES加密算法原理及Python代码实现

    千次阅读 2021-01-18 20:28:25
    写在前面:   1、本文中DES加解密基本流程及S盒等参数参照自杨波《现代密码学(第四版)》,实现过程均为自编函数。   2、为了说明64bit密钥中,只有56bit...  DES全称为Data Encryption Standard,即数据加密

    写在前面:
      1、本文中DES加解密基本流程及S盒等参数参照自杨波《现代密码学(第四版)》,实现过程均为自编函数。
      2、为了说明64bit密钥中,只有56bit真正参与加解密过程,对网上代码中的密钥生成过程做出了修改,详见正文。
      3、本文借鉴了网上部分代码,具体见参考文献,并对部分地方按题主想法进行了优化修改。

    1. DES算法理论介绍

      具体可参见杨波《现代密码学(第四版)》。本文只做简要介绍。

    1.1 DES介绍

      DES全称为Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛流传开来。

    1.2 DES加解密算法描述

    图 1.2 DES加密流程框图

      图1.2是DES加密变换框图,其中明文一组为64bit,密钥K长度56bit。加密过程有3个阶段:
      1、初始置换IP,用于重排明文分组的64比特数据。
      2、经过具有相同功能的16轮Feistel变换,每轮中F函数中都有置换和代换运算,第16轮变换的输出分为左右两半,并被交换次序。
      3、经过一个逆初始置换IP-1(为IP的逆)从而产生64比特的密文。

    1.2.1 轮结构

      采用Feistel相同的轮结构,将64bit的轮输入分为32bit的左、右两半,分别记为L和R:
    L i = R i − 1 L_i=R_{i-1} Li=Ri1
                    R i = L i − 1 ⊕ F ( R i − 1 , K i ) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ R_i=L_{i-1}\oplus F\left( R_{i-1},K_i \right)                Ri=Li1F(Ri1,Ki)
      其中,F函数示意图见图1.2.1。

    图1.2.1 F函数示意图

    1.2.2 密钥的生成

    图 1.2.2 16轮密钥生成图

      图1.2.2是使用56比特密钥的方法。密钥首先通过一个置换函数PC_1,然后,对加密过程的每一轮,通过一个左循环移位和一个置换PC_2产生一个子密钥。其中每轮的置换都相同,但由于密钥被重复迭代,所以产生的每轮子密钥不相同。

    1.2.3 DES解密

      和Feistel密码一样,DES的解密和加密使用同一种算法,但子密钥使用的顺序相反。

    2. Python代码实现

    2.1 实现思路

      由于加密与解密算法类似,此处给出加密算法实现思路:
      Step1:从文件中读取明文;
      Step2:将明文利用ASCII换成01比特流;
      Step3:将明文比特流每64位分为一组,最后不足的用0补齐;
      Step4:对64位比特加密操作(进行IP置换,16轮的Feistel变换、交换L、R、IP逆置换,将L、R合并为密文比特流);
      Step5:将每一组密文比特流合并转换成密文字符保存至文件。

    2.2 模块化程序设计

    2.2.1 各个模块调用关系及实现功能设计

    图2.2.1 各个模块调用关系及实现功能设计

      根据2.1中的实现思路,DES加解密算法各个模块调用关系及实现功能设计如图2.2.1所示,2.2.2中将详细介绍各个功能的代码实现。

    2.2.2 模块功能实现

      针对2.2.1的实现思路,分析DES加解密算法流程,可将其具体分成不同的模块分别设计:
    1.)文件读入模块

    def read_file(filename): 
        '''
        filename : 打开文件名
        return : 读取文件中字符串
        '''
        try:
            fp = open(filename,"r",encoding='utf-8')
            message = fp.read()
            fp.close()
            return message
        except:
            print("Open file error!")
    

    2.)文件写入模块
      将字符串写入文件text.txt与文件读入代码类似,只做如下修改:

            fp = open('text.txt','w',encoding='utf-8')
            fp.write(message)
    

      def write_file(message): 输入需要写入字符串,即可生成含有该字符串的text.txt文件。

    3.)字符串转01比特流

    def str_bit( message ):
        '''
        message :字符串
        return :将读入的字符串序列转化成01比特流序列
        '''
        bits = ""
        for i in message:
            asc2i = bin(ord(i))[2:] #bin将十进制数转二进制返回带有0b的01字符串
            '''为了统一每一个字符的01bit串位数相同,将每一个均补齐8位'''
            for j in range(8-len(asc2i)):
                asc2i = '0' + asc2i
            bits += asc2i
        return bits 
    

      每一个字符利用ord( )函数转化成对应ASCII值,利用bin( )将其转换成二进制字符串。
    4.)01比特流转字符
      def bit_str(bits): 输入01比特串(长度要是8的倍数),返回对应的字符,核心代码如下,主要利用int( )和chr( )函数。

        for i in range(len(bits)//8):
            temp += chr(int(bits[i*8:(i+1)*8],2))
    

    5.)密钥字符串转比特流
      本文假定密钥比特流的8、16、24、32、40、48、56、64位采用偶校验方式,分别校验其前面的7位01串。密钥字符串依然采用ASCII编码方式,一个字符占7位,第8位采用偶校验方式,核心代码如下:

    def process_key(key):
        '''
        key : 输入的密钥字符串
        return : 64bit 01序列密钥(采用偶校验的方法) 
        '''
        key_bits = ""
        for i in key:
            count = 0
            asc2i = bin(ord(i))[2:] 
            '''将每一个ascii均补齐7位,第8位作为奇偶效验位''' 
            for j in asc2i:
                count += int(j)
            if count % 2 == 0:
                asc2i += '0'
            else:
                asc2i += '1' 
            for j in range(7-len(asc2i)):
                asc2i = '0' + asc2i
            key_bits += asc2i
        if len(key_bits) > 64:
            return key_bits[0:64]
        else:
            for i in range(64-len(key_bits)):
                key_bits += '0'
            return key_bits 
    

    6.)对比特流分组
      函数定义如下,最后一组位数不足即补0。实现简单,此处不在赘述。

    def divide(bits,bit):
        '''
        bits : 将01bit按bit一组进行分组 
        return : 按bit位分组后得到的列表
        '''
    

    7.)IP置换
      为了实现简单,提前将IP、IP_RE、PC_1、PC_2、E、P、S等盒值写入文件DES_BOX.py,主函数即可直接调用。IP置换实现如下:

    def IP_change(bits):
        '''
        bits:一组64位的01比特字符串   
        return:初始置换IP后64bit01序列
        '''
        ip_str = ""
        for i in IP:
            ip_str = ip_str + bits[i-1]
        return ip_str
    

    8.)PC_1置换
      实现代码同IP置换,此处不在赘述。
    9.)比特串左移
      def key_leftshift(key_str,num): 将输入的01比特流key_str循环左移num位返回,实现过于简单,此处不在赘述。
    10.)PC_2置换
      实现代码同IP置换,此处不在赘述。
    11.)16轮密钥生成

    def generate_key(key):
        '''
        key : 64bit01密钥序列
        return : 16轮的16个48bit01密钥列表按1-16顺序
        '''
        key_list = ["" for i in range(16)]
        key = PC_1_change(key) #1、调用置换PC_1
        key_left = key[0:28] #2、左右28位分开
        key_right = key[28:]
        for i in range(len(SHIFT)): #共16轮即16次左循环移位
            key_left = key_leftshift(key_left, SHIFT[i]) #3、调用比特串左移函数
            key_right = key_leftshift(key_right, SHIFT[i]) 
            key_i = PC_2_change(key_left + key_right) #4、左右合并调用置换PC_2
            key_list[i] = key_i #5、将每一轮的56bit密钥存入列表key_list
        return key_list
    

    12.)E置换
      实现代码同IP置换,此处不在赘述。
    13.)异或运算
      函数实现较为简单,将输入的两个字符串逐位运算即可,仅给出定义如下。

    def xor(bits,ki):
        '''
        bits : 48bit01字符串 / 32bit01 F函数输出
        ki : 48bit01密钥序列 / 32bit01 Li
        return :bits与ki异或运算得到的48bit01 / 32bit01 
        ''' 
    

    14.)单次S盒查找

    def s(bits,i):
        '''
        bits : 6 bit01字符串
        i : 使用第i个s盒
        return : 4 bit01字符串
        '''
        row = int(bits[0]+bits[5],2) 
        col = int(bits[1:5],2)
        num = bin(S[i-1][row*16+col])[2:]  #i-1号S盒的row*16+col号数
        for i in range(4-len(num)):    #补齐4位后输出
            num = '0'+num
        return num
    

    15.)S盒变换
      def S_change(bits): 输入48bit字符串,输出经过S盒之后的32bit字符串。核心代码如下,调用8次单次S盒查找函数:

        for i in range(8):
            temp = bits[i*6:(i+1)*6]
            temp = s(temp,i+1)
            s_change += temp
    

    16.)P置换
      实现代码同IP置换,此处不在赘述。
    17.)F函数
      通过调用12-16模块即可实现第 i i i轮F函数运算:

    def F(bits,ki):
        '''
        bits : 32bit 01 Ri输入
        ki : 48bit 第i轮密钥
        return : F函数输出32bit 01序列串
        '''
        bits = xor(E_change(bits),ki)
        bits = P_change(S_change(bits))
        return bits
    

    18.)IP逆置换
      实现代码同IP置换,此处不在赘述。
    19.)64bit加密
      调用IP置换、16轮密钥生成、F函数、异或运算、IP逆置换等模块可以实现64bit一组明文的加密:

    def des_encrypt(bits,key):
        '''
        bits : 分组64bit 01明文字符串
        key : 64bit01密钥
        return : 加密得到64bit 01密文序列
        '''
        bits = IP_change(bits)  # IP置换
        L = bits[0:32]          # 切片分成两个32bit
        R = bits[32:]
        key_list = generate_key(key) # 生成16个密钥  
        for i in range(16):       # 16轮迭代变换
            L_next = R
            R = xor(L,F(R,key_list[i]))
            L = L_next
        result = IP_RE_change( R + L)  # IP逆置换
        return result
    
    

    20.)64bit解密
      def des_decrypt(bits,key):该模块与64bit加密模块流程相同,不同在于16个密钥使用顺序相反,16轮代换代码如下,其余代码同加密。

        for i in range(16):
            L_next = R
            R = xor(L,F(R,key_list[15-i]))
            L = L_next
    

    21.)整体加密模块
      def all_des_encrypt(message,key): 读入明文字符串message,以及密钥字符串key,返回加密后01比特流。通过调用字符串转01比特流、密钥字符串转比特流、对比特流分组、64bit加密等模块即可实现:

    def all_des_encrypt(message,key):
        '''
        message : 读入明文字符串
        key : 读入密钥串
        returns : 密文01序列
        '''
        message = str_bit(message)  # 明文转01比特流
        key = process_key(key)      # 64bit初始密钥生成
        mess_div = divide(message, 64)  # 明文按64bit一组进行分组
        result =""
        for i in mess_div:
            result += des_encrypt(i, key)  #对每一组进行加密运算
        return result    
    

    22.)整体解密模块
      def all_des_decrypt(message,key): 读入明文字符串message,以及密钥字符串key,返回解密后01比特流。与加密类似,此处不在赘述。

    2.2.3 主模块

      输出提示语,并与用户交互。通过调用文件读入或写入、字符串转01比特流、比特流转01字符串、加解密等模块实现,伪代码如下:

    2.3 Python源代码

      全部代码及相关注释点这里github

    2.4 关于密钥的说明

      起初按如下方式生成64bit密钥,即将密钥中每一个字符转成8bitASCII码,8个字符共构成64bit密钥。

    def process_key(key):
    	bin_key = str_bit(key)  #调用字符串转01比特流模块
    	return bin_key
    

      结果发现“wuzhenll”和“vt{idomm”这两个密钥加密后的密文相同。
      这是因为表面上这两个密码迥然不同,但是由于它们仅在奇偶校验位上有区别。例如,w的ASCII为01110111,v的ASCII为01110110,仅仅只在最后一位有区别。
      由于64位密钥中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在PC_1置换时去掉了这8位。如果输入的密码只是在这8位上有区别的话,那么操作后的结果也将是一样的。所以用这两个密码进行加密解密操作得到的结果是一样的。

    2.5 使用说明

      运行环境: Python 3.7
      使用方法: 将DES_BOX.py、DES.py、以及需要含有明密文的文本文件放置于同一目录下,运行DES.py程序,根据相应提示语即可完成操作。明文加密后乱码会自动保存到text.txt文件中。(注:输入的密钥将转化成对应的ASCII按照偶校验的方式构成64bit初始密钥)

    2.6 结果测试

    测试一:明文:keep early hours! 密钥:password

    测试二: 明文:Have a good day! 密钥:messagee

    参考文献

    DES算法原理完整版

    DES加解密python实现

    DES算法中密钥的校验位

    展开全文
  • DES加密python源码

    2019-02-03 11:53:29
    DES加密算法python源码,分放main、rule(变换规则)、function(变换操作)
  • DES是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。它的密钥长度是56位(因为每个第8 位都用作奇偶校验),密钥可以是任意的56位的数,而且可以任意时候改变。Python代码: ...
    全称:数据加密标准(Data Encryption Standard),属于对称加密算法。DES是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。它的密钥长度是56位(因为每个第8 位都用作奇偶校验),密钥可以是任意的56位的数,而且可以任意时候改变。Python代码:
    import binascii
    from pyDes import des, CBC, PAD_PKCS5
    # 需要安装 pip install pyDes
    
    def des_encrypt(secret_key, s):
        iv = secret_key
        k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        en = k.encrypt(s, padmode=PAD_PKCS5)
        return binascii.b2a_hex(en)
    def des_decrypt(secret_key, s):
        iv = secret_key
        k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        de = k.decrypt(binascii.a2b_hex(s), padmode=PAD_PKCS5)
        return de
    
    secret_str = des_encrypt('12345679', 'I love YOU~')#des 的尺寸为8
    print(secret_str)#加密的密钥
    clear_str = des_decrypt('12345679', secret_str)#解密的过程跟加密的过程密钥应该是一致的。
    print(clear_str)#输出明文
    展开全文
  • 主要介绍了DES加密解密算法python实现版,图文并茂的为大家分享一下,需要的朋友可以参考下
  • 基于Python实现的DES加密算法

    千次阅读 2019-07-24 19:26:29
    DES算法是利用56 + 8奇偶校验位 = 64位的密钥对以64位为单位的数据块进行加密和解密。它的加密与解密实现首先是要生成一套加密密钥,用户输入一个64位长的密码,然后通过等分、移位、选取和迭代形成一套16个加密密钥...

    一、算法描述

    DES算法是利用56 + 8奇偶校验位 = 64位的密钥对以64位为单位的数据块进行加密和解密。它的加密与解密实现首先是要生成一套加密密钥,用户输入一个64位长的密码,然后通过等分、移位、选取和迭代形成一套16个加密密钥,分别用于之后的每一轮运算。

    点击此处下载文档和源码

     

     

    展开全文
  • python实现DES加密算法的ECB,CBC,CTR3中模式的加密和解密
    • 流程图
      DES

    • f_package.py文件

    # 字符变成2进制
    def str_to_bin(s):
        res = []
        for c in s:
            tem = bin(ord(c)).replace('b', '')
            # 转为字符串时,后7位中,如果存在前面为0,会自动去掉,需要加回来,使之满足8位
            if len(tem) < 8:
                tem = "0" + tem
            res.append(tem)
        return ''.join(res)
    
    
    # 2进制变成字符
    def bin_to_str(s):
        return ''.join([chr(e) for e in [int(b, 2) for b in [s[8 * j: 8 * (j + 1)] for j in range(int(len(s) / 8))]]])
    
    
    # 2机制到16进制
    def bin_to_hex(s):
        return ''.join([hex(e).replace('0x', '') for e in [int(b, 2) for b in [s[4 * j: 4 * (j + 1)] for j in range(int(len(s) / 4))]]]).upper()
    
    
    # 16进制到2进制
    def hex_to_bin(s):
        res = []
        for c in s:
            tem = bin(int(c, 16)).replace('0b', '')
            while True:
                if len(tem) < 4:
                    tem = "0" + tem
                else:
                    break
            res.append(tem)
        return ''.join(res)
    
    • f_fun.py文件
    key_table_l_1 = [49, 42, 35, 28, 21, 14, 7,
                     0, 50, 43, 36, 29, 22, 15,
                     8, 1, 51, 44, 37, 30, 23,
                     16, 9, 2, 52, 45, 38, 31]
    
    key_table_r_1 = [55, 48, 41, 34, 27, 20, 13,
                     6, 54, 47, 40, 33, 26, 19,
                     12, 5, 53, 46, 39, 32, 25,
                     18, 11, 4, 24, 17, 10, 3]
    
    key_table_l_2 = [13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,
                     22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1]
    
    key_table_r_2 = [12, 23, 2, 8, 18, 26, 1, 11, 22, 16, 4, 19,
                     15, 20, 10, 27, 5, 24, 17, 13, 21, 7, 0, 3]
    
    expand_table = [31, 0, 1, 2, 3, 4, 3, 4, 5, 6, 7, 8,
                    7, 8, 9, 10, 11, 12, 11, 12, 13, 14, 15, 16,
                    15, 16, 17, 18, 19, 20, 19, 20, 21, 22, 23, 24,
                    23, 24, 25, 26, 27, 28, 27, 28, 29, 30, 31, 0]
    
    s_boxes_table_1 = [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]
    
    s_boxes_table_2 = [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]
    
    s_boxes_table_3 = [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]
    
    s_boxes_table_4 = [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]
    
    s_boxes_table_5 = [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]
    
    s_boxes_table_6 = [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 ]
    
    s_boxes_table_7 = [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]
    
    s_boxes_table_8 = [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]
    
    s_boxes_table = [s_boxes_table_1, s_boxes_table_2, s_boxes_table_3, s_boxes_table_4,
                     s_boxes_table_5, s_boxes_table_6, s_boxes_table_7, s_boxes_table_8]
    
    p_box_table = [15, 6, 19, 20, 28, 11, 27, 16, 0, 14, 22, 25, 4, 17, 30, 9,
                   1, 7, 23, 13, 31, 26, 2, 8, 18, 12, 29, 5, 21, 10, 3, 24]
    
    
    def f_shift(key_, step):  # key_: 56bit
        return key_[step:] + key_[:step]
    
    
    def f_zero_fill(str_, num_1_, num_2_, pos_):
        if num_1_ < num_2_:
            for _ in range(num_2_ - num_1_):
                if pos_ == 'l':
                    str_ = '0' + str_
                if pos_ == 'r':
                    str_ = str_ + '0'
        return str_
    
    
    def f_sub_keys(key_):  # key: 56bit
        key_result = []
        key_l = [key_[key_table_l_1[_]] for _ in range(28)]
        key_r = [key_[key_table_r_1[_]] for _ in range(28)]
        for i in range(16):
            if i == 0 or i == 1 or i == 8 or i == 15:
                step = 1
            else:
                step = 2
            key_l = f_shift(key_l, step)
            key_r = f_shift(key_r, step)
            key_l_ = [key_l[key_table_l_2[_]] for _ in range(24)]
            key_r_ = [key_l[key_table_r_2[_]] for _ in range(24)]
            key_result.append(key_l_ + key_r_)
        return key_result  # key_result: list_16 48bit
    
    
    def f_xor(x, y):
        return [str(int(x[_]) ^ int(y[_])) for _ in range(len(x))]
    
    
    def f_expand(r_):
        return [r_[expand_table[_]] for _ in range(48)]
    
    
    def f_s_boxes(expand_):  # expand_ 48bit
        s_boxes_ = []
        for i in range(8):
            row = 2 * int(expand_[i * 6]) + int(expand_[i * 6 + 5])
            col = 8 * int(expand_[i * 6 + 1]) + 4 * int(expand_[i * 6 + 2]) + 2 * int(expand_[i * 6 + 3]) + int(expand_[i * 6 + 4])
            t_ = s_boxes_table[i][row * 16 + col]
            s_ = bin(s_boxes_table[i][t_])[2:]
            s_ = f_zero_fill(s_, len(s_), 4, 'l')
            s_boxes_.extend(s_)
        return s_boxes_  # 32bit
    
    
    def f_p_box(s_boxes_):  # 32bit
        return [s_boxes_[p_box_table[_]] for _ in range(32)]
    
    • des.py文件
    # ECB
    import f_fun as f
    import f_package as p
    
    
    # 按照DES算法的流程图进行运算
    def des(text, key_, flag_):  # text 2进制列表
        sub_keys = f.f_sub_keys(key_)  # 16个子密钥
        if flag_ == 1:
            sub_keys.reverse()
        L, R = text[:32], text[32:]
        for net in range(16):
            __ = R
            __ = f.f_expand(__)
            __ = f.f_xor(__, sub_keys[net])
            __ = f.f_s_boxes(__)
            __ = f.f_p_box(__)
            __ = f.f_xor(__, L)
            L, R = R, __
        return R + L
    
    
    def des_input_plain():
        input_ = input("请输入明文:")
        input_ = p.str_to_bin(input_)
        n_ = len(input_) // 64
        mod = len(input_) % 64
        if mod != 0:
            n_ = n_ + 1
            input_ = f.f_zero_fill(input_, mod, 64, 'r')
        return input_, n_
    
    
    def des_input_cipher():
        input_ = input("请输入16进制密文:")
        input_ = p.hex_to_bin(input_)
        n_ = len(input_) // 64
        return input_, n_
    
    
    def des_output_cipher(cipher_str_):
        print("---------加密----------")
        print("2进制密文:" + cipher_str_)
        print("16进制密文:", p.bin_to_hex(cipher_str_))
        print()
    
    
    def des_output_plain(plain_str_):
        print("---------解密----------")
        print("2进制明文:" + plain_str_)
        print("明文:", p.bin_to_str(plain_str_))
        print()
    
    
    d_xor = f.f_xor
    
    d_zero_fill = f.f_zero_fill
    
    • des_ecb.py文件
    # des_ecb
    import des as d
    import os
    if __name__ == '__main__':
        key = '01010010100110010101000100101001001101000101011001111000'
    
        #  ################# 加密 ##################  #
        plain, n = d.des_input_plain()
        cipher_str = ''
        for i in range(n):
            plain_text = plain[i*64: (i + 1) * 64]
            flag = 0
            cipher_str = cipher_str + ''.join(d.des(plain_text, key, flag))
        d.des_output_cipher(cipher_str)
    
        #  ################# 解密 ##################  #
        cipher, n = d.des_input_cipher()
        plain_str = ''
        for i in range(n):
            cipher_text = cipher[i * 64: (i + 1) * 64]
            flag = 1
            plain_str = plain_str + ''.join(d.des(cipher_text, key, flag))
        d.des_output_plain(plain_str)
        os.system("pause")
    
    • des_cbc.py文件
    # des_cbc
    import des as d
    import os
    if __name__ == '__main__':
        key = '01010010100110010101000100101001001101000101011001111000'
        IV = '0101110001000010100101000101110110001000100110010001111000010000'
    
        #  ################# 加密 ##################  #
        plain, n = d.des_input_plain()
        iv = IV
        cipher_str = ''
        for i in range(n):
            plain_text = plain[i * 64: (i + 1) * 64]
            flag = 0
            iv = d.des(d.d_xor(iv, plain_text), key, flag)
            cipher_str = cipher_str + ''.join(iv)
        d.des_output_cipher(cipher_str)
    
        #  ################# 解密 ##################  #
        cipher, n = d.des_input_cipher()
        iv = IV
        plain_str = ''
        for i in range(n):
            cipher_text = cipher[i * 64: (i + 1) * 64]
            flag = 1
            t_ = d.d_xor(iv, d.des(cipher_text, key, flag))
            iv = cipher_text
            plain_str = plain_str + ''.join(t_)
        d.des_output_plain(plain_str)
        os.system("pause")
    
    • des_ctr.py文件
    # des_ctr
    import des as d
    import os
    if __name__ == '__main__':
        key = '01010010100110010101000100101001001101000101011001111000'
        IV = '0101110001000010100101000101110110001000100110010001111000010000'
    
        #  ################# 加密 ##################  #
        plain, n = d.des_input_plain()
        iv = IV
        cipher_str = ''
        for i in range(n):
            plain_text = plain[i * 64: (i + 1) * 64]
            flag = 0
            _t = d.des(iv, key, flag)
            cipher_str = cipher_str + ''.join(d.d_xor(plain_text, _t))
            iv = bin(int(iv, 2) + 1)[2:]
            iv = d.d_zero_fill(iv, len(iv), 64, 'l')
        d.des_output_cipher(cipher_str)
    
        #  ################# 解密 ##################  #
        cipher, n = d.des_input_cipher()
        iv = IV
        plain_str = ''
        for i in range(n):
            cipher_text = cipher[i * 64: (i + 1) * 64]
            flag = 0
            _t = d.des(iv, key, flag)
            plain_str = plain_str + ''.join(d.d_xor(cipher_text, _t))
            iv = bin(int(iv, 2) + 1)[2:]
            iv = d.d_zero_fill(iv, len(iv), 64, 'l')
        d.des_output_plain(plain_str)
        os.system("pause")
    
    展开全文
  • 对称加密算法——DES算法(python实现)

    万次阅读 多人点赞 2017-10-25 17:45:23
    对称加密算法——DES算法(python实现) 感谢深信服技术详解~ 一、DES算法描述    DES算法总的说
  • 2. 统计DES算法在密钥固定情况,输入明文改变1位、2位,。。。64位时。输出密文位数改变情况。 3. 统计DES算法在明文固定情况,输入密钥改变1位、2位,。。。64位时。输出密文位数改变情况。 为了具有客观性,2,3...
  • python实现DES加密算法

    2020-12-05 13:27:02
    1.[代码][Python]代码#coding=utf-8from functools import partialclass DES(object):"""DES加密算法interface: input_key(s, base=10), encode(s), decode(s)"""__ip = [58,50,42,34,26,18,10,2,60,52,44,36,28,20,...
  • 本文实例讲述了python实现DES加密解密方法。分享给大家供大家参考。具体分析如下:实现功能:加密中文等字符串密钥与明文可以不等长这里只贴代码,加密过程可以自己百度,此处python代码没有优化1. desstruct.py DES...
  • Python——加密算法DES

    2021-10-30 19:59:05
    目录 加密算法DES介绍 DES框架 DES实现 可视化 打包成可执行文件EXE 加密算法DES介绍 DES框架 DES实现 可视化 打包成可执行文件EXE
  • DES算法加密——python实现

    千次阅读 2018-04-04 22:53:55
    DES自公布以来,一直是国际商用通信和计算机通信最常用的加密算法。原定使用期10年,超期服役到2000年。DES对其后出现的大量分组密码加密算法的设计都产生了很大的影响,他们从中借鉴和吸取了宝贵的经验。二、基础...
  • python实现DES加密算法(超级详细)

    千次阅读 2020-05-25 17:58:39
    14,2,3,12, S_box8.txt: 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, 由于我们在加密过程中...
  • DES 加密数据通用 四种语言的加密解密 。
  • 下面小编就为大家分享一篇Python和Java进行DES加密和解密的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • DEC加密—CBC模式加解密python源码。支持文本的加解密,模块化方便提取复用。
  • 生活中我们经常会遇到一些加密算法,今天我们就聊聊这些加密算法Python实现。部分常用的加密方法基本都有对应的Python库,基本不再需要我们用代码实现具体算法。 MD5加密 全称:MD5消息摘要算法(英语:MD5 Message...
  • 本文实例讲述了Python基于DES算法加密解密... DES加密算法 interface: input_key(s, base=10), encode(s), decode(s) """ __ip = [ 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,5
  • 为了加深对DES加密算法的理解,lvchen很贴心地布置了一道手算DES加密结果的题,从昨晚回寝算到今天中午才写完,主要是花时间把代码逻辑实现了一遍,加深记忆也便于后续重复使用。 笔者参考了经典的DES算法详解这篇...
  • Python实现DES加密算法

    2020-12-11 12:16:45
    这是学校专业课程设计,要求实现112位的密钥长度的DES算法,与原有的DES算法不同的是密钥长度不懂,但是每轮的子密钥长度依然是56(64)位的。由于那阶段事情较多,为了早些完成,就选用的Python编程语言,参考了一个...
  • 使用python实现DES的加解密操作 输入:16位的16进制数 输出: import random import numpy as np def base_key_product(): # 密钥随机生成 base_key = [] for i in range(64): base_key.append(random.choice...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,178
精华内容 1,671
关键字:

des加密算法python

python 订阅