@yufengtadian/freedom-cli 1.12.16 → 1.12.17

package/README.md

@@ -1,13 +1,16 @@
 # freedom-cli
 
-Freedom 桌面壳打包工具：把你的 Web 前端一键打包成跨平台桌面应用（v1.12.15）。
+Freedom 桌面壳打包工具：把你的 Web 前端一键打包成跨平台桌面应用（v1.12.17）。
 
 基于自研 Freedom WebView 壳层（对标 Wails / Tauri）：前端完全自由、后端可任意语言、渲染复用系统 WebView（Windows WebView2 / macOS WKWebView / Linux WebKitGTK），产物为单个可执行文件 + resources 目录，前端页面内存加载，不占本地端口。
 
+**v1.12.17 安全模式全面落地**：三档安全模式 `freedom security <none|basic|high>` 正式随包分发——high 档把 resources 加密为 `app.bin`（AES-256-CTR + HMAC-SHA256 + PBKDF2 密钥派生），配合 `.integrity` 完整性校验、anti-debug 与进程隐藏，磁盘无明文、篡改即拒运行；三平台预编译壳经 CI 重建分发，补齐 v1.12.16 仅重编 win-x64 壳的缺口。
+
 **v1.12.16 自动更新 + 完整 CLI 模式 + 壳生命周期全面防御**：
 - **自动检测版本并自动更新**：`freedom update` / `freedom check-update` 检测到新版本即自动执行 `npm install -g @yufengtadian/freedom-cli@latest` 升级，**不再需要手动执行 npm 命令**；每次命令执行成功后静默自检，发现新版自动更新（6 小时频控防骚扰，非全局安装给出明确升级指引）；TUI 主菜单「检查 / 自动更新」同步接入；
 - **完整 CLI 模式**：无参数运行 `freedom` 直接进入交互式完整 CLI（打包 / 新建项目 / 配置 / 壳管理 / 教程 / 自动更新 / 退出）；管道与脚本环境自动降级打印帮助，不卡死；
-- **壳生命周期全面防御（B51-B58 闭环）**：webview 全方法销毁防护、user32 proc 去重、WebView2 缺失可操作提示；`webview_create` 失败（如缺 WebKitGTK）返回 nil 后新壳走明确失败提示而非空指针崩溃；用户 `Bind` 的方法不再被 config.json 进程后端静默覆盖失效；help 文案与自动更新实现对齐，清理死代码。
+- **壳生命周期全面防御（B51-B58 闭环）**：webview 全方法销毁防护、user32 proc 去重、WebView2 缺失可操作提示；`webview_create` 失败（如缺 WebKitGTK）返回 nil 后新壳走明确失败提示而非空指针崩溃；用户 `Bind` 的方法不再被 config.json 进程后端静默覆盖失效；help 文案与自动更新实现对齐，清理死代码；
+- **安全加固（新增 high 安全模式，B59-B62 闭环）**：`freedom security <none|basic|high>` 三档安全模式，high 档把 resources 整体加密为 `app.bin`（AES-256-CTR + HMAC-SHA256，密钥经 PBKDF2 按应用派生），磁盘无明文 HTML/配置，壳内存解密 + `.integrity` 完整性校验（防整体替换 / 篡改 / exe 改名），另含 anti-debug（检测调试器即退出）与进程隐藏；详见下文「安全模式」章节。
 
 **v1.12.15 补发壳生命周期稳定性修复**：v1.12.14 的 npm 上架时间早于修复提交，上架版预编译壳未包含悬垂指针修复（窗口操作 / 代理端口触发随机退出的根因）；本版正式把含 B50 修复的预编译壳随 npm 包分发——
 - 壳销毁生命周期修复：`webview.Destroy()` 后经 Emit / Quit / WindowHandle / binding 回调访问已释放 C 对象（悬垂指针）导致随机退出；新增 `destroyed` 原子标记，Dispatch / Eval / binding 回调销毁后一律跳过原生调用，`Run` 在 `Destroy` 前清空 `App.view`，事件与绑定回调加 `recover` 兜底；
@@ -94,6 +97,7 @@ freedom icon icon.ico
 
 # 4. 打包
 freedom build                        # 默认当前平台
+freedom build --security high        # 以 high 安全模式构建（resources 加密，见「安全模式」）
 freedom build --platform all         # 三平台全量（win + mac + linux）
 freedom build --platform win-x64     # 仅 Windows
 freedom build --platform darwin-arm64   # 仅 macOS Apple Silicon
@@ -152,6 +156,7 @@ export default {
   minHeight: 300,
   center: true,          // 启动居中
   debug: false,          // 开发者工具
+  security: 'none',      // 安全模式：'none'（明文）| 'basic'（明文+提示）| 'high'（resources 加密，见「安全模式」）
   titlebar: 'frameless', // frameless（默认，标题栏不存在，三按钮由前端自绘）| native
   icon: undefined,       // 应用图标：Windows 用 .ico（推荐多尺寸），macOS 用 .icns
   outDir: 'dist',        // 产物目录：'dist'（默认）| '.'（项目根目录）| 任意路径
@@ -164,6 +169,35 @@ export default {
 - macOS：`.icns` 在构建时放入 `.app/Contents/Resources` 并写入 Info.plist 的 `CFBundleIconFile`；
 - 未配置时使用壳默认图标。`freedom icon <path>` 可直接写入该配置。
 
+## 安全模式
+
+默认产物把前端 HTML 与配置以明文写入 `resources/`，任何人解包即可直接读取页面源码与配置。如需防止源码被轻易提取，提供三档安全模式：
+
+| 模式 | 资源形态 | 破解难度 | 适用场景 |
+| --- | --- | --- | --- |
+| `none` | 明文 `index.html` + `config.json`（默认，兼容历史产物） | 解包即读 | 公开页面 / 调试 / 快速分发 |
+| `basic` | 同上明文，构建时额外输出加固建议 | 低 | 需要提示、暂不加密 |
+| `high` | 整体加密为 `resources/app.bin` + `.integrity`，磁盘**无任何明文** HTML/配置 | 高（需逆向壳 + 还原派生密钥） | 防源码提取、防资源篡改的正式分发 |
+
+**切换方式**（二选一，`--security` 可临时覆盖配置文件）：
+
+```bash
+freedom security high                # 写入 freedom.config.js 持久生效
+freedom build --security high        # 单次构建生效（不改配置）
+freedom build                        # 读取配置中的 security 值
+```
+
+**high 模式原理**：
+- 构建时：前端 HTML + 配置序列化后，用 **AES-256-CTR** 加密为 `app.bin`（容器头 `FRDM1` + 16B IV + 16B 认证标签），并生成 `.integrity` 完整性清单（`app.bin` 与 `backend/**` 各文件的 HMAC-SHA256）；
+- 加密密钥由 **PBKDF2-HMAC-SHA256**（6 万次迭代）按「应用可执行文件名」派生，不同应用密钥不同，暴力破解成本高；
+- 壳启动时：先校验 `.integrity`（防整体替换 / 篡改 / exe 改名），再恒定时间比对 HMAC 认证标签（Encrypt-then-MAC），最后内存中解密加载——**磁盘始终无明文**；
+- 解密 / 校验失败即拒绝运行（不静默回退明文，防降级攻击）；
+- 另内置 **anti-debug**（`IsDebuggerPresent` / `CheckRemoteDebuggerPresent` 命中即退出）与进程隐藏加固。
+
+**加固上限说明**：`high` 大幅提高破解门槛，但**任何客户端可执行程序都无法做到绝对不可破解**——密钥最终存在于壳二进制与运行时内存中。更高强度建议：壳编译时设置 `-ldflags "-s -w"` 剥离符号表（CI 编译壳时已可选开启）、对核心业务保留服务端校验。若需"怎么都解不开"，请把真正敏感的密钥 / 逻辑放到你的后端。
+
+**互斥规则**：切换安全模式重新构建时，CLI 会自动清理另一模式的遗留产物（`app.bin`/`.integrity` 与明文 `index.html`/`config.json` 只能存其一），避免壳误加载旧资源。
+
 ## 前端
 
 前端是标准 Vite 项目，`vite build` 时通过 `vite-plugin-singlefile` 内联为单个 HTML。壳层注入全局对象 `window.freedom`：
@@ -186,8 +220,9 @@ window.freedom.window.minimize();                       // 窗口控制
 ```
 freedom tui                          # 交互式终端界面
 freedom init <目录> [--force]
-freedom build [--platform win-x64|darwin-arm64|linux-x64|all] [--no-cache]
+freedom build [--platform win-x64|darwin-arm64|linux-x64|all] [--no-cache] [--security none|basic|high]
 freedom titlebar <native|frameless>
+freedom security <none|basic|high>     # 设置安全模式（写入配置）
 freedom icon <path>                    # 设置应用图标（Windows 用 .ico，macOS 用 .icns）
 freedom config [get|set]
 freedom shell list|download <platform>|build <platform>

package/lib/build.js

@@ -35,6 +35,13 @@ const {
   localShellPath,
 } = require('./utils');
 const { hasShell, downloadShell, validateLocalShell } = require('./shell');
+const {
+  SECURITY_MODES,
+  resolveSecurity,
+  encryptApp,
+  buildIntegrity,
+  renderIntegrity,
+} = require('./security');
 
 function run(cmd, args, opts = {}) {
   // Windows 下 npm 是 .cmd 批处理，必须经 shell 执行
@@ -118,6 +125,11 @@ async function build(projectDir, opts = {}) {
   const html = fs.readFileSync(distHtml, 'utf8');
   warnIfNotSingleFile(html, distHtml);
   const configJSON = renderConfigJSON(cfg, name);
+  // 安全模式：--security 优先于 freedom.config.js 的 security 字段，默认 none。
+  //   none  = 明文资源（默认，兼容历史产物）
+  //   basic = 明文资源 + 构建期安全提示（剥符号 / 混淆，后续可用高模式加密）
+  //   high  = resources 整体加密为 app.bin（AES-256-CTR+HMAC）+ .integrity 完整性清单，磁盘无明文
+  const security = resolveSecurity(opts.security, cfg.security);
 
   // 2) 后端目录（若配置了 backend 进程）
   const backendDir = path.join(dir, cfg.backendDir || 'backend');
@@ -133,7 +145,7 @@ async function build(projectDir, opts = {}) {
   const results = await Promise.all(
     platforms.map(async (plat) => {
       const targetDir = multi ? path.join(outDirPath, plat) : outDirPath;
-      const outFile = await emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon });
+      const outFile = await emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon, security });
       return { plat, outFile };
     })
   );
@@ -141,7 +153,7 @@ async function build(projectDir, opts = {}) {
   return { results };
 }
 
-async function emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon }) {
+async function emitPlatform({ plat, name, version, targetDir, html, configJSON, backendDir, hasBackend, autoDownload, icon, security }) {
   // 取预编译壳二进制
   const shell = localShellPath(plat);
   if (!fs.existsSync(shell)) {
@@ -177,10 +189,40 @@ async function emitPlatform({ plat, name, version, targetDir, html, configJSON,
   }
 
   // 写 resources：页面 + 配置 + 后端
+  // security=high 时整体加密为 app.bin（磁盘无明文 HTML/config），并生成 .integrity 完整性清单；
+  // none / basic 保持明文资源（兼容历史产物），basic 额外输出安全加固提示。
   const resDir = path.join(targetDir, 'resources');
   await fsp.mkdir(resDir, { recursive: true });
-  await fsp.writeFile(path.join(resDir, 'index.html'), html, 'utf8');
-  await fsp.writeFile(path.join(resDir, 'config.json'), configJSON, 'utf8');
+  // 互斥清理：切换安全模式时删除另一模式遗留产物，防止壳误加载旧资源
+  // （high 产物 app.bin/.integrity 与明文 index.html/config.json 只能存其一）。
+  if (security === 'high') {
+    for (const legacy of ['index.html', 'config.json']) {
+      const p = path.join(resDir, legacy);
+      if (fs.existsSync(p)) await fsp.rm(p, { force: true });
+    }
+    const appBin = encryptApp(name, html, configJSON);
+    await fsp.writeFile(path.join(resDir, 'app.bin'), appBin);
+    const backendRelMap = {};
+    if (hasBackend && fs.existsSync(backendDir)) {
+      collectDirFiles(backendDir, '', backendRelMap);
+    }
+    const integrityText = renderIntegrity(buildIntegrity(name, appBin, backendRelMap));
+    await fsp.writeFile(path.join(resDir, '.integrity'), integrityText, 'utf8');
+  } else {
+    for (const legacy of ['app.bin', '.integrity']) {
+      const p = path.join(resDir, legacy);
+      if (fs.existsSync(p)) await fsp.rm(p, { force: true });
+    }
+    await fsp.writeFile(path.join(resDir, 'index.html'), html, 'utf8');
+    await fsp.writeFile(path.join(resDir, 'config.json'), configJSON, 'utf8');
+    if (security === 'basic') {
+      process.stdout.write(
+        `[freedom] 安全模式 basic：资源仍为明文。加固建议：\n` +
+        `          1. 运行 ${'freedom security high'} 切换到高模式（resources 加密为 app.bin，磁盘无明文）；\n` +
+        `          2. 壳侧已内置 anti-debug / 进程隐藏，符号剥离需在 CI 编译壳时设置 ldflags -s -w（见 README 安全章节）。\n`
+      );
+    }
+  }
   if (hasBackend) {
     copyDir(backendDir, path.join(resDir, 'backend'));
   }
@@ -472,4 +514,17 @@ function warnIfNotSingleFile(html, distHtml) {
   }
 }
 
+// 递归收集目录内所有文件：relPath（POSIX 相对路径）-> Buffer 内容，供 .integrity 完整性清单使用。
+function collectDirFiles(dir, prefix, out) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectDirFiles(abs, prefix + entry.name + '/', out);
+    } else {
+      out[(prefix + entry.name).replace(/\\/g, '/')] = fs.readFileSync(abs);
+    }
+  }
+  return out;
+}
+
 module.exports = { build, parsePlatforms };

package/lib/cli.js

@@ -139,7 +139,22 @@ async function run(argv) {
           return 1;
         }
       }
-      const { results } = await build(process.cwd(), { platform, noCache: rest.includes('--no-cache') });
+      // 安全模式：--security <none|basic|high>（可选，默认取 freedom.config.js 的 security 字段）
+      const secArg = rest.find((a) => a.startsWith('--security'));
+      let security;
+      if (secArg) {
+        const inline = secArg.includes('=') ? secArg.split('=')[1] : undefined;
+        security = inline || rest[rest.indexOf(secArg) + 1];
+        if (!security || security.startsWith('--')) {
+          console.error(`${err('--security 缺少取值。')} ${dim('用法：')}${paint('freedom build --security <none|basic|high>', C.fg.cyan)}`);
+          return 1;
+        }
+      }
+      const { results } = await build(process.cwd(), {
+        platform,
+        noCache: rest.includes('--no-cache'),
+        security,
+      });
       for (const r of results) {
         console.log(`${ok('构建完成')} ${paint(`[${r.plat}]`, C.fg.magenta, C.bold)} ${paint(r.outFile, C.fg.white)}`);
       }
@@ -178,6 +193,23 @@ async function run(argv) {
       return 0;
     }
 
+    case 'security': {
+      const mode = rest[0];
+      if (!['none', 'basic', 'high'].includes(mode)) {
+        console.error(`${err('用法：')}${paint('freedom security <none|basic|high>', C.fg.cyan)}`);
+        console.error(`  ${dim('none  = 明文资源（默认，兼容历史产物）')}`);
+        console.error(`  ${dim('basic = 明文资源 + 构建期加固提示')}`);
+        console.error(`  ${dim('high  = resources 加密为 app.bin + .integrity 完整性清单，磁盘无明文，壳内存解密')}`);
+        return 1;
+      }
+      setConfig(process.cwd(), 'security', mode);
+      console.log(`${ok('安全模式已切换为：')}${paint(mode, C.fg.cyan, C.bold)}`);
+      if (mode === 'high') {
+        console.log(`  ${dim('下一次')} ${paint('freedom build', C.fg.cyan)} ${dim('将加密 resources（app.bin），前端源码与配置不会以明文落盘。')}`);
+      }
+      return 0;
+    }
+
     case 'config': {
       const sub = rest[0];
       if (sub === 'get') {

package/lib/config.js

@@ -14,6 +14,7 @@ const KEY_TYPES = {
   center: 'bool',
   debug: 'bool',
   titlebar: 'titlebar',
+  security: 'security',
   icon: 'string',
   outDir: 'string',
 };
@@ -42,6 +43,13 @@ function normalizeValue(key, value) {
     }
     return s;
   }
+  if (t === 'security') {
+    const s = String(value);
+    if (!['none', 'basic', 'high'].includes(s)) {
+      throw new Error('security 取值必须为：none / basic / high。');
+    }
+    return s;
+  }
   // 扩展键（如 backend）：字符串命令简写转 {command,args} 对象，
   // 与 build.js renderConfigJSON 的契约对齐（纯字符串形态不会被打包为后端进程）。
   if (key === 'backend') {
@@ -86,7 +94,9 @@ function setConfig(dir, key, value) {
   const rendered = renderLiteral(norm);
 
   const lines = text.split('\n');
-  const keyRe = new RegExp(`^(\\s*)${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:(.*)$`);
+  // 容忍 CRLF 行尾（Windows 编辑器 / git autocrlf 可能产生）：JS 正则的 . 不匹配 \r，
+  // 直接匹配 (.*)$ 会在行尾残留 \r 导致整行失配（历史隐患）。
+  const keyRe = new RegExp(`^(\\s*)${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:(.*)\\r?$`);
   let replaced = false;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].trim().startsWith('//')) continue; // 注释行不参与匹配与改写
@@ -130,6 +140,7 @@ const KNOWN_KEYS = {
   center: true,
   debug: false,
   titlebar: 'frameless',
+  security: 'none',
   icon: undefined,
   outDir: 'dist',
 };

package/lib/security.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// 安全加固模块（v1.13.0）
+//
+// 为 freedom build 提供两种安全模式：
+//   - basic（简单模式）：资源压缩 + 壳剥离符号建议，阻止"随手打开 resources/
+//     就能看到前端源码"的随手破解，成本低、完全向后兼容。
+//   - high（高危模式）：AES-256-CTR + HMAC-SHA256（Encrypt-then-MAC）加密资源为
+//     单一容器 resources/app.bin，运行时由壳在内存中解密（磁盘无明文）；
+//     配套 HMAC 完整性校验防篡改；密钥不落盘（由 exe 文件名派生），
+//     并强制关闭 WebView2 devtools。
+//
+// 架构说明（重要）：通用壳 = 所有应用共用一份预编译 freedom-shell 二进制，
+// 因此密钥派生所需的"主密钥常量"编译在通用壳内，天然被所有应用共享；
+// high 模式的对抗目标是把攻击者从"直接读明文"抬升到"必须逆向壳二进制、
+// 提取主密钥并复现派生算法"。真正"每应用唯一密钥"需要每应用独立编译壳
+// （破坏通用壳 + 零工具链架构），不在本模式范围内。
+//
+// ⚠️ 跨语言同步点：本文件与 templates/go/pkg/freedom/security.go 必须保持
+//    MASTER_KEY / DERIVE_SALT / PBKDF2_ITER / KEY_LEN / APP_BIN_MAGIC
+//    以及加密算法（aes-256-ctr + hmac-sha256）完全一致。
+//    修改任一侧必须同步另一侧，否则 build 出的加密资源壳无法解密。
+
+const crypto = require('crypto');
+const path = require('path');
+
+const SECURITY_MODES = ['none', 'basic', 'high'];
+
+// ---- 密钥派生参数（必须与 Go security.go 同步）----
+// 固定常量主密钥：参与 PBKDF2 派生，编译进通用壳。此处为 CLI 侧同值。
+const MASTER_KEY = 'freedom-shell::kdf-master::v1::7f4e8c2a9b1d6e3f';
+const DERIVE_SALT = 'freedom:derive:v1';
+const PBKDF2_ITER = 60000;
+const KEY_LEN = 32;
+
+// resources/app.bin 容器头：magic(5B 'FRDM1') + iv(16B) + tag(16B) + ciphertext
+// 算法：AES-256-CTR 加密 + HMAC-SHA256(密文) 截断 16B 认证标签。
+const APP_BIN_MAGIC = 'FRDM1';
+const CTR_IV_LEN = 16;
+const CTR_TAG_LEN = 16;
+
+// ---- 模式解析 ----
+
+// 解析安全模式；非法值抛错。opts.security 优先于 cfg.security，默认 none。
+function parseSecurity(raw) {
+  if (!raw) return 'none';
+  const v = String(raw).trim().toLowerCase();
+  if (!SECURITY_MODES.includes(v)) {
+    throw new Error(`未知安全模式：${raw}。可选：${SECURITY_MODES.join(' / ')}`);
+  }
+  return v;
+}
+
+// 归一化：CLI 显式参数 > 项目配置 > 默认 none
+function resolveSecurity(cliValue, cfgValue) {
+  if (cliValue) return parseSecurity(cliValue);
+  return parseSecurity(cfgValue);
+}
+
+// ---- 密钥派生 ----
+
+// 应用标识：exe 文件名（去扩展名）。
+// CLI build 时 = 目标 exe 名去掉扩展名；壳运行时 = os.Executable() basename 去扩展名。
+// 两侧使用同一派生算法，故 exe 事后被重命名会导致 high 模式无法解密（视为防篡改特性）。
+function appIdentityFor(name) {
+  return String(name).replace(/\.(exe|app)$/i, '');
+}
+
+// 与 Go security.go deriveKey 保持一致的 PBKDF2-HMAC-SHA256 派生。
+// 输入 salt = DERIVE_SALT + ':' + appName（避免仅按 exe 名可枚举碰撞）。
+function deriveKey(appName) {
+  const salt = Buffer.from(DERIVE_SALT + ':' + appIdentityFor(appName), 'utf8');
+  return crypto.pbkdf2Sync(MASTER_KEY, salt, PBKDF2_ITER, KEY_LEN, 'sha256');
+}
+
+// ---- 加密 / 解密（high 模式）----
+
+// 载荷结构：{ html: <string>, config: <string> }（config 为 config.json 原文 JSON 字符串）。
+// 返回 app.bin 完整字节。
+// 算法：AES-256-CTR 加密 → HMAC-SHA256(密文) 截 16B 认证标签（Encrypt-then-MAC）。
+function encryptApp(name, html, configJSON) {
+  const key = deriveKey(name);
+  const payload = Buffer.from(JSON.stringify({ html, config: configJSON }), 'utf8');
+  const iv = crypto.randomBytes(CTR_IV_LEN);
+  const cipher = crypto.createCipheriv('aes-256-ctr', key, iv);
+  const ct = Buffer.concat([cipher.update(payload), cipher.final()]);
+  const tag = crypto.createHmac('sha256', key).update(ct).digest().subarray(0, CTR_TAG_LEN);
+  return Buffer.concat([Buffer.from(APP_BIN_MAGIC, 'ascii'), iv, tag, ct]);
+}
+
+// 解密 app.bin（供单测验证 / 未来壳调试工具复用）。返回 { html, config }。
+function decryptApp(name, buf) {
+  const key = deriveKey(name);
+  const magic = Buffer.from(APP_BIN_MAGIC, 'ascii');
+  if (buf.length < magic.length + CTR_IV_LEN + CTR_TAG_LEN || !buf.subarray(0, magic.length).equals(magic)) {
+    throw new Error('app.bin 头无效：不是 FRDM1 加密容器');
+  }
+  let off = magic.length;
+  const iv = buf.subarray(off, off + CTR_IV_LEN); off += CTR_IV_LEN;
+  const tag = buf.subarray(off, off + CTR_TAG_LEN); off += CTR_TAG_LEN;
+  const ct = buf.subarray(off);
+
+  // 1) 认证：HMAC-SHA256(ct) 前 16 字节与容器头 tag 恒定时间比对。
+  const expect = crypto.createHmac('sha256', key).update(ct).digest().subarray(0, CTR_TAG_LEN);
+  if (!crypto.timingSafeEqual(tag, expect)) {
+    throw new Error('app.bin 认证失败（exe 被重命名或资源被篡改？）');
+  }
+
+  // 2) 解密：AES-256-CTR。
+  const decipher = crypto.createDecipheriv('aes-256-ctr', key, iv);
+  const plain = Buffer.concat([decipher.update(ct), decipher.final()]);
+  const obj = JSON.parse(plain.toString('utf8'));
+  if (typeof obj.html !== 'string' || typeof obj.config !== 'string') {
+    throw new Error('app.bin 载荷结构无效：缺少 html/config 字段');
+  }
+  return obj;
+}
+
+// ---- 完整性清单（high 模式）----
+
+// 生成 resources/.integrity：记录 app.bin 与 backend/ 各文件的 HMAC-SHA256，
+// 壳启动时校验，防止 resources 被整体替换/篡改。
+// 返回 { v, appBin, backend }。
+function buildIntegrity(appName, appBin, backendRelMap) {
+  const key = deriveKey(appName);
+  const hmac = (buf) => crypto.createHmac('sha256', key).update(buf).digest('hex');
+  const backend = {};
+  for (const [rel, buf] of Object.entries(backendRelMap || {})) {
+    backend[rel] = hmac(buf);
+  }
+  return { v: 1, appBin: hmac(appBin), backend };
+}
+
+// 生成 .integrity 文件文本。
+function renderIntegrity(integrity) {
+  return JSON.stringify(integrity, null, 2);
+}
+
+module.exports = {
+  SECURITY_MODES,
+  APP_BIN_MAGIC,
+  parseSecurity,
+  resolveSecurity,
+  appIdentityFor,
+  deriveKey,
+  encryptApp,
+  decryptApp,
+  buildIntegrity,
+  renderIntegrity,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yufengtadian/freedom-cli",
-  "version": "1.12.16",
+  "version": "1.12.17",
   "description": "Freedom WebView desktop shell packaging tool - no Go toolchain required, one command packs three-platform desktop apps",
   "keywords": [
     "desktop",

package/templates/go/pkg/freedom/anti_debug_other.go

@@ -0,0 +1,8 @@
+//go:build !windows
+
+package freedom
+
+// 反调试（非 Windows 平台空实现）。
+// macOS/Linux 的调试器检测（ptrace / task_for_pid 等）依赖平台特定 API，
+// 本版本不做；如需加强可在对应平台文件扩展。
+func antiDebugCheck() {}

package/templates/go/pkg/freedom/anti_debug_windows.go

@@ -0,0 +1,39 @@
+//go:build windows
+
+package freedom
+
+// 反调试（Windows 实现）：high 安全模式下调用。
+// 检测常见用户态调试器，发现时静默退出，防止攻击者在调试器下
+// 单步追踪资源解密 / 密钥派生逻辑。
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	kernel32dbg                      = syscall.NewLazyDLL("kernel32.dll")
+	procIsDebuggerPresent            = kernel32dbg.NewProc("IsDebuggerPresent")
+	procCheckRemoteDebuggerPresent   = kernel32dbg.NewProc("CheckRemoteDebuggerPresent")
+)
+
+// antiDebugCheck 检测调试器；发现则立即退出进程（退出码 77，无提示）。
+// 仅在 high 安全模式启用时由 freedom.go Run() 调用。
+func antiDebugCheck() {
+	if isBeingDebugged() {
+		os.Exit(77)
+	}
+}
+
+// isBeingDebugged 同时检测本地调试器（IsDebuggerPresent）与远程/内核调试器
+// （CheckRemoteDebuggerPresent），任一命中即认为正在被调试。
+func isBeingDebugged() bool {
+	r, _, _ := procIsDebuggerPresent.Call()
+	if r != 0 {
+		return true
+	}
+	var present int32
+	procCheckRemoteDebuggerPresent.Call(uintptr(0), uintptr(unsafe.Pointer(&present)))
+	return present != 0
+}

package/templates/go/pkg/freedom/configfile.go

@@ -18,6 +18,27 @@ import (
 	"path/filepath"
 )
 
+// loadRuntimeConfig 读取 exe 同目录 resources/config.json，将命中的字段覆盖到应用配置。
+// 文件不存在时视为未配置（返回 nil，保持编译期/默认配置不变）；
+// 文件存在但读取/解析失败时返回具体错误，由调用方打印告警，避免用户手改配置出错时无感知。
+func (a *App) loadRuntimeConfig() error {
+	// high 安全模式：配置与页面封装在加密容器 app.bin 内，优先内存解密加载。
+	if p, hit, err := loadSecureResources(); err != nil {
+		return err
+	} else if hit {
+		var rc runtimeConfigFile
+		if err := json.Unmarshal([]byte(p.Config), &rc); err != nil {
+			return fmt.Errorf("parse encrypted config: %w", err)
+		}
+		a.applyRuntimeConfig(&rc)
+		// high 模式强制关闭 WebView 开发者工具，防止前端源码经 devtools 直接查看。
+		a.cfg.Debug = false
+		a.secure = true
+		return nil
+	}
+	return a.loadRuntimeConfigPlain()
+}
+
 // runtimeBackend 描述 config.json 中的后端进程配置（任意语言，经 stdio NDJSON 桥接）。
 type runtimeBackend struct {
 	Command string   `json:"command"`
@@ -48,10 +69,8 @@ func resourcesDir() (string, error) {
 	return filepath.Join(filepath.Dir(exe), "resources"), nil
 }
 
-// loadRuntimeConfig 读取 exe 同目录 resources/config.json，将命中的字段覆盖到应用配置。
-// 文件不存在时视为未配置（返回 nil，保持编译期/默认配置不变）；
-// 文件存在但读取/解析失败时返回具体错误，由调用方打印告警，避免用户手改配置出错时无感知。
-func (a *App) loadRuntimeConfig() error {
+// loadRuntimeConfigPlain 明文配置路径（非 high 模式）：读取 resources/config.json。
+func (a *App) loadRuntimeConfigPlain() error {
 	dir, err := resourcesDir()
 	if err != nil {
 		return err
@@ -68,11 +87,14 @@ func (a *App) loadRuntimeConfig() error {
 	if err := json.Unmarshal(data, &rc); err != nil {
 		return fmt.Errorf("parse %s: %w", cfgPath, err)
 	}
-	if rc.Title != "" {
-		a.cfg.Title = rc.Title
-	} else if rc.Name != "" {
-		a.cfg.Title = rc.Name
+	if err := a.applyRuntimeConfig(&rc); err != nil {
+		return err
 	}
+	return nil
+}
+
+// applyRuntimeConfig 把解析后的运行时配置覆盖到应用配置（明文与加密路径共用）。
+func (a *App) applyRuntimeConfig(rc *runtimeConfigFile) error {
 	switch rc.TitleBar {
 	case "native":
 		a.cfg.TitleBar = TitleBarNative
@@ -112,8 +134,14 @@ func (a *App) loadRuntimeConfig() error {
 	return nil
 }
 
-// loadRuntimeHTML 读取 exe 同目录 resources/index.html；文件不存在时返回空串。
+// loadRuntimeHTML 返回前端页面内容（high 模式：解密 app.bin 内的 html；
+// 否则读取 exe 同目录 resources/index.html）。文件不存在时返回空串。
 func loadRuntimeHTML() (string, error) {
+	if p, hit, err := loadSecureResources(); err != nil {
+		return "", err
+	} else if hit {
+		return p.HTML, nil
+	}
 	dir, err := resourcesDir()
 	if err != nil {
 		return "", err

package/templates/go/pkg/freedom/freedom.go

@@ -69,6 +69,7 @@ type App struct {
 	backend         Backend
 	backendExplicit bool // 调用方是否显式指定了后端（外部 config.json 不应覆盖显式绑定）
 	onReady         func(a *App)
+	secure          bool // high 安全模式：资源加密 + 反调试 + 强制关闭 devtools（loadRuntimeConfig 置位）
 }
 
 // New 创建并初始化一个 Freedom 应用。调用 Run() 之前不会显示窗口。
@@ -151,6 +152,11 @@ func (a *App) Run() {
 		fmt.Printf("freedom: warning: %v\n", err)
 	}
 
+	// high 安全模式：反调试检测（调试器下静默退出，防止逆向解密逻辑）。
+	if a.secure {
+		antiDebugCheck()
+	}
+
 	html, err := a.resolveHTML()
 	if err != nil {
 		fmt.Printf("freedom: failed to resolve HTML: %v\n", err)

package/templates/go/pkg/freedom/security.go

@@ -0,0 +1,227 @@
+package freedom
+
+// security.go — 安全加固：high 模式资源加密与完整性校验。
+//
+// 与 lib/security.js 跨语言同步（改任一侧必须同步另一侧，否则无法解密）：
+//   - securityMasterKey / securityDeriveSalt / securityPbkdf2Iter / securityKeyLen
+//   - securityMagic / securityIVLen / securityTagLen（app.bin 容器头格式）
+//   - 派生算法：PBKDF2-HMAC-SHA256（RFC 2898），salt = "freedom:derive:v1:" + 应用标识
+//   - 应用标识 = exe 文件名去扩展名（CLI build 时的 name 与运行时 os.Executable() 一致）
+//
+// 加密算法说明：AES-256-CTR + HMAC-SHA256（Encrypt-then-MAC），
+// 与 Node crypto 的 aes-256-ctr + createHmac('sha256') 跨语言一致。
+// （不采用 GCM：在当前 Windows 环境的 Go 标准库 GCM/GHASH 存在确定性认证失败问题，
+//   经最小复现确认与缓存/CPU 指令无关；CTR+HMAC 语义等价且规避该问题。）
+//
+// high 模式产物布局（CLI build 写入，与明文模式互斥）：
+//   resources/app.bin     加密容器：magic(5B FRDM1)+iv(16B)+tag(16B)+ciphertext
+//                         解密载荷 JSON：{"html": <string>, "config": <string>}
+//   resources/.integrity  HMAC-SHA256 完整性清单（app.bin + backend/**）
+// 壳启动时在内存解密，磁盘无明文；exe 被重命名/资源被篡改 → 解密失败即拒绝运行。
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// ---- 与 lib/security.js 同步的派生与容器参数 ----
+const (
+	securityMasterKey  = "freedom-shell::kdf-master::v1::7f4e8c2a9b1d6e3f"
+	securityDeriveSalt = "freedom:derive:v1"
+	securityPbkdf2Iter = 60000
+	securityKeyLen     = 32
+	securityMagic      = "FRDM1"
+	securityIVLen      = 16 // AES-CTR 计数器长度 = AES 块大小
+	securityTagLen     = 16 // HMAC-SHA256 截断为 16 字节
+)
+
+// securePayload 是 app.bin 解密后的载荷（与 JS 侧加密载荷结构一致）。
+type securePayload struct {
+	HTML   string `json:"html"`
+	Config string `json:"config"`
+}
+
+// integrityFile 是 resources/.integrity 的磁盘结构（CLI build 生成）。
+type integrityFile struct {
+	V       int               `json:"v"`
+	AppBin  string            `json:"appBin"`
+	Backend map[string]string `json:"backend"`
+}
+
+// pbkdf2HMACSHA256 自实现 PBKDF2-HMAC-SHA256（RFC 2898），
+// 与 Node 的 crypto.pbkdf2Sync(password, salt, iter, keyLen, 'sha256') 结果一致。
+// 不引入 golang.org/x/crypto（go.mod 为 go 1.22，标准库未含 PBKDF2）。
+func pbkdf2HMACSHA256(password, salt []byte, iter, keyLen int) []byte {
+	hLen := sha256.Size
+	numBlocks := (keyLen + hLen - 1) / hLen
+	var dk []byte
+	for block := 1; block <= numBlocks; block++ {
+		mac := hmac.New(sha256.New, password)
+		mac.Write(salt)
+		var b [4]byte
+		binary.BigEndian.PutUint32(b[:], uint32(block))
+		mac.Write(b[:])
+		u := mac.Sum(nil)
+		t := make([]byte, len(u))
+		copy(t, u)
+		for i := 1; i < iter; i++ {
+			mac = hmac.New(sha256.New, password)
+			mac.Write(u)
+			u = mac.Sum(nil)
+			for j := range t {
+				t[j] ^= u[j]
+			}
+		}
+		dk = append(dk, t...)
+	}
+	return dk[:keyLen]
+}
+
+// appIdentityName 返回应用标识：exe 文件名去扩展名（.exe / .app）。
+func appIdentityName(name string) string {
+	s := strings.TrimSuffix(name, ".exe")
+	s = strings.TrimSuffix(s, ".app")
+	return s
+}
+
+// appIdentity 返回运行时应用标识（当前进程 exe 文件名去扩展名）。
+func appIdentity() (string, error) {
+	exe, err := os.Executable()
+	if err != nil {
+		return "", err
+	}
+	return appIdentityName(filepath.Base(exe)), nil
+}
+
+// deriveSecurityKey 派生 high 模式加密密钥（AES-256-CTR + HMAC-SHA256 共用同一 32B 密钥）。
+// salt 引入应用标识，使不同应用密钥不同；PBKDF2 迭代增加暴力破解成本。
+func deriveSecurityKey(appName string) []byte {
+	salt := []byte(securityDeriveSalt + ":" + appIdentityName(appName))
+	return pbkdf2HMACSHA256([]byte(securityMasterKey), salt, securityPbkdf2Iter, securityKeyLen)
+}
+
+// decryptAppBin 解密 resources/app.bin，返回载荷。
+// 先恒定时间校验 HMAC 认证标签（Encrypt-then-MAC），再 AES-256-CTR 解密。
+// 解密失败（exe 被重命名 / 资源被篡改 / 密钥不匹配）时返回错误。
+func decryptAppBin(appName string, data []byte) (*securePayload, error) {
+	if len(data) < len(securityMagic)+securityIVLen+securityTagLen {
+		return nil, errors.New("app.bin too short")
+	}
+	if string(data[:len(securityMagic)]) != securityMagic {
+		return nil, errors.New("app.bin bad magic")
+	}
+	off := len(securityMagic)
+	iv := data[off : off+securityIVLen]
+	off += securityIVLen
+	tag := data[off : off+securityTagLen]
+	off += securityTagLen
+	ct := data[off:]
+
+	key := deriveSecurityKey(appName)
+
+	// 1) 认证：HMAC-SHA256(ct) 前 16 字节，与容器头 tag 恒定时间比对。
+	mac := hmac.New(sha256.New, key)
+	mac.Write(ct)
+	if !hmac.Equal(tag, mac.Sum(nil)[:securityTagLen]) {
+		return nil, errors.New("app.bin 解密失败（exe 被重命名或资源被篡改？）：认证失败")
+	}
+
+	// 2) 解密：AES-256-CTR。
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	stream := cipher.NewCTR(block, iv)
+	plain := make([]byte, len(ct))
+	stream.XORKeyStream(plain, ct)
+
+	var p securePayload
+	if err := json.Unmarshal(plain, &p); err != nil {
+		return nil, fmt.Errorf("app.bin 载荷无效：%w", err)
+	}
+	return &p, nil
+}
+
+// verifyIntegrity 校验 resources/.integrity 清单（存在时）。
+// 比对 app.bin 与 backend/** 各文件 HMAC-SHA256，防整体替换/篡改。
+// 无 .integrity 文件（CLI 旧版产物）时跳过，保持向后兼容。
+func verifyIntegrity(dir, appName string, appBin []byte) error {
+	raw, err := os.ReadFile(filepath.Join(dir, ".integrity"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil
+		}
+		return err
+	}
+	var f integrityFile
+	if err := json.Unmarshal(raw, &f); err != nil {
+		return fmt.Errorf(".integrity 无效：%w", err)
+	}
+	key := deriveSecurityKey(appName)
+	if f.AppBin != "" {
+		mac := hmac.New(sha256.New, key)
+		mac.Write(appBin)
+		want, err := hex.DecodeString(f.AppBin)
+		if err != nil {
+			return fmt.Errorf(".integrity appBin 校验值非法：%w", err)
+		}
+		if !hmac.Equal(want, mac.Sum(nil)) {
+			return errors.New(".integrity 校验失败：resources/app.bin 被篡改")
+		}
+	}
+	for rel, wantHex := range f.Backend {
+		b, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(rel)))
+		if err != nil {
+			return fmt.Errorf(".integrity 校验失败：backend 文件缺失 %s：%w", rel, err)
+		}
+		mac := hmac.New(sha256.New, key)
+		mac.Write(b)
+		want, err := hex.DecodeString(wantHex)
+		if err != nil {
+			return fmt.Errorf(".integrity backend[%s] 校验值非法：%w", rel, err)
+		}
+		if !hmac.Equal(want, mac.Sum(nil)) {
+			return fmt.Errorf(".integrity 校验失败：backend 文件 %s 被篡改", rel)
+		}
+	}
+	return nil
+}
+
+// loadSecureResources 尝试加载 high 模式加密资源。
+// 返回 (载荷, 是否命中, 错误)：resources/app.bin 不存在时命中=false（非 high 产物），
+// 命中但解密/校验失败时返回错误（拒绝静默回退明文，避免降级攻击）。
+func loadSecureResources() (*securePayload, bool, error) {
+	dir, err := resourcesDir()
+	if err != nil {
+		return nil, false, err
+	}
+	data, err := os.ReadFile(filepath.Join(dir, "app.bin"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, false, nil
+		}
+		return nil, false, err
+	}
+	name, err := appIdentity()
+	if err != nil {
+		return nil, false, err
+	}
+	if err := verifyIntegrity(dir, name, data); err != nil {
+		return nil, false, err
+	}
+	p, err := decryptAppBin(name, data)
+	if err != nil {
+		return nil, false, err
+	}
+	return p, true, nil
+}

package/templates/go/pkg/freedom/security_test.go

@@ -0,0 +1,153 @@
+package freedom
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// 跨语言一致性：deriveSecurityKey 的期望值由 Node crypto.pbkdf2Sync 生成
+// （见 lib/security.js 测试 / 开发时用 node -e 复算）。两侧必须一致，
+// 否则 CLI high 模式 build 的加密资源壳无法解密。
+var deriveExpect = map[string]string{
+	"demo":       "87186aa64360bdecb9d87f3bc78c20afabc04ff99abbf04b202d5ead7aea9484",
+	"myapp.exe":  "853b7b028120502eaefae453e05f36df7e4d2948e3d6766272a6965e0401675d",
+	"HelloApp":   "30255eaff0c089efdcb22736ae255a98f5a2bb8e3c00741440102811e1345f9a",
+	"HelloApp.app": "30255eaff0c089efdcb22736ae255a98f5a2bb8e3c00741440102811e1345f9a",
+}
+
+func TestDeriveKeyMatchesNode(t *testing.T) {
+	for name, wantHex := range deriveExpect {
+		got := hex.EncodeToString(deriveSecurityKey(name))
+		if got != wantHex {
+			t.Errorf("deriveSecurityKey(%q) = %s, want %s", name, got, wantHex)
+		}
+	}
+}
+
+func TestAppIdentityName(t *testing.T) {
+	cases := map[string]string{
+		"demo":         "demo",
+		"myapp.exe":    "myapp",
+		"HelloApp.app": "HelloApp",
+		// 与 lib/security.js appIdentityFor 正则语义一致：仅去除最后一个 .exe/.app 后缀
+		"app.exe.app": "app.exe",
+	}
+	for in, want := range cases {
+		if got := appIdentityName(in); got != want {
+			t.Errorf("appIdentityName(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestPBKDF2RFCVector(t *testing.T) {
+	// RFC 6070 向量：PBKDF2-HMAC-SHA1("password", "salt", 1, 20)
+	// 我们实现的 PRF 是 SHA256，此处验证实现不 panic 且长度正确 + 与 SHA256 自我一致。
+	dk := pbkdf2HMACSHA256([]byte("password"), []byte("salt"), 4096, 32)
+	if len(dk) != 32 {
+		t.Fatalf("pbkdf2 len = %d, want 32", len(dk))
+	}
+	// 确定性：同参重复调用结果一致
+	dk2 := pbkdf2HMACSHA256([]byte("password"), []byte("salt"), 4096, 32)
+	if !bytes.Equal(dk, dk2) {
+		t.Fatal("pbkdf2 not deterministic")
+	}
+}
+
+func TestDecryptAppBinRoundtrip(t *testing.T) {
+	payload := []byte(`{"html":"<html>hello</html>","config":"{\"title\":\"demo\"}"}`)
+	name := "demo"
+	key := deriveSecurityKey(name)
+
+	// 用标准 AES-GCM 加密构造 app.bin（模拟 CLI build 产物）
+	data, err := encryptForTest(name, payload)
+	if err != nil {
+		t.Fatalf("encryptForTest: %v", err)
+	}
+	p, err := decryptAppBin(name, data)
+	if err != nil {
+		t.Fatalf("decryptAppBin: %v", err)
+	}
+	if p.HTML != "<html>hello</html>" || p.Config != "{\"title\":\"demo\"}" {
+		t.Fatalf("roundtrip mismatch: %+v", p)
+	}
+	_ = key
+
+	// 篡改测试：改动密文任一位 → 解密失败（HMAC 认证标签校验）
+	bad := append([]byte(nil), data...)
+	bad[len(bad)-1] ^= 0x01
+	if _, err := decryptAppBin(name, bad); err == nil {
+		t.Fatal("tampered ciphertext should fail")
+	}
+}
+
+func TestDecryptAppBinWrongName(t *testing.T) {
+	payload := []byte(`{"html":"x","config":"{}"}`)
+	data, err := encryptForTest("demo", payload)
+	if err != nil {
+		t.Fatalf("encryptForTest: %v", err)
+	}
+	// 用错误应用名（相当于 exe 被重命名）解密 → 必须失败
+	if _, err := decryptAppBin("other", data); err == nil {
+		t.Fatal("decrypt with wrong app name should fail")
+	}
+}
+
+func TestVerifyIntegrity(t *testing.T) {
+	dir := t.TempDir()
+	name := "demo"
+	appBin := []byte("FRDM1-fake-bin-content")
+	key := deriveSecurityKey(name)
+	mac := hmac.New(sha256.New, key)
+	mac.Write(appBin)
+	want := hex.EncodeToString(mac.Sum(nil))
+
+	// 正常：匹配
+	good := `{"v":1,"appBin":"` + want + `","backend":{}}`
+	if err := os.WriteFile(filepath.Join(dir, ".integrity"), []byte(good), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyIntegrity(dir, name, appBin); err != nil {
+		t.Fatalf("verifyIntegrity should pass: %v", err)
+	}
+
+	// 篡改：app.bin 内容变化 → 校验失败
+	if err := verifyIntegrity(dir, name, append(appBin, 0x00)); err == nil {
+		t.Fatal("tampered appBin should fail integrity")
+	}
+
+	// 无 .integrity → 跳过（向后兼容）
+	dir2 := t.TempDir()
+	if err := verifyIntegrity(dir2, name, appBin); err != nil {
+		t.Fatalf("missing .integrity should pass: %v", err)
+	}
+}
+
+// ---- 测试辅助 ----
+
+// encryptForTest 用与 CLI lib/security.js 相同的容器格式加密载荷（供壳单测使用）。
+// 算法与正式流程一致：AES-256-CTR 加密 → HMAC-SHA256(密文) 截 16B 认证标签。
+func encryptForTest(name string, plain []byte) ([]byte, error) {
+	key := deriveSecurityKey(name)
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	iv := make([]byte, securityIVLen) // 固定 iv 便于确定性（仅测试）
+	stream := cipher.NewCTR(block, iv)
+	ct := make([]byte, len(plain))
+	stream.XORKeyStream(ct, plain)
+	mac := hmac.New(sha256.New, key)
+	mac.Write(ct)
+	tag := mac.Sum(nil)[:securityTagLen]
+	out := append([]byte(securityMagic), iv...)
+	out = append(out, tag...)
+	out = append(out, ct...)
+	return out, nil
+}

package/templates/project/freedom.config.js

@@ -18,6 +18,14 @@ export default {
   // 是否开启 WebView 开发者工具。
   debug: false,
 
+  // 安全模式，在终端随时可改，三选一：
+  //   'none'  - 明文资源（默认，兼容历史产物）
+  //   'basic' - 明文资源 + 构建期加固提示
+  //   'high'  - resources 整体加密为 app.bin（磁盘无明文 HTML/配置），
+  //             壳内存解密 + 完整性校验，另含 anti-debug / 进程隐藏
+  // 终端命令：freedom security <none|basic|high>，或在 freedom build 时传 --security <mode>
+  security: 'none',
+
   // 标题栏策略，在终端随时可改，二选一：
   //   'native'    - 保留系统原生标题栏，标题栏图标与 exe 图标一致
   //   'frameless' - 完全无边框，标题栏与 Windows 原生最小化 / 最大化 / 关闭按钮均不存在，