bdy 1.23.6-dev → 1.23.7-dev

package/node_modules/ssh2/test/test-shell.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const assert = require('assert');
+const { inspect } = require('util');
+
+const {
+  mustCall,
+  mustCallAtLeast,
+  setupSimple,
+} = require('./common.js');
+
+const DEBUG = false;
+
+const setup = setupSimple.bind(undefined, DEBUG);
+
+{
+  const { client, server } = setup('Simple shell()');
+
+  const OUTPUT = 'shell output!\n';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        const session = accept();
+        session.on('pty', mustCall((accept, reject, info) => {
+          accept();
+          session.on('shell', mustCall((accept, reject) => {
+            let input = '';
+            const stream = accept();
+            stream.write(OUTPUT);
+            stream.on('data', mustCallAtLeast((data) => {
+              input += data;
+              if (input === 'exit\n') {
+                stream.end();
+                conn.end();
+              }
+            }));
+          }));
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let output = '';
+    client.on('close', mustCall(() => {
+      assert(output === OUTPUT, `Wrong shell output: ${inspect(output)}`);
+    })).shell(mustCall((err, stream) => {
+      assert(!err, `Unexpected shell error: ${err}`);
+      stream.write('exit\n');
+      stream.on('data', mustCallAtLeast((d) => {
+        output += d;
+      })).on('close', mustCall(() => {}));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup('Shell with environment set');
+
+  const OUTPUT = 'shell output!\n';
+  const clientEnv = { SSH2NODETEST: 'foo' };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let pty = false;
+        let env = false;
+        accept().on('pty', mustCall((accept, reject, info) => {
+          accept();
+          pty = true;
+        })).on('env', mustCall((accept, reject, info) => {
+          accept && accept();
+          env = true;
+          assert(info.key === Object.keys(clientEnv)[0],
+                 `Wrong env key: ${inspect(info.key)}`);
+          assert(info.val === Object.values(clientEnv)[0],
+                 `Wrong env value: ${inspect(info.val)}`);
+        })).on('shell', mustCall((accept, reject) => {
+          assert(pty, 'Expected pty before shell');
+          assert(env, 'Expected env before shell');
+          let input = '';
+          const stream = accept();
+          stream.write(OUTPUT);
+          stream.on('data', mustCallAtLeast((data) => {
+            input += data;
+            if (input === 'exit\n') {
+              stream.end();
+              conn.end();
+            }
+          }));
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    let output = '';
+    client.on('close', mustCall(() => {
+      assert(output === OUTPUT, `Wrong shell output: ${inspect(output)}`);
+    })).shell({ env: clientEnv }, mustCall((err, stream) => {
+      assert(!err, `Unexpected shell error: ${err}`);
+      stream.write('exit\n');
+      stream.on('data', mustCallAtLeast((d) => {
+        output += d;
+      })).on('close', mustCall(() => {}));
+    }));
+  }));
+}

package/node_modules/ssh2/test/test-userauth-agent-openssh.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const debug = false;
+const SPAWN_OPTS = { windowsHide: true };
+
+// TODO: figure out why this test is failing on Windows
+if (process.platform === 'win32') {
+  console.log('Skipping ssh-agent test on Windows');
+  process.exit(0);
+}
+
+if (process.argv[2] === 'child') {
+  const {
+    fixtureKey,
+    mustCall,
+    setup,
+  } = require('./common.js');
+
+  const serverCfg = { hostKeys: [ fixtureKey('ssh_host_rsa_key').raw ] };
+
+  const clientKey = fixtureKey('openssh_new_rsa');
+
+  // Add key to the agent first
+  {
+    const {
+      error, status
+    } = spawnSync('ssh-add', [ clientKey.fullPath ], SPAWN_OPTS);
+    if (error || status !== 0) {
+      console.error('Failed to add key to agent');
+      process.exit(1);
+    }
+  }
+
+  const username = 'Agent User';
+  const { server } = setup(
+    'Agent authentication',
+    {
+      client: { username, agent: process.env.SSH_AUTH_SOCK },
+      server: serverCfg,
+
+      debug,
+    }
+  );
+
+  server.on('connection', mustCall((conn) => {
+    let authAttempt = 0;
+    conn.on('authentication', mustCall((ctx) => {
+      assert(ctx.username === username,
+             `Wrong username: ${ctx.username}`);
+      switch (++authAttempt) {
+        case 1:
+          assert(ctx.method === 'none', `Wrong auth method: ${ctx.method}`);
+          return ctx.reject();
+        case 3:
+          assert(ctx.signature, 'Missing publickey signature');
+        // FALLTHROUGH
+        case 2:
+          assert(ctx.method === 'publickey',
+                 `Wrong auth method: ${ctx.method}`);
+          assert(ctx.key.algo === clientKey.key.type,
+                 `Wrong key algo: ${ctx.key.algo}`);
+          assert.deepStrictEqual(clientKey.key.getPublicSSH(),
+                                 ctx.key.data,
+                                 'Public key mismatch');
+          break;
+      }
+      if (ctx.signature) {
+        const result =
+          clientKey.key.verify(ctx.blob, ctx.signature, ctx.hashAlgo);
+        assert(result === true, 'Could not verify publickey signature');
+      }
+      ctx.accept();
+    }, 3)).on('ready', mustCall(() => {
+      conn.end();
+    }));
+  }));
+} else {
+  {
+    const {
+      error, status
+    } = spawnSync('which', ['ssh-agent'], SPAWN_OPTS);
+
+    if (error || status !== 0) {
+      console.log('No ssh-agent available, skipping agent test ...');
+      process.exit(0);
+    }
+  }
+
+  {
+    const {
+      error, status
+    } = spawnSync('which', ['ssh-add'], SPAWN_OPTS);
+
+    if (error || status !== 0) {
+      console.log('No ssh-add available, skipping agent test ...');
+      process.exit(0);
+    }
+  }
+
+  const {
+    error, status
+  } = spawnSync('ssh-agent',
+                [ process.execPath, __filename, 'child' ],
+                { ...SPAWN_OPTS, stdio: 'inherit' });
+  if (error || status !== 0)
+    throw new Error('Agent test failed');
+}

package/node_modules/ssh2/test/test-userauth-agent.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const assert = require('assert');
+
+const debug = false;
+
+const {
+  fixtureKey,
+  mustCall,
+  setup,
+} = require('./common.js');
+const {
+  AgentProtocol,
+  BaseAgent,
+  utils: { parseKey },
+} = require('../lib/index.js');
+
+const serverCfg = { hostKeys: [ fixtureKey('ssh_host_rsa_key').raw ] };
+
+const clientKey = fixtureKey('openssh_new_rsa');
+
+{
+  let getIdentitiesCount = 0;
+  let signCount = 0;
+  class MyAgent extends BaseAgent {
+    getIdentities(cb) {
+      assert.strictEqual(++getIdentitiesCount, 1);
+      // Ensure that no private portion of the key is used by re-parsing the
+      // public version of the key
+      cb(null, [ parseKey(clientKey.key.getPublicSSH()) ]);
+    }
+    sign(pubKey, data, options, cb) {
+      assert.strictEqual(++signCount, 1);
+      assert.strictEqual(pubKey.getPublicPEM(), clientKey.key.getPublicPEM());
+      const sig = clientKey.key.sign(data, options.hash);
+      cb(null, sig);
+    }
+  }
+
+  const username = 'Agent User';
+  const { server } = setup(
+    'Custom agent authentication',
+    {
+      client: { username, agent: new MyAgent() },
+      server: serverCfg,
+
+      debug,
+    }
+  );
+
+  server.on('connection', mustCall((conn) => {
+    let authAttempt = 0;
+    conn.on('authentication', mustCall((ctx) => {
+      assert(ctx.username === username,
+             `Wrong username: ${ctx.username}`);
+      switch (++authAttempt) {
+        case 1:
+          assert(ctx.method === 'none', `Wrong auth method: ${ctx.method}`);
+          return ctx.reject();
+        case 3:
+          assert(ctx.signature, 'Missing publickey signature');
+        // FALLTHROUGH
+        case 2:
+          assert(ctx.method === 'publickey',
+                 `Wrong auth method: ${ctx.method}`);
+          assert(ctx.key.algo === clientKey.key.type,
+                 `Wrong key algo: ${ctx.key.algo}`);
+          assert.deepStrictEqual(clientKey.key.getPublicSSH(),
+                                 ctx.key.data,
+                                 'Public key mismatch');
+          break;
+      }
+      if (ctx.signature) {
+        const result =
+          clientKey.key.verify(ctx.blob, ctx.signature, ctx.hashAlgo);
+        assert(result === true, 'Could not verify publickey signature');
+      }
+      ctx.accept();
+    }, 3)).on('ready', mustCall(() => {
+      assert.strictEqual(getIdentitiesCount, 1);
+      assert.strictEqual(signCount, 1);
+      conn.end();
+    }));
+  }));
+}
+{
+  const client = new AgentProtocol(true);
+  const server = new AgentProtocol(false);
+
+  server.on('identities', mustCall((req) => {
+    setImmediate(() => server.failureReply(req));
+  }));
+  client.getIdentities(mustCall((err, keys) => {
+    assert(err, 'Missing expected error');
+  }));
+
+  client.pipe(server).pipe(client);
+}
+{
+  const client = new AgentProtocol(true);
+  const server = new AgentProtocol(false);
+
+  server.on('identities', mustCall((req) => {
+    const keys = [ clientKey.key ];
+    server.getIdentitiesReply(req, keys);
+  }));
+  client.getIdentities(mustCall((err, keys) => {
+    assert(!err, 'Unexpected error');
+    assert.strictEqual(keys.length, 1);
+    assert.strictEqual(keys[0].isPrivateKey(), false);
+    assert.strictEqual(keys[0].getPublicPEM(), clientKey.key.getPublicPEM());
+  }));
+
+  client.pipe(server).pipe(client);
+}
+{
+  const client = new AgentProtocol(true);
+  const server = new AgentProtocol(false);
+  const buf = Buffer.from('data to sign');
+
+  server.on('sign', mustCall((req, pubKey, data, options) => {
+    assert.strictEqual(pubKey.getPublicPEM(), clientKey.key.getPublicPEM());
+    assert.deepStrictEqual(data, buf);
+    assert.strictEqual(options.hash, undefined);
+    server.failureReply(req);
+  }));
+  client.sign(clientKey.key.getPublicSSH(),
+              buf,
+              mustCall((err, signature) => {
+    assert(err, 'Missing expected error');
+  }));
+
+  client.pipe(server).pipe(client);
+}
+{
+  const client = new AgentProtocol(true);
+  const server = new AgentProtocol(false);
+  const buf = Buffer.from('data to sign');
+
+  server.on('sign', mustCall((req, pubKey, data, options) => {
+    assert.strictEqual(pubKey.getPublicPEM(), clientKey.key.getPublicPEM());
+    assert.deepStrictEqual(data, buf);
+    assert.strictEqual(options.hash, undefined);
+    server.signReply(req, clientKey.key.sign(data));
+  }));
+  client.sign(clientKey.key.getPublicSSH(),
+              buf,
+              mustCall((err, signature) => {
+    assert(!err, 'Unexpected error');
+    const pubKey = parseKey(clientKey.key.getPublicSSH());
+    assert.strictEqual(pubKey.verify(buf, signature), true);
+  }));
+
+  client.pipe(server).pipe(client);
+}
+{
+  // Test that outstanding requests are handled upon unexpected closure of the
+  // protocol stream
+
+  const client = new AgentProtocol(true);
+  const server = new AgentProtocol(false);
+
+  server.on('identities', mustCall((req) => {
+    server.destroy();
+  }));
+  client.getIdentities(mustCall((err) => {
+    assert(err, 'Missing expected error');
+  }));
+
+  client.pipe(server).pipe(client);
+}