magic-agent 2.4.3 → 2.6.3

package/internal/client/browse.go

@@ -26,8 +26,18 @@ import (
  *              → 回给手机
  *
  * 用**路径前缀**承载目标地址（而不是 ?url= 全量编码）：浏览器解析相对地址时会自动保留
- * 前缀，配上注入的 <base> 就能让同站链接继续走中转。令牌只放在**首帧**的查询串里，
- * 首帧响应下发 cookie，后续子资源请求靠 cookie 过鉴权（否则每个 URL 都得带令牌）。
+ * 前缀，配上注入的 <base> 就能让同站链接继续走中转。
+ *
+ * ── 鉴权：令牌进每一条改写出的 URL ──
+ * 早先令牌只放在**首帧**的查询串里，首帧响应下发 cookie，后续子资源请求靠 cookie 过鉴权。
+ * 那个方案在 APK（Capacitor 壳）里必然失败：壳的首屏 origin 是它自己的本地服务器
+ * （localhost），与被代理 iframe 所在的桌面端 LAN origin **跨站**，而 cookie 是
+ * SameSite=Lax —— 跨站子资源请求压根不带它，于是改写过的图片/脚本/样式全部 401
+ * （首帧有 ?magicToken= 所以页面能出来，百度移动页 CSS 又全内联，看起来就是「图片全裂」）。
+ * SameSite=None 要求 Secure，而客户端在局域网是明文 HTTP，此路不通。
+ * 现在令牌**直接拼进每条改写出的 URL**（?magicToken=…），上游转发前由 stripMagicToken
+ * 剥掉，任何嵌入上下文（同源 / 跨站 / 第三方 cookie 被墙）都不受影响。
+ * cookie 仍然照发（同源场景下聊胜于无），但不再是唯一凭据。
  *
  * ── 刻意不做的事 ──
  *   - 不转发上游的 Set-Cookie：上游会话存桌面端的 cookie jar，别去污染手机对本服务的 cookie。
@@ -40,8 +50,11 @@ import (
 const (
 	// browsePrefix 中转路径前缀。
 	browsePrefix = "/b/"
-	// browseCookie 首帧下发、供子资源请求复用的鉴权 cookie。
+	// browseCookie 首帧下发、供子资源请求复用的鉴权 cookie（辅助凭据，见文件头注释）。
 	browseCookie = "magic_browse"
+	// browseTokenParam 令牌查询参数名：改写出的每条 URL 都带它（stripMagicToken 会在
+	// 转发上游前剥掉）。不用 cookie 独扛鉴权，就是为了跨站 iframe（APK 壳）也能过。
+	browseTokenParam = "magicToken"
 	// browseMaxBytes HTML 改写单页size上限；超了直接报错（不静默截断成坏页面）。
 	browseMaxBytes = 12 << 20
 	// browseUA 伪装成 Android Chrome —— 直接拿 Go 默认 UA 会被不少移动站点降级甚至拒绝。
@@ -111,6 +124,16 @@ func (s *Service) browseUserAgent() string {
 
 // handleBrowse 中转入口。
 func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
+	// relay 脚本本体：/b/relay.js。特判放在最前面 —— 它是**我们自己的**资源，
+	// 不能让 browseTarget 把 "relay.js" 当主机名去抓。
+	if strings.TrimPrefix(r.URL.Path, browsePrefix) == "relay.js" {
+		w.Header().Set("Content-Type", "text/javascript; charset=utf-8")
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(browseRelayJS))
+		return
+	}
+	// （/b/shotlib.js 已随页面内截图退役：截图改走服务端 agent-browser，见 ab.go。）
 	target, ok := browseTarget(r)
 	if !ok {
 		writeErr(w, http.StatusBadRequest, "用法：/b/<http|https>/<host>/<path>")
@@ -118,9 +141,11 @@ func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
 	}
 	target = remapBrowseHost(target)
 
-	// 鉴权：查询令牌（首帧）或 cookie（子资源）。
-	if want := strings.TrimSpace(s.opts.Token); want != "" {
-		got := strings.TrimSpace(r.URL.Query().Get("magicToken"))
+	// 鉴权：查询令牌（每条改写出的 URL 都带）或 cookie（同源场景下的辅助凭据）。
+	// want 同时是改写 URL 时要拼进去的令牌 —— 空表示没开鉴权，URL 保持干净。
+	want := strings.TrimSpace(s.opts.Token)
+	if want != "" {
+		got := strings.TrimSpace(r.URL.Query().Get(browseTokenParam))
 		if got == "" {
 			if c, err := r.Cookie(browseCookie); err == nil {
 				got = c.Value
@@ -130,7 +155,7 @@ func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
 			writeErr(w, http.StatusUnauthorized, "缺少或错误的访问令牌（?magicToken= 或 cookie）")
 			return
 		}
-		if r.URL.Query().Get("magicToken") != "" {
+		if r.URL.Query().Get(browseTokenParam) != "" {
 			http.SetCookie(w, &http.Cookie{
 				Name: browseCookie, Value: want, Path: "/",
 				HttpOnly: true, SameSite: http.SameSiteLaxMode,
@@ -192,7 +217,7 @@ func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
 	// 重定向：把 Location 也改成中转地址，否则浏览器一跳出前缀就离开中转了。
 	if loc := resp.Header.Get("Location"); loc != "" && resp.StatusCode >= 300 && resp.StatusCode < 400 {
 		if abs, perr := target.Parse(loc); perr == nil {
-			w.Header().Set("Location", browseURL(abs, proxyBase))
+			w.Header().Set("Location", browseURL(abs, proxyBase, want))
 		} else {
 			w.Header().Set("Location", loc)
 		}
@@ -210,7 +235,7 @@ func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
 		w.Header().Set("Cache-Control", "no-store")
 		w.WriteHeader(resp.StatusCode)
-		_, _ = w.Write(rewriteBrowseHTML(body, target, proxyBase))
+		_, _ = w.Write(rewriteBrowseHTML(body, target, proxyBase, want))
 		return
 	}
 	// CSS 也要改写：样式表里 background-image / @import 引用的图不经过 HTML，
@@ -223,7 +248,7 @@ func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
 		}
 		w.Header().Set("Content-Type", "text/css; charset=utf-8")
 		w.WriteHeader(resp.StatusCode)
-		_, _ = w.Write([]byte(rewriteCSS(string(body), target, proxyBase)))
+		_, _ = w.Write([]byte(rewriteCSS(string(body), target, proxyBase, want)))
 		return
 	}
 
@@ -314,11 +339,14 @@ func stripMagicToken(q string) string {
 // 原因：根相对地址按「所在文档 / 样式表的源」解析，而页面里常有**直连加载**的外站样式表
 // 或脚本（由 JS 动态插入，我们改写不到）。它们消费到 url(/b/...) 时会解析回自己的源
 // （实测：被解析成 ms.bdstatic.com/b/...，图片全裂）。绝对地址在任何上下文都指向中转。
-func browseURL(abs *url.URL, proxyBase string) string {
-	if abs == nil || (abs.Scheme != "http" && abs.Scheme != "https") {
-		if abs == nil {
-			return ""
-		}
+//
+// token 非空时拼上 ?magicToken=…：子资源鉴权不能只靠 cookie —— 跨站 iframe（APK 壳）
+// 下 SameSite=Lax 的 cookie 根本不随子资源请求发送，详见文件头注释。
+func browseURL(abs *url.URL, proxyBase, token string) string {
+	if abs == nil {
+		return ""
+	}
+	if abs.Scheme != "http" && abs.Scheme != "https" {
 		return abs.String()
 	}
 	p := abs.EscapedPath()
@@ -326,15 +354,22 @@ func browseURL(abs *url.URL, proxyBase string) string {
 		p = "/"
 	}
 	out := proxyBase + browsePrefix + abs.Scheme + "/" + abs.Host + p
-	if abs.RawQuery != "" {
-		out += "?" + abs.RawQuery
+	q := abs.RawQuery
+	if token != "" {
+		if q != "" {
+			q += "&"
+		}
+		q += browseTokenParam + "=" + url.QueryEscape(token)
+	}
+	if q != "" {
+		out += "?" + q
 	}
 	return out
 }
 
 // rewriteRef 把一个页面里的引用地址解析成绝对地址后再映射到中转。
 // data:/javascript:/mailto: 等非网络协议与纯锚点一律不动，避免把页面改坏。
-func rewriteRef(raw string, page *url.URL, proxyBase string) string {
+func rewriteRef(raw string, page *url.URL, proxyBase, token string) string {
 	t := strings.TrimSpace(raw)
 	if t == "" {
 		return raw
@@ -353,13 +388,16 @@ func rewriteRef(raw string, page *url.URL, proxyBase string) string {
 	if abs.Scheme != "http" && abs.Scheme != "https" {
 		return raw
 	}
-	return browseURL(abs, proxyBase)
+	return browseURL(abs, proxyBase, token)
 }
 
 // rewriteBrowseHTML 就地改写 HTML：剥掉会妨碍内嵌的头、把所有 URL 指回中转、注入 <base>。
 //
-// 分片处理：<script> 段原样保留（在 JS 里替换 URL 会砸脚本），其余段做属性 / srcset / CSS url() 改写。
-func rewriteBrowseHTML(body []byte, page *url.URL, proxyBase string) []byte {
+// 分片处理：<script> 元素拆成「开标签 + 内容」—— 开标签的属性（src 等）要改写
+// （否则 <script src="//cdn.example.com/a.js"> 这类协议相对地址会绕过中转，直连手机网络，
+// 桌面端才能访问的内网站点照样裂），内容原样保留（在 JS 里替换 URL 会砸脚本）。
+// 其余段做属性 / srcset / CSS url() 改写。
+func rewriteBrowseHTML(body []byte, page *url.URL, proxyBase, token string) []byte {
 	html := string(body)
 	html = browseBaseRe.ReplaceAllString(html, "")
 	html = browseCSPRe.ReplaceAllString(html, "")
@@ -367,27 +405,37 @@ func rewriteBrowseHTML(body []byte, page *url.URL, proxyBase string) []byte {
 	var b strings.Builder
 	last := 0
 	for _, loc := range browseScriptRe.FindAllStringIndex(html, -1) {
-		b.WriteString(rewriteChunk(html[last:loc[0]], page, proxyBase))
-		b.WriteString(html[loc[0]:loc[1]])
+		b.WriteString(rewriteChunk(html[last:loc[0]], page, proxyBase, token))
+		elem := html[loc[0]:loc[1]]
+		if gt := strings.IndexByte(elem, '>'); gt >= 0 {
+			b.WriteString(rewriteChunk(elem[:gt+1], page, proxyBase, token))
+			b.WriteString(elem[gt+1:])
+		} else {
+			b.WriteString(elem)
+		}
 		last = loc[1]
 	}
-	b.WriteString(rewriteChunk(html[last:], page, proxyBase))
+	b.WriteString(rewriteChunk(html[last:], page, proxyBase, token))
 	out := b.String()
 
 	// 注入 <base>：给**没被改写**的相对地址一个基准，指向本中转的页面地址。
 	// 改写过的地址现在是绝对的、不依赖 base（早先用根相对地址 + 指向原站的 base，
 	// 会被解析回原站导致图片全裂，已修）。
-	base := `<base href="` + htmlEscapeAttr(browseURL(page, proxyBase)) + `">`
+	// 同时注入 relay 脚本（/b/relay.js，见 browseinput.go）：连回 /browse-input
+	// 收指令，在被代理页面里派发合成鼠标/键盘事件 —— 为浏览器 MCP 驱动鼠标铺路。
+	// 脚本地址是绝对的（带 proxyBase）：页面 URL 可能是任何源，相对地址会解析回原站。
+	inject := `<base href="` + htmlEscapeAttr(browseURL(page, proxyBase, "")) + `">` +
+		`<script src="` + htmlEscapeAttr(proxyBase+"/b/relay.js") + `" defer></script>`
 	if i := strings.Index(strings.ToLower(out), "<head"); i >= 0 {
 		if j := strings.IndexByte(out[i:], '>'); j >= 0 {
 			k := i + j + 1
-			return []byte(out[:k] + base + out[k:])
+			return []byte(out[:k] + inject + out[k:])
 		}
 	}
-	return []byte(base + out)
+	return []byte(inject + out)
 }
 
-func rewriteChunk(chunk string, page *url.URL, proxyBase string) string {
+func rewriteChunk(chunk string, page *url.URL, proxyBase, token string) string {
 	chunk = browseAttrRe.ReplaceAllStringFunc(chunk, func(m string) string {
 		sub := browseAttrRe.FindStringSubmatch(m)
 		name := sub[1]
@@ -401,7 +449,7 @@ func rewriteChunk(chunk string, page *url.URL, proxyBase string) string {
 			q = '\''
 			val = sub[4]
 		}
-		return name + "=" + string(q) + rewriteRef(val, page, proxyBase) + string(q)
+		return name + "=" + string(q) + rewriteRef(val, page, proxyBase, token) + string(q)
 	})
 	chunk = browseSrcsetRe.ReplaceAllStringFunc(chunk, func(m string) string {
 		sub := browseSrcsetRe.FindStringSubmatch(m)
@@ -411,17 +459,17 @@ func rewriteChunk(chunk string, page *url.URL, proxyBase string) string {
 			val = sub[3]
 			q = `'`
 		}
-		return "srcset=" + q + rewriteSrcset(val, page, proxyBase) + q
+		return "srcset=" + q + rewriteSrcset(val, page, proxyBase, token) + q
 	})
-	return rewriteCSS(chunk, page, proxyBase)
+	return rewriteCSS(chunk, page, proxyBase, token)
 }
 
 // rewriteCSS 改写样式里的资源引用：url(...) 与 @import "..."。
-func rewriteCSS(css string, page *url.URL, proxyBase string) string {
+func rewriteCSS(css string, page *url.URL, proxyBase, token string) string {
 	css = browseCSSURLRe.ReplaceAllStringFunc(css, func(m string) string {
 		sub := browseCSSURLRe.FindStringSubmatch(m)
 		// 统一重建成不带引号的形式：Go 的 RE2 不支持反向引用，没法配对首尾引号。
-		return "url(" + rewriteRef(sub[1], page, proxyBase) + ")"
+		return "url(" + rewriteRef(sub[1], page, proxyBase, token) + ")"
 	})
 	css = browseImportRe.ReplaceAllStringFunc(css, func(m string) string {
 		sub := browseImportRe.FindStringSubmatch(m)
@@ -430,20 +478,20 @@ func rewriteCSS(css string, page *url.URL, proxyBase string) string {
 		if q == "'" {
 			val = sub[3]
 		}
-		return "@import " + q + rewriteRef(val, page, proxyBase) + q
+		return "@import " + q + rewriteRef(val, page, proxyBase, token) + q
 	})
 	return css
 }
 
 // rewriteSrcset 处理 srcset：逗号分隔，每段「URL [descriptor]」，只改 URL 那一段。
-func rewriteSrcset(val string, page *url.URL, proxyBase string) string {
+func rewriteSrcset(val string, page *url.URL, proxyBase, token string) string {
 	items := strings.Split(val, ",")
 	for i, it := range items {
 		fields := strings.Fields(strings.TrimSpace(it))
 		if len(fields) == 0 {
 			continue
 		}
-		fields[0] = rewriteRef(fields[0], page, proxyBase)
+		fields[0] = rewriteRef(fields[0], page, proxyBase, token)
 		items[i] = strings.Join(fields, " ")
 	}
 	return strings.Join(items, ", ")

package/internal/client/browse_test.go

@@ -43,18 +43,25 @@ func TestRemapBrowseHost(t *testing.T) {
 
 func TestBrowseURL(t *testing.T) {
 	cases := []struct {
-		in, want string
+		in, want, tok string
 	}{
-		{"https://example.com/", "http://p/b/https/example.com/"},
-		{"https://example.com/a/b?x=1", "http://p/b/https/example.com/a/b?x=1"},
-		{"http://192.168.1.5:8080/x", "http://p/b/http/192.168.1.5:8080/x"},
-		{"mailto:a@b.c", "mailto:a@b.c"},
+		{"https://example.com/", "http://p/b/https/example.com/", ""},
+		{"https://example.com/a/b?x=1", "http://p/b/https/example.com/a/b?x=1", ""},
+		{"http://192.168.1.5:8080/x", "http://p/b/http/192.168.1.5:8080/x", ""},
+		{"mailto:a@b.c", "mailto:a@b.c", ""},
+		// 令牌拼进查询串：无 query 用 ?，有 query 用 &（APK 跨站 iframe 下
+		// SameSite=Lax cookie 不随子资源发送，令牌必须走在 URL 里）。
+		{"https://example.com/", "http://p/b/https/example.com/?magicToken=T", "T"},
+		{"https://example.com/a/b?x=1", "http://p/b/https/example.com/a/b?x=1&magicToken=T", "T"},
 	}
 	for _, c := range cases {
-		if got := browseURL(mustURL(t, c.in), testProxyBase); got != c.want {
-			t.Errorf("browseURL(%q) = %q，期望 %q", c.in, got, c.want)
+		if got := browseURL(mustURL(t, c.in), testProxyBase, c.tok); got != c.want {
+			t.Errorf("browseURL(%q, tok=%q) = %q，期望 %q", c.in, c.tok, got, c.want)
 		}
 	}
+	if got := browseURL(nil, testProxyBase, "T"); got != "" {
+		t.Errorf("browseURL(nil) 应为空串，实际 %q", got)
+	}
 }
 
 func TestStripMagicToken(t *testing.T) {
@@ -86,7 +93,7 @@ func TestRewriteBrowseHTML(t *testing.T) {
 		`<img srcset="/1.png 1x, /2.png 2x">` +
 		`<script>var s="/y";</script>` +
 		`</body></html>`
-	out := string(rewriteBrowseHTML([]byte(in), page, testProxyBase))
+	out := string(rewriteBrowseHTML([]byte(in), page, testProxyBase, ""))
 
 	wants := []string{
 		`href="http://p/b/https/example.com/x"`,
@@ -131,7 +138,7 @@ func TestRewriteCSS(t *testing.T) {
 	page := mustURL(t, "https://example.com/css/style.css")
 	in := `.a{background:url('/img/a.png')} .b{background:url(../img/b.png)}` +
 		`@import "sub.css"; @import url('/other.css');`
-	out := rewriteCSS(in, page, testProxyBase)
+	out := rewriteCSS(in, page, testProxyBase, "")
 	wants := []string{
 		`url(http://p/b/https/example.com/img/a.png)`,
 		`url(http://p/b/https/example.com/img/b.png)`,
@@ -145,6 +152,60 @@ func TestRewriteCSS(t *testing.T) {
 	}
 }
 
+// TestRewriteBrowseHTMLScriptSrc <script> 的**开标签属性**必须改写（src 等），
+// 内容原样保留。不改的后果：//cdn.example.com/a.js 这类协议相对地址绕过中转
+// 直连手机网络 —— 桌面端才能访问的内网站点照样裂（百度首页就挂着两个这种脚本）。
+func TestRewriteBrowseHTMLScriptSrc(t *testing.T) {
+	page := mustURL(t, "https://example.com/a/b")
+	in := `<script src="//cdn.example.com/a.js"></script>` +
+		`<script src="/local.js" defer></script>` +
+		`<script>var s="/y"; var u="https://keep.example.com/z";</script>` +
+		`<script type="application/json">{"src":"/not-a-url"}</script>`
+	out := string(rewriteBrowseHTML([]byte(in), page, testProxyBase, ""))
+
+	wants := []string{
+		`<script src="http://p/b/https/cdn.example.com/a.js"></script>`,
+		`<script src="http://p/b/https/example.com/local.js" defer></script>`,
+	}
+	for _, w := range wants {
+		if !strings.Contains(out, w) {
+			t.Errorf("script 开标签应被改写，缺少 %q\n实际：%s", w, out)
+		}
+	}
+	notWants := []string{
+		`/b/https/example.com/y`,         // 脚本内字符串不许动
+		`/b/https/keep.example.com/z`,    // 脚本内的绝对 URL 字符串也不许动
+		`/b/https/example.com/not-a-url`, // JSON 脚本块内容不许动
+	}
+	for _, nw := range notWants {
+		if strings.Contains(out, nw) {
+			t.Errorf("脚本内容不应被改写，却包含 %q\n实际：%s", nw, out)
+		}
+	}
+	if !strings.Contains(out, `var s="/y";`) || !strings.Contains(out, `var u="https://keep.example.com/z";`) {
+		t.Errorf("脚本内容应原样保留，实际：%s", out)
+	}
+}
+
+// TestRewriteBrowseHTMLToken 令牌要拼进每条改写出的 URL —— 跨站 iframe（APK 壳）下
+// SameSite=Lax cookie 不随子资源请求发送，URL 里的令牌是唯一凭据。
+func TestRewriteBrowseHTMLToken(t *testing.T) {
+	page := mustURL(t, "https://example.com/a/b")
+	in := `<img src="pic.png"><a href="/x?q=1">l</a>` +
+		`<div style="background:url('/bg.png')"></div>`
+	out := string(rewriteBrowseHTML([]byte(in), page, testProxyBase, "T"))
+	wants := []string{
+		`src="http://p/b/https/example.com/a/pic.png?magicToken=T"`,
+		`href="http://p/b/https/example.com/x?q=1&magicToken=T"`,
+		`url(http://p/b/https/example.com/bg.png?magicToken=T)`,
+	}
+	for _, w := range wants {
+		if !strings.Contains(out, w) {
+			t.Errorf("改写 URL 应带令牌，缺少 %q\n实际：%s", w, out)
+		}
+	}
+}
+
 // TestHandleBrowseE2E 端到端：起一个「拒绝内嵌」的上游站点，经中转取回，
 // 断言 (1) X-Frame-Options 被剥掉、(2) 页内链接被改写到本中转。
 func TestHandleBrowseE2E(t *testing.T) {
@@ -197,3 +258,40 @@ func TestHandleBrowseAuth(t *testing.T) {
 		t.Errorf("缺令牌应 401，实际 %d", resp.StatusCode)
 	}
 }
+
+// TestHandleBrowseTokenInURL 开了令牌时：改写出的 URL 必须带 ?magicToken=，
+// 且这个参数**不准透传给上游**（stripMagicToken 剥掉）。
+func TestHandleBrowseTokenInURL(t *testing.T) {
+	var gotQuery string
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotQuery = r.URL.RawQuery
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		_, _ = io.WriteString(w, `<html><head></head><body><img src="/pic.png"></body></html>`)
+	}))
+	defer upstream.Close()
+
+	up, err := url.Parse(upstream.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := &Service{opts: Options{Token: "sekret"}}
+	proxy := httptest.NewServer(http.HandlerFunc(s.handleBrowse))
+	defer proxy.Close()
+
+	resp, err := http.Get(proxy.URL + browsePrefix + "http/" + up.Host + "/?magicToken=sekret")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("带正确令牌应 200，实际 %d", resp.StatusCode)
+	}
+	want := `src="` + proxy.URL + browsePrefix + "http/" + up.Host + "/pic.png?magicToken=sekret" + `"`
+	if !strings.Contains(string(body), want) {
+		t.Errorf("改写出的子资源 URL 应带令牌，期望包含 %q\n实际：%s", want, body)
+	}
+	if strings.Contains(gotQuery, "magicToken") {
+		t.Errorf("magicToken 不准透传给上游，实际上游收到 query=%q", gotQuery)
+	}
+}