StackPractices
intermediate Por Mathias Paulenko

Gestión de Llaves SSH en Bash

Genera, rota y distribuye llaves SSH con scripts bash.

Temas: security

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

EnfoqueTipo de LlaveUsar Cuando
ed25519Ed25519Llaves nuevas, servidores modernos
RSA 4096RSAServidores legacy sin soporte ed25519
ECDSAECDSARequisitos de compliance específicos
Llave hardware (FIDO2)Ed25519-SKEntornos 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-agent por sesión en vez de tipearla en cada conexión.
  • Usa ~/.ssh/config para gestionar múltiples llaves y alias de servidores.
  • Rota llaves después de salidas de miembros del equipo o compromisos sospechados.
  • Audita archivos authorized_keys trimestralmente. 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_keys despué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:

flowchart diagram: Generar llave nueva
#!/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

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.