Victorique/vtqe/tools/net.go

package tools

import (
	"fmt"
	"io"
	"net"
	"strconv"
	"strings"
	"time"

	"github.com/spf13/cobra"
)

func init() {
	Maincmd.AddCommand(netcmd)
	netcmd.AddCommand(netforwardcmd, natscmd, natccmd)
	netforwardcmd.Flags().BoolP("tcp", "t", false, "TCP转发")
	netforwardcmd.Flags().BoolP("udp", "u", false, "UDP转发")
	netforwardcmd.Flags().IntP("port", "p", 1127, "转发本地端口")
	netforwardcmd.Flags().StringP("address", "a", "0.0.0.0", "监听地址")

	natscmd.Flags().BoolP("tcp", "t", false, "TCP穿透")
	natscmd.Flags().BoolP("udp", "u", false, "UDP穿透")
	natscmd.Flags().IntP("port", "p", 1127, "监听本地端口开始点")
	natscmd.Flags().StringP("key", "k", "sakura", "认证密码")
	natscmd.Flags().StringP("address", "a", "0.0.0.0", "监听本地地址")
	natscmd.Flags().IntP("number", "n", 1, "监听端口数量")

	natccmd.Flags().BoolP("tcp", "t", false, "TCP穿透")
	natccmd.Flags().BoolP("udp", "u", false, "UDP穿透")
	natccmd.Flags().IntP("port", "p", 1127, "转发穿透端口")
	natccmd.Flags().StringP("key", "k", "sakura", "认证密码")
	natccmd.Flags().StringP("address", "a", "127.0.0.1", "转发穿透地址")
}

var netcmd = &cobra.Command{
	Use:   "net",
	Short: "端口转发，穿透相关",
	Long:  "端口转发，穿透相关",
}

var netforwardcmd = &cobra.Command{
	Use:   "forward",
	Short: "TCP/UDP端口转发",
	Long:  "TCP/UDP端口转发",
	Run: func(cmd *cobra.Command, args []string) {
		t, _ := cmd.Flags().GetBool("tcp")
		u, _ := cmd.Flags().GetBool("udp")
		p, _ := cmd.Flags().GetInt("port")
		a, _ := cmd.Flags().GetString("address")
		if len(args) != 1 {
			cmd.Help()
			return
		}
		ra := args[0]
		if !t && !u {
			fmt.Println("请指定TCP或UDP协议")
			return
		}

		localtcp, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p))
		if err != nil {
			fmt.Println(err)
			return
		}
		remotetcp, err := net.ResolveTCPAddr("tcp", ra)
		if err != nil {
			fmt.Println(err)
			return
		}
		localudp, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p))
		remoteudp, _ := net.ResolveUDPAddr("udp", ra)
		if u {
			go UdpForward(localudp, remoteudp)
		}
		if t {
			go TcpForward(localtcp, remotetcp)
		}

		for {
			time.Sleep(time.Second * 100)
		}
	},
}

var natscmd = &cobra.Command{
	Use:   "nats",
	Short: "TCP/UDP内网穿透服务端",
	Long:  "TCP/UDP内网穿透服务端",
	Run: func(cmd *cobra.Command, args []string) {
		t, _ := cmd.Flags().GetBool("tcp")
		u, _ := cmd.Flags().GetBool("udp")
		p, _ := cmd.Flags().GetInt("port")
		k, _ := cmd.Flags().GetString("key")
		a, _ := cmd.Flags().GetString("address")
		n, _ := cmd.Flags().GetInt("number")
		/*udplocal, err := net.ResolveUDPAddr("udp", a+":"+p)
		if err != nil {
			fmt.Println(err)
			return
		}
		*/
		for i := 0; i < n; i++ {
			tcplocal, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p+i))
			if err != nil {
				fmt.Println(err)
				return
			}
			udplocal, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p+i))
			if !t && !u {
				fmt.Println("请至少指定一种网络协议！")
				return
			}
			if t {
				go TcpNatServer(tcplocal, k)
			}
			if u {
				go UdpNatServer(udplocal, k)
			}
		}
		for {
			time.Sleep(time.Second * 10)
		}
	},
}

var natccmd = &cobra.Command{
	Use:   "natc",
	Short: "TCP/UDP内网穿透客户端",
	Long:  "TCP/UDP内网穿透客户端",
	Run: func(cmd *cobra.Command, args []string) {
		t, _ := cmd.Flags().GetBool("tcp")
		u, _ := cmd.Flags().GetBool("udp")
		p, _ := cmd.Flags().GetInt("port")
		k, _ := cmd.Flags().GetString("key")
		a, _ := cmd.Flags().GetString("address")
		/*udplocal, err := net.ResolveUDPAddr("udp", a+":"+p)
		if err != nil {
			fmt.Println(err)
			return
		}
		*/
		if len(args) != 1 {
			cmd.Help()
			return
		}
		if !t && !u {
			fmt.Println("请至少指定一种网络协议！")
			return
		}
		tcprmt, err := net.ResolveTCPAddr("tcp", args[0])
		if err != nil {
			fmt.Println(err)
			return
		}
		tcpforward, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p))
		if err != nil {
			fmt.Println(err)
			return
		}
		udprmt, _ := net.ResolveUDPAddr("udp", args[0])
		udpforward, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p))
		if t {
			go TcpNatClient(tcprmt, tcpforward, k)
		}
		if u {
			go UdpNatClient(udprmt, udpforward, k)
		}
		for {
			time.Sleep(time.Second * 10)
		}
	},
}

type tcpnat struct {
	Conn *net.TCPConn
	Msg  []byte
	Date int64
}

func UdpNatClient(udpremote, udpforward *net.UDPAddr, pwd string) {
	var trueconn *net.UDPConn
	var err error
	ismain := false
	var lastcheck int64
	dialudp := func(udpaddr *net.UDPAddr) (*net.UDPConn, error) {
		trueconn, err := net.DialUDP("udp", nil, udpaddr)
		if err != nil {
			return nil, err
		}
		return trueconn, nil
	}
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("PANIC:", err)
		}
	}()
	for {
		trueconn, err = dialudp(udpremote)
		if err != nil || trueconn == nil {
			time.Sleep(5 * time.Second)
			fmt.Println(err)
			continue
		}
		fmt.Println("UDP远端服务器连接成功" + trueconn.RemoteAddr().String())
		trueconn.Write([]byte(pwd))
		go func() {
			for !ismain {
				time.Sleep(time.Second * 2)
				if trueconn != nil {
					if ismain {
						return
					}
					_, err := trueconn.Write([]byte(pwd))
					if err != nil {
						fmt.Println(err)
						return
					}
				}
			}
		}()
		go func() {
			for {
				if trueconn == nil {
					break
				}
				var conn1, conn2 *net.UDPConn
				buf := make([]byte, 7)
				n, err := trueconn.Read(buf)
				if n != 7 || err != nil {
					fmt.Println(err)
					trueconn = nil
					ismain = false
					fmt.Println("UDP下线01")
					break
				}
				switch string(buf) {
				case "yesyesi":
					ismain = true
					fmt.Println("UDP主节点认证成功")
					lastcheck = time.Now().Unix()
					go func() {
						for {
							time.Sleep(time.Second * 2)
							if time.Now().Unix()-lastcheck > 4 {
								ismain = false
								trueconn = nil
								fmt.Println("UDP下线02")
								return
							}
						}
					}()
				case "vicregs":
					if trueconn != nil {
						trueconn.Write([]byte("vicregs"))
					}
					lastcheck = time.Now().Unix()
				case "newconn":
					if !ismain {
						trueconn.Close()
						break
					}
					for conn1, err = dialudp(udpforward); err != nil; conn1, err = dialudp(udpforward) {
						time.Sleep(time.Second * 2)
					}
					fmt.Println("UDP已连接转发远端：" + conn1.RemoteAddr().String())
					for conn2, err = dialudp(udpremote); err != nil; conn2, err = dialudp(udpremote) {
						time.Sleep(time.Second * 2)
					}
					conn2.Write([]byte("v%2^f&K"))
					fmt.Println("UDP已连接主控远端：" + conn2.RemoteAddr().String())
					go UdpCopy(conn1, conn2)
					go UdpCopy(conn2, conn1)
				}
			}
		}()
		for ismain || trueconn != nil {
			time.Sleep(time.Second * 4)
		}
		ismain = false
	}
}

func TcpNatClient(tcpremote, tcpforward *net.TCPAddr, pwd string) {
	var trueconn *net.TCPConn
	var err error
	ismain := false
	var lastcheck int64
	dialtcp := func(tcpaddr *net.TCPAddr) (*net.TCPConn, error) {
		trueconn, err := net.DialTCP("tcp", nil, tcpaddr)
		if err != nil {
			return nil, err
		}
		return trueconn, nil
	}
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("PANIC:", err)
		}
	}()
	for {
		trueconn, err = dialtcp(tcpremote)
		if err != nil || trueconn == nil {
			fmt.Println(err)
			time.Sleep(5 * time.Second)
			continue
		}
		fmt.Println("TCP远端服务器连接成功" + trueconn.RemoteAddr().String())
		n, err := trueconn.Write([]byte(pwd))
		if err != nil || n == 0 {
			fmt.Println(err)
			continue
		}
		go func() {
			for {
				time.Sleep(time.Second * 2)
				if !ismain {
					if trueconn != nil {
						_, err := trueconn.Write([]byte(pwd))
						if err != nil {
							return
						}
					} else {
						return
					}
				} else {
					return
				}
			}
		}()
		go func() {
			for {
				if trueconn == nil {
					break
				}
				var conn1, conn2 *net.TCPConn
				buf := make([]byte, 7)
				n, err := trueconn.Read(buf)
				if n != 7 || err != nil {
					fmt.Println("TCP下线01")
					fmt.Println(err)
					trueconn = nil
					ismain = false
					break
				}
				switch string(buf) {
				case "yesyesi":
					ismain = true
					fmt.Println("TCP主节点认证成功")
					lastcheck = time.Now().Unix()
					go func() {
						for {
							time.Sleep(time.Second)
							if time.Now().Unix()-lastcheck > 4 {
								fmt.Println("TCP下线02")
								ismain = false
								trueconn = nil
								return
							}
						}
					}()
				case "vicb612":
					lastcheck = time.Now().Unix()
					if trueconn != nil {
						trueconn.Write([]byte("vicb612"))
					}
				case "newconn":
					if !ismain {
						trueconn.Close()
						trueconn = nil
						fmt.Println("TCP下线03")
						break
					}
					for conn1, err = dialtcp(tcpforward); err != nil; conn1, err = dialtcp(tcpforward) {
						time.Sleep(time.Second * 2)
					}
					fmt.Println("TCP已连接转发远端：" + conn1.RemoteAddr().String())
					for conn2, err = dialtcp(tcpremote); err != nil; conn2, err = dialtcp(tcpremote) {
						time.Sleep(time.Second * 2)
					}
					conn2.Write([]byte("v%2^f&K"))
					fmt.Println("TCP已连接主控远端：" + conn2.RemoteAddr().String())
					go TcpCopy(conn1, conn2)
					go TcpCopy(conn2, conn1)
				}
			}
		}()
		for ismain || trueconn != nil {
			time.Sleep(time.Second * 4)
		}
		ismain = false

	}
}

func TcpCopy3(dst net.Conn, src *net.TCPConn) {
	defer dst.Close()
	defer src.Close()
	io.Copy(dst, src)
}

func TcpCopy2(dst *net.TCPConn, src net.Conn) {
	defer src.Close()
	defer dst.Close()
	io.Copy(dst, src)
}

func TcpCopy(dst, src *net.TCPConn) {
	defer dst.Close()
	defer src.Close()
	io.Copy(dst, src)
}

func UdpCopy(dst, src *net.UDPConn) {
	defer dst.Close()
	defer src.Close()
	for {
		buf := make([]byte, 131072)
		n, err := src.Read(buf)
		dst.Write(buf[0:n])
		if err != nil {
			fmt.Println(err)
			break
		}
	}
}

type udpnat struct {
	Conn      *net.UDPAddr
	Msg       []byte
	Married   bool
	LastTrans int64
}

func UdpNatServer(udplocal *net.UDPAddr, pwd string) {
	var trueconn *net.UDPAddr
	isconn := false
	var lastcheck int64
	udplistener, err := net.ListenUDP("udp", udplocal)
	defer udplistener.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	udpconnlist := []string{}
	udpool := make(map[string]*udpnat)
	udpdial := make(map[string]*net.UDPAddr)
	fmt.Println("UDP已建立监听：" + udplistener.LocalAddr().String())
	removeudplist := func(str string) {
		var tmp []string
		for _, v := range udpconnlist {
			if v != str {
				tmp = append(tmp, str)
			}
		}
		udpconnlist = tmp
	}
	go func() {
		for {
			time.Sleep(time.Second * 20)
			pool := []string{}
			for k, v := range udpool {
				if time.Now().Unix()-v.LastTrans > 30 {
					pool = append(pool, k)
				}
			}
			for _, v := range pool {
				if udpool[v].Married {
					delete(udpdial, udpool[v].Conn.String())
				} else {
					removeudplist(v)
				}
				delete(udpool, v)
			}
		}
	}()
	for {
		buf := make([]byte, 131072)
		n, conn, errp := udplistener.ReadFromUDP(buf)
		go func() {
			if !isconn {
				if errp != nil {
					return
				}
				if string(buf[0:len(pwd)]) == pwd && n == len(pwd) {
					isconn = true
					trueconn = conn
					udplistener.WriteToUDP([]byte("yesyesi"), trueconn)
					fmt.Println("UDP穿透客户端已注册")
					udpool = make(map[string]*udpnat)
					udpdial = make(map[string]*net.UDPAddr)
					udpconnlist = []string{}
					lastcheck = time.Now().Unix()
					go func() {
						for {
							time.Sleep(time.Second * 2)
							go udplistener.WriteToUDP([]byte("vicregs"), trueconn)
							if time.Now().Unix()-lastcheck > 6 {
								fmt.Println("UDP穿透客户端已下线")
								fmt.Println("UDP下线01")
								isconn = false
								break
							}
						}
					}()
				}
			} else {
				if string(buf[0:7]) == "vicregs" {
					lastcheck = time.Now().Unix()
					return
				}
				if string(buf[0:7]) == "v%2^f&K" {
					fmt.Println("穿透客户端已建立新连接")
					if len(udpconnlist) != 0 {
						if v, ok := udpool[udpconnlist[0]]; ok {
							if !v.Married {
								v.Conn = conn
								udplistener.WriteToUDP(v.Msg, conn)
								v.Msg = []byte{}
								udpaddr, _ := net.ResolveUDPAddr("udp", udpconnlist[0])
								udpdial[conn.String()] = udpaddr
								v.Married = true
							}
						}
						if len(udpconnlist) == 1 {
							udpconnlist = []string{}
						} else {
							udpconnlist = udpconnlist[1:]
						}
					}
					return
				} else {
					if v, ok := udpool[conn.String()]; ok {
						if !v.Married {
							for i := 0; i < n; i++ {
								v.Msg = append(v.Msg, buf[i])
							}
							if len(v.Msg) > 10485760 {
								v.Msg = []byte{}
							}
						} else {
							_, err := udplistener.WriteToUDP(buf[0:n], v.Conn)
							v.LastTrans = time.Now().Unix()
							if errp != nil || err != nil {
								fmt.Println(errp, err)
								udplistener.WriteToUDP(nil, v.Conn)
								udplistener.WriteToUDP(nil, conn)
								delete(udpool, conn.String())
								delete(udpdial, v.Conn.String())
								return
							}
						}
						return
					}
					if v, ok := udpdial[conn.String()]; ok {
						_, err := udplistener.WriteToUDP(buf[0:n], v)
						udpool[v.String()].LastTrans = time.Now().Unix()
						if errp != nil || err != nil {
							fmt.Println(errp, err)
							udplistener.WriteToUDP(nil, v)
							udplistener.WriteToUDP(nil, conn)
							delete(udpool, v.String())
							delete(udpdial, conn.String())
							return
						}
						return
					}
					fmt.Println("链接已加入等待列表")
					udpool[conn.String()] = &udpnat{
						Msg:       buf[0:n],
						Married:   false,
						LastTrans: time.Now().Unix(),
					}
					udpconnlist = append(udpconnlist, conn.String())
					_, err := udplistener.WriteToUDP([]byte("newconn"), trueconn)
					if err != nil {
						fmt.Println("UDP穿透客户端已下线")
						fmt.Println("UDP下线02")
						isconn = false
					}
				}
			}
		}()
	}
	fmt.Println("执行完毕")
}

func TcpNatServer(tcplocal *net.TCPAddr, pwd string) {
	var trueconn *net.TCPConn
	lastcheck := int64(0)
	isconn := false
	tcplistener, err := net.ListenTCP("tcp", tcplocal)
	defer tcplistener.Close()
	var waitconn []tcpnat
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("TCP已建立监听：" + tcplistener.Addr().String())
	for {
		conn, err := tcplistener.AcceptTCP()
		if err != nil {
			return
		}
		go func() {
			for {
				now := time.Now().Unix()
				if len(waitconn) != 0 {
					if now-waitconn[0].Date > 8 {
						waitconn[0].Conn.Close()
						if len(waitconn) > 1 {
							waitconn = waitconn[1:]
						} else {
							waitconn = []tcpnat{}
						}
					}
				}
				time.Sleep(time.Second * 2)
			}
		}()
		go func() {
			if !isconn {
				buf := make([]byte, len(pwd)+1)
				n, err := conn.Read(buf)
				if n != len(pwd) || err != nil {
					conn.Close()
					return
				}
				if string(buf[0:len(pwd)]) == pwd {
					isconn = true
					trueconn = conn
					conn.Write([]byte("yesyesi"))
					fmt.Println("TCP穿透客户端已注册")
					lastcheck = time.Now().Unix()
					go func() {
						for isconn && trueconn != nil {
							buf := make([]byte, 7)
							n, err := trueconn.Read(buf)
							if n != 7 || err != nil {
								isconn = false
								trueconn = nil
								return
							}
							if string(buf) == "vicb612" {
								lastcheck = time.Now().Unix()
							}
						}
					}()
					go func() {
						for {
							time.Sleep(time.Second * 2)
							if trueconn != nil {
								_, err := trueconn.Write([]byte("vicb612"))
								if err != nil {
									trueconn.Close()
									trueconn = nil
									isconn = false
									fmt.Println("TCP下线01")
									return
								}
							}
							if time.Now().Unix()-lastcheck > 4 {
								fmt.Println("TCP下线02")
								trueconn = nil
								isconn = false
								return
							}
						}
					}()
				}
				return
			} else {
				isRun := false
				buf := make([]byte, 7)
				if strings.Split(conn.RemoteAddr().String(), ":")[0] == strings.Split(trueconn.RemoteAddr().String(), ":")[0] {
					isRun = true
					n, err := conn.Read(buf)
					if n != 7 || err != nil {
						conn.Close()
						return
					}
				}
				if string(buf) == "v%2^f&K" {
					fmt.Println("穿透客户端已建立新连接")
					if len(waitconn) != 0 {
						if waitconn[0].Msg != nil {
							conn.Write(waitconn[0].Msg)
						}
						waitconn[0].Msg = []byte{}
						go TcpCopy(waitconn[0].Conn, conn)
						go TcpCopy(conn, waitconn[0].Conn)
						if len(waitconn) > 1 {
							waitconn = waitconn[1:]
						} else {
							waitconn = []tcpnat{}
						}
					} else {
						conn.Close()
					}
				} else {
					fmt.Println("链接已加入等待列表")
					var tcpnats tcpnat
					if isRun {
						tcpnats = tcpnat{Msg: buf, Conn: conn, Date: time.Now().Unix()}
					} else {
						tcpnats = tcpnat{Msg: nil, Conn: conn, Date: time.Now().Unix()}
					}
					waitconn = append(waitconn, tcpnats)
					if trueconn == nil {
						isconn = false
						fmt.Println("TCP下线04")
						return
					}
					_, err := trueconn.Write([]byte("newconn"))
					if err != nil {
						fmt.Println("穿透客户端已下线")
						fmt.Println("TCP下线03")
						trueconn.Close()
						trueconn = nil
						isconn = false
					}
				}
			}
		}()
	}

}

func TcpForward(tcplocal, tcpforward *net.TCPAddr) {
	tcplistener, err := net.ListenTCP("tcp", tcplocal)
	if err != nil {
		fmt.Println(err)
		return
	}
	dialtcp := func() (*net.Conn, error) {
		tcpclient, err := net.DialTimeout("tcp", tcpforward.String(), time.Second*10)
		if err != nil {
			return nil, err
		}
		return &tcpclient, nil
	}
	fmt.Println("TCP监听已建立：" + tcplocal.String())
	for {
		conn, err := tcplistener.AcceptTCP()
		if err != nil {
			continue
		}
		fmt.Println(conn.RemoteAddr().String() + " 已连接")
		tcpclient, err := dialtcp()
		if err != nil {
			fmt.Println(err)
			conn.Write([]byte("Dial To Remote Addr Error"))
			conn.Close()
			continue
		}
		fmt.Println("成功连接到转发端口，本地端口：" + (*tcpclient).LocalAddr().String())
		go TcpCopy2(conn, *tcpclient)
		go TcpCopy3(*tcpclient, conn)
	}
}

func UdpForward(udplocal, udpforward *net.UDPAddr) {
	udplistener, err := net.ListenUDP("udp", udplocal)
	if err != nil {
		fmt.Println(err)
		return
	}
	dialudp := func() (*net.UDPConn, error) {
		udpclient, err := net.DialUDP("udp", nil, udpforward)
		if err != nil {
			return nil, err
		}
		return udpclient, nil
	}
	fmt.Println("UDP监听已建立：" + udplocal.String())
	udppool := make(map[string]*net.UDPConn)
	for {
		buf := make([]byte, 131072)
		n, conn, err := udplistener.ReadFromUDP(buf)
		udpclient, ok := udppool[conn.String()]
		if !ok || udpclient == nil {
			fmt.Println(conn.String() + " 已连接")
			udpclient, err = dialudp()
			if err != nil {
				fmt.Println(err)
				udplistener.WriteToUDP([]byte("Dial To Remote Addr Error"), conn)
				continue
			}
			udppool[conn.String()] = udpclient
			fmt.Println("成功连接到转发端口，本地端口：" + udpclient.LocalAddr().String())
		}
		go udpclient.Write(buf[0:n])
		go func(conns *net.UDPAddr, udpclient *net.UDPConn) {
			bufs := make([]byte, 131072)
			n, err := udpclient.Read(bufs)
			udplistener.WriteToUDP(bufs[0:n], conns)
			if err != nil {
				udpclient.Close()
				udppool[conn.String()] = nil
			}
		}(conn, udpclient)
		if err != nil {
			udpclient.Close()
			udppool[conn.String()] = nil
		}
	}
}