sliftutils 1.7.130 → 1.7.132

package/security/machines/addMachine.ts

@@ -1,37 +1,75 @@
 import os from "os";
+import { runPromise } from "socket-function/src/runPromise";
 import { getOwnIPs } from "../../misc/ownIPs";
 import { describeHost } from "../helpers/remoteSSH";
 import { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from "./identity";
 import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
+import { signRepo } from "../signedFiles/signFiles";
 import { getMachines, setMachines } from "./machines";
 
-const USAGE = `Usage: yarn addmachine <domain> [ip]
+const GIT_KEYWORD = "git";
+const COMMIT_MESSAGE = "trusting a machine";
+// A machine id is the base32 hash of a public key, written with a leading b. Nothing else that can
+// appear in these arguments looks like that, which is what tells it apart from an ssh target.
+const MACHINE_ID = /^b[a-z2-7]{20}$/;
+const USAGE = `Usage:
+  yarn addmachine <domain> [${GIT_KEYWORD}]
+  yarn addmachine <domain> <ssh-host> [${GIT_KEYWORD}]
+  yarn addmachine <domain> <machine-id> <ip> [ip...] [${GIT_KEYWORD}]
 
 The domain is required: a machine has a different identity, and so a different machine id, under
 every domain it runs under, so there is no such thing as "this machine" without one.
 
-With no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh
-for its identity under that domain, gives it one if it has none, and adds it under that address.
+With nothing else it adds this machine, with its own addresses. With an ssh host it asks that
+machine for its identity under that domain, gives it one if it has none, and adds it under that
+address. With a machine id it adds exactly that machine at exactly those addresses, without
+talking to anything.
 
 It edits the keys repo this machine reads, wherever that is, not whatever directory this was run
-from. Nothing is signed or pushed here. Run "yarn signfiles git" in that repo afterwards, or no
-machine will believe any of it.`;
+from. With ${GIT_KEYWORD} it signs, commits and pushes; without it nothing else will believe any of
+this until you do.`;
 
-export async function main() {
-    let argv = process.argv.slice(2);
-    if (!argv.length || argv.length > 2) {
-        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\n${USAGE}`);
+/** A domain, then either nothing, an ssh host, or a machine id and the addresses it may talk from. */
+function parseArgs(argv: string[]) {
+    let pushToGit = argv.includes(GIT_KEYWORD);
+    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
+    let [domain, second, ...rest] = positional;
+    if (!domain) {
+        throw new Error(`Expected a domain\n${USAGE}`);
+    }
+    if (!second) {
+        return { domain, host: "", machineId: "", addresses: [] as string[], pushToGit };
+    }
+    if (MACHINE_ID.test(second)) {
+        if (!rest.length) {
+            throw new Error(`Expected at least one address for ${second}, was none\n${USAGE}`);
+        }
+        return { domain, host: "", machineId: second, addresses: rest, pushToGit };
+    }
+    if (rest.length) {
+        throw new Error(
+            `Expected nothing after the ssh host ${second}, was ${rest.join(" ")}.\n`
+            + `Addresses are only given alongside a machine id.\n${USAGE}`
+        );
     }
-    let [domain, host = ""] = argv;
+    return { domain, host: second, machineId: "", addresses: [] as string[], pushToGit };
+}
+
+export async function main() {
+    let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));
     // The same repo the acceptance check reads. Editing anything else would write a machine list
     // nothing on this machine ever looks at.
     let { repoPath } = await resolveKeysRepo();
 
-    let identity: Identity;
-    let addresses: string[];
-    if (!host) {
-        let found = await localIdentity(domain);
-        if (!found) {
+    let describe = machineId;
+    if (machineId) {
+        // Named outright, so there is nothing to ask anyone. The id is the hash of that machine's
+        // public key, so naming it is enough - it still has to prove it holds the key before any
+        // of this means anything.
+        describe = `${machineId} (named)`;
+    } else if (!host) {
+        let identity = await localIdentity(domain);
+        if (!identity) {
             throw new Error(
                 `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\n`
                 + `It has: ${(await localDomains()).join(", ") || "no identities at all"}\n`
@@ -39,7 +77,8 @@ export async function main() {
                 + ` first, or name another machine to add instead.`
             );
         }
-        identity = found;
+        machineId = identity.machineId;
+        describe = identity.fullDomain;
         addresses = await getOwnIPs();
         if (!addresses.length) {
             throw new Error(`Expected this machine to have an address anything else can see, it has none`);
@@ -51,7 +90,9 @@ export async function main() {
         if (!found) {
             console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);
         }
-        identity = found || await createRemoteIdentity({ host, domain });
+        let identity: Identity = found || await createRemoteIdentity({ host, domain });
+        machineId = identity.machineId;
+        describe = identity.fullDomain;
         // The address it was named by is the address it talks to us from, which is the one thing
         // it cannot lie about.
         addresses = [host];
@@ -60,25 +101,36 @@ export async function main() {
     // The whole list is read and written back, because setting is by the set: writing this one
     // machine alone would remove every other machine from the repo.
     let machines = await getMachines(repoPath);
-    let existing = machines.find(machine => machine.machineId === identity.machineId);
+    let existing = machines.find(machine => machine.machineId === machineId);
     let ips = [...(existing?.ips || [])];
     let added = addresses.filter(address => !ips.includes(address));
     if (existing) {
         existing.ips = [...ips, ...added];
     } else {
-        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: "" });
+        machines.push({ machineId, ips: [...added], addedAt: "" });
     }
     await setMachines({ repoPath, machines });
 
-    console.log(`\nTrusting machine ${identity.machineId}`);
+    console.log(`\nTrusting machine ${machineId}`);
     console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
     if (added.length) {
-        console.log(`  added to machines/${identity.machineId}.json: ${added.join(", ")}`);
+        console.log(`  added to machines/${machineId}.json: ${added.join(", ")}`);
     } else {
         console.log(`  already allowed from ${addresses.join(", ")}`);
     }
-    console.log(`  identity ${identity.fullDomain}`);
+    console.log(`  identity ${describe}`);
     console.log(`  in ${repoPath}`);
-    console.log(`\nNothing believes this until it is signed. In that repo, run:`);
-    console.log(`\`\`\`\nyarn signfiles git\n\`\`\``);
+
+    if (!pushToGit) {
+        console.log(`\nNothing believes this until it is signed. In that repo, run:`);
+        console.log(`\`\`\`\nyarn signfiles ${GIT_KEYWORD}\n\`\`\``);
+        return;
+    }
+    // Signed here rather than left as a step to remember, the same as unrevoke does it. A machine
+    // list nobody signed is ignored by every machine that reads it.
+    await signRepo({ repoPath });
+    await runPromise(`git add -A`, { cwd: repoPath });
+    await runPromise(`git commit -m "${COMMIT_MESSAGE}"`, { cwd: repoPath });
+    await runPromise(`git push`, { cwd: repoPath });
+    console.log(`\nSigned, committed and pushed. Machines pick it up as they sync.`);
 }

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

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const ownIPs_1 = require("../../misc/ownIPs");
 const remoteSSH_1 = require("../helpers/remoteSSH");
 const identity_1 = require("./identity");
+const keysRepo_1 = require("../authorizedKeys/keysRepo");
 const machines_1 = require("./machines");
 const USAGE = `Usage: yarn addmachine <domain> [ip]
 
@@ -28,7 +29,7 @@ async function main() {
     let [domain, host = ""] = argv;
     // The same repo the acceptance check reads. Editing anything else would write a machine list
     // nothing on this machine ever looks at.
-    let { repoPath } = await (0, machines_1.resolveKeysRepo)();
+    let { repoPath } = await (0, keysRepo_1.resolveKeysRepo)();
     let identity;
     let addresses;
     if (!host) {
@@ -59,7 +60,7 @@ async function main() {
     }
     // The whole list is read and written back, because setting is by the set: writing this one
     // machine alone would remove every other machine from the repo.
-    let machines = await (0, machines_1.machineState)({ repoPath });
+    let machines = await (0, machines_1.getMachines)(repoPath);
     let existing = machines.find(machine => machine.machineId === identity.machineId);
     let ips = [...((existing === null || existing === void 0 ? void 0 : existing.ips) || [])];
     let added = addresses.filter(address => !ips.includes(address));
@@ -69,7 +70,7 @@ async function main() {
     else {
         machines.push({ machineId: identity.machineId, ips: [...added], addedAt: "" });
     }
-    await (0, machines_1.machineState)({ repoPath, machines });
+    await (0, machines_1.setMachines)({ repoPath, machines });
     console.log(`\nTrusting machine ${identity.machineId}`);
     console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
     if (added.length) {
@@ -84,5 +85,5 @@ async function main() {
     console.log(`\`\`\`\nyarn signfiles git\n\`\`\``);
 }
 exports.main = main;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addMachine.js","sourceRoot":"","sources":["addMachine.ts"],"names":[],"mappings":"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","sourcesContent":["import os from \"os\";\nimport { getOwnIPs } from \"../../misc/ownIPs\";\nimport { describeHost } from \"../helpers/remoteSSH\";\nimport { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from \"./identity\";\nimport { machineState, resolveKeysRepo } from \"./machines\";\n\nconst USAGE = `Usage: yarn addmachine <domain> [ip]\n\nThe domain is required: a machine has a different identity, and so a different machine id, under\nevery domain it runs under, so there is no such thing as \"this machine\" without one.\n\nWith no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh\nfor its identity under that domain, gives it one if it has none, and adds it under that address.\n\nIt edits the keys repo this machine reads, wherever that is, not whatever directory this was run\nfrom. Nothing is signed or pushed here. Run \"yarn signfiles git\" in that repo afterwards, or no\nmachine will believe any of it.`;\n\nexport async function main() {\n    let argv = process.argv.slice(2);\n    if (!argv.length || argv.length > 2) {\n        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\\n${USAGE}`);\n    }\n    let [domain, host = \"\"] = argv;\n    // The same repo the acceptance check reads. Editing anything else would write a machine list\n    // nothing on this machine ever looks at.\n    let { repoPath } = await resolveKeysRepo();\n\n    let identity: Identity;\n    let addresses: string[];\n    if (!host) {\n        let found = await localIdentity(domain);\n        if (!found) {\n            throw new Error(\n                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\\n`\n                + `It has: ${(await localDomains()).join(\", \") || \"no identities at all\"}\\n`\n                + `One is generated the first time something runs here under a domain, so run that`\n                + ` first, or name another machine to add instead.`\n            );\n        }\n        identity = found;\n        addresses = await getOwnIPs();\n        if (!addresses.length) {\n            throw new Error(`Expected this machine to have an address anything else can see, it has none`);\n        }\n    } else {\n        // Nothing there under this domain means it gets one. Its own from this point on: the key\n        // is written there and nothing keeps a copy.\n        let found = await remoteIdentity(host, domain);\n        if (!found) {\n            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);\n        }\n        identity = found || await createRemoteIdentity({ host, domain });\n        // The address it was named by is the address it talks to us from, which is the one thing\n        // it cannot lie about.\n        addresses = [host];\n    }\n\n    // The whole list is read and written back, because setting is by the set: writing this one\n    // machine alone would remove every other machine from the repo.\n    let machines = await machineState({ repoPath });\n    let existing = machines.find(machine => machine.machineId === identity.machineId);\n    let ips = [...(existing?.ips || [])];\n    let added = addresses.filter(address => !ips.includes(address));\n    if (existing) {\n        existing.ips = [...ips, ...added];\n    } else {\n        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: \"\" });\n    }\n    await machineState({ repoPath, machines });\n\n    console.log(`\\nTrusting machine ${identity.machineId}`);\n    console.log(`Allowing IP ${[...ips, ...added].join(\", \")}`);\n    if (added.length) {\n        console.log(`  added to machines/${identity.machineId}.json: ${added.join(\", \")}`);\n    } else {\n        console.log(`  already allowed from ${addresses.join(\", \")}`);\n    }\n    console.log(`  identity ${identity.fullDomain}`);\n    console.log(`  in ${repoPath}`);\n    console.log(`\\nNothing believes this until it is signed. In that repo, run:`);\n    console.log(`\\`\\`\\`\\nyarn signfiles git\\n\\`\\`\\``);\n}\n"]}
- /* _JS_SOURCE_HASH = "8b6a7e13912660fd6733b2585e4fec0865a5548fe5846ee6e23f46c506f83e34"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addMachine.js","sourceRoot":"","sources":["addMachine.ts"],"names":[],"mappings":"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","sourcesContent":["import os from \"os\";\nimport { getOwnIPs } from \"../../misc/ownIPs\";\nimport { describeHost } from \"../helpers/remoteSSH\";\nimport { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from \"./identity\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { getMachines, setMachines } from \"./machines\";\n\nconst USAGE = `Usage: yarn addmachine <domain> [ip]\n\nThe domain is required: a machine has a different identity, and so a different machine id, under\nevery domain it runs under, so there is no such thing as \"this machine\" without one.\n\nWith no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh\nfor its identity under that domain, gives it one if it has none, and adds it under that address.\n\nIt edits the keys repo this machine reads, wherever that is, not whatever directory this was run\nfrom. Nothing is signed or pushed here. Run \"yarn signfiles git\" in that repo afterwards, or no\nmachine will believe any of it.`;\n\nexport async function main() {\n    let argv = process.argv.slice(2);\n    if (!argv.length || argv.length > 2) {\n        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\\n${USAGE}`);\n    }\n    let [domain, host = \"\"] = argv;\n    // The same repo the acceptance check reads. Editing anything else would write a machine list\n    // nothing on this machine ever looks at.\n    let { repoPath } = await resolveKeysRepo();\n\n    let identity: Identity;\n    let addresses: string[];\n    if (!host) {\n        let found = await localIdentity(domain);\n        if (!found) {\n            throw new Error(\n                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\\n`\n                + `It has: ${(await localDomains()).join(\", \") || \"no identities at all\"}\\n`\n                + `One is generated the first time something runs here under a domain, so run that`\n                + ` first, or name another machine to add instead.`\n            );\n        }\n        identity = found;\n        addresses = await getOwnIPs();\n        if (!addresses.length) {\n            throw new Error(`Expected this machine to have an address anything else can see, it has none`);\n        }\n    } else {\n        // Nothing there under this domain means it gets one. Its own from this point on: the key\n        // is written there and nothing keeps a copy.\n        let found = await remoteIdentity(host, domain);\n        if (!found) {\n            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);\n        }\n        identity = found || await createRemoteIdentity({ host, domain });\n        // The address it was named by is the address it talks to us from, which is the one thing\n        // it cannot lie about.\n        addresses = [host];\n    }\n\n    // The whole list is read and written back, because setting is by the set: writing this one\n    // machine alone would remove every other machine from the repo.\n    let machines = await getMachines(repoPath);\n    let existing = machines.find(machine => machine.machineId === identity.machineId);\n    let ips = [...(existing?.ips || [])];\n    let added = addresses.filter(address => !ips.includes(address));\n    if (existing) {\n        existing.ips = [...ips, ...added];\n    } else {\n        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: \"\" });\n    }\n    await setMachines({ repoPath, machines });\n\n    console.log(`\\nTrusting machine ${identity.machineId}`);\n    console.log(`Allowing IP ${[...ips, ...added].join(\", \")}`);\n    if (added.length) {\n        console.log(`  added to machines/${identity.machineId}.json: ${added.join(\", \")}`);\n    } else {\n        console.log(`  already allowed from ${addresses.join(\", \")}`);\n    }\n    console.log(`  identity ${identity.fullDomain}`);\n    console.log(`  in ${repoPath}`);\n    console.log(`\\nNothing believes this until it is signed. In that repo, run:`);\n    console.log(`\\`\\`\\`\\nyarn signfiles git\\n\\`\\`\\``);\n}\n"]}
+ /* _JS_SOURCE_HASH = "a28aef51d4e5c15665559ba6341cc219350f5b54987e7f2f257ccacaf827c938"; */

package/security/machines/dist/machines.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.isMachineAccepted = exports.setMachines = exports.getMachines = exports.MACHINES_DIR = void 0;
+//exports.isMachineAccepted = exports.addMachineCommand = exports.setMachines = exports.getTrustedMachines = exports.getMachines = exports.keysRepo = exports.MACHINES_DIR = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -17,6 +17,8 @@ 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");
+const caching_1 = require("socket-function/src/caching");
+const batching_1 = require("socket-function/src/batching");
 // 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.
@@ -26,6 +28,14 @@ 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;
+// And the machine list is re-read from the checkout on this interval, in the background. The
+// checkout itself only moves when the daemon pulls it, which is on the same sort of interval, so
+// reading more often than this would only re-read the same bytes.
+const MACHINES_REFRESH_INTERVAL = 60 * 1000;
+// How long a failure to find the keys repo is remembered. A long lived process may start before
+// the machine is set up, and should pick it up once it is, without being restarted - but it must
+// not pay for resolving the repo on every request either.
+const REPO_RETRY_DELAY = 15 * 1000;
 async function pathExists(filePath) {
     try {
         await promises_1.default.access(filePath);
@@ -38,11 +48,56 @@ async function pathExists(filePath) {
 function machineFilePath(repoPath, machineId) {
     return path_1.default.join(repoPath, exports.MACHINES_DIR, `${machineId}.json`);
 }
-/** Every machine a checkout lists. */
+/** This machine's keys repo, worked out once and then remembered.
+
+    A failure is remembered too, but only briefly: a server may well start before the machine has
+    been set up, and should start working when it is, rather than needing a restart. */
+exports.keysRepo = (0, caching_1.lazy)(async () => {
+    let lookup = (0, keysRepo_1.resolveKeysRepo)();
+    lookup.catch(() => {
+        setTimeout(() => exports.keysRepo.reset(), REPO_RETRY_DELAY).unref();
+    });
+    return await lookup;
+});
+/** Every machine a checkout lists. Without a repo, this machine's own. */
 async function getMachines(repoPath) {
-    return [...(await readMachines(repoPath)).values()];
+    return [...(await readMachines(repoPath || (await (0, exports.keysRepo)()).repoPath)).values()];
 }
 exports.getMachines = getMachines;
+/** Reads the machine list, once its signature has been checked. An unsigned machine list, or one
+    signed over different contents, is not evidence of anything, so this throws rather than
+    quietly trusting nobody. */
+async function readTrustedMachines() {
+    let { repoPath } = await (0, exports.keysRepo)();
+    await (0, trust_1.verifyCheckout)(repoPath);
+    return await getMachines(repoPath);
+}
+const trustedMachines = (0, caching_1.lazy)(async () => {
+    let read = readTrustedMachines();
+    read.catch(() => trustedMachines.reset());
+    return await read;
+});
+let refreshing = false;
+/** The machines this system trusts, as the signed repo lists them.
+
+    Held rather than read per call, and refreshed in the background, so nobody asking whether a
+    machine is trusted waits for a directory of files to be read and a signature to be checked. A
+    refresh that fails leaves the list we already have: the checkout is only stale, not wrong. */
+async function getTrustedMachines() {
+    if (!refreshing) {
+        refreshing = true;
+        (0, batching_1.runInfinitePoll)(MACHINES_REFRESH_INTERVAL, async () => {
+            try {
+                trustedMachines.set(Promise.resolve(await readTrustedMachines()));
+            }
+            catch (e) {
+                console.log(`Could not re-read the trusted machines, keeping the ones we have. ${e}`);
+            }
+        });
+    }
+    return await trustedMachines();
+}
+exports.getTrustedMachines = getTrustedMachines;
 /** 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.
 
@@ -55,7 +110,10 @@ exports.getMachines = getMachines;
     run afterwards. */
 async function setMachines(config) {
     var _a;
-    let { repoPath, machines } = config;
+    let { machines } = config;
+    let repoPath = config.repoPath || (await (0, exports.keysRepo)()).repoPath;
+    // Whatever was held is now stale, whoever reads it next.
+    trustedMachines.reset();
     let existing = await readMachines(repoPath);
     let directory = path_1.default.join(repoPath, exports.MACHINES_DIR);
     let written = [];
@@ -147,6 +205,17 @@ async function readMachineRevocations(sourceURL) {
     }
     return revocations;
 }
+/** What to run to trust a machine that has just been refused.
+
+    Everything in it is already known to whoever is being refused: their machine id, the address we
+    saw them at, and the domain they just talked to. Handing it back saves them working out the
+    parts of a command they have every right to know. Running it still takes the hardware key on
+    the machine that owns the repo, so telling them costs nothing. */
+function addMachineCommand(config) {
+    let { machineId, ip, domain } = config;
+    return `To trust it, run: yarn addmachine ${domain || "<domain>"} ${machineId} ${ip} git`;
+}
+exports.addMachineCommand = addMachineCommand;
 /** 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
@@ -210,17 +279,15 @@ async function recordMachineRevocation(config) {
         + `\nfrozen by: \`${hostLabel}\``);
 }
 async function isMachineAccepted(config) {
-    let { machineId, ip } = config;
+    let { machineId, ip, domain } = 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);
+    let { sourceURL } = await (0, exports.keysRepo)();
+    // Verified before it is believed, and cached, since this is asked once per request.
+    let machine = (await getTrustedMachines()).find(entry => entry.machineId === machineId);
     if (!machine) {
-        return { accepted: false, reason: "that machine is not trusted" };
+        return { accepted: false, reason: `that machine is not trusted. ${addMachineCommand({ machineId, ip, domain })}` };
     }
     await syncRevocations(sourceURL);
     let unrevokes = await (0, revocation_1.readUnrevokes)(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
@@ -260,5 +327,5 @@ async function isMachineAccepted(config) {
     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":";;;;;;AAAA,2DAA6B;AAC7B,4CAAoB;AACpB,gDAAwB;AACxB,yDAA6D;AAC7D,kEAA+E;AAC/E,kEAA+E;AAC/E,oEAAmH;AACnH,sDAAsD;AACtD,kEAAqE;AACrE,0DAAgE;AAChE,iEAA+E;AAC/E,4DAAyD;AACzD,sDAAuI;AAGvI,mGAAmG;AACnG,iGAAiG;AACjG,gEAAgE;AACnD,QAAA,YAAY,GAAG,UAAU,CAAC;AACvC,MAAM,eAAe,GAAG,aAAa,CAAC;AACtC,MAAM,iBAAiB,GAAG,8CAA8C,CAAC;AACzE,gGAAgG;AAChG,mCAAmC;AACnC,MAAM,oBAAoB,GAAG,EAAE,GAAG,IAAI,CAAC;AASvC,KAAK,UAAU,UAAU,CAAC,QAAgB;IACtC,IAAI,CAAC;QACD,MAAM,kBAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,KAAK,CAAC;IACjB,CAAC;AACL,CAAC;AAED,SAAS,eAAe,CAAC,QAAgB,EAAE,SAAiB;IACxD,OAAO,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAY,EAAE,GAAG,SAAS,OAAO,CAAC,CAAC;AAClE,CAAC;AAED,sCAAsC;AAC/B,KAAK,UAAU,WAAW,CAAC,QAAgB;IAC9C,OAAO,CAAC,GAAG,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AACxD,CAAC;AAFD,kCAEC;AAED;;;;;;;;;sBASsB;AACf,KAAK,UAAU,WAAW,CAAC,MAGjC;;IACG,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IACpC,IAAI,QAAQ,GAAG,MAAM,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC5C,IAAI,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAY,CAAC,CAAC;IAClD,IAAI,OAAO,GAAmB,EAAE,CAAC;IACjC,KAAK,IAAI,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,6BAA6B,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACtF,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACX,0BAA0B,OAAO,CAAC,SAAS,uCAAuC;kBAChF,4EAA4E,CACjF,CAAC;QACN,CAAC;QACD,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC;QACrF,IAAI,KAAK,GAAiB;YACtB,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,gFAAgF;YAChF,GAAG;YACH,OAAO,EAAE,CAAA,MAAA,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,0CAAE,OAAO,KAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SAChF,CAAC;QACF,MAAM,kBAAE,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/C,MAAM,kBAAE,CAAC,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAC3G,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED,0EAA0E;IAC1E,KAAK,IAAI,SAAS,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;QACpC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,EAAE,CAAC;YAC7D,MAAM,kBAAE,CAAC,EAAE,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACvE,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC;AArCD,kCAqCC;AAED,oCAAoC;AACpC,KAAK,UAAU,YAAY,CAAC,QAAgB;IACxC,IAAI,QAAQ,GAAG,IAAI,GAAG,EAAwB,CAAC;IAC/C,IAAI,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAY,CAAC,CAAC;IAClD,IAAI,KAAK,GAAG,MAAM,kBAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAc,CAAC,CAAC;IACpE,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1B,SAAS;QACb,CAAC;QACD,IAAI,CAAC;YACD,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,kBAAE,CAAC,QAAQ,CAAC,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;YAC/E,IAAI,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YAChE,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC,CAAC;QACjG,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,CAAC,GAAG,CAAC,oCAAoC,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC;QAClE,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED,IAAI,cAAc,GAAG,CAAC,CAAC;AAEvB;;wBAEwB;AACxB,KAAK,UAAU,eAAe,CAAC,SAAiB;IAC5C,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,GAAG,oBAAoB,EAAE,CAAC;QACrD,OAAO;IACX,CAAC;IACD,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC5B,IAAI,CAAC;QACD,MAAM,IAAA,yBAAa,EAAC,IAAA,sBAAU,EAAC,SAAS,CAAC,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAA,4BAAa,EAAC,SAAS,CAAC,yCAAyC,CAAC,EAAE,CAAC,CAAC;IACxG,CAAC;AACL,CAAC;AAED,yFAAyF;AACzF,KAAK,UAAU,sBAAsB,CAAC,SAAiB;IACnD,IAAI,IAAI,GAAG,IAAA,sBAAU,EAAC,SAAS,CAAC,CAAC;IACjC,IAAI,WAAW,GAA8D,EAAE,CAAC;IAChF,KAAK,IAAI,IAAI,IAAI,MAAM,IAAA,uBAAW,EAAC,IAAI,EAAE,eAAe,CAAC,EAAE,CAAC;QACxD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1B,SAAS;QACb,CAAC;QACD,IAAI,CAAC;YACD,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,IAAA,wBAAY,EAAC,IAAI,EAAE,cAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC1F,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;gBACnB,WAAW,CAAC,IAAI,CAAC;oBACb,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;oBAChE,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,EAAE,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE;iBACtB,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,CAAC,GAAG,CAAC,kCAAkC,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC;QAChE,CAAC;IACL,CAAC;IACD,OAAO,WAAW,CAAC;AACvB,CAAC;AAED;;;;;gEAKgE;AAChE,KAAK,UAAU,gBAAgB,CAAC,QAAgB,EAAE,IAAY;IAC1D,IAAI,CAAC;QACD,IAAI,CAAC,IAAA,2CAAiC,GAAE,EAAE,CAAC;YACvC,wFAAwF;YACxF,yEAAyE;YACzE,MAAM,kBAAE,CAAC,QAAQ,CAAC,mCAAyB,EAAE,MAAM,CAAC,CAAC;YACrD,MAAM,IAAA,uCAA6B,EAAC,EAAE,QAAQ,EAAE,mCAAyB,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,MAAM,IAAA,eAAM,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,CAAC,GAAG,CAAC,oEAAoE,CAAC,EAAE,CAAC,CAAC;IACzF,CAAC;AACL,CAAC;AAED;;yBAEyB;AACzB,KAAK,UAAU,uBAAuB,CAAC,MAKtC;IACG,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IACrD,IAAI,QAAQ,GAAG,IAAA,6BAAc,EAAC,SAAS,CAAC,CAAC;IACzC,IAAI,OAAO,GAAG,MAAM,IAAA,2BAAe,EAAC,SAAS,CAAC,CAAC;IAC/C,IAAI,YAAY,GAAG,IAAA,4BAAe,EAAC,SAAS,CAAC,CAAC;IAC9C,IAAI,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IACrD,MAAM,kBAAE,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/C,MAAM,kBAAE,CAAC,SAAS,CAAC,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,YAAY,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC;QAC5E,YAAY;QACZ,SAAS;QACT,EAAE;QACF,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,SAAS,EAAE,SAAS;QACpB,MAAM,EAAE,iBAAiB;KAC5B,EAAE,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAEzB,MAAM,IAAA,YAAM,EAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9D,MAAM,IAAA,YAAM,EAAC;QACT,IAAI,EAAE,CAAC,IAAI,EAAE,iCAAiC,EAAE,IAAI,EAAE,sBAAsB,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,YAAY,EAAE,CAAC;QACvH,GAAG,EAAE,QAAQ,EAAE,OAAO;KACzB,CAAC,CAAC;IACH,IAAI,IAAI,GAAG,MAAM,IAAA,YAAM,EAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1G,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpB,4FAA4F;QAC5F,OAAO,CAAC,GAAG,CAAC,oCAAoC,SAAS,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC/G,OAAO;IACX,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,WAAW,SAAS,SAAS,EAAE,KAAK,YAAY,EAAE,CAAC,CAAC;IAEhE,6FAA6F;IAC7F,0FAA0F;IAC1F,MAAM,gBAAgB,CAClB,iBAAiB,EAAE,kBAAkB,SAAS,EAAE,EAChD,wCAAwC,EAAE,iDAAiD;UACzF,wFAAwF;UACxF,qCAAqC;UACrC,0DAA0D;UAC1D,gDAAgD,SAAS,kBAAkB,SAAS,SAAS;UAC7F,6EAA6E,EAAE,WAAW;UAC1F,yDAAyD;UACzD,kBAAkB,SAAS,IAAI;UAC/B,kBAAkB,SAAS,IAAI,CACpC,CAAC;AACN,CAAC;AAkBM,KAAK,UAAU,iBAAiB,CAAC,MAAyC;IAC7E,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,MAAM,CAAC;IAC/B,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,uCAAuC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAClH,CAAC;IACD,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,IAAA,0BAAe,GAAE,CAAC;IACtD,yFAAyF;IACzF,+CAA+C;IAC/C,MAAM,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC;IAE/B,IAAI,OAAO,GAAG,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC5D,IAAI,CAAC,OAAO,EAAE,CAAC;QACX,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,6BAA6B,EAAE,CAAC;IACtE,CAAC;IAED,MAAM,eAAe,CAAC,SAAS,CAAC,CAAC;IACjC,IAAI,SAAS,GAAG,MAAM,IAAA,0BAAa,EAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;IACzG,2FAA2F;IAC3F,8FAA8F;IAC9F,oDAAoD;IACpD,IAAI,YAAY,GAAG,CAAC,IAAY,EAAE,EAAE,WAAC,OAAA,CAAC,CAAC,CAAA,MAAA,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,0CAAE,MAAM,CAAA,CAAA,EAAA,CAAC;IACzE,IAAI,WAAW,GAAG,MAAM,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC1D,8FAA8F;IAC9F,mFAAmF;IACnF,IAAI,UAAU,GAAG,EAAE,CAAC;IACpB,KAAK,IAAI,UAAU,IAAI,WAAW,EAAE,CAAC;QACjC,IAAI,UAAU,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACrC,SAAS;QACb,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,IAAA,oBAAO,EAAC,EAAE,WAAW,EAAE,UAAU,CAAC,SAAS,EAAE,EAAE,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;YACnF,UAAU,GAAG,UAAU,CAAC,EAAE,CAAC;QAC/B,CAAC;IACL,CAAC;IACD,IAAI,UAAU,EAAE,CAAC;QACb,OAAO;YACH,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,4CAA4C,UAAU,+BAA+B;SAChG,CAAC;IACN,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;QAC3B,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAC1C,CAAC;IAED,4FAA4F;IAC5F,wEAAwE;IACxE,IAAI,IAAI,GAAG,IAAA,oBAAO,EAAC,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;IACnD,IAAI,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAChD,IAAA,oBAAO,EAAC,EAAE,WAAW,EAAE,UAAU,CAAC,SAAS,EAAE,EAAE,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC;IAChF,IAAI,CAAC,eAAe,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,MAAM,uBAAuB,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,YAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACtF,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,oCAAoC,EAAE,kCAAkC,EAAE,CAAC;IACjH,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,oCAAoC,EAAE,EAAE,EAAE,CAAC;AACjF,CAAC;AAtDD,8CAsDC","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"; */
+//# 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 { lazy } from \"socket-function/src/caching\";\nimport { runInfinitePoll } from \"socket-function/src/batching\";\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// And the machine list is re-read from the checkout on this interval, in the background. The\n// checkout itself only moves when the daemon pulls it, which is on the same sort of interval, so\n// reading more often than this would only re-read the same bytes.\nconst MACHINES_REFRESH_INTERVAL = 60 * 1000;\n// How long a failure to find the keys repo is remembered. A long lived process may start before\n// the machine is set up, and should pick it up once it is, without being restarted - but it must\n// not pay for resolving the repo on every request either.\nconst REPO_RETRY_DELAY = 15 * 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/** This machine's keys repo, worked out once and then remembered.\n\n    A failure is remembered too, but only briefly: a server may well start before the machine has\n    been set up, and should start working when it is, rather than needing a restart. */\nexport const keysRepo = lazy(async () => {\n    let lookup = resolveKeysRepo();\n    lookup.catch(() => {\n        setTimeout(() => keysRepo.reset(), REPO_RETRY_DELAY).unref();\n    });\n    return await lookup;\n});\n\n/** Every machine a checkout lists. Without a repo, this machine's own. */\nexport async function getMachines(repoPath?: string): Promise<MachineState[]> {\n    return [...(await readMachines(repoPath || (await keysRepo()).repoPath)).values()];\n}\n\n/** Reads the machine list, once its signature has been checked. An unsigned machine list, or one\n    signed over different contents, is not evidence of anything, so this throws rather than\n    quietly trusting nobody. */\nasync function readTrustedMachines() {\n    let { repoPath } = await keysRepo();\n    await verifyCheckout(repoPath);\n    return await getMachines(repoPath);\n}\n\nconst trustedMachines = lazy(async () => {\n    let read = readTrustedMachines();\n    read.catch(() => trustedMachines.reset());\n    return await read;\n});\n\nlet refreshing = false;\n\n/** The machines this system trusts, as the signed repo lists them.\n\n    Held rather than read per call, and refreshed in the background, so nobody asking whether a\n    machine is trusted waits for a directory of files to be read and a signature to be checked. A\n    refresh that fails leaves the list we already have: the checkout is only stale, not wrong. */\nexport async function getTrustedMachines(): Promise<MachineState[]> {\n    if (!refreshing) {\n        refreshing = true;\n        runInfinitePoll(MACHINES_REFRESH_INTERVAL, async () => {\n            try {\n                trustedMachines.set(Promise.resolve(await readTrustedMachines()));\n            } catch (e) {\n                console.log(`Could not re-read the trusted machines, keeping the ones we have. ${e}`);\n            }\n        });\n    }\n    return await trustedMachines();\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 { machines } = config;\n    let repoPath = config.repoPath || (await keysRepo()).repoPath;\n    // Whatever was held is now stale, whoever reads it next.\n    trustedMachines.reset();\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/** What to run to trust a machine that has just been refused.\n\n    Everything in it is already known to whoever is being refused: their machine id, the address we\n    saw them at, and the domain they just talked to. Handing it back saves them working out the\n    parts of a command they have every right to know. Running it still takes the hardware key on\n    the machine that owns the repo, so telling them costs nothing. */\nexport function addMachineCommand(config: { machineId: string; ip: string; domain?: string }) {\n    let { machineId, ip, domain } = config;\n    return `To trust it, run: yarn addmachine ${domain || \"<domain>\"} ${machineId} ${ip} git`;\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: {\n    machineId: string;\n    ip: string;\n    // Only used to write a complete command into the refusal. A caller that knows which domain it\n    // is answering as saves whoever is refused from having to guess it.\n    domain?: string;\n}): Promise<MachineVerdict> {\n    let { machineId, ip, domain } = 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 { sourceURL } = await keysRepo();\n    // Verified before it is believed, and cached, since this is asked once per request.\n    let machine = (await getTrustedMachines()).find(entry => entry.machineId === machineId);\n    if (!machine) {\n        return { accepted: false, reason: `that machine is not trusted. ${addMachineCommand({ machineId, ip, domain })}` };\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 = "2d9e826cd3b14184bf081d819b9343dd010bb4fee837a56e1b15c1abee236d95"; */

package/security/machines/machines.d.ts

@@ -0,0 +1,81 @@
+export declare const MACHINES_DIR = "machines";
+/** One machine we are willing to talk to, and the addresses it may talk to us from. */
+export type MachineState = {
+    machineId: string;
+    ips: string[];
+    addedAt: string;
+};
+/** This machine's keys repo, worked out once and then remembered.
+
+    A failure is remembered too, but only briefly: a server may well start before the machine has
+    been set up, and should start working when it is, rather than needing a restart. */
+export declare const keysRepo: {
+    (): Promise<{
+        repoPath: string;
+        sourceURL: string;
+    }>;
+    reset(): void;
+    set(newValue: Promise<{
+        repoPath: string;
+        sourceURL: string;
+    }>): void;
+};
+/** Every machine a checkout lists. Without a repo, this machine's own. */
+export declare function getMachines(repoPath?: string): Promise<MachineState[]>;
+/** The machines this system trusts, as the signed repo lists them.
+
+    Held rather than read per call, and refreshed in the background, so nobody asking whether a
+    machine is trusted waits for a directory of files to be read and a signature to be checked. A
+    refresh that fails leaves the list we already have: the checkout is only stale, not wrong. */
+export declare function getTrustedMachines(): Promise<MachineState[]>;
+/** 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. */
+export declare function setMachines(config: {
+    repoPath?: string;
+    machines: {
+        machineId: string;
+        ips: string[];
+    }[];
+}): Promise<MachineState[]>;
+/** What to run to trust a machine that has just been refused.
+
+    Everything in it is already known to whoever is being refused: their machine id, the address we
+    saw them at, and the domain they just talked to. Handing it back saves them working out the
+    parts of a command they have every right to know. Running it still takes the hardware key on
+    the machine that owns the repo, so telling them costs nothing. */
+export declare function addMachineCommand(config: {
+    machineId: string;
+    ip: string;
+    domain?: string;
+}): string;
+/** Whether we will talk to this machine, coming from this address.
+
+    Both halves are required and neither is a guess: the caller knows the machine id because the
+    connection proved it, and knows the address because the packets came from there. A machine we
+    do not list is simply not accepted. A machine we do list, arriving from an address it does not
+    have, is treated as the same kind of event as a stolen ssh key - it is revoked everywhere, and
+    stays revoked until an unrevoke allows that machine from that address.
+
+    Says why when the answer is no, because the three ways to be refused are entirely different
+    things to a person reading it: never trusted at all, trusted but frozen, or trusted and talking
+    from somewhere it should not be.
+
+    Throws when the repo itself cannot be read or is not signed, rather than answering false: that
+    is a broken installation, not a rejected machine, and the two deserve different handling. */
+export type MachineVerdict = {
+    accepted: boolean;
+    reason: string;
+};
+export declare function isMachineAccepted(config: {
+    machineId: string;
+    ip: string;
+    domain?: string;
+}): Promise<MachineVerdict>;