ssh_tunnel_proxy 1.1.5 → 1.2.1

package/.vscode/launch.json

@@ -22,13 +22,13 @@
             "type": "node",
             "runtimeVersion": "19.4.0",
             "request": "launch",
-            "name": "Launch Program",
+            "name": "Launch node cli",
             "cwd": "${fileDirname}",
             "skipFiles": [
                 "<node_internals>/**"
             ],
             "program": "${file}",
-            "args":["--source=themagician_composite"]
+            "args":["-c","-d"]
         }
     ]
 }

package/README.md

@@ -1,14 +1,44 @@
 # ssh_tunnel_proxy
 Initiate a ssh reverse tunnel proxy with forwarding ports
 
-ssh_tunnel_proxy can function as a stand-alone api or part of an electron_js app. To establish a ssh tunnel proxy a keypair is generated on the client and stored in the system keychain.
-If a ngrok api key is provided the ngrok api endpoint method is invoked to obtain the hostport of
-the tunnel. A list of port forwards is provided to the connect_api function and ports validated to restrict connections to system ports on the remote host to a set of pre-defined ports such as http,https. After establishing a ssh connection to the remote server, local proxy port forwards are opened. If the connection is interrupted then the ssh_connect method will attempt to re-establish the connection.
+ssh_tunnel_proxy can function as a stand-alone api, nodejs command line script or part of an electron_js app. To establish a ssh tunnel proxy a keypair is generated on the client and stored in the system keychain.
 
-Example code for electron_js:
+If a ngrok api key is provided the ngrok api endpoint method is invoked to obtain the hostport of the tunnel. A list of port forwards is provided to the connect_api function and ports validated to restrict connections to system ports on the remote host to a set of pre-defined ports such as http,https. After establishing a ssh connection to the remote server, local proxy port forwards are opened. If the connection is interrupted then the ssh_connect method will attempt to re-establish the connection.
+
+Example command line usage:
+
+config file, located at:
+~/.config/ssh_tunnel_proxy/config.json
+```json
+[{
+  "enabled": true,
+  "username": "<username>",
+  "password": "",
+  "host": "",
+  "port": "",
+  "proxy_ports": [
+    "8280:127.0.0.1:80",
+    "9000:127.0.0.1:9000",
+    "8122:192.168.2.1:22"
+  ],
+  "whitelist": {
+    "80": true,
+    "443": true,
+    "22": true
+  },
+  "service_name": "ssh_proxy_client",
+  "server_name": "test",
+  "ngrok_api": "<ngrok api key>"
+}]
+
+start tunnel with default config, located at ~/.config/ssh_tunnel_proxy/config.json
+```
+node main.js -c -d
+
+The following code is an example of use of the api with electronjs and needs to be install in main.js, preload.js and the render process.
+main.js:
 ```js
 
-// electronjs main.js
 async function init_sshTunnelProxy(win) {
 
   const SSHTunnelProxy = require('ssh_tunnel_proxy');
@@ -40,8 +70,10 @@ async function init_sshTunnelProxy(win) {
   sshTunnelProxy.on('error',(...args) => win.webContents.send('error',...args));
 
 };
+```
 
-// electronjs preload.js
+preload.js:
+```js
 const { contextBridge, ipcRenderer } = require('electron')
 
 contextBridge.exposeInMainWorld('sshModule', {
@@ -54,8 +86,10 @@ contextBridge.exposeInMainWorld('sshModule', {
     debug: (callback) => ipcRenderer.on('debug', callback),
     error: (callback) => ipcRenderer.on('error', callback)
 });
+```
 
-// electronjs render process, setup listeners and initiate ssh tunnel
+// render process
+```js
 // initialize ssh message handlers
 sshModule.ready((event, data) => {
 });

package/lib/index.js

@@ -24,7 +24,6 @@ const KeypairStorage = require('./keypair_storage');
 const NgrokApi = require('./ngrok_service');
 
 // debug logging options
-const en = true;
 const debug_ssh = false;
 
 const keypairStorage = new KeypairStorage();
@@ -35,6 +34,8 @@ class sshTunnelProxy extends EventEmitter {
         super();
         this.listener = {};
         this.retries = 0;
+        this.debug_en = false;
+        this.debug_ssh = false;
     }
 
     // function to close all active sockets for tunnel restart and exception handling
@@ -45,7 +46,7 @@ class sshTunnelProxy extends EventEmitter {
         proxy_ports.forEach(proxy_port => {
             const server = this.listener[server_name][proxy_port];
             if (server && server.listening) {
-                en && this.debug('SSH Server :: closing forward:', proxy_port)
+                this.debug_en &&this.debug('SSH Server :: closing forward:', proxy_port)
                 server.close();
             }
         });
@@ -59,8 +60,8 @@ class sshTunnelProxy extends EventEmitter {
         const on_setup_ssh_forward = (err, stream) => {
 
             if (err) {
-                _this.emit('error', err);
-                en && _this.debug('socket forward error:', err);
+                _this.emit('debug', err);
+                _this.debug_en &&_this.debug('socket forward error:', err);
                 return;
             }
 
@@ -75,8 +76,8 @@ class sshTunnelProxy extends EventEmitter {
 
             // if socket error, emit error and close stream
             socket.on('error', (err) => {
-                _this.emit('error', err);
-                en && _this.debug('socket on error:', err);
+                _this.emit('debug', err);
+                _this.debug_en &&_this.debug('socket on error:', err);
                 stream.end();
             });
         }
@@ -105,9 +106,14 @@ class sshTunnelProxy extends EventEmitter {
             const [local_port, remote_hostname, remote_port] = proxy_port.split(':');
 
             // 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)
+                server.close();
+            }
             this.listener[server_name][proxy_port] = net.createServer({ keepAlive: true, allowHalfOpen: false }, socket => {
 
-                if (en) {
+                if (this.debug_en) {
                     var debug_msg = 'SSH Server :: connection on ' + local_port + ' ' + socket.remotePort;
                     _this.emit('debug', debug_msg);
                     _this.debug(debug_msg);
@@ -132,7 +138,7 @@ class sshTunnelProxy extends EventEmitter {
                     }
                 });
             } catch (err) {
-                en && _this.debug('listen err:', err);
+                _this.debug_en &&_this.debug('listen err:', err);
             }
         });
     };
@@ -162,30 +168,29 @@ class sshTunnelProxy extends EventEmitter {
             });
 
             ssh_client.on('end', () => {
-                en && _this.debug('SSH Client :: end');
+                _this.debug_en &&_this.debug('SSH Client :: end');
                 _this.close_sockets(opts.server_name, opts.proxy_ports);
             });
 
             ssh_client.on('close', () => {
-                en && _this.debug('SSH Client :: close');
+                _this.debug_en &&_this.debug('SSH Client :: close');
                 _this.close_sockets(opts.server_name, opts.proxy_ports);
             });
 
             ssh_client.on('error', err => {
-                en && _this.debug('SSH Client :: error :: ' + err);
+                _this.debug_en &&_this.debug('SSH Client :: error :: ' + err);
                 _this.emit('error', err);
-                _this.close_sockets(opts.server_name, opts.proxy_ports);
                 if (_this.listener[opts.server_name]) _this.listener[opts.server_name].isConnected = false;
                 _this.ssh_retry_connect(opts);
                 resolve();
             });
 
             ssh_client.on('handshake', negotiated => {
-                en && _this.debug('SSH Client :: handshake:', JSON.stringify(negotiated));
+                _this.debug_en &&_this.debug('SSH Client :: handshake:', JSON.stringify(negotiated));
             });
 
             ssh_client.on('greeting', (message, language) => {
-                en && _this.debug('SSH Client :: greeting:', message);
+                _this.debug_en &&_this.debug('SSH Client :: greeting:', message);
             });
 
             // initiate ssh client connection to remote host
@@ -223,7 +228,7 @@ class sshTunnelProxy extends EventEmitter {
         if (local_ports.length || remote_ports.length) {
             const err = new Error('Invalid local forward');
 
-            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 = {
@@ -237,7 +242,11 @@ class sshTunnelProxy extends EventEmitter {
 
     // on network error, attempt to re-establish connection until 10 retries
     ssh_retry_connect = (opts) => {
-        if (this.retries++ < 10) setTimeout(this.connect_ssh, 5000, opts);
+        const _this = this;
+        const invoke = () => {
+            _this.connectSSH(opts);
+        }
+        if (this.retries++ < 10) setTimeout(invoke, 5000);
     }
 
     // attempt to establish ssh tunnel to server with supplied parameters.
@@ -248,7 +257,7 @@ class sshTunnelProxy extends EventEmitter {
             // after successful tunnel setup complete, send events and reset retry counter
             await _this.do_ssh_connect(opts).then(() => {
                 const hostport = opts.host + ':' + opts.port;
-                if (en) {
+                if (_this.debug_en) {
                     const msg = 'SSH connection to ' + opts.server_name + ' established at ' + hostport;
                     _this.debug(msg);
                 }
@@ -256,7 +265,7 @@ class sshTunnelProxy extends EventEmitter {
                 _this.retries = 0;
                 resolve();
             }, (err) => {
-                en && _this.debug('ssh_retry error:', err);
+                _this.debug_en &&_this.debug('ssh_retry error:', err);
                 reject();
             });
         });
@@ -266,7 +275,7 @@ class sshTunnelProxy extends EventEmitter {
     // todo: if opts have changed while service is running, shutdown current service and restart with new opts
     async connectSSH(opts, whitelist) {
 
-        en && this.debug('connect_ssh:\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));
@@ -279,7 +288,7 @@ class sshTunnelProxy extends EventEmitter {
             this.validate_local_forward(_opts.proxy_ports, _opts.whitelist);
         } catch (err) {
             this.emit('error', err);
-            en && this.debug(err);
+            this.debug_en &&this.debug(err);
             return err;
         }
 
@@ -299,7 +308,7 @@ class sshTunnelProxy extends EventEmitter {
             const ngrokApi = new NgrokApi(_opts.ngrok_api);
             var hostport = await ngrokApi.get_hostport()
                 .catch((err) => {
-                    en && _this.debug('ngrok get_hostport connection error');
+                    _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);
                 });
@@ -313,7 +322,7 @@ class sshTunnelProxy extends EventEmitter {
         // initiate ssh tunnel, block until tunnel is established or error
         return await this.ssh_start_tunnel(_opts)
             .catch((err) => {
-                en && this.debug('ssh_start_tunnel catch:' + err);
+                this.debug_en &&this.debug('ssh_start_tunnel catch:' + err);
             });
     }
 
@@ -332,10 +341,14 @@ class sshTunnelProxy extends EventEmitter {
     }
 
     // ssh client debug function for verbose ssh connection details
-    debug_client = (debug_ssh) ? (msg) => { console.log(msg); } : null;
+    debug_client = (this.debug_ssh) ? (msg) => { console.log(msg); } : null;
 
-    debug = (...args) => { console.log(...args); }
+    debug(...args) { console.log(...args); }
 
 }
 
-module.exports = sshTunnelProxy;
+module.exports = {
+    SSHTunnelProxy:sshTunnelProxy,
+    KeypairStorage:KeypairStorage,    
+    NgrokApi:NgrokApi
+}

package/lib/keypair_storage.js

@@ -74,16 +74,3 @@ class KeypairStorage {
     }
 }
 module.exports = KeypairStorage;
-/*
-module.exports = {
-    store_private_key: keytar.setPassword,
-    retrieve_private_key: keytar.getPassword,
-    remove_keypair: keytar.deletePassword,
-    generate_keypair: generate_keypair,
-    generate_and_store_keypair: generate_and_store_keypair,
-    get_public_key_from_keychain: get_public_key_from_keychain,
-    get_keypair: get_keypair,
-    set_keypair: set_keypair,
-    delete_keypair: delete_keypair
-}
-*/

package/main.js

@@ -0,0 +1,153 @@
+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();
+var debug = false;
+var proxies = [];
+var configs = null;
+var host = null;
+var port = null;
+var username = null;
+var forwardOut = [];
+var forwardIn = [];
+var ngrokAPIKey = null;
+var privateKey = null;
+var service = null;
+var account = null;
+
+function get_key_from_file(filename) {
+    try {
+        return fs.readFileSync(filename);
+    } catch (err) {
+        console.log('Error loading key:', err);
+    }
+}
+
+function get_config(filename) {
+    try {
+        configs = JSON.parse(fs.readFileSync(filename), 'utf8');
+    } catch (err) {
+        console.log('Error loading config file:', err);
+    }
+}
+
+function get_default_config() {
+    try {
+        configs = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
+    } catch (err) {
+        console.log('Error loading config file:', err);
+    }
+}
+
+function main(args) {
+
+    // parse command line args
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i].split('=');
+        const cmd = arg[0];
+        const value = arg[1];
+        switch (cmd) {
+            case '-d':
+            case '--debug':
+                debug = true;
+                break;
+            case '-c':
+            case '--config':
+                if (value) get_config(value);
+                else get_default_config();
+                break;
+            case '-h':
+            case '--host':
+                host = value;
+                break;
+            case '-p':
+            case '--port':
+                port = value;
+                break;
+            case '-u':
+            case '--username':
+                username = value;
+                break;
+            case '-P':
+            case '--password':
+                password = value;
+                break;
+            case '-k':
+            case '--key':
+                privateKey = value;
+                break;
+            case '-s':
+            case '--service':
+                service = value;
+                break;
+            case '--a':
+                account = value;
+                break;
+            case '-L':
+            case '--LocalForward':
+                forwardOut.push(value);
+                break;
+            case '-R':
+            case '--RemoteForward':
+                forwardIn.push(value);
+                break;
+            case '-n':
+            case '--ngrok':
+                ngrokAPIKey = value;
+                break;
+            default:
+                if (i > 1) console.log('Invalid argument:', arg);
+        }
+    }
+
+    // prevent process from exiting
+    process.stdin.resume();
+
+    // if no config file specified, build config from args
+    if (!configs) {
+        config = {
+            enabled: true,
+            username: username,
+            password: password,
+            host: host,
+            port: port,
+            proxy_ports: forwardOut,
+            remote_ports: forwardIn,
+            service_name: service,
+            server_name: account,
+            ngrok_api: ngrokAPIKey,
+            private_key: privateKey
+        };
+        configs = [config];
+    }
+
+    // process each tunnel config in ssh proxy tunnel list
+    configs.forEach(async config => {
+
+        // skip tunnel if not enabled
+        if (!config.enabled) return;
+
+        // if system key storage name specified get key from system keychain
+        if (config.server_name) {
+            const service_name = config.service_name || 'ssh_tunnel_proxy';
+            config.private_key = await keypairStorage.get_keypair(service_name, config.server_name);
+        }
+        // if private key filename specified, read private key
+        else if (config.private_key) {
+            config.private_key = get_key_from_file(config.private_key);
+        }
+
+        // create new tunnel and start connection
+        var sshTunnelProxy = new SSHTunnelProxy();
+        proxies.push(sshTunnelProxy);
+        sshTunnelProxy.debug_en = debug;
+        sshTunnelProxy.connectSSH(config);
+    });
+
+
+}
+
+main(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh_tunnel_proxy",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "description": "obtain ngrok host port from api and establish a ssh connection",
   "main": "lib/index.js",
   "scripts": {

package/test/test.js

@@ -10,13 +10,12 @@ const fs = require('fs');
 const path = require('path');
 const sinon = require('sinon');
 
-const SSHTunnelProxy = require('../lib/index.js');
-const KeypairStorage = require('../lib/keypair_storage.js');
-const NgrokApi = require('../lib/ngrok_service');
+const { SSHTunnelProxy, KeypairStorage, NgrokApi } = require('../lib/index.js');
 
 // get config file containing api keys
 const homedir = require('os').homedir();
-const opts = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
+const config = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
+const opts = config[0];
 
 const sshTunnelProxy = new SSHTunnelProxy();
 const keypairStorage = new KeypairStorage();