当前位置：首页 > news >正文

【字节跳动青训营】后端笔记整理-2 | Go实践记录：猜谜游戏，在线词典，Socks5代理服务器

news 2025/6/21 3:41:49

**本人是第六届字节跳动青训营（后端组）的成员。本文由博主本人整理自该营的日常学习实践，首发于稀土掘金：🔗Go实践记录：猜谜游戏，在线词典，Socks5代理服务器 | 青训营

我的go开发环境：

*本地IDE：GoLand 2023.1.2

*go：1.20.6

一、猜谜游戏

猜数字游戏也算是入门一门编程语言必写的程序了。通过这个程序，我们可以熟悉Go语言中的输入输出、流程控制与随机函数的调用。

1、生成随机数

在Go语言中，标准库math/rand下的一系列方法可以用来生成随机数。

math/rand库的官方文档：https://pkg.go.dev/math/rand

通过调用库中的rand.Intn(n)函数，可以生成一个 [0,n) 的随机整数：

//Go 1.20
package mainimport ("fmt""math/rand"
)func main() {maxNum := 100for i := 0; i < 10; i++ {    //生成10个随机整数secretNum := rand.Intn(maxNum)        //每次生成的随机数在 [0,100)fmt.Println("随机数是", secretNum)}
}

注意：生成的这10个随机整数是否相同呢？

在我所使用的 Go 1.20.6 下，生成的10个随机数是各不相同的。也就是说，从 Go 1.20 开始，rand.Intn()生成的是真随机数，不需要设定Seed()。

依照官方的说法，math/rand 已弃用 rand.Seed(…) 全局函数，现在自动为全局随机数生成器Int生成一个随机值，并且顶级Seed函数已被弃用。因此，每次运行程序时会生成不同的随机数。

但如果在 Go 1.20 版本之前，如培训中王克纯老师演示的（Go 1.18），在调用rand.Intn()之前必须先通过 rand.Seed()设置随机数种子，这样才能让每次运行生成的随机数值不同，否则，由于随机数种子固定，每次运行生成的随机数也是固定的一个值，并不“随机”。

通常，用时间戳来作为随机数的种子。（这一点特性和C语言的rand()是类似的。）

//Go 1.20 之前package mainimport ("fmt""math/rand""time"
)func main() {maxNum := 100rand.Seed(time.Now().UnixNano())secretNumber := rand.Intn(maxNum)fmt.Println("The secret number is ", secretNumber)
}

2、读取用户输入

这里直接用 fmt.Scan() 来读取用户的输入。

fmt.Scan() 函数用于从标准输入中读取数据，并根据提供的格式字符串将输入解析为相应的变量。这个函数会一直等待用户输入，直到按下回车键，并尝试将输入解析为指定的变量类型：

package mainimport ("fmt"
)func main() {var num intfmt.Print("请输入一个整数: ")_, err := fmt.Scan(&num)if err != nil {fmt.Println("输入错误:", err)return}fmt.Println("您输入的整数是:", num)
}

在这个示例中，fmt.Scan(&num) 会等待用户输入，并将输入解析为整数，并将其存储到 num 变量中。如果输入无法解析为整数，将会返回错误。

注意，fmt.Scan() 函数需要提供变量的地址作为参数，以便将解析后的值存储到变量中。也可以在 fmt.Scan() 中使用格式字符串来匹配特定的输入格式，以及处理多个变量的读取。

通过 fmt.Scan() 完善猜数字的代码：

maxNum := 100
secretNum := rand.Intn(maxNum)
fmt.Println("随机数是", secretNum)fmt.Println("请输入你猜测的数字:>")
var guess int
_, err := fmt.Scan(&guess)
if err != nil {fmt.Println("输入出错！", err)return
}

3、实现逻辑判断与循环游戏

加上 if-else 对输入的 guess 与随机数 secretNum 进行值的校验，来得出用户是否猜中数字；加上循环，实现多次游戏。这样，猜数字游戏的程序就完成了。

package mainimport ("fmt""math/rand"
)func main() {maxNum := 100secretNum := rand.Intn(maxNum)//fmt.Println("随机数是", secretNum)for {fmt.Println("请输入你猜测的数字:>")var guess int_, err := fmt.Scan(&guess)if err != nil {fmt.Println("输入出错！", err)continue    //输入出错不能直接退出程序，而是进入下一次输入}if guess > secretNum {fmt.Println("猜大了！")} else if guess < secretNum {fmt.Println("猜小了！")} else {fmt.Println("恭喜你！猜中了！")break}}
}

二、在线词典

第二个案例是一个命令行词典。效果是输入一个单词，命令行中会显示这个单词的发音和注释。

原理是调用第三方的API去查询结果，并且其打印出来。

实现这个程序的关键在于，如何用Go语言发送HTTP请求和解析JSON。

1、抓包

以彩云小译为例：https://fanyi.caiyunapp.com/#/

分析这个请求：

2、代码自动生成

我们要实现在Golang里发送这个请求。

但这个请求很复杂，直接用代码来构造很麻烦，所以我们可以用另一种简单的方式来生成请求。

右键浏览器中的请求：

点击 Copy as cURL(bash) 后，打开这个网址：https://curlconverter.com/go/

把刚才复制的东西粘贴进去，自动会生成响应的请求代码：

将这些代码复制到Goland：

package mainimport ("fmt""io""log""net/http""strings"
)func main() {client := &http.Client{}var data = strings.NewReader(`{"trans_type":"en2zh","source":"hello"}`)req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)if err != nil {log.Fatal(err)}req.Header.Set("authority", "api.interpreter.caiyunai.com")req.Header.Set("accept", "application/json, text/plain, */*")req.Header.Set("accept-language", "zh-CN,zh;q=0.9")req.Header.Set("app-name", "xy")req.Header.Set("cache-control", "no-cache")req.Header.Set("content-type", "application/json;charset=UTF-8")req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")req.Header.Set("origin", "https://fanyi.caiyunapp.com")req.Header.Set("os-type", "web")req.Header.Set("os-version", "")req.Header.Set("pragma", "no-cache")req.Header.Set("referer", "https://fanyi.caiyunapp.com/")req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)req.Header.Set("sec-ch-ua-mobile", "?0")req.Header.Set("sec-ch-ua-platform", `"Windows"`)req.Header.Set("sec-fetch-dest", "empty")req.Header.Set("sec-fetch-mode", "cors")req.Header.Set("sec-fetch-site", "cross-site")req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")resp, err := client.Do(req)if err != nil {log.Fatal(err)}defer resp.Body.Close()bodyText, err := io.ReadAll(resp.Body)if err != nil {log.Fatal(err)}fmt.Printf("%s\n", bodyText)
}

代码解读：

这里特别解释一下上图中第40行的 defer 关键字。

在 Go 语言中，defer 是一个用于延迟函数调用执行的关键字。通过使用 defer，可以在函数返回之前（无论这个函数是正常结束还是发生了异常），推迟某个函数的执行。这在编写代码时可以很有用，特别是在需要确保资源释放或清理操作的情况下。

defer 语句的语法是：
defer functionCall(arguments)
当在一个函数内部使用 defer 时，被推迟执行的函数调用会被添加到一个栈中，而不会立即执行。在函数执行完毕并即将返回之前，栈中的函数调用会按照逆序执行。因此，如果有多个 defer 语句，它们会按照后进先出（LIFO）的顺序执行，即最后一个推迟的函数调用会最先执行，而最早的推迟的函数调用会最后执行。

以下示例演示了有三个 defer 的情况：
package mainimport "fmt"func main() {defer fmt.Println("第一个defer")defer fmt.Println("第二个defer")defer fmt.Println("第三个defer")fmt.Println("正常的函数调用")
}
在这个示例中，尽管 fmt.Println("正常的函数调用") 在代码中位于三个 defer 语句之前，但它会最先执行。然后，defer 语句会按照后进先出的顺序执行，所以先执行第三个 defer，然后是第二个 defer，最后是第一个 defer。这就是 defer 的执行顺序。

defer 的设计是为了在函数返回前执行一些清理工作，或者确保一些资源被正确释放。通过使用 defer，我们可以更方便地管理代码，并确保清理操作不会被遗漏。

运行自动生成得到的代码块，成功输出一大串JSON：

说明请求成功。

但是，这片请求代码是固定的，传入的data也是固定的 data = strings.NewReader(`{"trans_type":"en2zh","source":"hello"}`)

我们肯定希望用户能通过一个变量进行输入，想翻译什么单词，就翻译什么单词，而不是固定的只能输入JSON字符串。因此，我们要用到JSON序列化。

3、生成request body

如何进行JSON序列化？在上一篇文章中提到过：https://juejin.cn/post/7265577455208955938#heading-62

只需要构造一个结构体，让这个结构体的字段名称和JSON的结构一一对应，然后直接调用 json.Marshal() 即可。

因此这里，我们也需要构造出一个结构体，然后将结构体序列化，通过这样的方式，让data中的值是可变的：

package mainimport ("bytes""encoding/json""fmt""io""log""net/http"
)//构建结构体
type DictRequest struct {TransType string `json:"trans_type"`Source    string `json:"source"`UserID    string `json:"user_id"`
}func main() {client := &http.Client{}//将翻译的类型和要翻译的单词传入结构体request := DictRequest{TransType: "en2zh", Source: "hello"}buf, err := json.Marshal(request)if err != nil {log.Fatal(err)}var data = bytes.NewReader(buf)req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)if err != nil {log.Fatal(err)}req.Header.Set("authority", "api.interpreter.caiyunai.com")req.Header.Set("accept", "application/json, text/plain, */*")req.Header.Set("accept-language", "zh-CN,zh;q=0.9")req.Header.Set("app-name", "xy")req.Header.Set("cache-control", "no-cache")req.Header.Set("content-type", "application/json;charset=UTF-8")req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")req.Header.Set("origin", "https://fanyi.caiyunapp.com")req.Header.Set("os-type", "web")req.Header.Set("os-version", "")req.Header.Set("pragma", "no-cache")req.Header.Set("referer", "https://fanyi.caiyunapp.com/")req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)req.Header.Set("sec-ch-ua-mobile", "?0")req.Header.Set("sec-ch-ua-platform", `"Windows"`)req.Header.Set("sec-fetch-dest", "empty")req.Header.Set("sec-fetch-mode", "cors")req.Header.Set("sec-fetch-site", "cross-site")req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")resp, err := client.Do(req)if err != nil {log.Fatal(err)}defer resp.Body.Close()bodyText, err := io.ReadAll(resp.Body)if err != nil {log.Fatal(err)}fmt.Printf("%s\n", bodyText)
}

上述代码中，手动将要翻译的类型（“en2zh”）和单词（“hello”）传入了结构体。

此时代码的运行结果应与一开始的代码运行结果完全相同。对请求的序列化的逻辑就完成了。

4、解析 response body

完成了请求的序列化后，我们还要进行响应的反序列化，这样才能得到结果。这我们要解析出这一堆响应，并且获取到其中的一些关键信息如"explanations"等。

如果是python或者js，返回的会是一个字典的结构，可以直接通过 [] 或 . 去取值。但是Go是一种强类型的语言，这种方式并不是最佳实践（虽然也可以做到）。

更常见的方式是和处理request body一样，写一个结构体，这个结构体的字段和返回的response是一一对应的。再把返回的 json 反 序列化 （json.Unmarshal()）到结构体里面。

但是，我们看到，浏览器里返回的这个response结构非常复杂，手动一一创建结构体去对应显然不是好的做法。所以我们还是用代码生成的方式来实现。

打开这个工具网站：https://oktools.net/json2go

然后，把彩云小译界面的 response 的json粘贴进去：

点击“转换-嵌套”，就会生成一个结构体。（如果点击“转换-展开”，会生成独立的多个结构体。）

将生成的结构体代码粘贴到Goland中，将结构体改名为 DictResponse，然后修改最后处理响应的部分代码：

package mainimport ("bytes""encoding/json""fmt""io""log""net/http"
)type DictRequest struct {TransType string `json:"trans_type"`Source    string `json:"source"`UserID    string `json:"user_id"`
}//粘贴过来的响应结构体
type DictResponse struct {Rc   int `json:"rc"`Wiki struct {} `json:"wiki"`Dictionary struct {Prons struct {EnUs string `json:"en-us"`En   string `json:"en"`} `json:"prons"`Explanations []string      `json:"explanations"`Synonym      []string      `json:"synonym"`Antonym      []interface{} `json:"antonym"`WqxExample   [][]string    `json:"wqx_example"`Entry        string        `json:"entry"`Type         string        `json:"type"`Related      []interface{} `json:"related"`Source       string        `json:"source"`} `json:"dictionary"`
}func main() {client := &http.Client{}request := DictRequest{TransType: "en2zh", Source: "hello"}buf, err := json.Marshal(request)if err != nil {log.Fatal(err)}var data = bytes.NewReader(buf)req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)if err != nil {log.Fatal(err)}req.Header.Set("authority", "api.interpreter.caiyunai.com")req.Header.Set("accept", "application/json, text/plain, */*")req.Header.Set("accept-language", "zh-CN,zh;q=0.9")req.Header.Set("app-name", "xy")req.Header.Set("cache-control", "no-cache")req.Header.Set("content-type", "application/json;charset=UTF-8")req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")req.Header.Set("origin", "https://fanyi.caiyunapp.com")req.Header.Set("os-type", "web")req.Header.Set("os-version", "")req.Header.Set("pragma", "no-cache")req.Header.Set("referer", "https://fanyi.caiyunapp.com/")req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)req.Header.Set("sec-ch-ua-mobile", "?0")req.Header.Set("sec-ch-ua-platform", `"Windows"`)req.Header.Set("sec-fetch-dest", "empty")req.Header.Set("sec-fetch-mode", "cors")req.Header.Set("sec-fetch-site", "cross-site")req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")resp, err := client.Do(req)if err != nil {log.Fatal(err)}defer resp.Body.Close()bodyText, err := io.ReadAll(resp.Body)if err != nil {log.Fatal(err)}//处理响应var dictResponse DictResponseerr = json.Unmarshal(bodyText, &dictResponse)if err != nil {log.Fatal(err)}//用 %#v 会以最详细的方式来打印结构体，包括结构体的名字和字段的名字fmt.Println("%#v\n", dictResponse)
}

我们需要从response中筛选出我们需要的信息：如“音标”，“解释”：

//fmt.Println("%#v\n", dictResponse)
fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En,"US:", dictResponse.Dictionary.Prons.EnUs)
for _, item := range dictResponse.Dictionary.Explanations {fmt.Println(item)
}

最终经过调整，完整的程序代码如下：

package mainimport ("bytes""encoding/json""fmt""io""log""net/http""os"
)// 请求
type DictRequest struct {TransType string `json:"trans_type"`Source    string `json:"source"`UserID    string `json:"user_id"`
}// 响应
type DictResponse struct {Rc   int `json:"rc"`Wiki struct {} `json:"wiki"`Dictionary struct {Prons struct {EnUs string `json:"en-us"`En   string `json:"en"`} `json:"prons"`Explanations []string      `json:"explanations"`Synonym      []string      `json:"synonym"`Antonym      []string      `json:"antonym"`WqxExample   [][]string    `json:"wqx_example"`Entry        string        `json:"entry"`Type         string        `json:"type"`Related      []interface{} `json:"related"`Source       string        `json:"source"`} `json:"dictionary"`
}func main() {//检查命令行传入的参数个数（第一个参数是程序名称本身，第二个参数是传入的单词，因此必须是两个参数）if len(os.Args) != 2 {fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)os.Exit(1)}//将第二个命令行参数也就是单词传给变量 wordword := os.Args[1]query(word)
}// 将程序的主要代码封装为query()函数，传入要翻译的单词
func query(word string) {client := &http.Client{}request := DictRequest{TransType: "en2zh", Source: word}buf, err := json.Marshal(request)if err != nil {log.Fatal(err)}var data = bytes.NewReader(buf)req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)if err != nil {log.Fatal(err)}req.Header.Set("authority", "api.interpreter.caiyunai.com")req.Header.Set("accept", "application/json, text/plain, */*")req.Header.Set("accept-language", "zh-CN,zh;q=0.9")req.Header.Set("app-name", "xy")req.Header.Set("cache-control", "no-cache")req.Header.Set("content-type", "application/json;charset=UTF-8")req.Header.Set("device-id", "b72e9f6cbb97432941b8adf317a17dee")req.Header.Set("origin", "https://fanyi.caiyunapp.com")req.Header.Set("os-type", "web")req.Header.Set("os-version", "")req.Header.Set("pragma", "no-cache")req.Header.Set("referer", "https://fanyi.caiyunapp.com/")req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"`)req.Header.Set("sec-ch-ua-mobile", "?0")req.Header.Set("sec-ch-ua-platform", `"Windows"`)req.Header.Set("sec-fetch-dest", "empty")req.Header.Set("sec-fetch-mode", "cors")req.Header.Set("sec-fetch-site", "cross-site")req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36")req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")resp, err := client.Do(req)if err != nil {log.Fatal(err)}defer resp.Body.Close()bodyText, err := io.ReadAll(resp.Body)if err != nil {log.Fatal(err)}//防御性编程if resp.StatusCode != 200 {log.Fatal("bad StatusCode:", resp.StatusCode, "body:", string(bodyText))}var dictResponse DictResponseerr = json.Unmarshal(bodyText, &dictResponse)if err != nil {log.Fatal(err)}//fmt.Println("%#v\n", dictResponse)fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En,"US:", dictResponse.Dictionary.Prons.EnUs)for _, item := range dictResponse.Dictionary.Explanations {fmt.Println(item)}
}

在命令行运行：输入要翻译的单词，可以调用接口实现在线翻译

三、SOCKS5代理服务器

对于大家来说，一提到代理服务器，第一想到的是翻墙。不过遗憾的是， socks5 协议它虽然是代理协议，但它并不能用来翻墙，它的协议都是明文传输。这个协议历史比较久远，诞生于互联网早期。

它的用途是，比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用是访问某些资源会很麻烦。socks5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻墙软件，最终暴露的也是一个 socks5 协议的端口。

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

**socks5协议的原理

正常浏览器访问一个网站，如果不经过代理服务器的话，会先和对方的网站建立 TCP 连接，然后三次握手。握手完之后发起 HTTP 请求，然后服务返回 HTTP 响应。

如果设置代理服务器之后，流程会变得复杂一些：

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

这个就是 socks5 协议的工作原理，接下来我们尝试去简单地实现它。

1、TCP echo server

在实现代理服务器之前，我们先实现一个简单的回显服务器，以测试我们的server写的对不对。

当运行时，此代码将创建一个简单的 TCP 服务器，监听在 127.0.0.1 的 1080 端口上，接受客户端连接并将客户端发送的数据原样返回。以下是逐句加注释的代码解释：

package mainimport ("bufio""log""net"
)func main() {// 在本地的 127.0.0.1:1080 地址上创建一个 TCP 服务器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}// 启动一个新的 goroutine 处理客户端连接go process(client)}
}func process(conn net.Conn) {// 在函数退出时关闭客户端连接defer conn.Close()// 创建一个用于读取客户端数据的 bufio.Readerreader := bufio.NewReader(conn)for {// 从客户端读取一个字节b, err := reader.ReadByte()if err != nil {break}// 将读取的字节原样发送回客户端_, err = conn.Write([]byte{b})if err != nil {break}}
}

这是一个基本的 TCP 服务器，用于接受客户端连接并将接收到的数据返回给客户端。每当客户端发送一个字节，服务器会将相同的字节返回。

我们通过nc命令来进行测试。首先需要下载netcat，地址及教程：https://blog.csdn.net/BoomLee/article/details/102563472

安装配置完毕后，Goland中启动echo-server程序（直接启动或用命令go run echo-server.go）。启动后，另开一个cmd窗口，在其中输入nc命令：nc 127.0.0.1 1080

输入什么就显示什么，一个简单的回显服务器就搞定了。

2、认证阶段：auth

package mainimport ("bufio""fmt""io""log""net"
)const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04func main() {server, err := net.Listen("tcp", "127.0.0.1:1080") // 在 127.0.0.1 的 1080 端口上创建 TCP 服务器if err != nil {panic(err)}for {client, err := server.Accept() // 接受客户端连接if err != nil {log.Printf("Accept failed %v", err)continue}go process(client) // 启动一个新的 goroutine 处理客户端连接}
}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}log.Println("auth success")
}// +----+----------+----------+
// |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
func auth(reader *bufio.Reader, conn net.Conn) (err error) {// 解析客户端发送的认证请求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
}

这段代码演示了一个简单的 SOCKS5 服务器，用于处理客户端的认证请求，并向客户端发送响应。现在我们用 curl 命令进行一下测试。首先还是一样，在Goland运行项目程序。然后在另一个终端执行curl命令：

curl --socks5 127.0.0.1:1080 -v http://www.qq.com

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

3、请求阶段

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

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

再实现 connect 函数的代码。根据请求阶段的逻辑，浏览器会发送一个包，包里面包含如下6个字段：

VER 版本号，socks5的值为0x05
CMD 0x01表示CONNECT请求
RSV 保留字段，值为0x00
ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
1. 0x01表示IPv4地址，DST.ADDR为4个字节
2. 0x03表示域名，DST.ADDR是一个可变长度的域名
DST.ADDR 一个可变长度的值
DST.PORT 目标端口，固定2个字节

接下来我们要挨个去把这6个字段读出来。

面这四个字段总共四个字节，我们可以一次性把它读出来。创建一个长度为4的缓冲区，然后用io.ReadFull()把它整个填充满。

//connect()buf := make([]byte, 4)
_, err = io.ReadFull(reader, buf)
if err != nil {return fmt.Errorf("read header failed:%w", err)
}

这样就能一次性读取到前面4个字段，它们是定长的。对于每个字段，都要验证合法性：

//connect()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")
}

最后还有两个字节是 port ，我们读取它，然后按协议规定的大端字节序转换成数字。

由于上面的 buffer 已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice ，长度是2，用于读取，这样的话最多会只读两个字节回来。接下来我们把这个地址和端口打印出来用于调试。

//connect()_, 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)

收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用：

运行测试：虽然还没有完全成功，但是能够打印出IP地址和端口号了，说明实验还是成功的。

4、relay阶段

直接用 net.Dial 建立一个 TCP 连接。建立完连接之后，同样要加一个 defer 来关闭连接。

接下来需要建立浏览器和下游服务器的双向数据转发。标准库的 io.Copy 可以实现一个单向数据转发。完成双向转发还需启动两个 goroutinue。

完整代码如下

package mainimport ("bufio""context""encoding/binary""errors""fmt""io""log""net"
)const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04func 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/PASSWORDver, 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
}

到此，socks5代理服务器就实现完成了。

也可以在浏览器中进行测试。Chrome浏览器只需安装SwitchyOmega插件：

可以在浏览器里面再测试一下，在插件中新建一个情景模式，代理服务器选 socks5，端口 1080 ，保存并启用。此时你正常地访问其它网站，代理服务器这边会显示出浏览器版本的域名和端口。

至此，Go语言入门的三个实战项目就完成了。