#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 云笔记应用程序 支持本地和云端文件管理，支持文本文件(.txt)和加密笔记(.bjb) 完整修复版 - 支持端到端加密，云端下载的单独密钥文件需用户提供.key文件 """ import sys import os import json import tempfile import traceback from datetime import datetime from PyQt5.QtWidgets import * from PyQt5.QtCore import * from PyQt5.QtGui import * import requests # 导入加密模块 from DVT_RFSA import * # ==================== 调试日志配置 ==================== DEBUG = True # True=记录日志, False=不记录日志 def debug_log(msg, level="INFO"): """调试日志函数""" if DEBUG: timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3] print(f"[{timestamp}] [{level}] {msg}") sys.stdout.flush() def debug_error(msg): """错误日志（带堆栈）""" if DEBUG: debug_log(msg, "ERROR") traceback.print_exc() # ==================== 配置 ==================== API_BASE_URL = "https://noteapi.dvssvc.site/api" APP_NAME = "CloudNote" def get_app_dir(): """获取程序所在目录""" if getattr(sys, 'frozen', False): return os.path.dirname(sys.executable) else: return os.path.dirname(os.path.abspath(__file__)) APP_DIR = get_app_dir() USER_KEY_DIR = os.path.expanduser(f"~/.{APP_NAME.lower()}/keys") APP_KEY_DIR = os.path.join(APP_DIR, ".keys") if DEBUG: debug_log(f"程序目录: {APP_DIR}") debug_log(f"用户密钥目录: {USER_KEY_DIR}") debug_log(f"程序密钥目录: {APP_KEY_DIR}") KEY_FILES = { 'rsa_private': "global_rsa_private.pem", 'rsa_public': "global_rsa_public.pem", 'x25519_private': "global_x25519_private.bin", 'x25519_public': "global_x25519_public.bin" } def get_key_path(key_name, prefer_user=True): """获取密钥文件路径，优先使用用户目录""" if prefer_user: search_dirs = [USER_KEY_DIR, APP_KEY_DIR] dir_names = ['user', 'app'] else: search_dirs = [APP_KEY_DIR, USER_KEY_DIR] dir_names = ['app', 'user'] for dir_path, dir_type in zip(search_dirs, dir_names): file_path = os.path.join(dir_path, key_name) if os.path.exists(file_path): if DEBUG: debug_log(f"找到密钥 {key_name} 在 {dir_type} 目录: {file_path}") return file_path, dir_type if DEBUG: debug_log(f"密钥 {key_name} 未找到，将使用用户目录路径") return os.path.join(USER_KEY_DIR, key_name), 'user' def ensure_directory(dir_path): """确保目录存在""" try: os.makedirs(dir_path, exist_ok=True) if DEBUG: debug_log(f"目录已确保: {dir_path}") return True except Exception as e: debug_error(f"创建目录失败 {dir_path}: {e}") return False # ==================== 全局密钥管理（双路径） ==================== def ensure_global_keys(): """确保全局密钥对存在，支持双路径存储""" if DEBUG: debug_log("开始检查/生成全局密钥（双路径模式）...") ensure_directory(USER_KEY_DIR) ensure_directory(APP_KEY_DIR) key_pairs = [ ('rsa', KEY_FILES['rsa_private'], KEY_FILES['rsa_public'], generate_rsa_key, 4096), ('x25519', KEY_FILES['x25519_private'], KEY_FILES['x25519_public'], generate_x25519_keys, None) ] for key_type, priv_file, pub_file, gen_func, key_size in key_pairs: user_priv = os.path.join(USER_KEY_DIR, priv_file) user_pub = os.path.join(USER_KEY_DIR, pub_file) user_exists = os.path.exists(user_priv) and os.path.exists(user_pub) app_priv = os.path.join(APP_KEY_DIR, priv_file) app_pub = os.path.join(APP_KEY_DIR, pub_file) app_exists = os.path.exists(app_priv) and os.path.exists(app_pub) if DEBUG: debug_log(f"{key_type.upper()}密钥对 - 用户目录存在: {user_exists}, 程序目录存在: {app_exists}") if not user_exists: if DEBUG: debug_log(f"开始生成{key_type.upper()}密钥对到用户目录...") try: if key_size: priv, pub = gen_func(key_size) else: priv, pub = gen_func() with open(user_priv, 'wb') as f: f.write(priv) with open(user_pub, 'wb') as f: f.write(pub) try: with open(app_priv, 'wb') as f: f.write(priv) with open(app_pub, 'wb') as f: f.write(pub) if DEBUG: debug_log(f"{key_type.upper()}密钥备份到程序目录成功") except Exception as e: if DEBUG: debug_log(f"备份到程序目录失败: {e}") except Exception as e: debug_error(f"{key_type.upper()}密钥生成失败: {e}") raise elif user_exists and not app_exists: try: with open(user_priv, 'rb') as f: priv = f.read() with open(user_pub, 'rb') as f: pub = f.read() with open(app_priv, 'wb') as f: f.write(priv) with open(app_pub, 'wb') as f: f.write(pub) if DEBUG: debug_log(f"{key_type.upper()}密钥备份到程序目录成功") except Exception as e: if DEBUG: debug_log(f"备份失败: {e}") if DEBUG: debug_log("全局密钥检查/生成完成") def get_global_rsa_private(): """获取全局RSA私钥""" key_path, _ = get_key_path(KEY_FILES['rsa_private']) if not os.path.exists(key_path): ensure_global_keys() key_path, _ = get_key_path(KEY_FILES['rsa_private']) with open(key_path, 'rb') as f: return f.read() def get_global_rsa_public(): """获取全局RSA公钥""" key_path, _ = get_key_path(KEY_FILES['rsa_public']) if not os.path.exists(key_path): ensure_global_keys() key_path, _ = get_key_path(KEY_FILES['rsa_public']) with open(key_path, 'rb') as f: return f.read() def get_global_x25519_private(): """获取全局X25519私钥""" key_path, _ = get_key_path(KEY_FILES['x25519_private']) if not os.path.exists(key_path): ensure_global_keys() key_path, _ = get_key_path(KEY_FILES['x25519_private']) with open(key_path, 'rb') as f: return f.read() def get_global_x25519_public(): """获取全局X25519公钥""" key_path, _ = get_key_path(KEY_FILES['x25519_public']) if not os.path.exists(key_path): ensure_global_keys() key_path, _ = get_key_path(KEY_FILES['x25519_public']) with open(key_path, 'rb') as f: return f.read() # ==================== 加密笔记处理 ==================== class EncryptedNoteHandler: """加密笔记处理器 - 核心加密解密逻辑""" @staticmethod def check_file_has_password(file_path): """检查加密文件是否有密码保护""" try: with open(file_path, 'rb') as f: data = f.read() clean_data = remove_security_info(data) json_str = clean_data.decode('utf-8') info = json.loads(json_str) return info.get('has_password', False), info.get('mode', 'aes_rsa'), info.get('single_key', False) except Exception as e: debug_error(f"检查文件密码状态失败: {e}") return False, 'unknown', False @staticmethod def get_file_metadata(file_path): """获取加密文件的元数据（不进行解密）""" try: with open(file_path, 'rb') as f: data = f.read() clean_data = remove_security_info(data) json_str = clean_data.decode('utf-8') info = json.loads(json_str) return { 'has_password': info.get('has_password', False), 'mode': info.get('mode', 'aes_rsa'), 'single_key': info.get('single_key', False), 'algorithm': info.get('algorithm', 'unknown'), 'timestamp': info.get('timestamp', 'unknown') } except Exception as e: debug_error(f"获取文件元数据失败: {e}") return None @staticmethod def encrypt_content(content: str, algorithm: str, key_mode: str, password: str = None, single_private=None, single_public=None, strict_password=True): """ 加密内容 content: 要加密的文本内容 algorithm: 'rsa' 或 'x25519' key_mode: 'global' 或 'single' password: 用户密码（可选） single_private/single_public: 单独密钥对 strict_password: 是否使用高强度密码要求 """ if DEBUG: debug_log(f"开始加密 - 算法: {algorithm}, 密钥模式: {key_mode}, 密码保护: {password is not None}, 严格模式: {strict_password}") debug_log(f"内容长度: {len(content)} 字符") data = content.encode('utf-8') private_key = None public_key = None try: if algorithm == 'rsa': if key_mode == 'global': pub_pem = get_global_rsa_public() if password: encrypted = encrypt_text_aes_rsa_with_password(data, pub_pem, password, add_header=True, strict_password=strict_password) else: encrypted = encrypt_text_aes_rsa(data, pub_pem, add_header=True, strict_password=strict_password) private_key = None public_key = None else: if single_private is None or single_public is None: private_key, public_key = generate_rsa_key(4096) else: private_key = single_private public_key = single_public if password: encrypted = encrypt_text_aes_rsa_with_password(data, public_key, password, add_header=True, strict_password=strict_password) else: encrypted = encrypt_text_aes_rsa(data, public_key, add_header=True, strict_password=strict_password) # 添加single_key标记 json_str = remove_security_info(encrypted).decode('utf-8') info = json.loads(json_str) info['single_key'] = True encrypted = add_security_info(json.dumps(info).encode('utf-8'), 'aes_rsa', bool(password)) return encrypted, private_key, public_key else: # x25519 if key_mode == 'global': pub_raw = get_global_x25519_public() if password: encrypted = encrypt_text_aes_x25519(data, pub_raw, password, add_header=True, strict_password=strict_password) else: encrypted = encrypt_text_aes_x25519(data, pub_raw, add_header=True, strict_password=strict_password) private_key = None public_key = None else: if single_private is None or single_public is None: private_key, public_key = generate_x25519_keys() else: private_key = single_private public_key = single_public if password: encrypted = encrypt_text_aes_x25519(data, public_key, password, add_header=True, strict_password=strict_password) else: encrypted = encrypt_text_aes_x25519(data, public_key, add_header=True, strict_password=strict_password) # 添加single_key标记 json_str = remove_security_info(encrypted).decode('utf-8') info = json.loads(json_str) info['single_key'] = True encrypted = add_security_info(json.dumps(info).encode('utf-8'), 'aes_x25519', bool(password)) return encrypted, private_key, public_key return encrypted, private_key, public_key except Exception as e: debug_error(f"加密过程异常: {e}") raise Exception(f"加密失败: {str(e)}") @staticmethod def decrypt_file(file_path, password: str = None, single_private: bytes = None): """ 解密文件 file_path: 文件路径 password: 用户密码（可选） single_private: 单独私钥（可选） """ if DEBUG: debug_log(f"开始解密文件: {file_path}") debug_log(f"密码提供: {password is not None}, 单独私钥提供: {single_private is not None}") if password: debug_log(f"密码长度: {len(password)}") try: with open(file_path, 'rb') as f: data = f.read() clean_data = remove_security_info(data) json_str = clean_data.decode('utf-8') info = json.loads(json_str) mode = info.get('mode', 'aes_rsa') has_password = info.get('has_password', False) single_key = info.get('single_key', False) if DEBUG: debug_log(f"加密信息 - 模式: {mode}, 有密码: {has_password}, 单文件密钥: {single_key}") if mode in ['aes_rsa', 'aes_rsa_password_protected']: if single_key: if single_private is None: raise ValueError("单独密钥_需要选择密钥文件") priv = single_private else: priv = get_global_rsa_private() if has_password: if password is None: raise ValueError("密码保护_需要输入密码") decrypted = decrypt_text_aes_rsa_with_password(clean_data, priv, password, has_header=False) else: decrypted = decrypt_text_aes_rsa(clean_data, priv, has_header=False) elif mode in ['aes_x25519', 'aes_x25519_password_protected']: if single_key: if single_private is None: raise ValueError("单独密钥_需要选择密钥文件") priv = single_private else: priv = get_global_x25519_private() if has_password: if password is None: raise ValueError("密码保护_需要输入密码") decrypted = decrypt_text_aes_x25519(clean_data, priv, password, has_header=False) else: decrypted = decrypt_text_aes_x25519(clean_data, priv, has_header=False) else: raise ValueError(f"未知加密模式: {mode}") # 解密结果可能是 bytes 或 str，统一转为 bytes if isinstance(decrypted, str): decrypted = decrypted.encode('utf-8') if DEBUG: debug_log(f"解密成功，解密后数据大小: {len(decrypted)}字节") return decrypted except Exception as e: debug_error(f"解密过程异常: {e}") raise # ==================== 通用解密函数（修复版：支持单独密钥文件选择） ==================== def decrypt_bjb_file(file_path, parent_window, is_cloud_file=False, cloud_filename=None): """ 解密.bjb文件的通用函数 file_path: 文件路径 parent_window: 父窗口（用于弹窗） is_cloud_file: 是否为云端下载的文件 cloud_filename: 云端原始文件名（用于提示） 返回: (content, success) """ if DEBUG: debug_log(f"通用解密函数: {file_path}, 云端文件: {is_cloud_file}") display_name = cloud_filename if cloud_filename else os.path.basename(file_path) try: # 首先获取文件元数据，判断是否需要单独密钥 metadata = EncryptedNoteHandler.get_file_metadata(file_path) if metadata is None: QMessageBox.critical(parent_window, "文件错误", "无法读取文件元数据，文件可能已损坏") return None, False has_password = metadata['has_password'] single_key = metadata['single_key'] mode = metadata['mode'] if DEBUG: debug_log(f"文件元数据 - has_password: {has_password}, single_key: {single_key}, mode: {mode}") single_private = None # ========== 处理单独密钥模式 ========== if single_key: if DEBUG: debug_log("检测到单独密钥模式，需要查找或选择.key文件") # 首先尝试在相同目录下查找对应的.key文件 key_file_path = file_path + '.key' if os.path.exists(key_file_path): if DEBUG: debug_log(f"找到本地密钥文件: {key_file_path}") try: with open(key_file_path, 'rb') as f: single_private = f.read() if DEBUG: debug_log(f"密钥文件读取成功，长度: {len(single_private)}字节") except Exception as e: debug_error(f"读取密钥文件失败: {e}") QMessageBox.critical(parent_window, "读取失败", f"无法读取密钥文件: {str(e)}") return None, False else: # 没有找到，弹出文件选择对话框 if DEBUG: debug_log("未找到本地密钥文件，弹出选择对话框") # 构建提示信息 msg = f"文件「{display_name}」使用单独密钥加密（端到端加密）。\n\n" msg += "请选择对应的私钥文件(.key)：\n" msg += "提示：此文件加密时会在同目录生成同名.key文件。" if is_cloud_file: msg = f"云端文件「{display_name}」使用单独密钥加密（端到端加密）。\n\n" msg += "服务器不存储您的私钥，请选择您本地保存的对应.key文件：\n" msg += "提示：创建此文件时会在本地生成同名的.key文件。" key_file_path, ok = QFileDialog.getOpenFileName( parent_window, "选择密钥文件 - " + display_name, "", "密钥文件 (*.key);;所有文件 (*.*)" ) if not ok or not key_file_path: QMessageBox.warning(parent_window, "密钥缺失", f"无法解密「{display_name}」：缺少对应的私钥文件\n\n" "此文件是使用【安全加密】模式创建的，\n" "需要当初保存时生成的.key文件才能解密。\n" "请找到对应的.key文件后重试。") return None, False try: with open(key_file_path, 'rb') as f: single_private = f.read() if DEBUG: debug_log(f"用户选择密钥文件: {key_file_path}, 长度: {len(single_private)}字节") except Exception as e: debug_error(f"读取用户选择的密钥文件失败: {e}") QMessageBox.critical(parent_window, "读取失败", f"无法读取密钥文件: {str(e)}") return None, False # ========== 处理密码保护模式 ========== if has_password: if DEBUG: debug_log("检测到密码保护，弹出密码输入框") max_attempts = 3 attempts = 0 success = False while attempts < max_attempts and not success: pwd, ok = QInputDialog.getText( parent_window, "输入密码 - " + display_name, f"文件「{display_name}」受密码保护\n请输入密码 (尝试 {attempts + 1}/{max_attempts}):", QLineEdit.Password ) if not ok: if DEBUG: debug_log("用户取消输入密码") return None, False if pwd: try: if DEBUG: debug_log(f"尝试密码解密 (长度: {len(pwd)})") decrypted = EncryptedNoteHandler.decrypt_file( file_path, password=pwd, single_private=single_private ) if isinstance(decrypted, bytes): content = decrypted.decode('utf-8') else: content = str(decrypted) if DEBUG: debug_log("密码解密成功") return content, True except ValueError as e: error_msg = str(e) if DEBUG: debug_log(f"密码解密失败: {error_msg}") if "单独密钥" in error_msg: QMessageBox.warning(parent_window, "密钥错误", "解密失败：密钥文件不匹配\n请选择正确的.key文件") return None, False attempts += 1 if attempts < max_attempts: QMessageBox.warning(parent_window, "密码错误", f"密码错误，还剩 {max_attempts - attempts} 次尝试") else: QMessageBox.warning(parent_window, "解密失败", "多次密码错误，无法解密文件") return None, False except Exception as e: error_msg = str(e) if DEBUG: debug_log(f"解密异常: {error_msg}") attempts += 1 if attempts < max_attempts: QMessageBox.warning(parent_window, "解密失败", f"解密失败: {error_msg}\n还剩 {max_attempts - attempts} 次尝试") else: QMessageBox.warning(parent_window, "解密失败", f"多次尝试失败，无法解密文件\n错误: {error_msg}") return None, False else: attempts += 1 QMessageBox.warning(parent_window, "密码为空", "密码不能为空") return None, False else: # ========== 无密码保护，直接解密 ========== if DEBUG: debug_log("无密码保护，直接解密") try: decrypted = EncryptedNoteHandler.decrypt_file( file_path, password=None, single_private=single_private ) if isinstance(decrypted, bytes): content = decrypted.decode('utf-8') else: content = str(decrypted) return content, True except ValueError as e: error_msg = str(e) if "单独密钥" in error_msg: QMessageBox.warning(parent_window, "密钥错误", "解密失败：需要对应的.key密钥文件\n请选择正确的.key文件") else: QMessageBox.warning(parent_window, "解密失败", str(e)) return None, False except Exception as e: debug_error(f"解密失败: {e}") QMessageBox.critical(parent_window, "解密失败", str(e)) return None, False except Exception as e: debug_error(f"解密过程异常: {e}") QMessageBox.critical(parent_window, "解密失败", str(e)) return None, False # ==================== 云端API客户端 ==================== class CloudClient: """云端API客户端，处理所有网络请求""" def __init__(self): if DEBUG: debug_log("初始化CloudClient") self.token = None self.user_id = None self.username = None def set_auth(self, token, user_id, username): """设置认证信息""" if DEBUG: debug_log(f"设置认证信息 - 用户: {username}, ID: {user_id}") self.token = token self.user_id = user_id self.username = username def clear_auth(self): """清除认证信息""" if DEBUG: debug_log("清除认证信息") self.token = None self.user_id = None self.username = None def _headers(self): """获取请求头""" if self.token: return {'x-access-token': self.token} return {} def _request(self, method, endpoint, **kwargs): """发送HTTP请求""" url = f"{API_BASE_URL}{endpoint}" headers = self._headers() if 'headers' in kwargs: headers.update(kwargs.pop('headers')) try: resp = requests.request(method, url, headers=headers, timeout=30, **kwargs) if resp.status_code == 401: return None return resp except requests.exceptions.ConnectionError: QMessageBox.critical(None, "网络错误", "无法连接到服务器，请检查网络连接") return None except Exception as e: QMessageBox.critical(None, "网络错误", f"请求失败: {str(e)}") return None def register(self, username, email, password): """用户注册""" resp = self._request('POST', '/register', json={'username': username, 'email': email, 'password': password}) if resp and resp.status_code == 201: return resp.json() return None def login(self, email, password): """用户登录""" resp = self._request('POST', '/login', json={'email': email, 'password': password}) if resp and resp.status_code == 200: data = resp.json() self.set_auth(data['token'], data['user_id'], data['username']) return data return None def get_filetree(self, folder='/'): """获取文件树""" resp = self._request('GET', '/filetree', params={'folder': folder}) if resp and resp.status_code == 200: return resp.json() return None def create_folder(self, name, parent='/'): """创建文件夹""" resp = self._request('POST', '/create_folder', json={'name': name, 'parent': parent}) if resp and resp.status_code == 201: return resp.json() return None def upload_file(self, file_path, parent_folder='/'): """上传文件""" ext = os.path.splitext(file_path)[1].lower() if ext not in ['.txt', '.bjb']: QMessageBox.warning(None, "错误", "只支持上传 .txt 和 .bjb 文件") return None with open(file_path, 'rb') as f: files = {'file': (os.path.basename(file_path), f)} data = {'parent_folder': parent_folder} resp = self._request('POST', '/upload', files=files, data=data) if resp and resp.status_code == 201: return resp.json() return None def download_file(self, file_id, target_path): """下载文件""" resp = self._request('GET', f'/download/{file_id}') if resp and resp.status_code == 200: with open(target_path, 'wb') as f: f.write(resp.content) return True return False def delete_item(self, item_id): """删除文件或文件夹""" resp = self._request('DELETE', f'/delete/{item_id}') if resp: return resp.status_code == 200 return False def rename_item(self, item_id, new_name): """重命名文件或文件夹""" resp = self._request('PUT', f'/rename/{item_id}', json={'new_name': new_name}) if resp: return resp.status_code == 200 return False def move_item(self, item_id, target_folder): """移动文件或文件夹""" resp = self._request('POST', '/move', json={'item_id': item_id, 'target_folder': target_folder}) if resp: return resp.status_code == 200 return False def search_files(self, keyword): """搜索文件""" resp = self._request('GET', '/search', params={'q': keyword}) if resp and resp.status_code == 200: return resp.json() return None def get_storage_info(self): """获取存储信息""" resp = self._request('GET', '/storage_info') if resp and resp.status_code == 200: return resp.json() return None def get_user_info(self): """获取用户信息""" resp = self._request('GET', '/user_info') if resp and resp.status_code == 200: return resp.json() return None # ==================== 登录对话框 ==================== class LoginDialog(QDialog): """登录对话框""" def __init__(self, client, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化登录对话框") self.client = client self.setWindowTitle("云笔记 - 登录") self.setFixedSize(400, 350) self.setWindowFlags(Qt.FramelessWindowHint | Qt.Dialog) self.setAttribute(Qt.WA_TranslucentBackground) self.setup_ui() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) card = QWidget() card.setObjectName("card") card.setStyleSheet(""" #card { background-color: white; border-radius: 16px; } QLineEdit { border: 1px solid #e1e4e8; border-radius: 10px; padding: 12px; font-size: 14px; } QPushButton { border-radius: 10px; padding: 12px; font-size: 14px; font-weight: 500; } """) card_layout = QVBoxLayout(card) card_layout.setContentsMargins(40, 40, 40, 40) card_layout.setSpacing(20) title = QLabel("☁️ 云笔记") title.setStyleSheet("font-size: 28px; font-weight: bold;") title.setAlignment(Qt.AlignCenter) card_layout.addWidget(title) self.email_input = QLineEdit() self.email_input.setPlaceholderText("电子邮箱") self.email_input.setMinimumHeight(45) card_layout.addWidget(self.email_input) self.password_input = QLineEdit() self.password_input.setPlaceholderText("密码") self.password_input.setEchoMode(QLineEdit.Password) self.password_input.setMinimumHeight(45) card_layout.addWidget(self.password_input) self.remember_check = QCheckBox("记住我") card_layout.addWidget(self.remember_check) self.login_btn = QPushButton("登 录") self.login_btn.setMinimumHeight(45) self.login_btn.setStyleSheet("background-color: #0366d6; color: white; border: none;") self.login_btn.clicked.connect(self.do_login) card_layout.addWidget(self.login_btn) register_btn = QPushButton("还没有账号？立即注册") register_btn.setStyleSheet("background: transparent; color: #0366d6; border: none;") register_btn.clicked.connect(self.show_register) card_layout.addWidget(register_btn, alignment=Qt.AlignCenter) close_btn = QPushButton("×") close_btn.setFixedSize(30, 30) close_btn.setStyleSheet("background: transparent; border: none; font-size: 20px;") close_btn.clicked.connect(self.reject) layout.addWidget(card) close_btn.setParent(self) close_btn.move(self.width() - 40, 15) def do_login(self): """执行登录""" email = self.email_input.text().strip() password = self.password_input.text().strip() if not email or not password: QMessageBox.warning(self, "提示", "请填写邮箱和密码") return data = self.client.login(email, password) if data: if self.remember_check.isChecked(): settings = QSettings("CloudNote", "User") settings.setValue("token", self.client.token) settings.setValue("user_id", self.client.user_id) settings.setValue("username", self.client.username) self.accept() else: QMessageBox.warning(self, "错误", "邮箱或密码错误") def show_register(self): """显示注册对话框""" dialog = RegisterDialog(self.client, self) dialog.exec_() # ==================== 注册对话框 ==================== class RegisterDialog(QDialog): """注册对话框""" def __init__(self, client, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化注册对话框") self.client = client self.setWindowTitle("注册账号") self.setFixedSize(400, 450) self.setWindowFlags(Qt.FramelessWindowHint | Qt.Dialog) self.setAttribute(Qt.WA_TranslucentBackground) self.setup_ui() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) card = QWidget() card.setObjectName("card") card.setStyleSheet(""" #card { background-color: white; border-radius: 16px; } QLineEdit { border: 1px solid #e1e4e8; border-radius: 10px; padding: 12px; font-size: 14px; } QPushButton { border-radius: 10px; padding: 12px; font-size: 14px; font-weight: 500; } """) card_layout = QVBoxLayout(card) card_layout.setContentsMargins(40, 40, 40, 40) card_layout.setSpacing(15) title = QLabel("📝 创建新账号") title.setStyleSheet("font-size: 24px; font-weight: bold;") title.setAlignment(Qt.AlignCenter) card_layout.addWidget(title) self.username_input = QLineEdit() self.username_input.setPlaceholderText("用户名") self.username_input.setMinimumHeight(45) card_layout.addWidget(self.username_input) self.email_input = QLineEdit() self.email_input.setPlaceholderText("电子邮箱") self.email_input.setMinimumHeight(45) card_layout.addWidget(self.email_input) self.password_input = QLineEdit() self.password_input.setPlaceholderText("密码（至少6位）") self.password_input.setEchoMode(QLineEdit.Password) self.password_input.setMinimumHeight(45) card_layout.addWidget(self.password_input) self.confirm_input = QLineEdit() self.confirm_input.setPlaceholderText("确认密码") self.confirm_input.setEchoMode(QLineEdit.Password) self.confirm_input.setMinimumHeight(45) card_layout.addWidget(self.confirm_input) self.register_btn = QPushButton("注 册") self.register_btn.setMinimumHeight(45) self.register_btn.setStyleSheet("background-color: #0366d6; color: white; border: none;") self.register_btn.clicked.connect(self.do_register) card_layout.addWidget(self.register_btn) close_btn = QPushButton("×") close_btn.setFixedSize(30, 30) close_btn.setStyleSheet("background: transparent; border: none; font-size: 20px;") close_btn.clicked.connect(self.reject) layout.addWidget(card) close_btn.setParent(self) close_btn.move(self.width() - 40, 15) def do_register(self): """执行注册""" username = self.username_input.text().strip() email = self.email_input.text().strip() password = self.password_input.text().strip() confirm = self.confirm_input.text().strip() if not all([username, email, password]): QMessageBox.warning(self, "提示", "请填写所有字段") return if password != confirm: QMessageBox.warning(self, "错误", "两次密码不一致") return if len(password) < 6: QMessageBox.warning(self, "错误", "密码至少6位") return res = self.client.register(username, email, password) if res: QMessageBox.information(self, "成功", "注册成功，请登录") self.accept() else: QMessageBox.warning(self, "错误", "注册失败，用户名或邮箱已存在") # ==================== 新建加密文件对话框 ==================== class NewEncryptedFileDialog(QDialog): """新建加密文件配置对话框""" def __init__(self, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化新建加密文件对话框") self.setWindowTitle("新建加密笔记") self.setFixedSize(600, 700) self.selected_algorithm = 'rsa' self.selected_key_mode = 'global' self.use_password = False self.strict_password = True self.custom_password = None self.single_private = None self.single_public = None self.setup_ui() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) layout.setSpacing(15) title = QLabel("🔐 加密配置") title.setStyleSheet("font-size: 18px; font-weight: bold;") layout.addWidget(title) group1 = QGroupBox("1. 选择加密算法") group1_layout = QVBoxLayout() self.radio_rsa = QRadioButton("RSA-4096 + AES-256-GCM") self.radio_x25519 = QRadioButton("X25519 + AES-256-GCM") self.radio_rsa.setChecked(True) group1_layout.addWidget(self.radio_rsa) group1_layout.addWidget(self.radio_x25519) group1.setLayout(group1_layout) layout.addWidget(group1) group2 = QGroupBox("2. 选择密钥方式") group2_layout = QVBoxLayout() self.radio_global = QRadioButton("默认加密（使用全局密钥对）") self.radio_single = QRadioButton("安全加密（为当前文件单独生成密钥对）") self.radio_global.setChecked(True) group2_layout.addWidget(self.radio_global) group2_layout.addWidget(self.radio_single) group2.setLayout(group2_layout) layout.addWidget(group2) group3 = QGroupBox("3. 额外密码保护") group3_layout = QVBoxLayout() strength_layout = QHBoxLayout() strength_layout.addWidget(QLabel("密码强度要求:")) self.radio_strict = QRadioButton("高强度 (推荐)") self.radio_weak = QRadioButton("低强度 (不推荐)") self.radio_strict.setChecked(True) strength_layout.addWidget(self.radio_strict) strength_layout.addWidget(self.radio_weak) group3_layout.addLayout(strength_layout) self.checkbox_password = QCheckBox("启用双层加密") self.checkbox_password.toggled.connect(self.on_password_toggled) group3_layout.addWidget(self.checkbox_password) self.password_input = QLineEdit() self.password_input.setPlaceholderText("请输入密码（至少16位，包含大小写字母、数字和特殊字符）") self.password_input.setEchoMode(QLineEdit.Password) self.password_input.setEnabled(False) group3_layout.addWidget(self.password_input) self.confirm_input = QLineEdit() self.confirm_input.setPlaceholderText("确认密码") self.confirm_input.setEchoMode(QLineEdit.Password) self.confirm_input.setEnabled(False) group3_layout.addWidget(self.confirm_input) self.password_strength_label = QLabel("") self.password_strength_label.setStyleSheet("font-size: 12px;") group3_layout.addWidget(self.password_strength_label) self.password_input.textChanged.connect(self.check_password_strength) self.radio_strict.toggled.connect(self.on_strength_mode_changed) self.radio_weak.toggled.connect(self.on_strength_mode_changed) group3.setLayout(group3_layout) layout.addWidget(group3) info_label = QLabel("说明：\n• 默认加密：使用全局密钥对，所有文件共用同一密钥\n• 安全加密：每个文件独立生成密钥对，私钥保存为 .key 文件\n• 密钥文件请妥善保管，丢失后将无法解密文件！\n• 高强度密码要求≥16位含大小写+数字+特殊字符\n• 低强度模式仅用于测试，不推荐用于重要数据") info_label.setStyleSheet("color: #586069; font-size: 12px; background-color: #f6f8fa; padding: 10px; border-radius: 8px;") info_label.setWordWrap(True) layout.addWidget(info_label) btn_layout = QHBoxLayout() self.ok_btn = QPushButton("确定") self.cancel_btn = QPushButton("取消") self.ok_btn.clicked.connect(self.accept_config) self.cancel_btn.clicked.connect(self.reject) btn_layout.addWidget(self.ok_btn) btn_layout.addWidget(self.cancel_btn) layout.addLayout(btn_layout) def on_strength_mode_changed(self): """密码强度模式改变""" self.strict_password = self.radio_strict.isChecked() if self.radio_strict.isChecked(): self.password_input.setPlaceholderText("请输入密码（至少16位，包含大小写字母、数字和特殊字符）") else: self.password_input.setPlaceholderText("请输入密码（无强度限制，但强烈建议使用强密码）") self.check_password_strength() def on_password_toggled(self, checked): """密码开关切换""" self.password_input.setEnabled(checked) self.confirm_input.setEnabled(checked) self.use_password = checked if checked: self.check_password_strength() else: self.password_strength_label.setText("") def check_password_strength(self): """检查密码强度""" if not self.use_password: self.password_strength_label.setText("") return pwd = self.password_input.text() if self.radio_strict.isChecked(): if len(pwd) >= 16 and any(c.isupper() for c in pwd) and any(c.islower() for c in pwd) and any(c.isdigit() for c in pwd) and any(not c.isalnum() for c in pwd): self.password_strength_label.setText("✓ 密码强度：强") self.password_strength_label.setStyleSheet("color: green; font-size: 12px;") elif len(pwd) >= 12: self.password_strength_label.setText("⚠ 密码强度：中（建议至少16位，包含大小写+数字+特殊字符）") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") else: self.password_strength_label.setText("✗ 密码强度：弱（需要至少16位，包含大小写+数字+特殊字符）") self.password_strength_label.setStyleSheet("color: red; font-size: 12px;") else: if len(pwd) >= 8: self.password_strength_label.setText("✓ 密码已输入（低强度模式，建议使用高强度）") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") elif len(pwd) > 0: self.password_strength_label.setText("⚠ 密码太短（建议至少8位）") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") else: self.password_strength_label.setText("请输入密码") self.password_strength_label.setStyleSheet("color: gray; font-size: 12px;") def accept_config(self): """接受配置""" if DEBUG: debug_log("开始获取加密配置") if self.radio_rsa.isChecked(): self.selected_algorithm = 'rsa' else: self.selected_algorithm = 'x25519' if DEBUG: debug_log(f"算法: {self.selected_algorithm}") if self.radio_global.isChecked(): self.selected_key_mode = 'global' else: self.selected_key_mode = 'single' if DEBUG: debug_log(f"密钥模式: {self.selected_key_mode}") self.strict_password = self.radio_strict.isChecked() if DEBUG: debug_log(f"密码强度模式: {'高强度' if self.strict_password else '低强度'}") if self.use_password: pwd = self.password_input.text() confirm = self.confirm_input.text() if not pwd or not confirm: QMessageBox.warning(self, "提示", "请输入密码") return if pwd != confirm: QMessageBox.warning(self, "错误", "两次输入的密码不一致") return if self.strict_password and not is_password_strong(pwd, strict=True): QMessageBox.warning(self, "密码强度不足", "密码必须至少16位，包含大小写字母、数字和特殊字符\n\n" "或切换到「低强度」模式（不推荐）") return self.custom_password = pwd if DEBUG: debug_log("密码验证通过") if self.selected_key_mode == 'single': if DEBUG: debug_log("生成单独密钥对") if self.selected_algorithm == 'rsa': self.single_private, self.single_public = generate_rsa_key(4096) else: self.single_private, self.single_public = generate_x25519_keys() if DEBUG: debug_log("加密配置获取完成") self.accept() def get_config(self): """获取配置""" return { 'algorithm': self.selected_algorithm, 'key_mode': self.selected_key_mode, 'use_password': self.use_password, 'strict_password': self.strict_password, 'custom_password': self.custom_password, 'single_private': self.single_private, 'single_public': self.single_public } # ==================== 保存加密文件对话框 ==================== class SaveEncryptedFileDialog(QDialog): """保存加密文件对话框""" def __init__(self, content, algorithm, key_mode, use_password, strict_password, custom_password, single_private, single_public, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化保存加密文件对话框") self.content = content self.algorithm = algorithm self.key_mode = key_mode self.use_password = use_password self.strict_password = strict_password self.custom_password = custom_password self.single_private = single_private self.single_public = single_public self.setWindowTitle("保存加密笔记") self.setFixedSize(650, 400) self.selected_file_path = None self.setup_ui() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) layout.setSpacing(15) if self.key_mode == 'single': info_label = QLabel("⚠️ 您选择了【安全加密】模式，将为当前文件单独生成密钥对。\n密钥文件(.key)将与.bjb文件保存在同一目录，请妥善保管！\n丢失密钥文件后将无法解密！") info_label.setStyleSheet("color: #e36209; background-color: #fff5eb; padding: 10px; border-radius: 8px;") info_label.setWordWrap(True) layout.addWidget(info_label) layout.addWidget(QLabel("📁 保存位置和文件名：")) file_select_layout = QHBoxLayout() self.file_path_input = QLineEdit() self.file_path_input.setPlaceholderText("请选择保存位置...") self.file_path_input.setMinimumHeight(35) self.file_path_input.textChanged.connect(self.on_path_changed) file_select_layout.addWidget(self.file_path_input) self.browse_btn = QPushButton("浏览...") self.browse_btn.clicked.connect(self.select_save_file) file_select_layout.addWidget(self.browse_btn) layout.addLayout(file_select_layout) info_group = QGroupBox("加密信息摘要") info_layout = QVBoxLayout() algo_text = "RSA-4096" if self.algorithm == 'rsa' else "X25519" key_text = "全局密钥" if self.key_mode == 'global' else "单独密钥(安全模式)" pwd_text = "已启用" if self.use_password else "未启用" strength_text = "高强度" if self.strict_password else "低强度" info_layout.addWidget(QLabel(f"🔐 加密算法: {algo_text} + AES-256-GCM")) info_layout.addWidget(QLabel(f"🔑 密钥方式: {key_text}")) info_layout.addWidget(QLabel(f"🔒 密码保护: {pwd_text}")) if self.use_password: info_layout.addWidget(QLabel(f"🔐 密码强度: {strength_text}")) info_group.setLayout(info_layout) layout.addWidget(info_group) btn_layout = QHBoxLayout() self.ok_btn = QPushButton("💾 保存") self.ok_btn.setStyleSheet("background-color: #28a745; color: white;") self.cancel_btn = QPushButton("取消") self.ok_btn.clicked.connect(self.do_save) self.cancel_btn.clicked.connect(self.reject) btn_layout.addWidget(self.ok_btn) btn_layout.addWidget(self.cancel_btn) layout.addLayout(btn_layout) def on_path_changed(self, text): """路径改变""" if text.strip(): self.selected_file_path = text.strip() def select_save_file(self): """选择保存文件""" file_path, _ = QFileDialog.getSaveFileName(self, "保存加密笔记", "", "加密笔记 (*.bjb)") if file_path: if not file_path.endswith('.bjb'): file_path += '.bjb' self.selected_file_path = file_path self.file_path_input.setText(file_path) def do_save(self): """执行保存""" if not self.selected_file_path: QMessageBox.warning(self, "提示", "请选择保存位置") return if not self.selected_file_path.endswith('.bjb'): self.selected_file_path += '.bjb' try: encrypted_data, priv, pub = EncryptedNoteHandler.encrypt_content( self.content, self.algorithm, self.key_mode, self.custom_password, self.single_private, self.single_public, strict_password=self.strict_password ) except Exception as e: QMessageBox.critical(self, "加密失败", str(e)) return try: with open(self.selected_file_path, 'wb') as f: f.write(encrypted_data) except Exception as e: QMessageBox.critical(self, "保存失败", f"无法保存.bjb文件: {str(e)}") return key_path = None if self.key_mode == 'single' and priv: key_path = self.selected_file_path + '.key' try: with open(key_path, 'wb') as f: f.write(priv) except Exception as e: QMessageBox.critical(self, "保存失败", f"无法保存.key文件: {str(e)}") return msg = f"✅ 文件已保存！\n\n📄 .bjb文件：{self.selected_file_path}" if key_path: msg += f"\n🔑 .key文件：{key_path}\n\n⚠️ 请妥善保管密钥文件！" else: msg += "\n\n💡 提示：使用全局密钥，无需额外保存密钥文件。" QMessageBox.information(self, "保存成功", msg) self.accept() # ==================== 云端文件树窗口 ==================== class CloudFileTreeDialog(QDialog): """云端文件管理对话框""" def __init__(self, client, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化云端文件树对话框") self.client = client self.setWindowTitle("云端文件管理") self.resize(900, 700) self.setup_ui() self.current_folder = '/' self.load_filetree() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) toolbar = QToolBar() self.up_btn = QAction("⬆ 返回上级", self) self.up_btn.triggered.connect(self.go_up) toolbar.addAction(self.up_btn) self.refresh_btn = QAction("🔄 刷新", self) self.refresh_btn.triggered.connect(self.load_filetree) toolbar.addAction(self.refresh_btn) self.new_folder_btn = QAction("📁 新建文件夹", self) self.new_folder_btn.triggered.connect(self.create_folder) toolbar.addAction(self.new_folder_btn) self.upload_btn = QAction("📤 上传文件", self) self.upload_btn.triggered.connect(self.upload_file) toolbar.addAction(self.upload_btn) layout.addWidget(toolbar) search_layout = QHBoxLayout() self.search_input = QLineEdit() self.search_input.setPlaceholderText("搜索文件...") self.search_input.returnPressed.connect(self.search_files) search_btn = QPushButton("搜索") search_btn.clicked.connect(self.search_files) clear_btn = QPushButton("清除") clear_btn.clicked.connect(self.clear_search) search_layout.addWidget(self.search_input) search_layout.addWidget(search_btn) search_layout.addWidget(clear_btn) layout.addLayout(search_layout) self.tree = QTreeWidget() self.tree.setHeaderLabels(["名称", "大小", "类型", "修改时间"]) self.tree.setAlternatingRowColors(True) self.tree.setContextMenuPolicy(Qt.CustomContextMenu) self.tree.customContextMenuRequested.connect(self.show_context_menu) self.tree.itemDoubleClicked.connect(self.on_item_double_click) layout.addWidget(self.tree) self.status_label = QLabel("") layout.addWidget(self.status_label) self.load_storage_info() def load_storage_info(self): """加载存储信息""" info = self.client.get_storage_info() if info: used_mb = info['total_size'] / (1024 * 1024) max_mb = info['max_size'] / (1024 * 1024) download_used_mb = info['download_used'] / (1024 * 1024) download_max_mb = info['download_max'] / (1024 * 1024) self.status_label.setText(f"存储: {used_mb:.1f}MB / {max_mb:.0f}MB | 今日下载: {download_used_mb:.1f}MB / {download_max_mb:.0f}MB") def load_filetree(self): """加载文件树""" if DEBUG: debug_log(f"加载文件树: {self.current_folder}") data = self.client.get_filetree(self.current_folder) if not data: QMessageBox.warning(self, "错误", "加载文件树失败") return self.tree.clear() for item in data['items']: size_str = self.format_size(item['size']) if item['size'] else "" type_str = "文件夹" if item['is_folder'] else (item['type'] or "文件") tree_item = QTreeWidgetItem([item['name'], size_str, type_str, item['created_at']]) tree_item.setData(0, Qt.UserRole, item) self.tree.addTopLevelItem(tree_item) self.load_storage_info() def format_size(self, size_bytes): """格式化文件大小""" if not size_bytes: return "" for unit in ['B', 'KB', 'MB', 'GB']: if size_bytes < 1024.0: return f"{size_bytes:.1f}{unit}" size_bytes /= 1024.0 return f"{size_bytes:.1f}TB" def go_up(self): """返回上级目录""" if self.current_folder != '/': parts = self.current_folder.rstrip('/').split('/') if len(parts) > 1: self.current_folder = '/' + '/'.join(parts[:-1]) else: self.current_folder = '/' self.load_filetree() def create_folder(self): """创建文件夹""" name, ok = QInputDialog.getText(self, "新建文件夹", "请输入文件夹名称:") if ok and name: if '/' in name or '\\' in name: QMessageBox.warning(self, "错误", "文件夹名称不能包含路径分隔符") return res = self.client.create_folder(name, self.current_folder) if res: self.load_filetree() else: QMessageBox.warning(self, "错误", "创建失败") def upload_file(self): """上传文件""" file_path, _ = QFileDialog.getOpenFileName(self, "选择要上传的文件", "", "笔记本文件 (*.bjb *.txt)") if file_path: ext = os.path.splitext(file_path)[1].lower() if ext not in ['.txt', '.bjb']: QMessageBox.warning(self, "错误", "只支持上传 .txt 和 .bjb 文件") return file_size = os.path.getsize(file_path) info = self.client.get_storage_info() if info and info['total_size'] + file_size > info['max_size']: QMessageBox.warning(self, "错误", "云端存储空间不足") return res = self.client.upload_file(file_path, self.current_folder) if res: QMessageBox.information(self, "成功", "上传成功") self.load_filetree() else: QMessageBox.warning(self, "错误", "上传失败") def search_files(self): """搜索文件""" keyword = self.search_input.text().strip() if not keyword: return data = self.client.search_files(keyword) if data: self.tree.clear() for item in data['items']: size_str = self.format_size(item['size']) if item['size'] else "" type_str = "文件夹" if item['is_folder'] else (item['type'] or "文件") tree_item = QTreeWidgetItem([item['name'], size_str, type_str, ""]) tree_item.setData(0, Qt.UserRole, item) self.tree.addTopLevelItem(tree_item) self.status_label.setText(f"搜索到 {len(data['items'])} 个结果") def clear_search(self): """清除搜索""" self.search_input.clear() self.load_filetree() def on_item_double_click(self, item, col): """双击项目""" data = item.data(0, Qt.UserRole) if data['is_folder']: if self.search_input.text(): self.clear_search() self.current_folder = data['parent'] + '/' + data['name'] if data['parent'] != '/' else '/' + data['name'] self.load_filetree() else: self.download_and_open(data) def download_and_open(self, file_info): """ 下载并打开云端文件 修复：支持单独密钥模式，弹出文件选择对话框让用户选择.key文件 """ temp_dir = tempfile.gettempdir() local_path = os.path.join(temp_dir, f"cloud_{file_info['id']}_{file_info['name']}") if DEBUG: debug_log(f"下载文件到: {local_path}") debug_log(f"文件信息: ID={file_info['id']}, Name={file_info['name']}, Type={file_info.get('type', 'unknown')}") if self.client.download_file(file_info['id'], local_path): if DEBUG: debug_log("下载成功") ext = os.path.splitext(file_info['name'])[1].lower() if ext == '.txt': # 文本文件直接打开 try: with open(local_path, 'r', encoding='utf-8') as f: content = f.read() main_window = self.parent() if isinstance(main_window, MainWindow): tab = EditorTab(main_window.tabs, main_window.tabs.count(), file_path=local_path, cloud_id=file_info['id'], file_type='txt', content=content) main_window.tabs.addTab(tab.text_edit, os.path.basename(file_info['name'])) main_window.editor_tabs.append(tab) main_window.tabs.setCurrentIndex(main_window.tabs.count() - 1) self.accept() except Exception as e: debug_error(f"读取文本文件失败: {e}") QMessageBox.warning(self, "错误", f"读取文件失败: {str(e)}") else: # 加密文件：使用修复后的解密函数，传入云端文件标志和文件名 if DEBUG: debug_log("调用解密函数（云端文件模式）") # 先获取文件元数据，看看是否需要单独密钥 metadata = EncryptedNoteHandler.get_file_metadata(local_path) if metadata and metadata.get('single_key', False): if DEBUG: debug_log("检测到单独密钥模式，准备弹出密钥文件选择对话框") content, success = decrypt_bjb_file( local_path, self, is_cloud_file=True, cloud_filename=file_info['name'] ) if success and content is not None: if DEBUG: debug_log("解密成功，创建编辑器选项卡") main_window = self.parent() if isinstance(main_window, MainWindow): tab = EditorTab(main_window.tabs, main_window.tabs.count(), file_path=local_path, cloud_id=file_info['id'], file_type='bjb', content=content) main_window.tabs.addTab(tab.text_edit, os.path.basename(file_info['name'])) main_window.editor_tabs.append(tab) main_window.tabs.setCurrentIndex(main_window.tabs.count() - 1) self.accept() else: if DEBUG: debug_log(f"警告: parent 不是 MainWindow 类型: {type(main_window)}") else: if DEBUG: debug_log("解密失败，不关闭对话框") # 解密失败时不关闭对话框，让用户重试 else: if DEBUG: debug_log("下载失败") QMessageBox.warning(self, "错误", "下载失败") def show_context_menu(self, pos): """显示右键菜单""" item = self.tree.itemAt(pos) if not item: return data = item.data(0, Qt.UserRole) menu = QMenu() rename_action = menu.addAction("重命名") delete_action = menu.addAction("删除") move_action = menu.addAction("移动") download_action = menu.addAction("下载") action = menu.exec_(self.tree.viewport().mapToGlobal(pos)) if action == rename_action: new_name, ok = QInputDialog.getText(self, "重命名", "新名称:", text=data['name']) if ok and new_name: if self.client.rename_item(data['id'], new_name): self.load_filetree() else: QMessageBox.warning(self, "错误", "重命名失败") elif action == delete_action: if QMessageBox.question(self, "确认", f"确定删除 {data['name']} 吗？") == QMessageBox.Yes: if self.client.delete_item(data['id']): self.load_filetree() else: QMessageBox.warning(self, "错误", "删除失败") elif action == move_action: target, ok = QInputDialog.getText(self, "移动", "目标文件夹路径 (例如 /folder):") if ok and target: if self.client.move_item(data['id'], target): self.load_filetree() else: QMessageBox.warning(self, "错误", "移动失败") elif action == download_action: save_path, _ = QFileDialog.getSaveFileName(self, "保存文件", data['name']) if save_path: if self.client.download_file(data['id'], save_path): QMessageBox.information(self, "成功", "下载完成") else: QMessageBox.warning(self, "错误", "下载失败") # ==================== 编辑器选项卡 ==================== class EditorTab: """编辑器选项卡类""" def __init__(self, tab_widget, index, file_path=None, cloud_id=None, is_new=False, content="", file_type="txt", encrypt_config=None): if DEBUG: debug_log(f"创建编辑器选项卡 - 类型: {file_type}, 新文件: {is_new}, 路径: {file_path}") self.tab_widget = tab_widget self.index = index self.file_path = file_path self.cloud_id = cloud_id self.is_new = is_new self.file_type = file_type self.encrypt_config = encrypt_config self.modified = False self.text_edit = QTextEdit() self.text_edit.setPlainText(content) self.text_edit.textChanged.connect(self.on_text_changed) font = QFont("Consolas", 12) self.text_edit.setFont(font) self.update_tab_title() def update_tab_title(self): """更新选项卡标题""" if self.file_path: name = os.path.basename(self.file_path) elif self.cloud_id is not None: name = f"云端文件_{self.cloud_id}" else: name = "未命名" if self.file_type == 'bjb': name = f"🔒 {name}" if self.modified: name = "* " + name self.tab_widget.setTabText(self.index, name) def on_text_changed(self): """文本改变时的回调""" if not self.modified: self.modified = True self.update_tab_title() def get_content(self): """获取内容""" return self.text_edit.toPlainText() def set_content(self, content): """设置内容""" self.text_edit.setPlainText(content) self.modified = False self.update_tab_title() def mark_saved(self): """标记已保存""" self.modified = False self.update_tab_title() # ==================== 加密当前文件对话框 ==================== class EncryptCurrentFileDialog(QDialog): """加密当前文件对话框""" def __init__(self, parent=None): super().__init__(parent) if DEBUG: debug_log("初始化加密当前文件对话框") self.setWindowTitle("加密当前文件") self.setFixedSize(600, 600) self.selected_algorithm = 'rsa' self.selected_key_mode = 'global' self.use_password = False self.strict_password = True self.custom_password = None self.single_private = None self.single_public = None self.setup_ui() def setup_ui(self): """设置UI""" layout = QVBoxLayout(self) layout.setSpacing(15) title = QLabel("🔐 加密当前文件配置") title.setStyleSheet("font-size: 18px; font-weight: bold;") layout.addWidget(title) info_label = QLabel("⚠️ 注意：加密后将生成新的.bjb文件，原文件不会被删除") info_label.setStyleSheet("color: #e36209; background-color: #fff5eb; padding: 8px; border-radius: 8px;") layout.addWidget(info_label) group1 = QGroupBox("1. 选择加密算法") group1_layout = QVBoxLayout() self.radio_rsa = QRadioButton("RSA-4096 + AES-256-GCM") self.radio_x25519 = QRadioButton("X25519 + AES-256-GCM") self.radio_rsa.setChecked(True) group1_layout.addWidget(self.radio_rsa) group1_layout.addWidget(self.radio_x25519) group1.setLayout(group1_layout) layout.addWidget(group1) group2 = QGroupBox("2. 选择密钥方式") group2_layout = QVBoxLayout() self.radio_global = QRadioButton("默认加密（使用全局密钥对）") self.radio_single = QRadioButton("安全加密（为当前文件单独生成密钥对）") self.radio_global.setChecked(True) group2_layout.addWidget(self.radio_global) group2_layout.addWidget(self.radio_single) group2.setLayout(group2_layout) layout.addWidget(group2) group3 = QGroupBox("3. 额外密码保护") group3_layout = QVBoxLayout() strength_layout = QHBoxLayout() strength_layout.addWidget(QLabel("密码强度要求:")) self.radio_strict = QRadioButton("高强度 (推荐)") self.radio_weak = QRadioButton("低强度 (不推荐)") self.radio_strict.setChecked(True) strength_layout.addWidget(self.radio_strict) strength_layout.addWidget(self.radio_weak) group3_layout.addLayout(strength_layout) self.checkbox_password = QCheckBox("启用双层加密") self.checkbox_password.toggled.connect(self.on_password_toggled) group3_layout.addWidget(self.checkbox_password) self.password_input = QLineEdit() self.password_input.setPlaceholderText("请输入密码（至少16位，包含大小写字母、数字和特殊字符）") self.password_input.setEchoMode(QLineEdit.Password) self.password_input.setEnabled(False) group3_layout.addWidget(self.password_input) self.confirm_input = QLineEdit() self.confirm_input.setPlaceholderText("确认密码") self.confirm_input.setEchoMode(QLineEdit.Password) self.confirm_input.setEnabled(False) group3_layout.addWidget(self.confirm_input) self.password_strength_label = QLabel("") self.password_strength_label.setStyleSheet("font-size: 12px;") group3_layout.addWidget(self.password_strength_label) self.password_input.textChanged.connect(self.check_password_strength) self.radio_strict.toggled.connect(self.on_strength_mode_changed) group3.setLayout(group3_layout) layout.addWidget(group3) btn_layout = QHBoxLayout() self.ok_btn = QPushButton("加密并保存") self.ok_btn.setStyleSheet("background-color: #28a745; color: white;") self.cancel_btn = QPushButton("取消") self.ok_btn.clicked.connect(self.accept_config) self.cancel_btn.clicked.connect(self.reject) btn_layout.addWidget(self.ok_btn) btn_layout.addWidget(self.cancel_btn) layout.addLayout(btn_layout) def on_strength_mode_changed(self): """密码强度模式改变""" self.strict_password = self.radio_strict.isChecked() if self.radio_strict.isChecked(): self.password_input.setPlaceholderText("请输入密码（至少16位，包含大小写字母、数字和特殊字符）") else: self.password_input.setPlaceholderText("请输入密码（无强度限制，但强烈建议使用强密码）") self.check_password_strength() def on_password_toggled(self, checked): """密码开关切换""" self.password_input.setEnabled(checked) self.confirm_input.setEnabled(checked) self.use_password = checked if checked: self.check_password_strength() else: self.password_strength_label.setText("") def check_password_strength(self): """检查密码强度""" if not self.use_password: self.password_strength_label.setText("") return pwd = self.password_input.text() if self.radio_strict.isChecked(): if len(pwd) >= 16 and any(c.isupper() for c in pwd) and any(c.islower() for c in pwd) and any(c.isdigit() for c in pwd) and any(not c.isalnum() for c in pwd): self.password_strength_label.setText("✓ 密码强度：强") self.password_strength_label.setStyleSheet("color: green; font-size: 12px;") elif len(pwd) >= 12: self.password_strength_label.setText("⚠ 密码强度：中（建议至少16位）") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") else: self.password_strength_label.setText("✗ 密码强度：弱（需要至少16位）") self.password_strength_label.setStyleSheet("color: red; font-size: 12px;") else: if len(pwd) >= 8: self.password_strength_label.setText("✓ 密码已输入（低强度模式）") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") elif len(pwd) > 0: self.password_strength_label.setText("⚠ 密码太短") self.password_strength_label.setStyleSheet("color: orange; font-size: 12px;") else: self.password_strength_label.setText("请输入密码") self.password_strength_label.setStyleSheet("color: gray; font-size: 12px;") def accept_config(self): """接受配置""" if DEBUG: debug_log("开始获取加密配置") if self.radio_rsa.isChecked(): self.selected_algorithm = 'rsa' else: self.selected_algorithm = 'x25519' if DEBUG: debug_log(f"算法: {self.selected_algorithm}") if self.radio_global.isChecked(): self.selected_key_mode = 'global' else: self.selected_key_mode = 'single' if DEBUG: debug_log(f"密钥模式: {self.selected_key_mode}") self.strict_password = self.radio_strict.isChecked() if DEBUG: debug_log(f"密码强度模式: {'高强度' if self.strict_password else '低强度'}") if self.use_password: pwd = self.password_input.text() confirm = self.confirm_input.text() if not pwd or not confirm: QMessageBox.warning(self, "提示", "请输入密码") return if pwd != confirm: QMessageBox.warning(self, "错误", "两次输入的密码不一致") return if self.strict_password and not is_password_strong(pwd, strict=True): QMessageBox.warning(self, "密码强度不足", "密码必须至少16位，包含大小写字母、数字和特殊字符\n\n" "或切换到「低强度」模式（不推荐）") return self.custom_password = pwd if DEBUG: debug_log("密码验证通过") if self.selected_key_mode == 'single': if DEBUG: debug_log("生成单独密钥对") if self.selected_algorithm == 'rsa': self.single_private, self.single_public = generate_rsa_key(4096) else: self.single_private, self.single_public = generate_x25519_keys() if DEBUG: debug_log("加密配置获取完成") self.accept() def get_config(self): """获取配置""" return { 'algorithm': self.selected_algorithm, 'key_mode': self.selected_key_mode, 'use_password': self.use_password, 'strict_password': self.strict_password, 'custom_password': self.custom_password, 'single_private': self.single_private, 'single_public': self.single_public } # ==================== 主窗口 ==================== class MainWindow(QMainWindow): """主窗口类""" def __init__(self): super().__init__() if DEBUG: debug_log("初始化主窗口") self.client = CloudClient() self.tabs = QTabWidget() self.tabs.setTabsClosable(True) self.tabs.tabCloseRequested.connect(self.close_tab) self.tabs.currentChanged.connect(self.on_tab_changed) self.setCentralWidget(self.tabs) self.setWindowTitle(f"云笔记 - 安全加密笔记") self.resize(1200, 800) self.setup_menu() self.setup_statusbar() self.editor_tabs = [] self.pending_encrypt_config = None self.current_editor = None ensure_global_keys() self.check_login() def setup_menu(self): """设置菜单栏""" menubar = self.menuBar() file_menu = menubar.addMenu("文件") new_txt_action = QAction("新建文本文件(.txt)", self) new_txt_action.setShortcut(QKeySequence("Ctrl+N")) new_txt_action.triggered.connect(lambda: self.new_file('txt')) file_menu.addAction(new_txt_action) new_bjb_action = QAction("新建加密笔记(.bjb)...", self) new_bjb_action.setShortcut(QKeySequence("Ctrl+Shift+N")) new_bjb_action.triggered.connect(lambda: self.new_file('bjb')) file_menu.addAction(new_bjb_action) file_menu.addSeparator() open_action = QAction("打开文件...", self) open_action.setShortcut(QKeySequence.Open) open_action.triggered.connect(self.open_local_file_dialog) file_menu.addAction(open_action) open_cloud_action = QAction("从云端打开...", self) open_cloud_action.setShortcut(QKeySequence("Ctrl+Shift+O")) open_cloud_action.triggered.connect(self.open_cloud_file_dialog) file_menu.addAction(open_cloud_action) file_menu.addSeparator() save_action = QAction("保存", self) save_action.setShortcut(QKeySequence.Save) save_action.triggered.connect(self.save_current_tab) file_menu.addAction(save_action) save_as_action = QAction("另存为...", self) save_as_action.setShortcut(QKeySequence.SaveAs) save_as_action.triggered.connect(self.save_as_current_tab) file_menu.addAction(save_as_action) file_menu.addSeparator() exit_action = QAction("退出", self) exit_action.setShortcut(QKeySequence.Quit) exit_action.triggered.connect(self.close) file_menu.addAction(exit_action) # 加密菜单 encrypt_menu = menubar.addMenu("加密") encrypt_current_action = QAction("🔐 加密当前文件...", self) encrypt_current_action.setShortcut(QKeySequence("Ctrl+E")) encrypt_current_action.triggered.connect(self.encrypt_current_file) encrypt_menu.addAction(encrypt_current_action) encrypt_menu.addSeparator() txt_to_bjb_action = QAction("📄 另存为加密笔记(.bjb)...", self) txt_to_bjb_action.setShortcut(QKeySequence("Ctrl+Shift+S")) txt_to_bjb_action.triggered.connect(self.convert_txt_to_bjb) encrypt_menu.addAction(txt_to_bjb_action) cloud_menu = menubar.addMenu("云端") manage_cloud_action = QAction("管理云端文件", self) manage_cloud_action.triggered.connect(self.show_cloud_manager) cloud_menu.addAction(manage_cloud_action) upload_action = QAction("上传当前文件到云端", self) upload_action.triggered.connect(self.upload_current_tab) cloud_menu.addAction(upload_action) cloud_menu.addSeparator() logout_action = QAction("退出登录", self) logout_action.triggered.connect(self.logout) cloud_menu.addAction(logout_action) help_menu = menubar.addMenu("帮助") about_action = QAction("关于", self) about_action.triggered.connect(self.about) help_menu.addAction(about_action) def setup_statusbar(self): """设置状态栏""" self.status_bar = QStatusBar() self.setStatusBar(self.status_bar) self.storage_label = QLabel("") self.status_bar.addPermanentWidget(self.storage_label) self.update_storage_info() def update_storage_info(self): """更新存储信息""" if self.client.token: info = self.client.get_storage_info() if info: used_mb = info['total_size'] / (1024 * 1024) max_mb = info['max_size'] / (1024 * 1024) self.storage_label.setText(f"📁 {used_mb:.1f}MB / {max_mb:.0f}MB") def check_login(self): """检查登录状态""" settings = QSettings("CloudNote", "User") token = settings.value("token") user_id = settings.value("user_id") username = settings.value("username") if token and user_id and username: self.client.set_auth(token, int(user_id), username) user_info = self.client.get_user_info() if user_info: self.status_bar.showMessage(f"欢迎回来，{username}") self.update_storage_info() return else: settings.clear() self.client.clear_auth() dialog = LoginDialog(self.client, self) if dialog.exec_() == QDialog.Accepted: self.status_bar.showMessage(f"欢迎 {self.client.username}") self.update_storage_info() else: sys.exit(0) def logout(self): """退出登录""" self.client.clear_auth() settings = QSettings("CloudNote", "User") settings.clear() self.status_bar.showMessage("已退出登录") while self.tabs.count() > 0: self.close_tab(0) self.check_login() def new_file(self, file_type): """新建文件""" if DEBUG: debug_log(f"新建文件: {file_type}") if file_type == 'txt': tab = EditorTab(self.tabs, self.tabs.count(), file_type='txt', is_new=True, content="") self.tabs.addTab(tab.text_edit, "未命名") self.editor_tabs.append(tab) self.tabs.setCurrentIndex(self.tabs.count() - 1) else: # 先创建选项卡，再显示配置对话框 tab = EditorTab(self.tabs, self.tabs.count(), file_type='bjb', is_new=True, content="") self.tabs.addTab(tab.text_edit, "未命名加密笔记") self.editor_tabs.append(tab) self.tabs.setCurrentIndex(self.tabs.count() - 1) dialog = NewEncryptedFileDialog(self) if dialog.exec_() == QDialog.Accepted: config = dialog.get_config() tab.encrypt_config = config self.save_as_current_tab() else: self.close_tab(self.tabs.currentIndex()) def open_local_file_dialog(self): """打开本地文件对话框""" if DEBUG: debug_log("打开本地文件对话框") file_path, _ = QFileDialog.getOpenFileName( self, "打开文件", "", "笔记本文件 (*.bjb *.txt)" ) if file_path: if DEBUG: debug_log(f"用户选择文件: {file_path}") self.open_local_file(file_path) def open_local_file(self, file_path, cloud_id=None): """ 打开本地文件 修复：使用修复后的解密函数，支持单独密钥模式 """ ext = os.path.splitext(file_path)[1].lower() if DEBUG: debug_log(f"打开本地文件: {file_path}, 类型: {ext}") if ext == '.txt': try: with open(file_path, 'r', encoding='utf-8') as f: content = f.read() tab = EditorTab(self.tabs, self.tabs.count(), file_path=file_path, cloud_id=cloud_id, file_type='txt', content=content) self.tabs.addTab(tab.text_edit, os.path.basename(file_path)) self.editor_tabs.append(tab) self.tabs.setCurrentIndex(self.tabs.count() - 1) except Exception as e: debug_error(f"读取文件失败: {e}") QMessageBox.critical(self, "错误", f"读取文件失败: {str(e)}") elif ext == '.bjb': # 本地文件，is_cloud_file=False，会优先查找同目录.key文件 if DEBUG: debug_log("调用解密函数（本地文件模式）") content, success = decrypt_bjb_file(file_path, self, is_cloud_file=False) if success and content is not None: tab = EditorTab(self.tabs, self.tabs.count(), file_path=file_path, cloud_id=cloud_id, file_type='bjb', content=content) self.tabs.addTab(tab.text_edit, os.path.basename(file_path)) self.editor_tabs.append(tab) self.tabs.setCurrentIndex(self.tabs.count() - 1) else: if DEBUG: debug_log("解密失败，不创建选项卡") def open_cloud_file_dialog(self): """打开云端文件对话框""" if not self.client.token: QMessageBox.warning(self, "提示", "请先登录") self.check_login() return dialog = CloudFileTreeDialog(self.client, self) dialog.exec_() def save_current_tab(self): """保存当前选项卡 - 加密文件直接使用原有配置静默保存""" idx = self.tabs.currentIndex() if idx < 0 or idx >= len(self.editor_tabs): if DEBUG: debug_log(f"保存失败: 无效索引 {idx}") return tab = self.editor_tabs[idx] content = tab.get_content() if DEBUG: debug_log(f"保存当前选项卡: 索引 {idx}, 类型: {tab.file_type}, 新文件: {tab.is_new}") debug_log(f"内容长度: {len(content)}字符") # 新文件：调用另存为（会弹出配置对话框） if tab.is_new: if DEBUG: debug_log("新文件，调用另存为") self.save_as_current_tab() return # 已有文件路径 if tab.file_path and os.path.exists(tab.file_path): try: if tab.file_type == 'txt': # 文本文件：直接写入 if DEBUG: debug_log(f"保存文本文件: {tab.file_path}") with open(tab.file_path, 'w', encoding='utf-8') as f: f.write(content) tab.mark_saved() self.status_bar.showMessage(f"已保存: {os.path.basename(tab.file_path)}", 3000) if DEBUG: debug_log("文本文件保存成功") else: # bjb 加密文件 if DEBUG: debug_log(f"保存加密文件: {tab.file_path}") # 检查是否有加密配置 if hasattr(tab, 'encrypt_config') and tab.encrypt_config: config = tab.encrypt_config if DEBUG: debug_log(f"使用现有加密配置 - 算法: {config.get('algorithm')}, 密钥模式: {config.get('key_mode')}, 密码保护: {config.get('use_password', False)}") # 使用原有配置加密（静默保存，不弹窗） encrypted_data, _, _ = EncryptedNoteHandler.encrypt_content( content, config.get('algorithm', 'rsa'), config.get('key_mode', 'global'), config.get('custom_password'), config.get('single_private'), config.get('single_public'), strict_password=config.get('strict_password', True) ) with open(tab.file_path, 'wb') as f: f.write(encrypted_data) tab.mark_saved() self.status_bar.showMessage(f"已保存: {os.path.basename(tab.file_path)}", 3000) if DEBUG: debug_log("加密文件保存成功（使用现有配置，静默保存）") else: # 没有加密配置（理论上不应该发生，但作为后备） if DEBUG: debug_log("加密配置缺失，弹出配置对话框") dialog = NewEncryptedFileDialog(self) if dialog.exec_() == QDialog.Accepted: config = dialog.get_config() tab.encrypt_config = config encrypted_data, _, _ = EncryptedNoteHandler.encrypt_content( content, config['algorithm'], config['key_mode'], config.get('custom_password'), config.get('single_private'), config.get('single_public'), strict_password=config.get('strict_password', True) ) with open(tab.file_path, 'wb') as f: f.write(encrypted_data) tab.mark_saved() self.status_bar.showMessage(f"已保存: {os.path.basename(tab.file_path)}", 3000) if DEBUG: debug_log("加密文件保存成功（新配置）") else: if DEBUG: debug_log("用户取消保存") return except Exception as e: debug_error(f"保存失败: {e}") QMessageBox.critical(self, "保存失败", str(e)) else: # 文件路径无效，调用另存为 if DEBUG: debug_log("文件路径无效，调用另存为") self.save_as_current_tab() def save_as_current_tab(self): """另存为当前选项卡 - 首次保存时弹出配置对话框""" idx = self.tabs.currentIndex() if idx < 0 or idx >= len(self.editor_tabs): if DEBUG: debug_log(f"另存为失败: 无效索引 {idx}") return tab = self.editor_tabs[idx] content = tab.get_content() if DEBUG: debug_log(f"另存为当前选项卡: 索引 {idx}, 类型: {tab.file_type}") debug_log(f"内容长度: {len(content)}字符") if tab.file_type == 'txt': # 文本文件另存为 if DEBUG: debug_log("另存为文本文件") file_path, _ = QFileDialog.getSaveFileName(self, "保存文件", "", "文本文件 (*.txt)") if not file_path: if DEBUG: debug_log("用户取消保存") return if not file_path.endswith('.txt'): file_path += '.txt' try: with open(file_path, 'w', encoding='utf-8') as f: f.write(content) tab.file_path = file_path tab.is_new = False tab.mark_saved() if DEBUG: debug_log(f"文本文件另存为成功: {file_path}") self.status_bar.showMessage(f"已保存: {os.path.basename(file_path)}", 3000) except Exception as e: debug_error(f"保存失败: {e}") QMessageBox.critical(self, "保存失败", str(e)) else: # bjb 加密文件 if DEBUG: debug_log("另存为加密文件") # 获取加密配置 if hasattr(tab, 'encrypt_config') and tab.encrypt_config: # 已有配置，直接使用（但另存为时应该让用户选择新位置） config = tab.encrypt_config if DEBUG: debug_log("使用选项卡中的现有加密配置") else: # 没有配置，弹出配置对话框 if DEBUG: debug_log("显示加密配置对话框") dialog = NewEncryptedFileDialog(self) if dialog.exec_() != QDialog.Accepted: if DEBUG: debug_log("用户取消加密配置") return config = dialog.get_config() tab.encrypt_config = config if DEBUG: debug_log("加密配置获取完成") # 弹出保存文件对话框 save_dialog = SaveEncryptedFileDialog( content, config['algorithm'], config['key_mode'], config['use_password'], config.get('strict_password', True), config.get('custom_password'), config.get('single_private'), config.get('single_public'), self ) if save_dialog.exec_() == QDialog.Accepted: tab.file_type = 'bjb' tab.encrypt_config = config tab.is_new = False if save_dialog.selected_file_path: tab.file_path = save_dialog.selected_file_path tab.mark_saved() if DEBUG: debug_log(f"加密文件另存为成功: {tab.file_path}") def encrypt_current_file(self): """加密当前文件""" if DEBUG: debug_log("加密当前文件功能被调用") idx = self.tabs.currentIndex() if idx < 0 or idx >= len(self.editor_tabs): QMessageBox.warning(self, "提示", "没有打开的文件") return tab = self.editor_tabs[idx] content = tab.get_content() if not content.strip(): ret = QMessageBox.question(self, "确认", "文件内容为空，是否继续加密？", QMessageBox.Yes | QMessageBox.No) if ret != QMessageBox.Yes: return dialog = EncryptCurrentFileDialog(self) if dialog.exec_() != QDialog.Accepted: return config = dialog.get_config() default_name = "encrypted_note.bjb" if tab.file_path: base_name = os.path.splitext(os.path.basename(tab.file_path))[0] default_name = f"{base_name}_encrypted.bjb" file_path, _ = QFileDialog.getSaveFileName(self, "保存加密文件", default_name, "加密笔记 (*.bjb)") if not file_path: return if not file_path.endswith('.bjb'): file_path += '.bjb' try: encrypted_data, priv, pub = EncryptedNoteHandler.encrypt_content( content, config['algorithm'], config['key_mode'], config['custom_password'], config.get('single_private'), config.get('single_public'), strict_password=config.get('strict_password', True) ) with open(file_path, 'wb') as f: f.write(encrypted_data) if config['key_mode'] == 'single' and priv: key_path = file_path + '.key' with open(key_path, 'wb') as f: f.write(priv) QMessageBox.information(self, "加密成功", f"文件已加密保存为:\n{file_path}\n\n" f"密钥文件已保存为:\n{key_path}\n\n" f"请妥善保管密钥文件！") else: QMessageBox.information(self, "加密成功", f"文件已加密保存为:\n{file_path}\n\n" f"使用全局密钥加密，无需额外保存密钥文件。") ret = QMessageBox.question(self, "打开文件", "是否在新选项卡中打开加密后的文件？", QMessageBox.Yes | QMessageBox.No) if ret == QMessageBox.Yes: self.open_local_file(file_path) except Exception as e: debug_error(f"加密失败: {e}") QMessageBox.critical(self, "加密失败", str(e)) def convert_txt_to_bjb(self): """将当前文本文件转换为加密笔记""" if DEBUG: debug_log("TXT转BJB功能被调用") idx = self.tabs.currentIndex() if idx < 0 or idx >= len(self.editor_tabs): QMessageBox.warning(self, "提示", "没有打开的文件") return tab = self.editor_tabs[idx] if tab.file_type == 'bjb': QMessageBox.information(self, "提示", "当前文件已经是加密笔记格式") return content = tab.get_content() dialog = EncryptCurrentFileDialog(self) if dialog.exec_() != QDialog.Accepted: return config = dialog.get_config() default_name = os.path.splitext(os.path.basename(tab.file_path))[0] + ".bjb" if tab.file_path else "converted.bjb" file_path, _ = QFileDialog.getSaveFileName(self, "保存为加密笔记", default_name, "加密笔记 (*.bjb)") if not file_path: return if not file_path.endswith('.bjb'): file_path += '.bjb' try: encrypted_data, priv, pub = EncryptedNoteHandler.encrypt_content( content, config['algorithm'], config['key_mode'], config['custom_password'], config.get('single_private'), config.get('single_public'), strict_password=config.get('strict_password', True) ) with open(file_path, 'wb') as f: f.write(encrypted_data) if config['key_mode'] == 'single' and priv: key_path = file_path + '.key' with open(key_path, 'wb') as f: f.write(priv) QMessageBox.information(self, "转换成功", f"文件已转换为加密笔记:\n{file_path}\n\n" f"密钥文件已保存为:\n{key_path}\n\n" f"请妥善保管密钥文件！") else: QMessageBox.information(self, "转换成功", f"文件已转换为加密笔记:\n{file_path}\n\n" f"使用全局密钥加密，无需额外保存密钥文件。") ret = QMessageBox.question(self, "打开文件", "是否在新选项卡中打开加密后的文件？", QMessageBox.Yes | QMessageBox.No) if ret == QMessageBox.Yes: self.open_local_file(file_path) except Exception as e: debug_error(f"转换失败: {e}") QMessageBox.critical(self, "转换失败", str(e)) def upload_current_tab(self): """上传当前文件到云端""" if not self.client.token: QMessageBox.warning(self, "提示", "请先登录") self.check_login() return idx = self.tabs.currentIndex() if idx < 0 or idx >= len(self.editor_tabs): return tab = self.editor_tabs[idx] if tab.is_new or not tab.file_path: QMessageBox.warning(self, "提示", "请先保存文件到本地") return if tab.modified: ret = QMessageBox.question(self, "提示", "文件未保存，是否先保存？", QMessageBox.Yes | QMessageBox.No) if ret == QMessageBox.Yes: self.save_current_tab() folder, ok = QInputDialog.getText(self, "上传到云端", "请输入云端目录路径 (默认为 /):", text="/") if not ok: return if not folder: folder = "/" res = self.client.upload_file(tab.file_path, folder) if res: QMessageBox.information(self, "成功", "文件已上传到云端") else: QMessageBox.warning(self, "错误", "上传失败") def show_cloud_manager(self): """显示云端管理器""" if not self.client.token: QMessageBox.warning(self, "提示", "请先登录") self.check_login() return dialog = CloudFileTreeDialog(self.client, self) dialog.exec_() def on_tab_changed(self, index): """当前选项卡改变时的回调""" if index >= 0 and index < len(self.editor_tabs): self.current_editor = self.editor_tabs[index] else: self.current_editor = None def close_tab(self, index): """关闭指定索引的选项卡""" if index < 0 or index >= len(self.editor_tabs): return tab = self.editor_tabs[index] if tab.modified: ret = QMessageBox.question(self, "提示", "文件已修改，是否保存？", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if ret == QMessageBox.Yes: self.save_current_tab() elif ret == QMessageBox.Cancel: return self.tabs.removeTab(index) self.editor_tabs.pop(index) for i, t in enumerate(self.editor_tabs): t.index = i current_idx = self.tabs.currentIndex() if current_idx >= 0 and current_idx < len(self.editor_tabs): self.current_editor = self.editor_tabs[current_idx] else: self.current_editor = None def about(self): """关于对话框""" QMessageBox.about(self, "关于云笔记", "云笔记 v3.0\n\n" "功能特性：\n" "• 支持 .txt 文本文件\n" "• 支持 .bjb 加密笔记\n" "• 云端同步功能\n" "• 多选项卡编辑\n" "• 加密当前文件\n" "• TXT转BJB加密\n" "• 支持高强度/低强度密码模式\n" "• 端到端加密：服务器不存储私钥\n\n" "加密模式：\n" "1. RSA-4096 + AES-256-GCM\n" "2. X25519 + AES-256-GCM\n\n" "密钥方式：\n" "• 默认加密：全局密钥对\n" "• 安全加密：单独生成密钥对\n\n" "快捷键：\n" "• Ctrl+N: 新建文本\n" "• Ctrl+Shift+N: 新建加密笔记\n" "• Ctrl+E: 加密当前文件\n" "• Ctrl+Shift+S: 另存为加密笔记\n" "• Ctrl+S: 保存\n" "• Ctrl+O: 打开文件\n\n" f"密钥存储位置：\n" f"• 用户目录: {USER_KEY_DIR}\n" f"• 程序目录: {APP_KEY_DIR}") def main(): """主函数""" if DEBUG: debug_log("=" * 50) debug_log("云笔记应用程序启动") debug_log("=" * 50) app = QApplication(sys.argv) app.setStyle('Fusion') ensure_global_keys() window = MainWindow() window.show() sys.exit(app.exec_()) if __name__ == "__main__": main()