mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
1104 lines
42 KiB
JavaScript
1104 lines
42 KiB
JavaScript
/**
|
|
* 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 hostKeyVerifier = require("./hostKeyVerifier.cjs");
|
|
const { createProxySocket } = require("./proxyUtils.cjs");
|
|
const { attachX11Forwarding } = require("./x11Forwarding.cjs");
|
|
const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
|
|
const {
|
|
buildAuthHandler,
|
|
createKeyboardInteractiveHandler,
|
|
applyAuthToConnOpts,
|
|
safeSend: authSafeSend,
|
|
requestPassphrasesForEncryptedKeys,
|
|
findAllDefaultPrivateKeys: findAllDefaultPrivateKeysFromHelper,
|
|
getSshAgentSocket,
|
|
readFileNoFollow,
|
|
expandIdentityFilePath,
|
|
isAutoFillablePasswordChallenge,
|
|
preparePrivateKeyForAuth,
|
|
loadIdentityFileForAuth,
|
|
loadFirstIdentityFileForAuth,
|
|
hasUserConfiguredKey,
|
|
PassphraseCancelledError,
|
|
isPassphraseCancelledError,
|
|
} = require("./sshAuthHelper.cjs");
|
|
const sessionLogStreamManager = require("./sessionLogStreamManager.cjs");
|
|
const { trackSessionIdlePrompt, looksLikeIdleAutoLogout } = require("./ai/shellUtils.cjs");
|
|
const { createZmodemSentry } = require("./zmodemHelper.cjs");
|
|
const tempDirBridge = require("./tempDirBridge.cjs");
|
|
const {
|
|
buildAlgorithms,
|
|
_resetAlgorithmSupportCacheForTests,
|
|
} = require("./sshAlgorithms.cjs");
|
|
const { enableSshNoDelay, enableTcpNoDelay } = require("./tcpNoDelay.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, "'\\''") + "'";
|
|
}
|
|
|
|
function hasUsableProxy(proxy) {
|
|
if (!proxy) return false;
|
|
if (proxy.type === "command") return !!proxy.command?.trim();
|
|
return !!(proxy.host && proxy.port);
|
|
}
|
|
|
|
/**
|
|
* 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<Array<{ privateKey: string, keyPath: string, keyName: string }>>}
|
|
*/
|
|
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 SSH_DEBUG_REDACTED_KEYS = new Set([
|
|
"password",
|
|
"passphrase",
|
|
"privateKey",
|
|
"key",
|
|
"certificate",
|
|
]);
|
|
let sshDebugLoggingEnabled = process.env.NETCATTY_SSH_DEBUG === "1";
|
|
let sshDebugLogFilePath = tempDirBridge.getTempFilePath("netcatty-ssh.log");
|
|
|
|
function sanitizeSshDebugValue(value, key = "") {
|
|
if (SSH_DEBUG_REDACTED_KEYS.has(key)) return "[redacted]";
|
|
if (Array.isArray(value)) return value.map((item) => sanitizeSshDebugValue(item));
|
|
if (value && typeof value === "object") {
|
|
const result = {};
|
|
for (const [entryKey, entryValue] of Object.entries(value)) {
|
|
result[entryKey] = sanitizeSshDebugValue(entryValue, entryKey);
|
|
}
|
|
return result;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function setSshDebugLoggingEnabled(enabled, options = {}) {
|
|
sshDebugLoggingEnabled = !!enabled;
|
|
if (typeof options.logFilePath === "string" && options.logFilePath.trim()) {
|
|
sshDebugLogFilePath = options.logFilePath;
|
|
}
|
|
}
|
|
|
|
function isSshDebugLoggingEnabled() {
|
|
return sshDebugLoggingEnabled;
|
|
}
|
|
|
|
function getSshDebugLogFilePath() {
|
|
return sshDebugLogFilePath;
|
|
}
|
|
|
|
function appendSshDiagnosticLog(msg, data, options = {}) {
|
|
const enabled = Object.prototype.hasOwnProperty.call(options, "enabled")
|
|
? !!options.enabled
|
|
: isSshDebugLoggingEnabled();
|
|
if (!enabled) return;
|
|
const safeData = data ? sanitizeSshDebugValue(data) : undefined;
|
|
const line = `[${new Date().toISOString()}] ${msg} ${safeData ? JSON.stringify(safeData) : ""}\n`;
|
|
try { fs.appendFileSync(sshDebugLogFilePath, line); } catch { }
|
|
console.log("[SSH]", msg, safeData ? JSON.stringify(safeData, null, 2) : "");
|
|
}
|
|
|
|
const log = appendSshDiagnosticLog;
|
|
log.isEnabled = isSshDebugLoggingEnabled;
|
|
|
|
function createSshDiagnosticLogger(enabled) {
|
|
const isEnabled = !!enabled;
|
|
const logger = (msg, data) => appendSshDiagnosticLog(msg, data, { enabled: isEnabled });
|
|
logger.isEnabled = () => isEnabled;
|
|
return logger;
|
|
}
|
|
|
|
function shouldLogSshDebugMessage(msg) {
|
|
if (typeof msg !== "string") return false;
|
|
return /auth|publickey|keyboard|handshake|kex|newkeys|dh gex/i.test(msg);
|
|
}
|
|
|
|
function attachSshDebugLogger(connectOpts, logger = log) {
|
|
if (typeof logger.isEnabled === "function" && !logger.isEnabled()) return;
|
|
connectOpts.debug = (msg) => {
|
|
if (shouldLogSshDebugMessage(msg)) {
|
|
logger("ssh2 debug", { msg });
|
|
}
|
|
};
|
|
}
|
|
|
|
function logSshAlgorithms(label, algorithms, extra = {}, logger = log) {
|
|
logger(`${label} algorithm configuration`, {
|
|
...extra,
|
|
kex: algorithms.kex,
|
|
cipher: algorithms.cipher,
|
|
hmac: algorithms.hmac,
|
|
serverHostKey: algorithms.serverHostKey,
|
|
});
|
|
}
|
|
|
|
async function getSshDebugLogInfo() {
|
|
let size = 0;
|
|
let exists = false;
|
|
try {
|
|
const stat = await fs.promises.stat(sshDebugLogFilePath);
|
|
exists = stat.isFile();
|
|
size = stat.size;
|
|
} catch {
|
|
exists = false;
|
|
}
|
|
return {
|
|
enabled: isSshDebugLoggingEnabled(),
|
|
path: sshDebugLogFilePath,
|
|
exists,
|
|
size,
|
|
};
|
|
}
|
|
|
|
async function openSshDebugLogDir() {
|
|
if (!electronModule?.shell?.openPath) return { success: false, error: "shell unavailable" };
|
|
try {
|
|
await fs.promises.mkdir(path.dirname(sshDebugLogFilePath), { recursive: true });
|
|
const error = await electronModule.shell.openPath(path.dirname(sshDebugLogFilePath));
|
|
return error ? { success: false, error } : { success: true };
|
|
} catch (err) {
|
|
return { success: false, error: err?.message || String(err) };
|
|
}
|
|
}
|
|
|
|
// 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");
|
|
const { encodeTerminalInput, normalizeTerminalEncoding } = require("./terminalEncoding.cjs");
|
|
|
|
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";
|
|
}
|
|
if (normalizeTerminalEncoding(trimmed) === "gb18030" && !trimmed.includes(".")) {
|
|
return "zh_CN.GB18030";
|
|
}
|
|
return trimmed;
|
|
}
|
|
|
|
const { safeSend } = require("./ipcUtils.cjs");
|
|
const {
|
|
createConnectionRef,
|
|
acquireConnectionRef,
|
|
releaseConnectionRef,
|
|
findReusableSession,
|
|
} = require("./sshConnectionPool.cjs");
|
|
|
|
const zmodemOverwritePending = new Map(); // requestId -> (decision) => void
|
|
|
|
/**
|
|
* 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 || [];
|
|
const sshDiagnosticLogger = options?._sshDiagnosticLogger || log;
|
|
const keyboardInteractiveScope = options?._keyboardInteractiveScope || "terminal";
|
|
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;
|
|
}
|
|
|
|
// Per-hop keepalive. Each jump entry already carries its own resolved
|
|
// interval/countMax (see resolveHostKeepalive in domain/host.ts), so
|
|
// a chain with a router as the bastion and a cloud host at the end
|
|
// can have keepalive=0 on the bastion and the cloud-friendly values
|
|
// on the final target — without one stepping on the other. We fall
|
|
// back to the target-call options for backward compat with older
|
|
// serializers that don't populate the per-hop fields yet.
|
|
const hopInterval = jump.keepaliveInterval ?? options.keepaliveInterval ?? 0;
|
|
const hopCountMax = jump.keepaliveCountMax ?? options.keepaliveCountMax ?? 10;
|
|
// 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)
|
|
keepaliveInterval: hopInterval > 0 ? hopInterval * 1000 : 0,
|
|
keepaliveCountMax: hopInterval > 0 ? hopCountMax : 0,
|
|
// Enable keyboard-interactive authentication (required for 2FA/MFA)
|
|
tryKeyboard: true,
|
|
// Per-hop algorithm settings. Two distinct semantics:
|
|
//
|
|
// - `legacyAlgorithms` is *append-only* — it widens the offered
|
|
// list — so falling back to the target's setting when the hop
|
|
// didn't override is safe and matches the historic chain-wide
|
|
// behavior (a user with a single old leaf only needs to flip
|
|
// the toggle on the leaf).
|
|
//
|
|
// - `skipEcdsaHostKey` and `algorithmOverrides` *narrow* the
|
|
// offered list (the first removes every `ecdsa-sha2-*`, the
|
|
// second replaces a category outright). Propagating those to
|
|
// a bastion that doesn't need them can lock the hop to
|
|
// algorithms it doesn't accept — e.g. an Ed25519-only bastion
|
|
// would still negotiate while ECDSA was offered, but breaks
|
|
// when the leaf's ECDSA skip is applied to it. Treat both as
|
|
// strictly per-host: an unset hop value uses the hop's default
|
|
// offer, not the leaf's narrower setting.
|
|
algorithms: buildAlgorithms(
|
|
jump.legacyAlgorithms ?? options.legacyAlgorithms,
|
|
{
|
|
skipEcdsaHostKey: jump.skipEcdsaHostKey,
|
|
algorithmOverrides: jump.algorithmOverrides,
|
|
},
|
|
),
|
|
};
|
|
connOpts.hostVerifier = hostKeyVerifier.createHostVerifier({
|
|
sender,
|
|
sessionId,
|
|
hostname: jump.hostname,
|
|
port: jump.port || 22,
|
|
knownHosts: options.knownHosts,
|
|
verifyHostKeys: jump.verifyHostKeys ?? options.verifyHostKeys,
|
|
});
|
|
attachSshDebugLogger(connOpts, sshDiagnosticLogger);
|
|
logSshAlgorithms("Jump host", connOpts.algorithms, {
|
|
hostname: jump.hostname,
|
|
port: jump.port || 22,
|
|
legacyAlgorithms: !!(jump.legacyAlgorithms ?? options.legacyAlgorithms),
|
|
skipEcdsaHostKey: !!jump.skipEcdsaHostKey,
|
|
hasAlgorithmOverrides: !!jump.algorithmOverrides,
|
|
}, sshDiagnosticLogger);
|
|
|
|
// Auth - support agent (certificate), key, password, and default key fallback
|
|
const hasCertificate =
|
|
typeof jump.certificate === "string" && jump.certificate.trim().length > 0;
|
|
|
|
const identityFile = !jump.privateKey
|
|
? await loadFirstIdentityFileForAuth({
|
|
sender,
|
|
identityFilePaths: jump.identityFilePaths,
|
|
hostname: hopLabel,
|
|
initialPassphrase: jump.passphrase,
|
|
passphraseSignal: options._passphraseSignal,
|
|
logPrefix: `[Chain] Hop ${i + 1}:`,
|
|
onLoaded: (loaded) => {
|
|
if (loaded.passphrase) {
|
|
sendProgress(i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'passphrase required');
|
|
}
|
|
console.log(`[Chain] Hop ${i + 1}: loaded identity file ${loaded.keyPath}`);
|
|
},
|
|
onError: (err, keyPath) => {
|
|
console.warn(`[Chain] Hop ${i + 1}: failed to read identity file ${keyPath}:`, err.message);
|
|
},
|
|
})
|
|
: null;
|
|
const inlineKey = jump.privateKey
|
|
? await preparePrivateKeyForAuth({
|
|
sender,
|
|
privateKey: jump.privateKey,
|
|
keyId: jump.keyId,
|
|
keyName: jump.keyId || jump.label || jump.username,
|
|
hostname: hopLabel,
|
|
initialPassphrase: jump.passphrase,
|
|
passphraseSignal: options._passphraseSignal,
|
|
logPrefix: `[Chain] Hop ${i + 1}:`,
|
|
})
|
|
: null;
|
|
const effectivePrivateKey = inlineKey?.privateKey || identityFile?.privateKey;
|
|
const effectivePassphrase = inlineKey?.passphrase || identityFile?.passphrase;
|
|
|
|
let authAgent = null;
|
|
if (hasCertificate) {
|
|
authAgent = new NetcattyAgent({
|
|
mode: "certificate",
|
|
webContents: event.sender,
|
|
meta: {
|
|
label: jump.keyId || jump.username || "",
|
|
certificate: jump.certificate,
|
|
privateKey: effectivePrivateKey,
|
|
passphrase: effectivePassphrase,
|
|
},
|
|
});
|
|
connOpts.agent = authAgent;
|
|
} else if (effectivePrivateKey) {
|
|
connOpts.privateKey = effectivePrivateKey;
|
|
if (effectivePassphrase) {
|
|
connOpts.passphrase = effectivePassphrase;
|
|
} else if (jump.privateKey && 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,
|
|
false,
|
|
{ signal: options._passphraseSignal }
|
|
);
|
|
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 PassphraseCancelledError(hopLabel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 = hasUsableProxy(jump.proxy);
|
|
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)
|
|
conn.on('keyboard-interactive', createKeyboardInteractiveHandler({
|
|
sender,
|
|
sessionId,
|
|
hostname: hopLabel,
|
|
password: jump.password,
|
|
logPrefix: `[Chain] Hop ${i + 1}/${totalHops}`,
|
|
scope: keyboardInteractiveScope,
|
|
onAutoFill: () => sendProgress(
|
|
i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'using saved password',
|
|
),
|
|
onPromptShown: () => sendProgress(
|
|
i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'waiting for user input...',
|
|
),
|
|
onUserResponded: () => sendProgress(
|
|
i + 1, totalHops + 1, hopLabel, 'auth-attempt', 'user responded',
|
|
),
|
|
}));
|
|
console.log(`[Chain] Hop ${i + 1}/${totalHops}: Connecting to ${hopLabel}...`);
|
|
conn.once('connect', () => enableSshNoDelay(conn));
|
|
if (connOpts.sock) enableTcpNoDelay(connOpts.sock);
|
|
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
|
|
*/
|
|
const { createStartSessionApi } = require("./sshBridge/startSession.cjs");
|
|
const startSessionApi = createStartSessionApi({
|
|
get sessions() { return sessions; },
|
|
get electronModule() { return electronModule; },
|
|
SSHClient, sshUtils, NetcattyAgent, keyboardInteractiveHandler, passphraseHandler, hostKeyVerifier,
|
|
fs, path, os, net, crypto, Buffer, process, console, setTimeout, clearTimeout,
|
|
createProxySocket, attachX11Forwarding, createPtyOutputBuffer, sessionLogStreamManager,
|
|
trackSessionIdlePrompt, looksLikeIdleAutoLogout, createZmodemSentry, enableSshNoDelay, enableTcpNoDelay,
|
|
iconv, getSessionDecoder, resetSessionDecoders, sessionEncodings, sessionDecoders, encodeTerminalInput,
|
|
normalizeTerminalEncoding,
|
|
connectThroughChain, getAvailableAgentSocket, getCachedAuthMethod, setCachedAuthMethod, clearCachedAuthMethod,
|
|
attachSshDebugLogger, logSshAlgorithms, resolveLangFromCharset, safeSend, zmodemOverwritePending,
|
|
shouldLogSshDebugMessage, log, createSshDiagnosticLogger,
|
|
buildAlgorithms, randomUUID, findDefaultPrivateKey, findAllDefaultPrivateKeys,
|
|
preparePrivateKeyForAuth, loadFirstIdentityFileForAuth, hasUserConfiguredKey, createKeyboardInteractiveHandler,
|
|
createConnectionRef, acquireConnectionRef, releaseConnectionRef, findReusableSession,
|
|
get probeReceiveConflicts() { return probeReceiveConflicts; },
|
|
get removeRemoteFiles() { return removeRemoteFiles; },
|
|
get restoreRemoteModes() { return restoreRemoteModes; },
|
|
});
|
|
const { startSSHSession } = startSessionApi;
|
|
const { createExecCommandApi } = require("./sshBridge/execCommand.cjs");
|
|
const execCommandApi = createExecCommandApi({
|
|
SSHClient, NetcattyAgent, randomUUID, console, setTimeout, clearTimeout, Error,
|
|
findAllDefaultPrivateKeysFromHelper, preparePrivateKeyForAuth, loadIdentityFileForAuth,
|
|
isPassphraseCancelledError, buildAlgorithms, buildAuthHandler, applyAuthToConnOpts,
|
|
createKeyboardInteractiveHandler,
|
|
});
|
|
const { execCommand } = execCommandApi;
|
|
|
|
/**
|
|
* 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) {
|
|
// Only purge cached passphrases if the error is specifically
|
|
// a passphrase/key-parsing failure, not a generic auth rejection.
|
|
const retryMsg = (retryErr.message || '').toLowerCase();
|
|
const isPassphraseError = retryMsg.includes('bad passphrase') ||
|
|
retryMsg.includes('integrity check failed') ||
|
|
retryMsg.includes('cannot parse privatekey');
|
|
if (isPassphraseError) {
|
|
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.
|
|
*/
|
|
// Companion stats connection for Mosh sessions (issue #1198). Mosh runs over
|
|
// UDP and has no ssh2 connection, so getServerStats cannot open an exec
|
|
// channel. This helper lazily establishes a best-effort, non-interactive
|
|
// SSH connection reusing the handshake credentials and assigns it to
|
|
// session.conn so the existing stats path works unchanged.
|
|
const { createSystemKnownHostsApi } = require("./sshBridge/systemKnownHosts.cjs");
|
|
// Lets the Mosh stats companion trust a host whose key is already recorded in
|
|
// the user's system OpenSSH known_hosts (the trust source the Mosh handshake's
|
|
// system `ssh` actually uses), in addition to Netcatty's in-app vault.
|
|
const { isHostKeyTrustedBySystem } = createSystemKnownHostsApi({
|
|
fs, path, os, crypto, log,
|
|
});
|
|
|
|
const { createMoshStatsConnectionApi } = require("./sshBridge/moshStatsConnection.cjs");
|
|
const { ensureMoshStatsConnection, ensureEtStatsConnection } = createMoshStatsConnectionApi({
|
|
get sessions() { return sessions; },
|
|
SSHClient, sshUtils, NetcattyAgent, buildAlgorithms, getSshAgentSocket,
|
|
readFileNoFollow, expandIdentityFilePath, isAutoFillablePasswordChallenge,
|
|
hostKeyVerifier, isHostKeyTrustedBySystem, log,
|
|
});
|
|
|
|
const { createSessionOpsApi } = require("./sshBridge/sessionOps.cjs");
|
|
const sessionOpsApi = createSessionOpsApi({
|
|
get sessions() { return sessions; },
|
|
get electronModule() { return electronModule; },
|
|
fs, path, os, exec, randomUUID, iconv, Buffer, process, console, setTimeout, clearTimeout,
|
|
getSessionDecoder, resetSessionDecoders, sessionEncodings, normalizeTerminalEncoding,
|
|
resolveLangFromCharset, safeSend,
|
|
quoteShellArg, log, ensureMoshStatsConnection, ensureEtStatsConnection,
|
|
execOnEtSession: (...args) => require("./terminalBridge.cjs").execOnEtSession(...args),
|
|
getServerStats: undefined,
|
|
});
|
|
const {
|
|
getSessionRemoteInfo,
|
|
getSessionDistroInfo,
|
|
readRemoteHistory,
|
|
getSessionPwd,
|
|
probeReceiveConflicts,
|
|
removeRemoteFiles,
|
|
restoreRemoteModes,
|
|
listSessionDir,
|
|
getServerStats,
|
|
setSessionEncoding,
|
|
} = sessionOpsApi;
|
|
|
|
/**
|
|
* 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:readRemoteHistory", readRemoteHistory);
|
|
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:sshDebugLog:info", getSshDebugLogInfo);
|
|
ipcMain.handle("netcatty:sshDebugLog:openDir", openSshDebugLogDir);
|
|
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;
|
|
});
|
|
ipcMain.on("netcatty:zmodem:overwrite-response", (_event, payload) => {
|
|
const resolve = zmodemOverwritePending.get(payload?.requestId);
|
|
if (resolve) { zmodemOverwritePending.delete(payload.requestId); resolve(payload); }
|
|
});
|
|
// Register the shared keyboard-interactive response handler
|
|
keyboardInteractiveHandler.registerHandler(ipcMain);
|
|
// Register the passphrase response handler
|
|
passphraseHandler.registerHandler(ipcMain);
|
|
// Register the SSH host key verification response handler
|
|
hostKeyVerifier.registerHandler(ipcMain);
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
registerHandlers,
|
|
connectThroughChain,
|
|
buildAlgorithms,
|
|
_resetAlgorithmSupportCacheForTests,
|
|
_appendSshDiagnosticLog: appendSshDiagnosticLog,
|
|
_createSshDiagnosticLogger: createSshDiagnosticLogger,
|
|
_getSshDebugLogFilePath: getSshDebugLogFilePath,
|
|
_setSshDebugLoggingEnabled: setSshDebugLoggingEnabled,
|
|
_shouldLogSshDebugMessage: shouldLogSshDebugMessage,
|
|
// Exposed for the default-key dedupe characterization test (the connect path
|
|
// derives the preferred default key from findAllDefaultPrivateKeys()[0]).
|
|
_findDefaultPrivateKey: findDefaultPrivateKey,
|
|
_findAllDefaultPrivateKeys: findAllDefaultPrivateKeys,
|
|
ensureMoshStatsConnection,
|
|
};
|