dsh-remote 0.8.46 → 0.8.48

package/node_modules/ssh2/lib/utils.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const { SFTP } = require('./protocol/SFTP.js');
+
+const MAX_CHANNEL = 2 ** 32 - 1;
+
+function onChannelOpenFailure(self, recipient, info, cb) {
+  self._chanMgr.remove(recipient);
+  if (typeof cb !== 'function')
+    return;
+
+  let err;
+  if (info instanceof Error) {
+    err = info;
+  } else if (typeof info === 'object' && info !== null) {
+    err = new Error(`(SSH) Channel open failure: ${info.description}`);
+    err.reason = info.reason;
+  } else {
+    err = new Error(
+      '(SSH) Channel open failure: server closed channel unexpectedly'
+    );
+    err.reason = '';
+  }
+
+  cb(err);
+}
+
+function onCHANNEL_CLOSE(self, recipient, channel, err, dead) {
+  if (typeof channel === 'function') {
+    // We got CHANNEL_CLOSE instead of CHANNEL_OPEN_FAILURE when
+    // requesting to open a channel
+    onChannelOpenFailure(self, recipient, err, channel);
+    return;
+  }
+
+  if (typeof channel !== 'object' || channel === null)
+    return;
+
+  if (channel.incoming && channel.incoming.state === 'closed')
+    return;
+
+  self._chanMgr.remove(recipient);
+
+  if (channel.server && channel.constructor.name === 'Session')
+    return;
+
+  channel.incoming.state = 'closed';
+
+  if (channel.readable)
+    channel.push(null);
+  if (channel.server) {
+    if (channel.stderr.writable)
+      channel.stderr.end();
+  } else if (channel.stderr.readable) {
+    channel.stderr.push(null);
+  }
+
+  if (channel.constructor !== SFTP
+      && (channel.outgoing.state === 'open'
+          || channel.outgoing.state === 'eof')
+      && !dead) {
+    channel.close();
+  }
+  if (channel.outgoing.state === 'closing')
+    channel.outgoing.state = 'closed';
+
+  const readState = channel._readableState;
+  const writeState = channel._writableState;
+  if (writeState && !writeState.ending && !writeState.finished && !dead)
+    channel.end();
+
+  // Take care of any outstanding channel requests
+  const chanCallbacks = channel._callbacks;
+  channel._callbacks = [];
+  for (let i = 0; i < chanCallbacks.length; ++i)
+    chanCallbacks[i](true);
+
+  if (channel.server) {
+    if (!channel.readable
+        || channel.destroyed
+        || (readState && readState.endEmitted)) {
+      channel.emit('close');
+    } else {
+      channel.once('end', () => channel.emit('close'));
+    }
+  } else {
+    let doClose;
+    switch (channel.type) {
+      case 'direct-streamlocal@openssh.com':
+      case 'direct-tcpip':
+        doClose = () => channel.emit('close');
+        break;
+      default: {
+        // Align more with node child processes, where the close event gets
+        // the same arguments as the exit event
+        const exit = channel._exit;
+        doClose = () => {
+          if (exit.code === null)
+            channel.emit('close', exit.code, exit.signal, exit.dump, exit.desc);
+          else
+            channel.emit('close', exit.code);
+        };
+      }
+    }
+    if (!channel.readable
+        || channel.destroyed
+        || (readState && readState.endEmitted)) {
+      doClose();
+    } else {
+      channel.once('end', doClose);
+    }
+
+    const errReadState = channel.stderr._readableState;
+    if (!channel.stderr.readable
+        || channel.stderr.destroyed
+        || (errReadState && errReadState.endEmitted)) {
+      channel.stderr.emit('close');
+    } else {
+      channel.stderr.once('end', () => channel.stderr.emit('close'));
+    }
+  }
+}
+
+class ChannelManager {
+  constructor(client) {
+    this._client = client;
+    this._channels = {};
+    this._cur = -1;
+    this._count = 0;
+  }
+  add(val) {
+    // Attempt to reserve an id
+
+    let id;
+    // Optimized paths
+    if (this._cur < MAX_CHANNEL) {
+      id = ++this._cur;
+    } else if (this._count === 0) {
+      // Revert and reset back to fast path once we no longer have any channels
+      // open
+      this._cur = 0;
+      id = 0;
+    } else {
+      // Slower lookup path
+
+      // This path is triggered we have opened at least MAX_CHANNEL channels
+      // while having at least one channel open at any given time, so we have
+      // to search for a free id.
+      const channels = this._channels;
+      for (let i = 0; i < MAX_CHANNEL; ++i) {
+        if (channels[i] === undefined) {
+          id = i;
+          break;
+        }
+      }
+    }
+
+    if (id === undefined)
+      return -1;
+
+    this._channels[id] = (val || true);
+    ++this._count;
+
+    return id;
+  }
+  update(id, val) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    if (val && this._channels[id])
+      this._channels[id] = val;
+  }
+  get(id) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    return this._channels[id];
+  }
+  remove(id) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    if (this._channels[id]) {
+      delete this._channels[id];
+      if (this._count)
+        --this._count;
+    }
+  }
+  cleanup(err) {
+    const channels = this._channels;
+    this._channels = {};
+    this._cur = -1;
+    this._count = 0;
+
+    const chanIDs = Object.keys(channels);
+    const client = this._client;
+    for (let i = 0; i < chanIDs.length; ++i) {
+      const id = +chanIDs[i];
+      const channel = channels[id];
+      onCHANNEL_CLOSE(client, id, channel._channel || channel, err, true);
+    }
+  }
+}
+
+const isRegExp = (() => {
+  const toString = Object.prototype.toString;
+  return (val) => toString.call(val) === '[object RegExp]';
+})();
+
+function generateAlgorithmList(algoList, defaultList, supportedList) {
+  if (Array.isArray(algoList) && algoList.length > 0) {
+    // Exact list
+    for (let i = 0; i < algoList.length; ++i) {
+      if (supportedList.indexOf(algoList[i]) === -1)
+        throw new Error(`Unsupported algorithm: ${algoList[i]}`);
+    }
+    return algoList;
+  }
+
+  if (typeof algoList === 'object' && algoList !== null) {
+    // Operations based on the default list
+    const keys = Object.keys(algoList);
+    let list = defaultList;
+    for (let i = 0; i < keys.length; ++i) {
+      const key = keys[i];
+      let val = algoList[key];
+      switch (key) {
+        case 'append':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = 0; j < val.length; ++j) {
+              const append = val[j];
+              if (typeof append === 'string') {
+                if (!append || list.indexOf(append) !== -1)
+                  continue;
+                if (supportedList.indexOf(append) === -1)
+                  throw new Error(`Unsupported algorithm: ${append}`);
+                if (list === defaultList)
+                  list = list.slice();
+                list.push(append);
+              } else if (isRegExp(append)) {
+                for (let k = 0; k < supportedList.length; ++k) {
+                  const algo = supportedList[k];
+                  if (append.test(algo)) {
+                    if (list.indexOf(algo) !== -1)
+                      continue;
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.push(algo);
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case 'prepend':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = val.length; j >= 0; --j) {
+              const prepend = val[j];
+              if (typeof prepend === 'string') {
+                if (!prepend || list.indexOf(prepend) !== -1)
+                  continue;
+                if (supportedList.indexOf(prepend) === -1)
+                  throw new Error(`Unsupported algorithm: ${prepend}`);
+                if (list === defaultList)
+                  list = list.slice();
+                list.unshift(prepend);
+              } else if (isRegExp(prepend)) {
+                for (let k = supportedList.length; k >= 0; --k) {
+                  const algo = supportedList[k];
+                  if (prepend.test(algo)) {
+                    if (list.indexOf(algo) !== -1)
+                      continue;
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.unshift(algo);
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case 'remove':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = 0; j < val.length; ++j) {
+              const search = val[j];
+              if (typeof search === 'string') {
+                if (!search)
+                  continue;
+                const idx = list.indexOf(search);
+                if (idx === -1)
+                  continue;
+                if (list === defaultList)
+                  list = list.slice();
+                list.splice(idx, 1);
+              } else if (isRegExp(search)) {
+                for (let k = 0; k < list.length; ++k) {
+                  if (search.test(list[k])) {
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.splice(k, 1);
+                    --k;
+                  }
+                }
+              }
+            }
+          }
+          break;
+      }
+    }
+
+    return list;
+  }
+
+  return defaultList;
+}
+
+module.exports = {
+  ChannelManager,
+  generateAlgorithmList,
+  onChannelOpenFailure,
+  onCHANNEL_CLOSE,
+  isWritable: (stream) => {
+    // XXX: hack to workaround regression in node
+    // See: https://github.com/nodejs/node/issues/36029
+    return (stream
+            && stream.writable
+            && stream._readableState
+            && stream._readableState.ended === false);
+  },
+};

package/node_modules/ssh2/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "ssh2",
+  "version": "1.17.0",
+  "author": "Brian White <mscdex@mscdex.net>",
+  "description": "SSH2 client and server modules written in pure JavaScript for node.js",
+  "main": "./lib/index.js",
+  "engines": {
+    "node": ">=10.16.0"
+  },
+  "dependencies": {
+    "asn1": "^0.2.6",
+    "bcrypt-pbkdf": "^1.0.2"
+  },
+  "devDependencies": {
+    "@mscdex/eslint-config": "^1.1.0",
+    "eslint": "^7.32.0"
+  },
+  "optionalDependencies": {
+    "cpu-features": "~0.0.10",
+    "nan": "^2.23.0"
+  },
+  "scripts": {
+    "install": "node install.js",
+    "rebuild": "node install.js",
+    "test": "node test/test.js",
+    "lint": "eslint --cache --report-unused-disable-directives --ext=.js .eslintrc.js examples lib test",
+    "lint:fix": "npm run lint -- --fix"
+  },
+  "keywords": [
+    "ssh",
+    "ssh2",
+    "sftp",
+    "secure",
+    "shell",
+    "exec",
+    "remote",
+    "client"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/mscdex/ssh2/raw/master/LICENSE"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mscdex/ssh2.git"
+  }
+}

package/node_modules/ssh2/test/common.js

@@ -0,0 +1,316 @@
+'use strict';
+
+const assert = require('assert');
+const { readFileSync } = require('fs');
+const { join } = require('path');
+const { inspect } = require('util');
+
+const Client = require('../lib/client.js');
+const Server = require('../lib/server.js');
+const { parseKey } = require('../lib/protocol/keyParser.js');
+
+const mustCallChecks = [];
+
+const DEFAULT_TEST_TIMEOUT = 30 * 1000;
+
+function noop() {}
+
+function runCallChecks(exitCode) {
+  if (exitCode !== 0) return;
+
+  const failed = mustCallChecks.filter((context) => {
+    if ('minimum' in context) {
+      context.messageSegment = `at least ${context.minimum}`;
+      return context.actual < context.minimum;
+    }
+    context.messageSegment = `exactly ${context.exact}`;
+    return context.actual !== context.exact;
+  });
+
+  failed.forEach((context) => {
+    console.error('Mismatched %s function calls. Expected %s, actual %d.',
+                  context.name,
+                  context.messageSegment,
+                  context.actual);
+    console.error(context.stack.split('\n').slice(2).join('\n'));
+  });
+
+  if (failed.length)
+    process.exit(1);
+}
+
+function mustCall(fn, exact) {
+  return _mustCallInner(fn, exact, 'exact');
+}
+
+function mustCallAtLeast(fn, minimum) {
+  return _mustCallInner(fn, minimum, 'minimum');
+}
+
+function _mustCallInner(fn, criteria = 1, field) {
+  if (process._exiting)
+    throw new Error('Cannot use common.mustCall*() in process exit handler');
+
+  if (typeof fn === 'number') {
+    criteria = fn;
+    fn = noop;
+  } else if (fn === undefined) {
+    fn = noop;
+  }
+
+  if (typeof criteria !== 'number')
+    throw new TypeError(`Invalid ${field} value: ${criteria}`);
+
+  const context = {
+    [field]: criteria,
+    actual: 0,
+    stack: inspect(new Error()),
+    name: fn.name || '<anonymous>'
+  };
+
+  // Add the exit listener only once to avoid listener leak warnings
+  if (mustCallChecks.length === 0)
+    process.on('exit', runCallChecks);
+
+  mustCallChecks.push(context);
+
+  function wrapped(...args) {
+    ++context.actual;
+    return fn.call(this, ...args);
+  }
+  // TODO: remove origFn?
+  wrapped.origFn = fn;
+
+  return wrapped;
+}
+
+function getCallSite(top) {
+  const originalStackFormatter = Error.prepareStackTrace;
+  Error.prepareStackTrace = (err, stack) =>
+    `${stack[0].getFileName()}:${stack[0].getLineNumber()}`;
+  const err = new Error();
+  Error.captureStackTrace(err, top);
+  // With the V8 Error API, the stack is not formatted until it is accessed
+  // eslint-disable-next-line no-unused-expressions
+  err.stack;
+  Error.prepareStackTrace = originalStackFormatter;
+  return err.stack;
+}
+
+function mustNotCall(msg) {
+  const callSite = getCallSite(mustNotCall);
+  return function mustNotCall(...args) {
+    args = args.map(inspect).join(', ');
+    const argsInfo = (args.length > 0
+                      ? `\ncalled with arguments: ${args}`
+                      : '');
+    assert.fail(
+      `${msg || 'function should not have been called'} at ${callSite}`
+        + argsInfo);
+  };
+}
+
+function setup(title, configs) {
+  const {
+    client: clientCfg_,
+    server: serverCfg_,
+    allReady: allReady_,
+    timeout: timeout_,
+    debug,
+    noForceClientReady,
+    noForceServerReady,
+    noClientError,
+    noServerError,
+  } = configs;
+
+  // Make shallow copies of client/server configs to avoid mutating them when
+  // multiple tests share the same config object reference
+  let clientCfg;
+  if (clientCfg_)
+    clientCfg = { ...clientCfg_ };
+  let serverCfg;
+  if (serverCfg_)
+    serverCfg = { ...serverCfg_ };
+
+  let clientClose = false;
+  let clientReady = false;
+  let serverClose = false;
+  let serverReady = false;
+  const msg = (text) => {
+    return `${title}: ${text}`;
+  };
+
+  const timeout = (typeof timeout_ === 'number'
+                   ? timeout_
+                   : DEFAULT_TEST_TIMEOUT);
+
+  const allReady = (typeof allReady_ === 'function' ? allReady_ : undefined);
+
+  if (debug) {
+    if (clientCfg) {
+      clientCfg.debug = (...args) => {
+        console.log(`[${title}][CLIENT]`, ...args);
+      };
+    }
+    if (serverCfg) {
+      serverCfg.debug = (...args) => {
+        console.log(`[${title}][SERVER]`, ...args);
+      };
+    }
+  }
+
+  let timer;
+  let client;
+  let clientReadyFn;
+  let server;
+  let serverReadyFn;
+  if (clientCfg) {
+    client = new Client();
+    if (!noClientError)
+      client.on('error', onError);
+    clientReadyFn = (noForceClientReady ? onReady : mustCall(onReady));
+    client.on('ready', clientReadyFn)
+          .on('close', mustCall(onClose));
+  } else {
+    clientReady = clientClose = true;
+  }
+
+  if (serverCfg) {
+    server = new Server(serverCfg);
+    if (!noServerError)
+      server.on('error', onError);
+    serverReadyFn = (noForceServerReady ? onReady : mustCall(onReady));
+    server.on('connection', mustCall((conn) => {
+      if (!noServerError)
+        conn.on('error', onError);
+      conn.on('ready', serverReadyFn);
+      server.close();
+    })).on('close', mustCall(onClose));
+  } else {
+    serverReady = serverClose = true;
+  }
+
+  function onError(err) {
+    const which = (this === client ? 'client' : 'server');
+    assert(false, msg(`Unexpected ${which} error: ${err.stack}\n`));
+  }
+
+  function onReady() {
+    if (this === client) {
+      assert(!clientReady,
+             msg('Received multiple ready events for client'));
+      clientReady = true;
+    } else {
+      assert(!serverReady,
+             msg('Received multiple ready events for server'));
+      serverReady = true;
+    }
+    clientReady && serverReady && allReady && allReady();
+  }
+
+  function onClose() {
+    if (this === client) {
+      assert(!clientClose,
+             msg('Received multiple close events for client'));
+      clientClose = true;
+    } else {
+      assert(!serverClose,
+             msg('Received multiple close events for server'));
+      serverClose = true;
+    }
+    if (clientClose && serverClose)
+      clearTimeout(timer);
+  }
+
+  process.nextTick(mustCall(() => {
+    function connectClient() {
+      if (clientCfg.sock) {
+        clientCfg.sock.connect(server.address().port, 'localhost');
+      } else {
+        clientCfg.host = 'localhost';
+        clientCfg.port = server.address().port;
+      }
+      try {
+        client.connect(clientCfg);
+      } catch (ex) {
+        ex.message = msg(ex.message);
+        throw ex;
+      }
+    }
+
+    if (server) {
+      server.listen(0, 'localhost', mustCall(() => {
+        if (timeout >= 0) {
+          timer = setTimeout(() => {
+            assert(false, msg('Test timed out'));
+          }, timeout);
+        }
+        if (client)
+          connectClient();
+      }));
+    }
+  }));
+
+  return { client, server };
+}
+
+const FIXTURES_DIR = join(__dirname, 'fixtures');
+const fixture = (() => {
+  const cache = new Map();
+  return (file) => {
+    const existing = cache.get(file);
+    if (existing !== undefined)
+      return existing;
+
+    const result = readFileSync(join(FIXTURES_DIR, file));
+    cache.set(file, result);
+    return result;
+  };
+})();
+const fixtureKey = (() => {
+  const cache = new Map();
+  return (file, passphrase, bypass) => {
+    if (typeof passphrase === 'boolean') {
+      bypass = passphrase;
+      passphrase = undefined;
+    }
+    if (typeof bypass !== 'boolean' || !bypass) {
+      const existing = cache.get(file);
+      if (existing !== undefined)
+        return existing;
+    }
+    const fullPath = join(FIXTURES_DIR, file);
+    const raw = fixture(file);
+    let key = parseKey(raw, passphrase);
+    if (Array.isArray(key))
+      key = key[0];
+    const result = { key, raw, fullPath };
+    cache.set(file, result);
+    return result;
+  };
+})();
+
+function setupSimple(debug, title) {
+  const { client, server } = setup(title, {
+    client: { username: 'Password User', password: '12345' },
+    server: { hostKeys: [ fixtureKey('ssh_host_rsa_key').raw ] },
+    debug,
+  });
+  server.on('connection', mustCall((conn) => {
+    conn.on('authentication', mustCall((ctx) => {
+      ctx.accept();
+    }));
+  }));
+  return { client, server };
+}
+
+module.exports = {
+  fixture,
+  fixtureKey,
+  FIXTURES_DIR,
+  mustCall,
+  mustCallAtLeast,
+  mustNotCall,
+  setup,
+  setupSimple,
+};