@electerm/ssh2 0.8.11 → 1.5.0

package/lib/server.js

@@ -1,1160 +1,1367 @@
-var net = require('net');
-var EventEmitter = require('events').EventEmitter;
-var listenerCount = EventEmitter.listenerCount;
-var inherits = require('util').inherits;
-
-var ssh2_streams = require('ssh2-streams');
-var parseKey = ssh2_streams.utils.parseKey;
-var SSH2Stream = ssh2_streams.SSH2Stream;
-var SFTPStream = ssh2_streams.SFTPStream;
-var consts = ssh2_streams.constants;
-var DISCONNECT_REASON = consts.DISCONNECT_REASON;
-var CHANNEL_OPEN_FAILURE = consts.CHANNEL_OPEN_FAILURE;
-var ALGORITHMS = consts.ALGORITHMS;
-
-var Channel = require('./Channel');
-var KeepaliveManager = require('./keepalivemgr');
-var writeUInt32BE = require('./buffer-helpers').writeUInt32BE;
-
-var MAX_CHANNEL = Math.pow(2, 32) - 1;
-var MAX_PENDING_AUTHS = 10;
-
-var kaMgr;
-
-function Server(cfg, listener) {
-  if (!(this instanceof Server))
-    return new Server(cfg, listener);
-
-  var hostKeys = {
-    'ssh-rsa': null,
-    'ssh-dss': null,
-    'ssh-ed25519': null,
-    'ecdsa-sha2-nistp256': null,
-    'ecdsa-sha2-nistp384': null,
-    'ecdsa-sha2-nistp521': null
-  };
+// TODO:
+//   * convert listenerCount() usage to emit() return value checking?
+//   * emit error when connection severed early (e.g. before handshake)
+//   * add '.connected' or similar property to connection objects to allow
+//     immediate connection status checking
+'use strict';
+
+const { Server: netServer } = require('net');
+const EventEmitter = require('events');
+const { listenerCount } = EventEmitter;
+
+const {
+  CHANNEL_OPEN_FAILURE,
+  DEFAULT_CIPHER,
+  DEFAULT_COMPRESSION,
+  DEFAULT_KEX,
+  DEFAULT_MAC,
+  DEFAULT_SERVER_HOST_KEY,
+  DISCONNECT_REASON,
+  DISCONNECT_REASON_BY_VALUE,
+  SUPPORTED_CIPHER,
+  SUPPORTED_COMPRESSION,
+  SUPPORTED_KEX,
+  SUPPORTED_MAC,
+  SUPPORTED_SERVER_HOST_KEY,
+} = require('./protocol/constants.js');
+const { init: cryptoInit } = require('./protocol/crypto.js');
+const { KexInit } = require('./protocol/kex.js');
+const { parseKey } = require('./protocol/keyParser.js');
+const Protocol = require('./protocol/Protocol.js');
+const { SFTP } = require('./protocol/SFTP.js');
+const { writeUInt32BE } = require('./protocol/utils.js');
+
+const {
+  Channel,
+  MAX_WINDOW,
+  PACKET_SIZE,
+  windowAdjust,
+  WINDOW_THRESHOLD,
+} = require('./Channel.js');
+
+const {
+  ChannelManager,
+  generateAlgorithmList,
+  isWritable,
+  onChannelOpenFailure,
+  onCHANNEL_CLOSE,
+} = require('./utils.js');
+
+const MAX_PENDING_AUTHS = 10;
+
+class AuthContext extends EventEmitter {
+  constructor(protocol, username, service, method, cb) {
+    super();
+
+    this.username = this.user = username;
+    this.service = service;
+    this.method = method;
+    this._initialResponse = false;
+    this._finalResponse = false;
+    this._multistep = false;
+    this._cbfinal = (allowed, methodsLeft, isPartial) => {
+      if (!this._finalResponse) {
+        this._finalResponse = true;
+        cb(this, allowed, methodsLeft, isPartial);
+      }
+    };
+    this._protocol = protocol;
+  }
 
-  var hostKeys_ = cfg.hostKeys;
-  if (!Array.isArray(hostKeys_))
-    throw new Error('hostKeys must be an array');
-
-  var i;
-  for (i = 0; i < hostKeys_.length; ++i) {
-    var privateKey;
-    if (Buffer.isBuffer(hostKeys_[i]) || typeof hostKeys_[i] === 'string')
-      privateKey = parseKey(hostKeys_[i]);
-    else
-      privateKey = parseKey(hostKeys_[i].key, hostKeys_[i].passphrase);
-    if (privateKey instanceof Error)
-      throw new Error('Cannot parse privateKey: ' + privateKey.message);
-    if (Array.isArray(privateKey))
-      privateKey = privateKey[0]; // OpenSSH's newer format only stores 1 key for now
-    if (privateKey.getPrivatePEM() === null)
-      throw new Error('privateKey value contains an invalid private key');
-    if (hostKeys[privateKey.type])
-      continue;
-    hostKeys[privateKey.type] = privateKey;
+  accept() {
+    this._cleanup && this._cleanup();
+    this._initialResponse = true;
+    this._cbfinal(true);
   }
+  reject(methodsLeft, isPartial) {
+    this._cleanup && this._cleanup();
+    this._initialResponse = true;
+    this._cbfinal(false, methodsLeft, isPartial);
+  }
+}
 
-  var algorithms = {
-    kex: undefined,
-    kexBuf: undefined,
-    cipher: undefined,
-    cipherBuf: undefined,
-    serverHostKey: undefined,
-    serverHostKeyBuf: undefined,
-    hmac: undefined,
-    hmacBuf: undefined,
-    compress: undefined,
-    compressBuf: undefined
-  };
-  if (typeof cfg.algorithms === 'object' && cfg.algorithms !== null) {
-    var algosSupported;
-    var algoList;
-
-    algoList = cfg.algorithms.kex;
-    if (Array.isArray(algoList) && algoList.length > 0) {
-      algosSupported = ALGORITHMS.SUPPORTED_KEX;
-      for (i = 0; i < algoList.length; ++i) {
-        if (algosSupported.indexOf(algoList[i]) === -1)
-          throw new Error('Unsupported key exchange algorithm: ' + algoList[i]);
-      }
-      algorithms.kex = algoList;
-    }
 
-    algoList = cfg.algorithms.cipher;
-    if (Array.isArray(algoList) && algoList.length > 0) {
-      algosSupported = ALGORITHMS.SUPPORTED_CIPHER;
-      for (i = 0; i < algoList.length; ++i) {
-        if (algosSupported.indexOf(algoList[i]) === -1)
-          throw new Error('Unsupported cipher algorithm: ' + algoList[i]);
-      }
-      algorithms.cipher = algoList;
-    }
+class KeyboardAuthContext extends AuthContext {
+  constructor(protocol, username, service, method, submethods, cb) {
+    super(protocol, username, service, method, cb);
 
-    algoList = cfg.algorithms.serverHostKey;
-    var copied = false;
-    if (Array.isArray(algoList) && algoList.length > 0) {
-      algosSupported = ALGORITHMS.SUPPORTED_SERVER_HOST_KEY;
-      for (i = algoList.length - 1; i >= 0; --i) {
-        if (algosSupported.indexOf(algoList[i]) === -1) {
-          throw new Error('Unsupported server host key algorithm: '
-                           + algoList[i]);
-        }
-        if (!hostKeys[algoList[i]]) {
-          // Silently discard for now
-          if (!copied) {
-            algoList = algoList.slice();
-            copied = true;
-          }
-          algoList.splice(i, 1);
-        }
-      }
-      if (algoList.length > 0)
-        algorithms.serverHostKey = algoList;
-    }
+    this._multistep = true;
 
-    algoList = cfg.algorithms.hmac;
-    if (Array.isArray(algoList) && algoList.length > 0) {
-      algosSupported = ALGORITHMS.SUPPORTED_HMAC;
-      for (i = 0; i < algoList.length; ++i) {
-        if (algosSupported.indexOf(algoList[i]) === -1)
-          throw new Error('Unsupported HMAC algorithm: ' + algoList[i]);
+    this._cb = undefined;
+    this._onInfoResponse = (responses) => {
+      const callback = this._cb;
+      if (callback) {
+        this._cb = undefined;
+        callback(responses);
       }
-      algorithms.hmac = algoList;
+    };
+    this.submethods = submethods;
+    this.on('abort', () => {
+      this._cb && this._cb(new Error('Authentication request aborted'));
+    });
+  }
+
+  prompt(prompts, title, instructions, cb) {
+    if (!Array.isArray(prompts))
+      prompts = [ prompts ];
+
+    if (typeof title === 'function') {
+      cb = title;
+      title = instructions = undefined;
+    } else if (typeof instructions === 'function') {
+      cb = instructions;
+      instructions = undefined;
+    } else if (typeof cb !== 'function') {
+      cb = undefined;
     }
 
-    algoList = cfg.algorithms.compress;
-    if (Array.isArray(algoList) && algoList.length > 0) {
-      algosSupported = ALGORITHMS.SUPPORTED_COMPRESS;
-      for (i = 0; i < algoList.length; ++i) {
-        if (algosSupported.indexOf(algoList[i]) === -1)
-          throw new Error('Unsupported compression algorithm: ' + algoList[i]);
+    for (let i = 0; i < prompts.length; ++i) {
+      if (typeof prompts[i] === 'string') {
+        prompts[i] = {
+          prompt: prompts[i],
+          echo: true
+        };
       }
-      algorithms.compress = algoList;
     }
+
+    this._cb = cb;
+    this._initialResponse = true;
+
+    this._protocol.authInfoReq(title, instructions, prompts);
   }
+}
 
-  // Make sure we at least have some kind of valid list of support key
-  // formats
-  if (algorithms.serverHostKey === undefined) {
-    var hostKeyAlgos = Object.keys(hostKeys);
-    for (i = hostKeyAlgos.length - 1; i >= 0; --i) {
-      if (!hostKeys[hostKeyAlgos[i]])
-        hostKeyAlgos.splice(i, 1);
-    }
-    algorithms.serverHostKey = hostKeyAlgos;
+class PKAuthContext extends AuthContext {
+  constructor(protocol, username, service, method, pkInfo, cb) {
+    super(protocol, username, service, method, cb);
+
+    this.key = { algo: pkInfo.keyAlgo, data: pkInfo.key };
+    this.signature = pkInfo.signature;
+    this.blob = pkInfo.blob;
   }
 
-  if (!kaMgr
-      && Server.KEEPALIVE_INTERVAL > 0
-      && Server.KEEPALIVE_CLIENT_INTERVAL > 0
-      && Server.KEEPALIVE_CLIENT_COUNT_MAX >= 0) {
-    kaMgr = new KeepaliveManager(Server.KEEPALIVE_INTERVAL,
-                                 Server.KEEPALIVE_CLIENT_INTERVAL,
-                                 Server.KEEPALIVE_CLIENT_COUNT_MAX);
+  accept() {
+    if (!this.signature) {
+      this._initialResponse = true;
+      this._protocol.authPKOK(this.key.algo, this.key.data);
+    } else {
+      AuthContext.prototype.accept.call(this);
+    }
   }
+}
 
-  var self = this;
+class HostbasedAuthContext extends AuthContext {
+  constructor(protocol, username, service, method, pkInfo, cb) {
+    super(protocol, username, service, method, cb);
 
-  EventEmitter.call(this);
+    this.key = { algo: pkInfo.keyAlgo, data: pkInfo.key };
+    this.signature = pkInfo.signature;
+    this.blob = pkInfo.blob;
+    this.localHostname = pkInfo.localHostname;
+    this.localUsername = pkInfo.localUsername;
+  }
+}
 
-  if (typeof listener === 'function')
-    self.on('connection', listener);
+class PwdAuthContext extends AuthContext {
+  constructor(protocol, username, service, method, password, cb) {
+    super(protocol, username, service, method, cb);
 
-  var streamcfg = {
-    algorithms: algorithms,
-    hostKeys: hostKeys,
-    server: true
-  };
-  var keys;
-  var len;
-  for (i = 0, keys = Object.keys(cfg), len = keys.length; i < len; ++i) {
-    var key = keys[i];
-    if (key === 'privateKey'
-        || key === 'publicKey'
-        || key === 'passphrase'
-        || key === 'algorithms'
-        || key === 'hostKeys'
-        || key === 'server') {
-      continue;
-    }
-    streamcfg[key] = cfg[key];
+    this.password = password;
+    this._changeCb = undefined;
   }
 
-  if (typeof streamcfg.debug === 'function') {
-    var oldDebug = streamcfg.debug;
-    var cfgKeys = Object.keys(streamcfg);
+  requestChange(prompt, cb) {
+    if (this._changeCb)
+      throw new Error('Change request already in progress');
+    if (typeof prompt !== 'string')
+      throw new Error('prompt argument must be a string');
+    if (typeof cb !== 'function')
+      throw new Error('Callback argument must be a function');
+    this._changeCb = cb;
+    this._protocol.authPasswdChg(prompt);
   }
+}
 
-  this._srv = new net.Server(function(socket) {
-    if (self._connections >= self.maxConnections) {
-      socket.destroy();
-      return;
-    }
-    ++self._connections;
-    socket.once('close', function(had_err) {
-      --self._connections;
-
-      // since joyent/node#993bb93e0a, we have to "read past EOF" in order to
-      // get an `end` event on streams. thankfully adding this does not
-      // negatively affect node versions pre-joyent/node#993bb93e0a.
-      sshstream.read();
-    }).on('error', function(err) {
-      sshstream.reset();
-      sshstream.emit('error', err);
-    });
 
-    var conncfg = streamcfg;
+class Session extends EventEmitter {
+  constructor(client, info, localChan) {
+    super();
 
-    // prepend debug output with a unique identifier in case there are multiple
-    // clients connected at the same time
-    if (oldDebug) {
-      conncfg = {};
-      for (var i = 0, key; i < cfgKeys.length; ++i) {
-        key = cfgKeys[i];
-        conncfg[key] = streamcfg[key];
+    this.type = 'session';
+    this.subtype = undefined;
+    this.server = true;
+    this._ending = false;
+    this._channel = undefined;
+    this._chanInfo = {
+      type: 'session',
+      incoming: {
+        id: localChan,
+        window: MAX_WINDOW,
+        packetSize: PACKET_SIZE,
+        state: 'open'
+      },
+      outgoing: {
+        id: info.sender,
+        window: info.window,
+        packetSize: info.packetSize,
+        state: 'open'
       }
-      var debugPrefix = '[' + process.hrtime().join('.') + '] ';
-      conncfg.debug = function(msg) {
-        oldDebug(debugPrefix + msg);
-      };
-    }
-
-    var sshstream = new SSH2Stream(conncfg);
-    var client = new Client(sshstream, socket);
-
-    socket.pipe(sshstream).pipe(socket);
+    };
+  }
+}
 
-    // silence pre-header errors
-    function onClientPreHeaderError(err) {}
-    client.on('error', onClientPreHeaderError);
 
-    sshstream.once('header', function(header) {
-      if (sshstream._readableState.ended) {
-        // already disconnected internally in SSH2Stream due to incompatible
-        // protocol version
-        return;
-      } else if (!listenerCount(self, 'connection')) {
-        // auto reject
-        return sshstream.disconnect(DISCONNECT_REASON.BY_APPLICATION);
+class Server extends EventEmitter {
+  constructor(cfg, listener) {
+    super();
+
+    if (typeof cfg !== 'object' || cfg === null)
+      throw new Error('Missing configuration object');
+
+    const hostKeys = Object.create(null);
+    const hostKeyAlgoOrder = [];
+
+    const hostKeys_ = cfg.hostKeys;
+    if (!Array.isArray(hostKeys_))
+      throw new Error('hostKeys must be an array');
+
+    const cfgAlgos = (
+      typeof cfg.algorithms === 'object' && cfg.algorithms !== null
+      ? cfg.algorithms
+      : {}
+    );
+
+    const hostKeyAlgos = generateAlgorithmList(
+      cfgAlgos.serverHostKey,
+      DEFAULT_SERVER_HOST_KEY,
+      SUPPORTED_SERVER_HOST_KEY
+    );
+    for (let i = 0; i < hostKeys_.length; ++i) {
+      let privateKey;
+      if (Buffer.isBuffer(hostKeys_[i]) || typeof hostKeys_[i] === 'string')
+        privateKey = parseKey(hostKeys_[i]);
+      else
+        privateKey = parseKey(hostKeys_[i].key, hostKeys_[i].passphrase);
+
+      if (privateKey instanceof Error)
+        throw new Error(`Cannot parse privateKey: ${privateKey.message}`);
+
+      if (Array.isArray(privateKey)) {
+        // OpenSSH's newer format only stores 1 key for now
+        privateKey = privateKey[0];
       }
 
-      client.removeListener('error', onClientPreHeaderError);
+      if (privateKey.getPrivatePEM() === null)
+        throw new Error('privateKey value contains an invalid private key');
+
+      // Discard key if we already found a key of the same type
+      if (hostKeyAlgoOrder.includes(privateKey.type))
+        continue;
+
+      if (privateKey.type === 'ssh-rsa') {
+        // SSH supports multiple signature hashing algorithms for RSA, so we add
+        // the algorithms in the desired order
+        let sha1Pos = hostKeyAlgos.indexOf('ssh-rsa');
+        const sha256Pos = hostKeyAlgos.indexOf('rsa-sha2-256');
+        const sha512Pos = hostKeyAlgos.indexOf('rsa-sha2-512');
+        if (sha1Pos === -1) {
+          // Fall back to giving SHA1 the lowest priority
+          sha1Pos = Infinity;
+        }
+        [sha1Pos, sha256Pos, sha512Pos].sort(compareNumbers).forEach((pos) => {
+          if (pos === -1)
+            return;
 
-      self.emit('connection',
-                client,
-                { ip: socket.remoteAddress,
-                  family: socket.remoteFamily,
-                  port: socket.remotePort,
-                  header: header });
-    });
-  }).on('error', function(err) {
-    self.emit('error', err);
-  }).on('listening', function() {
-    self.emit('listening');
-  }).on('close', function() {
-    self.emit('close');
-  });
-  this._connections = 0;
-  this.maxConnections = Infinity;
-}
-inherits(Server, EventEmitter);
-
-Server.prototype.listen = function() {
-  this._srv.listen.apply(this._srv, arguments);
-  return this;
-};
-
-Server.prototype.address = function() {
-  return this._srv.address();
-};
-
-Server.prototype.getConnections = function(cb) {
-  this._srv.getConnections(cb);
-};
-
-Server.prototype.close = function(cb) {
-  this._srv.close(cb);
-  return this;
-};
-
-Server.prototype.ref = function() {
-  this._srv.ref();
-};
-
-Server.prototype.unref = function() {
-  this._srv.unref();
-};
-
-
-function Client(stream, socket) {
-  EventEmitter.call(this);
-
-  var self = this;
-
-  this._sshstream = stream;
-  var channels = this._channels = {};
-  this._curChan = -1;
-  this._sock = socket;
-  this.noMoreSessions = false;
-  this.authenticated = false;
-
-  stream.on('end', function() {
-    socket.resume();
-    self.emit('end');
-  }).on('close', function(hasErr) {
-    self.emit('close', hasErr);
-  }).on('error', function(err) {
-    self.emit('error', err);
-  }).on('drain', function() {
-    self.emit('drain');
-  }).on('continue', function() {
-    self.emit('continue');
-  });
-
-  var exchanges = 0;
-  var acceptedAuthSvc = false;
-  var pendingAuths = [];
-  var authCtx;
-
-  // begin service/auth-related ================================================
-  stream.on('SERVICE_REQUEST', function(service) {
-    if (exchanges === 0
-        || acceptedAuthSvc
-        || self.authenticated
-        || service !== 'ssh-userauth')
-      return stream.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
-
-    acceptedAuthSvc = true;
-    stream.serviceAccept(service);
-  }).on('USERAUTH_REQUEST', onUSERAUTH_REQUEST);
-  function onUSERAUTH_REQUEST(username, service, method, methodData) {
-    if (exchanges === 0
-        || (authCtx
-            && (authCtx.username !== username || authCtx.service !== service))
-          // TODO: support hostbased auth
-        || (method !== 'password'
-            && method !== 'publickey'
-            && method !== 'hostbased'
-            && method !== 'keyboard-interactive'
-            && method !== 'none')
-        || pendingAuths.length === MAX_PENDING_AUTHS)
-      return stream.disconnect(DISCONNECT_REASON.PROTOCOL_ERROR);
-    else if (service !== 'ssh-connection')
-      return stream.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
-
-    // XXX: this really shouldn't be reaching into private state ...
-    stream._state.authMethod = method;
-
-    var ctx;
-    if (method === 'keyboard-interactive') {
-      ctx = new KeyboardAuthContext(stream, username, service, method,
-                                    methodData, onAuthDecide);
-    } else if (method === 'publickey') {
-      ctx = new PKAuthContext(stream, username, service, method, methodData,
-                              onAuthDecide);
-    } else if (method === 'hostbased') {
-      ctx = new HostbasedAuthContext(stream, username, service, method,
-                                     methodData, onAuthDecide);
-    } else if (method === 'password') {
-      ctx = new PwdAuthContext(stream, username, service, method, methodData,
-                               onAuthDecide);
-    } else if (method === 'none')
-      ctx = new AuthContext(stream, username, service, method, onAuthDecide);
-
-    if (authCtx) {
-      if (!authCtx._initialResponse)
-        return pendingAuths.push(ctx);
-      else if (authCtx._multistep && !this._finalResponse) {
-        // RFC 4252 says to silently abort the current auth request if a new
-        // auth request comes in before the final response from an auth method
-        // that requires additional request/response exchanges -- this means
-        // keyboard-interactive for now ...
-        authCtx._cleanup && authCtx._cleanup();
-        authCtx.emit('abort');
-      }
-    }
+          let type;
+          switch (pos) {
+            case sha1Pos: type = 'ssh-rsa'; break;
+            case sha256Pos: type = 'rsa-sha2-256'; break;
+            case sha512Pos: type = 'rsa-sha2-512'; break;
+            default: return;
+          }
 
-    authCtx = ctx;
+          // Store same RSA key under each hash algorithm name for convenience
+          hostKeys[type] = privateKey;
 
-    if (listenerCount(self, 'authentication'))
-      self.emit('authentication', authCtx);
-    else
-      authCtx.reject();
-  }
-  function onAuthDecide(ctx, allowed, methodsLeft, isPartial) {
-    if (authCtx === ctx && !self.authenticated) {
-      if (allowed) {
-        stream.removeListener('USERAUTH_REQUEST', onUSERAUTH_REQUEST);
-        authCtx = undefined;
-        self.authenticated = true;
-        stream.authSuccess();
-        pendingAuths = [];
-        self.emit('ready');
+          hostKeyAlgoOrder.push(type);
+        });
       } else {
-        stream.authFailure(methodsLeft, isPartial);
-        if (pendingAuths.length) {
-          authCtx = pendingAuths.pop();
-          if (listenerCount(self, 'authentication'))
-            self.emit('authentication', authCtx);
-          else
-            authCtx.reject();
-        }
+        hostKeys[privateKey.type] = privateKey;
+        hostKeyAlgoOrder.push(privateKey.type);
       }
     }
-  }
-  // end service/auth-related ==================================================
-
-  var unsentGlobalRequestsReplies = [];
-
-  function sendReplies() {
-    var reply;
-    while (unsentGlobalRequestsReplies.length > 0
-           && unsentGlobalRequestsReplies[0].type) {
-      reply = unsentGlobalRequestsReplies.shift();
-      if (reply.type === 'SUCCESS')
-        stream.requestSuccess(reply.buf);
-      if (reply.type === 'FAILURE')
-        stream.requestFailure();
-    }
-  }
 
-  stream.on('GLOBAL_REQUEST', function(name, wantReply, data) {
-    var reply = {
-      type: null,
-      buf: null
+    const algorithms = {
+      kex: generateAlgorithmList(cfgAlgos.kex, DEFAULT_KEX, SUPPORTED_KEX),
+      serverHostKey: hostKeyAlgoOrder,
+      cs: {
+        cipher: generateAlgorithmList(
+                  cfgAlgos.cipher,
+                  DEFAULT_CIPHER,
+                  SUPPORTED_CIPHER
+                ),
+        mac: generateAlgorithmList(cfgAlgos.hmac, DEFAULT_MAC, SUPPORTED_MAC),
+        compress: generateAlgorithmList(
+                    cfgAlgos.compress,
+                    DEFAULT_COMPRESSION,
+                    SUPPORTED_COMPRESSION
+                  ),
+        lang: [],
+      },
+      sc: undefined,
     };
+    algorithms.sc = algorithms.cs;
 
-    function setReply(type, buf) {
-      reply.type = type;
-      reply.buf = buf;
-      sendReplies();
-    }
+    if (typeof listener === 'function')
+      this.on('connection', listener);
 
-    if (wantReply)
-      unsentGlobalRequestsReplies.push(reply);
-
-    if ((name === 'tcpip-forward'
-         || name === 'cancel-tcpip-forward'
-         || name === 'no-more-sessions@openssh.com'
-         || name === 'streamlocal-forward@openssh.com'
-         || name === 'cancel-streamlocal-forward@openssh.com')
-        && listenerCount(self, 'request')
-        && self.authenticated) {
-      var accept;
-      var reject;
-
-      if (wantReply) {
-        var replied = false;
-        accept = function(chosenPort) {
-          if (replied)
-            return;
-          replied = true;
-          var bufPort;
-          if (name === 'tcpip-forward'
-              && data.bindPort === 0
-              && typeof chosenPort === 'number') {
-            bufPort = Buffer.allocUnsafe(4);
-            writeUInt32BE(bufPort, chosenPort, 0);
-          }
-          setReply('SUCCESS', bufPort);
-        };
-        reject = function() {
-          if (replied)
-            return;
-          replied = true;
-          setReply('FAILURE');
-        };
-      }
+    const origDebug = (typeof cfg.debug === 'function' ? cfg.debug : undefined);
+    const ident = (cfg.ident ? Buffer.from(cfg.ident) : undefined);
+    const offer = new KexInit(algorithms);
 
-      if (name === 'no-more-sessions@openssh.com') {
-        self.noMoreSessions = true;
-        accept && accept();
+    this._srv = new netServer((socket) => {
+      if (this._connections >= this.maxConnections) {
+        socket.destroy();
         return;
       }
+      ++this._connections;
+      socket.once('close', () => {
+        --this._connections;
+      });
 
-      self.emit('request', accept, reject, name, data);
-    } else if (wantReply)
-      setReply('FAILURE');
-  });
-
-  stream.on('CHANNEL_OPEN', function(info) {
-    // do early reject in some cases to prevent wasteful channel allocation
-    if ((info.type === 'session' && self.noMoreSessions)
-        || !self.authenticated) {
-      var reasonCode = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
-      return stream.channelOpenFail(info.sender, reasonCode);
-    }
+      let debug;
+      if (origDebug) {
+        // Prepend debug output with a unique identifier in case there are
+        // multiple clients connected at the same time
+        const debugPrefix = `[${process.hrtime().join('.')}] `;
+        debug = (msg) => {
+          origDebug(`${debugPrefix}${msg}`);
+        };
+      }
 
-    var localChan = nextChannel(self);
-    var accept;
-    var reject;
-    var replied = false;
-    if (localChan === false) {
-      // auto-reject due to no channels available
-      return stream.channelOpenFail(info.sender,
-                                    CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE);
-    }
+      // eslint-disable-next-line no-use-before-define
+      new Client(socket, hostKeys, ident, offer, debug, this, cfg);
+    }).on('error', (err) => {
+      this.emit('error', err);
+    }).on('listening', () => {
+      this.emit('listening');
+    }).on('close', () => {
+      this.emit('close');
+    });
+    this._connections = 0;
+    this.maxConnections = Infinity;
+  }
 
-    // be optimistic, reserve channel to prevent another request from trying to
-    // take the same channel
-    channels[localChan] = true;
+  injectSocket(socket) {
+    this._srv.emit('connection', socket);
+  }
 
-    reject = function() {
-      if (replied)
-        return;
+  listen(...args) {
+    this._srv.listen(...args);
+    return this;
+  }
 
-      replied = true;
+  address() {
+    return this._srv.address();
+  }
 
-      delete channels[localChan];
+  getConnections(cb) {
+    this._srv.getConnections(cb);
+    return this;
+  }
 
-      var reasonCode = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
-      return stream.channelOpenFail(info.sender, reasonCode);
-    };
+  close(cb) {
+    this._srv.close(cb);
+    return this;
+  }
 
-    switch (info.type) {
-      case 'session':
-        if (listenerCount(self, 'session')) {
-          accept = function() {
-            if (replied)
-              return;
+  ref() {
+    this._srv.ref();
+    return this;
+  }
 
-            replied = true;
+  unref() {
+    this._srv.unref();
+    return this;
+  }
+}
+Server.KEEPALIVE_CLIENT_INTERVAL = 15000;
+Server.KEEPALIVE_CLIENT_COUNT_MAX = 3;
 
-            stream.channelOpenConfirm(info.sender,
-                                      localChan,
-                                      Channel.MAX_WINDOW,
-                                      Channel.PACKET_SIZE);
 
-            return new Session(self, info, localChan);
-          };
+class Client extends EventEmitter {
+  constructor(socket, hostKeys, ident, offer, debug, server, srvCfg) {
+    super();
+
+    let exchanges = 0;
+    let acceptedAuthSvc = false;
+    let pendingAuths = [];
+    let authCtx;
+    let kaTimer;
+    let onPacket;
+    const unsentGlobalRequestsReplies = [];
+    this._sock = socket;
+    this._chanMgr = new ChannelManager(this);
+    this._debug = debug;
+    this.noMoreSessions = false;
+    this.authenticated = false;
+
+    // Silence pre-header errors
+    function onClientPreHeaderError(err) {}
+    this.on('error', onClientPreHeaderError);
 
-          self.emit('session', accept, reject);
-        } else
-          reject();
-      break;
-      case 'direct-tcpip':
-        if (listenerCount(self, 'tcpip')) {
-          accept = function() {
-            if (replied)
-              return;
+    const DEBUG_HANDLER = (!debug ? undefined : (p, display, msg) => {
+      debug(`Debug output from client: ${JSON.stringify(msg)}`);
+    });
 
-            replied = true;
+    const kaIntvl = (
+      typeof srvCfg.keepaliveInterval === 'number'
+        && isFinite(srvCfg.keepaliveInterval)
+        && srvCfg.keepaliveInterval > 0
+      ? srvCfg.keepaliveInterval
+      : (
+        typeof Server.KEEPALIVE_CLIENT_INTERVAL === 'number'
+          && isFinite(Server.KEEPALIVE_CLIENT_INTERVAL)
+          && Server.KEEPALIVE_CLIENT_INTERVAL > 0
+        ? Server.KEEPALIVE_CLIENT_INTERVAL
+        : -1
+      )
+    );
+    const kaCountMax = (
+      typeof srvCfg.keepaliveCountMax === 'number'
+        && isFinite(srvCfg.keepaliveCountMax)
+        && srvCfg.keepaliveCountMax >= 0
+      ? srvCfg.keepaliveCountMax
+      : (
+        typeof Server.KEEPALIVE_CLIENT_COUNT_MAX === 'number'
+          && isFinite(Server.KEEPALIVE_CLIENT_COUNT_MAX)
+          && Server.KEEPALIVE_CLIENT_COUNT_MAX >= 0
+        ? Server.KEEPALIVE_CLIENT_COUNT_MAX
+        : -1
+      )
+    );
+    let kaCurCount = 0;
+    if (kaIntvl !== -1 && kaCountMax !== -1) {
+      this.once('ready', () => {
+        const onClose = () => {
+          clearInterval(kaTimer);
+        };
+        this.on('close', onClose).on('end', onClose);
+        kaTimer = setInterval(() => {
+          if (++kaCurCount > kaCountMax) {
+            clearInterval(kaTimer);
+            const err = new Error('Keepalive timeout');
+            err.level = 'client-timeout';
+            this.emit('error', err);
+            this.end();
+          } else {
+            // XXX: if the server ever starts sending real global requests to
+            //      the client, we will need to add a dummy callback here to
+            //      keep the correct reply order
+            proto.ping();
+          }
+        }, kaIntvl);
+      });
+      // TODO: re-verify keepalive behavior with OpenSSH
+      onPacket = () => {
+        kaTimer && kaTimer.refresh();
+        kaCurCount = 0;
+      };
+    }
 
-            stream.channelOpenConfirm(info.sender,
-                                      localChan,
-                                      Channel.MAX_WINDOW,
-                                      Channel.PACKET_SIZE);
-
-            var chaninfo = {
-              type: undefined,
-              incoming: {
-                id: localChan,
-                window: Channel.MAX_WINDOW,
-                packetSize: Channel.PACKET_SIZE,
-                state: 'open'
-              },
-              outgoing: {
-                id: info.sender,
-                window: info.window,
-                packetSize: info.packetSize,
-                state: 'open'
-              }
-            };
+    const proto = this._protocol = new Protocol({
+      server: true,
+      hostKeys,
+      ident,
+      offer,
+      onPacket,
+      greeting: srvCfg.greeting,
+      banner: srvCfg.banner,
+      onWrite: (data) => {
+        if (isWritable(socket))
+          socket.write(data);
+      },
+      onError: (err) => {
+        if (!proto._destruct)
+          socket.removeAllListeners('data');
+        this.emit('error', err);
+        try {
+          socket.end();
+        } catch {}
+      },
+      onHeader: (header) => {
+        this.removeListener('error', onClientPreHeaderError);
+
+        const info = {
+          ip: socket.remoteAddress,
+          family: socket.remoteFamily,
+          port: socket.remotePort,
+          header,
+        };
+        if (!server.emit('connection', this, info)) {
+          // auto reject
+          proto.disconnect(DISCONNECT_REASON.BY_APPLICATION);
+          socket.end();
+          return;
+        }
 
-            return new Channel(chaninfo, self);
-          };
+        if (header.greeting)
+          this.emit('greeting', header.greeting);
+      },
+      onHandshakeComplete: (negotiated) => {
+        if (++exchanges > 1)
+          this.emit('rekey');
+        this.emit('handshake', negotiated);
+      },
+      debug,
+      messageHandlers: {
+        DEBUG: DEBUG_HANDLER,
+        DISCONNECT: (p, reason, desc) => {
+          if (reason !== DISCONNECT_REASON.BY_APPLICATION) {
+            if (!desc) {
+              desc = DISCONNECT_REASON_BY_VALUE[reason];
+              if (desc === undefined)
+                desc = `Unexpected disconnection reason: ${reason}`;
+            }
+            const err = new Error(desc);
+            err.code = reason;
+            this.emit('error', err);
+          }
+          socket.end();
+        },
+        CHANNEL_OPEN: (p, info) => {
+          // Handle incoming requests from client
+
+          // Do early reject in some cases to prevent wasteful channel
+          // allocation
+          if ((info.type === 'session' && this.noMoreSessions)
+              || !this.authenticated) {
+            const reasonCode = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
+            return proto.channelOpenFail(info.sender, reasonCode);
+          }
 
-          self.emit('tcpip', accept, reject, info.data);
-        } else
-          reject();
-      break;
-      case 'direct-streamlocal@openssh.com':
-        if (listenerCount(self, 'openssh.streamlocal')) {
-          accept = function() {
+          let localChan = -1;
+          let reason;
+          let replied = false;
+
+          let accept;
+          const reject = () => {
             if (replied)
               return;
-
             replied = true;
 
-            stream.channelOpenConfirm(info.sender,
-                                      localChan,
-                                      Channel.MAX_WINDOW,
-                                      Channel.PACKET_SIZE);
-
-            var chaninfo = {
-              type: undefined,
-              incoming: {
-                id: localChan,
-                window: Channel.MAX_WINDOW,
-                packetSize: Channel.PACKET_SIZE,
-                state: 'open'
-              },
-              outgoing: {
-                id: info.sender,
-                window: info.window,
-                packetSize: info.packetSize,
-                state: 'open'
+            if (reason === undefined) {
+              if (localChan === -1)
+                reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;
+              else
+                reason = CHANNEL_OPEN_FAILURE.CONNECT_FAILED;
+            }
+
+            if (localChan !== -1)
+              this._chanMgr.remove(localChan);
+            proto.channelOpenFail(info.sender, reason, '');
+          };
+          const reserveChannel = () => {
+            localChan = this._chanMgr.add();
+
+            if (localChan === -1) {
+              reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;
+              if (debug) {
+                debug('Automatic rejection of incoming channel open: '
+                        + 'no channels available');
               }
-            };
+            }
 
-            return new Channel(chaninfo, self);
+            return (localChan !== -1);
           };
 
-          self.emit('openssh.streamlocal', accept, reject, info.data);
-        } else
-          reject();
-      break;
-      default:
-        // auto-reject unsupported channel types
-        reject();
-    }
-  });
+          const data = info.data;
+          switch (info.type) {
+            case 'session':
+              if (listenerCount(this, 'session') && reserveChannel()) {
+                accept = () => {
+                  if (replied)
+                    return;
+                  replied = true;
 
-  stream.on('NEWKEYS', function() {
-    if (++exchanges > 1)
-      self.emit('rekey');
-  });
+                  const instance = new Session(this, info, localChan);
+                  this._chanMgr.update(localChan, instance);
 
-  if (kaMgr) {
-    this.once('ready', function() {
-      kaMgr.add(stream);
-    });
-  }
-}
-inherits(Client, EventEmitter);
+                  proto.channelOpenConfirm(info.sender,
+                                           localChan,
+                                           MAX_WINDOW,
+                                           PACKET_SIZE);
 
-Client.prototype.end = function() {
-  return this._sshstream.disconnect(DISCONNECT_REASON.BY_APPLICATION);
-};
+                  return instance;
+                };
 
-Client.prototype.x11 = function(originAddr, originPort, cb) {
-  var opts = {
-    originAddr: originAddr,
-    originPort: originPort
-  };
-  return openChannel(this, 'x11', opts, cb);
-};
-
-Client.prototype.forwardOut = function(boundAddr, boundPort, remoteAddr,
-                                       remotePort, cb) {
-  var opts = {
-    boundAddr: boundAddr,
-    boundPort: boundPort,
-    remoteAddr: remoteAddr,
-    remotePort: remotePort
-  };
-  return openChannel(this, 'forwarded-tcpip', opts, cb);
-};
+                this.emit('session', accept, reject);
+                return;
+              }
+              break;
+            case 'direct-tcpip':
+              if (listenerCount(this, 'tcpip') && reserveChannel()) {
+                accept = () => {
+                  if (replied)
+                    return;
+                  replied = true;
+
+                  const chanInfo = {
+                    type: undefined,
+                    incoming: {
+                      id: localChan,
+                      window: MAX_WINDOW,
+                      packetSize: PACKET_SIZE,
+                      state: 'open'
+                    },
+                    outgoing: {
+                      id: info.sender,
+                      window: info.window,
+                      packetSize: info.packetSize,
+                      state: 'open'
+                    }
+                  };
+
+                  const stream = new Channel(this, chanInfo, { server: true });
+                  this._chanMgr.update(localChan, stream);
+
+                  proto.channelOpenConfirm(info.sender,
+                                           localChan,
+                                           MAX_WINDOW,
+                                           PACKET_SIZE);
+
+                  return stream;
+                };
+
+                this.emit('tcpip', accept, reject, data);
+                return;
+              }
+              break;
+            case 'direct-streamlocal@openssh.com':
+              if (listenerCount(this, 'openssh.streamlocal')
+                  && reserveChannel()) {
+                accept = () => {
+                  if (replied)
+                    return;
+                  replied = true;
+
+                  const chanInfo = {
+                    type: undefined,
+                    incoming: {
+                      id: localChan,
+                      window: MAX_WINDOW,
+                      packetSize: PACKET_SIZE,
+                      state: 'open'
+                    },
+                    outgoing: {
+                      id: info.sender,
+                      window: info.window,
+                      packetSize: info.packetSize,
+                      state: 'open'
+                    }
+                  };
+
+                  const stream = new Channel(this, chanInfo, { server: true });
+                  this._chanMgr.update(localChan, stream);
+
+                  proto.channelOpenConfirm(info.sender,
+                                           localChan,
+                                           MAX_WINDOW,
+                                           PACKET_SIZE);
+
+                  return stream;
+                };
+
+                this.emit('openssh.streamlocal', accept, reject, data);
+                return;
+              }
+              break;
+            default:
+              // Automatically reject any unsupported channel open requests
+              reason = CHANNEL_OPEN_FAILURE.UNKNOWN_CHANNEL_TYPE;
+              if (debug) {
+                debug('Automatic rejection of unsupported incoming channel open'
+                        + ` type: ${info.type}`);
+              }
+          }
 
-Client.prototype.openssh_forwardOutStreamLocal = function(socketPath, cb) {
-  var opts = {
-    socketPath: socketPath
-  };
-  return openChannel(this, 'forwarded-streamlocal@openssh.com', opts, cb);
-};
-
-Client.prototype.rekey = function(cb) {
-  var stream = this._sshstream;
-  var ret = true;
-  var error;
-
-  try {
-    ret = stream.rekey();
-  } catch (ex) {
-    error = ex;
-  }
+          if (reason === undefined) {
+            reason = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
+            if (debug) {
+              debug('Automatic rejection of unexpected incoming channel open'
+                      + ` for: ${info.type}`);
+            }
+          }
 
-  // TODO: re-throw error if no callback?
+          reject();
+        },
+        CHANNEL_OPEN_CONFIRMATION: (p, info) => {
+          const channel = this._chanMgr.get(info.recipient);
+          if (typeof channel !== 'function')
+            return;
 
-  if (typeof cb === 'function') {
-    if (error) {
-      process.nextTick(function() {
-        cb(error);
-      });
-    } else
-      this.once('rekey', cb);
-  }
+          const chanInfo = {
+            type: channel.type,
+            incoming: {
+              id: info.recipient,
+              window: MAX_WINDOW,
+              packetSize: PACKET_SIZE,
+              state: 'open'
+            },
+            outgoing: {
+              id: info.sender,
+              window: info.window,
+              packetSize: info.packetSize,
+              state: 'open'
+            }
+          };
 
-  return ret;
-};
-
-function Session(client, info, localChan) {
-  this.subtype = undefined;
-
-  var ending = false;
-  var self = this;
-  var outgoingId = info.sender;
-  var channel;
-
-  var chaninfo = {
-    type: 'session',
-    incoming: {
-      id: localChan,
-      window: Channel.MAX_WINDOW,
-      packetSize: Channel.PACKET_SIZE,
-      state: 'open'
-    },
-    outgoing: {
-      id: info.sender,
-      window: info.window,
-      packetSize: info.packetSize,
-      state: 'open'
-    }
-  };
+          const instance = new Channel(this, chanInfo, { server: true });
+          this._chanMgr.update(info.recipient, instance);
+          channel(undefined, instance);
+        },
+        CHANNEL_OPEN_FAILURE: (p, recipient, reason, description) => {
+          const channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'function')
+            return;
 
-  function onREQUEST(info) {
-    var replied = false;
-    var accept;
-    var reject;
-
-    if (info.wantReply) {
-      // "real session" requests will have custom accept behaviors
-      if (info.request !== 'shell'
-          && info.request !== 'exec'
-          && info.request !== 'subsystem') {
-        accept = function() {
-          if (replied || ending || channel)
+          const info = { reason, description };
+          onChannelOpenFailure(this, recipient, info, channel);
+        },
+        CHANNEL_DATA: (p, recipient, data) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
             return;
 
-          replied = true;
+          if (channel.constructor === Session) {
+            channel = channel._channel;
+            if (!channel)
+              return;
+          }
 
-          return client._sshstream.channelSuccess(outgoingId);
-        };
-      }
+          // The remote party should not be sending us data if there is no
+          // window space available ...
+          // TODO: raise error on data with not enough window?
+          if (channel.incoming.window === 0)
+            return;
 
-      reject = function() {
-        if (replied || ending || channel)
-          return;
+          channel.incoming.window -= data.length;
 
-        replied = true;
+          if (channel.push(data) === false) {
+            channel._waitChanDrain = true;
+            return;
+          }
 
-        return client._sshstream.channelFailure(outgoingId);
-      };
-    }
+          if (channel.incoming.window <= WINDOW_THRESHOLD)
+            windowAdjust(channel);
+        },
+        CHANNEL_EXTENDED_DATA: (p, recipient, data, type) => {
+          // NOOP -- should not be sent by client
+        },
+        CHANNEL_WINDOW_ADJUST: (p, recipient, amount) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
+            return;
 
-    if (ending) {
-      reject && reject();
-      return;
-    }
+          if (channel.constructor === Session) {
+            channel = channel._channel;
+            if (!channel)
+              return;
+          }
 
-    switch (info.request) {
-      // "pre-real session start" requests
-      case 'env':
-        if (listenerCount(self, 'env')) {
-          self.emit('env', accept, reject, {
-            key: info.key,
-            val: info.val
-          });
-        } else
-          reject && reject();
-      break;
-      case 'pty-req':
-        if (listenerCount(self, 'pty')) {
-          self.emit('pty', accept, reject, {
-            cols: info.cols,
-            rows: info.rows,
-            width: info.width,
-            height: info.height,
-            term: info.term,
-            modes: info.modes,
-          });
-        } else
-          reject && reject();
-      break;
-      case 'window-change':
-        if (listenerCount(self, 'window-change')) {
-          self.emit('window-change', accept, reject, {
-            cols: info.cols,
-            rows: info.rows,
-            width: info.width,
-            height: info.height
-          });
-        } else
-          reject && reject();
-      break;
-      case 'x11-req':
-        if (listenerCount(self, 'x11')) {
-          self.emit('x11', accept, reject, {
-            single: info.single,
-            protocol: info.protocol,
-            cookie: info.cookie,
-            screen: info.screen
-          });
-        } else
-          reject && reject();
-      break;
-      // "post-real session start" requests
-      case 'signal':
-        if (listenerCount(self, 'signal')) {
-          self.emit('signal', accept, reject, {
-            name: info.signal
-          });
-        } else
-          reject && reject();
-      break;
-      // XXX: is `auth-agent-req@openssh.com` really "post-real session start"?
-      case 'auth-agent-req@openssh.com':
-        if (listenerCount(self, 'auth-agent'))
-          self.emit('auth-agent', accept, reject);
-        else
-          reject && reject();
-      break;
-      // "real session start" requests
-      case 'shell':
-        if (listenerCount(self, 'shell')) {
-          accept = function() {
-            if (replied || ending || channel)
+          // The other side is allowing us to send `amount` more bytes of data
+          channel.outgoing.window += amount;
+
+          if (channel._waitWindow) {
+            channel._waitWindow = false;
+
+            if (channel._chunk) {
+              channel._write(channel._chunk, null, channel._chunkcb);
+            } else if (channel._chunkcb) {
+              channel._chunkcb();
+            } else if (channel._chunkErr) {
+              channel.stderr._write(channel._chunkErr,
+                                    null,
+                                    channel._chunkcbErr);
+            } else if (channel._chunkcbErr) {
+              channel._chunkcbErr();
+            }
+          }
+        },
+        CHANNEL_SUCCESS: (p, recipient) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
+            return;
+
+          if (channel.constructor === Session) {
+            channel = channel._channel;
+            if (!channel)
               return;
+          }
 
-            replied = true;
+          if (channel._callbacks.length)
+            channel._callbacks.shift()(false);
+        },
+        CHANNEL_FAILURE: (p, recipient) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
+            return;
 
-            if (info.wantReply)
-              client._sshstream.channelSuccess(outgoingId);
+          if (channel.constructor === Session) {
+            channel = channel._channel;
+            if (!channel)
+              return;
+          }
 
-            channel = new Channel(chaninfo, client, { server: true });
+          if (channel._callbacks.length)
+            channel._callbacks.shift()(true);
+        },
+        CHANNEL_REQUEST: (p, recipient, type, wantReply, data) => {
+          const session = this._chanMgr.get(recipient);
+          if (typeof session !== 'object' || session === null)
+            return;
 
-            channel.subtype = self.subtype = info.request;
+          let replied = false;
+          let accept;
+          let reject;
 
-            return channel;
-          };
+          if (session.constructor !== Session) {
+            // normal Channel instance
+            if (wantReply)
+              proto.channelFailure(session.outgoing.id);
+            return;
+          }
 
-          self.emit('shell', accept, reject);
-        } else
-          reject && reject();
-      break;
-      case 'exec':
-        if (listenerCount(self, 'exec')) {
-          accept = function() {
-            if (replied || ending || channel)
-              return;
+          if (wantReply) {
+            // "real session" requests will have custom accept behaviors
+            if (type !== 'shell'
+                && type !== 'exec'
+                && type !== 'subsystem') {
+              accept = () => {
+                if (replied || session._ending || session._channel)
+                  return;
+                replied = true;
+
+                proto.channelSuccess(session._chanInfo.outgoing.id);
+              };
+            }
+
+            reject = () => {
+              if (replied || session._ending || session._channel)
+                return;
+              replied = true;
+
+              proto.channelFailure(session._chanInfo.outgoing.id);
+            };
+          }
 
-            replied = true;
+          if (session._ending) {
+            reject && reject();
+            return;
+          }
 
-            if (info.wantReply)
-              client._sshstream.channelSuccess(outgoingId);
+          switch (type) {
+            // "pre-real session start" requests
+            case 'env':
+              if (listenerCount(session, 'env')) {
+                session.emit('env', accept, reject, {
+                  key: data.name,
+                  val: data.value
+                });
+                return;
+              }
+              break;
+            case 'pty-req':
+              if (listenerCount(session, 'pty')) {
+                session.emit('pty', accept, reject, data);
+                return;
+              }
+              break;
+            case 'window-change':
+              if (listenerCount(session, 'window-change'))
+                session.emit('window-change', accept, reject, data);
+              else
+                reject && reject();
+              break;
+            case 'x11-req':
+              if (listenerCount(session, 'x11')) {
+                session.emit('x11', accept, reject, data);
+                return;
+              }
+              break;
+            // "post-real session start" requests
+            case 'signal':
+              if (listenerCount(session, 'signal')) {
+                session.emit('signal', accept, reject, {
+                  name: data
+                });
+                return;
+              }
+              break;
+            // XXX: is `auth-agent-req@openssh.com` really "post-real session
+            // start"?
+            case 'auth-agent-req@openssh.com':
+              if (listenerCount(session, 'auth-agent')) {
+                session.emit('auth-agent', accept, reject);
+                return;
+              }
+              break;
+            // "real session start" requests
+            case 'shell':
+              if (listenerCount(session, 'shell')) {
+                accept = () => {
+                  if (replied || session._ending || session._channel)
+                    return;
+                  replied = true;
+
+                  if (wantReply)
+                    proto.channelSuccess(session._chanInfo.outgoing.id);
+
+                  const channel = new Channel(
+                    this, session._chanInfo, { server: true }
+                  );
+
+                  channel.subtype = session.subtype = type;
+                  session._channel = channel;
+
+                  return channel;
+                };
+
+                session.emit('shell', accept, reject);
+                return;
+              }
+              break;
+            case 'exec':
+              if (listenerCount(session, 'exec')) {
+                accept = () => {
+                  if (replied || session._ending || session._channel)
+                    return;
+                  replied = true;
+
+                  if (wantReply)
+                    proto.channelSuccess(session._chanInfo.outgoing.id);
+
+                  const channel = new Channel(
+                    this, session._chanInfo, { server: true }
+                  );
+
+                  channel.subtype = session.subtype = type;
+                  session._channel = channel;
+
+                  return channel;
+                };
+
+                session.emit('exec', accept, reject, {
+                  command: data
+                });
+                return;
+              }
+              break;
+            case 'subsystem': {
+              let useSFTP = (data === 'sftp');
+              accept = () => {
+                if (replied || session._ending || session._channel)
+                  return;
+                replied = true;
+
+                if (wantReply)
+                  proto.channelSuccess(session._chanInfo.outgoing.id);
+
+                let instance;
+                if (useSFTP) {
+                  instance = new SFTP(this, session._chanInfo, {
+                    server: true,
+                    debug,
+                  });
+                } else {
+                  instance = new Channel(
+                    this, session._chanInfo, { server: true }
+                  );
+                  instance.subtype =
+                    session.subtype = `${type}:${data}`;
+                }
+                session._channel = instance;
+
+                return instance;
+              };
+
+              if (data === 'sftp') {
+                if (listenerCount(session, 'sftp')) {
+                  session.emit('sftp', accept, reject);
+                  return;
+                }
+                useSFTP = false;
+              }
+              if (listenerCount(session, 'subsystem')) {
+                session.emit('subsystem', accept, reject, {
+                  name: data
+                });
+                return;
+              }
+              break;
+            }
+          }
+          debug && debug(
+            `Automatic rejection of incoming channel request: ${type}`
+          );
+          reject && reject();
+        },
+        CHANNEL_EOF: (p, recipient) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
+            return;
 
-            channel = new Channel(chaninfo, client, { server: true });
+          if (channel.constructor === Session) {
+            if (!channel._ending) {
+              channel._ending = true;
+              channel.emit('eof');
+              channel.emit('end');
+            }
+            channel = channel._channel;
+            if (!channel)
+              return;
+          }
 
-            channel.subtype = self.subtype = info.request;
+          if (channel.incoming.state !== 'open')
+            return;
+          channel.incoming.state = 'eof';
+
+          if (channel.readable)
+            channel.push(null);
+        },
+        CHANNEL_CLOSE: (p, recipient) => {
+          let channel = this._chanMgr.get(recipient);
+          if (typeof channel !== 'object' || channel === null)
+            return;
 
-            return channel;
-          };
+          if (channel.constructor === Session) {
+            channel._ending = true;
+            channel.emit('close');
+            channel = channel._channel;
+            if (!channel)
+              return;
+          }
 
-          self.emit('exec', accept, reject, {
-            command: info.command
-          });
-        } else
-          reject && reject();
-      break;
-      case 'subsystem':
-        accept = function() {
-          if (replied || ending || channel)
+          onCHANNEL_CLOSE(this, recipient, channel);
+        },
+        // Begin service/auth-related ==========================================
+        SERVICE_REQUEST: (p, service) => {
+          if (exchanges === 0
+              || acceptedAuthSvc
+              || this.authenticated
+              || service !== 'ssh-userauth') {
+            proto.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
+            socket.end();
             return;
+          }
 
-          replied = true;
+          acceptedAuthSvc = true;
+          proto.serviceAccept(service);
+        },
+        USERAUTH_REQUEST: (p, username, service, method, methodData) => {
+          if (exchanges === 0
+              || this.authenticated
+              || (authCtx
+                  && (authCtx.username !== username
+                      || authCtx.service !== service))
+                // TODO: support hostbased auth
+              || (method !== 'password'
+                  && method !== 'publickey'
+                  && method !== 'hostbased'
+                  && method !== 'keyboard-interactive'
+                  && method !== 'none')
+              || pendingAuths.length === MAX_PENDING_AUTHS) {
+            proto.disconnect(DISCONNECT_REASON.PROTOCOL_ERROR);
+            socket.end();
+            return;
+          } else if (service !== 'ssh-connection') {
+            proto.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
+            socket.end();
+            return;
+          }
 
-          if (info.wantReply)
-            client._sshstream.channelSuccess(outgoingId);
+          let ctx;
+          switch (method) {
+            case 'keyboard-interactive':
+              ctx = new KeyboardAuthContext(proto, username, service, method,
+                                            methodData, onAuthDecide);
+              break;
+            case 'publickey':
+              ctx = new PKAuthContext(proto, username, service, method,
+                                      methodData, onAuthDecide);
+              break;
+            case 'hostbased':
+              ctx = new HostbasedAuthContext(proto, username, service, method,
+                                             methodData, onAuthDecide);
+              break;
+            case 'password':
+              if (authCtx
+                  && authCtx instanceof PwdAuthContext
+                  && authCtx._changeCb) {
+                const cb = authCtx._changeCb;
+                authCtx._changeCb = undefined;
+                cb(methodData.newPassword);
+                return;
+              }
+              ctx = new PwdAuthContext(proto, username, service, method,
+                                       methodData, onAuthDecide);
+              break;
+            case 'none':
+              ctx = new AuthContext(proto, username, service, method,
+                                    onAuthDecide);
+              break;
+          }
 
-          channel = new Channel(chaninfo, client, { server: true });
+          if (authCtx) {
+            if (!authCtx._initialResponse) {
+              return pendingAuths.push(ctx);
+            } else if (authCtx._multistep && !authCtx._finalResponse) {
+              // RFC 4252 says to silently abort the current auth request if a
+              // new auth request comes in before the final response from an
+              // auth method that requires additional request/response exchanges
+              // -- this means keyboard-interactive for now ...
+              authCtx._cleanup && authCtx._cleanup();
+              authCtx.emit('abort');
+            }
+          }
 
-          channel.subtype = self.subtype = (info.request + ':' + info.subsystem);
+          authCtx = ctx;
 
-          if (info.subsystem === 'sftp') {
-            var sftp = new SFTPStream({
-              server: true,
-              debug: client._sshstream.debug
-            });
-            channel.pipe(sftp).pipe(channel);
+          if (listenerCount(this, 'authentication'))
+            this.emit('authentication', authCtx);
+          else
+            authCtx.reject();
+        },
+        USERAUTH_INFO_RESPONSE: (p, responses) => {
+          if (authCtx && authCtx instanceof KeyboardAuthContext)
+            authCtx._onInfoResponse(responses);
+        },
+        // End service/auth-related ============================================
+        GLOBAL_REQUEST: (p, name, wantReply, data) => {
+          const reply = {
+            type: null,
+            buf: null
+          };
 
-            return sftp;
-          } else
-            return channel;
-        };
+          function setReply(type, buf) {
+            reply.type = type;
+            reply.buf = buf;
+            sendReplies();
+          }
 
-        if (info.subsystem === 'sftp' && listenerCount(self, 'sftp'))
-          self.emit('sftp', accept, reject);
-        else if (info.subsystem !== 'sftp' && listenerCount(self, 'subsystem')) {
-          self.emit('subsystem', accept, reject, {
-            name: info.subsystem
-          });
-        } else
-          reject && reject();
-      break;
-      default:
-        reject && reject();
-    }
-  }
-  function onEOF() {
-    ending = true;
-    self.emit('eof');
-    self.emit('end');
-  }
-  function onCLOSE() {
-    ending = true;
-    self.emit('close');
-  }
-  client._sshstream
-        .on('CHANNEL_REQUEST:' + localChan, onREQUEST)
-        .once('CHANNEL_EOF:' + localChan, onEOF)
-        .once('CHANNEL_CLOSE:' + localChan, onCLOSE);
-}
-inherits(Session, EventEmitter);
+          if (wantReply)
+            unsentGlobalRequestsReplies.push(reply);
+
+          if ((name === 'tcpip-forward'
+               || name === 'cancel-tcpip-forward'
+               || name === 'no-more-sessions@openssh.com'
+               || name === 'streamlocal-forward@openssh.com'
+               || name === 'cancel-streamlocal-forward@openssh.com')
+              && listenerCount(this, 'request')
+              && this.authenticated) {
+            let accept;
+            let reject;
+
+            if (wantReply) {
+              let replied = false;
+              accept = (chosenPort) => {
+                if (replied)
+                  return;
+                replied = true;
+                let bufPort;
+                if (name === 'tcpip-forward'
+                    && data.bindPort === 0
+                    && typeof chosenPort === 'number') {
+                  bufPort = Buffer.allocUnsafe(4);
+                  writeUInt32BE(bufPort, chosenPort, 0);
+                }
+                setReply('SUCCESS', bufPort);
+              };
+              reject = () => {
+                if (replied)
+                  return;
+                replied = true;
+                setReply('FAILURE');
+              };
+            }
+
+            if (name === 'no-more-sessions@openssh.com') {
+              this.noMoreSessions = true;
+              accept && accept();
+              return;
+            }
 
+            this.emit('request', accept, reject, name, data);
+          } else if (wantReply) {
+            setReply('FAILURE');
+          }
+        },
+      },
+    });
 
-function AuthContext(stream, username, service, method, cb) {
-  EventEmitter.call(this);
+    socket.pause();
+    cryptoInit.then(() => {
+      proto.start();
+      socket.on('data', (data) => {
+        try {
+          proto.parse(data, 0, data.length);
+        } catch (ex) {
+          this.emit('error', ex);
+          try {
+            if (isWritable(socket))
+              socket.end();
+          } catch {}
+        }
+      });
+      socket.resume();
+    }).catch((err) => {
+      this.emit('error', err);
+      try {
+        if (isWritable(socket))
+          socket.end();
+      } catch {}
+    });
+    socket.on('error', (err) => {
+      err.level = 'socket';
+      this.emit('error', err);
+    }).once('end', () => {
+      debug && debug('Socket ended');
+      proto.cleanup();
+      this.emit('end');
+    }).once('close', () => {
+      debug && debug('Socket closed');
+      proto.cleanup();
+      this.emit('close');
+
+      const err = new Error('No response from server');
+
+      // Simulate error for pending channels and close any open channels
+      this._chanMgr.cleanup(err);
+    });
 
-  var self = this;
+    const onAuthDecide = (ctx, allowed, methodsLeft, isPartial) => {
+      if (authCtx === ctx && !this.authenticated) {
+        if (allowed) {
+          authCtx = undefined;
+          this.authenticated = true;
+          proto.authSuccess();
+          pendingAuths = [];
+          this.emit('ready');
+        } else {
+          proto.authFailure(methodsLeft, isPartial);
+          if (pendingAuths.length) {
+            authCtx = pendingAuths.pop();
+            if (listenerCount(this, 'authentication'))
+              this.emit('authentication', authCtx);
+            else
+              authCtx.reject();
+          }
+        }
+      }
+    };
 
-  this.username = this.user = username;
-  this.service = service;
-  this.method = method;
-  this._initialResponse = false;
-  this._finalResponse = false;
-  this._multistep = false;
-  this._cbfinal = function(allowed, methodsLeft, isPartial) {
-    if (!self._finalResponse) {
-      self._finalResponse = true;
-      cb(self, allowed, methodsLeft, isPartial);
-    }
-  };
-  this._stream = stream;
-}
-inherits(AuthContext, EventEmitter);
-AuthContext.prototype.accept = function() {
-  this._cleanup && this._cleanup();
-  this._initialResponse = true;
-  this._cbfinal(true);
-};
-AuthContext.prototype.reject = function(methodsLeft, isPartial) {
-  this._cleanup && this._cleanup();
-  this._initialResponse = true;
-  this._cbfinal(false, methodsLeft, isPartial);
-};
-
-var RE_KBINT_SUBMETHODS = /[ \t\r\n]*,[ \t\r\n]*/g;
-function KeyboardAuthContext(stream, username, service, method, submethods, cb) {
-  AuthContext.call(this, stream, username, service, method, cb);
-  this._multistep = true;
-
-  var self = this;
-
-  this._cb = undefined;
-  this._onInfoResponse = function(responses) {
-    if (self._cb) {
-      var callback = self._cb;
-      self._cb = undefined;
-      callback(responses);
+    function sendReplies() {
+      while (unsentGlobalRequestsReplies.length > 0
+             && unsentGlobalRequestsReplies[0].type) {
+        const reply = unsentGlobalRequestsReplies.shift();
+        if (reply.type === 'SUCCESS')
+          proto.requestSuccess(reply.buf);
+        if (reply.type === 'FAILURE')
+          proto.requestFailure();
+      }
     }
-  };
-  this.submethods = submethods.split(RE_KBINT_SUBMETHODS);
-  this.on('abort', function() {
-    self._cb && self._cb(new Error('Authentication request aborted'));
-  });
-}
-inherits(KeyboardAuthContext, AuthContext);
-KeyboardAuthContext.prototype._cleanup = function() {
-  this._stream.removeListener('USERAUTH_INFO_RESPONSE', this._onInfoResponse);
-};
-KeyboardAuthContext.prototype.prompt = function(prompts, title, instructions,
-                                                cb) {
-  if (!Array.isArray(prompts))
-    prompts = [ prompts ];
-
-  if (typeof title === 'function') {
-    cb = title;
-    title = instructions = undefined;
-  } else if (typeof instructions === 'function') {
-    cb = instructions;
-    instructions = undefined;
   }
 
-  for (var i = 0; i < prompts.length; ++i) {
-    if (typeof prompts[i] === 'string') {
-      prompts[i] = {
-        prompt: prompts[i],
-        echo: true
-      };
+  end() {
+    if (this._sock && isWritable(this._sock)) {
+      this._protocol.disconnect(DISCONNECT_REASON.BY_APPLICATION);
+      this._sock.end();
     }
+    return this;
   }
 
-  this._cb = cb;
-  this._initialResponse = true;
-  this._stream.once('USERAUTH_INFO_RESPONSE', this._onInfoResponse);
-
-  return this._stream.authInfoReq(title, instructions, prompts);
-};
-
-function PKAuthContext(stream, username, service, method, pkInfo, cb) {
-  AuthContext.call(this, stream, username, service, method, cb);
-
-  this.key = { algo: pkInfo.keyAlgo, data: pkInfo.key };
-  this.signature = pkInfo.signature;
-  var sigAlgo;
-  if (this.signature) {
-    // TODO: move key type checking logic to ssh2-streams
-    switch (pkInfo.keyAlgo) {
-      case 'ssh-rsa':
-      case 'ssh-dss':
-        sigAlgo = 'sha1';
-        break;
-      case 'ssh-ed25519':
-        sigAlgo = null;
-        break;
-      case 'ecdsa-sha2-nistp256':
-        sigAlgo = 'sha256';
-        break;
-      case 'ecdsa-sha2-nistp384':
-        sigAlgo = 'sha384';
-        break;
-      case 'ecdsa-sha2-nistp521':
-        sigAlgo = 'sha512';
-        break;
-    }
+  x11(originAddr, originPort, cb) {
+    const opts = { originAddr, originPort };
+    openChannel(this, 'x11', opts, cb);
+    return this;
   }
-  this.sigAlgo = sigAlgo;
-  this.blob = pkInfo.blob;
-}
-inherits(PKAuthContext, AuthContext);
-PKAuthContext.prototype.accept = function() {
-  if (!this.signature) {
-    this._initialResponse = true;
-    this._stream.authPKOK(this.key.algo, this.key.data);
-  } else {
-    AuthContext.prototype.accept.call(this);
+
+  forwardOut(boundAddr, boundPort, remoteAddr, remotePort, cb) {
+    const opts = { boundAddr, boundPort, remoteAddr, remotePort };
+    openChannel(this, 'forwarded-tcpip', opts, cb);
+    return this;
   }
-};
-
-function HostbasedAuthContext(stream, username, service, method, pkInfo, cb) {
-  AuthContext.call(this, stream, username, service, method, cb);
-
-  this.key = { algo: pkInfo.keyAlgo, data: pkInfo.key };
-  this.signature = pkInfo.signature;
-  var sigAlgo;
-  if (this.signature) {
-    // TODO: move key type checking logic to ssh2-streams
-    switch (pkInfo.keyAlgo) {
-      case 'ssh-rsa':
-      case 'ssh-dss':
-        sigAlgo = 'sha1';
-        break;
-      case 'ssh-ed25519':
-        sigAlgo = null;
-        break;
-      case 'ecdsa-sha2-nistp256':
-        sigAlgo = 'sha256';
-        break;
-      case 'ecdsa-sha2-nistp384':
-        sigAlgo = 'sha384';
-        break;
-      case 'ecdsa-sha2-nistp521':
-        sigAlgo = 'sha512';
-        break;
-    }
+
+  openssh_forwardOutStreamLocal(socketPath, cb) {
+    const opts = { socketPath };
+    openChannel(this, 'forwarded-streamlocal@openssh.com', opts, cb);
+    return this;
   }
-  this.sigAlgo = sigAlgo;
-  this.blob = pkInfo.blob;
-  this.localHostname = pkInfo.localHostname;
-  this.localUsername = pkInfo.localUsername;
-}
-inherits(HostbasedAuthContext, AuthContext);
 
-function PwdAuthContext(stream, username, service, method, password, cb) {
-  AuthContext.call(this, stream, username, service, method, cb);
+  rekey(cb) {
+    let error;
+
+    try {
+      this._protocol.rekey();
+    } catch (ex) {
+      error = ex;
+    }
 
-  this.password = password;
+    // TODO: re-throw error if no callback?
+
+    if (typeof cb === 'function') {
+      if (error)
+        process.nextTick(cb, error);
+      else
+        this.once('rekey', cb);
+    }
+  }
 }
-inherits(PwdAuthContext, AuthContext);
 
 
 function openChannel(self, type, opts, cb) {
-  // ask the client to open a channel for some purpose
-  // (e.g. a forwarded TCP connection)
-  var localChan = nextChannel(self);
-  var initWindow = Channel.MAX_WINDOW;
-  var maxPacket = Channel.PACKET_SIZE;
-  var ret = true;
-
-  if (localChan === false)
-    return cb(new Error('No free channels available'));
+  // Ask the client to open a channel for some purpose (e.g. a forwarded TCP
+  // connection)
+  const initWindow = MAX_WINDOW;
+  const maxPacket = PACKET_SIZE;
 
   if (typeof opts === 'function') {
     cb = opts;
     opts = {};
   }
 
-  self._channels[localChan] = true;
+  const wrapper = (err, stream) => {
+    cb(err, stream);
+  };
+  wrapper.type = type;
 
-  var sshstream = self._sshstream;
-  sshstream.once('CHANNEL_OPEN_CONFIRMATION:' + localChan, function(info) {
-    sshstream.removeAllListeners('CHANNEL_OPEN_FAILURE:' + localChan);
+  const localChan = self._chanMgr.add(wrapper);
 
-    var chaninfo = {
-      type: type,
-      incoming: {
-        id: localChan,
-        window: initWindow,
-        packetSize: maxPacket,
-        state: 'open'
-      },
-      outgoing: {
-        id: info.sender,
-        window: info.window,
-        packetSize: info.packetSize,
-        state: 'open'
-      }
-    };
-    cb(undefined, new Channel(chaninfo, self, { server: true }));
-  }).once('CHANNEL_OPEN_FAILURE:' + localChan, function(info) {
-    sshstream.removeAllListeners('CHANNEL_OPEN_CONFIRMATION:' + localChan);
-
-    delete self._channels[localChan];
-
-    var err = new Error('(SSH) Channel open failure: ' + info.description);
-    err.reason = info.reason;
-    err.lang = info.lang;
-    cb(err);
-  });
-
-  if (type === 'forwarded-tcpip')
-    ret = sshstream.forwardedTcpip(localChan, initWindow, maxPacket, opts);
-  else if (type === 'x11')
-    ret = sshstream.x11(localChan, initWindow, maxPacket, opts);
-  else if (type === 'forwarded-streamlocal@openssh.com') {
-    ret = sshstream.openssh_forwardedStreamLocal(localChan,
-                                                 initWindow,
-                                                 maxPacket,
-                                                 opts);
+  if (localChan === -1) {
+    cb(new Error('No free channels available'));
+    return;
   }
 
-  return ret;
+  switch (type) {
+    case 'forwarded-tcpip':
+      self._protocol.forwardedTcpip(localChan, initWindow, maxPacket, opts);
+      break;
+    case 'x11':
+      self._protocol.x11(localChan, initWindow, maxPacket, opts);
+      break;
+    case 'forwarded-streamlocal@openssh.com':
+      self._protocol.openssh_forwardedStreamLocal(
+        localChan, initWindow, maxPacket, opts
+      );
+      break;
+    default:
+      throw new Error(`Unsupported channel type: ${type}`);
+  }
 }
 
-function nextChannel(self) {
-  // get the next available channel number
-
-  // fast path
-  if (self._curChan < MAX_CHANNEL)
-    return ++self._curChan;
-
-  // slower lookup path
-  for (var i = 0, channels = self._channels; i < MAX_CHANNEL; ++i)
-    if (!channels[i])
-      return i;
-
-  return false;
+function compareNumbers(a, b) {
+  return a - b;
 }
 
-
-Server.createServer = function(cfg, listener) {
-  return new Server(cfg, listener);
-};
-Server.KEEPALIVE_INTERVAL = 1000;
-Server.KEEPALIVE_CLIENT_INTERVAL = 15000;
-Server.KEEPALIVE_CLIENT_COUNT_MAX = 3;
-
 module.exports = Server;
 module.exports.IncomingClient = Client;