三个实战|青训营

mchale
69 阅读9分钟

猜谜游戏

随机生成数

v1

据说是会每次都生成一样的随机数，但我的结果好像不会，每次都是不一样的数字，如下： 我的3次运行结果

import (
    "fmt"
    "math/rand"
)

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

v2

加了随机数种子
用时间戳初始化随机数种子

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

我的三次运行结果：
我的三次运行结果

读取用户输入

用bufio

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")
    //获取stdio文件
    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)
}

实现判断逻辑

比较用户input和实际secret数字的大小，并告知用户

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

实现游戏循环

for循环，让用户可以一直猜测，直到猜对

    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.Trim(input, "\r\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
        }
    }

在线词典

在命令行查询单词
词典输出单词的音标和注释
调用第三方API查询单词的翻译等信息
学习如何用go语言发送HTTP请求，解析json，

抓包

打开彩云翻译的网页
检查
network
dict
看到header，有很多请求，要想办法在golang里面发送请求

代码生成

copy as curl（bash） 得到一大串json
把那串json粘贴到 https：//curlconverter.com/#go 里面，将json转化成go代码
这得到的go代码就可以直接复制粘贴到编辑器里面用
go代码如下：

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"
)

func main() {
//创建一个http client
	client := &http.Client{}
	var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
//创建http request 请求。参数（method，url，data）。data是一个流（stings）
	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")
//真正发起请求，返回response
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)//退出进程
	}
//到这里，response就已经拿到了
//response的body也是一个流，防止资源泄露，用defer锁定这个流，它会在函数结束之后调用那个close函数
	defer resp.Body.Close()
//把流读到内存里面，得到一个byte数组
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
//打印出来就是json字符串
	fmt.Printf("%s\n", bodyText)
}

生成request body

以上代码是固定输入（就是data初始化那里是确定的一串字符串），我们希望要是变量输入，还要进一步修改
会用到json序列化

//定义一个大写字段的结构体
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: "good"}
//序列化
	buf, err := json.Marshal(request)
	if err != nil {
		log.Fatal(err)
	}
//和之前的那个data不同，上面用的是strings.NewReader,这里用的是bytes.NewReader。因为这里buf不是字符串，而是数组
	var data = bytes.NewReader(buf)
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
//剩下的代码不变，最终结果也应当是不变的

解析response body

刚刚是请求的序列化，现在是返回的反序列化
response很大，我们要提取其中的我们需要的字段
在golang里面，要写一个结构体和这个response对应，然后把返回的字符串反序列化到结构体里面
这个过程有网站帮我们完成：oktools.net/json2go
得到go结构体

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

把之前得到的response body（字符串）反序列化到上面的结构体中

	defer resp.Body.Close()
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
//下面三行是防御性编程
//虽然上面没有返回错误，但是可能还是不符合要求的请求，如403，404.添加了这一段方便排查问题
	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() {
//若命令行参数不为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代理服务器

TCP echo server

你给它发送啥，它就回复啥

package main

import (
	"bufio"
	"log"
	"net"
)

func main() {
//用net.listen增添端口，返回server
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
//死循环
	for {
//server.accept 接受请求，若成功，则返回一个连接client
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
//在process里面处理连接
//go 关键字 ，启动一个go routine，类似子线程，但是开销更小
		go process(client)
	}
}

func process(conn net.Conn) {
//defer 表示在函数退出的时候，要把连接关掉
	defer conn.Close()
//只读的待缓冲的流
	reader := bufio.NewReader(conn)
	for {
//readbyte，每次读一个字节
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
//写入字节。正常是写一个slice，这里写byte，做个类型转化
		_, err = conn.Write([]byte{b})
		if err != nil {
			break
		}
	}
}

运行不用go命令，而是nc命令，可以和某个IP+端口建立TCP连接
输入啥，就返回啥

auth

建传
process函数里面就用到这个auth函数
认证阶段：

  1. 浏览器给代理服务器发送报文。
    报文有3个字段：
    1.1. version：协议版本号
    1.2. 建传方式的数目
    1.3. 每个建传方式的编码
//参数：只读流，原始的TCP连接
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
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
//创建method的缓冲区
	method := make([]byte, methodSize)
//用io.readfull把它填充满
	_, 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    |
	// +----+--------+
//直接构造这个包
// 协议版本号socks5ver，建传方式00（不需要认证）
	_, 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的数据对应这个字段的类型。（重点关注。可能是多种类型，如ipv4，ipv6等）
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值
	// DST.PORT 目标端口，固定2个字节
//挨个把6个字节读出来
//对于单字节长度的字段，仍然可以采用readbyte一个字节一个字节地读，这里用另一个方法。
//4个字节长度的缓冲区
	buf := make([]byte, 4)
//io.readfull直接填充满，这样就一次性地读到前面的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)
	}
//atyp有不同的类型
	addr := ""
	switch atyp {
//若是ipv4，dst.addr是四个字节，就要读取四个字节
	case atypeIPV4:
//上面的缓冲区buf刚好是4个字节，直接读满
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
//打印成IP地址
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
//若是HOST类型
	case atypeHOST:
//先读一个字节，是HOST的长度
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
//make一个对应长度的字符串，用io.ReadFull把它填充满
		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])
//打印日志
	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
}

relay阶段

和真正的服务器建立TCP连接
在connect函数中，加入：

	port := binary.BigEndian.Uint16(buf[:2])
//下面是新加的
//net包的dial函数：用tcp协议往对应的addr+port建立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)

接下来要建立浏览器和下一个服务器的双向数据转发
io包里面有一个copy函数，可以实现单向数据转发
func Copy (dst Writer, src Reader) (written int64, err error)
会把src这个只读流里面的数据用一个死循环拷贝到dst这个可写流里面
因为要实现双向数据转发，一个copy不够，要启动两个go routine

	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
//代码如下：
//创建一个context
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
//启动两个go routine，分别调用io.Copy
//两个拷贝的方向不一样
	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()
//等待context执行完成。
//执行完成的时机就是cancel被调用的时机
//看上面，在任何一个go routine出错的时候就会调用cancel
//这样就实现了：在任意一个方向的copy失败的时候，就返回这个connect函数，并且关闭双方的连接
	<-ctx.Done()
	return nil

到这里，代理服务器就完工了
用curl命令测试 curl --socks5 127.0.0.1:1080 -v http://www.qq.com

avatar
文章
阅读
粉丝