@electerm/ssh2 0.8.11 → 1.5.0

package/lib/agent.js

@@ -1,419 +1,1123 @@
-var Socket = require('net').Socket;
-var EventEmitter = require('events').EventEmitter;
-var inherits = require('util').inherits;
-var path = require('path');
-var fs = require('fs');
-var cp = require('child_process');
-
-var readUInt32BE = require('./buffer-helpers').readUInt32BE;
-var writeUInt32BE = require('./buffer-helpers').writeUInt32BE;
-var writeUInt32LE = require('./buffer-helpers').writeUInt32LE;
-
-var REQUEST_IDENTITIES = 11;
-var IDENTITIES_ANSWER = 12;
-var SIGN_REQUEST = 13;
-var SIGN_RESPONSE = 14;
-var FAILURE = 5;
-
-var RE_CYGWIN_SOCK = /^\!<socket >(\d+) s ([A-Z0-9]{8}\-[A-Z0-9]{8}\-[A-Z0-9]{8}\-[A-Z0-9]{8})/;
-
-// Format of `//./pipe/ANYTHING`, with forward slashes and backward slashes being interchangeable
-var WINDOWS_PIPE_REGEX = /^[/\\][/\\]\.[/\\]pipe[/\\].+/;
-
-module.exports = function(sockPath, key, keyType, data, cb) {
-  var sock;
-  var error;
-  var sig;
-  var datalen;
-  var keylen = 0;
-  var isSigning = Buffer.isBuffer(key);
-  var type;
-  var count = 0;
-  var siglen = 0;
-  var nkeys = 0;
-  var keys;
-  var comlen = 0;
-  var comment = false;
-  var accept;
-  var reject;
-
-  if (typeof key === 'function' && typeof keyType === 'function') {
-    // agent forwarding
-    accept = key;
-    reject = keyType;
-  } else if (isSigning) {
-    keylen = key.length;
-    datalen = data.length;
-  } else {
-    cb = key;
-    key = undefined;
+'use strict';
+
+const { Socket } = require('net');
+const { Duplex } = require('stream');
+const { resolve } = require('path');
+const { readFile } = require('fs');
+const { execFile, spawn } = require('child_process');
+
+const { isParsedKey, parseKey } = require('./protocol/keyParser.js');
+
+const {
+  makeBufferParser,
+  readUInt32BE,
+  writeUInt32BE,
+  writeUInt32LE,
+} = require('./protocol/utils.js');
+
+function once(cb) {
+  let called = false;
+  return (...args) => {
+    if (called)
+      return;
+    called = true;
+    cb(...args);
+  };
+}
+
+function concat(buf1, buf2) {
+  const combined = Buffer.allocUnsafe(buf1.length + buf2.length);
+  buf1.copy(combined, 0);
+  buf2.copy(combined, buf1.length);
+  return combined;
+}
+
+function noop() {}
+
+const EMPTY_BUF = Buffer.alloc(0);
+
+const binaryParser = makeBufferParser();
+
+class BaseAgent {
+  getIdentities(cb) {
+    cb(new Error('Missing getIdentities() implementation'));
+  }
+  sign(pubKey, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options;
+    cb(new Error('Missing sign() implementation'));
   }
+}
 
-  function onconnect() {
-    var buf;
-    if (isSigning) {
-      /*
-        byte        SSH2_AGENTC_SIGN_REQUEST
-        string      key_blob
-        string      data
-        uint32      flags
-      */
-      var p = 9;
-      buf = Buffer.allocUnsafe(4 + 1 + 4 + keylen + 4 + datalen + 4);
-      writeUInt32BE(buf, buf.length - 4, 0);
-      buf[4] = SIGN_REQUEST;
-      writeUInt32BE(buf, keylen, 5);
-      key.copy(buf, p);
-      writeUInt32BE(buf, datalen, p += keylen);
-      data.copy(buf, p += 4);
-      writeUInt32BE(buf, 0, p += datalen);
-      sock.write(buf);
-    } else {
-      /*
-        byte        SSH2_AGENTC_REQUEST_IDENTITIES
-      */
-      sock.write(Buffer.from([0, 0, 0, 1, REQUEST_IDENTITIES]));
+class OpenSSHAgent extends BaseAgent {
+  constructor(socketPath) {
+    super();
+    this.socketPath = socketPath;
+  }
+
+  getStream(cb) {
+    cb = once(cb);
+    const sock = new Socket();
+    sock.on('connect', () => {
+      cb(null, sock);
+    });
+    sock.on('close', onFail)
+        .on('end', onFail)
+        .on('error', onFail);
+    sock.connect(this.socketPath);
+
+    function onFail() {
+      try {
+        sock.destroy();
+      } catch {}
+
+      cb(new Error('Failed to connect to agent'));
     }
   }
-  function ondata(chunk) {
-    for (var i = 0, len = chunk.length; i < len; ++i) {
-      if (type === undefined) {
-        // skip over packet length
-        if (++count === 5) {
-          type = chunk[i];
-          count = 0;
-        }
-      } else if (type === SIGN_RESPONSE) {
-        /*
-          byte        SSH2_AGENT_SIGN_RESPONSE
-          string      signature_blob
-        */
-        if (!sig) {
-          siglen <<= 8;
-          siglen += chunk[i];
-          if (++count === 4) {
-            sig = Buffer.allocUnsafe(siglen);
-            count = 0;
-          }
-        } else {
-          sig[count] = chunk[i];
-          if (++count === siglen) {
-            sock.removeAllListeners('data');
-            return sock.destroy();
-          }
-        }
-      } else if (type === IDENTITIES_ANSWER) {
-        /*
-          byte        SSH2_AGENT_IDENTITIES_ANSWER
-          uint32      num_keys
-
-        Followed by zero or more consecutive keys, encoded as:
-
-          string      public key blob
-          string      public key comment
-        */
-        if (keys === undefined) {
-          nkeys <<= 8;
-          nkeys += chunk[i];
-          if (++count === 4) {
-            keys = new Array(nkeys);
-            count = 0;
-            if (nkeys === 0) {
-              sock.removeAllListeners('data');
-              return sock.destroy();
-            }
-          }
-        } else {
-          if (!key) {
-            keylen <<= 8;
-            keylen += chunk[i];
-            if (++count === 4) {
-              key = Buffer.allocUnsafe(keylen);
-              count = 0;
-            }
-          } else if (comment === false) {
-            key[count] = chunk[i];
-            if (++count === keylen) {
-              keys[nkeys - 1] = key;
-              keylen = 0;
-              count = 0;
-              comment = true;
-              if (--nkeys === 0) {
-                key = undefined;
-                sock.removeAllListeners('data');
-                return sock.destroy();
-              }
-            }
-          } else if (comment === true) {
-            comlen <<= 8;
-            comlen += chunk[i];
-            if (++count === 4) {
-              count = 0;
-              if (comlen > 0)
-                comment = comlen;
-              else {
-                key = undefined;
-                comment = false;
-              }
-              comlen = 0;
-            }
-          } else {
-            // skip comments
-            if (++count === comment) {
-              comment = false;
-              count = 0;
-              key = undefined;
-            }
-          }
+
+  getIdentities(cb) {
+    cb = once(cb);
+    this.getStream((err, stream) => {
+      function onFail(err) {
+        if (stream) {
+          try {
+            stream.destroy();
+          } catch {}
         }
-      } else if (type === FAILURE) {
-        if (isSigning)
-          error = new Error('Agent unable to sign data');
-        else
-          error = new Error('Unable to retrieve list of keys from agent');
-        sock.removeAllListeners('data');
-        return sock.destroy();
+        if (!err)
+          err = new Error('Failed to retrieve identities from agent');
+        cb(err);
       }
+
+      if (err)
+        return onFail(err);
+
+      const protocol = new AgentProtocol(true);
+      protocol.on('error', onFail);
+      protocol.pipe(stream).pipe(protocol);
+
+      stream.on('close', onFail)
+            .on('end', onFail)
+            .on('error', onFail);
+
+      protocol.getIdentities((err, keys) => {
+        if (err)
+          return onFail(err);
+        try {
+          stream.destroy();
+        } catch {}
+        cb(null, keys);
+      });
+    });
+  }
+
+  sign(pubKey, data, options, cb) {
+    if (typeof options === 'function') {
+      cb = options;
+      options = undefined;
+    } else if (typeof options !== 'object' || options === null) {
+      options = undefined;
     }
+
+    cb = once(cb);
+    this.getStream((err, stream) => {
+      function onFail(err) {
+        if (stream) {
+          try {
+            stream.destroy();
+          } catch {}
+        }
+        if (!err)
+          err = new Error('Failed to sign data with agent');
+        cb(err);
+      }
+
+      if (err)
+        return onFail(err);
+
+      const protocol = new AgentProtocol(true);
+      protocol.on('error', onFail);
+      protocol.pipe(stream).pipe(protocol);
+
+      stream.on('close', onFail)
+            .on('end', onFail)
+            .on('error', onFail);
+
+      protocol.sign(pubKey, data, options, (err, sig) => {
+        if (err)
+          return onFail(err);
+
+        try {
+          stream.destroy();
+        } catch {}
+
+        cb(null, sig);
+      });
+    });
   }
-  function onerror(err) {
-    error = err;
+}
+
+const PageantAgent = (() => {
+  const RET_ERR_BADARGS = 10;
+  const RET_ERR_UNAVAILABLE = 11;
+  const RET_ERR_NOMAP = 12;
+  const RET_ERR_BINSTDIN = 13;
+  const RET_ERR_BINSTDOUT = 14;
+  const RET_ERR_BADLEN = 15;
+
+  const EXEPATH = resolve(__dirname, '..', 'util/pagent.exe');
+  const ERROR = {
+    [RET_ERR_BADARGS]: new Error('Invalid pagent.exe arguments'),
+    [RET_ERR_UNAVAILABLE]: new Error('Pageant is not running'),
+    [RET_ERR_NOMAP]: new Error('pagent.exe could not create an mmap'),
+    [RET_ERR_BINSTDIN]: new Error('pagent.exe could not set mode for stdin'),
+    [RET_ERR_BINSTDOUT]: new Error('pagent.exe could not set mode for stdout'),
+    [RET_ERR_BADLEN]:
+      new Error('pagent.exe did not get expected input payload'),
+  };
+
+  function destroy(stream) {
+    stream.buffer = null;
+    if (stream.proc) {
+      stream.proc.kill();
+      stream.proc = undefined;
+    }
   }
-  function onclose() {
-    if (error)
-      cb(error);
-    else if ((isSigning && !sig) || (!isSigning && !keys))
-      cb(new Error('Unexpected disconnection from agent'));
-    else if (isSigning && sig)
-      cb(undefined, sig);
-    else if (!isSigning && keys)
-      cb(undefined, keys);
+
+  class PageantSocket extends Duplex {
+    constructor() {
+      super();
+      this.proc = undefined;
+      this.buffer = null;
+    }
+    _read(n) {}
+    _write(data, encoding, cb) {
+      if (this.buffer === null) {
+        this.buffer = data;
+      } else {
+        const newBuffer = Buffer.allocUnsafe(this.buffer.length + data.length);
+        this.buffer.copy(newBuffer, 0);
+        data.copy(newBuffer, this.buffer.length);
+        this.buffer = newBuffer;
+      }
+      // Wait for at least all length bytes
+      if (this.buffer.length < 4)
+        return cb();
+
+      const len = readUInt32BE(this.buffer, 0);
+      // Make sure we have a full message before querying pageant
+      if ((this.buffer.length - 4) < len)
+        return cb();
+
+      data = this.buffer.slice(0, 4 + len);
+      if (this.buffer.length > (4 + len))
+        return cb(new Error('Unexpected multiple agent requests'));
+      this.buffer = null;
+
+      let error;
+      const proc = this.proc = spawn(EXEPATH, [ data.length ]);
+      proc.stdout.on('data', (data) => {
+        this.push(data);
+      });
+      proc.on('error', (err) => {
+        error = err;
+        cb(error);
+      });
+      proc.on('close', (code) => {
+        this.proc = undefined;
+        if (!error) {
+          if (error = ERROR[code])
+            return cb(error);
+          cb();
+        }
+      });
+      proc.stdin.end(data);
+    }
+    _final(cb) {
+      destroy(this);
+      cb();
+    }
+    _destroy(err, cb) {
+      destroy(this);
+      cb();
+    }
   }
 
-  if (process.platform === 'win32' && !WINDOWS_PIPE_REGEX.test(sockPath)) {
-    if (sockPath === 'pageant') {
-      // Pageant (PuTTY authentication agent)
-      sock = new PageantSock();
-    } else {
-      // cygwin ssh-agent instance
-      var triedCygpath = false;
-      fs.readFile(sockPath, function readCygsocket(err, data) {
+  return class PageantAgent extends OpenSSHAgent {
+    getStream(cb) {
+      cb(null, new PageantSocket());
+    }
+  };
+})();
+
+const CygwinAgent = (() => {
+  const RE_CYGWIN_SOCK = /^!<socket >(\d+) s ([A-Z0-9]{8}-[A-Z0-9]{8}-[A-Z0-9]{8}-[A-Z0-9]{8})/;
+
+  return class CygwinAgent extends OpenSSHAgent {
+    getStream(cb) {
+      cb = once(cb);
+
+      // The cygwin ssh-agent connection process looks like this:
+      //   1. Read the "socket" as a file to get the underlying TCP port and a
+      //      special "secret" that must be sent to the TCP server.
+      //   2. Connect to the server listening on localhost at the TCP port.
+      //   3. Send the "secret" to the server.
+      //   4. The server sends back the same "secret".
+      //   5. Send three 32-bit integer values of zero. This is ordinarily the
+      //      pid, uid, and gid of this process, but cygwin will actually
+      //      send us the correct values as a response.
+      //   6. The server sends back the pid, uid, gid.
+      //   7. Disconnect.
+      //   8. Repeat steps 2-6, except send the received pid, uid, and gid in
+      //      step 5 instead of zeroes.
+      //   9. Connection is ready to be used.
+
+      let socketPath = this.socketPath;
+      let triedCygpath = false;
+      readFile(socketPath, function readCygsocket(err, data) {
         if (err) {
           if (triedCygpath)
             return cb(new Error('Invalid cygwin unix socket path'));
-          // try using `cygpath` to convert a possible *nix-style path to the
+
+          // Try using `cygpath` to convert a possible *nix-style path to the
           // real Windows path before giving up ...
-          cp.exec('cygpath -w "' + sockPath + '"',
-                  function(err, stdout, stderr) {
+          execFile('cygpath', ['-w', socketPath], (err, stdout, stderr) => {
             if (err || stdout.length === 0)
               return cb(new Error('Invalid cygwin unix socket path'));
+
             triedCygpath = true;
-            sockPath = stdout.toString().replace(/[\r\n]/g, '');
-            fs.readFile(sockPath, readCygsocket);
+            socketPath = stdout.toString().replace(/[\r\n]/g, '');
+            readFile(socketPath, readCygsocket);
           });
           return;
         }
 
-        var m;
-        if (m = RE_CYGWIN_SOCK.exec(data.toString('ascii'))) {
-          var port;
-          var secret;
-          var secretbuf;
-          var state;
-          var bc = 0;
-          var isRetrying = false;
-          var inbuf = [];
-          var credsbuf = Buffer.allocUnsafe(12);
-          var i;
-          var j;
-
-          // use 0 for pid, uid, and gid to ensure we get an error and also
-          // a valid uid and gid from cygwin so that we don't have to figure it
-          // out ourselves
-          credsbuf.fill(0);
-
-          // parse cygwin unix socket file contents
-          port = parseInt(m[1], 10);
-          secret = m[2].replace(/\-/g, '');
-          secretbuf = Buffer.allocUnsafe(16);
-          for (i = 0, j = 0; j < 32; ++i,j+=2)
-            secretbuf[i] = parseInt(secret.substring(j, j + 2), 16);
-
-          // convert to host order (always LE for Windows)
-          for (i = 0; i < 16; i += 4)
-            writeUInt32LE(secretbuf, readUInt32BE(secretbuf, i), i);
-
-          function _onconnect() {
-            bc = 0;
-            state = 'secret';
-            sock.write(secretbuf);
+        const m = RE_CYGWIN_SOCK.exec(data.toString('ascii'));
+        if (!m)
+          return cb(new Error('Malformed cygwin unix socket file'));
+
+        let state;
+        let bc = 0;
+        let isRetrying = false;
+        const inBuf = [];
+        let sock;
+
+        // Use 0 for pid, uid, and gid to ensure we get an error and also
+        // a valid uid and gid from cygwin so that we don't have to figure it
+        // out ourselves
+        let credsBuf = Buffer.alloc(12);
+
+        // Parse cygwin unix socket file contents
+        const port = parseInt(m[1], 10);
+        const secret = m[2].replace(/-/g, '');
+        const secretBuf = Buffer.allocUnsafe(16);
+        for (let i = 0, j = 0; j < 32; ++i, j += 2)
+          secretBuf[i] = parseInt(secret.substring(j, j + 2), 16);
+
+        // Convert to host order (always LE for Windows)
+        for (let i = 0; i < 16; i += 4)
+          writeUInt32LE(secretBuf, readUInt32BE(secretBuf, i), i);
+
+        tryConnect();
+
+        function _onconnect() {
+          bc = 0;
+          state = 'secret';
+          sock.write(secretBuf);
+        }
+
+        function _ondata(data) {
+          bc += data.length;
+
+          if (state === 'secret') {
+            // The secret we sent is echoed back to us by cygwin, not sure of
+            // the reason for that, but we ignore it nonetheless ...
+            if (bc === 16) {
+              bc = 0;
+              state = 'creds';
+              sock.write(credsBuf);
+            }
+            return;
+          }
+
+          if (state === 'creds') {
+            // If this is the first attempt, make sure to gather the valid
+            // uid and gid for our next attempt
+            if (!isRetrying)
+              inBuf.push(data);
+
+            if (bc === 12) {
+              sock.removeListener('connect', _onconnect);
+              sock.removeListener('data', _ondata);
+              sock.removeListener('error', onFail);
+              sock.removeListener('end', onFail);
+              sock.removeListener('close', onFail);
+
+              if (isRetrying)
+                return cb(null, sock);
+
+              isRetrying = true;
+              credsBuf = Buffer.concat(inBuf);
+              writeUInt32LE(credsBuf, process.pid, 0);
+              sock.on('error', () => {});
+              sock.destroy();
+
+              tryConnect();
+            }
           }
-          function _ondata(data) {
-            bc += data.length;
-            if (state === 'secret') {
-              // the secret we sent is echoed back to us by cygwin, not sure of
-              // the reason for that, but we ignore it nonetheless ...
-              if (bc === 16) {
-                bc = 0;
-                state = 'creds';
-                sock.write(credsbuf);
+        }
+
+        function onFail() {
+          cb(new Error('Problem negotiating cygwin unix socket security'));
+        }
+
+        function tryConnect() {
+          sock = new Socket();
+          sock.on('connect', _onconnect);
+          sock.on('data', _ondata);
+          sock.on('error', onFail);
+          sock.on('end', onFail);
+          sock.on('close', onFail);
+          sock.connect(port);
+        }
+      });
+    }
+  };
+})();
+
+// Format of `//./pipe/ANYTHING`, with forward slashes and backward slashes
+// being interchangeable
+const WINDOWS_PIPE_REGEX = /^[/\\][/\\]\.[/\\]pipe[/\\].+/;
+function createAgent(path) {
+  if (process.platform === 'win32' && !WINDOWS_PIPE_REGEX.test(path)) {
+    return (path === 'pageant'
+            ? new PageantAgent()
+            : new CygwinAgent(path));
+  }
+  return new OpenSSHAgent(path);
+}
+
+const AgentProtocol = (() => {
+  // Client->Server messages
+  const SSH_AGENTC_REQUEST_IDENTITIES = 11;
+  const SSH_AGENTC_SIGN_REQUEST = 13;
+  // const SSH_AGENTC_ADD_IDENTITY = 17;
+  // const SSH_AGENTC_REMOVE_IDENTITY = 18;
+  // const SSH_AGENTC_REMOVE_ALL_IDENTITIES = 19;
+  // const SSH_AGENTC_ADD_SMARTCARD_KEY = 20;
+  // const SSH_AGENTC_REMOVE_SMARTCARD_KEY = 21;
+  // const SSH_AGENTC_LOCK = 22;
+  // const SSH_AGENTC_UNLOCK = 23;
+  // const SSH_AGENTC_ADD_ID_CONSTRAINED = 25;
+  // const SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED = 26;
+  // const SSH_AGENTC_EXTENSION = 27;
+  // Server->Client messages
+  const SSH_AGENT_FAILURE = 5;
+  // const SSH_AGENT_SUCCESS = 6;
+  const SSH_AGENT_IDENTITIES_ANSWER = 12;
+  const SSH_AGENT_SIGN_RESPONSE = 14;
+  // const SSH_AGENT_EXTENSION_FAILURE = 28;
+
+  // const SSH_AGENT_CONSTRAIN_LIFETIME = 1;
+  // const SSH_AGENT_CONSTRAIN_CONFIRM = 2;
+  // const SSH_AGENT_CONSTRAIN_EXTENSION = 255;
+
+  const SSH_AGENT_RSA_SHA2_256 = (1 << 1);
+  const SSH_AGENT_RSA_SHA2_512 = (1 << 2);
+
+  const ROLE_CLIENT = 0;
+  const ROLE_SERVER = 1;
+
+  // Ensures that responses get sent back in the same order the requests were
+  // received
+  function processResponses(protocol) {
+    let ret;
+    while (protocol[SYM_REQS].length) {
+      const nextResponse = protocol[SYM_REQS][0][SYM_RESP];
+      if (nextResponse === undefined)
+        break;
+
+      protocol[SYM_REQS].shift();
+      ret = protocol.push(nextResponse);
+    }
+    return ret;
+  }
+
+  const SYM_TYPE = Symbol('Inbound Request Type');
+  const SYM_RESP = Symbol('Inbound Request Response');
+  const SYM_CTX = Symbol('Inbound Request Context');
+  class AgentInboundRequest {
+    constructor(type, ctx) {
+      this[SYM_TYPE] = type;
+      this[SYM_RESP] = undefined;
+      this[SYM_CTX] = ctx;
+    }
+    hasResponded() {
+      return (this[SYM_RESP] !== undefined);
+    }
+    getType() {
+      return this[SYM_TYPE];
+    }
+    getContext() {
+      return this[SYM_CTX];
+    }
+  }
+  function respond(protocol, req, data) {
+    req[SYM_RESP] = data;
+    return processResponses(protocol);
+  }
+
+  function cleanup(protocol) {
+    protocol[SYM_BUFFER] = null;
+    if (protocol[SYM_MODE] === ROLE_CLIENT) {
+      const reqs = protocol[SYM_REQS];
+      if (reqs && reqs.length) {
+        protocol[SYM_REQS] = [];
+        for (const req of reqs)
+          req.cb(new Error('No reply from server'));
+      }
+    }
+
+    // Node streams hackery to make streams do the "right thing"
+    try {
+      protocol.end();
+    } catch {}
+    setImmediate(() => {
+      if (!protocol[SYM_ENDED])
+        protocol.emit('end');
+      if (!protocol[SYM_CLOSED])
+        protocol.emit('close');
+    });
+  }
+
+  function onClose() {
+    this[SYM_CLOSED] = true;
+  }
+
+  function onEnd() {
+    this[SYM_ENDED] = true;
+  }
+
+  const SYM_REQS = Symbol('Requests');
+  const SYM_MODE = Symbol('Agent Protocol Role');
+  const SYM_BUFFER = Symbol('Agent Protocol Buffer');
+  const SYM_MSGLEN = Symbol('Agent Protocol Current Message Length');
+  const SYM_CLOSED = Symbol('Agent Protocol Closed');
+  const SYM_ENDED = Symbol('Agent Protocol Ended');
+  // Implementation based on:
+  // https://tools.ietf.org/html/draft-miller-ssh-agent-04
+  return class AgentProtocol extends Duplex {
+    /*
+        Notes:
+          - `constraint` type consists of:
+               byte                    constraint_type
+               byte[]                  constraint_data
+            where `constraint_type` is one of:
+              * SSH_AGENT_CONSTRAIN_LIFETIME
+                - `constraint_data` consists of:
+                     uint32                  seconds
+              * SSH_AGENT_CONSTRAIN_CONFIRM
+                - `constraint_data` N/A
+              * SSH_AGENT_CONSTRAIN_EXTENSION
+                - `constraint_data` consists of:
+                     string                  extension name
+                     byte[]                  extension-specific details
+    */
+
+    constructor(isClient) {
+      super({ autoDestroy: true, emitClose: false });
+      this[SYM_MODE] = (isClient ? ROLE_CLIENT : ROLE_SERVER);
+      this[SYM_REQS] = [];
+      this[SYM_BUFFER] = null;
+      this[SYM_MSGLEN] = -1;
+      this.once('end', onEnd);
+      this.once('close', onClose);
+    }
+
+    _read(n) {}
+
+    _write(data, encoding, cb) {
+      /*
+          Messages are of the format:
+            uint32                    message length
+            byte                      message type
+            byte[message length - 1]  message contents
+      */
+      if (this[SYM_BUFFER] === null)
+        this[SYM_BUFFER] = data;
+      else
+        this[SYM_BUFFER] = concat(this[SYM_BUFFER], data);
+
+      let buffer = this[SYM_BUFFER];
+      let bufferLen = buffer.length;
+
+      let p = 0;
+      while (p < bufferLen) {
+        // Wait for length + type
+        if (bufferLen < 5)
+          break;
+
+        if (this[SYM_MSGLEN] === -1)
+          this[SYM_MSGLEN] = readUInt32BE(buffer, p);
+
+        // Check if we have the entire message
+        if (bufferLen < (4 + this[SYM_MSGLEN]))
+          break;
+
+        const msgType = buffer[p += 4];
+        ++p;
+
+        if (this[SYM_MODE] === ROLE_CLIENT) {
+          if (this[SYM_REQS].length === 0)
+            return cb(new Error('Received unexpected message from server'));
+
+          const req = this[SYM_REQS].shift();
+
+          switch (msgType) {
+            case SSH_AGENT_FAILURE:
+              req.cb(new Error('Agent responded with failure'));
+              break;
+            case SSH_AGENT_IDENTITIES_ANSWER: {
+              if (req.type !== SSH_AGENTC_REQUEST_IDENTITIES)
+                return cb(new Error('Agent responded with wrong message type'));
+
+              /*
+                 byte        SSH_AGENT_IDENTITIES_ANSWER
+                 uint32      nkeys
+
+                where `nkeys` is 0 or more of:
+                 string      key blob
+                 string      comment
+              */
+
+              binaryParser.init(buffer, p);
+
+              const numKeys = binaryParser.readUInt32BE();
+
+              if (numKeys === undefined) {
+                binaryParser.clear();
+                return cb(new Error('Malformed agent response'));
               }
-            } else if (state === 'creds') {
-              // if this is the first attempt, make sure to gather the valid
-              // uid and gid for our next attempt
-              if (!isRetrying)
-                inbuf.push(data);
-
-              if (bc === 12) {
-                sock.removeListener('connect', _onconnect);
-                sock.removeListener('data', _ondata);
-                sock.removeListener('close', _onclose);
-                if (isRetrying) {
-                  addSockListeners();
-                  sock.emit('connect');
-                } else {
-                  isRetrying = true;
-                  credsbuf = Buffer.concat(inbuf);
-                  writeUInt32LE(credsbuf, process.pid, 0);
-                  sock.destroy();
-                  tryConnect();
+
+              const keys = [];
+              for (let i = 0; i < numKeys; ++i) {
+                let pubKey = binaryParser.readString();
+                if (pubKey === undefined) {
+                  binaryParser.clear();
+                  return cb(new Error('Malformed agent response'));
                 }
+
+                const comment = binaryParser.readString(true);
+                if (comment === undefined) {
+                  binaryParser.clear();
+                  return cb(new Error('Malformed agent response'));
+                }
+
+                pubKey = parseKey(pubKey);
+                // We continue parsing the packet if we encounter an error
+                // in case the error is due to the key being an unsupported
+                // type
+                if (pubKey instanceof Error)
+                  continue;
+
+                pubKey.comment = pubKey.comment || comment;
+
+                keys.push(pubKey);
               }
+              p = binaryParser.pos();
+              binaryParser.clear();
+
+              req.cb(null, keys);
+              break;
             }
+            case SSH_AGENT_SIGN_RESPONSE: {
+              if (req.type !== SSH_AGENTC_SIGN_REQUEST)
+                return cb(new Error('Agent responded with wrong message type'));
+
+              /*
+                 byte        SSH_AGENT_SIGN_RESPONSE
+                 string      signature
+              */
+
+              binaryParser.init(buffer, p);
+              let signature = binaryParser.readString();
+              p = binaryParser.pos();
+              binaryParser.clear();
+
+              if (signature === undefined)
+                return cb(new Error('Malformed agent response'));
+
+              // We strip the algorithm from OpenSSH's output and assume it's
+              // using the algorithm we specified. This makes it easier on
+              // custom Agent implementations so they don't have to construct
+              // the correct binary format for a (OpenSSH-style) signature.
+
+              // TODO: verify signature type based on key and options used
+              // during initial sign request
+              binaryParser.init(signature, 0);
+              binaryParser.readString(true);
+              signature = binaryParser.readString();
+              binaryParser.clear();
+
+              if (signature === undefined)
+                return cb(new Error('Malformed OpenSSH signature format'));
+
+              req.cb(null, signature);
+              break;
+            }
+            default:
+              return cb(
+                new Error('Agent responded with unsupported message type')
+              );
           }
-          function _onclose() {
-            cb(new Error('Problem negotiating cygwin unix socket security'));
-          }
-          function tryConnect() {
-            sock = new Socket();
-            sock.once('connect', _onconnect);
-            sock.on('data', _ondata);
-            sock.once('close', _onclose);
-            sock.connect(port);
+        } else {
+          switch (msgType) {
+            case SSH_AGENTC_REQUEST_IDENTITIES: {
+              const req = new AgentInboundRequest(msgType);
+              this[SYM_REQS].push(req);
+              /*
+                byte        SSH_AGENTC_REQUEST_IDENTITIES
+              */
+              this.emit('identities', req);
+              break;
+            }
+            case SSH_AGENTC_SIGN_REQUEST: {
+              /*
+                byte        SSH_AGENTC_SIGN_REQUEST
+                string      key_blob
+                string      data
+                uint32      flags
+              */
+              binaryParser.init(buffer, p);
+              let pubKey = binaryParser.readString();
+              const data = binaryParser.readString();
+              const flagsVal = binaryParser.readUInt32BE();
+              p = binaryParser.pos();
+              binaryParser.clear();
+              if (flagsVal === undefined) {
+                const req = new AgentInboundRequest(msgType);
+                this[SYM_REQS].push(req);
+                return this.failureReply(req);
+              }
+
+              pubKey = parseKey(pubKey);
+              if (pubKey instanceof Error) {
+                const req = new AgentInboundRequest(msgType);
+                this[SYM_REQS].push(req);
+                return this.failureReply(req);
+              }
+
+              const flags = {
+                hash: undefined,
+              };
+              let ctx;
+              if (pubKey.type === 'ssh-rsa') {
+                if (flagsVal & SSH_AGENT_RSA_SHA2_256) {
+                  ctx = 'rsa-sha2-256';
+                  flags.hash = 'sha256';
+                } else if (flagsVal & SSH_AGENT_RSA_SHA2_512) {
+                  ctx = 'rsa-sha2-512';
+                  flags.hash = 'sha512';
+                }
+              }
+              if (ctx === undefined)
+                ctx = pubKey.type;
+
+              const req = new AgentInboundRequest(msgType, ctx);
+              this[SYM_REQS].push(req);
+
+              this.emit('sign', req, pubKey, data, flags);
+              break;
+            }
+            default: {
+              const req = new AgentInboundRequest(msgType);
+              this[SYM_REQS].push(req);
+              this.failureReply(req);
+            }
           }
-          tryConnect();
-        } else
-          cb(new Error('Malformed cygwin unix socket file'));
-      });
-      return;
+        }
+
+        // Get ready for next message
+        this[SYM_MSGLEN] = -1;
+        if (p === bufferLen) {
+          // Nothing left to process for now
+          this[SYM_BUFFER] = null;
+          break;
+        } else {
+          this[SYM_BUFFER] = buffer = buffer.slice(p);
+          bufferLen = buffer.length;
+          p = 0;
+        }
+      }
+
+      cb();
     }
-  } else
-    sock = new Socket();
-
-  function addSockListeners() {
-    if (!accept && !reject) {
-      sock.once('connect', onconnect);
-      sock.on('data', ondata);
-      sock.once('error', onerror);
-      sock.once('close', onclose);
-    } else {
-      var chan;
-      sock.once('connect', function() {
-        chan = accept();
-        var isDone = false;
-        function onDone() {
-          if (isDone)
-            return;
-          sock.destroy();
-          isDone = true;
+
+    _destroy(err, cb) {
+      cleanup(this);
+      cb();
+    }
+
+    _final(cb) {
+      cleanup(this);
+      cb();
+    }
+
+    // Client->Server messages =================================================
+    sign(pubKey, data, options, cb) {
+      if (this[SYM_MODE] !== ROLE_CLIENT)
+        throw new Error('Client-only method called with server role');
+
+      if (typeof options === 'function') {
+        cb = options;
+        options = undefined;
+      } else if (typeof options !== 'object' || options === null) {
+        options = undefined;
+      }
+
+      let flags = 0;
+
+      pubKey = parseKey(pubKey);
+      if (pubKey instanceof Error)
+        throw new Error('Invalid public key argument');
+
+      if (pubKey.type === 'ssh-rsa' && options) {
+        switch (options.hash) {
+          case 'sha256':
+            flags = SSH_AGENT_RSA_SHA2_256;
+            break;
+          case 'sha512':
+            flags = SSH_AGENT_RSA_SHA2_512;
+            break;
         }
-        chan.once('end', onDone)
-            .once('close', onDone)
-            .on('data', function(data) {
-          sock.write(data);
-        });
-        sock.on('data', function(data) {
-          chan.write(data);
-        });
-      });
-      sock.once('close', function() {
-        if (!chan)
-          reject();
-      });
+      }
+      pubKey = pubKey.getPublicSSH();
+
+      /*
+        byte        SSH_AGENTC_SIGN_REQUEST
+        string      key_blob
+        string      data
+        uint32      flags
+      */
+      const type = SSH_AGENTC_SIGN_REQUEST;
+      const keyLen = pubKey.length;
+      const dataLen = data.length;
+      let p = 0;
+      const buf = Buffer.allocUnsafe(4 + 1 + 4 + keyLen + 4 + dataLen + 4);
+
+      writeUInt32BE(buf, buf.length - 4, p);
+
+      buf[p += 4] = type;
+
+      writeUInt32BE(buf, keyLen, ++p);
+      pubKey.copy(buf, p += 4);
+
+      writeUInt32BE(buf, dataLen, p += keyLen);
+      data.copy(buf, p += 4);
+
+      writeUInt32BE(buf, flags, p += dataLen);
+
+      if (typeof cb !== 'function')
+        cb = noop;
+
+      this[SYM_REQS].push({ type, cb });
+
+      return this.push(buf);
     }
-  }
-  addSockListeners();
-  sock.connect(sockPath);
-};
+    getIdentities(cb) {
+      if (this[SYM_MODE] !== ROLE_CLIENT)
+        throw new Error('Client-only method called with server role');
 
+      /*
+        byte        SSH_AGENTC_REQUEST_IDENTITIES
+      */
+      const type = SSH_AGENTC_REQUEST_IDENTITIES;
 
-// win32 only ------------------------------------------------------------------
-if (process.platform === 'win32') {
-  var RET_ERR_BADARGS = 10;
-  var RET_ERR_UNAVAILABLE = 11;
-  var RET_ERR_NOMAP = 12;
-  var RET_ERR_BINSTDIN = 13;
-  var RET_ERR_BINSTDOUT = 14;
-  var RET_ERR_BADLEN = 15;
-
-  var ERROR = {};
-  var EXEPATH = path.resolve(__dirname, '..', 'util/pagent.exe');
-  ERROR[RET_ERR_BADARGS] = new Error('Invalid pagent.exe arguments');
-  ERROR[RET_ERR_UNAVAILABLE] = new Error('Pageant is not running');
-  ERROR[RET_ERR_NOMAP] = new Error('pagent.exe could not create an mmap');
-  ERROR[RET_ERR_BINSTDIN] = new Error('pagent.exe could not set mode for stdin');
-  ERROR[RET_ERR_BINSTDOUT] = new Error('pagent.exe could not set mode for stdout');
-  ERROR[RET_ERR_BADLEN] = new Error('pagent.exe did not get expected input payload');
-
-  function PageantSock() {
-    this.proc = undefined;
-    this.buffer = null;
-  }
-  inherits(PageantSock, EventEmitter);
-
-  PageantSock.prototype.write = function(buf) {
-    if (this.buffer === null)
-      this.buffer = buf;
-    else {
-      this.buffer = Buffer.concat([this.buffer, buf],
-                                  this.buffer.length + buf.length);
+      let p = 0;
+      const buf = Buffer.allocUnsafe(4 + 1);
+
+      writeUInt32BE(buf, buf.length - 4, p);
+
+      buf[p += 4] = type;
+
+      if (typeof cb !== 'function')
+        cb = noop;
+
+      this[SYM_REQS].push({ type, cb });
+
+      return this.push(buf);
     }
-    // Wait for at least all length bytes
-    if (this.buffer.length < 4)
-      return;
 
-    var len = readUInt32BE(this.buffer, 0);
-    // Make sure we have a full message before querying pageant
-    if ((this.buffer.length - 4) < len)
-      return;
+    // Server->Client messages =================================================
+    failureReply(req) {
+      if (this[SYM_MODE] !== ROLE_SERVER)
+        throw new Error('Server-only method called with client role');
 
-    buf = this.buffer.slice(0, 4 + len);
-    if (this.buffer.length > (4 + len))
-      this.buffer = this.buffer.slice(4 + len);
-    else
-      this.buffer = null;
+      if (!(req instanceof AgentInboundRequest))
+        throw new Error('Wrong request argument');
 
-    var self = this;
-    var proc;
-    var hadError = false;
-    proc = this.proc = cp.spawn(EXEPATH, [ buf.length ]);
-    proc.stdout.on('data', function(data) {
-      self.emit('data', data);
-    });
-    proc.once('error', function(err) {
-      if (!hadError) {
-        hadError = true;
-        self.emit('error', err);
+      if (req.hasResponded())
+        return true;
+
+      let p = 0;
+      const buf = Buffer.allocUnsafe(4 + 1);
+
+      writeUInt32BE(buf, buf.length - 4, p);
+
+      buf[p += 4] = SSH_AGENT_FAILURE;
+
+      return respond(this, req, buf);
+    }
+    getIdentitiesReply(req, keys) {
+      if (this[SYM_MODE] !== ROLE_SERVER)
+        throw new Error('Server-only method called with client role');
+
+      if (!(req instanceof AgentInboundRequest))
+        throw new Error('Wrong request argument');
+
+      if (req.hasResponded())
+        return true;
+
+      /*
+         byte        SSH_AGENT_IDENTITIES_ANSWER
+         uint32      nkeys
+
+        where `nkeys` is 0 or more of:
+         string      key blob
+         string      comment
+      */
+
+      if (req.getType() !== SSH_AGENTC_REQUEST_IDENTITIES)
+        throw new Error('Invalid response to request');
+
+      if (!Array.isArray(keys))
+        throw new Error('Keys argument must be an array');
+
+      let totalKeysLen = 4; // Include `nkeys` size
+
+      const newKeys = [];
+      for (let i = 0; i < keys.length; ++i) {
+        const entry = keys[i];
+        if (typeof entry !== 'object' || entry === null)
+          throw new Error(`Invalid key entry: ${entry}`);
+
+        let pubKey;
+        let comment;
+        if (isParsedKey(entry)) {
+          pubKey = entry;
+        } else if (isParsedKey(entry.pubKey)) {
+          pubKey = entry.pubKey;
+        } else {
+          if (typeof entry.pubKey !== 'object' || entry.pubKey === null)
+            continue;
+          ({ pubKey, comment } = entry.pubKey);
+          pubKey = parseKey(pubKey);
+          if (pubKey instanceof Error)
+            continue; // TODO: add debug output
+        }
+        comment = pubKey.comment || comment;
+        pubKey = pubKey.getPublicSSH();
+
+        totalKeysLen += 4 + pubKey.length;
+
+        if (comment && typeof comment === 'string')
+          comment = Buffer.from(comment);
+        else if (!Buffer.isBuffer(comment))
+          comment = EMPTY_BUF;
+
+        totalKeysLen += 4 + comment.length;
+
+        newKeys.push({ pubKey, comment });
       }
-    });
-    proc.once('close', function(code) {
-      self.proc = undefined;
-      if (ERROR[code] && !hadError) {
-        hadError = true;
-        self.emit('error', ERROR[code]);
+
+      let p = 0;
+      const buf = Buffer.allocUnsafe(4 + 1 + totalKeysLen);
+
+      writeUInt32BE(buf, buf.length - 4, p);
+
+      buf[p += 4] = SSH_AGENT_IDENTITIES_ANSWER;
+
+      writeUInt32BE(buf, newKeys.length, ++p);
+      p += 4;
+      for (let i = 0; i < newKeys.length; ++i) {
+        const { pubKey, comment } = newKeys[i];
+
+        writeUInt32BE(buf, pubKey.length, p);
+        pubKey.copy(buf, p += 4);
+
+        writeUInt32BE(buf, comment.length, p += pubKey.length);
+        p += 4;
+        if (comment.length) {
+          comment.copy(buf, p);
+          p += comment.length;
+        }
       }
-      self.emit('close', hadError);
-    });
-    proc.stdin.end(buf);
-  };
-  PageantSock.prototype.end = PageantSock.prototype.destroy = function() {
-    this.buffer = null;
-    if (this.proc) {
-      this.proc.kill();
-      this.proc = undefined;
+
+      return respond(this, req, buf);
+    }
+    signReply(req, signature) {
+      if (this[SYM_MODE] !== ROLE_SERVER)
+        throw new Error('Server-only method called with client role');
+
+      if (!(req instanceof AgentInboundRequest))
+        throw new Error('Wrong request argument');
+
+      if (req.hasResponded())
+        return true;
+
+      /*
+         byte        SSH_AGENT_SIGN_RESPONSE
+         string      signature
+      */
+
+      if (req.getType() !== SSH_AGENTC_SIGN_REQUEST)
+        throw new Error('Invalid response to request');
+
+      if (!Buffer.isBuffer(signature))
+        throw new Error('Signature argument must be a Buffer');
+
+      if (signature.length === 0)
+        throw new Error('Signature argument must be non-empty');
+
+      /*
+        OpenSSH agent signatures are encoded as:
+
+          string    signature format identifier (as specified by the
+                    public key/certificate format)
+          byte[n]   signature blob in format specific encoding.
+            - This is actually a `string` for: rsa, dss, ecdsa, and ed25519
+              types
+      */
+
+      let p = 0;
+      const sigFormat = req.getContext();
+      const sigFormatLen = Buffer.byteLength(sigFormat);
+      const buf = Buffer.allocUnsafe(
+        4 + 1 + 4 + 4 + sigFormatLen + 4 + signature.length
+      );
+
+      writeUInt32BE(buf, buf.length - 4, p);
+
+      buf[p += 4] = SSH_AGENT_SIGN_RESPONSE;
+
+      writeUInt32BE(buf, 4 + sigFormatLen + 4 + signature.length, ++p);
+      writeUInt32BE(buf, sigFormatLen, p += 4);
+      buf.utf8Write(sigFormat, p += 4, sigFormatLen);
+      writeUInt32BE(buf, signature.length, p += sigFormatLen);
+      signature.copy(buf, p += 4);
+
+      return respond(this, req, buf);
     }
   };
-  PageantSock.prototype.connect = function() {
-    this.emit('connect');
-  };
+})();
+
+const SYM_AGENT = Symbol('Agent');
+const SYM_AGENT_KEYS = Symbol('Agent Keys');
+const SYM_AGENT_KEYS_IDX = Symbol('Agent Keys Index');
+const SYM_AGENT_CBS = Symbol('Agent Init Callbacks');
+class AgentContext {
+  constructor(agent) {
+    if (typeof agent === 'string')
+      agent = createAgent(agent);
+    else if (!isAgent(agent))
+      throw new Error('Invalid agent argument');
+    this[SYM_AGENT] = agent;
+    this[SYM_AGENT_KEYS] = null;
+    this[SYM_AGENT_KEYS_IDX] = -1;
+    this[SYM_AGENT_CBS] = null;
+  }
+  init(cb) {
+    if (typeof cb !== 'function')
+      cb = noop;
+
+    if (this[SYM_AGENT_KEYS] === null) {
+      if (this[SYM_AGENT_CBS] === null) {
+        this[SYM_AGENT_CBS] = [cb];
+
+        const doCbs = (...args) => {
+          process.nextTick(() => {
+            const cbs = this[SYM_AGENT_CBS];
+            this[SYM_AGENT_CBS] = null;
+            for (const cb of cbs)
+              cb(...args);
+          });
+        };
+
+        this[SYM_AGENT].getIdentities(once((err, keys) => {
+          if (err)
+            return doCbs(err);
+
+          if (!Array.isArray(keys)) {
+            return doCbs(new Error(
+              'Agent implementation failed to provide keys'
+            ));
+          }
+
+          const newKeys = [];
+          for (let key of keys) {
+            key = parseKey(key);
+            if (key instanceof Error) {
+              // TODO: add debug output
+              continue;
+            }
+            newKeys.push(key);
+          }
+
+          this[SYM_AGENT_KEYS] = newKeys;
+          this[SYM_AGENT_KEYS_IDX] = -1;
+          doCbs();
+        }));
+      } else {
+        this[SYM_AGENT_CBS].push(cb);
+      }
+    } else {
+      process.nextTick(cb);
+    }
+  }
+  nextKey() {
+    if (this[SYM_AGENT_KEYS] === null
+        || ++this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
+      return false;
+    }
+
+    return this[SYM_AGENT_KEYS][this[SYM_AGENT_KEYS_IDX]];
+  }
+  currentKey() {
+    if (this[SYM_AGENT_KEYS] === null
+        || this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
+      return null;
+    }
+
+    return this[SYM_AGENT_KEYS][this[SYM_AGENT_KEYS_IDX]];
+  }
+  pos() {
+    if (this[SYM_AGENT_KEYS] === null
+        || this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
+      return -1;
+    }
+
+    return this[SYM_AGENT_KEYS_IDX];
+  }
+  reset() {
+    this[SYM_AGENT_KEYS_IDX] = -1;
+  }
+
+  sign(...args) {
+    this[SYM_AGENT].sign(...args);
+  }
+}
+
+function isAgent(val) {
+  return (val instanceof BaseAgent);
 }
+
+module.exports = {
+  AgentContext,
+  AgentProtocol,
+  BaseAgent,
+  createAgent,
+  CygwinAgent,
+  isAgent,
+  OpenSSHAgent,
+  PageantAgent,
+};