ssh_tunnel_proxy 1.2.7 → 1.2.9

package/.vscode/launch.json

@@ -28,7 +28,7 @@
                 "<node_internals>/**"
             ],
             "program": "${file}",
-            "args":["-c","-e=uptime","-e=ls -all"]
+            "args":["-c","-r=nqs"]
         }
     ]
 }

package/README.md

@@ -55,7 +55,37 @@ node main.js -c
   ],
   "ngrok_api": "<ngrok api key>"
 }]
+```
+
+Start a terminal session on the remote host:
+```
+node main.js -c -S
+```
+
+Example use of api to exec remote commands using async await and processing result through streams. Complete example is in test/test_remote_exec_streams.js:
 
+```js
+async function test_exec_stream(opts) {
+    sshTunnelProxy.debug_en = true;
+    await sshTunnelProxy.connectSSH(opts);
+
+    // exec remote command and save result to string
+    const uptime_result = await sshTunnelProxy.execCmd('uptime');
+    console.log('uptime:' + uptime_result.toString());
+
+    // exec remote command and pipe data through tunnel until end of data
+    const tunnel = new PassThrough();
+    tunnel.pipe(split())
+        .pipe(to_ls_JSON)
+        .pipe(to_JSON_string)
+        .pipe(process.stdout);
+
+    await sshTunnelProxy.execCmd('ls -all', tunnel);
+
+    // stream processing complete
+    console.log('done');
+    process.exit();
+}
 ```
 
 The following code is an example of use of the api with electronjs.

package/lib/index.js

@@ -18,6 +18,7 @@ License: MIT
 
 const net = require('net');
 const process = require('process');
+const { Buffer } = require('node:buffer');
 const { Client } = require('electron-ssh2');
 
 const KeypairStorage = require('./keypair_storage');
@@ -101,83 +102,102 @@ class SSHTunnelProxy extends Client {
     }
 
     // function to setup proxy forwards for ssh tunnel
-    on_ssh_client_ready(server_name, proxy_ports, resolve) {
+    setupProxyPorts(server_name, proxy_ports) {
 
-        var listeners = 0;
-        if (this.listener[server_name]) this.listener[server_name].isConnected = true;
-        const _this = this;
+        return new Promise((resolve, reject) => {
 
-        // iterate through a list of local forward ports and create a local proxy port
-        proxy_ports.forEach(proxy_port => {
+            var listeners = 0;
+            if (this.listener[server_name]) this.listener[server_name].isConnected = true;
+            const _this = this;
 
-            const [local_port, remote_hostname, remote_port] = proxy_port.split(':');
+            // iterate through a list of local forward ports and create a local proxy port
+            proxy_ports.forEach(proxy_port => {
 
-            // 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 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 => {
+                const [local_port, remote_hostname, remote_port] = proxy_port.split(':');
 
-                if (this.debug_en) {
-                    var debug_msg = 'SSH Server :: connection on ' + local_port + ' ' + socket.remotePort;
-                    _this.emit('debug', debug_msg);
-                    _this.debug(debug_msg);
+                // 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 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 => {
 
-                // create a proxy forward between local and remote ports
-                _this.setup_ssh_forward(socket, remote_hostname, remote_port);
-            });
+                    if (this.debug_en) {
+                        var debug_msg = 'SSH Server :: connection on ' + local_port + ' ' + socket.remotePort;
+                        _this.emit('debug', debug_msg);
+                        _this.debug(debug_msg);
+                    }
 
-            // 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, () => {
+                    // create a proxy forward between local and remote ports
+                    _this.setup_ssh_forward(socket, remote_hostname, remote_port);
+                });
 
-                    // emit server listening on port message
-                    var status_msg = 'SSH Server :: bound on ' + local_port;
+                // start listening on port
+                try {
+                    var status_msg = 'SSH Server :: before listen on ' + local_port;
                     _this.emit('debug', status_msg);
-
-                    // if all listeners have been successfully established, resolve setup connection
-                    if (listeners++ >= proxy_ports.length - 1) {
-                        _this.emit('ssh_tunnel_ready', {});
-                        if (_this._tunnelReadyTimeout) {
-                            clearTimeout(this._tunnelReadyTimeout);
-                            _this._tunnelReadyTimeout = undefined
+                    _this.listener[server_name][proxy_port].listen(local_port, () => {
+
+                        // emit server listening on port message
+                        var status_msg = 'SSH Server :: bound on ' + local_port;
+                        _this.emit('debug', status_msg);
+
+                        // if all listeners have been successfully established, resolve setup connection
+                        if (listeners++ >= proxy_ports.length - 1) {
+                            _this.emit('ssh_tunnel_ready', {});
+                            if (_this._tunnelReadyTimeout) {
+                                clearTimeout(this._tunnelReadyTimeout);
+                                _this._tunnelReadyTimeout = undefined
+                            }
+                            resolve();
                         }
-                        resolve();
-                    }
-                });
-            } catch (err) {
-                _this.debug_en && _this.debug('listen err:', err);
-            }
+                    });
+                } catch (err) {
+                    _this.debug_en && _this.debug('listen err:', err);
+                    reject(err);
+                }
+            });
         });
     }
 
-    exec_next() {
-        const _this = this;
-        const remote_exec = (err, stream) => {
-            if (err) throw err;
-            stream.on('close', () => {
-                process.stdout.write('-- exec completed --\n\n');
-                if (!_this.exec_next()) process.exit();
-            }).on('data', (data) => {
-                process.stdout.write(data);
-            }).stderr.on('data', (data) => {
-                process.stderr.write(data);
-            });
-        }
-        if (this.exec_cmds.length > 0) {
-            const cmd = this.exec_cmds[0];
-            this.exec_cmds.shift();
-            console.log('$: ' + cmd);
+    execCmd(cmd, dataStream, errStream) {
+
+        return new Promise((resolve, reject) => {
+            var bufs = [];
+            var errs = [];
+
+            const remote_exec = (err, stream) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                stream.on('close', () => {
+                    var buf = Buffer.concat(bufs);
+                    var err = Buffer.concat(errs);
+                    resolve(buf, err);
+                })
+
+                if (dataStream) {
+                    stream.pipe(dataStream);
+                } else {
+                    stream.on('data', (data) => {
+                        bufs.push(data);
+                    })
+                }
+
+                if (errStream) {
+                    stream.stderr.pipe(errStream);
+                } else {
+                    stream.stderr.on('data', (data) => {
+                        errs.push(data);
+                    });
+                }
+
+            }
             this.exec(cmd, remote_exec);
-            return true;
-        }
-        return false;
+        })
     }
 
     // handle remote shell stream processing
@@ -227,7 +247,7 @@ class SSHTunnelProxy extends Client {
                 _this.listener[opts.server_name] = {};
             }
 
-            _this.on('ready', () => {
+            _this.on('ready', async () => {
 
                 // stop any pending retry timeouts
                 if (_this._tunnelReadyTimeout) {
@@ -239,18 +259,24 @@ class SSHTunnelProxy extends Client {
                 if (opts.shell) {
                     _this.shell(_this.remote_shell);
 
-                    // if exec requested, exec series of cmds
+                // if exec requested, exec series of cmds
                 } else {
                     if (opts.exec && opts.exec.length > 0) {
-                        _this.exec_cmds = opts.exec;
-                        _this.exec_next();
+                        for (var i = 0; i < opts.exec.length; i++) {
+                            var cmd = opts.exec[i];
+                            console.log(opts.username + '@' + opts.hostname + ':' + cmd);
+                            var result = await _this.execCmd(cmd);
+                            console.log(result.toString());
+                        }
+                        process.exit();
                     }
                 }
 
                 // if local forward requested, setup local forwarding ports to remote host
                 if (opts.proxy_ports) {
-                    _this.on_ssh_client_ready(opts.server_name, opts.proxy_ports, resolve);
+                    await _this.setupProxyPorts(opts.server_name, opts.proxy_ports);
                 }
+                resolve();
             });
 
             _this.on('end', () => {
@@ -310,6 +336,9 @@ class SSHTunnelProxy extends Client {
 
     // validate local forwards for correct format and valid ports
     validate_local_forward(proxy_ports, whitelist) {
+
+        if (!proxy_ports) return;
+
         const local_ports = [];
         const remote_ports = [];
         proxy_ports.forEach(proxy_port => {

package/main.js

@@ -6,6 +6,7 @@ const keypairStorage = new KeypairStorage();
 const homedir = require('os').homedir();
 var debug = false;
 var exec = [];
+var remote_host = null;
 var proxies = [];
 var configs = null;
 var host = null;
@@ -92,6 +93,10 @@ function main(args) {
             case '--ngrok':
                 ngrokAPIKey = value;
                 break;
+            case '-r':
+            case '--remote':
+                remote_host = value;
+                break;
             case '-R':
             case '--RemoteForward':
                 forwardIn.push(value);
@@ -140,6 +145,9 @@ function main(args) {
         // skip tunnel if not enabled
         if (!config.enabled) return;
 
+        // if remote host specified, only select tunnel for remote host
+        if (remote_host && remote_host !== config.alias) 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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh_tunnel_proxy",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "obtain ngrok host port from api and establish a ssh connection",
   "main": "lib/index.js",
   "scripts": {
@@ -18,7 +18,9 @@
     "net": "^1.0.2",
     "ngrok": "^4.3.3",
     "socksv5": "^0.0.6",
-    "sshpk": "^1.17.0"
+    "split": "^1.0.1",
+    "sshpk": "^1.17.0",
+    "through": "^2.3.8"
   },
   "devDependencies": {
     "eslint": "^8.33.0",

package/test/test_remote_exec_streams.js

@@ -0,0 +1,140 @@
+/*
+
+test remote exec streams
+
+*/
+
+//const assert = require('assert');
+//const { describe, it } = require('mocha');
+const process = require('process');
+const fs = require('fs');
+const { PassThrough } = require("stream");
+const through = require('through');
+const split = require('split');
+
+const { SSHTunnelProxy } = require('../lib/index.js');
+
+// get config file containing api keys
+const homedir = require('os').homedir();
+var config = null;
+try {
+    config = JSON.parse(fs.readFileSync(homedir + '/.config/ssh_tunnel_proxy/config.json'), 'utf8');
+} catch (err) {
+    console.log('Error reading config');
+    process.exit();
+}
+
+if (!config && !config[1]) {
+    console.log('Specified config not found in configs');
+    process.exit();
+}
+
+const opts = config[1];
+
+const sshTunnelProxy = new SSHTunnelProxy();
+
+// parse shell command result into array of strings
+function parse_cmd(str) {
+
+    let result = [];
+    let log_matches = false;
+
+    let regex = /(([\w-/_~]+)|("(.*?)")|('(.*?)'))/g;
+    let groups = [2, 4, 6];
+    let match;
+
+    while ((match = regex.exec(str)) !== null) {
+        // This is necessary to avoid infinite loops 
+        // with zero-width matches
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+
+        // For this to work the regex groups need to 
+        // be mutually exclusive
+        groups.forEach(function (group) {
+            if (match[group]) {
+                result.push(match[group]);
+            }
+        });
+
+        // show matches for debugging
+        log_matches && match.forEach(function (m, group) {
+            if (m) {
+                console.log(`Match '${m}' found in group: ${group}`);
+            }
+        });
+    }
+    return result;
+}
+
+// generate object from arrays of names/values
+function toObj(names, values) {
+    const obj = {};
+    for (var i = 0; i < names.length; i++) {
+        obj[names[i]] = values[i];
+    }
+    return obj;
+}
+
+// stream that receives single line of ls long data and converts to json object
+const to_ls_JSON = new through(function (data) {
+    const file = processLSLong(data);
+    if (file.name) this.queue(file);
+});
+
+// stream that receives objects and converts to JSON strings
+const to_JSON_string = new through(function (data) {
+    this.queue(JSON.stringify(data) + '\n');
+});
+
+// parse ls long line output into json object
+function processLSLong(line) {
+    const format10 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'H', 'MM', 'name'];
+    const format9 = ['pm', 'links', 'user', 'group', 'size', 'M', 'D', 'Y', 'name'];
+    const values = parse_cmd(line);
+    const obj = toObj((values.length < 10) ? format9 : format10, values);
+    if (obj.pm) {
+        obj.type = obj.pm.substring(0, 1);
+        obj.pm = obj.pm.substring(1);
+    }
+    if (obj.M && obj.D) {
+        obj.date = obj.M + ' ' + obj.D;
+        delete obj.M;
+        delete obj.D;
+        if (obj.Y) {
+            obj.date += ' ' + obj.Y;
+            delete obj.Y;
+        }
+    }
+    if (obj.H && obj.MM) {
+        obj.time = obj.H + ':' + obj.MM;
+        delete obj.H;
+        delete obj.MM;
+    }
+    return obj;
+}
+
+async function test_exec_stream() {
+    sshTunnelProxy.debug_en = true;
+    await sshTunnelProxy.connectSSH(opts);
+
+    // exec remote command and save result to string
+    const uptime_result = await sshTunnelProxy.execCmd('uptime');
+    console.log('uptime:' + uptime_result.toString());
+
+    // exec remote command and pipe data through tunnel until no data
+    const tunnel = new PassThrough();
+    tunnel.pipe(split())
+        .pipe(to_ls_JSON)
+        .pipe(to_JSON_string)
+        .pipe(process.stdout);
+
+    await sshTunnelProxy.execCmd('ls -all', tunnel);
+
+    // stream processing complete
+    console.log('done');
+    process.exit();
+}
+
+test_exec_stream();