mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 07:04:53 +00:00
751 lines
24 KiB
JavaScript
751 lines
24 KiB
JavaScript
/**
|
|
* Port Forwarding Bridge - Handles SSH port forwarding tunnels
|
|
* Extracted from main.cjs for single responsibility
|
|
*/
|
|
|
|
const net = require("node:net");
|
|
require("./boringSslDhCompat.cjs").installBoringSslDhCompat();
|
|
const { Client: SSHClient } = require("ssh2");
|
|
const { NetcattyAgent } = require("./netcattyAgent.cjs");
|
|
const keyboardInteractiveHandler = require("./keyboardInteractiveHandler.cjs");
|
|
const { connectThroughChain, buildAlgorithms } = require("./sshBridge.cjs");
|
|
const { resolveSshConnectionTimeouts } = require("./sshBridge/startSession.cjs");
|
|
const hostKeyVerifier = require("./hostKeyVerifier.cjs");
|
|
const { createProxySocket, runWhenProxyConnectionReady } = require("./proxyUtils.cjs");
|
|
const {
|
|
buildAuthHandler,
|
|
createKeyboardInteractiveHandler,
|
|
applyAuthToConnOpts,
|
|
findAllDefaultPrivateKeys: findAllDefaultPrivateKeysFromHelper,
|
|
preparePrivateKeyForAuth,
|
|
loadFirstIdentityFileForAuth,
|
|
prepareSystemSshAgentForAuth,
|
|
isPassphraseCancelledError,
|
|
} = require("./sshAuthHelper.cjs");
|
|
|
|
// Active port forwarding tunnels
|
|
const portForwardingTunnels = new Map();
|
|
|
|
function cleanupChainConnections(connections) {
|
|
if (!Array.isArray(connections)) return;
|
|
for (const chainConn of connections) {
|
|
try { chainConn.end(); } catch { /* ignore */ }
|
|
}
|
|
}
|
|
|
|
function isTunnelCancelled(tunnelState) {
|
|
return Boolean(tunnelState?.cancelled);
|
|
}
|
|
|
|
function cancelTunnel(tunnelId, tunnel, sendStatus, { deleteEntry = false } = {}) {
|
|
if (!tunnel) return;
|
|
tunnel.cancelled = true;
|
|
tunnel.status = 'inactive';
|
|
if (tunnel.server) {
|
|
try { tunnel.server.close(); } catch { /* ignore */ }
|
|
}
|
|
if (tunnel.passphraseAbortController && !tunnel.passphraseAbortController.signal.aborted) {
|
|
try { tunnel.passphraseAbortController.abort(); } catch { /* ignore */ }
|
|
}
|
|
if (tunnel.pendingConn) {
|
|
try { tunnel.pendingConn.end(); } catch { /* ignore */ }
|
|
}
|
|
cleanupChainConnections(tunnel.chainConnections);
|
|
if (tunnel.conn) {
|
|
try { tunnel.conn.end(); } catch { /* ignore */ }
|
|
}
|
|
sendStatus?.('inactive');
|
|
if (deleteEntry) {
|
|
portForwardingTunnels.delete(tunnelId);
|
|
}
|
|
}
|
|
|
|
const { safeSend } = require("./ipcUtils.cjs");
|
|
|
|
/**
|
|
* Start a port forwarding tunnel
|
|
*/
|
|
async function startPortForward(event, payload) {
|
|
const {
|
|
ruleId,
|
|
tunnelId,
|
|
type, // 'local' | 'remote' | 'dynamic'
|
|
localPort,
|
|
bindAddress = '127.0.0.1',
|
|
remoteHost,
|
|
remotePort,
|
|
hostname,
|
|
port = 22,
|
|
username,
|
|
password,
|
|
privateKey,
|
|
certificate,
|
|
keyId,
|
|
passphrase,
|
|
knownHosts,
|
|
verifyHostKeys,
|
|
proxy,
|
|
jumpHosts = [],
|
|
identityFilePaths,
|
|
useSshAgent,
|
|
identityAgent,
|
|
identitiesOnly,
|
|
addKeysToAgent,
|
|
useKeychain,
|
|
legacyAlgorithms,
|
|
skipEcdsaHostKey,
|
|
algorithmOverrides,
|
|
keepaliveInterval: resolvedKeepaliveInterval,
|
|
keepaliveCountMax: resolvedKeepaliveCountMax,
|
|
sshTcpConnectTimeoutMs,
|
|
sshAuthReadyTimeoutMs,
|
|
} = payload;
|
|
const connectionTimeouts = resolveSshConnectionTimeouts({
|
|
sshTcpConnectTimeoutMs,
|
|
sshAuthReadyTimeoutMs,
|
|
});
|
|
|
|
const conn = new SSHClient();
|
|
const sender = event.sender;
|
|
const hasJumpHosts = jumpHosts.length > 0;
|
|
const hasProxy = !!proxy;
|
|
let chainConnections = [];
|
|
let connectionSocket = null;
|
|
const passphraseAbortController = new AbortController();
|
|
const tunnelState = {
|
|
type,
|
|
conn,
|
|
pendingConn: null,
|
|
server: null,
|
|
chainConnections,
|
|
passphraseAbortController,
|
|
ruleId,
|
|
status: 'connecting',
|
|
webContentsId: sender.id,
|
|
cancelled: false,
|
|
};
|
|
|
|
const sendStatus = (status, error = null) => {
|
|
if (!sender.isDestroyed()) {
|
|
sender.send("netcatty:portforward:status", { tunnelId, status, error });
|
|
}
|
|
};
|
|
|
|
// Keepalive policy:
|
|
// - positive value: honor it
|
|
// - explicit 0: truly disabled (host opted out via per-host override —
|
|
// a router/switch that doesn't reply to keepalive@openssh.com would
|
|
// otherwise be killed by ssh2 after countMax unanswered probes)
|
|
// - undefined: legacy caller path, fall back to 10s/3 so an idle
|
|
// forwarded TCP tunnel doesn't get dropped by NAT state tables.
|
|
const tunnelKeepaliveMs = resolvedKeepaliveInterval == null
|
|
? 10000
|
|
: (resolvedKeepaliveInterval > 0 ? resolvedKeepaliveInterval * 1000 : 0);
|
|
const tunnelKeepaliveCountMax = resolvedKeepaliveInterval == null
|
|
? 3
|
|
: (resolvedKeepaliveInterval > 0 ? (resolvedKeepaliveCountMax ?? 3) : 0);
|
|
const connectOpts = {
|
|
host: hostname,
|
|
port: port,
|
|
username: username || 'root',
|
|
timeout: connectionTimeouts.tcpConnectTimeoutMs,
|
|
readyTimeout: 0,
|
|
keepaliveInterval: tunnelKeepaliveMs,
|
|
keepaliveCountMax: tunnelKeepaliveCountMax,
|
|
// Enable keyboard-interactive authentication (required for 2FA/MFA)
|
|
tryKeyboard: true,
|
|
algorithms: buildAlgorithms(legacyAlgorithms, { skipEcdsaHostKey, algorithmOverrides }),
|
|
};
|
|
connectOpts.hostVerifier = hostKeyVerifier.createHostVerifier({
|
|
sender,
|
|
sessionId: tunnelId,
|
|
hostname,
|
|
port,
|
|
knownHosts,
|
|
verifyHostKeys,
|
|
});
|
|
|
|
const hasCertificate = typeof certificate === "string" && certificate.trim().length > 0;
|
|
sendStatus('connecting');
|
|
portForwardingTunnels.set(tunnelId, tunnelState);
|
|
|
|
let defaultKeys = [];
|
|
try {
|
|
const systemAuthAgent = hasCertificate ? null : await prepareSystemSshAgentForAuth({
|
|
useSshAgent,
|
|
identityAgent,
|
|
identityFilePaths,
|
|
identitiesOnly,
|
|
addKeysToAgent,
|
|
useKeychain,
|
|
hostname,
|
|
username,
|
|
}, "[PortForward]");
|
|
const identityFile = !privateKey && !systemAuthAgent
|
|
? await loadFirstIdentityFileForAuth({
|
|
sender,
|
|
identityFilePaths,
|
|
hostname,
|
|
initialPassphrase: passphrase,
|
|
passphraseSignal: passphraseAbortController.signal,
|
|
logPrefix: "[PortForward]",
|
|
onError: (err, keyPath) => {
|
|
console.warn(`[PortForward] Failed to read identity file ${keyPath}:`, err.message);
|
|
},
|
|
})
|
|
: null;
|
|
const inlineKey = privateKey && !systemAuthAgent
|
|
? await preparePrivateKeyForAuth({
|
|
sender,
|
|
privateKey,
|
|
keyId,
|
|
keyName: keyId || username,
|
|
hostname,
|
|
initialPassphrase: passphrase,
|
|
passphraseSignal: passphraseAbortController.signal,
|
|
logPrefix: "[PortForward]",
|
|
})
|
|
: null;
|
|
const effectivePrivateKey = inlineKey?.privateKey || identityFile?.privateKey;
|
|
const effectivePassphrase = inlineKey?.passphrase || identityFile?.passphrase;
|
|
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
|
|
if (systemAuthAgent) {
|
|
connectOpts.agent = systemAuthAgent;
|
|
}
|
|
if (hasCertificate) {
|
|
connectOpts.agent = new NetcattyAgent({
|
|
mode: "certificate",
|
|
webContents: sender,
|
|
meta: {
|
|
label: keyId || username || "",
|
|
certificate,
|
|
privateKey: effectivePrivateKey,
|
|
passphrase: effectivePassphrase,
|
|
},
|
|
});
|
|
} else if (effectivePrivateKey) {
|
|
connectOpts.privateKey = effectivePrivateKey;
|
|
if (effectivePassphrase) {
|
|
connectOpts.passphrase = effectivePassphrase;
|
|
}
|
|
}
|
|
if (password) {
|
|
connectOpts.password = password;
|
|
}
|
|
|
|
// Keep the discovered keys available to unrelated jump hosts even when
|
|
// strict agent selection disables them for the final target.
|
|
const discoveredDefaultKeys = await findAllDefaultPrivateKeysFromHelper();
|
|
defaultKeys = systemAuthAgent && identitiesOnly
|
|
? []
|
|
: discoveredDefaultKeys;
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
|
|
// Build auth handler using shared helper
|
|
const authConfig = buildAuthHandler({
|
|
privateKey: connectOpts.privateKey,
|
|
password,
|
|
passphrase: connectOpts.passphrase,
|
|
agent: connectOpts.agent,
|
|
username: connectOpts.username,
|
|
logPrefix: "[PortForward]",
|
|
defaultKeys,
|
|
allowAgentFallback: useSshAgent !== false,
|
|
});
|
|
applyAuthToConnOpts(connectOpts, authConfig);
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
|
|
if (hasJumpHosts) {
|
|
const chainResult = await connectThroughChain(
|
|
event,
|
|
{
|
|
hostname,
|
|
port,
|
|
username,
|
|
password,
|
|
privateKey,
|
|
passphrase,
|
|
useSshAgent,
|
|
identityAgent,
|
|
identityFilePaths,
|
|
identitiesOnly,
|
|
addKeysToAgent,
|
|
useKeychain,
|
|
proxy,
|
|
knownHosts,
|
|
verifyHostKeys,
|
|
jumpHosts,
|
|
legacyAlgorithms,
|
|
skipEcdsaHostKey,
|
|
algorithmOverrides,
|
|
sshTcpConnectTimeoutMs: connectionTimeouts.tcpConnectTimeoutMs,
|
|
sshAuthReadyTimeoutMs: connectionTimeouts.authReadyTimeoutMs,
|
|
_defaultKeys: discoveredDefaultKeys,
|
|
_connectionsRef: chainConnections,
|
|
_tunnelRef: tunnelState,
|
|
_passphraseSignal: passphraseAbortController.signal,
|
|
_keyboardInteractiveScope: "external",
|
|
},
|
|
jumpHosts,
|
|
hostname,
|
|
port,
|
|
tunnelId,
|
|
);
|
|
connectionSocket = chainResult.socket;
|
|
chainConnections = chainResult.connections;
|
|
tunnelState.chainConnections = chainConnections;
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
cleanupChainConnections(chainConnections);
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
connectOpts.sock = connectionSocket;
|
|
delete connectOpts.host;
|
|
delete connectOpts.port;
|
|
} else if (hasProxy) {
|
|
connectionSocket = await createProxySocket(proxy, hostname, port, {
|
|
timeoutMs: connectionTimeouts.tcpConnectTimeoutMs,
|
|
onSocket: (socket) => {
|
|
tunnelState.pendingConn = socket;
|
|
},
|
|
});
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
try { connectionSocket?.end?.(); } catch { /* ignore */ }
|
|
try { connectionSocket?.destroy?.(); } catch { /* ignore */ }
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
tunnelState.pendingConn = null;
|
|
connectOpts.sock = connectionSocket;
|
|
delete connectOpts.host;
|
|
delete connectOpts.port;
|
|
}
|
|
} catch (err) {
|
|
if (isTunnelCancelled(tunnelState)) {
|
|
portForwardingTunnels.delete(tunnelId);
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
if (isPassphraseCancelledError(err)) {
|
|
cancelTunnel(tunnelId, tunnelState, sendStatus, { deleteEntry: true });
|
|
return { tunnelId, success: false, cancelled: true };
|
|
}
|
|
tunnelState.cancelled = true;
|
|
if (tunnelState.pendingConn) {
|
|
try { tunnelState.pendingConn.end(); } catch { /* ignore */ }
|
|
}
|
|
cleanupChainConnections(tunnelState.chainConnections);
|
|
if (connectionSocket) {
|
|
try { connectionSocket.end?.(); } catch { /* ignore */ }
|
|
try { connectionSocket.destroy?.(); } catch { /* ignore */ }
|
|
}
|
|
portForwardingTunnels.delete(tunnelId);
|
|
sendStatus('error', err?.message || String(err));
|
|
throw err;
|
|
}
|
|
|
|
// Handle keyboard-interactive authentication (2FA/MFA)
|
|
conn.on("keyboard-interactive", createKeyboardInteractiveHandler({
|
|
sender,
|
|
sessionId: tunnelId,
|
|
hostname,
|
|
password,
|
|
logPrefix: "[PortForward]",
|
|
scope: "external",
|
|
}));
|
|
|
|
return new Promise((resolve, reject) => {
|
|
// Track whether the Promise has been settled so conn.on('close')
|
|
// can reject if the tunnel was killed during SSH handshake.
|
|
let settled = false;
|
|
let authReadyTimer = null;
|
|
const clearAuthReadyTimer = () => {
|
|
if (!authReadyTimer) return;
|
|
clearTimeout(authReadyTimer);
|
|
authReadyTimer = null;
|
|
};
|
|
|
|
conn.once('connect', () => {
|
|
runWhenProxyConnectionReady(conn._sock, () => {
|
|
try { conn._sock?.setTimeout?.(0); } catch { /* ignore */ }
|
|
clearAuthReadyTimer();
|
|
authReadyTimer = setTimeout(
|
|
() => conn.emit('timeout'),
|
|
connectionTimeouts.authReadyTimeoutMs,
|
|
);
|
|
authReadyTimer.unref?.();
|
|
});
|
|
});
|
|
|
|
conn.once('ready', () => {
|
|
clearAuthReadyTimer();
|
|
console.log(`[PortForward] SSH connection ready for tunnel ${tunnelId}`);
|
|
|
|
if (type === 'local') {
|
|
// LOCAL FORWARDING: Listen on local port, forward to remote
|
|
const server = net.createServer((socket) => {
|
|
conn.forwardOut(
|
|
bindAddress,
|
|
localPort,
|
|
remoteHost,
|
|
remotePort,
|
|
(err, stream) => {
|
|
if (err) {
|
|
console.error(`[PortForward] Forward error:`, err.message);
|
|
socket.end();
|
|
return;
|
|
}
|
|
socket.pipe(stream).pipe(socket);
|
|
|
|
socket.on('error', (e) => console.warn('[PortForward] Socket error:', e.message));
|
|
stream.on('error', (e) => console.warn('[PortForward] Stream error:', e.message));
|
|
}
|
|
);
|
|
});
|
|
|
|
server.on('error', (err) => {
|
|
console.error(`[PortForward] Server error:`, err.message);
|
|
sendStatus('error', err.message);
|
|
conn.end();
|
|
settled = true;
|
|
reject(err);
|
|
});
|
|
|
|
server.listen(localPort, bindAddress, () => {
|
|
console.log(`[PortForward] Local forwarding active: ${bindAddress}:${localPort} -> ${remoteHost}:${remotePort}`);
|
|
tunnelState.type = 'local';
|
|
tunnelState.conn = conn;
|
|
tunnelState.server = server;
|
|
tunnelState.chainConnections = chainConnections;
|
|
tunnelState.status = 'active';
|
|
tunnelState.webContentsId = sender.id;
|
|
tunnelState.pendingConn = null;
|
|
portForwardingTunnels.set(tunnelId, tunnelState);
|
|
sendStatus('active');
|
|
settled = true;
|
|
resolve({ tunnelId, success: true });
|
|
});
|
|
|
|
} else if (type === 'remote') {
|
|
// REMOTE FORWARDING: Listen on remote port, forward to local
|
|
conn.forwardIn(bindAddress, localPort, (err) => {
|
|
if (err) {
|
|
console.error(`[PortForward] Remote forward error:`, err.message);
|
|
sendStatus('error', err.message);
|
|
conn.end();
|
|
settled = true;
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
console.log(`[PortForward] Remote forwarding active: remote ${bindAddress}:${localPort} -> local ${remoteHost}:${remotePort}`);
|
|
tunnelState.type = 'remote';
|
|
tunnelState.conn = conn;
|
|
tunnelState.server = null;
|
|
tunnelState.chainConnections = chainConnections;
|
|
tunnelState.status = 'active';
|
|
tunnelState.webContentsId = sender.id;
|
|
tunnelState.pendingConn = null;
|
|
portForwardingTunnels.set(tunnelId, tunnelState);
|
|
sendStatus('active');
|
|
settled = true;
|
|
resolve({ tunnelId, success: true });
|
|
});
|
|
|
|
// Handle incoming connections from remote
|
|
conn.on('tcp connection', (info, accept, rejectConn) => {
|
|
const stream = accept();
|
|
const socket = net.connect(remotePort, remoteHost || '127.0.0.1', () => {
|
|
stream.pipe(socket).pipe(stream);
|
|
});
|
|
|
|
socket.on('error', (e) => {
|
|
console.warn('[PortForward] Local socket error:', e.message);
|
|
stream.end();
|
|
});
|
|
stream.on('error', (e) => {
|
|
console.warn('[PortForward] Remote stream error:', e.message);
|
|
socket.end();
|
|
});
|
|
});
|
|
|
|
} else if (type === 'dynamic') {
|
|
// DYNAMIC FORWARDING (SOCKS5 Proxy)
|
|
const server = net.createServer((socket) => {
|
|
// Simple SOCKS5 handshake
|
|
socket.once('data', (data) => {
|
|
if (data[0] !== 0x05) {
|
|
socket.end();
|
|
return;
|
|
}
|
|
|
|
// Reply: version, no auth required
|
|
socket.write(Buffer.from([0x05, 0x00]));
|
|
|
|
// Wait for connection request
|
|
socket.once('data', (request) => {
|
|
if (request[0] !== 0x05 || request[1] !== 0x01) {
|
|
socket.write(Buffer.from([0x05, 0x07, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
|
|
socket.end();
|
|
return;
|
|
}
|
|
|
|
let targetHost, targetPort;
|
|
const addressType = request[3];
|
|
|
|
if (addressType === 0x01) {
|
|
// IPv4
|
|
targetHost = `${request[4]}.${request[5]}.${request[6]}.${request[7]}`;
|
|
targetPort = request.readUInt16BE(8);
|
|
} else if (addressType === 0x03) {
|
|
// Domain name
|
|
const domainLength = request[4];
|
|
targetHost = request.slice(5, 5 + domainLength).toString();
|
|
targetPort = request.readUInt16BE(5 + domainLength);
|
|
} else if (addressType === 0x04) {
|
|
// IPv6 - simplified handling
|
|
socket.write(Buffer.from([0x05, 0x08, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
|
|
socket.end();
|
|
return;
|
|
} else {
|
|
socket.write(Buffer.from([0x05, 0x08, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
|
|
socket.end();
|
|
return;
|
|
}
|
|
|
|
// Forward through SSH tunnel
|
|
conn.forwardOut(
|
|
bindAddress,
|
|
0,
|
|
targetHost,
|
|
targetPort,
|
|
(err, stream) => {
|
|
if (err) {
|
|
socket.write(Buffer.from([0x05, 0x05, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
|
|
socket.end();
|
|
return;
|
|
}
|
|
|
|
// Success reply
|
|
const reply = Buffer.alloc(10);
|
|
reply[0] = 0x05;
|
|
reply[1] = 0x00;
|
|
reply[2] = 0x00;
|
|
reply[3] = 0x01;
|
|
reply.writeUInt16BE(0, 8);
|
|
socket.write(reply);
|
|
|
|
socket.pipe(stream).pipe(socket);
|
|
|
|
socket.on('error', () => stream.end());
|
|
stream.on('error', () => socket.end());
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
server.on('error', (err) => {
|
|
console.error(`[PortForward] SOCKS server error:`, err.message);
|
|
sendStatus('error', err.message);
|
|
conn.end();
|
|
settled = true;
|
|
reject(err);
|
|
});
|
|
|
|
server.listen(localPort, bindAddress, () => {
|
|
console.log(`[PortForward] Dynamic SOCKS5 proxy active on ${bindAddress}:${localPort}`);
|
|
tunnelState.type = 'dynamic';
|
|
tunnelState.conn = conn;
|
|
tunnelState.server = server;
|
|
tunnelState.chainConnections = chainConnections;
|
|
tunnelState.status = 'active';
|
|
tunnelState.webContentsId = sender.id;
|
|
tunnelState.pendingConn = null;
|
|
portForwardingTunnels.set(tunnelId, tunnelState);
|
|
sendStatus('active');
|
|
settled = true;
|
|
resolve({ tunnelId, success: true });
|
|
});
|
|
} else {
|
|
settled = true;
|
|
reject(new Error(`Unknown forwarding type: ${type}`));
|
|
}
|
|
});
|
|
|
|
conn.on('error', (err) => {
|
|
clearAuthReadyTimer();
|
|
console.error(`[PortForward] SSH error:`, err.message);
|
|
if (settled) return;
|
|
sendStatus('error', err.message);
|
|
cleanupChainConnections(chainConnections);
|
|
settled = true;
|
|
reject(err);
|
|
});
|
|
|
|
conn.once('close', () => {
|
|
clearAuthReadyTimer();
|
|
console.log(`[PortForward] SSH connection closed for tunnel ${tunnelId}`);
|
|
const tunnel = portForwardingTunnels.get(tunnelId) || tunnelState;
|
|
// Capture the cancelled flag BEFORE cleanup deletes the entry.
|
|
const wasCancelled = !!tunnel?.cancelled;
|
|
if (tunnel) {
|
|
if (tunnel.server) {
|
|
try { tunnel.server.close(); } catch { }
|
|
}
|
|
if (Array.isArray(tunnel.chainConnections)) {
|
|
cleanupChainConnections(tunnel.chainConnections);
|
|
}
|
|
if (tunnel.pendingConn) {
|
|
try { tunnel.pendingConn.end(); } catch { /* ignore */ }
|
|
}
|
|
sendStatus('inactive');
|
|
portForwardingTunnels.delete(tunnelId);
|
|
}
|
|
// If the Promise was never settled (tunnel killed during
|
|
// handshake by stopPortForwardByRuleId), settle it.
|
|
if (!settled) {
|
|
settled = true;
|
|
if (wasCancelled) {
|
|
resolve({ tunnelId, success: false, cancelled: true });
|
|
} else {
|
|
reject(new Error(`Tunnel ${tunnelId} closed before connection established`));
|
|
}
|
|
}
|
|
});
|
|
|
|
conn.once('timeout', () => {
|
|
clearAuthReadyTimer();
|
|
if (settled) return;
|
|
const err = new Error(`Connection timeout to ${hostname}`);
|
|
sendStatus('error', err.message);
|
|
cleanupChainConnections(chainConnections);
|
|
settled = true;
|
|
reject(err);
|
|
conn.end();
|
|
});
|
|
|
|
conn.connect(connectOpts);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Stop a port forwarding tunnel
|
|
*/
|
|
async function stopPortForward(event, payload) {
|
|
const { tunnelId } = payload;
|
|
const tunnel = portForwardingTunnels.get(tunnelId);
|
|
|
|
if (!tunnel) {
|
|
return { tunnelId, success: false, error: 'Tunnel not found' };
|
|
}
|
|
|
|
try {
|
|
cancelTunnel(tunnelId, tunnel, null, { deleteEntry: true });
|
|
if (!event.sender.isDestroyed()) {
|
|
event.sender.send("netcatty:portforward:status", { tunnelId, status: 'inactive', error: null });
|
|
}
|
|
return { tunnelId, success: true };
|
|
} catch (err) {
|
|
return { tunnelId, success: false, error: err.message };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get status of a tunnel
|
|
*/
|
|
async function getPortForwardStatus(event, payload) {
|
|
const { tunnelId } = payload;
|
|
const tunnel = portForwardingTunnels.get(tunnelId);
|
|
|
|
if (!tunnel) {
|
|
return { tunnelId, status: 'inactive' };
|
|
}
|
|
|
|
return { tunnelId, status: tunnel.status || 'active', type: tunnel.type };
|
|
}
|
|
|
|
/**
|
|
* List all active port forwards
|
|
*/
|
|
async function listPortForwards() {
|
|
const list = [];
|
|
for (const [tunnelId, tunnel] of portForwardingTunnels) {
|
|
list.push({
|
|
tunnelId,
|
|
type: tunnel.type,
|
|
status: tunnel.status || 'active',
|
|
});
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Stop all active port forwards (cleanup on app quit)
|
|
*/
|
|
function stopAllPortForwards() {
|
|
console.log(`[PortForward] Stopping all ${portForwardingTunnels.size} active tunnels...`);
|
|
for (const [tunnelId, tunnel] of portForwardingTunnels) {
|
|
try {
|
|
cancelTunnel(tunnelId, tunnel, null, { deleteEntry: true });
|
|
console.log(`[PortForward] Stopped tunnel ${tunnelId}`);
|
|
} catch (err) {
|
|
console.warn(`[PortForward] Failed to stop tunnel ${tunnelId}:`, err.message);
|
|
}
|
|
}
|
|
console.log('[PortForward] All tunnels stopped');
|
|
}
|
|
|
|
/**
|
|
* Stop all active port forwards for a given rule ID.
|
|
* This catches tunnels in ANY state (connecting, active) because it
|
|
* operates on the main-process portForwardingTunnels map directly.
|
|
*/
|
|
function stopPortForwardByRuleId(_event, { ruleId }) {
|
|
let stopped = 0;
|
|
for (const [tunnelId, tunnel] of portForwardingTunnels) {
|
|
if (tunnel.ruleId === ruleId) {
|
|
try {
|
|
cancelTunnel(tunnelId, tunnel, null, { deleteEntry: true });
|
|
console.log(`[PortForward] Stopped tunnel ${tunnelId} for rule ${ruleId}`);
|
|
stopped++;
|
|
} catch (err) {
|
|
console.warn(`[PortForward] Failed to stop tunnel ${tunnelId}:`, err.message);
|
|
}
|
|
}
|
|
}
|
|
return { stopped };
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for port forwarding operations
|
|
*/
|
|
function registerHandlers(ipcMain) {
|
|
ipcMain.handle("netcatty:portforward:start", startPortForward);
|
|
ipcMain.handle("netcatty:portforward:stop", stopPortForward);
|
|
ipcMain.handle("netcatty:portforward:status", getPortForwardStatus);
|
|
ipcMain.handle("netcatty:portforward:list", listPortForwards);
|
|
ipcMain.handle("netcatty:portforward:stopAll", () => stopAllPortForwards());
|
|
ipcMain.handle("netcatty:portforward:stopByRuleId", stopPortForwardByRuleId);
|
|
}
|
|
|
|
module.exports = {
|
|
registerHandlers,
|
|
startPortForward,
|
|
stopPortForward,
|
|
getPortForwardStatus,
|
|
listPortForwards,
|
|
stopAllPortForwards,
|
|
stopPortForwardByRuleId,
|
|
};
|