@dotrino/vaultd 0.38.0 → 0.49.0

package/lib/src/sshKeys.js

@@ -0,0 +1,76 @@
+/**
+ * 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í.
+ *
+ * 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`.
+ */
+import { createPublicKey, createHash, verify as nodeVerify } from 'node:crypto'
+
+export const ECDSA_P256 = 'ecdsa-sha2-nistp256'
+
+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)])
+export function sshMpint (bytes) {
+  let b = Buffer.from(bytes)
+  while (b.length > 1 && b[0] === 0) b = b.subarray(1)
+  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) {
+    const n = buf.readUInt32BE(o); o += 4
+    if (o + n > buf.length) throw new Error('ssh: truncated string')
+    out.push(buf.subarray(o, o + n)); o += n
+  }
+  return out
+}
+
+/** 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)])
+}
+
+/**
+ * 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) }
+}
+
+/** `SHA256:…` como lo imprime `ssh-keygen -l`. */
+export function fingerprint (blob) {
+  return 'SHA256:' + createHash('sha256').update(Buffer.from(blob)).digest('base64').replace(/=+$/, '')
+}
+
+/**
+ * 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.
+ */
+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 default { ECDSA_P256, parsePublicKey, p256Blob, sshSignature, sshString, sshMpint, readStrings, fingerprint }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.38.0",
+  "version": "0.49.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -20,8 +20,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.49.0",
-    "@dotrino/proxy-client": "^0.10.0",
+    "@dotrino/identity": "^0.58.0",
+    "@dotrino/proxy-client": "^0.10.1",
     "ws": "^8.18.0"
   },
   "license": "MIT",
@@ -43,8 +43,8 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "^0.3.0",
-    "typescript": "^5.7.3",
-    "@types/node": "^22.0.0"
+    "@dotrino/remote-agent": "^0.3.2",
+    "@types/node": "^22.0.0",
+    "typescript": "5.9.3"
   }
 }

package/src/approvals.js

@@ -0,0 +1,69 @@
+/**
+ * PEDIDOS DE APROBACIÓN y VENTANAS de un cajón con `approval` (puro: sin red ni disco).
+ *
+ * Cuando un cajón exige aprobación por uso, leerlo ya no depende solo de tener el cert:
+ * el vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su
+ * firma libera los secretos. Aprobado, se abre una VENTANA para ese aparato y ese cajón
+ * (15 min): una sesión de trabajo no pide veinte veces. Lo que nadie aprueba vence solo.
+ *
+ * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién
+ * pide y su llave efímera `ek` (a la que se sella la respuesta). Nunca un valor.
+ */
+const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
+
+export const PENDING_TTL_MS = 5 * 60 * 1000
+export const GRANT_TTL_MS = 15 * 60 * 1000
+
+export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS, grantTtlMs = GRANT_TTL_MS } = {}) {
+  /** id → { id, ns, device, deviceId, label, ek, ts, exp } */
+  const pending = new Map()
+  /** `${ns}|${device}` → exp */
+  const grants = new Map()
+  const gkey = (ns, device) => ns + '|' + device
+
+  const publicOf = (p) => ({ id: p.id, kind: p.kind, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ...(p.ssh ? { ssh: p.ssh } : {}) })
+
+  return {
+    /**
+     * Apunta un pedido. `kind`: `secrets` (leer un cajón; uno por cajón y aparato: pedir
+     * otra vez reemplaza al anterior) o `ssh` (firmar un reto SSH con la llave del
+     * teléfono; cada firma es un pedido, con `ssh: { key, data }` y sus callbacks).
+     */
+    request ({ kind = 'secrets', ns, device = null, deviceId, label = '', ek = null, ssh = null, resolve = null, reject = null }) {
+      if (kind === 'secrets') for (const [id, p] of pending) if (p.kind === 'secrets' && p.ns === ns && p.device === device) pending.delete(id)
+      const ts = now()
+      const p = { id: rnd(), kind, ns, device, deviceId, label, ek, ssh, resolve, reject, ts, exp: ts + pendingTtlMs }
+      pending.set(p.id, p)
+      return publicOf(p)
+    },
+    /** Los pedidos vivos, sin la `ek` (no hace falta fuera de aquí). */
+    list () { this.sweep(); return [...pending.values()].map(publicOf) },
+    /** Saca un pedido para resolverlo (aprobar o denegar). `null` si no existe o venció. */
+    take (id) {
+      this.sweep()
+      const p = pending.get(id)
+      if (p) pending.delete(id)
+      return p || null
+    },
+    /** Abre la ventana de ese aparato sobre ese cajón. */
+    grant (ns, device) { const exp = now() + grantTtlMs; grants.set(gkey(ns, device), exp); return exp },
+    /** ¿Sigue abierta la ventana? */
+    has (ns, device) {
+      const exp = grants.get(gkey(ns, device))
+      if (exp == null) return false
+      if (exp <= now()) { grants.delete(gkey(ns, device)); return false }
+      return true
+    },
+    /** Cierra las ventanas de un aparato (al revocarlo, por ejemplo). */
+    forget (device) { for (const k of [...grants.keys()]) if (k.endsWith('|' + device)) grants.delete(k) },
+    /** Tira lo vencido; devuelve los pedidos que vencieron, para anotarlos. */
+    sweep () {
+      const t = now(); const gone = []
+      for (const [id, p] of pending) if (p.exp <= t) { pending.delete(id); gone.push(publicOf(p)); try { p.reject?.(new Error('approval: nobody approved the request in time')) } catch (_) {} }
+      for (const [k, exp] of grants) if (exp <= t) grants.delete(k)
+      return gone
+    }
+  }
+}
+
+export default { createApprovals, PENDING_TTL_MS, GRANT_TTL_MS }