sliftutils 1.7.125 → 1.7.127

package/security/keys/sshKeyFile.ts

@@ -0,0 +1,156 @@
+import crypto from "crypto";
+
+// OpenSSH keeps private keys in its own container rather than anything node can read, so the few
+// bytes of it we need are handled here. Only unencrypted ed25519 keys are supported, which is what
+// a key used by automation is.
+
+const MAGIC = "openssh-key-v1\0";
+const KEY_TYPE = "ssh-ed25519";
+const NONE = "none";
+const SEED_LENGTH = 32;
+const PUBLIC_LENGTH = 32;
+// The one block size that matters here, since nothing is encrypted.
+const PADDING_BLOCK = 8;
+const PEM_LINE_LENGTH = 70;
+const PRIVATE_HEADER = "-----BEGIN OPENSSH PRIVATE KEY-----";
+const PRIVATE_FOOTER = "-----END OPENSSH PRIVATE KEY-----";
+// The prefix that turns a bare 32 byte seed into a pkcs8 ed25519 key node will accept.
+const PKCS8_ED25519_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+
+class ByteReader {
+    private offset = 0;
+    constructor(private buffer: Buffer) { }
+
+    readBytes(length: number) {
+        let value = this.buffer.subarray(this.offset, this.offset + length);
+        if (value.length !== length) {
+            throw new Error(`Expected ${length} bytes at offset ${this.offset}, was ${value.length}`);
+        }
+        this.offset += length;
+        return value;
+    }
+
+    readUInt32() {
+        let value = this.buffer.readUInt32BE(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    readString() {
+        return this.readBytes(this.readUInt32());
+    }
+}
+
+function writeString(value: Buffer | string) {
+    let contents = Buffer.isBuffer(value) && value || Buffer.from(value, "utf8");
+    let length = Buffer.alloc(4);
+    length.writeUInt32BE(contents.length);
+    return Buffer.concat([length, contents]);
+}
+
+function writeUInt32(value: number) {
+    let bytes = Buffer.alloc(4);
+    bytes.writeUInt32BE(value);
+    return bytes;
+}
+
+/** The public key of a seed, worked out by node rather than by reimplementing the curve. */
+export function publicKeyFromSeed(seed: Buffer) {
+    if (seed.length !== SEED_LENGTH) {
+        throw new Error(`Expected a ${SEED_LENGTH} byte seed, was ${seed.length}`);
+    }
+    let privateKey = crypto.createPrivateKey({
+        key: Buffer.concat([PKCS8_ED25519_PREFIX, seed]),
+        format: "der",
+        type: "pkcs8",
+    });
+    // The spki wrapper is a fixed 12 byte header followed by the raw key.
+    return crypto.createPublicKey(privateKey).export({ format: "der", type: "spki" }).subarray(12);
+}
+
+export function parseOpenSSHPrivateKey(contents: string) {
+    let body = contents.split("\n").filter(line => line.trim() && !line.startsWith("-----")).join("");
+    if (!contents.includes(PRIVATE_HEADER)) {
+        throw new Error(`Expected an OpenSSH private key starting with ${PRIVATE_HEADER}`);
+    }
+    let reader = new ByteReader(Buffer.from(body, "base64"));
+    if (reader.readBytes(MAGIC.length).toString() !== MAGIC) {
+        throw new Error(`Expected the key to start with ${JSON.stringify(MAGIC)}`);
+    }
+    let cipherName = reader.readString().toString();
+    let kdfName = reader.readString().toString();
+    reader.readString();
+    if (cipherName !== NONE || kdfName !== NONE) {
+        throw new Error(
+            `Expected an unencrypted key, was encrypted with ${cipherName}/${kdfName}.`
+            + ` Remove the passphrase with "ssh-keygen -p" first.`
+        );
+    }
+    let keyCount = reader.readUInt32();
+    if (keyCount !== 1) {
+        throw new Error(`Expected the key file to hold one key, held ${keyCount}`);
+    }
+    reader.readString();
+
+    let privateSection = new ByteReader(reader.readString());
+    let checkOne = privateSection.readUInt32();
+    let checkTwo = privateSection.readUInt32();
+    if (checkOne !== checkTwo) {
+        throw new Error(`Expected the key's two check values to match, were ${checkOne} and ${checkTwo}`);
+    }
+    let keyType = privateSection.readString().toString();
+    if (keyType !== KEY_TYPE) {
+        throw new Error(`Expected an ${KEY_TYPE} key, was ${keyType}`);
+    }
+    privateSection.readString();
+    // OpenSSH stores the seed and the public key together in the private field.
+    let privateValue = privateSection.readString();
+    if (privateValue.length !== SEED_LENGTH + PUBLIC_LENGTH) {
+        throw new Error(`Expected a ${SEED_LENGTH + PUBLIC_LENGTH} byte private value, was ${privateValue.length}`);
+    }
+    return {
+        seed: privateValue.subarray(0, SEED_LENGTH),
+        publicKey: privateValue.subarray(SEED_LENGTH),
+        comment: privateSection.readString().toString(),
+    };
+}
+
+export function formatOpenSSHPrivateKey(config: { seed: Buffer; comment: string }) {
+    let { seed, comment } = config;
+    let publicKey = publicKeyFromSeed(seed);
+    let publicBlob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);
+
+    // The check value only proves a passphrase decrypted correctly, and nothing here is encrypted.
+    // Taking it from the seed keeps the same input producing the same file, so deriving a key twice
+    // is something you can compare rather than something that looks different every time.
+    let check = crypto.createHash("sha256").update(seed).digest().readUInt32BE(0);
+    let privateSection = Buffer.concat([
+        writeUInt32(check),
+        writeUInt32(check),
+        writeString(KEY_TYPE),
+        writeString(publicKey),
+        writeString(Buffer.concat([seed, publicKey])),
+        writeString(comment),
+    ]);
+    let paddingLength = (PADDING_BLOCK - privateSection.length % PADDING_BLOCK) % PADDING_BLOCK;
+    let padding = Buffer.from(Array.from({ length: paddingLength }, (unused, index) => index + 1));
+
+    let contents = Buffer.concat([
+        Buffer.from(MAGIC),
+        writeString(NONE),
+        writeString(NONE),
+        writeString(""),
+        writeUInt32(1),
+        writeString(publicBlob),
+        writeString(Buffer.concat([privateSection, padding])),
+    ]);
+    let encoded = contents.toString("base64").match(new RegExp(`.{1,${PEM_LINE_LENGTH}}`, "g")) || [];
+    return `${PRIVATE_HEADER}\n${encoded.join("\n")}\n${PRIVATE_FOOTER}\n`;
+}
+
+/** The single line form, as it appears in authorized_keys and in a .pub file. */
+export function formatPublicKeyLine(config: { publicKey: Buffer; comment: string }) {
+    let { publicKey, comment } = config;
+    let blob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);
+    return `${KEY_TYPE} ${blob.toString("base64")}${comment && ` ${comment}` || ""}\n`;
+}

package/security/notifications/discord.ts

@@ -72,8 +72,25 @@ async function readWebhookFile(filePath: string) {
     return parseWebhookFile({ contents, sourceName: filePath });
 }
 
+/** When the message was sent, in the sending machine's own time zone. Discord shows when it
+    received something, which is not the same thing when a machine has been offline or a send has
+    been retried, and the zone matters when the machines are not all in one place. */
+export function messageTimestamp(now: Date) {
+    let date = now.toLocaleDateString("en-CA");
+    let time = now.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: true,
+        timeZoneName: "short",
+    });
+    return `${date} ${time}`;
+}
+
 async function postToWebhook(webhookURL: string, message: string) {
-    let content = message;
+    // Stamped once rather than per attempt, so a retry says when the thing happened rather than
+    // when we last managed to get it out.
+    let content = `\`${messageTimestamp(new Date())}\` ${message}`;
     if (content.length > DISCORD_MESSAGE_LIMIT) {
         content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
     }

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

@@ -0,0 +1,197 @@
+"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.messageTimestamp = 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 });
+}
+/** When the message was sent, in the sending machine's own time zone. Discord shows when it
+    received something, which is not the same thing when a machine has been offline or a send has
+    been retried, and the zone matters when the machines are not all in one place. */
+function messageTimestamp(now) {
+    let date = now.toLocaleDateString("en-CA");
+    let time = now.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: true,
+        timeZoneName: "short",
+    });
+    return `${date} ${time}`;
+}
+exports.messageTimestamp = messageTimestamp;
+async function postToWebhook(webhookURL, message) {
+    // Stamped once rather than per attempt, so a retry says when the thing happened rather than
+    // when we last managed to get it out.
+    let content = `\`${messageTimestamp(new Date())}\` ${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\n/** When the message was sent, in the sending machine's own time zone. Discord shows when it\n    received something, which is not the same thing when a machine has been offline or a send has\n    been retried, and the zone matters when the machines are not all in one place. */\nexport function messageTimestamp(now: Date) {\n    let date = now.toLocaleDateString(\"en-CA\");\n    let time = now.toLocaleTimeString(\"en-US\", {\n        hour: \"2-digit\",\n        minute: \"2-digit\",\n        second: \"2-digit\",\n        hour12: true,\n        timeZoneName: \"short\",\n    });\n    return `${date} ${time}`;\n}\n\nasync function postToWebhook(webhookURL: string, message: string) {\n    // Stamped once rather than per attempt, so a retry says when the thing happened rather than\n    // when we last managed to get it out.\n    let content = `\\`${messageTimestamp(new Date())}\\` ${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 = "be450922cec9e8a268e2a78f817bfedb88063a0b59db5b1a954d81c96169543a"; */

package/security/notifications/setupNotify.ts

@@ -1,16 +1,25 @@
 import { parseWebhookFile } from "./discord";
 import { ensureRemoteWebhook, REPLACE_KEYWORD } from "./remoteWebhook";
+import { describeHost, THIS_MACHINE } from "../helpers/remoteSSH";
 
-const USAGE = `Usage: yarn setupnotify <host> <discord-webhook-url> [${REPLACE_KEYWORD}]`;
+const USAGE = `Usage: yarn setupnotify [host] <discord-webhook-url> [${REPLACE_KEYWORD}]
+
+With no host it sets the webhook up on this machine.`;
 
 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}`);
+    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}`
+        );
     }
-    let [host, webhookURL] = positional;
-    // Validates the URL shape up front, so we never ssh anywhere with a bad webhook.
+    // 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] || THIS_MACHINE;
+    // Validates the URL shape up front, so we never go anywhere with a bad webhook.
     parseWebhookFile({ contents: webhookURL, sourceName: "the command line" });
     return { host, webhookURL, replace };
 }
@@ -19,11 +28,11 @@ 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.`);
+        console.log(`${describeHost(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(`Replaced the webhook on ${describeHost(host)} and notified the old one.`);
     }
-    console.log(`Wrote ${filePath} on ${host} (mode 600), and confirmed on the new webhook.`);
+    console.log(`Wrote ${filePath} on ${describeHost(host)} (mode 600), and confirmed on the new webhook.`);
 }

package/security/notifications/testNotify.ts

@@ -0,0 +1,48 @@
+import fs from "fs/promises";
+import os from "os";
+import { DEFAULT_WEBHOOK_FILE_PATH, parseWebhookFile, sendToWebhookURL } from "./discord";
+import { readRemoteFile } from "../helpers/remoteSSH";
+
+const USAGE = `Usage: yarn testnotify [host]
+
+Sends one message to a webhook, to prove it works. With no host it uses this machine's webhook at
+${DEFAULT_WEBHOOK_FILE_PATH}. With a host it reads that host's webhook and sends to that instead,
+which is how you check a machine you have just set up.`;
+
+export async function main() {
+    let argv = process.argv.slice(2);
+    if (argv.length > 1) {
+        throw new Error(`Expected at most a host, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let host = argv[0];
+
+    let contents: string | undefined;
+    if (host) {
+        contents = await readRemoteFile({ host, filePath: DEFAULT_WEBHOOK_FILE_PATH });
+        if (!contents) {
+            throw new Error(
+                `Expected a webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on ${host}, no such file exists.\n`
+                + `Set it up with:\n  yarn setupnotify ${host} <discord-webhook-url>`
+            );
+        }
+    } else {
+        try {
+            contents = await fs.readFile(DEFAULT_WEBHOOK_FILE_PATH, "utf8");
+        } catch (e) {
+            throw new Error(
+                `Expected a webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on this machine, ${e}\n`
+                + `Name a host to use that host's webhook instead.\n${USAGE}`
+            );
+        }
+    }
+
+    let source = host || os.hostname();
+    let webhookURL = parseWebhookFile({ contents, sourceName: `${source}:${DEFAULT_WEBHOOK_FILE_PATH}` });
+    // Said plainly, so nobody reading the channel later has to work out whether it was real.
+    await sendToWebhookURL({
+        webhookURL,
+        message: `**portsecure test**: this is a test message, nothing has happened.`
+            + ` Sent with \`yarn testnotify\` for the webhook \`${source}\` uses.`,
+    });
+    console.log(`Sent a test message to the webhook ${source} uses.`);
+}

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

@@ -0,0 +1,85 @@
+"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: what is in the index, plus what is not staged yet.
+    Git is asked because git is what knows how to apply the ignore rules.
+
+    What comes back is a hint that a file might be there, not that it is. A file deleted from the
+    working tree stays in the index until that deletion is staged, so git names it and there is
+    nothing to read, which is why each one is checked before it goes in.
+
+    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()}`);
+    }
+    let listed = result.stdout.split("\n")
+        .map(line => line.trim())
+        .filter(line => line && line !== exports.MANIFEST_NAME && line !== exports.SIGNATURE_NAME)
+        .sort();
+    let present = [];
+    for (let relativePath of listed) {
+        try {
+            await promises_1.default.access(path_1.default.join(repoPath, relativePath));
+            present.push(relativePath);
+        }
+        catch (e) {
+            console.log(`Leaving ${relativePath} out of the manifest, it is gone from the working tree`);
+        }
+    }
+    return present;
+}
+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,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["manifest.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport { spawnPromise } from \"../helpers/spawn\";\n\n// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js contains a plain JS port of the\n// verifying half of this file, so it can check a signature with no dependencies. Both sides must\n// agree on the manifest shape and on which files it covers - if you change one, make the matching\n// change in the other.\n\nexport const MANIFEST_NAME = \"signedfiles.json\";\nexport const SIGNATURE_NAME = \"signedfiles.json.sig\";\n// ssh signatures are namespaced, so a signature made for one purpose cannot be replayed as another.\nexport const SIGN_NAMESPACE = \"signfiles\";\nexport const MANIFEST_VERSION = 1;\n\nexport type Manifest = {\n    version: number;\n    files: { path: string; size: number; sha256: string }[];\n};\n\n/** Everything in the repo that is not ignored: what is in the index, plus what is not staged yet.\n    Git is asked because git is what knows how to apply the ignore rules.\n\n    What comes back is a hint that a file might be there, not that it is. A file deleted from the\n    working tree stays in the index until that deletion is staged, so git names it and there is\n    nothing to read, which is why each one is checked before it goes in.\n\n    The manifest and its signature are left out, since they cannot describe themselves. */\nexport async function listRepoFiles(repoPath: string) {\n    let result = await spawnPromise({\n        command: \"git\",\n        args: [\"ls-files\", \"--cached\", \"--others\", \"--exclude-standard\"],\n        cwd: repoPath,\n    });\n    if (result.status !== 0) {\n        throw new Error(\n            `Expected to list the files in ${repoPath}, git ls-files exited ${result.status}. `\n            + `${(result.stdout + result.stderr).trim()}`\n        );\n    }\n    let listed = result.stdout.split(\"\\n\")\n        .map(line => line.trim())\n        .filter(line => line && line !== MANIFEST_NAME && line !== SIGNATURE_NAME)\n        .sort();\n\n    let present: string[] = [];\n    for (let relativePath of listed) {\n        try {\n            await fs.access(path.join(repoPath, relativePath));\n            present.push(relativePath);\n        } catch (e) {\n            console.log(`Leaving ${relativePath} out of the manifest, it is gone from the working tree`);\n        }\n    }\n    return present;\n}\n\n/** A Windows checkout turns LF into CRLF, so the same commit hashes differently there than it\n    does on the machine that pulls it. Normalising first makes the digest describe the content\n    rather than whichever checkout produced it. latin1 round trips every byte, so this is safe on\n    files that are not text. */\nexport function normalizeContent(contents: Buffer) {\n    return Buffer.from(contents.toString(\"latin1\").replace(/\\r\\n/g, \"\\n\"), \"latin1\");\n}\n\n/** The size and hash of a file's normalised content. The size is the normalised one on purpose,\n    so it agrees with the hash rather than with whatever the local checkout happens to hold. */\nexport async function digestFile(filePath: string) {\n    let contents = normalizeContent(await fs.readFile(filePath));\n    return { size: contents.length, sha256: crypto.createHash(\"sha256\").update(contents).digest(\"hex\") };\n}\n\nexport async function buildManifest(repoPath: string) {\n    let files: Manifest[\"files\"] = [];\n    for (let relativePath of await listRepoFiles(repoPath)) {\n        let digest = await digestFile(path.join(repoPath, relativePath));\n        files.push({ path: relativePath, size: digest.size, sha256: digest.sha256 });\n    }\n    return { version: MANIFEST_VERSION, files };\n}\n\n/** Sorted keys and a trailing newline, so the same tree always produces the same bytes to sign. */\nexport function formatManifest(manifest: Manifest) {\n    return JSON.stringify(manifest, undefined, 4) + \"\\n\";\n}\n"]}
+ /* _JS_SOURCE_HASH = "e58787cb53d84ba9647f11c90c737f7303e120b8e02ca37cc9f38202fce1929d"; */