add obfs4 tunnel support

cmd/gost/main.go

@@ -156,6 +156,11 @@ func initChain() (*gost.Chain, error) {
 				gost.ChainDialOption(chain),
 			)
 			chain = gost.NewChain() // cutoff the chain for multiplex
+		case "obfs4":
+			if err := gost.Obfs4Init(node, false); err != nil {
+				return nil, err
+			}
+			tr = gost.Obfs4Transporter()
 		default:
 			tr = gost.TCPTransporter()
 		}
@@ -265,6 +270,11 @@ func serve(chain *gost.Chain) error {
 			ln, err = gost.H2Listener(node.Addr, tlsCfg)
 		case "h2c":
 			ln, err = gost.H2CListener(node.Addr)
+		case "obfs4":
+			if err = gost.Obfs4Init(node, true); err != nil {
+				return err
+			}
+			ln, err = gost.Obfs4Listener(node.Addr)
 		case "tcp":
 			ln, err = gost.TCPListener(node.Addr)
 		case "rtcp":

cmd/gost/secrets.txt

@@ -1,4 +1,6 @@
 # username password
 
+test\admin 123456
+$test 123456
 test001 123456
 test002 12345678

node.go

@@ -46,7 +46,7 @@ func ParseNode(s string) (node Node, err error) {
 	}
 
 	switch node.Transport {
-	case "tls", "ws", "wss", "kcp", "ssh", "quic", "ssu", "http2", "h2", "h2c", "redirect":
+	case "tls", "ws", "wss", "kcp", "ssh", "quic", "ssu", "http2", "h2", "h2c", "redirect", "obfs4":
 	case "https":
 		node.Protocol = "http"
 		node.Transport = "tls"

obfs4.go

@@ -0,0 +1,157 @@
+package gost
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+
+	"github.com/go-log/log"
+
+	pt "git.torproject.org/pluggable-transports/goptlib.git"
+	"git.torproject.org/pluggable-transports/obfs4.git/transports/base"
+	"git.torproject.org/pluggable-transports/obfs4.git/transports/obfs4"
+)
+
+type obfs4Context struct {
+	cf    base.ClientFactory
+	cargs interface{} // type obfs4ClientArgs
+	sf    base.ServerFactory
+	sargs *pt.Args
+}
+
+var obfs4Map = make(map[string]obfs4Context)
+
+func Obfs4Init(node Node, isServeNode bool) error {
+	if _, ok := obfs4Map[node.Addr]; ok {
+		return fmt.Errorf("obfs4 context already inited")
+	}
+
+	t := new(obfs4.Transport)
+
+	stateDir := node.Values.Get("state-dir")
+	if stateDir == "" {
+		stateDir = "."
+	}
+
+	ptArgs := pt.Args(node.Values)
+
+	if !isServeNode {
+		cf, err := t.ClientFactory(stateDir)
+		if err != nil {
+			return err
+		}
+
+		cargs, err := cf.ParseArgs(&ptArgs)
+		if err != nil {
+			return err
+		}
+
+		obfs4Map[node.Addr] = obfs4Context{cf: cf, cargs: cargs}
+	} else {
+		sf, err := t.ServerFactory(stateDir, &ptArgs)
+		if err != nil {
+			return err
+		}
+
+		sargs := sf.Args()
+
+		obfs4Map[node.Addr] = obfs4Context{sf: sf, sargs: sargs}
+
+		log.Log("[obfs4] server inited:", obfs4ServerURL(node))
+	}
+
+	return nil
+}
+
+func obfs4GetContext(addr string) (obfs4Context, error) {
+	ctx, ok := obfs4Map[addr]
+	if !ok {
+		return obfs4Context{}, fmt.Errorf("obfs4 context not inited")
+	}
+	return ctx, nil
+}
+
+func obfs4ServerURL(node Node) string {
+	ctx, err := obfs4GetContext(node.Addr)
+	if err != nil {
+		return ""
+	}
+
+	values := (*url.Values)(ctx.sargs)
+	query := values.Encode()
+
+	return fmt.Sprintf(
+		"%s+%s://%s/?%s", //obfs4-cert=%s&iat-mode=%s",
+		node.Protocol,
+		node.Transport,
+		node.Addr,
+		query,
+	)
+}
+
+func obfs4ClientConn(addr string, conn net.Conn) (net.Conn, error) {
+	ctx, err := obfs4GetContext(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	pseudoDial := func(a, b string) (net.Conn, error) { return conn, nil }
+	return ctx.cf.Dial("tcp", "", pseudoDial, ctx.cargs)
+}
+
+func obfs4ServerConn(addr string, conn net.Conn) (net.Conn, error) {
+	ctx, err := obfs4GetContext(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctx.sf.WrapConn(conn)
+}
+
+type obfs4Transporter struct {
+	tcpTransporter
+}
+
+// Obfs4Transporter creates a Transporter that is used by obfs4 client.
+func Obfs4Transporter() Transporter {
+	return &obfs4Transporter{}
+}
+
+func (tr *obfs4Transporter) Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error) {
+	opts := &HandshakeOptions{}
+	for _, option := range options {
+		option(opts)
+	}
+	return obfs4ClientConn(opts.Addr, conn)
+}
+
+type obfs4Listener struct {
+	addr string
+	net.Listener
+}
+
+// Obfs4Listener creates a Listener for obfs4 server.
+func Obfs4Listener(addr string) (Listener, error) {
+	ln, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+	l := &obfs4Listener{
+		addr:     addr,
+		Listener: ln,
+	}
+	return l, nil
+}
+
+func (l *obfs4Listener) Accpet() (net.Conn, error) {
+	conn, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+	cc, err := obfs4ServerConn(l.addr, conn)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return cc, nil
+}

tls.go

@@ -8,7 +8,7 @@ import (
 )
 
 type tlsTransporter struct {
-	*tcpTransporter
+	tcpTransporter
 }
 
 // TLSTransporter creates a Transporter that is used by TLS proxy client.