sliftutils 1.7.136 → 1.7.138

package/security/machines/machines.ts

@@ -3,11 +3,10 @@ import os from "os";
 import path from "path";
 import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { revokeRepo, syncRepoFiles } from "../authorizedKeys/daemon/repoFiles";
-import { listRepoDir, readRepoFile } from "../authorizedKeys/daemon/repoFiles";
-import { newRevocationId, pairKey, readRevocationFiles, readUnrevokes } from "../authorizedKeys/daemon/revocation";
+import { newRevocationId } from "../authorizedKeys/daemon/revocation";
 import { runGit, syncRepo } from "../authorizedKeys/daemon/git";
 import { ensureRevokeKey } from "../authorizedKeys/daemon/repoFiles";
-import { readSignedRepo } from "../authorizedKeys/daemon/trust";
+import { isIdentityFrozen, isPairRevoked, isPairUnrevoked, noteRevocation, readSignedRepo } from "../authorizedKeys/daemon/trust";
 import { revokeRepoPath, revokeRepoURL } from "../authorizedKeys/revokeSource";
 import { notify } from "../authorizedKeys/daemon/notify";
 import { areDiscordNotificationsConfigured, configureDiscordNotifications, DEFAULT_WEBHOOK_FILE_PATH } from "../notifications/discord";
@@ -81,8 +80,8 @@ export async function getMachines(repoPath?: string): Promise<MachineState[]> {
     read - an unsigned machines/*.json is not evidence of anything, so readSignedRepo has already
     left it out. */
 async function readTrustedMachines() {
-    let { repoPath } = await keysRepo();
-    let { files } = await readSignedRepo(repoPath);
+    let { repoPath, sourceURL } = await keysRepo();
+    let { files } = await readSignedRepo({ repoPath, sourceURL });
     let machines: MachineState[] = [];
     for (let [filePath, contents] of files) {
         let name = filePath.startsWith(`${MACHINES_DIR}/`) && filePath.slice(MACHINES_DIR.length + 1) || "";
@@ -237,43 +236,17 @@ async function readMachines(repoPath: string) {
 
 let lastRevokeSync = 0;
 
-/** Pulled at most once a REVOKE_SYNC_INTERVAL, because this is asked per request. A sync that
-    fails leaves the checkout we already have, which is the safe direction: revocations we know
-    about stay known. */
+/** Pulls the keys repo and its revoke repo, at most once a REVOKE_SYNC_INTERVAL, because this is
+    asked per request. Both, since either changing changes the answer: the keys repo carries the
+    machines and unrevokes, the revoke repo carries the revocations. A sync that fails leaves the
+    checkouts we already have. */
 async function syncRevocations(sourceURL: string) {
     if (Date.now() - lastRevokeSync < REVOKE_SYNC_INTERVAL) {
         return;
     }
     lastRevokeSync = Date.now();
-    try {
-        await syncRepoFiles(revokeRepo(sourceURL));
-    } catch (e) {
-        console.log(`Could not read ${revokeRepoURL(sourceURL)}, using the revocations already here. ${e}`);
-    }
-}
-
-/** Machine revocations, read out of the revoke repo the same way key revocations are. */
-async function readMachineRevocations(sourceURL: string) {
-    let repo = revokeRepo(sourceURL);
-    let revocations: { revocationId: string; machineId: string; ip: string }[] = [];
-    for (let name of await listRepoDir(repo, REVOCATIONS_DIR)) {
-        if (!name.endsWith(".json")) {
-            continue;
-        }
-        try {
-            let parsed = JSON.parse(await readRepoFile(repo, path.join(REVOCATIONS_DIR, name)) || "");
-            if (parsed.machineId) {
-                revocations.push({
-                    revocationId: parsed.revocationId || name.replace(/\.json$/, ""),
-                    machineId: parsed.machineId,
-                    ip: parsed.ip || "",
-                });
-            }
-        } catch (e) {
-            console.log(`Ignoring unreadable revocation ${name}. ${e}`);
-        }
-    }
-    return revocations;
+    await syncRepo(sourceURL).catch(e => console.log(`Could not sync ${sourceURL}, using the checkout already here. ${e}`));
+    await syncRepoFiles(revokeRepo(sourceURL)).catch(e => console.log(`Could not sync ${revokeRepoURL(sourceURL)}, using the revocations already absorbed. ${e}`));
 }
 
 /** What to run to trust a machine that has just been refused.
@@ -284,7 +257,7 @@ async function readMachineRevocations(sourceURL: string) {
     the machine that owns the repo, so telling them costs nothing. */
 export function addMachineCommand(config: { machineId: string; ip: string; domain?: string }) {
     let { machineId, ip, domain } = config;
-    return `To trust it, run: yarn addmachine ${domain || "<domain>"} ${machineId} ${ip} git`;
+    return `To trust ${machineId}, run: yarn addmachine ${domain || "<domain>"} ${machineId} ${ip} git`;
 }
 
 /** Sends the one notification this file is allowed to send, when it can.
@@ -342,19 +315,20 @@ async function recordMachineRevocation(config: {
         console.log(`Could not push the revocation of ${machineId} from ${ip}. ${(push.stdout + push.stderr).trim()}`);
         return;
     }
+    noteRevocation(revocationId, machineId, ip);
     console.log(`Revoked ${machineId} from ${ip}, ${revocationId}`);
 
     // Said by whoever wrote the revocation, once, the same as for an ssh key. Machines that only
     // read it later say nothing, or one event would be reported by every machine that saw it.
     await notifyBestEffort(
         `SUSPICIOUS IP ${ip} FROZE MACHINE ${machineId}`,
-        `A machine we trust talked to us from ${ip}, which is not an address it is allowed to talk`
-        + ` from. It proved it holds that machine's key, so either someone else has a copy of it,`
-        + ` or that machine's address changed.`
-        + `\n\nIt is frozen everywhere now, and nothing accepts it.`
+        `Trusted machine ${machineId} talked to us from ${ip}, an address ${machineId} is not`
+        + ` allowed from. The caller proved possession of ${machineId}'s key, so either someone`
+        + ` else has a copy of the key, or the machine's address changed.`
+        + `\n\nMachine ${machineId} is frozen everywhere now, and nothing accepts calls from ${machineId}.`
         + `\n\nIf this was an attack, remove \`machines/${machineId}.json\` from \`${sourceURL}\` now.`
-        + `\nIf it was legitimate, run \`yarn unrevoke git\` in that repo. It allows ${ip} for that`
-        + ` machine, and takes effect as each machine picks it up.`
+        + `\nIf the new address is legitimate, run \`yarn unrevoke git\` in \`${sourceURL}\`. The`
+        + ` unrevoke allows ${machineId} from ${ip}, and takes effect as each machine picks it up.`
         + `\n\nmachine: \`${machineId}\``
         + `\nfrozen by: \`${hostLabel}\``
     );
@@ -396,35 +370,15 @@ export async function isMachineAccepted(config: {
             return { verdict: { accepted: true, reason: "" }, froze: false };
         }
         let { sourceURL } = await keysRepo();
-        // Verified before it is believed, and cached, since this is asked once per request.
+        await syncRevocations(sourceURL);
+        // The list has revocations already applied - readSignedRepo drops frozen machines - so a
+        // machine in it is trusted, and a machine missing from it is either unknown or frozen.
         let machine = (await getTrustedMachines()).find(entry => entry.machineId === machineId);
         if (!machine) {
-            return { verdict: { accepted: false, reason: `that machine is not trusted. ${addMachineCommand({ machineId, ip, domain })}` }, froze: false };
-        }
-
-        await syncRevocations(sourceURL);
-        let unrevokes = await readUnrevokes(sourceURL).catch(() => ({ pairs: new Map(), legacyIds: new Map() }));
-        // An unrevoke counts as soon as it is seen. It is signed, so writing one already takes the
-        // hardware key, and anyone holding that can sign anything at all - a wait before honouring it
-        // guards against an attacker who has no need of it.
-        let allowedAgain = (pair: string) => !!unrevokes.pairs.get(pair)?.length;
-        let revocations = await readMachineRevocations(sourceURL);
-        // Any revocation nothing has undone keeps the machine out, from everywhere, the way a revoked
-        // ssh key is out everywhere rather than only from the address it was misused from.
-        let frozenFrom = "";
-        for (let revocation of revocations) {
-            if (revocation.machineId !== machineId) {
-                continue;
+            if (isIdentityFrozen(machineId)) {
+                return { verdict: { accepted: false, reason: `Machine ${machineId} is frozen, having been used from an unapproved address.` }, froze: false };
             }
-            if (!allowedAgain(pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }))) {
-                frozenFrom = revocation.ip;
-            }
-        }
-        if (frozenFrom) {
-            return {
-                verdict: { accepted: false, reason: `that machine is frozen, it was used from ${frozenFrom} which it is not allowed from` },
-                froze: false,
-            };
+            return { verdict: { accepted: false, reason: `Machine ${machineId} is not trusted. ${addMachineCommand({ machineId, ip, domain })}` }, froze: false };
         }
 
         if (machine.ips.includes(ip)) {
@@ -433,14 +387,11 @@ export async function isMachineAccepted(config: {
 
         // Listed, but talking to us from somewhere it should not be. Recorded once for this machine
         // and address, so being talked to repeatedly does not write repeatedly.
-        let pair = pairKey({ fingerprint: machineId, ip });
-        let alreadyRecorded = revocations.some(revocation =>
-            pairKey({ fingerprint: revocation.machineId, ip: revocation.ip }) === pair);
-        if (!alreadyRecorded && !allowedAgain(pair)) {
+        if (!isPairRevoked(machineId, ip) && !isPairUnrevoked(machineId, ip)) {
             await recordMachineRevocation({ sourceURL, machineId, ip, hostLabel: os.hostname() });
-            return { verdict: { accepted: false, reason: `that machine is not allowed from ${ip}, so it is now frozen everywhere` }, froze: true };
+            return { verdict: { accepted: false, reason: `Machine ${machineId} is not allowed from ${ip}, and is now frozen everywhere.` }, froze: true };
         }
-        return { verdict: { accepted: false, reason: `that machine is not allowed from ${ip}` }, froze: false };
+        return { verdict: { accepted: false, reason: `Machine ${machineId} is not allowed from ${ip}.` }, froze: false };
     };
 
     let { verdict, froze } = await evaluate();

package/security/machines/printMachineId.ts

@@ -0,0 +1,19 @@
+import { DEV_listIdentityDomains, getOwnMachineId, loadIdentityCA } from "../../misc/https/certs";
+
+// Prints this machine's id under every domain it has an identity for. A machine has a different
+// identity, and so a different machine id, under every domain it runs under.
+async function main() {
+    let domains = DEV_listIdentityDomains();
+    if (!domains.length) {
+        throw new Error(`This machine has no identities`);
+    }
+    for (let domain of domains) {
+        await loadIdentityCA(domain);
+        console.log(`${domain} ${getOwnMachineId(domain)}`);
+    }
+}
+
+main().catch(e => {
+    console.error(`${e}`);
+    process.exitCode = 1;
+}).finally(() => process.exit());

package/security/signedFiles/dist/signFiles.ts.cache

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.main = exports.signRepo = void 0;
+//exports.signRepo = exports.DEFAULT_KEY_PATH = exports.DEFAULT_KEY_TYPE = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -11,21 +11,14 @@ const runPromise_1 = require("socket-function/src/runPromise");
 const paths_1 = require("../helpers/paths");
 const spawn_1 = require("../helpers/spawn");
 const manifest_1 = require("./manifest");
+const sshsig_1 = require("./sshsig");
 const unrevoke_1 = require("../authorizedKeys/unrevoke");
-const keysRepo_1 = require("../authorizedKeys/keysRepo");
 const authorizedKeys_1 = require("../authorizedKeys/authorizedKeys");
 // A hardware backed key is the entire point. A key sitting on disk is compromised the moment the
 // machine is, and then the signature proves nothing, so this is what we make when asked to make one.
-const DEFAULT_KEY_TYPE = "ed25519-sk";
-const DEFAULT_KEY_PATH = "~/.ssh/signfiles_ed25519_sk";
-const GIT_KEYWORD = "git";
-const COMMIT_MESSAGE = "deploying signed files";
+exports.DEFAULT_KEY_TYPE = "ed25519-sk";
+exports.DEFAULT_KEY_PATH = "~/.ssh/signfiles_ed25519_sk";
 const MAX_ERROR_BODY_LENGTH = 500;
-const USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]
-
-Signs the files of the repo in the current directory. With no key, a hardware backed
-${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.
-Pass ${GIT_KEYWORD} to also commit and push the result.`;
 /** runPromise takes a command line rather than an argument list, so anything holding a path has to
     survive the shell. Double quotes work on both cmd and posix shells. */
 function quote(value) {
@@ -42,14 +35,14 @@ async function pathExists(filePath) {
 }
 /** Creating this needs the security key plugged in, and a touch. */
 async function ensureDefaultKey() {
-    let keyPath = (0, paths_1.expandHome)(DEFAULT_KEY_PATH);
+    let keyPath = (0, paths_1.expandHome)(exports.DEFAULT_KEY_PATH);
     if (await pathExists(keyPath)) {
         return keyPath;
     }
-    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);
+    console.log(`No signing key at ${keyPath}, creating an ${exports.DEFAULT_KEY_TYPE} one.`);
     console.log(`Plug your security key in - you will be asked to touch it.`);
     await promises_1.default.mkdir(path_1.default.dirname(keyPath), { recursive: true, mode: 0o700 });
-    await (0, runPromise_1.runPromise)(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N "" -C signfiles`);
+    await (0, runPromise_1.runPromise)(`ssh-keygen -t ${exports.DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N "" -C signfiles`);
     return keyPath;
 }
 /** The public key in the form the daemon reports it, so what is printed here can be compared
@@ -112,14 +105,6 @@ async function refuseRevokedKeys(repoPath) {
         }).join("\n")
         + `\nDelete them from authorized_keys, or run "yarn unrevoke" here to allow them again.`);
 }
-function parseArgs(argv) {
-    let pushToGit = argv.includes(GIT_KEYWORD);
-    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
-    if (positional.length > 1) {
-        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(" ")}\n${USAGE}`);
-    }
-    return { keyPath: positional[0], pushToGit };
-}
 /** Writes the manifest and its signature into a repo. Separate from the command so anything that
     changes a keys repo can leave it signed, rather than telling someone to go and do it. */
 async function signRepo(config) {
@@ -141,39 +126,18 @@ async function signRepo(config) {
     await promises_1.default.writeFile(stagedManifest, (0, manifest_1.formatManifest)(manifest));
     // Signing happens before any git work, so a failed push never costs a second touch of the key.
     await (0, runPromise_1.runPromise)(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${manifest_1.SIGN_NAMESPACE} ${quote(stagedManifest)}`);
-    // Checked here rather than left for a machine that has already pulled it to discover.
-    await (0, runPromise_1.runPromise)(`ssh-keygen -Y check-novalidate -n ${manifest_1.SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`);
+    // Checked with the same code the daemon verifies with, over the same normalised bytes, so what
+    // is about to be committed is proven to pass the check every other machine will run on it.
+    (0, sshsig_1.verifySSHSIG)({
+        signature: await promises_1.default.readFile(stagedSignature, "utf8"),
+        message: (0, manifest_1.normalizeContent)(await promises_1.default.readFile(stagedManifest)),
+        namespace: manifest_1.SIGN_NAMESPACE,
+    });
     await promises_1.default.copyFile(stagedManifest, path_1.default.join(repoPath, manifest_1.MANIFEST_NAME));
     await promises_1.default.copyFile(stagedSignature, path_1.default.join(repoPath, manifest_1.SIGNATURE_NAME));
     await promises_1.default.rm(stagingDirectory, { recursive: true, force: true });
     console.log(`Signed with ${await publicKeyOf(signingKey)}`);
 }
 exports.signRepo = signRepo;
-async function main() {
-    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));
-    // The keys repo, which is this one when it holds keys and this machine's otherwise. Signing
-    // whatever repo the terminal happened to be in is how you end up signing something that is not
-    // a keys repo at all.
-    let { repoPath } = await (0, keysRepo_1.resolveKeysRepo)();
-    console.log(`Signing ${repoPath}`);
-    await signRepo({ repoPath, keyPath });
-    if (!pushToGit) {
-        console.log(`Commit and push ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} for anything to see them.`);
-        return;
-    }
-    await (0, runPromise_1.runPromise)(`git add -A`, { cwd: repoPath });
-    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means
-    // the signature matches the one already committed, so there is nothing to deploy.
-    let status = await (0, spawn_1.spawnPromise)({ command: "git", args: ["status", "--porcelain"], cwd: repoPath });
-    let staged = status.stdout;
-    if (!staged.trim()) {
-        console.log(`Nothing changed, ${manifest_1.MANIFEST_NAME} and ${manifest_1.SIGNATURE_NAME} are already committed.`);
-        return;
-    }
-    await (0, runPromise_1.runPromise)(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });
-    await (0, runPromise_1.runPromise)(`git push`, { cwd: repoPath });
-    console.log(`Committed and pushed.`);
-}
-exports.main = main;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { runPromise } from \"socket-function/src/runPromise\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { buildManifest, formatManifest, MANIFEST_NAME, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { findKeyProblems, normalizeKeys } from \"../authorizedKeys/authorizedKeys\";\n\n// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the\n// machine is, and then the signature proves nothing, so this is what we make when asked to make one.\nconst DEFAULT_KEY_TYPE = \"ed25519-sk\";\nconst DEFAULT_KEY_PATH = \"~/.ssh/signfiles_ed25519_sk\";\nconst GIT_KEYWORD = \"git\";\nconst COMMIT_MESSAGE = \"deploying signed files\";\nconst MAX_ERROR_BODY_LENGTH = 500;\nconst USAGE = `Usage: yarn signfiles [signing-key] [${GIT_KEYWORD}]\n\nSigns the files of the repo in the current directory. With no key, a hardware backed\n${DEFAULT_KEY_TYPE} key at ${DEFAULT_KEY_PATH} is used, and created if it does not exist.\nPass ${GIT_KEYWORD} to also commit and push the result.`;\n\n/** runPromise takes a command line rather than an argument list, so anything holding a path has to\n    survive the shell. Double quotes work on both cmd and posix shells. */\nfunction quote(value: string) {\n    return `\"${value}\"`;\n}\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/** Creating this needs the security key plugged in, and a touch. */\nasync function ensureDefaultKey() {\n    let keyPath = expandHome(DEFAULT_KEY_PATH);\n    if (await pathExists(keyPath)) {\n        return keyPath;\n    }\n    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);\n    console.log(`Plug your security key in - you will be asked to touch it.`);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N \"\" -C signfiles`);\n    return keyPath;\n}\n\n/** The public key in the form the daemon reports it, so what is printed here can be compared\n    against what arrives on Discord. */\nasync function publicKeyOf(keyPath: string) {\n    let contents = await fs.readFile(`${keyPath}.pub`, \"utf8\");\n    let [keyType, keyBody] = contents.trim().split(/\\s+/);\n    if (!keyType || !keyBody) {\n        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return `${keyType} ${keyBody}`;\n}\n\n/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it\n    is signed. Signing anything that is not a keys repo is none of this function's business. */\nasync function refuseUnusableKeys(repoPath: string) {\n    let authorizedPath = path.join(repoPath, \"authorized_keys\");\n    if (!await pathExists(authorizedPath)) {\n        return;\n    }\n    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, \"utf8\")));\n    if (!problems.length) {\n        return;\n    }\n    throw new Error(\n        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`\n        + ` found ${problems.length} problem(s):\\n`\n        + problems.map(problem => `  - ${problem}`).join(\"\\n\")\n        + `\\n\\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`\n        + `\\nname the same ones. Revoking a key that shares its addresses with another leaves that`\n        + `\\nother key working, which defeats the point of revoking it.`\n    );\n}\n\n/** Signing a keys repo that still holds a revoked key would publish it back to every machine that\n    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing\n    anything else is none of this function's business. */\nasync function refuseRevokedKeys(repoPath: string) {\n    if (!await pathExists(path.join(repoPath, \"authorized_keys\"))) {\n        return;\n    }\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let originURL = origin.stdout.trim();\n    if (origin.status !== 0 || !originURL) {\n        return;\n    }\n    let revoked;\n    try {\n        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });\n    } catch (e) {\n        // No revoke repo, or no access to it. Nothing has been revoked that we can see.\n        return;\n    }\n    if (!revoked.length) {\n        return;\n    }\n    throw new Error(\n        `Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\\n`\n        + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || \"?\"}`\n            + ` after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n        + `\\nDelete them from authorized_keys, or run \"yarn unrevoke\" here to allow them again.`\n    );\n}\n\nfunction parseArgs(argv: string[]) {\n    let pushToGit = argv.includes(GIT_KEYWORD);\n    let positional = argv.filter(arg => arg !== GIT_KEYWORD);\n    if (positional.length > 1) {\n        throw new Error(`Expected at most a signing key, was ${positional.length} argument(s): ${positional.join(\" \")}\\n${USAGE}`);\n    }\n    return { keyPath: positional[0], pushToGit };\n}\n\n/** Writes the manifest and its signature into a repo. Separate from the command so anything that\n    changes a keys repo can leave it signed, rather than telling someone to go and do it. */\nexport async function signRepo(config: { repoPath: string; keyPath?: string }) {\n    let { repoPath } = config;\n    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();\n    if (!await pathExists(signingKey)) {\n        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);\n    }\n\n    await refuseUnusableKeys(repoPath);\n    await refuseRevokedKeys(repoPath);\n\n    let manifest = await buildManifest(repoPath);\n    console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);\n\n    // The manifest is built and signed away from the repo, and only moved in once both exist.\n    // Landing a new manifest next to an old signature produces a pair that can never verify, and\n    // the daemon reading it can only treat that as tampering.\n    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"signfiles-\"));\n    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);\n    let stagedSignature = `${stagedManifest}.sig`;\n    await fs.writeFile(stagedManifest, formatManifest(manifest));\n\n    // Signing happens before any git work, so a failed push never costs a second touch of the key.\n    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);\n    // Checked here rather than left for a machine that has already pulled it to discover.\n    await runPromise(\n        `ssh-keygen -Y check-novalidate -n ${SIGN_NAMESPACE} -s ${quote(stagedSignature)} < ${quote(stagedManifest)}`\n    );\n    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));\n    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));\n    await fs.rm(stagingDirectory, { recursive: true, force: true });\n    console.log(`Signed with ${await publicKeyOf(signingKey)}`);\n}\n\nexport async function main() {\n    let { keyPath, pushToGit } = parseArgs(process.argv.slice(2));\n\n    // The keys repo, which is this one when it holds keys and this machine's otherwise. Signing\n    // whatever repo the terminal happened to be in is how you end up signing something that is not\n    // a keys repo at all.\n    let { repoPath } = await resolveKeysRepo();\n    console.log(`Signing ${repoPath}`);\n    await signRepo({ repoPath, keyPath });\n\n    if (!pushToGit) {\n        console.log(`Commit and push ${MANIFEST_NAME} and ${SIGNATURE_NAME} for anything to see them.`);\n        return;\n    }\n    await runPromise(`git add -A`, { cwd: repoPath });\n    // Nothing staged is not worth stopping on. git commit calls that a failure, but it only means\n    // the signature matches the one already committed, so there is nothing to deploy.\n    let status = await spawnPromise({ command: \"git\", args: [\"status\", \"--porcelain\"], cwd: repoPath });\n    let staged = status.stdout;\n    if (!staged.trim()) {\n        console.log(`Nothing changed, ${MANIFEST_NAME} and ${SIGNATURE_NAME} are already committed.`);\n        return;\n    }\n    await runPromise(`git commit -m ${quote(COMMIT_MESSAGE)}`, { cwd: repoPath });\n    await runPromise(`git push`, { cwd: repoPath });\n    console.log(`Committed and pushed.`);\n}\n"]}
- /* _JS_SOURCE_HASH = "e62739f311ed1c2d2b818032186647cfb19cc96beec3178194cb15bda564b243"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signFiles.js","sourceRoot":"","sources":["signFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs/promises\";\nimport os from \"os\";\nimport path from \"path\";\nimport { runPromise } from \"socket-function/src/runPromise\";\nimport { expandHome } from \"../helpers/paths\";\nimport { spawnPromise } from \"../helpers/spawn\";\nimport { buildManifest, formatManifest, MANIFEST_NAME, normalizeContent, SIGNATURE_NAME, SIGN_NAMESPACE } from \"./manifest\";\nimport { verifySSHSIG } from \"./sshsig\";\nimport { revokedKeysInRepo } from \"../authorizedKeys/unrevoke\";\nimport { findKeyProblems, normalizeKeys } from \"../authorizedKeys/authorizedKeys\";\n\n// A hardware backed key is the entire point. A key sitting on disk is compromised the moment the\n// machine is, and then the signature proves nothing, so this is what we make when asked to make one.\nexport const DEFAULT_KEY_TYPE = \"ed25519-sk\";\nexport const DEFAULT_KEY_PATH = \"~/.ssh/signfiles_ed25519_sk\";\nconst MAX_ERROR_BODY_LENGTH = 500;\n\n/** runPromise takes a command line rather than an argument list, so anything holding a path has to\n    survive the shell. Double quotes work on both cmd and posix shells. */\nfunction quote(value: string) {\n    return `\"${value}\"`;\n}\n\nasync function pathExists(filePath: string) {\n    try {\n        await fs.access(filePath);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/** Creating this needs the security key plugged in, and a touch. */\nasync function ensureDefaultKey() {\n    let keyPath = expandHome(DEFAULT_KEY_PATH);\n    if (await pathExists(keyPath)) {\n        return keyPath;\n    }\n    console.log(`No signing key at ${keyPath}, creating an ${DEFAULT_KEY_TYPE} one.`);\n    console.log(`Plug your security key in - you will be asked to touch it.`);\n    await fs.mkdir(path.dirname(keyPath), { recursive: true, mode: 0o700 });\n    await runPromise(`ssh-keygen -t ${DEFAULT_KEY_TYPE} -f ${quote(keyPath)} -N \"\" -C signfiles`);\n    return keyPath;\n}\n\n/** The public key in the form the daemon reports it, so what is printed here can be compared\n    against what arrives on Discord. */\nasync function publicKeyOf(keyPath: string) {\n    let contents = await fs.readFile(`${keyPath}.pub`, \"utf8\");\n    let [keyType, keyBody] = contents.trim().split(/\\s+/);\n    if (!keyType || !keyBody) {\n        throw new Error(`Expected a public key in ${keyPath}.pub, was ${contents.slice(0, MAX_ERROR_BODY_LENGTH)}`);\n    }\n    return `${keyType} ${keyBody}`;\n}\n\n/** A keys repo has rules the rest of this cannot enforce afterwards, so they are enforced before it\n    is signed. Signing anything that is not a keys repo is none of this function's business. */\nasync function refuseUnusableKeys(repoPath: string) {\n    let authorizedPath = path.join(repoPath, \"authorized_keys\");\n    if (!await pathExists(authorizedPath)) {\n        return;\n    }\n    let problems = findKeyProblems(normalizeKeys(await fs.readFile(authorizedPath, \"utf8\")));\n    if (!problems.length) {\n        return;\n    }\n    throw new Error(\n        `Expected every key in ${authorizedPath} to be restricted and to belong to one person,`\n        + ` found ${problems.length} problem(s):\\n`\n        + problems.map(problem => `  - ${problem}`).join(\"\\n\")\n        + `\\n\\nEvery key needs a from= naming the addresses it may be used from, and no two keys may`\n        + `\\nname the same ones. Revoking a key that shares its addresses with another leaves that`\n        + `\\nother key working, which defeats the point of revoking it.`\n    );\n}\n\n/** Signing a keys repo that still holds a revoked key would publish it back to every machine that\n    took it out. Only applies to a repo that holds keys and has a revoke repo to check - signing\n    anything else is none of this function's business. */\nasync function refuseRevokedKeys(repoPath: string) {\n    if (!await pathExists(path.join(repoPath, \"authorized_keys\"))) {\n        return;\n    }\n    // Read for its value, so stdout has to be on its own. runPromise joins it with stderr.\n    let origin = await spawnPromise({ command: \"git\", args: [\"remote\", \"get-url\", \"origin\"], cwd: repoPath });\n    let originURL = origin.stdout.trim();\n    if (origin.status !== 0 || !originURL) {\n        return;\n    }\n    let revoked;\n    try {\n        revoked = await revokedKeysInRepo({ repoPath, sourceURL: originURL });\n    } catch (e) {\n        // No revoke repo, or no access to it. Nothing has been revoked that we can see.\n        return;\n    }\n    if (!revoked.length) {\n        return;\n    }\n    throw new Error(\n        `Expected ${repoPath} to hold no revoked keys, it holds ${revoked.length}:\\n`\n        + revoked.map(entry => `  ${entry.revocation.fingerprint} revoked by ${entry.revocation.revokedBy || \"?\"}`\n            + ` after use from ${entry.revocation.attempt?.ip || \"?\"}`).join(\"\\n\")\n        + `\\nDelete them from authorized_keys, or run \"yarn unrevoke\" here to allow them again.`\n    );\n}\n\n/** Writes the manifest and its signature into a repo. Separate from the command so anything that\n    changes a keys repo can leave it signed, rather than telling someone to go and do it. */\nexport async function signRepo(config: { repoPath: string; keyPath?: string }) {\n    let { repoPath } = config;\n    let signingKey = config.keyPath && expandHome(config.keyPath) || await ensureDefaultKey();\n    if (!await pathExists(signingKey)) {\n        throw new Error(`Expected a signing key at ${signingKey}, no such file exists`);\n    }\n\n    await refuseUnusableKeys(repoPath);\n    await refuseRevokedKeys(repoPath);\n\n    let manifest = await buildManifest(repoPath);\n    console.log(`${MANIFEST_NAME} covers ${manifest.files.length} file(s) in ${repoPath}`);\n\n    // The manifest is built and signed away from the repo, and only moved in once both exist.\n    // Landing a new manifest next to an old signature produces a pair that can never verify, and\n    // the daemon reading it can only treat that as tampering.\n    let stagingDirectory = await fs.mkdtemp(path.join(os.tmpdir(), \"signfiles-\"));\n    let stagedManifest = path.join(stagingDirectory, MANIFEST_NAME);\n    let stagedSignature = `${stagedManifest}.sig`;\n    await fs.writeFile(stagedManifest, formatManifest(manifest));\n\n    // Signing happens before any git work, so a failed push never costs a second touch of the key.\n    await runPromise(`ssh-keygen -Y sign -f ${quote(signingKey)} -n ${SIGN_NAMESPACE} ${quote(stagedManifest)}`);\n    // Checked with the same code the daemon verifies with, over the same normalised bytes, so what\n    // is about to be committed is proven to pass the check every other machine will run on it.\n    verifySSHSIG({\n        signature: await fs.readFile(stagedSignature, \"utf8\"),\n        message: normalizeContent(await fs.readFile(stagedManifest)),\n        namespace: SIGN_NAMESPACE,\n    });\n    await fs.copyFile(stagedManifest, path.join(repoPath, MANIFEST_NAME));\n    await fs.copyFile(stagedSignature, path.join(repoPath, SIGNATURE_NAME));\n    await fs.rm(stagingDirectory, { recursive: true, force: true });\n    console.log(`Signed with ${await publicKeyOf(signingKey)}`);\n}\n"]}
+ /* _JS_SOURCE_HASH = "4a0362e3ebb2c3e38ab98fe24ab7f151737c241a4186d0e880713fb9d14fa48f"; */

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -36,9 +36,9 @@ export declare class ArchivesRemote implements IArchives {
     private authenticate;
     private callAuthed;
     waitingForAccess(): Promise<{
-        link: string;
         machineId: string;
         ip: string;
+        reason: string;
     } | undefined>;
     hasWriteAccess(): Promise<boolean>;
     private registerAccessRequest;

package/storage/remoteStorage/ArchivesRemote.ts

@@ -1,7 +1,7 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { timeInMinute } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
-import { getIdentityCA, loadIdentityCA, sign } from "../../misc/https/certs";
+import { getIdentityCA, getThreadKeyCert, loadIdentityCA, sign } from "../../misc/https/certs";
 import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, MoveFileConfig, SourceConfig, SetConfig, SetLargeFileConfig, LARGE_SET_THRESHOLD, bufferChunkStream } from "../IArchives";
 import { parseHostedUrl, getBucketBaseUrl, buildFileUrl } from "./remoteConfig";
 import {
@@ -41,14 +41,20 @@ export async function authenticateStorage(config: { address: string; port: numbe
     SocketFunction.ENABLE_CLIENT_MODE = true;
     let rootDomain = config.address.split(".").slice(-2).join(".");
     await loadIdentityCA(rootDomain);
-    let ca = getIdentityCA(rootDomain);
+    let threadKeyCert = getThreadKeyCert(rootDomain);
+    let issuer = getIdentityCA(rootDomain);
     let data = {
         purpose: STORAGE_AUTH_PURPOSE,
         time: Date.now(),
         server: `${config.address}:${config.port}`,
     };
-    let signature = sign({ key: ca.key }, data);
-    return await RemoteStorageController.nodes[config.nodeId].authenticate({ certPem: ca.cert.toString(), signature, data });
+    let signature = sign(threadKeyCert, data);
+    return await RemoteStorageController.nodes[config.nodeId].authenticate({
+        certPem: threadKeyCert.cert.toString(),
+        issuerPem: issuer.cert.toString(),
+        signature,
+        data,
+    });
 }
 
 export class ArchivesRemote implements IArchives {
@@ -99,14 +105,14 @@ export class ArchivesRemote implements IArchives {
         }
     }
 
-    // Returns undefined if this machine has access to the account. Otherwise returns our machineId + ip as the server sees them, and the link to the access page - which shows the single command that grants access.
-    public async waitingForAccess(): Promise<{ link: string; machineId: string; ip: string } | undefined> {
+    // Returns undefined if this machine has access to the account. Otherwise returns our machineId + ip as the server sees them, why we were refused, and the exact command that grants access.
+    public async waitingForAccess(): Promise<{ machineId: string; ip: string; reason: string } | undefined> {
         let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));
         if (state.hasAccess) return undefined;
         return {
-            link: `https://${this.parsed.address}:${this.parsed.port}/${this.account}`,
             machineId: state.machineId,
             ip: state.ip,
+            reason: state.reason || "",
         };
     }
 
@@ -120,7 +126,7 @@ export class ArchivesRemote implements IArchives {
         if (Date.now() - this.lastDeniedLog < timeInMinute) return;
         let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));
         this.lastDeniedLog = Date.now();
-        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${state.machineId}, ip ${state.ip}). ${state.reason || ""} Grant it with: ${state.addMachineCommand || ""}`);
+        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port}. ${state.reason || ""}`);
     }
 
     // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account access as needed. With waitForAccess false, denied calls throw immediately instead - but the access request is still registered (in the background), so the denial is grantable.

package/storage/remoteStorage/accessPage.tsx

@@ -1,131 +1,12 @@
 process.env.NODE_ENV = "production";
 
 import preact from "preact";
-import { observable } from "mobx";
-import { observer } from "../../render-utils/observer";
 import { isNode } from "socket-function/src/misc";
 import { css } from "typesafecss";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { RemoteStorageController, AccessState } from "./storageController";
-import { authenticateStorage } from "./ArchivesRemote";
 
-// The storage server's access page. Visit https://<storageDomain>:<port>/<accountName> to see whether this browser's machine identity has access, and if not, the one command that grants it. Nothing is requested or approved here: trust lives in the signed authorized_keys repo, so access is granted by someone running addmachine there with the hardware key, and this page only reports what that repo says.
-
-const REFRESH_INTERVAL = 1000 * 15;
-const COPIED_RESET_DELAY = 2000;
-
-@observer
-class CopyableCommand extends preact.Component<{ command: string }> {
-    synced = observable({
-        copied: false,
-    });
-
-    render() {
-        let command = this.props.command;
-        return <div className={css.hbox(8).alignItems("flex-start")}>
-            <button onClick={async () => {
-                await navigator.clipboard.writeText(command);
-                this.synced.copied = true;
-                setTimeout(() => { this.synced.copied = false; }, COPIED_RESET_DELAY);
-            }}>
-                {this.synced.copied && "Copied!" || "Copy"}
-            </button>
-            <code className={css.fontFamily("monospace").whiteSpace("pre-wrap")
-                .hsl(0, 0, 92).pad2(8, 4).borderRadius(4)
-            }>
-                {command}
-            </code>
-        </div>;
-    }
-}
-
-@observer
-class AccessPage extends preact.Component {
-    synced = observable({
-        account: "",
-        state: undefined as AccessState | undefined,
-        error: "",
-    });
-
-    componentDidMount() {
-        let account = decodeURIComponent(location.pathname.split("/")[1] || "");
-        this.synced.account = account;
-        if (!account) return;
-        void (async () => {
-            while (true) {
-                try {
-                    await this.refresh(account);
-                } catch (e) {
-                    this.synced.error = String(e);
-                }
-                if (this.synced.state?.hasAccess) break;
-                await new Promise(resolve => setTimeout(resolve, REFRESH_INTERVAL));
-            }
-        })();
-    }
-
-    private authenticated = false;
-    private async controller() {
-        let address = location.hostname;
-        let port = +location.port || 443;
-        let nodeId = SocketFunction.connect({ address, port });
-        if (!this.authenticated) {
-            await authenticateStorage({ address, port, nodeId });
-            this.authenticated = true;
-        }
-        return RemoteStorageController.nodes[nodeId];
-    }
-    private async refresh(account: string) {
-        let controller = await this.controller();
-        this.synced.state = await controller.getAccessState({ account });
-        this.synced.error = "";
-    }
-
-    render() {
-        let synced = this.synced;
-        let { account, state, error } = synced;
-        if (!account) {
-            return <div className={css.vbox(8).pad2(16)}>
-                <div>Remote storage server.</div>
-                <div>Visit /(account name) to see whether this browser's machine has access to an account.</div>
-            </div>;
-        }
-        return <div className={css.vbox(12).pad2(16)}>
-            <div>Storage account: {account}</div>
-            {error && <div>Error: {error}</div>}
-            {!state && !error && <div>Checking access...</div>}
-            {state && !state.hasAccess && <div className={css.vbox(8)}>
-                <div>This machine ({state.machineId}, ip {state.ip}) does NOT have access.</div>
-                {state.reason && <div>{state.reason}</div>}
-                <div>Run this in the authorized_keys repo, on a machine with the signing key:</div>
-                {state.addMachineCommand && <CopyableCommand command={state.addMachineCommand} />}
-                <div>This page rechecks every {REFRESH_INTERVAL / 1000} seconds.</div>
-            </div>}
-            {state && state.hasAccess && <div className={css.vbox(16)}>
-                <div>This machine ({state.machineId}, ip {state.ip}) has access.</div>
-                <div className={css.vbox(6)}>
-                    <div>Trusted machines:</div>
-                    <table>
-                        <thead>
-                            <tr>
-                                <th className={css.pad2(8, 2).textAlign("left")}>Machine</th>
-                                <th className={css.pad2(8, 2).textAlign("left")}>Allowed from</th>
-                                <th className={css.pad2(8, 2).textAlign("left")}>Added</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {(state.trustedMachines || []).map(m => <tr key={m.machineId}>
-                                <td className={css.pad2(8, 2)}>{m.machineId}</td>
-                                <td className={css.pad2(8, 2)}>{m.ips.join(", ")}</td>
-                                <td className={css.pad2(8, 2)}>{m.addedAt}</td>
-                            </tr>)}
-                        </tbody>
-                    </table>
-                </div>
-            </div>}
-        </div>;
-    }
-}
+// The storage server's fallback page. There is no access-granting page any more: access errors in
+// the console say exactly why a machine was refused and the addmachine command that fixes it. This
+// only remains for the cert-trust flow (?trustCert=1, see certTrustModal.tsx).
 
 // Reached via the cert-trust flow (showCertTrustModal links here as ?trustCert=1). The browser only loads this page if it has ACCEPTED the certificate - so the mere fact that it rendered is the confirmation. Once accepted, the app's background connection to this same server works, so the user just returns.
 function CertTrustedPage() {
@@ -141,7 +22,10 @@ async function main() {
         preact.render(<CertTrustedPage />, document.body);
         return;
     }
-    preact.render(<AccessPage />, document.body);
+    preact.render(<div className={css.vbox(8).pad2(16)}>
+        <div>Remote storage server.</div>
+        <div>Access is granted by adding a machine to the authorized_keys repo (yarn addmachine). Denied requests print the exact command in their error.</div>
+    </div>, document.body);
 }
 
 main().catch(console.error);

package/storage/remoteStorage/createArchives.d.ts

@@ -23,9 +23,9 @@ export declare class ArchivesChain implements IArchives {
     private prepareWrongTargetRetry;
     private request;
     waitingForAccess(): Promise<{
-        link: string;
         machineId: string;
         ip: string;
+        reason: string;
     } | undefined>;
     /** The sources that can serve a file right now, in dispatch order - the first is the write node, the one a plain read asks first. Each entry's url is what GetConfig.sourceUrl / GetInfoConfig.sourceUrl accept, so listing these and then reading with sourceUrl compares the copies the sources actually hold. */
     getFileSources(fileName: string): Promise<SourceConfig[]>;

package/storage/remoteStorage/createArchives.ts

@@ -319,7 +319,7 @@ export class ArchivesChain implements IArchives {
         return await this.run(state, config, run);
     }
 
-    public async waitingForAccess(): Promise<{ link: string; machineId: string; ip: string } | undefined> {
+    public async waitingForAccess(): Promise<{ machineId: string; ip: string; reason: string } | undefined> {
         let state = await this.state.getState();
         for (let source of state.sources) {
             // A source whose window has passed is never read or written again, so its access state is irrelevant - and asking a dead intermediate would just hang or throw. Future windows DO matter: access should be granted before their window starts.