bdy 1.7.46-dev

package/src/output/noninteractive/agent/tunnels.js

@@ -0,0 +1,32 @@
+const { TUNNEL_OPEN } = require('../../../utils.js');
+const { NO_TUNNELS_STARTED } = require('../../../texts.js');
+const Format = require('../../../format');
+
+class OutputNoninteractiveAgentTunnels {
+  constructor(terminal, tunnels) {
+    this.terminal = terminal;
+    this.tunnels = tunnels;
+  }
+
+  start(output) {
+    if (!this.tunnels.length) {
+      output.exitNormal(NO_TUNNELS_STARTED);
+    } else {
+      const tunnels = [['Id', 'Type', 'Target / Latency', 'Entry / Latency', 'Status']];
+      this.tunnels.forEach((tunnel) => {
+        let target;
+        let status;
+        if (tunnel.serve) target = Format.serve(tunnel.serve) + ' / 0ms';
+        else target = Format.target(tunnel.type, tunnel.target) + ` / ${Format.latency(tunnel.targetLatency)}`;
+        const entry = Format.entry(tunnel) + ` / ${Format.latency(tunnel.regionLatency)}`;
+        if (tunnel.status === TUNNEL_OPEN) status = 'Open';
+        else status = 'Closed';
+        tunnels.push([tunnel.id, tunnel.type, target, entry, status]);
+      });
+      output.table(tunnels);
+      output.exitNormal();
+    }
+  }
+}
+
+module.exports = OutputNoninteractiveAgentTunnels;

package/src/output/noninteractive/config/tunnel.js

@@ -0,0 +1,52 @@
+const {
+  TUNNEL_HTTP,
+  TUNNEL_TLS
+} = require('../../../utils.js');
+const Format = require('../../../format');
+
+class OutputNoninteractiveConfigTunnel {
+  constructor(terminal, tunnel) {
+    this.terminal = terminal;
+    this.tunnel = tunnel;
+  }
+
+  start(output) {
+    const data = [
+      ['Name', this.tunnel.name],
+      ['Type', Format.type(this.tunnel.type)]
+    ];
+    if (this.tunnel.type === TUNNEL_HTTP && this.tunnel.serve) {
+      data.push(['Serve', Format.serve(this.tunnel.serve)]);
+    } else {
+      data.push(['Target', Format.target(this.tunnel.type, this.tunnel.target)]);
+    }
+    data.push(['Region', Format.tunnelRegion(this.tunnel.region)]);
+    data.push(['Server ID', this.tunnel.sshId]);
+    data.push(['Timeout', Format.tunnelTimeout(this.tunnel.timeout)]);
+    data.push(['Whitelist', Format.tunnelWhitelist(this.tunnel.whitelist)]);
+    data.push(['Domain', Format.tunnelDomain(this.tunnel.domain)]);
+    data.push(['Subdomain', Format.tunnelDomain(this.tunnel.subdomain)]);
+    if (this.tunnel.type === TUNNEL_HTTP) {
+      data.push(['Host Header', Format.hostHeader(this.tunnel.host)]);
+      data.push(['Basic Auth', Format.basicAuth(this.tunnel.login, this.tunnel.password)]);
+      data.push(['User Agents', Format.tunnelUserAgent(this.tunnel.useragents)]);
+      data.push(['Request Headers', Format.tunnelHeaders(this.tunnel.headers)]);
+      data.push(['Response Headers', Format.tunnelHeaders(this.tunnel.responseHeaders)]);
+      data.push(['Circuit Breaker', Format.tunnelCircuitBreaker(this.tunnel.circuitBreaker)]);
+      data.push(['Log Requests', Format.yesNo(this.tunnel.log)]);
+      data.push(['TLS Auth', Format.yesNo(!!this.tunnel.ca)]);
+      data.push(['TLS Verify', Format.yesNo(this.tunnel.verify)]);
+      data.push(['Force HTTP/2', Format.yesNo(this.tunnel.http2)]);
+      data.push(['Compression', Format.yesNo(this.tunnel.compression)]);
+    } else if (this.tunnel.type === TUNNEL_TLS) {
+      data.push(['Terminate TLS At', this.tunnel.terminate]);
+      data.push(['TLS Key', Format.yesNo(!!this.tunnel.key)]);
+      data.push(['TLS Cert', Format.yesNo(!!this.tunnel.cert)]);
+      data.push(['TLS Auth', Format.yesNo(!!this.tunnel.ca)]);
+    }
+    output.table(data);
+    output.exitNormal();
+  }
+}
+
+module.exports = OutputNoninteractiveConfigTunnel;

package/src/output/noninteractive/config/tunnels.js

@@ -0,0 +1,19 @@
+
+class OutputNoninteractiveConfigTunnels {
+  constructor(terminal, tunnels) {
+    this.terminal = terminal;
+    this.tunnels = tunnels;
+  }
+
+  start(output) {
+    const data = [['Name', 'Type', 'Target']];
+    Object.keys(this.tunnels).forEach((name) => {
+      const t = this.tunnels[name];
+      data.push([name, t.type, String(t.target)]);
+    });
+    output.table(data);
+    output.exitNormal();
+  }
+}
+
+module.exports = OutputNoninteractiveConfigTunnels;

package/src/output/noninteractive/tunnel.js

@@ -0,0 +1,79 @@
+const Format = require('../../format');
+const {
+  TUNNEL_EVENT_OPEN,
+  TUNNEL_EVENT_CLOSED,
+  TUNNEL_EVENT_TCP_OPEN,
+  TUNNEL_EVENT_TCP_CLOSED,
+  TUNNEL_EVENT_TLS_OPEN,
+  TUNNEL_EVENT_TLS_CLOSED,
+  TUNNEL_EVENT_HTTP_IDENTIFIED,
+  TUNNEL_EVENT_HTTP_REQUEST,
+  TUNNEL_EVENT_HTTP_RESPONSE,
+  TUNNEL_EVENT_STOPPED
+} = require('../../utils');
+
+class OutputNoninteractiveTunnel {
+  constructor(terminal, tunnel) {
+    this.tunnel = tunnel;
+    this.terminal = terminal;
+  }
+
+  status(t, status) {
+    this.terminal(`${Format.date()}: Tunnel ${t.type} to ${t.serve || t.target} ${status}\n`);
+  }
+
+  onOpen(t) {
+    this.status(t, `open. Entry: ${Format.entry(t)}`);
+  }
+
+  onClosed(t) {
+    this.status(t, 'closed');
+  }
+
+  onTcpOpen(t) {
+    this.status(t, 'has incoming tcp connection');
+  }
+
+  onTcpClosed(t) {
+    this.status(t, 'closed tcp connection');
+  }
+
+  onTlsOpen(t) {
+    this.status(t, 'has incoming tls connection');
+  }
+
+  onTlsClosed(t) {
+    this.status(t, 'closed tls connection');
+  }
+
+  onHttpIdentified(t, type) {
+    this.status(t, `identified as ${type}`);
+  }
+
+  onHttpRequest(t, logRequest) {
+    this.status(t, `Request ${logRequest.method} ${logRequest.url}`);
+  }
+
+  onHttpResponse(t, logRequest) {
+    this.status(t, `Response ${logRequest.method} ${logRequest.url} ${logRequest.status} in ${logRequest.time}ms`);
+  }
+
+  onStopped() {
+    process.exit();
+  }
+
+  start() {
+    this.tunnel.on(TUNNEL_EVENT_OPEN, (t) => this.onOpen(t));
+    this.tunnel.on(TUNNEL_EVENT_CLOSED, (t) => this.onClosed(t));
+    this.tunnel.on(TUNNEL_EVENT_TCP_OPEN, (t) => this.onTcpOpen(t));
+    this.tunnel.on(TUNNEL_EVENT_TCP_CLOSED, (t) => this.onTcpClosed(t));
+    this.tunnel.on(TUNNEL_EVENT_TLS_OPEN, (t) => this.onTlsOpen(t));
+    this.tunnel.on(TUNNEL_EVENT_TLS_CLOSED, (t) => this.onTlsClosed(t));
+    this.tunnel.on(TUNNEL_EVENT_HTTP_IDENTIFIED, (t, type) => this.onHttpIdentified(t, type));
+    this.tunnel.on(TUNNEL_EVENT_HTTP_REQUEST, (t, logRequest) => this.onHttpRequest(t, logRequest));
+    this.tunnel.on(TUNNEL_EVENT_HTTP_RESPONSE, (t, logRequest) => this.onHttpResponse(t, logRequest));
+    this.tunnel.on(TUNNEL_EVENT_STOPPED, (t) => this.onStopped(t));
+  }
+}
+
+module.exports = OutputNoninteractiveTunnel;

package/src/output.js

@@ -0,0 +1,136 @@
+const TerminalKit = require('terminal-kit/lib/termkit-no-lazy-require');
+const OutputInteractiveTunnel = require('./output/interactive/tunnel.js');
+const OutputNoninteractiveTunnel = require('./output/noninteractive/tunnel.js');
+const OutputNoninteractiveConfigTunnel = require('./output/noninteractive/config/tunnel.js');
+const OutputNoninteractiveConfigTunnels = require('./output/noninteractive/config/tunnels.js');
+const {
+  TXT_NEW_AGENT_VERSION,
+  TXT_NEW_CLI_AGENT_VERSION,
+  TXT_NEW_CLI_VERSION
+} = require('./texts.js');
+const OutputNoninteractiveAgentTunnels = require('./output/noninteractive/agent/tunnels.js');
+const { TXT_NEW_CLI_DOCKER_VERSION } = require('./texts');
+
+const terminal = TerminalKit.terminal;
+
+class Output {
+  static s;
+
+  static exitSuccess(msg) {
+    this.killSpinner();
+    terminal.green(`${msg}\n`);
+    process.exit(0);
+  }
+
+  static exitNormal(msg) {
+    this.killSpinner();
+    if (msg) terminal(`${msg}\n`);
+    process.exit(0);
+  }
+
+  static newline() {
+    terminal('\n');
+  }
+
+  static normal(txt) {
+    terminal(`${txt}\n`);
+  }
+
+  static killSpinner() {
+    if (this.s) {
+      this.s.destroy();
+      this.s = null;
+      terminal.eraseLine();
+      terminal.left();
+    }
+  }
+
+  static async spinner(txt) {
+    if (!this.s && terminal.isTTY) {
+      this.s = await terminal.spinner();
+      if (txt) terminal(` ${txt}`);
+    }
+  }
+
+  static agentTunnels(tunnels) {
+    const on = new OutputNoninteractiveAgentTunnels(terminal, tunnels);
+    on.start(this);
+  }
+
+  static tunnelInteractive(tunnel) {
+    this.killSpinner();
+    const oi = new OutputInteractiveTunnel(terminal, tunnel);
+    oi.start();
+  }
+
+  static tunnelNonInteractive(tunnel) {
+    this.killSpinner();
+    const on = new OutputNoninteractiveTunnel(terminal, tunnel);
+    on.start();
+  }
+
+  static newCliVersion(version) {
+    terminal.gray(TXT_NEW_CLI_VERSION(version));
+  }
+
+  static newCliDockerVersion(version) {
+    terminal.gray(TXT_NEW_CLI_DOCKER_VERSION(version));
+  }
+
+  static newCliAgentVersion(version) {
+    terminal.gray(TXT_NEW_CLI_AGENT_VERSION(version));
+  }
+
+  static newAgentVersion(version) {
+    terminal.gray(TXT_NEW_AGENT_VERSION(version));
+  }
+
+  static tunnel(tunnel) {
+    if (terminal.isTTY) this.tunnelInteractive(tunnel);
+    else this.tunnelNonInteractive(tunnel);
+  }
+
+  static table(data) {
+    // apply padding
+    for (let i=0; i < data.length; i += 1) {
+      for (let j=0; j < data[i].length; j += 1) {
+        const s = data[i][j].split('\n');
+        const tmp = [];
+        for (let k=0; k < s.length; k += 1) {
+          tmp.push(` ${s[k]} `);
+        }
+        data[i][j] = tmp.join('\n');
+      }
+    }
+    terminal.table(data, {
+      fit: false,
+    });
+  }
+
+  static configTunnels(tunnels) {
+    const on = new OutputNoninteractiveConfigTunnels(terminal, tunnels);
+    on.start(this);
+  }
+
+  static configTunnel(tunnel) {
+    const on = new OutputNoninteractiveConfigTunnel(terminal, tunnel);
+    on.start(this);
+  }
+
+  static exitError(err) {
+    this.killSpinner();
+    terminal.fullscreen(false);
+    terminal.hideCursor(false);
+    terminal.grabInput(false);
+    let msg;
+    if (err instanceof Error) {
+      msg = err.message;
+      if (process.env.DEBUG === '1') msg += `\n${err.stack}`;
+    }
+    else msg = err;
+    terminal.red.error(`${msg}\n`);
+    process.exit(1);
+  }
+}
+
+module.exports = Output;

package/src/server/cert.js

@@ -0,0 +1,51 @@
+const forge = require('node-forge');
+
+const toPositiveHex = (hexString) => {
+  let hexAsInt = parseInt(hexString[0], 16);
+  if (hexAsInt < 8){
+    return hexString;
+  }
+  hexAsInt -= 8;
+  return hexAsInt.toString() + hexString.substring(1);
+};
+
+class ServerCert {
+  constructor() {
+    const keyPair = forge.pki.rsa.generateKeyPair(2048);
+    const cert = forge.pki.createCertificate();
+    cert.serialNumber = toPositiveHex(forge.util.bytesToHex(forge.random.getBytesSync(9)));
+    cert.validity.notBefore = new Date();
+    const notAfter = new Date();
+    notAfter.setTime(notAfter.getTime() + 622080000000);
+    cert.validity.notAfter = notAfter;
+
+    const attrs = [{
+      name: 'commonName',
+      value: 'buddy.tunnel'
+    }];
+
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+
+    cert.publicKey = keyPair.publicKey;
+
+    cert.setExtensions([{
+      name: 'basicConstraints',
+      cA: true
+    }, {
+      name: 'keyUsage',
+      keyCertSign: true,
+      digitalSignature: true,
+      nonRepudiation: true,
+      keyEncipherment: true,
+      dataEncipherment: true
+    }]);
+
+    cert.sign(keyPair.privateKey, forge.md.sha256.create());
+
+    this.key = forge.pki.privateKeyToPem(keyPair.privateKey);
+    this.cert = forge.pki.certificateToPem(cert);
+  }
+}
+
+module.exports = ServerCert;

package/src/server/http1.js

@@ -0,0 +1,79 @@
+const EventEmitter = require('events');
+const logger = require('../logger.js');
+const { v4 } = require('uuid');
+const http = require('http');
+const {
+  LOG_HTTP1_CONNECTION,
+  LOG_HTTP1_REQUEST
+} = require('../texts.js');
+const {
+  HTTP1_SOCKET_OPEN,
+  HTTP1_SOCKET_CLOSED,
+  HTTP1_REQUEST
+} = require('../utils');
+
+class ServerHttp1 extends EventEmitter {
+  constructor(host) {
+    super();
+    this.server = http.createServer((req, res) => this.processRequest(req, res, host));
+    this.server.on('connection', (socket) => {
+      socket.id = v4();
+      this.emit(HTTP1_SOCKET_OPEN, socket);
+      socket.once('close', () => {
+        this.emit(HTTP1_SOCKET_CLOSED, socket);
+      });
+    });
+    this.server.listen();
+  }
+
+  stop() {
+    this.server.close();
+    this.server.removeAllListeners();
+    this.server = null;
+  }
+
+  handleSshTunnel(stream, info, ip) {
+    logger.debug(LOG_HTTP1_CONNECTION(ip));
+    stream.remoteAddress = ip;
+    this.server.emit('connection', stream);
+  }
+
+  retryRequest(logRequest) {
+    const address = this.server.address();
+    if (!address || !address.port) return;
+    let req = http.request({
+      host: 'localhost',
+      port: address.port,
+      method: logRequest.method,
+      setHost: false,
+      path: logRequest.url,
+      headers: logRequest.headers
+    });
+    if (logRequest.requestBody.data.length > 0) req.write(logRequest.requestBody.data);
+    req.on('response', (res) => {
+      res.resume();
+    });
+    req.on('close', () => {
+      req.removeAllListeners();
+      req = null;
+    });
+    req.end();
+  }
+
+  checkHostHeader(req, res, host) {
+    if (req.headers.host === host) return true;
+    else {
+      res.statusCode = 421;
+      res.end('Misdirected Request');
+      return false;
+    }
+  }
+
+  async processRequest(req, res, host) {
+    if (!this.checkHostHeader(req, res, host)) return;
+    logger.debug(LOG_HTTP1_REQUEST(req.method, req.url));
+    this.emit(HTTP1_REQUEST, req, res);
+  }
+}
+
+module.exports = ServerHttp1;

package/src/server/http2.js

@@ -0,0 +1,79 @@
+const EventEmitter = require('events');
+const http2 = require('http2');
+const logger = require('../logger.js');
+const { v4 } = require('uuid');
+const {
+  LOG_ERROR,
+  LOG_HTTP2_CONNECTION,
+  LOG_HTTP2_REQUEST
+} = require('../texts.js');
+const { HTTP2_SESSION_OPEN,
+  HTTP2_SESSION_CLOSED,
+  HTTP2_REQUEST
+} = require('../utils');
+
+class ServerHttp2 extends EventEmitter {
+  constructor(host) {
+    super();
+    this.server = http2.createServer((req, res) => this.processRequest(req, res, host));
+    this.server.on('session', (session) => {
+      session.id = v4();
+      this.emit(HTTP2_SESSION_OPEN, session);
+      session.once('close', () => {
+        this.emit(HTTP2_SESSION_CLOSED, session);
+      });
+    });
+    this.server.listen();
+  }
+
+  stop() {
+    this.server.close();
+    this.server.removeAllListeners();
+    this.server = null;
+  }
+
+  handleSshTunnel(stream, info, ip) {
+    logger.debug(LOG_HTTP2_CONNECTION(ip));
+    stream.remoteAddress = ip;
+    this.server.emit('connection', stream);
+  }
+
+  retryRequest(logRequest) {
+    const address = this.server.address();
+    if (!address || !address.port) return;
+    let client = http2.connect(`http://localhost:${address.port}`);
+    let req = client.request(logRequest.headers);
+    if (logRequest.requestBody.data.length > 0) req.write(logRequest.requestBody.data);
+    req.on('response', () => {
+      req.resume();
+    });
+    req.on('error', (err) => {
+      logger.debug(LOG_ERROR);
+      logger.debug(err);
+    });
+    req.on('close', () => {
+      req.removeAllListeners();
+      client.close();
+      req = null;
+      client = null;
+    });
+    req.end();
+  }
+
+  checkHostHeader(req, res, host) {
+    if (req.headers[':authority'] === host) return true;
+    else {
+      res.statusCode = 421;
+      res.end('Misdirected Request');
+      return false;
+    }
+  }
+
+  async processRequest(req, res, host) {
+    if (!this.checkHostHeader(req, res, host)) return;
+    logger.debug(LOG_HTTP2_REQUEST(req.method, req.url));
+    this.emit(HTTP2_REQUEST, req, res);
+  }
+}
+
+module.exports = ServerHttp2;