sliftutils 1.7.124 → 1.7.126

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

@@ -0,0 +1,180 @@
+"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.stopDiscordNotifications = exports.sendDiscordNotification = exports.configureDiscordNotifications = exports.sendToWebhookURL = exports.formatWebhookFile = exports.redactWebhookURL = exports.parseWebhookFile = exports.DEFAULT_WEBHOOK_FILE_PATH = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js embeds a hand port of this file in plain JS, so the
+// daemon can run with no dependencies. The two are expected to behave identically - if you change
+// one, make the matching change in the other.
+exports.DEFAULT_WEBHOOK_FILE_PATH = "/etc/portsecure/discord-webhook";
+const DEFAULT_CHECK_INTERVAL = 5 * 60 * 1000;
+const VALID_WEBHOOK_PREFIXES = [
+    "https://discord.com/api/webhooks/",
+    "https://discordapp.com/api/webhooks/",
+    "https://canary.discord.com/api/webhooks/",
+];
+const DISCORD_MESSAGE_LIMIT = 2000;
+const MAX_ERROR_BODY_LENGTH = 500;
+const MAX_SEND_ATTEMPTS = 3;
+const REDACTED_TOKEN_VISIBLE = 8;
+const DEFAULT_RATE_LIMIT_WAIT = 2 * 1000;
+let notificationState;
+// Discord webhooks are rate limited (roughly 5 requests per 2 seconds), so every send
+// goes through one chain instead of racing.
+let sendChain = Promise.resolve();
+/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so
+    callers can name a remote path. */
+function parseWebhookFile(config) {
+    let { contents, sourceName } = config;
+    let lines = contents.split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("#"));
+    let webhookURL = lines[0];
+    if (!webhookURL) {
+        throw new Error(`Expected a Discord webhook URL in ${sourceName}, the file has no usable lines`);
+    }
+    if (!VALID_WEBHOOK_PREFIXES.some(prefix => webhookURL.startsWith(prefix))) {
+        throw new Error(`Expected a Discord webhook URL starting with one of ${VALID_WEBHOOK_PREFIXES.join(", ")}, `
+            + `was ${webhookURL.slice(0, MAX_ERROR_BODY_LENGTH)} (in ${sourceName})`);
+    }
+    return webhookURL;
+}
+exports.parseWebhookFile = parseWebhookFile;
+/** Keeps the id and both ends of the token, so a reader can confirm which webhook replaced theirs
+    without receiving one they could post to. */
+function redactWebhookURL(webhookURL) {
+    let separatorIndex = webhookURL.lastIndexOf("/");
+    let base = webhookURL.slice(0, separatorIndex + 1);
+    let token = webhookURL.slice(separatorIndex + 1);
+    if (token.length <= REDACTED_TOKEN_VISIBLE * 2) {
+        // Too short to show both ends without giving away the whole token.
+        return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...`;
+    }
+    return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...${token.slice(-REDACTED_TOKEN_VISIBLE)}`;
+}
+exports.redactWebhookURL = redactWebhookURL;
+function formatWebhookFile(webhookURL) {
+    return `# portsecure Discord webhook. First non-comment line is used.\n${webhookURL}\n`;
+}
+exports.formatWebhookFile = formatWebhookFile;
+async function readWebhookFile(filePath) {
+    let contents;
+    try {
+        contents = await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (e) {
+        throw new Error(`Expected a readable Discord webhook file at ${filePath}, ${e}`);
+    }
+    return parseWebhookFile({ contents, sourceName: filePath });
+}
+async function postToWebhook(webhookURL, message) {
+    let content = message;
+    if (content.length > DISCORD_MESSAGE_LIMIT) {
+        content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
+    }
+    for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {
+        let response = await fetch(webhookURL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ content }),
+        });
+        if (response.ok) {
+            return;
+        }
+        let body = (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);
+        if (response.status === 429 && attempt < MAX_SEND_ATTEMPTS) {
+            let retryAfter = Number(response.headers.get("retry-after"));
+            let waitTime = retryAfter && retryAfter * 1000 || DEFAULT_RATE_LIMIT_WAIT;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+            continue;
+        }
+        throw new Error(`Expected a 2xx response from the Discord webhook, was ${response.status} ${response.statusText}, body ${body}`);
+    }
+}
+function queueSend(webhookURL, message) {
+    let send = () => postToWebhook(webhookURL, message);
+    let result = sendChain.then(send, send);
+    sendChain = result.catch(() => undefined);
+    return result;
+}
+/** Sends to an explicit webhook URL, for tooling that acts on a webhook before (or instead of)
+    configureDiscordNotifications - setup, migrations, connectivity checks. */
+function sendToWebhookURL(config) {
+    return queueSend(config.webhookURL, config.message);
+}
+exports.sendToWebhookURL = sendToWebhookURL;
+async function checkWebhookFileChanged() {
+    let state = notificationState;
+    if (!state) {
+        return;
+    }
+    let newWebhookURL;
+    try {
+        newWebhookURL = await readWebhookFile(state.filePath);
+    }
+    catch (e) {
+        console.error(`portsecure: Discord webhook file is no longer readable, still using the loaded webhook. ${e}`);
+        return;
+    }
+    if (newWebhookURL === state.webhookURL) {
+        return;
+    }
+    // Warn the old channel first, with the new webhook redacted, so a stolen old webhook does not
+    // hand the attacker a usable new one.
+    try {
+        await queueSend(state.webhookURL, `**portsecure**: the Discord webhook in \`${state.filePath}\` changed to`
+            + ` \`${redactWebhookURL(newWebhookURL)}\`.`
+            + ` Notifications are moving to the new webhook and this channel will stop receiving them.`);
+    }
+    catch (e) {
+        console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);
+    }
+    state.webhookURL = newWebhookURL;
+}
+/** Must be called once on startup, before any notification is sent. Aborts the process if the
+    webhook file is missing or invalid, then re-checks the file on an interval and warns the old
+    webhook whenever it changes. */
+async function configureDiscordNotifications(config) {
+    if (notificationState) {
+        throw new Error(`Expected configureDiscordNotifications to be called once, was called again (already using ${notificationState.filePath})`);
+    }
+    let filePath = (config === null || config === void 0 ? void 0 : config.filePath) || exports.DEFAULT_WEBHOOK_FILE_PATH;
+    let checkInterval = (config === null || config === void 0 ? void 0 : config.checkInterval) || DEFAULT_CHECK_INTERVAL;
+    let webhookURL;
+    try {
+        webhookURL = await readWebhookFile(filePath);
+    }
+    catch (e) {
+        console.error(`portsecure: refusing to start without a valid Discord webhook file.\n${e}`);
+        process.exit(1);
+    }
+    let checkTimer = setInterval(() => {
+        checkWebhookFileChanged().catch(e => console.error(`portsecure: Discord webhook file check failed. ${e}`));
+    }, checkInterval);
+    // The check should never be the reason the process stays alive.
+    checkTimer.unref();
+    notificationState = { filePath, webhookURL, checkTimer };
+    return { filePath, checkInterval };
+}
+exports.configureDiscordNotifications = configureDiscordNotifications;
+// DO NOT add new calls to this. Every message goes to a real Discord server someone reads, so a
+// notification is only ever added when the user explicitly asks for that specific case. Startup,
+// success, errors, retries and recoveries all belong in a log instead.
+async function sendDiscordNotification(message) {
+    let state = notificationState;
+    if (!state) {
+        throw new Error(`Expected configureDiscordNotifications to be called before sending, was called with message ${message.slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    await queueSend(state.webhookURL, message);
+}
+exports.sendDiscordNotification = sendDiscordNotification;
+function stopDiscordNotifications() {
+    if (!notificationState) {
+        return;
+    }
+    clearInterval(notificationState.checkTimer);
+    notificationState = undefined;
+}
+exports.stopDiscordNotifications = stopDiscordNotifications;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discord.js","sourceRoot":"","sources":["discord.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\n\n// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js embeds a hand port of this file in plain JS, so the\n// daemon can run with no dependencies. The two are expected to behave identically - if you change\n// one, make the matching change in the other.\n\nexport const DEFAULT_WEBHOOK_FILE_PATH = \"/etc/portsecure/discord-webhook\";\nconst DEFAULT_CHECK_INTERVAL = 5 * 60 * 1000;\nconst VALID_WEBHOOK_PREFIXES = [\n    \"https://discord.com/api/webhooks/\",\n    \"https://discordapp.com/api/webhooks/\",\n    \"https://canary.discord.com/api/webhooks/\",\n];\nconst DISCORD_MESSAGE_LIMIT = 2000;\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst MAX_SEND_ATTEMPTS = 3;\nconst REDACTED_TOKEN_VISIBLE = 8;\nconst DEFAULT_RATE_LIMIT_WAIT = 2 * 1000;\n\nlet notificationState: {\n    filePath: string;\n    webhookURL: string;\n    checkTimer: NodeJS.Timeout;\n} | undefined;\n\n// Discord webhooks are rate limited (roughly 5 requests per 2 seconds), so every send\n// goes through one chain instead of racing.\nlet sendChain: Promise<unknown> = Promise.resolve();\n\n/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so\n    callers can name a remote path. */\nexport function parseWebhookFile(config: { contents: string; sourceName: string }) {\n    let { contents, sourceName } = config;\n    let lines = contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n    let webhookURL = lines[0];\n    if (!webhookURL) {\n        throw new Error(`Expected a Discord webhook URL in ${sourceName}, the file has no usable lines`);\n    }\n    if (!VALID_WEBHOOK_PREFIXES.some(prefix => webhookURL.startsWith(prefix))) {\n        throw new Error(\n            `Expected a Discord webhook URL starting with one of ${VALID_WEBHOOK_PREFIXES.join(\", \")}, `\n            + `was ${webhookURL.slice(0, MAX_ERROR_BODY_LENGTH)} (in ${sourceName})`\n        );\n    }\n    return webhookURL;\n}\n\n/** Keeps the id and both ends of the token, so a reader can confirm which webhook replaced theirs\n    without receiving one they could post to. */\nexport function redactWebhookURL(webhookURL: string) {\n    let separatorIndex = webhookURL.lastIndexOf(\"/\");\n    let base = webhookURL.slice(0, separatorIndex + 1);\n    let token = webhookURL.slice(separatorIndex + 1);\n    if (token.length <= REDACTED_TOKEN_VISIBLE * 2) {\n        // Too short to show both ends without giving away the whole token.\n        return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...`;\n    }\n    return `${base}${token.slice(0, REDACTED_TOKEN_VISIBLE)}...${token.slice(-REDACTED_TOKEN_VISIBLE)}`;\n}\n\nexport function formatWebhookFile(webhookURL: string) {\n    return `# portsecure Discord webhook. First non-comment line is used.\\n${webhookURL}\\n`;\n}\n\nasync function readWebhookFile(filePath: string) {\n    let contents;\n    try {\n        contents = await fs.readFile(filePath, \"utf8\");\n    } catch (e) {\n        throw new Error(`Expected a readable Discord webhook file at ${filePath}, ${e}`);\n    }\n    return parseWebhookFile({ contents, sourceName: filePath });\n}\n\nasync function postToWebhook(webhookURL: string, message: string) {\n    let content = message;\n    if (content.length > DISCORD_MESSAGE_LIMIT) {\n        content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + \"...\";\n    }\n    for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {\n        let response = await fetch(webhookURL, {\n            method: \"POST\",\n            headers: { \"Content-Type\": \"application/json\" },\n            body: JSON.stringify({ content }),\n        });\n        if (response.ok) {\n            return;\n        }\n        let body = (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);\n        if (response.status === 429 && attempt < MAX_SEND_ATTEMPTS) {\n            let retryAfter = Number(response.headers.get(\"retry-after\"));\n            let waitTime = retryAfter && retryAfter * 1000 || DEFAULT_RATE_LIMIT_WAIT;\n            await new Promise(resolve => setTimeout(resolve, waitTime));\n            continue;\n        }\n        throw new Error(\n            `Expected a 2xx response from the Discord webhook, was ${response.status} ${response.statusText}, body ${body}`\n        );\n    }\n}\n\nfunction queueSend(webhookURL: string, message: string) {\n    let send = () => postToWebhook(webhookURL, message);\n    let result = sendChain.then(send, send);\n    sendChain = result.catch(() => undefined);\n    return result;\n}\n\n/** Sends to an explicit webhook URL, for tooling that acts on a webhook before (or instead of)\n    configureDiscordNotifications - setup, migrations, connectivity checks. */\nexport function sendToWebhookURL(config: { webhookURL: string; message: string }) {\n    return queueSend(config.webhookURL, config.message);\n}\n\nasync function checkWebhookFileChanged() {\n    let state = notificationState;\n    if (!state) {\n        return;\n    }\n    let newWebhookURL;\n    try {\n        newWebhookURL = await readWebhookFile(state.filePath);\n    } catch (e) {\n        console.error(`portsecure: Discord webhook file is no longer readable, still using the loaded webhook. ${e}`);\n        return;\n    }\n    if (newWebhookURL === state.webhookURL) {\n        return;\n    }\n    // Warn the old channel first, with the new webhook redacted, so a stolen old webhook does not\n    // hand the attacker a usable new one.\n    try {\n        await queueSend(\n            state.webhookURL,\n            `**portsecure**: the Discord webhook in \\`${state.filePath}\\` changed to`\n            + ` \\`${redactWebhookURL(newWebhookURL)}\\`.`\n            + ` Notifications are moving to the new webhook and this channel will stop receiving them.`\n        );\n    } catch (e) {\n        console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);\n    }\n    state.webhookURL = newWebhookURL;\n}\n\n/** Must be called once on startup, before any notification is sent. Aborts the process if the\n    webhook file is missing or invalid, then re-checks the file on an interval and warns the old\n    webhook whenever it changes. */\nexport async function configureDiscordNotifications(config?: {\n    filePath?: string;\n    checkInterval?: number;\n}) {\n    if (notificationState) {\n        throw new Error(`Expected configureDiscordNotifications to be called once, was called again (already using ${notificationState.filePath})`);\n    }\n    let filePath = config?.filePath || DEFAULT_WEBHOOK_FILE_PATH;\n    let checkInterval = config?.checkInterval || DEFAULT_CHECK_INTERVAL;\n    let webhookURL;\n    try {\n        webhookURL = await readWebhookFile(filePath);\n    } catch (e) {\n        console.error(`portsecure: refusing to start without a valid Discord webhook file.\\n${e}`);\n        process.exit(1);\n    }\n    let checkTimer = setInterval(() => {\n        checkWebhookFileChanged().catch(e => console.error(`portsecure: Discord webhook file check failed. ${e}`));\n    }, checkInterval);\n    // The check should never be the reason the process stays alive.\n    checkTimer.unref();\n    notificationState = { filePath, webhookURL, checkTimer };\n    return { filePath, checkInterval };\n}\n\n// DO NOT add new calls to this. Every message goes to a real Discord server someone reads, so a\n// notification is only ever added when the user explicitly asks for that specific case. Startup,\n// success, errors, retries and recoveries all belong in a log instead.\nexport async function sendDiscordNotification(message: string) {\n    let state = notificationState;\n    if (!state) {\n        throw new Error(`Expected configureDiscordNotifications to be called before sending, was called with message ${message.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    await queueSend(state.webhookURL, message);\n}\n\nexport function stopDiscordNotifications() {\n    if (!notificationState) {\n        return;\n    }\n    clearInterval(notificationState.checkTimer);\n    notificationState = undefined;\n}\n"]}
+ /* _JS_SOURCE_HASH = "d5d1b1a9e262cd5b805adb2fa7d074d1a92e9a99dd226550e7f055a9766ebd19"; */

package/security/notifications/remoteWebhook.ts

@@ -0,0 +1,85 @@
+import { DEFAULT_WEBHOOK_FILE_PATH, formatWebhookFile, parseWebhookFile, redactWebhookURL, sendToWebhookURL } from "./discord";
+import { readRemoteFile, writeRemoteFile } from "../helpers/remoteSSH";
+
+export const 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. */
+export async function ensureRemoteWebhook(config: {
+    host: string;
+    webhookURL: string;
+    replace: boolean;
+    filePath?: string;
+}) {
+    let { host, webhookURL, replace } = config;
+    let filePath = config.filePath || DEFAULT_WEBHOOK_FILE_PATH;
+
+    let replacedURL = "";
+    let existingContents = await 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 = 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" as const, 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 "${REPLACE_KEYWORD}" to overwrite it.`
+            );
+        }
+        replacedURL = existingURL;
+    }
+
+    await writeRemoteFile({
+        host,
+        filePath,
+        contents: formatWebhookFile(webhookURL),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+
+    let writtenContents = await readRemoteFile({ host, filePath });
+    if (!writtenContents) {
+        throw new Error(`Expected ${filePath} to exist on ${host} after writing, no such file exists`);
+    }
+    let writtenURL = 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 sendToWebhookURL({
+                webhookURL: replacedURL,
+                message: `**portsecure**: the Discord webhook for \`${host}\` was replaced with`
+                    + ` \`${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 sendToWebhookURL({
+        webhookURL,
+        message: `**portsecure**: notifications are now configured for \`${host}\`.`
+            + ` This channel will receive its security notifications.`,
+    });
+
+    return { outcome: replacedURL && "replaced" as const || "created" as const, filePath };
+}

package/security/notifications/setupNotify.ts

@@ -0,0 +1,29 @@
+import { parseWebhookFile } from "./discord";
+import { ensureRemoteWebhook, REPLACE_KEYWORD } from "./remoteWebhook";
+
+const USAGE = `Usage: yarn setupnotify <host> <discord-webhook-url> [${REPLACE_KEYWORD}]`;
+
+function parseArgs(argv: string[]) {
+    let replace = argv.includes(REPLACE_KEYWORD);
+    let positional = argv.filter(arg => arg !== REPLACE_KEYWORD);
+    if (positional.length !== 2) {
+        throw new Error(`Expected a host and a webhook URL, was ${positional.length} argument(s): ${positional.join(" ") || "(none)"}\n${USAGE}`);
+    }
+    let [host, webhookURL] = positional;
+    // Validates the URL shape up front, so we never ssh anywhere with a bad webhook.
+    parseWebhookFile({ contents: webhookURL, sourceName: "the command line" });
+    return { host, webhookURL, replace };
+}
+
+export async function main() {
+    let { host, webhookURL, replace } = parseArgs(process.argv.slice(2));
+    let { outcome, filePath } = await ensureRemoteWebhook({ host, webhookURL, replace });
+    if (outcome === "unchanged") {
+        console.log(`${host} already has this exact webhook in ${filePath}, nothing to do.`);
+        return;
+    }
+    if (outcome === "replaced") {
+        console.log(`Replaced the webhook on ${host} and notified the old one.`);
+    }
+    console.log(`Wrote ${filePath} on ${host} (mode 600), and confirmed on the new webhook.`);
+}

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

@@ -0,0 +1,68 @@
+"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.formatManifest = exports.buildManifest = exports.digestFile = exports.normalizeContent = exports.listRepoFiles = exports.MANIFEST_VERSION = exports.SIGN_NAMESPACE = exports.SIGNATURE_NAME = exports.MANIFEST_NAME = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const spawn_1 = require("../helpers/spawn");
+// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js contains a plain JS port of the
+// verifying half of this file, so it can check a signature with no dependencies. Both sides must
+// agree on the manifest shape and on which files it covers - if you change one, make the matching
+// change in the other.
+exports.MANIFEST_NAME = "signedfiles.json";
+exports.SIGNATURE_NAME = "signedfiles.json.sig";
+// ssh signatures are namespaced, so a signature made for one purpose cannot be replayed as another.
+exports.SIGN_NAMESPACE = "signfiles";
+exports.MANIFEST_VERSION = 1;
+/** Everything in the repo that is not ignored, which is exactly what a clone of it will contain.
+    The manifest and its signature are left out, since they cannot describe themselves. */
+async function listRepoFiles(repoPath) {
+    let result = await (0, spawn_1.spawnPromise)({
+        command: "git",
+        args: ["ls-files", "--cached", "--others", "--exclude-standard"],
+        cwd: repoPath,
+    });
+    if (result.status !== 0) {
+        throw new Error(`Expected to list the files in ${repoPath}, git ls-files exited ${result.status}. `
+            + `${(result.stdout + result.stderr).trim()}`);
+    }
+    return result.stdout.split("\n")
+        .map(line => line.trim())
+        .filter(line => line && line !== exports.MANIFEST_NAME && line !== exports.SIGNATURE_NAME)
+        .sort();
+}
+exports.listRepoFiles = listRepoFiles;
+/** A Windows checkout turns LF into CRLF, so the same commit hashes differently there than it
+    does on the machine that pulls it. Normalising first makes the digest describe the content
+    rather than whichever checkout produced it. latin1 round trips every byte, so this is safe on
+    files that are not text. */
+function normalizeContent(contents) {
+    return Buffer.from(contents.toString("latin1").replace(/\r\n/g, "\n"), "latin1");
+}
+exports.normalizeContent = normalizeContent;
+/** The size and hash of a file's normalised content. The size is the normalised one on purpose,
+    so it agrees with the hash rather than with whatever the local checkout happens to hold. */
+async function digestFile(filePath) {
+    let contents = normalizeContent(await promises_1.default.readFile(filePath));
+    return { size: contents.length, sha256: crypto_1.default.createHash("sha256").update(contents).digest("hex") };
+}
+exports.digestFile = digestFile;
+async function buildManifest(repoPath) {
+    let files = [];
+    for (let relativePath of await listRepoFiles(repoPath)) {
+        let digest = await digestFile(path_1.default.join(repoPath, relativePath));
+        files.push({ path: relativePath, size: digest.size, sha256: digest.sha256 });
+    }
+    return { version: exports.MANIFEST_VERSION, files };
+}
+exports.buildManifest = buildManifest;
+/** Sorted keys and a trailing newline, so the same tree always produces the same bytes to sign. */
+function formatManifest(manifest) {
+    return JSON.stringify(manifest, undefined, 4) + "\n";
+}
+exports.formatManifest = formatManifest;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "b03b98c478c3d40c11ab30a9be0a3a73ddfbb41e74230864ca940f9edd07dc68"; */

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

@@ -0,0 +1,146 @@
+"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.main = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const runPromise_1 = require("socket-function/src/runPromise");
+const paths_1 = require("../helpers/paths");
+const manifest_1 = require("./manifest");
+const unrevoke_1 = require("../authorizedKeys/unrevoke");
+// 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.
+const DEFAULT_KEY_TYPE = "ed25519-sk";
+const DEFAULT_KEY_PATH = "~/.ssh/signfiles_ed25519_sk";
+const GIT_KEYWORD = "git";
+const COMMIT_MESSAGE = "deploying signed files";
+const MAX_ERROR_BODY_LENGTH = 500;
+const USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]
+
+Signs the files of the repo in the current directory. With no key, a hardware backed
+${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.
+Pass ${GIT_KEYWORD} to also commit and push the result.`;
+/** runPromise takes a command line rather than an argument list, so anything holding a path has to
+    survive the shell. Double quotes work on both cmd and posix shells. */
+function quote(value) {
+    return `"${value}"`;
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** Creating this needs the security key plugged in, and a touch. */
+async function ensureDefaultKey() {
+    let keyPath = (0, paths_1.expandHome)(DEFAULT_KEY_PATH);
+    if (await pathExists(keyPath)) {
+        return keyPath;
+    }
+    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);
+    console.log(`Plug your security key in - you will be asked to touch it.`);
+    await promises_1.default.mkdir(path_1.default.dirname(keyPath), { recursive: true, mode: 0o700 });
+    await (0, runPromise_1.runPromise)(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N "" -C signfiles`);
+    return keyPath;
+}
+/** The public key in the form the daemon reports it, so what is printed here can be compared
+    against what arrives on Discord. */
+async function publicKeyOf(keyPath) {
+    let contents = await promises_1.default.readFile(`${keyPath}.pub`, "utf8");
+    let [keyType, keyBody] = contents.trim().split(/\s+/);
+    if (!keyType || !keyBody) {
+        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return `${keyType} ${keyBody}`;
+}
+/** Signing a keys repo that still holds a revoked key would publish it back to every machine that
+    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing
+    anything else is none of this function's business. */
+async function refuseRevokedKeys(repoPath) {
+    if (!await pathExists(path_1.default.join(repoPath, "authorized_keys"))) {
+        return;
+    }
+    let originURL = (await (0, runPromise_1.runPromise)("git remote get-url origin", { cwd: repoPath, quiet: true, nothrow: true })).trim();
+    if (!originURL) {
+        return;
+    }
+    let revoked;
+    try {
+        revoked = await (0, unrevoke_1.revokedKeysInRepo)({ repoPath, sourceURL: originURL });
+    }
+    catch (e) {
+        // No revoke repo, or no access to it. Nothing has been revoked that we can see.
+        return;
+    }
+    if (!revoked.length) {
+        return;
+    }
+    throw new Error(`Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\n`
+        + revoked.map(entry => {
+            var _a;
+            return `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || "?"}`
+                + ` after use from ${((_a = entry.revocation.attempt) === null || _a === void 0 ? void 0 : _a.ip) || "?"}`;
+        }).join("\n")
+        + `\nDelete them from authorized_keys, or run "yarn unrevoke" here to allow them again.`);
+}
+function parseArgs(argv) {
+    let pushToGit = argv.includes(GIT_KEYWORD);
+    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
+    if (positional.length > 1) {
+        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(" ")}\n${USAGE}`);
+    }
+    return { keyPath: positional[0], pushToGit };
+}
+async function main() {
+    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
+    let repoPath = (await (0, runPromise_1.runPromise)("git rev-parse --show-toplevel", { quiet: true })).trim();
+    if (!repoPath) {
+        throw new Error(`Expected the current directory to be inside a git repo, it is not.\n${USAGE}`);
+    }
+    let signingKey = keyPath && (0, paths_1.expandHome)(keyPath) || await ensureDefaultKey();
+    if (!await pathExists(signingKey)) {
+        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);
+    }
+    await refuseRevokedKeys(repoPath);
+    let manifest = await (0, manifest_1.buildManifest)(repoPath);
+    console.log(`${manifest_1.MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);
+    // The manifest is built and signed away from the repo, and only moved in once both exist.
+    // Landing a new manifest next to an old signature produces a pair that can never verify, and
+    // the daemon reading it can only treat that as tampering.
+    let stagingDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "signfiles-"));
+    let stagedManifest = path_1.default.join(stagingDirectory, manifest_1.MANIFEST_NAME);
+    let stagedSignature = `${stagedManifest}.sig`;
+    await promises_1.default.writeFile(stagedManifest, (0, manifest_1.formatManifest)(manifest));
+    // Signing happens before any git work, so a failed push never costs a second touch of the key.
+    await (0, runPromise_1.runPromise)(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${manifest_1.SIGN_NAMESPACE} ${quote(stagedManifest)}`);
+    // Checked here rather than left for a machine that has already pulled it to discover.
+    await (0, runPromise_1.runPromise)(`ssh-keygen -Y check-novalidate -n ${manifest_1.SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`);
+    await promises_1.default.copyFile(stagedManifest, path_1.default.join(repoPath, manifest_1.MANIFEST_NAME));
+    await promises_1.default.copyFile(stagedSignature, path_1.default.join(repoPath, manifest_1.SIGNATURE_NAME));
+    await promises_1.default.rm(stagingDirectory, { recursive: true, force: true });
+    console.log(`Signed with ${await publicKeyOf(signingKey)}`);
+    if (!pushToGit) {
+        console.log(`Commit and push ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} for anything to see them.`);
+        return;
+    }
+    await (0, runPromise_1.runPromise)(`git add -A`, { cwd: repoPath });
+    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means
+    // the signature matches the one already committed, so there is nothing to deploy.
+    let staged = await (0, runPromise_1.runPromise)(`git status --porcelain`, { cwd: repoPath, quiet: true });
+    if (!staged.trim()) {
+        console.log(`Nothing changed, ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} are already committed.`);
+        return;
+    }
+    await (0, runPromise_1.runPromise)(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });
+    await (0, runPromise_1.runPromise)(`git push`, { cwd: repoPath });
+    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 { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\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/** 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    let originURL = (await runPromise(\"git remote get-url origin\", { cwd: repoPath, quiet: true, nothrow: true })).trim();\n    if (!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\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    let repoPath = (await runPromise(\"git rev-parse --show-toplevel\", { quiet: true })).trim();\n    if (!repoPath) {\n        throw new Error(`Expected the current directory to be inside a git repo, it is not.\\n${USAGE}`);\n    }\n\n    let signingKey = keyPath && expandHome(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 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    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 staged = await runPromise(`git status --porcelain`, { cwd: repoPath, quiet: true });\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 = "534e0243c3e52f007b386e8947198cdd98869d9cc5f9dda1413aeecb36b947a7"; */