@dotrino/vault 0.31.0 → 0.32.0

package/README.md

@@ -279,3 +279,10 @@ cert de una máquina vigente: sin esto toda máquina enrolada caducaba a los 30
 | bitácora, cifrado en reposo, candado, multi-perfil | son del daemon; en el navegador dependen de `@dotrino/identity` |
 
 MIT · parte de [Dotrino](https://dotrino.com).
+
+## Agente SSH delgado (`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 })`.

package/bin/dotrino-env.js

@@ -38,6 +38,9 @@ function help () {
   status                 servicios enrolados en esta máquina
   check [--ns <ns>]      pide los secretos al vault y lista sus NOMBRES (nunca los valores)
   run [--ns <ns>] -- <cmd> [args…]
+  ssh-agent [--ns <ns>] [--socket <ruta>]
+                         agente SSH delgado: las llaves viven en el teléfono; cada firma es
+                         un pedido a la bóveda. Pon SSH_AUTH_SOCK en la ruta que imprime.
                          ejecuta <cmd> con los secretos inyectados en su entorno
 
 En tu código:
@@ -140,19 +143,50 @@ async function cmdRun () {
   const sep = argv.indexOf('--')
   const cmd = sep >= 0 ? argv.slice(sep + 1) : []
   if (!cmd.length) { console.error('uso: dotrino-env run [--ns <ns>] -- <cmd> [args…]'); process.exit(2) }
-  const { injected, overridden } = await loadEnv({ ns: flag('ns') })
+  const onPending = () => console.error('[dotrino-env] waiting for approval on your phone…')
+  const { injected, overridden } = await loadEnv({ ns: flag('ns'), onPending })
   console.error('[dotrino-env] %d valor(es) en el entorno de %s%s', injected.length, cmd[0],
     overridden.length ? ` (pisados: ${overridden.join(', ')})` : '')
   const child = spawn(cmd[0], cmd.slice(1), { stdio: 'inherit', env: process.env })
   child.on('exit', (code, signal) => process.exit(signal ? 1 : (code ?? 0)))
 }
 
+/**
+ * Agente SSH DELGADO. Aquí no hay ninguna llave: el `ssh` del usuario pide firmar, esto
+ * convierte el reto en un pedido a la bóveda (la que enroló este servicio, esté donde
+ * esté) y el teléfono firma. Las públicas se cachean 30 s para no preguntar en cada `ssh`.
+ */
+async function cmdSshAgent () {
+  const { startSshAgent, defaultSocketPath } = await import('../src/sshAgent.js')
+  const { listSshKeys, requestSshSign } = await import('../src/service.js')
+  const ns = flag('ns') || undefined
+  const { serviceDir, resolveNs } = await import('../src/env.js')
+  const dir = flag('dir') || serviceDir(resolveNs(ns))
+  const socketPath = flag('socket') || defaultSocketPath(dir)
+  let cache = { at: 0, keys: [] }
+  const keys = async () => {
+    if (Date.now() - cache.at > 30 * 1000) { try { cache = { at: Date.now(), keys: await listSshKeys({ dir }) } } catch (e) { console.error('[dotrino-env] could not list keys: ' + e.message) } }
+    return cache.keys
+  }
+  const vault = {
+    sshKeys: () => cache.keys,
+    requestSshSign: ({ keyId, data }) => requestSshSign({ dir }, { keyId, data, onPending: () => console.error('[dotrino-env] ssh: waiting for approval on your phone…') })
+  }
+  await keys()
+  const agent = startSshAgent({ socketPath, vault: () => vault, log: console.error, refresh: keys })
+  console.error('export SSH_AUTH_SOCK=%s', agent.socketPath)
+  const stop = () => { agent.close(); process.exit(0) }
+  process.on('SIGINT', stop); process.on('SIGTERM', stop)
+  await new Promise(() => {})
+}
+
 const run = async () => {
   switch (argv[0]) {
     case 'enroll': return cmdEnroll()
     case 'status': return cmdStatus()
     case 'check': return cmdCheck()
     case 'run': return cmdRun()
+    case 'ssh-agent': return cmdSshAgent()
     case undefined:
     case 'help':
     case '--help':

package/package.json

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

package/src/service.js

@@ -491,6 +491,54 @@ 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/src/sshAgent.js

@@ -0,0 +1,100 @@
+/**
+ * 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.
+ *
+ * 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
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import path from 'node:path'
+import { sshString, readStrings } from './sshKeys.js'
+
+const AGENT_FAILURE = 5
+const AGENT_SUCCESS = 6
+const REQUEST_IDENTITIES = 11
+const IDENTITIES_ANSWER = 12
+const SIGN_REQUEST = 13
+const SIGN_RESPONSE = 14
+
+/** Dónde va el socket: en el directorio de ejecución del usuario si lo hay (se limpia solo). */
+export function defaultSocketPath (dir) {
+  const run = process.env.XDG_RUNTIME_DIR
+  return run ? path.join(run, 'dotrino-vault', 'ssh-agent.sock') : path.join(dir, 'ssh-agent.sock')
+}
+
+const frame = (type, payload = Buffer.alloc(0)) => {
+  const body = Buffer.concat([Buffer.from([type]), payload])
+  const len = Buffer.alloc(4); len.writeUInt32BE(body.length)
+  return Buffer.concat([len, body])
+}
+
+/**
+ * @param {{ socketPath: string, vault: () => { sshKeys: () => any[], requestSshSign: (a: { keyId: string, data: Buffer }) => Promise<Buffer> }, log?: Function }} opts
+ */
+export function startSshAgent ({ socketPath, vault, log = () => {}, refresh = null }) {
+  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()
+    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 || ''))]))
+      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'))
+      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)
+        return frame(AGENT_FAILURE)
+      }
+    }
+    // Añadir/quitar llaves, candado, extensiones: nada de eso vive aquí.
+    return frame(AGENT_FAILURE)
+  }
+
+  const server = net.createServer((sock) => {
+    let buf = Buffer.alloc(0)
+    let busy = Promise.resolve()
+    sock.on('data', (chunk) => {
+      buf = Buffer.concat([buf, chunk])
+      while (buf.length >= 4) {
+        const len = buf.readUInt32BE(0)
+        if (len < 1 || len > 256 * 1024) { sock.destroy(); return }
+        if (buf.length < 4 + len) break
+        const type = buf[4]; const payload = buf.subarray(5, 4 + len)
+        buf = buf.subarray(4 + len)
+        // En orden: el protocolo es petición-respuesta, y un cliente que encadena dos
+        // firmas espera las respuestas en el mismo orden.
+        busy = busy.then(() => handle(type, payload)).then((out) => { if (!sock.destroyed) sock.write(out) }).catch(() => { if (!sock.destroyed) sock.write(frame(AGENT_FAILURE)) })
+      }
+    })
+    sock.on('error', () => {})
+  })
+  server.on('error', (e) => log('[vault] 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})`)
+  })
+  return {
+    socketPath,
+    close () { try { server.close() } catch (_) {} try { fs.unlinkSync(socketPath) } catch (_) {} }
+  }
+}
+
+export default { startSshAgent, defaultSocketPath, AGENT_SUCCESS }

package/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 }