sliftutils 1.7.136 → 1.7.138

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

@@ -3,18 +3,65 @@ 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.readSignedRepo = exports.SignedRepoError = exports.UNSIGNED = void 0;
+//exports.readSignedRepo = exports.SignedRepoError = exports.noteRevocation = exports.isPairUnrevoked = exports.isPairRevoked = exports.isIdentityFrozen = exports.UNSIGNED = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const manifest_1 = require("../../signedFiles/manifest");
 const sshsig_1 = require("../../signedFiles/sshsig");
+const authorizedKeys_1 = require("../authorizedKeys");
+const revokeSource_1 = require("../revokeSource");
 // A source that has never been signed reads as this, so losing a signature counts as a change of
 // signer rather than as something to wave through.
 exports.UNSIGNED = "";
 // What fixes both of the signature problems we report, so the message can say so rather than
 // leaving someone to work it out.
 const SIGN_COMMAND = "yarn signfiles git";
+const REVOCATIONS_DIR = "revocations";
+const UNREVOKES_DIR = "unrevoked";
+// Every revocation this process has ever seen, keyed by revocation id. Once absorbed a revocation
+// never leaves, even if its file disappears from the revoke repo - the key that writes revocations
+// is on every server, so whoever stole one could otherwise erase the record that shut them out.
+// Restarting the process is the way back from a revocation that should not have happened.
+let absorbedRevocations = new Map();
+// The pairs the signed unrevokes allow, and the legacy revocation ids they name. Rebuilt on every
+// read, since unrevokes are signed content and removing one must take effect.
+let unrevokedPairs = new Set();
+let unrevokedIds = new Set();
+/** Whether an identity - a key fingerprint or a machine id - has a revocation nothing has undone.
+    The one meaning of "frozen", used both when stripping repo content and when explaining why. */
+function isIdentityFrozen(identity) {
+    for (let [revocationId, revocation] of absorbedRevocations) {
+        if (revocation.identity !== identity) {
+            continue;
+        }
+        if (unrevokedIds.has(revocationId) || unrevokedPairs.has(`${identity} ${revocation.ip}`)) {
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+exports.isIdentityFrozen = isIdentityFrozen;
+function isPairRevoked(identity, ip) {
+    for (let [revocationId, revocation] of absorbedRevocations) {
+        if (revocation.identity === identity && revocation.ip === ip && !unrevokedIds.has(revocationId)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isPairRevoked = isPairRevoked;
+function isPairUnrevoked(identity, ip) {
+    return unrevokedPairs.has(`${identity} ${ip}`);
+}
+exports.isPairUnrevoked = isPairUnrevoked;
+/** For whoever just wrote a revocation, so it holds here immediately rather than on the next
+    absorb. Sticky like the rest. */
+function noteRevocation(revocationId, identity, ip) {
+    absorbedRevocations.set(revocationId, { identity, ip });
+}
+exports.noteRevocation = noteRevocation;
 /** A repo that cannot be trusted, with the message ready for whoever asked. Not every caller
     treats these the same - a source keeps its last keys, a machine list is just refused - so the
     kind is carried rather than acted on here. */
@@ -35,7 +82,9 @@ exports.SignedRepoError = SignedRepoError;
     without re-signing - either way the caller keeps whatever it last accepted rather than believing
     a repo that no longer matches what was signed. A file not in the manifest is just unsigned, so
     it is left out and warned about rather than treated as tampering. */
-async function readSignedRepo(repoPath) {
+async function readSignedRepo(config) {
+    var _a;
+    let { repoPath, sourceURL } = config;
     let manifestBytes = await promises_1.default.readFile(path_1.default.join(repoPath, manifest_1.MANIFEST_NAME)).catch(() => undefined);
     let signatureBytes = await promises_1.default.readFile(path_1.default.join(repoPath, manifest_1.SIGNATURE_NAME)).catch(() => undefined);
     let manifestHash = manifestBytes && crypto_1.default.createHash("sha256").update(manifestBytes).digest("hex") || "";
@@ -108,8 +157,81 @@ async function readSignedRepo(repoPath) {
             throw stale(`${path_1.default.join(repoPath, filePath)} is signed for but missing`);
         }
     }
+    // Absorb the revoke repo's files into the sticky map. Once seen a revocation never leaves it,
+    // even if its file disappears - the key that writes revocations is on every server, so whoever
+    // stole one could otherwise erase the record that shut them out.
+    let revocationsDirectory = path_1.default.join((0, revokeSource_1.revokeRepoPath)(sourceURL), REVOCATIONS_DIR);
+    for (let name of (await promises_1.default.readdir(revocationsDirectory).catch(() => [])).sort()) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await promises_1.default.readFile(path_1.default.join(revocationsDirectory, name), "utf8"));
+            let identity = parsed.fingerprint || parsed.machineId;
+            if (!identity) {
+                continue;
+            }
+            let revocationId = parsed.revocationId || name.replace(/\.json$/, "");
+            if (!absorbedRevocations.has(revocationId)) {
+                absorbedRevocations.set(revocationId, { identity, ip: parsed.ip || ((_a = parsed.attempt) === null || _a === void 0 ? void 0 : _a.ip) || "" });
+            }
+        }
+        catch (e) {
+            console.log(`Ignoring unreadable revocation ${path_1.default.join(revocationsDirectory, name)}. ${e}`);
+        }
+    }
+    // Rebuild the unrevokes from the signed files just read. Unrevokes are signed content, so
+    // removing one must take effect, unlike the sticky revocations.
+    unrevokedPairs = new Set();
+    unrevokedIds = new Set();
+    for (let [filePath, contents] of files) {
+        if (!filePath.startsWith(`${UNREVOKES_DIR}/`) || !filePath.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(contents.toString("utf8"));
+            for (let allowed of parsed.allowed || []) {
+                let identity = allowed.fingerprint || allowed.machineId;
+                if (identity && allowed.ip) {
+                    unrevokedPairs.add(`${identity} ${allowed.ip}`);
+                }
+            }
+            for (let revocationId of parsed.revocationIds || []) {
+                unrevokedIds.add(revocationId);
+            }
+        }
+        catch (e) {
+            console.log(`Ignoring unreadable unrevoke ${filePath}. ${e}`);
+        }
+    }
+    // Drop everything frozen: revoked keys out of authorized_keys and top level .pub files, and
+    // frozen machines' files out of machines/. What comes back is what this machine actually
+    // trusts, so no caller can read the list and forget the revocations.
+    for (let [filePath, contents] of [...files]) {
+        if (filePath === "authorized_keys" || (filePath.endsWith(".pub") && !filePath.includes("/"))) {
+            let lines = contents.toString("utf8").split("\n");
+            let kept = lines.filter(line => {
+                let fingerprint = (0, authorizedKeys_1.keyFingerprint)(line);
+                if (fingerprint && isIdentityFrozen(fingerprint)) {
+                    console.log(`Dropping revoked key ${fingerprint} from ${path_1.default.join(repoPath, filePath)}`);
+                    return false;
+                }
+                return true;
+            });
+            if (kept.length !== lines.length) {
+                files.set(filePath, Buffer.from(kept.join("\n")));
+            }
+        }
+        if (filePath.startsWith("machines/") && filePath.endsWith(".json")) {
+            let machineId = filePath.slice("machines/".length, -".json".length);
+            if (isIdentityFrozen(machineId)) {
+                console.log(`Dropping frozen machine ${machineId} from ${path_1.default.join(repoPath, filePath)}`);
+                files.delete(filePath);
+            }
+        }
+    }
     return { signer, manifestHash, signatureHash, files };
 }
 exports.readSignedRepo = readSignedRepo;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trust.js","sourceRoot":"","sources":["trust.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport { MANIFEST_NAME, normalizeContent, SIGN_NAMESPACE, SIGNATURE_NAME } from \"../../signedFiles/manifest\";\nimport { verifySSHSIG } from \"../../signedFiles/sshsig\";\n\n// A source that has never been signed reads as this, so losing a signature counts as a change of\n// signer rather than as something to wave through.\nexport const UNSIGNED = \"\";\n// What fixes both of the signature problems we report, so the message can say so rather than\n// leaving someone to work it out.\nconst SIGN_COMMAND = \"yarn signfiles git\";\n\n/** A repo that cannot be trusted, with the message ready for whoever asked. Not every caller\n    treats these the same - a source keeps its last keys, a machine list is just refused - so the\n    kind is carried rather than acted on here. */\nexport class SignedRepoError extends Error {\n    constructor(public problem: string, public headline: string, public body: string) {\n        super(`${headline}. ${body}`);\n    }\n}\n\n/** Everything a signed checkout vouches for, in one call: who signed it, and the contents of every\n    file the signature actually covers.\n\n    UNSIGNED with no files when there is no signature at all. Throws a SignedRepoError when a\n    signature is present but does not hold up, or when a file it signed for was changed or removed\n    without re-signing - either way the caller keeps whatever it last accepted rather than believing\n    a repo that no longer matches what was signed. A file not in the manifest is just unsigned, so\n    it is left out and warned about rather than treated as tampering. */\nexport async function readSignedRepo(repoPath: string): Promise<{\n    signer: string;\n    manifestHash: string;\n    signatureHash: string;\n    files: Map<string, Buffer>;\n}> {\n    let manifestBytes = await fs.readFile(path.join(repoPath, MANIFEST_NAME)).catch(() => undefined);\n    let signatureBytes = await fs.readFile(path.join(repoPath, SIGNATURE_NAME)).catch(() => undefined);\n    let manifestHash = manifestBytes && crypto.createHash(\"sha256\").update(manifestBytes).digest(\"hex\") || \"\";\n    let signatureHash = signatureBytes && crypto.createHash(\"sha256\").update(signatureBytes).digest(\"hex\") || \"\";\n\n    if (!manifestBytes && !signatureBytes) {\n        console.log(`${repoPath} is not signed, ignoring all of its files`);\n        return { signer: UNSIGNED, manifestHash, signatureHash, files: new Map() };\n    }\n\n    let broken = (detail: string) => new SignedRepoError(\n        \"corrupt\",\n        `KEY REPO SIGNATURE IS BROKEN`,\n        `The signature on ${repoPath} does not check out, so everything in it is being ignored and`\n        + ` this machine keeps using what it last accepted.\\n\\n${detail}`\n        + `\\n\\nTo replace the signature, run in that repo:\\n\\`\\`\\`\\n${SIGN_COMMAND}\\n\\`\\`\\``\n    );\n    if (!manifestBytes || !signatureBytes) {\n        throw broken(`Only one of ${MANIFEST_NAME} and ${SIGNATURE_NAME} is present.`);\n    }\n\n    let signer: string;\n    try {\n        // The signature covers the normalised bytes, so a checkout that arrived with CRLF still\n        // verifies rather than looking like tampering.\n        signer = verifySSHSIG({\n            signature: signatureBytes.toString(\"utf8\"),\n            message: normalizeContent(manifestBytes),\n            namespace: SIGN_NAMESPACE,\n        }).publicKey;\n    } catch (e) {\n        throw broken(`${e}`);\n    }\n\n    let stale = (detail: string) => new SignedRepoError(\n        \"stale\",\n        `KEY REPO CHANGED WITHOUT BEING SIGNED`,\n        `${detail}, so the repo is being ignored and this machine keeps using what it last accepted.`\n        + `\\n\\nTo make the change take effect, run in that repo:\\n\\`\\`\\`\\n${SIGN_COMMAND}\\n\\`\\`\\``\n    );\n\n    // Every file on disk, other than git's own directory and the two signature files, which cannot\n    // describe themselves.\n    let listCheckoutFiles = async (prefix?: string): Promise<string[]> => {\n        let found: string[] = [];\n        for (let entry of await fs.readdir(path.join(repoPath, prefix || \"\"), { withFileTypes: true })) {\n            let relativePath = prefix && `${prefix}/${entry.name}` || entry.name;\n            if (entry.name === \".git\") continue;\n            if (!prefix && (entry.name === MANIFEST_NAME || entry.name === SIGNATURE_NAME)) continue;\n            if (entry.isDirectory()) {\n                found.push(...await listCheckoutFiles(relativePath));\n                continue;\n            }\n            found.push(relativePath);\n        }\n        return found.sort();\n    };\n\n    let manifest = JSON.parse(manifestBytes.toString(\"utf8\"));\n    let listed = new Map<string, { size: number; sha256: string }>(\n        (manifest.files || []).map((file: { path: string; size: number; sha256: string }) => [file.path, file])\n    );\n\n    let files = new Map<string, Buffer>();\n    for (let filePath of await listCheckoutFiles()) {\n        let expected = listed.get(filePath);\n        // A file the signature never mentioned is not tampering, it is just unsigned - left out\n        // rather than trusted. An extra file in a working tree is ordinary, so it is only a note.\n        if (!expected) {\n            console.log(`Ignoring ${path.join(repoPath, filePath)}, it is not in the signed manifest`);\n            continue;\n        }\n        let contents = normalizeContent(await fs.readFile(path.join(repoPath, filePath)));\n        let hash = crypto.createHash(\"sha256\").update(contents).digest(\"hex\");\n        // A file the manifest DOES name, but whose content no longer matches, is a signed file\n        // changed without re-signing - the repo being edited out from under its signature.\n        if (contents.length !== expected.size || hash !== expected.sha256) {\n            throw stale(`${path.join(repoPath, filePath)} was changed after it was signed`);\n        }\n        files.set(filePath, contents);\n    }\n    for (let filePath of listed.keys()) {\n        if (!files.has(filePath)) {\n            throw stale(`${path.join(repoPath, filePath)} is signed for but missing`);\n        }\n    }\n\n    return { signer, manifestHash, signatureHash, files };\n}\n"]}
- /* _JS_SOURCE_HASH = "7efe11ad80e1fd0da4255a229551a7973443a58b48163d836cf32e330cced446"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trust.js","sourceRoot":"","sources":["trust.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport { MANIFEST_NAME, normalizeContent, SIGN_NAMESPACE, SIGNATURE_NAME } from \"../../signedFiles/manifest\";\nimport { verifySSHSIG } from \"../../signedFiles/sshsig\";\nimport { keyFingerprint } from \"../authorizedKeys\";\nimport { revokeRepoPath } from \"../revokeSource\";\n\n// A source that has never been signed reads as this, so losing a signature counts as a change of\n// signer rather than as something to wave through.\nexport const UNSIGNED = \"\";\n// What fixes both of the signature problems we report, so the message can say so rather than\n// leaving someone to work it out.\nconst SIGN_COMMAND = \"yarn signfiles git\";\nconst REVOCATIONS_DIR = \"revocations\";\nconst UNREVOKES_DIR = \"unrevoked\";\n\n// Every revocation this process has ever seen, keyed by revocation id. Once absorbed a revocation\n// never leaves, even if its file disappears from the revoke repo - the key that writes revocations\n// is on every server, so whoever stole one could otherwise erase the record that shut them out.\n// Restarting the process is the way back from a revocation that should not have happened.\nlet absorbedRevocations = new Map<string, { identity: string; ip: string }>();\n// The pairs the signed unrevokes allow, and the legacy revocation ids they name. Rebuilt on every\n// read, since unrevokes are signed content and removing one must take effect.\nlet unrevokedPairs = new Set<string>();\nlet unrevokedIds = new Set<string>();\n\n/** Whether an identity - a key fingerprint or a machine id - has a revocation nothing has undone.\n    The one meaning of \"frozen\", used both when stripping repo content and when explaining why. */\nexport function isIdentityFrozen(identity: string) {\n    for (let [revocationId, revocation] of absorbedRevocations) {\n        if (revocation.identity !== identity) {\n            continue;\n        }\n        if (unrevokedIds.has(revocationId) || unrevokedPairs.has(`${identity} ${revocation.ip}`)) {\n            continue;\n        }\n        return true;\n    }\n    return false;\n}\n\nexport function isPairRevoked(identity: string, ip: string) {\n    for (let [revocationId, revocation] of absorbedRevocations) {\n        if (revocation.identity === identity && revocation.ip === ip && !unrevokedIds.has(revocationId)) {\n            return true;\n        }\n    }\n    return false;\n}\n\nexport function isPairUnrevoked(identity: string, ip: string) {\n    return unrevokedPairs.has(`${identity} ${ip}`);\n}\n\n/** For whoever just wrote a revocation, so it holds here immediately rather than on the next\n    absorb. Sticky like the rest. */\nexport function noteRevocation(revocationId: string, identity: string, ip: string) {\n    absorbedRevocations.set(revocationId, { identity, ip });\n}\n\n/** A repo that cannot be trusted, with the message ready for whoever asked. Not every caller\n    treats these the same - a source keeps its last keys, a machine list is just refused - so the\n    kind is carried rather than acted on here. */\nexport class SignedRepoError extends Error {\n    constructor(public problem: string, public headline: string, public body: string) {\n        super(`${headline}. ${body}`);\n    }\n}\n\n/** Everything a signed checkout vouches for, in one call: who signed it, and the contents of every\n    file the signature actually covers.\n\n    UNSIGNED with no files when there is no signature at all. Throws a SignedRepoError when a\n    signature is present but does not hold up, or when a file it signed for was changed or removed\n    without re-signing - either way the caller keeps whatever it last accepted rather than believing\n    a repo that no longer matches what was signed. A file not in the manifest is just unsigned, so\n    it is left out and warned about rather than treated as tampering. */\nexport async function readSignedRepo(config: { repoPath: string; sourceURL: string }): Promise<{\n    signer: string;\n    manifestHash: string;\n    signatureHash: string;\n    files: Map<string, Buffer>;\n}> {\n    let { repoPath, sourceURL } = config;\n    let manifestBytes = await fs.readFile(path.join(repoPath, MANIFEST_NAME)).catch(() => undefined);\n    let signatureBytes = await fs.readFile(path.join(repoPath, SIGNATURE_NAME)).catch(() => undefined);\n    let manifestHash = manifestBytes && crypto.createHash(\"sha256\").update(manifestBytes).digest(\"hex\") || \"\";\n    let signatureHash = signatureBytes && crypto.createHash(\"sha256\").update(signatureBytes).digest(\"hex\") || \"\";\n\n    if (!manifestBytes && !signatureBytes) {\n        console.log(`${repoPath} is not signed, ignoring all of its files`);\n        return { signer: UNSIGNED, manifestHash, signatureHash, files: new Map() };\n    }\n\n    let broken = (detail: string) => new SignedRepoError(\n        \"corrupt\",\n        `KEY REPO SIGNATURE IS BROKEN`,\n        `The signature on ${repoPath} does not check out, so everything in it is being ignored and`\n        + ` this machine keeps using what it last accepted.\\n\\n${detail}`\n        + `\\n\\nTo replace the signature, run in that repo:\\n\\`\\`\\`\\n${SIGN_COMMAND}\\n\\`\\`\\``\n    );\n    if (!manifestBytes || !signatureBytes) {\n        throw broken(`Only one of ${MANIFEST_NAME} and ${SIGNATURE_NAME} is present.`);\n    }\n\n    let signer: string;\n    try {\n        // The signature covers the normalised bytes, so a checkout that arrived with CRLF still\n        // verifies rather than looking like tampering.\n        signer = verifySSHSIG({\n            signature: signatureBytes.toString(\"utf8\"),\n            message: normalizeContent(manifestBytes),\n            namespace: SIGN_NAMESPACE,\n        }).publicKey;\n    } catch (e) {\n        throw broken(`${e}`);\n    }\n\n    let stale = (detail: string) => new SignedRepoError(\n        \"stale\",\n        `KEY REPO CHANGED WITHOUT BEING SIGNED`,\n        `${detail}, so the repo is being ignored and this machine keeps using what it last accepted.`\n        + `\\n\\nTo make the change take effect, run in that repo:\\n\\`\\`\\`\\n${SIGN_COMMAND}\\n\\`\\`\\``\n    );\n\n    // Every file on disk, other than git's own directory and the two signature files, which cannot\n    // describe themselves.\n    let listCheckoutFiles = async (prefix?: string): Promise<string[]> => {\n        let found: string[] = [];\n        for (let entry of await fs.readdir(path.join(repoPath, prefix || \"\"), { withFileTypes: true })) {\n            let relativePath = prefix && `${prefix}/${entry.name}` || entry.name;\n            if (entry.name === \".git\") continue;\n            if (!prefix && (entry.name === MANIFEST_NAME || entry.name === SIGNATURE_NAME)) continue;\n            if (entry.isDirectory()) {\n                found.push(...await listCheckoutFiles(relativePath));\n                continue;\n            }\n            found.push(relativePath);\n        }\n        return found.sort();\n    };\n\n    let manifest = JSON.parse(manifestBytes.toString(\"utf8\"));\n    let listed = new Map<string, { size: number; sha256: string }>(\n        (manifest.files || []).map((file: { path: string; size: number; sha256: string }) => [file.path, file])\n    );\n\n    let files = new Map<string, Buffer>();\n    for (let filePath of await listCheckoutFiles()) {\n        let expected = listed.get(filePath);\n        // A file the signature never mentioned is not tampering, it is just unsigned - left out\n        // rather than trusted. An extra file in a working tree is ordinary, so it is only a note.\n        if (!expected) {\n            console.log(`Ignoring ${path.join(repoPath, filePath)}, it is not in the signed manifest`);\n            continue;\n        }\n        let contents = normalizeContent(await fs.readFile(path.join(repoPath, filePath)));\n        let hash = crypto.createHash(\"sha256\").update(contents).digest(\"hex\");\n        // A file the manifest DOES name, but whose content no longer matches, is a signed file\n        // changed without re-signing - the repo being edited out from under its signature.\n        if (contents.length !== expected.size || hash !== expected.sha256) {\n            throw stale(`${path.join(repoPath, filePath)} was changed after it was signed`);\n        }\n        files.set(filePath, contents);\n    }\n    for (let filePath of listed.keys()) {\n        if (!files.has(filePath)) {\n            throw stale(`${path.join(repoPath, filePath)} is signed for but missing`);\n        }\n    }\n\n    // Absorb the revoke repo's files into the sticky map. Once seen a revocation never leaves it,\n    // even if its file disappears - the key that writes revocations is on every server, so whoever\n    // stole one could otherwise erase the record that shut them out.\n    let revocationsDirectory = path.join(revokeRepoPath(sourceURL), REVOCATIONS_DIR);\n    for (let name of (await fs.readdir(revocationsDirectory).catch(() => [] as string[])).sort()) {\n        if (!name.endsWith(\".json\")) {\n            continue;\n        }\n        try {\n            let parsed = JSON.parse(await fs.readFile(path.join(revocationsDirectory, name), \"utf8\"));\n            let identity = parsed.fingerprint || parsed.machineId;\n            if (!identity) {\n                continue;\n            }\n            let revocationId = parsed.revocationId || name.replace(/\\.json$/, \"\");\n            if (!absorbedRevocations.has(revocationId)) {\n                absorbedRevocations.set(revocationId, { identity, ip: parsed.ip || parsed.attempt?.ip || \"\" });\n            }\n        } catch (e) {\n            console.log(`Ignoring unreadable revocation ${path.join(revocationsDirectory, name)}. ${e}`);\n        }\n    }\n\n    // Rebuild the unrevokes from the signed files just read. Unrevokes are signed content, so\n    // removing one must take effect, unlike the sticky revocations.\n    unrevokedPairs = new Set();\n    unrevokedIds = new Set();\n    for (let [filePath, contents] of files) {\n        if (!filePath.startsWith(`${UNREVOKES_DIR}/`) || !filePath.endsWith(\".json\")) {\n            continue;\n        }\n        try {\n            let parsed = JSON.parse(contents.toString(\"utf8\"));\n            for (let allowed of parsed.allowed || []) {\n                let identity = allowed.fingerprint || allowed.machineId;\n                if (identity && allowed.ip) {\n                    unrevokedPairs.add(`${identity} ${allowed.ip}`);\n                }\n            }\n            for (let revocationId of parsed.revocationIds || []) {\n                unrevokedIds.add(revocationId);\n            }\n        } catch (e) {\n            console.log(`Ignoring unreadable unrevoke ${filePath}. ${e}`);\n        }\n    }\n\n    // Drop everything frozen: revoked keys out of authorized_keys and top level .pub files, and\n    // frozen machines' files out of machines/. What comes back is what this machine actually\n    // trusts, so no caller can read the list and forget the revocations.\n    for (let [filePath, contents] of [...files]) {\n        if (filePath === \"authorized_keys\" || (filePath.endsWith(\".pub\") && !filePath.includes(\"/\"))) {\n            let lines = contents.toString(\"utf8\").split(\"\\n\");\n            let kept = lines.filter(line => {\n                let fingerprint = keyFingerprint(line);\n                if (fingerprint && isIdentityFrozen(fingerprint)) {\n                    console.log(`Dropping revoked key ${fingerprint} from ${path.join(repoPath, filePath)}`);\n                    return false;\n                }\n                return true;\n            });\n            if (kept.length !== lines.length) {\n                files.set(filePath, Buffer.from(kept.join(\"\\n\")));\n            }\n        }\n        if (filePath.startsWith(\"machines/\") && filePath.endsWith(\".json\")) {\n            let machineId = filePath.slice(\"machines/\".length, -\".json\".length);\n            if (isIdentityFrozen(machineId)) {\n                console.log(`Dropping frozen machine ${machineId} from ${path.join(repoPath, filePath)}`);\n                files.delete(filePath);\n            }\n        }\n    }\n\n    return { signer, manifestHash, signatureHash, files };\n}\n"]}
+ /* _JS_SOURCE_HASH = "dca3e0a9ba6326240f357f9f44b892b1cf1bf3622269921530457ceab4e3266a"; */

package/security/authorizedKeys/daemon/revocation.d.ts

@@ -65,10 +65,7 @@ export declare function absorbRevocations(sourceURLs: string[]): Promise<void>;
 
     What still protects a stolen signing key is the 24 hours before a NEW signer is accepted. */
 export declare function applyUnrevokes(sourceURLs: string[]): Promise<void>;
-/** Every key held out of authorized_keys: one that has at least one revocation nothing has
-    forgiven. A key forgiven for one address is an ordinary key again, and revoking it from another
-    address puts it back in here. */
-export declare function revokedFingerprints(): Set<string>;
-/** Drops revoked keys from the merged set, and says so the first time a key actually disappears -
-    which is the thing worth knowing, rather than the mere existence of a revocation. */
-export declare function removeRevokedKeys(keys: string[]): Promise<string[]>;
+/** Reports each revocation the first time it actually takes a key out of this machine's file. The
+    dropping itself happens in readSignedRepo, which strips revoked keys before anything reads them
+    - this only says so, and kills whatever sessions the key was holding open. */
+export declare function reportRevokedKeys(): Promise<void>;

package/security/authorizedKeys/daemon/trust.d.ts

@@ -1,6 +1,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 export declare const UNSIGNED = "";
+/** Whether an identity - a key fingerprint or a machine id - has a revocation nothing has undone.
+    The one meaning of "frozen", used both when stripping repo content and when explaining why. */
+export declare function isIdentityFrozen(identity: string): boolean;
+export declare function isPairRevoked(identity: string, ip: string): boolean;
+export declare function isPairUnrevoked(identity: string, ip: string): boolean;
+/** For whoever just wrote a revocation, so it holds here immediately rather than on the next
+    absorb. Sticky like the rest. */
+export declare function noteRevocation(revocationId: string, identity: string, ip: string): void;
 /** A repo that cannot be trusted, with the message ready for whoever asked. Not every caller
     treats these the same - a source keeps its last keys, a machine list is just refused - so the
     kind is carried rather than acted on here. */
@@ -18,7 +26,10 @@ export declare class SignedRepoError extends Error {
     without re-signing - either way the caller keeps whatever it last accepted rather than believing
     a repo that no longer matches what was signed. A file not in the manifest is just unsigned, so
     it is left out and warned about rather than treated as tampering. */
-export declare function readSignedRepo(repoPath: string): Promise<{
+export declare function readSignedRepo(config: {
+    repoPath: string;
+    sourceURL: string;
+}): Promise<{
     signer: string;
     manifestHash: string;
     signatureHash: string;

package/security/authorizedKeys/daemon/trust.ts

@@ -3,6 +3,8 @@ import fs from "fs/promises";
 import path from "path";
 import { MANIFEST_NAME, normalizeContent, SIGN_NAMESPACE, SIGNATURE_NAME } from "../../signedFiles/manifest";
 import { verifySSHSIG } from "../../signedFiles/sshsig";
+import { keyFingerprint } from "../authorizedKeys";
+import { revokeRepoPath } from "../revokeSource";
 
 // A source that has never been signed reads as this, so losing a signature counts as a change of
 // signer rather than as something to wave through.
@@ -10,6 +12,52 @@ export const UNSIGNED = "";
 // What fixes both of the signature problems we report, so the message can say so rather than
 // leaving someone to work it out.
 const SIGN_COMMAND = "yarn signfiles git";
+const REVOCATIONS_DIR = "revocations";
+const UNREVOKES_DIR = "unrevoked";
+
+// Every revocation this process has ever seen, keyed by revocation id. Once absorbed a revocation
+// never leaves, even if its file disappears from the revoke repo - the key that writes revocations
+// is on every server, so whoever stole one could otherwise erase the record that shut them out.
+// Restarting the process is the way back from a revocation that should not have happened.
+let absorbedRevocations = new Map<string, { identity: string; ip: string }>();
+// The pairs the signed unrevokes allow, and the legacy revocation ids they name. Rebuilt on every
+// read, since unrevokes are signed content and removing one must take effect.
+let unrevokedPairs = new Set<string>();
+let unrevokedIds = new Set<string>();
+
+/** Whether an identity - a key fingerprint or a machine id - has a revocation nothing has undone.
+    The one meaning of "frozen", used both when stripping repo content and when explaining why. */
+export function isIdentityFrozen(identity: string) {
+    for (let [revocationId, revocation] of absorbedRevocations) {
+        if (revocation.identity !== identity) {
+            continue;
+        }
+        if (unrevokedIds.has(revocationId) || unrevokedPairs.has(`${identity} ${revocation.ip}`)) {
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+
+export function isPairRevoked(identity: string, ip: string) {
+    for (let [revocationId, revocation] of absorbedRevocations) {
+        if (revocation.identity === identity && revocation.ip === ip && !unrevokedIds.has(revocationId)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export function isPairUnrevoked(identity: string, ip: string) {
+    return unrevokedPairs.has(`${identity} ${ip}`);
+}
+
+/** For whoever just wrote a revocation, so it holds here immediately rather than on the next
+    absorb. Sticky like the rest. */
+export function noteRevocation(revocationId: string, identity: string, ip: string) {
+    absorbedRevocations.set(revocationId, { identity, ip });
+}
 
 /** A repo that cannot be trusted, with the message ready for whoever asked. Not every caller
     treats these the same - a source keeps its last keys, a machine list is just refused - so the
@@ -28,12 +76,13 @@ export class SignedRepoError extends Error {
     without re-signing - either way the caller keeps whatever it last accepted rather than believing
     a repo that no longer matches what was signed. A file not in the manifest is just unsigned, so
     it is left out and warned about rather than treated as tampering. */
-export async function readSignedRepo(repoPath: string): Promise<{
+export async function readSignedRepo(config: { repoPath: string; sourceURL: string }): Promise<{
     signer: string;
     manifestHash: string;
     signatureHash: string;
     files: Map<string, Buffer>;
 }> {
+    let { repoPath, sourceURL } = config;
     let manifestBytes = await fs.readFile(path.join(repoPath, MANIFEST_NAME)).catch(() => undefined);
     let signatureBytes = await fs.readFile(path.join(repoPath, SIGNATURE_NAME)).catch(() => undefined);
     let manifestHash = manifestBytes && crypto.createHash("sha256").update(manifestBytes).digest("hex") || "";
@@ -121,5 +170,79 @@ export async function readSignedRepo(repoPath: string): Promise<{
         }
     }
 
+    // Absorb the revoke repo's files into the sticky map. Once seen a revocation never leaves it,
+    // even if its file disappears - the key that writes revocations is on every server, so whoever
+    // stole one could otherwise erase the record that shut them out.
+    let revocationsDirectory = path.join(revokeRepoPath(sourceURL), REVOCATIONS_DIR);
+    for (let name of (await fs.readdir(revocationsDirectory).catch(() => [] as string[])).sort()) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await fs.readFile(path.join(revocationsDirectory, name), "utf8"));
+            let identity = parsed.fingerprint || parsed.machineId;
+            if (!identity) {
+                continue;
+            }
+            let revocationId = parsed.revocationId || name.replace(/\.json$/, "");
+            if (!absorbedRevocations.has(revocationId)) {
+                absorbedRevocations.set(revocationId, { identity, ip: parsed.ip || parsed.attempt?.ip || "" });
+            }
+        } catch (e) {
+            console.log(`Ignoring unreadable revocation ${path.join(revocationsDirectory, name)}. ${e}`);
+        }
+    }
+
+    // Rebuild the unrevokes from the signed files just read. Unrevokes are signed content, so
+    // removing one must take effect, unlike the sticky revocations.
+    unrevokedPairs = new Set();
+    unrevokedIds = new Set();
+    for (let [filePath, contents] of files) {
+        if (!filePath.startsWith(`${UNREVOKES_DIR}/`) || !filePath.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(contents.toString("utf8"));
+            for (let allowed of parsed.allowed || []) {
+                let identity = allowed.fingerprint || allowed.machineId;
+                if (identity && allowed.ip) {
+                    unrevokedPairs.add(`${identity} ${allowed.ip}`);
+                }
+            }
+            for (let revocationId of parsed.revocationIds || []) {
+                unrevokedIds.add(revocationId);
+            }
+        } catch (e) {
+            console.log(`Ignoring unreadable unrevoke ${filePath}. ${e}`);
+        }
+    }
+
+    // Drop everything frozen: revoked keys out of authorized_keys and top level .pub files, and
+    // frozen machines' files out of machines/. What comes back is what this machine actually
+    // trusts, so no caller can read the list and forget the revocations.
+    for (let [filePath, contents] of [...files]) {
+        if (filePath === "authorized_keys" || (filePath.endsWith(".pub") && !filePath.includes("/"))) {
+            let lines = contents.toString("utf8").split("\n");
+            let kept = lines.filter(line => {
+                let fingerprint = keyFingerprint(line);
+                if (fingerprint && isIdentityFrozen(fingerprint)) {
+                    console.log(`Dropping revoked key ${fingerprint} from ${path.join(repoPath, filePath)}`);
+                    return false;
+                }
+                return true;
+            });
+            if (kept.length !== lines.length) {
+                files.set(filePath, Buffer.from(kept.join("\n")));
+            }
+        }
+        if (filePath.startsWith("machines/") && filePath.endsWith(".json")) {
+            let machineId = filePath.slice("machines/".length, -".json".length);
+            if (isIdentityFrozen(machineId)) {
+                console.log(`Dropping frozen machine ${machineId} from ${path.join(repoPath, filePath)}`);
+                files.delete(filePath);
+            }
+        }
+    }
+
     return { signer, manifestHash, signatureHash, files };
 }