Go语言上手 - 基础语言 | 青训营笔记

氧烷
169 阅读9分钟

Go语言上手 - 基础语言 | 青训营笔记

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

1.1 什么是Go语言

  1. 高性能 高并发
  2. 语法简单、学习曲线平缓
  3. 丰富的标准库（不需要借助第三方库开发）
  4. 完善的工具链
  5. 静态连接
  6. 快速编译（不需要jre）
  7. 跨平台开发
  8. 垃圾回收

1.2 哪些公司在用go语言

字节、谷歌、腾讯、facebook、美团、七牛云、滴滴、bilibili、百度、pingcap

1.3 为什么拥抱Go

  1. 最初的Python有性能问题
  2. C++不适合在线web业务
  3. 团队非java背景
  4. 新能比较好
  5. 部署简单、学习成本低
  6. 内部RPC和HTTP框架的推广

2.1 开发环境

  1. Goland
  2. VScode

2.2 基础语法

helloworld

package main
​
import (
    "fmt"
)
​
func main() {
    fmt.Println("hello world")
}

变量

var a = "initial"
​
var b, c int = 1, 2
​
var d = true
​
var e float64
​
const s string = "constant"
​
const h = 500000000
​
const i = 3e20 / h

if-else

  • if没有括号
if 7%2 == 0 {
   fmt.Println("7 is even")
} else {
   fmt.Println("7 is odd")
}

for循环

  • 循环条件没有括号
for n := 0; n < 5; n++ {
    if n%2 == 0 {
        continue
    }
    fmt.Println(n)
}

switch

  • 判断变量名不需要括号 (也可以不写变量)
  • 不需要 加break可以自动跳出
  • 取代if else 如下:
t := time.Now()
switch {
    case t.Hour() < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
}

数组

    var a [5]int

切片

  • 可变长度数组
  • 可以用append 追加元素（需要赋值回去）：扩容会产生新的Slice
  • 可以用copy拷贝数据
  • 切片取值操作
    s := make([]string, 3)
    s = append(s, "d") // 需要赋值回原数组
    copy(c, s)
    fmt.Println(s[2:5]) // [c d e]

Map（哈希）

Go语言中 map的定义语法如下

    map[KeyType]ValueType

其中，

    KeyType:表示键的类型。
​
    ValueType:表示键对应的值的类型。
  • 用delete删除k-v对
  • ok获取key是否存在
    r, ok := m["unknow"]
    fmt.Println(r, ok) // e0 fals

range

range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。不需要索引的话可以用“_”替换

for i, num := range nums {
   sum += num
   if num == 2 {
      fmt.Println("index:", i, "num:", num) // index: 0 num: 2
   }
}

函数

返回值： 结果 + 错误信息

func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok = m[k]
    return v, ok
}

指针

对传入参数进行修改

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。 Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型，如：*int、*int64、*string等。

func add2ptr(n *int) {
    *n += 2
}

结构体

Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

type user struct {
    name     string
    password string
}

作为参数

  • 指针
  • 非指针 ：可以对结构体进行修改、避免大结构体拷贝的开销
func checkPassword(u user, password string) bool {
   return u.password == password
}
​
func checkPassword2(u *user, password string) bool {
   return u.password == password
}

结构体方法

同类成员函数

  • 非指针
  • 指针 ： 可以对结构体进行修改
func (u user) checkPassword(password string) bool {
    return u.password == password
}
​
func (u *user) resetPassword(password string) {
    u.password = password
}

错误处理

  • 在返回值类型中加error，代表可能会返回错误
  • 如果出现错误返回 使用errors.New() ，否则可能会出现空指针
  • 如果没有错误返回原始值 + nil
func findUser(users []user, name string) (v *user, err error) {
   for _, u := range users {
      if u.name == name {
         return &u, nil
      }
   }
   return nil, errors.New("not found")
}

字符串

标准库 strings包中

方法介绍
len(str)求长度
+或fmt.Sprintf拼接字符串
strings.Split分割
strings.Contains判断是否包含
strings.HasPrefix ,strings.HasSuffix前缀/后缀判断
strings.Index() ,strings.LastIndex()子串出现的位置
strings.Join(a[]string, sep string)join操作
   a := "hello"
   fmt.Println(strings.Contains(a, "ll"))                // true
   fmt.Println(strings.Count(a, "l"))                    // 2
   fmt.Println(strings.HasPrefix(a, "he"))               // true
   fmt.Println(strings.HasSuffix(a, "llo"))              // true
   fmt.Println(strings.Index(a, "ll"))                   // 2
   fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
   fmt.Println(strings.Repeat(a, 2))                     // hellohello
   fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
   fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
   fmt.Println(strings.ToLower(a))                       // hello
   fmt.Println(strings.ToUpper(a))                       // HELLO
   fmt.Println(len(a))                                   // 5
   b := "你好"
   fmt.Println(len(b)) // 6

字符串格式化

fmt.Println()

打印并换行

fmt.Printf()

%d十进制整数
%x,%d,%o, %b十六进制，十进制，八进制，二进制整数。
%f, %g, %e浮点数： 3.141593 , 3.141592653589793 , 3.141593e+00
%t布尔：true或false
%c字符（rune） (Unicode码点)
%s字符串
%q带双引号的字符串“abc”或带单引号的字符’c’
%v变量的自然形式（natural format）
%T变量的类型
%%字面上的百分号标志（无操作数）
\t制表符
\n换行符
%p指针
%v任意类型
%+v详细
%#v更加详细

JSON处理

  • 只要保证结构体每个字段的首字母是大写（公开字段），就可以用 json.Marshal序列化为buf数组 在用string()转换成json格式
  • 序列化后的字符串可以用json.Unmarshal()反序列化到空变量
  • 可以字段格式在结构体字段名处改成小写
package main
​
import (
   "encoding/json"
   "fmt"
)
​
type userInfo struct {
   Name  string
   Age   int `json:"age"`
   Hobby []string
}
​
func main() {
   a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
   buf, err := json.Marshal(a)
   if err != nil {
      panic(err)
   }
   fmt.Println(buf)         // [123 34 78 97...]
   fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
​
   buf, err = json.MarshalIndent(a, "", "\t")
   if err != nil {
      panic(err)
   }
   fmt.Println(string(buf))
​
   var b userInfo
   err = json.Unmarshal(buf, &b)
   if err != nil {
      panic(err)
   }
   fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

时间处理

  • now := time.Now()获取当前时间
  • time.sub()对时间做减法（分，秒）
  • time.Date()构造带时区的时间
  • fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute())获取信息
  • fmt.Println(t.Format("2006-01-02 15:04:05"))输出时间格式化
  • now.Unix()获取时间戳
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
diff := t2.Sub(t)
fmt.Println(diff)                           // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
    panic(err)
}
fmt.Println(t3 == t)    // true
fmt.Println(now.Unix()) // 1648738080

数字解析

  • strconv包下
  • strconv.ParseInt("参数","传入进制","返回进制")
  • 输入不合法返回错误0 strconv.Atoi: parsing "AAA": invalid syntax
  • strconv.Atoi快速将10进制字符串转换为10进制数字
  • strconv.Itoa转回去
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
​
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
​
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
​
n2, _ := strconv.Atoi("123") 
fmt.Println(n2) // 123
​
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax

进程信息

  • os.Args获取命令行参数
  • os.Getenv()获得环境变量
  • os.Setenv()写入环境变量
  • exec.Command()启动子进程并获取输入输出
// go run example/20-env/main.go a b c d
    fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
    fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
    fmt.Println(os.Setenv("AA", "BB"))
​
    buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf)) // 127.0.0.1       localhost

3 实战

3.1 猜字谜游戏

  1. 需要随机数: 设置随机数种子rand.Seed(time.Now().UnixNano())
  2. os.Stdin执行文件 用bufio.NewReader()把它转成只读的流
  3. ReadString从流中读取一行
  4. strings.TrimSuffix去掉换行符
  5. strconv.Atoi快速将10进制字符串转换为10进制数字
  6. 得到用户输入数字
  7. 实现比较
  8. 实现游戏循环

获取用户输入部分:

    fmt.Println("Please input your guess")
    reader := bufio.NewReader(os.Stdin)
    input, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("An error occured while reading input. Please try again", err)
        return
    }
    input = strings.TrimSuffix(input, "\n")
​
    guess, err := strconv.Atoi(input)
    if err != nil {
        fmt.Println("Invalid input. Please enter an integer value")
        return
    }
    fmt.Println("You guess is", guess)

完整代码:

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)
        continue
    }
    input = strings.TrimSuffix(input, "\n")
​
    guess, err := strconv.Atoi(input)
    if err != nil {
        fmt.Println("Invalid input. Please enter an integer value")
        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
    }
}

3.2 在线词典

  1. 抓包

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

    2. 复制链接

      image-20220507113605355

      curl 'https://api.interpreter.caiyunai.com/v1/dict' \
  -H 'Accept: application/json, text/plain, */*' \
  -H 'Accept-Language: en-CN,en;q=0.9,zh-CN;q=0.8,zh;q=0.7,en-US;q=0.6' \
  -H 'Connection: keep-alive' \
  -H 'Content-Type: application/json;charset=UTF-8' \
  -H 'Origin: https://fanyi.caiyunapp.com' \
  -H 'Referer: https://fanyi.caiyunapp.com/' \
  -H 'Sec-Fetch-Dest: empty' \
  -H 'Sec-Fetch-Mode: cors' \
  -H 'Sec-Fetch-Site: cross-site' \
  -H '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' \
  -H 'X-Authorization: token:qgemv4jr1y38jyq6vhvi' \
  -H 'app-name: xy' \
  -H 'device-id: ' \
  -H 'os-type: web' \
  -H 'os-version: ' \
  -H 'sec-ch-ua: " Not A;Brand";v="99", "Chromium";v="101", "Google Chrome";v="101"' \
  -H 'sec-ch-ua-mobile: ?0' \
  -H 'sec-ch-ua-platform: "Windows"' \
  --data-raw '{"trans_type":"en2zh","source":"hello"}' \
  --compressed

    3. curlconverter.com/#go 编译代码(Post请求)

      • &http.Client{}创建http Client

      • strings.NewReader()字符串转换成流

      • http.NewRequest("POST", "http://fiddle.jshell.net/echo/html/", data)创建post请求

        • 参数 ( method, url, 数据流(占用内存小))

      • req.Header.Set()设置请求头

      • resp, err := client.Do(req)发起请求 返回一个response

      • log.Fatal(err)退出进程

      • defer resp.Body.Close()关闭流 避免资源泄露

      • ioutil.ReadAll(resp.Body)读取流,变成byte数组

      package main
​
import (
    "fmt"
    "io/ioutil"
    "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("Accept", "application/json, text/plain, */*")
    req.Header.Set("Accept-Language", "en-CN,en;q=0.9,zh-CN;q=0.8,zh;q=0.7,en-US;q=0.6")
    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) //打印 Json字符串
}

    4. 生成 request body

      1. 构造结构体

        type DictRequest struct {
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
    UserID    string `json:"user_id"`
}

      1. 序列化request 数组 -> byte流

      2. 将byte数组转换成流

        client := &http.Client{}
request := DictRequest{TransType: "en2zh", Source: "good"}
buf, err := json.Marshal(request) //序列化request 成byte数组
if err != nil {
    log.Fatal(err)
}
var data = bytes.NewReader(buf) //buf数组转换成流
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
    log.Fatal(err)
}

    5. 解析response body

      var dictResponse DictResponse
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
        log.Fatal(err)
    }
fmt.Printf("%#v\n", dictResponse)

    6. 打印结果

      1. 检测状态码 打印返回报文
      2. 打印结果
      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)
}

    7. main函数

      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协议工作原理

image-20220507124314598

正常浏览器访问网站:

  1. 建立tcp连接 三次握手
  2. 发起http请求
  3. 服务器返回http响应

代理服务器:

  1. 协商阶段 (握手阶段): Client向Socks5 代理服务器发送请求报文(协议版本号(v5) 支持认证种类)
  2. 通过协商(认证阶段): 返回浏览器支持的认证方式(返回0,0 不需要认证,返回其他认证会走认证流程)
  3. 发送请求 (请求阶段): 发送报文(协议版本号,请求类型(connection请求))
  4. 建立tcp连接: 收到响应 建立连接
  5. 返回响应: 返回报文
  6. 返回状态: 返回报文告诉浏览器连接成功
  7. 发送数据:(relay阶段): 正常发送请求
  8. relay数据: 代理服务器收到请求,转发到真正服务器
  9. 响应结果: 返回响应
  10. 响应结果: 转发到浏览器

3.3.1 实现 - TCP echo server

  • net.Listen()监听端口 返回server
  • server.accept()接受请求 成功返回连接
package main
​
import (
    "bufio"
    "log"
    "net"
)
​
func main() {
    server, err := net.Listen("tcp", "127.0.0.1:1080") //监听端口返回server
    if err != nil {
        panic(err)
    }
    for { //死循环
        client, err := server.Accept() //接受请求 成功返回连接
        if err != nil {
            log.Printf("Accept failed %v", err)
            continue
        }
        go process(client) //处理连接 go: 启动子线程
    }
}
​
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}) // 写入字节 用byte[] 包装
        if err != nil {
            break
        }
    }
}

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
}

测试:

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

返回 :

2022/05/07 13:13:08 ver 5 method [0 1]
2022/05/07 13:13:08 auth success

3.3.3实现 - SOCKS5 代理 -请求阶段

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: //判断atyp类型
      _, 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
}

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

3.3.4 SOCKS5代理 - relay阶段

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

io.Copy(dst Writer ,src Reader)(written int64 , err error)单向数据转换src中数据拷贝到dst

image-20220507134142364

context.WithCancel()创建 context

<-ctx.Done()等待context执行完成 => cancel()函数被调用时机

    _, 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()
    }()
    //任何一个方向copy失败就关闭连接
    <-ctx.Done()
    return nil

完整代码

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() {
    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])
​
    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
}

\

avatar
文章
阅读
粉丝