使用 UTLS 和 HTTP 1.1 请求时通过代理连接

Question

我正在尝试使用随机 TLS 指纹连接到主机。 我正在使用https://github.com/refraction-networking/utls （请参阅我在https://github.com/refraction-networking/utls/issues/42 上创建的问题）

我现在的问题是，如何在打开该连接时使用 HTTP 或 SOCKS5 代理？

我现在使用的代码是：

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "net/http"
    "net/http/httputil"
    "net/url"
    "time"

    "github.com/refraction-networking/utls"
)


var (
    dialTimeout   = time.Duration(15) * time.Second
)

var requestHostname = "google.com"
var requestAddr = "172.217.22.110:443"


// this example generates a randomized fingeprint, then re-uses it in a follow-up connection
func HttpGetConsistentRandomized(hostname string, addr , uri string) (*http.Response, error) {
    config := tls.Config{ServerName: hostname}
    tcpConn, err := net.DialTimeout("tcp", addr, dialTimeout)
    if err != nil {
        return nil, fmt.Errorf("net.DialTimeout error: %+v", err)
    }
    uTlsConn := tls.UClient(tcpConn, &config, tls.HelloRandomized)
    defer uTlsConn.Close()
    err = uTlsConn.Handshake()
    if err != nil {
        return nil, fmt.Errorf("uTlsConn.Handshake() error: %+v", err)
    }
    uTlsConn.Close()

    // At this point uTlsConn.ClientHelloID holds a seed that was used to generate
    // randomized fingerprint. Now we can establish second connection with same fp
    tcpConn2, err := net.DialTimeout("tcp", addr, dialTimeout)
    if err != nil {
        return nil, fmt.Errorf("net.DialTimeout error: %+v", err)
    }
    uTlsConn2 := tls.UClient(tcpConn2, &config, uTlsConn.ClientHelloID)
    defer uTlsConn2.Close()
    err = uTlsConn2.Handshake()
    if err != nil {
        return nil, fmt.Errorf("uTlsConn.Handshake() error: %+v", err)
    }

    return httpGetOverConn(uTlsConn2, uTlsConn2.HandshakeState.ServerHello.AlpnProtocol, uri)
}

func main() {
    var response *http.Response
    var err error

    response, err = HttpGetConsistentRandomized(requestHostname, requestAddr, "/2.0/ssocookie")
    if err != nil {
        fmt.Printf("#> HttpGetConsistentRandomized() failed: %+v\n", err)
    } else {
        //fmt.Printf("#> HttpGetConsistentRandomized() response: %+s\n", httputil.DumpResponse(response,true))
        dump, err := httputil.DumpResponse(response, true)
        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf("%+s\n", dump)
    }
    return
}

func httpGetOverConn(conn net.Conn, alpn string, uri string) (*http.Response, error) {

    req := &http.Request{
        Method: "GET",
        URL:    &url.URL{Host: "www." + requestHostname  + uri},
        Header: make(http.Header),
        Host:   "www." + requestHostname,
    }

        req.Proto = "HTTP/1.1"
        req.ProtoMajor = 1
        req.ProtoMinor = 1

        err := req.Write(conn)
        if err != nil {
            return nil, err
        }
        return http.ReadResponse(bufio.NewReader(conn), req)
}

Answer 1

正如 Steffen 所说，你必须先创建一个代理拨号器，拨号代理创建一个 net.Conn，然后在创建 uTLS 客户端时使用该 net.Conn，然后再握手。 为简洁起见，您的自定义 dialTLS 函数如下所示：

import (
    "crypto/tls"
    "net"
    "net/url"    

    "github.com/magisterquis/connectproxy"
    "golang.org/x/net/proxy"
    utls "github.com/refraction-networking/utls"
)

var proxyString = "http://127.0.0.1:8080"
                                                                          
dialTLS := func(network, addr string, _ *tls.Config) (net.Conn, error) {
    proxyURI, _ := url.Parse(proxyString)

    switch proxyURI.Scheme {                                                       
    case "socks5":                                                                 
            proxyDialer, err = proxy.SOCKS5("tcp", proxyString, nil, proxy.Direct)
    case "http":                                                          
            proxyDialer, err = connectproxy.New(proxyURI, proxy.Direct)            
    }   

    conn, err := proxyDialer.Dial("tcp", addr)
    uconn := utls.UClient(conn, cfg, &utls.HelloRandomizedALPN) 

    ...
} 

两个建议：

1. 如果您打算通过 HTTP CONNECT 代理进行隧道传输，请使用上面引用的“connectproxy”模块。
2. 让自己的生活更轻松，看看 Tor 的Meek 可插拔传输源。 有一个“utls.go”模块可以为您处理所有事情，包括根据协商的 ALPN 协议设置 http 或 http2 传输。 它仅支持 SOCKS，但您可以轻松调整它以处理 HTTP 代理。

Answer 2

HTTP 代理和 SOCKS 代理在 TCP 连接后进行一些初始代理特定的握手。 握手完成后，它们提供一个普通的 TCP 套接字，然后可用于进行 TLS 握手等。因此，您只需要替换您的

tcpConn, err := net.DialTimeout("tcp", addr, dialTimeout)

使用代理特定的方法来设置 TCP 连接。 这可以通过在x/net/proxy使用SOCKS5创建适当的 Dialer 或使用 HTTP CONNECT 方法在connectproxy 中完成的类似方法来完成。