Go语言实战案例 ｜ 青训营笔记

琴酒Gin
161 阅读10分钟

3 实战

3.1 猜数字

注意: rand.Seed已被弃用，应使用rand.New(rand.NewSource(seed))

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

但是每次执行都是生成同一个数

需要使用time.now.unix生成随机种子

用户输入输出: 使用ReadString读取一行 输入错误打印错误推出 返回结果包含换行符需要去掉

要注意文件行分隔符格式 若是LF格式则应该为 strings.TrimSuffix(input, "\r\n")

将整个主程序包入for循环 出错进行return 输入错误continue 输入正确break

package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	maxNum := 100
	rand.New(rand.NewSource(time.Now().Unix()))
	secretNum := rand.Intn(maxNum)
	fmt.Println("secret number is", secretNum)

	fmt.Println("input your guess: ")
	reader := bufio.NewReader(os.Stdin)

	for {
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("An error occurred while reading input:", err)
			continue
		}
		input = strings.TrimSuffix(input, "\r\n")

		guess, err := strconv.Atoi(input)
		if err != nil {
			fmt.Println("Invalid input. Enter an integer value", err)
			continue
		}
		fmt.Println("Your guess: ", guess)

		if guess > secretNum {
			fmt.Println("Your guess is bigger than secret.Try again.")
		} else if guess < secretNum {
			fmt.Println("Your guess is smaller than secret.Try again.")
		} else {
			fmt.Println("Your guess is correctly")
			break
		}
	}
}

3.2 在线词典

使用go调用api

发送http请求 解析json

由于彩云的api问题，我采用了腾讯云的翻译api

实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：cloud.tencent.com/document/pr… 密钥可前往官网控制台 console.cloud.tencent.com/cam/capi 进行获取

cpf.HttpProfile.Endpoint = "tmt.tencentcloudapi.com"

另外需要写一个签名方法生成需要的签名

func sha256hex(s string) string {
	b := sha256.Sum256([]byte(s))
	return hex.EncodeToString(b[:])
}

func hmacsha256(s, key string) string {
	hashed := hmac.New(sha256.New, []byte(key))
	hashed.Write([]byte(s))
	return string(hashed.Sum(nil))
}

func signature(timestamp int64, request string) string {
	// 需要设置环境变量 TENCENTCLOUD_SECRET_ID，值为示例的 AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******
	secretId := "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******"
	// 需要设置环境变量 TENCENTCLOUD_SECRET_KEY，值为示例的 Gu5t9xGARNpq86cd98joQYCN3*******
	secretKey := "Gu5t9xGARNpq86cd98joQYCN3*******"
	host := "tmt.tencentcloudapi.com"
	algorithm := "TC3-HMAC-SHA256"
	service := "tmt"
	//version := "2018-03-21"
	action := "TextTranslate"
	//region := "ap-guangzhou"
	//var timestamp int64 = time.Now().Unix()
	//var timestamp int64 = 1551113065

	// step 1: build canonical request string
	httpRequestMethod := "POST"
	canonicalURI := "/"
	canonicalQueryString := ""
	canonicalHeaders := fmt.Sprintf("content-type:%s\nhost:%s\nx-tc-action:%s\n",
		"application/json", host, strings.ToLower(action))
	signedHeaders := "content-type;host;x-tc-action"
	payload := request
	hashedRequestPayload := sha256hex(string(payload))
	canonicalRequest := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s",
		httpRequestMethod,
		canonicalURI,
		canonicalQueryString,
		canonicalHeaders,
		signedHeaders,
		hashedRequestPayload)
	//fmt.Println(canonicalRequest)

	// step 2: build string to sign
	date := time.Unix(timestamp, 0).UTC().Format("2006-01-02")
	credentialScope := fmt.Sprintf("%s/%s/tc3_request", date, service)
	hashedCanonicalRequest := sha256hex(canonicalRequest)
	string2sign := fmt.Sprintf("%s\n%d\n%s\n%s",
		algorithm,
		timestamp,
		credentialScope,
		hashedCanonicalRequest)
	//fmt.Println(string2sign)

	// step 3: sign string
	secretDate := hmacsha256(date, "TC3"+secretKey)
	secretService := hmacsha256(service, secretDate)
	secretSigning := hmacsha256("tc3_request", secretService)
	signature := hex.EncodeToString([]byte(hmacsha256(string2sign, secretSigning)))
	//fmt.Println(signature)

	// step 4: build authorization
	authorization := fmt.Sprintf("%s Credential=%s/%s, SignedHeaders=%s, Signature=%s",
		algorithm,
		secretId,
		credentialScope,
		signedHeaders,
		signature)
	//fmt.Println(authorization)

	//curl := fmt.Sprintf(`curl -X POST https://%s\
	//-H "Authorization: %s"\
	//-H "Content-Type: application/json; charset=utf-8"\
	//-H "Host: %s" -H "X-TC-Action: %s"\
	//-H "X-TC-Timestamp: %d"\
	//-H "X-TC-Version: %s"\
	//-H "X-TC-Region: %s"\
	//-d '%s'`, host, authorization, host, action, timestamp, version, region, payload)
	//fmt.Println(curl)

	return authorization
}

完整代码

package main

import (
	"bufio"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

type DictionaryReq struct {
	SourceText string
	Source     string
	Target     string
	ProjectId  int
}

type DictionaryResponse struct {
	Response struct {
		RequestId  string
		Source     string
		Target     string
		TargetText string
	}
}

func sha256hex(s string) string {
	b := sha256.Sum256([]byte(s))
	return hex.EncodeToString(b[:])
}

func hmacsha256(s, key string) string {
	hashed := hmac.New(sha256.New, []byte(key))
	hashed.Write([]byte(s))
	return string(hashed.Sum(nil))
}

func signature(timestamp int64, request string) string {
	// 需要设置环境变量 TENCENTCLOUD_SECRET_ID，值为示例的 AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******
	secretId := "AKIDz8krbsJ5yKBZQpn74WFkmLPx3*******"
	// 需要设置环境变量 TENCENTCLOUD_SECRET_KEY，值为示例的 Gu5t9xGARNpq86cd98joQYCN3*******
	secretKey := "Gu5t9xGARNpq86cd98joQYCN3*******"
	host := "tmt.tencentcloudapi.com"
	algorithm := "TC3-HMAC-SHA256"
	service := "tmt"
	//version := "2018-03-21"
	action := "TextTranslate"
	//region := "ap-guangzhou"
	//var timestamp int64 = time.Now().Unix()
	//var timestamp int64 = 1551113065

	// step 1: build canonical request string
	httpRequestMethod := "POST"
	canonicalURI := "/"
	canonicalQueryString := ""
	canonicalHeaders := fmt.Sprintf("content-type:%s\nhost:%s\nx-tc-action:%s\n",
		"application/json", host, strings.ToLower(action))
	signedHeaders := "content-type;host;x-tc-action"
	payload := request
	hashedRequestPayload := sha256hex(string(payload))
	canonicalRequest := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s",
		httpRequestMethod,
		canonicalURI,
		canonicalQueryString,
		canonicalHeaders,
		signedHeaders,
		hashedRequestPayload)
	//fmt.Println(canonicalRequest)

	// step 2: build string to sign
	date := time.Unix(timestamp, 0).UTC().Format("2006-01-02")
	credentialScope := fmt.Sprintf("%s/%s/tc3_request", date, service)
	hashedCanonicalRequest := sha256hex(canonicalRequest)
	string2sign := fmt.Sprintf("%s\n%d\n%s\n%s",
		algorithm,
		timestamp,
		credentialScope,
		hashedCanonicalRequest)
	//fmt.Println(string2sign)

	// step 3: sign string
	secretDate := hmacsha256(date, "TC3"+secretKey)
	secretService := hmacsha256(service, secretDate)
	secretSigning := hmacsha256("tc3_request", secretService)
	signature := hex.EncodeToString([]byte(hmacsha256(string2sign, secretSigning)))
	//fmt.Println(signature)

	// step 4: build authorization
	authorization := fmt.Sprintf("%s Credential=%s/%s, SignedHeaders=%s, Signature=%s",
		algorithm,
		secretId,
		credentialScope,
		signedHeaders,
		signature)
	//fmt.Println(authorization)

	//curl := fmt.Sprintf(`curl -X POST https://%s\
	//-H "Authorization: %s"\
	//-H "Content-Type: application/json; charset=utf-8"\
	//-H "Host: %s" -H "X-TC-Action: %s"\
	//-H "X-TC-Timestamp: %d"\
	//-H "X-TC-Version: %s"\
	//-H "X-TC-Region: %s"\
	//-d '%s'`, host, authorization, host, action, timestamp, version, region, payload)
	//fmt.Println(curl)

	return authorization
}

func main() {
	fmt.Println("Enter your text(Chinese): ")
	reader := bufio.NewReader(os.Stdin)
	input, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}
	input = strings.TrimSuffix(input, "\r\n")

	var timestamp int64 = time.Now().Unix()
	//fmt.Println(signature(timestamp))
	client := &http.Client{}
	var text = DictionaryReq{
		SourceText: input,
		Source:     "zh",
		Target:     "en",
		ProjectId:  0,
	}
	buf, err := json.Marshal(text)
	if err != nil {
		log.Fatal(err)
	}
	var data = strings.NewReader(string(buf))

	req, err := http.NewRequest("POST", "https://tmt.tencentcloudapi.com", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", signature(timestamp, string(buf)))
	req.Header.Set("X-TC-RequestClient", "APIExplorer")
	req.Header.Set("Host", "tmt.tencentcloudapi.com")
	req.Header.Set("X-TC-Action", "TextTranslate")
	req.Header.Set("X-TC-Version", "2018-03-21")
	req.Header.Set("X-TC-Timestamp", strconv.FormatInt(timestamp, 10))
	req.Header.Set("X-TC-Region", "ap-guangzhou")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)

	var response DictionaryResponse
	err = json.Unmarshal(bodyText, &response)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response)
	fmt.Println("翻译结果为: ", response.Response.TargetText)
}

彩云翻译样例

输入 go run .\DictionaryExample.go hello

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"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 := io.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 Socket5

明文传输协议

配置代理ip池

代理服务器日志会打印风闻得网站得域名/IP，我们网络流量通过该代理服务器

可以用命令行测试代理服务器，curl -socks5 + 代理服务器地址 + url

QQ截图20230516234209

image

  1. 握手阶段 像socks5代理发送请求：版本号、支持认证的种类 服务器选中一个认证方式返回给浏览器，00则不需要认证
  2. 认证阶段
  3. 请求阶段 一般是connection请求，代理服务器于某个服务器的某个端口建立TCP连接，代理服务器收到响应后会真正和后端服务器建立连接，返回一个响应
  4. relay阶段 浏览器正常发送请求，代理服务器收到请求后吧请求转换到真正的服务器上，如果真正的服务器返回响应的化，也会把请求转发到浏览器。

代理服务器并不关心流量的细节。

package main

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

const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 0x01
const atypeHOST = 0x02
const atypeIPV6 = 0x03

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) {
	fmt.Println("创建携程")
	// 发送数据->relay数据->响应结果
	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 [1个字节 固定为0x05代表使用socks5协议]
	// NMETHODS: 支持认证的方法数量 [1个字节][METHODS字段中有多少种客户端支持的认证方法]
	// 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    |
	// +----+--------+

	//0x00: 不需要认证
	//0x01: GSSAPI认证
	//0x02: 用户名和密码方式认证
	//0x03: IANA认证
	//0x80-0xfe: 保留的认证方式
	//0xff: 不支持任何认证方式，当客户端收到此信息必须关闭连接。

	_, 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) {
	// 连接请求阶段(一般是connection请求，代理服务器于某个服务器的某个端口建立TCP连接，代理服务器收到响应后会真正和后端服务器建立连接，返回一个响应)
	// 发送请求->建立tcp->返回响应

	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05
	// CMD 指令编号,0x01 CONNECT 指令，用于 TCP 代理;0x03 UDP ASSOCIATE 指令，用于 UDP 代理
	// RSV 保留字段，值为0x00 必须为 0
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	//	 0x04 表明地址为IPV6 地址，长度为16字节 [暂不支持]
	// DST.ADDR 一个可变长度的值,要访问的目标服务器的地址或域名，类型由ATYP字段决定
	// 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", cmd)
	}
	addr := ""
	switch atyp {
	case atypeIPV4:
		_, 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)

	// SOCKS 服务端会根据请求类型和源、目标地址，执行对应操作，并且返回对应的一个或多个报文信息
	// +----+-----+-------+------+----------+----------+
	// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER socks版本，这里为0x05
	// REP Relay field,内容取值如下 X’00’ succeeded
	// 请求的结果，0x00 成功
	//0x01常规 SOCKS 服务故障
	//0x02 规则不允许的连接
	//0x03 网络不可达
	//0x04 主机无法访问
	//0x05 拒绝连接
	//0x06 连接超时
	//0x07 不支持的命令
	//0x08 不支持的地址类型
	// 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
}

使用方式： 运行go文件后就开始监听该ip端口 使用curl进行访问测试

curl --sock5 127.0.0.1:4927 -v www.baidu.com

avatar
文章
阅读
粉丝