Go语言实战案例-SOCKS5代理
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)
}
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 代码实现了一个简单的 SOCKS5 代理服务器，主要功能包括客户端认证和目标连接请求的处理。首先，main 函数通过 net.Listen 启动一个 TCP 监听器，监听本地 127.0.0.1:1080，并为每个连接创建一个新的 goroutine 进行处理。
在 process 函数中，处理了两步操作：首先是认证阶段（auth 函数），在此阶段服务器根据客户端发送的认证方式信息（如是否需要用户名/密码）进行验证，成功后返回一个 0x00 表示无认证要求。接下来进入连接阶段（connect 函数），该阶段服务器处理客户端的 CONNECT 请求，解析目标地址（IPv4 地址、域名或 IPv6），并建立到目标服务器的 TCP 连接。如果目标连接成功，代理服务器会向客户端返回成功的响应。
在连接建立后，程序通过两个并发的 goroutine，分别转发客户端和目标服务器之间的数据，直到连接关闭。整个过程中，错误处理和日志记录都得到了良好的实现。
简而言之，这段代码实现了一个基本的 SOCKS5 代理服务器，支持认证和连接请求的处理，并能够在客户端与目标服务器之间转发数据。
语言进阶
1.并发VS并行
并发：多个任务交替执行，可能在一个处理器上轮流执行，给人同时进行的感觉。
并行：多个任务同时在不同的处理器或核心上执行，真正的“同时”进行。
1.1 Goroutine
Goroutine是 Go 语言的轻量级执行单元，由 Go 运行时调度管理。每个 goroutine 只需要很少的内存（通常几 KB），并且启动和销毁的开销非常低。多个 goroutine 可以在一个或多个操作系统线程上运行，Go 会自动调度它们。
package main
import (
"fmt"
"time"
)
func printHello() {
fmt.Println("Hello, Goroutine!")
}
func main() {
// 启动一个 goroutine
go printHello()
// 主 goroutine 等待一段时间，保证 printHello 执行完成
time.Sleep(time.Second)
}
这段 Go 代码演示了如何使用 goroutine 来并发执行任务。在 main 函数中，go printHello() 启动了一个新的 goroutine 来执行 printHello 函数，输出 "Hello, Goroutine!"。由于主 goroutine 在启动新 goroutine 后没有立即等待其完成，因此使用 time.Sleep(time.Second) 暂停主 goroutine 1 秒，确保新启动的 goroutine 有足够的时间执行完毕。这个例子展示了如何在 Go 中通过 goroutine 并发执行任务。
1.2 CSP
CSP（Communicating Sequential Processes，通信顺序进程）是一种并发编程模型，主要通过进程间通信来实现并发执行。Go 语言将 CSP 模型融入其并发编程模型中，使用 goroutines 和 channels 来实现并发和通信。
1.3 Channel
在 Go 语言中，Channel 是用来在不同的 goroutine 之间传递数据的管道。它是 Go 并发模型（基于 CSP）的一部分，用来实现安全的数据共享和同步。通过 channels，goroutines 可以在没有锁和共享内存的情况下进行通信。
1.4 并发安全Lock
在并发编程中，当多个 goroutine 共享某个资源（如变量、数据结构等）时，需要保证这些资源的访问是安全的，防止出现竞态条件（race condition）。**锁（Lock）**是实现并发安全的常见方法之一。Go 语言提供了 sync.Mutex 和 sync.RWMutex 来进行锁操作，从而确保在并发环境中对共享资源的访问是互斥的。
1.5 WaitGroup
sync.WaitGroup 是 Go 语言中的一个并发同步原语，用来等待一组 goroutine 执行完成。它通常用于在多个 goroutine 启动后，等待它们全部执行完毕，常见于并发任务的协调。
