brook

package module
v0.0.0-...-8d2094c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 1, 2026 License: GPL-3.0 Imports: 49 Imported by: 33

README

Brook

A cross-platform programmable network tool.

Sponsor: Shiliew - A network app designed for those who value their time

Server

bash <(curl https://bash.ooo/nami.sh)

nami install brook

brook server -l :9999 -p hello

Client

You may want to use brook link to customize some parameters

Docs

https://www.txthinking.com/brook.html

https://brook.app

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ClientGate func(ex Exchanger) (Exchanger, error) = func(ex Exchanger) (Exchanger, error) {
	return ex, nil
}
View Source 
var ClientHKDFInfo = []byte{0x62, 0x72, 0x6f, 0x6f, 0x6b}
View Source 
var DHCPServerGate func(inmt string, in dhcp4.Packet, outmt string, ip net.IP, err error) = func(inmt string, in dhcp4.Packet, outmt string, ip net.IP, err error) {
}
View Source 
var DNSGate func(addr *net.UDPAddr, m *dns.Msg, l1 *net.UDPConn) (done bool, err error) = func(addr *net.UDPAddr, m *dns.Msg, l1 *net.UDPConn) (done bool, err error) {
	if m.Question[0].Qtype == dns.TypeHTTPS || m.Question[0].Qtype == dns.TypeSVCB {
		m1 := &dns.Msg{}
		m1.SetReply(m)
		m1.Authoritative = true
		m1.Answer = append(m1.Answer, &dns.SOA{
			Hdr:     dns.RR_Header{Name: m.Question[0].Name, Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 60},
			Ns:      "txthinking.com.",
			Mbox:    "cloud.txthinking.com.",
			Serial:  uint32((time.Now().Year() * 10000) + (int(time.Now().Month()) * 100) + (time.Now().Day())*100),
			Refresh: 21600,
			Retry:   3600,
			Expire:  259200,
			Minttl:  300,
		})
		m1b, err := m1.PackBuffer(nil)
		if err != nil {
			return false, err
		}
		if _, err := l1.WriteToUDP(m1b, addr); err != nil {
			return false, err
		}
		return true, nil
	}
	return false, nil
}
View Source 
var DOHGate func(m *dns.Msg, w http.ResponseWriter, r *http.Request) (done bool, err error) = func(m *dns.Msg, w http.ResponseWriter, r *http.Request) (done bool, err error) {
	if m.Question[0].Qtype == dns.TypeHTTPS || m.Question[0].Qtype == dns.TypeSVCB {
		m1 := &dns.Msg{}
		m1.SetReply(m)
		m1.Authoritative = true
		m1.Answer = append(m1.Answer, &dns.SOA{
			Hdr:     dns.RR_Header{Name: m.Question[0].Name, Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 60},
			Ns:      "txthinking.com.",
			Mbox:    "cloud.txthinking.com.",
			Serial:  uint32((time.Now().Year() * 10000) + (int(time.Now().Month()) * 100) + (time.Now().Day())*100),
			Refresh: 21600,
			Retry:   3600,
			Expire:  259200,
			Minttl:  300,
		})
		m1b, err := m1.PackBuffer(nil)
		if err != nil {
			return false, err
		}
		w.Header().Set("Content-Type", "application/dns-message")
		w.Write(m1b)
		return true, nil
	}
	return false, nil
}
View Source 
var DialTCP func(network string, laddr, raddr string) (net.Conn, error) = func(network string, laddr, raddr string) (net.Conn, error) {
	var la, ra *net.TCPAddr
	if laddr != "" {
		var err error
		la, err = net.ResolveTCPAddr(network, laddr)
		if err != nil {
			return nil, err
		}
	}
	a, err := Resolve(network, raddr)
	if err != nil {
		return nil, err
	}
	ra = a.(*net.TCPAddr)
	return net.DialTCP(network, la, ra)
}
View Source 
var DialUDP func(network string, laddr, raddr string) (net.Conn, error) = func(network string, laddr, raddr string) (net.Conn, error) {
	var la, ra *net.UDPAddr
	if laddr != "" {
		var err error
		la, err = net.ResolveUDPAddr(network, laddr)
		if err != nil {
			return nil, err
		}
	}
	a, err := Resolve(network, raddr)
	if err != nil {
		return nil, err
	}
	ra = a.(*net.UDPAddr)
	return net.DialUDP(network, la, ra)
}
View Source 
var ListenUDP func(network string, laddr *net.UDPAddr) (*net.UDPConn, error) = net.ListenUDP
View Source 
var Log func(err error) = func(err error) {
	log.Println(err)
}
View Source 
var NAT = &NATTable{
	Table: map[string]string{},
	Lock:  &sync.Mutex{},
}
View Source 
var NATDial func(network string, src, dst, addr string) (net.Conn, error) = func(network string, src, dst, addr string) (net.Conn, error) {
	s := NAT.Get(src, dst)
	var c net.Conn
	var err error
	if network == "tcp" {
		c, err = DialTCP(network, s, addr)
	}
	if network == "udp" {
		c, err = DialUDP(network, s, addr)
	}
	if err != nil {
		if !strings.Contains(err.Error(), "address already in use") && !strings.Contains(err.Error(), "assign requested address") {
			return nil, err
		}
		if network == "tcp" {
			c, err = DialTCP(network, "", addr)
		}
		if network == "udp" {
			c, err = DialUDP(network, "", addr)
		}
		s = ""
	}
	if err != nil {
		return nil, err
	}
	if s == "" {
		NAT.Set(src, dst, c.LocalAddr().String())
	}
	return c, nil
}
View Source 
var NATListenUDP func(network string, src, dst string) (*net.UDPConn, error) = func(network string, src, dst string) (*net.UDPConn, error) {
	var laddr *net.UDPAddr
	s := NAT.Get(src, dst)
	if s != "" {
		var err error
		laddr, err = net.ResolveUDPAddr("udp", s)
		if err != nil {
			return nil, err
		}
	}
	c, err := ListenUDP("udp", laddr)
	if err != nil {
		if !strings.Contains(err.Error(), "address already in use") && !strings.Contains(err.Error(), "assign requested address") {
			return nil, err
		}
		c, err = ListenUDP("udp", nil)
		s = ""
	}
	if err != nil {
		return nil, err
	}
	if s == "" {
		NAT.Set(src, dst, c.LocalAddr().String())
	}
	return c, nil
}
View Source 
var Resolve func(network string, addr string) (net.Addr, error) = func(network string, addr string) (net.Addr, error) {
	if network == "tcp" {
		return net.ResolveTCPAddr("tcp", addr)
	}
	return net.ResolveUDPAddr("udp", addr)
}
View Source 
var ServerGate func(ex Exchanger) (Exchanger, error) = func(ex Exchanger) (Exchanger, error) {
	return ex, nil
}
View Source 
var ServerHKDFInfo = []byte{0x62, 0x72, 0x6f, 0x6f, 0x6b}

Functions

func CAC 

func CAC(file string) ([]string, error)

TODO: make me more compatible with the shell environment. https://github.com/TxThinkingInc/CAC

func Conn2Conn 

func Conn2Conn(c, rc net.Conn, bufsize, timeout int)

func DHCPListen 

func DHCPListen(iface string) (net.PacketConn, error)

func EchoClient 

func EchoClient(server string, times int) error

func ErrorReply 

func ErrorReply(r *socks5.Request, c *net.TCPConn, e error) error

func GetAddressFromURL 

func GetAddressFromURL(s string) (string, error)
func Link(kind, server string, v url.Values) string

func ListHasDomain 

func ListHasDomain(ds map[string]byte, domain string, c *cache.Cache) bool

func ListHasIP 

func ListHasIP(c4, c6 []*net.IPNet, i net.IP, c *cache.Cache, geo []string) bool

func NextNonce 

func NextNonce(b []byte)
func ParseLink(link string) (kind, server string, v url.Values, err error)

func QUICDialTCP 

func QUICDialTCP(src, dst, addr string, tc *tls.Config, idleTime int) (net.Conn, error)

func QUICDialUDP 

func QUICDialUDP(src, dst, addr string, tc *tls.Config, idleTime int) (net.Conn, error)

func ReadCIDRList 

func ReadCIDRList(url string) ([]*net.IPNet, error)

func ReadData 

func ReadData(url string) ([]byte, error)

func ReadDomainList 

func ReadDomainList(url string) (map[string]byte, error)

func ReadList 

func ReadList(url string) ([]string, error)

func Resolve4 

func Resolve4(host string) (string, error)

func Resolve6 

func Resolve6(host string) (string, error)

func SHA256Bytes 

func SHA256Bytes(s []byte) ([]byte, error)

func Socks5Test 

func Socks5Test(s, u, p, domain, a, ds string) error

func WaitReadErr 

func WaitReadErr(conn net.Conn)

func WebSocketDial 

func WebSocketDial(src, dst, addr, host, path string, tc *tls.Config, timeout int, tlsfingerprint utls.ClientHelloID, fragmentMinLength, fragmentMaxLength, fragmentMinDelay, fragmentMaxDelay int64) (net.Conn, error)

Types 

type BrookLink struct {
	Kind              string
	Address           string
	Host              string
	Path              string
	Password          []byte
	V                 url.Values
	Tc                *tls.Config
	TLSFingerprint    utls.ClientHelloID
	FragmentMinLength int64
	FragmentMaxLength int64
	FragmentMinDelay  int64
	FragmentMaxDelay  int64

	S5         *socks5.Server
	Pcf        *PacketConnFactory
	TCPTimeout int
	UDPTimeout int
}
func NewBrookLink(link string) (*BrookLink, error)

func (*BrookLink) CreateExchanger 

func (blk *BrookLink) CreateExchanger(network, src string, dstb []byte, tcptimeout, udptimeout int) (Exchanger, net.Conn, error)

func (*BrookLink) ListenAndServe 

func (x *BrookLink) ListenAndServe() error

func (*BrookLink) PrepareSocks5Server 

func (x *BrookLink) PrepareSocks5Server(addr, ip string, tcptimeout, udptimeout int) error

func (*BrookLink) Shutdown 

func (x *BrookLink) Shutdown() error

func (*BrookLink) TCPHandle 

func (x *BrookLink) TCPHandle(s *socks5.Server, c *net.TCPConn, r *socks5.Request) error

func (*BrookLink) UDPHandle 

func (x *BrookLink) UDPHandle(s *socks5.Server, addr *net.UDPAddr, d *socks5.Datagram) error

type Client 

type Client struct {
	Server            *socks5.Server
	ServerAddress     string
	Password          []byte
	TCPTimeout        int
	UDPTimeout        int
	UDPOverTCP        bool
	PacketConnFactory *PacketConnFactory
}

func NewClient 

func NewClient(addr, ip, server, password string, tcpTimeout, udpTimeout int) (*Client, error)

func (*Client) ListenAndServe 

func (x *Client) ListenAndServe() error

func (*Client) Shutdown 

func (x *Client) Shutdown() error

func (*Client) TCPHandle 

func (x *Client) TCPHandle(s *socks5.Server, c *net.TCPConn, r *socks5.Request) error

func (*Client) UDPHandle 

func (x *Client) UDPHandle(s *socks5.Server, addr *net.UDPAddr, d *socks5.Datagram) error

type ConnFirst 

type ConnFirst struct {
	*net.UDPConn
	First []byte
}

func (*ConnFirst) Read 

func (c *ConnFirst) Read(b []byte) (int, error)

type DHCPServer 

type DHCPServer struct {
	Listen   net.PacketConn
	ServerIP net.IP
	Start    net.IP
	Count    int
	Leases   map[int]string
	Options  dhcp4.Options
	Cache    string
}

func NewDHCPServer 

func NewDHCPServer(iface, serverip, start, mask string, count int, gateway string, dnsserver []string, cache string) (*DHCPServer, error)

func (*DHCPServer) ListenAndServe 

func (h *DHCPServer) ListenAndServe() error

func (*DHCPServer) ServeDHCP 

func (h *DHCPServer) ServeDHCP(p dhcp4.Packet, msgType dhcp4.MessageType, options dhcp4.Options) (d dhcp4.Packet)

func (*DHCPServer) Shutdown 

func (h *DHCPServer) Shutdown() error

type DNSClient 

type DNSClient struct {
	Server string
}

func (*DNSClient) A 

func (c *DNSClient) A(domain string) (net.IP, error)

if no A, return nil

func (*DNSClient) AAAA 

func (c *DNSClient) AAAA(domain string) (net.IP, error)

if no AAAA, return nil

func (*DNSClient) Exchange 

func (c *DNSClient) Exchange(m *dns.Msg) (*dns.Msg, error)

type DOHClient 

type DOHClient struct {
	Client *http.Client
	DOH    string
}

func NewDOHClient 

func NewDOHClient(doh string) (*DOHClient, error)

func (*DOHClient) A 

func (c *DOHClient) A(domain string) (net.IP, error)

if no A, return nil

func (*DOHClient) AAAA 

func (c *DOHClient) AAAA(domain string) (net.IP, error)

if no AAAA, return nil

func (*DOHClient) Exchange 

func (c *DOHClient) Exchange(m *dns.Msg) (*dns.Msg, error)

type DOHServer 

type DOHServer struct {
	Addr       string
	Domain     string
	Path       string
	DNSClient  *DNSClient
	DOHClient  *DOHClient
	HTTPServer *http.Server
	Cert       []byte
	CertKey    []byte
}

func NewDOHServer 

func NewDOHServer(addr, domain, path, to string, tcpTimeout, udpTimeout int) (*DOHServer, error)

func (*DOHServer) ListenAndServe 

func (s *DOHServer) ListenAndServe() error

func (*DOHServer) ServeHTTP 

func (s *DOHServer) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*DOHServer) Shutdown 

func (s *DOHServer) Shutdown() error

type EchoServer 

type EchoServer struct {
	Addr        string
	RunnerGroup *runnergroup.RunnerGroup
}

func NewEchoServer 

func NewEchoServer(addr string) (*EchoServer, error)

func (*EchoServer) ListenAndServe 

func (s *EchoServer) ListenAndServe() error

func (*EchoServer) Shutdown 

func (s *EchoServer) Shutdown() error

func (*EchoServer) TCPHandle 

func (s *EchoServer) TCPHandle(c *net.TCPConn) error

func (*EchoServer) UDPHandle 

func (s *EchoServer) UDPHandle(addr *net.UDPAddr, b []byte, l1 *net.UDPConn) error

type Error 

type Error map[string]string

func (Error) Error 

func (e Error) Error() string

type Exchanger 

type Exchanger interface {
	Network() string
	Src() string
	Dst() string
	Exchange(remote net.Conn) error
	Clean()
}

func NewPacketClient 

func NewPacketClient(password []byte, src string, server net.Conn, timeout int, dstb []byte) (Exchanger, error)

func NewPacketServer 

func NewPacketServer(password []byte, src string, client net.Conn, timeout int, dstb []byte) (Exchanger, error)

func NewSimplePacketClient 

func NewSimplePacketClient(password []byte, src string, server net.Conn, timeout int, dst []byte) (Exchanger, error)

func NewSimplePacketServer 

func NewSimplePacketServer(password []byte, src string, client net.Conn, timeout int, dst []byte) (Exchanger, error)

func NewSimpleStreamClient 

func NewSimpleStreamClient(network string, password []byte, src string, server net.Conn, timeout int, dst []byte) (Exchanger, error)

func NewSimpleStreamServer 

func NewSimpleStreamServer(password []byte, src string, client net.Conn, timeout, udptimeout int) (Exchanger, error)

func NewStreamClient 

func NewStreamClient(network string, password []byte, src string, server net.Conn, timeout int, dst []byte) (Exchanger, error)

func NewStreamServer 

func NewStreamServer(password []byte, src string, client net.Conn, timeout, udptimeout int) (Exchanger, error)

type NATTable 

type NATTable struct {
	Table map[string]string
	Lock  *sync.Mutex
}

func (*NATTable) Get 

func (n *NATTable) Get(src, dst string) string

func (*NATTable) Reset 

func (n *NATTable) Reset()

func (*NATTable) Set 

func (n *NATTable) Set(src, dst, addr string)

type PAC 

type PAC struct {
	Addr       string
	File       string
	Proxy      string
	DomainURL  string
	DomainData []byte
	HTTPServer *http.Server
	Body       []byte
}

func NewPAC 

func NewPAC(addr, file, proxy, domainURL string) *PAC

func (*PAC) ListenAndServe 

func (p *PAC) ListenAndServe() error

func (*PAC) MakeBody 

func (p *PAC) MakeBody() (io.Reader, error)

func (*PAC) ServeHTTP 

func (p *PAC) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*PAC) Shutdown 

func (p *PAC) Shutdown() error

func (*PAC) WriteToFile 

func (p *PAC) WriteToFile() error

func (*PAC) WriteToStdout 

func (p *PAC) WriteToStdout() error

type PacketClient 

type PacketClient struct {
	Server   net.Conn
	Password []byte
	RB       []byte
	WB       []byte
	Timeout  int
	// contains filtered or unexported fields
}

func (*PacketClient) Clean 

func (s *PacketClient) Clean()

func (*PacketClient) Dst 

func (s *PacketClient) Dst() string

func (*PacketClient) Exchange 

func (c *PacketClient) Exchange(local net.Conn) error

func (*PacketClient) Network 

func (s *PacketClient) Network() string

func (*PacketClient) Src 

func (s *PacketClient) Src() string

type PacketConn 

type PacketConn struct {
	First   []byte
	InCh    chan []byte
	Done    chan byte
	W       func([]byte) (int, error)
	Clean   func()
	Timeout int
}

func NewPacketConn 

func NewPacketConn(fb []byte, w func([]byte) (int, error), timeout int, clean func()) *PacketConn

func (*PacketConn) Close 

func (c *PacketConn) Close() error

func (*PacketConn) In 

func (c *PacketConn) In(b []byte) error

func (*PacketConn) LocalAddr 

func (c *PacketConn) LocalAddr() net.Addr

func (*PacketConn) Read 

func (c *PacketConn) Read(b []byte) (int, error)

func (*PacketConn) RemoteAddr 

func (c *PacketConn) RemoteAddr() net.Addr

func (*PacketConn) SetDeadline 

func (c *PacketConn) SetDeadline(t time.Time) error

func (*PacketConn) SetReadDeadline 

func (c *PacketConn) SetReadDeadline(t time.Time) error

func (*PacketConn) SetWriteDeadline 

func (c *PacketConn) SetWriteDeadline(t time.Time) error

func (*PacketConn) Write 

func (c *PacketConn) Write(b []byte) (int, error)

type PacketConnFactory 

type PacketConnFactory struct {
	Conns map[string]*PacketConn
	Lock  *sync.Mutex
}

func NewPacketConnFactory 

func NewPacketConnFactory() *PacketConnFactory

func (*PacketConnFactory) Handle 

func (f *PacketConnFactory) Handle(addr *net.UDPAddr, dstb, data []byte, w func([]byte) (int, error), timeout int) (net.Conn, error)

type PacketServer 

type PacketServer struct {
	Client   net.Conn
	Password []byte
	RB       []byte
	WB       []byte
	Timeout  int
	// contains filtered or unexported fields
}

func (*PacketServer) Clean 

func (s *PacketServer) Clean()

func (*PacketServer) Dst 

func (s *PacketServer) Dst() string

func (*PacketServer) Exchange 

func (s *PacketServer) Exchange(remote net.Conn) error

func (*PacketServer) Network 

func (s *PacketServer) Network() string

func (*PacketServer) Src 

func (s *PacketServer) Src() string

type PacketServerConnFactory 

type PacketServerConnFactory struct {
	Conns map[string]*PacketConn
	Lock  *sync.Mutex
}

func NewPacketServerConnFactory 

func NewPacketServerConnFactory() *PacketServerConnFactory

func (*PacketServerConnFactory) Handle 

func (f *PacketServerConnFactory) Handle(addr *net.UDPAddr, b, p []byte, w func([]byte) (int, error), timeout int) (net.Conn, []byte, error)

type QUICClient 

type QUICClient struct {
	Server            *socks5.Server
	ServerHost        string
	ServerAddress     string
	TLSConfig         *tls.Config
	Password          []byte
	TCPTimeout        int
	UDPTimeout        int
	WithoutBrook      bool
	PacketConnFactory *PacketConnFactory
}

func NewQUICClient 

func NewQUICClient(addr, ip, server, password string, tcpTimeout, udpTimeout int, withoutbrook bool) (*QUICClient, error)

func (*QUICClient) ListenAndServe 

func (x *QUICClient) ListenAndServe() error

func (*QUICClient) Shutdown 

func (x *QUICClient) Shutdown() error

func (*QUICClient) TCPHandle 

func (x *QUICClient) TCPHandle(s *socks5.Server, c *net.TCPConn, r *socks5.Request) error

func (*QUICClient) UDPHandle 

func (x *QUICClient) UDPHandle(s *socks5.Server, addr *net.UDPAddr, d *socks5.Datagram) error

type QUICConn 

type QUICConn struct {
	UDPConn *net.UDPConn
	Conn    quic.Connection
	Stream  quic.Stream
	LAddr   net.Addr
	RAddr   net.Addr
}

func (*QUICConn) Close 

func (c *QUICConn) Close() error

func (*QUICConn) LocalAddr 

func (c *QUICConn) LocalAddr() net.Addr

func (*QUICConn) Read 

func (c *QUICConn) Read(b []byte) (int, error)

func (*QUICConn) RemoteAddr 

func (c *QUICConn) RemoteAddr() net.Addr

func (*QUICConn) SetDeadline 

func (c *QUICConn) SetDeadline(t time.Time) error

func (*QUICConn) SetReadDeadline 

func (c *QUICConn) SetReadDeadline(t time.Time) error

func (*QUICConn) SetWriteDeadline 

func (c *QUICConn) SetWriteDeadline(t time.Time) error

func (*QUICConn) Write 

func (c *QUICConn) Write(b []byte) (int, error)

type QUICServer 

type QUICServer struct {
	Password             []byte
	Domain               string
	Addr                 string
	TCPTimeout           int
	UDPTimeout           int
	Cert                 []byte
	CertKey              []byte
	RunnerGroup          *runnergroup.RunnerGroup
	WithoutBrook         bool
	UDPServerConnFactory UDPServerConnFactory
}

func NewQUICServer 

func NewQUICServer(addr, password, domain string, tcpTimeout, udpTimeout int, withoutbrook bool) (*QUICServer, error)

func (*QUICServer) ListenAndServe 

func (s *QUICServer) ListenAndServe() error

func (*QUICServer) Shutdown 

func (s *QUICServer) Shutdown() error

func (*QUICServer) TCPHandle 

func (s *QUICServer) TCPHandle(ss Exchanger) error

func (*QUICServer) UDPHandle 

func (s *QUICServer) UDPHandle(ss Exchanger) error

func (*QUICServer) UDPOverTCPHandle 

func (s *QUICServer) UDPOverTCPHandle(ss Exchanger) error

type Relay 

type Relay struct {
	From        string
	To          string
	Dstb        []byte
	TCPTimeout  int
	UDPTimeout  int
	Pcf         *PacketConnFactory
	RunnerGroup *runnergroup.RunnerGroup
	IsDNS       bool
}

func NewRelay 

func NewRelay(from, to string, tcpTimeout, udpTimeout int) (*Relay, error)

func (*Relay) ListenAndServe 

func (s *Relay) ListenAndServe() error

func (*Relay) Shutdown 

func (s *Relay) Shutdown() error

func (*Relay) TCPHandle 

func (s *Relay) TCPHandle(c *net.TCPConn) error

func (*Relay) UDPHandle 

func (s *Relay) UDPHandle(addr *net.UDPAddr, b []byte, l1 *net.UDPConn) error

type RelayOverBrook 

type RelayOverBrook struct {
	From string
	Link string

	TCPTimeout int
	UDPTimeout int

	RunnerGroup *runnergroup.RunnerGroup
	IsDNS       bool
	// contains filtered or unexported fields
}

func NewRelayOverBrook 

func NewRelayOverBrook(from, link, to string, tcpTimeout, udpTimeout int) (*RelayOverBrook, error)

func (*RelayOverBrook) ListenAndServe 

func (s *RelayOverBrook) ListenAndServe() error

func (*RelayOverBrook) Shutdown 

func (s *RelayOverBrook) Shutdown() error

func (*RelayOverBrook) TCPHandle 

func (s *RelayOverBrook) TCPHandle(c *net.TCPConn) error

func (*RelayOverBrook) UDPHandle 

func (s *RelayOverBrook) UDPHandle(addr *net.UDPAddr, b []byte, l1 *net.UDPConn) error

type Server 

type Server struct {
	Addr        string
	Password    []byte
	TCPTimeout  int
	UDPTimeout  int
	RunnerGroup *runnergroup.RunnerGroup
}

func NewServer 

func NewServer(addr, password string, tcpTimeout, udpTimeout int) (*Server, error)

func (*Server) ListenAndServe 

func (s *Server) ListenAndServe() error

func (*Server) Shutdown 

func (s *Server) Shutdown() error

func (*Server) TCPHandle 

func (s *Server) TCPHandle(ss Exchanger) error

func (*Server) UDPHandle 

func (s *Server) UDPHandle(ss Exchanger) error

func (*Server) UDPOverTCPHandle 

func (s *Server) UDPOverTCPHandle(ss Exchanger) error

type SimplePacketClient 

type SimplePacketClient struct {
	Server   net.Conn
	Password []byte
	RB       []byte
	WB       []byte
	Timeout  int
	// contains filtered or unexported fields
}

func (*SimplePacketClient) Clean 

func (s *SimplePacketClient) Clean()

func (*SimplePacketClient) Dst 

func (s *SimplePacketClient) Dst() string

func (*SimplePacketClient) Exchange 

func (c *SimplePacketClient) Exchange(local net.Conn) error

func (*SimplePacketClient) Network 

func (s *SimplePacketClient) Network() string

func (*SimplePacketClient) Src 

func (s *SimplePacketClient) Src() string

type SimplePacketServer 

type SimplePacketServer struct {
	Client   net.Conn
	Password []byte
	RB       []byte
	WB       []byte
	Timeout  int
	// contains filtered or unexported fields
}

func (*SimplePacketServer) Clean 

func (s *SimplePacketServer) Clean()

func (*SimplePacketServer) Dst 

func (s *SimplePacketServer) Dst() string

func (*SimplePacketServer) Exchange 

func (s *SimplePacketServer) Exchange(remote net.Conn) error

func (*SimplePacketServer) Network 

func (s *SimplePacketServer) Network() string

func (*SimplePacketServer) Src 

func (s *SimplePacketServer) Src() string

type SimplePacketServerConnFactory 

type SimplePacketServerConnFactory struct {
	Conns map[string]*PacketConn
	Lock  *sync.Mutex
}

func NewSimplePacketServerConnFactory 

func NewSimplePacketServerConnFactory() *SimplePacketServerConnFactory

func (*SimplePacketServerConnFactory) Handle 

func (f *SimplePacketServerConnFactory) Handle(addr *net.UDPAddr, b, p []byte, w func([]byte) (int, error), timeout int) (net.Conn, []byte, error)

type SimpleStreamClient 

type SimpleStreamClient struct {
	Server  net.Conn
	Timeout int
	RB      []byte
	WB      []byte
	// contains filtered or unexported fields
}

func (*SimpleStreamClient) Clean 

func (s *SimpleStreamClient) Clean()

func (*SimpleStreamClient) Dst 

func (s *SimpleStreamClient) Dst() string

func (*SimpleStreamClient) Exchange 

func (c *SimpleStreamClient) Exchange(local net.Conn) error

func (*SimpleStreamClient) Network 

func (s *SimpleStreamClient) Network() string

func (*SimpleStreamClient) Src 

func (s *SimpleStreamClient) Src() string

type SimpleStreamServer 

type SimpleStreamServer struct {
	Client  net.Conn
	Timeout int
	RB      []byte
	WB      []byte
	// contains filtered or unexported fields
}

func (*SimpleStreamServer) Clean 

func (s *SimpleStreamServer) Clean()

func (*SimpleStreamServer) Dst 

func (s *SimpleStreamServer) Dst() string

func (*SimpleStreamServer) Exchange 

func (s *SimpleStreamServer) Exchange(remote net.Conn) error

func (*SimpleStreamServer) Network 

func (s *SimpleStreamServer) Network() string

func (*SimpleStreamServer) Src 

func (s *SimpleStreamServer) Src() string

type Socks5Server 

type Socks5Server struct {
	Server *socks5.Server
}

func NewSocks5Server 

func NewSocks5Server(addr, ip, userName, password string, tcpTimeout, udpTimeout int) (*Socks5Server, error)

func (*Socks5Server) ListenAndServe 

func (x *Socks5Server) ListenAndServe() error

func (*Socks5Server) Shutdown 

func (x *Socks5Server) Shutdown() error

type Socks5ToHTTP 

type Socks5ToHTTP struct {
	Addr       string
	Dial       proxy.Dialer
	TCPTimeout int
	Listen     *net.TCPListener
}

func NewSocks5ToHTTP 

func NewSocks5ToHTTP(addr, socks5addr, socks5username, socks5password string, tcpTimeout int) (*Socks5ToHTTP, error)

func (*Socks5ToHTTP) Handle 

func (s *Socks5ToHTTP) Handle(c *net.TCPConn) error

func (*Socks5ToHTTP) ListenAndServe 

func (s *Socks5ToHTTP) ListenAndServe() error

func (*Socks5ToHTTP) Shutdown 

func (s *Socks5ToHTTP) Shutdown() error

type StreamClient 

type StreamClient struct {
	Server net.Conn

	RB      []byte
	WB      []byte
	Timeout int
	// contains filtered or unexported fields
}

func (*StreamClient) Clean 

func (c *StreamClient) Clean()

func (*StreamClient) Dst 

func (s *StreamClient) Dst() string

func (*StreamClient) Exchange 

func (c *StreamClient) Exchange(local net.Conn) error

func (*StreamClient) Network 

func (s *StreamClient) Network() string

func (*StreamClient) Read 

func (c *StreamClient) Read() (int, error)

func (*StreamClient) Src 

func (s *StreamClient) Src() string

func (*StreamClient) Write 

func (c *StreamClient) Write(l int) error

type StreamServer 

type StreamServer struct {
	Client net.Conn

	RB      []byte
	WB      []byte
	Timeout int
	// contains filtered or unexported fields
}

func (*StreamServer) Clean 

func (s *StreamServer) Clean()

func (*StreamServer) Dst 

func (s *StreamServer) Dst() string

func (*StreamServer) Exchange 

func (s *StreamServer) Exchange(remote net.Conn) error

func (*StreamServer) Network 

func (s *StreamServer) Network() string

func (*StreamServer) Read 

func (s *StreamServer) Read() (int, error)

func (*StreamServer) Src 

func (s *StreamServer) Src() string

func (*StreamServer) Write 

func (s *StreamServer) Write(l int) error

type TLSFragmentConn 

type TLSFragmentConn struct {
	net.Conn
	MinLength int64
	MaxLength int64
	MinDelay  int64
	MaxDelay  int64
	Buf       []byte
	L         int
	Finished  bool
}

func (*TLSFragmentConn) Write 

func (c *TLSFragmentConn) Write(b []byte) (int, error)

type UDPServerConnFactory 

type UDPServerConnFactory interface {
	Handle(addr *net.UDPAddr, b, p []byte, w func([]byte) (int, error), timeout int) (net.Conn, []byte, error)
}

type WSClient 

type WSClient struct {
	Server            *socks5.Server
	ServerHost        string
	ServerAddress     string
	TLSConfig         *tls.Config
	TLSFingerprint    utls.ClientHelloID
	Password          []byte
	TCPTimeout        int
	UDPTimeout        int
	Path              string
	WithoutBrook      bool
	PacketConnFactory *PacketConnFactory
}

func NewWSClient 

func NewWSClient(addr, ip, server, password string, tcpTimeout, udpTimeout int, withoutbrook bool) (*WSClient, error)

func (*WSClient) ListenAndServe 

func (x *WSClient) ListenAndServe() error

func (*WSClient) Shutdown 

func (x *WSClient) Shutdown() error

func (*WSClient) TCPHandle 

func (x *WSClient) TCPHandle(s *socks5.Server, c *net.TCPConn, r *socks5.Request) error

func (*WSClient) UDPHandle 

func (x *WSClient) UDPHandle(s *socks5.Server, addr *net.UDPAddr, d *socks5.Datagram) error

type WSServer 

type WSServer struct {
	Password      []byte
	Domain        string
	Addr          string
	HTTPServer    *http.Server
	TCPTimeout    int
	UDPTimeout    int
	Path          string
	Cert          []byte
	CertKey       []byte
	WithoutBrook  bool
	XForwardedFor bool
}

func NewWSServer 

func NewWSServer(addr, password, domain, path string, tcpTimeout, udpTimeout int, withoutbrook bool) (*WSServer, error)

func (*WSServer) ListenAndServe 

func (s *WSServer) ListenAndServe() error

func (*WSServer) ServeHTTP 

func (s *WSServer) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*WSServer) Shutdown 

func (s *WSServer) Shutdown() error

func (*WSServer) TCPHandle 

func (s *WSServer) TCPHandle(ss Exchanger) error

func (*WSServer) UDPHandle 

func (s *WSServer) UDPHandle(ss Exchanger) error

Source Files

View all Source files

Directories

Path Synopsis
cli
brook command
plugins
block
dialwithdns
dialwithip
dialwithnic
logger
pprof
prometheus
socks5dial
thedns

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.