sliftutils 1.7.125 → 1.7.126

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

@@ -0,0 +1,146 @@
+"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 = 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 manifest_1 = require("./manifest");
+const unrevoke_1 = require("../authorizedKeys/unrevoke");
+// 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}`;
+}
+/** 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;
+    }
+    let originURL = (await (0, runPromise_1.runPromise)("git remote get-url origin", { cwd: repoPath, quiet: true, nothrow: true })).trim();
+    if (!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 };
+}
+async function main() {
+    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
+    let repoPath = (await (0, runPromise_1.runPromise)("git rev-parse --show-toplevel", { quiet: true })).trim();
+    if (!repoPath) {
+        throw new Error(`Expected the current directory to be inside a git repo, it is not.\n${USAGE}`);
+    }
+    let signingKey = keyPath && (0, paths_1.expandHome)(keyPath) || await ensureDefaultKey();
+    if (!await pathExists(signingKey)) {
+        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);
+    }
+    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)}`);
+    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 staged = await (0, runPromise_1.runPromise)(`git status --porcelain`, { cwd: repoPath, quiet: true });
+    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 { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\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/** 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    let originURL = (await runPromise(\"git remote get-url origin\", { cwd: repoPath, quiet: true, nothrow: true })).trim();\n    if (!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\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    let repoPath = (await runPromise(\"git rev-parse --show-toplevel\", { quiet: true })).trim();\n    if (!repoPath) {\n        throw new Error(`Expected the current directory to be inside a git repo, it is not.\\n${USAGE}`);\n    }\n\n    let signingKey = keyPath && expandHome(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 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    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 staged = await runPromise(`git status --porcelain`, { cwd: repoPath, quiet: true });\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 = "534e0243c3e52f007b386e8947198cdd98869d9cc5f9dda1413aeecb36b947a7"; */

package/security/signedFiles/manifest.ts

@@ -28,7 +28,10 @@ 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")
         .map(line => line.trim())
@@ -36,16 +39,26 @@ export async function listRepoFiles(repoPath: string) {
         .sort();
 }
 
-export async function hashFile(filePath: string) {
-    return crypto.createHash("sha256").update(await fs.readFile(filePath)).digest("hex");
+/** 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");
+}
+
+/** 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,10 @@
 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";
 
 // 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 +19,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 +34,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 +43,48 @@ 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}`;
+}
+
+/** 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;
+    }
+    let originURL = (await runPromise("git remote get-url origin", { cwd: repoPath, quiet: true, nothrow: true })).trim();
+    if (!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;
     }
-    return match[1];
+    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[]) {
@@ -81,36 +99,53 @@ function parseArgs(argv: string[]) {
 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) {
+    let repoPath = (await runPromise("git rev-parse --show-toplevel", { quiet: true })).trim();
+    if (!repoPath) {
         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();
     if (!await pathExists(signingKey)) {
         throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);
     }
 
+    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)}`);
 
     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 staged = await runPromise(`git status --porcelain`, { cwd: repoPath, quiet: true });
+    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.`);
 }