Go 语言学习（三） SOCKS5 代理项目|青训营笔记

Go 语言学习（三） SOCKS5 代理项目_青训营笔记

• Go 语言学习（三） SOCKS5 代理项目_青训营笔记
  • 一、 SOCKS5 代理项目介绍
  • 二、SOCKS5 代理原理
  • 三、开发步骤
    • 1. TCP echo server
    • 2. auth
    • 3. 请求阶段
    • 4. relay 阶段
  • 四、代码展示

这是我参与「第三届青训营 -后端场」笔记创作活动的的第 3 篇笔记。

一、 SOCKS5 代理项目介绍

• SOCKS5 是一个代理服务器 ，SOCKS5 的协议都是明文传输。

• 这个协议历史比较久远，诞生于互联网早期。在某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦，SOCKS5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多软件，最终暴露的也是一个 SOCKS5 协议的端口。

• 在开发爬虫的时候，在爬取过程中很容易会遇到 IP 访问频率超过限制，这个时候可以去网上找一些代理 IP 池，这些代理 IP 池里面的很多代理的协议就是 SOCKS5。

• 以下为最终写完的代理服务器的效果。
• 启动这个程序，然后在浏览器里面配置使用这个代理，此时打开网页。代理服务器的日志会打印出访问的网站的域名或者 IP ，这说明网络流量是通过这个代理服务器的。
• 也能在命令行去测试我们的代理服务器。可以用 curl -socks5 + 代理服务器地址，后面加一个可访问的 URL， 如果代理服务器工作正常，那么 curl 命令就会正常返回。

二、SOCKS5 代理原理

• 正常浏览器访问一个网站，如果不经过代理服务器，就是先和对方的网站建立 TCP 连接，然后三次握手，握手完之后发起 HTTP 请求，然后服务返回 HTTP 响应。
• 如果设置代理服务器之后，流程会变得复杂一些。首先是浏览器和 SOCKS5 代理建立 TCP 连接，代理再和真正的服务器建立 TCP 连接。
• 这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、 relay 阶段。
• 第一个握手阶段，浏览器会向 SOCKS5 代理发送请求，内容包括协议的版本号，还有支持的认证的种类，SOCKS5 服务器会选中一个认证方式，返回给浏览器。如果返回的是 00 的就代表不需要认证，返回其他类型的话会开始认证流程。
• 第三个阶段是请求阶段，认证通过之后浏览器会 SOCKS5 服务器发起请求。主要信息包括版本号，请求的类型，一般主要是 connection 请求，就代表代理服务器要和某个域名或者某个 IP 地址某个端口建立 TCP 连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。
• 第四个阶段是 relay 阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边。实际上代理服务器并不关心流量的细节，可以是 HTTP 流量，也可以是其它 TCP 流量。
• 这个就是 SOCKS5 协议的工作原理。

三、开发步骤

1. TCP echo server

第一步，先在 Go 里面写一个简单的 TCP echo server。为了方便测试， server 的工作逻辑很简单，你给他发送啥，他就回复啥。

2. auth

• 接下来要开始实现协议的第一步，认证阶段。
• 我们实现一个 auth 函数，在 process 函数里面调用。
• 认证阶段的逻辑为，第一步，浏览器会给代理服务器发送一个包，这个包有三个字段。
• 第一个字段，version 协议版本号，固定是 5。
• 第二个字段，methods 认证的方法数目。
• 第三个字段，每个 method 的编码，0 代表不需要认证，2 代表用户名密码认证。
• 先用 read bytes 来把版本号读出来，如果版本号不是 socket 5 的话直接返回报错，接下来再读取 method size ，也是一个字节。然后需要去 make 一个相应长度的一个 slice ，用 io.ReadFull 把它去填充进去。现在把获取到的版本号和认证方式打印一下。此时，代理服务器还需要返回一个 response，返回包括 两个字段，一个是 version ，一个是 method。

3. 请求阶段

• 接下来开始做第三步，实现请求阶段。
• 试图读取到携带 URL 或者 IP 地址+端口的包，然后把它打印出来。实现一个和 auth 函数类似的 connect 函数，同样在 process 里面去调用。
• 请求阶段，浏览器会发送一个包，包里面包含如下 6 个字段， version 版本号，command 请求的类型，RSV 保留字段，atype 就是目标地址类型，可能是 IPV 4 IPV 6 或者域名，addr 地址，port 端口号，然后需要逐个去读取这些字段。
• 接下来把这个地址和端口打印出来用于调试，收到浏览器的这个请求包之后，需要返回一个包。

4. relay 阶段

• 直接用 net.dial 建立一个 TCP 连接，建立完连接之后，要加一个 defer 来关闭连接。
• 接下来需要建立浏览器和下游服务器的双向数据转发。
• 标准库的 io.copy 可以实现一个单向数据转发，双向转发需要启动两个 goroutinue。
• 这里可以使用到标准库里面的一个 context 机制，用 context 连 with cancel 来创建一个 context，在最后等待 ctx.Done() ，只要 cancel 被调用， ctx.Done 就会立刻返回，然后在上面的两个 goroutinue 里面 调用一次 cancel 即可。

四、代码展示

经过课后编程实践，我实现了一个简单的 SOCKS5 代理服务器。

下面是我的代码展示，包含了代码详细注释，便于理解。

package main

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

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

func main() { //此在SOCKS5 代理程序需要在命令行运行，如输入 go run main.go 和 curl.exe --socks5 127.0.0.1:1080 -v http://www.baidu.com
   server, err := net.Listen("tcp", "127.0.0.1:1080") // Listen()可以收听本地网络地址上的广播，以此来侦听一个端口
   if err != nil {
      panic(err) // panic() 会停止当前 goroutine 协程的正常执行
   }
   for {
      client, err := server.Accept() // Accept() 等待并将下一个连接返回给侦听器
      if err != nil {
         log.Printf("Accept failed %v", err)
         continue
      }
      go process(client) //go 启动一个子线程或 goroutine 协程（处理并发）来处理连接
   }
}

func process(conn net.Conn) { // Conn 是一个通用的面向流的网络连接。 多个 goroutine 协程可以同时调用 Conn 上的方法
   defer conn.Close()              // defer 会在函数结束后从后往前触发，Close() 手动关闭连接
   reader := bufio.NewReader(conn) // 把输入的连接转换成只读的带缓冲的流
   err := auth(reader, conn)
   if err != nil {
      log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err) // RemoteAddr() 返回远程网络地址
      return
   }
   err = connect(reader, conn)
   if err != nil {
      log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err) // RemoteAddr() 返回远程网络地址
      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() // ReadByte() 读取并返回单个字节，读取到版本号 VER
   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() // ReadByte() 读取并返回单个字节，读取到支持认证的方法数量 NMETHODS
   if err != nil {
      return fmt.Errorf("read methodSize failed:%w", err)
   }
   method := make([]byte, methodSize)   // 创建一个 method 的缓冲区
   _, err = io.ReadFull(reader, method) // ReadFull() 将reader中的字节准确地读取到 method 中
   if err != nil {
      return fmt.Errorf("read method failed:%w", err)
   }

   // +----+--------+
   // |VER | METHOD |
   // +----+--------+
   // | 1  |   1    |
   // +----+--------+
   _, err = conn.Write([]byte{socks5Ver, 0x00}) // 返回协议版本号 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) // ReadFull() 将 reader 中的 len(buf) 个字节准确地读取到 buf 中
   if err != nil {
      return fmt.Errorf("read header failed:%w", err)
   }

   /*读取到 VER、CMD、ATYP，并验证其合法性*/
   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", ver)
   }
   addr := ""
   switch atyp {
   case atypIPV4:
      _, 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]) // binary 实现了数字和字节序列之间的简单转换以及 varints 的编码和解码

   dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port)) //Dial() 拨号连接到指定网络上的地址,进行 TCP 连接
   if err != nil {
      return fmt.Errorf("dial dst failed:%w", err)
   }
   defer dest.Close() // defer 会在函数结束后从后往前触发，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)
   }
   /*
      WithCancel() 返回具有新 Done 通道的 parent 副本。返回的上下文的完成通道在调用返回的取消函数或父上下文的完成通道关闭时关闭，以先发生者为准，
      取消此上下文会释放与其关联的资源，因此代码应在此上下文中运行的操作完成后立即调用取消
   */
   ctx, cancel := context.WithCancel(context.Background()) // Background() 返回一个非零、空的Context
   defer cancel()

   /* 启动2个协程，实现双向数值转换 */
   /* 从浏览器到服务器 */
   go func() {
      _, _ = io.Copy(dest, reader) // 将副本从 reader 复制到 dest，直到在 reader 上达到EOF或发生错误，它返回复制的字节数和复制时遇到的第一个错误（如果有）
      cancel()
   }()
   /* 从服务器到浏览器 */
   go func() {
      _, _ = io.Copy(conn, dest) // 将副本从 dest 复制到 conn，直到在 dest 上达到EOF或发生错误，它返回复制的字节数和复制时遇到的第一个错误（如果有）
      cancel()
   }()

   <-ctx.Done() // Done() 代表此上下文完成的工作应该被取消时，Done 返回一个关闭的通道
   return nil
}