ssh: github.com/gliderlabs/ssh Index | Examples | Files | Directories

package ssh

import "github.com/gliderlabs/ssh"

Package ssh wraps the crypto/ssh package with a higher-level API for building SSH servers. The goal of the API was to make it as simple as using net/http, so the API is very similar.

You should be able to build any SSH server using only this package, which wraps relevant types and some functions from crypto/ssh. However, you still need to use crypto/ssh for building SSH clients.

ListenAndServe starts an SSH server with a given address, handler, and options. The handler is usually nil, which means to use DefaultHandler. Handle sets DefaultHandler:

ssh.Handle(func(s ssh.Session) {
    io.WriteString(s, "Hello world\n")
})

log.Fatal(ssh.ListenAndServe(":2222", nil))

If you don't specify a host key, it will generate one every time. This is convenient except you'll have to deal with clients being confused that the host key is different. It's a better idea to generate or point to an existing key on your system:

log.Fatal(ssh.ListenAndServe(":2222", nil, ssh.HostKeyFile("/Users/progrium/.ssh/id_rsa")))

Although all options have functional option helpers, another way to control the server's behavior is by creating a custom Server:

s := &ssh.Server{
    Addr:             ":2222",
    Handler:          sessionHandler,
    PublicKeyHandler: authHandler,
}
s.AddHostKey(hostKeySigner)

log.Fatal(s.ListenAndServe())

This package automatically handles basic SSH requests like setting environment variables, requesting PTY, and changing window size. These requests are processed, responded to, and any relevant state is updated. This state is then exposed to you via the Session interface.

The one big feature missing from the Session abstraction is signals. This was started, but not completed. Pull Requests welcome!

Index

Examples

Package Files

agent.go conn.go context.go doc.go options.go server.go session.go ssh.go tcpip.go util.go wrap.go

Variables

var (
    // ContextKeyUser is a context key for use with Contexts in this package.
    // The associated value will be of type string.
    ContextKeyUser = &contextKey{"user"}

    // ContextKeySessionID is a context key for use with Contexts in this package.
    // The associated value will be of type string.
    ContextKeySessionID = &contextKey{"session-id"}

    // ContextKeyPermissions is a context key for use with Contexts in this package.
    // The associated value will be of type *Permissions.
    ContextKeyPermissions = &contextKey{"permissions"}

    // ContextKeyClientVersion is a context key for use with Contexts in this package.
    // The associated value will be of type string.
    ContextKeyClientVersion = &contextKey{"client-version"}

    // ContextKeyServerVersion is a context key for use with Contexts in this package.
    // The associated value will be of type string.
    ContextKeyServerVersion = &contextKey{"server-version"}

    // ContextKeyLocalAddr is a context key for use with Contexts in this package.
    // The associated value will be of type net.Addr.
    ContextKeyLocalAddr = &contextKey{"local-addr"}

    // ContextKeyRemoteAddr is a context key for use with Contexts in this package.
    // The associated value will be of type net.Addr.
    ContextKeyRemoteAddr = &contextKey{"remote-addr"}

    // ContextKeyServer is a context key for use with Contexts in this package.
    // The associated value will be of type *Server.
    ContextKeyServer = &contextKey{"ssh-server"}

    // ContextKeyConn is a context key for use with Contexts in this package.
    // The associated value will be of type gossh.ServerConn.
    ContextKeyConn = &contextKey{"ssh-conn"}

    // ContextKeyPublicKey is a context key for use with Contexts in this package.
    // The associated value will be of type PublicKey.
    ContextKeyPublicKey = &contextKey{"public-key"}
)
var DefaultChannelHandlers = map[string]ChannelHandler{
    "session": DefaultSessionHandler,
}
var DefaultRequestHandlers = map[string]RequestHandler{}
var ErrServerClosed = errors.New("ssh: Server closed")

ErrServerClosed is returned by the Server's Serve, ListenAndServe, and ListenAndServeTLS methods after a call to Shutdown or Close.

func AgentRequested Uses

func AgentRequested(sess Session) bool

AgentRequested returns true if the client requested agent forwarding.

func DefaultSessionHandler Uses

func DefaultSessionHandler(srv *Server, conn *gossh.ServerConn, newChan gossh.NewChannel, ctx Context)

func DirectTCPIPHandler Uses

func DirectTCPIPHandler(srv *Server, conn *gossh.ServerConn, newChan gossh.NewChannel, ctx Context)

DirectTCPIPHandler can be enabled by adding it to the server's ChannelHandlers under direct-tcpip.

func ForwardAgentConnections Uses

func ForwardAgentConnections(l net.Listener, s Session)

ForwardAgentConnections takes connections from a listener to proxy into the session on the OpenSSH channel for agent connections. It blocks and services connections until the listener stop accepting.

func Handle Uses

func Handle(handler Handler)

Handle registers the handler as the DefaultHandler.

func KeysEqual Uses

func KeysEqual(ak, bk PublicKey) bool

KeysEqual is constant time compare of the keys to avoid timing attacks.

func ListenAndServe Uses

func ListenAndServe(addr string, handler Handler, options ...Option) error

ListenAndServe listens on the TCP network address addr and then calls Serve with handler to handle sessions on incoming connections. Handler is typically nil, in which case the DefaultHandler is used.

Code:

ssh.ListenAndServe(":2222", func(s ssh.Session) {
    io.WriteString(s, "Hello world\n")
})

func NewAgentListener Uses

func NewAgentListener() (net.Listener, error)

NewAgentListener sets up a temporary Unix socket that can be communicated to the session environment and used for forwarding connections.

func Serve Uses

func Serve(l net.Listener, handler Handler, options ...Option) error

Serve accepts incoming SSH connections on the listener l, creating a new connection goroutine for each. The connection goroutines read requests and then calls handler to handle sessions. Handler is typically nil, in which case the DefaultHandler is used.

func SetAgentRequested Uses

func SetAgentRequested(ctx Context)

SetAgentRequested sets up the session context so that AgentRequested returns true.

type ChannelHandler Uses

type ChannelHandler func(srv *Server, conn *gossh.ServerConn, newChan gossh.NewChannel, ctx Context)

type ConnCallback Uses

type ConnCallback func(conn net.Conn) net.Conn

ConnCallback is a hook for new connections before handling. It allows wrapping for timeouts and limiting by returning the net.Conn that will be used as the underlying connection.

type Context Uses

type Context interface {
    context.Context
    sync.Locker

    // User returns the username used when establishing the SSH connection.
    User() string

    // SessionID returns the session hash.
    SessionID() string

    // ClientVersion returns the version reported by the client.
    ClientVersion() string

    // ServerVersion returns the version reported by the server.
    ServerVersion() string

    // RemoteAddr returns the remote address for this connection.
    RemoteAddr() net.Addr

    // LocalAddr returns the local address for this connection.
    LocalAddr() net.Addr

    // Permissions returns the Permissions object used for this connection.
    Permissions() *Permissions

    // SetValue allows you to easily write new values into the underlying context.
    SetValue(key, value interface{})
}

Context is a package specific context interface. It exposes connection metadata and allows new values to be easily written to it. It's used in authentication handlers and callbacks, and its underlying context.Context is exposed on Session in the session Handler. A connection-scoped lock is also embedded in the context to make it easier to limit operations per-connection.

type ForwardedTCPHandler Uses

type ForwardedTCPHandler struct {
    sync.Mutex
    // contains filtered or unexported fields
}

ForwardedTCPHandler can be enabled by creating a ForwardedTCPHandler and adding the HandleSSHRequest callback to the server's RequestHandlers under tcpip-forward and cancel-tcpip-forward.

func (*ForwardedTCPHandler) HandleSSHRequest Uses

func (h *ForwardedTCPHandler) HandleSSHRequest(ctx Context, srv *Server, req *gossh.Request) (bool, []byte)

type Handler Uses

type Handler func(Session)

Handler is a callback for handling established SSH sessions.

var DefaultHandler Handler

DefaultHandler is the default Handler used by Serve.

type KeyboardInteractiveHandler Uses

type KeyboardInteractiveHandler func(ctx Context, challenger gossh.KeyboardInteractiveChallenge) bool

KeyboardInteractiveHandler is a callback for performing keyboard-interactive authentication.

type LocalPortForwardingCallback Uses

type LocalPortForwardingCallback func(ctx Context, destinationHost string, destinationPort uint32) bool

LocalPortForwardingCallback is a hook for allowing port forwarding

type Option Uses

type Option func(*Server) error

Option is a functional option handler for Server.

func HostKeyFile Uses

func HostKeyFile(filepath string) Option

HostKeyFile returns a functional option that adds HostSigners to the server from a PEM file at filepath.

Code:

ssh.ListenAndServe(":2222", nil, ssh.HostKeyFile("/path/to/host/key"))

func HostKeyPEM Uses

func HostKeyPEM(bytes []byte) Option

HostKeyPEM returns a functional option that adds HostSigners to the server from a PEM file as bytes.

func NoPty Uses

func NoPty() Option

NoPty returns a functional option that sets PtyCallback to return false, denying PTY requests.

Code:

ssh.ListenAndServe(":2222", nil, ssh.NoPty())

func PasswordAuth Uses

func PasswordAuth(fn PasswordHandler) Option

PasswordAuth returns a functional option that sets PasswordHandler on the server.

Code:

ssh.ListenAndServe(":2222", nil,
    ssh.PasswordAuth(func(ctx ssh.Context, pass string) bool {
        return pass == "secret"
    }),
)

func PublicKeyAuth Uses

func PublicKeyAuth(fn PublicKeyHandler) Option

PublicKeyAuth returns a functional option that sets PublicKeyHandler on the server.

Code:

ssh.ListenAndServe(":2222", nil,
    ssh.PublicKeyAuth(func(ctx ssh.Context, key ssh.PublicKey) bool {
        data, _ := ioutil.ReadFile("/path/to/allowed/key.pub")
        allowed, _, _, _, _ := ssh.ParseAuthorizedKey(data)
        return ssh.KeysEqual(key, allowed)
    }),
)

func WrapConn Uses

func WrapConn(fn ConnCallback) Option

WrapConn returns a functional option that sets ConnCallback on the server.

type PasswordHandler Uses

type PasswordHandler func(ctx Context, password string) bool

PasswordHandler is a callback for performing password authentication.

type Permissions Uses

type Permissions struct {
    *gossh.Permissions
}

The Permissions type holds fine-grained permissions that are specific to a user or a specific authentication method for a user. Permissions, except for "source-address", must be enforced in the server application layer, after successful authentication.

type Pty Uses

type Pty struct {
    Term   string
    Window Window
}

Pty represents a PTY request and configuration.

type PtyCallback Uses

type PtyCallback func(ctx Context, pty Pty) bool

PtyCallback is a hook for allowing PTY sessions.

type PublicKey Uses

type PublicKey interface {
    gossh.PublicKey
}

PublicKey is an abstraction of different types of public keys.

func ParseAuthorizedKey Uses

func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []string, rest []byte, err error)

ParseAuthorizedKey parses a public key from an authorized_keys file used in OpenSSH according to the sshd(8) manual page.

func ParsePublicKey Uses

func ParsePublicKey(in []byte) (out PublicKey, err error)

ParsePublicKey parses an SSH public key formatted for use in the SSH wire protocol according to RFC 4253, section 6.6.

type PublicKeyHandler Uses

type PublicKeyHandler func(ctx Context, key PublicKey) bool

PublicKeyHandler is a callback for performing public key authentication.

type RequestHandler Uses

type RequestHandler func(ctx Context, srv *Server, req *gossh.Request) (ok bool, payload []byte)

type ReversePortForwardingCallback Uses

type ReversePortForwardingCallback func(ctx Context, bindHost string, bindPort uint32) bool

ReversePortForwardingCallback is a hook for allowing reverse port forwarding

type Server Uses

type Server struct {
    Addr        string   // TCP address to listen on, ":22" if empty
    Handler     Handler  // handler to invoke, ssh.DefaultHandler if nil
    HostSigners []Signer // private keys for the host key, must have at least one
    Version     string   // server version to be sent before the initial handshake

    KeyboardInteractiveHandler    KeyboardInteractiveHandler    // keyboard-interactive authentication handler
    PasswordHandler               PasswordHandler               // password authentication handler
    PublicKeyHandler              PublicKeyHandler              // public key authentication handler
    PtyCallback                   PtyCallback                   // callback for allowing PTY sessions, allows all if nil
    ConnCallback                  ConnCallback                  // optional callback for wrapping net.Conn before handling
    LocalPortForwardingCallback   LocalPortForwardingCallback   // callback for allowing local port forwarding, denies all if nil
    ReversePortForwardingCallback ReversePortForwardingCallback // callback for allowing reverse port forwarding, denies all if nil
    ServerConfigCallback          ServerConfigCallback          // callback for configuring detailed SSH options
    SessionRequestCallback        SessionRequestCallback        // callback for allowing or denying SSH sessions

    IdleTimeout time.Duration // connection timeout when no activity, none if empty
    MaxTimeout  time.Duration // absolute connection timeout, none if empty

    // ChannelHandlers allow overriding the built-in session handlers or provide
    // extensions to the protocol, such as tcpip forwarding. By default only the
    // "session" handler is enabled.
    ChannelHandlers map[string]ChannelHandler

    // RequestHandlers allow overriding the server-level request handlers or
    // provide extensions to the protocol, such as tcpip forwarding. By default
    // no handlers are enabled.
    RequestHandlers map[string]RequestHandler
    // contains filtered or unexported fields
}

Server defines parameters for running an SSH server. The zero value for Server is a valid configuration. When both PasswordHandler and PublicKeyHandler are nil, no client authentication is performed.

func (*Server) AddHostKey Uses

func (srv *Server) AddHostKey(key Signer)

AddHostKey adds a private key as a host key. If an existing host key exists with the same algorithm, it is overwritten. Each server config must have at least one host key.

func (*Server) Close Uses

func (srv *Server) Close() error

Close immediately closes all active listeners and all active connections.

Close returns any error returned from closing the Server's underlying Listener(s).

func (*Server) Handle Uses

func (srv *Server) Handle(fn Handler)

Handle sets the Handler for the server.

func (*Server) ListenAndServe Uses

func (srv *Server) ListenAndServe() error

ListenAndServe listens on the TCP network address srv.Addr and then calls Serve to handle incoming connections. If srv.Addr is blank, ":22" is used. ListenAndServe always returns a non-nil error.

func (*Server) Serve Uses

func (srv *Server) Serve(l net.Listener) error

Serve accepts incoming connections on the Listener l, creating a new connection goroutine for each. The connection goroutines read requests and then calls srv.Handler to handle sessions.

Serve always returns a non-nil error.

func (*Server) SetOption Uses

func (srv *Server) SetOption(option Option) error

SetOption runs a functional option against the server.

func (*Server) Shutdown Uses

func (srv *Server) Shutdown(ctx context.Context) error

Shutdown gracefully shuts down the server without interrupting any active connections. Shutdown works by first closing all open listeners, and then waiting indefinitely for connections to close. If the provided context expires before the shutdown is complete, then the context's error is returned.

type ServerConfigCallback Uses

type ServerConfigCallback func(ctx Context) *gossh.ServerConfig

ServerConfigCallback is a hook for creating custom default server configs

type Session Uses

type Session interface {
    gossh.Channel

    // User returns the username used when establishing the SSH connection.
    User() string

    // RemoteAddr returns the net.Addr of the client side of the connection.
    RemoteAddr() net.Addr

    // LocalAddr returns the net.Addr of the server side of the connection.
    LocalAddr() net.Addr

    // Environ returns a copy of strings representing the environment set by the
    // user for this session, in the form "key=value".
    Environ() []string

    // Exit sends an exit status and then closes the session.
    Exit(code int) error

    // Command returns a shell parsed slice of arguments that were provided by the
    // user. Shell parsing splits the command string according to POSIX shell rules,
    // which considers quoting not just whitespace.
    Command() []string

    // PublicKey returns the PublicKey used to authenticate. If a public key was not
    // used it will return nil.
    PublicKey() PublicKey

    // Context returns the connection's context. The returned context is always
    // non-nil and holds the same data as the Context passed into auth
    // handlers and callbacks.
    //
    // The context is canceled when the client's connection closes or I/O
    // operation fails.
    Context() context.Context

    // Permissions returns a copy of the Permissions object that was available for
    // setup in the auth handlers via the Context.
    Permissions() Permissions

    // Pty returns PTY information, a channel of window size changes, and a boolean
    // of whether or not a PTY was accepted for this session.
    Pty() (Pty, <-chan Window, bool)

    // Signals registers a channel to receive signals sent from the client. The
    // channel must handle signal sends or it will block the SSH request loop.
    // Registering nil will unregister the channel from signal sends. During the
    // time no channel is registered signals are buffered up to a reasonable amount.
    // If there are buffered signals when a channel is registered, they will be
    // sent in order on the channel immediately after registering.
    Signals(c chan<- Signal)
}

Session provides access to information about an SSH session and methods to read and write to the SSH channel with an embedded Channel interface from cypto/ssh.

When Command() returns an empty slice, the user requested a shell. Otherwise the user is performing an exec with those command arguments.

TODO: Signals

type SessionRequestCallback Uses

type SessionRequestCallback func(sess Session, requestType string) bool

SessionRequestCallback is a callback for allowing or denying SSH sessions.

type Signal Uses

type Signal string
const (
    SIGABRT Signal = "ABRT"
    SIGALRM Signal = "ALRM"
    SIGFPE  Signal = "FPE"
    SIGHUP  Signal = "HUP"
    SIGILL  Signal = "ILL"
    SIGINT  Signal = "INT"
    SIGKILL Signal = "KILL"
    SIGPIPE Signal = "PIPE"
    SIGQUIT Signal = "QUIT"
    SIGSEGV Signal = "SEGV"
    SIGTERM Signal = "TERM"
    SIGUSR1 Signal = "USR1"
    SIGUSR2 Signal = "USR2"
)

POSIX signals as listed in RFC 4254 Section 6.10.

type Signer Uses

type Signer interface {
    gossh.Signer
}

A Signer can create signatures that verify against a public key.

type Window Uses

type Window struct {
    Width  int
    Height int
}

Window represents the size of a PTY window.

Directories

PathSynopsis
_examples/ssh-docker
_examples/ssh-forwardagent
_examples/ssh-pty
_examples/ssh-publickey
_examples/ssh-remoteforward
_examples/ssh-simple
_examples/ssh-timeouts

Package ssh imports 19 packages (graph) and is imported by 21 packages. Updated 2019-06-19. Refresh now. Tools for package owners.