这是我参与「第五届青训营」伴学笔记创作活动的第7天。

猜谜游戏

• 获取随机数前必须设置随机数种子

func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    secretNumber := rand.Intn(maxNum)
}

• 读取用户输入

   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

在线词典

抓包

• api：fanyi.caiyunapp.com/
• 在chrome中按F12打开网页解析页面，然后输入good，网页产生相关的包，查看名为dict包的post请求内容

代码生成

• 使用三方来生成go的请求代码
• 首先复制curl

• 打开三方网页：curlconverter.com/#go

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

type DictRequest struct {
	TransType string `json:"trans_type"` //相当于在json中起别名
	Source    string `json:"source"`
	UserID    string `json:"user_id"`
}

        request := DictRequest{TransType: "en2zh", Source: "good"} //构造结构体
	buf, err := json.Marshal(request)  //序列化request变成一个数组
	if err != nil {
		log.Fatal(err)
	}
	var data = bytes.NewReader(buf)  //数组读取使用bytes
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)

解析response body

• 写一个结构体，将response body反序列化结构体中
• 反序列化代码生成api:oktools.net/json2go

        bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	var dictResponse DictResponse
	err = json.Unmarshal(bodyText, &dictResponse) //使用json包来相应的反序列化，注意第二个参数要取地址
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%#v\n", dictResponse)

• 最后可以根据数组内容来进行相应字段的提取

完善代码

        //防御式编程来排查问题
        if resp.StatusCode != 200 {
		log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
	}

    //如果输入变量长度不为2，则报错
    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)
}

SOCKS5代理

原理

client--------------socks5 server------------------host

• 协商阶段-------------->
• 通过协商<--------------
• 发送请求-------------->|建立TCP连接---------------->|
• 返回状态<--------------|返回响应<-------------------|
• 发送数据-------------->|relay数据------------------>|
• 响应结束<--------------|响应结果<-------------------|

测试实现：simple TCP echo server

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

协议第一步 认证(auth)

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
}

请求阶段

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
}

relay阶段：双向传输

        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

• 从一个被close的channel中接收数据不会被阻塞，而是立即返回，接收完已发送的数据后会返回传递的元素类型的零值(zero value)
• ctx, cancelFunc := context.WithCancel(context.Background()) 通过执行cancelFunc函数关闭chan struct{}通道，从而可以从ctx.Done()获取返回值{}，最后结束该上下文