Grok 生成的简易 socks5 代理服务器

AI 生成的简易 socks5 代理服务器，使用 golang 实现，使用 docker-compose 部署。

准备

• golang 开发环境
• docker

目录结构

your_project/
├── main.go
├── Dockerfile
└── docker-compose.yml

main.go 代码内容

默认监听 1080 端口，修改端口可以在 docker-compose 映射修改。

package main

import (
    "encoding/binary"
    "fmt"
    "io"
    "log"
    "net"
    "sync"
)

// 全局变量用于会话管理
var (
    // allowedClients 存储允许的客户端 IP 及其活跃会话计数
    allowedClients sync.Map // map[string]interface{}, value is *int
    // destToClient 存储目标地址到客户端 UDP 地址的映射
    destToClient sync.Map // map[string]string
)

func main() {
    // 启动 TCP 监听器
    go func() {
        listener, err := net.Listen("tcp", ":1080")
        if err != nil {
            log.Fatal("TCP 监听失败: ", err)
        }
        defer listener.Close()
        log.Println("TCP 服务器启动在 :1080")

        for {
            conn, err := listener.Accept()
            if err != nil {
                log.Println("接受 TCP 连接失败: ", err)
                continue
            }
            go handleConnection(conn)
        }
    }()

    // 启动 UDP 监听器
    udpAddr, err := net.ResolveUDPAddr("udp", ":1080")
    if err != nil {
        log.Fatal("解析 UDP 地址失败: ", err)
    }
    udpConn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        log.Fatal("UDP 监听失败: ", err)
    }
    defer udpConn.Close()
    log.Println("UDP 服务器启动在 :1080")

    buf := make([]byte, 65536)
    for {
        n, clientAddr, err := udpConn.ReadFromUDP(buf)
        if err != nil {
            log.Println("读取 UDP 数据失败: ", err)
            continue
        }
        go handleUDPPacket(udpConn, clientAddr, buf[:n])
    }
}

// handleConnection 处理 TCP 连接
func handleConnection(conn net.Conn) {
    defer conn.Close()

    // 读取客户端问候
    buf := make([]byte, 2)
    _, err := io.ReadFull(conn, buf)
    if err != nil {
        log.Println("读取问候失败: ", err)
        return
    }
    if buf[0] != 0x05 {
        log.Println("不支持的协议版本: ", buf[0])
        return
    }
    nmethods := buf[1]
    methods := make([]byte, nmethods)
    _, err = io.ReadFull(conn, methods)
    if err != nil {
        log.Println("读取认证方法失败: ", err)
        return
    }

    // 回复无认证
    _, err = conn.Write([]byte{0x05, 0x00})
    if err != nil {
        log.Println("发送认证回复失败: ", err)
        return
    }

    // 读取客户端请求
    buf = make([]byte, 4)
    _, err = io.ReadFull(conn, buf)
    if err != nil {
        log.Println("读取请求失败: ", err)
        return
    }
    if buf[0] != 0x05 {
        log.Println("不支持的协议版本: ", buf[0])
        return
    }
    cmd := buf[1]
    if cmd != 0x01 && cmd != 0x03 {
        log.Println("不支持的命令: ", cmd)
        conn.Write([]byte{0x05, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
        return
    }
    atyp := buf[3]
    var addr string
    switch atyp {
    case 0x01: // IPv4
        ip := make([]byte, 4)
        _, err = io.ReadFull(conn, ip)
        if err != nil {
            log.Println("读取 IPv4 地址失败: ", err)
            return
        }
        addr = net.IP(ip).String()
    case 0x03: // 域名
        lenByte := make([]byte, 1)
        _, err = io.ReadFull(conn, lenByte)
        if err != nil {
            log.Println("读取域名长度失败: ", err)
            return
        }
        domainLen := lenByte[0]
        domain := make([]byte, domainLen)
        _, err = io.ReadFull(conn, domain)
        if err != nil {
            log.Println("读取域名失败: ", err)
            return
        }
        addr = string(domain)
    case 0x04: // IPv6
        ip := make([]byte, 16)
        _, err = io.ReadFull(conn, ip)
        if err != nil {
            log.Println("读取 IPv6 地址失败: ", err)
            return
        }
        addr = net.IP(ip).String()
    default:
        log.Println("不支持的地址类型: ", atyp)
        conn.Write([]byte{0x05, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
        return
    }
    portBytes := make([]byte, 2)
    _, err = io.ReadFull(conn, portBytes)
    if err != nil {
        log.Println("读取端口失败: ", err)
        return
    }
    port := binary.BigEndian.Uint16(portBytes)

    if cmd == 0x01 { // CONNECT
        // 连接目标服务器
        destConn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", addr, port))
        if err != nil {
            log.Println("连接目标失败: ", err)
            conn.Write([]byte{0x05, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
            return
        }
        defer destConn.Close()

        // 发送成功回复
        reply := []byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
        _, err = conn.Write(reply)
        if err != nil {
            log.Println("发送成功回复失败: ", err)
            return
        }

        // 中继数据
        go io.Copy(destConn, conn)
        io.Copy(conn, destConn)
    } else if cmd == 0x03 { // UDP ASSOCIATE
        clientIP := conn.RemoteAddr().(*net.TCPAddr).IP.String()
        val, _ := allowedClients.LoadOrStore(clientIP, new(int))
        count := val.(*int)
        *count++
        defer func() {
            *count--
            if *count == 0 {
                allowedClients.Delete(clientIP)
            }
        }()

        // 发送 UDP 地址回复
        localAddr := conn.LocalAddr().(*net.TCPAddr)
        reply := []byte{0x05, 0x00, 0x00}
        if localAddr.IP.To4() != nil {
            reply = append(reply, 0x01)
            reply = append(reply, localAddr.IP.To4()...)
        } else {
            reply = append(reply, 0x04)
            reply = append(reply, localAddr.IP.To16()...)
        }
        reply = append(reply, byte(localAddr.Port>>8), byte(localAddr.Port&0xff))
        _, err = conn.Write(reply)
        if err != nil {
            log.Println("发送 UDP ASSOCIATE 回复失败: ", err)
            return
        }

        // 保持 TCP 连接打开
        buf := make([]byte, 1)
        _, err = conn.Read(buf)
        if err != nil {
            log.Println("TCP 连接关闭: ", err)
        }
    }
}

// handleUDPPacket 处理 UDP 数据包
func handleUDPPacket(udpConn *net.UDPConn, srcAddr *net.UDPAddr, data []byte) {
    clientIP := srcAddr.IP.String()
    if _, ok := allowedClients.Load(clientIP); !ok {
        log.Println("来自未授权客户端的 UDP 数据包: ", clientIP)
        return
    }

    // 判断是否为客户端发送的 SOCKS5 UDP 数据包
    if len(data) < 3 || binary.BigEndian.Uint16(data[0:2]) != 0 || data[2] != 0 {
        // 来自目标服务器的响应
        destKey := srcAddr.String()
        if val, ok := destToClient.Load(destKey); ok {
            clientUDPAddrStr := val.(string)
            clientUDPAddr, err := net.ResolveUDPAddr("udp", clientUDPAddrStr)
            if err != nil {
                log.Println("解析客户端 UDP 地址失败: ", err)
                return
            }
            // 封装 SOCKS5 头部
            response := []byte{0x00, 0x00, 0x00} // RSV 和 FRAG
            if ip := srcAddr.IP.To4(); ip != nil {
                response = append(response, 0x01)
                response = append(response, ip...)
            } else if ip := srcAddr.IP.To16(); ip != nil {
                response = append(response, 0x04)
                response = append(response, ip...)
            } else {
                log.Println("不支持的 IP 类型")
                return
            }
            response = append(response, byte(srcAddr.Port>>8), byte(srcAddr.Port&0xff))
            response = append(response, data...)
            _, err = udpConn.WriteToUDP(response, clientUDPAddr)
            if err != nil {
                log.Println("发送响应到客户端失败: ", err)
            }
        }
        return
    }

    // 来自客户端的请求
    atyp := data[3]
    var destAddr string
    var destPort uint16
    var offset int
    switch atyp {
    case 0x01: // IPv4
        if len(data) < 10 {
            log.Println("无效的 UDP 数据包")
            return
        }
        destAddr = net.IP(data[4:8]).String()
        destPort = binary.BigEndian.Uint16(data[8:10])
        offset = 10
    case 0x03: // 域名
        if len(data) < 5 {
            log.Println("无效的 UDP 数据包")
            return
        }
        domainLen := data[4]
        if len(data) < int(5+domainLen+2) {
            log.Println("无效的 UDP 数据包")
            return
        }
        domain := string(data[5 : 5+domainLen])
        destAddr = domain
        destPort = binary.BigEndian.Uint16(data[5+domainLen : 7+domainLen])
        offset = int(7 + domainLen)
    case 0x04: // IPv6
        if len(data) < 22 {
            log.Println("无效的 UDP 数据包")
            return
        }
        destAddr = net.IP(data[4:20]).String()
        destPort = binary.BigEndian.Uint16(data[20:22])
        offset = 22
    default:
        log.Println("不支持的地址类型: ", atyp)
        return
    }
    payload := data[offset:]

    // 发送数据到目标
    destUDPAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", destAddr, destPort))
    if err != nil {
        log.Println("解析目标 UDP 地址失败: ", err)
        return
    }
    _, err = udpConn.WriteToUDP(payload, destUDPAddr)
    if err != nil {
        log.Println("发送数据到目标失败: ", err)
        return
    }

    // 记录目标到客户端的映射
    destKey := destUDPAddr.String()
    clientKey := srcAddr.String()
    destToClient.Store(destKey, clientKey)
}

初始化 mod 并且下载依赖

执行以下命令：

go mod init socks5-server
go mod tidy

Dockerfile 内容

# 使用官方 Golang 镜像作为基础镜像
FROM golang:1.20-alpine

# 设置工作目录
WORKDIR /app

# 将当前目录下的所有文件复制到容器的 /app 目录中
COPY . .

# 编译 Golang 应用程序
RUN go build -o socks5-server

# 运行编译好的二进制文件
CMD ["./socks5-server"]

docker-compose.yml 内容

services:
  socks5-server:  # 服务名称
    build:
      context: .  # 构建上下文为当前目录
      dockerfile: Dockerfile  # 指定使用的 Dockerfile
    ports:
      - "1080:1080"  # 将主机的 1080 端口映射到容器的 1080 端口
      - "1080:1080/udp"

启动

docker compose up -d