精华内容
下载资源
问答
  • 2022-05-13 11:31:07

    凯撒加密是最简单的加密算法,代码如下 :

    def kaisa(n):#加密函数
     for m in n:
          if m==" ":
           return ' '
          elif 97<=ord(m)<123-key or 65<=ord(m)<91-key:#位移值不超过最后一个z字母
              m=chr(ord(m)+key)
              return m
          elif ord(m)>=123-key or 91-key<=ord(m)<91:
           m=chr(ord(m)+key-26)
           return m
    out=''
    #求解算法
    while 1:
        plaintext=input('请输入明文:')
        if plaintext=='退出':
            break
        key=eval(input('请输入位移值:'))
        for i in list(map(kaisa,plaintext)):
         out+=i
        print('加密结果为:',out)
    

    代码比较简单,主要思路就是将明文全都往后推几个字母变成密文,故可以通过穷举的方式列出所有可能的明文结果,代码如下:

    #破解凯撒加密
    
    def jiema(m):
     for i in m:
         if i ==' ':
            return " "
         elif 97+key<=ord(m)<123 or 65+key<=ord(m)<92:
            m=chr(ord(m)-key)
            return m
         elif 97<=ord(m)<97+key or 65<=ord(m)<65+key:
            m=chr(ord(m)-key+26)
            return m
    m=input('请输入密文:')
    out=''
    for key in range(1,27):
        for n in list(map(jiema,m)):
         out = out + str(n)
        print('第%d个可能的结果是%s'%(key,out))
        out=''

    感谢大家观看。

    更多相关内容
  • python实现凯撒密码加密解密 凯撒加密就是通过将字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移,被替换成密文。例如,当偏移量是2的时候,所有的字母B将...
  • 主要介绍了利用python实现凯撒密码解密功能,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 凯撒密码加密解密,用python编写,可分两个程序运行
  • 利用python实现凯撒密码解密实验目的实验内容实验环境实验步骤实验代码及运行结果1.import this运行结果原理分析2.实现凯撒解密过程实验代码运行结果写在最后 实验目的 应用Python程序设计语言的相关知识,理解...
  • 密码学中,凯撒密码(英语:Caesar cipher),或称凯撒加密、凯撒变换、变换加密,是一种最简单且最广为人知的加密技术。它是一种替换加密的技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目...

    在密码学中,凯撒密码(英语:Caesar cipher),或称凯撒加密、凯撒变换、变换加密,是一种最简单且最广为人知的加密技术。它是一种替换加密的技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。
    需求分析:
    1、输入一行明文,使用凯撒加密方法对其加密,其中为保证加密的随机性,对Key进行随机处理。
    2、对于加密后的密文,使用暴力搜索的方法对其进行解密,并调用字典对解密后的字词进行比较,自动选出正确的密匙。
    例如:
    在这里插入图片描述

    先放一个不带UI界面的代码

    from random import randint
    
    import enchant
    from enchant.checker import SpellChecker
    import numpy as np
    import string
    
    #加密
    def kaisa(s, k):  # 定义函数 接受一个字符串s 和 一个偏移量k
    
        lower = string.ascii_lowercase  # 小写字母
        upper = string.ascii_uppercase  # 大写字母
        before = string.ascii_letters  # 无偏移的字母顺序 小写+大写
        after = lower[k:] + lower[:k] + upper[k:] + upper[:k]  # 偏移后的字母顺序 还是小写+大写
        # 分别把小写字母和大写字母偏移后再加到一起
        table = ''.maketrans(before, after)  # 创建映射表
        return s.translate(table)  # 对s进行偏移 即加密
    
    s = input('请输入一个字符串:')
    
    k = randint(0,26) #从0-25中挑选随机一个数字当做偏移量
    print(kaisa(s, k))
    
    #解密
    
    # message = input("message:")
    message = kaisa(s,k)
    LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    true_yuju = ""
    tmp = np.ones((1,26))
    # print(tmp)
    # 把每个可能的密钥循环一遍
    message = "GUVF VF ZL FRPERG ZRFFNTR"
    for key in range(len(LETTERS)):
        # key代表密钥
        # translated设为空字符串
        # 每次循环后清空.
        translated = ''
        # 密文里的每一个字符按顺序解密
        for symbol in message:
            if symbol in LETTERS:
                num = LETTERS.find(symbol) # 在26个字母里搜索到密文字符的位置
                num = num - key
                # 检查是否小于0,如果小于0,就加上26
                if num < 0:
                    num = num + len(LETTERS)
                # 把解密之后的字符追加到translated字符串的末尾
                translated = translated + LETTERS[num]
    
            else:
                # 密文里的symbol如果不在26个字母里,就不进行解密,直接追加到字符串末尾
                translated = translated + symbol
    
        # 输出解密采用的key和解密后的明文
        print('Key #%s: %s' % (key, translated))
        chkr = SpellChecker("en_US")
        chkr.set_text(translated)
        for err in chkr:
            if(err.word == None):
                true_yuju = translated
            else:
                tmp[0][key] = 0
        if(tmp[0][key] == 1):
            true_yuju = translated
    print("正确的是: ",true_yuju)
    
    

    再放一个带UI界面的代码:

    import tkinter
    from tkinter import *
    # from project1 import kaisa
    from random import randint
    import string
    import numpy as np
    from enchant.checker import SpellChecker
    
    def kaisa(s, k):  # 定义函数 接受一个字符串s 和 一个偏移量k
    
        lower = string.ascii_lowercase  # 小写字母
        upper = string.ascii_uppercase  # 大写字母
        before = string.ascii_letters  # 无偏移的字母顺序 小写+大写
        after = lower[k:] + lower[:k] + upper[k:] + upper[:k]  # 偏移后的字母顺序 还是小写+大写
        # 分别把小写字母和大写字母偏移后再加到一起
        table = ''.maketrans(before, after)  # 创建映射表
        return s.translate(table)  # 对s进行偏移 即加密
    
    class MY_GUI():
        def __init__(self, init_window_name):
            self.init_window_name = init_window_name
    
        def set_init_window(self):
            self.init_window_name.title("凯撒密码")
            self.init_window_name.geometry('680x500+10+10')
            self.init_window_name.resizable(False, False)
    
            self.init_label = Label(self.init_window_name, text = "初始字符串: ", height = 2, width = 10,anchor="w")
            self.init_label.grid(row = 0, column = 0)
            self.encipher_label = Label(self.init_window_name, text = "加密后结果: ", height = 2, width = 10,anchor="w")
            self.encipher_label.grid(row = 1, column = 0)
            self.decipher_label = Label(self.init_window_name, text = "解密后结果: ", height = 2, width = 10,anchor="w")
            self.decipher_label.grid(row = 2, column = 0)
    
            self.init_data_Text = Text(self.init_window_name, height =1, width = 70)
            # self.init_data_Text.insert(1.0, "abc")
            self.init_data_Text.grid(row = 0, column = 1, padx = 5, pady = 5)
            self.encipher_data_Text = Text(self.init_window_name, width = 70, height = 1)
            self.encipher_data_Text.grid(row =1, column = 1)
            self.decipher_data_Text = Text(self.init_window_name, width = 70, height = 30)
            self.decipher_data_Text.grid(row = 2, column = 1, padx = 5, pady = 5,rowspan =30)
            self.encipher_button = Button(self.init_window_name, text= "加密", width=10, command=self.encipher)
            self.encipher_button.grid(row=0, column=11)
            self.decipher_button = Button(self.init_window_name, text="解密", width = 10, command = self.decipher)
            self.decipher_button.grid(row = 2, column = 11)
    
        def encipher(self):
            str = self.init_data_Text.get(1.0, END)
            k = randint(0, 26)
            encipher_text = kaisa(str, k)
            #encipher_text = "abc"
            self.encipher_data_Text.insert(1.0, encipher_text)
        def decipher(self):
            message = self.encipher_data_Text.get(1.0, END)
            LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
            true_yuju = ""
            tmp = np.ones((1, 26))
            # print(tmp)
            # 把每个可能的密钥循环一遍
            result = ""
            KEY = 0
            for key in range(len(LETTERS)):
                # key代表密钥
                # translated设为空字符串
                # 每次循环后清空.
                translated = ''
                # 密文里的每一个字符按顺序解密
                for symbol in message:
                    if symbol in LETTERS:
                        num = LETTERS.find(symbol)  # 在26个字母里搜索到密文字符的位置
                        num = num - key
                        # 检查是否小于0,如果小于0,就加上26
                        if num < 0:
                            num = num + len(LETTERS)
                        # 把解密之后的字符追加到translated字符串的末尾
                        translated = translated + LETTERS[num]
    
                    else:
                        # 密文里的symbol如果不在26个字母里,就不进行解密,直接追加到字符串末尾
                        translated = translated + symbol
    
                # 输出解密采用的key和解密后的明文
                print('Key #%s: %s' % (key, translated))
                result += "Key #" + str(key) + ": " + str(translated)
                result = result.strip('\n')
                result += '\n'
                chkr = SpellChecker("en_US")
                chkr.set_text(translated)
                for err in chkr:
                    if (err.word == None):
                        true_yuju = translated
                    else:
                        tmp[0][key] = 0
                if (tmp[0][key] == 1):
                    true_yuju = translated
                    KEY = key
            result += '\n' + '\n'
            true_yuju = "Key为: "+ str(KEY) + " 解密后的信息为: " + true_yuju
            result += true_yuju
            self.decipher_data_Text.insert(1.0, result)
    
    def gui_start():
        init_window = Tk()
        ZMJ_PORTAL = MY_GUI(init_window)
        # 设置根窗口默认属性
        ZMJ_PORTAL.set_init_window()
        init_window.mainloop()  # 父窗口进入事件循环,可以理解为保持窗口运行,否则界面不展示
    gui_start()
    
    展开全文
  • 凯撒密码 来自 百度百科凯撒密码密码学中,恺撒密码(英语:Caesar cipher),或称恺撒加密、恺撒变换、变换加密,是一种最简单且最广为人知的加密技术。...使用python3实现 凯撒解密 加密函数 # Caesar class Cae

    凯撒密码

    来自 百度百科凯撒密码

    在密码学中,恺撒密码(英语:Caesar cipher),或称恺撒加密、恺撒变换、变换加密,是一种最简单且最广为人知的加密技术。它是一种替换加密的技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。例如,当偏移量是3的时候,所有的字母A将被替换成D,B变成E,以此类推。这个加密方法是以罗马共和时期恺撒的名字命名的,当年恺撒曾用此方法与其将军们进行联系。

    在这里插入图片描述

    使用python3实现 凯撒加解密

    加密函数

    #  Caesar
    class Caesar:
        def encryption(self,x,num1):
            li = [chr(i) for i in range(65,91)] 
            ls = [chr(i) for i in range(97,123)]
            li1 = []
            for i in x:      
                if i in ls and num1 <= 25:    
                    s = ls.index(i)          
                    if s+num1 >= len(ls[s:]):  
                        li1.append(ls[num1-len(ls[s:])]) 
                    else:
                        li1.append(ls[s+num1]) 
                elif i in li and num1 <= 25:   
                    s1 = li.index(i)           
                    if s1+num1 > len(li[s1:]):  
                        li1.append(li[num1-len(li[s1:])]) 
                    else:
                        li1.append(li[s1+num1])  
                else:
                    li1.append(i)
            if len(li1) > 0: 
                return ''.join(li1) 
            return x 
    

    解密函数

        # decrypt
        def decrypt(self,x,num1):
            li = [chr(i) for i in range(65,91)] 
            ls = [chr(i) for i in range(97,123)] 
            li1 = [] 
            for i in x: 
                if i in ls and num1 <= 25: 
                    s = ls.index(i)
                    li1.append(ls[s+(-num1)]) 
                elif i in li and num1 <= 25: 
                    s1 = li.index(i) 
                    li1.append(li[s1+(-num1)]) 
            if len(li1) > 0:
                return ''.join(li1)
            return x 
    
    展开全文
  • 主要介绍了python语言编程实现凯撒密码凯撒解密算法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • python实现 古典密码 凯撒密码加密解密 实现效果如下图: # 凯撒密码加密解密 # author Sundm string = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x'...

    python实现 古典密码 凯撒密码的加密与解密

    实现效果如下图:

    在这里插入图片描述

    # 凯撒密码加密与解密
    # author Sundm
    
    string = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
    # 密文列表
    cipher_text_list = []
    # 明文列表
    plain_text_list = []
    # 凯撒密码加密函数
    def encrypt():
        cipher = int(input("请输入你的密钥:"))
        plaintext = input("请输入你的明文:")
    
        length = len(plaintext)
    
        print("加密后的密文是:")
        for i in range(0,length):
            cipher_text_list.append(string[string.index(plaintext[i])+cipher])
            print(cipher_text_list[i],end="")
    # 凯撒密码解密函数
    def decrypt():
        cipher = int(input("请输入你的密钥:"))
        ciphertext = input("请输入你的密文:")
        length = len(ciphertext)
    
        print("解密后的明文是:")
        for i in range(0,length):
            plain_text_list.append(string[string.index(ciphertext[i])-cipher])
            print(plain_text_list[i],end="")
    
    
    def main():
        print("##################################")
        print("        凯撒密码加密与解密         ")
        print("----------------------------------")
        print("         0. 退出程序              ")
        print("         1. 凯撒密码加密          ")
        print("         2. 凯撒密码解密          ")
    
        while True:
            choice = int(input("\n请输入数字进行选择:"))
            if choice == 0:
                break
            elif choice == 1 :
                cipher_text_list.clear()
                encrypt()
            elif choice == 2:
                plain_text_list.clear()
                decrypt()
            else:
                print("输入错误,请重新进行输入")
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • 该压缩包包含了Python脚本编写的摩斯密码加密解密、培根密码加密解密、ASCII编码解码、凯撒密码加密解密,可用于教学和实操
  • Python编程:实现凯撒密码加密解密

    万次阅读 多人点赞 2018-10-12 16:54:44
    凯撒密码 原理: 通过把字母移动一定的位数来实现加解密 明文中的所有字母从字母表向后(或向前)按照一个固定步长进行偏移后被替换成密文。 例如: 当步长为3时,A被替换成D,B被替换成E,依此类推,X替换成A。 在...
  • python练习:加密解密凯撒密码

    万次阅读 多人点赞 2019-04-19 14:47:05
    恺撒密码是古罗马恺撒大帝用来对军事情报进行加解密的算法,它采用了替换方法对信息中的每一个英文字符循环替换为字母表序列中该字符后面的第三个字符,即,字母表的对应关系如下:‪‬‪‬‪‬‪‬‪‬‮...
  • Python凯撒密码解密

    千次阅读 2021-04-07 19:30:16
    Python编写基于词频统计方法的凯撒密码解密
  • Python实现凯撒密码加密解密

    万次阅读 多人点赞 2017-10-17 00:30:24
    除非知道这个键(即用于加密消息的数字),否则无法对这个保密的代码进行解密凯撒密码是人类最早发明的密码之一,原理是获取消息中的每个字母,并用一个“移位后的”字母来代替它,如果把字母A移动1格
  • 这个程序可以帮你用凯撒密码加密或者解密,快给你的情人发一个秘密情书吧! 在密码学中,恺撒密码(英语:Caesar cipher),或称恺撒加密、恺撒变换、变换加密,是一种最简单且最广为人知的加密技术。它是一种替换...
  • import string letter = string.ascii_letters ... print("输入数字1为凯撒加密,输入数字2为凯撒解密,输入0退出!") choice = int(input('请输入相应数值:')) if choice == 1: kaisa_jiami() elif choice =.
  • Python实现凯撒密码加密解密

    千次阅读 2021-01-30 14:14:36
    运行凯撒密码 原理: 通过把字母移动一定的位数来实现加解密 明文中的所有字母从字母表向后(或向前)按照一个固定步长进行偏移后被替换成密文。 例如: 当步长为3时,A被替换成D,B被替换成E,依此类推,X替换成...
  • 凯撒密码的原理:计算并输出偏移量为3的凯撒密码的结果 注意:密文是大写字母,在变换加密之前把明文字母都替换为大写字母 def casar(message): # *************begin************# message1=message.upper() #把...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么?... 1.... 2....第一篇blog为恺撒密码 ...一、确定恺撒密码原理,用公式表示 ... s = input("请输入需要加密的文.
  • 凯撒密码 单表替代密码 ——凯撒(Caesar)密码,又叫循环移位密码。它的加密方法就是将明文中的每个字母用字母表中该字母后的第R个字母来替换,达到加密的目的。 加密过程可以表示为下面的函数: E(x) = (x + key) ...
  • 凯撒密码的原理和Python实现。
  • Python 编写凯撒密码加密解密

    千次阅读 2020-07-08 08:00:39
    Caesar密码 让每个字母等价一个数 加密算法: C=(p+k)mod 26 解密算法: C=(p-k)mod 26 (k = [ 1,25 ]) def on_key(string,num): #加密函数 work=""#加密后的结果 for i in string: if i==" ": work=...
  • 凯撒密码python加密

    2020-12-03 19:31:05
    Python源代码:Note: working for negative shift numbers alsoNote: if reverse shift then we do encode - decode messageNote: preserving spaces alsosmall_chars = [chr(item) for item in range(ord('a'), ord...

空空如也

空空如也

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

python凯撒密码加密解密