root/gost_software
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add udp connect for udp port forwarding

Browse Source
This commit is contained in:
rui.zheng 2016-09-14 12:51:47 +08:00
parent f2de67f8c1
commit 3a1ea87c31
5 changed files with 218 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -130,7 +130,7 @@ gost -L=rtcp://:2222/192.168.1.1:22 -F=... -F=socks://172.24.10.1:1080
``` ```
将172.24.10.1:2222上的数据(通过转发链)转发到192.168.1.1:22上。 将172.24.10.1:2222上的数据(通过转发链)转发到192.168.1.1:22上。
#### 远程端口转发(UDP #### 远程端口转发(UDP)
```bash ```bash
gost -L=rudp://:5353/192.168.1.1:53 -F=... -F=socks://172.24.10.1:1080 gost -L=rudp://:5353/192.168.1.1:53 -F=... -F=socks://172.24.10.1:1080
@ -182,7 +182,7 @@ gost -L=:8080 -F=ss://aes-128-cfb:123456@server_ip:8338
``` ```
#### TLS #### TLS
gost内置了tls证书，如果需要使用其他tls证书，在gost目录放置cert.pem(公钥)和key.pem(私钥)两个文件即可。 gost内置了tls证书，如果需要使用其他tls证书，在gost运行目录放置cert.pem(公钥)和key.pem(私钥)两个文件即可。
SOCKS5 UDP数据处理 SOCKS5 UDP数据处理
@ -201,7 +201,7 @@ gost作为标准socks5代理处理UDP数据
<img src="https://ginuerzh.github.io/images/udp03.png" height=200 /> <img src="https://ginuerzh.github.io/images/udp03.png" height=200 />
当设置转发代理时，gost会使用UDP-Over-TCP方式转发UDP数据。proxy1 - proxyN可以为任意http(s)/socks5/shadowsocks类型代理。 当设置转发代理时，gost会使用UDP-over-TCP方式转发UDP数据。proxy1 - proxyN可以为任意http(s)/socks5/shadowsocks类型代理。
限制条件 限制条件
------ ------

104
conn.go
View File

@ -76,10 +76,12 @@ func listenAndServe(arg Args) error {
glog.V(LWARNING).Infoln(err) glog.V(LWARNING).Infoln(err)
continue continue
} }
if tc, ok := conn.(*net.TCPConn); ok { if tc, ok := conn.(*net.TCPConn); ok {
tc.SetKeepAlive(true) tc.SetKeepAlive(true)
tc.SetKeepAlivePeriod(time.Second * 180) tc.SetKeepAlivePeriod(time.Second * 180)
} }
go handleConn(conn, arg) go handleConn(conn, arg)
} }
} }
@ -91,15 +93,48 @@ func listenAndServeTcpForward(arg Args) error {
} }
defer ln.Close() defer ln.Close()
raddr, err := net.ResolveTCPAddr("tcp", arg.Remote)
if err != nil {
return err
}
for { for {
conn, err := ln.Accept() conn, err := ln.Accept()
if err != nil { if err != nil {
glog.V(LWARNING).Infoln(err) glog.V(LWARNING).Infoln(err)
continue continue
} }
go handleTcpForward(conn, arg) go handleTcpForward(conn, raddr)
} }
return nil }
func prepareUdpConnectTunnel(addr net.Addr) (net.Conn, error) {
conn, _, err := forwardChain(forwardArgs...)
if err != nil {
return nil, err
}
conn.SetWriteDeadline(time.Now().Add(time.Second * 90))
if err = gosocks5.NewRequest(CmdUdpConnect, ToSocksAddr(addr)).Write(conn); err != nil {
conn.Close()
return nil, err
}
conn.SetWriteDeadline(time.Time{})
conn.SetReadDeadline(time.Now().Add(90 * time.Second))
reply, err := gosocks5.ReadReply(conn)
if err != nil {
conn.Close()
return nil, err
}
conn.SetReadDeadline(time.Time{})
if reply.Rep != gosocks5.Succeeded {
conn.Close()
return nil, errors.New("udp connect failure")
}
return conn, nil
} }
func listenAndServeUdpForward(arg Args) error { func listenAndServeUdpForward(arg Args) error {
@ -107,24 +142,61 @@ func listenAndServeUdpForward(arg Args) error {
if err != nil { if err != nil {
return err return err
} }
ln, err := net.ListenUDP("udp", laddr)
raddr, err := net.ResolveUDPAddr("udp", arg.Remote)
if err != nil { if err != nil {
return err return err
} }
defer ln.Close()
for {
var conn *net.UDPConn
for {
conn, err = net.ListenUDP("udp", laddr)
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
time.Sleep((1) * time.Second)
continue
}
break
}
if len(forwardArgs) == 0 {
defer conn.Close()
for { for {
b := udpPool.Get().([]byte) b := udpPool.Get().([]byte)
n, raddr, err := ln.ReadFromUDP(b) n, addr, err := conn.ReadFromUDP(b)
if err != nil { if err != nil {
glog.V(LWARNING).Infoln(err) glog.V(LWARNING).Infoln(err)
continue continue
} }
go func(data []byte, length int) { go func() {
handleUdpForward(ln, raddr, data[:length], arg) handleUdpForwardLocal(conn, addr, raddr, b[:n])
udpPool.Put(data) udpPool.Put(b)
}(b, n) }()
}
}
var tun net.Conn
retry := 0
for {
tun, err = prepareUdpConnectTunnel(raddr)
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
time.Sleep((1 << uint(retry)) * time.Second)
if retry < 5 {
retry++
}
continue
}
break
}
glog.V(LWARNING).Infof("[udp-connect] %s <-> %s : %s", laddr, raddr)
tunnelUDP(conn, tun, false)
glog.V(LWARNING).Infof("[udp-connect] %s >-< %s : %s", laddr, raddr)
conn.Close()
} }
} }
@ -179,19 +251,6 @@ func serveRUdpForward(arg Args) error {
} }
func handleConn(conn net.Conn, arg Args) { func handleConn(conn net.Conn, arg Args) {
/*
atomic.AddInt32(&connCounter, 1)
glog.V(LDEBUG).Infof("%s connected, connections: %d",
conn.RemoteAddr(), atomic.LoadInt32(&connCounter))
if glog.V(LDEBUG) {
defer func() {
glog.Infof("%s disconnected, connections: %d",
conn.RemoteAddr(), atomic.LoadInt32(&connCounter))
}()
}
defer atomic.AddInt32(&connCounter, -1)
*/
defer conn.Close() defer conn.Close()
// socks5 server supported methods // socks5 server supported methods
@ -335,6 +394,7 @@ func forwardChain(chain ...Args) (conn net.Conn, end Args, err error) {
if conn, err = net.DialTimeout("tcp", end.Addr, time.Second*90); err != nil { if conn, err = net.DialTimeout("tcp", end.Addr, time.Second*90); err != nil {
return return
} }
tc := conn.(*net.TCPConn) tc := conn.(*net.TCPConn)
tc.SetKeepAlive(true) tc.SetKeepAlive(true)
tc.SetKeepAlivePeriod(time.Second * 180) // 3min tc.SetKeepAlivePeriod(time.Second * 180) // 3min

47
forward.go
View File

@ -10,23 +10,50 @@ import (
"time" "time"
) )
func handleTcpForward(conn net.Conn, arg Args) { func handleTcpForward(conn net.Conn, raddr net.Addr) {
defer conn.Close() defer conn.Close()
if !strings.Contains(arg.Remote, ":") { glog.V(LINFO).Infof("[tcp-forward] %s - %s", conn.RemoteAddr(), raddr)
arg.Remote += ":22" // default is ssh service c, err := Connect(raddr.String())
}
glog.V(LINFO).Infof("[tcp-forward] %s - %s", conn.RemoteAddr(), arg.Remote)
c, err := Connect(arg.Remote)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[tcp-forward] %s -> %s : %s", conn.RemoteAddr(), arg.Remote, err) glog.V(LWARNING).Infof("[tcp-forward] %s -> %s : %s", conn.RemoteAddr(), raddr, err)
return return
} }
defer c.Close() defer c.Close()
glog.V(LINFO).Infof("[tcp-forward] %s <-> %s", conn.RemoteAddr(), arg.Remote) glog.V(LINFO).Infof("[tcp-forward] %s <-> %s", conn.RemoteAddr(), raddr)
Transport(conn, c) Transport(conn, c)
glog.V(LINFO).Infof("[tcp-forward] %s >-< %s", conn.RemoteAddr(), arg.Remote) glog.V(LINFO).Infof("[tcp-forward] %s >-< %s", conn.RemoteAddr(), raddr)
}
func handleUdpForwardLocal(conn *net.UDPConn, laddr, raddr *net.UDPAddr, data []byte) {
lconn, err := net.ListenUDP("udp", nil)
if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", laddr, raddr, err)
return
}
defer lconn.Close()
if _, err := lconn.WriteToUDP(data, raddr); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", laddr, raddr, err)
return
}
glog.V(LDEBUG).Infof("[udp-forward] %s >>> %s length %d", laddr, raddr, len(data))
b := udpPool.Get().([]byte)
defer udpPool.Put(b)
lconn.SetReadDeadline(time.Now().Add(time.Second * 60))
n, addr, err := lconn.ReadFromUDP(b)
if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", laddr, raddr, err)
return
}
glog.V(LDEBUG).Infof("[udp-forward] %s <<< %s length %d", laddr, addr, n)
if _, err := conn.WriteToUDP(b[:n], laddr); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", laddr, raddr, err)
}
return
} }
func handleUdpForward(conn *net.UDPConn, raddr *net.UDPAddr, data []byte, arg Args) { func handleUdpForward(conn *net.UDPConn, raddr *net.UDPAddr, data []byte, arg Args) {
@ -141,7 +168,7 @@ func connectRTcpForward(conn net.Conn, arg Args) error {
req := gosocks5.NewRequest(gosocks5.CmdBind, ToSocksAddr(addr)) req := gosocks5.NewRequest(gosocks5.CmdBind, ToSocksAddr(addr))
bindAddr := req.Addr bindAddr := req.Addr
if err := req.Write(conn); err != nil { if err := req.Write(conn); err != nil {
glog.V(LWARNING).Infof("[rtcp] %s <- %s : %s", bindAddr, arg.Remote, err) glog.V(LWARNING).Infof("[rtcp] %s -> %s : %s", bindAddr, arg.Remote, err)
return err return err
} }

90
socks.go
View File

@ -21,7 +21,8 @@ const (
) )
const ( const (
CmdUdpTun uint8 = 0xf3 // extended method for udp over tcp CmdUdpConnect uint8 = 0xF1 // extended method for udp local port forwarding
CmdUdpTun uint8 = 0xF3 // extended method for udp over tcp
) )
type clientSelector struct { type clientSelector struct {
@ -218,6 +219,10 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
Transport(conn, fconn) Transport(conn, fconn)
glog.V(LINFO).Infof("[socks5-bind] %s >-< %s", conn.RemoteAddr(), fconn.RemoteAddr()) glog.V(LINFO).Infof("[socks5-bind] %s >-< %s", conn.RemoteAddr(), fconn.RemoteAddr())
case CmdUdpConnect:
glog.V(LINFO).Infof("[udp-connect] %s - %s", conn.RemoteAddr(), req.Addr)
udpConnect(req, conn)
case gosocks5.CmdUdp: case gosocks5.CmdUdp:
glog.V(LINFO).Infof("[socks5-udp] %s - %s", conn.RemoteAddr(), req.Addr) glog.V(LINFO).Infof("[socks5-udp] %s - %s", conn.RemoteAddr(), req.Addr)
socks5UDP(req, conn) socks5UDP(req, conn)
@ -240,6 +245,87 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
} }
} }
func udpConnect(req *gosocks5.Request, conn net.Conn) error {
if len(forwardArgs) > 0 { // direct forwarding
fconn, _, err := forwardChain(forwardArgs...)
if err != nil {
glog.V(LINFO).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), req.Addr, err)
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
defer fconn.Close()
if err := req.Write(fconn); err != nil {
glog.V(LINFO).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), req.Addr, err)
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
glog.V(LINFO).Infof("[udp-connect] %s <-> %s", conn.RemoteAddr(), req.Addr)
err = Transport(conn, fconn)
glog.V(LINFO).Infof("[udp-connect] %s >-< %s", conn.RemoteAddr(), req.Addr)
return err
}
raddr, err := net.ResolveUDPAddr("udp", req.Addr.String())
if err != nil {
glog.V(LINFO).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), req.Addr, err)
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
if err := gosocks5.NewReply(gosocks5.Succeeded, nil).Write(conn); err != nil {
glog.V(LINFO).Infof("[udp-connect] %s <- %s : %s", conn.RemoteAddr(), req.Addr, err)
return err
}
glog.V(LINFO).Infof("[udp-connect] %s <-> %s", conn.RemoteAddr(), raddr)
defer glog.V(LINFO).Infof("[udp-connect] %s >-< %s", conn.RemoteAddr(), raddr)
for {
dgram, err := gosocks5.ReadUDPDatagram(conn)
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), req.Addr, err)
return err
}
go func() {
b := udpPool.Get().([]byte)
defer udpPool.Put(b)
relay, err := net.DialUDP("udp", nil, raddr)
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), raddr, err)
return
}
defer relay.Close()
if _, err := relay.Write(dgram.Data); err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", conn.RemoteAddr(), raddr, err)
return
}
glog.V(LDEBUG).Infof("[udp-connect] %s >>> %s length: %d", conn.RemoteAddr(), raddr, len(dgram.Data))
relay.SetReadDeadline(time.Now().Add(time.Second * 60))
n, err := relay.Read(b)
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s <- %s : %s", conn.RemoteAddr(), raddr, err)
return
}
relay.SetReadDeadline(time.Time{})
glog.V(LDEBUG).Infof("[udp-connect] %s <<< %s length: %d", conn.RemoteAddr(), raddr, n)
conn.SetWriteDeadline(time.Now().Add(time.Second * 90))
if err := gosocks5.NewUDPDatagram(gosocks5.NewUDPHeader(uint16(n), 0, dgram.Header.Addr), b[:n]).Write(conn); err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s <- %s : %s", conn.RemoteAddr(), raddr, err)
return
}
conn.SetWriteDeadline(time.Time{})
}()
}
}
func socks5UDP(req *gosocks5.Request, conn net.Conn) error { func socks5UDP(req *gosocks5.Request, conn net.Conn) error {
bindAddr, _ := net.ResolveUDPAddr("udp", req.Addr.String()) bindAddr, _ := net.ResolveUDPAddr("udp", req.Addr.String())
relay, err := net.ListenUDP("udp", bindAddr) // udp associate, strict mode: if the port already in use, it will return error relay, err := net.ListenUDP("udp", bindAddr) // udp associate, strict mode: if the port already in use, it will return error
@ -319,7 +405,7 @@ func socks5UDP(req *gosocks5.Request, conn net.Conn) error {
} }
func socks5TunnelUDP(req *gosocks5.Request, conn net.Conn) error { func socks5TunnelUDP(req *gosocks5.Request, conn net.Conn) error {
if len(forwardArgs) > 0 { // tunnel -> tunnel, direct forward if len(forwardArgs) > 0 { // tunnel -> tunnel, direct forwarding
tun, _, err := forwardChain(forwardArgs...) tun, _, err := forwardChain(forwardArgs...)
if err != nil { if err != nil {
return err return err

8
udp.go
View File

@ -111,7 +111,7 @@ func tunnelUDP(conn *net.UDPConn, tun net.Conn, client bool) (err error) {
rChan <- err rChan <- err
return return
} }
glog.V(LDEBUG).Infof("[socks5-udp] %s >>> %s length: %d", conn.LocalAddr(), dgram.Header.Addr, len(dgram.Data)) glog.V(LDEBUG).Infof("[udp-tun] %s >>> %s length: %d", conn.LocalAddr(), dgram.Header.Addr, len(dgram.Data))
} else { // pipe from peer to tunnel } else { // pipe from peer to tunnel
dgram = gosocks5.NewUDPDatagram( dgram = gosocks5.NewUDPDatagram(
gosocks5.NewUDPHeader(uint16(n), 0, ToSocksAddr(addr)), b[:n]) gosocks5.NewUDPHeader(uint16(n), 0, ToSocksAddr(addr)), b[:n])
@ -119,7 +119,7 @@ func tunnelUDP(conn *net.UDPConn, tun net.Conn, client bool) (err error) {
rChan <- err rChan <- err
return return
} }
glog.V(LDEBUG).Infof("[socks5-udp] %s <<< %s length: %d", tun.RemoteAddr(), dgram.Header.Addr, len(dgram.Data)) glog.V(LDEBUG).Infof("[udp-tun] %s <<< %s length: %d", tun.RemoteAddr(), dgram.Header.Addr, len(dgram.Data))
} }
} }
}() }()
@ -144,7 +144,7 @@ func tunnelUDP(conn *net.UDPConn, tun net.Conn, client bool) (err error) {
wChan <- err wChan <- err
return return
} }
glog.V(LDEBUG).Infof("[socks5-udp] %s <<< %s length: %d", conn.LocalAddr(), dgram.Header.Addr, len(dgram.Data)) glog.V(LDEBUG).Infof("[udp-tun] %s <<< %s length: %d", conn.LocalAddr(), dgram.Header.Addr, len(dgram.Data))
} else { // pipe from tunnel to peer } else { // pipe from tunnel to peer
addr, err := net.ResolveUDPAddr("udp", dgram.Header.Addr.String()) addr, err := net.ResolveUDPAddr("udp", dgram.Header.Addr.String())
if err != nil { if err != nil {
@ -154,7 +154,7 @@ func tunnelUDP(conn *net.UDPConn, tun net.Conn, client bool) (err error) {
wChan <- err wChan <- err
return return
} }
glog.V(LDEBUG).Infof("[socks5-udp] %s >>> %s length: %d", tun.RemoteAddr(), addr, len(dgram.Data)) glog.V(LDEBUG).Infof("[udp-tun] %s >>> %s length: %d", tun.RemoteAddr(), addr, len(dgram.Data))
} }
} }
}() }()