sliftutils 1.7.127 → 1.7.129

package/security/authorizedKeys/daemon/daemon.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import os from "os";
 import { configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from "../../notifications/discord";
-import { sourceKeyPath, sourceRepoPath } from "../sources";
+import { findSourceKey, legacySourceKeyPath, sourceKeyPath, sourceRepoPath } from "../sources";
 import { cloneRepo, syncRepo } from "./git";
 import {
     CHECK_INTERVAL,
@@ -15,7 +15,9 @@ import { enforceSSHDConfig } from "./sshdConfig";
 import { getState, loadState, saveState, sourceState } from "./state";
 import { resolveSourceKeys } from "./trust";
 import { parseAuthLog, readNewAuthLog, watchAuthLog } from "./authLog";
-import { absorbRevocations, applyUnrevokes, recordRevocation, removeRevokedKeys, syncRevokeRepo } from "./revocation";
+import { absorbRevocations, applyUnrevokes, pairKey, recordRevocation, removeRevokedKeys } from "./revocation";
+import { revokeRepo, syncRepoFiles } from "./repoFiles";
+import { revokeRepoURL } from "../revokeSource";
 import { keyFingerprint } from "../authorizedKeys";
 import { addChangeReason } from "./changes";
 import { checkOtherUserKeys, seedUserKeys } from "./userKeys";
@@ -42,6 +44,8 @@ import { checkOtherUserKeys, seedUserKeys } from "./userKeys";
 //   7. A source changed without its signature being updated, so the change is ignored.
 //   8. A source has a corrupted signature, so its contents are ignored.
 //   9. The webhook file itself changed, reported to the webhook being replaced.
+//  10. A trusted machine talked to us from an address it is not allowed from, so it was frozen
+//      everywhere. Sent by whichever machine wrote that revocation, from machines.ts.
 
 export type DaemonConfig = {
     repoSources: string[];
@@ -74,10 +78,11 @@ async function loadConfig(): Promise<DaemonConfig> {
         process.exit(1);
     }
     for (let repoURL of parsed.repoSources) {
-        try {
-            await fs.access(sourceKeyPath(repoURL));
-        } catch (e) {
-            console.error(`portsecure: expected the private key for ${repoURL} at ${sourceKeyPath(repoURL)}, ${e}`);
+        if (!await findSourceKey(repoURL)) {
+            console.error(
+                `portsecure: expected the private key for ${repoURL} at ${sourceKeyPath(repoURL)}`
+                + ` or ${legacySourceKeyPath(repoURL)}, neither exists`
+            );
             process.exit(1);
         }
     }
@@ -137,11 +142,13 @@ async function queueRefusedKeys(allowedKeys: string[]) {
     }
     let state = getState();
     for (let found of parseAuthLog(contents)) {
-        // One key is revoked once, no matter how many addresses it was tried from.
-        if (state.revocations[found.fingerprint]) {
+        // A key and the address it was used from. The same pair twice is one revocation, but the
+        // same key from somewhere else is a new event, whatever was forgiven before.
+        let pair = pairKey({ fingerprint: found.fingerprint, ip: found.attempt.ip });
+        if (Object.values(state.revocations).some(revocation => pairKey(revocation) === pair)) {
             continue;
         }
-        if (state.pendingRevocations.some(pending => pending.fingerprint === found.fingerprint)) {
+        if (state.pendingRevocations.some(pending => pairKey({ fingerprint: pending.fingerprint, ip: pending.attempt.ip }) === pair)) {
             continue;
         }
         let sourceURL = sourceOfFingerprint(found.fingerprint);
@@ -174,11 +181,13 @@ async function writeQueuedRevocations() {
     try {
         let remaining = [];
         for (let pending of state.pendingRevocations) {
-            if (state.revocations[pending.fingerprint]) {
+            let known = () => Object.values(state.revocations)
+                .some(revocation => pairKey(revocation) === pairKey({ fingerprint: pending.fingerprint, ip: pending.attempt.ip }));
+            if (known()) {
                 continue;
             }
             let recorded = await recordRevocation({ ...pending, hostLabel: config.hostLabel });
-            if (!recorded && !state.revocations[pending.fingerprint]) {
+            if (!recorded && !known()) {
                 remaining.push(pending);
             }
         }
@@ -213,7 +222,7 @@ async function pollSource(repoURL: string) {
         // Availability over tidiness: throw the working copy away and start again.
         console.log(`Discarding the checkout of ${repoURL} and cloning from scratch`);
         try {
-            await cloneRepo({ repoURL, repoPath: sourceRepoPath(repoURL), keyPath: sourceKeyPath(repoURL) });
+            await cloneRepo({ repoURL, repoPath: sourceRepoPath(repoURL), keyPath: await findSourceKey(repoURL) || sourceKeyPath(repoURL) });
             repoFailureCounts[repoURL] = 0;
             return true;
         } catch (cloneError) {
@@ -223,10 +232,11 @@ async function pollSource(repoURL: string) {
     }
 
     if (result.historyRewritten) {
-        await notify(
-            `the history of \`${repoURL}\` was rewritten. Commit \`${result.previousSha.slice(0, 12)}\` is no`
-            + ` longer an ancestor of \`${result.remoteSha.slice(0, 12)}\`, so history was force pushed or`
-            + ` tampered with. The new state has been applied.`
+        await notify(`KEY REPO HISTORY REWRITTEN`,
+            `Commits that used to be in \`${repoURL}\` are gone, so somebody force pushed over it`
+            + ` or tampered with it. Whatever it says now has been applied.`
+            + `\n\nwas at: \`${result.previousSha.slice(0, 12)}\``
+            + `\nnow at: \`${result.remoteSha.slice(0, 12)}\``
         );
     }
     if (!result.changed) {
@@ -234,11 +244,18 @@ async function pollSource(repoURL: string) {
     }
     // Said when the file is written, and only if it came out different. A commit that does not
     // touch the keys is not worth telling anyone about.
-    addChangeReason(`\`${repoURL}\` moved to \`${result.remoteSha.slice(0, 12)}\`.`);
+    addChangeReason(`The key repo \`${repoURL}\` moved to \`${result.remoteSha.slice(0, 12)}\`.`);
     sourceState(repoURL).lastSha = result.remoteSha;
     return true;
 }
 
+/** The one loop. Every repo this machine reads is brought up to date here: each source, and the
+    revoke repo beside it that says which of its keys are no longer accepted.
+
+    A repo that cannot be read is reported and skipped, and nothing downstream may read that as an
+    answer. An unreachable source keeps the keys it last gave us, and an unreachable revoke repo
+    keeps the revocations we already know - the alternative is one network failure emptying
+    authorized_keys, or handing a revoked key back to every machine. */
 async function everyCheck() {
     let anyChanged = false;
     for (let repoURL of config.repoSources) {
@@ -246,17 +263,20 @@ async function everyCheck() {
         try {
             anyChanged = await pollSource(repoURL) || anyChanged;
         } catch (e) {
-            console.log(`Polling ${repoURL} failed. ${e && (e as Error).stack || e}`);
+            console.error(`Polling ${repoURL} failed, its last known keys stay in place. ${e && (e as Error).stack || e}`);
+        }
+        try {
+            await syncRepoFiles(revokeRepo(repoURL));
+        } catch (e) {
+            console.error(
+                `Could not read ${revokeRepoURL(repoURL)}, the revocations already known stay in place. ${e}`
+            );
         }
     }
     if (anyChanged) {
         await saveState();
     }
 
-    // What other machines have revoked, and anything published to undo a revocation.
-    for (let repoURL of config.repoSources) {
-        await syncRevokeRepo(repoURL);
-    }
     await absorbRevocations(config.repoSources);
     await applyUnrevokes(config.repoSources);
 
@@ -298,28 +318,18 @@ export async function main() {
 
     console.log(`Starting, ${config.repoSources.length} source(s), keys applied to ${ROOT_AUTHORIZED_KEYS}`);
 
-    // A first pass has to happen before the intervals, so a machine is correct immediately after
-    // boot rather than a minute later.
-    for (let repoURL of config.repoSources) {
-        try {
-            sourceState(repoURL).lastSha = (await syncRepo(repoURL)).remoteSha;
-        } catch (e) {
-            console.log(`Initial sync of ${repoURL} failed, continuing with whatever is on disk. ${e}`);
-        }
-    }
-    await saveState();
+    // Whatever other users already have, before the first check, so what is there at startup is
+    // not reported as somebody having just changed it.
     await seedUserKeys();
 
-    for (let repoURL of config.repoSources) {
-        await syncRevokeRepo(repoURL);
-    }
-    await absorbRevocations(config.repoSources);
-    await enforceRootKeys(await removeRevokedKeys(await readAllowedKeys()));
-    await enforceSSHDConfig();
-
     // configureDiscordNotifications watches the webhook file on its own, so there is nothing to
     // schedule for it here.
-    startInterval({ name: "check", intervalTime: CHECK_INTERVAL, run: everyCheck });
+    let runCheck = startInterval({ name: "check", intervalTime: CHECK_INTERVAL, run: everyCheck });
+    // The same check as every other, run once now rather than a minute from now: a machine has to
+    // be correct immediately after boot. Running the one function, rather than a startup copy of
+    // it, is what keeps a step from being left out of one of them - the copy here had no
+    // applyUnrevokes, so every restart re-applied a revocation that had already been undone.
+    await runCheck();
 
     // A refused login is acted on when sshd writes it. The one pass here covers anything written
     // while the daemon was not running.

package/security/authorizedKeys/daemon/dist/changes.ts.cache

@@ -0,0 +1,40 @@
+"use strict";
+// Why root's authorized_keys is about to change, collected as it happens.
+//
+// Nothing announces itself at the moment it decides something. A revocation arriving, a key being
+// revoked here, an unrevoke taking effect, a repo moving on: each of those says what it is and
+// leaves it here. The file is then written, and only if it actually came out different does any of
+// it get reported, in one message.
+//
+// Doing it the other way round is what produced several messages for one event, and messages about
+// removing a key that had already gone.
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.takeChangeReasons = exports.addLeadingChangeReason = exports.addChangeReason = void 0;
+let reasons = [];
+let leadingReasons = [];
+function addChangeReason(reason) {
+    // The same reason twice in one pass says nothing the once did not.
+    if (!reasons.includes(reason)) {
+        reasons.push(reason);
+    }
+}
+exports.addChangeReason = addChangeReason;
+/** For the one thing worth reading before anything else: somebody using a key from an address it
+    is not allowed from. */
+function addLeadingChangeReason(reason) {
+    if (!leadingReasons.some(existing => existing.headline === reason.headline)) {
+        leadingReasons.push(reason);
+    }
+}
+exports.addLeadingChangeReason = addLeadingChangeReason;
+/** The reasons gathered since the last write, and clears them. Called whether or not anything
+    changed, so reasons that came to nothing cannot show up against some later change. */
+function takeChangeReasons() {
+    let taken = { leading: leadingReasons, reasons };
+    leadingReasons = [];
+    reasons = [];
+    return taken;
+}
+exports.takeChangeReasons = takeChangeReasons;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "6d0282fa2244057d7a106dc14b6b13dd37ddc1ba1ecc4a44b33dfd51c3e409a5"; */

package/security/authorizedKeys/daemon/dist/git.ts.cache

@@ -0,0 +1,121 @@
+"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.syncRepo = exports.currentBranch = exports.cloneRepo = exports.repoIsUsable = exports.runGit = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const spawn_1 = require("../../helpers/spawn");
+const sources_1 = require("../sources");
+const paths_1 = require("./paths");
+const state_1 = require("./state");
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** core.sshCommand keeps the key selection with the command instead of in the environment. */
+async function runGit(config) {
+    let { args, cwd, keyPath, allowFailure } = config;
+    let sshCommand = `ssh -i ${keyPath} -o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=accept-new`;
+    let result = await (0, spawn_1.spawnPromise)({
+        command: "git",
+        args: ["-c", `core.sshCommand=${sshCommand}`, ...args],
+        cwd,
+        timeoutTime: paths_1.GIT_TIMEOUT,
+    });
+    if (result.error) {
+        throw new Error(`Expected git ${args.join(" ")} to run, failed with ${result.error.message}`);
+    }
+    if (result.status !== 0 && !allowFailure) {
+        throw new Error(`Expected git ${args.join(" ")} to exit 0, was ${result.status}. `
+            + `${(result.stdout + result.stderr).trim().slice(0, paths_1.MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return result;
+}
+exports.runGit = runGit;
+async function repoIsUsable(config) {
+    let { repoPath, keyPath } = config;
+    if (!await pathExists(path_1.default.join(repoPath, ".git"))) {
+        return false;
+    }
+    let result = await runGit({ args: ["rev-parse", "--git-dir"], cwd: repoPath, keyPath, allowFailure: true });
+    if (result.status !== 0) {
+        console.log(`Repo at ${repoPath} is not usable. ${(result.stdout + result.stderr).trim()}`);
+        return false;
+    }
+    return true;
+}
+exports.repoIsUsable = repoIsUsable;
+/** Cloned beside the old checkout and swapped in, so a clone that fails leaves the copy we are
+    already using untouched rather than deleting the only keys we have. */
+async function cloneRepo(config) {
+    let { repoURL, repoPath, keyPath } = config;
+    let incomingPath = `${repoPath}.incoming`;
+    await promises_1.default.rm(incomingPath, { recursive: true, force: true });
+    await promises_1.default.mkdir(path_1.default.dirname(repoPath), { recursive: true });
+    await runGit({ args: ["clone", repoURL, incomingPath], keyPath });
+    await promises_1.default.rm(repoPath, { recursive: true, force: true });
+    await promises_1.default.rename(incomingPath, repoPath);
+    console.log(`Cloned ${repoURL} into ${repoPath}`);
+}
+exports.cloneRepo = cloneRepo;
+async function currentBranch(config) {
+    return (await runGit({ args: ["rev-parse", "--abbrev-ref", "HEAD"], ...config })).stdout.trim();
+}
+exports.currentBranch = currentBranch;
+async function ensureSourceRepo(repoURL) {
+    let repoPath = (0, sources_1.sourceRepoPath)(repoURL);
+    let keyPath = await (0, sources_1.findSourceKey)(repoURL) || (0, sources_1.sourceKeyPath)(repoURL);
+    if (!await repoIsUsable({ repoPath, keyPath })) {
+        await cloneRepo({ repoURL, repoPath, keyPath });
+    }
+    if (!(0, state_1.sourceState)(repoURL).branch) {
+        (0, state_1.sourceState)(repoURL).branch = await currentBranch({ repoPath, keyPath });
+    }
+}
+/** Returns what changed, so the caller can report it. A rewritten history is called out
+    separately - it means the remote no longer contains the commits we already had. */
+async function syncRepo(repoURL) {
+    await ensureSourceRepo(repoURL);
+    let repoPath = (0, sources_1.sourceRepoPath)(repoURL);
+    let keyPath = await (0, sources_1.findSourceKey)(repoURL) || (0, sources_1.sourceKeyPath)(repoURL);
+    let branch = (0, state_1.sourceState)(repoURL).branch;
+    let localSha = (await runGit({ args: ["rev-parse", "HEAD"], cwd: repoPath, keyPath })).stdout.trim();
+    // A ref listing is a few hundred bytes and no objects, so the usual case of nothing having
+    // changed costs almost nothing and we only fetch when there is something to fetch.
+    let listing = (await runGit({ args: ["ls-remote", "origin", branch], cwd: repoPath, keyPath })).stdout;
+    let remoteSha = (listing.split(/\s+/)[0] || "").trim();
+    if (!remoteSha) {
+        throw new Error(`Expected origin to report a sha for ${branch}, listed ${listing.slice(0, paths_1.MAX_ERROR_BODY_LENGTH)}`);
+    }
+    if (remoteSha === localSha && remoteSha === (0, state_1.sourceState)(repoURL).lastSha) {
+        return { changed: false, historyRewritten: false, remoteSha, previousSha: localSha };
+    }
+    await runGit({ args: ["fetch", "--prune", "origin", branch], cwd: repoPath, keyPath });
+    remoteSha = (await runGit({ args: ["rev-parse", `origin/${branch}`], cwd: repoPath, keyPath })).stdout.trim();
+    let previousSha = (0, state_1.sourceState)(repoURL).lastSha || localSha;
+    let historyRewritten = false;
+    if (previousSha && previousSha !== remoteSha) {
+        // If what we already had is no longer an ancestor of the remote tip, commits were removed
+        // or rewritten rather than added.
+        let ancestry = await runGit({
+            args: ["merge-base", "--is-ancestor", previousSha, remoteSha],
+            cwd: repoPath,
+            keyPath,
+            allowFailure: true,
+        });
+        historyRewritten = ancestry.status !== 0;
+    }
+    await runGit({ args: ["reset", "--hard", `origin/${branch}`], cwd: repoPath, keyPath });
+    await runGit({ args: ["clean", "-fdx"], cwd: repoPath, keyPath });
+    return { changed: true, historyRewritten, remoteSha, previousSha };
+}
+exports.syncRepo = syncRepo;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"git.js","sourceRoot":"","sources":["git.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport path from \"path\";\nimport { spawnPromise } from \"../../helpers/spawn\";\nimport { findSourceKey, sourceKeyPath, sourceRepoPath } from \"../sources\";\nimport { GIT_TIMEOUT, MAX_ERROR_BODY_LENGTH } from \"./paths\";\nimport { sourceState } from \"./state\";\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/** core.sshCommand keeps the key selection with the command instead of in the environment. */\nexport async function runGit(config: { args: string[]; cwd?: string; keyPath: string; allowFailure?: boolean }) {\n    let { args, cwd, keyPath, allowFailure } = config;\n    let sshCommand = `ssh -i ${keyPath} -o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=accept-new`;\n    let result = await spawnPromise({\n        command: \"git\",\n        args: [\"-c\", `core.sshCommand=${sshCommand}`, ...args],\n        cwd,\n        timeoutTime: GIT_TIMEOUT,\n    });\n    if (result.error) {\n        throw new Error(`Expected git ${args.join(\" \")} to run, failed with ${result.error.message}`);\n    }\n    if (result.status !== 0 && !allowFailure) {\n        throw new Error(\n            `Expected git ${args.join(\" \")} to exit 0, was ${result.status}. `\n            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n    return result;\n}\n\nexport async function repoIsUsable(config: { repoPath: string; keyPath: string }) {\n    let { repoPath, keyPath } = config;\n    if (!await pathExists(path.join(repoPath, \".git\"))) {\n        return false;\n    }\n    let result = await runGit({ args: [\"rev-parse\", \"--git-dir\"], cwd: repoPath, keyPath, allowFailure: true });\n    if (result.status !== 0) {\n        console.log(`Repo at ${repoPath} is not usable. ${(result.stdout + result.stderr).trim()}`);\n        return false;\n    }\n    return true;\n}\n\n/** Cloned beside the old checkout and swapped in, so a clone that fails leaves the copy we are\n    already using untouched rather than deleting the only keys we have. */\nexport async function cloneRepo(config: { repoURL: string; repoPath: string; keyPath: string }) {\n    let { repoURL, repoPath, keyPath } = config;\n    let incomingPath = `${repoPath}.incoming`;\n    await fs.rm(incomingPath, { recursive: true, force: true });\n    await fs.mkdir(path.dirname(repoPath), { recursive: true });\n    await runGit({ args: [\"clone\", repoURL, incomingPath], keyPath });\n    await fs.rm(repoPath, { recursive: true, force: true });\n    await fs.rename(incomingPath, repoPath);\n    console.log(`Cloned ${repoURL} into ${repoPath}`);\n}\n\nexport async function currentBranch(config: { repoPath: string; keyPath: string }) {\n    return (await runGit({ args: [\"rev-parse\", \"--abbrev-ref\", \"HEAD\"], ...config })).stdout.trim();\n}\n\nasync function ensureSourceRepo(repoURL: string) {\n    let repoPath = sourceRepoPath(repoURL);\n    let keyPath = await findSourceKey(repoURL) || sourceKeyPath(repoURL);\n    if (!await repoIsUsable({ repoPath, keyPath })) {\n        await cloneRepo({ repoURL, repoPath, keyPath });\n    }\n    if (!sourceState(repoURL).branch) {\n        sourceState(repoURL).branch = await currentBranch({ repoPath, keyPath });\n    }\n}\n\n/** Returns what changed, so the caller can report it. A rewritten history is called out\n    separately - it means the remote no longer contains the commits we already had. */\nexport async function syncRepo(repoURL: string) {\n    await ensureSourceRepo(repoURL);\n    let repoPath = sourceRepoPath(repoURL);\n    let keyPath = await findSourceKey(repoURL) || sourceKeyPath(repoURL);\n    let branch = sourceState(repoURL).branch;\n    let localSha = (await runGit({ args: [\"rev-parse\", \"HEAD\"], cwd: repoPath, keyPath })).stdout.trim();\n\n    // A ref listing is a few hundred bytes and no objects, so the usual case of nothing having\n    // changed costs almost nothing and we only fetch when there is something to fetch.\n    let listing = (await runGit({ args: [\"ls-remote\", \"origin\", branch], cwd: repoPath, keyPath })).stdout;\n    let remoteSha = (listing.split(/\\s+/)[0] || \"\").trim();\n    if (!remoteSha) {\n        throw new Error(`Expected origin to report a sha for ${branch}, listed ${listing.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    if (remoteSha === localSha && remoteSha === sourceState(repoURL).lastSha) {\n        return { changed: false, historyRewritten: false, remoteSha, previousSha: localSha };\n    }\n\n    await runGit({ args: [\"fetch\", \"--prune\", \"origin\", branch], cwd: repoPath, keyPath });\n    remoteSha = (await runGit({ args: [\"rev-parse\", `origin/${branch}`], cwd: repoPath, keyPath })).stdout.trim();\n\n    let previousSha = sourceState(repoURL).lastSha || localSha;\n    let historyRewritten = false;\n    if (previousSha && previousSha !== remoteSha) {\n        // If what we already had is no longer an ancestor of the remote tip, commits were removed\n        // or rewritten rather than added.\n        let ancestry = await runGit({\n            args: [\"merge-base\", \"--is-ancestor\", previousSha, remoteSha],\n            cwd: repoPath,\n            keyPath,\n            allowFailure: true,\n        });\n        historyRewritten = ancestry.status !== 0;\n    }\n    await runGit({ args: [\"reset\", \"--hard\", `origin/${branch}`], cwd: repoPath, keyPath });\n    await runGit({ args: [\"clean\", \"-fdx\"], cwd: repoPath, keyPath });\n    return { changed: true, historyRewritten, remoteSha, previousSha };\n}\n"]}
+ /* _JS_SOURCE_HASH = "da70130786edfd6c82adec69297c753d740fb3477e29daf0f2670052fa21b0fd"; */

package/security/authorizedKeys/daemon/dist/notify.ts.cache

@@ -0,0 +1,39 @@
+"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.notify = exports.setHostLabel = void 0;
+const os_1 = __importDefault(require("os"));
+const discord_1 = require("../../notifications/discord");
+let hostLabelValue = "";
+function setHostLabel(value) {
+    hostLabelValue = value;
+}
+exports.setHostLabel = setHostLabel;
+// 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 console.log instead. The complete list of
+// cases that are allowed to notify is at the top of daemon.ts.
+/** A headline and the rest.
+
+    The headline is all a phone shows. It gets the whole preview to itself: no product name, no
+    host, no timestamp in front of it, because a person glancing at their lock screen needs to read
+    what happened, not which machine said it or when. Those go at the end, where they are there for
+    whoever opens the message and out of the way of whoever does not. */
+async function notify(headline, body) {
+    let full = `**${headline}**\n\n${body}\n\n${hostLabelValue || os_1.default.hostname()}`;
+    // Logged before it is sent, and whether or not it arrives, so the journal is a complete record
+    // of what this machine had to say even when Discord is unreachable or the webhook is wrong.
+    console.log(`Discord: ${full}`);
+    try {
+        await (0, discord_1.sendDiscordNotification)(full);
+    }
+    catch (e) {
+        // A failed notification must never take the daemon down, the local log is the fallback.
+        console.log(`Failed to send the Discord notification above. ${e}`);
+    }
+}
+exports.notify = notify;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "9fe72e2c338fa1d2d53a34b85265b997cc47def23f019ca77b8a3735088305e5"; */

package/security/authorizedKeys/daemon/dist/paths.ts.cache

@@ -0,0 +1,29 @@
+"use strict";
+// Locations the daemon owns. Fixed rather than configurable, so every machine looks the same and
+// the config file only carries what genuinely differs between them.
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.MAX_REPO_FAILURES_BEFORE_RECLONE = exports.UNREVOKE_DELAY = exports.SIGNER_CHANGE_DELAY = exports.MAX_ERROR_BODY_LENGTH = exports.GIT_TIMEOUT = exports.WEBHOOK_CHECK_INTERVAL = exports.CHECK_INTERVAL = exports.AUTH_LOG_PATH = exports.PASSWD_PATH = exports.SSHD_DROPIN_PATH = exports.SSHD_DROPIN_DIR = exports.SSHD_CONFIG_PATH = exports.ROOT_AUTHORIZED_KEYS = exports.KEYS_HISTORY_PATH = exports.STATE_PATH = exports.CONFIG_PATH = void 0;
+exports.CONFIG_PATH = "/etc/portsecure/daemon.json";
+exports.STATE_PATH = "/var/lib/portsecure/state.json";
+exports.KEYS_HISTORY_PATH = "/var/lib/portsecure/authorized-keys-history";
+exports.ROOT_AUTHORIZED_KEYS = "/root/.ssh/authorized_keys";
+exports.SSHD_CONFIG_PATH = "/etc/ssh/sshd_config";
+exports.SSHD_DROPIN_DIR = "/etc/ssh/sshd_config.d";
+exports.SSHD_DROPIN_PATH = "/etc/ssh/sshd_config.d/00-portsecure.conf";
+exports.PASSWD_PATH = "/etc/passwd";
+exports.AUTH_LOG_PATH = "/var/log/auth.log";
+exports.CHECK_INTERVAL = 60 * 1000;
+exports.WEBHOOK_CHECK_INTERVAL = 5 * 60 * 1000;
+exports.GIT_TIMEOUT = 120 * 1000;
+exports.MAX_ERROR_BODY_LENGTH = 500;
+// A source that starts being signed by someone new is held at arm's length for this long, so a
+// stolen signing key cannot push keys onto a machine before anyone notices the warning.
+exports.SIGNER_CHANGE_DELAY = 24 * 60 * 60 * 1000;
+// An unrevoke waits this long before taking effect, so a compromised signing key cannot instantly
+// undo the revocation that locked it out.
+exports.UNREVOKE_DELAY = 60 * 60 * 1000;
+// After this many consecutive failures a repo is thrown away and cloned from scratch, which
+// recovers from corruption and interrupted fetches. Counted in checks, so about a quarter hour.
+exports.MAX_REPO_FAILURES_BEFORE_RECLONE = 15;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "04c95747c8ff6d5611015502a598fe430e5fddd148541921318ff8e5ec0cbf25"; */

package/security/authorizedKeys/daemon/dist/repoFiles.ts.cache

@@ -0,0 +1,114 @@
+"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.listRepoDir = exports.readRepoFile = exports.syncRepoFiles = exports.ensureRevokeKey = exports.revokeRepo = exports.sourceRepo = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const revokeSource_1 = require("../revokeSource");
+const sources_1 = require("../sources");
+const git_1 = require("./git");
+function sourceRepo(sourceURL) {
+    return {
+        repoURL: sourceURL,
+        repoPath: (0, sources_1.sourceRepoPath)(sourceURL),
+        keyPath: async () => await (0, sources_1.findSourceKey)(sourceURL) || (0, sources_1.sourceKeyPath)(sourceURL),
+    };
+}
+exports.sourceRepo = sourceRepo;
+function revokeRepo(sourceURL) {
+    return {
+        repoURL: (0, revokeSource_1.revokeRepoURL)(sourceURL),
+        repoPath: (0, revokeSource_1.revokeRepoPath)(sourceURL),
+        keyPath: () => ensureRevokeKey(sourceURL),
+    };
+}
+exports.revokeRepo = revokeRepo;
+/** The revoke repo's key is worked out from the source's, so nothing extra had to be uploaded and
+    nothing extra is stored anywhere it could be taken from. */
+async function ensureRevokeKey(sourceURL) {
+    let existing = await (0, revokeSource_1.findRevokeKey)(sourceURL);
+    if (existing) {
+        return existing;
+    }
+    let sourceKey = await (0, sources_1.findSourceKey)(sourceURL);
+    if (!sourceKey) {
+        throw new Error(`Expected a key for ${sourceURL} at ${(0, sources_1.sourceKeyPath)(sourceURL)}, no such file exists`);
+    }
+    let derived = (0, revokeSource_1.deriveRevokeKey)(await promises_1.default.readFile(sourceKey, "utf8"));
+    let keyPath = (0, revokeSource_1.revokeKeyPath)(sourceURL);
+    await promises_1.default.mkdir(path_1.default.dirname(keyPath), { recursive: true, mode: 0o700 });
+    await promises_1.default.writeFile(keyPath, derived.privateKeyFile, { mode: 0o600 });
+    await promises_1.default.writeFile(`${keyPath}.pub`, `${derived.publicKey} ${revokeSource_1.REVOKE_KEY_LABEL}\n`, { mode: 0o644 });
+    console.log(`Derived the revoke key for ${sourceURL} into ${keyPath}`);
+    return keyPath;
+}
+exports.ensureRevokeKey = ensureRevokeKey;
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** Brings the checkout in line with the remote. Cloned the first time, pulled after that, and the
+    usual case of nothing having changed costs one ref listing and no objects. Throws if the repo
+    cannot be read, so a caller cannot mistake that for an empty repo. */
+async function syncRepoFiles(repo) {
+    let { repoURL, repoPath } = repo;
+    let keyPath = await repo.keyPath();
+    if (!await (0, git_1.repoIsUsable)({ repoPath, keyPath })) {
+        await (0, git_1.cloneRepo)({ repoURL, repoPath, keyPath });
+        return;
+    }
+    let localHead = await (0, git_1.runGit)({ args: ["rev-parse", "HEAD"], cwd: repoPath, keyPath, allowFailure: true });
+    if (localHead.status !== 0) {
+        // A repo with no commits yet, which is the state every revoke repo starts in. There is
+        // nothing to pull and nothing to say.
+        return;
+    }
+    let branch = (await (0, git_1.runGit)({ args: ["rev-parse", "--abbrev-ref", "HEAD"], cwd: repoPath, keyPath })).stdout.trim();
+    let listing = (await (0, git_1.runGit)({ args: ["ls-remote", "origin", branch], cwd: repoPath, keyPath })).stdout;
+    let remoteSha = (listing.split(/\s+/)[0] || "").trim();
+    if (remoteSha && remoteSha === localHead.stdout.trim()) {
+        return;
+    }
+    await (0, git_1.runGit)({ args: ["fetch", "--prune", "origin"], cwd: repoPath, keyPath });
+    await (0, git_1.runGit)({ args: ["reset", "--hard", `origin/${branch}`], cwd: repoPath, keyPath });
+    await (0, git_1.runGit)({ args: ["clean", "-fdx"], cwd: repoPath, keyPath });
+}
+exports.syncRepoFiles = syncRepoFiles;
+/** Throws when there is no checkout at all. "I have never managed to read this repo" and "this
+    repo is empty" are different answers and must not collapse into one. */
+async function requireCheckout(repo) {
+    if (!await pathExists(path_1.default.join(repo.repoPath, ".git"))) {
+        throw new Error(`Expected a checkout of ${repo.repoURL} at ${repo.repoPath}, there is none`);
+    }
+}
+/** One file out of the repo, or undefined if the repo does not have that file. */
+async function readRepoFile(repo, filePath) {
+    await requireCheckout(repo);
+    try {
+        return await promises_1.default.readFile(path_1.default.join(repo.repoPath, filePath), "utf8");
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.readRepoFile = readRepoFile;
+/** The names in one of the repo's directories, or nothing if it has no such directory. */
+async function listRepoDir(repo, directory) {
+    await requireCheckout(repo);
+    try {
+        return (await promises_1.default.readdir(path_1.default.join(repo.repoPath, directory))).sort();
+    }
+    catch (e) {
+        return [];
+    }
+}
+exports.listRepoDir = listRepoDir;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repoFiles.js","sourceRoot":"","sources":["repoFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport path from \"path\";\nimport { deriveRevokeKey, findRevokeKey, REVOKE_KEY_LABEL, revokeKeyPath, revokeRepoPath, revokeRepoURL } from \"../revokeSource\";\nimport { findSourceKey, sourceKeyPath, sourceRepoPath } from \"../sources\";\nimport { cloneRepo, repoIsUsable, runGit } from \"./git\";\n\n/** Reading a repo, made to look like reading a directory. A caller asks for a file and gets its\n    contents; keeping a checkout on disk, cloning it once and pulling it since, is this module's\n    business and nobody else's.\n\n    Nothing here ever answers \"there is nothing\" when the truth is \"I could not look\". A repo that\n    cannot be reached throws, and the caller skips that source, because reading an unreachable\n    revoke repo as empty would un-revoke every key in it. */\nexport type RepoRef = {\n    repoURL: string;\n    repoPath: string;\n    keyPath: () => Promise<string>;\n};\n\nexport function sourceRepo(sourceURL: string): RepoRef {\n    return {\n        repoURL: sourceURL,\n        repoPath: sourceRepoPath(sourceURL),\n        keyPath: async () => await findSourceKey(sourceURL) || sourceKeyPath(sourceURL),\n    };\n}\n\nexport function revokeRepo(sourceURL: string): RepoRef {\n    return {\n        repoURL: revokeRepoURL(sourceURL),\n        repoPath: revokeRepoPath(sourceURL),\n        keyPath: () => ensureRevokeKey(sourceURL),\n    };\n}\n\n/** The revoke repo's key is worked out from the source's, so nothing extra had to be uploaded and\n    nothing extra is stored anywhere it could be taken from. */\nexport async function ensureRevokeKey(sourceURL: string) {\n    let existing = await findRevokeKey(sourceURL);\n    if (existing) {\n        return existing;\n    }\n    let sourceKey = await findSourceKey(sourceURL);\n    if (!sourceKey) {\n        throw new Error(`Expected a key for ${sourceURL} at ${sourceKeyPath(sourceURL)}, no such file exists`);\n    }\n    let derived = deriveRevokeKey(await fs.readFile(sourceKey, \"utf8\"));\n    let keyPath = revokeKeyPath(sourceURL);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await fs.writeFile(keyPath, derived.privateKeyFile, { mode: 0o600 });\n    await fs.writeFile(`${keyPath}.pub`, `${derived.publicKey} ${REVOKE_KEY_LABEL}\\n`, { mode: 0o644 });\n    console.log(`Derived the revoke key for ${sourceURL} into ${keyPath}`);\n    return keyPath;\n}\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/** Brings the checkout in line with the remote. Cloned the first time, pulled after that, and the\n    usual case of nothing having changed costs one ref listing and no objects. Throws if the repo\n    cannot be read, so a caller cannot mistake that for an empty repo. */\nexport async function syncRepoFiles(repo: RepoRef) {\n    let { repoURL, repoPath } = repo;\n    let keyPath = await repo.keyPath();\n    if (!await repoIsUsable({ repoPath, keyPath })) {\n        await cloneRepo({ repoURL, repoPath, keyPath });\n        return;\n    }\n    let localHead = await runGit({ args: [\"rev-parse\", \"HEAD\"], cwd: repoPath, keyPath, allowFailure: true });\n    if (localHead.status !== 0) {\n        // A repo with no commits yet, which is the state every revoke repo starts in. There is\n        // nothing to pull and nothing to say.\n        return;\n    }\n    let branch = (await runGit({ args: [\"rev-parse\", \"--abbrev-ref\", \"HEAD\"], cwd: repoPath, keyPath })).stdout.trim();\n    let listing = (await runGit({ args: [\"ls-remote\", \"origin\", branch], cwd: repoPath, keyPath })).stdout;\n    let remoteSha = (listing.split(/\\s+/)[0] || \"\").trim();\n    if (remoteSha && remoteSha === localHead.stdout.trim()) {\n        return;\n    }\n    await runGit({ args: [\"fetch\", \"--prune\", \"origin\"], cwd: repoPath, keyPath });\n    await runGit({ args: [\"reset\", \"--hard\", `origin/${branch}`], cwd: repoPath, keyPath });\n    await runGit({ args: [\"clean\", \"-fdx\"], cwd: repoPath, keyPath });\n}\n\n/** Throws when there is no checkout at all. \"I have never managed to read this repo\" and \"this\n    repo is empty\" are different answers and must not collapse into one. */\nasync function requireCheckout(repo: RepoRef) {\n    if (!await pathExists(path.join(repo.repoPath, \".git\"))) {\n        throw new Error(`Expected a checkout of ${repo.repoURL} at ${repo.repoPath}, there is none`);\n    }\n}\n\n/** One file out of the repo, or undefined if the repo does not have that file. */\nexport async function readRepoFile(repo: RepoRef, filePath: string) {\n    await requireCheckout(repo);\n    try {\n        return await fs.readFile(path.join(repo.repoPath, filePath), \"utf8\");\n    } catch (e) {\n        return undefined;\n    }\n}\n\n/** The names in one of the repo's directories, or nothing if it has no such directory. */\nexport async function listRepoDir(repo: RepoRef, directory: string) {\n    await requireCheckout(repo);\n    try {\n        return (await fs.readdir(path.join(repo.repoPath, directory))).sort();\n    } catch (e) {\n        return [];\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "7340581691819b6036825721d39ae6393118181e0730254e1cead9650e3aa91e"; */