bdy 1.7.46-dev

package/src/format.js

@@ -0,0 +1,171 @@
+const {
+  TLS_TERMINATE_AT_AGENT,
+  TLS_TERMINATE_AT_REGION,
+  TUNNEL_HTTP,
+  TARGET_ONLY_PORT_REGEX,
+  TARGET_HTTP_REGEX,
+  TARGET_TCP_TLS_REGEX,
+  TUNNEL_TCP,
+  TUNNEL_TLS,
+  TUNNEL_IDENTIFIED_HTTP1
+} = require('./utils');
+
+class Format {
+  static date() {
+    const dt = new Date();
+    return dt.toISOString();
+  }
+
+  static token(token) {
+    if (!token || token.length < 6) return 'Not provided';
+    return token.substring(0, 3) + '...' + token.substring(token.length - 3);
+  }
+
+  static region(region) {
+    if (!region) return 'Autodetect';
+    return region.toUpperCase();
+  }
+
+  static timeout(timeout) {
+    if (timeout === 1) return '1 second';
+    return `${timeout} seconds`;
+  }
+
+  static tunnelTimeout(timeout) {
+    if (!timeout) return 'Default';
+    return this.timeout(timeout);
+  }
+
+  static whitelist(whitelist) {
+    if (!whitelist || !whitelist.length) return 'No one';
+    if (whitelist.includes('*')) return 'Everyone';
+    return whitelist.join('\n');
+  }
+
+  static tunnelWhitelist(whitelist) {
+    if (!whitelist) return 'Default';
+    return this.whitelist(whitelist);
+  }
+
+  static tunnelHeaders(headers) {
+    if (!headers || !headers.length) return 'Not set';
+    return headers.map((h) => `${h.name}: ${h.value}`).join('\n');
+  }
+
+  static tunnelCircuitBreaker(cb) {
+    if (cb === undefined || cb === null) return 'Not set';
+    return String(cb);
+  }
+
+  static tunnelUserAgent(userAgents) {
+    if (!userAgents || !userAgents.length) return 'Everyone';
+    return userAgents.join('\n');
+  }
+
+  static tunnelDomain(domain) {
+    if (!domain) return 'Default';
+    return domain;
+  }
+
+  static type(type) {
+    return type.toUpperCase();
+  }
+
+  static tunnelRegion(region) {
+    if (!region) return 'Default';
+    return this.region(region);
+  }
+
+  static identify(identifyType) {
+    if (identifyType === TUNNEL_IDENTIFIED_HTTP1) return 'Ver. 1.1';
+    return 'Ver. 2';
+  }
+
+  static terminate(terminate) {
+    if (terminate === TLS_TERMINATE_AT_AGENT) return 'AGENT';
+    if (terminate === TLS_TERMINATE_AT_REGION) return 'REGION';
+    return 'TARGET';
+  }
+
+  static serve(serve) {
+    return serve;
+  }
+
+  static hostHeader(host) {
+    if (!host) return 'Not set';
+    return host;
+  }
+
+  static basicAuth(login, pass) {
+    if (!login || !pass) return 'Not set';
+    return `${login}:${pass}`;
+  }
+
+  static latency(latency) {
+    if (latency < 0) return 'Unreachable';
+    if (latency < 1000) return `${latency.toFixed(0)}ms`;
+    return `${(latency / 1000).toFixed(0)}s`;
+  }
+
+  static yesNo(val) {
+    if (!val) return 'No';
+    return 'Yes';
+  }
+
+  static entryHost(tunnel) {
+    let host = '';
+    host += tunnel.subdomain;
+    host += '.';
+    // todo custom domain
+    host += tunnel.region.toLowerCase();
+    host += '-';
+    host += tunnel.sshId;
+    host += '.';
+    host += tunnel.domain;
+    return host;
+  }
+
+  static entry(tunnel) {
+    let entry = '';
+    if (tunnel.type === TUNNEL_HTTP) entry += 'https://';
+    entry += this.entryHost(tunnel);
+    if (tunnel.type === TUNNEL_TCP) entry += `:${tunnel.sshForwardPort}`;
+    else if (tunnel.type === TUNNEL_TLS) entry += ':443';
+    return entry;
+  }
+
+  static target(type, target) {
+    if (type === TUNNEL_HTTP) {
+      let port = '80';
+      let host = 'localhost';
+      let proto = 'http';
+      let m = target.match(TARGET_ONLY_PORT_REGEX);
+      if (m) {
+        port = m[0];
+      } else {
+        m = target.match(TARGET_HTTP_REGEX);
+        if (m) {
+          if (m[2]) proto = m[2];
+          if (m[4]) host = m[4];
+          if (m[6]) port = m[6];
+          else if (proto === 'https') port = '443';
+        }
+      }
+      let t = `${proto}://${host}`;
+      if (proto === 'http' && port !== '80') t += `:${port}`;
+      else if (proto === 'https' && port !== '443') t += `:${port}`;
+      return t;
+    } else {
+      let host = 'localhost';
+      let port = '80';
+      const m = target.match(TARGET_TCP_TLS_REGEX);
+      if (m) {
+        if (m[3]) port = m[3];
+        if (m[2]) host = m[2];
+      }
+      return `${host}:${port}`;
+    }
+  }
+}
+
+module.exports = Format;

package/src/index.js

@@ -0,0 +1,32 @@
+const { Command } = require('commander');
+const commandConfig = require('./command/config.js');
+const Output = require('./output.js');
+const commandTcp = require('./command/tcp.js');
+const commandTls = require('./command/tls.js');
+const commandHttp = require('./command/http.js');
+const commandStart = require('./command/start.js');
+const commandAgent = require('./command/agent.js');
+const logger = require('./logger.js');
+const commandVersion = require('./command/version.js');
+const commandPre = require('./command/pre.js');
+const stream = require('stream');
+const { isDocker } = require('./utils');
+
+stream.setDefaultHighWaterMark(false, 67108864);
+process.title = 'bdy';
+process.on('uncaughtException', (err) => {
+  logger.fatal(err);
+  Output.exitError(err);
+});
+
+const program = new Command();
+program.hook('preAction', commandPre);
+program.addCommand(commandConfig);
+program.addCommand(commandTcp);
+program.addCommand(commandTls);
+program.addCommand(commandHttp);
+program.addCommand(commandStart);
+if (!isDocker()) program.addCommand(commandAgent);
+program.addCommand(commandVersion);
+
+program.parse();

package/src/input.js

@@ -0,0 +1,283 @@
+const Output = require('./output.js');
+const netmask = require('netmask');
+const fs = require('fs');
+const { statSync } = require('fs');
+const tls = require('tls');
+const crypto = require('crypto');
+const {
+  isStringRegExp,
+  REGION_EU,
+  REGION_US,
+  TARGET_HTTP_REGEX,
+  TARGET_ONLY_PORT_REGEX,
+  TARGET_TCP_TLS_REGEX,
+  TLS_TERMINATE_AT_AGENT,
+  TLS_TERMINATE_AT_REGION,
+  TLS_TERMINATE_AT_TARGET,
+  TUNNEL_HTTP,
+  TUNNEL_TCP,
+  TUNNEL_TLS
+} = require('./utils.js');
+const {
+  ERR_BA_IS_NOT_VALID,
+  ERR_BA_LOGIN_NOT_PROVIDED,
+  ERR_BA_PASSWORD_NOT_PROVIDED,
+  ERR_CA_PATH_IS_NOT_VALID,
+  ERR_CB_THRESHOLD_IS_NOT_VALID,
+  ERR_CERT_PATH_IS_NOT_VALID,
+  ERR_DIRECTORY_DOES_NOT_EXISTS,
+  ERR_DOMAIN_IS_NOT_VALID,
+  ERR_KEY_PATH_IS_NOT_VALID,
+  ERR_NAME_WITHOUT_ASTERISK,
+  ERR_PATH_IS_NOT_DIRECTORY,
+  ERR_PORT_IS_NOT_VALID,
+  ERR_REGION_IS_NOT_VALID,
+  ERR_SUBDOMAIN_IS_NOT_VALID,
+  ERR_SUBDOMAIN_IS_TOO_LONG,
+  ERR_SUBDOMAIN_IS_TOO_SHORT,
+  ERR_TARGET_IS_NOT_VALID,
+  ERR_TERMINATE_IS_NOT_VALID,
+  ERR_TIMEOUT_IS_NOT_VALID,
+  ERR_TYPE_IS_NOT_VALID,
+  ERR_USER_AGENT_IS_NOT_VALID,
+  ERR_WHITELIST_IS_NOT_VALID,
+  ERR_WRONG_CA,
+  ERR_WRONG_KEY_CERT
+} = require('./texts.js');
+
+class Input {
+  static timeout(timeout) {
+    const t = parseInt(timeout, 10);
+    if (isNaN(t) || t <= 0 || t > 999) {
+      Output.exitError(ERR_TIMEOUT_IS_NOT_VALID(timeout));
+    }
+    return t;
+  }
+
+  static serve(serve) {
+    if (!serve) return serve;
+    try {
+      const info = statSync(serve);
+      if (!info.isDirectory()) {
+        Output.exitError(ERR_PATH_IS_NOT_DIRECTORY(serve));
+      }
+    } catch (err) {
+      Output.exitError(ERR_DIRECTORY_DOES_NOT_EXISTS(serve));
+    }
+    return serve;
+  }
+
+  static circuitBreaker(threshold) {
+    if (threshold === undefined) return null;
+    const n = parseFloat(threshold);
+    if (isNaN(n) || n < 0 || n > 1) {
+      Output.exitError(ERR_CB_THRESHOLD_IS_NOT_VALID(n));
+    }
+    return n;
+  }
+
+  static headers(headers) {
+    const r = [];
+    (headers || []).forEach((h) => {
+      if (!h) return;
+      const s = h.split(':');
+      if (s.length !== 2) return;
+      r.push({
+        name: s[0],
+        value: s[1]
+      });
+    });
+    return r;
+  }
+
+  static subdomain(subdomain) {
+    if (!/^[a-z0-9-]+$/i.test(subdomain)) {
+      Output.exitError(ERR_SUBDOMAIN_IS_NOT_VALID(subdomain));
+    }
+    if (subdomain.length < 5) {
+      Output.exitError(ERR_SUBDOMAIN_IS_TOO_SHORT(subdomain));
+    }
+    if (subdomain.length > 63) {
+      Output.exitError(ERR_SUBDOMAIN_IS_TOO_LONG(subdomain));
+    }
+    return subdomain;
+  }
+
+  static domain(domain) {
+    if (!/^(?:[A-z0-9](?:[A-z0-9-]{0,61}[A-z0-9])?\.)+[A-z0-9][A-z0-9-]{0,61}[A-z0-9]$/i.test(domain)) {
+      Output.exitError(ERR_DOMAIN_IS_NOT_VALID(domain));
+    }
+    return domain;
+  }
+
+  static auth(auth) {
+    const s = auth.split(':');
+    if (s.length !== 2) {
+      Output.exitError(ERR_BA_IS_NOT_VALID(auth));
+    }
+    if (!s[0]) {
+      Output.exitError(ERR_BA_LOGIN_NOT_PROVIDED);
+    }
+    if (!s[1]) {
+      Output.exitError(ERR_BA_PASSWORD_NOT_PROVIDED);
+    }
+    return {
+      login: s[0],
+      password: s[1]
+    };
+  }
+
+  static useragents(useragents) {
+    if (!useragents || !useragents.length) return [];
+    useragents.forEach((ua) => {
+      if (isStringRegExp(ua)) {
+        try {
+          new RegExp(ua);
+        } catch (err) {
+          Output.exitError(ERR_USER_AGENT_IS_NOT_VALID(ua));
+        }
+      }
+    });
+    return useragents;
+  }
+
+  static whitelist(whitelist) {
+    if (!whitelist || !whitelist.length) return [];
+    for (let i = 0; i < whitelist.length; i += 1) {
+      const wh = whitelist[i];
+      if (wh === '*') return ['*'];
+      try {
+        new netmask.Netmask(wh);
+      } catch (err) {
+        Output.exitError(ERR_WHITELIST_IS_NOT_VALID(wh));
+      }
+    }
+    return whitelist;
+  }
+
+  static region(region) {
+    if (!region) Output.exitError(ERR_REGION_IS_NOT_VALID(''));
+    region = region.toUpperCase();
+    if (![REGION_EU, REGION_US].includes(region)) {
+      Output.exitError(ERR_REGION_IS_NOT_VALID(region));
+    }
+    return region;
+  }
+
+  static terminate(terminate) {
+    if (!terminate) return TLS_TERMINATE_AT_REGION;
+    terminate = terminate.toUpperCase();
+    if (![TLS_TERMINATE_AT_AGENT, TLS_TERMINATE_AT_REGION, TLS_TERMINATE_AT_TARGET].includes(terminate)) {
+      Output.exitError(ERR_TERMINATE_IS_NOT_VALID(terminate));
+    }
+    return terminate;
+  }
+
+  static target(target, type) {
+    if (!target) return '80';
+    if (target.length > 200) {
+      Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
+    }
+    target = target.toLowerCase();
+    // 80
+    // localhost
+    // localhost:80
+    // http://localhost:80
+    // http://localhost
+    // http://user:pass@localhost
+    // http://user:pass@localhost:80
+    let port;
+    if ([TUNNEL_TCP, TUNNEL_TLS].includes(type)) {
+      const m = target.match(TARGET_TCP_TLS_REGEX);
+      if (!m) {
+        Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
+      }
+      port = m[3];
+    } else {
+      let m = target.match(TARGET_ONLY_PORT_REGEX);
+      if (m) {
+        port = m[0];
+      } else {
+        m = target.match(TARGET_HTTP_REGEX);
+        if (!m) {
+          Output.exitError(ERR_TARGET_IS_NOT_VALID(target));
+        } else {
+          let proto;
+          if (m[2]) proto = m[2];
+          else proto = 'http';
+          if (m[6]) port = m[6];
+          else if (proto === 'https') port = '443';
+          else port = '80';
+        }
+      }
+    }
+    Input.port(port);
+    return target;
+  }
+
+  static port(port) {
+    const p = parseInt(port, 10);
+    if (isNaN(p) || p <= 0 || p > 65535) Output.exitError(ERR_PORT_IS_NOT_VALID(port));
+    return p;
+  }
+
+  static type(type) {
+    if (!type) return TUNNEL_TCP;
+    type = type.toUpperCase();
+    if (![TUNNEL_TCP, TUNNEL_TLS, TUNNEL_HTTP].includes(type)) {
+      Output.exitError(ERR_TYPE_IS_NOT_VALID(type));
+    }
+    return type;
+  }
+
+  static name(name) {
+    if (name.includes('*')) {
+      Output.exitError(ERR_NAME_WITHOUT_ASTERISK);
+    }
+    return name;
+  }
+
+  static ca(caPath) {
+    let cert;
+    try {
+      cert = fs.readFileSync(caPath, 'utf8');
+    } catch (err) {
+      Output.exitError(ERR_CA_PATH_IS_NOT_VALID(caPath));
+    }
+    try {
+      new crypto.X509Certificate(cert);
+    } catch (err) {
+      Output.exitError(ERR_WRONG_CA(caPath));
+    }
+    return cert;
+  }
+
+  static keyCert(keyPath, certPath) {
+    let key;
+    let cert;
+    try {
+      key = fs.readFileSync(keyPath, 'utf8');
+    } catch (err) {
+      Output.exitError(ERR_KEY_PATH_IS_NOT_VALID(keyPath));
+    }
+    try {
+      cert = fs.readFileSync(certPath, 'utf8');
+    } catch (err) {
+      Output.exitError(ERR_CERT_PATH_IS_NOT_VALID(certPath));
+    }
+    try {
+      tls.createSecureContext({
+        cert,
+        key
+      });
+    } catch (err) {
+      Output.exitError(ERR_WRONG_KEY_CERT);
+    }
+    return {
+      cert,
+      key
+    };
+  }
+}
+
+module.exports = Input;

package/src/logger.js

@@ -0,0 +1,87 @@
+const pino = require('pino');
+const { resolve } = require('path');
+const fs = require('fs');
+const {
+  getHomeDirectory,
+} = require('./utils.js');
+
+class Logger {
+  rootPath = null;
+  logPath = null;
+  log1Path = null;
+  logStream = null;
+  p = null;
+  ts = null;
+  constructor() {
+    this.rootPath = getHomeDirectory();
+  }
+  checkLogSize() {
+    try {
+      const s = fs.statSync(this.logPath);
+      if (s.size > 5242880) {
+        fs.copyFileSync(this.logPath, this.log1Path);
+        fs.truncateSync(this.logPath);
+      }
+    } catch {
+      // do nothing
+    }
+  }
+  getPino() {
+    if (!this.p) {
+      this.logPath = resolve(this.rootPath, 'cli.log');
+      this.log1Path = resolve(this.rootPath, 'cli.1.log');
+      this.logStream = fs.openSync(this.logPath, 'w');
+      this.p = pino({
+        level: process.env.DEBUG === '1' ? 'debug' : 'info',
+        timestamp: () => `, "time": "${new Date().toISOString()}"`,
+        formatters: {
+          bindings: () => ({}),
+          level: (label) => ({
+            level: label.toUpperCase()
+          })
+        }
+      }, pino.destination(this.logStream));
+      this.checkLogSize();
+      this.ts = setInterval(() => {
+        this.checkLogSize();
+      }, 30000);
+    }
+    return this.p;
+  }
+  error(...args) {
+    this.getPino().error(...args);
+  }
+  info(...args) {
+    this.getPino().info(...args);
+  }
+  debug(...args){
+    this.getPino().debug(...args);
+  }
+  fatal(...args){
+    this.getPino().fatal(...args);
+  }
+
+  stack() {
+    this.getPino().info(new Error().stack);
+  }
+
+  changeRootPath(path) {
+    if (this.ts) {
+      clearInterval(this.ts);
+      this.ts = null;
+    }
+    if (this.logStream) {
+      try {
+        this.logStream.close();
+      } catch {
+        // do nothing
+      }
+      this.logStream = null;
+    }
+    this.p = null;
+    this.rootPath = path;
+
+  }
+}
+
+module.exports = new Logger();