@dotrino/identity 0.29.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -299,6 +299,11 @@ export class Identity {
 
   /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
   async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
+   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
+  async profileCard () { return this._call('profileCard') }
+  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
+  async adoptPeerCard (card) { return this._call('adoptPeerCard', { card }) }
   /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
   async contentKey () { return this._call('contentKey') }
   /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */

package/src/node.js

@@ -173,6 +173,11 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
+   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
+  profileCard () { return this._h('profileCard') }
+  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
+  adoptPeerCard (card) { return this._h('adoptPeerCard', { card }) }
   /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
   contentKey () { return this._h('contentKey') }
   /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */

package/vault/acta.js

@@ -32,10 +32,37 @@ import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
 export const ACTA_V = 1
 
-/** Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master. */
-export const CAPS = Object.freeze(['sign', 'store', 'read'])
+/**
+ * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
+ *
+ * `secrets` es distinta de las otras tres: solo la pueden tener los miembros con **CN**
+ * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
+ */
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets'])
+
+/** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read'])
+
+/** Capacidades de un SERVICIO (con CN): solo su propio cajón de secretos. */
+export const SERVICE_CAPS = Object.freeze(['secrets'])
+
+/** Un CN válido: minúsculas, números y guiones (igual que el namespace de secretos). */
+export const isValidCn = (cn) => typeof cn === 'string' && /^[a-z0-9-]{1,32}$/.test(cn)
+
+/**
+ * Scope del cert que corresponde a cada capacidad. `secrets` necesita el CN para
+ * completarse: el miembro `proxy` obtiene `vault:secrets:proxy` y nada más — no existe un
+ * scope de secretos «de todos».
+ */
+export function capScope (cap, cn = null) {
+  if (cap === 'sign') return 'vault:sign'
+  if (cap === 'store') return 'vault:store'
+  if (cap === 'read') return 'vault:read'
+  if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
+  return null
+}
 
-/** Cada capacidad es uno de los scopes que ya existen en los certs (sin scopes nuevos). */
+/** Compat: el mapa directo, para las tres capacidades de dispositivo. */
 export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read' })
 
 const enc = (s) => new TextEncoder().encode(s)
@@ -43,9 +70,12 @@ const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart
 const isPub = (v) => typeof v === 'string' && v.length > 0
 const cleanCaps = (caps) => [...new Set((Array.isArray(caps) ? caps : []).filter((c) => CAPS.includes(c)))].sort()
 
-/** El acta SIN la firma: es lo que se sella y sobre lo que se calcula el hash. */
+/**
+ * El acta SIN la firma ni la tarjeta: es lo que se sella y sobre lo que se calcula el hash.
+ * La `card` va aparte porque lleva su propia firma y se comparte sola (ver `makeProfileCard`).
+ */
 export function actaBody (acta) {
-  const { sig, ...body } = acta || {}
+  const { sig, card, ...body } = acta || {}
   return body
 }
 
@@ -77,7 +107,7 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), caps: [...CAPS], addedAt: now, cert: null }],
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...DEVICE_CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -98,6 +128,15 @@ export function checkShape (acta) {
   for (const m of acta.members) {
     if (!isPub(m?.pub) || !Array.isArray(m?.caps)) return 'member'
     if (m.caps.some((c) => !CAPS.includes(c))) return 'cap-desconocida'
+    // El CN es la frontera: un SERVICIO solo puede abrir su propio cajón, y un
+    // DISPOSITIVO no tiene cajón que abrir. Que no se pueda escribir un acta que
+    // mezcle las dos cosas es lo que hace que el límite sea real y no una costumbre.
+    if (m.cn != null) {
+      if (!isValidCn(m.cn)) return 'cn-invalido'
+      if (m.caps.some((c) => !SERVICE_CAPS.includes(c))) return 'servicio-con-capacidades-de-dispositivo'
+    } else if (m.caps.includes('secrets')) {
+      return 'secretos-sin-cn'
+    }
   }
   if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
   if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
@@ -110,7 +149,11 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
   const shape = checkShape(acta)
   if (shape) throw new Error('acta inválida: ' + shape)
   const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
-  return { ...acta, sig: signature }
+  const sealed = { ...acta, sig: signature }
+  // La TARJETA se firma en el mismo gesto y viaja con el acta: así cualquier miembro puede
+  // entregársela a un contacto sin ser el master y sin contarle nada de más.
+  sealed.card = await makeProfileCard({ acta: sealed, privateKey, privateJwk })
+  return sealed
 }
 
 /**
@@ -166,11 +209,15 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         const m = ch.member
         if (!isPub(m?.pub)) throw new Error('admit: falta la pubkey del miembro')
         if (find(m.pub)) throw new Error('admit: ese miembro ya está en el acta')
+        const cn = m.cn != null ? String(m.cn) : null
+        if (cn !== null && !isValidCn(cn)) throw new Error('admit: CN inválido (minúsculas, números y guiones)')
         next.members.push({
           pub: m.pub,
           encPub: m.encPub || null,
           label: String(m.label || '').slice(0, 60),
-          caps: cleanCaps(m.caps),
+          cn,
+          // Un servicio (con CN) solo puede tener `secrets`; un dispositivo, las otras tres.
+          caps: cleanCaps(m.caps).filter((c) => (cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c)),
           addedAt: now,
           cert: m.cert || null,
           // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
@@ -181,7 +228,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       case 'caps': {
         const m = find(ch.pub)
         if (!m) throw new Error('caps: ese miembro no está en el acta')
-        m.caps = cleanCaps(ch.caps)
+        // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
+        // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
+        m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
         break
       }
       case 'remove': {
@@ -284,11 +333,98 @@ export function effectiveCaps (acta, pub, extraRenounces = []) {
   return m.caps.filter((c) => !quitadas.has(c))
 }
 
+/**
+ * ¿Puede este miembro leer el cajón de secretos `ns`? Solo si su CN es exactamente ése.
+ * Es la frontera que pediste: la llave del proxy no ve nada más que lo del proxy.
+ */
+export function memberCanReadSecrets (acta, pub, ns) {
+  const m = (acta?.members || []).find((x) => x.pub === pub)
+  if (!m || !m.cn) return false
+  return m.cn === ns && effectiveCaps(acta, pub).includes('secrets')
+}
+
+/** Los scopes de cert que le corresponden a un miembro según el acta. */
+export function memberScopes (acta, pub, extraRenounces = []) {
+  const m = (acta?.members || []).find((x) => x.pub === pub)
+  if (!m) return []
+  return effectiveCaps(acta, pub, extraRenounces).map((c) => capScope(c, m.cn)).filter(Boolean)
+}
+
+/** ¿Es un servicio (tiene CN) o un dispositivo del usuario? */
+export const isService = (acta, pub) => !!(acta?.members || []).find((x) => x.pub === pub)?.cn
+
 /** ¿Puede este miembro hacer `cap` según el acta? (con el cert se cruza aparte: cert ∩ acta). */
 export function memberCan (acta, pub, cap, extraRenounces = []) {
   return effectiveCaps(acta, pub, extraRenounces).includes(cap)
 }
 
+// ----- TARJETA DE PERFIL: lo mínimo que se comparte con otra persona -----
+
+/**
+ * Para escribirle a alguien cifrado hay que conocer las llaves de CIFRADO de todos sus
+ * dispositivos — si no, el mensaje solo lo abre el aparato desde el que hablaste. Pero
+ * pasarle el ACTA a un contacto le contaría de más: cuántos dispositivos tienes, cómo se
+ * llaman y qué puede cada uno. Nada de eso es asunto suyo.
+ *
+ * Así que se comparte una TARJETA: el mínimo imprescindible —el perfil, su versión y las
+ * llaves— firmada por el master, y por lo tanto verificable sin tener el acta. Sin
+ * etiquetas, sin permisos, sin certificados.
+ *
+ * La firma el MASTER al sellar, y viaja con el acta, para que cualquier miembro pueda
+ * entregarla aunque no sea él quien manda.
+ */
+export function cardBody (acta) {
+  return {
+    v: 1,
+    profileId: acta.profileId,
+    seq: acta.seq,
+    sealedBy: acta.sealedBy,
+    // Solo las llaves. Los servicios (con CN) NO van: no son la persona, y no tienen por
+    // qué recibir los mensajes de nadie.
+    keys: acta.members
+      .filter((m) => !m.cn && m.encPub)
+      .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+      .sort((a, b) => (a.pub < b.pub ? -1 : 1)),
+    iat: acta.updatedAt
+  }
+}
+
+/** Firma la tarjeta de este acta (lo hace el master al sellar). */
+export async function makeProfileCard ({ acta, privateKey, privateJwk }) {
+  const body = cardBody(acta)
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: body })
+  return { ...body, sig: signature }
+}
+
+/** Verifica que la tarjeta la firmó quien dice (`sealedBy`). Que ÉSE sea el master de esa
+ * persona se decide al adoptarla, comparándola con la que ya tenías (`canAdoptCard`). */
+export async function verifyProfileCard (card) {
+  if (!card || card.v !== 1 || !isPub(card.profileId) || !isPub(card.sealedBy)) return false
+  if (!Number.isInteger(card.seq) || !Array.isArray(card.keys) || typeof card.sig !== 'string') return false
+  const { sig, ...body } = card
+  return verifyDeviceSig({ publickey: card.sealedBy, data: body, signature: sig })
+}
+
+/**
+ * ¿Me quedo con esta tarjeta en vez de la que tenía de esa persona?
+ *   · la primera vez, sí (confías en el contacto que agregaste: es el mismo criterio
+ *     que ya usas al añadirlo);
+ *   · después, solo si el `seq` es mayor o igual Y la firmó el mismo master que la
+ *     anterior — así nadie te cuela dispositivos ajenos en el perfil de tu contacto,
+ *     y nunca se retrocede a una versión vieja.
+ * Si el master cambió legítimamente (traspaso), la tarjeta nueva la firma el entrante y
+ * hay que re-confirmarla: se devuelve `master-cambiado` para que la app lo diga en vez de
+ * aceptarlo en silencio.
+ */
+export async function canAdoptCard ({ card, current }) {
+  if (!(await verifyProfileCard(card))) return { adopt: false, reason: 'firma-invalida' }
+  if (current && current.profileId !== card.profileId) return { adopt: false, reason: 'otro-perfil' }
+  if (!current) return { adopt: true, reason: 'primera-vez' }
+  if (card.seq < current.seq) return { adopt: false, reason: 'seq-menor' }
+  if (card.sealedBy !== current.sealedBy) return { adopt: false, reason: 'master-cambiado' }
+  return { adopt: true, reason: card.seq > current.seq ? 'seq-mayor' : 'igual' }
+}
+
 // ----- continuidad: unir una identidad que ya existía -----
 
 /**
@@ -362,5 +498,6 @@ export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
-  effectiveCaps, memberCan, canAdopt
+  cardBody, makeProfileCard, verifyProfileCard, canAdoptCard,
+  effectiveCaps, memberCan, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
 }

package/vault/core.js

@@ -21,6 +21,7 @@
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
 import * as Acta from './acta.js'
 import * as Content from './content.js'
+import { pubkeyId as pubkeyIdOf } from './capabilities.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -319,6 +320,9 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     if (e && /\brevoked\b/.test(e.message || '')) emitVault({ phase: 'rejected', reason: e.message })
     throw e
   }
+  /** Id estable y corto de una llave de cifrado: con esto se indexan las envolturas. */
+  const encKeyId = async (encPub) => (await pubkeyIdOf(encPub)).slice(0, 16)
+
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
   const loadVaultDevice = () => {
     try {
@@ -1071,6 +1075,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         pub: m.pub,
         id: await Acta.memberId(m.pub),
         label: m.label || '',
+        cn: m.cn || null,
+        isService: !!m.cn,
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
         isMe: m.pub === publickeyJwkStr,
@@ -1099,8 +1105,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * Admite un miembro (solo el master). El cert lo emite quien llama, antes o después.
      * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
      */
-    async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null, continuity = null } = {}) {
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert, continuity } }])
+    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null } = {}) {
+      // `cn`: si viene, este miembro es un SERVICIO y su único permiso es abrir el cajón de
+      // secretos de ESE nombre — no ve nada más del usuario. Sin `cn` es un dispositivo.
+      const finales = caps || (cn ? ['secrets'] : ['store', 'read'])
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }])
       // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
       // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
       let wrapped = false
@@ -1203,6 +1212,28 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { chain: all.sort((a, b) => a.seq - b.seq), window: ACTA_WINDOW }
     },
 
+    /**
+     * MI tarjeta de perfil: lo mínimo que se le pasa a un contacto para que pueda cifrarme a
+     * todos mis dispositivos (perfil, versión y llaves de cifrado). Sin etiquetas, sin
+     * permisos, sin certificados: lo demás no es asunto de nadie.
+     */
+    async profileCard () { return loadActa()?.card || null },
+
+    /**
+     * Guarda la tarjeta de OTRA persona en su ficha de contacto. La primera vez se acepta
+     * (es el mismo criterio con el que agregaste el contacto); después solo si no retrocede
+     * y la firmó el mismo master. Si el master cambió, se avisa en vez de aceptarlo callando.
+     */
+    async adoptPeerCard ({ card } = {}) {
+      if (!card?.profileId) throw new Error('tarjeta inválida')
+      const peers = loadPeers()
+      const prev = peers[card.profileId]?.card || null
+      const r = await Acta.canAdoptCard({ card, current: prev })
+      if (!r.adopt) return { adopted: false, reason: r.reason, devices: (prev?.keys || []).length }
+      upsertPeer(card.profileId, { card, profileId: card.profileId })
+      return { adopted: true, reason: r.reason, devices: card.keys.length }
+    },
+
     /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
     async adoptActa ({ acta } = {}) { return adoptActa(acta) },
 
@@ -1356,6 +1387,15 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async getEncryptionPubkey () { return encPublickeyJwkStr },
 
+    /**
+     * Cifra para uno o varios destinatarios. Dos cosas que cambian respecto de antes:
+     *
+     * 1. **El sobre va atado a la LLAVE, no a la conexión.** Cada envoltura se indexa por un
+     *    id derivado de la llave de cifrado del destinatario, en vez del token del proxy: así
+     *    puede abrirla también un dispositivo que no estaba conectado cuando se envió.
+     * 2. **Se cifra a TODOS los dispositivos de esa persona**, si conocemos su tarjeta de
+     *    perfil (§tarjeta). Le escribes a la persona, no al aparato desde el que te habló.
+     */
     async encrypt ({ recipients, plaintext }) {
       if (!Array.isArray(recipients) || recipients.length === 0) throw new Error('recipients required')
       if (typeof plaintext !== 'string') throw new Error('plaintext required')
@@ -1363,26 +1403,40 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const kRaw = await crypto.subtle.exportKey('raw', k)
       const iv = crypto.getRandomValues(new Uint8Array(12))
       const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, k, new TextEncoder().encode(plaintext))
-      const wrap = {}
+
+      // Expandir cada destinatario a TODOS los dispositivos de su perfil que conozcamos.
+      const encPubs = new Set()
+      const peers = loadPeers()
       for (const r of recipients) {
-        if (!r || !r.token || !r.encryptionPubkey) continue
+        if (!r) continue
+        if (r.encryptionPubkey) encPubs.add(r.encryptionPubkey)
+        const card = (r.publickey && peers[r.publickey]?.card) || null
+        for (const kk of (card?.keys || [])) if (kk.encPub) encPubs.add(kk.encPub)
+      }
+
+      const wrap = {}
+      for (const encPub of encPubs) {
         try {
-          const peerPub = await importPeerEncPubkey(r.encryptionPubkey)
+          const peerPub = await importPeerEncPubkey(encPub)
           const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, peerPub)
           const wrapIv = crypto.getRandomValues(new Uint8Array(12))
           const wrappedCt = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: wrapIv }, sharedKey, kRaw)
-          wrap[r.token] = { iv: bufToBase64(wrapIv), ct: bufToBase64(new Uint8Array(wrappedCt)) }
+          wrap[await encKeyId(encPub)] = { iv: bufToBase64(wrapIv), ct: bufToBase64(new Uint8Array(wrappedCt)) }
         } catch (e) { /* destinatario omitido */ }
       }
-      return { v: 1, iv: bufToBase64(iv), ct: bufToBase64(new Uint8Array(ct)), wrap }
+      return { v: 2, iv: bufToBase64(iv), ct: bufToBase64(new Uint8Array(ct)), wrap }
     },
 
+    /**
+     * Descifra. Busca MI envoltura por el id de mi llave de cifrado (v2); `myToken` ya no
+     * hace falta y se acepta solo por compatibilidad de llamada.
+     */
     async decrypt ({ senderEncryptionPubkey, myToken, envelope }) {
       if (!senderEncryptionPubkey) throw new Error('senderEncryptionPubkey required')
-      if (!myToken) throw new Error('myToken required')
-      if (!envelope || envelope.v !== 1) throw new Error('Unsupported envelope')
-      const myEntry = envelope.wrap && envelope.wrap[myToken]
-      if (!myEntry) throw new Error('No wrap entry for this recipient')
+      if (!envelope || (envelope.v !== 1 && envelope.v !== 2)) throw new Error('Unsupported envelope')
+      const myId = await encKeyId(encPublickeyJwkStr)
+      const myEntry = envelope.wrap && (envelope.wrap[myId] || (myToken ? envelope.wrap[myToken] : null))
+      if (!myEntry) throw new Error('este dispositivo no está entre los destinatarios del mensaje')
       const senderPub = await importPeerEncPubkey(senderEncryptionPubkey)
       const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, senderPub)
       const kRaw = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: base64ToBuf(myEntry.iv) }, sharedKey, base64ToBuf(myEntry.ct))

package/vault/vendor/vault/enroll.js

@@ -50,6 +50,19 @@ const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 
+/**
+ * El CN de un servicio sale de su scope: `vault:secrets:proxy` ⇒ CN `proxy`. Con CN, el
+ * miembro entra al acta como SERVICIO —solo abre su propio cajón— en vez de como un
+ * dispositivo del usuario. Es la frontera, y vive en el acta para que se pueda comprobar.
+ */
+export function scopeToCn (scope) {
+  for (const s of (Array.isArray(scope) ? scope : [scope])) {
+    const m = /^vault:secrets:([a-z0-9-]{1,32})$/.exec(String(s || ''))
+    if (m) return m[1]
+  }
+  return null
+}
+
 /** Token aleatorio de 128 bits en hex. */
 export function randToken () {
   const b = crypto.getRandomValues(new Uint8Array(16))
@@ -215,8 +228,9 @@ export function createEnrollDesk ({
     let acta = null
     try {
       if (typeof identity.admitMember === 'function') {
-        const caps = scopeToCaps(pend.scope)
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
+        const cn = scopeToCn(pend.scope)
+        const caps = cn ? ['secrets'] : scopeToCaps(pend.scope)
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
       }
       acta = (await identity.profileActa?.())?.acta || null
     } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }