-
-
package main
-
-import (
- "flag"
- "fmt"
- "log"
- "os"
-
- "github.com/azoic/wormhole-client/internal/client"
-)
-
-var (
- version = "v1.0.0"
- buildTime = "unknown"
-)
-
-func main() {
- configPath := flag.String("config", "configs/client.yaml", "Configuration file path")
- mode := flag.String("mode", "http", "Client mode: http, global, transparent")
- showVersion := flag.Bool("version", false, "Show version information")
- flag.Parse()
-
- if *showVersion {
- fmt.Printf("Wormhole SOCKS5 Client %s\n", version)
- fmt.Printf("Build time: %s\n", buildTime)
- os.Exit(0)
- }
-
- fmt.Printf("🚀 Starting Wormhole SOCKS5 Client %s\n", version)
- fmt.Printf("📄 Config: %s\n", *configPath)
- fmt.Printf("🔧 Mode: %s\n", *mode)
-
- // TODO: 实现完整的客户端逻辑
- cli := client.NewClient(*mode)
- if err := cli.Start(*configPath); err != nil {
- log.Fatalf("Client failed: %v", err)
- }
-}
-
-
-
package client
-
-import (
- "fmt"
- "os"
- "os/signal"
- "syscall"
-
- "github.com/azoic/wormhole-client/internal/config"
- "github.com/azoic/wormhole-client/internal/proxy"
- "github.com/azoic/wormhole-client/internal/system"
- "github.com/azoic/wormhole-client/pkg/dns"
- "github.com/azoic/wormhole-client/pkg/logger"
-)
-
-type Client struct {
- mode string
- config *config.Config
- socks5Proxy *proxy.SOCKS5Proxy
- dnsProxy *dns.DNSProxy
- systemProxyMgr *system.SystemProxyManager
-}
-
-func NewClient(mode string) *Client {
- return &Client{
- mode: mode,
- systemProxyMgr: system.NewSystemProxyManager(),
- }
-}
-
-func (c *Client) Start(configPath string) error {
- // 加载配置
- cfg, err := config.LoadConfig(configPath)
- if err != nil {
- return fmt.Errorf("failed to load config: %v", err)
- }
-
- if err := cfg.Validate(); err != nil {
- return fmt.Errorf("invalid config: %v", err)
- }
-
- c.config = cfg
-
- // 设置日志级别
- logger.SetLevel(cfg.LogLevel)
-
- logger.Info("🚀 Starting Wormhole SOCKS5 Client")
- logger.Info("📄 Config loaded from: %s", configPath)
- logger.Info("🔧 Mode: %s", c.mode)
- logger.Info("🎯 SOCKS5 Server: %s", cfg.GetServerAddr())
-
- // 创建SOCKS5代理客户端
- c.socks5Proxy = proxy.NewSOCKS5Proxy(
- cfg.GetServerAddr(),
- cfg.Server.Username,
- cfg.Server.Password,
- cfg.Timeout,
- )
-
- // 设置信号处理
- c.setupSignalHandler()
-
- switch c.mode {
- case "http":
- return c.startHTTPProxy()
- case "global":
- return c.startGlobalProxy()
- case "transparent":
- return c.startTransparentProxy()
- default:
- return fmt.Errorf("unsupported mode: %s", c.mode)
- }
-}
-
-func (c *Client) startHTTPProxy() error {
- logger.Info("🌐 Starting HTTP proxy mode...")
- logger.Info("💡 Setting up HTTP proxy on port %d", c.config.Proxy.LocalPort)
-
- server := c.socks5Proxy.CreateHTTPProxy(c.config.Proxy.LocalPort)
-
- logger.Info("✅ HTTP proxy started on :%d", c.config.Proxy.LocalPort)
- logger.Info("💡 Configure your browser to use HTTP proxy: 127.0.0.1:%d", c.config.Proxy.LocalPort)
-
- return server.ListenAndServe()
-}
-
-func (c *Client) startGlobalProxy() error {
- logger.Info("🌍 Starting global proxy mode...")
- logger.Info("💡 This will configure system-wide proxy settings")
- logger.Info("⚠️ Requires administrator privileges")
-
- // 启动HTTP代理服务器
- server := c.socks5Proxy.CreateHTTPProxy(c.config.Proxy.LocalPort)
- go func() {
- if err := server.ListenAndServe(); err != nil {
- logger.Error("HTTP proxy server failed: %v", err)
- }
- }()
-
- // 设置系统代理
- httpProxy := fmt.Sprintf("127.0.0.1:%d", c.config.Proxy.LocalPort)
- httpsProxy := httpProxy
-
- if err := c.systemProxyMgr.SetGlobalProxy(httpProxy, httpsProxy, ""); err != nil {
- logger.Error("Failed to set system proxy: %v", err)
- logger.Warn("You may need to run with administrator privileges")
- logger.Info("Manual setup: Set HTTP/HTTPS proxy to %s", httpProxy)
- } else {
- logger.Info("✅ System proxy configured successfully")
- }
-
- // 启动DNS代理（如果启用）
- if c.config.GlobalProxy.DNSProxy {
- logger.Info("🔍 Starting DNS proxy on port %d", c.config.GlobalProxy.DNSPort)
- c.dnsProxy = dns.NewDNSProxy("8.8.8.8:53", c.config.GlobalProxy.DNSPort)
- if err := c.dnsProxy.Start(); err != nil {
- logger.Warn("Failed to start DNS proxy: %v", err)
- } else {
- logger.Info("✅ DNS proxy started")
- }
- }
-
- logger.Info("🎉 Global proxy mode started successfully")
- logger.Info("📍 HTTP/HTTPS Proxy: %s", httpProxy)
- if c.dnsProxy != nil {
- logger.Info("📍 DNS Proxy: 127.0.0.1:%d", c.config.GlobalProxy.DNSPort)
- }
-
- // 保持运行
- select {}
-}
-
-func (c *Client) startTransparentProxy() error {
- logger.Info("🔍 Starting transparent proxy mode...")
- logger.Info("💡 This will intercept network traffic transparently")
- logger.Info("⚠️ Requires root privileges and iptables support")
- logger.Error("❌ Transparent proxy mode is not yet implemented")
-
- return fmt.Errorf("transparent proxy mode not implemented")
-}
-
-func (c *Client) setupSignalHandler() {
- sigChan := make(chan os.Signal, 1)
- signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
-
- go func() {
- <-sigChan
- logger.Info("🛑 Shutting down...")
- c.cleanup()
- os.Exit(0)
- }()
-}
-
-func (c *Client) cleanup() {
- // 恢复系统代理设置
- if c.systemProxyMgr != nil {
- if err := c.systemProxyMgr.RestoreProxy(); err != nil {
- logger.Error("Failed to restore system proxy: %v", err)
- }
- }
-
- // 停止DNS代理
- if c.dnsProxy != nil {
- if err := c.dnsProxy.Stop(); err != nil {
- logger.Error("Failed to stop DNS proxy: %v", err)
- }
- }
-
- logger.Info("✅ Cleanup completed")
-}
-
-
-
package config
-
-import (
- "fmt"
- "io/ioutil"
- "time"
-
- "gopkg.in/yaml.v3"
-)
-
-// Config 客户端配置结构
-type Config struct {
- ServiceType string `yaml:"serviceType"`
- Server Server `yaml:"server"`
- Proxy Proxy `yaml:"proxy"`
- GlobalProxy GlobalProxy `yaml:"globalProxy"`
- TransparentProxy TransparentProxy `yaml:"transparentProxy"`
- LogLevel string `yaml:"logLevel"`
- Timeout time.Duration `yaml:"timeout"`
-}
-
-// Server SOCKS5服务器配置
-type Server struct {
- Address string `yaml:"address"`
- Port int `yaml:"port"`
- Username string `yaml:"username"`
- Password string `yaml:"password"`
-}
-
-// Proxy 代理模式配置
-type Proxy struct {
- Mode string `yaml:"mode"`
- LocalPort int `yaml:"localPort"`
-}
-
-// GlobalProxy 全局代理配置
-type GlobalProxy struct {
- Enabled bool `yaml:"enabled"`
- DNSProxy bool `yaml:"dnsProxy"`
- DNSPort int `yaml:"dnsPort"`
- Routing Routing `yaml:"routing"`
-}
-
-// TransparentProxy 透明代理配置
-type TransparentProxy struct {
- Enabled bool `yaml:"enabled"`
- Port int `yaml:"port"`
- DNSPort int `yaml:"dnsPort"`
- ModifyDNS bool `yaml:"modifyDNS"`
- ModifyRoute bool `yaml:"modifyRoute"`
-}
-
-// Routing 路由规则配置
-type Routing struct {
- BypassLocal bool `yaml:"bypassLocal"`
- BypassPrivate bool `yaml:"bypassPrivate"`
- BypassDomains []string `yaml:"bypassDomains"`
- ForceDomains []string `yaml:"forceDomains"`
-}
-
-// LoadConfig 从文件加载配置
-func LoadConfig(configPath string) (*Config, error) {
- data, err := ioutil.ReadFile(configPath)
- if err != nil {
- return nil, fmt.Errorf("failed to read config file: %v", err)
- }
-
- var config Config
- if err := yaml.Unmarshal(data, &config); err != nil {
- return nil, fmt.Errorf("failed to parse config file: %v", err)
- }
-
- // 设置默认值
- if config.LogLevel == "" {
- config.LogLevel = "info"
- }
- if config.Timeout == 0 {
- config.Timeout = 30 * time.Second
- }
- if config.Proxy.LocalPort == 0 {
- config.Proxy.LocalPort = 8080
- }
-
- return &config, nil
-}
-
-// GetServerAddr 获取服务器地址
-func (c *Config) GetServerAddr() string {
- return fmt.Sprintf("%s:%d", c.Server.Address, c.Server.Port)
-}
-
-// Validate 验证配置
-func (c *Config) Validate() error {
- if c.Server.Address == "" {
- return fmt.Errorf("server address is required")
- }
- if c.Server.Port <= 0 || c.Server.Port > 65535 {
- return fmt.Errorf("invalid server port: %d", c.Server.Port)
- }
-
- validModes := map[string]bool{"http": true, "global": true, "transparent": true}
- if !validModes[c.Proxy.Mode] {
- return fmt.Errorf("invalid proxy mode: %s", c.Proxy.Mode)
- }
-
- return nil
-}
-
-
-
package proxy
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "io"
- "net"
- "net/http"
- "strconv"
- "sync"
- "time"
-
- "github.com/azoic/wormhole-client/pkg/logger"
-)
-
-// SOCKS5Proxy SOCKS5代理客户端
-type SOCKS5Proxy struct {
- serverAddr string
- username string
- password string
- timeout time.Duration
- connPool *connectionPool
- stats *ProxyStats
-}
-
-// connectionPool 连接池
-type connectionPool struct {
- connections chan net.Conn
- maxSize int
- mutex sync.Mutex
-}
-
-// NewSOCKS5Proxy 创建SOCKS5代理客户端
-func NewSOCKS5Proxy(serverAddr, username, password string, timeout time.Duration) *SOCKS5Proxy {
- return &SOCKS5Proxy{
- serverAddr: serverAddr,
- username: username,
- password: password,
- timeout: timeout,
- connPool: &connectionPool{
- connections: make(chan net.Conn, 10),
- maxSize: 10,
- },
- stats: NewProxyStats(),
- }
-}
-
-// CreateHTTPProxy 创建HTTP代理服务器
-func (p *SOCKS5Proxy) CreateHTTPProxy(localPort int) *http.Server {
- proxyHandler := &httpProxyHandler{
- socks5Proxy: p,
- }
-
- // 创建ServeMux来处理不同的路径
- mux := http.NewServeMux()
- mux.Handle("/", proxyHandler)
- mux.HandleFunc("/stats", p.handleStats)
- mux.HandleFunc("/health", p.handleHealth)
-
- server := &http.Server{
- Addr: fmt.Sprintf(":%d", localPort),
- Handler: mux,
- ReadTimeout: 30 * time.Second,
- WriteTimeout: 30 * time.Second,
- IdleTimeout: 120 * time.Second,
- MaxHeaderBytes: 1 << 20, // 1MB
- }
-
- return server
-}
-
-// httpProxyHandler HTTP代理处理器
-type httpProxyHandler struct {
- socks5Proxy *SOCKS5Proxy
-}
-
-func (h *httpProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- // 统计连接
- h.socks5Proxy.stats.IncrementConnections()
- defer h.socks5Proxy.stats.DecrementActiveConnections()
-
- logger.Debug("Processing request: %s %s from %s", r.Method, r.URL.String(), r.RemoteAddr)
-
- if r.Method == http.MethodConnect {
- h.handleHTTPSProxy(w, r)
- } else {
- h.handleHTTPProxy(w, r)
- }
-}
-
-// handleHTTPSProxy 处理HTTPS代理请求 (CONNECT方法)
-func (h *httpProxyHandler) handleHTTPSProxy(w http.ResponseWriter, r *http.Request) {
- ctx, cancel := context.WithTimeout(r.Context(), h.socks5Proxy.timeout)
- defer cancel()
-
- destConn, err := h.socks5Proxy.DialTCPWithContext(ctx, r.Host)
- if err != nil {
- h.socks5Proxy.stats.IncrementFailedRequests()
- h.socks5Proxy.stats.IncrementSOCKS5Error("connection_failed")
- logger.Error("Failed to connect via SOCKS5 to %s: %v", r.Host, err)
- http.Error(w, "Bad Gateway", http.StatusBadGateway)
- return
- }
- defer destConn.Close()
-
- // 发送200 Connection established响应
- w.WriteHeader(http.StatusOK)
-
- hijacker, ok := w.(http.Hijacker)
- if !ok {
- h.socks5Proxy.stats.IncrementFailedRequests()
- logger.Error("Hijacking not supported")
- http.Error(w, "Internal Server Error", http.StatusInternalServerError)
- return
- }
-
- clientConn, _, err := hijacker.Hijack()
- if err != nil {
- h.socks5Proxy.stats.IncrementFailedRequests()
- logger.Error("Failed to hijack connection: %v", err)
- return
- }
- defer clientConn.Close()
-
- h.socks5Proxy.stats.IncrementSuccessfulRequests()
- logger.Debug("Established HTTPS tunnel to %s", r.Host)
-
- // 双向数据转发
- var wg sync.WaitGroup
- wg.Add(2)
-
- go func() {
- defer wg.Done()
- written := h.copyData(clientConn, destConn, "client->server")
- h.socks5Proxy.stats.AddBytesTransferred(written, 0)
- }()
-
- go func() {
- defer wg.Done()
- written := h.copyData(destConn, clientConn, "server->client")
- h.socks5Proxy.stats.AddBytesTransferred(0, written)
- }()
-
- wg.Wait()
- logger.Debug("HTTPS tunnel to %s closed", r.Host)
-}
-
-// handleHTTPProxy 处理HTTP代理请求
-func (h *httpProxyHandler) handleHTTPProxy(w http.ResponseWriter, r *http.Request) {
- ctx, cancel := context.WithTimeout(r.Context(), h.socks5Proxy.timeout)
- defer cancel()
-
- // 确保URL包含Host
- if r.URL.Host == "" {
- r.URL.Host = r.Host
- }
- if r.URL.Scheme == "" {
- r.URL.Scheme = "http"
- }
-
- // 通过SOCKS5连接到目标服务器
- destConn, err := h.socks5Proxy.DialTCPWithContext(ctx, r.Host)
- if err != nil {
- h.socks5Proxy.stats.IncrementFailedRequests()
- h.socks5Proxy.stats.IncrementSOCKS5Error("connection_failed")
- logger.Error("Failed to connect via SOCKS5 to %s: %v", r.Host, err)
- http.Error(w, "Bad Gateway", http.StatusBadGateway)
- return
- }
- defer destConn.Close()
-
- // 发送HTTP请求
- if err := r.Write(destConn); err != nil {
- h.socks5Proxy.stats.IncrementFailedRequests()
- logger.Error("Failed to write request to %s: %v", r.Host, err)
- http.Error(w, "Bad Gateway", http.StatusBadGateway)
- return
- }
-
- // 设置响应头
- w.Header().Set("Via", "1.1 wormhole-proxy")
-
- // 使用自定义ResponseWriter来统计字节数
- statsWriter := &statsResponseWriter{
- ResponseWriter: w,
- stats: h.socks5Proxy.stats,
- }
-
- // 读取响应并返回给客户端
- written, err := io.Copy(statsWriter, destConn)
- if err != nil {
- h.socks5Proxy.stats.IncrementFailedRequests()
- logger.Error("Failed to copy response from %s: %v", r.Host, err)
- return
- }
-
- h.socks5Proxy.stats.IncrementSuccessfulRequests()
- h.socks5Proxy.stats.AddBytesTransferred(0, written)
- logger.Debug("HTTP request to %s completed, %d bytes", r.Host, written)
-}
-
-// statsResponseWriter 带统计功能的ResponseWriter
-type statsResponseWriter struct {
- http.ResponseWriter
- stats *ProxyStats
-}
-
-func (w *statsResponseWriter) Write(data []byte) (int, error) {
- n, err := w.ResponseWriter.Write(data)
- if n > 0 {
- w.stats.AddBytesTransferred(int64(n), 0)
- }
- return n, err
-}
-
-// copyData 数据复制，带方向标识和字节统计
-func (h *httpProxyHandler) copyData(dst, src net.Conn, direction string) int64 {
- defer dst.Close()
- defer src.Close()
-
- written, err := io.Copy(dst, src)
- if err != nil {
- logger.Debug("Copy %s finished with error: %v, bytes: %d", direction, err, written)
- } else {
- logger.Debug("Copy %s finished successfully, bytes: %d", direction, written)
- }
-
- return written
-}
-
-// handleStats 处理统计信息请求
-func (p *SOCKS5Proxy) handleStats(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodGet {
- http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
- return
- }
-
- stats := p.stats.GetStats()
-
- w.Header().Set("Content-Type", "application/json")
- w.Header().Set("Access-Control-Allow-Origin", "*")
-
- if err := json.NewEncoder(w).Encode(stats); err != nil {
- logger.Error("Failed to encode stats: %v", err)
- http.Error(w, "Internal Server Error", http.StatusInternalServerError)
- return
- }
-}
-
-// handleHealth 处理健康检查请求
-func (p *SOCKS5Proxy) handleHealth(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodGet {
- http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
- return
- }
-
- stats := p.stats.GetStats()
-
- health := map[string]interface{}{
- "status": "healthy",
- "uptime": stats.Uptime.String(),
- "active_connections": stats.ActiveConnections,
- "success_rate": stats.GetSuccessRate(),
- }
-
- w.Header().Set("Content-Type", "application/json")
-
- if err := json.NewEncoder(w).Encode(health); err != nil {
- logger.Error("Failed to encode health: %v", err)
- http.Error(w, "Internal Server Error", http.StatusInternalServerError)
- return
- }
-}
-
-// GetStats 获取代理统计信息
-func (p *SOCKS5Proxy) GetStats() ProxyStatsSnapshot {
- return p.stats.GetStats()
-}
-
-// DialTCP 通过SOCKS5连接到目标地址
-func (p *SOCKS5Proxy) DialTCP(address string) (net.Conn, error) {
- return p.DialTCPWithContext(context.Background(), address)
-}
-
-// DialTCPWithContext 通过SOCKS5连接到目标地址（带上下文）
-func (p *SOCKS5Proxy) DialTCPWithContext(ctx context.Context, address string) (net.Conn, error) {
- // 连接到SOCKS5代理服务器
- dialer := &net.Dialer{
- Timeout: p.timeout,
- }
-
- conn, err := dialer.DialContext(ctx, "tcp", p.serverAddr)
- if err != nil {
- return nil, fmt.Errorf("failed to connect to SOCKS5 server: %v", err)
- }
-
- // 设置连接超时
- deadline, ok := ctx.Deadline()
- if ok {
- conn.SetDeadline(deadline)
- }
-
- // 执行SOCKS5握手
- if err := p.performSOCKS5Handshake(conn, address); err != nil {
- conn.Close()
- return nil, fmt.Errorf("SOCKS5 handshake failed: %v", err)
- }
-
- // 清除deadline，让连接正常使用
- conn.SetDeadline(time.Time{})
-
- logger.Debug("Successfully connected to %s via SOCKS5 proxy", address)
- return conn, nil
-}
-
-// performSOCKS5Handshake 执行SOCKS5握手协议
-func (p *SOCKS5Proxy) performSOCKS5Handshake(conn net.Conn, targetAddr string) error {
- // 设置握手超时
- deadline := time.Now().Add(p.timeout)
- conn.SetDeadline(deadline)
-
- // 第一步：发送认证方法选择
- authMethods := []byte{0x05, 0x02, 0x00, 0x02} // 版本5，2个方法，无认证+用户名密码认证
- if _, err := conn.Write(authMethods); err != nil {
- return fmt.Errorf("failed to send auth methods: %v", err)
- }
-
- // 读取服务器响应
- response := make([]byte, 2)
- if _, err := io.ReadFull(conn, response); err != nil {
- return fmt.Errorf("failed to read auth response: %v", err)
- }
-
- if response[0] != 0x05 {
- return fmt.Errorf("invalid SOCKS version: %d", response[0])
- }
-
- // 第二步：处理认证
- switch response[1] {
- case 0x00: // 无认证
- logger.Debug("SOCKS5 server requires no authentication")
- case 0x02: // 用户名密码认证
- if err := p.performUserPassAuth(conn); err != nil {
- return fmt.Errorf("user/pass authentication failed: %v", err)
- }
- case 0xFF: // 无可接受的认证方法
- return fmt.Errorf("no acceptable authentication methods")
- default:
- return fmt.Errorf("unsupported authentication method: %d", response[1])
- }
-
- // 第三步：发送连接请求
- connectReq, err := p.buildConnectRequest(targetAddr)
- if err != nil {
- return fmt.Errorf("failed to build connect request: %v", err)
- }
-
- if _, err := conn.Write(connectReq); err != nil {
- return fmt.Errorf("failed to send connect request: %v", err)
- }
-
- // 第四步：读取连接响应
- return p.readConnectResponse(conn)
-}
-
-// buildConnectRequest 构建连接请求
-func (p *SOCKS5Proxy) buildConnectRequest(targetAddr string) ([]byte, error) {
- host, portStr, err := net.SplitHostPort(targetAddr)
- if err != nil {
- return nil, fmt.Errorf("invalid target address: %v", err)
- }
-
- // 解析端口号
- portNum, err := parsePort(portStr)
- if err != nil {
- return nil, fmt.Errorf("invalid port: %v", err)
- }
-
- var connectReq []byte
-
- // 检测地址类型并构建请求
- if ip := net.ParseIP(host); ip != nil {
- if ip4 := ip.To4(); ip4 != nil {
- // IPv4地址
- connectReq = []byte{0x05, 0x01, 0x00, 0x01}
- connectReq = append(connectReq, ip4...)
- } else if ip6 := ip.To16(); ip6 != nil {
- // IPv6地址
- connectReq = []byte{0x05, 0x01, 0x00, 0x04}
- connectReq = append(connectReq, ip6...)
- }
- } else {
- // 域名
- if len(host) > 255 {
- return nil, fmt.Errorf("domain name too long: %d", len(host))
- }
- connectReq = []byte{0x05, 0x01, 0x00, 0x03}
- connectReq = append(connectReq, byte(len(host)))
- connectReq = append(connectReq, []byte(host)...)
- }
-
- // 添加端口
- connectReq = append(connectReq, byte(portNum>>8), byte(portNum&0xFF))
-
- return connectReq, nil
-}
-
-// readConnectResponse 读取连接响应
-func (p *SOCKS5Proxy) readConnectResponse(conn net.Conn) error {
- // 读取响应头部
- header := make([]byte, 4)
- if _, err := io.ReadFull(conn, header); err != nil {
- return fmt.Errorf("failed to read connect response header: %v", err)
- }
-
- if header[0] != 0x05 {
- return fmt.Errorf("invalid SOCKS version in response: %d", header[0])
- }
-
- if header[1] != 0x00 {
- return fmt.Errorf("connection failed, status: %d (%s)", header[1], getSOCKS5ErrorMessage(header[1]))
- }
-
- // 读取绑定地址和端口
- addrType := header[3]
- switch addrType {
- case 0x01: // IPv4
- skipBytes := make([]byte, 6) // 4字节IP + 2字节端口
- _, err := io.ReadFull(conn, skipBytes)
- return err
- case 0x03: // 域名
- lenByte := make([]byte, 1)
- if _, err := io.ReadFull(conn, lenByte); err != nil {
- return err
- }
- skipBytes := make([]byte, int(lenByte[0])+2) // 域名长度 + 2字节端口
- _, err := io.ReadFull(conn, skipBytes)
- return err
- case 0x04: // IPv6
- skipBytes := make([]byte, 18) // 16字节IP + 2字节端口
- _, err := io.ReadFull(conn, skipBytes)
- return err
- default:
- return fmt.Errorf("unsupported address type: %d", addrType)
- }
-}
-
-// performUserPassAuth 执行用户名密码认证
-func (p *SOCKS5Proxy) performUserPassAuth(conn net.Conn) error {
- // 发送用户名密码
- authData := []byte{0x01} // 子协议版本
- authData = append(authData, byte(len(p.username)))
- authData = append(authData, []byte(p.username)...)
- authData = append(authData, byte(len(p.password)))
- authData = append(authData, []byte(p.password)...)
-
- if _, err := conn.Write(authData); err != nil {
- return fmt.Errorf("failed to send credentials: %v", err)
- }
-
- // 读取认证结果
- authResult := make([]byte, 2)
- if _, err := io.ReadFull(conn, authResult); err != nil {
- return fmt.Errorf("failed to read auth result: %v", err)
- }
-
- if authResult[0] != 0x01 {
- return fmt.Errorf("invalid auth response version: %d", authResult[0])
- }
-
- if authResult[1] != 0x00 {
- return fmt.Errorf("authentication failed")
- }
-
- logger.Debug("SOCKS5 authentication successful")
- return nil
-}
-
-// getSOCKS5ErrorMessage 获取SOCKS5错误消息
-func getSOCKS5ErrorMessage(code byte) string {
- switch code {
- case 0x01:
- return "general SOCKS server failure"
- case 0x02:
- return "connection not allowed by ruleset"
- case 0x03:
- return "network unreachable"
- case 0x04:
- return "host unreachable"
- case 0x05:
- return "connection refused"
- case 0x06:
- return "TTL expired"
- case 0x07:
- return "command not supported"
- case 0x08:
- return "address type not supported"
- default:
- return "unknown error"
- }
-}
-
-// parsePort 解析端口号
-func parsePort(portStr string) (int, error) {
- if portStr == "" {
- return 80, nil // 默认HTTP端口
- }
-
- port, err := strconv.Atoi(portStr)
- if err != nil {
- return 0, fmt.Errorf("invalid port format: %s", portStr)
- }
-
- if port < 1 || port > 65535 {
- return 0, fmt.Errorf("port out of range: %d", port)
- }
-
- return port, nil
-}
-
-
-
package proxy
-
-import (
- "sync"
- "sync/atomic"
- "time"
-)
-
-// ProxyStats 代理统计信息
-type ProxyStats struct {
- StartTime time.Time
- TotalConnections int64
- ActiveConnections int64
- SuccessfulRequests int64
- FailedRequests int64
- BytesSent int64
- BytesReceived int64
- SOCKS5Errors map[string]int64
- mutex sync.RWMutex
-}
-
-// NewProxyStats 创建新的统计实例
-func NewProxyStats() *ProxyStats {
- return &ProxyStats{
- StartTime: time.Now(),
- SOCKS5Errors: make(map[string]int64),
- }
-}
-
-// IncrementConnections 增加连接计数
-func (s *ProxyStats) IncrementConnections() {
- atomic.AddInt64(&s.TotalConnections, 1)
- atomic.AddInt64(&s.ActiveConnections, 1)
-}
-
-// DecrementActiveConnections 减少活跃连接计数
-func (s *ProxyStats) DecrementActiveConnections() {
- atomic.AddInt64(&s.ActiveConnections, -1)
-}
-
-// IncrementSuccessfulRequests 增加成功请求计数
-func (s *ProxyStats) IncrementSuccessfulRequests() {
- atomic.AddInt64(&s.SuccessfulRequests, 1)
-}
-
-// IncrementFailedRequests 增加失败请求计数
-func (s *ProxyStats) IncrementFailedRequests() {
- atomic.AddInt64(&s.FailedRequests, 1)
-}
-
-// AddBytesTransferred 添加传输字节数
-func (s *ProxyStats) AddBytesTransferred(sent, received int64) {
- atomic.AddInt64(&s.BytesSent, sent)
- atomic.AddInt64(&s.BytesReceived, received)
-}
-
-// IncrementSOCKS5Error 增加SOCKS5错误计数
-func (s *ProxyStats) IncrementSOCKS5Error(errorType string) {
- s.mutex.Lock()
- defer s.mutex.Unlock()
- s.SOCKS5Errors[errorType]++
-}
-
-// GetStats 获取统计快照
-func (s *ProxyStats) GetStats() ProxyStatsSnapshot {
- s.mutex.RLock()
- defer s.mutex.RUnlock()
-
- errors := make(map[string]int64)
- for k, v := range s.SOCKS5Errors {
- errors[k] = v
- }
-
- return ProxyStatsSnapshot{
- StartTime: s.StartTime,
- Uptime: time.Since(s.StartTime),
- TotalConnections: atomic.LoadInt64(&s.TotalConnections),
- ActiveConnections: atomic.LoadInt64(&s.ActiveConnections),
- SuccessfulRequests: atomic.LoadInt64(&s.SuccessfulRequests),
- FailedRequests: atomic.LoadInt64(&s.FailedRequests),
- BytesSent: atomic.LoadInt64(&s.BytesSent),
- BytesReceived: atomic.LoadInt64(&s.BytesReceived),
- SOCKS5Errors: errors,
- }
-}
-
-// ProxyStatsSnapshot 统计快照
-type ProxyStatsSnapshot struct {
- StartTime time.Time `json:"start_time"`
- Uptime time.Duration `json:"uptime"`
- TotalConnections int64 `json:"total_connections"`
- ActiveConnections int64 `json:"active_connections"`
- SuccessfulRequests int64 `json:"successful_requests"`
- FailedRequests int64 `json:"failed_requests"`
- BytesSent int64 `json:"bytes_sent"`
- BytesReceived int64 `json:"bytes_received"`
- SOCKS5Errors map[string]int64 `json:"socks5_errors"`
-}
-
-// GetSuccessRate 获取成功率
-func (s *ProxyStatsSnapshot) GetSuccessRate() float64 {
- total := s.SuccessfulRequests + s.FailedRequests
- if total == 0 {
- return 0
- }
- return float64(s.SuccessfulRequests) / float64(total) * 100
-}
-
-// GetTotalBytes 获取总传输字节数
-func (s *ProxyStatsSnapshot) GetTotalBytes() int64 {
- return s.BytesSent + s.BytesReceived
-}
-
-// GetAverageConnectionsPerHour 获取每小时平均连接数
-func (s *ProxyStatsSnapshot) GetAverageConnectionsPerHour() float64 {
- hours := s.Uptime.Hours()
- if hours == 0 {
- return 0
- }
- return float64(s.TotalConnections) / hours
-}
-
-
-
package system
-
-import (
- "fmt"
- "os/exec"
- "runtime"
- "strings"
-
- "github.com/azoic/wormhole-client/pkg/logger"
-)
-
-// SystemProxyManager 系统代理管理器
-type SystemProxyManager struct {
- originalSettings map[string]string
-}
-
-// NewSystemProxyManager 创建系统代理管理器
-func NewSystemProxyManager() *SystemProxyManager {
- return &SystemProxyManager{
- originalSettings: make(map[string]string),
- }
-}
-
-// SetGlobalProxy 设置全局代理
-func (s *SystemProxyManager) SetGlobalProxy(httpProxy, httpsProxy, socksProxy string) error {
- switch runtime.GOOS {
- case "darwin":
- return s.setMacOSProxy(httpProxy, httpsProxy, socksProxy)
- case "windows":
- return s.setWindowsProxy(httpProxy, httpsProxy, socksProxy)
- case "linux":
- return s.setLinuxProxy(httpProxy, httpsProxy, socksProxy)
- default:
- return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
- }
-}
-
-// RestoreProxy 恢复原始代理设置
-func (s *SystemProxyManager) RestoreProxy() error {
- switch runtime.GOOS {
- case "darwin":
- return s.restoreMacOSProxy()
- case "windows":
- return s.restoreWindowsProxy()
- case "linux":
- return s.restoreLinuxProxy()
- default:
- return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
- }
-}
-
-// macOS 代理设置
-func (s *SystemProxyManager) setMacOSProxy(httpProxy, httpsProxy, socksProxy string) error {
- logger.Info("Setting macOS system proxy...")
-
- // 获取网络服务名称
- networkService, err := s.getMacOSNetworkService()
- if err != nil {
- return fmt.Errorf("failed to get network service: %v", err)
- }
-
- // 保存原始设置
- if err := s.saveMacOSOriginalSettings(networkService); err != nil {
- logger.Warn("Failed to save original proxy settings: %v", err)
- }
-
- // 设置HTTP代理
- if httpProxy != "" {
- if err := s.runCommand("networksetup", "-setwebproxy", networkService,
- s.parseProxyHost(httpProxy), s.parseProxyPort(httpProxy)); err != nil {
- return fmt.Errorf("failed to set HTTP proxy: %v", err)
- }
-
- if err := s.runCommand("networksetup", "-setwebproxystate", networkService, "on"); err != nil {
- return fmt.Errorf("failed to enable HTTP proxy: %v", err)
- }
- }
-
- // 设置HTTPS代理
- if httpsProxy != "" {
- if err := s.runCommand("networksetup", "-setsecurewebproxy", networkService,
- s.parseProxyHost(httpsProxy), s.parseProxyPort(httpsProxy)); err != nil {
- return fmt.Errorf("failed to set HTTPS proxy: %v", err)
- }
-
- if err := s.runCommand("networksetup", "-setsecurewebproxystate", networkService, "on"); err != nil {
- return fmt.Errorf("failed to enable HTTPS proxy: %v", err)
- }
- }
-
- // 设置SOCKS代理
- if socksProxy != "" {
- if err := s.runCommand("networksetup", "-setsocksfirewallproxy", networkService,
- s.parseProxyHost(socksProxy), s.parseProxyPort(socksProxy)); err != nil {
- return fmt.Errorf("failed to set SOCKS proxy: %v", err)
- }
-
- if err := s.runCommand("networksetup", "-setsocksfirewallproxystate", networkService, "on"); err != nil {
- return fmt.Errorf("failed to enable SOCKS proxy: %v", err)
- }
- }
-
- logger.Info("macOS system proxy configured successfully")
- return nil
-}
-
-// 获取macOS网络服务名称
-func (s *SystemProxyManager) getMacOSNetworkService() (string, error) {
- output, err := exec.Command("networksetup", "-listallnetworkservices").Output()
- if err != nil {
- return "", err
- }
-
- lines := strings.Split(string(output), "\n")
- for _, line := range lines {
- line = strings.TrimSpace(line)
- if line != "" && !strings.HasPrefix(line, "*") && !strings.Contains(line, "An asterisk") {
- // 优先选择Wi-Fi，否则选择第一个可用的服务
- if strings.Contains(strings.ToLower(line), "wi-fi") || strings.Contains(strings.ToLower(line), "wifi") {
- return line, nil
- }
- }
- }
-
- // 如果没找到Wi-Fi，返回第一个可用的服务
- for _, line := range lines {
- line = strings.TrimSpace(line)
- if line != "" && !strings.HasPrefix(line, "*") && !strings.Contains(line, "An asterisk") {
- return line, nil
- }
- }
-
- return "", fmt.Errorf("no network service found")
-}
-
-// 保存macOS原始代理设置
-func (s *SystemProxyManager) saveMacOSOriginalSettings(networkService string) error {
- // 保存HTTP代理状态
- if output, err := exec.Command("networksetup", "-getwebproxy", networkService).Output(); err == nil {
- s.originalSettings["http_proxy"] = string(output)
- }
-
- // 保存HTTPS代理状态
- if output, err := exec.Command("networksetup", "-getsecurewebproxy", networkService).Output(); err == nil {
- s.originalSettings["https_proxy"] = string(output)
- }
-
- // 保存SOCKS代理状态
- if output, err := exec.Command("networksetup", "-getsocksfirewallproxy", networkService).Output(); err == nil {
- s.originalSettings["socks_proxy"] = string(output)
- }
-
- s.originalSettings["network_service"] = networkService
- return nil
-}
-
-// 恢复macOS代理设置
-func (s *SystemProxyManager) restoreMacOSProxy() error {
- networkService, exists := s.originalSettings["network_service"]
- if !exists {
- return fmt.Errorf("no network service information saved")
- }
-
- logger.Info("Restoring macOS system proxy...")
-
- // 关闭所有代理
- s.runCommand("networksetup", "-setwebproxystate", networkService, "off")
- s.runCommand("networksetup", "-setsecurewebproxystate", networkService, "off")
- s.runCommand("networksetup", "-setsocksfirewallproxystate", networkService, "off")
-
- logger.Info("macOS system proxy restored")
- return nil
-}
-
-// Windows 代理设置（简化实现）
-func (s *SystemProxyManager) setWindowsProxy(httpProxy, httpsProxy, socksProxy string) error {
- logger.Warn("Windows proxy setting not fully implemented")
- return fmt.Errorf("Windows proxy setting not implemented yet")
-}
-
-func (s *SystemProxyManager) restoreWindowsProxy() error {
- logger.Warn("Windows proxy restoration not fully implemented")
- return nil
-}
-
-// Linux 代理设置（简化实现）
-func (s *SystemProxyManager) setLinuxProxy(httpProxy, httpsProxy, socksProxy string) error {
- logger.Warn("Linux proxy setting not fully implemented")
- return fmt.Errorf("Linux proxy setting not implemented yet")
-}
-
-func (s *SystemProxyManager) restoreLinuxProxy() error {
- logger.Warn("Linux proxy restoration not fully implemented")
- return nil
-}
-
-// 辅助函数
-func (s *SystemProxyManager) runCommand(name string, args ...string) error {
- cmd := exec.Command(name, args...)
- output, err := cmd.CombinedOutput()
- if err != nil {
- logger.Error("Command failed: %s %v, output: %s", name, args, string(output))
- return err
- }
- return nil
-}
-
-func (s *SystemProxyManager) parseProxyHost(proxy string) string {
- // 简单解析，格式: host:port
- parts := strings.Split(proxy, ":")
- if len(parts) >= 1 {
- return parts[0]
- }
- return proxy
-}
-
-func (s *SystemProxyManager) parseProxyPort(proxy string) string {
- // 简单解析，格式: host:port
- parts := strings.Split(proxy, ":")
- if len(parts) >= 2 {
- return parts[1]
- }
- return "8080" // 默认端口
-}
-
-
-
package dns
-
-import (
- "fmt"
- "net"
- "strings"
- "sync"
- "time"
-
- "github.com/azoic/wormhole-client/pkg/logger"
-)
-
-// DNSProxy DNS代理服务器
-type DNSProxy struct {
- upstreamDNS string
- localPort int
- server *net.UDPConn
- cache *dnsCache
- running bool
- mutex sync.RWMutex
-}
-
-// dnsCache DNS缓存
-type dnsCache struct {
- entries map[string]*cacheEntry
- mutex sync.RWMutex
-}
-
-type cacheEntry struct {
- response []byte
- expiry time.Time
-}
-
-// NewDNSProxy 创建DNS代理
-func NewDNSProxy(upstreamDNS string, localPort int) *DNSProxy {
- return &DNSProxy{
- upstreamDNS: upstreamDNS,
- localPort: localPort,
- cache: &dnsCache{
- entries: make(map[string]*cacheEntry),
- },
- }
-}
-
-// Start 启动DNS代理服务器
-func (d *DNSProxy) Start() error {
- d.mutex.Lock()
- defer d.mutex.Unlock()
-
- if d.running {
- return fmt.Errorf("DNS proxy is already running")
- }
-
- addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", d.localPort))
- if err != nil {
- return fmt.Errorf("failed to resolve UDP address: %v", err)
- }
-
- d.server, err = net.ListenUDP("udp", addr)
- if err != nil {
- return fmt.Errorf("failed to start DNS proxy server: %v", err)
- }
-
- d.running = true
- logger.Info("DNS proxy started on port %d", d.localPort)
-
- // 启动清理缓存的goroutine
- go d.cleanupCache()
-
- // 处理DNS请求
- go d.handleRequests()
-
- return nil
-}
-
-// Stop 停止DNS代理服务器
-func (d *DNSProxy) Stop() error {
- d.mutex.Lock()
- defer d.mutex.Unlock()
-
- if !d.running {
- return nil
- }
-
- d.running = false
- if d.server != nil {
- d.server.Close()
- }
-
- logger.Info("DNS proxy stopped")
- return nil
-}
-
-// handleRequests 处理DNS请求
-func (d *DNSProxy) handleRequests() {
- buffer := make([]byte, 512) // DNS消息最大512字节（UDP）
-
- for d.isRunning() {
- n, clientAddr, err := d.server.ReadFromUDP(buffer)
- if err != nil {
- if d.isRunning() {
- logger.Error("Failed to read DNS request: %v", err)
- }
- continue
- }
-
- go d.processRequest(buffer[:n], clientAddr)
- }
-}
-
-// processRequest 处理单个DNS请求
-func (d *DNSProxy) processRequest(request []byte, clientAddr *net.UDPAddr) {
- // 简单的DNS请求解析
- domain := d.extractDomain(request)
- logger.Debug("DNS request for domain: %s", domain)
-
- // 检查缓存
- if cachedResponse := d.getFromCache(domain); cachedResponse != nil {
- logger.Debug("Serving %s from cache", domain)
- d.server.WriteToUDP(cachedResponse, clientAddr)
- return
- }
-
- // 转发到上游DNS服务器
- response, err := d.forwardToUpstream(request)
- if err != nil {
- logger.Error("Failed to forward DNS request: %v", err)
- return
- }
-
- // 缓存响应
- d.addToCache(domain, response)
-
- // 返回响应给客户端
- d.server.WriteToUDP(response, clientAddr)
-}
-
-// extractDomain 从DNS请求中提取域名（简化实现）
-func (d *DNSProxy) extractDomain(request []byte) string {
- if len(request) < 12 {
- return ""
- }
-
- // 跳过DNS头部（12字节）
- offset := 12
- var domain strings.Builder
-
- for offset < len(request) {
- length := int(request[offset])
- if length == 0 {
- break
- }
-
- offset++
- if offset+length > len(request) {
- break
- }
-
- if domain.Len() > 0 {
- domain.WriteByte('.')
- }
- domain.Write(request[offset : offset+length])
- offset += length
- }
-
- return domain.String()
-}
-
-// forwardToUpstream 转发DNS请求到上游服务器
-func (d *DNSProxy) forwardToUpstream(request []byte) ([]byte, error) {
- conn, err := net.Dial("udp", d.upstreamDNS)
- if err != nil {
- return nil, fmt.Errorf("failed to connect to upstream DNS: %v", err)
- }
- defer conn.Close()
-
- // 设置超时
- conn.SetDeadline(time.Now().Add(5 * time.Second))
-
- // 发送请求
- if _, err := conn.Write(request); err != nil {
- return nil, fmt.Errorf("failed to send DNS request: %v", err)
- }
-
- // 读取响应
- response := make([]byte, 512)
- n, err := conn.Read(response)
- if err != nil {
- return nil, fmt.Errorf("failed to read DNS response: %v", err)
- }
-
- return response[:n], nil
-}
-
-// getFromCache 从缓存获取DNS响应
-func (d *DNSProxy) getFromCache(domain string) []byte {
- d.cache.mutex.RLock()
- defer d.cache.mutex.RUnlock()
-
- entry, exists := d.cache.entries[domain]
- if !exists || time.Now().After(entry.expiry) {
- return nil
- }
-
- return entry.response
-}
-
-// addToCache 添加DNS响应到缓存
-func (d *DNSProxy) addToCache(domain string, response []byte) {
- d.cache.mutex.Lock()
- defer d.cache.mutex.Unlock()
-
- // 设置缓存过期时间（5分钟）
- expiry := time.Now().Add(5 * time.Minute)
-
- d.cache.entries[domain] = &cacheEntry{
- response: make([]byte, len(response)),
- expiry: expiry,
- }
- copy(d.cache.entries[domain].response, response)
-}
-
-// cleanupCache 清理过期的缓存条目
-func (d *DNSProxy) cleanupCache() {
- ticker := time.NewTicker(1 * time.Minute)
- defer ticker.Stop()
-
- for {
- select {
- case <-ticker.C:
- if !d.isRunning() {
- return
- }
-
- d.cache.mutex.Lock()
- now := time.Now()
- for domain, entry := range d.cache.entries {
- if now.After(entry.expiry) {
- delete(d.cache.entries, domain)
- }
- }
- d.cache.mutex.Unlock()
- }
- }
-}
-
-// isRunning 检查DNS代理是否在运行
-func (d *DNSProxy) isRunning() bool {
- d.mutex.RLock()
- defer d.mutex.RUnlock()
- return d.running
-}
-
-
-
package logger
-
-import (
- "fmt"
- "log"
- "os"
- "strings"
- "time"
-)
-
-type LogLevel int
-
-const (
- DEBUG LogLevel = iota
- INFO
- WARN
- ERROR
-)
-
-type Logger struct {
- level LogLevel
- logger *log.Logger
-}
-
-var defaultLogger *Logger
-
-func init() {
- defaultLogger = New("INFO")
-}
-
-// New 创建新的日志记录器
-func New(levelStr string) *Logger {
- level := parseLogLevel(levelStr)
- logger := log.New(os.Stdout, "", 0)
-
- return &Logger{
- level: level,
- logger: logger,
- }
-}
-
-// SetLevel 设置日志级别
-func SetLevel(levelStr string) {
- defaultLogger.level = parseLogLevel(levelStr)
-}
-
-func parseLogLevel(levelStr string) LogLevel {
- switch strings.ToUpper(levelStr) {
- case "DEBUG":
- return DEBUG
- case "INFO":
- return INFO
- case "WARN", "WARNING":
- return WARN
- case "ERROR":
- return ERROR
- default:
- return INFO
- }
-}
-
-func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
- if level < l.level {
- return
- }
-
- levelStr := ""
- switch level {
- case DEBUG:
- levelStr = "DEBUG"
- case INFO:
- levelStr = "INFO"
- case WARN:
- levelStr = "WARN"
- case ERROR:
- levelStr = "ERROR"
- }
-
- timestamp := time.Now().Format("2006-01-02 15:04:05")
- message := fmt.Sprintf(format, args...)
- logLine := fmt.Sprintf("[%s] [%s] %s", timestamp, levelStr, message)
-
- l.logger.Println(logLine)
-}
-
-// Debug 调试日志
-func (l *Logger) Debug(format string, args ...interface{}) {
- l.log(DEBUG, format, args...)
-}
-
-// Info 信息日志
-func (l *Logger) Info(format string, args ...interface{}) {
- l.log(INFO, format, args...)
-}
-
-// Warn 警告日志
-func (l *Logger) Warn(format string, args ...interface{}) {
- l.log(WARN, format, args...)
-}
-
-// Error 错误日志
-func (l *Logger) Error(format string, args ...interface{}) {
- l.log(ERROR, format, args...)
-}
-
-// 全局日志函数
-func Debug(format string, args ...interface{}) {
- defaultLogger.Debug(format, args...)
-}
-
-func Info(format string, args ...interface{}) {
- defaultLogger.Info(format, args...)
-}
-
-func Warn(format string, args ...interface{}) {
- defaultLogger.Warn(format, args...)
-}
-
-func Error(format string, args ...interface{}) {
- defaultLogger.Error(format, args...)
-}
-
-
-