sliftutils 1.7.128 → 1.7.130

package/security/machines/machines.ts

@@ -0,0 +1,304 @@
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+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";
+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 { notify } from "../authorizedKeys/daemon/notify";
+import { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from "../notifications/discord";
+import { spawnPromise } from "../helpers/spawn";
+
+// Which machines this system talks to, kept in the same repo as the ssh keys. That repo is already
+// signed, already distributed to every machine, and already has somewhere to record a rejection,
+// so a second one would only be a second thing to keep in step.
+export const MACHINES_DIR = "machines";
+const REVOCATIONS_DIR = "revocations";
+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;
+
+/** 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;
+};
+
+async function pathExists(filePath: string) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+function machineFilePath(repoPath: string, machineId: string) {
+    return path.join(repoPath, MACHINES_DIR, `${machineId}.json`);
+}
+
+/** Every machine a checkout lists. */
+export async function getMachines(repoPath: string): Promise<MachineState[]> {
+    return [...(await readMachines(repoPath)).values()];
+}
+
+/** Makes a checkout list exactly these machines: those named are written with the addresses given,
+    and anything not named is removed. So read them, change what you want, and write the result.
+
+    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 setMachines(config: {
+    repoPath: string;
+    machines: { machineId: string; ips: string[] }[];
+}): Promise<MachineState[]> {
+    let { repoPath, machines } = config;
+    let existing = await readMachines(repoPath);
+    let directory = path.join(repoPath, MACHINES_DIR);
+    let written: MachineState[] = [];
+    for (let machine of machines) {
+        if (!machine.machineId) {
+            throw new Error(`Expected a machineId, was ${JSON.stringify(machine.machineId)}`);
+        }
+        if (!machine.ips.length) {
+            throw new Error(
+                `Expected addresses for ${machine.machineId}, was none. A machine is trusted from`
+                + ` the addresses it may talk from, so leave it out of the list to remove it.`
+            );
+        }
+        let ips = machine.ips.filter((ip, index) => ip && machine.ips.indexOf(ip) === index);
+        let state: MachineState = {
+            machineId: machine.machineId,
+            // In the order given, without duplicates, so the file reads the way it was set.
+            ips,
+            addedAt: existing.get(machine.machineId)?.addedAt || new Date().toISOString(),
+        };
+        await fs.mkdir(directory, { recursive: true });
+        await fs.writeFile(machineFilePath(repoPath, state.machineId), JSON.stringify(state, undefined, 4) + "\n");
+        written.push(state);
+    }
+
+    // Whatever the repo had and the caller did not name is no longer trusted.
+    for (let machineId of existing.keys()) {
+        if (!machines.some(machine => machine.machineId === machineId)) {
+            await fs.rm(machineFilePath(repoPath, machineId), { force: true });
+        }
+    }
+    return written;
+}
+
+/** Every machine the repo lists. */
+async function readMachines(repoPath: string) {
+    let machines = new Map<string, MachineState>();
+    let directory = path.join(repoPath, MACHINES_DIR);
+    let names = await fs.readdir(directory).catch(() => [] as string[]);
+    for (let name of names.sort()) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await fs.readFile(path.join(directory, name), "utf8"));
+            let machineId = parsed.machineId || name.replace(/\.json$/, "");
+            machines.set(machineId, { machineId, ips: parsed.ips || [], addedAt: parsed.addedAt || "" });
+        } catch (e) {
+            console.log(`Ignoring unreadable machine file ${name}. ${e}`);
+        }
+    }
+    return machines;
+}
+
+let lastRevokeSync = 0;
+
+/** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that
+    fails leaves the checkout we already have, which is the safe direction: revocations we know
+    about stay known. */
+async function syncRevocations(sourceURL: string) {
+    if (Date.now() - lastRevokeSync < REVOKE_SYNC_INTERVAL) {
+        return;
+    }
+    lastRevokeSync = Date.now();
+    try {
+        await syncRepoFiles(revokeRepo(sourceURL));
+    } catch (e) {
+        console.log(`Could not read ${revokeRepoURL(sourceURL)}, using the revocations already here. ${e}`);
+    }
+}
+
+/** Machine revocations, read out of the revoke repo the same way key revocations are. */
+async function readMachineRevocations(sourceURL: string) {
+    let repo = revokeRepo(sourceURL);
+    let revocations: { revocationId: string; machineId: string; ip: string }[] = [];
+    for (let name of await listRepoDir(repo, REVOCATIONS_DIR)) {
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        try {
+            let parsed = JSON.parse(await readRepoFile(repo, path.join(REVOCATIONS_DIR, name)) || "");
+            if (parsed.machineId) {
+                revocations.push({
+                    revocationId: parsed.revocationId || name.replace(/\.json$/, ""),
+                    machineId: parsed.machineId,
+                    ip: parsed.ip || "",
+                });
+            }
+        } catch (e) {
+            console.log(`Ignoring unreadable revocation ${name}. ${e}`);
+        }
+    }
+    return revocations;
+}
+
+/** 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
+    other process, which has not, so the webhook is picked up here if it is readable. A machine
+    with no webhook set up still records the revocation - being unable to tell anyone is not a
+    reason to keep accepting a machine that is being misused. */
+async function notifyBestEffort(headline: string, body: string) {
+    try {
+        if (!areDiscordNotificationsConfigured()) {
+            // Read first: configureDiscordNotifications exits the process when the file is missing,
+            // which is right for the daemon at startup and wrong for a library call.
+            await fs.readFile(DEFAULT_WEBHOOK_FILE_PATH, "utf8");
+            await configureDiscordNotifications({ filePath: DEFAULT_WEBHOOK_FILE_PATH });
+        }
+        await notify(headline, body);
+    } catch (e) {
+        console.log(`Could not send a notification about this, it is only in the log. ${e}`);
+    }
+}
+
+/** Records that a machine we accept talked to us from an address it is not allowed from. One per
+    machine and address, so a second address is a second revocation and an unrevoke of the first
+    does not cover it. */
+async function recordMachineRevocation(config: {
+    sourceURL: string;
+    machineId: string;
+    ip: string;
+    hostLabel: string;
+}) {
+    let { sourceURL, machineId, ip, hostLabel } = config;
+    let repoPath = revokeRepoPath(sourceURL);
+    let keyPath = await ensureRevokeKey(sourceURL);
+    let revocationId = newRevocationId(machineId);
+    let directory = path.join(repoPath, REVOCATIONS_DIR);
+    await fs.mkdir(directory, { recursive: true });
+    await fs.writeFile(path.join(directory, `${revocationId}.json`), JSON.stringify({
+        revocationId,
+        machineId,
+        ip,
+        revokedAt: new Date().toISOString(),
+        revokedBy: hostLabel,
+        reason: REVOCATION_REASON,
+    }, undefined, 4) + "\n");
+
+    await runGit({ args: ["add", "-A"], cwd: repoPath, keyPath });
+    await runGit({
+        args: ["-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", `revoke ${revocationId}`],
+        cwd: repoPath, keyPath,
+    });
+    let push = await runGit({ args: ["push", "origin", "HEAD"], cwd: repoPath, keyPath, allowFailure: true });
+    if (push.status !== 0) {
+        // Another machine most likely recorded the same thing first, and the next read picks it up.
+        console.log(`Could not push the revocation of ${machineId} from ${ip}. ${(push.stdout + push.stderr).trim()}`);
+        return;
+    }
+    console.log(`Revoked ${machineId} from ${ip}, ${revocationId}`);
+
+    // Said by whoever wrote the revocation, once, the same as for an ssh key. Machines that only
+    // read it later say nothing, or one event would be reported by every machine that saw it.
+    await notifyBestEffort(
+        `SUSPICIOUS IP ${ip} FROZE MACHINE ${machineId}`,
+        `A machine we trust talked to us from ${ip}, which is not an address it is allowed to talk`
+        + ` from. It proved it holds that machine's key, so either someone else has a copy of it,`
+        + ` or that machine's address changed.`
+        + `\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 effect as each machine picks it up.`
+        + `\n\nmachine: \`${machineId}\``
+        + `\nfrozen by: \`${hostLabel}\``
+    );
+}
+
+/** 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 async function isMachineAccepted(config: { machineId: string; ip: string }): Promise<MachineVerdict> {
+    let { machineId, ip } = config;
+    if (!machineId || !ip) {
+        throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);
+    }
+    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);
+    if (!machine) {
+        return { accepted: false, reason: "that machine is not trusted" };
+    }
+
+    await syncRevocations(sourceURL);
+    let unrevokes = await readUnrevokes(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
+    // An unrevoke 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 frozenFrom = "";
+    for (let revocation of revocations) {
+        if (revocation.machineId !== machineId) {
+            continue;
+        }
+        if (!allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
+            frozenFrom = revocation.ip;
+        }
+    }
+    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 { accepted: true, reason: "" };
+    }
+
+    // Listed, but talking to us from somewhere it should not be. Recorded once for this machine
+    // and address, so being talked to repeatedly does not write repeatedly.
+    let pair = pairKey({ fingerprint: machineId, ip });
+    let alreadyRecorded = revocations.some(revocation =>
+        pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }) === 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 { accepted: false, reason: `that machine is not allowed from ${ip}` };
+}

package/security/machines/trustClient.ts

@@ -0,0 +1,51 @@
+import { signTrustPacket } from "./identity";
+
+// The other half of the demonstration: asks a server whether it trusts this machine. The answer
+// depends on the address this machine reaches the server from, which is why the client cannot
+// work it out alone.
+const TRUST_PATH = "/trusted";
+const USAGE = `Usage: yarn machineclient <url> <domain>
+
+Asks that server whether this machine is trusted, proving which machine it is with a signed packet.
+The server decides using the address we reach it from, so the answer is about how we are talking to
+it, not only about who we are.
+
+The domain is required: this machine has a different identity under each one, and the answer is
+about the identity we sign with.`;
+
+export type TrustAnswer = {
+    trusted: boolean;
+    machineId?: string;
+    ip?: string;
+    reason?: string;
+};
+
+/** Asks one server whether it trusts this machine, as it is under this domain. */
+export async function askIfTrusted(config: { baseURL: string; domain: string }): Promise<TrustAnswer> {
+    let { baseURL, domain } = config;
+    let packet = await signTrustPacket(domain);
+    let url = `${baseURL.replace(/\/+$/, "")}${TRUST_PATH}`;
+    let response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(packet),
+    });
+    return await response.json() as TrustAnswer;
+}
+
+export async function main() {
+    let [baseURL, domain] = process.argv.slice(2);
+    if (!baseURL || !domain) {
+        throw new Error(USAGE);
+    }
+    let answer = await askIfTrusted({ baseURL, domain });
+    console.log(`${answer.trusted && "TRUSTED" || "NOT TRUSTED"} by ${baseURL}`);
+    console.log(`  machine ${answer.machineId || "(not established)"}`);
+    console.log(`  seen coming from ${answer.ip || "(unknown)"}`);
+    if (answer.reason) {
+        console.log(`  ${answer.reason}`);
+    }
+    if (!answer.trusted) {
+        process.exitCode = 1;
+    }
+}

package/security/machines/trustServer.ts

@@ -0,0 +1,87 @@
+import http from "http";
+import { verifyTrustPacket } from "./identity";
+import { isMachineAccepted } from "./machines";
+
+// A demonstration of machine trust, and the smallest thing that exercises it end to end: a client
+// proves which machine it is, and this answers whether that machine is trusted from the address it
+// is actually talking from.
+//
+// Plain http on purpose. Nothing here is secret - the packet proves who the client is by signature
+// rather than by the channel, and the answer is a yes or no about a machine the caller already
+// knows the id of.
+const DEFAULT_PORT = 47812;
+const TRUST_PATH = "/trusted";
+const MAX_BODY_LENGTH = 64 * 1024;
+
+/** The address the client is actually talking from. Not read from anything the client sent,
+    because that is the one half of the pair it must not get to choose. */
+function addressOf(request: http.IncomingMessage) {
+    let address = request.socket.remoteAddress || "";
+    // Node reports IPv4 over a dual stack socket this way.
+    return address.replace(/^::ffff:/, "");
+}
+
+async function readBody(request: http.IncomingMessage) {
+    let chunks: Buffer[] = [];
+    let length = 0;
+    for await (let chunk of request) {
+        length += chunk.length;
+        if (length > MAX_BODY_LENGTH) {
+            throw new Error(`Expected at most ${MAX_BODY_LENGTH} bytes, was more`);
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+
+export function startTrustServer(config: { port: number }) {
+    let server = http.createServer((request, response) => {
+        let answer = async () => {
+            if (request.url !== TRUST_PATH) {
+                return { status: 404, body: { error: `POST a trust packet to ${TRUST_PATH}` } };
+            }
+            let packet = JSON.parse(await readBody(request));
+            let ip = addressOf(request);
+            let verified = verifyTrustPacket(packet);
+            if (!verified.valid) {
+                // 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 verdict = await isMachineAccepted({ machineId: packet.machineId, ip });
+            return {
+                status: 200,
+                body: {
+                    trusted: verdict.accepted,
+                    machineId: packet.machineId,
+                    ip,
+                    // Whatever the check itself said. It is the only thing that knows which of the
+                    // ways to be refused this was.
+                    reason: verdict.reason,
+                },
+            };
+        };
+        answer().then(result => {
+            console.log(`${request.method} ${request.url} from ${addressOf(request)}: ${JSON.stringify(result.body)}`);
+            response.writeHead(result.status, { "Content-Type": "application/json" });
+            response.end(JSON.stringify(result.body, undefined, 4));
+        }).catch(e => {
+            console.log(`${request.method} ${request.url} from ${addressOf(request)} failed. ${e}`);
+            response.writeHead(500, { "Content-Type": "application/json" });
+            response.end(JSON.stringify({ trusted: false, error: `${e}` }, undefined, 4));
+        });
+    });
+    server.listen(config.port);
+    return server;
+}
+
+export async function main() {
+    let port = Number(process.argv[2] || DEFAULT_PORT);
+    if (!Number.isFinite(port)) {
+        throw new Error(`Usage: yarn machineserver [port]`);
+    }
+    startTrustServer({ port });
+    console.log(`Answering trust checks on http://0.0.0.0:${port}${TRUST_PATH}`);
+    console.log(`A client asks with: yarn machineclient http://<this machine>:${port}`);
+    // Left running. Nothing else to do here, the server is the program.
+    await new Promise(() => { });
+}

package/security/notifications/discord.ts

@@ -89,8 +89,9 @@ export function messageTimestamp(now: Date) {
 
 async function postToWebhook(webhookURL: string, message: string) {
     // 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}`;
+    // when we last managed to get it out. At the end, because the first line of a message is the
+    // notification preview and a timestamp there would spend it saying nothing.
+    let content = `${message} · \`${messageTimestamp(new Date())}\``;
     if (content.length > DISCORD_MESSAGE_LIMIT) {
         content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
     }
@@ -149,9 +150,11 @@ async function checkWebhookFileChanged() {
     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.`
+            `**portsecure**: **NOTIFICATIONS ARE MOVING TO ANOTHER CHANNEL**`
+            + `\n\nThis channel stops receiving them now. If that was not you, somebody with access`
+            + ` to this machine just redirected its alerts.`
+            + `\n\nnew webhook: \`${redactWebhookURL(newWebhookURL)}\``
+            + `\nset in: \`${state.filePath}\``
         );
     } catch (e) {
         console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);
@@ -198,6 +201,12 @@ export async function sendDiscordNotification(message: string) {
     await queueSend(state.webhookURL, message);
 }
 
+/** 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 function areDiscordNotificationsConfigured() {
+    return !!notificationState;
+}
+
 export function stopDiscordNotifications() {
     if (!notificationState) {
         return;

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

@@ -3,7 +3,7 @@ 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;
+//exports.stopDiscordNotifications = exports.areDiscordNotificationsConfigured = 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
@@ -84,8 +84,9 @@ function messageTimestamp(now) {
 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}`;
+    // when we last managed to get it out. At the end, because the first line of a message is the
+    // notification preview and a timestamp there would spend it saying nothing.
+    let content = `${message} · \`${messageTimestamp(new Date())}\``;
     if (content.length > DISCORD_MESSAGE_LIMIT) {
         content = content.slice(0, DISCORD_MESSAGE_LIMIT - 3) + "...";
     }
@@ -139,9 +140,11 @@ async function checkWebhookFileChanged() {
     // 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.`);
+        await queueSend(state.webhookURL, `**portsecure**: **NOTIFICATIONS ARE MOVING TO ANOTHER CHANNEL**`
+            + `\n\nThis channel stops receiving them now. If that was not you, somebody with access`
+            + ` to this machine just redirected its alerts.`
+            + `\n\nnew webhook: \`${redactWebhookURL(newWebhookURL)}\``
+            + `\nset in: \`${state.filePath}\``);
     }
     catch (e) {
         console.error(`portsecure: failed to warn the old Discord webhook about the change. ${e}`);
@@ -185,6 +188,12 @@ async function sendDiscordNotification(message) {
     await queueSend(state.webhookURL, message);
 }
 exports.sendDiscordNotification = sendDiscordNotification;
+/** 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. */
+function areDiscordNotificationsConfigured() {
+    return !!notificationState;
+}
+exports.areDiscordNotificationsConfigured = areDiscordNotificationsConfigured;
 function stopDiscordNotifications() {
     if (!notificationState) {
         return;
@@ -193,5 +202,5 @@ function stopDiscordNotifications() {
     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"; */
+//# 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"; */