ssh_tunnel_proxy 1.2.10 → 2.0.1

package/main.js

@@ -1,176 +0,0 @@
-const process = require('process');
-const fs = require('fs');
-const { SSHTunnelProxy, KeypairStorage } = require('./lib/index.js');
-
-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;
-var port = null;
-var username = null;
-var password = null;
-var forwardOut = [];
-var forwardIn = [];
-var ngrokAPIKey = null;
-var privateKey = null;
-var service = null;
-var account = null;
-var shell = 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 '--a':
-                account = value;
-                break;
-            case '-c':
-            case '--config':
-                if (value) get_config(value);
-                else get_default_config();
-                break;
-            case '-d':
-            case '--debug':
-                debug = true;
-                break;
-            case '-e':
-            case '--exec':
-                exec.push(value);
-                break;
-            case '-h':
-            case '--host':
-                host = value;
-                break;
-            case '-p':
-            case '--port':
-                port = value;
-                break;
-            case '-P':
-            case '--password':
-                password = value;
-                break;
-            case '-k':
-            case '--key':
-                privateKey = value;
-                break;
-            case '-L':
-            case '--LocalForward':
-                forwardOut.push(value);
-                break;
-            case '-n':
-            case '--ngrok':
-                ngrokAPIKey = value;
-                break;
-            case '-r':
-            case '--remote':
-                remote_host = value;
-                break;
-            case '-R':
-            case '--RemoteForward':
-                forwardIn.push(value);
-                break;
-            case '-s':
-            case '--service':
-                service = value;
-                break;
-            case '-S':
-            case '--shell':
-                shell = true;
-                break;
-            case '-u':
-            case '--username':
-                username = 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) {
-        var 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 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';
-            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);
-        }
-        if (shell) {
-            config.shell = true;
-        }
-        if (exec.length > 0) {
-            config.exec = exec;
-        }
-        // create new tunnel and start connection
-        var sshTunnelProxy = new SSHTunnelProxy();
-        proxies.push(sshTunnelProxy);
-        sshTunnelProxy.debug_en = debug;
-        sshTunnelProxy.connectSSH(config);
-    });
-
-
-}
-
-main(process.argv);

package/test/test.js

@@ -1,214 +0,0 @@
-/*
-todo:
-add generate and store keys test
-add ngrok api test with stored api key in ssh_tunnel_proxy config
-to run ssh tunnel api tests edit config.json and provide api keys for each service
-*/
-
-const assert = require('assert');
-const { describe, it } = require('mocha');
-const fs = require('fs');
-
-const { SSHTunnelProxy, KeypairStorage, NgrokApi } = require('../lib/index.js');
-
-// get config file containing api keys
-const homedir = require('os').homedir();
-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();
-const ngrokApi = new NgrokApi(opts.ngrok_api);
-
-const whitelist = {
-  80: true,
-  443: true,
-  22: true
-}
-
-// port value validation tests
-describe('Validate ports', function () {
-  //const validate_port_number = sshTunnelProxy.__get__('validate_port_number');
-  it('valid port number 1024', function () {
-    assert(sshTunnelProxy.validate_port_number(1024, whitelist), 'should be valid');
-  });
-  it('valid port number 80', function () {
-    assert(sshTunnelProxy.validate_port_number(80, whitelist), 'should be valid');
-  });
-  it('invalid port number -1', function () {
-    assert.equal(false, sshTunnelProxy.validate_port_number(-1, whitelist), 'should be invalid');
-  });
-  it('invalid port number 65536', function () {
-    assert.equal(false, sshTunnelProxy.validate_port_number(65536, whitelist), 'should be invalid');
-  });
-  it('invalid system port number 137', function () {
-    assert.equal(false, sshTunnelProxy.validate_port_number(137, whitelist), 'should be invalid');
-  });
-  it('port number nan', function () {
-    assert.equal(false, sshTunnelProxy.validate_port_number('nan', whitelist), 'should be invalid');
-  });
-});
-
-// local forward format and value validation test
-describe('Validate local forwards', function () {
-  //const validate_local_forward = sshTunnelProxy.__get__('validate_local_forward');
-  var local_forward = [
-    '8080:127.0.0.1:80',
-    '9000:192.168.43.5:9000',
-    '9000:192.168.43.5',
-    '192.168.43.5:9000',
-    '8137:127.0.0.1:137',
-    '-1:127.0.0.1:65537',
-  ];
-  it('valid local forward to 80 ' + local_forward[0], function () {
-    assert(() => { return sshTunnelProxy.validate_local_forward([local_forward[0]], whitelist) }, 'should be valid');
-  });
-  it('valid local forward to 9000 ' + local_forward[1], function () {
-    assert(() => { return sshTunnelProxy.validate_local_forward([local_forward[1]], whitelist) }, 'should be valid');
-  });
-  it('invalid local forward format ' + local_forward[2], function () {
-    const err = {
-      message: 'Invalid local forward',
-      info: {
-        local_ports: '',
-        remote_ports: '',
-      }
-    };
-    assert.throws(() => { sshTunnelProxy.validate_local_forward([local_forward[2]], whitelist) }, err);
-  });
-  it('invalid local forward format ' + local_forward[3], function () {
-    const err = {
-      message: 'Invalid local forward',
-      info: {
-        local_ports: '192.168.43.5',
-        remote_ports: '',
-      }
-    };
-    assert.throws(() => { sshTunnelProxy.validate_local_forward([local_forward[3]], whitelist) }, err, 'should be invalid');
-  });
-  it('invalid local forward system port ' + local_forward[4], function () {
-    const err = {
-      message: 'Invalid local forward',
-      info: {
-        local_ports: '',
-        remote_ports: '137',
-      }
-    };
-    assert.throws(() => { sshTunnelProxy.validate_local_forward([local_forward[4]], whitelist) }, err, 'should be invalid');
-  });
-  it('invalid local forward port range ' + local_forward[5], function () {
-    const err = {
-      message: 'Invalid local forward',
-      info: {
-        local_ports: '-1',
-        remote_ports: '65537',
-      }
-    };
-    assert.throws(() => { sshTunnelProxy.validate_local_forward([local_forward[5]], whitelist) }, err, 'should be invalid');
-  });
-});
-
-// generate, store and retrieve private key test
-describe('Store and retrieve private key in system keychain', function () {
-  const service_name = 'ssh_proxy_tunnel';
-  const account = 'test';
-  const keypair = keypairStorage.generate_keypair();
-  it('generated key should contain a private key', function () {
-    assert(keypair.private_key, 'should not be empty');
-  });
-  it('generated key should contain a public key', function () {
-    assert(keypair.public_key, 'should not be empty');
-  });
-  it('should store generated private key', () => {
-    return keypairStorage.set_keypair(service_name, account, keypair.private_key).then(result => {
-      assert.equal(result, undefined, 'should not return error');
-    })
-  });
-  it('stored private key should match generated key', () => {
-    return keypairStorage.get_keypair(service_name, account).then(stored_key => {
-      assert.equal(stored_key, keypair.private_key, 'should match');
-    });
-  });
-  it('stored public key should match generated key', () => {
-    return keypairStorage.get_public_key_from_keychain(service_name, account).then(stored_key => {
-      assert.equal(stored_key, keypair.public_key, 'should match');
-    });
-  });
-  it('remove key 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', () => {
-    return keypairStorage.get_keypair(service_name, account).then((result) => {
-      assert.equal(result, null, 'should return null');
-    });
-  });
-  it('retrieve stored public key after delete should return null', () => {
-    return keypairStorage.get_public_key_from_keychain(service_name, account).then((result) => {
-      assert.equal(result, null, 'should return null');
-    });
-  });
-});
-
-/*
-// generate and store private key test
-describe('', function () {
-  it('', function () {
-    assert('', '');
-  });
-});
-*/
-
-describe('Get ngrok hostport', function () {
-  //const parse_ngrok_hostport = ngrok_service.__get__('parse_ngrok_hostport');
-  var test_endpoint = [{
-    hostport: '8.tcp.ngrok.io:17632'
-  }];
-  var result_opts = ngrokApi.parse_ngrok_hostport(test_endpoint, opts);
-  it('host should match 8.tcp.ngrok.io', function () {
-    assert.equal(result_opts.host, '8.tcp.ngrok.io');
-  });
-  it('port should match 17632', function () {
-    assert.equal(result_opts.port, '17632');
-  });
-  it('host, port should be obtained from api', async () => {
-    const result = await ngrokApi.get_hostport(opts);
-    assert(result.host, 'host should exist');
-    assert(result.port, 'port should exist');
-  }, (err) => {
-    assert.equal(err, null);
-  });
-
-});
-
-/*
-describe('ssh connection client ready', function () {
-});
-
-it('myEmitter should be enabled', function () {
-  assert(myEmitter, 'received event emitter');
-});
-
-describe('ssh connection integration test', function () {
-
-  it('ssh connect should invoke the ssh ready function', function (done) {
-    this.timeout(10000);
-    myEmitter.on('ssh_client_ready', (ssh_client) => {
-      assert(ssh_client, 'ssh client created');
-      done();
-    });
-  });
-  var ws_socket = false;
-  it('two websocket servers should be created', function (done) {
-    this.timeout(18000);
-    myEmitter.on('websocket_server_created', (socket) => {
-      assert(socket, 'ssh websocket server created:' + socket.remotePort);
-      if (!ws_socket) done();
-      ws_socket = true;
-    });
-  });
-  connect_ssh(opts);
-
-});
-*/

package/test/test_remote_exec.js

@@ -1,219 +0,0 @@
-/*
-test exec cmd on remote server, parse to json object stream
-*/
-
-//const assert = require('assert');
-//const { describe, it } = require('mocha');
-
-const fs = require('fs');
-const process = require('node:process');
-const { SSHTunnelProxy } = require('..');
-const { PassThrough, pipeline } = require("stream");
-const through = require('through');
-const split = require('split');
-
-// 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:' + err);
-    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 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]);
-            }
-        });
-        /*
-        let log_matches = false;
-        // 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;
-}
-
-
-// merge array items beginning at start into single item and append back to array
-function mergeArray(ar, start) {
-    const ar2 = ar.slice(start);
-    const ar1 = ar.slice(0, start);
-    const item = ar2.join(' ');
-    ar1.push(item);
-    return ar1;
-}
-
-/*
-Feb  4 21:34:17 tim-ThinkPad-P50s systemd[1]: Started Run anacron jobs.
-*/
-function parseSyslog(line) {
-    const format = ['M', 'D', 'T', 'host', 'proc', 'msg'];
-    const values = parse_cmd(line);
-    const log = mergeArray(values, 5);
-    const obj = toObj(format, log);
-    if (obj.M && obj.D && obj.T) {
-        obj.date = obj.M + ' ' + obj.D + ' ' + obj.T;
-        delete obj.M;
-        delete obj.D;
-        delete obj.T;
-    }
-    return obj;
-}
-
-// 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;
-}
-
-function to_lsParse() {
-    return new through(function (data) {
-        const obj = processLSLong(data);
-        if (obj.name) this.queue(obj);
-    });
-}
-
-function to_syslogParse() {
-    return new through(function (data) {
-        const obj = parseSyslog(data);
-        if (obj.proc) this.queue(obj);
-    });
-}
-
-function to_JSONString() {
-    return new through(function (data) {
-        this.queue(JSON.stringify(data) + '\n');
-    })
-}
-
-// lsLongShellProc conversion tests
-async function lsTest(sshTunnelProxy) {
-    return new Promise(async (resolve) => {
-
-        // exec remote command and pipe data through tunnel until end of data
-        const tunnel = new PassThrough();
-        pipeline(tunnel,
-            split(),
-            to_lsParse(),
-            to_JSONString(),
-            process.stdout,
-            () => { }
-        );
-
-        const lscmd = 'ls -all';
-        //const lscmd = 'ls -all | column --table --table-columns pm,links,user,group,size,month,day,time,name -J';
-        console.log('\ninvoking ' + lscmd + ' on remote host:\n');
-        await sshTunnelProxy.execCmd(lscmd, tunnel);
-
-        // stream processing complete
-        console.log('ls -all completed');
-        resolve();
-    })
-}
-
-// lsLongShellProc conversion tests
-async function syslogTest(sshTunnelProxy) {
-    return new Promise(async (resolve) => {
-
-        // exec remote command and pipe data through tunnel until end of data
-        const tunnel = new PassThrough();
-        pipeline(tunnel,
-            split(),
-            to_syslogParse(),
-            to_JSONString(),
-            process.stdout,
-            () => { }
-        );
-        //const syslogcmd = 'tail /var/log/syslog | column --table --table-columns-limit 6 --table-columns month,day,time,host,proc,msg -J';
-        const syslogcmd = 'tail /var/log/syslog';
-        console.log('\ninvoking ' + syslogcmd + ' on remote host:\n');
-        await sshTunnelProxy.execCmd(syslogcmd, tunnel);
-
-        // stream processing complete
-        console.log(syslogcmd+' completed');
-        resolve();
-    })
-}
-
-async function runTests() {
-
-    // connect to remote host
-    sshTunnelProxy.debug_en = true;
-    await sshTunnelProxy.connectSSH(opts);
-
-    // invoke ls -all on remote host and parse result to json object string
-    await lsTest(sshTunnelProxy);
-
-    // invoke tail /var/log/syslog on remote host and parse result to json object string
-    await syslogTest(sshTunnelProxy);
-
-    process.exit();
-}
-
-runTests();
-
-