/** * SSH Bridge - Handles SSH connections, sessions, and related operations * Extracted from main.cjs for single responsibility */ const net = require("node:net"); const fs = require("node:fs"); const path = require("node:path"); const { randomUUID } = require("node:crypto"); const os = require("node:os"); const crypto = require("node:crypto"); const { exec } = require("node:child_process"); const { Client: SSHClient, utils: sshUtils } = require("ssh2"); const { NetcattyAgent } = require("./netcattyAgent.cjs"); const keyboardInteractiveHandler = require("./keyboardInteractiveHandler.cjs"); const passphraseHandler = require("./passphraseHandler.cjs"); const { createProxySocket } = require("./proxyUtils.cjs"); const { attachX11Forwarding } = require("./x11Forwarding.cjs"); const { buildAuthHandler, createKeyboardInteractiveHandler, applyAuthToConnOpts, safeSend: authSafeSend, requestPassphrasesForEncryptedKeys, findAllDefaultPrivateKeys: findAllDefaultPrivateKeysFromHelper, getSshAgentSocket, readFileNoFollow, } = require("./sshAuthHelper.cjs"); const sessionLogStreamManager = require("./sessionLogStreamManager.cjs"); const { trackSessionIdlePrompt } = require("./ai/shellUtils.cjs"); const { createZmodemSentry } = require("./zmodemHelper.cjs"); // Default SSH key names in priority order (preferred keys tried first) const PREFERRED_KEY_NAMES = ["id_ed25519", "id_ecdsa", "id_rsa"]; // Match any private key file: id_* but not *.pub const SSH_KEY_PATTERN = /^id_[\w-]+$/; function quoteShellArg(value) { return "'" + String(value).replace(/'/g, "'\\''") + "'"; } /** * Quick check if file content looks like an SSH private key. * Rejects non-key files that happen to match the id_* filename pattern. */ function looksLikePrivateKey(content) { if (!content || typeof content !== "string") return false; const trimmed = content.trimStart(); return trimmed.startsWith("-----BEGIN") || trimmed.startsWith("openssh-key-v1") || trimmed.startsWith("PuTTY-User-Key-File"); } /** * Check if an SSH private key is encrypted (requires passphrase) * @param {string} keyContent - The content of the private key file * @returns {boolean} - True if the key is encrypted */ function isKeyEncrypted(keyContent) { // Check for PuTTY PPK encrypted format const ppkEncMatch = keyContent.match(/^Encryption:\s*(.+)$/m); if (ppkEncMatch && ppkEncMatch[1].trim() !== "none") { return true; } // Check for PKCS#8 encrypted format (-----BEGIN ENCRYPTED PRIVATE KEY-----) if (keyContent.includes("-----BEGIN ENCRYPTED PRIVATE KEY-----")) { return true; } // Check for legacy PEM format encryption (e.g., RSA PRIVATE KEY with encryption) if (keyContent.includes("Proc-Type:") && keyContent.includes("ENCRYPTED")) { return true; } // Check for OpenSSH format keys if (keyContent.includes("-----BEGIN OPENSSH PRIVATE KEY-----")) { try { // Extract the base64 content between the markers const base64Match = keyContent.match( /-----BEGIN OPENSSH PRIVATE KEY-----\s*([\s\S]*?)\s*-----END OPENSSH PRIVATE KEY-----/ ); if (base64Match) { const base64Content = base64Match[1].replace(/\s/g, ""); const keyBuffer = Buffer.from(base64Content, "base64"); // OpenSSH key format: "openssh-key-v1\0" followed by cipher name // If ciphername is "none", the key is not encrypted const authMagic = "openssh-key-v1\0"; if (keyBuffer.toString("ascii", 0, authMagic.length) === authMagic) { // After magic, read ciphername (length-prefixed string) let offset = authMagic.length; const cipherNameLen = keyBuffer.readUInt32BE(offset); offset += 4; const cipherName = keyBuffer.toString("ascii", offset, offset + cipherNameLen); return cipherName !== "none"; } } } catch { // If parsing fails, assume it might be encrypted to be safe return true; } } return false; } /** * Find default SSH private key from user's ~/.ssh directory * Skips encrypted keys that require a passphrase to allow password/keyboard-interactive auth * @returns {Promise<{ privateKey: string, keyPath: string, keyName: string } | null>} */ async function findDefaultPrivateKey() { const sshDir = path.join(os.homedir(), ".ssh"); // Scan ~/.ssh/ for all files matching id_* (same as Tabby/OpenSSH), // with preferred key types tried first let allNames = []; try { const entries = await fs.promises.readdir(sshDir); allNames = entries.filter(f => SSH_KEY_PATTERN.test(f)); } catch { return null; } // Sort: preferred keys first (in order), then rest alphabetically const preferred = PREFERRED_KEY_NAMES.filter(n => allNames.includes(n)); const rest = allNames.filter(n => !PREFERRED_KEY_NAMES.includes(n)).sort(); const sorted = [...preferred, ...rest]; log("Searching for default SSH keys", { sshDir, found: sorted }); for (const name of sorted) { const keyPath = path.join(sshDir, name); try { const privateKey = await readFileNoFollow(keyPath); if (!privateKey) continue; if (!looksLikePrivateKey(privateKey)) { log("Skipping non-key file", { keyPath, keyName: name }); continue; } const encrypted = isKeyEncrypted(privateKey); log("Key file read", { keyPath, keyName: name, encrypted, keyLength: privateKey.length }); if (encrypted) { log("Skipping encrypted default key", { keyPath, keyName: name }); continue; } log("Found default key", { keyPath, keyName: name }); return { privateKey, keyPath, keyName: name }; } catch (e) { log("Failed to read default key", { keyPath, error: e.message }); continue; } } log("No suitable default SSH key found"); return null; } /** * Find ALL default SSH private keys from user's ~/.ssh directory * Returns all non-encrypted keys for fallback authentication * @returns {Promise>} */ async function findAllDefaultPrivateKeys() { const sshDir = path.join(os.homedir(), ".ssh"); let allNames = []; try { const entries = await fs.promises.readdir(sshDir); allNames = entries.filter(f => SSH_KEY_PATTERN.test(f)); } catch { return []; } const preferred = PREFERRED_KEY_NAMES.filter(n => allNames.includes(n)); const rest = allNames.filter(n => !PREFERRED_KEY_NAMES.includes(n)).sort(); const sorted = [...preferred, ...rest]; log("Searching for ALL default SSH keys", { sshDir, found: sorted }); const promises = sorted.map(async (name) => { const keyPath = path.join(sshDir, name); try { const privateKey = await readFileNoFollow(keyPath); if (!privateKey) return null; if (!looksLikePrivateKey(privateKey)) { log("Skipping non-key file", { keyPath, keyName: name }); return null; } const encrypted = isKeyEncrypted(privateKey); if (!encrypted) { log("Found default key for fallback", { keyPath, keyName: name }); return { privateKey, keyPath, keyName: name }; } else { log("Skipping encrypted key", { keyPath, keyName: name }); return null; } } catch (e) { log("Failed to read key", { keyPath, error: e.message }); return null; } }); const results = await Promise.all(promises); const keys = results.filter(Boolean); log("Found default SSH keys", { count: keys.length, keyNames: keys.map(k => k.keyName) }); return keys; } const WIN_SSH_AGENT_PIPE = "\\\\.\\pipe\\openssh-ssh-agent"; /** * Check if an SSH agent is available on Windows by connecting to the * well-known named pipe. fs.statSync is unreliable for named pipes (returns * EBUSY even when usable), so we use net.connect() as the authoritative check. * @returns {Promise<{ running: boolean, startupType: string | null, error: string | null }>} */ function checkWindowsSshAgent() { if (process.platform !== "win32") { return Promise.resolve({ running: true, startupType: null, error: null }); } const net = require("net"); return new Promise((resolve) => { const socket = net.connect(WIN_SSH_AGENT_PIPE); let settled = false; const finish = (ok, error) => { if (settled) return; settled = true; try { socket.destroy(); } catch {} resolve({ running: ok, startupType: ok ? "running" : "stopped", error: ok ? null : (error || "SSH Agent pipe not connectable"), }); }; socket.setTimeout(1000); socket.once("connect", () => finish(true, null)); socket.once("timeout", () => finish(false, "SSH Agent pipe connect timeout")); socket.once("error", (err) => finish(false, err.message)); }); } async function getAvailableAgentSocket() { if (process.platform === "win32") { const agentStatus = await checkWindowsSshAgent(); log("Windows SSH Agent check", agentStatus); return agentStatus.running ? WIN_SSH_AGENT_PIPE : null; } return getSshAgentSocket(); } const DEBUG_SSH = process.env.NETCATTY_SSH_DEBUG === "1"; // Debug logger (disabled by default) const logFile = DEBUG_SSH ? path.join(require("os").tmpdir(), "netcatty-ssh.log") : null; const log = (msg, data) => { if (!DEBUG_SSH) return; const line = `[${new Date().toISOString()}] ${msg} ${data ? JSON.stringify(data) : ""}\n`; try { fs.appendFileSync(logFile, line); } catch { } console.log("[SSH]", msg, data ? JSON.stringify(data, null, 2) : ""); }; // FIPS-enabled OpenSSL builds disable MD5. Feature-detect once so the legacy // algorithm list can skip hmac-md5 on those builds — ssh2 validates exact // algorithm lists strictly and would otherwise throw "Unsupported algorithm" // before the SSH handshake even starts. let _md5Supported = null; function md5Supported() { if (_md5Supported === null) { try { _md5Supported = crypto.getHashes().includes("md5"); } catch { _md5Supported = false; } } return _md5Supported; } /** * Build SSH algorithm configuration. * When legacyEnabled is true, legacy algorithms are appended to each list * (lower priority than modern ones) for compatibility with older network equipment. */ function buildAlgorithms(legacyEnabled) { const algorithms = { cipher: [ 'aes128-gcm@openssh.com', 'aes256-gcm@openssh.com', 'aes128-ctr', 'aes192-ctr', 'aes256-ctr', ], kex: [ 'curve25519-sha256', 'curve25519-sha256@libssh.org', 'ecdh-sha2-nistp256', 'ecdh-sha2-nistp384', 'ecdh-sha2-nistp521', 'diffie-hellman-group14-sha256', 'diffie-hellman-group16-sha512', 'diffie-hellman-group18-sha512', 'diffie-hellman-group-exchange-sha256', ], compress: ['none'], }; if (legacyEnabled) { algorithms.kex.push( 'diffie-hellman-group14-sha1', 'diffie-hellman-group1-sha1', ); algorithms.cipher.push( 'aes128-cbc', 'aes256-cbc', '3des-cbc', ); algorithms.serverHostKey = [ 'ssh-ed25519', 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521', 'rsa-sha2-512', 'rsa-sha2-256', 'ssh-rsa', 'ssh-dss', ]; // Legacy HMACs — required by very old servers (e.g. FreeBSD 6.1 OpenSSH // ~2006, issue #807). Without hmac-sha1/md5 in the offered list, the // handshake exchange-hash MAC never agrees and the host-key signature // verification that depends on it fails with // "Handshake failed: signature verification failed" — which looks like // a host-key problem but is really a MAC negotiation mismatch. // // hmac-md5 is only appended when the local OpenSSL build actually // supports MD5. FIPS-enabled Node builds disable MD5 entirely, and // ssh2 strictly validates exact algorithm lists — listing an unavailable // algorithm would throw "Unsupported algorithm" before any SSH // negotiation, turning the legacy toggle into a hard failure for FIPS // users. hmac-sha1 is allowed for HMAC even under FIPS 140-2 so it // stays unconditionally. // hmac-sha1-etm@openssh.com is in ssh2's default MAC set — keep it so // hosts that only accept EtM SHA-1 MACs don't regress to "no matching // C->S MAC" when legacy mode replaces the default list. algorithms.hmac = [ 'hmac-sha2-256-etm@openssh.com', 'hmac-sha2-512-etm@openssh.com', 'hmac-sha2-256', 'hmac-sha2-512', 'hmac-sha1-etm@openssh.com', 'hmac-sha1', ]; if (md5Supported()) { algorithms.hmac.push('hmac-md5'); } } return algorithms; } // Session storage - shared reference passed from main let sessions = null; let electronModule = null; // Authentication method cache - remembers successful auth methods per host // Key format: "username@hostname:port" // Value: { method: "password" | "publickey" | "publickey-default" } // Cache persists until auth failure, then cleared to retry all methods const authMethodCache = new Map(); // Per-session terminal encoding (default: utf-8) const sessionEncodings = new Map(); // Per-session stateful iconv decoders (keyed by sessionId, value: { stdout, stderr }) const sessionDecoders = new Map(); const iconv = require("iconv-lite"); function getSessionDecoder(sessionId, stream) { let decoders = sessionDecoders.get(sessionId); if (!decoders) { decoders = { stdout: null, stderr: null }; sessionDecoders.set(sessionId, decoders); } if (!decoders[stream]) { const enc = sessionEncodings.get(sessionId) || "utf-8"; decoders[stream] = iconv.getDecoder(enc); } return decoders[stream]; } function resetSessionDecoders(sessionId) { const enc = sessionEncodings.get(sessionId) || "utf-8"; const decoders = { stdout: iconv.getDecoder(enc), stderr: iconv.getDecoder(enc) }; sessionDecoders.set(sessionId, decoders); } function getAuthCacheKey(username, hostname, port) { return `${username}@${hostname}:${port || 22}`; } function getCachedAuthMethod(username, hostname, port) { const key = getAuthCacheKey(username, hostname, port); const cached = authMethodCache.get(key); if (cached) { log("Using cached auth method", { key, method: cached.method }); return cached.method; } return null; } function setCachedAuthMethod(username, hostname, port, method) { const key = getAuthCacheKey(username, hostname, port); log("Caching successful auth method", { key, method }); authMethodCache.set(key, { method }); } function clearCachedAuthMethod(username, hostname, port) { const key = getAuthCacheKey(username, hostname, port); log("Clearing cached auth method", { key }); authMethodCache.delete(key); } // Normalize charset inputs (often provided as bare encodings like "UTF-8") // into a usable LANG locale for remote shells. function resolveLangFromCharset(charset) { if (!charset) return "en_US.UTF-8"; const trimmed = String(charset).trim(); if (/^utf-?8$/i.test(trimmed) || /^utf8$/i.test(trimmed)) { return "en_US.UTF-8"; } return trimmed; } const { safeSend } = require("./ipcUtils.cjs"); /** * Initialize the SSH bridge with dependencies */ function init(deps) { sessions = deps.sessions; electronModule = deps.electronModule; } /** * Connect through a chain of jump hosts */ async function connectThroughChain(event, options, jumpHosts, targetHost, targetPort, sessionId) { const sender = event.sender; const connections = options?._connectionsRef || []; let currentSocket = null; const sendProgress = (hop, total, label, status, error) => { if (!sender.isDestroyed()) { sender.send("netcatty:chain:progress", { sessionId, hop, total, label, status, error }); } }; try { const totalHops = jumpHosts.length; // Connect through each jump host for (let i = 0; i < jumpHosts.length; i++) { const jump = jumpHosts[i]; const isFirst = i === 0; const isLast = i === jumpHosts.length - 1; const hopLabel = jump.label || (jump.hostname.includes(':') && !jump.hostname.startsWith('[') ? `[${jump.hostname}]:${jump.port || 22}` : `${jump.hostname}:${jump.port || 22}`); sendProgress(i + 1, totalHops + 1, hopLabel, 'connecting'); const conn = new SSHClient(); if (options?._tunnelRef) { options._tunnelRef.pendingConn = conn; options._tunnelRef.chainConnections = connections; } // Build connection options const connOpts = { host: jump.hostname, port: jump.port || 22, username: jump.username || 'root', readyTimeout: 120000, // 2 minutes to allow for keyboard-interactive (2FA/MFA) // Use user-configured keepalive interval from options (in seconds -> convert to ms) // 0 = disabled (no keepalive packets sent) keepaliveInterval: options.keepaliveInterval > 0 ? options.keepaliveInterval * 1000 : 0, keepaliveCountMax: options.keepaliveInterval > 0 ? 3 : 0, // Enable keyboard-interactive authentication (required for 2FA/MFA) tryKeyboard: true, algorithms: buildAlgorithms(options.legacyAlgorithms), }; // Auth - support agent (certificate), key, password, and default key fallback const hasCertificate = typeof jump.certificate === "string" && jump.certificate.trim().length > 0; let authAgent = null; if (hasCertificate) { authAgent = new NetcattyAgent({ mode: "certificate", webContents: event.sender, meta: { label: jump.keyId || jump.username || "", certificate: jump.certificate, privateKey: jump.privateKey, passphrase: jump.passphrase, }, }); connOpts.agent = authAgent; } else if (jump.privateKey) { connOpts.privateKey = jump.privateKey; if (jump.passphrase) { connOpts.passphrase = jump.passphrase; } else if (isKeyEncrypted(jump.privateKey)) { // Key is encrypted but no passphrase provided — prompt the user console.log(`[Chain] Hop ${i + 1}: key is encrypted, requesting passphrase`); sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'passphrase required'); const keyLabel = jump.label || hopLabel; const result = await passphraseHandler.requestPassphrase( sender, `SSH key for ${keyLabel}`, keyLabel, hopLabel ); if (result?.passphrase) { connOpts.passphrase = result.passphrase; } else { // No passphrase (cancelled/skipped/timeout) — remove the encrypted // key so buildAuthHandler won't try it and stall auth. delete connOpts.privateKey; if (result?.cancelled) { throw new Error(`Passphrase entry cancelled for ${hopLabel}`); } } } } // Read identity files from local paths (e.g. from SSH config IdentityFile) if (!connOpts.privateKey && !connOpts.agent && jump.identityFilePaths?.length > 0) { for (const keyPath of jump.identityFilePaths) { try { const resolvedPath = keyPath.startsWith("~/") ? path.join(os.homedir(), keyPath.slice(2)) : keyPath; const keyContent = await fs.promises.readFile(resolvedPath, "utf8"); connOpts.privateKey = keyContent; if (isKeyEncrypted(keyContent)) { console.log(`[Chain] Hop ${i + 1}: identity file ${resolvedPath} is encrypted, requesting passphrase`); sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'passphrase required'); const result = await passphraseHandler.requestPassphrase( sender, resolvedPath, path.basename(resolvedPath), hopLabel ); if (result?.passphrase) { connOpts.passphrase = result.passphrase; } else { // Cancelled/skipped/timeout — clear encrypted key, try next file delete connOpts.privateKey; continue; } } console.log(`[Chain] Hop ${i + 1}: loaded identity file ${resolvedPath}`); break; } catch (err) { console.warn(`[Chain] Hop ${i + 1}: failed to read identity file ${keyPath}:`, err.message); } } } if (jump.password) connOpts.password = jump.password; // Get default keys (either from options if pre-fetched, or fetch them now) const defaultKeys = options._defaultKeys || await findAllDefaultPrivateKeys(); // Build auth handler using shared helper // Pass unlocked encrypted keys from options so jump hosts can use them for retry const authConfig = buildAuthHandler({ privateKey: connOpts.privateKey, password: connOpts.password, passphrase: connOpts.passphrase, agent: connOpts.agent, username: connOpts.username, logPrefix: `[Chain] Hop ${i + 1}`, unlockedEncryptedKeys: options._unlockedEncryptedKeys || [], defaultKeys, onAuthAttempt: (method) => { sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', method); }, }); applyAuthToConnOpts(connOpts, authConfig); // If first hop and proxy is configured, connect through proxy const hasUsableJumpProxy = !!(jump.proxy?.host && jump.proxy?.port); const effectiveHopProxy = isFirst ? ((hasUsableJumpProxy ? jump.proxy : null) || options.proxy) : null; if (effectiveHopProxy) { currentSocket = await createProxySocket(effectiveHopProxy, jump.hostname, jump.port || 22, { onSocket: (socket) => { if (options?._tunnelRef) { options._tunnelRef.pendingConn = socket; options._tunnelRef.chainConnections = connections; } }, }); if (options?._tunnelRef) { options._tunnelRef.pendingConn = null; options._tunnelRef.chainConnections = connections; } connOpts.sock = currentSocket; delete connOpts.host; delete connOpts.port; } else if (!isFirst && currentSocket) { // Tunnel through previous hop connOpts.sock = currentSocket; delete connOpts.host; delete connOpts.port; } // Connect this hop await new Promise((resolve, reject) => { conn.once('handshake', () => { console.log(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} handshake complete`); sendProgress(i + 1, totalHops + 1, hopLabel, 'authenticating'); }); conn.once('ready', () => { console.log(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} connected`); sendProgress(i + 1, totalHops + 1, hopLabel, 'connected'); if (options?._tunnelRef) { options._tunnelRef.pendingConn = null; options._tunnelRef.chainConnections = connections; } resolve(); }); conn.once('error', (err) => { console.error(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} error:`, err.message); sendProgress(i + 1, totalHops + 1, hopLabel, 'error', err.message); reject(err); }); conn.once('timeout', () => { console.error(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} timeout`); const errMsg = `Connection timeout to ${hopLabel}`; sendProgress(i + 1, totalHops + 1, hopLabel, 'error', errMsg); reject(new Error(errMsg)); }); // Handle keyboard-interactive authentication for jump hosts (2FA/MFA) const chainKiHandler = createKeyboardInteractiveHandler({ sender, sessionId, hostname: hopLabel, password: jump.password, logPrefix: `[Chain] Hop ${i + 1}/${totalHops}`, }); conn.on('keyboard-interactive', (name, instructions, lang, prompts, finish) => { if (prompts && prompts.length > 0) { sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'waiting for user input...'); } const wrappedFinish = (...args) => { sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'user responded'); finish(...args); }; chainKiHandler(name, instructions, lang, prompts, wrappedFinish); }); console.log(`[Chain] Hop ${i + 1}/${totalHops}: Connecting to ${hopLabel}...`); conn.connect(connOpts); }); connections.push(conn); // Determine next target let nextHost, nextPort; if (isLast) { // Last jump host, forward to final target nextHost = targetHost; nextPort = targetPort; } else { // Forward to next jump host const nextJump = jumpHosts[i + 1]; nextHost = nextJump.hostname; nextPort = nextJump.port || 22; } // Create forward stream to next hop console.log(`[Chain] Hop ${i + 1}/${totalHops}: Forwarding from ${hopLabel} to ${nextHost}:${nextPort}...`); sendProgress(i + 1, totalHops + 1, hopLabel, 'forwarding'); currentSocket = await new Promise((resolve, reject) => { conn.forwardOut('127.0.0.1', 0, nextHost, nextPort, (err, stream) => { if (err) { console.error(`[Chain] Hop ${i + 1}/${totalHops}: forwardOut from ${hopLabel} to ${nextHost}:${nextPort} FAILED:`, err.message); reject(err); return; } console.log(`[Chain] Hop ${i + 1}/${totalHops}: forwardOut from ${hopLabel} to ${nextHost}:${nextPort} SUCCESS`); resolve(stream); }); }); } // Return the final forwarded stream and all connections for cleanup return { socket: currentSocket, connections, sendProgress }; } catch (err) { if (options?._tunnelRef) { options._tunnelRef.pendingConn = null; options._tunnelRef.chainConnections = connections; } // Cleanup on error for (const conn of connections) { try { conn.end(); } catch { } } throw err; } } /** * Start an SSH session */ async function startSSHSession(event, options) { const sessionId = options.sessionId || randomUUID(); const cols = options.cols || 80; const rows = options.rows || 24; const sender = event.sender; const sendProgress = (hop, total, label, status, error) => { if (!sender.isDestroyed()) { sender.send("netcatty:chain:progress", { sessionId, hop, total, label, status, error }); } }; try { const conn = new SSHClient(); let chainConnections = []; let connectionSocket = null; // Determine if we have jump hosts const jumpHosts = options.jumpHosts || []; const hasJumpHosts = jumpHosts.length > 0; const hasProxy = !!options.proxy; const totalHops = jumpHosts.length + 1; // +1 for final target // Build base connection options for final target const connectOpts = { host: options.hostname, port: options.port || 22, username: options.username || "root", // `readyTimeout` covers the entire connection + authentication flow in ssh2. readyTimeout: 20000, // Fast failure for non-interactive auth // Use user-configured keepalive interval (in seconds -> convert to ms) // 0 = disabled (no keepalive packets sent) keepaliveInterval: options.keepaliveInterval > 0 ? options.keepaliveInterval * 1000 : 0, keepaliveCountMax: options.keepaliveInterval > 0 ? 3 : 0, // Enable keyboard-interactive authentication (required for 2FA/MFA) tryKeyboard: true, algorithms: buildAlgorithms(options.legacyAlgorithms), }; // Authentication for final target const hasCertificate = typeof options.certificate === "string" && options.certificate.trim().length > 0; const effectivePassphrase = options.passphrase; console.log("[SSH] Auth configuration:", { hasCertificate, keySource: options.keySource, hasPublicKey: !!options.publicKey, hasPrivateKey: !!options.privateKey, hasPassword: !!options.password, hasEffectivePassphrase: !!effectivePassphrase, }); log("Auth configuration", { hasCertificate, keySource: options.keySource, hasPublicKey: !!options.publicKey, hasPrivateKey: !!options.privateKey, }); let authAgent = null; if (hasCertificate) { authAgent = new NetcattyAgent({ mode: "certificate", webContents: event.sender, meta: { label: options.keyId || options.username || "", certificate: options.certificate, privateKey: options.privateKey, passphrase: effectivePassphrase, }, }); connectOpts.agent = authAgent; } else if (options.privateKey) { connectOpts.privateKey = options.privateKey; if (effectivePassphrase) { connectOpts.passphrase = effectivePassphrase; } } // Read identity files from local paths (e.g. from SSH config IdentityFile) // Only if no explicit key was already configured if (!connectOpts.privateKey && !connectOpts.agent && options.identityFilePaths?.length > 0) { for (const keyPath of options.identityFilePaths) { try { const resolvedPath = keyPath.startsWith("~/") ? path.join(os.homedir(), keyPath.slice(2)) : keyPath; const keyContent = await fs.promises.readFile(resolvedPath, "utf8"); connectOpts.privateKey = keyContent; // Check if key is encrypted — if so, use provided passphrase or prompt if (isKeyEncrypted(keyContent)) { if (options.passphrase) { log("Identity file is encrypted, using provided passphrase", { keyPath: resolvedPath }); connectOpts.passphrase = options.passphrase; } else { log("Identity file is encrypted, requesting passphrase", { keyPath: resolvedPath }); const result = await passphraseHandler.requestPassphrase( sender, resolvedPath, path.basename(resolvedPath), options.hostname ); if (result?.passphrase) { connectOpts.passphrase = result.passphrase; } else { // Cancelled/skipped/timeout — clear encrypted key, try next file delete connectOpts.privateKey; continue; } } } log("Loaded identity file", { keyPath: resolvedPath, encrypted: isKeyEncrypted(keyContent) }); break; // Use the first successfully loaded key } catch (err) { log("Failed to read identity file", { keyPath, error: err.message }); } } } if (options.password && typeof options.password === "string" && options.password.trim().length > 0) { connectOpts.password = options.password; } // Always try to find default SSH keys for fallback authentication // This allows fallback even when password auth fails let defaultKeyInfo = null; let allDefaultKeys = []; let usedDefaultKeyAsPrimary = false; const defaultKey = await findDefaultPrivateKey(); if (defaultKey) { defaultKeyInfo = defaultKey; log("Found default SSH key for fallback", { keyPath: defaultKey.keyPath, keyName: defaultKey.keyName }); } // Also find ALL default keys for comprehensive fallback allDefaultKeys = await findAllDefaultPrivateKeys(); // Use unlocked encrypted keys if provided (from retry after auth failure) // These are passed via _unlockedEncryptedKeys from startSSHSessionWrapper const unlockedEncryptedKeys = options._unlockedEncryptedKeys || []; if (unlockedEncryptedKeys.length > 0) { log("Using unlocked encrypted keys from retry", { count: unlockedEncryptedKeys.length, keyNames: unlockedEncryptedKeys.map(k => k.keyName) }); } // If no primary auth method configured, try ssh-agent first, then ALL default keys if (!connectOpts.privateKey && !connectOpts.password && !connectOpts.agent) { // First, try to use ssh-agent if available (this is what regular SSH does) const sshAgentSocket = await getAvailableAgentSocket(); if (sshAgentSocket) { log("No auth method configured, trying ssh-agent first", { agentSocket: sshAgentSocket }); connectOpts.agent = sshAgentSocket; } // Mark that we need to try all default keys (handled in authMethods below) if (allDefaultKeys.length > 0) { log("Will try all default SSH keys as fallback", { count: allDefaultKeys.length, keyNames: allDefaultKeys.map(k => k.keyName) }); // Set first key for connectOpts.privateKey (required for ssh2 to allow publickey auth) connectOpts.privateKey = allDefaultKeys[0].privateKey; usedDefaultKeyAsPrimary = true; } else { log("No default SSH key found in ~/.ssh directory"); } } log("Final auth configuration", { hasPrivateKey: !!connectOpts.privateKey, hasPassword: !!connectOpts.password, hasAgent: !!connectOpts.agent, hasDefaultKeyFallback: !!defaultKeyInfo, }); // Agent forwarding if (options.agentForwarding) { if (!connectOpts.agent) { connectOpts.agent = await getAvailableAgentSocket(); } // Only enable forwarding when an agent is actually available if (connectOpts.agent) { connectOpts.agentForward = true; } else { log("Agent forwarding requested but no agent available, skipping"); } } // Build authentication handler with fallback support // ssh2 authHandler can be a function that returns the next auth method to try // Check if we have a cached successful auth method for this host const cachedMethod = getCachedAuthMethod(connectOpts.username, options.hostname, options.port); // Track which method succeeded for caching let lastTriedMethod = null; if (authAgent) { const order = ["none", "agent"]; if (connectOpts.password) order.push("password"); // Add default key fallback if available and no user key configured // Must also set connectOpts.privateKey for ssh2 to actually try publickey auth if (defaultKeyInfo && !options.privateKey) { connectOpts.privateKey = defaultKeyInfo.privateKey; order.push("publickey"); } order.push("keyboard-interactive"); connectOpts.authHandler = order; log("Auth order (agent mode)", { order }); } else { // Build dynamic auth handler for fallback support const authMethods = []; // First try user-configured key if available (explicit user choice) if (connectOpts.privateKey && !usedDefaultKeyAsPrimary) { authMethods.push({ type: "publickey", key: connectOpts.privateKey, passphrase: connectOpts.passphrase, id: "publickey-user" }); } // Then try agent if configured (try agent before password since it's usually faster) if (connectOpts.agent) { authMethods.push({ type: "agent", id: "agent" }); } // Then try password if available (explicit user choice) if (connectOpts.password) { authMethods.push({ type: "password", id: "password" }); } // Then try ALL default SSH keys as fallback (not just the first one!) // This is critical because different servers may have different keys in authorized_keys if (usedDefaultKeyAsPrimary && allDefaultKeys.length > 0) { for (const keyInfo of allDefaultKeys) { authMethods.push({ type: "publickey", key: keyInfo.privateKey, isDefault: true, id: `publickey-default-${keyInfo.keyName}` }); } } else if (defaultKeyInfo && !options.privateKey && !usedDefaultKeyAsPrimary) { // Single default key fallback (when user has configured other auth methods) authMethods.push({ type: "publickey", key: defaultKeyInfo.privateKey, isDefault: true, id: "publickey-default" }); } // Add unlocked encrypted default keys (user provided passphrases for these) for (const keyInfo of unlockedEncryptedKeys) { authMethods.push({ type: "publickey", key: keyInfo.privateKey, passphrase: keyInfo.passphrase, isDefault: true, id: `publickey-encrypted-${keyInfo.keyName}` }); } // Finally try keyboard-interactive authMethods.push({ type: "keyboard-interactive", id: "keyboard-interactive" }); log("Auth methods configured", { methods: authMethods.map(m => ({ type: m.type, id: m.id, isDefault: m.isDefault || false })), cachedMethod, usedDefaultKeyAsPrimary }); // Reorder methods based on cached successful method if (cachedMethod) { const cachedIndex = authMethods.findIndex(m => m.id === cachedMethod); if (cachedIndex > 0) { const [cachedAuthMethod] = authMethods.splice(cachedIndex, 1); authMethods.unshift(cachedAuthMethod); log("Reordered auth methods based on cache", { methods: authMethods.map(m => m.id) }); } } // Always use dynamic authHandler to ensure consistent "none" probing // and auth method logging regardless of how many methods are configured if (authMethods.length >= 1) { let authIndex = 0; // Track methods that have been attempted (to avoid re-trying on failure) // This prevents reusing the same key when server requires multiple publickey auth steps // and also prevents re-attempting failed methods const attemptedMethodIds = new Set(); // Track the first successful method for caching (not the last one in multi-step flows) let firstSuccessfulMethod = null; // Track if we've gone through a partialSuccess flow (multi-step auth) let hadPartialSuccess = false; connectOpts.authHandler = (methodsLeft, partialSuccess, callback) => { log("authHandler called", { methodsLeft, partialSuccess, authIndex, attemptedMethodIds: Array.from(attemptedMethodIds) }); // Log rejection of previous method if (lastTriedMethod && !partialSuccess) { sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', `${lastTriedMethod} rejected`); } // On the very first call (methodsLeft === null), try "none" auth. // Per RFC 4252, the "none" request is how the client discovers which // methods the server supports. It also allows passwordless login on // embedded devices. This matches the behavior of OpenSSH and Tabby. if (methodsLeft === null && !attemptedMethodIds.has("none")) { attemptedMethodIds.add("none"); lastTriedMethod = "none"; sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'none (no credentials)'); return callback("none"); } // methodsLeft can be null on first call (before server responds with available methods) // Include "agent" for SSH agent-based auth (used with agentForwarding) const availableMethods = methodsLeft || ["publickey", "password", "keyboard-interactive", "agent"]; // Handle partialSuccess case (e.g., password succeeded but server requires additional auth like MFA) // When partialSuccess is true, we should try the remaining methods the server is asking for if (partialSuccess && methodsLeft && methodsLeft.length > 0) { hadPartialSuccess = true; // Record the first successful method (the one that triggered partialSuccess) if (lastTriedMethod && !firstSuccessfulMethod) { firstSuccessfulMethod = lastTriedMethod; log("Recorded first successful method for caching", { method: firstSuccessfulMethod }); } // Mark the last tried method as attempted (it succeeded, so we shouldn't retry it) if (lastTriedMethod) { attemptedMethodIds.add(lastTriedMethod); log("Marked method as attempted (partial success)", { method: lastTriedMethod }); } log("Partial success - server requires additional auth", { methodsLeft, attemptedMethodIds: Array.from(attemptedMethodIds) }); // Find a method from our list that matches what the server wants // Skip methods that have already been attempted for (const serverMethod of methodsLeft) { // Map server method names to our method types const matchingMethod = authMethods.find(m => { // Skip already attempted methods if (attemptedMethodIds.has(m.id)) return false; if (serverMethod === "keyboard-interactive" && m.type === "keyboard-interactive") return true; if (serverMethod === "password" && m.type === "password") return true; if (serverMethod === "publickey" && (m.type === "publickey" || m.type === "agent")) return true; return false; }); if (matchingMethod) { log("Found matching method for partial success", { serverMethod, matchingMethod: matchingMethod.id }); // Mark as attempted BEFORE returning to prevent re-use on failure attemptedMethodIds.add(matchingMethod.id); lastTriedMethod = matchingMethod.id; if (matchingMethod.type === "keyboard-interactive") { log("Trying keyboard-interactive auth (partial success)", { id: matchingMethod.id }); return callback("keyboard-interactive"); } else if (matchingMethod.type === "password") { log("Trying password auth (partial success)", { id: matchingMethod.id }); return callback({ type: "password", username: connectOpts.username, password: connectOpts.password, }); } else if (matchingMethod.type === "agent") { const agentType = typeof connectOpts.agent === "string" ? "path" : "NetcattyAgent"; log("Trying agent auth (partial success)", { id: matchingMethod.id, agentType }); return callback("agent"); } else if (matchingMethod.type === "publickey") { log("Trying publickey auth (partial success)", { id: matchingMethod.id }); return callback({ type: "publickey", username: connectOpts.username, key: matchingMethod.key, passphrase: matchingMethod.passphrase, }); } } } // No matching method found for partial success log("No matching method found for partial success requirements", { methodsLeft }); return callback(false); } while (authIndex < authMethods.length) { const method = authMethods[authIndex]; authIndex++; // Skip methods that have already been attempted (e.g., during partial success handling) if (attemptedMethodIds.has(method.id)) { log("Skipping already attempted method", { method: method.id }); continue; } // Check if this method is still available on server // Note: "agent" uses "publickey" as the underlying method type const methodName = method.type === "password" ? "password" : method.type === "publickey" ? "publickey" : method.type === "agent" ? "publickey" : "keyboard-interactive"; if (!availableMethods.includes(methodName) && !availableMethods.includes(method.type)) { log("Auth method not available on server, skipping", { method: method.id }); continue; } // Mark as attempted BEFORE returning attemptedMethodIds.add(method.id); lastTriedMethod = method.id; if (method.type === "agent") { // Only log safe identifier, not the full agent object which may contain private keys const agentType = typeof connectOpts.agent === "string" ? "path" : "NetcattyAgent"; log("Trying agent auth", { id: method.id, agentType }); sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'SSH agent'); // Return "agent" string to use SSH agent for authentication return callback("agent"); } else if (method.type === "publickey") { log("Trying publickey auth", { id: method.id, isDefault: method.isDefault || false }); const keyLabel = method.id.startsWith("publickey-default-") ? `key ${method.id.replace("publickey-default-", "")}` : method.id.startsWith("publickey-encrypted-") ? `key ${method.id.replace("publickey-encrypted-", "")} (encrypted)` : method.id === "publickey-user" ? "configured key" : method.id; sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', keyLabel); return callback({ type: "publickey", username: connectOpts.username, key: method.key, passphrase: method.passphrase, }); } else if (method.type === "password") { log("Trying password auth", { id: method.id }); sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'password'); return callback({ type: "password", username: connectOpts.username, password: connectOpts.password, }); } else if (method.type === "keyboard-interactive") { log("Trying keyboard-interactive auth", { id: method.id }); sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'keyboard-interactive'); // Return string instead of object - ssh2 requires a prompt function // for keyboard-interactive objects. Returning the string lets ssh2 // use its default handling and trigger the keyboard-interactive event. return callback("keyboard-interactive"); } } log("All auth methods exhausted"); sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'all methods exhausted'); return callback(false); }; // Store method reference for success callback // For multi-step auth (partialSuccess), cache the first successful method, not the last // This ensures next connection starts with the correct first factor connectOpts._lastTriedMethodRef = () => { if (hadPartialSuccess && firstSuccessfulMethod) { log("Using first successful method for cache (multi-step auth)", { firstSuccessfulMethod }); return firstSuccessfulMethod; } return lastTriedMethod; }; } } // Handle chain/proxy connections if (hasJumpHosts) { // Pass fetched keys to chain connection to avoid re-reading files options._defaultKeys = allDefaultKeys; const chainResult = await connectThroughChain( event, options, jumpHosts, options.hostname, options.port || 22, sessionId ); connectionSocket = chainResult.socket; chainConnections = chainResult.connections; connectOpts.sock = connectionSocket; delete connectOpts.host; delete connectOpts.port; sendProgress(totalHops, totalHops, options.hostname, 'connecting'); } else if (hasProxy) { sendProgress(1, 1, options.hostname, 'connecting'); connectionSocket = await createProxySocket( options.proxy, options.hostname, options.port || 22 ); connectOpts.sock = connectionSocket; delete connectOpts.host; delete connectOpts.port; } else { // Direct connection (no jump hosts, no proxy) sendProgress(1, 1, options.hostname, 'connecting'); } return new Promise((resolve, reject) => { const logPrefix = hasJumpHosts ? '[Chain]' : '[SSH]'; let settled = false; let detachX11Forwarding = null; conn.once("handshake", () => { console.log(`${logPrefix} ${options.hostname} handshake complete`); sendProgress(totalHops, totalHops, options.hostname, 'authenticating'); }); conn.once("ready", () => { console.log(`${logPrefix} ${options.hostname} ready`); // Cache the successful auth method if (connectOpts._lastTriedMethodRef) { const successMethod = connectOpts._lastTriedMethodRef(); if (successMethod) { setCachedAuthMethod(connectOpts.username, options.hostname, options.port, successMethod); } } sendProgress(totalHops, totalHops, options.hostname, 'authenticated'); sendProgress(totalHops, totalHops, options.hostname, 'shell'); const sendTerminalMessage = (data) => { safeSend(event.sender, "netcatty:data", { sessionId, data }); }; const x11FakeCookie = options.x11Forwarding ? crypto.randomBytes(16).toString("hex") : null; if (options.x11Forwarding) { detachX11Forwarding = attachX11Forwarding(conn, { display: options.x11Display, fakeCookie: x11FakeCookie, sendMessage: sendTerminalMessage, }); } const shellOptions = { env: { LANG: resolveLangFromCharset(options.charset), COLORTERM: "truecolor", ...(options.env || {}), }, }; if (options.x11Forwarding) { shellOptions.x11 = { protocol: "MIT-MAGIC-COOKIE-1", cookie: x11FakeCookie, screen: 0, single: false, }; } conn.shell( { term: "xterm-256color", cols, rows, }, shellOptions, (err, stream) => { if (err) { if (detachX11Forwarding) detachX11Forwarding(); settled = true; conn.end(); for (const c of chainConnections) { try { c.end(); } catch { } } if (options.x11Forwarding && /x11/i.test(err.message || "")) { sendTerminalMessage("\r\n[X11] Could not enable X11 forwarding. Make sure X11 forwarding is allowed on the server and xauth is installed.\r\n"); } sendProgress(totalHops, totalHops, options.hostname, 'error', `Failed to open shell: ${err.message}`); reject(err); return; } sendProgress(totalHops, totalHops, options.hostname, 'connected'); const session = { conn, stream, chainConnections, webContentsId: event.sender.id, // Store connection info for MCP host discovery hostname: options.host || options.hostname || '', username: options.username || '', label: options.label || '', lastIdlePrompt: '', lastIdlePromptAt: 0, _promptTrackTail: '', // SSH server identification string (the `software` part of // `SSH-2.0-`). ssh2 captures this during the header // exchange and stores it on the client as `_remoteVer` — it // is available by the time 'ready' fires, so the renderer can // use it to detect network-device vendors without running any // additional exec channels. See domain/host.ts // `detectVendorFromSshVersion`. remoteSshVersion: (conn && typeof conn._remoteVer === 'string') ? conn._remoteVer : '', }; sessions.set(sessionId, session); // Start real-time session log stream if configured if (options.sessionLog?.enabled && options.sessionLog?.directory) { sessionLogStreamManager.startStream(sessionId, { hostLabel: options.hostLabel || options.hostname || '', hostname: options.hostname || '', directory: options.sessionLog.directory, format: options.sessionLog.format || 'txt', startTime: Date.now(), }); } // Data buffering for reduced IPC overhead let dataBuffer = ''; let flushTimeout = null; const FLUSH_INTERVAL = 8; // ms - flush every 8ms for ~120fps equivalent const MAX_BUFFER_SIZE = 16384; // 16KB - flush immediately if buffer gets too large const flushBuffer = () => { if (dataBuffer.length > 0) { const contents = event.sender; safeSend(contents, "netcatty:data", { sessionId, data: dataBuffer }); dataBuffer = ''; } flushTimeout = null; }; const bufferData = (data) => { dataBuffer += data; // Immediate flush for large chunks if (dataBuffer.length >= MAX_BUFFER_SIZE) { if (flushTimeout) { clearTimeout(flushTimeout); flushTimeout = null; } flushBuffer(); } else if (!flushTimeout) { // Schedule flush flushTimeout = setTimeout(flushBuffer, FLUSH_INTERVAL); } }; const sshZmodemSentry = createZmodemSentry({ sessionId, onData(buf) { const decoder = getSessionDecoder(sessionId, "stdout"); const decoded = decoder.write(buf); trackSessionIdlePrompt(session, decoded); bufferData(decoded); sessionLogStreamManager.appendData(sessionId, decoded); }, writeToRemote(buf) { try { return stream.write(buf); } catch { return true; /* ignore */ } }, interruptRemote() { try { stream.signal?.("INT"); } catch { /* ignore */ } }, getWebContents() { return event.sender; }, label: "SSH", }); session.zmodemSentry = sshZmodemSentry; stream.on("data", (data) => { // data is Buffer from ssh2 — feed raw bytes to ZMODEM sentry. // In normal mode, sentry's onData callback handles decoding and buffering. sshZmodemSentry.consume(data); }); stream.stderr?.on("data", (data) => { // stderr is not used for ZMODEM — decode normally const decoder = getSessionDecoder(sessionId, "stderr"); const decoded = decoder.write(data); bufferData(decoded); sessionLogStreamManager.appendData(sessionId, decoded); }); // Capture the real exit code from the remote process. // "exit" fires when the remote shell/process exits normally; // "close" fires whenever the channel closes (could be network drop). // Only treat it as user-initiated exit if "exit" fired with a numeric // code and no signal. Signal terminations (e.g. server kill, idle // timeout) have code=null and signal set — those are not user exits. let streamExitCode = 0; let streamExited = false; stream.on("exit", (code, signal) => { streamExitCode = typeof code === "number" ? code : 0; streamExited = typeof code === "number" && !signal; }); stream.on("close", () => { // Always flush buffered data regardless of session state if (flushTimeout) { clearTimeout(flushTimeout); } flushBuffer(); sessionLogStreamManager.stopStream(sessionId); if (detachX11Forwarding) { detachX11Forwarding(); detachX11Forwarding = null; } // Only send exit if session hasn't already been cleaned up by // conn.once("close") — which fires before stream.on("close") // in ssh2 when the transport drops. if (sessions.has(sessionId)) { const contents = event.sender; const session = sessions.get(sessionId); const transportError = session?._transportError; if (transportError) { safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: transportError, reason: "error" }); } else { safeSend(contents, "netcatty:exit", { sessionId, exitCode: streamExitCode, reason: streamExited ? "exited" : "closed" }); } sessions.get(sessionId)?.zmodemSentry?.cancel(); sessions.delete(sessionId); sessionEncodings.delete(sessionId); sessionDecoders.delete(sessionId); } conn.end(); for (const c of chainConnections) { try { c.end(); } catch { } } }); // Pre-seed encoding from host charset if it's a GB variant if (options.charset && /^gb/i.test(String(options.charset).trim())) { sessionEncodings.set(sessionId, "gb18030"); } // Run startup command if specified if (options.startupCommand) { setTimeout(() => { stream.write(`${options.startupCommand}\n`); }, 300); } settled = true; resolve({ sessionId }); } ); }); conn.on("error", (err) => { // After the promise is settled, we can't reject again. But if the // session was already established (resolved), we still need to notify // the renderer about transport errors so the session shows as failed // rather than silently closing. // Don't send netcatty:exit here — the stream close handler will flush // any buffered data first and then send exit with this error info. if (settled) { console.warn(`${logPrefix} ${options.hostname} post-settle error:`, err.message); // Store the error so the close handler can include it in the exit event if (sessions.has(sessionId)) { const session = sessions.get(sessionId); if (session) session._transportError = err.message; } return; } const contents = event.sender; const isAuthError = err.message?.toLowerCase().includes('authentication') || err.message?.toLowerCase().includes('auth') || err.message?.toLowerCase().includes('password') || err.level === 'client-authentication'; // Clear cached auth method on auth failure so next attempt tries all methods if (isAuthError) { clearCachedAuthMethod(connectOpts.username, options.hostname, options.port); console.log(`${logPrefix} ${options.hostname} auth failed:`, err.message); safeSend(contents, "netcatty:auth:failed", { sessionId, error: err.message, hostname: options.hostname }); } else { console.error(`${logPrefix} ${options.hostname} error:`, err.message); } sendProgress(totalHops, totalHops, options.hostname, 'error', err.message); safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: err.message, reason: "error" }); sessionLogStreamManager.stopStream(sessionId); if (detachX11Forwarding) { detachX11Forwarding(); detachX11Forwarding = null; } sessions.get(sessionId)?.zmodemSentry?.cancel(); sessions.delete(sessionId); sessionEncodings.delete(sessionId); sessionDecoders.delete(sessionId); for (const c of chainConnections) { try { c.end(); } catch { } } // Destroy the connection to prevent further socket errors from leaking // as uncaught exceptions (e.g. ECONNRESET on embedded devices). try { conn.destroy(); } catch { } settled = true; reject(err); }); conn.once("timeout", () => { console.error(`${logPrefix} ${options.hostname} connection timeout`); const err = new Error(`Connection timeout to ${options.hostname}`); const contents = event.sender; sendProgress(totalHops, totalHops, options.hostname, 'error', err.message); safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: err.message, reason: "timeout" }); sessionLogStreamManager.stopStream(sessionId); sessions.get(sessionId)?.zmodemSentry?.cancel(); sessions.delete(sessionId); sessionEncodings.delete(sessionId); sessionDecoders.delete(sessionId); for (const c of chainConnections) { try { c.end(); } catch { } } try { conn.destroy(); } catch { } settled = true; reject(err); }); conn.once("close", () => { const contents = event.sender; if (!settled) { sendProgress(totalHops, totalHops, options.hostname, 'error', `Connection to ${options.hostname} closed unexpectedly`); } // Only send exit if the session hasn't already been cleaned up by the // error handler (avoids sending a misleading exitCode:0 "closed" after // a real transport error was already reported). if (sessions.has(sessionId)) { const session = sessions.get(sessionId); const transportError = session?._transportError; if (transportError) { // A transport error was recorded — report it as an error exit safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: transportError, reason: "error" }); } else { safeSend(contents, "netcatty:exit", { sessionId, exitCode: 0, reason: "closed" }); } } sessionLogStreamManager.stopStream(sessionId); sessions.get(sessionId)?.zmodemSentry?.cancel(); sessions.delete(sessionId); sessionEncodings.delete(sessionId); sessionDecoders.delete(sessionId); for (const c of chainConnections) { try { c.end(); } catch { } } if (!settled) { settled = true; reject(new Error(`Connection to ${options.hostname} closed unexpectedly`)); } }); // Handle keyboard-interactive authentication (2FA/MFA) conn.on("keyboard-interactive", (name, instructions, instructionsLang, prompts, finish) => { console.log(`${logPrefix} ${options.hostname} keyboard-interactive auth requested`, { name, instructions, promptCount: prompts?.length || 0, prompts: prompts?.map(p => ({ prompt: p.prompt, echo: p.echo })), }); // If there are no prompts, just call finish with empty array if (!prompts || prompts.length === 0) { console.log(`${logPrefix} No prompts, finishing keyboard-interactive`); finish([]); return; } sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'waiting for user input...'); // Forward ALL prompts to user - no auto-fill to avoid semantic detection issues // (Prompt text is admin-customizable and may not contain expected keywords) const requestId = keyboardInteractiveHandler.generateRequestId('ssh'); keyboardInteractiveHandler.storeRequest(requestId, (userResponses) => { console.log(`${logPrefix} Received user responses, finishing keyboard-interactive`); sendProgress(totalHops, totalHops, options.hostname, 'auth-attempt', 'user responded'); finish(userResponses); }, sender.id, sessionId); const promptsData = prompts.map((p) => ({ prompt: p.prompt, echo: p.echo, })); console.log(`${logPrefix} Showing modal for ${promptsData.length} prompts`); safeSend(sender, "netcatty:keyboard-interactive", { requestId, sessionId, name: name || "", instructions: instructions || "", prompts: promptsData, hostname: options.hostname, savedPassword: options.password || null, // Pass saved password for optional fill button }); }); // Enable keyboard-interactive authentication in authHandler // Note: If authHandler is a function (for fallback support), keyboard-interactive // is already included in the auth methods list if (Array.isArray(connectOpts.authHandler)) { // Add keyboard-interactive after the existing methods if (!connectOpts.authHandler.includes("keyboard-interactive")) { connectOpts.authHandler.push("keyboard-interactive"); } } else if (typeof connectOpts.authHandler !== "function") { // Create authHandler with keyboard-interactive support // This path is taken when usedDefaultKeyAsPrimary=true (only keyboard-interactive in authMethods) // Using array format is more reliable - ssh2 uses connectOpts credentials directly const authMethods = []; // Try agent FIRST (this is what regular SSH does - it checks ssh-agent before key files) if (connectOpts.agent) authMethods.push("agent"); if (connectOpts.privateKey) authMethods.push("publickey"); if (connectOpts.password) authMethods.push("password"); authMethods.push("keyboard-interactive"); connectOpts.authHandler = authMethods; log("Using simple array authHandler", { authMethods, usedDefaultKeyAsPrimary }); } // If authHandler is a function, it already handles keyboard-interactive // Increase timeout to allow for keyboard-interactive auth connectOpts.readyTimeout = 120000; // 2 minutes for 2FA input // Enable debug logging for ssh2 to diagnose auth issues connectOpts.debug = (msg) => { // Only log auth-related messages to avoid noise if (msg.includes('Auth') || msg.includes('auth') || msg.includes('publickey') || msg.includes('keyboard')) { log("ssh2 debug", { msg }); } }; console.log(`${logPrefix} Connecting to ${options.hostname}...`); conn.connect(connectOpts); }); } catch (err) { console.error("[Chain] SSH chain connection error:", err.message); const contents = event.sender; safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: err.message }); throw err; } } /** * Execute a one-off command via SSH */ async function execCommand(event, payload) { const enableKeyboardInteractive = !!payload.enableKeyboardInteractive; const baseTimeoutMs = payload.timeout || 10000; const timeoutMs = enableKeyboardInteractive ? Math.max(baseTimeoutMs, 120000) : baseTimeoutMs; const sender = event.sender; const sessionId = payload.sessionId || randomUUID(); const defaultKeys = enableKeyboardInteractive ? await findAllDefaultPrivateKeysFromHelper() : []; return new Promise((resolve, reject) => { const conn = new SSHClient(); let stdout = ""; let stderr = ""; let settled = false; const timer = setTimeout(() => { if (settled) return; settled = true; conn.end(); reject(new Error("SSH exec timeout")); }, timeoutMs); conn .once("ready", () => { conn.exec(payload.command, (err, stream) => { if (err) { clearTimeout(timer); settled = true; conn.end(); return reject(err); } stream .on("data", (data) => { stdout += data.toString(); }) .stderr.on("data", (data) => { stderr += data.toString(); }) .on("close", (code) => { if (settled) return; clearTimeout(timer); settled = true; conn.end(); resolve({ stdout, stderr, code: code ?? (stderr ? 1 : 0) }); }); }); }) .on("error", (err) => { if (settled) return; clearTimeout(timer); settled = true; conn.end(); reject(err); }) .once("end", () => { if (settled) return; clearTimeout(timer); settled = true; if (stderr || stdout) { resolve({ stdout, stderr, code: 0 }); } else { reject(new Error("SSH connection closed unexpectedly")); } }); const hasCertificate = typeof payload.certificate === "string" && payload.certificate.trim().length > 0; const connectOpts = { host: payload.hostname, port: payload.port || 22, username: payload.username, readyTimeout: enableKeyboardInteractive ? Math.max(timeoutMs, 120000) : timeoutMs, keepaliveInterval: 0, }; let authAgent = null; if (hasCertificate) { authAgent = new NetcattyAgent({ mode: "certificate", webContents: event.sender, meta: { label: payload.keyId || payload.username || "", certificate: payload.certificate, privateKey: payload.privateKey, passphrase: payload.passphrase, }, }); connectOpts.agent = authAgent; } else if (payload.privateKey) { connectOpts.privateKey = payload.privateKey; if (payload.passphrase) connectOpts.passphrase = payload.passphrase; } if (payload.password) connectOpts.password = payload.password; if (enableKeyboardInteractive) { connectOpts.tryKeyboard = true; const authConfig = buildAuthHandler({ privateKey: connectOpts.privateKey, password: connectOpts.password, passphrase: connectOpts.passphrase, agent: connectOpts.agent, username: connectOpts.username, logPrefix: "[SSH Exec]", defaultKeys, }); applyAuthToConnOpts(connectOpts, authConfig); conn.on("keyboard-interactive", createKeyboardInteractiveHandler({ sender, sessionId, hostname: payload.hostname, password: payload.password, logPrefix: "[SSH Exec]", })); } else if (authAgent) { const order = ["agent"]; if (connectOpts.password) order.push("password"); connectOpts.authHandler = order; } conn.connect(connectOpts); }); } /** * Generate SSH key pair */ async function generateKeyPair(event, options) { const { type, bits, comment } = options; try { let keyType; let keyBits = bits; switch (type) { case 'ED25519': keyType = 'ed25519'; keyBits = undefined; break; case 'ECDSA': keyType = 'ecdsa'; keyBits = bits || 256; break; case 'RSA': default: keyType = 'rsa'; keyBits = bits || 4096; break; } const result = sshUtils.generateKeyPairSync(keyType, { bits: keyBits, comment: comment || 'netcatty-generated-key', }); const privateKey = result.private; const publicKey = result.public; return { success: true, privateKey, publicKey, }; } catch (err) { console.error('Key generation failed:', err); return { success: false, error: err.message || 'Key generation failed', }; } } /** * Wrapper for SSH session handler to suppress noisy auth error stack traces * Auth failures are expected when fallback to password is available */ async function startSSHSessionWrapper(event, options) { try { return await startSSHSession(event, options); } catch (err) { const isAuthError = err.message?.toLowerCase().includes('authentication') || err.message?.toLowerCase().includes('auth') || err.level === 'client-authentication'; if (isAuthError) { // Check if there are encrypted default keys we haven't tried yet // Only offer retry if no unlocked keys were provided in this attempt const hasJumpHosts = options.jumpHosts && options.jumpHosts.length > 0; const isPasswordOnly = !hasJumpHosts && !options.agentForwarding && !!options.password && !options.privateKey && !options.certificate; if (!isPasswordOnly && (!options._unlockedEncryptedKeys || options._unlockedEncryptedKeys.length === 0)) { const allKeysWithEncrypted = await findAllDefaultPrivateKeysFromHelper({ includeEncrypted: true }); const encryptedKeys = allKeysWithEncrypted.filter(k => k.isEncrypted); if (encryptedKeys.length > 0) { console.log('[SSH] Auth failed, found encrypted default keys. Requesting passphrases for retry...'); // Request passphrases from user const passphraseResult = await requestPassphrasesForEncryptedKeys( event.sender, options.hostname ); // If user cancelled, don't retry even if some keys were unlocked if (passphraseResult.cancelled) { console.log('[SSH] User cancelled passphrase flow, not retrying'); } else if (passphraseResult.keys.length > 0) { console.log('[SSH] User unlocked keys, retrying connection...', { count: passphraseResult.keys.length, keyNames: passphraseResult.keys.map(k => k.keyName) }); // Retry connection with unlocked keys // Wrap in try-catch to ensure consistent error handling for retry failures try { return await startSSHSession(event, { ...options, _unlockedEncryptedKeys: passphraseResult.keys, }); } catch (retryErr) { // Notify renderer that passphrase-based retry failed, // so it can clear any saved passphrases that didn't work. try { const failedKeyPaths = passphraseResult.keys.map(k => k.keyPath); event.sender.send('netcatty:passphrase-auth-failed', { keyPaths: failedKeyPaths }); } catch (_) { /* sender may be destroyed */ } // Re-wrap retry errors the same way as initial errors const isRetryAuthError = retryErr.message?.toLowerCase().includes('authentication') || retryErr.message?.toLowerCase().includes('auth') || retryErr.level === 'client-authentication'; if (isRetryAuthError) { const authError = new Error(retryErr.message); authError.level = 'client-authentication'; authError.isAuthError = true; throw authError; } // Wrap non-auth retry errors as connection errors to prevent crash const connError = new Error(retryErr.message); connError.level = retryErr.level || 'client-socket'; connError.code = retryErr.code; throw connError; } } else { console.log('[SSH] User did not unlock any keys, not retrying'); } } } // Re-throw with a clean error to avoid Electron printing full stack trace // The frontend will handle this as a normal auth failure for fallback const authError = new Error(err.message); authError.level = 'client-authentication'; authError.isAuthError = true; throw authError; } // Non-auth errors (e.g. ECONNRESET, ETIMEDOUT) — wrap in a clean Error // so Electron's ipcMain.handle can serialize it back to the renderer // instead of it becoming an uncaught exception that crashes the app. // See: https://github.com/nicely-gg/netcatty/issues/482 const connError = new Error(err.message); connError.level = err.level || 'client-socket'; connError.code = err.code; throw connError; } } /** * Get current working directory from an active SSH session * This sends 'pwd' to the existing shell stream and captures the output * using unique markers to identify the command output boundaries */ /** * Return metadata about an already-connected session that was captured at * connect time. Currently exposes the SSH server identification string * (the `software` portion of the SSH-2.0 banner) so the renderer can * classify network devices from the banner without running any additional * exec channels. */ async function getSessionRemoteInfo(_event, payload) { const { sessionId } = payload || {}; const session = sessions.get(sessionId); if (!session) { return { success: false, error: 'Session not found' }; } return { success: true, remoteSshVersion: session.remoteSshVersion || '', }; } /** * Run the distro-identification probe on an already-connected SSH * session's connection. Uses an exec channel on the existing conn — * which is still one extra channel (and therefore one extra AAA * session on vendor CLIs that don't multiplex channels cleanly), but * avoids the full auth round-trip that `execCommand` would do by * creating a brand new SSHClient. The renderer only falls through to * this when banner classification returned no vendor, so in practice * it never runs against Cisco/Huawei/HPE/etc. — only against * Linux-like hosts and OpenSSH-fronted network devices (JUNOS, * NX-OS, EOS) that are already handled by the useServerStats * failure-counter path downstream. */ async function getSessionDistroInfo(_event, payload) { const { sessionId } = payload || {}; const session = sessions.get(sessionId); if (!session || !session.conn) { return { success: false, error: 'Session not found or not connected' }; } const command = "cat /etc/os-release 2>/dev/null || uname -a"; return new Promise((resolve) => { let settled = false; const settle = (result) => { if (settled) return; settled = true; clearTimeout(timer); resolve(result); }; const timer = setTimeout(() => { settle({ success: false, error: 'Timeout probing distro' }); // Clean up the exec channel so it doesn't linger. try { if (activeStream) activeStream.close(); } catch { /* ignore */ } }, 5000); let activeStream = null; try { session.conn.exec(command, (err, stream) => { if (err) { settle({ success: false, error: err.message || String(err) }); return; } activeStream = stream; let stdout = ''; let stderr = ''; stream.on('data', (chunk) => { stdout += chunk.toString(); }); stream.stderr.on('data', (chunk) => { stderr += chunk.toString(); }); stream.on('close', () => { settle({ success: true, stdout, stderr }); }); }); } catch (err) { settle({ success: false, error: err?.message || String(err) }); } }); } async function getSessionPwd(event, payload) { const { sessionId } = payload; const session = sessions.get(sessionId); if (!session || !session.conn) { return { success: false, error: 'Session not found or not connected' }; } // Completely silent: uses a separate exec channel, nothing is printed // in the interactive terminal. The exec channel and the interactive // shell are both children of the same per-connection sshd process, // so we find the shell as a sibling via $PPID. return new Promise((resolve) => { const timer = setTimeout(() => { resolve({ success: false, error: 'Timeout getting pwd' }); }, 5000); // POSIX sh script that: // 1. Finds the sibling interactive shell under sshd ($PPID). // 2. Follows foreground child shells only, which covers bash->fish // without mistaking background shell scripts for the active shell. // 3. Reads /proc//cwd via readlink. // 4. Falls back to the user's home directory if anything fails. // // `exec` makes sh replace the user's login shell (fish/bash/...) // so sh keeps the same PID and $PPID = sshd. Starting another shell // without exec would make $PPID point at the intermediate shell instead. const posixScript = `SELF=$$ find_child_shell() { mode=$2 ps -e -o pid=,ppid=,stat=,comm= 2>/dev/null | awk -v pp="$1" -v self="$SELF" -v mode="$mode" ' $1 != self && $2 == pp && $4 ~ /^(ba|z|fi|k|da)?sh$/ { if (index($3, "+") > 0) { print $1; found=1; exit } if (mode != "foreground" && pid == "") pid=$1 } END { if (!found && mode != "foreground" && pid != "") print pid } ' } pid=$(find_child_shell "$PPID" any) while [ -n "$pid" ]; do child=$(find_child_shell "$pid" foreground) [ -n "$child" ] || break pid="$child" done if [ -n "$pid" ]; then cwd=$(readlink /proc/$pid/cwd 2>/dev/null) [ -n "$cwd" ] && printf '%s\\n' "$cwd" && exit 0 fi emit_home() { case "$1" in /*) printf '%s\\n' "$1"; exit 0 ;; esac } home=$(eval echo "~" 2>/dev/null) emit_home "$home" uid=$(id -u 2>/dev/null) if [ -n "$uid" ]; then home=$(getent passwd "$uid" 2>/dev/null | awk -F: 'NR == 1 { print $6; exit }') emit_home "$home" home=$(awk -F: -v uid="$uid" '$3 == uid { print $6; exit }' /etc/passwd 2>/dev/null) emit_home "$home" fi home=$(id -P 2>/dev/null | awk -F: 'NR == 1 { print $9; exit }') emit_home "$home" emit_home "$HOME" exit 1`; const cmd = `exec sh -c ${quoteShellArg(posixScript)}`; session.conn.exec(cmd, (err, stream) => { if (err) { clearTimeout(timer); log('[getSessionPwd] exec error:', err.message); resolve({ success: false, error: err.message }); return; } let out = ''; let errOut = ''; stream.on('data', (d) => { out += d.toString(); }); stream.stderr?.on('data', (d) => { errOut += d.toString(); }); stream.on('close', (code) => { clearTimeout(timer); const path = out.trim(); log('[getSessionPwd]', { stdout: path, stderr: errOut.trim(), exitCode: code }); if (path && path.startsWith('/')) { resolve({ success: true, cwd: path }); } else { resolve({ success: false, error: 'Could not determine cwd' }); } }); }); }); } /** * List directory contents on remote machine for path autocomplete. * Uses a separate exec channel — does not touch the interactive shell. */ async function listSessionDir(_event, payload) { const { sessionId, path: dirPath, foldersOnly, filterPrefix = "", limit = 100, } = payload || {}; const session = sessions.get(sessionId); if (!session || !session.conn) { return { success: false, entries: [], error: 'Session not found' }; } if (typeof dirPath !== "string" || dirPath.length === 0) { return { success: false, entries: [], error: 'Invalid directory path' }; } return new Promise((resolve) => { let settled = false; let streamRef = null; const resolveOnce = (result) => { if (settled) return; settled = true; clearTimeout(timer); resolve(result); }; const timer = setTimeout(() => { try { streamRef?.close?.(); streamRef?.destroy?.(); } catch {} resolveOnce({ success: false, entries: [], error: 'Timeout listing directory' }); }, 3000); // Emit a NUL-delimited stream from plain POSIX shell/find so we don't depend on // Python/Perl, while still preserving whitespace and newline characters in filenames. const safePath = dirPath.replace(/'/g, "'\\''"); const tildePathSuffix = dirPath.startsWith("~/") ? dirPath.slice(2).replace(/(["\\$`])/g, "\\$1") : ""; const normalizedPrefix = typeof filterPrefix === "string" ? filterPrefix.toLowerCase() : ""; const safePrefix = normalizedPrefix.replace(/'/g, "'\\''"); const maxEntries = Number.isFinite(limit) ? Math.min(Math.max(1, Math.floor(limit)), 200) : 100; const pathExpr = dirPath === "~" ? '"$HOME"' : dirPath.startsWith("~/") ? `"$HOME/${tildePathSuffix}"` : `'${safePath}'`; // When dirPath is relative (not absolute and not ~/...), exec channels default // to the user's home directory. Resolve the interactive shell's actual cwd first // so that relative paths like "." or "src" are resolved correctly. const needsCwdResolve = !dirPath.startsWith('/') && dirPath !== '~' && !dirPath.startsWith('~/'); const cwdResolveCmd = needsCwdResolve ? `_sc_p=$(ps --ppid $PPID -o pid=,comm= 2>/dev/null | awk -v self=$$ '$1!=self && $2~/^(ba|z|fi|k|da)?sh$/{pid=$1}END{print pid}'); [ -z "$_sc_p" ] && _sc_p=$(ps -e -o pid=,ppid=,comm= 2>/dev/null | awk -v pp=$PPID -v self=$$ '$1!=self && $2==pp && $3~/^(ba|z|fi|k|da)?sh$/{pid=$1}END{print pid}'); [ -n "$_sc_p" ] && { _sc_d=$(readlink /proc/$_sc_p/cwd 2>/dev/null); [ -n "$_sc_d" ] && cd "$_sc_d" 2>/dev/null; }; ` : ''; const cmd = `${cwdResolveCmd}find ${pathExpr} -mindepth 1 -maxdepth 1 -exec sh -c ' prefix="$1" folders_only="$2" limit="$3" shift 3 count=0 for path do name=\${path##*/} lower_name=$(printf "%s" "$name" | tr "[:upper:]" "[:lower:]") if [ -n "$prefix" ]; then case "$lower_name" in "$prefix"*) ;; *) continue ;; esac fi if [ "$folders_only" -eq 1 ] && [ ! -d "$path" ]; then continue fi if [ -L "$path" ]; then type="symlink" elif [ -d "$path" ]; then type="directory" else type="file" fi printf "%s\\0%s\\0" "$name" "$type" count=$((count + 1)) if [ "$count" -ge "$limit" ]; then break fi done ' sh '${safePrefix}' ${foldersOnly ? 1 : 0} ${maxEntries} {} + 2>/dev/null`; session.conn.exec(cmd, (err, stream) => { if (err) { resolveOnce({ success: false, entries: [], error: err.message }); return; } streamRef = stream; const chunks = []; let errOut = ''; stream.on('data', (d) => { chunks.push(Buffer.from(d)); }); stream.stderr?.on('data', (d) => { errOut += d.toString(); }); stream.on('close', () => { if (settled) return; try { const output = Buffer.concat(chunks); const entries = []; let fieldStart = 0; let pendingName = null; for (let i = 0; i < output.length; i++) { if (output[i] !== 0) continue; const field = output.toString('utf8', fieldStart, i); fieldStart = i + 1; if (pendingName === null) { pendingName = field; } else { entries.push({ name: pendingName, type: field }); pendingName = null; if (entries.length >= maxEntries) break; } } if (pendingName !== null) { resolveOnce({ success: false, entries: [], error: 'Invalid directory listing response' }); return; } resolveOnce({ success: true, entries }); } catch { resolveOnce({ success: false, entries: [], error: errOut.trim() || 'Failed to parse directory listing', }); } }); }); }); } /** * Get server stats (CPU, Memory, Disk) from an active SSH session * Only works for Linux servers */ async function getServerStats(event, payload) { const { sessionId } = payload; const session = sessions.get(sessionId); if (!session || !session.conn) { return { success: false, error: 'Session not found or not connected' }; } const conn = session.conn; // macOS stats command: uses sysctl, vm_stat, top, ps, df, netstat // CPU reported as direct percentage (top computes delta internally) // cpuPerCore not available on macOS without sudo const macosStatsCommand = [ `cores=$(sysctl -n hw.logicalcpu 2>/dev/null || echo "1")`, `pagesize=$(sysctl -n hw.pagesize 2>/dev/null || echo "4096")`, `memsize=$(sysctl -n hw.memsize 2>/dev/null || echo "0")`, // CPU usage: top -l 1 gives one logging sample, parse idle% `cpuline=$(top -l 1 -s 0 -n 0 2>/dev/null | grep "CPU usage:" | head -1)`, `cpupct=$(echo "$cpuline" | awk '{for(i=1;i<=NF;i++){if($(i+1)~/^idle/){v=$i;gsub(/%/,"",v);idle=v+0;found=1}};if(found)printf "%.0f",100-idle}')`, // Memory: single vm_stat pipe → awk extracts all page counts (strip trailing dots with gsub) // Outputs: "memfree memcached" in MB `vmmem=$(vm_stat 2>/dev/null | awk -v ps="$pagesize" '/^Pages free:/{gsub(/[^0-9]/,"",$NF);free=$NF+0} /^Pages speculative:/{gsub(/[^0-9]/,"",$NF);spec=$NF+0} /^Pages inactive:/{gsub(/[^0-9]/,"",$NF);inact=$NF+0} /^Pages purgeable:/{gsub(/[^0-9]/,"",$NF);purg=$NF+0} END{mfree=int((free+spec)*ps/1024/1024);mcached=int((inact+purg)*ps/1024/1024);printf "%d %d",mfree,mcached}')`, `memtotal=$(echo "$memsize" | awk '{printf "%d",$1/1024/1024}')`, `memfree=$(echo "$vmmem" | awk '{print $1}')`, `memcached=$(echo "$vmmem" | awk '{print $2}')`, // Swap `swapraw=$(sysctl vm.swapusage 2>/dev/null)`, `swaptotal=$(echo "$swapraw" | awk '{for(i=1;i<=NF;i++){if($i=="total"&&$(i+1)=="="){v=$(i+2);m=1;if(v~/G/)m=1024;gsub(/[MmGg]/,"",v);st=v*m}};printf "%.0f",st+0}')`, `swapused=$(echo "$swapraw" | awk '{for(i=1;i<=NF;i++){if($i=="used"&&$(i+1)=="="){v=$(i+2);m=1;if(v~/G/)m=1024;gsub(/[MmGg]/,"",v);su=v*m}};printf "%.0f",su+0}')`, `swapfree=$(echo "$swaptotal $swapused" | awk '{printf "%.0f",$1-$2}')`, // Top processes by memory% `procs=$(ps -A -o pid=,%mem=,comm= 2>/dev/null | sort -k2 -rn | head -10 | awk '{gsub(/;/,"_",$3);printf "%s;%.1f;%s,",$1,$2,$3}' | sed 's/,$//')`, // Disk: only show root "/" and external volumes "/Volumes/*", skip system APFS snapshots `disks=$(df -k 2>/dev/null | awk 'NR>1&&index($1,"/dev/")==1&&NF>=9&&($NF=="/"||index($NF,"/Volumes/")==1){u=$3/1048576;t=$2/1048576;p=$5;gsub(/%/,"",p);printf "%s:%.0f:%.0f:%s,",$NF,u,t,p}' | sed 's/,$//')`, // Network: Link# lines only, exclude loopback, detect column shift (no MAC addr → cols shift left) `net=$(netstat -ib 2>/dev/null | awk '/^[a-z]/&&$3~/Link/&&$1!~/^lo/{if($4~/:/){rx=$7;tx=$10}else{rx=$6;tx=$9};if((rx+0)>0){gsub(/[*]/,"",$1);printf "%s:%s:%s,",$1,rx,tx}}' | sed 's/,$//')`, `echo "CPU:$cpupct|CORES:$cores|MEMINFO:$memtotal $memfree 0 $memcached $swaptotal $swapfree|PROCS:$procs|DISKS:$disks|NET:$net"`, ].join('; '); // Command to get CPU (overall + per-core), Memory, Disk, and Network stats // This command is designed to work across most Linux distributions // Note: Using semicolons and avoiding comments for single-line execution // CPU: Output raw values (total and idle) instead of percentage - we calculate delta on backend const linuxStatsCommand = [ // Get number of CPU cores `cores=$(nproc 2>/dev/null || grep -c "^processor" /proc/cpuinfo 2>/dev/null || echo "1")`, // Get raw CPU values from /proc/stat: "total idle" for overall CPU // We output raw values and calculate delta-based percentage on the backend `cpuraw=$(awk '/^cpu / {total=0; for(i=2;i<=NF;i++) total+=$i; printf "%d %d", total, $5}' /proc/stat 2>/dev/null || echo "")`, // Get raw per-core CPU values from /proc/stat: "total:idle,total:idle,..." `percoreraw=$(awk '/^cpu[0-9]/ {total=0; for(i=2;i<=NF;i++) total+=$i; printf "%d:%d,", total, $5}' /proc/stat 2>/dev/null | sed 's/,$//' || echo "")`, // Get memory details from /proc/meminfo (total, free, buffers, cached, swapTotal, swapFree in KB) `meminfo=$(awk '/^MemTotal:/{t=$2} /^MemFree:/{f=$2} /^Buffers:/{b=$2} /^Cached:/{c=$2} /^SReclaimable:/{s=$2} /^SwapTotal:/{st=$2} /^SwapFree:/{sf=$2} END{printf "%d %d %d %d %d %d", t/1024, f/1024, b/1024, (c+s)/1024, st/1024, sf/1024}' /proc/meminfo 2>/dev/null || echo "")`, // Get top 10 processes by memory - with BusyBox fallback // GNU ps: ps -eo pid,%mem,comm --sort=-%mem // BusyBox fallback: ps -o pid,vsz,comm and sort manually (BusyBox ps doesn't have %mem, use vsz instead) `procs=$(ps -eo pid,%mem,comm --sort=-%mem 2>/dev/null | awk 'NR>1 && NR<=11 {gsub(/;/, "_", $3); printf "%s;%.1f;%s,", $1, $2, $3}' | sed 's/,$//' || ps -o pid,vsz,comm 2>/dev/null | awk 'NR>1 {gsub(/;/, "_", $3); print $2, $1, $3}' | sort -rn | head -10 | awk -v total=$(awk '/^MemTotal:/{print $2}' /proc/meminfo) '{if(total>0) pct=$1*100/total; else pct=0; printf "%s;%.1f;%s,", $2, pct, $3}' | sed 's/,$//' || echo "")`, // Get all mounted disk info - with BusyBox fallback // GNU df: df -BG (block size in GB) // BusyBox fallback: df and calculate from 1K blocks, or df -h and parse units `disks=$(df -BG 2>/dev/null | awk 'NR>1 && $1 ~ /^\\/dev/ {gsub(/G/,"",$2); gsub(/G/,"",$3); gsub(/%/,"",$5); printf "%s:%s:%s:%s,", $6, $3, $2, $5}' | sed 's/,$//' || df 2>/dev/null | awk 'NR>1 && $1 ~ /^\\/dev/ {total=$2/1048576; used=$3/1048576; pct=$5; gsub(/%/,"",pct); printf "%s:%.0f:%.0f:%s,", $6, used, total, pct}' | sed 's/,$//' || echo "")`, // Get network interface stats from /proc/net/dev (interface:rx_bytes:tx_bytes), excluding lo and virtual interfaces `net=$(cat /proc/net/dev 2>/dev/null | awk 'NR>2 {gsub(/^[ \\t]+/, ""); split($0, a, ":"); iface=a[1]; if(iface != "lo" && iface !~ /^veth/ && iface !~ /^docker/ && iface !~ /^br-/) {split(a[2], b); printf "%s:%s:%s,", iface, b[1], b[9]}}' | sed 's/,$//' || echo "")`, // Output all stats (using CPURAW and PERCORERAW instead of CPU and PERCORE) `echo "CPURAW:$cpuraw|CORES:$cores|PERCORERAW:$percoreraw|MEMINFO:$meminfo|PROCS:$procs|DISKS:$disks|NET:$net"` ].join('; '); // Auto-detect OS via uname — only Linux and macOS are supported const statsCommand = `ostype=$(uname -s 2>/dev/null || echo "Unknown"); if [ "$ostype" = "Darwin" ]; then ${macosStatsCommand}; elif [ "$ostype" = "Linux" ]; then ${linuxStatsCommand}; else echo "UNSUPPORTED_OS:$ostype"; fi`; return new Promise((resolve) => { const timeout = setTimeout(() => { resolve({ success: false, error: 'Timeout getting server stats' }); }, 5000); conn.exec(statsCommand, (err, stream) => { if (err) { clearTimeout(timeout); resolve({ success: false, error: err.message }); return; } let stdout = ''; let stderr = ''; stream.on('data', (data) => { stdout += data.toString(); }); stream.stderr.on('data', (data) => { stderr += data.toString(); }); stream.on('close', () => { clearTimeout(timeout); // Parse the output const output = stdout.trim(); // Unsupported OS — stop polling this session if (output.startsWith('UNSUPPORTED_OS:')) { resolve({ success: false, error: `Server stats not supported on this OS (${output.substring(15)})` }); return; } const parts = output.split('|'); let cpuDirect = null; // macOS: direct CPU percentage from top let cpuRawTotal = null; let cpuRawIdle = null; let cpuPerCoreRaw = []; // Array of { total, idle } let cpuCores = null; let memTotal = null; let memFree = null; let memBuffers = null; let memCached = null; let memUsed = null; let swapTotal = null; let swapUsed = null; let topProcesses = []; // Array of { pid, memPercent, command } let disks = []; // Array of { mountPoint, used, total, percent } let networkInterfaces = []; // Array of { name, rxBytes, txBytes } for (const part of parts) { if (part.startsWith('CPU:')) { // macOS: top reports CPU% directly (no delta needed) const val = parseFloat(part.substring(4).trim()); if (!isNaN(val)) cpuDirect = Math.min(100, Math.max(0, Math.round(val))); } else if (part.startsWith('CPURAW:')) { const rawParts = part.substring(7).trim().split(/\s+/); if (rawParts.length >= 2) { cpuRawTotal = parseInt(rawParts[0], 10); cpuRawIdle = parseInt(rawParts[1], 10); } } else if (part.startsWith('CORES:')) { const coreStr = part.substring(6).trim(); const val = parseInt(coreStr, 10); if (!isNaN(val) && val > 0) cpuCores = val; } else if (part.startsWith('PERCORERAW:')) { const coreStr = part.substring(11).trim(); if (coreStr && coreStr !== '') { cpuPerCoreRaw = coreStr.split(',').map(v => { const coreParts = v.trim().split(':'); if (coreParts.length >= 2) { const total = parseInt(coreParts[0], 10); const idle = parseInt(coreParts[1], 10); if (!isNaN(total) && !isNaN(idle)) { return { total, idle }; } } return null; }).filter(v => v !== null); } } else if (part.startsWith('MEMINFO:')) { const memParts = part.substring(8).trim().split(/\s+/); if (memParts.length >= 4) { const total = parseInt(memParts[0], 10); const free = parseInt(memParts[1], 10); const buffers = parseInt(memParts[2], 10); const cached = parseInt(memParts[3], 10); if (!isNaN(total)) memTotal = total; if (!isNaN(free)) memFree = free; if (!isNaN(buffers)) memBuffers = buffers; if (!isNaN(cached)) memCached = cached; // Calculate used memory (excluding buffers/cache) if (memTotal !== null && memFree !== null && memBuffers !== null && memCached !== null) { memUsed = memTotal - memFree - memBuffers - memCached; if (memUsed < 0) memUsed = 0; } // Parse swap info (fields 5 and 6) if (memParts.length >= 6) { const st = parseInt(memParts[4], 10); const sf = parseInt(memParts[5], 10); if (!isNaN(st)) swapTotal = st; if (!isNaN(sf)) { swapUsed = (swapTotal !== null) ? swapTotal - sf : null; if (swapUsed !== null && swapUsed < 0) swapUsed = 0; } } } } else if (part.startsWith('PROCS:')) { const procsStr = part.substring(6).trim(); if (procsStr && procsStr !== '') { const procEntries = procsStr.split(','); for (const entry of procEntries) { const procParts = entry.split(';'); // Using ; as delimiter if (procParts.length >= 3) { const pid = procParts[0]; const memPercent = parseFloat(procParts[1]); const command = procParts.slice(2).join(';'); // Command might contain semicolons if (!isNaN(memPercent)) { topProcesses.push({ pid, memPercent, command }); } } } } } else if (part.startsWith('DISKS:')) { const disksStr = part.substring(6).trim(); if (disksStr && disksStr !== '') { const diskEntries = disksStr.split(','); for (const entry of diskEntries) { const diskParts = entry.split(':'); if (diskParts.length >= 4) { const mountPoint = diskParts[0]; const used = parseInt(diskParts[1], 10); const total = parseInt(diskParts[2], 10); const percent = parseInt(diskParts[3], 10); if (!isNaN(used) && !isNaN(total) && !isNaN(percent)) { disks.push({ mountPoint, used, total, percent }); } } } } } else if (part.startsWith('NET:')) { const netStr = part.substring(4).trim(); if (netStr && netStr !== '') { const netEntries = netStr.split(','); for (const entry of netEntries) { const netParts = entry.split(':'); if (netParts.length >= 3) { const name = netParts[0]; const rxBytes = parseInt(netParts[1], 10); const txBytes = parseInt(netParts[2], 10); if (!isNaN(rxBytes) && !isNaN(txBytes)) { networkInterfaces.push({ name, rxBytes, txBytes }); } } } } } } // Calculate network speed based on previous reading const now = Date.now(); const prevNet = session.prevNetStats || { interfaces: [], timestamp: 0 }; const timeDelta = (now - prevNet.timestamp) / 1000; // seconds let netRxSpeed = 0; // bytes per second let netTxSpeed = 0; // bytes per second const netInterfaces = []; if (timeDelta > 0 && prevNet.interfaces.length > 0) { for (const iface of networkInterfaces) { const prevIface = prevNet.interfaces.find(p => p.name === iface.name); if (prevIface) { const rxDelta = iface.rxBytes - prevIface.rxBytes; const txDelta = iface.txBytes - prevIface.txBytes; // Only count positive deltas (handles counter reset) const rxSpeed = rxDelta > 0 ? Math.round(rxDelta / timeDelta) : 0; const txSpeed = txDelta > 0 ? Math.round(txDelta / timeDelta) : 0; netRxSpeed += rxSpeed; netTxSpeed += txSpeed; netInterfaces.push({ name: iface.name, rxBytes: iface.rxBytes, txBytes: iface.txBytes, rxSpeed, txSpeed, }); } else { netInterfaces.push({ name: iface.name, rxBytes: iface.rxBytes, txBytes: iface.txBytes, rxSpeed: 0, txSpeed: 0, }); } } } else { // First reading - no speed data yet for (const iface of networkInterfaces) { netInterfaces.push({ name: iface.name, rxBytes: iface.rxBytes, txBytes: iface.txBytes, rxSpeed: 0, txSpeed: 0, }); } } // Store current reading for next calculation session.prevNetStats = { interfaces: networkInterfaces, timestamp: now, }; // Calculate CPU usage based on delta from previous reading const prevCpu = session.prevCpuStats || { total: 0, idle: 0, perCore: [], timestamp: 0 }; let cpu = null; let cpuPerCore = []; if (cpuRawTotal !== null && cpuRawIdle !== null && prevCpu.total > 0) { const totalDelta = cpuRawTotal - prevCpu.total; const idleDelta = cpuRawIdle - prevCpu.idle; if (totalDelta > 0) { // CPU% = 100 - (idleDelta / totalDelta * 100) cpu = Math.round(100 - (idleDelta / totalDelta * 100)); // Clamp to valid range if (cpu < 0) cpu = 0; if (cpu > 100) cpu = 100; } } // macOS: use direct percentage from top (no delta needed) if (cpu === null && cpuDirect !== null) { cpu = cpuDirect; } // Calculate per-core CPU usage from deltas if (cpuPerCoreRaw.length > 0 && prevCpu.perCore.length > 0) { cpuPerCore = cpuPerCoreRaw.map((core, index) => { const prevCore = prevCpu.perCore[index]; if (prevCore) { const totalDelta = core.total - prevCore.total; const idleDelta = core.idle - prevCore.idle; if (totalDelta > 0) { let usage = Math.round(100 - (idleDelta / totalDelta * 100)); if (usage < 0) usage = 0; if (usage > 100) usage = 100; return usage; } } return 0; }); } else if (cpuPerCoreRaw.length > 0) { // First reading - no delta data yet, return zeros cpuPerCore = cpuPerCoreRaw.map(() => 0); } // Store current CPU reading for next calculation session.prevCpuStats = { total: cpuRawTotal || 0, idle: cpuRawIdle || 0, perCore: cpuPerCoreRaw, timestamp: now, }; // For backward compatibility, extract root disk info const rootDisk = disks.find(d => d.mountPoint === '/'); const diskPercent = rootDisk ? rootDisk.percent : null; const diskUsed = rootDisk ? rootDisk.used : null; const diskTotal = rootDisk ? rootDisk.total : null; // If no meaningful data was parsed, treat as failure to stop futile polling if (cpu === null && memTotal === null && cpuCores === null) { resolve({ success: false, error: 'Unable to parse server stats (unsupported OS or shell)' }); return; } resolve({ success: true, stats: { cpu, // CPU usage percentage (0-100) cpuCores, // Number of CPU cores cpuPerCore, // Per-core CPU usage array memTotal, // Total memory in MB memUsed, // Used memory in MB (excluding buffers/cache) memFree, // Free memory in MB memBuffers, // Buffers in MB memCached, // Cached in MB swapTotal, // Swap total in MB swapUsed, // Swap used in MB topProcesses, // Top 10 processes by memory diskPercent, // Disk usage percentage for root partition (backward compat) diskUsed, // Disk used in GB for root partition (backward compat) diskTotal, // Total disk in GB for root partition (backward compat) disks, // Array of all mounted disks netRxSpeed, // Total network receive speed (bytes/sec) netTxSpeed, // Total network transmit speed (bytes/sec) netInterfaces, // Per-interface network stats }, }); }); }); }); } /** * Set terminal encoding for an active SSH session */ async function setSessionEncoding(_event, { sessionId, encoding }) { const session = sessions?.get(sessionId); if (!session || !session.stream) { return { ok: false, encoding: encoding || "utf-8" }; } const enc = String(encoding || "utf-8").toLowerCase(); if (!iconv.encodingExists(enc)) { return { ok: false, encoding: enc }; } sessionEncodings.set(sessionId, enc); // Reset stateful decoders so new data uses the updated encoding resetSessionDecoders(sessionId); return { ok: true, encoding: enc }; } /** * Register IPC handlers for SSH operations */ function registerHandlers(ipcMain) { ipcMain.handle("netcatty:start", startSSHSessionWrapper); ipcMain.handle("netcatty:ssh:exec", execCommand); ipcMain.handle("netcatty:ssh:pwd", getSessionPwd); ipcMain.handle("netcatty:ssh:remoteInfo", getSessionRemoteInfo); ipcMain.handle("netcatty:ssh:distroInfo", getSessionDistroInfo); ipcMain.handle("netcatty:ssh:listdir", listSessionDir); ipcMain.handle("netcatty:ssh:stats", getServerStats); ipcMain.handle("netcatty:key:generate", generateKeyPair); ipcMain.handle("netcatty:ssh:setEncoding", setSessionEncoding); ipcMain.handle("netcatty:ssh:check-agent", async () => { return await checkWindowsSshAgent(); }); ipcMain.handle("netcatty:ssh:get-default-keys", async () => { const sshDir = path.join(os.homedir(), ".ssh"); const keys = []; try { const entries = await fs.promises.readdir(sshDir); const names = entries.filter(f => SSH_KEY_PATTERN.test(f)); // Preferred first, then rest alphabetically const preferred = PREFERRED_KEY_NAMES.filter(n => names.includes(n)); const rest = names.filter(n => !PREFERRED_KEY_NAMES.includes(n)).sort(); for (const name of [...preferred, ...rest]) { keys.push({ name, path: path.join(sshDir, name) }); } } catch { // ~/.ssh doesn't exist } return keys; }); // Register the shared keyboard-interactive response handler keyboardInteractiveHandler.registerHandler(ipcMain); // Register the passphrase response handler passphraseHandler.registerHandler(ipcMain); } module.exports = { init, registerHandlers, connectThroughChain, buildAlgorithms, };