@dotrino/vault 0.32.0 → 0.33.1

package/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/bin/dotrino-env.js

@@ -39,8 +39,8 @@ function help () {
   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.
+                         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:
@@ -152,29 +152,36 @@ async function cmdRun () {
 }
 
 /**
- * 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`.
+ * 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 { listSshKeys, requestSshSign } = await import('../src/service.js')
-  const ns = flag('ns') || undefined
+  const { loadPrivateKey, publicLine } = await import('../src/sshKeys.js')
   const { serviceDir, resolveNs } = await import('../src/env.js')
-  const dir = flag('dir') || serviceDir(resolveNs(ns))
+  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)
-  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…') })
+  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) }
   }
-  await keys()
-  const agent = startSshAgent({ socketPath, vault: () => vault, log: console.error, refresh: keys })
-  console.error('export SSH_AUTH_SOCK=%s', agent.socketPath)
+  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(() => {})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.32.0",
+  "version": "0.33.1",
   "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

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