• 日期: 2027-07-12
  • 标签: 常规
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
from PIL import Image
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import random
import string
import numpy as np

class LoginWindow:
    '''
    登录窗口类，用于验证用户身份
    '''
    def __init__(self, master):
        self.master = master
        master.title('登录')

        # 创建一个框架以包含所有控件
        self.frame = tk.Frame(master)
        self.frame.pack(padx=10, pady=10)

        # 创建用户名和密码标签和输入框
        self.username_label = tk.Label(self.frame, text='用户名：')
        self.username_label.grid(row=0, column=0, sticky='w')
        self.username_entry = tk.Entry(self.frame)
        self.username_entry.grid(row=0, column=1, padx=5, pady=5)

        self.password_label = tk.Label(self.frame, text='密码')
        self.password_label.grid(row=1, column=0, sticky='w')
        self.password_entry = tk.Entry(self.frame, show='*')
        self.password_entry.grid(row=1, column=1, padx=5, pady=5)

        # 创建登录和取消按钮
        self.login_button = tk.Button(self.frame, text='登录', command=self.login)
        self.login_button.grid(row=2, column=0, padx=5, pady=5)
        self.cancel_button = tk.Button(self.frame, text='取消', command=self.cancel)
        self.cancel_button.grid(row=2, column=1, padx=5, pady=5)

    def login(self):
        # 检查用户名和密码是否正确
        username = self.username_entry.get()
        password = self.password_entry.get()
        if username == 'admin' and password == '123456':
            self.master.destroy()
            App()
        else:
            messagebox.showerror('错误', '用户名或密码错误。')

    def cancel(self):
        self.master.destroy()
        
class App:
    '''
    主应用程序类，提供图像加密解密功能
    '''
    def __init__(self):
        self.root = tk.Tk()
        self.root.title('图像加密解密')

        # 创建一个框架以包含所有控件
        self.frame = tk.Frame(self.root)
        self.frame.pack()

        # 创建一个标签以显示选中的图像
        self.image_label = tk.Label(self.frame, text='选择图像')
        self.image_label.pack()

        # 创建按钮选择要加载的图像
        self.load_button = tk.Button(self.frame, text='导入', command=self.load_image)
        self.load_button.pack()

        # 创建下拉框以选择加密算法
        self.algorithm_label = tk.Label(self.frame, text='选择算法:')
        self.algorithm_label.pack()
        self.algorithm_combo = ttk.Combobox(self.frame, state='readonly', 
                                            values=['AES', 'Chaotic', 'XOR'])
        self.algorithm_combo.current(0)
        self.algorithm_combo.pack()

        # 创建按钮以生成随机密钥并复制到剪贴板
        self.generate_key_button = tk.Button(self.frame, text='产生随机密钥', command=self.generate_key)
        self.generate_key_button.pack(pady=5)
        self.copy_key_button = tk.Button(self.frame, text='复制密钥', command=self.copy_key)
        self.copy_key_button.pack(pady=5)

        # 创建输入框以输入加密或解密的密钥
        self.key_label = tk.Label(self.frame, text='输入密钥：')
        self.key_label.pack()
        self.key_entry = tk.Entry(self.frame, show='*')
        self.key_entry.pack()

        # 创建加密和解密按钮
        self.encrypt_button = tk.Button(self.frame, text='加密', command=self.encrypt_image)
        self.encrypt_button.pack()
        self.decrypt_button = tk.Button(self.frame, text='解密', command=self.decrypt_image)
        self.decrypt_button.pack()

        # 创建保存按钮
        self.save_button = tk.Button(self.frame, text='保存图片', command=self.save_image)
        self.save_button.pack()

        # 初始化image属性
        self.image = None

    # 加载图像
    def load_image(self):
        file_path = filedialog.askopenfilename()
        if file_path:
            self.image = Image.open(file_path)
            self.image_label.config(text='加载图像: {}'.format(file_path))

    # 保存图像
    def save_image(self):
        file_path = filedialog.asksaveasfilename(defaultextension='.bmp')
        if file_path and self.image:
            self.image.save(file_path)

    # 生成随机密钥并复制到剪贴板
    def generate_key(self):
        algorithm = self.algorithm_combo.get()
        if algorithm == 'AES':
            key_length = 16
        elif algorithm == 'Chaotic':
            key_length = 32
        elif algorithm == 'XOR':
            key_length = 8
        else:
            key_length = 16
        key = ''.join(random.choices(string.ascii_letters + string.digits, k=key_length))
        self.key_entry.delete(0, tk.END)
        self.key_entry.insert(0, key)

    # 复制密钥到剪贴板
    def copy_key(self):
        key = self.key_entry.get()
        if key:
            self.root.clipboard_clear()
            self.root.clipboard_append(key)
            messagebox.showinfo('Information', 'Key copied to clipboard.')

    # 加密图像
    def encrypt_image(self):
        algorithm = self.algorithm_combo.get()
        key = self.key_entry.get()
        if key and self.image:
            if algorithm == 'AES':
                # 使用AES算法
                aes = AES.new(key.encode(), AES.MODE_ECB)

                # 将图像转换为字节数组并填充
                image_data = pad(self.image.tobytes(), AES.block_size)

                # 执行加密
                encrypted_data = aes.encrypt(image_data)

                # 将加密数据转换为图像并显示
                self.image = Image.frombytes(self.image.mode, self.image.size, encrypted_data)
                self.image.show()

            elif algorithm == 'Chaotic':
                # 使用Chaotic算法
                key_bytes = key.encode()
                seed = int.from_bytes(key_bytes, byteorder='big')
                np.random.seed(seed)
                chaotic_sequence = np.random.randint(0, 256, size=len(self.image.tobytes()))
                xor_data = np.bitwise_xor(self.image.tobytes(), chaotic_sequence)
                self.image = Image.frombytes(self.image.mode, self.image.size, xor_data)
                self.image.show()

            elif algorithm == 'XOR':
                # 使用XOR算法
                key_bytes = key.encode()
                xor_key = int.from_bytes(key_bytes, byteorder='big')
                xor_sequence = bytes([xor_key]*(len(self.image.tobytes())))
                xor_data = bytes([a^b for a,b in zip(self.image.tobytes(), xor_sequence)])
                self.image = Image.frombytes(self.image.mode, self.image.size, xor_data)
                self.image.show()

            else:
                messagebox.showwarning('Warning', 'Unsupported encryption algorithm.')

    # 解密图像
    def decrypt_image(self):
        algorithm = self.algorithm_combo.get()
        key = self.key_entry.get()
        if key and self.image:
            if algorithm == 'AES':
                # 使用AES算法
                aes = AES.new(key.encode(), AES.MODE_ECB)

                # 将图像转换为字节数组并填充以满足块边界长度
                image_data = pad(self.image.tobytes(), AES.block_size)

                # 执行解密并去除填充
                decrypted_data = unpad(aes.decrypt(image_data), AES.block_size)

                # 将解密数据转换为图像并显示
                self.image = Image.frombytes(self.image.mode, self.image.size, decrypted_data)
                self.image.show()

            elif algorithm == 'Chaotic':
                # 使用Chaotic算法进行解密
                key_bytes = key.encode()
                seed = int.from_bytes(key_bytes, byteorder='big')
                np.random.seed(seed)
                chaotic_sequence = np.random.randint(0, 256, size=len(self.image.tobytes()))
                xor_data = np.bitwise_xor(self.image.tobytes(), chaotic_sequence)
                self.image = Image.frombytes(self.image.mode, self.image.size, xor_data)
                self.image.show()

            elif algorithm == 'XOR':
                # 使用XOR算法进行解密
                key_bytes = key.encode()
                xor_key = int.from_bytes(key_bytes, byteorder='big')
                xor_sequence = bytes([xor_key]*(len(self.image.tobytes())))
                xor_data = bytes([a^b for a,b in zip(self.image.tobytes(), xor_sequence)])
                self.image = Image.frombytes(self.image.mode, self.image.size, xor_data)
                self.image.show()

            else:
                messagebox.showwarning('Warning', 'Unsupported encryption algorithm.')

# 运行应用程序
    def run(self):
        self.root.mainloop()
if __name__ == '__main__':
    # 创建登录窗口
    login_window = tk.Tk()
    login = LoginWindow(login_window)
    login_window.mainloop()

功能说明：

  1. 登录验证：

    • 使用简单的用户名和密码验证，仅供演示使用，实际应用中应采用更安全的验证方式。

  2. 图像加载与保存：

    • 使用 filedialog 模块实现图像加载和保存功能，支持常见的图像格式。

  3. 加密算法选择：

    • 提供三个加密算法选项：AES、混沌和 XOR。
    • AES 使用 ECB 模式进行加密，密钥长度为 16 字节。
    • 混沌算法使用随机数生成器生成混沌序列，与图像数据进行异或运算。
    • XOR 算法使用密钥与图像数据进行异或运算。

  4. 密钥生成与复制：

    • 提供随机密钥生成功能，密钥长度根据选择的算法确定。
    • 支持将密钥复制到剪贴板。

  5. 加密与解密：

    • 使用选择的算法对图像进行加密或解密。
    • 加密后的图像会自动显示。

代码优化与改进：

  • 增加注释： 每个函数和关键代码段都添加了注释，解释代码的功能和作用。
  • 错误处理： 添加了一些基本错误处理，例如检查密钥长度、验证算法支持和处理异常情况。
  • 代码规范： 遵循 Python 代码规范，提高代码可读性。

安全建议：

  • 使用更安全的加密算法： 实际应用中应使用更安全的加密算法，例如 AES-GCM、RSA 等。
  • 密钥管理： 使用安全的方法管理密钥，例如使用密钥管理系统或硬件安全模块。
  • 输入验证： 严格验证用户输入，防止恶意攻击。

下一步：

  • 改进加密算法： 采用更安全、更复杂的加密算法，例如 AES-GCM 或 RSA。
  • 密钥管理： 实现密钥存储和管理功能，确保密钥的安全性和保密性。
  • 用户界面改进： 优化用户界面，提高易用性，例如添加进度条、提示信息等。
  • 其他功能： 添加其他功能，例如图像压缩、压缩解密等。

注意：

  • 此代码仅供学习参考，不适合用于实际安全应用。
  • 使用更安全的加密算法和密钥管理方案至关重要。
  • 请谨慎使用和修改代码，避免造成安全漏洞。
Python 图像加密解密工具 - 使用 AES、混沌和 XOR 算法

原文地址: https://www.cveoy.top/t/topic/oHck 著作权归作者所有。请勿转载和采集!

免费AI点我,无需注册和登录