mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
641 lines
19 KiB
TypeScript
641 lines
19 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import {
|
|
clearKeyPassphrasesByIds,
|
|
clearReferenceKeyPassphrases,
|
|
deleteVaultKey,
|
|
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<string, string>();
|
|
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("deleting a reference key also forgets its remembered passphrase", async (t) => {
|
|
installLocalStorage(t);
|
|
const key = referenceKey();
|
|
let keys = [key];
|
|
await saveDefaultKeyPassphrase(key.filePath!, "remembered-passphrase");
|
|
|
|
await deleteVaultKey({
|
|
keyId: key.id,
|
|
getKeys: () => keys,
|
|
updateKeys: (updated) => {
|
|
keys = updated;
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(keys, []);
|
|
assert.equal(await loadDefaultKeyPassphrase(key.filePath!), null);
|
|
});
|
|
|
|
test("deleting one reference keeps the passphrase while another key uses the same file", async (t) => {
|
|
installLocalStorage(t);
|
|
const key = referenceKey();
|
|
const duplicate = { ...key, id: "duplicate-reference" };
|
|
let keys = [key, duplicate];
|
|
await saveDefaultKeyPassphrase(key.filePath!, "remembered-passphrase");
|
|
|
|
await deleteVaultKey({
|
|
keyId: key.id,
|
|
getKeys: () => keys,
|
|
updateKeys: (updated) => {
|
|
keys = updated;
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(keys, [duplicate]);
|
|
assert.equal(
|
|
await loadDefaultKeyPassphrase(key.filePath!),
|
|
"remembered-passphrase",
|
|
);
|
|
});
|
|
|
|
test("deleting a key cannot overwrite a concurrent key-list update", async (t) => {
|
|
installLocalStorage(t);
|
|
const key = referenceKey();
|
|
const concurrentReference = { ...key, id: "concurrent-reference" };
|
|
let keys = [key];
|
|
await saveDefaultKeyPassphrase(key.filePath!, "remembered-passphrase");
|
|
let releaseHomeLookup: (() => void) | undefined;
|
|
const homeLookup = new Promise<void>((resolve) => {
|
|
releaseHomeLookup = resolve;
|
|
});
|
|
let homeLookupCount = 0;
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: { netcatty: { getHomeDir: async () => {
|
|
homeLookupCount += 1;
|
|
await homeLookup;
|
|
return "/Users/alice";
|
|
} } },
|
|
});
|
|
|
|
const deletion = deleteVaultKey({
|
|
keyId: key.id,
|
|
getKeys: () => keys,
|
|
updateKeys: (updated) => {
|
|
keys = updated;
|
|
},
|
|
});
|
|
assert.deepEqual(keys, []);
|
|
keys = [concurrentReference];
|
|
releaseHomeLookup?.();
|
|
await deletion;
|
|
|
|
assert.deepEqual(keys, [concurrentReference]);
|
|
assert.equal(homeLookupCount, 1);
|
|
assert.equal(
|
|
await loadDefaultKeyPassphrase(key.filePath!),
|
|
"remembered-passphrase",
|
|
);
|
|
});
|
|
|
|
test("deleting a Windows reference clears remembered path aliases", async (t) => {
|
|
installLocalStorage(t);
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: { netcatty: { getHomeDir: async () => "C:\\Users\\Alice" } },
|
|
});
|
|
const key = {
|
|
...referenceKey(),
|
|
filePath: "~/.ssh/id_ed25519",
|
|
};
|
|
let keys = [key];
|
|
globalThis.localStorage.setItem(
|
|
STORAGE_KEY_DEFAULT_KEY_PASSPHRASES,
|
|
JSON.stringify({
|
|
"~/.ssh/id_ed25519": "old-relative",
|
|
"C:\\Users\\Alice\\.ssh\\id_ed25519": "old-native",
|
|
"C:/Users/Alice/.ssh/id_ed25519": "old-normalized",
|
|
"C:/Users/Alice/.ssh/other": "keep",
|
|
}),
|
|
);
|
|
|
|
await deleteVaultKey({
|
|
keyId: key.id,
|
|
getKeys: () => keys,
|
|
updateKeys: (updated) => {
|
|
keys = updated;
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(keys, []);
|
|
assert.deepEqual(
|
|
JSON.parse(globalThis.localStorage.getItem(STORAGE_KEY_DEFAULT_KEY_PASSPHRASES) ?? "{}"),
|
|
{ "C:/Users/Alice/.ssh/other": "keep" },
|
|
);
|
|
});
|
|
|
|
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<void>((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<void>((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<string, string>;
|
|
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<void>((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<void> | undefined;
|
|
const updateStarted = new Promise<void>((resolve) => {
|
|
const updateKeys = async (updated: SSHKey[]) => {
|
|
assert.equal(currentKeys[0].passphrase, "saved");
|
|
assert.equal(updated[0].passphrase, "saved");
|
|
resolve();
|
|
await new Promise<void>((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;
|
|
});
|