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

    # 检查密钥长度和强度
    if key_length < 8:
        messagebox.showerror('错误', '密钥长度不能小于8个字符。')
        return
    key = ''.join(random.choices(string.ascii_letters + string.digits, k=key_length))
    if not any(char.isdigit() for char in key) or not any(char.isupper() for char in key) or not any(char.islower() for char in key):
        messagebox.showerror('错误', '密钥必须包含至少一个大写字母、一个小写字母和一个数字。')
        return

    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:
        try:
            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.')
        except Exception as e:
            messagebox.showerror('错误', str(e))

# 解密图像
def decrypt_image(self):
    algorithm = self.algorithm_combo.get()
    key = self.key_entry.get()
    if key and self.image:
        try:
            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.')
        except Exception as e:
            messagebox.showerror('错误', str(e))

运行应用程序

def run(self):
    self.root.mainloop()

if name == 'main': # 创建登录窗口 login_window = tk.Tk() login = LoginWindow(login_window) login_window.mainloop()