DES加密与解密 (python) (附实例测试)

最新推荐文章于 2024-02-02 10:19:06 发布
最新推荐文章于 2024-02-02 10:19:06 发布
阅读量2.7k 收藏 15
点赞数 4
分类专栏： ❥Cryptography
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lancecrazy/article/details/89079182
版权

文章目录

1 代码

1.1 密码表

##--------------------------imperative矩阵--------------------------
#这些矩阵使用时下标记得要减一
#IP置换作用于进行16轮f函数作用之前，IP逆置换作用于16轮f函数作用之后
#IP置换表
IP_table=[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置换表
_IP_table=[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
]

#每一个S-盒的输入数据是6位，输出数据是4位，但是每个S-盒自身是64位
#设入的六位为b1,b2,b3,b4,b5,b6，b1、b6位组合得到列号，b2,b3,b4,b5组合得到行号。
#S盒中的S1盒
S1=[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盒中的S2盒
S2=[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盒中的S3盒
S3=[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盒中的S4盒
S4=[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盒中的S5盒
S5=[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盒中的S6盒
S6=[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盒中的S7盒
S7=[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盒中的S8盒
S8=[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盒；将8个S盒组成一个8行64列的2维数组
S=[S1,S2,S3,S4,S5,S6,S7,S8]

#P盒置换将每一位输入位映射到输出位。任何一位都不能被映射两次，也不能被略去。
#P盒
P_table=[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
]

#压缩置换表1，不考虑每字节的第8位，将64位密钥减至56位。然后进行一次密钥置换。
#忽略第8位奇偶校验的同时，进行置换，
yasuo1_table=[ 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，用于将循环左移和右移后的56bit密钥压缩为48bit
#完成左移和右移后
#去掉第9、18、22、25、35、38、43、54位，从56位变成48位，再按表的位置置换。
yasuo2_table=[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
]


#扩展置换改变了位的次序，重复了某些位
#用于对数据进行扩展置换，将32bit数据扩展为48bit
#目的A:产生与秘钥相同长度的数据以进行异或运算，R0是32位，子秘钥是48位，
#目的B:提供更长的结果，使得在替代运算时能够进行压缩。
extend_table=[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
]

1.2 字符与bit间的转换

#--------------------------从字符到bit--------------------------
#将字符转换为对应的Unicode码，中文用2个字节表示
def char2unicode_ascii(intext, length):
    outtext = []
    for i in range(length):
        #ord是chr()的及配对函数，以‘c’“c”做为参数
        #返回对应的ASCII或Unicode数值，若超出，返回TypeError
        outtext.append(ord(intext[i]))
    return outtext

#将Unicode码转为bit
def unicode2bit(intext, length):
    outbit = []
    for i in range(length*16):
        #每一位Unicode都是16bit组成
        #intext[int(i/16)]length*16:对应intext中的每一个Unicode，进行16次操作
        #每轮操作右移0,1,2...,15位，然后与1且运算，一次得到16bit
        #！！！得到的这16位bit是个逆序
        outbit.append(intext[int(i/16)]>>(i%16)&1)
    return outbit

#将8位ASCII码转为bit  
def byte2bit(inchar, length):
    outbit = []
    for i in range(length*8):
        #原理同上
        outbit.append(inchar[int(i/8)]>>(i%8)&1)
    return outbit

#--------------------------从bit到字符--------------------------
#将bit转为Unicode码
def bit2unicode(inbit,length):
    out = []
    temp = 0
    for i in range(length):
        #这和上面是同步的，将bit，反着求出，刚刚好
        #或的运算符在这里相当+，左边是int，右边是int，这里相当于二进制数，妙
        #每16位bit，对应着一位Unicode，
        #所以当i对16求模，余数为15时
        #将append(temp),并且重新设置temp为0
        temp = temp | (inbit[i]<<(i%16))
        if i%16 == 15:
            out.append(temp)
            temp = 0
    return out

#将bit转为ascii码
def bit2byte(inbit, length):
    out = []
    temp = 0
    for i in range(length):
        temp = temp | (inbit[i]<<(i%8))
        if i%8 == 7:
            out.append(temp)
            temp = 0
    return out

#将unicode码转为字符（中文或英文）
def unicode2char(inbyte, length):
    out=""
    for i in range(length):
        out = out + chr(inbyte[i])
    return out

1.3 生成密匙串

#------------------生成每一轮的key------------------
def createKeys(inkeys):
    keyResult = []
    #将char型秘钥转化为bit型
    asciikey = char2unicode_ascii(inkeys, len(inkeys))
    keyinit = byte2bit(asciikey, len(asciikey))
    #print("keyinit = ", end = '')
    #print(keyinit)
    #用0初始化列表key0，key1,
    key0 = [0 for i in range(56)]
    key1 = [0 for i in range(48)]
    #进行密码压缩置换1，
    #用压缩置换表1，不考虑每字节的第8位，
    #将64位密码压缩为56位
    for i in range(56):
        key0[i] = keyinit[yasuo1_table[i] - 1]
    
    #进行16轮的密码生成
    for i in range(16):
        #---------------确定左移的次数---------------
        if(i == 0 or i == 1 or i == 8 or i == 15):
            movestep = 1
        else:
            movestep = 2
        #--------------------------------------------
        
        #-----分两部分，每28bit位一部分，进行循环左移-----
        #因为每次循环左移就是第28个移动至第1个
        for j in range(movestep):
            #以行为单位
            #移动2位就是，移动一位进行2次操作
            '''
            for k in range(8):
                #以行为单位左移
                #除去最后一位，每一行都左移一位，操作前保留第一位
                temp = key0[k*7]
                for m in range(7*k, 7*k + 6):
                    key0[m] = key0[m+1]
                key0[7*k + 6] = temp
            '''
            #以组为单位左移
            temp = key0[0]
            for k in range(27):
                key0[k] = key0[k+1]
            key0[27] = temp
            temp = key0[28]
            for k in range(28, 55):
                key0[k] = key0[k+1]
            key0[55] = temp
        #-----------------------------------------------
        
        #-------对56位密钥进行压缩置换，压缩为48位--------
        #置换选择表2(PC-2)，得到子密匙K1
        for k in range(48):
            key1[k] = key0[yasuo2_table[k] - 1]
        #keyResult为16行48列的二维数组
        keyResult.extend(key1)
        #-------------------------------------------------
        
        
    return keyResult

'''
#用来检验代码
key0 = [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]


#以组为单位左移
temp = key0[0]
for k in range(27):
    key0[k] = key0[k+1]
key0[27] = temp
temp = key0[28]
for k in range(28, 55):
    key0[k] = key0[k+1]
key0[55] = temp
key0
'''

1.4 DES加密与解密

def DES(text, key, optionType):
    keyResult = createKeys(key)
    #初始化最终得到的结果
    finalTextOfBit = [0 for i in range(64)]
    finalTextOfUnicode = [0 for i in range(4)]
    
    #打印出来检验一下
    #print(keyResult)
    
    if optionType == 0:
        #初始化
        #用于临时盛放IP拟置换前，将L部分和R部分合成64的结果
        tempText = [0 for i in range(64)]
        
        #初始化
        #用于盛放R部分的扩展到48位的结果
        extendR = [0 for i in range(48)]
        
        #char型向bit型转化
        unicodeText = char2unicode_ascii(text, len(text))
        #print(unicodeText)
        bitText = unicode2bit(unicodeText, len(unicodeText))
        #print(bitText)
        
        #初始化
        #用于存放IP置换之后的结果
        initTrans = [0 for i in range(64)]
        
        #---------------进行初始IP置换---------------
        for i in range(64):
            initTrans[i] = bitText[IP_table[i] - 1]
        #将64位明文分为左右两部分
        
        L = initTrans[:32]
        R = initTrans[32:]
        #print("lkasdjfklsjdflksdfj")
        #print("L and R",L,R)
        # print('initTrans:',initTrans)
        # print("bittext:",bitText)
        #开始进行16轮运算
        for i in range(16):
            #临时存放R
            tempR = R
            
            #-------对R进行扩展，将32位扩展为48位-------
            for j in range(48):
                extendR[j] = R[extend_table[j] - 1]
            #print(len(keyResult))
            
            #第i轮的秘钥，从keyResult中取出
            keyi = [keyResult[j] for j in range(i*48, i*48 + 48)]
            #print(i,keyi)
            #---------与key进行异或运算--------
            #初始化
            XORResult = [0 for j in range(48)]
            for j in range(48):
                if keyi[j] != extendR[j]:
                    XORResult[j] = 1
            #----------------------------------
            
            #---------开始进行盒运算----------
            #初始化
            SResult = [0 for k in range(32)]
            for k in range(8):
                #此处使用移位转进制
                row = ((XORResult[k*6])<<1) | (XORResult[k*6+5])
                column = 0
                for j in range(1,5):
                    column = column | (XORResult[k*6 + j]<<(4-j))
                temp = S[k][row*16+column]
                for m in range(4):
                    SResult[k*4+m] = (temp>>m)&1
            #---------------------------------
            #if i == 0:
            #    print('PRsult is :;；：',PResult)

            #-------------开始进行P盒置换-------------
            #初始化
            PResult=[0 for k in range(32)]
            for k in range(32):
                PResult[k]=SResult[P_table[k]-1]
            #-----------------------------------------
            #if i == 0:
                #print('PRsult is :;；：',PResult)
            #--------------与L部分的数据进行异或------------
            XORWithL=[0 for k in range(32)]
            for k in range(32):
                if L[k]!=PResult[k]:
                    XORWithL[k]=1
            #----------------------------------------------

            #将临时保存的R部分值，即tempR复制给L
            L=tempR
            R=XORWithL
            
            #print("当前i为%d",(i))
            #print("当前L,R为",L,R)
            #-----------------循环结束-----------------
            
        #交换左右两部分
        L, R = R, L
        #if i == 0:
        #    print('LRis :;；：',L,R)
        #合并为一部分
        tempText = L
        tempText.extend(R)
            
        #IP逆置换
        for k in range(64):
            finalTextOfBit[k]=tempText[_IP_table[k]-1]

        #bit型转化为char型
        finalTextOfUnicode = bit2byte(finalTextOfBit, len(finalTextOfBit))
        #print("finalTextOfUnicode", finalTextOfUnicode)
        finalTextOfChar = unicode2char(finalTextOfUnicode, len(finalTextOfUnicode))
        #print("finalTextOfChar",finalTextOfChar)
        return finalTextOfChar
    else:
        #初始化
        #用于临时盛放IP拟置换前，将L部分和R部分合成64的结果
        tempText = [0 for i in range(64)]
        
        #初始化
        #用于盛放R部分的扩展到48位的结果
        extendR = [0 for i in range(48)]
        
        #char型向bit型转化
        unicodeText = char2unicode_ascii(text, len(text))
        #print(unicodeText)
        bitText = byte2bit(unicodeText, len(unicodeText))
        #print(bitText)
        
        #初始化
        #用于存放IP置换之后的结果
        initTrans = [0 for i in range(64)]
        
        #---------------进行初始IP置换---------------
        for i in range(64):
            initTrans[i] = bitText[IP_table[i] - 1]
        #将64位明文分为左右两部分
        L=[initTrans[i] for i in range(32)]
        R=[initTrans[i] for i in range(32,64)]

        #开始进行16轮运算
        for i in range(15,-1,-1):
            #临时存放R
            tempR = R
            
            #-------对R进行扩展，将32位扩展为48位-------
            for j in range(48):
                extendR[j] = R[extend_table[j] - 1]
            #print(len(keyResult))
            
            #第i轮的秘钥，从keyResult中取出
            keyi = [keyResult[j] for j in range(i*48, i*48 + 48)]
            #---------与key进行异或运算--------
            #初始化
            XORResult = [0 for j in range(48)]
            for j in range(48):
                if keyi[j] != extendR[j]:
                    XORResult[j] = 1
            #----------------------------------
            
            #---------开始进行S盒运算----------
            #初始化
            SResult = [0 for k in range(32)]
            
            for k in range(8):
                #此处使用移位转进制
                row = (XORResult[k*6]<<1) | (XORResult[k*6+5])
                column = 0
                for j in range(1,5):
                    column = column | (XORResult[k*6 + j]<<(4-j))
                temp = S[k][row*16+column]
                for m in range(4):
                    SResult[k*4+m] = (temp>>m)&1
            #---------------------------------
            #print('SResult',SResult)
            #-------------开始进行P盒置换-------------
            #初始化
            PResult=[0 for k in range(32)]
            for k in range(32):
                PResult[k]=SResult[P_table[k]-1]
            #-----------------------------------------
            
            #--------------与L部分的数据进行异或------------
            XORWithL=[0 for k in range(32)]
            for k in range(32):
                if L[k]!=PResult[k]:
                    XORWithL[k]=1
            #----------------------------------------------

            #将临时保存的R部分值，即tempR复制给L
            L=tempR
            R=XORWithL
            #print("L, R在第%d轮",(i, L,R))
        #交换左右两部分
        L, R = R, L
        #print("L, R",(L,R))
        #合并为一部分
        tempText = L
        tempText.extend(R)
        #----------------------IP逆置换----------------------
        for k in range(64):
            finalTextOfBit[k]=tempText[_IP_table[k]-1]

        #bit型转化为char型
        finalTextOfUnicode = bit2unicode(finalTextOfBit, len(finalTextOfBit))
        #print(finalTextOfUnicode)
        finalTextOfChar = unicode2char(finalTextOfUnicode, len(finalTextOfUnicode))
        #print(finalTextOfChar)
        return finalTextOfChar

#用来帮忙测试代码
# '''
#代码小记
#import numpy as np
#rng = np.random.RandomState(1)
#initTrans = rng.randint(3, size = 64)
#L = initTrans[:32]
#R = initTrans[32:]
#initTrans
#'''

#用来帮忙测试代码
'''
#1,0,0
temp =4 
k=0
SResult = [0 for i in range(10)]
for m in range(4):
    SResult[k*4+m] = (temp>>m)&1
SResult
'''

1.5 main函数

def main():
    text = input("请输入要操作的文本:  ")
    #str0.join([str1,str2])
    print(" ".join(["输入的文本是：",text]))
    optionType = input("请选择是进行加密还是解密，加密输入0，解密输入1:  ")
    while(not(optionType == '0' or optionType == '1')):
        print("Wrong!!!选择的操作类型只能是0或者是1")
        optionType = input("请选择是进行加密还是解密，加密输入0，解密输入1:  ")
    length = len(text)
    Result = ""
    #print('optiontype',optionType)
    if optionType == '0':
        #f=open('D:\encyptText.txt','w')


        #若输入文本的长度不是4的整数倍，
        #即不是64字节的整数倍，
        #用空格补全（此处为了加密中文，
        #用的是unicode编码，即用16字节表示一个字符

        text = text + int(length % 4) * " "
        length = len(text)
        key = input("请输入8位加密密码: ")
        while(len(key) != 8):
            print("wrong!!请输入8位密码")
            key = input("请输入8位加密密码: ")

        print("加密后的文本：",end = " ")  
        #字符每四个为一组
        for i in range(int(length/4)):
            #    [text[j] for j in range()]
            tempText = [text[j] for j in range(i*4,i*4+4)]
            Result = "".join([Result,DES(tempText,key,int(optionType))])
        #f.write(Result)
        print(Result)

    if optionType == '1':

        #若输入文本的长度不是8的整数倍，
        #即不是64字节的整数倍，
        #用空格补全（此处解密出来的密文用的是每8bit转换为一个ascii码，
        #所以生成的八位表示的字符）-------

        #text = text+int(length%8)*" "
        length = len(text) 
        key = input("请输入8位解密密码: ")
        while(len(key) != 8):
            print("wrong!!请输入8位密码")
            key = input("请输入8位解密密码: ")

        print("解密后的文本：",end = " ")
        for i in range(int(length/8)):
            tempText = [text[j] for j in range(i*8,i*8+8)]
            Result = "".join([Result,DES(tempText,key,int(optionType))])
        print(Result)

    

#帮忙测试代码
aa = createKeys('hipython')
bb = createKeys2('hipython')

count = 1
for i in range(len(aa)):
    if aa[i] != bb[i]:
        print("..fine")
    else:
        count += 1
        
count

c = DES(['o', 'a', 's', 'a'],'hipython',0)
c
#finalTextOfUnicode [227, 34, 249, 130, 238, 162, 100, 136]
#finalTextOfChar ã"ù‚î¢dˆ



'V\x9d¡\x93R\x05ðà'

2 实例测试

main()
#we are the champion, my friend胜不骄败不馁

请输入要操作的文本:  我好傻呀哈哈哈哈
输入的文本是： 我好傻呀哈哈哈哈
请选择是进行加密还是解密，加密输入0，解密输入1:  0
请输入8位加密密码: hipython
加密后的文本： ºZœ’cÿ¦2{„0æ«L“

请输入要操作的文本: 我好傻呀哈哈哈哈
输入的文本是： 我好傻呀哈哈哈哈
请选择是进行加密还是解密，加密输入0，解密输入1: 0
请输入8位加密密码: hipython
加密后的文本： ºZœ’cÿ¦2{„0æ«L“

main()

请输入要操作的文本:  ºZœ’cÿ¦2{„0æ«L“
输入的文本是： ºZœ’cÿ¦2{„0æ«L“
请选择是进行加密还是解密，加密输入0，解密输入1:  hipython
Wrong!!!选择的操作类型只能是0或者是1
请选择是进行加密还是解密，加密输入0，解密输入1:  1
请输入8位解密密码: hipython
解密后的文本： 我好傻呀哈哈哈哈

请输入要操作的文本: ºZœ’cÿ¦2{„0æ«L“
输入的文本是： ºZœ’cÿ¦2{„0æ«L“
请选择是进行加密还是解密，加密输入0，解密输入1: hipython
Wrong!!!选择的操作类型只能是0或者是1
请选择是进行加密还是解密，加密输入0，解密输入1: 1
请输入8位解密密码: hipython
解密后的文本： 我好傻呀哈哈哈哈

main()

请输入要操作的文本:  to the love of my life
输入的文本是： to the love of my life
请选择是进行加密还是解密，加密输入0，解密输入1:  0
请输入8位加密密码: hipython
加密后的文本： ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå

请输入要操作的文本: to the love of my life
输入的文本是： to the love of my life
请选择是进行加密还是解密，加密输入0，解密输入1: 0
请输入8位加密密码: hipython
加密后的文本： ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå

main()

请输入要操作的文本:  ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå
输入的文本是： ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå
请选择是进行加密还是解密，加密输入0，解密输入1:  1
请输入8位解密密码: hipython
解密后的文本： to the love of m♒㭗櫎㗁

请输入要操作的文本: ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå
输入的文本是： ý!2>áÎ]J‰"Äg“»¤Å¡¸€;{×GÑκŠÏ°ûÜøðñdý„Zå
请选择是进行加密还是解密，加密输入0，解密输入1: 1
请输入8位解密密码: hipython
解密后的文本： to the love of m♒㭗櫎㗁

main()

请输入要操作的文本:  omg 你真是天才
输入的文本是： omg 你真是天才
请选择是进行加密还是解密，加密输入0，解密输入1:  0
请输入8位加密密码: hipython
加密后的文本： 8¢|í9.°ef’Þ®·

请输入要操作的文本: omg 你真是天才
输入的文本是： omg 你真是天才
请选择是进行加密还是解密，加密输入0，解密输入1: 0
请输入8位加密密码: hipython
加密后的文本： 8¢|í9.°ef’Þ®·

main()

请输入要操作的文本:  8¢|í9.°ef’Þ®·
输入的文本是： 8¢|í9.°ef’Þ®·
请选择是进行加密还是解密，加密输入0，解密输入1:  1
请输入8位解密密码: hipython
解密后的文本： omg 你真是天

请输入要操作的文本: 8¢|í9.°ef’Þ®·
输入的文本是： 8¢|í9.°ef’Þ®·
请选择是进行加密还是解密，加密输入0，解密输入1: 1
请输入8位解密密码: hipython
解密后的文本： omg 你真是天

main()

请输入要操作的文本:  omg你真是天
输入的文本是： omg你真是天
请选择是进行加密还是解密，加密输入0，解密输入1:  0
请输入8位加密密码: hipython
加密后的文本： ΔÃxgÏ6†ÂA»ø¾a

请输入要操作的文本: omg你真是天
输入的文本是： omg你真是天
请选择是进行加密还是解密，加密输入0，解密输入1: 0
请输入8位加密密码: hipython
加密后的文本： ΔÃxgÏ6†ÂA»ø¾a

main()

请输入要操作的文本:  ΔÃxgÏ6†ÂA»ø¾a
输入的文本是： ΔÃxgÏ6†ÂA»ø¾a
请选择是进行加密还是解密，加密输入0，解密输入1:  1
请输入8位解密密码: hipython
解密后的文本： omg你真是天

请输入要操作的文本: ΔÃxgÏ6†ÂA»ø¾a
输入的文本是： ΔÃxgÏ6†ÂA»ø¾a
请选择是进行加密还是解密，加密输入0，解密输入1: 1
请输入8位解密密码: hipython
解密后的文本： omg你真是天

main()

请输入要操作的文本:  radiogagaradiogugu
输入的文本是： radiogagaradiogugu
请选择是进行加密还是解密，加密输入0，解密输入1:  0
请输入8位加密密码: hipython
加密后的文本： ¶‚×ÜOÅø܃ðMäo

 ¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬

请输入要操作的文本: radiogagaradiogugu
输入的文本是： radiogagaradiogugu
请选择是进行加密还是解密，加密输入0，解密输入1: 0
请输入8位加密密码: hipython
加密后的文本： ¶‚×ÜOÅø܃ðMäo
 ¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬

main()

    请输入要操作的文本:  ¶‚×ÜOÅø܃ðMäo
¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬
    输入的文本是： ¶‚×ÜOÅø܃ðMäo
¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬
    请选择是进行加密还是解密，加密输入0，解密输入1:  1
    请输入8位解密密码: hipython
    解密后的文本： radiogagaradiogugu  
    

请输入要操作的文本:  ¶‚×ÜOÅø܃ðMäo
¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬
输入的文本是： ¶‚×ÜOÅø܃ðMäo
¦h+@OV4ÂrÉ áÃ÷Sµ¾¶à§¬
请选择是进行加密还是解密，加密输入0，解密输入1:  1
请输入8位解密密码: hipython
解密后的文本： radiogagaradiogugu

大部分正确，不足的地方是需要文本中无空格，否则会出现一些乱码，原因暂时不清楚

'''
# 用来帮助测试代码
c = DES('qwertyui','hipython',1)
c


d = DES2('qwertyui','hipython',1)
d


'''

reference:
1
2

搬运代码打工人
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python入门实战：数据加密与解密
AI架构设计之禅
11-23 247
1.背景介绍 数据加密与解密 数据加密与解密（英语：Data Encryption Standard），简称DES，一种密码对称算法，是美国联邦政府采用的一种对敏感信息进行加密的算法标准，后被国家标准化部门作为行业标志。 它是一种块密码算法，速度快，安全性高，目前被广泛应用于各种场合，比如银行卡交易、互联网支
Python-DES加密和解密
乱舞的浮尘
06-02 7139
Python有着丰富的类库，可以快速实现基于DES的加密和解密。下面就是简单的几行代码就可以实现DES-CBC，采用PKCS5进行填充的标准加密和解密。 需要指出的是，Python支持的DES-CBC，key是8位的，在openssl 3.0后已经移除，建议采用安全性更高的DES-EDE-CBC或DES-EDE3-CBC。另外一种方法，就是采用C/C++编写一个Windows DLL，具体可见 windows动态链接库DLL-文本加密和解密以上是非常简单的代码，根据实际应用场景，需要自己再封装另外的代码
DES算法实现python（含图形化界面）
11-14
1. 网上搜索DES的源代码。 2. 利用DES源代码实现下面功能： 1. 给定某个Sbox的输入差分情况下，计算所有输入对和所有Sbox输出差分的分布情况 2. 统计DES算法在密钥固定情况，输入明文改变1位、2位，。。。64位时。输出密文位数改变情况。 3. 统计DES算法在明文固定情况，输入密钥改变1位、2位，。。。64位时。输出密文位数改变情况。 为了具有客观性，2，3小题需要对多次进行统计，并计算其平均值。
密码学--DES算法（图形化界面）python
qq_43337502的博客
11-15 4145
密码学--DES算法python要求原理主要功能界面具体功能代码源码 要求 网上搜索DES的源代码。 利用DES源代码实现下面功能： 给定某个Sbox的输入差分情况下，计算所有输入对和所有Sbox输出差分的分布情况 统计DES算法在密钥固定情况，输入明文改变1位、2位，。。。64位时。输出密文位数改变情况。 统计DES算法在明文固定情况，输入密钥改变1位、2位，。。。64位时。输出密文位数改变情况。 为了具有客观性，2，3小题需要对多次进行统计，并计算其平均值。 异或加密算法 原理 差分： 1、公式：S
基于Python的DES算法加密、解密算法（含原理详解）
qq_45688383的博客
09-30 3541
基于Python的DES加密、解密算法 DES算法是一种对称加密算法（加密密钥和解密密钥相同），加密过程要求密钥长度和待加密数据长度均为64位。因此在使用DES算法加密之前，需要把待加密数据切割位64位长度的数据块。 ...
DES加解密算法详解（py+tkinter实现可视化加密软件）
cxiaodi的博客
05-07 1893
DES加解密详解，借助tkinter实现可视化
python des解密_DES-Python加解密案例
weixin_36481965的博客
01-28 1060
在python中处理des加解密，常用的库是pyDes这个库，现在以具体例子来讲解加解密算法1、需求：对一段数字或者字符或者其他格式文本进行加密，本次使用des里面的ECB模式快捷工具链接：http://tool.chacuo.net/cryptdesimage.png比如：想要实现以上的加密方式，代码实现为：from pyDes import *import base64Des_Key = b"...
Python基于DES算法加密解密实例
09-21
主要介绍了Python基于DES算法加密解密实现方法,以实例形式分析了DES算法实现加密解密的相关技巧,需要的朋友可以参考下
Python和Java进行DES加密和解密的实例
08-28
"Python和Java进行DES加密和解密的实例" 本文将对Python和Java进行DES加密和解密的实例进行详细的解释和分析。 标题解释 本文的标题为"Python和Java进行DES加密和解密的实例”，该标题说明了本文的主要内容，即使...
python实现DES加密解密方法实例详解
09-21
### Python 实现 DES 加密解密方法实例详解 #### 一、引言 在信息安全领域，数据加密技术是一项至关重要的技术。其中，**数据加密标准（Data Encryption Standard, DES）**是一种广泛使用的对称加密算法。它使用一...
des-python-cipher:DES 加密算法的 Python3 实现
05-16
DES 加解密的 Python 实现 环境 使用的 Python 版本是：Python 3.6.3。 无使用其他第三方库，根据密码学实验要求纯手工实现。 使用 加密字符串 在得到的项目文件夹下使用如下命令即可启动 GUI 界面： $ python3 main.py 因为 DES 是分组密码，密钥要求是64位也就是8个字节的字符，所以密钥输入框只能输入8字节字符，待加密明文会对其进行填充补全，不用在意输入个数。 加密文件 在 filecipher 中定义了使用 DES 对文件进行加解密的类和方法，进入 static 文件夹后运行如下命令： $ python3 ../filecipher.py 得到了加密和解密的文件。 拓展 可继承 mian.py 中定义的 GUI 类来做加解密文件的图形界面，这里就不写了，有兴趣的人可以尝试去拓展。
DES加密算法及Python实现
嵌入式之斋
06-22 1977
首先对明文进行按位填充，然后调用encrypt()和decrypt()函数实现加密和解密操作，最后去除填充并返回解密后的明文。密钥的生成：将64位密钥按照置换选择1表进行置换，得到56位的密钥，并分成左右两部分各28位。16轮迭代：将加密得到的块分成左右两部分各32位，分别作为下一轮的输入，重复上述运算直到第16轮。加密运算：把置换后的明文块和第1个子密钥进行加密运算，得到一个64位的块。初始置换：对64位的明文按照初始置换表进行置换处理。明文分组：将明文分成64位的块，对每个块进行加密。
实验二 DES密码算法的设计与实现
最新发布
Martin-share的博客
02-02 2297
通过用DES算法对实际的数据进行加密和解密，并撰写实验报告，深刻理解DES算法的设计机制、分组密码算法工作模式。(1) 设计并实现DES加解密算法；（提供图形界面，必做） (2) 能用DES加解密算法对字符串文本进行加解密，记录运行时间（必做），对文件进行加解密（扩展）； (3) 设计并实现ECB、CBC工作模式的加解密算法；（必做） (4) 设计并实现3DES加解密算法（扩展）； (5) 提供图形化用户界面，并提交核心程序代码和执行结果。（必做） (6) 使用（3）中实现的程序，对输入的字符数据进行加密，
3DES加密算法Python实现
chqi987333的博客
06-30 592
目前网上使用Python实现的DES算法，绝大部分是用原始的PC表、置换表E、S盒实现加解密计算的。这里给出另外一个更接近DES算法反编译后的版本。
DES+RSA密码工具（图形界面）
Cody的博客
06-12 5879
1、实验环境：框架脚本：Python3.5UI设计脚本：Wxpython4.0.1平台：Win102、界面截图 2、实验内容：1）DES加密算法：（1）加解密字符串。（2）加解密文件。（3）界面设计。2）RSA加密算法：（1）RSA生成公私钥及加密解密过程演示。（2）RSA加密解密 3、实验目的：（1）理解对称加密算法的原理和特点（2）理解DES算法的加密原理和使用模式（3）了解非对称加密机制（4...
python笔记66 - DES/CBC/pkcs5padding加解密（pyDes）
qq_27371025的博客
10-07 1892
前言 使用python代码实现 DES/CBC/pkcs5padding加解密 DES加密模式 加密模式：DES/CBC/pkcs5padding 加解密在线工具：http://tool.chacuo.net/cryptdes 需知道加密的密码(8位)：yoyo1234 IV偏移量（8位）：12345678 输出编码格式(16进制)：hex 在线加密结果 输入：yoyo 得到16进制：d50d7e20173f0e27 pyDes库 先安装pyDes库Version: 2.0.1 > pip inst
分组加密中的四种模式(ECB、CBC、CFB、OFB)
lance～crazy
06-06 4848
ECB 优点 缺点 1.具有操作简单，易于实现的特点 1.不能隐藏明文的模式； 2.分组独立性，有利于并行计算； 2.可能对明文进行主动攻击； 3. 误差不会被传送； 3. 明文中的重复内容会在密文中有所体现，因此难以抵抗统计分析攻击 ECB模式一般只适用于小数据量的字符信息的安全性保护，例如密钥保护。 CBC （Cipher-block chaining）模式 若...
密码学史观----Cryptography
lance～crazy
03-22 648
1 Basic Introduction 1.1 Definition Cryptography is the practice and study of techniques for secure communication in the presence of third parties called adversaries. More generally, cryptography cry...
python DES加密解密
09-07
以下是一个使用DES加密和解密的示例代码： ```python from Crypto.Cipher import DES from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes def encrypt(plain_text, key): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值