sliftutils 1.7.128 → 1.7.130

package/security/machines/dist/machines.ts.cache

@@ -0,0 +1,264 @@
+"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.isMachineAccepted = exports.setMachines = exports.getMachines = exports.MACHINES_DIR = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const keysRepo_1 = require("../authorizedKeys/keysRepo");
+const repoFiles_1 = require("../authorizedKeys/daemon/repoFiles");
+const repoFiles_2 = require("../authorizedKeys/daemon/repoFiles");
+const revocation_1 = require("../authorizedKeys/daemon/revocation");
+const git_1 = require("../authorizedKeys/daemon/git");
+const repoFiles_3 = require("../authorizedKeys/daemon/repoFiles");
+const trust_1 = require("../authorizedKeys/daemon/trust");
+const revokeSource_1 = require("../authorizedKeys/revokeSource");
+const notify_1 = require("../authorizedKeys/daemon/notify");
+const discord_1 = require("../notifications/discord");
+// Which machines this system talks to, kept in the same repo as the ssh keys. That repo is already
+// signed, already distributed to every machine, and already has somewhere to record a rejection,
+// so a second one would only be a second thing to keep in step.
+exports.MACHINES_DIR = "machines";
+const REVOCATIONS_DIR = "revocations";
+const REVOCATION_REASON = "a machine talked to us from an unapproved IP";
+// The revoke repo is pulled at most this often. A check happens per request, and a request must
+// not cost a round trip to github.
+const REVOKE_SYNC_INTERVAL = 60 * 1000;
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function machineFilePath(repoPath, machineId) {
+    return path_1.default.join(repoPath, exports.MACHINES_DIR, `${machineId}.json`);
+}
+/** Every machine a checkout lists. */
+async function getMachines(repoPath) {
+    return [...(await readMachines(repoPath)).values()];
+}
+exports.getMachines = getMachines;
+/** Makes a checkout list exactly these machines: those named are written with the addresses given,
+    and anything not named is removed. So read them, change what you want, and write the result.
+
+    The addresses are part of setting rather than a separate step, because a machine with no
+    address it may talk from is not a machine that would ever be accepted - there is no state where
+    naming one without them means anything.
+
+    Nothing here signs or commits. The signature is what every other machine checks before
+    believing any of this, and it takes the hardware key, so `yarn signfiles git` is still yours to
+    run afterwards. */
+async function setMachines(config) {
+    var _a;
+    let { repoPath, machines } = config;
+    let existing = await readMachines(repoPath);
+    let directory = path_1.default.join(repoPath, exports.MACHINES_DIR);
+    let written = [];
+    for (let machine of machines) {
+        if (!machine.machineId) {
+            throw new Error(`Expected a machineId, was ${JSON.stringify(machine.machineId)}`);
+        }
+        if (!machine.ips.length) {
+            throw new Error(`Expected addresses for ${machine.machineId}, was none. A machine is trusted from`
+                + ` the addresses it may talk from, so leave it out of the list to remove it.`);
+        }
+        let ips = machine.ips.filter((ip, index) => ip && machine.ips.indexOf(ip) === index);
+        let state = {
+            machineId: machine.machineId,
+            // In the order given, without duplicates, so the file reads the way it was set.
+            ips,
+            addedAt: ((_a = existing.get(machine.machineId)) === null || _a === void 0 ? void 0 : _a.addedAt) || new Date().toISOString(),
+        };
+        await promises_1.default.mkdir(directory, { recursive: true });
+        await promises_1.default.writeFile(machineFilePath(repoPath, state.machineId), JSON.stringify(state, undefined, 4) + "\n");
+        written.push(state);
+    }
+    // Whatever the repo had and the caller did not name is no longer trusted.
+    for (let machineId of existing.keys()) {
+        if (!machines.some(machine => machine.machineId === machineId)) {
+            await promises_1.default.rm(machineFilePath(repoPath, machineId), { force: true });
+        }
+    }
+    return written;
+}
+exports.setMachines = setMachines;
+/** Every machine the repo lists. */
+async function readMachines(repoPath) {
+    let machines = new Map();
+    let directory = path_1.default.join(repoPath, exports.MACHINES_DIR);
+    let names = await promises_1.default.readdir(directory).catch(() => []);
+    for (let name of names.sort()) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await promises_1.default.readFile(path_1.default.join(directory, name), "utf8"));
+            let machineId = parsed.machineId || name.replace(/\.json$/, "");
+            machines.set(machineId, { machineId, ips: parsed.ips || [], addedAt: parsed.addedAt || "" });
+        }
+        catch (e) {
+            console.log(`Ignoring unreadable machine file ${name}. ${e}`);
+        }
+    }
+    return machines;
+}
+let lastRevokeSync = 0;
+/** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that
+    fails leaves the checkout we already have, which is the safe direction: revocations we know
+    about stay known. */
+async function syncRevocations(sourceURL) {
+    if (Date.now() - lastRevokeSync < REVOKE_SYNC_INTERVAL) {
+        return;
+    }
+    lastRevokeSync = Date.now();
+    try {
+        await (0, repoFiles_1.syncRepoFiles)((0, repoFiles_1.revokeRepo)(sourceURL));
+    }
+    catch (e) {
+        console.log(`Could not read ${(0, revokeSource_1.revokeRepoURL)(sourceURL)}, using the revocations already here. ${e}`);
+    }
+}
+/** Machine revocations, read out of the revoke repo the same way key revocations are. */
+async function readMachineRevocations(sourceURL) {
+    let repo = (0, repoFiles_1.revokeRepo)(sourceURL);
+    let revocations = [];
+    for (let name of await (0, repoFiles_2.listRepoDir)(repo, REVOCATIONS_DIR)) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await (0, repoFiles_2.readRepoFile)(repo, path_1.default.join(REVOCATIONS_DIR, name)) || "");
+            if (parsed.machineId) {
+                revocations.push({
+                    revocationId: parsed.revocationId || name.replace(/\.json$/, ""),
+                    machineId: parsed.machineId,
+                    ip: parsed.ip || "",
+                });
+            }
+        }
+        catch (e) {
+            console.log(`Ignoring unreadable revocation ${name}. ${e}`);
+        }
+    }
+    return revocations;
+}
+/** Sends the one notification this file is allowed to send, when it can.
+
+    The daemon configures notifications on startup and would simply send. This can also run in some
+    other process, which has not, so the webhook is picked up here if it is readable. A machine
+    with no webhook set up still records the revocation - being unable to tell anyone is not a
+    reason to keep accepting a machine that is being misused. */
+async function notifyBestEffort(headline, body) {
+    try {
+        if (!(0, discord_1.areDiscordNotificationsConfigured)()) {
+            // Read first: configureDiscordNotifications exits the process when the file is missing,
+            // which is right for the daemon at startup and wrong for a library call.
+            await promises_1.default.readFile(discord_1.DEFAULT_WEBHOOK_FILE_PATH, "utf8");
+            await (0, discord_1.configureDiscordNotifications)({ filePath: discord_1.DEFAULT_WEBHOOK_FILE_PATH });
+        }
+        await (0, notify_1.notify)(headline, body);
+    }
+    catch (e) {
+        console.log(`Could not send a notification about this, it is only in the log. ${e}`);
+    }
+}
+/** Records that a machine we accept talked to us from an address it is not allowed from. One per
+    machine and address, so a second address is a second revocation and an unrevoke of the first
+    does not cover it. */
+async function recordMachineRevocation(config) {
+    let { sourceURL, machineId, ip, hostLabel } = config;
+    let repoPath = (0, revokeSource_1.revokeRepoPath)(sourceURL);
+    let keyPath = await (0, repoFiles_3.ensureRevokeKey)(sourceURL);
+    let revocationId = (0, revocation_1.newRevocationId)(machineId);
+    let directory = path_1.default.join(repoPath, REVOCATIONS_DIR);
+    await promises_1.default.mkdir(directory, { recursive: true });
+    await promises_1.default.writeFile(path_1.default.join(directory, `${revocationId}.json`), JSON.stringify({
+        revocationId,
+        machineId,
+        ip,
+        revokedAt: new Date().toISOString(),
+        revokedBy: hostLabel,
+        reason: REVOCATION_REASON,
+    }, undefined, 4) + "\n");
+    await (0, git_1.runGit)({ args: ["add", "-A"], cwd: repoPath, keyPath });
+    await (0, git_1.runGit)({
+        args: ["-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", `revoke ${revocationId}`],
+        cwd: repoPath, keyPath,
+    });
+    let push = await (0, git_1.runGit)({ args: ["push", "origin", "HEAD"], cwd: repoPath, keyPath, allowFailure: true });
+    if (push.status !== 0) {
+        // Another machine most likely recorded the same thing first, and the next read picks it up.
+        console.log(`Could not push the revocation of ${machineId} from ${ip}. ${(push.stdout + push.stderr).trim()}`);
+        return;
+    }
+    console.log(`Revoked ${machineId} from ${ip}, ${revocationId}`);
+    // Said by whoever wrote the revocation, once, the same as for an ssh key. Machines that only
+    // read it later say nothing, or one event would be reported by every machine that saw it.
+    await notifyBestEffort(`SUSPICIOUS IP ${ip} FROZE MACHINE ${machineId}`, `A machine we trust talked to us from ${ip}, which is not an address it is allowed to talk`
+        + ` from. It proved it holds that machine's key, so either someone else has a copy of it,`
+        + ` or that machine's address changed.`
+        + `\n\nIt is frozen everywhere now, and nothing accepts it.`
+        + `\n\nIf this was an attack, remove \`machines/${machineId}.json\` from \`${sourceURL}\` now.`
+        + `\nIf it was legitimate, run \`yarn unrevoke git\` in that repo. It allows ${ip} for that`
+        + ` machine, and takes effect as each machine picks it up.`
+        + `\n\nmachine: \`${machineId}\``
+        + `\nfrozen by: \`${hostLabel}\``);
+}
+async function isMachineAccepted(config) {
+    let { machineId, ip } = config;
+    if (!machineId || !ip) {
+        throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);
+    }
+    let { repoPath, sourceURL } = await (0, keysRepo_1.resolveKeysRepo)();
+    // Unsigned, or signed over different contents, means the machine list is not evidence of
+    // anything. Same gate the ssh keys go through.
+    await (0, trust_1.verifyCheckout)(repoPath);
+    let machine = (await readMachines(repoPath)).get(machineId);
+    if (!machine) {
+        return { accepted: false, reason: "that machine is not trusted" };
+    }
+    await syncRevocations(sourceURL);
+    let unrevokes = await (0, revocation_1.readUnrevokes)(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
+    // An unrevoke counts as soon as it is seen. It is signed, so writing one already takes the
+    // hardware key, and anyone holding that can sign anything at all - a wait before honouring it
+    // guards against an attacker who has no need of it.
+    let allowedAgain = (pair) => { var _a; return !!((_a = unrevokes.pairs.get(pair)) === null || _a === void 0 ? void 0 : _a.length); };
+    let revocations = await readMachineRevocations(sourceURL);
+    // Any revocation nothing has undone keeps the machine out, from everywhere, the way a revoked
+    // ssh key is out everywhere rather than only from the address it was misused from.
+    let frozenFrom = "";
+    for (let revocation of revocations) {
+        if (revocation.machineId !== machineId) {
+            continue;
+        }
+        if (!allowedAgain((0, revocation_1.pairKey)({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
+            frozenFrom = revocation.ip;
+        }
+    }
+    if (frozenFrom) {
+        return {
+            accepted: false,
+            reason: `that machine is frozen, it was used from ${frozenFrom} which it is not allowed from`,
+        };
+    }
+    if (machine.ips.includes(ip)) {
+        return { accepted: true, reason: "" };
+    }
+    // Listed, but talking to us from somewhere it should not be. Recorded once for this machine
+    // and address, so being talked to repeatedly does not write repeatedly.
+    let pair = (0, revocation_1.pairKey)({ fingerprint: machineId, ip });
+    let alreadyRecorded = revocations.some(revocation => (0, revocation_1.pairKey)({ fingerprint: revocation.machineId, ip: revocation.ip }) === pair);
+    if (!alreadyRecorded && !allowedAgain(pair)) {
+        await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os_1.default.hostname() });
+        return { accepted: false, reason: `that machine is not allowed from ${ip}, so it is now frozen everywhere` };
+    }
+    return { accepted: false, reason: `that machine is not allowed from ${ip}` };
+}
+exports.isMachineAccepted = isMachineAccepted;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"machines.js","sourceRoot":"","sources":["machines.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { revokeRepo, syncRepoFiles } from \"../authorizedKeys/daemon/repoFiles\";\nimport { listRepoDir, readRepoFile } from \"../authorizedKeys/daemon/repoFiles\";\nimport { newRevocationId, pairKey, readRevocationFiles, readUnrevokes } from \"../authorizedKeys/daemon/revocation\";\nimport { runGit } from \"../authorizedKeys/daemon/git\";\nimport { ensureRevokeKey } from \"../authorizedKeys/daemon/repoFiles\";\nimport { verifyCheckout } from \"../authorizedKeys/daemon/trust\";\nimport { revokeRepoPath, revokeRepoURL } from \"../authorizedKeys/revokeSource\";\nimport { notify } from \"../authorizedKeys/daemon/notify\";\nimport { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from \"../notifications/discord\";\nimport { spawnPromise } from \"../helpers/spawn\";\n\n// Which machines this system talks to, kept in the same repo as the ssh keys. That repo is already\n// signed, already distributed to every machine, and already has somewhere to record a rejection,\n// so a second one would only be a second thing to keep in step.\nexport const MACHINES_DIR = \"machines\";\nconst REVOCATIONS_DIR = \"revocations\";\nconst REVOCATION_REASON = \"a machine talked to us from an unapproved IP\";\n// The revoke repo is pulled at most this often. A check happens per request, and a request must\n// not cost a round trip to github.\nconst REVOKE_SYNC_INTERVAL = 60 * 1000;\n\n/** One machine we are willing to talk to, and the addresses it may talk to us from. */\nexport type MachineState = {\n    machineId: string;\n    ips: string[];\n    addedAt: string;\n};\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction machineFilePath(repoPath: string, machineId: string) {\n    return path.join(repoPath, MACHINES_DIR, `${machineId}.json`);\n}\n\n/** Every machine a checkout lists. */\nexport async function getMachines(repoPath: string): Promise<MachineState[]> {\n    return [...(await readMachines(repoPath)).values()];\n}\n\n/** Makes a checkout list exactly these machines: those named are written with the addresses given,\n    and anything not named is removed. So read them, change what you want, and write the result.\n\n    The addresses are part of setting rather than a separate step, because a machine with no\n    address it may talk from is not a machine that would ever be accepted - there is no state where\n    naming one without them means anything.\n\n    Nothing here signs or commits. The signature is what every other machine checks before\n    believing any of this, and it takes the hardware key, so `yarn signfiles git` is still yours to\n    run afterwards. */\nexport async function setMachines(config: {\n    repoPath: string;\n    machines: { machineId: string; ips: string[] }[];\n}): Promise<MachineState[]> {\n    let { repoPath, machines } = config;\n    let existing = await readMachines(repoPath);\n    let directory = path.join(repoPath, MACHINES_DIR);\n    let written: MachineState[] = [];\n    for (let machine of machines) {\n        if (!machine.machineId) {\n            throw new Error(`Expected a machineId, was ${JSON.stringify(machine.machineId)}`);\n        }\n        if (!machine.ips.length) {\n            throw new Error(\n                `Expected addresses for ${machine.machineId}, was none. A machine is trusted from`\n                + ` the addresses it may talk from, so leave it out of the list to remove it.`\n            );\n        }\n        let ips = machine.ips.filter((ip, index) => ip && machine.ips.indexOf(ip) === index);\n        let state: MachineState = {\n            machineId: machine.machineId,\n            // In the order given, without duplicates, so the file reads the way it was set.\n            ips,\n            addedAt: existing.get(machine.machineId)?.addedAt || new Date().toISOString(),\n        };\n        await fs.mkdir(directory, { recursive: true });\n        await fs.writeFile(machineFilePath(repoPath, state.machineId), JSON.stringify(state, undefined, 4) + \"\\n\");\n        written.push(state);\n    }\n\n    // Whatever the repo had and the caller did not name is no longer trusted.\n    for (let machineId of existing.keys()) {\n        if (!machines.some(machine => machine.machineId === machineId)) {\n            await fs.rm(machineFilePath(repoPath, machineId), { force: true });\n        }\n    }\n    return written;\n}\n\n/** Every machine the repo lists. */\nasync function readMachines(repoPath: string) {\n    let machines = new Map<string, MachineState>();\n    let directory = path.join(repoPath, MACHINES_DIR);\n    let names = await fs.readdir(directory).catch(() => [] as string[]);\n    for (let name of names.sort()) {\n        if (!name.endsWith(\".json\")) {\n            continue;\n        }\n        try {\n            let parsed = JSON.parse(await fs.readFile(path.join(directory, name), \"utf8\"));\n            let machineId = parsed.machineId || name.replace(/\\.json$/, \"\");\n            machines.set(machineId, { machineId, ips: parsed.ips || [], addedAt: parsed.addedAt || \"\" });\n        } catch (e) {\n            console.log(`Ignoring unreadable machine file ${name}. ${e}`);\n        }\n    }\n    return machines;\n}\n\nlet lastRevokeSync = 0;\n\n/** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that\n    fails leaves the checkout we already have, which is the safe direction: revocations we know\n    about stay known. */\nasync function syncRevocations(sourceURL: string) {\n    if (Date.now() - lastRevokeSync < REVOKE_SYNC_INTERVAL) {\n        return;\n    }\n    lastRevokeSync = Date.now();\n    try {\n        await syncRepoFiles(revokeRepo(sourceURL));\n    } catch (e) {\n        console.log(`Could not read ${revokeRepoURL(sourceURL)}, using the revocations already here. ${e}`);\n    }\n}\n\n/** Machine revocations, read out of the revoke repo the same way key revocations are. */\nasync function readMachineRevocations(sourceURL: string) {\n    let repo = revokeRepo(sourceURL);\n    let revocations: { revocationId: string; machineId: string; ip: string }[] = [];\n    for (let name of await listRepoDir(repo, REVOCATIONS_DIR)) {\n        if (!name.endsWith(\".json\")) {\n            continue;\n        }\n        try {\n            let parsed = JSON.parse(await readRepoFile(repo, path.join(REVOCATIONS_DIR, name)) || \"\");\n            if (parsed.machineId) {\n                revocations.push({\n                    revocationId: parsed.revocationId || name.replace(/\\.json$/, \"\"),\n                    machineId: parsed.machineId,\n                    ip: parsed.ip || \"\",\n                });\n            }\n        } catch (e) {\n            console.log(`Ignoring unreadable revocation ${name}. ${e}`);\n        }\n    }\n    return revocations;\n}\n\n/** Sends the one notification this file is allowed to send, when it can.\n\n    The daemon configures notifications on startup and would simply send. This can also run in some\n    other process, which has not, so the webhook is picked up here if it is readable. A machine\n    with no webhook set up still records the revocation - being unable to tell anyone is not a\n    reason to keep accepting a machine that is being misused. */\nasync function notifyBestEffort(headline: string, body: string) {\n    try {\n        if (!areDiscordNotificationsConfigured()) {\n            // Read first: configureDiscordNotifications exits the process when the file is missing,\n            // which is right for the daemon at startup and wrong for a library call.\n            await fs.readFile(DEFAULT_WEBHOOK_FILE_PATH, \"utf8\");\n            await configureDiscordNotifications({ filePath: DEFAULT_WEBHOOK_FILE_PATH });\n        }\n        await notify(headline, body);\n    } catch (e) {\n        console.log(`Could not send a notification about this, it is only in the log. ${e}`);\n    }\n}\n\n/** Records that a machine we accept talked to us from an address it is not allowed from. One per\n    machine and address, so a second address is a second revocation and an unrevoke of the first\n    does not cover it. */\nasync function recordMachineRevocation(config: {\n    sourceURL: string;\n    machineId: string;\n    ip: string;\n    hostLabel: string;\n}) {\n    let { sourceURL, machineId, ip, hostLabel } = config;\n    let repoPath = revokeRepoPath(sourceURL);\n    let keyPath = await ensureRevokeKey(sourceURL);\n    let revocationId = newRevocationId(machineId);\n    let directory = path.join(repoPath, REVOCATIONS_DIR);\n    await fs.mkdir(directory, { recursive: true });\n    await fs.writeFile(path.join(directory, `${revocationId}.json`), JSON.stringify({\n        revocationId,\n        machineId,\n        ip,\n        revokedAt: new Date().toISOString(),\n        revokedBy: hostLabel,\n        reason: REVOCATION_REASON,\n    }, undefined, 4) + \"\\n\");\n\n    await runGit({ args: [\"add\", \"-A\"], cwd: repoPath, keyPath });\n    await runGit({\n        args: [\"-c\", \"user.email=portsecure@localhost\", \"-c\", \"user.name=portsecure\", \"commit\", \"-m\", `revoke ${revocationId}`],\n        cwd: repoPath, keyPath,\n    });\n    let push = await runGit({ args: [\"push\", \"origin\", \"HEAD\"], cwd: repoPath, keyPath, allowFailure: true });\n    if (push.status !== 0) {\n        // Another machine most likely recorded the same thing first, and the next read picks it up.\n        console.log(`Could not push the revocation of ${machineId} from ${ip}. ${(push.stdout + push.stderr).trim()}`);\n        return;\n    }\n    console.log(`Revoked ${machineId} from ${ip}, ${revocationId}`);\n\n    // Said by whoever wrote the revocation, once, the same as for an ssh key. Machines that only\n    // read it later say nothing, or one event would be reported by every machine that saw it.\n    await notifyBestEffort(\n        `SUSPICIOUS IP ${ip} FROZE MACHINE ${machineId}`,\n        `A machine we trust talked to us from ${ip}, which is not an address it is allowed to talk`\n        + ` from. It proved it holds that machine's key, so either someone else has a copy of it,`\n        + ` or that machine's address changed.`\n        + `\\n\\nIt is frozen everywhere now, and nothing accepts it.`\n        + `\\n\\nIf this was an attack, remove \\`machines/${machineId}.json\\` from \\`${sourceURL}\\` now.`\n        + `\\nIf it was legitimate, run \\`yarn unrevoke git\\` in that repo. It allows ${ip} for that`\n        + ` machine, and takes effect as each machine picks it up.`\n        + `\\n\\nmachine: \\`${machineId}\\``\n        + `\\nfrozen by: \\`${hostLabel}\\``\n    );\n}\n\n/** Whether we will talk to this machine, coming from this address.\n\n    Both halves are required and neither is a guess: the caller knows the machine id because the\n    connection proved it, and knows the address because the packets came from there. A machine we\n    do not list is simply not accepted. A machine we do list, arriving from an address it does not\n    have, is treated as the same kind of event as a stolen ssh key - it is revoked everywhere, and\n    stays revoked until an unrevoke allows that machine from that address.\n\n    Says why when the answer is no, because the three ways to be refused are entirely different\n    things to a person reading it: never trusted at all, trusted but frozen, or trusted and talking\n    from somewhere it should not be.\n\n    Throws when the repo itself cannot be read or is not signed, rather than answering false: that\n    is a broken installation, not a rejected machine, and the two deserve different handling. */\nexport type MachineVerdict = { accepted: boolean; reason: string };\n\nexport async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<MachineVerdict> {\n    let { machineId, ip } = config;\n    if (!machineId || !ip) {\n        throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);\n    }\n    let { repoPath, sourceURL } = await resolveKeysRepo();\n    // Unsigned, or signed over different contents, means the machine list is not evidence of\n    // anything. Same gate the ssh keys go through.\n    await verifyCheckout(repoPath);\n\n    let machine = (await readMachines(repoPath)).get(machineId);\n    if (!machine) {\n        return { accepted: false, reason: \"that machine is not trusted\" };\n    }\n\n    await syncRevocations(sourceURL);\n    let unrevokes = await readUnrevokes(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));\n    // An unrevoke counts as soon as it is seen. It is signed, so writing one already takes the\n    // hardware key, and anyone holding that can sign anything at all - a wait before honouring it\n    // guards against an attacker who has no need of it.\n    let allowedAgain = (pair: string) => !!unrevokes.pairs.get(pair)?.length;\n    let revocations = await readMachineRevocations(sourceURL);\n    // Any revocation nothing has undone keeps the machine out, from everywhere, the way a revoked\n    // ssh key is out everywhere rather than only from the address it was misused from.\n    let frozenFrom = \"\";\n    for (let revocation of revocations) {\n        if (revocation.machineId !== machineId) {\n            continue;\n        }\n        if (!allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {\n            frozenFrom = revocation.ip;\n        }\n    }\n    if (frozenFrom) {\n        return {\n            accepted: false,\n            reason: `that machine is frozen, it was used from ${frozenFrom} which it is not allowed from`,\n        };\n    }\n\n    if (machine.ips.includes(ip)) {\n        return { accepted: true, reason: \"\" };\n    }\n\n    // Listed, but talking to us from somewhere it should not be. Recorded once for this machine\n    // and address, so being talked to repeatedly does not write repeatedly.\n    let pair = pairKey({ fingerprint: machineId, ip });\n    let alreadyRecorded = revocations.some(revocation =>\n        pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }) === pair);\n    if (!alreadyRecorded && !allowedAgain(pair)) {\n        await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os.hostname() });\n        return { accepted: false, reason: `that machine is not allowed from ${ip}, so it is now frozen everywhere` };\n    }\n    return { accepted: false, reason: `that machine is not allowed from ${ip}` };\n}\n"]}
+ /* _JS_SOURCE_HASH = "4f49b3c9f4a58987204c92820f6aca5ff7cf73325e697e849445299f06638103"; */

package/security/machines/dist/trustClient.ts.cache

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.main = exports.askIfTrusted = void 0;
+const identity_1 = require("./identity");
+// The other half of the demonstration: asks a server whether it trusts this machine. The answer
+// depends on the address this machine reaches the server from, which is why the client cannot
+// work it out alone.
+const TRUST_PATH = "/trusted";
+const USAGE = `Usage: yarn machineclient <url> <domain>
+
+Asks that server whether this machine is trusted, proving which machine it is with a signed packet.
+The server decides using the address we reach it from, so the answer is about how we are talking to
+it, not only about who we are.
+
+The domain is required: this machine has a different identity under each one, and the answer is
+about the identity we sign with.`;
+/** Asks one server whether it trusts this machine, as it is under this domain. */
+async function askIfTrusted(config) {
+    let { baseURL, domain } = config;
+    let packet = await (0, identity_1.signTrustPacket)(domain);
+    let url = `${baseURL.replace(/\/+$/, "")}${TRUST_PATH}`;
+    let response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(packet),
+    });
+    return await response.json();
+}
+exports.askIfTrusted = askIfTrusted;
+async function main() {
+    let [baseURL, domain] = process.argv.slice(2);
+    if (!baseURL || !domain) {
+        throw new Error(USAGE);
+    }
+    let answer = await askIfTrusted({ baseURL, domain });
+    console.log(`${answer.trusted && "TRUSTED" || "NOT TRUSTED"} by ${baseURL}`);
+    console.log(`  machine ${answer.machineId || "(not established)"}`);
+    console.log(`  seen coming from ${answer.ip || "(unknown)"}`);
+    if (answer.reason) {
+        console.log(`  ${answer.reason}`);
+    }
+    if (!answer.trusted) {
+        process.exitCode = 1;
+    }
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "51f52913bf4c7fbbeb7e5b3c70a7bc032fcc718b1eba1d8ed233fe7fe01617d2"; */

package/security/machines/dist/trustState.ts.cache

@@ -0,0 +1,57 @@
+"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.unrevokeInEffect = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../authorizedKeys/daemon/paths");
+const sources_1 = require("../authorizedKeys/sources");
+const discord_1 = require("../notifications/discord");
+// When this machine first saw each unrevoke, by unrevoke id.
+//
+// The same rule the ssh keys get, for the same reason: an unrevoke waits an hour before it counts,
+// so a signing key that was itself stolen cannot instantly undo the revocation that shut it out.
+// Counted from when we first saw it, never from a time the file states - whoever wrote the file
+// chooses that, and would choose an hour ago.
+//
+// On disk, because a check runs in whatever process happens to be asking. Measuring from process
+// start would restart the hour on every request and the unrevoke would never arrive. Kept beside
+// the repo keys rather than in the daemon's state, because this has to work on a machine with no
+// daemon, which is most of them.
+const FIRST_SEEN_FILE = "machine-unrevokes.json";
+function firstSeenPath() {
+    return path_1.default.join((0, sources_1.keysDir)(), FIRST_SEEN_FILE);
+}
+async function readFirstSeen() {
+    try {
+        return JSON.parse(await promises_1.default.readFile(firstSeenPath(), "utf8"));
+    }
+    catch (e) {
+        // Never written, or unreadable. Either way nothing has been seen before now.
+        return {};
+    }
+}
+/** Whether an unrevoke has waited out its hour, recording the first sighting if this is one.
+
+    Returns false the first time, which is the point: seeing an unrevoke is not the same as
+    honouring it. */
+async function unrevokeInEffect(unrevokeId) {
+    let firstSeen = await readFirstSeen();
+    let seenAt = firstSeen[unrevokeId];
+    if (!seenAt) {
+        seenAt = Date.now();
+        firstSeen[unrevokeId] = seenAt;
+        await promises_1.default.mkdir(path_1.default.dirname(firstSeenPath()), { recursive: true, mode: 0o700 });
+        await promises_1.default.writeFile(firstSeenPath(), JSON.stringify(firstSeen, undefined, 4) + "\n");
+    }
+    if (Date.now() - seenAt < paths_1.UNREVOKE_DELAY) {
+        console.log(`Holding the unrevoke ${unrevokeId} until ${(0, discord_1.messageTimestamp)(new Date(seenAt + paths_1.UNREVOKE_DELAY))}`);
+        return false;
+    }
+    return true;
+}
+exports.unrevokeInEffect = unrevokeInEffect;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "eaf8b0fd92f88a8682308f89a16f004ca1c28ff8bfcd90a56c734f63669c2aeb"; */

package/security/machines/identity.ts

@@ -0,0 +1,199 @@
+import crypto from "crypto";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { generateTestCA, getMachineId, identityStorageKey, IdentityStorageType, verifyMachineIdForPublicKey } from "../../misc/https/certs";
+import { runOverSSH, writeRemoteFile } from "../helpers/remoteSSH";
+
+// A machine's identity is the CA it generated for itself, kept in one file in the home directory
+// of whoever runs it. The name carries the domain it belongs to, so a machine can hold one per
+// domain, and the id itself is a hash of that CA's public key - which is why a machine cannot
+// claim to be another one without holding its key.
+const IDENTITY_PREFIX = "keystore_";
+const IDENTITY_SUFFIX = `_${identityStorageKey}.json`;
+// How stale a signed packet may be. Long enough for clock skew between two machines, short enough
+// that a captured packet is not worth replaying.
+export const PACKET_LIFETIME = 2 * 60 * 1000;
+
+export type Identity = {
+    machineId: string;
+    domain: string;
+    fullDomain: string;
+    fileName: string;
+};
+
+function identityFileName(domain: string) {
+    return `${IDENTITY_PREFIX}${domain}${IDENTITY_SUFFIX}`;
+}
+
+/** The domain out of an identity file's name, or "" if it is not one. */
+function domainOfFileName(fileName: string) {
+    if (!fileName.startsWith(IDENTITY_PREFIX) || !fileName.endsWith(IDENTITY_SUFFIX)) {
+        return "";
+    }
+    return fileName.slice(IDENTITY_PREFIX.length, -IDENTITY_SUFFIX.length);
+}
+
+function describeIdentity(config: { domain: string; stored: IdentityStorageType }) {
+    let { domain, stored } = config;
+    return {
+        machineId: getMachineId(stored.domain, domain),
+        domain,
+        fullDomain: stored.domain,
+        fileName: identityFileName(domain),
+    };
+}
+
+/** Every domain this machine holds an identity under. A machine has one identity per domain, and
+    they are different machine ids, so which one is meant is a real question rather than a detail. */
+export async function localDomains() {
+    let domains: string[] = [];
+    for (let name of (await fs.readdir(os.homedir()).catch(() => [] as string[])).sort()) {
+        let domain = domainOfFileName(name);
+        if (domain) {
+            domains.push(domain);
+        }
+    }
+    return domains;
+}
+
+/** This machine's identity under one domain. Undefined when it has none under that one.
+
+    The domain is required everywhere it appears. A machine has a different identity, and so a
+    different machine id, under every domain it runs under, so "this machine" on its own does not
+    name anything: answering under the wrong one means answering as a machine we are not. */
+export async function localIdentity(domain: string): Promise<Identity | undefined> {
+    if (!domain) {
+        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);
+    }
+    let contents = await fs.readFile(path.join(os.homedir(), identityFileName(domain)), "utf8").catch(() => "");
+    if (!contents) {
+        return undefined;
+    }
+    return describeIdentity({ domain, stored: JSON.parse(contents) });
+}
+
+/** This machine's identity and its keys, for signing. */
+export async function localIdentityKeys(domain: string) {
+    let identity = await localIdentity(domain);
+    if (!identity) {
+        throw new Error(
+            `Expected an identity for ${domain} at ${path.join(os.homedir(), identityFileName(domain))},`
+            + ` there is none.\n`
+            + `This machine has: ${(await localDomains()).join(", ") || "no identities at all"}`
+        );
+    }
+    let stored: IdentityStorageType = JSON.parse(
+        await fs.readFile(path.join(os.homedir(), identity.fileName), "utf8")
+    );
+    return { identity, stored };
+}
+
+/** The identity of another machine under one domain, over ssh. Undefined when it has none under
+    that domain, whatever else it may have under others. */
+export async function remoteIdentity(host: string, domain: string): Promise<Identity | undefined> {
+    if (!domain) {
+        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);
+    }
+    let home = (await runOverSSH({ host, script: `echo $HOME` })).stdout.trim();
+    if (!home) {
+        throw new Error(`Expected ${host} to report a home directory, it reported nothing`);
+    }
+    let contents = await runOverSSH({
+        host,
+        script: `cat ${home}/${identityFileName(domain)} 2>/dev/null || true`,
+    });
+    if (!contents.stdout.trim()) {
+        return undefined;
+    }
+    return describeIdentity({ domain, stored: JSON.parse(contents.stdout) });
+}
+
+/** Gives a machine an identity it does not have yet, by generating one here and writing it there.
+
+    The CA is self signed and never leaves that machine afterwards, so generating it here is only a
+    convenience: what matters is that the private key ends up in one place and the id is the hash
+    of its public half. */
+export async function createRemoteIdentity(config: { host: string; domain: string }) {
+    let { host, domain } = config;
+    let generated = generateTestCA(domain);
+    let stored: IdentityStorageType = {
+        domain: generated.domain,
+        certB64: generated.cert.toString("base64"),
+        keyB64: generated.key.toString("base64"),
+    };
+    let home = (await runOverSSH({ host, script: `echo $HOME` })).stdout.trim();
+    await writeRemoteFile({
+        host,
+        filePath: `${home}/${identityFileName(domain)}`,
+        contents: JSON.stringify(stored),
+        fileMode: "600",
+        // The home directory is already there, this is only what it is created with if it is not.
+        directoryMode: "700",
+    });
+    return describeIdentity({ domain, stored });
+}
+
+/** The raw ed25519 public key out of a certificate, which is what the machine id is a hash of. */
+function publicKeyBytes(certPEM: string) {
+    let spki = new crypto.X509Certificate(certPEM).publicKey.export({ type: "spki", format: "der" });
+    // An ed25519 SPKI is a fixed 12 byte header followed by the 32 byte key.
+    return spki.subarray(spki.length - 32);
+}
+
+export type TrustPacket = {
+    machineId: string;
+    certB64: string;
+    signedAt: number;
+    signatureB64: string;
+};
+
+/** Proves we hold the private key behind our machine id, right now. The signature covers the id
+    and the time, so the packet cannot be replayed later or reused for another id. */
+export async function signTrustPacket(domain: string): Promise<TrustPacket> {
+    let { identity, stored } = await localIdentityKeys(domain);
+    let signedAt = Date.now();
+    let signature = crypto.sign(
+        null,
+        Buffer.from(`${identity.machineId} ${signedAt}`),
+        crypto.createPrivateKey(Buffer.from(stored.keyB64, "base64").toString())
+    );
+    return {
+        machineId: identity.machineId,
+        certB64: stored.certB64,
+        signedAt,
+        signatureB64: signature.toString("base64"),
+    };
+}
+
+/** Whether a packet really came from the machine it names. Says why when it did not, because
+    "this is not that machine" and "this arrived too late" are different problems. */
+export function verifyTrustPacket(packet: TrustPacket) {
+    if (!packet || !packet.machineId || !packet.certB64 || !packet.signatureB64) {
+        return { valid: false, problem: "the packet is missing fields" };
+    }
+    if (Math.abs(Date.now() - packet.signedAt) > PACKET_LIFETIME) {
+        return { valid: false, problem: `it was signed ${Math.round((Date.now() - packet.signedAt) / 1000)}s ago` };
+    }
+    let certPEM = Buffer.from(packet.certB64, "base64").toString();
+    let publicKey: crypto.KeyObject;
+    try {
+        publicKey = new crypto.X509Certificate(certPEM).publicKey;
+    } catch (e) {
+        return { valid: false, problem: `its certificate could not be read, ${e}` };
+    }
+    // The id is a hash of the public key, so this is what stops a machine claiming another's id.
+    if (!verifyMachineIdForPublicKey({ machineId: packet.machineId, publicKey: publicKeyBytes(certPEM) })) {
+        return { valid: false, problem: "the machine id does not belong to that certificate" };
+    }
+    let signed = crypto.verify(
+        null,
+        Buffer.from(`${packet.machineId} ${packet.signedAt}`),
+        publicKey,
+        Buffer.from(packet.signatureB64, "base64")
+    );
+    if (!signed) {
+        return { valid: false, problem: "the signature does not check out" };
+    }
+    return { valid: true, problem: "" };
+}