bdy 1.10.14-stage → 1.11.0-beta

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

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../../utils");
+const texts_1 = require("../../../../texts");
+const format_1 = __importDefault(require("../../../../format"));
+class OutputNoninteractiveAgentTunnels {
+    constructor(terminal, tunnels) {
+        this.terminal = terminal;
+        this.tunnels = tunnels;
+    }
+    start(output) {
+        if (!this.tunnels.length) {
+            output.exitNormal(texts_1.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_1.default.serve(tunnel.serve) + ' / 0ms';
+                else
+                    target =
+                        format_1.default.target(tunnel.type, tunnel.target) +
+                            ` / ${format_1.default.latency(tunnel.targetLatency)}`;
+                const entry = format_1.default.entry(tunnel) + ` / ${format_1.default.latency(tunnel.regionLatency)}`;
+                if (tunnel.status === utils_1.TUNNEL_OPEN)
+                    status = 'Open';
+                else
+                    status = 'Closed';
+                tunnels.push([tunnel.id, tunnel.type, target, entry, status]);
+            });
+            output.table(tunnels);
+            output.exitNormal();
+        }
+    }
+}
+exports.default = OutputNoninteractiveAgentTunnels;

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

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../../utils");
+const format_1 = __importDefault(require("../../../../format"));
+class OutputNoninteractiveConfigTunnel {
+    constructor(terminal, tunnel) {
+        this.terminal = terminal;
+        this.tunnel = tunnel;
+    }
+    start(output) {
+        const data = [
+            ['Name', this.tunnel.name],
+            ['Type', format_1.default.type(this.tunnel.type)],
+        ];
+        if (this.tunnel.type === utils_1.TUNNEL_HTTP && this.tunnel.serve) {
+            data.push(['Serve', format_1.default.serve(this.tunnel.serve)]);
+        }
+        else {
+            data.push([
+                'Target',
+                format_1.default.target(this.tunnel.type, this.tunnel.target),
+            ]);
+        }
+        data.push(['Region', format_1.default.tunnelRegion(this.tunnel.region)]);
+        data.push(['Timeout', format_1.default.tunnelTimeout(this.tunnel.timeout)]);
+        data.push(['Whitelist', format_1.default.tunnelWhitelist(this.tunnel.whitelist)]);
+        if (this.tunnel.type === utils_1.TUNNEL_HTTP) {
+            data.push(['Host Header', format_1.default.hostHeader(this.tunnel.host)]);
+            data.push([
+                'Basic Auth',
+                format_1.default.basicAuth(this.tunnel.login, this.tunnel.password),
+            ]);
+            data.push([
+                'User Agents',
+                format_1.default.tunnelUserAgent(this.tunnel.useragents),
+            ]);
+            data.push(['Request Headers', format_1.default.tunnelHeaders(this.tunnel.headers)]);
+            data.push([
+                'Response Headers',
+                format_1.default.tunnelHeaders(this.tunnel.responseHeaders),
+            ]);
+            data.push([
+                'Circuit Breaker',
+                format_1.default.tunnelCircuitBreaker(this.tunnel.circuitBreaker),
+            ]);
+            data.push(['Log Requests', format_1.default.yesNo(this.tunnel.log)]);
+            data.push(['TLS Auth', format_1.default.yesNo(!!this.tunnel.ca)]);
+            data.push(['TLS Verify', format_1.default.yesNo(this.tunnel.verify)]);
+            data.push(['Force HTTP/2', format_1.default.yesNo(this.tunnel.http2)]);
+            data.push(['Compression', format_1.default.yesNo(this.tunnel.compression)]);
+        }
+        else if (this.tunnel.type === utils_1.TUNNEL_TLS) {
+            data.push(['Terminate TLS At', this.tunnel.terminate]);
+            data.push(['TLS Key', format_1.default.yesNo(!!this.tunnel.key)]);
+            data.push(['TLS Cert', format_1.default.yesNo(!!this.tunnel.cert)]);
+            data.push(['TLS Auth', format_1.default.yesNo(!!this.tunnel.ca)]);
+        }
+        output.table(data);
+        output.exitNormal();
+    }
+}
+exports.default = OutputNoninteractiveConfigTunnel;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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();
+    }
+}
+exports.default = OutputNoninteractiveConfigTunnels;

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const format_1 = __importDefault(require("../../../format"));
+class OutputNoninteractiveTunnel {
+    constructor(terminal, tunnel) {
+        this.tunnel = tunnel;
+        this.terminal = terminal;
+    }
+    status(t, status) {
+        this.terminal(`${format_1.default.date()}: Tunnel ${t.type} to ${t.serve || t.target} ${status}\n`);
+    }
+    onOpen(t) {
+        this.status(t, `open. Entry: ${format_1.default.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(utils_1.TUNNEL_EVENT_OPEN, (t) => this.onOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_CLOSED, (t) => this.onClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_OPEN, (t) => this.onTcpOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TCP_CLOSED, (t) => this.onTcpClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_OPEN, (t) => this.onTlsOpen(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_TLS_CLOSED, (t) => this.onTlsClosed(t));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_IDENTIFIED, (t, type) => this.onHttpIdentified(t, type));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_REQUEST, (t, logRequest) => this.onHttpRequest(t, logRequest));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_HTTP_RESPONSE, (t, logRequest) => this.onHttpResponse(t, logRequest));
+        this.tunnel.on(utils_1.TUNNEL_EVENT_STOPPED, (t) => this.onStopped(t));
+    }
+}
+exports.default = OutputNoninteractiveTunnel;

package/distTs/src/tunnel/server/cert.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_forge_1 = __importDefault(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 = node_forge_1.default.pki.rsa.generateKeyPair(2048);
+        const cert = node_forge_1.default.pki.createCertificate();
+        cert.serialNumber = toPositiveHex(node_forge_1.default.util.bytesToHex(node_forge_1.default.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, node_forge_1.default.md.sha256.create());
+        this.key = node_forge_1.default.pki.privateKeyToPem(keyPair.privateKey);
+        this.cert = node_forge_1.default.pki.certificateToPem(cert);
+    }
+}
+exports.default = ServerCert;

package/distTs/src/tunnel/server/http1.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const logger_1 = __importDefault(require("../../logger"));
+const uuid_1 = require("uuid");
+const http_1 = __importDefault(require("http"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+class ServerHttp1 extends events_1.default {
+    constructor(host) {
+        super();
+        this.server = http_1.default.createServer((req, res) => this.processRequest(req, res, host));
+        this.server.on('connection', (socket) => {
+            socket.id = (0, uuid_1.v4)();
+            this.emit(utils_1.HTTP1_SOCKET_OPEN, socket);
+            socket.once('close', () => {
+                this.emit(utils_1.HTTP1_SOCKET_CLOSED, socket);
+            });
+        });
+        this.server.listen();
+    }
+    stop() {
+        this.server.close();
+        this.server.removeAllListeners();
+        this.server = null;
+    }
+    handleSshTunnel(stream, info, ip) {
+        logger_1.default.debug((0, texts_1.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_1.default.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) {
+        const headerHost = (req.headers.host || '').split(':')[0];
+        if (headerHost === 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_1.default.debug((0, texts_1.LOG_HTTP1_REQUEST)(req.method, req.url));
+        this.emit(utils_1.HTTP1_REQUEST, req, res);
+    }
+}
+exports.default = ServerHttp1;

package/distTs/src/tunnel/server/http2.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const http2_1 = __importDefault(require("http2"));
+const logger_js_1 = __importDefault(require("../../logger.js"));
+const uuid_1 = require("uuid");
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+class ServerHttp2 extends events_1.default {
+    constructor(host) {
+        super();
+        this.server = http2_1.default.createServer((req, res) => this.processRequest(req, res, host));
+        this.server.on('session', (session) => {
+            session.id = (0, uuid_1.v4)();
+            this.emit(utils_1.HTTP2_SESSION_OPEN, session);
+            session.once('close', () => {
+                this.emit(utils_1.HTTP2_SESSION_CLOSED, session);
+            });
+        });
+        this.server.listen();
+    }
+    stop() {
+        this.server.close();
+        this.server.removeAllListeners();
+        this.server = null;
+    }
+    handleSshTunnel(stream, info, ip) {
+        logger_js_1.default.debug((0, texts_1.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_1.default.connect(`http://localhost:${address.port}`, {
+            maxSessionMemory: 100,
+            noDelay: true
+        });
+        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_js_1.default.debug(texts_1.LOG_ERROR);
+            logger_js_1.default.debug(err);
+        });
+        req.on('close', () => {
+            req.removeAllListeners();
+            client.close();
+            req = null;
+            client = null;
+        });
+        req.end();
+    }
+    checkHostHeader(req, res, host) {
+        const headerHost = (req.headers[':authority'] || '').split(':')[0];
+        if (headerHost === 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_js_1.default.debug((0, texts_1.LOG_HTTP2_REQUEST)(req.method, req.url));
+        this.emit(utils_1.HTTP2_REQUEST, req, res);
+    }
+}
+exports.default = ServerHttp2;