feat(update): 差分 OTA + 安装形态分派 + 事件总线统一受安全监控

三条主线,由 e2e 实测驱动。

## 一、差分 OTA(internal/update/delta.go)

实测:改一行逻辑,88MB 的二进制逐字节只差 80 字节,而 OTA 一直下整包。

用 rsync 族的滚动哈希块匹配(4KB 粒度),不是 bsdiff —— 后者需 17×N
峰值内存(88MB → 1.5GB),而升级恰可能发生在内存紧张时。

真实二进制实测:88,036,728 字节 → 补丁 77,316 字节(0.088%)。

三道闸:应用前验旧文件 sha256(错基线会静默产出垃圾)、应用后验结果
sha256、COPY/LITERAL 越界防护。任何失败**退回整包**,不向上抛 ——
差分是优化,不是可用性前提。

接入:Source.Resolve 优先试 delta;CheckRelease 按 -from-<commit8>.delta
匹配(不猜基线);CLI 新增 -make-delta;打包脚本 build_delta(需
PREVIOUS_HOMED),delta 进 SHA256SUMS。

## 二、安装形态分派(internal/update/install.go + channel.go)

内核对「能不能自己升级」此前只有一个答案:直接替换二进制。而 deb/rpm
形态下那样做会让 dpkg/rpm 数据库与实际内容不一致(下次 apt upgrade
覆盖回旧版,或 dpkg 拒绝后续升级)。

新增探测:deb/rpm/tar/container/source 五类形态 + 变体(full/server/
client/toolchain)+ 目录写权限。判据全部来自可观测系统事实(dpkg 的
info 目录、容器标记文件),不做路径推断。

三端统一走 PlanUpgrade 分派;形态闸门放在**下载 880MB 之前**。

## 三、事件总线统一受安全监控(internal/events + security)

用户指正:「eventbus 上所有事件都要接受安全模块的监控」。

此前 EventPolicy 只被 internal/sdk/events.go 调用,而那是四条路径中的
一条。s.Publish / s.Subscribe / s.EventBus() 拿的是裸 *events.Bus,
任何插件都能绕过策略发任意事件(含伪造内核事件)。

现在闸门在 Bus.Publish/Subscribe 本体上(Guard 接口注入,避免 events
↔ security 成环),四条路径全部覆盖。sdk.EventBus() 改返回带身份的
BusHandle。内核身份免授权,但载荷照样过凭据闸门。

白名单按主体收窄:agent_output/stage/terminal_output 只允许承载者
(webui/cli/agentcli)发布 —— 它们是内核向外的输出面,谁都能发就等于
能伪造 agent 说的话。

## e2e 暴露并修掉的三个真实回归

	[bus] subscribe denied: pluginmgr type=update_request
	[bus] subscribe denied: skillmgr type=skill_detected

前两个让升级请求静默丢失、职责链交接断掉。内部协作事件必须可订阅
(安全边界在发布侧,订阅只是「听得到」)。

## 顺带的止血修复

- 回滚判据从 `--version` 改为 digest:旧内核(1.3.x 及以前)没有该
  flag,而它恰是最常见的回滚目标 —— 原逻辑让「从旧版升级失败」永久
  无法回滚。
- CopyFile 补 fsync(替换 homed 本体时掉电会留半截文件)。
- restore 完整还原才清 marker(原先先清再还原,还原失败就失去第二次
  自愈机会)。
- 回滚时移除升级中新增的 depgraph(否则「旧 homed + 新 depgraph」
  会因 digest 不匹配崩溃循环)。
- homed-upgrade 不再硬编码 systemctl restart(丢 guard 状态、unit 名
  漂移);改用内核已有的 restartCh → exit 42 语义。
- homed-upgrade 不再用 CGO_ENABLED=0 编却依赖 go-sqlite3(stub 下
  静默失效,该路径从未工作过);改用 internal/config。
- 服务单元补 User=hologramagent + 三条安装路径补建用户(此前发行物里
  完全没有落实降权)。
- rpm 的 fpm 调用补 --after-install(此前 rpm 装完根本不建用户)。

## 判据

新增 30 条:差分 8(往返/压缩比/错基线/截断/篡改/边界)、通道 8、
执行器 6、事件闸门 8、按主体授权 8。全仓 go test ./... 0 失败。
This commit is contained in:
JianFeeeee
2026-10-29 09:54:55 +08:00
parent 7f68d2b1bf
commit ba281a855a
42 changed files with 4897 additions and 272 deletions

View File

@ -0,0 +1,188 @@
package update
// 差分 OTA 的判据。
//
// 这一层的收益是**实测的**:改一行逻辑,88MB 的二进制只差 80 字节。
// 但机制本身有真实风险 —— 错误应用会静默产出一份"看起来正常"的坏二进制。
// 所以判据的重点是「错了一定被咬住」,而不是「正常情况能跑」。
import (
"bytes"
"crypto/rand"
"os"
"path/filepath"
"testing"
)
// ① 往返:make → apply 得到逐字节相同的内容。
func TestDeltaRoundTrip(t *testing.T) {
old := bytes.Repeat([]byte("ABCDEFGHIJKLMNOP"), 5000) // 80KB
newData := append([]byte(nil), old...)
// 中间插入 3 个字节(模拟改代码导致后续偏移全变)
mid := len(newData) / 2
newData = append(newData[:mid], append([]byte("XYZ"), newData[mid:]...)...)
patch, hdr, err := MakeDelta(old, newData)
if err != nil {
t.Fatalf("生成补丁: %v", err)
}
if hdr.NewSize != int64(len(newData)) || hdr.OldSize != int64(len(old)) {
t.Fatalf("头部大小不对: %+v", hdr)
}
got, err := ApplyDelta(old, patch)
if err != nil {
t.Fatalf("应用补丁: %v", err)
}
if !bytes.Equal(got, newData) {
t.Fatal("★ 重建内容与目标不一致")
}
}
// ② 关键收益:小改动 ⇒ 小补丁。
//
// 这条判据钉住的是**压缩比**本身。若实现退化成"全字面量",
// 往返仍能通过但 OTA 一点没省 —— 那是最容易漏掉的失败形态。
func TestDeltaSmallChangeProducesSmallPatch(t *testing.T) {
old := make([]byte, 1<<20) // 1MB
if _, err := rand.Read(old); err != nil {
t.Fatal(err)
}
newData := append([]byte(nil), old...)
// 只改 64 字节
for i := 0; i < 64; i++ {
newData[i*100] ^= 0xFF
}
patch, hdr, err := MakeDelta(old, newData)
if err != nil {
t.Fatal(err)
}
st := hdr.Stats(int64(len(patch)))
t.Logf("patch=%d bytes, ratio=%.4f", len(patch), st.Ratio)
// 1MB 随机内容,只有 64 字节变化 ⇒ 补丁应远小于原文件。
// 这里用 5% 作宽松上限(块粒度 4KB,改动分散在 100 字节间隔上,
// 会打断一些块,实际比例低于此)。
if st.Ratio > 0.05 {
t.Errorf("★ 补丁过大(%.2f%% of %d bytes):差分没起作用", st.Ratio*100, hdr.NewSize)
}
}
// ③ 基线不符必须拒绝(用错旧版本 ⇒ 产出垃圾)。
func TestDeltaRejectsWrongBaseline(t *testing.T) {
old := []byte("the-original-content-here")
newData := []byte("the-original-content-here-plus-more")
patch, _, err := MakeDelta(old, newData)
if err != nil {
t.Fatal(err)
}
if _, err := ApplyDelta([]byte("a-completely-different-baseline"), patch); err == nil {
t.Fatal("★ 基线不符时必须拒绝(否则静默产出垃圾)")
}
}
// ④ 补丁被截断必须拒绝,不得"部分成功"。
func TestDeltaRejectsTruncatedPatch(t *testing.T) {
old := bytes.Repeat([]byte("Z"), 8192)
newData := append([]byte(nil), old...)
newData = append(newData, []byte("TAIL")...)
patch, _, err := MakeDelta(old, newData)
if err != nil {
t.Fatal(err)
}
for _, cut := range []int{len(deltaMagic), 20, len(patch) / 2, len(patch) - 1} {
if _, err := ApplyDelta(old, patch[:cut]); err == nil {
t.Errorf("★ 截断到 %d/%d 字节仍被接受", cut, len(patch))
}
}
}
// ⑤ 内容被篡改必须被 sha256 咬住。
//
// 这是最后一道防线:patch 结构合法、指令也不越界,但产出内容错。
func TestDeltaRejectsCorruptedOutput(t *testing.T) {
old := bytes.Repeat([]byte("Q"), 4096)
newData := append([]byte(nil), old...)
newData[0] = 'X'
patch, hdr, err := MakeDelta(old, newData)
if err != nil {
t.Fatal(err)
}
// 篡改头部里的 NewSHA256(模拟恶意/损坏的补丁)
b := append([]byte(nil), patch...)
off := len(deltaMagic) + 16 + 64
b[off] ^= 0xFF
if _, err := ApplyDelta(old, b); err == nil {
t.Fatal("★ 内容哈希不符时必须拒绝")
}
_ = hdr
}
// ⑥ 空文件与超小文件不崩。
func TestDeltaEdgeCases(t *testing.T) {
cases := [][2][]byte{
{nil, nil},
{[]byte("a"), []byte("b")},
{bytes.Repeat([]byte("a"), 100), bytes.Repeat([]byte("a"), 100)},
{[]byte{}, []byte("new")},
{[]byte("old"), []byte{}},
}
for i, c := range cases {
patch, _, err := MakeDelta(c[0], c[1])
if err != nil {
t.Fatalf("case %d 生成失败: %v", i, err)
}
got, err := ApplyDelta(c[0], patch)
if err != nil {
t.Fatalf("case %d 应用失败: %v", i, err)
}
if !bytes.Equal(got, c[1]) {
t.Errorf("case %d 结果不符", i)
}
}
}
// ⑦ 文件级入口(CLI 用)。
func TestDeltaFileRoundTrip(t *testing.T) {
dir := t.TempDir()
oldPath := filepath.Join(dir, "homed.old")
newPath := filepath.Join(dir, "homed.new")
patchPath := filepath.Join(dir, "homed.patch")
outPath := filepath.Join(dir, "homed.out")
oldData := bytes.Repeat([]byte("0123456789abcdef"), 4096)
newData := append([]byte(nil), oldData...)
newData = append(newData[:100], append([]byte("INSERTED"), newData[100:]...)...)
if err := os.WriteFile(oldPath, oldData, 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(newPath, newData, 0755); err != nil {
t.Fatal(err)
}
hdr, patchSize, err := MakeDeltaFile(oldPath, newPath, patchPath)
if err != nil {
t.Fatal(err)
}
t.Logf("patch=%d bytes (%.2f%% of new)", patchSize, hdr.Stats(patchSize).Ratio*100)
if _, err := ApplyDeltaFile(oldPath, patchPath, outPath); err != nil {
t.Fatal(err)
}
got, err := os.ReadFile(outPath)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(got, newData) {
t.Fatal("★ 文件级往返结果不一致")
}
}
// ⑧ 头部解析拒绝非本格式。
func TestParseDeltaHeaderRejectsGarbage(t *testing.T) {
if _, err := ParseDeltaHeader([]byte("not a delta file at all")); err == nil {
t.Fatal("应拒绝非补丁数据")
}
}