sliftutils 1.7.126 → 1.7.127

package/security/notifications/testNotify.ts

@@ -0,0 +1,48 @@
+import fs from "fs/promises";
+import os from "os";
+import { DEFAULT_WEBHOOK_FILE_PATH, parseWebhookFile, sendToWebhookURL } from "./discord";
+import { readRemoteFile } from "../helpers/remoteSSH";
+
+const USAGE = `Usage: yarn testnotify [host]
+
+Sends one message to a webhook, to prove it works. With no host it uses this machine's webhook at
+${DEFAULT_WEBHOOK_FILE_PATH}. With a host it reads that host's webhook and sends to that instead,
+which is how you check a machine you have just set up.`;
+
+export async function main() {
+    let argv = process.argv.slice(2);
+    if (argv.length > 1) {
+        throw new Error(`Expected at most a host, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let host = argv[0];
+
+    let contents: string | undefined;
+    if (host) {
+        contents = await readRemoteFile({ host, filePath: DEFAULT_WEBHOOK_FILE_PATH });
+        if (!contents) {
+            throw new Error(
+                `Expected a webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on ${host}, no such file exists.\n`
+                + `Set it up with:\n  yarn setupnotify ${host} <discord-webhook-url>`
+            );
+        }
+    } else {
+        try {
+            contents = await fs.readFile(DEFAULT_WEBHOOK_FILE_PATH, "utf8");
+        } catch (e) {
+            throw new Error(
+                `Expected a webhook at ${DEFAULT_WEBHOOK_FILE_PATH} on this machine, ${e}\n`
+                + `Name a host to use that host's webhook instead.\n${USAGE}`
+            );
+        }
+    }
+
+    let source = host || os.hostname();
+    let webhookURL = parseWebhookFile({ contents, sourceName: `${source}:${DEFAULT_WEBHOOK_FILE_PATH}` });
+    // Said plainly, so nobody reading the channel later has to work out whether it was real.
+    await sendToWebhookURL({
+        webhookURL,
+        message: `**portsecure test**: this is a test message, nothing has happened.`
+            + ` Sent with \`yarn testnotify\` for the webhook \`${source}\` uses.`,
+    });
+    console.log(`Sent a test message to the webhook ${source} uses.`);
+}

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

@@ -17,7 +17,13 @@ exports.SIGNATURE_NAME = "signedfiles.json.sig";
 // ssh signatures are namespaced, so a signature made for one purpose cannot be replayed as another.
 exports.SIGN_NAMESPACE = "signfiles";
 exports.MANIFEST_VERSION = 1;
-/** 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. */
 async function listRepoFiles(repoPath) {
     let result = await (0, spawn_1.spawnPromise)({
@@ -29,10 +35,21 @@ async function listRepoFiles(repoPath) {
         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 !== exports.MANIFEST_NAME && line !== exports.SIGNATURE_NAME)
         .sort();
+    let present = [];
+    for (let relativePath of listed) {
+        try {
+            await promises_1.default.access(path_1.default.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;
 }
 exports.listRepoFiles = listRepoFiles;
 /** A Windows checkout turns LF into CRLF, so the same commit hashes differently there than it
@@ -64,5 +81,5 @@ function formatManifest(manifest) {
     return JSON.stringify(manifest, undefined, 4) + "\n";
 }
 exports.formatManifest = formatManifest;
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "b03b98c478c3d40c11ab30a9be0a3a73ddfbb41e74230864ca940f9edd07dc68"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["manifest.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\nimport { spawnPromise } from \"../helpers/spawn\";\n\n// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js contains a plain JS port of the\n// verifying half of this file, so it can check a signature with no dependencies. Both sides must\n// agree on the manifest shape and on which files it covers - if you change one, make the matching\n// change in the other.\n\nexport const MANIFEST_NAME = \"signedfiles.json\";\nexport const SIGNATURE_NAME = \"signedfiles.json.sig\";\n// ssh signatures are namespaced, so a signature made for one purpose cannot be replayed as another.\nexport const SIGN_NAMESPACE = \"signfiles\";\nexport const MANIFEST_VERSION = 1;\n\nexport type Manifest = {\n    version: number;\n    files: { path: string; size: number; sha256: string }[];\n};\n\n/** Everything in the repo that is not ignored: what is in the index, plus what is not staged yet.\n    Git is asked because git is what knows how to apply the ignore rules.\n\n    What comes back is a hint that a file might be there, not that it is. A file deleted from the\n    working tree stays in the index until that deletion is staged, so git names it and there is\n    nothing to read, which is why each one is checked before it goes in.\n\n    The manifest and its signature are left out, since they cannot describe themselves. */\nexport async function listRepoFiles(repoPath: string) {\n    let result = await spawnPromise({\n        command: \"git\",\n        args: [\"ls-files\", \"--cached\", \"--others\", \"--exclude-standard\"],\n        cwd: repoPath,\n    });\n    if (result.status !== 0) {\n        throw new Error(\n            `Expected to list the files in ${repoPath}, git ls-files exited ${result.status}. `\n            + `${(result.stdout + result.stderr).trim()}`\n        );\n    }\n    let listed = result.stdout.split(\"\\n\")\n        .map(line => line.trim())\n        .filter(line => line && line !== MANIFEST_NAME && line !== SIGNATURE_NAME)\n        .sort();\n\n    let present: string[] = [];\n    for (let relativePath of listed) {\n        try {\n            await fs.access(path.join(repoPath, relativePath));\n            present.push(relativePath);\n        } catch (e) {\n            console.log(`Leaving ${relativePath} out of the manifest, it is gone from the working tree`);\n        }\n    }\n    return present;\n}\n\n/** A Windows checkout turns LF into CRLF, so the same commit hashes differently there than it\n    does on the machine that pulls it. Normalising first makes the digest describe the content\n    rather than whichever checkout produced it. latin1 round trips every byte, so this is safe on\n    files that are not text. */\nexport function normalizeContent(contents: Buffer) {\n    return Buffer.from(contents.toString(\"latin1\").replace(/\\r\\n/g, \"\\n\"), \"latin1\");\n}\n\n/** The size and hash of a file's normalised content. The size is the normalised one on purpose,\n    so it agrees with the hash rather than with whatever the local checkout happens to hold. */\nexport async function digestFile(filePath: string) {\n    let contents = normalizeContent(await fs.readFile(filePath));\n    return { size: contents.length, sha256: crypto.createHash(\"sha256\").update(contents).digest(\"hex\") };\n}\n\nexport async function buildManifest(repoPath: string) {\n    let files: Manifest[\"files\"] = [];\n    for (let relativePath of await listRepoFiles(repoPath)) {\n        let digest = await digestFile(path.join(repoPath, relativePath));\n        files.push({ path: relativePath, size: digest.size, sha256: digest.sha256 });\n    }\n    return { version: MANIFEST_VERSION, files };\n}\n\n/** Sorted keys and a trailing newline, so the same tree always produces the same bytes to sign. */\nexport function formatManifest(manifest: Manifest) {\n    return JSON.stringify(manifest, undefined, 4) + \"\\n\";\n}\n"]}
+ /* _JS_SOURCE_HASH = "e58787cb53d84ba9647f11c90c737f7303e120b8e02ca37cc9f38202fce1929d"; */

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

@@ -3,14 +3,16 @@ 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;
+//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";
@@ -59,6 +61,24 @@ async function publicKeyOf(keyPath) {
     }
     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. */
@@ -66,8 +86,10 @@ 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) {
+    // 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;
@@ -97,16 +119,15 @@ function parseArgs(argv) {
     }
     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();
+/** 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}`);
@@ -125,6 +146,19 @@ async function main() {
     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;
@@ -132,7 +166,8 @@ async function main() {
     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 });
+    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;
@@ -142,5 +177,5 @@ async function main() {
     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"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.ts"],"names":[],"mappings":";;;;;;AAAA,2DAA6B;AAC7B,4CAAoB;AACpB,gDAAwB;AACxB,+DAA4D;AAC5D,4CAA8C;AAC9C,4CAAgD;AAChD,yCAA0G;AAC1G,yDAA+D;AAC/D,qEAAkF;AAElF,iGAAiG;AACjG,qGAAqG;AACrG,MAAM,gBAAgB,GAAG,YAAY,CAAC;AACtC,MAAM,gBAAgB,GAAG,6BAA6B,CAAC;AACvD,MAAM,WAAW,GAAG,KAAK,CAAC;AAC1B,MAAM,cAAc,GAAG,wBAAwB,CAAC;AAChD,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,KAAK,GAAG,wCAAwC,WAAW;;;EAG/D,gBAAgB,WAAW,gBAAgB;OACtC,WAAW,sCAAsC,CAAC;AAEzD;0EAC0E;AAC1E,SAAS,KAAK,CAAC,KAAa;IACxB,OAAO,IAAI,KAAK,GAAG,CAAC;AACxB,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,QAAgB;IACtC,IAAI,CAAC;QACD,MAAM,kBAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,KAAK,CAAC;IACjB,CAAC;AACL,CAAC;AAED,oEAAoE;AACpE,KAAK,UAAU,gBAAgB;IAC3B,IAAI,OAAO,GAAG,IAAA,kBAAU,EAAC,gBAAgB,CAAC,CAAC;IAC3C,IAAI,MAAM,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,qBAAqB,OAAO,iBAAiB,gBAAgB,OAAO,CAAC,CAAC;IAClF,OAAO,CAAC,GAAG,CAAC,4DAA4D,CAAC,CAAC;IAC1E,MAAM,kBAAE,CAAC,KAAK,CAAC,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACxE,MAAM,IAAA,uBAAU,EAAC,iBAAiB,gBAAgB,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAC9F,OAAO,OAAO,CAAC;AACnB,CAAC;AAED;uCACuC;AACvC,KAAK,UAAU,WAAW,CAAC,OAAe;IACtC,IAAI,QAAQ,GAAG,MAAM,kBAAE,CAAC,QAAQ,CAAC,GAAG,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtD,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,4BAA4B,OAAO,aAAa,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAChH,CAAC;IACD,OAAO,GAAG,OAAO,IAAI,OAAO,EAAE,CAAC;AACnC,CAAC;AAED;+FAC+F;AAC/F,KAAK,UAAU,kBAAkB,CAAC,QAAgB;IAC9C,IAAI,cAAc,GAAG,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;IAC5D,IAAI,CAAC,MAAM,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;QACpC,OAAO;IACX,CAAC;IACD,IAAI,QAAQ,GAAG,IAAA,gCAAe,EAAC,IAAA,8BAAa,EAAC,MAAM,kBAAE,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACzF,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;QACnB,OAAO;IACX,CAAC;IACD,MAAM,IAAI,KAAK,CACX,yBAAyB,cAAc,gDAAgD;UACrF,UAAU,QAAQ,CAAC,MAAM,gBAAgB;UACzC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;UACpD,2FAA2F;UAC3F,yFAAyF;UACzF,8DAA8D,CACnE,CAAC;AACN,CAAC;AAED;;yDAEyD;AACzD,KAAK,UAAU,iBAAiB,CAAC,QAAgB;IAC7C,IAAI,CAAC,MAAM,UAAU,CAAC,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC;QAC5D,OAAO;IACX,CAAC;IACD,uFAAuF;IACvF,IAAI,MAAM,GAAG,MAAM,IAAA,oBAAY,EAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1G,IAAI,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;QACpC,OAAO;IACX,CAAC;IACD,IAAI,OAAO,CAAC;IACZ,IAAI,CAAC;QACD,OAAO,GAAG,MAAM,IAAA,4BAAiB,EAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;IAC1E,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,gFAAgF;QAChF,OAAO;IACX,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO;IACX,CAAC;IACD,MAAM,IAAI,KAAK,CACX,YAAY,QAAQ,sCAAsC,OAAO,CAAC,MAAM,KAAK;UAC3E,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;;YAAC,OAAA,KAAK,KAAK,CAAC,UAAU,CAAC,WAAW,eAAe,KAAK,CAAC,UAAU,CAAC,SAAS,IAAI,GAAG,EAAE;kBACpG,mBAAmB,CAAA,MAAA,KAAK,CAAC,UAAU,CAAC,OAAO,0CAAE,EAAE,KAAI,GAAG,EAAE,CAAA;SAAA,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;UACxE,sFAAsF,CAC3F,CAAC;AACN,CAAC;AAED,SAAS,SAAS,CAAC,IAAc;IAC7B,IAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC;IACzD,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,uCAAuC,UAAU,CAAC,MAAM,iBAAiB,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC;IAC/H,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC;AACjD,CAAC;AAED;4FAC4F;AACrF,KAAK,UAAU,QAAQ,CAAC,MAA8C;IACzE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IAC1B,IAAI,UAAU,GAAG,MAAM,CAAC,OAAO,IAAI,IAAA,kBAAU,EAAC,MAAM,CAAC,OAAO,CAAC,IAAI,MAAM,gBAAgB,EAAE,CAAC;IAC1F,IAAI,CAAC,MAAM,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,6BAA6B,UAAU,uBAAuB,CAAC,CAAC;IACpF,CAAC;IAED,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAElC,IAAI,QAAQ,GAAG,MAAM,IAAA,wBAAa,EAAC,QAAQ,CAAC,CAAC;IAC7C,OAAO,CAAC,GAAG,CAAC,GAAG,wBAAa,WAAW,QAAQ,CAAC,KAAK,CAAC,MAAM,eAAe,QAAQ,EAAE,CAAC,CAAC;IAEvF,0FAA0F;IAC1F,6FAA6F;IAC7F,0DAA0D;IAC1D,IAAI,gBAAgB,GAAG,MAAM,kBAAE,CAAC,OAAO,CAAC,cAAI,CAAC,IAAI,CAAC,YAAE,CAAC,MAAM,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC;IAC9E,IAAI,cAAc,GAAG,cAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,wBAAa,CAAC,CAAC;IAChE,IAAI,eAAe,GAAG,GAAG,cAAc,MAAM,CAAC;IAC9C,MAAM,kBAAE,CAAC,SAAS,CAAC,cAAc,EAAE,IAAA,yBAAc,EAAC,QAAQ,CAAC,CAAC,CAAC;IAE7D,+FAA+F;IAC/F,MAAM,IAAA,uBAAU,EAAC,yBAAyB,KAAK,CAAC,UAAU,CAAC,OAAO,yBAAc,IAAI,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IAC7G,sFAAsF;IACtF,MAAM,IAAA,uBAAU,EACZ,qCAAqC,yBAAc,OAAO,KAAK,CAAC,eAAe,CAAC,MAAM,KAAK,CAAC,cAAc,CAAC,EAAE,CAChH,CAAC;IACF,MAAM,kBAAE,CAAC,QAAQ,CAAC,cAAc,EAAE,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,wBAAa,CAAC,CAAC,CAAC;IACtE,MAAM,kBAAE,CAAC,QAAQ,CAAC,eAAe,EAAE,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,yBAAc,CAAC,CAAC,CAAC;IACxE,MAAM,kBAAE,CAAC,EAAE,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAChE,OAAO,CAAC,GAAG,CAAC,eAAe,MAAM,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;AAChE,CAAC;AA/BD,4BA+BC;AAEM,KAAK,UAAU,IAAI;IACtB,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,6FAA6F;IAC7F,kFAAkF;IAClF,IAAI,QAAQ,GAAG,MAAM,IAAA,oBAAY,EAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC,EAAE,CAAC,CAAC;IAC9F,IAAI,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACtC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CACX,sEAAsE;cACpE,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,KAAK,EAAE,CAC9D,CAAC;IACN,CAAC;IACD,MAAM,QAAQ,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAEtC,IAAI,CAAC,SAAS,EAAE,CAAC;QACb,OAAO,CAAC,GAAG,CAAC,mBAAmB,wBAAa,QAAQ,yBAAc,4BAA4B,CAAC,CAAC;QAChG,OAAO;IACX,CAAC;IACD,MAAM,IAAA,uBAAU,EAAC,YAAY,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAClD,8FAA8F;IAC9F,kFAAkF;IAClF,IAAI,MAAM,GAAG,MAAM,IAAA,oBAAY,EAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IACpG,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,oBAAoB,wBAAa,QAAQ,yBAAc,yBAAyB,CAAC,CAAC;QAC9F,OAAO;IACX,CAAC;IACD,MAAM,IAAA,uBAAU,EAAC,iBAAiB,KAAK,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC9E,MAAM,IAAA,uBAAU,EAAC,UAAU,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAChD,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;AACzC,CAAC;AA/BD,oBA+BC","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({
@@ -33,10 +39,21 @@ export async function listRepoFiles(repoPath: string) {
             + `${(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

package/security/signedFiles/signFiles.ts

@@ -3,8 +3,10 @@ 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.
@@ -58,6 +60,27 @@ async function publicKeyOf(keyPath: string) {
     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;
+    }
+    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. */
@@ -65,8 +88,10 @@ 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) {
+    // 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;
@@ -96,19 +121,16 @@ function parseArgs(argv: string[]) {
     return { keyPath: positional[0], pushToGit };
 }
 
-export async function main() {
-    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
-
-    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 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);
@@ -132,6 +154,22 @@ export async function main() {
     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.`);
@@ -140,7 +178,8 @@ export async function main() {
     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 });
+    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;