bdy 1.12.8-dev → 1.12.8-dev-pipeline-run

package/distTs/src/tunnel/http.js

@@ -1,508 +0,0 @@
-"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_1 = require("../texts");
-const logger_1 = __importDefault(require("../logger"));
-const serve_1 = __importDefault(require("./http/serve"));
-const https_1 = __importDefault(require("https"));
-const compression_1 = __importDefault(require("./compression"));
-const html_1 = __importDefault(require("./html"));
-const agent_1 = __importDefault(require("./agent"));
-const punycode_1 = __importDefault(require("punycode/"));
-const tunnel_1 = require("../types/tunnel");
-class TunnelHttp extends events_1.default {
-    id;
-    req;
-    res;
-    proto;
-    host;
-    port;
-    hostHeader;
-    serve;
-    timeout;
-    httpIdentify;
-    verify;
-    compression;
-    headers;
-    responseHeaders;
-    httpLog;
-    logRequest;
-    auth;
-    proxyRes;
-    proxyReq;
-    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);
-            }
-            if (this.httpLog)
-                this.httpLog.newResponse(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;
-    }
-    output504() {
-        this.outputEnd(504, html_1.default.get504(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 punycode_1.default.toASCII(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 punycode_1.default.toASCII(h);
-    }
-    getForwardedHost() {
-        if (this.req.headers.host)
-            return this.req.headers.host;
-        if (this.req.headers[':authority'])
-            return this.req.headers[':authority'];
-        return 'localhost';
-    }
-    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';
-        h['x-forwarded-host'] = this.getForwardedHost();
-        if (this.auth) {
-            h['authorization'] = `Basic ${Buffer.from(this.auth).toString('base64')}`;
-        }
-        return h;
-    }
-    getClearedHeaders(headers = {}, compressionMethod, allowUpgrade = false) {
-        const hop = [
-            ':method',
-            ':path',
-            ':scheme',
-            ':authority',
-            ':status',
-            'host',
-            'proxy-authenticate',
-            'proxy-connection',
-            'proxy-authorization',
-            'trailer',
-            'transfer-encoding',
-            'strict-transport-security',
-            'te',
-        ];
-        if (!(allowUpgrade && headers.connection === 'Upgrade')) {
-            hop.push('upgrade');
-            hop.push('connection');
-            hop.push('keep-alive');
-        }
-        const tmp = {};
-        if (compressionMethod &&
-            compressionMethod !== tunnel_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];
-            }
-        });
-        tmp['access-control-allow-origin'] = '*';
-        if (tmp['set-cookie']) {
-            const setCookie = [];
-            const h = (this.req.headers.host ||
-                this.req.headers[':authority'] ||
-                '').split(':')[0];
-            tmp['set-cookie'].forEach((cookie) => {
-                setCookie.push(cookie.replaceAll(/([dD]omain)=[\w_\-\\.]+/gi, `$1=${h}`));
-            });
-            tmp['set-cookie'] = setCookie;
-        }
-        return tmp;
-    }
-    getPath() {
-        const { pathname, search } = new URL(this.req.url, 'http://a.b');
-        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, null, true),
-            ...this.headers,
-            ...this.getRequestHeaders(false),
-        };
-        const r = http_1.default.request({
-            agent: agent_1.default.getHttp1(),
-            host: (0, utils_1.getRealTargetHost)(this.host),
-            port: this.port,
-            method,
-            protocol: 'http:',
-            setHost: false,
-            path,
-            headers,
-        });
-        if (this.httpLog) {
-            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
-        }
-        r.on('upgrade', (proxyRes, socket, head) => this.upgrade(proxyRes, socket, head));
-        r.on('response', (proxyRes) => {
-            this.proxyRes = proxyRes;
-            const statusCode = this.proxyRes.statusCode;
-            const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
-            this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
-            if (this.logRequest) {
-                this.proxyRes
-                    .pipe(this.logRequest.responseBody)
-                    .pipe(compression_1.default.compress(compressionMethod))
-                    .pipe(this.res);
-            }
-            else {
-                this.proxyRes
-                    .pipe(compression_1.default.compress(compressionMethod))
-                    .pipe(this.res);
-            }
-            if (this.httpLog) {
-                this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
-            }
-        });
-        return r;
-    }
-    createRequestHttps1() {
-        const reqHeaders = this.req.headers;
-        const method = this.getMethod();
-        const headers = {
-            ...this.getClearedHeaders(reqHeaders, null, true),
-            ...this.headers,
-            ...this.getRequestHeaders(false),
-        };
-        const path = this.getPath();
-        const r = https_1.default.request({
-            agent: agent_1.default.getHttps1(),
-            host: (0, utils_1.getRealTargetHost)(this.host),
-            port: this.port,
-            method,
-            protocol: 'https:',
-            setHost: false,
-            path,
-            rejectUnauthorized: this.verify,
-            headers,
-        });
-        if (this.httpLog) {
-            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
-        }
-        r.on('upgrade', (proxyRes, socket, head) => this.upgrade(proxyRes, socket, head));
-        r.on('response', (proxyRes) => {
-            this.proxyRes = proxyRes;
-            const statusCode = this.proxyRes.statusCode;
-            const resHeaders = this.proxyRes.headers;
-            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
-            this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
-            if (this.logRequest) {
-                this.proxyRes
-                    .pipe(this.logRequest.responseBody)
-                    .pipe(compression_1.default.compress(compressionMethod))
-                    .pipe(this.res);
-            }
-            else {
-                this.proxyRes
-                    .pipe(compression_1.default.compress(compressionMethod))
-                    .pipe(this.res);
-            }
-            if (this.httpLog) {
-                this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
-            }
-        });
-        return r;
-    }
-    createServe() {
-        const reqHeaders = this.req.headers;
-        const r = new serve_1.default(this.serve || '');
-        const method = this.getMethod();
-        const path = this.getPath();
-        if (this.httpLog) {
-            this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1, this.req);
-        }
-        r.on('response', (statusCode, resHeaders, stream) => {
-            if (!stream) {
-                this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders));
-                this.res.end();
-            }
-            else {
-                const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
-                this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
-                if (this.logRequest) {
-                    stream
-                        .pipe(this.logRequest.responseBody)
-                        .pipe(compression_1.default.compress(compressionMethod))
-                        .pipe(this.res);
-                }
-                else {
-                    stream
-                        .pipe(compression_1.default.compress(compressionMethod))
-                        .pipe(this.res);
-                }
-            }
-            if (this.httpLog) {
-                this.httpLog.newResponse(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_1.default.getHttp2Client(authority, this.host || '', this.verify || false);
-        const method = this.getMethod();
-        const path = this.getPath();
-        const headers = {
-            ...this.getClearedHeaders(reqHeaders),
-            ...this.headers,
-            ...this.getRequestHeaders(true),
-        };
-        const r = client.request(headers);
-        if (this.httpLog) {
-            this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2, this.req);
-        }
-        r.on('response', (resHeaders) => {
-            const status = resHeaders[':status'] || 200;
-            const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
-            this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
-            if (this.logRequest) {
-                r.pipe(this.logRequest.responseBody)
-                    .pipe(compression_1.default.compress(compressionMethod))
-                    .pipe(this.res);
-            }
-            else {
-                r.pipe(compression_1.default.compress(compressionMethod)).pipe(this.res);
-            }
-            if (this.httpLog) {
-                this.httpLog.newResponse(status, resHeaders, this.logRequest);
-            }
-        });
-        return r;
-    }
-    async createRequest() {
-        if (this.httpIdentify === tunnel_1.TUNNEL_HTTP_IDENTIFY.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;
-        }
-    }
-    upgrade(proxyRes, socket, head) {
-        const resHeaders = proxyRes?.headers || {};
-        const reqSocket = this.req.socket;
-        if (this.httpLog) {
-            this.httpLog.newResponse(101, resHeaders, this.logRequest);
-        }
-        socket.setTimeout(0);
-        const headers = this.getClearedHeaders(resHeaders, null, true);
-        this.clear();
-        let msg = 'HTTP/1.1 101 Web Socket Protocol Handshake\r\n';
-        Object.keys(headers).forEach((k) => {
-            const v = headers[k];
-            if (Array.isArray(v)) {
-                v.forEach((vv) => {
-                    msg += `${k}: ${vv}\r\n`;
-                });
-            }
-            else {
-                msg += `${k}: ${v}\r\n`;
-            }
-        });
-        msg += '\r\n';
-        reqSocket.removeAllListeners();
-        socket.removeAllListeners();
-        reqSocket.on('close', () => {
-            reqSocket.removeAllListeners();
-            this.emit(tunnel_1.TUNNEL_HTTP_SOCKET.CLOSED, reqSocket);
-        });
-        socket.on('close', () => {
-            socket.removeAllListeners();
-            try {
-                reqSocket.destroy();
-            }
-            catch {
-                // do nothing
-            }
-        });
-        if (head && head.length) {
-            socket.unshift(head);
-        }
-        reqSocket.write(msg);
-        reqSocket.pipe(socket).pipe(reqSocket);
-    }
-    async pipe() {
-        if (this.serve) {
-            try {
-                this.proxyReq = this.createServe();
-            }
-            catch (err) {
-                logger_1.default.debug(texts_1.LOG_ERROR);
-                logger_1.default.debug(err);
-                this.output504();
-                return;
-            }
-            this.proxyReq.on('error', () => {
-                this.output504();
-            });
-            this.proxyReq.on('close', () => {
-                setTimeout(() => {
-                    this.clear();
-                }, 5000);
-            });
-            this.proxyReq.process(this.req);
-        }
-        else {
-            try {
-                this.proxyReq = await this.createRequest();
-            }
-            catch (err) {
-                logger_1.default.debug(texts_1.LOG_ERROR);
-                logger_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.output504();
-                    });
-                    return;
-                }
-                this.output504();
-                return;
-            }
-            this.proxyReq.setTimeout(this.timeout * 1000);
-            this.proxyReq.on('timeout', () => {
-                this.output504();
-            });
-            this.proxyReq.on('error', (err) => {
-                logger_1.default.debug(texts_1.LOG_ERROR);
-                logger_1.default.debug(err);
-                this.output504();
-            });
-            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

@@ -1,103 +0,0 @@
-"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_1 = require("../utils");
-const tunnel_1 = require("../types/tunnel");
-const CHECK_INTERVAL = 300000;
-const CHECK_TIMEOUT = 5000;
-class TunnelIdentification extends events_1.default {
-    proto;
-    host;
-    port;
-    forceHttp2;
-    type;
-    ts;
-    constructor(proto, host, port, forceHttp2) {
-        super();
-        this.proto = proto;
-        this.host = (0, utils_1.getRealTargetHost)(host);
-        this.port = port;
-        this.forceHttp2 = forceHttp2;
-        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.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 = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
-            this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2);
-            return;
-        }
-        let socket;
-        const close = () => {
-            try {
-                socket.removeAllListeners();
-                socket.end();
-                socket.destroy();
-            }
-            catch {
-                // do nothing
-            }
-        };
-        const connected = () => {
-            if (socket instanceof tls_1.default.TLSSocket && socket.alpnProtocol) {
-                if (socket.alpnProtocol === 'h2') {
-                    this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
-                    this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2);
-                }
-                else {
-                    this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1;
-                    this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1);
-                }
-                close();
-            }
-            else {
-                socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
-                socket.on('data', (d) => {
-                    if (/HTTP\/1/.test(d.toString('utf8'))) {
-                        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1;
-                        this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP1);
-                    }
-                    else {
-                        this.type = tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2;
-                        this.emit(tunnel_1.TUNNEL_EVENT.IDENTIFIED, tunnel_1.TUNNEL_HTTP_IDENTIFY.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

@@ -1,83 +0,0 @@
-"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_1 = require("../utils");
-const tunnel_1 = require("../types/tunnel");
-class TunnelLatency extends events_1.default {
-    latency;
-    isChecking;
-    port;
-    host;
-    ts;
-    constructor(host, port) {
-        super();
-        this.latency = -1;
-        this.isChecking = false;
-        this.port = port;
-        this.host = (0, utils_1.getRealTargetHost)(host);
-        this.ts = null;
-    }
-    check() {
-        if (this.isChecking)
-            return;
-        if (!this.port || !this.host) {
-            this.latency = -1;
-            return;
-        }
-        this.isChecking = true;
-        let socket = new net_1.Socket();
-        let ts = null;
-        const clear = () => {
-            if (ts)
-                clearTimeout(ts);
-            if (socket) {
-                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(tunnel_1.TUNNEL_EVENT_LATENCY.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;