Initial commit

server/node_modules/ssh2/test/test-openssh.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const assert = require('assert');
+const { inspect } = require('util');
+
+const {
+  fixture,
+  mustCall,
+  mustCallAtLeast,
+  setup: setup_,
+} = require('./common.js');
+
+const debug = false;
+
+const clientCfg = { username: 'foo', password: 'bar' };
+const serverCfg = { hostKeys: [ fixture('ssh_host_rsa_key') ] };
+
+{
+  const { client, server } = setup_(
+    'Exec with OpenSSH agent forwarding',
+    {
+      client: {
+        ...clientCfg,
+        agent: '/path/to/agent',
+      },
+      server: serverCfg,
+
+      debug,
+    },
+  );
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('authentication', mustCall((ctx) => {
+      ctx.accept();
+    })).on('ready', mustCall(() => {
+      conn.on('session', mustCall((accept, reject) => {
+        let sawAuthAgent = false;
+        accept().on('auth-agent', mustCall((accept, reject) => {
+          sawAuthAgent = true;
+          accept && accept();
+        })).on('exec', mustCall((accept, reject, info) => {
+          assert(sawAuthAgent, 'Expected auth-agent before exec');
+          assert(info.command === 'foo --bar',
+                 `Wrong exec command: ${info.command}`);
+          const stream = accept();
+          stream.exit(100);
+          stream.end();
+          conn.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.exec('foo --bar', { agentForward: true }, mustCall((err, stream) => {
+      assert(!err, `Unexpected exec error: ${err}`);
+      stream.resume();
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup_(
+    'OpenSSH forwarded UNIX socket connection',
+    {
+      client: clientCfg,
+      server: {
+        ...serverCfg,
+        ident: 'OpenSSH_7.1',
+      },
+
+      debug,
+    },
+  );
+
+  const socketPath = '/foo';
+  const events = [];
+  const expected = [
+    ['client', 'openssh_forwardInStreamLocal'],
+    ['server', 'streamlocal-forward@openssh.com', { socketPath }],
+    ['client', 'forward callback'],
+    ['client', 'unix connection', { socketPath }],
+    ['client', 'socket data', '1'],
+    ['server', 'socket data', '2'],
+    ['client', 'socket end'],
+    ['server', 'cancel-streamlocal-forward@openssh.com', { socketPath }],
+    ['client', 'cancel callback']
+  ];
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('authentication', mustCall((ctx) => {
+      ctx.accept();
+    })).on('ready', mustCall(() => {
+      conn.once('request', mustCall((accept, reject, name, info) => {
+        events.push(['server', name, info]);
+        assert(name === 'streamlocal-forward@openssh.com',
+               `Wrong request name: ${name}`);
+        accept();
+        conn.openssh_forwardOutStreamLocal(socketPath,
+                                           mustCall((err, ch) => {
+          assert(!err, `Unexpected error: ${err}`);
+          ch.write('1');
+          ch.on('data', mustCallAtLeast((data) => {
+            events.push(['server', 'socket data', data.toString()]);
+            ch.close();
+          }));
+        }));
+
+        conn.on('request', mustCall((accept, reject, name, info) => {
+          events.push(['server', name, info]);
+          assert(name === 'cancel-streamlocal-forward@openssh.com',
+                 `Wrong request name: ${name}`);
+          accept();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    // request forwarding
+    events.push(['client', 'openssh_forwardInStreamLocal']);
+    client.openssh_forwardInStreamLocal(socketPath, mustCall((err) => {
+      assert(!err, `Unexpected error: ${err}`);
+      events.push(['client', 'forward callback']);
+    }));
+    client.on('unix connection', mustCall((info, accept, reject) => {
+      events.push(['client', 'unix connection', info]);
+      const stream = accept();
+      stream.on('data', mustCallAtLeast((data) => {
+        events.push(['client', 'socket data', data.toString()]);
+        stream.write('2');
+      })).on('end', mustCall(() => {
+        events.push(['client', 'socket end']);
+        client.openssh_unforwardInStreamLocal(socketPath,
+                                              mustCall((err) => {
+          assert(!err, `Unexpected error: ${err}`);
+          events.push(['client', 'cancel callback']);
+          client.end();
+        }));
+      }));
+    }));
+  })).on('close', mustCall(() => {
+    assert.deepStrictEqual(
+      events,
+      expected,
+      'Events mismatch\n'
+        + `Actual:\n${inspect(events)}\n`
+        + `Expected:\n${inspect(expected)}`
+    );
+  }));
+}
+
+{
+  const { client, server } = setup_(
+    'OpenSSH UNIX socket connection',
+    {
+      client: clientCfg,
+      server: {
+        ...serverCfg,
+        ident: 'OpenSSH_8.0',
+      },
+
+      debug,
+    },
+  );
+
+  const socketPath = '/foo/bar/baz';
+  const response = 'Hello World';
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('authentication', mustCall((ctx) => {
+      ctx.accept();
+    })).on('ready', mustCall(() => {
+      conn.on('openssh.streamlocal', mustCall((accept, reject, info) => {
+        assert.deepStrictEqual(
+          info,
+          { socketPath },
+          `Wrong info: ${inspect(info)}`
+        );
+
+        const stream = accept();
+        stream.on('close', mustCall(() => {
+          client.end();
+        })).end(response);
+        stream.resume();
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    client.openssh_forwardOutStreamLocal(socketPath, mustCall((err, stream) => {
+      assert(!err, `Unexpected error: ${err}`);
+      let buf = '';
+      stream.on('data', mustCallAtLeast((data) => {
+        buf += data;
+      })).on('close', mustCall(() => {
+        assert(buf === response, `Wrong response: ${inspect(buf)}`);
+      }));
+    }));
+  }));
+}
+
+{
+  const { client, server } = setup_(
+    'OpenSSH 5.x workaround for binding on port 0',
+    {
+      client: clientCfg,
+      server: {
+        ...serverCfg,
+        ident: 'OpenSSH_5.3',
+      },
+
+      debug,
+    },
+  );
+
+  const boundAddr = 'good';
+  const boundPort = 1337;
+  const tcpInfo = {
+    destIP: boundAddr,
+    destPort: boundPort,
+    srcIP: 'remote',
+    srcPort: 12345,
+  };
+
+  server.on('connection', mustCall((conn) => {
+    conn.on('authentication', mustCall((ctx) => {
+      ctx.accept();
+    })).on('ready', mustCall(() => {
+      conn.on('request', mustCall((accept, reject, name, info) => {
+        assert(name === 'tcpip-forward', `Unexpected request: ${name}`);
+        assert(info.bindAddr === boundAddr, `Wrong addr: ${info.bindAddr}`);
+        assert(info.bindPort === 0, `Wrong port: ${info.bindPort}`);
+        accept(boundPort);
+        conn.forwardOut(boundAddr,
+                        0,
+                        tcpInfo.srcIP,
+                        tcpInfo.srcPort,
+                        mustCall((err, ch) => {
+          assert(!err, `Unexpected error: ${err}`);
+          client.end();
+        }));
+      }));
+    }));
+  }));
+
+  client.on('ready', mustCall(() => {
+    // request forwarding
+    client.forwardIn(boundAddr, 0, mustCall((err, port) => {
+      assert(!err, `Unexpected error: ${err}`);
+      assert(port === boundPort, `Bad bound port: ${port}`);
+    }));
+  })).on('tcp connection', mustCall((details, accept, reject) => {
+    assert.deepStrictEqual(
+      details,
+      tcpInfo,
+      `Wrong tcp details: ${inspect(details)}`
+    );
+    accept();
+  }));
+}