sshh

README

sshh

An SSH Handler library which makes it easy to implement SSH servers

Documentation

Index

• Constants
• type Config
  • func (c *Config) SSHConfig() *ssh.ServerConfig
• type Context
• type Dispatcher
• type Handler
• type HandlerFunc
• type PanicHandler
• type RequestConsumer
• type SSHServer
  • func New(cfg *Config) (server SSHServer, err error)
  • func (s *SSHServer) Start()
  • func (s *SSHServer) Stop()
• type SimpleDispatcher
  • func (u *SimpleDispatcher) Dispatch(c context.Context, conn *ssh.ServerConn, ch ssh.NewChannel)
• type UrlDispatcher
  • func (u *UrlDispatcher) Dispatch(c context.Context, conn *ssh.ServerConn, ch ssh.NewChannel)

Constants

const (
	ChannelAcceptError ssh.RejectionReason = 1000
	InvalidChannelType ssh.RejectionReason = 1001
	InvalidQueryParams ssh.RejectionReason = 1002
	HostNotSupported   ssh.RejectionReason = 1003
	SchemeNotSupported ssh.RejectionReason = 1004
	UserNotSupported   ssh.RejectionReason = 1005
	ChannelHandleError ssh.RejectionReason = 1006
)

Types

type Config

type Config struct {
	sync.Mutex

	// Context allows for lifecycle management of the server.
	Context context.Context

	// Deadline is the maximum time the listener will block
	// between connections. As a consequence, this duration
	// also sets the max length of time the SSH server will
	// be unresponsive before shutting down.
	Deadline time.Duration

	// Dispatcher handles all open channel requests and dispatches them to a handler.
	Dispatcher Dispatcher

	// Consumer processes all global ssh.Requests for the life of the connection.
	Consumer RequestConsumer

	// Logger logs errors and debug output for the SSH server.
	Logger log.Logger

	// Bind specifies the Bind address the SSH server will listen on.
	Bind string

	// PrivateKey is added to the SSH config as a host key.
	PrivateKey ssh.Signer

	// AuthLogCallback, if non-nil, is called to log all authentication
	// attempts.
	AuthLogCallback func(conn ssh.ConnMetadata, method string, err error)

	// PasswordCallback, if non-nil, is called when a user
	// attempts to authenticate using a password.
	PasswordCallback func(conn ssh.ConnMetadata, password []byte) (*ssh.Permissions, error)

	// PublicKeyCallback, if non-nil, is called when a client attempts public
	// key authentication. It must return true if the given public key is
	// valid for the given user. For example, see CertChecker.Authenticate.
	PublicKeyCallback func(ssh.ConnMetadata, ssh.PublicKey) (*ssh.Permissions, error)
	// contains filtered or unexported fields
}

Config is used to setup the SSHServer, including the server config and the SSHHandlers.

func (*Config) SSHConfig

func (c *Config) SSHConfig() *ssh.ServerConfig

SSHConfig returns an SSH server configuration. If the AuthLogCallback is nil at the time this method is called, the default function will be used.

type Context

type Context struct {
	ChannelType string
	Context     context.Context
	Channel     ssh.Channel
	Requests    <-chan *ssh.Request
}

type Dispatcher

type Dispatcher interface {
	Dispatch(context.Context, *ssh.ServerConn, ssh.NewChannel)
}

type Handler

type Handler interface {
	Handle(*Context) error
}

type HandlerFunc

type HandlerFunc func(*Context) error

type PanicHandler

type PanicHandler interface {
	Handle(*Context, interface{})
}

type RequestConsumer

type RequestConsumer interface {
	Consume(<-chan *ssh.Request)
}

type SSHServer

type SSHServer struct {
	Addr *net.TCPAddr
	// contains filtered or unexported fields
}

SSHServer handles all the incoming connections as well as handler dispatch.

func New

func New(cfg *Config) (server SSHServer, err error)

New creates a new server with the given config. The server will call `cfg.SSHConfig()` to setup the server. If an error occurs it will be returned. If the Bind address is empty or invalid an error will be returned. If there is an error starting the TCP server, the error will be returned.

func (*SSHServer) Start

func (s *SSHServer) Start()

Start starts accepting client connections. This method is non-blocking.

func (*SSHServer) Stop

func (s *SSHServer) Stop()

Stop stops the server and kills all goroutines. This method is blocking.

type SimpleDispatcher

type SimpleDispatcher struct {
	Logger       log.Logger
	Handlers     map[string]Handler
	PanicHandler PanicHandler
	NotFound     Handler
}

func (*SimpleDispatcher) Dispatch

func (u *SimpleDispatcher) Dispatch(c context.Context, conn *ssh.ServerConn, ch ssh.NewChannel)

type UrlDispatcher

type UrlDispatcher struct {
	Logger log.Logger
	Router *router.Router
}

func (*UrlDispatcher) Dispatch

func (u *UrlDispatcher) Dispatch(c context.Context, conn *ssh.ServerConn, ch ssh.NewChannel)