这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记
Go语言语法
对Go语言语法进行了简要说明，详细用法可以参考Go语言圣经
实战
项目一：猜谜游戏
用Golang来构建一个猜谜游戏，程序首先会生成一个介于1到100之间的随机整数，然后玩家进行猜测。玩家每输入一个数字，程序都会反馈一个信息告诉玩家是高于正确答案还是低于正确答案，直到玩家输入正确。
项目代码
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
maxNum := 100
rand.Seed(time.Now().UnixNano()) //用时间戳来初始化随机数种子
secretNumber := rand.Intn(maxNum)
//fmt.Println("The secret number is ", secretNumber)
/* 实现用户的输入输出，并解析成数字 */
fmt.Println("Please input your guess")
//reader := bufio.NewReader(os.Stdin) //转成只读流
for {
//input, err := reader.ReadString('\n') //从只读流中读取一行
//if err != nil {
// fmt.Println("An error occured while reading input.Please try again", err)
// //return
// continue
//}
//
//input = strings.TrimSuffix(input, "\n") //去掉换行符
//
var guess int
_, err := fmt.Scanf("%d", &guess)
if err != nil {
fmt.Println("Invaild input. Please enter an integer value")
//return
continue
}
fmt.Println("You guess is", guess)
/* 实现判断逻辑 */
if guess > secretNumber {
fmt.Println("Your guess is bigger than the secret number.Please try again")
} else if guess < secretNumber {
fmt.Println("Your guess is smaller than the secret number.Please try again")
} else {
fmt.Println("Correct,you legend")
break
}
}
}
复制代码项目二：在线词典
用户可以在命令行内输入一个单词，我们通过调用第三方的API查询到单词的翻译并打印出来 即需要三步：1.输入单词，2.通过reques调用API，3.获取response并打印
第一步没必要说
第二步：
首先要找到第三方API，我们打开翻译网站，这里以彩云小译为例，在翻译栏中输入一个单词，打开网站源代码模式，找到network，从下往上开始找，找到状态为200，请求方式为POST的一栏
然后右键dict，以cURL的格式复制，这时我们会得到一串json
通过这个网站将其转换成代码，直接粘接到IDE里运行，会返回request body得到一串Json（即数组或者字符串）
package main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"strings"
)
func main() {
client := &http.Client{}
var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Accept", "application/json, text/plain, */*")
req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
req.Header.Set("Connection", "keep-alive")
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36")
req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
req.Header.Set("app-name", "xy")
req.Header.Set("os-type", "web")
req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"`)
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("sec-ch-ua-platform", `"macOS"`)
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", bodyText)
}
复制代码但现在的request信息是固定的，为了能更方便的提取信息，利用结构体将JSON序列化，再输出会得到一样的结果，因为结构体内的source还没更改。
package main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"strings"
)
type DictRequest struct {
TransType string `json:"trans_type"`
Source string `json:"source"`
UserID string `json:"user_id"`
}
func main() {
client := &http.Client{}
//var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
//初始化结构体成员
request := DictRequest{TransType: "en2zh", Source: word}
//调用json.Marshal来序列化request变成一个byte数组
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("Accept", "application/json, text/plain, */*")
req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
req.Header.Set("Connection", "keep-alive")
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36")
req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
req.Header.Set("app-name", "xy")
req.Header.Set("os-type", "web")
req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"`)
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("sec-ch-ua-platform", `"macOS"`)
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", bodyText)
}
复制代码第三步：获取response
在相同的dict内复制preview内的值，粘贴到网站，可以很方便的将JSON转成GO结构体,粘贴到IDE内后，并更改后续代码可以得到response信息。
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 {
KnownInLaguages int `json:"known_in_laguages"`
Description struct {
Source string `json:"source"`
Target interface{} `json:"target"`
} `json:"description"`
ID string `json:"id"`
Item struct {
Source string `json:"source"`
Target string `json:"target"`
} `json:"item"`
ImageURL string `json:"image_url"`
IsSubject string `json:"is_subject"`
Sitelink string `json:"sitelink"`
} `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() {
//创建一个http实例
client := &http.Client{}
//初始化结构体成员
request := DictRequest{TransType: "en2zh", Source: word}
//调用json.Marshal来序列化request变成一个byte数组
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("Connection", "keep-alive")
req.Header.Set("DNT", "1")
req.Header.Set("os-version", "")
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
req.Header.Set("app-name", "xy")
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("Accept", "application/json, text/plain, */*")
req.Header.Set("device-id", "")
req.Header.Set("os-type", "web")
req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
req.Header.Set("Sec-Fetch-Site", "cross-site")
req.Header.Set("Sec-Fetch-Mode", "cors")
req.Header.Set("Sec-Fetch-Dest", "empty")
req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
//发起请求
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
//读取响应
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
if resp.StatusCode != 200 {
log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
}
//定义一个结构体对象
var dictResponse DictResponse
//用Unmarshal将body反序列化到结构体中
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
log.Fatal(err)
}
fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
for _, item := range dictResponse.Dictionary.Explanations {
fmt.Println(item)
}
}
复制代码但此时的程序还是死的，只能查询一个单词且执行一次，我们将main函数改成query函数并通过word传参给source可实现查询任意单词
func query(word string) {
//创建一个http实例
client := &http.Client{}
//初始化结构体成员
request := DictRequest{TransType: "en2zh", Source: word}
//调用json.Marshal来序列化request变成一个byte数组
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("Connection", "keep-alive")
req.Header.Set("DNT", "1")
req.Header.Set("os-version", "")
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
req.Header.Set("app-name", "xy")
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("Accept", "application/json, text/plain, */*")
req.Header.Set("device-id", "")
req.Header.Set("os-type", "web")
req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
req.Header.Set("Sec-Fetch-Site", "cross-site")
req.Header.Set("Sec-Fetch-Mode", "cors")
req.Header.Set("Sec-Fetch-Dest", "empty")
req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
//发起请求
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
//读取响应
bodyText, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
if resp.StatusCode != 200 {
log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
}
//定义一个结构体对象
var dictResponse DictResponse
//用Unmarshal将body反序列化到结构体中
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
log.Fatal(err)
}
fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
for _, item := range dictResponse.Dictionary.Explanations {
fmt.Println(item)
}
}
func main() {
//如果命令和参数的个数不是2
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
`)
os.Exit(1)
}
word := os.Args[1]
query(word)
}
复制代码至此项目二完成
项目三 socks5代理
先了解socks5工作原理
正常浏览器访问一个网站，如果不经过代理服务器的话，就是先和对方的网站建立TCP连接，然后三次握手，握手完之后发起HTTP请求，然后 服务返回HTTP响应。如果设置代理服务器之后，流程会变得复杂一些。
首先是浏览器和socks5代理建立TCP连接，代理再和真正的服务器建立TCP连接。这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、relay 阶段。
第一个握手阶段，浏览器会向socks5代理发送请求，包的内容包括一个协议的版本号， 还有支持的认证的种类，socks5 服务器会选中-个认证方式，返回给浏览器。如果返回的是00的话就代不需要认证，返回其他类型的话会开始认证流程，这里我们就不对认证流程进行概述了。
第三个阶段是请求阶段，认证通过之后浏览器会socks5服务器发起请求。主要信息包括版本号，请求的类型，一般主要是connection请求，就代表代理服务器要和某个域名或者某个IP地址某个端口建立TCP连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。
第四个阶段是relay阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求 转发到浏览器这边。然后实际上代理服务器并不关心流量的细节，可以是HTTP流量，也可以是其它TCP流量。这个就是 socks5 协议的工作原理，接下来我们就会试图去简单地实现它。
1.建立一个简单的TCP echo server
注意这前面会有个go关键字，这个代表启动一个goroutinue，可以暂时类比为其他语言 里面的启动一个子线程。 只是这里的goroutinue的开销会比子线程要小很多，可以很轻松地处理上万的并
接下来是这个process函数的实现。首先第一步的话会先加一 个defer connection.close()，defer 是Golang里面的一个语法，这一行的含 义就是代表在这个函数退出的时候要把这个连接关掉，否则会有资源的泄露。
接下来的话我们会用bufio.NewReader 来创建一个 带缓冲的只读流，这个在前面的猜谜游戏里面也有用到，带 缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便是一个字节一个字节的读取，但是底层可能合并成几次大的读取操作。并且带缓冲的流会有更多的一些工具函数用来读取数据。
我们可以简单地调用那个readbyte函数来读取单个字节。再把这一个字节写进去连接。
func main() {
//监听一个端口，返回server
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代表采用goroutine
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
}
}
}
复制代码测试：运行代码后输入 nc 127.0.0.1 1080 然后在命令行输入什么信息就会返回什么信息
2.握手-认证阶段
就这样我们就已经完成了一个能够返回你输入信息的一个TCP server,接下来我们是要开始实现协议的第一步， 认证阶段，从这一 部分开始会变得比较复 杂。
我们实现一个空的auth函数，在process函数里面调用，再来编写auth函数的代码。
我们回忆一下认证阶段的逻辑，首先第一步的话， 浏览器会给代理服务器发送一个包， 然后这个包有三个字段，
第一个字段，version 也就是协议版本号，固定是5第二个字段methods，认证的方法数目第三个字段每个method的编码，0代表 不需要认证，2 代表用户名密码认证
我们先用read bytes来把版本号读出来，然后如果版本号不是socket 5的话直接返回报错，接下来我们再读取methodsize,也是一个字节。 然后我们需要我们去make一个相应长度的一个slice，用io.ReadFull把它去填充进去。
写到这里，我们把获取到的版本号和认证方式打印一下。
此时，代理服务器还需要返回一个response，返回包包括 两个字段，一个 是version一个是method,也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00。
我们用curl命令测试一下当前版本的效果
测试：curl --socks5 127.0.0.1:1080 -v www.qq.com
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")
}
}
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
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)
}
//对应NMETHNODS
methodSize, err := reader.ReadByte()
if err != nil {
return fmt.Errorf("read methodSize failed:%w", err)
}
//根据method的大小创建一个缓冲区
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
}
复制代码3.请求阶段
接下来我们开始做第三步，实现请求阶段，我们试图读取到携带URL或者IP地址+端口的包，然后把它打印出来。我们实现一个和auth函数类似的connect 函数，同样在process里面去调用。再来实现connect函数的代码。
我们来回忆一 下请求阶段的逻辑。浏览器会发送一 个包，包里面包含如下6个字段， version版本号， 还是5。command, 代表请求的类型，我们只支持connection请求，也就是让代理服务建 立新的TCP连接。RSV保留字段，不理会。atype 就是目标地址类型，可能是IPV4IPV6或者域名下面是 addr，这个地址的长度 是根据atype的类型而不同的,port 端口号，两个字节，我们需要逐个去读取这些字段。
面这四个字段总共四个字节，我们可以一次性把它读出来。我们定义一个长度为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变量。IPV6 用得比较少，我们就暂时先不支持。 最后还有两个字节那个是port, 我们读取它，然后按协议规定的大端字节序转换成数字。由于上面的buffer已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice,长度是2用于读取，这样的话最多会只读两个字节回来。接下来我们把这个地址和端口打印出来用于调试。收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用。第一 个 是版本 号还是socket5。第二个， 就是返回的类型，这里是成功就返回0第三个是保留字段填0第四个atype地址类型填1第五个，第六个暂时用不到，都填成0。一 共4+4+2个字节，后面6个字节都是0填充。
const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04
func main() {
//监听一个端口，返回server
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代表采用goroutine
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
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)
}
//对应NMETHNODS
methodSize, err := reader.ReadByte()
if err != nil {
return fmt.Errorf("read methodSize failed:%w", err)
}
//根据method的大小创建一个缓冲区
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
}
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", ver)
}
addr := ""
switch atyp {
case atypIPV4: //如果是IPV4，则刚好4个字节，用buf读取即可
_, 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")
}
//读取最后一个参数，用切片语法将buf裁剪成一个两个字节的缓冲区
_, err = io.ReadFull(reader, buf[:2])
if err != nil {
return fmt.Errorf("read port failed:%w", err)
}
//读取端口号
port := binary.BigEndian.Uint16(buf[:2])
//用tcp协议往对应的域名和端口建立连接
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)
}
return nil
}
复制代码4.relay阶段-建立tcp连接
我们直接用net.dial建立一个TCP连接
建立完连接之后，我们同样要加一个defer来关闭连接。
接下来需要建立浏览器和下游服务器的双向数据转发。
标准库的io.copy可以实现一个单向数据转发，双向转发的话，需要启动两个goroutinue。
现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向copy出错的时候，再返回connect函数。 这里可以使用到标准库里面的一个context机制，用context连with cancel来创建一个context。
在最后等待ctx.Done，只要cancel被调用，cbx.Done就会 立刻返回。然后在上面的两个goroutinue里面调用一次cancel即可。