import tkinter as tk from tkinter import ttk, scrolledtext, messagebox, filedialog, simpledialog import re import os import hashlib import base64 import binascii import json from datetime import datetime import threading import time import math import ttkbootstrap as ttkb from ttkbootstrap.constants import * from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad # ================== 简化版多语言支持 ================== class I18N: def __init__(self): self.translations = {} self.current_lang = 'zh' # 设置默认语言 self.load_translations() def load_translations(self): """加载翻译数据""" # 基础翻译字典 self.translations = { 'zh': { "文本加密工具": "文本加密工具", "启动中...": "启动中...", "正在加载加密引擎核心模块...": "正在加载加密引擎核心模块...", "正在配置安全参数...": "正在配置安全参数...", "正在加载密钥配置...": "正在加载密钥配置...", "正在加载历史记录...": "正在加载历史记录...", "正在初始化用户界面...": "正在初始化用户界面...", "正在构建界面组件...": "正在构建界面组件...", "正在进行最终安全检查...": "正在进行最终安全检查...", "加密引擎已就绪！": "加密引擎已就绪！", "准备就绪 - 可以进行智能加密/解密。": "准备就绪 - 可以进行智能加密/解密。", "全屏模式 - 按Esc退出全屏": "全屏模式 - 按Esc退出全屏", "窗口模式 - 按Esc进入全屏": "窗口模式 - 按Esc进入全屏", "当前密钥:": "当前密钥:", "管理密钥": "管理密钥", "输入内容:": "输入内容:", "打开文本文件": "打开文本文件", "打开二进制文件": "打开二进制文件", "保存解释结果到文件": "保存解释结果到文件", "加密/解密": "加密/解密", "输出格式:": "输出格式:", "转换结果:": "转换结果:", "历史记录:": "历史记录:", "无打开文件": "无打开文件", "设置": "设置", "语言": "语言", "地区": "地区", "主题": "主题", "高级选项": "高级选项", "错误": "错误", "历史记录错误": "历史记录错误", "保存错误": "保存错误", "警告": "警告", "确认": "确认", "文件错误": "文件错误", "处理错误": "处理错误", "加密/解密错误": "加密/解密错误", "添加密钥": "添加密钥", "删除密钥": "删除密钥", "编辑密钥": "编辑密钥", "设为默认": "设为默认", "关闭": "关闭", "文件: {}": "文件: {}", "剪切": "剪切", "复制": "复制", "粘贴": "粘贴", "清除": "清除", "输入框不能为空": "输入框不能为空", "没有内容可保存": "没有内容可保存", "处理完成": "处理完成", "进度: {:.1f}% | 速度: {:.2f} MB/s | 剩余时间: {}": "进度: {:.1f}% | 速度: {:.2f} MB/s | 剩余时间: {}", "已选择密钥: {}": "已选择密钥: {}", "输出格式设置为: {}": "输出格式设置为: {}", "已加载历史记录: {}": "已加载历史记录: {}", "密钥 '{}' 不存在": "密钥 '{}' 不存在", "加载密钥配置失败: {}": "加载密钥配置失败: {}", "保存密钥配置失败: {}": "保存密钥配置失败: {}", "加载历史记录失败: {}": "加载历史记录失败: {}", "保存历史记录失败: {}": "保存历史记录失败: {}", "密钥名称已存在！": "密钥名称已存在！", "不能删除默认密钥!": "不能删除默认密钥!", "确定要删除密钥 '{}' 吗?": "确定要删除密钥 '{}' 吗?", "密钥长度至少需要8个字符！": "密钥长度至少需要8个字符！", "打开文件失败: {}": "打开文件失败: {}", "保存文件失败: {}": "保存文件失败: {}", "处理文件失败: {}": "处理文件失败: {}", "二进制处理失败: {}": "二进制处理失败: {}", "数据长度不足": "数据长度不足", "文本加密失败: {}": "文本加密失败: {}", "密钥解密失败: {}": "密钥解密失败: {}", "操作失败: {}": "操作失败: {}", "语言切换": "语言切换", "语言已切换，部分界面元素将在下次启动时完全更新": "语言已切换，部分界面元素将在下次启动时完全更新", "密钥 → 文本: 解密完成": "密钥 → 文本: 解密完成", "文本 → 密钥: 加密完成": "文本 → 密钥: 加密完成", "已添加密钥: {}": "已添加密钥: {}", "已删除密钥: {}": "已删除密钥: {}", "已更新密钥: {}": "已更新密钥: {}", "已将 '{}' 设为当前密钥": "已将 '{}' 设为当前密钥", "已加载文本文件: {}": "已加载文本文件: {}", "已加载二进制文件: {}": "已加载二进制文件: {}", "结果已保存到: {}": "结果已保存到: {}", "文件处理完成: {}": "文件处理完成: {}", "文件已成功处理并保存为:\n{}": "文件已成功处理并保存为:\n{}", "二进制": "二进制", "Base64": "Base64", "十六进制": "十六进制", "默认密钥": "默认密钥", "文件解密": "文件解密", "文件加密": "文件加密", "二进制数据 ({}字节)": "二进制数据 ({}字节)", "解密": "解密", "加密": "加密", "选择文本文件": "选择文本文件", "选择二进制文件": "选择二进制文件", "保存结果": "保存结果", "文本文件": "文本文件", "所有文件": "所有文件", "密钥管理": "密钥管理", "输入新密钥名称:": "输入新密钥名称:", "输入'{}'的密钥值:": "输入'{}'的密钥值:", "修改密钥 '{}' 的值:": "修改密钥 '{}' 的值:", "可用密钥:": "可用密钥:", "准备就绪": "准备就绪", "操作失败": "操作失败", "启用动画效果": "启用动画效果", "显示高级选项": "显示高级选项", "自动检查更新": "自动检查更新", "启用云同步": "启用云同步", "记录操作日志": "记录操作日志", "使用硬件加速": "使用硬件加速", "启用安全模式": "启用安全模式", "优化性能": "优化性能", "暗黑模式": "暗黑模式", "浅色模式": "浅色模式", "系统默认": "系统默认", "设置已保存": "设置已保存", "设置已保存，部分更改需要重启应用": "设置已保存，部分更改需要重启应用", "禁用历史记录": "禁用历史记录", "历史记录功能已禁用": "历史记录功能已禁用", "历史记录功能已启用": "历史记录功能已启用" }, 'en': { "文本加密工具": "Text Encryption Tool", "启动中...": "Starting...", "正在加载加密引擎核心模块...": "Loading encryption engine core...", "正在配置安全参数...": "Configuring security parameters...", "正在加载密钥配置...": "Loading key configurations...", "正在加载历史记录...": "Loading history...", "正在初始化用户界面...": "Initializing user interface...", "正在构建界面组件...": "Building UI components...", "正在进行最终安全检查...": "Performing final security checks...", "加密引擎已就绪！": "Encryption engine ready!", "准备就绪 - 可以进行智能加密/解密。": "Ready - You can perform intelligent encryption/decryption.", "全屏模式 - 按Esc退出全屏": "Fullscreen mode - Press Esc to exit", "窗口模式 - 按Esc进入全屏": "Window mode - Press Esc for fullscreen", "当前密钥:": "Current Key:", "管理密钥": "Manage Keys", "输入内容:": "Input Content:", "打开文本文件": "Open Text File", "打开二进制文件": "Open Binary File", "保存解释结果到文件": "Save Result to File", "加密/解密": "Encrypt/Decrypt", "输出格式:": "Output Format:", "转换结果:": "Conversion Result:", "历史记录:": "History:", "无打开文件": "No file opened", "设置": "Settings", "语言": "Language", "地区": "Region", "主题": "Theme", "高级选项": "Advanced Options", "错误": "Error", "历史记录错误": "History Error", "保存错误": "Save Error", "警告": "Warning", "确认": "Confirm", "文件错误": "File Error", "处理错误": "Processing Error", "加密/解密错误": "Encryption/Decryption Error", "添加密钥": "Add Key", "删除密钥": "Delete Key", "编辑密钥": "Edit Key", "设为默认": "Set as Default", "关闭": "Close", "文件: {}": "File: {}", "剪切": "Cut", "复制": "Copy", "粘贴": "Paste", "清除": "Clear", "输入框不能为空": "Input cannot be empty", "没有内容可保存": "No content to save", "处理完成": "Processing complete", "进度: {:.1f}% | 速度: {:.2f} MB/s | 剩余时间: {}": "Progress: {:.1f}% | Speed: {:.2f} MB/s | Remaining: {}", "已选择密钥: {}": "Key selected: {}", "输出格式设置为: {}": "Output format set to: {}", "已加载历史记录: {}": "History loaded: {}", "密钥 '{}' 不存在": "Key '{}' does not exist", "加载密钥配置失败: {}": "Failed to load key config: {}", "保存密钥配置失败: {}": "Failed to save key config: {}", "加载历史记录失败: {}": "Failed to load history: {}", "保存历史记录失败: {}": "Failed to save history: {}", "密钥名称已存在！": "Key name already exists!", "不能删除默认密钥!": "Cannot delete default key!", "确定要删除密钥 '{}' 吗?": "Are you sure to delete key '{}'?", "密钥长度至少需要8个字符！": "Key must be at least 8 characters!", "打开文件失败: {}": "Failed to open file: {}", "保存文件失败: {}": "Failed to save file: {}", "处理文件失败: {}": "Failed to process file: {}", "二进制处理失败: {}": "Binary processing failed: {}", "数据长度不足": "Insufficient data length", "文本加密失败: {}": "Text encryption failed: {}", "密钥解密失败: {}": "Key decryption failed: {}", "操作失败: {}": "Operation failed: {}", "语言切换": "Language Changed", "语言已切换，部分界面元素将在下次启动时完全更新": "Language changed, some UI elements will update on next launch", "密钥 → 文本: 解密完成": "Key → Text: Decryption complete", "文本 → 密钥: 加密完成": "Text → Key: Encryption complete", "已添加密钥: {}": "Key added: {}", "已删除密钥: {}": "Key deleted: {}", "已更新密钥: {}": "Key updated: {}", "已将 '{}' 设为当前密钥": "'{}' set as current key", "已加载文本文件: {}": "Text file loaded: {}", "已加载二进制文件: {}": "Binary file loaded: {}", "结果已保存到: {}": "Result saved to: {}", "文件处理完成: {}": "File processed: {}", "文件已成功处理并保存为:\n{}": "File processed and saved as:\n{}", "二进制": "Binary", "Base64": "Base64", "十六进制": "Hexadecimal", "默认密钥": "Default Key", "文件解密": "File Decryption", "文件加密": "File Encryption", "二进制数据 ({}字节)": "Binary Data ({} bytes)", "解密": "Decryption", "加密": "Encryption", "选择文本文件": "Select Text File", "选择二进制文件": "Select Binary File", "保存结果": "Save Result", "文本文件": "Text Files", "所有文件": "All Files", "密钥管理": "Key Management", "输入新密钥名称:": "Enter new key name:", "输入'{}'的密钥值:": "Enter key value for '{}':", "修改密钥 '{}' 的值:": "Modify value for key '{}':", "可用密钥:": "Available Keys:", "准备就绪": "Ready", "操作失败": "Operation Failed", "启用动画效果": "Enable Animations", "显示高级选项": "Show Advanced Options", "自动检查更新": "Auto Check Updates", "启用云同步": "Enable Cloud Sync", "记录操作日志": "Log Operations", "使用硬件加速": "Use Hardware Acceleration", "启用安全模式": "Enable Safe Mode", "优化性能": "Optimize Performance", "暗黑模式": "Dark Mode", "浅色模式": "Light Mode", "系统默认": "System Default", "设置已保存": "Settings Saved", "设置已保存，部分更改需要重启应用": "Settings saved, some changes require restart", "禁用历史记录": "Disable History", "历史记录功能已禁用": "History function disabled", "历史记录功能已启用": "History function enabled" }, 'ja': { "文本加密工具": "テキスト暗号化ツール", "启动中...": "起動中...", "正在加载加密引擎核心模块...": "暗号化エンジンコアモジュールをロード中...", "正在配置安全参数...": "セキュリティパラメータを設定中...", "正在加载密钥配置...": "キー設定をロード中...", "正在加载历史记录...": "履歴をロード中...", "正在初始化用户界面...": "ユーザーインターフェースを初期化中...", "正在构建界面组件...": "UIコンポーネントを構築中...", "正在进行最终安全检查...": "最終セキュリティチェックを実行中...", "加密引擎已就绪！": "暗号化エンジン準備完了！", "准备就绪 - 可以进行智能加密/解密。": "準備完了 - インテリジェントな暗号化/復号を実行できます。", "全屏模式 - 按Esc退出全屏": "フルスクリーンモード - Escキーで終了", "窗口模式 - 按Esc进入全屏": "ウィンドウモード - Escキーでフルスクリーンへ", "当前密钥:": "現在のキー:", "管理密钥": "キー管理", "输入内容:": "入力内容:", "打开文本文件": "テキストファイルを開く", "打开二进制文件": "バイナリファイルを開く", "保存解释结果到文件": "結果をファイルに保存", "加密/解密": "暗号化/復号", "输出格式:": "出力形式:", "转换结果:": "変換結果:", "历史记录:": "履歴:", "无打开文件": "ファイル未開封", "设置": "設定", "语言": "言語", "地区": "地域", "主题": "テーマ", "高级选项": "詳細オプション", "错误": "エラー", "历史记录错误": "履歴エラー", "保存错误": "保存エラー", "警告": "警告", "确认": "確認", "文件错误": "ファイルエラー", "处理错误": "処理エラー", "加密/解密错误": "暗号化/復号エラー", "添加密钥": "キー追加", "删除密钥": "キー削除", "编辑密钥": "キー編集", "设为默认": "デフォルトに設定", "关闭": "閉じる", "文件: {}": "ファイル: {}", "剪切": "切り取り", "复制": "コピー", "粘贴": "貼り付け", "清除": "クリア", "输入框不能为空": "入力は空にできません", "没有内容可保存": "保存する内容がありません", "处理完成": "処理完了", "进度: {:.1f}% | 速度: {:.2f} MB/s | 剩余时间: {}": "進捗: {:.1f}% | 速度: {:.2f} MB/s | 残り時間: {}", "已选择密钥: {}": "キーを選択済み: {}", "输出格式设置为: {}": "出力形式を設定: {}", "已加载历史记录: {}": "履歴をロード済み: {}", "密钥 '{}' 不存在": "キー '{}' は存在しません", "加载密钥配置失败: {}": "キー設定のロード失敗: {}", "保存密钥配置失败: {}": "キー設定の保存失敗: {}", "加载历史记录失败: {}": "履歴のロード失敗: {}", "保存历史记录失败: {}": "履歴の保存失敗: {}", "密钥名称已存在！": "キー名が既に存在します！", "不能删除默认密钥!": "デフォルトキーは削除できません！", "确定要删除密钥 '{}' 吗?": "キー '{}' を削除してもよろしいですか？", "密钥长度至少需要8个字符！": "キーは最低8文字必要です！", "打开文件失败: {}": "ファイルオープン失敗: {}", "保存文件失败: {}": "ファイル保存失敗: {}", "处理文件失败: {}": "ファイル処理失敗: {}", "二进制处理失败: {}": "バイナリ処理失敗: {}", "数据长度不足": "データ長が不足しています", "文本加密失败: {}": "テキスト暗号化失敗: {}", "密钥解密失败: {}": "キー復号失敗: {}", "操作失败: {}": "操作失敗: {}", "语言切换": "言語切替", "语言已切换，部分界面元素将在下次启动时完全更新": "言語を変更しました。一部のUI要素は次回起動時に完全に更新されます", "密钥 → 文本: 解密完成": "キー → テキスト: 復号完了", "文本 → 密钥: 加密完成": "テキスト → キー: 暗号化完了", "已添加密钥: {}": "キーを追加: {}", "已删除密钥: {}": "キーを削除: {}", "已更新密钥: {}": "キーを更新: {}", "已将 '{}' 设为当前密钥": "'{}' を現在のキーに設定しました", "已加载文本文件: {}": "テキストファイルをロード: {}", "已加载二进制文件: {}": "バイナリファイルをロード: {}", "结果已保存到: {}": "結果を保存: {}", "文件处理完成: {}": "ファイル処理完了: {}", "文件已成功处理并保存为:\n{}": "ファイルの処理と保存に成功しました:\n{}", "二进制": "バイナリ", "Base64": "Base64", "十六进制": "16進数", "默认密钥": "デフォルトキー", "文件解密": "ファイル復号", "文件加密": "ファイル暗号化", "二进制数据 ({}字节)": "バイナリデータ ({} バイト)", "解密": "復号", "加密": "暗号化", "选择文本文件": "テキストファイルを選択", "选择二进制文件": "バイナリファイルを選択", "保存结果": "結果を保存", "文本文件": "テキストファイル", "所有文件": "すべてのファイル", "密钥管理": "キー管理", "输入新密钥名称:": "新しいキー名を入力:", "输入'{}'的密钥值:": "'{}'のキー値を入力:", "修改密钥 '{}' 的值:": "キー '{}' の値を変更:", "可用密钥:": "利用可能なキー:", "准备就绪": "準備完了", "操作失败": "操作失敗", "启用动画效果": "アニメーション効果を有効化", "显示高级选项": "詳細オプションを表示", "自动检查更新": "自動更新チェック", "启用云同步": "クラウド同期を有効化", "记录操作日志": "操作ログを記録", "使用硬件加速": "ハードウェアアクセラレーションを使用", "启用安全模式": "セーフモードを有効化", "优化性能": "パフォーマンスを最適化", "暗黑模式": "ダークモード", "浅色模式": "ライトモード", "系统默认": "システムデフォルト", "设置已保存": "設定を保存しました", "设置已保存，部分更改需要重启应用": "設定を保存しました。一部の変更はアプリの再起動が必要です", "禁用历史记录": "履歴を無効化", "历史记录功能已禁用": "履歴機能を無効化しました", "历史记录功能已启用": "履歴機能を有効化しました" } } def set_language(self, lang_code): """设置当前语言""" self.current_lang = lang_code def translate(self, text, *args): """翻译文本并格式化""" # 获取翻译 if self.current_lang in self.translations and text in self.translations[self.current_lang]: translated = self.translations[self.current_lang][text] else: translated = text # 找不到翻译则返回原文 # 格式化文本 if args: try: return translated.format(*args) except: return translated return translated # 初始化多语言支持 i18n = I18N() _ = i18n.translate # ================== 其余代码保持不变 ================== class SplashScreen: """开启动画类""" def __init__(self, root): self.root = root self.splash = tk.Toplevel(root) self.splash.title(_("启动中...")) self.splash.geometry("600x400") self.splash.overrideredirect(True) # 无边框 self.splash.configure(bg="#f0f0f0") # 设置窗口居中 screen_width = self.splash.winfo_screenwidth() screen_height = self.splash.winfo_screenheight() x = (screen_width - 500) // 2 y = (screen_height - 300) // 2 self.splash.geometry(f"500x300+{x}+{y}") # 创建内容 self.create_widgets() def create_widgets(self): """创建动画组件""" # 标题 title_frame = tk.Frame(self.splash, bg="#f0f0f0") title_frame.pack(fill=tk.X, pady=20) title_label = tk.Label( title_frame, text=_("文件加密工具"), font=("SimHei", 24, "bold"), fg="#2c3e50", bg="#f0f0f0" ) title_label.pack() version_label = tk.Label( title_frame, text="AES - 4.0", font=("SimHei", 10), fg="#7f8c8d", bg="#f0f0f0" ) version_label.pack(pady=5) # 进度条区域 progress_frame = tk.Frame(self.splash, bg="#f0f0f0") progress_frame.pack(fill=tk.X, padx=50, pady=40) self.status_var = tk.StringVar() self.status_var.set(_("正在初始化加密引擎...")) status_label = tk.Label( progress_frame, textvariable=self.status_var, font=("SimHei", 10), fg="#34495e", bg="#f0f0f0", anchor="w" ) status_label.pack(fill=tk.X, pady=5) # 自定义进度条 self.progress_frame = tk.Frame(progress_frame, bg="#e0e0e0", height=20) self.progress_frame.pack(fill=tk.X) self.progress_bar = tk.Frame(self.progress_frame, bg="#3498db", width=0) self.progress_bar.pack(side=tk.LEFT, fill=tk.Y) # 进度百分比 self.percent_var = tk.StringVar() self.percent_var.set("0%") percent_label = tk.Label( progress_frame, textvariable=self.percent_var, font=("SimHei", 10), fg="#34495e", bg="#f0f0f0" ) percent_label.pack(pady=5) # 版权信息 copyright_label = tk.Label( self.splash, text="©NetSphere Corporation | 版本 AES - 4.0", font=("SimHei", 8), fg="#95a5a6", bg="#f0f0f0" ) copyright_label.pack(side=tk.BOTTOM, pady=10) def update_progress(self, percent, message): """更新进度""" self.status_var.set(_(message)) self.percent_var.set(f"{percent}%") # 更新进度条宽度 bar_width = int(400 * (percent / 100)) self.progress_bar.config(width=bar_width) self.splash.update() time.sleep(0.1) # 模拟处理时间 def destroy(self): """销毁启动画面""" self.splash.destroy() class EnhancedTextCipherConverter: def __init__(self, root): """Initialize the enhanced application""" self.root = root self.root.title(_("文件加密工具（国际版）.exe")) self.root.geometry("1200x750") self.root.resizable(True, True) # 应用主题 self.style = ttkb.Style(theme="minty") # 先显示启动画面 self.splash = SplashScreen(root) self.splash.update_progress(10, _("正在加载加密引擎核心模块...")) self.current_file_path = "" # 当前文件路径 self.splash.update_progress(20, _("正在配置安全参数...")) # 全屏状态标志 self.fullscreen = False # 创建应用数据目录 self.app_data_dir = self.get_app_data_dir() os.makedirs(self.app_data_dir, exist_ok=True) self.splash.update_progress(30, _("正在加载密钥配置...")) # 密钥管理 self.key_profiles = {} self.current_key = None self.load_key_profiles() self.splash.update_progress(50, _("正在加载历史记录...")) # 历史记录 self.history = [] self.load_history() self.max_history = 20 # 输出格式 self.output_formats = [_("二进制"), _("Base64"), _("十六进制")] self.current_format = _("二进制") # 添加设置管理 self.settings = { "disable_history": False # 默认不禁用历史记录 } self.load_settings() # 加载设置 self.splash.update_progress(60, _("正在初始化用户界面...")) self.splash.update_progress(75, _("正在构建界面组件...")) self.create_widgets() # 绑定Esc键切换全屏 self.root.bind("", self.toggle_fullscreen) # 绑定Enter键触发智能转换 self.text_input.bind("", self.on_enter_key) # 在程序关闭时保存密钥 self.root.protocol("WM_DELETE_WINDOW", self.on_close) self.splash.update_progress(90, _("正在进行最终安全检查...")) time.sleep(0.5) # 模拟安全检查 self.splash.update_progress(100, _("加密引擎已就绪！")) time.sleep(0.5) # 显示完成信息 # 销毁启动画面 self.splash.destroy() def get_app_data_dir(self): """获取应用数据目录""" # 跨平台方法：在用户主目录下创建专用目录 home_dir = os.path.expanduser("~") app_dir = os.path.join(home_dir, ".text_cipher_tool") return app_dir def get_key_profiles_path(self): """获取密钥配置文件的完整路径""" return os.path.join(self.app_data_dir, "key_profiles.json") def get_history_path(self): """获取历史记录文件的完整路径""" return os.path.join(self.app_data_dir, "history.json") def get_settings_path(self): """获取设置文件的完整路径""" return os.path.join(self.app_data_dir, "settings.json") def load_settings(self): """加载设置""" settings_path = self.get_settings_path() try: if os.path.exists(settings_path): with open(settings_path, "r", encoding="utf-8") as f: self.settings = json.load(f) except Exception as e: # 如果加载失败，使用默认设置 self.settings = {"disable_history": False} def save_settings(self): """保存设置""" settings_path = self.get_settings_path() try: with open(settings_path, "w", encoding="utf-8") as f: json.dump(self.settings, f, ensure_ascii=False, indent=2) except Exception as e: messagebox.showerror(_("错误"), _("保存设置失败: {}", str(e))) def on_close(self): """程序关闭时保存密钥和历史记录""" self.save_key_profiles() self.save_history() self.save_settings() # 保存设置 self.root.destroy() def load_key_profiles(self): """加载密钥配置文件""" key_profiles_path = self.get_key_profiles_path() try: if os.path.exists(key_profiles_path): with open(key_profiles_path, "r", encoding="utf-8") as f: self.key_profiles = json.load(f) # 添加默认密钥（如果不存在） if _("默认密钥") not in self.key_profiles: self.key_profiles[_("默认密钥")] = "7x#9FpL2$kZbQ5vR!dH8Yg@3WcN6*4TmS" # 设置当前密钥 if self.key_profiles: self.current_key = list(self.key_profiles.keys())[0] except Exception as e: messagebox.showerror(_("错误"), _("加载密钥配置失败: {}", str(e))) self.key_profiles = {_("默认密钥"): "7x#9FpL2$kZbQ5vR!dH8Yg@3WcN6*4TmS"} self.current_key = _("默认密钥") def save_key_profiles(self): """保存密钥配置文件""" key_profiles_path = self.get_key_profiles_path() try: with open(key_profiles_path, "w", encoding="utf-8") as f: json.dump(self.key_profiles, f, ensure_ascii=False, indent=2) except Exception as e: messagebox.showerror(_("错误"), _("保存密钥配置失败: {}", str(e))) def load_history(self): """加载历史记录""" history_path = self.get_history_path() try: if os.path.exists(history_path): with open(history_path, "r", encoding="utf-8") as f: self.history = json.load(f) except Exception as e: messagebox.showerror(_("历史记录错误"), _("加载历史记录失败: {}", str(e))) self.history = [] def save_history(self): """保存历史记录""" history_path = self.get_history_path() try: with open(history_path, "w", encoding="utf-8") as f: json.dump(self.history, f, ensure_ascii=False, indent=2) except Exception as e: messagebox.showerror(_("保存错误"), _("保存历史记录失败: {}", str(e))) def add_history(self, operation, input_data, output_data): """添加历史记录（如果不禁用）""" if self.settings.get("disable_history", False): return # 如果禁用了历史记录，直接返回 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") key_name = self.current_key # 截断过长的数据 if len(input_data) > 100: input_data = input_data[:100] + "..." if len(output_data) > 100: output_data = output_data[:100] + "..." self.history.insert(0, { "timestamp": timestamp, "operation": operation, "key": key_name, "input": input_data, "output": output_data }) # 限制历史记录数量 if len(self.history) > self.max_history: self.history = self.history[:self.max_history] self.save_history() self.update_history_listbox() def update_history_listbox(self): """更新历史记录列表框""" self.history_listbox.delete(0, tk.END) for item in self.history: timestamp = item["timestamp"] operation = item["operation"] key_name = item["key"] self.history_listbox.insert(tk.END, f"[{timestamp}] {operation} ({key_name})") def get_encryption_key(self, key_name=None): """获取加密密钥""" if key_name is None: key_name = self.current_key if key_name not in self.key_profiles: raise ValueError(_("密钥 '{}' 不存在", key_name)) secret_key = self.key_profiles[key_name] return hashlib.sha256(secret_key.encode()).digest()[:16] def enter_fullscreen(self): """进入全屏模式""" self.fullscreen = True self.root.attributes('-fullscreen', True) self.root.attributes('-topmost', False) self.update_status_bar(_("全屏模式 - 按Esc退出全屏")) def toggle_fullscreen(self, event=None): """切换全屏状态""" self.fullscreen = not self.fullscreen self.root.attributes('-fullscreen', self.fullscreen) if self.fullscreen: self.root.attributes('-topmost', False) self.update_status_bar(_("全屏模式 - 按Esc退出全屏")) else: self.update_status_bar(_("窗口模式 - 按Esc进入全屏")) return "break" def create_widgets(self): """创建界面组件""" # 主框架 main_frame = ttkb.Frame(self.root) main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10) # 添加语言选择菜单 menu_bar = tk.Menu(self.root) self.root.config(menu=menu_bar) settings_menu = tk.Menu(menu_bar, tearoff=0) menu_bar.add_cascade(label=_("设置"), menu=settings_menu) # 语言子菜单 lang_menu = tk.Menu(settings_menu, tearoff=0) settings_menu.add_cascade(label=_("语言"), menu=lang_menu) # 添加所有主要语言选项 languages = [ ("English", "en"), ("中文", "zh"), ("Español", "es"), ("Français", "fr"), ("Deutsch", "de"), ("Italiano", "it"), ("Português", "pt"), ("Русский", "ru"), ("日本語", "ja"), ("한국어", "ko"), ("العربية", "ar"), ("हिन्दी", "hi"), ("বাংলা", "bn"), ("Türkçe", "tr"), ("Tiếng Việt", "vi"), ("ไทย", "th"), ("Nederlands", "nl"), ("Polski", "pl"), ("Svenska", "sv"), ("Suomi", "fi"), ("Dansk", "da"), ("Norsk", "no"), ("Čeština", "cs"), ("Magyar", "hu"), ("Română", "ro"), ("Ελληνικά", "el"), ("עברית", "he"), ("فارسی", "fa"), ("اردو", "ur") ] for lang_name, lang_code in languages: lang_menu.add_command(label=lang_name, command=lambda code=lang_code: self.change_language(code)) # 地区子菜单 region_menu = tk.Menu(settings_menu, tearoff=0) settings_menu.add_cascade(label=_("地区"), menu=region_menu) # 添加主要国家和地区 regions = [ ("全球", "global"), ("中国", "cn"), ("美国", "us"), ("英国", "gb"), ("加拿大", "ca"), ("澳大利亚", "au"), ("日本", "jp"), ("韩国", "kr"), ("德国", "de"), ("法国", "fr"), ("意大利", "it"), ("西班牙", "es"), ("俄罗斯", "ru"), ("巴西", "br"), ("印度", "in"), ("新加坡", "sg"), ("香港", "hk"), ("台湾", "tw"), ("澳门", "mo"), ("马来西亚", "my"), ("泰国", "th"), ("越南", "vn"), ("菲律宾", "ph"), ("印度尼西亚", "id"), ("沙特阿拉伯", "sa"), ("阿联酋", "ae"), ("土耳其", "tr"), ("南非", "za") ] for region_name, region_code in regions: region_menu.add_command(label=region_name, command=lambda code=region_code: self.set_region(code)) # 主题子菜单 theme_menu = tk.Menu(settings_menu, tearoff=0) settings_menu.add_cascade(label=_("主题"), menu=theme_menu) themes = [ (_("暗黑模式"), "dark"), (_("浅色模式"), "light"), (_("系统默认"), "system") ] for theme_name, theme_code in themes: theme_menu.add_command(label=theme_name, command=lambda code=theme_code: self.set_theme(code)) # 高级选项子菜单 advanced_menu = tk.Menu(settings_menu, tearoff=0) settings_menu.add_cascade(label=_("高级选项"), menu=advanced_menu) # 添加禁用历史记录选项 self.disable_history_var = tk.BooleanVar(value=self.settings.get("disable_history", False)) advanced_menu.add_checkbutton( label=_("禁用历史记录"), variable=self.disable_history_var, command=self.toggle_disable_history ) # 添加各种高级选项 advanced_menu.add_checkbutton(label=_("启用动画效果")) advanced_menu.add_checkbutton(label=_("显示高级选项")) advanced_menu.add_checkbutton(label=_("自动检查更新")) advanced_menu.add_checkbutton(label=_("启用云同步")) advanced_menu.add_checkbutton(label=_("记录操作日志")) advanced_menu.add_checkbutton(label=_("使用硬件加速")) advanced_menu.add_checkbutton(label=_("启用安全模式")) advanced_menu.add_checkbutton(label=_("优化性能")) # 密钥管理区域 key_frame = ttkb.Frame(main_frame) key_frame.pack(fill=tk.X, pady=5) ttkb.Label(key_frame, text=_("当前密钥:")).pack(side=tk.LEFT, padx=5) self.key_var = tk.StringVar() self.key_combobox = ttkb.Combobox(key_frame, textvariable=self.key_var, width=20) self.key_combobox['values'] = list(self.key_profiles.keys()) self.key_combobox.set(self.current_key) self.key_combobox.pack(side=tk.LEFT, padx=5) self.key_combobox.bind("<>", self.on_key_selected) ttkb.Button(key_frame, text=_("管理密钥"), command=self.manage_keys).pack(side=tk.LEFT, padx=5) # 输入区域 input_frame = ttkb.LabelFrame(main_frame, text=_("输入内容")) input_frame.pack(fill=tk.BOTH, expand=True, pady=5) self.text_input = scrolledtext.ScrolledText(input_frame, wrap=tk.WORD, height=15) # 设置固定高度 self.text_input.pack(fill=tk.BOTH, expand=True, padx=5, pady=5) # 文件操作区域 file_frame = ttkb.Frame(input_frame) file_frame.pack(fill=tk.X, pady=5) ttkb.Button(file_frame, text=_("打开文本文件"), command=self.open_text_file).pack(side=tk.LEFT, padx=5) ttkb.Button(file_frame, text=_("打开二进制文件"), command=self.open_binary_file).pack(side=tk.LEFT, padx=5) ttkb.Button(file_frame, text=_("保存解释结果到文件"), command=self.save_result_to_file).pack(side=tk.LEFT, padx=5) # 转换按钮和格式选择 convert_frame = ttkb.Frame(main_frame) convert_frame.pack(fill=tk.X, pady=5) self.convert_btn = ttkb.Button(convert_frame, text=_("加密/解密"), command=self.convert_intelligently, bootstyle=PRIMARY) self.convert_btn.pack(side=tk.LEFT, padx=5) ttkb.Label(convert_frame, text=_("输出格式:")).pack(side=tk.LEFT, padx=5) self.format_var = tk.StringVar() self.format_combobox = ttkb.Combobox(convert_frame, textvariable=self.format_var, width=10) self.format_combobox['values'] = self.output_formats self.format_combobox.set(self.current_format) self.format_combobox.pack(side=tk.LEFT, padx=5) self.format_combobox.bind("<>", self.on_format_selected) # 进度条和信息区域 progress_frame = ttkb.Frame(main_frame) progress_frame.pack(fill=tk.X, pady=5) # 进度信息标签 self.progress_info_var = tk.StringVar() self.progress_info_var.set("") progress_info_label = ttkb.Label(progress_frame, textvariable=self.progress_info_var) progress_info_label.pack(anchor=tk.W, pady=2) # 进度条 self.progress_var = tk.DoubleVar() self.progress_bar = ttkb.Progressbar(progress_frame, variable=self.progress_var, maximum=100, bootstyle=SUCCESS) self.progress_bar.pack(fill=tk.X, pady=2) self.progress_bar.pack_forget() # 初始隐藏 # 输出区域 output_frame = ttkb.LabelFrame(main_frame, text=_("转换结果")) output_frame.pack(fill=tk.BOTH, expand=True, pady=5) self.result_output = scrolledtext.ScrolledText(output_frame, wrap=tk.WORD) self.result_output.pack(fill=tk.BOTH, expand=True, padx=5, pady=5) self.result_output.config(state=tk.DISABLED) # 历史记录区域 history_frame = ttkb.LabelFrame(main_frame, text=_("历史记录")) history_frame.pack(fill=tk.BOTH, expand=True, pady=5) self.history_listbox = tk.Listbox(history_frame) self.history_listbox.pack(fill=tk.BOTH, expand=True, padx=5, pady=5) self.history_listbox.bind("<>", self.on_history_selected) # 状态栏（多信息区域） status_frame = ttkb.Frame(main_frame) status_frame.pack(fill=tk.X, pady=5) # 状态信息 self.status_var = tk.StringVar() self.status_var.set(_("准备就绪 - 可以进行加密/解密。")) status_label = ttkb.Label(status_frame, textvariable=self.status_var, anchor=tk.W) status_label.pack(side=tk.LEFT, fill=tk.X, expand=True) # 文件路径信息 self.file_path_var = tk.StringVar() self.file_path_var.set(_("无打开文件")) file_path_label = ttkb.Label(status_frame, textvariable=self.file_path_var, anchor=tk.W) file_path_label.pack(side=tk.LEFT, fill=tk.X, expand=True) # 时间信息 self.time_var = tk.StringVar() self.time_var.set(datetime.now().strftime("%H:%M:%S")) time_label = ttkb.Label(status_frame, textvariable=self.time_var, anchor=tk.W) time_label.pack(side=tk.LEFT, fill=tk.X, expand=False) # 右键菜单 self.text_input.bind("", self.show_popup_menu) self.result_output.bind("", self.show_popup_menu) # 更新历史记录列表 self.update_history_listbox() # 启动时间更新 self.update_clock() def toggle_disable_history(self): """切换禁用历史记录状态""" self.settings["disable_history"] = self.disable_history_var.get() self.save_settings() if self.settings["disable_history"]: self.update_status_bar(_("历史记录功能已禁用")) else: self.update_status_bar(_("历史记录功能已启用")) def set_region(self, region_code): """设置地区（仅显示，无实际功能）""" messagebox.showinfo(_("设置已保存"), _("设置已保存，部分更改需要重启应用")) def set_theme(self, theme_code): """设置主题（仅显示，无实际功能）""" if theme_code == "dark": self.style.theme_use("darkly") elif theme_code == "light": self.style.theme_use("minty") else: # 系统默认 - 使用当前主题 pass self.update_status_bar(_("主题已切换")) def change_language(self, lang_code): """切换语言""" if lang_code not in ['zh', 'en', 'ja']: messagebox.showinfo(_("提示"), _("语言包缺失，暂不支持当前语言。")) return i18n.set_language(lang_code) # 更新界面文本 self.root.title(_("文本加密工具")) self.convert_btn.config(text=_("加密/解密")) self.status_var.set(_("准备就绪 - 可以进行智能加密/解密。")) self.file_path_var.set(_("无打开文件")) # 更新输出格式 self.output_formats = [_("二进制"), _("Base64"), _("十六进制")] self.format_combobox['values'] = self.output_formats self.format_combobox.set(self.current_format) # 更新密钥下拉框 keys = list(self.key_profiles.keys()) self.key_combobox['values'] = keys # 更新其他界面元素... messagebox.showinfo(_("语言切换"), _("语言已切换，部分界面元素将在下次启动时完全更新")) def update_clock(self): """更新时间显示""" self.time_var.set(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) self.root.after(1000, self.update_clock) # 每秒更新一次 def update_status_bar(self, message): """更新状态栏信息""" self.status_var.set(message) def update_file_path(self, file_path): """更新文件路径显示""" if file_path: self.file_path_var.set(_("文件: {}", os.path.basename(file_path))) self.current_file_path = file_path else: self.file_path_var.set(_("无打开文件")) self.current_file_path = "" def update_progress_info(self, progress, speed, remaining_time): """更新进度信息""" if progress >= 100: self.progress_info_var.set(_("处理完成")) else: info = _("进度: {:.1f}% | 速度: {:.2f} MB/s | 剩余时间: {}", progress, speed, self.format_time(remaining_time)) self.progress_info_var.set(info) def format_time(self, seconds): """格式化时间显示""" if seconds <= 0: return "00:00" minutes, seconds = divmod(int(seconds), 60) hours, minutes = divmod(minutes, 60) if hours > 0: return f"{hours:02d}:{minutes:02d}:{seconds:02d}" else: return f"{minutes:02d}:{seconds:02d}" def on_key_selected(self, event): """密钥选择事件""" self.current_key = self.key_var.get() self.update_status_bar(_("已选择密钥: {}", self.current_key)) def on_format_selected(self, event): """输出格式选择事件""" self.current_format = self.format_var.get() self.update_status_bar(_("输出格式设置为: {}", self.current_format)) def on_history_selected(self, event): """历史记录选择事件""" selection = self.history_listbox.curselection() if not selection: return index = selection[0] if index < len(self.history): item = self.history[index] self.result_output.config(state=tk.NORMAL) self.result_output.delete("1.0", tk.END) self.result_output.insert(tk.END, item["output"]) self.result_output.config(state=tk.DISABLED) self.update_status_bar(_("已加载历史记录: {}", item['timestamp'])) def manage_keys(self): """密钥管理对话框""" key_dialog = tk.Toplevel(self.root) key_dialog.title(_("密钥管理")) key_dialog.geometry("530x600") key_dialog.transient(self.root) key_dialog.grab_set() # 密钥列表框架 list_frame = ttkb.Frame(key_dialog, padding="10") list_frame.pack(fill=tk.BOTH, expand=True) ttkb.Label(list_frame, text=_("可用密钥:")).pack(anchor=tk.W, pady=5) key_listbox = tk.Listbox(list_frame) key_listbox.pack(fill=tk.BOTH, expand=True, padx=5, pady=5) for key_name in self.key_profiles: key_listbox.insert(tk.END, key_name) # 按钮框架 btn_frame = ttkb.Frame(key_dialog, padding="10") btn_frame.pack(fill=tk.X, pady=10) def add_key(): key_name = simpledialog.askstring(_("添加密钥"), _("输入新密钥名称:")) if not key_name: return if key_name in self.key_profiles: messagebox.showwarning(_("警告"), _("密钥名称已存在！")) return key_value = simpledialog.askstring(_("添加密钥"), _("输入'{}'的密钥值:", key_name), show='*') if key_value: if len(key_value) < 16: messagebox.showwarning(_("警告"), _("密钥长度至少需要16个字符！")) return self.key_profiles[key_name] = key_value key_listbox.insert(tk.END, key_name) self.save_key_profiles() # 立即保存 # 更新主界面密钥下拉框 self.key_combobox['values'] = list(self.key_profiles.keys()) self.update_status_bar(_("已添加密钥: {}", key_name)) def delete_key(): selection = key_listbox.curselection() if not selection: return index = selection[0] key_name = key_listbox.get(index) if key_name == _("默认密钥"): messagebox.showwarning(_("警告"), _("不能删除默认密钥!")) return if messagebox.askyesno(_("确认"), _("确定要删除密钥 '{}' 吗?", key_name)): del self.key_profiles[key_name] key_listbox.delete(index) self.save_key_profiles() # 立即保存 # 更新主界面密钥下拉框 self.key_combobox['values'] = list(self.key_profiles.keys()) if self.current_key == key_name: self.current_key = list(self.key_profiles.keys())[0] if self.key_profiles else _("默认密钥") self.key_var.set(self.current_key) self.update_status_bar(_("已删除密钥: {}", key_name)) def edit_key(): selection = key_listbox.curselection() if not selection: return index = selection[0] key_name = key_listbox.get(index) new_value = simpledialog.askstring(_("编辑密钥"), _("修改密钥 '{}' 的值:", key_name), initialvalue=self.key_profiles[key_name], show='*') if new_value: if len(new_value) < 8: messagebox.showwarning(_("警告"), _("密钥长度至少需要8个字符！")) return self.key_profiles[key_name] = new_value self.save_key_profiles() # 立即保存 self.update_status_bar(_("已更新密钥: {}", key_name)) def set_default(): selection = key_listbox.curselection() if not selection: return index = selection[0] key_name = key_listbox.get(index) self.current_key = key_name self.key_var.set(key_name) self.update_status_bar(_("已将 '{}' 设为当前密钥", key_name)) ttkb.Button(btn_frame, text=_("添加密钥"), command=add_key).pack(side=tk.LEFT, padx=5) ttkb.Button(btn_frame, text=_("删除密钥"), command=delete_key).pack(side=tk.LEFT, padx=5) ttkb.Button(btn_frame, text=_("编辑密钥"), command=edit_key).pack(side=tk.LEFT, padx=5) ttkb.Button(btn_frame, text=_("设为默认"), command=set_default).pack(side=tk.LEFT, padx=5) ttkb.Button(btn_frame, text=_("关闭"), command=key_dialog.destroy, bootstyle=SECONDARY).pack(side=tk.RIGHT, padx=5) def show_popup_menu(self, event): """显示右键菜单""" popup_menu = tk.Menu(self.root, tearoff=0) popup_menu.add_command(label=_("剪切"), command=lambda: self.root.focus_get().event_generate("<>")) popup_menu.add_command(label=_("复制"), command=lambda: self.root.focus_get().event_generate("<>")) popup_menu.add_command(label=_("粘贴"), command=lambda: self.root.focus_get().event_generate("<>")) popup_menu.add_separator() popup_menu.add_command(label=_("清除"), command=self.clear_content) popup_menu.post(event.x_root, event.y_root) def clear_content(self): """清除内容""" if self.root.focus_get() == self.text_input: self.text_input.delete("1.0", tk.END) elif self.root.focus_get() == self.result_output: self.result_output.config(state=tk.NORMAL) self.result_output.delete("1.0", tk.END) self.result_output.config(state=tk.DISABLED) def on_enter_key(self, event): """处理Enter键事件 - 智能检测和转换""" if event.widget == self.text_input: content = self.text_input.get("1.0", tk.END).strip() if not content: messagebox.showwarning(_("警告"), _("输入框不能为空")) return "break" self.convert_intelligently() return "break" def open_text_file(self): """打开文本文件""" file_path = filedialog.askopenfilename( title=_("选择文本文件"), filetypes=[(_("文本文件"), "*.txt"), (_("所有文件"), "*.*")] ) if file_path: try: with open(file_path, "r", encoding="utf-8") as f: content = f.read() self.text_input.delete("1.0", tk.END) self.text_input.insert(tk.END, content) self.update_status_bar(_("已加载文本文件: {}", os.path.basename(file_path))) self.update_file_path(file_path) except Exception as e: messagebox.showerror(_("文件错误"), _("打开文件失败: {}", str(e))) def open_binary_file(self): """打开二进制文件""" file_path = filedialog.askopenfilename( title=_("选择二进制文件"), filetypes=[(_("所有文件"), "*.*")] ) if file_path: try: self.update_file_path(file_path) # 根据文件大小决定处理方式 file_size = os.path.getsize(file_path) if file_size > 1024 * 1024: # 大于1MB self.update_status_bar(_("处理大文件中: {}", os.path.basename(file_path))) self.progress_bar.pack(fill=tk.X, pady=2) # 显示进度条 self.root.update() # 在新线程中处理大文件 threading.Thread( target=self.process_large_file, args=(file_path, "decrypt"), daemon=True ).start() else: # 直接处理小文件 with open(file_path, "rb") as f: content = f.read() self.process_binary_content(content, "decrypt") self.update_status_bar(_("已加载二进制文件: {}", os.path.basename(file_path))) except Exception as e: messagebox.showerror(_("文件错误"), _("打开文件失败: {}", str(e))) def save_result_to_file(self): """保存结果到文件""" content = self.result_output.get("1.0", tk.END).strip() if not content: messagebox.showwarning(_("警告"), _("没有内容可保存")) return # 获取文件路径，默认添加.txt扩展名 file_path = filedialog.asksaveasfilename( title=_("保存结果"), filetypes=[(_("文本文件"), "*.txt"), (_("所有文件"), "*.*")], defaultextension=".txt" ) if file_path: try: # 确保文件扩展名为.txt if not file_path.lower().endswith('.'): file_path += '.' # 始终以文本模式写入文件 with open(file_path, "w", encoding="utf-8") as f: f.write(content) self.update_status_bar(_("结果已保存到: {}", os.path.basename(file_path))) self.update_file_path(file_path) except Exception as e: messagebox.showerror(_("保存错误"), _("保存文件失败: {}", str(e))) def process_large_file(self, file_path, operation): """处理大文件（带进度条）""" try: file_size = os.path.getsize(file_path) chunk_size = 1024 * 1024 # 1MB块大小 output_path = os.path.splitext(file_path)[0] if operation == "encrypt": output_path += "_encrypted.bin" else: output_path += "_decrypted.bin" processed = 0 encryption_key = self.get_encryption_key() start_time = time.time() last_update = start_time with open(file_path, "rb") as f_in, open(output_path, "wb") as f_out: while True: chunk = f_in.read(chunk_size) if not chunk: break if operation == "encrypt": processed_chunk = self.encrypt_bytes(chunk, encryption_key) else: processed_chunk = self.decrypt_bytes(chunk, encryption_key) f_out.write(processed_chunk) processed += len(chunk) # 更新进度 current_time = time.time() progress = (processed / file_size) * 100 # 每秒更新一次显示信息 if current_time - last_update > 0.5 or processed == file_size: elapsed_time = current_time - start_time speed = (processed / (1024 * 1024)) / elapsed_time # MB/s # 计算剩余时间 if speed > 0: remaining_bytes = file_size - processed remaining_time = remaining_bytes / (speed * 1024 * 1024) else: remaining_time = 0 # 更新进度信息 self.progress_var.set(progress) self.update_progress_info(progress, speed, remaining_time) last_update = current_time # 处理完成 self.progress_var.set(100) self.update_progress_info(100, 0, 0) self.root.after(2000, self.hide_progress_bar) # 2秒后隐藏进度条 self.update_status_bar(_("文件处理完成: {}", os.path.basename(output_path))) messagebox.showinfo(_("完成"), _("文件已成功处理并保存为:\n{}", os.path.basename(output_path))) except Exception as e: self.hide_progress_bar() messagebox.showerror(_("处理错误"), _("处理文件失败: {}", str(e))) def hide_progress_bar(self): """隐藏进度条和相关信息""" self.progress_bar.pack_forget() self.progress_info_var.set("") def process_binary_content(self, content, operation): """处理二进制内容""" try: encryption_key = self.get_encryption_key() if operation == "encrypt": result = self.encrypt_bytes(content, encryption_key) output = self.format_output(result) else: result = self.decrypt_bytes(content, encryption_key) output = result.decode('utf-8', errors='replace') # 显示结果 self.result_output.config(state=tk.NORMAL) self.result_output.delete("1.0", tk.END) self.result_output.insert(tk.END, output) self.result_output.config(state=tk.DISABLED) # 添加历史记录 input_preview = content[:50] + b"..." if len(content) > 50 else content self.add_history( _("文件解密") if operation == "decrypt" else _("文件加密"), _("二进制数据 ({}字节)", len(content)), output[:100] + "..." if len(output) > 100 else output ) return output except Exception as e: raise ValueError(_("二进制处理失败: {}", str(e))) def is_encryption_key(self, text): """检测文本是否为加密密钥（由1和0组成）""" cleaned_text = re.sub(r'\s+', '', text) if not cleaned_text: return False # 检查是否为Base64 try: if len(cleaned_text) % 4 == 0 and re.match(r'^[A-Za-z0-9+/]+={0,2}$', cleaned_text): base64.b64decode(cleaned_text) return True except: pass # 检查是否为十六进制 try: if re.match(r'^[0-9A-Fa-f]+$', cleaned_text): bytes.fromhex(cleaned_text) return True except: pass # 检查是否为二进制 key_chars = sum(1 for c in cleaned_text if c in '01') key_ratio = key_chars / len(cleaned_text) is_valid_length = (len(cleaned_text) % 8 == 0) is_high_key_ratio = key_ratio >= 0.9 return is_valid_length and is_high_key_ratio def convert_intelligently(self): """智能检测并执行加密/解密""" content = self.text_input.get("1.0", tk.END).strip() if not content: messagebox.showwarning(_("警告"), _("输入框不能为空")) return try: if self.is_encryption_key(content): output = self.key_to_text(content) operation = _("解密") self.add_history(operation, content, output) self.update_status_bar(_("密钥 → 文本: 解密完成")) else: output = self.text_to_key(content) operation = _("加密") self.add_history(operation, content, output) self.update_status_bar(_("文本 → 密钥: 加密完成")) except Exception as e: messagebox.showerror(_("加密/解密错误"), _("操作失败: {}", str(e))) self.update_status_bar(_("操作失败")) def encrypt_bytes(self, data_bytes, encryption_key): """使用 AES (CBC 模式) 加密字节数据""" iv = os.urandom(16) cipher = AES.new(encryption_key, AES.MODE_CBC, iv) # 对数据进行填充以确保它是块大小的倍数 padded_data = pad(data_bytes, AES.block_size) # 加密：IV + 密文 ciphertext = cipher.encrypt(padded_data) return iv + ciphertext def decrypt_bytes(self, data_bytes, encryption_key): """使用 AES (CBC 模式) 解密字节数据""" # 提取 IV（前16字节）和实际的密文 if len(data_bytes) < 16: raise ValueError(_("数据长度不足")) iv = data_bytes[:16] ciphertext = data_bytes[16:] cipher = AES.new(encryption_key, AES.MODE_CBC, iv) # 解密然后去除填充 decrypted_padded_data = cipher.decrypt(ciphertext) try: decrypted_data = unpad(decrypted_padded_data, AES.block_size) except ValueError: raise ValueError("解密失败：可能是密钥不正确或数据已损坏") return decrypted_data def format_output(self, data_bytes): """格式化输出为指定格式""" if self.current_format == _("二进制"): # 转换为二进制字符串 binary_key = ''.join(format(byte, '08b') for byte in data_bytes) # 添加空格提高可读性（每8位一组） return ' '.join([binary_key[i:i+8] for i in range(0, len(binary_key), 8)]) elif self.current_format == _("Base64"): return base64.b64encode(data_bytes).decode('utf-8') elif self.current_format == _("十六进制"): return binascii.hexlify(data_bytes).decode('utf-8') return str(data_bytes) def text_to_key(self, text): """加密文本为密钥""" try: # 获取加密密钥 encryption_key = self.get_encryption_key() # 转换为字节 data_bytes = text.encode('utf-8') # 加密 encrypted_data = self.encrypt_bytes(data_bytes, encryption_key) # 格式化输出 output = self.format_output(encrypted_data) # 显示结果 self.result_output.config(state=tk.NORMAL) self.result_output.delete("1.0", tk.END) self.result_output.insert(tk.END, output) self.result_output.config(state=tk.DISABLED) return output except Exception as e: raise ValueError(_("文本加密失败: {}", str(e))) def key_to_text(self, encryption_key): """解密密钥为文本""" try: # 获取加密密钥 decryption_key = self.get_encryption_key() # 根据格式解码 if self.current_format == _("二进制"): cleaned_key = re.sub(r'[^01]', '', encryption_key) byte_list = [] for i in range(0, len(cleaned_key), 8): if i + 8 > len(cleaned_key): break byte_str = cleaned_key[i:i+8] byte_value = int(byte_str, 2) byte_list.append(byte_value) data_bytes = bytes(byte_list) elif self.current_format == _("Base64"): data_bytes = base64.b64decode(encryption_key) elif self.current_format == _("十六进制"): data_bytes = bytes.fromhex(encryption_key) else: # 尝试自动检测 try: data_bytes = base64.b64decode(encryption_key) except: try: data_bytes = bytes.fromhex(encryption_key) except: # 作为二进制处理 cleaned_key = re.sub(r'[^01]', '', encryption_key) byte_list = [] for i in range(0, len(cleaned_key), 8): if i + 8 > len(cleaned_key): break byte_str = cleaned_key[i:i+8] byte_value = int(byte_str, 2) byte_list.append(byte_value) data_bytes = bytes(byte_list) # 解密 decrypted_data = self.decrypt_bytes(data_bytes, decryption_key) # 转换为文本 text = decrypted_data.decode('utf-8', errors='replace') # 显示结果 self.result_output.config(state=tk.NORMAL) self.result_output.delete("1.0", tk.END) self.result_output.insert(tk.END, text) self.result_output.config(state=tk.DISABLED) return text except Exception as e: raise ValueError(_("密钥解密失败: {}", str(e))) if __name__ == "__main__": # 隐藏主窗口直到启动画面完成 root = ttkb.Window(themename="minty") root.withdraw() app = EnhancedTextCipherConverter(root) # 启动画面完成后显示主窗口 root.deiconify() root.mainloop()