mirror
/
gost-mirror
mirror of https://github.com/ginuerzh/gost
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

add socks5 bind/udp associate features

1.x
rui.zheng 11 years ago
parent
f3d3a66d03
commit
4056db5979
2 changed files with 504 additions and 137 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 507
      gost.go
  2. 134
      socks5.go

507
gost.go
View File

@ -74,15 +74,16 @@ func (g *Gost) cli(conn net.Conn) {
lg.Flush()
}()
lg.Logln("accept", conn.(*net.TCPConn).RemoteAddr().String())
raddr := conn.(*net.TCPConn).RemoteAddr()
lg.Logln("accept", raddr.String())
sconn, err := g.connect(g.Saddr)
sconn, err := Connect(g.Saddr, g.Proxy)
if err != nil {
lg.Logln(err)
return
}
defer sconn.Close()
laddr := sconn.(*net.TCPConn).LocalAddr().String()
lg.Logln(laddr)
@ -114,96 +115,362 @@ func (g *Gost) cli(conn net.Conn) {
if g.Shadows {
lg.Logln("shadowsocks, aes-256-cfb")
cipher, _ := shadowsocks.NewCipher("aes-256-cfb", "gost")
conn = shadowsocks.NewConn(conn, cipher)
addr, port, extra, err := getRequest(conn)
if err != nil {
shadowTransfer(shadowsocks.NewConn(conn, cipher), sconn, lg)
return
}
n, err = conn.Read(b)
if err != nil {
lg.Logln(err)
return
}
//log.Println(b[:n])
if b[0] == 5 { // socks5,NO AUTHENTICATION
lg.Logln("|>>>", b[:n])
if _, err := conn.Write([]byte{5, 0}); err != nil {
lg.Logln(err)
return
}
lg.Logln(addr, port)
lg.Logln("|<<<", []byte{5, 0})
cmd := NewCmd(CmdConnect, AddrDomain, addr, port)
if err = cmd.Write(sconn); err != nil {
socks5Transfer(conn, sconn, lg)
return
}
//log.Println(string(b[:n]))
req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(b[:n])))
if err != nil {
lg.Logln(err)
return
}
httpTransfer(req, conn, sconn, lg)
}
func (g *Gost) srv(conn net.Conn) {
b := make([]byte, 8192)
lg := NewLog(false)
defer func() {
lg.Logln()
lg.Flush()
}()
raddr := conn.(*net.TCPConn).RemoteAddr()
lg.Logln("accept", raddr.String())
n, err := conn.Read(b)
if err != nil {
lg.Logln(err)
return
}
if b[0] == 5 { // socks5
lg.Logln("|>>>", b[:n])
method := b[2]
if _, err := conn.Write([]byte{5, method}); err != nil {
lg.Logln(err)
return
}
lg.Logln(">>>|", cmd)
lg.Logln("|<<<", []byte{5, method})
if cmd, err = ReadCmd(sconn); err != nil {
if method == 0x88 {
cipher, _ := shadowsocks.NewCipher("aes-256-cfb", "gost")
conn = shadowsocks.NewConn(conn, cipher)
}
cmd, err := ReadCmd(conn)
if err != nil {
lg.Logln(err)
return
}
lg.Logln("<<<|", cmd)
lg.Logln("|>>>", cmd)
if cmd.Cmd != Succeeded {
conn.Write([]byte("HTTP/1.1 503 Service unavailable\r\n" +
"Proxy-Agent: gost/1.0\r\n\r\n"))
switch cmd.Cmd {
case CmdConnect:
//host := cmd.Addr + ":" + strconv.Itoa(int(cmd.Port))
host := net.JoinHostPort(cmd.Addr, strconv.Itoa(int(cmd.Port)))
lg.Logln("connect", host)
tconn, err := Connect(host, g.Proxy)
if err != nil {
lg.Logln(err)
cmd = NewCmd(ConnRefused, 0, "", 0)
cmd.Write(conn)
lg.Logln("|<<<", cmd)
return
}
defer tconn.Close()
cmd = NewCmd(Succeeded, AddrIPv4, "", 0)
if err = cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
if err := Transport(conn, tconn); err != nil {
lg.Logln(err)
}
case CmdUdp:
//log.Println("recv udp")
//addr := &net.UDPAddr{IP: raddr.(*net.TCPAddr).IP}
uconn, err := net.ListenUDP("udp", nil)
if err != nil {
lg.Logln(err)
return
}
defer uconn.Close()
uaddr := uconn.LocalAddr()
lg.Logln("listen udp", uaddr)
_, port, _ := net.SplitHostPort(uaddr.String())
p, _ := strconv.Atoi(port)
cmd = NewCmd(Succeeded, AddrIPv4, "", uint16(p))
if err = cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
tunnelUdp(conn, uconn)
/*
up, err := ReadUdpPayload(uconn)
if err != nil {
lg.Logln(err)
return
}
lg.Logln("[>>>", up)
*/
case CmdBind:
//log.Println("recv bind")
l, err := net.ListenTCP("tcp", nil)
if err != nil {
lg.Logln(err)
cmd := NewCmd(Failure, AddrIPv4, "", 0)
cmd.Write(conn)
lg.Logln("|<<<", cmd)
return
}
defer l.Close()
addr := ""
ifis, _ := net.Interfaces()
for _, ifi := range ifis {
if strings.HasPrefix(ifi.Name, "eth") {
addrs, _ := ifi.Addrs()
if len(addrs) > 0 {
ip, _, _ := net.ParseCIDR(addrs[0].String())
addr = ip.String()
}
break
}
}
lg.Logln("bind", addr, l.Addr().(*net.TCPAddr).Port)
cmd := NewCmd(Succeeded, AddrIPv4, addr, uint16(l.Addr().(*net.TCPAddr).Port))
if err := cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
for {
c, err := l.AcceptTCP()
if err != nil {
log.Println("accept:", err)
return
}
raddr := c.RemoteAddr().(*net.TCPAddr)
cmd := NewCmd(Succeeded, AddrIPv4, raddr.IP.String(), uint16(raddr.Port))
if err := cmd.Write(conn); err != nil {
log.Println(err)
return
}
defer c.Close()
Transport(conn, c)
return
}
}
return
}
//log.Println(string(b[:n]))
req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(b[:n])))
if err != nil {
lg.Logln(err)
return
}
lg.Logln(req.Method, req.RequestURI)
host := req.Host
if !strings.Contains(host, ":") {
host = host + ":80"
}
tconn, err := Connect(host, g.Proxy)
if err != nil {
lg.Logln(err)
conn.Write([]byte("HTTP/1.1 503 Service unavailable\r\n" +
"Proxy-Agent: gost/1.0\r\n\r\n"))
return
}
defer tconn.Close()
if req.Method == "CONNECT" {
if _, err = conn.Write(
[]byte("HTTP/1.1 200 Connection established\r\n" +
"Proxy-Agent: gost/1.0\r\n\r\n")); err != nil {
lg.Logln(err)
return
}
} else {
if err := req.Write(tconn); err != nil {
lg.Logln(err)
return
}
}
if extra != nil {
if _, err := sconn.Write(extra); err != nil {
log.Println(err)
if err := Transport(conn, tconn); err != nil {
lg.Logln(err)
}
}
func tunnelUdp(conn net.Conn, uconn *net.UDPConn) (err error) {
rChan := make(chan error, 1)
wChan := make(chan error, 1)
go func() {
for {
up, err := ReadUdpPayload(conn)
if err != nil {
rChan <- err
return
}
addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(up.Addr, strconv.Itoa(int(up.Port))))
if err != nil {
rChan <- err
return
}
if _, err = uconn.WriteTo(up.Data, addr); err != nil {
rChan <- err
return
}
}
}()
g.transport(conn, sconn)
go func() {
b := make([]byte, 65535)
return
for {
n, addr, err := uconn.ReadFrom(b)
if err != nil {
wChan <- err
return
}
host, port, _ := net.SplitHostPort(addr.String())
p, _ := strconv.Atoi(port)
up := NewUdpPayload(uint16(n), AddrIPv4, host, uint16(p), b[:n])
if err := up.Write(conn); err != nil {
wChan <- err
return
}
}
}()
select {
case err = <-wChan:
//log.Println("w exit", err)
case err = <-rChan:
//log.Println("r exit", err)
}
n, err = conn.Read(b)
return
}
func socks5Transfer(conn, sconn net.Conn, lg *BufferedLog) {
cmd, err := ReadCmd(conn)
if err != nil {
lg.Logln(err)
return
}
//log.Println(b[:n])
if b[0] == 5 { // socks5,NO AUTHENTICATION
lg.Logln("|>>>", b[:n])
lg.Logln("|>>>", cmd)
if _, err := conn.Write([]byte{5, 0}); err != nil {
switch cmd.Cmd {
case CmdConnect:
if err = cmd.Write(sconn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", []byte{5, 0})
lg.Logln(">>>|", cmd)
cmd, err := ReadCmd(conn)
cmd, err = ReadCmd(sconn)
if err != nil {
lg.Logln(err)
return
}
lg.Logln("|>>>", cmd)
lg.Logln("<<<|", cmd)
if err = cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
if err := Transport(conn, sconn); err != nil {
lg.Logln(err)
}
case CmdUdp:
//raddr := conn.(*net.TCPConn).RemoteAddr()
addr := &net.UDPAddr{IP: net.ParseIP(cmd.Addr)}
uconn, err := net.ListenUDP("udp", addr)
if err != nil {
lg.Logln(err)
return
}
uaddr := uconn.LocalAddr()
lg.Logln("listen udp", uaddr)
cmd := NewCmd(CmdUdp, AddrIPv4, "", 0)
if err = cmd.Write(sconn); err != nil {
lg.Logln(err)
return
}
lg.Logln(">>>|", cmd)
cmd, err = ReadCmd(sconn)
if err != nil {
if cmd, err = ReadCmd(sconn); err != nil {
lg.Logln(err)
return
}
lg.Logln("<<<|", cmd)
host, port, _ := net.SplitHostPort(uconn.LocalAddr().String())
p, _ := strconv.Atoi(port)
cmd = NewCmd(CmdUdp, AddrIPv4, host, uint16(p))
if err = cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
g.transport(conn, sconn)
return
}
if err := tunnelUdp(sconn, uconn); err != nil {
lg.Logln(err)
}
case CmdBind:
if err := cmd.Write(sconn); err != nil {
lg.Logln(err)
return
}
//log.Println(string(b[:n]))
req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(b[:n])))
if err != nil {
lg.Logln(err)
return
if err := Transport(conn, sconn); err != nil {
lg.Logln(err)
}
}
}
func httpTransfer(req *http.Request, conn, sconn net.Conn, lg *BufferedLog) {
lg.Logln(req.Method, req.RequestURI)
var addr string
@ -221,7 +488,8 @@ func (g *Gost) cli(conn net.Conn) {
}
cmd := NewCmd(CmdConnect, AddrDomain, addr, port)
if err = cmd.Write(sconn); err != nil {
err := cmd.Write(sconn)
if err != nil {
lg.Logln(err)
return
}
@ -253,114 +521,53 @@ func (g *Gost) cli(conn net.Conn) {
}
}
g.transport(conn, sconn)
if err := Transport(conn, sconn); err != nil {
lg.Logln(err)
}
}
func (g *Gost) srv(conn net.Conn) {
b := make([]byte, 8192)
lg := NewLog(true)
defer func() {
lg.Logln()
lg.Flush()
}()
lg.Logln("accept", conn.(*net.TCPConn).RemoteAddr().String())
n, err := conn.Read(b)
func shadowTransfer(conn, sconn net.Conn, lg *BufferedLog) {
t, addr, port, extra, err := getRequest(conn)
if err != nil {
lg.Logln(err)
return
}
lg.Logln(addr, port)
if b[0] == 5 { // socks5,NO AUTHENTICATION
lg.Logln("|>>>", b[:n])
method := b[2]
if _, err := conn.Write([]byte{5, method}); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", []byte{5, method})
if method == 0x88 {
cipher, _ := shadowsocks.NewCipher("aes-256-cfb", "gost")
conn = shadowsocks.NewConn(conn, cipher)
}
cmd, err := ReadCmd(conn)
if err != nil {
lg.Logln(err)
return
}
lg.Logln("|>>>", cmd)
host := cmd.Addr + ":" + strconv.Itoa(int(cmd.Port))
lg.Logln("connect", host)
tconn, err := g.connect(host)
if err != nil {
lg.Logln(err)
cmd = NewCmd(ConnRefused, 0, "", 0)
cmd.Write(conn)
lg.Logln("|<<<", cmd)
return
}
defer tconn.Close()
cmd = NewCmd(Succeeded, AddrIPv4, "0.0.0.0", 0)
if err = cmd.Write(conn); err != nil {
lg.Logln(err)
return
}
lg.Logln("|<<<", cmd)
lg.Logln()
lg.Flush()
g.transport(conn, tconn)
cmd := NewCmd(CmdConnect, t, addr, port)
if err = cmd.Write(sconn); err != nil {
lg.Logln(err)
return
}
lg.Logln(">>>|", cmd)
//log.Println(string(b[:n]))
req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(b[:n])))
if err != nil {
if cmd, err = ReadCmd(sconn); err != nil {
lg.Logln(err)
return
}
lg.Logln("<<<|", cmd)
lg.Logln(req.Method, req.RequestURI)
host := req.Host
if !strings.Contains(host, ":") {
host = host + ":80"
}
tconn, err := g.connect(host)
if err != nil {
lg.Logln(err)
if cmd.Cmd != Succeeded {
conn.Write([]byte("HTTP/1.1 503 Service unavailable\r\n" +
"Proxy-Agent: gost/1.0\r\n\r\n"))
return
}
defer tconn.Close()
if req.Method == "CONNECT" {
if _, err = conn.Write(
[]byte("HTTP/1.1 200 Connection established\r\n" +
"Proxy-Agent: gost/1.0\r\n\r\n")); err != nil {
lg.Logln(err)
return
}
} else {
if err := req.Write(tconn); err != nil {
if extra != nil {
//lg.Logln("extra:", string(extra))
if _, err := sconn.Write(extra); err != nil {
lg.Logln(err)
return
}
}
lg.Logln()
lg.Flush()
g.transport(conn, tconn)
if err := Transport(conn, sconn); err != nil {
lg.Logln(err)
}
}
func (g *Gost) connect(addr string) (net.Conn, error) {
if len(g.Proxy) == 0 {
func Connect(addr, proxy string) (net.Conn, error) {
if len(proxy) == 0 {
taddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
log.Println(err)
@ -369,7 +576,7 @@ func (g *Gost) connect(addr string) (net.Conn, error) {
return net.DialTCP("tcp", nil, taddr)
}
paddr, err := net.ResolveTCPAddr("tcp", g.Proxy)
paddr, err := net.ResolveTCPAddr("tcp", proxy)
if err != nil {
return nil, err
}
@ -407,17 +614,50 @@ func (g *Gost) connect(addr string) (net.Conn, error) {
return pconn, nil
}
func (g *Gost) pipe(src io.Reader, dst io.Writer, c chan<- error) {
_, err := io.Copy(dst, src)
func Copy(dst io.Writer, src io.Reader) (written int64, err error) {
buf := make([]byte, 32*1024)
for {
nr, er := src.Read(buf)
//log.Println("cp r", nr, er)
if nr > 0 {
nw, ew := dst.Write(buf[:nr])
//log.Println("cp w", nw, ew)
if nw > 0 {
written += int64(nw)
}
if ew != nil {
err = ew
break
}
/*
if nr != nw {
err = io.ErrShortWrite
break
}
*/
}
if er == io.EOF {
break
}
if er != nil {
err = er
break
}
}
return
}
func Pipe(src io.Reader, dst io.Writer, c chan<- error) {
_, err := Copy(dst, src)
c <- err
}
func (g *Gost) transport(conn, conn2 net.Conn) (err error) {
func Transport(conn, conn2 net.Conn) (err error) {
rChan := make(chan error, 1)
wChan := make(chan error, 1)
go g.pipe(conn, conn2, wChan)
go g.pipe(conn2, conn, rChan)
go Pipe(conn, conn2, wChan)
go Pipe(conn2, conn, rChan)
select {
case err = <-wChan:
@ -429,7 +669,7 @@ func (g *Gost) transport(conn, conn2 net.Conn) (err error) {
return
}
func getRequest(conn net.Conn) (host string, port uint16, extra []byte, err error) {
func getRequest(conn net.Conn) (addrType uint8, addr string, port uint16, extra []byte, err error) {
const (
idType = 0 // address type index
idIP0 = 1 // ip addres start index
@ -451,12 +691,13 @@ func getRequest(conn net.Conn) (host string, port uint16, extra []byte, err erro
buf := make([]byte, 260)
var n int
// read till we get possible domain length field
//ss.SetReadTimeout(conn)
//shadowsocks.SetReadTimeout(conn)
if n, err = io.ReadAtLeast(conn, buf, idDmLen+1); err != nil {
log.Println(err)
return
}
log.Println(buf[:n])
//log.Println(buf[:n])
addrType = buf[idType]
reqLen := -1
switch buf[idType] {
@ -487,11 +728,11 @@ func getRequest(conn net.Conn) (host string, port uint16, extra []byte, err erro
// big problem.
switch buf[idType] {
case typeIPv4:
host = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
addr = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
case typeIPv6:
host = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
addr = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
case typeDm:
host = string(buf[idDm0 : idDm0+buf[idDmLen]])
addr = string(buf[idDm0 : idDm0+buf[idDmLen]])
}
// parse port
port = binary.BigEndian.Uint16(buf[reqLen-2 : reqLen])

134
socks5.go
View File

@ -6,6 +6,7 @@ import (
"fmt"
"io"
//"log"
"bytes"
"net"
)
@ -79,6 +80,9 @@ type Cmd struct {
}
func NewCmd(cmd uint8, atype uint8, addr string, port uint16) *Cmd {
if len(addr) == 0 {
addr = "0.0.0.0"
}
return &Cmd{
Cmd: cmd,
AddrType: atype,
@ -112,14 +116,14 @@ func ReadCmd(r io.Reader) (*Cmd, error) {
if n != 10 {
return nil, ErrBadFormat
}
cmd.Addr = net.IP(b[pos : pos+4]).String()
pos += 4
cmd.Addr = net.IP(b[pos : pos+net.IPv4len]).String()
pos += net.IPv4len
case AddrIPv6:
if n != 22 {
return nil, ErrBadFormat
}
cmd.Addr = net.IP(b[pos : pos+16]).String()
pos += 16
cmd.Addr = net.IP(b[pos : pos+net.IPv6len]).String()
pos += net.IPv6len
case AddrDomain:
length := int(b[pos])
if n != 4+1+length+2 {
@ -168,3 +172,125 @@ func (cmd *Cmd) String() string {
return fmt.Sprintf("5 %d 0 %d %s %d",
cmd.Cmd, cmd.AddrType, cmd.Addr, cmd.Port)
}
/*
+----+------+------+----------+----------+----------+
|RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
+----+------+------+----------+----------+----------+
| 2 | 1 | 1 | Variable | 2 | Variable |
+----+------+------+----------+----------+----------+
*/
type UdpPayload struct {
Rsv uint16
Frag uint8
AddrType uint8
Addr string
Port uint16
Data []byte
}
func NewUdpPayload(rsv uint16, atype uint8, addr string, port uint16, data []byte) *UdpPayload {
if len(addr) == 0 {
addr = "0.0.0.0"
}
return &UdpPayload{
Rsv: rsv,
AddrType: atype,
Addr: addr,
Port: port,
Data: data,
}
}
func ReadUdpPayload(r io.Reader) (*UdpPayload, error) {
buf := make([]byte, 65797)
n, err := io.ReadAtLeast(r, buf, 5)
//log.Println("r", buf[:n])
if err != nil {
return nil, err
}
up := &UdpPayload{
Rsv: binary.BigEndian.Uint16(buf[:2]),
Frag: buf[2],
AddrType: buf[3],
}
dataIndex := 0
switch up.AddrType {
case AddrIPv4:
dataIndex = 10
case AddrIPv6:
dataIndex = 22
case AddrDomain:
dataIndex = 7 + int(buf[4])
default:
return nil, ErrBadAddrType
}
dataLen := int(up.Rsv)
if n < dataIndex+dataLen {
if _, err := io.ReadFull(r, buf[n:dataIndex+dataLen]); err != nil {
return nil, err
}
}
pos := 4
switch up.AddrType {
case AddrIPv4:
up.Addr = net.IP(buf[pos : pos+net.IPv4len]).String()
pos += net.IPv4len
case AddrIPv6:
up.Addr = net.IP(buf[pos : pos+net.IPv6len]).String()
pos += net.IPv6len
case AddrDomain:
length := int(buf[pos])
pos++
up.Addr = string(buf[pos : pos+length])
pos += length
}
up.Port = binary.BigEndian.Uint16(buf[pos:])
//log.Println(up.Addr, up.Port)
if dataLen > 0 {
up.Data = buf[dataIndex : dataIndex+dataLen]
} else {
up.Data = buf[dataIndex:n]
}
return up, nil
}
func (up *UdpPayload) Write(w io.Writer) error {
buffer := &bytes.Buffer{}
b := make([]byte, 2)
binary.BigEndian.PutUint16(b, up.Rsv)
buffer.Write(b)
buffer.WriteByte(up.Frag)
buffer.WriteByte(up.AddrType)
switch up.AddrType {
case AddrIPv4:
buffer.Write(net.ParseIP(up.Addr).To4())
case AddrDomain:
buffer.WriteByte(uint8(len(up.Addr)))
buffer.Write([]byte(up.Addr))
case AddrIPv6:
buffer.Write(net.ParseIP(up.Addr).To16())
}
binary.BigEndian.PutUint16(b, up.Port)
buffer.Write(b)
buffer.Write(up.Data)
_, err := w.Write(buffer.Bytes())
return err
}
func (up *UdpPayload) String() string {
return fmt.Sprintf("%d %d %d %s %d [%d]",
up.Rsv, up.Frag, up.AddrType, up.Addr, up.Port, len(up.Data))
}

Write Preview
Loading…
Cancel
Save