gost: github.com/ginuerzh/gost Index | Files

package gost

import "github.com/ginuerzh/gost"

Index

Package Files

auth.go bypass.go chain.go client.go forward.go gost.go handler.go hosts.go http.go http2.go kcp.go log.go mux.go node.go obfs.go permissions.go quic.go redirect.go reload.go resolver.go selector.go server.go signal_unix.go sni.go socks.go ss.go ss2.go ssh.go tls.go ws.go

Constants

const (
    DefaultMaxFails    = 1
    DefaultFailTimeout = 30 * time.Second
)

default options for FailFilter

const (
    // MethodTLS is an extended SOCKS5 method with tls encryption support.
    MethodTLS uint8 = 0x80
    // MethodTLSAuth is an extended SOCKS5 method with tls encryption and authentication support.
    MethodTLSAuth uint8 = 0x82
    // MethodMux is an extended SOCKS5 method for stream multiplexing.
    MethodMux = 0x88
)
const (
    // CmdMuxBind is an extended SOCKS5 request CMD for
    // multiplexing transport with the binding server.
    CmdMuxBind uint8 = 0xF2
    // CmdUDPTun is an extended SOCKS5 request CMD for UDP over TCP.
    CmdUDPTun uint8 = 0xF3
)
const (
    DirectForwardRequest       = "direct-tcpip"         // RFC 4254 7.2
    RemoteForwardRequest       = "tcpip-forward"        // RFC 4254 7.1
    ForwardedTCPReturnRequest  = "forwarded-tcpip"      // RFC 4254 7.2
    CancelRemoteForwardRequest = "cancel-tcpip-forward" // RFC 4254 7.1

    GostSSHTunnelRequest = "gost-tunnel" // extended request type for ssh tunnel
)

Applicable SSH Request types for Port Forwarding - RFC 4254 7.X

const Version = "2.8.1"

Version is the gost version.

Variables

var (
    // KeepAliveTime is the keep alive time period for TCP connection.
    KeepAliveTime = 180 * time.Second
    // DialTimeout is the timeout of dial.
    DialTimeout = 5 * time.Second
    // HandshakeTimeout is the timeout of handshake.
    HandshakeTimeout = 5 * time.Second
    // ConnectTimeout is the timeout for connect.
    ConnectTimeout = 5 * time.Second
    // ReadTimeout is the timeout for reading.
    ReadTimeout = 10 * time.Second
    // WriteTimeout is the timeout for writing.
    WriteTimeout = 10 * time.Second
    // PingTimeout is the timeout for pinging.
    PingTimeout = 30 * time.Second
    // PingRetries is the reties of ping.
    PingRetries = 1
)
var (
    // DefaultTLSConfig is a default TLS config for internal use.
    DefaultTLSConfig *tls.Config

    // DefaultUserAgent is the default HTTP User-Agent header used by HTTP and websocket.
    DefaultUserAgent = "Chrome/60.0.3112.90"
)
var Debug bool

Debug is a flag that enables the debug log.

var DefaultClient = &Client{Connector: HTTPConnector(nil), Transporter: TCPTransporter()}

DefaultClient is a standard HTTP proxy client.

var (
    // DefaultKCPConfig is the default KCP config.
    DefaultKCPConfig = KCPConfig{
        Key:          "it's a secrect",
        Crypt:        "aes",
        Mode:         "fast",
        MTU:          1350,
        SndWnd:       1024,
        RcvWnd:       1024,
        DataShard:    10,
        ParityShard:  3,
        DSCP:         0,
        NoComp:       false,
        AckNodelay:   false,
        NoDelay:      0,
        Interval:     50,
        Resend:       0,
        NoCongestion: 0,
        SockBuf:      4194304,
        KeepAlive:    10,
        SnmpLog:      "",
        SnmpPeriod:   60,
        Signal:       false,
    }
)
var (
    // DefaultResolverTimeout is the default timeout for name resolution.
    DefaultResolverTimeout = 5 * time.Second
)
var (
    // ErrEmptyChain is an error that implies the chain is empty.
    ErrEmptyChain = errors.New("empty chain")
)
var (
    // ErrInvalidNode is an error that implies the node is invalid.
    ErrInvalidNode = errors.New("invalid node")
)
var (
    // ErrNoneAvailable indicates there is no node available.
    ErrNoneAvailable = errors.New("none available")
)
var (
    // KCPSalt is the default salt for KCP cipher.
    KCPSalt = "kcp-go"
)

func Can Uses

func Can(action string, addr string, whitelist, blacklist *Permissions) bool

Can tests whether the given action and address is allowed by the whitelist and blacklist.

func Connect Uses

func Connect(conn net.Conn, addr string) (net.Conn, error)

Connect connects to the address addr via the DefaultClient.

func Dial Uses

func Dial(addr string, options ...DialOption) (net.Conn, error)

Dial connects to the address addr via the DefaultClient.

func GenCertificate Uses

func GenCertificate() (cert tls.Certificate, err error)

GenCertificate generates a random TLS certificate.

func Handshake Uses

func Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error)

Handshake performs a handshake via the DefaultClient.

func Obfs4Init Uses

func Obfs4Init(node Node, isServeNode bool) error

Obfs4Init initializes the obfs client or server based on isServeNode

func PeriodReload Uses

func PeriodReload(r Reloader, configFile string) error

PeriodReload reloads the config configFile periodically according to the period of the Reloader r.

func SetLogger Uses

func SetLogger(logger log.Logger)

SetLogger sets a new logger for internal log system.

type Accepter Uses

type Accepter interface {
    Accept() (net.Conn, error)
}

Accepter represents a network endpoint that can accept connection from peer.

type Authenticator Uses

type Authenticator interface {
    Authenticate(user, password string) bool
}

Authenticator is an interface for user authentication.

type Bypass Uses

type Bypass struct {
    // contains filtered or unexported fields
}

Bypass is a filter for address (IP or domain). It contains a list of matchers.

func NewBypass Uses

func NewBypass(reversed bool, matchers ...Matcher) *Bypass

NewBypass creates and initializes a new Bypass using matchers as its match rules. The rules will be reversed if the reversed is true.

func NewBypassPatterns Uses

func NewBypassPatterns(reversed bool, patterns ...string) *Bypass

NewBypassPatterns creates and initializes a new Bypass using matcher patterns as its match rules. The rules will be reversed if the reverse is true.

func (*Bypass) AddMatchers Uses

func (bp *Bypass) AddMatchers(matchers ...Matcher)

AddMatchers appends matchers to the bypass matcher list.

func (*Bypass) Contains Uses

func (bp *Bypass) Contains(addr string) bool

Contains reports whether the bypass includes addr.

func (*Bypass) Matchers Uses

func (bp *Bypass) Matchers() []Matcher

Matchers return the bypass matcher list.

func (*Bypass) Period Uses

func (bp *Bypass) Period() time.Duration

Period returns the reload period.

func (*Bypass) Reload Uses

func (bp *Bypass) Reload(r io.Reader) error

Reload parses config from r, then live reloads the bypass.

func (*Bypass) Reversed Uses

func (bp *Bypass) Reversed() bool

Reversed reports whether the rules of the bypass are reversed.

func (*Bypass) Stop Uses

func (bp *Bypass) Stop()

Stop stops reloading.

func (*Bypass) Stopped Uses

func (bp *Bypass) Stopped() bool

Stopped checks whether the reloader is stopped.

func (*Bypass) String Uses

func (bp *Bypass) String() string

type Chain Uses

type Chain struct {
    Retries int
    // contains filtered or unexported fields
}

Chain is a proxy chain that holds a list of proxy node groups.

func NewChain Uses

func NewChain(nodes ...Node) *Chain

NewChain creates a proxy chain with a list of proxy nodes. It creates the node groups automatically, one group per node.

func (*Chain) AddNode Uses

func (c *Chain) AddNode(nodes ...Node)

AddNode appends the node(s) to the chain.

func (*Chain) AddNodeGroup Uses

func (c *Chain) AddNodeGroup(groups ...*NodeGroup)

AddNodeGroup appends the group(s) to the chain.

func (*Chain) Conn Uses

func (c *Chain) Conn(opts ...ChainOption) (conn net.Conn, err error)

Conn obtains a handshaked connection to the last node of the chain.

func (*Chain) Dial Uses

func (c *Chain) Dial(addr string, opts ...ChainOption) (conn net.Conn, err error)

Dial connects to the target address addr through the chain. If the chain is empty, it will use the net.Dial directly.

func (*Chain) IsEmpty Uses

func (c *Chain) IsEmpty() bool

IsEmpty checks if the chain is empty. An empty chain means that there is no proxy node or node group in the chain.

func (*Chain) LastNode Uses

func (c *Chain) LastNode() Node

LastNode returns the last node of the node list. If the chain is empty, an empty node will be returned. If the last node is a node group, the first node in the group will be returned.

func (*Chain) LastNodeGroup Uses

func (c *Chain) LastNodeGroup() *NodeGroup

LastNodeGroup returns the last group of the group list.

func (*Chain) NodeGroups Uses

func (c *Chain) NodeGroups() []*NodeGroup

NodeGroups returns the list of node group.

func (*Chain) Nodes Uses

func (c *Chain) Nodes() (nodes []Node)

Nodes returns the proxy nodes that the chain holds. The first node in each group will be returned.

type ChainOption Uses

type ChainOption func(opts *ChainOptions)

ChainOption allows a common way to set chain options.

func HostsChainOption Uses

func HostsChainOption(hosts *Hosts) ChainOption

HostsChainOption specifies the hosts used by Chain.Dial.

func ResolverChainOption Uses

func ResolverChainOption(resolver Resolver) ChainOption

ResolverChainOption specifies the Resolver used by Chain.Dial.

func RetryChainOption Uses

func RetryChainOption(retries int) ChainOption

RetryChainOption specifies the times of retry used by Chain.Dial.

func TimeoutChainOption Uses

func TimeoutChainOption(timeout time.Duration) ChainOption

TimeoutChainOption specifies the timeout used by Chain.Dial.

type ChainOptions Uses

type ChainOptions struct {
    Retries  int
    Timeout  time.Duration
    Hosts    *Hosts
    Resolver Resolver
}

ChainOptions holds options for Chain.

type Client Uses

type Client struct {
    Connector   Connector
    Transporter Transporter
}

Client is a proxy client. A client is divided into two layers: connector and transporter. Connector is responsible for connecting to the destination address through this proxy. Transporter performs a handshake with this proxy.

func (*Client) Connect Uses

func (c *Client) Connect(conn net.Conn, addr string, options ...ConnectOption) (net.Conn, error)

Connect connects to the address addr via the proxy over connection conn.

func (*Client) Dial Uses

func (c *Client) Dial(addr string, options ...DialOption) (net.Conn, error)

Dial connects to the target address.

func (*Client) Handshake Uses

func (c *Client) Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error)

Handshake performs a handshake with the proxy over connection conn.

type ConnectOption Uses

type ConnectOption func(opts *ConnectOptions)

ConnectOption allows a common way to set ConnectOptions.

func AddrConnectOption Uses

func AddrConnectOption(addr string) ConnectOption

AddrConnectOption specifies the corresponding address of the target.

func SelectorConnectOption Uses

func SelectorConnectOption(s gosocks5.Selector) ConnectOption

SelectorConnectOption specifies the SOCKS5 client selector.

func TimeoutConnectOption Uses

func TimeoutConnectOption(timeout time.Duration) ConnectOption

TimeoutConnectOption specifies the timeout for connecting to target.

func UserAgentConnectOption Uses

func UserAgentConnectOption(ua string) ConnectOption

UserAgentConnectOption specifies the HTTP user-agent header.

func UserConnectOption Uses

func UserConnectOption(user *url.Userinfo) ConnectOption

UserConnectOption specifies the user info for authentication.

type ConnectOptions Uses

type ConnectOptions struct {
    Addr      string
    Timeout   time.Duration
    User      *url.Userinfo
    Selector  gosocks5.Selector
    UserAgent string
}

ConnectOptions describes the options for Connector.Connect.

type Connector Uses

type Connector interface {
    Connect(conn net.Conn, addr string, options ...ConnectOption) (net.Conn, error)
}

Connector is responsible for connecting to the destination address.

func ForwardConnector Uses

func ForwardConnector() Connector

ForwardConnector creates a Connector for data forward client.

func HTTP2Connector Uses

func HTTP2Connector(user *url.Userinfo) Connector

HTTP2Connector creates a Connector for HTTP2 proxy client. It accepts an optional auth info for HTTP Basic Authentication.

func HTTPConnector Uses

func HTTPConnector(user *url.Userinfo) Connector

HTTPConnector creates a Connector for HTTP proxy client. It accepts an optional auth info for HTTP Basic Authentication.

func SNIConnector Uses

func SNIConnector(host string) Connector

SNIConnector creates a Connector for SNI proxy client.

func SOCKS4AConnector Uses

func SOCKS4AConnector() Connector

SOCKS4AConnector creates a Connector for SOCKS4A proxy client.

func SOCKS4Connector Uses

func SOCKS4Connector() Connector

SOCKS4Connector creates a Connector for SOCKS4 proxy client.

func SOCKS5BindConnector Uses

func SOCKS5BindConnector(user *url.Userinfo) Connector

SOCKS5BindConnector creates a connector for SOCKS5 bind. It accepts an optional auth info for SOCKS5 Username/Password Authentication.

func SOCKS5Connector Uses

func SOCKS5Connector(user *url.Userinfo) Connector

SOCKS5Connector creates a connector for SOCKS5 proxy client. It accepts an optional auth info for SOCKS5 Username/Password Authentication.

func SOCKS5UDPConnector Uses

func SOCKS5UDPConnector(user *url.Userinfo) Connector

SOCKS5UDPConnector creates a connector for SOCKS5 UDP relay. It accepts an optional auth info for SOCKS5 Username/Password Authentication.

func SOCKS5UDPTunConnector Uses

func SOCKS5UDPTunConnector(user *url.Userinfo) Connector

SOCKS5UDPTunConnector creates a connector for SOCKS5 UDP-over-TCP relay. It accepts an optional auth info for SOCKS5 Username/Password Authentication.

func SSHDirectForwardConnector Uses

func SSHDirectForwardConnector() Connector

SSHDirectForwardConnector creates a Connector for SSH TCP direct port forwarding.

func SSHRemoteForwardConnector Uses

func SSHRemoteForwardConnector() Connector

SSHRemoteForwardConnector creates a Connector for SSH TCP remote port forwarding.

func Shadow2Connector Uses

func Shadow2Connector(cipher *url.Userinfo) Connector

Shadow2Connector creates a Connector for go-shadowsocks2 proxy client. It accepts a cipher info for shadowsocks data encryption/decryption. The cipher must not be nil.

func ShadowConnector Uses

func ShadowConnector(cipher *url.Userinfo) Connector

ShadowConnector creates a Connector for shadowsocks proxy client. It accepts a cipher info for shadowsocks data encryption/decryption. The cipher must not be nil.

func ShadowUDPConnector Uses

func ShadowUDPConnector(cipher *url.Userinfo) Connector

ShadowUDPConnector creates a Connector for shadowsocks UDP client. It accepts a cipher info for shadowsocks data encryption/decryption. The cipher must not be nil.

func Socks5MuxBindConnector Uses

func Socks5MuxBindConnector() Connector

Socks5MuxBindConnector creates a Connector for SOCKS5 multiplex bind client.

type DialOption Uses

type DialOption func(opts *DialOptions)

DialOption allows a common way to set DialOptions.

func ChainDialOption Uses

func ChainDialOption(chain *Chain) DialOption

ChainDialOption specifies a chain used by Transporter.Dial

func TimeoutDialOption Uses

func TimeoutDialOption(timeout time.Duration) DialOption

TimeoutDialOption specifies the timeout used by Transporter.Dial

type DialOptions Uses

type DialOptions struct {
    Timeout time.Duration
    Chain   *Chain
}

DialOptions describes the options for Transporter.Dial.

type Exchanger Uses

type Exchanger interface {
    Exchange(ctx context.Context, query *dns.Msg) (*dns.Msg, error)
}

Exchanger is an interface for DNS synchronous query.

type FIFOStrategy Uses

type FIFOStrategy struct{}

FIFOStrategy is a strategy for node selector. The node will be selected from first to last, and will stick to the selected node until it is failed.

func (*FIFOStrategy) Apply Uses

func (s *FIFOStrategy) Apply(nodes []Node) Node

Apply applies the fifo strategy for the nodes.

func (*FIFOStrategy) String Uses

func (s *FIFOStrategy) String() string

type FailFilter Uses

type FailFilter struct {
    MaxFails    int
    FailTimeout time.Duration
}

FailFilter filters the dead node. A node is marked as dead if its failed count is greater than MaxFails.

func (*FailFilter) Filter Uses

func (f *FailFilter) Filter(nodes []Node) []Node

Filter filters dead nodes.

func (*FailFilter) String Uses

func (f *FailFilter) String() string

type Filter Uses

type Filter interface {
    Filter([]Node) []Node
    String() string
}

Filter is used to filter a node during the selection process

type Handler Uses

type Handler interface {
    Init(options ...HandlerOption)
    Handle(net.Conn)
}

Handler is a proxy server handler

func AutoHandler Uses

func AutoHandler(opts ...HandlerOption) Handler

AutoHandler creates a server Handler for auto proxy server.

func HTTP2Handler Uses

func HTTP2Handler(opts ...HandlerOption) Handler

HTTP2Handler creates a server Handler for HTTP2 proxy server.

func HTTPHandler Uses

func HTTPHandler(opts ...HandlerOption) Handler

HTTPHandler creates a server Handler for HTTP proxy server.

func SNIHandler Uses

func SNIHandler(opts ...HandlerOption) Handler

SNIHandler creates a server Handler for SNI proxy server.

func SOCKS4Handler Uses

func SOCKS4Handler(opts ...HandlerOption) Handler

SOCKS4Handler creates a server Handler for SOCKS4(A) proxy server.

func SOCKS5Handler Uses

func SOCKS5Handler(opts ...HandlerOption) Handler

SOCKS5Handler creates a server Handler for SOCKS5 proxy server.

func SSHForwardHandler Uses

func SSHForwardHandler(opts ...HandlerOption) Handler

SSHForwardHandler creates a server Handler for SSH port forwarding server.

func Shadow2Handler Uses

func Shadow2Handler(opts ...HandlerOption) Handler

Shadow2Handler creates a server Handler for go-shadowsocks2 proxy server.

func ShadowHandler Uses

func ShadowHandler(opts ...HandlerOption) Handler

ShadowHandler creates a server Handler for shadowsocks proxy server.

func ShadowUDPdHandler Uses

func ShadowUDPdHandler(opts ...HandlerOption) Handler

ShadowUDPdHandler creates a server Handler for shadowsocks UDP relay server.

func TCPDirectForwardHandler Uses

func TCPDirectForwardHandler(raddr string, opts ...HandlerOption) Handler

TCPDirectForwardHandler creates a server Handler for TCP port forwarding server. The raddr is the remote address that the server will forward to. NOTE: as of 2.6, remote address can be a comma-separated address list.

func TCPRedirectHandler Uses

func TCPRedirectHandler(opts ...HandlerOption) Handler

TCPRedirectHandler creates a server Handler for TCP redirect server.

func TCPRemoteForwardHandler Uses

func TCPRemoteForwardHandler(raddr string, opts ...HandlerOption) Handler

TCPRemoteForwardHandler creates a server Handler for TCP remote port forwarding server. The raddr is the remote address that the server will forward to. NOTE: as of 2.6, remote address can be a comma-separated address list.

func UDPDirectForwardHandler Uses

func UDPDirectForwardHandler(raddr string, opts ...HandlerOption) Handler

UDPDirectForwardHandler creates a server Handler for UDP port forwarding server. The raddr is the remote address that the server will forward to. NOTE: as of 2.6, remote address can be a comma-separated address list.

func UDPRemoteForwardHandler Uses

func UDPRemoteForwardHandler(raddr string, opts ...HandlerOption) Handler

UDPRemoteForwardHandler creates a server Handler for UDP remote port forwarding server. The raddr is the remote address that the server will forward to. NOTE: as of 2.6, remote address can be a comma-separated address list.

type HandlerOption Uses

type HandlerOption func(opts *HandlerOptions)

HandlerOption allows a common way to set handler options.

func AddrHandlerOption Uses

func AddrHandlerOption(addr string) HandlerOption

AddrHandlerOption sets the Addr option of HandlerOptions.

func AuthenticatorHandlerOption Uses

func AuthenticatorHandlerOption(au Authenticator) HandlerOption

AuthenticatorHandlerOption sets the Authenticator option of HandlerOptions.

func BlacklistHandlerOption Uses

func BlacklistHandlerOption(blacklist *Permissions) HandlerOption

BlacklistHandlerOption sets the Blacklist option of HandlerOptions.

func BypassHandlerOption Uses

func BypassHandlerOption(bypass *Bypass) HandlerOption

BypassHandlerOption sets the bypass option of HandlerOptions.

func ChainHandlerOption Uses

func ChainHandlerOption(chain *Chain) HandlerOption

ChainHandlerOption sets the Chain option of HandlerOptions.

func FailTimeoutHandlerOption Uses

func FailTimeoutHandlerOption(d time.Duration) HandlerOption

FailTimeoutHandlerOption sets the fail_timeout option of HandlerOptions.

func HostHandlerOption Uses

func HostHandlerOption(host string) HandlerOption

HostHandlerOption sets the target host for SNI proxy.

func HostsHandlerOption Uses

func HostsHandlerOption(hosts *Hosts) HandlerOption

HostsHandlerOption sets the Hosts option of HandlerOptions.

func IPsHandlerOption Uses

func IPsHandlerOption(ips []string) HandlerOption

IPsHandlerOption sets the ip list for port forward.

func KnockingHandlerOption Uses

func KnockingHandlerOption(host string) HandlerOption

KnockingHandlerOption adds the knocking host for probe resistance.

func MaxFailsHandlerOption Uses

func MaxFailsHandlerOption(n int) HandlerOption

MaxFailsHandlerOption sets the max_fails option of HandlerOptions.

func NodeHandlerOption Uses

func NodeHandlerOption(node Node) HandlerOption

NodeHandlerOption set the server node for server handler.

func ProbeResistHandlerOption Uses

func ProbeResistHandlerOption(pr string) HandlerOption

ProbeResistHandlerOption adds the probe resistance for HTTP proxy.

func ResolverHandlerOption Uses

func ResolverHandlerOption(resolver Resolver) HandlerOption

ResolverHandlerOption sets the resolver option of HandlerOptions.

func RetryHandlerOption Uses

func RetryHandlerOption(retries int) HandlerOption

RetryHandlerOption sets the retry option of HandlerOptions.

func StrategyHandlerOption Uses

func StrategyHandlerOption(strategy Strategy) HandlerOption

StrategyHandlerOption sets the strategy option of HandlerOptions.

func TLSConfigHandlerOption Uses

func TLSConfigHandlerOption(config *tls.Config) HandlerOption

TLSConfigHandlerOption sets the TLSConfig option of HandlerOptions.

func TimeoutHandlerOption Uses

func TimeoutHandlerOption(timeout time.Duration) HandlerOption

TimeoutHandlerOption sets the timeout option of HandlerOptions.

func UsersHandlerOption Uses

func UsersHandlerOption(users ...*url.Userinfo) HandlerOption

UsersHandlerOption sets the Users option of HandlerOptions.

func WhitelistHandlerOption Uses

func WhitelistHandlerOption(whitelist *Permissions) HandlerOption

WhitelistHandlerOption sets the Whitelist option of HandlerOptions.

type HandlerOptions Uses

type HandlerOptions struct {
    Addr          string
    Chain         *Chain
    Users         []*url.Userinfo
    Authenticator Authenticator
    TLSConfig     *tls.Config
    Whitelist     *Permissions
    Blacklist     *Permissions
    Strategy      Strategy
    MaxFails      int
    FailTimeout   time.Duration
    Bypass        *Bypass
    Retries       int
    Timeout       time.Duration
    Resolver      Resolver
    Hosts         *Hosts
    ProbeResist   string
    KnockingHost  string
    Node          Node
    Host          string
    IPs           []string
}

HandlerOptions describes the options for Handler.

type HandshakeOption Uses

type HandshakeOption func(opts *HandshakeOptions)

HandshakeOption allows a common way to set HandshakeOptions.

func AddrHandshakeOption Uses

func AddrHandshakeOption(addr string) HandshakeOption

AddrHandshakeOption specifies the server address

func HostHandshakeOption Uses

func HostHandshakeOption(host string) HandshakeOption

HostHandshakeOption specifies the hostname

func IntervalHandshakeOption Uses

func IntervalHandshakeOption(interval time.Duration) HandshakeOption

IntervalHandshakeOption specifies the interval time used by Transporter.Handshake

func KCPConfigHandshakeOption Uses

func KCPConfigHandshakeOption(config *KCPConfig) HandshakeOption

KCPConfigHandshakeOption specifies the KCP config used by KCP handshake

func QUICConfigHandshakeOption Uses

func QUICConfigHandshakeOption(config *QUICConfig) HandshakeOption

QUICConfigHandshakeOption specifies the QUIC config used by QUIC handshake

func RetryHandshakeOption Uses

func RetryHandshakeOption(retry int) HandshakeOption

RetryHandshakeOption specifies the times of retry used by Transporter.Handshake

func TLSConfigHandshakeOption Uses

func TLSConfigHandshakeOption(config *tls.Config) HandshakeOption

TLSConfigHandshakeOption specifies the TLS config used by Transporter.Handshake

func TimeoutHandshakeOption Uses

func TimeoutHandshakeOption(timeout time.Duration) HandshakeOption

TimeoutHandshakeOption specifies the timeout used by Transporter.Handshake

func UserHandshakeOption Uses

func UserHandshakeOption(user *url.Userinfo) HandshakeOption

UserHandshakeOption specifies the user used by Transporter.Handshake

func WSOptionsHandshakeOption Uses

func WSOptionsHandshakeOption(options *WSOptions) HandshakeOption

WSOptionsHandshakeOption specifies the websocket options used by websocket handshake

type HandshakeOptions Uses

type HandshakeOptions struct {
    Addr       string
    Host       string
    User       *url.Userinfo
    Timeout    time.Duration
    Interval   time.Duration
    Retry      int
    TLSConfig  *tls.Config
    WSOptions  *WSOptions
    KCPConfig  *KCPConfig
    QUICConfig *QUICConfig
}

HandshakeOptions describes the options for handshake.

type Host Uses

type Host struct {
    IP       net.IP
    Hostname string
    Aliases  []string
}

Host is a static mapping from hostname to IP.

func NewHost Uses

func NewHost(ip net.IP, hostname string, aliases ...string) Host

NewHost creates a Host.

type Hosts Uses

type Hosts struct {
    // contains filtered or unexported fields
}

Hosts is a static table lookup for hostnames. For each host a single line should be present with the following information: IP_address canonical_hostname [aliases...] Fields of the entry are separated by any number of blanks and/or tab characters. Text from a "#" character until the end of the line is a comment, and is ignored.

func NewHosts Uses

func NewHosts(hosts ...Host) *Hosts

NewHosts creates a Hosts with optional list of hosts.

func (*Hosts) AddHost Uses

func (h *Hosts) AddHost(host ...Host)

AddHost adds host(s) to the host table.

func (*Hosts) Lookup Uses

func (h *Hosts) Lookup(host string) (ip net.IP)

Lookup searches the IP address corresponds to the given host from the host table.

func (*Hosts) Period Uses

func (h *Hosts) Period() time.Duration

Period returns the reload period

func (*Hosts) Reload Uses

func (h *Hosts) Reload(r io.Reader) error

Reload parses config from r, then live reloads the hosts.

func (*Hosts) Stop Uses

func (h *Hosts) Stop()

Stop stops reloading.

func (*Hosts) Stopped Uses

func (h *Hosts) Stopped() bool

Stopped checks whether the reloader is stopped.

type InvalidFilter Uses

type InvalidFilter struct{}

InvalidFilter filters the invalid node. A node is invalid if its port is invalid (negative or zero value).

func (*InvalidFilter) Filter Uses

func (f *InvalidFilter) Filter(nodes []Node) []Node

Filter filters invalid nodes.

func (*InvalidFilter) String Uses

func (f *InvalidFilter) String() string

type KCPConfig Uses

type KCPConfig struct {
    Key          string `json:"key"`
    Crypt        string `json:"crypt"`
    Mode         string `json:"mode"`
    MTU          int    `json:"mtu"`
    SndWnd       int    `json:"sndwnd"`
    RcvWnd       int    `json:"rcvwnd"`
    DataShard    int    `json:"datashard"`
    ParityShard  int    `json:"parityshard"`
    DSCP         int    `json:"dscp"`
    NoComp       bool   `json:"nocomp"`
    AckNodelay   bool   `json:"acknodelay"`
    NoDelay      int    `json:"nodelay"`
    Interval     int    `json:"interval"`
    Resend       int    `json:"resend"`
    NoCongestion int    `json:"nc"`
    SockBuf      int    `json:"sockbuf"`
    KeepAlive    int    `json:"keepalive"`
    SnmpLog      string `json:"snmplog"`
    SnmpPeriod   int    `json:"snmpperiod"`
    Signal       bool   `json:"signal"` // Signal enables the signal SIGUSR1 feature.
}

KCPConfig describes the config for KCP.

func (*KCPConfig) Init Uses

func (c *KCPConfig) Init()

Init initializes the KCP config.

type Listener Uses

type Listener interface {
    net.Listener
}

Listener is a proxy server listener, just like a net.Listener.

func H2CListener Uses

func H2CListener(addr string) (Listener, error)

H2CListener creates a Listener for HTTP2 h2c tunnel server.

func H2Listener Uses

func H2Listener(addr string, config *tls.Config) (Listener, error)

H2Listener creates a Listener for HTTP2 h2 tunnel server.

func HTTP2Listener Uses

func HTTP2Listener(addr string, config *tls.Config) (Listener, error)

HTTP2Listener creates a Listener for HTTP2 proxy server.

func KCPListener Uses

func KCPListener(addr string, config *KCPConfig) (Listener, error)

KCPListener creates a Listener for KCP proxy server.

func MTLSListener Uses

func MTLSListener(addr string, config *tls.Config) (Listener, error)

MTLSListener creates a Listener for multiplex-TLS proxy server.

func MWSListener Uses

func MWSListener(addr string, options *WSOptions) (Listener, error)

MWSListener creates a Listener for multiplex-websocket proxy server.

func MWSSListener Uses

func MWSSListener(addr string, tlsConfig *tls.Config, options *WSOptions) (Listener, error)

MWSSListener creates a Listener for multiplex-websocket secure proxy server.

func Obfs4Listener Uses

func Obfs4Listener(addr string) (Listener, error)

Obfs4Listener creates a Listener for obfs4 server.

func ObfsHTTPListener Uses

func ObfsHTTPListener(addr string) (Listener, error)

ObfsHTTPListener creates a Listener for HTTP obfuscating tunnel server.

func QUICListener Uses

func QUICListener(addr string, config *QUICConfig) (Listener, error)

QUICListener creates a Listener for QUIC proxy server.

func SSHTunnelListener Uses

func SSHTunnelListener(addr string, config *SSHConfig) (Listener, error)

SSHTunnelListener creates a Listener for SSH tunnel server.

func ShadowUDPListener Uses

func ShadowUDPListener(addr string, cipher *url.Userinfo, ttl time.Duration) (Listener, error)

ShadowUDPListener creates a Listener for shadowsocks UDP relay server.

func TCPListener Uses

func TCPListener(addr string) (Listener, error)

TCPListener creates a Listener for TCP proxy server.

func TCPRemoteForwardListener Uses

func TCPRemoteForwardListener(addr string, chain *Chain) (Listener, error)

TCPRemoteForwardListener creates a Listener for TCP remote port forwarding server.

func TLSListener Uses

func TLSListener(addr string, config *tls.Config) (Listener, error)

TLSListener creates a Listener for TLS proxy server.

func UDPDirectForwardListener Uses

func UDPDirectForwardListener(addr string, ttl time.Duration) (Listener, error)

UDPDirectForwardListener creates a Listener for UDP port forwarding server.

func UDPRemoteForwardListener Uses

func UDPRemoteForwardListener(addr string, chain *Chain, ttl time.Duration) (Listener, error)

UDPRemoteForwardListener creates a Listener for UDP remote port forwarding server.

func WSListener Uses

func WSListener(addr string, options *WSOptions) (Listener, error)

WSListener creates a Listener for websocket proxy server.

func WSSListener Uses

func WSSListener(addr string, tlsConfig *tls.Config, options *WSOptions) (Listener, error)

WSSListener creates a Listener for websocket secure proxy server.

type LocalAuthenticator Uses

type LocalAuthenticator struct {
    // contains filtered or unexported fields
}

LocalAuthenticator is an Authenticator that authenticates client by local key-value pairs.

func NewLocalAuthenticator Uses

func NewLocalAuthenticator(kvs map[string]string) *LocalAuthenticator

NewLocalAuthenticator creates an Authenticator that authenticates client by local infos.

func (*LocalAuthenticator) Add Uses

func (au *LocalAuthenticator) Add(k, v string)

Add adds a key-value pair to the Authenticator.

func (*LocalAuthenticator) Authenticate Uses

func (au *LocalAuthenticator) Authenticate(user, password string) bool

Authenticate checks the validity of the provided user-password pair.

func (*LocalAuthenticator) Period Uses

func (au *LocalAuthenticator) Period() time.Duration

Period returns the reload period.

func (*LocalAuthenticator) Reload Uses

func (au *LocalAuthenticator) Reload(r io.Reader) error

Reload parses config from r, then live reloads the Authenticator.

func (*LocalAuthenticator) Stop Uses

func (au *LocalAuthenticator) Stop()

Stop stops reloading.

func (*LocalAuthenticator) Stopped Uses

func (au *LocalAuthenticator) Stopped() bool

Stopped checks whether the reloader is stopped.

type LogLogger Uses

type LogLogger struct {
}

LogLogger uses the standard log package as the logger

func (*LogLogger) Log Uses

func (l *LogLogger) Log(v ...interface{})

Log uses the standard log library log.Output

func (*LogLogger) Logf Uses

func (l *LogLogger) Logf(format string, v ...interface{})

Logf uses the standard log library log.Output

type Matcher Uses

type Matcher interface {
    Match(v string) bool
    String() string
}

Matcher is a generic pattern matcher, it gives the match result of the given pattern for specific v.

func CIDRMatcher Uses

func CIDRMatcher(inet *net.IPNet) Matcher

CIDRMatcher creates a Matcher for a specific CIDR notation IP address.

func DomainMatcher Uses

func DomainMatcher(pattern string) Matcher

DomainMatcher creates a Matcher for a specific domain pattern, the pattern can be a plain domain such as 'example.com', a wildcard such as '*.exmaple.com' or a special wildcard '.example.com'.

func IPMatcher Uses

func IPMatcher(ip net.IP) Matcher

IPMatcher creates a Matcher for a specific IP address.

func NewMatcher Uses

func NewMatcher(pattern string) Matcher

NewMatcher creates a Matcher for the given pattern. The acutal Matcher depends on the pattern: IP Matcher if pattern is a valid IP address. CIDR Matcher if pattern is a valid CIDR address. Domain Matcher if both of the above are not.

type NameServer Uses

type NameServer struct {
    Addr     string
    Protocol string
    Hostname string // for TLS handshake verification
    Timeout  time.Duration
    // contains filtered or unexported fields
}

NameServer is a name server. Currently supported protocol: TCP, UDP and TLS.

func (*NameServer) Init Uses

func (ns *NameServer) Init() error

Init initializes the name server.

func (NameServer) String Uses

func (ns NameServer) String() string

type Node Uses

type Node struct {
    ID        int
    Addr      string
    Host      string
    Protocol  string
    Transport string
    Remote    string // remote address, used by tcp/udp port forwarding

    User             *url.Userinfo
    Values           url.Values
    DialOptions      []DialOption
    HandshakeOptions []HandshakeOption
    ConnectOptions   []ConnectOption
    Client           *Client

    Bypass *Bypass
    // contains filtered or unexported fields
}

Node is a proxy node, mainly used to construct a proxy chain.

func ParseNode Uses

func ParseNode(s string) (node Node, err error)

ParseNode parses the node info. The proxy node string pattern is [scheme://][user:pass@host]:port. Scheme can be divided into two parts by character '+', such as: http+tls.

func (*Node) Clone Uses

func (node *Node) Clone() Node

Clone clones the node, it will prevent data race.

func (*Node) Get Uses

func (node *Node) Get(key string) string

Get returns node parameter specified by key.

func (*Node) GetBool Uses

func (node *Node) GetBool(key string) bool

GetBool converts node parameter value to bool.

func (*Node) GetDuration Uses

func (node *Node) GetDuration(key string) time.Duration

GetDuration converts node parameter value to time.Duration.

func (*Node) GetInt Uses

func (node *Node) GetInt(key string) int

GetInt converts node parameter value to int.

func (*Node) MarkDead Uses

func (node *Node) MarkDead()

MarkDead marks the node fail status.

func (*Node) ResetDead Uses

func (node *Node) ResetDead()

ResetDead resets the node fail status.

func (Node) String Uses

func (node Node) String() string

type NodeGroup Uses

type NodeGroup struct {
    ID int
    // contains filtered or unexported fields
}

NodeGroup is a group of nodes.

func NewNodeGroup Uses

func NewNodeGroup(nodes ...Node) *NodeGroup

NewNodeGroup creates a node group

func (*NodeGroup) AddNode Uses

func (group *NodeGroup) AddNode(node ...Node)

AddNode appends node or node list into group node.

func (*NodeGroup) GetNode Uses

func (group *NodeGroup) GetNode(i int) Node

GetNode returns the node specified by index in the group.

func (*NodeGroup) Next Uses

func (group *NodeGroup) Next() (node Node, err error)

Next selects a node from group. It also selects IP if the IP list exists.

func (*NodeGroup) Nodes Uses

func (group *NodeGroup) Nodes() []Node

Nodes returns the node list in the group

func (*NodeGroup) SetNodes Uses

func (group *NodeGroup) SetNodes(nodes ...Node) []Node

SetNodes replaces the group nodes to the specified nodes, and returns the previous nodes.

func (*NodeGroup) SetSelector Uses

func (group *NodeGroup) SetSelector(selector NodeSelector, opts ...SelectOption)

SetSelector sets node selector with options for the group.

type NodeSelector Uses

type NodeSelector interface {
    Select(nodes []Node, opts ...SelectOption) (Node, error)
}

NodeSelector as a mechanism to pick nodes and mark their status.

type NopLogger Uses

type NopLogger struct {
}

NopLogger is a dummy logger that discards the log outputs

func (*NopLogger) Log Uses

func (l *NopLogger) Log(v ...interface{})

Log does nothing

func (*NopLogger) Logf Uses

func (l *NopLogger) Logf(format string, v ...interface{})

Logf does nothing

type PasswordCallbackFunc Uses

type PasswordCallbackFunc func(conn ssh.ConnMetadata, password []byte) (*ssh.Permissions, error)

PasswordCallbackFunc is a callback function used by SSH server.

type Permission Uses

type Permission struct {
    Actions StringSet
    Hosts   StringSet
    Ports   PortSet
}

Permission is a rule for blacklist and whitelist.

type Permissions Uses

type Permissions []Permission

Permissions is a set of Permission.

func ParsePermissions Uses

func ParsePermissions(s string) (*Permissions, error)

ParsePermissions parses the s to a Permissions.

func (*Permissions) Can Uses

func (ps *Permissions) Can(action string, host string, port int) bool

Can tests whether the given action and host:port is allowed by this Permissions.

type PortRange Uses

type PortRange struct {
    Min, Max int
}

PortRange specifies the range of port, such as 1000-2000.

func ParsePortRange Uses

func ParsePortRange(s string) (*PortRange, error)

ParsePortRange parses the s to a PortRange. The s may be a '*' means 0-65535.

func (*PortRange) Contains Uses

func (ir *PortRange) Contains(value int) bool

Contains checks whether the value is within this range.

type PortSet Uses

type PortSet []PortRange

PortSet is a set of PortRange

func ParsePortSet Uses

func ParsePortSet(s string) (*PortSet, error)

ParsePortSet parses the s to a PortSet. The s shoud be a comma separated string.

func (*PortSet) Contains Uses

func (ps *PortSet) Contains(value int) bool

Contains checks whether the value is within this port set.

type QUICConfig Uses

type QUICConfig struct {
    TLSConfig   *tls.Config
    Timeout     time.Duration
    KeepAlive   bool
    IdleTimeout time.Duration
    Key         []byte
}

QUICConfig is the config for QUIC client and server

type RandomStrategy Uses

type RandomStrategy struct {
    Seed int64
    // contains filtered or unexported fields
}

RandomStrategy is a strategy for node selector. The node will be selected randomly.

func (*RandomStrategy) Apply Uses

func (s *RandomStrategy) Apply(nodes []Node) Node

Apply applies the random strategy for the nodes.

func (*RandomStrategy) String Uses

func (s *RandomStrategy) String() string

type ReloadResolver Uses

type ReloadResolver interface {
    Resolver
    Reloader
    Stoppable
}

ReloadResolver is resolover that support live reloading.

func NewResolver Uses

func NewResolver(ttl time.Duration, servers ...NameServer) ReloadResolver

NewResolver create a new Resolver with the given name servers and resolution timeout.

type Reloader Uses

type Reloader interface {
    Reload(r io.Reader) error
    Period() time.Duration
}

Reloader is the interface for objects that support live reloading.

type Resolver Uses

type Resolver interface {
    // Resolve returns a slice of that host's IPv4 and IPv6 addresses.
    Resolve(host string) ([]net.IP, error)
}

Resolver is a name resolver for domain name. It contains a list of name servers.

type RoundStrategy Uses

type RoundStrategy struct {
    // contains filtered or unexported fields
}

RoundStrategy is a strategy for node selector. The node will be selected by round-robin algorithm.

func (*RoundStrategy) Apply Uses

func (s *RoundStrategy) Apply(nodes []Node) Node

Apply applies the round-robin strategy for the nodes.

func (*RoundStrategy) String Uses

func (s *RoundStrategy) String() string

type SSHConfig Uses

type SSHConfig struct {
    Authenticator Authenticator
    TLSConfig     *tls.Config
}

SSHConfig holds the SSH tunnel server config

type SelectOption Uses

type SelectOption func(*SelectOptions)

SelectOption is the option used when making a select call.

func WithFilter Uses

func WithFilter(f ...Filter) SelectOption

WithFilter adds a filter function to the list of filters used during the Select call.

func WithStrategy Uses

func WithStrategy(s Strategy) SelectOption

WithStrategy sets the selector strategy

type SelectOptions Uses

type SelectOptions struct {
    Filters  []Filter
    Strategy Strategy
}

SelectOptions is the options for node selection.

type Server Uses

type Server struct {
    Listener Listener
    Handler  Handler
    // contains filtered or unexported fields
}

Server is a proxy server.

func (*Server) Addr Uses

func (s *Server) Addr() net.Addr

Addr returns the address of the server

func (*Server) Close Uses

func (s *Server) Close() error

Close closes the server

func (*Server) Init Uses

func (s *Server) Init(opts ...ServerOption)

Init intializes server with given options.

func (*Server) Run Uses

func (s *Server) Run() error

Run starts to serve.

func (*Server) Serve Uses

func (s *Server) Serve(h Handler, opts ...ServerOption) error

Serve serves as a proxy server.

type ServerOption Uses

type ServerOption func(opts *ServerOptions)

ServerOption allows a common way to set server options.

type ServerOptions Uses

type ServerOptions struct {
}

ServerOptions holds the options for Server.

type Stoppable Uses

type Stoppable interface {
    Stop()
    Stopped() bool
}

Stoppable is the interface that indicates a Reloader can be stopped.

type Strategy Uses

type Strategy interface {
    Apply([]Node) Node
    String() string
}

Strategy is a selection strategy e.g random, round-robin.

func NewStrategy Uses

func NewStrategy(s string) Strategy

NewStrategy creates a Strategy by the name s.

type StringSet Uses

type StringSet []string

StringSet is a set of string.

func ParseStringSet Uses

func ParseStringSet(s string) (*StringSet, error)

ParseStringSet parses the s to a StringSet. The s shoud be a comma separated string.

func (*StringSet) Contains Uses

func (ss *StringSet) Contains(subj string) bool

Contains checks whether the string subj within this StringSet.

type Transporter Uses

type Transporter interface {
    Dial(addr string, options ...DialOption) (net.Conn, error)
    Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error)
    // Indicate that the Transporter supports multiplex
    Multiplex() bool
}

Transporter is responsible for handshaking with the proxy server.

func H2CTransporter Uses

func H2CTransporter() Transporter

H2CTransporter creates a Transporter that is used by HTTP2 h2c tunnel client.

func H2Transporter Uses

func H2Transporter(config *tls.Config) Transporter

H2Transporter creates a Transporter that is used by HTTP2 h2 tunnel client.

func HTTP2Transporter Uses

func HTTP2Transporter(config *tls.Config) Transporter

HTTP2Transporter creates a Transporter that is used by HTTP2 h2 proxy client.

func KCPTransporter Uses

func KCPTransporter(config *KCPConfig) Transporter

KCPTransporter creates a Transporter that is used by KCP proxy client.

func MTLSTransporter Uses

func MTLSTransporter() Transporter

MTLSTransporter creates a Transporter that is used by multiplex-TLS proxy client.

func MWSSTransporter Uses

func MWSSTransporter(opts *WSOptions) Transporter

MWSSTransporter creates a Transporter that is used by multiplex-websocket secure proxy client.

func MWSTransporter Uses

func MWSTransporter(opts *WSOptions) Transporter

MWSTransporter creates a Transporter that is used by multiplex-websocket proxy client.

func Obfs4Transporter Uses

func Obfs4Transporter() Transporter

Obfs4Transporter creates a Transporter that is used by obfs4 client.

func ObfsHTTPTransporter Uses

func ObfsHTTPTransporter() Transporter

ObfsHTTPTransporter creates a Transporter that is used by HTTP obfuscating tunnel client.

func QUICTransporter Uses

func QUICTransporter(config *QUICConfig) Transporter

QUICTransporter creates a Transporter that is used by QUIC proxy client.

func SOCKS5MuxBindTransporter Uses

func SOCKS5MuxBindTransporter(bindAddr string) Transporter

SOCKS5MuxBindTransporter creates a Transporter for SOCKS5 multiplex bind client.

func SSHForwardTransporter Uses

func SSHForwardTransporter() Transporter

SSHForwardTransporter creates a Transporter that is used by SSH port forwarding server.

func SSHTunnelTransporter Uses

func SSHTunnelTransporter() Transporter

SSHTunnelTransporter creates a Transporter that is used by SSH tunnel client.

func TCPTransporter Uses

func TCPTransporter() Transporter

TCPTransporter creates a raw TCP client.

func TLSTransporter Uses

func TLSTransporter() Transporter

TLSTransporter creates a Transporter that is used by TLS proxy client.

func UDPTransporter Uses

func UDPTransporter() Transporter

UDPTransporter creates a raw UDP client.

func WSSTransporter Uses

func WSSTransporter(opts *WSOptions) Transporter

WSSTransporter creates a Transporter that is used by websocket secure proxy client.

func WSTransporter Uses

func WSTransporter(opts *WSOptions) Transporter

WSTransporter creates a Transporter that is used by websocket proxy client.

type WSOptions Uses

type WSOptions struct {
    ReadBufferSize    int
    WriteBufferSize   int
    HandshakeTimeout  time.Duration
    EnableCompression bool
    UserAgent         string
    Path              string
}

WSOptions describes the options for websocket.

Package gost imports 55 packages (graph) and is imported by 1 packages. Updated 2019-11-30. Refresh now. Tools for package owners.