现在我们来做一个更复杂的项目，socks5代理服务器。

一、内容介绍

一提到代理服务器，大家首先会想到翻墙。不过遗憾的是，socks5协议它虽然是代理协议，但它并不能用来翻墙，因为它的协议都是明文传输的。这个协议历史比较久远，诞生于互联网早期，它的用途是，比如某些企业的内网，为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦，socks5相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源，实际上很多翻墙软件最终暴露的也是一个socks5协议的端口。 其实如果你开发过爬虫的话，就知道在爬取过程中很容易遇到IP访问频率超过限制，这个时候很多人就会去网上找一些代理IP池，这些代理IP池里面有很多代理的协议就是socks5。

二、socks5的原理

接下来我们来了解一下socks5协议的工作原理，正常浏览器访问一个网站，如果不经过代理服务器的话，就是先和对方的网站建立TCP连接，然后三次握手，握手完之后发起HTTP请求，然后服务返回HTTP响应，如果设置代理服务器之后，流程就会变得复杂一些，首先是浏览器和socks5代立建立TCP连接，代理在和真正的服务器建立TCP连接，这里可以分成4个阶段，握手阶段，认证阶段，请求阶段，relay阶段。

握手阶段

浏览器会向socks5代理发送请求，包的内容包括一个协议的版本号，还有支持的认证的种类。

认证阶段

socks5服务器会选中一个认证方式返回给浏览器，如果返回的是00的话，就代表不需要认证，返回其他类型的话会开始认证流程。

请求阶段

认证通过之后浏览器会socks5服务发起请求，主要信息包括版本号，请求的类型一般主要是connection请求，就代表代理服务器和某个域名或者某个IP地址某个端口建立TCP连接，代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。

relay阶段

此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上，然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边，然后实际上代理服务器并不关心流量的细节，可以是HTTP流量，也可以是其他TCP流量。

三、TCP echo sever

第一步我们先在go里面写一个简单的TCP echo server。为了方便测试server的工作逻辑，很简单，你给他发送啥他就回复啥，大概代码，会长这样子：

package main

import (
    "bufio"
    "log"
    "net"
)

func main() {
    server, err := net.Listen("tcp", "127.0.0.1:1080")
    if err != nil {
       panic(err)
    }
    for {
       client, err := server.Accept()
       if err != nil {
          log.Printf("Accept failed %v", err)
          continue
       }
       go process(client)
    }
}

func process(conn net.Conn) {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    for {
       b, err := reader.ReadByte()
       if err != nil {
          break
       }
       _, err = conn.Write([]byte{b})
       if err != nil {
          break
       }
    }
}

• 1.首先我们在main函数里面先用net.listen去监听一个端口，会返回一个server，然后在一个死循环里面,每次去accept一个请求，成功就会返回一个连接。

• 2.接下来的话我们在一个process函数里面去处理这个连接，注意这前面会有个go关键词，这个代表启动一个goroutinue，可以暂时类比为其他语言里面的启动一个子线程。只是这里的 goroutine的开销会比子线程要小很多，可以很轻松的处理上万的并发。

• 3.接下来是这个process函数的实现，首先第一步的话会加一个defer connection.close(),defer是golang里面的一个语法，这一行的含义就是代表这个函数退出的时候,要把这个连接关掉，否则会有资源的泄露。

• 4.接下来的话我们会用 bufio.NewReader来创建一个带缓冲的只读流，这个在前面的猜谜游戏里面也有用到，带缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便一个字节一个字节的读取，但是底层可能合并成几次大的读取操作，并且带缓冲的流会有更多的一些工具函数来读取数据。我们可以简单的调用那个readbyte函数来读取单个字节，再把这个字节写进去连接。

我们来简单测试一下，我们第1个TCP服务器，然后测试会用到nc命令，我们用nc 127.0.0.1 1080,输入hello，然后服务器就会给你返回hello。

就这样我们已经完成了一个能够返回你输入信息的一个TCP server。

四、认证阶段

接下来我们是要开始实现协议的第二步,认证阶段,从这一部分开始会变得比较复杂。

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
    // +----+----------+----------+
    // |VER | NMETHODS | METHODS  |
    // +----+----------+----------+
    // | 1  |    1     | 1 to 255 |
    // +----+----------+----------+
    // VER: 协议版本，socks5为0x05
    // NMETHODS: 支持认证的方法数量
    // METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
    // X’00’ NO AUTHENTICATION REQUIRED
    // X’02’ USERNAME/PASSWORD

    ver, err := reader.ReadByte()
    if err != nil {
       return fmt.Errorf("read ver failed:%w", err)
    }
    if ver != socks5Ver {
       return fmt.Errorf("not supported ver:%v", ver)
    }
    methodSize, err := reader.ReadByte()
    if err != nil {
       return fmt.Errorf("read methodSize failed:%w", err)
    }
    method := make([]byte, methodSize)
    _, err = io.ReadFull(reader, method)
    if err != nil {
       return fmt.Errorf("read method failed:%w", err)
    }
    log.Println("ver", ver, "method", method)
    // +----+--------+
    // |VER | METHOD |
    // +----+--------+
    // | 1  |   1    |
    // +----+--------+
    _, err = conn.Write([]byte{socks5Ver, 0x00})
    if err != nil {
       return fmt.Errorf("write failed:%w", err)
    }
    return nil
}

我们实现一个空的auth函数在process函数里面调用，再来编写auth函数的代码。

• 我们回忆一下认证阶段的逻辑，首先第1步的话，浏览器会给代理服务器发一个包，然后这个包有三个字段，第一个字段，version也就是协议版本号，固定是5，第二个字段methods，认证方法数目，第三个字段，每一个method的编号，0代表不需要认证，2代表用户密码认证。

• 我们先用read bytes来把版本号读出来，然后如果版本号不是socks5的话直接返回报错，接下来我们再读取method size，也是一个字节。然后我们需要去make一个相应长度的一个 slice，然后用io.ReadFull把它填充进去。 写到这里，我们把获取的版本号和认证方式打印一下。

• 此时，代理服务器还需要返回一个response，返回包括两个字段，version，一个是method，也就是我们选中的鉴传方式，也就是00。

• 此时 curl 命令肯定是不成功的，因为我们的协议还没实现完成。但是我们看日志会发现， version 和 method 可以正常打印，说明当前我们的实现是正确的。

五、请求阶段

接下来我们开始做第三步，实现请求阶段。

• 我们试图读取到携带URL或者IP地址+端口的包，然后把它打印出来。我们实现一个和auth函数类似的connect函数，同样在process里面去调用。再来实现connect函数的代码。

• 我们来回忆一下请求阶段的逻辑。浏览器会发送一个包， 包里面包含如下6个字段，version 版本号还是5。command 代表请求的类型，我们只支持connection请求，也就是让代理服务建立新的TCP连接。RSV 保留字段，不理会。atype 就是目标地址类型，可能是IPV 4或IPV 6或者域名下面是 addr，这个地址的长度是根据atype的类型而不同的，port 端口号，两个字节，我们需要逐个去读取这些字段。

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
    // +----+-----+-------+------+----------+----------+
    // |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
    // +----+-----+-------+------+----------+----------+
    // | 1  |  1  | X'00' |  1   | Variable |    2     |
    // +----+-----+-------+------+----------+----------+
    // VER 版本号，socks5的值为0x05
    // CMD 0x01表示CONNECT请求
    // RSV 保留字段，值为0x00
    // ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
    //   0x01表示IPv4地址，DST.ADDR为4个字节
    //   0x03表示域名，DST.ADDR是一个可变长度的域名
    // DST.ADDR 一个可变长度的值
    // DST.PORT 目标端口，固定2个字节

    buf := make([]byte, 4)
    _, err = io.ReadFull(reader, buf)
    if err != nil {
       return fmt.Errorf("read header failed:%w", err)
    }
    ver, cmd, atyp := buf[0], buf[1], buf[3]
    if ver != socks5Ver {
       return fmt.Errorf("not supported ver:%v", ver)
    }
    if cmd != cmdBind {
       return fmt.Errorf("not supported cmd:%v", cmd)
    }
    addr := ""
    switch atyp {
    case atypeIPV4:
       _, err = io.ReadFull(reader, buf)
       if err != nil {
          return fmt.Errorf("read atyp failed:%w", err)
       }
       addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
    case atypeHOST:
       hostSize, err := reader.ReadByte()
       if err != nil {
          return fmt.Errorf("read hostSize failed:%w", err)
       }
       host := make([]byte, hostSize)
       _, err = io.ReadFull(reader, host)
       if err != nil {
          return fmt.Errorf("read host failed:%w", err)
       }
       addr = string(host)
    case atypeIPV6:
       return errors.New("IPv6: no supported yet")
    default:
       return errors.New("invalid atyp")
    }
    _, err = io.ReadFull(reader, buf[:2])
    if err != nil {
       return fmt.Errorf("read port failed:%w", err)
    }
    port := binary.BigEndian.Uint16(buf[:2])

    log.Println("dial", addr, port)

    // +----+-----+-------+------+----------+----------+
    // |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
    // +----+-----+-------+------+----------+----------+
    // | 1  |  1  | X'00' |  1   | Variable |    2     |
    // +----+-----+-------+------+----------+----------+
    // VER socks版本，这里为0x05
    // REP Relay field,内容取值如下 X’00’ succeeded
    // RSV 保留字段
    // ATYPE 地址类型
    // BND.ADDR 服务绑定的地址
    // BND.PORT 服务绑定的端口DST.PORT
    _, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
    if err != nil {
       return fmt.Errorf("write failed: %w", err)
    }
    return nil
}

• 下面这四个字段总共四个字节，我们可以一次性把它读出来。我们定义一个长度为4的buffer然后把它读满。读满之后，然后第0个、第1个、 第3个、分别是version cmd和type,version需要判断是socket5, cmd 需要判断是1。下面的atype,可能是ipv4，ipv6， 或者是host。如果IPV 4的话，我们再次读满这个buffer,因为这个buffer长度刚好也是4个字节，然后逐个字节打印成IP地址的格式保存到addr变量。

• 如果是个host的话，需要先读它的长度，再make一个相应长度的buf填充它。再转换成字符串保存到addr变量。IPV 6用得比较少，我们就暂时先不支持。 最后还有两个字节那个是port，我们读取它，然后按协议规定的大端字节序转换成数字。由于上面的buffer已经不用了，打印出来用于调试，收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用。 第一个是版本号还是socket5。 第二个，就是返回的类型 ，这里是成功就返回0第三个是保留字段填 0，第四个atype地址类型填1，第五个、第六个暂时用不到，都填成0。一共4+4+2个字节，后面6个字节都是0填充。

• 现在我们来测试一下当前阶段的成果，简单curl此时请求还是会失败，我们现在已经能看到正常打印出来访问的IP地址和端口，这说明我们当前的实现正常，这样我们就可以做最后一步，我们真正和这个端口建立连接，双向转发数据。

六、relay阶段

我们直接用net.dial建立一个TCP连接，建立完连接之后，我们同样要加一个defer来关闭连接。接下来需要建立浏览器和下游服务器的双向数据转发。标准库的io.copy可以实现一个单向数据转发，双向转发的话，需要启动两个goroutinue。

go func() {
    _, _ = io.Copy(dest, reader)
    cancel()
}()
go func() {
    _, _ = io.Copy(conn, dest)
    cancel()
}()

<-ctx.Done()
return nil

现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向copy出错的时候， 再返回connect函数。这里可以使用到标准库里面的一个context机制，用context连with cancel来创建一个context。

在最后等待ctx.Done，只要 cancel被调用，ctx.Done就会立刻返回。 然后在上面的两个goroutinue里面调用一次cancel 即可。

完整版：

package main

import (
    "bufio"
    "context"
    "encoding/binary"
    "errors"
    "fmt"
    "io"
    "log"
    "net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

func main() {
    server, err := net.Listen("tcp", "127.0.0.1:1080")
    if err != nil {
       panic(err)
    }
    for {
       client, err := server.Accept()
       if err != nil {
          log.Printf("Accept failed %v", err)
          continue
       }
       go process(client)
    }
}

func process(conn net.Conn) {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    err := auth(reader, conn)
    if err != nil {
       log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
       return
    }
    err = connect(reader, conn)
    if err != nil {
       log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
       return
    }
}

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
    // +----+----------+----------+
    // |VER | NMETHODS | METHODS  |
    // +----+----------+----------+
    // | 1  |    1     | 1 to 255 |
    // +----+----------+----------+
    // VER: 协议版本，socks5为0x05
    // NMETHODS: 支持认证的方法数量
    // METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
    // X’00’ NO AUTHENTICATION REQUIRED
    // X’02’ USERNAME/PASSWORD

    ver, err := reader.ReadByte()
    if err != nil {
       return fmt.Errorf("read ver failed:%w", err)
    }
    if ver != socks5Ver {
       return fmt.Errorf("not supported ver:%v", ver)
    }
    methodSize, err := reader.ReadByte()
    if err != nil {
       return fmt.Errorf("read methodSize failed:%w", err)
    }
    method := make([]byte, methodSize)
    _, err = io.ReadFull(reader, method)
    if err != nil {
       return fmt.Errorf("read method failed:%w", err)
    }

    // +----+--------+
    // |VER | METHOD |
    // +----+--------+
    // | 1  |   1    |
    // +----+--------+
    _, err = conn.Write([]byte{socks5Ver, 0x00})
    if err != nil {
       return fmt.Errorf("write failed:%w", err)
    }
    return nil
}

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
    // +----+-----+-------+------+----------+----------+
    // |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
    // +----+-----+-------+------+----------+----------+
    // | 1  |  1  | X'00' |  1   | Variable |    2     |
    // +----+-----+-------+------+----------+----------+
    // VER 版本号，socks5的值为0x05
    // CMD 0x01表示CONNECT请求
    // RSV 保留字段，值为0x00
    // ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
    //   0x01表示IPv4地址，DST.ADDR为4个字节
    //   0x03表示域名，DST.ADDR是一个可变长度的域名
    // DST.ADDR 一个可变长度的值
    // DST.PORT 目标端口，固定2个字节

    buf := make([]byte, 4)
    _, err = io.ReadFull(reader, buf)
    if err != nil {
       return fmt.Errorf("read header failed:%w", err)
    }
    ver, cmd, atyp := buf[0], buf[1], buf[3]
    if ver != socks5Ver {
       return fmt.Errorf("not supported ver:%v", ver)
    }
    if cmd != cmdBind {
       return fmt.Errorf("not supported cmd:%v", cmd)
    }
    addr := ""
    switch atyp {
    case atypeIPV4:
       _, err = io.ReadFull(reader, buf)
       if err != nil {
          return fmt.Errorf("read atyp failed:%w", err)
       }
       addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
    case atypeHOST:
       hostSize, err := reader.ReadByte()
       if err != nil {
          return fmt.Errorf("read hostSize failed:%w", err)
       }
       host := make([]byte, hostSize)
       _, err = io.ReadFull(reader, host)
       if err != nil {
          return fmt.Errorf("read host failed:%w", err)
       }
       addr = string(host)
    case atypeIPV6:
       return errors.New("IPv6: no supported yet")
    default:
       return errors.New("invalid atyp")
    }
    _, err = io.ReadFull(reader, buf[:2])
    if err != nil {
       return fmt.Errorf("read port failed:%w", err)
    }
    port := binary.BigEndian.Uint16(buf[:2])

    dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
    if err != nil {
       return fmt.Errorf("dial dst failed:%w", err)
    }
    defer dest.Close()
    log.Println("dial", addr, port)

    // +----+-----+-------+------+----------+----------+
    // |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
    // +----+-----+-------+------+----------+----------+
    // | 1  |  1  | X'00' |  1   | Variable |    2     |
    // +----+-----+-------+------+----------+----------+
    // VER socks版本，这里为0x05
    // REP Relay field,内容取值如下 X’00’ succeeded
    // RSV 保留字段
    // ATYPE 地址类型
    // BND.ADDR 服务绑定的地址
    // BND.PORT 服务绑定的端口DST.PORT
    _, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
    if err != nil {
       return fmt.Errorf("write failed: %w", err)
    }
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go func() {
       _, _ = io.Copy(dest, reader)
       cancel()
    }()
    go func() {
       _, _ = io.Copy(conn, dest)
       cancel()
    }()

    <-ctx.Done()
    return nil
}

这样我们的代理服务器就终于完工了。 我们来测试一下。 执行cur命令，此时，终于返回了成功。

2023/08/05 23:36:03 dial api.bilibili.com 443 2023/08/05 23:36:03 dial i0.hdslb.com 443 2023/08/05 23:36:03 dial passport.bilibili.com 443 2023/08/05 23:36:03 dial s1.hdslb.com 443 2023/08/05 23:36:03 dial static.clewm.net 443 2023/08/05 23:36:03 dial cm.bilibili.com 443 2023/08/05 23:36:03 dial cm.bilibili.com 443 2023/08/05 23:36:03 dial api.vc.bilibili.com 443 2023/08/05 23:36:03 dial api.live.bilibili.com 443

我们可以试着在浏览器里面再测试一 下，在浏览器里面测试代理需要安装这个switchomega插件，然后里面新建一 个情景模式，代理服务器选socks5, 端口1080，保存并启用。 此时你应该还能够正常地访问网站，代理服务器这边会显示出浏览器版本的域名和端口。