socks5: github.com/txthinking/socks5 Index | Examples | Files

package socks5

import "github.com/txthinking/socks5"

Index

Examples

Package Files

bind.go client.go client_side.go connect.go init.go server.go server_side.go socks5.go udp.go util.go

Constants

const (
    // Ver is socks protocol version
    Ver byte = 0x05

    // MethodNone is none method
    MethodNone byte = 0x00
    // MethodGSSAPI is gssapi method
    MethodGSSAPI byte = 0x01 // MUST support // todo
    // MethodUsernamePassword is username/assword auth method
    MethodUsernamePassword byte = 0x02 // SHOULD support
    // MethodUnsupportAll means unsupport all given methods
    MethodUnsupportAll byte = 0xFF

    // UserPassVer is username/password auth protocol version
    UserPassVer byte = 0x01
    // UserPassStatusSuccess is success status of username/password auth
    UserPassStatusSuccess byte = 0x00
    // UserPassStatusFailure is failure status of username/password auth
    UserPassStatusFailure byte = 0x01 // just other than 0x00

    // CmdConnect is connect command
    CmdConnect byte = 0x01
    // CmdBind is bind command
    CmdBind byte = 0x02
    // CmdUDP is UDP command
    CmdUDP byte = 0x03

    // ATYPIPv4 is ipv4 address type
    ATYPIPv4 byte = 0x01 // 4 octets
    // ATYPDomain is domain address type
    ATYPDomain byte = 0x03 // The first octet of the address field contains the number of octets of name that follow, there is no terminating NUL octet.
    // ATYPIPv6 is ipv6 address type
    ATYPIPv6 byte = 0x04 // 16 octets

    // RepSuccess means that success for repling
    RepSuccess byte = 0x00
    // RepServerFailure means the server failure
    RepServerFailure byte = 0x01
    // RepNotAllowed means the request not allowed
    RepNotAllowed byte = 0x02
    // RepNetworkUnreachable means the network unreachable
    RepNetworkUnreachable byte = 0x03
    // RepHostUnreachable means the host unreachable
    RepHostUnreachable byte = 0x04
    // RepConnectionRefused means the connection refused
    RepConnectionRefused byte = 0x05
    // RepTTLExpired means the TTL expired
    RepTTLExpired byte = 0x06
    // RepCommandNotSupported means the request command not supported
    RepCommandNotSupported byte = 0x07
    // RepAddressNotSupported means the request address not supported
    RepAddressNotSupported byte = 0x08
)

Variables

var (
    // ErrUnsupportCmd is the error when got unsupport command
    ErrUnsupportCmd = errors.New("Unsupport Command")
    // ErrUserPassAuth is the error when got invalid username or password
    ErrUserPassAuth = errors.New("Invalid Username or Password for Auth")
)
var (
    // ErrVersion is version error
    ErrVersion = errors.New("Invalid Version")
    // ErrUserPassVersion is username/password auth version error
    ErrUserPassVersion = errors.New("Invalid Version of Username Password Auth")
    // ErrBadRequest is bad request error
    ErrBadRequest = errors.New("Bad Request")
)
var Debug bool

Debug enable debug log

var Dial x.Dialer = x.DefaultDial
var (
    // ErrBadReply is the error when read reply
    ErrBadReply = errors.New("Bad Reply")
)

func ParseAddress Uses

func ParseAddress(address string) (a byte, addr []byte, port []byte, err error)

ParseAddress format address x.x.x.x:xx to raw address. addr contains domain length

func ToAddress Uses

func ToAddress(a byte, addr []byte, port []byte) string

ToAddress format raw address to x.x.x.x:xx addr contains domain length

type Client Uses

type Client struct {
    Server        string
    UserName      string
    Password      string
    TCPConn       *net.TCPConn
    UDPConn       *net.UDPConn
    RemoteAddress net.Addr
    TCPDeadline   int
    TCPTimeout    int
    UDPDeadline   int
}

Client is socks5 client wrapper

Code:

c, err := socks5.NewClient("127.0.0.1:1080", "", "", 60, 0, 60)
if err != nil {
    panic(err)
}
client := &http.Client{
    Transport: &http.Transport{
        Dial: func(network, addr string) (net.Conn, error) {
            return c.Dial(network, addr)
        },
    },
}
res, err := client.Get("https://ifconfig.co")
if err != nil {
    panic(err)
}
defer res.Body.Close()
b, err := ioutil.ReadAll(res.Body)
if err != nil {
    panic(err)
}
log.Println(string(b))
// #Output:

Code:

c, err := socks5.NewClient("127.0.0.1:1080", "", "", 60, 0, 60)
if err != nil {
    panic(err)
}
conn, err := c.Dial("udp", "8.8.8.8:53")
if err != nil {
    panic(err)
}
b, err := hex.DecodeString("0001010000010000000000000a74787468696e6b696e6703636f6d0000010001")
if err != nil {
    panic(err)
}
if _, err := conn.Write(b); err != nil {
    panic(err)
}
b = make([]byte, 2048)
n, err := conn.Read(b)
if err != nil {
    panic(err)
}
b = b[:n]
b = b[len(b)-4:]
log.Println(net.IPv4(b[0], b[1], b[2], b[3]))
// #Output:

func NewClient Uses

func NewClient(addr, username, password string, tcpTimeout, tcpDeadline, udpDeadline int) (*Client, error)

This is just create a client, you need to use Dial to create conn

func (*Client) Close Uses

func (c *Client) Close() error

func (*Client) Dial Uses

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

func (*Client) LocalAddr Uses

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

func (*Client) Negotiate Uses

func (c *Client) Negotiate() error

func (*Client) Read Uses

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

func (*Client) RemoteAddr Uses

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

func (*Client) Request Uses

func (c *Client) Request(r *Request) (*Reply, error)

func (*Client) SetDeadline Uses

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

func (*Client) SetReadDeadline Uses

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

func (*Client) SetWriteDeadline Uses

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

func (*Client) Write Uses

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

type Datagram Uses

type Datagram struct {
    Rsv     []byte // 0x00 0x00
    Frag    byte
    Atyp    byte
    DstAddr []byte
    DstPort []byte // 2 bytes
    Data    []byte
}

Datagram is the UDP packet

func NewDatagram Uses

func NewDatagram(atyp byte, dstaddr []byte, dstport []byte, data []byte) *Datagram

NewDatagram return datagram packet can be writed into client, dstaddr should not have domain length

func NewDatagramFromBytes Uses

func NewDatagramFromBytes(bb []byte) (*Datagram, error)

func (*Datagram) Address Uses

func (d *Datagram) Address() string

Address return datagram address like ip:xx

func (*Datagram) Bytes Uses

func (d *Datagram) Bytes() []byte

Bytes return []byte

type DefaultHandle Uses

type DefaultHandle struct {
}

DefaultHandle implements Handler interface

func (*DefaultHandle) TCPHandle Uses

func (h *DefaultHandle) TCPHandle(s *Server, c *net.TCPConn, r *Request) error

TCPHandle auto handle request. You may prefer to do yourself.

func (*DefaultHandle) UDPHandle Uses

func (h *DefaultHandle) UDPHandle(s *Server, addr *net.UDPAddr, d *Datagram) error

UDPHandle auto handle packet. You may prefer to do yourself.

type Handler Uses

type Handler interface {
    // Request has not been replied yet
    TCPHandle(*Server, *net.TCPConn, *Request) error
    UDPHandle(*Server, *net.UDPAddr, *Datagram) error
}

Handler handle tcp, udp request

type NegotiationReply Uses

type NegotiationReply struct {
    Ver    byte
    Method byte
}

NegotiationReply is the negotiation reply packet

func NewNegotiationReply Uses

func NewNegotiationReply(method byte) *NegotiationReply

NewNegotiationReply return negotiation reply packet can be writed into client

func NewNegotiationReplyFrom Uses

func NewNegotiationReplyFrom(r io.Reader) (*NegotiationReply, error)

NewNegotiationReplyFrom read negotiation reply packet from server

func (*NegotiationReply) WriteTo Uses

func (r *NegotiationReply) WriteTo(w io.Writer) (int64, error)

WriteTo write negotiation reply packet into client

type NegotiationRequest Uses

type NegotiationRequest struct {
    Ver      byte
    NMethods byte
    Methods  []byte // 1-255 bytes
}

NegotiationRequest is the negotiation reqeust packet

func NewNegotiationRequest Uses

func NewNegotiationRequest(methods []byte) *NegotiationRequest

NewNegotiationRequest return negotiation request packet can be writed into server

func NewNegotiationRequestFrom Uses

func NewNegotiationRequestFrom(r io.Reader) (*NegotiationRequest, error)

NewNegotiationRequestFrom read negotiation requst packet from client

func (*NegotiationRequest) WriteTo Uses

func (r *NegotiationRequest) WriteTo(w io.Writer) (int64, error)

WriteTo write negotiation request packet into server

type Reply Uses

type Reply struct {
    Ver  byte
    Rep  byte
    Rsv  byte // 0x00
    Atyp byte
    // CONNECT socks server's address which used to connect to dst addr
    // BIND ...
    // UDP socks server's address which used to connect to dst addr
    BndAddr []byte
    // CONNECT socks server's port which used to connect to dst addr
    // BIND ...
    // UDP socks server's port which used to connect to dst addr
    BndPort []byte // 2 bytes
}

Reply is the reply packet

func NewReply Uses

func NewReply(rep byte, atyp byte, bndaddr []byte, bndport []byte) *Reply

NewReply return reply packet can be writed into client, bndaddr should not have domain length

func NewReplyFrom Uses

func NewReplyFrom(r io.Reader) (*Reply, error)

NewReplyFrom read reply packet from server

func (*Reply) Address Uses

func (r *Reply) Address() string

Address return request address like ip:xx

func (*Reply) WriteTo Uses

func (r *Reply) WriteTo(w io.Writer) (int64, error)

WriteTo write reply packet into client

type Request Uses

type Request struct {
    Ver     byte
    Cmd     byte
    Rsv     byte // 0x00
    Atyp    byte
    DstAddr []byte
    DstPort []byte // 2 bytes
}

Request is the request packet

func NewRequest Uses

func NewRequest(cmd byte, atyp byte, dstaddr []byte, dstport []byte) *Request

NewRequest return request packet can be writed into server, dstaddr should not have domain length

func NewRequestFrom Uses

func NewRequestFrom(r io.Reader) (*Request, error)

NewRequestFrom read requst packet from client

func (*Request) Address Uses

func (r *Request) Address() string

Address return request address like ip:xx

func (*Request) Connect Uses

func (r *Request) Connect(c *net.TCPConn) (*net.TCPConn, error)

Connect remote conn which u want to connect with your dialer Error or OK both replied.

func (*Request) UDP Uses

func (r *Request) UDP(c *net.TCPConn, serverAddr *net.UDPAddr) (*net.UDPAddr, error)

UDP remote conn which u want to connect with your dialer. Error or OK both replied. Addr can be used to associate TCP connection with the coming UDP connection, so we can close the TCP connection when UDP connection closed. If client send 0.0.0.0:0 address, alternative solution is set fixed time on TCP connection.

func (*Request) WriteTo Uses

func (r *Request) WriteTo(w io.Writer) (int64, error)

WriteTo write request packet into server

type Server Uses

type Server struct {
    UserName          string
    Password          string
    Method            byte
    SupportedCommands []byte
    TCPAddr           *net.TCPAddr
    UDPAddr           *net.UDPAddr
    ServerAddr        *net.UDPAddr
    TCPListen         *net.TCPListener
    UDPConn           *net.UDPConn
    UDPExchanges      *cache.Cache
    TCPDeadline       int
    TCPTimeout        int
    UDPDeadline       int
    UDPSessionTime    int // If client does't send address, use this fixed time
    Handle            Handler
    TCPUDPAssociate   *cache.Cache
    RunnerGroup       *runnergroup.RunnerGroup
}

Server is socks5 server wrapper

Code:

s, err := socks5.NewClassicServer("127.0.0.1:1080", "127.0.0.1", "", "", 60, 0, 60, 60)
if err != nil {
    panic(err)
}
// You can pass in custom Handler
s.ListenAndServe(nil)
// #Output:

func NewClassicServer Uses

func NewClassicServer(addr, ip, username, password string, tcpTimeout, tcpDeadline, udpDeadline, udpSessionTime int) (*Server, error)

NewClassicServer return a server which allow none method

func (*Server) GetRequest Uses

func (s *Server) GetRequest(c *net.TCPConn) (*Request, error)

GetRequest get request packet from client, and check command according to SupportedCommands Error replied.

func (*Server) ListenAndServe Uses

func (s *Server) ListenAndServe(h Handler) error

Run server

func (*Server) Negotiate Uses

func (s *Server) Negotiate(c *net.TCPConn) error

Negotiate handle negotiate packet. This method do not handle gssapi(0x01) method now. Error or OK both replied.

func (*Server) RunTCPServer Uses

func (s *Server) RunTCPServer() error

RunTCPServer starts tcp server

func (*Server) RunUDPServer Uses

func (s *Server) RunUDPServer() error

RunUDPServer starts udp server

func (*Server) Shutdown Uses

func (s *Server) Shutdown() error

Stop server

func (*Server) TCPWaitsForUDP Uses

func (s *Server) TCPWaitsForUDP(addr *net.UDPAddr) error

TCP connection waits for associated UDP to close

func (*Server) UDPReleasesTCP Uses

func (s *Server) UDPReleasesTCP(addr *net.UDPAddr)

UDP releases associated TCP

type UDPExchange Uses

type UDPExchange struct {
    ClientAddr *net.UDPAddr
    RemoteConn *net.UDPConn
}

UDPExchange used to store client address and remote connection

type UserPassNegotiationReply Uses

type UserPassNegotiationReply struct {
    Ver    byte
    Status byte
}

UserPassNegotiationReply is the negotiation username/password reply packet

func NewUserPassNegotiationReply Uses

func NewUserPassNegotiationReply(status byte) *UserPassNegotiationReply

NewUserPassNegotiationReply return negotiation username password reply packet can be writed into client

func NewUserPassNegotiationReplyFrom Uses

func NewUserPassNegotiationReplyFrom(r io.Reader) (*UserPassNegotiationReply, error)

NewUserPassNegotiationReplyFrom read user password negotiation reply packet from server

func (*UserPassNegotiationReply) WriteTo Uses

func (r *UserPassNegotiationReply) WriteTo(w io.Writer) (int64, error)

WriteTo write negotiation username password reply packet into client

type UserPassNegotiationRequest Uses

type UserPassNegotiationRequest struct {
    Ver    byte
    Ulen   byte
    Uname  []byte // 1-255 bytes
    Plen   byte
    Passwd []byte // 1-255 bytes
}

UserPassNegotiationRequest is the negotiation username/password reqeust packet

func NewUserPassNegotiationRequest Uses

func NewUserPassNegotiationRequest(username []byte, password []byte) *UserPassNegotiationRequest

NewUserPassNegotiationRequest return user password negotiation request packet can be writed into server

func NewUserPassNegotiationRequestFrom Uses

func NewUserPassNegotiationRequestFrom(r io.Reader) (*UserPassNegotiationRequest, error)

NewUserPassNegotiationRequestFrom read user password negotiation request packet from client

func (*UserPassNegotiationRequest) WriteTo Uses

func (r *UserPassNegotiationRequest) WriteTo(w io.Writer) (int64, error)

WriteTo write user password negotiation request packet into server

Package socks5 imports 11 packages (graph) and is imported by 22 packages. Updated 2020-05-31. Refresh now. Tools for package owners.