sliftutils 1.7.124 → 1.7.126

package/security/keys/dist/sshKeyFile.ts.cache

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

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

@@ -0,0 +1,190 @@
+import fs from "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.
+
+export const 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: {
+    filePath: string;
+    webhookURL: string;
+    checkTimer: NodeJS.Timeout;
+} | undefined;
+
+// Discord webhooks are rate limited (roughly 5 requests per 2 seconds), so every send
+// goes through one chain instead of racing.
+let sendChain: Promise<unknown> = Promise.resolve();
+
+/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so
+    callers can name a remote path. */
+export function parseWebhookFile(config: { contents: string; sourceName: string }) {
+    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;
+}
+
+/** 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. */
+export function redactWebhookURL(webhookURL: string) {
+    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)}`;
+}
+
+export function formatWebhookFile(webhookURL: string) {
+    return `# portsecure Discord webhook. First non-comment line is used.\n${webhookURL}\n`;
+}
+
+async function readWebhookFile(filePath: string) {
+    let contents;
+    try {
+        contents = await fs.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: string, message: string) {
+    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: string, message: string) {
+    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. */
+export function sendToWebhookURL(config: { webhookURL: string; message: string }) {
+    return queueSend(config.webhookURL, config.message);
+}
+
+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. */
+export async function configureDiscordNotifications(config?: {
+    filePath?: string;
+    checkInterval?: number;
+}) {
+    if (notificationState) {
+        throw new Error(`Expected configureDiscordNotifications to be called once, was called again (already using ${notificationState.filePath})`);
+    }
+    let filePath = config?.filePath || DEFAULT_WEBHOOK_FILE_PATH;
+    let checkInterval = 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 };
+}
+
+// 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.
+export async function sendDiscordNotification(message: string) {
+    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);
+}
+
+export function stopDiscordNotifications() {
+    if (!notificationState) {
+        return;
+    }
+    clearInterval(notificationState.checkTimer);
+    notificationState = undefined;
+}