Python 图像加密解密工具

本程序使用 Python Tkinter 库创建一个简单的图像加密解密工具，支持 AES、Chaotic 和 XOR 三种算法。用户可以选择算法，输入或生成密钥，并对图像进行加密或解密操作。

功能

图像加载和保存: 支持加载和保存 BMP 格式的图像。
算法选择: 提供 AES、Chaotic 和 XOR 三种加密算法供用户选择。
随机密钥生成: 提供随机密钥生成功能，并支持将密钥复制到剪贴板。
加密和解密: 支持使用所选算法和密钥对图像进行加密和解密操作。

安装依赖

为了运行该程序，需要安装以下 Python 库:

Pillow: 用于图像处理。
```
pip install Pillow
```
pycryptodome: 用于加密操作。
```
pip install pycryptodome
```

代码

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()

使用说明

运行程序，将会出现登录窗口。
输入用户名“admin”和密码“123456”登录。
选择要加密或解密的图像。
选择加密算法。
生成或输入密钥。
点击“加密”或“解密”按钮。
保存加密或解密后的图像。

注意

该程序仅支持 BMP 格式的图像。
密钥的安全性取决于密钥的长度和随机性。
使用该工具进行图像加密解密需要谨慎，不要将敏感信息存储在未加密的图像中。

Python 图像加密解密工具 - 使用 AES、Chaotic 和 XOR 算法