Go 语言实战案例:猜谜游戏&在线词典&SOCKS5代理服务器 Go学习路线

字节跳动后端入门 - Go 语言原理与实践& vscode配置安装Go

---

3.1猜谜游戏

3.1.2 生成随机数v2

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

3.1.3 读取用户输入

package main
import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"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)    //转成 只读 流
	input, err := reader.ReadString('\n')  //读取一行输入
	if err != nil {
		fmt.Println("An error occured while reading input. Please try again", err)
		return
	}
	input = strings.Trim(input, "\r\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)
}

3.1.4 实现判断逻辑

3.1.5 实现游戏循环

3.2 在线词典介绍

这个实例中我们将学习:

如何用Go语言发送http请求、解析JSON，还会学习如何使用代码生成提高效率；

3.2.1 抓包

3.2.1 代码生成

想办法在Go里面发送这个请求！

有几个Header比较复杂 转义导致的编译错误

3.2.2 生成代码解读

转换成流 异常 ；

defer手动关闭流 defer会在函数结束之后 从下往上触发 防止泄露

3.2.3 生成request body

3.2.4 解析response body

点击“转换-嵌套” 生成的代码会紧凑一点

3.2.5 打印结果

3.2.6 完善代码

---

3.3 SOCKS5代理服务器

SOCKS5代理协议 明文不能用来 早期用于某些企业的内网搭建过于安全导致管理员访问某些资源也很麻烦 这个协议相当于在防火墙内部开了个口子 使用户通过单个端口可以访问所有资源

3.3.0 SOCKS5协议工作原理

正常浏览器访问网站 不经过代理服务器 要建立TCP链接，进行三次握手 发起http请求，服务器返回http响应；

设置代理服务器：

1.用户浏览器和socks5代理服务器进行链接，发送报文请求；

1.1代理服务器协商 建议浏览器用哪种请求方式建立链接 ；

2.发送请求； 2.1 代理服务器和真正的服务器进行TCP链接；

3.浏览器 发送数据；

3.3.1 简版TCP echo server

逻辑：给他发送啥 就回复啥

接受请求 成功的话返回一个链接；

在go process函数(其中go类似线程)里面处理这个链接 关闭链接 基于链接创建只读缓冲流；

死循环 ReadByte()读一字节；这个读看上去是1字节；但是又因为缓冲流，所以在底层会做一个合并，提前读1kb，然后再for里读1字节 Write()写入字节 出错的话就break关闭链接

3.3.2 auth-实现协议的第一步-认证阶段

只读流 原始的TCP链接

死循环删掉 调用auth函数 成功打印success

认证阶段 发送报文 ；55行先读版本号1字节；用读出来的methodsize创建method缓冲区；io.ReadFull填充； 77行返回一个包 告诉浏览器 代理服务器选择了哪种建桥方式；

看日志 发现成功打印出来两个字段和建桥方式；

3.3.3 请求阶段

auth函数类似的connect函数；

浏览器在请求阶段发送报文 包括6个阶段

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

const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 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)  //创建一个长度为4的缓冲区
	_, err = io.ReadFull(reader, buf)  //readfull填充满
	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 {//不同的atype 类型走不同case分支
	case atypeIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		//打印成ip地址 xxx.xxx...
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	case atypeHOST://HOST类型
		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
}

3.3.4 relay阶段 和真正的服务建立TCP链接

net.Dial函数 简单的建立tcp链接；

关闭链接；

io.copy 实现单向数据转发 把参数src的数据死循环的拷贝到dst里

用户浏览器到底层服务器 反向 ；context.withconce创建context ；182行等到ctx.Done()即context执行完成也就是cancel函数()被调用； cancel()在两个方向任一方向的拷贝出错时被调用；

3.3.5 实现成功

Chrome浏览器下载插件SwitchyOmega

入门总结