Gestión de Llaves SSH en Bash
Genera, rota y distribuye llaves SSH con scripts bash.
Visión General
Las llaves SSH son la forma estándar de autenticarse a servidores remotos. Gestionarlas manualmente entre múltiples máquinas es propenso a errores. Esta recipe cubre generar llaves ed25519, distribuirlas a servidores, rotar llaves comprometidas y deshabilitar la autenticación por password.
Cuándo Usar
- Necesitas generar llaves SSH para nuevos miembros del equipo
- Quieres distribuir tu llave pública a toda una flota de servidores de una vez
- Necesitas rotar llaves después de un incidente de seguridad
- Estás endureciendo la seguridad del servidor deshabilitando auth por password
- No uses rotación de llaves longevas si ya tienes una CA SSH que emite certificados de corta vida — la firma reemplaza la distribución por
authorized_keys(ver la variante de CA más abajo)
Solución
Generar una llave ed25519
#!/bin/bash
KEY_NAME="${1:-default}"
KEY_PATH="$HOME/.ssh/${KEY_NAME}"
if [ -f "$KEY_PATH" ]; then
echo "Key already exists: $KEY_PATH"
exit 1
fi
ssh-keygen -t ed25519 -C "$(whoami)@$(hostname)-${KEY_NAME}" -f "$KEY_PATH" -N ""
echo "Generated: $KEY_PATH"
echo "Public key: ${KEY_PATH}.pub"
Distribuir llave pública a múltiples servidores
#!/bin/bash
PUBLIC_KEY="$HOME/.ssh/id_ed25519.pub"
SERVERS=(
"user@server1.example.com"
"user@server2.example.com"
"user@server3.example.com"
)
for server in "${SERVERS[@]}"; do
echo "Distributing key to $server..."
ssh-copy-id -i "$PUBLIC_KEY" "$server"
done
echo "Key distributed to ${#SERVERS[@]} servers"
Distribuir llave sin ssh-copy-id
#!/bin/bash
PUBLIC_KEY=$(cat "$HOME/.ssh/id_ed25519.pub")
SERVERS_FILE="servers.txt"
while IFS= read -r server; do
[ -z "$server" ] && continue
echo "Adding key to $server..."
ssh "$server" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && echo '$PUBLIC_KEY' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
done < "$SERVERS_FILE"
Rotar llaves comprometidas
#!/bin/bash
OLD_KEY="$1"
SERVERS_FILE="servers.txt"
if [ -z "$OLD_KEY" ]; then
echo "Usage: $0 <old-public-key-string>"
exit 1
fi
# Remover llave vieja de todos los servidores
while IFS= read -r server; do
[ -z "$server" ] && continue
echo "Removing old key from $server..."
ssh "$server" "sed -i '/${OLD_KEY}/d' ~/.ssh/authorized_keys"
done < "$SERVERS_FILE"
# Generar nueva llave
ssh-keygen -t ed25519 -C "$(whoami)@$(hostname)-rotated" -f "$HOME/.ssh/id_ed25519_rotated" -N ""
echo "Old key removed. New key: $HOME/.ssh/id_ed25519_rotated"
echo "Distribute the new key with the distribute script."
Deshabilitar autenticación por password
#!/bin/bash
SSHD_CONFIG="/etc/ssh/sshd_config"
# Backup de la config original
cp "$SSHD_CONFIG" "${SSHD_CONFIG}.bak"
# Deshabilitar auth por password
sed -i 's/^#*PasswordAuthentication.*/PasswordAuthentication no/' "$SSHD_CONFIG"
sed -i 's/^#*ChallengeResponseAuthentication.*/ChallengeResponseAuthentication no/' "$SSHD_CONFIG"
sed -i 's/^#*PubkeyAuthentication.*/PubkeyAuthentication yes/' "$SSHD_CONFIG"
# Reiniciar SSH
systemctl restart sshd
echo "Password authentication disabled. Key-based auth only."
Auditar llaves SSH en un servidor
#!/bin/bash
echo "=== SSH Key Audit ==="
echo "Date: $(date)"
echo ""
for user_home in /home/* /root; do
user=$(basename "$user_home")
auth_file="${user_home}/.ssh/authorized_keys"
if [ -f "$auth_file" ]; then
key_count=$(wc -l < "$auth_file")
echo "User: $user ($key_count keys)"
while IFS= read -r key; do
[ -z "$key" ] && continue
key_type=$(echo "$key" | awk '{print $1}')
key_comment=$(echo "$key" | awk '{print $3}')
key_fingerprint=$(echo "$key" | ssh-keygen -lf - 2>/dev/null | awk '{print $1}')
echo " - $key_type | $key_fingerprint | $key_comment"
done < "$auth_file"
echo ""
fi
done
Listar todas las llaves SSH en la máquina local
#!/bin/bash
echo "=== Local SSH Keys ==="
for key in ~/.ssh/id_* ~/.ssh/*.pub; do
[ -f "$key" ] || continue
if [[ "$key" == *.pub ]]; then
fingerprint=$(ssh-keygen -lf "$key" 2>/dev/null)
echo "Public: $key"
echo " $fingerprint"
fi
done
Explicación
Las llaves ed25519 son más pequeñas, rápidas y seguras que RSA. Una llave ed25519 de 256 bits provee seguridad equivalente a una llave RSA de 3072 bits. Siempre prefiere ed25519 para llaves nuevas.
ssh-copy-id agrega tu llave pública a ~/.ssh/authorized_keys en el servidor remoto. Maneja la configuración de permisos (700 para ~/.ssh, 600 para authorized_keys). Si ssh-copy-id no está disponible, puedes hacer lo mismo con un comando ssh manual.
La rotación de llaves remueve la llave pública vieja de los archivos authorized_keys en todos los servidores. El comando sed -i borra cualquier línea que contenga el string de la llave vieja. Después de remover, genera una llave nueva y distribúyela.
Deshabilitar la autenticación por password es el paso más efectivo de hardening SSH. Elimina los ataques de brute-force por password completamente.
Variantes
| Enfoque | Tipo de Llave | Usar Cuando |
|---|---|---|
| ed25519 | Ed25519 | Llaves nuevas, servidores modernos |
| RSA 4096 | RSA | Servidores legacy sin soporte ed25519 |
| ECDSA | ECDSA | Requisitos de compliance específicos |
| Llave hardware (FIDO2) | Ed25519-SK | Entornos de alta seguridad con YubiKey |
Pautas
- Usa ed25519 para todas las llaves nuevas. Es más rápida y segura que RSA.
- Ponle passphrase a toda llave privada que viva en una laptop. Cárgala una vez en
ssh-agentpor sesión en vez de tipearla en cada conexión. - Usa
~/.ssh/configpara gestionar múltiples llaves y alias de servidores. - Rota llaves después de salidas de miembros del equipo o compromisos sospechados.
- Audita archivos
authorized_keystrimestralmente. Remueve llaves de usuarios que ya no necesitan acceso.
Errores Comunes
- Usar llaves RSA más cortas que 3072 bits. RSA 2048 ya no se recomienda para uso a largo plazo.
- Dejar llaves privadas sin passphrase. Cualquiera con acceso al archivo puede usar la llave.
- No remover llaves viejas de
authorized_keysdespués de rotar. La llave comprometida sigue siendo válida. - Deshabilitar auth por password antes de verificar que el login por llave funciona. Te bloqueas fuera.
- Compartir llaves privadas entre usuarios. Cada usuario debe tener su propio par de llaves.
Soluciones Avanzadas
Archivos complementarios: todos los scripts de abajo están disponibles como archivos ejecutables en el repo companion de bash-ssh-key-manager, incluyendo la rotación verificada en flota, la auditoría CSV, el setup de agent para CI/CD y el gestor en Python.
Configuración SSH con jump host (bastion)
Conéctate a servidores internos a través de un bastion host sin exponerlos a internet. La directiva ProxyJump encadena conexiones SSH:
# Bastion host (alcanzable desde internet)
Host bastion
HostName bastion.example.com
User deploy
IdentityFile ~/.ssh/id_ed25519_bastion
Port 2222
# Servidores internos (solo alcanzables vía bastion)
Host *.internal.example.com
User deploy
IdentityFile ~/.ssh/id_ed25519_internal
ProxyJump bastion
# Deshabilitar agent forwarding al bastion por seguridad
ForwardAgent no
# Servidor de base de datos (dos saltos: bastion -> jump -> db)
Host db-prod.internal.example.com
User dbadmin
IdentityFile ~/.ssh/id_ed25519_db
ProxyJump jump-vm.internal.example.com
Llaves SSH respaldadas por hardware FIDO2 (YubiKey)
Genera llaves SSH que requieren presencia física de hardware. La llave privada nunca sale del YubiKey:
#!/bin/bash
# Generar una llave ed25519 respaldada por FIDO2
# Requiere OpenSSH 8.2+ y un dispositivo compatible con FIDO2 (YubiKey 5 Series)
ssh-keygen -t ed25519-sk -C "$(whoami)@$(hostname)-fido2" -f "$HOME/.ssh/id_ed25519_sk"
# Con passphrase y requiriendo touch en cada uso
ssh-keygen -t ed25519-sk -O resident -O verify-required \
-C "$(whoami)@$(hostname)-fido2-strict" \
-f "$HOME/.ssh/id_ed25519_sk_strict"
echo "FIDO2 key generated. Touch YubiKey when prompted during use."
# Resident key puede recuperarse en una máquina nueva
# ssh-keygen -K # descarga resident keys del dispositivo FIDO2
Autoridad Certificadora SSH (CA) para firma de llaves
En lugar de distribuir llaves públicas a cada servidor, configura una CA SSH. Los servidores confían en la CA, y los usuarios obtienen certificados firmados con expiración:
#!/bin/bash
# === En el host CA ===
# Generar par de llaves CA (hacer esto una vez, mantener la llave privada segura)
ssh-keygen -t ed25519 -f /etc/ssh/ca_key -N "" -C "SSH CA"
# === En cada servidor (confiar en la CA) ===
# Agregar llave pública de la CA como trusted user CA
echo "TrustedUserCAKeys /etc/ssh/ca_key.pub" >> /etc/ssh/sshd_config
systemctl restart sshd
# === Firmar la llave pública de un usuario (en host CA) ===
# Firmar con período de validez y restricciones de principal
ssh-keygen -s /etc/ssh/ca_key \
-I "user-$(date +%Y%m%d)" \
-n deploy,admin \
-V +1d \
~/.ssh/id_ed25519.pub
# Esto genera ~/.ssh/id_ed25519-cert.pub
# El usuario se conecta con su llave + certificado:
# ssh -i ~/.ssh/id_ed25519 user@server
# El certificado es válido por 1 día y solo para principals 'deploy' y 'admin'
Rotación masiva de llaves en un fleet de servidores
Rota llaves en cientos de servidores usando una herramienta SSH paralela y un manifiesto de rotación:
#!/bin/bash
# rotation-manifest.txt format: server old_key_fingerprint new_key_path
MANIFEST="rotation-manifest.txt"
KEYS_DIR="$HOME/.ssh"
while IFS=$'\t' read -r server old_fp new_key; do
[ -z "$server" ] && continue
echo "Rotating key on $server..."
# Remover llave vieja por fingerprint
ssh "$server" "ssh-keygen -R -f ~/.ssh/authorized_keys -F '$old_fp'" 2>/dev/null
# Agregar llave nueva
NEW_PUB=$(cat "${KEYS_DIR}/${new_key}.pub")
ssh "$server" "echo '$NEW_PUB' >> ~/.ssh/authorized_keys"
echo " Done: $server"
done < "$MANIFEST"
echo "Rotation complete for $(wc -l < "$MANIFEST") servers"
Rotación de llaves en flota con verificación
La rotación basada en manifiesto remueve la llave vieja antes de confirmar que la nueva funciona — si una subida falla a mitad de camino, pierdes el acceso. Esta variante agrega primero la llave nueva a todos los servidores, verifica el login con ella y recién después borra la vieja:
#!/usr/bin/env bash
set -euo pipefail
# servers.txt: un user@host por línea
OLD_KEY="$HOME/.ssh/id_ed25519"
NEW_KEY="$HOME/.ssh/id_ed25519_new"
SERVERS_FILE="${1:-servers.txt}"
ssh-keygen -t ed25519 -a 100 -f "$NEW_KEY" -N "" -C "rotated-$(date +%Y-%m-%d)"
# 1. Subir la llave pública nueva a todos lados, autenticando con la vieja
while IFS= read -r server; do
[[ -z "$server" || "$server" == \#* ]] && continue
ssh -i "$OLD_KEY" -o BatchMode=yes -o ConnectTimeout=10 "$server" \
"mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys" \
< "${NEW_KEY}.pub" \
&& echo "OK: $server" || echo "FAIL: $server"
done < "$SERVERS_FILE"
# 2. Verificar la llave nueva en cada servidor
ALL_OK=true
while IFS= read -r server; do
[[ -z "$server" || "$server" == \#* ]] && continue
ssh -i "$NEW_KEY" -o BatchMode=yes -o ConnectTimeout=10 "$server" true 2>/dev/null \
|| { echo "FAIL: $server rechaza la llave nueva"; ALL_OK=false; }
done < "$SERVERS_FILE"
# 3. Solo cuando todos los servidores aceptan la llave nueva, remover la vieja.
# authorized_keys guarda el blob de la llave pública, no su fingerprint,
# así que hay que matchear la línea completa del archivo .pub.
OLD_PUB=$(cat "${OLD_KEY}.pub")
if $ALL_OK; then
while IFS= read -r server; do
[[ -z "$server" || "$server" == \#* ]] && continue
ssh -i "$NEW_KEY" -o BatchMode=yes "$server" \
"grep -vxF '$OLD_PUB' ~/.ssh/authorized_keys > ~/.ssh/authorized_keys.tmp \
&& mv ~/.ssh/authorized_keys.tmp ~/.ssh/authorized_keys"
done < "$SERVERS_FILE"
mv "$NEW_KEY" "$OLD_KEY"
mv "${NEW_KEY}.pub" "${OLD_KEY}.pub"
echo "Rotación completa."
else
echo "ABORT: se mantiene la llave vieja; reintenta tras arreglar los servidores fallidos."
rm -f "$NEW_KEY" "${NEW_KEY}.pub"
exit 1
fi
El camino de aborto importa: ante cualquier fallo de verificación la llave vieja queda en los servidores y la nueva se borra localmente, así que el script se puede reejecutar sin riesgo.
Auditoría de authorized_keys en flota con reporte CSV
La auditoría anterior recorre una sola máquina. Esta variante recorre la flota y escribe un reporte CSV con columna de bits, lo que hace explícito el marcado de llaves débiles en lugar de sacarlo del campo fingerprint:
#!/usr/bin/env bash
set -euo pipefail
# Uso: ./audit-keys.sh server1 server2 server3
REPORT_FILE="ssh-key-audit-$(date +%Y%m%d).csv"
echo "server,user,key_type,bits,fingerprint,comment" > "$REPORT_FILE"
for server in "$@"; do
ssh -o BatchMode=yes -o ConnectTimeout=10 "$server" \
'for user_dir in /home/* /root; do
auth_keys="$user_dir/.ssh/authorized_keys"
[ -f "$auth_keys" ] || continue
while IFS= read -r line; do
[ -z "$line" ] || [[ "$line" == \#* ]] && continue
info=$(echo "$line" | ssh-keygen -lf - 2>/dev/null) || continue
bits=$(echo "$info" | awk "{print \$1}")
fp=$(echo "$info" | awk "{print \$2}")
ktype=$(echo "$line" | awk "{print \$1}")
comment=$(echo "$line" | awk "{print \$3}")
echo "'"$server"',$(basename "$user_dir"),$ktype,$bits,$fp,$comment"
done < "$auth_keys"
done' >> "$REPORT_FILE" 2>/dev/null \
|| echo "WARN: no se pudo auditar $server" >&2
done
# ssh-keygen -lf imprime "<bits> <SHA256:fp> <comment> (<TIPO>)" — el CSV lleva
# los bits en la columna 4, así que marcar llaves débiles es una comparación numérica:
awk -F',' 'NR>1 && ($3=="ssh-dss" || $3=="ecdsa" || ($3=="ssh-rsa" && $4+0 < 4096)) \
{print "WEAK: " $0}' "$REPORT_FILE"
Automatización de ssh-agent para CI/CD
Los runners de CI necesitan llaves cargadas sin interacción. Guarda la llave privada como secreto codificado en base64 y alimenta un agent desechable — consulta la guía de CI/CD para la parte de GitHub Actions:
#!/usr/bin/env bash
set -euo pipefail
# Iniciar un agent si no hay ninguno corriendo
ssh-add -l > /dev/null 2>&1 || eval "$(ssh-agent -s)"
# CI: la llave llega en base64 dentro de una variable de entorno secreta
if [[ -n "${SSH_KEY:-}" ]]; then
echo "$SSH_KEY" | base64 -d | ssh-add -
else
for key in "$HOME"/.ssh/id_ed25519*; do
[[ -f "$key" && "$key" != *.pub ]] && ssh-add "$key" 2>/dev/null || true
done
fi
# Fijar las llaves de host en vez de deshabilitar la verificación por completo.
# accept-new confía en el primer escaneo pero sigue detectando cambios posteriores.
mkdir -p "$HOME/.ssh"
for host in ${SSH_HOSTS:-github.com gitlab.com}; do
ssh-keyscan -H "$host" >> "$HOME/.ssh/known_hosts" 2>/dev/null
done
export GIT_SSH_COMMAND="ssh -o StrictHostKeyChecking=accept-new"
Gestión de llaves SSH en Python
Para tareas de inventario y auditoría, un pequeño wrapper de Python sobre ssh-keygen es más fácil de extender que bash. Ojo con el formato de -lf: <bits> <SHA256:fingerprint> <comentario> (<TIPO>), así que el tipo de llave es el último campo y el comentario es todo lo que queda en el medio:
import os
import subprocess
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Optional
@dataclass
class SSHKeyInfo:
key_type: str
bits: int
fingerprint: str
comment: str
file_path: str
class SSHKeyManager:
"""Genera, rota y audita llaves SSH en ~/.ssh."""
def __init__(self, key_dir: str = "~/.ssh"):
self.key_dir = Path(key_dir).expanduser()
self.key_dir.mkdir(parents=True, exist_ok=True)
self.key_dir.chmod(0o700)
def generate_key(self, name: str, key_type: str = "ed25519",
passphrase: str = "", comment: Optional[str] = None) -> Path:
key_path = self.key_dir / name
if key_path.exists():
raise FileExistsError(f"La llave ya existe: {key_path}")
comment = comment or (
f"{os.getenv('USER', 'user')}@{os.uname().nodename}"
f"-{datetime.now():%Y-%m-%d}"
)
cmd = ["ssh-keygen", "-t", key_type, "-f", str(key_path),
"-N", passphrase, "-C", comment]
if key_type == "ed25519":
cmd += ["-a", "100"]
subprocess.run(cmd, check=True, capture_output=True)
key_path.chmod(0o600)
key_path.with_suffix(".pub").chmod(0o644)
return key_path
def get_key_info(self, pub_key_path: Path) -> SSHKeyInfo:
out = subprocess.run(
["ssh-keygen", "-lf", str(pub_key_path)],
capture_output=True, text=True, check=True,
).stdout.strip().split()
return SSHKeyInfo(
key_type=out[-1].strip("()"), # (ED25519) -> ED25519
bits=int(out[0]),
fingerprint=out[1],
comment=" ".join(out[2:-1]),
file_path=str(pub_key_path),
)
def list_all_keys(self) -> list[SSHKeyInfo]:
keys = []
for pub_file in self.key_dir.glob("*.pub"):
try:
keys.append(self.get_key_info(pub_file))
except subprocess.CalledProcessError:
continue
return keys
def audit_weak_keys(self) -> list[SSHKeyInfo]:
weak = []
for key in self.list_all_keys():
if key.key_type in ("DSA", "ECDSA"):
weak.append(key)
elif key.key_type == "RSA" and key.bits < 4096:
weak.append(key)
return weak
manager = SSHKeyManager()
for k in manager.list_all_keys():
print(f"{k.file_path}: {k.key_type} {k.bits} {k.fingerprint} ({k.comment})")
for k in manager.audit_weak_keys():
print(f"WEAK: {k.file_path} ({k.key_type} {k.bits})")
Dos trampas que el código evita: ssh-keygen -lf reporta el tipo como RSA/ED25519, no con los nombres ssh-rsa/ssh-ed25519 que se usan dentro de authorized_keys; y un comentario de varias palabras desplaza el campo del tipo, así que hay que leerlo desde el final de la línea, no de la posición 4.
Lecturas Adicionales
- man page de ssh-keygen(1) — todos los flags usados aquí, incluidas las rondas KDF de
-ay el formato de-lf. - man page de sshd_config(5) —
PasswordAuthentication,TrustedUserCAKeysy el resto de opciones de hardening. - Notas de release de OpenSSH — las llaves
ed25519-skcon FIDO2 llegaron en OpenSSH 8.2.
Preguntas frecuentes
¿Cómo uso una llave específica para un servidor específico?
Usa ~/.ssh/config:
Host server1.example.com
IdentityFile ~/.ssh/id_ed25519_server1
User deploy
Host *.internal
IdentityFile ~/.ssh/id_ed25519_internal
User admin
¿Cómo configuro SSH agent forwarding de forma segura?
Agrega la llave al agent:
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
Luego conecta con -A para forwardear el agent. Solo usa agent forwarding con servidores confiables. Un servidor comprometido puede usar tu agent forwardeado para conectarse a otros servidores como tú.
¿Cómo fuerza auth por llave sin bloquearme fuera?
Testea el login por llave en una segunda terminal antes de deshabilitar passwords:
# Terminal 1: mantén esta abierta
ssh user@server
# Terminal 2: testea login por llave
ssh -o PasswordAuthentication=no user@server
# Si funciona, deshabilita passwords en Terminal 1
¿Cuál es la diferencia entre authorized_keys y known_hosts?
authorized_keys lista llaves públicas que pueden loguearse a esta máquina. known_hosts lista servidores a los que esta máquina se ha conectado. Sirven propósitos opuestos: uno controla acceso inbound, el otro valida conexiones outbound.
Recursos Relacionados
Scripting en Bash para Automatización DevOps y Tareas de
Como escribir scripts Bash robustos para automatizar despliegues, monitoreo de sistemas, rotacion de logs y tareas de mantenimiento rutinarias
DocPlantilla de Gestion de Certificados SSL
Una plantilla para rastrear el inventario, renovaciones, despliegues y riesgos de vencimiento de certificados TLS/SSL en dominios y servicios.
DocPlantilla de Revisión de Seguridad de API (OWASP)
Una plantilla de checklist rellenable para revisar autenticación, autorización, rate limiting y cobertura del OWASP API Security Top 10.
GuideChecklist de Seguridad API: Autenticación a Encriptación
Checklist de seguridad esencial para APIs: autenticación, autorización, validación de entrada, rate limiting, encriptación, logging y endurecimiento de despliegue.
GuideGuía de Mejores Prácticas de Seguridad
Una Referencia Detallada de seguridad de aplicaciones: autenticación, autorización, validación de inputs, gestión de secretos y prevención de vulnerabilidades comunes.
RecipeConfigurar Reglas de Firewall iptables con Bash
Configura un firewall iptables endurecido con bash: reglas seguras para SSH, NAT port forwarding, bloqueo de IPs y persistencia tras reinicios.