sliftutils 1.7.125 → 1.7.127

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

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

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

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

package/security/authorizedKeys/revokeSource.ts

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