init

go-gost/x/dialer/obfs/http/conn.go

@@ -0,0 +1,145 @@
+package http
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/rand"
+	"encoding/base64"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"sync"
+
+	"github.com/go-gost/core/logger"
+)
+
+type obfsHTTPConn struct {
+	net.Conn
+	host           string
+	path           string
+	rbuf           bytes.Buffer
+	wbuf           bytes.Buffer
+	headerDrained  bool
+	handshaked     bool
+	handshakeMutex sync.Mutex
+	header         http.Header
+	logger         logger.Logger
+}
+
+func (c *obfsHTTPConn) Handshake() (err error) {
+	c.handshakeMutex.Lock()
+	defer c.handshakeMutex.Unlock()
+
+	if c.handshaked {
+		return nil
+	}
+
+	err = c.handshake()
+	if err != nil {
+		return
+	}
+
+	c.handshaked = true
+	return nil
+}
+
+func (c *obfsHTTPConn) handshake() (err error) {
+	r := &http.Request{
+		Method:     http.MethodGet,
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		URL:        &url.URL{Scheme: "http", Host: c.host},
+		Header:     c.header,
+	}
+	if r.Header == nil {
+		r.Header = http.Header{}
+	}
+	r.Header.Set("Connection", "Upgrade")
+	r.Header.Set("Upgrade", "websocket")
+	key, _ := c.generateChallengeKey()
+	r.Header.Set("Sec-WebSocket-Key", key)
+
+	// cache the request header
+	if err = r.Write(&c.wbuf); err != nil {
+		return
+	}
+
+	if c.logger.IsLevelEnabled(logger.TraceLevel) {
+		dump, _ := httputil.DumpRequest(r, false)
+		c.logger.Trace(string(dump))
+	}
+
+	return nil
+}
+
+func (c *obfsHTTPConn) Read(b []byte) (n int, err error) {
+	if err = c.Handshake(); err != nil {
+		return
+	}
+
+	if err = c.drainHeader(); err != nil {
+		return
+	}
+
+	if c.rbuf.Len() > 0 {
+		return c.rbuf.Read(b)
+	}
+	return c.Conn.Read(b)
+}
+
+func (c *obfsHTTPConn) drainHeader() (err error) {
+	if c.headerDrained {
+		return
+	}
+	c.headerDrained = true
+
+	br := bufio.NewReader(c.Conn)
+	// drain and discard the response header
+	var line string
+	var buf bytes.Buffer
+	for {
+		line, err = br.ReadString('\n')
+		if err != nil {
+			return
+		}
+		buf.WriteString(line)
+		if line == "\r\n" {
+			break
+		}
+	}
+
+	if c.logger.IsLevelEnabled(logger.TraceLevel) {
+		c.logger.Trace(buf.String())
+	}
+
+	// cache the extra data for next read.
+	var b []byte
+	b, err = br.Peek(br.Buffered())
+	if len(b) > 0 {
+		_, err = c.rbuf.Write(b)
+	}
+	return
+}
+
+func (c *obfsHTTPConn) Write(b []byte) (n int, err error) {
+	if err = c.Handshake(); err != nil {
+		return
+	}
+	if c.wbuf.Len() > 0 {
+		c.wbuf.Write(b) // append the data to the cached header
+		_, err = c.wbuf.WriteTo(c.Conn)
+		n = len(b) // exclude the header length
+		return
+	}
+	return c.Conn.Write(b)
+}
+
+func (c *obfsHTTPConn) generateChallengeKey() (string, error) {
+	p := make([]byte, 16)
+	if _, err := io.ReadFull(rand.Reader, p); err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(p), nil
+}

go-gost/x/dialer/obfs/http/dialer.go

@@ -0,0 +1,90 @@
+package http
+
+import (
+	"context"
+	"crypto/tls"
+	"net"
+
+	"github.com/go-gost/core/dialer"
+	"github.com/go-gost/core/logger"
+	md "github.com/go-gost/core/metadata"
+	"github.com/go-gost/x/registry"
+)
+
+func init() {
+	registry.DialerRegistry().Register("ohttp", NewDialer)
+	registry.DialerRegistry().Register("ohttps", NewDialer)
+}
+
+type obfsHTTPDialer struct {
+	tlsEnabled bool
+	md         metadata
+	logger     logger.Logger
+}
+
+func NewDialer(opts ...dialer.Option) dialer.Dialer {
+	options := &dialer.Options{}
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	return &obfsHTTPDialer{
+		logger: options.Logger,
+	}
+}
+
+func NewTLSDialer(opts ...dialer.Option) dialer.Dialer {
+	options := &dialer.Options{}
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	return &obfsHTTPDialer{
+		tlsEnabled: true,
+		logger:     options.Logger,
+	}
+}
+
+func (d *obfsHTTPDialer) Init(md md.Metadata) (err error) {
+	return d.parseMetadata(md)
+}
+
+func (d *obfsHTTPDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (net.Conn, error) {
+	options := &dialer.DialOptions{}
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	conn, err := options.Dialer.Dial(ctx, "tcp", addr)
+	if err != nil {
+		d.logger.Error(err)
+	}
+	return conn, err
+}
+
+// Handshake implements dialer.Handshaker
+func (d *obfsHTTPDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
+	opts := &dialer.HandshakeOptions{}
+	for _, option := range options {
+		option(opts)
+	}
+
+	host := d.md.host
+	if host == "" {
+		host = opts.Addr
+	}
+
+	if d.tlsEnabled {
+		conn = tls.Client(conn, &tls.Config{
+			ServerName: host,
+		})
+	}
+
+	return &obfsHTTPConn{
+		Conn:   conn,
+		host:   host,
+		path:   d.md.path,
+		header: d.md.header,
+		logger: d.logger,
+	}, nil
+}

go-gost/x/dialer/obfs/http/metadata.go

@@ -0,0 +1,35 @@
+package http
+
+import (
+	"net/http"
+
+	mdata "github.com/go-gost/core/metadata"
+	mdutil "github.com/go-gost/x/metadata/util"
+)
+
+const (
+	defaultPath = "/"
+)
+
+type metadata struct {
+	host   string
+	path   string
+	header http.Header
+}
+
+func (d *obfsHTTPDialer) parseMetadata(md mdata.Metadata) (err error) {
+	d.md.host = mdutil.GetString(md, "obfs.host", "host")
+	d.md.path = mdutil.GetString(md, "obfs.path", "path")
+	if d.md.path == "" {
+		d.md.path = defaultPath
+	}
+
+	if m := mdutil.GetStringMapString(md, "obfs.header", "header"); len(m) > 0 {
+		h := http.Header{}
+		for k, v := range m {
+			h.Add(k, v)
+		}
+		d.md.header = h
+	}
+	return
+}