mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +00:00
Enables SSH certificate and WebAuthn/FIDO2 passkey authentication for both terminal and SFTP connections, including UI for key and certificate selection and passphrase entry. Updates agent and SSH bridge logic to handle certificate, passkey, and fallback methods, and patches signature algorithm handling for certificate auth to ensure correct signature formats and algorithm negotiation. Improves compatibility with modern SSH deployments and enhances security by supporting hardware-backed and certificate-based keys.
846 lines
27 KiB
JavaScript
846 lines
27 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 { Client: SSHClient, utils: sshUtils } = require("ssh2");
|
|
const { registerHandlers: registerWebAuthnHandlers } = require("./webauthnIpc.cjs");
|
|
const { NetcattyAgent } = require("./netcattyAgent.cjs");
|
|
|
|
// Simple file logger for debugging
|
|
const logFile = path.join(require("os").tmpdir(), "netcatty-ssh.log");
|
|
const log = (msg, data) => {
|
|
const line = `[${new Date().toISOString()}] ${msg} ${data ? JSON.stringify(data) : ""}\n`;
|
|
try { fs.appendFileSync(logFile, line); } catch {}
|
|
console.log("[SSH]", msg, data || "");
|
|
};
|
|
|
|
// Session storage - shared reference passed from main
|
|
let sessions = null;
|
|
let electronModule = null;
|
|
|
|
// 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;
|
|
}
|
|
|
|
/**
|
|
* Initialize the SSH bridge with dependencies
|
|
*/
|
|
function init(deps) {
|
|
sessions = deps.sessions;
|
|
electronModule = deps.electronModule;
|
|
}
|
|
|
|
/**
|
|
* Create a socket through a proxy (HTTP CONNECT or SOCKS5)
|
|
*/
|
|
function createProxySocket(proxy, targetHost, targetPort) {
|
|
return new Promise((resolve, reject) => {
|
|
if (proxy.type === 'http') {
|
|
// HTTP CONNECT proxy
|
|
const socket = net.connect(proxy.port, proxy.host, () => {
|
|
let authHeader = '';
|
|
if (proxy.username && proxy.password) {
|
|
const auth = Buffer.from(`${proxy.username}:${proxy.password}`).toString('base64');
|
|
authHeader = `Proxy-Authorization: Basic ${auth}\r\n`;
|
|
}
|
|
const connectRequest = `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\nHost: ${targetHost}:${targetPort}\r\n${authHeader}\r\n`;
|
|
socket.write(connectRequest);
|
|
|
|
let response = '';
|
|
const onData = (data) => {
|
|
response += data.toString();
|
|
if (response.includes('\r\n\r\n')) {
|
|
socket.removeListener('data', onData);
|
|
if (response.startsWith('HTTP/1.1 200') || response.startsWith('HTTP/1.0 200')) {
|
|
resolve(socket);
|
|
} else {
|
|
socket.destroy();
|
|
reject(new Error(`HTTP proxy error: ${response.split('\r\n')[0]}`));
|
|
}
|
|
}
|
|
};
|
|
socket.on('data', onData);
|
|
});
|
|
socket.on('error', reject);
|
|
} else if (proxy.type === 'socks5') {
|
|
// SOCKS5 proxy
|
|
const socket = net.connect(proxy.port, proxy.host, () => {
|
|
// SOCKS5 greeting
|
|
const authMethods = proxy.username && proxy.password ? [0x00, 0x02] : [0x00];
|
|
socket.write(Buffer.from([0x05, authMethods.length, ...authMethods]));
|
|
|
|
let step = 'greeting';
|
|
const onData = (data) => {
|
|
if (step === 'greeting') {
|
|
if (data[0] !== 0x05) {
|
|
socket.destroy();
|
|
reject(new Error('Invalid SOCKS5 response'));
|
|
return;
|
|
}
|
|
const method = data[1];
|
|
if (method === 0x02 && proxy.username && proxy.password) {
|
|
// Username/password auth
|
|
step = 'auth';
|
|
const userBuf = Buffer.from(proxy.username);
|
|
const passBuf = Buffer.from(proxy.password);
|
|
socket.write(Buffer.concat([
|
|
Buffer.from([0x01, userBuf.length]),
|
|
userBuf,
|
|
Buffer.from([passBuf.length]),
|
|
passBuf
|
|
]));
|
|
} else if (method === 0x00) {
|
|
// No auth, proceed to connect
|
|
step = 'connect';
|
|
sendConnectRequest();
|
|
} else {
|
|
socket.destroy();
|
|
reject(new Error('SOCKS5 authentication method not supported'));
|
|
}
|
|
} else if (step === 'auth') {
|
|
if (data[1] !== 0x00) {
|
|
socket.destroy();
|
|
reject(new Error('SOCKS5 authentication failed'));
|
|
return;
|
|
}
|
|
step = 'connect';
|
|
sendConnectRequest();
|
|
} else if (step === 'connect') {
|
|
socket.removeListener('data', onData);
|
|
if (data[1] === 0x00) {
|
|
resolve(socket);
|
|
} else {
|
|
const errors = {
|
|
0x01: 'General failure',
|
|
0x02: 'Connection not allowed',
|
|
0x03: 'Network unreachable',
|
|
0x04: 'Host unreachable',
|
|
0x05: 'Connection refused',
|
|
0x06: 'TTL expired',
|
|
0x07: 'Command not supported',
|
|
0x08: 'Address type not supported',
|
|
};
|
|
socket.destroy();
|
|
reject(new Error(`SOCKS5 error: ${errors[data[1]] || 'Unknown'}`));
|
|
}
|
|
}
|
|
};
|
|
|
|
const sendConnectRequest = () => {
|
|
// SOCKS5 connect request
|
|
const hostBuf = Buffer.from(targetHost);
|
|
const request = Buffer.concat([
|
|
Buffer.from([0x05, 0x01, 0x00, 0x03, hostBuf.length]),
|
|
hostBuf,
|
|
Buffer.from([(targetPort >> 8) & 0xff, targetPort & 0xff])
|
|
]);
|
|
socket.write(request);
|
|
};
|
|
|
|
socket.on('data', onData);
|
|
});
|
|
socket.on('error', reject);
|
|
} else {
|
|
reject(new Error(`Unknown proxy type: ${proxy.type}`));
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Connect through a chain of jump hosts
|
|
*/
|
|
async function connectThroughChain(event, options, jumpHosts, targetHost, targetPort) {
|
|
const sender = event.sender;
|
|
const connections = [];
|
|
let currentSocket = null;
|
|
|
|
const sendProgress = (hop, total, label, status) => {
|
|
if (!sender.isDestroyed()) {
|
|
sender.send("netcatty:chain:progress", { hop, total, label, status });
|
|
}
|
|
};
|
|
|
|
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}:${jump.port || 22}`;
|
|
|
|
sendProgress(i + 1, totalHops + 1, hopLabel, 'connecting');
|
|
|
|
const conn = new SSHClient();
|
|
|
|
// Build connection options
|
|
const connOpts = {
|
|
host: jump.hostname,
|
|
port: jump.port || 22,
|
|
username: jump.username || 'root',
|
|
readyTimeout: 20000, // Reduced from 60s for faster failure detection
|
|
keepaliveInterval: 10000,
|
|
keepaliveCountMax: 3,
|
|
algorithms: {
|
|
// Prioritize fastest ciphers (GCM modes are hardware-accelerated)
|
|
cipher: ['aes128-gcm@openssh.com', 'aes256-gcm@openssh.com', 'aes128-ctr', 'aes256-ctr'],
|
|
// Prioritize faster key exchange
|
|
kex: ['curve25519-sha256', 'curve25519-sha256@libssh.org', 'ecdh-sha2-nistp256', 'ecdh-sha2-nistp384', 'diffie-hellman-group14-sha256'],
|
|
compress: ['none'],
|
|
},
|
|
};
|
|
|
|
// Auth - support agent (webauthn/certificate), key, and password fallback
|
|
const hasCertificate =
|
|
typeof jump.certificate === "string" && jump.certificate.trim().length > 0;
|
|
const hasWebAuthn =
|
|
typeof jump.credentialId === "string"
|
|
&& typeof jump.rpId === "string"
|
|
&& typeof jump.publicKey === "string"
|
|
&& jump.publicKey.trim().length > 0;
|
|
|
|
let authAgent = null;
|
|
if (hasWebAuthn) {
|
|
// Give users time to complete Touch ID / Passkey prompts
|
|
connOpts.readyTimeout = 240000;
|
|
authAgent = new NetcattyAgent({
|
|
mode: "webauthn",
|
|
webContents: event.sender,
|
|
meta: {
|
|
label: jump.keyId || jump.username || "",
|
|
publicKey: jump.publicKey,
|
|
credentialId: jump.credentialId,
|
|
rpId: jump.rpId,
|
|
userVerification: jump.userVerification,
|
|
keySource: jump.keySource,
|
|
},
|
|
});
|
|
connOpts.agent = authAgent;
|
|
} else 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;
|
|
}
|
|
|
|
if (jump.password) connOpts.password = jump.password;
|
|
|
|
if (authAgent) {
|
|
const order = ["agent"];
|
|
if (connOpts.password) order.push("password");
|
|
connOpts.authHandler = order;
|
|
}
|
|
|
|
// If first hop and proxy is configured, connect through proxy
|
|
if (isFirst && options.proxy) {
|
|
currentSocket = await createProxySocket(options.proxy, jump.hostname, jump.port || 22);
|
|
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.on('ready', () => {
|
|
console.log(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} connected`);
|
|
sendProgress(i + 1, totalHops + 1, hopLabel, 'connected');
|
|
resolve();
|
|
});
|
|
conn.on('error', (err) => {
|
|
console.error(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} error:`, err.message);
|
|
sendProgress(i + 1, totalHops + 1, hopLabel, 'error');
|
|
reject(err);
|
|
});
|
|
conn.on('timeout', () => {
|
|
console.error(`[Chain] Hop ${i + 1}/${totalHops}: ${hopLabel} timeout`);
|
|
reject(new Error(`Connection timeout to ${hopLabel}`));
|
|
});
|
|
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) {
|
|
// 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 ||
|
|
`${Date.now()}-${Math.random().toString(16).slice(2)}`;
|
|
|
|
const cols = options.cols || 80;
|
|
const rows = options.rows || 24;
|
|
const sender = event.sender;
|
|
|
|
const sendProgress = (hop, total, label, status) => {
|
|
if (!sender.isDestroyed()) {
|
|
sender.send("netcatty:chain:progress", { hop, total, label, status });
|
|
}
|
|
};
|
|
|
|
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.
|
|
// WebAuthn (Touch ID / browser helper) can be user-interactive and take longer than a typical key auth.
|
|
readyTimeout: 20000, // Fast failure for non-interactive auth
|
|
keepaliveInterval: 10000,
|
|
keepaliveCountMax: 3,
|
|
algorithms: {
|
|
// Prioritize fastest ciphers (GCM modes are hardware-accelerated)
|
|
cipher: ['aes128-gcm@openssh.com', 'aes256-gcm@openssh.com', 'aes128-ctr', 'aes256-ctr'],
|
|
// Prioritize faster key exchange
|
|
kex: ['curve25519-sha256', 'curve25519-sha256@libssh.org', 'ecdh-sha2-nistp256', 'ecdh-sha2-nistp384', 'diffie-hellman-group14-sha256'],
|
|
compress: ['none'],
|
|
},
|
|
// Enable debug logging for SSH connection troubleshooting
|
|
debug: (msg) => {
|
|
log("SSH DEBUG", msg);
|
|
},
|
|
};
|
|
|
|
// Authentication for final target
|
|
const hasCertificate = typeof options.certificate === "string" && options.certificate.trim().length > 0;
|
|
const hasWebAuthn =
|
|
typeof options.credentialId === "string"
|
|
&& typeof options.rpId === "string"
|
|
&& typeof options.publicKey === "string"
|
|
&& options.publicKey.trim().length > 0;
|
|
|
|
console.log("[SSH] Auth configuration:", {
|
|
hasCertificate,
|
|
hasWebAuthn,
|
|
keySource: options.keySource,
|
|
hasCredentialId: !!options.credentialId,
|
|
hasRpId: !!options.rpId,
|
|
hasPublicKey: !!options.publicKey,
|
|
});
|
|
|
|
log("Auth configuration", {
|
|
hasCertificate,
|
|
hasWebAuthn,
|
|
keySource: options.keySource,
|
|
hasCredentialId: !!options.credentialId,
|
|
hasRpId: !!options.rpId,
|
|
hasPublicKey: !!options.publicKey,
|
|
});
|
|
|
|
let authAgent = null;
|
|
if (hasWebAuthn) {
|
|
// Give users time to complete Touch ID / Passkey prompts (browser helper can take time).
|
|
connectOpts.readyTimeout = 240000;
|
|
authAgent = new NetcattyAgent({
|
|
mode: "webauthn",
|
|
webContents: event.sender,
|
|
meta: {
|
|
label: options.keyId || options.username || "",
|
|
publicKey: options.publicKey,
|
|
credentialId: options.credentialId,
|
|
rpId: options.rpId,
|
|
userVerification: options.userVerification,
|
|
keySource: options.keySource,
|
|
},
|
|
});
|
|
connectOpts.agent = authAgent;
|
|
} else if (hasCertificate) {
|
|
authAgent = new NetcattyAgent({
|
|
mode: "certificate",
|
|
webContents: event.sender,
|
|
meta: {
|
|
label: options.keyId || options.username || "",
|
|
certificate: options.certificate,
|
|
privateKey: options.privateKey,
|
|
passphrase: options.passphrase,
|
|
},
|
|
});
|
|
connectOpts.agent = authAgent;
|
|
} else if (options.privateKey) {
|
|
connectOpts.privateKey = options.privateKey;
|
|
if (options.passphrase) {
|
|
connectOpts.passphrase = options.passphrase;
|
|
}
|
|
}
|
|
|
|
if (options.password) {
|
|
connectOpts.password = options.password;
|
|
}
|
|
|
|
// Agent forwarding
|
|
if (options.agentForwarding) {
|
|
connectOpts.agentForward = true;
|
|
if (!connectOpts.agent) {
|
|
if (process.platform === "win32") {
|
|
connectOpts.agent = "\\\\.\\pipe\\openssh-ssh-agent";
|
|
} else {
|
|
connectOpts.agent = process.env.SSH_AUTH_SOCK;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prefer agent-based auth when we created an in-process agent (cert/webauthn)
|
|
if (authAgent) {
|
|
const order = ["agent"];
|
|
// Allow password fallback if provided
|
|
if (connectOpts.password) order.push("password");
|
|
connectOpts.authHandler = order;
|
|
}
|
|
|
|
// Handle chain/proxy connections
|
|
if (hasJumpHosts) {
|
|
const chainResult = await connectThroughChain(
|
|
event,
|
|
options,
|
|
jumpHosts,
|
|
options.hostname,
|
|
options.port || 22
|
|
);
|
|
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;
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
conn.on("ready", () => {
|
|
console.log(`[Chain] Final target ${options.hostname} ready`);
|
|
if (hasJumpHosts || hasProxy) {
|
|
sendProgress(totalHops, totalHops, options.hostname, 'connected');
|
|
}
|
|
|
|
conn.shell(
|
|
{
|
|
term: "xterm-256color",
|
|
cols,
|
|
rows,
|
|
},
|
|
{
|
|
env: {
|
|
LANG: resolveLangFromCharset(options.charset),
|
|
COLORTERM: "truecolor",
|
|
...(options.env || {}),
|
|
},
|
|
},
|
|
(err, stream) => {
|
|
if (err) {
|
|
conn.end();
|
|
for (const c of chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
const session = {
|
|
conn,
|
|
stream,
|
|
chainConnections,
|
|
webContentsId: event.sender.id,
|
|
};
|
|
sessions.set(sessionId, session);
|
|
|
|
// 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 = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
contents?.send("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);
|
|
}
|
|
};
|
|
|
|
stream.on("data", (data) => {
|
|
bufferData(data.toString("utf8"));
|
|
});
|
|
|
|
stream.stderr?.on("data", (data) => {
|
|
bufferData(data.toString("utf8"));
|
|
});
|
|
|
|
stream.on("close", () => {
|
|
// Flush any remaining data before close
|
|
if (flushTimeout) {
|
|
clearTimeout(flushTimeout);
|
|
}
|
|
flushBuffer();
|
|
const contents = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 0 });
|
|
sessions.delete(sessionId);
|
|
conn.end();
|
|
for (const c of chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
});
|
|
|
|
// Run startup command if specified
|
|
if (options.startupCommand) {
|
|
setTimeout(() => {
|
|
stream.write(`${options.startupCommand}\n`);
|
|
}, 300);
|
|
}
|
|
|
|
resolve({ sessionId });
|
|
}
|
|
);
|
|
});
|
|
|
|
conn.on("error", (err) => {
|
|
console.error(`[Chain] Final target ${options.hostname} error:`, err.message);
|
|
const contents = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
|
|
const isAuthError = err.message?.toLowerCase().includes('authentication') ||
|
|
err.message?.toLowerCase().includes('auth') ||
|
|
err.message?.toLowerCase().includes('password') ||
|
|
err.level === 'client-authentication';
|
|
|
|
if (isAuthError) {
|
|
contents?.send("netcatty:auth:failed", {
|
|
sessionId,
|
|
error: err.message,
|
|
hostname: options.hostname
|
|
});
|
|
}
|
|
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 1, error: err.message });
|
|
sessions.delete(sessionId);
|
|
for (const c of chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
reject(err);
|
|
});
|
|
|
|
conn.on("timeout", () => {
|
|
console.error(`[Chain] Final target ${options.hostname} connection timeout`);
|
|
const err = new Error(`Connection timeout to ${options.hostname}`);
|
|
const contents = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 1, error: err.message });
|
|
sessions.delete(sessionId);
|
|
for (const c of chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
reject(err);
|
|
});
|
|
|
|
conn.on("close", () => {
|
|
const contents = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 0 });
|
|
sessions.delete(sessionId);
|
|
for (const c of chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
});
|
|
|
|
console.log(`[Chain] Connecting to final target ${options.hostname}...`);
|
|
conn.connect(connectOpts);
|
|
});
|
|
} catch (err) {
|
|
console.error("[Chain] SSH chain connection error:", err.message);
|
|
const contents = electronModule.BrowserWindow.fromWebContents(event.sender)?.webContents;
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 1, error: err.message });
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Execute a one-off command via SSH
|
|
*/
|
|
async function execCommand(event, payload) {
|
|
return new Promise((resolve, reject) => {
|
|
const conn = new SSHClient();
|
|
let stdout = "";
|
|
let stderr = "";
|
|
let settled = false;
|
|
const timeoutMs = payload.timeout || 10000;
|
|
const timer = setTimeout(() => {
|
|
if (settled) return;
|
|
settled = true;
|
|
conn.end();
|
|
reject(new Error("SSH exec timeout"));
|
|
}, timeoutMs);
|
|
|
|
conn
|
|
.on("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;
|
|
reject(err);
|
|
})
|
|
.on("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 hasWebAuthn =
|
|
typeof payload.credentialId === "string"
|
|
&& typeof payload.rpId === "string"
|
|
&& typeof payload.publicKey === "string"
|
|
&& payload.publicKey.trim().length > 0;
|
|
|
|
const connectOpts = {
|
|
host: payload.hostname,
|
|
port: payload.port || 22,
|
|
username: payload.username,
|
|
readyTimeout: timeoutMs,
|
|
keepaliveInterval: 0,
|
|
};
|
|
|
|
let authAgent = null;
|
|
if (hasWebAuthn) {
|
|
authAgent = new NetcattyAgent({
|
|
mode: "webauthn",
|
|
webContents: event.sender,
|
|
meta: {
|
|
label: payload.keyId || payload.username || "",
|
|
publicKey: payload.publicKey,
|
|
credentialId: payload.credentialId,
|
|
rpId: payload.rpId,
|
|
userVerification: payload.userVerification,
|
|
keySource: payload.keySource,
|
|
},
|
|
});
|
|
connectOpts.agent = authAgent;
|
|
} else 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 (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',
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for SSH operations
|
|
*/
|
|
function registerHandlers(ipcMain) {
|
|
registerWebAuthnHandlers(ipcMain);
|
|
ipcMain.handle("netcatty:start", startSSHSession);
|
|
ipcMain.handle("netcatty:ssh:exec", execCommand);
|
|
ipcMain.handle("netcatty:key:generate", generateKeyPair);
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
registerHandlers,
|
|
createProxySocket,
|
|
startSSHSession,
|
|
execCommand,
|
|
generateKeyPair,
|
|
};
|