sliftutils 1.7.127 → 1.7.129

package/security/authorizedKeys/unrevoke.ts

@@ -2,12 +2,14 @@ import fs from "fs/promises";
 import os from "os";
 import path from "path";
 import { runPromise } from "socket-function/src/runPromise";
-import { keyFingerprint, normalizeKeys } from "./authorizedKeys";
-import { revokeRepoURL } from "./revokeSource";
+import { allowAddresses, keyFingerprint, normalizeKeys, summarizeKey } from "./authorizedKeys";
+import { deriveRevokeKey, revokeRepoURL } from "./revokeSource";
+import { findSourceKey } from "./sources";
 import { signRepo } from "../signedFiles/signFiles";
 import { readRepoKeys } from "./authorizedKeys";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
+import { machineState } from "../machines/machines";
 
 const UNREVOKES_DIR = "unrevoked";
 const REVOCATIONS_DIR = "revocations";
@@ -22,26 +24,54 @@ passes. It signs the result, and with ${GIT_KEYWORD} it commits and pushes it to
 Keys that were revoked should normally be deleted from the repo instead. Unrevoking only matters
 for a key you still want.`;
 
+/** One revocation event. Either an ssh key used from an address it is not allowed from, or a
+    machine that talked to us from one. Both are the same shape - an identity and an address - and
+    an unrevoke undoes either by allowing that same pair.
+
+    Which is why unrevoking never makes anything unrevokable: used from some other address, it is
+    revoked again, under a new id no existing unrevoke names. */
 export type Revocation = {
     revocationId: string;
-    fingerprint: string;
+    // Exactly one of these. A key revocation names a fingerprint, a machine revocation a machineId.
+    fingerprint?: string;
+    machineId?: string;
+    ip?: string;
     key?: string;
     revokedAt?: string;
     revokedBy?: string;
+    reason?: string;
     attempt?: { ip?: string; user?: string; required?: string };
 };
 
-/** 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. */
+/** Older revocation files carry the address under attempt only. */
+export function revocationIP(revocation: Revocation) {
+    return revocation.ip || revocation.attempt?.ip || "";
+}
+
+/** What the revocation is about, which is what an unrevoke has to name to undo it. */
+export function revocationIdentity(revocation: Revocation) {
+    return revocation.fingerprint || revocation.machineId || "";
+}
+
+/** Every revocation the revoke repo lists. Cloned read only into a temp directory.
+
+    A person running this has their own access to the repo, so their credentials are what is used.
+    On a machine that is already a portsecure host there may be no such credentials, but the source
+    deploy key is right there, and the key derived from it is one that repo definitely accepts. */
 export async function readRemoteRevocations(config: { sourceURL: string }) {
     let { sourceURL } = config;
     let temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "unrevoke-"));
     let repoPath = path.join(temporaryDirectory, "repo");
-    let clone = await spawnPromise({
-        command: "git",
-        args: ["clone", "--depth", "1", revokeRepoURL(sourceURL), repoPath],
-    });
+    let cloneArgs = ["clone", "--depth", "1", revokeRepoURL(sourceURL), repoPath];
+    let sourceKey = await findSourceKey(sourceURL);
+    if (sourceKey) {
+        let derived = deriveRevokeKey(await fs.readFile(sourceKey, "utf8"));
+        let derivedKeyPath = path.join(temporaryDirectory, "key");
+        await fs.writeFile(derivedKeyPath, derived.privateKeyFile, { mode: 0o600 });
+        let sshCommand = `ssh -i ${derivedKeyPath} -o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=accept-new`;
+        cloneArgs = ["-c", `core.sshCommand=${sshCommand}`, ...cloneArgs];
+    }
+    let clone = await spawnPromise({ command: "git", args: cloneArgs });
     if (clone.status !== 0) {
         await fs.rm(temporaryDirectory, { recursive: true, force: true });
         throw new Error(
@@ -77,6 +107,10 @@ export async function revokedKeysInRepo(config: { repoPath: string; sourceURL: s
                 continue;
             }
             let parsed = JSON.parse(await fs.readFile(path.join(directory, name), "utf8"));
+            for (let allowed of parsed.allowed || []) {
+                unrevoked.add(`${allowed.fingerprint || allowed.machineId} ${allowed.ip}`);
+            }
+            // Named ids, for the unrevokes written before this was about pairs.
             for (let revocationId of parsed.revocationIds || []) {
                 unrevoked.add(revocationId);
             }
@@ -84,13 +118,84 @@ export async function revokedKeysInRepo(config: { repoPath: string; sourceURL: s
     } catch (e) {
         // Nothing has been unrevoked.
     }
-    let stillRevoked = revocations.filter(revocation => !unrevoked.has(revocation.revocationId));
+    let stillRevoked = revocations.filter(revocation => !unrevoked.has(revocation.revocationId)
+        && !unrevoked.has(`${revocation.fingerprint} ${revocationIP(revocation)}`));
     let keys = normalizeKeys(await fs.readFile(path.join(repoPath, "authorized_keys"), "utf8").catch(() => ""));
     return stillRevoked
         .filter(revocation => keys.some(key => keyFingerprint(key) === revocation.fingerprint))
         .map(revocation => ({ revocation, key: keys.find(key => keyFingerprint(key) === revocation.fingerprint) || "" }));
 }
 
+/** Writes the addresses into the from= list of each key in the repo's authorized_keys, and says
+    which ones were actually new. Only the lines being changed are touched, so comments, ordering
+    and any key not involved come out of this byte for byte the same. */
+async function allowAddressesInRepo(config: {
+    repoPath: string;
+    addressesByFingerprint: Map<string, string[]>;
+}) {
+    let { repoPath, addressesByFingerprint } = config;
+    let added = new Map<string, string[]>();
+    let filePath = path.join(repoPath, "authorized_keys");
+    let contents;
+    try {
+        contents = await fs.readFile(filePath, "utf8");
+    } catch (e) {
+        // A repo holding its keys as separate .pub files. Nothing to edit in one place, so the
+        // caller's listing is all whoever ran this gets.
+        console.log(`No authorized_keys in ${repoPath}, so the addresses were not added to any key.`);
+        return added;
+    }
+    let lines = contents.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+        let fingerprint = keyFingerprint(lines[index]);
+        let addresses = fingerprint && addressesByFingerprint.get(fingerprint);
+        if (!addresses || !addresses.length) {
+            continue;
+        }
+        let result = allowAddresses(lines[index], addresses);
+        lines[index] = result.keyLine;
+        added.set(fingerprint, [...(added.get(fingerprint) || []), ...result.added]);
+    }
+    if ([...added.values()].some(list => list.length)) {
+        await fs.writeFile(filePath, lines.join("\n"));
+    }
+    return added;
+}
+
+/** Puts each machine's addresses back into its own file, which is the machine equivalent of adding
+    an address to a key's from= list: without it the machine is allowed again in principle and
+    still rejected on sight, which revokes it once more. */
+async function allowAddressesForMachines(config: { repoPath: string; revocations: Revocation[] }) {
+    let { repoPath, revocations } = config;
+    let added = new Map<string, string[]>();
+    // Read the whole list, change what these revocations are about, write it back. Setting is by
+    // the whole set, so writing one machine at a time would delete every other machine.
+    let machines = await machineState({ repoPath });
+    for (let revocation of revocations) {
+        let machineId = revocation.machineId;
+        let ip = revocationIP(revocation);
+        if (!machineId || !ip) {
+            continue;
+        }
+        let existing = machines.find(machine => machine.machineId === machineId);
+        if (!existing) {
+            // Removed from the repo since it was revoked, so there is nothing to allow. Deleting a
+            // machine is the stronger statement and it stands.
+            console.log(`machines/${machineId}.json is not in this repo, so ${ip} was not added to it`);
+            continue;
+        }
+        if (existing.ips.includes(ip)) {
+            continue;
+        }
+        existing.ips = [...existing.ips, ip];
+        added.set(machineId, [...(added.get(machineId) || []), ip]);
+    }
+    if (added.size) {
+        await machineState({ repoPath, machines });
+    }
+    return added;
+}
+
 /** 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: string | undefined) {
@@ -140,22 +245,77 @@ export async function main() {
     await fs.writeFile(path.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),
+        // What this file says: each of these keys is allowed from this address. Pairs, not keys,
+        // and not a blanket "allow everything again" - a key forgiven here for one address is
+        // still revoked the moment it is used from another.
+        allowed: revocations.map(revocation => ({
+            fingerprint: revocation.fingerprint,
+            machineId: revocation.machineId,
+            ip: revocationIP(revocation),
+        })),
         revocations: revocations.map(revocation => ({
             revocationId: revocation.revocationId,
             fingerprint: revocation.fingerprint,
+            machineId: revocation.machineId,
+            ip: revocationIP(revocation),
             revokedAt: revocation.revokedAt,
             revokedBy: revocation.revokedBy,
             attempt: revocation.attempt,
         })),
     }, undefined, 4) + "\n");
 
-    console.log(`Wrote ${UNREVOKES_DIR}/${unrevokeId}.json covering ${revocations.length} revocation(s):`);
+    // Named the way the notifications name them. A fingerprint is not in authorized_keys and
+    // cannot be worked out by eye, so on its own it tells whoever is reading this nothing about
+    // which of their keys is being talked about.
+    let keysByFingerprint = new Map<string, string>();
+    for (let key of await readRepoKeys(repoPath).catch(() => [] as string[])) {
+        keysByFingerprint.set(keyFingerprint(key), key);
+    }
+    let describeKey = (revocation: Revocation) => {
+        let key = keysByFingerprint.get(revocation.fingerprint || "") || revocation.key || "";
+        return key && summarizeKey(key) || `a key no longer in this repo (${revocation.fingerprint})`;
+    };
+
+    let addressesByIdentity = new Map<string, string[]>();
     for (let revocation of revocations) {
-        console.log(`  ${revocation.fingerprint} revoked by ${revocation.revokedBy || "?"} from ${revocation.attempt?.ip || "?"}`);
+        let ip = revocationIP(revocation);
+        let identity = revocationIdentity(revocation);
+        let existing = addressesByIdentity.get(identity) || [];
+        if (ip && !existing.includes(ip)) {
+            existing.push(ip);
+        }
+        addressesByIdentity.set(identity, existing);
+    }
+
+    // Cancelling the revocation on its own would leave sshd refusing that address, and the machines
+    // revoking all over again, so the addresses go into the key's from= list and into the machine's
+    // own file here. We are in the repo that owns both, so there is nothing to hand back to whoever
+    // ran this.
+    let added = await allowAddressesInRepo({ repoPath, addressesByFingerprint: addressesByIdentity });
+    let addedForMachines = await allowAddressesForMachines({ repoPath, revocations });
+
+    console.log("");
+    for (let [identity, addresses] of addressesByIdentity) {
+        let entries = revocations.filter(entry => revocationIdentity(entry) === identity);
+        let machineId = entries[0].machineId;
+        console.log(`Unfreezing ${machineId && `machine ${machineId}` || describeKey(entries[0])}`);
+        console.log(`Allowing IP ${addresses.join(", ") || "(no address recorded)"}`);
+        let addedHere = machineId && addedForMachines.get(machineId) || added.get(identity) || [];
+        if (addedHere.length) {
+            let where = machineId && `machines/${machineId}.json` || `that key's from= list in authorized_keys`;
+            console.log(`  added to ${where}: ${addedHere.join(", ")}`);
+        } else {
+            console.log(`  already allowed from ${addresses.join(", ") || "everywhere"}`);
+        }
+        for (let entry of entries) {
+            console.log(
+                `  frozen by ${entry.revokedBy || "?"} ${entry.revokedAt || "at an unrecorded time"}`
+            );
+        }
+        console.log("");
     }
+    console.log(`Every other address stays frozen, and any of these used from anywhere else is`);
+    console.log(`frozen again.`);
 
     // 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.

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":";;;AAAA,mCAAuC;AAEvC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAC/B,MAAM,aAAa,GAAG,uBAAuB,CAAC;AAC9C,MAAM,cAAc,GAAG,wBAAwB,CAAC;AAChD,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAElC,8EAA8E;AACjE,QAAA,aAAa,GAAG,2DAA2D,CAAC;AAEzF;;6BAE6B;AAChB,QAAA,YAAY,GAAG,EAAE,CAAC;AAE/B,SAAgB,YAAY,CAAC,IAAY;IACrC,OAAO,IAAI,IAAI,cAAc,CAAC;AAClC,CAAC;AAFD,oCAEC;AAED;wFACwF;AACjF,KAAK,UAAU,UAAU,CAAC,MAAgF;IAC7G,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IACnD,IAAI,MAAM,GAAG,MAAM,IAAA,oBAAY,EAAC;QAC5B,OAAO,EAAE,IAAI,IAAI,KAAK,IAAI,IAAI;QAC9B,IAAI,EAAE,IAAI,IAAI;YACV,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,kBAAkB,mBAAmB,EAAE;YAC7C,IAAI;YACJ,MAAM;SACT,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC;QACnB,KAAK;QACL,aAAa,EAAE,CAAC,YAAY;KAC/B,CAAC,CAAC;IACH,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,2BAA2B,YAAY,CAAC,IAAI,CAAC,iBAAiB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IAC1G,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QACvC,IAAI,MAAM,GAAG,IAAI;eACV,kCAAkC,IAAI,sDAAsD;eAC5F,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACX,0BAA0B,YAAY,CAAC,IAAI,CAAC,mBAAmB,MAAM,CAAC,MAAM,IAAI,MAAM,IAAI;cACxF,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,EAAE,CAChF,CAAC;IACN,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAC/F,CAAC;AA1BD,gCA0BC;AAED;iBACiB;AACV,KAAK,UAAU,cAAc,CAAC,MAA0C;IAC3E,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IAChC,IAAI,MAAM,GAAG,CAAC,MAAM,UAAU,CAAC;QAC3B,IAAI;QACJ,MAAM,EAAE,GAAG,qBAAa;oBACZ,QAAQ;YAChB,aAAa;iBACR,QAAQ;;YAEb,cAAc;GACvB;KACE,CAAC,CAAC,CAAC,MAAM,CAAC;IACX,IAAI,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;IAClD,IAAI,MAAM,KAAK,cAAc,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,MAAM,KAAK,aAAa,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,YAAY,aAAa,OAAO,cAAc,SAAS,IAAI,SAAS,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAClI,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;AAC1C,CAAC;AArBD,wCAqBC;AAEM,KAAK,UAAU,eAAe,CAAC,MAMrC;IACG,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,CAAC;IACnE,IAAI,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7D,MAAM,UAAU,CAAC;QACb,IAAI;QACJ,sFAAsF;QACtF,kDAAkD;QAClD,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;QACtC,MAAM,EAAE,GAAG,qBAAa;;kBAEd,SAAS;cACb,aAAa,KAAK,SAAS;aAC5B,QAAQ;cACP,QAAQ,KAAK,QAAQ,GAAG;KACjC,CAAC,CAAC;AACP,CAAC;AArBD,0CAqBC;AAEM,KAAK,UAAU,mBAAmB,CAAC,MAAyC;IAC/E,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAC/B,IAAI,MAAM,GAAG,MAAM,UAAU,CAAC;QAC1B,IAAI;QACJ,MAAM,EAAE,eAAe,OAAO,2CAA2C;QACzE,YAAY,EAAE,IAAI;KACrB,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,KAAK,CAAC;AAC1C,CAAC;AARD,kDAQC","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"; */