@dotrino/vaultd 0.49.1 → 0.52.0

package/README.md

@@ -240,7 +240,7 @@ dotrino-vault revoke  <nonce>      # revoca un dispositivo (le ordena autoborrar
 dotrino-vault activity [n]         # bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
 dotrino-vault pair --service <ns>  # empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
 dotrino-vault pair --scope <lista>  # los PERMISOS del cert: sign,read,store,secrets:<ns>. Sin esto, sign,read,store.
-dotrino-vault secret policy <ns> approval on|off   # el cajón pide tu aprobación en cada lectura (15 min de ventana)
+dotrino-vault caps <ID> +permiso     # ese aparato pide tu aprobación (teléfono) al recibir claves; pair --approval al enrolar
                                     # Se combina con --service: `--service eco --scope sign` = un bot que firma
                                     # como aparato del acta y lee SOLO su cajón. `admin` no se empareja (caps).
 dotrino-vault secret set <ns> <CLAVE> <valor>   # variable del SCOPE: la comparten todos los
@@ -756,46 +756,40 @@ CLI de apoyo: `dotrino-env status` (qué hay enrolado aquí), `dotrino-env check
 los secretos en el entorno de un proceso que no es Node). Primer consumidor:
 `dotrino-proxy` (TURN de Cloudflare).
 
-### Aprobación por uso (el teléfono dice que sí) y la llave SSH en el teléfono
+### Aprobación desde el teléfono (un aparato que pide permiso para recibir claves)
 
-Un cajón puede exigir el **visto bueno de un aparato** en cada lectura: para lo que corre
-en tu PC (un asistente, un script) y no debería llevarse tus claves sin que lo sepas.
+Liberar claves privadas a un aparato puede exigir el **visto bueno de otro aparato** (el
+teléfono, con `caps <ID> +aprueba`). Es una propiedad **del aparato**, no del cajón: el VPS
+desatendido no pide; la PC del dueño sí. Por defecto nadie pide; se fija al enrolar o se
+cambia después como un permiso más:
 
 ```sh
-dotrino-vault caps <ID-del-teléfono> +aprueba       # quién aprueba (no viaja en un QR)
-dotrino-vault secret policy claude approval on       # el cajón «claude» espera el sí
-dotrino-env run --ns claude -- node mi-script.js     # el proceso se queda esperando…
+dotrino-vault caps <ID-del-teléfono> +aprueba        # quién aprueba (no viaja en un QR)
+dotrino-vault pair --service claude --approval       # el que entre pedirá permiso
+dotrino-vault caps <ID> +permiso | -permiso          # cambiarlo después
+dotrino-env run --ns claude -- node mi-script.js     # el proceso espera el sí…
 ```
 
-…la bóveda apunta el pedido, avisa al teléfono (cola del proxio → aviso nativo), y solo su
-firma entrega las claves — **al proceso que pidió, en memoria**, con una **ventana de
-15 min** por aparato y cajón para no pedir veinte veces. Lo denegado corta sin reintentos;
-lo que nadie atiende vence a los 5 min; todo queda en `dotrino-vault activity`.
+…la bóveda apunta el pedido, avisa al teléfono (cola del proxio → aviso nativo en la app de
+Dotrino), y solo su firma entrega las claves — **al proceso que pidió, en memoria**. Pide en
+**cada petición**, que para un servicio bien hecho es **una por arranque**: pide al iniciar,
+se queda las claves en memoria y no vuelve a pedir. Lo denegado corta sin reintentos; lo que
+nadie atiende vence a los 5 min; todo queda en `dotrino-vault activity`.
 
-**La llave SSH vive en el teléfono.** El daemon expone un **agente SSH** (protocolo de
-`ssh-agent`, socket en `$XDG_RUNTIME_DIR/dotrino-vault/ssh-agent.sock`) que **no guarda
-ninguna llave privada**: la llave nace en el teléfono (vault.dotrino.com → *Llave SSH de
-este aparato*; WebCrypto no extraíble, `ecdsa-sha2-nistp256`) y cada firma es un pedido
-que apruebas ahí. En el PC no queda nada que copiar.
+### La llave SSH como un secreto más (`dotrino-env ssh-agent`)
 
-```sh
-dotrino-vault ssh                 # imprime el export SSH_AUTH_SOCK=… y la receta
-dotrino-vault ssh keys            # las llaves registradas (= ssh-add -L)
-ssh mi-servidor                   # el teléfono pide tu «sí» y firma
-```
-
-**La bóveda puede estar en OTRA máquina** (la de Dotrino en el VPS): en tu PC corre el
-agente **delgado**, que no custodia nada y reenvía cada reto como un pedido a la bóveda
-que enroló ese servicio:
+La llave privada SSH vive **sellada en la bóveda** (cajón `ssh`, variables `SSH_KEY_*` con el
+archivo en base64) y solo existe en claro en la memoria del agente que la pidió. En el disco
+de la PC no queda nada; cerrar el agente es olvidar las llaves.
 
 ```sh
-dotrino-env enroll --ns claude                   # una vez, contra la bóveda que sea
-dotrino-env ssh-agent --ns claude                # imprime export SSH_AUTH_SOCK=…
+dotrino-vault secret set ssh SSH_KEY_DOTRINO "$(base64 -w0 ~/.ssh/id_ed25519)"
+dotrino-env enroll --ns ssh --code <código>                 # una vez (pair --service ssh --approval en la bóveda)
+dotrino-env ssh-agent --ns ssh              # pide el cajón (tu sí en el teléfono) e imprime export SSH_AUTH_SOCK=…
+ssh mi-servidor                             # firma en local, con la llave en memoria
 ```
 
-Para no aprobar cada comando, reusa la conexión con `ControlMaster auto` +
-`ControlPersist 15m` en `~/.ssh/config`: esa es la ventana de 15 min del SSH.
-`DOTRINO_VAULT_SSH_AGENT=0` apaga el agente.
+ed25519 en formato OpenSSH (sin frase: la bóveda es el candado) y RSA/P-256 en PEM.
 
 ## Alcance
 
@@ -840,7 +834,7 @@ Para no aprobar cada comando, reusa la conexión con `ControlMaster auto` +
 - `packaging/` — `build.sh` (binario SEA + tarball), `build-deb.sh`, `build-win.sh`, `install.sh`/`uninstall.sh`, unit systemd.
 - `Dockerfile` — la imagen que publica `.github/workflows/docker.yml` en GHCR.
 - `test/` — las pruebas (`npm test`, `node --test`, sin dependencias).
-- `web/` — `vault.dotrino.com` (Vite + Vue): la página pública **y la consola «Dónde vive tu perfil»**, la única pantalla del ecosistema donde se ven y gestionan los dispositivos de un perfil. Sirve además las rutas del QR (`/d` y `/dispositivos`). La publica `.github/workflows/deploy.yml`.
+- `web/` — `vault.dotrino.com` (Vite + Vue): la página pública **y la consola «Dónde vive tu perfil»**, la única pantalla del ecosistema donde se ven y gestionan los dispositivos de un perfil — en `/vault`, que además decide sola si esta máquina hace de bóveda o se conecta a la que ya hay. Sirve también `/d`, la ruta corta del QR. La publica `.github/workflows/deploy.yml`.
 - `docs/` — las decisiones de diseño, que mandan sobre el código:
   - [`acta-de-perfil.md`](./docs/acta-de-perfil.md) — el modelo vigente: un perfil es un conjunto de llaves con un acta firmada por un solo sellador.
   - [`pairing-protocol.md`](./docs/pairing-protocol.md) — el emparejamiento endurecido: por qué el token dejó de ser autoridad suficiente.

package/lib/README.md

@@ -280,9 +280,10 @@ cert de una máquina vigente: sin esto toda máquina enrolada caducaba a los 30
 
 MIT · parte de [Dotrino](https://dotrino.com).
 
-## Agente SSH delgado (`dotrino-env ssh-agent`)
+## Agente SSH con llaves en memoria (`dotrino-env ssh-agent`)
 
-La llave SSH vive en el teléfono del dueño (registrada en su bóveda). En esta máquina solo
-corre un agente `ssh-agent` sin llaves: cada `SIGN_REQUEST` viaja a la bóveda como un
-pedido que el teléfono aprueba firmando. `dotrino-env ssh-agent --ns <ns>` imprime el
-`SSH_AUTH_SOCK`. Como librería: `listSshKeys(args)` y `requestSshSign(args, { keyId, data })`.
+La llave SSH es un secreto más del cajón (`SSH_KEY_*`, el archivo en base64). Al arrancar,
+el agente pide el cajón a la bóveda (con la aprobación del teléfono si el aparato la pide),
+carga las llaves en memoria y sirve el protocolo de `ssh-agent`; en el disco no queda nada.
+`dotrino-env ssh-agent --ns ssh` imprime el `SSH_AUTH_SOCK`. Como librería:
+`loadPrivateKey`, `publicLine`, `signSsh` (`src/sshKeys.js`) y `startSshAgent` (`src/sshAgent.js`).

package/lib/src/enroll.js

@@ -52,7 +52,7 @@ export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin' }
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin', 'vault:passwords': 'passwords' }
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 

package/lib/src/index.js

@@ -25,10 +25,10 @@
  * (`identity.signDelegation`). Transporte: `@dotrino/proxy-client` (import perezoso).
  * No reimplementa nada del ecosistema.
  */
-import { verifyChain } from '@dotrino/identity/capabilities'
+import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
-// local se queda corta, el dispositivo deja de atender mensajes sin que nadie lo note.
+// local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
@@ -168,15 +168,132 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (mine) desk.emitRevoke(chk.device, mine.nonce)
   }
 
+  /**
+   * Lo que el daemon comprueba antes de cualquier operación firmada, en un solo sitio:
+   * frescura (anti-replay), cadena de certs, scope esperado y revocaciones.
+   *
+   * Estaba repetido en `handleRenew` y `handleDevices` con matices distintos; al añadir
+   * el resto de operaciones eso habría sido cuatro copias divergiendo.
+   */
+  async function authorise (from, p, expectedScope) {
+    const d = p?.data
+    if (!d || !p.signature || !p.cert) {
+      send(from, { type: MSG.ERROR, error: 'invalid request' })
+      return null
+    }
+    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or a clock out of sync)' })
+      return null
+    }
+    const chk = await verifyChain({
+      data: d, signature: p.signature, cert: p.cert,
+      ...(expectedScope ? { expectedScope } : {}),
+      trustedIssuer: iss, revoked: await revocationSet(),
+    })
+    if (!chk.ok) {
+      send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+      return null
+    }
+    return chk
+  }
+
+  /**
+   * FIRMAR en name de la identidad. Es la razón de ser de una bóveda, y faltaba: un
+   * aparato enrolado contra este dispositivo podía renovar su cert y listar aparatos,
+   * pero no pedir la única cosa para la que se enroló.
+   */
+  async function handleSign (from, p) {
+    const chk = await authorise(from, p, SCOPE.SIGN)
+    if (!chk) return
+    const toSign = p.data?.payload
+    if (toSign == null) return send(from, { type: MSG.ERROR, error: 'data.payload required' })
+    const { signature, publickey } = await identity.signData(toSign)
+    send(from, { type: MSG.SIGNED, signature, publickey, device: chk.device })
+  }
+
+  /** Leer del almacén del perfil. Mismo scope que en el daemon: `read`. */
+  async function handleGet (from, p) {
+    const chk = await authorise(from, p, SCOPE.READ)
+    if (!chk) return
+    const id = p.data?.id || 'root'
+    try {
+      const node = await identity.getNode?.(id)
+      send(from, { type: MSG.DATA, id, node: node ?? null })
+    } catch (e) {
+      send(from, { type: MSG.ERROR, error: 'get: ' + e.message })
+    }
+  }
+
+  /**
+   * Escribir en el almacén. Se pasa por `vaultStore`, que es el mismo camino que usa
+   * un aparato contra el daemon — no se reimplementa el store aquí.
+   */
+  async function handleStore (from, p) {
+    const d = p?.data
+    if (!d || typeof d.method !== 'string') {
+      return send(from, { type: MSG.ERROR, error: 'store: invalid method' })
+    }
+    const chk = await authorise(from, p, SCOPE.STORE)
+    if (!chk) return
+    try {
+      const result = await identity.vaultStore?.(d.method, d.args || [])
+      send(from, { type: MSG.DATA, id: d.method, node: result ?? null })
+    } catch (e) {
+      send(from, { type: MSG.ERROR, error: 'store: ' + e.message })
+    }
+  }
+
+  /**
+   * ¿Sigue este aparato dentro del acta? Lo pregunta un aparato al arrancar, y por eso
+   * NO va firmado con cert: va firmado con su propia llave. Un aparato revocado tiene
+   * que poder enterarse de que lo está.
+   */
+  async function handleCheck (from, p) {
+    const d = p?.data
+    if (!d || typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
+    const pub = d.publickey
+    if (typeof pub !== 'string') return send(from, { type: MSG.ERROR, error: 'unauthorized: shape' })
+    if (!(await verifyDeviceSig({ publickey: pub, data: d, signature: p.signature }))) {
+      return send(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature' })
+    }
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const inside = (record?.members || []).some((m) => m?.pub === pub)
+    if (inside) return send(from, { type: MSG.CHECKED, in: true })
+
+    // Fuera del acta: se le dice, y además se le re-emite el aviso firmado si consta
+    // revocado — para que se apague solo en vez de quedarse creyendo que sigue dentro.
+    const { revokedCerts, issued } = await identity.listDelegations()
+    const mine = (revokedCerts || issued || []).find((x) => x.sub === pub && x.revokedAt)
+    if (mine) desk.emitRevoke(pub, mine.nonce)
+    send(from, { type: MSG.CHECKED, in: false })
+  }
+
+  /**
+   * Un fallo dentro de un handler NO se traga.
+   *
+   * El router llevaba `.catch(() => {})` en cada rama: si algo reventaba, el aparato del
+   * otro lado se quedaba esperando para siempre y aquí no quedaba rastro. Ahora se
+   * contesta el error — que es lo que permite depurarlo desde el lado que pregunta.
+   */
+  const handle = (name, promise, from) => Promise.resolve(promise).catch((e) => {
+    send(from, { type: MSG.ERROR, error: `${name}: ${e?.message || e}` })
+  })
+
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
     // El QR corto no lleva la llave: el aparato la pide con un HELLO presentando el `sn`.
-    if (p.type === MSG.HELLO) Promise.resolve(desk.handleHello(_from, p)).catch(() => {})
-    else if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    if (p.type === MSG.HELLO) handle('hello', desk.handleHello(_from, p), _from)
+    else if (p.type === MSG.ENROLL) handle('enroll', desk.handleEnroll(_from, p), _from)
     // Camino A: el aparato devuelve su acta sellada admitiendo a esta bóveda.
-    else if (p.type === MSG.ACTA_SEALED) Promise.resolve(desk.handleActaSealed(_from, p)).catch(() => {})
-    else if (p.type === MSG.RENEW) handleRenew(_from, p).catch(() => {})
-    else if (p.type === MSG.DEVICES) handleDevices(_from, p).catch(() => {})
+    else if (p.type === MSG.ACTA_SEALED) handle('acta', desk.handleActaSealed(_from, p), _from)
+    else if (p.type === MSG.RENEW) handle('renew', handleRenew(_from, p), _from)
+    else if (p.type === MSG.DEVICES) handle('devices', handleDevices(_from, p), _from)
+    // Lo que faltaba para que un aparato enrolado aquí pueda hacer lo mismo que contra
+    // el daemon del PC: firmar, leer, guardar y comprobar que sigue dentro.
+    else if (p.type === MSG.SIGN) handle('sign', handleSign(_from, p), _from)
+    else if (p.type === MSG.GET) handle('get', handleGet(_from, p), _from)
+    else if (p.type === MSG.STORE) handle('store', handleStore(_from, p), _from)
+    else if (p.type === MSG.CHECK) handle('check', handleCheck(_from, p), _from)
   })
 
   /**

package/lib/src/invite.js

@@ -69,10 +69,12 @@ export const FMT_SHORT = 't'
 export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
 
 /**
- * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de
- * `/dispositivos#vault=`): son 15 caracteres menos dentro del QR, y ahí los
- * caracteres se pagan en módulos. `vault.dotrino.com/dispositivos` sigue
- * funcionando —es la ruta que la gente ya tiene— y `parseInvite` lee las dos.
+ * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de `/vault#vault=`):
+ * son caracteres menos dentro del QR, y ahí los caracteres se pagan en módulos.
+ *
+ * `parseInvite` no mira la ruta, solo el #fragment: por eso un enlace emitido con
+ * cualquiera de las formas anteriores sigue emparejando aunque su dirección ya no
+ * exista.
  */
 export const PAIR_URL = 'https://vault.dotrino.com/d#v='
 

package/lib/src/protocol.js

@@ -98,7 +98,11 @@ export const SCOPE = Object.freeze({
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
   ADMIN: 'vault:admin',
-  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  APPROVE: 'vault:approve', // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  // El gestor de contraseñas: pedir credenciales de la bóveda, de a una y por dominio.
+  // Nunca lista la bóveda entera. Este SÍ se empareja (`pair --scope contrasenas`): es
+  // lo primero que hace la extensión, y no tendría sentido obligar a un segundo paso.
+  PASSWORDS: 'vault:passwords'
 })
 
 /**

package/lib/src/service.js

@@ -338,7 +338,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
 export async function enrollService ({ qr, ns, dir, label, onCode, onReplace, approveTimeoutMs = 180000 } = {}) {
   if (!isValidSecretsNs(ns)) throw new Error('invalid ns (use [a-z0-9-]{1,32}, e.g. "proxy")')
   if (!dir) throw new Error('dir required (where to persist the service identity)')
-  label = label || 'service:' + ns
+  label = label || ns
 
   // La identidad que va a quedar descartada. Se avisa antes de tocar nada: para
   // el proxy, por ejemplo, esta llave es además su identidad de red, así que
@@ -491,54 +491,6 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
   } finally { client.close() }
 }
 
-/**
- * AGENTE SSH DELGADO (`dotrino-env ssh-agent`): este proceso no custodia nada. Lista las
- * llaves públicas que la bóveda tiene registradas y, por cada reto, le pide a la bóveda
- * que lo convierta en un PEDIDO que el teléfono firma. Cualquier aparato con `vault:sign`
- * puede pedir; quien decide es el teléfono.
- */
-function serviceArgs ({ dir, ns, proxyUrl, masterPubkey, device, cert }) {
-  let saved = dir ? readServiceIdentity(dir) : null
-  if (!saved && device && cert) saved = { ns, iss: masterPubkey, proxy: proxyUrl, device, cert }
-  const out = { ns: ns || saved?.ns, proxyUrl: proxyUrl || saved?.proxy, masterPubkey: masterPubkey || saved?.iss, device: device || saved?.device, cert: cert || saved?.cert }
-  if (!out.proxyUrl || !out.masterPubkey || !out.device || !out.cert) throw new Error('service not enrolled: run enrollService() first (service-identity.json missing)')
-  return out
-}
-async function sshRpc (args, data, { timeoutMs = 30000, waitResult = null } = {}) {
-  const { proxyUrl, masterPubkey, device, cert } = serviceArgs(args)
-  const client = await freshClient(proxyUrl)
-  try {
-    await identifyAsService(client, device)
-    const signed = { ...data, publickey: device.publickey, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
-    const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
-    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data: signed, signature, cert })
-    let res = await pending
-    if (res.type === MSG.ERROR) throw new Error(res.error)
-    if (waitResult && res.body?.op === 'ssh.pending') {
-      try { waitResult.onPending?.({ id: res.body.id, exp: res.body.exp }) } catch (_) {}
-      const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : APPROVAL_TIMEOUT_MS
-      res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'ssh.sign.result') || p.type === MSG.ERROR, Math.min(until, APPROVAL_TIMEOUT_MS))
-        .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'ssh: nobody approved the request in time' : e.message) })
-      if (res.type === MSG.ERROR) throw new Error(res.error)
-    }
-    const ok = await verifyDeviceSig({ publickey: masterPubkey, data: res.body, signature: res.signature })
-    if (!ok) throw new Error('invalid master signature on the reply')
-    return res.body
-  } finally { client.close() }
-}
-/** Las llaves SSH públicas registradas en la bóveda: `[{ id, blob, comment }]`. */
-export async function listSshKeys (args = {}) {
-  const body = await sshRpc(args, { op: 'ssh.keys.public' })
-  return Array.isArray(body.items) ? body.items : []
-}
-/** Pide la firma SSH de `data` con la llave `keyId`; devuelve el blob de firma (Buffer). */
-export async function requestSshSign (args = {}, { keyId, data, onPending } = {}) {
-  const body = await sshRpc(args, { op: 'ssh.sign', key: keyId, data: Buffer.from(data).toString('base64') }, { waitResult: { onPending } })
-  if (typeof body.sig !== 'string') throw new Error('ssh: malformed signature reply')
-  return Buffer.from(body.sig, 'base64')
-}
-
 /**
  * Abre un bundle sellado: saca la CEK de la envoltura dirigida a este aparato y
  * descifra con ella las variables privadas. Las públicas vienen en claro.

package/lib/src/sshAgent.js

@@ -1,21 +1,18 @@
 /**
- * AGENTE SSH del daemon: un socket Unix con el protocolo de `ssh-agent` (draft-miller-
- * ssh-agent), para que el `ssh` del usuario firme con la llave que vive en su TELÉFONO.
+ * AGENTE SSH: un socket Unix con el protocolo de `ssh-agent` (draft-miller-ssh-agent)
+ * cuyas llaves viven SOLO EN MEMORIA — se las dio la bóveda al arrancar (`dotrino-env
+ * ssh-agent`, con la aprobación del teléfono si el aparato la pide). En el disco no hay
+ * nada. No acepta que le añadan llaves (`ssh-add` de un archivo se rechaza: la idea es
+ * justo que no haya archivos) ni hace de proxy de nada más.
  *
- * Lo que hace es poco a propósito: listar las llaves públicas registradas y, en cada
- * `SIGN_REQUEST`, pedirle la firma al aparato que aprueba (`vault.requestSshSign`) y
- * devolverla. No guarda llaves privadas, no acepta que le añadan (`ssh-add` de una llave
- * del disco se rechaza: la idea es justo que no haya llaves en el disco) y no hace de
- * proxy de nada más.
- *
- *   export SSH_AUTH_SOCK=$XDG_RUNTIME_DIR/dotrino-vault/ssh-agent.sock
- *   ssh-add -L          # las llaves del teléfono
- *   ssh mi-servidor     # el teléfono pide tu «sí» y firma
+ *   export SSH_AUTH_SOCK=…   # lo imprime dotrino-env ssh-agent
+ *   ssh-add -L               # las llaves del cajón
+ *   ssh mi-servidor          # firma en local, con la llave en memoria
  */
 import fs from 'node:fs'
 import net from 'node:net'
 import path from 'node:path'
-import { sshString, readStrings } from './sshKeys.js'
+import { sshString, readStrings, signSsh } from './sshKeys.js'
 
 const AGENT_FAILURE = 5
 const AGENT_SUCCESS = 6
@@ -37,30 +34,27 @@ const frame = (type, payload = Buffer.alloc(0)) => {
 }
 
 /**
- * @param {{ socketPath: string, vault: () => { sshKeys: () => any[], requestSshSign: (a: { keyId: string, data: Buffer }) => Promise<Buffer> }, log?: Function }} opts
+ * @param {{ socketPath: string, keys: () => any[], log?: Function }} opts
+ *   `keys()`: las llaves cargadas (`loadPrivateKey` de sshKeys.js), con su privada en memoria.
  */
-export function startSshAgent ({ socketPath, vault, log = () => {}, refresh = null }) {
+export function startSshAgent ({ socketPath, keys, log = () => {} }) {
   fs.mkdirSync(path.dirname(socketPath), { recursive: true, mode: 0o700 })
   try { fs.unlinkSync(socketPath) } catch (_) {}
 
   async function handle (type, payload) {
-    if (refresh) { try { await refresh() } catch (_) {} }
-    const v = vault()
+    const list = keys() || []
     if (type === REQUEST_IDENTITIES) {
-      const keys = v.sshKeys()
-      const n = Buffer.alloc(4); n.writeUInt32BE(keys.length)
-      const parts = keys.map((k) => Buffer.concat([sshString(Buffer.from(k.blob, 'base64')), sshString(Buffer.from(k.comment || ''))]))
+      const n = Buffer.alloc(4); n.writeUInt32BE(list.length)
+      const parts = list.map((k) => Buffer.concat([sshString(k.blob), sshString(Buffer.from(k.comment || ''))]))
       return frame(IDENTITIES_ANSWER, Buffer.concat([n, ...parts]))
     }
     if (type === SIGN_REQUEST) {
       const [blob, data] = readStrings(payload, 2)
-      const key = v.sshKeys().find((k) => k.blob === blob.toString('base64'))
+      const flags = payload.length >= 4 ? payload.readUInt32BE(payload.length - 4) : 0
+      const key = list.find((k) => k.blob.equals(blob))
       if (!key) return frame(AGENT_FAILURE)
-      try {
-        const sig = await v.requestSshSign({ keyId: key.id, data })
-        return frame(SIGN_RESPONSE, sshString(sig))
-      } catch (e) {
-        log('[vault] ssh-agent: not signed: ' + e.message)
+      try { return frame(SIGN_RESPONSE, sshString(signSsh(key, data, flags))) } catch (e) {
+        log('[ssh-agent] not signed: ' + e.message)
         return frame(AGENT_FAILURE)
       }
     }
@@ -86,10 +80,10 @@ export function startSshAgent ({ socketPath, vault, log = () => {}, refresh = nu
     })
     sock.on('error', () => {})
   })
-  server.on('error', (e) => log('[vault] ssh-agent: ' + e.message))
+  server.on('error', (e) => log('[ssh-agent] ' + e.message))
   server.listen(socketPath, () => {
     try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
-    log(`[vault] ssh-agent listening at ${socketPath}  (export SSH_AUTH_SOCK=${socketPath})`)
+    log(`[ssh-agent] listening at ${socketPath}`)
   })
   return {
     socketPath,

package/lib/src/sshKeys.js

@@ -1,17 +1,16 @@
 /**
- * LLAVES SSH del teléfono — solo la parte PÚBLICA, que es lo único que vive en esta
- * máquina. La privada nace y muere en el aparato que aprueba (WebCrypto no extraíble hoy;
- * el llavero del sistema en la app nativa): firmar un reto SSH es un pedido de aprobación
- * más, y la firma vuelve con el «sí». Así la llave SSH no está en el disco del PC, que
- * era exactamente lo que había que sacar de aquí.
+ * LLAVES SSH como secretos de la bóveda. La llave privada vive sellada en un cajón
+ * (variables `SSH_KEY_*`, valor = el archivo de la llave en base64) y solo existe en claro
+ * en la memoria del agente que la pidió (`dotrino-env ssh-agent`). Aquí: leerla, sacar su
+ * pública en el formato de `authorized_keys` y firmar como manda SSH (RFC 4253/8332/5656).
  *
- * Formatos (RFC 4253 / 5656): el blob de una llave `ecdsa-sha2-nistp256` es
- * string(tipo) string("nistp256") string(0x04‖X‖Y); su firma es string(tipo) string(mpint r ‖ mpint s).
- * Puro: sin disco ni red — quien guarda es `vault.js`.
+ *   · ed25519: formato OpenSSH («-----BEGIN OPENSSH PRIVATE KEY-----»), parseado a mano
+ *     (Node no lo lee) — solo sin frase.
+ *   · RSA / ECDSA P-256: PEM (PKCS#8 o tradicional), vía `node:crypto`.
+ *
+ * Puro: sin disco ni red.
  */
-import { createPublicKey, createHash, verify as nodeVerify } from 'node:crypto'
-
-export const ECDSA_P256 = 'ecdsa-sha2-nistp256'
+import { createPrivateKey, createPublicKey, sign as nodeSign, createHash } from 'node:crypto'
 
 const u32 = (n) => { const b = Buffer.alloc(4); b.writeUInt32BE(n >>> 0); return b }
 export const sshString = (buf) => Buffer.concat([u32(buf.length), Buffer.from(buf)])
@@ -21,7 +20,6 @@ export function sshMpint (bytes) {
   if (b[0] & 0x80) b = Buffer.concat([Buffer.from([0]), b])
   return sshString(b)
 }
-/** Lee strings SSH encadenados: `[Buffer, …]`. */
 export function readStrings (buf, max = 16) {
   const out = []; let o = 0
   while (o + 4 <= buf.length && out.length < max) {
@@ -31,46 +29,90 @@ export function readStrings (buf, max = 16) {
   }
   return out
 }
+export const fingerprint = (blob) => 'SHA256:' + createHash('sha256').update(Buffer.from(blob)).digest('base64').replace(/=+$/, '')
 
-/** Blob de llave pública a partir de las coordenadas (base64url JWK). */
-export function p256Blob ({ x, y }) {
-  const point = Buffer.concat([Buffer.from([4]), Buffer.from(x, 'base64url'), Buffer.from(y, 'base64url')])
-  return Buffer.concat([sshString(Buffer.from(ECDSA_P256)), sshString(Buffer.from('nistp256')), sshString(point)])
-}
+const OPENSSH_MAGIC = 'openssh-key-v1\0'
 
-/**
- * Acepta una línea `authorized_keys` (`ecdsa-sha2-nistp256 AAAA… comentario`) y devuelve
- * lo que se guarda: tipo, blob, comentario y JWK pública. Solo P-256: es lo que firma
- * WebCrypto y el llavero del teléfono; RSA no entra.
- */
-export function parsePublicKey (line) {
-  const [type, b64, ...rest] = String(line || '').trim().split(/\s+/)
-  if (type !== ECDSA_P256 || !b64) throw new Error(`ssh: only ${ECDSA_P256} keys are accepted`)
-  const blob = Buffer.from(b64, 'base64')
-  const [t, curve, point] = readStrings(blob, 3)
-  if (t.toString() !== ECDSA_P256 || curve.toString() !== 'nistp256' || point.length !== 65 || point[0] !== 4) throw new Error('ssh: malformed key blob')
-  const jwk = { kty: 'EC', crv: 'P-256', x: point.subarray(1, 33).toString('base64url'), y: point.subarray(33).toString('base64url') }
-  return { type, blob: blob.toString('base64'), comment: rest.join(' '), jwk, id: fingerprint(blob) }
+/** Llave ed25519 en formato OpenSSH sin frase → { type, privateKey (KeyObject), blob }. */
+function parseOpenSsh (text) {
+  const b64 = text.replace(/-----(BEGIN|END) OPENSSH PRIVATE KEY-----/g, '').replace(/\s+/g, '')
+  const buf = Buffer.from(b64, 'base64')
+  if (buf.subarray(0, OPENSSH_MAGIC.length).toString('latin1') !== OPENSSH_MAGIC) throw new Error('ssh: not an OpenSSH private key')
+  // string cipher · string kdf · string kdfoptions · uint32 nkeys · string pub · string priv
+  let body = buf.subarray(OPENSSH_MAGIC.length)
+  const [cipher, kdf, kdfopts] = readStrings(body, 3)
+  body = body.subarray(12 + cipher.length + kdf.length + kdfopts.length)
+  if (cipher.toString() !== 'none' || kdf.toString() !== 'none') throw new Error('ssh: passphrase-protected keys are not supported (store the key without one; the vault is the lock)')
+  const [pubBlob, priv] = readStrings(body.subarray(4), 2)
+  const [type] = readStrings(pubBlob, 1)
+  if (type.toString() !== 'ssh-ed25519') {
+    // Otros tipos en formato OpenSSH: conviértelos a PEM (`ssh-keygen -p -m PEM`).
+    throw new Error(`ssh: ${type.toString()} in OpenSSH format is not supported; convert it with ssh-keygen -p -m PEM`)
+  }
+  // priv: uint32 check ×2, string type, string pub(32), string priv(64 = seed‖pub), string comment
+  const [t2, , sk] = readStrings(priv.subarray(8), 3)
+  if (t2.toString() !== 'ssh-ed25519' || sk.length !== 64) throw new Error('ssh: malformed ed25519 key')
+  const seed = sk.subarray(0, 32)
+  // PKCS#8 de ed25519: prefijo fijo + semilla de 32 bytes.
+  const pkcs8 = Buffer.concat([Buffer.from('302e020100300506032b657004220420', 'hex'), seed])
+  const privateKey = createPrivateKey({ key: pkcs8, format: 'der', type: 'pkcs8' })
+  return { type: 'ssh-ed25519', privateKey, blob: Buffer.from(pubBlob) }
 }
 
-/** `SHA256:…` como lo imprime `ssh-keygen -l`. */
-export function fingerprint (blob) {
-  return 'SHA256:' + createHash('sha256').update(Buffer.from(blob)).digest('base64').replace(/=+$/, '')
+/** Blob público SSH de una KeyObject RSA / P-256 / ed25519. */
+export function publicBlob (privateKey) {
+  const pub = createPublicKey(privateKey)
+  const jwk = pub.export({ format: 'jwk' })
+  if (jwk.kty === 'RSA') {
+    return Buffer.concat([sshString(Buffer.from('ssh-rsa')), sshMpint(Buffer.from(jwk.e, 'base64url')), sshMpint(Buffer.from(jwk.n, 'base64url'))])
+  }
+  if (jwk.kty === 'EC' && jwk.crv === 'P-256') {
+    const point = Buffer.concat([Buffer.from([4]), Buffer.from(jwk.x, 'base64url'), Buffer.from(jwk.y, 'base64url')])
+    return Buffer.concat([sshString(Buffer.from('ecdsa-sha2-nistp256')), sshString(Buffer.from('nistp256')), sshString(point)])
+  }
+  if (jwk.kty === 'OKP' && jwk.crv === 'Ed25519') {
+    return Buffer.concat([sshString(Buffer.from('ssh-ed25519')), sshString(Buffer.from(jwk.x, 'base64url'))])
+  }
+  throw new Error('ssh: unsupported key type ' + jwk.kty + '/' + (jwk.crv || ''))
 }
 
 /**
- * Comprueba la firma cruda del teléfono (`r‖s`, 64 bytes, SHA-256 sobre `data`) y la
- * convierte al blob de firma SSH. Una firma que no cuadra NO se convierte: devolver un
- * blob inválido dejaría al `ssh` del usuario con un error opaco y a nosotros sin bitácora.
+ * Lee una llave privada (texto del archivo: OpenSSH ed25519 o PEM RSA/P-256) y devuelve
+ * lo que el agente necesita: `{ type, privateKey, blob, id, comment }`.
  */
-export function sshSignature ({ jwk, data, rawSig }) {
-  const sig = Buffer.from(rawSig, 'base64')
-  if (sig.length !== 64) throw new Error('ssh: raw signature must be 64 bytes (r||s)')
-  const key = createPublicKey({ key: { kty: 'EC', crv: 'P-256', x: jwk.x, y: jwk.y }, format: 'jwk' })
-  const ok = nodeVerify('sha256', Buffer.from(data), { key, dsaEncoding: 'ieee-p1363' }, sig)
-  if (!ok) throw new Error('ssh: the signature does not verify against the registered key')
-  const rs = Buffer.concat([sshMpint(sig.subarray(0, 32)), sshMpint(sig.subarray(32))])
-  return Buffer.concat([sshString(Buffer.from(ECDSA_P256)), sshString(rs)])
+export function loadPrivateKey (text, comment = '') {
+  const t = String(text || '').trim()
+  let privateKey, blob
+  if (t.startsWith('-----BEGIN OPENSSH PRIVATE KEY-----')) ({ privateKey, blob } = parseOpenSsh(t))
+  else { privateKey = createPrivateKey(t); blob = publicBlob(privateKey) }
+  const [type] = readStrings(blob, 1)
+  return { type: type.toString(), privateKey, blob, id: fingerprint(blob), comment }
+}
+
+/** Línea `authorized_keys` de una llave cargada. */
+export const publicLine = (k) => `${k.type} ${k.blob.toString('base64')}${k.comment ? ' ' + k.comment : ''}`
+
+const SSH_AGENT_RSA_SHA2_256 = 2
+const SSH_AGENT_RSA_SHA2_512 = 4
+
+/** Firma `data` como manda SSH para ese tipo de llave; devuelve el blob de firma. */
+export function signSsh (k, data, flags = 0) {
+  if (k.type === 'ssh-ed25519') {
+    return Buffer.concat([sshString(Buffer.from('ssh-ed25519')), sshString(nodeSign(null, Buffer.from(data), k.privateKey))])
+  }
+  if (k.type === 'ecdsa-sha2-nistp256') {
+    const raw = nodeSign('sha256', Buffer.from(data), { key: k.privateKey, dsaEncoding: 'ieee-p1363' })
+    const rs = Buffer.concat([sshMpint(raw.subarray(0, 32)), sshMpint(raw.subarray(32))])
+    return Buffer.concat([sshString(Buffer.from('ecdsa-sha2-nistp256')), sshString(rs)])
+  }
+  if (k.type === 'ssh-rsa') {
+    // Sin flags es el `ssh-rsa` (SHA-1) histórico, que los servidores modernos rechazan;
+    // OpenSSH pide rsa-sha2-256/512 con las banderas del agente (RFC 8332).
+    const algo = (flags & SSH_AGENT_RSA_SHA2_512) ? 'rsa-sha2-512' : (flags & SSH_AGENT_RSA_SHA2_256) ? 'rsa-sha2-256' : 'ssh-rsa'
+    const hash = algo === 'rsa-sha2-512' ? 'sha512' : algo === 'rsa-sha2-256' ? 'sha256' : 'sha1'
+    return Buffer.concat([sshString(Buffer.from(algo)), sshString(nodeSign(hash, Buffer.from(data), k.privateKey))])
+  }
+  throw new Error('ssh: cannot sign with ' + k.type)
 }
 
-export default { ECDSA_P256, parsePublicKey, p256Blob, sshSignature, sshString, sshMpint, readStrings, fingerprint }
+export default { loadPrivateKey, publicBlob, publicLine, signSsh, sshString, sshMpint, readStrings, fingerprint }