@sharedenv/cli 1.1.0 → 2.0.0

package/lib/sharing.js

@@ -0,0 +1,112 @@
+// Sharing a vault you administer. With a person: their key comes from the directory, so
+// before anything is sealed to it, it must be the last key the public key log holds for
+// them, and the one this machine knows for them (the bin asks about a new or changed
+// one). With a team you belong to: its public key is derived from the team private key
+// sealed to you, never taken from the server.
+
+import { Buffer } from 'buffer';
+import { Wallet } from './crypto.js';
+import { expectOk, listAll, listOrgs } from './api.js';
+import { assertLogged, syncLog } from './transparency.js';
+
+const wallet = new Wallet();
+
+// → { userId, publicKey, username } of the account behind an email.
+export async function lookupPerson(client, email) {
+  const res = await client.call('GET', `/keyring/lookup?email=${encodeURIComponent(email)}`);
+  if (res.status === 404) throw new Error(`no sharedenv account with a key for ${email}`);
+  const person = expectOk(res, 'cannot look this person up');
+  if (!person?.userId || !person?.publicKey) {
+    throw new Error(`no sharedenv account with a key for ${email}`);
+  }
+  return {
+    ...person,
+    userId: String(person.userId),
+    publicKey: String(person.publicKey).toLowerCase(),
+  };
+}
+
+// The person's key must be the last one the log holds for them. `log`: { store, watch },
+// the watch of the unlock, so this read checks what it goes past like any other.
+export async function assertPersonLogged(client, log, person, label) {
+  const { view } = await syncLog(client, log);
+  assertLogged(view, [{ subject: `user:${person.userId}`, publicKey: person.publicKey, label }]);
+}
+
+// Seals the vault's key to the person and adds them. → 'pending' (until they accept) or
+// 'accepted'.
+export async function shareWithPerson(client, privateKey, vault, person, level) {
+  const sealedSafeKey = wallet.seal(
+    privateKey,
+    person.publicKey,
+    Buffer.from(vault.deks[0], 'hex')
+  );
+  const body = expectOk(
+    await client.call('POST', `/members/${vault.safe._id}`, {
+      userId: person.userId,
+      level,
+      sealedSafeKey: JSON.stringify(sealedSafeKey),
+    }),
+    'cannot share the vault'
+  );
+  return body?.status || 'pending';
+}
+
+// Every team of every organization you are in. → [{ _id, name, org: { _id, name } }]
+export async function listTeams(client) {
+  const teams = [];
+  for (const org of await listOrgs(client)) {
+    const rows = await listAll(client, `/team/list?orgId=${encodeURIComponent(org._id)}`, 'teams');
+    for (const t of rows) {
+      teams.push({ _id: String(t._id), name: t.name, memberCount: t.memberCount, org });
+    }
+  }
+  return teams;
+}
+
+export const teamLabel = (team) => (team.org?.name ? `${team.name} (${team.org.name})` : team.name);
+
+// A team by id or (case-insensitive) name; several answering to it pick none.
+export async function resolveTeam(client, ref) {
+  const want = String(ref).toLowerCase();
+  const matches = (await listTeams(client)).filter(
+    (t) => t._id.toLowerCase() === want || t.name?.toLowerCase() === want
+  );
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) throw new Error(`no team named "${ref}" (sharedenv teams lists yours)`);
+  throw Object.assign(
+    new Error(
+      [
+        `"${ref}" names ${matches.length} teams: give its id`,
+        ...matches.map((t) => `  ${teamLabel(t)}  ${t._id}`),
+      ].join('\n')
+    ),
+    { exitCode: 2 }
+  );
+}
+
+// Seals the vault's key to the team's key — derived from the team private key sealed to
+// you — and grants it. → 'accepted', or 'pending' until someone who answers for the team
+// accepts it.
+export async function shareWithTeam(client, privateKey, vault, team, level) {
+  const res = await client.call('GET', `/team-keys/${encodeURIComponent(team._id)}/me`);
+  if (res.status === 404) {
+    throw new Error(
+      `you hold no key for team ${teamLabel(team)}: only one of its members can share with it`
+    );
+  }
+  const mine = expectOk(res, 'cannot read your team key');
+  const opened = mine?.sealedTeamKey && wallet.open(privateKey, mine.sealedTeamKey);
+  if (!opened) throw new Error(`cannot open your key for team ${teamLabel(team)}`);
+  const teamPublicKey = wallet.keypass.publicFromPrivate(opened.toString('utf8'));
+  const sealedSafeKey = wallet.seal(privateKey, teamPublicKey, Buffer.from(vault.deks[0], 'hex'));
+  const body = expectOk(
+    await client.call('POST', `/safes/${vault.safe._id}/share-team`, {
+      teamId: team._id,
+      level,
+      sealedSafeKey: JSON.stringify(sealedSafeKey),
+    }),
+    'cannot share the vault with the team'
+  );
+  return body?.status || 'accepted';
+}

package/lib/transparency.js

@@ -4,37 +4,38 @@
 // each entry chained to the previous one by its hash. This CLI:
 //   - seals to, or trusts the seal of, a key only if it is the LAST one the log holds
 //     for its owner: a substituted key would have to be logged, where its owner sees it ;
-//   - watches your own name: a key logged under it that is not yours is reported ;
+//   - watches the keys you hold - your own, and the key of every team sealed to you: a
+//     key logged under one of their names that is not the one you hold is reported, and
+//     the warning comes back at every unlock until `sharedenv log --ack` ;
 //   - keeps what it checked (~/.sharedenv/log.json) and refuses a log that does not
 //     chain, rewrites what it already saw, or goes back.
-// The arithmetic is lib/crypto/kt.js.
+// The arithmetic, and the rules of what is kept, are lib/crypto/kt.js.
 
-import { emptyView, replay, isLogged } from './crypto.js';
-import { expectOk } from './api.js';
+import { Wallet, absorb, acknowledge, readFrom, toRecord, isLogged } from './crypto.js';
+import { expectOk, listAll, listOrgs } from './api.js';
 
 const PAGE_LIMIT = 500;
 
-const saneView = (v) =>
-  v &&
-  Number.isInteger(v.seq) &&
-  typeof v.hash === 'string' &&
-  v.latest &&
-  typeof v.latest === 'object';
+const wallet = new Wallet();
 
 // Reads the log after what this machine checked, replays it, keeps the result.
 //   store   lib/store.js (or none: replay from the start, keep nothing)
-//   watch   { [subject]: publicKey } — the keys we hold
-// → { view, foreign, unlogged }. Throws when the log cannot be read or does not add up.
+//   watch   { [subject]: publicKey } - EVERY key we hold (heldKeys). A sync that watches
+//           nothing does not move what is kept: the entries it went past would never be
+//           checked against anyone's name.
+// → { view, foreign, unlogged, alerts }: `alerts`, what the watch found and nobody
+// acknowledged yet, this sync included. Throws when the log cannot be read or does not
+// add up.
 export async function syncLog(client, { store, watch = {} } = {}) {
-  const stored = store?.readLogView();
-  const from = saneView(stored) ? stored : emptyView();
+  const record = toRecord(store?.readLogView());
+  const from = readFrom(record, watch);
 
   const read = async (to, page) => {
     const bound = to === null ? '' : `&to=${to}`;
     return expectOk(
       await client.call(
         'GET',
-        `/transparency/log?from=${from.seq}${bound}&page=${page}&limit=${PAGE_LIMIT}`
+        `/transparency/log?from=${from}${bound}&page=${page}&limit=${PAGE_LIMIT}`
       ),
       'cannot read the public key log'
     );
@@ -44,7 +45,7 @@ export async function syncLog(client, { store, watch = {} } = {}) {
   if (!Number.isInteger(head?.seq) || typeof head?.hash !== 'string') {
     throw new Error('the public key log sent no head');
   }
-  if (head.seq < from.seq) {
+  if (head.seq < record.seq) {
     throw new Error('the public key log is shorter than what this machine already checked');
   }
   const entries = [...(first.data || [])];
@@ -52,18 +53,81 @@ export async function syncLog(client, { store, watch = {} } = {}) {
     entries.push(...((await read(head.seq, page)).data || []));
   }
 
-  let replayed;
+  let result;
   try {
-    replayed = replay(from, entries, { watch });
+    result = absorb(record, from, entries, head, { watch });
   } catch (err) {
     throw new Error(`the public key log does not add up: ${err.message}`);
   }
-  const { view, foreign, unlogged } = replayed;
-  if (view.seq !== head.seq || view.hash !== head.hash) {
-    throw new Error('the public key log does not add up: its head does not match its entries');
+  if (store && result.changed) store.writeLogView(result.record);
+  const { view, foreign, unlogged, alerts } = result;
+  return { view, foreign, unlogged, alerts };
+}
+
+// The warnings kept on this machine and not acknowledged yet, without reading the log.
+export const keptAlerts = (store) => toRecord(store.readLogView()).alerts;
+
+// The owner has read them. → the warnings acknowledged. One still true comes back at
+// the next unlock.
+export function acknowledgeAlerts(store) {
+  const record = toRecord(store.readLogView());
+  if (record.alerts.length) store.writeLogView(acknowledge(record));
+  return record.alerts;
+}
+
+// The keys this account holds, as the log should hold them:
+//   - its own, `user:<id>`, derived from the private key (never the server's copy) ;
+//   - for every team whose key was sealed to it, `team:<id>`, DERIVED from the team
+//     private key it opens. That key is watched like our own: a team key swapped in the
+//     directory would receive every safe shared with the team, and only those who hold
+//     the real one can tell.
+// Teams that cannot be read are left out of this watch: they are read again from the
+// start of the log the next time they are watched (kt.js `readFrom`).
+// → { watch: { [subject]: publicKey }, labels: { [subject]: name } }
+export async function heldKeys(client, { privateKey, userId }) {
+  const watch = { [`user:${userId}`]: wallet.keypass.publicFromPrivate(privateKey) };
+  const labels = {};
+  let orgs = [];
+  try {
+    orgs = await listOrgs(client);
+  } catch {
+    return { watch, labels };
   }
-  if (store && view.seq > from.seq) store.writeLogView(view);
-  return { view, foreign, unlogged };
+  const teams = new Map();
+  for (const org of orgs) {
+    try {
+      const rows = await listAll(
+        client,
+        `/team/list?orgId=${encodeURIComponent(org._id)}`,
+        'teams'
+      );
+      // Every team of the org: the server hands its key only to a member it was sealed to.
+      for (const t of rows) teams.set(String(t._id), t.name);
+    } catch {
+      /* an org that does not answer: its teams wait for the next unlock */
+    }
+  }
+  for (const [teamId, name] of teams) {
+    const key = await teamKeyOf(client, privateKey, teamId).catch(() => null);
+    if (key) {
+      watch[`team:${teamId}`] = key;
+      labels[`team:${teamId}`] = name;
+    }
+  }
+  return { watch, labels };
+}
+
+// The team's OFFICIAL public key, derived from the team private key sealed to us, or
+// null (not provisioned, or not readable). While a team-key rotation is unfinished our
+// row may already hold the next key: the official one is then the key it held before.
+async function teamKeyOf(client, privateKey, teamId) {
+  const res = await client.call('GET', `/team-keys/${encodeURIComponent(teamId)}/me`);
+  if (res.status !== 200 || !res.body?.sealedTeamKey) return null;
+  const mine = res.body;
+  const ahead = (mine.keyVersion || 1) > (mine.teamKeyVersion || 1);
+  const blob = ahead ? mine.previousSealedTeamKey : mine.sealedTeamKey;
+  const opened = blob && wallet.open(privateKey, blob);
+  return opened ? wallet.keypass.publicFromPrivate(opened.toString('utf8')) : null;
 }
 
 // Every target's key must be the last one the log holds for its subject.
@@ -79,21 +143,41 @@ export function assertLogged(view, targets) {
   }
 }
 
-// What the watch found, as lines for stderr (none when all is well).
-export function watchWarnings({ foreign = [], unlogged = [] }) {
+// The warnings, as lines for stderr (none when all is well). `labels`: team names.
+export function watchWarnings({ alerts = [] } = {}, labels = {}) {
   const lines = [];
-  if (foreign.length) {
+  const entries = (list) => list.map((a) => a.seq).join(', ');
+  const bySubject = (kind) => {
+    const groups = new Map();
+    for (const a of alerts.filter((x) => x.kind === kind)) {
+      groups.set(a.subject, [...(groups.get(a.subject) || []), a]);
+    }
+    return groups;
+  };
+  const teamName = (subject) => labels[subject] || subject.slice('team:'.length);
+  for (const [subject, list] of bySubject('foreign')) {
     lines.push(
-      'WARNING: a key that is not yours was registered under your name in the public key log ' +
-        `(entry ${foreign.map((f) => f.seq).join(', ')}). If you did not reset your vault, ` +
-        'tell SharedEnv: it is the trace of an attack.'
+      subject.startsWith('team:')
+        ? `WARNING: a key that is not the one you hold for team "${teamName(subject)}" was ` +
+            `registered for it in the public key log (entry ${entries(list)}). Unless a lead ` +
+            'of the team replaced its key, tell SharedEnv: it is the trace of an attack.'
+        : 'WARNING: a key that is not yours was registered under your name in the public key ' +
+            `log (entry ${entries(list)}). If you did not reset your vault, tell SharedEnv: it ` +
+            'is the trace of an attack.'
     );
   }
-  if (unlogged.length) {
+  for (const [subject] of bySubject('unlogged')) {
     lines.push(
-      'WARNING: your key is not the last one the public key log holds for you: nobody can ' +
-        'share with you until it is. Tell SharedEnv.'
+      subject.startsWith('team:')
+        ? `WARNING: the key you hold for team "${teamName(subject)}" is not the last one the ` +
+            'public key log holds for it: nobody can share with the team until it is. Tell ' +
+            'SharedEnv.'
+        : 'WARNING: your key is not the last one the public key log holds for you: nobody can ' +
+            'share with you until it is. Tell SharedEnv.'
     );
   }
+  if (lines.length) {
+    lines.push('These warnings come back at every unlock until `sharedenv log --ack`.');
+  }
   return lines;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sharedenv/cli",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
   "description": "sharedenv CLI — pull and run with your zero-knowledge secrets, decrypted locally.",
   "license": "Apache-2.0",