You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Victorique/vtqe/tools/net.go

800 lines
19 KiB
Go

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

package tools
import (
"fmt"
"io"
"net"
"strconv"
"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
}
}()
go func() {
if isconn {
buf := make([]byte, 7)
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 {
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("链接已加入等待列表")
tcpnats := tcpnat{Msg: buf, 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
}
}
}