@dotrino/vault 0.31.0 → 0.33.0

package/README.md

@@ -279,3 +279,11 @@ 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 con llaves en memoria (`dotrino-env ssh-agent`)
+
+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/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 con las llaves (SSH_KEY_* del cajón) solo en memoria;
+                         pide el cajón al arrancar. 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,57 @@ 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 con las llaves EN MEMORIA. Al arrancar pide su cajón a la bóveda (si este
+ * aparato está marcado con `approval`, el teléfono tiene que decir que sí), carga las
+ * variables `SSH_KEY_*` (el archivo de la llave, en base64) y sirve el protocolo de
+ * `ssh-agent`. En el disco no queda nada; cerrar el agente es olvidar las llaves.
+ *
+ *   dotrino-vault secret set ssh SSH_KEY_DOTRINO "$(base64 -w0 ~/.ssh/id_ed25519)"
+ *   dotrino-env ssh-agent --ns ssh          # imprime: export SSH_AUTH_SOCK=…
+ */
+async function cmdSshAgent () {
+  const { startSshAgent, defaultSocketPath } = await import('../src/sshAgent.js')
+  const { loadPrivateKey, publicLine } = await import('../src/sshKeys.js')
+  const { serviceDir, resolveNs } = await import('../src/env.js')
+  const { waitForSecrets } = await import('../src/service.js')
+  const ns = resolveNs(flag('ns') || undefined)
+  const dir = flag('dir') || serviceDir(ns)
+  const socketPath = flag('socket') || defaultSocketPath(dir)
+  console.error('[dotrino-env] asking the vault for the keys of «%s»…', ns)
+  const secrets = await waitForSecrets({ dir, ns, onPending: () => console.error('[dotrino-env] waiting for approval on your phone…') })
+  const keys = []
+  for (const [name, value] of Object.entries(secrets)) {
+    if (!/^SSH_KEY_[A-Z0-9_]*$/.test(name)) continue
+    try {
+      const text = /^-----BEGIN/.test(value) ? value : Buffer.from(value, 'base64').toString('utf8')
+      keys.push(loadPrivateKey(text, name.toLowerCase().replace(/_/g, '-')))
+    } catch (e) { console.error('[dotrino-env] %s skipped: %s', name, e.message) }
+  }
+  if (!keys.length) { console.error('[dotrino-env] no SSH_KEY_* variables in «%s»: nothing to serve', ns); process.exit(1) }
+  for (const k of keys) console.error('[dotrino-env] key %s %s', k.id, k.comment)
+  const agent = startSshAgent({ socketPath, keys: () => keys, log: console.error })
+  console.log('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.33.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/sshAgent.js

@@ -0,0 +1,94 @@
+/**
+ * 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.
+ *
+ *   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, signSsh } 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, keys: () => any[], log?: Function }} opts
+ *   `keys()`: las llaves cargadas (`loadPrivateKey` de sshKeys.js), con su privada en memoria.
+ */
+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) {
+    const list = keys() || []
+    if (type === REQUEST_IDENTITIES) {
+      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 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 { return frame(SIGN_RESPONSE, sshString(signSsh(key, data, flags))) } catch (e) {
+        log('[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('[ssh-agent] ' + e.message))
+  server.listen(socketPath, () => {
+    try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+    log(`[ssh-agent] listening at ${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,118 @@
+/**
+ * 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).
+ *
+ *   · 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 { 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)])
+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)
+}
+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
+}
+export const fingerprint = (blob) => 'SHA256:' + createHash('sha256').update(Buffer.from(blob)).digest('base64').replace(/=+$/, '')
+
+const OPENSSH_MAGIC = 'openssh-key-v1\0'
+
+/** 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) }
+}
+
+/** 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 || ''))
+}
+
+/**
+ * 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 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 { loadPrivateKey, publicBlob, publicLine, signSsh, sshString, sshMpint, readStrings, fingerprint }