You can do this if you need to

can use "golang.org/x/net/proxy" lib：

demo :

internal/server/server.go

import (
  "github.com/things-go/go-socks5"
  netProxy "golang.org/x/net/proxy"
)


func RunSocks5Proxy(opt *common.Options) {
	var recs []*logo.Receiver
	cli := logo.NewReceiver(os.Stderr, "")
	cli.Color = true
	cli.Level = logo.DEBUG
	recs = append(recs, cli)
	file, err := logo.Open(opt.Output)
	if err == nil {
		out := logo.NewReceiver(file, "")
		out.Format = "%s: %s"
		recs = append(recs, out)
	}
	handler = &Proxy{}
	handler.Options = opt
	log = logo.NewLogger(recs...)
	// use netProxy golang.org/x/net/proxy
	socksOpts := []socks5.Option{
		socks5.WithLogger(log),
		// set Dial func
		socks5.WithDial(func(ctx context.Context, net_, addr string) (net.Conn, error) {
			// get one socks proxy uri => socks5://xxxx
			uri := handler.getProxy()
			parse, err := url.Parse(uri)
			if err != nil {
				return nil, err
			}
			if parse.Host == "" {
				return nil, errors.New("socks5 address invalid")
			}
			// processing certification
			password, _ := parse.User.Password()
			auth := &netProxy.Auth{
				User:     parse.User.Username(),
				Password: password,
			}
			// get socks5 dialer
			dialer, err := netProxy.SOCKS5("tcp", parse.Host, auth, netProxy.Direct)
			if err != nil {
				return nil, err
			}
			log.Infof("proxy server: %v target addr: %v", parse.Host, addr)
			return dialer.Dial(net_, addr)
		}),
	}
	if opt.Auth != "" {
		splitN := strings.SplitN(opt.Auth, ":", 2)
		credentials := socks5.StaticCredentials(map[string]string{splitN[0]: splitN[1]})
		socksOpts = append(socksOpts, socks5.WithCredential(credentials))
		log.Infof("SockeAuth Uname:%v Pwd:%v", splitN[0], splitN[1])
	}
	// get socks5 server
	socks5Server := socks5.NewServer(socksOpts...)
	if opt.Watch {
		watcher, err := opt.ProxyManager.Watch()
		if err != nil {
			log.Fatal(err)
		}
		defer watcher.Close()
		go watch(watcher)
	}
	// maintain a healthy proxy pool ( I need it )
	go func() {
		healthyFunc := func() error {
			// 1. check socks proxy alive
			// Use checker.Do() => because checker.check cannot be used directly
			opt.Output = "pipe"
			r, w, err := os.Pipe()
			if err != nil {
				return err
			}
			opt.Result = w
			opt.Verbose = true
			checker.Do(opt)
			w.Close()
			buffer, err := io.ReadAll(r)
			if err != nil {
				return err
			}
			r.Close()
			handler.Options.ProxyManager.Proxies = strings.Split(string(buffer), "\n")
			// 2. clear other type proxy
			for _, proxy := range handler.Options.ProxyManager.Proxies {
				if !strings.Contains(proxy, "socks5") || strings.ReplaceAll(proxy, " ", "") == "" {
					handler.Options.ProxyManager.RemoveProxy(proxy)
				}
			}
			log.Infof("current proxy count: %d", handler.Options.ProxyManager.Count())
			return nil
		}
		for {
			err := healthyFunc()
			if err != nil {
				log.Error(err)
			}
			time.Sleep(30 * time.Minute)
		}
	}()
	log.Infof("%d proxies loaded", opt.ProxyManager.Count())
	log.Infof("[PID: %d] Starting proxy server on %s", os.Getpid(), opt.Address)
	if opt.Auth != "" {
		log.Infof("socks url: socks5://%v:%v", opt.Auth, opt.Address)
	} else {
		log.Infof("socks url: socks5://%v", opt.Address)
	}
	// start socks5 server
	err = socks5Server.ListenAndServe("tcp", opt.Address)
	if err != nil {
		log.Fatal(err)
	}
}

getProxy:

func (p *Proxy) getProxy() string {
	if p.currentProxy == "" || int(p.num) >= p.Options.Rotate {
		proxy, err := p.Options.ProxyManager.Rotate(p.Options.Method)
		if err != nil {
			log.Fatalf("Could not rotate proxy IP: %s", err)
		}
		p.mu.Lock()
		p.currentProxy = proxy
		p.num = 1
		p.mu.Unlock()
	} else {
		atomic.AddUint32(&p.num, 1)
	}
	return p.currentProxy
}

runner.New

func New(opt *common.Options) error {
	if opt.Address != "" {
		if opt.Daemon {
			return daemon.New(opt)
		}
		if opt.Socks {
			log.Println("start mubeng socks5 proxy server mode ...")
			server.RunSocks5Proxy(opt)
		} else {
			log.Println("start mubeng http proxy server mode ...")
			server.RunHTTPProxy(opt)
		}
	} else if opt.Check {
		checker.Do(opt)
		if opt.Output != "" {
			defer opt.Result.Close()
		}
	} else {
		return errors.New("no action to run")
	}
	return nil
}

[FEATURE] Socks5 Proxy Server for IP Rotation? #76

Description

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions