sliftutils 1.7.128 → 1.7.130

package/security/authorizedKeys/secureSSH.ts

@@ -7,6 +7,7 @@ import { findSourceKey, KEYS_DIR_NAME, sourceKeyPath, sourceName, sourceRepoPath
 import { deriveRevokeKey, REVOKE_KEY_LABEL, revokeRepoURL } from "./revokeSource";
 import { legacySourceKeyPath } from "./sources";
 import { revokedKeysInRepo } from "./unrevoke";
+import { resolveKeysRepo } from "./keysRepo";
 import { expandHome } from "../helpers/paths";
 import { spawnPromise } from "../helpers/spawn";
 import { describeHost, readRemoteFile, remoteCommandExists, runOverSSH, SUDO_PREAMBLE, THIS_MACHINE, writeRemoteFile } from "../helpers/remoteSSH";
@@ -155,38 +156,15 @@ async function cloneRepoForInspection(config: { repoURL: string; keyPath: string
     return repoPath;
 }
 
-/** With no repo url given, the repo we are standing in is used. It has to actually hold keys
-    before we hand it to a host, so a stray working directory cannot be deployed by accident. */
+/** With no repo url given, the keys repo this machine resolves to is used - the one we are
+    standing in when that holds keys, and this machine's own otherwise. */
 async function resolveRepoURL(passedURL: string | undefined) {
     if (passedURL) {
         return normalizeRepoURL(passedURL);
     }
-    let topLevel = await runLocal({ command: "git", args: ["rev-parse", "--show-toplevel"], allowFailure: true });
-    if (topLevel.status !== 0) {
-        throw new Error(`Expected a repo url, or the current directory to be inside a git repo, it is not.\n${USAGE}`);
-    }
-    let repoPath = topLevel.stdout.trim();
-    try {
-        await readRepoKeys(repoPath);
-    } catch (e) {
-        throw new Error(
-            `Expected a repo url, or the current repo (${repoPath}) to hold keys, it does not.\n${e}\n${USAGE}`
-        );
-    }
-    let origin = await runLocal({
-        command: "git",
-        args: ["remote", "get-url", "origin"],
-        cwd: repoPath,
-        allowFailure: true,
-    });
-    if (origin.status !== 0 || !origin.stdout.trim()) {
-        throw new Error(
-            `Expected the current repo (${repoPath}) to have an origin remote, it has none.`
-            + ` The host clones the source itself, so a local path is no use to it.`
-        );
-    }
-    let repoURL = normalizeRepoURL(origin.stdout.trim());
-    console.log(`No repo url given, using the current repo: ${repoURL}`);
+    let { repoPath, sourceURL } = await resolveKeysRepo();
+    let repoURL = normalizeRepoURL(sourceURL);
+    console.log(`No repo url given, using ${repoPath}: ${repoURL}`);
     return repoURL;
 }
 
@@ -449,6 +427,31 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
         console.log(`${describeHost(host)} already has ${repoURL}, refreshing its key and the daemon.`);
     }
 
+    // Copied into place before anything else needs it. The checks below look this source's key up
+    // where the machine keeps it, not at the path it was handed on the command line, so a key that
+    // is still only sitting in the caller's directory reads as no key at all.
+    //
+    // Into the home of whoever the daemon runs as, which is where it looks. Asked of the host
+    // rather than worked out here: this may be running on a machine with no such user, and with a
+    // home directory in an entirely different shape.
+    let hostKeysDirectory = await daemonKeysDir(host);
+    await writeRemoteFile({
+        host,
+        filePath: `${hostKeysDirectory}/${sourceName(repoURL)}`,
+        contents: await fs.readFile(keyPath, "utf8"),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    // The public half too, so the deploy key that a repo was given can be looked up on the machine
+    // using it, rather than only in whatever github shows.
+    await writeRemoteFile({
+        host,
+        filePath: `${hostKeysDirectory}/${sourceName(repoURL)}.pub`,
+        contents: await publicKeyOf(keyPath),
+        fileMode: "644",
+        directoryMode: "700",
+    });
+
     // The merged result is what root ends up with, so our own key has to be somewhere in it. On
     // this machine there is no ssh session to preserve, so there is nothing to check.
     let ourFingerprint = "";
@@ -490,27 +493,6 @@ async function addSource(config: { host: string; keyPath: string; repoURL: strin
     let webhookURL = await requireRemoteWebhook(host);
     console.log(`${describeHost(host)} notifies ${webhookURL}`);
 
-    // Into the home of whoever the daemon runs as, which is where it looks. Asked of the host
-    // rather than worked out here: this may be running on a machine with no such user, and with a
-    // home directory in an entirely different shape.
-    let hostKeysDirectory = await daemonKeysDir(host);
-    await writeRemoteFile({
-        host,
-        filePath: `${hostKeysDirectory}/${sourceName(repoURL)}`,
-        contents: await fs.readFile(keyPath, "utf8"),
-        fileMode: "600",
-        directoryMode: "700",
-    });
-    // The public half too, so the deploy key that a repo was given can be looked up on the machine
-    // using it, rather than only in whatever github shows.
-    await writeRemoteFile({
-        host,
-        filePath: `${hostKeysDirectory}/${sourceName(repoURL)}.pub`,
-        contents: await publicKeyOf(keyPath),
-        fileMode: "644",
-        directoryMode: "700",
-    });
-
     let repoSources = remoteConfig.repoSources.filter(source => source !== repoURL);
     repoSources.push(repoURL);
     await installDaemon({ host, hostLabel: remoteConfig.hostLabel, repoSources });
@@ -634,32 +616,58 @@ function parseArgs(argv: string[]) {
         host = positional[0];
         positional = positional.slice(1);
     }
+
+    // How many arguments each verb takes, checked here rather than where the verb is acted on, so
+    // that a command which was typed wrong says so before anything else is complained about.
+    if (verb === "list" && positional.length) {
+        throw new Error(`Expected nothing after list, was ${positional.length} argument(s)\n${USAGE}`);
+    }
+    if (verb === "update" && positional.length) {
+        throw new Error(`Expected nothing after update, was ${positional.length} argument(s)\n${USAGE}`);
+    }
+    if (verb === "add" && (!positional.length || positional.length > 2)) {
+        throw new Error(`Expected a private key and optionally a repo url, was ${positional.length} argument(s)\n${USAGE}`);
+    }
+    if (verb === "remove" && positional.length > 1) {
+        throw new Error(`Expected at most a repo url to remove, was ${positional.length} argument(s)\n${USAGE}`);
+    }
     return { verb, host, rest: positional };
 }
 
+/** Everything here is root's: root's authorized_keys, root's keys directory, the sshd config, the
+    systemd unit. Run as anyone else it reads a different home and writes files the daemon will
+    never see, and it gets there several steps in rather than failing at the start. */
+function requireRoot() {
+    let uid = process.getuid?.();
+    if (uid !== 0) {
+        throw new Error(
+            `Expected to be running as root, is uid ${uid ?? "unknown"}.\n`
+            + `Rerun this with sudo.`
+        );
+    }
+}
+
 export async function main() {
+    // What was typed is checked before anything about this machine is. A command that does not
+    // make sense is worth saying so about whoever is running it, and being told to find sudo only
+    // to then be told the arguments were wrong is two trips for one mistake.
     let { verb, host, rest } = parseArgs(process.argv.slice(2));
+    // With a host, everything root-owned happens on that host through $SUDO over ssh, so being root here proves nothing and would block running this from a workstation.
+    if (host === THIS_MACHINE) {
+        requireRoot();
+    }
 
     if (verb === "list") {
         await listSources(host);
         return;
     }
     if (verb === "update") {
-        if (rest.length) {
-            throw new Error(`Expected nothing after update, was ${rest.length} argument(s)\n${USAGE}`);
-        }
         await updateDaemon(host);
         return;
     }
     if (verb === "add") {
-        if (!rest.length || rest.length > 2) {
-            throw new Error(`Expected a private key and optionally a repo url, was ${rest.length} argument(s)\n${USAGE}`);
-        }
         await addSource({ host, keyPath: expandHome(rest[0]), repoURL: await resolveRepoURL(rest[1]) });
         return;
     }
-    if (rest.length > 1) {
-        throw new Error(`Expected at most a repo url to remove, was ${rest.length} argument(s)\n${USAGE}`);
-    }
     await removeSource({ host, repoURL: await resolveRepoURL(rest[0]) });
 }

package/security/authorizedKeys/unrevoke.ts

@@ -2,13 +2,15 @@ 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 { 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 { getMachines, setMachines } from "../machines/machines";
+import { resolveKeysRepo } from "./keysRepo";
 
 const UNREVOKES_DIR = "unrevoked";
 const REVOCATIONS_DIR = "revocations";
@@ -17,21 +19,41 @@ const COMMIT_MESSAGE = "unrevoke keys";
 const USAGE = `Usage: yarn unrevoke [keys-repo] [${GIT_KEYWORD}]
 
 Run this in a keys repo, or name one. It reads that repo's revoke repo and writes one unrevoke file
-naming every revocation in it, so the keys are accepted again once each machine's hour long wait
-passes. It signs the result, and with ${GIT_KEYWORD} it commits and pushes it too.
+naming every revocation in it, so the keys are accepted again as each machine picks it up. It signs
+the result, and with ${GIT_KEYWORD} it commits and pushes it too.
 
 Keys that were revoked should normally be deleted from the repo instead. Unrevoking only matters
 for a key you still want.`;
 
+/** 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 };
 };
 
+/** 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.
@@ -86,6 +108,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);
             }
@@ -93,40 +119,85 @@ 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) || "" }));
 }
 
-/** 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) {
-    let cwd = named && expandHome(named) || undefined;
-    // spawnPromise rather than runPromise, because these two are read for their value. runPromise
-    // returns stdout and stderr joined, so one git warning ends up glued to the front of the path.
-    let topLevel = await spawnPromise({ command: "git", args: ["rev-parse", "--show-toplevel"], cwd });
-    let repoPath = topLevel.stdout.trim();
-    if (topLevel.status !== 0 || !repoPath) {
-        throw new Error(
-            `Expected ${named || "the current directory"} to be inside a git repo, it is not.\n`
-            + `${(topLevel.stdout + topLevel.stderr).trim()}\n${USAGE}`
-        );
-    }
+/** 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 {
-        await readRepoKeys(repoPath);
+        contents = await fs.readFile(filePath, "utf8");
     } catch (e) {
-        throw new Error(`Expected ${repoPath} to be a keys repo, it holds no keys.\n${e}\n${USAGE}`);
+        // 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 getMachines(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]);
     }
-    let origin = await spawnPromise({ command: "git", args: ["remote", "get-url", "origin"], cwd: repoPath });
-    let originURL = origin.stdout.trim();
-    if (origin.status !== 0 || !originURL) {
-        throw new Error(`Expected ${repoPath} to have an origin remote, it has none.\n${USAGE}`);
+    if (added.size) {
+        await setMachines({ repoPath, machines });
     }
-    return { repoPath, originURL };
+    return added;
 }
 
+
 export async function main() {
     let argv = process.argv.slice(2);
     let pushToGit = argv.includes(GIT_KEYWORD);
@@ -134,7 +205,7 @@ export async function main() {
     if (positional.length > 1) {
         throw new Error(`Expected at most a keys repo, was ${positional.length} argument(s)\n${USAGE}`);
     }
-    let { repoPath, originURL } = await resolveKeysRepo(positional[0]);
+    let { repoPath, sourceURL: originURL } = await resolveKeysRepo(positional[0]);
 
     let revocations = await readRemoteRevocations({ sourceURL: originURL });
     if (!revocations.length) {
@@ -149,36 +220,89 @@ 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.
     await signRepo({ repoPath });
 
     if (!pushToGit) {
-        console.log(`\nCommit and push it, and each machine will wait an hour after seeing it before`);
-        console.log(`those keys work again:`);
+        console.log(`\nCommit and push it, and those keys work again as each machine picks it up:`);
         console.log(`\`\`\`\ngit add -A\ngit commit -m "${COMMIT_MESSAGE}"\ngit push\n\`\`\``);
         return;
     }
     await runPromise(`git add -A`, { cwd: repoPath });
     await runPromise(`git commit -m "${COMMIT_MESSAGE}"`, { cwd: repoPath });
     await runPromise(`git push`, { cwd: repoPath });
-    console.log(`\nCommitted and pushed. Each machine waits an hour after seeing it before those`);
-    console.log(`keys work again.`);
+    console.log(`\nCommitted and pushed. Those keys work again as each machine picks it up.`);
 }

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,84 @@
+import os from "os";
+import { getOwnIPs } from "../../misc/ownIPs";
+import { describeHost } from "../helpers/remoteSSH";
+import { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from "./identity";
+import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
+import { getMachines, setMachines } 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 getMachines(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 setMachines({ 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\`\`\``);
+}