From e64ea0b156b1d41949aa07551203e01acfb6fb88 Mon Sep 17 00:00:00 2001 From: AskaEth Date: Sun, 4 Oct 2026 16:24:56 +0800 Subject: [PATCH] =?UTF-8?q?fix(vision):=20SSRF=20=E4=B8=89=E5=B1=82?= =?UTF-8?q?=E5=AE=88=E5=8D=AB=20+=20base64=20=E9=95=BF=E5=BA=A6=E9=A2=84?= =?UTF-8?q?=E6=A3=80=EF=BC=88=E7=BA=B5=E6=B7=B1=E9=98=B2=E5=BE=A1=EF=BC=8C?= =?UTF-8?q?F3/G3=20=E7=9A=84=E6=94=B6=E5=B0=BE=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - SSRF 三层：① 字面主机判定（**链路本地** `169.254.0.0/16`/`fe80::/10`（先 Unmap ⇒ `::ffff:169.254.169.254` 绕不过）+ 云元数据 `100.100.100.200`、`fd00:ec2::/64`）；② 重定向逐跳校验 + 上限 5 跳； ③ **建连前校验解析结果并用校验过的 IP 直连**（防 DNS 重绑，拨号器不再二次解析） - **没打断同源自取**（两条独立证据）：`127.0.0.1:/api/v1/files/<32hex>.png` 端到端取回成功、 私网地址**原样交给底层拨号器**；被拒地址则底层拨号器 0 次调用（无真实连接发出） - 失败文案**不含 URL/查询串签名**；非图片响应仍 `ErrNotImage` 且不泄漏响应体 - base64 路径长度预检（**先于 DecodeString 与 `data:` 短路**，零分配）：口径与网关同值同推导 （`((5MiB+2)/3)*4+64`），超限 `ErrImageTooLarge`、文案只含上限与本次长度 - 复核：vision 包 build/vet/测试绿（15 条新用例）；**4 条变异反证**（守卫整体短路 → 8 条被拒地址全中； 只短路链路本地分支 → 4 红且实测「无守卫时进程真的去连 169.254.169.254」；预检恒 nil → 3 红； 去掉重定向校验仍全绿 ⇒ 证明第三层独立兜住） - 登记：`CHAT_IMAGE_MAX_BYTES` 调大 > 默认时「网关照放、vision 拒」的配置耦合（待单一真源对齐） --- internal/runtime/multimodal/vision/errors.go | 6 + internal/runtime/multimodal/vision/guard.go | 241 ++++++++++++++++++ .../runtime/multimodal/vision/guard_test.go | 238 +++++++++++++++++ internal/runtime/multimodal/vision/image.go | 40 ++- internal/runtime/multimodal/vision/limits.go | 41 +++ .../runtime/multimodal/vision/limits_test.go | 128 ++++++++++ 6 files changed, 686 insertions(+), 8 deletions(-) create mode 100644 internal/runtime/multimodal/vision/guard.go create mode 100644 internal/runtime/multimodal/vision/guard_test.go create mode 100644 internal/runtime/multimodal/vision/limits.go create mode 100644 internal/runtime/multimodal/vision/limits_test.go diff --git a/internal/runtime/multimodal/vision/errors.go b/internal/runtime/multimodal/vision/errors.go index 9caa868..3405b5b 100644 --- a/internal/runtime/multimodal/vision/errors.go +++ b/internal/runtime/multimodal/vision/errors.go @@ -22,4 +22,10 @@ var ( ErrNotImage = errors.New("vision: source is not an image") // ErrBadArgs 在工具参数格式错误时由该工具返回。 ErrBadArgs = errors.New("vision: bad tool arguments") + // ErrBlockedAddress 在图像 URL 指向被拒的链路本地/云元数据地址时返回 + // （见 guard.go）。错误只带主机与网段原因，不带 URL 或其中的凭据。 + ErrBlockedAddress = errors.New("vision: image URL points at a blocked address") + // ErrImageTooLarge 在内联图像（base64 / data: URI）字符串超过上限时返回。 + // 判定在解码与短路之前完成，错误信息只带上限与本次长度。 + ErrImageTooLarge = errors.New("vision: inline image is too large") ) diff --git a/internal/runtime/multimodal/vision/guard.go b/internal/runtime/multimodal/vision/guard.go new file mode 100644 index 0000000..dbf7722 --- /dev/null +++ b/internal/runtime/multimodal/vision/guard.go @@ -0,0 +1,241 @@ +package vision + +import ( + "context" + "errors" + "fmt" + "net" + "net/http" + "net/netip" + "net/url" +) + +// 图像 URL 守卫：服务端会代取用户/渠道传入的任意 http(s) URL（F3 之后 +// 含 IM 陌生人的来图），因此取回链路必须自己拦下链路本地与云元数据地址， +// 不能指望入口层过滤。这里只收紧「链路本地 + 云元数据」：环回、私网与 +// 公网保持原样可达 —— 同源自取需要它们（本服务要能取自己的 +// http://<局域网地址>:10942/api/v1/files/…）。 +// +// 判定分三层，任一层命中都拒绝： +// 1. 取回前对字面主机校验（guardImageURL）：IP 字面量立即被拒， +// DNS 名放行到下一层； +// 2. 重定向每一跳重新校验（guardedCheckRedirect）：跨主机跳转不得落到 +// 被拒网段； +// 3. 真正建连前校验解析结果（guardedDialContext）：解析到被拒地址的连接 +// 根本不会建立，也顺带让「先答公网 IP、再答元数据 IP」的 DNS 重绑失效。 +// +// 三层只报「主机 + 网段原因」，绝不把 URL、userinfo 或查询串写进错误。 + +// maxImageRedirects 是一次取回最多跟随的重定向跳数。与 net/http 默认的 10 +// 同形，只是更小：取一张图不需要长跳转链，少跟几跳就少几次对陌生主机的连接。 +const maxImageRedirects = 5 + +// 被拒的云元数据地址以字符串常量给出（netip 的值只能是变量，而本项目约束 +// 不允许包级变量，只允许 var ErrXxx），判定时解析一次即可。 +const ( + // alibabaIMDSv4 是阿里云 ECS 元数据地址，落在 100.64.0.0/10 共享地址段内。 + alibabaIMDSv4 = "100.100.100.200" + // awsIMDSv6Prefix 是 AWS 元数据专用 IPv6 前缀，fd00:ec2::254 在其内。 + // IPv6 ULA（fd00::/8）整体仍按私网放行，只拒这一个前缀。 + awsIMDSv6Prefix = "fd00:ec2::/64" +) + +// blockedAddressError 是被拒地址的错误：只携带主机与网段原因， +// 绝不携带 URL 或其中的凭据，因此即使被 net/http 的 *url.Error 包裹 +// （重定向与拨号失败都走这条路径），也能用 errors.As 取回原因原样呈现。 +type blockedAddressError struct { + host string + reason string +} + +func (e *blockedAddressError) Error() string { + return fmt.Sprintf("%s: %s（主机 %s）", ErrBlockedAddress, e.reason, e.host) +} + +func (e *blockedAddressError) Unwrap() error { return ErrBlockedAddress } + +// blockedImageAddrReason 报告 addr 是否属于被拒的链路本地/云元数据地址， +// 是则给出原因（用于错误文案）。IPv4-mapped 形式 +// （::ffff:169.254.169.254）先经 Unmap 归一到 IPv4 再判定，绕不过去； +// IPv6 ULA（fd00::/8）整体仍按私网放行，只拒云元数据专用的 fd00:ec2::/64。 +func blockedImageAddrReason(addr netip.Addr) (string, bool) { + if !addr.IsValid() { + return "", false + } + addr = addr.Unmap() + // netip 的 IsLinkLocalUnicast 同时覆盖 IPv4 169.254.0.0/16 + // （含云元数据 169.254.169.254）与 IPv6 fe80::/10。 + if addr.IsLinkLocalUnicast() { + return "链路本地地址 169.254.0.0/16（含云元数据 169.254.169.254）或 fe80::/10", true + } + if addr == netip.MustParseAddr(alibabaIMDSv4) { + return "云元数据地址 " + alibabaIMDSv4 + "（阿里云 ECS）", true + } + // AWS IMDSv6：fd00:ec2::254 落在 AWS 元数据专用前缀内。 + if netip.MustParsePrefix(awsIMDSv6Prefix).Contains(addr) { + return "云元数据地址 " + awsIMDSv6Prefix + "（AWS IMDSv6）", true + } + return "", false +} + +// guardImageURL 校验一个待取回/待跳转的 URL：协议必须仍是 http/https， +// 且主机不得是被拒地址。主机是 DNS 名时这里放行（字面量判不出解析结果）， +// 由 guardedDialContext 在建连前按解析结果继续拦。 +func guardImageURL(u *url.URL) error { + if u == nil { + return fmt.Errorf("vision: %w: 空的 URL", ErrUnsupportedSource) + } + if u.Scheme != "http" && u.Scheme != "https" { + return fmt.Errorf("vision: %w: 仅支持 http/https", ErrUnsupportedSource) + } + host := u.Hostname() + if host == "" { + return fmt.Errorf("vision: %w: URL 缺少主机", ErrFetch) + } + addr, err := netip.ParseAddr(host) + if err != nil { + return nil + } + reason, blocked := blockedImageAddrReason(addr) + if !blocked { + return nil + } + return &blockedAddressError{host: host, reason: reason} +} + +// guardedImageClient 返回带守卫的 http.Client **副本**，绝不改动传入的 +// client（调用方可能把它共享给上游 chat 请求等其他用途）：重定向逐跳校验 +// 并限跳，未设超时时取下限超时（复用 imageFetchTimeout），传输层换成 +// 「建连前按解析结果校验」的副本。 +func guardedImageClient(base *http.Client) *http.Client { + c := &http.Client{} + if base != nil { + *c = *base + } + if c.Timeout <= 0 { + c.Timeout = imageFetchTimeout + } + c.Transport = guardedImageTransport(base) + c.CheckRedirect = guardedCheckRedirect + return c +} + +// guardedImageTransport 返回带拨号守卫的传输层。用 *http.Transport 的副本 +// 是为了把校验下沉到真正建连的一刻（连接池是逐 Transport 的，因此副本也 +// 意味着每次取图新建连接；换取的是一张图都取不到被拒网段）。调用方给了 +// 非 *http.Transport 的自定义 RoundTripper 时保留它 —— 此时字面主机与 +// 重定向两层守卫仍然生效。走环境代理时拨号目标是代理本身（不是图片主机）， +// 那种形态下拦下被拒网段的是前两层：字面主机与重定向逐跳校验。 +func guardedImageTransport(base *http.Client) http.RoundTripper { + if base != nil && base.Transport != nil { + bt, ok := base.Transport.(*http.Transport) + if !ok { + return base.Transport + } + return guardedTransport(bt) + } + dt, ok := http.DefaultTransport.(*http.Transport) + if !ok { + return http.DefaultTransport + } + return guardedTransport(dt) +} + +// guardedTransport 复制 t 并把拨号改为守卫版本。 +func guardedTransport(t *http.Transport) *http.Transport { + clone := t.Clone() + clone.DialContext = guardedDialContext(clone.DialContext) + return clone +} + +// guardedCheckRedirect 校验重定向的每一跳：跳数有上限，跳转目标必须仍是 +// http/https 且不是被拒地址。跨主机跳转因此不能把取回引到 169.254.169.254 +// 或 fd00:ec2::254 上；即便这一层被绕过，第三层的拨号守卫也不会真正建连。 +func guardedCheckRedirect(req *http.Request, via []*http.Request) error { + if len(via) >= maxImageRedirects { + // 这里不包 ErrFetch：可由 fetchURL 统一包一层， + // 免得同一句话被套上两层前缀。 + return fmt.Errorf("重定向超过 %d 跳", maxImageRedirects) + } + return guardImageURL(req.URL) +} + +// dialFunc 与 net.Dialer.DialContext 同形，便于测试注入假拨号器。 +type dialFunc func(ctx context.Context, network, addr string) (net.Conn, error) + +// guardedDialContext 在真正建连**之前**校验目标地址的解析结果：只要解析 +// 结果里有被拒地址，整次连接就被拒（宁可不取这张图，也不让进程去连元数据 +// 服务）；随后用校验过的 IP 直接连接，拨号器不会再解析一次，「先答公网 IP、 +// 再答元数据 IP」的 DNS 重绑因此无从生效。 +func guardedDialContext(base dialFunc) dialFunc { + if base == nil { + dialer := &net.Dialer{Timeout: imageFetchTimeout} + base = dialer.DialContext + } + return func(ctx context.Context, network, addr string) (net.Conn, error) { + host, port, err := net.SplitHostPort(addr) + if err != nil { + return nil, fmt.Errorf("vision: %w: 目标地址无法解析", ErrFetch) + } + addrs, err := resolveImageHost(ctx, host) + if err != nil { + return nil, err + } + for _, a := range addrs { + if reason, blocked := blockedImageAddrReason(a); blocked { + return nil, &blockedAddressError{host: host, reason: reason} + } + } + var lastErr error + for _, a := range addrs { + conn, err := base(ctx, network, net.JoinHostPort(a.Unmap().String(), port)) + if err == nil { + return conn, nil + } + lastErr = err + if ctx.Err() != nil { + break + } + } + if lastErr == nil { + return nil, fmt.Errorf("vision: %w: 主机 %s 没有可用地址", ErrFetch, host) + } + return nil, lastErr + } +} + +// resolveImageHost 把主机名解析为 IP 列表；主机已是 IP 字面量时直接返回它， +// 不再查一次 DNS。 +func resolveImageHost(ctx context.Context, host string) ([]netip.Addr, error) { + if addr, err := netip.ParseAddr(host); err == nil { + return []netip.Addr{addr}, nil + } + addrs, err := net.DefaultResolver.LookupNetIP(ctx, "ip", host) + if err != nil { + return nil, fmt.Errorf("vision: %w: 解析主机 %s 失败: %v", ErrFetch, host, err) + } + if len(addrs) == 0 { + return nil, fmt.Errorf("vision: %w: 主机 %s 没有解析结果", ErrFetch, host) + } + return addrs, nil +} + +// blockedAddressOf 从（可能被 *url.Error 包裹的）错误里取回被拒地址错误， +// 使调用方能直接呈现「主机 + 网段原因」而不是带回整条 URL 的错误串。 +func blockedAddressOf(err error) (*blockedAddressError, bool) { + var blocked *blockedAddressError + if errors.As(err, &blocked) { + return blocked, true + } + return nil, false +} + +// fetchCause 返回取回失败的底层原因：*url.Error 会把整条 URL（含查询串里 +// 可能的凭据）拼进错误串，这里只取内层错误，哨兵链因此也保留下来。 +func fetchCause(err error) error { + var uerr *url.Error + if errors.As(err, &uerr) && uerr.Err != nil { + return uerr.Err + } + return err +} diff --git a/internal/runtime/multimodal/vision/guard_test.go b/internal/runtime/multimodal/vision/guard_test.go new file mode 100644 index 0000000..a85a118 --- /dev/null +++ b/internal/runtime/multimodal/vision/guard_test.go @@ -0,0 +1,238 @@ +package vision + +import ( + "bytes" + "context" + "errors" + "net" + "net/http" + "net/http/httptest" + "net/netip" + "strings" + "sync/atomic" + "testing" + "time" +) + +// TestBlockedImageAddrReason 钉住被拒网段的判定：链路本地 +// （IPv4/IPv6，含 IPv4-mapped 形式）与已知云元数据地址一律拒绝；环回、 +// 私网（含 IPv6 ULA）与公网必须放行 —— 后者是同源自取 +// （本服务的局域网 URL）能继续工作的前提。 +func TestBlockedImageAddrReason(t *testing.T) { + t.Parallel() + blocked := []string{ + "169.254.169.254", // 云元数据（AWS/GCP/Azure/Azure IMDSv4） + "169.254.0.23", // 腾讯云元数据（同一链路本地网段） + "::ffff:169.254.169.254", // IPv4-mapped 形式不得绕过 + "::ffff:169.254.0.23", + "fe80::1", // fe80::/10 + "fe80::a9fe:a9fe", + "fd00:ec2::254", // AWS IMDSv6 + "100.100.100.200", // 阿里云元数据 + } + for _, s := range blocked { + if reason, got := blockedImageAddrReason(netip.MustParseAddr(s)); !got { + t.Errorf("%s 未被拒绝", s) + } else if reason == "" { + t.Errorf("%s 被拒但没有给出原因文案", s) + } + } + allowed := []string{ + "127.0.0.1", "::1", // 环回：测试与同源自取都要用 + "192.168.1.10", "10.0.0.5", "172.16.9.1", // 私网 IPv4：同源自取的常态 + "fd00::1", "fd12:3456::1", // IPv6 ULA 整体仍按私网放行 + "8.8.8.8", "2001:db8::1", // 公网 + } + for _, s := range allowed { + if reason, got := blockedImageAddrReason(netip.MustParseAddr(s)); got { + t.Errorf("%s 被误拒（同源自取会被打断）：%s", s, reason) + } + } +} + +// TestResolve_RejectsMetadataAndLinkLocalLiterals 是 SSRF 收紧的主用例： +// 字面量元数据/链路本地地址必须在发起任何连接之前被拒；错误里不得出现 +// URL 与凭据，只允许出现主机与网段原因。 +func TestResolve_RejectsMetadataAndLinkLocalLiterals(t *testing.T) { + t.Parallel() + cases := []string{ + "http://169.254.169.254/latest/meta-data/iam/security-credentials/", + "http://[::ffff:169.254.169.254]/latest/meta-data/", + "http://[fe80::1]:10942/api/v1/files/x.png", + "http://[fd00:ec2::254]/latest/meta-data/", + "http://user:secret@169.254.169.254/latest/meta-data/?token=abc", + "https://100.100.100.200/latest/meta-data/", + } + for _, u := range cases { + _, _, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: u}, nil) + if !errors.Is(err, ErrBlockedAddress) { + t.Errorf("Resolve(%s) error = %v, want ErrBlockedAddress", u, err) + continue + } + msg := err.Error() + for _, leak := range []string{"http://", "https://", "secret", "token=", "meta-data"} { + if strings.Contains(msg, leak) { + t.Errorf("错误泄漏了 URL/凭据（含 %q）：%v", leak, err) + } + } + } +} + +// TestResolve_AllowsSelfOriginatedURL 是「没打断自取」的端到端证据： +// 同源自取的地址形状正是 +// http://<主机>:10942/api/v1/files/<32 位十六进制名>.。用 httptest +// （绑定环回）模拟同源服务，走完整 Resolve→fetchURL→守卫链路，证明 +// 环回/私网仍可取回，且守卫没有改坏取回本身（MIME 与字节都不变）。 +func TestResolve_AllowsSelfOriginatedURL(t *testing.T) { + t.Parallel() + png := pngBytes(t) + srv := newImageServer(t, png, "image/png", nil) + selfURL := srv.URL + "/api/v1/files/" + strings.Repeat("a", 32) + ".png" + + mime, data, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: selfURL}, nil) + if err != nil { + t.Fatalf("Resolve(%s): %v（同源自取被守卫打断）", selfURL, err) + } + if mime != "image/png" || !bytes.Equal(data, png) { + t.Fatalf("Resolve = (%q, %d bytes), want (image/png, %d bytes)", mime, len(data), len(png)) + } +} + +// TestGuardedDialContext_LayerThree 钉住第三层（建连前按解析结果校验）： +// 局域网自取地址必须原样交给底层拨号器（即不打断自取），而被拒网段在 +// 建连之前失败，且底层拨号器**根本不会被调用**（没有真正的连接发出）。 +func TestGuardedDialContext_LayerThree(t *testing.T) { + t.Parallel() + var dialed []string + base := func(_ context.Context, _, addr string) (net.Conn, error) { + dialed = append(dialed, addr) + return nil, errors.New("dial stub") + } + dial := guardedDialContext(base) + + if _, err := dial(context.Background(), "tcp", "192.168.1.10:10942"); err == nil { + t.Fatal("底层拨号桩必然失败，这里应回传错误") + } + if len(dialed) != 1 || dialed[0] != "192.168.1.10:10942" { + t.Fatalf("局域网地址未被交给底层拨号器：%v（同源自取会被打断）", dialed) + } + + _, err := dial(context.Background(), "tcp", "169.254.169.254:80") + if !errors.Is(err, ErrBlockedAddress) { + t.Fatalf("error = %v, want ErrBlockedAddress", err) + } + if len(dialed) != 1 { + t.Fatalf("被拒地址仍然发起了连接：%v", dialed) + } +} + +// TestFetchURL_RejectsRedirectToBlockedAddress 钉住第二层：跨主机重定向 +// 不得把取回引到元数据/链路本地网段，被拒的那一跳根本不会发出（源服务 +// 只收到第一次请求），且错误里不带 URL。 +func TestFetchURL_RejectsRedirectToBlockedAddress(t *testing.T) { + t.Parallel() + var hits atomic.Int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + hits.Add(1) + http.Redirect(w, r, "http://169.254.169.254/latest/meta-data/", http.StatusFound) + })) + t.Cleanup(srv.Close) + + _, _, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: srv.URL + "/redirect"}, nil) + if !errors.Is(err, ErrBlockedAddress) { + t.Fatalf("error = %v, want ErrBlockedAddress", err) + } + if hits.Load() != 1 { + t.Fatalf("源服务收到 %d 次请求，want 1（被拒的跳不得发出）", hits.Load()) + } + if msg := err.Error(); strings.Contains(msg, "http://") || strings.Contains(msg, "meta-data") { + t.Fatalf("错误泄漏了 URL：%v", err) + } +} + +// TestFetchURL_LimitsRedirectChain 钉住重定向上限：自我循环的重定向不得 +// 把一次取回变成无限跟随（每多跟一跳就多连一次陌生主机）。 +func TestFetchURL_LimitsRedirectChain(t *testing.T) { + t.Parallel() + var hits atomic.Int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + hits.Add(1) + http.Redirect(w, r, "/again", http.StatusFound) + })) + t.Cleanup(srv.Close) + + _, _, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: srv.URL + "/loop"}, nil) + if err == nil { + t.Fatal("自我循环的重定向未报错") + } + if !errors.Is(err, ErrFetch) { + t.Fatalf("error = %v, want ErrFetch", err) + } + if got := hits.Load(); got != maxImageRedirects { + t.Fatalf("请求了 %d 次，want %d（= 重定向上限）", got, maxImageRedirects) + } +} + +// TestFetchURL_StillRejectsHTMLAtAllowedAddress 钉住既有断言在换上新守卫 +// client 之后仍然成立：守卫只拦地址，不改变字节嗅探的否决权 —— 允许地址 +// 上的 text/html 错误页仍明确报 ErrNotImage，且不泄漏页面内容。 +func TestFetchURL_StillRejectsHTMLAtAllowedAddress(t *testing.T) { + t.Parallel() + srv := newImageServer(t, htmlBytes(), "text/html; charset=utf-8", nil) + _, _, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: srv.URL + "/err"}, nil) + if !errors.Is(err, ErrNotImage) { + t.Fatalf("error = %v, want ErrNotImage", err) + } + if strings.Contains(err.Error(), "502 Bad Gateway") { + t.Fatalf("错误泄漏了响应体：%v", err) + } +} + +// TestFetchURL_FailureDoesNotEchoURL 钉住取回失败的文案不外泄 URL/凭据： +// *url.Error 会把整条 URL（查询串里的签名也是凭据）拼进错误串， +// 因此失败路径必须剥掉它，只留底层原因，并仍可被 ErrFetch 判定。 +func TestFetchURL_FailureDoesNotEchoURL(t *testing.T) { + t.Parallel() + srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + target := srv.URL + "/cat.png?token=SECRETSIG" + srv.Close() // 关闭后取回必然失败（端口无人监听） + + _, _, err := Resolve(context.Background(), ImageRef{Source: SourceURL, Data: target}, nil) + if err == nil { + t.Fatal("取回已关闭的地址未报错") + } + if !errors.Is(err, ErrFetch) { + t.Fatalf("error = %v, want ErrFetch", err) + } + if msg := err.Error(); strings.Contains(msg, "SECRETSIG") || strings.Contains(msg, "token=") || strings.Contains(msg, "http://") { + t.Fatalf("取回失败的文案外泄了 URL/凭据：%v", err) + } +} + +// TestGuardedImageClient_DoesNotMutateCaller 钉住「不改调用方 client」： +// 适配器把同一个 client 也用于上游 chat 请求，若守卫原地改它，上游请求会 +// 被套上取图专用的重定向/拨号守卫（跨用途的副作用）。 +func TestGuardedImageClient_DoesNotMutateCaller(t *testing.T) { + t.Parallel() + base := &http.Client{} + guarded := guardedImageClient(base) + + if base.CheckRedirect != nil || base.Transport != nil || base.Timeout != 0 { + t.Fatalf("调用方 client 被原地修改：%+v", base) + } + if guarded == base { + t.Fatal("守卫必须返回副本，而不是同一个 client") + } + if guarded.CheckRedirect == nil { + t.Fatal("副本没有装重定向守卫") + } + if guarded.Timeout != imageFetchTimeout { + t.Fatalf("副本超时 = %v, want %v（复用既有取回超时）", guarded.Timeout, imageFetchTimeout) + } + + // 调用方显式设过超时时不得被覆盖。 + withTimeout := &http.Client{Timeout: time.Minute} + if got := guardedImageClient(withTimeout).Timeout; got != time.Minute { + t.Fatalf("调用方超时被改写：%v", got) + } +} diff --git a/internal/runtime/multimodal/vision/image.go b/internal/runtime/multimodal/vision/image.go index c94b95d..b06f6eb 100644 --- a/internal/runtime/multimodal/vision/image.go +++ b/internal/runtime/multimodal/vision/image.go @@ -6,6 +6,7 @@ import ( "fmt" "io" "net/http" + "net/url" "os" "strings" "time" @@ -21,7 +22,8 @@ const ( // imageFetchTimeout 限制一次图像 URL 取回的时长。适配器与消息解析器会 // 为模型代取 URL，没有上限时一个卡住或恶意的地址会一直占着这一轮 -// （fetchURL 复用默认 client，其本身不设整体超时）。 +// （fetchURL 经 guardedImageClient 给未设超时的 client 补上它， +// 拨号守卫也用同一个值作单次建连上限）。 const imageFetchTimeout = 30 * time.Second // DataURI 由 mime 与原始字节构造一个 base64 data: 图像 URI。 @@ -66,7 +68,12 @@ func readFile(path string) (string, []byte, error) { } // decodeBase64 返回 base64/data: 载荷解码后的字节及其 MIME。 +// 长度预检先于解码与 data: 解析（见 checkInlineImageLength）：超限载荷在 +// 分配之前就被拦下，而不是先按约 4/3 分配再报错。 func decodeBase64(src string) (string, []byte, error) { + if err := checkInlineImageLength(src); err != nil { + return "", nil, err + } mime, encoded, isDataURI := splitDataURI(src) if isDataURI { decoded, err := base64.StdEncoding.DecodeString(encoded) @@ -83,22 +90,35 @@ func decodeBase64(src string) (string, []byte, error) { } // fetchURL 通过 http(s) 下载一张图像；只允许 http/https 协议。 +// 取回前、重定向每一跳与真正建连前都有守卫（见 guard.go）：链路本地与 +// 云元数据地址被拒，环回/私网/公网照旧可达（同源自取需要它们）。 // 声明的 Content-Type 只作参考，真实字节嗅探说了算（见 imageMIMEFor）： // 网关/PROXY 返回的 HTML 错误页绝不会被当成 png 送进模型。 func fetchURL(ctx context.Context, rawURL string, client *http.Client) (string, []byte, error) { if !strings.HasPrefix(rawURL, "http://") && !strings.HasPrefix(rawURL, "https://") { return "", nil, fmt.Errorf("vision: %w: %q", ErrUnsupportedSource, rawURL) } - if client == nil { - client = defaultHTTPClient() + u, err := url.Parse(rawURL) + if err != nil { + // 不回显 URL：解析失败的原文里带着整条地址（可能含凭据）。 + return "", nil, fmt.Errorf("vision: %w: URL 无法解析", ErrFetch) } + if err := guardImageURL(u); err != nil { + return "", nil, err + } + guarded := guardedImageClient(client) req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil) if err != nil { - return "", nil, fmt.Errorf("vision: %w: %v", ErrFetch, err) + return "", nil, fmt.Errorf("vision: %w: 无法构造请求", ErrFetch) } - resp, err := client.Do(req) + resp, err := guarded.Do(req) if err != nil { - return "", nil, fmt.Errorf("vision: %w: %v", ErrFetch, err) + // 被拒地址直接返回类型化错误：它只含主机与网段原因， + // 不像 client.Do 的 *url.Error 那样把整条 URL（可能含凭据）带出来。 + if blocked, ok := blockedAddressOf(err); ok { + return "", nil, blocked + } + return "", nil, fmt.Errorf("vision: %w: %w", ErrFetch, fetchCause(err)) } defer func() { _ = resp.Body.Close() }() if resp.StatusCode != http.StatusOK { @@ -117,10 +137,14 @@ func fetchURL(ctx context.Context, rawURL string, client *http.Client) (string, // inlineImageSrc 把图像来源字符串取回并内联为 data: URI，供主模型 // 直接消费。已是 data: URI 的原样返回（客户端现有的 base64 路径因此 -// 逐字节不变）。URL 取回复用 Resolve→fetchURL 的既有守卫 -// （协议白名单 + 体积上限），并加取回超时。 +// 逐字节不变），但**短路之前**也要过长度预检：这条路径不解码，不预检 +// 就等于把体积上限完全交给入口层。URL 取回复用 Resolve→fetchURL 的既有 +// 守卫（协议白名单 + 体积上限 + 地址守卫），并加取回超时。 func inlineImageSrc(ctx context.Context, src string) (string, error) { if strings.HasPrefix(src, "data:") { + if err := checkInlineImageLength(src); err != nil { + return "", err + } return src, nil } ref, err := ParseImageRef(src) diff --git a/internal/runtime/multimodal/vision/limits.go b/internal/runtime/multimodal/vision/limits.go new file mode 100644 index 0000000..4d9a362 --- /dev/null +++ b/internal/runtime/multimodal/vision/limits.go @@ -0,0 +1,41 @@ +package vision + +import "fmt" + +// 内联图像（base64 / data: URI）的体积预算：与网关 REST 入口 +// internal/services/gateway/rest.go 的图片上限同口径 —— 5 MiB 解码后字节， +// 外加 64 字符的 data: 前缀余量。网关是**入口层**实现，这里是**解码层**的 +// 同一口径兜底：REST 入口已有 5 MiB 上限，但任何未来新入口，或把 WS 上限 +// 放宽，都会重新打开「先按约 4/3 分配再报错」这个洞（G3 的纵深）。 +// +// 口径换算只有一处：(n+2)/3*4 是 base64 每 3 字节编码为 4 字符的膨胀系数 +// （余 1、2 字节时末组仍需补满 4 字符），再加 data: 前缀余量 —— 恰好 +// 5 MiB 的合法图片编码后正好等于该上限，不会被误拒。 +// +// 注意生效范围：网关的生效上限可由配置 CHAT_IMAGE_MAX_BYTES 调整（默认 +// 5242880 与本常量同值），本包读不到网关配置，因此这里钉住的是**默认口径的 +// 硬顶** —— 解码层不随入口配置放宽；入口层比它更严时以入口层为准。 +const ( + // MaxInlineImageBytes 是一张内联图像解码后的字节上限（5 MiB）， + // 与网关 POST /api/v1/upload 的 maxUploadBytes 同口径。 + MaxInlineImageBytes = 5 << 20 + // InlineImagePrefixAllowance 是 data: URI 前缀（如 + // "data:image/png;base64,"）所占的字符余量，不含 base64 载荷本身。 + InlineImagePrefixAllowance = 64 + // MaxInlineImageChars 是同一口径换算到 base64 字符串长度的上限。 + MaxInlineImageChars = ((MaxInlineImageBytes+2)/3)*4 + InlineImagePrefixAllowance +) + +// checkInlineImageLength 对 base64 / data: URI 字符串做长度预检，在任何 +// 解码或短路之前拦下超限载荷：解码要先按约 4/3 分配，不预检就是「先分配 +// 再报错」，放宽了入口上限的新入口会因此被放大成内存压力。判定按**字符串 +// 长度**（零分配），与网关入口 checkChatImageSize 同一口径。 +// +// 错误文案只带上限与本次长度，绝不包含图片内容。 +func checkInlineImageLength(src string) error { + if len(src) <= MaxInlineImageChars { + return nil + } + return fmt.Errorf("vision: %w: 内联图像上限 %d 字符（解码后约 %d MiB），本次 %d 字符", + ErrImageTooLarge, MaxInlineImageChars, MaxInlineImageBytes>>20, len(src)) +} diff --git a/internal/runtime/multimodal/vision/limits_test.go b/internal/runtime/multimodal/vision/limits_test.go new file mode 100644 index 0000000..873a914 --- /dev/null +++ b/internal/runtime/multimodal/vision/limits_test.go @@ -0,0 +1,128 @@ +package vision + +import ( + "bytes" + "context" + "encoding/base64" + "errors" + "strings" + "testing" +) + +// TestInlineImageLengthBoundary 钉住长度预检的边界与错误文案：恰好等于 +// 上限通过，多一个字符就报 ErrImageTooLarge。比较运算符一旦被挪位 +// （>= / <），或口径被换成另一个数，这里立刻红。 +func TestInlineImageLengthBoundary(t *testing.T) { + t.Parallel() + if err := checkInlineImageLength(strings.Repeat("A", MaxInlineImageChars)); err != nil { + t.Fatalf("恰好等于上限被拒：%v", err) + } + err := checkInlineImageLength(strings.Repeat("A", MaxInlineImageChars+1)) + if !errors.Is(err, ErrImageTooLarge) { + t.Fatalf("error = %v, want ErrImageTooLarge", err) + } + msg := err.Error() + if !strings.Contains(msg, "上限") || !strings.Contains(msg, "699") { + t.Fatalf("文案没有带上限：%v", err) + } + if strings.Contains(msg, "AAAA") { + t.Fatalf("文案泄漏了载荷内容：%v", err) + } +} + +// TestMaxInlineImageCharsMatchesByteBudget 钉住换算口径：字符上限换算回 +// 解码字节必须装得下一张满额 5 MiB 图，余量只能是 data: 前缀那点字符， +// 不能顺带塞进第二张图 —— 与网关入口 checkChatImageSize 同一口径。 +func TestMaxInlineImageCharsMatchesByteBudget(t *testing.T) { + t.Parallel() + if got := MaxInlineImageChars / 4 * 3; got < MaxInlineImageBytes { + t.Fatalf("字符上限只装得下 %d 字节，少于预算 %d", got, MaxInlineImageBytes) + } + if want := ((MaxInlineImageBytes+2)/3)*4 + InlineImagePrefixAllowance; MaxInlineImageChars != want { + t.Fatalf("MaxInlineImageChars = %d, want %d（base64 膨胀 4/3 + 前缀余量）", MaxInlineImageChars, want) + } + if MaxInlineImageChars > ((MaxInlineImageBytes+2)/3)*4+4096 { + t.Fatalf("余量过大（应只是 data: 前缀余量）：%d", MaxInlineImageChars) + } + if MaxInlineImageBytes != 5<<20 { + t.Fatalf("MaxInlineImageBytes = %d, want 5 MiB（与上传/网关口徑同值）", MaxInlineImageBytes) + } +} + +// TestDecodeBase64_RejectsOversizeBeforeDecoding 钉住「预检先于解码」： +// 用一段既超限又非法 base64 的载荷，错误必须是 ErrImageTooLarge 而不是 +// ErrBadImage —— 后者只可能来自 base64.StdEncoding.DecodeString， +// 也就是「先按约 4/3 分配再报错」，正是要避免的那一步。 +func TestDecodeBase64_RejectsOversizeBeforeDecoding(t *testing.T) { + t.Parallel() + oversize := strings.Repeat("!", MaxInlineImageChars+1) + if _, _, err := decodeBase64(oversize); !errors.Is(err, ErrImageTooLarge) { + t.Fatalf("裸载荷 error = %v, want ErrImageTooLarge（预检没有先于解码）", err) + } + if _, _, err := decodeBase64("data:image/png;base64," + oversize); !errors.Is(err, ErrImageTooLarge) { + t.Fatalf("data: URI error = %v, want ErrImageTooLarge", err) + } +} + +// TestInlineImageSrc_RejectsOversizeDataURI 覆盖短路路径：data: URI 在 +// 原样返回**之前**也要过预检（这条路径不解码，此前完全不看体积）， +// 而恰好等于上限的合法串必须逐字节原样返回、不受影响。 +func TestInlineImageSrc_RejectsOversizeDataURI(t *testing.T) { + t.Parallel() + prefix := "data:image/png;base64," + oversize := prefix + strings.Repeat("A", MaxInlineImageChars) + if _, err := inlineImageSrc(context.Background(), oversize); !errors.Is(err, ErrImageTooLarge) { + t.Fatalf("error = %v, want ErrImageTooLarge", err) + } + + exact := prefix + strings.Repeat("A", MaxInlineImageChars-len(prefix)) + got, err := inlineImageSrc(context.Background(), exact) + if err != nil { + t.Fatalf("恰好等于上限的 data: URI 被拒：%v", err) + } + if got != exact { + t.Fatal("短路路径改动了原串（客户端 base64 路径必须逐字节不变）") + } +} + +// TestDecodeBase64_ExactBudgetImagePasses 用一张**恰好 5 MiB** 的载荷把口径 +// 从字符数真的换算回解码字节数：满额图片编码后的字符串必须仍在字符上限内 +// （否则网关入口与解码层对「一张图能有多大」给出了两个答案），解码结果 +// 逐字节一致，绝不能误拒 —— 这正是「恰好 = 上限通过」的字节侧半边。 +// +// 判定口径是**字符数**（与网关入口一致，含 64 字符的 data: 前缀余量）， +// 因此多出几十字节的载荷仍可能落在余量内通过；字符侧的 +1 越界由 +// TestInlineImageLengthBoundary 钉住，余量本身不超过 64 字符 +// （TestMaxInlineImageCharsMatchesByteBudget）。 +func TestDecodeBase64_ExactBudgetImagePasses(t *testing.T) { + t.Parallel() + exact := bytes.Repeat([]byte{0x5a}, MaxInlineImageBytes) + dataURI := DataURI("image/png", exact) + if len(dataURI) > MaxInlineImageChars { + t.Fatalf("满额图片编码后 %d 字符，超过上限 %d（口径不一致）", len(dataURI), MaxInlineImageChars) + } + mime, data, err := decodeBase64(dataURI) + if err != nil { + t.Fatalf("满额图片被拒：%v", err) + } + if mime != "image/png" || !bytes.Equal(data, exact) { + t.Fatalf("满额图片解码结果不一致：mime=%q bytes=%d", mime, len(data)) + } +} + +// TestDecodeBase64_SmallPayloadUnchanged 钉住预检不伤正常载荷：一张小图的 +// data: URI 解码后 MIME 与字节都不变。 +func TestDecodeBase64_SmallPayloadUnchanged(t *testing.T) { + t.Parallel() + png := pngBytes(t) + mime, data, err := decodeBase64(DataURI("image/png", png)) + if err != nil { + t.Fatalf("decodeBase64: %v", err) + } + if mime != "image/png" || !bytes.Equal(data, png) { + t.Fatalf("decodeBase64 = (%q, %d bytes), want (image/png, %d bytes)", mime, len(data), len(png)) + } + if _, _, err := decodeBase64(base64.StdEncoding.EncodeToString(png)); err != nil { + t.Fatalf("裸 base64 被拒：%v", err) + } +}