ZoneMinder Forums

Code: Select all

/*
Can you add the following:
Obtain a list of local port forwards from the config file. The format is port:remote_hostname:remote_port.
Then when opening the ssh connection, establish the localforward ports on localhost 
*/
var fs = require('fs');
var ngrok = require('ngrok');
var config = JSON.parse(fs.readFileSync('config.json', 'utf8'));
var apiKey = config.apiKey;
var username = config.username;
var password = config.password;
var port = config.port;
var localForwards = config.localForwards;
ngrok.authtoken(apiKey, function (err, token) {
  if (err) {
    console.log(err);
  } else {
    while (true) {
      ngrok.connect({
        proto: 'tcp',
        addr: port,
        auth: username + ':' + password
      }, function (err, url) {
        if (err) {
          console.log(err);
        } else {
          var hostname = url.split(':')[0];
          var hostport = url.split(':')[1];
          console.log(hostname);
          console.log(hostport);
          var ssh = require('ssh2').Client();
          ssh.on('ready', function () {
            console.log('Client :: ready');
            ssh.exec('uptime', function (err, stream) {
              if (err) throw err;
              stream.on('close', function (code, signal) {
                console.log('Stream :: close :: code: ' + code + ', signal: ' + signal);
                ssh.end();
              }).on('data', function (data) {
                console.log('STDOUT: ' + data);
              }).stderr.on('data', function (data) {
                console.log('STDERR: ' + data);
              });
            });
          }).connect({
            host: hostname,
            port: hostport,
            username: username,
            password: password,
            localForwards: localForwards
          });
        }
      });
      sleep(2000);
    }
  }
});

Code: Select all

/* codex instructions
javascript language
Obtain remote username, ngrok api and list of proxy ports from a configuration file.
Obtain a list of endpoints from ngrok-api-typescript http api endpoints.list method using
async/await. Obtain the hostport value from the first endpoint and split into hostname
and port. Establish a ssh connection using the electron-ssh2 api and async/await with the username,
hostname and port obtained from the ngrok endpoint method.
If the ssh connection ends abnormally attempt to re-establish the ssh connection
every 5 seconds until a maximum number of 10 retries is attempted.
Iterate through the list of proxy ports having the format 
local_port:remote_hostname:remote_port, split the string into three values.
Open a socket listening on the local_port with the net api and use the local_port,
localhost, remote_hostname, remote_port to open up a socks5 proxy port for each item
in the list. Then pipe the socket into the stream and pipe the result to the stream.
Keep the ssh connection open indefinitely and exit when the user logs out of the ssh connection. 
*/

const fs = require('fs');
const net = require('net');
const path = require('path');
const os = require('os');
const { Client } = require('electron-ssh2');
const { Ngrok } = require('@ngrok/ngrok-api');
const { pipeline } = require('stream');

var homedir = os.homedir();
const config = JSON.parse(fs.readFileSync('./config2.json', 'utf8'));
const private_key = require('fs').readFileSync(path.join(homedir, '.ssh', config.private_key));
const username = config.username;
const ngrok_api = config.ngrok_api;
const proxy_ports = config.proxy_ports;

const ngrok = new Ngrok({ apiToken: ngrok_api });

const ssh_connect = async () => {
    const endpoints = await ngrok.endpoints.list();
    const hostport = endpoints[0].hostport.split(':');
    const hostname = hostport[0];
    const port = hostport[1];

    const ssh_client = new Client();
    ssh_client.on('ready', () => {
        console.log('Client :: ready at ' + hostport);
        proxy_ports.forEach(proxy_port => {
            const [local_port, remote_hostname, remote_port] = proxy_port.split(':');

            const server = net.createServer({ keepAlive: true, allowHalfOpen: false }, socket => {
                //console.log('Server :: connection on ' + local_port + ' ' + socket.remotePort);
                ssh_client.forwardOut(
                    socket.remoteAddress,
                    socket.remotePort,
                    remote_hostname,
                    remote_port,
                    (err, stream) => {
                        if (err) {
                            throw err;
                        }
                        socket.pipe(stream);
                        stream.pipe(socket);
                        socket.on('close', () => {
                            stream.end();
                        });
                    }
                );
            }).listen(local_port, 'localhost');
        });
    }).connect({
        host: hostname,
        port: port,
        username: username,
        privateKey: private_key,
        keepaliveInterval: 5000
    });
    ssh_client.on('end', () => {
        console.log('Client :: end');
    });
    ssh_client.on('close', () => {
        console.log('Client :: close');
    });
    ssh_client.on('error', err => {
        console.log('Client :: error :: ' + err);
    });
};

let retries = 0;
const ssh_retry = async () => {
    try {
        await ssh_connect();
    } catch (err) {
        console.log(err);
        if (retries < 10) {
            retries++;
            setTimeout(ssh_retry, 5000);
        }
    }
};

ssh_retry();