@dotrino/identity 0.82.0 → 0.83.1

package/README.md

@@ -109,6 +109,43 @@ Mismo registro de `peers` que arriba, pero filtrado por flag `isContact: true`.
 
 - `id.signData(data)` → `{ signature, publickey }` con encoding canonical-JSON. Lo usa el messenger para construir sobres `identify` que el proxy verifica con su `verifySignatureWithJWK`.
 
+### Prueba con destinatario (0.83.0+)
+
+`signData` dice «esto lo firmé yo», y no dice para quién. Eso significaba que **un sobre
+firmado para el proxio valía ante geo**: los dos comprueban la misma firma de la misma
+identidad y ninguno tenía con qué notar que no le hablaban a él. La ventana de repetición
+evita que el mismo sobre se reenvíe dos veces al mismo sitio; el cruce de destinatario es
+otra cosa.
+
+Una *assertion* es una firma normal del perfil sobre un cuerpo que además dice `aud` (para
+quién), `nonce` (para qué petición) e `iat`/`exp` (desde y hasta cuándo).
+
+```js
+// quien PIDE genera el reto y dice quién es él
+const nonce = newAssertionNonce()
+const prueba = await id.requestAssertion({ audience: 'https://proxy.dotrino.com', nonce })
+
+// quien RECIBE comprueba las dos cosas que él sabe y la prueba no puede inventar
+import { verifyAssertion } from '@dotrino/identity/assertion'
+const v = await verifyAssertion(prueba, { audience: 'https://proxy.dotrino.com', nonce })
+// { ok, profileId, signer, seq, scopes, claims, aud, exp }  ·  o { ok:false, reason }
+```
+
+- **`audience` y `nonce` son obligatorios en las dos puntas.** Sin ellos no hay nada que
+  comparar, así que `verifyAssertion` responde `no-audience` / `no-nonce` en vez de dar por
+  buena una prueba que no ha podido juzgar. **No hay modo permisivo.**
+- **Vigencia corta** (2 min por defecto, tope 5). El tope lo comprueba también quien
+  recibe: fiarse del `exp` que puso el otro es fiarse de su buena fe.
+- **Alcances**, lista cerrada: `id:whoami` (el mínimo, solo quién eres), `profile:name`,
+  `profile:avatar`, `profile:email`, `profile:social`. Un dato sin su alcance no se emite
+  ni se acepta. Hoy solo viaja lo que el perfil ya comparte; la pantalla de permiso para
+  conceder algo oculto a un destinatario concreto es la fase siguiente.
+- **Verificar no necesita el iframe ni clave alguna**: `@dotrino/identity/assertion` es un
+  módulo puro y lo puede importar un servidor.
+
+Diseño y hacia dónde va (inicio de sesión y federación):
+[`dotrino-vault/docs/inicio-de-sesion.md`](../dotrino-vault/docs/inicio-de-sesion.md).
+
 ### Backup / migración
 
 - `id.exportIdentity()` → blob JSON con `privateJwk` (ECDSA), `encPrivateJwk` (ECDH), `me`, `peers`. **Sensible** — el host app es responsable de guardarlo de manera segura.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.82.0",
+  "version": "0.83.1",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -28,6 +28,9 @@
     "./content": {
       "import": "./vault/content.js"
     },
+    "./assertion": {
+      "import": "./vault/assertion.js"
+    },
     "./keyid": {
       "import": "./vault/keyid.js"
     }

package/src/index.d.ts

@@ -123,6 +123,7 @@ export class Identity {
   removeContact (publickey: string): Promise<PeerInfo | null>
   listContacts (): Promise<PeerInfo[]>
   signData (data: any): Promise<{ signature: string; publickey: string }>
+  requestAssertion (args: { audience: string; nonce: string; scopes?: AssertionScope[]; ttlMs?: number }): Promise<Assertion>
   setMyNickname (nickname: string): Promise<{ me: Me }>
   getEncryptionPubkey (): Promise<string>
   encrypt (recipients: EncryptRecipient[], plaintext: string): Promise<EnvelopeV1>
@@ -224,3 +225,48 @@ export function verifyDelegation (args: { cert: CapabilityCert; expectedScope?:
 /** Verifica la cadena de una acción/pin delegado: D firmó + cert prueba D←P + scope/exp/revocación. */
 export function verifyChain (args: { data: any; signature: string; cert: CapabilityCert; expectedScope?: string; trustedIssuer?: string; now?: number; revoked?: ((nonce: string) => boolean) | Set<string> | Record<string, any> }): Promise<{ ok: boolean; reason?: string; issuer?: string; device?: string }>
 
+// ----- Prueba firmada con destinatario y vigencia (`@dotrino/identity/assertion`) -----
+
+export type AssertionScope = 'id:whoami' | 'profile:name' | 'profile:avatar' | 'profile:email' | 'profile:social'
+
+export interface AssertionClaims { name?: string; avatar?: string; email?: string; links?: ProfileLink[] }
+
+export interface Assertion {
+  v: 1
+  op: 'assertion'
+  sub: string              // profileId: la identidad a la que se atribuye
+  aud: string              // PARA QUIÉN vale
+  nonce: string            // el reto de quien pide, de un solo uso
+  iat: number              // ms epoch
+  exp: number              // ms epoch (tope ASSERTION_MAX_TTL_MS desde iat)
+  scopes: AssertionScope[]
+  claims: AssertionClaims
+  signature: string        // firma del aparato firmante sobre el cuerpo canónico
+  publickey: string        // quién firmó (miembro del acta con `sign`)
+  chain: any[]             // cadena de actas que prueba que ese firmante es del perfil
+}
+
+export interface VerifiedAssertion {
+  ok: boolean
+  reason?: string
+  profileId?: string
+  signer?: string
+  seq?: number
+  scopes?: AssertionScope[]
+  claims?: AssertionClaims
+  aud?: string
+  exp?: number
+}
+
+export const ASSERTION_MAX_TTL_MS: number
+export const ASSERTION_DEFAULT_TTL_MS: number
+export const ASSERTION_MAX_SKEW_MS: number
+export const SCOPES: readonly AssertionScope[]
+export const SCOPE_CLAIMS: Readonly<Record<AssertionScope, readonly string[]>>
+/** Un reto de un solo uso, para quien pide la prueba. */
+export function newAssertionNonce (): string
+export function cleanScopes (scopes?: string[]): AssertionScope[]
+export function claimsAllowed (scopes?: string[]): Set<string>
+export function assertionBody (args: { sub: string; aud: string; nonce: string; scopes?: string[]; claims?: AssertionClaims; iat: number; exp: number }): Omit<Assertion, 'signature' | 'publickey' | 'chain'>
+/** ¿Vale esta prueba, PARA MÍ y AHORA? `audience` y `nonce` son obligatorios; sin modo permisivo. */
+export function verifyAssertion (assertion: Assertion, opts: { audience: string; nonce: string; expectedProfileId?: string | null; now?: number; maxSkewMs?: number }): Promise<VerifiedAssertion>

package/src/index.js

@@ -243,6 +243,24 @@ export class Identity {
     return this._call('signData', { data })
   }
 
+  /**
+   * Una prueba firmada PARA ALGUIEN EN CONCRETO y por un rato: `signData` dice «lo firmé
+   * yo», y esto dice además para quién, contestando a qué reto y hasta cuándo. Es lo que
+   * un servicio (o una aplicación ajena) tiene que pedir en vez de una firma suelta, que
+   * le sirve igual a otro servicio.
+   *
+   * `audience` es quien va a verificarla —su URL— y `nonce` lo pone él, de un solo uso.
+   * `scopes` es lo que se le deja ver, del catálogo cerrado de `@dotrino/identity/assertion`;
+   * `id:whoami` (solo quién eres) es el mínimo y el valor por defecto.
+   *
+   * @returns {Promise<object>} la prueba, lista para mandar. Se comprueba con
+   * `verifyAssertion(prueba, { audience, nonce })`.
+   */
+  async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+    const { assertion } = await this._call('requestAssertion', { audience, nonce, scopes, ttlMs })
+    return assertion
+  }
+
   /**
    * Firma un CERTIFICADO DE DELEGACIÓN: autoriza a una sub-clave de dispositivo
    * `sub` (JWK string) a hacer `scope` en tu nombre, hasta `exp`, revocable por
@@ -718,3 +736,8 @@ export class Identity {
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), reutilizables
 // por apps/bridges sin cargar el iframe del vault.
 export { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri } from '../vault/capabilities.js'
+
+// PARA QUIÉN vale una firma, y hasta cuándo. Verificar NO necesita el iframe ni la clave
+// de nadie, así que un servicio puede importarlo suelto (`@dotrino/identity/assertion`, que
+// no arrastra el cliente del vault); aquí se reexporta para quien ya tiene esto cargado.
+export { verifyAssertion, newAssertionNonce, cleanScopes, claimsAllowed, assertionBody, SCOPES, SCOPE_CLAIMS, ASSERTION_MAX_TTL_MS, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_SKEW_MS } from '../vault/assertion.js'

package/src/node.js

@@ -174,6 +174,14 @@ export class Identity {
   removeContact (publickey) { return this._h('removeContact', { publickey }) }
   listContacts () { return this._h('listContacts') }
   signData (data) { return this._h('signData', { data }) }
+  /**
+   * Prueba firmada con destinatario y vigencia (ver `vault/assertion.js`). Un servicio en
+   * Node la pide igual que una app: `{ audience, nonce, scopes?, ttlMs? }`.
+   */
+  async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+    const { assertion } = await this._h('requestAssertion', { audience, nonce, scopes, ttlMs })
+    return assertion
+  }
   // Delegación de capacidad (sub-clave de dispositivo con scope/exp/revocación)
   signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
   revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }

package/vault/acta.js

@@ -585,7 +585,11 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
  * reciente». Si la cadena que te llega es vieja, sigue verificando — para eso está el
  * registro público, que es otra capa.
  */
-export async function verifySignedBy ({ data, signature, publickey, chain, expectedProfileId = null } = {}) {
+/**
+ * @param {{ data?: any, signature?: string, publickey?: string, chain?: any[], expectedProfileId?: string|null }} [args]
+ */
+export async function verifySignedBy (args = {}) {
+  const { data, signature, publickey, chain, expectedProfileId = null } = args
   if (!data || typeof signature !== 'string' || typeof publickey !== 'string') {
     return { ok: false, reason: 'shape' }
   }

package/vault/assertion.js

@@ -0,0 +1,177 @@
+/**
+ * assertion.js — PARA QUIÉN vale una firma, y HASTA CUÁNDO.
+ *
+ * EL AGUJERO QUE TAPA. Una firma del ecosistema decía «esta identidad firmó esto» y nada
+ * más. No decía a quién va dirigida, así que un sobre firmado para el proxio **valía ante
+ * geo**: los dos comprueban la misma firma de la misma identidad y ninguno tenía con qué
+ * notar que no le hablaban a él. La ventana de repetición evita que el MISMO sobre se
+ * reenvíe dos veces al MISMO sitio; no evita el cruce de destinatario, que es otra cosa.
+ *
+ * Una prueba (`assertion`) es una firma normal del perfil —misma cripto, misma cadena de
+ * actas— sobre un cuerpo que además dice `aud` (para quién), `nonce` (para qué petición) e
+ * `iat`/`exp` (desde y hasta cuándo). Verificarla es lo de siempre MÁS comprobar esas
+ * cuatro cosas.
+ *
+ * TRES REGLAS, y las tres son la razón de que esto exista:
+ *
+ *   · **`aud` es obligatorio al emitir Y al verificar.** Una prueba sin destinatario no se
+ *     emite, y quien verifica tiene que decir quién es él. Sin eso no hay nada que
+ *     comparar y devolver «vale» sería exactamente el agujero de arriba.
+ *   · **El `nonce` lo pone quien PIDE.** Ata la prueba a esa petición y a ninguna otra.
+ *     Aquí no se lleva registro de nonces vistos: el que pide sabe cuál mandó, y un nonce
+ *     que no vuelve a usar no se puede repetir.
+ *   · **SIN MODO PERMISIVO.** No hay bandera para saltarse una comprobación, ni valor por
+ *     defecto que rellene lo que falta. Si falta el destinatario, el reto o la cadena, se
+ *     devuelve `ok:false` con su motivo. Un verificador laxo es un verificador roto.
+ *
+ * Módulo PURO: sin red, sin kv, sin iframe. Lo importan las apps, los servicios y el
+ * daemon.
+ */
+import { verifySignedBy } from './acta.js'
+
+export const ASSERTION_V = 1
+
+/**
+ * VIGENCIA. Corta a propósito: es lo que hace barata la revocación —no hay nada que
+ * invalidar, solo se deja de renovar— y lo que limita el daño de una prueba interceptada.
+ *
+ * El tope lo comprueba también QUIEN RECIBE, no solo quien emite: fiarse de que el otro
+ * puso un `exp` sensato es fiarse de la buena fe del que firma, y una prueba con un año de
+ * vigencia es una credencial al portador.
+ */
+export const ASSERTION_MAX_TTL_MS = 5 * 60 * 1000
+export const ASSERTION_DEFAULT_TTL_MS = 2 * 60 * 1000
+
+/**
+ * Tolerancia de reloj para `iat`. No es un repliegue: dos máquinas honestas difieren en
+ * segundos, y sin margen una prueba recién firmada se rechazaría por venir «del futuro».
+ * Solo afecta al arranque de la ventana; el vencimiento no se estira (ver §verify).
+ */
+export const ASSERTION_MAX_SKEW_MS = 60 * 1000
+
+/** Lo que se puede pedir. Lista CERRADA: lo que no está aquí no existe. */
+export const SCOPES = Object.freeze(['id:whoami', 'profile:name', 'profile:avatar', 'profile:email', 'profile:social'])
+
+/**
+ * Qué dato deja ver cada alcance. `id:whoami` no deja ver NINGUNO —es el mínimo: dice
+ * quién eres y nada más— y por eso es la lista vacía y no una omisión.
+ */
+export const SCOPE_CLAIMS = Object.freeze({
+  'id:whoami': Object.freeze([]),
+  'profile:name': Object.freeze(['name']),
+  'profile:avatar': Object.freeze(['avatar']),
+  'profile:email': Object.freeze(['email']),
+  'profile:social': Object.freeze(['links'])
+})
+
+/** Un reto de un solo uso, para quien pide. Que sea él quien lo genere es la mitad del mecanismo. */
+export const newAssertionNonce = () => crypto.randomUUID()
+
+/**
+ * Normaliza los alcances pedidos: solo los del catálogo, sin repetidos y en orden estable
+ * (el cuerpo se firma canónicamente, así que el orden importa para no firmar dos cosas
+ * distintas que dicen lo mismo).
+ *
+ * Pedir alcances desconocidos NO es un aviso que se pueda ignorar: se descartan, y si no
+ * queda ninguno se emite el mínimo (`id:whoami`), que es lo que significa «solo quiero
+ * saber quién eres».
+ */
+export function cleanScopes (scopes) {
+  const list = [...new Set((Array.isArray(scopes) ? scopes : []).filter((s) => SCOPES.includes(s)))].sort()
+  return list.length ? list : ['id:whoami']
+}
+
+/** Las claves de datos que esos alcances permiten llevar. */
+export function claimsAllowed (scopes) {
+  const out = new Set()
+  for (const s of cleanScopes(scopes)) for (const c of SCOPE_CLAIMS[s]) out.add(c)
+  return out
+}
+
+/**
+ * El cuerpo que se firma. Se construye AQUÍ y en un solo sitio, porque quien firma y quien
+ * verifica tienen que estar mirando exactamente los mismos campos: si el emisor añadiera
+ * uno que el verificador no reconstruye, la firma no cuadraría y el fallo aparecería como
+ * «firma inválida», que manda a buscar al sitio equivocado.
+ *
+ * Lanza si le falta algo: es un error de programación de quien emite, no un dato del otro
+ * lado que pueda venir mal.
+ */
+export function assertionBody ({ sub, aud, nonce, scopes, claims, iat, exp }) {
+  if (typeof sub !== 'string' || !sub) throw new Error('assertion: sub required')
+  if (typeof aud !== 'string' || !aud.trim()) throw new Error('assertion: aud required')
+  if (typeof nonce !== 'string' || !nonce) throw new Error('assertion: nonce required')
+  if (!Number.isFinite(iat) || !Number.isFinite(exp)) throw new Error('assertion: iat/exp required')
+  if (exp <= iat) throw new Error('assertion: exp must be after iat')
+  if (exp - iat > ASSERTION_MAX_TTL_MS) throw new Error('assertion: lifetime over the cap')
+  const granted = cleanScopes(scopes)
+  const permitido = claimsAllowed(granted)
+  const out = {}
+  for (const [k, v] of Object.entries(claims || {})) {
+    // NO se recorta en silencio lo que sobra: llevar un dato sin su alcance es entregar
+    // algo que nadie concedió, y el emisor tiene que enterarse de que lo intentó.
+    if (!permitido.has(k)) throw new Error(`assertion: claim "${k}" has no scope granting it`)
+    if (v !== undefined && v !== null && v !== '') out[k] = v
+  }
+  return { v: ASSERTION_V, op: 'assertion', sub, aud: aud.trim(), nonce, iat, exp, scopes: granted, claims: out }
+}
+
+/** Los campos del cuerpo, sacados de una prueba completa (que además lleva firma y cadena). */
+const bodyOf = (a) => ({ v: a.v, op: a.op, sub: a.sub, aud: a.aud, nonce: a.nonce, iat: a.iat, exp: a.exp, scopes: a.scopes, claims: a.claims })
+
+/**
+ * ¿Vale esta prueba, PARA MÍ y AHORA?
+ *
+ * `audience` y `nonce` los pone quien verifica, y son obligatorios: son las dos cosas que
+ * él sabe y la prueba no puede inventar. Faltando cualquiera de las dos no se puede
+ * juzgar, y decir «ok» sin haber comprobado es cómo un sobre de otro seguía entrando.
+ *
+ * Devuelve `{ ok:true, profileId, signer, seq, scopes, claims, aud, exp }` o
+ * `{ ok:false, reason }`.
+ */
+/**
+ * @param {any} assertion
+ * @param {{ audience?: string, nonce?: string, expectedProfileId?: string|null, now?: number, maxSkewMs?: number }} [opts]
+ */
+export async function verifyAssertion (assertion, opts = {}) {
+  const { audience, nonce, expectedProfileId = null, now = Date.now(), maxSkewMs = ASSERTION_MAX_SKEW_MS } = opts
+  if (typeof audience !== 'string' || !audience.trim()) return { ok: false, reason: 'no-audience' }
+  if (typeof nonce !== 'string' || !nonce) return { ok: false, reason: 'no-nonce' }
+  const a = assertion
+  if (!a || typeof a !== 'object') return { ok: false, reason: 'shape' }
+  if (a.v !== ASSERTION_V || a.op !== 'assertion') return { ok: false, reason: 'shape' }
+  if (typeof a.sub !== 'string' || typeof a.aud !== 'string' || typeof a.nonce !== 'string') return { ok: false, reason: 'shape' }
+  if (!Number.isFinite(a.iat) || !Number.isFinite(a.exp)) return { ok: false, reason: 'shape' }
+  if (!Array.isArray(a.scopes) || (a.claims != null && typeof a.claims !== 'object')) return { ok: false, reason: 'shape' }
+  if (typeof a.signature !== 'string' || typeof a.publickey !== 'string') return { ok: false, reason: 'shape' }
+
+  if (a.aud !== audience.trim()) return { ok: false, reason: 'otro-destinatario' }
+  if (a.nonce !== nonce) return { ok: false, reason: 'otro-reto' }
+
+  if (a.exp <= a.iat) return { ok: false, reason: 'vigencia-invalida' }
+  // El TOPE lo comprueba quien recibe. Si no, el emisor decide solo cuánto dura su
+  // credencial y el tope no es un tope.
+  if (a.exp - a.iat > ASSERTION_MAX_TTL_MS) return { ok: false, reason: 'vigencia-excesiva' }
+  // Y el vencimiento se juzga SIN margen: el margen es para el arranque (relojes que
+  // difieren), no para seguir aceptando lo que ya venció.
+  if (a.exp <= now) return { ok: false, reason: 'vencida' }
+  if (a.iat > now + maxSkewMs) return { ok: false, reason: 'del-futuro' }
+
+  if (a.scopes.some((s) => !SCOPES.includes(s))) return { ok: false, reason: 'alcance-desconocido' }
+  const permitido = claimsAllowed(a.scopes)
+  if (Object.keys(a.claims || {}).some((k) => !permitido.has(k))) return { ok: false, reason: 'claim-sin-alcance' }
+
+  // Y lo de siempre: que la firma sea de alguien a quien el acta de esa cadena autoriza a
+  // firmar por esta identidad. Es la misma comprobación que para cualquier contenido
+  // firmado; aquí no se inventa una cripto aparte.
+  const v = await verifySignedBy({ data: bodyOf(a), signature: a.signature, publickey: a.publickey, chain: a.chain, expectedProfileId })
+  if (!v.ok) return { ok: false, reason: 'firma:' + v.reason }
+  // A NOMBRE DE QUIÉN dice ir, contra a nombre de quién va de verdad. Sin esto una prueba
+  // podría afirmar ser de otro perfil y la firma seguiría cuadrando: diría la verdad sobre
+  // quién la firmó y una mentira sobre de quién es.
+  if (a.sub !== v.profileId) return { ok: false, reason: 'otro-sujeto' }
+
+  return { ok: true, profileId: v.profileId, signer: v.signer, seq: v.seq, scopes: [...a.scopes], claims: { ...(a.claims || {}) }, aud: a.aud, exp: a.exp }
+}
+
+export default { ASSERTION_V, ASSERTION_MAX_TTL_MS, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_SKEW_MS, SCOPES, SCOPE_CLAIMS, newAssertionNonce, cleanScopes, claimsAllowed, assertionBody, verifyAssertion }

package/vault/core.js

@@ -21,6 +21,7 @@
 import { signDelegationWith } from './capabilities.js'
 import * as Acta from './acta.js'
 import * as Content from './content.js'
+import { assertionBody, cleanScopes, claimsAllowed, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_TTL_MS } from './assertion.js'
 import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck } from './remote.js'
 
@@ -1605,10 +1606,71 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         throw new Error('profile-without-signer: this device no longer signs for you and is not connected to any vault that can')
       }
       maybeRenewVaultCert()
-      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload: data, onRevoked: wipeVaultLink }) }
+      try {
+        const firmado = await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload: data, onRevoked: wipeVaultLink })
+        // A NOMBRE DE QUIÉN, TAMBIÉN CUANDO FIRMA LA BÓVEDA. La respuesta del daemon trae
+        // `signature` y `publickey` y nada más, así que por este camino la firma salía sin
+        // identidad ni cadena: quien la recibía no podía ni verificarla (le falta el acta que
+        // dice que ese firmante es de este perfil) ni atribuirla a nadie. Se completa con lo
+        // que este aparato ya tiene: el `profileId` y la cadena son del PERFIL, no de quien
+        // firma, y los dos lados están en la misma.
+        //
+        // Si el acta de este aparato estuviera atrasada y la bóveda firmara con una llave
+        // admitida después, la cadena no la incluiría y el receptor lo rechazará por
+        // «firmante-no-autorizado» — ruidoso y correcto: lo que falta ahí es sincronizar el
+        // acta, no aflojar la comprobación.
+        return { ...firmado, profileId: acta?.profileId || publickeyJwkStr, chain: sealerChain() }
+      }
       catch (e) { return handleVaultError(e) }
     },
 
+    /**
+     * UNA PRUEBA PARA ALGUIEN EN CONCRETO, Y POR UN RATO (`vault/assertion.js`).
+     *
+     * `signData` firma «esto lo firmé yo» y no dice para quién: el mismo sobre valía ante
+     * el proxio y ante geo. Esto firma «esto lo firmé yo, PARA `aud`, contestando a
+     * `nonce`, y vale hasta `exp`».
+     *
+     * Firma por el camino de siempre —`signData`—, y eso no es un atajo: así hereda el
+     * re-enrutado a la bóveda cuando este aparato ya no firma por ti, y la prueba sale
+     * igual desde el teléfono que desde el PC.
+     *
+     * QUÉ DATOS LLEVA. Solo los que el perfil YA comparte (`publicMe`), y nunca más de lo
+     * que dan los alcances pedidos. La pantalla de permiso —donde se podrá conceder algo
+     * oculto a un destinatario concreto— es la fase siguiente
+     * (`dotrino-vault/docs/inicio-de-sesion.md`); hasta entonces esto no entrega nada que
+     * no se entregue ya, que es la forma de no adelantar una decisión del usuario.
+     */
+    async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+      if (typeof audience !== 'string' || !audience.trim()) throw new Error('audience required')
+      if (typeof nonce !== 'string' || !nonce) throw new Error('nonce required')
+      const acta = loadActa()
+      // A NOMBRE DE QUIÉN va: la identidad es el `profileId`, no la llave de este aparato.
+      const sub = acta?.profileId || publickeyJwkStr
+      const granted = cleanScopes(scopes)
+      const permitido = claimsAllowed(granted)
+      const claims = {}
+      if (permitido.size) {
+        const pub = await handlers.publicMe()
+        if (permitido.has('name')) {
+          const n = pub.nickname || [pub.nombres, pub.apellidos].filter(Boolean).join(' ').trim()
+          if (n) claims.name = n
+        }
+        if (permitido.has('avatar') && pub.avatar) claims.avatar = pub.avatar
+        if (permitido.has('email') && pub.email) claims.email = pub.email
+        if (permitido.has('links') && Array.isArray(pub.links) && pub.links.length) claims.links = pub.links
+      }
+      const ttl = Math.min(Math.max(Number(ttlMs) || ASSERTION_DEFAULT_TTL_MS, 1000), ASSERTION_MAX_TTL_MS)
+      const iat = Date.now()
+      const body = assertionBody({ sub, aud: audience, nonce, scopes: granted, claims, iat, exp: iat + ttl })
+      const { signature, publickey, profileId, chain } = await handlers.signData({ data: body })
+      // QUIEN FIRMÓ TIENE QUE SER DE ESTE PERFIL. Si `signData` se re-enrutó a una bóveda
+      // de otra cuenta, la prueba diría `sub` de una y firma de otra: no se arregla, se
+      // para. Verificarla fallaría igual, pero mucho más lejos y con otro nombre.
+      if (profileId !== sub) throw new Error('assertion: the signer belongs to another profile')
+      return { assertion: { ...body, signature, publickey, chain } }
+    },
+
     // ----- delegación de capacidad: la maestra firma un cert para una sub-clave -----
     // de dispositivo `sub`, acotado por `scope` y `exp`, revocable por `nonce`.
     // Es la ÚNICA forma en que la autoridad sale de la clave maestra, y va limitada.