毕业设计实战：多模态数据加密系统架构与Python实现

如果你的毕业设计题目是“多种数据模态的密文加解密系统”，并且要求支持多种算法，那么你很可能正面临一个典型困境：题目听起来高大上，但实际动手时却不知从何开始。是应该先研究复杂的密码学理论，还是直接找现成的代码拼凑？如何将文本、图像、音频等不同模态的数据统一处理？六种算法又该如何选择和集成？

这篇文章将为你提供一个清晰的实现路径。我们不空谈理论，而是直接构建一个可运行、可演示、代码结构清晰的毕业设计项目。你将了解到，一个合格的“多模态密文加解密系统”的核心并非算法数量，而是统一的抽象层设计和清晰的模块化架构。我们将从零开始，用Python实现一个支持文本、图像文件两种模态，并集成AES、DES、RSA三种经典算法（作为六种算法的代表）的完整系统。通过这个最小可行产品，你可以掌握扩展至更多模态和算法的通用方法，轻松应对毕设答辩。

1. 这篇文章真正要解决的问题

毕业设计中的“多模态加解密系统”项目，其难点往往不在于单个算法的实现，而在于如何优雅地处理“多模态”和“多算法”这两个维度带来的复杂度。许多同学会陷入以下误区：

1. 代码堆砌：为每种“模态x算法”的组合都写一套独立的加解密函数，导致代码冗余，难以维护和扩展。
2. 概念混淆：将数据模态（如文本、图像）与数据格式（如.txt, .jpg）混为一谈，导致文件处理逻辑混乱。
3. 脱离场景：只实现算法，没有构建一个完整的、带用户交互（命令行或图形界面）的系统，演示效果差。

本文要解决的核心问题是：如何设计一个高内聚、低耦合的系统架构，使得新增一种数据模态或一种加密算法变得简单，并最终打包成一个完整的应用程序。我们将聚焦于工程实现，而非深奥的密码学数学原理。读完本文，你将获得一个可以直接运行、代码结构清晰的项目原型，并能在此基础上轻松扩展至你题目要求的六种算法和更多数据模态。

2. 基础概念与核心原理

在开始编码前，需要明确几个关键概念，这决定了我们系统的设计边界。

2.1 数据模态 vs. 数据格式

• 数据模态：指数据的本质类型和内在结构。在我们的系统中，主要关注：
  • 文本模态：由字符序列组成的数据，如字符串、文档内容。其加解密操作直接在字符/字节层面进行。
  • 图像模态：由像素矩阵组成的数据。其加解密需要将图像读取为字节流或NumPy数组进行处理。对于加密，我们通常处理其字节流；对于某些算法，也可能处理其像素值。
  • （可扩展）音频模态、视频模态等。
• 数据格式：是数据模态在存储时的具体封装形式，如.txt,.json,.png,.jpg,.wav,.mp4。系统需要根据文件后缀名判断如何处理该文件的读取和写入，但加解密的核心逻辑应基于其模态。

设计原则：系统应基于模态设计处理接口，而利用格式进行文件I/O适配。

2.2 对称加密 vs. 非对称加密

这是选择算法时首先要区分的。

• 对称加密：加密和解密使用同一把密钥。速度快，适合大数据量加密。
  • 代表算法：AES (Advanced Encryption Standard), DES (Data Encryption Standard)。我们将实现这两种。
  • 关键问题：密钥如何安全地生成、存储和传递？在我们的演示系统中，可以固定或由用户输入。
• 非对称加密：使用公钥加密，私钥解密。速度慢，但解决了密钥分发问题。
  • 代表算法：RSA。我们将实现这一种。
  • 关键问题：密钥对（公钥、私钥）的生成与管理。

设计原则：在系统内部，加解密函数应接受“密钥”作为参数，并由调用者决定传入对称密钥还是非对称密钥对。

2.3 系统架构核心思想：策略模式

为了灵活支持“多模态x多算法”，我们将采用策略模式。

1. 算法策略：将每种加密算法（如AES, DES, RSA）封装成独立的类，它们实现统一的接口（例如encrypt(data, key)和decrypt(cipher_data, key)）。
2. 模态处理器：针对每种数据模态（如文本、图像），编写一个处理器。处理器的职责是：读取原始数据→转换为统一格式（如字节流）→调用指定的算法策略进行加密→处理加密后的数据（如保存为文件）。
3. 上下文/控制器：一个核心调度模块，根据用户选择的模态和算法，组合对应的“模态处理器”和“算法策略”，执行加解密流程。

这样，当需要新增一个算法时，你只需增加一个算法策略类，而无需修改任何模态处理器的代码。新增模态亦然。

3. 环境准备与前置条件

我们将使用Python作为实现语言，因为它库丰富、原型开发快。请确保你的环境满足以下要求：

• 操作系统：Windows 10/11, macOS, 或 Linux (如 Ubuntu)。本文示例在Windows 11 + Python 3.9上测试。
• Python版本：>= 3.7。建议使用3.8或3.9以获得最佳库兼容性。
• 必备库：
  • cryptography：一个功能强大且安全的密码学库，我们将用它实现AES、DES、RSA算法。这是核心库。
  • Pillow (PIL)：Python图像处理库，用于读取和保存图像文件。
  • argparse：Python标准库，用于构建命令行界面。
  • （可选）tkinter或PyQt5：如果你计划开发图形界面(GUI)，可以选择其一。本文先完成核心逻辑和命令行界面(CLI)。

安装命令：打开你的终端(CMD, PowerShell, 或 Terminal)，执行以下命令来安装必要的库。

pip install cryptography pillow

argparse是Python内置库，无需安装。

项目目录结构建议：在开始前，先创建清晰的项目文件夹，这对毕设答辩时的代码展示非常重要。

your_project/ ├── main.py # 程序主入口，CLI逻辑 ├── core/ # 核心模块 │ ├── __init__.py │ ├── crypto_strategy.py # 算法策略类 (AES, DES, RSA) │ └── data_handler.py # 模态处理器类 (文本， 图像) ├── utils/ # 工具函数 │ ├── __init__.py │ └── file_utils.py # 文件读写辅助函数 ├── keys/ # 存储生成的密钥文件（如RSA密钥对） │ ├── rsa_private.pem │ └── rsa_public.pem ├── data/ # 测试数据 │ ├── input.txt │ ├── input_image.png │ └── encrypted/ # 加密后输出目录 └── README.md # 项目说明文档

4. 核心流程拆解

整个系统的运行流程可以分解为以下步骤，我们将按照这个顺序实现代码：

1. 解析用户输入：通过命令行参数，获取用户指定的操作（加密/解密）、数据模态、算法、密钥、输入文件路径和输出文件路径。
2. 加载密钥：根据算法类型，从文件或参数中加载密钥（对称密钥或非对称密钥对）。
3. 读取输入数据：根据输入文件路径和其格式，调用对应的模态处理器，将数据加载到内存中（文本作为字符串，图像作为字节流或PIL Image对象）。
4. 执行加解密：根据用户选择的算法，实例化对应的算法策略对象。将数据和密钥传递给该对象的encrypt或decrypt方法。
5. 处理输出数据：将加解密结果（字节流）交给模态处理器，根据输出文件路径和格式进行保存。
6. 反馈结果：在命令行打印操作成功或失败的信息。

5. 完整示例与代码实现

现在，我们开始填充各个模块的代码。我们将从最底层的算法策略和模态处理器开始，最后组装主程序。

5.1 实现算法策略 (core/crypto_strategy.py)

这里我们定义所有算法类的基类，并实现AES、DES、RSA。

# 文件路径：core/crypto_strategy.py from abc import ABC, abstractmethod from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.primitives import padding, hashes from cryptography.hazmat.primitives.asymmetric import rsa, padding as asym_padding from cryptography.hazmat.primitives.serialization import load_pem_private_key, load_pem_public_key import os class CryptoStrategy(ABC): """加密策略抽象基类""" @abstractmethod def encrypt(self, plain_data: bytes, key) -> bytes: pass @abstractmethod def decrypt(self, cipher_data: bytes, key) -> bytes: pass class AESCrypto(CryptoStrategy): """AES加密策略 (使用CBC模式，需要初始化向量IV)""" def __init__(self, key_size=256): # AES密钥长度可以是128, 192, 256位 self.key_size = key_size def encrypt(self, plain_data: bytes, key: bytes) -> bytes: # 确保密钥长度正确 if len(key) * 8 != self.key_size: raise ValueError(f"AES-{self.key_size} requires a {self.key_size//8}-byte key.") # 生成随机初始化向量 (IV) iv = os.urandom(16) # 创建加密器 cipher = Cipher(algorithms.AES(key), modes.CBC(iv)) encryptor = cipher.encryptor() # 对数据进行PKCS7填充 padder = padding.PKCS7(128).padder() padded_data = padder.update(plain_data) + padder.finalize() # 加密 cipher_data = encryptor.update(padded_data) + encryptor.finalize() # 将IV和密文一起返回，解密时需要IV return iv + cipher_data def decrypt(self, cipher_data: bytes, key: bytes) -> bytes: if len(key) * 8 != self.key_size: raise ValueError(f"AES-{self.key_size} requires a {self.key_size//8}-byte key.") # 提取前16字节作为IV iv = cipher_data[:16] actual_cipher_data = cipher_data[16:] # 创建解密器 cipher = Cipher(algorithms.AES(key), modes.CBC(iv)) decryptor = cipher.decryptor() # 解密 padded_plain_data = decryptor.update(actual_cipher_data) + decryptor.finalize() # 去除填充 unpadder = padding.PKCS7(128).unpadder() plain_data = unpadder.update(padded_plain_data) + unpadder.finalize() return plain_data class DESCrypto(CryptoStrategy): """DES加密策略 (使用CBC模式)""" def encrypt(self, plain_data: bytes, key: bytes) -> bytes: # DES密钥必须是8字节 if len(key) != 8: raise ValueError("DES requires an 8-byte key.") iv = os.urandom(8) # DES块大小是8字节 cipher = Cipher(algorithms.TripleDES(key), modes.CBC(iv)) # 使用3DES增强安全性 encryptor = cipher.encryptor() padder = padding.PKCS7(64).padder() padded_data = padder.update(plain_data) + padder.finalize() cipher_data = encryptor.update(padded_data) + encryptor.finalize() return iv + cipher_data def decrypt(self, cipher_data: bytes, key: bytes) -> bytes: if len(key) != 8: raise ValueError("DES requires an 8-byte key.") iv = cipher_data[:8] actual_cipher_data = cipher_data[8:] cipher = Cipher(algorithms.TripleDES(key), modes.CBC(iv)) decryptor = cipher.decryptor() padded_plain_data = decryptor.update(actual_cipher_data) + decryptor.finalize() unpadder = padding.PKCS7(64).unpadder() plain_data = unpadder.update(padded_plain_data) + unpadder.finalize() return plain_data class RSACrypto(CryptoStrategy): """RSA加密策略""" def encrypt(self, plain_data: bytes, public_key) -> bytes: # public_key 可以是一个bytes（PEM格式）或一个公钥对象 if isinstance(public_key, bytes): public_key = load_pem_public_key(public_key) # RSA加密有长度限制，对于长数据需要分段或使用混合加密。这里演示基础用法。 # 实际中，RSA常用于加密一个随机的对称密钥。 cipher_data = public_key.encrypt( plain_data, asym_padding.OAEP( mgf=asym_padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None ) ) return cipher_data def decrypt(self, cipher_data: bytes, private_key) -> bytes: if isinstance(private_key, bytes): private_key = load_pem_private_key(private_key, password=None) plain_data = private_key.decrypt( cipher_data, asym_padding.OAEP( mgf=asym_padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None ) ) return plain_data

关键点解释：

1. 我们使用了cryptography库，它是目前Python社区推荐的安全密码学库，避免了自行实现算法可能带来的安全隐患。
2. 对称加密（AES/DES）使用了CBC模式，这是一种常用的分组密码模式，需要初始化向量(IV)来增加安全性。我们将IV与密文一起存储。
3. DES算法密钥短，已不安全，示例中实际使用了TripleDES(3DES)来演示。在你的毕设中，可以明确指出DES的安全性缺陷，并说明3DES是其增强版本。
4. RSA加密有数据长度限制（与密钥长度有关）。在实际文件加密中，通常采用“混合加密”：用RSA加密一个随机生成的对称密钥，再用该对称密钥加密文件数据。本文为简化，直接加密较短数据。你可以在扩展部分实现混合加密。

5.2 实现模态处理器 (core/data_handler.py)

这个模块负责不同模态数据的读取、预处理和后处理。

# 文件路径：core/data_handler.py from PIL import Image import io class DataHandler(ABC): """数据处理器抽象基类""" @abstractmethod def load(self, input_path: str) -> bytes: """从文件路径加载数据，返回字节流""" pass @abstractmethod def save(self, data: bytes, output_path: str): """将字节流数据保存到指定路径""" pass class TextHandler(DataHandler): """文本数据处理器""" def load(self, input_path: str) -> bytes: # 以二进制模式读取，确保得到原始字节 with open(input_path, 'rb') as f: return f.read() def save(self, data: bytes, output_path: str): # 以二进制模式写入 with open(output_path, 'wb') as f: f.write(data) class ImageHandler(DataHandler): """图像数据处理器""" def load(self, input_path: str) -> bytes: # 方案1：直接读取为字节流（适用于任何加密算法） with open(input_path, 'rb') as f: return f.read() # 方案2：如果需要对像素值进行操作，可以读取为PIL Image，再转换。 # img = Image.open(input_path) # img_byte_arr = io.BytesIO() # img.save(img_byte_arr, format=img.format) # return img_byte_arr.getvalue() def save(self, data: bytes, output_path: str): # 因为加密后是乱码字节流，无法用PIL解析，所以直接写入文件。 # 解密后，如果是有效的图像字节流，则可以正常显示。 with open(output_path, 'wb') as f: f.write(data) # 可选：解密后验证图像是否有效 # try: # img = Image.open(io.BytesIO(data)) # img.verify() # 验证文件完整性 # print(f"[INFO] 解密后的图像文件有效，已保存至 {output_path}") # except Exception as e: # print(f"[WARN] 解密后的数据可能不是有效图像格式: {e}") # 工厂函数：根据文件扩展名返回对应的处理器 def get_handler_for_file(file_path: str) -> DataHandler: ext = file_path.lower().split('.')[-1] image_exts = ['png', 'jpg', 'jpeg', 'bmp', 'gif', 'tiff'] if ext in image_exts: return ImageHandler() else: # 默认视为文本类文件处理（如.txt, .csv, .json等） return TextHandler()

关键点解释：

1. 所有处理器都统一返回bytes类型，这是加解密算法需要的通用格式。
2. 对于图像，我们有两种处理思路：一是直接当作二进制文件加密（简单通用），二是解析为像素矩阵后对像素值进行加密（可能涉及图像处理算法）。前者更通用，后者可能作为“特色功能”在毕设中展示。我们采用第一种。
3. get_handler_for_file函数是一个简单的工厂，根据文件后缀名自动选择处理器。这简化了主程序的逻辑。

5.3 实现工具函数 (utils/file_utils.py)

一些辅助函数，例如密钥加载。

# 文件路径：utils/file_utils.py import os def load_key_from_file(key_path: str) -> bytes: """从文件加载密钥（二进制或PEM格式）""" if not os.path.exists(key_path): raise FileNotFoundError(f"密钥文件不存在: {key_path}") with open(key_path, 'rb') as f: return f.read() def generate_and_save_rsa_keys(private_key_path='keys/rsa_private.pem', public_key_path='keys/rsa_public.pem', key_size=2048): """生成RSA密钥对并保存到文件""" from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization os.makedirs(os.path.dirname(private_key_path), exist_ok=True) private_key = rsa.generate_private_key( public_exponent=65537, key_size=key_size, ) public_key = private_key.public_key() # 保存私钥 with open(private_key_path, 'wb') as f: f.write(private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.NoEncryption() )) # 保存公钥 with open(public_key_path, 'wb') as f: f.write(public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo )) print(f"[INFO] RSA密钥对已生成。私钥: {private_key_path}, 公钥: {public_key_path}")

5.4 实现主程序与命令行界面 (main.py)

这是系统的入口，负责协调所有模块。

# 文件路径：main.py import argparse import os import sys sys.path.append(os.path.dirname(os.path.abspath(__file__))) from core.crypto_strategy import AESCrypto, DESCrypto, RSACrypto from core.data_handler import get_handler_for_file from utils.file_utils import load_key_from_file, generate_and_save_rsa_keys def main(): parser = argparse.ArgumentParser(description='多模态数据加解密系统') parser.add_argument('mode', choices=['encrypt', 'decrypt'], help='操作模式：加密或解密') parser.add_argument('algorithm', choices=['aes', 'des', 'rsa'], help='加密算法') parser.add_argument('input_file', help='输入文件路径') parser.add_argument('output_file', help='输出文件路径') parser.add_argument('--key', help='对称加密密钥文件路径（AES/DES使用）') parser.add_argument('--key-size', type=int, default=256, help='AES密钥长度（128, 192, 256），默认256') parser.add_argument('--pub-key', help='RSA公钥文件路径（加密时使用）') parser.add_argument('--priv-key', help='RSA私钥文件路径（解密时使用）') parser.add_argument('--gen-rsa-keys', action='store_true', help='生成RSA密钥对并退出') args = parser.parse_args() # 如果指定了生成RSA密钥，则生成并退出 if args.gen_rsa_keys: generate_and_save_rsa_keys() return # 1. 根据算法选择策略 crypto_map = { 'aes': AESCrypto(key_size=args.key_size), 'des': DESCrypto(), 'rsa': RSACrypto(), } crypto = crypto_map.get(args.algorithm) if not crypto: print(f"[ERROR] 不支持的算法: {args.algorithm}") return # 2. 加载密钥 key = None if args.algorithm in ['aes', 'des']: if not args.key: print(f"[ERROR] 对称加密算法 {args.algorithm.upper()} 需要 --key 参数指定密钥文件。") # 或者可以在这里让用户输入密钥字符串并编码 return key = load_key_from_file(args.key) # 简单验证密钥长度 if args.algorithm == 'aes': expected_len = args.key_size // 8 if len(key) != expected_len: print(f"[ERROR] AES-{args.key_size} 需要 {expected_len} 字节的密钥，当前为 {len(key)} 字节。") return elif args.algorithm == 'des' and len(key) != 8: print(f"[ERROR] DES 需要 8 字节的密钥，当前为 {len(key)} 字节。") return elif args.algorithm == 'rsa': if args.mode == 'encrypt': if not args.pub_key: print("[ERROR] RSA加密需要 --pub-key 参数指定公钥文件。") return key = load_key_from_file(args.pub_key) else: # decrypt if not args.priv_key: print("[ERROR] RSA解密需要 --priv-key 参数指定私钥文件。") return key = load_key_from_file(args.priv_key) # 3. 获取数据处理器并加载数据 handler = get_handler_for_file(args.input_file) try: data = handler.load(args.input_file) except Exception as e: print(f"[ERROR] 读取文件失败: {e}") return # 4. 执行加解密操作 try: if args.mode == 'encrypt': processed_data = crypto.encrypt(data, key) print(f"[INFO] 加密完成。") else: # decrypt processed_data = crypto.decrypt(data, key) print(f"[INFO] 解密完成。") except Exception as e: print(f"[ERROR] 加解密过程出错: {e}") return # 5. 保存结果 try: handler.save(processed_data, args.output_file) print(f"[INFO] 结果已保存至: {args.output_file}") except Exception as e: print(f"[ERROR] 保存文件失败: {e}") return if __name__ == '__main__': main()

6. 运行结果与效果验证

现在，让我们用实际数据来测试整个系统。请确保你的项目目录结构已创建好，并且data/文件夹下有一些测试文件。

6.1 准备测试数据

1. 在data/目录下创建input.txt，内容为Hello, CSDN! This is a secret message.。
2. 准备一张测试图片input_image.png也放在data/目录下。
3. 在项目根目录运行python main.py --gen-rsa-keys生成RSA密钥对，它们会保存在keys/目录。

6.2 测试AES加密文本

首先生成一个32字节（256位）的AES密钥。我们可以用Python生成并保存：

# 在项目根目录打开Python交互环境或创建一个临时脚本 python -c "import os; key=os.urandom(32); open('data/aes_key.bin', 'wb').write(key); print('AES key generated.')"

现在进行加密：

# 加密文本文件 python main.py encrypt aes data/input.txt data/encrypted/secret.aes --key data/aes_key.bin

如果成功，会看到[INFO] 加密完成。和[INFO] 结果已保存至: data/encrypted/secret.aes。用文本编辑器打开secret.aes会看到乱码。

解密：

python main.py decrypt aes data/encrypted/secret.aes data/decrypted.txt --key data/aes_key.bin

打开data/decrypted.txt，应该能看到原始文本内容。

6.3 测试DES加密图像

生成一个8字节的DES密钥：

python -c "import os; key=os.urandom(8); open('data/des_key.bin', 'wb').write(key); print('DES key generated.')"

加密图像：

python main.py encrypt des data/input_image.png data/encrypted/image.des --key data/des_key.bin

解密图像：

python main.py decrypt des data/encrypted/image.des data/decrypted.png --key data/des_key.bin

用图片查看器打开data/decrypted.png，应该能看到和原图一样的图像。

6.4 测试RSA加密文本

RSA加密使用公钥，解密使用私钥。

# 使用之前生成的公钥加密 python main.py encrypt rsa data/input.txt data/encrypted/secret.rsa --pub-key keys/rsa_public.pem # 使用私钥解密 python main.py decrypt rsa data/encrypted/secret.rsa data/decrypted_rsa.txt --priv-key keys/rsa_private.pem

检查data/decrypted_rsa.txt内容是否正确。

如何验证成功？

1. 功能验证：加解密后的文件内容（文本可读，图像可显示）与原始文件一致。
2. 完整性验证：对于文本，可以计算MD5或SHA256哈希值，比较加解密前后是否一致。对于图像，可以使用PIL验证文件格式有效性。
3. 安全性观察：加密后的文件应为乱码，且即使对同一明文使用相同密钥加密两次（由于IV随机），产生的密文也不同（CBC模式特性）。

7. 常见问题与排查思路

在实现和运行过程中，你可能会遇到以下问题：

8. 最佳实践与工程建议

为了让你的毕业设计项目更专业、更健壮，可以考虑以下扩展和优化：

1. 扩展至六种算法：你已经有了AES、DES、RSA的框架。要支持更多算法（如Blowfish, IDEA, RC4等），只需在crypto_strategy.py中创建新的策略类，并在main.py的crypto_map中注册即可。注意：选择算法时，应优先选择现代、安全的算法（如AES-256， ChaCha20），并对DES等老旧算法说明其安全性不足。

2. 支持更多数据模态：要支持音频，可以创建AudioHandler，使用librosa或pydub库读取音频为字节流或数值数组。视频处理则更为复杂，可以考虑使用OpenCV或moviepy逐帧处理。

3. 实现混合加密：这是实际应用中的标准做法。修改RSACrypto或创建一个新的HybridRSA策略类，其encrypt方法：生成随机AES密钥 → 用AES加密数据 → 用RSA公钥加密AES密钥 → 将两者打包输出。解密过程则相反。

4. 增加图形用户界面(GUI)：使用tkinter或PyQt5构建一个简单的桌面应用。界面应包括：文件选择、算法选择、密钥输入/选择、加密/解密按钮、状态显示。将核心的core模块导入GUI程序即可复用。

5. 增强错误处理与日志：在主程序中加入更细致的try...except块，捕获不同类型的异常（如IO错误、密钥错误、数据格式错误），并给出友好的提示。可以使用Python的logging模块记录运行日志，便于调试。

6. 性能优化：对于大文件（如视频），一次性读入内存可能不可行。需要实现流式处理：分块读取数据，分块加密/解密，分块写入。这需要算法支持流式操作（如使用CFB、OFB等模式或流密码）。

7. 项目文档与展示：

   • README.md：详细说明项目背景、功能、使用方法、目录结构、依赖安装。
   • 设计文档：用UML类图展示策略模式、工厂模式在你的系统中的应用。
   • 测试报告：对不同模态、不同算法、不同文件大小进行测试，记录成功率、耗时。
   • 演示视频：录制一个从安装到加解密完整流程的短视频，在答辩时播放。

8. 安全性提醒：在毕设报告中必须指出，本演示系统密钥管理简单（文件存储），不适合生产环境。生产环境需要使用密钥管理系统(KMS)、硬件安全模块(HSM)等。同时强调使用经过审计的密码学库（如cryptography）而非自己实现算法。

通过以上步骤，你不仅完成了一个能运行的毕设项目，更掌握了一套处理“多模态x多算法”复杂系统的设计方法论。这个基于策略模式的架构清晰、扩展性强，足以让你在答辩时清晰地阐述设计思路，并从容应对老师的提问。