Python图像加密工具开发：基于像素XOR与密钥派生的本地隐私保护方案-编程实验室

1. 项目概述：为什么我们需要一个自己的图像加密工具？

最近在整理一些个人照片和设计稿，总有些文件不想直接“裸奔”在硬盘或网盘里。网上的加密软件要么功能臃肿，要么担心后门，用起来总不放心。正好，用Python自己搓一个轻量级的图像加密解密工具，就成了一个很实际的需求。这不仅仅是把图片变成一堆乱码那么简单，它涉及到数据隐私的自我保护、对加密原理的实践理解，以及一个非常实用的Python综合应用场景。

这个工具的核心目标很明确：输入一张图片和一个密码，输出一张肉眼无法识别、但结构完整的加密图片；反之，输入加密图片和正确密码，能无损还原出原图。整个过程要完全在本地完成，不依赖任何第三方云服务，确保数据不出手。实现起来，我们会用到PIL/Pillow库来处理图像像素，用hashlib来派生密钥，再结合一些基本的位操作（如XOR）来完成加密。别看原理基础，但组合起来的效果对于日常非军用级的隐私保护来说，已经足够可靠。

它适合谁呢？如果你是对Python有基本了解，想找一个有明确产出、能串联起多个库的综合小项目来练手，那么再合适不过。它不像爬虫或数据分析那样需要庞大的外部数据，也不像Web开发那样涉及复杂的前后端，但涵盖了文件I/O、二进制操作、密码学应用和GUI（可选）等多个实用技能点。对于有隐私保护需求的普通用户，通过这个项目生成的工具，也能实实在在地用起来。

2. 核心原理与方案选型：从像素到密文的旅程

图像加密，本质上是对图像数据（一种特殊格式的二进制数据）施加一个变换，使得未授权者无法解读。我们这里实现的是一种对称加密，即加密和解密使用相同的密钥。方案选型上，我们放弃了复杂的AES、DES等标准算法直接对图像文件进行加密，而是选择在像素层面进行流加密。原因有二：一是标准算法加密后的输出是二进制流，会破坏图像的文件结构，导致无法被图片查看器打开（虽然这本身也是一种加密强度），但我们希望加密后的输出仍然是一张“正常的”图片；二是像素级加密更直观，便于理解和教学。

2.1 为什么选择像素级XOR加密？

我们的核心加密操作是异或（XOR）。这是一个非常经典且高效的位运算，它有一个黄金特性：(A XOR K) XOR K = A。也就是说，用密钥K对数据A加密一次得到密文C，再用同一个K对C加密一次，就能完美还原A。这完美契合了对称加密的需求。

将图像加载到内存后，我们可以通过Pillow库将其转换为一个包含RGB（或RGBA）值的像素数组。每个像素值范围是0-255。我们生成一个同样长度的、由密码衍生的伪随机密钥流（也由0-255的数字组成），然后让每个像素值与其对应的密钥流数值进行XOR运算，得到新的像素值，再写回图像。这样，从视觉上看，原图的特征就完全被破坏了。由于XOR的可逆性，解密过程完全一致。

注意：单纯的XOR加密如果密钥流不够随机或重复使用，会存在安全隐患。我们这里通过将用户密码与一个随机数种子（Salt）结合，并通过哈希函数（如SHA256）多次迭代，来生成一个看似随机的、与密码强相关的密钥流，这通常被称为基于密码的密钥派生。虽然其密码学强度不及专业的加密标准，但对于抵御普通窥探和满足学习目的而言，是一个在安全性和实现复杂度之间很好的平衡点。

2.2 工具栈选择：轻量、高效、跨平台

图像处理库：Pillow (PIL Fork)：这是Python图像处理的事实标准。它比OpenCV更轻量，接口对于基本的图像读写和像素操作来说也更简单直观。我们的核心操作是Image.open(),Image.convert(),Image.load()获取像素数据，以及Image.new()和Image.putdata()来创建和保存图像。
密码学相关：hashlib, secrets：hashlib用于从密码生成固定长度的哈希值，作为我们密钥派生的基础。secrets模块用于生成密码学安全的随机数，我们用它来生成加密所需的随机盐（Salt），确保即使相同的密码，每次加密也会因盐值不同而产生不同的密钥流，防止重复加密模式被分析。
用户界面（可选）：Tkinter 或 PyQt：为了让工具更方便使用，我们可以为其包裹一个简单的图形界面。Tkinter是Python标准库，无需额外安装，适合快速构建简单的文件选择、密码输入和按钮操作界面。如果追求更美观的界面，可以选择PyQt，但需要额外安装。本文将主要讲解核心逻辑，GUI实现会给出一个Tkinter的简明示例。
打包工具（可选）：PyInstaller：项目完成后，你可能希望分享给不会Python的朋友使用。PyInstaller可以将你的Python脚本及其所有依赖打包成一个独立的.exe（Windows）或可执行文件（macOS/Linux），真正做到开箱即用。

这个工具栈的选择，确保了项目从核心逻辑到最终分发，整个链条都清晰、可控，且依赖简单。

3. 核心模块拆解与实现细节

接下来，我们深入到代码层面，把工具的每个核心模块拆开揉碎了讲清楚。我会先给出关键代码片段，然后解释其背后的意图和注意事项。

3.1 密钥派生函数：从密码到密钥流

这是整个加密系统的安全基石。我们不能直接使用用户输入的简单密码作为密钥，而是要通过一个密钥派生函数（KDF）来生成一个强度足够、长度匹配图像像素数量的密钥流。

import hashlib import secrets def derive_key(password: str, salt: bytes, key_length: int) -> bytes: """ 基于密码和盐派生指定长度的密钥。 参数: password: 用户输入的密码字符串。 salt: 随机盐值，用于防止彩虹表攻击。 key_length: 需要生成的密钥字节长度。 返回: 派生出的密钥字节流。 """ # 将密码编码为字节串 password_bytes = password.encode('utf-8') # 使用PBKDF2_HMAC算法进行密钥派生。这里使用SHA256作为哈希函数。 # iterations参数是迭代次数，增加迭代次数可以大幅增加暴力破解的难度，但也会轻微增加计算时间。 # 这里设为100000次是一个在安全和性能间折衷的常用值。 derived_key = hashlib.pbkdf2_hmac( 'sha256', password_bytes, salt, iterations=100000, dklen=key_length # 指定需要的密钥长度 ) return derived_key

关键点解析：

盐（Salt）的作用：secrets.token_bytes(16)可以生成一个16字节的安全随机盐。盐的作用是确保即使用户使用了相同的密码，每次加密也会因为盐的不同而产生完全不同的密钥，从而防止攻击者使用预先计算好的“彩虹表”来快速破解。盐不需要保密，可以明文保存在加密图像的文件头或单独的文件中，解密时需要用到同一个盐。
PBKDF2算法：hashlib.pbkdf2_hmac实现的是PBKDF2（Password-Based Key Derivation Function 2）算法。它通过将密码和盐进行多次（iterations次）哈希运算，来增加从密码推导出密钥的计算成本，有效抵御暴力破解。dklen参数决定了输出密钥的长度，我们需要根据图像的总像素数×每像素的字节数来计算。
密钥长度：对于一张RGB图像，每个像素有3个字节（R, G, B）。如果图像尺寸是width * height，那么总像素数据长度就是width * height * 3。我们的key_length必须至少等于这个值。derive_key函数会生成恰好这么长的密钥流。

3.2 加密过程：像素数据的混淆

有了密钥流，加密过程就变成了按字节进行XOR的循环操作。

from PIL import Image import numpy as np # 使用NumPy数组操作会极大提升处理速度 def encrypt_image(image_path: str, password: str, output_path: str): """加密图像""" # 1. 打开图像并确保为RGB模式 img = Image.open(image_path) if img.mode != 'RGB': img = img.convert('RGB') # 2. 将图像数据转换为NumPy数组，形状为 (height, width, 3) img_array = np.array(img) height, width, channels = img_array.shape # 计算总字节数 total_bytes = height * width * channels # 3. 生成随机盐并派生密钥 salt = secrets.token_bytes(16) key = derive_key(password, salt, total_bytes) # 4. 将密钥重塑为与图像数组相同的形状，以便进行逐元素XOR # 注意：key是1维字节数组，需要reshape成3维数组才能与img_array运算 key_array = np.frombuffer(key, dtype=np.uint8).reshape((height, width, channels)) # 5. 执行XOR加密 encrypted_array = np.bitwise_xor(img_array, key_array) # 6. 将盐保存在加密图像的开头（或末尾）。这里采用一个简单方法： # 创建一个新的图像，高度增加1像素，第一行像素用于存储盐（16字节=48个RGB值，需要16个像素）。 # 更健壮的做法是使用自定义文件头，但此法更直观。 # 计算存储盐所需的像素行数（每像素3字节） salt_pixels_needed = (len(salt) + 2) // 3 # 向上取整 new_height = height + salt_pixels_needed # 创建一个新的、高度增加了的数组 new_array = np.zeros((new_height, width, 3), dtype=np.uint8) # 第一行（或前几行）存放盐 # 将盐值转换为0-255的整数，并填充到前几个像素的RGB通道中 salt_np = np.frombuffer(salt, dtype=np.uint8) # 确保盐数据能完整放入预留的像素中 salt_flat = np.zeros(salt_pixels_needed * 3, dtype=np.uint8) salt_flat[:len(salt_np)] = salt_np new_array[:salt_pixels_needed, :, :] = salt_flat.reshape((salt_pixels_needed, 1, 3)) # 剩余部分存放加密后的图像数据 new_array[salt_pixels_needed:, :, :] = encrypted_array # 7. 保存加密后的图像 encrypted_img = Image.fromarray(new_array, mode='RGB') encrypted_img.save(output_path) print(f"图像已加密并保存至: {output_path}") print(f"盐值（十六进制）: {salt.hex()}") # 输出盐值，实际应用中可能需要单独保存

实操心得与陷阱：

模式转换：img.convert('RGB')这步至关重要。如果原图是RGBA（带透明度）、P（调色板）或L（灰度）模式，不转换会导致数组形状不一致，后续XOR操作出错。统一到RGB模式简化了处理逻辑。
性能考量：直接使用Python循环遍历每个像素进行XOR，对于大图会非常慢。这里使用NumPy的bitwise_xor进行向量化运算，速度可以提升数百倍。np.array(img)和Image.fromarray()是Pillow与NumPy互操作的桥梁。
盐的存储：将盐直接嵌入图像像素中是一个取巧但有效的方法。解密时，我们需要用同样的逻辑从加密图像的前几个像素中读取盐。这种方法会略微改变图像尺寸。更专业的做法是将盐和可能的其他元数据（如图像原始尺寸）写入图像文件的EXIF信息或自定义二进制文件头，但这涉及更底层的文件操作。我们的简易方法保证了“加密图像”仍然是一个能被任何看图软件打开的合法图片文件。
密钥流匹配：np.frombuffer(key, dtype=np.uint8).reshape((height, width, channels))这行代码确保了密钥流的形状与图像像素数组完全一致，这是实现逐像素XOR的前提。dklen=total_bytes在派生密钥时保证了长度匹配。

3.3 解密过程：逆向操作与完整性校验

解密是加密的逆过程，但需要小心处理盐的提取。

def decrypt_image(encrypted_image_path: str, password: str, output_path: str): """解密图像""" # 1. 打开加密图像 encrypted_img = Image.open(encrypted_image_path) if encrypted_img.mode != 'RGB': encrypted_img = encrypted_img.convert('RGB') encrypted_array = np.array(encrypted_img) e_height, e_width, channels = encrypted_array.shape # 2. 从图像数据中提取盐（假设盐存储在前`salt_pixels_needed`行） # 我们需要知道盐的长度，这里假设是16字节。在实际完整工具中，这个信息应该和盐一起存储。 # 为了演示，我们假设盐是16字节（48个值），占用 ceil(16/3)=6个像素（即6行）。 assumed_salt_length = 16 salt_pixels_needed = (assumed_salt_length + 2) // 3 if e_height <= salt_pixels_needed: raise ValueError("加密图像文件已损坏或格式不正确。") # 提取前几行像素中存储的盐值 salt_flat = encrypted_array[:salt_pixels_needed, 0, :].flatten() # 取第一列的所有通道 # 盐值只存储在开头的指定字节数里，后面的可能是填充的0 salt_bytes = bytes(salt_flat[:assumed_salt_length]) # 3. 获取实际的加密图像数据部分 original_height = e_height - salt_pixels_needed original_width = e_width encrypted_data_array = encrypted_array[salt_pixels_needed:, :, :] # 4. 计算原始图像数据总字节数，并派生密钥 total_bytes = original_height * original_width * channels key = derive_key(password, salt_bytes, total_bytes) key_array = np.frombuffer(key, dtype=np.uint8).reshape((original_height, original_width, channels)) # 5. 执行XOR解密（与加密操作完全相同） decrypted_array = np.bitwise_xor(encrypted_data_array, key_array) # 6. 保存解密后的图像 decrypted_img = Image.fromarray(decrypted_array, mode='RGB') decrypted_img.save(output_path) print(f"图像已解密并保存至: {output_path}")

注意事项：

盐的同步：加密和解密必须使用完全相同的盐。在我们的实现中，解密方需要知道盐的存储方式和长度。这是一个简易实现中的耦合点。更健壮的系统可能会将盐的长度信息也存储进去（例如，用前两个像素存储盐的长度本身），或者使用固定的、双方都知道的盐值（但这会降低安全性，不推荐）。
错误处理：如果密码错误，派生出的密钥流就不对，XOR解密后得到的将是毫无意义的乱码，保存为图片后可能是灰色、条纹或噪点图。程序本身不会崩溃，但结果错误。在实际的GUI工具中，可以尝试解密后检查图像是否“看起来合理”（例如，通过计算像素值的统计特性），但这并不完全可靠。最根本的还是用户保管好密码。
模式一致性：务必确保加密和解密时图像模式处理一致。如果加密时强制转为了RGB，解密后得到的也是RGB图。如果原图是RGBA带透明通道，这个简易版本会丢失透明度信息。如果需要支持透明通道，需要处理RGBA模式，即4个通道，并在计算total_bytes和key_array形状时做相应调整。

4. 构建一个简单的图形用户界面（GUI）

为了让工具真正“可用”，我们用一个简单的Tkinter界面把它包装起来。这个界面提供文件选择、密码输入和加密/解密按钮。

import tkinter as tk from tkinter import filedialog, messagebox, ttk import threading class ImageEncryptorApp: def __init__(self, root): self.root = root self.root.title("Python图像加密解密工具") self.root.geometry("500x400") # 变量 self.input_path = tk.StringVar() self.output_path = tk.StringVar() self.password = tk.StringVar() self.mode = tk.StringVar(value="encrypt") # 'encrypt' or 'decrypt' # 创建界面组件 self.create_widgets() def create_widgets(self): # 模式选择 frame_mode = ttk.LabelFrame(self.root, text="操作模式", padding=10) frame_mode.pack(pady=10, padx=20, fill="x") ttk.Radiobutton(frame_mode, text="加密", variable=self.mode, value="encrypt").pack(side=tk.LEFT, padx=20) ttk.Radiobutton(frame_mode, text="解密", variable=self.mode, value="decrypt").pack(side=tk.LEFT, padx=20) # 输入文件选择 frame_input = ttk.LabelFrame(self.root, text="输入文件", padding=10) frame_input.pack(pady=10, padx=20, fill="x") ttk.Entry(frame_input, textvariable=self.input_path, state='readonly').pack(side=tk.LEFT, fill="x", expand=True, padx=(0, 10)) ttk.Button(frame_input, text="浏览...", command=self.browse_input).pack(side=tk.RIGHT) # 输出路径选择 frame_output = ttk.LabelFrame(self.root, text="输出文件", padding=10) frame_output.pack(pady=10, padx=20, fill="x") ttk.Entry(frame_output, textvariable=self.output_path).pack(side=tk.LEFT, fill="x", expand=True, padx=(0, 10)) ttk.Button(frame_output, text="浏览...", command=self.browse_output).pack(side=tk.RIGHT) # 密码输入 frame_pwd = ttk.LabelFrame(self.root, text="密码", padding=10) frame_pwd.pack(pady=10, padx=20, fill="x") ttk.Entry(frame_pwd, textvariable=self.password, show="*").pack(fill="x") # 执行按钮 self.btn_execute = ttk.Button(self.root, text="开始执行", command=self.execute) self.btn_execute.pack(pady=20) # 状态标签 self.status_label = ttk.Label(self.root, text="就绪") self.status_label.pack() # 进度条 self.progress = ttk.Progressbar(self.root, mode='indeterminate') def browse_input(self): filetypes = [("图像文件", "*.jpg *.jpeg *.png *.bmp *.tiff"), ("所有文件", "*.*")] filename = filedialog.askopenfilename(title="选择要加密/解密的图像", filetypes=filetypes) if filename: self.input_path.set(filename) # 自动生成一个默认输出路径 if self.mode.get() == "encrypt": base, ext = os.path.splitext(filename) self.output_path.set(base + "_encrypted.png") else: base, ext = os.path.splitext(filename) self.output_path.set(base + "_decrypted.png") def browse_output(self): filetypes = [("PNG 图像", "*.png"), ("所有文件", "*.*")] filename = filedialog.asksaveasfilename(title="保存输出文件", defaultextension=".png", filetypes=filetypes) if filename: self.output_path.set(filename) def execute(self): if not self.input_path.get(): messagebox.showerror("错误", "请选择输入文件！") return if not self.output_path.get(): messagebox.showerror("错误", "请指定输出文件路径！") return if not self.password.get(): messagebox.showerror("错误", "请输入密码！") return # 禁用按钮，防止重复点击 self.btn_execute.config(state='disabled') self.status_label.config(text="处理中...") self.progress.pack(pady=10) self.progress.start() # 在新线程中执行加密/解密，防止界面卡死 thread = threading.Thread(target=self.process_image) thread.daemon = True thread.start() def process_image(self): try: if self.mode.get() == "encrypt": encrypt_image(self.input_path.get(), self.password.get(), self.output_path.get()) msg = "加密完成！" else: decrypt_image(self.input_path.get(), self.password.get(), self.output_path.get()) msg = "解密完成！" # 回到主线程更新UI self.root.after(0, self.on_process_done, True, msg) except Exception as e: self.root.after(0, self.on_process_done, False, f"处理失败: {str(e)}") def on_process_done(self, success, message): self.progress.stop() self.progress.pack_forget() self.btn_execute.config(state='normal') self.status_label.config(text=message) if success: messagebox.showinfo("成功", message) else: messagebox.showerror("错误", message) if __name__ == "__main__": import os root = tk.Tk() app = ImageEncryptorApp(root) root.mainloop()

GUI实现要点：

线程分离：图像处理（尤其是大图）是耗时操作。如果在主线程（也是Tkinter的事件循环线程）中直接执行，会导致界面“冻住”，无法响应用户操作。使用threading.Thread将处理逻辑放到后台线程中是GUI程序保持流畅的关键。
线程安全更新UI：Tkinter的UI组件不是线程安全的。不能在子线程中直接调用messagebox或修改Label的文本。正确的做法是通过self.root.after(0, callable, ...)方法，将UI更新任务“投递”回主线程的事件队列中执行。
用户体验细节：比如根据选择的模式（加密/解密）自动生成默认的输出文件名、使用show="*"隐藏密码输入、添加进度条（这里用了不确定模式indeterminate）来给用户反馈，这些都是让工具更友好的小技巧。

5. 项目扩展与高级话题

完成基础版本后，这个工具还有很多可以深化和扩展的方向，这能让它从一个练手小项目变成一个更“像样”的工具。

5.1 增强安全性：引入更标准的加密模式

我们目前的XOR流加密在密码学上被称为ECB（电子密码本）模式，每个像素独立加密。对于图像这种具有空间相关性的数据，ECB模式可能会留下一些模式痕迹（尽管因为密钥流是随机的，风险已降低）。为了更严谨，可以考虑：

使用密码学标准库：Python的cryptography库提供了完整的AES等算法实现。我们可以用AES的CTR（计数器）模式，它本质上也是一个流密码，但基于更安全的块密码算法。加密时，用AES-CTR生成密钥流，再与图像像素XOR。这样做安全性更高，但需要处理加密后数据不再是标准图片格式的问题（除非将密文编码后嵌入图片的某些通道）。
结合图像编码：另一种思路是，先将图像数据用zlib压缩，然后用cryptography库的AES-GCM等认证加密模式进行加密，最后将密文以二进制形式保存为自定义文件（如.encimg）。解密时反向操作。这种方式安全性最高，但输出不再是图片格式。

5.2 支持更多图像格式与特性

透明度（Alpha通道）：修改代码支持RGBA模式。这意味着每个像素有4个字节，密钥长度和数组形状需要相应调整。
大图像与性能优化：对于超大的图像，一次性加载到NumPy数组可能消耗大量内存。可以采用分块处理的方式，例如将图像分成若干瓦片（tiles），逐块读取、加密、写入。Pillow的Image.crop()和Image.paste()可以配合使用。
保留EXIF信息：使用Pillow的Image.info或Image.getexif()方法可以在加密前提取元数据，在保存加密或解密后的图像时再写回去。

5.3 错误处理与鲁棒性

密码验证：在解密时，如何知道密码是否正确？一个常见做法是在加密时，不仅嵌入盐，还嵌入一个由密码和盐共同衍生的“验证令牌”（比如对固定字符串“header”加密后的一段密文）。解密时先尝试解密这个令牌，如果结果等于已知的明文“header”，则密码正确，再继续解密图像主体。
文件完整性校验：可以使用哈希函数（如SHA256）计算原始图像的哈希值，将其加密后与盐一起存储。解密后再次计算哈希并进行比对，确保图像在传输或存储过程中未被篡改。
更友好的盐存储：可以将盐、原始图像尺寸、操作模式等元数据，以JSON等格式序列化后，嵌入到PNG文件的tEXt或zTXt块中（PNG支持自定义文本块）。Pillow库对此支持有限，可能需要使用png等更底层的库。

5.4 打包与分发

使用PyInstaller打包非常简单。在项目根目录下，确保所有代码在一个主脚本（比如main.py）中启动，然后执行：

pip install pyinstaller pyinstaller --onefile --windowed --name ImageEncryptor main.py

--onefile：打包成单个可执行文件。
--windowed：运行时不显示控制台窗口（适合GUI程序）。
--name：指定输出exe的名称。

打包后，会在dist目录下生成ImageEncryptor.exe，你可以直接分享这个文件，对方无需安装Python或任何库即可运行。

6. 常见问题与排查实录

在实际编写和运行过程中，你可能会遇到以下问题。这里记录了我踩过的坑和解决方法。

问题1：运行加密后，输出的图片是全黑或全白的。

可能原因A：图像模式不匹配。这是最常见的问题。如果你用Image.open()打开了一张灰度图（模式L）或带透明度的图（模式RGBA），但没有进行convert('RGB')，那么img_array.shape可能是(H, W)或(H, W, 4)。而你派生的密钥流长度和形状是基于(H, W, 3)计算的，在XOR操作时会发生形状不匹配，NumPy可能会进行广播操作，导致结果异常。
排查与解决：在加密和解密函数的最开始，立即添加print(f"Image mode: {img.mode}")。确保在操作前，图像模式已统一为RGB或RGBA（如果你支持的话）。
可能原因B：密钥派生错误。确保加密和解密时使用的盐和密码完全一致。检查盐的存储和读取逻辑是否对应。一个简单的调试方法是，在加密后立即打印出盐的十六进制字符串，在解密时手动将这个字符串硬编码到解密函数中，看是否能成功。如果可以，说明问题出在盐的存储/读取环节。

问题2：处理大图片时程序内存占用很高，甚至崩溃。

原因：np.array(img)会将整个图像数据加载到内存中的一个NumPy数组。一张2000万像素的RGB图像，内存占用约为 2000万 * 3字节 ≈ 57 MB，加上中间变量，轻松超过100MB。

解决：实现分块处理。将图像在高度或宽度上分成若干段。例如，每次处理100行像素。

def encrypt_image_by_tiles(image_path, password, output_path, tile_height=100): img = Image.open(image_path).convert('RGB') width, height = img.size salt = secrets.token_bytes(16) # ... 其他初始化 ... encrypted_img = Image.new('RGB', (width, height)) for y in range(0, height, tile_height): # 计算当前瓦片的实际高度 h = min(tile_height, height - y) # 裁剪出瓦片 box = (0, y, width, y+h) tile = img.crop(box) tile_array = np.array(tile) # 计算当前瓦片对应的密钥流片段 tile_bytes = width * h * 3 tile_key_start = y * width * 3 tile_key_end = tile_key_start + tile_bytes tile_key = key[tile_key_start:tile_key_end] # key是之前派生好的完整密钥流 tile_key_array = np.frombuffer(tile_key, dtype=np.uint8).reshape((h, width, 3)) # 加密瓦片 encrypted_tile_array = np.bitwise_xor(tile_array, tile_key_array) encrypted_tile = Image.fromarray(encrypted_tile_array, mode='RGB') # 将加密后的瓦片粘贴到新图像上 encrypted_img.paste(encrypted_tile, box) # 可选：更新进度条 # 保存盐和图像...

这种方法能显著降低峰值内存使用。

问题3：打包成exe后，运行提示找不到Pillow或NumPy模块。

原因：PyInstaller有时无法自动捕获所有的隐式依赖，特别是像NumPy这样使用C扩展的库。
解决：在打包命令中通过--hidden-import显式指定。
```
pyinstaller --onefile --windowed --name ImageEncryptor --hidden-import PIL --hidden-import numpy main.py
```
如果还有问题，可以尝试在代码中显式导入子模块，例如在main.py开头加上import PIL.Image和import numpy as np。

问题4：加密后的图片用某些看图软件打开提示“文件已损坏”。

原因：我们修改了图像的像素数据，并可能改变了图像尺寸（由于嵌入了盐）。绝大多数看图软件对PNG、JPEG的容错性很好，只要文件头和数据块结构基本正确就能打开。但某些严格的软件可能会校验某些内部数据（如CRC校验码）。
解决：优先使用PNG格式进行输出。PNG格式支持无损压缩且结构清晰。Pillow在保存PNG时会自动计算并写入正确的CRC。确保在保存加密图像时使用Image.save(output_path, format='PNG')。避免使用JPEG，因为其有损压缩可能会在加密数据上引入不可预测的 artifacts，且多次保存会导致质量下降。

这个项目从原理到实现，再到优化和问题排查，几乎涵盖了一个小型桌面工具开发的全流程。它不只是一个加密工具，更是一个学习Python如何处理二进制数据、应用密码学基础、构建GUI和打包分发的绝佳范例。最重要的是，你最终得到了一个真正属于自己、可以信赖的隐私保护小工具。