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

package/distTs/src/tunnel/ssh/client.js

@@ -1,211 +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 ssh2_1 = require("ssh2");
-const events_1 = __importDefault(require("events"));
-const logger_1 = __importDefault(require("../../logger"));
-const texts_1 = require("../../texts");
-const tunnel_1 = require("../../types/tunnel");
-class SshClient extends events_1.default {
-    ip;
-    port;
-    username;
-    password;
-    keepalive;
-    client;
-    constructor(ip, port, username, password) {
-        super();
-        this.ip = ip;
-        this.port = port;
-        this.username = username;
-        this.password = password;
-        this.keepalive = false;
-        logger_1.default.debug(`New ssh client: ${username}:${password}@${ip}:${port}`);
-    }
-    async open() {
-        return new Promise((resolve, reject) => {
-            this.close();
-            this.client = new ssh2_1.Client();
-            this.client.setNoDelay();
-            this.client.on('ready', () => {
-                if (this.client) {
-                    this.client.removeAllListeners();
-                    this.client.on('error', () => { });
-                }
-                resolve();
-            });
-            this.client.once('error', (err) => {
-                if (this.client) {
-                    this.client.removeAllListeners();
-                }
-                reject(err);
-            });
-            try {
-                this.client.connect({
-                    algorithms: {
-                        cipher: ['aes256-gcm@openssh.com'],
-                        compress: ['none'],
-                        hmac: ['hmac-sha2-256-etm@openssh.com'],
-                        kex: ['ecdh-sha2-nistp256'],
-                    },
-                    keepaliveInterval: 10000,
-                    host: this.ip,
-                    port: this.port,
-                    username: this.username,
-                    password: this.password,
-                });
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    waitForStreamReadable(s) {
-        return new Promise((resolve) => {
-            s.once('readable', resolve);
-        });
-    }
-    async readStreamBytes(s, toRead) {
-        await this.waitForStreamReadable(s);
-        const data = s.read(toRead) ?? s.read();
-        if (data === null) {
-            return this.readStreamBytes(s, toRead);
-        }
-        const newToRead = toRead - data.length;
-        if (newToRead <= 0)
-            return data;
-        const newData = await this.readStreamBytes(s, newToRead);
-        return Buffer.concat([data, newData]);
-    }
-    async processStream(stream, info) {
-        stream.allowHalfOpen = false;
-        if (stream.readableFlowing)
-            stream.pause();
-        stream.on('error', () => {
-            try {
-                stream.removeAllListeners();
-                stream.once('error', () => { });
-                stream.end();
-            }
-            catch {
-                // do nothing
-            }
-            setTimeout(() => {
-                try {
-                    stream.destroy();
-                }
-                catch {
-                    // do nothing
-                }
-            }, 1000);
-        });
-        stream.on('close', () => {
-            stream.removeAllListeners();
-        });
-        const triggerStream = (type, ip) => {
-            stream.removeAllListeners();
-            this.emit(type, stream, info, ip);
-        };
-        let type;
-        let ip;
-        try {
-            const b = await this.readStreamBytes(stream, 50);
-            const s = b.toString('utf8').replace(/\s+/, ' ').split(' ');
-            if (s.length !== 2)
-                throw new Error(texts_1.ERR_WRONG_HANDSHAKE);
-            type = parseInt(s[0]);
-            ip = s[1];
-        }
-        catch (err) {
-            stream.emit('error', err);
-            return;
-        }
-        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.TLS) {
-            logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('TLS'));
-            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TLS, ip);
-            return;
-        }
-        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.HTTP1) {
-            logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('HTTP1'));
-            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP1, ip);
-            return;
-        }
-        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.HTTP2) {
-            logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('HTTP2'));
-            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP2, ip);
-            return;
-        }
-        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.TCP) {
-            logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('TCP'));
-            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TCP, ip);
-            return;
-        }
-        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.SSH) {
-            logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('SSH'));
-            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_SSH, ip);
-            return;
-        }
-        logger_1.default.debug(texts_1.LOG_WRONG_STREAM);
-        stream.emit('error', new Error(texts_1.ERR_WRONG_STREAM));
-    }
-    forwardIn(port) {
-        return new Promise((resolve, reject) => {
-            if (this.client) {
-                this.client.on('tcp connection', async (info, accept) => {
-                    logger_1.default.debug(texts_1.LOG_SSH_CONNECTION);
-                    return this.processStream(accept(), info);
-                });
-                this.client.forwardIn('0.0.0.0', port, (err) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(err);
-                });
-            }
-        });
-    }
-    closeKeepAlive() {
-        this.keepalive = false;
-        this.close();
-    }
-    openKeepAlive() {
-        logger_1.default.debug(`SSH client open`);
-        this.keepalive = true;
-        this.open()
-            .then(() => {
-            logger_1.default.debug(`SSH client opened`);
-            this.emit(tunnel_1.TUNNEL_SSH_EVENT.CONNECTED);
-            if (this.client) {
-                this.client.on('close', () => {
-                    logger_1.default.debug(`SSH client closed`);
-                    if (this.keepalive)
-                        this.openKeepAlive();
-                });
-            }
-        })
-            .catch(() => {
-            logger_1.default.debug(`SSH client closed`);
-            this.emit(tunnel_1.TUNNEL_SSH_EVENT.DISCONNECTED);
-            setTimeout(() => {
-                if (this.keepalive)
-                    this.openKeepAlive();
-            }, 3000);
-        });
-    }
-    close() {
-        if (this.client) {
-            try {
-                this.client.removeAllListeners();
-                this.client.on('error', () => { });
-                this.client.end();
-            }
-            catch {
-                // nic nie rob
-            }
-            this.client = null;
-        }
-    }
-}
-exports.default = SshClient;

package/distTs/src/tunnel/tcp.js

@@ -1,113 +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 uuid_1 = require("uuid");
-const events_1 = __importDefault(require("events"));
-const utils_1 = require("../utils");
-const tunnel_1 = require("../types/tunnel");
-class TunnelTcp extends events_1.default {
-    id;
-    host;
-    port;
-    stream;
-    socket;
-    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 {
-            if (this.stream)
-                this.stream.unpipe();
-            if (this.socket)
-                this.socket.unpipe();
-        }
-        catch {
-            // do nothing
-        }
-        if (this.stream) {
-            try {
-                this.stream.removeAllListeners();
-                this.stream.on('error', () => { });
-                this.stream.end();
-            }
-            catch {
-                // do nothing
-            }
-        }
-        const s1 = this.stream;
-        if (this.socket) {
-            try {
-                this.socket.removeAllListeners();
-                this.socket.once('error', () => { });
-                this.socket.end();
-            }
-            catch {
-                // do nothing
-            }
-        }
-        const s2 = this.socket;
-        setTimeout(() => {
-            try {
-                if (s1)
-                    s1.destroy();
-            }
-            catch {
-                // do nothing
-            }
-            try {
-                if (s2)
-                    s2.destroy();
-            }
-            catch {
-                // do nothing
-            }
-        }, 1000);
-        this.socket = null;
-        this.stream = null;
-        this.host = null;
-        this.port = null;
-        this.emit(tunnel_1.TUNNEL_EVENT_TCP.CLOSED);
-    }
-    pipe() {
-        if (this.stream) {
-            this.stream.on('error', () => {
-                this.end();
-            });
-            this.stream.on('close', () => {
-                this.end();
-            });
-        }
-        if (this.socket) {
-            this.socket.on('error', () => {
-                this.end();
-            });
-            this.socket.on('close', () => {
-                this.end();
-            });
-            try {
-                this.socket.connect({
-                    noDelay: true,
-                    keepAlive: true,
-                    host: (0, utils_1.getRealTargetHost)(this.host),
-                    port: this.port || 0,
-                }, () => {
-                    if (this.socket && this.stream) {
-                        this.socket.pipe(this.stream).pipe(this.socket);
-                    }
-                });
-            }
-            catch {
-                this.end();
-            }
-        }
-    }
-}
-exports.default = TunnelTcp;