sliftutils 1.7.127 → 1.7.129

package/security/authorizedKeys/daemon/git.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
 import { spawnPromise } from "../../helpers/spawn";
-import { sourceKeyPath, sourceRepoPath } from "../sources";
+import { findSourceKey, sourceKeyPath, sourceRepoPath } from "../sources";
 import { GIT_TIMEOUT, MAX_ERROR_BODY_LENGTH } from "./paths";
 import { sourceState } from "./state";
 
@@ -68,7 +68,7 @@ export async function currentBranch(config: { repoPath: string; keyPath: string
 
 async function ensureSourceRepo(repoURL: string) {
     let repoPath = sourceRepoPath(repoURL);
-    let keyPath = sourceKeyPath(repoURL);
+    let keyPath = await findSourceKey(repoURL) || sourceKeyPath(repoURL);
     if (!await repoIsUsable({ repoPath, keyPath })) {
         await cloneRepo({ repoURL, repoPath, keyPath });
     }
@@ -82,7 +82,7 @@ async function ensureSourceRepo(repoURL: string) {
 export async function syncRepo(repoURL: string) {
     await ensureSourceRepo(repoURL);
     let repoPath = sourceRepoPath(repoURL);
-    let keyPath = sourceKeyPath(repoURL);
+    let keyPath = await findSourceKey(repoURL) || sourceKeyPath(repoURL);
     let branch = sourceState(repoURL).branch;
     let localSha = (await runGit({ args: ["rev-parse", "HEAD"], cwd: repoPath, keyPath })).stdout.trim();
 

package/security/authorizedKeys/daemon/notify.ts

@@ -11,8 +11,14 @@ export function setHostLabel(value: string) {
 // notification is only ever added when the user explicitly asks for that specific case. Startup,
 // success, errors, retries and recoveries all belong in console.log instead. The complete list of
 // cases that are allowed to notify is at the top of daemon.ts.
-export async function notify(message: string) {
-    let full = `**portsecure [${hostLabelValue || os.hostname()}]**: ${message}`;
+/** A headline and the rest.
+
+    The headline is all a phone shows. It gets the whole preview to itself: no product name, no
+    host, no timestamp in front of it, because a person glancing at their lock screen needs to read
+    what happened, not which machine said it or when. Those go at the end, where they are there for
+    whoever opens the message and out of the way of whoever does not. */
+export async function notify(headline: string, body: string) {
+    let full = `**${headline}**\n\n${body}\n\n${hostLabelValue || os.hostname()}`;
     // Logged before it is sent, and whether or not it arrives, so the journal is a complete record
     // of what this machine had to say even when Discord is unreachable or the webhook is wrong.
     console.log(`Discord: ${full}`);

package/security/authorizedKeys/daemon/repoFiles.ts

@@ -0,0 +1,118 @@
+import fs from "fs/promises";
+import path from "path";
+import { deriveRevokeKey, findRevokeKey, REVOKE_KEY_LABEL, revokeKeyPath, revokeRepoPath, revokeRepoURL } from "../revokeSource";
+import { findSourceKey, sourceKeyPath, sourceRepoPath } from "../sources";
+import { cloneRepo, repoIsUsable, runGit } from "./git";
+
+/** Reading a repo, made to look like reading a directory. A caller asks for a file and gets its
+    contents; keeping a checkout on disk, cloning it once and pulling it since, is this module's
+    business and nobody else's.
+
+    Nothing here ever answers "there is nothing" when the truth is "I could not look". A repo that
+    cannot be reached throws, and the caller skips that source, because reading an unreachable
+    revoke repo as empty would un-revoke every key in it. */
+export type RepoRef = {
+    repoURL: string;
+    repoPath: string;
+    keyPath: () => Promise<string>;
+};
+
+export function sourceRepo(sourceURL: string): RepoRef {
+    return {
+        repoURL: sourceURL,
+        repoPath: sourceRepoPath(sourceURL),
+        keyPath: async () => await findSourceKey(sourceURL) || sourceKeyPath(sourceURL),
+    };
+}
+
+export function revokeRepo(sourceURL: string): RepoRef {
+    return {
+        repoURL: revokeRepoURL(sourceURL),
+        repoPath: revokeRepoPath(sourceURL),
+        keyPath: () => ensureRevokeKey(sourceURL),
+    };
+}
+
+/** The revoke repo's key is worked out from the source's, so nothing extra had to be uploaded and
+    nothing extra is stored anywhere it could be taken from. */
+export async function ensureRevokeKey(sourceURL: string) {
+    let existing = await findRevokeKey(sourceURL);
+    if (existing) {
+        return existing;
+    }
+    let sourceKey = await findSourceKey(sourceURL);
+    if (!sourceKey) {
+        throw new Error(`Expected a key for ${sourceURL} at ${sourceKeyPath(sourceURL)}, no such file exists`);
+    }
+    let derived = deriveRevokeKey(await fs.readFile(sourceKey, "utf8"));
+    let keyPath = revokeKeyPath(sourceURL);
+    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });
+    await fs.writeFile(keyPath, derived.privateKeyFile, { mode: 0o600 });
+    await fs.writeFile(`${keyPath}.pub`, `${derived.publicKey} ${REVOKE_KEY_LABEL}\n`, { mode: 0o644 });
+    console.log(`Derived the revoke key for ${sourceURL} into ${keyPath}`);
+    return keyPath;
+}
+
+async function pathExists(filePath: string) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/** Brings the checkout in line with the remote. Cloned the first time, pulled after that, and the
+    usual case of nothing having changed costs one ref listing and no objects. Throws if the repo
+    cannot be read, so a caller cannot mistake that for an empty repo. */
+export async function syncRepoFiles(repo: RepoRef) {
+    let { repoURL, repoPath } = repo;
+    let keyPath = await repo.keyPath();
+    if (!await repoIsUsable({ repoPath, keyPath })) {
+        await cloneRepo({ repoURL, repoPath, keyPath });
+        return;
+    }
+    let localHead = await runGit({ args: ["rev-parse", "HEAD"], cwd: repoPath, keyPath, allowFailure: true });
+    if (localHead.status !== 0) {
+        // A repo with no commits yet, which is the state every revoke repo starts in. There is
+        // nothing to pull and nothing to say.
+        return;
+    }
+    let branch = (await runGit({ args: ["rev-parse", "--abbrev-ref", "HEAD"], cwd: repoPath, keyPath })).stdout.trim();
+    let listing = (await runGit({ args: ["ls-remote", "origin", branch], cwd: repoPath, keyPath })).stdout;
+    let remoteSha = (listing.split(/\s+/)[0] || "").trim();
+    if (remoteSha && remoteSha === localHead.stdout.trim()) {
+        return;
+    }
+    await runGit({ args: ["fetch", "--prune", "origin"], cwd: repoPath, keyPath });
+    await runGit({ args: ["reset", "--hard", `origin/${branch}`], cwd: repoPath, keyPath });
+    await runGit({ args: ["clean", "-fdx"], cwd: repoPath, keyPath });
+}
+
+/** Throws when there is no checkout at all. "I have never managed to read this repo" and "this
+    repo is empty" are different answers and must not collapse into one. */
+async function requireCheckout(repo: RepoRef) {
+    if (!await pathExists(path.join(repo.repoPath, ".git"))) {
+        throw new Error(`Expected a checkout of ${repo.repoURL} at ${repo.repoPath}, there is none`);
+    }
+}
+
+/** One file out of the repo, or undefined if the repo does not have that file. */
+export async function readRepoFile(repo: RepoRef, filePath: string) {
+    await requireCheckout(repo);
+    try {
+        return await fs.readFile(path.join(repo.repoPath, filePath), "utf8");
+    } catch (e) {
+        return undefined;
+    }
+}
+
+/** The names in one of the repo's directories, or nothing if it has no such directory. */
+export async function listRepoDir(repo: RepoRef, directory: string) {
+    await requireCheckout(repo);
+    try {
+        return (await fs.readdir(path.join(repo.repoPath, directory))).sort();
+    } catch (e) {
+        return [];
+    }
+}

package/security/authorizedKeys/daemon/rootKeys.ts

@@ -1,6 +1,6 @@
 import fs from "fs/promises";
 import path from "path";
-import { keyFingerprint, keyRestriction, keyRestrictionList, NO_RESTRICTION, summarizeKey } from "../authorizedKeys";
+import { keyFingerprint, keyNiceName, keyRestriction, keyRestrictionList, NO_RESTRICTION, summarizeKey } from "../authorizedKeys";
 import { KEYS_HISTORY_PATH, ROOT_AUTHORIZED_KEYS } from "./paths";
 import { notify } from "./notify";
 import { getState, saveState } from "./state";
@@ -53,6 +53,64 @@ function describeAddressChange(config: { previousLine: string; currentLine: stri
     return lines.join("\n");
 }
 
+/** The change in one line, for the notification preview. One key added, one removed, or one
+    address gained or lost, said plainly - that covers nearly every real change. Anything with more
+    than one part to it falls back to counting, because a line that tries to say four things says
+    none of them in the space a preview gives it. */
+export function summarizeKeyDifference(config: { before: string[]; after: string[] }) {
+    let { before, after } = config;
+    let beforeByKey = new Map(before.map(key => [keyIdentity(key), key]));
+    let afterByKey = new Map(after.map(key => [keyIdentity(key), key]));
+
+    let added = [...afterByKey].filter(([identity]) => !beforeByKey.has(identity)).map(([, key]) => key);
+    let removed = [...beforeByKey].filter(([identity]) => !afterByKey.has(identity)).map(([, key]) => key);
+    let addressesAdded: { key: string; address: string }[] = [];
+    let addressesRemoved: { key: string; address: string }[] = [];
+    let otherwiseChanged: string[] = [];
+    for (let [identity, previousLine] of beforeByKey) {
+        let currentLine = afterByKey.get(identity);
+        if (!currentLine || currentLine === previousLine) {
+            continue;
+        }
+        let keyLine = currentLine;
+        let previous = keyRestrictionList(previousLine) || [];
+        let current = keyRestrictionList(keyLine) || [];
+        let gained = current.filter(address => !previous.includes(address));
+        let lost = previous.filter(address => !current.includes(address));
+        if (!gained.length && !lost.length) {
+            otherwiseChanged.push(keyLine);
+            continue;
+        }
+        addressesAdded.push(...gained.map(address => ({ key: keyLine, address })));
+        addressesRemoved.push(...lost.map(address => ({ key: keyLine, address })));
+    }
+
+    let changes = added.length + removed.length + addressesAdded.length + addressesRemoved.length
+        + otherwiseChanged.length;
+    if (changes === 1) {
+        if (added.length) {
+            return `SSH KEY ADDED ${keyNiceName(added[0])}`;
+        }
+        if (removed.length) {
+            return `SSH KEY REMOVED ${keyNiceName(removed[0])}`;
+        }
+        if (addressesAdded.length) {
+            return `IP ${addressesAdded[0].address} ALLOWED ON ${keyNiceName(addressesAdded[0].key)}`;
+        }
+        if (addressesRemoved.length) {
+            return `IP ${addressesRemoved[0].address} REMOVED FROM ${keyNiceName(addressesRemoved[0].key)}`;
+        }
+        return `SSH KEY CHANGED ${keyNiceName(otherwiseChanged[0])}`;
+    }
+    let counted = [
+        added.length && `${added.length} key(s) added` || "",
+        removed.length && `${removed.length} key(s) removed` || "",
+        addressesAdded.length && `${addressesAdded.length} IP(s) allowed` || "",
+        addressesRemoved.length && `${addressesRemoved.length} IP(s) removed` || "",
+    ].filter(part => part);
+    return `SSH KEYS CHANGED: ${counted.join(", ") || "no keys differ"}`;
+}
+
 export function describeKeyDifference(config: { before: string[]; after: string[] }) {
     let { before, after } = config;
     let beforeByKey = new Map(before.map(key => [keyIdentity(key), key]));
@@ -181,18 +239,27 @@ export async function enforceRootKeys(keys: string[]) {
     state.appliedKeys = keys;
     await saveState();
 
-    let reasons = takeChangeReasons();
-    let why = reasons.length && `\n\n${reasons.join("\n\n")}` || "";
+    let { leading, reasons } = takeChangeReasons();
+    // An attack names the message. Whoever is looking at a preview needs to see that, not that
+    // some keys changed - the change is what the attack caused.
+    let alert = leading.map(entry => entry.body).join("\n\n");
+    let why = [alert, ...reasons].filter(part => part).join("\n\n");
+    let before = weChangedIt && previouslyApplied || keys;
+    let after = weChangedIt && keys || currentKeys;
+    let headline = leading[0]?.headline || summarizeKeyDifference({ before, after });
+
     if (weChangedIt) {
-        await notify(
-            `applied authorized key changes:`
-            + `\n\`\`\`\n${describeKeyDifference({ before: previouslyApplied, after: keys })}\n\`\`\`${why}`
+        await notify(headline,
+            `Who can log in as root:`
+            + `\n\`\`\`\n${describeKeyDifference({ before, after })}\n\`\`\``
+            + `${why && `\n${why}` || ""}`
         );
         return;
     }
-    await notify(
-        `root's authorized_keys was edited by something other than portsecure. The edit below has`
-        + ` been undone, and the keys from the repos are back in place.`
-        + `\n\`\`\`\n${describeKeyDifference({ before: keys, after: currentKeys })}\n\`\`\`${why}`
+    await notify(leading[0]?.headline || `SSH KEYS EDITED BY SOMETHING ELSE`,
+        `Something other than portsecure edited root's authorized_keys. The edit below has been`
+        + ` undone, and the keys from the repos are back in place.`
+        + `\n\`\`\`\n${describeKeyDifference({ before, after })}\n\`\`\``
+        + `${why && `\n${why}` || ""}`
     );
 }

package/security/authorizedKeys/daemon/state.ts

@@ -17,14 +17,26 @@ export type SourceState = {
     reportedProblem: string;
 };
 
-/** A key this machine has stopped accepting. Kept even when the revoke repo no longer lists it:
-    the deploy key that writes revocations lives on every server, so an attacker who took one could
-    otherwise delete the revocation that locked them out. */
+/** One revocation event: this key, used from this address, so it is no longer accepted. Kept even
+    when the revoke repo no longer lists it: the deploy key that writes revocations lives on every
+    server, so an attacker who took one could otherwise delete the revocation that locked them out.
+
+    The id is unique to the event, never derived from the key. A key that has been forgiven for one
+    address is still an ordinary key, and using it from some other address revokes it again, with a
+    new id that no existing unrevoke names. */
 export type RevocationState = {
-    fingerprint: string;
     revocationId: string;
-    // Set once an unrevoke has been seen, so the wait can be served out across restarts.
-    unrevokeSeenAt: number;
+    fingerprint: string;
+    // The address it was used from. Half of what a revocation says, and the half an unrevoke has
+    // to name to undo it.
+    ip: string;
+    // Why this key was revoked, carried from the revocation file so a machine that reads one
+    // written elsewhere can say what happened rather than only that something did.
+    revokedAt: string;
+    revokedBy: string;
+    reason: string;
+    // Which unrevoke allowed this key from this address, once one has been seen. When the wait it
+    // started runs out is in unrevokeFirstSeen, which outlives the daemon.
     unrevokeId: string;
     unrevoked: boolean;
     // Whether we have said that this key actually left root's authorized_keys. The removal is the
@@ -50,7 +62,12 @@ export type DaemonState = {
     // revocations is on every server, so whoever stole one could otherwise erase the record that
     // shut them out. Restarting the daemon does clear it, which is the way back from a revocation
     // that should not have happened.
-    revocations: { [fingerprint: string]: RevocationState };
+    revocations: { [revocationId: string]: RevocationState };
+    // When this machine first saw each unrevoke, by unrevoke id. On disk, unlike the revocations
+    // themselves, because it is what the hour long wait is counted from: measuring from a time the
+    // unrevoke file states would let whoever wrote it backdate the file and skip the wait, and
+    // measuring from process start would restart the wait on every restart.
+    unrevokeFirstSeen: { [unrevokeId: string]: number };
     pendingRevocations: PendingRevocation[];
     // The keys we last wrote out. What tells a change we made apart from one somebody else made:
     // if this still matches what we want, and the file does not, the file was edited behind us.
@@ -64,6 +81,7 @@ let state: DaemonState = {
     sources: {},
     userKeyHashes: {},
     revocations: {},
+    unrevokeFirstSeen: {},
     pendingRevocations: [],
     appliedKeys: [],
     authLogOffset: 0,

package/security/authorizedKeys/daemon/trust.ts

@@ -174,21 +174,31 @@ async function verifyCheckoutSigner(config: {
     return publicKey;
 }
 
+/** Proves a checkout on disk was signed, and that the files in it are the ones that were signed.
+    Returns the signer, and throws if anything about that does not hold.
+
+    Anything reading a repo for something other than ssh keys goes through this first: the whole
+    checkout is covered by one manifest, so a machine list is exactly as trustworthy as the keys
+    beside it, and neither is worth reading unsigned. */
+export async function verifyCheckout(repoPath: string) {
+    return await verifyCheckoutSigner({ repoPath, files: await readSignatureFiles(repoPath) });
+}
+
 export function describeSigner(signer: string) {
     return signer === UNSIGNED && "<no public key>" || signer;
 }
 
 /** Reports a problem with a source's signature, but only when it is not the same problem we
     already reported, so a fault that persists does not repeat every check. */
-async function reportProblem(config: { repoURL: string; problem: string; message: string }) {
-    let { repoURL, problem, message } = config;
+async function reportProblem(config: { repoURL: string; problem: string; headline: string; body: string }) {
+    let { repoURL, problem, headline, body } = config;
     let sourceStateValue = sourceState(repoURL);
     if (sourceStateValue.reportedProblem === problem) {
         return;
     }
     sourceStateValue.reportedProblem = problem;
     await saveState();
-    await notify(message);
+    await notify(headline, body);
 }
 
 /** The keys a source is allowed to contribute right now. A source signed by someone we have not
@@ -210,17 +220,24 @@ export async function resolveSourceKeys(repoURL: string) {
             await reportProblem({
                 repoURL,
                 problem: "stale",
-                message: `\`${repoURL}\` changed but its signature was not updated, so the changes are being`
-                    + ` ignored. Still using the keys signed by \`${describeSigner(sourceStateValue.acceptedSigner)}\`.`
-                    + `\nTo deploy the change, run this in that repo:\n\`\`\`\n${SIGN_COMMAND}\n\`\`\``,
+                headline: `KEY REPO CHANGED WITHOUT BEING SIGNED`,
+                body: `\`${repoURL}\` changed, but nobody signed the change, so it is being ignored`
+                    + ` and this machine is still using the keys signed by`
+                    + ` \`${describeSigner(sourceStateValue.acceptedSigner)}\`.`
+                    + `\n\nTo make the change take effect, run this in that repo:`
+                    + `\n\`\`\`\n${SIGN_COMMAND}\n\`\`\``,
             });
         } else {
             await reportProblem({
                 repoURL,
                 problem: "corrupt",
-                message: `\`${repoURL}\` has a corrupted signature, so its contents are being ignored:`
-                    + ` ${e}.\nStill using the keys signed by \`${describeSigner(sourceStateValue.acceptedSigner)}\`.`
-                    + `\nTo replace it, run this in that repo:\n\`\`\`\n${SIGN_COMMAND}\n\`\`\``,
+                headline: `KEY REPO SIGNATURE IS BROKEN`,
+                body: `The signature on \`${repoURL}\` does not check out, so everything in it is`
+                    + ` being ignored and this machine is still using the keys signed by`
+                    + ` \`${describeSigner(sourceStateValue.acceptedSigner)}\`.`
+                    + `\n\n${e}`
+                    + `\n\nTo replace the signature, run this in that repo:`
+                    + `\n\`\`\`\n${SIGN_COMMAND}\n\`\`\``,
             });
         }
         return sourceStateValue.acceptedKeys;
@@ -259,9 +276,10 @@ export async function resolveSourceKeys(repoURL: string) {
 
     // Going from nothing to something signed is only ever an improvement, so it does not wait.
     if (sourceStateValue.acceptedSigner === UNSIGNED) {
-        await notify(
-            `\`${repoURL}\` is now signed, by \`${signer}\`. It was not signed before, so its keys are`
-            + ` being applied right away.`
+        await notify(`KEY REPO IS NOW SIGNED`,
+            `\`${repoURL}\` was not signed at all before, so this is an improvement and its keys`
+            + ` are being applied right away.`
+            + `\n\nsigned by: \`${signer}\``
         );
         return await accept();
     }
@@ -273,10 +291,13 @@ export async function resolveSourceKeys(repoURL: string) {
         sourceStateValue.pendingSigner = signer;
         sourceStateValue.pendingSince = Date.now();
         await saveState();
-        await notify(
-            `\`${repoURL}\` is now signed by \`${describeSigner(signer)}\`, where it was signed by`
-            + ` \`${describeSigner(sourceStateValue.acceptedSigner)}\`. Its keys are NOT being applied.`
-            + ` If nothing changes they will be applied in 24 hours.`
+        await notify(`KEY REPO SIGNED BY A DIFFERENT KEY`,
+            `Somebody else is signing \`${repoURL}\` now. Its keys are NOT being applied, and this`
+            + ` machine is still using the ones it already had. If nothing changes, the new signer`
+            + ` is accepted in 24 hours.`
+            + `\n\nIf that was not you, fix the repo before the 24 hours are up.`
+            + `\n\nsigned by now: \`${describeSigner(signer)}\``
+            + `\nsigned by before: \`${describeSigner(sourceStateValue.acceptedSigner)}\``
         );
         return sourceStateValue.acceptedKeys;
     }

package/security/authorizedKeys/daemon/userKeys.ts

@@ -65,10 +65,11 @@ export async function checkOtherUserKeys() {
         if (previousHash === undefined || previousHash === hash) {
             continue;
         }
-        await notify(
-            `authorized_keys for user \`${entry.name}\` changed (\`${entry.filePath}\`).`
-            + ` portsecure does not manage this account, so the change was left in place.`
-            + `\n\`\`\`\n${keys.map(summarizeKey).join("\n") || "(now empty)"}\n\`\`\``
+        await notify(`SSH KEYS CHANGED FOR USER ${entry.name}`,
+            `Somebody changed who can log in as \`${entry.name}\`. portsecure does not manage that`
+            + ` account, so the change was left alone. Who can log in as \`${entry.name}\` now:`
+            + `\n\`\`\`\n${keys.map(summarizeKey).join("\n") || "(nobody, the file is now empty)"}\n\`\`\``
+            + `\n${entry.filePath}`
         );
     }
     state.userKeyHashes = hashes;

package/security/authorizedKeys/dist/authorizedKeys.ts.cache

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.readRepoKeys = exports.findKeyProblems = exports.summarizeKey = exports.keyRestriction = exports.keyRestrictionList = exports.NO_RESTRICTION = exports.keyFingerprint = exports.normalizeKeys = void 0;
+//exports.readRepoKeys = exports.findKeyProblems = exports.keyNiceName = exports.summarizeKey = exports.allowAddresses = exports.keyRestriction = exports.keyRestrictionList = exports.NO_RESTRICTION = exports.keyFingerprint = exports.normalizeKeys = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
@@ -44,6 +44,27 @@ function keyRestriction(keyLine) {
     return list.join(",");
 }
 exports.keyRestriction = keyRestriction;
+/** Adds addresses to a key's from= list, leaving the rest of the line exactly as it was. Returns
+    which addresses were actually new, so a caller can report only what it changed.
+
+    A key with no from= at all is left alone: adding one would silently restrict a key that is
+    currently unrestricted, which is a different decision than the one being made here. */
+function allowAddresses(keyLine, addresses) {
+    let list = keyRestrictionList(keyLine);
+    if (!list) {
+        return { keyLine, added: [] };
+    }
+    let allowed = list;
+    let added = addresses.filter(address => address && !allowed.includes(address));
+    if (!added.length) {
+        return { keyLine, added };
+    }
+    return {
+        keyLine: keyLine.replace(/from="[^"]*"/, `from="${[...allowed, ...added].join(",")}"`),
+        added,
+    };
+}
+exports.allowAddresses = allowAddresses;
 /** Enough to recognise whose key this is without printing the whole blob. */
 function summarizeKey(keyLine) {
     let parts = keyLine.trim().split(/\s+/);
@@ -57,6 +78,19 @@ function summarizeKey(keyLine) {
     return `${type} ...${blob.slice(-12)}${comment && ` ${comment}` || ""}`;
 }
 exports.summarizeKey = summarizeKey;
+/** The shortest thing that still identifies a key to a person: the comment it carries, which is
+    usually user@machine, and otherwise the tail of the key itself. For the first line of a
+    notification, where there is only room for the one thing that matters. */
+function keyNiceName(keyLine) {
+    let parts = keyLine.trim().split(/\s+/);
+    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));
+    if (typeIndex < 0) {
+        return keyLine.slice(0, 20);
+    }
+    let comment = parts.slice(typeIndex + 2).join(" ");
+    return comment || `...${(parts[typeIndex + 1] || "").slice(-8)}`;
+}
+exports.keyNiceName = keyNiceName;
 /** What a set of keys has to satisfy before it is worth signing, as a list of complaints.
 
     Every key needs a from=, because an unrestricted key can never be caught being used from the
@@ -107,5 +141,5 @@ async function readRepoKeys(repoPath) {
     return keys;
 }
 exports.readRepoKeys = readRepoKeys;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorizedKeys.js","sourceRoot":"","sources":["authorizedKeys.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\n\nexport function normalizeKeys(contents: string) {\n    return contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n}\n\n/** The fingerprint ssh itself reports for a key, which is what the sshd log names and therefore\n    what a revocation is keyed by. Returns \"\" for a line that holds no key. */\nexport function keyFingerprint(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    let blob = typeIndex >= 0 && parts[typeIndex + 1] || \"\";\n    if (!blob) {\n        return \"\";\n    }\n    return \"SHA256:\" + crypto.createHash(\"sha256\").update(Buffer.from(blob, \"base64\")).digest(\"base64\").replace(/=+$/, \"\");\n}\n\nexport const NO_RESTRICTION = \"ANY ADDRESS (no from= restriction)\";\n\n/** The addresses a key may be used from, one by one, or undefined when the key carries no from=\n    at all. Undefined and an empty list are very different things, so they stay distinguishable. */\nexport function keyRestrictionList(keyLine: string) {\n    let match = keyLine.match(/from=\"([^\"]*)\"/);\n    if (!match) {\n        return undefined;\n    }\n    return match[1].split(\",\").map(entry => entry.trim()).filter(entry => entry);\n}\n\n/** The addresses a key may be used from, which is the part of an authorized_keys line that\n    decides how much a stolen key is worth. A key with no restriction says so loudly. */\nexport function keyRestriction(keyLine: string) {\n    let list = keyRestrictionList(keyLine);\n    if (!list) {\n        return NO_RESTRICTION;\n    }\n    return list.join(\",\");\n}\n\n/** Enough to recognise whose key this is without printing the whole blob. */\nexport function summarizeKey(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    if (typeIndex < 0) {\n        return keyLine.slice(0, 60);\n    }\n    let type = parts[typeIndex];\n    let blob = parts[typeIndex + 1] || \"\";\n    let comment = parts.slice(typeIndex + 2).join(\" \");\n    return `${type} ...${blob.slice(-12)}${comment && ` ${comment}` || \"\"}`;\n}\n\n/** What a set of keys has to satisfy before it is worth signing, as a list of complaints.\n\n    Every key needs a from=, because an unrestricted key can never be caught being used from the\n    wrong place, and being caught is the only thing that triggers a revocation.\n\n    No two keys may allow the same addresses, because that is one person holding two keys: revoking\n    one of them leaves the other working, so the revocation achieves nothing. */\nexport function findKeyProblems(keys: string[]) {\n    let problems: string[] = [];\n    let byRestriction = new Map<string, string[]>();\n    for (let key of keys) {\n        let restriction = keyRestrictionList(key);\n        if (!restriction) {\n            problems.push(`no from= restriction, so it can be used from anywhere:\\n      ${summarizeKey(key)}`);\n            continue;\n        }\n        // Sorted, so the same addresses written in a different order still count as the same.\n        let identity = [...restriction].sort().join(\",\");\n        byRestriction.set(identity, [...(byRestriction.get(identity) || []), key]);\n    }\n    for (let [restriction, sharing] of byRestriction) {\n        if (sharing.length < 2) {\n            continue;\n        }\n        problems.push(\n            `${sharing.length} keys allow exactly the same addresses (${restriction}), which is one`\n            + ` person holding more than one key:\\n`\n            + sharing.map(key => `      ${summarizeKey(key)}`).join(\"\\n\")\n        );\n    }\n    return problems;\n}\n\n/** Reads the authorized keys a repo checkout wants applied. Prefers a top level authorized_keys\n    file and otherwise concatenates every .pub at the top level. */\nexport async function readRepoKeys(repoPath: string) {\n    let combinedPath = path.join(repoPath, \"authorized_keys\");\n    let entries = await fs.readdir(repoPath);\n    if (entries.includes(\"authorized_keys\")) {\n        return normalizeKeys(await fs.readFile(combinedPath, \"utf8\"));\n    }\n    let pubFiles = entries.filter(name => name.endsWith(\".pub\")).sort();\n    if (!pubFiles.length) {\n        throw new Error(`Expected authorized_keys or at least one .pub file in ${repoPath}, found neither`);\n    }\n    let keys: string[] = [];\n    for (let name of pubFiles) {\n        keys.push(...normalizeKeys(await fs.readFile(path.join(repoPath, name), \"utf8\")));\n    }\n    return keys;\n}\n"]}
- /* _JS_SOURCE_HASH = "a5147a2eb954468a9ddfcac36189a744f5b17f944d7e837ce0a525c780093a26"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorizedKeys.js","sourceRoot":"","sources":["authorizedKeys.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\n\nexport function normalizeKeys(contents: string) {\n    return contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n}\n\n/** The fingerprint ssh itself reports for a key, which is what the sshd log names and therefore\n    what a revocation is keyed by. Returns \"\" for a line that holds no key. */\nexport function keyFingerprint(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    let blob = typeIndex >= 0 && parts[typeIndex + 1] || \"\";\n    if (!blob) {\n        return \"\";\n    }\n    return \"SHA256:\" + crypto.createHash(\"sha256\").update(Buffer.from(blob, \"base64\")).digest(\"base64\").replace(/=+$/, \"\");\n}\n\nexport const NO_RESTRICTION = \"ANY ADDRESS (no from= restriction)\";\n\n/** The addresses a key may be used from, one by one, or undefined when the key carries no from=\n    at all. Undefined and an empty list are very different things, so they stay distinguishable. */\nexport function keyRestrictionList(keyLine: string) {\n    let match = keyLine.match(/from=\"([^\"]*)\"/);\n    if (!match) {\n        return undefined;\n    }\n    return match[1].split(\",\").map(entry => entry.trim()).filter(entry => entry);\n}\n\n/** The addresses a key may be used from, which is the part of an authorized_keys line that\n    decides how much a stolen key is worth. A key with no restriction says so loudly. */\nexport function keyRestriction(keyLine: string) {\n    let list = keyRestrictionList(keyLine);\n    if (!list) {\n        return NO_RESTRICTION;\n    }\n    return list.join(\",\");\n}\n\n/** Adds addresses to a key's from= list, leaving the rest of the line exactly as it was. Returns\n    which addresses were actually new, so a caller can report only what it changed.\n\n    A key with no from= at all is left alone: adding one would silently restrict a key that is\n    currently unrestricted, which is a different decision than the one being made here. */\nexport function allowAddresses(keyLine: string, addresses: string[]) {\n    let list = keyRestrictionList(keyLine);\n    if (!list) {\n        return { keyLine, added: [] as string[] };\n    }\n    let allowed = list;\n    let added = addresses.filter(address => address && !allowed.includes(address));\n    if (!added.length) {\n        return { keyLine, added };\n    }\n    return {\n        keyLine: keyLine.replace(/from=\"[^\"]*\"/, `from=\"${[...allowed, ...added].join(\",\")}\"`),\n        added,\n    };\n}\n\n/** Enough to recognise whose key this is without printing the whole blob. */\nexport function summarizeKey(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    if (typeIndex < 0) {\n        return keyLine.slice(0, 60);\n    }\n    let type = parts[typeIndex];\n    let blob = parts[typeIndex + 1] || \"\";\n    let comment = parts.slice(typeIndex + 2).join(\" \");\n    return `${type} ...${blob.slice(-12)}${comment && ` ${comment}` || \"\"}`;\n}\n\n/** The shortest thing that still identifies a key to a person: the comment it carries, which is\n    usually user@machine, and otherwise the tail of the key itself. For the first line of a\n    notification, where there is only room for the one thing that matters. */\nexport function keyNiceName(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    if (typeIndex < 0) {\n        return keyLine.slice(0, 20);\n    }\n    let comment = parts.slice(typeIndex + 2).join(\" \");\n    return comment || `...${(parts[typeIndex + 1] || \"\").slice(-8)}`;\n}\n\n/** What a set of keys has to satisfy before it is worth signing, as a list of complaints.\n\n    Every key needs a from=, because an unrestricted key can never be caught being used from the\n    wrong place, and being caught is the only thing that triggers a revocation.\n\n    No two keys may allow the same addresses, because that is one person holding two keys: revoking\n    one of them leaves the other working, so the revocation achieves nothing. */\nexport function findKeyProblems(keys: string[]) {\n    let problems: string[] = [];\n    let byRestriction = new Map<string, string[]>();\n    for (let key of keys) {\n        let restriction = keyRestrictionList(key);\n        if (!restriction) {\n            problems.push(`no from= restriction, so it can be used from anywhere:\\n      ${summarizeKey(key)}`);\n            continue;\n        }\n        // Sorted, so the same addresses written in a different order still count as the same.\n        let identity = [...restriction].sort().join(\",\");\n        byRestriction.set(identity, [...(byRestriction.get(identity) || []), key]);\n    }\n    for (let [restriction, sharing] of byRestriction) {\n        if (sharing.length < 2) {\n            continue;\n        }\n        problems.push(\n            `${sharing.length} keys allow exactly the same addresses (${restriction}), which is one`\n            + ` person holding more than one key:\\n`\n            + sharing.map(key => `      ${summarizeKey(key)}`).join(\"\\n\")\n        );\n    }\n    return problems;\n}\n\n/** Reads the authorized keys a repo checkout wants applied. Prefers a top level authorized_keys\n    file and otherwise concatenates every .pub at the top level. */\nexport async function readRepoKeys(repoPath: string) {\n    let combinedPath = path.join(repoPath, \"authorized_keys\");\n    let entries = await fs.readdir(repoPath);\n    if (entries.includes(\"authorized_keys\")) {\n        return normalizeKeys(await fs.readFile(combinedPath, \"utf8\"));\n    }\n    let pubFiles = entries.filter(name => name.endsWith(\".pub\")).sort();\n    if (!pubFiles.length) {\n        throw new Error(`Expected authorized_keys or at least one .pub file in ${repoPath}, found neither`);\n    }\n    let keys: string[] = [];\n    for (let name of pubFiles) {\n        keys.push(...normalizeKeys(await fs.readFile(path.join(repoPath, name), \"utf8\")));\n    }\n    return keys;\n}\n"]}
+ /* _JS_SOURCE_HASH = "5dc60c0f88ff3878003bf57017d1342326afa7c6a9f511d5896e4113565a7823"; */

package/security/authorizedKeys/dist/revokeSource.ts.cache

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.deriveRevokeKey = exports.revokeRepoPath = exports.revokeKeyPath = exports.revokeRepoURL = exports.REVOKE_KEY_LABEL = void 0;
+//exports.deriveRevokeKey = exports.revokeRepoPath = exports.findRevokeKey = exports.legacyRevokeKeyPath = exports.revokeKeyPath = exports.revokeRepoURL = exports.REVOKE_KEY_LABEL = void 0;
 const deriveKey_1 = require("../keys/deriveKey");
 const sshKeyFile_1 = require("../keys/sshKeyFile");
+const path_1 = __importDefault(require("path"));
 const sources_1 = require("./sources");
 // A source's revocations live in a repo beside it. Derived rather than configured, so adding a
 // source brings its revoke repo with it and there is nothing extra to pass on the command line.
@@ -16,9 +20,18 @@ function revokeRepoURL(sourceURL) {
 }
 exports.revokeRepoURL = revokeRepoURL;
 function revokeKeyPath(sourceURL) {
-    return `${sources_1.REPO_KEYS_DIR}/${(0, sources_1.sourceName)(sourceURL)}${REVOKED_SUFFIX}`;
+    return path_1.default.join((0, sources_1.keysDir)(), `${(0, sources_1.sourceName)(sourceURL)}${REVOKED_SUFFIX}`);
 }
 exports.revokeKeyPath = revokeKeyPath;
+function legacyRevokeKeyPath(sourceURL) {
+    return `${sources_1.LEGACY_REPO_KEYS_DIR}/${(0, sources_1.sourceName)(sourceURL)}${REVOKED_SUFFIX}`;
+}
+exports.legacyRevokeKeyPath = legacyRevokeKeyPath;
+/** Wherever this source's revoke key already is, or nothing if it has not been derived yet. */
+async function findRevokeKey(sourceURL) {
+    return await (0, sources_1.findKey)({ current: revokeKeyPath(sourceURL), legacy: legacyRevokeKeyPath(sourceURL) });
+}
+exports.findRevokeKey = findRevokeKey;
 function revokeRepoPath(sourceURL) {
     return `${sources_1.REPOS_DIR}/${(0, sources_1.sourceName)(sourceURL)}${REVOKED_SUFFIX}`;
 }
@@ -40,5 +53,5 @@ function deriveRevokeKey(sourcePrivateKey) {
     };
 }
 exports.deriveRevokeKey = deriveRevokeKey;
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "9f16cd6aea6e1f1a646eda715ac4cac70dc67579ce23c1e473bd371b7985b229"; */
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "fa19b1fd43388ad835ac95f96f64acb37f8ebbc316741e6c48fc273ac174e1e7"; */