@yufengtadian/freedom-cli 1.13.2 → 1.14.0-preview

package/templates/desktop/backend/desktop.mjs

@@ -21,12 +21,18 @@ function write(msg) {
 }
 
 // ---- CLI 定位：优先 cli-entry.json（freedom desktop 打包时写入），再退到环境变量 ----
+// cliMeta.root 一并带出：high 模式下本文件被解到系统临时目录，
+// 不能再靠 `__dirname/../package.json` 反推 CLI 包版本，只能读容器里的 root。
+const cliMeta = { entry: null, root: null };
 function cliEntry() {
   const candidates = [];
-  try {
-    const meta = JSON.parse(fs.readFileSync(path.join(__dirname, 'cli-entry.json'), 'utf8'));
-    if (meta && meta.entry) candidates.push(meta.entry);
-  } catch { /* 缺文件走后续回退 */ }
+  if (!cliMeta.entry) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(path.join(__dirname, 'cli-entry.json'), 'utf8'));
+      if (meta && meta.entry) { cliMeta.entry = meta.entry; cliMeta.root = meta.root || null; }
+    } catch { /* 缺文件走后续回退 */ }
+  }
+  if (cliMeta.entry && fs.existsSync(cliMeta.entry)) return cliMeta.entry;
   if (process.env.FREEDOM_CLI_ENTRY) candidates.push(process.env.FREEDOM_CLI_ENTRY);
   for (const c of candidates) {
     if (c && fs.existsSync(c)) return c;
@@ -108,10 +114,14 @@ function stopDev() {
 const api = {
   async 'app.info'() {
     const entry = cliEntry();
-    const pkg = entry ? (() => { try { return JSON.parse(fs.readFileSync(path.join(path.dirname(entry), '..', 'package.json'), 'utf8')); } catch { return {}; } })() : {};
+    const readVersion = (base) => {
+      try { return JSON.parse(fs.readFileSync(path.join(base, 'package.json'), 'utf8')).version || null; } catch { return null; }
+    };
+    const cliVersion = (entry ? readVersion(path.join(path.dirname(entry), '..')) : null)
+      || (cliMeta.root ? readVersion(cliMeta.root) : null);
     return {
       cliEntry: entry,
-      cliVersion: pkg.version || null,
+      cliVersion,
       platform: `${process.platform}-${process.arch}`,
       nodeVersion: process.version,
       home: os.homedir(),

package/templates/desktop/freedom.config.js

@@ -15,7 +15,10 @@ export default {
   staticHtml: 'app.html',
 
   titlebar: 'native',
-  security: 'none',
+  // 闭源自举：Desktop 自身也要经得起逆向——前端 app.html、config.json 与后端
+  // backend/*（含 cli-entry.json）整体进 FRDM2 容器，磁盘只留 app.bin + .integrity，
+  // 运行期由壳解密到私有临时目录（退出即删，崩溃残留由下次启动回收）。
+  security: 'high',
   outDir: 'dist',
 
   // 应用图标：构建时注入 exe（Windows 用 rcedit 写 PE 资源），运行时壳层经

package/templates/go/go.mod

@@ -3,3 +3,6 @@ module freedom-cli-shell
 go 1.26.5
 
 require github.com/webview/webview_go v0.0.0-20240831120633-6173450d4dd6
+
+// 与仓库根 go.mod 同步的本地补丁副本：WebKitGTK 4.0/4.1 依赖名按构建标签选择。
+replace github.com/webview/webview_go => ./third_party/webview_go

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

@@ -0,0 +1,69 @@
+//go:build linux
+
+package freedom
+
+// 反调试（Linux 实现）：high 安全模式下由 Run() 在资源解密前后各调用一次，
+// 与 Windows 侧同一语义——**探测失败一律记未命中**，只在确证被附加调试器时退出，
+// 误杀正常用户的代价高于多一路信号的收益。
+//
+// 两道信号：
+//  1. ptrace(PTRACE_TRACEME)：本进程已被别的进程 attach 时返回 EPERM —— 这是
+//     "GDB 已挂上来"的确证。TRACEME 是一次性的（成功后无法再 DETACH 复位），
+//     故整个进程生命周期只探测一次并缓存结论；Run 里的"解密前 / 解密后"两次调用
+//     因此共享同一结论——本就只能挡住「启动时已挂调试器」，运行中途 attach
+//     （gdb -p）要等下次启动才被抓到，这是诚实的能力边界。
+//     **已知边界**：本进程此前处于停止/跟踪-停止状态（被 SIGSTOP 过）时 TRACEME
+//     也会 EPERM，理论上存在误判窗口；桌面壳正常生命周期内不走这条路，且
+//     非 high 模式完全不检测，可用 FREEDOM_DISABLE_ANTIDEBUG=1 关闭。
+//  2. PR_SET_DUMPABLE=0：不是检测而是加固——内核不再产出 core dump，且非属主、
+//     非 ptrace 授权的进程读不到 /proc/<pid>/mem 与 /proc/<pid>/maps。
+//     副作用是本进程写的文件属主不再是 dumpable 语义下的自己（/tmp 下按目录名
+//     隔离的私有临时目录不受影响）。
+//
+// 未纳入：/proc/<pid>/status 的 TracerPid 字段——读它本身没问题，但攻击者 attach
+// 前后改一行 status 即可绕过（同一函数里 ptrace 系统调用才是硬证据），徒增误报源。
+
+import (
+	"os"
+	"sync"
+	"syscall"
+)
+
+// antiDebugCheck 命中即退出（退出码 77，与 Windows 侧一致，不显示窗口、不回显原因）。
+func antiDebugCheck() {
+	if debuggerPresent() {
+		os.Exit(77)
+	}
+}
+
+// debuggerPresent 汇总 Linux 侧信号。
+func debuggerPresent() bool {
+	if ptracemeRejectedOnce() {
+		return true
+	}
+	makeNonDumpable() // 未命中也要落地下一步加固（core dump / /proc 读内存收紧）
+	return false
+}
+
+var (
+	tracemeOnce     = new(sync.Once) // 指针：单测需要可复位的实例
+	tracemeDetected bool
+)
+
+// ptracemeRejectedOnce 缓存一次性 TRACEME 结论（见文件头：TRACEME 不可复位）。
+func ptracemeRejectedOnce() bool {
+	tracemeOnce.Do(func() { tracemeDetected = ptracemeRejected() })
+	return tracemeDetected
+}
+
+// ptracemeRejected 报告 PTRACE_TRACEME 是否被拒（被拒 = 已有调试器附加）；
+// 变量形式便于单测替换，生产路径只会被调用一次。
+var ptracemeRejected = func() bool {
+	r, _, errno := syscall.RawSyscall(syscall.SYS_PTRACE, uintptr(syscall.PTRACE_TRACEME), 0, 0)
+	return r != 0 || errno != 0
+}
+
+// makeNonDumpable 关闭 core dump 并收紧 /proc/<pid>/* 的读取授权；失败按未命中处理。
+var makeNonDumpable = func() {
+	syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_DUMPABLE, 0, 0)
+}

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

@@ -1,7 +1,9 @@
-//go:build !windows
+//go:build !windows && !linux
 
 package freedom
 
-// 反调试（非 Windows 平台空实现）。macOS/Linux 的调试器检测依赖
-// ptrace / task_for_pid 等平台特定 API，本版本不做；如需加强在对应平台文件扩展。
+// 反调试（macOS 占位实现）。Linux 侧已实装在 anti_debug_linux.go
+// （PTRACE_TRACEME 一次性探测 + PR_SET_DUMPABLE=0 加固）；macOS 需要
+// ptrace(PT_DENY_ATTACH) / task_for_pid 等平台 API，本机无 Apple 设备无法验证，
+// 故留空不装——诚实的"未实现"优于未验证的代码。
 func antiDebugCheck() {}

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

@@ -6,19 +6,22 @@ package freedom
 // 命中时静默退出（退出码 77，无提示），防止攻击者在调试器下单步追踪
 // 密钥派生 / 容器解密逻辑，或直接读内存里的明文密钥。
 //
-// 六道独立信号（任一命中即判定被调试），覆盖不同层次的附加手段：
+// 七道独立信号（任一命中即判定被调试），覆盖不同层次的附加手段：
 //   1. IsDebuggerPresent          —— 读 PEB.BeingDebugged 的快捷 API（最易被 hook 篡改）；
 //   2. CheckRemoteDebuggerPresent —— 内核调试器 / 远程调试器；
 //   3. 直接读 PEB.BeingDebugged    —— 不经 API，绕过"只 patch API 返回值"的调试辅助；
 //   4. NtQueryInformationProcess(ProcessDebugPort)          —— 调试端口句柄；
 //   5. NtQueryInformationProcess(ProcessDebugObjectHandle)  —— 调试对象（无端口也命中）；
-//   6. NtQueryInformationProcess(ProcessDebugFlags)         —— 标志位反向确认。
+//   6. NtQueryInformationProcess(ProcessDebugFlags)         —— 标志位反向确认；
+//   7. 线程上下文 DR0–DR3         —— 硬件断点（数据/内存断点常常不落在前六道上）。
 //
-// 未纳入的信号及原因：硬件断点（Dr7）需先 SuspendThread 再 GetThreadContext，
-// 对本线程调用实测返回 ERROR_ACCESS_DENIED（非挂起线程读不到上下文），
-// 为一次启动期检测去挂起自建线程不划算；时间差检测在 CI/低配机误判率高，
-// 误杀正常用户的代价高于其收益。所有信号都遵循"探测失败即视为未命中"，
-// 只在确证被调试时退出，杜绝误杀。
+// 第七道的实现约束：对本线程直接 GetThreadContext 会返回 ERROR_ACCESS_DENIED，
+// 故用 Toolhelp 枚举进程内线程、以 THREAD_GET_CONTEXT 打开后读取（不挂起任何线程），
+// 读不到上下文一律记未命中。只在启动期跑、只在 high 模式跑；
+// 已知局限：抓的是"检测时刻已设下的硬件断点"，运行中途 attach 再下断点不在射程内。
+//
+// 未纳入：时间差检测在 CI/低配机误判率高，误杀正常用户的代价高于其收益。
+// 所有信号都遵循"探测失败即视为未命中"，只在确证被调试时退出，杜绝误杀。
 //
 // 诚实边界：这些是抬升成本的对抗，不是不可绕过的墙。绕开者仍需逆向壳二进制、
 // 复现掩码后的主密钥与 PBKDF2 参数，并在无调试器环境下取密钥。
@@ -39,10 +42,12 @@ var (
 )
 
 // 进程信息类别（PROCESSINFOCLASS）与各类别的返回长度，编号与长度均为本机实测校准：
-// 	ProcessBasicInformation(0)  48 字节（x64，PEB 在偏移 8）
-// 	ProcessDebugPort(7)          8 字节（HANDLE）；len 给 4 会返回 STATUS_INFO_LENGTH_MISMATCH
-// 	ProcessDebugObjectHandle(30) 8 字节；未被调试时返回 STATUS_PORT_NOT_SET(0xC0000353)
-// 	ProcessDebugFlags(31)        4 字节（ULONG）；未被调试时返回 1
+//
+//	ProcessBasicInformation(0)  48 字节（x64，PEB 在偏移 8）
+//	ProcessDebugPort(7)          8 字节（HANDLE）；len 给 4 会返回 STATUS_INFO_LENGTH_MISMATCH
+//	ProcessDebugObjectHandle(30) 8 字节；未被调试时返回 STATUS_PORT_NOT_SET(0xC0000353)
+//	ProcessDebugFlags(31)        4 字节（ULONG）；未被调试时返回 1
+//
 // 注意 30/31 两号易写成 32/33（那是 LUIDDeviceMapsEnabled / BreakOnTermination），
 // 编号或长度写错不会报错、只会静默失去一路信号，故此处配套测试锁死。
 const (
@@ -66,7 +71,7 @@ func antiDebugCheck() {
 	}
 }
 
-// debuggerPresent 汇总六道信号。lazy DLL 加载失败（Proc.Find 出错）时该信号记为未命中。
+// debuggerPresent 汇总七道信号。lazy DLL 加载失败（Proc.Find 出错）时该信号记为未命中。
 func debuggerPresent() bool {
 	if r, _, _ := procIsDebuggerPresent.Call(); r != 0 {
 		return true
@@ -90,6 +95,10 @@ func debuggerPresent() bool {
 	if r, ok := ntQueryProcessInfo(processDebugFlags, debugFlagsSize); ok && r == 0 {
 		return true
 	}
+	// 硬件断点：数据断点 / 内存断点常不改动上面任何一处状态，只能看 DR0–DR3。
+	if hardwareBreakpointSet() {
+		return true
+	}
 	return false
 }
 
@@ -138,3 +147,118 @@ func pebBeingDebuggedSet() bool {
 	}
 	return *(*byte)(unsafe.Pointer(info.pebAddress + pebBeingDebuggedOff)) != 0
 }
+
+// ---- 第七道信号：硬件断点（DR0–DR3）----
+//
+// 数据断点与部分内存断点不改 PEB、不建调试端口，只写在线程上下文的调试寄存器里。
+// 对本线程调 GetThreadContext 会被拒（ERROR_ACCESS_DENIED），因此走 Toolhelp 枚举
+// 进程内线程 + THREAD_GET_CONTEXT 读取；任何一步失败都记未命中（宁漏不误杀）。
+
+const (
+	th32csSnapThread = 0x00000002
+	threadQueryInfo  = 0x0040
+	threadGetContext = 0x0010
+	threadAllAccess  = threadQueryInfo | threadGetContext
+	// CONTEXT_AMD64(0x00100000) | CONTEXT_DEBUG_REGISTERS(0x10)：不置此标志，
+	// GetThreadContext 根本不回填 Dr0–Dr7（读到的只是栈上残值，会误报）。
+	contextDebugRegisters = 0x00100000 | 0x10
+	dr7LocalBitsMask      = 0b1111
+	invalidHandleVal      = ^uintptr(0)
+	threadEntrySize       = unsafe.Sizeof(threadEntry32{})
+)
+
+var (
+	procCreateToolhelp32Snapshot = kernel32AntiDebug.NewProc("CreateToolhelp32Snapshot")
+	procThread32First            = kernel32AntiDebug.NewProc("Thread32First")
+	procThread32Next             = kernel32AntiDebug.NewProc("Thread32Next")
+	procOpenThread               = kernel32AntiDebug.NewProc("OpenThread")
+	procGetThreadContext         = kernel32AntiDebug.NewProc("GetThreadContext")
+)
+
+// threadEntry32 是 Toolhelp 线程快照项（x64 布局：32 字节，末尾有对齐填充）。
+type threadEntry32 struct {
+	dwSize       uint32
+	cntUsage     uint32
+	th32ThreadID uint32
+	th32OwnerPID uint32
+	tpBasePrio   int32
+	dwFlags      uint32
+	hModule      uintptr
+	_pad         uint32
+}
+
+// contextAMD64 是 Windows x64 CONTEXT 的局部视图，偏移严格按 winnt.h：
+// P1Home–P6Home 占 0x00–0x2F，ContextFlags@0x30，MxCsr@0x34，段寄存器 0x38–0x43，
+// EFlags@0x44，Dr0@0x48、Dr1@0x50、Dr2@0x58、Dr3@0x60、Dr6@0x68、Dr7@0x70，
+// 其后寄存器/XMM/XSTATE 一并归入 padding（总长取 0x400）。
+// 偏移错一位就会把 EFlags/残值当成断点地址（误杀），故 anti_debug_windows_test.go 逐字段挂断言。
+type contextAMD64 struct {
+	_            [48]byte
+	contextFlags uint32
+	_            [20]byte // MxCsr + 6 个段寄存器 + EFlags
+	dr0          uint64
+	dr1          uint64
+	dr2          uint64
+	dr3          uint64
+	dr6          uint64
+	dr7          uint64
+	_            [1024 - 120]byte
+}
+
+func hardwareBreakpointSet() bool {
+	for _, fn := range []uintptr{
+		procCreateToolhelp32Snapshot.Addr(), procThread32First.Addr(), procThread32Next.Addr(),
+		procOpenThread.Addr(), procGetThreadContext.Addr(),
+	} {
+		if fn == 0 {
+			return false // DLL 未加载成功：本信号记未命中
+		}
+	}
+	snap, _, _ := procCreateToolhelp32Snapshot.Call(th32csSnapThread, 0)
+	if snap == invalidHandleVal || snap == 0 {
+		return false
+	}
+	defer syscall.CloseHandle(syscall.Handle(snap))
+	pid := uintptr(syscall.Getpid())
+	var te threadEntry32
+	te.dwSize = uint32(threadEntrySize)
+	for ok, _, _ := procThread32First.Call(snap, uintptr(unsafe.Pointer(&te))); ok != 0; ok, _, _ = procThread32Next.Call(snap, uintptr(unsafe.Pointer(&te))) {
+		if te.th32OwnerPID != uint32(pid) {
+			continue // 只看本进程的线程
+		}
+		if threadHasHardwareBreakpoint(uintptr(te.th32ThreadID)) {
+			return true
+		}
+	}
+	return false
+}
+
+// threadHasHardwareBreakpoint 读一个线程的调试寄存器；读不到即未命中。
+// 刻意不 SuspendThread：挂起 Go 运行时线程有死锁风险，而调试器 attach 时本就把线程挂住了
+// ——那种状态下 GetThreadContext 才会成功并带回 Dr0–Dr7，正是这一路要抓的场景。
+func threadHasHardwareBreakpoint(tid uintptr) bool {
+	h, _, _ := procOpenThread.Call(threadAllAccess, 0, tid)
+	if h == invalidHandleVal || h == 0 {
+		return false
+	}
+	defer syscall.CloseHandle(syscall.Handle(h))
+	// 16 字节留白供 round16 向上对齐（GetThreadContext 要求 CONTEXT 16 字节对齐）。
+	var ctxRaw [unsafe.Sizeof(contextAMD64{}) + 16]byte
+	ctx := (*contextAMD64)(unsafe.Pointer(round16(&ctxRaw[0])))
+	ctx.contextFlags = contextDebugRegisters // 输入：只取调试寄存器
+	r, _, _ := procGetThreadContext.Call(h, uintptr(unsafe.Pointer(ctx)))
+	if r == 0 || ctx.contextFlags&contextDebugRegisters == 0 {
+		return false // 线程在跑 / 权限不足 / 未回填：一律未命中
+	}
+	return (ctx.dr7&dr7LocalBitsMask) != 0 &&
+		(ctx.dr0 != 0 || ctx.dr1 != 0 || ctx.dr2 != 0 || ctx.dr3 != 0)
+}
+
+// round16 把切片首地址向上对齐到 16 字节（GetThreadContext 要求 CONTEXT 16 字节对齐）。
+func round16(p *byte) *byte {
+	a := uintptr(unsafe.Pointer(p))
+	if d := a % 16; d != 0 {
+		a += 16 - d
+	}
+	return (*byte)(unsafe.Pointer(a))
+}

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

@@ -12,6 +12,7 @@ import _ "embed"
 //	window.freedom.emit(event, data)                  // 应用内事件广播（后端 Eval 亦使用）
 //
 // bridge 由 go-webview2 的 Bind 机制注册，返回 Promise，Go 侧自动 JSON 编解码。
+//
 //go:embed assets/freedom.js
 var jsSDK string
 

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

@@ -42,11 +42,11 @@ type ProcBackend struct {
 	maxLine int // 单条 stdout 行（一次响应）上限字节；超限即那条响应过大，不得中断整个通道
 
 	// —— W4 崩溃自愈（对标 Tauri shell spawn 的失败处理 / sidecar 重启）——
-	rp        RestartPolicy   // 重启策略（零值=不重启，保持旧行为）
-	gen       int             // 每次拉起递增；readLoop 据此识别"自己那一期"，过期实例不触发重启
-	pdone     chan struct{}   // 当前这期进程 Wait 完成后由 readLoop 关闭（Close 等它，不再自己 Wait，避免双重 Wait）
-	attempts  int             // 连续崩溃重启计数
-	startedAt time.Time       // 本期进程启动时刻（存活够久则重置 attempts）
+	rp        RestartPolicy // 重启策略（零值=不重启，保持旧行为）
+	gen       int           // 每次拉起递增；readLoop 据此识别"自己那一期"，过期实例不触发重启
+	pdone     chan struct{} // 当前这期进程 Wait 完成后由 readLoop 关闭（Close 等它，不再自己 Wait，避免双重 Wait）
+	attempts  int           // 连续崩溃重启计数
+	startedAt time.Time     // 本期进程启动时刻（存活够久则重置 attempts）
 }
 
 // RestartPolicy 是后端进程崩溃后的自动重启策略（经 SetRestartPolicy 启用）。

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

@@ -18,10 +18,10 @@ import (
 
 const (
 	wmSize         = 0x0005
-	wmMove           = 0x0003
+	wmMove         = 0x0003
 	wmExitSizeMove = 0x0212
-	wmSetFocus       = 0x0007
-	wmKillFocus      = 0x0008
+	wmSetFocus     = 0x0007
+	wmKillFocus    = 0x0008
 
 	sizeMaximized = 1
 	sizeMinimized = 2
@@ -244,8 +244,8 @@ func enumMonitorsProc(hmon, hdc, lprci, data uintptr) uintptr {
 			Width:  int(mi.rcMonitor.right - mi.rcMonitor.left),
 			Height: int(mi.rcMonitor.bottom - mi.rcMonitor.top),
 			WorkX:  int(mi.rcWork.left), WorkY: int(mi.rcWork.top),
-			WorkWidth:  int(mi.rcWork.right - mi.rcWork.left),
-			WorkHeight: int(mi.rcWork.bottom - mi.rcWork.top),
+			WorkWidth:   int(mi.rcWork.right - mi.rcWork.left),
+			WorkHeight:  int(mi.rcWork.bottom - mi.rcWork.top),
 			ScaleFactor: scale,
 			IsPrimary:   mi.dwFlags&monitorInfofPrimary != 0,
 		})

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

@@ -65,6 +65,11 @@ type Config struct {
 	MinHeight int
 	// Debug 为 true 时开启 WebView 开发者工具（目标平台支持时）。
 	Debug bool
+	// DisableAntiDebug 关闭 high 安全模式的调试器探测（见 antiDebugEnabled）。
+	// 默认 false：探测在位。仅在合法运行环境被误判（部分沙箱 / EDR / 虚拟化环境会让
+	// NtQueryInformationProcess 一类调用给出命中值）时由发布方显式置真。
+	// 关闭不影响容器解密与 .integrity 校验——那两道才是源码保护的本体。
+	DisableAntiDebug bool
 	// Backend 指定后端适配器。为空时默认使用内嵌 Go 后端（配合 Bind 使用）。
 	Backend Backend
 	// HTML 返回要加载到窗口的前端页面内容（内存加载，无本地端口）。
@@ -113,6 +118,10 @@ type App struct {
 	backendExplicit  bool
 	secureBackendDir string
 
+	// runtimeVersion = config.json / app.bin 容器里声明的「本应用」版本。
+	// 与编译期的 Version（通用壳的版本）分属两个版本域，自更新比较只认前者。
+	runtimeVersion string
+
 	// upMu 保护 upPending：CheckUpdate 验签通过的更新条目，install 桥接只认它
 	//（前端无法注入未验签的 URL/哈希）。见 updater.go。
 	upMu         sync.Mutex
@@ -231,7 +240,7 @@ func (a *App) Unbind(name string) {
 func (a *App) Run() {
 	// high 产物：解密前先跑一次反调试（此时密钥与明文都还没进内存），
 	// 解密后再跑一次（兜住"启动后才附加调试器"）。非 high 应用不受影响。
-	if hasSecureResources() {
+	if hasSecureResources() && a.antiDebugEnabled() {
 		antiDebugCheck()
 	}
 	// 通用壳：先加载 exe 同目录 resources/ 覆盖窗口与后端配置（CLI build 写入；
@@ -242,14 +251,19 @@ func (a *App) Run() {
 		var se *secureFatalError
 		if errors.As(err, &se) {
 			fmt.Printf("freedom: 安全模式资源校验失败，拒绝运行：%v\n", err)
-			return
+			// 退出码必须非零：Run 返回 nil 会让"拒跑"与"正常退出"在脚本与 CI 眼里同形，
+			// 而这条分支存在的意义正是"不能让它悄悄跑起来"。此处尚无 defer 注册
+			// （cleanupSecureBackend 在下一行才 defer），os.Exit 不会跳过清理。
+			os.Exit(exitSecureFatal)
 		}
 		fmt.Printf("freedom: warning: %v\n", err)
 	}
 	// high 模式的临时后端目录随进程退出清理（defer 早于后端 Close 注册 → 后于其执行）。
 	defer a.cleanupSecureBackend()
+	// Ctrl+C / SIGTERM / 控制台关闭：defer 不会执行，须显式清扫（见 installSecureShutdown）。
+	a.installSecureShutdown()
 	// high 模式：解密后复查调试器（见 Run 开头的"解密前一次"）。
-	if a.secure {
+	if a.secure && a.antiDebugEnabled() {
 		antiDebugCheck()
 	}
 	// 平台层回调（单实例转发/热键）经 currentApp 找到本实例推送事件。

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

@@ -35,14 +35,14 @@ func validCopyData(dwData uintptr, cbData uint32, lpData uintptr) bool {
 }
 
 type msgWindow struct {
-	mu        sync.Mutex
-	hwnd      uintptr
-	ready     chan struct{}
-	created   bool
-	hotkeys   map[string]uint32 // 前端 id → 热键数值 id
-	nextHKID  uint32
-	onHotkey  func(id string)
-	onData    func(payload []byte)
+	mu       sync.Mutex
+	hwnd     uintptr
+	ready    chan struct{}
+	created  bool
+	hotkeys  map[string]uint32 // 前端 id → 热键数值 id
+	nextHKID uint32
+	onHotkey func(id string)
+	onData   func(payload []byte)
 }
 
 var (

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

@@ -34,6 +34,11 @@ func secureFatal(err error) error {
 	return &secureFatalError{err: err}
 }
 
+// exitSecureFatal 是 high 模式拒绝运行时的进程退出码（见 freedom.go Run）。
+// 取 70 —— BSD sysexits 的 EX_SOFTWARE："这份产物本身不可信"，与 1（一般失败）、
+// 130（Ctrl+C 收尾）区分开，发布脚本据此认出这一具体事件。
+const exitSecureFatal = 70
+
 // runtimeBackend 描述 config.json 中的后端进程配置（任意语言，经 stdio NDJSON 桥接）。
 type runtimeBackend struct {
 	Command string   `json:"command"`
@@ -52,6 +57,7 @@ type runtimeUpdater struct {
 // 由 freedom CLI 在 build 阶段根据 freedom.config.js 生成；Name 仅作来源标记不应用。
 type runtimeConfigFile struct {
 	Name           string          `json:"name"`
+	Version        string          `json:"version"`
 	Title          string          `json:"title"`
 	TitleBar       string          `json:"titlebar"`
 	Width          int             `json:"width"`
@@ -64,6 +70,9 @@ type runtimeConfigFile struct {
 	URL            string          `json:"url"`
 	SingleInstance *bool           `json:"singleInstance"`
 	Updater        *runtimeUpdater `json:"updater"`
+	// Capabilities 收口前端可调用面。通用壳里编译不进应用作者的 Config 字面量，
+	// 没有这条透传则 freedom.config.js 写 capabilities 会被静默忽略（= 全开）。
+	Capabilities *Capabilities `json:"capabilities"`
 }
 
 // resourcesDirOverride 是单测缝：非空时替代 exe 同目录的 resources 定位。
@@ -102,6 +111,8 @@ func (a *App) loadRuntimeConfig() error {
 				return secureFatal(fmt.Errorf("后端源码解密落地失败：%w", err))
 			}
 			a.secureBackendDir = bdir
+			// 落盘完成即擦：载荷缓存会活到进程结束，后端源码没有理由跟着一起常驻。
+			scrubSecureBackendPayload(p)
 		}
 		a.applyRuntimeConfig(&rc)
 		// high 模式强制关闭 WebView 开发者工具，防止前端源码经 devtools 直接查看。
@@ -135,6 +146,15 @@ func (a *App) loadRuntimeConfigPlain() error {
 
 // applyRuntimeConfig 把解析后的运行时配置覆盖到应用配置（明文与加密路径共用）。
 func (a *App) applyRuntimeConfig(rc *runtimeConfigFile) {
+	// 应用版本：通用壳编译期注入的 Version 是「壳」的版本，不是「这个应用」的版本。
+	// 自更新比较必须用后者，否则要么永远报 uncomparable（壳未打戳时是 "dev"），
+	// 要么拿壳的版本号跟应用的清单比——换来的仍是同一个壳，更新永远收敛不了。
+	if rc.Version != "" {
+		a.runtimeVersion = rc.Version
+	}
+	if rc.Capabilities != nil && a.cfg.Capabilities == nil {
+		a.cfg.Capabilities = rc.Capabilities
+	}
 	// 窗口标题：config.json 的 title 覆盖编译期默认（"Freedom App"）。
 	if rc.Title != "" {
 		a.cfg.Title = rc.Title
@@ -193,6 +213,16 @@ func (a *App) applyRuntimeConfig(rc *runtimeConfigFile) {
 	}
 }
 
+// appVersion 返回「本应用」的版本：优先用 config.json / app.bin 容器里声明的值，
+// 回落编译期 Version（examples 自建壳走 ldflags 注入）。通用壳的 Version 是壳自己的
+// 版本域，拿它跟应用发布清单比是两个数在比——见 updater.go 的 CheckUpdate。
+func (a *App) appVersion() string {
+	if a != nil && a.runtimeVersion != "" {
+		return a.runtimeVersion
+	}
+	return Version
+}
+
 // backendWorkDir 返回后端进程的工作目录。
 func (a *App) backendWorkDir() (string, error) {
 	if a.secureBackendDir != "" {
@@ -201,6 +231,31 @@ func (a *App) backendWorkDir() (string, error) {
 	return resourcesDir()
 }
 
+// installSecureShutdown 注册信号退出通道（Run 调用）。
+//
+// 清扫顺序刻意是「先后端、后目录」：后端子进程的工作目录就是 high 模式解出的那个明文临时
+// 目录，它还活着时 Windows 会因文件被占用让 RemoveAll 静默失败——明文源码继续留在 %TEMP%，
+// 而信号路径紧接着就 os.Exit，下次启动的 GC 也帮不上（PID 仍存活）。ProcBackend.Close 自带
+// closed 幂等与 3s 等待上界，与 Run 正常退出的 defer 双跑无害。
+// 非 high 模式下 cleanupSecureBackend 是 no-op，但后端该停照样得停，故不再判安全档。
+func (a *App) installSecureShutdown() {
+	secureCleanup = func() {
+		a.closeBackendForShutdown()
+		a.cleanupSecureBackend()
+	}
+	installShutdownCleanup()
+}
+
+// closeBackendForShutdown 停后端子进程；未配置后端（nil）时为空操作。
+func (a *App) closeBackendForShutdown() {
+	if a.backend == nil {
+		return
+	}
+	if err := a.backend.Close(); err != nil {
+		fmt.Fprintf(os.Stderr, "freedom: shutdown backend close: %v\n", err)
+	}
+}
+
 // cleanupSecureBackend 删除 high 模式解出的临时后端目录（Run 退出时调用）。
 // 进程被强杀时目录会残留在系统临时区——内容仍可被下一次启动的壳重新解出，
 // 且明文源码本就来自内存，故不引入跨进程清扫。
@@ -208,7 +263,10 @@ func (a *App) cleanupSecureBackend() {
 	if a.secureBackendDir == "" {
 		return
 	}
-	_ = os.RemoveAll(a.secureBackendDir)
+	// 删不掉必须在退出前喊出来：这是「磁盘不留明文」承诺当场失守的时刻，静默等于隐瞒。
+	if err := os.RemoveAll(a.secureBackendDir); err != nil {
+		fmt.Fprintf(os.Stderr, "freedom: 明文后端临时目录未清除（后端源码可能仍可读取）：%s: %v\n", a.secureBackendDir, err)
+	}
 	a.secureBackendDir = ""
 }