Claves SSH: generación, configuración y múltiples…

Claves SSH: un método de autenticación más seguro que las contraseñas

Comparación	Contraseña	Clave SSH
Método de autenticación	Factor de conocimiento (lo que sabes)	Factor de posesión (lo que tienes)
Fuerza bruta	Posible	Prácticamente imposible
Riesgo de phishing	Alto	Bajo (la clave privada no sale del equipo local)
Filtración del servidor	Contraseñas en texto plano/hash vulnerables	Solo se almacena la clave pública, no se puede derivar la privada
Comodidad	Escribir cada vez	Configurar una vez, autenticación automática

1. Generar un par de claves

Ed25519 (recomendado)

ssh-keygen -t ed25519 -C "your@email.com"

Parámetro	Descripción
`-t ed25519`	Tipo de algoritmo (Ed25519, el más seguro y rápido)
`-C`	Comentario (generalmente el email para identificar)

RSA (alternativa por compatibilidad)

ssh-keygen -t rsa -b 4096 -C "your@email.com"

Algoritmo	Longitud de clave	Seguridad	Rendimiento	Recomendación
Ed25519	256 bit	Máxima	Más rápido	✅
ECDSA P256	256 bit	Alta	Rápido	Opcional
RSA 4096	4096 bit	Alta	Lento	Alternativa por compatibilidad
RSA 2048	2048 bit	Media	Lento	❌ No recomendado

Proceso de generación

$ ssh-keygen -t ed25519 -C "dev@example.com"
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase): ****
Enter same passphrase again: ****
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub

Se recomienda encarecidamente establecer una passphrase: incluso si la clave privada se filtra, una passphrase impide su uso directo.

2. Desplegar la clave pública

GitHub / GitLab

# Copiar la clave pública
cat ~/.ssh/id_ed25519.pub | clip

# GitHub → Settings → SSH and GPG keys → New SSH key
# Pegar el contenido de la clave pública

Servidor

# Método 1: ssh-copy-id
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server.com

# Método 2: Agregar manualmente
cat ~/.ssh/id_ed25519.pub | ssh user@server.com 'mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys'

Verificar conexión

ssh -T git@github.com
# Hi username! You've successfully authenticated...

ssh user@server.com
# Inicio de sesión directo, sin contraseña

3. Configuración de múltiples cuentas

Escenario: GitHub de trabajo + GitHub personal

# Generar dos pares de claves
ssh-keygen -t ed25519 -C "work@company.com" -f ~/.ssh/id_work
ssh-keygen -t ed25519 -C "personal@gmail.com" -f ~/.ssh/id_personal

SSH Config

# ~/.ssh/config
Host github-work
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_work
  IdentitiesOnly yes

Host github-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_personal
  IdentitiesOnly yes

Uso con Git

# Repositorio de trabajo
git clone git@github-work:company/project.git

# Repositorio personal
git clone git@github-personal:username/project.git

Configuración multiplataforma

# ~/.ssh/config
Host github.com
  User git
  IdentityFile ~/.ssh/id_github

Host gitlab.com
  User git
  IdentityFile ~/.ssh/id_gitlab

Host gitee.com
  User git
  IdentityFile ~/.ssh/id_gitee

Host dev.azure.com
  User git
  IdentityFile ~/.ssh/id_azure

4. Gestión de SSH Agent

Iniciar Agent

eval "$(ssh-agent -s)"

Agregar clave

ssh-add ~/.ssh/id_ed25519
# Enter passphrase: ****

# Ver claves agregadas
ssh-add -l
# 256 SHA256:xxx... dev@example.com (ED25519)

Inicio automático (bashrc)

# ~/.bashrc o ~/.zshrc
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)"
  ssh-add ~/.ssh/id_ed25519 2>/dev/null
fi

Persistencia con keychain

# macOS: usar Keychain para almacenar la passphrase
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Linux: usar keychain
eval "$(keychain --eval id_ed25519)"

5. Configuración de servidor de salto

Escenario: Local → Servidor de salto → Servidor de producción

# ~/.ssh/config
Host jumpbox
  HostName jump.example.com
  User jump-user
  IdentityFile ~/.ssh/id_jump

Host production
  HostName 10.0.1.100
  User deploy
  IdentityFile ~/.ssh/id_prod
  ProxyJump jumpbox

# Conexión directa al servidor de producción (pasa automáticamente por el servidor de salto)
ssh production

Reenvío de Agent

Host jumpbox
  HostName jump.example.com
  ForwardAgent yes

Aviso de seguridad: Solo habilita el reenvío de Agent cuando confíes en el servidor de salto.

6. Seguridad reforzada

sshd_config del servidor

# /etc/ssh/sshd_config
PermitRootLogin no                    # Prohibir inicio de sesión root
PasswordAuthentication no             # Prohibir inicio de sesión con contraseña
PubkeyAuthentication yes             # Solo permitir inicio de sesión con clave
AuthorizedKeysFile .ssh/authorized_keys
MaxAuthTries 3                       # Máximo de intentos
LoginGraceTime 30                    # Tiempo de espera de 30 segundos
AllowUsers deploy admin              # Lista blanca de usuarios

Permisos de claves

# La clave privada debe ser 600
chmod 600 ~/.ssh/id_ed25519

# El directorio .ssh debe ser 700
chmod 700 ~/.ssh

# authorized_keys debe ser 600
chmod 600 ~/.ssh/authorized_keys

Rotación de claves

# 1. Generar nueva clave
ssh-keygen -t ed25519 -C "dev@example.com" -f ~/.ssh/id_ed25519_new

# 2. Desplegar la nueva clave pública en todos los servidores/plataformas Git
ssh-copy-id -i ~/.ssh/id_ed25519_new.pub user@server

# 3. Verificar que la nueva clave funciona
ssh -i ~/.ssh/id_ed25519_new user@server

# 4. Eliminar la clave pública antigua
# Editar servidor ~/.ssh/authorized_keys, borrar la línea de la clave pública antigua

# 5. Eliminar la clave antigua
rm ~/.ssh/id_ed25519_old

7. Solución de problemas comunes

Problema	Causa	Solución
`Permission denied`	Clave pública no desplegada	`ssh-copy-id`
`Too many authentication failures`	Demasiadas claves en el Agent	`IdentitiesOnly yes`
`Are you sure you want to continue connecting`	Primera conexión	`StrictHostKeyChecking=accept-new`
Conexión lenta	Consulta DNS inversa	`UseDNS no` (en el servidor)
Clave no funciona	Permisos incorrectos	`chmod 600` en la clave privada

Modo de depuración

ssh -vvv user@server.com
# Salida detallada del proceso de conexión, localizar la causa del fallo de autenticación