go socks5实现

什么是SOCKS

SOCKS是一种网络传输协议，主要用于Client端与外网Server端之间通讯的中间传递。SOCKS是"SOCKETS"的缩写，意外这一切socks都可以通过代理。 SOCKS是一种代理协议，相比于常见的HTTP代理，SOCKS的代理更加的底层，传统的HTTP代理会修改HTTP头，SOCKS则不会它只是做了数据的中转。

SOCKS的最新版本为SOCKS5。

SOCKS5协议详解

SOCKS5的协议是基于二进制的，协议设计十分的简洁。

Client端和Server端第一次通讯的时候，Client端会想服务端发送版本认证信息，协议格式如下：

	+----+----------+----------+
	|VER | NMETHODS | METHODS  |
	+----+----------+----------+
	| 1  |    1     | 1 to 255 |
	+----+----------+----------+

VER是SOCKS版本，目前版本是0x05；
NMETHODS是METHODS部分的长度；
METHODS是Client端支持的认证方式列表，每个方法占1字节。当前的定义是：
- 0x00 不需要认证
- 0x01 GSSAPI
- 0x02 用户名、密码认证
- 0x03 - 0x7F由IANA分配（保留）
- 0x80 - 0xFE为私人方法保留
- 0xFF 无可接受的方法

Server端从Client端提供的方法中选择一个并通过以下消息通知Client端：

	+----+--------+
	|VER | METHOD |
	+----+--------+
	| 1  |   1    |
	+----+--------+

VER是SOCKS版本，目前是0x05；
METHOD是服务端选中的方法。如果返回0xFF表示没有一个认证方法被选中，Client端需要关闭连接。

SOCKS5请求协议格式：

	+----+-----+-------+------+----------+----------+
	|VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	+----+-----+-------+------+----------+----------+
	| 1  |  1  | X'00' |  1   | Variable |    2     |
	+----+-----+-------+------+----------+----------+

VER是SOCKS版本，目前是0x05；
CMD是SOCK的命令码
- 0x01表示CONNECT请求
- 0x02表示BIND请求
- 0x03表示UDP转发
RSV 0x00，保留
ATYP DST.ADDR类型
- 0x01 IPv4地址，DST.ADDR部分4字节长度
- 0x03 域名地址，DST.ADDR部分第一个字节为域名长度，剩余的内容为域名。
- 0x04 IPv6地址，16个字节长度。
DST.ADDR 目的地址
DST.PORT 网络字节序表示的目的端口

Server端按以下格式返回给Client端：

	+----+-----+-------+------+----------+----------+
	|VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	+----+-----+-------+------+----------+----------+
	| 1  |  1  | X'00' |  1   | Variable |    2     |
	+----+-----+-------+------+----------+----------+

VER是SOCKS版本，目前是0x05；
REP应答字段
- 0x00 表示成功
- 0x01 普通SOCKSServer端连接失败
- 0x02 现有规则不允许连接
- 0x03 网络不可达
- 0x04 主机不可达
- 0x05 连接被拒
- 0x06 TTL超时域名地址
- 0x07 不支持的命令
- 0x08 不支持的地址类型
- 0x09 - 0xFF未定义
RSV 0x00，保留
ATYP BND.ADDR类型
- 0x01 IPv4地址，DST.ADDR部分4字节长度
- 0x03 域名地址，DST.ADDR部分第一个字节为域名长度，剩余的内容为域名。
- 0x04 IPv6地址，16个字节长度。
BND.ADDR Server端绑定的地址
BND.PORT 网络字节序表示的Server端绑定的端口

用go实现socks5

package main

import (
	"errors"
	"fmt"
	"io"
	"log"
	"net"
	"strconv"
	"strings"
)
const (
	IPV4ADDR = uint8(1) //ipv4地址
	DNADDR   = uint8(3) //域名地址
	IPV6ADDR = uint8(4) //地址
	CONNECTCMD = uint8(1)
	SUCCEEDED                     = uint8(0)
	NETWORKUNREACHABLE            = uint8(3)
	HOSTUNREACHABLE               = uint8(4)
	CONNECTIONREFUSED             = uint8(5)
	COMMANDNOTSUPPORTED           = uint8(7)
)

type Addr struct {
	Dn   string
	IP   net.IP
	Port int
}
func (a Addr) Addr() string {
	if 0 != len(a.IP) {
		return net.JoinHostPort(a.IP.String(), strconv.Itoa(a.Port))
	}
	return net.JoinHostPort(a.Dn, strconv.Itoa(a.Port))
}


type Command struct {
	Version      uint8
	Command      uint8
	RemoteAddr   *Addr
	DestAddr     *Addr
	RealDestAddr *Addr
	reader       io.Reader
}

func auth(conn io.ReadWriter) error {
	header := make([]byte,2)
	_,err:= io.ReadFull(conn,header)
	if err!=nil {
		return err
	}
	//igonre check version
	methods := make([]byte,int(header[1]))
	_,err = io.ReadFull(conn,methods)
	if err!=nil {
		return err
	}
	_,err = conn.Write([]byte{uint8(5), uint8(0)}) // 返回协议5，不需要认证
	return err
}


func readAddr(r io.Reader) (*Addr, error) {
	d := &Addr{}
	addrType := []byte{0}
	if _, err := r.Read(addrType); err != nil {
		return nil, err
	}
	switch addrType[0] {
	case IPV4ADDR:
		addr := make([]byte, 4)
		if _, err := io.ReadFull(r, addr); err != nil {
			return nil, err
		}
		d.IP = net.IP(addr)
	case IPV6ADDR:
		addr := make([]byte, 16)
		if _, err := io.ReadFull(r, addr); err != nil {
			return nil, err
		}
		d.IP = net.IP(addr)

	case DNADDR:
		if _, err := r.Read(addrType); err != nil {
			return nil, err
		}
		addrLen := int(addrType[0])
		DN := make([]byte, addrLen)
		if _, err := io.ReadFull(r, DN); err != nil {
			return nil, err
		}
		d.Dn = string(DN)

	default:
		return nil, errors.New("unkown addr type")
	}

	port := []byte{0, 0}
	if _, err := io.ReadFull(r, port); err != nil {
		return nil, err
	}
	d.Port = (int(port[0]) << 8) | int(port[1])
	return d, nil
}


func request(conn io.ReadWriter) (*Command, error)  {
	header := []byte{0, 0, 0}
	if _, err := io.ReadFull(conn, header); err != nil {
		return nil, err
	}
	//igonre check version
	dest, err := readAddr(conn)
	if err != nil {
		return nil, err
	}
	cmd := &Command{
		Version:  uint8(5),
		Command:  header[1],
		DestAddr: dest,
		reader:   conn,
	}

	return cmd, nil
}

func replyMsg(w io.Writer, resp uint8, addr *Addr) error {
	var addrType uint8
	var addrBody []byte
	var addrPort uint16
	switch {
	case addr == nil:
		addrType = IPV4ADDR
		addrBody = []byte{0, 0, 0, 0}
		addrPort = 0

	case addr.Dn != "":
		addrType = DNADDR
		addrBody = append([]byte{byte(len(addr.Dn))}, addr.Dn...)
		addrPort = uint16(addr.Port)

	case addr.IP.To4() != nil:
		addrType = IPV4ADDR
		addrBody = []byte(addr.IP.To4())
		addrPort = uint16(addr.Port)

	case addr.IP.To16() != nil:
		addrType = IPV6ADDR
		addrBody = []byte(addr.IP.To16())
		addrPort = uint16(addr.Port)

	default:
		return errors.New("format address error")
	}
	bodyLen := len(addrBody)
	msg := make([]byte, 6+bodyLen)
	msg[0] = uint8(5)
	msg[1] = resp
	msg[2] = 0 // RSV
	msg[3] = addrType
	copy(msg[4:], addrBody)
	msg[4+bodyLen] = byte(addrPort >> 8)
	msg[4+bodyLen+1] = byte(addrPort & 0xff)
	_, err := w.Write(msg)
	return err
}

func handleSocks5(conn io.ReadWriteCloser) error {
	if err := auth(conn);err !=nil {
		return err
	}
	cmd,err := request(conn)
	if err !=nil {
		return  err
	}
	fmt.Printf("%v",cmd.DestAddr)
	if err := handleCmd( cmd, conn); err != nil {
		return err
	}
	return nil
}

func handleCmd(cmd *Command, conn io.ReadWriteCloser) error {
	dest := cmd.DestAddr
	if dest.Dn != "" {
		addr, err := net.ResolveIPAddr("ip", dest.Dn)
		if err != nil {
			if err := replyMsg(conn, HOSTUNREACHABLE, nil); err != nil {
				return err
			}
			return err
		}
		dest.IP = addr.IP
	}

	cmd.RealDestAddr = cmd.DestAddr
	switch cmd.Command {
	case CONNECTCMD:
		return handleConn(conn, cmd)
	default:
		if err := replyMsg(conn, COMMANDNOTSUPPORTED, nil); err != nil {
			return err
		}
		return errors.New("Unsupported command")
	}
}

func handleConn(conn io.ReadWriteCloser, req *Command) error {
	target, err := net.Dial("tcp", req.RealDestAddr.Addr())
	if err != nil {
		msg := err.Error()
		resp := HOSTUNREACHABLE
		if strings.Contains(msg, "refused") {
			resp = CONNECTIONREFUSED
		} else if strings.Contains(msg, "network is unreachable") {
			resp = NETWORKUNREACHABLE
		}
		if err := replyMsg(conn, resp, nil); err != nil {
			return err
		}
		return errors.New(fmt.Sprintf("Connect to %v failed: %v", req.DestAddr, err))
	}
	defer target.Close()

	local := target.LocalAddr().(*net.TCPAddr)
	bind := Addr{IP: local.IP, Port: local.Port}
	if err := replyMsg(conn, SUCCEEDED, &bind); err != nil {
		return err
	}
	go io.Copy(target, req.reader)
	io.Copy(conn, target)
	return nil
}
func main()  {
	l,err := net.Listen("tcp",":8090")
	if err !=nil {
		log.Fatal(err)
	}
	for {
		conn, err := l.Accept()
		if err != nil {
			log.Fatal(err)
		}
		handle := func(conn net.Conn) {
			handleSocks5(conn)
		}
		go handle(conn)
	}
}

$ go run main.go
&{ 180.101.49.12 443} ## 使用curl出现
$ export ALL_PROXY=socks5://127.0.0.1:8090 # 设置终端代理
$ curl https://www.baidu.com
<!DOCTYPE html>
...

上面的例子中我们，使用了linux的终端代理，这边隐藏了一个细节就是，终端代理实践上有socks5 client，所以我们并没有自己拼client相关的二进制协议。 linux的终端只支持http，https。像ssh协议这需要自己去实现client协议，有兴趣的同学可以自己去实现下，这不不再赘述。

总结

本小节介绍了socks5的协议，以及实现了socks代理server。socks5其实不仅仅支持tcp还有支持udp。总体来说是一个简洁但功能强大的协议。

Go一站式编程

go socks5实现

什么是SOCKS

SOCKS5协议详解

用go实现socks5

总结