init

wss_test.go

@@ -0,0 +1,809 @@
+package gost
+
+import (
+	"crypto/rand"
+	"crypto/tls"
+	"fmt"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+)
+
+func httpOverWSSRoundtrip(targetURL string, data []byte, tlsConfig *tls.Config,
+	clientInfo *url.Userinfo, serverInfo []*url.Userinfo) error {
+
+	ln, err := WSSListener("", tlsConfig, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   HTTPConnector(clientInfo),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(serverInfo...),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestHTTPOverWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range httpProxyTests {
+		err := httpOverWSSRoundtrip(httpSrv.URL, sendData, nil, tc.cliUser, tc.srvUsers)
+		if err == nil {
+			if tc.errStr != "" {
+				t.Errorf("#%d should failed with error %s", i, tc.errStr)
+			}
+		} else {
+			if tc.errStr == "" {
+				t.Errorf("#%d got error %v", i, err)
+			}
+			if err.Error() != tc.errStr {
+				t.Errorf("#%d got error %v, want %v", i, err, tc.errStr)
+			}
+		}
+	}
+}
+
+func BenchmarkHTTPOverWSS(b *testing.B) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		b.Error(err)
+	}
+
+	client := &Client{
+		Connector:   HTTPConnector(url.UserPassword("admin", "123456")),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(url.UserPassword("admin", "123456")),
+		),
+	}
+	go server.Run()
+	defer server.Close()
+
+	for i := 0; i < b.N; i++ {
+		if err := proxyRoundtrip(client, server, httpSrv.URL, sendData); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkHTTPOverWSSParallel(b *testing.B) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		b.Error(err)
+	}
+
+	client := &Client{
+		Connector:   HTTPConnector(url.UserPassword("admin", "123456")),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(url.UserPassword("admin", "123456")),
+		),
+	}
+	go server.Run()
+	defer server.Close()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := proxyRoundtrip(client, server, httpSrv.URL, sendData); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+func socks5OverWSSRoundtrip(targetURL string, data []byte,
+	clientInfo *url.Userinfo, serverInfo []*url.Userinfo) error {
+
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS5Connector(clientInfo),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: SOCKS5Handler(
+			UsersHandlerOption(serverInfo...),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS5OverWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range socks5ProxyTests {
+		err := socks5OverWSSRoundtrip(httpSrv.URL, sendData,
+			tc.cliUser,
+			tc.srvUsers,
+		)
+		if err == nil {
+			if !tc.pass {
+				t.Errorf("#%d should failed", i)
+			}
+		} else {
+			// t.Logf("#%d %v", i, err)
+			if tc.pass {
+				t.Errorf("#%d got error: %v", i, err)
+			}
+		}
+	}
+}
+
+func socks4OverWSSRoundtrip(targetURL string, data []byte) error {
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS4Connector(),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SOCKS4Handler(),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS4OverWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := socks4OverWSSRoundtrip(httpSrv.URL, sendData)
+	// t.Logf("#%d %v", i, err)
+	if err != nil {
+		t.Errorf("got error: %v", err)
+	}
+}
+
+func socks4aOverWSSRoundtrip(targetURL string, data []byte) error {
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS4AConnector(),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SOCKS4Handler(),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS4AOverWSS(t *testing.T) {
+
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := socks4aOverWSSRoundtrip(httpSrv.URL, sendData)
+	// t.Logf("#%d %v", i, err)
+	if err != nil {
+		t.Errorf("got error: %v", err)
+	}
+}
+
+func ssOverWSSRoundtrip(targetURL string, data []byte,
+	clientInfo, serverInfo *url.Userinfo) error {
+
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   ShadowConnector(clientInfo),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: ShadowHandler(
+			UsersHandlerOption(serverInfo),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSSOverWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range ssProxyTests {
+		err := ssOverWSSRoundtrip(httpSrv.URL, sendData,
+			tc.clientCipher,
+			tc.serverCipher,
+		)
+		if err == nil {
+			if !tc.pass {
+				t.Errorf("#%d should failed", i)
+			}
+		} else {
+			// t.Logf("#%d %v", i, err)
+			if tc.pass {
+				t.Errorf("#%d got error: %v", i, err)
+			}
+		}
+	}
+}
+
+func sniOverWSSRoundtrip(targetURL string, data []byte, host string) error {
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(targetURL)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SNIConnector(host),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SNIHandler(HostHandlerOption(u.Host)),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return sniRoundtrip(client, server, targetURL, data)
+}
+
+func TestSNIOverWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+	httpsSrv := httptest.NewTLSServer(httpTestHandler)
+	defer httpsSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	var sniProxyTests = []struct {
+		targetURL string
+		host      string
+		pass      bool
+	}{
+		{httpSrv.URL, "", true},
+		{httpSrv.URL, "example.com", true},
+		{httpsSrv.URL, "", true},
+		{httpsSrv.URL, "example.com", true},
+	}
+
+	for i, tc := range sniProxyTests {
+		tc := tc
+		t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
+			err := sniOverWSSRoundtrip(tc.targetURL, sendData, tc.host)
+			if err == nil {
+				if !tc.pass {
+					t.Errorf("#%d should failed", i)
+				}
+			} else {
+				// t.Logf("#%d %v", i, err)
+				if tc.pass {
+					t.Errorf("#%d got error: %v", i, err)
+				}
+			}
+		})
+	}
+}
+
+func wssForwardTunnelRoundtrip(targetURL string, data []byte) error {
+	ln, err := WSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(targetURL)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   ForwardConnector(),
+		Transporter: WSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  TCPDirectForwardHandler(u.Host),
+	}
+	server.Handler.Init()
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestWSSForwardTunnel(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := wssForwardTunnelRoundtrip(httpSrv.URL, sendData)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func httpOverMWSSRoundtrip(targetURL string, data []byte,
+	clientInfo *url.Userinfo, serverInfo []*url.Userinfo) error {
+
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   HTTPConnector(clientInfo),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(serverInfo...),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestHTTPOverMWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range httpProxyTests {
+		err := httpOverMWSSRoundtrip(httpSrv.URL, sendData, tc.cliUser, tc.srvUsers)
+		if err == nil {
+			if tc.errStr != "" {
+				t.Errorf("#%d should failed with error %s", i, tc.errStr)
+			}
+		} else {
+			if tc.errStr == "" {
+				t.Errorf("#%d got error %v", i, err)
+			}
+			if err.Error() != tc.errStr {
+				t.Errorf("#%d got error %v, want %v", i, err, tc.errStr)
+			}
+		}
+	}
+}
+
+func BenchmarkHTTPOverMWSS(b *testing.B) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		b.Error(err)
+	}
+
+	client := &Client{
+		Connector:   HTTPConnector(url.UserPassword("admin", "123456")),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(url.UserPassword("admin", "123456")),
+		),
+	}
+	go server.Run()
+	defer server.Close()
+
+	for i := 0; i < b.N; i++ {
+		if err := proxyRoundtrip(client, server, httpSrv.URL, sendData); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkHTTPOverMWSSParallel(b *testing.B) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		b.Error(err)
+	}
+
+	b.Log(ln.Addr())
+	client := &Client{
+		Connector:   HTTPConnector(url.UserPassword("admin", "123456")),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: HTTPHandler(
+			UsersHandlerOption(url.UserPassword("admin", "123456")),
+		),
+	}
+	go server.Run()
+	defer server.Close()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := proxyRoundtrip(client, server, httpSrv.URL, sendData); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+func socks5OverMWSSRoundtrip(targetURL string, data []byte,
+	clientInfo *url.Userinfo, serverInfo []*url.Userinfo) error {
+
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS5Connector(clientInfo),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: SOCKS5Handler(
+			UsersHandlerOption(serverInfo...),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS5OverMWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range socks5ProxyTests {
+		err := socks5OverMWSSRoundtrip(httpSrv.URL, sendData,
+			tc.cliUser,
+			tc.srvUsers,
+		)
+		if err == nil {
+			if !tc.pass {
+				t.Errorf("#%d should failed", i)
+			}
+		} else {
+			// t.Logf("#%d %v", i, err)
+			if tc.pass {
+				t.Errorf("#%d got error: %v", i, err)
+			}
+		}
+	}
+}
+
+func socks4OverMWSSRoundtrip(targetURL string, data []byte) error {
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS4Connector(),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SOCKS4Handler(),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS4OverMWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := socks4OverMWSSRoundtrip(httpSrv.URL, sendData)
+	// t.Logf("#%d %v", i, err)
+	if err != nil {
+		t.Errorf("got error: %v", err)
+	}
+}
+
+func socks4aOverMWSSRoundtrip(targetURL string, data []byte) error {
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SOCKS4AConnector(),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SOCKS4Handler(),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSOCKS4AOverMWSS(t *testing.T) {
+
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := socks4aOverMWSSRoundtrip(httpSrv.URL, sendData)
+	// t.Logf("#%d %v", i, err)
+	if err != nil {
+		t.Errorf("got error: %v", err)
+	}
+}
+
+func ssOverMWSSRoundtrip(targetURL string, data []byte,
+	clientInfo, serverInfo *url.Userinfo) error {
+
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   ShadowConnector(clientInfo),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler: ShadowHandler(
+			UsersHandlerOption(serverInfo),
+		),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestSSOverMWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	for i, tc := range ssProxyTests {
+		err := ssOverMWSSRoundtrip(httpSrv.URL, sendData,
+			tc.clientCipher,
+			tc.serverCipher,
+		)
+		if err == nil {
+			if !tc.pass {
+				t.Errorf("#%d should failed", i)
+			}
+		} else {
+			// t.Logf("#%d %v", i, err)
+			if tc.pass {
+				t.Errorf("#%d got error: %v", i, err)
+			}
+		}
+	}
+}
+
+func sniOverMWSSRoundtrip(targetURL string, data []byte, host string) error {
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(targetURL)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   SNIConnector(host),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  SNIHandler(HostHandlerOption(u.Host)),
+	}
+
+	go server.Run()
+	defer server.Close()
+
+	return sniRoundtrip(client, server, targetURL, data)
+}
+
+func TestSNIOverMWSS(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+	httpsSrv := httptest.NewTLSServer(httpTestHandler)
+	defer httpsSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	var sniProxyTests = []struct {
+		targetURL string
+		host      string
+		pass      bool
+	}{
+		{httpSrv.URL, "", true},
+		{httpSrv.URL, "example.com", true},
+		{httpsSrv.URL, "", true},
+		{httpsSrv.URL, "example.com", true},
+	}
+
+	for i, tc := range sniProxyTests {
+		tc := tc
+		t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
+			err := sniOverMWSSRoundtrip(tc.targetURL, sendData, tc.host)
+			if err == nil {
+				if !tc.pass {
+					t.Errorf("#%d should failed", i)
+				}
+			} else {
+				// t.Logf("#%d %v", i, err)
+				if tc.pass {
+					t.Errorf("#%d got error: %v", i, err)
+				}
+			}
+		})
+	}
+}
+
+func mwssForwardTunnelRoundtrip(targetURL string, data []byte) error {
+	ln, err := MWSSListener("", nil, nil)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(targetURL)
+	if err != nil {
+		return err
+	}
+
+	client := &Client{
+		Connector:   ForwardConnector(),
+		Transporter: MWSSTransporter(nil),
+	}
+
+	server := &Server{
+		Listener: ln,
+		Handler:  TCPDirectForwardHandler(u.Host),
+	}
+	server.Handler.Init()
+
+	go server.Run()
+	defer server.Close()
+
+	return proxyRoundtrip(client, server, targetURL, data)
+}
+
+func TestMWSSForwardTunnel(t *testing.T) {
+	httpSrv := httptest.NewServer(httpTestHandler)
+	defer httpSrv.Close()
+
+	sendData := make([]byte, 128)
+	rand.Read(sendData)
+
+	err := mwssForwardTunnelRoundtrip(httpSrv.URL, sendData)
+	if err != nil {
+		t.Error(err)
+	}
+}