sliftutils 1.7.128 → 1.7.129

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"; */

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

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

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

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