sliftutils 1.7.124 → 1.7.126

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

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

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

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

package/security/authorizedKeys/revokeSource.ts

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