@dotrino/vault 0.78.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/admin.js

@@ -47,6 +47,9 @@ export const ADMIN_OPS = Object.freeze([
   // `pending`, `pair`, `approve` y `reject` NO están, y no es un olvido: agregar aparatos
   // a distancia se quitó (ver la cabecera). Lo que queda es mirar, quitar y configurar.
   'revoke', 'audit',
+  // Los BLOQUEADOS por un aprobador (`src/blocked.js`): verlos y desbloquearlos. Bloquear a
+  // distancia también, por si el administrador llega antes que el teléfono. No toca el acta.
+  'blocked', 'block', 'unblock',
   // Variables de entorno: verlas (nombres siempre; valor solo de las públicas) y
   // ponerles valor (de las dos). Borrar NO está, y es a propósito: un aparato robado
   // no debe poder dejar sin configuración a los servicios.
@@ -96,6 +99,8 @@ export const ADMIN_OPS = Object.freeze([
  */
 export const ADMIN_OPS_WHILE_LOCKED = Object.freeze([
   'audit', 'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // Bloquear no sella nada: la lista es de la bóveda, no del acta.
+  'blocked', 'block', 'unblock',
   // Las dos de abrir, obviamente: son las únicas que solo tienen sentido con el candado
   // echado. Que estén aquí NO las deja pasar sin más — siguen exigiendo cert, acta, nonce
   // y frescura como todas, y además la contraseña dentro del sobre.
@@ -147,6 +152,8 @@ export function createAdminDesk ({
   // este módulo es puro a propósito. `null` en una bóveda que no lo soporte: entonces la
   // operación existe y contesta que no, en vez de romper con un TypeError.
   unlockDesk = null,
+  // La lista de bloqueados, inyectada como `vars`: `{ list(), set(pub, on, { by }) }`.
+  blocked = null,
   now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
@@ -333,6 +340,14 @@ export function createAdminDesk ({
       // usarlo para quitar dejaba un miembro sin certificados al que la bóveda ya nunca le
       // mandaba el aviso de expulsión (mientras siga en el acta, un papel retirado
       // significa «renueva»). Ese era el dispositivo fantasma.
+      if (data.op === 'blocked' || data.op === 'block' || data.op === 'unblock') {
+        if (!blocked) return { ok: false, error: 'admin: this vault cannot block devices' }
+        if (data.op === 'blocked') return { ok: true, result: { items: blocked.list() } }
+        if (typeof data.sub !== 'string' || !data.sub) return { ok: false, error: `admin: ${data.op} needs the device key (sub)` }
+        const r = await blocked.set(data.sub, data.op === 'block', { by })
+        audit(`admin.${data.op}`, { by, device: await deviceIdOf(data.sub).catch(() => null) })
+        return { ok: true, result: { ok: true, was: r } }
+      }
       if (data.op === 'revoke') {
         if (data.sub) {
           const deviceId = await deviceIdOf(String(data.sub)).catch(() => null)

package/src/protocol.js

@@ -65,7 +65,7 @@ export const MSG = Object.freeze({
   //     empieza con el heap limpio.
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
-  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, seal, acta }
   // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
   // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
   // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
@@ -74,7 +74,7 @@ export const MSG = Object.freeze({
   // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
   // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
   // llave para alguien que la maestra no haya metido en su propio cajón.
-  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, seal }
   REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
@@ -85,7 +85,7 @@ export const MSG = Object.freeze({
   // Aviso a TODOS los miembros de que el perfil cambió (alguien entró o salió). Es la
   // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
   // invisible para el resto de tus dispositivos.
-  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, acta } (pedidos: + seal)
   // RÉPLICAS: la principal empuja lo que hay que servir (el acta y los sobres, que van
   // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
   REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }
@@ -103,6 +103,13 @@ export const MSG = Object.freeze({
   // una forma de echar a alguien de su cuenta.
   LOGIN_CLOSE: 'vault.login.close',           // aparato → vault: { data:{op,user,sid,publickey,ts}, signature }
   LOGIN_CLOSED: 'vault.login.closed',         // vault → aparato: { ok }
+  // INCIDENTE: un agente de la cuenta (la terminal) avisa de que OTRO aparato de la cuenta
+  // se equivocó de clave tres veces seguidas. La bóveda lo apunta como un pedido más
+  // (`kind: 'incident'`), timbra a quien aprueba, y el aprobador bloquea o ignora. Bloquear
+  // no toca el acta: es una lista de la bóveda (`blocked.json`) que viaja a los agentes con
+  // `vault.devices.result` (`blocked`) y se deshace con `dotrino-vault unblock <ID>`.
+  INCIDENT: 'vault.incident',                 // agente → vault: { data:{op:'incident',kind,about,tries,publickey,ts}, signature, cert }
+  INCIDENT_RESULT: 'vault.incident.result',   // vault → agente: { id, approvers, blocked }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })
 

package/src/service.js

@@ -1137,8 +1137,9 @@ export async function watchSecretsChanges ({
    * NO SE FÍA DE LO QUE LE MANDAN, y esto es lo que hace que sea seguro incluso si la
    * bóveda estuviera comprometida:
    *
-   *  · la petición va firmada por la MAESTRA;
-   *  · el acta viaja dentro y se comprueba aparte (también la firma la maestra);
+   *  · la petición la firma la llave de SELLADO que nombra el acta (`verifyResponder`), no la
+   *    maestra: esto tiene que funcionar con la bóveda cerrada;
+   *  · el acta viaja dentro y la selló la maestra que este agente conoce;
    *  · **la llave pública del destinatario se saca del ACTA, nunca del mensaje** — si
    *    se cogiera del mensaje, quien lo mandara podría hacer que este agente envolviera
    *    la llave para una pública suya;
@@ -1150,9 +1151,9 @@ export async function watchSecretsChanges ({
     if (!body || body.op !== 'rewrap') return
     const mineOwners = [`ns:${ns}`, `dev:${saved.device.publickey}`]
     if (!mineOwners.includes(body.owner)) return log('[vault] rewrap for a drawer that is not mine: ignored')
-    if (!(await verifyDeviceSig({ publickey: master, data: body, signature: payload.signature }))) {
-      return log('[vault] rewrap request BADLY SIGNED: ignored')
-    }
+    try {
+      await verifyResponder({ body, seal: payload.seal, acta: body.acta, masterPubkey: master, knownSeq: readServiceIdentity(dir)?.actaSeq ?? null })
+    } catch (e) { return log(`[vault] rewrap request BADLY SIGNED: ignored (${e.message})`) }
     const acta = body.acta
     if (!acta || acta.sealedBy !== master || !(await verifyActa({ acta })).ok) {
       return log('[vault] rewrap request without a valid record: ignored')
@@ -1192,11 +1193,15 @@ export async function watchSecretsChanges ({
     // que un aviso falso con fecha lejana no pueda dejar fuera a los de verdad.
     if (inFlight.has(body.ts)) return
     inFlight.add(body.ts)
-    let valid = false
+    // FIRMADO COMO TODO LO QUE SIRVE LA BÓVEDA: la llave de sellado que nombra el acta, con
+    // el acta al lado. Lo firmaba la maestra, y la bóveda vive CERRADA: el aviso reventaba
+    // con «vault locked» antes de salir y el servicio no se enteraba de ningún cambio
+    // (la maestra solo firma el acta y reenvuelve sobres, CLAUDE.md).
+    let bad = null
     try {
-      valid = await verifyDeviceSig({ publickey: master, data: body, signature: payload.signature })
-    } finally { inFlight.delete(body.ts) }
-    if (!valid) return log('[vault] change notice BADLY SIGNED: ignored (not from your vault)')
+      await verifyResponder({ body, seal: payload.seal, acta: payload.acta, masterPubkey: master, knownSeq: readServiceIdentity(dir)?.actaSeq ?? null })
+    } catch (e) { bad = e } finally { inFlight.delete(body.ts) }
+    if (bad) return log(`[vault] change notice BADLY SIGNED: ignored (${bad.message})`)
     if (body.ts <= lastTs) return
     lastTs = body.ts