sliftutils 1.7.125 → 1.7.126

package/security/authorizedKeys/dist/sources.ts.cache

@@ -0,0 +1,24 @@
+"use strict";
+// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js contains a plain JS port of everything here, so it can
+// resolve the same locations with no dependencies. Both sides must derive identical paths from a
+// repo url - if you change one, make the matching change in the other.
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.sourceRepoPath = exports.sourceKeyPath = exports.sourceName = exports.REPOS_DIR = exports.REPO_KEYS_DIR = void 0;
+exports.REPO_KEYS_DIR = "/etc/portsecure/repo-keys";
+exports.REPOS_DIR = "/var/lib/portsecure/authorized-keys-repos";
+/** A repo url reduced to something usable as a file name. Derived rather than configured, so the
+    daemon and the deploy script always agree on where a source's key and checkout live. */
+function sourceName(repoURL) {
+    return repoURL.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+exports.sourceName = sourceName;
+function sourceKeyPath(repoURL) {
+    return `${exports.REPO_KEYS_DIR}/${sourceName(repoURL)}`;
+}
+exports.sourceKeyPath = sourceKeyPath;
+function sourceRepoPath(repoURL) {
+    return `${exports.REPOS_DIR}/${sourceName(repoURL)}`;
+}
+exports.sourceRepoPath = sourceRepoPath;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "d4a51163d16ac57a8fa5966ca3b09eaebcbef4ca2200c706a7e125220c7db7b8"; */

package/security/authorizedKeys/dist/unrevoke.ts.cache

@@ -0,0 +1,145 @@
+"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.main = exports.revokedKeysInRepo = exports.readRemoteRevocations = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const runPromise_1 = require("socket-function/src/runPromise");
+const authorizedKeys_1 = require("./authorizedKeys");
+const revokeSource_1 = require("./revokeSource");
+const authorizedKeys_2 = require("./authorizedKeys");
+const paths_1 = require("../helpers/paths");
+const spawn_1 = require("../helpers/spawn");
+const UNREVOKES_DIR = "unrevoked";
+const REVOCATIONS_DIR = "revocations";
+const USAGE = `Usage: yarn unrevoke [keys-repo]
+
+Run this in a keys repo, or name one. It reads that repo's revoke repo and writes one unrevoke file
+naming every revocation in it, so the keys are accepted again once each machine's hour long wait
+passes.
+
+Keys that were revoked should normally be deleted from the repo instead. Unrevoking only matters
+for a key you still want.`;
+/** Every revocation the revoke repo lists. Cloned read only into a temp directory, with whatever
+    credentials this machine already has - the derived deploy key is for servers, and a person
+    running this has their own access to the repo. */
+async function readRemoteRevocations(config) {
+    let { sourceURL } = config;
+    let temporaryDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "unrevoke-"));
+    let repoPath = path_1.default.join(temporaryDirectory, "repo");
+    let clone = await (0, spawn_1.spawnPromise)({
+        command: "git",
+        args: ["clone", "--depth", "1", (0, revokeSource_1.revokeRepoURL)(sourceURL), repoPath],
+    });
+    if (clone.status !== 0) {
+        await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+        throw new Error(`Expected to be able to read ${(0, revokeSource_1.revokeRepoURL)(sourceURL)}.\n`
+            + `${(clone.stdout + clone.stderr).trim()}`);
+    }
+    let revocations = [];
+    let directory = path_1.default.join(repoPath, REVOCATIONS_DIR);
+    try {
+        for (let name of (await promises_1.default.readdir(directory)).sort()) {
+            if (name.endsWith(".json")) {
+                revocations.push(JSON.parse(await promises_1.default.readFile(path_1.default.join(directory, name), "utf8")));
+            }
+        }
+    }
+    catch (e) {
+        // No revocations directory at all just means nothing has ever been revoked.
+    }
+    await promises_1.default.rm(temporaryDirectory, { recursive: true, force: true });
+    return revocations;
+}
+exports.readRemoteRevocations = readRemoteRevocations;
+/** Which keys in a repo are revoked. What signfiles and securessh refuse over. */
+async function revokedKeysInRepo(config) {
+    let { repoPath, sourceURL } = config;
+    let revocations = await readRemoteRevocations({ sourceURL });
+    let revokedFingerprints = new Set(revocations.map(revocation => revocation.fingerprint));
+    let unrevoked = new Set();
+    try {
+        let directory = path_1.default.join(repoPath, UNREVOKES_DIR);
+        for (let name of await promises_1.default.readdir(directory)) {
+            if (!name.endsWith(".json")) {
+                continue;
+            }
+            let parsed = JSON.parse(await promises_1.default.readFile(path_1.default.join(directory, name), "utf8"));
+            for (let revocationId of parsed.revocationIds || []) {
+                unrevoked.add(revocationId);
+            }
+        }
+    }
+    catch (e) {
+        // Nothing has been unrevoked.
+    }
+    let stillRevoked = revocations.filter(revocation => !unrevoked.has(revocation.revocationId));
+    let keys = (0, authorizedKeys_1.normalizeKeys)(await promises_1.default.readFile(path_1.default.join(repoPath, "authorized_keys"), "utf8").catch(() => ""));
+    return stillRevoked
+        .filter(revocation => keys.some(key => (0, authorizedKeys_1.keyFingerprint)(key) === revocation.fingerprint))
+        .map(revocation => ({ revocation, key: keys.find(key => (0, authorizedKeys_1.keyFingerprint)(key) === revocation.fingerprint) || "" }));
+}
+exports.revokedKeysInRepo = revokedKeysInRepo;
+/** The repo named, or the one we are standing in. Checked the same way securessh checks it: a git
+    repo that actually holds keys and has an origin to clone from. */
+async function resolveKeysRepo(named) {
+    let cwd = named && (0, paths_1.expandHome)(named) || undefined;
+    let repoPath = (await (0, runPromise_1.runPromise)("git rev-parse --show-toplevel", { quiet: true, cwd })).trim();
+    if (!repoPath) {
+        throw new Error(`Expected ${named || "the current directory"} to be inside a git repo, it is not.\n${USAGE}`);
+    }
+    try {
+        await (0, authorizedKeys_2.readRepoKeys)(repoPath);
+    }
+    catch (e) {
+        throw new Error(`Expected ${repoPath} to be a keys repo, it holds no keys.\n${e}\n${USAGE}`);
+    }
+    let originURL = (await (0, runPromise_1.runPromise)("git remote get-url origin", { quiet: true, cwd: repoPath })).trim();
+    if (!originURL) {
+        throw new Error(`Expected ${repoPath} to have an origin remote, it has none.\n${USAGE}`);
+    }
+    return { repoPath, originURL };
+}
+async function main() {
+    var _a;
+    let argv = process.argv.slice(2);
+    if (argv.length > 1) {
+        throw new Error(`Expected at most a keys repo, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let { repoPath, originURL } = await resolveKeysRepo(argv[0]);
+    let revocations = await readRemoteRevocations({ sourceURL: originURL });
+    if (!revocations.length) {
+        console.log(`${(0, revokeSource_1.revokeRepoURL)(originURL)} lists no revocations, so there is nothing to undo.`);
+        return;
+    }
+    let directory = path_1.default.join(repoPath, UNREVOKES_DIR);
+    await promises_1.default.mkdir(directory, { recursive: true });
+    let stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    let unrevokeId = `${stamp}-unrevoke`;
+    await promises_1.default.writeFile(path_1.default.join(directory, `${unrevokeId}.json`), JSON.stringify({
+        unrevokeId,
+        createdAt: new Date().toISOString(),
+        // Named one by one rather than as a blanket "allow everything again", so this file only
+        // ever undoes the revocations that existed when it was written.
+        revocationIds: revocations.map(revocation => revocation.revocationId),
+        revocations: revocations.map(revocation => ({
+            revocationId: revocation.revocationId,
+            fingerprint: revocation.fingerprint,
+            revokedAt: revocation.revokedAt,
+            revokedBy: revocation.revokedBy,
+            attempt: revocation.attempt,
+        })),
+    }, undefined, 4) + "\n");
+    console.log(`Wrote ${UNREVOKES_DIR}/${unrevokeId}.json covering ${revocations.length} revocation(s):`);
+    for (let revocation of revocations) {
+        console.log(`  ${revocation.fingerprint} revoked by ${revocation.revokedBy || "?"} from ${((_a = revocation.attempt) === null || _a === void 0 ? void 0 : _a.ip) || "?"}`);
+    }
+    console.log(`Each machine waits an hour after seeing it before the keys work again.`);
+    console.log(`Sign and publish it with:\n  yarn signfiles git`);
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unrevoke.js","sourceRoot":"","sources":["unrevoke.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { runPromise } from \"socket-function/src/runPromise\";\nimport { keyFingerprint, normalizeKeys } from \"./authorizedKeys\";\nimport { revokeRepoURL } from \"./revokeSource\";\nimport { readRepoKeys } from \"./authorizedKeys\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\n\nconst UNREVOKES_DIR = \"unrevoked\";\nconst REVOCATIONS_DIR = \"revocations\";\nconst USAGE = `Usage: yarn unrevoke [keys-repo]\n\nRun this in a keys repo, or name one. It reads that repo's revoke repo and writes one unrevoke file\nnaming every revocation in it, so the keys are accepted again once each machine's hour long wait\npasses.\n\nKeys that were revoked should normally be deleted from the repo instead. Unrevoking only matters\nfor a key you still want.`;\n\nexport type Revocation = {\n    revocationId: string;\n    fingerprint: string;\n    key?: string;\n    revokedAt?: string;\n    revokedBy?: string;\n    attempt?: { ip?: string; user?: string; required?: string };\n};\n\n/** Every revocation the revoke repo lists. Cloned read only into a temp directory, with whatever\n    credentials this machine already has - the derived deploy key is for servers, and a person\n    running this has their own access to the repo. */\nexport async function readRemoteRevocations(config: { sourceURL: string }) {\n    let { sourceURL } = config;\n    let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"unrevoke-\"));\n    let repoPath = path.join(temporaryDirectory, \"repo\");\n    let clone = await spawnPromise({\n        command: \"git\",\n        args: [\"clone\", \"--depth\", \"1\", revokeRepoURL(sourceURL), repoPath],\n    });\n    if (clone.status !== 0) {\n        await fs.rm(temporaryDirectory, { recursive: true, force: true });\n        throw new Error(\n            `Expected to be able to read ${revokeRepoURL(sourceURL)}.\\n`\n            + `${(clone.stdout + clone.stderr).trim()}`\n        );\n    }\n    let revocations: Revocation[] = [];\n    let directory = path.join(repoPath, REVOCATIONS_DIR);\n    try {\n        for (let name of (await fs.readdir(directory)).sort()) {\n            if (name.endsWith(\".json\")) {\n                revocations.push(JSON.parse(await fs.readFile(path.join(directory, name), \"utf8\")));\n            }\n        }\n    } catch (e) {\n        // No revocations directory at all just means nothing has ever been revoked.\n    }\n    await fs.rm(temporaryDirectory, { recursive: true, force: true });\n    return revocations;\n}\n\n/** Which keys in a repo are revoked. What signfiles and securessh refuse over. */\nexport async function revokedKeysInRepo(config: { repoPath: string; sourceURL: string }) {\n    let { repoPath, sourceURL } = config;\n    let revocations = await readRemoteRevocations({ sourceURL });\n    let revokedFingerprints = new Set(revocations.map(revocation => revocation.fingerprint));\n    let unrevoked = new Set<string>();\n    try {\n        let directory = path.join(repoPath, UNREVOKES_DIR);\n        for (let name of await fs.readdir(directory)) {\n            if (!name.endsWith(\".json\")) {\n                continue;\n            }\n            let parsed = JSON.parse(await fs.readFile(path.join(directory, name), \"utf8\"));\n            for (let revocationId of parsed.revocationIds || []) {\n                unrevoked.add(revocationId);\n            }\n        }\n    } catch (e) {\n        // Nothing has been unrevoked.\n    }\n    let stillRevoked = revocations.filter(revocation => !unrevoked.has(revocation.revocationId));\n    let keys = normalizeKeys(await fs.readFile(path.join(repoPath, \"authorized_keys\"), \"utf8\").catch(() => \"\"));\n    return stillRevoked\n        .filter(revocation => keys.some(key => keyFingerprint(key) === revocation.fingerprint))\n        .map(revocation => ({ revocation, key: keys.find(key => keyFingerprint(key) === revocation.fingerprint) || \"\" }));\n}\n\n/** The repo named, or the one we are standing in. Checked the same way securessh checks it: a git\n    repo that actually holds keys and has an origin to clone from. */\nasync function resolveKeysRepo(named: string | undefined) {\n    let cwd = named && expandHome(named) || undefined;\n    let repoPath = (await runPromise(\"git rev-parse --show-toplevel\", { quiet: true, cwd })).trim();\n    if (!repoPath) {\n        throw new Error(`Expected ${named || \"the current directory\"} to be inside a git repo, it is not.\\n${USAGE}`);\n    }\n    try {\n        await readRepoKeys(repoPath);\n    } catch (e) {\n        throw new Error(`Expected ${repoPath} to be a keys repo, it holds no keys.\\n${e}\\n${USAGE}`);\n    }\n    let originURL = (await runPromise(\"git remote get-url origin\", { quiet: true, cwd: repoPath })).trim();\n    if (!originURL) {\n        throw new Error(`Expected ${repoPath} to have an origin remote, it has none.\\n${USAGE}`);\n    }\n    return { repoPath, originURL };\n}\n\nexport async function main() {\n    let argv = process.argv.slice(2);\n    if (argv.length > 1) {\n        throw new Error(`Expected at most a keys repo, was ${argv.length} argument(s)\\n${USAGE}`);\n    }\n    let { repoPath, originURL } = await resolveKeysRepo(argv[0]);\n\n    let revocations = await readRemoteRevocations({ sourceURL: originURL });\n    if (!revocations.length) {\n        console.log(`${revokeRepoURL(originURL)} lists no revocations, so there is nothing to undo.`);\n        return;\n    }\n\n    let directory = path.join(repoPath, UNREVOKES_DIR);\n    await fs.mkdir(directory, { recursive: true });\n    let stamp = new Date().toISOString().replace(/[:.]/g, \"-\");\n    let unrevokeId = `${stamp}-unrevoke`;\n    await fs.writeFile(path.join(directory, `${unrevokeId}.json`), JSON.stringify({\n        unrevokeId,\n        createdAt: new Date().toISOString(),\n        // Named one by one rather than as a blanket \"allow everything again\", so this file only\n        // ever undoes the revocations that existed when it was written.\n        revocationIds: revocations.map(revocation => revocation.revocationId),\n        revocations: revocations.map(revocation => ({\n            revocationId: revocation.revocationId,\n            fingerprint: revocation.fingerprint,\n            revokedAt: revocation.revokedAt,\n            revokedBy: revocation.revokedBy,\n            attempt: revocation.attempt,\n        })),\n    }, undefined, 4) + \"\\n\");\n\n    console.log(`Wrote ${UNREVOKES_DIR}/${unrevokeId}.json covering ${revocations.length} revocation(s):`);\n    for (let revocation of revocations) {\n        console.log(`  ${revocation.fingerprint} revoked by ${revocation.revokedBy || \"?\"} from ${revocation.attempt?.ip || \"?\"}`);\n    }\n    console.log(`Each machine waits an hour after seeing it before the keys work again.`);\n    console.log(`Sign and publish it with:\\n  yarn signfiles git`);\n}\n"]}
+ /* _JS_SOURCE_HASH = "1f43574c62196a1eb6f7594da6497ffb17128b3c8914274f810f020ee0cc4224"; */

package/security/authorizedKeys/revokeSource.ts

@@ -0,0 +1,40 @@
+import { deriveEd25519Key } from "../keys/deriveKey";
+import { formatOpenSSHPrivateKey, parseOpenSSHPrivateKey } from "../keys/sshKeyFile";
+import { REPO_KEYS_DIR, REPOS_DIR, sourceName } from "./sources";
+
+// A source's revocations live in a repo beside it. Derived rather than configured, so adding a
+// source brings its revoke repo with it and there is nothing extra to pass on the command line.
+const REVOKED_SUFFIX = "_revoked";
+// GitHub will not take the same public key as a deploy key on two repos, so the revoke repo is
+// reached with a key derived from the source's, under this label.
+export const REVOKE_KEY_LABEL = "revokegithubkey";
+
+export function revokeRepoURL(sourceURL: string) {
+    let withoutGit = sourceURL.replace(/\.git$/, "");
+    return `${withoutGit}${REVOKED_SUFFIX}.git`;
+}
+
+export function revokeKeyPath(sourceURL: string) {
+    return `${REPO_KEYS_DIR}/${sourceName(sourceURL)}${REVOKED_SUFFIX}`;
+}
+
+export function revokeRepoPath(sourceURL: string) {
+    return `${REPOS_DIR}/${sourceName(sourceURL)}${REVOKED_SUFFIX}`;
+}
+
+/** The revoke repo's key, worked out from the source repo's key. Anything holding the source key
+    can produce it, so it never has to be stored anywhere separately or handed around. */
+export function deriveRevokeKey(sourcePrivateKey: string) {
+    let source = parseOpenSSHPrivateKey(sourcePrivateKey);
+    let derived = deriveEd25519Key({ seed: source.seed, label: REVOKE_KEY_LABEL });
+    return {
+        publicKey: `ssh-ed25519 ${Buffer.concat([
+            Buffer.from([0, 0, 0, 11]), Buffer.from("ssh-ed25519"),
+            Buffer.from([0, 0, 0, 32]), derived.publicKey,
+        ]).toString("base64")}`,
+        privateKeyFile: formatOpenSSHPrivateKey({
+            seed: derived.seed,
+            comment: `${source.comment || "portsecure"} ${REVOKE_KEY_LABEL}`,
+        }),
+    };
+}

package/security/authorizedKeys/secureSSH.ts

@@ -4,24 +4,30 @@ import path from "path";
 import { DEFAULT_WEBHOOK_FILE_PATH, parseWebhookFile } from "../notifications/discord";
 import { normalizeKeys, readRepoKeys, summarizeKey } from "./authorizedKeys";
 import { sourceKeyPath, sourceRepoPath } from "./sources";
+import { deriveRevokeKey, REVOKE_KEY_LABEL, revokeRepoURL } from "./revokeSource";
+import { revokedKeysInRepo } from "./unrevoke";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
 import { readRemoteFile, remoteCommandExists, runOverSSH, SUDO_PREAMBLE, writeRemoteFile } from "../helpers/remoteSSH";
 
-const DAEMON_SOURCE = path.join(__dirname, "daemon", "portsecureDaemon.js");
 const SERVICE_SOURCE = path.join(__dirname, "daemon", "portsecure.service");
-const REMOTE_DAEMON_PATH = "/opt/portsecure/portsecure-daemon.js";
+// The daemon runs from a checkout of this repo on the host, rather than from a copy we upload, so
+// a host updates itself from github the same way anything else does. sliftutils is public, so this
+// needs no key.
+const SLIFTUTILS_URL = "https://github.com/sliftist/sliftutils.git";
+const REMOTE_CHECKOUT_PATH = "/opt/portsecure/sliftutils";
 const REMOTE_SERVICE_PATH = "/etc/systemd/system/portsecure.service";
 const REMOTE_CONFIG_PATH = "/etc/portsecure/daemon.json";
 const ROOT_AUTHORIZED_KEYS = "/root/.ssh/authorized_keys";
 const SERVICE_NAME = "portsecure";
 const MAX_ERROR_BODY_LENGTH = 500;
-const VERBS = ["add", "remove", "list"];
+const VERBS = ["add", "remove", "list", "update"];
 // The repo url is optional, and defaults to the repo the command is run from.
 const USAGE = `Usage:
   yarn securessh <host> add <repo-private-key> [repo-url]
   yarn securessh <host> remove [repo-url]
-  yarn securessh <host> list`;
+  yarn securessh <host> list
+  yarn securessh <host> update`;
 
 async function pathExists(filePath: string) {
     try {
@@ -41,7 +47,7 @@ async function runLocal(config: { command: string; args: string[]; cwd?: string;
     if (result.status !== 0 && !allowFailure) {
         throw new Error(
             `Expected ${command} ${args.join(" ")} to exit 0, was ${result.status}. `
-            + `${(result.stderr || "").slice(0, MAX_ERROR_BODY_LENGTH)}`
+            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
         );
     }
     return result;
@@ -69,7 +75,7 @@ async function gitWithKey(config: { keyPath: string; args: string[]; cwd?: strin
     if (result.status !== 0 && !allowFailure) {
         throw new Error(
             `Expected git ${args.join(" ")} to exit 0, was ${result.status}. `
-            + `${(result.stderr || "").slice(0, MAX_ERROR_BODY_LENGTH)}`
+            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
         );
     }
     return result;
@@ -158,6 +164,101 @@ async function resolveRepoURL(passedURL: string | undefined) {
     return repoURL;
 }
 
+/** Every source's revoke repo has to exist and hold at least one commit, or the hosts using it
+    cannot record a revocation. Checked with this machine's own git credentials, since update is
+    not given any deploy key, and an empty repo is initialised rather than merely complained about.
+
+    A host that cannot write a revocation silently keeps accepting a key it just saw being misused,
+    which is the one failure this whole thing exists to prevent, so it is checked on every deploy
+    and not only when a source is first added. */
+async function ensureRevokeReposExist(repoSources: string[]) {
+    for (let repoURL of repoSources) {
+        let revokeURL = revokeRepoURL(repoURL);
+        let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "portsecure-revoke-"));
+        let checkoutPath = path.join(temporaryDirectory, "repo");
+        let clone = await runLocal({ command: "git", args: ["clone", revokeURL, checkoutPath], allowFailure: true });
+        if (clone.status !== 0) {
+            await fs.rm(temporaryDirectory, { recursive: true, force: true });
+            throw new Error(
+                `Expected ${revokeURL} to exist, it does not, so ${repoURL} has nowhere to record a`
+                + ` revocation.\nCreate it, then run "yarn securessh <host> add" for that source to`
+                + ` register its deploy key.\n${(clone.stdout + clone.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
+            );
+        }
+        let head = await runLocal({ command: "git", args: ["-C", checkoutPath, "rev-parse", "HEAD"], allowFailure: true });
+        if (head.status !== 0) {
+            console.log(`${revokeURL} is empty, giving it a first commit`);
+            await fs.writeFile(path.join(checkoutPath, "README.md"),
+                `# revoked keys\n\nWritten by portsecure. Each file under revocations/ is one key that was used from an\n`
+                + `address it is not allowed from, and is no longer accepted anywhere.\n`);
+            for (let args of [
+                ["-C", checkoutPath, "add", "-A"],
+                ["-C", checkoutPath, "-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", "initialise revoke repo"],
+                ["-C", checkoutPath, "push", "origin", "HEAD"],
+            ]) {
+                await runLocal({ command: "git", args });
+            }
+        }
+        await fs.rm(temporaryDirectory, { recursive: true, force: true });
+        console.log(`${revokeURL} is ready`);
+    }
+}
+
+/** The revoke repo has to exist and be writable before a host is set up, because a host that
+    cannot write a revocation cannot revoke a key that is being misused. The key for it is derived
+    from the source's, since github will not take one public key on two repos. */
+async function ensureRevokeRepo(config: { keyPath: string; repoURL: string }) {
+    let { keyPath, repoURL } = config;
+    let revokeURL = revokeRepoURL(repoURL);
+    let derived = deriveRevokeKey(await fs.readFile(keyPath, "utf8"));
+
+    let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "portsecure-revoke-"));
+    let derivedKeyPath = path.join(temporaryDirectory, "key");
+    await fs.writeFile(derivedKeyPath, derived.privateKeyFile, { mode: 0o600 });
+    let checkoutPath = path.join(temporaryDirectory, "repo");
+
+    let explain = (problem: string) => new Error(
+        `${problem}\n`
+        + `Create ${revokeURL} and add this as a deploy key WITH WRITE ACCESS:\n`
+        + `  ${derived.publicKey} ${REVOKE_KEY_LABEL}\n`
+        + `It has to be this key: it is derived from ${keyPath}, and github will not accept the same`
+        + ` public key on two repositories.`
+    );
+
+    console.log(`Checking ${revokeURL}`);
+    let clone = await gitWithKey({ keyPath: derivedKeyPath, args: ["clone", revokeURL, checkoutPath], allowFailure: true });
+    if (clone.status !== 0) {
+        throw explain(`Expected ${revokeURL} to be readable with the derived key, it is not.`);
+    }
+
+    // An empty repo has no branch for the daemon to clone, so it gets its first commit here. That
+    // doubles as the proof that we can write to it.
+    let head = await gitWithKey({ keyPath: derivedKeyPath, args: ["rev-parse", "HEAD"], cwd: checkoutPath, allowFailure: true });
+    if (head.status !== 0) {
+        await fs.writeFile(path.join(checkoutPath, "README.md"),
+            `# revoked keys\n\nWritten by portsecure. Each file under revocations/ is one key that was used from an\n`
+            + `address it is not allowed from, and is no longer accepted anywhere.\n`);
+        for (let args of [
+            ["add", "-A"],
+            ["-c", "user.email=portsecure@localhost", "-c", "user.name=portsecure", "commit", "-m", "initialise revoke repo"],
+        ]) {
+            await gitWithKey({ keyPath: derivedKeyPath, args, cwd: checkoutPath });
+        }
+        let push = await gitWithKey({ keyPath: derivedKeyPath, args: ["push", "origin", "HEAD"], cwd: checkoutPath, allowFailure: true });
+        if (push.status !== 0) {
+            throw explain(`Expected write access to ${revokeURL}, the first push was refused.\n${(push.stdout + push.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+        }
+    } else {
+        let dryRun = await gitWithKey({ keyPath: derivedKeyPath, args: ["push", "--dry-run", "origin", "HEAD"], cwd: checkoutPath, allowFailure: true });
+        if (dryRun.status !== 0) {
+            throw explain(`Expected write access to ${revokeURL}, a dry run push was refused.\n${(dryRun.stdout + dryRun.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
+        }
+    }
+
+    await fs.rm(temporaryDirectory, { recursive: true, force: true });
+    console.log(`${revokeURL} is writable`);
+}
+
 async function readRemoteConfig(host: string) {
     let contents = await readRemoteFile({ host, filePath: REMOTE_CONFIG_PATH });
     if (!contents) {
@@ -187,11 +288,31 @@ fi`,
 
 async function installDaemon(config: { host: string; hostLabel: string; repoSources: string[] }) {
     let { host, hostLabel, repoSources } = config;
-    for (let command of ["node", "git"]) {
+    for (let command of ["node", "git", "yarn"]) {
         if (!await remoteCommandExists({ host, command })) {
             throw new Error(`Expected ${command} to be installed on ${host}, it is not. Install it and rerun.`);
         }
     }
+
+    // The checkout is brought to the latest commit rather than a copy being pushed, so what runs on
+    // the host is exactly what is on github.
+    console.log(`Updating ${REMOTE_CHECKOUT_PATH} on ${host}`);
+    await runOverSSH({
+        host,
+        script: `${SUDO_PREAMBLE}
+set -e
+$SUDO mkdir -p "${path.posix.dirname(REMOTE_CHECKOUT_PATH)}"
+if $SUDO test -d "${REMOTE_CHECKOUT_PATH}/.git"; then
+    $SUDO git -C "${REMOTE_CHECKOUT_PATH}" fetch --prune origin
+    $SUDO git -C "${REMOTE_CHECKOUT_PATH}" reset --hard origin/HEAD
+else
+    $SUDO rm -rf "${REMOTE_CHECKOUT_PATH}"
+    $SUDO git clone "${SLIFTUTILS_URL}" "${REMOTE_CHECKOUT_PATH}"
+fi
+$SUDO yarn --cwd "${REMOTE_CHECKOUT_PATH}" install --production --non-interactive
+# The single file daemon this replaced, left over on a host set up by an older version.
+$SUDO rm -f /opt/portsecure/portsecure-daemon.js`,
+    });
     await writeRemoteFile({
         host,
         filePath: REMOTE_CONFIG_PATH,
@@ -201,13 +322,6 @@ async function installDaemon(config: { host: string; hostLabel: string; repoSour
         fileMode: "600",
         directoryMode: "700",
     });
-    await writeRemoteFile({
-        host,
-        filePath: REMOTE_DAEMON_PATH,
-        contents: await fs.readFile(DAEMON_SOURCE, "utf8"),
-        fileMode: "755",
-        directoryMode: "755",
-    });
     await writeRemoteFile({
         host,
         filePath: REMOTE_SERVICE_PATH,
@@ -271,7 +385,8 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
     if (reachable.status !== 0) {
         throw new Error(
             `Expected ${repoURL} to be reachable with ${keyPath}, git ls-remote failed.`
-            + ` The daemon would have no way to fetch keys.\n${reachable.stderr.slice(0, MAX_ERROR_BODY_LENGTH)}`
+            + ` The daemon would have no way to fetch keys.\n`
+            + `${(reachable.stdout + reachable.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
         );
     }
 
@@ -299,6 +414,19 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
     }
     console.log(`Our key ${ourFingerprint} is in the merged keys, access will survive.`);
 
+    await ensureRevokeRepo({ keyPath, repoURL });
+
+    // Deploying a repo that still holds a revoked key would hand it back to every machine.
+    let revoked = await revokedKeysInRepo({ repoPath: inspectionPath, sourceURL: repoURL });
+    if (revoked.length) {
+        throw new Error(
+            `Expected ${repoURL} to hold no revoked keys, it holds ${revoked.length}:\n`
+            + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by`
+                + ` ${entry.revocation.revokedBy || "?"} after use from ${entry.revocation.attempt?.ip || "?"}`).join("\n")
+            + `\nDelete them from the repo, or run "yarn unrevoke" there to allow them again.`
+        );
+    }
+
     let webhookURL = await requireRemoteWebhook(host);
     console.log(`${host} notifies ${webhookURL}`);
 
@@ -362,6 +490,57 @@ $SUDO rm -rf "${sourceRepoPath(repoURL)}"`,
 
 /** Answers "who can log into this box, and which repo says so". The paths the daemon uses are
     left out on purpose, they are plumbing rather than something to act on. */
+/** The daemon is installed from this checkout, so the checkout is brought up to date first.
+    Anything that stops the pull - a conflict, local commits, no upstream - stops the update too,
+    rather than quietly installing whatever happened to be on disk. */
+async function pullLocalCheckout() {
+    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"], cwd: __dirname });
+    if (topLevel.status !== 0) {
+        throw new Error(
+            `Expected ${__dirname} to be inside a git checkout, it is not.`
+            + ` update installs the daemon from this checkout, so it has to be one.`
+        );
+    }
+    let repoPath = topLevel.stdout.trim();
+    let pull = await spawnPromise({ command: "git", args: ["pull", "--ff-only"], cwd: repoPath });
+    if (pull.status !== 0) {
+        throw new Error(
+            `Expected git pull in ${repoPath} to succeed, it did not, so nothing was installed.\n`
+            + `${(pull.stdout + pull.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`
+        );
+    }
+    // The host installs from github, not from here, so local commits that have not been pushed
+    // are not what it will run.
+    let local = await spawnPromise({ command: "git", args: ["rev-parse", "HEAD"], cwd: repoPath });
+    let remote = await spawnPromise({ command: "git", args: ["rev-parse", "@{u}"], cwd: repoPath });
+    if (local.stdout.trim() !== remote.stdout.trim()) {
+        console.log(`WARNING: ${repoPath} has commits that are not pushed. The host installs from github,`);
+        console.log(`         so it will run the pushed version, not what is here.`);
+    }
+    console.log(`Pulled ${repoPath}`);
+}
+
+/** Pushes the current daemon onto a host that already has one, for when this code has moved on.
+    Nothing about which keys the host trusts is touched. */
+async function updateDaemon(host: string) {
+    // Pulled before anything else, so a checkout that cannot be brought up to date fails here
+    // rather than after we have already started changing the host.
+    await pullLocalCheckout();
+    let contents = await readRemoteFile({ host, filePath: REMOTE_CONFIG_PATH });
+    if (!contents) {
+        throw new Error(
+            `Expected ${host} to already have portsecure, ${REMOTE_CONFIG_PATH} does not exist.\n`
+            + `Set it up with:\n  yarn securessh ${host} add <repo-private-key> [repo-url]`
+        );
+    }
+    let parsed = JSON.parse(contents) as { hostLabel?: string; repoSources?: string[] };
+    let repoSources = parsed.repoSources || [];
+    await requireRemoteWebhook(host);
+    await ensureRevokeReposExist(repoSources);
+    await installDaemon({ host, hostLabel: parsed.hostLabel || host, repoSources });
+    console.log(`Updated the daemon on ${host}. ${repoSources.length} source(s), unchanged.`);
+}
+
 async function listSources(host: string) {
     let remoteConfig = await readRemoteConfig(host);
     if (!remoteConfig.repoSources.length) {
@@ -413,6 +592,13 @@ export async function main() {
         await listSources(host);
         return;
     }
+    if (verb === "update") {
+        if (rest.length) {
+            throw new Error(`Expected nothing after update, was ${rest.length} argument(s)\n${USAGE}`);
+        }
+        await updateDaemon(host);
+        return;
+    }
     if (verb === "add") {
         if (!rest.length || rest.length > 2) {
             throw new Error(`Expected a private key and optionally a repo url, was ${rest.length} argument(s)\n${USAGE}`);