day01Go语言入门｜青训营go语言上手的第一篇笔记，因已有c++，java等高级语言的基础，故语法部分不是重点记

3.1猜谜游戏介绍

这里用Golang来构建一个猜数字游戏。在这个游戏里面，程序首先会生成一个介于 1到100之间的随机整数，然后提示玩家进行猜测。玩家每次输入一个数字，程序会告诉玩家这个猜测的值是高于还是低于那个秘密的值。如果猜对了，就告诉玩家胜利并且退出程序。

3.1.1猜谜游戏-生成随机数

package main

import (
 "fmt"
 "math/rand"
)

func main() {
 maxNum := 100
 secretNumber := rand.Intn(maxNum)
 fmt.Println("The secret number is ", secretNumber)
}

复制

当程序运行的时候会生成一个0到100之间的随机数字。我们先来生成这个随机数。为了生成随机数，我们需要用到math/rand包。我们的第一个版本的代码是这样子的，我们先导入fmt包和math/rand包，定义一个变量，maxNum是100。下面用rand.Intn来生成一个随机数，再打印出这个随机数。

3.1.2猜谜游戏-生成随机数效果

我们发现每次都会打印相同的数字到屏幕上。这个不是我们想要的，为什么呢?

3.1.2猜谜游戏-生成随机数V2

我们用time.Now().UnixNano()来初始化随机种子。

3.1.3猜谜游戏-读取用户输入

实现用户输入输出，并成数字。我们可以用它的ReadString 方法来读取一行。如果失败了的话，我们会打印错误并能退出。ReadString 返回的结果包含结尾的换行符，我们把它去掉，再转换成数字。如果转换失败，我们同样打印错误，退出。

1.4猜谜游戏-实现判断逻辑

现在我们有了一个秘密的值，然后也从用户的输入里面读到了一个值，我们来比较这两个值的大小。如果是用户输入的值比那个秘密的值要大的话，就告诉用户你猜的值太大了，请再试一次。如果是小了也同理，如果是相等的话，那么我们就告诉用户你赢了。

3.1.5猜谜游戏-实现游戏循环

此时我们的程序大致可以正常工作了，但是玩家只能输入一次猜测，无论猜测是否正确，程序都会突退出。为了改变这种行为，让游戏可以正常玩下去，我们需要加一个循环。我们把刚刚的代码挪到一个for循环里面，再把return改成continue以便于在出错的时候能够继续循环。在用户输入正确的时候break，这样才能够在用户胜利的时候退出游戏。

就这样，我们已经成功地在Golang里面构建了一个猜谜游戏。在这个过程中，我们复习了之前的很多概念，比如变量循环、函数控制流和错误处理。

3.2在线词典介绍

实现一个命令行排版的词典

用户可以在命令行里面查询一个单词。我们能通过调用第三方的API查询到单词的翻译并打印出来。这个例子里面，我们会学习如何用go语言来来发送HTTP请求、解析json 过来，还会学习如何使用代码生成来提高开发效率。

3.2.1在线词典-抓包

我们先来看一下我们要用到的API，以彩云科技提供的在线翻译为例。先请打开彩云翻译的网页，然后右键F12检查打开浏览器的开发者工具。

彩云小译：fanyi.caiyunapp.com/#/

此时我们点一下翻译按钮，浏览器会发送系列请求，我们能很轻松地找到那个用来查询单词的请求。

这是一个HTTP的post的请求，请求的header的相当的复杂，有十来个。然后请求头是一个 json里面有两个字段，一个是代表你要你是从什么语言转化成什么语言，source 就是你要查询的单词。API 的返回结果里面会有Wiki和dictionary两个字段。我们需要用的结果主要在dictionary Explanations字段里面。其他有些字段里面还包括音标等信息。

3.2.2在线词典-代码生成

我们需要在Golang里面去发送这个请求。因为这个请求比较复杂，用代码构造很麻烦，实际上我们有一种非常简单的方式来生成代码，我们可以右键浏览器里面的copy as cur。copy完成之后大家可以在终端粘贴一下curl命令，应该可以成功

3.2.2在线词典-代码生成

然后我们打开一个网站curlconverter.com/#go，粘贴curl请… 生成代码有转义导致的编译错误，删掉这几行即可。

3.2.2在线词典-生成代码解读

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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 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="101", "Google Chrome";v="101"`)
 req.Header.Set("sec-ch-ua-mobile", "?0")
 req.Header.Set("sec-ch-ua-platform", `"Windows"`)
 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)
}

复制

我们来看一下这生成的代码：

首先第12行我们创建了一个 HTTP client,创建的时候可以指定很多参数，包括比如请求的超时是否使用cookie等。接下来是构造一个 HTTP请求，这是一个 post请求。
然后会用到HTTP .NewRequest，第一个参数是http方法POST，第二个参数是URL，最后一个参数是 body，body因为可能很大，为了支持流式发送，是一个只读流。我们用了strings.NewReader来把字符串转换成一个流。这样我们就成功构造了一个HTTP request,接下来我们需要对这个HTTP request来设置一堆header.
接下来我们把我们调用client.do request，就能得到response如果请求失败的话，那么这个error会返回非nil,会打印错误并且退出进程。response 有它的HTTP状态码，response header和body。body同样是一个流，在golang里面，为了避免资源泄露，你需要加一个defer来手动关闭这个流，这个defer会在这个函数运行结束之后去执行。接下来我们是用ioutil.Readll来读取这个流，能得到整个body。我们再用print打印出来。

我们来运行生成的代码，能看到我们已经能够成功地发出请求，把返回的JSON打印出来。但是现在那个输入是固定的，我们是要从一个变量来输入，我们需要用到JSON列化

3.2.3在线词典-生成request body

3.2.4在线词典-解析response body

接下来我们要做的是把这个response body来解析出来。在js/Python这些脚本语言里面，body 是一个字典或者map的结构，可以直接从里面取值。但是golang是个强类型语言，这种做法并不是最佳实践。更常用的方式是和request的一样，写一个结构体，把返回的JSON反序列化到结构体里面。但是我们在浏览器里面可以看到这个API返回的结构非常复杂，如果要一定义结构体字段，非常繁琐并且容易出错。

此时有一个小技巧的是，网上有对应的代码生成工具，我们可以打开这个网站oktools.net/json2go，把js…

这样我们就得到了一个response结构体。接下来我们修改代码，我们先定一个 response结构体的对象，然后我们用JSON.unmarshal把body反序列化到这个结构体里面，再试图打印出来

现在我们再运行一下，这里打印的时候使用了%#v，这样可以让打印出来的结果比较容易读。我们现在离最终版本已经很近了，接下来我们需要修改代码为打印response里面的特定字段。

3.2.5在线词典-打印结果

观察那个json可以看出我们需要的结果是在Dictionary.explanations.我们用for range循环来迭代它，然后直接打印结构，参照一些词典的显示方式，我们可以在那个前面打印出这个单词和它的音标。这里有英式音标和美式音标。

3.2.6在线词典-完善代码

现在我们的程序的输入还是写死的。我们把代码的主体改成个query函数，查询的单词作为参数传递进来。然后我们写一个简单的 main函数，这个main函数首先判断下命令和参数的个数，如果它不是两个，那么我们就打印出错误信息，退出程序。否则就获取到用户输入的单词，然后执行query函数。

package main

import (
 "bytes"
 "encoding/json"
 "fmt"
 "io/ioutil"
 "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 {
  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 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("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
 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() {
 if len(os.Args) != 2 {
  fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)
  os.Exit(1)
 }
 word := os.Args[1]
 query(word)
}

复制

这样子我们的命令行词典就算完成了，我们可以简单地试一下。

3.3 SOCKS5代理介绍

我们来写一个socks5代理服务器，对于大家来说，一提到代理服务器，第一想到的是翻墙。不过很遗憾的是，socks5 协议它虽然是代理协议，但它并不能用来翻墙，它的协议都是明文传输。

这个协议历史比较久远，诞生于互联网早期。它的用途是，比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦。

socks5相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻墙软件，最终暴露的也是一个 socks5协议的端口。如果有同学开发过爬虫的话，就知道，在爬取过程中很容易会遇到IP访问频率超过限制。这个时候很多人就会去网上找一些代理IP池，这些代理IP池里面的很多代理的协议就是socks5。

go-by-example\proxy\v4> go run .\main.go curl --socks5 127.0.0.1:1080 -v www.qq.com

3.3 SOCKS5代理-原理

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

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

3.3.1 SOCKS5代理-TCP echo server

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

首先我们在main函数里面先用net.listen去监听一个端口，会返回一个server,然后在一个死循环里面，每次去accept一个请求，成功就会返回一个连接。接下来的话我们在一个process函数里面去处理这个连接。注意这前面会有个go关键字，这个代表启动一个goroutinue,可以暂时类比为其他语言里面的启动一个子线程。只是这里的goroutinue的开销会比子线程要小很多，可以很轻松地处理上万的并发。
接下来是这个process函数的实现。首先第一步的话会先加一个 defer connection.close()，defer 是Golang里面的一个语法，这一行的含义就是代表在这个函数退出的时候要把这个连接关掉，否则会有资源的泄露。
接下来的话我们会用bufio.NewReader来创建一个带缓冲的只读流，这个在前面的猜谜游戏里面也有用到，带缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便是一个字节一个字节的读取，但是底层可能合并成几次大的读取操作。并且带缓冲的流会有更多的一些工具数用来读取数据。我们可以简单地调用那个readbyte函数来读取单个字节。再把这一个字节写进去连接。

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
  }
 }
}

复制

我们来简单测试一下我们的第一个TCP服务器，然后测试会需要用到nc命令（window需要安装），我们用nc 127.0.0.1 1080，输入Hello然后服务器就会给你返回Hello。

3.3.2 SOCKS5代理- auth

package main

import (
 "bufio"
 "fmt"
 "io"
 "log"
 "net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 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
 }
 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, 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
}

复制

就这样我们就已经完成了一个能够返回你输入信息的一个TCP server,接下来我们是要开始实现协议的第一步，认证阶段，从这一部分开始会变得比较复杂。我们实现一个空的auth函数，在process函数里面调用，再来编写auth函数的代码。我们回忆一下认证阶段的逻辑，

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

我们先用read bytes来把版本号读出来，然后如果版本号不是socket 5的话直接返回报错，接下来我们再读取method size，也是一个字节。然后我们需要我们去make一个相应长度的一个slice，用io.ReadFull把它去填充进去。写到这里，我们把获取到的版本号和认证方式打印一下。此时，代理服务器还需要返回一个response，返回包包括两个字段，一个是version一个是method,也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00。我们用curl命令测试一下当前版本的效果

3.3.3 SOCKS5代理-请求阶段

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

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

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

如果是个host的话，需要先读它的长度，再make 一个相应长度的buf填充它。再转换成字符串保存到 addr变量。IPV 6用得比较少，我们就暂时先不支持。最后还有两个字节那个是port，我们读取它，然后按协议规定的大端字节序转换成数字。由于上面的buffer已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice，长度是2用于读取，这样的话最多会只读两个字节回来。接下来我们把这个地址和端口打印出来用于调试。收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用。

第一个是版本号还是socket5。第二个，就是返回的类型，这里是成功就返回0第三个是保留字段填0第四个atype地址类型填1第五个，第六个暂时用不到，都填成0。一共4+4+2个字节，后面6个字节都是0填充。

package main

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

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 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", 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])

 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
}

复制

3.3.4 SOCKS5 代理- relay 阶段

我们直接用net.dial建立一个TCP连接

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

 _, 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)

复制

3.3.4 SOCKS5 代理- relay 阶段

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

day01Go语言入门 ｜ 青训营

3.1猜谜游戏介绍

3.1.1猜谜游戏-生成随机数

3.1.2猜谜游戏-生成随机数效果

3.1.2猜谜游戏-生成随机数V2

3.1.3猜谜游戏-读取用户输入

1.4猜谜游戏-实现判断逻辑

3.1.5猜谜游戏-实现游戏循环

3.2在线词典介绍

3.2.1在线词典-抓包

3.2.2在线词典-代码生成

3.2.2在线词典-代码生成

3.2.2在线词典-生成代码解读

3.2.3在线词典-生成request body

3.2.4在线词典-解析response body

3.2.5在线词典-打印结果

3.2.6在线词典-完善代码

3.3 SOCKS5代理介绍

3.3 SOCKS5代理-原理

3.3.1 SOCKS5代理-TCP echo server

3.3.2 SOCKS5代理- auth

3.3.3 SOCKS5代理-请求阶段

3.3.4 SOCKS5 代理- relay 阶段

3.3.4 SOCKS5 代理- relay 阶段

day01Go语言入门｜青训营