sliftutils 1.7.132 → 1.7.133

package/index.d.ts

@@ -77,6 +77,7 @@ declare module "sliftutils/misc/https/certs" {
         certB64: string;
         keyB64: string;
     };
+    export declare function DEV_getIdentityFilePath(domain: string): string;
     export interface X509KeyPair {
         domain: string;
         cert: Buffer;
@@ -105,7 +106,7 @@ declare module "sliftutils/misc/https/certs" {
         publicKey: forge.Ed25519PublicKey;
         privateKey: forge.Ed25519PrivateKey;
     };
-    export declare function generateTestCA(domain: string): X509KeyPair;
+    export declare function generateCA(domain: string): X509KeyPair;
     export declare function createCertFromCA(config: {
         CAKeyPair: X509KeyPair;
     }): X509KeyPair;
@@ -320,6 +321,10 @@ declare module "sliftutils/misc/https/node-forge-ed25519" {
 }
 
 declare module "sliftutils/misc/https/persistentLocalStorage" {
+    export declare function DEV_getKeyStorePath(config: {
+        appName: string;
+        key: string;
+    }): string;
     export declare function getKeyStore<T>(appName: string, key: string): {
         get(): T | undefined;
         set(value: T | null): void;

package/misc/https/certs.d.ts

@@ -10,6 +10,7 @@ export type IdentityStorageType = {
     certB64: string;
     keyB64: string;
 };
+export declare function DEV_getIdentityFilePath(domain: string): string;
 export interface X509KeyPair {
     domain: string;
     cert: Buffer;
@@ -38,7 +39,7 @@ export declare function generateKeyPair(): {
     publicKey: forge.Ed25519PublicKey;
     privateKey: forge.Ed25519PrivateKey;
 };
-export declare function generateTestCA(domain: string): X509KeyPair;
+export declare function generateCA(domain: string): X509KeyPair;
 export declare function createCertFromCA(config: {
     CAKeyPair: X509KeyPair;
 }): X509KeyPair;

package/misc/https/certs.ts

@@ -18,7 +18,7 @@ import { measureBlock, measureFnc, measureWrap } from "socket-function/src/profi
 import { getNodeIdDomain, getNodeIdDomainMaybeUndefined, getNodeIdLocation } from "socket-function/src/nodeCache";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { resetAllNodeCallFactories } from "socket-function/src/nodeCache";
-import { getKeyStore } from "./persistentLocalStorage";
+import { getKeyStore, DEV_getKeyStorePath } from "./persistentLocalStorage";
 import { ellipsize } from "../strings";
 
 setFlag(require, "node-forge", "allowclient", true);
@@ -35,6 +35,12 @@ function getIdentityStore(domain: string) {
     return getKeyStore<IdentityStorageType>(domain, identityStorageKey);
 }
 
+// Just used for machine maintenance (finding a machine's identity file on disk, ex to copy it to
+// another machine over ssh). NEVER access this unless explicitly given permission.
+export function DEV_getIdentityFilePath(domain: string): string {
+    return DEV_getKeyStorePath({ appName: domain, key: identityStorageKey });
+}
+
 export interface X509KeyPair { domain: string; cert: Buffer; key: Buffer; }
 
 export function getCommonName(cert: Buffer | string) {
@@ -331,7 +337,7 @@ export function generateKeyPair() {
     });
 }
 
-export function generateTestCA(domain: string) {
+export function generateCA(domain: string) {
     const keyPair = generateKeyPair();
     let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);
     let fullDomain = `${caPublicKeyPart}.${domain}`;
@@ -343,12 +349,7 @@ let identityCA = cache((domain: string) => lazy((): X509KeyPair => {
     let caCached = identityCACached.get();
     if (!caCached) {
         console.log(`Generating new identity CA`);
-        const keyPair = generateKeyPair();
-        let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);
-        let fullDomain = `${caPublicKeyPart}.${domain}`;
-
-        let value = createX509({ domain: fullDomain, issuer: "self", keyPair, lifeSpan: timeInDay * 365 * 20 });
-
+        let value = generateCA(domain);
         caCached = {
             domain: value.domain,
             certB64: value.cert.toString("base64"),

package/misc/https/persistentLocalStorage.d.ts

@@ -1,3 +1,7 @@
+export declare function DEV_getKeyStorePath(config: {
+    appName: string;
+    key: string;
+}): string;
 export declare function getKeyStore<T>(appName: string, key: string): {
     get(): T | undefined;
     set(value: T | null): void;

package/misc/https/persistentLocalStorage.ts

@@ -3,12 +3,18 @@ import fs from "fs";
 import os from "os";
 import { cache } from "socket-function/src/caching";
 
+// Just used for machine maintenance (finding a key store file on disk, ex to copy it to another
+// machine over ssh). NEVER access this unless explicitly given permission.
+export function DEV_getKeyStorePath(config: { appName: string; key: string }): string {
+    return os.homedir() + `/keystore_${config.appName}_` + config.key + ".json";
+}
+
 export function getKeyStore<T>(appName: string, key: string): {
     get(): T | undefined;
     set(value: T | null): void;
 } {
     if (isNode()) {
-        let path = os.homedir() + `/keystore_${appName}_` + key + ".json";
+        let path = DEV_getKeyStorePath({ appName, key });
         return {
             get() {
                 let contents: string | undefined = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.132",
+    "version": "1.7.133",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -35,9 +35,7 @@
         "derivekey": "node ./bin/derivekey.js",
         "unrevoke": "node ./bin/unrevoke.js",
         "testnotify": "node ./bin/testnotify.js",
-        "addmachine": "node ./bin/addmachine.js",
-        "machineserver": "node ./bin/machineserver.js",
-        "machineclient": "node ./bin/machineclient.js"
+        "addmachine": "node ./bin/addmachine.js"
     },
     "bin": {
         "filehoster": "./bin/filehoster.js",
@@ -62,9 +60,7 @@
         "portsecuredaemon": "./bin/portsecuredaemon.js",
         "unrevoke": "./bin/unrevoke.js",
         "testnotify": "./bin/testnotify.js",
-        "addmachine": "./bin/addmachine.js",
-        "machineserver": "./bin/machineserver.js",
-        "machineclient": "./bin/machineclient.js"
+        "addmachine": "./bin/addmachine.js"
     },
     "dependencies": {
         "@types/chrome": "^0.0.237",

package/security/keys/sshKeyFile.ts

@@ -65,7 +65,9 @@ export function publicKeyFromSeed(seed: Buffer) {
         type: "pkcs8",
     });
     // The spki wrapper is a fixed 12 byte header followed by the raw key.
-    return crypto.createPublicKey(privateKey).export({ format: "der", type: "spki" }).subarray(12);
+    // The cast is because some @types/node versions don't accept a KeyObject here, even though the
+    // runtime always has. Consumers compile us with their own @types/node, so this has to not fail.
+    return crypto.createPublicKey(privateKey as any).export({ format: "der", type: "spki" }).subarray(12);
 }
 
 export function parseOpenSSHPrivateKey(contents: string) {

package/security/machines/addMachine.ts

@@ -1,8 +1,8 @@
-import os from "os";
+import path from "path";
 import { runPromise } from "socket-function/src/runPromise";
+import { DEV_getIdentityFilePath, generateCA, getMachineId, getOwnMachineId, IdentityStorageType, loadIdentityCA } from "../../misc/https/certs";
 import { getOwnIPs } from "../../misc/ownIPs";
-import { describeHost } from "../helpers/remoteSSH";
-import { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from "./identity";
+import { describeHost, runOverSSH, writeRemoteFile } from "../helpers/remoteSSH";
 import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { signRepo } from "../signedFiles/signFiles";
 import { getMachines, setMachines } from "./machines";
@@ -55,46 +55,51 @@ function parseArgs(argv: string[]) {
     return { domain, host: second, machineId: "", addresses: [] as string[], pushToGit };
 }
 
+/** The machine id of a machine reached over ssh, generating and installing an identity for it if
+    it has none under this domain. The private key ends up on that machine and nowhere else. */
+async function getOrCreateRemoteMachineId(host: string, domain: string): Promise<string> {
+    let fileName = path.basename(DEV_getIdentityFilePath(domain));
+    let home = (await runOverSSH({ host, script: `echo $HOME` })).stdout.trim();
+    if (!home) {
+        throw new Error(`Expected ${host} to report a home directory, it reported nothing`);
+    }
+    let contents = await runOverSSH({ host, script: `cat ${home}/${fileName} 2>/dev/null || true` });
+    if (contents.stdout.trim()) {
+        let stored = JSON.parse(contents.stdout) as IdentityStorageType;
+        return getMachineId(stored.domain, domain);
+    }
+    console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);
+    let generated = generateCA(domain);
+    let stored: IdentityStorageType = {
+        domain: generated.domain,
+        certB64: generated.cert.toString("base64"),
+        keyB64: generated.key.toString("base64"),
+    };
+    await writeRemoteFile({
+        host,
+        filePath: `${home}/${fileName}`,
+        contents: JSON.stringify(stored),
+        fileMode: "600",
+        directoryMode: "700",
+    });
+    return getMachineId(generated.domain, domain);
+}
+
 export async function main() {
     let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));
     // 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 describe = machineId;
-    if (machineId) {
-        // Named outright, so there is nothing to ask anyone. The id is the hash of that machine's
-        // public key, so naming it is enough - it still has to prove it holds the key before any
-        // of this means anything.
-        describe = `${machineId} (named)`;
-    } else if (!host) {
-        let identity = await localIdentity(domain);
-        if (!identity) {
-            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.`
-            );
-        }
-        machineId = identity.machineId;
-        describe = identity.fullDomain;
+    if (!machineId && !host) {
+        await loadIdentityCA(domain);
+        machineId = getOwnMachineId(domain);
         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`);
-        }
-        let identity: Identity = found || await createRemoteIdentity({ host, domain });
-        machineId = identity.machineId;
-        describe = identity.fullDomain;
-        // The address it was named by is the address it talks to us from, which is the one thing
-        // it cannot lie about.
+    } else if (host) {
+        machineId = await getOrCreateRemoteMachineId(host, domain);
         addresses = [host];
     }
 
@@ -118,7 +123,6 @@ export async function main() {
     } else {
         console.log(`  already allowed from ${addresses.join(", ")}`);
     }
-    console.log(`  identity ${describe}`);
     console.log(`  in ${repoPath}`);
 
     if (!pushToGit) {

package/security/machines/identity2.ts

@@ -0,0 +1,39 @@
+import { getCommonName, getIdentityCA, getMachineId, getThreadKeyCert, sign, validateCertificate, verify } from "../../misc/https/certs";
+
+const MAX_SIGNED_AGE = 5 * 60 * 1000;
+
+export type SignedPayload<T> = {
+    signature: string;
+    payload: {
+        time: number;
+        cert: string;
+        certIssuer: string;
+        data: T;
+    };
+};
+
+export function signAsMachine<T>(domain: string, data: T): SignedPayload<T> {
+    let threadKeyCert = getThreadKeyCert(domain);
+    let issuer = getIdentityCA(domain);
+    let payload = {
+        time: Date.now(),
+        cert: threadKeyCert.cert.toString(),
+        certIssuer: issuer.cert.toString(),
+        data,
+    };
+    return { signature: sign(threadKeyCert, payload), payload };
+}
+
+/** Returns the machineId that signed, and the data. Throws if the signature, certificate chain,
+    or time do not check out. */
+export function verifyMachineSigned<T>(domain: string, signed: SignedPayload<T>): { machineId: string; data: T } {
+    let { signature, payload } = signed;
+    let signedThreshold = Date.now() - MAX_SIGNED_AGE;
+    if (payload.time < signedThreshold) {
+        throw new Error(`Signed payload too old, ${payload.time} < ${signedThreshold}`);
+    }
+    verify(payload.cert, signature, payload);
+    validateCertificate(domain, payload.cert, payload.certIssuer);
+    let machineId = getMachineId(getCommonName(payload.certIssuer), domain);
+    return { machineId, data: payload.data };
+}

package/security/machines/machines.ts

@@ -11,6 +11,7 @@ import { verifyCheckout } 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";
+import { getOwnMachineId } from "../../misc/https/certs";
 import { lazy } from "socket-function/src/caching";
 import { runInfinitePoll } from "socket-function/src/batching";
 import { spawnPromise } from "../helpers/spawn";
@@ -32,6 +33,7 @@ const MACHINES_REFRESH_INTERVAL = 60 * 1000;
 // the machine is set up, and should pick it up once it is, without being restarted - but it must
 // not pay for resolving the repo on every request either.
 const REPO_RETRY_DELAY = 15 * 1000;
+const LOOPBACK = ["127.0.0.1", "::1", "::ffff:127.0.0.1"];
 
 /** One machine we are willing to talk to, and the addresses it may talk to us from. */
 export type MachineState = {
@@ -322,14 +324,16 @@ export type MachineVerdict = { accepted: boolean; reason: string };
 export async function isMachineAccepted(config: {
     machineId: string;
     ip: string;
-    // Only used to write a complete command into the refusal. A caller that knows which domain it
-    // is answering as saves whoever is refused from having to guess it.
+    // Used for local loopback acceptance, and for better error messages.
     domain?: string;
 }): Promise<MachineVerdict> {
     let { machineId, ip, domain } = config;
     if (!machineId || !ip) {
         throw new Error(`Expected a machineId and an ip, was ${JSON.stringify(machineId)} and ${JSON.stringify(ip)}`);
     }
+    if (LOOPBACK.includes(ip) && !!domain && machineId === getOwnMachineId(domain)) {
+        return { accepted: true, reason: "" };
+    }
     let { sourceURL } = await keysRepo();
     // Verified before it is believed, and cached, since this is asked once per request.
     let machine = (await getTrustedMachines()).find(entry => entry.machineId === machineId);

package/storage/backblaze.ts

@@ -562,6 +562,17 @@ export class ArchivesBackblaze implements IArchives {
         } catch (err: any) {
             if (retries <= 0) throw err;
 
+            // A file that does not exist is an answer, not a failure. It is the one error here that
+            // cannot become anything else by asking again, so it is thrown at once instead of being
+            // slept on twice - callers turn it into undefined, which is what they were asking.
+            if (
+                err.stack.includes(`"not_found"`)
+                || err.stack.includes(`file_not_found`)
+                || err.stack.includes(`"status": 404`)
+            ) {
+                throw err;
+            }
+
             // If it's a 503 and it's been a minute since we last reset, then Wait and reset.
             if (
                 (err.stack.includes(`"status": 503`)

package/bin/machineclient.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-// Asks a server whether this machine is trusted.
-require("typenode");
-
-require("../security/machines/trustClient").main().catch(e => {
-    console.error(`${e}`);
-    process.exitCode = 1;
-}).finally(() => process.exit());

package/bin/machineserver.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-// Answers whether the machine asking is trusted, from the address it is asking from.
-require("typenode");
-
-// No exit on success: this one is a server, and returning from main only means it is listening.
-require("../security/machines/trustServer").main().catch(e => {
-    console.error(`${e}`);
-    process.exit(1);
-});

package/security/machines/identity.ts

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

package/security/machines/trustClient.ts

@@ -1,51 +0,0 @@
-import { signTrustPacket } from "./identity";
-
-// The other half of the demonstration: asks a server whether it trusts this machine. The answer
-// depends on the address this machine reaches the server from, which is why the client cannot
-// work it out alone.
-const TRUST_PATH = "/trusted";
-const USAGE = `Usage: yarn machineclient <url> <domain>
-
-Asks that server whether this machine is trusted, proving which machine it is with a signed packet.
-The server decides using the address we reach it from, so the answer is about how we are talking to
-it, not only about who we are.
-
-The domain is required: this machine has a different identity under each one, and the answer is
-about the identity we sign with.`;
-
-export type TrustAnswer = {
-    trusted: boolean;
-    machineId?: string;
-    ip?: string;
-    reason?: string;
-};
-
-/** Asks one server whether it trusts this machine, as it is under this domain. */
-export async function askIfTrusted(config: { baseURL: string; domain: string }): Promise<TrustAnswer> {
-    let { baseURL, domain } = config;
-    let packet = await signTrustPacket(domain);
-    let url = `${baseURL.replace(/\/+$/, "")}${TRUST_PATH}`;
-    let response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(packet),
-    });
-    return await response.json() as TrustAnswer;
-}
-
-export async function main() {
-    let [baseURL, domain] = process.argv.slice(2);
-    if (!baseURL || !domain) {
-        throw new Error(USAGE);
-    }
-    let answer = await askIfTrusted({ baseURL, domain });
-    console.log(`${answer.trusted && "TRUSTED" || "NOT TRUSTED"} by ${baseURL}`);
-    console.log(`  machine ${answer.machineId || "(not established)"}`);
-    console.log(`  seen coming from ${answer.ip || "(unknown)"}`);
-    if (answer.reason) {
-        console.log(`  ${answer.reason}`);
-    }
-    if (!answer.trusted) {
-        process.exitCode = 1;
-    }
-}

package/security/machines/trustServer.ts

@@ -1,87 +0,0 @@
-import http from "http";
-import { verifyTrustPacket } from "./identity";
-import { isMachineAccepted } from "./machines";
-
-// A demonstration of machine trust, and the smallest thing that exercises it end to end: a client
-// proves which machine it is, and this answers whether that machine is trusted from the address it
-// is actually talking from.
-//
-// Plain http on purpose. Nothing here is secret - the packet proves who the client is by signature
-// rather than by the channel, and the answer is a yes or no about a machine the caller already
-// knows the id of.
-const DEFAULT_PORT = 47812;
-const TRUST_PATH = "/trusted";
-const MAX_BODY_LENGTH = 64 * 1024;
-
-/** The address the client is actually talking from. Not read from anything the client sent,
-    because that is the one half of the pair it must not get to choose. */
-function addressOf(request: http.IncomingMessage) {
-    let address = request.socket.remoteAddress || "";
-    // Node reports IPv4 over a dual stack socket this way.
-    return address.replace(/^::ffff:/, "");
-}
-
-async function readBody(request: http.IncomingMessage) {
-    let chunks: Buffer[] = [];
-    let length = 0;
-    for await (let chunk of request) {
-        length += chunk.length;
-        if (length > MAX_BODY_LENGTH) {
-            throw new Error(`Expected at most ${MAX_BODY_LENGTH} bytes, was more`);
-        }
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString("utf8");
-}
-
-export function startTrustServer(config: { port: number }) {
-    let server = http.createServer((request, response) => {
-        let answer = async () => {
-            if (request.url !== TRUST_PATH) {
-                return { status: 404, body: { error: `POST a trust packet to ${TRUST_PATH}` } };
-            }
-            let packet = JSON.parse(await readBody(request));
-            let ip = addressOf(request);
-            let verified = verifyTrustPacket(packet);
-            if (!verified.valid) {
-                // Not a rejection of the machine, a packet that does not prove anything about one.
-                return { status: 400, body: { trusted: false, ip, reason: verified.problem } };
-            }
-            let verdict = await isMachineAccepted({ machineId: packet.machineId, ip });
-            return {
-                status: 200,
-                body: {
-                    trusted: verdict.accepted,
-                    machineId: packet.machineId,
-                    ip,
-                    // Whatever the check itself said. It is the only thing that knows which of the
-                    // ways to be refused this was.
-                    reason: verdict.reason,
-                },
-            };
-        };
-        answer().then(result => {
-            console.log(`${request.method} ${request.url} from ${addressOf(request)}: ${JSON.stringify(result.body)}`);
-            response.writeHead(result.status, { "Content-Type": "application/json" });
-            response.end(JSON.stringify(result.body, undefined, 4));
-        }).catch(e => {
-            console.log(`${request.method} ${request.url} from ${addressOf(request)} failed. ${e}`);
-            response.writeHead(500, { "Content-Type": "application/json" });
-            response.end(JSON.stringify({ trusted: false, error: `${e}` }, undefined, 4));
-        });
-    });
-    server.listen(config.port);
-    return server;
-}
-
-export async function main() {
-    let port = Number(process.argv[2] || DEFAULT_PORT);
-    if (!Number.isFinite(port)) {
-        throw new Error(`Usage: yarn machineserver [port]`);
-    }
-    startTrustServer({ port });
-    console.log(`Answering trust checks on http://0.0.0.0:${port}${TRUST_PATH}`);
-    console.log(`A client asks with: yarn machineclient http://<this machine>:${port}`);
-    // Left running. Nothing else to do here, the server is the program.
-    await new Promise(() => { });
-}