sliftutils 1.7.125 → 1.7.127

package/security/signedFiles/dist/signFiles.ts.cache

@@ -0,0 +1,181 @@
+"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.signRepo = 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 paths_1 = require("../helpers/paths");
+const spawn_1 = require("../helpers/spawn");
+const manifest_1 = require("./manifest");
+const unrevoke_1 = require("../authorizedKeys/unrevoke");
+const authorizedKeys_1 = require("../authorizedKeys/authorizedKeys");
+// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the
+// machine is, and then the signature proves nothing, so this is what we make when asked to make one.
+const DEFAULT_KEY_TYPE = "ed25519-sk";
+const DEFAULT_KEY_PATH = "~/.ssh/signfiles_ed25519_sk";
+const GIT_KEYWORD = "git";
+const COMMIT_MESSAGE = "deploying signed files";
+const MAX_ERROR_BODY_LENGTH = 500;
+const USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]
+
+Signs the files of the repo in the current directory. With no key, a hardware backed
+${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.
+Pass ${GIT_KEYWORD} to also commit and push the result.`;
+/** runPromise takes a command line rather than an argument list, so anything holding a path has to
+    survive the shell. Double quotes work on both cmd and posix shells. */
+function quote(value) {
+    return `"${value}"`;
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** Creating this needs the security key plugged in, and a touch. */
+async function ensureDefaultKey() {
+    let keyPath = (0, paths_1.expandHome)(DEFAULT_KEY_PATH);
+    if (await pathExists(keyPath)) {
+        return keyPath;
+    }
+    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);
+    console.log(`Plug your security key in - you will be asked to touch it.`);
+    await promises_1.default.mkdir(path_1.default.dirname(keyPath), { recursive: true, mode: 0o700 });
+    await (0, runPromise_1.runPromise)(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N "" -C signfiles`);
+    return keyPath;
+}
+/** The public key in the form the daemon reports it, so what is printed here can be compared
+    against what arrives on Discord. */
+async function publicKeyOf(keyPath) {
+    let contents = await promises_1.default.readFile(`${keyPath}.pub`, "utf8");
+    let [keyType, keyBody] = contents.trim().split(/\s+/);
+    if (!keyType || !keyBody) {
+        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return `${keyType} ${keyBody}`;
+}
+/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it
+    is signed. Signing anything that is not a keys repo is none of this function's business. */
+async function refuseUnusableKeys(repoPath) {
+    let authorizedPath = path_1.default.join(repoPath, "authorized_keys");
+    if (!await pathExists(authorizedPath)) {
+        return;
+    }
+    let problems = (0, authorizedKeys_1.findKeyProblems)((0, authorizedKeys_1.normalizeKeys)(await promises_1.default.readFile(authorizedPath, "utf8")));
+    if (!problems.length) {
+        return;
+    }
+    throw new Error(`Expected every key in ${authorizedPath} to be restricted and to belong to one person,`
+        + ` found ${problems.length} problem(s):\n`
+        + problems.map(problem => `  - ${problem}`).join("\n")
+        + `\n\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`
+        + `\nname the same ones. Revoking a key that shares its addresses with another leaves that`
+        + `\nother key working, which defeats the point of revoking it.`);
+}
+/** Signing a keys repo that still holds a revoked key would publish it back to every machine that
+    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing
+    anything else is none of this function's business. */
+async function refuseRevokedKeys(repoPath) {
+    if (!await pathExists(path_1.default.join(repoPath, "authorized_keys"))) {
+        return;
+    }
+    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.
+    let origin = await (0, spawn_1.spawnPromise)({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
+    let originURL = origin.stdout.trim();
+    if (origin.status !== 0 || !originURL) {
+        return;
+    }
+    let revoked;
+    try {
+        revoked = await (0, unrevoke_1.revokedKeysInRepo)({ repoPath, sourceURL: originURL });
+    }
+    catch (e) {
+        // No revoke repo, or no access to it. Nothing has been revoked that we can see.
+        return;
+    }
+    if (!revoked.length) {
+        return;
+    }
+    throw new Error(`Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\n`
+        + revoked.map(entry => {
+            var _a;
+            return `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || "?"}`
+                + ` after use from ${((_a = entry.revocation.attempt) === null || _a === void 0 ? void 0 : _a.ip) || "?"}`;
+        }).join("\n")
+        + `\nDelete them from authorized_keys, or run "yarn unrevoke" here to allow them again.`);
+}
+function parseArgs(argv) {
+    let pushToGit = argv.includes(GIT_KEYWORD);
+    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
+    if (positional.length > 1) {
+        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(" ")}\n${USAGE}`);
+    }
+    return { keyPath: positional[0], pushToGit };
+}
+/** Writes the manifest and its signature into a repo. Separate from the command so anything that
+    changes a keys repo can leave it signed, rather than telling someone to go and do it. */
+async function signRepo(config) {
+    let { repoPath } = config;
+    let signingKey = config.keyPath && (0, paths_1.expandHome)(config.keyPath) || await ensureDefaultKey();
+    if (!await pathExists(signingKey)) {
+        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);
+    }
+    await refuseUnusableKeys(repoPath);
+    await refuseRevokedKeys(repoPath);
+    let manifest = await (0, manifest_1.buildManifest)(repoPath);
+    console.log(`${manifest_1.MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);
+    // The manifest is built and signed away from the repo, and only moved in once both exist.
+    // Landing a new manifest next to an old signature produces a pair that can never verify, and
+    // the daemon reading it can only treat that as tampering.
+    let stagingDirectory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "signfiles-"));
+    let stagedManifest = path_1.default.join(stagingDirectory, manifest_1.MANIFEST_NAME);
+    let stagedSignature = `${stagedManifest}.sig`;
+    await promises_1.default.writeFile(stagedManifest, (0, manifest_1.formatManifest)(manifest));
+    // Signing happens before any git work, so a failed push never costs a second touch of the key.
+    await (0, runPromise_1.runPromise)(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${manifest_1.SIGN_NAMESPACE} ${quote(stagedManifest)}`);
+    // Checked here rather than left for a machine that has already pulled it to discover.
+    await (0, runPromise_1.runPromise)(`ssh-keygen -Y check-novalidate -n ${manifest_1.SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`);
+    await promises_1.default.copyFile(stagedManifest, path_1.default.join(repoPath, manifest_1.MANIFEST_NAME));
+    await promises_1.default.copyFile(stagedSignature, path_1.default.join(repoPath, manifest_1.SIGNATURE_NAME));
+    await promises_1.default.rm(stagingDirectory, { recursive: true, force: true });
+    console.log(`Signed with ${await publicKeyOf(signingKey)}`);
+}
+exports.signRepo = signRepo;
+async function main() {
+    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
+    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a
+    // git warning glued to the front of this becomes a directory that does not exist.
+    let topLevel = await (0, spawn_1.spawnPromise)({ command: "git", args: ["rev-parse", "--show-toplevel"] });
+    let repoPath = topLevel.stdout.trim();
+    if (topLevel.status !== 0 || !repoPath) {
+        throw new Error(`Expected the current directory to be inside a git repo, it is not.\n`
+            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`);
+    }
+    await signRepo({ repoPath, keyPath });
+    if (!pushToGit) {
+        console.log(`Commit and push ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} for anything to see them.`);
+        return;
+    }
+    await (0, runPromise_1.runPromise)(`git add -A`, { cwd: repoPath });
+    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means
+    // the signature matches the one already committed, so there is nothing to deploy.
+    let status = await (0, spawn_1.spawnPromise)({ command: "git", args: ["status", "--porcelain"], cwd: repoPath });
+    let staged = status.stdout;
+    if (!staged.trim()) {
+        console.log(`Nothing changed, ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} are already committed.`);
+        return;
+    }
+    await (0, runPromise_1.runPromise)(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });
+    await (0, runPromise_1.runPromise)(`git push`, { cwd: repoPath });
+    console.log(`Committed and pushed.`);
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.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 { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\nimport { findKeyProblems, normalizeKeys } from \"../authorizedKeys/authorizedKeys\";\n\n// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the\n// machine is, and then the signature proves nothing, so this is what we make when asked to make one.\nconst DEFAULT_KEY_TYPE = \"ed25519-sk\";\nconst DEFAULT_KEY_PATH = \"~/.ssh/signfiles_ed25519_sk\";\nconst GIT_KEYWORD = \"git\";\nconst COMMIT_MESSAGE = \"deploying signed files\";\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]\n\nSigns the files of the repo in the current directory. With no key, a hardware backed\n${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.\nPass ${GIT_KEYWORD} to also commit and push the result.`;\n\n/** runPromise takes a command line rather than an argument list, so anything holding a path has to\n    survive the shell. Double quotes work on both cmd and posix shells. */\nfunction quote(value: string) {\n    return `\"${value}\"`;\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/** Creating this needs the security key plugged in, and a touch. */\nasync function ensureDefaultKey() {\n    let keyPath = expandHome(DEFAULT_KEY_PATH);\n    if (await pathExists(keyPath)) {\n        return keyPath;\n    }\n    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);\n    console.log(`Plug your security key in - you will be asked to touch it.`);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N \"\" -C signfiles`);\n    return keyPath;\n}\n\n/** The public key in the form the daemon reports it, so what is printed here can be compared\n    against what arrives on Discord. */\nasync function publicKeyOf(keyPath: string) {\n    let contents = await fs.readFile(`${keyPath}.pub`, \"utf8\");\n    let [keyType, keyBody] = contents.trim().split(/\\s+/);\n    if (!keyType || !keyBody) {\n        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return `${keyType} ${keyBody}`;\n}\n\n/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it\n    is signed. Signing anything that is not a keys repo is none of this function's business. */\nasync function refuseUnusableKeys(repoPath: string) {\n    let authorizedPath = path.join(repoPath, \"authorized_keys\");\n    if (!await pathExists(authorizedPath)) {\n        return;\n    }\n    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, \"utf8\")));\n    if (!problems.length) {\n        return;\n    }\n    throw new Error(\n        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`\n        + ` found ${problems.length} problem(s):\\n`\n        + problems.map(problem => `  - ${problem}`).join(\"\\n\")\n        + `\\n\\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`\n        + `\\nname the same ones. Revoking a key that shares its addresses with another leaves that`\n        + `\\nother key working, which defeats the point of revoking it.`\n    );\n}\n\n/** Signing a keys repo that still holds a revoked key would publish it back to every machine that\n    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing\n    anything else is none of this function's business. */\nasync function refuseRevokedKeys(repoPath: string) {\n    if (!await pathExists(path.join(repoPath, \"authorized_keys\"))) {\n        return;\n    }\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let originURL = origin.stdout.trim();\n    if (origin.status !== 0 || !originURL) {\n        return;\n    }\n    let revoked;\n    try {\n        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });\n    } catch (e) {\n        // No revoke repo, or no access to it. Nothing has been revoked that we can see.\n        return;\n    }\n    if (!revoked.length) {\n        return;\n    }\n    throw new Error(\n        `Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\\n`\n        + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || \"?\"}`\n            + ` after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n        + `\\nDelete them from authorized_keys, or run \"yarn unrevoke\" here to allow them again.`\n    );\n}\n\nfunction parseArgs(argv: string[]) {\n    let pushToGit = argv.includes(GIT_KEYWORD);\n    let positional = argv.filter(arg => arg !== GIT_KEYWORD);\n    if (positional.length > 1) {\n        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(\" \")}\\n${USAGE}`);\n    }\n    return { keyPath: positional[0], pushToGit };\n}\n\n/** Writes the manifest and its signature into a repo. Separate from the command so anything that\n    changes a keys repo can leave it signed, rather than telling someone to go and do it. */\nexport async function signRepo(config: { repoPath: string; keyPath?: string }) {\n    let { repoPath } = config;\n    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();\n    if (!await pathExists(signingKey)) {\n        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);\n    }\n\n    await refuseUnusableKeys(repoPath);\n    await refuseRevokedKeys(repoPath);\n\n    let manifest = await buildManifest(repoPath);\n    console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);\n\n    // The manifest is built and signed away from the repo, and only moved in once both exist.\n    // Landing a new manifest next to an old signature produces a pair that can never verify, and\n    // the daemon reading it can only treat that as tampering.\n    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"signfiles-\"));\n    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);\n    let stagedSignature = `${stagedManifest}.sig`;\n    await fs.writeFile(stagedManifest, formatManifest(manifest));\n\n    // Signing happens before any git work, so a failed push never costs a second touch of the key.\n    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);\n    // Checked here rather than left for a machine that has already pulled it to discover.\n    await runPromise(\n        `ssh-keygen -Y check-novalidate -n ${SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`\n    );\n    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));\n    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));\n    await fs.rm(stagingDirectory, { recursive: true, force: true });\n    console.log(`Signed with ${await publicKeyOf(signingKey)}`);\n}\n\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a\n    // git warning glued to the front of this becomes a directory that does not exist.\n    let topLevel = await spawnPromise({ command: \"git\", args: [\"rev-parse\", \"--show-toplevel\"] });\n    let repoPath = topLevel.stdout.trim();\n    if (topLevel.status !== 0 || !repoPath) {\n        throw new Error(\n            `Expected the current directory to be inside a git repo, it is not.\\n`\n            + `${(topLevel.stdout + topLevel.stderr).trim()}\\n${USAGE}`\n        );\n    }\n    await signRepo({ repoPath, keyPath });\n\n    if (!pushToGit) {\n        console.log(`Commit and push ${MANIFEST_NAME} and ${SIGNATURE_NAME} for anything to see them.`);\n        return;\n    }\n    await runPromise(`git add -A`, { cwd: repoPath });\n    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means\n    // the signature matches the one already committed, so there is nothing to deploy.\n    let status = await spawnPromise({ command: \"git\", args: [\"status\", \"--porcelain\"], cwd: repoPath });\n    let staged = status.stdout;\n    if (!staged.trim()) {\n        console.log(`Nothing changed, ${MANIFEST_NAME} and ${SIGNATURE_NAME} are already committed.`);\n        return;\n    }\n    await runPromise(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });\n    await runPromise(`git push`, { cwd: repoPath });\n    console.log(`Committed and pushed.`);\n}\n"]}
+ /* _JS_SOURCE_HASH = "5656bac7a766bdb1101df9294951fc82d227c63f880590d3dd4eb51bd67c88d1"; */

package/security/signedFiles/manifest.ts

@@ -19,7 +19,13 @@ export type Manifest = {
     files: { path: string; size: number; sha256: string }[];
 };
 
-/** Everything in the repo that is not ignored, which is exactly what a clone of it will contain.
+/** Everything in the repo that is not ignored: what is in the index, plus what is not staged yet.
+    Git is asked because git is what knows how to apply the ignore rules.
+
+    What comes back is a hint that a file might be there, not that it is. A file deleted from the
+    working tree stays in the index until that deletion is staged, so git names it and there is
+    nothing to read, which is why each one is checked before it goes in.
+
     The manifest and its signature are left out, since they cannot describe themselves. */
 export async function listRepoFiles(repoPath: string) {
     let result = await spawnPromise({
@@ -28,24 +34,48 @@ export async function listRepoFiles(repoPath: string) {
         cwd: repoPath,
     });
     if (result.status !== 0) {
-        throw new Error(`Expected to list the files in ${repoPath}, git ls-files exited ${result.status}. ${result.stderr}`);
+        throw new Error(
+            `Expected to list the files in ${repoPath}, git ls-files exited ${result.status}. `
+            + `${(result.stdout + result.stderr).trim()}`
+        );
     }
-    return result.stdout.split("\n")
+    let listed = result.stdout.split("\n")
         .map(line => line.trim())
         .filter(line => line && line !== MANIFEST_NAME && line !== SIGNATURE_NAME)
         .sort();
+
+    let present: string[] = [];
+    for (let relativePath of listed) {
+        try {
+            await fs.access(path.join(repoPath, relativePath));
+            present.push(relativePath);
+        } catch (e) {
+            console.log(`Leaving ${relativePath} out of the manifest, it is gone from the working tree`);
+        }
+    }
+    return present;
+}
+
+/** A Windows checkout turns LF into CRLF, so the same commit hashes differently there than it
+    does on the machine that pulls it. Normalising first makes the digest describe the content
+    rather than whichever checkout produced it. latin1 round trips every byte, so this is safe on
+    files that are not text. */
+export function normalizeContent(contents: Buffer) {
+    return Buffer.from(contents.toString("latin1").replace(/\r\n/g, "\n"), "latin1");
 }
 
-export async function hashFile(filePath: string) {
-    return crypto.createHash("sha256").update(await fs.readFile(filePath)).digest("hex");
+/** The size and hash of a file's normalised content. The size is the normalised one on purpose,
+    so it agrees with the hash rather than with whatever the local checkout happens to hold. */
+export async function digestFile(filePath: string) {
+    let contents = normalizeContent(await fs.readFile(filePath));
+    return { size: contents.length, sha256: crypto.createHash("sha256").update(contents).digest("hex") };
 }
 
 export async function buildManifest(repoPath: string) {
     let files: Manifest["files"] = [];
     for (let relativePath of await listRepoFiles(repoPath)) {
-        let fullPath = path.join(repoPath, relativePath);
-        let stats = await fs.stat(fullPath);
-        files.push({ path: relativePath, size: stats.size, sha256: await hashFile(fullPath) });
+        let digest = await digestFile(path.join(repoPath, relativePath));
+        files.push({ path: relativePath, size: digest.size, sha256: digest.sha256 });
     }
     return { version: MANIFEST_VERSION, files };
 }

package/security/signedFiles/signFiles.ts

@@ -1,9 +1,12 @@
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
+import { runPromise } from "socket-function/src/runPromise";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
 import { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from "./manifest";
+import { revokedKeysInRepo } from "../authorizedKeys/unrevoke";
+import { findKeyProblems, normalizeKeys } from "../authorizedKeys/authorizedKeys";
 
 // A hardware backed key is the entire point. A key sitting on disk is compromised the moment the
 // machine is, and then the signature proves nothing, so this is what we make when asked to make one.
@@ -18,6 +21,12 @@ Signs the files of the repo in the current directory. With no key, a hardware ba
 ${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.
 Pass ${GIT_KEYWORD} to also commit and push the result.`;
 
+/** runPromise takes a command line rather than an argument list, so anything holding a path has to
+    survive the shell. Double quotes work on both cmd and posix shells. */
+function quote(value: string) {
+    return `"${value}"`;
+}
+
 async function pathExists(filePath: string) {
     try {
         await fs.access(filePath);
@@ -27,23 +36,7 @@ async function pathExists(filePath: string) {
     }
 }
 
-async function run(config: { command: string; args: string[]; cwd?: string; interactive?: boolean }) {
-    let { command, args, cwd, interactive } = config;
-    let result = await spawnPromise({ command, args, cwd, inheritStderr: interactive });
-    if (result.error) {
-        throw new Error(`Expected ${command} to run, failed with ${result.error.message}`);
-    }
-    if (result.status !== 0) {
-        throw new Error(
-            `Expected ${command} ${args.join(" ")} to exit 0, was ${result.status}. `
-            + `${(result.stderr || "").slice(0, MAX_ERROR_BODY_LENGTH)}`
-        );
-    }
-    return result;
-}
-
-/** Creating this needs the security key plugged in, and a touch, so its output goes straight to
-    the terminal rather than being captured. */
+/** Creating this needs the security key plugged in, and a touch. */
 async function ensureDefaultKey() {
     let keyPath = expandHome(DEFAULT_KEY_PATH);
     if (await pathExists(keyPath)) {
@@ -52,21 +45,71 @@ async function ensureDefaultKey() {
     console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);
     console.log(`Plug your security key in - you will be asked to touch it.`);
     await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });
-    await run({
-        command: "ssh-keygen",
-        args: ["-t", DEFAULT_KEY_TYPE, "-f", keyPath, "-N", "", "-C", "signfiles"],
-        interactive: true,
-    });
+    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N "" -C signfiles`);
     return keyPath;
 }
 
-async function fingerprintOf(keyPath: string) {
-    let result = await run({ command: "ssh-keygen", args: ["-lf", `${keyPath}.pub`] });
-    let match = result.stdout.match(/(SHA256:[A-Za-z0-9+/=]+)/);
-    if (!match) {
-        throw new Error(`Expected a fingerprint for ${keyPath}.pub, was ${result.stdout.slice(0, MAX_ERROR_BODY_LENGTH)}`);
+/** The public key in the form the daemon reports it, so what is printed here can be compared
+    against what arrives on Discord. */
+async function publicKeyOf(keyPath: string) {
+    let contents = await fs.readFile(`${keyPath}.pub`, "utf8");
+    let [keyType, keyBody] = contents.trim().split(/\s+/);
+    if (!keyType || !keyBody) {
+        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);
+    }
+    return `${keyType} ${keyBody}`;
+}
+
+/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it
+    is signed. Signing anything that is not a keys repo is none of this function's business. */
+async function refuseUnusableKeys(repoPath: string) {
+    let authorizedPath = path.join(repoPath, "authorized_keys");
+    if (!await pathExists(authorizedPath)) {
+        return;
     }
-    return match[1];
+    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, "utf8")));
+    if (!problems.length) {
+        return;
+    }
+    throw new Error(
+        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`
+        + ` found ${problems.length} problem(s):\n`
+        + problems.map(problem => `  - ${problem}`).join("\n")
+        + `\n\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`
+        + `\nname the same ones. Revoking a key that shares its addresses with another leaves that`
+        + `\nother key working, which defeats the point of revoking it.`
+    );
+}
+
+/** Signing a keys repo that still holds a revoked key would publish it back to every machine that
+    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing
+    anything else is none of this function's business. */
+async function refuseRevokedKeys(repoPath: string) {
+    if (!await pathExists(path.join(repoPath, "authorized_keys"))) {
+        return;
+    }
+    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.
+    let origin = await spawnPromise({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
+    let originURL = origin.stdout.trim();
+    if (origin.status !== 0 || !originURL) {
+        return;
+    }
+    let revoked;
+    try {
+        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });
+    } catch (e) {
+        // No revoke repo, or no access to it. Nothing has been revoked that we can see.
+        return;
+    }
+    if (!revoked.length) {
+        return;
+    }
+    throw new Error(
+        `Expected ${repoPath} 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 authorized_keys, or run "yarn unrevoke" here to allow them again.`
+    );
 }
 
 function parseArgs(argv: string[]) {
@@ -78,39 +121,70 @@ function parseArgs(argv: string[]) {
     return { keyPath: positional[0], pushToGit };
 }
 
-export async function main() {
-    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
-
-    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"] });
-    if (topLevel.status !== 0) {
-        throw new Error(`Expected the current directory to be inside a git repo, it is not.\n${USAGE}`);
-    }
-    let repoPath = topLevel.stdout.trim();
-
-    let signingKey = keyPath && expandHome(keyPath) || await ensureDefaultKey();
+/** Writes the manifest and its signature into a repo. Separate from the command so anything that
+    changes a keys repo can leave it signed, rather than telling someone to go and do it. */
+export async function signRepo(config: { repoPath: string; keyPath?: string }) {
+    let { repoPath } = config;
+    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();
     if (!await pathExists(signingKey)) {
         throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);
     }
 
+    await refuseUnusableKeys(repoPath);
+    await refuseRevokedKeys(repoPath);
+
     let manifest = await buildManifest(repoPath);
-    let manifestPath = path.join(repoPath, MANIFEST_NAME);
-    await fs.writeFile(manifestPath, formatManifest(manifest));
     console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);
 
+    // The manifest is built and signed away from the repo, and only moved in once both exist.
+    // Landing a new manifest next to an old signature produces a pair that can never verify, and
+    // the daemon reading it can only treat that as tampering.
+    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "signfiles-"));
+    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);
+    let stagedSignature = `${stagedManifest}.sig`;
+    await fs.writeFile(stagedManifest, formatManifest(manifest));
+
     // Signing happens before any git work, so a failed push never costs a second touch of the key.
-    await run({
-        command: "ssh-keygen",
-        args: ["-Y", "sign", "-f", signingKey, "-n", SIGN_NAMESPACE, manifestPath],
-        interactive: true,
-    });
-    console.log(`Signed with ${await fingerprintOf(signingKey)}`);
+    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);
+    // Checked here rather than left for a machine that has already pulled it to discover.
+    await runPromise(
+        `ssh-keygen -Y check-novalidate -n ${SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`
+    );
+    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));
+    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));
+    await fs.rm(stagingDirectory, { recursive: true, force: true });
+    console.log(`Signed with ${await publicKeyOf(signingKey)}`);
+}
+
+export async function main() {
+    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
+
+    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr, and a
+    // git warning glued to the front of this becomes a directory that does not exist.
+    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"] });
+    let repoPath = topLevel.stdout.trim();
+    if (topLevel.status !== 0 || !repoPath) {
+        throw new Error(
+            `Expected the current directory to be inside a git repo, it is not.\n`
+            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`
+        );
+    }
+    await signRepo({ repoPath, keyPath });
 
     if (!pushToGit) {
         console.log(`Commit and push ${MANIFEST_NAME} and ${SIGNATURE_NAME} for anything to see them.`);
         return;
     }
-    await run({ command: "git", args: ["add", "-A"], cwd: repoPath, interactive: true });
-    await run({ command: "git", args: ["commit", "-m", COMMIT_MESSAGE], cwd: repoPath, interactive: true });
-    await run({ command: "git", args: ["push"], cwd: repoPath, interactive: true });
+    await runPromise(`git add -A`, { cwd: repoPath });
+    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means
+    // the signature matches the one already committed, so there is nothing to deploy.
+    let status = await spawnPromise({ command: "git", args: ["status", "--porcelain"], cwd: repoPath });
+    let staged = status.stdout;
+    if (!staged.trim()) {
+        console.log(`Nothing changed, ${MANIFEST_NAME} and ${SIGNATURE_NAME} are already committed.`);
+        return;
+    }
+    await runPromise(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });
+    await runPromise(`git push`, { cwd: repoPath });
     console.log(`Committed and pushed.`);
 }