首页 > 其他分享 >go 语言实战入门案例之实现Socks5

go 语言实战入门案例之实现Socks5

时间：2023-08-03 13:31:57浏览次数：47  
标签：err return 入门 nil fmt failed Socks5 reader go

文章和代码已经归档至【Github仓库：<https://github.com/timerring/backend-tutorial> 】或者公众号【AIShareLab】回复 go 也可获取。

实现 Socks 5 代理

介绍

go 语言实战入门案例之实现Socks5_代理服务器

socks5 协议它虽然是代理协议，但它并不能用来翻，它的协议都是明文传输。 这个协议历史比较久远，诞生于互联网早期。它的用途是， 比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦。socks5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻软件，最终暴露的也是一个 socks5 协议的端口。 例如爬，在爬取过程中很容易会遇到 IP 访问频率超过限制。这个时候很多人就会去网上找一些代理 IP 池，这些代理 IP 池里面的很多代理的协议就是 socks5。

go 语言实战入门案例之实现Socks5_代理服务器_02

先看一下最终写完的代理服务器的效果。启动程序，然后在浏览器里面配置使用这个代理，此时打开网页。代理服务器的日志，会打印出你访问的网站的域名或者 IP ，这说明我们的网络流量是通过这个代理服务器的。也能在命令行去测试我们的代理服务器。我们可以用 curl -socks5 + 代理服务器地址，后面加一个可访问的 URL，如果代理服务器工作正常的话，那么 curl 命令就会正常返回。

原理

go 语言实战入门案例之实现Socks5_代理服务器_03

了解 socks5 协议的工作原理。正常浏览器访问一个网站，如果不经过代理服务器的话，就是先和对方的网站建立 TCP 连接，然后三次握手，握手完之后发起 HTTP 请求，然后服务返回 HTTP 响应。

如果设置代理服务器之后，流程会变得复杂一些。首先是浏览器和 socks5 代理建立 TCP 连接，代理再和真正的服务器建立 TCP 连接。这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、 relay 阶段。

  • 第一个握手阶段，浏览器会向 socks 5 代理发送请求，包的内容包括一个协议的版本号，还有支持的认证的种类，socks 5 服务器会选中一个认证方式，返回给浏览器。如果返回的是 00 的话就代表不需要认证，返回其他类型的话会开始认证流程，这里我们就不对认证流程进行概述了。
  • 第三个阶段是请求阶段，认证通过之后浏览器会对 socks 5 服务器发起请求。主要信息包括版本号，请求的类型，一般主要是 connection 请求，就代表代理服务器要和某个域名或者某个 IP 地址某个端口建立 TCP 连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。
  • 第四个阶段是 relay 阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边。然后实际上代理服务器并不关心流量的细节，可以是 HTTP 流量，也可以是其它 TCP 流量。

TCP echo server

我们先在 go 里面写一个简单的 TCP echo server。为了方便测试， server 的工作逻辑很简单，你给他发送啥，他就回复啥，代码如下。

package main

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

func main() {
	// 首先在 main 函数里面先用 net.listen 去监听一个端口，会返回一个 server
	server, err := net.Listen("tcp", "127.0.0.1:10803")
	if err != nil {
		panic(err)
	}
	for {
		// 然后在一个死循环里面，每次去 accept 一个请求，成功就会返回一个连接
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		// 接下来的话我们在一个 process 函数里面去处理这个连接。
		// 这前面会有个 go 关键字，这个代表启动一个 goroutinue， 可以暂时类比为其他语言里面的启动一个子线程。只是这里的 goroutinue 的开销会比子线程要小很多，可以很轻松地处理上万的并发。
		go process(client)
	}
}
// 接下来是这个 process 函数的实现。
func process(conn net.Conn) {
	// 首先第一步的话会先加一个 defer connection.close()， defer 是 Golang 里面的一个语法，这一行的含义就是代表在这个函数退出的时候要把这个连接关掉，否则会有资源的泄露。
	defer conn.Close()
	// 用 bufio.NewReader 来创建一个带缓冲的只读流
	reader := bufio.NewReader(conn)
	for {
		// 带缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便是一个字节一个字节的读取，但是底层可能合并成几次大的读取操作。并且带缓冲的流会有更多的一些工具函数用来读取数据。
		// 可以简单地调用 readbyte 函数来读取单个字节。再把这一个字节写进去连接。
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
		_, err = conn.Write([]byte{b})
		if err != nil {
			break
		}
	}
}

我们来简单测试一下我们的第一个 TCP 服务器，然后测试会需要用到 nc 命令。如果没有的话可以进行安装，这里用 nc 127.0.0.1 10803，输入 timerring 然后服务器就会给你返回 timerring。 先运行代码

go 语言实战入门案例之实现Socks5_字段_04

然后另开一个终端进行测试：

go 语言实战入门案例之实现Socks5_代理服务器_05

auth

package main

import (
	"bufio"
	"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)
	// 我们实现一个空的 auth 函数，在 process 函数里面调用，再来编写 auth 函数的代码。
	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

	// 先用 read bytes 来把版本号读出来
	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	// 然后如果版本号不是 socket 5 的话直接返回报错
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	// 接下来我们再读取 method size ，也是一个字节。
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	// 然后需要我们去 make 一个相应长度的一个 slice ，用 io.ReadFull 把它去填充进去。
	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    |
	// +----+--------+
	// 此时，代理服务器还需要返回一个response， 返回包包括 两个字段，一个是 version 一个是 method，也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00。
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

我们回忆一下认证阶段的逻辑，首先第一步的话，浏览器会给代理服务器发送一个包，然后这个包有三个字段，

  • 第一个字段， version 也就是协议版本号，固定是 5
  • 第二个字段 methods，认证的方法数目
  • 第三个字段每个 method 的编码， 0代表不需要认证， 2 代表用户名密码认证 我们用 curl 命令测试一下当前版本的效果。此时 curl 命令肯定是不成功的，因为我们的协议还没实现完成。

go 语言实战入门案例之实现Socks5_代理服务器_06

但是我们看日志会发现， version 和 method 可以正常打印，说明当前我们的实现是正确的。

go 语言实战入门案例之实现Socks5_字段_07

请求阶段

接下来我们开始做第三步，实现请求阶段，我们试图读取到携带 URL 或者 IP 地址+端口的包，然后把它打印出来。

package main

import (
	"bufio"
	"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
	}
	// 我们实现一个和 auth 函数类似的 connect 函数，同样在 process 里面去调用。再来实现 connect 函数的代码。
	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) {
	// 我们来回忆一下请求阶段的逻辑。浏览器会发送一个包，包里面包含如下6个字段
	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05。version 版本号， 还是 5
	// CMD 0x01表示CONNECT请求。CMD 代表请求的类型，我们只支持 connection 请求，也就是让代理服务建立新的TCP连接。
	// RSV 保留字段，值为0x00，不理会。
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。可能是 IPV4 IPV6 或者域名。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值，这个地址的长度是根据 atype 的类型而不同的,port 端口号，两个字节, 我们需要逐个去读取这些字段。
	// DST.PORT 目标端口，固定2个字节

	// 后面这四个字段总共四个字节，我们可以一次性把它读出来。我们定义一个长度为 4 的 buffer 然后把它读满。
	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	// 读满之后，然后第0 个、第1个、第3个、分别是 version cmd 和 type
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	// version 需要判断是 socket 5
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	// cmd 需要判断是 1，这里cmdBind是在前面定义好的
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd:%v", cmd)
	}
	// 下面的 atype，可能是 ipv4 ，ipv6，或者是 host。
	addr := ""
	switch atyp {
	// 如果 IPV4 的话，我们再次读满这个 buffer，因为这个 buffer 长度刚好也是4个字节
	case atypeIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		// 然后逐个字节打印成 IP 地址的格式保存到 addr 变量。
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	// 如果是个 host 的话
	case atypeHOST:
		// 需要先读它的长度
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		// 再 make 一个相应长度的buf 填充它。
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read host failed:%w", err)
		}
		// 再转换成字符串保存到 addr 变量。
		addr = string(host)
	// IPV6 用得比较少，我们就暂时先不支持。
	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 ，我们读取它，然后按协议规定的大端字节序转换成数字。
	// 由于上面的 buffer 已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice ，长度是2用于读取，这样的话最多会只读两个字节回来。
	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，第一个是版本号还是 socket 5。
	// REP Relay field,内容取值如下 X’00’ succeeded，第二个，就是返回的类型，这里是成功就返回0。
	// RSV 保留字段，第三个是保留字段填 0。
	// ATYPE 地址类型，第四个 atype 地址类型填 1。
	// BND.ADDR 服务绑定的地址，第五个，第六个暂时用不到，都填成 0。
	// BND.PORT 服务绑定的端口DST.PORT

	// 一共 4 + 4 + 2 个字节，后面6个字节都是 0 填充。
	_, 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
}

现在我们来测试一下当前阶段的成果， 简单 curl 一下。

go 语言实战入门案例之实现Socks5_字段_08

go 语言实战入门案例之实现Socks5_字段_09

此时请求还是会失败，我们现在已经能看到正常打印出来访问的 IP 地址和端口，这说明我们当前的实现正常，这样我们就可以做最后一步，我们真正和这个端口建立连接，双向转发数据。

go 语言实战入门案例之实现Socks5_字段_10

我们直接用 net.dial 建立一个 TCP 连接，建立完连接之后，我们同样要加一个 defer 来关闭连接。接下来需要建立浏览器和下游服务器的双向数据转发。

标准库的 io.copy 可以实现一个单向数据转发，双向转发的话，需要启动两个 goroutinue。

go 语言实战入门案例之实现Socks5_字段_11

现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向 copy 出错的时候，再返回 connect 函数。这里可以使用到标准库里面的一个 context 机制，用 context 连 with cancel 来创建一个 context。

go 语言实战入门案例之实现Socks5_代理服务器_12

在最后等待 ctx.Done() ，只要 cancel 被调用， ctx.Done 就会立刻返回。然后在上面的两个 goroutinue 里面调用一次 cancel 即可。

完整代码

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)
	_, 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)

	// +----+-----+-------+------+----------+----------+
	// |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)
	}
	// 现在有一个问题，connect 函数会立刻返回，返回的时候连接就被关闭了。需要等待任意一个方向copy出错的时候，再返回 connect 函数。
	// 可以使用到标准库里面的一个 context 机制，用 context 连 with cancel 来创建一个context。
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// 然后在两个 goroutinue 里面 调用一次 cancel 即可。
	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()
	// 在最后等待 ctx.Done() ， 只要 cancel 被调用， ctx.Done就会立刻返回。
	<-ctx.Done()
	return nil
}

我们可以试着在浏览器里面再测试一下，在浏览器里面测试代理需要安装这个 switchomega 插件，然后里面新建一个情景模式，代理服务器选 socks 5，端口 1080 ，保存并启用。此时你应该还能够正常地访问网站，代理服务器这边会显示出浏览器版本的域名和端口。

go 语言实战入门案例之实现Socks5_字段_13

go 语言实战入门案例之实现Socks5_代理服务器_14

学习路线推荐

go 语言实战入门案例之实现Socks5_字段_15

参考：字节内部课 Go 语言原理与实践

标签：err,return,入门,nil,fmt,failed,Socks5,reader,go
From： https://blog.51cto.com/u_15736437/6948589

相关文章

  • play连接mongodb并进行查询测试
    环境准备1、 IP白名单分组添加2、 相关配置信息 application.conf增加 morphia.db.name=库名morphia.db.url=连接信息dependencies.yml增加require:-playmongo->playmongolatest.integration-org.mongodb->mongo-java-driver3.12.13-org.mongodb.m......
  • 整数加法小程序（新人入门）
     #include<stdio.h>intmain(){ printf("本程序为整数求和程序\n"); intnum1=0; intnum2=0; intsum=0; printf("请输入第一个整数："); scanf_s("%d",&num1); printf("请输入第二个整数："); scanf_s("%d",&num2);......
  • Google官方出品的Android App反编绎工具-Enjarify
    enjarify是由Google官方新出品的基于Python3开发，类似dex2jar的一个将Dalvik字节码转换成相对应的Java字节码开源工具，官方宣称有比dex2jar更优秀的兼容性，准确性及更高的效率。IntroductionEnjarifyisatoolfortranslatingDalvikbytecodetoequivalentJavabytecode.Thisal......
  • Redis从入门到放弃（7）：主从复制
    1、概念主从复制是Redis的一项重要特性，用于将一个Redis服务器（Master主节点）的数据复制到其他Redis服务器（Slave从节点），以实现数据的高可用性和读写分离。数据的复制是单向的，只能由主节点到从节点。2、作用主从复制在Redis中扮演着重要的角色，带来了以下几个主要的作用：高可用性：......
  • [数据分析与可视化] Python绘制数据地图4-MovingPandas入门指北
    MovingPandas是一个基于Python和GeoPandas的开源地理时空数据处理库，用于处理移动物体的轨迹数据。它提供了一组强大的工具，可以轻松地加载、分析和可视化移动物体的轨迹。通过使用MovingPandas，用户可以轻松地处理和分析移动对象数据，并从中提取有关行为、模式和趋势的见解。无论是处......
  • django自定义错误补获
    settings.pyREST_FRAMEWORK={'EXCEPTION_HANDLER':'xxx.custom_exception_handler',}新建.py文件，名称任意 xxx.pyfromdjango.dbimportDatabaseErrorfromrest_frameworkimportstatusfromrest_framework.responseimportResponsefromrest......
  • Django----三种返回值
    1、return render(request,'login.html')返回HTML的内容给前端浏览器2、returnredirect('/register/')重定向前端到url=register3、return HttpResponse(dl_len)django想前端返回json数据......
  • Govulncheck v1.0.0 发布了！
    原文在这里原文作者：JulieQiu,fortheGosecurityteam发布于13July2023我们很高兴地宣布，govulncheckv1.0.0已经发布，同时还发布了用于将扫描集成到其他工具中的API的v1.0.0版本！Go对漏洞管理的支持首次在去年九月宣布。自那以后，我们进行了多次更改，最终在今天发布......
  • 国产GOWIN实现低成本实现CSI MIPI转换DVP
     CSIMIPI转换DVP，要么就是通用IC操作，如龙讯芯片和索尼芯片，但是复杂的寄存器控制器实在开发太累。对于FPGA操作，大部分都是用xilinx的方案，xilinx方案成本太高，IP复杂。    而用国产GOWIN已经实现了直接mipicsi解码，而且支持非连续的clk时钟功能。   由于MIPICSI......
  • 小程序云开发快速入门（2/4）
    前言我们对《微信小程序云开发快速入门（1/4）》的知识进行回顾一下。在上章节我们知道了云开发的优势以及能力，并且我们还完成了码仔备忘录的本地版到网络版的改造，主要学习了云数据库同时还通过在小程序使用云API直接操作了云数据库：使用get()进行了数据库的查询使用add()进行了数据......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99