feat(security): 实现内置 CurseForge API 密钥保护机制

添加内置密钥管理模块和安全说明文档，防止密钥泄露
- 通过 GitHub Actions 注入密钥到编译环境
- 运行时自动加载内置密钥并防止写入配置文件
- 修改设置界面以区分内置密钥和用户自定义密钥
- 更新配置管理器以处理密钥保护逻辑

Author: blibilijojo

.github/workflows/nuitka-windows-release.yml

@@ -42,6 +42,18 @@ jobs:
           Write-Output "version=$version" >> $env:GITHUB_OUTPUT
         shell: pwsh
 
+      - name: Set CurseForge API Key
+        id: cf_key
+        run: |
+          if ($env:CURSEFORGE_API_KEY) {
+            Write-Output "has_key=true" >> $env:GITHUB_OUTPUT
+          } else {
+            Write-Output "has_key=false" >> $env:GITHUB_OUTPUT
+          }
+        shell: pwsh
+        env:
+          CURSEFORGE_API_KEY: ${{ secrets.CURSEFORGE_API_KEY }}
+
       - name: Build Windows Executable with Nuitka
         uses: Nuitka/Nuitka-Action@main
         with:
@@ -64,6 +76,8 @@ jobs:
             core
           include-data-files: |
             requirements.txt=requirements.txt
+          environment-variables: |
+            CURSEFORGE_API_KEY=${{ secrets.CURSEFORGE_API_KEY }}
 
       - name: Upload Release Artifact
         uses: actions/upload-artifact@v4

BUILTIN_KEY_SECURITY.md

@@ -0,0 +1,71 @@
+# 内置 CurseForge API 密钥安全说明
+
+## 概述
+
+为了防止 CurseForge API 密钥泄露，项目实现了内置密钥保护机制。当通过 GitHub Actions 打包时，可以将 `CURSEFORGE_API_KEY` 作为 GitHub Secret 注入到编译后的 exe 文件中，并且该密钥不会被写入配置文件。
+
+## 工作原理
+
+### 1. 构建时注入
+在 GitHub Actions 工作流中，通过 `environment-variables` 将 Secret 注入到编译环境：
+
+```yaml
+environment-variables: |
+  CURSEFORGE_API_KEY=${{ secrets.CURSEFORGE_API_KEY }}
+```
+
+### 2. 运行时保护
+- **加载时**：程序启动时自动从环境变量读取内置密钥，并注入到配置中
+- **保存时**：检测到当前使用的密钥与内置密钥相同时，自动阻止写入配置文件
+
+### 3. 核心文件
+- `utils/builtin_secrets.py` - 内置密钥管理模块
+- `utils/config_manager.py` - 配置加载/保存时处理密钥保护
+- `gui/settings_components/curseforge_settings.py` - UI 层保护
+- `gui/settings_components/external_services_settings.py` - 外部服务设置保护
+
+## 配置 GitHub Secrets
+
+1. 进入 GitHub 仓库页面
+2. 点击 **Settings** → **Secrets and variables** → **Actions**
+3. 点击 **New repository secret**
+4. 添加以下 Secret：
+   - **Name**: `CURSEFORGE_API_KEY`
+   - **Value**: 你的 CurseForge API 密钥（从 https://console.curseforge.com 获取）
+
+## 用户行为
+
+### 对于普通用户（无内置密钥）
+- 需要手动输入自己的 CurseForge API 密钥
+- 密钥会正常保存到 `config.json`
+
+### 对于使用官方构建的用户（有内置密钥）
+- 程序自动使用内置的 API 密钥
+- 在设置界面查看时，显示的是内置密钥（但不会显示完整内容）
+- **即使修改设置，内置密钥也不会被覆盖或写入配置文件**
+- 配置文件中的 `curseforge_api_key` 字段始终为空
+
+## 安全优势
+
+1. **防止泄露**：即使用户分享配置文件，也不会泄露内置 API 密钥
+2. **透明使用**：用户无需配置即可使用 CurseForge 功能
+3. **防篡改**：用户无法通过修改配置文件来窃取内置密钥
+4. **可追溯**：如果密钥泄露，可以追溯到具体的构建版本
+
+## 注意事项
+
+- 内置密钥仅在读入内存时使用，不会持久化存储
+- 如果用户输入自己的密钥，会覆盖内置密钥并正常保存
+- 反编译 exe 文件仍然可能提取出密钥，因此建议：
+  - 定期轮换 API 密钥
+  - 监控 API 使用情况
+  - 如发现泄露立即在 CurseForge 控制台撤销密钥
+
+## 开发调试
+
+在本地开发时，可以通过环境变量设置测试密钥：
+
+```powershell
+$env:CURSEFORGE_API_KEY="your_test_key_here"
+python main.py
+```

gui/settings_components/curseforge_settings.py

@@ -36,7 +36,9 @@ def _create_basic_settings(self, parent):
         frame.pack(fill="x", pady=(0, 10), padx=5)
         frame.columnconfigure(1, weight=1)
 
-        info_label = ttk.Label(frame, text="请输入您的CurseForge API密钥", bootstyle="secondary")
+        info_label = ttk.Label(frame, 
+            text="官方版本已内置 API 密钥，可直接使用；\n如为自行构建或使用单文件版本，请自行输入密钥。", 
+            bootstyle="secondary")
         info_label.pack(anchor="w", pady=(0, 10))
 
         key_frame = ttk.Frame(frame)
@@ -69,8 +71,23 @@ def _toggle_key_visibility(self):
             self.key_entry.config(show="*")
 
     def _save_settings(self):
+        api_key = self.api_key_var.get().strip()
+        
+        # 检查是否为内置密钥
+        is_builtin = False
+        try:
+            from utils.builtin_secrets import get_builtin_curseforge_key
+            if get_builtin_curseforge_key() and api_key == get_builtin_curseforge_key():
+                is_builtin = True
+        except ImportError:
+            pass
+        
+        # 如果是内置密钥，不触发保存（因为会被 config_manager 拦截）
+        if is_builtin:
+            return
+        
         curseforge_config = {
-            'curseforge_api_key': self.api_key_var.get().strip()
+            'curseforge_api_key': api_key
         }
 
         self.config.update(curseforge_config)

gui/settings_components/external_services_settings.py

@@ -83,7 +83,9 @@ def _create_curseforge_settings(self, parent):
         frame.pack(fill="x", pady=(0, 10), padx=5)
         frame.columnconfigure(1, weight=1)
 
-        info_label = ttk.Label(frame, text="用于从CurseForge平台搜索和下载模组", bootstyle="secondary")
+        info_label = ttk.Label(frame, 
+            text="用于获取模组信息、从 CurseForge 平台搜索和下载模组\n官方版本已内置密钥；自行构建请自行输入。", 
+            bootstyle="secondary")
         info_label.grid(row=0, column=0, columnspan=3, sticky="w", pady=(0, 10))
 
         # API密钥
@@ -171,8 +173,23 @@ def _save_github_settings(self):
         self.save_callback(github_config)
 
     def _save_cf_settings(self):
+        api_key = self.cf_api_key_var.get().strip()
+        
+        # 检查是否为内置密钥
+        is_builtin = False
+        try:
+            from utils.builtin_secrets import get_builtin_curseforge_key
+            if get_builtin_curseforge_key() and api_key == get_builtin_curseforge_key():
+                is_builtin = True
+        except ImportError:
+            pass
+        
+        # 如果是内置密钥，不触发保存
+        if is_builtin:
+            return
+        
         cf_config = {
-            'curseforge_api_key': self.cf_api_key_var.get().strip()
+            'curseforge_api_key': api_key
         }
         self.config.update(cf_config)
         self.save_callback(cf_config)

utils/builtin_secrets.py

@@ -0,0 +1,39 @@
+"""
+内置密钥管理模块
+用于在打包时嵌入敏感密钥，并防止其被写入配置文件
+"""
+import os
+
+# 内置 CurseForge API 密钥（在构建时由 GitHub Secrets 注入）
+BUILTIN_CURSEFORGE_API_KEY = os.environ.get('CURSEFORGE_API_KEY', '')
+
+# 标记是否为内置密钥
+IS_BUILTIN_CURSEFORGE_KEY = bool(BUILTIN_CURSEFORGE_API_KEY)
+
+
+def get_builtin_curseforge_key() -> str:
+    """获取内置的 CurseForge API 密钥"""
+    return BUILTIN_CURSEFORGE_API_KEY
+
+
+def is_builtin_curseforge_key_set() -> bool:
+    """检查是否设置了内置 CurseForge API 密钥"""
+    return IS_BUILTIN_CURSEFORGE_KEY
+
+
+def is_protected_key(key: str, value: str) -> bool:
+    """
+    检查某个配置项是否为受保护的内置密钥
+    
+    Args:
+        key: 配置项的键
+        value: 配置项的值
+        
+    Returns:
+        如果是受保护的内置密钥则返回 True
+    """
+    if key == 'curseforge_api_key' and IS_BUILTIN_CURSEFORGE_KEY:
+        # 如果用户输入的值与内置密钥相同，则认为是受保护的
+        if value.strip() == BUILTIN_CURSEFORGE_API_KEY:
+            return True
+    return False

utils/config_manager.py

@@ -119,6 +119,20 @@ def load_config() -> dict:
     try:
         with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
             config = json.load(f)
+        
+        # 注入内置 CurseForge API 密钥（如果存在且用户未自定义）
+        try:
+            from utils.builtin_secrets import get_builtin_curseforge_key
+            builtin_key = get_builtin_curseforge_key()
+            if builtin_key:
+                # 只有当配置文件中没有设置密钥时，才使用内置密钥
+                if not config.get('curseforge_api_key', '').strip():
+                    config['curseforge_api_key'] = builtin_key
+                    logging.debug("已加载内置 CurseForge API 密钥")
+                else:
+                    logging.debug("检测到用户自定义 CurseForge API 密钥，将优先使用用户设置")
+        except ImportError:
+            pass
         config_updated = False
 
         if "api_keys_raw" not in config and "api_keys" in config:
@@ -200,8 +214,20 @@ def load_config() -> dict:
 
 def save_config(config_data: dict):
     try:
+        # 防止内置密钥被写入配置文件
+        config_to_save = config_data.copy()
+        try:
+            from utils.builtin_secrets import is_protected_key, get_builtin_curseforge_key
+            if get_builtin_curseforge_key():
+                # 如果设置了内置密钥，则从保存的配置中移除
+                if config_to_save.get('curseforge_api_key', '').strip() == get_builtin_curseforge_key():
+                    config_to_save['curseforge_api_key'] = ''
+                    logging.debug("已阻止内置 CurseForge API 密钥写入配置文件")
+        except ImportError:
+            pass
+        
         with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
-            json.dump(config_data, f, indent=4, ensure_ascii=False)
+            json.dump(config_to_save, f, indent=4, ensure_ascii=False)
         logging.debug("配置已自动保存")
     except Exception as e:
         logging.error(f"保存配置文件时出错：{e}")