migrated to wzshiming/socks5 from net/proxy because of udp support for socks5 proxy

Author: shadowy-pycoder

dialer_linux.go

@@ -0,0 +1,29 @@
+//go:build linux
+// +build linux
+
+package gohpts
+
+import (
+	"net"
+	"syscall"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func getBaseDialer(timeout time.Duration, mark uint) *net.Dialer {
+	var dialer *net.Dialer
+	if mark > 0 {
+		dialer = &net.Dialer{
+			Timeout: timeout,
+			Control: func(_, _ string, c syscall.RawConn) error {
+				return c.Control(func(fd uintptr) {
+					unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_MARK, int(mark))
+				})
+			},
+		}
+	} else {
+		dialer = &net.Dialer{Timeout: timeout}
+	}
+	return dialer
+}

dialer_nonlinux.go

@@ -0,0 +1,14 @@
+//go:build !linux
+// +build !linux
+
+package gohpts
+
+import (
+	"net"
+	"time"
+)
+
+func getBaseDialer(timeout time.Duration, mark uint) *net.Dialer {
+	_ = mark
+	return &net.Dialer{Timeout: timeout}
+}

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/rs/zerolog v1.34.0
 	github.com/shadowy-pycoder/colors v0.0.1
 	github.com/shadowy-pycoder/mshark v0.0.10
-	golang.org/x/net v0.40.0
+	github.com/wzshiming/socks5 v0.5.2
 	golang.org/x/sys v0.33.0
 	golang.org/x/term v0.32.0
 )
@@ -21,5 +21,6 @@ require (
 	github.com/mdlayher/packet v1.1.2 // indirect
 	github.com/mdlayher/socket v0.4.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sync v0.16.0 // indirect
 )

go.sum

@@ -34,6 +34,8 @@ github.com/shadowy-pycoder/mshark v0.0.10 h1:pLMIsgfvnO0oKeBNdy0fTGQsx//6scCPT52
 github.com/shadowy-pycoder/mshark v0.0.10/go.mod h1:FqbHFdsx0zMnrZZH0+oPzaFcleP4O+tUWv8i5gxo87k=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/wzshiming/socks5 v0.5.2 h1:LtoowVNwAmkIQSkP1r1Wg435xUmC+tfRxorNW30KtnM=
+github.com/wzshiming/socks5 v0.5.2/go.mod h1:BvCAqlzocQN5xwLjBZDBbvWlrx8sCYSSbHEOf2wZgT0=
 golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
 golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=

gohpts.go

@@ -31,7 +31,7 @@ import (
 	"github.com/shadowy-pycoder/mshark/arpspoof"
 	"github.com/shadowy-pycoder/mshark/layers"
 	"github.com/shadowy-pycoder/mshark/network"
-	"golang.org/x/net/proxy"
+	"github.com/wzshiming/socks5"
 )
 
 const (
@@ -127,7 +127,7 @@ type proxyapp struct {
 	httpServer     *http.Server
 	sockClient     *http.Client
 	httpClient     *http.Client
-	sockDialer     proxy.Dialer
+	sockDialer     *socks5.Dialer
 	logger         *zerolog.Logger
 	snifflogger    *zerolog.Logger
 	certFile       string
@@ -390,19 +390,19 @@ func New(conf *Config) *proxyapp {
 		if err != nil {
 			p.logger.Fatal().Err(err).Msg("")
 		}
-		auth := proxy.Auth{
+		auth := Auth{
 			User:     conf.User,
 			Password: conf.Pass,
 		}
-		dialer, err := proxy.SOCKS5("tcp", addrSOCKS, &auth, getBaseDialer(timeout, p.mark))
+		dialer, err := newSOCKS5Dialer(addrSOCKS, &auth, getBaseDialer(timeout, p.mark))
 		if err != nil {
 			p.logger.Fatal().Err(err).Msg("Unable to create SOCKS5 dialer")
 		}
 		p.sockDialer = dialer
 		if !tproxyonly {
 			p.sockClient = &http.Client{
 				Transport: &http.Transport{
-					Dial: dialer.Dial,
+					DialContext: dialer.DialContext,
 				},
 				CheckRedirect: func(req *http.Request, via []*http.Request) error {
 					return http.ErrUseLastResponse
@@ -764,7 +764,7 @@ func (p *proxyapp) handleTunnel(w http.ResponseWriter, r *http.Request) {
 		}
 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 		defer cancel()
-		dstConn, err = sockDialer.(proxy.ContextDialer).DialContext(ctx, "tcp", r.Host)
+		dstConn, err = sockDialer.DialContext(ctx, "tcp", r.Host)
 		if err != nil {
 			p.logger.Error().Err(err).Msgf("Failed connecting to %s", r.Host)
 			http.Error(w, err.Error(), http.StatusServiceUnavailable)
@@ -849,26 +849,25 @@ func (p *proxyapp) updateSocksList() {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 	p.availProxyList = p.availProxyList[:0]
-	var base proxy.Dialer = getBaseDialer(timeout, p.mark)
-	var dialer proxy.Dialer
+	var dialer *socks5.Dialer
 	var err error
 	failed := 0
 	chainType := p.proxychain.Type
 	ctl := colorizeChainType(chainType, p.nocolor)
 	for _, pr := range p.proxylist {
-		auth := proxy.Auth{
+		auth := Auth{
 			User:     pr.Username,
 			Password: pr.Password,
 		}
-		dialer, err = proxy.SOCKS5("tcp", pr.Address, &auth, base)
+		dialer, err = newSOCKS5Dialer(pr.Address, &auth, getBaseDialer(timeout, p.mark))
 		if err != nil {
 			p.logger.Error().Err(err).Msgf("%s Unable to create SOCKS5 dialer %s", ctl, pr.Address)
 			failed++
 			continue
 		}
 		ctx, cancel := context.WithTimeout(context.Background(), hopTimeout)
 		defer cancel()
-		conn, err := dialer.(proxy.ContextDialer).DialContext(ctx, "tcp", pr.Address)
+		conn, err := dialer.DialContext(ctx, "tcp", pr.Address)
 		if err != nil && !errors.Is(err, io.EOF) { // check for EOF to include localhost SOCKS5 in the chain
 			p.logger.Error().Err(err).Msgf("%s Unable to connect to %s", ctl, pr.Address)
 			failed++
@@ -890,19 +889,19 @@ func (p *proxyapp) updateSocksList() {
 	}
 	currentDialer := dialer
 	for _, pr := range p.proxylist[failed+1:] {
-		auth := proxy.Auth{
+		auth := Auth{
 			User:     pr.Username,
 			Password: pr.Password,
 		}
-		dialer, err = proxy.SOCKS5("tcp", pr.Address, &auth, currentDialer)
+		dialer, err = newSOCKS5Dialer(pr.Address, &auth, currentDialer)
 		if err != nil {
 			p.logger.Error().Err(err).Msgf("%s Unable to create SOCKS5 dialer %s", ctl, pr.Address)
 			continue
 		}
 		// https://github.com/golang/go/issues/37549#issuecomment-1178745487
 		ctx, cancel := context.WithTimeout(context.Background(), hopTimeout)
 		defer cancel()
-		conn, err := dialer.(proxy.ContextDialer).DialContext(ctx, "tcp", pr.Address)
+		conn, err := dialer.DialContext(ctx, "tcp", pr.Address)
 		if err != nil {
 			p.logger.Error().Err(err).Msgf("%s Unable to connect to %s", ctl, pr.Address)
 			if conn != nil {
@@ -929,7 +928,7 @@ func shuffle(vals []proxyEntry) {
 	}
 }
 
-func (p *proxyapp) getSocks() (proxy.Dialer, *http.Client, error) {
+func (p *proxyapp) getSocks() (*socks5.Dialer, *http.Client, error) {
 	if p.proxylist == nil {
 		return p.sockDialer, p.sockClient, nil
 	}
@@ -984,22 +983,26 @@ func (p *proxyapp) getSocks() (proxy.Dialer, *http.Client, error) {
 		p.logger.Error().Msgf("%s Not all SOCKS5 Proxy available", ctl)
 		return nil, nil, fmt.Errorf("not all socks5 proxy available")
 	}
-	var dialer proxy.Dialer = getBaseDialer(timeout, p.mark)
+	var dialer *socks5.Dialer
 	var err error
-	for _, pr := range copyProxyList {
-		auth := proxy.Auth{
+	for i, pr := range copyProxyList {
+		auth := Auth{
 			User:     pr.Username,
 			Password: pr.Password,
 		}
-		dialer, err = proxy.SOCKS5("tcp", pr.Address, &auth, dialer)
+		if i > 0 {
+			dialer, err = newSOCKS5Dialer(pr.Address, &auth, dialer)
+		} else {
+			dialer, err = newSOCKS5Dialer(pr.Address, &auth, getBaseDialer(timeout, p.mark))
+		}
 		if err != nil {
 			p.logger.Error().Err(err).Msgf("%s Unable to create SOCKS5 dialer %s", ctl, pr.Address)
 			return nil, nil, err
 		}
 	}
 	socks := &http.Client{
 		Transport: &http.Transport{
-			Dial: dialer.Dial,
+			DialContext: dialer.DialContext,
 		},
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
 			return http.ErrUseLastResponse

helpers.go

@@ -1,15 +1,19 @@
 package gohpts
 
 import (
+	"context"
 	"encoding/base64"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
+	"net/netip"
 	"os"
 	"strconv"
 	"strings"
 
 	"github.com/shadowy-pycoder/mshark/network"
+	"github.com/wzshiming/socks5"
 )
 
 // Hop-by-hop headers
@@ -129,3 +133,55 @@ func parseProxyAuth(auth string) (username, password string, ok bool) {
 	}
 	return username, password, true
 }
+
+func splitHostPort(address string) (string, int, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return "", 0, err
+	}
+	portnum, err := strconv.Atoi(port)
+	if err != nil {
+		return "", 0, err
+	}
+	if 1 > portnum || portnum > 0xffff {
+		return "", 0, errors.New("port number out of range " + port)
+	}
+	return host, portnum, nil
+}
+
+type Auth struct {
+	User, Password string
+}
+
+type ContextDialer interface {
+	DialContext(ctx context.Context, network, address string) (net.Conn, error)
+}
+
+var (
+	_ ContextDialer = &socks5.Dialer{}
+	_ ContextDialer = &net.Dialer{}
+)
+
+func newSOCKS5Dialer(address string, auth *Auth, forward ContextDialer) (*socks5.Dialer, error) {
+	d := &socks5.Dialer{
+		ProxyNetwork: "tcp",
+		IsResolve:    false,
+	}
+	host, port, err := splitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+	ip, err := netip.ParseAddr(host)
+	if err == nil {
+		host = ip.String()
+	}
+	d.ProxyAddress = net.JoinHostPort(host, strconv.Itoa(port))
+	if auth != nil {
+		d.Username = auth.User
+		d.Password = auth.Password
+	}
+	if forward != nil {
+		d.ProxyDial = forward.DialContext
+	}
+	return d, nil
+}

tproxy_linux.go

@@ -21,7 +21,6 @@ import (
 
 	"github.com/shadowy-pycoder/mshark/layers"
 	"github.com/shadowy-pycoder/mshark/network"
-	"golang.org/x/net/proxy"
 	"golang.org/x/sys/unix"
 )
 
@@ -171,7 +170,7 @@ func (ts *tproxyServer) handleConnection(srcConn net.Conn) {
 		}
 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 		defer cancel()
-		dstConn, err = sockDialer.(proxy.ContextDialer).DialContext(ctx, "tcp", dst)
+		dstConn, err = sockDialer.DialContext(ctx, "tcp", dst)
 		if err != nil {
 			ts.p.logger.Error().Err(err).Msgf("[%s] Failed connecting to %s", ts.p.tproxyMode, dst)
 			return
@@ -240,23 +239,6 @@ func (ts *tproxyServer) Shutdown() {
 	}
 }
 
-func getBaseDialer(timeout time.Duration, mark uint) *net.Dialer {
-	var dialer *net.Dialer
-	if mark > 0 {
-		dialer = &net.Dialer{
-			Timeout: timeout,
-			Control: func(_, _ string, c syscall.RawConn) error {
-				return c.Control(func(fd uintptr) {
-					unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_MARK, int(mark))
-				})
-			},
-		}
-	} else {
-		dialer = &net.Dialer{Timeout: timeout}
-	}
-	return dialer
-}
-
 func (ts *tproxyServer) createSysctlOptCmd(opt, value, setex string, opts map[string]string) *exec.Cmd {
 	cmdCat := exec.Command("bash", "-c", fmt.Sprintf(`
     cat /proc/sys/%s

tproxy_nonlinux.go

@@ -8,7 +8,6 @@ import (
 	"os/exec"
 	"sync"
 	"syscall"
-	"time"
 )
 
 type tproxyServer struct {
@@ -43,11 +42,6 @@ func (ts *tproxyServer) handleConnection(srcConn net.Conn) {
 
 func (ts *tproxyServer) Shutdown() {}
 
-func getBaseDialer(timeout time.Duration, mark uint) *net.Dialer {
-	_ = mark
-	return &net.Dialer{Timeout: timeout}
-}
-
 func (ts *tproxyServer) createSysctlOptCmd(opt, value, setex string, opts map[string]string) *exec.Cmd {
 	_ = opt
 	_ = value