sliftutils 1.7.127 → 1.7.129

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

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

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

@@ -0,0 +1,322 @@
+"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.resolveKeysRepo = exports.machineState = 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 paths_1 = require("../authorizedKeys/daemon/paths");
+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 sources_1 = require("../authorizedKeys/sources");
+const notify_1 = require("../authorizedKeys/daemon/notify");
+const discord_1 = require("../notifications/discord");
+const trustState_1 = require("./trustState");
+const spawn_1 = require("../helpers/spawn");
+// 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;
+// Where a Windows machine is expected to keep the repo, relative to the working directory. There
+// is no daemon there to ask, and no /etc to look in.
+const WINDOWS_REPO_PATH = "../authorized_keys";
+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`);
+}
+/** Reads every machine a checkout lists, or sets them.
+
+    Passing `machines` makes the repo match it exactly: machines named are written with the
+    addresses given, and machines not named are removed. That is why the addresses are part of
+    setting rather than a separate step - a machine with no address it may talk from is not a
+    machine we would accept anyway, so there is no state where naming one without them means
+    anything. Read first, change what you want, write the result.
+
+    Nothing here signs or commits anything. 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 machineState(config) {
+    var _a;
+    let { repoPath, machines } = config;
+    let existing = await readMachines(repoPath);
+    if (!machines) {
+        return [...existing.values()];
+    }
+    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.machineState = machineState;
+/** 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;
+}
+async function isKeysRepo(repoPath) {
+    return await pathExists(path_1.default.join(repoPath, ".git"))
+        && await pathExists(path_1.default.join(repoPath, "authorized_keys"));
+}
+async function originOf(repoPath) {
+    let origin = await (0, spawn_1.spawnPromise)({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
+    let url = origin.stdout.trim();
+    if (origin.status !== 0 || !url) {
+        throw new Error(`Expected ${repoPath} to have an origin remote, it has none`);
+    }
+    return url;
+}
+/** The keys repo this machine answers from, and the one anything editing the machine list edits.
+
+    On a host, that is the checkout the daemon already keeps up to date. On Windows there is no
+    daemon and no /etc, so the repo is expected beside the working directory, which is where a
+    developer working on both would have it.
+
+    Never the directory the command happens to be run from. Which repo this machine trusts is a
+    property of the machine, not of where somebody was standing when they typed something. */
+async function resolveKeysRepo() {
+    if (os_1.default.platform() === "win32") {
+        let repoPath = path_1.default.resolve(WINDOWS_REPO_PATH);
+        if (!await isKeysRepo(repoPath)) {
+            throw new Error(`Expected ${repoPath} to be an authorized_keys repo, it is not.\n`
+                + `On Windows the repo is read from there, so clone it beside this one:\n`
+                + `  git clone <your authorized_keys repo> ${repoPath}`);
+        }
+        return { repoPath, sourceURL: await originOf(repoPath) };
+    }
+    let config = await promises_1.default.readFile(paths_1.CONFIG_PATH, "utf8").catch(() => "");
+    let sourceURL = config && (JSON.parse(config).repoSources || [])[0] || "";
+    if (!sourceURL) {
+        throw new Error(`Expected this machine to be set up with an authorized_keys repo, ${paths_1.CONFIG_PATH} names none.\n`
+            + `Set it up first:\n`
+            + `  yarn setupnotify <discord-webhook-url>\n`
+            + `  yarn securessh add <repo-private-key> <repo-url>`);
+    }
+    let repoPath = (0, sources_1.sourceRepoPath)(sourceURL);
+    if (!await isKeysRepo(repoPath)) {
+        throw new Error(`Expected a checkout of ${sourceURL} at ${repoPath}, there is none.\n`
+            + `Run \`yarn securessh update\` to put it back.`);
+    }
+    return { repoPath, sourceURL };
+}
+exports.resolveKeysRepo = resolveKeysRepo;
+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 an hour to reach every machine.`
+        + `\n\nmachine: \`${machineId}\``
+        + `\nfrozen by: \`${hostLabel}\``);
+}
+/** 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.
+
+    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. */
+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 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 false;
+    }
+    await syncRevocations(sourceURL);
+    let unrevokes = await (0, revocation_1.readUnrevokes)(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
+    // An unrevoke is only honoured once it has waited out its hour, exactly as an ssh key's is.
+    let allowedAgain = async (pair) => {
+        let unrevokeId = unrevokes.pairs.get(pair);
+        return !!unrevokeId && await (0, trustState_1.unrevokeInEffect)(unrevokeId);
+    };
+    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 revoked = false;
+    for (let revocation of revocations) {
+        if (revocation.machineId !== machineId) {
+            continue;
+        }
+        if (!await allowedAgain((0, revocation_1.pairKey)({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
+            revoked = true;
+        }
+    }
+    if (revoked) {
+        return false;
+    }
+    if (machine.ips.includes(ip)) {
+        return true;
+    }
+    // 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 && !await allowedAgain(pair)) {
+        await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os_1.default.hostname() });
+    }
+    return false;
+}
+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 { CONFIG_PATH } from \"../authorizedKeys/daemon/paths\";\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 { sourceRepoPath } from \"../authorizedKeys/sources\";\nimport { notify } from \"../authorizedKeys/daemon/notify\";\nimport { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from \"../notifications/discord\";\nimport { unrevokeInEffect } from \"./trustState\";\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// Where a Windows machine is expected to keep the repo, relative to the working directory. There\n// is no daemon there to ask, and no /etc to look in.\nconst WINDOWS_REPO_PATH = \"../authorized_keys\";\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/** Reads every machine a checkout lists, or sets them.\n\n    Passing `machines` makes the repo match it exactly: machines named are written with the\n    addresses given, and machines not named are removed. That is why the addresses are part of\n    setting rather than a separate step - a machine with no address it may talk from is not a\n    machine we would accept anyway, so there is no state where naming one without them means\n    anything. Read first, change what you want, write the result.\n\n    Nothing here signs or commits anything. 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 machineState(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    if (!machines) {\n        return [...existing.values()];\n    }\n\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\nasync function isKeysRepo(repoPath: string) {\n    return await pathExists(path.join(repoPath, \".git\"))\n        && await pathExists(path.join(repoPath, \"authorized_keys\"));\n}\n\nasync function originOf(repoPath: string) {\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let url = origin.stdout.trim();\n    if (origin.status !== 0 || !url) {\n        throw new Error(`Expected ${repoPath} to have an origin remote, it has none`);\n    }\n    return url;\n}\n\n/** The keys repo this machine answers from, and the one anything editing the machine list edits.\n\n    On a host, that is the checkout the daemon already keeps up to date. On Windows there is no\n    daemon and no /etc, so the repo is expected beside the working directory, which is where a\n    developer working on both would have it.\n\n    Never the directory the command happens to be run from. Which repo this machine trusts is a\n    property of the machine, not of where somebody was standing when they typed something. */\nexport async function resolveKeysRepo() {\n    if (os.platform() === \"win32\") {\n        let repoPath = path.resolve(WINDOWS_REPO_PATH);\n        if (!await isKeysRepo(repoPath)) {\n            throw new Error(\n                `Expected ${repoPath} to be an authorized_keys repo, it is not.\\n`\n                + `On Windows the repo is read from there, so clone it beside this one:\\n`\n                + `  git clone <your authorized_keys repo> ${repoPath}`\n            );\n        }\n        return { repoPath, sourceURL: await originOf(repoPath) };\n    }\n\n    let config = await fs.readFile(CONFIG_PATH, \"utf8\").catch(() => \"\");\n    let sourceURL = config && (JSON.parse(config).repoSources || [])[0] || \"\";\n    if (!sourceURL) {\n        throw new Error(\n            `Expected this machine to be set up with an authorized_keys repo, ${CONFIG_PATH} names none.\\n`\n            + `Set it up first:\\n`\n            + `  yarn setupnotify <discord-webhook-url>\\n`\n            + `  yarn securessh add <repo-private-key> <repo-url>`\n        );\n    }\n    let repoPath = sourceRepoPath(sourceURL);\n    if (!await isKeysRepo(repoPath)) {\n        throw new Error(\n            `Expected a checkout of ${sourceURL} at ${repoPath}, there is none.\\n`\n            + `Run \\`yarn securessh update\\` to put it back.`\n        );\n    }\n    return { repoPath, sourceURL };\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 an hour to reach every machine.`\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    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 async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<boolean> {\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 false;\n    }\n\n    await syncRevocations(sourceURL);\n    let unrevokes = await readUnrevokes(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));\n    // An unrevoke is only honoured once it has waited out its hour, exactly as an ssh key's is.\n    let allowedAgain = async (pair: string) => {\n        let unrevokeId = unrevokes.pairs.get(pair);\n        return !!unrevokeId && await unrevokeInEffect(unrevokeId);\n    };\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 revoked = false;\n    for (let revocation of revocations) {\n        if (revocation.machineId !== machineId) {\n            continue;\n        }\n        if (!await allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {\n            revoked = true;\n        }\n    }\n    if (revoked) {\n        return false;\n    }\n\n    if (machine.ips.includes(ip)) {\n        return true;\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 && !await allowedAgain(pair)) {\n        await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os.hostname() });\n    }\n    return false;\n}\n"]}
+ /* _JS_SOURCE_HASH = "42ec23e7ee1a7879769634b3b36b652f35e6140757988d443d15d7a3a5d4adec"; */