自学内容网 自学内容网
自学内容网 > 正文

实验一 古典密码算法的设计与实现

🕗 发布于 2024-02-05 18:29 算法  linux  服务器  

✅作者简介：CSDN内容合伙人、信息安全专业在校大学生🏆
🔥系列专栏 ：简单外包单
📃新人博主 ：欢迎点赞收藏关注，会回访！
💬舞台再大，你不上台，永远是个观众。平台再好，你不参与，永远是局外人。能力再大，你不行动，只能看别人成功！没有人会关心你付出过多少努力，撑得累不累，摔得痛不痛，他们只会看你最后站在什么位置，然后羡慕或鄙夷。

文章目录

实验一 古典密码算法的设计与实现

一、实验目的

通过编程实现替代密码和置换密码算法，加深对古典密码体制对了解，为深入学习密码学奠定基础。

二、实验任务

实验内容与要求：自己生成明文，并选择一个密钥，编程实现一种替代密码和一种置换密码算法，实现加解密操作，要求上述密码算法最后的实现程序提供加密和解密两个接口，提供图形化用户界面（选做）。提交核心程序代码和执行结果，并撰写实验报告。

三、实验环境

信息楼西505，Windows10，python3.9.7

四、实验原理

4.1 替代密码

密钥生成： 替代密码的关键是一个密钥，该密钥定义了明文字符和密文字符之间的映射关系。密钥通常是一个简单的置换表，其中包含字母表的不同排列。
加密： 加密过程涉及将明文中的每个字符替换为密钥中相应字符。例如，如果密钥规定字母A映射到密文中的字母D，则在加密时，所有的A都会被替换为D。
解密： 解密是加密的逆过程，涉及将密文字符替换为明文字符。如果在加密中A映射到D，那么在解密中D将被替换为A。
单字母替代和多字母替代： 替代密码可以是单字母替代，其中每个明文字母都被替换为一个密文字母，也可以是多字母替代，其中一组字母被替换为另一组字母或符号。

4.2 置换密码

单行置换密码：
密钥生成： 单行置换密码使用一个密钥，通常是一个数字或单词，表示重新排列字符的规则。
加密： 将明文按照密钥规定的顺序重新排列，然后读取排列后的字符以生成密文。例如，如果密钥是2314，那么明文中的第一个字符就会被移到第二个位置，第二个移到第三个位置，以此类推。

解密： 解密过程是加密过程的逆操作，按照密钥规定的逆序重新排列密文即可还原为明文。
多行置换密码：
密钥生成： 多行置换密码使用一个矩阵作为密钥，规定了字符的排列顺序。
加密： 将明文按照矩阵的规定，逐行写入矩阵，然后按列读取，得到密文。例如，如果密钥矩阵为：3 1 4 2那么明文中的字符将按照列的顺序排列，生成密文。
解密： 解密过程是加密过程的逆操作，按照密钥规定的逆序重新排列密文即可还原为明文。

五、程序设计核心代码

在SubstitutionCipher类的构造函数中，接受用户提供的密钥，并初始化两个字典，encrypt_dict和decrypt_dict。encrypt_dict将明文字母映射到密钥对应的字母，而decrypt_dict则实现反向映射。
加密：encrypt方法接受一个字符串作为参数，遍历字符串中的每个字符。对于字母字符，根据其大小写使用encrypt_dict进行替换；对于非字母字符，保持不变。构建加密后的字符串并返回。
解密：decrypt方法与encrypt类似，遍历输入字符串中的每个字符。对于字母字符，根据其大小写使用decrypt_dict进行替换；对于非字母字符，保持不变。构建解密后的字符串并返回。
这个算法简单地通过替换字母来实现替代密码。界面部分使用了tkinter库来构建一个简单的图形用户界面，用户可以通过界面输入密钥和文本，然后进行加密和解密操作。

  1. def encrypt(self, text):
  2. encrypted_text = ''  

  3. **for** char **in** text:  

  4.     **if** char.isalpha():  # 只加密字母  

  5.         **if** char.islower():  

  6.             encrypted_text += self.encrypt_dict.get(char, char)  

  7.         **else**:  

  8.             encrypted_text += self.encrypt_dict.get(char.lower(), char)  

  9.     **else**:  

  10.         encrypted_text += char  

  11. **return** encrypted_text
  13. def decrypt(self, text):
  14. decrypted_text = ''  

  15. **for** char **in** text:  

  16.     **if** char.isalpha():  # 只解密字母  

  17.         **if** char.islower():  

  18.             decrypted_text += self.decrypt_dict.get(char, char)  

  19.         **else**:  

  20.             decrypted_text += self.decrypt_dict.get(char.lower(), char)  

  21.     **else**:  

  22.         decrypted_text += char  

  23. **return** decrypted_text

SubstitutionCipher 类是置换密码的实现，它包含一个构造函数和两个方法：encrypt_block 和 encrypt。encrypt_block 方法对一个8位的文本块进行置换加密。encrypt 方法将输入的文本分割成8位一组的块，然后对每个块调用 encrypt_block 方法进行加密，最后合并所有的块。decrypt 方法通过将密钥反转后，使用相同的加密逻辑进行解密。SubstitutionCipherGUI 类是用户界面的实现，通过 Tkinter 构建。它包含一个构造函数和三个方法：encrypt_text、decrypt_text 和 create_widgets。create_widgets 方法负责创建用户界面的各种元素，包括标签、输入框、文本框以及加密和解密按钮。encrypt_text 方法从界面获取用户输入的密钥和文本，然后调用 SubstitutionCipher 类的 encrypt 方法进行加密，并将结果显示在界面上。
decrypt_text 方法同样从界面获取用户输入的密钥和文本，然后调用 SubstitutionCipher 类的 decrypt 方法进行解密，并将结果显示在界面上。

六、实验结果及软件使用说明

1. 替代密码


图 1 替代密码主界面
使用说明：
前两行的26个字母代表字典表，可以直接输入修改替代的方法，在input中输入文本，点击encrypt实现加密，decrypt实现解密。

图 2 测试数据

图 3 测试数据

七、源代码

'''
Author: Martin
Date: 2023-11-11 19:08:09
Description: 替代密码的实现
'''
import tkinter as tk

class SubstitutionCipher:
    def __init__(self, key):
        self.key = key
        self.encrypt_dict = dict(zip('abcdefghijklmnopqrstuvwxyz', key))
        self.decrypt_dict = dict(zip(key, 'abcdefghijklmnopqrstuvwxyz'))

    def encrypt(self, text):
        encrypted_text = ''
        for char in text:
            if char.isalpha():  # 只加密字母
                if char.islower():
                    encrypted_text += self.encrypt_dict.get(char, char)
                else:
                    encrypted_text += self.encrypt_dict.get(char.lower(), char)
            else:
                encrypted_text += char
        return encrypted_text

    def decrypt(self, text):
        decrypted_text = ''
        for char in text:
            if char.isalpha():  # 只解密字母
                if char.islower():
                    decrypted_text += self.decrypt_dict.get(char, char)
                else:
                    decrypted_text += self.decrypt_dict.get(char.lower(), char)
            else:
                decrypted_text += char
        return decrypted_text

class SubstitutionCipherGUI:
    def __init__(self, master):
        self.master = master
        master.title("Substitution Cipher")

        self.master.geometry("600x400")  # 设置窗口大小

        self.alphabet_frame = tk.Frame(master)
        self.alphabet_frame.pack()

        self.labels = []
        self.entries = []

        tmp1 = 0
        tmp2 = 1
        for i, char in enumerate('abcdefghijklmnopqrstuvwxyz'):
            if i>=13:
                tmp1 = 2
                tmp2 = 3
            label = tk.Label(self.alphabet_frame, text=char, width=2)
            label.grid(row=(i // 13) + tmp1, column=i % 13, padx=2)
            self.labels.append(label)

            entry = tk.Entry(self.alphabet_frame, width=3)
            entry.grid(row=(i // 13) + tmp2, column=i % 13, padx=2)
            entry.insert(tk.END, char)  # 设置默认值为大写字母
            self.entries.append(entry)


        self.label_input = tk.Label(master, text="Input:")
        self.label_input.pack()

        self.entry_input = tk.Text(master,width=50,height=3)
        self.entry_input.pack()

        self.label_encrypt_output = tk.Label(master, text="Encrypted:")
        self.label_encrypt_output.pack()

        self.text_encrypt_output = tk.Text(master, height=3, width=50)
        self.text_encrypt_output.pack()

        self.label_decrypt_output = tk.Label(master, text="Decrypted:")
        self.label_decrypt_output.pack()

        self.text_decrypt_output = tk.Text(master, height=3, width=50)
        self.text_decrypt_output.pack()

        self.button_encrypt = tk.Button(master, text="Encrypt", command=self.encrypt_text)
        self.button_encrypt.pack()

        self.button_decrypt = tk.Button(master, text="Decrypt", command=self.decrypt_text)
        self.button_decrypt.pack()

        self.canvas = tk.Canvas(master, width=600, height=150)
        self.canvas.pack()


    def encrypt_text(self):
        key = [entry.get() for entry in self.entries]  # 获取用户输入的字典内容
        text = self.entry_input.get("1.0", tk.END).strip()  # 获取多行文本框的内容
        cipher = SubstitutionCipher(key)
        encrypted_text = cipher.encrypt(text)
        self.text_encrypt_output.delete(1.0, tk.END)  # 清空之前的内容
        self.text_encrypt_output.insert(tk.END, encrypted_text)


    def decrypt_text(self):
        key = [entry.get() for entry in self.entries]  # 获取用户输入的字典内容
        text = self.entry_input.get("1.0", tk.END).strip()  # 获取多行文本框的内容
        cipher = SubstitutionCipher(key)
        decrypted_text = cipher.decrypt(text)
        self.text_decrypt_output.delete(1.0, tk.END)  # 清空之前的内容
        self.text_decrypt_output.insert(tk.END, decrypted_text)



if __name__ == "__main__":
    root = tk.Tk()
    app = SubstitutionCipherGUI(root)
    root.mainloop()

'''
Author: Martin
Date: 2023-11-11 19:52:32
Description: 置换密码
'''
import tkinter as tk

class SubstitutionCipherGUI:
    def __init__(self, master):
        self.master = master
        master.title("Substitution Cipher")

        self.master.geometry("600x400")  # 设置窗口大小

        self.alphabet_frame = tk.Frame(master)
        self.alphabet_frame.pack()

        self.labels = []
        self.entries = []

        tmp1 = 0
        tmp2 = 1
        for i, char in enumerate('12345678'):
            label = tk.Label(self.alphabet_frame, text=f"{char}:")
            label.grid(row=tmp2, column=i, padx=2)
            self.labels.append(label)

            entry = tk.Entry(self.alphabet_frame, width=3)
            entry.grid(row=tmp2 + 1, column=i, padx=2)
            entry.insert(tk.END, 9-int(char))  # 设置默认值为大写字母
            self.entries.append(entry)

        self.label_input = tk.Label(master, text="Input:")
        self.label_input.pack()

        self.entry_input = tk.Text(master, width=50, height=3)
        self.entry_input.pack()
        
        self.label_encrypt_output = tk.Label(master, text="Encrypted:")
        self.label_encrypt_output.pack()

        self.text_encrypt_output = tk.Text(master, height=3, width=50)
        self.text_encrypt_output.pack()

        self.label_decrypt_output = tk.Label(master, text="Decrypted:")
        self.label_decrypt_output.pack()

        self.text_decrypt_output = tk.Text(master, height=3, width=50)
        self.text_decrypt_output.pack()

        self.button_encrypt = tk.Button(master, text="Encrypt", command=self.encrypt_text)
        self.button_encrypt.pack()

        self.button_decrypt = tk.Button(master, text="Decrypt", command=self.decrypt_text)
        self.button_decrypt.pack()

        self.canvas = tk.Canvas(master, width=600, height=150)
        self.canvas.pack()


    def encrypt_text(self):
        key = [entry.get() for entry in self.entries]  # 获取用户输入的字典内容
        text = self.entry_input.get("1.0", tk.END).strip()  # 获取多行文本框的内容
        cipher = SubstitutionCipher(key)
        encrypted_text = cipher.encrypt(text)
        self.text_encrypt_output.delete(1.0, tk.END)  # 清空之前的内容
        self.text_encrypt_output.insert(tk.END, encrypted_text)


    def decrypt_text(self):
        key = [entry.get() for entry in self.entries]  # 获取用户输入的字典内容
        text = self.entry_input.get("1.0", tk.END).strip()  # 获取多行文本框的内容
        cipher = SubstitutionCipher(key)
        decrypted_text = cipher.decrypt(text)
        self.text_decrypt_output.delete(1.0, tk.END)  # 清空之前的内容
        self.text_decrypt_output.insert(tk.END, decrypted_text)



class SubstitutionCipher:
    def __init__(self, key):
        self.key = key

    def encrypt_block(self, block):
        return ''.join(block[int(self.key[i]) - 1] for i in range(min(len(self.key), len(block))))

    def encrypt(self, plaintext):
        blocks = [plaintext[i:i + 8] for i in range(0, len(plaintext), 8)]
        print(blocks)
        encrypted_blocks = [self.encrypt_block(block) for block in blocks[:-1]]
        encrypted_blocks.append(blocks[-1])
        return ''.join(encrypted_blocks)

    def decrypt(self, ciphertext):
        reversed_key = ''.join(reversed(self.key))
        reversed_cipher = SubstitutionCipher(reversed_key)
        return reversed_cipher.encrypt(ciphertext)

if __name__ == "__main__":
    root = tk.Tk()
    app = SubstitutionCipherGUI(root)
    root.mainloop()

原文地址：https://blog.csdn.net/qq_53517370/article/details/135987902

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024