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/net.go

807 lines
19 KiB
Go

4 years ago
package main
import (
"fmt"
"io"
"net"
"strconv"
"strings"
"time"
"github.com/spf13/cobra"
)
func init() {
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
}
}
}