remove v1

proxy/proxy.go

@@ -1,84 +0,0 @@
-package proxy
-
-import (
-	"errors"
-	"net"
-	"strconv"
-	"strings"
-
-	D "github.com/xjasonlyu/tun2socks/component/fakedns"
-	S "github.com/xjasonlyu/tun2socks/component/session"
-)
-
-var (
-	monitor S.Monitor
-
-	fakeDNS D.FakeDNS
-	// default DNS address
-	hijackDNS []string
-)
-
-func RegisterMonitor(m S.Monitor) {
-	monitor = m
-}
-
-func RegisterFakeDNS(d D.FakeDNS, h string) {
-	fakeDNS = d
-	hijackDNS = append(hijackDNS, strings.Split(h, ",")...)
-}
-
-// Session Operation
-func addSession(key interface{}, session *S.Session) {
-	if monitor != nil {
-		monitor.AddSession(key, session)
-	}
-}
-
-func removeSession(key interface{}) {
-	if monitor != nil {
-		monitor.RemoveSession(key)
-	}
-}
-
-// Check target if is hijacked address.
-func isHijacked(target *net.UDPAddr) bool {
-	if fakeDNS == nil {
-		// ignore when fake DNS disabled
-		return false
-	}
-
-	for _, addr := range hijackDNS {
-		host, port, err := net.SplitHostPort(addr)
-		if err != nil {
-			continue
-		}
-		portInt, _ := strconv.Atoi(port)
-		if (host == "*" && portInt == target.Port) || addr == target.String() {
-			return true
-		}
-	}
-	return false
-}
-
-// DNS lookup
-func lookupHost(target net.Addr) (targetHost string, err error) {
-	var targetIP net.IP
-	switch addr := target.(type) {
-	case *net.TCPAddr:
-		targetIP = addr.IP
-	case *net.UDPAddr:
-		targetIP = addr.IP
-	default:
-		err = errors.New("invalid target type")
-		return
-	}
-
-	targetHost = targetIP.String()
-	// Replace with a domain name if target address IP is a fake IP.
-	if fakeDNS != nil {
-		if host, exist := fakeDNS.IPToHost(targetIP); exist {
-			targetHost = host
-		}
-	}
-	return
-}

proxy/socks/socks.go

@@ -1,247 +0,0 @@
-package socks
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"net"
-	"strconv"
-)
-
-const Version = 5
-
-// Error represents a SOCKS error
-type Error byte
-
-func (err Error) Error() string {
-	return "SOCKS5 error: " + strconv.Itoa(int(err))
-}
-
-// Command is request commands as defined in RFC 1928 section 4.
-type Command = uint8
-
-// SOCKS request commands as defined in RFC 1928 section 4.
-const (
-	CmdConnect      Command = 1
-	CmdBind         Command = 2
-	CmdUDPAssociate Command = 3
-)
-
-// SOCKS address types as defined in RFC 1928 section 5.
-const (
-	AtypIPv4       = 1
-	AtypDomainName = 3
-	AtypIPv6       = 4
-)
-
-// MaxAddrLen is the maximum size of SOCKS address in bytes.
-const MaxAddrLen = 1 + 1 + 255 + 2
-
-// MaxAuthLen is the maximum size of user/password field in SOCKS5 Auth
-const MaxAuthLen = 255
-
-// Addr represents a SOCKS address as defined in RFC 1928 section 5.
-type Addr []byte
-
-func (a Addr) String() string {
-	var host, port string
-
-	switch a[0] {
-	case AtypDomainName:
-		hostLen := uint16(a[1])
-		host = string(a[2 : 2+hostLen])
-		port = strconv.Itoa((int(a[2+hostLen]) << 8) | int(a[2+hostLen+1]))
-	case AtypIPv4:
-		host = net.IP(a[1 : 1+net.IPv4len]).String()
-		port = strconv.Itoa((int(a[1+net.IPv4len]) << 8) | int(a[1+net.IPv4len+1]))
-	case AtypIPv6:
-		host = net.IP(a[1 : 1+net.IPv6len]).String()
-		port = strconv.Itoa((int(a[1+net.IPv6len]) << 8) | int(a[1+net.IPv6len+1]))
-	}
-
-	return net.JoinHostPort(host, port)
-}
-
-// SOCKS errors as defined in RFC 1928 section 6.
-const (
-	ErrGeneralFailure       = Error(1)
-	ErrConnectionNotAllowed = Error(2)
-	ErrNetworkUnreachable   = Error(3)
-	ErrHostUnreachable      = Error(4)
-	ErrConnectionRefused    = Error(5)
-	ErrTTLExpired           = Error(6)
-	ErrCommandNotSupported  = Error(7)
-	ErrAddressNotSupported  = Error(8)
-)
-
-// Auth errors used to return a specific "Auth failed" error
-var ErrAuth = errors.New("auth failed")
-
-// ClientHandshake fast-tracks SOCKS initialization to get target address to connect on client side.
-func ClientHandshake(rw io.ReadWriter, addr Addr, command Command) (Addr, error) {
-	buf := make([]byte, MaxAddrLen)
-	var err error
-
-	// VER, NMETHODS, METHODS
-	_, err = rw.Write([]byte{Version, 1, 0})
-
-	if err != nil {
-		return nil, err
-	}
-
-	// VER, METHOD
-	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
-		return nil, err
-	}
-
-	if buf[0] != 5 {
-		return nil, errors.New("SOCKS version error")
-	}
-
-	if buf[1] != 0 {
-		return nil, errors.New("SOCKS need auth")
-	}
-
-	// VER, CMD, RSV, ADDR
-	if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
-		return nil, err
-	}
-
-	// VER, REP, RSV
-	if _, err := io.ReadFull(rw, buf[:3]); err != nil {
-		return nil, err
-	}
-
-	return readAddr(rw, buf)
-}
-
-func readAddr(r io.Reader, b []byte) (Addr, error) {
-	if len(b) < MaxAddrLen {
-		return nil, io.ErrShortBuffer
-	}
-	_, err := io.ReadFull(r, b[:1]) // read 1st byte for address type
-	if err != nil {
-		return nil, err
-	}
-
-	switch b[0] {
-	case AtypDomainName:
-		_, err = io.ReadFull(r, b[1:2]) // read 2nd byte for domain length
-		if err != nil {
-			return nil, err
-		}
-		domainLength := uint16(b[1])
-		_, err = io.ReadFull(r, b[2:2+domainLength+2])
-		return b[:1+1+domainLength+2], err
-	case AtypIPv4:
-		_, err = io.ReadFull(r, b[1:1+net.IPv4len+2])
-		return b[:1+net.IPv4len+2], err
-	case AtypIPv6:
-		_, err = io.ReadFull(r, b[1:1+net.IPv6len+2])
-		return b[:1+net.IPv6len+2], err
-	}
-
-	return nil, ErrAddressNotSupported
-}
-
-// SplitAddr slices a SOCKS address from beginning of b. Returns nil if failed.
-func SplitAddr(b []byte) Addr {
-	addrLen := 1
-	if len(b) < addrLen {
-		return nil
-	}
-
-	switch b[0] {
-	case AtypDomainName:
-		if len(b) < 2 {
-			return nil
-		}
-		addrLen = 1 + 1 + int(b[1]) + 2
-	case AtypIPv4:
-		addrLen = 1 + net.IPv4len + 2
-	case AtypIPv6:
-		addrLen = 1 + net.IPv6len + 2
-	default:
-		return nil
-
-	}
-
-	if len(b) < addrLen {
-		return nil
-	}
-
-	return b[:addrLen]
-}
-
-// ParseAddr parses the address in string s. Returns nil if failed.
-func ParseAddr(s string) Addr {
-	var addr Addr
-	host, port, err := net.SplitHostPort(s)
-	if err != nil {
-		return nil
-	}
-	if ip := net.ParseIP(host); ip != nil {
-		if ip4 := ip.To4(); ip4 != nil {
-			addr = make([]byte, 1+net.IPv4len+2)
-			addr[0] = AtypIPv4
-			copy(addr[1:], ip4)
-		} else {
-			addr = make([]byte, 1+net.IPv6len+2)
-			addr[0] = AtypIPv6
-			copy(addr[1:], ip)
-		}
-	} else {
-		if len(host) > 255 {
-			return nil
-		}
-		addr = make([]byte, 1+1+len(host)+2)
-		addr[0] = AtypDomainName
-		addr[1] = byte(len(host))
-		copy(addr[2:], host)
-	}
-
-	portUint, err := strconv.ParseUint(port, 10, 16)
-	if err != nil {
-		return nil
-	}
-
-	addr[len(addr)-2], addr[len(addr)-1] = byte(portUint>>8), byte(portUint)
-
-	return addr
-}
-
-func DecodeUDPPacket(packet []byte) (addr Addr, payload []byte, err error) {
-	if len(packet) < 5 {
-		err = errors.New("insufficient length of packet")
-		return
-	}
-
-	// packet[0] and packet[1] are reserved
-	if !bytes.Equal(packet[:2], []byte{0, 0}) {
-		err = errors.New("reserved fields should be zero")
-		return
-	}
-
-	if packet[2] != 0 /* fragments */ {
-		err = errors.New("discarding fragmented payload")
-		return
-	}
-
-	addr = SplitAddr(packet[3:])
-	if addr == nil {
-		err = errors.New("failed to read UDP header")
-	}
-
-	payload = make([]byte, len(packet[3+len(addr):]))
-	copy(payload, packet[3+len(addr):])
-	return
-}
-
-func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
-	if addr == nil {
-		err = errors.New("address is invalid")
-		return
-	}
-	packet = bytes.Join([][]byte{{0, 0, 0}, addr, payload}, []byte{})
-	return
-}

proxy/tcp.go

@@ -1,126 +0,0 @@
-package proxy
-
-import (
-	"io"
-	"net"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/xjasonlyu/tun2socks/common/lsof"
-	"github.com/xjasonlyu/tun2socks/common/pool"
-	"github.com/xjasonlyu/tun2socks/core"
-	"github.com/xjasonlyu/tun2socks/log"
-
-	S "github.com/xjasonlyu/tun2socks/component/session"
-)
-
-type tcpHandler struct {
-	proxyHost string
-	proxyPort int
-}
-
-func NewTCPHandler(proxyHost string, proxyPort int) core.TCPConnHandler {
-	return &tcpHandler{
-		proxyHost: proxyHost,
-		proxyPort: proxyPort,
-	}
-}
-
-func (h *tcpHandler) relay(localConn, remoteConn net.Conn) {
-	var once sync.Once
-	closeOnce := func() {
-		once.Do(func() {
-			localConn.Close()
-			remoteConn.Close()
-		})
-	}
-
-	// Cleanup
-	defer func() {
-		// Close
-		closeOnce()
-		// Remove session
-		removeSession(localConn)
-	}()
-
-	// WaitGroup
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	// Up Link
-	go func() {
-		buf := pool.BufPool.Get().([]byte)
-		defer pool.BufPool.Put(buf[:cap(buf)])
-		if _, err := io.CopyBuffer(remoteConn, localConn, buf); err != nil {
-			closeOnce()
-		} else {
-			localConn.SetDeadline(time.Now())
-			remoteConn.SetDeadline(time.Now())
-			tcpCloseRead(remoteConn)
-		}
-		wg.Done()
-	}()
-
-	// Down Link
-	buf := pool.BufPool.Get().([]byte)
-	if _, err := io.CopyBuffer(localConn, remoteConn, buf); err != nil {
-		closeOnce()
-	} else {
-		localConn.SetDeadline(time.Now())
-		remoteConn.SetDeadline(time.Now())
-		tcpCloseRead(localConn)
-	}
-	pool.BufPool.Put(buf[:cap(buf)])
-
-	wg.Wait() // Wait for Up Link done
-}
-
-func (h *tcpHandler) Handle(conn net.Conn, target *net.TCPAddr) error {
-	// Alias
-	var localConn = conn
-
-	// Lookup fakeDNS host record
-	targetHost, err := lookupHost(target)
-	if err != nil {
-		log.Warnf("lookup target host: %v", err)
-		return err
-	}
-
-	proxyAddr := net.JoinHostPort(h.proxyHost, strconv.Itoa(h.proxyPort))
-	targetAddr := net.JoinHostPort(targetHost, strconv.Itoa(target.Port))
-	// Dial
-	remoteConn, err := dial(proxyAddr, targetAddr)
-	if err != nil {
-		log.Infof("Dial: %v", err)
-		return err
-	}
-
-	var process = "N/A"
-	if monitor != nil {
-		// Get name of the process
-		process = lsof.GetProcessName(localConn.LocalAddr())
-		session := &S.Session{
-			Process:       process,
-			Network:       localConn.LocalAddr().Network(),
-			DialerAddr:    remoteConn.LocalAddr().String(),
-			ClientAddr:    localConn.LocalAddr().String(),
-			TargetAddr:    targetAddr,
-			UploadBytes:   0,
-			DownloadBytes: 0,
-			SessionStart:  time.Now(),
-		}
-		addSession(localConn, session)
-		remoteConn = &S.Conn{Session: session, Conn: remoteConn}
-	}
-
-	// Set keepalive
-	tcpKeepAlive(localConn)
-	tcpKeepAlive(remoteConn)
-
-	// Relay connections
-	go h.relay(localConn, remoteConn)
-
-	log.Access(process, "proxy", "tcp", localConn.LocalAddr().String(), targetAddr)
-	return nil
-}

proxy/udp.go

@@ -1,165 +0,0 @@
-package proxy
-
-import (
-	"fmt"
-	"net"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/xjasonlyu/tun2socks/common/lsof"
-	"github.com/xjasonlyu/tun2socks/common/pool"
-	"github.com/xjasonlyu/tun2socks/core"
-	"github.com/xjasonlyu/tun2socks/log"
-
-	S "github.com/xjasonlyu/tun2socks/component/session"
-)
-
-type udpHandler struct {
-	proxyHost string
-	proxyPort int
-	timeout   time.Duration
-
-	remoteMap sync.Map
-}
-
-func NewUDPHandler(proxyHost string, proxyPort int, timeout time.Duration) core.UDPConnHandler {
-	return &udpHandler{
-		proxyHost: proxyHost,
-		proxyPort: proxyPort,
-		timeout:   timeout,
-	}
-}
-
-func (h *udpHandler) fetchUDPInput(conn core.UDPConn, input net.PacketConn, addr *net.UDPAddr) {
-	buf := pool.BufPool.Get().([]byte)
-
-	defer func() {
-		h.Close(conn)
-		pool.BufPool.Put(buf[:cap(buf)])
-	}()
-
-	for {
-		input.SetDeadline(time.Now().Add(h.timeout))
-		n, _, err := input.ReadFrom(buf)
-		if err != nil {
-			if !isTimeout(err) && !isClosed(err) {
-				log.Warnf("failed to read UDP data from remote: %v", err)
-			}
-			return
-		}
-
-		if _, err := conn.WriteFrom(buf[:n], addr); err != nil {
-			log.Warnf("failed to write UDP data: %v", err)
-			return
-		}
-	}
-}
-
-func (h *udpHandler) Connect(conn core.UDPConn, target *net.UDPAddr) error {
-	// Check hijackDNS
-	if isHijacked(target) {
-		return nil
-	}
-
-	// Lookup fakeDNS host record
-	targetHost, err := lookupHost(target)
-	if err != nil {
-		log.Warnf("lookup target host: %v", err)
-		return err
-	}
-
-	proxyAddr := net.JoinHostPort(h.proxyHost, strconv.Itoa(h.proxyPort))
-	targetAddr := net.JoinHostPort(targetHost, strconv.Itoa(target.Port))
-	// Dial
-	remoteConn, remoteAddr, err := dialUDP(proxyAddr, targetAddr)
-	if err != nil {
-		log.Infof("DialUDP: %v", err)
-		return err
-	}
-
-	var process = "N/A"
-	if monitor != nil {
-		// Get name of the process
-		process = lsof.GetProcessName(conn.LocalAddr())
-		session := &S.Session{
-			Process:       process,
-			Network:       conn.LocalAddr().Network(),
-			DialerAddr:    remoteConn.LocalAddr().String(),
-			ClientAddr:    conn.LocalAddr().String(),
-			TargetAddr:    targetAddr,
-			UploadBytes:   0,
-			DownloadBytes: 0,
-			SessionStart:  time.Now(),
-		}
-		addSession(conn, session)
-		remoteConn = &S.PacketConn{Session: session, PacketConn: remoteConn}
-	}
-
-	h.remoteMap.Store(conn, &udpElement{
-		remoteAddr: remoteAddr,
-		remoteConn: remoteConn,
-	})
-
-	go h.fetchUDPInput(conn, remoteConn, target)
-
-	log.Access(process, "proxy", "udp", conn.LocalAddr().String(), targetAddr)
-	return nil
-}
-
-func (h *udpHandler) ReceiveTo(conn core.UDPConn, data []byte, addr *net.UDPAddr) (err error) {
-	// Close if return error
-	defer func() {
-		if err != nil {
-			h.Close(conn)
-		}
-	}()
-
-	// Check hijackDNS
-	if isHijacked(addr) {
-		resp, err := fakeDNS.Resolve(data)
-		if err != nil {
-			return fmt.Errorf("hijack DNS request error: %v", err)
-		}
-
-		if _, err = conn.WriteFrom(resp, addr); err != nil {
-			return fmt.Errorf("write dns answer failed: %v", err)
-		}
-		h.Close(conn)
-		return nil
-	}
-
-	var remoteAddr net.Addr
-	var remoteConn net.PacketConn
-
-	if elm, ok := h.remoteMap.Load(conn); ok {
-		remoteAddr = elm.(*udpElement).remoteAddr
-		remoteConn = elm.(*udpElement).remoteConn
-	}
-
-	if remoteAddr == nil || remoteConn == nil {
-		return fmt.Errorf("proxy connection %v->%v does not exists", conn.LocalAddr(), addr)
-	}
-
-	if _, err = remoteConn.WriteTo(data, remoteAddr); err != nil {
-		return fmt.Errorf("write remote failed: %v", err)
-	}
-
-	return nil
-}
-
-func (h *udpHandler) Close(conn core.UDPConn) {
-	// Close
-	conn.Close()
-
-	// Load from remoteConnMap
-	if elm, ok := h.remoteMap.Load(conn); ok {
-		elm.(*udpElement).remoteConn.Close()
-		h.remoteMap.Delete(conn)
-	} else {
-		return
-	}
-
-	// Remove session
-	removeSession(conn)
-}

proxy/utils.go

@@ -1,157 +0,0 @@
-package proxy
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"strings"
-	"time"
-
-	"github.com/xjasonlyu/tun2socks/proxy/socks"
-)
-
-// Error
-func isTimeout(err error) bool {
-	if netErr, ok := err.(net.Error); ok {
-		return netErr.Timeout()
-	}
-	return false
-}
-
-func isClosed(err error) bool {
-	want := "use of closed network connection"
-	return strings.Contains(err.Error(), want)
-}
-
-// UDP util
-type udpElement struct {
-	remoteAddr net.Addr
-	remoteConn net.PacketConn
-}
-
-// TCP functions
-type duplexConn interface {
-	net.Conn
-	CloseRead() error
-	CloseWrite() error
-}
-
-func tcpCloseRead(conn net.Conn) {
-	if c, ok := conn.(duplexConn); ok {
-		c.CloseRead()
-	}
-}
-
-func tcpCloseWrite(conn net.Conn) {
-	if c, ok := conn.(duplexConn); ok {
-		c.CloseWrite()
-	}
-}
-
-func tcpKeepAlive(conn net.Conn) {
-	if tcp, ok := conn.(*net.TCPConn); ok {
-		tcp.SetKeepAlive(true)
-		tcp.SetKeepAlivePeriod(30 * time.Second)
-	}
-}
-
-// Socks dialer
-func dial(proxy, target string) (net.Conn, error) {
-	c, err := net.DialTimeout("tcp", proxy, 5*time.Second)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", proxy)
-	}
-
-	targetAddr := socks.ParseAddr(target)
-	if targetAddr == nil {
-		return nil, fmt.Errorf("target address parse error")
-	}
-
-	if _, err := socks.ClientHandshake(c, targetAddr, socks.CmdConnect); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-func dialUDP(proxy, target string) (_ net.PacketConn, _ net.Addr, err error) {
-	c, err := net.DialTimeout("tcp", proxy, 5*time.Second)
-	if err != nil {
-		err = fmt.Errorf("%s connect error", proxy)
-		return
-	}
-
-	// tcp set keepalive
-	tcpKeepAlive(c)
-
-	defer func() {
-		if err != nil {
-			c.Close()
-		}
-	}()
-
-	targetAddr := socks.ParseAddr(target)
-	if targetAddr == nil {
-		err = fmt.Errorf("target address parse error")
-		return
-	}
-
-	bindAddr, err := socks.ClientHandshake(c, targetAddr, socks.CmdUDPAssociate)
-	if err != nil {
-		err = fmt.Errorf("%v client hanshake error", err)
-		return
-	}
-
-	addr, err := net.ResolveUDPAddr("udp", bindAddr.String())
-	if err != nil {
-		return
-	}
-
-	pc, err := net.ListenPacket("udp", "")
-	if err != nil {
-		return
-	}
-
-	go func() {
-		io.Copy(ioutil.Discard, c)
-		c.Close()
-		// A UDP association terminates when the TCP connection that the UDP
-		// ASSOCIATE request arrived on terminates. RFC1928
-		pc.Close()
-	}()
-
-	return &socksUDPConn{PacketConn: pc, tcpConn: c, targetAddr: targetAddr}, addr, nil
-}
-
-// Socks wrapped UDPConn
-type socksUDPConn struct {
-	net.PacketConn
-	tcpConn    net.Conn
-	targetAddr socks.Addr
-}
-
-func (c *socksUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
-	packet, err := socks.EncodeUDPPacket(c.targetAddr, b)
-	if err != nil {
-		return
-	}
-	return c.PacketConn.WriteTo(packet, addr)
-}
-
-func (c *socksUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
-	n, a, e := c.PacketConn.ReadFrom(b)
-	if e != nil {
-		return 0, nil, e
-	}
-	addr, payload, err := socks.DecodeUDPPacket(b)
-	if err != nil {
-		return 0, nil, err
-	}
-	copy(b, payload)
-	return n - len(addr) - 3, a, nil
-}
-
-func (c *socksUDPConn) Close() error {
-	c.tcpConn.Close()
-	return c.PacketConn.Close()
-}