@dotrino/identity 0.115.0 → 0.117.0

package/vault/vendor/passmanager/vault/sealed-local.js

@@ -0,0 +1,199 @@
+// LA BÓVEDA SELLADA CUANDO QUIEN GUARDA Y QUIEN LEE SON EL MISMO PROCESO.
+//
+// `SealedVault` es el aparato hablando con una bóveda que está al otro lado de un
+// transporte. Esto es el otro caso, y existe de verdad en dos sitios del ecosistema:
+//
+//   · **`dotrino-passmanager serve`** — el mismo proceso atiende por el proxio y es
+//     también la línea de comandos con la que el dueño mira lo suyo;
+//   · **la bóveda de dentro de la extensión** — no hay nadie más a quien preguntar.
+//
+// En los dos, quien lee lo hace con UNA envoltura: la de `#recovery` (el dueño con su
+// contraseña) o la del propio aparato. Se le dice cuál al construirla y no se adivina:
+// adivinarlo sería leer con la que hubiera, y entonces «no puedo abrir esto» y «esto no es
+// para mí» se verían igual.
+//
+// Cumple el contrato de siempre (`./interface.js`) para que nada de lo que hay encima
+// tenga que aprender otra forma de pedir las cosas.
+
+import { VaultError, CODES } from './errors.js'
+import { findForUrl } from '../match.js'
+import { siteIndex, fieldIndex, valueDigest } from '../sealed/keys.js'
+import { buildSealedEntry, openSealedEntry, openSealedView } from '../sealed/device.js'
+import { mergePatch } from '../model.js'
+
+/** Los nombres FIJOS, que viajan tal cual: vocabulario cerrado e igual para todos. */
+const FIXED = ['name', 'username', 'secret', 'totp', 'notes']
+
+export class SealedLocalVault {
+  /**
+   * @param {SealedStore} sealed  el almacén de sobres
+   * @param {object} opts
+   *   `readerPub`   con qué envoltura se lee: `RECOVERY` o la pública de este aparato
+   *   `openSealed({ wrap, envelope })` abre un sobre. La privada no sale de donde viva.
+   *   `author`      `{ publickey, sign(body) }` quien firma lo que se escribe
+   *   `recipients()` → `{ recoveryPub, main, passkeys }` a quién se le envuelve
+   *   `keys()`      → las llaves del perfil (`profileKeys`), para huellas y resúmenes
+   */
+  constructor (sealed, { readerPub, openSealed, author, recipients, keys } = {}) {
+    if (!sealed) throw new Error('SealedLocalVault: missing the sealed store')
+    if (!readerPub) throw new Error('SealedLocalVault: say which wrap this one reads with')
+    for (const n of ['openSealed', 'author', 'recipients', 'keys']) {
+      if (!arguments[1]?.[n]) throw new Error(`SealedLocalVault: missing ${n}`)
+    }
+    this.sealed = sealed
+    this.readerPub = readerPub
+    this.openSealed = openSealed
+    this.author = author
+    this.recipients = recipients
+    this.keys = keys
+  }
+
+  get capabilities () {
+    // `canList` es `true` y aquí sí es verdad: quien pregunta es el dueño en su propia
+    // máquina, no un aparato pidiendo por el proxio. Lo que no existe en remoto sigue sin
+    // existir — esto no se asoma por ningún transporte.
+    return { canWrite: true, canList: true, needsApproval: false, sealed: true }
+  }
+
+  /** De la clave que usa la interfaz a la que guarda la bóveda. La misma que `SealedVault`. */
+  async #sealedKey (k) {
+    if (FIXED.includes(k) || k.startsWith('wa.')) return k
+    const { kidx } = await this.keys()
+    return 'f:' + await fieldIndex(kidx, k)
+  }
+
+  /** Las vistas, abiertas. Es lo que se enseña en una lista: sin valores privados. */
+  async list () {
+    const vistas = await this.sealed.views({ pub: this.readerPub })
+    const out = []
+    for (const v of vistas) {
+      const abierta = await openSealedView({ ...v, openSealed: this.openSealed })
+      // `fieldHashes` con el nombre que ya usa la interfaz para comparar sin abrir nada.
+      // Los resúmenes están GUARDADOS y su clave viaja por huella, así que aquí se
+      // traducen de vuelta — la vista sí lleva los nombres de verdad, porque va sellada.
+      // Sin esto, «¿ya está guardado igual?» se contesta que no siempre, y el aviso de
+      // guardar sale en cada formulario que ya tenías.
+      const fieldHashes = {}
+      for (const k of [...(abierta.fieldKeys || []), 'notes']) {
+        const clave = await this.#sealedKey(k)
+        if (abierta.digests?.[clave] !== undefined) fieldHashes[k] = abierta.digests[clave]
+      }
+      out.push({ ...abierta, fieldHashes })
+    }
+    return out
+  }
+
+  /**
+   * El resumen de un valor, para decir si ya está guardado igual **sin abrir nada** (§2.6).
+   * No hay nonce que compartir: el `id` de la entrada va dentro, que es lo que impide que
+   * un valor repetido en dos entradas se note.
+   */
+  async digest (id, key, value) {
+    const { kcmp } = await this.keys()
+    return valueDigest(kcmp, id, key, String(value))
+  }
+
+  /**
+   * Lo que hay para una URL, ya ORDENADO por lo bien que casa: las entradas, no los pares
+   * `{entry, match}` de `findForUrl`. Es la misma forma que devuelve `SealedVault.find`,
+   * y tiene que serlo — quien llama no debería notar de qué bóveda le están contestando.
+   */
+  async find (url) {
+    return findForUrl(await this.list(), url).map((x) => x.entry)
+  }
+
+  /**
+   * EN QUÉ SITIOS HAY ALGO, y cuánto en cada uno. Misma forma que `LocalVault.sites()`
+   * —`[{ site, count }]`— porque es lo que pinta el gestor: devolver una lista de cadenas
+   * dejaba la fila de dominios vacía sin un solo error.
+   *
+   * El sitio vacío es «sirve en cualquier parte» y va al final, que es donde se busca.
+   */
+  async sites () {
+    const cuenta = new Map()
+    for (const e of await this.list()) {
+      for (const s of (e.sites?.length ? e.sites : [''])) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta.entries()]
+      .map(([site, count]) => ({ site, count }))
+      .sort((a, b) => (a.site === '' ? 1 : b.site === '' ? -1 : a.site.localeCompare(b.site)))
+  }
+
+  /**
+   * BUSCAR por texto. Se mira lo mismo que mira `SealedVault`: el nombre, el SITIO y la
+   * **pista** —el usuario tapado que la vista lleva—, que es por lo que la gente busca de
+   * verdad («ana@…»). Dejarla fuera hacía que buscar la cuenta de otro dominio no
+   * encontrara nada, sin un solo error.
+   *
+   * Se busca sobre las VISTAS, no sobre los valores: aquí no se abre ninguna contraseña
+   * para contestar a un buscador.
+   */
+  async search (texto, { limit = 20 } = {}) {
+    const q = String(texto || '').trim().toLowerCase()
+    if (!q) return []
+    const out = []
+    for (const v of await this.list()) {
+      if (out.length >= limit) break
+      if ([v.title, v.hint, ...(v.sites || [])].filter(Boolean).join(' ').toLowerCase().includes(q)) out.push(v)
+    }
+    return out
+  }
+
+  /** Una entrada ENTERA, o solo los campos que se pidan. */
+  async get (id, { keys = null } = {}) {
+    let got
+    try { got = await this.sealed.get(id, { pub: this.readerPub, keys }) }
+    catch (e) {
+      if (e?.code === 'not-found') throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+      // «no me la envolvieron a mí» no es «no existe», y confundirlas manda a buscar el
+      // problema al sitio equivocado.
+      if (e?.code === 'not-yours') throw new VaultError(CODES.NOT_ALLOWED, 'esta punta no tiene llave para esa entrada')
+      throw e
+    }
+    return openSealedEntry({ got, openSealed: this.openSealed })
+  }
+
+  /**
+   * GUARDAR. Se cierra aquí y sale cerrado: la entrada se cifra, su llave se envuelve a
+   * los destinatarios que diga el acta AHORA y el conjunto va firmado.
+   *
+   * Los destinatarios se piden en cada escritura y no se cachean: un aparato que acaba de
+   * entrar tiene que poder leer lo siguiente que se guarde.
+   */
+  async put (entry) {
+    const sobre = await buildSealedEntry({
+      plain: entry,
+      keys: await this.keys(),
+      recipients: await this.recipients(),
+      author: this.author
+    })
+    await this.sealed.putSealed(sobre)
+    // La VISTA, como devuelve `LocalVault.put`: quien llama enseña el nombre de lo que
+    // acaba de guardar. Devolver solo el id dejaba un «Guardada: undefined» en la CLI.
+    return { id: sobre.entry.id, title: entry.title || '', sites: entry.sites || [] }
+  }
+
+  /**
+   * Cambiar unos campos. Se hace leyendo y volviendo a escribir porque aquí quien lee y
+   * quien escribe son el mismo: no hay nada que ahorrar ocultándose un valor a sí mismo.
+   * (En remoto SÍ lo hay, y por eso allí existe `patchSealed`.)
+   *
+   * La fusión la hace `mergePatch`, la MISMA que `LocalVault` — y tiene que ser la misma,
+   * porque no es un `{...a, ...b}`: un campo sin `value` dice «déjale el que tenga», no
+   * «bórralo». Marcar uno como privado llega así, y fusionarlo a lo bruto le borraba el
+   * valor. Costó encontrarlo porque no falla: guarda, y el campo ya no está.
+   */
+  async patch (id, changes = {}) {
+    return this.put(mergePatch(await this.get(id), changes))
+  }
+
+  async remove (id) { return this.sealed.remove(id) }
+
+  /** La huella de un sitio, por si quien llama quiere preguntar por ella directamente. */
+  async siteIndexOf (site) {
+    const { kidx } = await this.keys()
+    return siteIndex(kidx, site)
+  }
+}
+
+export default { SealedLocalVault }

package/vault/vendor/passmanager/vault/sealed-responder.js

@@ -0,0 +1,159 @@
+// EL LADO QUE RESPONDE, con el formato sellado.
+//
+// Hace lo mismo que `VaultResponder` —es donde vive la política: quién puede pedir, qué
+// exige un dedo encima y qué queda anotado— con una diferencia que lo cambia todo: **esta
+// bóveda no puede abrir nada**. Así que lo que entrega son sobres, y lo que comprueba es lo
+// que se puede comprobar sin ninguna llave.
+//
+// Va aparte del responder de siempre y no dentro de él porque el protocolo es OTRO
+// (`pm2.*`, ver `../transport/protocol.js`): mezclarlos daría una clase con dos modos, que
+// es como se acaba sirviendo el formato viejo «mientras tanto» — o sea, el agujero otra vez.
+
+import { isRequest, reply, replyError, SEALED_OPS } from '../transport/protocol.js'
+import { ApprovalGate } from './approval.js'
+import { ALWAYS_PRIVATE } from '../fields.js'
+import { CODES } from './errors.js'
+import { PASSKEY_FIELD } from '../sealed/entry.js'
+
+/** Lo que es privado POR LO QUE ES, sin mirar ninguna marca. */
+const SIEMPRE_PRIVADO = new Set([...ALWAYS_PRIVATE.filter((k) => k !== 'webauthn'), PASSKEY_FIELD, 'wa.userHandle'])
+
+export class SealedResponder {
+  /**
+   * @param {object} opts
+   *   `client`    cliente de `@dotrino/proxy-client` conectado e identificado
+   *   `store`     una `SealedStore`
+   *   `recipients()` → `{ recoveryPub, main, passkeys }`, del acta
+   *   `isAllowed(pubkey)`  quién puede pedir (el acta: `passwords`). Por defecto NADIE.
+   *   `needsApproval(pubkey)`  si ese aparato tiene que pedir permiso (el acta:
+   *      `unattended`). Se compone con el criterio de abajo: **solo lo privado pregunta**.
+   *   `approve({ op, payload, pubkey })`  pide el visto bueno y espera
+   *   `encPubOf(pubkey)`  para sellarle la respuesta
+   *   `onRequest(record)` la bitácora
+   */
+  constructor ({ client, store, recipients, isAllowed, needsApproval, approve, encPubOf, onRequest } = {}) {
+    this.client = client
+    this.store = store
+    this.recipients = recipients || (async () => ({ recoveryPub: null, main: [], passkeys: [] }))
+    this.isAllowed = isAllowed || (() => false)
+    this.encPubOf = encPubOf || (() => null)
+    this.needsApproval = needsApproval || (async () => true)
+    this.approve = approve || (async () => false)
+    this.onRequest = onRequest || (() => {})
+    this._handler = null
+    this.gate = new ApprovalGate({
+      ask: ({ op, payload, pubkey }) => this.approve({ op, payload, pubkey }),
+      scope: ({ pubkey }) => pubkey
+    })
+  }
+
+  revokeApproval (pubkey) { this.gate.revoke(pubkey || null) }
+  isApproved (pubkey) { return this.gate.granted(pubkey) }
+
+  /**
+   * ¿LO QUE SE PIDE ES PRIVADO? Aquí se contesta SIN abrir nada, y por eso hace falta la
+   * lista en claro de la entrada (`priv`): la bóveda no ve la vista.
+   *
+   * Sin `keys` se pide la entrada entera, y eso siempre es privado: pedir todo es pedir la
+   * contraseña.
+   */
+  async wantsPrivate (op, payload) {
+    if (op !== 'pm2.get') return false
+    const keys = payload?.keys
+    if (!Array.isArray(keys)) return true
+    const priv = new Set(await this.store.privateKeysOf(payload?.id))
+    return keys.some((k) => SIEMPRE_PRIVADO.has(k) || priv.has(k))
+  }
+
+  start () {
+    if (this._handler) return
+    this._handler = async (from, msg, meta) => {
+      const p = typeof msg === 'string' ? (() => { try { return JSON.parse(msg) } catch (_) { return null } })() : msg
+      if (!isRequest(p)) return
+      // QUIÉN PREGUNTA lo dice el proxio (`fromPubkey`: la llave con la que se identificó esa
+      // conexión) o un saludo previo (`pubkeyOfToken`). Aquí se leía `meta.pubkey`, que no
+      // existe, y se caía al token: ninguna bóveda sabía a quién sellarle la respuesta, no
+      // contestaba, y del otro lado se veía «nadie respondió». Sin llave no hay a quién
+      // contestar sellado, así que no se contesta — el token no es una llave.
+      const pubkey = meta?.fromPubkey || this.client?.pubkeyOfToken?.(from) || null
+      if (!pubkey) { this.onRequest({ op: p.op, outcome: 'anonymous', from: null }); return }
+      await this.handle({ from, pubkey, msg: p, sealed: meta?.sealed === true })
+    }
+    this.client.on('message', this._handler)
+  }
+
+  stop () {
+    if (!this._handler) return
+    this.client.off?.('message', this._handler)
+    this._handler = null
+  }
+
+  /** Contesta UNA petición. Público para que las pruebas no tengan que fingir un socket. */
+  async handle ({ from, pubkey, msg, sealed = true }) {
+    const { rid, op, payload } = msg
+    const anota = (outcome, extra = {}) => this.onRequest({ op, outcome, from: pubkey, ...extra })
+    // EL SELLADO DEL TRANSPORTE NO ES OPCIONAL (CONVENCIONES §4.1): lo que llega en claro
+    // no se atiende, porque contestarlo sería mandar sobres a quien no sabemos que es.
+    //
+    // Los códigos son los del responder de siempre (`responder.js`): «la política dice que
+    // no» es `denied` y «el humano dijo que no» es `not-approved`. Se arreglan distinto —uno
+    // dando permiso al aparato, el otro volviendo a pedir— y quien pide los distingue así.
+    if (!sealed) { anota('unsealed'); return this.#send(from, pubkey, replyError(rid, CODES.UNSEALED, 'unsealed request')) }
+    if (!SEALED_OPS.includes(op)) { anota('unknown-op'); return this.#send(from, pubkey, replyError(rid, CODES.DENIED, 'operation not allowed: ' + op)) }
+    if (!this.isAllowed(pubkey)) { anota('denied'); return this.#send(from, pubkey, replyError(rid, CODES.DENIED, 'this device cannot ask for passwords')) }
+
+    try {
+      if (await this.#needsApproval(op, payload, pubkey)) {
+        // `allow`, no `ask`: es el que RECUERDA el sí y junta las simultáneas. `ask` es la
+        // función cruda de preguntar, y usarla directamente hacía sonar el teléfono en cada
+        // petición — que es como se enseña a aprobar sin mirar.
+        const ok = await this.gate.allow({ op, payload, pubkey })
+        if (!ok) { anota('rejected'); return this.#send(from, pubkey, replyError(rid, CODES.NOT_APPROVED, 'not approved on the trusted device')) }
+      }
+      const result = await this.#run(op, payload, pubkey)
+      anota('ok')
+      return this.#send(from, pubkey, reply(rid, result))
+    } catch (e) {
+      anota('error', { code: e?.code })
+      return this.#send(from, pubkey, replyError(rid, e?.code || CODES.UNKNOWN, e?.message || 'error'))
+    }
+  }
+
+  async #needsApproval (op, payload, pubkey) {
+    return await this.needsApproval(pubkey) && await this.wantsPrivate(op, payload)
+  }
+
+  async #run (op, payload = {}, pubkey) {
+    switch (op) {
+      case 'pm2.recipients': return this.recipients()
+      case 'pm2.profile':
+        // Con `set` se estrena (al convertir); sin él, se pide la que hay.
+        if (payload.set) return this.store.setProfile(payload.set)
+        return this.store.profile({ pub: pubkey })
+      case 'pm2.views': return this.store.views({ pub: pubkey })
+      case 'pm2.find': return this.store.find({ pub: pubkey, idx: payload.idx || [] })
+      case 'pm2.passkey': return this.store.findPasskey({ pub: pubkey, rp: payload.rp, cred: payload.cred })
+      case 'pm2.get': return this.store.get(payload.id, { pub: pubkey, keys: payload.keys })
+      case 'pm2.put': return this.store.putSealed({ ...payload, by: pubkey })
+      case 'pm2.patch': return this.store.patchSealed({ ...payload, by: pubkey })
+      case 'pm2.remove': return this.store.remove(payload.id)
+      default: throw Object.assign(new Error('operation not allowed: ' + op), { code: CODES.DENIED })
+    }
+  }
+
+  /** `to` es por dónde se contesta (el token); `pubkey`, a quién se le sella. */
+  #send (to, pubkey, msg) {
+    const encPub = this.encPubOf(pubkey)
+    // La respuesta va SELLADA: el proxio enruta pero no cifra. Si no se puede sellar, no se
+    // manda — mandarlo en claro sería entregar los sobres y las envolturas a quien mire.
+    if (encPub && typeof this.client.sendSealedTo === 'function') {
+      return this.client.sendSealedTo(to, msg, { peerEncPub: encPub })
+    }
+    if (typeof this.client.sendSealed === 'function' && encPub) {
+      return this.client.sendSealed([to], msg, { peerEncPub: encPub })
+    }
+    throw Object.assign(new Error('cannot seal the reply to that device: it has no encryption key in the record'), { code: 'no-encpub' })
+  }
+}
+
+export default SealedResponder