是否可以通过 websockets 或其他协议传输 TCP 连接？

Question

我想知道，是否可以通过 websockets 协议传输/隧道 TCP 连接？

有一个websockets 包，似乎我可以将 TCP 连接 io.copy 复制到 websockets 连接中，但我不知道如何在另一端将其重新组装为 TCPConn。

例如，我想在一端创建一个 socks5 ServerN（在 NAT 后面），在另一端创建一个 ServerIE。互联网用户会向 ServerIE 发出socks5 请求（通过socks5 协议），ServerIE 会通过websocket 连接将socks5 请求发送到ServerNAT。ServerNAT 然后将处理socks5 请求（即它是socks5 服务器）。

编辑： 我写了一些代码，但不幸的是它在从 TCP 连接读取到 WS 时卡住了。运行它：go run main.go -logtostderr

package main

import (
    "flag"

    log "github.com/golang/glog"
    "golang.org/x/net/websocket"
    "bufio"
    "net"
    "net/http"
    "time"
//  "io"
)

func main() {
    flag.Parse()
    defer log.Flush()
    log.Infof("wsServer()")
    wsCh := wsServer()
    log.Infof("wsNAT()")
    natWS, err := wsNAT()
    if err != nil {
        log.Error(err)
        return
    }
    done := make(chan struct{}, 1)
        log.Infof("listenTCP()")
        conn := listenTCP()
        buf := bufio.NewReader(conn)
    go func() {
        log.Infof("Write TCP to WS")
        n, err := buf.WriteTo(natWS)
        if err != nil {
            log.Fatal(err)
            return
        }
        log.Infof("newConn.ws.ReadFrom(conn) %v", n)
        close(done)
    }()
    wsToTCP(<- wsCh)
    <-done
}
// wsNAT dials /ws endpoint and returns a websocket connection.
func wsNAT() (*websocket.Conn, error) {
    time.Sleep(1 * time.Second)
    origin := "http://localhost/"
    url := "ws://localhost:12345/ws"
    return websocket.Dial(url, "", origin)
}
 // wsServer returns the websocket
 // connections received on /ws endpoint
func wsServer() chan *websocket.Conn {
    wsCh := make(chan *websocket.Conn, 1)
    http.Handle("/ws", websocket.Handler(func(ws *websocket.Conn) {
        wsCh <- ws
        time.Sleep(1 *time.Hour)
    }))
    go func() {
        err := http.ListenAndServe(":12345", nil)
        if err != nil {
            panic("ListenAndServe: " + err.Error())
        }
    }()
    return wsCh
}
// wsToTCP reads a ws connection and converts its payload
// to a TCP connection.
func wsToTCP(ws *websocket.Conn) {
    conn := &net.TCPConn{}
    var msg []byte
    if _, err := ws.Read(msg); err != nil {
        log.Error(err)
        return
    }
    log.Infof("msg %v", msg)
    n, err := conn.Write(msg)
    if err != nil {
        log.Errorf("conn.Write %v, msg %v", err, msg)
        return
    }
    log.Infof("conn is %v, copied %v", conn, n)
    // END: do something with the connection
    // ..... 
}
//ListenTCP returns the first TCP connection received on port 8080
func listenTCP() *net.TCPConn {
    addr := &net.TCPAddr{IP: net.ParseIP("0.0.0.0"), Port: 8080}
    lr, err := net.ListenTCP("tcp", addr)
    if err != nil {
        panic(err)

    }
    defer lr.Close()
    ieConn, err := lr.AcceptTCP()
    if err != nil {
        panic(err)
    }
    log.Infof("connection accepted")
    return ieConn
}

要触发 TCP 侦听器，您可以在端口 8080 上发出请求（例如curl --socks5 localhost:8080 google.com -v或curl localhost:8080 -v）

Answer 1

这应该没有任何问题。我已经通过多种协议构建了 TCP 转发器。从不使用 WebSockets，但我看不出有什么不同的原因。

你有两个问题：

• 建立连接的正确方法是使用net.Dial，而不仅仅是创建net.TCPConn.
• 你只是在一个方向上复制。您需要双向复制。

这是我今天早上为不同目的构建的一个超级简单的代理（我的完整代码每隔一段时间就会破坏一个数据包，这样我就可以测试坏的连接）。它应该可以转换为许多其他用途：

func run(inPort int, dest string) {
    l, err := net.Listen("tcp", fmt.Sprintf(":%d", inPort))
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    fmt.Printf("http://%v -> %s\n", l.Addr(), dest)

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf("Connection from %s\n", conn.RemoteAddr())
        go proxy(conn, dest)
    }
}

func proxy(in net.Conn, dest string) {
    out, err := net.Dial("tcp", dest)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }

    go io.Copy(out, in)
    io.Copy(in, out)
    fmt.Printf("Disconnect from %s\n", in.RemoteAddr())
}

您只需要将net.Dial此处替换为对服务器的 WS 调用，并在服务器端使用net.Dial以将其转发。

但可能最关键的一点是最后几行。你必须双向复制，人们忘记了这一点。