@dotrino/vaultd 0.155.0 → 0.157.0

package/{src → lib/src/core}/notices.js

@@ -12,9 +12,6 @@
  * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se LANZA: callar
  * sería decir «no pasó nada» de algo que sí pasó.
  */
-import fs from 'node:fs'
-import path from 'node:path'
-import crypto from 'node:crypto'
 
 export const NOTICES_FILE = 'notices.json'
 /** Cuánto se sigue contando un aviso. */
@@ -25,25 +22,24 @@ export const NOTICE_EVS = ['updated', 'update-needs-root']
 const fail = (code, message) => Object.assign(new Error(message), { code })
 
 /**
- * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ * @param {{ disk: object, now?: () => number }} opts
  */
-export function openNotices ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, NOTICES_FILE)
+export function openNotices ({ disk, now = Date.now }) {
+  const file = NOTICES_FILE
+  const atRest = disk.atRest
   let items = load()
 
   function load () {
-    if (!fs.existsSync(file)) return []
+    if (!disk.exists(file)) return []
     try {
-      const d = JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8')))
+      const d = JSON.parse(atRest.decrypt(disk.read(file)))
       if (!d || !Array.isArray(d.items)) throw new Error('not a list')
       return d.items.filter((n) => n && typeof n.id === 'string' && typeof n.ts === 'number')
     } catch (e) { throw fail('notices-unreadable', `${NOTICES_FILE} cannot be read: ${e.message}`) }
   }
 
   function save () {
-    const tmp = file + '.tmp'
-    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items })), { mode: 0o600 })
-    fs.renameSync(tmp, file)
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items })))
   }
 
   const alive = (n) => now() - n.ts < NOTICE_TTL_MS
@@ -60,7 +56,7 @@ export function openNotices ({ dir, atRest, now = Date.now }) {
       if (typeof version !== 'string' || !version) throw fail('bad-notice', `${ev}: a version is required`)
       if (typeof product !== 'string' || !product) throw fail('bad-notice', `${ev}: a product is required`)
       const n = {
-        id: crypto.randomBytes(8).toString('hex'), ev, product, version, from: typeof from === 'string' ? from : null,
+        id: [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join(''), ev, product, version, from: typeof from === 'string' ? from : null,
         ...(typeof deviceId === 'string' && deviceId ? { deviceId, label: typeof label === 'string' ? label : '' } : {}),
         ts: now()
       }

package/{src → lib/src/core}/notifiable.js

@@ -22,8 +22,6 @@
  * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer NO es «nadie
  * puede recibir avisos»: se lanza.
  */
-import fs from 'node:fs'
-import path from 'node:path'
 
 export const NOTIFIABLE_FILE = 'notifiable.json'
 /** Cuánto vale un «puedo recibir avisos» sin renovarse. */
@@ -32,19 +30,20 @@ export const NOTIFIABLE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 const fail = (code, message) => Object.assign(new Error(message), { code })
 
 /**
- * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ * @param {{ disk: object, now?: () => number }} opts
  */
-export function openNotifiable ({ dir, atRest, now = Date.now }) {
-  const file = path.join(dir, NOTIFIABLE_FILE)
+export function openNotifiable ({ disk, now = Date.now }) {
+  const file = NOTIFIABLE_FILE
+  const atRest = disk.atRest
   /** pub → ms de la última vez que dijo que sí */
   const items = load()
 
   function load () {
     let raw
-    try { raw = fs.readFileSync(file, 'utf8') } catch (e) {
-      if (e.code === 'ENOENT') return new Map()
+    try { raw = disk.read(file) } catch (e) {
       throw fail('notifiable-unreadable', `cannot read ${NOTIFIABLE_FILE}: ${e.message}`)
     }
+    if (raw == null) return new Map()
     let d
     try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('notifiable-unreadable', `${NOTIFIABLE_FILE} cannot be opened: ${e.message}`) }
     if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('notifiable-unreadable', `${NOTIFIABLE_FILE} has an unknown shape`)
@@ -52,9 +51,7 @@ export function openNotifiable ({ dir, atRest, now = Date.now }) {
   }
 
   function save () {
-    const tmp = file + '.tmp'
-    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })), { mode: 0o600 })
-    fs.renameSync(tmp, file)
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
   }
 
   return {

package/{src → lib/src/core}/sealKey.js

@@ -17,9 +17,7 @@
  * No guarda ninguna correspondencia con `seq`: quién mandaba y cuándo lo dice el acta
  * (`sealKeys` con su tramo). Aquí solo están las privadas, indexadas por su pública.
  */
-import path from 'node:path'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './disk.js'
 import { signWithDevice } from '@dotrino/identity/capabilities'
 
 /**
@@ -30,13 +28,12 @@ import { signWithDevice } from '@dotrino/identity/capabilities'
 const MAX_KEYS = 8
 
 /** Abre (o estrena) el llavero de sellado del perfil. */
-export function openSealKeys (dir) {
-  const file = path.join(dir, 'sealkeys.json')
-  const atRest = atRestFor(dir)
-  const data = readJson(file, null, atRest) || { v: 1, keys: [] }
+export function openSealKeys (disk) {
+  const file = 'sealkeys.json'
+  const data = readJson(disk, file, null) || { v: 1, keys: [] }
   if (!Array.isArray(data.keys)) data.keys = []
 
-  const save = () => writeJson(file, data, atRest)
+  const save = () => writeJson(disk, file, data)
   const find = (pub) => data.keys.find((k) => k.pub === pub) || null
 
   return {

package/{src → lib/src/core}/sealer.js

@@ -24,13 +24,14 @@
  * Lo que sí abre es todo lo demás; los límites honestos están en
  * `docs/secretos-sellados.md` §3 y conviene leerlos antes de confiar de más.
  */
-import crypto from 'node:crypto'
 import {
   makeContentKey, makeGeneration, encryptWithCek, decryptWithCek, wrapForMember, openWrap
 } from '@dotrino/identity/content'
 
-const b64 = (b) => Buffer.from(b).toString('base64')
-const un64 = (s) => Buffer.from(s, 'base64')
+const b64 = (b) => { let s = ''; for (const x of new Uint8Array(b)) s += String.fromCharCode(x); return btoa(s) }
+const un64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0))
+/** AES-256-GCM con WebCrypto: el mismo en Node y en el navegador. */
+const aesKey = (raw, uses) => crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, false, uses)
 
 /** La copia maestra va cifrada con AES-256-GCM bajo la llave derivada de la contraseña. */
 const MASTER_V = 1
@@ -66,9 +67,11 @@ export function makeSealer () {
       if (!blob) return {}
       if (blob.v !== MASTER_V) throw new Error(`master copy: unknown format v${blob.v}`)
       try {
-        const d = crypto.createDecipheriv('aes-256-gcm', adminKey, un64(blob.iv))
-        d.setAuthTag(un64(blob.tag))
-        return JSON.parse(Buffer.concat([d.update(un64(blob.ct)), d.final()]).toString('utf8'))
+        // WebCrypto quiere la etiqueta pegada al final del cifrado; en disco van aparte.
+        const ct = un64(blob.ct); const tag = un64(blob.tag)
+        const both = new Uint8Array(ct.length + tag.length); both.set(ct); both.set(tag, ct.length)
+        const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: un64(blob.iv) }, await aesKey(adminKey, ['decrypt']), both)
+        return JSON.parse(new TextDecoder().decode(plain))
       } catch (_) {
         // El tag de AES-GCM ES el verificador: si no cuadra, la contraseña no era.
         // Por eso no hace falta guardar aparte un verificador de la contraseña, que
@@ -79,10 +82,9 @@ export function makeSealer () {
 
     async sealMaster (obj, adminKey) {
       assertKey(adminKey)
-      const iv = crypto.randomBytes(12)
-      const c = crypto.createCipheriv('aes-256-gcm', adminKey, iv)
-      const ct = Buffer.concat([c.update(JSON.stringify(obj), 'utf8'), c.final()])
-      return { v: MASTER_V, iv: b64(iv), ct: b64(ct), tag: b64(c.getAuthTag()) }
+      const iv = crypto.getRandomValues(new Uint8Array(12))
+      const both = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, await aesKey(adminKey, ['encrypt']), new TextEncoder().encode(JSON.stringify(obj))))
+      return { v: MASTER_V, iv: b64(iv), ct: b64(both.subarray(0, both.length - 16)), tag: b64(both.subarray(both.length - 16)) }
     },
 
     /** La CEK de un cajón, creándola si es la primera variable que entra ahí. */

package/{src → lib/src/core}/secretsStore.js

@@ -53,10 +53,8 @@
  * pide sobres. Así se prueba con un sellador falso y determinista, y la forma del
  * archivo se razona sin mirar una sola llave.
  */
-import path from 'node:path'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
-import { isValidSecretsNs } from './protocol.js'
+import { readJson, writeJson } from './disk.js'
+import { isValidSecretsNs } from '../protocol.js'
 
 const SCHEMA_VERSION = 5
 /** v4: sellado, pero con la copia maestra bajo la frase. Se lee y se sirve; no se escribe. */
@@ -168,10 +166,9 @@ function migrateBag (bag) {
  *   `defaultKey`: con qué sellar la privada de recuperación cuando el perfil NO tiene
  *   contraseña. Vive aquí, en un solo sitio, para que dé igual por qué puerta se entre.
  */
-export function openSecretsStore (dir, { sealer = null, recipients = null, signer = null, defaultKey = null } = {}) {
-  const file = path.join(dir, 'secrets.json')
-  const atRest = atRestFor(dir)
-  let data = readJson(file, null, atRest)
+export function openSecretsStore (disk, { sealer = null, recipients = null, signer = null, defaultKey = null } = {}) {
+  const file = 'secrets.json'
+  let data = readJson(disk, file, null)
 
   // v1 → v2: el cajón por scope se conserva y estrena el `dev`.
   // v2 → v3: los valores dejan de ser strings sueltos y pasan a llevar su visibilidad.
@@ -196,13 +193,13 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   const isLegacy = () => data.schemaVersion === LEGACY_VERSION
   const needsMigration = () => data.schemaVersion === SEALED_MASTER_VERSION
 
-  writeJson(file, data, atRest) // reescribe al abrir: cifra lo que venía en claro
+  writeJson(disk, file, data) // reescribe al abrir: cifra lo que venía en claro
 
   // Un grupo de escrituras se guarda UNA vez (ver `batch`). Fuera de un grupo, `held`
   // vale 0 y cada cambio va al disco en el acto, como siempre.
   let held = 0
   let pending = false
-  const flush = () => writeJson(file, data, atRest)
+  const flush = () => writeJson(disk, file, data)
   const save = () => { if (held) { pending = true; return } ; flush() }
 
   const assertNs = (ns) => {
@@ -1313,7 +1310,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
 
       // Copia de lo anterior antes de pisarlo. Con nodos en producción, deshacer tiene
       // que ser un `mv`, no una restauración. La borra el operador a mano.
-      writeJson(`${file}.v${desde}.bak`, data, atRest)
+      writeJson(disk, `${file}.v${desde}.bak`, data)
       data = next
       flush()
       return { migrated: true, from: desde, sinLlave }

package/lib/src/core/sha256.js

@@ -0,0 +1,69 @@
+/**
+ * SHA-256 SÍNCRONO, en JavaScript puro.
+ *
+ * El navegador solo trae `crypto.subtle.digest`, que es asíncrono, y la bitácora de la
+ * bóveda encadena cada línea con el hash de la anterior en el mismo paso en que la escribe:
+ * volverlo asíncrono dejaría dos entradas apuntando a la misma anterior. Así el binario y
+ * el navegador encadenan exactamente igual, y lo comprueba la prueba contra `node:crypto`.
+ */
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+])
+
+/** @param {Uint8Array} data */
+export function sha256Bytes (data) {
+  const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19])
+  const len = data.length
+  const total = ((len + 9 + 63) >> 6) << 6
+  const buf = new Uint8Array(total)
+  buf.set(data)
+  buf[len] = 0x80
+  const bits = len * 8
+  const view = new DataView(buf.buffer)
+  view.setUint32(total - 8, Math.floor(bits / 0x100000000))
+  view.setUint32(total - 4, bits >>> 0)
+  const w = new Uint32Array(64)
+  for (let off = 0; off < total; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4)
+    for (let i = 16; i < 64; i++) {
+      const a = w[i - 15], b = w[i - 2]
+      const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3)
+      const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10)
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0
+    }
+    let [a, b, c, d, e, f, g, hh] = h
+    for (let i = 0; i < 64; i++) {
+      const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7))
+      const ch = (e & f) ^ (~e & g)
+      const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0
+      const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10))
+      const maj = (a & b) ^ (a & c) ^ (b & c)
+      const t2 = (S0 + maj) >>> 0
+      hh = g; g = f; f = e; e = (d + t1) >>> 0
+      d = c; c = b; b = a; a = (t1 + t2) >>> 0
+    }
+    h[0] = (h[0] + a) >>> 0; h[1] = (h[1] + b) >>> 0; h[2] = (h[2] + c) >>> 0; h[3] = (h[3] + d) >>> 0
+    h[4] = (h[4] + e) >>> 0; h[5] = (h[5] + f) >>> 0; h[6] = (h[6] + g) >>> 0; h[7] = (h[7] + hh) >>> 0
+  }
+  const out = new Uint8Array(32)
+  const ov = new DataView(out.buffer)
+  for (let i = 0; i < 8; i++) ov.setUint32(i * 4, h[i])
+  return out
+}
+
+/** El hash de un texto (UTF-8), en hexadecimal. Lo mismo que `createHash('sha256').update(text, 'utf8').digest('hex')`. */
+export function sha256Hex (text) {
+  const bytes = typeof text === 'string' ? new TextEncoder().encode(text) : text
+  let s = ''
+  for (const b of sha256Bytes(bytes)) s += b.toString(16).padStart(2, '0')
+  return s
+}
+
+export default { sha256Bytes, sha256Hex }

package/{src → lib/src/core}/store.js

@@ -6,9 +6,7 @@
  * `@dotrino/identity` dentro del mismo dir (keypair, contactos, delegaciones,
  * revocaciones). Aquí vive solo lo del usuario: el árbol y los settings.
  */
-import path from 'node:path'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './disk.js'
 
 const SCHEMA_VERSION = 1
 
@@ -28,17 +26,16 @@ function findNode (node, id) {
   return null
 }
 
-export function openStore (dir) {
-  const file = path.join(dir, 'vault.json')
-  const atRest = atRestFor(dir)
-  let data = readJson(file, null, atRest)
+export function openStore (disk) {
+  const file = 'vault.json'
+  let data = readJson(disk, file, null)
   if (!data || data.schemaVersion !== SCHEMA_VERSION) {
     data = { schemaVersion: SCHEMA_VERSION, tree: newTree(), settings: {} }
   }
   // Se reescribe SIEMPRE al abrir: así un archivo de una instalación anterior
   // (en claro) queda cifrado sin pedirle nada al usuario.
-  writeJson(file, data, atRest)
-  const save = () => writeJson(file, data, atRest)
+  writeJson(disk, file, data)
+  const save = () => writeJson(disk, file, data)
 
   return {
     get raw () { return data },

package/{src → lib/src/core}/subacta.js

@@ -32,9 +32,8 @@
  * hay conflictos ni hace falta un `seq`. Y **solo salen al absorberse** en el acta: nunca
  * por reloj, o un aparato apagado perdería justo la que lo protege.
  */
-import path from 'node:path'
 import { verifyRenounce } from '@dotrino/identity/acta'
-import { readJson, writeJson } from './paths.js'
+import { readJson, writeJson } from './disk.js'
 
 /** Las operaciones que caben. La lista ES la regla: todas quitan, todas las firma su sujeto. */
 export const OPS = Object.freeze(['renounce'])
@@ -57,10 +56,10 @@ export async function isAcceptable (e) {
  * demás: sus entradas dicen qué aparatos se quedaron sin qué, y eso es material de la
  * cuenta aunque no sea un secreto.
  */
-export function openSubacta (dir, atRest) {
-  const file = path.join(dir, 'subacta.json')
-  let data = readJson(file, null, atRest) || { v: 1, entries: [] }
-  const guardar = () => writeJson(file, data, atRest)
+export function openSubacta (disk) {
+  const file = 'subacta.json'
+  let data = readJson(disk, file, null) || { v: 1, entries: [] }
+  const guardar = () => writeJson(disk, file, data)
 
   return {
     /** Las entradas vigentes, tal cual se le pasan a `memberCan` y compañía. */

package/{src → lib/src/core}/threadStore.js

@@ -13,11 +13,9 @@
  * vive el contenido de las apps y el perfil del usuario, que es exactamente lo
  * que el ecosistema promete que no queda en claro en ningún disco.
  */
-import path from 'node:path'
 import * as core from '@dotrino/store/core'
 import { resealStale } from '@dotrino/identity/content'
-import { readJson, writeJson } from './paths.js'
-import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './disk.js'
 
 // El MISMO tope que acepta la página del almacén. Era 1000: una app que guarda más en un
 // hilo (los compradores de facturero, por ejemplo) perdía aquí lo más viejo sin decir nada,
@@ -35,10 +33,9 @@ export const RESEALED_KEEP_MS = 366 * 24 * 60 * 60 * 1000
 const MAX_SECURE_ITEMS = 2000
 const MAX_SECURE_BLOB = 64 * 1024   // por campo sellado (meta y valor)
 
-export function openThreadStore (dir) {
-  const file = path.join(dir, 'threads.json')
-  const atRest = atRestFor(dir)
-  let data = readJson(file, null, atRest)
+export function openThreadStore (disk) {
+  const file = 'threads.json'
+  let data = readJson(disk, file, null)
   if (!data || typeof data !== 'object') data = { v: 1, threads: {}, opens: {} }
   if (!data.threads) data.threads = {}
   if (!data.opens) data.opens = {}
@@ -47,7 +44,7 @@ export function openThreadStore (dir) {
   // primer aparato que todavía tenga la entrada.
   if (!data.tombs) data.tombs = {}
   core.pruneTombs(data.tombs, Date.now())
-  const save = () => writeJson(file, data, atRest)
+  const save = () => writeJson(disk, file, data)
   save() // reescribe al abrir: cifra lo que venía en claro
   const budget = (n) => Math.min(Math.max(Number(n) || core.PAGE_BYTES, 1024), core.PAGE_BYTES)
   const needKeys = (keys) => {

package/{src → lib/src/core}/transport.js

@@ -20,7 +20,6 @@
  * con un `signData` de cortesía si hace falta. El daemon (vault.js) además puebla
  * `me` antes de conectar.
  */
-import { installNodeGlobals } from './node-globals.js'
 
 const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
 
@@ -31,13 +30,13 @@ export async function masterPubkeyOf (identity) {
 /**
  * Conecta el transporte y lo identifica con la maestra del vault.
  * @param {Object} opts
- * @param {import('@dotrino/identity/node').Identity} opts.identity
- * @param {string} opts.dir   Directorio de persistencia.
+ * @param {import('@dotrino/identity/facade').IdentityFacade} opts.identity
+ * @param {Function} [opts.makeClient]  quién crea el cliente del proxio. Sin él, el del
+ *   ecosistema; el navegador lo pasa siempre (un service worker no puede hacer `import()`).
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
-  installNodeGlobals(dir)
+export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
   // ese es un SINGLETON de proceso, y con multi-perfil el vault necesita una