bdy 1.11.0-dev → 1.12.0-dev

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class OutputNoninteractiveConfigTunnels {
+    terminal;
+    tunnels;
     constructor(terminal, tunnels) {
         this.terminal = terminal;
         this.tunnels = tunnels;

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

@@ -3,9 +3,11 @@ 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"));
+const tunnel_1 = require("../../../types/tunnel");
 class OutputNoninteractiveTunnel {
+    tunnel;
+    terminal;
     constructor(terminal, tunnel) {
         this.tunnel = tunnel;
         this.terminal = terminal;
@@ -44,16 +46,16 @@ class OutputNoninteractiveTunnel {
         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));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.OPEN, (t) => this.onOpen(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.CLOSED, (t) => this.onClosed(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_OPEN, (t) => this.onTcpOpen(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TCP_CLOSED, (t) => this.onTcpClosed(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_OPEN, (t) => this.onTlsOpen(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.TLS_CLOSED, (t) => this.onTlsClosed(t));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_IDENTIFIED, (t, type) => this.onHttpIdentified(t, type));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, (t, logRequest) => this.onHttpRequest(t, logRequest));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.HTTP_RESPONSE, (t, logRequest) => this.onHttpResponse(t, logRequest));
+        this.tunnel.on(tunnel_1.TUNNEL_EVENT.STOPPED, () => this.onStopped());
     }
 }
 exports.default = OutputNoninteractiveTunnel;

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

@@ -13,6 +13,8 @@ const toPositiveHex = (hexString) => {
     return hexAsInt.toString() + hexString.substring(1);
 };
 class ServerCert {
+    key;
+    cert;
     constructor() {
         const keyPair = node_forge_1.default.pki.rsa.generateKeyPair(2048);
         const cert = node_forge_1.default.pki.createCertificate();

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

@@ -8,32 +8,36 @@ 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");
+const tunnel_1 = require("../../types/tunnel");
 class ServerHttp1 extends events_1.default {
+    server;
     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);
+            this.emit(tunnel_1.TUNNEL_HTTP_SOCKET.OPEN, socket);
             socket.once('close', () => {
-                this.emit(utils_1.HTTP1_SOCKET_CLOSED, socket);
+                this.emit(tunnel_1.TUNNEL_HTTP_SOCKET.CLOSED, socket);
             });
         });
         this.server.listen();
     }
     stop() {
-        this.server.close();
-        this.server.removeAllListeners();
+        if (this.server) {
+            this.server.close();
+            this.server.removeAllListeners();
+        }
         this.server = null;
     }
-    handleSshTunnel(stream, info, ip) {
+    handleSshTunnel(stream, _, ip) {
         logger_1.default.debug((0, texts_1.LOG_HTTP1_CONNECTION)(ip));
         stream.remoteAddress = ip;
-        this.server.emit('connection', stream);
+        if (this.server)
+            this.server.emit('connection', stream);
     }
     retryRequest(logRequest) {
-        const address = this.server.address();
+        const address = this.server?.address();
         if (!address || !address.port)
             return;
         let req = http_1.default.request({
@@ -50,7 +54,8 @@ class ServerHttp1 extends events_1.default {
             res.resume();
         });
         req.on('close', () => {
-            req.removeAllListeners();
+            if (req)
+                req.removeAllListeners();
             req = null;
         });
         req.end();
@@ -69,7 +74,7 @@ class ServerHttp1 extends events_1.default {
         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);
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, req, res);
     }
 }
 exports.default = ServerHttp1;

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

@@ -8,51 +8,57 @@ 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");
+const tunnel_1 = require("../../types/tunnel");
 class ServerHttp2 extends events_1.default {
+    server;
     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);
+            this.emit(tunnel_1.TUNNEL_EVENT.HTTP_SESSION_OPEN, session);
             session.once('close', () => {
-                this.emit(utils_1.HTTP2_SESSION_CLOSED, session);
+                this.emit(tunnel_1.TUNNEL_EVENT.HTTP_SESSION_CLOSED, session);
             });
         });
         this.server.listen();
     }
     stop() {
-        this.server.close();
-        this.server.removeAllListeners();
+        if (this.server) {
+            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);
+        if (this.server)
+            this.server.emit('connection', stream);
     }
     retryRequest(logRequest) {
-        const address = this.server.address();
+        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();
+            if (req)
+                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();
+            if (req)
+                req.removeAllListeners();
+            if (client)
+                client.close();
             req = null;
             client = null;
         });
@@ -72,7 +78,7 @@ class ServerHttp2 extends events_1.default {
         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);
+        this.emit(tunnel_1.TUNNEL_EVENT.HTTP_REQUEST, req, res);
     }
 }
 exports.default = ServerHttp2;

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

@@ -6,10 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = __importDefault(require("../../logger"));
 const ssh2_1 = __importDefault(require("ssh2"));
 const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
+const path_1 = require("path");
 const node_os_1 = require("node:os");
 const { flagsToString, STATUS_CODE } = ssh2_1.default.utils.sftp;
 class ServerSftp {
+    openHandlers;
+    count;
+    sftp;
     constructor(sftp) {
         logger_1.default.debug('Creating sftp server');
         this.openHandlers = new Map();
@@ -79,11 +82,7 @@ class ServerSftp {
             }
             const fd = this.openHandlers.get(id);
             const buffer = Buffer.alloc(length);
-            const r = await fd.read(buffer, {
-                offset: 0,
-                length,
-                position: offset,
-            });
+            const r = await fd.read(buffer, 0, length, offset);
             if (r.bytesRead <= 0) {
                 this.sftp.status(reqId, STATUS_CODE.EOF);
             }
@@ -142,6 +141,16 @@ class ServerSftp {
             this.debugEnd('SFTP close handler failed', s, err);
         }
     }
+    stats2attributes(stat) {
+        return {
+            mode: stat.mode,
+            uid: stat.uid,
+            gid: stat.gid,
+            size: stat.size,
+            atime: stat.atime.getTime() / 1000,
+            mtime: stat.mtime.getTime() / 1000
+        };
+    }
     async fstat(reqId, handle) {
         const s = this.debugStart('SFTP want to stat file');
         try {
@@ -153,7 +162,7 @@ class ServerSftp {
             }
             const fd = this.openHandlers.get(id);
             const attrs = await fd.stat();
-            this.sftp.attrs(reqId, attrs);
+            this.sftp.attrs(reqId, this.stats2attributes(attrs));
             this.debugEnd('SFTP stat file succeed', s);
         }
         catch (err) {
@@ -287,13 +296,13 @@ class ServerSftp {
                 }
                 else {
                     const name = dir.name;
-                    const fullPath = path_1.default.join(fd.path, name);
+                    const fullPath = (0, path_1.join)(fd.path, name);
                     const stat = await promises_1.default.lstat(fullPath);
                     const longname = await this.longname(fullPath, name, stat);
                     names.push({
                         filename: name,
                         longname,
-                        attrs: stat,
+                        attrs: this.stats2attributes(stat),
                     });
                     r += 1;
                 }
@@ -310,7 +319,7 @@ class ServerSftp {
         const s = this.debugStart(`SFTP want to stat ${path}`);
         try {
             const attrs = await promises_1.default.stat(path);
-            this.sftp.attrs(reqId, attrs);
+            this.sftp.attrs(reqId, this.stats2attributes(attrs));
             this.debugEnd('SFTP stat path succeed', s);
         }
         catch (err) {
@@ -352,9 +361,14 @@ class ServerSftp {
                 p = p.replaceAll('~', (0, node_os_1.homedir)());
             }
             const realPath = await promises_1.default.realpath(p);
+            const name = (0, path_1.basename)(realPath);
+            const stat = await promises_1.default.lstat(realPath);
+            const longname = await this.longname(realPath, name, stat);
             this.sftp.name(reqId, [
                 {
                     filename: realPath,
+                    longname,
+                    attrs: this.stats2attributes(stat)
                 },
             ]);
             this.debugEnd('SFTP realpath succeed', s);
@@ -368,9 +382,14 @@ class ServerSftp {
         const s = this.debugStart(`SFTP want readlink ${path}`);
         try {
             const realPath = await promises_1.default.readlink(path);
+            const name = (0, path_1.basename)(realPath);
+            const stats = await promises_1.default.lstat(realPath);
+            const longname = await this.longname(realPath, name, stats);
             this.sftp.name(reqId, [
                 {
                     filename: realPath,
+                    longname,
+                    attrs: this.stats2attributes(stats)
                 },
             ]);
             this.debugEnd('SFTP readlink succeed', s);
@@ -465,7 +484,7 @@ class ServerSftp {
         const s = this.debugStart(`SFTP want to lstat ${path}`);
         try {
             const attrs = await promises_1.default.lstat(path);
-            this.sftp.attrs(reqId, attrs);
+            this.sftp.attrs(reqId, this.stats2attributes(attrs));
             this.debugEnd('SFTP lstat path succeed', s);
         }
         catch (err) {
@@ -477,19 +496,17 @@ class ServerSftp {
         if (this.sftp) {
             this.sftp.removeAllListeners();
             this.sftp.end();
-            this.sftp = null;
         }
         if (this.openHandlers) {
-            this.openHandlers.forEach((fd) => {
+            this.openHandlers.forEach((fd, id) => {
                 try {
                     fd.close();
                 }
                 catch {
                     // do nothing
                 }
-                fd = null;
+                this.openHandlers.delete(id);
             });
-            this.openHandlers = null;
         }
         this.count = 0;
     }

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

@@ -14,8 +14,12 @@ const buddy_1 = __importDefault(require("../api/buddy"));
 const pipeStreamToChannel = (stream, channel) => {
     channel.once('exit', (code, signal) => {
         logger_1.default.debug(`shell channel exit: ${code}, signal: ${signal}`);
-        if (stream.exit)
-            stream.exit(signal || code);
+        if (stream.exit) {
+            if (signal)
+                stream.exit(signal);
+            else
+                stream.exit(code);
+        }
     });
     channel.on('close', () => {
         stream.end();
@@ -24,13 +28,16 @@ const pipeStreamToChannel = (stream, channel) => {
     channel.stderr.pipe(stream.stderr);
 };
 class ServerSsh extends events_1.default {
+    agent;
+    login;
+    password;
+    server;
     constructor(agent, login, password, hostKey) {
         super();
         this.agent = agent;
         this.login = login;
         this.password = password;
         this.server = new ssh2_1.default.Server({
-            keepAlive: true,
             hostKeys: [hostKey],
             highWaterMark: 16 * 1024 * 1024,
             ident: 'ssh2 server',
@@ -38,29 +45,35 @@ class ServerSsh extends events_1.default {
         this.server.listen();
     }
     stop() {
-        this.server.close();
-        this.server.removeAllListeners();
+        if (this.server) {
+            this.server.close();
+            this.server.removeAllListeners();
+        }
         this.server = null;
     }
     handleSshTunnel(stream) {
-        this.server.injectSocket(stream);
+        if (this.server)
+            this.server.injectSocket(stream);
     }
     checkValueSafe(input, allowed) {
         const autoReject = input.length !== allowed.length;
         if (autoReject)
             allowed = input;
         const isMatch = (0, crypto_1.timingSafeEqual)(input, allowed);
-        return (!autoReject && isMatch);
+        return !autoReject && isMatch;
     }
     async verifyKey(ctx, keys) {
         try {
             for (let i = 0; i < keys.length; i += 1) {
                 const publicKey = ssh2_1.default.utils.parseKey(keys[i]);
+                if (publicKey instanceof Error)
+                    continue;
                 if (ctx.key.algo !== publicKey.type)
                     continue;
                 if (!this.checkValueSafe(ctx.key.data, publicKey.getPublicSSH()))
                     continue;
-                if (ctx.signature && !publicKey.verify(ctx.blob, ctx.signature, ctx.hashAlgo))
+                if (ctx.signature &&
+                    !publicKey.verify(ctx.blob || '', ctx.signature, ctx.hashAlgo))
                     continue;
                 return true;
             }
@@ -85,7 +98,7 @@ class ServerSsh extends events_1.default {
                 host: '127.0.0.1',
                 port: 22,
                 username: 'root',
-                privateKey: privateKey
+                privateKey: privateKey,
             });
         });
     }
@@ -146,15 +159,15 @@ class ServerSsh extends events_1.default {
     }
     localExec(stream, command, env) {
         const s = process.hrtime();
-        (0, child_process_1.exec)(command, {
-            env,
-        }, (err, stdout, stderr) => {
+        const opts = {};
+        if (env)
+            opts.env = env;
+        (0, child_process_1.exec)(command, opts, (err, stdout, stderr) => {
             if (stream) {
                 stream.stderr.write(stderr);
                 stream.write(stdout);
                 stream.exit(!err ? 0 : 1);
                 stream.end();
-                stream = null;
             }
             const [seconds, nano] = process.hrtime(s);
             const ms = seconds * 1000 + nano / 1000 / 1000;
@@ -173,7 +186,6 @@ class ServerSsh extends events_1.default {
             pty = null;
             x11 = null;
             session.removeAllListeners();
-            session = null;
             if (sftp) {
                 sftp.destroy();
                 sftp = null;
@@ -183,7 +195,6 @@ class ServerSsh extends events_1.default {
                 channel = null;
             }
             client.removeListener('close', closeSession);
-            client = null;
         };
         client.on('close', closeSession);
         session.on('close', closeSession);
@@ -215,7 +226,7 @@ class ServerSsh extends events_1.default {
             pty.rows = info.rows;
             pty.width = info.width;
             if (channel && channel.setWindow)
-                channel.setWindow(pty.rows, pty.cols, pty.height, pty.width);
+                channel.setWindow(pty.rows || 1, pty.cols || 1, pty.height || 1, pty.width || 1);
             if (accept)
                 accept();
         });
@@ -227,10 +238,12 @@ class ServerSsh extends events_1.default {
                 return;
             }
             const stream = accept();
-            proxyClient.shell(pty, {
-                env,
-                x11
-            }, (err, c) => {
+            const opts = {};
+            if (env)
+                opts.env = env;
+            if (x11)
+                opts.x11 = x11;
+            proxyClient.shell(pty || {}, opts, (err, c) => {
                 if (err || !c) {
                     if (reject)
                         reject();
@@ -296,11 +309,14 @@ class ServerSsh extends events_1.default {
                 this.localExec(stream, info.command, env);
                 return;
             }
-            proxyClient.exec(info.command, {
-                env,
-                pty,
-                x11
-            }, (err, c) => {
+            const opts = {};
+            if (env)
+                opts.env = env;
+            if (pty)
+                opts.pty = pty;
+            if (x11)
+                opts.x11 = x11;
+            proxyClient.exec(info.command, opts, (err, c) => {
                 if (err || !c) {
                     if (reject)
                         reject();
@@ -309,12 +325,14 @@ class ServerSsh extends events_1.default {
                 pipeStreamToChannel(stream, c);
             });
         });
-        session.on('env', (accept, reject, info) => {
+        session.on('env', (accept, _, info) => {
             logger_1.default.debug('ssh env');
             logger_1.default.debug(info);
-            Object.keys(info || {}).forEach((key) => {
-                env[key] = info[key];
-            });
+            if (info.key) {
+                if (!env)
+                    env = {};
+                env[info.key] = info.val;
+            }
             if (accept)
                 accept();
         });
@@ -377,7 +395,7 @@ class ServerSsh extends events_1.default {
             let accepted = false;
             const socket = node_net_1.default.connect({
                 host: destIP,
-                port: destPort
+                port: destPort,
             });
             socket.on('connect', () => {
                 accepted = true;
@@ -409,7 +427,7 @@ class ServerSsh extends events_1.default {
                 return;
             }
             if (name === 'tcpip-forward') {
-                let { bindAddr, bindPort } = info;
+                const { bindAddr, bindPort } = info;
                 proxyClient.forwardIn(bindAddr, bindPort, (err, port) => {
                     if (err) {
                         reject();

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

@@ -6,8 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = __importDefault(require("events"));
 const tls_1 = __importDefault(require("tls"));
 const cert_js_1 = __importDefault(require("./cert.js"));
-const utils_1 = require("../../utils");
+const tunnel_1 = require("../../types/tunnel");
 class ServerTls extends events_1.default {
+    key;
+    cert;
+    ca;
+    server;
     constructor(key, cert, ca) {
         super();
         this.key = key;
@@ -22,19 +26,21 @@ class ServerTls extends events_1.default {
             handshakeTimeout: 60000,
             key: this.key,
             cert: this.cert,
-            ca: this.ca,
+            ca: this.ca || undefined,
             rejectUnauthorized: !!this.ca,
             requestCert: !!this.ca,
         }, (socket) => this.processSocket(socket));
     }
     async processSocket(socket) {
-        this.emit(utils_1.TLS_SOCKET, socket);
+        this.emit(tunnel_1.TUNNEL_EVENT.TLS_SOCKET, socket);
     }
     handleSshTunnel(channel) {
-        this.server.emit('connection', channel);
+        if (this.server)
+            this.server.emit('connection', channel);
     }
     stop() {
-        this.server.removeAllListeners();
+        if (this.server)
+            this.server.removeAllListeners();
         this.server = null;
     }
 }