sliftutils 1.7.129 → 1.7.130

package/security/machines/machines.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import { CONFIG_PATH } from "../authorizedKeys/daemon/paths";
+import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { revokeRepo, syncRepoFiles } from "../authorizedKeys/daemon/repoFiles";
 import { listRepoDir, readRepoFile } from "../authorizedKeys/daemon/repoFiles";
 import { newRevocationId, pairKey, readRevocationFiles, readUnrevokes } from "../authorizedKeys/daemon/revocation";
@@ -9,10 +9,8 @@ import { runGit } from "../authorizedKeys/daemon/git";
 import { ensureRevokeKey } from "../authorizedKeys/daemon/repoFiles";
 import { verifyCheckout } from "../authorizedKeys/daemon/trust";
 import { revokeRepoPath, revokeRepoURL } from "../authorizedKeys/revokeSource";
-import { sourceRepoPath } from "../authorizedKeys/sources";
 import { notify } from "../authorizedKeys/daemon/notify";
 import { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from "../notifications/discord";
-import { unrevokeInEffect } from "./trustState";
 import { spawnPromise } from "../helpers/spawn";
 
 // Which machines this system talks to, kept in the same repo as the ssh keys. That repo is already
@@ -24,9 +22,6 @@ 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";
 
 /** One machine we are willing to talk to, and the addresses it may talk to us from. */
 export type MachineState = {
@@ -48,27 +43,27 @@ function machineFilePath(repoPath: string, machineId: string) {
     return path.join(repoPath, MACHINES_DIR, `${machineId}.json`);
 }
 
-/** Reads every machine a checkout lists, or sets them.
+/** Every machine a checkout lists. */
+export async function getMachines(repoPath: string): Promise<MachineState[]> {
+    return [...(await readMachines(repoPath)).values()];
+}
+
+/** 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.
 
-    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.
+    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 anything. The signature is what every other machine checks before
+    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 async function machineState(config: {
+export async function setMachines(config: {
     repoPath: string;
-    machines?: { machineId: string; ips: string[] }[];
+    machines: { machineId: string; ips: string[] }[];
 }): Promise<MachineState[]> {
     let { repoPath, machines } = config;
     let existing = await readMachines(repoPath);
-    if (!machines) {
-        return [...existing.values()];
-    }
-
     let directory = path.join(repoPath, MACHINES_DIR);
     let written: MachineState[] = [];
     for (let machine of machines) {
@@ -122,61 +117,6 @@ async function readMachines(repoPath: string) {
     return machines;
 }
 
-async function isKeysRepo(repoPath: string) {
-    return await pathExists(path.join(repoPath, ".git"))
-        && await pathExists(path.join(repoPath, "authorized_keys"));
-}
-
-async function originOf(repoPath: string) {
-    let origin = await 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. */
-export async function resolveKeysRepo() {
-    if (os.platform() === "win32") {
-        let repoPath = path.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 fs.readFile(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, ${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 = 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 };
-}
-
 let lastRevokeSync = 0;
 
 /** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that
@@ -285,7 +225,7 @@ async function recordMachineRevocation(config: {
         + `\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.`
+        + ` machine, and takes effect as each machine picks it up.`
         + `\n\nmachine: \`${machineId}\``
         + `\nfrozen by: \`${hostLabel}\``
     );
@@ -299,9 +239,15 @@ async function recordMachineRevocation(config: {
     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 async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<boolean> {
+export type MachineVerdict = { accepted: boolean; reason: string };
+
+export async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<MachineVerdict> {
     let { machineId, ip } = config;
     if (!machineId || !ip) {
         throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);
@@ -313,34 +259,36 @@ export async function isMachineAccepted(config: { machineId: string; ip: string
 
     let machine = (await readMachines(repoPath)).get(machineId);
     if (!machine) {
-        return false;
+        return { accepted: false, reason: "that machine is not trusted" };
     }
 
     await syncRevocations(sourceURL);
     let unrevokes = await 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: string) => {
-        let unrevokeId = unrevokes.pairs.get(pair);
-        return !!unrevokeId && await unrevokeInEffect(unrevokeId);
-    };
+    // An unrevoke counts as soon as it is seen. It is signed, so writing one already takes the
+    // hardware key, and anyone holding that can sign anything at all - a wait before honouring it
+    // guards against an attacker who has no need of it.
+    let allowedAgain = (pair: string) => !!unrevokes.pairs.get(pair)?.length;
     let revocations = await readMachineRevocations(sourceURL);
     // Any revocation nothing has undone keeps the machine out, from everywhere, the way a revoked
     // ssh key is out everywhere rather than only from the address it was misused from.
-    let revoked = false;
+    let frozenFrom = "";
     for (let revocation of revocations) {
         if (revocation.machineId !== machineId) {
             continue;
         }
-        if (!await allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
-            revoked = true;
+        if (!allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
+            frozenFrom = revocation.ip;
         }
     }
-    if (revoked) {
-        return false;
+    if (frozenFrom) {
+        return {
+            accepted: false,
+            reason: `that machine is frozen, it was used from ${frozenFrom} which it is not allowed from`,
+        };
     }
 
     if (machine.ips.includes(ip)) {
-        return true;
+        return { accepted: true, reason: "" };
     }
 
     // Listed, but talking to us from somewhere it should not be. Recorded once for this machine
@@ -348,8 +296,9 @@ export async function isMachineAccepted(config: { machineId: string; ip: string
     let pair = pairKey({ fingerprint: machineId, ip });
     let alreadyRecorded = revocations.some(revocation =>
         pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }) === pair);
-    if (!alreadyRecorded && !await allowedAgain(pair)) {
+    if (!alreadyRecorded && !allowedAgain(pair)) {
         await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os.hostname() });
+        return { accepted: false, reason: `that machine is not allowed from ${ip}, so it is now frozen everywhere` };
     }
-    return false;
+    return { accepted: false, reason: `that machine is not allowed from ${ip}` };
 }

package/security/machines/trustServer.ts

@@ -47,14 +47,16 @@ export function startTrustServer(config: { port: number }) {
                 // Not a rejection of the machine, a packet that does not prove anything about one.
                 return { status: 400, body: { trusted: false, ip, reason: verified.problem } };
             }
-            let trusted = await isMachineAccepted({ machineId: packet.machineId, ip });
+            let verdict = await isMachineAccepted({ machineId: packet.machineId, ip });
             return {
                 status: 200,
                 body: {
-                    trusted,
+                    trusted: verdict.accepted,
                     machineId: packet.machineId,
                     ip,
-                    reason: trusted && "" || "that machine is not trusted from that address",
+                    // Whatever the check itself said. It is the only thing that knows which of the
+                    // ways to be refused this was.
+                    reason: verdict.reason,
                 },
             };
         };

package/security/notifications/dist/remoteWebhook.ts.cache

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ensureRemoteWebhook = exports.REPLACE_KEYWORD = void 0;
+const discord_1 = require("./discord");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+exports.REPLACE_KEYWORD = "replace";
+const UNPARSEABLE_LABEL = "(unparseable)";
+/** Puts a webhook on a remote host, refusing to clobber a different existing one unless asked.
+    Returns what happened, so callers can decide whether to keep going. */
+async function ensureRemoteWebhook(config) {
+    let { host, webhookURL, replace } = config;
+    let filePath = config.filePath || discord_1.DEFAULT_WEBHOOK_FILE_PATH;
+    let replacedURL = "";
+    let existingContents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath });
+    if (existingContents) {
+        // A corrupt existing file still counts as a conflict, so "replace" can repair it instead
+        // of the setup dead ending on a parse error.
+        let existingURL = UNPARSEABLE_LABEL;
+        try {
+            existingURL = (0, discord_1.parseWebhookFile)({ contents: existingContents, sourceName: `${host}:${filePath}` });
+        }
+        catch (e) {
+            console.error(`${host}:${filePath} exists but could not be parsed. ${e}`);
+        }
+        if (existingURL === webhookURL) {
+            return { outcome: "unchanged", filePath };
+        }
+        if (!replace) {
+            throw new Error(`Expected no conflicting webhook on ${host}, but ${filePath} already holds a different one.\n`
+                + `Existing: ${existingURL}\n`
+                + `New:      ${webhookURL}\n`
+                + `Pass "${exports.REPLACE_KEYWORD}" to overwrite it.`);
+        }
+        replacedURL = existingURL;
+    }
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath,
+        contents: (0, discord_1.formatWebhookFile)(webhookURL),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    let writtenContents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath });
+    if (!writtenContents) {
+        throw new Error(`Expected ${filePath} to exist on ${host} after writing, no such file exists`);
+    }
+    let writtenURL = (0, discord_1.parseWebhookFile)({ contents: writtenContents, sourceName: `${host}:${filePath}` });
+    if (writtenURL !== webhookURL) {
+        throw new Error(`Expected ${host}:${filePath} to hold the new webhook, was ${writtenURL}`);
+    }
+    if (replacedURL && replacedURL !== UNPARSEABLE_LABEL) {
+        // The new webhook is redacted, so this channel can identify the replacement without
+        // receiving a webhook it could post to.
+        try {
+            await (0, discord_1.sendToWebhookURL)({
+                webhookURL: replacedURL,
+                message: `**portsecure**: the Discord webhook for \`${host}\` was replaced with`
+                    + ` \`${(0, discord_1.redactWebhookURL)(webhookURL)}\`.`
+                    + ` This channel will stop receiving notifications for that host.`,
+            });
+        }
+        catch (e) {
+            // The replacement already happened, so a dead old webhook must not fail the setup.
+            console.error(`Could not notify the old webhook that it was replaced. ${e}`);
+        }
+    }
+    // Failing here means the file is in place but the webhook itself does not work, which is
+    // exactly what the operator needs to hear about.
+    await (0, discord_1.sendToWebhookURL)({
+        webhookURL,
+        message: `**portsecure**: notifications are now configured for \`${host}\`.`
+            + ` This channel will receive its security notifications.`,
+    });
+    return { outcome: replacedURL && "replaced" || "created", filePath };
+}
+exports.ensureRemoteWebhook = ensureRemoteWebhook;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteWebhook.js","sourceRoot":"","sources":["remoteWebhook.ts"],"names":[],"mappings":";;;AAAA,uCAA+H;AAC/H,oDAAuE;AAE1D,QAAA,eAAe,GAAG,SAAS,CAAC;AACzC,MAAM,iBAAiB,GAAG,eAAe,CAAC;AAE1C;0EAC0E;AACnE,KAAK,UAAU,mBAAmB,CAAC,MAKzC;IACG,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAC3C,IAAI,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,mCAAyB,CAAC;IAE5D,IAAI,WAAW,GAAG,EAAE,CAAC;IACrB,IAAI,gBAAgB,GAAG,MAAM,IAAA,0BAAc,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAChE,IAAI,gBAAgB,EAAE,CAAC;QACnB,yFAAyF;QACzF,6CAA6C;QAC7C,IAAI,WAAW,GAAG,iBAAiB,CAAC;QACpC,IAAI,CAAC;YACD,WAAW,GAAG,IAAA,0BAAgB,EAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,IAAI,IAAI,QAAQ,EAAE,EAAE,CAAC,CAAC;QACtG,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,QAAQ,oCAAoC,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,WAAW,KAAK,UAAU,EAAE,CAAC;YAC7B,OAAO,EAAE,OAAO,EAAE,WAAoB,EAAE,QAAQ,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CACX,sCAAsC,IAAI,SAAS,QAAQ,mCAAmC;kBAC5F,aAAa,WAAW,IAAI;kBAC5B,aAAa,UAAU,IAAI;kBAC3B,SAAS,uBAAe,oBAAoB,CACjD,CAAC;QACN,CAAC;QACD,WAAW,GAAG,WAAW,CAAC;IAC9B,CAAC;IAED,MAAM,IAAA,2BAAe,EAAC;QAClB,IAAI;QACJ,QAAQ;QACR,QAAQ,EAAE,IAAA,2BAAiB,EAAC,UAAU,CAAC;QACvC,QAAQ,EAAE,KAAK;QACf,aAAa,EAAE,KAAK;KACvB,CAAC,CAAC;IAEH,IAAI,eAAe,GAAG,MAAM,IAAA,0BAAc,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC/D,IAAI,CAAC,eAAe,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,gBAAgB,IAAI,qCAAqC,CAAC,CAAC;IACnG,CAAC;IACD,IAAI,UAAU,GAAG,IAAA,0BAAgB,EAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,IAAI,IAAI,QAAQ,EAAE,EAAE,CAAC,CAAC;IACpG,IAAI,UAAU,KAAK,UAAU,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,IAAI,QAAQ,iCAAiC,UAAU,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,IAAI,WAAW,IAAI,WAAW,KAAK,iBAAiB,EAAE,CAAC;QACnD,oFAAoF;QACpF,wCAAwC;QACxC,IAAI,CAAC;YACD,MAAM,IAAA,0BAAgB,EAAC;gBACnB,UAAU,EAAE,WAAW;gBACvB,OAAO,EAAE,6CAA6C,IAAI,sBAAsB;sBAC1E,MAAM,IAAA,0BAAgB,EAAC,UAAU,CAAC,KAAK;sBACvC,gEAAgE;aACzE,CAAC,CAAC;QACP,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,mFAAmF;YACnF,OAAO,CAAC,KAAK,CAAC,0DAA0D,CAAC,EAAE,CAAC,CAAC;QACjF,CAAC;IACL,CAAC;IAED,yFAAyF;IACzF,iDAAiD;IACjD,MAAM,IAAA,0BAAgB,EAAC;QACnB,UAAU;QACV,OAAO,EAAE,0DAA0D,IAAI,KAAK;cACtE,wDAAwD;KACjE,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,EAAE,WAAW,IAAI,UAAmB,IAAI,SAAkB,EAAE,QAAQ,EAAE,CAAC;AAC3F,CAAC;AA5ED,kDA4EC","sourcesContent":["import { DEFAULT_WEBHOOK_FILE_PATH, formatWebhookFile, parseWebhookFile, redactWebhookURL, sendToWebhookURL } from \"./discord\";\nimport { readRemoteFile, writeRemoteFile } from \"../helpers/remoteSSH\";\n\nexport const REPLACE_KEYWORD = \"replace\";\nconst UNPARSEABLE_LABEL = \"(unparseable)\";\n\n/** Puts a webhook on a remote host, refusing to clobber a different existing one unless asked.\n    Returns what happened, so callers can decide whether to keep going. */\nexport async function ensureRemoteWebhook(config: {\n    host: string;\n    webhookURL: string;\n    replace: boolean;\n    filePath?: string;\n}) {\n    let { host, webhookURL, replace } = config;\n    let filePath = config.filePath || DEFAULT_WEBHOOK_FILE_PATH;\n\n    let replacedURL = \"\";\n    let existingContents = await readRemoteFile({ host, filePath });\n    if (existingContents) {\n        // A corrupt existing file still counts as a conflict, so \"replace\" can repair it instead\n        // of the setup dead ending on a parse error.\n        let existingURL = UNPARSEABLE_LABEL;\n        try {\n            existingURL = parseWebhookFile({ contents: existingContents, sourceName: `${host}:${filePath}` });\n        } catch (e) {\n            console.error(`${host}:${filePath} exists but could not be parsed. ${e}`);\n        }\n        if (existingURL === webhookURL) {\n            return { outcome: \"unchanged\" as const, filePath };\n        }\n        if (!replace) {\n            throw new Error(\n                `Expected no conflicting webhook on ${host}, but ${filePath} already holds a different one.\\n`\n                + `Existing: ${existingURL}\\n`\n                + `New:      ${webhookURL}\\n`\n                + `Pass \"${REPLACE_KEYWORD}\" to overwrite it.`\n            );\n        }\n        replacedURL = existingURL;\n    }\n\n    await writeRemoteFile({\n        host,\n        filePath,\n        contents: formatWebhookFile(webhookURL),\n        fileMode: \"600\",\n        directoryMode: \"700\",\n    });\n\n    let writtenContents = await readRemoteFile({ host, filePath });\n    if (!writtenContents) {\n        throw new Error(`Expected ${filePath} to exist on ${host} after writing, no such file exists`);\n    }\n    let writtenURL = parseWebhookFile({ contents: writtenContents, sourceName: `${host}:${filePath}` });\n    if (writtenURL !== webhookURL) {\n        throw new Error(`Expected ${host}:${filePath} to hold the new webhook, was ${writtenURL}`);\n    }\n\n    if (replacedURL && replacedURL !== UNPARSEABLE_LABEL) {\n        // The new webhook is redacted, so this channel can identify the replacement without\n        // receiving a webhook it could post to.\n        try {\n            await sendToWebhookURL({\n                webhookURL: replacedURL,\n                message: `**portsecure**: the Discord webhook for \\`${host}\\` was replaced with`\n                    + ` \\`${redactWebhookURL(webhookURL)}\\`.`\n                    + ` This channel will stop receiving notifications for that host.`,\n            });\n        } catch (e) {\n            // The replacement already happened, so a dead old webhook must not fail the setup.\n            console.error(`Could not notify the old webhook that it was replaced. ${e}`);\n        }\n    }\n\n    // Failing here means the file is in place but the webhook itself does not work, which is\n    // exactly what the operator needs to hear about.\n    await sendToWebhookURL({\n        webhookURL,\n        message: `**portsecure**: notifications are now configured for \\`${host}\\`.`\n            + ` This channel will receive its security notifications.`,\n    });\n\n    return { outcome: replacedURL && \"replaced\" as const || \"created\" as const, filePath };\n}\n"]}
+ /* _JS_SOURCE_HASH = "7383d5b5b9fee5c3deb4ea3e75d9c556e64aef84ab8d71e7683a02bc87c5070a"; */

package/security/notifications/dist/setupNotify.ts.cache

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.main = void 0;
+const discord_1 = require("./discord");
+const remoteWebhook_1 = require("./remoteWebhook");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+const USAGE = `Usage: yarn setupnotify [host] <discord-webhook-url> [${remoteWebhook_1.REPLACE_KEYWORD}]
+
+With no host it sets the webhook up on this machine.`;
+function parseArgs(argv) {
+    let replace = argv.includes(remoteWebhook_1.REPLACE_KEYWORD);
+    let positional = argv.filter(arg => arg !== remoteWebhook_1.REPLACE_KEYWORD);
+    if (!positional.length || positional.length > 2) {
+        throw new Error(`Expected a webhook URL, and optionally a host before it, was ${positional.length}`
+            + ` argument(s): ${positional.join(" ") || "(none)"}\n${USAGE}`);
+    }
+    // The webhook url is the last one, so whatever comes before it is the host. Without one this
+    // machine is the target.
+    let webhookURL = positional[positional.length - 1];
+    let host = positional.length > 1 && positional[0] || remoteSSH_1.THIS_MACHINE;
+    // Validates the URL shape up front, so we never go anywhere with a bad webhook.
+    (0, discord_1.parseWebhookFile)({ contents: webhookURL, sourceName: "the command line" });
+    return { host, webhookURL, replace };
+}
+async function main() {
+    let { host, webhookURL, replace } = parseArgs(process.argv.slice(2));
+    let { outcome, filePath } = await (0, remoteWebhook_1.ensureRemoteWebhook)({ host, webhookURL, replace });
+    if (outcome === "unchanged") {
+        console.log(`${(0, remoteSSH_1.describeHost)(host)} already has this exact webhook in ${filePath}, nothing to do.`);
+        return;
+    }
+    if (outcome === "replaced") {
+        console.log(`Replaced the webhook on ${(0, remoteSSH_1.describeHost)(host)} and notified the old one.`);
+    }
+    console.log(`Wrote ${filePath} on ${(0, remoteSSH_1.describeHost)(host)} (mode 600), and confirmed on the new webhook.`);
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXBOb3RpZnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzZXR1cE5vdGlmeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBNkM7QUFDN0MsbURBQXVFO0FBQ3ZFLG9EQUFrRTtBQUVsRSxNQUFNLEtBQUssR0FBRyx5REFBeUQsK0JBQWU7O3FEQUVqQyxDQUFDO0FBRXRELFNBQVMsU0FBUyxDQUFDLElBQWM7SUFDN0IsSUFBSSxPQUFPLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQywrQkFBZSxDQUFDLENBQUM7SUFDN0MsSUFBSSxVQUFVLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsS0FBSywrQkFBZSxDQUFDLENBQUM7SUFDN0QsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLElBQUksVUFBVSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUM5QyxNQUFNLElBQUksS0FBSyxDQUNYLGdFQUFnRSxVQUFVLENBQUMsTUFBTSxFQUFFO2NBQ2pGLGlCQUFpQixVQUFVLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLFFBQVEsS0FBSyxLQUFLLEVBQUUsQ0FDbEUsQ0FBQztJQUNOLENBQUM7SUFDRCw2RkFBNkY7SUFDN0YseUJBQXlCO0lBQ3pCLElBQUksVUFBVSxHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ25ELElBQUksSUFBSSxHQUFHLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxJQUFJLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSx3QkFBWSxDQUFDO0lBQ2xFLGdGQUFnRjtJQUNoRixJQUFBLDBCQUFnQixFQUFDLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQyxDQUFDO0lBQzNFLE9BQU8sRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBQ3pDLENBQUM7QUFFTSxLQUFLLFVBQVUsSUFBSTtJQUN0QixJQUFJLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyRSxJQUFJLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxHQUFHLE1BQU0sSUFBQSxtQ0FBbUIsRUFBQyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUNyRixJQUFJLE9BQU8sS0FBSyxXQUFXLEVBQUUsQ0FBQztRQUMxQixPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBQSx3QkFBWSxFQUFDLElBQUksQ0FBQyxzQ0FBc0MsUUFBUSxrQkFBa0IsQ0FBQyxDQUFDO1FBQ25HLE9BQU87SUFDWCxDQUFDO0lBQ0QsSUFBSSxPQUFPLEtBQUssVUFBVSxFQUFFLENBQUM7UUFDekIsT0FBTyxDQUFDLEdBQUcsQ0FBQywyQkFBMkIsSUFBQSx3QkFBWSxFQUFDLElBQUksQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0lBQzNGLENBQUM7SUFDRCxPQUFPLENBQUMsR0FBRyxDQUFDLFNBQVMsUUFBUSxPQUFPLElBQUEsd0JBQVksRUFBQyxJQUFJLENBQUMsZ0RBQWdELENBQUMsQ0FBQztBQUM1RyxDQUFDO0FBWEQsb0JBV0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBwYXJzZVdlYmhvb2tGaWxlIH0gZnJvbSBcIi4vZGlzY29yZFwiO1xuaW1wb3J0IHsgZW5zdXJlUmVtb3RlV2ViaG9vaywgUkVQTEFDRV9LRVlXT1JEIH0gZnJvbSBcIi4vcmVtb3RlV2ViaG9va1wiO1xuaW1wb3J0IHsgZGVzY3JpYmVIb3N0LCBUSElTX01BQ0hJTkUgfSBmcm9tIFwiLi4vaGVscGVycy9yZW1vdGVTU0hcIjtcblxuY29uc3QgVVNBR0UgPSBgVXNhZ2U6IHlhcm4gc2V0dXBub3RpZnkgW2hvc3RdIDxkaXNjb3JkLXdlYmhvb2stdXJsPiBbJHtSRVBMQUNFX0tFWVdPUkR9XVxuXG5XaXRoIG5vIGhvc3QgaXQgc2V0cyB0aGUgd2ViaG9vayB1cCBvbiB0aGlzIG1hY2hpbmUuYDtcblxuZnVuY3Rpb24gcGFyc2VBcmdzKGFyZ3Y6IHN0cmluZ1tdKSB7XG4gICAgbGV0IHJlcGxhY2UgPSBhcmd2LmluY2x1ZGVzKFJFUExBQ0VfS0VZV09SRCk7XG4gICAgbGV0IHBvc2l0aW9uYWwgPSBhcmd2LmZpbHRlcihhcmcgPT4gYXJnICE9PSBSRVBMQUNFX0tFWVdPUkQpO1xuICAgIGlmICghcG9zaXRpb25hbC5sZW5ndGggfHwgcG9zaXRpb25hbC5sZW5ndGggPiAyKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgICAgIGBFeHBlY3RlZCBhIHdlYmhvb2sgVVJMLCBhbmQgb3B0aW9uYWxseSBhIGhvc3QgYmVmb3JlIGl0LCB3YXMgJHtwb3NpdGlvbmFsLmxlbmd0aH1gXG4gICAgICAgICAgICArIGAgYXJndW1lbnQocyk6ICR7cG9zaXRpb25hbC5qb2luKFwiIFwiKSB8fCBcIihub25lKVwifVxcbiR7VVNBR0V9YFxuICAgICAgICApO1xuICAgIH1cbiAgICAvLyBUaGUgd2ViaG9vayB1cmwgaXMgdGhlIGxhc3Qgb25lLCBzbyB3aGF0ZXZlciBjb21lcyBiZWZvcmUgaXQgaXMgdGhlIGhvc3QuIFdpdGhvdXQgb25lIHRoaXNcbiAgICAvLyBtYWNoaW5lIGlzIHRoZSB0YXJnZXQuXG4gICAgbGV0IHdlYmhvb2tVUkwgPSBwb3NpdGlvbmFsW3Bvc2l0aW9uYWwubGVuZ3RoIC0gMV07XG4gICAgbGV0IGhvc3QgPSBwb3NpdGlvbmFsLmxlbmd0aCA+IDEgJiYgcG9zaXRpb25hbFswXSB8fCBUSElTX01BQ0hJTkU7XG4gICAgLy8gVmFsaWRhdGVzIHRoZSBVUkwgc2hhcGUgdXAgZnJvbnQsIHNvIHdlIG5ldmVyIGdvIGFueXdoZXJlIHdpdGggYSBiYWQgd2ViaG9vay5cbiAgICBwYXJzZVdlYmhvb2tGaWxlKHsgY29udGVudHM6IHdlYmhvb2tVUkwsIHNvdXJjZU5hbWU6IFwidGhlIGNvbW1hbmQgbGluZVwiIH0pO1xuICAgIHJldHVybiB7IGhvc3QsIHdlYmhvb2tVUkwsIHJlcGxhY2UgfTtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIG1haW4oKSB7XG4gICAgbGV0IHsgaG9zdCwgd2ViaG9va1VSTCwgcmVwbGFjZSB9ID0gcGFyc2VBcmdzKHByb2Nlc3MuYXJndi5zbGljZSgyKSk7XG4gICAgbGV0IHsgb3V0Y29tZSwgZmlsZVBhdGggfSA9IGF3YWl0IGVuc3VyZVJlbW90ZVdlYmhvb2soeyBob3N0LCB3ZWJob29rVVJMLCByZXBsYWNlIH0pO1xuICAgIGlmIChvdXRjb21lID09PSBcInVuY2hhbmdlZFwiKSB7XG4gICAgICAgIGNvbnNvbGUubG9nKGAke2Rlc2NyaWJlSG9zdChob3N0KX0gYWxyZWFkeSBoYXMgdGhpcyBleGFjdCB3ZWJob29rIGluICR7ZmlsZVBhdGh9LCBub3RoaW5nIHRvIGRvLmApO1xuICAgICAgICByZXR1cm47XG4gICAgfVxuICAgIGlmIChvdXRjb21lID09PSBcInJlcGxhY2VkXCIpIHtcbiAgICAgICAgY29uc29sZS5sb2coYFJlcGxhY2VkIHRoZSB3ZWJob29rIG9uICR7ZGVzY3JpYmVIb3N0KGhvc3QpfSBhbmQgbm90aWZpZWQgdGhlIG9sZCBvbmUuYCk7XG4gICAgfVxuICAgIGNvbnNvbGUubG9nKGBXcm90ZSAke2ZpbGVQYXRofSBvbiAke2Rlc2NyaWJlSG9zdChob3N0KX0gKG1vZGUgNjAwKSwgYW5kIGNvbmZpcm1lZCBvbiB0aGUgbmV3IHdlYmhvb2suYCk7XG59XG4iXX0=
+ /* _JS_SOURCE_HASH = "75262294c247703aec2fc4b9dcf81c245e79b0b1566401ca4654e019705f6a40"; */

package/security/signedFiles/dist/signFiles.ts.cache

@@ -12,6 +12,7 @@ const paths_1 = require("../helpers/paths");
 const spawn_1 = require("../helpers/spawn");
 const manifest_1 = require("./manifest");
 const unrevoke_1 = require("../authorizedKeys/unrevoke");
+const keysRepo_1 = require("../authorizedKeys/keysRepo");
 const authorizedKeys_1 = require("../authorizedKeys/authorizedKeys");
 // A hardware backed key is the entire point. A key sitting on disk is compromised the moment the
 // machine is, and then the signature proves nothing, so this is what we make when asked to make one.
@@ -150,14 +151,11 @@ async function signRepo(config) {
 exports.signRepo = signRepo;
 async function main() {
     let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
-    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a
-    // git warning glued to the front of this becomes a directory that does not exist.
-    let topLevel = await (0, spawn_1.spawnPromise)({ command: "git", args: ["rev-parse", "--show-toplevel"] });
-    let repoPath = topLevel.stdout.trim();
-    if (topLevel.status !== 0 || !repoPath) {
-        throw new Error(`Expected the current directory to be inside a git repo, it is not.\n`
-            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`);
-    }
+    // The keys repo, which is this one when it holds keys and this machine's otherwise. Signing
+    // whatever repo the terminal happened to be in is how you end up signing something that is not
+    // a keys repo at all.
+    let { repoPath } = await (0, keysRepo_1.resolveKeysRepo)();
+    console.log(`Signing ${repoPath}`);
     await signRepo({ repoPath, keyPath });
     if (!pushToGit) {
         console.log(`Commit and push ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} for anything to see them.`);
@@ -177,5 +175,5 @@ async function main() {
     console.log(`Committed and pushed.`);
 }
 exports.main = main;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { runPromise } from \"socket-function/src/runPromise\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\nimport { findKeyProblems, normalizeKeys } from \"../authorizedKeys/authorizedKeys\";\n\n// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the\n// machine is, and then the signature proves nothing, so this is what we make when asked to make one.\nconst DEFAULT_KEY_TYPE = \"ed25519-sk\";\nconst DEFAULT_KEY_PATH = \"~/.ssh/signfiles_ed25519_sk\";\nconst GIT_KEYWORD = \"git\";\nconst COMMIT_MESSAGE = \"deploying signed files\";\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]\n\nSigns the files of the repo in the current directory. With no key, a hardware backed\n${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.\nPass ${GIT_KEYWORD} to also commit and push the result.`;\n\n/** runPromise takes a command line rather than an argument list, so anything holding a path has to\n    survive the shell. Double quotes work on both cmd and posix shells. */\nfunction quote(value: string) {\n    return `\"${value}\"`;\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\n/** Creating this needs the security key plugged in, and a touch. */\nasync function ensureDefaultKey() {\n    let keyPath = expandHome(DEFAULT_KEY_PATH);\n    if (await pathExists(keyPath)) {\n        return keyPath;\n    }\n    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);\n    console.log(`Plug your security key in - you will be asked to touch it.`);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N \"\" -C signfiles`);\n    return keyPath;\n}\n\n/** The public key in the form the daemon reports it, so what is printed here can be compared\n    against what arrives on Discord. */\nasync function publicKeyOf(keyPath: string) {\n    let contents = await fs.readFile(`${keyPath}.pub`, \"utf8\");\n    let [keyType, keyBody] = contents.trim().split(/\\s+/);\n    if (!keyType || !keyBody) {\n        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return `${keyType} ${keyBody}`;\n}\n\n/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it\n    is signed. Signing anything that is not a keys repo is none of this function's business. */\nasync function refuseUnusableKeys(repoPath: string) {\n    let authorizedPath = path.join(repoPath, \"authorized_keys\");\n    if (!await pathExists(authorizedPath)) {\n        return;\n    }\n    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, \"utf8\")));\n    if (!problems.length) {\n        return;\n    }\n    throw new Error(\n        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`\n        + ` found ${problems.length} problem(s):\\n`\n        + problems.map(problem => `  - ${problem}`).join(\"\\n\")\n        + `\\n\\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`\n        + `\\nname the same ones. Revoking a key that shares its addresses with another leaves that`\n        + `\\nother key working, which defeats the point of revoking it.`\n    );\n}\n\n/** Signing a keys repo that still holds a revoked key would publish it back to every machine that\n    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing\n    anything else is none of this function's business. */\nasync function refuseRevokedKeys(repoPath: string) {\n    if (!await pathExists(path.join(repoPath, \"authorized_keys\"))) {\n        return;\n    }\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let originURL = origin.stdout.trim();\n    if (origin.status !== 0 || !originURL) {\n        return;\n    }\n    let revoked;\n    try {\n        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });\n    } catch (e) {\n        // No revoke repo, or no access to it. Nothing has been revoked that we can see.\n        return;\n    }\n    if (!revoked.length) {\n        return;\n    }\n    throw new Error(\n        `Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\\n`\n        + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || \"?\"}`\n            + ` after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n        + `\\nDelete them from authorized_keys, or run \"yarn unrevoke\" here to allow them again.`\n    );\n}\n\nfunction parseArgs(argv: string[]) {\n    let pushToGit = argv.includes(GIT_KEYWORD);\n    let positional = argv.filter(arg => arg !== GIT_KEYWORD);\n    if (positional.length > 1) {\n        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(\" \")}\\n${USAGE}`);\n    }\n    return { keyPath: positional[0], pushToGit };\n}\n\n/** Writes the manifest and its signature into a repo. Separate from the command so anything that\n    changes a keys repo can leave it signed, rather than telling someone to go and do it. */\nexport async function signRepo(config: { repoPath: string; keyPath?: string }) {\n    let { repoPath } = config;\n    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();\n    if (!await pathExists(signingKey)) {\n        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);\n    }\n\n    await refuseUnusableKeys(repoPath);\n    await refuseRevokedKeys(repoPath);\n\n    let manifest = await buildManifest(repoPath);\n    console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);\n\n    // The manifest is built and signed away from the repo, and only moved in once both exist.\n    // Landing a new manifest next to an old signature produces a pair that can never verify, and\n    // the daemon reading it can only treat that as tampering.\n    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"signfiles-\"));\n    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);\n    let stagedSignature = `${stagedManifest}.sig`;\n    await fs.writeFile(stagedManifest, formatManifest(manifest));\n\n    // Signing happens before any git work, so a failed push never costs a second touch of the key.\n    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);\n    // Checked here rather than left for a machine that has already pulled it to discover.\n    await runPromise(\n        `ssh-keygen -Y check-novalidate -n ${SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`\n    );\n    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));\n    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));\n    await fs.rm(stagingDirectory, { recursive: true, force: true });\n    console.log(`Signed with ${await publicKeyOf(signingKey)}`);\n}\n\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a\n    // git warning glued to the front of this becomes a directory that does not exist.\n    let topLevel = await spawnPromise({ command: \"git\", args: [\"rev-parse\", \"--show-toplevel\"] });\n    let repoPath = topLevel.stdout.trim();\n    if (topLevel.status !== 0 || !repoPath) {\n        throw new Error(\n            `Expected the current directory to be inside a git repo, it is not.\\n`\n            + `${(topLevel.stdout + topLevel.stderr).trim()}\\n${USAGE}`\n        );\n    }\n    await signRepo({ repoPath, keyPath });\n\n    if (!pushToGit) {\n        console.log(`Commit and push ${MANIFEST_NAME} and ${SIGNATURE_NAME} for anything to see them.`);\n        return;\n    }\n    await runPromise(`git add -A`, { cwd: repoPath });\n    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means\n    // the signature matches the one already committed, so there is nothing to deploy.\n    let status = await spawnPromise({ command: \"git\", args: [\"status\", \"--porcelain\"], cwd: repoPath });\n    let staged = status.stdout;\n    if (!staged.trim()) {\n        console.log(`Nothing changed, ${MANIFEST_NAME} and ${SIGNATURE_NAME} are already committed.`);\n        return;\n    }\n    await runPromise(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });\n    await runPromise(`git push`, { cwd: repoPath });\n    console.log(`Committed and pushed.`);\n}\n"]}
- /* _JS_SOURCE_HASH = "5656bac7a766bdb1101df9294951fc82d227c63f880590d3dd4eb51bd67c88d1"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { runPromise } from \"socket-function/src/runPromise\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { findKeyProblems, normalizeKeys } from \"../authorizedKeys/authorizedKeys\";\n\n// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the\n// machine is, and then the signature proves nothing, so this is what we make when asked to make one.\nconst DEFAULT_KEY_TYPE = \"ed25519-sk\";\nconst DEFAULT_KEY_PATH = \"~/.ssh/signfiles_ed25519_sk\";\nconst GIT_KEYWORD = \"git\";\nconst COMMIT_MESSAGE = \"deploying signed files\";\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]\n\nSigns the files of the repo in the current directory. With no key, a hardware backed\n${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.\nPass ${GIT_KEYWORD} to also commit and push the result.`;\n\n/** runPromise takes a command line rather than an argument list, so anything holding a path has to\n    survive the shell. Double quotes work on both cmd and posix shells. */\nfunction quote(value: string) {\n    return `\"${value}\"`;\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\n/** Creating this needs the security key plugged in, and a touch. */\nasync function ensureDefaultKey() {\n    let keyPath = expandHome(DEFAULT_KEY_PATH);\n    if (await pathExists(keyPath)) {\n        return keyPath;\n    }\n    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);\n    console.log(`Plug your security key in - you will be asked to touch it.`);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N \"\" -C signfiles`);\n    return keyPath;\n}\n\n/** The public key in the form the daemon reports it, so what is printed here can be compared\n    against what arrives on Discord. */\nasync function publicKeyOf(keyPath: string) {\n    let contents = await fs.readFile(`${keyPath}.pub`, \"utf8\");\n    let [keyType, keyBody] = contents.trim().split(/\\s+/);\n    if (!keyType || !keyBody) {\n        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return `${keyType} ${keyBody}`;\n}\n\n/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it\n    is signed. Signing anything that is not a keys repo is none of this function's business. */\nasync function refuseUnusableKeys(repoPath: string) {\n    let authorizedPath = path.join(repoPath, \"authorized_keys\");\n    if (!await pathExists(authorizedPath)) {\n        return;\n    }\n    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, \"utf8\")));\n    if (!problems.length) {\n        return;\n    }\n    throw new Error(\n        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`\n        + ` found ${problems.length} problem(s):\\n`\n        + problems.map(problem => `  - ${problem}`).join(\"\\n\")\n        + `\\n\\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`\n        + `\\nname the same ones. Revoking a key that shares its addresses with another leaves that`\n        + `\\nother key working, which defeats the point of revoking it.`\n    );\n}\n\n/** Signing a keys repo that still holds a revoked key would publish it back to every machine that\n    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing\n    anything else is none of this function's business. */\nasync function refuseRevokedKeys(repoPath: string) {\n    if (!await pathExists(path.join(repoPath, \"authorized_keys\"))) {\n        return;\n    }\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let originURL = origin.stdout.trim();\n    if (origin.status !== 0 || !originURL) {\n        return;\n    }\n    let revoked;\n    try {\n        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });\n    } catch (e) {\n        // No revoke repo, or no access to it. Nothing has been revoked that we can see.\n        return;\n    }\n    if (!revoked.length) {\n        return;\n    }\n    throw new Error(\n        `Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\\n`\n        + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || \"?\"}`\n            + ` after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n        + `\\nDelete them from authorized_keys, or run \"yarn unrevoke\" here to allow them again.`\n    );\n}\n\nfunction parseArgs(argv: string[]) {\n    let pushToGit = argv.includes(GIT_KEYWORD);\n    let positional = argv.filter(arg => arg !== GIT_KEYWORD);\n    if (positional.length > 1) {\n        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(\" \")}\\n${USAGE}`);\n    }\n    return { keyPath: positional[0], pushToGit };\n}\n\n/** Writes the manifest and its signature into a repo. Separate from the command so anything that\n    changes a keys repo can leave it signed, rather than telling someone to go and do it. */\nexport async function signRepo(config: { repoPath: string; keyPath?: string }) {\n    let { repoPath } = config;\n    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();\n    if (!await pathExists(signingKey)) {\n        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);\n    }\n\n    await refuseUnusableKeys(repoPath);\n    await refuseRevokedKeys(repoPath);\n\n    let manifest = await buildManifest(repoPath);\n    console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);\n\n    // The manifest is built and signed away from the repo, and only moved in once both exist.\n    // Landing a new manifest next to an old signature produces a pair that can never verify, and\n    // the daemon reading it can only treat that as tampering.\n    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"signfiles-\"));\n    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);\n    let stagedSignature = `${stagedManifest}.sig`;\n    await fs.writeFile(stagedManifest, formatManifest(manifest));\n\n    // Signing happens before any git work, so a failed push never costs a second touch of the key.\n    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);\n    // Checked here rather than left for a machine that has already pulled it to discover.\n    await runPromise(\n        `ssh-keygen -Y check-novalidate -n ${SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`\n    );\n    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));\n    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));\n    await fs.rm(stagingDirectory, { recursive: true, force: true });\n    console.log(`Signed with ${await publicKeyOf(signingKey)}`);\n}\n\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    // The keys repo, which is this one when it holds keys and this machine's otherwise. Signing\n    // whatever repo the terminal happened to be in is how you end up signing something that is not\n    // a keys repo at all.\n    let { repoPath } = await resolveKeysRepo();\n    console.log(`Signing ${repoPath}`);\n    await signRepo({ repoPath, keyPath });\n\n    if (!pushToGit) {\n        console.log(`Commit and push ${MANIFEST_NAME} and ${SIGNATURE_NAME} for anything to see them.`);\n        return;\n    }\n    await runPromise(`git add -A`, { cwd: repoPath });\n    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means\n    // the signature matches the one already committed, so there is nothing to deploy.\n    let status = await spawnPromise({ command: \"git\", args: [\"status\", \"--porcelain\"], cwd: repoPath });\n    let staged = status.stdout;\n    if (!staged.trim()) {\n        console.log(`Nothing changed, ${MANIFEST_NAME} and ${SIGNATURE_NAME} are already committed.`);\n        return;\n    }\n    await runPromise(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });\n    await runPromise(`git push`, { cwd: repoPath });\n    console.log(`Committed and pushed.`);\n}\n"]}
+ /* _JS_SOURCE_HASH = "e62739f311ed1c2d2b818032186647cfb19cc96beec3178194cb15bda564b243"; */

package/security/signedFiles/signFiles.ts

@@ -6,6 +6,7 @@ import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
 import { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from "./manifest";
 import { revokedKeysInRepo } from "../authorizedKeys/unrevoke";
+import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { findKeyProblems, normalizeKeys } from "../authorizedKeys/authorizedKeys";
 
 // A hardware backed key is the entire point. A key sitting on disk is compromised the moment the
@@ -159,16 +160,11 @@ export async function signRepo(config: { repoPath: string; keyPath?: string }) {
 export async function main() {
     let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
 
-    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a
-    // git warning glued to the front of this becomes a directory that does not exist.
-    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"] });
-    let repoPath = topLevel.stdout.trim();
-    if (topLevel.status !== 0 || !repoPath) {
-        throw new Error(
-            `Expected the current directory to be inside a git repo, it is not.\n`
-            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`
-        );
-    }
+    // The keys repo, which is this one when it holds keys and this machine's otherwise. Signing
+    // whatever repo the terminal happened to be in is how you end up signing something that is not
+    // a keys repo at all.
+    let { repoPath } = await resolveKeysRepo();
+    console.log(`Signing ${repoPath}`);
     await signRepo({ repoPath, keyPath });
 
     if (!pushToGit) {

package/security/machines/trustState.ts

@@ -1,53 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { UNREVOKE_DELAY } from "../authorizedKeys/daemon/paths";
-import { keysDir } from "../authorizedKeys/sources";
-import { messageTimestamp } from "../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.join(keysDir(), FIRST_SEEN_FILE);
-}
-
-async function readFirstSeen(): Promise<{ [unrevokeId: string]: number }> {
-    try {
-        return JSON.parse(await fs.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. */
-export async function unrevokeInEffect(unrevokeId: string) {
-    let firstSeen = await readFirstSeen();
-    let seenAt = firstSeen[unrevokeId];
-    if (!seenAt) {
-        seenAt = Date.now();
-        firstSeen[unrevokeId] = seenAt;
-        await fs.mkdir(path.dirname(firstSeenPath()), { recursive: true, mode: 0o700 });
-        await fs.writeFile(firstSeenPath(), JSON.stringify(firstSeen, undefined, 4) + "\n");
-    }
-    if (Date.now() - seenAt < UNREVOKE_DELAY) {
-        console.log(
-            `Holding the unrevoke ${unrevokeId} until ${messageTimestamp(new Date(seenAt + UNREVOKE_DELAY))}`
-        );
-        return false;
-    }
-    return true;
-}