ssh_tunnel_proxy 1.2.2 → 1.2.4

package/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "overrides": [
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest"
+    },
+    "rules": {
+    }
+}

package/lib/index.js

@@ -17,18 +17,14 @@ License: MIT
 */
 
 const net = require('net');
-const { EventEmitter } = require('node:events');
 const { Client } = require('electron-ssh2');
 
 const KeypairStorage = require('./keypair_storage');
 const NgrokApi = require('./ngrok_service');
 
-// debug logging options
-const debug_ssh = false;
-
 const keypairStorage = new KeypairStorage();
 
-class sshTunnelProxy extends EventEmitter {
+class SSHTunnelProxy extends Client {
 
     constructor() {
         super();
@@ -46,14 +42,14 @@ class sshTunnelProxy extends EventEmitter {
         proxy_ports.forEach(proxy_port => {
             const server = this.listener[server_name][proxy_port];
             if (server && server.listening) {
-                this.debug_en &&this.debug('SSH Server :: closing forward:', proxy_port)
+                this.debug_en && this.debug('SSH Server :: closing forward:', proxy_port)
                 server.close();
             }
         });
     }
 
     // create forward out on socket connection
-    setup_ssh_forward(ssh_client, socket, remote_hostname, remote_port) {
+    setup_ssh_forward(socket, remote_hostname, remote_port) {
         const _this = this;
 
         // setup stream pipeline when port forward is ready
@@ -61,7 +57,7 @@ class sshTunnelProxy extends EventEmitter {
 
             if (err) {
                 _this.emit('debug', err);
-                _this.debug_en &&_this.debug('socket forward error:', err);
+                _this.debug_en && _this.debug('socket forward error:', err);
                 return;
             }
 
@@ -77,13 +73,13 @@ class sshTunnelProxy extends EventEmitter {
             // if socket error, emit error and close stream
             socket.on('error', (err) => {
                 _this.emit('debug', err);
-                _this.debug_en &&_this.debug('socket on error:', err);
+                _this.debug_en && _this.debug('socket on error:', err);
                 stream.end();
             });
         }
 
         // create port forward
-        ssh_client.forwardOut(
+        _this.forwardOut(
             socket.remoteAddress,
             socket.remotePort,
             remote_hostname,
@@ -94,7 +90,7 @@ class sshTunnelProxy extends EventEmitter {
     }
 
     // function to setup proxy forwards for ssh tunnel
-    on_ssh_client_ready(ssh_client, server_name, proxy_ports, resolve) {
+    on_ssh_client_ready(server_name, proxy_ports, resolve) {
 
         var listeners = 0;
         if (this.listener[server_name]) this.listener[server_name].isConnected = true;
@@ -108,9 +104,10 @@ class sshTunnelProxy extends EventEmitter {
             // create local socket server
             const server = this.listener[server_name][proxy_port];
             if (server && server.listening) {
-                this.debug_en &&this.debug('SSH Server :: closing forward:', proxy_port)
+                this.debug_en && this.debug('SSH Server :: closing forward 2:', proxy_port)
                 server.close();
             }
+            this.listener[server_name][proxy_port] = null;
             this.listener[server_name][proxy_port] = net.createServer({ keepAlive: true, allowHalfOpen: false }, socket => {
 
                 if (this.debug_en) {
@@ -120,11 +117,13 @@ class sshTunnelProxy extends EventEmitter {
                 }
 
                 // create a proxy forward between local and remote ports
-                _this.setup_ssh_forward(ssh_client, socket, remote_hostname, remote_port);
+                _this.setup_ssh_forward(socket, remote_hostname, remote_port);
             });
 
             // start listening on port
             try {
+                var status_msg = 'SSH Server :: before listen on ' + local_port;
+                _this.emit('debug', status_msg);
                 _this.listener[server_name][proxy_port].listen(local_port, () => {
 
                     // emit server listening on port message
@@ -133,15 +132,15 @@ class sshTunnelProxy extends EventEmitter {
 
                     // if all listeners have been successfully established, resolve setup connection
                     if (listeners++ >= proxy_ports.length - 1) {
-                        _this.emit('ready', {});
+                        _this.emit('ssh_tunnel_ready', {});
                         resolve();
                     }
                 });
             } catch (err) {
-                _this.debug_en &&_this.debug('listen err:', err);
+                _this.debug_en && _this.debug('listen err:', err);
             }
         });
-    };
+    }
 
     // handle setting up ssh client and proxy forward ports
     do_ssh_connect(opts) {
@@ -149,7 +148,7 @@ class sshTunnelProxy extends EventEmitter {
         const _this = this;
 
         // create a new ssh client connection with supplied credentials and hostname/port
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
 
             // exit if connection already established, avoid redundant connection on retry
             if (_this.listener[opts.server_name] && _this.listener[opts.server_name].isConnected) resolve();
@@ -161,46 +160,46 @@ class sshTunnelProxy extends EventEmitter {
                 _this.listener[opts.server_name] = {};
             }
 
-            const ssh_client = new Client();
-
-            ssh_client.on('ready', () => {
-                _this.on_ssh_client_ready(ssh_client, opts.server_name, opts.proxy_ports, resolve);
+            _this.on('ready', () => {
+                _this.on_ssh_client_ready(opts.server_name, opts.proxy_ports, resolve);
             });
 
-            ssh_client.on('end', () => {
-                _this.debug_en &&_this.debug('SSH Client :: end');
+            _this.on('end', () => {
+                _this.debug_en && _this.debug('SSH Client :: end');
                 _this.close_sockets(opts.server_name, opts.proxy_ports);
             });
 
-            ssh_client.on('close', () => {
-                _this.debug_en &&_this.debug('SSH Client :: close');
+            _this.on('close', () => {
+                _this.debug_en && _this.debug('SSH Client :: close');
                 _this.close_sockets(opts.server_name, opts.proxy_ports);
             });
 
-            ssh_client.on('error', err => {
-                _this.debug_en &&_this.debug('SSH Client :: error :: ' + err);
-                _this.emit('error', err);
+            _this.on('error', err => {
+                _this.debug_en && _this.debug('SSH Client :: error :: ' + err);
+                _this.emit('debug', err);
                 if (_this.listener[opts.server_name]) _this.listener[opts.server_name].isConnected = false;
                 _this.ssh_retry_connect(opts);
                 resolve();
             });
 
-            ssh_client.on('handshake', negotiated => {
-                _this.debug_en &&_this.debug('SSH Client :: handshake:', JSON.stringify(negotiated));
+            _this.on('handshake', negotiated => {
+                _this.debug_en && _this.debug('SSH Client :: handshake:', JSON.stringify(negotiated));
             });
 
-            ssh_client.on('greeting', (message, language) => {
-                _this.debug_en &&_this.debug('SSH Client :: greeting:', message);
+            _this.on('greeting', (message) => {
+                _this.debug_en && _this.debug('SSH Client :: greeting:', message);
             });
 
             // initiate ssh client connection to remote host
-            ssh_client.connect({
+            // ssh client debug function for verbose ssh connection details
+            const debug_client = (this.debug_ssh) ? (...args) => { console.log(...args); } : null;
+            _this.connect({
                 host: opts.host,
                 port: opts.port,
                 username: opts.username,
                 password: opts.password,
                 privateKey: opts.private_key,
-                debug: _this.debug_client,
+                debug: debug_client,
                 keepaliveInterval: 10000
             });
 
@@ -222,13 +221,14 @@ class sshTunnelProxy extends EventEmitter {
         const remote_ports = [];
         proxy_ports.forEach(proxy_port => {
             const [local_port, remote_hostname, remote_port] = proxy_port.split(':');
+            if (remote_hostname.length < 1) remote_ports.push(remote_port);
             if (!this.validate_port_number(local_port, whitelist)) local_ports.push(local_port);
             if (!this.validate_port_number(remote_port, whitelist)) remote_ports.push(remote_port);
         });
         if (local_ports.length || remote_ports.length) {
             const err = new Error('Invalid local forward');
 
-            this.debug_en &&this.debug('invalid ports found:\n', JSON.stringify(proxy_ports, null, 2),
+            this.debug_en && this.debug('invalid ports found:\n', JSON.stringify(proxy_ports, null, 2),
                 '\n', JSON.stringify(whitelist, null, 2));
 
             err.info = {
@@ -241,7 +241,8 @@ class sshTunnelProxy extends EventEmitter {
     }
 
     // on network error, attempt to re-establish connection until 10 retries
-    ssh_retry_connect = (opts) => {
+    //clearTimeout(this._readyTimeout);
+    ssh_retry_connect(opts) {
         const _this = this;
         const invoke = () => {
             _this.connectSSH(opts);
@@ -250,9 +251,9 @@ class sshTunnelProxy extends EventEmitter {
     }
 
     // attempt to establish ssh tunnel to server with supplied parameters.
-    ssh_start_tunnel = async (opts) => {
+    async ssh_start_tunnel(opts) {
         const _this = this;
-        return new Promise(async (resolve, reject) => {
+        async function do_ssh_connect(resolve) {
 
             // after successful tunnel setup complete, send events and reset retry counter
             await _this.do_ssh_connect(opts).then(() => {
@@ -264,18 +265,16 @@ class sshTunnelProxy extends EventEmitter {
                 _this.emit('status', '', 'ready', hostport);
                 _this.retries = 0;
                 resolve();
-            }, (err) => {
-                _this.debug_en &&_this.debug('ssh_retry error:', err);
-                reject();
             });
-        });
+        }
+        return new Promise(do_ssh_connect);
     }
 
     // setup ssh connection parameters and attempt to establish ssh tunnel
     // todo: if opts have changed while service is running, shutdown current service and restart with new opts
     async connectSSH(opts, whitelist) {
 
-        this.debug_en &&this.debug('connectSSH:\n', JSON.stringify(opts, null, 2));
+        this.debug_en && this.debug('connectSSH:\n', JSON.stringify(opts, null, 2));
 
         // make deep copy of opts for modification
         var _opts = JSON.parse(JSON.stringify(opts));
@@ -287,8 +286,8 @@ class sshTunnelProxy extends EventEmitter {
         try {
             this.validate_local_forward(_opts.proxy_ports, _opts.whitelist);
         } catch (err) {
-            this.emit('error', err);
-            this.debug_en &&this.debug(err);
+            this.emit('debug', err);
+            this.debug_en && this.debug(err);
             return err;
         }
 
@@ -307,8 +306,8 @@ class sshTunnelProxy extends EventEmitter {
             const _this = this;
             const ngrokApi = new NgrokApi(_opts.ngrok_api);
             var hostport = await ngrokApi.get_hostport()
-                .catch((err) => {
-                    _this.debug_en &&_this.debug('ngrok get_hostport connection error');
+                .catch(() => {
+                    _this.debug_en && _this.debug('ngrok get_hostport connection error');
                     if (this.listener[opts.server_name]) this.listener[opts.server_name].isConnected = false;
                     _this.ssh_retry_connect(_opts);
                 });
@@ -322,7 +321,7 @@ class sshTunnelProxy extends EventEmitter {
         // initiate ssh tunnel, block until tunnel is established or error
         return await this.ssh_start_tunnel(_opts)
             .catch((err) => {
-                this.debug_en &&this.debug('ssh_start_tunnel catch:' + err);
+                this.debug_en && this.debug('ssh_start_tunnel catch:' + err);
             });
     }
 
@@ -340,15 +339,12 @@ class sshTunnelProxy extends EventEmitter {
         keypairStorage.get_public_key_from_keychain(...args);
     }
 
-    // ssh client debug function for verbose ssh connection details
-    debug_client = (this.debug_ssh) ? (msg) => { console.log(msg); } : null;
-
     debug(...args) { console.log(...args); }
 
 }
 
 module.exports = {
-    SSHTunnelProxy:sshTunnelProxy,
-    KeypairStorage:KeypairStorage,    
-    NgrokApi:NgrokApi
+    SSHTunnelProxy: SSHTunnelProxy,
+    KeypairStorage: KeypairStorage,
+    NgrokApi: NgrokApi
 }

package/lib/keypair_storage.js

@@ -23,7 +23,7 @@ class KeypairStorage {
     generate_and_store_keypair(service_name, account) {
         const keypair = this.generate_keypair();
         return new Promise((resolve, reject) => {
-            keytar.setPassword(service_name, account, keypair.private_key).then((result) => {
+            keytar.setPassword(service_name, account, keypair.private_key).then(() => {
                 resolve(keypair.public_key);
             }, (err) => {
                 reject(err);

package/main.js

@@ -1,7 +1,6 @@
 const process = require('process');
 const fs = require('fs');
 const { SSHTunnelProxy, KeypairStorage } = require('./lib/index.js');
-const { config } = require('process');
 
 const keypairStorage = new KeypairStorage();
 const homedir = require('os').homedir();
@@ -11,6 +10,7 @@ var configs = null;
 var host = null;
 var port = null;
 var username = null;
+var password = null;
 var forwardOut = [];
 var forwardIn = [];
 var ngrokAPIKey = null;
@@ -108,7 +108,7 @@ function main(args) {
 
     // if no config file specified, build config from args
     if (!configs) {
-        config = {
+        var config = {
             enabled: true,
             username: username,
             password: password,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh_tunnel_proxy",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "obtain ngrok host port from api and establish a ssh connection",
   "main": "lib/index.js",
   "scripts": {
@@ -11,7 +11,6 @@
   "dependencies": {
     "@ngrok/ngrok-api": "^0.9.0",
     "bluebird": "^3.7.2",
-    "crypto": "^1.0.1",
     "electron-ssh2": "^0.1.2",
     "form-data": "^4.0.0",
     "fs": "^0.0.1-security",
@@ -22,6 +21,7 @@
     "sshpk": "^1.17.0"
   },
   "devDependencies": {
+    "eslint": "^8.33.0",
     "mocha": "^10.2.0",
     "rewire": "^6.0.0",
     "sinon": "^15.0.1"

package/test/test.js

@@ -6,9 +6,8 @@ to run ssh tunnel api tests edit config.json and provide api keys for each servi
 */
 
 const assert = require('assert');
+const { describe, it } = require('mocha');
 const fs = require('fs');
-const path = require('path');
-const sinon = require('sinon');
 
 const { SSHTunnelProxy, KeypairStorage, NgrokApi } = require('../lib/index.js');
 
@@ -136,8 +135,8 @@ describe('Store and retrieve private key in system keychain', function () {
     });
   });
   it('remove key should return true', () => {
-    return keypairStorage.delete_keypair(service_name, account).then(result => {
-      assert('should return true');
+    return keypairStorage.delete_keypair(service_name, account).then((result) => {
+      assert(result, 'should return true');
     });
   });
   it('retrieve stored private key after delete should return null', () => {
@@ -174,7 +173,7 @@ describe('Get ngrok hostport', function () {
     assert.equal(result_opts.port, '17632');
   });
   it('host, port should be obtained from api', async () => {
-    result = await ngrokApi.get_hostport(opts);
+    const result = await ngrokApi.get_hostport(opts);
     assert(result.host, 'host should exist');
     assert(result.port, 'port should exist');
   }, (err) => {
@@ -213,17 +212,3 @@ describe('ssh connection integration test', function () {
 
 });
 */
-
-
-// test generate keypair
-var test_generate_keypair = function () {
-  const keypair = generate_keypair();
-  console.log('keypair:');
-  console.log(keypair.public_key);
-  console.log(keypair.private_key);
-  var homedir = homedir();
-  var fname = path.join(homedir, '.ssh', 'zm_id_rsa.pub')
-  //fs.writeFileSync(fname, keypair.public_key);
-  fname = path.join(homedir, '.ssh', 'zm_id_rsa')
-  //fs.writeFileSync(fname, keypair.private_key);
-}