sliftutils 1.7.129 → 1.7.131

package/security/machines/machines.d.ts

@@ -0,0 +1,81 @@
+export declare const MACHINES_DIR = "machines";
+/** One machine we are willing to talk to, and the addresses it may talk to us from. */
+export type MachineState = {
+    machineId: string;
+    ips: string[];
+    addedAt: string;
+};
+/** This machine's keys repo, worked out once and then remembered.
+
+    A failure is remembered too, but only briefly: a server may well start before the machine has
+    been set up, and should start working when it is, rather than needing a restart. */
+export declare const keysRepo: {
+    (): Promise<{
+        repoPath: string;
+        sourceURL: string;
+    }>;
+    reset(): void;
+    set(newValue: Promise<{
+        repoPath: string;
+        sourceURL: string;
+    }>): void;
+};
+/** Every machine a checkout lists. Without a repo, this machine's own. */
+export declare function getMachines(repoPath?: string): Promise<MachineState[]>;
+/** The machines this system trusts, as the signed repo lists them.
+
+    Held rather than read per call, and refreshed in the background, so nobody asking whether a
+    machine is trusted waits for a directory of files to be read and a signature to be checked. A
+    refresh that fails leaves the list we already have: the checkout is only stale, not wrong. */
+export declare function getTrustedMachines(): Promise<MachineState[]>;
+/** Makes a checkout list exactly these machines: those named are written with the addresses given,
+    and anything not named is removed. So read them, change what you want, and write the result.
+
+    The addresses are part of setting rather than a separate step, because a machine with no
+    address it may talk from is not a machine that would ever be accepted - there is no state where
+    naming one without them means anything.
+
+    Nothing here signs or commits. The signature is what every other machine checks before
+    believing any of this, and it takes the hardware key, so `yarn signfiles git` is still yours to
+    run afterwards. */
+export declare function setMachines(config: {
+    repoPath?: string;
+    machines: {
+        machineId: string;
+        ips: string[];
+    }[];
+}): Promise<MachineState[]>;
+/** What to run to trust a machine that has just been refused.
+
+    Everything in it is already known to whoever is being refused: their machine id, the address we
+    saw them at, and the domain they just talked to. Handing it back saves them working out the
+    parts of a command they have every right to know. Running it still takes the hardware key on
+    the machine that owns the repo, so telling them costs nothing. */
+export declare function addMachineCommand(config: {
+    machineId: string;
+    ip: string;
+    domain?: string;
+}): string;
+/** Whether we will talk to this machine, coming from this address.
+
+    Both halves are required and neither is a guess: the caller knows the machine id because the
+    connection proved it, and knows the address because the packets came from there. A machine we
+    do not list is simply not accepted. A machine we do list, arriving from an address it does not
+    have, is treated as the same kind of event as a stolen ssh key - it is revoked everywhere, and
+    stays revoked until an unrevoke allows that machine from that address.
+
+    Says why when the answer is no, because the three ways to be refused are entirely different
+    things to a person reading it: never trusted at all, trusted but frozen, or trusted and talking
+    from somewhere it should not be.
+
+    Throws when the repo itself cannot be read or is not signed, rather than answering false: that
+    is a broken installation, not a rejected machine, and the two deserve different handling. */
+export type MachineVerdict = {
+    accepted: boolean;
+    reason: string;
+};
+export declare function isMachineAccepted(config: {
+    machineId: string;
+    ip: string;
+    domain?: string;
+}): Promise<MachineVerdict>;

package/security/machines/machines.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import { CONFIG_PATH } from "../authorizedKeys/daemon/paths";
+import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { revokeRepo, syncRepoFiles } from "../authorizedKeys/daemon/repoFiles";
 import { listRepoDir, readRepoFile } from "../authorizedKeys/daemon/repoFiles";
 import { newRevocationId, pairKey, readRevocationFiles, readUnrevokes } from "../authorizedKeys/daemon/revocation";
@@ -9,10 +9,10 @@ import { runGit } from "../authorizedKeys/daemon/git";
 import { ensureRevokeKey } from "../authorizedKeys/daemon/repoFiles";
 import { verifyCheckout } from "../authorizedKeys/daemon/trust";
 import { revokeRepoPath, revokeRepoURL } from "../authorizedKeys/revokeSource";
-import { sourceRepoPath } from "../authorizedKeys/sources";
 import { notify } from "../authorizedKeys/daemon/notify";
 import { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from "../notifications/discord";
-import { unrevokeInEffect } from "./trustState";
+import { lazy } from "socket-function/src/caching";
+import { runInfinitePoll } from "socket-function/src/batching";
 import { spawnPromise } from "../helpers/spawn";
 
 // Which machines this system talks to, kept in the same repo as the ssh keys. That repo is already
@@ -24,9 +24,14 @@ const REVOCATION_REASON = "a machine talked to us from an unapproved IP";
 // The revoke repo is pulled at most this often. A check happens per request, and a request must
 // not cost a round trip to github.
 const REVOKE_SYNC_INTERVAL = 60 * 1000;
-// Where a Windows machine is expected to keep the repo, relative to the working directory. There
-// is no daemon there to ask, and no /etc to look in.
-const WINDOWS_REPO_PATH = "../authorized_keys";
+// And the machine list is re-read from the checkout on this interval, in the background. The
+// checkout itself only moves when the daemon pulls it, which is on the same sort of interval, so
+// reading more often than this would only re-read the same bytes.
+const MACHINES_REFRESH_INTERVAL = 60 * 1000;
+// How long a failure to find the keys repo is remembered. A long lived process may start before
+// the machine is set up, and should pick it up once it is, without being restarted - but it must
+// not pay for resolving the repo on every request either.
+const REPO_RETRY_DELAY = 15 * 1000;
 
 /** One machine we are willing to talk to, and the addresses it may talk to us from. */
 export type MachineState = {
@@ -48,27 +53,78 @@ function machineFilePath(repoPath: string, machineId: string) {
     return path.join(repoPath, MACHINES_DIR, `${machineId}.json`);
 }
 
-/** Reads every machine a checkout lists, or sets them.
+/** This machine's keys repo, worked out once and then remembered.
 
-    Passing `machines` makes the repo match it exactly: machines named are written with the
-    addresses given, and machines not named are removed. That is why the addresses are part of
-    setting rather than a separate step - a machine with no address it may talk from is not a
-    machine we would accept anyway, so there is no state where naming one without them means
-    anything. Read first, change what you want, write the result.
+    A failure is remembered too, but only briefly: a server may well start before the machine has
+    been set up, and should start working when it is, rather than needing a restart. */
+export const keysRepo = lazy(async () => {
+    let lookup = resolveKeysRepo();
+    lookup.catch(() => {
+        setTimeout(() => keysRepo.reset(), REPO_RETRY_DELAY).unref();
+    });
+    return await lookup;
+});
+
+/** Every machine a checkout lists. Without a repo, this machine's own. */
+export async function getMachines(repoPath?: string): Promise<MachineState[]> {
+    return [...(await readMachines(repoPath || (await keysRepo()).repoPath)).values()];
+}
+
+/** Reads the machine list, once its signature has been checked. An unsigned machine list, or one
+    signed over different contents, is not evidence of anything, so this throws rather than
+    quietly trusting nobody. */
+async function readTrustedMachines() {
+    let { repoPath } = await keysRepo();
+    await verifyCheckout(repoPath);
+    return await getMachines(repoPath);
+}
 
-    Nothing here signs or commits anything. The signature is what every other machine checks before
+const trustedMachines = lazy(async () => {
+    let read = readTrustedMachines();
+    read.catch(() => trustedMachines.reset());
+    return await read;
+});
+
+let refreshing = false;
+
+/** The machines this system trusts, as the signed repo lists them.
+
+    Held rather than read per call, and refreshed in the background, so nobody asking whether a
+    machine is trusted waits for a directory of files to be read and a signature to be checked. A
+    refresh that fails leaves the list we already have: the checkout is only stale, not wrong. */
+export async function getTrustedMachines(): Promise<MachineState[]> {
+    if (!refreshing) {
+        refreshing = true;
+        runInfinitePoll(MACHINES_REFRESH_INTERVAL, async () => {
+            try {
+                trustedMachines.set(Promise.resolve(await readTrustedMachines()));
+            } catch (e) {
+                console.log(`Could not re-read the trusted machines, keeping the ones we have. ${e}`);
+            }
+        });
+    }
+    return await trustedMachines();
+}
+
+/** Makes a checkout list exactly these machines: those named are written with the addresses given,
+    and anything not named is removed. So read them, change what you want, and write the result.
+
+    The addresses are part of setting rather than a separate step, because a machine with no
+    address it may talk from is not a machine that would ever be accepted - there is no state where
+    naming one without them means anything.
+
+    Nothing here signs or commits. The signature is what every other machine checks before
     believing any of this, and it takes the hardware key, so `yarn signfiles git` is still yours to
     run afterwards. */
-export async function machineState(config: {
-    repoPath: string;
-    machines?: { machineId: string; ips: string[] }[];
+export async function setMachines(config: {
+    repoPath?: string;
+    machines: { machineId: string; ips: string[] }[];
 }): Promise<MachineState[]> {
-    let { repoPath, machines } = config;
+    let { machines } = config;
+    let repoPath = config.repoPath || (await keysRepo()).repoPath;
+    // Whatever was held is now stale, whoever reads it next.
+    trustedMachines.reset();
     let existing = await readMachines(repoPath);
-    if (!machines) {
-        return [...existing.values()];
-    }
-
     let directory = path.join(repoPath, MACHINES_DIR);
     let written: MachineState[] = [];
     for (let machine of machines) {
@@ -122,61 +178,6 @@ async function readMachines(repoPath: string) {
     return machines;
 }
 
-async function isKeysRepo(repoPath: string) {
-    return await pathExists(path.join(repoPath, ".git"))
-        && await pathExists(path.join(repoPath, "authorized_keys"));
-}
-
-async function originOf(repoPath: string) {
-    let origin = await spawnPromise({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
-    let url = origin.stdout.trim();
-    if (origin.status !== 0 || !url) {
-        throw new Error(`Expected ${repoPath} to have an origin remote, it has none`);
-    }
-    return url;
-}
-
-/** The keys repo this machine answers from, and the one anything editing the machine list edits.
-
-    On a host, that is the checkout the daemon already keeps up to date. On Windows there is no
-    daemon and no /etc, so the repo is expected beside the working directory, which is where a
-    developer working on both would have it.
-
-    Never the directory the command happens to be run from. Which repo this machine trusts is a
-    property of the machine, not of where somebody was standing when they typed something. */
-export async function resolveKeysRepo() {
-    if (os.platform() === "win32") {
-        let repoPath = path.resolve(WINDOWS_REPO_PATH);
-        if (!await isKeysRepo(repoPath)) {
-            throw new Error(
-                `Expected ${repoPath} to be an authorized_keys repo, it is not.\n`
-                + `On Windows the repo is read from there, so clone it beside this one:\n`
-                + `  git clone <your authorized_keys repo> ${repoPath}`
-            );
-        }
-        return { repoPath, sourceURL: await originOf(repoPath) };
-    }
-
-    let config = await fs.readFile(CONFIG_PATH, "utf8").catch(() => "");
-    let sourceURL = config && (JSON.parse(config).repoSources || [])[0] || "";
-    if (!sourceURL) {
-        throw new Error(
-            `Expected this machine to be set up with an authorized_keys repo, ${CONFIG_PATH} names none.\n`
-            + `Set it up first:\n`
-            + `  yarn setupnotify <discord-webhook-url>\n`
-            + `  yarn securessh add <repo-private-key> <repo-url>`
-        );
-    }
-    let repoPath = sourceRepoPath(sourceURL);
-    if (!await isKeysRepo(repoPath)) {
-        throw new Error(
-            `Expected a checkout of ${sourceURL} at ${repoPath}, there is none.\n`
-            + `Run \`yarn securessh update\` to put it back.`
-        );
-    }
-    return { repoPath, sourceURL };
-}
-
 let lastRevokeSync = 0;
 
 /** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that
@@ -218,6 +219,17 @@ async function readMachineRevocations(sourceURL: string) {
     return revocations;
 }
 
+/** What to run to trust a machine that has just been refused.
+
+    Everything in it is already known to whoever is being refused: their machine id, the address we
+    saw them at, and the domain they just talked to. Handing it back saves them working out the
+    parts of a command they have every right to know. Running it still takes the hardware key on
+    the machine that owns the repo, so telling them costs nothing. */
+export function addMachineCommand(config: { machineId: string; ip: string; domain?: string }) {
+    let { machineId, ip, domain } = config;
+    return `To trust it, run: yarn addmachine ${domain || "<domain>"} ${machineId} ${ip} git`;
+}
+
 /** Sends the one notification this file is allowed to send, when it can.
 
     The daemon configures notifications on startup and would simply send. This can also run in some
@@ -285,7 +297,7 @@ async function recordMachineRevocation(config: {
         + `\n\nIt is frozen everywhere now, and nothing accepts it.`
         + `\n\nIf this was an attack, remove \`machines/${machineId}.json\` from \`${sourceURL}\` now.`
         + `\nIf it was legitimate, run \`yarn unrevoke git\` in that repo. It allows ${ip} for that`
-        + ` machine, and takes an hour to reach every machine.`
+        + ` machine, and takes effect as each machine picks it up.`
         + `\n\nmachine: \`${machineId}\``
         + `\nfrozen by: \`${hostLabel}\``
     );
@@ -299,48 +311,59 @@ async function recordMachineRevocation(config: {
     have, is treated as the same kind of event as a stolen ssh key - it is revoked everywhere, and
     stays revoked until an unrevoke allows that machine from that address.
 
+    Says why when the answer is no, because the three ways to be refused are entirely different
+    things to a person reading it: never trusted at all, trusted but frozen, or trusted and talking
+    from somewhere it should not be.
+
     Throws when the repo itself cannot be read or is not signed, rather than answering false: that
     is a broken installation, not a rejected machine, and the two deserve different handling. */
-export async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<boolean> {
-    let { machineId, ip } = config;
+export type MachineVerdict = { accepted: boolean; reason: string };
+
+export async function isMachineAccepted(config: {
+    machineId: string;
+    ip: string;
+    // Only used to write a complete command into the refusal. A caller that knows which domain it
+    // is answering as saves whoever is refused from having to guess it.
+    domain?: string;
+}): Promise<MachineVerdict> {
+    let { machineId, ip, domain } = config;
     if (!machineId || !ip) {
         throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);
     }
-    let { repoPath, sourceURL } = await resolveKeysRepo();
-    // Unsigned, or signed over different contents, means the machine list is not evidence of
-    // anything. Same gate the ssh keys go through.
-    await verifyCheckout(repoPath);
-
-    let machine = (await readMachines(repoPath)).get(machineId);
+    let { sourceURL } = await keysRepo();
+    // Verified before it is believed, and cached, since this is asked once per request.
+    let machine = (await getTrustedMachines()).find(entry => entry.machineId === machineId);
     if (!machine) {
-        return false;
+        return { accepted: false, reason: `that machine is not trusted. ${addMachineCommand({ machineId, ip, domain })}` };
     }
 
     await syncRevocations(sourceURL);
     let unrevokes = await readUnrevokes(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
-    // An unrevoke is only honoured once it has waited out its hour, exactly as an ssh key's is.
-    let allowedAgain = async (pair: string) => {
-        let unrevokeId = unrevokes.pairs.get(pair);
-        return !!unrevokeId && await unrevokeInEffect(unrevokeId);
-    };
+    // An unrevoke counts as soon as it is seen. It is signed, so writing one already takes the
+    // hardware key, and anyone holding that can sign anything at all - a wait before honouring it
+    // guards against an attacker who has no need of it.
+    let allowedAgain = (pair: string) => !!unrevokes.pairs.get(pair)?.length;
     let revocations = await readMachineRevocations(sourceURL);
     // Any revocation nothing has undone keeps the machine out, from everywhere, the way a revoked
     // ssh key is out everywhere rather than only from the address it was misused from.
-    let revoked = false;
+    let frozenFrom = "";
     for (let revocation of revocations) {
         if (revocation.machineId !== machineId) {
             continue;
         }
-        if (!await allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
-            revoked = true;
+        if (!allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
+            frozenFrom = revocation.ip;
         }
     }
-    if (revoked) {
-        return false;
+    if (frozenFrom) {
+        return {
+            accepted: false,
+            reason: `that machine is frozen, it was used from ${frozenFrom} which it is not allowed from`,
+        };
     }
 
     if (machine.ips.includes(ip)) {
-        return true;
+        return { accepted: true, reason: "" };
     }
 
     // Listed, but talking to us from somewhere it should not be. Recorded once for this machine
@@ -348,8 +371,9 @@ export async function isMachineAccepted(config: { machineId: string; ip: string
     let pair = pairKey({ fingerprint: machineId, ip });
     let alreadyRecorded = revocations.some(revocation =>
         pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }) === pair);
-    if (!alreadyRecorded && !await allowedAgain(pair)) {
+    if (!alreadyRecorded && !allowedAgain(pair)) {
         await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os.hostname() });
+        return { accepted: false, reason: `that machine is not allowed from ${ip}, so it is now frozen everywhere` };
     }
-    return false;
+    return { accepted: false, reason: `that machine is not allowed from ${ip}` };
 }

package/security/machines/trustServer.ts

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

package/security/notifications/discord.d.ts

@@ -0,0 +1,36 @@
+export declare const DEFAULT_WEBHOOK_FILE_PATH = "/etc/portsecure/discord-webhook";
+/** Pulls the webhook URL out of webhook file contents. `sourceName` only appears in errors, so
+    callers can name a remote path. */
+export declare function parseWebhookFile(config: {
+    contents: string;
+    sourceName: string;
+}): string;
+/** 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 declare function redactWebhookURL(webhookURL: string): string;
+export declare function formatWebhookFile(webhookURL: string): string;
+/** 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 declare function messageTimestamp(now: Date): string;
+/** Sends to an explicit webhook URL, for tooling that acts on a webhook before (or instead of)
+    configureDiscordNotifications - setup, migrations, connectivity checks. */
+export declare function sendToWebhookURL(config: {
+    webhookURL: string;
+    message: string;
+}): Promise<void>;
+/** 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 declare function configureDiscordNotifications(config?: {
+    filePath?: string;
+    checkInterval?: number;
+}): Promise<{
+    filePath: string;
+    checkInterval: number;
+}>;
+export declare function sendDiscordNotification(message: string): Promise<void>;
+/** Whether notifications are set up in this process. For code that may run outside the daemon,
+    where sending is worth doing if it can be and not worth failing over if it cannot. */
+export declare function areDiscordNotificationsConfigured(): boolean;
+export declare function stopDiscordNotifications(): void;

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

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
@@ -203,4 +203,4 @@ function stopDiscordNotifications() {
 }
 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. At the end, because the first line of a message is the\n    // notification preview and a timestamp there would spend it saying nothing.\n    let content = `${message} · \\`${messageTimestamp(new Date())}\\``;\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**: **NOTIFICATIONS ARE MOVING TO ANOTHER CHANNEL**`\n            + `\\n\\nThis channel stops receiving them now. If that was not you, somebody with access`\n            + ` to this machine just redirected its alerts.`\n            + `\\n\\nnew webhook: \\`${redactWebhookURL(newWebhookURL)}\\``\n            + `\\nset in: \\`${state.filePath}\\``\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\n/** Whether notifications are set up in this process. For code that may run outside the daemon,\n    where sending is worth doing if it can be and not worth failing over if it cannot. */\nexport function areDiscordNotificationsConfigured() {\n    return !!notificationState;\n}\n\nexport function stopDiscordNotifications() {\n    if (!notificationState) {\n        return;\n    }\n    clearInterval(notificationState.checkTimer);\n    notificationState = undefined;\n}\n"]}
- /* _JS_SOURCE_HASH = "abb6e0b243d1d85cb4a3599020263d0b3164ce4bf2aef2aa81489e304cd43b4c"; */
+ /* _JS_SOURCE_HASH = "a4fe18f537fa6da028d1607b16331b146697f9fabb96c6de058f0b41c5553b17"; */

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ensureRemoteWebhook = exports.REPLACE_KEYWORD = void 0;
+const discord_1 = require("./discord");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+exports.REPLACE_KEYWORD = "replace";
+const UNPARSEABLE_LABEL = "(unparseable)";
+/** Puts a webhook on a remote host, refusing to clobber a different existing one unless asked.
+    Returns what happened, so callers can decide whether to keep going. */
+async function ensureRemoteWebhook(config) {
+    let { host, webhookURL, replace } = config;
+    let filePath = config.filePath || discord_1.DEFAULT_WEBHOOK_FILE_PATH;
+    let replacedURL = "";
+    let existingContents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath });
+    if (existingContents) {
+        // A corrupt existing file still counts as a conflict, so "replace" can repair it instead
+        // of the setup dead ending on a parse error.
+        let existingURL = UNPARSEABLE_LABEL;
+        try {
+            existingURL = (0, discord_1.parseWebhookFile)({ contents: existingContents, sourceName: `${host}:${filePath}` });
+        }
+        catch (e) {
+            console.error(`${host}:${filePath} exists but could not be parsed. ${e}`);
+        }
+        if (existingURL === webhookURL) {
+            return { outcome: "unchanged", filePath };
+        }
+        if (!replace) {
+            throw new Error(`Expected no conflicting webhook on ${host}, but ${filePath} already holds a different one.\n`
+                + `Existing: ${existingURL}\n`
+                + `New:      ${webhookURL}\n`
+                + `Pass "${exports.REPLACE_KEYWORD}" to overwrite it.`);
+        }
+        replacedURL = existingURL;
+    }
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath,
+        contents: (0, discord_1.formatWebhookFile)(webhookURL),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    let writtenContents = await (0, remoteSSH_1.readRemoteFile)({ host, filePath });
+    if (!writtenContents) {
+        throw new Error(`Expected ${filePath} to exist on ${host} after writing, no such file exists`);
+    }
+    let writtenURL = (0, discord_1.parseWebhookFile)({ contents: writtenContents, sourceName: `${host}:${filePath}` });
+    if (writtenURL !== webhookURL) {
+        throw new Error(`Expected ${host}:${filePath} to hold the new webhook, was ${writtenURL}`);
+    }
+    if (replacedURL && replacedURL !== UNPARSEABLE_LABEL) {
+        // The new webhook is redacted, so this channel can identify the replacement without
+        // receiving a webhook it could post to.
+        try {
+            await (0, discord_1.sendToWebhookURL)({
+                webhookURL: replacedURL,
+                message: `**portsecure**: the Discord webhook for \`${host}\` was replaced with`
+                    + ` \`${(0, discord_1.redactWebhookURL)(webhookURL)}\`.`
+                    + ` This channel will stop receiving notifications for that host.`,
+            });
+        }
+        catch (e) {
+            // The replacement already happened, so a dead old webhook must not fail the setup.
+            console.error(`Could not notify the old webhook that it was replaced. ${e}`);
+        }
+    }
+    // Failing here means the file is in place but the webhook itself does not work, which is
+    // exactly what the operator needs to hear about.
+    await (0, discord_1.sendToWebhookURL)({
+        webhookURL,
+        message: `**portsecure**: notifications are now configured for \`${host}\`.`
+            + ` This channel will receive its security notifications.`,
+    });
+    return { outcome: replacedURL && "replaced" || "created", filePath };
+}
+exports.ensureRemoteWebhook = ensureRemoteWebhook;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteWebhook.js","sourceRoot":"","sources":["remoteWebhook.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEFAULT_WEBHOOK_FILE_PATH, formatWebhookFile, parseWebhookFile, redactWebhookURL, sendToWebhookURL } from \"./discord\";\nimport { readRemoteFile, writeRemoteFile } from \"../helpers/remoteSSH\";\n\nexport const REPLACE_KEYWORD = \"replace\";\nconst UNPARSEABLE_LABEL = \"(unparseable)\";\n\n/** Puts a webhook on a remote host, refusing to clobber a different existing one unless asked.\n    Returns what happened, so callers can decide whether to keep going. */\nexport async function ensureRemoteWebhook(config: {\n    host: string;\n    webhookURL: string;\n    replace: boolean;\n    filePath?: string;\n}) {\n    let { host, webhookURL, replace } = config;\n    let filePath = config.filePath || DEFAULT_WEBHOOK_FILE_PATH;\n\n    let replacedURL = \"\";\n    let existingContents = await readRemoteFile({ host, filePath });\n    if (existingContents) {\n        // A corrupt existing file still counts as a conflict, so \"replace\" can repair it instead\n        // of the setup dead ending on a parse error.\n        let existingURL = UNPARSEABLE_LABEL;\n        try {\n            existingURL = parseWebhookFile({ contents: existingContents, sourceName: `${host}:${filePath}` });\n        } catch (e) {\n            console.error(`${host}:${filePath} exists but could not be parsed. ${e}`);\n        }\n        if (existingURL === webhookURL) {\n            return { outcome: \"unchanged\" as const, filePath };\n        }\n        if (!replace) {\n            throw new Error(\n                `Expected no conflicting webhook on ${host}, but ${filePath} already holds a different one.\\n`\n                + `Existing: ${existingURL}\\n`\n                + `New:      ${webhookURL}\\n`\n                + `Pass \"${REPLACE_KEYWORD}\" to overwrite it.`\n            );\n        }\n        replacedURL = existingURL;\n    }\n\n    await writeRemoteFile({\n        host,\n        filePath,\n        contents: formatWebhookFile(webhookURL),\n        fileMode: \"600\",\n        directoryMode: \"700\",\n    });\n\n    let writtenContents = await readRemoteFile({ host, filePath });\n    if (!writtenContents) {\n        throw new Error(`Expected ${filePath} to exist on ${host} after writing, no such file exists`);\n    }\n    let writtenURL = parseWebhookFile({ contents: writtenContents, sourceName: `${host}:${filePath}` });\n    if (writtenURL !== webhookURL) {\n        throw new Error(`Expected ${host}:${filePath} to hold the new webhook, was ${writtenURL}`);\n    }\n\n    if (replacedURL && replacedURL !== UNPARSEABLE_LABEL) {\n        // The new webhook is redacted, so this channel can identify the replacement without\n        // receiving a webhook it could post to.\n        try {\n            await sendToWebhookURL({\n                webhookURL: replacedURL,\n                message: `**portsecure**: the Discord webhook for \\`${host}\\` was replaced with`\n                    + ` \\`${redactWebhookURL(webhookURL)}\\`.`\n                    + ` This channel will stop receiving notifications for that host.`,\n            });\n        } catch (e) {\n            // The replacement already happened, so a dead old webhook must not fail the setup.\n            console.error(`Could not notify the old webhook that it was replaced. ${e}`);\n        }\n    }\n\n    // Failing here means the file is in place but the webhook itself does not work, which is\n    // exactly what the operator needs to hear about.\n    await sendToWebhookURL({\n        webhookURL,\n        message: `**portsecure**: notifications are now configured for \\`${host}\\`.`\n            + ` This channel will receive its security notifications.`,\n    });\n\n    return { outcome: replacedURL && \"replaced\" as const || \"created\" as const, filePath };\n}\n"]}
+ /* _JS_SOURCE_HASH = "7383d5b5b9fee5c3deb4ea3e75d9c556e64aef84ab8d71e7683a02bc87c5070a"; */