@yufengtadian/freedom-cli 1.13.2 → 1.13.3

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 写入；
@@ -248,8 +257,10 @@ func (a *App) Run() {
 	}
 	// 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

@@ -52,6 +52,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 +65,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 定位。
@@ -135,6 +139,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 +206,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 +224,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 +256,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 = ""
 }
 

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

@@ -70,6 +70,7 @@ var masterKeyCipher = []byte{
 }
 
 // masterSecret 还原主密钥（PBKDF2 的 password）。
+// 生产路径请用 withMasterSecret：明文只存在于回调作用域内，返回前逐字节抹零。
 func masterSecret() []byte {
 	out := make([]byte, len(masterKeyCipher))
 	for i, b := range masterKeyCipher {
@@ -78,6 +79,21 @@ func masterSecret() []byte {
 	return out
 }
 
+// withMasterSecret 把还原出的主密钥交给 fn，并在 fn 返回后立刻抹零该缓冲区
+// （Go 的分配器会复用内存，留着明文等于给内存扫描留靶子）。
+func withMasterSecret(fn func(secret []byte)) {
+	secret := masterSecret()
+	defer clearBytes(secret)
+	fn(secret)
+}
+
+// clearBytes 抹零一段字节。编译器不会把对切片的显式写零当死代码删掉（逐元素赋值）。
+func clearBytes(b []byte) {
+	for i := range b {
+		b[i] = 0
+	}
+}
+
 // securePayload 是 app.bin 解密后的载荷（与 JS 侧加密载荷结构一致）。
 // Backend 为 high 模式下的后端源码表：键是相对 resources 的路径（斜杠分隔），
 // 值是 base64 内容 d 与 POSIX 权限位 m——后端源码不再明文落盘（FRDM1 的缺口）。
@@ -172,11 +188,19 @@ func deriveSecurityKey(appName string, salt []byte) secureKey {
 		return k
 	}
 	base := append([]byte(securityDeriveSalt+":"+appIdentityName(appName)), salt...)
-	kek := pbkdf2HMACSHA256(masterSecret(), base, securityPbkdf2Iter, securityKeyLen)
-	h := hmac.New(sha256.New, kek)
-	h.Write([]byte(securityMacLabel))
-	k := secureKey{enc: kek, mac: h.Sum(nil)}
+	var k secureKey
+	withMasterSecret(func(secret []byte) {
+		kek := pbkdf2HMACSHA256(secret, base, securityPbkdf2Iter, securityKeyLen)
+		h := hmac.New(sha256.New, kek)
+		h.Write([]byte(securityMacLabel))
+		k = secureKey{enc: kek, mac: h.Sum(nil)}
+	})
 	if len(secureKeyCache) >= secureKeyCacheMax { // 防御性上限：单进程正常只用一两条
+		// 淘汰不是"丢掉引用"就完事：被丢弃的密钥字节仍会被分配器复用，先抹零。
+		for _, stale := range secureKeyCache {
+			clearBytes(stale.enc)
+			clearBytes(stale.mac)
+		}
 		secureKeyCache = make(map[string]secureKey)
 	}
 	secureKeyCache[id] = k
@@ -247,6 +271,11 @@ func decryptAppBin(appName string, data []byte) (*securePayload, error) {
 	if err := json.Unmarshal(plain, &p); err != nil {
 		return nil, fmt.Errorf("app.bin 载荷无效：%w", err)
 	}
+	// 与打包端 lib/security.js 同一道门：认证通过不等于结构可用。少了 html/config 的容器
+	// 会让上层回落到内置占位页——那是「加密产物跑起来了但内容是空的」级别的静默降级。
+	if p.HTML == "" || p.Config == "" {
+		return nil, errors.New("app.bin 载荷结构无效：缺少 html/config 字段")
+	}
 	for rel := range p.Backend {
 		if !isSafeRelPath(rel) {
 			return nil, fmt.Errorf("app.bin 后端路径非法：%q", rel)
@@ -272,15 +301,18 @@ func isSafeRelPath(rel string) bool {
 	return true
 }
 
-// verifyIntegrity 校验 resources/.integrity 清单（存在时）。
+// verifyIntegrity 校验 resources/.integrity 清单。
 // 比对 app.bin 的 HMAC-SHA256，防容器被整体替换；backend 已进容器，其完整性由
 // 容器认证标签一并保证，清单里的 backend 段仅作向后兼容。
-// 无 .integrity 文件（旧产物）时跳过，保持向后兼容。
+// 清单缺失是致命错误而非"旧产物豁免"：app.bin 的认证钥由「exe 名 + 容器自带盐」派生，
+// 两者都在产物里，攻击者能为任意内容自造合法容器；.integrity 正是那道产物外的重放绑定，
+// 而「删掉 .integrity」就是绕过它最省事的手法——跳过校验等于把这道门留给攻击者关。
+// 自 FRDM2 起 CLI 恒写清单（lib/build.js），拒绝无清单容器不会误伤任何正规产物。
 func verifyIntegrity(dir string, k secureKey, appBin []byte) error {
 	raw, err := os.ReadFile(filepath.Join(dir, ".integrity"))
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
-			return nil
+			return errors.New("resources/.integrity 缺失：app.bin 未经完整性绑定，产物可能被整体替换（请重新 freedom build）")
 		}
 		return err
 	}
@@ -328,6 +360,24 @@ func hasSecureResources() bool {
 	return err == nil
 }
 
+// antiDebugEnabled 是 high 模式调试器探测的开关。
+//
+// 探测本身是 fail-safe 的（每个信号取不到数据一律按"未命中"处理），但六路信号里
+// IsDebuggerPresent / NtQueryInformationProcess 在部分合法环境本就会给出真值：
+// 逆向沙箱、EDR/杀软注入、某些虚拟化与远程桌面环境。被误判的用户需要一条**不必重新
+// 打包**就能脱身的路，所以除了发布方编译期的 Config.DisableAntiDebug，这里再认一个
+// 运行期环境变量。
+//
+// 关掉只影响"探测"这一道：容器解密、HMAC 认证与 .integrity 校验照常，
+// 源码保护的本体不在此。config.json 里刻意不给这个开关——非 high 产物的
+// config.json 是明文可改的，那样等于把防御交给攻击者。
+func (a *App) antiDebugEnabled() bool {
+	if a != nil && a.cfg.DisableAntiDebug {
+		return false
+	}
+	return os.Getenv("FREEDOM_DISABLE_ANTIDEBUG") != "1"
+}
+
 // loadSecureResources 尝试加载 high 模式加密资源。
 // 返回 (载荷, 是否命中, 错误)：resources/app.bin 不存在时命中=false（非 high 产物），
 // 命中但解密/校验失败时返回错误（拒绝静默回退明文，避免降级攻击）。

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

@@ -0,0 +1,55 @@
+package freedom
+
+// 退出前清扫（跨平台）：high 模式把后端源码解密到系统临时目录，正常退出由 Run 的
+// defer 删除；但 SIGINT / SIGTERM（Ctrl+C、`kill`、systemd stop）会让 Go 直接终止
+// 进程，defer 与 cleanup 都不执行，明文后端源码就永久躺在 %TEMP% / /tmp 里——
+// 直到用户下次再启动这个应用才会被启动期 GC 回收。对「磁盘不留明文」的承诺来说
+// 这是真空档，故在此显式接管常规信号：命中即先清扫再退。
+//
+// 边界：SIGKILL / taskkill /F / 断电无法拦截（无用户态代码可跑），仍靠下次启动的
+// gcStaleSecureBackendDirs 兜底；Windows 的控制台事件见 shutdown_windows.go。
+
+import (
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+)
+
+// secureCleanup 由 Run 注册（Run 未跑过就没有可清的东西）。
+var secureCleanup func()
+
+// cleanupOnce 用指针：单测需要一个可复位的实例来断言「只挂一次」。
+var cleanupOnce = new(sync.Once)
+
+// platformShutdownHooks 由各平台补挂退出通道（Windows 控制台事件），无额外通道的平台为 nil。
+var platformShutdownHooks func()
+
+// installShutdownCleanup 幂等地挂上退出清扫通道，由 Run 在注册 secureCleanup 后调用。
+func installShutdownCleanup() {
+	cleanupOnce.Do(func() {
+		ch := make(chan os.Signal, 1)
+		signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
+		go waitForShutdownSignal(ch)
+		if platformShutdownHooks != nil {
+			platformShutdownHooks()
+		}
+	})
+}
+
+// waitForShutdownSignal 命中信号即清扫退场；拆成变量便于单测注入（真实信号无法跨平台自投）。
+var waitForShutdownSignal = func(ch <-chan os.Signal) {
+	<-ch
+	exitAfterCleanup()
+}
+
+// exitAfterCleanup 清扫后以 130（128+SIGINT 惯例）退出。
+func exitAfterCleanup() {
+	if fn := secureCleanup; fn != nil {
+		fn()
+	}
+	shutdownExit(130)
+}
+
+// shutdownExit 是 os.Exit 的槽位：单测靠它断言"先清扫再退出"，否则会把测试进程一起带走。
+var shutdownExit = os.Exit

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

@@ -0,0 +1,47 @@
+//go:build windows
+
+package freedom
+
+// Windows 退出通道补挂：SIGTERM 在本平台不存在，控制台关闭 / 注销 / 关机走
+// SetConsoleCtrlHandler。命中 CTRL_CLOSE_EVENT 时系统只给约 5 秒宽限，
+// 删一个临时目录绑绑有余；GUI 无控制台时注册会失败，静默跳过（不影响信号通道）。
+//
+// 覆盖面要说清：`-H windowsgui` 发布的正式壳根本没有控制台，这条通道对它永不触发，
+// 其正常关窗由 WM_CLOSE → DestroyWindow → Run 的 defer 清扫，强杀/崩溃由下次启动的
+// gcStaleSecureBackendDirs 兜底。本通道实际服务控制台子系统构建（裸 go build、调试期直接跑 exe）。
+
+import (
+	"syscall"
+)
+
+var (
+	kernel32Shutdown          = syscall.NewLazyDLL("kernel32.dll")
+	procSetConsoleCtrlHandler = kernel32Shutdown.NewProc("SetConsoleCtrlHandler")
+
+	consoleCtrlCloseEvent uint32 = 2
+)
+
+// consoleCtrlHandlerProc 的形参与返回必须是 uintptr：syscall.NewCallback 会校验
+// 「一个 uintptr 宽返回值」，写成 BOOL 习惯的 uint32 直接 panic
+// （compileCallback: expected function with one uintptr-sized result）。
+func consoleCtrlHandlerProc(ctrlType uintptr) uintptr {
+	if uint32(ctrlType) == consoleCtrlCloseEvent {
+		exitAfterCleanup() // 不返回：清扫后立即退场
+	}
+	return 0 // 继续交给链上其它处理器
+}
+
+// consoleCtrlHandler 固定在包级求值一次：syscall.NewCallback 每次调用都占用全局句柄表，
+// 重复申请会泄漏（与 events_windows.go 的同款约束）。
+var consoleCtrlHandler = syscall.NewCallback(consoleCtrlHandlerProc)
+
+func init() {
+	platformShutdownHooks = installConsoleCtrlCleanup
+}
+
+func installConsoleCtrlCleanup() {
+	if err := procSetConsoleCtrlHandler.Find(); err != nil {
+		return
+	}
+	procSetConsoleCtrlHandler.Call(consoleCtrlHandler, 1)
+}

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

@@ -232,7 +232,7 @@ func saveWindowState(dir string, st WindowState) error {
 
 // ---- os / process 信息 ----
 
-func osInfo() map[string]interface{} {
+func osInfo(app *App) map[string]interface{} {
 	host, _ := os.Hostname()
 	info := map[string]interface{}{
 		"platform":   runtime.GOOS,
@@ -240,7 +240,7 @@ func osInfo() map[string]interface{} {
 		"hostname":   host,
 		"osVersion":  osVersionString(), // 平台分文件：osver_windows.go / osver_other.go
 		"goVersion":  runtime.Version(),
-		"appVersion": Version, // 构建期 ldflags 注入，见 freedom.go
+		"appVersion": app.appVersion(), // 运行时声明优先，回落 ldflags 注入值
 		"numCPU":     runtime.NumCPU(),
 	}
 	// M6：WebView2 Runtime 探测回显（仅 Windows 且检出时给键，其他平台省略）
@@ -311,7 +311,7 @@ func (a *App) sysGeneric(method string, args map[string]json.RawMessage) (result
 		}
 		return sf.keys(), true, nil
 	case "os.info":
-		info := osInfo()
+		info := osInfo(a)
 		// M3：回显生效的能力收口，前端可据此隐藏入口（nil=全开时省略该键）。
 		if a.cfg.Capabilities != nil {
 			info["capabilities"] = map[string][]string{