import test from "node:test"; import assert from "node:assert/strict"; import { clearKeyPassphrasesByIds, clearReferenceKeyPassphrases, loadDefaultKeyPassphrase, rememberKeyPassphrase, removeDefaultKeyPassphraseAliases, saveDefaultKeyPassphrase, shouldUpdateReferenceKeyPassphrase, } from "../defaultKeyPassphrases"; import { STORAGE_KEY_DEFAULT_KEY_PASSPHRASES } from "../../infrastructure/config/storageKeys"; import type { SSHKey } from "../../domain/models"; function installLocalStorage(t: test.TestContext): void { const store = new Map(); const storage: Storage = { get length() { return store.size; }, clear() { store.clear(); }, getItem(key: string) { return store.get(key) ?? null; }, key(index: number) { return Array.from(store.keys())[index] ?? null; }, removeItem(key: string) { store.delete(key); }, setItem(key: string, value: string) { store.set(key, value); }, }; Object.defineProperty(globalThis, "localStorage", { configurable: true, value: storage, }); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: undefined }, }); t.after(() => { Reflect.deleteProperty(globalThis, "localStorage"); Reflect.deleteProperty(globalThis, "window"); }); } const referenceKey = (): SSHKey => ({ id: "reference-key", label: "id_ed25519", type: "ED25519", category: "key", source: "reference", filePath: "/Users/alice/.ssh/id_ed25519", privateKey: "", created: 1, }); test("loadDefaultKeyPassphrase removes undecryptable credential placeholders", async (t) => { installLocalStorage(t); const keyPath = "/Users/alice/.ssh/id_ed25519"; globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ [keyPath]: "enc:v1:djEwYWJj", "/Users/alice/.ssh/id_rsa": "still-valid", }), ); const result = await loadDefaultKeyPassphrase(keyPath); assert.equal(result, null); assert.deepEqual( JSON.parse(globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}"), { "/Users/alice/.ssh/id_rsa": "still-valid" }, ); }); test("loadDefaultKeyPassphrase cleanup preserves a passphrase saved concurrently", async (t) => { installLocalStorage(t); let releaseFirstHomeLookup: (() => void) | undefined; const firstHomeLookup = new Promise((resolve) => { releaseFirstHomeLookup = resolve; }); let homeLookupCount = 0; Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => { homeLookupCount += 1; if (homeLookupCount === 1) await firstHomeLookup; return "/Users/alice"; }, }, }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "/Users/alice/.ssh/id_old": "enc:v1:djEwYWJj" }), ); const pendingLoad = loadDefaultKeyPassphrase("/Users/alice/.ssh/id_old"); await saveDefaultKeyPassphrase("/Users/alice/.ssh/id_new", "new-passphrase"); releaseFirstHomeLookup?.(); assert.equal(await pendingLoad, null); assert.equal( await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_new"), "new-passphrase", ); }); test("loadDefaultKeyPassphrase retries when the same path is saved concurrently", async (t) => { installLocalStorage(t); let releaseFirstHomeLookup: (() => void) | undefined; const firstHomeLookup = new Promise((resolve) => { releaseFirstHomeLookup = resolve; }); let homeLookupCount = 0; Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => { homeLookupCount += 1; if (homeLookupCount === 1) await firstHomeLookup; return "/Users/alice"; }, }, }, }); const keyPath = "/Users/alice/.ssh/id_ed25519"; globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ [keyPath]: "old-passphrase" }), ); const pendingLoad = loadDefaultKeyPassphrase(keyPath); await saveDefaultKeyPassphrase(keyPath, "new-passphrase"); releaseFirstHomeLookup?.(); assert.equal(await pendingLoad, "new-passphrase"); }); test("loadDefaultKeyPassphrase returns plain stored passphrases", async (t) => { installLocalStorage(t); const keyPath = "/Users/alice/.ssh/id_ed25519"; globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ [keyPath]: "correct horse battery staple" }), ); assert.equal(await loadDefaultKeyPassphrase(keyPath), "correct horse battery staple"); }); test("saveDefaultKeyPassphrase makes the passphrase available to the connection prompt", async (t) => { installLocalStorage(t); const keyPath = "/Users/alice/.ssh/id_ed25519"; await saveDefaultKeyPassphrase(keyPath, "saved by agent"); assert.equal(await loadDefaultKeyPassphrase(keyPath), "saved by agent"); }); test("loadDefaultKeyPassphrase matches an expanded connection path to a saved home-relative path", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice", }, }, }); await saveDefaultKeyPassphrase("~/.ssh/id_ed25519", "saved by agent"); assert.equal( await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_ed25519"), "saved by agent", ); }); test("loadDefaultKeyPassphrase prefers an exact saved path over a stale alias", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "~/.ssh/id_ed25519": "enc:v1:djEwYWJj", "/Users/alice/.ssh/id_ed25519": "valid-exact-passphrase", }), ); assert.equal( await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_ed25519"), "valid-exact-passphrase", ); assert.deepEqual( JSON.parse(globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}"), { "/Users/alice/.ssh/id_ed25519": "valid-exact-passphrase" }, ); }); test("loadDefaultKeyPassphrase falls back to a valid alias and removes an invalid exact value", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "~/.ssh/id_ed25519": "valid-alias-passphrase", "/Users/alice/.ssh/id_ed25519": "enc:v1:djEwYWJj", }), ); assert.equal( await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_ed25519"), "valid-alias-passphrase", ); assert.deepEqual( JSON.parse(globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}"), { "~/.ssh/id_ed25519": "valid-alias-passphrase" }, ); }); test("loadDefaultKeyPassphrase consolidates conflicting valid aliases around the exact path", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "~/.ssh/id_ed25519": "old-alias-passphrase", "/Users/alice/.ssh/id_ed25519": "new-exact-passphrase", }), ); assert.equal( await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_ed25519"), "new-exact-passphrase", ); assert.equal( await loadDefaultKeyPassphrase("~/.ssh/id_ed25519"), "new-exact-passphrase", ); }); test("saveDefaultKeyPassphrase replaces stale values stored under path aliases", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "~/.ssh/id_ed25519": "old-relative", "/Users/alice/.ssh/id_ed25519": "old-absolute", }), ); await saveDefaultKeyPassphrase("~/.ssh/id_ed25519", "replacement"); const stored = JSON.parse( globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}", ) as Record; assert.equal(stored["/Users/alice/.ssh/id_ed25519"], undefined); assert.equal(await loadDefaultKeyPassphrase("/Users/alice/.ssh/id_ed25519"), "replacement"); }); test("removeDefaultKeyPassphraseAliases clears relative and expanded paths", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ "~/.ssh/id_ed25519": "old-relative", "/Users/alice/.ssh/id_ed25519": "old-absolute", "/Users/alice/.ssh/other": "keep", }), ); const aliases = await removeDefaultKeyPassphraseAliases(["~/.ssh/id_ed25519"]); assert.deepEqual(new Set(aliases), new Set([ "~/.ssh/id_ed25519", "/Users/alice/.ssh/id_ed25519", ])); assert.deepEqual( JSON.parse(globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}"), { "/Users/alice/.ssh/other": "keep" }, ); const clearedKeys = clearReferenceKeyPassphrases([ { ...referenceKey(), passphrase: "old", savePassphrase: true }, ], aliases); assert.equal(clearedKeys[0].passphrase, undefined); assert.equal(clearedKeys[0].savePassphrase, false); }); test("removeDefaultKeyPassphraseAliases preserves a corrected passphrase saved during alias lookup", async (t) => { installLocalStorage(t); let releaseFirstHomeLookup: (() => void) | undefined; const firstHomeLookup = new Promise((resolve) => { releaseFirstHomeLookup = resolve; }); let homeLookupCount = 0; Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => { homeLookupCount += 1; if (homeLookupCount === 1) await firstHomeLookup; return "/Users/alice"; }, }, }, }); const keyPath = "/Users/alice/.ssh/id_ed25519"; globalThis.localStorage.setItem( STORAGE_KEY_DEFAULT_KEY_PASSPHRASES, JSON.stringify({ [keyPath]: "old-passphrase" }), ); const pendingRemoval = removeDefaultKeyPassphraseAliases([keyPath]); await saveDefaultKeyPassphrase(keyPath, "corrected-passphrase"); releaseFirstHomeLookup?.(); assert.deepEqual(await pendingRemoval, []); assert.equal(await loadDefaultKeyPassphrase(keyPath), "corrected-passphrase"); }); test("rememberKeyPassphrase updates a reference key stored under an expanded alias", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "/Users/alice" } }, }); let updatedKeys: SSHKey[] | undefined; await rememberKeyPassphrase({ keyPath: "~/.ssh/id_ed25519", passphrase: "replacement", keys: [{ ...referenceKey(), passphrase: "old", savePassphrase: true }], updateKeys: (keys) => { updatedKeys = keys; }, }); assert.equal(updatedKeys?.[0].passphrase, "replacement"); assert.equal(updatedKeys?.[0].savePassphrase, true); }); test("path aliases replace and clear Windows reference-key spellings", async (t) => { installLocalStorage(t); Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: { getHomeDir: async () => "C:\\Users\\Alice" } }, }); const windowsReferenceKey: SSHKey = { ...referenceKey(), filePath: "c:\\users\\alice\\.ssh\\id_ed25519", passphrase: "old", savePassphrase: true, }; let updatedKeys: SSHKey[] | undefined; await rememberKeyPassphrase({ keyPath: "~/.ssh/id_ed25519", passphrase: "replacement", keys: [windowsReferenceKey], updateKeys: (keys) => { updatedKeys = keys; }, }); assert.equal(updatedKeys?.[0].passphrase, "replacement"); assert.equal( await loadDefaultKeyPassphrase("C:\\Users\\Alice\\.ssh\\id_ed25519"), "replacement", ); const aliases = await removeDefaultKeyPassphraseAliases(["~/.ssh/id_ed25519"]); const clearedKeys = clearReferenceKeyPassphrases(updatedKeys ?? [], aliases); assert.equal(clearedKeys[0].passphrase, undefined); assert.equal(await loadDefaultKeyPassphrase("c:\\users\\alice\\.ssh\\id_ed25519"), null); }); test("POSIX backslashes remain distinct from path separators", async (t) => { installLocalStorage(t); await saveDefaultKeyPassphrase("/home/alice/.ssh/team\\key", "backslash-name"); await saveDefaultKeyPassphrase("/home/alice/.ssh/team/key", "nested-path"); assert.equal( await loadDefaultKeyPassphrase("/home/alice/.ssh/team\\key"), "backslash-name", ); assert.equal( await loadDefaultKeyPassphrase("/home/alice/.ssh/team/key"), "nested-path", ); }); test("clearReferenceKeyPassphrases clears matching reference key paths only", () => { const keys: SSHKey[] = [ { ...referenceKey(), passphrase: "bad", savePassphrase: true, }, { ...referenceKey(), id: "other-key", label: "other", filePath: "/Users/alice/.ssh/other", passphrase: "keep", savePassphrase: true, }, ]; const updated = clearReferenceKeyPassphrases(keys, ["/Users/alice/.ssh/id_ed25519"]); assert.equal(updated[0].passphrase, undefined); assert.equal(updated[0].savePassphrase, false); assert.equal(updated[1].passphrase, "keep"); }); test("clearKeyPassphrasesByIds clears matching saved key passphrases", () => { const keys: SSHKey[] = [ { ...referenceKey(), id: "inline-key", source: "imported", filePath: undefined, privateKey: "PRIVATE KEY", passphrase: "bad", savePassphrase: true, }, { ...referenceKey(), id: "other-key", label: "other", passphrase: "keep", savePassphrase: true, }, ]; const updated = clearKeyPassphrasesByIds(keys, ["inline-key"]); assert.equal(updated[0].passphrase, undefined); assert.equal(updated[0].savePassphrase, false); assert.equal(updated[1].passphrase, "keep"); }); test("shouldUpdateReferenceKeyPassphrase replaces missing or undecryptable passphrases", () => { assert.equal(shouldUpdateReferenceKeyPassphrase(null), false); assert.equal(shouldUpdateReferenceKeyPassphrase(referenceKey()), true); assert.equal( shouldUpdateReferenceKeyPassphrase({ ...referenceKey(), passphrase: "enc:v1:djEwAAAA", }), true, ); assert.equal( shouldUpdateReferenceKeyPassphrase({ ...referenceKey(), passphrase: "saved", }), false, ); }); test("rememberKeyPassphrase updates reference key state before completing", async (t) => { installLocalStorage(t); const keys = [referenceKey()]; let currentKeys = keys; let releaseUpdate: (() => void) | undefined; let rememberPromise: Promise | undefined; const updateStarted = new Promise((resolve) => { const updateKeys = async (updated: SSHKey[]) => { assert.equal(currentKeys[0].passphrase, "saved"); assert.equal(updated[0].passphrase, "saved"); resolve(); await new Promise((release) => { releaseUpdate = release; }); }; rememberPromise = rememberKeyPassphrase({ keyPath: "/Users/alice/.ssh/id_ed25519", passphrase: "saved", keys, updateKeys, setCurrentKeys: (updated) => { currentKeys = updated; }, }); }); await updateStarted; assert.equal(currentKeys[0].passphrase, "saved"); releaseUpdate?.(); await rememberPromise; });