From 1f1831b584772592d05d45964c4ba4b72ca6c7fc Mon Sep 17 00:00:00 2001 From: Mag1cFall Date: Sat, 21 Nov 2026 16:12:22 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E5=88=A0=E9=99=A4=E7=9B=B4=E8=BF=9E=20H?= =?UTF-8?q?TTP/3=EF=BC=8C=E7=9B=B4=E8=BF=9E=E4=B8=8E=E7=BB=8F=E4=BB=A3?= =?UTF-8?q?=E7=90=86=E9=83=BD=E5=8F=AA=E7=94=A8=20HTTP/2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- go.mod | 3 - go.sum | 11 - internal/aistudio/navigation_timing.go | 2 - internal/aistudio/transport_browser.go | 136 ++-- internal/aistudio/transport_http3.go | 458 ----------- internal/aistudio/transport_http3_conn.go | 259 ------- internal/aistudio/transport_http3_stream.go | 296 ------- internal/aistudio/transport_qpack.go | 813 -------------------- internal/aistudio/transport_quic.go | 454 ----------- internal/aistudio/transport_quic_test.go | 126 --- internal/i18n/messages/de.json | 9 - internal/i18n/messages/en.json | 9 - internal/i18n/messages/fr.json | 9 - internal/i18n/messages/ja.json | 9 - internal/i18n/messages/ko.json | 9 - internal/i18n/messages/zh-TW.json | 9 - 16 files changed, 61 insertions(+), 2551 deletions(-) delete mode 100644 internal/aistudio/transport_http3.go delete mode 100644 internal/aistudio/transport_http3_conn.go delete mode 100644 internal/aistudio/transport_http3_stream.go delete mode 100644 internal/aistudio/transport_qpack.go delete mode 100644 internal/aistudio/transport_quic.go delete mode 100644 internal/aistudio/transport_quic_test.go diff --git a/go.mod b/go.mod index 02519c79..80e38cb7 100644 --- a/go.mod +++ b/go.mod @@ -7,8 +7,6 @@ require ( github.com/Mag1cFall/fhttp v0.6.8-firefox.2 github.com/Mag1cFall/go-mp3 v0.1.1 github.com/Mag1cFall/go-sentencepiece v0.7.1 - github.com/Mag1cFall/uquic v0.0.6-firefox.6 - github.com/Mag1cFall/utls v1.8.2-firefox.3 github.com/bogdanfinn/fhttp v0.6.8 github.com/bogdanfinn/tls-client v1.15.1 github.com/bogdanfinn/utls v1.7.7-barnius @@ -60,7 +58,6 @@ require ( github.com/mattn/go-isatty v0.0.24 // indirect github.com/mewkiz/pkg v0.0.0-20250417130911-3f050ff8c56d // indirect github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985 // indirect - github.com/molecule-man/go-brrr v1.2.0 // indirect github.com/power-devops/perfstat v0.0.0-20260805114148-88456608a4f6 // indirect github.com/quic-go/qpack v0.6.0 // indirect github.com/segmentio/asm v1.1.3 // indirect diff --git a/go.sum b/go.sum index 75fcd075..1d7c850d 100644 --- a/go.sum +++ b/go.sum @@ -8,10 +8,6 @@ github.com/Mag1cFall/go-mp3 v0.1.1 h1:r/wBscYGXWpGdEhCQCcrHI36EDbNx6rtio2yv/Y547 github.com/Mag1cFall/go-mp3 v0.1.1/go.mod h1:/vhuC+guK5mKVhCBE8ZQSocH0FmHXM244FT7239cSlY= github.com/Mag1cFall/go-sentencepiece v0.7.1 h1:Evzu4bQYge6F2tv40wMqr9MazbtbvoPbSD/eLl2gJEA= github.com/Mag1cFall/go-sentencepiece v0.7.1/go.mod h1:5xb9a9oAB7EQ/J/47DTrj+BSrGoJIcXZ9CB5y27Nehw= -github.com/Mag1cFall/uquic v0.0.6-firefox.6 h1:AvAWHvAMST2ffRJb+LKTWv8+Gz0u6JfzGxcXuXxOPFI= -github.com/Mag1cFall/uquic v0.0.6-firefox.6/go.mod h1:JHH4tzlX5KM0a4TJSglkbL2kW1hdVBenlA0YFKD8o0E= -github.com/Mag1cFall/utls v1.8.2-firefox.3 h1:5DGK0Ps9Kew+pd1E0d96YeirOdk4AOHJmx+NeNJwRxM= -github.com/Mag1cFall/utls v1.8.2-firefox.3/go.mod h1:HFKOiYks7qa1VvvhZBWu7Ic9tTYm1xNXHKiRcpw3Mtc= github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78= github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ= github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ= @@ -91,8 +87,6 @@ github.com/minio/selfupdate v0.6.0 h1:i76PgT0K5xO9+hjzKcacQtO7+MjJ4JKA8Ak8XQ9DDw github.com/minio/selfupdate v0.6.0/go.mod h1:bO02GTIPCMQFTEvE5h4DjYB58bCoZ35XLeBf0buTDdM= github.com/modelcontextprotocol/go-sdk v1.8.0 h1:KIvahhYqwtbeniWVPs3TcXEA7b8jEtwfBpOTAI+Urx4= github.com/modelcontextprotocol/go-sdk v1.8.0/go.mod h1:dL7u98E/zjJTGzEq+j30jQ8K2k1mb6LeAH4inEcSGts= -github.com/molecule-man/go-brrr v1.2.0 h1:dOJU45BC3Gc2WXoxAW0rgCAgVuu2gruAOGncfieA0Jw= -github.com/molecule-man/go-brrr v1.2.0/go.mod h1:7ybW6/7gA3oKY45jOfVNjSJDtrr6ea4tzbsTkjmQDC4= github.com/nlnwa/whatwg-url v0.6.2 h1:jU61lU2ig4LANydbEJmA2nPrtCGiKdtgT0rmMd2VZ/Q= github.com/nlnwa/whatwg-url v0.6.2/go.mod h1:x0FPXJzzOEieQtsBT/AKvbiBbQ46YlL6Xa7m02M1ECk= github.com/power-devops/perfstat v0.0.0-20260805114148-88456608a4f6 h1:jL3a8soXdzuTCcRnKhOmtcsVOObdDTFf4O2B403HPRU= @@ -157,8 +151,6 @@ golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c= -golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o= golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg= golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -184,8 +176,6 @@ golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= -golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -239,7 +229,6 @@ golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI= golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA= -golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= diff --git a/internal/aistudio/navigation_timing.go b/internal/aistudio/navigation_timing.go index 991dcae0..268836a6 100644 --- a/internal/aistudio/navigation_timing.go +++ b/internal/aistudio/navigation_timing.go @@ -78,8 +78,6 @@ func documentTiming(entry map[string]any, resources time.Duration) { // nextHopProtocol 返回响应协议对应的 ALPN 名称 func nextHopProtocol(proto string) string { switch proto { - case "HTTP/3.0": - return "h3" case "HTTP/2.0": return "h2" default: diff --git a/internal/aistudio/transport_browser.go b/internal/aistudio/transport_browser.go index f45d2b3f..a9b7fd84 100644 --- a/internal/aistudio/transport_browser.go +++ b/internal/aistudio/transport_browser.go @@ -2,6 +2,7 @@ package aistudio import ( "context" + "encoding/binary" "fmt" "io" "net" @@ -29,6 +30,8 @@ const ( firefoxPingThreshold = 58 * time.Second // firefoxPingTimeout 是 Firefox network.http.http2.ping-timeout,PING 超过该时长未应答时关闭连接 firefoxPingTimeout = 8 * time.Second + // nssTLSGREASEECHInner 是 NSS 为 TCP ClientHello 的 GREASE ECH 估算的内层 ClientHello 基础长度 + nssTLSGREASEECHInner = 217 // firefoxTLSHandshakeTimeout 是 Firefox network.http.tls-handshake-timeout firefoxTLSHandshakeTimeout = 30 * time.Second // browserIdleConnTimeout 是 Firefox network.http.http2.timeout,空闲 HTTP/2 连接保留该时长后关闭 @@ -104,7 +107,6 @@ var firefoxRequestHeaderOrder = []string{ "x-user-agent", "content-length", "origin", - "alt-used", "sec-fetch-storage-access", "cookie", "upgrade-insecure-requests", @@ -216,9 +218,7 @@ var browserManagedHeaders = map[string]struct{}{ type browserRoundTripper struct { transport *http2.Transport pool *firefoxConnPool - // http3 在直连时按 Alt-Svc 把请求切换到 HTTP/3,经代理时为 nil - http3 *firefoxHTTP3 - mu sync.Mutex + mu sync.Mutex // preflights 按 preflightKey 记录 CORS 预检缓存 preflights map[string]preflightGrant } @@ -248,7 +248,7 @@ type browserResponseBody struct { trailer stdhttp.Header } -// newBrowserRoundTripper 创建与当前 Camoufox 网络形状一致的传输:经代理时只用 HTTP/2,直连时按 Alt-Svc 改用 HTTP/3 +// newBrowserRoundTripper 创建与当前 Camoufox 网络形状一致的 HTTP/2 传输 func newBrowserRoundTripper(proxyURL string) (stdhttp.RoundTripper, error) { proxyURL = strings.TrimSpace(proxyURL) var proxyDialer proxy.ContextDialer = &net.Dialer{} @@ -295,11 +295,7 @@ func newBrowserRoundTripper(proxyURL string) (stdhttp.RoundTripper, error) { StreamWindowUpdate: firefoxStreamWindowUpdate, WindowUpdateThreshold: firefoxWindowUpdateThreshold, } - roundTripper := &browserRoundTripper{preflights: map[string]preflightGrant{}, transport: pool.transport, pool: pool} - if proxyURL == "" { - roundTripper.http3 = newFirefoxHTTP3(pool) - } - return roundTripper, nil + return &browserRoundTripper{preflights: map[string]preflightGrant{}, transport: pool.transport, pool: pool}, nil } // connectionTimingKey 是请求 context 中记录该请求自己建立连接各阶段时刻的 *connectionTiming @@ -354,7 +350,7 @@ func (dialer tracedDialer) DialContext(ctx context.Context, network, address str return conn, err } -// firefoxConnPool 按 Firefox 选择 HTTP/2 连接,匿名请求、携带凭据的请求与 HTTP/3 备用连接分开建连 +// firefoxConnPool 按 Firefox 选择 HTTP/2 连接,匿名请求与携带凭据的请求分开建连 type firefoxConnPool struct { transport *http2.Transport dial func(address string, anonymous bool, timing *connectionTiming) (net.Conn, error) @@ -368,28 +364,41 @@ type firefoxConnPool struct { added chan struct{} } +// requestClass 标记请求在连接池中的类别:匿名请求(CORS 预检)与携带凭据的请求按类别建连,优先复用本类连接 +type requestClass struct { + anonymous bool +} + +type requestClassKey struct{} + +func withRequestClass(ctx context.Context, class requestClass) context.Context { + return context.WithValue(ctx, requestClassKey{}, class) +} + +func requestClassOf(ctx context.Context) requestClass { + class, _ := ctx.Value(requestClassKey{}).(requestClass) + return class +} + // poolKey 是地址与请求类别组成的连接池键 func poolKey(address string, class requestClass) string { if class.anonymous { address += "|anonymous" } - if class.fallback { - address += "|fallback" - } return address } func (pool *firefoxConnPool) GetClientConn(request *fhttp.Request, address string) (*http2.ClientConn, error) { - return pool.get(request.Context(), address, true) + return pool.get(request.Context(), address) } -// get 返回 context 所标类别下能接受新请求的连接,没有时取另一类已复用过的连接,仍没有时拨号并使用自己拨出的连接;dispatch 表示返回的连接将承载请求 -func (pool *firefoxConnPool) get(ctx context.Context, address string, dispatch bool) (*http2.ClientConn, error) { +// get 返回 context 所标类别下能接受新请求的连接,没有时取另一类已复用过的连接,仍没有时拨号并使用自己拨出的连接 +func (pool *firefoxConnPool) get(ctx context.Context, address string) (*http2.ClientConn, error) { class := requestClassOf(ctx) key := poolKey(address, class) - inverted := poolKey(address, requestClass{anonymous: !class.anonymous, fallback: class.fallback}) + inverted := poolKey(address, requestClass{anonymous: !class.anonymous}) pool.mu.Lock() - conn := pool.availableLocked(key, inverted, dispatch) + conn := pool.availableLocked(key, inverted) for conn == nil && len(pool.conns[key])+pool.dialing[key] >= firefoxMaxPersistentConns { added := pool.added pool.mu.Unlock() @@ -399,7 +408,7 @@ func (pool *firefoxConnPool) get(ctx context.Context, address string, dispatch b return nil, ctx.Err() } pool.mu.Lock() - conn = pool.availableLocked(key, inverted, dispatch) + conn = pool.availableLocked(key, inverted) } if conn != nil { pool.mu.Unlock() @@ -447,11 +456,11 @@ func (pool *firefoxConnPool) speculate(address string, class requestClass) { go func() { _, _ = pool.connect(address, class, nil) }() } -// availableLocked 返回本类能接受新请求的最早连接,没有时返回另一类已复用过的连接;dispatch 时把取到的本类连接记为已复用 -func (pool *firefoxConnPool) availableLocked(key string, inverted string, dispatch bool) *http2.ClientConn { +// availableLocked 返回本类能接受新请求的最早连接并把它记为已复用,没有时返回另一类已复用过的连接 +func (pool *firefoxConnPool) availableLocked(key string, inverted string) *http2.ClientConn { for _, conn := range pool.conns[key] { if conn.CanTakeNewRequest() { - pool.experienced[conn] = pool.experienced[conn] || dispatch + pool.experienced[conn] = true return conn } } @@ -463,28 +472,6 @@ func (pool *firefoxConnPool) availableLocked(key string, inverted string, dispat return nil } -// idle 报告该类别是否已有能接受新请求的连接 -func (pool *firefoxConnPool) idle(address string, class requestClass) bool { - pool.mu.Lock() - defer pool.mu.Unlock() - return slices.ContainsFunc(pool.conns[poolKey(address, class)], (*http2.ClientConn).CanTakeNewRequest) -} - -// retire 让该类别的连接在已有请求结束后关闭,之后的请求不再复用它们 -func (pool *firefoxConnPool) retire(address string, class requestClass) { - pool.mu.Lock() - conns := pool.conns[poolKey(address, class)] - delete(pool.conns, poolKey(address, class)) - for _, conn := range conns { - delete(pool.experienced, conn) - } - pool.notifyLocked() - pool.mu.Unlock() - for _, conn := range conns { - go func() { _ = conn.Shutdown(context.Background()) }() - } -} - func (pool *firefoxConnPool) MarkDead(dead *http2.ClientConn) { pool.mu.Lock() defer pool.mu.Unlock() @@ -551,6 +538,26 @@ func (cache *firefoxSessionCache) take(peer firefoxSessionPeer) (*tls.ClientSess return nil, 0 } +// resumptionPSKLength 返回以编码为 raw(utls SessionState.Bytes)的 TLS 1.3 客户端会话恢复时 pre_shared_key 扩展的长度,会话不是 TLS 1.3 或票据已过期时为 0 +func resumptionPSKLength(raw []byte, ticket int) int { + if binary.BigEndian.Uint16(raw) != tls.VersionTLS13 || time.Now().After(time.Unix(int64(binary.BigEndian.Uint64(raw[len(raw)-12:])), 0)) { + return 0 + } + binder := 32 + if binary.BigEndian.Uint16(raw[3:]) == tls.TLS_AES_256_GCM_SHA384 { + binder = 48 + } + return 2 + 2 + ticket + 4 + 2 + 1 + binder +} + +// nssGREASEECHPayload 是 NSS 按内层基础长度 inner 与 pre_shared_key 扩展长度 psk 算出的 GREASE ECH 密文长度(不含 AEAD 标签),按 RFC 9849 补齐到 32 字节的整数倍 +func nssGREASEECHPayload(inner int, psk int) uint16 { + if psk > 0 { + inner += 4 + psk + } + return uint16(inner + 31 - (inner-1)%32) +} + // put 把服务器下发的票据存到 peer 名下,已满时丢弃最早收到的一张 func (cache *firefoxSessionCache) put(peer firefoxSessionPeer, session *tls.ClientSessionState) { cache.mu.Lock() @@ -655,26 +662,10 @@ func (transport *browserRoundTripper) RoundTrip(request *stdhttp.Request) (*stdh }, nil } -// roundTrip 执行上游请求,anonymous 表示不携带凭据的请求(CORS 预检与 CSP 报告):直连时先按 Alt-Svc 选择 HTTP/3,其余经 HTTP/2 发送并记录响应的 Alt-Svc +// roundTrip 经 HTTP/2 以 Firefox 的 HEADERS 帧优先级执行上游请求,anonymous 表示不携带凭据的请求(CORS 预检与 CSP 报告),请求 context 结束时立即返回,未完成的拨号在后台结束 func (transport *browserRoundTripper) roundTrip(request *fhttp.Request, anonymous bool) (*fhttp.Response, error) { - request = request.WithContext(withRequestClass(request.Context(), requestClass{anonymous: anonymous})) - if transport.http3 == nil { - return transport.roundTripHTTP2(request) - } - response, http2Request, err := transport.http3.send(request, anonymous) - if http2Request == nil { - return response, err - } - response, err = transport.roundTripHTTP2(http2Request) - if err == nil { - transport.http3.observe(request.URL.Hostname(), response.Header) - } - return response, err -} - -// roundTripHTTP2 经 HTTP/2 以 Firefox 的 HEADERS 帧优先级执行上游请求,请求 context 结束时立即返回,未完成的拨号在后台结束 -func (transport *browserRoundTripper) roundTripHTTP2(request *fhttp.Request) (*fhttp.Response, error) { - request = request.WithContext(http2.WithHeaderPriority(request.Context(), firefoxStreamPriority(request.Header))) + ctx := withRequestClass(request.Context(), requestClass{anonymous: anonymous}) + request = request.WithContext(http2.WithHeaderPriority(ctx, firefoxStreamPriority(request.Header))) type result struct { response *fhttp.Response err error @@ -720,9 +711,6 @@ func (body *browserResponseBody) syncTrailer() { func (transport *browserRoundTripper) CloseIdleConnections() { transport.pool.shutdown() - if transport.http3 != nil { - transport.http3.shutdown() - } } func standardHeader(source fhttp.Header) stdhttp.Header { @@ -741,7 +729,7 @@ func preflightKey(request *stdhttp.Request) string { return request.URL.String() } -// ensurePreflight 为带 Origin 的跨域 cors 请求按 Firefox 的流程先发 CORS 预检:经 HTTP/2 时先在后台为实际请求的类别预先拨出连接,预检走匿名连接,预检响应允许的方法与请求头按 Access-Control-Max-Age(上限 24 小时)逐个缓存;no-cors 请求与只带安全头的 GET、HEAD、POST 不预检 +// ensurePreflight 为带 Origin 的跨域 cors 请求按 Firefox 的流程先发 CORS 预检:先在后台为实际请求的类别预先拨出连接,预检走匿名连接,预检响应允许的方法与请求头按 Access-Control-Max-Age(上限 24 小时)逐个缓存;no-cors 请求与只带安全头的 GET、HEAD、POST 不预检 func (transport *browserRoundTripper) ensurePreflight(request *stdhttp.Request) error { origin, err := url.Parse(request.Header.Get("Origin")) if request.Method == stdhttp.MethodOptions || request.Header.Get("Sec-Fetch-Mode") == "no-cors" || err != nil || origin.Host == "" || origin.Host == request.URL.Host { @@ -759,13 +747,11 @@ func (transport *browserRoundTripper) ensurePreflight(request *stdhttp.Request) if cached { return nil } - if transport.http3 == nil { - port := request.URL.Port() - if port == "" { - port = "443" - } - transport.pool.speculate(net.JoinHostPort(request.URL.Hostname(), port), requestClass{anonymous: requestClassOf(request.Context()).anonymous}) + port := request.URL.Port() + if port == "" { + port = "443" } + transport.pool.speculate(net.JoinHostPort(request.URL.Hostname(), port), requestClassOf(request.Context())) preflight, err := fhttp.NewRequestWithContext(request.Context(), stdhttp.MethodOptions, target, nil) if err != nil { return err @@ -914,7 +900,7 @@ func firefox158ClientHello(psk int) tls.ClientHelloID { typed.Curves = []tls.CurveID{tls.X25519MLKEM768, tls.X25519, tls.CurveP256, tls.CurveP384, tls.CurveP521} case *tls.GREASEEncryptedClientHelloExtension: typed.CandidateCipherSuites = []tls.HPKESymmetricCipherSuite{{KdfId: dicttls.HKDF_SHA256, AeadId: dicttls.AEAD_AES_128_GCM}, {KdfId: dicttls.HKDF_SHA256, AeadId: dicttls.AEAD_CHACHA20_POLY1305}} - typed.CandidatePayloadLens = []uint16{nssGREASEECHPayload(nssTLSGREASEECHInner, psk, false)} + typed.CandidatePayloadLens = []uint16{nssGREASEECHPayload(nssTLSGREASEECHInner, psk)} } } if psk > 0 { diff --git a/internal/aistudio/transport_http3.go b/internal/aistudio/transport_http3.go deleted file mode 100644 index efaab393..00000000 --- a/internal/aistudio/transport_http3.go +++ /dev/null @@ -1,458 +0,0 @@ -package aistudio - -import ( - "context" - "errors" - "net" - "strconv" - "strings" - "sync" - "time" - - fhttp "github.com/Mag1cFall/fhttp" - quic "github.com/Mag1cFall/uquic" -) - -const ( - h3FrameData = 0x00 - h3FrameHeaders = 0x01 - h3FrameSettings = 0x04 - h3FrameGoaway = 0x07 - // h3ControlStreamType 是 HTTP/3 控制流的单向流类型 - h3ControlStreamType = 0x00 - // h3StreamCreationError 是 H3_STREAM_CREATION_ERROR,neqo 以它拒绝推送流与未知类型的单向流 - h3StreamCreationError = 0x103 - // h3RequestCancelled 是 H3_REQUEST_CANCELLED,Firefox 取消请求时以它重置请求流 - h3RequestCancelled = 0x10c - // h3SettingQPACKCapacity 是 SETTINGS_QPACK_MAX_TABLE_CAPACITY - h3SettingQPACKCapacity = 0x01 - // h3SettingQPACKBlocked 是 SETTINGS_QPACK_BLOCKED_STREAMS - h3SettingQPACKBlocked = 0x07 - // firefoxHTTP3BackupDelay 是 Firefox network.http.http3.backup_timer_delay:HTTP/3 连接未就绪时开始备用 HTTP/2 连接的延迟 - firefoxHTTP3BackupDelay = 100 * time.Millisecond - // altSvcDefaultMaxAge 是 Alt-Svc 未带 ma 参数时的映射有效期 - altSvcDefaultMaxAge = 24 * time.Hour - // h3RequestBodyChunk 是请求体写成 DATA 帧时每帧的最大长度 - h3RequestBodyChunk = 32 << 10 -) - -// firefoxHTTP3Settings 是 Firefox 158 控制流 SETTINGS 的参数与顺序:QPACK 容量、阻塞流、WebTransport、两个 H3 DATAGRAM 与扩展 CONNECT -var firefoxHTTP3Settings = [][2]uint64{ - {h3SettingQPACKCapacity, firefoxQPACKTableSize}, - {h3SettingQPACKBlocked, firefoxQPACKBlockedStreams}, - {0x2b603742, 0}, - {0xffd277, 1}, - {0x33, 1}, - {0x08, 1}, -} - -// firefoxSafeMethods 是 Firefox nsHttpRequestHead::IsSafeMethod 认定的方法,0-RTT 连接只在握手完成前发送这些方法的请求 -var firefoxSafeMethods = map[string]bool{"GET": true, "HEAD": true, "OPTIONS": true, "TRACE": true, "PROPFIND": true, "REPORT": true, "SEARCH": true} - -// h3ExcludedRequestHeaders 是 Firefox 为 HTTP/3 请求丢弃的逐跳与连接头 -var h3ExcludedRequestHeaders = map[string]struct{}{ - "connection": {}, "host": {}, "keep-alive": {}, "proxy-connection": {}, "te": {}, "transfer-encoding": {}, "upgrade": {}, -} - -// requestClass 标记请求在连接池中的类别:匿名请求(CORS 预检)与携带凭据的请求使用不同连接,备用连接只供 HTTP/3 未就绪时回退 -type requestClass struct { - anonymous bool - fallback bool -} - -type requestClassKey struct{} - -func withRequestClass(ctx context.Context, class requestClass) context.Context { - return context.WithValue(ctx, requestClassKey{}, class) -} - -func requestClassOf(ctx context.Context) requestClass { - class, _ := ctx.Value(requestClassKey{}).(requestClass) - return class -} - -// firefoxHTTP3 按 Firefox 158 的 Alt-Svc 流程在直连时把请求切换到 HTTP/3:响应通告 h3 后以携带凭据的连接验证,验证成功后该主机的请求改走 HTTP/3 -type firefoxHTTP3 struct { - pool *firefoxConnPool - mu sync.Mutex - origins map[string]*altSvcOrigin - // resumption 按是否匿名分别保存会话票据、令牌与服务端设置 - resumption [2]*quicResumption -} - -// altSvcOrigin 是一个主机的 Alt-Svc h3 映射,classes 按是否匿名分别保存 HTTP/3 连接 -type altSvcOrigin struct { - validated bool - validation *http3Dial - expires time.Time - classes [2]http3Class -} - -// http3Class 是主机上一类请求的 HTTP/3 状态,excluded 表示备用 HTTP/2 连接抢先就绪后不再尝试 HTTP/3 -type http3Class struct { - conn *http3Conn - dial *http3Dial - excluded bool -} - -// http3Dial 是进行中的 QUIC 拨号 -type http3Dial struct { - done chan struct{} - conn *http3Conn - err error - cancel context.CancelFunc -} - -func newFirefoxHTTP3(pool *firefoxConnPool) *firefoxHTTP3 { - return &firefoxHTTP3{pool: pool, origins: map[string]*altSvcOrigin{}, resumption: [2]*quicResumption{newQUICResumption(), newQUICResumption()}} -} - -func classIndex(anonymous bool) int { - if anonymous { - return 1 - } - return 0 -} - -// observe 处理响应的 Alt-Svc:主机首次通告 h3 时开始验证连接,已验证的映射按 ma 续期,clear 删除映射 -func (h3 *firefoxHTTP3) observe(host string, header fhttp.Header) { - maxAge, clear, ok := parseAltSvcH3(header.Values("Alt-Svc"), host) - if !ok && !clear { - return - } - h3.mu.Lock() - defer h3.mu.Unlock() - origin := h3.origins[host] - if clear { - delete(h3.origins, host) - return - } - if origin != nil && origin.validated && time.Now().Before(origin.expires) { - origin.expires = time.Now().Add(maxAge) - return - } - if origin != nil && origin.validation != nil { - return - } - if origin == nil { - origin = &altSvcOrigin{} - h3.origins[host] = origin - } - origin.validated = false - validation := h3.startDial(host, false) - origin.validation = validation - go func() { - <-validation.done - h3.mu.Lock() - defer h3.mu.Unlock() - if h3.origins[host] != origin { - if validation.conn != nil { - validation.conn.close() - } - return - } - origin.validation = nil - if validation.err != nil { - delete(h3.origins, host) - return - } - origin.validated = true - origin.expires = time.Now().Add(maxAge) - h3.adopt(host, origin, false, validation.conn) - h3.pool.retire(net.JoinHostPort(host, "443"), requestClass{}) - }() -} - -// parseAltSvcH3 返回 Alt-Svc 中第一个指向同主机 443 端口的 h3 条目的有效期,clear 表示清除映射 -func parseAltSvcH3(values []string, host string) (time.Duration, bool, bool) { - for _, value := range values { - if strings.TrimSpace(value) == "clear" { - return 0, true, false - } - for _, entry := range strings.Split(value, ",") { - parameters := strings.Split(entry, ";") - protocol, authority, found := strings.Cut(strings.TrimSpace(parameters[0]), "=") - if !found || protocol != "h3" { - continue - } - alternate, port, err := net.SplitHostPort(strings.Trim(authority, `"`)) - if err != nil || port != "443" || (alternate != "" && alternate != host) { - continue - } - maxAge := altSvcDefaultMaxAge - for _, parameter := range parameters[1:] { - name, raw, _ := strings.Cut(strings.TrimSpace(parameter), "=") - if seconds, err := strconv.ParseUint(strings.Trim(raw, `"`), 10, 32); err == nil && strings.EqualFold(name, "ma") { - maxAge = time.Duration(seconds) * time.Second - } - } - return maxAge, false, true - } - } - return 0, false, false -} - -// startDial 在后台以 Firefox 的 QUIC 首航拨号并建立 HTTP/3 会话,该类别有会话票据时恢复会话 -func (h3 *firefoxHTTP3) startDial(host string, anonymous bool) *http3Dial { - ctx, cancel := context.WithCancel(context.Background()) - dial := &http3Dial{done: make(chan struct{}), cancel: cancel} - resumption := h3.resumption[classIndex(anonymous)] - go func() { - defer close(dial.done) - connection, settings, err := dialFirefoxQUIC(ctx, host, resumption) - if err != nil { - dial.err = err - return - } - dial.conn, dial.err = newHTTP3Conn(connection, settings, func(capacity uint64, blocked uint64) { - resumption.rememberSettings(host, capacity, blocked) - }) - }() - return dial -} - -// adopt 把建立好的连接放进主机对应类别,连接关闭或收到 GOAWAY 后自动移出 -func (h3 *firefoxHTTP3) adopt(host string, origin *altSvcOrigin, anonymous bool, conn *http3Conn) { - origin.classes[classIndex(anonymous)].conn = conn - go func() { - select { - case <-conn.quic.Context().Done(): - case <-conn.goaway: - } - h3.mu.Lock() - defer h3.mu.Unlock() - if class := &origin.classes[classIndex(anonymous)]; class.conn == conn { - class.conn = nil - } - }() -} - -// send 按 Firefox 的连接选择发送请求:返回 HTTP/3 响应,或返回改走 HTTP/2 的请求(备用连接已在请求 context 中标记) -func (h3 *firefoxHTTP3) send(request *fhttp.Request, anonymous bool) (*fhttp.Response, *fhttp.Request, error) { - if request.URL.Scheme != "https" || (request.URL.Port() != "" && request.URL.Port() != "443") { - return nil, request, nil - } - host := request.URL.Hostname() - for attempt := 0; ; attempt++ { - conn, mapped, fallback, err := h3.route(request, host, anonymous) - if err != nil { - return nil, nil, err - } - if conn == nil { - if fallback { - request = request.WithContext(withRequestClass(request.Context(), requestClass{anonymous: anonymous, fallback: true})) - } - return nil, request, nil - } - reused := conn.streams.Load() > 0 - response, opened, err := conn.roundTrip(request, h3RequestFields(request, mapped && !anonymous)) - if err != nil && attempt == 0 && request.Context().Err() == nil && (!opened || quicConnectionClosed(err) && (reused || firefoxSafeMethods[request.Method])) { - if restarted, ok := restartRequest(request, opened); ok { - conn.close() - h3.drop(host, anonymous, conn) - request = restarted - continue - } - } - if err == nil { - h3.observe(host, response.Header) - } - return response, nil, err - } -} - -// quicConnectionClosed 判断请求失败是否因为 QUIC 连接关闭,请求流被单独重置时为 false -func quicConnectionClosed(err error) bool { - var application *quic.ApplicationError - var transport *quic.TransportError - var idle *quic.IdleTimeoutError - var reset *quic.StatelessResetError - return errors.As(err, &application) || errors.As(err, &transport) || errors.As(err, &idle) || errors.As(err, &reset) -} - -// restartRequest 返回在新连接上重发的请求,请求流已打开时以 GetBody 重新取得请求体,取不到时 ok 为 false -func restartRequest(request *fhttp.Request, opened bool) (*fhttp.Request, bool) { - if !opened || request.Body == nil || request.Body == fhttp.NoBody { - return request, true - } - if request.GetBody == nil { - return nil, false - } - body, err := request.GetBody() - if err != nil { - return nil, false - } - restarted := request.Clone(request.Context()) - restarted.Body = body - return restarted, true -} - -// drop 把失败的连接从主机对应类别移出,使重发的请求改用新连接 -func (h3 *firefoxHTTP3) drop(host string, anonymous bool, conn *http3Conn) { - h3.mu.Lock() - defer h3.mu.Unlock() - if origin := h3.origins[host]; origin != nil && origin.classes[classIndex(anonymous)].conn == conn { - origin.classes[classIndex(anonymous)].conn = nil - } -} - -// route 选择请求的承载:返回可用的 HTTP/3 连接与是否经 Alt-Svc 映射发送,conn 为 nil 时经 HTTP/2,fallback 表示使用备用连接 -func (h3 *firefoxHTTP3) route(request *fhttp.Request, host string, anonymous bool) (conn *http3Conn, mapped bool, fallback bool, err error) { - ctx := request.Context() - address := net.JoinHostPort(host, "443") - h3.mu.Lock() - origin := h3.origins[host] - if origin == nil { - h3.mu.Unlock() - return nil, false, false, nil - } - if !origin.validated { - validation := origin.validation - h3.mu.Unlock() - if anonymous || validation == nil { - return nil, false, false, nil - } - ready := h3.http2Ready(ctx, address, requestClass{}) - for { - select { - case <-validation.done: - if validation.err == nil { - return validation.conn, false, false, nil - } - return nil, false, false, nil - case err := <-ready: - if err == nil { - return nil, false, false, nil - } - ready = nil - case <-ctx.Done(): - return nil, false, false, ctx.Err() - } - } - } - if time.Now().After(origin.expires) { - delete(h3.origins, host) - h3.mu.Unlock() - return nil, false, false, nil - } - class := &origin.classes[classIndex(anonymous)] - if class.excluded { - h3.mu.Unlock() - return nil, false, false, nil - } - if class.conn != nil { - conn = class.conn - h3.mu.Unlock() - return conn, true, false, nil - } - dial := class.dial - if dial == nil { - dial = h3.startDial(host, anonymous) - class.dial = dial - go h3.finishDial(host, origin, anonymous, dial) - } - idle := h3.pool.idle(address, requestClass{anonymous: anonymous}) - h3.mu.Unlock() - if idle { - return nil, false, false, nil - } - timer := time.NewTimer(firefoxHTTP3BackupDelay) - defer timer.Stop() - var backup <-chan error - var backupErr error - for { - select { - case <-dial.done: - if dial.err == nil { - return dial.conn, true, false, nil - } - if backupErr != nil { - return nil, false, false, errors.Join(dial.err, backupErr) - } - if backup == nil { - return nil, false, false, nil - } - select { - case err := <-backup: - if err != nil { - return nil, false, false, errors.Join(dial.err, err) - } - case <-ctx.Done(): - return nil, false, false, ctx.Err() - } - return nil, false, true, nil - case <-timer.C: - backup = h3.http2Ready(ctx, address, requestClass{anonymous: anonymous, fallback: true}) - case backupErr = <-backup: - if backupErr != nil { - backup = nil - continue - } - select { - case <-dial.done: - if dial.err == nil { - return dial.conn, true, false, nil - } - default: - h3.mu.Lock() - class.excluded = true - h3.mu.Unlock() - dial.cancel() - } - return nil, false, true, nil - case <-ctx.Done(): - return nil, false, false, ctx.Err() - } - } -} - -// finishDial 在拨号结束后把连接交给主机类别,拨号失败时该类别不再尝试 HTTP/3,类别已改走 HTTP/2 时以 H3_NO_ERROR 关闭连接 -func (h3 *firefoxHTTP3) finishDial(host string, origin *altSvcOrigin, anonymous bool, dial *http3Dial) { - <-dial.done - h3.mu.Lock() - defer h3.mu.Unlock() - class := &origin.classes[classIndex(anonymous)] - if class.dial == dial { - class.dial = nil - } - if dial.conn == nil { - class.excluded = true - return - } - if class.excluded || h3.origins[host] != origin { - dial.conn.close() - return - } - h3.adopt(host, origin, anonymous, dial.conn) -} - -// http2Ready 在后台取得一条该类别的 HTTP/2 连接,返回的 channel 交付取得结果 -func (h3 *firefoxHTTP3) http2Ready(ctx context.Context, address string, class requestClass) <-chan error { - ready := make(chan error, 1) - go func() { - _, err := h3.pool.get(withRequestClass(context.WithoutCancel(ctx), class), address, false) - ready <- err - }() - return ready -} - -// shutdown 关闭全部 HTTP/3 连接与进行中的拨号,Alt-Svc 映射保留 -func (h3 *firefoxHTTP3) shutdown() { - h3.mu.Lock() - defer h3.mu.Unlock() - for _, origin := range h3.origins { - if origin.validation != nil { - origin.validation.cancel() - } - for i := range origin.classes { - class := &origin.classes[i] - if class.dial != nil { - class.dial.cancel() - } - if class.conn != nil { - class.conn.close() - class.conn = nil - } - } - } -} diff --git a/internal/aistudio/transport_http3_conn.go b/internal/aistudio/transport_http3_conn.go deleted file mode 100644 index 6094c8b9..00000000 --- a/internal/aistudio/transport_http3_conn.go +++ /dev/null @@ -1,259 +0,0 @@ -package aistudio - -import ( - "bufio" - "context" - "crypto/rand" - "encoding/binary" - "fmt" - "io" - "sync" - "sync/atomic" - "time" - - quic "github.com/Mag1cFall/uquic" - "github.com/Mag1cFall/uquic/quicvarint" -) - -// http3Conn 是一条按 neqo 0.31 行为收发的 HTTP/3 连接 -type http3Conn struct { - quic *quic.Conn - // mu 保护 QPACK 编码器,并保证编码器流指令先于引用它的头块写出 - mu sync.Mutex - encoder *qpackEncoder - encoderStream *quic.SendStream - decoder *qpackDecoder - decoderMu sync.Mutex - decoderStream *quic.SendStream - ackPending atomic.Bool - goaway chan struct{} - goawayOnce sync.Once - // ready 在握手完成后关闭,0-RTT 被拒绝时在重新打开控制流与 QPACK 流之后关闭 - ready chan struct{} - // remember 记录服务端 SETTINGS 中的 QPACK 设置,供下次 0-RTT 沿用 - remember func(capacity uint64, blocked uint64) - // streams 是本连接已打开的请求流数 - streams atomic.Int64 -} - -// newHTTP3Conn 在 QUIC 连接上按 neqo 的顺序打开控制流、QPACK 编码器流与解码器流;settings 非 nil 表示握手尚未完成的 0-RTT 连接 -func newHTTP3Conn(connection *quic.Conn, settings *[2]uint64, remember func(capacity uint64, blocked uint64)) (*http3Conn, error) { - conn := &http3Conn{quic: connection, goaway: make(chan struct{}), ready: make(chan struct{}), remember: remember} - if err := conn.open(settings); err != nil { - conn.close() - return nil, err - } - if settings == nil { - close(conn.ready) - } else { - go conn.awaitHandshake() - } - return conn, nil -} - -// open 打开控制流、QPACK 编码器流与解码器流并写出各流开头,编码器与解码器从初始状态开始 -func (conn *http3Conn) open(settings *[2]uint64) error { - encoder, decoder := newQPACKEncoder(), newQPACKDecoder() - if settings != nil { - encoder.setPeerSettings(settings[0], settings[1]) - } - var encoderStream, decoderStream *quic.SendStream - control, err := conn.quic.OpenUniStream() - if err == nil { - _, err = control.Write(firefoxControlStream()) - } - if err == nil { - encoderStream, err = conn.quic.OpenUniStream() - } - if err == nil { - decoderStream, err = conn.quic.OpenUniStream() - } - if err != nil { - return err - } - conn.mu.Lock() - conn.encoder, conn.encoderStream = encoder, encoderStream - err = conn.flushEncoderLocked() - conn.mu.Unlock() - conn.decoderMu.Lock() - conn.decoder, conn.decoderStream = decoder, decoderStream - conn.decoderMu.Unlock() - if err == nil { - err = conn.flushDecoder() - } - if err == nil { - go conn.acceptUniStreams(encoder, decoder) - } - return err -} - -// awaitHandshake 等 0-RTT 连接握手完成;服务端拒绝 0-RTT 时按 neqo 重新打开控制流与 QPACK 流,编码器等待新的服务端 SETTINGS -func (conn *http3Conn) awaitHandshake() { - defer close(conn.ready) - select { - case <-conn.quic.HandshakeComplete(): - case <-conn.quic.Context().Done(): - return - } - if conn.quic.ConnectionState().Used0RTT { - return - } - if _, err := conn.quic.NextConnection(conn.quic.Context()); err != nil || conn.open(nil) != nil { - conn.close() - } -} - -// awaitReady 等待连接握手完成 -func (conn *http3Conn) awaitReady(ctx context.Context) error { - select { - case <-conn.ready: - return nil - case <-ctx.Done(): - return ctx.Err() - } -} - -// firefoxControlStream 返回控制流开头的流类型、SETTINGS 与一个随机 GREASE 帧 -func firefoxControlStream() []byte { - var settings []byte - for _, setting := range firefoxHTTP3Settings { - settings = quicvarint.Append(settings, setting[0]) - settings = quicvarint.Append(settings, setting[1]) - } - stream := quicvarint.Append(nil, h3ControlStreamType) - stream = appendH3Frame(stream, h3FrameSettings, settings) - var random [8]byte - _, _ = rand.Read(random[:]) - greaseType := (binary.NativeEndian.Uint64(random[:])>>7)*0x1f + 0x21 - return appendH3Frame(stream, greaseType, random[1:1+random[0]&0x7]) -} - -func appendH3Frame(buffer []byte, kind uint64, payload []byte) []byte { - buffer = quicvarint.Append(buffer, kind) - buffer = quicvarint.Append(buffer, uint64(len(payload))) - return append(buffer, payload...) -} - -func (conn *http3Conn) flushEncoderLocked() error { - if len(conn.encoder.pending) == 0 { - return nil - } - _, err := conn.encoderStream.Write(conn.encoder.pending) - conn.encoder.pending = nil - return err -} - -func (conn *http3Conn) flushDecoder() error { - conn.decoderMu.Lock() - defer conn.decoderMu.Unlock() - if pending := conn.decoder.takePending(); len(pending) > 0 { - _, err := conn.decoderStream.Write(pending) - return err - } - return nil -} - -// scheduleDecoderFlush 在本批编码器指令处理完的 1 毫秒后写出 Insert Count Increment,期间解码的头块先写出 Section Acknowledgment -func (conn *http3Conn) scheduleDecoderFlush() { - if conn.ackPending.CompareAndSwap(false, true) { - time.AfterFunc(time.Millisecond, func() { - conn.ackPending.Store(false) - _ = conn.flushDecoder() - }) - } -} - -// acceptUniStreams 处理服务端打开的单向流:控制流、QPACK 编码器流与解码器流,其余类型以 H3_STREAM_CREATION_ERROR 停止接收 -func (conn *http3Conn) acceptUniStreams(encoder *qpackEncoder, decoder *qpackDecoder) { - for { - stream, err := conn.quic.AcceptUniStream(conn.quic.Context()) - if err != nil { - return - } - go func() { - reader := bufio.NewReader(stream) - kind, err := quicvarint.Read(reader) - if err != nil { - return - } - switch kind { - case h3ControlStreamType: - err = conn.readControlStream(reader, encoder) - case qpackEncoderStreamType: - err = decoder.readEncoderStream(reader, conn.scheduleDecoderFlush) - case qpackDecoderStreamType: - err = encoder.readDecoderStream(reader, &conn.mu) - default: - stream.CancelRead(h3StreamCreationError) - return - } - if err != nil && conn.quic.Context().Err() == nil { - _ = conn.quic.CloseWithError(0x0104, "") - } - }() - } -} - -// readControlStream 读取服务端控制流:SETTINGS 设置并记录 QPACK 编码器参数,GOAWAY 后不再在本连接发起请求 -func (conn *http3Conn) readControlStream(reader *bufio.Reader, encoder *qpackEncoder) error { - for first := true; ; first = false { - kind, payload, err := readH3Frame(reader) - if err != nil { - return err - } - switch { - case kind == h3FrameSettings && first: - capacity, blocked := uint64(0), uint64(0) - for len(payload) > 0 { - id, n, err := quicvarint.Parse(payload) - if err != nil { - return err - } - value, m, err := quicvarint.Parse(payload[n:]) - if err != nil { - return err - } - payload = payload[n+m:] - switch id { - case h3SettingQPACKCapacity: - capacity = value - case h3SettingQPACKBlocked: - blocked = value - } - } - conn.remember(capacity, blocked) - conn.mu.Lock() - encoder.setPeerSettings(capacity, blocked) - err = conn.flushEncoderLocked() - conn.mu.Unlock() - if err != nil { - return err - } - case first: - return fmt.Errorf("HTTP/3 控制流首帧不是 SETTINGS") - case kind == h3FrameGoaway: - conn.goawayOnce.Do(func() { close(conn.goaway) }) - } - } -} - -func readH3Frame(reader *bufio.Reader) (uint64, []byte, error) { - kind, err := quicvarint.Read(reader) - if err != nil { - return 0, nil, err - } - length, err := quicvarint.Read(reader) - if err != nil { - return 0, nil, err - } - if length > 16<<20 { - return 0, nil, fmt.Errorf("HTTP/3 帧长度 %d 超出上限", length) - } - payload := make([]byte, length) - _, err = io.ReadFull(reader, payload) - return kind, payload, err -} - -func (conn *http3Conn) close() { - _ = conn.quic.CloseWithError(h3NoError, "") -} diff --git a/internal/aistudio/transport_http3_stream.go b/internal/aistudio/transport_http3_stream.go deleted file mode 100644 index e9681982..00000000 --- a/internal/aistudio/transport_http3_stream.go +++ /dev/null @@ -1,296 +0,0 @@ -package aistudio - -import ( - "bufio" - "context" - "errors" - "fmt" - "io" - "strconv" - "strings" - "sync/atomic" - - fhttp "github.com/Mag1cFall/fhttp" - quic "github.com/Mag1cFall/uquic" - "github.com/Mag1cFall/uquic/quicvarint" -) - -// h3RequestFields 按 Firefox 的 HTTP/3 请求头生成 QPACK 字段,altUsed 时写入 Alt-Used -func h3RequestFields(request *fhttp.Request, altUsed bool) []qpackField { - authority := request.Host - if authority == "" { - authority = request.URL.Host - } - fields := []qpackField{ - {":method", request.Method}, - {":scheme", request.URL.Scheme}, - {":authority", authority}, - {":path", request.URL.RequestURI()}, - } - header := request.Header.Clone() - delete(header, fhttp.HeaderOrderKey) - if altUsed && header.Get("Sec-Fetch-Dest") != "image" { - header.Set("Alt-Used", request.URL.Hostname()) - } - if length := request.ContentLength; length > 0 || (length == 0 && (request.Method == "POST" || request.Method == "PUT" || request.Method == "PATCH")) { - header.Set("Content-Length", strconv.FormatInt(length, 10)) - } - for _, name := range orderedHeaderNames(header, request.URL.Host) { - if _, excluded := h3ExcludedRequestHeaders[name]; excluded { - continue - } - values := header.Values(name) - if len(values) == 0 { - continue - } - separator := ", " - if name == "cookie" { - separator = "; " - } - fields = append(fields, qpackField{name, strings.Join(values, separator)}) - } - return fields -} - -// roundTrip 在本连接上发送请求并返回响应头已到达的响应,opened 表示请求流已经打开;0-RTT 被拒绝的请求在握手完成后重发一次 -func (conn *http3Conn) roundTrip(request *fhttp.Request, fields []qpackField) (*fhttp.Response, bool, error) { - if !firefoxSafeMethods[request.Method] { - if err := conn.awaitReady(request.Context()); err != nil { - return nil, false, err - } - } - response, opened, err := conn.exchange(request, fields) - if errors.Is(err, quic.Err0RTTRejected) { - if err := conn.awaitReady(request.Context()); err != nil { - return nil, false, err - } - return conn.exchange(request, fields) - } - return response, opened, err -} - -// exchange 打开请求流写出请求并读取响应头,0-RTT 被拒绝的请求流随 0-RTT 数据一起作废,不再重置 -func (conn *http3Conn) exchange(request *fhttp.Request, fields []qpackField) (*fhttp.Response, bool, error) { - ctx := request.Context() - stream, err := conn.quic.OpenStreamSync(ctx) - if err != nil { - return nil, false, err - } - conn.streams.Add(1) - id := int64(stream.StreamID()) - conn.mu.Lock() - block := conn.encoder.encode(fields, id) - err = conn.flushEncoderLocked() - conn.mu.Unlock() - if err == nil { - _, err = stream.Write(appendH3Frame(nil, h3FrameHeaders, block)) - } - if err != nil { - if !errors.Is(err, quic.Err0RTTRejected) { - stream.CancelWrite(h3RequestCancelled) - stream.CancelRead(h3RequestCancelled) - } - return nil, true, err - } - conn.decoderMu.Lock() - body := &http3Body{conn: conn, decoder: conn.decoder, stream: stream, reader: bufio.NewReader(stream)} - conn.decoderMu.Unlock() - body.stopWatch = context.AfterFunc(ctx, body.abort) - if request.Body != nil && request.Body != fhttp.NoBody { - go body.writeRequest(request.Body, request.ContentLength) - } else { - _ = stream.Close() - } - response, err := body.readResponse(ctx, request) - if err != nil { - body.stopWatch() - if !errors.Is(err, quic.Err0RTTRejected) { - body.abort() - } - if ctx.Err() != nil { - err = ctx.Err() - } - return nil, true, err - } - return response, true, nil -} - -// http3Body 是请求流上的响应体,按帧读取 DATA,结尾的 HEADERS 写入 trailer -type http3Body struct { - conn *http3Conn - decoder *qpackDecoder - stream *quic.Stream - reader *bufio.Reader - response *fhttp.Response - remaining uint64 - done bool - aborted atomic.Bool - stopWatch func() bool -} - -// h3DataHeaderMax 是 DATA 帧头的最大长度:1 字节帧类型与 4 字节帧长 -const h3DataHeaderMax = 5 - -// writeRequest 把 source 每次读到的正文写成一个 DATA 帧:读取缓冲前预留帧头的位置,帧头紧贴正文写入后以一次 Write 发出整帧;length 为已知的正文长度,小于每帧上限时缓冲只取这么长 -func (body *http3Body) writeRequest(source io.ReadCloser, length int64) { - defer source.Close() - size := h3RequestBodyChunk - if length > 0 && length < int64(size) { - size = int(length) - } - buffer := make([]byte, h3DataHeaderMax+size) - for { - read, err := source.Read(buffer[h3DataHeaderMax:]) - if read > 0 { - start := h3DataHeaderMax - quicvarint.Len(h3FrameData) - quicvarint.Len(uint64(read)) - quicvarint.Append(quicvarint.Append(buffer[start:start], h3FrameData), uint64(read)) - if _, werr := body.stream.Write(buffer[start : h3DataHeaderMax+read]); werr != nil { - return - } - } - if err == io.EOF { - _ = body.stream.Close() - return - } - if err != nil { - body.stream.CancelWrite(h3RequestCancelled) - return - } - } -} - -func (body *http3Body) readResponse(ctx context.Context, request *fhttp.Request) (*fhttp.Response, error) { - for { - kind, payload, err := readH3Frame(body.reader) - if err != nil { - return nil, err - } - if kind != h3FrameHeaders { - if kind == h3FrameData { - return nil, fmt.Errorf("HTTP/3 响应在 HEADERS 之前收到 DATA") - } - continue - } - fields, err := body.decoder.decode(ctx, payload, int64(body.stream.StreamID())) - if err != nil { - return nil, err - } - _ = body.conn.flushDecoder() - header := make(fhttp.Header, len(fields)) - status := 0 - for _, field := range fields { - if field.name == ":status" { - status, _ = strconv.Atoi(field.value) - continue - } - header.Add(field.name, field.value) - } - if status < 100 || status > 599 { - return nil, fmt.Errorf("HTTP/3 响应状态 %d 无效", status) - } - if status < 200 { - continue - } - response := &fhttp.Response{ - Status: strconv.Itoa(status) + " " + fhttp.StatusText(status), - StatusCode: status, - Proto: "HTTP/3.0", - ProtoMajor: 3, - Header: header, - ContentLength: -1, - Trailer: fhttp.Header{}, - Request: request, - Body: body, - } - if length, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil { - response.ContentLength = length - } - body.response = response - if request.Method != "HEAD" { - response.Body = fhttp.DecompressBody(response) - } - return response, nil - } -} - -func (body *http3Body) Read(buffer []byte) (int, error) { - for { - if body.done { - return 0, io.EOF - } - if body.remaining > 0 { - read, err := body.reader.Read(buffer[:min(uint64(len(buffer)), body.remaining)]) - body.remaining -= uint64(read) - if err == io.EOF { - err = nil - if body.remaining > 0 { - err = io.ErrUnexpectedEOF - } - } - return read, body.readError(err) - } - kind, err := quicvarint.Read(body.reader) - if err == io.EOF { - body.done = true - body.stopWatch() - return 0, io.EOF - } - if err != nil { - return 0, body.readError(err) - } - length, err := quicvarint.Read(body.reader) - if err != nil { - return 0, body.readError(err) - } - switch kind { - case h3FrameData: - body.remaining = length - case h3FrameHeaders: - payload := make([]byte, length) - if _, err := io.ReadFull(body.reader, payload); err != nil { - return 0, body.readError(err) - } - fields, err := body.decoder.decode(context.Background(), payload, int64(body.stream.StreamID())) - if err != nil { - return 0, err - } - _ = body.conn.flushDecoder() - for _, field := range fields { - body.response.Trailer.Add(field.name, field.value) - } - default: - if _, err := body.reader.Discard(int(length)); err != nil { - return 0, body.readError(err) - } - } - } -} - -func (body *http3Body) readError(err error) error { - if err != nil && body.aborted.Load() { - if ctxErr := body.response.Request.Context().Err(); ctxErr != nil { - return ctxErr - } - return errors.New("HTTP/3 响应体已关闭") - } - return err -} - -func (body *http3Body) Close() error { - body.stopWatch() - if !body.done { - body.abort() - } - return nil -} - -// abort 按 Firefox 取消请求:以 H3_REQUEST_CANCELLED 重置请求流并在解码器流写出 Stream Cancellation -func (body *http3Body) abort() { - if !body.aborted.CompareAndSwap(false, true) { - return - } - body.stream.CancelWrite(h3RequestCancelled) - body.stream.CancelRead(h3RequestCancelled) - body.decoder.cancel(int64(body.stream.StreamID())) - _ = body.conn.flushDecoder() -} diff --git a/internal/aistudio/transport_qpack.go b/internal/aistudio/transport_qpack.go deleted file mode 100644 index a1767d78..00000000 --- a/internal/aistudio/transport_qpack.go +++ /dev/null @@ -1,813 +0,0 @@ -package aistudio - -import ( - "bufio" - "context" - "errors" - "fmt" - "io" - "math" - "sync" - - "golang.org/x/net/http2/hpack" -) - -const ( - // qpackEncoderStreamType 是 QPACK 编码器单向流的类型 - qpackEncoderStreamType = 0x02 - // qpackDecoderStreamType 是 QPACK 解码器单向流的类型 - qpackDecoderStreamType = 0x03 - // firefoxQPACKTableSize 是 Firefox network.http.http3.default_qpack_table_size,编码与解码两侧共用 - firefoxQPACKTableSize = 65536 - // firefoxQPACKBlockedStreams 是 Firefox network.http.http3.default_max_stream_blocked - firefoxQPACKBlockedStreams = 20 - // qpackEntryOverhead 是 QPACK 动态表条目在名与值之外计入的字节数 - qpackEntryOverhead = 32 - // qpackDecoderMaxEntries 是 RFC 9204 3.2.2 按本端声明的动态表容量算出的最大条目数 - qpackDecoderMaxEntries uint64 = firefoxQPACKTableSize / qpackEntryOverhead -) - -// qpackField 是一条 QPACK 头字段 -type qpackField struct { - name string - value string -} - -// qpackStaticTable 是 RFC 9204 附录 A 的 QPACK 静态表 -var qpackStaticTable = [...]qpackField{ - {":authority", ""}, {":path", "/"}, {"age", "0"}, {"content-disposition", ""}, {"content-length", "0"}, {"cookie", ""}, {"date", ""}, {"etag", ""}, - {"if-modified-since", ""}, {"if-none-match", ""}, {"last-modified", ""}, {"link", ""}, {"location", ""}, {"referer", ""}, {"set-cookie", ""}, - {":method", "CONNECT"}, {":method", "DELETE"}, {":method", "GET"}, {":method", "HEAD"}, {":method", "OPTIONS"}, {":method", "POST"}, {":method", "PUT"}, - {":scheme", "http"}, {":scheme", "https"}, {":status", "103"}, {":status", "200"}, {":status", "304"}, {":status", "404"}, {":status", "503"}, - {"accept", "*/*"}, {"accept", "application/dns-message"}, {"accept-encoding", "gzip, deflate, br"}, {"accept-ranges", "bytes"}, - {"access-control-allow-headers", "cache-control"}, {"access-control-allow-headers", "content-type"}, {"access-control-allow-origin", "*"}, - {"cache-control", "max-age=0"}, {"cache-control", "max-age=2592000"}, {"cache-control", "max-age=604800"}, {"cache-control", "no-cache"}, - {"cache-control", "no-store"}, {"cache-control", "public, max-age=31536000"}, {"content-encoding", "br"}, {"content-encoding", "gzip"}, - {"content-type", "application/dns-message"}, {"content-type", "application/javascript"}, {"content-type", "application/json"}, - {"content-type", "application/x-www-form-urlencoded"}, {"content-type", "image/gif"}, {"content-type", "image/jpeg"}, {"content-type", "image/png"}, - {"content-type", "text/css"}, {"content-type", "text/html; charset=utf-8"}, {"content-type", "text/plain"}, {"content-type", "text/plain;charset=utf-8"}, - {"range", "bytes=0-"}, {"strict-transport-security", "max-age=31536000"}, {"strict-transport-security", "max-age=31536000; includesubdomains"}, - {"strict-transport-security", "max-age=31536000; includesubdomains; preload"}, {"vary", "accept-encoding"}, {"vary", "origin"}, - {"x-content-type-options", "nosniff"}, {"x-xss-protection", "1; mode=block"}, {":status", "100"}, {":status", "204"}, {":status", "206"}, - {":status", "302"}, {":status", "400"}, {":status", "403"}, {":status", "421"}, {":status", "425"}, {":status", "500"}, {"accept-language", ""}, - {"access-control-allow-credentials", "FALSE"}, {"access-control-allow-credentials", "TRUE"}, {"access-control-allow-headers", "*"}, - {"access-control-allow-methods", "get"}, {"access-control-allow-methods", "get, post, options"}, {"access-control-allow-methods", "options"}, - {"access-control-expose-headers", "content-length"}, {"access-control-request-headers", "content-type"}, {"access-control-request-method", "get"}, - {"access-control-request-method", "post"}, {"alt-svc", "clear"}, {"authorization", ""}, - {"content-security-policy", "script-src 'none'; object-src 'none'; base-uri 'none'"}, {"early-data", "1"}, {"expect-ct", ""}, {"forwarded", ""}, - {"if-range", ""}, {"origin", ""}, {"purpose", "prefetch"}, {"server", ""}, {"timing-allow-origin", "*"}, {"upgrade-insecure-requests", "1"}, - {"user-agent", ""}, {"x-forwarded-for", ""}, {"x-frame-options", "deny"}, {"x-frame-options", "sameorigin"}, -} - -// errQPACK 是 QPACK 数据无法按 RFC 9204 解释时的错误 -var errQPACK = errors.New("QPACK 数据无效") - -// qpackEntry 是动态表中的一条记录,index 为绝对索引 -type qpackEntry struct { - qpackField - index uint64 - refs int -} - -func (entry *qpackEntry) size() uint64 { - return uint64(len(entry.name)+len(entry.value)) + qpackEntryOverhead -} - -// qpackTable 是 neqo 语义的 QPACK 动态表,entries 按插入顺序从新到旧排列 -type qpackTable struct { - entries []*qpackEntry - capacity uint64 - used uint64 - base uint64 - acked uint64 -} - -func (table *qpackTable) canReduce(entry *qpackEntry) bool { - return entry.refs == 0 && entry.index < table.acked -} - -func (table *qpackTable) evictTo(size uint64) bool { - for len(table.entries) > 0 && table.used > size { - oldest := table.entries[len(table.entries)-1] - if !table.canReduce(oldest) { - return false - } - table.used -= oldest.size() - table.entries = table.entries[:len(table.entries)-1] - } - return true -} - -func (table *qpackTable) canEvictTo(size uint64) bool { - evictable := uint64(0) - for i := len(table.entries) - 1; i >= 0 && table.canReduce(table.entries[i]); i-- { - evictable += table.entries[i].size() - } - return table.used-evictable <= size -} - -func (table *qpackTable) setCapacity(capacity uint64) error { - if !table.evictTo(capacity) { - return errQPACK - } - table.capacity = capacity - return nil -} - -func (table *qpackTable) insert(field qpackField) (uint64, error) { - entry := &qpackEntry{qpackField: field, index: table.base} - if entry.size() > table.capacity || !table.evictTo(table.capacity-entry.size()) { - return 0, errQPACK - } - table.base++ - table.used += entry.size() - table.entries = append([]*qpackEntry{entry}, table.entries...) - return entry.index, nil -} - -func (table *qpackTable) absolute(index uint64) *qpackEntry { - if index >= table.base || table.base-index-1 >= uint64(len(table.entries)) { - return nil - } - return table.entries[table.base-index-1] -} - -// relative 按头块的 base 与相对索引取条目,post 表示 post-base 索引 -func (table *qpackTable) relative(index uint64, base uint64, post bool) (*qpackEntry, error) { - var absolute uint64 - if post { - absolute = base + index - } else { - if index >= base { - return nil, errQPACK - } - absolute = base - index - 1 - } - if entry := table.absolute(absolute); entry != nil { - return entry, nil - } - return nil, errQPACK -} - -// lookup 按 neqo 的顺序先查静态表再查动态表,返回完整匹配或首个同名条目 -func (table *qpackTable) lookup(field qpackField, canBlock bool) (index uint64, static bool, exact bool, found bool) { - for i, entry := range qpackStaticTable { - if entry.name != field.name { - continue - } - if entry.value == field.value { - return uint64(i), true, true, true - } - if !found { - index, static, found = uint64(i), true, true - } - } - for _, entry := range table.entries { - if !canBlock && entry.index >= table.acked { - continue - } - if entry.name != field.name { - continue - } - if entry.value == field.value { - return entry.index, false, true, true - } - if !found { - index, static, found = entry.index, false, true - } - } - return index, static, false, found -} - -// appendQPACKInt 按 RFC 9204 4.1.1 写入带前缀的整数,prefix 为前缀位,bits 为前缀位数 -func appendQPACKInt(buffer []byte, prefix byte, bits uint8, value uint64) []byte { - limit := uint64(1)<<(8-bits) - 1 - if value < limit { - return append(buffer, prefix|byte(value)) - } - buffer = append(buffer, prefix|byte(limit)) - value -= limit - for value >= 0x80 { - buffer = append(buffer, byte(value)|0x80) - value >>= 7 - } - return append(buffer, byte(value)) -} - -// appendQPACKString 以 Huffman 编码写入字符串字面量,H 位紧随 bits 个前缀位 -func appendQPACKString(buffer []byte, prefix byte, bits uint8, value string) []byte { - buffer = appendQPACKInt(buffer, prefix|0x80>>bits, bits+1, hpack.HuffmanEncodeLength(value)) - return hpack.AppendHuffmanString(buffer, value) -} - -// qpackEncoder 按 neqo 0.31 的策略编码请求头:静态表没有的头名连同取值写入动态表并按索引引用,字面量一律 Huffman 编码 -type qpackEncoder struct { - table qpackTable - maxEntries uint64 - maxBlocked uint64 - blocked uint64 - nextCapacity uint64 - hasNext bool - // unacked 记录每个请求流尚未确认的头块引用的动态表条目,按发送顺序排列 - unacked map[int64][][]uint64 - // pending 是待写入编码器流的字节 - pending []byte -} - -func newQPACKEncoder() *qpackEncoder { - return &qpackEncoder{unacked: map[int64][][]uint64{}, pending: []byte{qpackEncoderStreamType}} -} - -// setPeerSettings 按服务端 SETTINGS 的动态表容量与阻塞流上限设置编码器 -func (encoder *qpackEncoder) setPeerSettings(capacity uint64, blocked uint64) { - encoder.maxBlocked = blocked - if capacity = min(capacity, firefoxQPACKTableSize); capacity != encoder.table.capacity { - encoder.nextCapacity, encoder.hasNext = capacity, true - } - _ = encoder.sendCapacity() -} - -func (encoder *qpackEncoder) sendCapacity() error { - if !encoder.hasNext { - return nil - } - if encoder.nextCapacity < encoder.table.capacity && !encoder.table.canEvictTo(encoder.nextCapacity) { - return errQPACK - } - encoder.pending = appendQPACKInt(encoder.pending, 0x20, 3, encoder.nextCapacity) - _ = encoder.table.setCapacity(encoder.nextCapacity) - encoder.maxEntries = encoder.nextCapacity / 32 - encoder.hasNext = false - return nil -} - -func (encoder *qpackEncoder) isBlocker(stream int64) bool { - for _, refs := range encoder.unacked[stream] { - for _, index := range refs { - if index >= encoder.table.acked { - return true - } - } - } - return false -} - -// encode 编码一个头块,需要写入编码器流的指令追加到 pending -func (encoder *qpackEncoder) encode(fields []qpackField, stream int64) []byte { - encoderBlocked := encoder.sendCapacity() != nil - base := encoder.table.base - streamBlocker := encoder.isBlocker(stream) - canBlock := encoder.blocked < encoder.maxBlocked || streamBlocker - refs := make([]uint64, 0) - referenced := map[uint64]bool{} - maxRef, hasRef := uint64(0), false - reference := func(index uint64) { - if !hasRef || index > maxRef { - maxRef, hasRef = index, true - } - } - addRef := func(index uint64) { - if !referenced[index] { - referenced[index] = true - refs = append(refs, index) - encoder.table.absolute(index).refs++ - } - } - var body []byte - for _, field := range fields { - index, static, exact, found := encoder.table.lookup(field, canBlock) - switch { - case found && exact && static: - body = appendQPACKInt(body, 0xc0, 2, index) - case found && exact: - body = encoder.appendDynamicIndex(body, index, base) - reference(index) - case found && static: - body = appendQPACKInt(body, 0x50, 4, index) - body = appendQPACKString(body, 0, 0, field.value) - case found: - if index < base { - body = appendQPACKInt(body, 0x40, 4, base-index-1) - } else { - body = appendQPACKInt(body, 0x00, 5, index-base) - } - body = appendQPACKString(body, 0, 0, field.value) - reference(index) - case canBlock && !encoderBlocked: - inserted, ok := encoder.insert(field) - if !ok { - encoderBlocked = true - body = appendQPACKString(body, 0x20, 4, field.name) - body = appendQPACKString(body, 0, 0, field.value) - continue - } - body = encoder.appendDynamicIndex(body, inserted, base) - reference(inserted) - addRef(inserted) - continue - default: - body = appendQPACKString(body, 0x20, 4, field.name) - body = appendQPACKString(body, 0, 0, field.value) - continue - } - if found && !static { - addRef(index) - } - } - block := encoder.appendPrefix(nil, base, maxRef, hasRef) - block = append(block, body...) - if !streamBlocker && hasRef && maxRef >= encoder.table.acked { - encoder.blocked++ - } - if len(refs) > 0 { - encoder.unacked[stream] = append(encoder.unacked[stream], refs) - } - return block -} - -func (encoder *qpackEncoder) insert(field qpackField) (uint64, bool) { - size := uint64(len(field.name)+len(field.value)) + qpackEntryOverhead - if size > encoder.table.capacity || !encoder.table.canEvictTo(encoder.table.capacity-size) { - return 0, false - } - encoder.pending = appendQPACKString(encoder.pending, 0x40, 2, field.name) - encoder.pending = appendQPACKString(encoder.pending, 0, 0, field.value) - index, err := encoder.table.insert(field) - return index, err == nil -} - -func (encoder *qpackEncoder) appendDynamicIndex(buffer []byte, index uint64, base uint64) []byte { - if index < base { - return appendQPACKInt(buffer, 0x80, 2, base-index-1) - } - return appendQPACKInt(buffer, 0x10, 4, index-base) -} - -func (encoder *qpackEncoder) appendPrefix(buffer []byte, base uint64, maxRef uint64, hasRef bool) []byte { - if !hasRef { - buffer = appendQPACKInt(buffer, 0, 0, 0) - return appendQPACKInt(buffer, 0x00, 1, base) - } - required := maxRef + 1 - buffer = appendQPACKInt(buffer, 0, 0, required%(2*encoder.maxEntries)+1) - if required <= base { - return appendQPACKInt(buffer, 0x00, 1, base-required) - } - return appendQPACKInt(buffer, 0x80, 1, required-base-1) -} - -func (encoder *qpackEncoder) recalculateBlocked() { - encoder.blocked = 0 - for stream := range encoder.unacked { - if encoder.isBlocker(stream) { - encoder.blocked++ - } - } -} - -func (encoder *qpackEncoder) incrementAcked(increment uint64) error { - encoder.table.acked += increment - if encoder.table.base < encoder.table.acked { - return errQPACK - } - encoder.recalculateBlocked() - return nil -} - -func (encoder *qpackEncoder) sectionAck(stream int64) error { - blocks := encoder.unacked[stream] - if len(blocks) == 0 { - return errQPACK - } - acked := encoder.table.acked - for _, index := range blocks[0] { - encoder.table.absolute(index).refs-- - if index >= acked { - acked = index + 1 - } - } - if blocks = blocks[1:]; len(blocks) == 0 { - delete(encoder.unacked, stream) - } else { - encoder.unacked[stream] = blocks - } - if acked > encoder.table.acked { - return encoder.incrementAcked(acked - encoder.table.acked) - } - return nil -} - -func (encoder *qpackEncoder) streamCancel(stream int64) { - wasBlocker := false - for _, refs := range encoder.unacked[stream] { - for _, index := range refs { - encoder.table.absolute(index).refs-- - wasBlocker = wasBlocker || index >= encoder.table.acked - } - } - delete(encoder.unacked, stream) - if wasBlocker && encoder.blocked > 0 { - encoder.blocked-- - } -} - -// readQPACKInt 读取带前缀的整数,first 为已读出的首字节,bits 为前缀位数 -func readQPACKInt(reader io.ByteReader, first byte, bits uint8) (uint64, error) { - limit := uint64(1)<<(8-bits) - 1 - value := uint64(first) & limit - if value < limit { - return value, nil - } - for shift := uint(0); shift < 63; shift += 7 { - next, err := reader.ReadByte() - if err != nil { - return 0, err - } - value += uint64(next&0x7f) << shift - if next&0x80 == 0 { - return value, nil - } - } - return 0, errQPACK -} - -// qpackByteReader 是读取 QPACK 字面量所需的字节读取接口 -type qpackByteReader interface { - io.ByteReader - io.Reader -} - -// readQPACKValue 读取首字节没有其他字段的字符串字面量 -func readQPACKValue(reader qpackByteReader) (string, error) { - first, err := reader.ReadByte() - if err != nil { - return "", err - } - return readQPACKString(reader, first, 0) -} - -// readQPACKString 读取字符串字面量,H 位紧随 bits 个前缀位 -func readQPACKString(reader qpackByteReader, first byte, bits uint8) (string, error) { - length, err := readQPACKInt(reader, first, bits+1) - if err != nil { - return "", err - } - if length > 1<<20 { - return "", errQPACK - } - raw := make([]byte, length) - if _, err := io.ReadFull(reader, raw); err != nil { - return "", err - } - if first&(0x80>>bits) == 0 { - return string(raw), nil - } - return hpack.HuffmanDecodeToString(raw) -} - -// readDecoderStream 读取服务端解码器流上的指令并更新编码器状态 -func (encoder *qpackEncoder) readDecoderStream(stream io.Reader, mu *sync.Mutex) error { - reader := bufio.NewReader(stream) - for { - first, err := reader.ReadByte() - if err != nil { - return err - } - var apply func() error - switch { - case first&0x80 != 0: - id, err := readQPACKInt(reader, first, 1) - if err != nil { - return err - } - apply = func() error { return encoder.sectionAck(int64(id)) } - case first&0x40 != 0: - id, err := readQPACKInt(reader, first, 2) - if err != nil { - return err - } - apply = func() error { encoder.streamCancel(int64(id)); return nil } - default: - increment, err := readQPACKInt(reader, first, 2) - if err != nil { - return err - } - apply = func() error { return encoder.incrementAcked(increment) } - } - mu.Lock() - err = apply() - mu.Unlock() - if err != nil { - return err - } - } -} - -// qpackDecoder 维护服务端编码器写入的动态表并解码响应头块,回执时机与 neqo 0.31 一致 -type qpackDecoder struct { - mu sync.Mutex - changed chan struct{} - table qpackTable - acked uint64 - blocked int - // pending 是待写入解码器流的字节 - pending []byte -} - -func newQPACKDecoder() *qpackDecoder { - return &qpackDecoder{changed: make(chan struct{}), table: qpackTable{acked: math.MaxUint64}, pending: []byte{qpackDecoderStreamType}} -} - -// readEncoderStream 读取服务端编码器流的指令写入动态表,每读完一批到达的数据调用一次 flush -func (decoder *qpackDecoder) readEncoderStream(stream io.Reader, flush func()) error { - reader := bufio.NewReader(stream) - for { - first, err := reader.ReadByte() - if err != nil { - return err - } - if err := decoder.readInstruction(reader, first); err != nil { - return err - } - if reader.Buffered() == 0 { - flush() - } - } -} - -func (decoder *qpackDecoder) readInstruction(reader *bufio.Reader, first byte) error { - var field qpackField - switch { - case first&0x80 != 0: - index, err := readQPACKInt(reader, first, 2) - if err != nil { - return err - } - value, err := readQPACKValue(reader) - if err != nil { - return err - } - decoder.mu.Lock() - defer decoder.mu.Unlock() - if first&0x40 != 0 { - if index >= uint64(len(qpackStaticTable)) { - return errQPACK - } - field = qpackField{qpackStaticTable[index].name, value} - } else { - entry, err := decoder.table.relative(index, decoder.table.base, false) - if err != nil { - return err - } - field = qpackField{entry.name, value} - } - return decoder.insertLocked(field) - case first&0x40 != 0: - name, err := readQPACKString(reader, first, 2) - if err != nil { - return err - } - value, err := readQPACKValue(reader) - if err != nil { - return err - } - decoder.mu.Lock() - defer decoder.mu.Unlock() - return decoder.insertLocked(qpackField{name, value}) - case first&0x20 != 0: - capacity, err := readQPACKInt(reader, first, 3) - if err != nil { - return err - } - if capacity > firefoxQPACKTableSize { - return errQPACK - } - decoder.mu.Lock() - defer decoder.mu.Unlock() - return decoder.table.setCapacity(capacity) - default: - index, err := readQPACKInt(reader, first, 3) - if err != nil { - return err - } - decoder.mu.Lock() - defer decoder.mu.Unlock() - entry, err := decoder.table.relative(index, decoder.table.base, false) - if err != nil { - return err - } - return decoder.insertLocked(entry.qpackField) - } -} - -func (decoder *qpackDecoder) insertLocked(field qpackField) error { - if _, err := decoder.table.insert(field); err != nil { - return err - } - close(decoder.changed) - decoder.changed = make(chan struct{}) - return nil -} - -// decode 解码一个头块,引用尚未到达的动态表条目时等待编码器流,解码后追加 Section Acknowledgment -func (decoder *qpackDecoder) decode(ctx context.Context, block []byte, stream int64) ([]qpackField, error) { - reader := &qpackBlockReader{data: block} - first, err := reader.ReadByte() - if err != nil { - return nil, err - } - encoded, err := readQPACKInt(reader, first, 0) - if err != nil { - return nil, err - } - signByte, err := reader.ReadByte() - if err != nil { - return nil, err - } - delta, err := readQPACKInt(reader, signByte, 1) - if err != nil { - return nil, err - } - decoder.mu.Lock() - defer decoder.mu.Unlock() - required, err := decoder.requiredInsertCount(encoded) - if err != nil { - return nil, err - } - var base uint64 - if signByte&0x80 != 0 { - if required <= delta { - return nil, errQPACK - } - base = required - delta - 1 - } else { - base = required + delta - } - if decoder.table.base < required { - if decoder.blocked > firefoxQPACKBlockedStreams { - return nil, fmt.Errorf("QPACK 阻塞流超过 %d", firefoxQPACKBlockedStreams) - } - decoder.blocked++ - for decoder.table.base < required { - changed := decoder.changed - decoder.mu.Unlock() - select { - case <-changed: - decoder.mu.Lock() - case <-ctx.Done(): - decoder.mu.Lock() - decoder.blocked-- - return nil, ctx.Err() - } - } - decoder.blocked-- - } - fields, err := decoder.decodeFields(reader, base) - if err != nil { - return nil, err - } - if required != 0 { - decoder.pending = appendQPACKInt(decoder.pending, 0x80, 1, uint64(stream)) - decoder.acked = max(decoder.acked, required) - } - return fields, nil -} - -func (decoder *qpackDecoder) requiredInsertCount(encoded uint64) (uint64, error) { - if encoded == 0 { - return 0, nil - } - full := 2 * qpackDecoderMaxEntries - if encoded > full { - return 0, errQPACK - } - maxValue := decoder.table.base + qpackDecoderMaxEntries - required := maxValue/full*full + encoded - 1 - if required > maxValue { - if required < full { - return 0, errQPACK - } - required -= full - } - return required, nil -} - -func (decoder *qpackDecoder) decodeFields(reader *qpackBlockReader, base uint64) ([]qpackField, error) { - fields := make([]qpackField, 0, 16) - for reader.offset < len(reader.data) { - first, _ := reader.ReadByte() - var field qpackField - switch { - case first&0x80 != 0: - index, err := readQPACKInt(reader, first, 2) - if err != nil { - return nil, err - } - if field, err = decoder.lookup(index, base, first&0x40 != 0, false); err != nil { - return nil, err - } - case first&0x40 != 0: - index, err := readQPACKInt(reader, first, 4) - if err != nil { - return nil, err - } - if field, err = decoder.lookup(index, base, first&0x10 != 0, false); err != nil { - return nil, err - } - if field.value, err = readQPACKValue(reader); err != nil { - return nil, err - } - case first&0x20 != 0: - name, err := readQPACKString(reader, first, 4) - if err != nil { - return nil, err - } - value, err := readQPACKValue(reader) - if err != nil { - return nil, err - } - field = qpackField{name, value} - case first&0x10 != 0: - index, err := readQPACKInt(reader, first, 4) - if err != nil { - return nil, err - } - if field, err = decoder.lookup(index, base, false, true); err != nil { - return nil, err - } - default: - index, err := readQPACKInt(reader, first, 5) - if err != nil { - return nil, err - } - if field, err = decoder.lookup(index, base, false, true); err != nil { - return nil, err - } - if field.value, err = readQPACKValue(reader); err != nil { - return nil, err - } - } - fields = append(fields, field) - } - return fields, nil -} - -func (decoder *qpackDecoder) lookup(index uint64, base uint64, static bool, post bool) (qpackField, error) { - if static { - if index >= uint64(len(qpackStaticTable)) { - return qpackField{}, errQPACK - } - return qpackStaticTable[index], nil - } - entry, err := decoder.table.relative(index, base, post) - if err != nil { - return qpackField{}, err - } - return entry.qpackField, nil -} - -// cancel 在放弃读取请求流时追加 Stream Cancellation -func (decoder *qpackDecoder) cancel(stream int64) { - decoder.mu.Lock() - defer decoder.mu.Unlock() - if decoder.table.capacity > 0 { - decoder.pending = appendQPACKInt(decoder.pending, 0x40, 2, uint64(stream)) - } -} - -// takePending 追加尚未确认插入数的 Insert Count Increment 并取出待写入解码器流的字节 -func (decoder *qpackDecoder) takePending() []byte { - decoder.mu.Lock() - defer decoder.mu.Unlock() - if increment := decoder.table.base - decoder.acked; increment > 0 { - decoder.pending = appendQPACKInt(decoder.pending, 0x00, 2, increment) - decoder.acked = decoder.table.base - } - pending := decoder.pending - decoder.pending = nil - return pending -} - -// qpackBlockReader 顺序读取一个完整头块 -type qpackBlockReader struct { - data []byte - offset int -} - -func (reader *qpackBlockReader) ReadByte() (byte, error) { - if reader.offset >= len(reader.data) { - return 0, errQPACK - } - value := reader.data[reader.offset] - reader.offset++ - return value, nil -} - -func (reader *qpackBlockReader) Read(buffer []byte) (int, error) { - if reader.offset >= len(reader.data) { - return 0, io.EOF - } - read := copy(buffer, reader.data[reader.offset:]) - reader.offset += read - return read, nil -} diff --git a/internal/aistudio/transport_quic.go b/internal/aistudio/transport_quic.go deleted file mode 100644 index e3e73c75..00000000 --- a/internal/aistudio/transport_quic.go +++ /dev/null @@ -1,454 +0,0 @@ -package aistudio - -import ( - "context" - "crypto/rand" - "encoding/binary" - "fmt" - mrand "math/rand/v2" - "net" - "net/netip" - "sync" - "time" - - quic "github.com/Mag1cFall/uquic" - "github.com/Mag1cFall/uquic/quicvarint" - utls "github.com/Mag1cFall/utls" - "github.com/Mag1cFall/utls/dicttls" -) - -const ( - // firefoxQUICIdleTimeout 是 Firefox network.http.http3.idle_timeout - firefoxQUICIdleTimeout = 30 * time.Second - // firefoxQUICMaxData 是 Firefox network.http.http3.max_data - firefoxQUICMaxData = 25165824 - // firefoxQUICMaxStreamData 是 Firefox network.http.http3.max_stream_data - firefoxQUICMaxStreamData = 12582912 - // neqoStreamWindow 是 neqo 0.31 对端发起流与单向流的初始接收窗口 - neqoStreamWindow = 1048576 - // neqoMaxStreams 是 neqo 0.31 允许对端打开的双向流与单向流数 - neqoMaxStreams = 100 - // neqoResetStreamAtParameter 是 neqo 0.31 以空值声明支持 RESET_STREAM_AT 的传输参数 ID - neqoResetStreamAtParameter = 0x1d - // neqoMinAckDelayParameter 是 neqo 0.31 发送的 min_ack_delay 草案传输参数 ID - neqoMinAckDelayParameter = 0xff02de1a - // neqoMinAckDelay 是 neqo 0.31 声明的 min_ack_delay,单位微秒 - neqoMinAckDelay = 1000 - // neqoSourceConnectionIDLength 是 Firefox 为 neqo 配置的本端连接 ID 长度 - neqoSourceConnectionIDLength = 3 - // neqoIPv4Datagram 是 neqo 0.31 关闭 PMTUD 时 IPv4 的 UDP 载荷上限,Initial 数据报补零到该长度 - neqoIPv4Datagram = 1252 - // neqoIPv6Datagram 是 neqo 0.31 关闭 PMTUD 时 IPv6 的 UDP 载荷上限 - neqoIPv6Datagram = 1232 - // quicAEADOverhead 是 QUIC 包保护的 AEAD 标签长度 - quicAEADOverhead = 16 - // h3NoError 是 HTTP/3 H3_NO_ERROR - h3NoError = 0x100 - // nssQUICGREASEECHInner 是 NSS 为 QUIC ClientHello 的 GREASE ECH 估算的内层 ClientHello 基础长度 - nssQUICGREASEECHInner = 193 - // nssTLSGREASEECHInner 是 NSS 为 TCP ClientHello 的 GREASE ECH 估算的内层 ClientHello 基础长度,比 QUIC 多 12 个 TLS 1.2 密码套件 - nssTLSGREASEECHInner = 217 -) - -// quicResumption 是一类请求的 QUIC 连接共用的会话票据、NEW_TOKEN 令牌与各主机上次收到的服务端 QPACK 设置 -type quicResumption struct { - sessions utls.ClientSessionCache - tokens quic.TokenStore - mu sync.Mutex - settings map[string][2]uint64 -} - -func newQUICResumption() *quicResumption { - return &quicResumption{sessions: utls.NewLRUClientSessionCache(0), tokens: quic.NewLRUTokenStore(100, 1), settings: map[string][2]uint64{}} -} - -// lookup 按 utls loadSession 的判定返回 host 会话恢复时 pre_shared_key 扩展的长度(0 表示不恢复),票据允许 0-RTT 且记得服务端设置时 settings 非 nil -func (resumption *quicResumption) lookup(host string) (int, *[2]uint64) { - session, _ := resumption.sessions.Get(host) - ticket, state, err := session.ResumptionState() - if err != nil || state == nil { - return 0, nil - } - raw, err := state.Bytes() - if err != nil { - return 0, nil - } - psk := resumptionPSKLength(raw, len(ticket)) - if psk == 0 { - return 0, nil - } - settings, ok := resumption.rememberedSettings(host) - if !state.EarlyData || !ok { - return psk, nil - } - return psk, &settings -} - -// rememberSettings 记录 host 服务端 SETTINGS 中的 QPACK 动态表容量与阻塞流上限 -func (resumption *quicResumption) rememberSettings(host string, capacity uint64, blocked uint64) { - resumption.mu.Lock() - defer resumption.mu.Unlock() - resumption.settings[host] = [2]uint64{capacity, blocked} -} - -// rememberedSettings 返回 host 上次连接记录的服务端 QPACK 设置 -func (resumption *quicResumption) rememberedSettings(host string) ([2]uint64, bool) { - resumption.mu.Lock() - defer resumption.mu.Unlock() - settings, ok := resumption.settings[host] - return settings, ok -} - -// dialFirefoxQUIC 以 Firefox 158 的 QUIC 首航直连 host:443,有会话票据时恢复会话,票据允许 0-RTT 时不等握手完成即返回并返回沿用的服务端设置 -func dialFirefoxQUIC(ctx context.Context, host string, resumption *quicResumption) (*quic.Conn, *[2]uint64, error) { - addresses, err := net.DefaultResolver.LookupNetIP(ctx, "ip", host) - if err != nil { - return nil, nil, err - } - if len(addresses) == 0 { - return nil, nil, fmt.Errorf("%s 没有可用地址", host) - } - address := addresses[0].Unmap() - network, datagram := "udp4", neqoIPv4Datagram - if address.Is6() { - network, datagram = "udp6", neqoIPv6Datagram - } - socket, err := net.ListenUDP(network, nil) - if err != nil { - return nil, nil, err - } - psk, settings := resumption.lookup(host) - transport := &quic.UTransport{Transport: &quic.Transport{Conn: socket}, QUICSpec: firefoxQUICSpec(datagram, psk, settings != nil)} - dial := transport.Dial - if settings != nil { - dial = transport.DialEarly - } - connection, err := dial(ctx, net.UDPAddrFromAddrPort(netip.AddrPortFrom(address, 443)), &utls.Config{ - ServerName: host, - NextProtos: []string{"h3"}, - MinVersion: utls.VersionTLS13, - ClientSessionCache: resumption.sessions, - OmitEmptyPsk: true, - }, firefoxQUICConfig(datagram, resumption.tokens)) - if err != nil { - _ = transport.Close() - _ = socket.Close() - return nil, nil, err - } - go func() { - <-connection.Context().Done() - _ = transport.Close() - _ = socket.Close() - }() - return connection, settings, nil -} - -// firefoxQUICConfig 返回 Firefox 158 的 QUIC 连接配置:空闲超时 30 秒,与 neqo 一样只在请求流尚未完成时每半个空闲超时发送保活 PING -func firefoxQUICConfig(datagram int, tokens quic.TokenStore) *quic.Config { - return &quic.Config{ - Versions: []quic.Version{quic.Version1}, - HandshakeIdleTimeout: firefoxQUICIdleTimeout, - MaxIdleTimeout: firefoxQUICIdleTimeout, - KeepAlivePeriod: firefoxQUICIdleTimeout / 2, - KeepAliveStreamsOnly: true, - InitialStreamReceiveWindow: firefoxQUICMaxStreamData, - MaxStreamReceiveWindow: firefoxQUICMaxStreamData, - InitialConnectionReceiveWindow: firefoxQUICMaxData, - MaxConnectionReceiveWindow: firefoxQUICMaxData, - MaxIncomingStreams: neqoMaxStreams, - MaxIncomingUniStreams: neqoMaxStreams, - InitialPacketSize: uint16(datagram), - DisablePathMTUDiscovery: true, - EnableStreamResetPartialDelivery: true, - TokenStore: tokens, - } -} - -// firefoxQUICSpec 返回 Firefox 158(neqo 0.31)一次直连的 QUIC 首航,psk 与 early 决定 ClientHello 是否带 pre_shared_key 与 early_data -func firefoxQUICSpec(datagram int, psk int, early bool) *quic.QUICSpec { - var random [3]byte - _, _ = rand.Read(random[:]) - destination := max(8, 5+int(random[0]&(random[0]>>4))) - firstPN := uint64(random[1]&0x1f) + uint64(max(int(random[2])-224, 0))<<5 + 1 - lengths := []quic.PacketNumberLen{neqoPacketNumberLength(firstPN + 1), neqoPacketNumberLength(firstPN + 2), quic.PacketNumberLen1} - return &quic.QUICSpec{ - InitialPacketSpec: quic.InitialPacketSpec{ - SrcConnIDLength: neqoSourceConnectionIDLength, - DestConnIDLength: destination, - InitPacketNumber: firstPN, - InitPacketNumberLengths: lengths, - FrameBuilder: &neqoInitialFlight{limit: datagram - quicAEADOverhead}, - }, - ClientHelloSpec: firefoxQUICClientHello(psk, early), - UDPDatagramMinSize: datagram, - } -} - -// neqoPacketNumberLength 是 neqo 在尚无确认时为包号 pn 选择的编码长度,即 pn 的非零字节数 -func neqoPacketNumberLength(unacked uint64) quic.PacketNumberLen { - switch { - case unacked < 1<<8: - return quic.PacketNumberLen1 - case unacked < 1<<16: - return quic.PacketNumberLen2 - case unacked < 1<<24: - return quic.PacketNumberLen3 - default: - return quic.PacketNumberLen4 - } -} - -// firefoxQUICClientHello 返回 Firefox 158 经 NSS 发出的 QUIC ClientHello,psk 为 pre_shared_key 扩展长度,非 0 时该扩展在最后 -func firefoxQUICClientHello(psk int, early bool) *utls.ClientHelloSpec { - extensions := []utls.TLSExtension{ - &utls.UtlsCompressCertExtension{Algorithms: []utls.CertCompressionAlgo{utls.CertCompressionZlib, utls.CertCompressionZstd, utls.CertCompressionBrotli}}, - &utls.ExtendedMasterSecretExtension{}, - &utls.KeyShareExtension{KeyShares: append(utls.ReuseHybridAndClassicalKeyShares(utls.KeyShare{Group: utls.X25519MLKEM768}, utls.KeyShare{Group: utls.X25519}), utls.KeyShare{Group: utls.CurveP256})}, - &utls.StatusRequestExtension{}, - &utls.ALPNExtension{AlpnProtocols: []string{"h3"}}, - &utls.PSKKeyExchangeModesExtension{Modes: []uint8{utls.PskModeDHE}}, - &utls.SupportedCurvesExtension{Curves: []utls.CurveID{utls.X25519MLKEM768, utls.X25519, utls.CurveP256, utls.CurveP384, utls.CurveP521}}, - &utls.RenegotiationInfoExtension{Renegotiation: utls.RenegotiateOnceAsClient}, - &utls.SupportedVersionsExtension{Versions: []uint16{utls.VersionTLS13}}, - &utls.FakeRecordSizeLimitExtension{Limit: 0x4001}, - &utls.FakeDelegatedCredentialsExtension{SupportedSignatureAlgorithms: []utls.SignatureScheme{ - utls.ECDSAWithP256AndSHA256, utls.ECDSAWithP384AndSHA384, utls.ECDSAWithP521AndSHA512, utls.ECDSAWithSHA1, - }}, - &utls.SNIExtension{}, - &utls.SignatureAlgorithmsExtension{SupportedSignatureAlgorithms: []utls.SignatureScheme{ - utls.ECDSAWithP256AndSHA256, utls.ECDSAWithP384AndSHA384, utls.ECDSAWithP521AndSHA512, utls.ECDSAWithSHA1, - utls.PSSWithSHA256, utls.PSSWithSHA384, utls.PSSWithSHA512, - utls.PKCS1WithSHA256, utls.PKCS1WithSHA384, utls.PKCS1WithSHA512, utls.PKCS1WithSHA1, - }}, - } - if early { - extensions = append(extensions, &utls.GenericExtension{Id: 42}) - } - mrand.Shuffle(len(extensions), func(i, j int) { extensions[i], extensions[j] = extensions[j], extensions[i] }) - extensions = append(extensions, - &utls.QUICTransportParametersExtension{TransportParameters: utls.TransportParameters{ - utls.MaxIdleTimeout(firefoxQUICIdleTimeout.Milliseconds()), - utls.InitialMaxData(firefoxQUICMaxData), - utls.InitialMaxStreamDataBidiLocal(firefoxQUICMaxStreamData), - utls.InitialMaxStreamDataBidiRemote(neqoStreamWindow), - utls.InitialMaxStreamDataUni(neqoStreamWindow), - utls.InitialMaxStreamsBidi(neqoMaxStreams), - utls.InitialMaxStreamsUni(neqoMaxStreams), - utls.MaxAckDelay(20), - utls.ActiveConnectionIDLimit(8), - utls.InitialSourceConnectionID(nil), - &utls.VersionInformation{ChoosenVersion: utls.VERSION_1, AvailableVersions: []uint32{utls.VERSION_GREASE, utls.VERSION_2, utls.VERSION_1}}, - &utls.FakeQUICTransportParameter{Id: neqoResetStreamAtParameter}, - &utls.FakeQUICTransportParameter{Id: neqoMinAckDelayParameter, Val: quicvarint.Append(nil, neqoMinAckDelay)}, - utls.MaxDatagramFrameSize(65535), - }}, - &utls.GREASEEncryptedClientHelloExtension{ - CandidateCipherSuites: []utls.HPKESymmetricCipherSuite{{KdfId: dicttls.HKDF_SHA256, AeadId: dicttls.AEAD_AES_128_GCM}, {KdfId: dicttls.HKDF_SHA256, AeadId: dicttls.AEAD_CHACHA20_POLY1305}}, - CandidatePayloadLens: []uint16{nssGREASEECHPayload(nssQUICGREASEECHInner, psk, early)}, - }, - ) - if psk > 0 { - extensions = append(extensions, &utls.UtlsPreSharedKeyExtension{}) - } - return &utls.ClientHelloSpec{ - TLSVersMin: utls.VersionTLS13, - TLSVersMax: utls.VersionTLS13, - CipherSuites: []uint16{utls.TLS_AES_128_GCM_SHA256, utls.TLS_CHACHA20_POLY1305_SHA256, utls.TLS_AES_256_GCM_SHA384}, - CompressionMethods: []uint8{0}, - Extensions: extensions, - } -} - -// resumptionPSKLength 返回以编码为 raw(utls SessionState.Bytes)的 TLS 1.3 客户端会话恢复时 pre_shared_key 扩展的长度,会话不是 TLS 1.3 或票据已过期时为 0 -func resumptionPSKLength(raw []byte, ticket int) int { - if binary.BigEndian.Uint16(raw) != utls.VersionTLS13 || time.Now().After(time.Unix(int64(binary.BigEndian.Uint64(raw[len(raw)-12:])), 0)) { - return 0 - } - binder := 32 - if binary.BigEndian.Uint16(raw[3:]) == utls.TLS_AES_256_GCM_SHA384 { - binder = 48 - } - return 2 + 2 + ticket + 4 + 2 + 1 + binder -} - -// nssGREASEECHPayload 是 NSS 按内层基础长度 inner 算出的 GREASE ECH 密文长度(不含 AEAD 标签),按 RFC 9849 补齐到 32 字节的整数倍 -func nssGREASEECHPayload(inner int, psk int, early bool) uint16 { - if psk > 0 { - inner += 4 + psk - } - if early { - inner += 2 - } - return uint16(inner + 31 - (inner-1)%32) -} - -// neqoInitialFlight 按 neqo 0.31 的 SNI 切分把 ClientHello 排进 Initial 包 -type neqoInitialFlight struct { - // limit 是一个 Initial 包去掉 AEAD 标签后的长度上限 - limit int -} - -// cryptoRange 是 CRYPTO 流中的一段 -type cryptoRange struct { - offset int - data []byte -} - -func (flight *neqoInitialFlight) Build(crypto []byte) ([]byte, error) { - payloads, err := flight.BuildFlight(crypto, []quic.InitialDatagramBudget{{MaxFrameBytes: flight.limit}}) - if err != nil { - return nil, err - } - return payloads[0], nil -} - -// BuildFlight 按 budgets 给出的各包帧空间排布 CRYPTO 帧,包数超出 budgets 时沿用最后一项 -func (flight *neqoInitialFlight) BuildFlight(crypto []byte, budgets []quic.InitialDatagramBudget) ([][]byte, error) { - room := func(index int) int { return budgets[min(index, len(budgets)-1)].MaxFrameBytes } - var payloads [][]byte - pending := []cryptoRange{{0, crypto}} - if start, end, ok := findClientHelloSNI(crypto); ok { - middle := start + (end-start)/2 - packets := (len(crypto) + flight.limit - 1) / flight.limit - left, right := neqoLimitChunks(cryptoRange{0, crypto[:middle]}, cryptoRange{middle, crypto[middle:]}, len(crypto)/packets) - remaining := room(0) - var payload []byte - sent := make([]cryptoRange, 0, 2) - for _, chunk := range []cryptoRange{right, left} { - var written int - var ok bool - if payload, written, ok = appendCryptoChunk(payload, chunk, remaining-len(payload)); ok { - sent = append(sent, cryptoRange{chunk.offset, chunk.data[:written]}) - } - } - if len(sent) == 0 { - return nil, fmt.Errorf("Initial 包放不下 CRYPTO 帧") - } - payloads = append(payloads, payload) - pending = subtractCryptoRanges(crypto, sent) - } - for len(pending) > 0 { - remaining := room(len(payloads)) - var payload []byte - for len(pending) > 0 { - chunk := pending[0] - var written int - var ok bool - if payload, written, ok = appendCryptoChunk(payload, chunk, remaining-len(payload)); !ok { - break - } - if written < len(chunk.data) { - pending[0] = cryptoRange{chunk.offset + written, chunk.data[written:]} - break - } - pending = pending[1:] - } - if payload == nil { - return nil, fmt.Errorf("Initial 包放不下 CRYPTO 帧") - } - payloads = append(payloads, payload) - } - return payloads, nil -} - -// neqoLimitChunks 是 neqo limit_chunks:把 SNI 两侧的片段截到 limit 以内,使 SNI 分落在不同包 -func neqoLimitChunks(left cryptoRange, right cryptoRange, limit int) (cryptoRange, cryptoRange) { - switch { - case len(left.data)+len(right.data) <= limit: - case len(left.data) <= limit: - skip := len(right.data) + len(left.data) - limit - right = cryptoRange{right.offset + skip, right.data[skip:]} - case len(right.data) <= limit: - left.data = left.data[:limit-len(right.data)] - default: - left.data = left.data[:limit/2] - right.data = right.data[:limit/2] - } - return left, right -} - -// appendCryptoChunk 是 neqo write_chunk:在 room 字节内写入尽量多的 chunk 并返回写入的数据长度,放不下帧头与 1 字节数据时返回 false -func appendCryptoChunk(payload []byte, chunk cryptoRange, room int) ([]byte, int, bool) { - header := 1 + quicvarint.Len(uint64(chunk.offset)) + 1 - if room < header+1 { - return payload, 0, false - } - length := min(len(chunk.data), room-header) - header += quicvarint.Len(uint64(length)) - 1 - length = min(len(chunk.data), room-header) - payload = append(payload, 0x06) - payload = quicvarint.Append(payload, uint64(chunk.offset)) - payload = quicvarint.Append(payload, uint64(length)) - return append(payload, chunk.data[:length]...), length, true -} - -// subtractCryptoRanges 返回 crypto 中未被 sent 覆盖的各段,按偏移排列 -func subtractCryptoRanges(crypto []byte, sent []cryptoRange) []cryptoRange { - covered := make([]bool, len(crypto)) - for _, chunk := range sent { - for i := range chunk.data { - covered[chunk.offset+i] = true - } - } - var pending []cryptoRange - for start := 0; start < len(crypto); { - if covered[start] { - start++ - continue - } - end := start - for end < len(crypto) && !covered[end] { - end++ - } - pending = append(pending, cryptoRange{start, crypto[start:end]}) - start = end - } - return pending -} - -// findClientHelloSNI 是 neqo find_sni:返回 ClientHello 中 SNI 主机名的字节区间 -func findClientHelloSNI(hello []byte) (int, int, bool) { - if len(hello) < 1+3+2+32+1 || hello[0] != 1 { - return 0, 0, false - } - offset := 1 + 3 + 2 + 32 - skip := func(width int) bool { - if offset+width > len(hello) { - return false - } - length := 0 - for _, b := range hello[offset : offset+width] { - length = length<<8 | int(b) - } - offset += width + length - return offset <= len(hello) - } - if !skip(1) || !skip(2) || !skip(1) { - return 0, 0, false - } - offset += 2 - for offset+4 <= len(hello) { - kind := binary.BigEndian.Uint16(hello[offset:]) - length := int(binary.BigEndian.Uint16(hello[offset+2:])) - offset += 4 - if kind == 0 { - if offset+2 > len(hello) { - return 0, 0, false - } - list := int(binary.BigEndian.Uint16(hello[offset:])) - if list < 3 { - return 0, 0, false - } - start := offset + 2 + 3 - end := start + list - 3 - if end > len(hello) { - return 0, 0, false - } - return start, end, true - } - offset += length - } - return 0, 0, false -} - -var _ quic.QUICFlightFrameBuilder = (*neqoInitialFlight)(nil) diff --git a/internal/aistudio/transport_quic_test.go b/internal/aistudio/transport_quic_test.go deleted file mode 100644 index fe22cd0c..00000000 --- a/internal/aistudio/transport_quic_test.go +++ /dev/null @@ -1,126 +0,0 @@ -package aistudio - -import ( - "bufio" - "context" - "io" - "net/http/httptest" - "strings" - "sync" - "sync/atomic" - "testing" - "time" - - fhttp "github.com/Mag1cFall/fhttp" - quic "github.com/Mag1cFall/uquic" - utls "github.com/Mag1cFall/utls" -) - -// TestHTTP3SlowResponse 验证上游超过空闲超时才返回响应头或响应体时,请求流未完成期间的保活使连接不断开,POST 只发一次 -func TestHTTP3SlowResponse(t *testing.T) { - for _, flushHeaders := range []bool{false, true} { - name := "headers" - if flushHeaders { - name = "body" - } - t.Run(name, func(t *testing.T) { - var requests atomic.Int32 - conn := newTestHTTP3Conn(t, func(stream *quic.Stream) { - requests.Add(1) - block := newQPACKEncoder().encode([]qpackField{{":status", "200"}}, int64(stream.StreamID())) - headers := appendH3Frame(nil, h3FrameHeaders, block) - if flushHeaders { - _, _ = stream.Write(headers) - } - time.Sleep(1500 * time.Millisecond) - if !flushHeaders { - _, _ = stream.Write(headers) - } - _, _ = stream.Write(appendH3Frame(nil, h3FrameData, []byte("ok"))) - _ = stream.Close() - }) - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - request, err := fhttp.NewRequestWithContext(ctx, "POST", "https://localhost/", strings.NewReader("test")) - if err != nil { - t.Fatal(err) - } - response, opened, err := conn.roundTrip(request, h3RequestFields(request, false)) - if err != nil || !opened { - t.Fatalf("等待慢响应失败: opened=%v err=%v", opened, err) - } - defer response.Body.Close() - body, err := io.ReadAll(response.Body) - if err != nil || string(body) != "ok" || response.StatusCode != 200 { - t.Fatalf("响应=%q 状态=%d err=%v", body, response.StatusCode, err) - } - if requests.Load() != 1 { - t.Fatalf("POST 执行了 %d 次,应为 1 次", requests.Load()) - } - }) - } -} - -// newTestHTTP3Conn 返回连到本地 QUIC 服务的 HTTP/3 连接,连接使用生产 QUIC 配置并把空闲超时改为 500 ms,handler 处理正文为 test 的请求流 -func newTestHTTP3Conn(t *testing.T, handler func(*quic.Stream)) *http3Conn { - t.Helper() - certServer := httptest.NewTLSServer(nil) - t.Cleanup(certServer.Close) - cert := certServer.TLS.Certificates[0] - tlsConfig := &utls.Config{ - Certificates: []utls.Certificate{{Certificate: cert.Certificate, PrivateKey: cert.PrivateKey}}, - NextProtos: []string{"h3"}, - } - listener, err := quic.ListenAddr("127.0.0.1:0", tlsConfig, &quic.Config{MaxIdleTimeout: 500 * time.Millisecond}) - if err != nil { - t.Fatal(err) - } - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) - t.Cleanup(cancel) - done := make(chan struct{}) - go func() { - defer close(done) - connection, err := listener.Accept(ctx) - if err != nil { - return - } - defer connection.CloseWithError(0, "") - var handlers sync.WaitGroup - defer handlers.Wait() - for { - stream, err := connection.AcceptStream(ctx) - if err != nil { - return - } - handlers.Add(1) - go func() { - defer handlers.Done() - reader := bufio.NewReader(stream) - if kind, _, err := readH3Frame(reader); err != nil || kind != h3FrameHeaders { - return - } - if kind, body, err := readH3Frame(reader); err == nil && kind == h3FrameData && string(body) == "test" { - handler(stream) - } - }() - } - }() - t.Cleanup(func() { - cancel() - _ = listener.Close() - <-done - }) - config := firefoxQUICConfig(neqoIPv4Datagram, nil) - config.MaxIdleTimeout = 500 * time.Millisecond - connection, err := quic.DialAddr(ctx, listener.Addr().String(), &utls.Config{InsecureSkipVerify: true, NextProtos: []string{"h3"}}, config) - if err != nil { - t.Fatal(err) - } - t.Cleanup(func() { _ = connection.CloseWithError(0, "") }) - conn, err := newHTTP3Conn(connection, nil, func(uint64, uint64) {}) - if err != nil { - t.Fatal(err) - } - t.Cleanup(conn.close) - return conn -} diff --git a/internal/i18n/messages/de.json b/internal/i18n/messages/de.json index 84ef3dbe..291efc4a 100644 --- a/internal/i18n/messages/de.json +++ b/internal/i18n/messages/de.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0} muss eine positive Zeitspanne sein, z. B. 30s oder 5m", "%s 必须是正整数": "{0} muss eine positive Ganzzahl sein", "%s 未协商 HTTP/2,实际协议为 %q": "{0} hat HTTP/2 nicht ausgehandelt, tatsächliches Protokoll ist {1}", - "%s 没有可用地址": "{0} hat keine verfügbaren Adressen", "%s 状态为 %s": "Status von {0} ist {1}", "%s 的 token_service 没有 %s 的记录": "token_service von {0} hat keinen Eintrag für {1}", "%s 的 token_service 缺少认证材料": "token_service von {0} fehlen Authentifizierungsdaten", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Google AI Pro- oder Ultra-Abo", "Google AI Ultra 订阅": "Google AI Ultra-Abo", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Google-Mehrkonten-Sitzungsindex (0..9, entspricht /u/0, /u/1...)", - "HTTP/3 响应体已关闭": "HTTP/3-Antworttext ist bereits geschlossen", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "HTTP/3-Antwort empfing DATA vor HEADERS", - "HTTP/3 响应状态 %d 无效": "HTTP/3-Antwortstatus {0} ist ungültig", - "HTTP/3 帧长度 %d 超出上限": "HTTP/3-Framelänge {0} überschreitet das Limit", - "HTTP/3 控制流首帧不是 SETTINGS": "Erster Frame im HTTP/3-Steuerstream ist nicht SETTINGS", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT muss eine positive Zeitdauer sein", "INIT_TIMEOUT 无效: %w": "INIT_TIMEOUT ist ungültig: {0}", - "Initial 包放不下 CRYPTO 帧": "Initial-Paket kann den CRYPTO-Frame nicht aufnehmen", "Interaction 模型不接受 %s 消息": "Interaction-Modell akzeptiert keine {0}-Nachrichten", "Interaction 模型的 %w": "{0} des Interaction-Modells", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "contents[{0}] des Interaction-Modells akzeptiert kein Video-Clipping, Sampling, Verarbeitungsverfahren oder Verarbeitungsschritte", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "PROXY-Authentifizierung enthält keinen Benutzernamen", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent verwendet serverseitiges Streaming und antwortet nach Abschluss der Erfassung", "Playwright storage state 文件": "Playwright-storage-state-Datei", - "QPACK 数据无效": "Ungültige QPACK-Daten", - "QPACK 阻塞流超过 %d": "Blockierte QPACK-Streams überschreiten {0}", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT muss eine positive Dauer sein", "REQUEST_TIMEOUT 无效: %w": "REQUEST_TIMEOUT ist ungültig: {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY muss round-robin oder fill-first sein", diff --git a/internal/i18n/messages/en.json b/internal/i18n/messages/en.json index 79289080..75739fb2 100644 --- a/internal/i18n/messages/en.json +++ b/internal/i18n/messages/en.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0} must be a positive duration, such as 30s or 5m", "%s 必须是正整数": "{0} must be a positive integer", "%s 未协商 HTTP/2,实际协议为 %q": "{0} did not negotiate HTTP/2, actual protocol was {1}", - "%s 没有可用地址": "{0} has no available addresses", "%s 状态为 %s": "{0} status is {1}", "%s 的 token_service 没有 %s 的记录": "{0} token_service has no record for {1}", "%s 的 token_service 缺少认证材料": "{0} token_service is missing credentials", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Google AI Pro or Ultra subscription", "Google AI Ultra 订阅": "Google AI Ultra subscription", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Google multi-account session index (0..9, for /u/0, /u/1...)", - "HTTP/3 响应体已关闭": "HTTP/3 response body already closed", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "HTTP/3 response received DATA before HEADERS", - "HTTP/3 响应状态 %d 无效": "Invalid HTTP/3 response status {0}", - "HTTP/3 帧长度 %d 超出上限": "HTTP/3 frame length {0} exceeds limit", - "HTTP/3 控制流首帧不是 SETTINGS": "First frame of HTTP/3 control stream is not SETTINGS", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT must be a positive duration", "INIT_TIMEOUT 无效: %w": "Invalid INIT_TIMEOUT: {0}", - "Initial 包放不下 CRYPTO 帧": "Initial packet cannot fit CRYPTO frame", "Interaction 模型不接受 %s 消息": "Interaction models do not accept {0} messages", "Interaction 模型的 %w": "{0} of Interaction model", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "Interaction model contents[{0}] does not accept video clipping, sampling, processing mode, or processing steps", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "PROXY credentials missing username", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent uses server-side streaming, returning after collection is complete", "Playwright storage state 文件": "Playwright storage state file", - "QPACK 数据无效": "Invalid QPACK data", - "QPACK 阻塞流超过 %d": "QPACK blocked streams exceeded {0}", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT must be a positive duration", "REQUEST_TIMEOUT 无效: %w": "Invalid REQUEST_TIMEOUT: {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY must be round-robin or fill-first", diff --git a/internal/i18n/messages/fr.json b/internal/i18n/messages/fr.json index 7f732e8f..1ebfbd1a 100644 --- a/internal/i18n/messages/fr.json +++ b/internal/i18n/messages/fr.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0} doit être une durée positive, par exemple 30s ou 5m", "%s 必须是正整数": "{0} doit être un entier positif", "%s 未协商 HTTP/2,实际协议为 %q": "{0} n’a pas négocié HTTP/2, protocole effectif : {1}", - "%s 没有可用地址": "{0} n’a aucune adresse disponible", "%s 状态为 %s": "État de {0} : {1}", "%s 的 token_service 没有 %s 的记录": "Le token_service de {0} n’a aucun enregistrement pour {1}", "%s 的 token_service 缺少认证材料": "Le token_service de {0} manque d’éléments d’authentification", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Abonnement Google AI Pro ou Ultra", "Google AI Ultra 订阅": "Abonnement Google AI Ultra", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Index de session Google multi-comptes (0..9, correspond à /u/0, /u/1...)", - "HTTP/3 响应体已关闭": "Le corps de réponse HTTP/3 est fermé", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "Réponse HTTP/3 : DATA reçu avant HEADERS", - "HTTP/3 响应状态 %d 无效": "Code d’état de réponse HTTP/3 {0} non valide", - "HTTP/3 帧长度 %d 超出上限": "Longueur de trame HTTP/3 {0} supérieure à la limite", - "HTTP/3 控制流首帧不是 SETTINGS": "La première trame du flux de contrôle HTTP/3 n’est pas SETTINGS", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT doit être une durée positive", "INIT_TIMEOUT 无效: %w": "INIT_TIMEOUT non valide : {0}", - "Initial 包放不下 CRYPTO 帧": "Le paquet Initial ne peut pas contenir la trame CRYPTO", "Interaction 模型不接受 %s 消息": "Les modèles Interaction n’acceptent pas les messages {0}", "Interaction 模型的 %w": "{0} du modèle Interaction", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "contents[{0}] du modèle Interaction n’accepte pas le découpage vidéo, l’échantillonnage, le mode de traitement ni les étapes de traitement", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "Nom d'utilisateur manquant dans les identifiants PROXY", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent utilise un flux côté serveur et retourne après collecte", "Playwright storage state 文件": "Fichier storage state de Playwright", - "QPACK 数据无效": "Données QPACK non valides", - "QPACK 阻塞流超过 %d": "Flux bloqués QPACK dépassant {0}", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT doit être une durée positive", "REQUEST_TIMEOUT 无效: %w": "REQUEST_TIMEOUT non valide : {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY doit être round-robin ou fill-first", diff --git a/internal/i18n/messages/ja.json b/internal/i18n/messages/ja.json index 53aeed18..05a68ca3 100644 --- a/internal/i18n/messages/ja.json +++ b/internal/i18n/messages/ja.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0} は 30s や 5m などの正の期間である必要があります", "%s 必须是正整数": "{0} は正の整数である必要があります", "%s 未协商 HTTP/2,实际协议为 %q": "{0} で HTTP/2 がネゴシエートされませんでした。実際のプロトコル: {1}", - "%s 没有可用地址": "{0} に利用可能なアドレスがありません", "%s 状态为 %s": "{0} の状態は {1}", "%s 的 token_service 没有 %s 的记录": "{0} の token_service に {1} のレコードがありません", "%s 的 token_service 缺少认证材料": "{0} の token_service に認証情報がありません", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Google AI Pro または Ultra サブスクリプション", "Google AI Ultra 订阅": "Google AI Ultra サブスクリプション", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Google マルチアカウントのセッション番号 (0..9、/u/0、/u/1... に対応)", - "HTTP/3 响应体已关闭": "HTTP/3 レスポンス本文はすでに閉じられています", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "HTTP/3 レスポンスで HEADERS の前に DATA を受信しました", - "HTTP/3 响应状态 %d 无效": "HTTP/3 レスポンスステータス {0} は無効です", - "HTTP/3 帧长度 %d 超出上限": "HTTP/3 フレーム長 {0} が上限を超えています", - "HTTP/3 控制流首帧不是 SETTINGS": "HTTP/3 コントロールストリームの先頭フレームが SETTINGS ではありません", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT は正の期間である必要があります", "INIT_TIMEOUT 无效: %w": "INIT_TIMEOUT が無効です: {0}", - "Initial 包放不下 CRYPTO 帧": "Initial パケットに CRYPTO フレームが収まりません", "Interaction 模型不接受 %s 消息": "Interaction モデルは {0} メッセージを受け付けません", "Interaction 模型的 %w": "Interaction モデルの {0}", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "Interaction モデルの contents[{0}] では、動画の切り出し、サンプリング、処理方法、処理手順を受け付けません", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "PROXY 認証情報にユーザー名がありません", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent はサーバー ストリームを使用し、収集完了後に返します", "Playwright storage state 文件": "Playwright storage state ファイル", - "QPACK 数据无效": "QPACK データが無効です", - "QPACK 阻塞流超过 %d": "QPACK ブロックされたストリームが {0} を超えました", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT は正の時間である必要があります", "REQUEST_TIMEOUT 无效: %w": "REQUEST_TIMEOUT が無効です: {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY は round-robin または fill-first である必要があります", diff --git a/internal/i18n/messages/ko.json b/internal/i18n/messages/ko.json index 89968889..79c059e5 100644 --- a/internal/i18n/messages/ko.json +++ b/internal/i18n/messages/ko.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0}은(는) 30s 또는 5m 같은 양수 기간이어야 합니다", "%s 必须是正整数": "{0}은(는) 양의 정수여야 합니다", "%s 未协商 HTTP/2,实际协议为 %q": "{0}에서 HTTP/2가 협상되지 않음, 실제 프로토콜: {1}", - "%s 没有可用地址": "{0}에 사용 가능한 주소가 없습니다", "%s 状态为 %s": "{0} 상태: {1}", "%s 的 token_service 没有 %s 的记录": "{0}의 token_service에 {1} 레코드가 없습니다", "%s 的 token_service 缺少认证材料": "{0}의 token_service에 인증 정보가 없습니다", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Google AI Pro 또는 Ultra 구독", "Google AI Ultra 订阅": "Google AI Ultra 구독", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Google 다중 계정 세션 번호 (0..9, /u/0, /u/1... 에 해당)", - "HTTP/3 响应体已关闭": "HTTP/3 응답 본문이 닫혔습니다", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "HTTP/3 응답에서 HEADERS 전에 DATA를 수신했습니다", - "HTTP/3 响应状态 %d 无效": "HTTP/3 응답 상태 {0}이(가) 유효하지 않습니다", - "HTTP/3 帧长度 %d 超出上限": "HTTP/3 프레임 길이 {0}이(가) 한도를 초과했습니다", - "HTTP/3 控制流首帧不是 SETTINGS": "HTTP/3 제어 스트림의 첫 번째 프레임이 SETTINGS가 아닙니다", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT은(는) 양수 시간이어야 합니다", "INIT_TIMEOUT 无效: %w": "INIT_TIMEOUT이 유효하지 않습니다: {0}", - "Initial 包放不下 CRYPTO 帧": "Initial 패킷에 CRYPTO 프레임을 담을 수 없습니다", "Interaction 模型不接受 %s 消息": "Interaction 모델은 {0} 메시지를 허용하지 않습니다", "Interaction 模型的 %w": "Interaction 모델의 {0}", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "Interaction 모델의 contents[{0}]에는 동영상 클립, 샘플링, 처리 방법 및 처리 단계를 지정할 수 없습니다", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "PROXY 인증 정보에 사용자 이름이 없습니다", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent가 서버 스트림을 사용하며, 수집 완료 후 반환합니다", "Playwright storage state 文件": "Playwright storage state 파일", - "QPACK 数据无效": "QPACK 데이터가 잘못되었습니다", - "QPACK 阻塞流超过 %d": "QPACK 차단 스트림이 {0}을(를) 초과했습니다", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT은 양수 시간이어야 합니다", "REQUEST_TIMEOUT 无效: %w": "REQUEST_TIMEOUT이 잘못되었습니다: {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY는 round-robin 또는 fill-first여야 합니다", diff --git a/internal/i18n/messages/zh-TW.json b/internal/i18n/messages/zh-TW.json index bd7d4da6..e4e3a096 100644 --- a/internal/i18n/messages/zh-TW.json +++ b/internal/i18n/messages/zh-TW.json @@ -7,7 +7,6 @@ "%s 必须是正数时长,例如 30s 或 5m": "{0} 必須是正數時長,例如 30s 或 5m", "%s 必须是正整数": "{0} 必須是正整數", "%s 未协商 HTTP/2,实际协议为 %q": "{0} 未協商 HTTP/2,實際協定為 {1}", - "%s 没有可用地址": "{0} 沒有可用位址", "%s 状态为 %s": "{0} 狀態為 {1}", "%s 的 token_service 没有 %s 的记录": "{0} 的 token_service 沒有 {1} 的記錄", "%s 的 token_service 缺少认证材料": "{0} 的 token_service 缺少認證資料", @@ -247,14 +246,8 @@ "Google AI Pro 或 Ultra 订阅": "Google AI Pro 或 Ultra 訂閱", "Google AI Ultra 订阅": "Google AI Ultra 訂閱", "Google 多账号会话序号 (0..9,对应 /u/0、/u/1...)": "Google 多帳號工作階段序號 (0..9,對應 /u/0、/u/1...)", - "HTTP/3 响应体已关闭": "HTTP/3 回應主體已關閉", - "HTTP/3 响应在 HEADERS 之前收到 DATA": "HTTP/3 回應在 HEADERS 之前收到 DATA", - "HTTP/3 响应状态 %d 无效": "HTTP/3 回應狀態 {0} 無效", - "HTTP/3 帧长度 %d 超出上限": "HTTP/3 訊框長度 {0} 超出上限", - "HTTP/3 控制流首帧不是 SETTINGS": "HTTP/3 控制串流首個訊框不是 SETTINGS", "INIT_TIMEOUT 必须是正数时长": "INIT_TIMEOUT 必須是正數時間長度", "INIT_TIMEOUT 无效: %w": "INIT_TIMEOUT 無效: {0}", - "Initial 包放不下 CRYPTO 帧": "Initial 封包放不下 CRYPTO 訊框", "Interaction 模型不接受 %s 消息": "Interaction 模型不接受 {0} 訊息", "Interaction 模型的 %w": "Interaction 模型的 {0}", "Interaction 模型的 contents[%d] 不接受视频截取、采样、处理方式与处理步骤": "Interaction 模型的 contents[{0}] 不接受影片擷取、取樣、處理方式與處理步驟", @@ -296,8 +289,6 @@ "PROXY 认证信息缺少用户名": "PROXY 驗證資訊缺少使用者名稱", "Playground GenerateContent 使用服务端流,收集完成后返回": "Playground GenerateContent 使用伺服端串流,收集完成後傳回", "Playwright storage state 文件": "Playwright storage state 檔案", - "QPACK 数据无效": "QPACK 資料無效", - "QPACK 阻塞流超过 %d": "QPACK 阻塞串流超過 {0}", "REQUEST_TIMEOUT 必须是正数时长": "REQUEST_TIMEOUT 必須是正數時長", "REQUEST_TIMEOUT 无效: %w": "REQUEST_TIMEOUT 無效: {0}", "ROUTING_STRATEGY 必须是 round-robin 或 fill-first": "ROUTING_STRATEGY 必須是 round-robin 或 fill-first",