Files
Netcatty/electron/preload.cjs
T
LAPTOP-O016UC3M\Qi Chen d719dfdc69 Add integrated FIDO2 SSH key generation workflow
Implements a comprehensive UI and backend bridge for FIDO2 hardware and platform authenticator SSH key creation, including device selection, PIN entry, and touch prompts. Modernizes the key generation panel with enhanced options, feedback, and error handling, and establishes Electron IPC support for seamless device communication.

Improves security, user experience, and support for modern authentication hardware.
2025-12-16 11:40:43 +08:00

556 lines
19 KiB
JavaScript

const { ipcRenderer, contextBridge } = require("electron");
const dataListeners = new Map();
const exitListeners = new Map();
const transferProgressListeners = new Map();
const transferCompleteListeners = new Map();
const transferErrorListeners = new Map();
const chainProgressListeners = new Map();
const authFailedListeners = new Map();
// FIDO2 key generation listeners
const fido2PinRequestListeners = new Map();
const fido2TouchPromptListeners = new Map();
// WebAuthn requests from main process
const base64UrlToUint8 = (b64url) => {
if (typeof b64url !== "string") throw new Error("Invalid base64url value");
const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
const bin = atob(padded);
const out = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
return out;
};
const uint8ToBase64Url = (bytes) => {
let binary = "";
const chunkSize = 0x8000;
for (let i = 0; i < bytes.length; i += chunkSize) {
binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
}
return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
};
ipcRenderer.on("netcatty:webauthn:request", async (_event, payload) => {
const requestId = payload?.requestId;
try {
if (!requestId || typeof requestId !== "string") throw new Error("Missing requestId");
if (!window.PublicKeyCredential) throw new Error("WebAuthn is not supported in this environment");
if (!window.isSecureContext) throw new Error("WebAuthn requires a secure context (HTTPS/localhost)");
const credentialId = payload?.credentialId;
const challenge = payload?.challenge;
const rpId = payload?.rpId;
const userVerification = payload?.userVerification || "preferred";
const timeout = payload?.timeoutMs || 180000;
if (typeof credentialId !== "string" || !credentialId) throw new Error("Missing credentialId");
if (typeof challenge !== "string" || !challenge) throw new Error("Missing challenge");
if (typeof rpId !== "string" || !rpId) throw new Error("Missing rpId");
const idBytes = base64UrlToUint8(credentialId);
const challengeBytes = base64UrlToUint8(challenge);
const credential = await navigator.credentials.get({
publicKey: {
rpId,
challenge: challengeBytes,
allowCredentials: [
{
type: "public-key",
id: idBytes,
},
],
userVerification,
timeout,
},
});
if (!credential) throw new Error("Credential assertion was cancelled");
const assertion = credential;
const response = assertion.response;
const origin = window.location.origin || "";
const authenticatorData = uint8ToBase64Url(new Uint8Array(response.authenticatorData));
const clientDataJSON = uint8ToBase64Url(new Uint8Array(response.clientDataJSON));
const signature = uint8ToBase64Url(new Uint8Array(response.signature));
const userHandle = response.userHandle
? uint8ToBase64Url(new Uint8Array(response.userHandle))
: null;
ipcRenderer.send("netcatty:webauthn:response", {
requestId,
ok: true,
result: {
origin,
authenticatorData,
clientDataJSON,
signature,
userHandle,
},
});
} catch (err) {
ipcRenderer.send("netcatty:webauthn:response", {
requestId,
ok: false,
error: err?.message || String(err),
});
}
});
ipcRenderer.on("netcatty:data", (_event, payload) => {
const set = dataListeners.get(payload.sessionId);
if (!set) return;
set.forEach((cb) => {
try {
cb(payload.data);
} catch (err) {
console.error("Data callback failed", err);
}
});
});
ipcRenderer.on("netcatty:exit", (_event, payload) => {
const set = exitListeners.get(payload.sessionId);
if (set) {
set.forEach((cb) => {
try {
cb(payload);
} catch (err) {
console.error("Exit callback failed", err);
}
});
}
dataListeners.delete(payload.sessionId);
exitListeners.delete(payload.sessionId);
});
// Chain progress events (for jump host connections)
ipcRenderer.on("netcatty:chain:progress", (_event, payload) => {
const { hop, total, label, status } = payload;
// Notify all registered chain progress listeners
chainProgressListeners.forEach((cb) => {
try {
cb(hop, total, label, status);
} catch (err) {
console.error("Chain progress callback failed", err);
}
});
});
// FIDO2 PIN request events
ipcRenderer.on("netcatty:fido2:pinRequest", (_event, payload) => {
const { requestId } = payload;
fido2PinRequestListeners.forEach((cb) => {
try {
cb(requestId);
} catch (err) {
console.error("FIDO2 PIN request callback failed", err);
}
});
});
// FIDO2 touch prompt events
ipcRenderer.on("netcatty:fido2:touchPrompt", (_event, payload) => {
const { requestId } = payload;
fido2TouchPromptListeners.forEach((cb) => {
try {
cb(requestId);
} catch (err) {
console.error("FIDO2 touch prompt callback failed", err);
}
});
});
// Authentication failed events
ipcRenderer.on("netcatty:auth:failed", (_event, payload) => {
const set = authFailedListeners.get(payload.sessionId);
if (set) {
set.forEach((cb) => {
try {
cb(payload);
} catch (err) {
console.error("Auth failed callback failed", err);
}
});
}
});
// Transfer progress events
ipcRenderer.on("netcatty:transfer:progress", (_event, payload) => {
const cb = transferProgressListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.transferred, payload.totalBytes, payload.speed);
} catch (err) {
console.error("Transfer progress callback failed", err);
}
}
});
ipcRenderer.on("netcatty:transfer:complete", (_event, payload) => {
const cb = transferCompleteListeners.get(payload.transferId);
if (cb) {
try {
cb();
} catch (err) {
console.error("Transfer complete callback failed", err);
}
}
// Cleanup listeners
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:transfer:error", (_event, payload) => {
const cb = transferErrorListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.error);
} catch (err) {
console.error("Transfer error callback failed", err);
}
}
// Cleanup listeners
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:transfer:cancelled", (_event, payload) => {
// Just cleanup listeners, the UI already knows it's cancelled
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
// Upload with progress listeners
const uploadProgressListeners = new Map();
const uploadCompleteListeners = new Map();
const uploadErrorListeners = new Map();
ipcRenderer.on("netcatty:upload:progress", (_event, payload) => {
const cb = uploadProgressListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.transferred, payload.totalBytes, payload.speed);
} catch (err) {
console.error("Upload progress callback failed", err);
}
}
});
ipcRenderer.on("netcatty:upload:complete", (_event, payload) => {
const cb = uploadCompleteListeners.get(payload.transferId);
if (cb) {
try {
cb();
} catch (err) {
console.error("Upload complete callback failed", err);
}
}
// Cleanup listeners
uploadProgressListeners.delete(payload.transferId);
uploadCompleteListeners.delete(payload.transferId);
uploadErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:upload:error", (_event, payload) => {
const cb = uploadErrorListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.error);
} catch (err) {
console.error("Upload error callback failed", err);
}
}
// Cleanup listeners
uploadProgressListeners.delete(payload.transferId);
uploadCompleteListeners.delete(payload.transferId);
uploadErrorListeners.delete(payload.transferId);
});
// Port forwarding status listeners
const portForwardStatusListeners = new Map();
ipcRenderer.on("netcatty:portforward:status", (_event, payload) => {
const { tunnelId, status, error } = payload;
const callbacks = portForwardStatusListeners.get(tunnelId);
if (callbacks) {
callbacks.forEach((cb) => {
try {
cb(status, error);
} catch (err) {
console.error("Port forward status callback failed", err);
}
});
}
});
const api = {
startSSHSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:start", options);
return result.sessionId;
},
startTelnetSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:telnet:start", options);
return result.sessionId;
},
startMoshSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:mosh:start", options);
return result.sessionId;
},
startLocalSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:local:start", options || {});
return result.sessionId;
},
writeToSession: (sessionId, data) => {
ipcRenderer.send("netcatty:write", { sessionId, data });
},
execCommand: async (options) => {
return ipcRenderer.invoke("netcatty:ssh:exec", options);
},
generateKeyPair: async (options) => {
return ipcRenderer.invoke("netcatty:key:generate", options);
},
resizeSession: (sessionId, cols, rows) => {
ipcRenderer.send("netcatty:resize", { sessionId, cols, rows });
},
closeSession: (sessionId) => {
ipcRenderer.send("netcatty:close", { sessionId });
},
onSessionData: (sessionId, cb) => {
if (!dataListeners.has(sessionId)) dataListeners.set(sessionId, new Set());
dataListeners.get(sessionId).add(cb);
return () => dataListeners.get(sessionId)?.delete(cb);
},
onSessionExit: (sessionId, cb) => {
if (!exitListeners.has(sessionId)) exitListeners.set(sessionId, new Set());
exitListeners.get(sessionId).add(cb);
return () => exitListeners.get(sessionId)?.delete(cb);
},
onAuthFailed: (sessionId, cb) => {
if (!authFailedListeners.has(sessionId)) authFailedListeners.set(sessionId, new Set());
authFailedListeners.get(sessionId).add(cb);
return () => authFailedListeners.get(sessionId)?.delete(cb);
},
openSftp: async (options) => {
const result = await ipcRenderer.invoke("netcatty:sftp:open", options);
return result.sftpId;
},
listSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:list", { sftpId, path });
},
readSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:read", { sftpId, path });
},
writeSftp: async (sftpId, path, content) => {
return ipcRenderer.invoke("netcatty:sftp:write", { sftpId, path, content });
},
closeSftp: async (sftpId) => {
return ipcRenderer.invoke("netcatty:sftp:close", { sftpId });
},
mkdirSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:mkdir", { sftpId, path });
},
deleteSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:delete", { sftpId, path });
},
renameSftp: async (sftpId, oldPath, newPath) => {
return ipcRenderer.invoke("netcatty:sftp:rename", { sftpId, oldPath, newPath });
},
statSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:stat", { sftpId, path });
},
chmodSftp: async (sftpId, path, mode) => {
return ipcRenderer.invoke("netcatty:sftp:chmod", { sftpId, path, mode });
},
// Write binary with real-time progress callback
writeSftpBinaryWithProgress: async (sftpId, path, content, transferId, onProgress, onComplete, onError) => {
// Register callbacks
if (onProgress) uploadProgressListeners.set(transferId, onProgress);
if (onComplete) uploadCompleteListeners.set(transferId, onComplete);
if (onError) uploadErrorListeners.set(transferId, onError);
return ipcRenderer.invoke("netcatty:sftp:writeBinaryWithProgress", {
sftpId,
path,
content,
transferId
});
},
// Local filesystem operations
listLocalDir: async (path) => {
return ipcRenderer.invoke("netcatty:local:list", { path });
},
readLocalFile: async (path) => {
return ipcRenderer.invoke("netcatty:local:read", { path });
},
writeLocalFile: async (path, content) => {
return ipcRenderer.invoke("netcatty:local:write", { path, content });
},
deleteLocalFile: async (path) => {
return ipcRenderer.invoke("netcatty:local:delete", { path });
},
renameLocalFile: async (oldPath, newPath) => {
return ipcRenderer.invoke("netcatty:local:rename", { oldPath, newPath });
},
mkdirLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:mkdir", { path });
},
statLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:stat", { path });
},
getHomeDir: async () => {
return ipcRenderer.invoke("netcatty:local:homedir");
},
getSystemInfo: async () => {
return ipcRenderer.invoke("netcatty:system:info");
},
// Read system known_hosts file
readKnownHosts: async () => {
return ipcRenderer.invoke("netcatty:known-hosts:read");
},
setTheme: async (theme) => {
return ipcRenderer.invoke("netcatty:setTheme", theme);
},
// Streaming transfer with real progress
startStreamTransfer: async (options, onProgress, onComplete, onError) => {
const { transferId } = options;
// Register callbacks
if (onProgress) transferProgressListeners.set(transferId, onProgress);
if (onComplete) transferCompleteListeners.set(transferId, onComplete);
if (onError) transferErrorListeners.set(transferId, onError);
return ipcRenderer.invoke("netcatty:transfer:start", options);
},
cancelTransfer: async (transferId) => {
// Cleanup listeners
transferProgressListeners.delete(transferId);
transferCompleteListeners.delete(transferId);
transferErrorListeners.delete(transferId);
return ipcRenderer.invoke("netcatty:transfer:cancel", { transferId });
},
// Window controls for custom title bar
windowMinimize: () => ipcRenderer.invoke("netcatty:window:minimize"),
windowMaximize: () => ipcRenderer.invoke("netcatty:window:maximize"),
windowClose: () => ipcRenderer.invoke("netcatty:window:close"),
windowIsMaximized: () => ipcRenderer.invoke("netcatty:window:isMaximized"),
// Settings window
openSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:open"),
closeSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:close"),
// Cloud sync session (in-memory only, shared across windows)
cloudSyncSetSessionPassword: (password) =>
ipcRenderer.invoke("netcatty:cloudSync:session:setPassword", password),
cloudSyncGetSessionPassword: () =>
ipcRenderer.invoke("netcatty:cloudSync:session:getPassword"),
cloudSyncClearSessionPassword: () =>
ipcRenderer.invoke("netcatty:cloudSync:session:clearPassword"),
// Open URL in default browser
openExternal: (url) => ipcRenderer.invoke("netcatty:openExternal", url),
// WebAuthn browser fallback (primarily for macOS Touch ID prompt issues)
webauthnCreateCredentialInBrowser: (options) =>
ipcRenderer.invoke("netcatty:webauthn:browser:create", options),
webauthnGetAssertionInBrowser: (options) =>
ipcRenderer.invoke("netcatty:webauthn:browser:get", options),
// Port Forwarding API
startPortForward: async (options) => {
return ipcRenderer.invoke("netcatty:portforward:start", options);
},
stopPortForward: async (tunnelId) => {
return ipcRenderer.invoke("netcatty:portforward:stop", { tunnelId });
},
getPortForwardStatus: async (tunnelId) => {
return ipcRenderer.invoke("netcatty:portforward:status", { tunnelId });
},
listPortForwards: async () => {
return ipcRenderer.invoke("netcatty:portforward:list");
},
onPortForwardStatus: (tunnelId, cb) => {
if (!portForwardStatusListeners.has(tunnelId)) {
portForwardStatusListeners.set(tunnelId, new Set());
}
portForwardStatusListeners.get(tunnelId).add(cb);
return () => {
portForwardStatusListeners.get(tunnelId)?.delete(cb);
if (portForwardStatusListeners.get(tunnelId)?.size === 0) {
portForwardStatusListeners.delete(tunnelId);
}
};
},
// Chain progress listener for jump host connections
onChainProgress: (cb) => {
const id = Date.now().toString() + Math.random().toString(16).slice(2);
chainProgressListeners.set(id, cb);
return () => {
chainProgressListeners.delete(id);
};
},
// OAuth callback server
startOAuthCallback: (expectedState) => ipcRenderer.invoke("oauth:startCallback", expectedState),
cancelOAuthCallback: () => ipcRenderer.invoke("oauth:cancelCallback"),
// GitHub Device Flow (proxied via main process to avoid CORS)
githubStartDeviceFlow: (options) => ipcRenderer.invoke("netcatty:github:deviceFlow:start", options),
githubPollDeviceFlowToken: (options) => ipcRenderer.invoke("netcatty:github:deviceFlow:poll", options),
// Google OAuth (proxied via main process to avoid CORS)
googleExchangeCodeForTokens: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:exchange", options),
googleRefreshAccessToken: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:refresh", options),
googleGetUserInfo: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:userinfo", options),
// Google Drive API (proxied via main process to avoid CORS/COEP issues in renderer)
googleDriveFindSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:findSyncFile", options),
googleDriveCreateSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:createSyncFile", options),
googleDriveUpdateSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:updateSyncFile", options),
googleDriveDownloadSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:downloadSyncFile", options),
googleDriveDeleteSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:deleteSyncFile", options),
// FIDO2 SSH Key Generation API
fido2ListDevices: () =>
ipcRenderer.invoke("netcatty:fido2:listDevices"),
fido2CheckSupport: () =>
ipcRenderer.invoke("netcatty:fido2:checkSupport"),
fido2Generate: (options) =>
ipcRenderer.invoke("netcatty:fido2:generate", options),
fido2SubmitPin: (requestId, pin) =>
ipcRenderer.invoke("netcatty:fido2:submitPin", { requestId, pin }),
fido2CancelPin: (requestId) =>
ipcRenderer.invoke("netcatty:fido2:cancelPin", { requestId }),
fido2Cancel: (requestId) =>
ipcRenderer.invoke("netcatty:fido2:cancel", { requestId }),
fido2GetSshKeygenPath: () =>
ipcRenderer.invoke("netcatty:fido2:getSshKeygenPath"),
onFido2PinRequest: (cb) => {
const id = Date.now().toString() + Math.random().toString(16).slice(2);
fido2PinRequestListeners.set(id, cb);
return () => fido2PinRequestListeners.delete(id);
},
onFido2TouchPrompt: (cb) => {
const id = Date.now().toString() + Math.random().toString(16).slice(2);
fido2TouchPromptListeners.set(id, cb);
return () => fido2TouchPromptListeners.delete(id);
},
};
// Merge with existing netcatty (if any) to avoid stale objects on hot reload
const existing = (typeof window !== "undefined" && window.netcatty) ? window.netcatty : {};
contextBridge.exposeInMainWorld("netcatty", { ...existing, ...api });