feat: 设备鉴权迁移至客户端 + 插件卸载保护

安全修复（客户端鉴权）： - remotedevice 服务端移除授权状态存储（authorized map/SetAuthorized/handleDeviceAuth） - DeviceMeta.Authorized 改为设备 hello 自报，服务端仅透传展示 - device_ctl_* 工具移除服务端授权检查，无条件转发，设备端自行决定是否执行 - 共享设备桥库 Bridge 新增本地 authorized 状态，未授权收到 cmd 直接拒绝 - waiter: --device-authorized / device_authorized 配置控制本地授权 - GUI: 授权存 gui-prefs 本地文件；设备页仅本机可切换开关 - webui /device/auth 旧路径返回 410 Gone - 根因：agent 可经 config_set 篡改服务端授权配置自行授权设备插件管理强化： - 内置插件禁止卸载（IsBuiltinPlugin + 409），外部插件卸载即时生效 - 卸载不存在插件返回 404；移除误导性 reload_required 提示 - webui 插件路由：名称白名单校验防路径穿越、保留字路径保护
2026-10-04 00:03:59 +00:00 · 2026-08-24 19:26:11 +08:00
parent 5163ce51a7
commit ba5785036a
21 changed files with 616 additions and 383 deletions
--- a/internal/plugins/remotedevice/binary_test.go
+++ b/internal/plugins/remotedevice/binary_test.go
@ -322,7 +322,6 @@ func TestScreenseeEndToEnd(t *testing.T) {
 	if _, _, err := cli.readMsg(); err != nil {
 		t.Fatalf("read hello_ack: %v", err)
 	}
-	reg.SetAuthorized("see-dev", true)

 	// 设备侧循环收命令并回执（模拟 GUI screensee 实现）
 	go func() {
@ -363,10 +362,10 @@ func TestScreenseeEndToEnd(t *testing.T) {
 		t.Fatalf("handler received bad dataURL: %s", gotDataURL)
 	}

-	// 未授权设备应拒绝
-	reg.SetAuthorized("see-dev", false)
-	if _, err := dev.Execute("screensee", map[string]interface{}{"device_id": "see-dev"}); err == nil {
-		t.Fatal("expected unauthorized error")
+	// 客户端鉴权模式：服务端不拦截，总是转发（设备端自行决定是否执行）。
+	// see-dev 未声明 screensee 之外的问题，此处仅验证服务端不再因授权状态报错。
+	if _, err := dev.Execute("screensee", map[string]interface{}{"device_id": "see-dev"}); err != nil {
+		t.Fatalf("server should forward regardless of authorization, got: %v", err)
 	}
 }

@ -389,7 +388,6 @@ func TestComputeruseEndToEnd(t *testing.T) {
 	if _, _, err := cli.readMsg(); err != nil {
 		t.Fatalf("read hello_ack: %v", err)
 	}
-	reg.SetAuthorized("cu-dev", true)

 	// 设备侧收 computeruse 命令并回执
 	var receivedCmd string
@ -480,7 +478,6 @@ func TestClipboardEndToEnd(t *testing.T) {
 	if _, _, err := cli.readMsg(); err != nil {
 		t.Fatalf("read hello_ack: %v", err)
 	}
-	reg.SetAuthorized("clip-dev", true)

 	// 设备侧响应剪贴板命令
 	go func() {
@ -553,11 +550,11 @@ func TestClipboardEndToEnd(t *testing.T) {
 		}
 	})

-	t.Run("unauthorized_device_rejected", func(t *testing.T) {
-		reg.SetAuthorized("clip-dev", false)
-		defer reg.SetAuthorized("clip-dev", true)
-		if _, err := dev.Execute("clipboardsee", map[string]interface{}{"device_id": "clip-dev"}); err == nil {
-			t.Fatal("unauthorized should error")
+	t.Run("server_forwards_regardless_of_authorization", func(t *testing.T) {
+		// 客户端鉴权模式：服务端不再拦截未授权设备，由设备端自行拒绝。
+		// 这里验证服务端能正常查询设备（不因授权状态报错）。
+		if _, ok := reg.Get("clip-dev"); !ok {
+			t.Fatal("device should be registered")
 		}
 	})
 }
@ -603,7 +600,6 @@ func TestCapabilityMatrix(t *testing.T) {
 	if _, _, err := cli.readMsg(); err != nil {
 		t.Fatalf("read hello_ack: %v", err)
 	}
-	reg.SetAuthorized("cam-only", true)

 	if _, err := dev.Execute("screensee", map[string]interface{}{"device_id": "cam-only"}); err == nil {
 		t.Fatal("camera-only device should not support screensee")
@ -640,8 +636,8 @@ func TestDeviceEventReport(t *testing.T) {
 	// 设备主动上报：识别到未知人员驻留
 	cli.sendText(mustJSON(map[string]interface{}{
 		"op": "event", "device_id": "cam-watch",
-		"type":    "unknown_person_detected",
-		"detail":  "后门区域检测到陌生面孔，驻留超过30秒",
+		"type":   "unknown_person_detected",
+		"detail": "后门区域检测到陌生面孔，驻留超过30秒",
 	}))
 	// 不带 device_id 时应回退到当前连接的设备
 	cli.sendText(mustJSON(map[string]interface{}{
--- a/internal/plugins/remotedevice/device.go
+++ b/internal/plugins/remotedevice/device.go
@ -12,10 +12,9 @@ import (

 // devicectlDevice 把设备网关暴露为 IOManager 的一个 Device：
 // Tools() 提供 devicedetect / device_ctl_status / device_ctl_cmdrun / device_ctl_cmdresult / screensee，
-// Execute() 检查授权并路由到 WS 在线设备。
+// Execute() 推送命令到设备，设备端自行鉴权（客户端存储授权）。
 type devicectlDevice struct {
-	reg     *Registry
-	persist func() // 授权变更后持久化
+	reg *Registry

 	// screensee 回调：设备截屏回传后由 agent 核心消费（视觉描述）。
 	// 由插件 Start 注入；nil 时退化为仅返回 base64 数据。
@ -121,9 +120,9 @@ func (d *devicectlDevice) Tools() []agentIO.ToolDef {
 				"properties": map[string]interface{}{
 					"device_id": map[string]interface{}{"type": "string", "description": "目标设备 ID"},
 					"action": map[string]interface{}{
-						"type": "string",
+						"type":        "string",
 						"description": "操作类型：click(单击) / doubleclick(双击) / rightclick(右键) / move(移动) / scroll(滚动) / keypress(按键) / type(输入文字)",
-						"enum": []interface{}{"click", "doubleclick", "rightclick", "move", "scroll", "keypress", "type"},
+						"enum":        []interface{}{"click", "doubleclick", "rightclick", "move", "scroll", "keypress", "type"},
 					},
 					"x":      map[string]interface{}{"type": "integer", "description": "鼠标 X 坐标（像素）。click/doubleclick/rightclick/move 必填"},
 					"y":      map[string]interface{}{"type": "integer", "description": "鼠标 Y 坐标（像素）。click/doubleclick/rightclick/move 必填"},
@ -257,9 +256,7 @@ func (d *devicectlDevice) status(args map[string]interface{}) (interface{}, erro
 	if !ok {
 		return nil, fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return nil, fmt.Errorf("device %s 未授权，无法查询状态（需先在设备管理页或经 bind 授权）", id)
-	}
+	// 服务端不检查授权；设备端收到请求后自行决定是否执行。
 	if !m.Online {
 		return publicDevices([]DeviceMeta{m}), nil // 带 offline=true
 	}
@ -277,9 +274,7 @@ func (d *devicectlDevice) cmdrun(args map[string]interface{}) (interface{}, erro
 	if !ok {
 		return nil, fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return nil, fmt.Errorf("device %s 未授权，无法执行命令（请先在设备管理页授权）", id)
-	}
+	// 服务端不检查授权；设备端收到请求后自行决定是否执行。
 	if !m.Online {
 		return nil, fmt.Errorf("device %s 不在线，无法执行命令", id)
 	}
@ -328,13 +323,10 @@ func (d *devicectlDevice) cmdresult(args map[string]interface{}) (interface{}, e
 	if deviceID != "" {
 		// 返回该设备最近一次结果（简化：遍历 results 找 device_id 匹配的最近一条）
 		// 说明：当前只按 req_id 查询；device_id 查询留给后续迭代。
-		m, ok := d.reg.Get(deviceID)
+		_, ok := d.reg.Get(deviceID)
 		if !ok {
 			return nil, fmt.Errorf("device %s 不存在", deviceID)
 		}
-		if !m.Authorized {
-			return nil, fmt.Errorf("device %s 未授权", deviceID)
-		}
 		return map[string]interface{}{"device_id": deviceID, "note": "请用 device_ctl_cmdrun 返回的 req_id 查询命令结果"}, nil
 	}
 	return nil, fmt.Errorf("req_id 或 device_id 至少提供一个")
@ -350,9 +342,6 @@ func (d *devicectlDevice) info(args map[string]interface{}) (interface{}, error)
 	if !ok {
 		return nil, fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return nil, fmt.Errorf("device %s 未授权，无法探查信息（请先在设备管理页授权）", id)
-	}
 	out := map[string]interface{}{
 		"device_id":  m.DeviceID,
 		"name":       m.Name,
@ -385,9 +374,7 @@ func (d *devicectlDevice) screensee(args map[string]interface{}) (interface{}, e
 	if !ok {
 		return nil, fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return nil, fmt.Errorf("device %s 未授权，无法查看屏幕（请先在设备管理页授权）", id)
-	}
+	// 服务端不检查授权；设备端收到请求后自行决定是否执行。
 	if !m.Online {
 		return nil, fmt.Errorf("device %s 不在线", id)
 	}
@ -436,9 +423,7 @@ func (d *devicectlDevice) computeruse(args map[string]interface{}) (interface{},
 	if !ok {
 		return nil, fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return nil, fmt.Errorf("device %s 未授权，无法远程操控（请先在设备管理页授权）", id)
-	}
+	// 服务端不检查授权；设备端收到请求后自行决定是否执行。
 	if !m.Online {
 		return nil, fmt.Errorf("device %s 不在线", id)
 	}
@ -508,9 +493,6 @@ func (d *devicectlDevice) clipboardCheck(id, verb, tool string) error {
 	if !ok {
 		return fmt.Errorf("device %s 不存在", id)
 	}
-	if !m.Authorized {
-		return fmt.Errorf("device %s 未授权，无法%s剪切板（请先在设备管理页授权）", id, verb)
-	}
 	if !m.Online {
 		return fmt.Errorf("device %s 不在线", id)
 	}
--- a/internal/plugins/remotedevice/plugin.go
+++ b/internal/plugins/remotedevice/plugin.go
@ -71,7 +71,8 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	// ---- 设置 ----------------
 	s.Settings().RegisterDef(sdk.ConfigDef{Key: "listen_addr", Default: defaultAddr, Type: "string", DisplayName: "监听地址", Description: "设备网关 HTTP/WS 监听地址（默认 127.0.0.1:9890，仅本机）", Category: "remotedevice"})
 	s.Settings().RegisterDef(sdk.ConfigDef{Key: "ws_token", Default: "", Type: "password", DisplayName: "接入 Token", Description: "设备绑定/接入时使用的令牌；留空启动时自动生成", Category: "remotedevice"})
-	s.Settings().RegisterDef(sdk.ConfigDef{Key: "authorized_devices", Default: "", Type: "text", DisplayName: "已授权设备", Description: "逗号分隔的已授权设备 ID 列表（由系统维护）", Category: "remotedevice"})
+	// 注意：不注册 authorized_devices 设置项 —— 鉴权在设备端执行（客户端存储），
+	// 服务端不保存授权状态，避免 agent 经 config_set 工具自行授权。

 	p.addr = defaultAddr
 	if v, _ := s.Settings().Get("listen_addr"); v != nil {
@ -95,21 +96,8 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 		return provided != "" && provided == p.token
 	})

-	// 恢复已授权设备集合
-	if v, _ := s.Settings().Get("authorized_devices"); v != nil {
-		if s2, ok := v.(string); ok && s2 != "" {
-			var ids []string
-			for _, id := range strings.Split(s2, ",") {
-				if id = strings.TrimSpace(id); id != "" {
-					ids = append(ids, id)
-				}
-			}
-			p.registry.RestoreAuthorized(ids)
-		}
-	}
-
 	// ---- devicectl Device（agent 工具） ----------------
-	p.dev = &devicectlDevice{reg: p.registry, persist: p.persistAuthorized}
+	p.dev = &devicectlDevice{reg: p.registry}
 	// screensee 视觉描述回调：截屏回传后用视觉模型描述屏幕内容
 	p.dev.SetSeeHandler(p.describeScreen)
 	if err := s.RegisterChannel("devicectl", p.dev); err != nil {
@ -171,24 +159,15 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	return nil
 }

-// persistAuthorized 在授权变更后写回设置（持久化重启不丢）。
-func (p *Plugin) persistAuthorized() {
-	if p.sdk == nil {
-		return
-	}
-	ids := p.registry.AuthorizedIDs()
-	_ = p.sdk.Settings().Set("authorized_devices", strings.Join(ids, ","))
-}
-
 func (p *Plugin) registerRoutes() {
 	// 设备通道（WS）
 	p.mux.HandleFunc("/api/v1/device/ws", p.registry.ServeWS)
 	// REST 管理面（全部需 token）
+	// 注意：/api/v1/device/auth 已移除 —— 授权由设备端控制，服务端不提供授权接口。
 	p.mux.HandleFunc("/api/v1/device", p.requireToken(p.handleDeviceList))
 	p.mux.HandleFunc("/api/v1/device/online", p.requireToken(p.handleDeviceOnline))
 	p.mux.HandleFunc("/api/v1/device/", p.requireToken(p.handleDeviceByID))
 	p.mux.HandleFunc("/api/v1/device/push", p.requireToken(p.handleDevicePush))
-	p.mux.HandleFunc("/api/v1/device/auth", p.requireToken(p.handleDeviceAuth))
 }

 // requireToken 校验 REST 请求的接入令牌（X-API-Key header 或 ?token=）。
@ -270,32 +249,6 @@ func (p *Plugin) handleDevicePush(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]interface{}{"status": "ok"})
 }

-func (p *Plugin) handleDeviceAuth(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.NotFound(w, r)
-		return
-	}
-	var req struct {
-		DeviceID  string `json:"device_id"`
-		Authorize bool   `json:"authorize"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		writeJSON(w, http.StatusBadRequest, map[string]interface{}{"error": err.Error()})
-		return
-	}
-	if req.DeviceID == "" {
-		writeJSON(w, http.StatusBadRequest, map[string]interface{}{"error": "device_id required"})
-		return
-	}
-	if _, ok := p.registry.Get(req.DeviceID); !ok {
-		writeJSON(w, http.StatusNotFound, map[string]interface{}{"error": "device not found"})
-		return
-	}
-	p.registry.SetAuthorized(req.DeviceID, req.Authorize)
-	p.persistAuthorized()
-	writeJSON(w, http.StatusOK, map[string]interface{}{"device_id": req.DeviceID, "authorized": req.Authorize})
-}
-
 // describeScreen 用视觉模型描述设备屏幕截图（screensee 回调）。
 // provider 为空时使用默认 LLM 源；模型不支持视觉时返回友好错误。
 func (p *Plugin) describeScreen(dataURL string, provider string) string {
--- a/internal/plugins/remotedevice/registry.go
+++ b/internal/plugins/remotedevice/registry.go
@ -17,6 +17,8 @@ import (
 )

 // DeviceMeta 描述一台接入了网关的设备。
+// Authorized 设备自报（由客户端存储和声明），服务端仅报告不决策。
+// 鉴权在设备端执行：服务端推送命令后，设备自行决定是否执行。
 type DeviceMeta struct {
 	DeviceID   string                 `json:"device_id"`
 	Name       string                 `json:"name"`
@ -35,11 +37,11 @@ type wconn struct {
 	w        *bufio.Writer
 }

-// Registry 是设备接入网关的注册表：管理在线连接、设备元数据与已授权集合。线程安全。
+// Registry 是设备接入网关的注册表：管理在线连接、设备元数据。线程安全。
+// 鉴权在设备端执行，服务端不存储授权状态。
 type Registry struct {
 	mu         sync.RWMutex
 	devices    map[string]*DeviceMeta // deviceID -> meta（在线/历史）
-	authorized map[string]bool        // deviceID -> 是否已授权（持久化恢复）
 	conns      map[string]*wconn      // deviceID -> 活跃连接（支持 push）
 	onlineCh   chan string
 	onStatus   func(msg map[string]interface{})
@ -62,9 +64,9 @@ type resultEntry struct {
 // （如旧版 GUI/waiter）视为全能力，保持向后兼容。
 var capabilityTools = map[string][]string{
 	// 屏幕显示/查看
-	"screen":     {"screensue", "screensee"},
-	"screensue":  {"screensue"},
-	"screensee":  {"screensee"},
+	"screen":    {"screensue", "screensee"},
+	"screensue": {"screensue"},
+	"screensee": {"screensee"},
 	// 鼠标键盘操控
 	"computeruse": {"computeruse"},
 	// 剪切板
@ -121,7 +123,6 @@ func deviceSupportsTool(caps []string, tool string) bool {
 func NewRegistry() *Registry {
 	return &Registry{
 		devices:    make(map[string]*DeviceMeta),
-		authorized: make(map[string]bool),
 		conns:      make(map[string]*wconn),
 		onlineCh:   make(chan string, 16),
 		cmdPending: make(map[string]chan map[string]interface{}),
@ -172,21 +173,15 @@ func (r *Registry) Online(id string) bool {
 	return ok && m.Online
 }

-// Authorized 返回设备是否已授权。
-func (r *Registry) Authorized(id string) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return r.authorized[id]
-}
+// Authorized 已移除：授权状态由设备端自报（DeviceMeta.Authorized），服务端不存储。

-// List 返回全部设备（在线或历史），合并授权态。
+// List 返回全部设备（在线或历史）。
 func (r *Registry) List() []DeviceMeta {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	out := make([]DeviceMeta, 0, len(r.devices))
 	for _, m := range r.devices {
 		c := *m
-		c.Authorized = r.authorized[c.DeviceID]
 		out = append(out, c)
 	}
 	return out
@ -200,7 +195,6 @@ func (r *Registry) OnlineList() []DeviceMeta {
 	for _, m := range r.devices {
 		if m.Online {
 			c := *m
-			c.Authorized = r.authorized[c.DeviceID]
 			out = append(out, c)
 		}
 	}
@ -215,44 +209,12 @@ func (r *Registry) Get(id string) (DeviceMeta, bool) {
 	if !ok {
 		return DeviceMeta{}, false
 	}
-	c := *m
-	c.Authorized = r.authorized[id]
-	return c, true
+	return *m, true
 }

 // ============ 授权 ============
-
-// SetAuthorized 标记某设备已授权/取消授权（持久化由插件负责）。
-func (r *Registry) SetAuthorized(id string, auth bool) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.authorized[id] = auth
-	if m, ok := r.devices[id]; ok {
-		m.Authorized = auth
-	}
-}
-
-// RestoreAuthorized 插件启动时从配置恢复已授权设备集合。
-func (r *Registry) RestoreAuthorized(ids []string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	for _, id := range ids {
-		r.authorized[id] = true
-	}
-}
-
-// AuthorizedIDs 返回全部已授权设备 ID（供插件持久化）。
-func (r *Registry) AuthorizedIDs() []string {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	var out []string
-	for id, ok := range r.authorized {
-		if ok {
-			out = append(out, id)
-		}
-	}
-	return out
-}
+// 已移除服务端授权存储：设备在 hello/status 中自报 authorized，
+// 服务端仅透传展示；实际鉴权由设备端执行（收到 cmd 后自行决定是否执行）。

 // ============ 在线状态维护 ============

@ -260,7 +222,7 @@ func (r *Registry) register(meta DeviceMeta) {
 	r.mu.Lock()
 	meta.Online = true
 	meta.LastSeen = time.Now().Unix()
-	meta.Authorized = r.authorized[meta.DeviceID]
+	// 保留设备自报的授权状态（客户端鉴权，服务端不覆盖）
 	r.devices[meta.DeviceID] = &meta
 	r.mu.Unlock()
 	r.notifyChange(meta.DeviceID)
@ -335,7 +297,9 @@ func (r *Registry) PushCmd(deviceID, reqID, command, cmdType string) error {

 // PushData 向设备分块下发二进制数据（网关→设备，如 TTS 音频）。
 // 协议（与 GUI 设备桥协商）：
-//   文本帧 cmd_speech_start {op, req_id, kind, mime, total} → N 个二进制帧(0x2, ≤8KB) → 文本帧 cmd_speech_end {op, req_id}
+//
+//	文本帧 cmd_speech_start {op, req_id, kind, mime, total} → N 个二进制帧(0x2, ≤8KB) → 文本帧 cmd_speech_end {op, req_id}
+//
 // kind 为语义标记（如 speech），mime 为数据 MIME 类型。设备聚合后按自身能力处理（播放等）。
 func (r *Registry) PushData(deviceID, reqID, kind, mime string, data []byte) error {
 	r.mu.RLock()
@ -813,6 +777,9 @@ func metaFromMsg(msg map[string]interface{}) DeviceMeta {
 				}
 			}
 		}
+		if v, ok := d["authorized"].(bool); ok {
+			meta.Authorized = v
+		}
 		if info, ok := d["info"].(map[string]interface{}); ok {
 			if len(info) > 0 {
 				meta.Info = info