bdy 1.8.3-dev → 1.8.4-dev

package/distTs/src/tunnel/http.js

@@ -0,0 +1,405 @@
+"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 uuid_1 = require("uuid");
+const http_1 = __importDefault(require("http"));
+const utils_1 = require("../utils");
+const stream_1 = __importDefault(require("stream"));
+const texts_js_1 = require("../texts.js");
+const logger_js_1 = __importDefault(require("../logger.js"));
+const serve_js_1 = __importDefault(require("./http/serve.js"));
+const https_1 = __importDefault(require("https"));
+const compression_js_1 = __importDefault(require("./compression.js"));
+const html_js_1 = __importDefault(require("./html.js"));
+const url_1 = __importDefault(require("url"));
+const agent_js_1 = __importDefault(require("./agent.js"));
+class TunnelHttp extends events_1.default {
+    constructor({ req, res, proto, host, port, hostHeader, serve, timeout, httpIdentify, verify, httpLog, compression, headers, responseHeaders, auth = null, }) {
+        super();
+        this.id = (0, uuid_1.v4)();
+        this.host = host;
+        this.port = port;
+        this.proto = proto;
+        this.auth = auth;
+        this.req = req;
+        this.res = res;
+        this.hostHeader = hostHeader;
+        this.timeout = timeout || utils_1.DEFAULT_TIMEOUT;
+        this.httpIdentify = httpIdentify;
+        this.verify = verify;
+        this.compression = compression;
+        this.headers = {};
+        this.responseHeaders = {};
+        this.serve = serve;
+        if (responseHeaders) {
+            responseHeaders.forEach((header) => {
+                this.responseHeaders[header.name.toLowerCase()] = header.value;
+            });
+        }
+        if (headers) {
+            headers.forEach((header) => {
+                this.headers[header.name.toLowerCase()] = header.value;
+            });
+        }
+        this.httpLog = httpLog;
+        this.logRequest = null;
+    }
+    outputEnd(code, html) {
+        try {
+            if (this.logRequest) {
+                const s = new stream_1.default.Readable();
+                s.push(html);
+                s.push(null);
+                s.pipe(this.logRequest.responseBody);
+            }
+            this.httpLog.newResponse(this.req, code, {}, this.logRequest);
+            this.res.statusCode = code;
+            this.res.end(html);
+        }
+        catch {
+            // do nothing
+        }
+        this.clear();
+    }
+    getDisplayTarget() {
+        let t = `${this.proto}://${this.host}`;
+        if (this.proto === 'http' && this.port !== 80)
+            t += `:${this.port}`;
+        else if (this.proto === 'https' && this.port !== 443)
+            t += `:${this.port}`;
+        return t;
+    }
+    output503() {
+        this.outputEnd(503, html_js_1.default.get503(this.getDisplayTarget()));
+    }
+    outputHeaders(statusCode, headers) {
+        this.res.statusCode = statusCode;
+        Object.keys(headers).forEach((name) => {
+            this.res.setHeader(name.toLowerCase(), headers[name]);
+        });
+        Object.keys(this.responseHeaders).forEach((name) => {
+            this.res.setHeader(name.toLowerCase(), this.responseHeaders[name]);
+        });
+    }
+    getHostHeader() {
+        if (this.hostHeader)
+            return this.hostHeader;
+        let h = this.host;
+        if (this.proto === 'http' && this.port !== 80)
+            h += `:${this.port}`;
+        else if (this.proto === 'https' && this.port !== 443)
+            h += `:${this.port}`;
+        return h;
+    }
+    getRequestHeaders(http2) {
+        const h = {};
+        let ip;
+        if (this.req.httpVersion === '2.0') {
+            ip = this.req.socket.stream
+                ? this.req.socket.stream.remoteAddress
+                : '::1';
+        }
+        else {
+            ip = this.req.socket.remoteAddress;
+        }
+        if (http2) {
+            h[':scheme'] = this.proto;
+            h[':authority'] = this.getHostHeader();
+            h[':method'] = this.getMethod();
+            h[':path'] = this.getPath();
+        }
+        else {
+            h.host = this.getHostHeader();
+        }
+        h['x-forwarded-for'] = ip || '0.0.0.0';
+        h['x-forwarded-proto'] = 'https';
+        if (this.auth) {
+            h['authorization'] = `Basic ${Buffer.from(this.auth).toString('base64')}`;
+        }
+        return h;
+    }
+    getClearedHeaders(headers = {}, compressionMethod) {
+        const hop = [
+            ':method',
+            ':path',
+            ':scheme',
+            ':authority',
+            ':status',
+            'keep-alive',
+            'host',
+            'connection',
+            'proxy-authenticate',
+            'proxy-connection',
+            'Proxy-authorization',
+            'trailer',
+            'upgrade',
+            'transfer-encoding',
+            'strict-transport-security',
+            'te',
+        ];
+        const tmp = {};
+        if (compressionMethod &&
+            compressionMethod !== utils_1.TUNNEL_COMPRESSION_METHOD_IDENTITY) {
+            tmp['content-encoding'] = compressionMethod;
+            hop.push('content-length');
+            hop.push('content-encoding');
+        }
+        Object.keys(headers).forEach((name) => {
+            if (!hop.includes(name)) {
+                tmp[name] = headers[name];
+            }
+        });
+        return tmp;
+    }
+    getPath() {
+        const { pathname, search } = url_1.default.parse(this.req.url);
+        let path = pathname;
+        if (search)
+            path += search;
+        return path;
+    }
+    getMethod() {
+        return this.req.method;
+    }
+    createRequestHttp1() {
+        const reqHeaders = this.req.headers;
+        const method = this.getMethod();
+        const path = this.getPath();
+        const headers = {
+            ...this.getClearedHeaders(reqHeaders),
+            ...this.headers,
+            ...this.getRequestHeaders(false),
+        };
+        const r = http_1.default.request({
+            agent: agent_js_1.default.getHttp1(),
+            host: (0, utils_1.getRealTargetHost)(this.host),
+            port: this.port,
+            method,
+            protocol: 'http:',
+            setHost: false,
+            path,
+            headers,
+        });
+        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        r.on('response', (proxyRes) => {
+            this.proxyRes = proxyRes;
+            const statusCode = this.proxyRes.statusCode;
+            const resHeaders = this.proxyRes.headers;
+            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+            if (this.logRequest) {
+                this.proxyRes
+                    .pipe(this.logRequest.responseBody)
+                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(this.res);
+            }
+            else {
+                this.proxyRes
+                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(this.res);
+            }
+            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+        });
+        return r;
+    }
+    createRequestHttps1() {
+        const reqHeaders = this.req.headers;
+        const method = this.getMethod();
+        const headers = {
+            ...this.getClearedHeaders(reqHeaders),
+            ...this.headers,
+            ...this.getRequestHeaders(false),
+        };
+        const path = this.getPath();
+        const r = https_1.default.request({
+            agent: agent_js_1.default.getHttps1(),
+            host: (0, utils_1.getRealTargetHost)(this.host),
+            port: this.port,
+            method,
+            protocol: 'https:',
+            setHost: false,
+            path,
+            rejectUnauthorized: this.verify,
+            headers,
+        });
+        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        r.on('response', (proxyRes) => {
+            this.proxyRes = proxyRes;
+            const statusCode = this.proxyRes.statusCode;
+            const resHeaders = this.proxyRes.headers;
+            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+            if (this.logRequest) {
+                this.proxyRes
+                    .pipe(this.logRequest.responseBody)
+                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(this.res);
+            }
+            else {
+                this.proxyRes
+                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(this.res);
+            }
+            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+        });
+        return r;
+    }
+    createServe() {
+        const reqHeaders = this.req.headers;
+        const r = new serve_js_1.default(this.serve);
+        const method = this.getMethod();
+        const path = this.getPath();
+        this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, utils_1.TUNNEL_IDENTIFIED_HTTP1, this.req);
+        r.on('response', (statusCode, resHeaders, stream) => {
+            if (!stream) {
+                this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders));
+                this.res.end();
+            }
+            else {
+                const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+                this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+                if (this.logRequest) {
+                    stream
+                        .pipe(this.logRequest.responseBody)
+                        .pipe(compression_js_1.default.compress(compressionMethod))
+                        .pipe(this.res);
+                }
+                else {
+                    stream
+                        .pipe(compression_js_1.default.compress(compressionMethod))
+                        .pipe(this.res);
+                }
+            }
+            this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+        });
+        return r;
+    }
+    async createRequestHttps2() {
+        const reqHeaders = this.req.headers;
+        const authority = `${this.proto}://${(0, utils_1.getRealTargetHost)(this.host)}:${this.port}`;
+        const client = await agent_js_1.default.getHttp2Client(authority, this.host, this.verify);
+        const method = this.getMethod();
+        const path = this.getPath();
+        const headers = {
+            ...this.getClearedHeaders(reqHeaders),
+            ...this.headers,
+            ...this.getRequestHeaders(true),
+        };
+        const r = client.request(headers);
+        this.logRequest = this.httpLog.newRequest(method, headers, path, utils_1.TUNNEL_IDENTIFIED_HTTP2, this.req);
+        r.on('response', (resHeaders) => {
+            const status = resHeaders[':status'] || 200;
+            const compressionMethod = compression_js_1.default.detect(this.compression, reqHeaders, resHeaders);
+            this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
+            if (this.logRequest) {
+                r.pipe(this.logRequest.responseBody)
+                    .pipe(compression_js_1.default.compress(compressionMethod))
+                    .pipe(this.res);
+            }
+            else {
+                r.pipe(compression_js_1.default.compress(compressionMethod)).pipe(this.res);
+            }
+            this.httpLog.newResponse(this.req, status, resHeaders, this.logRequest);
+        });
+        return r;
+    }
+    async createRequest() {
+        if (this.httpIdentify === utils_1.TUNNEL_IDENTIFIED_HTTP1) {
+            if (this.proto === 'http')
+                return this.createRequestHttp1();
+            return this.createRequestHttps1();
+        }
+        return this.createRequestHttps2();
+    }
+    clear() {
+        if (this.req) {
+            this.req.removeAllListeners();
+            this.req = null;
+        }
+        if (this.res) {
+            this.res.removeAllListeners();
+            this.res = null;
+        }
+        if (this.proxyReq) {
+            this.proxyReq.removeAllListeners();
+            this.proxyReq = null;
+        }
+        if (this.proxyRes) {
+            this.proxyRes.removeAllListeners();
+            this.proxyRes = null;
+        }
+        if (this.httpLog) {
+            this.httpLog = null;
+        }
+        if (this.logRequest) {
+            this.logRequest.removeAllListeners();
+            this.logRequest = null;
+        }
+    }
+    async pipe() {
+        if (this.serve) {
+            try {
+                this.proxyReq = this.createServe();
+            }
+            catch (err) {
+                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
+                logger_js_1.default.debug(err);
+                this.output503();
+                return;
+            }
+            this.proxyReq.on('error', () => {
+                this.output503();
+            });
+            this.proxyReq.on('close', () => {
+                setTimeout(() => {
+                    this.clear();
+                }, 5000);
+            });
+            this.proxyReq.process(this.req);
+        }
+        else {
+            try {
+                this.proxyReq = await this.createRequest();
+            }
+            catch (err) {
+                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
+                logger_js_1.default.debug(err);
+                if (this.logRequest) {
+                    this.req.pipe(this.logRequest.requestBody);
+                    // no real request waiting for this data -> push it into the void
+                    this.logRequest.requestBody.pipeToNothing(() => {
+                        // wait for piping request
+                        this.output503();
+                    });
+                    return;
+                }
+                this.output503();
+                return;
+            }
+            this.proxyReq.setTimeout(this.timeout * 1000);
+            this.proxyReq.on('timeout', () => {
+                this.output503();
+            });
+            this.proxyReq.on('error', (err) => {
+                logger_js_1.default.debug(texts_js_1.LOG_ERROR);
+                logger_js_1.default.debug(err);
+                this.output503();
+            });
+            this.proxyReq.on('close', () => {
+                setTimeout(() => {
+                    this.clear();
+                }, 5000);
+            });
+            if (this.logRequest) {
+                this.req.pipe(this.logRequest.requestBody).pipe(this.proxyReq);
+            }
+            else {
+                this.req.pipe(this.proxyReq);
+            }
+        }
+    }
+}
+exports.default = TunnelHttp;

package/distTs/src/tunnel/identification.js

@@ -0,0 +1,96 @@
+"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 tls_1 = __importDefault(require("tls"));
+const net_1 = __importDefault(require("net"));
+const utils_js_1 = require("../utils.js");
+const utils_1 = require("../utils");
+const CHECK_INTERVAL = 300000;
+const CHECK_TIMEOUT = 5000;
+class TunnelIdentification extends events_1.default {
+    constructor(proto, host, port, forceHttp2) {
+        super();
+        this.proto = proto;
+        this.host = (0, utils_js_1.getRealTargetHost)(host);
+        this.port = port;
+        this.forceHttp2 = forceHttp2;
+        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
+        this.identify();
+        this.ts = setInterval(() => this.identify(), CHECK_INTERVAL);
+    }
+    stop() {
+        if (this.ts) {
+            clearInterval(this.ts);
+            this.ts = null;
+        }
+    }
+    identify() {
+        if (this.forceHttp2) {
+            this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
+            this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+            return;
+        }
+        let socket;
+        const close = () => {
+            try {
+                socket.removeAllListeners();
+                socket.close();
+            }
+            catch {
+                // do nothing
+            }
+        };
+        const connected = () => {
+            if (socket.alpnProtocol) {
+                if (socket.alpnProtocol === 'h2') {
+                    this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
+                    this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+                }
+                else {
+                    this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
+                    this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP1);
+                }
+                close();
+            }
+            else {
+                socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
+                socket.on('data', (d) => {
+                    if (/HTTP\/1\.1/.test(d.toString('utf8'))) {
+                        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP1;
+                        this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP1);
+                    }
+                    else {
+                        this.type = utils_1.TUNNEL_IDENTIFIED_HTTP2;
+                        this.emit(utils_1.EVENT_TUNNEL_IDENTIFIED, utils_1.TUNNEL_IDENTIFIED_HTTP2);
+                    }
+                    close();
+                });
+            }
+        };
+        if (this.proto === 'http') {
+            socket = net_1.default.connect({
+                host: this.host,
+                port: this.port,
+            });
+            socket.on('connect', connected);
+        }
+        else {
+            socket = tls_1.default.connect({
+                host: this.host,
+                port: this.port,
+                rejectUnauthorized: true,
+                ALPNProtocols: ['h2', 'http/1.1'],
+                servername: this.host,
+            });
+            socket.on('secureConnect', connected);
+        }
+        socket.setTimeout(CHECK_TIMEOUT);
+        socket.on('timeout', close);
+        socket.on('error', close);
+        socket.on('close', close);
+    }
+}
+exports.default = TunnelIdentification;

package/distTs/src/tunnel/latency.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = require("net");
+const events_1 = __importDefault(require("events"));
+const utils_js_1 = require("../utils.js");
+class TunnelLatency extends events_1.default {
+    constructor(host, port) {
+        super();
+        this.latency = -1;
+        this.isChecking = false;
+        this.port = port;
+        this.host = (0, utils_js_1.getRealTargetHost)(host);
+        this.ts = null;
+    }
+    check() {
+        if (this.isChecking)
+            return;
+        this.isChecking = true;
+        let socket = new net_1.Socket();
+        let ts = null;
+        const clear = () => {
+            clearTimeout(ts);
+            try {
+                socket.removeAllListeners();
+                socket.once('error', () => {
+                });
+                socket.end();
+                socket.destroy();
+            }
+            catch {
+                // do nothing
+            }
+            socket = null;
+            this.isChecking = false;
+        };
+        ts = setTimeout(() => {
+            this.latency = -1;
+            clear();
+        }, 30000);
+        const start = process.hrtime();
+        socket.on('error', () => {
+            this.latency = -1;
+            clear();
+        });
+        socket.on('ready', () => {
+            const elapsed = process.hrtime(start);
+            if (this.latency < 0)
+                this.emit(utils_js_1.TUNNEL_LATENCY_EVENT_RECONNECTED);
+            this.latency = elapsed[0] * 1000 + elapsed[1] / 1000000; // ms
+            clear();
+        });
+        socket.connect(this.port, this.host);
+    }
+    startChecking() {
+        this.check();
+        this.stopChecking();
+        this.ts = setInterval(() => {
+            this.check();
+        }, 3000);
+    }
+    stopChecking() {
+        if (this.ts) {
+            clearInterval(this.ts);
+            this.ts = null;
+        }
+    }
+}
+exports.default = TunnelLatency;

package/distTs/src/tunnel/tcp.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = require("net");
+const uuid_1 = require("uuid");
+const events_1 = __importDefault(require("events"));
+const utils_js_1 = require("../utils.js");
+const utils_1 = require("../utils");
+class TunnelTcp extends events_1.default {
+    constructor(host, port, stream) {
+        super();
+        this.id = (0, uuid_1.v4)();
+        this.host = host;
+        this.port = port;
+        this.stream = stream;
+        this.socket = new net_1.Socket();
+    }
+    end() {
+        try {
+            this.stream.unpipe();
+            this.socket.unpipe();
+        }
+        catch {
+            // do nothing
+        }
+        try {
+            this.stream.removeAllListeners();
+            this.stream.on('error', () => { });
+            this.stream.end();
+        }
+        catch {
+            // do nothing
+        }
+        const s1 = this.stream;
+        try {
+            this.socket.removeAllListeners();
+            this.socket.once('error', () => { });
+            this.socket.end();
+        }
+        catch {
+            // do nothing
+        }
+        const s2 = this.socket;
+        setTimeout(() => {
+            try {
+                s1.destroy();
+            }
+            catch {
+                // do nothing
+            }
+            try {
+                s2.destroy();
+            }
+            catch {
+                // do nothing
+            }
+        }, 1000);
+        this.socket = null;
+        this.stream = null;
+        this.host = null;
+        this.port = null;
+        this.emit(utils_1.TCP_EVENT_CLOSED);
+    }
+    pipe() {
+        this.socket.on('error', () => {
+            this.end();
+        });
+        this.socket.on('close', () => {
+            this.end();
+        });
+        this.stream.on('error', () => {
+            this.end();
+        });
+        this.stream.on('close', () => {
+            this.end();
+        });
+        try {
+            this.socket.connect({
+                host: (0, utils_js_1.getRealTargetHost)(this.host),
+                port: this.port,
+            }, () => {
+                this.socket.pipe(this.stream).pipe(this.socket);
+            });
+        }
+        catch {
+            this.end();
+        }
+    }
+}
+exports.default = TunnelTcp;