anyos-client 0.2.0

package/secrets.js

@@ -0,0 +1,203 @@
+/**
+ * Secrets: the token a kernel asks for, kept apart from the machine list.
+ *
+ * machines.json is a plain document — a name and an address per machine,
+ * safe to read over a shoulder or hand-edit, and `clean()` refuses even a
+ * user name inside an address. A password does not belong in it, so it
+ * lives here instead, keyed by the same machine id.
+ *
+ * Where the OS offers a keychain, Electron's safeStorage seals each value
+ * with it and what lands on disk is ciphertext. Where it does not — a Linux
+ * box with no keyring is the usual case — the value is written as it is and
+ * the record says so, because a store that lies about how it kept your
+ * secret is worse than one that keeps it badly. Ask `sealed()` and tell the
+ * person. The file is 0600 either way.
+ *
+ * The same file also keeps each machine's pinned certificate fingerprint.
+ * That is not a secret — the kernel prints it at startup for anyone to read —
+ * but it is a claim about who the machine is, and quietly editing one is an
+ * attack. It belongs with the token rather than in a document people are
+ * told is safe to hand-edit, so it lives here, written plain because
+ * pretending to seal a public value would be theatre.
+ *
+ * Nothing here reaches Electron directly: the cipher is handed in, so this
+ * runs and is tested without a display, like the rest of the client.
+ */
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * A store over one JSON file. `cipher` is Electron's safeStorage, or
+ * anything with the same three calls; omit it and secrets are kept plain.
+ */
+export function createSecrets(file, { cipher = null } = {}) {
+  const sealing = () => { try { return Boolean(cipher?.isEncryptionAvailable()); } catch { return false; } };
+  const data = load();
+
+  function load() {
+    try {
+      const parsed = JSON.parse(readFileSync(file, 'utf8'));
+      const tokens = parsed?.tokens;
+      const pins = parsed?.pins;
+      return {
+        tokens: tokens && typeof tokens === 'object' ? tokens : {},
+        pins: pins && typeof pins === 'object' ? pins : {}
+      };
+    } catch {
+      return { tokens: {}, pins: {} };
+    }
+  }
+
+  function save() {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+    /* mode only applies to a file being created — an existing one keeps
+       whatever it had, so say it again every time */
+    try { chmodSync(file, 0o600); } catch { /* not every filesystem has modes */ }
+  }
+
+  return {
+    /** Whether what goes to disk is ciphertext. The picker says this out loud. */
+    sealed: sealing,
+
+    /** The token for a machine, or null. A sealed value that will not open is a null, not a throw. */
+    get(id) {
+      const row = data.tokens[String(id)];
+      if (!row || typeof row.value !== 'string') return null;
+      if (row.how !== 'sealed') return row.value;
+      try { return cipher.decryptString(Buffer.from(row.value, 'base64')); } catch { return null; }
+    },
+
+    /** Keep a token, or forget it when the token is empty — one call for both, so a blank field clears. */
+    set(id, token) {
+      const value = String(token ?? '');
+      const key = String(id);
+      if (!value) {
+        if (!(key in data.tokens)) return;
+        delete data.tokens[key];
+        return save();
+      }
+      data.tokens[key] = sealing()
+        ? { how: 'sealed', value: cipher.encryptString(value).toString('base64') }
+        : { how: 'plain', value };
+      save();
+    },
+
+    /** Is there one at all — asked without opening it, so the picker can show a field as filled. */
+    has(id) { return Boolean(data.tokens[String(id)]); },
+
+    /** The fingerprint this machine's certificate must have, or null. */
+    pin(id) {
+      const kept = data.pins[String(id)];
+      return typeof kept === 'string' && kept ? kept : null;
+    },
+
+    /** Pin a fingerprint, or drop it when the field is cleared. Stored normalised. */
+    setPin(id, fingerprint) {
+      const value = normalise(fingerprint);
+      const key = String(id);
+      if (!value) {
+        if (!(key in data.pins)) return;
+        delete data.pins[key];
+        return save();
+      }
+      data.pins[key] = value;
+      save();
+    },
+
+    /** A machine dropped from the list takes its secret and its pin with it. */
+    forget(id) { this.set(id, ''); this.setPin(id, ''); }
+  };
+}
+
+/**
+ * One fingerprint, in the form everything here compares: uppercase hex pairs
+ * separated by colons, which is what the kernel prints and what Node's
+ * X509Certificate.fingerprint256 gives back.
+ *
+ * What arrives may be neither — someone pastes it lowercase, or without the
+ * colons, or with a space where the terminal wrapped it. All of those mean
+ * the same certificate, so all of them are accepted and stored the same way.
+ * Anything that is not 32 bytes of hex is not a fingerprint at all.
+ */
+export function normalise(fingerprint) {
+  const hex = String(fingerprint ?? '').replace(/[^0-9a-fA-F]/g, '').toUpperCase();
+  if (hex.length !== 64) return '';
+  return hex.match(/../g).join(':');
+}
+
+/** Do two fingerprints name the same certificate, however they were written? */
+export function samePin(a, b) {
+  const left = normalise(a);
+  return Boolean(left) && left === normalise(b);
+}
+
+/**
+ * The keyring: which secret to answer a challenge from a given origin with.
+ *
+ * Separate from the store above because most of what it holds never reaches
+ * disk — a kernel this client started has a token that exists only in two
+ * live processes. What lands here is whatever the window will need before it
+ * is pointed at a URL.
+ *
+ * The attempt count is the whole reason this is not a bare Map. Chromium asks
+ * again every time a credential is refused, so answering with the same wrong
+ * secret forever is an infinite loop with a spinner on it. One refusal proves
+ * it is wrong; after that we decline and let the kernel's own 401 be seen.
+ */
+export function createKeyring() {
+  const keys = new Map();     /* host:port → the secret */
+  const tried = new Map();    /* host:port → times offered since it was set */
+  const pins = new Map();     /* host:port → the fingerprint its certificate must have */
+
+  const origin = url => {
+    try {
+      const parsed = new URL(url);
+      return `${parsed.hostname}:${parsed.port || (parsed.protocol === 'https:' ? '443' : '80')}`;
+    } catch { return null; }
+  };
+
+  return {
+    origin,
+
+    /** Hold a secret for whatever is at this URL — or drop it, when there is none. */
+    offer(url, token) {
+      const at = origin(url);
+      if (!at) return null;
+      tried.delete(at);   /* a freshly given secret has not been refused yet */
+      if (token) keys.set(at, token); else keys.delete(at);
+      return at;
+    },
+
+    /**
+     * What to answer `host:port` with, or null to decline. Counts the asking:
+     * a second challenge for the same origin means the first answer was wrong.
+     */
+    answer(host, port) {
+      const at = `${host}:${port}`;
+      const token = keys.get(at);
+      const attempts = (tried.get(at) ?? 0) + 1;
+      tried.set(at, attempts);
+      return token && attempts === 1 ? token : null;
+    },
+
+    /** Hold the fingerprint whatever is at this URL must present — or drop it. */
+    expect(url, fingerprint) {
+      const at = origin(url);
+      if (!at) return null;
+      const value = normalise(fingerprint);
+      if (value) pins.set(at, value); else pins.delete(at);
+      return at;
+    },
+
+    /**
+     * The fingerprint required of `host:port`, or null when nothing is pinned
+     * there. Null means refuse: a certificate no one vouched for and no one
+     * pinned is not one to accept.
+     */
+    expected(host, port) { return pins.get(`${host}:${port}`) ?? null; },
+
+    /** For tests and for forgetting a machine. */
+    has(url) { return keys.has(origin(url)); }
+  };
+}