@types/ssh2

constructor

constructor(isClient: boolean);

• Creates and returns a new AgentProtocol instance. isClient determines whether the instance operates in client or server mode.

method failureReply

failureReply: (request: AgentInboundRequest) => void;

• (Server mode only) Replies to the given request with a failure response.

method getIdentities

getIdentities: (
    callback: (err: Error | undefined, publicKeys?: ParsedKey[]) => void
) => void;

• (Client mode only) Requests a list of public keys from the agent. callback is passed (err, keys) where keys is a possible array of public keys for authentication.

method getIdentitiesReply

getIdentitiesReply: (request: AgentInboundRequest, keys: ParsedKey[]) => void;

• (Server mode only) Responds to a identities list request with the given array of keys in keys.

method on

on: {
    (event: 'identities', listener: (req: AgentInboundRequest) => void): this;
    (
        event: 'sign',
        listener: (
            req: AgentInboundRequest,
            pubKey: ParsedKey,
            data: Buffer,
            options: SigningRequestOptions
        ) => void
    ): this;
    (event: string | symbol, listener: Function): this;
};

• (Server mode only) The client has requested a list of public keys stored in the agent. Use failureReply() or getIdentitiesReply() to reply appropriately.

• (Server mode only) The client has requested data to be signed using the key identified by pubKey. Use failureReply() or signReply() to reply appropriately.

method once

once: {
    (event: 'identities', listener: (req: AgentInboundRequest) => void): this;
    (
        event: 'sign',
        listener: (
            req: AgentInboundRequest,
            pubKey: ParsedKey,
            data: Buffer,
            options: SigningRequestOptions
        ) => void
    ): this;
    (event: string | symbol, listener: Function): this;
};

• (Server mode only) The client has requested a list of public keys stored in the agent. Use failureReply() or getIdentitiesReply() to reply appropriately.

• (Server mode only) The client has requested data to be signed using the key identified by pubKey. Use failureReply() or signReply() to reply appropriately.

method sign

sign: {
    (
        pubKey: ParsedKey | Buffer | string,
        data: Buffer,
        options?: SigningRequestOptions,
        callback?: SignCallback
    ): boolean;
    (pubKey: any, data: Buffer, callback?: SignCallback): boolean;
};

• (Client mode only) Signs the datawith the given public key, and calls back with its signature.

method signReply

signReply: (request: AgentInboundRequest, signature: Buffer) => void;

• (Server mode only) Responds to a sign request with the given signature in signature.

method getIdentities

abstract getIdentities: (cb: IdentityCallback<TPublicKey>) => void;

• Retrieves user identities, where keys is a possible array of public keys for authentication.

method getStream

getStream: (cb: GetStreamCallback) => void;

• Optional method that may be implemented to support agent forwarding. Callback should be invoked with a Duplex stream to be used to communicate with your agent/ You will probably want to utilize AgentProtocol as agent forwarding is an OpenSSH feature, so the stream needs to be able to transmit/receive OpenSSH agent protocol packets.

method sign

abstract sign: {
    (
        pubKey: TPublicKey,
        data: Buffer,
        options: SigningRequestOptions,
        cb?: SignCallback
    ): void;
    (pubKey: TPublicKey, data: Buffer, cb: SignCallback): void;
};

• Signs the datawith the given public key, and calls back with its signature. Note that, in the current implementation, "options" is always an empty object.

method connect

connect: (config: ConnectConfig) => this;

• Attempts a connection to a server.

method destroy

destroy: () => this;

• Destroys the socket.

method end

end: () => this;

• Disconnects the socket.

method exec

exec: {
    (command: string, options: ExecOptions, callback: ClientCallback): this;
    (command: string, callback: ClientCallback): this;
};

• Executes a command on the server.

  Parameter command

  The command to execute.

  Parameter options

  Options for the command.

  Parameter callback

  The callback to execute when the command has completed.

• Executes a command on the server.

  Parameter command

  The command to execute.

  Parameter callback

  The callback to execute when the command has completed.

method forwardIn

forwardIn: (
    remoteAddr: string,
    remotePort: number,
    callback?: ClientForwardCallback
) => this;

• Bind to remoteAddr on remotePort on the server and forward incoming TCP connections.

  Parameter remoteAddr

  The remote address to bind on the server. The following lists several special values for remoteAddr and their respective bindings:

  | address | description |:--------------|:----------- | '' | Listen on all protocol families supported by the server | '0.0.0.0' | Listen on all IPv4 addresses | '::' | Listen on all IPv6 addresses | 'localhost' | Listen on the loopback interface for all protocol families | '127.0.0.1' | Listen on the loopback interfaces for IPv4 | '::1' | Listen on the loopback interfaces for IPv6

  Parameter remotePort

  The remote port to bind on the server. If this value is 0, the actual bound port is provided to callback.

  Parameter callback

  An optional callback that is invoked when the remote address is bound.

method forwardOut

forwardOut: (
    srcIP: string,
    srcPort: number,
    dstIP: string,
    dstPort: number,
    callback?: ClientCallback
) => this;

• Open a connection with srcIP and srcPort as the originating address and port and dstIP and dstPort as the remote destination address and port.

  Parameter srcIP

  The originating address.

  Parameter srcPort

  The originating port.

  Parameter dstIP

  The destination address.

  Parameter dstPort

  The destination port.

  Parameter callback

  The callback that is invoked when the address is bound.

method on

on: {
    (event: 'banner', listener: (message: string) => void): this;
    (event: 'ready', listener: () => void): this;
    (
        event: 'tcp connection',
        listener: (
            details: TcpConnectionDetails,
            accept: AcceptConnection<ClientChannel>,
            reject: RejectConnection
        ) => void
    ): this;
    (
        event: 'x11',
        listener: (
            details: X11Details,
            accept: AcceptConnection<ClientChannel>,
            reject: RejectConnection
        ) => void
    ): this;
    (
        event: 'keyboard-interactive',
        listener: (
            name: string,
            instructions: string,
            lang: string,
            prompts: Prompt[],
            finish: KeyboardInteractiveCallback
        ) => void
    ): this;
    (
        event: 'change password',
        listener: (message: string, done: ChangePasswordCallback) => void
    ): this;
    (
        event: 'error',
        listener: (err: Error & ClientErrorExtensions) => void
    ): this;
    (event: 'end', listener: () => void): this;
    (event: 'close', listener: () => void): this;
    (event: 'timeout', listener: () => void): this;
    (event: 'connect', listener: () => void): this;
    (event: 'greeting', listener: (greeting: string) => void): this;
    (
        event: 'handshake',
        listener: (negotiated: NegotiatedAlgorithms) => void
    ): this;
    (event: 'hostkeys', listener: (keys: ParsedKey[]) => void): this;
    (
        event: 'unix connection',
        listener: (
            info: UNIXConnectionDetails,
            accept: AcceptConnection<Channel>,
            reject: RejectConnection
        ) => void
    ): this;
};

• Emitted when a notice was sent by the server upon connection.

• Emitted when authentication was successful.

• Emitted when an incoming forwarded TCP connection is being requested.

  Calling accept() accepts the connection and returns a Channel object. Calling reject() rejects the connection and no further action is needed.

• Emitted when an incoming X11 connection is being requested.

  Calling accept() accepts the connection and returns a Channel object. Calling reject() rejects the connection and no further action is needed.

• Emitted when the server is asking for replies to the given prompts for keyboard- interactive user authentication.

  * name is generally what you'd use as a window title (for GUI apps). * prompts is an array of Prompt objects.

  The answers for all prompts must be provided as an array of strings and passed to finish when you are ready to continue.

  NOTE: It's possible for the server to come back and ask more questions.

• Emitted when the server has requested that the user's password be changed, if using password-based user authentication.

  Call done with the new password.

• Emitted when an error occurred.

• Emitted when the socket was disconnected.

• Emitted when the socket was closed.

• Emitted when the socket has timed out.

• Emitted when the socket has connected.

• Emitted when the server responds with a greeting message.

• Emitted when a handshake has completed (either initial or rekey).

• Emitted when the server announces its available host keys.

• An incoming forwarded UNIX socket connection is being requested.

method once

once: {
    (event: 'banner', listener: (message: string) => void): this;
    (event: 'ready', listener: () => void): this;
    (
        event: 'tcp connection',
        listener: (
            details: TcpConnectionDetails,
            accept: AcceptConnection<ClientChannel>,
            reject: RejectConnection
        ) => void
    ): this;
    (
        event: 'x11',
        listener: (
            details: X11Details,
            accept: AcceptConnection<ClientChannel>,
            reject: RejectConnection
        ) => void
    ): this;
    (
        event: 'keyboard-interactive',
        listener: (
            name: string,
            instructions: string,
            lang: string,
            prompts: Prompt[],
            finish: KeyboardInteractiveCallback
        ) => void
    ): this;
    (
        event: 'change password',
        listener: (message: string, done: ChangePasswordCallback) => void
    ): this;
    (
        event: 'error',
        listener: (err: Error & ClientErrorExtensions) => void
    ): this;
    (event: 'end', listener: () => void): this;
    (event: 'close', listener: () => void): this;
    (event: 'timeout', listener: () => void): this;
    (event: 'connect', listener: () => void): this;
    (event: 'greeting', listener: (greeting: string) => void): this;
    (
        event: 'handshake',
        listener: (negotiated: NegotiatedAlgorithms) => void
    ): this;
    (event: 'hostkeys', listener: (keys: ParsedKey[]) => void): this;
    (
        event: 'unix connection',
        listener: (
            info: UNIXConnectionDetails,
            accept: AcceptConnection<Channel>,
            reject: RejectConnection
        ) => void
    ): this;
};

• Emitted when a notice was sent by the server upon connection.

• Emitted when authentication was successful.

• Emitted when an incoming forwarded TCP connection is being requested.

  Calling accept() accepts the connection and returns a Channel object. Calling reject() rejects the connection and no further action is needed.

• Emitted when an incoming X11 connection is being requested.

  Calling accept() accepts the connection and returns a Channel object. Calling reject() rejects the connection and no further action is needed.

• Emitted when the server is asking for replies to the given prompts for keyboard- interactive user authentication.

  * name is generally what you'd use as a window title (for GUI apps). * prompts is an array of Prompt objects.

  The answers for all prompts must be provided as an array of strings and passed to finish when you are ready to continue.

  NOTE: It's possible for the server to come back and ask more questions.

• Emitted when the server has requested that the user's password be changed, if using password-based user authentication.

  Call done with the new password.

• Emitted when an error occurred.

• Emitted when the socket was disconnected.

• Emitted when the socket was closed.

• Emitted when the socket has timed out.

• Emitted when the socket has connected.

• Emitted when the server responds with a greeting message.

• Emitted when a handshake has completed (either initial or rekey).

• Emitted when the server announces its available host keys.

• An incoming forwarded UNIX socket connection is being requested.

method openssh_forwardInStreamLocal

openssh_forwardInStreamLocal: (socketPath: string, cb: Callback) => this;

• OpenSSH extension that binds to a UNIX domain socket at socketPath on the server and forwards incoming connections.

method openssh_forwardOutStreamLocal

openssh_forwardOutStreamLocal: (socketPath: string, cb: ClientCallback) => this;

• OpenSSH extension that opens a connection to a UNIX domain socket at socketPath on the server.

method openssh_noMoreSessions

openssh_noMoreSessions: (cb: Callback) => this;

• OpenSSH extension that sends a request to reject any new sessions (e.g. exec, shell, sftp, subsys) for this connection.

method openssh_unforwardInStreamLocal

openssh_unforwardInStreamLocal: (socketPath: string, cb: Callback) => this;

• OpenSSH extension that unbinds from a UNIX domain socket at socketPath on the server and stops forwarding incoming connections.

method sftp

sftp: (callback: ClientSFTPCallback) => this;

• Starts an SFTP session.

  Parameter callback

  The callback that is invoked when the SFTP session has started.

method shell

shell: {
    (
        window: PseudoTtyOptions | false,
        options: ShellOptions,
        callback: ClientCallback
    ): this;
    (window: false | PseudoTtyOptions, callback: ClientCallback): this;
    (options: ShellOptions, callback: ClientCallback): this;
    (callback: ClientCallback): this;
};

• Starts an interactive shell session on the server.

  Parameter window

  Either an object containing pseudo-tty settings, false to suppress creation of a pseudo-tty.

  Parameter options

  Options for the command.

  Parameter callback

  The callback to execute when the channel has been created.

• Starts an interactive shell session on the server.

  Parameter window

  Either an object containing pseudo-tty settings, false to suppress creation of a pseudo-tty.

  Parameter callback

  The callback to execute when the channel has been created.

• Starts an interactive shell session on the server.

  Parameter options

  Options for the command.

  Parameter callback

  The callback to execute when the channel has been created.

• Starts an interactive shell session on the server.

  Parameter callback

  The callback to execute when the channel has been created.

method subsys

subsys: (subsystem: string, callback: ClientCallback) => this;

• Invokes subsystem on the server.

  Parameter subsystem

  The subsystem to start on the server.

  Parameter callback

  The callback that is invoked when the subsystem has started.

method unforwardIn

unforwardIn: (
    remoteAddr: string,
    remotePort: number,
    callback?: Callback
) => this;

• Unbind from remoteAddr on remotePort on the server and stop forwarding incoming TCP connections. Until callback is called, more connections may still come in.

  Parameter remoteAddr

  The remote address to unbind on the server.

  Parameter remotePort

  The remote port to unbind on the server.

  Parameter callback

  An optional callback that is invoked when the remote address is unbound.

constructor

constructor(connectCfg: ConnectConfig, agentOptions: HTTPAgentOptions);

constructor

constructor(connectCfg: ConnectConfig, agentOptions: HTTPAgentOptions);

constructor

constructor(socketPath: string);

method getIdentities

getIdentities: (cb: IdentityCallback<ParsedKey>) => void;

method getStream

getStream: (cb: GetStreamCallback) => void;

method sign

sign: {
    (
        pubKey: ParsedKey | Buffer | string,
        data: Buffer,
        options?: SigningRequestOptions,
        cb?: SignCallback
    ): boolean;
    (pubKey: any, data: Buffer, cb?: SignCallback): boolean;
};

constructor

constructor(cfg: ServerConfig, listener?: ServerConnectionListener);

property KEEPALIVE_CLIENT_COUNT_MAX

static KEEPALIVE_CLIENT_COUNT_MAX: number;

property KEEPALIVE_CLIENT_INTERVAL

static KEEPALIVE_CLIENT_INTERVAL: number;

method injectSocket

injectSocket: (socket: Socket) => void;

method on

on: {
    (event: 'connection', listener: ServerConnectionListener): this;
    (event: string | symbol, listener: Function): this;
};

method once

once: {
    (event: 'connection', listener: ServerConnectionListener): this;
    (event: string | symbol, listener: Function): this;
};

property agent

agent: BaseAgent | string;

• Can be a string that is interpreted exactly like the agent connection config option or can be a custom agent object/instance that extends and implements BaseAgent

property type

type: 'agent';

property cipher

cipher?: AlgorithmList<CipherAlgorithm>;

property compress

compress?: AlgorithmList<CompressionAlgorithm>;

property hmac

hmac?: AlgorithmList<MacAlgorithm>;

property kex

kex?: AlgorithmList<KexAlgorithm>;

property serverHostKey

serverHostKey?: AlgorithmList<ServerHostKeyAlgorithm>;

property atime

atime: number;

property gid

gid: number;

property mode

mode: number;

property mtime

mtime: number;

property size

size: number;

property uid

uid: number;

property method

method: AuthenticationType;

• The method of authentication.

property service

service: string;

• The service requesting authentication.

property username

username: string;

• The client's username.

method accept

accept: () => void;

• Accepts the authentication request.

method on

on: (event: 'abort', listener: () => void) => this;

• Emitted when the client aborts the authentication request.

method once

once: (event: 'abort', listener: () => void) => this;

• Emitted when the client aborts the authentication request.

method reject

reject: (
    authMethodsLeft?: AuthenticationType[],
    isPartialSuccess?: boolean
) => void;

• Rejects the authentication request.

property type

type: AuthenticationType;

property username

username: string;

property incoming

incoming: unknown;

property outgoing

outgoing: unknown;

property server

server: boolean;

• Indicates whether this is a server or client channel.

property stderr

stderr: Writable | Readable;

• Standard error for the Channel.

property stdin

stdin: this;

• Standard input for the Channel.

property stdout

stdout: this;

• Standard output for the Channel.

property subtype

subtype?: ChannelSubType;

• The channel subtype, usually "exec", "shell", or undefined.

property type

type: ChannelType;

• The channel type, usually "session".

method close

close: (...args: any[]) => void;

• Closes the channel on both sides.

method destroy

destroy: () => this;

• Shuts down the channel on this side.

method eof

eof: () => void;

• Sends EOF to the remote side.

method exit

exit: {
    (status: number): void;
    (signalName: string, coreDumped?: boolean, msg?: string): void;
};

method on

on: {
    (event: 'close', listener: () => void): this;
    (event: 'eof', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: string | symbol, listener: Function): this;
};

• Emitted once the channel is completely closed on both the client and the server.

method once

once: {
    (event: 'close', listener: () => void): this;
    (event: 'eof', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: string | symbol, listener: Function): this;
};

method setWindow

setWindow: (rows: number, cols: number, height: number, width: number) => void;

• Session type-specific methods

method signal

signal: (signalName: string) => void;

property server

server: false;

• Indicates whether this is a server or client channel.

property stderr

stderr: Readable;

• Standard error for the Channel.

method on

on: {
    (event: 'exit', listener: (code: number) => void): this;
    (
        event: 'exit',
        listener: (
            code: null,
            signal: string,
            dump: string,
            desc: string
        ) => void
    ): this;
    (event: string | symbol, listener: Function): this;
};

• An exit event *may* (the SSH2 spec says it is optional) be emitted when the process finishes. If the process finished normally, the process's return value is passed to the exit callback.

method once

once: {
    (event: 'exit', listener: (code: number) => void): this;
    (
        event: 'exit',
        listener: (
            code: null,
            signal: string,
            dump: string,
            desc: string
        ) => void
    ): this;
    (event: string | symbol, listener: Function): this;
};

property description

description?: string;

• Additional detail for 'client-ssh' messages.

property level

level?: string;

• Indicates 'client-socket' for socket-level errors and 'client-ssh' for SSH disconnection messages.

property family

family: string;

property header

header: Header;

• Information about the client.

property ip

ip: string;

• The remote address of the connection.

property port

port: number;

property agent

agent?: BaseAgent | string;

• Path to ssh-agent's UNIX socket for ssh-agent-based user authentication (or 'pageant' when using Pagent on Windows).

property agentForward

agentForward?: boolean;

• Set to true to use OpenSSH agent forwarding (auth-agent@openssh.com) for the life of the connection.

property algorithms

algorithms?: Algorithms;

• Explicit overrides for the default transport layer algorithms used for the connection.

property authHandler

authHandler?: AuthenticationType[] | AuthHandlerMiddleware | AuthMethod[];

• Function with parameters (methodsLeft, partialSuccess, callback) where methodsLeft and partialSuccess are null on the first authentication attempt, otherwise are an array and boolean respectively. Return or call callback() with the name of the authentication method to try next (pass false to signal no more methods to try). Valid method names are: 'none', 'password', 'publickey', 'agent', 'keyboard-interactive', 'hostbased'. Default: function that follows a set method order: None -> Password -> Private Key -> Agent (-> keyboard-interactive if tryKeyboard is true) -> Hostbased.

property debug

debug?: DebugFunction;

• A function that receives a single string argument to get detailed (local) debug information.

property forceIPv4

forceIPv4?: boolean;

• Only connect via resolved IPv4 address for host.

property forceIPv6

forceIPv6?: boolean;

• Only connect via resolved IPv6 address for host.

property host

host?: string;

• Hostname or IP address of the server.

property hostHash

hostHash?: string;

• The host's key is hashed using this method and passed to hostVerifier.

property hostVerifier

hostVerifier?:
    | HostVerifier
    | SyncHostVerifier
    | HostFingerprintVerifier
    | SyncHostFingerprintVerifier;

• Verifies a hexadecimal hash of the host's key.

property ident

ident?: Buffer | string;

• A custom server software name/version identifier. Default: 'ssh2js' + moduleVersion + 'srv'

property keepaliveCountMax

keepaliveCountMax?: number;

• How many consecutive, unanswered SSH-level keepalive packets that can be sent to the server before disconnection.

property keepaliveInterval

keepaliveInterval?: number;

• How often (in milliseconds) to send SSH-level keepalive packets to the server. Set to 0 to disable.

property localAddress

localAddress?: string;

• IP address of the network interface to use to connect to the server. Default: (none -- determined by OS)

property localHostname

localHostname?: string;

• Along with localUsername and privateKey, set this to a non-empty string for hostbased user authentication.

property localPort

localPort?: number;

• The local port number to connect from. Default: (none -- determined by OS)

property localUsername

localUsername?: string;

• Along with localHostname and privateKey, set this to a non-empty string for hostbased user authentication.

property passphrase

passphrase?: Buffer | string;

• For an encrypted private key, this is the passphrase used to decrypt it.

property password

password?: string;

• Password for password-based user authentication.

property port

port?: number;

• Port number of the server.

property privateKey

privateKey?: Buffer | string;

• Buffer or string that contains a private key for either key-based or hostbased user authentication (OpenSSH format).

property readyTimeout

readyTimeout?: number;

• * How long (in milliseconds) to wait for the SSH handshake to complete.

property sock

sock?: Readable;

• A ReadableStream to use for communicating with the server instead of creating and using a new TCP connection (useful for connection hopping).

property strictVendor

strictVendor?: boolean;

• Performs a strict server vendor check before sending vendor-specific requests.

property timeout

timeout?: number;

• The underlying socket timeout in ms. Default: none)

property tryKeyboard

tryKeyboard?: boolean;

• Try keyboard-interactive user authentication if primary user authentication method fails.

property username

username?: string;

• Username for authentication.

property authenticated

authenticated: boolean;

property noMoreSessions

noMoreSessions: boolean;

method end

end: () => this;

• Closes the client connection.

method forwardOut

forwardOut: (
    boundAddr: string,
    boundPort: number,
    remoteAddr: string,
    remotePort: number,
    callback: ServerCallback
) => this;

• Alert the client of an incoming TCP connection on boundAddr on port boundPort from remoteAddr on port remotePort.

method on

on: {
    (event: 'authentication', listener: (context: AuthContext) => void): this;
    (event: 'ready', listener: () => void): this;
    (
        event: 'session',
        listener: (
            accept: AcceptConnection<Session>,
            reject: RejectConnection
        ) => void
    ): this;
    (
        event: 'tcpip',
        listener: (
            accept: AcceptConnection<ServerChannel>,
            reject: RejectConnection,
            info: TcpipRequestInfo
        ) => void
    ): this;
    (
        event: 'openssh.streamlocal',
        listener: (
            accept: AcceptConnection<ServerChannel>,
            reject: RejectConnection,
            info: SocketRequestInfo
        ) => void
    ): this;
    (
        event: 'request',
        listener: (
            accept: (chosenPort?: number) => void,
            reject: () => void,
            name: 'tcpip-forward' | 'cancel-tcpip-forward',
            info: TcpipBindInfo
        ) => void
    ): this;
    (
        event: 'request',
        listener: (
            accept: () => void,
            reject: () => void,
            name:
                | 'streamlocal-forward@openssh.com'
                | 'cancel-streamlocal-forward@openssh.com',
            info: SocketBindInfo
        ) => void
    ): this;
    (event: 'rekey', listener: () => void): this;
    (event: 'error', listener: ErrorCallback): this;
    (event: 'end', listener: () => void): this;
    (event: 'close', listener: () => void): this;
    (
        event: 'handshake',
        listener: (negotiated: NegotiatedAlgorithms) => void
    ): this;
    (event: 'greeting', listener: (greeting: string) => void): this;
};