精华内容
下载资源
问答
  • 加密过程:就是按列依次从上到下对明文进行排列,然后按照密钥对各行进行打乱,最后以行顺序从左至右进行合并形成密文解密过程:上述过程进行逆推,对每一行根据密钥的顺序回复到原始的方阵的顺序,并从密文...
  • python实现DES加密和解密

    千次阅读 2020-10-24 16:02:02
    DES是一种64比特的明文加密成64比特的密文对称密码算法。DES是以64比特的明文为一个单位来进行加密的,这个64比特的单位成为分组,所以DES密码又称为分组密码 ...1.首先将将明文和密钥转化二进制,

    DES是一种将64比特的明文加密成64比特的密文对称密码算法。DES是以64比特的明文为一个单位来进行加密的,这个64比特的单位成为分组,所以DES密码又称为分组密码

    DES的基本结构是由Horst Feistel 设计的,因此也称为Feistel网络Feistel结构,在Feistel网络中加密的哥哥步骤成为轮(round),整个加密过程就是进行若干次轮的循环。如下图所示(来自百度百科):
    des加密流程图

    • 下面用具体的代码实现DES的加密,解密的过程完全一样,不过是密钥逆用。

    1.首先将将明文和密钥转化为二进制,以64位分一组,最后不足的用0补齐

    # 将明文转化为二进制
    def str2bin(message):
        res = ''
        for i in message:
            tmp = bin(ord(i))[2:]  # 将每个字符转化成二进制
            tmp = str('0' * (8 - len(tmp))) + tmp  # 补齐8位
            res += tmp
        if len(res) % 64 != 0:
            count = 64 - len(res) % 64  # 不够64位补充0
        else:
            count = 0
        res += '0' * count
        return res
    
    
    # 将密钥转化为二进制
    def key2bin(key):
        res = ''
        for i in key:
            tmp = bin(ord(i))[2:]  # 将每个字符转化成二进制
            tmp = str('0' * (8 - len(tmp))) + tmp  # 补齐8位
            res += tmp
        if len(res) < 64:
            count = 64 - len(res) % 64  # 不够64位补充0
            res += '0' * count
        else:
            res = res[:64]
        return res
    

    2.然后进行ip盒置换

    IP置换的目的是将转化后的64位比特数据按位重新组合,并把输出分为L0和R0两部分,各部分长32位。
    例如ip盒中的第一个数是58,那么就是把原数据中的第58位放到新数据的第1位

    # IP盒处理
    def ip_change(str_bin):
        res = ''
        for i in IP_table:
            res += str_bin[i - 1]
        return res
    
    str_left = str_bin[:32]  # L0位新数据的左32位
    str_right = str_bin[32:]  # # R0位新数据的右32位
    

    3.密钥置换

    子密钥产生示意图
    这个流程图可以让我们很直观的了解到密钥产生的过程

    • 首先对给定的64位密钥K,应用PC-1变换进行选为,选为后结果是56位
    # 秘钥的PC-1置换
    def change_key1(my_key):
        res = ""
        for i in PC_1:  # PC_1盒上的元素表示位置    只循环64次
            res += my_key[i - 1]  # 将密钥按照PC_1的位置顺序排列,
        return res
    
    • 然后将56位密钥分为左边和右边两部分,对该28位,进行重复左移。

    • 这里将循环左移的位数,写在一个列表SHIFT中,方便调用,每一轮左移,都会得到一个56位子密钥

    • 然后再通过PC-2选择出最终的48比特的子密钥

    # 生成子密钥
    def gen_key(bin_key):
        key_list = []
        key1 = change_key1(bin_key)  # 秘钥的PC-1置换
        key_C0 = key1[0:28]
        key_D0 = key1[28:]
        for i in SHIFT:  # shift左移位数
            key_c = key_C0[i:] + key_C0[:i]  # 左移操作
            key_d = key_D0[i:] + key_D0[:i]
            key_output = change_key2(key_c + key_d)  # 秘钥的PC-2置换
            key_list.append(key_output)
        return key_list
    
    
    # 秘钥的PC-2置换
    def change_key2(my_key):
        res = ""
        for i in PC_2:
            res += my_key[i - 1]
        return res  # 这里置换玩密钥从56位变为48位
    

    通过上述操作,我们就得到了16组48位的子密钥,然后接下来进行DES的核心环节

    4.轮函数f运算

    有了每一轮的加密密钥Ki,就可以进行16次迭代

    函数f迭代过程

    E扩展置换

    • 要先实现明文拓展的功能,这里我们使用E盒,将明文的部分bit重复排列,造成冗余,来实现拓展。
    • E扩展置换的目的有两个:
    1. 生成与密钥相同长度的数据以进行异或运算
    2. 提供更长的结果,再后续的替代运算中可以进行压缩。
    # E盒置换
    def e_change(str_left):
        res = ""
        for i in E:
            res += str_left[i - 1]
        return res
    
    • 然后将48位结果与子密钥Ki进行异或(xor)
    def xor_change(str1, str2):
        res = ""
        for i in range(0, len(str1)):
            xor_res = int(str1[i], 10) ^ int(str2[i], 10)  # 进行xor操作
            if xor_res == 1:
                res += '1'
            if xor_res == 0:
                res += '0'
        return res
    

    S盒代替

    • 异或运算结束后,我们需要将48bit缩减位32bit,分组使用S盒置换,。
    • 替代由8个不同的S盒完成,每个S盒有6个输入4个输出。
    • 48位输入分为8个6位分组,每个分组对应一个S盒,对应的S盒对各组进行代替操作。
    • 替代过程中产生的8个4位的分组,组合在一起形成32位数据

    例如S盒8的输入位110011,第1位和第6位组合为11,对应S盒8的第3行,第2位到第5位为1001,对应于S盒8的地9列。S盒的第3行第9列的数字为12,那么就用1100来代替110011。

    def s_change(my_str):
        res = ""
        c = 0
        for i in range(0, len(my_str), 6):  # 步长为6   表示分6为一组
            now_str = my_str[i:i + 6]  # 第i个分组
            row = int(now_str[0] + now_str[5], 2)  # 第r行
            col = int(now_str[1:5], 2)  # 第c列
            # 第几个s盒的第row*16+col个位置的元素
            num = bin(S[c][row * 16 + col])[2:]  # 利用了bin输出有可能不是4位str类型的值,所以才有下面的循环并且加上字符0
            for gz in range(0, 4 - len(num)):  # 补全4位
                num = '0' + num
            res += num
            c += 1
        return res
    
    
    • 然后再进行P盒运算
    def p_change(bin_str):
        res = ""
        for i in P:
            res += bin_str[i - 1]
        return res
    

    整个轮函数f如下:

    def f(str_left, key):
        e_change_output = e_change(str_left)  # E扩展置换
        xor_output = xor_change(e_change_output, key)  # 将48位结果与子密钥Ki进行异或(xor)
        s_change_output = s_change(xor_output)
        res = p_change(s_change_output)
        return res
    
    • 然后明文右侧与子密钥进行论函数f后的结果与明文左边的数据进行xor运算,然后交换左边和右边

    至此 我们只完成了一轮的Feistel变换,之后的15轮都是这样的,但要注意,再进行最后一轮Feistel变换的时候不需要交换左边和右边

            for j in range(15):  # 先循环15次 因为最后一次不需要不用换位
                f_res = f(str_right, key_lst[j])
                str_left = xor_change(f_res, str_left)
                str_left, str_right = str_right, str_left  # 左边和右边交换
    
            f_res = f(str_right, key_lst[15])  # 第16次
    

    Feistel网络中的一轮
    这张图即可很直观明白的了解Feistel网络中的一轮

    5.IP逆置换

    得到了加密后的56位比特,现在我们要使用初始置换函数的逆函数,得到正确的密文序列。也是直接从盒中置换:

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

    6.将密文比特流转化为密文字符

    # 二进制转字符串
    def bin2str(bin_str):
        res = ""
        tmp = re.findall(r'.{8}', bin_str)  # 每8位表示一个字符
        for i in tmp:
            res += chr(int(i, 2))
        return res
    

    至此所有加密结束




    • 下面是加密的代码
    def encrypt():
        bin_str = str2bin(input('请输入明文:'))
        bin_key = key2bin(input('请输入密钥:'))
        tmp = re.findall(r'.{64}', bin_str)
        result = ''
        for i in tmp:
            str_bin = ip_change(i)  # IP置换
            key_lst = gen_key(bin_key)  # 生成16个子密钥
            str_left = str_bin[:32]
            str_right = str_bin[32:]
            for j in range(15):  # 先循环15次 因为最后一次不需要不用换位
                f_res = f(str_right, key_lst[j])
                str_left = xor_change(f_res, str_left)
                str_left, str_right = str_right, str_left
    
            f_res = f(str_right, key_lst[15])  # 第16次
            str_left = xor_change(str_left, f_res)
            fin_str = ip_re_change(str_left + str_right)  # ip的逆
            result += fin_str
        last = bin2str(result)
        print('密文为:', last)
    

    解密的大致流程

    首先上代码,可以看出,解密的脚本盒加密的脚本大同小异,只不过是再解密的时候密钥是反过来了。

    def decrypt():  # 解密和加密的步骤差不多,但要注意解密时密钥是倒过来的 ,第一个的时候左右不交换
        bin_str = str2bin(input('请输入密文:'))
        bin_key = key2bin(input('请输入密钥:'))
        tmp = re.findall(r'.{64}', bin_str)
        result = ''
        for i in tmp:
            str_bin = ip_change(i)  # IP置换
            key_lst = gen_key(bin_key)  # 生成16个子密钥
            str_left = str_bin[:32]
            str_right = str_bin[32:]
            for _j in range(1, 16):
                j = 16 - _j  # 解密的时候秘钥反过来的
                f_res = f(str_right, key_lst[j])
                str_left = xor_change(f_res, str_left)
                str_left, str_right = str_right, str_left
            f_res = f(str_right, key_lst[0])
            str_left = xor_change(str_left, f_res)
            fin_str = ip_re_change(str_left + str_right)  # ip的逆
            result += fin_str
        last = bin2str(result)
        print('明文为:', last)
    

    完整参考代码

    github

    展开全文
  • 注意:密文是大写字母,在变换加密之前把明文字母都替换大写字母 def casar(message): # *************begin************# message1=message.upper() #把明文字母变成大写 message1=list(message1) #将明文字符...

    python实现凯撒密码、凯撒加解密算法

    更多python视频教程请到菜鸟教程https://www.piaodoo.com/

    凯撒密码的原理:计算并输出偏移量为3的凯撒密码的结果
    注意:密文是大写字母,在变换加密之前把明文字母都替换为大写字母

    def casar(message):
    # *************begin************#
     message1=message.upper() #把明文字母变成大写
     message1=list(message1) #将明文字符串转换成列表
     list1=[]
     for i in range(len(message1)):
     if message1[i]==' ':
      list1.append(message1[i]) #若为空格不用移动
     elif ord(message1[i]) <= 90-3+1: #A-X右移三位
      list1.append(chr(ord(message1[i]) + 3))
      result = ''.join(list1) #列表转换成字符串
     else:
      list1.append(chr(ord(message1[i]) - (26-3))) #Y和Z回到A、B
      result = ''.join(list1)
     print(result)
    # **************end*************# 
    

    def main():
    message = input()
    casar(message)
    if name==‘main’:
    main()

    测试输入:Guet
    预期输出:JXHW
    测试输入:information security
    预期输出:LQIRUPDWLRQ VHFXULWB

    凯撒密码原理:根据输入的加解密模式和密钥对消息进行加解密。
    注意:如果是加密,输出的密文是大写字母,如果是解密,按照凯撒解密后,转换为小写后,输出解密后的明文.

    def casar(mode,message,key):
    # *************begin************#
     if mode==1: #加密
     message1 = message.upper() # 把明文字母变成大写
     message1 = list(message1) # 将明文字符串转换成列表
     list1 = []
     for i in range(len(message1)):
      if message1[i] == ' ':
      list1.append(message1[i]) # 若为空格不用移动
      elif ord(message1[i]) <= 65 +key-1: 
      list1.append(chr(ord(message1[i]) + key)) # 右移key位
      result = ''.join(list1) # 列表转换成字符串
      else:
      list1.append(chr(ord(message1[i]) - key)) 
      result = ''.join(list1)
     print(result)
     elif mode==0: #解密
     message2 = list(message) # 将明文字符串转换成列表
     list2 = []
     for i in range(len(message2)):
      if message2[i] == ' ':
      list2.append(message2[i]) # 若为空格不用移动
      elif ord(message2[i]) <= 65+ key -1: 
      list2.append(chr(ord(message2[i]) + (26-key))) # 右移三位
      result = ''.join(list2) # 列表转换成字符串
      else:
      list2.append(chr(ord(message2[i]) - key)) 
      result = ''.join(list2)
     result = result.lower()
     print(result)
    

    *end#

    def main():
    mode = int(input()) # 1代表加密,0代表解密
    message = input() #待加密或解密的消息
    key = int(input()) # key的范围0~25之间
    casar(mode,message,key)
    if name==‘main’:
    main()

    测试输入:
    1
    zhang
    13
    测试输出:
    MUNAT
    测试输入:
    0
    GOHUN
    7
    测试输出:
    zhang

    编写一个仿射加解密程序,范围是所有的大小写字母范围
    本题需要掌握相关知识1.仿射加密算法,2.扩展的欧几里得算法。
    假设X,Y,a,b是Z52整数环中的元素,a和b为密钥,X是原文,Y是密文
    加密函数:Y=(aX+b)%52
    获取乘法逆元
    通过扩展的欧几里得算法求a的乘法逆元
    加密过程
    加密函数:Y=(aX+b)%52
    解密过程
    解密函数:X=(a的逆元)*(Y-B)%52

    #仿射密码
    

    def encrypt(k1,k2,message):

    *begin#

    message1 = list(message)
    list1=list(map(chr,range(ord(‘a’),ord(‘z’)+1)))
    list2=list(map(chr,range(ord(‘A’),ord(‘Z’)+1)))
    for i in range(len(list1)):
    list1.append(list2[i])
    y=[]
    for i in range(len(message)):
    if message1[i]==’ ':
    y.append(message1[i])
    else:
    for j in range(52):
    if message1[i]==list1[j]:
    y.append(list1[(k1*j + k2) % 52])
    result = ‘’.join(y)
    return result

    *end#

    def decrypt(k1,k2,message):

    *begin#

    #扩展欧几里得算法求逆元法
    

    x1, x2, x3 = 1, 0, 52

    y1, y2, y3 = 0, 1, k1

    while True:

    if y3 == 0:

    return ‘None’

    break

    elif y3 == 1:

    a_reverse =y2 % 52

    break

    else:

    Q = x3 // y3

    t1, t2, t3 = x1 - Q * y1, x2 - Q * y2, x3 - Q * y3

    x1, x2, x3 = y1, y2, y3

    y1, y2, y3 = t1, t2, t3

    #已知模求逆元
    for i in range(1,53):
    if k1 * i % 52 == 1:
    a_reverse = i

    message1 = list(message)
    list1=list(map(chr,range(ord(‘a’),ord(‘z’)+1)))
    list2=list(map(chr,range(ord(‘A’),ord(‘Z’)+1)))
    for i in range(len(list1)):
    list1.append(list2[i])
    x=[]
    for i in range(len(message1)):
    if message1[i]==’ ':
    x.append(message1[i])
    else:
    for j in range(52):
    if message1[i]==list1[j]:
    x.append(list1[(a_reverse * (j-k2) )% 52])
    result = ‘’.join(x)
    return result

    *end#

    def main():
    mode = int(input()) # 1代表加密,0代表解密
    message = input() #待加密或解密的消息
    key1 = int(input()) # key的范围0~51之间
    key2 = int(input()) # key的范围0~51之间
    if mode == 1:
    translated = encrypt(key1,key2,message)
    else:
    translated = decrypt(key1,key2,message)
    print(translated)

    if name==‘main’:
    main()

    测试输入:
    1
    zhang
    7
    31
    预期输出:
    YCFsv
    测试输入:
    0
    gVEXGT iDIT
    5
    29
    预期输出:
    Lovely Baby

    总结

    到此这篇关于python语言编程实现凯撒密码、凯撒加解密算法的文章就介绍到这了,更多相关python凯撒密码 凯撒加解密算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多

    茂名论坛https://www.hnthzk.com/

    化州橘红http://www.sfkyty.com/

    茂名论坛http://www.nrso.net/

    源码搜藏网http://www.cntkd.net/

    茂名市高级技工学校(茂名一技)http://www.szsyby.net/

    茂名一技https://www.mmbbu.com/

    展开全文
  • 为了提高自己搭建的Django站点的安全性,加密后的数据库连接信息以及加密使用的信息单独存放在了一个配置文件中,之后写了一个中间层来解密配置文件中的密文并用于站点应用连接数据库。虽然这样一种安全方式很初级...
    为了提高自己搭建的Django站点的安全性,将加密后的数据库连接信息以及加密使用的信息单独存放在了一个配置文件中,之后写了一个中间层来解密配置文件中的密文并用于站点应用连接数据库。虽然这样一种安全方式很初级,但起码比明文存放密码等敏感信息要好的多。

    现在面临另外一个问题,因为最终密文形式的密码还是需要解密后才能使用的,上边提到的用于解密配置文件中的密文的中间层正是用于此目的。若恶意用户获取到了相关文件,很容易根据文件中的代码推测出加密使用的算法,也很容易获取的明文的密码,因此现在需要一种方式将python源代码转换成不能被“小人”轻易读取的文件形式。

    怎么转换呢?其实通过将python源程序.py文件编译为字节码文件.pyc或.pyo就可以很好的达到上述目的(尽管这仍有可能被恶意着反编译为.py源文件,但至少算是有加强了一层防护,是无意的“君子”不至于这么轻松获取密码。)

    那么该如何编译python源程序呢?

    可以有多重形式:
    python -m py_compile file.py #把单个.py文件编译为字节码文件
    python -m py_compile /path/to/src/ #批量生成字节码文件,/path/to/src/是包含.py文件名的路径
    python -m compileall file.py #把单个.py文件编译为字节码文件
    python -m compileall /path/to/src/ #批量生成字节码文件,/path/to/src/是包含.py文件名的路径

    或者:
    python -O -m py_compile file.py
    python -O -m py_compile /path/to/src/
    python -O -m compileall file.py
    python -O -m compileall /path/to/src/

    或者
    python -OO -m py_compile file.py
    python -OO -m py_compile /path/to/src/
    python -OO -m compileall file.py
    python -OO -m compileall /path/to/src/

    或者通过脚本来编译:
    import py_compile
    py_compile.compile('file.py')

    import compileall
    compileall.compile_file('file.py')

    import compileall
    compileall.compile_dir('/path/to/src/')
    compileall.compile_path()

    具体参数:
        compile(file, cfile=None, dfile=None, doraise=False)
            Byte-compile one Python source file to Python bytecode.
            
            Arguments:
            
            file:    source filename
            cfile:   target filename; defaults to source with 'c' or 'o' appended
                     ('c' normally, 'o' in optimizing mode, giving .pyc or .pyo)
            dfile:   purported filename; defaults to source (this is the filename
                     that will show up in error messages)
            doraise: flag indicating whether or not an exception should be
                     raised when a compile error is found. If an exception
                     occurs and this flag is set to False, a string
                     indicating the nature of the exception will be printed,
                     and the function will return to the caller. If an
                     exception occurs and this flag is set to True, a
                     PyCompileError exception will be raised.


        compile_dir(dir, maxlevels=10, ddir=None, force=0, rx=None, quiet=0)
            Byte-compile all modules in the given directory tree.
            
            Arguments (only dir is required):
            
            dir:       the directory to byte-compile
            maxlevels: maximum recursion level (default 10)
            ddir:      the directory that will be prepended to the path to the
                       file as it is compiled into each byte-code file.
            force:     if 1, force compilation, even if timestamps are up-to-date
            quiet:     if 1, be quiet during compilation
        
        compile_file(fullname, ddir=None, force=0, rx=None, quiet=0)
            Byte-compile one file.
            
            Arguments (only fullname is required):
            
            fullname:  the file to byte-compile
            ddir:      if given, the directory name compiled in to the
                       byte-code file.
            force:     if 1, force compilation, even if timestamps are up-to-date
            quiet:     if 1, be quiet during compilation
        
        compile_path(skip_curdir=1, maxlevels=0, force=0, quiet=0)
            Byte-compile all module on sys.path.
            
            Arguments (all optional):
            
            skip_curdir: if true, skip current directory (default true)
            maxlevels:   max recursion level (default 0)
            force: as for compile_dir() (default 0)
            quiet: as for compile_dir() (default 0)

    注解:
    -m参数相当于脚本中的import,这里的-m py_compile 相当于上面的 import py_compile,也即把后边跟随的库模块当做脚本运行。这样生成的字节码文件后缀名为.pyc
    -O参数表明要生成更加紧凑的优化后的字节码,-OO会进一步移除-O选项生成的优化后的字节码文件中的文档字符串。这样生成的字节码文件后缀名为.pyo,对于.pyo文件可以通过 python命令加-O参数执行导入了该模块的python程序来调用。
    需注意的是,不同版本编译后的pyc文件是不同的,比如2.5编译的pyc文件2.4版本的python是无法执行的。










    展开全文
  • 一、DSE算法背景介绍 1. DES的采用 1979年,美国银行协会批准使用 ...64位一组的明文从算法一端输入,64位密文从另一端输出。 2) 对称算法: 加密和解密用同一密钥。 3) 有效密钥长度56位。 密钥通常表示
  • 注意:密文是大写字母,在变换加密之前把明文字母都替换大写字母 def casar(message): # *************begin************# message1=message.upper() #把明文字母变成大写 message1=list(message1) #将明文字符...

    凯撒密码的原理:计算并输出偏移量为3的凯撒密码的结果
    注意:密文是大写字母,在变换加密之前把明文字母都替换为大写字母

    def casar(message):
    # *************begin************#
        message1=message.upper()   #把明文字母变成大写
        message1=list(message1)   #将明文字符串转换成列表
        list1=[]
        for i in range(len(message1)):
            if message1[i]==' ':
                list1.append(message1[i])  #若为空格不用移动
            elif ord(message1[i]) <= 90-3+1:    #A-X右移三位
                list1.append(chr(ord(message1[i]) + 3))
                result = ''.join(list1)    #列表转换成字符串
            else:
                list1.append(chr(ord(message1[i]) - (26-3)))  #Y和Z回到A、B
                result = ''.join(list1)
        print(result)
    # **************end*************#  
        
        
    def main():
        message = input()
        casar(message)
    if __name__=='__main__':
        main()
    

    测试输入:Guet
    预期输出:JXHW
    测试输入:information security
    预期输出:LQIRUPDWLRQ VHFXULWB

    凯撒密码原理:根据输入的加解密模式和密钥对消息进行加解密。
    注意:如果是加密,输出的密文是大写字母,如果是解密,按照凯撒解密后,转换为小写后,输出解密后的明文.

    def casar(mode,message,key):
    # *************begin************#
        if mode==1:   #加密
            message1 = message.upper()  # 把明文字母变成大写
            message1 = list(message1)  # 将明文字符串转换成列表
            list1 = []
            for i in range(len(message1)):
                if message1[i] == ' ':
                    list1.append(message1[i])  # 若为空格不用移动
                elif ord(message1[i]) <= 65 +key-1: 
                    list1.append(chr(ord(message1[i]) + key))   # 右移key位
                    result = ''.join(list1)  # 列表转换成字符串
                else:
                    list1.append(chr(ord(message1[i]) - key)) 
                    result = ''.join(list1)
            print(result)
        elif mode==0:  #解密
            message2 = list(message)  # 将明文字符串转换成列表
            list2 = []
            for i in range(len(message2)):
                if message2[i] == ' ':
                    list2.append(message2[i])  # 若为空格不用移动
                elif ord(message2[i]) <= 65+ key -1:  
                    list2.append(chr(ord(message2[i]) + (26-key))) # 右移三位
                    result = ''.join(list2)  # 列表转换成字符串
                else:
                    list2.append(chr(ord(message2[i]) - key))  
                    result = ''.join(list2)
            result = result.lower()
            print(result)
    
    # **************end*************#  
    
    def main():
        mode = int(input()) # 1代表加密,0代表解密
        message = input() #待加密或解密的消息
        key = int(input()) # key的范围0~25之间
        casar(mode,message,key)
    if __name__=='__main__':
        main()
    

    测试输入:
    1
    zhang
    13
    测试输出:
    MUNAT
    测试输入:
    0
    GOHUN
    7
    测试输出:
    zhang

    编写一个仿射加解密程序,范围是所有的大小写字母范围
    本题需要掌握相关知识1.仿射加密算法,2.扩展的欧几里得算法。
    假设X,Y,a,b是Z52整数环中的元素,a和b为密钥,X是原文,Y是密文
    加密函数:Y=(aX+b)%52
    获取乘法逆元
    通过扩展的欧几里得算法求a的乘法逆元
    加密过程
    加密函数:Y=(aX+b)%52
    解密过程
    解密函数:X=(a的逆元)*(Y-B)%52

    #仿射密码
    
    def encrypt(k1,k2,message):
    # *************begin************#
        message1 = list(message)
        list1=list(map(chr,range(ord('a'),ord('z')+1)))
        list2=list(map(chr,range(ord('A'),ord('Z')+1)))
        for i in range(len(list1)):
            list1.append(list2[i])
        y=[]
        for i in range(len(message)):
            if message1[i]==' ':
                y.append(message1[i])
            else:
                for j in range(52):
                    if message1[i]==list1[j]:
                        y.append(list1[(k1*j + k2) % 52])
                        result = ''.join(y)
        return result
    # **************end*************#   
    
    def decrypt(k1,k2,message):
    # *************begin************#
    	#扩展欧几里得算法求逆元法
        # x1, x2, x3 = 1, 0, 52  
        # y1, y2, y3 = 0, 1, k1
        # while True:
        #     if y3 == 0:
        #         return 'None'
        #         break
        #     elif y3 == 1:
        #         a_reverse =y2 % 52
        #         break
        #     else:
        #         Q = x3 // y3
        #         t1, t2, t3 = x1 - Q * y1, x2 - Q * y2, x3 - Q * y3
        #         x1, x2, x3 = y1, y2, y3
        #         y1, y2, y3 = t1, t2, t3
        
        #已知模求逆元
        for i in range(1,53):
            if k1 * i % 52 == 1:
                 a_reverse = i
    
        message1 = list(message)
        list1=list(map(chr,range(ord('a'),ord('z')+1)))
        list2=list(map(chr,range(ord('A'),ord('Z')+1)))
        for i in range(len(list1)):
            list1.append(list2[i])
        x=[]
        for i in range(len(message1)):
            if message1[i]==' ':
                x.append(message1[i])
            else:
                for j in range(52):
                    if message1[i]==list1[j]:
                        x.append(list1[(a_reverse * (j-k2) )% 52])
                        result = ''.join(x)
        return result
                
    # **************end*************#     
    
    def main():
        mode = int(input()) # 1代表加密,0代表解密
        message = input() #待加密或解密的消息
        key1 = int(input()) # key的范围0~51之间
        key2 = int(input()) # key的范围0~51之间
        if mode == 1:
            translated = encrypt(key1,key2,message)
        else:
            translated = decrypt(key1,key2,message)
        print(translated)
    
    if __name__=='__main__':
        main()
    

    测试输入:
    1
    zhang
    7
    31
    预期输出:
    YCFsv
    测试输入:
    0
    gVEXGT iDIT
    5
    29
    预期输出:
    Lovely Baby

    展开全文
  • Python——hashlib模块

    2021-01-04 20:20:37
    Python——hashlib模块 用于加密相关的操作,3.x里代替了md5模块和sha模块,主要提供 SHA1, SHA...3、md5 密文不能反解(明文加密成密文密文不能解密为明文) 既然不能反解,那就用户名也加密成密文,让用户名的密
  • RSA算法的具体描述如下: [5] (1)任意选取两个不同的大素数p和q计算乘积 [5] ; (2)任意选取一个大整数e,满足 ,整数e用做加密钥(注意:e的选取是很...(6)将密文c解密为明文m,解密算法为 [5] 然而只根据n和
  • 每一个密钥字母被用来加密一个明文字母,第一个密钥字母加密第一个明文字母,第二个密钥字母加密第二个明文字母,等所有密钥字母使用完后,密钥再次循环使用,于是加解密前需先密文按照密钥长度进行分组。...
  • 一、凯撒加密法原理 ...此时明文中的‘A’移到了数字4的位置,A加密成了E,将明文信息“Today”对照密文对应的字母,结果“XSHEC”。 解密的话,要先知道密钥(移位的值),再明文中的A移到对应的数字上,
  • python 实现凯撒加密

    万次阅读 多人点赞 2019-05-07 20:11:44
    加密时,我们需要某个明文字母做N位偏移得到密文,这个N最多26,而且偏移26时和偏移0时一样,明文密文对应相等,实际上可以说最大的偏移量25,这里的偏移量是这个加密解密算法的核心,我们可以说他就是...
  • python对凯撒密码的实现

    万次阅读 2016-12-07 12:58:05
    明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。例如,当偏移量是3的时候,所有的字母A被替换成D,B变成E,以此类推X变成A,Y变成B,Z变成C。由此可见,位数就是凯撒密码...
  • 数据加密是指利用加密算法和秘钥将明文转变为密文的过程。 二、数据加密的方式 1、单向加密 指只能加密数据而不能解密数据,这种加密方式主要是为了保证数据的完整性,常见的加密算法有MD5、sha系列等(位于python...
  • DES原理及Python实现

    千次阅读 2019-01-12 16:53:13
    DES是分组密码的一类,是一种对称密码技术,使用了Feistel的网络结构,将明文分成多个等长模块,使用确定的算法以及对称并且相同的密钥对明密文进行加解密。 算法流程 64位的明文经过初始置换而被重新排列,并...
  • 凯撒加密算法的python实现

    千次阅读 2020-03-28 17:42:20
    它是一种替换加密的技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。 2. 加密方法 ** 恺撒密码的加密、解密方法还能够通过同余的数学方法进行计算。首先字母用数字代替...
  • 代换密码体制的一般定义为M=C=K=Z26,其中M为明文空间、C为密文空间、K为密钥空间、Z26为26个整数(对应26个英文字母)组成的空间;要求26个字母与模26的剩余类集合{0,1,2,…,25}建立一一对应的关系。 1、移位密码 ...
  • a.append(ord(ch.upper())-65) #ord()函数返回ASCii值 upper()小写转大写Python 列表 append() 方法用于在列表末尾追加新的对象。 get_list = a ciphertext = ''; i = 0 for ch in src: # 遍历明文 if ...
  • ^最重要的一点是密文,即将明文转换为密文的算法 ^我们有更高级的术语,例如盐,初始化向量和派生密钥。 ^这些术语在生成密文的算法中内部使用 ^这些术语的想法是尽可能随机地生成密钥,并避免或防止彩虹表或字典...
  • e(x)=11x+6(mod26) 密文:welcylk (flagbase64形式) ... 注意仿射变换26个字母按数字0~25记,因此在需要将密文ASCII对应的数值减去97,解密完恢复成字母即加上97 此外,题目要求最后的flagbase64形.
  • 明文plaintext1你的姓名的汉语拼音(如果不够8字符的整数倍,则用下划线填充),密钥字符串24062406,使用DES算法对其进行加密和解密操作,密文用变量名ciphertext1表示,其显示的值以便于阅读的16进制形式...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

python将密文解密为明文

python 订阅