sliftutils 1.7.128 → 1.7.129

package/security/helpers/dist/remoteSSH.ts.cache

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.remoteCommandExists = exports.writeRemoteFile = exports.readRemoteFile = exports.runOverSSH = exports.SUDO_PREAMBLE = void 0;
+//exports.remoteCommandExists = exports.writeRemoteFile = exports.readRemoteFile = exports.runOverSSH = exports.describeHost = exports.THIS_MACHINE = exports.SUDO_PREAMBLE = void 0;
 const spawn_1 = require("./spawn");
 const SSH_CONNECT_TIMEOUT = 10;
 const EXISTS_MARKER = "__PORTSECURE_EXISTS__";
@@ -8,27 +8,37 @@ const MISSING_MARKER = "__PORTSECURE_MISSING__";
 const MAX_ERROR_BODY_LENGTH = 500;
 // /etc is root owned, so fall back to sudo whenever the SSH user is not root.
 exports.SUDO_PREAMBLE = `SUDO=""; if [ "$(id -u)" -ne 0 ]; then SUDO="sudo -n"; fi`;
+/** No host means this machine, so the very same script runs with nothing in front of it. Local and
+    remote then do exactly the same thing, rather than being two pieces of code that have to be kept
+    saying the same thing. */
+exports.THIS_MACHINE = "";
+function describeHost(host) {
+    return host || "this machine";
+}
+exports.describeHost = describeHost;
 /** The host string is handed to ssh untouched. Users, keys and ports belong in the caller's ssh
     config, so BatchMode makes a missing setup fail immediately instead of prompting. */
 async function runOverSSH(config) {
     let { host, script, input, allowFailure } = config;
     let result = await (0, spawn_1.spawnPromise)({
-        command: "ssh",
-        args: [
+        command: host && "ssh" || "sh",
+        args: host && [
             "-o", "BatchMode=yes",
             "-o", `ConnectTimeout=${SSH_CONNECT_TIMEOUT}`,
             host,
             script,
-        ],
+        ] || ["-c", script],
         input,
         inheritStderr: !allowFailure,
     });
     if (result.error) {
-        throw new Error(`Expected ssh to run against ${host}, failed with ${result.error.message}`);
+        throw new Error(`Expected to run against ${describeHost(host)}, failed with ${result.error.message}`);
     }
     if (result.status !== 0 && !allowFailure) {
-        throw new Error(`Expected ssh to ${host} to exit 0, was ${result.status}.`
-            + ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.\n`
+        let advice = host
+            && ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.`
+            || "";
+        throw new Error(`Expected the script on ${describeHost(host)} to exit 0, was ${result.status}.${advice}\n`
             + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`);
     }
     return { stdout: result.stdout || "", stderr: result.stderr || "", status: result.status };
@@ -86,5 +96,5 @@ async function remoteCommandExists(config) {
     return result.stdout.trim() === "yes";
 }
 exports.remoteCommandExists = remoteCommandExists;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteSSH.js","sourceRoot":"","sources":["remoteSSH.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawnPromise } from \"./spawn\";\n\nconst SSH_CONNECT_TIMEOUT = 10;\nconst EXISTS_MARKER = \"__PORTSECURE_EXISTS__\";\nconst MISSING_MARKER = \"__PORTSECURE_MISSING__\";\nconst MAX_ERROR_BODY_LENGTH = 500;\n\n// /etc is root owned, so fall back to sudo whenever the SSH user is not root.\nexport const SUDO_PREAMBLE = `SUDO=\"\"; if [ \"$(id -u)\" -ne 0 ]; then SUDO=\"sudo -n\"; fi`;\n\n/** The host string is handed to ssh untouched. Users, keys and ports belong in the caller's ssh\n    config, so BatchMode makes a missing setup fail immediately instead of prompting. */\nexport async function runOverSSH(config: { host: string; script: string; input?: string; allowFailure?: boolean }) {\n    let { host, script, input, allowFailure } = config;\n    let result = await spawnPromise({\n        command: \"ssh\",\n        args: [\n            \"-o\", \"BatchMode=yes\",\n            \"-o\", `ConnectTimeout=${SSH_CONNECT_TIMEOUT}`,\n            host,\n            script,\n        ],\n        input,\n        inheritStderr: !allowFailure,\n    });\n    if (result.error) {\n        throw new Error(`Expected ssh to run against ${host}, failed with ${result.error.message}`);\n    }\n    if (result.status !== 0 && !allowFailure) {\n        throw new Error(\n            `Expected ssh to ${host} to exit 0, was ${result.status}.`\n            + ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.\\n`\n            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n    return { stdout: result.stdout || \"\", stderr: result.stderr || \"\", status: result.status };\n}\n\n/** Returns undefined when the file does not exist, so a missing file reads differently from an\n    empty one. */\nexport async function readRemoteFile(config: { host: string; filePath: string }) {\n    let { host, filePath } = config;\n    let output = (await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\nif $SUDO test -f \"${filePath}\"; then\n    echo \"${EXISTS_MARKER}\"\n    $SUDO cat \"${filePath}\"\nelse\n    echo \"${MISSING_MARKER}\"\nfi`,\n    })).stdout;\n    let newlineIndex = output.indexOf(\"\\n\");\n    let marker = output.slice(0, newlineIndex).trim();\n    if (marker === MISSING_MARKER) {\n        return undefined;\n    }\n    if (marker !== EXISTS_MARKER) {\n        throw new Error(`Expected ${EXISTS_MARKER} or ${MISSING_MARKER} from ${host}, was ${output.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return output.slice(newlineIndex + 1);\n}\n\nexport async function writeRemoteFile(config: {\n    host: string;\n    filePath: string;\n    contents: string;\n    fileMode: string;\n    directoryMode: string;\n}) {\n    let { host, filePath, contents, fileMode, directoryMode } = config;\n    let directory = filePath.slice(0, filePath.lastIndexOf(\"/\"));\n    await runOverSSH({\n        host,\n        // Deploying from Windows must not carry CRLF onto the target, where it breaks systemd\n        // units and makes private keys unreadable to ssh.\n        input: contents.replace(/\\r\\n/g, \"\\n\"),\n        script: `${SUDO_PREAMBLE}\nset -e\n$SUDO mkdir -p \"${directory}\"\n$SUDO chmod ${directoryMode} \"${directory}\"\n$SUDO tee \"${filePath}\" > /dev/null\n$SUDO chmod ${fileMode} \"${filePath}\"`,\n    });\n}\n\nexport async function remoteCommandExists(config: { host: string; command: string }) {\n    let { host, command } = config;\n    let result = await runOverSSH({\n        host,\n        script: `command -v \"${command}\" > /dev/null 2>&1 && echo yes || echo no`,\n        allowFailure: true,\n    });\n    return result.stdout.trim() === \"yes\";\n}\n"]}
- /* _JS_SOURCE_HASH = "b9707fe65376e19327371edb2ebdda68daa9b9b21220d7ac91ec21ef22520290"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteSSH.js","sourceRoot":"","sources":["remoteSSH.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawnPromise } from \"./spawn\";\n\nconst SSH_CONNECT_TIMEOUT = 10;\nconst EXISTS_MARKER = \"__PORTSECURE_EXISTS__\";\nconst MISSING_MARKER = \"__PORTSECURE_MISSING__\";\nconst MAX_ERROR_BODY_LENGTH = 500;\n\n// /etc is root owned, so fall back to sudo whenever the SSH user is not root.\nexport const SUDO_PREAMBLE = `SUDO=\"\"; if [ \"$(id -u)\" -ne 0 ]; then SUDO=\"sudo -n\"; fi`;\n\n/** No host means this machine, so the very same script runs with nothing in front of it. Local and\n    remote then do exactly the same thing, rather than being two pieces of code that have to be kept\n    saying the same thing. */\nexport const THIS_MACHINE = \"\";\n\nexport function describeHost(host: string) {\n    return host || \"this machine\";\n}\n\n/** The host string is handed to ssh untouched. Users, keys and ports belong in the caller's ssh\n    config, so BatchMode makes a missing setup fail immediately instead of prompting. */\nexport async function runOverSSH(config: { host: string; script: string; input?: string; allowFailure?: boolean }) {\n    let { host, script, input, allowFailure } = config;\n    let result = await spawnPromise({\n        command: host && \"ssh\" || \"sh\",\n        args: host && [\n            \"-o\", \"BatchMode=yes\",\n            \"-o\", `ConnectTimeout=${SSH_CONNECT_TIMEOUT}`,\n            host,\n            script,\n        ] || [\"-c\", script],\n        input,\n        inheritStderr: !allowFailure,\n    });\n    if (result.error) {\n        throw new Error(`Expected to run against ${describeHost(host)}, failed with ${result.error.message}`);\n    }\n    if (result.status !== 0 && !allowFailure) {\n        let advice = host\n            && ` Non-interactive ssh access to ${host} has to work on its own - fix it in your ssh config.`\n            || \"\";\n        throw new Error(\n            `Expected the script on ${describeHost(host)} to exit 0, was ${result.status}.${advice}\\n`\n            + `${(result.stdout + result.stderr).trim().slice(0, MAX_ERROR_BODY_LENGTH)}`\n        );\n    }\n    return { stdout: result.stdout || \"\", stderr: result.stderr || \"\", status: result.status };\n}\n\n/** Returns undefined when the file does not exist, so a missing file reads differently from an\n    empty one. */\nexport async function readRemoteFile(config: { host: string; filePath: string }) {\n    let { host, filePath } = config;\n    let output = (await runOverSSH({\n        host,\n        script: `${SUDO_PREAMBLE}\nif $SUDO test -f \"${filePath}\"; then\n    echo \"${EXISTS_MARKER}\"\n    $SUDO cat \"${filePath}\"\nelse\n    echo \"${MISSING_MARKER}\"\nfi`,\n    })).stdout;\n    let newlineIndex = output.indexOf(\"\\n\");\n    let marker = output.slice(0, newlineIndex).trim();\n    if (marker === MISSING_MARKER) {\n        return undefined;\n    }\n    if (marker !== EXISTS_MARKER) {\n        throw new Error(`Expected ${EXISTS_MARKER} or ${MISSING_MARKER} from ${host}, was ${output.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return output.slice(newlineIndex + 1);\n}\n\nexport async function writeRemoteFile(config: {\n    host: string;\n    filePath: string;\n    contents: string;\n    fileMode: string;\n    directoryMode: string;\n}) {\n    let { host, filePath, contents, fileMode, directoryMode } = config;\n    let directory = filePath.slice(0, filePath.lastIndexOf(\"/\"));\n    await runOverSSH({\n        host,\n        // Deploying from Windows must not carry CRLF onto the target, where it breaks systemd\n        // units and makes private keys unreadable to ssh.\n        input: contents.replace(/\\r\\n/g, \"\\n\"),\n        script: `${SUDO_PREAMBLE}\nset -e\n$SUDO mkdir -p \"${directory}\"\n$SUDO chmod ${directoryMode} \"${directory}\"\n$SUDO tee \"${filePath}\" > /dev/null\n$SUDO chmod ${fileMode} \"${filePath}\"`,\n    });\n}\n\nexport async function remoteCommandExists(config: { host: string; command: string }) {\n    let { host, command } = config;\n    let result = await runOverSSH({\n        host,\n        script: `command -v \"${command}\" > /dev/null 2>&1 && echo yes || echo no`,\n        allowFailure: true,\n    });\n    return result.stdout.trim() === \"yes\";\n}\n"]}
+ /* _JS_SOURCE_HASH = "50b1a08f2aa4b96f04f676f20c516bc6c2897a47ad7c12729c0f651735c71057"; */

package/security/machines/addMachine.ts

@@ -0,0 +1,83 @@
+import os from "os";
+import { getOwnIPs } from "../../misc/ownIPs";
+import { describeHost } from "../helpers/remoteSSH";
+import { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from "./identity";
+import { machineState, resolveKeysRepo } from "./machines";
+
+const USAGE = `Usage: yarn addmachine <domain> [ip]
+
+The domain is required: a machine has a different identity, and so a different machine id, under
+every domain it runs under, so there is no such thing as "this machine" without one.
+
+With no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh
+for its identity under that domain, gives it one if it has none, and adds it under that address.
+
+It edits the keys repo this machine reads, wherever that is, not whatever directory this was run
+from. Nothing is signed or pushed here. Run "yarn signfiles git" in that repo afterwards, or no
+machine will believe any of it.`;
+
+export async function main() {
+    let argv = process.argv.slice(2);
+    if (!argv.length || argv.length > 2) {
+        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let [domain, host = ""] = argv;
+    // The same repo the acceptance check reads. Editing anything else would write a machine list
+    // nothing on this machine ever looks at.
+    let { repoPath } = await resolveKeysRepo();
+
+    let identity: Identity;
+    let addresses: string[];
+    if (!host) {
+        let found = await localIdentity(domain);
+        if (!found) {
+            throw new Error(
+                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\n`
+                + `It has: ${(await localDomains()).join(", ") || "no identities at all"}\n`
+                + `One is generated the first time something runs here under a domain, so run that`
+                + ` first, or name another machine to add instead.`
+            );
+        }
+        identity = found;
+        addresses = await getOwnIPs();
+        if (!addresses.length) {
+            throw new Error(`Expected this machine to have an address anything else can see, it has none`);
+        }
+    } else {
+        // Nothing there under this domain means it gets one. Its own from this point on: the key
+        // is written there and nothing keeps a copy.
+        let found = await remoteIdentity(host, domain);
+        if (!found) {
+            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);
+        }
+        identity = found || await createRemoteIdentity({ host, domain });
+        // The address it was named by is the address it talks to us from, which is the one thing
+        // it cannot lie about.
+        addresses = [host];
+    }
+
+    // The whole list is read and written back, because setting is by the set: writing this one
+    // machine alone would remove every other machine from the repo.
+    let machines = await machineState({ repoPath });
+    let existing = machines.find(machine => machine.machineId === identity.machineId);
+    let ips = [...(existing?.ips || [])];
+    let added = addresses.filter(address => !ips.includes(address));
+    if (existing) {
+        existing.ips = [...ips, ...added];
+    } else {
+        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: "" });
+    }
+    await machineState({ repoPath, machines });
+
+    console.log(`\nTrusting machine ${identity.machineId}`);
+    console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
+    if (added.length) {
+        console.log(`  added to machines/${identity.machineId}.json: ${added.join(", ")}`);
+    } else {
+        console.log(`  already allowed from ${addresses.join(", ")}`);
+    }
+    console.log(`  identity ${identity.fullDomain}`);
+    console.log(`  in ${repoPath}`);
+    console.log(`\nNothing believes this until it is signed. In that repo, run:`);
+    console.log(`\`\`\`\nyarn signfiles git\n\`\`\``);
+}

package/security/machines/dist/addMachine.ts.cache

@@ -0,0 +1,88 @@
+"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 os_1 = __importDefault(require("os"));
+const ownIPs_1 = require("../../misc/ownIPs");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+const identity_1 = require("./identity");
+const machines_1 = require("./machines");
+const USAGE = `Usage: yarn addmachine <domain> [ip]
+
+The domain is required: a machine has a different identity, and so a different machine id, under
+every domain it runs under, so there is no such thing as "this machine" without one.
+
+With no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh
+for its identity under that domain, gives it one if it has none, and adds it under that address.
+
+It edits the keys repo this machine reads, wherever that is, not whatever directory this was run
+from. Nothing is signed or pushed here. Run "yarn signfiles git" in that repo afterwards, or no
+machine will believe any of it.`;
+async function main() {
+    let argv = process.argv.slice(2);
+    if (!argv.length || argv.length > 2) {
+        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let [domain, host = ""] = argv;
+    // The same repo the acceptance check reads. Editing anything else would write a machine list
+    // nothing on this machine ever looks at.
+    let { repoPath } = await (0, machines_1.resolveKeysRepo)();
+    let identity;
+    let addresses;
+    if (!host) {
+        let found = await (0, identity_1.localIdentity)(domain);
+        if (!found) {
+            throw new Error(`Expected an identity for ${domain} in ${os_1.default.homedir()}, this machine has none.\n`
+                + `It has: ${(await (0, identity_1.localDomains)()).join(", ") || "no identities at all"}\n`
+                + `One is generated the first time something runs here under a domain, so run that`
+                + ` first, or name another machine to add instead.`);
+        }
+        identity = found;
+        addresses = await (0, ownIPs_1.getOwnIPs)();
+        if (!addresses.length) {
+            throw new Error(`Expected this machine to have an address anything else can see, it has none`);
+        }
+    }
+    else {
+        // Nothing there under this domain means it gets one. Its own from this point on: the key
+        // is written there and nothing keeps a copy.
+        let found = await (0, identity_1.remoteIdentity)(host, domain);
+        if (!found) {
+            console.log(`${(0, remoteSSH_1.describeHost)(host)} has no identity for ${domain}, generating one`);
+        }
+        identity = found || await (0, identity_1.createRemoteIdentity)({ host, domain });
+        // The address it was named by is the address it talks to us from, which is the one thing
+        // it cannot lie about.
+        addresses = [host];
+    }
+    // The whole list is read and written back, because setting is by the set: writing this one
+    // machine alone would remove every other machine from the repo.
+    let machines = await (0, machines_1.machineState)({ repoPath });
+    let existing = machines.find(machine => machine.machineId === identity.machineId);
+    let ips = [...((existing === null || existing === void 0 ? void 0 : existing.ips) || [])];
+    let added = addresses.filter(address => !ips.includes(address));
+    if (existing) {
+        existing.ips = [...ips, ...added];
+    }
+    else {
+        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: "" });
+    }
+    await (0, machines_1.machineState)({ repoPath, machines });
+    console.log(`\nTrusting machine ${identity.machineId}`);
+    console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
+    if (added.length) {
+        console.log(`  added to machines/${identity.machineId}.json: ${added.join(", ")}`);
+    }
+    else {
+        console.log(`  already allowed from ${addresses.join(", ")}`);
+    }
+    console.log(`  identity ${identity.fullDomain}`);
+    console.log(`  in ${repoPath}`);
+    console.log(`\nNothing believes this until it is signed. In that repo, run:`);
+    console.log(`\`\`\`\nyarn signfiles git\n\`\`\``);
+}
+exports.main = main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addMachine.js","sourceRoot":"","sources":["addMachine.ts"],"names":[],"mappings":"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","sourcesContent":["import os from \"os\";\nimport { getOwnIPs } from \"../../misc/ownIPs\";\nimport { describeHost } from \"../helpers/remoteSSH\";\nimport { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from \"./identity\";\nimport { machineState, resolveKeysRepo } from \"./machines\";\n\nconst USAGE = `Usage: yarn addmachine <domain> [ip]\n\nThe domain is required: a machine has a different identity, and so a different machine id, under\nevery domain it runs under, so there is no such thing as \"this machine\" without one.\n\nWith no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh\nfor its identity under that domain, gives it one if it has none, and adds it under that address.\n\nIt edits the keys repo this machine reads, wherever that is, not whatever directory this was run\nfrom. Nothing is signed or pushed here. Run \"yarn signfiles git\" in that repo afterwards, or no\nmachine will believe any of it.`;\n\nexport async function main() {\n    let argv = process.argv.slice(2);\n    if (!argv.length || argv.length > 2) {\n        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\\n${USAGE}`);\n    }\n    let [domain, host = \"\"] = argv;\n    // The same repo the acceptance check reads. Editing anything else would write a machine list\n    // nothing on this machine ever looks at.\n    let { repoPath } = await resolveKeysRepo();\n\n    let identity: Identity;\n    let addresses: string[];\n    if (!host) {\n        let found = await localIdentity(domain);\n        if (!found) {\n            throw new Error(\n                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\\n`\n                + `It has: ${(await localDomains()).join(\", \") || \"no identities at all\"}\\n`\n                + `One is generated the first time something runs here under a domain, so run that`\n                + ` first, or name another machine to add instead.`\n            );\n        }\n        identity = found;\n        addresses = await getOwnIPs();\n        if (!addresses.length) {\n            throw new Error(`Expected this machine to have an address anything else can see, it has none`);\n        }\n    } else {\n        // Nothing there under this domain means it gets one. Its own from this point on: the key\n        // is written there and nothing keeps a copy.\n        let found = await remoteIdentity(host, domain);\n        if (!found) {\n            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);\n        }\n        identity = found || await createRemoteIdentity({ host, domain });\n        // The address it was named by is the address it talks to us from, which is the one thing\n        // it cannot lie about.\n        addresses = [host];\n    }\n\n    // The whole list is read and written back, because setting is by the set: writing this one\n    // machine alone would remove every other machine from the repo.\n    let machines = await machineState({ repoPath });\n    let existing = machines.find(machine => machine.machineId === identity.machineId);\n    let ips = [...(existing?.ips || [])];\n    let added = addresses.filter(address => !ips.includes(address));\n    if (existing) {\n        existing.ips = [...ips, ...added];\n    } else {\n        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: \"\" });\n    }\n    await machineState({ repoPath, machines });\n\n    console.log(`\\nTrusting machine ${identity.machineId}`);\n    console.log(`Allowing IP ${[...ips, ...added].join(\", \")}`);\n    if (added.length) {\n        console.log(`  added to machines/${identity.machineId}.json: ${added.join(\", \")}`);\n    } else {\n        console.log(`  already allowed from ${addresses.join(\", \")}`);\n    }\n    console.log(`  identity ${identity.fullDomain}`);\n    console.log(`  in ${repoPath}`);\n    console.log(`\\nNothing believes this until it is signed. In that repo, run:`);\n    console.log(`\\`\\`\\`\\nyarn signfiles git\\n\\`\\`\\``);\n}\n"]}
+ /* _JS_SOURCE_HASH = "8b6a7e13912660fd6733b2585e4fec0865a5548fe5846ee6e23f46c506f83e34"; */

package/security/machines/dist/identity.ts.cache

@@ -0,0 +1,176 @@
+"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.verifyTrustPacket = exports.signTrustPacket = exports.createRemoteIdentity = exports.remoteIdentity = exports.localIdentityKeys = exports.localIdentity = exports.localDomains = exports.PACKET_LIFETIME = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const certs_1 = require("../../misc/https/certs");
+const remoteSSH_1 = require("../helpers/remoteSSH");
+// A machine's identity is the CA it generated for itself, kept in one file in the home directory
+// of whoever runs it. The name carries the domain it belongs to, so a machine can hold one per
+// domain, and the id itself is a hash of that CA's public key - which is why a machine cannot
+// claim to be another one without holding its key.
+const IDENTITY_PREFIX = "keystore_";
+const IDENTITY_SUFFIX = `_${certs_1.identityStorageKey}.json`;
+// How stale a signed packet may be. Long enough for clock skew between two machines, short enough
+// that a captured packet is not worth replaying.
+exports.PACKET_LIFETIME = 2 * 60 * 1000;
+function identityFileName(domain) {
+    return `${IDENTITY_PREFIX}${domain}${IDENTITY_SUFFIX}`;
+}
+/** The domain out of an identity file's name, or "" if it is not one. */
+function domainOfFileName(fileName) {
+    if (!fileName.startsWith(IDENTITY_PREFIX) || !fileName.endsWith(IDENTITY_SUFFIX)) {
+        return "";
+    }
+    return fileName.slice(IDENTITY_PREFIX.length, -IDENTITY_SUFFIX.length);
+}
+function describeIdentity(config) {
+    let { domain, stored } = config;
+    return {
+        machineId: (0, certs_1.getMachineId)(stored.domain, domain),
+        domain,
+        fullDomain: stored.domain,
+        fileName: identityFileName(domain),
+    };
+}
+/** Every domain this machine holds an identity under. A machine has one identity per domain, and
+    they are different machine ids, so which one is meant is a real question rather than a detail. */
+async function localDomains() {
+    let domains = [];
+    for (let name of (await promises_1.default.readdir(os_1.default.homedir()).catch(() => [])).sort()) {
+        let domain = domainOfFileName(name);
+        if (domain) {
+            domains.push(domain);
+        }
+    }
+    return domains;
+}
+exports.localDomains = localDomains;
+/** This machine's identity under one domain. Undefined when it has none under that one.
+
+    The domain is required everywhere it appears. A machine has a different identity, and so a
+    different machine id, under every domain it runs under, so "this machine" on its own does not
+    name anything: answering under the wrong one means answering as a machine we are not. */
+async function localIdentity(domain) {
+    if (!domain) {
+        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);
+    }
+    let contents = await promises_1.default.readFile(path_1.default.join(os_1.default.homedir(), identityFileName(domain)), "utf8").catch(() => "");
+    if (!contents) {
+        return undefined;
+    }
+    return describeIdentity({ domain, stored: JSON.parse(contents) });
+}
+exports.localIdentity = localIdentity;
+/** This machine's identity and its keys, for signing. */
+async function localIdentityKeys(domain) {
+    let identity = await localIdentity(domain);
+    if (!identity) {
+        throw new Error(`Expected an identity for ${domain} at ${path_1.default.join(os_1.default.homedir(), identityFileName(domain))},`
+            + ` there is none.\n`
+            + `This machine has: ${(await localDomains()).join(", ") || "no identities at all"}`);
+    }
+    let stored = JSON.parse(await promises_1.default.readFile(path_1.default.join(os_1.default.homedir(), identity.fileName), "utf8"));
+    return { identity, stored };
+}
+exports.localIdentityKeys = localIdentityKeys;
+/** The identity of another machine under one domain, over ssh. Undefined when it has none under
+    that domain, whatever else it may have under others. */
+async function remoteIdentity(host, domain) {
+    if (!domain) {
+        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);
+    }
+    let home = (await (0, remoteSSH_1.runOverSSH)({ host, script: `echo $HOME` })).stdout.trim();
+    if (!home) {
+        throw new Error(`Expected ${host} to report a home directory, it reported nothing`);
+    }
+    let contents = await (0, remoteSSH_1.runOverSSH)({
+        host,
+        script: `cat ${home}/${identityFileName(domain)} 2>/dev/null || true`,
+    });
+    if (!contents.stdout.trim()) {
+        return undefined;
+    }
+    return describeIdentity({ domain, stored: JSON.parse(contents.stdout) });
+}
+exports.remoteIdentity = remoteIdentity;
+/** Gives a machine an identity it does not have yet, by generating one here and writing it there.
+
+    The CA is self signed and never leaves that machine afterwards, so generating it here is only a
+    convenience: what matters is that the private key ends up in one place and the id is the hash
+    of its public half. */
+async function createRemoteIdentity(config) {
+    let { host, domain } = config;
+    let generated = (0, certs_1.generateTestCA)(domain);
+    let stored = {
+        domain: generated.domain,
+        certB64: generated.cert.toString("base64"),
+        keyB64: generated.key.toString("base64"),
+    };
+    let home = (await (0, remoteSSH_1.runOverSSH)({ host, script: `echo $HOME` })).stdout.trim();
+    await (0, remoteSSH_1.writeRemoteFile)({
+        host,
+        filePath: `${home}/${identityFileName(domain)}`,
+        contents: JSON.stringify(stored),
+        fileMode: "600",
+        // The home directory is already there, this is only what it is created with if it is not.
+        directoryMode: "700",
+    });
+    return describeIdentity({ domain, stored });
+}
+exports.createRemoteIdentity = createRemoteIdentity;
+/** The raw ed25519 public key out of a certificate, which is what the machine id is a hash of. */
+function publicKeyBytes(certPEM) {
+    let spki = new crypto_1.default.X509Certificate(certPEM).publicKey.export({ type: "spki", format: "der" });
+    // An ed25519 SPKI is a fixed 12 byte header followed by the 32 byte key.
+    return spki.subarray(spki.length - 32);
+}
+/** Proves we hold the private key behind our machine id, right now. The signature covers the id
+    and the time, so the packet cannot be replayed later or reused for another id. */
+async function signTrustPacket(domain) {
+    let { identity, stored } = await localIdentityKeys(domain);
+    let signedAt = Date.now();
+    let signature = crypto_1.default.sign(null, Buffer.from(`${identity.machineId} ${signedAt}`), crypto_1.default.createPrivateKey(Buffer.from(stored.keyB64, "base64").toString()));
+    return {
+        machineId: identity.machineId,
+        certB64: stored.certB64,
+        signedAt,
+        signatureB64: signature.toString("base64"),
+    };
+}
+exports.signTrustPacket = signTrustPacket;
+/** Whether a packet really came from the machine it names. Says why when it did not, because
+    "this is not that machine" and "this arrived too late" are different problems. */
+function verifyTrustPacket(packet) {
+    if (!packet || !packet.machineId || !packet.certB64 || !packet.signatureB64) {
+        return { valid: false, problem: "the packet is missing fields" };
+    }
+    if (Math.abs(Date.now() - packet.signedAt) > exports.PACKET_LIFETIME) {
+        return { valid: false, problem: `it was signed ${Math.round((Date.now() - packet.signedAt) / 1000)}s ago` };
+    }
+    let certPEM = Buffer.from(packet.certB64, "base64").toString();
+    let publicKey;
+    try {
+        publicKey = new crypto_1.default.X509Certificate(certPEM).publicKey;
+    }
+    catch (e) {
+        return { valid: false, problem: `its certificate could not be read, ${e}` };
+    }
+    // The id is a hash of the public key, so this is what stops a machine claiming another's id.
+    if (!(0, certs_1.verifyMachineIdForPublicKey)({ machineId: packet.machineId, publicKey: publicKeyBytes(certPEM) })) {
+        return { valid: false, problem: "the machine id does not belong to that certificate" };
+    }
+    let signed = crypto_1.default.verify(null, Buffer.from(`${packet.machineId} ${packet.signedAt}`), publicKey, Buffer.from(packet.signatureB64, "base64"));
+    if (!signed) {
+        return { valid: false, problem: "the signature does not check out" };
+    }
+    return { valid: true, problem: "" };
+}
+exports.verifyTrustPacket = verifyTrustPacket;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["identity.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { generateTestCA, getMachineId, identityStorageKey, IdentityStorageType, verifyMachineIdForPublicKey } from \"../../misc/https/certs\";\nimport { runOverSSH, writeRemoteFile } from \"../helpers/remoteSSH\";\n\n// A machine's identity is the CA it generated for itself, kept in one file in the home directory\n// of whoever runs it. The name carries the domain it belongs to, so a machine can hold one per\n// domain, and the id itself is a hash of that CA's public key - which is why a machine cannot\n// claim to be another one without holding its key.\nconst IDENTITY_PREFIX = \"keystore_\";\nconst IDENTITY_SUFFIX = `_${identityStorageKey}.json`;\n// How stale a signed packet may be. Long enough for clock skew between two machines, short enough\n// that a captured packet is not worth replaying.\nexport const PACKET_LIFETIME = 2 * 60 * 1000;\n\nexport type Identity = {\n    machineId: string;\n    domain: string;\n    fullDomain: string;\n    fileName: string;\n};\n\nfunction identityFileName(domain: string) {\n    return `${IDENTITY_PREFIX}${domain}${IDENTITY_SUFFIX}`;\n}\n\n/** The domain out of an identity file's name, or \"\" if it is not one. */\nfunction domainOfFileName(fileName: string) {\n    if (!fileName.startsWith(IDENTITY_PREFIX) || !fileName.endsWith(IDENTITY_SUFFIX)) {\n        return \"\";\n    }\n    return fileName.slice(IDENTITY_PREFIX.length, -IDENTITY_SUFFIX.length);\n}\n\nfunction describeIdentity(config: { domain: string; stored: IdentityStorageType }) {\n    let { domain, stored } = config;\n    return {\n        machineId: getMachineId(stored.domain, domain),\n        domain,\n        fullDomain: stored.domain,\n        fileName: identityFileName(domain),\n    };\n}\n\n/** Every domain this machine holds an identity under. A machine has one identity per domain, and\n    they are different machine ids, so which one is meant is a real question rather than a detail. */\nexport async function localDomains() {\n    let domains: string[] = [];\n    for (let name of (await fs.readdir(os.homedir()).catch(() => [] as string[])).sort()) {\n        let domain = domainOfFileName(name);\n        if (domain) {\n            domains.push(domain);\n        }\n    }\n    return domains;\n}\n\n/** This machine's identity under one domain. Undefined when it has none under that one.\n\n    The domain is required everywhere it appears. A machine has a different identity, and so a\n    different machine id, under every domain it runs under, so \"this machine\" on its own does not\n    name anything: answering under the wrong one means answering as a machine we are not. */\nexport async function localIdentity(domain: string): Promise<Identity | undefined> {\n    if (!domain) {\n        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);\n    }\n    let contents = await fs.readFile(path.join(os.homedir(), identityFileName(domain)), \"utf8\").catch(() => \"\");\n    if (!contents) {\n        return undefined;\n    }\n    return describeIdentity({ domain, stored: JSON.parse(contents) });\n}\n\n/** This machine's identity and its keys, for signing. */\nexport async function localIdentityKeys(domain: string) {\n    let identity = await localIdentity(domain);\n    if (!identity) {\n        throw new Error(\n            `Expected an identity for ${domain} at ${path.join(os.homedir(), identityFileName(domain))},`\n            + ` there is none.\\n`\n            + `This machine has: ${(await localDomains()).join(\", \") || \"no identities at all\"}`\n        );\n    }\n    let stored: IdentityStorageType = JSON.parse(\n        await fs.readFile(path.join(os.homedir(), identity.fileName), \"utf8\")\n    );\n    return { identity, stored };\n}\n\n/** The identity of another machine under one domain, over ssh. Undefined when it has none under\n    that domain, whatever else it may have under others. */\nexport async function remoteIdentity(host: string, domain: string): Promise<Identity | undefined> {\n    if (!domain) {\n        throw new Error(`Expected a domain, was ${JSON.stringify(domain)}`);\n    }\n    let home = (await runOverSSH({ host, script: `echo $HOME` })).stdout.trim();\n    if (!home) {\n        throw new Error(`Expected ${host} to report a home directory, it reported nothing`);\n    }\n    let contents = await runOverSSH({\n        host,\n        script: `cat ${home}/${identityFileName(domain)} 2>/dev/null || true`,\n    });\n    if (!contents.stdout.trim()) {\n        return undefined;\n    }\n    return describeIdentity({ domain, stored: JSON.parse(contents.stdout) });\n}\n\n/** Gives a machine an identity it does not have yet, by generating one here and writing it there.\n\n    The CA is self signed and never leaves that machine afterwards, so generating it here is only a\n    convenience: what matters is that the private key ends up in one place and the id is the hash\n    of its public half. */\nexport async function createRemoteIdentity(config: { host: string; domain: string }) {\n    let { host, domain } = config;\n    let generated = generateTestCA(domain);\n    let stored: IdentityStorageType = {\n        domain: generated.domain,\n        certB64: generated.cert.toString(\"base64\"),\n        keyB64: generated.key.toString(\"base64\"),\n    };\n    let home = (await runOverSSH({ host, script: `echo $HOME` })).stdout.trim();\n    await writeRemoteFile({\n        host,\n        filePath: `${home}/${identityFileName(domain)}`,\n        contents: JSON.stringify(stored),\n        fileMode: \"600\",\n        // The home directory is already there, this is only what it is created with if it is not.\n        directoryMode: \"700\",\n    });\n    return describeIdentity({ domain, stored });\n}\n\n/** The raw ed25519 public key out of a certificate, which is what the machine id is a hash of. */\nfunction publicKeyBytes(certPEM: string) {\n    let spki = new crypto.X509Certificate(certPEM).publicKey.export({ type: \"spki\", format: \"der\" });\n    // An ed25519 SPKI is a fixed 12 byte header followed by the 32 byte key.\n    return spki.subarray(spki.length - 32);\n}\n\nexport type TrustPacket = {\n    machineId: string;\n    certB64: string;\n    signedAt: number;\n    signatureB64: string;\n};\n\n/** Proves we hold the private key behind our machine id, right now. The signature covers the id\n    and the time, so the packet cannot be replayed later or reused for another id. */\nexport async function signTrustPacket(domain: string): Promise<TrustPacket> {\n    let { identity, stored } = await localIdentityKeys(domain);\n    let signedAt = Date.now();\n    let signature = crypto.sign(\n        null,\n        Buffer.from(`${identity.machineId} ${signedAt}`),\n        crypto.createPrivateKey(Buffer.from(stored.keyB64, \"base64\").toString())\n    );\n    return {\n        machineId: identity.machineId,\n        certB64: stored.certB64,\n        signedAt,\n        signatureB64: signature.toString(\"base64\"),\n    };\n}\n\n/** Whether a packet really came from the machine it names. Says why when it did not, because\n    \"this is not that machine\" and \"this arrived too late\" are different problems. */\nexport function verifyTrustPacket(packet: TrustPacket) {\n    if (!packet || !packet.machineId || !packet.certB64 || !packet.signatureB64) {\n        return { valid: false, problem: \"the packet is missing fields\" };\n    }\n    if (Math.abs(Date.now() - packet.signedAt) > PACKET_LIFETIME) {\n        return { valid: false, problem: `it was signed ${Math.round((Date.now() - packet.signedAt) / 1000)}s ago` };\n    }\n    let certPEM = Buffer.from(packet.certB64, \"base64\").toString();\n    let publicKey: crypto.KeyObject;\n    try {\n        publicKey = new crypto.X509Certificate(certPEM).publicKey;\n    } catch (e) {\n        return { valid: false, problem: `its certificate could not be read, ${e}` };\n    }\n    // The id is a hash of the public key, so this is what stops a machine claiming another's id.\n    if (!verifyMachineIdForPublicKey({ machineId: packet.machineId, publicKey: publicKeyBytes(certPEM) })) {\n        return { valid: false, problem: \"the machine id does not belong to that certificate\" };\n    }\n    let signed = crypto.verify(\n        null,\n        Buffer.from(`${packet.machineId} ${packet.signedAt}`),\n        publicKey,\n        Buffer.from(packet.signatureB64, \"base64\")\n    );\n    if (!signed) {\n        return { valid: false, problem: \"the signature does not check out\" };\n    }\n    return { valid: true, problem: \"\" };\n}\n"]}
+ /* _JS_SOURCE_HASH = "2b16a13142ed08ef2e755cf33ce9a940aaef44261d0b1bdd42b8efe807f54df2"; */