CONNECT 方法打开一条裸隧道

Mon, 13 Dec 2027 00:00:00 +0000

CONNECT 请求代理建立隧道，并不让代理从数据路径上消失。准入成功之后，代理仍然向两个方向转发字节，并管理套接字、缓冲区和故障处理。CONNECT 本身不提供加密；HTTPS 是在这条隧道内部另行建立并验证 TLS 会话，不能把两个阶段的成功混为一谈。

在正确的边界切换语义

HTTP/1.1 的 CONNECT 目标是 server.example:443 这样的主机与端口组合，而不是普通路径或完整 HTTPS URL。端口必须明确给出。成功的 2xx 响应在响应头结束后立即切换到隧道模式；非成功响应则表示隧道尚未建立，此时不能直接开始把后续内容当作目标服务的数据。

成功的 CONNECT 响应不能携带 Content-Length 或 Transfer-Encoding。随后出现的字节属于隧道，而不是一份用长度界定的 HTTP 响应正文。自己实现中继时，这一点尤其重要：HTTP 解析器已经缓冲的字节也可能属于隧道，不能因为切换到原始套接字，就把此前预读的数据丢掉。

客户端随后可以穿过中继，与目标协商 TLS。代理返回 200 只说明允许并建立了隧道，不负责证明目标证书有效，也不证明应用请求成功。客户端仍须检查信任链、主机名与应用响应。TLS 拦截属于另一种部署方式，需要客户端信任会终止 TLS 的中间实体，不能把它与普通盲转发混为同一种安全模型。

看不见正文，仍然占用资源

盲中继不必解释加密的应用内容，但仍能观察目标地址、字节量、时序和关闭行为。它可以落实连接预算、超时、流量限制，以及撤销准入之后的断开操作。无法读取 TLS 内部的 HTTP 消息，不等于失去所有运营控制，更不等于不再承担带宽和描述符成本。

真正的正向代理应验证调用方身份，并限制目的地。任意主机和端口访问，可能暴露内部服务，或被用于其他协议的滥用。按主机名放行时，还必须考虑地址解析策略：通过名称检查，并不自动证明最终拨号的 IP 地址符合约束。本地实验只允许一个预先确定的环回地址与端口，因此没有引入任意目标的解析和转发能力。

坏掉的样子

代理可能在上游尚未连通时就返回 200，可能丢弃解析器缓冲的字节，也可能在待转发数据尚未送出时，过早关闭另一个方向。这些错误看起来可能像证书配置正确却仍然失败的 TLS 握手。排障时，应分别记录准入失败、隧道传输失败、TLS 身份验证失败和源站 HTTP 失败。

Go 的 HTTP/1.1 连接一旦被 Hijack，生命周期就交给处理函数负责，普通 HTTP 服务端不会再管理它。请求上下文也不能代替隧道清理，需要显式管理两个复制方向和截止时间。普通服务端停机不会自动关闭已经接管的连接，生产停机需要记录这些连接，并显式排空或关闭，避免遗漏长连接。固定的绝对期限限制的是连接总寿命，并不是每收到一批流量就自动续期的空闲超时；两者不能使用同一个解释。

快速验证

保存为 connect_probe.go，使用 Go 1.23 或更新版本运行 go run connect_probe.go。实验建立环回 HTTP/1.1 代理和 TLS 1.3 源站，只允许源站的精确主机端口组合。客户端信任这台测试服务的证书，不关闭证书验证，也不修改系统信任库。

package main

import (
 "context"
 "crypto/tls"
 "crypto/x509"
 "errors"
 "fmt"
 "io"
 "log"
 "net"
 "net/http"
 "net/http/httptest"
 "net/url"
 "runtime"
 "sync/atomic"
 "time"
)

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func main() {
 var handled, admitted, denied, connectStatus atomic.Int64
 origin := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 check(r.TLS != nil && r.TLS.Version == tls.VersionTLS13, "origin requires TLS 1.3")
 fmt.Fprint(w, "through the tunnel")
 }))
 origin.Config.ErrorLog = log.New(io.Discard, "", 0) // Expected wrong-name handshake failure.
 origin.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 origin.StartTLS()
 defer origin.Close()
 target, err := url.Parse(origin.URL)
 must(err)
 relayed := make(chan [2]int64, 3)
 proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 if r.Method != http.MethodConnect {
 http.Error(w, "CONNECT required", http.StatusMethodNotAllowed)
 return
 }
 if r.Host != target.Host || r.URL.Host != target.Host {
 denied.Add(1)
 http.Error(w, "target denied", http.StatusForbidden)
 return
 }
 upstream, err := net.DialTimeout("tcp", target.Host, time.Second)
 must(err)
 defer upstream.Close()
 downstream, buffered, err := w.(http.Hijacker).Hijack()
 must(err)
 defer downstream.Close()
 admitted.Add(1)
 deadline := time.Now().Add(3 * time.Second)
 must(upstream.SetDeadline(deadline))
 must(downstream.SetDeadline(deadline))
 _, err = buffered.WriteString("HTTP/1.1 200 Connection Established\r\n\r\n")
 must(err)
 must(buffered.Flush())
 upDone := make(chan int64, 1)
 go func() {
 count, _ := io.Copy(upstream, buffered) // Preserve already-buffered tunnel bytes.
 _ = upstream.(*net.TCPConn).CloseWrite()
 upDone <- count
 }()
 count, _ := io.Copy(downstream, upstream)
 _ = downstream.(*net.TCPConn).CloseWrite()
 relayed <- [2]int64{<-upDone, count}
 }))
 defer proxy.Close()
 proxyURL, err := url.Parse(proxy.URL)
 must(err)
 config := origin.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{
 Proxy: http.ProxyURL(proxyURL), TLSClientConfig: config, DisableKeepAlives: true,
 OnProxyConnectResponse: func(_ context.Context, _ *url.URL, _ *http.Request, response *http.Response) error {
 connectStatus.Store(int64(response.StatusCode))
 if response.StatusCode == 200 {
 check(response.Header.Get("Content-Length") == "" && response.Header.Get("Transfer-Encoding") == "", "successful CONNECT must not frame a body")
 }
 return nil
 },
 }
 defer transport.CloseIdleConnections()
 get := func(tr *http.Transport, address string) (*http.Response, error) {
 return (&http.Client{Transport: tr, Timeout: 2 * time.Second}).Get(address)
 }
 success := func(label string) {
 response, err := get(transport, origin.URL)
 must(err)
 body, readError := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(readError)
 must(closeError)
 check(response.StatusCode == 200 && string(body) == "through the tunnel", "wrong origin response")
 check(connectStatus.Load() == 200 && len(response.TLS.VerifiedChains) > 0, "CONNECT and verified TLS required")
 fmt.Println(label, "CONNECT=200; verified origin response")
 }
 success("allowed")
 response, err := get(transport, "https://denied.invalid:443/")
 check(err != nil && response == nil && connectStatus.Load() == 403, "proxy must reject the target")
 check(denied.Load() == 1 && admitted.Load() == 1 && handled.Load() == 1, "denial must not open an upstream tunnel")
 fmt.Println("denied CONNECT=403; no upstream admission")

 wrong := transport.Clone()
 wrong.TLSClientConfig = config.Clone()
 wrong.TLSClientConfig.ServerName = "wrong.invalid"
 defer wrong.CloseIdleConnections()
 response, err = get(wrong, origin.URL)
 var hostnameError x509.HostnameError
 check(response == nil && errors.As(err, &hostnameError) && connectStatus.Load() == 200, "client must verify the tunneled TLS identity")
 check(handled.Load() == 1, "wrong-name TLS must not reach the HTTP handler")
 fmt.Println("wrong name CONNECT=200; TLS rejected before origin HTTP")
 success("recovery")
 check(handled.Load() == 2 && admitted.Load() == 3, "wrong final origin/tunnel counts")
 for index := 0; index < 3; index++ {
 select {
 case counts := <-relayed:
 check(counts[0] > 0 && counts[1] > 0, "proxy must relay bytes in both directions")
 case <-time.After(4 * time.Second):
 panic("relay did not finish")
 }
 }
 fmt.Println("three completed relays; two successful origin HTTP requests")
 fmt.Println(runtime.Version())
}

第一次请求记录 CONNECT 200，并读到完整的源站正文。denied.invalid 目标得到 CONNECT 403，没有新增上游准入；实验不会解析这个名称。第三次尝试虽然得到 CONNECT 200，却在证书主机名验证阶段失败，源站 HTTP 处理次数不变。最后用正确配置再次请求，恢复成功。

三条获准隧道都向两个方向转发了字节，但只有两次源站 HTTP 请求完成。DisableKeepAlives 防止其他连接复用掩盖新的 CONNECT 交换；代理响应回调检查实际准入状态，并核对成功响应不含正文分帧字段。程序等待两个方向的复制结束，并显式关闭自行接管的套接字。

作者记录的 macOS、Go 1.27.0 运行通过了全部断言；本轮审阅没有重跑该网络实验，不能把历史记录当成本轮执行证据。请求限时两秒，拨号限时一秒，隧道套接字设置三秒绝对期限。这是隔离的协议实验，不是可以直接部署的公共代理。它没有测试调用方认证、DNS 策略、TLS 拦截、提前注入的缓冲数据、流量整形、持续负载或 HTTP/2、HTTP/3 的 CONNECT 映射，不能据此宣称具备这些生产能力。

来源

RFC 9110：HTTP 语义，CONNECT 准入、目标形式、中继职责和目的地约束，已核验 2026-09-09。
RFC 9112：HTTP/1.1，消息分帧与 CONNECT 隧道切换边界，已核验 2026-09-09。
Go net/http，代理响应观察与接管连接的生命周期，已核验 2026-09-09。
Go net，连接截止时间与 TCP 半关闭，已核验 2026-09-09。
Go crypto/tls，证书验证和 TLS 连接状态，已核验 2026-09-09。

CONNECT · XB 现场笔记

CONNECT 方法打开一条裸隧道

在正确的边界切换语义

看不见正文，仍然占用资源

坏掉的样子

快速验证

延伸阅读

来源