DES算法的加解密实现-python语言

最新推荐文章于 2024-09-16 14:49:33 发布
最新推荐文章于 2024-09-16 14:49:33 发布
阅读量200 收藏 1
点赞数 1
文章标签： python 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43260858/article/details/119327915
版权

目录


网课推荐 武汉大学的密码学课程，老师讲的很不错。

DES简要分析

DES的关键模块分析

实验结果

在这里插入图片描述

源代码

# --------------生成密钥需要的数组 ---------------
# 置换选择1
PC_1tab = [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]
# 置换选择2
PC_2tab = [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]
# 循环左移位数表
Left_move = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

# --------------加密过程需要的数组 ---------------
# 初始置换IP表，将原始明文打乱
IPtab = [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]

#逆初始置换IP-1表
tIPtable=[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]

# 选择运算E的矩阵，将32位的R变为48位，方便与子密钥异或
E = [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]

# des算法s盒
S=[[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表
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]

# ----------------------产生16个子密钥----------------------

# 置换函数
def zhihuan(s, tab):
    # 计算置换表长度
    length = len(tab)
    list = []
    for i in range(0, length):
        temp = tab[i]
        # 找到s中temp位的数据，依次加入list中
        list.extend(str(s[temp - 1]))
    # 字符串连接
    s_new = "".join(list)
    return s_new


# 循环左移函数
# 法二：令字符串Arr.extend(Arr)(即Arr=Arr+Arr)，取新的字符串Arr_new=Arr[m+1:len(Arr)+m](即m+1到len(Arr)+m位)
def LeftMove(Arr, i):
    # 取出要左移的位数
    m = Left_move[i]
    # 定义空数组临时存放
    Arr_new = []
    # 开始左移
    for j in range(m, 28):
        Arr_new.append(Arr[j])
    for j in range(0, m):
        Arr_new.append(Arr[j])
    # print(Arr_new)
    return Arr_new


# 子密钥生成函数
def Gen_key(key):
    # print("第一步生成子密钥")
    Kkid = []  # 子密钥存放列表
    # 置换选择1
    s = zhihuan(key, PC_1tab)
    C = s[0:28]
    D = s[28:56]
    # print("C_0:"+str(C))
    # print("D_0:" + str(D))
    # 16次的循环左移及转换选择2，以生成子密钥K
    for i in range(0, 16):
        C = LeftMove(C, i)
        D = LeftMove(D, i)
        # 将C和D合并成56位中间数据
        CD = C + D
        # 置换选择2从中选择出一个48位的子密码Ki
        key = zhihuan(CD, PC_2tab)
        Kkid.append(key)
        # print("第%d个子密钥为:%s"%(i+1,str(key)))
    return Kkid


# ----------------------------加密----------------------------
# 异或函数,相同为0,不同为1
def XOR(s1, s2):
    strlen = len(s1)
    s3 = []
    for i in range(0, strlen):
        s3.extend(str(int(s1[i]) ^ int(s2[i])))
    s4 = "".join(s3)
    return s4


#S盒将输入的六位，前两位做行数，中间四位做列数
def Fun_S(f,subst_Arr):
    b=[]
    for i in range(0,8):
        row=int(f[i*6])*2+int(f[i*6+5])
        col=int(f[i*6+1])*8+int(f[i*6+2])*4+int(f[i*6+3])*2+int(f[i*6+4])
        result=subst_Arr[i][row*16+col]
        #print(result)
        a=[]
        for i in range(0,4):
            #每次都在最前面插入
            a.insert(0,str(result%2))
            result=int(result/2)# 注意加int，因为忘记加int而出现很多位小数
        b.extend(a)
    c = "".join(b)
    #print("S盒的结果(32位):"+c)
    return c



def Fun_f(R, key):
    # 选择运算E，将32位的R变为48位，方便与子密钥异或
    R_new = zhihuan(R, E)
    # 与子密钥异或
    f = XOR(R_new, key)
    #print("子密钥加："+str(f))
    # 利用S盒将48位转为32位
    S_result=Fun_S(f,S)
    # 置换算法P把S盒输出的32位数据打乱重排
    P_result=zhihuan(S_result,P)
    #print("P置换："+P_result)
    return P_result


# 加密函数，调用上述几个函数
def Encryption(MingWen, Kkid):
    # 使用初始置换Ip实现第一步密码变换
    Ipzhihuan = zhihuan(MingWen, IPtab)
    print("初始置换：%s" % (str(Ipzhihuan)))
    L = Ipzhihuan[0:32]
    R = Ipzhihuan[32:64]
    for i in range(0, 16):
        temp=Fun_f(R, Kkid[i])
        R_new=XOR(L,temp)
        print("第%d个L：%s" % (i + 1, R))
        print("第%d个R：%s\n" % (i + 1, R_new))
        L=R
        R=R_new
    # 使用逆初始置换IP-1，生成最终密文
    MiWen=zhihuan(R+L,tIPtable)
    print("密文："+MiWen+'\n\n')
    return MiWen


# ----------------------------解密----------------------------

# 将64位密文当做明文输入，第一次使用密钥K16
def Decryption(MiWen,Kkid):
    # 初始置换Ip
    Ipzhihuan = zhihuan(MiWen, IPtab)
    print("解密初始置换：%s" % (str(Ipzhihuan)))
    L = Ipzhihuan[0:32]
    R = Ipzhihuan[32:64]
    '''相比于加密，多定义变量m,使密钥从16开始使用'''
    m=15
    for i in range(0, 16):
        temp=Fun_f(R, Kkid[m])
        R_new=XOR(L,temp)
        print("第%d个L：%s" % (i + 1, R))
        print("第%d个R：%s\n" % (i + 1, R_new))
        L=R
        R=R_new
        m=m-1
    # 使用逆初始置换IP-1，生成最终密文
    MingWen=zhihuan(R+L,tIPtable)
    print("解密后明文："+MingWen)
    return MingWen


# ----------------------------加解密----------------------------
# 因为加密函数与解密函数，大部分代码重合，现利用if函数将其合并
def En_De_cryption(text, Kkid,method):
    # 使用初始置换Ip实现第一步密码变换
    Ipzhihuan = zhihuan(text, IPtab)
    #print("初始置换：%s" % (str(Ipzhihuan)))
    L = Ipzhihuan[0:32]
    R = Ipzhihuan[32:64]
    for i in range(0, 16):
        if(method=='1'):
            temp=Fun_f(R,Kkid[i])
        else:
            temp=Fun_f(R, Kkid[15-i])
        R_new=XOR(L,temp)
        #print("第%d个L：%s" % (i + 1, R))
        #print("第%d个R：%s\n" % (i + 1, R_new))
        L=R           #新的L是上一阶段的R
        R=R_new       #新的R是由F函数及XOR异或L得到的
    # 使用逆初始置换IP-1，生成最终密文
    text_new=zhihuan(R+L,tIPtable)
    return text_new


# ----------------------------优化部分----------------------------
# 针对问题：1.输入字符串必须是二进制格式；2.输入字符串必须是64位
# 字符串转为二进制,一个字符转为八位的二进制
def StrToBinary(text):
    temp=""
    for i in text:
        # 找到字节对应ASCII值
        a=ord(i)
        # 将ASCII值转化为二进制
        b=bin(a)
        if len(b)==8:
            b='00'+b[2:]
        else:
            b='0'+b[2:]
        temp=temp+b
    return temp


# 二进制转字符串
def BinaryToStr(text):
    temp=''
    m=int(len(text)/8)
    for i in range(0,m):
        n = text[i*8]+'0'+text[i*8+1:i*8+8]
        x = chr(int(n, 2))
        temp=temp+x
    return temp


# 不够64位补0
def deal_text(text):
    while (len(text) < 64):
        text = text + '0'
    return text


# ----------------------------主函数----------------------------
if __name__ == '__main__':

    # 自定义密钥及明文
    '''
    key = "0011000100110010001100110011010000110101001101100011011100111000"
    MingWen = "0011000000110001001100100011001100110100001101010011011000110111"
    # 得到16个子密钥
    Kkid = Gen_key(key)
    # 加密
    MiWen=Encryption(MingWen, Kkid)
    # 解密
    MingWen_new=Decryption(MiWen,Kkid)
    '''

    # 优化一：程序可一直加解密，按退出键才可退出程序
    '''
    # 加解密函数
    method=input('1.加密\n2.解密\n按换行键或其他数字，可退出，请输入要选择的操作(数字)：\n')
    while method.strip()!=""and(method=='1' or method=='2'):
        method=int(method)
        MingWen=input("请输入待加密/带解密的文本：\n")
        text=En_De_cryption(MingWen,Kkid,method)
        if(method=='1'):
            print("加密后得到的密文为："+text)
        else:
            print("解密后得到的明文为："+text)
        print('--------------------------------------------------------------------------------')
        method = input('1.加密\n2.解密\n按换行键可退出，请输入(数字)：\n')
    '''

    # 优化二：密钥及明文可输入八位以内的字母数字，例如abcd1234
    method = input('1.加密\n2.解密\n按换行键或其他数字，可退出，请输入要选择的操作(数字)：\n')
    while method.strip() != "" and (method == '1' or method == '2'):
        # 文本
        if method=='1':
            text = input("请输入待加密文本(8位的字母串)：\n")  # 一个字母转为二进制占8字节
            text = StrToBinary(text)  # 字母转二进制
        if method=='2':
            text = input("请输入待解密二进制串：\n")
        text = deal_text(text)  # 如果不满足64位，则后面补0

        # 密钥
        miyao = input("请输入密钥(8位的字母串)：\n")
        miyao=StrToBinary(miyao)
        miyao = deal_text(miyao)
        zimiyao=Gen_key(miyao)

        # 加解密
        result=En_De_cryption(text,zimiyao,method)
        print("处理结果为：" + result)
        if method== '2':
            print('解密后明文为：'+BinaryToStr(result))
        print('--------------------------------------------------------------------------------')
        method = input('1.加密\n2.解密\n按换行键或其他数字，可退出，请输入要选择的操作(数字)：\n')
bling-bling-bling
关注
python实现AES，DES加解密算法
景天科技苑
01-05 1万+
对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥（mi yao）一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。
python实现Simplified_DES （S-DES）
weixin_43386443的博客
10-07 693
https://codereview.stackexchange.com/questions/108057/simplified-des-encryption 1. 源码修正后： FIXED_IP = [2, 6, 3, 1, 4, 8, 5, 7] FIXED_EP = [4, 1, 2, 3, 2, 3, 4, 1] FIXED_IP_INVERSE = [4, 1, 3, 5, 7, 2, 8, 6] FIXED_P10 = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] FIXE.
DES加解密算法
qq_44763755的博客
12-07 4565
DES算法以及其C语言实现 算法简介 DES(Data Encrytion Standard)算法，又被称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。 DES算法属于对称加密算法，加密解密公用一套算法。 明文按64位进行分组，密钥长64位但实际上只有56位参与DES运算（第8、16、24、32、40、48、56、64位是奇偶校验位）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。 首先要生成一套加密密钥，从用户处取得一个64位长的密码口令，然后通过等分
DES算法全解+C语言实现（加密和解密）
VistorsYan的博客
04-18 1万+
DES算法全解 一、什么是DES算法 DES是(Data Encryption Standard）的缩写，为密码体制中的对称密码体制，又被称为美国数据加密标准。 DES是一种分组密码。明文，密文，密钥的分组长度都是64位。 DES是面向二进制的密码算法。因而能够加解密任何形式的计算机数据。 DES是对合运算，因而加密和解密共用同一算法，从而使工程实现的工作量减半 DES的密码结构属于Feistel结构 二、DES的加密过程 64位秘钥经子秘钥产生算法产生出16个子秘钥：K1,K2,...,K16K_1
javaweb的问卷调查系统-JAVA【数据库设计、源码、开题报告】
laowang8的博客
11-20 3413
例如，一个数据提交（操作请求）的标准流程：在问卷管理模块中的添加问卷页面（SurveyAdd.jsp），用户在这个页面中输入数据，提交之后，请求被派发到一个名为SurveyManage的servlet中集中处理，在这个servlet中，调用了持久层的名为SurveyDAO 的javabean的addSurvey方法对数据进行持久化，然后把处理结果返回给SurveyMange这个控制器，控制器根据返回的结果决定将相应的页面展现给客户端浏览器。系统中所以的数据库实体，都被封装成了这样的VO。
DES加密算法介绍（含例子）
dieyuqi2955的博客
08-29 4274
http://www.hankcs.com/security/des-algorithm-illustrated.html DES（Data Encryption Standard）算法是世界上最常用的加密算法。在很长时间内，许多人心目中“密码生成”与DES一直是个同义词。 DES是怎么工作的？本文通过一个简单的例子来一部一部展示DES的加密流程。自动DES诞生以来，许多加密算法都采...
2024年Python最全python实现DES算法加解密_python des加解密
2401_84584682的博客
04-30 1204
秘钥左移的位数try:f.close()print(“文件读取成功”)print(“文件读取失败”)try:f.close()print(“文件写入成功”)print(“文件写入失败”)#在分组加解密的时候 我们再bit级上进行操作 ，这里将字符ascii转bit流# 字符串转2进制(bit流) 每个字符8个bit 不够补0res = “”res += tmpreturn res#初始置换IP。
DES加解密算法及其python实现
weixin_45181522的博客
01-15 2873
就当为CSDN这方面的python开源做点贡献哈哈哈 DES DES介绍 算法原理 （ps：原理内容有点多，这里就不写啦，想知道的话辛苦读者自己找找喔，下面直接放我的代码。） python代码 #7.用DES算法完成数据的加密和解密 class DES(): def __init__(self,k0:str,lan):#k0为初始密钥，64bit，任意二进制长度为64位的数字、字母、汉字的组合 k0str=k0 if lan==0:self.lang
python实现对称加解密3DES算法
热门推荐
timerring的博客
07-09 1万+
In this program, you are required to implement the 3DES algorithm using the provided encrypt and decrypt function of DES. The encrypt and decrypt method of 3DES should also be pure functions, i.e. without side effects.Your program does the following:Read a
Python基于DES算法加密解密实例
09-21
主要介绍了Python基于DES算法加密解密实现方法,以实例形式分析了DES算法实现加密解密的相关技巧,需要的朋友可以参考下
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 385
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
Python办公自动化案例（二）：对比两个Excel数据内容并标出不同
衍生星球的博客
09-14 368
在数据处理和分析的日常工作中，我们经常需要比较两个Excel文件的差异。这可能是为了验证数据的一致性、检查数据的准确性，或者在版本控制中追踪更改。手动比较这些文件不仅耗时，而且容易出错。幸运的是，Python的openpyxl库提供了一种自动化这一过程的方法。
Tcl lnit error: Can’t find a usable init.tcl in the following directories 问题解决
梦想闹钟
09-15 277
实际研究后发现，其实py2exe已经把打包需要的lib放在dist文件夹下了，但是打包后的程序运行后却没有去lib下找，而是去找系统自带的环境变量里找，所以找不到。这个问题出现在我用py2exe打包了一个包含tkinter的图形化界面，在当前电脑上运行无问题，在移动到新电脑上后提示报错、getcwd用于获取当前工作目录绝对路径，在设置环境的变量的时候它用的是绝对路径-所以也导致了在当前电脑上能用而移动后不能用。解决方法是在你的程序里重新设置下环境变量，而且是用相对路径的形式。
JUC从实战到源码：中断机制与API实现
qq_43843951的博客
09-12 1138
在Java中，线程中断是一种机制，用于通知线程应该停止当前正在执行的任务。中断通常用于协同线程之间的合作，以便让线程在适当的时候终止其工作，尤其是在长时间运行的任务或阻塞操作中。通过学了多线程以及synchronized的相关知识，接下来就到了学习线程中断知识。
opencv学习：calcHist 函数绘制图像直方图及代码实现
mohanyelong的博客
09-13 1456
opencv学习：calcHist 函数绘制图像直方图及代码实现
基于机器学习的乳腺癌肿瘤智能分析预测系统
最新发布
Python极客之家
09-16 795
本系统致力于通过分析肿瘤的各种特征，如半径、纹理、形状等，利用Matplotlib、Seaborn 等工具进行可视化统计分析，并建立机器学习模型来预测肿瘤是否为恶性，测试集预测 AUC 达到 98.441%。系统的设计目的是为了帮助医疗专业人员更快地做出决策，并为患者提供更及时的治疗方案。
面试真题 | web自动化关闭浏览器，quit()和close()的区别
NHB234567的博客
09-13 326
关闭所有的浏览器窗口，销毁driver操作，则需要使用的是quit方法；当打开了多个窗口，只想要关闭非最后一个窗口的时候，使用的是close方法。这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！close():只关闭当前的浏览器标签页，如果当前浏览器标签页剩下最后一个，则所有标签页面退出。是否编写过对应浏览器退出的测试用例。quit():所有的浏览器窗口退出。关闭当前的标签页，其他窗口不退出。退出当前所有的窗口；
Python——俄罗斯方块
2302_81225694的博客
09-14 1002
这段代码使用了Pygame库来实现游戏的图形界面，通过键盘控制方块的移动和旋转。游戏循环不断更新方块的位置和网格状态，并绘制在屏幕上。在方块达到底部或无法继续移动时，判断是否有满行，并清除满行的方块。游戏会根据方块的状态和移动情况不断更新，直到无法继续下落为止，游戏结束。俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。请注意，这只是一个简单的示例，可能还有一些功能和优化方面的改进。您可以根据自己的需求进行修改和扩展。
Python实现DES加密解密详细教程
"本文将详细介绍如何在Python中实现DES（Data Encryption Standard）加密解密方法，通过实例分析Python实现DES加密与解密的核心技巧。" DES（数据加密标准）是一种广泛应用的块密码算法，它使用56位的密钥对64位的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值