← volver

Certificados SSH: tu propia CA para autenticar flotas sin repartir llaves

Por · · [Admin-Sistemas] · lectura estimada: ~5 min
$ índice

Si gestionas más de tres servidores, ya conoces el ritual: copiar la llave pública de cada persona en el authorized_keys de cada máquina, y repetirlo cuando alguien entra, cambia de portátil o se va. Funciona, pero no escala y deja un rastro imposible de auditar. Los certificados SSH resuelven exactamente eso: en lugar de confiar en llaves sueltas, los servidores confían en una autoridad de certificación (CA) propia, y cada usuario presenta un certificado firmado, con identidad, permisos y fecha de caducidad. Es la misma idea que TLS, aplicada a SSH, y viene incluida en OpenSSH: solo necesitas ssh-keygen y un par de líneas en sshd_config.

Por qué un certificado vence a una llave suelta

Una llave pública en authorized_keys no caduca, no dice quién la emitió y solo se puede revocar borrándola de cada servidor, uno a uno. Un certificado, en cambio, lleva dentro:

  • Identidad verificable: el campo -I (por ejemplo, ana-2026) identifica a quién se emitió.
  • Principales: los nombres de usuario permitidos (-n ana,despliegue), no cualquier cuenta del sistema.
  • Validez temporal: -V -5m:+90d lo hace válido desde hace cinco minutos y durante 90 días. Pasada esa fecha, deja de funcionar solo.
  • Restricciones opcionales: prohibir el reenvío de agente o de puertos, o limitar el origen con force-command y source-address.

El resultado práctico: dar de alta a alguien es firmar un certificado; darle de baja es dejar que caduque o revocarlo en un solo sitio. Y los servidores ya no necesitan saber nada de cada usuario: solo necesitan la llave pública de la CA.

Paso 1: crea la CA (y guárdala como se merece)

La CA es una pareja de llaves Ed25519 normal y corriente. La privada es el activo más sensible del montaje: quien la tenga puede firmar certificados para cualquier usuario. Guárdala fuera de los servidores, en una máquina dedicada o un medio extraíble cifrado.

ssh-keygen -t ed25519 -f ~/.ssh/ca_usuario -C "CA usuarios SSH"
chmod 600 ~/.ssh/ca_usuario

La llave pública (ca_usuario.pub) es la que distribuirás a los servidores. La privada no debe pisar jamás un servidor de producción.

Paso 2: firma certificados de usuario

Cada persona genera su llave como siempre y te pasa solo la pública. Tú la firmas con la CA, indicando identidad, principales y validez:

ssh-keygen -s ~/.ssh/ca_usuario \
  -I ana-2026 -n ana,despliegue \
  -V -5m:+90d -z 42 \
  ana_id_ed25519.pub

Esto genera ana_id_ed25519-cert.pub junto a la llave. El usuario la coloca en ~/.ssh/ y SSH la presenta automáticamente al conectar, sin cambiar su forma de trabajar:

ssh ana@servidor

El -z 42 asigna un número de serie: es lo que te permitirá revocar este certificado concreto más adelante, sin tocar los demás.

Paso 3: haz que los servidores confíen en la CA

En cada servidor, copia la llave pública de la CA y añade una línea a la configuración de SSH:

sudo cp ca_usuario.pub /etc/ssh/ca_usuario_key.pub
echo "TrustedUserCAKeys /etc/ssh/ca_usuario_key.pub" \
  | sudo tee /etc/ssh/sshd_config.d/10-ca.conf
sudo sshd -t && sudo systemctl reload ssh

Desde ese momento, cualquier certificado firmado por esa CA y válido para el usuario de destino permite el acceso. Ya no hace falta tocar authorized_keys para altas nuevas: el servidor confía en la firma, no en la llave individual.

Puedes comprobar qué contiene un certificado antes de entregarlo con ssh-keygen -L -f ana_id_ed25519-cert.pub: verás el emisor, los principales, la validez y las extensiones. Si algo no cuadra, corrige los parámetros y vuelve a firmar.

Diagrama conceptual de la CA firmando certificados para usuarios y servidores

Paso 4: certificados de host, o adiós al “¿aceptas esta huella?”

El mismo mecanismo funciona en dirección contraria: la CA puede firmar las llaves de host de los servidores, y los clientes dejan de ver el temido aviso de huella desconocida cada vez que reinstalas una máquina.

# En el servidor, con su llave de host
ssh-keygen -s ~/.ssh/ca_host \
  -I web01 -h -n web01,web01.midominio.local \
  -V -5m:+52w -z 7 \
  /etc/ssh/ssh_host_ed25519_key.pub

En el servidor, añade el certificado:

echo "HostCertificate /etc/ssh/ssh_host_ed25519_key-cert.pub" \
  | sudo tee -a /etc/ssh/sshd_config.d/10-ca.conf
sudo sshd -t && sudo systemctl reload ssh

Y en el cliente, una línea en ~/.ssh/known_hosts sustituye a todas las huellas individuales:

@cert-authority *.midominio.local ssh-ed25519 AAAAC3... CA de hosts

A partir de ahí, cualquier host con certificado válido de tu CA se acepta sin preguntas, y un host impostor con otra llave se rechaza aunque su nombre coincida.

Revocación y caducidad: el plan de salida

La caducidad corta (90 días para usuarios, un año para hosts) ya resuelve la mayoría de las bajas: el acceso muere solo. Para una revocación inmediata, OpenSSH ofrece las listas KRL (Key Revocation Lists). Escribe las series a revocar en un fichero de especificación y genera la lista:

echo "serial: 42" > revocados.txt
ssh-keygen -k -f /etc/ssh/revoked_keys -s ca_usuario revocados.txt
echo "RevokedKeys /etc/ssh/revoked_keys" \
  | sudo tee /etc/ssh/sshd_config.d/11-revocados.conf
sudo sshd -t && sudo systemctl reload ssh

Y comprueba si un certificado está revocado antes de culpar a la red:

ssh-keygen -Q -f /etc/ssh/revoked_keys ana_id_ed25519-cert.pub

Detalle importante: la KRL hay que distribuirla a todos los servidores (con Ansible, por ejemplo). Una revocación que no llega a un servidor no existe en ese servidor.

Checklist para implantarlo sin sustos

Paso Acción Verificación
1 Crea la CA fuera de producción La privada nunca está en un servidor
2 Firma con identidad, principales y validez corta ssh-keygen -L muestra lo esperado
3 Despliega la pública de la CA en los servidores sshd -t pasa y el reload no corta sesiones
4 Prueba con un usuario antes de migrar a todos Acceso con certificado, denegado sin él
5 Documenta series, caducidades y el proceso de revocación Una baja se ejecuta en minutos, no en días

Un consejo final: no migres toda la flota de golpe. Empieza con un servidor de pruebas y un par de usuarios, deja authorized_keys como respaldo unas semanas, y cuando los certificados completen un ciclo de renovación sin incidentes, retira las llaves sueltas. El día que alguien se vaya, su acceso caducará solo, y si hace falta, lo revocarás en un solo fichero en lugar de perseguir su llave por veinte servidores.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal